/* $NetBSD: wzero3_keypad.c,v 1.6 2021/08/07 16:18:53 thorpej Exp $ */
/*-
* Copyright (C) 2010 NONAKA Kimihiro <
[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: wzero3_keypad.c,v 1.6 2021/08/07 16:18:53 thorpej Exp $");
#include "wzero3lcd.h"
#include "opt_wsdisplay_compat.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/callout.h>
#include <sys/bus.h>
#include <arm/xscale/pxa2x0cpu.h>
#include <arm/xscale/pxa2x0var.h>
#include <arm/xscale/pxa2x0_gpio.h>
#include <machine/bootinfo.h>
#include <machine/config_hook.h>
#include <machine/platid.h>
#include <machine/platid_mask.h>
#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wskbdvar.h>
#include <dev/wscons/wsksymvar.h>
#include <dev/wscons/wsksymdef.h>
#ifdef WSDISPLAY_COMPAT_RAWKBD
#include <dev/hpc/pckbd_encode.h>
#endif
#include <arch/hpcarm/dev/wzero3_reg.h>
#include <arch/hpcarm/dev/wzero3_sspvar.h>
enum {
KD_0,
KD_1,
KD_2,
KD_3,
KD_4,
KD_5,
KD_6,
KD_7,
KD_8,
KD_9,
KD_ASTERISK,
KD_NUMBER,
KD_WINDOWS,
KD_OK,
KD_ONHOOK,
KD_OFFHOOK,
KD_CLEAR,
KD_MOJI,
KD_UP,
KD_DOWN,
KD_LEFT,
KD_RIGHT,
KD_CENTER_BUTTON,
KD_LSOFT,
KD_RSOFT,
KD_NUM,
KD_INVALID = -1
};
static int ws011sh_keyscan2keydown[32] = {
KD_INVALID,
KD_CLEAR,
KD_INVALID,
KD_OK,
KD_INVALID,
KD_LEFT,
KD_INVALID,
KD_ONHOOK,
KD_INVALID,
KD_UP,
KD_DOWN,
KD_MOJI,
KD_INVALID,
KD_WINDOWS,
KD_INVALID,
KD_RIGHT,
KD_INVALID,
KD_1,
KD_4,
KD_7,
KD_ASTERISK,
KD_2,
KD_5,
KD_8,
KD_0,
KD_CENTER_BUTTON,
KD_INVALID,
KD_3,
KD_6,
KD_9,
KD_NUMBER,
KD_INVALID,
};
struct wzero3keypad_softc {
device_t sc_dev;
void *sc_ih;
int sc_intr_pin;
uint32_t sc_okeystat;
struct callout sc_poll_ch;
int sc_poll_interval;
device_t sc_wskbddev;
#ifdef WSDISPLAY_COMPAT_RAWKBD
int sc_rawkbd;
#endif
};
static int wzero3keypad_match(device_t, cfdata_t, void *);
static void wzero3keypad_attach(device_t, device_t, void *);
CFATTACH_DECL_NEW(wzero3keypad, sizeof(struct wzero3keypad_softc),
wzero3keypad_match, wzero3keypad_attach, NULL, NULL);
static int wzero3keypad_wskbd_enable(void *, int);
static void wzero3keypad_wskbd_set_leds(void *, int);
static int wzero3keypad_wskbd_ioctl(void *, u_long, void *, int, struct lwp *);
static const int wzero3keypad_wskbd_keys[] = {
82, /* KD_0: 0 */
79, /* KD_1: 1 */
80, /* KD_2: 2 */
81, /* KD_3: 3 */
75, /* KD_4: 4 */
76, /* KD_5: 5 */
77, /* KD_6: 6 */
71, /* KD_7: 7 */
72, /* KD_8: 8 */
73, /* KD_9: 9 */
64, /* KD_ASTERISK: f6 */
65, /* KD_NUMBER: f7 */
221, /* KD_WINDOWS: Menu */
61, /* KD_OK: f3 */
59, /* KD_ONHOOK: f1 */
60, /* KD_OFFHOOK: f2 */
62, /* KD_CLEAR: f4 */
63, /* KD_MOJI: f5 */
200, /* KD_UP: Up */
208, /* KD_DOWN: Down */
203, /* KD_LEFT: Left */
205, /* KD_RIGHT: Right */
156, /* KD_CENTER_BUTTON: KP_Enter */
87, /* KD_LSOFT: f11 */
88, /* KD_RSOFT: f12 */
};
static const keysym_t wzero3keypad_wskbd_keydesc[] = {
KS_KEYCODE(59), KS_f1,
KS_KEYCODE(60), KS_f2,
KS_KEYCODE(61), KS_f3,
KS_KEYCODE(62), KS_f4,
KS_KEYCODE(63), KS_f5,
KS_KEYCODE(64), KS_f6,
KS_KEYCODE(65), KS_f7,
KS_KEYCODE(71), KS_7,
KS_KEYCODE(72), KS_8,
KS_KEYCODE(73), KS_9,
KS_KEYCODE(75), KS_4,
KS_KEYCODE(76), KS_5,
KS_KEYCODE(77), KS_6,
KS_KEYCODE(79), KS_1,
KS_KEYCODE(80), KS_2,
KS_KEYCODE(81), KS_3,
KS_KEYCODE(82), KS_0,
KS_KEYCODE(87), KS_f11,
KS_KEYCODE(88), KS_f12,
KS_KEYCODE(156), KS_KP_Enter,
KS_KEYCODE(200), KS_Up,
KS_KEYCODE(203), KS_Left,
KS_KEYCODE(205), KS_Right,
KS_KEYCODE(208), KS_Down,
KS_KEYCODE(221), KS_Menu,
};
static const struct wscons_keydesc wzero3keypad_wskbd_keydesctab[] = {
{ KB_JP, 0,
sizeof(wzero3keypad_wskbd_keydesc) / sizeof(keysym_t),
wzero3keypad_wskbd_keydesc
},
{ 0, 0, 0, 0 }
};
static const struct wskbd_mapdata wzero3keypad_wskbd_keymapdata = {
wzero3keypad_wskbd_keydesctab, KB_JP
};
static const struct wskbd_accessops wzero3keypad_wskbd_accessops = {
wzero3keypad_wskbd_enable,
wzero3keypad_wskbd_set_leds,
wzero3keypad_wskbd_ioctl,
};
static int wzero3keypad_intr(void *);
static void wzero3keypad_poll(void *);
static void wzero3keypad_poll1(struct wzero3keypad_softc *, int);
static void wzero3keypad_init(struct wzero3keypad_softc *);
static uint32_t wzero3keypad_getkeydown(struct wzero3keypad_softc *, int);
static const struct wzero3keypad_model {
platid_mask_t *platid;
int intr_pin;
} wzero3keypad_table[] = {
#if 0
/* WS007SH */
{
&platid_mask_MACH_SHARP_WZERO3_WS007SH,
-1, /* XXX */
},
#endif
/* WS011SH */
{
&platid_mask_MACH_SHARP_WZERO3_WS011SH,
GPIO_WS011SH_KEYPAD,
},
{ NULL, -1, }
};
static const struct wzero3keypad_model *
wzero3keypad_lookup(void)
{
const struct wzero3keypad_model *model;
for (model = wzero3keypad_table; model->platid != NULL; model++) {
if (platid_match(&platid, model->platid)) {
return model;
}
}
return NULL;
}
static int
wzero3keypad_match(device_t parent, cfdata_t cf, void *aux)
{
if (strcmp(cf->cf_name, "wzero3keypad") != 0)
return 0;
if (wzero3keypad_lookup() == NULL)
return 0;
return 1;
}
static void
wzero3keypad_attach(device_t parent, device_t self, void *aux)
{
struct wzero3keypad_softc *sc = device_private(self);
const struct wzero3keypad_model *model;
struct wskbddev_attach_args wska;
#if NWZERO3LCD > 0
extern int screen_rotate;
#endif
sc->sc_dev = self;
sc->sc_okeystat = 0;
#ifdef WSDISPLAY_COMPAT_RAWKBD
sc->sc_rawkbd = 0;
#endif
model = wzero3keypad_lookup();
if (model == NULL) {
aprint_error(": unknown model\n");
return;
}
aprint_normal(": keypad\n");
aprint_naive("\n");
sc->sc_intr_pin = model->intr_pin;
callout_init(&sc->sc_poll_ch, 0);
callout_setfunc(&sc->sc_poll_ch, wzero3keypad_poll, sc);
sc->sc_poll_interval = hz / 32;
#if NWZERO3LCD > 0
switch (screen_rotate) {
default:
case 0:
break;
case 270: /* counter clock-wise */
ws011sh_keyscan2keydown[5] = KD_UP;
ws011sh_keyscan2keydown[9] = KD_RIGHT;
ws011sh_keyscan2keydown[10] = KD_LEFT;
ws011sh_keyscan2keydown[15] = KD_DOWN;
break;
}
#endif
/* attach wskbd */
wska.console = 0;
wska.keymap = &wzero3keypad_wskbd_keymapdata;
wska.accessops = &wzero3keypad_wskbd_accessops;
wska.accesscookie = sc;
sc->sc_wskbddev = config_found(self, &wska, wskbddevprint, CFARGS_NONE);
/* setup keypad interrupt */
pxa2x0_gpio_set_function(sc->sc_intr_pin, GPIO_IN);
sc->sc_ih = pxa2x0_gpio_intr_establish(sc->sc_intr_pin,
IST_EDGE_RISING, IPL_TTY, wzero3keypad_intr, sc);
if (sc->sc_ih == NULL) {
aprint_error_dev(sc->sc_dev,
"couldn't establish keypad interrupt\n");
}
/* init hardware */
wzero3keypad_init(sc);
}
static int
wzero3keypad_wskbd_enable(void *arg, int onoff)
{
return 0;
}
static void
wzero3keypad_wskbd_set_leds(void *arg, int leds)
{
/* Nothing to do */
}
static int
wzero3keypad_wskbd_ioctl(void *arg, u_long cmd, void *data, int flags,
struct lwp *l)
{
#ifdef WSDISPLAY_COMPAT_RAWKBD
struct wzero3keypad_softc *sc = (struct wzero3keypad_softc *)arg;
#endif
switch (cmd) {
case WSKBDIO_GTYPE:
*(int *)data = WSKBD_TYPE_HPC_KBD;
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);
return 0;
#endif
}
return EPASSTHROUGH;
}
static int
wzero3keypad_intr(void *arg)
{
struct wzero3keypad_softc *sc = (struct wzero3keypad_softc *)arg;
pxa2x0_gpio_clear_intr(sc->sc_intr_pin);
wzero3keypad_poll1(sc, 0);
callout_schedule(&sc->sc_poll_ch, sc->sc_poll_interval);
return 1;
}
static void
wzero3keypad_poll(void *v)
{
struct wzero3keypad_softc *sc = (struct wzero3keypad_softc *)v;
wzero3keypad_poll1(sc, 1);
callout_stop(&sc->sc_poll_ch);
}
static void
wzero3keypad_poll1(struct wzero3keypad_softc *sc, int doscan)
{
uint32_t keydown;
uint32_t diff;
int i;
int s;
s = spltty();
keydown = wzero3keypad_getkeydown(sc, doscan);
diff = keydown ^ sc->sc_okeystat;
if (diff == 0)
goto out;
for (i = 0; i < KD_NUM; i++) {
if (diff & (1 << i)) {
int state = keydown & (1 << i);
int type = state ? WSCONS_EVENT_KEY_DOWN :
WSCONS_EVENT_KEY_UP;
int key = wzero3keypad_wskbd_keys[i];
#ifdef WSDISPLAY_COMPAT_RAWKBD
if (sc->sc_rawkbd) {
int n;
u_char data[16];
n = pckbd_encode(type, key, data);
wskbd_rawinput(sc->sc_wskbddev, data, n);
} else
#endif
wskbd_input(sc->sc_wskbddev, type, key);
}
}
sc->sc_okeystat = keydown;
out:
splx(s);
}
/*----------------------------------------------------------------------------
* AK4184 keypad controller for WS011SH
*/
/* ak4184 command register */
#define AKMCTRL_WR_SH 7
#define AKMCTRL_PAGE_SH 6
#define AKMCTRL_ADDR_SH 0
#define AKMCTRL_WRITE (0<<AKMCTRL_WR_SH)
#define AKMCTRL_READ (1<<AKMCTRL_WR_SH)
#define AKMCTRL_DATA (0<<AKMCTRL_PAGE_SH)
#define AKMCTRL_CTRL (1<<AKMCTRL_PAGE_SH)
static void
wzero3keypad_init(struct wzero3keypad_softc *sc)
{
int s;
s = spltty();
#if 0
/*
* - key interrupt enable
* - key touch scan
* - debounce time: 1ms
* - wait 100us for debounce time
*/
(void) wzero3ssp_ic_send(WZERO3_SSP_IC_AK4184_KEYPAD,
AKMCTRL_WRITE | AKMCTRL_CTRL | (0<<AKMCTRL_ADDR_SH), 0);
#endif
/* unmask all keys & columns */
(void) wzero3ssp_ic_send(WZERO3_SSP_IC_AK4184_KEYPAD,
AKMCTRL_WRITE | AKMCTRL_CTRL | (1<<AKMCTRL_ADDR_SH), 0);
(void) wzero3ssp_ic_send(WZERO3_SSP_IC_AK4184_KEYPAD,
AKMCTRL_WRITE | AKMCTRL_CTRL | (2<<AKMCTRL_ADDR_SH), 0);
(void) wzero3ssp_ic_send(WZERO3_SSP_IC_AK4184_KEYPAD,
AKMCTRL_WRITE | AKMCTRL_CTRL | (3<<AKMCTRL_ADDR_SH), 0);
/* Enable keypad interrupt (kpdata dummy read) */
(void) wzero3ssp_ic_send(WZERO3_SSP_IC_AK4184_KEYPAD,
AKMCTRL_READ | AKMCTRL_DATA | (1<<AKMCTRL_ADDR_SH), 0);
splx(s);
}
static uint32_t
wzero3keypad_getkeydown(struct wzero3keypad_softc *sc, int doscan)
{
uint32_t keydown = 0;
uint16_t status;
uint16_t kpdata;
int timo;
if (doscan) {
/* host scan */
(void) wzero3ssp_ic_send(WZERO3_SSP_IC_AK4184_KEYPAD,
AKMCTRL_WRITE | AKMCTRL_CTRL | (4<<AKMCTRL_ADDR_SH), 0);
delay(100);
}
timo = 1000;
do {
status = wzero3ssp_ic_send(WZERO3_SSP_IC_AK4184_KEYPAD,
AKMCTRL_READ | AKMCTRL_CTRL | (0<<AKMCTRL_ADDR_SH), 0);
} while ((status & 0xc000) == 0 && timo-- > 0);
kpdata = wzero3ssp_ic_send(WZERO3_SSP_IC_AK4184_KEYPAD,
AKMCTRL_READ | AKMCTRL_DATA | (1<<AKMCTRL_ADDR_SH), 0);
if ((status & 0xc000) == 0xc000) {
if (!(kpdata & 0x8000)) {
int i;
for (i = 0; i < 3; i++) {
int key, bits;
key = kpdata & 0x1f;
if (key == 0)
break;
bits = ws011sh_keyscan2keydown[key];
if (bits != KD_INVALID)
keydown |= 1 << bits;
kpdata >>= 5;
}
}
}
return keydown;
}
