/*	$OpenBSD: aplhidev.c,v 1.13 2024/01/15 13:27:20 kettenis Exp $	*/
/*
 * Copyright (c) 2021 Mark Kettenis <kettenis@openbsd.org>
 * Copyright (c) 2013-2014 joshua stein <jcs@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/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/timeout.h>

#include <lib/libkern/crc16.h>

#include <machine/fdt.h>

#include <dev/spi/spivar.h>

#include <dev/ofw/openfirm.h>
#include <dev/ofw/ofw_gpio.h>
#include <dev/ofw/ofw_pinctrl.h>

#include <dev/usb/usbdevs.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wskbdvar.h>
#include <dev/wscons/wsksymdef.h>
#include <dev/wscons/wsmousevar.h>

#include <dev/hid/hid.h>
#include <dev/hid/hidkbdsc.h>
#include <dev/hid/hidmsvar.h>

#include "aplhidev.h"

#define APLHIDEV_READ_PACKET	0x20
#define APLHIDEV_WRITE_PACKET	0x40

#define APLHIDEV_KBD_DEVICE	1
#define APLHIDEV_TP_DEVICE	2
#define APLHIDEV_INFO_DEVICE	208

#define APLHIDEV_GET_INFO	0x0120
#define APLHIDEV_GET_DESCRIPTOR	0x1020
#define  APLHIDEV_DESC_MAX	512
#define APLHIDEV_KBD_REPORT	0x0110
#define APLHIDEV_TP_REPORT	0x0210
#define APLHIDEV_SET_LEDS	0x0151
#define APLHIDEV_SET_MODE	0x0252
#define  APLHIDEV_MODE_HID	0x00
#define  APLHIDEV_MODE_RAW	0x01
#define APLHIDEV_GET_DIMENSIONS	0xd932

struct aplhidev_dim {
	uint32_t width;
	uint32_t height;
	int16_t x_min;
	int16_t y_min;
	int16_t x_max;
	int16_t y_max;
};

struct aplhidev_attach_args {
	uint8_t	aa_reportid;
	void	*aa_desc;
	size_t	aa_desclen;
};

struct aplhidev_spi_packet {
	uint8_t		flags;
	uint8_t		device;
	uint16_t	offset;
	uint16_t	remaining;
	uint16_t	len;
	uint8_t		data[246];
	uint16_t	crc;
};

struct aplhidev_spi_status {
	uint8_t		status[4];
};

struct aplhidev_msghdr {
	uint16_t	type;
	uint8_t		device;
	uint8_t		msgid;
	uint16_t	rsplen;
	uint16_t	cmdlen;
};

struct aplhidev_info_hdr {
	uint16_t	unknown[2];
	uint16_t	num_devices;
	uint16_t	vendor;
	uint16_t	product;
	uint16_t	version;
	uint16_t	vendor_str[2];
	uint16_t	product_str[2];
	uint16_t	serial_str[2];
};

struct aplhidev_get_desc {
	struct aplhidev_msghdr	hdr;
	uint16_t		crc;
};

struct aplhidev_set_leds {
	struct aplhidev_msghdr	hdr;
	uint8_t			reportid;
	uint8_t			leds;
	uint16_t		crc;
};

struct aplhidev_set_mode {
	struct aplhidev_msghdr	hdr;
	uint8_t			reportid;
	uint8_t			mode;
	uint16_t		crc;
};

struct aplhidev_softc {
	struct device		sc_dev;
	int			sc_node;

	spi_tag_t		sc_spi_tag;
	struct spi_config	sc_spi_conf;

	uint8_t			sc_msgid;

	uint32_t		*sc_gpio;
	int			sc_gpiolen;

	uint8_t			sc_mode;
	uint16_t		sc_vendor;
	uint16_t		sc_product;

	struct device 		*sc_kbd;
	uint8_t			sc_kbddesc[APLHIDEV_DESC_MAX];
	size_t			sc_kbddesclen;

	struct device		*sc_ms;
	uint8_t			sc_tpdesc[APLHIDEV_DESC_MAX];
	size_t			sc_tpdesclen;
	uint8_t			sc_dimdesc[APLHIDEV_DESC_MAX];
	size_t			sc_dimdesclen;
	int			sc_x_min;
	int			sc_x_max;
	int			sc_y_min;
	int			sc_y_max;
	int			sc_h_res;
	int			sc_v_res;
};

int	 aplhidev_match(struct device *, void *, void *);
void	 aplhidev_attach(struct device *, struct device *, void *);

const struct cfattach aplhidev_ca = {
	sizeof(struct aplhidev_softc), aplhidev_match, aplhidev_attach
};

struct cfdriver aplhidev_cd = {
	NULL, "aplhidev", DV_DULL
};

void	aplhidev_get_info(struct aplhidev_softc *);
void	aplhidev_get_descriptor(struct aplhidev_softc *, uint8_t);
void	aplhidev_set_leds(struct aplhidev_softc *, uint8_t);
void	aplhidev_set_mode(struct aplhidev_softc *, uint8_t);
void	aplhidev_get_dimensions(struct aplhidev_softc *);

int	aplhidev_intr(void *);
void	aplkbd_intr(struct device *, uint8_t *, size_t);
void	aplms_intr(struct device *, uint8_t *, size_t);

int
aplhidev_match(struct device *parent, void *match, void *aux)
{
	struct spi_attach_args *sa = aux;

	if (strcmp(sa->sa_name, "apple,spi-hid-transport") == 0)
		return 1;

	return 0;
}

void
aplhidev_attach(struct device *parent, struct device *self, void *aux)
{
	struct aplhidev_softc *sc = (struct aplhidev_softc *)self;
	struct spi_attach_args *sa = aux;
	struct aplhidev_attach_args aa;
	struct aplhidev_dim dim;
	int retry;

	sc->sc_spi_tag = sa->sa_tag;
	sc->sc_node = *(int *)sa->sa_cookie;

	sc->sc_gpiolen = OF_getproplen(sc->sc_node, "spien-gpios");
	if (sc->sc_gpiolen > 0) {
		sc->sc_gpio = malloc(sc->sc_gpiolen, M_TEMP, M_WAITOK);
		OF_getpropintarray(sc->sc_node, "spien-gpios",
		    sc->sc_gpio, sc->sc_gpiolen);
		gpio_controller_config_pin(sc->sc_gpio, GPIO_CONFIG_OUTPUT);

		/* Reset */
		gpio_controller_set_pin(sc->sc_gpio, 1);
		delay(5000);
		gpio_controller_set_pin(sc->sc_gpio, 0);
		delay(5000);

		/* Enable. */
		gpio_controller_set_pin(sc->sc_gpio, 1);
		delay(50000);
	}

	sc->sc_spi_conf.sc_bpw = 8;
	sc->sc_spi_conf.sc_freq = OF_getpropint(sc->sc_node,
	    "spi-max-frequency", 0);
	sc->sc_spi_conf.sc_cs = OF_getpropint(sc->sc_node, "reg", 0);
	sc->sc_spi_conf.sc_cs_delay = 100;

	fdt_intr_establish(sc->sc_node, IPL_TTY,
	    aplhidev_intr, sc, sc->sc_dev.dv_xname);

	aplhidev_get_info(sc);
	for (retry = 10; retry > 0; retry--) {
		aplhidev_intr(sc);
		delay(1000);
		if (sc->sc_vendor != 0 && sc->sc_product != 0)
			break;
	}

	aplhidev_get_descriptor(sc, APLHIDEV_KBD_DEVICE);
	for (retry = 10; retry > 0; retry--) {
		aplhidev_intr(sc);
		delay(1000);
		if (sc->sc_kbddesclen > 0)
			break;
	}

	aplhidev_get_descriptor(sc, APLHIDEV_TP_DEVICE);
	for (retry = 10; retry > 0; retry--) {
		aplhidev_intr(sc);
		delay(1000);
		if (sc->sc_tpdesclen > 0)
			break;
	}

	sc->sc_mode = APLHIDEV_MODE_HID;
	aplhidev_set_mode(sc, APLHIDEV_MODE_RAW);
	for (retry = 10; retry > 0; retry--) {
		aplhidev_intr(sc);
		delay(1000);
		if (sc->sc_mode == APLHIDEV_MODE_RAW)
			break;
	}

	aplhidev_get_dimensions(sc);
	for (retry = 10; retry > 0; retry--) {
		aplhidev_intr(sc);
		delay(1000);
		if (sc->sc_dimdesclen > 0)
			break;
	}

	printf("\n");

	if (sc->sc_dimdesclen == sizeof(dim) + 1) {
		memcpy(&dim, &sc->sc_dimdesc[1], sizeof(dim));
		sc->sc_x_min = dim.x_min;
		sc->sc_x_max = dim.x_max;
		sc->sc_y_min = dim.y_min;
		sc->sc_y_max = dim.y_max;
		sc->sc_h_res = (100 * (dim.x_max - dim.x_min)) / dim.width;
		sc->sc_v_res = (100 * (dim.y_max - dim.y_min)) / dim.height;
	}

	if (sc->sc_kbddesclen > 0) {
		aa.aa_reportid = APLHIDEV_KBD_DEVICE;
		aa.aa_desc = sc->sc_kbddesc;
		aa.aa_desclen = sc->sc_kbddesclen;
		sc->sc_kbd = config_found(self, &aa, NULL);
	}

	if (sc->sc_tpdesclen > 0) {
		aa.aa_reportid = APLHIDEV_TP_DEVICE;
		aa.aa_desc = sc->sc_tpdesc;
		aa.aa_desclen = sc->sc_tpdesclen;
		sc->sc_ms = config_found(self, &aa, NULL);
	}
}

