src/sys/arch/arm64/dev/apldc.c

/*	$OpenBSD: apldc.c,v 1.12 2024/01/20 08:00:59 kettenis Exp $	*/
/*
 * Copyright (c) 2022 Mark Kettenis <kettenis@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/device.h>
#include <sys/evcount.h>
#include <sys/malloc.h>
#include <sys/task.h>
#include <sys/timeout.h>

#include <machine/bus.h>
#include <machine/fdt.h>

#include <dev/ofw/openfirm.h>
#include <dev/ofw/ofw_gpio.h>
#include <dev/ofw/fdt.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 <arm64/dev/rtkit.h>
#include <machine/simplebusvar.h>

#include "apldc.h"

#define DC_IRQ_MASK		0x0000
#define DC_IRQ_STAT		0x0004

#define DC_CONFIG_TX_THRESH	0x0000
#define DC_CONFIG_RX_THRESH	0x0004

#define DC_DATA_TX8		0x0004
#define DC_DATA_TX32		0x0010
#define DC_DATA_TX_FREE		0x0014
#define DC_DATA_RX8		0x001c
#define  DC_DATA_RX8_COUNT(d)	((d) & 0x7f)
#define  DC_DATA_RX8_DATA(d)	(((d) >> 8) & 0xff)
#define DC_DATA_RX32		0x0028
#define DC_DATA_RX_COUNT	0x002c

#define APLDC_MAX_INTR		32

#define HREAD4(sc, reg)							\
	(bus_space_read_4((sc)->sc_iot, (sc)->sc_ioh, (reg)))
#define HWRITE4(sc, reg, val)						\
	bus_space_write_4((sc)->sc_iot, (sc)->sc_ioh, (reg), (val))
#define HSET4(sc, reg, bits)						\
	HWRITE4((sc), (reg), HREAD4((sc), (reg)) | (bits))
#define HCLR4(sc, reg, bits)						\
	HWRITE4((sc), (reg), HREAD4((sc), (reg)) & ~(bits))

struct apldchidev_attach_args {
	const char *aa_name;
	void	*aa_desc;
	size_t	aa_desclen;
};

struct intrhand {
	int (*ih_func)(void *);
	void *ih_arg;
	int ih_ipl;
	int ih_irq;
	int ih_level;
	struct evcount ih_count;
	char *ih_name;
	void *ih_sc;
};

struct apldc_softc {
	struct simplebus_softc	sc_sbus;
	bus_space_tag_t		sc_iot;
	bus_space_handle_t	sc_ioh;

	void			*sc_ih;
	struct intrhand		*sc_handlers[APLDC_MAX_INTR];
	struct interrupt_controller sc_ic;
};

int	apldc_match(struct device *, void *, void *);
void	apldc_attach(struct device *, struct device *, void *);

const struct cfattach apldc_ca = {
	sizeof (struct apldc_softc), apldc_match, apldc_attach
};

struct cfdriver apldc_cd = {
	NULL, "apldc", DV_DULL
};

int	apldc_intr(void *);
void	*apldc_intr_establish(void *, int *, int, struct cpu_info *,
	    int (*)(void *), void *, char *);
void	apldc_intr_enable(void *);
void	apldc_intr_disable(void *);
void	apldc_intr_barrier(void *);

int
apldc_match(struct device *parent, void *match, void *aux)
{
	struct fdt_attach_args *faa = aux;

	return OF_is_compatible(faa->fa_node, "apple,dockchannel");
}

void
apldc_attach(struct device *parent, struct device *self, void *aux)
{
	struct apldc_softc *sc = (struct apldc_softc *)self;
	struct fdt_attach_args *faa = aux;

	if (faa->fa_nreg < 1) {
		printf(": no registers\n");
		return;
	}

	sc->sc_iot = faa->fa_iot;
	if (bus_space_map(sc->sc_iot, faa->fa_reg[0].addr,
	    faa->fa_reg[0].size, 0, &sc->sc_ioh)) {
		printf(": can't map registers\n");
		return;
	}

	/* Disable and clear all interrupts. */
	HWRITE4(sc, DC_IRQ_MASK, 0);
	HWRITE4(sc, DC_IRQ_STAT, 0xffffffff);

	sc->sc_ih = fdt_intr_establish(faa->fa_node, IPL_TTY,
	    apldc_intr, sc, sc->sc_sbus.sc_dev.dv_xname);

	sc->sc_ic.ic_node = faa->fa_node;
	sc->sc_ic.ic_cookie = sc;
	sc->sc_ic.ic_establish = apldc_intr_establish;
	sc->sc_ic.ic_enable = apldc_intr_enable;
	sc->sc_ic.ic_disable = apldc_intr_disable;
	sc->sc_ic.ic_barrier = apldc_intr_barrier;
	fdt_intr_register(&sc->sc_ic);

	simplebus_attach(parent, &sc->sc_sbus.sc_dev, faa);
}

int
apldc_intr(void *arg)
{
	struct apldc_softc *sc = arg;
	struct intrhand *ih;
	uint32_t stat, pending;
	int irq, s;

	stat = HREAD4(sc, DC_IRQ_STAT);

	pending = stat;
	while (pending) {
		irq = ffs(pending) - 1;
		ih = sc->sc_handlers[irq];
		if (ih) {
			s = splraise(ih->ih_ipl);
			if (ih->ih_func(ih->ih_arg))
				ih->ih_count.ec_count++;
			splx(s);
		}

		pending &= ~(1 << irq);
	}

	HWRITE4(sc, DC_IRQ_STAT, stat);

	return 1;
}

