1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/slab.h>
27#include <linux/module.h>
28#include <linux/init.h>
29#include <linux/input.h>
30#include <linux/delay.h>
31#include <linux/device.h>
32#include <linux/interrupt.h>
33#include <linux/ioport.h>
34
35#include <asm/hardware/locomo.h>
36#include <asm/irq.h>
37
38MODULE_AUTHOR("John Lenz <lenz@cs.wisc.edu>");
39MODULE_DESCRIPTION("LoCoMo keyboard driver");
40MODULE_LICENSE("GPL");
41
42#define LOCOMOKBD_NUMKEYS 128
43
44#define KEY_ACTIVITY KEY_F16
45#define KEY_CONTACT KEY_F18
46#define KEY_CENTER KEY_F15
47
48static const unsigned char
49locomokbd_keycode[LOCOMOKBD_NUMKEYS] __devinitconst = {
50 0, KEY_ESC, KEY_ACTIVITY, 0, 0, 0, 0, 0, 0, 0,
51 0, 0, 0, 0, 0, 0, 0, KEY_MENU, KEY_HOME, KEY_CONTACT,
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
53 0, 0, 0, KEY_CENTER, 0, KEY_MAIL, 0, 0, 0, 0,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RIGHT,
55 KEY_UP, KEY_LEFT, 0, 0, KEY_P, 0, KEY_O, KEY_I, KEY_Y, KEY_T,
56 KEY_E, KEY_W, 0, 0, 0, 0, KEY_DOWN, KEY_ENTER, 0, 0,
57 KEY_BACKSPACE, 0, KEY_L, KEY_U, KEY_H, KEY_R, KEY_D, KEY_Q, 0, 0,
58 0, 0, 0, 0, 0, 0, KEY_ENTER, KEY_RIGHTSHIFT, KEY_K, KEY_J,
59 KEY_G, KEY_F, KEY_X, KEY_S, 0, 0, 0, 0, 0, 0,
60 0, 0, KEY_DOT, 0, KEY_COMMA, KEY_N, KEY_B, KEY_C, KEY_Z, KEY_A,
61 KEY_LEFTSHIFT, KEY_TAB, KEY_LEFTCTRL, 0, 0, 0, 0, 0, 0, 0,
62 KEY_M, KEY_SPACE, KEY_V, KEY_APOSTROPHE, KEY_SLASH, 0, 0, 0
63};
64
65#define KB_ROWS 16
66#define KB_COLS 8
67#define KB_ROWMASK(r) (1 << (r))
68#define SCANCODE(c,r) ( ((c)<<4) + (r) + 1 )
69
70#define KB_DELAY 8
71#define SCAN_INTERVAL (HZ/10)
72
73struct locomokbd {
74 unsigned char keycode[LOCOMOKBD_NUMKEYS];
75 struct input_dev *input;
76 char phys[32];
77
78 unsigned long base;
79 spinlock_t lock;
80
81 struct timer_list timer;
82 unsigned long suspend_jiffies;
83 unsigned int count_cancel;
84};
85
86
87static inline void locomokbd_charge_all(unsigned long membase)
88{
89 locomo_writel(0x00FF, membase + LOCOMO_KSC);
90}
91
92static inline void locomokbd_activate_all(unsigned long membase)
93{
94 unsigned long r;
95
96 locomo_writel(0, membase + LOCOMO_KSC);
97 r = locomo_readl(membase + LOCOMO_KIC);
98 r &= 0xFEFF;
99 locomo_writel(r, membase + LOCOMO_KIC);
100}
101
102static inline void locomokbd_activate_col(unsigned long membase, int col)
103{
104 unsigned short nset;
105 unsigned short nbset;
106
107 nset = 0xFF & ~(1 << col);
108 nbset = (nset << 8) + nset;
109 locomo_writel(nbset, membase + LOCOMO_KSC);
110}
111
112static inline void locomokbd_reset_col(unsigned long membase, int col)
113{
114 unsigned short nbset;
115
116 nbset = ((0xFF & ~(1 << col)) << 8) + 0xFF;
117 locomo_writel(nbset, membase + LOCOMO_KSC);
118}
119
120
121
122
123
124
125
126
127static void locomokbd_scankeyboard(struct locomokbd *locomokbd)
128{
129 unsigned int row, col, rowd;
130 unsigned long flags;
131 unsigned int num_pressed;
132 unsigned long membase = locomokbd->base;
133
134 spin_lock_irqsave(&locomokbd->lock, flags);
135
136 locomokbd_charge_all(membase);
137
138 num_pressed = 0;
139 for (col = 0; col < KB_COLS; col++) {
140
141 locomokbd_activate_col(membase, col);
142 udelay(KB_DELAY);
143
144 rowd = ~locomo_readl(membase + LOCOMO_KIB);
145 for (row = 0; row < KB_ROWS; row++) {
146 unsigned int scancode, pressed, key;
147
148 scancode = SCANCODE(col, row);
149 pressed = rowd & KB_ROWMASK(row);
150 key = locomokbd->keycode[scancode];
151
152 input_report_key(locomokbd->input, key, pressed);
153 if (likely(!pressed))
154 continue;
155
156 num_pressed++;
157
158
159
160
161 if (unlikely(key == KEY_ESC)) {
162 if (!time_after(jiffies,
163 locomokbd->suspend_jiffies + HZ))
164 continue;
165 if (locomokbd->count_cancel++
166 != (HZ/SCAN_INTERVAL + 1))
167 continue;
168 input_event(locomokbd->input, EV_PWR,
169 KEY_SUSPEND, 1);
170 locomokbd->suspend_jiffies = jiffies;
171 } else
172 locomokbd->count_cancel = 0;
173 }
174 locomokbd_reset_col(membase, col);
175 }
176 locomokbd_activate_all(membase);
177
178 input_sync(locomokbd->input);
179
180
181 if (num_pressed)
182 mod_timer(&locomokbd->timer, jiffies + SCAN_INTERVAL);
183 else
184 locomokbd->count_cancel = 0;
185
186 spin_unlock_irqrestore(&locomokbd->lock, flags);
187}
188
189
190
191
192static irqreturn_t locomokbd_interrupt(int irq, void *dev_id)
193{
194 struct locomokbd *locomokbd = dev_id;
195
196 udelay(100);
197
198 locomokbd_scankeyboard(locomokbd);
199
200 return IRQ_HANDLED;
201}
202
203
204
205
206static void locomokbd_timer_callback(unsigned long data)
207{
208 struct locomokbd *locomokbd = (struct locomokbd *) data;
209
210 locomokbd_scankeyboard(locomokbd);
211}
212
213static int __devinit locomokbd_probe(struct locomo_dev *dev)
214{
215 struct locomokbd *locomokbd;
216 struct input_dev *input_dev;
217 int i, err;
218
219 locomokbd = kzalloc(sizeof(struct locomokbd), GFP_KERNEL);
220 input_dev = input_allocate_device();
221 if (!locomokbd || !input_dev) {
222 err = -ENOMEM;
223 goto err_free_mem;
224 }
225
226
227 if (!request_mem_region((unsigned long) dev->mapbase,
228 dev->length,
229 LOCOMO_DRIVER_NAME(dev))) {
230 err = -EBUSY;
231 printk(KERN_ERR "locomokbd: Can't acquire access to io memory for keyboard\n");
232 goto err_free_mem;
233 }
234
235 locomo_set_drvdata(dev, locomokbd);
236
237 locomokbd->base = (unsigned long) dev->mapbase;
238
239 spin_lock_init(&locomokbd->lock);
240
241 init_timer(&locomokbd->timer);
242 locomokbd->timer.function = locomokbd_timer_callback;
243 locomokbd->timer.data = (unsigned long) locomokbd;
244
245 locomokbd->suspend_jiffies = jiffies;
246
247 locomokbd->input = input_dev;
248 strcpy(locomokbd->phys, "locomokbd/input0");
249
250 input_dev->name = "LoCoMo keyboard";
251 input_dev->phys = locomokbd->phys;
252 input_dev->id.bustype = BUS_HOST;
253 input_dev->id.vendor = 0x0001;
254 input_dev->id.product = 0x0001;
255 input_dev->id.version = 0x0100;
256 input_dev->dev.parent = &dev->dev;
257
258 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
259 BIT_MASK(EV_PWR);
260 input_dev->keycode = locomokbd->keycode;
261 input_dev->keycodesize = sizeof(locomokbd_keycode[0]);
262 input_dev->keycodemax = ARRAY_SIZE(locomokbd_keycode);
263
264 memcpy(locomokbd->keycode, locomokbd_keycode, sizeof(locomokbd->keycode));
265 for (i = 0; i < LOCOMOKBD_NUMKEYS; i++)
266 set_bit(locomokbd->keycode[i], input_dev->keybit);
267 clear_bit(0, input_dev->keybit);
268
269
270 err = request_irq(dev->irq[0], locomokbd_interrupt, 0, "locomokbd", locomokbd);
271 if (err) {
272 printk(KERN_ERR "locomokbd: Can't get irq for keyboard\n");
273 goto err_release_region;
274 }
275
276 err = input_register_device(locomokbd->input);
277 if (err)
278 goto err_free_irq;
279
280 return 0;
281
282 err_free_irq:
283 free_irq(dev->irq[0], locomokbd);
284 err_release_region:
285 release_mem_region((unsigned long) dev->mapbase, dev->length);
286 locomo_set_drvdata(dev, NULL);
287 err_free_mem:
288 input_free_device(input_dev);
289 kfree(locomokbd);
290
291 return err;
292}
293
294static int __devexit locomokbd_remove(struct locomo_dev *dev)
295{
296 struct locomokbd *locomokbd = locomo_get_drvdata(dev);
297
298 free_irq(dev->irq[0], locomokbd);
299
300 del_timer_sync(&locomokbd->timer);
301
302 input_unregister_device(locomokbd->input);
303 locomo_set_drvdata(dev, NULL);
304
305 release_mem_region((unsigned long) dev->mapbase, dev->length);
306
307 kfree(locomokbd);
308
309 return 0;
310}
311
312static struct locomo_driver keyboard_driver = {
313 .drv = {
314 .name = "locomokbd"
315 },
316 .devid = LOCOMO_DEVID_KEYBOARD,
317 .probe = locomokbd_probe,
318 .remove = __devexit_p(locomokbd_remove),
319};
320
321static int __init locomokbd_init(void)
322{
323 return locomo_driver_register(&keyboard_driver);
324}
325
326static void __exit locomokbd_exit(void)
327{
328 locomo_driver_unregister(&keyboard_driver);
329}
330
331module_init(locomokbd_init);
332module_exit(locomokbd_exit);
333