void
aplhidev_get_info(struct aplhidev_softc *sc)
{
	struct aplhidev_spi_packet packet;
	struct aplhidev_get_desc *msg;
	struct aplhidev_spi_status status;

	memset(&packet, 0, sizeof(packet));
	packet.flags = APLHIDEV_WRITE_PACKET;
	packet.device = APLHIDEV_INFO_DEVICE;
	packet.len = sizeof(*msg);

	msg = (void *)&packet.data[0];
	msg->hdr.type = APLHIDEV_GET_INFO;
	msg->hdr.device = APLHIDEV_INFO_DEVICE;
	msg->hdr.msgid = sc->sc_msgid++;
	msg->hdr.cmdlen = 0;
	msg->hdr.rsplen = APLHIDEV_DESC_MAX;
	msg->crc = crc16(0, (void *)msg, sizeof(*msg) - 2);

	packet.crc = crc16(0, (void *)&packet, sizeof(packet) - 2);

	spi_acquire_bus(sc->sc_spi_tag, 0);
	spi_config(sc->sc_spi_tag, &sc->sc_spi_conf);
	spi_transfer(sc->sc_spi_tag, (char *)&packet, NULL, sizeof(packet),
	    SPI_KEEP_CS);
	delay(100);
	spi_read(sc->sc_spi_tag, (char *)&status, sizeof(status));
	spi_release_bus(sc->sc_spi_tag, 0);

	delay(1000);
}

