* Copyright (c) 2001 The NetBSD Foundation, Inc.

/* $NetBSD: uirda.c,v 1.53 2022/08/07 11:25:32 riastradh Exp $ */

/*
* Copyright (c) 2001 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Lennart Augustsson ([email protected]).
*
* 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 NETBSD FOUNDATION, INC. 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.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: uirda.c,v 1.53 2022/08/07 11:25:32 riastradh Exp $");

#ifdef _KERNEL_OPT
#include "opt_usb.h"
#endif

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/mutex.h>
#include <sys/ioctl.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/poll.h>
#include <sys/select.h>
#include <sys/proc.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/irdaio.h>
#include <dev/ir/irframevar.h>

#include <dev/usb/uirdavar.h>

#ifdef UIRDA_DEBUG
#define DPRINTF(x) if (uirdadebug) printf x
#define DPRINTFN(n,x) if (uirdadebug>(n)) printf x
int uirdadebug = 0;
#else
#define DPRINTF(x)
#define DPRINTFN(n,x)
#endif

/* Class specific requests */
#define UR_IRDA_RECEIVING 0x01 /* Receive in progress? */
#define UR_IRDA_CHECK_MEDIA_BUSY 0x03
#define UR_IRDA_SET_RATE_SNIFF 0x04 /* opt */
#define UR_IRDA_SET_UNICAST_LIST 0x05 /* opt */
#define UR_IRDA_GET_DESC 0x06

#define UIRDA_NEBOFS 8
static const struct {
int count;
int mask;
int header;
} uirda_ebofs[UIRDA_NEBOFS] = {
{ 0, UI_EB_0, UIRDA_EB_0 },
{ 1, UI_EB_1, UIRDA_EB_1 },
{ 2, UI_EB_2, UIRDA_EB_2 },
{ 3, UI_EB_3, UIRDA_EB_3 },
{ 6, UI_EB_6, UIRDA_EB_6 },
{ 12, UI_EB_12, UIRDA_EB_12 },
{ 24, UI_EB_24, UIRDA_EB_24 },
{ 48, UI_EB_48, UIRDA_EB_48 }
};

#define UIRDA_NSPEEDS 9
static const struct {
int speed;
int mask;
int header;
} uirda_speeds[UIRDA_NSPEEDS] = {
{ 4000000, UI_BR_4000000, UIRDA_4000000 },
{ 1152000, UI_BR_1152000, UIRDA_1152000 },
{ 576000, UI_BR_576000, UIRDA_576000 },
{ 115200, UI_BR_115200, UIRDA_115200 },
{ 57600, UI_BR_57600, UIRDA_57600 },
{ 38400, UI_BR_38400, UIRDA_38400 },
{ 19200, UI_BR_19200, UIRDA_19200 },
{ 9600, UI_BR_9600, UIRDA_9600 },
{ 2400, UI_BR_2400, UIRDA_2400 },
};

int uirda_open(void *, int, int, struct lwp *);
int uirda_close(void *, int, int, struct lwp *);
int uirda_read(void *, struct uio *, int);
int uirda_write(void *, struct uio *, int);
int uirda_set_params(void *, struct irda_params *);
int uirda_get_speeds(void *, int *);
int uirda_get_turnarounds(void *, int *);
int uirda_poll(void *, int, struct lwp *);
int uirda_kqfilter(void *, struct knote *);

static const struct irframe_methods uirda_methods = {
uirda_open, uirda_close, uirda_read, uirda_write, uirda_poll,
uirda_kqfilter, uirda_set_params, uirda_get_speeds,
uirda_get_turnarounds
};

static void uirda_rd_cb(struct usbd_xfer *xfer, void *priv,
usbd_status status);
static usbd_status uirda_start_read(struct uirda_softc *sc);

/*
* These devices don't quite follow the spec. Speed changing is broken
* and they don't handle windows.
* But we change speed in a safe way, and don't use windows now.
* Some devices also seem to have an interrupt pipe that can be ignored.
*
* Table information taken from Linux driver.
*/
Static const struct usb_devno uirda_devs[] = {
{ USB_VENDOR_ACTISYS, USB_PRODUCT_ACTISYS_IR2000U },
{ USB_VENDOR_EXTENDED, USB_PRODUCT_EXTENDED_XTNDACCESS },
{ USB_VENDOR_KAWATSU, USB_PRODUCT_KAWATSU_KC180 },
};
#define uirda_lookup(v, p) (usb_lookup(uirda_devs, v, p))

