xref: /src/sys/arch/hpcarm/dev/wzero3_keypad.c

/*	$NetBSD: wzero3_keypad.c,v 1.6 2021/08/07 16:18:53 thorpej Exp $	*/

/*-
 * Copyright (C) 2010 NONAKA Kimihiro <nonaka (at) netbsd.org>
 * 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;
}