void
aplhidev_get_descriptor(struct aplhidev_softc *sc, uint8_t device)
{
	struct aplhidev_spi_packet packet;
	struct aplhidev_get_desc *msg;
	struct aplhidev_spi_status status;

	memset(&packet, 0, sizeof(packet));
	packet.flags = APLHIDEV_WRITE_PACKET;
	packet.device = APLHIDEV_INFO_DEVICE;
	packet.len = sizeof(*msg);

	msg = (void *)&packet.data[0];
	msg->hdr.type = APLHIDEV_GET_DESCRIPTOR;
	msg->hdr.device = device;
	msg->hdr.msgid = sc->sc_msgid++;
	msg->hdr.cmdlen = 0;
	msg->hdr.rsplen = APLHIDEV_DESC_MAX;
	msg->crc = crc16(0, (void *)msg, sizeof(*msg) - 2);

	packet.crc = crc16(0, (void *)&packet, sizeof(packet) - 2);

	spi_acquire_bus(sc->sc_spi_tag, 0);
	spi_config(sc->sc_spi_tag, &sc->sc_spi_conf);
	spi_transfer(sc->sc_spi_tag, (char *)&packet, NULL, sizeof(packet),
	    SPI_KEEP_CS);
	delay(100);
	spi_read(sc->sc_spi_tag, (char *)&status, sizeof(status));
	spi_release_bus(sc->sc_spi_tag, 0);

	delay(1000);
}

