NetBSD/sys/dev/usb/irmce.c

/* $NetBSD: irmce.c,v 1.6 2020/03/14 02:35:33 christos Exp $ */

/*-
 * Copyright (c) 2011 Jared D. McNeill <jmcneill@invisible.ca>
 * 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 AND CONTRIBUTORS ``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 FOUNDATION OR CONTRIBUTORS
 * 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.
 */

/*
 * IR receiver/transceiver for Windows Media Center
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: irmce.c,v 1.6 2020/03/14 02:35:33 christos Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <sys/bus.h>
#include <sys/select.h>
#include <sys/module.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbdevs.h>

#include <dev/ir/ir.h>
#include <dev/ir/cirio.h>
#include <dev/ir/cirvar.h>

enum irmce_state {
	IRMCE_STATE_HEADER,
	IRMCE_STATE_IRDATA,
	IRMCE_STATE_CMDHEADER,
	IRMCE_STATE_CMDDATA,
};

struct irmce_softc {
	device_t		sc_dev;
	device_t		sc_cirdev;

	struct usbd_device *	sc_udev;
	struct usbd_interface *	sc_iface;

	int			sc_bulkin_ep;
	uint16_t		sc_bulkin_maxpktsize;
	struct usbd_pipe *	sc_bulkin_pipe;
	struct usbd_xfer *	sc_bulkin_xfer;
	uint8_t *		sc_bulkin_buffer;

	int			sc_bulkout_ep;
	uint16_t		sc_bulkout_maxpktsize;
	struct usbd_pipe *	sc_bulkout_pipe;
	struct usbd_xfer *	sc_bulkout_xfer;
	uint8_t *		sc_bulkout_buffer;

	bool			sc_raw;

	uint8_t			sc_ir_buf[16];
	size_t			sc_ir_bufused;
	size_t			sc_ir_resid;
	enum irmce_state	sc_ir_state;
	uint8_t			sc_ir_header;

	bool			sc_rc6_hb[256];
	size_t			sc_rc6_nhb;
};

static int	irmce_match(device_t, cfdata_t, void *);
static void	irmce_attach(device_t, device_t, void *);
static int	irmce_detach(device_t, int);
static void	irmce_childdet(device_t, device_t);
static int	irmce_activate(device_t, enum devact);
static int	irmce_rescan(device_t, const char *, const int *);

static int	irmce_print(void *, const char *);

static int	irmce_reset(struct irmce_softc *);

static int	irmce_open(void *, int, int, struct proc *);
static int	irmce_close(void *, int, int, struct proc *);
static int	irmce_read(void *, struct uio *, int);
static int	irmce_write(void *, struct uio *, int);
static int	irmce_setparams(void *, struct cir_params *);

static const struct cir_methods irmce_cir_methods = {
	.im_open = irmce_open,
	.im_close = irmce_close,
	.im_read = irmce_read,
	.im_write = irmce_write,
	.im_setparams = irmce_setparams,
};

static const struct {
	uint16_t		vendor;
	uint16_t		product;
} irmce_devices[] = {
	{ USB_VENDOR_SMK, USB_PRODUCT_SMK_MCE_IR },
};

CFATTACH_DECL2_NEW(irmce, sizeof(struct irmce_softc),
    irmce_match, irmce_attach, irmce_detach, irmce_activate,
    irmce_rescan, irmce_childdet);

static int
irmce_match(device_t parent, cfdata_t match, void *opaque)
{
	struct usbif_attach_arg *uiaa = opaque;
	unsigned int i;

	for (i = 0; i < __arraycount(irmce_devices); i++) {
		if (irmce_devices[i].vendor == uiaa->uiaa_vendor &&
		    irmce_devices[i].product == uiaa->uiaa_product)
			return UMATCH_VENDOR_PRODUCT;
	}

	return UMATCH_NONE;
}

static void
irmce_attach(device_t parent, device_t self, void *opaque)
{
	struct irmce_softc *sc = device_private(self);
	struct usbif_attach_arg *uiaa = opaque;
	usb_endpoint_descriptor_t *ed;
	char *devinfop;
	unsigned int i;
	uint8_t nep;

	if (!pmf_device_register(self, NULL, NULL))
		aprint_error_dev(self, "couldn't establish power handler\n");

	aprint_naive("\n");

	devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0);
	aprint_normal(": %s\n", devinfop);
	usbd_devinfo_free(devinfop);

	sc->sc_dev = self;
	sc->sc_udev = uiaa->uiaa_device;
	sc->sc_iface = uiaa->uiaa_iface;

	nep = 0;
	usbd_endpoint_count(sc->sc_iface, &nep);
	sc->sc_bulkin_ep = sc->sc_bulkout_ep = -1;
	for (i = 0; i < nep; i++) {
		int dir, type;

		ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
		if (ed == NULL) {
			aprint_error_dev(self,
			    "couldn't read endpoint descriptor %d\n", i);
			continue;
		}

		dir = UE_GET_DIR(ed->bEndpointAddress);
		type = UE_GET_XFERTYPE(ed->bmAttributes);

		if (type != UE_BULK)
			continue;

		if (dir == UE_DIR_IN && sc->sc_bulkin_ep == -1) {
			sc->sc_bulkin_ep = ed->bEndpointAddress;
			sc->sc_bulkin_maxpktsize =
			    UE_GET_SIZE(UGETW(ed->wMaxPacketSize)) *
			    (UE_GET_TRANS(UGETW(ed->wMaxPacketSize)) + 1);
		}
		if (dir == UE_DIR_OUT && sc->sc_bulkout_ep == -1) {
			sc->sc_bulkout_ep = ed->bEndpointAddress;
			sc->sc_bulkout_maxpktsize =
			    UE_GET_SIZE(UGETW(ed->wMaxPacketSize)) *
			    (UE_GET_TRANS(UGETW(ed->wMaxPacketSize)) + 1);
		}
	}

	aprint_debug_dev(self, "in 0x%02x/%d out 0x%02x/%d\n",
	    sc->sc_bulkin_ep, sc->sc_bulkin_maxpktsize,
	    sc->sc_bulkout_ep, sc->sc_bulkout_maxpktsize);

	if (sc->sc_bulkin_maxpktsize < 16 || sc->sc_bulkout_maxpktsize < 16) {
		aprint_error_dev(self, "bad maxpktsize\n");
		return;
	}
	usbd_status err;

	err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin_ep,
	    USBD_EXCLUSIVE_USE, &sc->sc_bulkin_pipe);
	if (err) {
		aprint_error_dev(sc->sc_dev,
		    "couldn't open bulk-in pipe: %s\n", usbd_errstr(err));
		return;
	}
	err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkout_ep,
	    USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);
	if (err) {
		aprint_error_dev(sc->sc_dev,
		    "couldn't open bulk-out pipe: %s\n", usbd_errstr(err));
		usbd_close_pipe(sc->sc_bulkin_pipe);
		sc->sc_bulkin_pipe = NULL;
		return;
	}

	int error;
	error = usbd_create_xfer(sc->sc_bulkin_pipe, sc->sc_bulkin_maxpktsize,
	    0, 0, &sc->sc_bulkin_xfer);
	if (error) {
		goto fail;
	}

	error = usbd_create_xfer(sc->sc_bulkout_pipe,
	    sc->sc_bulkout_maxpktsize, USBD_FORCE_SHORT_XFER, 0,
	    &sc->sc_bulkout_xfer);
	if (error) {
		goto fail;
	}
	sc->sc_bulkin_buffer = usbd_get_buffer(sc->sc_bulkin_xfer);
	sc->sc_bulkout_buffer = usbd_get_buffer(sc->sc_bulkout_xfer);

	irmce_rescan(self, NULL, NULL);
	return;

fail:
	if (sc->sc_bulkin_xfer)
		usbd_destroy_xfer(sc->sc_bulkin_xfer);
	if (sc->sc_bulkout_xfer)
		usbd_destroy_xfer(sc->sc_bulkout_xfer);
}

static int
irmce_detach(device_t self, int flags)
{
	struct irmce_softc *sc = device_private(self);
	int error;

	if (sc->sc_cirdev) {
		error = config_detach(sc->sc_cirdev, flags);
		if (error)
			return error;
	}

	if (sc->sc_bulkin_pipe) {
		usbd_abort_pipe(sc->sc_bulkin_pipe);
	}
	if (sc->sc_bulkout_pipe) {
		usbd_abort_pipe(sc->sc_bulkout_pipe);
	}
	if (sc->sc_bulkin_xfer) {
		usbd_destroy_xfer(sc->sc_bulkin_xfer);
		sc->sc_bulkin_buffer = NULL;
		sc->sc_bulkin_xfer = NULL;
	}
	if (sc->sc_bulkout_xfer) {
		usbd_destroy_xfer(sc->sc_bulkout_xfer);
		sc->sc_bulkout_buffer = NULL;
		sc->sc_bulkout_xfer = NULL;
	}
	if (sc->sc_bulkin_pipe) {
		usbd_close_pipe(sc->sc_bulkin_pipe);
		sc->sc_bulkin_pipe = NULL;
	}
	if (sc->sc_bulkout_pipe) {
		usbd_close_pipe(sc->sc_bulkout_pipe);
		sc->sc_bulkout_pipe = NULL;
	}

	pmf_device_deregister(self);

	return 0;
}

static int
irmce_activate(device_t self, enum devact act)
{
	return 0;
}

static int
irmce_rescan(device_t self, const char *ifattr, const int *locators)
{
	struct irmce_softc *sc = device_private(self);
	struct ir_attach_args iaa;

	if (sc->sc_cirdev == NULL) {
		iaa.ia_type = IR_TYPE_CIR;
		iaa.ia_methods = &irmce_cir_methods;
		iaa.ia_handle = sc;
		sc->sc_cirdev = config_found_ia(self, "irbus",
		    &iaa, irmce_print);
	}

	return 0;
}

static int
irmce_print(void *priv, const char *pnp)
{
	if (pnp)
		aprint_normal("cir at %s", pnp);

	return UNCONF;
}

static void
irmce_childdet(device_t self, device_t child)
{
	struct irmce_softc *sc = device_private(self);

	if (sc->sc_cirdev == child)
		sc->sc_cirdev = NULL;
}

static int
irmce_reset(struct irmce_softc *sc)
{
	static const uint8_t reset_cmd[] = { 0x00, 0xff, 0xaa };
	uint8_t *p = sc->sc_bulkout_buffer;
	usbd_status err;
	uint32_t wlen;
	unsigned int n;

	for (n = 0; n < __arraycount(reset_cmd); n++)
		*p++ = reset_cmd[n];

	wlen = sizeof(reset_cmd);
	err = usbd_bulk_transfer(sc->sc_bulkout_xfer, sc->sc_bulkout_pipe,
	    USBD_FORCE_SHORT_XFER, USBD_DEFAULT_TIMEOUT,
	    sc->sc_bulkout_buffer, &wlen);
	if (err != USBD_NORMAL_COMPLETION) {
		if (err == USBD_INTERRUPTED)
			return EINTR;
		else if (err == USBD_TIMEOUT)
			return ETIMEDOUT;
		else
			return EIO;
	}

	return 0;
}

static int
irmce_open(void *priv, int flag, int mode, struct proc *p)
{
	struct irmce_softc *sc = priv;
	int err = irmce_reset(sc);
	if (err) {
		aprint_error_dev(sc->sc_dev,
		    "couldn't reset device: %s\n", usbd_errstr(err));
	}
	sc->sc_ir_state = IRMCE_STATE_HEADER;
	sc->sc_rc6_nhb = 0;

	return 0;
}

static int
irmce_close(void *priv, int flag, int mode, struct proc *p)
{
	struct irmce_softc *sc = priv;

	if (sc->sc_bulkin_pipe) {
		usbd_abort_pipe(sc->sc_bulkin_pipe);
	}
	if (sc->sc_bulkout_pipe) {
		usbd_abort_pipe(sc->sc_bulkout_pipe);
	}

	return 0;
}

static int
irmce_rc6_decode(struct irmce_softc *sc, uint8_t *buf, size_t buflen,
    struct uio *uio)
{
	bool *hb = &sc->sc_rc6_hb[0];
	unsigned int n;
	int state, pulse;
	uint32_t data;
	uint8_t mode;
	bool idle = false;

	for (n = 0; n < buflen; n++) {
		state = (buf[n] & 0x80) ? 1 : 0;
		pulse = (buf[n] & 0x7f) * 50;

		if (pulse >= 300 && pulse <= 600) {
			hb[sc->sc_rc6_nhb++] = state;
		} else if (pulse >= 680 && pulse <= 1080) {
			hb[sc->sc_rc6_nhb++] = state;
			hb[sc->sc_rc6_nhb++] = state;
		} else if (pulse >= 1150 && pulse <= 1450) {
			hb[sc->sc_rc6_nhb++] = state;
			hb[sc->sc_rc6_nhb++] = state;
			hb[sc->sc_rc6_nhb++] = state;
		} else if (pulse >= 2400 && pulse <= 2800) {
			hb[sc->sc_rc6_nhb++] = state;
			hb[sc->sc_rc6_nhb++] = state;
			hb[sc->sc_rc6_nhb++] = state;
			hb[sc->sc_rc6_nhb++] = state;
			hb[sc->sc_rc6_nhb++] = state;
			hb[sc->sc_rc6_nhb++] = state;
		} else if (pulse > 3000) {
			if (sc->sc_rc6_nhb & 1)
				hb[sc->sc_rc6_nhb++] = state;
			idle = true;
			break;
		} else {
			aprint_debug_dev(sc->sc_dev,
			    "error parsing RC6 stream (pulse=%d)\n", pulse);
			return EIO;
		}
	}

	if (!idle)
		return 0;

	if (sc->sc_rc6_nhb < 20) {
		aprint_debug_dev(sc->sc_dev, "not enough RC6 data\n");
		return EIO;
	}

	/* RC6 leader 11111100 */
	if (!hb[0] || !hb[1] || !hb[2] || !hb[3] || !hb[4] || !hb[5] ||
	    hb[6] || hb[7]) {
		aprint_debug_dev(sc->sc_dev, "bad RC6 leader\n");
		return EIO;
	}

	/* start bit 10 */
	if (!hb[8] || hb[9]) {
		aprint_debug_dev(sc->sc_dev, "missing RC6 start bit\n");
		return EIO;
	}

	/* mode info */
	mode = 0x00;
	for (n = 10; n < 15; n += 2) {
		if (hb[n] && !hb[n + 1])
			mode = (mode << 1) | 1;
		else if (!hb[n] && hb[n + 1])
			mode = (mode << 1) | 0;
		else {
			aprint_debug_dev(sc->sc_dev, "bad RC6 mode bits\n");
			return EIO;
		}
	}

	data = 0;
	for (n = 20; n < sc->sc_rc6_nhb; n += 2) {
		if (hb[n] && !hb[n + 1])
			data = (data << 1) | 1;
		else if (!hb[n] && hb[n + 1])
			data = (data << 1) | 0;
		else {
			aprint_debug_dev(sc->sc_dev, "bad RC6 data bits\n");
			return EIO;
		}
	}

	sc->sc_rc6_nhb = 0;

	return uiomove(&data, sizeof(data), uio);
}