int uirda_match(device_t, cfdata_t, void *);
void uirda_attach(device_t, device_t, void *);
void uirda_childdet(device_t, device_t);
int uirda_detach(device_t, int);
int uirda_activate(device_t, enum devact);

CFATTACH_DECL2_NEW(uirda, sizeof(struct uirda_softc), uirda_match,
uirda_attach, uirda_detach, uirda_activate, NULL, uirda_childdet);

int
uirda_match(device_t parent, cfdata_t match, void *aux)
{
struct usbif_attach_arg *uiaa = aux;

DPRINTFN(50,("uirda_match\n"));

if (uirda_lookup(uiaa->uiaa_vendor, uiaa->uiaa_product) != NULL)
return UMATCH_VENDOR_PRODUCT;

if (uiaa->uiaa_class == UICLASS_APPL_SPEC &&
uiaa->uiaa_subclass == UISUBCLASS_IRDA &&
uiaa->uiaa_proto == UIPROTO_IRDA)
return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO;
return UMATCH_NONE;
}

void
uirda_attach(device_t parent, device_t self, void *aux)
{
struct uirda_softc *sc = device_private(self);
struct usbif_attach_arg *uiaa = aux;
struct usbd_device * dev = uiaa->uiaa_device;
struct usbd_interface *iface = uiaa->uiaa_iface;
char *devinfop;
usb_endpoint_descriptor_t *ed;
usbd_status err;
uint8_t epcount;
u_int specrev;
int i;
struct ir_attach_args ia;

DPRINTFN(10,("uirda_attach: sc=%p\n", sc));

sc->sc_dev = self;

aprint_naive("\n");
aprint_normal("\n");

devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);

sc->sc_udev = dev;
sc->sc_iface = iface;

mutex_init(&sc->sc_wr_buf_lk, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&sc->sc_rd_buf_lk, MUTEX_DEFAULT, IPL_NONE);
selinit(&sc->sc_rd_sel);

if (sc->sc_hdszi == 0)
sc->sc_hdszi = UIRDA_INPUT_HEADER_SIZE;

epcount = 0;
(void)usbd_endpoint_count(iface, &epcount);

sc->sc_rd_addr = -1;
sc->sc_wr_addr = -1;
for (i = 0; i < epcount; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
aprint_error_dev(self, "couldn't get ep %d\n", i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_rd_addr = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_wr_addr = ed->bEndpointAddress;
}
}
if (sc->sc_rd_addr == -1 || sc->sc_wr_addr == -1) {
aprint_error_dev(self, "missing endpoint\n");
return;
}

if (sc->sc_loadfw(sc) != 0) {
return;
}

/* Get the IrDA descriptor */
err = usbd_get_class_desc(sc->sc_udev, UDESC_IRDA, 0,
USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc);
aprint_error_dev(self, "error %d reading class desc\n", err);
if (err) {
err = usbd_get_desc(sc->sc_udev, UDESC_IRDA, 0,
USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc);
}
aprint_error_dev(self, "error %d reading desc\n", err);
if (err) {
/* maybe it's embedded in the config desc? */
usbd_desc_iter_t iter;
const usb_descriptor_t *d;
usb_desc_iter_init(sc->sc_udev, &iter);
for (;;) {
d = usb_desc_iter_next(&iter);
if (!d || d->bDescriptorType == UDESC_IRDA)
break;
}
if (d == NULL) {
aprint_error_dev(self,
"Cannot get IrDA descriptor\n");
return;
}
memcpy(&sc->sc_irdadesc, d, USB_IRDA_DESCRIPTOR_SIZE);
}
DPRINTF(("uirda_attach: bDescriptorSize %d bDescriptorType %#x "
"bmDataSize=0x%02x bmWindowSize=0x%02x "
"bmMinTurnaroundTime=0x%02x wBaudRate=0x%04x "
"bmAdditionalBOFs=0x%02x bIrdaSniff=%d bMaxUnicastList=%d\n",
sc->sc_irdadesc.bLength,
sc->sc_irdadesc.bDescriptorType,
sc->sc_irdadesc.bmDataSize,
sc->sc_irdadesc.bmWindowSize,
sc->sc_irdadesc.bmMinTurnaroundTime,
UGETW(sc->sc_irdadesc.wBaudRate),
sc->sc_irdadesc.bmAdditionalBOFs,
sc->sc_irdadesc.bIrdaSniff,
sc->sc_irdadesc.bMaxUnicastList));