void
aplhidev_set_leds(struct aplhidev_softc *sc, uint8_t leds)
{
	struct aplhidev_spi_packet packet;
	struct aplhidev_set_leds *msg;
	struct aplhidev_spi_status status;

	memset(&packet, 0, sizeof(packet));
	packet.flags = APLHIDEV_WRITE_PACKET;
	packet.device = APLHIDEV_KBD_DEVICE;
	packet.len = sizeof(*msg);

	msg = (void *)&packet.data[0];
	msg->hdr.type = APLHIDEV_SET_LEDS;
	msg->hdr.device = APLHIDEV_KBD_DEVICE;
	msg->hdr.msgid = sc->sc_msgid++;
	msg->hdr.cmdlen = sizeof(*msg) - sizeof(struct aplhidev_msghdr) - 2;
	msg->hdr.rsplen = msg->hdr.cmdlen;
	msg->reportid = APLHIDEV_KBD_DEVICE;
	msg->leds = leds;
	msg->crc = crc16(0, (void *)msg, sizeof(*msg) - 2);

	packet.crc = crc16(0, (void *)&packet, sizeof(packet) - 2);

	/*
	 * XXX Without a delay here, the command will fail.  Does the
	 * controller need a bit of time between sending us a keypress
	 * event and accepting a new command from us?
	 */
	delay(250);

	spi_acquire_bus(sc->sc_spi_tag, 0);
	spi_config(sc->sc_spi_tag, &sc->sc_spi_conf);
	spi_transfer(sc->sc_spi_tag, (char *)&packet, NULL, sizeof(packet),
	    SPI_KEEP_CS);
	delay(100);
	spi_read(sc->sc_spi_tag, (char *)&status, sizeof(status));
	spi_release_bus(sc->sc_spi_tag, 0);
}

void
aplhidev_set_mode(struct aplhidev_softc *sc, uint8_t mode)
{
	struct aplhidev_spi_packet packet;
	struct aplhidev_set_mode *msg;
	struct aplhidev_spi_status status;

	memset(&packet, 0, sizeof(packet));
	packet.flags = APLHIDEV_WRITE_PACKET;
	packet.device = APLHIDEV_TP_DEVICE;
	packet.len = sizeof(*msg);

	msg = (void *)&packet.data[0];
	msg->hdr.type = APLHIDEV_SET_MODE;
	msg->hdr.device = APLHIDEV_TP_DEVICE;
	msg->hdr.msgid = sc->sc_msgid++;
	msg->hdr.cmdlen = sizeof(*msg) - sizeof(struct aplhidev_msghdr) - 2;
	msg->hdr.rsplen = msg->hdr.cmdlen;
	msg->reportid = APLHIDEV_TP_DEVICE;
	msg->mode = mode;
	msg->crc = crc16(0, (void *)msg, sizeof(*msg) - 2);

	packet.crc = crc16(0, (void *)&packet, sizeof(packet) - 2);

	spi_acquire_bus(sc->sc_spi_tag, 0);
	spi_config(sc->sc_spi_tag, &sc->sc_spi_conf);
	spi_transfer(sc->sc_spi_tag, (char *)&packet, NULL, sizeof(packet),
	    SPI_KEEP_CS);
	delay(100);
	spi_read(sc->sc_spi_tag, (char *)&status, sizeof(status));
	spi_release_bus(sc->sc_spi_tag, 0);

	delay(1000);
}

void
aplhidev_get_dimensions(struct aplhidev_softc *sc)
{
	struct aplhidev_spi_packet packet;
	struct aplhidev_get_desc *msg;
	struct aplhidev_spi_status status;

	memset(&packet, 0, sizeof(packet));
	packet.flags = APLHIDEV_WRITE_PACKET;
	packet.device = APLHIDEV_TP_DEVICE;
	packet.len = sizeof(*msg);

	msg = (void *)&packet.data[0];
	msg->hdr.type = APLHIDEV_GET_DIMENSIONS;
	msg->hdr.device = 0;
	msg->hdr.msgid = sc->sc_msgid++;
	msg->hdr.cmdlen = 0;
	msg->hdr.rsplen = APLHIDEV_DESC_MAX;
	msg->crc = crc16(0, (void *)msg, sizeof(*msg) - 2);

	packet.crc = crc16(0, (void *)&packet, sizeof(packet) - 2);

	spi_acquire_bus(sc->sc_spi_tag, 0);
	spi_config(sc->sc_spi_tag, &sc->sc_spi_conf);
	spi_transfer(sc->sc_spi_tag, (char *)&packet, NULL, sizeof(packet),
	    SPI_KEEP_CS);
	delay(100);
	spi_read(sc->sc_spi_tag, (char *)&status, sizeof(status));
	spi_release_bus(sc->sc_spi_tag, 0);

	delay(1000);
}

