/*
* Get mac address
*/
static int
lgue_getmac(struct lgue_softc *sc, void *buf)
{
const usb_cdc_ethernet_descriptor_t *ced;
usb_interface_descriptor_t *id;
char sbuf[ETHER_ADDR_LEN * 2 + 1];
usbd_status err;
int i;
id = usbd_get_interface_descriptor(sc->lgue_ctl_iface);
if (id == NULL) goto bad;
ced = (const usb_cdc_ethernet_descriptor_t *)usb_find_desc_if(sc->lgue_udev,
UDESC_CS_INTERFACE, UDESCSUB_CDC_ETHERNET, id);
if (ced == NULL) goto bad;
err = usbd_get_string(sc->lgue_udev, ced->iMACAddress, sbuf);
if(err) {
kprintf("Read MAC address failed\n");
goto bad;
}
for (i = 0; i < ETHER_ADDR_LEN; ++i) {
((uByte *)buf)[i] = (hex(sbuf[i * 2]) << 4) + hex(sbuf[(i * 2) + 1]);
}
return(0);
bad:
return(-1);
}
int
uhub_child_pnpinfo_str(device_t cbdev, device_t child, char *buf,
size_t buflen)
{
struct uhub_softc *sc = device_get_softc(cbdev);
usbd_device_handle devhub = sc->sc_hub;
usbd_device_handle dev;
struct usbd_interface *iface;
char serial[128];
int nports;
int port;
int i;
crit_enter();
nports = devhub->hub->hubdesc.bNbrPorts;
for (port = 0; port < nports; port++) {
dev = devhub->hub->ports[port].device;
if (dev && dev->subdevs) {
for (i = 0; dev->subdevs[i]; i++) {
if (dev->subdevs[i] == child) {
goto found_dev;
}
}
}
}
DPRINTFN(0,("uhub_child_pnpinfo_str: device not on hub\n"));
buf[0] = '\0';
crit_exit();
return (0);
found_dev:
/* XXX can sleep */
(void)usbd_get_string(dev, dev->ddesc.iSerialNumber, &serial[0]);
if (dev->ifacenums == NULL) {
ksnprintf(buf, buflen, "vendor=0x%04x product=0x%04x "
"devclass=0x%02x devsubclass=0x%02x "
"release=0x%04x sernum=\"%s\"",
UGETW(dev->ddesc.idVendor), UGETW(dev->ddesc.idProduct),
dev->ddesc.bDeviceClass, dev->ddesc.bDeviceSubClass,
UGETW(dev->ddesc.bcdDevice), serial);
} else {
iface = &dev->ifaces[dev->ifacenums[i]];
ksnprintf(buf, buflen, "vendor=0x%04x product=0x%04x "
"devclass=0x%02x devsubclass=0x%02x "
"release=0x%04x sernum=\"%s\" "
"intclass=0x%02x intsubclass=0x%02x",
UGETW(dev->ddesc.idVendor), UGETW(dev->ddesc.idProduct),
dev->ddesc.bDeviceClass, dev->ddesc.bDeviceSubClass,
UGETW(dev->ddesc.bcdDevice), serial,
iface->idesc->bInterfaceClass,
iface->idesc->bInterfaceSubClass);
}
crit_exit();
return (0);
}
static void
usbd_devinfo_vp(usbd_device_handle dev, char *v, char *p, int usedev)
{
usb_device_descriptor_t *udd = &dev->ddesc;
char *vendor = 0, *product = 0;
if (dev == NULL) {
v[0] = p[0] = '\0';
return;
}
if (usedev) {
if (usbd_get_string(dev, udd->iManufacturer, v))
vendor = NULL;
else
vendor = v;
usbd_trim_spaces(vendor);
if (usbd_get_string(dev, udd->iProduct, p))
product = NULL;
else
product = p;
usbd_trim_spaces(product);
if (vendor && !*vendor)
vendor = NULL;
if (product && !*product)
product = NULL;
} else {
vendor = NULL;
product = NULL;
}
if (vendor != NULL && *vendor)
strcpy(v, vendor);
else
ksprintf(v, "vendor 0x%04x", UGETW(udd->idVendor));
if (product != NULL && *product)
strcpy(p, product);
else
ksprintf(p, "product 0x%04x", UGETW(udd->idProduct));
}
static int ep0_get_descriptor (struct usb_device_instance *device,
struct urb *urb,
int max,
int descriptor_type,
int index)
{
char *cp;
urb->actual_length = 0;
cp = (char*)urb->buffer;
switch (descriptor_type) {
case USB_DESCRIPTOR_TYPE_DEVICE:
{
struct usb_device_descriptor *device_descriptor;
if (!(device_descriptor = usbd_device_device_descriptor(device)))
return -1;
copy_config(urb, device_descriptor, sizeof(struct usb_device_descriptor), max);
}
break;
case USB_DESCRIPTOR_TYPE_CONFIGURATION:
{
struct usb_configuration_descriptor *configuration_descriptor;
struct usb_device_descriptor *device_descriptor;
usb_info("get configuration, index = %d\n", index);
if (!(device_descriptor = usbd_device_device_descriptor (device)))
return -1;
if (index >= device_descriptor->bNumConfigurations) {
return -1;
}
if (!(configuration_descriptor = usbd_device_configuration_descriptor (device, index)))
return -1;
copy_config (urb, configuration_descriptor,
cpu_to_le16(configuration_descriptor->wTotalLength), max);
}
break;
case USB_DESCRIPTOR_TYPE_STRING:
{
struct usb_string_descriptor *string_descriptor;
usb_info("get string, index = %d, max = %d\n", index, max);
string_descriptor = usbd_get_string (index);
// if (!(string_descriptor))
// return -1;
copy_config (urb, string_descriptor, string_descriptor->bLength, max);
}
break;
case USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER:
//TODO
case USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION:
//TODO
case USB_DESCRIPTOR_TYPE_INTERFACE: //should not see this
case USB_DESCRIPTOR_TYPE_ENDPOINT: //should not see this
default:
return -1;
}
return 0;
}
void
usbd_fill_deviceinfo(struct usbd_device *dev, struct usb_device_info *di,
int usedev)
{
struct usbd_port *p;
int i, j, err;
di->udi_bus = device_unit(dev->ud_bus->ub_usbctl);
di->udi_addr = dev->ud_addr;
di->udi_cookie = dev->ud_cookie;
usbd_devinfo_vp(dev, di->udi_vendor, sizeof(di->udi_vendor),
di->udi_product, sizeof(di->udi_product), usedev, 1);
usbd_printBCD(di->udi_release, sizeof(di->udi_release),
UGETW(dev->ud_ddesc.bcdDevice));
if (usedev) {
usbd_status uerr = usbd_get_string(dev,
dev->ud_ddesc.iSerialNumber, di->udi_serial);
if (uerr != USBD_NORMAL_COMPLETION) {
di->udi_serial[0] = '\0';
} else {
usbd_trim_spaces(di->udi_serial);
}
} else {
di->udi_serial[0] = '\0';
if (dev->ud_serial) {
strlcpy(di->udi_serial, dev->ud_serial,
sizeof(di->udi_serial));
}
}
di->udi_vendorNo = UGETW(dev->ud_ddesc.idVendor);
di->udi_productNo = UGETW(dev->ud_ddesc.idProduct);
di->udi_releaseNo = UGETW(dev->ud_ddesc.bcdDevice);
di->udi_class = dev->ud_ddesc.bDeviceClass;
di->udi_subclass = dev->ud_ddesc.bDeviceSubClass;
di->udi_protocol = dev->ud_ddesc.bDeviceProtocol;
di->udi_config = dev->ud_config;
di->udi_power = dev->ud_selfpowered ? 0 : dev->ud_power;
di->udi_speed = dev->ud_speed;
if (dev->ud_subdevlen > 0) {
for (i = 0, j = 0; i < dev->ud_subdevlen &&
j < USB_MAX_DEVNAMES; i++) {
if (!dev->ud_subdevs[i])
continue;
strncpy(di->udi_devnames[j],
device_xname(dev->ud_subdevs[i]), USB_MAX_DEVNAMELEN);
di->udi_devnames[j][USB_MAX_DEVNAMELEN-1] = '\0';
j++;
}
} else {
j = 0;
}
for (/* j is set */; j < USB_MAX_DEVNAMES; j++)
di->udi_devnames[j][0] = 0; /* empty */
if (!dev->ud_hub) {
di->udi_nports = 0;
return;
}
const int nports = dev->ud_hub->uh_hubdesc.bNbrPorts;
for (i = 0; i < __arraycount(di->udi_ports) && i < nports; i++) {
p = &dev->ud_hub->uh_ports[i];
if (p->up_dev)
err = p->up_dev->ud_addr;
else {
int s = UGETW(p->up_status.wPortStatus);
if (s & UPS_PORT_ENABLED)
err = USB_PORT_ENABLED;
else if (s & UPS_SUSPEND)
err = USB_PORT_SUSPENDED;
/*
* Note: UPS_PORT_POWER_SS is available only
* on 3.x, and UPS_PORT_POWER is available
* only on 2.0 or 1.1.
*/
else if (USB_IS_SS(dev->ud_speed) &&
(s & UPS_PORT_POWER_SS))
err = USB_PORT_POWERED;
else if (s & UPS_PORT_POWER)
err = USB_PORT_POWERED;
else
err = USB_PORT_DISABLED;
}
di->udi_ports[i] = err;
}
di->udi_nports = nports;
}