specrev = UGETW(sc->sc_irdadesc.bcdSpecRevision);
aprint_normal_dev(self, "USB-IrDA protocol version %x.%02x\n",
specrev >> 8, specrev & 0xff);

DPRINTFN(10, ("uirda_attach: %p\n", sc->sc_udev));

usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);

ia.ia_type = IR_TYPE_IRFRAME;
ia.ia_methods = sc->sc_irm ? sc->sc_irm : &uirda_methods;
ia.ia_handle = sc;

sc->sc_child = config_found(self, &ia, ir_print, CFARGS_NONE);

return;
}

int
uirda_detach(device_t self, int flags)
{
struct uirda_softc *sc = device_private(self);
int s;
int rv = 0;

DPRINTF(("uirda_detach: sc=%p flags=%d\n", sc, flags));

sc->sc_dying = 1;
/* Abort all pipes. Causes processes waiting for transfer to wake. */
if (sc->sc_rd_pipe != NULL) {
usbd_abort_pipe(sc->sc_rd_pipe);
}
if (sc->sc_wr_pipe != NULL) {
usbd_abort_pipe(sc->sc_wr_pipe);
}
if (sc->sc_rd_xfer != NULL) {
usbd_destroy_xfer(sc->sc_rd_xfer);
sc->sc_rd_xfer = NULL;
sc->sc_rd_buf = NULL;
}
if (sc->sc_wr_xfer != NULL) {
usbd_destroy_xfer(sc->sc_wr_xfer);
sc->sc_wr_xfer = NULL;
sc->sc_wr_buf = NULL;
}
if (sc->sc_rd_pipe != NULL) {
usbd_close_pipe(sc->sc_rd_pipe);
sc->sc_rd_pipe = NULL;
}
if (sc->sc_wr_pipe != NULL) {
usbd_close_pipe(sc->sc_wr_pipe);
sc->sc_wr_pipe = NULL;
}
wakeup(&sc->sc_rd_count);

s = splusb();
if (--sc->sc_refcnt >= 0) {
/* Wait for processes to go away. */
usb_detach_waitold(sc->sc_dev);
}
splx(s);

if (sc->sc_child != NULL)
rv = config_detach(sc->sc_child, flags);

usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);

mutex_destroy(&sc->sc_wr_buf_lk);
mutex_destroy(&sc->sc_rd_buf_lk);
seldestroy(&sc->sc_rd_sel);

return rv;
}

void
uirda_childdet(device_t self, device_t child)
{
struct uirda_softc *sc = device_private(self);

KASSERT(sc->sc_child == child);
sc->sc_child = NULL;
}

int
uirda_activate(device_t self, enum devact act)
{
struct uirda_softc *sc = device_private(self);

switch (act) {
case DVACT_DEACTIVATE:
sc->sc_dying = 1;
return 0;
default:
return EOPNOTSUPP;
}
}

int
uirda_open(void *h, int flag, int mode,
struct lwp *l)
{
struct uirda_softc *sc = h;
int error;
usbd_status err;

DPRINTF(("%s: sc=%p\n", __func__, sc));

err = usbd_open_pipe(sc->sc_iface, sc->sc_rd_addr, 0, &sc->sc_rd_pipe);
if (err) {
error = EIO;
goto bad1;
}
err = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &sc->sc_wr_pipe);
if (err) {
error = EIO;
goto bad2;
}
error = usbd_create_xfer(sc->sc_rd_pipe,
IRDA_MAX_FRAME_SIZE + sc->sc_hdszi, 0, 0,
&sc->sc_rd_xfer);
if (error)
goto bad3;
sc->sc_rd_buf = usbd_get_buffer(sc->sc_rd_xfer);

