License cleanup: remove unintended "All Rights Reserved" notices.
[platform/kernel/u-boot.git] / drivers / input / ps2mult.c
1 /***********************************************************************
2  *
3  * (C) Copyright 2004
4  * DENX Software Engineering
5  * Wolfgang Denk, wd@denx.de
6  *
7  * PS/2 multiplexer driver
8  *
9  * Originally from linux source (drivers/char/ps2mult.c)
10  *
11  * Uses simple serial driver (ps2ser.c) to access the multiplexer
12  * Used by PS/2 keyboard driver (pc_keyb.c)
13  *
14  ***********************************************************************/
15
16 #include <common.h>
17
18 #include <pc_keyb.h>
19 #include <asm/atomic.h>
20 #include <ps2mult.h>
21
22 /* #define DEBUG_MULT */
23 /* #define DEBUG_KEYB */
24
25 #define KBD_STAT_DEFAULT                (KBD_STAT_SELFTEST | KBD_STAT_UNLOCKED)
26
27 #define PRINTF(format, args...)         printf("ps2mult.c: " format, ## args)
28
29 #ifdef DEBUG_MULT
30 #define PRINTF_MULT(format, args...)    printf("PS2MULT: " format, ## args)
31 #else
32 #define PRINTF_MULT(format, args...)
33 #endif
34
35 #ifdef DEBUG_KEYB
36 #define PRINTF_KEYB(format, args...)    printf("KEYB: " format, ## args)
37 #else
38 #define PRINTF_KEYB(format, args...)
39 #endif
40
41
42 static ulong start_time;
43 static int init_done = 0;
44
45 static int received_escape = 0;
46 static int received_bsync = 0;
47 static int received_selector = 0;
48
49 static int kbd_command_active = 0;
50 static int mouse_command_active = 0;
51 static int ctl_command_active = 0;
52
53 static u_char command_byte = 0;
54
55 static void (*keyb_handler)(void *dev_id);
56
57 static u_char ps2mult_buf [PS2BUF_SIZE];
58 static atomic_t ps2mult_buf_cnt;
59 static int ps2mult_buf_in_idx;
60 static int ps2mult_buf_out_idx;
61
62 static u_char ps2mult_buf_status [PS2BUF_SIZE];
63
64 #ifndef CONFIG_BOARD_EARLY_INIT_R
65 #error #define CONFIG_BOARD_EARLY_INIT_R and call ps2mult_early_init() in board_early_init_r()
66 #endif
67 void ps2mult_early_init (void)
68 {
69         start_time = get_timer(0);
70 }
71
72 static void ps2mult_send_byte(u_char byte, u_char sel)
73 {
74         ps2ser_putc(sel);
75
76         if (sel == PS2MULT_KB_SELECTOR) {
77                 PRINTF_MULT("0x%02x send KEYBOARD\n", byte);
78                 kbd_command_active = 1;
79         } else {
80                 PRINTF_MULT("0x%02x send MOUSE\n", byte);
81                 mouse_command_active = 1;
82         }
83
84         switch (byte) {
85         case PS2MULT_ESCAPE:
86         case PS2MULT_BSYNC:
87         case PS2MULT_KB_SELECTOR:
88         case PS2MULT_MS_SELECTOR:
89         case PS2MULT_SESSION_START:
90         case PS2MULT_SESSION_END:
91                 ps2ser_putc(PS2MULT_ESCAPE);
92                 break;
93         default:
94                 break;
95         }
96
97         ps2ser_putc(byte);
98 }
99
100 static void ps2mult_receive_byte(u_char byte, u_char sel)
101 {
102         u_char status = KBD_STAT_DEFAULT;
103
104 #if 1 /* Ignore mouse in U-Boot */
105         if (sel == PS2MULT_MS_SELECTOR) return;
106 #endif
107
108         if (sel == PS2MULT_KB_SELECTOR) {
109                 if (kbd_command_active) {
110                         if (!received_bsync) {
111                                 PRINTF_MULT("0x%02x lost KEYBOARD !!!\n", byte);
112                                 return;
113                         } else {
114                                 kbd_command_active = 0;
115                                 received_bsync = 0;
116                         }
117                 }
118                 PRINTF_MULT("0x%02x receive KEYBOARD\n", byte);
119                 status |= KBD_STAT_IBF | KBD_STAT_OBF;
120         } else {
121                 if (mouse_command_active) {
122                         if (!received_bsync) {
123                                 PRINTF_MULT("0x%02x lost MOUSE !!!\n", byte);
124                                 return;
125                         } else {
126                                 mouse_command_active = 0;
127                                 received_bsync = 0;
128                         }
129                 }
130                 PRINTF_MULT("0x%02x receive MOUSE\n", byte);
131                 status |= KBD_STAT_IBF | KBD_STAT_OBF | KBD_STAT_MOUSE_OBF;
132         }
133
134         if (atomic_read(&ps2mult_buf_cnt) < PS2BUF_SIZE) {
135                 ps2mult_buf_status[ps2mult_buf_in_idx] = status;
136                 ps2mult_buf[ps2mult_buf_in_idx++] = byte;
137                 ps2mult_buf_in_idx &= (PS2BUF_SIZE - 1);
138                 atomic_inc(&ps2mult_buf_cnt);
139         } else {
140                 PRINTF("buffer overflow\n");
141         }
142
143         if (received_bsync) {
144                 PRINTF("unexpected BSYNC\n");
145                 received_bsync = 0;
146         }
147 }
148
149 void ps2mult_callback (int in_cnt)
150 {
151         int i;
152         u_char byte;
153         static int keyb_handler_active = 0;
154
155         if (!init_done) {
156                 return;
157         }
158
159         for (i = 0; i < in_cnt; i ++) {
160                 byte = ps2ser_getc();
161
162                 if (received_escape) {
163                         ps2mult_receive_byte(byte, received_selector);
164                         received_escape = 0;
165                 } else switch (byte) {
166                 case PS2MULT_ESCAPE:
167                         PRINTF_MULT("ESCAPE receive\n");
168                         received_escape = 1;
169                         break;
170
171                 case PS2MULT_BSYNC:
172                         PRINTF_MULT("BSYNC receive\n");
173                         received_bsync = 1;
174                         break;
175
176                 case PS2MULT_KB_SELECTOR:
177                 case PS2MULT_MS_SELECTOR:
178                         PRINTF_MULT("%s receive\n",
179                             byte == PS2MULT_KB_SELECTOR ? "KB_SEL" : "MS_SEL");
180                         received_selector = byte;
181                         break;
182
183                 case PS2MULT_SESSION_START:
184                 case PS2MULT_SESSION_END:
185                         PRINTF_MULT("%s receive\n",
186                             byte == PS2MULT_SESSION_START ?
187                             "SESSION_START" : "SESSION_END");
188                         break;
189
190                 default:
191                         ps2mult_receive_byte(byte, received_selector);
192                 }
193         }
194
195         if (keyb_handler && !keyb_handler_active &&
196             atomic_read(&ps2mult_buf_cnt)) {
197                 keyb_handler_active = 1;
198                 keyb_handler(NULL);
199                 keyb_handler_active = 0;
200         }
201 }
202
203 u_char ps2mult_read_status(void)
204 {
205         u_char byte;
206
207         if (atomic_read(&ps2mult_buf_cnt) == 0) {
208                 ps2ser_check();
209         }
210
211         if (atomic_read(&ps2mult_buf_cnt)) {
212                 byte = ps2mult_buf_status[ps2mult_buf_out_idx];
213         } else {
214                 byte = KBD_STAT_DEFAULT;
215         }
216         PRINTF_KEYB("read_status()=0x%02x\n", byte);
217         return byte;
218 }
219
220 u_char ps2mult_read_input(void)
221 {
222         u_char byte = 0;
223
224         if (atomic_read(&ps2mult_buf_cnt) == 0) {
225                 ps2ser_check();
226         }
227
228         if (atomic_read(&ps2mult_buf_cnt)) {
229                 byte = ps2mult_buf[ps2mult_buf_out_idx++];
230                 ps2mult_buf_out_idx &= (PS2BUF_SIZE - 1);
231                 atomic_dec(&ps2mult_buf_cnt);
232         }
233         PRINTF_KEYB("read_input()=0x%02x\n", byte);
234         return byte;
235 }
236
237 void ps2mult_write_output(u_char val)
238 {
239         int i;
240
241         PRINTF_KEYB("write_output(0x%02x)\n", val);
242
243         for (i = 0; i < KBD_TIMEOUT; i++) {
244                 if (!kbd_command_active && !mouse_command_active) {
245                         break;
246                 }
247                 udelay(1000);
248                 ps2ser_check();
249         }
250
251         if (kbd_command_active) {
252                 PRINTF("keyboard command not acknoledged\n");
253                 kbd_command_active = 0;
254         }
255
256         if (mouse_command_active) {
257                 PRINTF("mouse command not acknoledged\n");
258                 mouse_command_active = 0;
259         }
260
261         if (ctl_command_active) {
262                 switch (ctl_command_active) {
263                 case KBD_CCMD_WRITE_MODE:
264                           /* Scan code conversion not supported */
265                         command_byte = val & ~KBD_MODE_KCC;
266                         break;
267
268                 case KBD_CCMD_WRITE_AUX_OBUF:
269                         ps2mult_receive_byte(val, PS2MULT_MS_SELECTOR);
270                         break;
271
272                 case KBD_CCMD_WRITE_MOUSE:
273                         ps2mult_send_byte(val, PS2MULT_MS_SELECTOR);
274                         break;
275
276                 default:
277                         PRINTF("invalid controller command\n");
278                         break;
279                 }
280
281                 ctl_command_active = 0;
282                 return;
283         }
284
285         ps2mult_send_byte(val, PS2MULT_KB_SELECTOR);
286 }
287
288 void ps2mult_write_command(u_char val)
289 {
290         ctl_command_active = 0;
291
292         PRINTF_KEYB("write_command(0x%02x)\n", val);
293
294         switch (val) {
295         case KBD_CCMD_READ_MODE:
296                 ps2mult_receive_byte(command_byte, PS2MULT_KB_SELECTOR);
297                 break;
298
299         case KBD_CCMD_WRITE_MODE:
300                 ctl_command_active = val;
301                 break;
302
303         case KBD_CCMD_MOUSE_DISABLE:
304                 break;
305
306         case KBD_CCMD_MOUSE_ENABLE:
307                 break;
308
309         case KBD_CCMD_SELF_TEST:
310                 ps2mult_receive_byte(0x55, PS2MULT_KB_SELECTOR);
311                 break;
312
313         case KBD_CCMD_KBD_TEST:
314                 ps2mult_receive_byte(0x00, PS2MULT_KB_SELECTOR);
315                 break;
316
317         case KBD_CCMD_KBD_DISABLE:
318                 break;
319
320         case KBD_CCMD_KBD_ENABLE:
321                 break;
322
323         case KBD_CCMD_WRITE_AUX_OBUF:
324                 ctl_command_active = val;
325                 break;
326
327         case KBD_CCMD_WRITE_MOUSE:
328                 ctl_command_active = val;
329                 break;
330
331         default:
332                 PRINTF("invalid controller command\n");
333                 break;
334         }
335 }
336
337 static int ps2mult_getc_w (void)
338 {
339         int res = -1;
340         int i;
341
342         for (i = 0; i < KBD_TIMEOUT; i++) {
343                 if (ps2ser_check()) {
344                         res = ps2ser_getc();
345                         break;
346                 }
347                 udelay(1000);
348         }
349
350         switch (res) {
351         case PS2MULT_KB_SELECTOR:
352         case PS2MULT_MS_SELECTOR:
353                 received_selector = res;
354                 break;
355         default:
356                 break;
357         }
358
359         return res;
360 }
361
362 int ps2mult_init (void)
363 {
364         int byte;
365         int kbd_found = 0;
366         int mouse_found = 0;
367
368         while (get_timer(start_time) < CONFIG_PS2MULT_DELAY);
369
370         ps2ser_init();
371
372         ps2ser_putc(PS2MULT_SESSION_START);
373
374         ps2ser_putc(PS2MULT_KB_SELECTOR);
375         ps2ser_putc(KBD_CMD_RESET);
376
377         do {
378                 byte = ps2mult_getc_w();
379         } while (byte >= 0 && byte != KBD_REPLY_ACK);
380
381         if (byte == KBD_REPLY_ACK) {
382                 byte = ps2mult_getc_w();
383                 if (byte == 0xaa) {
384                         kbd_found = 1;
385                         puts("keyboard");
386                 }
387         }
388
389         if (!kbd_found) {
390                 while (byte >= 0) {
391                         byte = ps2mult_getc_w();
392                 }
393         }
394
395 #if 1 /* detect mouse */
396         ps2ser_putc(PS2MULT_MS_SELECTOR);
397         ps2ser_putc(AUX_RESET);
398
399         do {
400                 byte = ps2mult_getc_w();
401         } while (byte >= 0 && byte != AUX_ACK);
402
403         if (byte == AUX_ACK) {
404                 byte = ps2mult_getc_w();
405                 if (byte == 0xaa) {
406                         byte = ps2mult_getc_w();
407                         if (byte == 0x00) {
408                                 mouse_found = 1;
409                                 puts(", mouse");
410                         }
411                 }
412         }
413
414         if (!mouse_found) {
415                 while (byte >= 0) {
416                         byte = ps2mult_getc_w();
417                 }
418         }
419 #endif
420
421         if (mouse_found || kbd_found) {
422                 if (!received_selector) {
423                         if (mouse_found) {
424                                 received_selector = PS2MULT_MS_SELECTOR;
425                         } else {
426                                 received_selector = PS2MULT_KB_SELECTOR;
427                         }
428                 }
429
430                 init_done = 1;
431         } else {
432                 puts("No device found");
433         }
434
435         puts("\n");
436
437 #if 0 /* for testing */
438         {
439                 int i;
440                 u_char key[] = {
441                         0x1f, 0x12, 0x14, 0x12, 0x31, 0x2f, 0x39,       /* setenv */
442                         0x1f, 0x14, 0x20, 0x17, 0x31, 0x39,             /* stdin */
443                         0x1f, 0x12, 0x13, 0x17, 0x1e, 0x26, 0x1c,       /* serial */
444                 };
445
446                 for (i = 0; i < sizeof (key); i++) {
447                         ps2mult_receive_byte (key[i],        PS2MULT_KB_SELECTOR);
448                         ps2mult_receive_byte (key[i] | 0x80, PS2MULT_KB_SELECTOR);
449                 }
450         }
451 #endif
452
453         return init_done ? 0 : -1;
454 }
455
456 int ps2mult_request_irq(void (*handler)(void *))
457 {
458         keyb_handler = handler;
459
460         return 0;
461 }