![[BACK]](/icons/back.gif){kind=icon}
Return to zaurus_kbd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / zaurus / dev|
Return to zaurus_kbd.c CVS log | Up to [local] / sys / arch / zaurus / dev |
1.1 nbrk 1: /* $OpenBSD: zaurus_kbd.c,v 1.28 2005/12/21 20:36:03 deraadt Exp $ */
2: /*
3: * Copyright (c) 2005 Dale Rahn <drahn@openbsd.org>
4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: */
17:
18: #include <sys/param.h>
19: #include <sys/systm.h>
20: #include <sys/device.h>
21: #include <sys/malloc.h>
22: #include <sys/timeout.h>
23: #include <sys/kernel.h>
24: #include <sys/proc.h>
25: #include <sys/signalvar.h>
26:
27: #include <arm/xscale/pxa2x0reg.h>
28: #include <arm/xscale/pxa2x0_gpio.h>
29:
30: #include <dev/wscons/wsconsio.h>
31: #include <dev/wscons/wskbdvar.h>
32: #include <dev/wscons/wsksymdef.h>
33: #include <dev/wscons/wsksymvar.h>
34:
35: #include <zaurus/dev/zaurus_kbdmap.h>
36:
37: #include "apm.h"
38:
39: const int
40: gpio_sense_pins_c3000[] = {
41: 12,
42: 17,
43: 91,
44: 34,
45: 36,
46: 38,
47: 39,
48: -1
49: };
50:
51: const int
52: gpio_strobe_pins_c3000[] = {
53: 88,
54: 23,
55: 24,
56: 25,
57: 26,
58: 27,
59: 52,
60: 103,
61: 107,
62: -1,
63: 108,
64: 114
65: };
66:
67: const int stuck_keys[] = {
68: 7,
69: 15,
70: 23,
71: 31
72: };
73:
74:
75: #define REP_DELAY1 400
76: #define REP_DELAYN 100
77:
78: struct zkbd_softc {
79: struct device sc_dev;
80:
81: const int *sc_sense_array;
82: const int *sc_strobe_array;
83: int sc_nsense;
84: int sc_nstrobe;
85:
86: short sc_onkey_pin;
87: short sc_sync_pin;
88: short sc_swa_pin;
89: short sc_swb_pin;
90: char *sc_okeystate;
91: char *sc_keystate;
92: char sc_hinge; /* 0=open, 1=nonsense, 2=backwards, 3=closed */
93: char sc_maxkbdcol;
94:
95: struct timeout sc_roll_to;
96:
97: /* console stuff */
98: int sc_polling;
99: int sc_pollUD;
100: int sc_pollkey;
101:
102: /* wskbd bits */
103: struct device *sc_wskbddev;
104: int sc_rawkbd;
105: #ifdef WSDISPLAY_COMPAT_RAWKBD
106: const char *sc_xt_keymap;
107: struct timeout sc_rawrepeat_ch;
108: #define MAXKEYS 20
109: char sc_rep[MAXKEYS];
110: int sc_nrep;
111: #endif
112: void *sc_powerhook;
113: };
114:
115: struct zkbd_softc *zkbd_dev; /* XXX */
116:
117: int zkbd_match(struct device *, void *, void *);
118: void zkbd_attach(struct device *, struct device *, void *);
119:
120: int zkbd_irq(void *v);
121: void zkbd_poll(void *v);
122: int zkbd_on(void *v);
123: int zkbd_sync(void *v);
124: int zkbd_hinge(void *v);
125: void zkbd_power(int why, void *arg);
126:
127: int zkbd_modstate;
128:
129: struct cfattach zkbd_ca = {
130: sizeof(struct zkbd_softc), zkbd_match, zkbd_attach
131: };
132:
133: struct cfdriver zkbd_cd = {
134: NULL, "zkbd", DV_DULL
135: };
136:
137: int zkbd_enable(void *, int);
138: void zkbd_set_leds(void *, int);
139: int zkbd_ioctl(void *, u_long, caddr_t, int, struct proc *);
140: void zkbd_rawrepeat(void *v);
141:
142: struct wskbd_accessops zkbd_accessops = {
143: zkbd_enable,
144: zkbd_set_leds,
145: zkbd_ioctl,
146: };
147:
148: void zkbd_cngetc(void *, u_int *, int *);
149: void zkbd_cnpollc(void *, int);
150:
151: struct wskbd_consops zkbd_consops = {
152: zkbd_cngetc,
153: zkbd_cnpollc,
154: };
155:
156: struct wskbd_mapdata zkbd_keymapdata = {
157: zkbd_keydesctab,
158: KB_US,
159: };
160:
161:
162:
163: int
164: zkbd_match(struct device *parent, void *cf, void *aux)
165: {
166: return 1;
167: }
168:
169:
170: void
171: zkbd_attach(struct device *parent, struct device *self, void *aux)
172: {
173: struct zkbd_softc *sc = (struct zkbd_softc *)self;
174: struct wskbddev_attach_args a;
175: int pin, i;
176: extern int glass_console;
177:
178: zkbd_dev = sc;
179: sc->sc_polling = 0;
180: #ifdef WSDISPLAY_COMPAT_RAWKBD
181: sc->sc_rawkbd = 0;
182: #endif
183: /* Determine which system we are - XXX */
184:
185: sc->sc_powerhook = powerhook_establish(zkbd_power, sc);
186: if (sc->sc_powerhook == NULL) {
187: printf(": unable to establish powerhook\n");
188: return;
189: }
190:
191: if (1 /* C3000 */) {
192: sc->sc_sense_array = gpio_sense_pins_c3000;
193: sc->sc_strobe_array = gpio_strobe_pins_c3000;
194: sc->sc_nsense = sizeof(gpio_sense_pins_c3000)/sizeof(int);
195: sc->sc_nstrobe = sizeof(gpio_strobe_pins_c3000)/sizeof(int);
196: sc->sc_maxkbdcol = 10;
197: sc->sc_onkey_pin = 95;
198: sc->sc_sync_pin = 16;
199: sc->sc_swa_pin = 97;
200: sc->sc_swb_pin = 96;
201: #ifdef WSDISPLAY_COMPAT_RAWKBD
202: sc->sc_xt_keymap = xt_keymap;
203: #endif
204: } /* XXX */
205:
206: sc->sc_okeystate = malloc(sc->sc_nsense * sc->sc_nstrobe,
207: M_DEVBUF, M_NOWAIT);
208: bzero(sc->sc_okeystate, (sc->sc_nsense * sc->sc_nstrobe));
209:
210: sc->sc_keystate = malloc(sc->sc_nsense * sc->sc_nstrobe,
211: M_DEVBUF, M_NOWAIT);
212: bzero(sc->sc_keystate, (sc->sc_nsense * sc->sc_nstrobe));
213:
214: /* set all the strobe bits */
215: for (i = 0; i < sc->sc_nstrobe; i++) {
216: pin = sc->sc_strobe_array[i];
217: if (pin == -1) {
218: continue;
219: }
220: pxa2x0_gpio_set_function(pin, GPIO_SET|GPIO_OUT);
221: }
222: /* set all the sense bits */
223: for (i = 0; i < sc->sc_nsense; i++) {
224: pin = sc->sc_sense_array[i];
225: if (pin == -1) {
226: continue;
227: }
228: pxa2x0_gpio_set_function(pin, GPIO_IN);
229: pxa2x0_gpio_intr_establish(pin, IST_EDGE_BOTH, IPL_TTY,
230: zkbd_irq, sc, sc->sc_dev.dv_xname);
231: }
232: pxa2x0_gpio_intr_establish(sc->sc_onkey_pin, IST_EDGE_BOTH, IPL_TTY,
233: zkbd_on, sc, sc->sc_dev.dv_xname);
234: pxa2x0_gpio_intr_establish(sc->sc_sync_pin, IST_EDGE_RISING, IPL_TTY,
235: zkbd_sync, sc, sc->sc_dev.dv_xname);
236: pxa2x0_gpio_intr_establish(sc->sc_swa_pin, IST_EDGE_BOTH, IPL_TTY,
237: zkbd_hinge, sc, sc->sc_dev.dv_xname);
238: pxa2x0_gpio_intr_establish(sc->sc_swb_pin, IST_EDGE_BOTH, IPL_TTY,
239: zkbd_hinge, sc, sc->sc_dev.dv_xname);
240:
241: if (glass_console) {
242: wskbd_cnattach(&zkbd_consops, sc, &zkbd_keymapdata);
243: a.console = 1;
244: } else {
245: a.console = 0;
246: }
247:
248: a.keymap = &zkbd_keymapdata;
249: a.accessops = &zkbd_accessops;
250: a.accesscookie = sc;
251:
252: printf("\n");
253:
254: zkbd_hinge(sc); /* to initialize sc_hinge */
255:
256: sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
257:
258: timeout_set(&(sc->sc_roll_to), zkbd_poll, sc);
259: #ifdef WSDISPLAY_COMPAT_RAWKBD
260: timeout_set(&sc->sc_rawrepeat_ch, zkbd_rawrepeat, sc);
261: #endif
262:
263: }
264:
265: #ifdef WSDISPLAY_COMPAT_RAWKBD
266: void
267: zkbd_rawrepeat(void *v)
268: {
269: struct zkbd_softc *sc = v;
270: int s;
271:
272: s = spltty();
273: wskbd_rawinput(sc->sc_wskbddev, sc->sc_rep, sc->sc_nrep);
274: splx(s);
275: timeout_add(&sc->sc_rawrepeat_ch, hz * REP_DELAYN / 1000);
276: }
277: #endif
278:
279: /* XXX only deal with keys that can be pressed when display is open? */
280: /* XXX are some not in the array? */
281: /* handle keypress interrupt */
282: int
283: zkbd_irq(void *v)
284: {
285: zkbd_poll(v);
286:
287: return 1;
288: }
289:
290: void
291: zkbd_poll(void *v)
292: {
293: struct zkbd_softc *sc = v;
294: int i, j, col, pin, type, keysdown = 0, s;
295: int stuck;
296: int keystate;
297: #ifdef WSDISPLAY_COMPAT_RAWKBD
298: int npress = 0, ncbuf = 0, c;
299: char cbuf[MAXKEYS *2];
300: #endif
301:
302: s = spltty();
303:
304: /* discharge all */
305: for (i = 0; i < sc->sc_nstrobe; i++) {
306: pin = sc->sc_strobe_array[i];
307: if (pin != -1) {
308: pxa2x0_gpio_clear_bit(pin);
309: pxa2x0_gpio_set_dir(pin, GPIO_IN);
310: }
311: }
312:
313: delay (10);
314: for(col = 0; col < sc->sc_nstrobe; col++) {
315: if (sc->sc_strobe_array[i] == -1)
316: continue;
317:
318: pin = sc->sc_strobe_array[col];
319:
320: /* activate_col */
321: pxa2x0_gpio_set_bit(pin);
322: pxa2x0_gpio_set_dir(pin, GPIO_OUT);
323:
324: /* wait activate delay */
325: delay(10);
326:
327: /* read row */
328: for (i = 0; i < sc->sc_nsense; i++) {
329: int bit;
330:
331: if (sc->sc_sense_array[i] == -1)
332: continue;
333:
334: bit = pxa2x0_gpio_get_bit(sc->sc_sense_array[i]);
335: if (bit && sc->sc_hinge && col < sc->sc_maxkbdcol)
336: continue;
337: sc->sc_keystate[i + (col * sc->sc_nsense)] = bit;
338: }
339:
340: /* reset_col */
341: pxa2x0_gpio_set_dir(pin, GPIO_IN);
342: /* wait discharge delay */
343: delay(10);
344: }
345: /* charge all */
346: for (i = 0; i < sc->sc_nstrobe; i++) {
347: pin = sc->sc_strobe_array[i];
348: if (pin != -1) {
349: pxa2x0_gpio_set_bit(pin);
350: pxa2x0_gpio_set_dir(pin, GPIO_OUT);
351: }
352: }
353:
354: /* force the irqs to clear as we have just played with them. */
355: for (i = 0; i < sc->sc_nsense; i++)
356: if (sc->sc_sense_array[i] != -1)
357: pxa2x0_gpio_clear_intr(sc->sc_sense_array[i]);
358:
359: /* process after resetting interrupt */
360:
361: zkbd_modstate = (
362: (sc->sc_keystate[84] ? (1 << 0) : 0) | /* shift */
363: (sc->sc_keystate[93] ? (1 << 1) : 0) | /* Fn */
364: (sc->sc_keystate[14] ? (1 << 2) : 0)); /* 'alt' */
365:
366: for (i = 0; i < (sc->sc_nsense * sc->sc_nstrobe); i++) {
367: stuck = 0;
368: /* extend xt_keymap to do this faster. */
369: /* ignore 'stuck' keys' */
370: for (j = 0; j < sizeof(stuck_keys)/sizeof(stuck_keys[0]); j++) {
371: if (stuck_keys[j] == i) {
372: stuck = 1 ;
373: break;
374: }
375: }
376: if (stuck)
377: continue;
378: keystate = sc->sc_keystate[i];
379:
380: keysdown |= keystate; /* if any keys held */
381:
382: #ifdef WSDISPLAY_COMPAT_RAWKBD
383: if (sc->sc_polling == 0 && sc->sc_rawkbd) {
384: if ((keystate) || (sc->sc_okeystate[i] != keystate)) {
385: c = sc->sc_xt_keymap[i];
386: if (c & 0x80) {
387: cbuf[ncbuf++] = 0xe0;
388: }
389: cbuf[ncbuf] = c & 0x7f;
390:
391: if (keystate) {
392: if (c & 0x80) {
393: sc->sc_rep[npress++] = 0xe0;
394: }
395: sc->sc_rep[npress++] = c & 0x7f;
396: } else {
397: cbuf[ncbuf] |= 0x80;
398: }
399: ncbuf++;
400: sc->sc_okeystate[i] = keystate;
401: }
402: }
403: #endif
404:
405: if ((!sc->sc_rawkbd) && (sc->sc_okeystate[i] != keystate)) {
406:
407: type = keystate ? WSCONS_EVENT_KEY_DOWN :
408: WSCONS_EVENT_KEY_UP;
409:
410: if (sc->sc_polling) {
411: sc->sc_pollkey = i;
412: sc->sc_pollUD = type;
413: } else {
414: wskbd_input(sc->sc_wskbddev, type, i);
415: }
416:
417: sc->sc_okeystate[i] = keystate;
418: }
419: }
420:
421: #ifdef WSDISPLAY_COMPAT_RAWKBD
422: if (sc->sc_polling == 0 && sc->sc_rawkbd) {
423: wskbd_rawinput(sc->sc_wskbddev, cbuf, ncbuf);
424: sc->sc_nrep = npress;
425: if (npress != 0)
426: timeout_add(&sc->sc_rawrepeat_ch, hz * REP_DELAY1/1000);
427: else
428: timeout_del(&sc->sc_rawrepeat_ch);
429: }
430: #endif
431: if (keysdown)
432: timeout_add(&(sc->sc_roll_to), hz * REP_DELAYN / 1000 / 2);
433: else
434: timeout_del(&(sc->sc_roll_to)); /* always cancel? */
435:
436: splx(s);
437: }
438:
439: #if NAPM > 0
440: extern int kbd_reset;
441: extern int apm_suspends;
442: static int zkbdondown; /* on key is pressed */
443: static struct timeval zkbdontv = { 0, 0 }; /* last on key event */
444: const struct timeval zkbdhalttv = { 3, 0 }; /* 3s for safe shutdown */
445: const struct timeval zkbdsleeptv = { 0, 250000 }; /* .25s for suspend */
446: extern int lid_suspend;
447: #endif
448:
449: int
450: zkbd_on(void *v)
451: {
452: #if NAPM > 0
453: struct zkbd_softc *sc = v;
454: int down = pxa2x0_gpio_get_bit(sc->sc_onkey_pin) ? 1 : 0;
455:
456: /*
457: * Change run mode depending on how long the key is held down.
458: * Ignore the key if it gets pressed while the lid is closed.
459: *
460: * Keys can bounce and we have to work around missed interrupts.
461: * Only the second edge is detected upon exit from sleep mode.
462: */
463: if (down) {
464: if (sc->sc_hinge == 3) {
465: zkbdondown = 0;
466: } else {
467: microuptime(&zkbdontv);
468: zkbdondown = 1;
469: }
470: } else if (zkbdondown) {
471: if (ratecheck(&zkbdontv, &zkbdhalttv)) {
472: if (kbd_reset == 1) {
473: kbd_reset = 0;
474: psignal(initproc, SIGUSR1);
475: }
476: } else if (ratecheck(&zkbdontv, &zkbdsleeptv)) {
477: apm_suspends++;
478: }
479: zkbdondown = 0;
480: }
481: #endif
482: return 1;
483: }
484:
485: int
486: zkbd_sync(void *v)
487: {
488: return 1;
489: }
490:
491: int
492: zkbd_hinge(void *v)
493: {
494: struct zkbd_softc *sc = v;
495: int a = pxa2x0_gpio_get_bit(sc->sc_swa_pin) ? 1 : 0;
496: int b = pxa2x0_gpio_get_bit(sc->sc_swb_pin) ? 2 : 0;
497: extern void lcd_blank(int);
498:
499: sc->sc_hinge = a | b;
500:
501: if (sc->sc_hinge == 3) {
502: #if NAPM > 0
503: if (lid_suspend)
504: apm_suspends++;
505: #endif
506: lcd_blank(1);
507: } else
508: lcd_blank(0);
509:
510:
511: return 1;
512: }
513:
514: int
515: zkbd_enable(void *v, int on)
516: {
517: return 0;
518: }
519:
520: void
521: zkbd_set_leds(void *v, int on)
522: {
523: }
524:
525: int
526: zkbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
527: {
528: #ifdef WSDISPLAY_COMPAT_RAWKBD
529: struct zkbd_softc *sc = v;
530: #endif
531:
532: switch (cmd) {
533:
534: case WSKBDIO_GTYPE:
535: *(int *)data = WSKBD_TYPE_ZAURUS;
536: return 0;
537: case WSKBDIO_SETLEDS:
538: return 0;
539: case WSKBDIO_GETLEDS:
540: *(int *)data = 0;
541: return 0;
542: #ifdef WSDISPLAY_COMPAT_RAWKBD
543: case WSKBDIO_SETMODE:
544: sc->sc_rawkbd = *(int *)data == WSKBD_RAW;
545: timeout_del(&sc->sc_rawrepeat_ch);
546: return (0);
547: #endif
548:
549: }
550: /* kbdioctl(...); */
551:
552: return -1;
553: }
554:
555: /* implement polling for zaurus_kbd */
556: void
557: zkbd_cngetc(void *v, u_int *type, int *data)
558: {
559: struct zkbd_softc *sc = zkbd_dev;
560: sc->sc_pollkey = -1;
561: sc->sc_pollUD = -1;
562: sc->sc_polling = 1;
563: while (sc->sc_pollkey == -1) {
564: zkbd_poll(zkbd_dev);
565: DELAY(10000); /* XXX */
566: }
567: sc->sc_polling = 0;
568: *data = sc->sc_pollkey;
569: *type = sc->sc_pollUD;
570: }
571:
572: void
573: zkbd_cnpollc(void *v, int on)
574: {
575: }
576:
577: void
578: zkbd_power(int why, void *arg)
579: {
580: zkbd_hinge(arg);
581: }