/* worst case ST-UIRDA length */
error = usbd_create_xfer(sc->sc_wr_pipe,
IRDA_MAX_FRAME_SIZE + UIRDA_OUTPUT_HEADER_SIZE + 2 + 1,
USBD_FORCE_SHORT_XFER, 0, &sc->sc_wr_xfer);
if (error)
goto bad4;
sc->sc_wr_buf = usbd_get_buffer(sc->sc_wr_xfer);

sc->sc_rd_count = 0;
sc->sc_rd_err = 0;
sc->sc_params.speed = 0;
sc->sc_params.ebofs = 0;
sc->sc_params.maxsize = IRDA_MAX_FRAME_SIZE;
sc->sc_wr_hdr = -1;

err = uirda_start_read(sc);
/* XXX check err */

return 0;

bad4:
usbd_destroy_xfer(sc->sc_rd_xfer);
sc->sc_rd_xfer = NULL;
bad3:
usbd_close_pipe(sc->sc_wr_pipe);
sc->sc_wr_pipe = NULL;
bad2:
usbd_close_pipe(sc->sc_rd_pipe);
sc->sc_rd_pipe = NULL;
bad1:
return error;
}

int
uirda_close(void *h, int flag, int mode,
struct lwp *l)
{
struct uirda_softc *sc = h;

DPRINTF(("%s: sc=%p\n", __func__, sc));

if (sc->sc_rd_pipe != NULL) {
usbd_abort_pipe(sc->sc_rd_pipe);
}
if (sc->sc_wr_pipe != NULL) {
usbd_abort_pipe(sc->sc_wr_pipe);
}
if (sc->sc_rd_xfer != NULL) {
usbd_destroy_xfer(sc->sc_rd_xfer);
sc->sc_rd_xfer = NULL;
sc->sc_rd_buf = NULL;
}
if (sc->sc_wr_xfer != NULL) {
usbd_destroy_xfer(sc->sc_wr_xfer);
sc->sc_wr_xfer = NULL;
sc->sc_wr_buf = NULL;
}
if (sc->sc_rd_pipe != NULL) {
usbd_close_pipe(sc->sc_rd_pipe);
sc->sc_rd_pipe = NULL;
}
if (sc->sc_wr_pipe != NULL) {
usbd_close_pipe(sc->sc_wr_pipe);
sc->sc_wr_pipe = NULL;
}

return 0;
}

int
uirda_read(void *h, struct uio *uio, int flag)
{
struct uirda_softc *sc = h;
int s;
int error;
u_int n;

DPRINTFN(1,("%s: sc=%p\n", __func__, sc));

if (sc->sc_dying)
return EIO;

#ifdef DIAGNOSTIC
if (sc->sc_rd_buf == NULL)
return EINVAL;
#endif

sc->sc_refcnt++;

do {
s = splusb();
while (sc->sc_rd_count == 0) {
DPRINTFN(5,("uirda_read: calling tsleep()\n"));
error = tsleep(&sc->sc_rd_count, PZERO | PCATCH,
"uirdrd", 0);
if (sc->sc_dying)
error = EIO;
if (error) {
splx(s);
DPRINTF(("uirda_read: tsleep() = %d\n", error));
goto ret;
}
}
splx(s);

mutex_enter(&sc->sc_rd_buf_lk);
n = sc->sc_rd_count - sc->sc_hdszi;
DPRINTFN(1,("%s: sc=%p n=%u, hdr=0x%02x\n", __func__,
sc, n, sc->sc_rd_buf[0]));
if (n > uio->uio_resid)
error = EINVAL;
else
error = uiomove(sc->sc_rd_buf + sc->sc_hdszi, n, uio);
sc->sc_rd_count = 0;
mutex_exit(&sc->sc_rd_buf_lk);

uirda_start_read(sc);
/* XXX check uirda_start_read() return value */

} while (n == 0);

DPRINTFN(1,("uirda_read: return %d\n", error));

ret:
if (--sc->sc_refcnt < 0)
usb_detach_wakeupold(sc->sc_dev);
return error;
}

