/* $NetBSD: irmce.c,v 1.9 2023/05/10 00:12:28 riastradh Exp $ */

/*-
* Copyright (c) 2011 Jared D. McNeill <[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 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.9 2023/05/10 00:12:28 riastradh 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;

       error = config_detach_children(self, 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(self, &iaa, irmce_print, CFARGS_NONE);
       }

       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;
       }
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.