add ADK protocol implement & format code style

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2219 bbd45198-f89e-11dd-88c7-29a3b14d5316

components/drivers/usb/usbhost/SConscript

@@ -17,10 +17,10 @@ if GetDepend('RT_USB_CLASS_MASS_STORAGE'):
 	src += Glob('class/mass.c')
 	src += Glob('udev/udisk.c')
 
-if GetDepend('RT_USING_CLASS_HID'):
+if GetDepend('RT_USB_CLASS_HID'):
 	src += Glob('class/hid.c')
 
-if GetDepend('RT_USING_HID_MOUSE'):
+if GetDepend('RT_USB_HID_MOUSE'):
 	src += Glob('udev/umouse.c')
 
 if GetDepend('RT_USB_HID_KEYBOARD'):

components/drivers/usb/usbhost/class/adk.c

@@ -20,50 +20,155 @@
 
 static struct uclass_driver adk_driver;
 
-rt_err_t rt_usb_adk_read(uifinst_t ifinst, rt_uint8_t *buffer, 
+/**
+ * This function will do USB_REQ_GET_PROTOCOL request to set idle period to the usb adk device
+ *
+ * @param ifinst the interface instance.
+ * @duration the idle period of requesting data.
+ * @report_id the report id
+ * 
+ * @return the error code, RT_EOK on successfully.
+*/
+rt_err_t rt_usb_adk_get_protocol(uifinst_t ifinst, rt_uint16_t *protocol)
+{
+    struct ureqest setup;
+    uinst_t uinst;    
+    int timeout = 100;
+            
+        /* parameter check */
+    RT_ASSERT(ifinst != RT_NULL);
+    RT_ASSERT(ifinst->uinst != RT_NULL);
+
+    uinst = ifinst->uinst;
+
+    setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_VENDOR | 
+        USB_REQ_TYPE_DEVICE;
+    setup.request = USB_REQ_GET_PROTOCOL;
+    setup.index = 0;
+    setup.length = 2;
+    setup.value = 0;
+
+    if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, (void*)protocol, 2, 
+        timeout) == 0) return RT_EOK;
+    else return -RT_FALSE;    
+}
+
+/**
+ * This function will do USB_REQ_SEND_STRING request to set idle period to the usb adk device
+ *
+ * @param ifinst the interface instance.
+ * @duration the idle period of requesting data.
+ * @report_id the report id
+ * 
+ * @return the error code, RT_EOK on successfully.
+*/
+rt_err_t rt_usb_adk_send_string(uifinst_t ifinst, rt_uint16_t index, 
+    const char* str)
+{
+    struct ureqest setup;
+    uinst_t uinst;    
+    int timeout = 100;
+            
+        /* parameter check */
+    RT_ASSERT(ifinst != RT_NULL);
+    RT_ASSERT(ifinst->uinst != RT_NULL);
+
+    uinst = ifinst->uinst;
+
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_VENDOR | 
+        USB_REQ_TYPE_DEVICE;
+    setup.request = USB_REQ_SEND_STRING;
+    setup.index = index;
+    setup.length = rt_strlen(str) + 1;
+    setup.value = 0;
+
+    if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, (void*)str, 
+        rt_strlen(str) + 1, timeout) == 0) return RT_EOK;
+    else return -RT_FALSE;   
+}
+
+/**
+ * This function will do USB_REQ_START request to set idle period to the usb adk device
+ *
+ * @param ifinst the interface instance.
+ * @duration the idle period of requesting data.
+ * @report_id the report id
+ * 
+ * @return the error code, RT_EOK on successfully.
+*/
+rt_err_t rt_usb_adk_start(uifinst_t ifinst)
+{
+    struct ureqest setup;
+    uinst_t uinst;    
+    int timeout = 100;
+            
+        /* parameter check */
+    RT_ASSERT(ifinst != RT_NULL);
+    RT_ASSERT(ifinst->uinst != RT_NULL);
+
+    uinst = ifinst->uinst;
+
+    setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_VENDOR | 
+        USB_REQ_TYPE_DEVICE;
+    setup.request = USB_REQ_START;
+    setup.index = 0;
+    setup.length = 0;
+    setup.value = 0;
+
+    if(rt_usb_hcd_control_xfer(uinst->hcd, uinst, &setup, RT_NULL, 0, 
+        timeout) == 0) return RT_EOK;
+    else return -RT_FALSE;   
+}
+
+/**
+ * This function will read data from usb adk device
+ *
+ * @param ifinst the interface instance.
+ * 
+ * @return the error code, RT_EOK on successfully.
+*/
+static rt_size_t rt_usb_adk_read(rt_device_t device, rt_off_t pos, void* buffer, 
     rt_size_t size)
 {
     uadkinst_t adkinst;
     rt_size_t length;
+    uifinst_t ifinst;
 
+    /* check parameter */
+    RT_ASSERT(device != RT_NULL);
     RT_ASSERT(buffer != RT_NULL);
 
-	if(ifinst == RT_NULL)
-	{
-		rt_kprintf("the interface is not available\n");
-		return -RT_EIO;
-	}
-	
-	/* get storage instance from the interface instance */	
+    ifinst = (uifinst_t)device->user_data;
     adkinst = (uadkinst_t)ifinst->user_data;
 
-	/* send the cbw */
     length = rt_usb_hcd_bulk_xfer(ifinst->uinst->hcd, adkinst->pipe_in, 
         buffer, size, 300);
     
     return length;
+
 }
 
