| /* | |
| * Copyright 2017, Data61 | |
| * Commonwealth Scientific and Industrial Research Organisation (CSIRO) | |
| * ABN 41 687 119 230. | |
| * | |
| * This software may be distributed and modified according to the terms of | |
| * the BSD 2-Clause license. Note that NO WARRANTY is provided. | |
| * See "LICENSE_BSD2.txt" for details. | |
| * | |
| * @TAG(DATA61_BSD) | |
| */ | |
| #include <stdio.h> | |
| #include <stdint.h> | |
| #include <usb/usb.h> | |
| #include <usb/usb_host.h> | |
| #include <usb/drivers/usbhub.h> | |
| #include <usb/usb.h> | |
| #include "services.h" | |
| #include <string.h> | |
| #include <utils/util.h> | |
| #include <utils/sglib.h> | |
| #define NUM_DEVICES 32 | |
| #define CLASS_RESERVED_STR "<Reserved>" | |
| const char *usb_class_get_description(enum usb_class usb_class) | |
| { | |
| switch (usb_class) { | |
| case USB_CLASS_UNSPECIFIED: | |
| return "Unspecified - See interface classes"; | |
| case USB_CLASS_AUDIO: | |
| return "Audio"; | |
| case USB_CLASS_COMM: | |
| return "Communication and CDC Control"; | |
| case USB_CLASS_HID: | |
| return "Human interface device (HID)"; | |
| case USB_CLASS_PID: | |
| return "Physical Interface Device (PID)"; | |
| case USB_CLASS_IMAGE: | |
| return "Image"; | |
| case USB_CLASS_PRINTER: | |
| return "Printer"; | |
| case USB_CLASS_STORAGE: | |
| return "Mass storage"; | |
| case USB_CLASS_HUB: | |
| return "USB hub"; | |
| case USB_CLASS_CDCDATA: | |
| return "CDC-Data"; | |
| case USB_CLASS_CARDREADER: | |
| return "Smart Card"; | |
| case USB_CLASS_SECURITY: | |
| return "Content security"; | |
| case USB_CLASS_VIDEO: | |
| return "Video"; | |
| case USB_CLASS_HEALTH: | |
| return "Personal Healthcare Pulse monitor"; | |
| case USB_CLASS_AV: | |
| return "Audio/Video (AV)"; | |
| /* Some other sparse classes */ | |
| case USB_CLASS_DIAGNOSTIC: | |
| return "Diagnostic Device"; | |
| case USB_CLASS_WIRELESS: | |
| return "Wireless Controller"; | |
| case USB_CLASS_MISC: | |
| return "Miscellaneous"; | |
| case USB_CLASS_APPSPEC: | |
| return "Application specific"; | |
| case USB_CLASS_VEND: | |
| return "Vendor specific"; | |
| default: | |
| return CLASS_RESERVED_STR; | |
| } | |
| } | |
| /***************** | |
| **** Helpers **** | |
| *****************/ | |
| static inline struct usbreq __new_desc_req(enum DescriptorType t, int size) | |
| { | |
| struct usbreq r = { | |
| .bmRequestType = (USB_DIR_IN | USB_TYPE_STD | USB_RCPT_DEVICE), | |
| .bRequest = GET_DESCRIPTOR, | |
| .wValue = t << 8, | |
| .wIndex = 0, | |
| .wLength = size | |
| }; | |
| return r; | |
| } | |
| static inline struct usbreq __new_address_req(int addr) | |
| { | |
| struct usbreq r = { | |
| .bmRequestType = (USB_DIR_OUT | USB_TYPE_STD | USB_RCPT_DEVICE), | |
| .bRequest = SET_ADDRESS, | |
| .wValue = addr, | |
| .wIndex = 0, | |
| .wLength = 0 | |
| }; | |
| return r; | |
| } | |
| /**** Device list ****/ | |
| /* Initialise the device list */ | |
| static void devlist_init(usb_t * host) | |
| { | |
| host->devlist = NULL; | |
| host->addrbm = 1; | |
| host->next_addr = 1; | |
| } | |
| /* Insert a device into the list, return the index at which it was inserted */ | |
| static int devlist_insert(struct usb_dev *d) | |
| { | |
| usb_t *host = d->host; | |
| int i = host->next_addr; | |
| /* Early exit */ | |
| if (host->addrbm == (1ULL << NUM_DEVICES) - 1) { | |
| return -1; | |
| } | |
| /* cycle the list searching for a free address */ | |
| while (host->addrbm & (1 << i)) { | |
| if (i == NUM_DEVICES) { | |
| /* Remember address 0 is a special case */ | |
| i = 1; | |
| } else { | |
| i++; | |
| } | |
| } | |
| /* Add the device to the list */ | |
| SGLIB_LIST_ADD(struct usb_dev, host->devlist, d, next); | |
| host->addrbm |= (1 << i); | |
| /* Update the next address for next insertion */ | |
| if ((i + 1) == NUM_DEVICES) { | |
| host->next_addr = 1; | |
| } else { | |
| host->next_addr = i + 1; | |
| } | |
| /* return address */ | |
| return i; | |
| } | |
| /* Remove the device from the list */ | |
| static void devlist_remove(struct usb_dev *d) | |
| { | |
| usb_t *host = d->host; | |
| SGLIB_LIST_DELETE(struct usb_dev, host->devlist, d, next); | |
| d->next = NULL; | |
| host->addrbm &= ~(1 << d->addr); | |
| d->addr = -1; | |
| } | |
| /* Retrieve a device from the list */ | |
| static struct usb_dev *devlist_at(usb_t *host, int addr) | |
| { | |
| struct usb_dev *d; | |
| if (addr < 0 || addr > NUM_DEVICES) { | |
| ZF_LOGW("USB: Device not found\n"); | |
| } | |
| for (d = host->devlist; d != NULL; d = d->next) { | |
| if (d->addr == addr) { | |
| return d; | |
| } | |
| } | |
| return NULL; | |
| } | |
| /************************ | |
| **** Debug printing **** | |
| ************************/ | |
| #define PFIELD(d, x) printf("\t0x%-4x : %s\n", (d)->x, #x) | |
| #define PFIELD2(d, x) printf("\t0x%-4x : %-20s | ", (d)->x, #x) | |
| static void usb_print_descriptor(struct anon_desc *desc, int index) | |
| { | |
| int type = desc->bDescriptorType; | |
| switch (desc->bDescriptorType) { | |
| case DEVICE:{ | |
| struct device_desc d; | |
| memcpy(&d, desc, desc->bLength); | |
| printf("Device descriptor:\n"); | |
| PFIELD(&d, bLength); | |
| PFIELD(&d, bDescriptorType); | |
| PFIELD(&d, bcdUSB); | |
| PFIELD2(&d, bDeviceClass); | |
| printf("%s\n", usb_class_get_description(d.bDeviceClass)); | |
| PFIELD2(&d, bDeviceSubClass); | |
| printf("%s\n", usb_class_get_description(d.bDeviceSubClass)); | |
| PFIELD(&d, bDeviceProtocol); | |
| PFIELD(&d, bMaxPacketSize0); | |
| PFIELD(&d, idVendor); | |
| PFIELD(&d, idProduct); | |
| PFIELD(&d, bcdDevice); | |
| PFIELD(&d, iManufacturer); | |
| PFIELD(&d, iProduct); | |
| PFIELD(&d, iSerialNumber); | |
| PFIELD(&d, bNumConfigurations); | |
| break;} | |
| case CONFIGURATION:{ | |
| struct config_desc d; | |
| memcpy(&d, desc, desc->bLength); | |
| if (index >= 0) { | |
| printf("Config descriptor %d\n", index); | |
| } else { | |
| printf("Config descriptor\n"); | |
| } | |
| PFIELD(&d, bLength); | |
| PFIELD(&d, bDescriptorType); | |
| PFIELD(&d, wTotalLength); | |
| PFIELD(&d, bNumInterfaces); | |
| PFIELD(&d, bConfigurationValue); | |
| PFIELD(&d, iConfigurationIndex); | |
| PFIELD2(&d, bmAttributes); | |
| printf("%s ", (d.bmAttributes & (1 << 6)) ? | |
| "Self powered" : ""); | |
| printf("%s ", (d.bmAttributes & (1 << 5)) ? | |
| "Remote wakeup" : ""); | |
| printf("%s ", (d.bmAttributes & (1 << 7)) ? | |
| "" : "Warning: bit 7 should be set"); | |
| printf("%s ", (d.bmAttributes & (1 << 4)) ? | |
| "Warning: bit 5 should not be set" : ""); | |
| printf("\n"); | |
| PFIELD2(&d, bMaxPower); | |
| printf("%dmA\n", d.bMaxPower * 2); | |
| break;} | |
| case INTERFACE:{ | |
| struct iface_desc d; | |
| memcpy(&d, desc, desc->bLength); | |
| if (index >= 0) { | |
| printf("Interface descriptor %d\n", index); | |
| } else { | |
| printf("Interface descriptor\n"); | |
| } | |
| PFIELD(&d, bLength); | |
| PFIELD(&d, bDescriptorType); | |
| PFIELD(&d, bInterfaceNumber); | |
| PFIELD(&d, bAlternateSetting); | |
| PFIELD(&d, bNumEndpoints); | |
| PFIELD2(&d, bInterfaceClass); | |
| printf("%s\n", usb_class_get_description(d.bInterfaceClass)); | |
| PFIELD2(&d, bInterfaceSubClass); | |
| printf("%s\n", usb_class_get_description(d.bInterfaceSubClass)); | |
| PFIELD(&d, bInterfaceProtocol); | |
| PFIELD(&d, iInterface); | |
| break;} | |
| case ENDPOINT:{ | |
| struct endpoint_desc d; | |
| memcpy(&d, desc, desc->bLength); | |
| if (index >= 0) { | |
| printf("Endpoint descriptor %d\n", index); | |
| } else { | |
| printf("Endpoint descriptor\n"); | |
| } | |
| PFIELD(&d, bLength); | |
| PFIELD(&d, bDescriptorType); | |
| PFIELD2(&d, bEndpointAddress); | |
| printf("%d-", d.bEndpointAddress & 0xf); | |
| if (d.bmAttributes & 0x3) { | |
| if (d.bEndpointAddress & (1 << 7)) { | |
| printf("IN"); | |
| } else { | |
| printf("OUT"); | |
| } | |
| } | |
| printf("\n"); | |
| PFIELD2(&d, bmAttributes); | |
| switch (d.bmAttributes & 0x3) { | |
| case 0: | |
| printf("CONTROL"); | |
| break; | |
| case 1: | |
| printf("ISOCH"); | |
| break; | |
| case 2: | |
| printf("BULK"); | |
| break; | |
| case 3: | |
| printf("INT"); | |
| break; | |
| } | |
| printf(","); | |
| switch ((d.bmAttributes >> 2) & 0x3) { | |
| case 0: | |
| printf("No synch"); | |
| break; | |
| case 1: | |
| printf("Asynchronous"); | |
| break; | |
| case 2: | |
| printf("Adaptive"); | |
| break; | |
| case 3: | |
| printf("Synchronous"); | |
| break; | |
| } | |
| printf(","); | |
| switch ((d.bmAttributes >> 4) & 0x3) { | |
| case 0: | |
| printf("DATA"); | |
| break; | |
| case 1: | |
| printf("Feedback"); | |
| break; | |
| case 2: | |
| printf("Implicit feedback data"); | |
| break; | |
| case 3: | |
| printf("<Reserved>"); | |
| break; | |
| } | |
| printf("\n"); | |
| PFIELD2(&d, wMaxPacketSize); | |
| printf("%d bytes, %d xacts per uFrame\n", | |
| d.wMaxPacketSize & 0x7ff, | |
| ((d.wMaxPacketSize >> 11) & 0x3) + 1); | |
| PFIELD(&d, bInterval); | |
| break;} | |
| case DEVICE_QUALIFIER: | |
| case OTHER_SPEED_CONFIGURATION: | |
| case INTERFACE_POWER: | |
| case STRING: | |
| printf("Descriptor type %d not implemented\n", type); | |
| break; | |
| /* Class specific types */ | |
| case HID:{ | |
| struct hid_desc d; | |
| memcpy(&d, desc, desc->bLength); | |
| printf("HID descriptor\n"); | |
| PFIELD(&d, bLength); | |
| PFIELD(&d, bDescriptorType); | |
| PFIELD(&d, bcdHID); | |
| PFIELD(&d, bCountryCode); | |
| PFIELD(&d, bNumDescriptors); | |
| PFIELD(&d, bReportDescriptorType); | |
| PFIELD(&d, wReportDescriptorLength); | |
| break;} | |
| default: | |
| printf("Unknown descriptor type %d\n", type); | |
| } | |
| } | |
| static void print_string_desc(struct string_desc *desc) | |
| { | |
| if (!desc) { | |
| ZF_LOGF("USB: Invalid arguments\n"); | |
| } | |
| for (int i = 0; i < desc->bLength - 2; i++) { | |
| printf("%c", desc->bString[i]); | |
| } | |
| printf("\n"); | |
| } | |
| static void | |
| usb_get_string_desc(struct usb_dev *udev, int index, struct string_desc *desc) | |
| { | |
| int err; | |
| int lang; | |
| struct xact xact[2]; | |
| struct usbreq *req; | |
| struct string_desc *sdesc; | |
| if (index == 0) { | |
| return; | |
| } | |
| /* XXX: xact allocation relies on the xact.len */ | |
| xact[0].len = sizeof(struct usbreq); | |
| xact[1].len = sizeof(struct string_desc); | |
| /* Get memory for the request */ | |
| err = usb_alloc_xact(udev->dman, xact, | |
| sizeof(xact) / sizeof(struct xact)); | |
| if (err) { | |
| ZF_LOGE("USB %d: Not enough DMA memory!\n", udev->addr); | |
| return; | |
| } | |
| /* Fill in the SETUP packet */ | |
| xact[0].type = PID_SETUP; | |
| xact[1].type = PID_IN; | |
| req = xact_get_vaddr(&xact[0]); | |
| sdesc = (struct string_desc *)xact[1].vaddr; | |
| /* Get language ID */ | |
| *req = __get_descriptor_req(STRING, 0, 0, sizeof(struct string_desc)); | |
| err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 2, NULL, NULL); | |
| if (err < 0) { | |
| ZF_LOGD("USB %d: USB request failed.\n", udev->addr); | |
| usb_destroy_xact(udev->dman, xact, 2); | |
| return; | |
| } | |
| lang = sdesc->bString[1] << 8 | sdesc->bString[0]; | |
| /* Get the string descriptor */ | |
| *req = __get_descriptor_req(STRING, index, lang, | |
| sizeof(struct string_desc)); | |
| err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 2, NULL, NULL); | |
| if (err < 0) { | |
| ZF_LOGD("USB %d: USB request failed.\n", udev->addr); | |
| usb_destroy_xact(udev->dman, xact, 2); | |
| return; | |
| } | |
| if (desc) { | |
| memcpy(desc, sdesc, sdesc->bLength); | |
| } | |
| usb_destroy_xact(udev->dman, xact, 2); | |
| } | |
| static void print_dev(struct usb_dev *d) | |
| { | |
| if (d) { | |
| printf("USB@%02d: 0x%04x:0x%04x | %-40s\n", | |
| d->addr, d->vend_id, d->prod_id, | |
| usb_class_get_description(d->class)); | |
| } | |
| } | |
| static int | |
| usb_config_print_cb(void *token, int cfg, int iface, struct anon_desc *d) | |
| { | |
| uint32_t *cnt = (uint32_t *) token; | |
| int v; | |
| if (d == NULL) { | |
| printf("\n"); | |
| return 0; | |
| } else { | |
| switch (d->bDescriptorType) { | |
| case CONFIGURATION: | |
| cnt[0]++; | |
| cnt[1] = 0; | |
| cnt[2] = 0; | |
| v = cnt[0]; | |
| break; | |
| case INTERFACE: | |
| cnt[1]++; | |
| cnt[2] = 0; | |
| v = cnt[1]; | |
| break; | |
| case ENDPOINT: | |
| cnt[2]++; | |
| v = cnt[2]; | |
| break; | |
| default: | |
| v = -1; | |
| break; | |
| } | |
| usb_print_descriptor(d, v); | |
| return 0; | |
| } | |
| } | |
| static void usbdev_config_print(struct usb_dev *udev) | |
| { | |
| struct anon_desc *desc; | |
| struct usbreq *req; | |
| struct xact xact[2]; | |
| int ret; | |
| uint32_t cnt[3] = { 0, 0, 0 }; | |
| /* Device descriptor */ | |
| xact[0].type = PID_SETUP; | |
| xact[0].len = sizeof(*req); | |
| xact[1].type = PID_IN; | |
| xact[1].len = sizeof(struct device_desc); | |
| ret = usb_alloc_xact(udev->dman, xact, 2); | |
| if (ret) { | |
| ZF_LOGF("USB: Out of DMA memory\n"); | |
| } | |
| req = xact_get_vaddr(&xact[0]); | |
| *req = __get_descriptor_req(DEVICE, 0, 0, xact[1].len); | |
| ret = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 2, NULL, NULL); | |
| if (ret < 0) { | |
| ZF_LOGF("USB: Transaction error\n"); | |
| } | |
| desc = (struct anon_desc *)xact_get_vaddr(&xact[1]); | |
| usb_print_descriptor(desc, -1); | |
| usb_destroy_xact(udev->dman, xact, sizeof(xact) / sizeof(*xact)); | |
| /* Print config descriptors */ | |
| usbdev_parse_config(udev, usb_config_print_cb, cnt); | |
| } | |
| static void print_dev_graph(usb_t * host, struct usb_dev *d, int depth) | |
| { | |
| int i; | |
| if (d != NULL) { | |
| for (i = 0; i < depth; i++) { | |
| printf(" "); | |
| } | |
| print_dev(d); | |
| } | |
| /* Search for connected devices */ | |
| for (i = 1; i < NUM_DEVICES; i++) { | |
| struct usb_dev *d2; | |
| d2 = devlist_at(host, i); | |
| if (d2 && d2->hub == d) { | |
| print_dev_graph(host, d2, depth + 1); | |
| } | |
| } | |
| } | |
| static int | |
| parse_config(struct usb_dev *udev, struct anon_desc *d, int tot_len, | |
| usb_config_cb cb, void *t) | |
| { | |
| int cfg = -1; | |
| int iface = -1; | |
| struct anon_desc *usrd = NULL; | |
| struct endpoint_desc *edsc; | |
| struct endpoint *ep; | |
| int buf_len = 0; | |
| int cur_len = 0; | |
| int err = 0; | |
| int cnt = 0; | |
| /* | |
| * FIXME: Not all devices report the total length of its descriptors | |
| * correctly. We should always check the details of each descriptor. | |
| */ | |
| while (cur_len < tot_len) { | |
| if (!d->bLength) { | |
| break; | |
| } | |
| /* Copy in for the sake of alignment */ | |
| if (buf_len < d->bLength) { | |
| if (usrd) { | |
| usb_free(usrd); | |
| } | |
| usrd = usb_malloc(d->bLength); | |
| if (usrd == NULL) { | |
| ZF_LOGE("USB: Out of memory\n"); | |
| err = 1; | |
| break; | |
| } | |
| buf_len = d->bLength; | |
| } | |
| memcpy(usrd, d, d->bLength); | |
| /* Update our config/iface */ | |
| switch (d->bDescriptorType) { | |
| case CONFIGURATION: | |
| cfg = ((struct config_desc *)usrd)->bConfigurationValue; | |
| iface = -1; | |
| break; | |
| case INTERFACE: | |
| iface = ((struct iface_desc *)usrd)->bInterfaceNumber; | |
| /* Device class defined at interface level */ | |
| if (!udev->class) { | |
| udev->class = | |
| ((struct iface_desc *) | |
| usrd)->bInterfaceClass; | |
| } | |
| break; | |
| case ENDPOINT: | |
| edsc = (struct endpoint_desc *)usrd; | |
| ep = usb_malloc(sizeof(struct endpoint)); | |
| if (!ep) { | |
| ZF_LOGF("Out of memory\n"); | |
| } | |
| /* Fill in the endpoint structure, USB standard(9.6.6) */ | |
| ep->type = edsc->bmAttributes & 0x3; | |
| ep->dir = edsc->bEndpointAddress >> 0x7; | |
| ep->num = edsc->bEndpointAddress & 0xF; | |
| ep->max_pkt = edsc->wMaxPacketSize; | |
| ep->interval = edsc->bInterval; | |
| udev->ep[cnt++] = ep; | |
| break; | |
| default: | |
| break; | |
| } | |
| /* Send to caller */ | |
| if (cb && cb(t, cfg, iface, usrd)) { | |
| break; | |
| } | |
| /* Next */ | |
| cur_len += d->bLength; | |
| d = (struct anon_desc *)((uintptr_t) d + d->bLength); | |
| } | |
| /* Report end of list */ | |
| if (cb && cur_len == tot_len) { | |
| cb(t, cfg, iface, NULL); | |
| } | |
| /* Clean up */ | |
| if (usrd == NULL) { | |
| usb_free(usrd); | |
| } | |
| return err; | |
| } | |
| static int | |
| usb_new_device_with_host(struct usb_dev *hub, usb_t * host, int port, | |
| enum usb_speed speed, struct usb_dev **d) | |
| { | |
| struct usb_dev *udev = NULL; | |
| struct usb_dev *parent = NULL, *child = NULL; | |
| struct usbreq *req; | |
| struct device_desc *d_desc; | |
| struct string_desc s_desc; | |
| struct xact xact[2]; | |
| int addr = 0; | |
| int err; | |
| ZF_LOGD("USB: New USB device!\n"); | |
| udev = (struct usb_dev*)usb_malloc(sizeof(*udev)); | |
| if (!udev) { | |
| ZF_LOGE("USB: No heap memory for new USB device\n"); | |
| return -1; | |
| } | |
| udev->addr = 0; | |
| udev->tt_addr = 0; | |
| udev->tt_port = 0; | |
| udev->connect = NULL; | |
| udev->disconnect = NULL; | |
| udev->dev_data = NULL; | |
| udev->hub = hub; | |
| udev->port = port; | |
| udev->speed = speed; | |
| udev->host = host; | |
| udev->dman = host->hdev.dman; | |
| /* | |
| * Work out the TT hub for full/low speed devices. | |
| * Assuming all high speed hubs have TT. | |
| */ | |
| if (speed != USBSPEED_HIGH) { | |
| parent = hub; | |
| child = udev; | |
| while (parent) { | |
| if (parent->speed == USBSPEED_HIGH) { | |
| udev->tt_addr = parent->addr; | |
| udev->tt_port = child->port; | |
| break; | |
| } else { | |
| child = parent; | |
| parent = parent->hub; | |
| } | |
| } | |
| } | |
| /* | |
| * Allocate control endpoint | |
| * Every device should have one control endpoint, the endpoint number is | |
| * always zero and we initialize the maximum packet size to 8 for sending | |
| * the very first request. | |
| */ | |
| udev->ep_ctrl = (struct endpoint *)usb_malloc(sizeof(struct endpoint)); | |
| if (!udev->ep_ctrl) { | |
| ZF_LOGE("USB: No heap memory for control endpoint\n"); | |
| usb_free(udev); | |
| udev = NULL; | |
| return -1; | |
| } | |
| udev->ep_ctrl->type = EP_CONTROL; | |
| udev->ep_ctrl->num = 0; | |
| udev->ep_ctrl->max_pkt = 8; | |
| xact[0].type = PID_SETUP; | |
| xact[0].len = sizeof(*req); | |
| xact[1].type = PID_IN; | |
| xact[1].len = sizeof(*d_desc); | |
| err = usb_alloc_xact(udev->dman, xact, 2); | |
| if (err) { | |
| ZF_LOGE("USB: No DMA memory for new USB device\n"); | |
| usb_free(udev); | |
| udev = NULL; | |
| return -1; | |
| } | |
| req = xact_get_vaddr(&xact[0]); | |
| d_desc = xact_get_vaddr(&xact[1]); | |
| /* USB transactions are O(n) when trying to bind a driver. | |
| * This is a good time to at least cache | |
| * a) Max packet size for EP 0 | |
| * b) product and vendor ID | |
| * c) device class | |
| */ | |
| ZF_LOGD("USB: Determining maximum packet size on the control endpoint\n"); | |
| /* | |
| * We need the value of bMaxPacketSize in order to request | |
| * the bMaxPacketSize. A work around to this circular | |
| * dependency is to set the maximum packet size to 8 and | |
| * limit the size of our packets to prevent splitting until | |
| * we know what the correct value is NOTE: High speed | |
| * devices must always have a MaxPacketSize of 64 on the | |
| * control endpoint (see USB spec) but we do not consider | |
| * special cases. | |
| */ | |
| xact[1].len = 8; | |
| *req = __new_desc_req(DEVICE, 8); | |
| err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 2, NULL, NULL); | |
| if (err < 0) { | |
| usb_destroy_xact(udev->dman, xact, 2); | |
| usb_free(udev); | |
| udev = NULL; | |
| ZF_LOGE("USB: Transaction error"); | |
| return -1; | |
| } | |
| udev->ep_ctrl->max_pkt = d_desc->bMaxPacketSize0; | |
| /* Find the next available address */ | |
| addr = devlist_insert(udev); | |
| if (addr < 0) { | |
| ZF_LOGE("USB: Too many devices\n"); | |
| usb_destroy_xact(udev->dman, xact, | |
| sizeof(xact) / sizeof(*xact)); | |
| usb_free(udev); | |
| udev = NULL; | |
| return -1; | |
| } | |
| /* Set the address */ | |
| *req = __new_address_req(addr); | |
| ZF_LOGD("USB: Setting address to %d\n", addr); | |
| err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 1, NULL, NULL); | |
| if (err < 0) { | |
| usb_destroy_xact(udev->dman, xact, 2); | |
| usb_free(udev); | |
| udev = NULL; | |
| return -1; | |
| } | |
| /* Device has 2ms to start responding to new address */ | |
| ps_mdelay(2); | |
| udev->addr = addr; | |
| /* All settled, start processing standard USB descriptors */ | |
| ZF_LOGD("USB %d: Retrieving device descriptor\n", udev->addr); | |
| xact[1].len = sizeof(*d_desc); | |
| *req = __new_desc_req(DEVICE, sizeof(*d_desc)); | |
| err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 2, NULL, NULL); | |
| if (err < 0) { | |
| usb_destroy_xact(udev->dman, xact, 2); | |
| usb_free(udev); | |
| udev = NULL; | |
| return -1; | |
| } | |
| udev->prod_id = d_desc->idProduct; | |
| udev->vend_id = d_desc->idVendor; | |
| udev->class = d_desc->bDeviceClass; | |
| printf("USB %d: idVendor 0x%04x | ", udev->addr, udev->vend_id); | |
| if (d_desc->iManufacturer) { | |
| usb_get_string_desc(udev, d_desc->iManufacturer, &s_desc); | |
| print_string_desc(&s_desc); | |
| } else { | |
| printf("\n"); | |
| } | |
| printf("USB %d: idProduct 0x%04x | ", udev->addr, udev->prod_id); | |
| if (d_desc->iProduct) { | |
| usb_get_string_desc(udev, d_desc->iProduct, &s_desc); | |
| print_string_desc(&s_desc); | |
| } else { | |
| printf("\n"); | |
| } | |
| *d = udev; | |
| usb_destroy_xact(udev->dman, xact, sizeof(xact) / sizeof(*xact)); | |
| return 0; | |
| } | |
| /**************************** | |
| **** Exported functions **** | |
| ****************************/ | |
| ps_malloc_ops_t *ps_malloc_ops = NULL; | |
| int | |
| usb_init(enum usb_host_id id, ps_io_ops_t * ioops, ps_mutex_ops_t * sync, | |
| usb_t * host) | |
| { | |
| usb_hub_t hub; | |
| struct usb_dev *udev; | |
| int err; | |
| ps_malloc_ops = &ioops->malloc_ops; | |
| /* Pre-fill the host structure */ | |
| devlist_init(host); | |
| err = usb_host_init(id, ioops, sync, &host->hdev); | |
| if (err) { | |
| ZF_LOGE("USB: Platform error\n"); | |
| return -1; | |
| } | |
| err = usb_new_device_with_host(NULL, host, 1, 0, &udev); | |
| if (err) { | |
| ZF_LOGE("USB: Host error\n"); | |
| return -1; | |
| } | |
| err = usb_hub_driver_bind(udev, &hub); | |
| if (err) { | |
| ZF_LOGE("USB: Failed to bind a hub"); | |
| return -1; | |
| } | |
| return 0; | |
| } | |
| int usb_new_device(usb_dev_t *hub, int port, enum usb_speed speed, usb_dev_t **d) | |
| { | |
| return usb_new_device_with_host(hub, hub->host, port, speed, d); | |
| } | |
| usb_dev_t *usb_get_device(usb_t * host, int addr) | |
| { | |
| if (addr <= 0 || addr >= NUM_DEVICES) { | |
| return NULL; | |
| } else { | |
| return devlist_at(host, addr); | |
| } | |
| } | |
| /* | |
| * Parsing standard USB descriptors. | |
| * We don't support multiple configurations, if the device has more than one | |
| * configurations, the first one will be activated. | |
| */ | |
| int usbdev_parse_config(usb_dev_t *udev, usb_config_cb cb, void *t) | |
| { | |
| struct xact xact[2]; | |
| struct usbreq *req; | |
| struct config_desc *cd; | |
| struct anon_desc *d; | |
| int tot_len; | |
| int err; | |
| /* First read to find the size of the descriptor table */ | |
| xact[0].len = sizeof(*req); | |
| xact[0].type = PID_SETUP; | |
| xact[1].len = sizeof(*cd); | |
| xact[1].type = PID_IN; | |
| err = usb_alloc_xact(udev->dman, xact, 2); | |
| if (err) { | |
| ZF_LOGE("USB %d: Out of DMA memory", udev->addr); | |
| return -1; | |
| } | |
| req = xact_get_vaddr(&xact[0]); | |
| cd = xact_get_vaddr(&xact[1]); | |
| *req = __get_descriptor_req(CONFIGURATION, 0, 0, xact[1].len); | |
| err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 2, NULL, NULL); | |
| if (err < 0) { | |
| usb_destroy_xact(udev->dman, xact, 2); | |
| return -1; | |
| } | |
| tot_len = cd->wTotalLength; | |
| /* Some devices need a pause during initialization */ | |
| ps_mdelay(100); | |
| /* Next read for the entire descriptor table */ | |
| xact[0].len = sizeof(*req); | |
| xact[0].type = PID_SETUP; | |
| xact[1].len = tot_len; | |
| xact[1].type = PID_IN; | |
| err = usb_alloc_xact(udev->dman, xact, 2); | |
| if (err) { | |
| ZF_LOGE("USB %d: Out of DMA memory", udev->addr); | |
| return -1; | |
| } | |
| req = xact_get_vaddr(&xact[0]); | |
| d = xact_get_vaddr(&xact[1]); | |
| *req = __get_descriptor_req(CONFIGURATION, 0, 0, tot_len); | |
| err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 2, NULL, NULL); | |
| if (err < 0) { | |
| usb_destroy_xact(udev->dman, xact, | |
| sizeof(xact) / sizeof(*xact)); | |
| return -1; | |
| } | |
| /* Now loop through descriptors */ | |
| err = parse_config(udev, d, tot_len, cb, t); | |
| usb_destroy_xact(udev->dman, xact, sizeof(xact) / sizeof(*xact)); | |
| return err; | |
| } | |
| void usbdev_disconnect(usb_dev_t *udev) | |
| { | |
| UNUSED int err; | |
| usb_host_t *hdev; | |
| usb_hub_t hub; | |
| int cnt = 0; | |
| if (!udev || !udev->host) { | |
| ZF_LOGF("USB: Invalid arguments\n"); | |
| } | |
| ZF_LOGD("USB %d: Disconnecting\n", udev->addr); | |
| hdev = &udev->host->hdev; | |
| if (udev->disconnect) { | |
| ZF_LOGD("USB %d: calling device disconnect 0x%x\n", | |
| udev->addr, (uint32_t) udev->disconnect); | |
| udev->disconnect(udev); | |
| } | |
| /* | |
| * Check if we are disconnecting a Hub, in which case we also need to | |
| * disconnect all devices that connect to it. | |
| */ | |
| if (udev->class == USB_CLASS_HUB) { | |
| hub = (usb_hub_t) udev->dev_data; | |
| for (int i = 0; i < hub->nports; i++) { | |
| if (hub->port[i].udev) { | |
| usbdev_disconnect(hub->port[i].udev); | |
| } | |
| } | |
| } | |
| /* Remove control endpoint */ | |
| err = hdev->cancel_xact(hdev, udev->ep_ctrl); | |
| /* Remove all other endpoints */ | |
| while (udev->ep[cnt] && cnt < USB_MAX_EPS) { | |
| err = hdev->cancel_xact(hdev, udev->ep[cnt]); | |
| cnt++; | |
| } | |
| if (err) { | |
| ZF_LOGW("USB %d: Failed to cancel some of the transactions\n", | |
| udev->addr); | |
| } | |
| (void)hdev; | |
| devlist_remove(udev); | |
| /* destroy it */ | |
| usb_free(udev->ep_ctrl); | |
| for (int i = 0; i < USB_MAX_EPS; i++) { | |
| if (udev->ep[i]) { | |
| usb_free(udev->ep[i]); | |
| } | |
| } | |
| usb_free(udev); | |
| } | |
| void usb_handle_irq(usb_t *host) | |
| { | |
| usb_host_t *hdev; | |
| if (!host) { | |
| ZF_LOGF("Invalid arguments\n"); | |
| } | |
| hdev = &host->hdev; | |
| hdev->handle_irq(hdev); | |
| } | |
| int | |
| usbdev_schedule_xact(usb_dev_t *udev, struct endpoint *ep, struct xact *xact, | |
| int nxact, usb_cb_t cb, void *token) | |
| { | |
| int err; | |
| usb_host_t *hdev; | |
| uint8_t hub_addr; | |
| if (!udev) { | |
| ZF_LOGF("Invalid arguments\n"); | |
| } | |
| hdev = &udev->host->hdev; | |
| if (udev->hub) { | |
| hub_addr = udev->tt_addr; | |
| } else { | |
| hub_addr = -1; | |
| } | |
| err = | |
| usb_hcd_schedule(hdev, udev->addr, hub_addr, udev->tt_port, | |
| udev->speed, ep, xact, nxact, cb, token); | |
| return err; | |
| } | |
| void usb_lsusb(usb_t * host, int v) | |
| { | |
| int i; | |
| printf("\n"); | |
| if (v == 0) { | |
| /* Print a simple list */ | |
| for (i = 1; i < NUM_DEVICES; i++) { | |
| struct usb_dev *d = devlist_at(host, i); | |
| print_dev(d); | |
| } | |
| } else { | |
| /* Print by connection */ | |
| print_dev_graph(host, NULL, -1); | |
| } | |
| /* Print out all the configs */ | |
| if (v > 1) { | |
| printf("\n"); | |
| for (i = 1; i < NUM_DEVICES; i++) { | |
| struct usb_dev *d = devlist_at(host, i); | |
| if (d) { | |
| print_dev(d); | |
| usbdev_config_print(d); | |
| } | |
| } | |
| } | |
| printf("\n"); | |
| } | |
| void usb_probe_device(usb_dev_t *dev) | |
| { | |
| usbdev_config_print(dev); | |
| } | |
| int usb_alloc_xact(ps_dma_man_t * dman, struct xact *xact, int nxact) | |
| { | |
| int i; | |
| for (i = 0; i < nxact; i++) { | |
| if (xact[i].len) { | |
| xact[i].vaddr = | |
| ps_dma_alloc_pinned(dman, xact[i].len, 32, 0, | |
| PS_MEM_NORMAL, &xact[i].paddr); | |
| if (xact[i].vaddr == NULL) { | |
| usb_destroy_xact(dman, xact, i); | |
| return -1; | |
| } | |
| } else { | |
| xact[i].vaddr = NULL; | |
| } | |
| } | |
| return 0; | |
| } | |
| void usb_destroy_xact(ps_dma_man_t * dman, struct xact *xact, int nxact) | |
| { | |
| while (nxact-- > 0) { | |
| if (xact[nxact].vaddr) { | |
| ps_dma_free_pinned(dman, xact[nxact].vaddr, | |
| xact[nxact].len); | |
| } | |
| } | |
| } | |
| enum usb_class usbdev_get_class(usb_dev_t *dev) | |
| { | |
| return dev->class; | |
| } |