void *
apldc_intr_establish(void *cookie, int *cells, int ipl,
    struct cpu_info *ci, int (*func)(void *), void *arg, char *name)
{
	struct apldc_softc *sc = cookie;
	struct intrhand *ih;
	int irq = cells[0];
	int level = cells[1];

	if (irq < 0 || irq >= APLDC_MAX_INTR)
		return NULL;

	if (ipl != IPL_TTY)
		return NULL;

	if (ci != NULL && !CPU_IS_PRIMARY(ci))
		return NULL;

	if (sc->sc_handlers[irq])
		return NULL;

	ih = malloc(sizeof(*ih), M_DEVBUF, M_WAITOK);
	ih->ih_func = func;
	ih->ih_arg = arg;
	ih->ih_ipl = ipl & IPL_IRQMASK;
	ih->ih_irq = irq;
	ih->ih_name = name;
	ih->ih_level = level;
	ih->ih_sc = sc;

	sc->sc_handlers[irq] = ih;

	if (name != NULL)
		evcount_attach(&ih->ih_count, name, &ih->ih_irq);

	return ih;
}

void
apldc_intr_enable(void *cookie)
{
	struct intrhand	*ih = cookie;
	struct apldc_softc *sc = ih->ih_sc;

	HSET4(sc, DC_IRQ_MASK, 1 << ih->ih_irq);
}

void
apldc_intr_disable(void *cookie)
{
	struct intrhand	*ih = cookie;
	struct apldc_softc *sc = ih->ih_sc;

	HCLR4(sc, DC_IRQ_MASK, 1 << ih->ih_irq);
}

void
apldc_intr_barrier(void *cookie)
{
	struct intrhand	*ih = cookie;
	struct apldc_softc *sc = ih->ih_sc;

	intr_barrier(sc->sc_ih);
}

#define APLDCHIDEV_DESC_MAX	512
#define APLDCHIDEV_PKT_MAX	1024
#define APLDCHIDEV_GPIO_MAX	4

#define APLDCHIDEV_NUM_GPIOS	16

struct apldchidev_gpio {
	struct apldchidev_softc	*ag_sc;
	uint8_t			ag_id;
	uint8_t			ag_iface;
	uint32_t		ag_gpio[APLDCHIDEV_GPIO_MAX];
	struct task		ag_task;
};

struct apldchidev_softc {
	struct device		sc_dev;
	bus_space_tag_t		sc_iot;
	bus_space_handle_t	sc_cfg_ioh;
	bus_space_handle_t	sc_data_ioh;

	bus_dma_tag_t		sc_dmat;
	int			sc_node;

	void			*sc_rx_ih;

	uint8_t			sc_seq_comm;

	uint8_t			sc_iface_stm;
	uint8_t			sc_seq_stm;
	uint8_t			sc_stmdesc[APLDCHIDEV_DESC_MAX];
	size_t			sc_stmdesclen;
	int			sc_stm_ready;

	uint8_t			sc_iface_kbd;
	uint8_t			sc_seq_kbd;
	struct device		*sc_kbd;
	uint8_t			sc_kbddesc[APLDCHIDEV_DESC_MAX];
	size_t			sc_kbddesclen;
	int			sc_kbd_ready;

	uint8_t			sc_iface_mt;
	uint8_t			sc_seq_mt;
	struct device		*sc_mt;
	uint8_t			sc_mtdesc[APLDCHIDEV_DESC_MAX];
	size_t			sc_mtdesclen;
	int			sc_mt_ready;
	int			sc_x_min;
	int			sc_x_max;
	int			sc_y_min;
	int			sc_y_max;
	int			sc_h_res;
	int			sc_v_res;

	struct apldchidev_gpio	sc_gpio[APLDCHIDEV_NUM_GPIOS];
	u_int			sc_ngpios;
	uint8_t			sc_gpio_cmd[APLDCHIDEV_PKT_MAX];
	size_t			sc_gpio_cmd_len;

	uint8_t			sc_cmd_iface;
	uint8_t			sc_cmd_seq;
	uint8_t			sc_data[APLDCHIDEV_DESC_MAX];
	size_t			sc_data_len;
	uint32_t		sc_retcode;
	int			sc_busy;
};

int	apldchidev_match(struct device *, void *, void *);
void	apldchidev_attach(struct device *, struct device *, void *);

const struct cfattach apldchidev_ca = {
	sizeof(struct apldchidev_softc), apldchidev_match, apldchidev_attach
};

struct cfdriver apldchidev_cd = {
	NULL, "apldchidev", DV_DULL
};

void	apldchidev_attachhook(struct device *);
void	apldchidev_cmd(struct apldchidev_softc *, uint8_t, uint8_t,
	    void *, size_t);
void	apldchidev_wait(struct apldchidev_softc *);
int	apldchidev_send_firmware(struct apldchidev_softc *, int,
	    void *, size_t);
void	apldchidev_enable(struct apldchidev_softc *, uint8_t);
void	apldchidev_reset(struct apldchidev_softc *, uint8_t, uint8_t);
int	apldchidev_rx_intr(void *);
void	apldchidev_gpio_task(void *);

int
apldchidev_match(struct device *parent, void *cfdata, void *aux)
{
	struct fdt_attach_args *faa = aux;

	return OF_is_compatible(faa->fa_node, "apple,dockchannel-hid");
}