-rt_err_t rt_usb_adk_write(uifinst_t ifinst, rt_uint8_t *buffer, 
+/**
+ * This function will write data to usb adk device
+ *
+ * @param ifinst the interface instance.
+ * 
+ * @return the error code, RT_EOK on successfully.
+*/
+static rt_size_t rt_usb_adk_write (rt_device_t device, rt_off_t pos, const void* buffer, 
     rt_size_t size)
 {
     uadkinst_t adkinst;
     rt_size_t length;
+    uifinst_t ifinst;
 
     RT_ASSERT(buffer != RT_NULL);    
 
-	if(ifinst == RT_NULL)
-	{
-		rt_kprintf("the interface is not available\n");
-		return -RT_EIO;
-	}
-	
-	/* get storage instance from the interface instance */	
+    ifinst = (uifinst_t)device->user_data;
     adkinst = (uadkinst_t)ifinst->user_data;
 
-	/* send the cbw */
     length = rt_usb_hcd_bulk_xfer(ifinst->uinst->hcd, adkinst->pipe_out, 
-		buffer, size, 300);
+        (void*)buffer, size, 300);
     
     return length;
 }
@@ -81,6 +186,8 @@ 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 */
@@ -92,6 +199,47 @@ static rt_err_t rt_usb_adk_run(void* arg)
 
     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);
 
@@ -139,6 +287,22 @@ static rt_err_t rt_usb_adk_run(void* arg)
         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;
 }
 
@@ -160,15 +324,26 @@ static rt_err_t rt_usb_adk_stop(void* arg)
     RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usb_adk_stop\n"));
 
     adkinst = (uadkinst_t)ifinst->user_data;
+    if(adkinst == RT_NULL) 
+    {
+        rt_free(ifinst);    
+        return RT_EOK;
+    }
     
     if(adkinst->pipe_in != RT_NULL)
         rt_usb_hcd_free_pipe(ifinst->uinst->hcd, adkinst->pipe_in);
 
+    if(adkinst->pipe_out != RT_NULL)
+        rt_usb_hcd_free_pipe(ifinst->uinst->hcd, adkinst->pipe_out);
+
+    /* unregister adk device */
+    rt_device_unregister(&adkinst->device);
+
     /* free adk instance */
     if(adkinst != RT_NULL) rt_free(adkinst);
     
     /* free interface instance */
-	if(ifinst != RT_NULL) rt_free(ifinst);
+    rt_free(ifinst);
 
     return RT_EOK;
 }

components/drivers/usb/usbhost/class/adk.h

@@ -21,9 +21,26 @@ struct uadkinst
 {
     upipe_t pipe_in;
     upipe_t pipe_out;
+
+    struct rt_device device;
 };    
 typedef struct uadkinst* uadkinst_t;
 
+#define USB_ACCESSORY_VENDOR_ID         0x18D1
+#define USB_ACCESSORY_PRODUCT_ID        0x2D00
+#define USB_ACCESSORY_ADB_PRODUCT_ID    0x2D01
+
+#define ACCESSORY_STRING_MANUFACTURER   0
+#define ACCESSORY_STRING_MODEL          1
+#define ACCESSORY_STRING_DESCRIPTION    2
+#define ACCESSORY_STRING_VERSION        3
+#define ACCESSORY_STRING_URI            4
+#define ACCESSORY_STRING_SERIAL         5
+
+#define USB_REQ_GET_PROTOCOL            51
+#define USB_REQ_SEND_STRING             52
+#define USB_REQ_START                   53
+
 #define USB_CLASS_ADK                   0xff
 
 #endif

components/drivers/usb/usbhost/core/core.c

@@ -79,6 +79,8 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst)
     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)
@@ -110,6 +112,9 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst)
         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));
@@ -136,7 +141,7 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst)
     ret = rt_usb_set_configure(uinst, 1);
     if(ret != RT_EOK) return ret;
 
-	//for(i=0; i<uinst->cfg_desc->bNumInterfaces; i++)
+    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);
@@ -146,9 +151,13 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst)
             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 */
@@ -158,6 +167,7 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst)
             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]);
@@ -169,7 +179,7 @@ rt_err_t rt_usb_attatch_instance(uinst_t uinst)
         else
         {
             rt_kprintf("find usb device driver failed\n");
-			return -RT_ERROR;
+            continue;
         }
     }
     

components/drivers/usb/usbhost/core/hub.c

@@ -319,7 +319,7 @@ static rt_err_t rt_usb_hub_port_change(uhubinst_t uhub)
         
         if(reconnect)
         {            
-			if(uhub->child[i]) 
+            if(uhub->child[i]->status != UINST_STATUS_IDLE) 
                 rt_usb_detach_instance(uhub->child[i]);
             
             ret = rt_usb_hub_port_debounce(uhub, i + 1);