605 lines
13 KiB
C
605 lines
13 KiB
C
/* $NetBSD: zkbd.c,v 1.7 2007/10/17 19:58:34 garbled Exp $ */
|
|
/* $OpenBSD: zaurus_kbd.c,v 1.28 2005/12/21 20:36:03 deraadt Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2005 Dale Rahn <drahn@openbsd.org>
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: zkbd.c,v 1.7 2007/10/17 19:58:34 garbled Exp $");
|
|
|
|
#include "opt_wsdisplay_compat.h"
|
|
#include "lcd.h"
|
|
#if 0 /* XXX */
|
|
#include "apm.h"
|
|
#endif
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/device.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/signalvar.h>
|
|
#include <sys/callout.h>
|
|
|
|
#include <arm/xscale/pxa2x0reg.h>
|
|
#include <arm/xscale/pxa2x0_gpio.h>
|
|
|
|
#include <dev/wscons/wsconsio.h>
|
|
#include <dev/wscons/wskbdvar.h>
|
|
#include <dev/wscons/wsksymdef.h>
|
|
#include <dev/wscons/wsksymvar.h>
|
|
|
|
#include <zaurus/dev/zkbdmap.h>
|
|
#include <zaurus/zaurus/zaurus_var.h>
|
|
|
|
static const int gpio_sense_pins_c3000[] = {
|
|
12,
|
|
17,
|
|
91,
|
|
34,
|
|
36,
|
|
38,
|
|
39,
|
|
-1
|
|
};
|
|
|
|
static const int gpio_strobe_pins_c3000[] = {
|
|
88,
|
|
23,
|
|
24,
|
|
25,
|
|
26,
|
|
27,
|
|
52,
|
|
103,
|
|
107,
|
|
-1,
|
|
108,
|
|
114
|
|
};
|
|
|
|
static const int stuck_keys[] = {
|
|
7,
|
|
15,
|
|
23,
|
|
31
|
|
};
|
|
|
|
#define REP_DELAY1 400
|
|
#define REP_DELAYN 100
|
|
|
|
struct zkbd_softc {
|
|
struct device sc_dev;
|
|
|
|
const int *sc_sense_array;
|
|
const int *sc_strobe_array;
|
|
int sc_nsense;
|
|
int sc_nstrobe;
|
|
|
|
short sc_onkey_pin;
|
|
short sc_sync_pin;
|
|
short sc_swa_pin;
|
|
short sc_swb_pin;
|
|
char *sc_okeystate;
|
|
char *sc_keystate;
|
|
char sc_hinge; /* 0=open, 1=nonsense, 2=backwards, 3=closed */
|
|
char sc_maxkbdcol;
|
|
|
|
struct callout sc_roll_to;
|
|
|
|
/* console stuff */
|
|
int sc_polling;
|
|
int sc_pollUD;
|
|
int sc_pollkey;
|
|
|
|
/* wskbd bits */
|
|
struct device *sc_wskbddev;
|
|
int sc_rawkbd;
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
const char *sc_xt_keymap;
|
|
struct callout sc_rawrepeat_ch;
|
|
#define MAXKEYS 20
|
|
char sc_rep[MAXKEYS];
|
|
int sc_nrep;
|
|
#endif
|
|
void *sc_powerhook;
|
|
};
|
|
|
|
static struct zkbd_softc *zkbd_sc;
|
|
|
|
static int zkbd_match(struct device *, struct cfdata *, void *);
|
|
static void zkbd_attach(struct device *, struct device *, void *);
|
|
|
|
CFATTACH_DECL(zkbd, sizeof(struct zkbd_softc),
|
|
zkbd_match, zkbd_attach, NULL, NULL);
|
|
|
|
static int zkbd_irq(void *v);
|
|
static void zkbd_poll(void *v);
|
|
static int zkbd_on(void *v);
|
|
static int zkbd_sync(void *v);
|
|
static int zkbd_hinge(void *v);
|
|
static void zkbd_power(int why, void *arg);
|
|
|
|
int zkbd_modstate;
|
|
|
|
static int zkbd_enable(void *, int);
|
|
static void zkbd_set_leds(void *, int);
|
|
static int zkbd_ioctl(void *, u_long, void *, int, struct lwp *);
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
static void zkbd_rawrepeat(void *v);
|
|
#endif
|
|
|
|
static struct wskbd_accessops zkbd_accessops = {
|
|
zkbd_enable,
|
|
zkbd_set_leds,
|
|
zkbd_ioctl,
|
|
};
|
|
|
|
static void zkbd_cngetc(void *, u_int *, int *);
|
|
static void zkbd_cnpollc(void *, int);
|
|
|
|
static struct wskbd_consops zkbd_consops = {
|
|
zkbd_cngetc,
|
|
zkbd_cnpollc,
|
|
};
|
|
|
|
static struct wskbd_mapdata zkbd_keymapdata = {
|
|
zkbd_keydesctab,
|
|
KB_US,
|
|
};
|
|
|
|
static int
|
|
zkbd_match(struct device *parent, struct cfdata *cf, void *aux)
|
|
{
|
|
|
|
if (zkbd_sc)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
zkbd_attach(struct device *parent, struct device *self, void *aux)
|
|
{
|
|
struct zkbd_softc *sc = (struct zkbd_softc *)self;
|
|
struct wskbddev_attach_args a;
|
|
int pin, i;
|
|
|
|
zkbd_sc = sc;
|
|
|
|
printf("\n");
|
|
|
|
sc->sc_polling = 0;
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
sc->sc_rawkbd = 0;
|
|
#endif
|
|
|
|
callout_init(&sc->sc_roll_to, 0);
|
|
callout_setfunc(&sc->sc_roll_to, zkbd_poll, sc);
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
callout_init(&sc->sc_rawrepeat_ch, 0);
|
|
callout_setfunc(&sc->sc_rawrepeat_ch, zkbd_rawrepeat, sc);
|
|
#endif
|
|
|
|
if (ZAURUS_ISC3000) {
|
|
sc->sc_sense_array = gpio_sense_pins_c3000;
|
|
sc->sc_strobe_array = gpio_strobe_pins_c3000;
|
|
sc->sc_nsense = __arraycount(gpio_sense_pins_c3000);
|
|
sc->sc_nstrobe = __arraycount(gpio_strobe_pins_c3000);
|
|
sc->sc_maxkbdcol = 10;
|
|
sc->sc_onkey_pin = 95;
|
|
sc->sc_sync_pin = 16;
|
|
sc->sc_swa_pin = 97;
|
|
sc->sc_swb_pin = 96;
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
sc->sc_xt_keymap = xt_keymap;
|
|
#endif
|
|
} else {
|
|
/* XXX */
|
|
return;
|
|
}
|
|
|
|
sc->sc_powerhook = powerhook_establish(sc->sc_dev.dv_xname,
|
|
zkbd_power, sc);
|
|
if (sc->sc_powerhook == NULL) {
|
|
printf("%s: unable to establish powerhook\n",
|
|
sc->sc_dev.dv_xname);
|
|
return;
|
|
}
|
|
|
|
sc->sc_okeystate = malloc(sc->sc_nsense * sc->sc_nstrobe,
|
|
M_DEVBUF, M_NOWAIT);
|
|
memset(sc->sc_okeystate, 0, sc->sc_nsense * sc->sc_nstrobe);
|
|
|
|
sc->sc_keystate = malloc(sc->sc_nsense * sc->sc_nstrobe,
|
|
M_DEVBUF, M_NOWAIT);
|
|
memset(sc->sc_keystate, 0, sc->sc_nsense * sc->sc_nstrobe);
|
|
|
|
/* set all the strobe bits */
|
|
for (i = 0; i < sc->sc_nstrobe; i++) {
|
|
pin = sc->sc_strobe_array[i];
|
|
if (pin == -1)
|
|
continue;
|
|
pxa2x0_gpio_set_function(pin, GPIO_SET|GPIO_OUT);
|
|
}
|
|
|
|
/* set all the sense bits */
|
|
for (i = 0; i < sc->sc_nsense; i++) {
|
|
pin = sc->sc_sense_array[i];
|
|
if (pin == -1)
|
|
continue;
|
|
pxa2x0_gpio_set_function(pin, GPIO_IN);
|
|
pxa2x0_gpio_intr_establish(pin, IST_EDGE_BOTH, IPL_TTY,
|
|
zkbd_irq, sc);
|
|
}
|
|
|
|
pxa2x0_gpio_intr_establish(sc->sc_onkey_pin, IST_EDGE_BOTH, IPL_TTY,
|
|
zkbd_on, sc);
|
|
pxa2x0_gpio_intr_establish(sc->sc_sync_pin, IST_EDGE_RISING, IPL_TTY,
|
|
zkbd_sync, sc);
|
|
pxa2x0_gpio_intr_establish(sc->sc_swa_pin, IST_EDGE_BOTH, IPL_TTY,
|
|
zkbd_hinge, sc);
|
|
pxa2x0_gpio_intr_establish(sc->sc_swb_pin, IST_EDGE_BOTH, IPL_TTY,
|
|
zkbd_hinge, sc);
|
|
|
|
if (glass_console) {
|
|
wskbd_cnattach(&zkbd_consops, sc, &zkbd_keymapdata);
|
|
a.console = 1;
|
|
} else {
|
|
a.console = 0;
|
|
}
|
|
a.keymap = &zkbd_keymapdata;
|
|
a.accessops = &zkbd_accessops;
|
|
a.accesscookie = sc;
|
|
|
|
zkbd_hinge(sc); /* to initialize sc_hinge */
|
|
|
|
sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
|
|
}
|
|
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
static void
|
|
zkbd_rawrepeat(void *v)
|
|
{
|
|
struct zkbd_softc *sc = (struct zkbd_softc *)v;
|
|
int s;
|
|
|
|
s = spltty();
|
|
wskbd_rawinput(sc->sc_wskbddev, sc->sc_rep, sc->sc_nrep);
|
|
splx(s);
|
|
callout_schedule(&sc->sc_rawrepeat_ch, hz * REP_DELAYN / 1000);
|
|
}
|
|
#endif
|
|
|
|
/* XXX only deal with keys that can be pressed when display is open? */
|
|
/* XXX are some not in the array? */
|
|
/* handle keypress interrupt */
|
|
static int
|
|
zkbd_irq(void *v)
|
|
{
|
|
|
|
zkbd_poll(v);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
zkbd_poll(void *v)
|
|
{
|
|
struct zkbd_softc *sc = (struct zkbd_softc *)v;
|
|
int i, j, col, pin, type, keysdown = 0;
|
|
int stuck;
|
|
int keystate;
|
|
int s;
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
int npress = 0, ncbuf = 0, c;
|
|
char cbuf[MAXKEYS * 2];
|
|
#endif
|
|
|
|
s = spltty();
|
|
|
|
/* discharge all */
|
|
for (i = 0; i < sc->sc_nstrobe; i++) {
|
|
pin = sc->sc_strobe_array[i];
|
|
if (pin == -1)
|
|
continue;
|
|
pxa2x0_gpio_clear_bit(pin);
|
|
pxa2x0_gpio_set_dir(pin, GPIO_IN);
|
|
}
|
|
|
|
delay(10);
|
|
for (col = 0; col < sc->sc_nstrobe; col++) {
|
|
pin = sc->sc_strobe_array[col];
|
|
if (pin == -1)
|
|
continue;
|
|
|
|
/* activate_col */
|
|
pxa2x0_gpio_set_bit(pin);
|
|
pxa2x0_gpio_set_dir(pin, GPIO_OUT);
|
|
|
|
/* wait activate delay */
|
|
delay(10);
|
|
|
|
/* read row */
|
|
for (i = 0; i < sc->sc_nsense; i++) {
|
|
int bit;
|
|
|
|
if (sc->sc_sense_array[i] == -1)
|
|
continue;
|
|
bit = pxa2x0_gpio_get_bit(sc->sc_sense_array[i]);
|
|
if (bit && sc->sc_hinge && col < sc->sc_maxkbdcol)
|
|
continue;
|
|
sc->sc_keystate[i + (col * sc->sc_nsense)] = bit;
|
|
}
|
|
|
|
/* reset_col */
|
|
pxa2x0_gpio_set_dir(pin, GPIO_IN);
|
|
|
|
/* wait discharge delay */
|
|
delay(10);
|
|
}
|
|
|
|
/* charge all */
|
|
for (i = 0; i < sc->sc_nstrobe; i++) {
|
|
pin = sc->sc_strobe_array[i];
|
|
if (pin == -1)
|
|
continue;
|
|
pxa2x0_gpio_set_bit(pin);
|
|
pxa2x0_gpio_set_dir(pin, GPIO_OUT);
|
|
}
|
|
|
|
/* force the irqs to clear as we have just played with them. */
|
|
for (i = 0; i < sc->sc_nsense; i++) {
|
|
pin = sc->sc_sense_array[i];
|
|
if (pin == -1)
|
|
continue;
|
|
pxa2x0_gpio_clear_intr(pin);
|
|
}
|
|
|
|
/* process after resetting interrupt */
|
|
zkbd_modstate = (
|
|
(sc->sc_keystate[84] ? (1 << 0) : 0) | /* shift */
|
|
(sc->sc_keystate[93] ? (1 << 1) : 0) | /* Fn */
|
|
(sc->sc_keystate[14] ? (1 << 2) : 0)); /* 'alt' */
|
|
|
|
for (i = 0; i < sc->sc_nsense * sc->sc_nstrobe; i++) {
|
|
stuck = 0;
|
|
/* extend xt_keymap to do this faster. */
|
|
/* ignore 'stuck' keys' */
|
|
for (j = 0; j < __arraycount(stuck_keys); j++) {
|
|
if (stuck_keys[j] == i) {
|
|
stuck = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (stuck)
|
|
continue;
|
|
|
|
keystate = sc->sc_keystate[i];
|
|
keysdown |= keystate; /* if any keys held */
|
|
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
if (sc->sc_polling == 0 && sc->sc_rawkbd) {
|
|
if ((keystate) || (sc->sc_okeystate[i] != keystate)) {
|
|
c = sc->sc_xt_keymap[i];
|
|
if (c & 0x80) {
|
|
cbuf[ncbuf++] = 0xe0;
|
|
}
|
|
cbuf[ncbuf] = c & 0x7f;
|
|
|
|
if (keystate) {
|
|
if (c & 0x80) {
|
|
sc->sc_rep[npress++] = 0xe0;
|
|
}
|
|
sc->sc_rep[npress++] = c & 0x7f;
|
|
} else {
|
|
cbuf[ncbuf] |= 0x80;
|
|
}
|
|
ncbuf++;
|
|
sc->sc_okeystate[i] = keystate;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if ((!sc->sc_rawkbd) && (sc->sc_okeystate[i] != keystate)) {
|
|
type = keystate ? WSCONS_EVENT_KEY_DOWN :
|
|
WSCONS_EVENT_KEY_UP;
|
|
|
|
if (sc->sc_polling) {
|
|
sc->sc_pollkey = i;
|
|
sc->sc_pollUD = type;
|
|
} else {
|
|
wskbd_input(sc->sc_wskbddev, type, i);
|
|
}
|
|
|
|
sc->sc_okeystate[i] = keystate;
|
|
}
|
|
}
|
|
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
if (sc->sc_polling == 0 && sc->sc_rawkbd) {
|
|
wskbd_rawinput(sc->sc_wskbddev, cbuf, ncbuf);
|
|
sc->sc_nrep = npress;
|
|
if (npress != 0)
|
|
callout_schedule(&sc->sc_rawrepeat_ch,
|
|
hz * REP_DELAY1 / 1000);
|
|
else
|
|
callout_stop(&sc->sc_rawrepeat_ch);
|
|
}
|
|
#endif
|
|
if (keysdown)
|
|
callout_schedule(&sc->sc_roll_to, hz * REP_DELAYN / 1000 / 2);
|
|
else
|
|
callout_stop(&sc->sc_roll_to); /* always cancel? */
|
|
|
|
splx(s);
|
|
}
|
|
|
|
#if NAPM > 0
|
|
extern int kbd_reset;
|
|
extern int apm_suspends;
|
|
static int zkbdondown; /* on key is pressed */
|
|
static struct timeval zkbdontv = { 0, 0 }; /* last on key event */
|
|
const struct timeval zkbdhalttv = { 3, 0 }; /* 3s for safe shutdown */
|
|
const struct timeval zkbdsleeptv = { 0, 250000 }; /* .25s for suspend */
|
|
extern int lid_suspend;
|
|
#endif
|
|
|
|
static int
|
|
zkbd_on(void *v)
|
|
{
|
|
#if NAPM > 0
|
|
struct zkbd_softc *sc = (struct zkbd_softc *)v;
|
|
int down = pxa2x0_gpio_get_bit(sc->sc_onkey_pin) ? 1 : 0;
|
|
|
|
/*
|
|
* Change run mode depending on how long the key is held down.
|
|
* Ignore the key if it gets pressed while the lid is closed.
|
|
*
|
|
* Keys can bounce and we have to work around missed interrupts.
|
|
* Only the second edge is detected upon exit from sleep mode.
|
|
*/
|
|
if (down) {
|
|
if (sc->sc_hinge == 3) {
|
|
zkbdondown = 0;
|
|
} else {
|
|
microuptime(&zkbdontv);
|
|
zkbdondown = 1;
|
|
}
|
|
} else if (zkbdondown) {
|
|
if (ratecheck(&zkbdontv, &zkbdhalttv)) {
|
|
if (kbd_reset == 1) {
|
|
kbd_reset = 0;
|
|
psignal(initproc, SIGUSR1);
|
|
}
|
|
} else if (ratecheck(&zkbdontv, &zkbdsleeptv)) {
|
|
apm_suspends++;
|
|
}
|
|
zkbdondown = 0;
|
|
}
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
zkbd_sync(void *v)
|
|
{
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
zkbd_hinge(void *v)
|
|
{
|
|
struct zkbd_softc *sc = (struct zkbd_softc *)v;
|
|
int a = pxa2x0_gpio_get_bit(sc->sc_swa_pin) ? 1 : 0;
|
|
int b = pxa2x0_gpio_get_bit(sc->sc_swb_pin) ? 2 : 0;
|
|
#if NLCD > 0
|
|
extern void lcd_blank(int);
|
|
#endif
|
|
|
|
sc->sc_hinge = a | b;
|
|
|
|
if (sc->sc_hinge == 3) {
|
|
#if NAPM > 0
|
|
if (lid_suspend)
|
|
apm_suspends++;
|
|
#endif
|
|
#if NLCD > 0
|
|
lcd_blank(1);
|
|
#endif
|
|
} else {
|
|
#if NLCD > 0
|
|
lcd_blank(0);
|
|
#endif
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
zkbd_enable(void *v, int on)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
zkbd_set_leds(void *v, int on)
|
|
{
|
|
}
|
|
|
|
static int
|
|
zkbd_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
|
|
{
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
struct zkbd_softc *sc = (struct zkbd_softc *)v;
|
|
#endif
|
|
|
|
switch (cmd) {
|
|
case WSKBDIO_GTYPE:
|
|
*(int *)data = WSKBD_TYPE_ZAURUS;
|
|
return 0;
|
|
|
|
case WSKBDIO_SETLEDS:
|
|
return 0;
|
|
|
|
case WSKBDIO_GETLEDS:
|
|
*(int *)data = 0;
|
|
return 0;
|
|
|
|
#ifdef WSDISPLAY_COMPAT_RAWKBD
|
|
case WSKBDIO_SETMODE:
|
|
sc->sc_rawkbd = *(int *)data == WSKBD_RAW;
|
|
callout_stop(&sc->sc_rawrepeat_ch);
|
|
return 0;
|
|
#endif
|
|
|
|
}
|
|
return EPASSTHROUGH;
|
|
}
|
|
|
|
/* implement polling for zaurus_kbd */
|
|
static void
|
|
zkbd_cngetc(void *v, u_int *type, int *data)
|
|
{
|
|
struct zkbd_softc *sc = (struct zkbd_softc *)zkbd_sc;
|
|
|
|
sc->sc_pollkey = -1;
|
|
sc->sc_pollUD = -1;
|
|
sc->sc_polling = 1;
|
|
while (sc->sc_pollkey == -1) {
|
|
zkbd_poll(sc);
|
|
DELAY(10000); /* XXX */
|
|
}
|
|
sc->sc_polling = 0;
|
|
*data = sc->sc_pollkey;
|
|
*type = sc->sc_pollUD;
|
|
}
|
|
|
|
static void
|
|
zkbd_cnpollc(void *v, int on)
|
|
{
|
|
}
|
|
|
|
static void
|
|
zkbd_power(int why, void *arg)
|
|
{
|
|
|
|
zkbd_hinge(arg);
|
|
}
|