void
apldchidev_attach(struct device *parent, struct device *self, void *aux)
{
	struct apldchidev_softc *sc = (struct apldchidev_softc *)self;
	struct fdt_attach_args *faa = aux;
	struct apldchidev_attach_args aa;
	uint32_t phandle;
	int error, idx, retry;

	if (faa->fa_nreg < 2) {
		printf(": no registers\n");
		return;
	}

	sc->sc_iot = faa->fa_iot;
	if (bus_space_map(sc->sc_iot, faa->fa_reg[0].addr,
	    faa->fa_reg[0].size, 0, &sc->sc_cfg_ioh)) {
		printf(": can't map registers\n");
		return;
	}
	if (bus_space_map(sc->sc_iot, faa->fa_reg[1].addr,
	    faa->fa_reg[1].size, 0, &sc->sc_data_ioh)) {
		printf(": can't map registers\n");
		return;
	}

	sc->sc_dmat = faa->fa_dmat;
	sc->sc_node = faa->fa_node;

	idx = OF_getindex(faa->fa_node, "rx", "interrupt-names");
	if (idx < 0) {
		printf(": no rx interrupt\n");
		return;
	}
	sc->sc_rx_ih = fdt_intr_establish_idx(faa->fa_node, idx, IPL_TTY,
	    apldchidev_rx_intr, sc, sc->sc_dev.dv_xname);
	if (sc->sc_rx_ih == NULL) {
		printf(": can't establish interrupt\n");
		return;
	}

	phandle = OF_getpropint(faa->fa_node, "apple,helper-cpu", 0);
	if (phandle) {
		error = aplrtk_start(phandle);
		if (error) {
			printf(": can't start helper CPU\n");
			return;
		}
	}

	printf("\n");

	/* Poll until we have received the STM HID descriptor. */
	for (retry = 10; retry > 0; retry--) {
		if (sc->sc_stmdesclen > 0)
			break;
		apldchidev_rx_intr(sc);
		delay(1000);
	}

	if (sc->sc_stmdesclen > 0) {
		/* Enable interface. */
		apldchidev_enable(sc, sc->sc_iface_stm);
	}

	/* Poll until we have received the keyboard HID descriptor. */
	for (retry = 10; retry > 0; retry--) {
		if (sc->sc_kbddesclen > 0)
			break;
		apldchidev_rx_intr(sc);
		delay(1000);
	}

	if (sc->sc_kbddesclen > 0) {
		/* Enable interface. */
		apldchidev_enable(sc, sc->sc_iface_kbd);

		aa.aa_name = "keyboard";
		aa.aa_desc = sc->sc_kbddesc;
		aa.aa_desclen = sc->sc_kbddesclen;
		sc->sc_kbd = config_found(self, &aa, NULL);
	}

	bus_space_write_4(sc->sc_iot, sc->sc_cfg_ioh, DC_CONFIG_RX_THRESH, 8);
	fdt_intr_enable(sc->sc_rx_ih);

#if NAPLDCMS > 0
	config_mountroot(self, apldchidev_attachhook);
#endif
}

int
apldchidev_read(struct apldchidev_softc *sc, void *buf, size_t len,
    uint32_t *checksum)
{
	uint8_t *dst = buf;
	uint32_t data;
	int shift = 0;

	while (len > 0) {
		data = bus_space_read_4(sc->sc_iot, sc->sc_data_ioh,
		    DC_DATA_RX8);
		if (DC_DATA_RX8_COUNT(data) > 0) {
			*dst++ = DC_DATA_RX8_DATA(data);
			*checksum += (DC_DATA_RX8_DATA(data) << shift);
			shift += 8;
			if (shift > 24)
				shift = 0;
			len--;
		} else {
			delay(10);
		}
	}

	return 0;
}

int
apldchidev_write(struct apldchidev_softc *sc, const void *buf, size_t len,
    uint32_t *checksum)
{
	const uint8_t *src = buf;
	uint32_t free;
	int shift = 0;

	while (len > 0) {
		free = bus_space_read_4(sc->sc_iot, sc->sc_data_ioh,
		    DC_DATA_TX_FREE);
		if (free > 0) {
			if (checksum)
				*checksum -= *src << shift;
			bus_space_write_4(sc->sc_iot, sc->sc_data_ioh,
			    DC_DATA_TX8, *src++);
			shift += 8;
			if (shift > 24)
				shift = 0;
			len--;
		} else {
			delay(10);
		}
	}

	return 0;
}

struct mtp_hdr {
	uint8_t hdr_len;
	uint8_t chan;
#define MTP_CHAN_CMD		0x11
#define MTP_CHAN_REPORT		0x12
	uint16_t pkt_len;
	uint8_t seq;
	uint8_t iface;
#define MTP_IFACE_COMM		0
	uint16_t pad;
} __packed;

struct mtp_subhdr {
	uint8_t flags;
#define MTP_GROUP_SHIFT	6
#define MTP_GROUP(x)		((x >> 6) & 0x3)
#define MTP_GROUP_INPUT	0
#define MTP_GROUP_OUTPUT	1
#define MTP_GROUP_CMD		2
#define MTP_REQ_SHIFT		0
#define MTP_REQ(x)		((x >> 0) & 0x3f)
#define MTP_REQ_SET_REPORT	0
#define MTP_REQ_GET_REPORT	1
	uint8_t unk;
	uint16_t len;
	uint32_t retcode;
} __packed;