int
aplhidev_intr(void *arg)
{
	struct aplhidev_softc *sc = arg;
	struct aplhidev_spi_packet packet;
	struct aplhidev_msghdr *hdr = (struct aplhidev_msghdr *)&packet.data[0];

	memset(&packet, 0, sizeof(packet));
	spi_acquire_bus(sc->sc_spi_tag, 0);
	spi_config(sc->sc_spi_tag, &sc->sc_spi_conf);
	spi_read(sc->sc_spi_tag, (char *)&packet, sizeof(packet));
	spi_release_bus(sc->sc_spi_tag, 0);

	/* Treat empty packets as spurious interrupts. */
	if (packet.flags == 0 && packet.device == 0 && packet.crc == 0)
		return 0;

	if (crc16(0, (uint8_t *)&packet, sizeof(packet)))
		return 1;

	/* Keyboard input. */
	if (packet.flags == APLHIDEV_READ_PACKET &&
	    packet.device == APLHIDEV_KBD_DEVICE &&
	    hdr->type == APLHIDEV_KBD_REPORT) {
		if (sc->sc_kbd)
			aplkbd_intr(sc->sc_kbd, &packet.data[8], hdr->cmdlen);
		return 1;
	}

	/* Touchpad input. */
	if (packet.flags == APLHIDEV_READ_PACKET &&
	    packet.device == APLHIDEV_TP_DEVICE &&
	    hdr->type == APLHIDEV_TP_REPORT) {
		if (sc->sc_ms)
			aplms_intr(sc->sc_ms, &packet.data[8], hdr->cmdlen);
		return 1;
	}

	/* Replies to commands we sent. */
	if (packet.flags == APLHIDEV_WRITE_PACKET &&
	    packet.device == APLHIDEV_INFO_DEVICE &&
	    hdr->type == APLHIDEV_GET_INFO) {
		struct aplhidev_info_hdr *info =
		    (struct aplhidev_info_hdr *)&packet.data[8];
		sc->sc_vendor = info->vendor;
		sc->sc_product = info->product;
		return 1;
	}
	if (packet.flags == APLHIDEV_WRITE_PACKET &&
	    packet.device == APLHIDEV_INFO_DEVICE &&
	    hdr->type == APLHIDEV_GET_DESCRIPTOR) {
		switch (hdr->device) {
		case APLHIDEV_KBD_DEVICE:
			memcpy(sc->sc_kbddesc, &packet.data[8], hdr->cmdlen);
			sc->sc_kbddesclen = hdr->cmdlen;
			break;
		case APLHIDEV_TP_DEVICE:
			memcpy(sc->sc_tpdesc, &packet.data[8], hdr->cmdlen);
			sc->sc_tpdesclen = hdr->cmdlen;
			break;
		}

		return 1;
	}
	if (packet.flags == APLHIDEV_WRITE_PACKET &&
	    packet.device == APLHIDEV_TP_DEVICE &&
	    hdr->type == APLHIDEV_SET_MODE) {
		sc->sc_mode = APLHIDEV_MODE_RAW;
		return 1;
	}
	if (packet.flags == APLHIDEV_WRITE_PACKET &&
	    packet.device == APLHIDEV_TP_DEVICE &&
	    hdr->type == APLHIDEV_GET_DIMENSIONS) {
		memcpy(sc->sc_dimdesc, &packet.data[8], hdr->cmdlen);
		sc->sc_dimdesclen = hdr->cmdlen;
		return 1;
	}

	/* Valid, but unrecognized packet; ignore for now. */
	return 1;
}

/* Keyboard */

