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