struct mtp_init_hdr {
	uint8_t type;
#define MTP_EVENT_GPIO_CMD	0xa0
#define MTP_EVENT_INIT	0xf0
#define MTP_EVENT_READY	0xf1
	uint8_t unk1;
	uint8_t unk2;
	uint8_t iface;
	char name[16];
} __packed;

struct mtp_init_block_hdr {
	uint16_t type;
#define MTP_BLOCK_DESCRIPTOR	0
#define MTP_BLOCK_GPIO_REQ	1
#define MTP_BLOCK_END		2
	uint16_t subtype;
	uint16_t len;
} __packed;

struct mtp_gpio_req {
	uint16_t unk;
	uint16_t id;
	char name[32];
} __packed;

struct mtp_gpio_cmd {
	uint8_t type;
	uint8_t iface;
	uint8_t id;
	uint8_t unk;
	uint8_t cmd;
#define MTP_GPIO_CMD_TOGGLE	0x03
} __packed;

struct mtp_gpio_ack {
	uint8_t type;
	uint32_t retcode;
	uint8_t cmd[512];
} __packed;

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

#define MTP_CMD_RESET_INTERFACE	0x40
#define MTP_CMD_SEND_FIRMWARE		0x95
#define MTP_CMD_ENABLE_INTERFACE	0xb4
#define MTP_CMD_ACK_GPIO_CMD		0xa1
#define MTP_CMD_GET_DIMENSIONS		0xd9

void
apldchidev_handle_gpio_req(struct apldchidev_softc *sc, uint8_t iface,
    void *buf, size_t len)
{
	struct mtp_gpio_req *req = buf;
	uint32_t gpio[APLDCHIDEV_GPIO_MAX];
	char name[64];
	int node = -1;

	if (len < sizeof(*req))
		return;

	if (sc->sc_ngpios >= APLDCHIDEV_NUM_GPIOS)
		return;

	node = sc->sc_node;
	snprintf(name, sizeof(name), "apple,%s-gpios", req->name);
	len = OF_getproplen(node, name);
	if (len <= 0 || len > sizeof(gpio)) {
		/* XXX: older device trees store gpios in sub-nodes */
		if (iface == sc->sc_iface_mt)
			node = OF_getnodebyname(sc->sc_node, "multi-touch");
		else if (iface == sc->sc_iface_stm)
			node = OF_getnodebyname(sc->sc_node, "stm");
		if (node == -1)
			return;
		len = OF_getproplen(node, name);
		if (len <= 0 || len > sizeof(gpio))
			return;
	}

	OF_getpropintarray(node, name, gpio, len);
	gpio_controller_config_pin(gpio, GPIO_CONFIG_OUTPUT);
	gpio_controller_set_pin(gpio, 0);

	sc->sc_gpio[sc->sc_ngpios].ag_sc = sc;
	sc->sc_gpio[sc->sc_ngpios].ag_id = req->id;
	sc->sc_gpio[sc->sc_ngpios].ag_iface = iface;
	memcpy(sc->sc_gpio[sc->sc_ngpios].ag_gpio, gpio, len);
	task_set(&sc->sc_gpio[sc->sc_ngpios].ag_task,
	    apldchidev_gpio_task, &sc->sc_gpio[sc->sc_ngpios]);
	sc->sc_ngpios++;
}

void
apldchidev_handle_init(struct apldchidev_softc *sc, uint8_t iface,
    void *buf, size_t len)
{
	struct mtp_init_block_hdr *bhdr = buf;

	for (;;) {
		if (len < sizeof(*bhdr))
			return;
		len -= sizeof(*bhdr);

		if (len < bhdr->len)
			return;
		len -= bhdr->len;

		switch (bhdr->type) {
		case MTP_BLOCK_DESCRIPTOR:
			if (iface == sc->sc_iface_kbd &&
			    bhdr->len <= sizeof(sc->sc_kbddesc)) {
				memcpy(sc->sc_kbddesc, bhdr + 1, bhdr->len);
				sc->sc_kbddesclen = bhdr->len;
			} else if (iface == sc->sc_iface_mt &&
			    bhdr->len <= sizeof(sc->sc_mtdesc)) {
				memcpy(sc->sc_mtdesc, bhdr + 1, bhdr->len);
				sc->sc_mtdesclen = bhdr->len;
			} else if (iface == sc->sc_iface_stm &&
			    bhdr->len <= sizeof(sc->sc_stmdesc)) {
				memcpy(sc->sc_stmdesc, bhdr + 1, bhdr->len);
				sc->sc_stmdesclen = bhdr->len;
			}
			break;
		case MTP_BLOCK_GPIO_REQ:
			apldchidev_handle_gpio_req(sc, iface,
			    bhdr + 1, bhdr->len);
			break;
		case MTP_BLOCK_END:
			return;
		default:
			printf("%s: unhandled block type 0x%04x\n",
			    sc->sc_dev.dv_xname, bhdr->type);
			break;
		}

		bhdr = (struct mtp_init_block_hdr *)
		    ((uint8_t *)(bhdr + 1) + bhdr->len);
	}
}

