Merge branch 'x86/core' into x86/xsave
[linux-2.6] / drivers / input / keyboard / sunkbd.c
1 /*
2  *  Copyright (c) 1999-2001 Vojtech Pavlik
3  */
4
5 /*
6  * Sun keyboard driver for Linux
7  */
8
9 /*
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23  *
24  * Should you need to contact me, the author, you can do so either by
25  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
26  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
27  */
28
29 #include <linux/delay.h>
30 #include <linux/slab.h>
31 #include <linux/module.h>
32 #include <linux/interrupt.h>
33 #include <linux/init.h>
34 #include <linux/input.h>
35 #include <linux/serio.h>
36 #include <linux/workqueue.h>
37
38 #define DRIVER_DESC     "Sun keyboard driver"
39
40 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
41 MODULE_DESCRIPTION(DRIVER_DESC);
42 MODULE_LICENSE("GPL");
43
44 static unsigned char sunkbd_keycode[128] = {
45           0,128,114,129,115, 59, 60, 68, 61, 87, 62, 88, 63,100, 64,112,
46          65, 66, 67, 56,103,119, 99, 70,105,130,131,108,106,  1,  2,  3,
47           4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 41, 14,110,113, 98, 55,
48         116,132, 83,133,102, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
49          26, 27,111,127, 71, 72, 73, 74,134,135,107,  0, 29, 30, 31, 32,
50          33, 34, 35, 36, 37, 38, 39, 40, 43, 28, 96, 75, 76, 77, 82,136,
51         104,137, 69, 42, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,101,
52          79, 80, 81,  0,  0,  0,138, 58,125, 57,126,109, 86, 78
53 };
54
55 #define SUNKBD_CMD_RESET        0x1
56 #define SUNKBD_CMD_BELLON       0x2
57 #define SUNKBD_CMD_BELLOFF      0x3
58 #define SUNKBD_CMD_CLICK        0xa
59 #define SUNKBD_CMD_NOCLICK      0xb
60 #define SUNKBD_CMD_SETLED       0xe
61 #define SUNKBD_CMD_LAYOUT       0xf
62
63 #define SUNKBD_RET_RESET        0xff
64 #define SUNKBD_RET_ALLUP        0x7f
65 #define SUNKBD_RET_LAYOUT       0xfe
66
67 #define SUNKBD_LAYOUT_5_MASK    0x20
68 #define SUNKBD_RELEASE          0x80
69 #define SUNKBD_KEY              0x7f
70
71 /*
72  * Per-keyboard data.
73  */
74
75 struct sunkbd {
76         unsigned char keycode[128];
77         struct input_dev *dev;
78         struct serio *serio;
79         struct work_struct tq;
80         wait_queue_head_t wait;
81         char name[64];
82         char phys[32];
83         char type;
84         unsigned char enabled;
85         volatile s8 reset;
86         volatile s8 layout;
87 };
88
89 /*
90  * sunkbd_interrupt() is called by the low level driver when a character
91  * is received.
92  */
93
94 static irqreturn_t sunkbd_interrupt(struct serio *serio,
95                 unsigned char data, unsigned int flags)
96 {
97         struct sunkbd* sunkbd = serio_get_drvdata(serio);
98
99         if (sunkbd->reset <= -1) {              /* If cp[i] is 0xff, sunkbd->reset will stay -1. */
100                 sunkbd->reset = data;           /* The keyboard sends 0xff 0xff 0xID on powerup */
101                 wake_up_interruptible(&sunkbd->wait);
102                 goto out;
103         }
104
105         if (sunkbd->layout == -1) {
106                 sunkbd->layout = data;
107                 wake_up_interruptible(&sunkbd->wait);
108                 goto out;
109         }
110
111         switch (data) {
112
113                 case SUNKBD_RET_RESET:
114                         schedule_work(&sunkbd->tq);
115                         sunkbd->reset = -1;
116                         break;
117
118                 case SUNKBD_RET_LAYOUT:
119                         sunkbd->layout = -1;
120                         break;
121
122                 case SUNKBD_RET_ALLUP: /* All keys released */
123                         break;
124
125                 default:
126                         if (!sunkbd->enabled)
127                                 break;
128
129                         if (sunkbd->keycode[data & SUNKBD_KEY]) {
130                                 input_report_key(sunkbd->dev, sunkbd->keycode[data & SUNKBD_KEY], !(data & SUNKBD_RELEASE));
131                                 input_sync(sunkbd->dev);
132                         } else {
133                                 printk(KERN_WARNING "sunkbd.c: Unknown key (scancode %#x) %s.\n",
134                                         data & SUNKBD_KEY, data & SUNKBD_RELEASE ? "released" : "pressed");
135                         }
136         }
137 out:
138         return IRQ_HANDLED;
139 }
140
141 /*
142  * sunkbd_event() handles events from the input module.
143  */
144
145 static int sunkbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
146 {
147         struct sunkbd *sunkbd = input_get_drvdata(dev);
148
149         switch (type) {
150
151                 case EV_LED:
152
153                         sunkbd->serio->write(sunkbd->serio, SUNKBD_CMD_SETLED);
154                         sunkbd->serio->write(sunkbd->serio,
155                                 (!!test_bit(LED_CAPSL, dev->led) << 3) | (!!test_bit(LED_SCROLLL, dev->led) << 2) |
156                                 (!!test_bit(LED_COMPOSE, dev->led) << 1) | !!test_bit(LED_NUML, dev->led));
157                         return 0;
158
159                 case EV_SND:
160
161                         switch (code) {
162
163                                 case SND_CLICK:
164                                         sunkbd->serio->write(sunkbd->serio, SUNKBD_CMD_NOCLICK - value);
165                                         return 0;
166
167                                 case SND_BELL:
168                                         sunkbd->serio->write(sunkbd->serio, SUNKBD_CMD_BELLOFF - value);
169                                         return 0;
170                         }
171
172                         break;
173         }
174
175         return -1;
176 }
177
178 /*
179  * sunkbd_initialize() checks for a Sun keyboard attached, and determines
180  * its type.
181  */
182
183 static int sunkbd_initialize(struct sunkbd *sunkbd)
184 {
185         sunkbd->reset = -2;
186         sunkbd->serio->write(sunkbd->serio, SUNKBD_CMD_RESET);
187         wait_event_interruptible_timeout(sunkbd->wait, sunkbd->reset >= 0, HZ);
188         if (sunkbd->reset < 0)
189                 return -1;
190
191         sunkbd->type = sunkbd->reset;
192
193         if (sunkbd->type == 4) {        /* Type 4 keyboard */
194                 sunkbd->layout = -2;
195                 sunkbd->serio->write(sunkbd->serio, SUNKBD_CMD_LAYOUT);
196                 wait_event_interruptible_timeout(sunkbd->wait, sunkbd->layout >= 0, HZ/4);
197                 if (sunkbd->layout < 0) return -1;
198                 if (sunkbd->layout & SUNKBD_LAYOUT_5_MASK) sunkbd->type = 5;
199         }
200
201         return 0;
202 }
203
204 /*
205  * sunkbd_reinit() sets leds and beeps to a state the computer remembers they
206  * were in.
207  */
208
209 static void sunkbd_reinit(struct work_struct *work)
210 {
211         struct sunkbd *sunkbd = container_of(work, struct sunkbd, tq);
212
213         wait_event_interruptible_timeout(sunkbd->wait, sunkbd->reset >= 0, HZ);
214
215         sunkbd->serio->write(sunkbd->serio, SUNKBD_CMD_SETLED);
216         sunkbd->serio->write(sunkbd->serio,
217                 (!!test_bit(LED_CAPSL, sunkbd->dev->led) << 3) | (!!test_bit(LED_SCROLLL, sunkbd->dev->led) << 2) |
218                 (!!test_bit(LED_COMPOSE, sunkbd->dev->led) << 1) | !!test_bit(LED_NUML, sunkbd->dev->led));
219         sunkbd->serio->write(sunkbd->serio, SUNKBD_CMD_NOCLICK - !!test_bit(SND_CLICK, sunkbd->dev->snd));
220         sunkbd->serio->write(sunkbd->serio, SUNKBD_CMD_BELLOFF - !!test_bit(SND_BELL, sunkbd->dev->snd));
221 }
222
223 static void sunkbd_enable(struct sunkbd *sunkbd, int enable)
224 {
225         serio_pause_rx(sunkbd->serio);
226         sunkbd->enabled = enable;
227         serio_continue_rx(sunkbd->serio);
228 }
229
230 /*
231  * sunkbd_connect() probes for a Sun keyboard and fills the necessary structures.
232  */
233
234 static int sunkbd_connect(struct serio *serio, struct serio_driver *drv)
235 {
236         struct sunkbd *sunkbd;
237         struct input_dev *input_dev;
238         int err = -ENOMEM;
239         int i;
240
241         sunkbd = kzalloc(sizeof(struct sunkbd), GFP_KERNEL);
242         input_dev = input_allocate_device();
243         if (!sunkbd || !input_dev)
244                 goto fail1;
245
246         sunkbd->serio = serio;
247         sunkbd->dev = input_dev;
248         init_waitqueue_head(&sunkbd->wait);
249         INIT_WORK(&sunkbd->tq, sunkbd_reinit);
250         snprintf(sunkbd->phys, sizeof(sunkbd->phys), "%s/input0", serio->phys);
251
252         serio_set_drvdata(serio, sunkbd);
253
254         err = serio_open(serio, drv);
255         if (err)
256                 goto fail2;
257
258         if (sunkbd_initialize(sunkbd) < 0) {
259                 err = -ENODEV;
260                 goto fail3;
261         }
262
263         snprintf(sunkbd->name, sizeof(sunkbd->name), "Sun Type %d keyboard", sunkbd->type);
264         memcpy(sunkbd->keycode, sunkbd_keycode, sizeof(sunkbd->keycode));
265
266         input_dev->name = sunkbd->name;
267         input_dev->phys = sunkbd->phys;
268         input_dev->id.bustype = BUS_RS232;
269         input_dev->id.vendor  = SERIO_SUNKBD;
270         input_dev->id.product = sunkbd->type;
271         input_dev->id.version = 0x0100;
272         input_dev->dev.parent = &serio->dev;
273
274         input_set_drvdata(input_dev, sunkbd);
275
276         input_dev->event = sunkbd_event;
277
278         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) |
279                 BIT_MASK(EV_SND) | BIT_MASK(EV_REP);
280         input_dev->ledbit[0] = BIT_MASK(LED_CAPSL) | BIT_MASK(LED_COMPOSE) |
281                 BIT_MASK(LED_SCROLLL) | BIT_MASK(LED_NUML);
282         input_dev->sndbit[0] = BIT_MASK(SND_CLICK) | BIT_MASK(SND_BELL);
283
284         input_dev->keycode = sunkbd->keycode;
285         input_dev->keycodesize = sizeof(unsigned char);
286         input_dev->keycodemax = ARRAY_SIZE(sunkbd_keycode);
287         for (i = 0; i < 128; i++)
288                 set_bit(sunkbd->keycode[i], input_dev->keybit);
289         clear_bit(0, input_dev->keybit);
290
291         sunkbd_enable(sunkbd, 1);
292
293         err = input_register_device(sunkbd->dev);
294         if (err)
295                 goto fail4;
296
297         return 0;
298
299  fail4: sunkbd_enable(sunkbd, 0);
300  fail3: serio_close(serio);
301  fail2: serio_set_drvdata(serio, NULL);
302  fail1: input_free_device(input_dev);
303         kfree(sunkbd);
304         return err;
305 }
306
307 /*
308  * sunkbd_disconnect() unregisters and closes behind us.
309  */
310
311 static void sunkbd_disconnect(struct serio *serio)
312 {
313         struct sunkbd *sunkbd = serio_get_drvdata(serio);
314
315         sunkbd_enable(sunkbd, 0);
316         input_unregister_device(sunkbd->dev);
317         serio_close(serio);
318         serio_set_drvdata(serio, NULL);
319         kfree(sunkbd);
320 }
321
322 static struct serio_device_id sunkbd_serio_ids[] = {
323         {
324                 .type   = SERIO_RS232,
325                 .proto  = SERIO_SUNKBD,
326                 .id     = SERIO_ANY,
327                 .extra  = SERIO_ANY,
328         },
329         {
330                 .type   = SERIO_RS232,
331                 .proto  = SERIO_UNKNOWN, /* sunkbd does probe */
332                 .id     = SERIO_ANY,
333                 .extra  = SERIO_ANY,
334         },
335         { 0 }
336 };
337
338 MODULE_DEVICE_TABLE(serio, sunkbd_serio_ids);
339
340 static struct serio_driver sunkbd_drv = {
341         .driver         = {
342                 .name   = "sunkbd",
343         },
344         .description    = DRIVER_DESC,
345         .id_table       = sunkbd_serio_ids,
346         .interrupt      = sunkbd_interrupt,
347         .connect        = sunkbd_connect,
348         .disconnect     = sunkbd_disconnect,
349 };
350
351 /*
352  * The functions for insering/removing us as a module.
353  */
354
355 static int __init sunkbd_init(void)
356 {
357         return serio_register_driver(&sunkbd_drv);
358 }
359
360 static void __exit sunkbd_exit(void)
361 {
362         serio_unregister_driver(&sunkbd_drv);
363 }
364
365 module_init(sunkbd_init);
366 module_exit(sunkbd_exit);