int
uirda_write(void *h, struct uio *uio, int flag)
{
struct uirda_softc *sc = h;
usbd_status err;
uint32_t n;
int error = 0;

DPRINTFN(1,("%s: sc=%p\n", __func__, sc));

if (sc->sc_dying)
return EIO;

#ifdef DIAGNOSTIC
if (sc->sc_wr_buf == NULL)
return EINVAL;
#endif

n = uio->uio_resid;
if (n > sc->sc_params.maxsize)
return EINVAL;

sc->sc_refcnt++;
mutex_enter(&sc->sc_wr_buf_lk);

sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED;
error = uiomove(sc->sc_wr_buf + UIRDA_OUTPUT_HEADER_SIZE, n, uio);
if (error)
goto done;

DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n));

n += UIRDA_OUTPUT_HEADER_SIZE;
err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe,
USBD_FORCE_SHORT_XFER, UIRDA_WR_TIMEOUT, sc->sc_wr_buf, &n);
DPRINTFN(2, ("uirdawrite: err=%d\n", err));
if (err) {
if (err == USBD_INTERRUPTED)
error = EINTR;
else if (err == USBD_TIMEOUT)
error = ETIMEDOUT;
else
error = EIO;
}
done:
mutex_exit(&sc->sc_wr_buf_lk);
if (--sc->sc_refcnt < 0)
usb_detach_wakeupold(sc->sc_dev);

DPRINTFN(1,("%s: sc=%p done\n", __func__, sc));
return error;
}

int
uirda_poll(void *h, int events, struct lwp *l)
{
struct uirda_softc *sc = h;
int revents = 0;
int s;

DPRINTFN(1,("%s: sc=%p\n", __func__, sc));

s = splusb();
if (events & (POLLOUT | POLLWRNORM))
revents |= events & (POLLOUT | POLLWRNORM);
if (events & (POLLIN | POLLRDNORM)) {
if (sc->sc_rd_count != 0) {
DPRINTFN(2,("%s: have data\n", __func__));
revents |= events & (POLLIN | POLLRDNORM);
} else {
DPRINTFN(2,("%s: recording select\n", __func__));
selrecord(l, &sc->sc_rd_sel);
}
}
splx(s);

return revents;
}

static void
filt_uirdardetach(struct knote *kn)
{
struct uirda_softc *sc = kn->kn_hook;
int s;

s = splusb();
selremove_knote(&sc->sc_rd_sel, kn);
splx(s);
}

static int
filt_uirdaread(struct knote *kn, long hint)
{
struct uirda_softc *sc = kn->kn_hook;

kn->kn_data = sc->sc_rd_count;
return kn->kn_data > 0;
}

static const struct filterops uirdaread_filtops = {
.f_flags = FILTEROP_ISFD,
.f_attach = NULL,
.f_detach = filt_uirdardetach,
.f_event = filt_uirdaread,
};

int
uirda_kqfilter(void *h, struct knote *kn)
{
struct uirda_softc *sc = kn->kn_hook;
int s;

switch (kn->kn_filter) {
case EVFILT_READ:
kn->kn_fop = &uirdaread_filtops;
kn->kn_hook = sc;
s = splusb();
selrecord_knote(&sc->sc_rd_sel, kn);
splx(s);
break;

case EVFILT_WRITE:
kn->kn_fop = &seltrue_filtops;
break;

default:
return EINVAL;
}

return 0;
}