void
apldchidev_handle_comm(struct apldchidev_softc *sc, void *buf, size_t len)
{
	struct mtp_init_hdr *ihdr = buf;
	struct mtp_gpio_cmd *cmd = buf;
	uint8_t iface;
	int i;

	switch (ihdr->type) {
	case MTP_EVENT_INIT:
		if (strcmp(ihdr->name, "keyboard") == 0) {
			sc->sc_iface_kbd = ihdr->iface;
			apldchidev_handle_init(sc, ihdr->iface,
			    ihdr + 1, len - sizeof(*ihdr));
		}
		if (strcmp(ihdr->name, "multi-touch") == 0) {
			sc->sc_iface_mt = ihdr->iface;
			apldchidev_handle_init(sc, ihdr->iface,
			    ihdr + 1, len - sizeof(*ihdr));
		}
		if (strcmp(ihdr->name, "stm") == 0) {
			sc->sc_iface_stm = ihdr->iface;
			apldchidev_handle_init(sc, ihdr->iface,
			    ihdr + 1, len - sizeof(*ihdr));
		}
		break;
	case MTP_EVENT_READY:
		iface = ihdr->unk1;
		if (iface == sc->sc_iface_stm)
			sc->sc_stm_ready = 1;
		if (iface == sc->sc_iface_kbd)
			sc->sc_kbd_ready = 1;
		if (iface == sc->sc_iface_mt)
			sc->sc_mt_ready = 1;
		break;
	case MTP_EVENT_GPIO_CMD:
		for (i =0; i < sc->sc_ngpios; i++) {
			if (cmd->id == sc->sc_gpio[i].ag_id &&
			    cmd->iface == sc->sc_gpio[i].ag_iface &&
			    cmd->cmd == MTP_GPIO_CMD_TOGGLE) {
				/* Stash the command for the reply. */
				KASSERT(len < sizeof(sc->sc_gpio_cmd));
				memcpy(sc->sc_gpio_cmd, buf, len);
				sc->sc_gpio_cmd_len = len;
				task_add(systq, &sc->sc_gpio[i].ag_task);
				return;
			}
		}
		printf("%s: unhandled gpio id %d iface %d cmd 0x%02x\n",
		       sc->sc_dev.dv_xname, cmd->id, cmd->iface, cmd->cmd);
		break;
	default:
		printf("%s: unhandled comm event 0x%02x\n",
		    sc->sc_dev.dv_xname, ihdr->type);
		break;
	}
}

void
apldchidev_gpio_task(void *arg)
{
	struct apldchidev_gpio *ag = arg;
	struct apldchidev_softc *sc = ag->ag_sc;
	struct mtp_gpio_ack *ack;
	uint8_t flags;
	size_t len;

	gpio_controller_set_pin(ag->ag_gpio, 1);
	delay(10000);
	gpio_controller_set_pin(ag->ag_gpio, 0);

	len = sizeof(*ack) + sc->sc_gpio_cmd_len;
	ack = malloc(len, M_TEMP, M_WAITOK);
	ack->type = MTP_CMD_ACK_GPIO_CMD;
	ack->retcode = 0;
	memcpy(ack->cmd, sc->sc_gpio_cmd, sc->sc_gpio_cmd_len);

	flags = MTP_GROUP_CMD << MTP_GROUP_SHIFT;
	flags |= MTP_REQ_SET_REPORT << MTP_REQ_SHIFT;
	apldchidev_cmd(sc, MTP_IFACE_COMM, flags, ack, len);

	free(ack, M_TEMP, len);
}

void apldckbd_intr(struct device *, uint8_t *, size_t);
void apldcms_intr(struct device *, uint8_t *, size_t);

int
apldchidev_rx_intr(void *arg)
{
	struct apldchidev_softc *sc = arg;
	struct mtp_hdr hdr;
	struct mtp_subhdr *shdr;
	uint32_t checksum = 0;
	char buf[APLDCHIDEV_PKT_MAX];

	apldchidev_read(sc, &hdr, sizeof(hdr), &checksum);
	apldchidev_read(sc, buf, hdr.pkt_len + 4, &checksum);
	if (checksum != 0xffffffff) {
		printf("%s: packet checksum error\n", sc->sc_dev.dv_xname);
		return 1;
	}
	if (hdr.pkt_len < sizeof(*shdr)) {
		printf("%s: packet too small\n", sc->sc_dev.dv_xname);
		return 1;
	}

	shdr = (struct mtp_subhdr *)buf;
	if (MTP_GROUP(shdr->flags) == MTP_GROUP_OUTPUT ||
	    MTP_GROUP(shdr->flags) == MTP_GROUP_CMD) {
		if (hdr.iface != sc->sc_cmd_iface) {
			printf("%s: got ack for unexpected iface\n",
			    sc->sc_dev.dv_xname);
		}
		if (hdr.seq != sc->sc_cmd_seq) {
			printf("%s: got ack with unexpected seq\n",
			    sc->sc_dev.dv_xname);
		}
		if (MTP_REQ(shdr->flags) == MTP_REQ_GET_REPORT &&
		    shdr->len <= sizeof(sc->sc_data)) {
			memcpy(sc->sc_data, (shdr + 1), shdr->len);
			sc->sc_data_len = shdr->len;
		} else {
			sc->sc_data_len = 0;
		}
		sc->sc_retcode = shdr->retcode;
		sc->sc_busy = 0;
		wakeup(sc);
		return 1;
	}
	if (MTP_GROUP(shdr->flags) != MTP_GROUP_INPUT) {
		printf("%s: unhandled group 0x%02x\n",
		    sc->sc_dev.dv_xname, shdr->flags);
		return 1;
	}

	if (hdr.iface == MTP_IFACE_COMM)
		apldchidev_handle_comm(sc, shdr + 1, shdr->len);
	else if (hdr.iface == sc->sc_iface_kbd && sc->sc_kbd)
		apldckbd_intr(sc->sc_kbd, (uint8_t *)(shdr + 1), shdr->len);
	else if (hdr.iface == sc->sc_iface_mt && sc->sc_mt)
		apldcms_intr(sc->sc_mt, (uint8_t *)(shdr + 1), shdr->len);
	else {
		printf("%s: unhandled iface %d\n",
		    sc->sc_dev.dv_xname, hdr.iface);
	}

	wakeup(sc);
	return 1;
}

