/** * This function will attatch an usb device instance to a host controller, * and do device enumunation process. * * @param hcd the host controller driver. * @param uinst the usb device instance. * * @return the error code, RT_EOK on successfully. */ rt_err_t rt_usb_attatch_instance(uinst_t uinst) { int i = 0; rt_err_t ret = RT_EOK; struct uconfig_descriptor cfg_desc; udev_desc_t dev_desc; uintf_desc_t intf_desc; ucd_t drv; RT_ASSERT(uinst != RT_NULL); rt_memset(&cfg_desc, 0, sizeof(struct uconfig_descriptor)); dev_desc = &uinst->dev_desc; RT_DEBUG_LOG(RT_DEBUG_USB, ("start enumnation\n")); /* get device descriptor head */ ret = rt_usb_get_descriptor(uinst, USB_DESC_TYPE_DEVICE, (void *)dev_desc, 8); if(ret != RT_EOK) { rt_kprintf("get device descriptor head failed\n"); return ret; } /* set device address */ ret = rt_usb_set_address(uinst); if(ret != RT_EOK) { rt_kprintf("set device address failed\n"); return ret; } /* set device max packet size */ uinst->max_packet_size = uinst->dev_desc.bMaxPacketSize0; RT_DEBUG_LOG(RT_DEBUG_USB, ("get device descriptor length %d\n", dev_desc->bLength)); /* get full device descriptor again */ ret = rt_usb_get_descriptor (uinst, USB_DESC_TYPE_DEVICE, (void *)dev_desc, dev_desc->bLength); if(ret != RT_EOK) { rt_kprintf("get full device descriptor failed\n"); return ret; } RT_DEBUG_LOG(RT_DEBUG_USB, ("Vendor ID 0x%x\n", dev_desc->idVendor)); RT_DEBUG_LOG(RT_DEBUG_USB, ("Product ID 0x%x\n", dev_desc->idProduct)); /* get configuration descriptor head */ ret = rt_usb_get_descriptor(uinst, USB_DESC_TYPE_CONFIGURATION, &cfg_desc, sizeof(struct uconfig_descriptor)); if(ret != RT_EOK) { rt_kprintf("get configuration descriptor head failed\n"); return ret; } /* alloc memory for configuration descriptor */ uinst->cfg_desc = (ucfg_desc_t)rt_malloc(cfg_desc.wTotalLength); rt_memset(uinst->cfg_desc, 0, cfg_desc.wTotalLength); /* get full configuration descriptor */ ret = rt_usb_get_descriptor(uinst, USB_DESC_TYPE_CONFIGURATION, uinst->cfg_desc, cfg_desc.wTotalLength); if(ret != RT_EOK) { rt_kprintf("get full configuration descriptor failed\n"); return ret; } /* set configuration */ ret = rt_usb_set_configure(uinst, 1); if(ret != RT_EOK) return ret; for(i = 0; i < uinst->cfg_desc->bNumInterfaces; i++) { /* get interface descriptor through configuration descriptor */ ret = rt_usb_get_interface_descriptor(uinst->cfg_desc, i, &intf_desc); if(ret != RT_EOK) { rt_kprintf("rt_usb_get_interface_descriptor error\n"); return -RT_ERROR; } RT_DEBUG_LOG(RT_DEBUG_USB, ("interface class 0x%x, subclass 0x%x\n", intf_desc->bInterfaceClass, intf_desc->bInterfaceSubClass)); /* find driver by class code found in interface descriptor */ drv = rt_usb_class_driver_find(intf_desc->bInterfaceClass, intf_desc->bInterfaceSubClass); if(drv != RT_NULL) { /* allocate memory for interface uinst */ uinst->ifinst[i] = (uifinst_t)rt_malloc(sizeof(struct uifinst)); uinst->ifinst[i]->drv = drv; uinst->ifinst[i]->uinst = uinst; uinst->ifinst[i]->intf_desc = intf_desc; uinst->ifinst[i]->user_data = RT_NULL; /* open usb class driver */ ret = rt_usb_class_driver_run(drv, (void *)uinst->ifinst[i]); if(ret != RT_EOK) { rt_kprintf("interface %d run class driver error\n", i); } } else { rt_kprintf("find usb device driver failed\n"); continue; } } return RT_EOK; }
/** * This function will run adk class driver when usb device is detected and identified * as a adk class device, it will continue the enumulate process. * * @param arg the argument. * * @return the error code, RT_EOK on successfully. */ static rt_err_t rt_usb_adk_run(void* arg) { int i = 0; uadkinst_t adkinst; uifinst_t ifinst = (uifinst_t)arg; udev_desc_t dev_desc; rt_uint16_t protocol; rt_err_t ret; /* parameter check */ if(ifinst == RT_NULL) { rt_kprintf("the interface is not available\n"); return -RT_EIO; } RT_DEBUG_LOG(RT_DEBUG_USB,("rt_usb_adk_run\n")); if(ifinst->intf_desc->bInterfaceSubClass != 0xFF) return -RT_ERROR; dev_desc = &ifinst->uinst->dev_desc; if(dev_desc->idVendor == USB_ACCESSORY_VENDOR_ID && (dev_desc->idProduct == USB_ACCESSORY_PRODUCT_ID || dev_desc->idProduct == USB_ACCESSORY_ADB_PRODUCT_ID)) { rt_kprintf("found android accessory device\n"); } else { rt_kprintf("switch device\n"); if((ret = rt_usb_adk_get_protocol(ifinst, &protocol)) != RT_EOK) { rt_kprintf("rt_usb_adk_get_protocol failed\n"); return ret; } if(protocol != 1) { rt_kprintf("read protocol failed\n"); return -RT_ERROR; } rt_usb_adk_send_string(ifinst, ACCESSORY_STRING_MANUFACTURER, "Real Thread, Inc"); rt_usb_adk_send_string(ifinst, ACCESSORY_STRING_MODEL, "ART"); rt_usb_adk_send_string(ifinst, ACCESSORY_STRING_DESCRIPTION, "Arduino like board"); rt_usb_adk_send_string(ifinst, ACCESSORY_STRING_VERSION, "1.0"); rt_usb_adk_send_string(ifinst, ACCESSORY_STRING_VERSION, "www.rt-thread.org"); rt_usb_adk_send_string(ifinst, ACCESSORY_STRING_SERIAL, "00000012345678"); if((ret = rt_usb_adk_start(ifinst)) != RT_EOK) { rt_kprintf("rt_usb_adk_start failed\n"); return ret; } return RT_EOK; } adkinst = rt_malloc(sizeof(struct uadkinst)); RT_ASSERT(adkinst != RT_NULL); /* initilize the data structure */ rt_memset(adkinst, 0, sizeof(struct uadkinst)); ifinst->user_data = (void*)adkinst; for(i=0; i<ifinst->intf_desc->bNumEndpoints; i++) { uep_desc_t ep_desc; /* get endpoint descriptor from interface descriptor */ rt_usb_get_endpoint_descriptor(ifinst->intf_desc, i, &ep_desc); if(ep_desc == RT_NULL) { rt_kprintf("rt_usb_get_endpoint_descriptor error\n"); return -RT_ERROR; } /* the endpoint type of adk class should be BULK */ if((ep_desc->bmAttributes & USB_EP_ATTR_TYPE_MASK) != USB_EP_ATTR_BULK) continue; /* allocate pipes according to the endpoint type */ if(ep_desc->bEndpointAddress & USB_DIR_IN) { /* allocate an in pipe for the adk instance */ ret = rt_usb_hcd_alloc_pipe(ifinst->uinst->hcd, &adkinst->pipe_in, ifinst, ep_desc, RT_NULL); if(ret != RT_EOK) return ret; } else { /* allocate an output pipe for the adk instance */ ret = rt_usb_hcd_alloc_pipe(ifinst->uinst->hcd, &adkinst->pipe_out, ifinst, ep_desc, RT_NULL); if(ret != RT_EOK) return ret; } } /* check pipes infomation */ if(adkinst->pipe_in == RT_NULL || adkinst->pipe_out == RT_NULL) { rt_kprintf("pipe error, unsupported device\n"); return -RT_ERROR; } /* set configuration */ ret = rt_usb_set_configure(ifinst->uinst, 1); if(ret != RT_EOK) return ret; /* register adk device */ adkinst->device.type = RT_Device_Class_Char; adkinst->device.init = RT_NULL; adkinst->device.open = RT_NULL; adkinst->device.close = RT_NULL; adkinst->device.read = rt_usb_adk_read; adkinst->device.write = rt_usb_adk_write; adkinst->device.control = RT_NULL; adkinst->device.user_data = (void*)ifinst; rt_device_register(&adkinst->device, "adkdev", RT_DEVICE_FLAG_RDWR); return RT_EOK; }