static int
irmce_process(struct irmce_softc *sc, uint8_t *buf, size_t buflen,
    struct uio *uio)
{
	uint8_t *p = buf;
	uint8_t data, cmd;
	int error;

	while (p - buf < (ssize_t)buflen) {
		switch (sc->sc_ir_state) {
		case IRMCE_STATE_HEADER:
			sc->sc_ir_header = data = *p++;
			if ((data & 0xe0) == 0x80 && (data & 0x1f) != 0x1f) {
				sc->sc_ir_bufused = 0;
				sc->sc_ir_resid = data & 0x1f;
				sc->sc_ir_state = IRMCE_STATE_IRDATA;
				if (sc->sc_ir_resid > sizeof(sc->sc_ir_buf))
					return EIO;
				if (sc->sc_ir_resid == 0)
					sc->sc_ir_state = IRMCE_STATE_HEADER;
			} else {
				sc->sc_ir_state = IRMCE_STATE_CMDHEADER;
			}
			break;
		case IRMCE_STATE_CMDHEADER:
			cmd = *p++;
			data = sc->sc_ir_header;
			if (data == 0x00 && cmd == 0x9f)
				sc->sc_ir_resid = 1;
			else if (data == 0xff && cmd == 0x0b)
				sc->sc_ir_resid = 2;
			else if (data == 0x9f) {
				if (cmd == 0x04 || cmd == 0x06 ||
				    cmd == 0x0c || cmd == 0x15) {
					sc->sc_ir_resid = 2;
				} else if (cmd == 0x01 || cmd == 0x08 ||
				    cmd == 0x14) {
					sc->sc_ir_resid = 1;
				}
			}
			if (sc->sc_ir_resid > 0)
				sc->sc_ir_state = IRMCE_STATE_CMDDATA;
			else
				sc->sc_ir_state = IRMCE_STATE_HEADER;
			break;
		case IRMCE_STATE_IRDATA:
			sc->sc_ir_resid--;
			sc->sc_ir_buf[sc->sc_ir_bufused++] = *p;
			p++;
			if (sc->sc_ir_resid == 0) {
				sc->sc_ir_state = IRMCE_STATE_HEADER;
				error = irmce_rc6_decode(sc,
				    sc->sc_ir_buf, sc->sc_ir_bufused, uio);
				if (error)
					sc->sc_rc6_nhb = 0;
			}
			break;
		case IRMCE_STATE_CMDDATA:
			p++;
			sc->sc_ir_resid--;
			if (sc->sc_ir_resid == 0)
				sc->sc_ir_state = IRMCE_STATE_HEADER;
			break;
		}

	}

