URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [scan_keyb.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *      $Id: scan_keyb.c,v 1.1.1.1 2004-04-15 01:58:44 phoenix Exp $
 *      Copyright (C) 2000 YAEGASHI Takeshi
 *      Generic scan keyboard driver
 */
 
#include <linux/spinlock.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/mm.h>
#include <linux/signal.h>
#include <linux/init.h>
#include <linux/kbd_ll.h>
#include <linux/delay.h>
#include <linux/random.h>
#include <linux/poll.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/kbd_kern.h>
#include <linux/timer.h>
 
#define SCANHZ  (HZ/20)
 
struct scan_keyboard {
        struct scan_keyboard *next;
        int (*scan)(unsigned char *buffer);
        const unsigned char *table;
        unsigned char *s0, *s1;
        int length;
};
 
static int scan_jiffies=0;
static struct scan_keyboard *keyboards=NULL;
struct timer_list scan_timer;
 
static void check_kbd(const unsigned char *table,
                      unsigned char *new, unsigned char *old, int length)
{
        int need_tasklet_schedule=0;
        unsigned int xor, bit;
 
        while(length-->0) {
                if((xor=*new^*old)==0) {
                        table+=8;
                }
                else {
                        for(bit=0x01; bit<0x100; bit<<=1) {
                                if(xor&bit) {
                                        handle_scancode(*table, !(*new&bit));
                                        need_tasklet_schedule=1;
#if 0
                                        printk("0x%x %s\n", *table, (*new&bit)?"released":"pressed");
#endif
                                }
                                table++;
                        }
                }
                new++; old++;
        }
 
        if(need_tasklet_schedule)
                tasklet_schedule(&keyboard_tasklet);
}
 
 
static void scan_kbd(unsigned long dummy)
{
        struct scan_keyboard *kbd;
 
        scan_jiffies++;
 
        for(kbd=keyboards; kbd!=NULL; kbd=kbd->next) {
                if(scan_jiffies&1) {
                        if(!kbd->scan(kbd->s0))
                                check_kbd(kbd->table,
                                          kbd->s0, kbd->s1, kbd->length);
                        else
                                memcpy(kbd->s0, kbd->s1, kbd->length);
                }
                else {
                        if(!kbd->scan(kbd->s1))
                                check_kbd(kbd->table,
                                          kbd->s1, kbd->s0, kbd->length);
                        else
                                memcpy(kbd->s1, kbd->s0, kbd->length);
                }
 
        }
 
        init_timer(&scan_timer);
        scan_timer.expires = jiffies + SCANHZ;
        scan_timer.data = 0;
        scan_timer.function = scan_kbd;
        add_timer(&scan_timer);
}
 
 
int register_scan_keyboard(int (*scan)(unsigned char *buffer),
                           const unsigned char *table,
                           int length)
{
        struct scan_keyboard *kbd;
 
        kbd = kmalloc(sizeof(struct scan_keyboard), GFP_KERNEL);
        if (kbd == NULL)
                goto error_out;
 
        kbd->scan=scan;
        kbd->table=table;
        kbd->length=length;
 
        kbd->s0 = kmalloc(length, GFP_KERNEL);
        if (kbd->s0 == NULL)
                goto error_free_kbd;
 
        kbd->s1 = kmalloc(length, GFP_KERNEL);
        if (kbd->s1 == NULL)
                goto error_free_s0;
 
        memset(kbd->s0, -1, kbd->length);
        memset(kbd->s1, -1, kbd->length);
 
        kbd->next=keyboards;
        keyboards=kbd;
 
        return 0;
 
 error_free_s0:
        kfree(kbd->s0);
 
 error_free_kbd:
        kfree(kbd);
 
 error_out:
        return -ENOMEM;
}
 
 
void __init scan_kbd_init(void)
{
        init_timer(&scan_timer);
        scan_timer.expires = jiffies + SCANHZ;
        scan_timer.data = 0;
        scan_timer.function = scan_kbd;
        add_timer(&scan_timer);
 
        printk(KERN_INFO "Generic scan keyboard driver initialized\n");
}

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* $Id: scan_keyb.c,v 1.1.1.1 2004-04-15 01:58:44 phoenix Exp $`
3			`* Copyright (C) 2000 YAEGASHI Takeshi`
4			`* Generic scan keyboard driver`
5			`*/`
6
7			`#include <linux/spinlock.h>`
8			`#include <linux/sched.h>`
9			`#include <linux/interrupt.h>`
10			`#include <linux/tty.h>`
11			`#include <linux/mm.h>`
12			`#include <linux/signal.h>`
13			`#include <linux/init.h>`
14			`#include <linux/kbd_ll.h>`
15			`#include <linux/delay.h>`
16			`#include <linux/random.h>`
17			`#include <linux/poll.h>`
18			`#include <linux/miscdevice.h>`
19			`#include <linux/slab.h>`
20			`#include <linux/kbd_kern.h>`
21			`#include <linux/timer.h>`
22
23			`#define SCANHZ (HZ/20)`
24
25			`struct scan_keyboard {`
26			`struct scan_keyboard *next;`
27			`int (scan)(unsigned char buffer);`
28			`const unsigned char *table;`
29			`unsigned char s0, s1;`
30			`int length;`
31			`};`
32
33			`static int scan_jiffies=0;`
34			`static struct scan_keyboard *keyboards=NULL;`
35			`struct timer_list scan_timer;`
36
37			`static void check_kbd(const unsigned char *table,`
38			`unsigned char new, unsigned char old, int length)`
39			`{`
40			`int need_tasklet_schedule=0;`
41			`unsigned int xor, bit;`
42
43			`while(length-->0) {`
44			`if((xor=new^old)==0) {`
45			`table+=8;`
46			`}`
47			`else {`
48			`for(bit=0x01; bit<0x100; bit<<=1) {`
49			`if(xor&bit) {`
50			`handle_scancode(table, !(new&bit));`
51			`need_tasklet_schedule=1;`
52			`#if 0`
53			`printk("0x%x %s\n", table, (new&bit)?"released":"pressed");`
54			`#endif`
55			`}`
56			`table++;`
57			`}`
58			`}`
59			`new++; old++;`
60			`}`
61
62			`if(need_tasklet_schedule)`
63			`tasklet_schedule(&keyboard_tasklet);`
64			`}`
65
66
67			`static void scan_kbd(unsigned long dummy)`
68			`{`
69			`struct scan_keyboard *kbd;`
70
71			`scan_jiffies++;`
72
73			`for(kbd=keyboards; kbd!=NULL; kbd=kbd->next) {`
74			`if(scan_jiffies&1) {`
75			`if(!kbd->scan(kbd->s0))`
76			`check_kbd(kbd->table,`
77			`kbd->s0, kbd->s1, kbd->length);`
78			`else`
79			`memcpy(kbd->s0, kbd->s1, kbd->length);`
80			`}`
81			`else {`
82			`if(!kbd->scan(kbd->s1))`
83			`check_kbd(kbd->table,`
84			`kbd->s1, kbd->s0, kbd->length);`
85			`else`
86			`memcpy(kbd->s1, kbd->s0, kbd->length);`
87			`}`
88
89			`}`
90
91			`init_timer(&scan_timer);`
92			`scan_timer.expires = jiffies + SCANHZ;`
93			`scan_timer.data = 0;`
94			`scan_timer.function = scan_kbd;`
95			`add_timer(&scan_timer);`
96			`}`
97
98
99			`int register_scan_keyboard(int (scan)(unsigned char buffer),`
100			`const unsigned char *table,`
101			`int length)`
102			`{`
103			`struct scan_keyboard *kbd;`
104
105			`kbd = kmalloc(sizeof(struct scan_keyboard), GFP_KERNEL);`
106			`if (kbd == NULL)`
107			`goto error_out;`
108
109			`kbd->scan=scan;`
110			`kbd->table=table;`
111			`kbd->length=length;`
112
113			`kbd->s0 = kmalloc(length, GFP_KERNEL);`
114			`if (kbd->s0 == NULL)`
115			`goto error_free_kbd;`
116
117			`kbd->s1 = kmalloc(length, GFP_KERNEL);`
118			`if (kbd->s1 == NULL)`
119			`goto error_free_s0;`
120
121			`memset(kbd->s0, -1, kbd->length);`
122			`memset(kbd->s1, -1, kbd->length);`
123
124			`kbd->next=keyboards;`
125			`keyboards=kbd;`
126
127			`return 0;`
128
129			`error_free_s0:`
130			`kfree(kbd->s0);`
131
132			`error_free_kbd:`
133			`kfree(kbd);`
134
135			`error_out:`
136			`return -ENOMEM;`
137			`}`
138
139
140			`void __init scan_kbd_init(void)`
141			`{`
142			`init_timer(&scan_timer);`
143			`scan_timer.expires = jiffies + SCANHZ;`
144			`scan_timer.data = 0;`
145			`scan_timer.function = scan_kbd;`
146			`add_timer(&scan_timer);`
147
148			`printk(KERN_INFO "Generic scan keyboard driver initialized\n");`
149			`}`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [scan_keyb.c] - Blame information for rev 1774