struct aplkbd_softc {
	struct device		sc_dev;
	struct aplhidev_softc	*sc_hidev;
	struct hidkbd		sc_kbd;
	int			sc_spl;
};

void	aplkbd_cngetc(void *, u_int *, int *);
void	aplkbd_cnpollc(void *, int);
void	aplkbd_cnbell(void *, u_int, u_int, u_int);

const struct wskbd_consops aplkbd_consops = {
	aplkbd_cngetc,
	aplkbd_cnpollc,
	aplkbd_cnbell,
};

int	aplkbd_enable(void *, int);
void	aplkbd_set_leds(void *, int);
int	aplkbd_ioctl(void *, u_long, caddr_t, int, struct proc *);

const struct wskbd_accessops aplkbd_accessops = {
	.enable = aplkbd_enable,
	.ioctl = aplkbd_ioctl,
	.set_leds = aplkbd_set_leds,
};

int	 aplkbd_match(struct device *, void *, void *);
void	 aplkbd_attach(struct device *, struct device *, void *);

const struct cfattach aplkbd_ca = {
	sizeof(struct aplkbd_softc), aplkbd_match, aplkbd_attach
};

struct cfdriver aplkbd_cd = {
	NULL, "aplkbd", DV_DULL
};

int
aplkbd_match(struct device *parent, void *match, void *aux)
{
	struct aplhidev_attach_args *aa = (struct aplhidev_attach_args *)aux;

	return (aa->aa_reportid == APLHIDEV_KBD_DEVICE);
}

void
aplkbd_attach(struct device *parent, struct device *self, void *aux)
{
	struct aplkbd_softc *sc = (struct aplkbd_softc *)self;
	struct aplhidev_attach_args *aa = (struct aplhidev_attach_args *)aux;
	struct hidkbd *kbd = &sc->sc_kbd;

	sc->sc_hidev = (struct aplhidev_softc *)parent;
	if (hidkbd_attach(self, kbd, 1, 0, APLHIDEV_KBD_DEVICE,
	    aa->aa_desc, aa->aa_desclen))
		return;

	printf("\n");

	if (hid_locate(aa->aa_desc, aa->aa_desclen, HID_USAGE2(HUP_APPLE, HUG_FN_KEY),
	    1, hid_input, &kbd->sc_fn, NULL)) {
		switch (sc->sc_hidev->sc_product) {
		case USB_PRODUCT_APPLE_WELLSPRINGM1_J293:
			kbd->sc_munge = hidkbd_apple_tb_munge;
			break;
		default:
			kbd->sc_munge = hidkbd_apple_munge;
			break;
		}
	}

	if (kbd->sc_console_keyboard) {
		extern struct wskbd_mapdata ukbd_keymapdata;

		ukbd_keymapdata.layout = KB_US | KB_DEFAULT;
		wskbd_cnattach(&aplkbd_consops, sc, &ukbd_keymapdata);
		aplkbd_enable(sc, 1);
	}

	hidkbd_attach_wskbd(kbd, KB_US | KB_DEFAULT, &aplkbd_accessops);
}

void
aplkbd_intr(struct device *self, uint8_t *packet, size_t packetlen)
{
	struct aplkbd_softc *sc = (struct aplkbd_softc *)self;
	struct hidkbd *kbd = &sc->sc_kbd;

	if (kbd->sc_enabled)
		hidkbd_input(kbd, &packet[1], packetlen - 1);
}

int
aplkbd_enable(void *v, int on)
{
	struct aplkbd_softc *sc = v;
	struct hidkbd *kbd = &sc->sc_kbd;

	return hidkbd_enable(kbd, on);
}

int
aplkbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
{
	struct aplkbd_softc *sc = v;
	struct hidkbd *kbd = &sc->sc_kbd;

	switch (cmd) {
	case WSKBDIO_GTYPE:
		/* XXX: should we set something else? */
		*(u_int *)data = WSKBD_TYPE_USB;
		return 0;
	case WSKBDIO_SETLEDS:
		aplkbd_set_leds(v, *(int *)data);
		return 0;
	default:
		return hidkbd_ioctl(kbd, cmd, data, flag, p);
	}
}

