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