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