void
aplkbd_set_leds(void *v, int leds)
{
	struct aplkbd_softc *sc = v;
	struct hidkbd *kbd = &sc->sc_kbd;
	uint8_t res;

	if (hidkbd_set_leds(kbd, leds, &res))
		aplhidev_set_leds(sc->sc_hidev, res);
}

/* Console interface. */
void
aplkbd_cngetc(void *v, u_int *type, int *data)
{
	struct aplkbd_softc *sc = v;
	struct hidkbd *kbd = &sc->sc_kbd;

	kbd->sc_polling = 1;
	while (kbd->sc_npollchar <= 0) {
		aplhidev_intr(sc->sc_dev.dv_parent);
		delay(1000);
	}
	kbd->sc_polling = 0;
	hidkbd_cngetc(kbd, type, data);
}

void
aplkbd_cnpollc(void *v, int on)
{
	struct aplkbd_softc *sc = v;

	if (on)
		sc->sc_spl = spltty();
	else
		splx(sc->sc_spl);
}

void
aplkbd_cnbell(void *v, u_int pitch, u_int period, u_int volume)
{
	hidkbd_bell(pitch, period, volume, 1);
}

#if NAPLMS > 0

/* Touchpad */

/*
 * The contents of the touchpad event packets is identical to those
 * used by the ubcmtp(4) driver.  The relevant definitions and the
 * code to decode the packets is replicated here.
 */

struct ubcmtp_finger {
	uint16_t	origin;
	uint16_t	abs_x;
	uint16_t	abs_y;
	uint16_t	rel_x;
	uint16_t	rel_y;
	uint16_t	tool_major;
	uint16_t	tool_minor;
	uint16_t	orientation;
	uint16_t	touch_major;
	uint16_t	touch_minor;
	uint16_t	unused[2];
	uint16_t	pressure;
	uint16_t	multi;
} __packed __attribute((aligned(2)));

#define UBCMTP_MAX_FINGERS	16

#define UBCMTP_TYPE4_TPOFF	(24 * sizeof(uint16_t))
#define UBCMTP_TYPE4_BTOFF	31
#define UBCMTP_TYPE4_FINGERPAD	(1 * sizeof(uint16_t))

/* Use a constant, synaptics-compatible pressure value for now. */
#define DEFAULT_PRESSURE	40

static struct wsmouse_param aplms_wsmousecfg[] = {
	{ WSMOUSECFG_MTBTN_MAXDIST, 0 }, /* 0: Compute a default value. */
};

struct aplms_softc {
	struct device		sc_dev;
	struct aplhidev_softc	*sc_hidev;
	struct device		*sc_wsmousedev;

	int			sc_enabled;

	int			tp_offset;
	int			tp_fingerpad;

	struct mtpoint		frame[UBCMTP_MAX_FINGERS];
	int			contacts;
	int			btn;
};

int	aplms_enable(void *);
void	aplms_disable(void *);
int	aplms_ioctl(void *, u_long, caddr_t, int, struct proc *);

const struct wsmouse_accessops aplms_accessops = {
	.enable = aplms_enable,
	.disable = aplms_disable,
	.ioctl = aplms_ioctl,
};

int	 aplms_match(struct device *, void *, void *);
void	 aplms_attach(struct device *, struct device *, void *);

const struct cfattach aplms_ca = {
	sizeof(struct aplms_softc), aplms_match, aplms_attach
};

struct cfdriver aplms_cd = {
	NULL, "aplms", DV_DULL
};

int	aplms_configure(struct aplms_softc *);

int
aplms_match(struct device *parent, void *match, void *aux)
{
	struct aplhidev_attach_args *aa = (struct aplhidev_attach_args *)aux;

	return (aa->aa_reportid == APLHIDEV_TP_DEVICE);
}

void
aplms_attach(struct device *parent, struct device *self, void *aux)
{
	struct aplms_softc *sc = (struct aplms_softc *)self;
	struct wsmousedev_attach_args aa;

	sc->sc_hidev = (struct aplhidev_softc *)parent;

	printf("\n");

	sc->tp_offset = UBCMTP_TYPE4_TPOFF;
	sc->tp_fingerpad = UBCMTP_TYPE4_FINGERPAD;

	aa.accessops = &aplms_accessops;
	aa.accesscookie = sc;

	sc->sc_wsmousedev = config_found(self, &aa, wsmousedevprint);
	if (sc->sc_wsmousedev != NULL && aplms_configure(sc))
		aplms_disable(sc);
}

