[PATCH] orinoco: further comment cleanup in the PCI drivers
[linux-2.6] / drivers / char / ec3104_keyb.c
1 /*
2  * linux/drivers/char/ec3104_keyb.c
3  * 
4  * Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org>
5  *
6  * based on linux/drivers/char/pc_keyb.c, which had the following comments:
7  *
8  * Separation of the PC low-level part by Geert Uytterhoeven, May 1997
9  * See keyboard.c for the whole history.
10  *
11  * Major cleanup by Martin Mares, May 1997
12  *
13  * Combined the keyboard and PS/2 mouse handling into one file,
14  * because they share the same hardware.
15  * Johan Myreen <jem@iki.fi> 1998-10-08.
16  *
17  * Code fixes to handle mouse ACKs properly.
18  * C. Scott Ananian <cananian@alumni.princeton.edu> 1999-01-29.
19  */
20 /* EC3104 note:
21  * This code was written without any documentation about the EC3104 chip.  While
22  * I hope I got most of the basic functionality right, the register names I use
23  * are most likely completely different from those in the chip documentation.
24  *
25  * If you have any further information about the EC3104, please tell me
26  * (prumpf@tux.org).
27  */
28
29 #include <linux/config.h>
30
31 #include <linux/spinlock.h>
32 #include <linux/sched.h>
33 #include <linux/interrupt.h>
34 #include <linux/tty.h>
35 #include <linux/mm.h>
36 #include <linux/signal.h>
37 #include <linux/init.h>
38 #include <linux/kbd_ll.h>
39 #include <linux/delay.h>
40 #include <linux/random.h>
41 #include <linux/poll.h>
42 #include <linux/miscdevice.h>
43 #include <linux/slab.h>
44 #include <linux/kbd_kern.h>
45 #include <linux/smp_lock.h>
46 #include <linux/bitops.h>
47
48 #include <asm/keyboard.h>
49 #include <asm/uaccess.h>
50 #include <asm/irq.h>
51 #include <asm/system.h>
52 #include <asm/ec3104.h>
53
54 #include <asm/io.h>
55
56 /* Some configuration switches are present in the include file... */
57
58 #include <linux/pc_keyb.h>
59
60 #define MSR_CTS 0x10
61 #define MCR_RTS 0x02
62 #define LSR_DR 0x01
63 #define LSR_BOTH_EMPTY 0x60
64
65 static struct e5_struct {
66         u8 packet[8];
67         int pos;
68         int length;
69
70         u8 cached_mcr;
71         u8 last_msr;
72 } ec3104_keyb;
73         
74 /* Simple translation table for the SysRq keys */
75
76
77 #ifdef CONFIG_MAGIC_SYSRQ
78 unsigned char ec3104_kbd_sysrq_xlate[128] =
79         "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
80         "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
81         "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
82         "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
83         "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
84         "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
85         "\r\000/";                                      /* 0x60 - 0x6f */
86 #endif
87
88 static void kbd_write_command_w(int data);
89 static void kbd_write_output_w(int data);
90 #ifdef CONFIG_PSMOUSE
91 static void aux_write_ack(int val);
92 static void __aux_write_ack(int val);
93 #endif
94
95 static DEFINE_SPINLOCK(kbd_controller_lock);
96 static unsigned char handle_kbd_event(void);
97
98 /* used only by send_data - set by keyboard_interrupt */
99 static volatile unsigned char reply_expected;
100 static volatile unsigned char acknowledge;
101 static volatile unsigned char resend;
102
103
104 int ec3104_kbd_setkeycode(unsigned int scancode, unsigned int keycode)
105 {
106         return 0;
107 }
108
109 int ec3104_kbd_getkeycode(unsigned int scancode)
110 {
111         return 0;
112 }
113
114
115 /* yes, it probably would be faster to use an array.  I don't care. */
116
117 static inline unsigned char ec3104_scan2key(unsigned char scancode)
118 {
119         switch (scancode) {
120         case  1: /* '`' */
121                 return 41;
122                 
123         case  2 ... 27:
124                 return scancode;
125                 
126         case 28: /* '\\' */
127                 return 43;
128
129         case 29 ... 39:
130                 return scancode + 1;
131
132         case 40: /* '\r' */
133                 return 28;
134
135         case 41 ... 50:
136                 return scancode + 3;
137
138         case 51: /* ' ' */
139                 return 57;
140                 
141         case 52: /* escape */
142                 return 1;
143
144         case 54: /* insert/delete (labelled delete) */
145                 /* this should arguably be 110, but I'd like to have ctrl-alt-del
146                  * working with a standard keymap */
147                 return 111;
148
149         case 55: /* left */
150                 return 105;
151         case 56: /* home */
152                 return 102;
153         case 57: /* end */
154                 return 107;
155         case 58: /* up */
156                 return 103;
157         case 59: /* down */
158                 return 108;
159         case 60: /* pgup */
160                 return 104;
161         case 61: /* pgdown */
162                 return 109;
163         case 62: /* right */
164                 return 106;
165
166         case 79 ... 88: /* f1 - f10 */
167                 return scancode - 20;
168
169         case 89 ... 90: /* f11 - f12 */
170                 return scancode - 2;
171
172         case 91: /* left shift */
173                 return 42;
174
175         case 92: /* right shift */
176                 return 54;
177
178         case 93: /* left alt */
179                 return 56;
180         case 94: /* right alt */
181                 return 100;
182         case 95: /* left ctrl */
183                 return 29;
184         case 96: /* right ctrl */
185                 return 97;
186
187         case 97: /* caps lock */
188                 return 58;
189         case 102: /* left windows */
190                 return 125;
191         case 103: /* right windows */
192                 return 126;
193
194         case 106: /* Fn */
195                 /* this is wrong. */
196                 return 84;
197
198         default:
199                 return 0;
200         }
201 }
202                 
203 int ec3104_kbd_translate(unsigned char scancode, unsigned char *keycode,
204                     char raw_mode)
205 {
206         scancode &= 0x7f;
207
208         *keycode = ec3104_scan2key(scancode);
209
210         return 1;
211 }
212
213 char ec3104_kbd_unexpected_up(unsigned char keycode)
214 {
215         return 0200;
216 }
217
218 static inline void handle_keyboard_event(unsigned char scancode)
219 {
220 #ifdef CONFIG_VT
221         handle_scancode(scancode, !(scancode & 0x80));
222 #endif                          
223         tasklet_schedule(&keyboard_tasklet);
224 }       
225
226 void ec3104_kbd_leds(unsigned char leds)
227 {
228 }
229
230 static u8 e5_checksum(u8 *packet, int count)
231 {
232         int i;
233         u8 sum = 0;
234
235         for (i=0; i<count; i++)
236                 sum ^= packet[i];
237                 
238         if (sum & 0x80)
239                 sum ^= 0xc0;
240
241         return sum;
242 }
243
244 static void e5_wait_for_cts(struct e5_struct *k)
245 {
246         u8 msr;
247                 
248         do {
249                 msr = ctrl_inb(EC3104_SER4_MSR);
250         } while (!(msr & MSR_CTS));
251 }
252
253
254 static void e5_send_byte(u8 byte, struct e5_struct *k)
255 {
256         u8 status;
257                 
258         do {
259                 status = ctrl_inb(EC3104_SER4_LSR);
260         } while ((status & LSR_BOTH_EMPTY) != LSR_BOTH_EMPTY);
261         
262         printk("<%02x>", byte);
263
264         ctrl_outb(byte, EC3104_SER4_DATA);
265
266         do {
267                 status = ctrl_inb(EC3104_SER4_LSR);
268         } while ((status & LSR_BOTH_EMPTY) != LSR_BOTH_EMPTY);
269         
270 }
271
272 static int e5_send_packet(u8 *packet, int count, struct e5_struct *k)
273 {
274         int i;
275
276         disable_irq(EC3104_IRQ_SER4);
277         
278         if (k->cached_mcr & MCR_RTS) {
279                 printk("e5_send_packet: too slow\n");
280                 enable_irq(EC3104_IRQ_SER4);
281                 return -EAGAIN;
282         }
283
284         k->cached_mcr |= MCR_RTS;
285         ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
286
287         e5_wait_for_cts(k);
288
289         printk("p: ");
290
291         for(i=0; i<count; i++)
292                 e5_send_byte(packet[i], k);
293
294         e5_send_byte(e5_checksum(packet, count), k);
295
296         printk("\n");
297
298         udelay(1500);
299
300         k->cached_mcr &= ~MCR_RTS;
301         ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
302
303         set_current_state(TASK_UNINTERRUPTIBLE);
304         
305         
306
307         enable_irq(EC3104_IRQ_SER4);
308
309         
310
311         return 0;
312 }
313
314 /*
315  * E5 packets we know about:
316  * E5->host 0x80 0x05 <checksum> - resend packet
317  * host->E5 0x83 0x43 <contrast> - set LCD contrast
318  * host->E5 0x85 0x41 0x02 <brightness> 0x02 - set LCD backlight
319  * E5->host 0x87 <ps2 packet> 0x00 <checksum> - external PS2 
320  * E5->host 0x88 <scancode> <checksum> - key press
321  */
322
323 static void e5_receive(struct e5_struct *k)
324 {
325         k->packet[k->pos++] = ctrl_inb(EC3104_SER4_DATA);
326
327         if (k->pos == 1) {
328                 switch(k->packet[0]) {
329                 case 0x80:
330                         k->length = 3;
331                         break;
332                         
333                 case 0x87: /* PS2 ext */
334                         k->length = 6;
335                         break;
336
337                 case 0x88: /* keyboard */
338                         k->length = 3;
339                         break;
340
341                 default:
342                         k->length = 1;
343                         printk(KERN_WARNING "unknown E5 packet %02x\n",
344                                k->packet[0]);
345                 }
346         }
347
348         if (k->pos == k->length) {
349                 int i;
350
351                 if (e5_checksum(k->packet, k->length) != 0)
352                         printk(KERN_WARNING "E5: wrong checksum\n");
353
354 #if 0
355                 printk("E5 packet [");
356                 for(i=0; i<k->length; i++) {
357                         printk("%02x ", k->packet[i]);
358                 }
359
360                 printk("(%02x)]\n", e5_checksum(k->packet, k->length-1));
361 #endif
362
363                 switch(k->packet[0]) {
364                 case 0x80:
365                 case 0x88:
366                         handle_keyboard_event(k->packet[1]);
367                         break;
368                 }
369
370                 k->pos = k->length = 0;
371         }
372 }
373
374 static void ec3104_keyb_interrupt(int irq, void *data, struct pt_regs *regs)
375 {
376         struct e5_struct *k = &ec3104_keyb;
377         u8 msr, lsr;
378
379         msr = ctrl_inb(EC3104_SER4_MSR);
380         
381         if ((msr & MSR_CTS) && !(k->last_msr & MSR_CTS)) {
382                 if (k->cached_mcr & MCR_RTS)
383                         printk("confused: RTS already high\n");
384                 /* CTS went high.  Send RTS. */
385                 k->cached_mcr |= MCR_RTS;
386                 
387                 ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
388         } else if ((!(msr & MSR_CTS)) && (k->last_msr & MSR_CTS)) {
389                 /* CTS went low. */
390                 if (!(k->cached_mcr & MCR_RTS))
391                         printk("confused: RTS already low\n");
392
393                 k->cached_mcr &= ~MCR_RTS;
394
395                 ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
396         }
397
398         k->last_msr = msr;
399
400         lsr = ctrl_inb(EC3104_SER4_LSR);
401
402         if (lsr & LSR_DR)
403                 e5_receive(k);
404 }
405
406 static void ec3104_keyb_clear_state(void)
407 {
408         struct e5_struct *k = &ec3104_keyb;
409         u8 msr, lsr;
410         
411         /* we want CTS to be low */
412         k->last_msr = 0;
413
414         for (;;) {
415                 msleep(100);
416
417                 msr = ctrl_inb(EC3104_SER4_MSR);
418         
419                 lsr = ctrl_inb(EC3104_SER4_LSR);
420                 
421                 if (lsr & LSR_DR) {
422                         e5_receive(k);
423                         continue;
424                 }
425
426                 if ((msr & MSR_CTS) && !(k->last_msr & MSR_CTS)) {
427                         if (k->cached_mcr & MCR_RTS)
428                                 printk("confused: RTS already high\n");
429                         /* CTS went high.  Send RTS. */
430                         k->cached_mcr |= MCR_RTS;
431                 
432                         ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
433                 } else if ((!(msr & MSR_CTS)) && (k->last_msr & MSR_CTS)) {
434                         /* CTS went low. */
435                         if (!(k->cached_mcr & MCR_RTS))
436                                 printk("confused: RTS already low\n");
437                         
438                         k->cached_mcr &= ~MCR_RTS;
439                         
440                         ctrl_outb(k->cached_mcr, EC3104_SER4_MCR);
441                 } else
442                         break;
443
444                 k->last_msr = msr;
445
446                 continue;
447         }
448 }
449
450 void __init ec3104_kbd_init_hw(void)
451 {
452         ec3104_keyb.last_msr = ctrl_inb(EC3104_SER4_MSR);
453         ec3104_keyb.cached_mcr = ctrl_inb(EC3104_SER4_MCR);
454
455         ec3104_keyb_clear_state();
456
457         /* Ok, finally allocate the IRQ, and off we go.. */
458         request_irq(EC3104_IRQ_SER4, ec3104_keyb_interrupt, 0, "keyboard", NULL);
459 }