void
apldchidev_cmd(struct apldchidev_softc *sc, uint8_t iface, uint8_t flags,
    void *data, size_t len)
{
	struct mtp_hdr hdr;
	struct mtp_subhdr shdr;
	uint32_t checksum = 0xffffffff;
	uint8_t pad[4];

	KASSERT(sc->sc_busy == 0);
	sc->sc_busy = 1;

	memset(&hdr, 0, sizeof(hdr));
	hdr.hdr_len = sizeof(hdr);
	hdr.chan = MTP_CHAN_CMD;
	hdr.pkt_len = roundup(len, 4) + sizeof(shdr);
	if (iface == MTP_IFACE_COMM)
		hdr.seq = sc->sc_seq_comm++;
	else if (iface == sc->sc_iface_kbd)
		hdr.seq = sc->sc_seq_kbd++;
	else if (iface == sc->sc_iface_mt)
		hdr.seq = sc->sc_seq_mt++;
	else if (iface == sc->sc_iface_stm)
		hdr.seq = sc->sc_seq_stm++;
	hdr.iface = iface;
	sc->sc_cmd_iface = hdr.iface;
	sc->sc_cmd_seq = hdr.seq;
	memset(&shdr, 0, sizeof(shdr));
	shdr.flags = flags;
	shdr.len = len;
	apldchidev_write(sc, &hdr, sizeof(hdr), &checksum);
	apldchidev_write(sc, &shdr, sizeof(shdr), &checksum);
	apldchidev_write(sc, data, len & ~3, &checksum);
	if (len & 3) {
		memset(pad, 0, sizeof(pad));
		memcpy(pad, &data[len & ~3], len & 3);
		apldchidev_write(sc, pad, sizeof(pad), &checksum);
	}
	apldchidev_write(sc, &checksum, sizeof(checksum), NULL);
}

void
apldchidev_wait(struct apldchidev_softc *sc)
{
	int retry, error;

	if (cold) {
		for (retry = 10; retry > 0; retry--) {
			if (sc->sc_busy == 0)
				break;
			apldchidev_rx_intr(sc);
			delay(1000);
		}
		return;
	}

	while (sc->sc_busy) {
		error = tsleep_nsec(sc, PZERO, "apldcwt", SEC_TO_NSEC(1));
		if (error == EWOULDBLOCK)
			return;
	}

	if (sc->sc_retcode) {
		printf("%s: command failed with error 0x%04x\n",
		    sc->sc_dev.dv_xname, sc->sc_retcode);
	}
}

void
apldchidev_enable(struct apldchidev_softc *sc, uint8_t iface)
{
	uint8_t cmd[2] = { MTP_CMD_ENABLE_INTERFACE, iface };
	uint8_t flags;

	flags = MTP_GROUP_CMD << MTP_GROUP_SHIFT;
	flags |= MTP_REQ_SET_REPORT << MTP_REQ_SHIFT;
	apldchidev_cmd(sc, MTP_IFACE_COMM, flags, cmd, sizeof(cmd));
	apldchidev_wait(sc);
}

void
apldchidev_reset(struct apldchidev_softc *sc, uint8_t iface, uint8_t state)
{
	uint8_t cmd[4] = { MTP_CMD_RESET_INTERFACE, 1, iface, state };
	uint8_t flags;

	flags = MTP_GROUP_CMD << MTP_GROUP_SHIFT;
	flags |= MTP_REQ_SET_REPORT << MTP_REQ_SHIFT;
	apldchidev_cmd(sc, MTP_IFACE_COMM, flags, cmd, sizeof(cmd));
	apldchidev_wait(sc);
}

#if NAPLDCMS > 0