int
aplms_configure(struct aplms_softc *sc)
{
	struct wsmousehw *hw = wsmouse_get_hw(sc->sc_wsmousedev);

	hw->type = WSMOUSE_TYPE_TOUCHPAD;
	hw->hw_type = WSMOUSEHW_CLICKPAD;
	hw->x_min = sc->sc_hidev->sc_x_min;
	hw->x_max = sc->sc_hidev->sc_x_max;
	hw->y_min = sc->sc_hidev->sc_y_min;
	hw->y_max = sc->sc_hidev->sc_y_max;
	hw->h_res = sc->sc_hidev->sc_h_res;
	hw->v_res = sc->sc_hidev->sc_v_res;
	hw->mt_slots = UBCMTP_MAX_FINGERS;
	hw->flags = WSMOUSEHW_MT_TRACKING;

	return wsmouse_configure(sc->sc_wsmousedev,
	    aplms_wsmousecfg, nitems(aplms_wsmousecfg));
}

void
aplms_intr(struct device *self, uint8_t *packet, size_t packetlen)
{
	struct aplms_softc *sc = (struct aplms_softc *)self;
	struct ubcmtp_finger *finger;
	int off, s, btn, contacts;

	if (!sc->sc_enabled)
		return;

	contacts = 0;
	for (off = sc->tp_offset; off < packetlen;
	    off += (sizeof(struct ubcmtp_finger) + sc->tp_fingerpad)) {
		finger = (struct ubcmtp_finger *)(packet + off);

		if ((int16_t)letoh16(finger->touch_major) == 0)
			continue; /* finger lifted */

		sc->frame[contacts].x = (int16_t)letoh16(finger->abs_x);
		sc->frame[contacts].y = (int16_t)letoh16(finger->abs_y);
		sc->frame[contacts].pressure = DEFAULT_PRESSURE;
		contacts++;
	}

	btn = sc->btn;
	sc->btn = !!((int16_t)letoh16(packet[UBCMTP_TYPE4_BTOFF]));

	if (contacts || sc->contacts || sc->btn != btn) {
		sc->contacts = contacts;
		s = spltty();
		wsmouse_buttons(sc->sc_wsmousedev, sc->btn);
		wsmouse_mtframe(sc->sc_wsmousedev, sc->frame, contacts);
		wsmouse_input_sync(sc->sc_wsmousedev);
		splx(s);
	}
}

int
aplms_enable(void *v)
{
	struct aplms_softc *sc = v;

	if (sc->sc_enabled)
		return EBUSY;

	sc->sc_enabled = 1;
	return 0;
}

void
aplms_disable(void *v)
{
	struct aplms_softc *sc = v;

	sc->sc_enabled = 0;
}

int
aplms_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
{
	struct aplms_softc *sc = v;
	struct wsmousehw *hw = wsmouse_get_hw(sc->sc_wsmousedev);
	struct wsmouse_calibcoords *wsmc = (struct wsmouse_calibcoords *)data;
	int wsmode;

	switch (cmd) {
	case WSMOUSEIO_GTYPE:
		*(u_int *)data = hw->type;
		break;

	case WSMOUSEIO_GCALIBCOORDS:
		wsmc->minx = hw->x_min;
		wsmc->maxx = hw->x_max;
		wsmc->miny = hw->y_min;
		wsmc->maxy = hw->y_max;
		wsmc->swapxy = 0;
		wsmc->resx = hw->h_res;
		wsmc->resy = hw->v_res;
		break;

	case WSMOUSEIO_SETMODE:
		wsmode = *(u_int *)data;
		if (wsmode != WSMOUSE_COMPAT && wsmode != WSMOUSE_NATIVE) {
			printf("%s: invalid mode %d\n", sc->sc_dev.dv_xname,
			    wsmode);
			return (EINVAL);
		}
		wsmouse_set_mode(sc->sc_wsmousedev, wsmode);
		break;

	default:
		return -1;
	}

	return 0;
}

#else

void
aplms_intr(struct device *self, uint8_t *packet, size_t packetlen)
{
}

#endif