int
uirda_set_params(void *h, struct irda_params *p)
{
struct uirda_softc *sc = h;
usbd_status err;
int i;
uint8_t hdr;
uint32_t n;
u_int mask;

DPRINTF(("%s: sc=%p, speed=%d ebofs=%d maxsize=%d\n", __func__,
sc, p->speed, p->ebofs, p->maxsize));

if (sc->sc_dying)
return EIO;

hdr = 0;
if (p->ebofs != sc->sc_params.ebofs) {
/* round up ebofs */
mask = 1 /* sc->sc_irdadesc.bmAdditionalBOFs*/;
DPRINTF(("u.s.p.: mask=%#x, sc->ebofs=%d, p->ebofs=%d\n",
mask, sc->sc_params.ebofs, p->ebofs));
for (i = 0; i < UIRDA_NEBOFS; i++) {
DPRINTF(("u.s.p.: u_e[%d].mask=%#x, count=%d\n",
i, uirda_ebofs[i].mask, uirda_ebofs[i].count));
if ((mask & uirda_ebofs[i].mask) &&
uirda_ebofs[i].count >= p->ebofs) {
hdr = uirda_ebofs[i].header;
goto found1;
}
}
for (i = 0; i < UIRDA_NEBOFS; i++) {
DPRINTF(("u.s.p.: u_e[%d].mask=%#x, count=%d\n",
i, uirda_ebofs[i].mask, uirda_ebofs[i].count));
if ((mask & uirda_ebofs[i].mask)) {
hdr = uirda_ebofs[i].header;
goto found1;
}
}
/* no good value found */
return EINVAL;
found1:
DPRINTF(("uirda_set_params: ebofs hdr=0x%02x\n", hdr));
;

}
if (hdr != 0 || p->speed != sc->sc_params.speed) {
/* find speed */
mask = UGETW(sc->sc_irdadesc.wBaudRate);
for (i = 0; i < UIRDA_NSPEEDS; i++) {
if ((mask & uirda_speeds[i].mask) &&
uirda_speeds[i].speed == p->speed) {
hdr |= uirda_speeds[i].header;
goto found2;
}
}
/* no good value found */
return EINVAL;
found2:
DPRINTF(("uirda_set_params: speed hdr=0x%02x\n", hdr));
;
}
if (p->maxsize != sc->sc_params.maxsize) {
if (p->maxsize > IRDA_MAX_FRAME_SIZE)
return EINVAL;
sc->sc_params.maxsize = p->maxsize;
#if 0
DPRINTF(("%s: new buffers, old size=%d\n", __func__,
sc->sc_params.maxsize));
if (p->maxsize > 10000 || p < 0) /* XXX */
return EINVAL;

/* Change the write buffer */
mutex_enter(&sc->sc_wr_buf_lk);
if (sc->sc_wr_buf != NULL)
usbd_free_buffer(sc->sc_wr_xfer);
sc->sc_wr_buf = usbd_get_buffer(sc->sc_wr_xfer, p->maxsize+1);
mutex_exit(&sc->sc_wr_buf_lk);
if (sc->sc_wr_buf == NULL)
return ENOMEM;

/* Change the read buffer */
mutex_enter(&sc->sc_rd_buf_lk);
usbd_abort_pipe(sc->sc_rd_pipe);
if (sc->sc_rd_buf != NULL)
usbd_free_buffer(sc->sc_rd_xfer);
sc->sc_rd_buf = usbd_get_buffer(sc->sc_rd_xfer, p->maxsize+1);
sc->sc_rd_count = 0;
if (sc->sc_rd_buf == NULL) {
mutex_exit(&sc->sc_rd_buf_lk);
return ENOMEM;
}
sc->sc_params.maxsize = p->maxsize;
err = uirda_start_read(sc); /* XXX check */
mutex_exit(&sc->sc_rd_buf_lk);
#endif
}
if (hdr != 0 && hdr != sc->sc_wr_hdr) {
/*
* A change has occurred, transmit a 0 length frame with
* the new settings. The 0 length frame is not sent to the
* device.
*/
DPRINTF(("%s: sc=%p setting header 0x%02x\n",
__func__, sc, hdr));
sc->sc_wr_hdr = hdr;
mutex_enter(&sc->sc_wr_buf_lk);
sc->sc_wr_buf[0] = hdr;
n = UIRDA_OUTPUT_HEADER_SIZE;
err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe,
USBD_FORCE_SHORT_XFER, UIRDA_WR_TIMEOUT,
sc->sc_wr_buf, &n);
if (err) {
aprint_error_dev(sc->sc_dev, "set failed, err=%d\n",
err);
usbd_clear_endpoint_stall(sc->sc_wr_pipe);
}
mutex_exit(&sc->sc_wr_buf_lk);
}

sc->sc_params = *p;

return 0;
}