int
apldchidev_send_firmware(struct apldchidev_softc *sc, int iface,
    void *ucode, size_t ucode_size)
{
	bus_dmamap_t map;
	bus_dma_segment_t seg;
	uint8_t cmd[16] = {};
	uint64_t addr;
	uint32_t size;
	uint8_t flags;
	caddr_t buf;
	int nsegs;
	int error;

	error = bus_dmamap_create(sc->sc_dmat, ucode_size, 1, ucode_size, 0,
	    BUS_DMA_WAITOK, &map);
	if (error)
		return error;

	error = bus_dmamem_alloc(sc->sc_dmat, ucode_size, 4 * PAGE_SIZE, 0,
	    &seg, 1, &nsegs, BUS_DMA_WAITOK);
	if (error) {
		bus_dmamap_destroy(sc->sc_dmat, map);
		return error;
	}

	error = bus_dmamem_map(sc->sc_dmat, &seg, 1, ucode_size, &buf,
	    BUS_DMA_WAITOK);
	if (error) {
		bus_dmamem_free(sc->sc_dmat, &seg, 1);
		bus_dmamap_destroy(sc->sc_dmat, map);
		return error;
	}

	error = bus_dmamap_load_raw(sc->sc_dmat, map, &seg, 1,
	    ucode_size, BUS_DMA_WAITOK);
	if (error) {
		bus_dmamem_unmap(sc->sc_dmat, buf, ucode_size);
		bus_dmamem_free(sc->sc_dmat, &seg, 1);
		bus_dmamap_destroy(sc->sc_dmat, map);
		return error;
	}

	memcpy(buf, ucode, ucode_size);
	bus_dmamap_sync(sc->sc_dmat, map, 0, ucode_size, BUS_DMASYNC_PREWRITE);

	cmd[0] = MTP_CMD_SEND_FIRMWARE;
	cmd[1] = 2;
	cmd[2] = 0;
	cmd[3] = iface;
	addr = map->dm_segs[0].ds_addr;
	memcpy(&cmd[4], &addr, sizeof(addr));
	size = map->dm_segs[0].ds_len;
	memcpy(&cmd[12], &size, sizeof(size));

	flags = MTP_GROUP_CMD << MTP_GROUP_SHIFT;
	flags |= MTP_REQ_SET_REPORT << MTP_REQ_SHIFT;
	apldchidev_cmd(sc, MTP_IFACE_COMM, flags, cmd, sizeof(cmd));
	apldchidev_wait(sc);

	bus_dmamap_unload(sc->sc_dmat, map);
	bus_dmamem_unmap(sc->sc_dmat, buf, ucode_size);
	bus_dmamem_free(sc->sc_dmat, &seg, 1);
	bus_dmamap_destroy(sc->sc_dmat, map);

	return 0;
}

struct mtp_fwhdr {
	uint32_t magic;
#define MTP_FW_MAGIC	0x46444948
	uint32_t version;
#define MTP_FW_VERSION	1
	uint32_t hdr_len;
	uint32_t data_len;
	uint32_t iface_off;
};

int
apldchidev_load_firmware(struct apldchidev_softc *sc, const char *name)
{
	struct mtp_fwhdr *hdr;
	uint8_t *ucode;
	size_t ucode_size;
	uint8_t *data;
	size_t size;
	int error;

	error = loadfirmware(name, &ucode, &ucode_size);
	if (error) {
		printf("%s: error %d, could not read firmware %s\n",
		    sc->sc_dev.dv_xname, error, name);
		return error;
	}

	hdr = (struct mtp_fwhdr *)ucode;
	if (sizeof(hdr) > ucode_size ||
	    hdr->hdr_len + hdr->data_len > ucode_size) {
		printf("%s: loaded firmware is too small\n",
		    sc->sc_dev.dv_xname);
		return EINVAL;
	}
	if (hdr->magic != MTP_FW_MAGIC) {
		printf("%s: wrong firmware magic number 0x%08x\n",
		    sc->sc_dev.dv_xname, hdr->magic);
		return EINVAL;
	}
	if (hdr->version != MTP_FW_VERSION) {
		printf("%s: wrong firmware version %d\n",
		    sc->sc_dev.dv_xname, hdr->version);
		return EINVAL;
	}
	data = ucode + hdr->hdr_len;
	if (hdr->iface_off)
		data[hdr->iface_off] = sc->sc_iface_mt;
	size = hdr->data_len;

	apldchidev_send_firmware(sc, sc->sc_iface_mt, data, size);
	apldchidev_reset(sc, sc->sc_iface_mt, 0);
	apldchidev_reset(sc, sc->sc_iface_mt, 2);

	/* Wait until ready. */
	while (sc->sc_mt_ready == 0) {
		error = tsleep_nsec(sc, PZERO, "apldcmt", SEC_TO_NSEC(2));
		if (error == EWOULDBLOCK)
			return error;
	}

	return 0;
}

