Remove obsolete #include <linux/config.h>
[linux-3.10.git] / drivers / char / qtronix.c
1 /*
2  *
3  * BRIEF MODULE DESCRIPTION
4  *      Qtronix 990P infrared keyboard driver.
5  *
6  *
7  * Copyright 2001 MontaVista Software Inc.
8  * Author: MontaVista Software, Inc.
9  *              ppopov@mvista.com or source@mvista.com
10  *
11  *
12  *  The bottom portion of this driver was take from 
13  *  pc_keyb.c  Please see that file for copyrights.
14  *
15  *  This program is free software; you can redistribute  it and/or modify it
16  *  under  the terms of  the GNU General  Public License as published by the
17  *  Free Software Foundation;  either version 2 of the  License, or (at your
18  *  option) any later version.
19  *
20  *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
21  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
22  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
23  *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
24  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
26  *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
27  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
28  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  *
31  *  You should have received a copy of the  GNU General Public License along
32  *  with this program; if not, write  to the Free Software Foundation, Inc.,
33  *  675 Mass Ave, Cambridge, MA 02139, USA.
34  */
35
36
37 /* 
38  * NOTE:  
39  *
40  *      This driver has only been tested with the Consumer IR
41  *      port of the ITE 8172 system controller.
42  *
43  *      You do not need this driver if you are using the ps/2 or
44  *      USB adapter that the keyboard ships with.  You only need 
45  *      this driver if your board has a IR port and the keyboard
46  *      data is being sent directly to the IR.  In that case,
47  *      you also need some low-level IR support. See it8172_cir.c.
48  *      
49  */
50
51 #ifdef CONFIG_QTRONIX_KEYBOARD
52
53 #include <linux/module.h>
54 #include <linux/types.h>
55 #include <linux/pci.h>
56 #include <linux/kernel.h>
57
58 #include <asm/it8172/it8172.h>
59 #include <asm/it8172/it8172_int.h>
60 #include <asm/it8172/it8172_cir.h>
61
62 #include <linux/spinlock.h>
63 #include <linux/sched.h>
64 #include <linux/interrupt.h>
65 #include <linux/tty.h>
66 #include <linux/mm.h>
67 #include <linux/signal.h>
68 #include <linux/init.h>
69 #include <linux/kbd_ll.h>
70 #include <linux/delay.h>
71 #include <linux/poll.h>
72 #include <linux/miscdevice.h>
73 #include <linux/slab.h>
74 #include <linux/kbd_kern.h>
75 #include <linux/smp_lock.h>
76 #include <asm/io.h>
77 #include <linux/pc_keyb.h>
78
79 #include <asm/keyboard.h>
80 #include <linux/bitops.h>
81 #include <asm/uaccess.h>
82 #include <asm/irq.h>
83 #include <asm/system.h>
84
85 #define leading1 0
86 #define leading2 0xF
87
88 #define KBD_CIR_PORT 0
89 #define AUX_RECONNECT 170 /* scancode when ps2 device is plugged (back) in */
90
91 static int data_index;
92 struct cir_port *cir;
93 static unsigned char kbdbytes[5];
94 static unsigned char cir_data[32]; /* we only need 16 chars */
95
96 static void kbd_int_handler(int irq, void *dev_id, struct pt_regs *regs);
97 static int handle_data(unsigned char *p_data);
98 static inline void handle_mouse_event(unsigned char scancode);
99 static inline void handle_keyboard_event(unsigned char scancode, int down);
100 static int __init psaux_init(void);
101
102 static struct aux_queue *queue; /* Mouse data buffer. */
103 static int aux_count = 0;
104
105 /*
106  * Keys accessed through the 'Fn' key
107  * The Fn key does not produce a key-up sequence. So, the first
108  * time the user presses it, it will be key-down event. The key
109  * stays down until the user presses it again.
110  */
111 #define NUM_FN_KEYS 56
112 static unsigned char fn_keys[NUM_FN_KEYS] = {
113         0,0,0,0,0,0,0,0,        /* 0 7   */
114         8,9,10,93,0,0,0,0,      /* 8 15  */
115         0,0,0,0,0,0,0,5,        /* 16 23 */
116         6,7,91,0,0,0,0,0,       /* 24 31 */
117         0,0,0,0,0,2,3,4,        /* 32 39 */
118         92,0,0,0,0,0,0,0,       /* 40 47 */
119         0,0,0,0,11,0,94,95        /* 48 55 */
120
121 };
122
123 void __init init_qtronix_990P_kbd(void)
124 {
125         int retval;
126
127         cir = (struct cir_port *)kmalloc(sizeof(struct cir_port), GFP_KERNEL);
128         if (!cir) {
129                 printk("Unable to initialize Qtronix keyboard\n");
130                 return;
131         }
132
133         /* 
134          * revisit
135          * this should be programmable, somehow by the, by the user.
136          */
137         cir->port = KBD_CIR_PORT;
138         cir->baud_rate = 0x1d;
139         cir->rdwos = 0;
140         cir->rxdcr = 0x3;
141         cir->hcfs = 0;
142         cir->fifo_tl = 0;
143         cir->cfq = 0x1d;
144         cir_port_init(cir);
145
146         retval = request_irq(IT8172_CIR0_IRQ, kbd_int_handler, 
147                         (unsigned long )(SA_INTERRUPT|SA_SHIRQ), 
148                         (const char *)"Qtronix IR Keyboard", (void *)cir);
149
150         if (retval) {
151                 printk("unable to allocate cir %d irq %d\n", 
152                                 cir->port, IT8172_CIR0_IRQ);
153         }
154 #ifdef CONFIG_PSMOUSE
155         psaux_init();
156 #endif
157 }
158
159 static inline unsigned char BitReverse(unsigned short key)
160 {
161         unsigned char rkey = 0;
162         rkey |= (key & 0x1) << 7;
163         rkey |= (key & 0x2) << 5;
164         rkey |= (key & 0x4) << 3;
165         rkey |= (key & 0x8) << 1;
166         rkey |= (key & 0x10) >> 1;
167         rkey |= (key & 0x20) >> 3;
168         rkey |= (key & 0x40) >> 5;
169         rkey |= (key & 0x80) >> 7;
170         return rkey;
171
172 }
173
174
175 static inline u_int8_t UpperByte(u_int8_t data)
176 {
177         return (data >> 4);
178 }
179
180
181 static inline u_int8_t LowerByte(u_int8_t data)
182 {
183         return (data & 0xF);
184 }
185
186
187 int CheckSumOk(u_int8_t byte1, u_int8_t byte2, 
188                 u_int8_t byte3, u_int8_t byte4, u_int8_t byte5)
189 {
190         u_int8_t CheckSum;
191
192         CheckSum = (byte1 & 0x0F) + byte2 + byte3 + byte4 + byte5;
193         if ( LowerByte(UpperByte(CheckSum) + LowerByte(CheckSum)) != UpperByte(byte1) )
194                 return 0;
195         else
196                 return 1;
197 }
198
199
200 static void kbd_int_handler(int irq, void *dev_id, struct pt_regs *regs)
201 {
202         struct cir_port *cir;
203         int j;
204         unsigned char int_status;
205
206         cir = (struct cir_port *)dev_id;
207         int_status = get_int_status(cir);
208         if (int_status & 0x4) {
209                 clear_fifo(cir);
210                 return;
211         }
212
213         while (cir_get_rx_count(cir)) {
214
215                 cir_data[data_index] = cir_read_data(cir);
216
217                 if (data_index == 0) {/* expecting first byte */
218                         if (cir_data[data_index] != leading1) {
219                                 //printk("!leading byte %x\n", cir_data[data_index]);
220                                 set_rx_active(cir);
221                                 clear_fifo(cir);
222                                 continue;
223                         }
224                 }
225                 if (data_index == 1) {
226                         if ((cir_data[data_index] & 0xf) != leading2) {
227                                 set_rx_active(cir);
228                                 data_index = 0; /* start over */
229                                 clear_fifo(cir);
230                                 continue;
231                         }
232                 }
233
234                 if ( (cir_data[data_index] == 0xff)) { /* last byte */
235                         //printk("data_index %d\n", data_index);
236                         set_rx_active(cir);
237 #if 0
238                         for (j=0; j<=data_index; j++) {
239                                 printk("rx_data %d:  %x\n", j, cir_data[j]);
240                         }
241 #endif
242                         data_index = 0;
243                         handle_data(cir_data);
244                         return;
245                 }
246                 else if (data_index>16) {
247                         set_rx_active(cir);
248 #if 0
249                         printk("warning: data_index %d\n", data_index);
250                         for (j=0; j<=data_index; j++) {
251                                 printk("rx_data %d:  %x\n", j, cir_data[j]);
252                         }
253 #endif
254                         data_index = 0;
255                         clear_fifo(cir);
256                         return;
257                 }
258                 data_index++;
259         }
260 }
261
262
263 #define NUM_KBD_BYTES 5
264 static int handle_data(unsigned char *p_data)
265 {
266         u_int32_t bit_bucket;
267         u_int32_t i, j;
268         u_int32_t got_bits, next_byte;
269         int down = 0;
270
271         /* Reorganize the bit stream */
272         for (i=0; i<16; i++)
273                 p_data[i] = BitReverse(~p_data[i]);
274
275         /* 
276          * We've already previously checked that p_data[0]
277          * is equal to leading1 and that (p_data[1] & 0xf)
278          * is equal to leading2. These twelve bits are the
279          * leader code.  We can now throw them away (the 12
280          * bits) and continue parsing the stream.
281          */
282         bit_bucket = p_data[1] << 12;
283         got_bits = 4;
284         next_byte = 2;
285
286         /* 
287          * Process four bits at a time
288          */
289         for (i=0; i<NUM_KBD_BYTES; i++) {
290
291                 kbdbytes[i]=0;
292
293                 for (j=0; j<8; j++) /* 8 bits per byte */
294                 {
295                         if (got_bits < 4) {
296                                 bit_bucket |= (p_data[next_byte++] << (8 - got_bits));
297                                 got_bits += 8;
298                         }
299
300                         if ((bit_bucket & 0xF000) == 0x8000) { 
301                                 /* Convert 1000b to 1 */
302                                 kbdbytes[i] = 0x80 | (kbdbytes[i] >> 1);
303                                 got_bits -= 4;
304                                 bit_bucket = bit_bucket << 4;
305                         }
306                         else if ((bit_bucket & 0xC000) == 0x8000) {
307                                 /* Convert 10b to 0 */
308                                 kbdbytes[i] =  kbdbytes[i] >> 1;
309                                 got_bits -= 2;
310                                 bit_bucket = bit_bucket << 2;
311                         }
312                         else {
313                                 /* bad serial stream */
314                                 return 1;
315                         }
316
317                         if (next_byte > 16) {
318                                 //printk("error: too many bytes\n");
319                                 return 1;
320                         }
321                 }
322         }
323
324
325         if (!CheckSumOk(kbdbytes[0], kbdbytes[1], 
326                                 kbdbytes[2], kbdbytes[3], kbdbytes[4])) {
327                 //printk("checksum failed\n");
328                 return 1;
329         }
330
331         if (kbdbytes[1] & 0x08) {
332                 //printk("m: %x %x %x\n", kbdbytes[1], kbdbytes[2], kbdbytes[3]);
333                 handle_mouse_event(kbdbytes[1]);
334                 handle_mouse_event(kbdbytes[2]);
335                 handle_mouse_event(kbdbytes[3]);
336         }
337         else {
338                 if (kbdbytes[2] == 0) down = 1;
339 #if 0
340                 if (down)
341                         printk("down %d\n", kbdbytes[3]);
342                 else
343                         printk("up %d\n", kbdbytes[3]);
344 #endif
345                 handle_keyboard_event(kbdbytes[3], down);
346         }
347         return 0;
348 }
349
350
351 DEFINE_SPINLOCK(kbd_controller_lock);
352 static unsigned char handle_kbd_event(void);
353
354
355 int kbd_setkeycode(unsigned int scancode, unsigned int keycode)
356 {
357         printk("kbd_setkeycode scancode %x keycode %x\n", scancode, keycode);
358         return 0;
359 }
360
361 int kbd_getkeycode(unsigned int scancode)
362 {
363         return scancode;
364 }
365
366
367 int kbd_translate(unsigned char scancode, unsigned char *keycode,
368                     char raw_mode)
369 {
370         static int prev_scancode = 0;
371
372         if (scancode == 0x00 || scancode == 0xff) {
373                 prev_scancode = 0;
374                 return 0;
375         }
376
377         /* todo */
378         if (!prev_scancode && scancode == 160) { /* Fn key down */
379                 //printk("Fn key down\n");
380                 prev_scancode = 160;
381                 return 0;
382         }
383         else if (prev_scancode && scancode == 160) { /* Fn key up */
384                 //printk("Fn key up\n");
385                 prev_scancode = 0;
386                 return 0;
387         }
388
389         /* todo */
390         if (prev_scancode == 160) {
391                 if (scancode <= NUM_FN_KEYS) {
392                         *keycode = fn_keys[scancode];
393                         //printk("fn keycode %d\n", *keycode);
394                 }
395                 else
396                         return 0;
397         } 
398         else if (scancode <= 127) {
399                 *keycode = scancode;
400         }
401         else
402                 return 0;
403
404
405         return 1;
406 }
407
408 char kbd_unexpected_up(unsigned char keycode)
409 {
410         //printk("kbd_unexpected_up\n");
411         return 0;
412 }
413
414 static unsigned char kbd_exists = 1;
415
416 static inline void handle_keyboard_event(unsigned char scancode, int down)
417 {
418         kbd_exists = 1;
419         handle_scancode(scancode, down);
420         tasklet_schedule(&keyboard_tasklet);
421 }       
422
423
424 void kbd_leds(unsigned char leds)
425 {
426 }
427
428 /* dummy */
429 void kbd_init_hw(void)
430 {
431 }
432
433
434
435 static inline void handle_mouse_event(unsigned char scancode)
436 {
437         if(scancode == AUX_RECONNECT){
438                 queue->head = queue->tail = 0;  /* Flush input queue */
439         //      __aux_write_ack(AUX_ENABLE_DEV);  /* ping the mouse :) */
440                 return;
441         }
442
443         if (aux_count) {
444                 int head = queue->head;
445
446                 queue->buf[head] = scancode;
447                 head = (head + 1) & (AUX_BUF_SIZE-1);
448                 if (head != queue->tail) {
449                         queue->head = head;
450                         kill_fasync(&queue->fasync, SIGIO, POLL_IN);
451                         wake_up_interruptible(&queue->proc_list);
452                 }
453         }
454 }
455
456 static unsigned char get_from_queue(void)
457 {
458         unsigned char result;
459         unsigned long flags;
460
461         spin_lock_irqsave(&kbd_controller_lock, flags);
462         result = queue->buf[queue->tail];
463         queue->tail = (queue->tail + 1) & (AUX_BUF_SIZE-1);
464         spin_unlock_irqrestore(&kbd_controller_lock, flags);
465         return result;
466 }
467
468
469 static inline int queue_empty(void)
470 {
471         return queue->head == queue->tail;
472 }
473
474 static int fasync_aux(int fd, struct file *filp, int on)
475 {
476         int retval;
477
478         //printk("fasync_aux\n");
479         retval = fasync_helper(fd, filp, on, &queue->fasync);
480         if (retval < 0)
481                 return retval;
482         return 0;
483 }
484
485
486 /*
487  * Random magic cookie for the aux device
488  */
489 #define AUX_DEV ((void *)queue)
490
491 static int release_aux(struct inode * inode, struct file * file)
492 {
493         fasync_aux(-1, file, 0);
494         aux_count--;
495         return 0;
496 }
497
498 static int open_aux(struct inode * inode, struct file * file)
499 {
500         if (aux_count++) {
501                 return 0;
502         }
503         queue->head = queue->tail = 0;          /* Flush input queue */
504         return 0;
505 }
506
507 /*
508  * Put bytes from input queue to buffer.
509  */
510
511 static ssize_t read_aux(struct file * file, char * buffer,
512                         size_t count, loff_t *ppos)
513 {
514         DECLARE_WAITQUEUE(wait, current);
515         ssize_t i = count;
516         unsigned char c;
517
518         if (queue_empty()) {
519                 if (file->f_flags & O_NONBLOCK)
520                         return -EAGAIN;
521                 add_wait_queue(&queue->proc_list, &wait);
522 repeat:
523                 set_current_state(TASK_INTERRUPTIBLE);
524                 if (queue_empty() && !signal_pending(current)) {
525                         schedule();
526                         goto repeat;
527                 }
528                 current->state = TASK_RUNNING;
529                 remove_wait_queue(&queue->proc_list, &wait);
530         }
531         while (i > 0 && !queue_empty()) {
532                 c = get_from_queue();
533                 put_user(c, buffer++);
534                 i--;
535         }
536         if (count-i) {
537                 struct inode *inode = file->f_dentry->d_inode;
538                 inode->i_atime = current_fs_time(inode->i_sb);
539                 return count-i;
540         }
541         if (signal_pending(current))
542                 return -ERESTARTSYS;
543         return 0;
544 }
545
546 /*
547  * Write to the aux device.
548  */
549
550 static ssize_t write_aux(struct file * file, const char * buffer,
551                          size_t count, loff_t *ppos)
552 {
553         /*
554          * The ITE boards this was tested on did not have the
555          * transmit wires connected.
556          */
557         return count;
558 }
559
560 static unsigned int aux_poll(struct file *file, poll_table * wait)
561 {
562         poll_wait(file, &queue->proc_list, wait);
563         if (!queue_empty())
564                 return POLLIN | POLLRDNORM;
565         return 0;
566 }
567
568 struct file_operations psaux_fops = {
569         .read           = read_aux,
570         .write          = write_aux,
571         .poll           = aux_poll,
572         .open           = open_aux,
573         .release        = release_aux,
574         .fasync         = fasync_aux,
575 };
576
577 /*
578  * Initialize driver.
579  */
580 static struct miscdevice psaux_mouse = {
581         PSMOUSE_MINOR, "psaux", &psaux_fops
582 };
583
584 static int __init psaux_init(void)
585 {
586         int retval;
587
588         retval = misc_register(&psaux_mouse);
589         if(retval < 0)
590                 return retval;
591
592         queue = (struct aux_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
593         if (!queue) {
594                 misc_deregister(&psaux_mouse);
595                 return -ENOMEM;
596         }
597                 
598         memset(queue, 0, sizeof(*queue));
599         queue->head = queue->tail = 0;
600         init_waitqueue_head(&queue->proc_list);
601
602         return 0;
603 }
604 module_init(init_qtronix_990P_kbd);
605 #endif