25int _IsInUsbInterrupt = 0;
27static UDEV_DRV_T * _drivers[MAX_UDEV_DRIVER];
29static CONN_FUNC *g_conn_func, *g_disconn_func;
47 memset(_drivers, 0,
sizeof(_drivers));
50 g_disconn_func =
NULL;
88 g_conn_func = conn_func;
89 g_disconn_func = disconn_func;
94 if (udev->parent ==
NULL)
97 return udev->hc_driver->rthub_port_reset(udev->port_num-1);
103 return udev->parent->port_reset(udev->parent, udev->port_num);
108static uint32_t ehci_UCMDR;
146 ehci_UCMDR = _ehci->
UCMDR;
164 USB_error(
"usbh_suspend - RUN/HCHalted error!\n");
198 _ehci->
UCMDR = ehci_UCMDR;
204 _ehci->
UPSCR[0] &= ~HSUSBH_UPSCR_FPR_Msk;
223int usbh_register_driver(UDEV_DRV_T *udrv)
227 for (i = 0; i < MAX_UDEV_DRIVER; i++)
229 if (_drivers[i] == udrv)
232 if (_drivers[i] ==
NULL)
258int usbh_ctrl_xfer(UDEV_T *udev, uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
259 uint16_t wLength, uint8_t *buff, uint32_t *xfer_len, uint32_t timeout)
270 utr = alloc_utr(udev);
274 utr->setup.bmRequestType = bmRequestType;
275 utr->setup.bRequest = bRequest;
276 utr->setup.wValue = wValue;
277 utr->setup.wIndex = wIndex;
278 utr->setup.wLength = wLength;
281 utr->data_len = wLength;
282 utr->bIsTransferDone = 0;
283 status = udev->hc_driver->ctrl_xfer(utr);
286 udev->ep0.hw_pipe =
NULL;
292 while (utr->bIsTransferDone == 0)
298 udev->ep0.hw_pipe =
NULL;
303 status = utr->status;
307 *xfer_len = utr->xfer_len;
323int usbh_bulk_xfer(UTR_T *utr)
325 return utr->udev->hc_driver->bulk_xfer(utr);
336int usbh_int_xfer(UTR_T *utr)
338 return utr->udev->hc_driver->int_xfer(utr);
349int usbh_iso_xfer(UTR_T *utr)
351 if (utr->udev->hc_driver ==
NULL)
353 printf(
"hc_driver - 0x%x\n", (
int)utr->udev->hc_driver);
356 if (utr->udev->hc_driver->iso_xfer ==
NULL)
358 printf(
"iso_xfer - 0x%x\n", (
int)utr->udev->hc_driver->iso_xfer);
361 return utr->udev->hc_driver->iso_xfer(utr);
370int usbh_quit_utr(UTR_T *utr)
372 if (!utr || !utr->udev)
375 return utr->udev->hc_driver->quit_xfer(utr,
NULL);
386int usbh_quit_xfer(UDEV_T *udev, EP_INFO_T *ep)
388 return udev->hc_driver->quit_xfer(
NULL, ep);
392void dump_device_descriptor(DESC_DEV_T *desc)
394 USB_debug(
"\n[Device Descriptor]\n");
395 USB_debug(
"----------------------------------------------\n");
396 USB_debug(
" Length = %2d\n", desc->bLength);
397 USB_debug(
" DescriptorType = 0x%02x\n", desc->bDescriptorType);
398 USB_debug(
" USB version = %x.%02x\n",
399 desc->bcdUSB >> 8, desc->bcdUSB & 0xff);
400 USB_debug(
" Vendor:Product = %04x:%04x\n",
401 desc->idVendor, desc->idProduct);
402 USB_debug(
" MaxPacketSize0 = %d\n", desc->bMaxPacketSize0);
403 USB_debug(
" NumConfigurations = %d\n", desc->bNumConfigurations);
404 USB_debug(
" Device version = %x.%02x\n",
405 desc->bcdDevice >> 8, desc->bcdDevice & 0xff);
406 USB_debug(
" Device Class:SubClass:Protocol = %02x:%02x:%02x\n",
407 desc->bDeviceClass, desc->bDeviceSubClass, desc->bDeviceProtocol);
410void usbh_dump_interface_descriptor(DESC_IF_T *if_desc)
412 USB_debug(
"\n [Interface Descriptor]\n");
413 USB_debug(
" ----------------------------------------------\n");
414 USB_debug(
" Length = %2d\n", if_desc->bLength);
415 USB_debug(
" DescriptorType = %02x\n", if_desc->bDescriptorType);
416 USB_debug(
" bInterfaceNumber = %d\n", if_desc->bInterfaceNumber);
417 USB_debug(
" bAlternateSetting = %d\n", if_desc->bAlternateSetting);
418 USB_debug(
" bNumEndpoints = %d\n", if_desc->bNumEndpoints);
419 USB_debug(
" bInterfaceClass = 0x%02x\n", if_desc->bInterfaceClass);
420 USB_debug(
" bInterfaceSubClass = 0x%02x\n", if_desc->bInterfaceSubClass);
421 USB_debug(
" bInterfaceProtocol = 0x%02x\n", if_desc->bInterfaceProtocol);
422 USB_debug(
" iInterface = %d\n", if_desc->iInterface);
425void usbh_dump_endpoint_descriptor(DESC_EP_T *ep_desc)
427 USB_debug(
"\n [Endpoint Descriptor]\n");
428 USB_debug(
" ----------------------------------------------\n");
429 USB_debug(
" Length = %2d\n", ep_desc->bLength);
430 USB_debug(
" DescriptorType = %02x\n", ep_desc->bDescriptorType);
431 USB_debug(
" bEndpointAddress = 0x%02x\n", ep_desc->bEndpointAddress);
432 USB_debug(
" bmAttributes = 0x%02x\n", ep_desc->bmAttributes);
433 USB_debug(
" wMaxPacketSize = %d\n", ep_desc->wMaxPacketSize);
434 USB_debug(
" bInterval = %d\n", ep_desc->bInterval);
435 USB_debug(
" bRefresh = %d\n", ep_desc->bRefresh);
436 USB_debug(
" bSynchAddress = %d\n", ep_desc->bSynchAddress);
439void dump_config_descriptor(DESC_CONF_T *desc)
441 uint8_t *bptr = (uint8_t *)desc;
443 int tlen = desc->wTotalLength;
449 case USB_DT_CONFIGURATION:
450 USB_debug(
"\n[Configuration Descriptor]\n");
451 USB_debug(
"----------------------------------------------\n");
452 USB_debug(
" Length = %2d\n", desc->bLength);
453 USB_debug(
" DescriptorType = %02x\n", desc->bDescriptorType);
454 USB_debug(
" wTotalLength = %2d\n", desc->wTotalLength);
455 USB_debug(
" bNumInterfaces = %d\n", desc->bNumInterfaces);
456 USB_debug(
" bConfigurationValue = %d\n", desc->bConfigurationValue);
457 USB_debug(
" iConfiguration = %d\n", desc->iConfiguration);
458 USB_debug(
" bmAttributes = 0x%02x\n", desc->bmAttributes);
459 USB_debug(
" MaxPower = %d\n", desc->MaxPower);
462 case USB_DT_INTERFACE:
463 usbh_dump_interface_descriptor((DESC_IF_T *)bptr);
466 case USB_DT_ENDPOINT:
467 usbh_dump_endpoint_descriptor((DESC_EP_T *)bptr);
471 hdr = (DESC_HDR_T *)bptr;
472 USB_debug(
"\n!![Unknown Descriptor]\n");
473 USB_debug(
"----------------------------------------------\n");
474 USB_debug(
"Length = %2d\n", hdr->bLength);
475 USB_debug(
"DescriptorType = %02x\n", hdr->bDescriptorType);
490int usbh_set_address(UDEV_T *udev)
495 if (udev->dev_num != 0)
498 dev_num = alloc_dev_address();
503 ret = usbh_ctrl_xfer(udev, REQ_TYPE_OUT | REQ_TYPE_STD_DEV | REQ_TYPE_TO_DEV,
504 USB_REQ_SET_ADDRESS, dev_num, 0, 0,
505 NULL, &read_len, 100);
508 free_dev_address(dev_num);
512 udev->dev_num = dev_num;
522int usbh_set_configuration(UDEV_T *udev, uint8_t conf_val)
528 if (udev->cur_conf == conf_val)
532 if (udev->cur_conf != -1)
538 ret = usbh_ctrl_xfer(udev, REQ_TYPE_OUT | REQ_TYPE_STD_DEV | REQ_TYPE_TO_DEV,
539 USB_REQ_SET_CONFIGURATION, conf_val, 0, 0,
540 NULL, &read_len, 300);
544 udev->cur_conf = (int8_t)conf_val;
556int usbh_set_interface(IFACE_T *iface, uint16_t alt_setting)
558 ALT_IFACE_T *aif =
NULL;
562 for (i = 0; i < iface->num_alt; i++)
564 if (iface->alt[i].ifd->bAlternateSetting == alt_setting)
566 aif = &iface->alt[i];
573 ret = usbh_ctrl_xfer(iface->udev, REQ_TYPE_OUT | REQ_TYPE_STD_DEV | REQ_TYPE_TO_IFACE,
574 USB_REQ_SET_INTERFACE, alt_setting, iface->if_num, 0,
575 NULL, &xfer_len, 100);
588int usbh_get_device_descriptor(UDEV_T *udev, DESC_DEV_T *desc_buff)
594 for (retry = 0; retry < 3; retry++)
596 ret = usbh_ctrl_xfer(udev, REQ_TYPE_IN | REQ_TYPE_STD_DEV | REQ_TYPE_TO_DEV,
597 USB_REQ_GET_DESCRIPTOR,
598 ((USB_DT_STANDARD | USB_DT_DEVICE) << 8), 0,
sizeof(DESC_DEV_T),
599 (uint8_t *)desc_buff, &read_len, timeout);
603 USB_debug(
"Get device descriptor failed - %d, retry!\n", ret);
616int usbh_get_config_descriptor(UDEV_T *udev, uint8_t *desc_buff,
int buff_len)
619 DESC_CONF_T *conf = (DESC_CONF_T *)desc_buff;
625 ret = usbh_ctrl_xfer(udev, REQ_TYPE_IN | REQ_TYPE_STD_DEV | REQ_TYPE_TO_DEV,
626 USB_REQ_GET_DESCRIPTOR,
627 ((USB_DT_STANDARD | USB_DT_CONFIGURATION) << 8), 0, 9,
628 desc_buff, &read_len, 200);
632 if (conf->wTotalLength > buff_len)
634 USB_error(
"Device configuration %d length > %d!\n", conf->wTotalLength, buff_len);
638 read_len = conf->wTotalLength;
640 ret = usbh_ctrl_xfer(udev, REQ_TYPE_IN | REQ_TYPE_STD_DEV | REQ_TYPE_TO_DEV,
641 USB_REQ_GET_DESCRIPTOR,
642 ((USB_DT_STANDARD | USB_DT_CONFIGURATION) << 8), 0, read_len,
643 desc_buff, &read_len, 200);
660int usbh_get_string_descriptor(UDEV_T *udev,
int index, uint8_t *desc_buff,
int buff_len)
668 ret = usbh_ctrl_xfer(udev, REQ_TYPE_IN | REQ_TYPE_STD_DEV | REQ_TYPE_TO_DEV,
669 USB_REQ_GET_DESCRIPTOR,
670 ((USB_DT_STANDARD | USB_DT_STRING) << 8) | index, 0x0409, buff_len,
671 desc_buff, &read_len, 200);
682int usbh_clear_halt(UDEV_T *udev, uint16_t ep_addr)
686 USB_debug(
"Clear endpoint 0x%x halt.\n", ep_addr);
687 return usbh_ctrl_xfer(udev, REQ_TYPE_OUT | REQ_TYPE_STD_DEV | REQ_TYPE_TO_EP,
688 USB_REQ_CLEAR_FEATURE, 0, ep_addr, 0,
689 NULL, &read_len, 100);
692static int usbh_parse_endpoint(ALT_IFACE_T *alt,
int ep_idx, uint8_t *desc_buff,
int len)
700 ep_desc = (DESC_EP_T *)desc_buff;
702 if ((len < ep_desc->bLength) || (ep_desc->bLength < 2))
704 USB_error(
"ERR DESCRIPTOR EP LEN [0x%X %d]\n", ep_desc->bDescriptorType, ep_desc->bLength);
708 if (ep_desc->bDescriptorType == USB_DT_ENDPOINT)
712 USB_vdebug(
"ignore descriptor 0x%X %d\n", ep_desc->bDescriptorType, ep_desc->bLength);
713 desc_buff += ep_desc->bLength;
714 parsed_len += ep_desc->bLength;
715 len -= ep_desc->bLength;
718 USB_vdebug(
"Descriptor Found - Alt: %d, Endpoint 0x%x, remaining len: %d\n", alt->ifd->bAlternateSetting, ep_desc->bEndpointAddress, len);
720 alt->ep[ep_idx].bEndpointAddress = ep_desc->bEndpointAddress;
721 alt->ep[ep_idx].bmAttributes = ep_desc->bmAttributes;
722 alt->ep[ep_idx].bInterval = ep_desc->bInterval;
723 pksz = ep_desc->wMaxPacketSize;
724 pksz = (pksz & 0x07ff) * (1 + ((pksz >> 11) & 3));
725 alt->ep[ep_idx].wMaxPacketSize = pksz;
726 alt->ep[ep_idx].hw_pipe =
NULL;
728 return parsed_len + ep_desc->bLength;
740static int usbh_parse_interface(UDEV_T *udev, uint8_t *desc_buff,
int len)
742 int i, matched, parsed_len = 0;
745 IFACE_T *iface =
NULL;
748 iface = usbh_alloc_mem(
sizeof(*iface));
752 iface->aif = &iface->alt[0];
754 iface->if_num = ((DESC_IF_T *)desc_buff)->bInterfaceNumber;
761 if_desc = (DESC_IF_T *)desc_buff;
763 if (if_desc->bDescriptorType != USB_DT_INTERFACE)
765 desc_buff += if_desc->bLength;
766 parsed_len += if_desc->bLength;
767 len -= if_desc->bLength;
771 if (if_desc->bInterfaceNumber != iface->if_num)
776 if (if_desc->bNumEndpoints > MAX_EP_PER_IFACE)
778 USB_error(
"IF EP LIMITE %d\n", if_desc->bNumEndpoints);
784 desc_buff += if_desc->bLength;
785 parsed_len += if_desc->bLength;
786 len -= if_desc->bLength;
787 USB_vdebug(
"Descriptor Found - Interface %d, Alt: %d, num_alt:%d, remaining len: %d\n", if_desc->bInterfaceNumber, if_desc->bAlternateSetting, iface->num_alt, len);
792 if (iface->num_alt >= MAX_ALT_PER_IFACE)
803 hdr = (DESC_HDR_T *)desc_buff;
805 if ((len < hdr->bLength) || (hdr->bLength < 2))
807 USB_error(
"ERR DESCRIPTOR IF LEN [0x%X %d]\n", hdr->bDescriptorType, hdr->bLength);
812 if (hdr->bDescriptorType == USB_DT_CONFIGURATION)
815 if ((hdr->bDescriptorType == USB_DT_INTERFACE) || (hdr->bDescriptorType == USB_DT_ENDPOINT))
819 USB_vdebug(
"ignore descriptor 0x%X %d\n", hdr->bDescriptorType, hdr->bLength);
820 desc_buff += hdr->bLength;
821 parsed_len += hdr->bLength;
825 iface->alt[iface->num_alt].ifd = if_desc;
831 if (hdr->bDescriptorType == USB_DT_INTERFACE)
834 USB_vdebug(
"Finding %d endpoints of interface %d, alt %d...\n", if_desc->bNumEndpoints, if_desc->bInterfaceNumber, if_desc->bAlternateSetting);
837 for (i = 0; i < if_desc->bNumEndpoints; i++)
839 ret = usbh_parse_endpoint(&iface->alt[iface->num_alt-1], i, desc_buff, len);
846 USB_vdebug(
"EP parse remaining %d\n", len);
856 for (i = 0; i < MAX_UDEV_DRIVER; i++)
858 if ((_drivers[i] !=
NULL) && (_drivers[i]->probe(iface) == 0))
867 iface->driver = _drivers[i];
871 if (udev->iface_list ==
NULL)
872 udev->iface_list = iface;
875 iface->next = udev->iface_list;
876 udev->iface_list = iface;
881 usbh_free_mem(iface,
sizeof(*iface));
888 usbh_free_mem(iface,
sizeof(*iface));
893static int usbh_parse_configuration(UDEV_T *udev, uint8_t *desc_buff)
895 DESC_CONF_T *config = (DESC_CONF_T *)desc_buff;
899 len = config->wTotalLength;
901 desc_buff += config->bLength;
902 len -= config->bLength;
904 USB_vdebug(
"Parsing CONFIG =>\n");
906 for (i = 0; i < config->bNumInterfaces; i++)
911 while (len >=
sizeof(DESC_HDR_T))
913 hdr = (DESC_HDR_T *)desc_buff;
915 if ((hdr->bLength > len) || (hdr->bLength < 2))
917 USB_error(
"ERR DESCRIPTOR CONFIG [%d]\n", hdr->bLength);
921 if (hdr->bDescriptorType == USB_DT_INTERFACE)
924 USB_debug(
"ignore descriptor 0x%X %d\n", hdr->bDescriptorType, hdr->bLength);
926 desc_buff += hdr->bLength;
930 ret = usbh_parse_interface(udev, desc_buff, len);
936 USB_vdebug(
"IFACE parse remaining %d\n", len);
941 USB_debug(
"ERR DESCRIPTOR CONFIG LEN %d\n", len);
947void print_usb_string(
char *lead, uint8_t *str)
951 USB_debug(
"%s", lead);
955 USB_debug(
"%c", str[i]);
961int connect_device(UDEV_T *udev)
967 USB_debug(
"Connect device =>\n");
969 delay_us(100 * 1000);
971 usbh_get_device_descriptor(udev, &udev->descriptor);
975 delay_us(100 * 1000);
977 ret = usbh_set_address(udev);
980 USB_debug(
"Set address command failed!!\n");
984 delay_us(100 * 1000);
986 USB_debug(
"New %s device address %d assigned.\n", (udev->speed == SPEED_HIGH) ?
"high-speed" : ((udev->speed == SPEED_FULL) ?
"full-speed" :
"low-speed"), udev->dev_num);
989 ret = usbh_get_device_descriptor(udev, &udev->descriptor);
992 free_dev_address(udev->dev_num);
996#if defined(DUMP_DESCRIPTOR) && defined(ENABLE_DEBUG_MSG)
997 dump_device_descriptor(&udev->descriptor);
1000 if (udev->descriptor.bNumConfigurations != 1)
1002 USB_debug(
"Warning! This device has multiple configurations [%d]. \n", udev->descriptor.bNumConfigurations);
1005 conf = (DESC_CONF_T *)usbh_alloc_mem(MAX_DESC_BUFF_SIZE);
1008 free_dev_address(udev->dev_num);
1012 udev->cfd_buff = (uint8_t *)conf;
1015 ret = usbh_get_config_descriptor(udev, (uint8_t *)conf, MAX_DESC_BUFF_SIZE);
1018 free_dev_address(udev->dev_num);
1022#if defined(DUMP_DESCRIPTOR) && defined(ENABLE_DEBUG_MSG)
1023 dump_config_descriptor(conf);
1027 str_buff = (uint8_t *)usbh_alloc_mem(MAX_DESC_BUFF_SIZE);
1028 if (udev->descriptor.iManufacturer != 0)
1030 usbh_get_string_descriptor(udev, udev->descriptor.iManufacturer, str_buff, MAX_DESC_BUFF_SIZE);
1031 print_usb_string(
"Manufactor: ", str_buff);
1033 if (udev->descriptor.iProduct != 0)
1035 usbh_get_string_descriptor(udev, udev->descriptor.iProduct, str_buff, MAX_DESC_BUFF_SIZE);
1036 print_usb_string(
"Product: ", str_buff);
1038 if (udev->descriptor.iSerialNumber != 0)
1040 usbh_get_string_descriptor(udev, udev->descriptor.iSerialNumber, str_buff, MAX_DESC_BUFF_SIZE);
1041 print_usb_string(
"Serial Number: ", str_buff);
1043 usbh_free_mem(str_buff, MAX_DESC_BUFF_SIZE);
1047 ret = usbh_set_configuration(udev, conf->bConfigurationValue);
1050 USB_debug(
"Set configuration %d failed!\n", conf->bConfigurationValue);
1051 free_dev_address(udev->dev_num);
1056 ret = usbh_parse_configuration(udev, (uint8_t *)conf);
1059 USB_debug(
"Parse configuration %d failed!\n", conf->bConfigurationValue);
1060 free_dev_address(udev->dev_num);
1064 if (conf->bmAttributes & (1<<5))
1067 if (usbh_ctrl_xfer(udev, REQ_TYPE_OUT | REQ_TYPE_STD_DEV | REQ_TYPE_TO_DEV,
1068 USB_REQ_SET_FEATURE, 0x01, 0x0000, 0x0000,
1069 NULL, &read_len, 300) < 0)
1071 USB_debug(
"Device does not accept remote wakeup enable command.\n");
1076 g_conn_func(udev, 0);
1081int usbh_reset_device(UDEV_T *udev)
1088 USB_debug(
"Reset device =>\n");
1097 g_disconn_func(udev, 0);
1099 usbh_quit_xfer(udev, &(udev->ep0));
1102 iface = udev->iface_list;
1103 while (iface !=
NULL)
1105 udev->iface_list = iface->next;
1106 iface->driver->disconnect(iface);
1107 usbh_free_mem(iface,
sizeof(*iface));
1108 iface = udev->iface_list;
1117 delay_us(100 * 1000);
1123 dev_num = udev->dev_num;
1126 ret = usbh_ctrl_xfer(udev, REQ_TYPE_OUT | REQ_TYPE_STD_DEV | REQ_TYPE_TO_DEV,
1127 USB_REQ_SET_ADDRESS, dev_num, 0, 0,
1128 NULL, &read_len, 100);
1129 udev->dev_num = dev_num;
1133 delay_us(100 * 1000);
1140 ret = usbh_get_device_descriptor(udev, &udev->descriptor);
1148 conf = (DESC_CONF_T *)udev->cfd_buff;
1151 ret = usbh_get_config_descriptor(udev, (uint8_t *)conf, MAX_DESC_BUFF_SIZE);
1156 ret = usbh_set_configuration(udev, udev->cur_conf);
1159 USB_debug(
"Set configuration %d failed!\n", udev->cur_conf);
1164 ret = usbh_parse_configuration(udev, (uint8_t *)conf);
1167 USB_debug(
"Parse configuration %d failed!\n", conf->bConfigurationValue);
1172 if (usbh_ctrl_xfer(udev, REQ_TYPE_OUT | REQ_TYPE_STD_DEV | REQ_TYPE_TO_DEV,
1173 USB_REQ_SET_FEATURE, 0x01, 0x0000, 0x0000,
1174 NULL, &read_len, 300) < 0)
1176 USB_debug(
"Device not accept remote wakeup enable command.\n");
1180 g_conn_func(udev, 0);
1185void disconnect_device(UDEV_T *udev)
1189 USB_debug(
"disconnect device...\n");
1192 g_disconn_func(udev, 0);
1194 usbh_quit_xfer(udev, &(udev->ep0));
1197 iface = udev->iface_list;
1198 while (iface !=
NULL)
1200 udev->iface_list = iface->next;
1201 iface->driver->disconnect(iface);
1202 usbh_free_mem(iface,
sizeof(*iface));
1203 iface = udev->iface_list;
1207 free_dev_address(udev->dev_num);
1214static int check_device(UDEV_T *udev)
1235EP_INFO_T * usbh_iface_find_ep(IFACE_T *iface, uint8_t ep_addr, uint8_t dir_type)
1237 ALT_IFACE_T *aif = iface->aif;
1242 for (i = 0; i < aif->ifd->bNumEndpoints; i++)
1244 if (((aif->ep[i].bEndpointAddress & EP_ADDR_DIR_MASK) == (dir_type & EP_ADDR_DIR_MASK)) &&
1245 ((aif->ep[i].bmAttributes & EP_ATTR_TT_MASK) == (dir_type & EP_ATTR_TT_MASK)))
1251 for (i = 0; i < aif->ifd->bNumEndpoints; i++)
1253 if (aif->ep[i].bEndpointAddress == ep_addr)
1260void usbh_dump_buff_bytes(uint8_t *buff,
int nSize)
1267 printf(
"0x%04X ", nIdx);
1268 for (i = 0; i < 16; i++)
1269 printf(
"%02x ", buff[nIdx + i]);
1271 for (i = 0; i < 16; i++)
1273 if ((buff[nIdx + i] >= 0x20) && (buff[nIdx + i] < 127))
1274 printf(
"%c", buff[nIdx + i]);
1285void usbh_dump_iface(IFACE_T *iface)
1287 USB_debug(
"\n [IFACE info] (0x%x)\n", (
int)iface);
1288 USB_debug(
" ----------------------------------------------\n");
1289 USB_debug(
" udev = 0x%x\n", iface->udev);
1290 USB_debug(
" if_num = %d\n", iface->if_num);
1291 USB_debug(
" driver = 0x%x\n", (
int)iface->driver);
1292 USB_debug(
" next = 0x%x\n", (
int)iface->next);
1293 usbh_dump_interface_descriptor(iface->aif->ifd);
1296void usbh_dump_ep_info(EP_INFO_T *ep)
1298 USB_debug(
"\n [Endpoint Info] (0x%x)\n", (
int)ep);
1299 USB_debug(
" ----------------------------------------------\n");
1300 USB_debug(
" bEndpointAddress = 0x%02x\n", ep->bEndpointAddress);
1301 USB_debug(
" bmAttributes = 0x%02x\n", ep->bmAttributes);
1302 USB_debug(
" bInterval = %d\n", ep->bInterval);
1303 USB_debug(
" wMaxPacketSize = %d\n", ep->wMaxPacketSize);
1304 USB_debug(
" hw_pipe = 0x%x\n", (
int)ep->hw_pipe);
NuMicro peripheral access layer header file.
#define NULL
NULL pointer.
#define HSUSBH_UCMDR_RUN_Msk
#define SYS_CSERVER_VERSION_Msk
#define HSUSBH_UPSCR_PE_Msk
#define USBH_HcRhStatus_DRWE_Msk
#define HSUSBH_UCMDR_ASEN_Msk
#define USBH_HcRhPortStatus_PSS_Msk
#define HSUSBH_USTSR_HCHalted_Msk
#define HSUSBH_UPSCR_SUSPEND_Msk
#define USBH_HcMiscControl_OCAL_Msk
#define USBH_HcInterruptEnable_RD_Msk
#define HSUSBH_UCMDR_PSEN_Msk
#define USBH_HcInterruptEnable_RHSC_Msk
#define USBH_HcControl_HCFS_Pos
#define USBH_HcRhPortStatus_CCS_Msk
#define USBH_HcRhPortStatus_POCI_Msk
#define HSUSBH_UPSCR_FPR_Msk
#define USBH_ERR_SET_CONFIG
#define USBH_ERR_SET_DEV_ADDR
#define USBH_ERR_INVALID_PARAM
#define USBH_ERR_IF_EP_LIMIT
#define USBH_ERR_NOT_FOUND
#define USBH_ERR_DESCRIPTOR
#define USBH_ERR_DATA_OVERRUN
#define USBH_ERR_IF_ALT_LIMIT
#define USBH_ERR_MEMORY_OUT
void usbh_suspend()
Suspend USB Host Controller and devices.
int usbh_pooling_hubs(void)
Let USB stack polls all root hubs and downstream hubs. If there's any hub port change found,...
HIDDEN_SYMBOLS void usbh_core_init()
Initialize M480 USB Host controller and USB stack.
void usbh_install_conn_callback(CONN_FUNC *conn_func, CONN_FUNC *disconn_func)
Install device connect and disconnect callback function.
uint32_t get_ticks(void)
A function return current tick count.
void usbh_resume(void)
Resume USB Host controller and devices.
void() CONN_FUNC(struct udev_t *udev, int param)
USB Host hub class driver header file.
__IO uint32_t HcRhPortStatus[2]
__IO uint32_t HcMiscControl
__IO uint32_t HcInterruptEnable
USB Host library header file.
static int reset_device(UDEV_T *udev)