void
apldchidev_get_dimensions(struct apldchidev_softc *sc)
{
	uint8_t cmd[1] = { MTP_CMD_GET_DIMENSIONS };
	struct mtp_dim dim;
	uint8_t flags;

	flags = MTP_GROUP_CMD << MTP_GROUP_SHIFT;
	flags |= MTP_REQ_GET_REPORT << MTP_REQ_SHIFT;
	apldchidev_cmd(sc, sc->sc_iface_mt, flags, cmd, sizeof(cmd));
	apldchidev_wait(sc);

	if (sc->sc_retcode == 0 && sc->sc_data_len == sizeof(dim) + 1 &&
	    sc->sc_data[0] == MTP_CMD_GET_DIMENSIONS) {
		memcpy(&dim, &sc->sc_data[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;
	}		
}

void
apldchidev_attachhook(struct device *self)
{
	struct apldchidev_softc *sc = (struct apldchidev_softc *)self;
	struct apldchidev_attach_args aa;
	char *firmware_name;
	int node, len;
	int retry;
	int error;

	/* Enable interface. */
	apldchidev_enable(sc, sc->sc_iface_mt);

	node = OF_getnodebyname(sc->sc_node, "multi-touch");
	if (node == -1)
		return;
	len = OF_getproplen(node, "firmware-name");
	if (len <= 0)
		return;

	/* Wait until we have received the multi-touch HID descriptor. */
	while (sc->sc_mtdesclen == 0) {
		error = tsleep_nsec(sc, PZERO, "apldcmt", SEC_TO_NSEC(1));
		if (error == EWOULDBLOCK)
			return;
	}

	firmware_name = malloc(len, M_TEMP, M_WAITOK);
	OF_getprop(node, "firmware-name", firmware_name, len);

	for (retry = 5; retry > 0; retry--) {
		error = apldchidev_load_firmware(sc, firmware_name);
		if (error != EWOULDBLOCK)
			break;
	}
	if (error)
		goto out;

	apldchidev_get_dimensions(sc);

	aa.aa_name = "multi-touch";
	aa.aa_desc = sc->sc_mtdesc;
	aa.aa_desclen = sc->sc_mtdesclen;
	sc->sc_mt = config_found(self, &aa, NULL);

out:
	free(firmware_name, M_TEMP, len);
}

#endif

void
apldchidev_set_leds(struct apldchidev_softc *sc, uint8_t leds)
{
	uint8_t report[2] = { 1, leds };
	uint8_t flags;

	flags = MTP_GROUP_OUTPUT << MTP_GROUP_SHIFT;
	flags |= MTP_REQ_SET_REPORT << MTP_REQ_SHIFT;
	apldchidev_cmd(sc, sc->sc_iface_kbd, flags, report, sizeof(report));
}

/* Keyboard */

struct apldckbd_softc {
	struct device		sc_dev;
	struct apldchidev_softc	*sc_hidev;
	struct hidkbd		sc_kbd;
	int			sc_spl;
};

void	apldckbd_cngetc(void *, u_int *, int *);
void	apldckbd_cnpollc(void *, int);
void	apldckbd_cnbell(void *, u_int, u_int, u_int);

const struct wskbd_consops apldckbd_consops = {
	apldckbd_cngetc,
	apldckbd_cnpollc,
	apldckbd_cnbell,
};

int	apldckbd_enable(void *, int);
void	apldckbd_set_leds(void *, int);
int	apldckbd_ioctl(void *, u_long, caddr_t, int, struct proc *);

const struct wskbd_accessops apldckbd_accessops = {
	.enable = apldckbd_enable,
	.ioctl = apldckbd_ioctl,
	.set_leds = apldckbd_set_leds,
};

int	 apldckbd_match(struct device *, void *, void *);
void	 apldckbd_attach(struct device *, struct device *, void *);

const struct cfattach apldckbd_ca = {
	sizeof(struct apldckbd_softc), apldckbd_match, apldckbd_attach
};

struct cfdriver apldckbd_cd = {
	NULL, "apldckbd", DV_DULL
};

int
apldckbd_match(struct device *parent, void *match, void *aux)
{
	struct apldchidev_attach_args *aa = aux;

	return strcmp(aa->aa_name, "keyboard") == 0;
}

void
apldckbd_attach(struct device *parent, struct device *self, void *aux)
{
	struct apldckbd_softc *sc = (struct apldckbd_softc *)self;
	struct apldchidev_attach_args *aa = aux;
	struct hidkbd *kbd = &sc->sc_kbd;

#define APLHIDEV_KBD_DEVICE	1
	sc->sc_hidev = (struct apldchidev_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))
		kbd->sc_munge = hidkbd_apple_munge;

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

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

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

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

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

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

	return hidkbd_enable(kbd, on);
}

int
apldckbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
{
	struct apldckbd_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:
		apldckbd_set_leds(v, *(int *)data);
		return 0;
	default:
		return hidkbd_ioctl(kbd, cmd, data, flag, p);
	}
}

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

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

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

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

void
apldckbd_cnpollc(void *v, int on)
{
	struct apldckbd_softc *sc = v;

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

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

#if NAPLDCMS > 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	(20 * sizeof(uint16_t))
#define UBCMTP_TYPE4_BTOFF	23
#define UBCMTP_TYPE4_FINGERPAD	(1 * sizeof(uint16_t))

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

struct apldcms_softc {
	struct device		sc_dev;
	struct apldchidev_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	apldcms_enable(void *);
void	apldcms_disable(void *);
int	apldcms_ioctl(void *, u_long, caddr_t, int, struct proc *);

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

const struct wsmouse_accessops apldcms_accessops = {
	.enable = apldcms_enable,
	.disable = apldcms_disable,
	.ioctl = apldcms_ioctl,
};

int	 apldcms_match(struct device *, void *, void *);
void	 apldcms_attach(struct device *, struct device *, void *);

const struct cfattach apldcms_ca = {
	sizeof(struct apldcms_softc), apldcms_match, apldcms_attach
};

struct cfdriver apldcms_cd = {
	NULL, "apldcms", DV_DULL
};

int	apldcms_configure(struct apldcms_softc *);

int
apldcms_match(struct device *parent, void *match, void *aux)
{
	struct apldchidev_attach_args *aa = aux;

	return strcmp(aa->aa_name, "multi-touch") == 0;
}

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

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

	printf("\n");

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

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

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

int
apldcms_configure(struct apldcms_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, apldcms_wsmousecfg,
	    nitems(apldcms_wsmousecfg));
}

void
apldcms_intr(struct device *self, uint8_t *packet, size_t packetlen)
{
	struct apldcms_softc *sc = (struct apldcms_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
apldcms_enable(void *v)
{
	struct apldcms_softc *sc = v;

	if (sc->sc_enabled)
		return EBUSY;

	sc->sc_enabled = 1;
	return 0;
}

void
apldcms_disable(void *v)
{
	struct apldcms_softc *sc = v;

	sc->sc_enabled = 0;
}

int
apldcms_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
{
	struct apldcms_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 = 0;
		wsmc->resy = 0;
		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
apldcms_intr(struct device *self, uint8_t *packet, size_t packetlen)
{
}

#endif