URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [keyboard/] [atakbd.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 *  atakbd.c
 *
 *  Copyright (c) 2005 Michael Schmitz
 *
 * Based on amikbd.c, which is
 *
 *  Copyright (c) 2000-2001 Vojtech Pavlik
 *
 *  Based on the work of:
 *      Hamish Macdonald
 */
 
/*
 * Atari keyboard driver for Linux/m68k
 *
 * The low level init and interrupt stuff is handled in arch/mm68k/atari/atakeyb.c
 * (the keyboard ACIA also handles the mouse and joystick data, and the keyboard
 * interrupt is shared with the MIDI ACIA so MIDI data also get handled there).
 * This driver only deals with handing key events off to the input layer.
 */
 
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Should you need to contact me, the author, you can do so either by
 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
 */
 
#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
 
#include <asm/atariints.h>
#include <asm/atarihw.h>
#include <asm/atarikb.h>
#include <asm/irq.h>
 
MODULE_AUTHOR("Michael Schmitz <schmitz@biophys.uni-duesseldorf.de>");
MODULE_DESCRIPTION("Atari keyboard driver");
MODULE_LICENSE("GPL");
 
/*
 0x47: KP_7     71
 0x48: KP_8     72
 0x49: KP_9     73
 0x62: KP_/     98
 0x4b: KP_4     75
 0x4c: KP_5     76
 0x4d: KP_6     77
 0x37: KP_*     55
 0x4f: KP_1     79
 0x50: KP_2     80
 0x51: KP_3     81
 0x4a: KP_-     74
 0x52: KP_0     82
 0x53: KP_.     83
 0x4e: KP_+     78
 
 0x67: Up       103
 0x6c: Down     108
 0x69: Left     105
 0x6a: Right    106
 */
 
 
static unsigned char atakbd_keycode[0x72] = {   /* American layout */
        [0]       = KEY_GRAVE,
        [1]      = KEY_ESC,
        [2]      = KEY_1,
        [3]      = KEY_2,
        [4]      = KEY_3,
        [5]      = KEY_4,
        [6]      = KEY_5,
        [7]      = KEY_6,
        [8]      = KEY_7,
        [9]      = KEY_8,
        [10]     = KEY_9,
        [11]     = KEY_0,
        [12]     = KEY_MINUS,
        [13]     = KEY_EQUAL,
        [14]     = KEY_BACKSPACE,
        [15]     = KEY_TAB,
        [16]     = KEY_Q,
        [17]     = KEY_W,
        [18]     = KEY_E,
        [19]     = KEY_R,
        [20]     = KEY_T,
        [21]     = KEY_Y,
        [22]     = KEY_U,
        [23]     = KEY_I,
        [24]     = KEY_O,
        [25]     = KEY_P,
        [26]     = KEY_LEFTBRACE,
        [27]     = KEY_RIGHTBRACE,
        [28]     = KEY_ENTER,
        [29]     = KEY_LEFTCTRL,
        [30]     = KEY_A,
        [31]     = KEY_S,
        [32]     = KEY_D,
        [33]     = KEY_F,
        [34]     = KEY_G,
        [35]     = KEY_H,
        [36]     = KEY_J,
        [37]     = KEY_K,
        [38]     = KEY_L,
        [39]     = KEY_SEMICOLON,
        [40]     = KEY_APOSTROPHE,
        [41]     = KEY_BACKSLASH,       /* FIXME, '#' */
        [42]     = KEY_LEFTSHIFT,
        [43]     = KEY_GRAVE,           /* FIXME: '~' */
        [44]     = KEY_Z,
        [45]     = KEY_X,
        [46]     = KEY_C,
        [47]     = KEY_V,
        [48]     = KEY_B,
        [49]     = KEY_N,
        [50]     = KEY_M,
        [51]     = KEY_COMMA,
        [52]     = KEY_DOT,
        [53]     = KEY_SLASH,
        [54]     = KEY_RIGHTSHIFT,
        [55]     = KEY_KPASTERISK,
        [56]     = KEY_LEFTALT,
        [57]     = KEY_SPACE,
        [58]     = KEY_CAPSLOCK,
        [59]     = KEY_F1,
        [60]     = KEY_F2,
        [61]     = KEY_F3,
        [62]     = KEY_F4,
        [63]     = KEY_F5,
        [64]     = KEY_F6,
        [65]     = KEY_F7,
        [66]     = KEY_F8,
        [67]     = KEY_F9,
        [68]     = KEY_F10,
        [69]     = KEY_ESC,
        [70]     = KEY_DELETE,
        [71]     = KEY_KP7,
        [72]     = KEY_KP8,
        [73]     = KEY_KP9,
        [74]     = KEY_KPMINUS,
        [75]     = KEY_KP4,
        [76]     = KEY_KP5,
        [77]     = KEY_KP6,
        [78]     = KEY_KPPLUS,
        [79]     = KEY_KP1,
        [80]     = KEY_KP2,
        [81]     = KEY_KP3,
        [82]     = KEY_KP0,
        [83]     = KEY_KPDOT,
        [90]     = KEY_KPLEFTPAREN,
        [91]     = KEY_KPRIGHTPAREN,
        [92]     = KEY_KPASTERISK,      /* FIXME */
        [93]     = KEY_KPASTERISK,
        [94]     = KEY_KPPLUS,
        [95]     = KEY_HELP,
        [96]     = KEY_BACKSLASH,       /* FIXME: '<' */
        [97]     = KEY_KPASTERISK,      /* FIXME */
        [98]     = KEY_KPSLASH,
        [99]     = KEY_KPLEFTPAREN,
        [100]    = KEY_KPRIGHTPAREN,
        [101]    = KEY_KPSLASH,
        [102]    = KEY_KPASTERISK,
        [103]    = KEY_UP,
        [104]    = KEY_KPASTERISK,      /* FIXME */
        [105]    = KEY_LEFT,
        [106]    = KEY_RIGHT,
        [107]    = KEY_KPASTERISK,      /* FIXME */
        [108]    = KEY_DOWN,
        [109]    = KEY_KPASTERISK,      /* FIXME */
        [110]    = KEY_KPASTERISK,      /* FIXME */
        [111]    = KEY_KPASTERISK,      /* FIXME */
        [112]    = KEY_KPASTERISK,      /* FIXME */
        [113]    = KEY_KPASTERISK       /* FIXME */
};
 
static struct input_dev *atakbd_dev;
 
static void atakbd_interrupt(unsigned char scancode, char down)
{
 
        if (scancode < 0x72) {          /* scancodes < 0xf2 are keys */
 
                // report raw events here?
 
                scancode = atakbd_keycode[scancode];
 
                if (scancode == KEY_CAPSLOCK) { /* CapsLock is a toggle switch key on Amiga */
                        input_report_key(atakbd_dev, scancode, 1);
                        input_report_key(atakbd_dev, scancode, 0);
                        input_sync(atakbd_dev);
                } else {
                        input_report_key(atakbd_dev, scancode, down);
                        input_sync(atakbd_dev);
                }
        } else                          /* scancodes >= 0xf2 are mouse data, most likely */
                printk(KERN_INFO "atakbd: unhandled scancode %x\n", scancode);
 
        return;
}
 
static int __init atakbd_init(void)
{
        int i, error;
 
        if (!MACH_IS_ATARI || !ATARIHW_PRESENT(ST_MFP))
                return -EIO;
 
        // need to init core driver if not already done so
        if (atari_keyb_init())
                return -ENODEV;
 
        atakbd_dev = input_allocate_device();
        if (!atakbd_dev)
                return -ENOMEM;
 
        atakbd_dev->name = "Atari Keyboard";
        atakbd_dev->phys = "atakbd/input0";
        atakbd_dev->id.bustype = BUS_HOST;
        atakbd_dev->id.vendor = 0x0001;
        atakbd_dev->id.product = 0x0001;
        atakbd_dev->id.version = 0x0100;
 
        atakbd_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
        atakbd_dev->keycode = atakbd_keycode;
        atakbd_dev->keycodesize = sizeof(unsigned char);
        atakbd_dev->keycodemax = ARRAY_SIZE(atakbd_keycode);
 
        for (i = 1; i < 0x72; i++) {
                set_bit(atakbd_keycode[i], atakbd_dev->keybit);
        }
 
        /* error check */
        error = input_register_device(atakbd_dev);
        if (error) {
                input_free_device(atakbd_dev);
                return error;
        }
 
        atari_input_keyboard_interrupt_hook = atakbd_interrupt;
 
        return 0;
}
 
static void __exit atakbd_exit(void)
{
        atari_input_keyboard_interrupt_hook = NULL;
        input_unregister_device(atakbd_dev);
}
 
module_init(atakbd_init);
module_exit(atakbd_exit);

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [keyboard/] [atakbd.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* atakbd.c`
3			`*`
4			`* Copyright (c) 2005 Michael Schmitz`
5			`*`
6			`* Based on amikbd.c, which is`
7			`*`
8			`* Copyright (c) 2000-2001 Vojtech Pavlik`
9			`*`
10			`* Based on the work of:`
11			`* Hamish Macdonald`
12			`*/`
13
14			`/*`
15			`* Atari keyboard driver for Linux/m68k`
16			`*`
17			`* The low level init and interrupt stuff is handled in arch/mm68k/atari/atakeyb.c`
18			`* (the keyboard ACIA also handles the mouse and joystick data, and the keyboard`
19			`* interrupt is shared with the MIDI ACIA so MIDI data also get handled there).`
20			`* This driver only deals with handing key events off to the input layer.`
21			`*/`
22
23			`/*`
24			`* This program is free software; you can redistribute it and/or modify`
25			`* it under the terms of the GNU General Public License as published by`
26			`* the Free Software Foundation; either version 2 of the License, or`
27			`* (at your option) any later version.`
28			`*`
29			`* This program is distributed in the hope that it will be useful,`
30			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
31			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
32			`* GNU General Public License for more details.`
33			`*`
34			`* You should have received a copy of the GNU General Public License`
35			`* along with this program; if not, write to the Free Software`
36			`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`
37			`*`
38			`* Should you need to contact me, the author, you can do so either by`
39			`* e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:`
40			`* Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic`
41			`*/`
42
43			`#include <linux/module.h>`
44			`#include <linux/init.h>`
45			`#include <linux/input.h>`
46			`#include <linux/delay.h>`
47			`#include <linux/interrupt.h>`
48
49			`#include <asm/atariints.h>`
50			`#include <asm/atarihw.h>`
51			`#include <asm/atarikb.h>`
52			`#include <asm/irq.h>`
53
54			`MODULE_AUTHOR("Michael Schmitz <schmitz@biophys.uni-duesseldorf.de>");`
55			`MODULE_DESCRIPTION("Atari keyboard driver");`
56			`MODULE_LICENSE("GPL");`
57
58			`/*`
59			`0x47: KP_7 71`
60			`0x48: KP_8 72`
61			`0x49: KP_9 73`
62			`0x62: KP_/ 98`
63			`0x4b: KP_4 75`
64			`0x4c: KP_5 76`
65			`0x4d: KP_6 77`
66			`0x37: KP_* 55`
67			`0x4f: KP_1 79`
68			`0x50: KP_2 80`
69			`0x51: KP_3 81`
70			`0x4a: KP_- 74`
71			`0x52: KP_0 82`
72			`0x53: KP_. 83`
73			`0x4e: KP_+ 78`
74
75			`0x67: Up 103`
76			`0x6c: Down 108`
77			`0x69: Left 105`
78			`0x6a: Right 106`
79			`*/`
80
81
82			`static unsigned char atakbd_keycode[0x72] = { /* American layout */`
83			`[0] = KEY_GRAVE,`
84			`[1] = KEY_ESC,`
85			`[2] = KEY_1,`
86			`[3] = KEY_2,`
87			`[4] = KEY_3,`
88			`[5] = KEY_4,`
89			`[6] = KEY_5,`
90			`[7] = KEY_6,`
91			`[8] = KEY_7,`
92			`[9] = KEY_8,`
93			`[10] = KEY_9,`
94			`[11] = KEY_0,`
95			`[12] = KEY_MINUS,`
96			`[13] = KEY_EQUAL,`
97			`[14] = KEY_BACKSPACE,`
98			`[15] = KEY_TAB,`
99			`[16] = KEY_Q,`
100			`[17] = KEY_W,`
101			`[18] = KEY_E,`
102			`[19] = KEY_R,`
103			`[20] = KEY_T,`
104			`[21] = KEY_Y,`
105			`[22] = KEY_U,`
106			`[23] = KEY_I,`
107			`[24] = KEY_O,`
108			`[25] = KEY_P,`
109			`[26] = KEY_LEFTBRACE,`
110			`[27] = KEY_RIGHTBRACE,`
111			`[28] = KEY_ENTER,`
112			`[29] = KEY_LEFTCTRL,`
113			`[30] = KEY_A,`
114			`[31] = KEY_S,`
115			`[32] = KEY_D,`
116			`[33] = KEY_F,`
117			`[34] = KEY_G,`
118			`[35] = KEY_H,`
119			`[36] = KEY_J,`
120			`[37] = KEY_K,`
121			`[38] = KEY_L,`
122			`[39] = KEY_SEMICOLON,`
123			`[40] = KEY_APOSTROPHE,`
124			`[41] = KEY_BACKSLASH, /* FIXME, '#' */`
125			`[42] = KEY_LEFTSHIFT,`
126			`[43] = KEY_GRAVE, /* FIXME: '~' */`
127			`[44] = KEY_Z,`
128			`[45] = KEY_X,`
129			`[46] = KEY_C,`
130			`[47] = KEY_V,`
131			`[48] = KEY_B,`
132			`[49] = KEY_N,`
133			`[50] = KEY_M,`
134			`[51] = KEY_COMMA,`
135			`[52] = KEY_DOT,`
136			`[53] = KEY_SLASH,`
137			`[54] = KEY_RIGHTSHIFT,`
138			`[55] = KEY_KPASTERISK,`
139			`[56] = KEY_LEFTALT,`
140			`[57] = KEY_SPACE,`
141			`[58] = KEY_CAPSLOCK,`
142			`[59] = KEY_F1,`
143			`[60] = KEY_F2,`
144			`[61] = KEY_F3,`
145			`[62] = KEY_F4,`
146			`[63] = KEY_F5,`
147			`[64] = KEY_F6,`
148			`[65] = KEY_F7,`
149			`[66] = KEY_F8,`
150			`[67] = KEY_F9,`
151			`[68] = KEY_F10,`
152			`[69] = KEY_ESC,`
153			`[70] = KEY_DELETE,`
154			`[71] = KEY_KP7,`
155			`[72] = KEY_KP8,`
156			`[73] = KEY_KP9,`
157			`[74] = KEY_KPMINUS,`
158			`[75] = KEY_KP4,`
159			`[76] = KEY_KP5,`
160			`[77] = KEY_KP6,`
161			`[78] = KEY_KPPLUS,`
162			`[79] = KEY_KP1,`
163			`[80] = KEY_KP2,`
164			`[81] = KEY_KP3,`
165			`[82] = KEY_KP0,`
166			`[83] = KEY_KPDOT,`
167			`[90] = KEY_KPLEFTPAREN,`
168			`[91] = KEY_KPRIGHTPAREN,`
169			`[92] = KEY_KPASTERISK, /* FIXME */`
170			`[93] = KEY_KPASTERISK,`
171			`[94] = KEY_KPPLUS,`
172			`[95] = KEY_HELP,`
173			`[96] = KEY_BACKSLASH, /* FIXME: '<' */`
174			`[97] = KEY_KPASTERISK, /* FIXME */`
175			`[98] = KEY_KPSLASH,`
176			`[99] = KEY_KPLEFTPAREN,`
177			`[100] = KEY_KPRIGHTPAREN,`
178			`[101] = KEY_KPSLASH,`
179			`[102] = KEY_KPASTERISK,`
180			`[103] = KEY_UP,`
181			`[104] = KEY_KPASTERISK, /* FIXME */`
182			`[105] = KEY_LEFT,`
183			`[106] = KEY_RIGHT,`
184			`[107] = KEY_KPASTERISK, /* FIXME */`
185			`[108] = KEY_DOWN,`
186			`[109] = KEY_KPASTERISK, /* FIXME */`
187			`[110] = KEY_KPASTERISK, /* FIXME */`
188			`[111] = KEY_KPASTERISK, /* FIXME */`
189			`[112] = KEY_KPASTERISK, /* FIXME */`
190			`[113] = KEY_KPASTERISK /* FIXME */`
191			`};`
192
193			`static struct input_dev *atakbd_dev;`
194
195			`static void atakbd_interrupt(unsigned char scancode, char down)`
196			`{`
197
198			`if (scancode < 0x72) { /* scancodes < 0xf2 are keys */`
199
200			`// report raw events here?`
201
202			`scancode = atakbd_keycode[scancode];`
203
204			`if (scancode == KEY_CAPSLOCK) { /* CapsLock is a toggle switch key on Amiga */`
205			`input_report_key(atakbd_dev, scancode, 1);`
206			`input_report_key(atakbd_dev, scancode, 0);`
207			`input_sync(atakbd_dev);`
208			`} else {`
209			`input_report_key(atakbd_dev, scancode, down);`
210			`input_sync(atakbd_dev);`
211			`}`
212			`} else /* scancodes >= 0xf2 are mouse data, most likely */`
213			`printk(KERN_INFO "atakbd: unhandled scancode %x\n", scancode);`
214
215			`return;`
216			`}`
217
218			`static int __init atakbd_init(void)`
219			`{`
220			`int i, error;`
221
222			`if (!MACH_IS_ATARI \|\| !ATARIHW_PRESENT(ST_MFP))`
223			`return -EIO;`
224
225			`// need to init core driver if not already done so`
226			`if (atari_keyb_init())`
227			`return -ENODEV;`
228
229			`atakbd_dev = input_allocate_device();`
230			`if (!atakbd_dev)`
231			`return -ENOMEM;`
232
233			`atakbd_dev->name = "Atari Keyboard";`
234			`atakbd_dev->phys = "atakbd/input0";`
235			`atakbd_dev->id.bustype = BUS_HOST;`
236			`atakbd_dev->id.vendor = 0x0001;`
237			`atakbd_dev->id.product = 0x0001;`
238			`atakbd_dev->id.version = 0x0100;`
239
240			`atakbd_dev->evbit[0] = BIT_MASK(EV_KEY) \| BIT_MASK(EV_REP);`
241			`atakbd_dev->keycode = atakbd_keycode;`
242			`atakbd_dev->keycodesize = sizeof(unsigned char);`
243			`atakbd_dev->keycodemax = ARRAY_SIZE(atakbd_keycode);`
244
245			`for (i = 1; i < 0x72; i++) {`
246			`set_bit(atakbd_keycode[i], atakbd_dev->keybit);`
247			`}`
248
249			`/* error check */`
250			`error = input_register_device(atakbd_dev);`
251			`if (error) {`
252			`input_free_device(atakbd_dev);`
253			`return error;`
254			`}`
255
256			`atari_input_keyboard_interrupt_hook = atakbd_interrupt;`
257
258			`return 0;`
259			`}`
260
261			`static void __exit atakbd_exit(void)`
262			`{`
263			`atari_input_keyboard_interrupt_hook = NULL;`
264			`input_unregister_device(atakbd_dev);`
265			`}`
266
267			`module_init(atakbd_init);`
268			`module_exit(atakbd_exit);`