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