int
uhid_do_write(struct uhid_softc *sc, struct uio *uio, int flag)
{
int error;
int size;
usbd_status err;
DPRINTFN(1, ("uhidwrite\n"));
if (sc->sc_dying)
return (EIO);
size = sc->sc_osize;
error = 0;
if (uio->uio_resid != size)
return (EINVAL);
error = uiomove(sc->sc_obuf, size, uio);
if (!error) {
if (sc->sc_oid)
err = usbd_set_report(sc->sc_iface, UHID_OUTPUT_REPORT,
sc->sc_obuf[0], sc->sc_obuf+1, size-1);
else
err = usbd_set_report(sc->sc_iface, UHID_OUTPUT_REPORT,
0, sc->sc_obuf, size);
if (err)
error = EIO;
}
return (error);
}
usbd_status
uhidev_set_report(struct uhidev *scd, int type, void *data, int len)
{
char *buf;
usbd_status retstat;
if (scd->sc_report_id == 0)
return usbd_set_report(scd->sc_parent->sc_iface, type,
scd->sc_report_id, data, len);
buf = malloc(len + 1, M_TEMP, M_WAITOK);
buf[0] = scd->sc_report_id;
memcpy(buf+1, data, len);
retstat = usbd_set_report(scd->sc_parent->sc_iface, type,
scd->sc_report_id, buf, len + 1);
free(buf, M_TEMP);
return retstat;
}
usbd_status
uhidev_set_report(struct uhidev *scd, int type, void *data, int len)
{
/* XXX */
char buf[100];
if (scd->sc_report_id) {
buf[0] = scd->sc_report_id;
memcpy(buf+1, data, len);
len++;
data = buf;
}
return usbd_set_report(scd->sc_parent->sc_iface, type,
scd->sc_report_id, data, len);
}
int
uhidev_use_rdesc(struct uhidev_softc *sc, int vendor, int product,
void **descp, int *sizep)
{
static uByte reportbuf[] = {2, 2, 2};
const void *descptr = NULL;
void *desc;
int size;
if (vendor == USB_VENDOR_WACOM) {
/* The report descriptor for the Wacom Graphire is broken. */
switch (product) {
case USB_PRODUCT_WACOM_GRAPHIRE:
size = sizeof(uhid_graphire_report_descr);
descptr = uhid_graphire_report_descr;
break;
case USB_PRODUCT_WACOM_GRAPHIRE3_4X5:
case USB_PRODUCT_WACOM_GRAPHIRE4_4X5:
usbd_set_report(sc->sc_iface, UHID_FEATURE_REPORT, 2,
&reportbuf, sizeof(reportbuf));
size = sizeof(uhid_graphire3_4x5_report_descr);
descptr = uhid_graphire3_4x5_report_descr;
break;
default:
break;
}
} else if (vendor == USB_VENDOR_MICROSOFT &&
product == USB_PRODUCT_MICROSOFT_XBOX360_CONTROLLER) {
/* The Xbox 360 gamepad has no report descriptor. */
size = sizeof(uhid_xb360gp_report_descr);
descptr = uhid_xb360gp_report_descr;
}
if (descptr) {
desc = malloc(size, M_USBDEV, M_NOWAIT);
if (desc == NULL)
return (ENOMEM);
memcpy(desc, descptr, size);
*descp = desc;
*sizep = size;
}
return (0);
}
void
uhidev_attach(struct device *parent, struct device *self, void *aux)
{
struct uhidev_softc *sc = (struct uhidev_softc *)self;
struct usb_attach_arg *uaa = aux;
usbd_interface_handle iface = uaa->iface;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
struct uhidev_attach_arg uha;
struct uhidev *dev;
int size, nrepid, repid, repsz;
int repsizes[256];
int i;
void *desc;
const void *descptr;
usbd_status err;
sc->sc_udev = uaa->device;
sc->sc_iface = iface;
id = usbd_get_interface_descriptor(iface);
(void)usbd_set_idle(iface, 0, 0);
#if 0
qflags = usbd_get_quirks(sc->sc_udev)->uq_flags;
if ((qflags & UQ_NO_SET_PROTO) == 0 &&
id->bInterfaceSubClass != UISUBCLASS_BOOT)
(void)usbd_set_protocol(iface, 1);
#endif
sc->sc_iep_addr = sc->sc_oep_addr = -1;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
printf("%s: could not read endpoint descriptor\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
DPRINTFN(10,("uhidev_attach: bLength=%d bDescriptorType=%d "
"bEndpointAddress=%d-%s bmAttributes=%d wMaxPacketSize=%d"
" bInterval=%d\n",
ed->bLength, ed->bDescriptorType,
ed->bEndpointAddress & UE_ADDR,
UE_GET_DIR(ed->bEndpointAddress)==UE_DIR_IN? "in" : "out",
ed->bmAttributes & UE_XFERTYPE,
UGETW(ed->wMaxPacketSize), ed->bInterval));
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
(ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
sc->sc_iep_addr = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
(ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
sc->sc_oep_addr = ed->bEndpointAddress;
} else {
printf("%s: unexpected endpoint\n", sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
}
/*
* Check that we found an input interrupt endpoint. The output interrupt
* endpoint is optional
*/
if (sc->sc_iep_addr == -1) {
printf("%s: no input interrupt endpoint\n", sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
/* XXX need to extend this */
descptr = NULL;
if (uaa->vendor == USB_VENDOR_WACOM) {
static uByte reportbuf[] = {2, 2, 2};
/* The report descriptor for the Wacom Graphire is broken. */
switch (uaa->product) {
case USB_PRODUCT_WACOM_GRAPHIRE:
size = sizeof uhid_graphire_report_descr;
descptr = uhid_graphire_report_descr;
break;
case USB_PRODUCT_WACOM_GRAPHIRE3_4X5:
case USB_PRODUCT_WACOM_GRAPHIRE4_4X5:
usbd_set_report(uaa->iface, UHID_FEATURE_REPORT, 2,
&reportbuf, sizeof reportbuf);
size = sizeof uhid_graphire3_4x5_report_descr;
descptr = uhid_graphire3_4x5_report_descr;
break;
default:
/* Keep descriptor */
break;
}
}
if (descptr) {
desc = malloc(size, M_USBDEV, M_NOWAIT);
if (desc == NULL)
err = USBD_NOMEM;
else {
err = USBD_NORMAL_COMPLETION;
memcpy(desc, descptr, size);
}
} else {
desc = NULL;
err = usbd_read_report_desc(uaa->iface, &desc, &size, M_USBDEV);
}
if (err) {
printf("%s: no report descriptor\n", sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
sc->sc_repdesc = desc;
sc->sc_repdesc_size = size;
uha.uaa = uaa;
nrepid = uhidev_maxrepid(desc, size);
if (nrepid < 0)
return;
printf("%s: iclass %d/%d", sc->sc_dev.dv_xname,
id->bInterfaceClass, id->bInterfaceSubClass);
if (nrepid > 0)
printf(", %d report id%s", nrepid,
nrepid > 1 ? "s" : "");
printf("\n");
nrepid++;
sc->sc_subdevs = malloc(nrepid * sizeof(struct device *),
M_USBDEV, M_NOWAIT | M_ZERO);
if (sc->sc_subdevs == NULL) {
printf("%s: no memory\n", sc->sc_dev.dv_xname);
return;
}
sc->sc_nrepid = nrepid;
sc->sc_isize = 0;
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
&sc->sc_dev);
for (repid = 0; repid < nrepid; repid++) {
repsz = hid_report_size(desc, size, hid_input, repid);
DPRINTF(("uhidev_match: repid=%d, repsz=%d\n", repid, repsz));
repsizes[repid] = repsz;
if (repsz > 0) {
if (repsz > sc->sc_isize)
sc->sc_isize = repsz;
}
}
sc->sc_isize += nrepid != 1; /* space for report ID */
DPRINTF(("uhidev_attach: isize=%d\n", sc->sc_isize));
uha.parent = sc;
for (repid = 0; repid < nrepid; repid++) {
DPRINTF(("uhidev_match: try repid=%d\n", repid));
if (hid_report_size(desc, size, hid_input, repid) == 0 &&
hid_report_size(desc, size, hid_output, repid) == 0 &&
hid_report_size(desc, size, hid_feature, repid) == 0) {
; /* already NULL in sc->sc_subdevs[repid] */
} else {
uha.reportid = repid;
dev = (struct uhidev *)config_found_sm(self, &uha,
uhidevprint, uhidevsubmatch);
sc->sc_subdevs[repid] = dev;
if (dev != NULL) {
dev->sc_in_rep_size = repsizes[repid];
#ifdef DIAGNOSTIC
DPRINTF(("uhidev_match: repid=%d dev=%p\n",
repid, dev));
if (dev->sc_intr == NULL) {
DPRINTF(("%s: sc_intr == NULL\n",
sc->sc_dev.dv_xname));
return;
}
#endif
}
}
}
}
int
uhid_do_ioctl(struct uhid_softc *sc, u_long cmd, caddr_t addr, int flag,
usb_proc_ptr p)
{
struct usb_ctl_report_desc *rd;
struct usb_ctl_report *re;
int size, id;
usbd_status err;
DPRINTFN(2, ("uhidioctl: cmd=%lx\n", cmd));
if (sc->sc_dying)
return (EIO);
switch (cmd) {
case FIONBIO:
/* All handled in the upper FS layer. */
break;
case FIOASYNC:
if (*(int *)addr) {
if (sc->sc_async != NULL)
return (EBUSY);
sc->sc_async = p->td_proc; /* XXXKSE */
DPRINTF(("uhid_do_ioctl: FIOASYNC %p\n", p->td_proc));
} else
sc->sc_async = NULL;
break;
/* XXX this is not the most general solution. */
case TIOCSPGRP:
if (sc->sc_async == NULL)
return (EINVAL);
if (*(int *)addr != sc->sc_async->p_pgid)
return (EPERM);
break;
case USB_GET_REPORT_DESC:
rd = (struct usb_ctl_report_desc *)addr;
size = min(sc->sc_repdesc_size, sizeof rd->ucrd_data);
rd->ucrd_size = size;
memcpy(rd->ucrd_data, sc->sc_repdesc, size);
break;
case USB_SET_IMMED:
if (*(int *)addr) {
/* XXX should read into ibuf, but does it matter? */
err = usbd_get_report(sc->sc_iface, UHID_INPUT_REPORT,
sc->sc_iid, sc->sc_ibuf, sc->sc_isize);
if (err)
return (EOPNOTSUPP);
sc->sc_state |= UHID_IMMED;
} else
sc->sc_state &= ~UHID_IMMED;
break;
case USB_GET_REPORT:
re = (struct usb_ctl_report *)addr;
switch (re->ucr_report) {
case UHID_INPUT_REPORT:
size = sc->sc_isize;
id = sc->sc_iid;
break;
case UHID_OUTPUT_REPORT:
size = sc->sc_osize;
id = sc->sc_oid;
break;
case UHID_FEATURE_REPORT:
size = sc->sc_fsize;
id = sc->sc_fid;
break;
default:
return (EINVAL);
}
err = usbd_get_report(sc->sc_iface, re->ucr_report, id, re->ucr_data,
size);
if (err)
return (EIO);
break;
case USB_SET_REPORT:
re = (struct usb_ctl_report *)addr;
switch (re->ucr_report) {
case UHID_INPUT_REPORT:
size = sc->sc_isize;
id = sc->sc_iid;
break;
case UHID_OUTPUT_REPORT:
size = sc->sc_osize;
id = sc->sc_oid;
break;
case UHID_FEATURE_REPORT:
size = sc->sc_fsize;
id = sc->sc_fid;
break;
default:
return (EINVAL);
}
err = usbd_set_report(sc->sc_iface, re->ucr_report, id, re->ucr_data,
size);
if (err)
return (EIO);
break;
default:
return (EINVAL);
}
return (0);
}
void
uhidev_attach(device_t parent, device_t self, void *aux)
{
struct uhidev_softc *sc = device_private(self);
struct usbif_attach_arg *uiaa = aux;
struct usbd_interface *iface = uiaa->uiaa_iface;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
struct uhidev_attach_arg uha;
device_t dev;
struct uhidev *csc;
int maxinpktsize, size, nrepid, repid, repsz;
int *repsizes;
int i;
void *desc;
const void *descptr;
usbd_status err;
char *devinfop;
int locs[UHIDBUSCF_NLOCS];
sc->sc_dev = self;
sc->sc_udev = uiaa->uiaa_device;
sc->sc_iface = iface;
aprint_naive("\n");
aprint_normal("\n");
mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
id = usbd_get_interface_descriptor(iface);
devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0);
aprint_normal_dev(self, "%s, iclass %d/%d\n",
devinfop, id->bInterfaceClass, id->bInterfaceSubClass);
usbd_devinfo_free(devinfop);
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
(void)usbd_set_idle(iface, 0, 0);
#if 0
if ((usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_NO_SET_PROTO) == 0 &&
id->bInterfaceSubClass != UISUBCLASS_BOOT)
(void)usbd_set_protocol(iface, 1);
#endif
maxinpktsize = 0;
sc->sc_iep_addr = sc->sc_oep_addr = -1;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
aprint_error_dev(self,
"could not read endpoint descriptor\n");
sc->sc_dying = 1;
return;
}
DPRINTFN(10,("uhidev_attach: bLength=%d bDescriptorType=%d "
"bEndpointAddress=%d-%s bmAttributes=%d wMaxPacketSize=%d"
" bInterval=%d\n",
ed->bLength, ed->bDescriptorType,
ed->bEndpointAddress & UE_ADDR,
UE_GET_DIR(ed->bEndpointAddress)==UE_DIR_IN? "in" : "out",
ed->bmAttributes & UE_XFERTYPE,
UGETW(ed->wMaxPacketSize), ed->bInterval));
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
(ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
maxinpktsize = UGETW(ed->wMaxPacketSize);
sc->sc_iep_addr = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
(ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
sc->sc_oep_addr = ed->bEndpointAddress;
} else {
aprint_verbose_dev(self, "endpoint %d: ignored\n", i);
}
}
/*
* Check that we found an input interrupt endpoint. The output interrupt
* endpoint is optional
*/
if (sc->sc_iep_addr == -1) {
aprint_error_dev(self, "no input interrupt endpoint\n");
sc->sc_dying = 1;
return;
}
/* XXX need to extend this */
descptr = NULL;
if (uiaa->uiaa_vendor == USB_VENDOR_WACOM) {
static uByte reportbuf[] = {2, 2, 2};
/* The report descriptor for the Wacom Graphire is broken. */
switch (uiaa->uiaa_product) {
case USB_PRODUCT_WACOM_GRAPHIRE:
case USB_PRODUCT_WACOM_GRAPHIRE2:
case USB_PRODUCT_WACOM_GRAPHIRE3_4X5:
case USB_PRODUCT_WACOM_GRAPHIRE3_6X8:
case USB_PRODUCT_WACOM_GRAPHIRE4_4X5: /* The 6x8 too? */
/*
* The Graphire3 needs 0x0202 to be written to
* feature report ID 2 before it'll start
* returning digitizer data.
*/
usbd_set_report(uiaa->uiaa_iface, UHID_FEATURE_REPORT, 2,
&reportbuf, sizeof(reportbuf));
size = sizeof(uhid_graphire3_4x5_report_descr);
descptr = uhid_graphire3_4x5_report_descr;
break;
default:
/* Keep descriptor */
break;
}
}
if (USBIF_IS_XINPUT(uiaa)) {
size = sizeof(uhid_xinput_report_descr);
descptr = uhid_xinput_report_descr;
}
if (USBIF_IS_X1INPUT(uiaa)) {
sc->sc_flags |= UHIDEV_F_XB1;
size = sizeof(uhid_x1input_report_descr);
descptr = uhid_x1input_report_descr;
}
if (descptr) {
desc = kmem_alloc(size, KM_SLEEP);
if (desc == NULL)
err = USBD_NOMEM;
else {
err = USBD_NORMAL_COMPLETION;
memcpy(desc, descptr, size);
}
} else {
desc = NULL;
err = usbd_read_report_desc(uiaa->uiaa_iface, &desc, &size);
}
if (err) {
aprint_error_dev(self, "no report descriptor\n");
sc->sc_dying = 1;
return;
}
if (uiaa->uiaa_vendor == USB_VENDOR_HOSIDEN &&
uiaa->uiaa_product == USB_PRODUCT_HOSIDEN_PPP) {
static uByte reportbuf[] = { 1 };
/*
* This device was sold by Konami with its ParaParaParadise
* game for PlayStation2. It needs to be "turned on"
* before it will send any reports.
*/
usbd_set_report(uiaa->uiaa_iface, UHID_FEATURE_REPORT, 0,
&reportbuf, sizeof(reportbuf));
}
if (uiaa->uiaa_vendor == USB_VENDOR_LOGITECH &&
uiaa->uiaa_product == USB_PRODUCT_LOGITECH_CBT44 && size == 0xb1) {
uint8_t *data = desc;
/*
* This device has a odd USAGE_MINIMUM value that would
* cause the multimedia keys to have their usage number
* shifted up one usage. Adjust so the usages are sane.
*/
if (data[0x56] == 0x19 && data[0x57] == 0x01 &&
data[0x58] == 0x2a && data[0x59] == 0x8c)
data[0x57] = 0x00;
}
/*
* Enable the Six Axis and DualShock 3 controllers.
* See http://ps3.jim.sh/sixaxis/usb/
*/
if (uiaa->uiaa_vendor == USB_VENDOR_SONY &&
uiaa->uiaa_product == USB_PRODUCT_SONY_PS3CONTROLLER) {
usb_device_request_t req;
char data[17];
int actlen;
req.bmRequestType = UT_READ_CLASS_INTERFACE;
req.bRequest = 1;
USETW(req.wValue, 0x3f2);
USETW(req.wIndex, 0);
USETW(req.wLength, sizeof(data));
usbd_do_request_flags(sc->sc_udev, &req, data,
USBD_SHORT_XFER_OK, &actlen, USBD_DEFAULT_TIMEOUT);
}
sc->sc_repdesc = desc;
sc->sc_repdesc_size = size;
uha.uiaa = uiaa;
nrepid = uhidev_maxrepid(desc, size);
if (nrepid < 0)
return;
if (nrepid > 0)
aprint_normal_dev(self, "%d report ids\n", nrepid);
nrepid++;
repsizes = kmem_alloc(nrepid * sizeof(*repsizes), KM_SLEEP);
if (repsizes == NULL)
goto nomem;
sc->sc_subdevs = kmem_zalloc(nrepid * sizeof(device_t),
KM_SLEEP);
if (sc->sc_subdevs == NULL) {
kmem_free(repsizes, nrepid * sizeof(*repsizes));
nomem:
aprint_error_dev(self, "no memory\n");
return;
}
/* Just request max packet size for the interrupt pipe */
sc->sc_isize = maxinpktsize;
sc->sc_nrepid = nrepid;
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
for (repid = 0; repid < nrepid; repid++) {
repsz = hid_report_size(desc, size, hid_input, repid);
DPRINTF(("uhidev_match: repid=%d, repsz=%d\n", repid, repsz));
repsizes[repid] = repsz;
}
DPRINTF(("uhidev_attach: isize=%d\n", sc->sc_isize));
uha.parent = sc;
for (repid = 0; repid < nrepid; repid++) {
DPRINTF(("uhidev_match: try repid=%d\n", repid));
if (hid_report_size(desc, size, hid_input, repid) == 0 &&
hid_report_size(desc, size, hid_output, repid) == 0 &&
hid_report_size(desc, size, hid_feature, repid) == 0) {
; /* already NULL in sc->sc_subdevs[repid] */
} else {
uha.reportid = repid;
locs[UHIDBUSCF_REPORTID] = repid;
dev = config_found_sm_loc(self,
"uhidbus", locs, &uha,
uhidevprint, config_stdsubmatch);
sc->sc_subdevs[repid] = dev;
if (dev != NULL) {
csc = device_private(dev);
csc->sc_in_rep_size = repsizes[repid];
#ifdef DIAGNOSTIC
DPRINTF(("uhidev_match: repid=%d dev=%p\n",
repid, dev));
if (csc->sc_intr == NULL) {
kmem_free(repsizes,
nrepid * sizeof(*repsizes));
aprint_error_dev(self,
"sc_intr == NULL\n");
return;
}
#endif
rnd_attach_source(&csc->rnd_source,
device_xname(dev),
RND_TYPE_TTY,
RND_FLAG_DEFAULT);
}
}
}
kmem_free(repsizes, nrepid * sizeof(*repsizes));
return;
}