int
uirda_get_speeds(void *h, int *speeds)
{
struct uirda_softc *sc = h;
u_int isp;
u_int usp;

DPRINTF(("%s: sc=%p\n", __func__, sc));

if (sc->sc_dying)
return EIO;

usp = UGETW(sc->sc_irdadesc.wBaudRate);
isp = 0;
if (usp & UI_BR_4000000) isp |= IRDA_SPEED_4000000;
if (usp & UI_BR_1152000) isp |= IRDA_SPEED_1152000;
if (usp & UI_BR_576000) isp |= IRDA_SPEED_576000;
if (usp & UI_BR_115200) isp |= IRDA_SPEED_115200;
if (usp & UI_BR_57600) isp |= IRDA_SPEED_57600;
if (usp & UI_BR_38400) isp |= IRDA_SPEED_38400;
if (usp & UI_BR_19200) isp |= IRDA_SPEED_19200;
if (usp & UI_BR_9600) isp |= IRDA_SPEED_9600;
if (usp & UI_BR_2400) isp |= IRDA_SPEED_2400;
*speeds = isp;
DPRINTF(("%s: speeds = %#x\n", __func__, isp));
return 0;
}

int
uirda_get_turnarounds(void *h, int *turnarounds)
{
struct uirda_softc *sc = h;
u_int ita;
u_int uta;

DPRINTF(("%s: sc=%p\n", __func__, sc));

if (sc->sc_dying)
return EIO;

uta = sc->sc_irdadesc.bmMinTurnaroundTime;
ita = 0;
if (uta & UI_TA_0) ita |= IRDA_TURNT_0;
if (uta & UI_TA_10) ita |= IRDA_TURNT_10;
if (uta & UI_TA_50) ita |= IRDA_TURNT_50;
if (uta & UI_TA_100) ita |= IRDA_TURNT_100;
if (uta & UI_TA_500) ita |= IRDA_TURNT_500;
if (uta & UI_TA_1000) ita |= IRDA_TURNT_1000;
if (uta & UI_TA_5000) ita |= IRDA_TURNT_5000;
if (uta & UI_TA_10000) ita |= IRDA_TURNT_10000;
*turnarounds = ita;
return 0;
}

static void
uirda_rd_cb(struct usbd_xfer *xfer, void *priv,
usbd_status status)
{
struct uirda_softc *sc = priv;
uint32_t size;

DPRINTFN(1,("%s: sc=%p\n", __func__, sc));

if (status == USBD_CANCELLED) /* this is normal */
return;
if (status) {
size = sc->sc_hdszi;
sc->sc_rd_err = 1;
} else {
usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL);
}
DPRINTFN(1,("%s: sc=%p size=%u, err=%d\n", __func__, sc, size,
sc->sc_rd_err));
sc->sc_rd_count = size;
wakeup(&sc->sc_rd_count); /* XXX should use flag */
selnotify(&sc->sc_rd_sel, 0, 0);
}

static usbd_status
uirda_start_read(struct uirda_softc *sc)
{
usbd_status err;

DPRINTFN(1,("%s: sc=%p, size=%d\n", __func__, sc,
sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE));

if (sc->sc_dying)
return USBD_IOERROR;

if (sc->sc_rd_err) {
sc->sc_rd_err = 0;
DPRINTF(("uirda_start_read: clear stall\n"));
usbd_clear_endpoint_stall(sc->sc_rd_pipe);
}

usbd_setup_xfer(sc->sc_rd_xfer, sc, sc->sc_rd_buf,
sc->sc_params.maxsize + sc->sc_hdszi, USBD_SHORT_XFER_OK,
USBD_NO_TIMEOUT, uirda_rd_cb);
err = usbd_transfer(sc->sc_rd_xfer);
if (err != USBD_IN_PROGRESS) {
DPRINTF(("uirda_start_read: err=%d\n", err));
return err;
}
return USBD_NORMAL_COMPLETION;
}

usbd_status
usbd_get_class_desc(struct usbd_device *dev, int type, int index, int len, void *desc)
{
usb_device_request_t req;

DPRINTFN(3,("usbd_get_desc: type=%d, index=%d, len=%d\n",
type, index, len));

req.bmRequestType = 0xa1; /* XXX ? */
req.bRequest = UR_GET_DESCRIPTOR;
USETW2(req.wValue, type, index);
USETW(req.wIndex, 0);
USETW(req.wLength, len);
return usbd_do_request(dev, &req, desc);
}