	return 0;
}

static int
irmce_read(void *priv, struct uio *uio, int flag)
{
	struct irmce_softc *sc = priv;
	usbd_status err;
	uint32_t rlen;
	int error = 0;

	while (uio->uio_resid > 0) {
		rlen = sc->sc_bulkin_maxpktsize;
		err = usbd_bulk_transfer(sc->sc_bulkin_xfer,
		    sc->sc_bulkin_pipe, USBD_SHORT_XFER_OK,
		    USBD_DEFAULT_TIMEOUT, sc->sc_bulkin_buffer, &rlen);
		if (err != USBD_NORMAL_COMPLETION) {
			if (err == USBD_INTERRUPTED)
				return EINTR;
			else if (err == USBD_TIMEOUT)
				continue;
			else
				return EIO;
		}

		if (sc->sc_raw) {
			error = uiomove(sc->sc_bulkin_buffer, rlen, uio);
			break;
		} else {
			error = irmce_process(sc, sc->sc_bulkin_buffer,
			    rlen, uio);
			if (error)
				break;
		}
	}

	return error;
}

static int
irmce_write(void *priv, struct uio *uio, int flag)
{
	return EIO;
}

static int
irmce_setparams(void *priv, struct cir_params *params)
{
	struct irmce_softc *sc = priv;

	if (params->raw > 1)
		return EINVAL;
	sc->sc_raw = params->raw;

	return 0;
}

MODULE(MODULE_CLASS_DRIVER, irmce, NULL);

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
irmce_modcmd(modcmd_t cmd, void *opaque)
{
	switch (cmd) {
	case MODULE_CMD_INIT:
#ifdef _MODULE
		return config_init_component(cfdriver_ioconf_irmce,
		    cfattach_ioconf_irmce, cfdata_ioconf_irmce);
#else
		return 0;
#endif
	case MODULE_CMD_FINI:
#ifdef _MODULE
		return config_fini_component(cfdriver_ioconf_irmce,
		    cfattach_ioconf_irmce, cfdata_ioconf_irmce);
#else
		return 0;
#endif
	default:
		return ENOTTY;
	}
}