USB gadget设备驱动解析

转载：http://blog.csdn.net/aleon_liao/article/details/8573254

http://blog.csdn.net/lushengchu_luis/article/details/17628937  

利用Linux USB gadget设备驱动可以实现一些比较有意思的功能，举两个例子： 1、一个嵌入式产品中的某个存储设备，或是一个存储设备的某个分区，可以作为一个U盘被PC；设别，从而非常方便的完成文件交互，这个功能被广泛的应用于手机、数码相机等产品中。2、一个嵌入式设备通过USB连接到你的PC后，在你的PC端会出现一个新的网络连接，在嵌入式设备上也会有一个网卡设备，你可以配置它们的IP地址，并进行网络通讯，俗称USBNET。

所有USB通讯的设备端都有usb device程序，通常称它们为usb固件。在一些功能简单的设备里，用一些专用的可编程USB控制器就可以了。而在一些运行了类似linux操作系统的复杂的嵌入式系统中，要完成usb device程序，就会要求你不仅熟悉usb device控制器的操作，还要熟悉操作系统的驱动架构。

我想通过 “功能体验”、“驱动调试”、“gadget驱动结构分析”、“编写一个自己的gadget驱动”这4个方面解析linux usb gadget设备驱动的编写方法。

一、linux模拟U盘功能的实现

在硬件环境为华清远见的fs2410平台，软件环境为linux-2.6.26的linux系统上，实现模拟U盘的功能。

向内核添加代码

#include <asm/arch/regs-gpio.h>
    #include <asm/arch/regs-clock.h>
    #include <asm/plat-s3c24xx/udc.h>

修改arch/arm/mach-s3c2410/mach-smdk2410.c

/*USB device上拉电阻处理 */
    static void smdk2410_udc_pullup(enum s3c2410_udc_cmd_e cmd)
    {
        u8 *s3c2410_pullup_info[] = {
            " ",
            "Pull-up enable",
            "Pull-up disable",
            "UDC reset, in case of"
        };
        printk("smdk2410_udc: %s/n",s3c2410_pullup_info[cmd]);
        s3c2410_gpio_cfgpin(S3C2410_GPG9, S3C2410_GPG9_OUTP);
        switch (cmd)
        {
            case S3C2410_UDC_P_ENABLE :
                
            s3c2410_gpio_setpin(S3C2410_GPG9, 1);   //set gpg9 output HIGH
                break;
            case S3C2410_UDC_P_DISABLE :
                s3c2410_gpio_setpin(S3C2410_GPG9, 0);   //set gpg9 output LOW
                break;
            case S3C2410_UDC_P_RESET :
                //FIXME!!!
                break;
            default:
                break;
        }
    }

static struct s3c2410_udc_mach_info smdk2410_udc_cfg __initdata = {
        .udc_command    = smdk2410_udc_pullup,
    };

static struct platform_device *smdk2410_devices[] __initdata = {
    …,
    &s3c_device_usbgadget,  /*USB gadget device设备登记*/
    };

static void __init sdmk2410_init(void)    
    {
       u32 upll_value;
       set_s3c2410fb_info(&smdk2410_lcdcfg);
      s3c24xx_udc_set_platdata(&smdk2410_udc_cfg); /* 初始化*/
       s3c_device_sdi.dev.platform_data = &smdk2410_mmc_cfg;
       /* Turn off suspend on both USB ports, and switch the
        * selectable USB port to USB device mode. */

   s3c2410_modify_misccr(S3C2410_MISCCR_USBHOST |
                 S3C2410_MISCCR_USBSUSPND0 |
                 S3C2410_MISCCR_USBSUSPND1, 0x0);
      /* 设置USB时钟 */
      upll_value = (
           0x78 << S3C2410_PLLCON_MDIVSHIFT)
            | (0x02 << S3C2410_PLLCON_PDIVSHIFT)
            | (0x03 << S3C2410_PLLCON_SDIVSHIFT);
      while (upll_value != readl(S3C2410_UPLLCON)) {
          writel(upll_value, S3C2410_UPLLCON);
          udelay(20);       
        }
    }

修改drivers/usb/gadget/file_storage.c

static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
                struct usb_request *req, int *pbusy,
                enum fsg_buffer_state *state)
    {
        int     rc;
        udelay(800);
    …… 
    }

配置内核支持U盘模拟

<*>   USB Gadget Support  --->
            USB Peripheral Controller (S3C2410 USB Device Controller)  --->
             S3C2410 USB Device Controller
    [*]       S3C2410 udc debug messages
    <M>   USB Gadget Drivers 
    <M>     File-backed Storage Gadget

3、编译内核

#make zImage
    #make modules

在目录drivers/usb/gadget下生成g_file_storage.ko

加载驱动，测试功能

利用前面的生成的内核，启动系统后，加载g_file_storage.ko

#insmod g_file_storage.ko
    # insmod g_file_storage.ko file=/dev/mtdblock2 stall=0 removable=1
    0.03 USB: usb_gadget_register_driver() 'g_file_storage'
    0.04 USB: binding gadget driver 'g_file_storage'
    0.05 USB: s3c2410_set_selfpowered()
    g_file_storage gadget: File-backed Storage Gadget, version: 20 October 2004
    g_file_storage gadget: Number of LUNs=1
    g_file_storage gadget-lun0: ro=0, file: /dev/mtdblock3
    0.06 USB: udc_enable called
    smdk2410_udc: Pull-up enable

连接设备到windows，windows系统会自动设备到一个新的U盘加入。格式化U盘，存入文件。卸载U盘后，在目标板上执行如下操作：

# mkdir /mnt/gadget
    # mount -t vfat /dev/mtdblock2 /mnt/gadget/ 
    #ls

可以看到windows存入U盘的文件。

二、usbnet功能的实现

配置内核支持usbnet

<*>   USB Gadget Support  --->
            USB Peripheral Controller (S3C2410 USB Device Controller)  --->
             S3C2410 USB Device Controller
    [*]       S3C2410 udc debug messages
    <M>   USB Gadget Drivers
    <M>     Ethernet Gadget (with CDC Ethernet support)
    [*]       RNDIS support

2、编译内核

#make zImage
    #make modules

在目录drivers/usb/gadget下生成g_ether.ko

3、加载驱动，测试功能

利用前面的生成的内核，启动系统后，加载g_ether.ko

#insmod g_ether.ko
    #ifconfig usb0 192.168.1.120
    ……
    usb0 Link encap:Ethernet HWaddr 5E:C5:F6:D4:2B:91
    inet addr:192.168.1.120 Bcast:192.168.1.255 Mask:255.255.255.0
    UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
    RX packets:253 errors:0 dropped:0 overruns:0 frame:0
    TX packets:43 errors:0 dropped:0 overruns:0 carrier:0
    collisions:0 txqueuelen:1000
    RX bytes:35277 (34.4 KiB) TX bytes:10152 (9.9 KiB)

连接设备到windows，windows系统会提示安装驱动，根据提示安装上RNDIS驱动。这个驱动可以在网络上找到。此时windows会新生成一个网络连接，配置它的ip地址等信息。然后就可以和目标系统通过USB实现网络通讯了。

————————————————————————————————————————————————————————————————————————————

gadget就是指一些比较杂的小设备，gadget类的一定是作为usb device用。

前面一篇提到usb作为device的情况，注册完成后，导出usb_gadget_probe_driver函数后就完了。

这个函数就是为gadget驱动准备的，这就要从gadget/Android.c开始分析，先从它的init函数看起：

[java] view plain copy

1. static int __init init(void)  
2. {  
3.     struct android_dev *dev;  
4.     int err;  
5. 。。。。。。  
6.     android_class = class_create(THIS_MODULE, "android_usb");  
7.     if (IS_ERR(android_class))  
8.         return PTR_ERR(android_class);  
9.   
10.     dev = kzalloc(sizeof(*dev), GFP_KERNEL);  
11.     if (!dev)  
12.         return -ENOMEM;  
13.   
14.     dev->functions = supported_functions;  
15.     INIT_LIST_HEAD(&dev->enabled_functions);  
16.     INIT_WORK(&dev->work, android_work);  
17.   
18.     err = android_create_device(dev);                                                                                                                            
19.     if (err) {  
20.         class_destroy(android_class);  
21.         kfree(dev);  
22.         return err;  
23.     }  
24.   
25.     _android_dev = dev;  
26.   
27.     /* Override composite driver functions */  
28.     composite_driver.setup = android_setup;  
29.     composite_driver.disconnect = android_disconnect;  
30.   
31.     return usb_composite_probe(&android_usb_driver, android_bind);  
32. }  

supported_functions代表了gadget驱动支持的类型，如下：

[java] view plain copy

1. static struct android_usb_function *supported_functions[] = {                                                                                                    
2.     &adb_function,  
3.     &acm_function,  
4.     &mtp_function,  
5.     &ptp_function,  
6.     &rndis_function,  
7.     &mass_storage_function,  
8.     &accessory_function,  
9.     NULL  
10. };  

他们分别代表adb设备、acm(串口设备)、mtp(ptp的扩展)、ptp(图片传输设备)、rndis(网络设备)、U盘设备、accessory(其他一些小附件)。

不管上述何种设备，都是把它们模拟成一个usb从设备来看待，所以必须要有端点0作为控制传输、还要有其它非零端点用来传输数据。

刚好A10 CPU的usb otg 口有一个控制传输端点，4个批量传输端点和一个中断传输端点，可以符合上述的要求。

所以android.c、composite.c 的作用就是依据USB协议模拟出端点0、设备描述符等一个usb设备枚举过程所要求的功能；至于这个usb设备具体做什么，那就是由接口描述符和端点的功能决定，所以f_mtp.c、f_accessory.c、f_mass_storage.c、f_adb.c、f_acm.c等文件所做的事情的就是实现具体接口和这个接口下的端点的具体功能。

android_usb_driver代表了一个设备描述符所要具备的信息和响应的动作：

[java] view plain copy

1. static struct usb_composite_driver android_usb_driver = {                                                                                                        
2.     .name       = "android_usb",  
3.     .dev        = &device_desc,  
4.     .strings    = dev_strings,  
5.     .unbind     = android_usb_unbind,  
6. };  

device_desc类型为usb_device_descriptor，定义如下：

[java] view plain copy

1. static struct usb_device_descriptor device_desc = {                                                                                                              
2.     .bLength              = sizeof(device_desc),  
3.     .bDescriptorType      = USB_DT_DEVICE,  
4.     .bcdUSB               = __constant_cpu_to_le16(0x0200),  
5.     .bDeviceClass         = USB_CLASS_PER_INTERFACE,  
6.     .idVendor             = __constant_cpu_to_le16(VENDOR_ID),  
7.     .idProduct            = __constant_cpu_to_le16(PRODUCT_ID),  
8.     .bcdDevice            = __constant_cpu_to_le16(0xffff),  
9.     .bNumConfigurations   = 1,   
10. };  

这就是一个设备描述符的信息。

接着usb_composite_probe注册一个usb_composite_driver到composite.c 中，如果这一步能注册成功，那么gadget驱动就已经准备好了，随时可以相应主机的请求：

[java] view plain copy

1. int usb_composite_probe(struct usb_composite_driver *driver,  
2.                    int (*bind)(struct usb_composite_dev *cdev))  
3. {  
4.     if (!driver || !driver->dev || !bind || composite)  
5.         return -EINVAL;  
6.   
7.     if (!driver->name)  
8.         driver->name = "composite";  
9.     if (!driver->iProduct)  
10.         driver->iProduct = driver->name;  
11.     composite_driver.function =  (char *) driver->name;  
12.     composite_driver.driver.name = driver->name;  
13.     composite = driver;  
14.     composite_gadget_bind = bind;  
15.   
16.     return usb_gadget_probe_driver(&composite_driver, composite_bind);  
17. }  

composite_driver代表一个gadget驱动：

[java] view plain copy

1. static struct usb_gadget_driver composite_driver = {  
2.     .speed      = USB_SPEED_HIGH,  
3.   
4.     .unbind     = composite_unbind,  
5.   
6.     .setup      = composite_setup,                                                                                                                               
7.     .disconnect = composite_disconnect,  
8.   
9.     .suspend    = composite_suspend,  
10.     .resume     = composite_resume,  
11.   
12.     .driver = {  
13.         .owner      = THIS_MODULE,  
14.     },  
15. };  

简单的将driver和bind的值保存下来后调用。

usb_gadget_probe_driver函数就是在具体平台中定义的。前面一篇文章说过，这是导出来给gadget驱动用的，它是在usb/sun4i_usb/udc/sw_udc.c中：

[java] view plain copy

1. int usb_gadget_probe_driver(struct usb_gadget_driver *driver,  
2.                             int (*bind)(struct usb_gadget *))  
3. {  
4. 。。。。。。  
5.     if (!bind || !driver->setup || driver->speed < USB_SPEED_FULL) {  
6.         DMSG_PANIC("ERR: Invalid driver: bind %p setup %p speed %d\n",  
7.                    bind, driver->setup, driver->speed);  
8.         return -EINVAL;                                                                                                                                          
9.     }     
10. 。。。。。。  
11.     /* Bind the driver */  
12.     if ((retval = device_add(&udc->gadget.dev)) != 0) {  
13.         DMSG_PANIC("ERR: Error in device_add() : %d\n",retval);  
14.         goto register_error;  
15.     }  
16.   
17.     DMSG_INFO_UDC("[%s]: binding gadget driver '%s'\n", gadget_name, driver->driver.name);  
18.   
19.     if ((retval = bind (&udc->gadget)) != 0) {  
20.         DMSG_PANIC("ERR: Error in bind() : %d\n",retval);  
21.         device_del(&udc->gadget.dev);  
22.         goto register_error;  
23.     }  

这里才用device_add将设备添加到设备层，接着回调bind方法：

[java] view plain copy

1. static int composite_bind(struct usb_gadget *gadget)  
2. {  
3.     struct usb_composite_dev    *cdev;  
4.     int             status = -ENOMEM;  
5.   
6.     cdev = kzalloc(sizeof *cdev, GFP_KERNEL);  
7.     if (!cdev)  
8.         return status;  
9.   
10.     spin_lock_init(&cdev->lock);  
11.     cdev->gadget = gadget;  
12.     set_gadget_data(gadget, cdev);  
13.     INIT_LIST_HEAD(&cdev->configs);  
14.   
15.     /* preallocate control response and buffer */  
16.     cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);  
17.     if (!cdev->req)  
18.         goto fail;  
19.     cdev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);  
20.     if (!cdev->req->buf)  
21.         goto fail;  
22.     cdev->req->complete = composite_setup_complete;  
23.     gadget->ep0->driver_data = cdev;  
24. 。。。。。。  
25.     if (CONFIG_USB_GADGET_VBUS_DRAW <= USB_SELF_POWER_VBUS_MAX_DRAW)  
26.         usb_gadget_set_selfpowered(gadget);  
27.   
28.     /* interface and string IDs start at zero via kzalloc. 
29.      * we force endpoints to start unassigned; few controller 
30.      * drivers will zero ep->driver_data. 
31.      */  
32.     usb_ep_autoconfig_reset(cdev->gadget);  
33.   
34.     /* composite gadget needs to assign strings for whole device (like 
35.      * serial number), register function drivers, potentially update 
36.      * power state and consumption, etc 
37.      */  
38.     status = composite_gadget_bind(cdev);  
39. 。。。。。。  
40.     /* standardized runtime overrides for device ID data */  
41.     if (idVendor)  
42.         cdev->desc.idVendor = cpu_to_le16(idVendor);  
43.     if (idProduct)  
44.         cdev->desc.idProduct = cpu_to_le16(idProduct);                                                                                                           
45.     if (bcdDevice)  
46.         cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);  
47.   
48.     /* string overrides */  
49.     if (iManufacturer || !cdev->desc.iManufacturer) {  
50.         if (!iManufacturer && !composite->iManufacturer &&  
51.             !*composite_manufacturer)  
52.             snprintf(composite_manufacturer,  
53.                  sizeof composite_manufacturer,  
54.                  "%s %s with %s",  
55.                  init_utsname()->sysname,  
56.                  init_utsname()->release,  
57.                  gadget->name);  
58.   
59.         cdev->manufacturer_override =  
60.             override_id(cdev, &cdev->desc.iManufacturer);  
61.     }  
62.   
63.     if (iProduct || (!cdev->desc.iProduct && composite->iProduct))  
64.         cdev->product_override =  
65.             override_id(cdev, &cdev->desc.iProduct);  
66.   
67.     if (iSerialNumber)  
68.         cdev->serial_override =  
69.             override_id(cdev, &cdev->desc.iSerialNumber);  
70. 。。。。。。  
71. }  

首先认识usb_gadget这个结构体，这是具体平台定义的gadget资源，在sun4i_usb/udc/sw_udc.c中：

[java] view plain copy

1. static struct sw_udc sw_udc = {  
2.     .gadget = {  
3.         .ops        = &sw_udc_ops,  
4.         .ep0        = &sw_udc.ep[0].ep,  
5.         .name       = gadget_name,  
6.         .dev = {  
7.             .init_name  = "gadget",  
8.         },  
9.     },  
10.   
11.     /* control endpoint */  
12.     .ep[0] = {  
13.         .num            = 0,  
14.         .ep = {  
15.             .name       = ep0name,  
16.             .ops        = &sw_udc_ep_ops,                                                                                                                        
17.             .maxpacket  = EP0_FIFO_SIZE,  
18.         },  
19.         .dev            = &sw_udc,  
20.     },  
21.   
22.     /* first group of endpoints */  
23.     .ep[1] = {  
24.         .num            = 1,  
25.         .ep = {  
26.             .name       = "ep1-bulk",  
27.             .ops        = &sw_udc_ep_ops,  
28.             .maxpacket  = SW_UDC_EP_FIFO_SIZE,  
29.         },  
30.         .dev                = &sw_udc,  
31.         .fifo_size          = (SW_UDC_EP_FIFO_SIZE * (SW_UDC_FIFO_NUM + 1)),  
32.         .bEndpointAddress   = 1,  
33.         .bmAttributes       = USB_ENDPOINT_XFER_BULK,  
34.     },  
35. 。。。。。。  
36. .ep[5] = {  
37.         .num            = 5,  
38.         .ep = {  
39.             .name       = "ep5-int",  
40.             .ops        = &sw_udc_ep_ops,  
41.             .maxpacket  = SW_UDC_EP_FIFO_SIZE,  
42.         },  
43.         .dev                = &sw_udc,  
44.         .fifo_size          = (SW_UDC_EP_FIFO_SIZE * (SW_UDC_FIFO_NUM + 1)),  
45.         .bEndpointAddress   = 5,  
46.         .bmAttributes       = USB_ENDPOINT_XFER_INT,  
47.     },  
48. };  

一个端点0，4个bulk和一个int传输全部定义在这里，他们的ops指针都指向同一个sw_udc_ep_ops:

[java] view plain copy

1. static const struct usb_ep_ops sw_udc_ep_ops = {                                                                                                                 
2.     .enable         = sw_udc_ep_enable,  
3.     .disable        = sw_udc_ep_disable,  
4.   
5.     .alloc_request  = sw_udc_alloc_request,  
6.     .free_request   = sw_udc_free_request,  
7.   
8.     .queue          = sw_udc_queue,  
9.     .dequeue        = sw_udc_dequeue,  
10.   
11.     .set_halt       = sw_udc_set_halt,  
12. };  

usb_ep_alloc_request是为端点0分配空间对象，这样才能使用。composite_gadget_bind指针指向了android.c的bind函数：

[java] view plain copy

1. static int android_bind(struct usb_composite_dev *cdev)  
2. {  
3.     struct android_dev *dev = _android_dev;  
4.     struct usb_gadget   *gadget = cdev->gadget;  
5.     int         gcnum, id, ret;  
6.   
7.     usb_gadget_disconnect(gadget);  
8.   
9.     ret = android_init_functions(dev->functions, cdev);  
10. 。。。。。。  
11.     usb_gadget_set_selfpowered(gadget);  
12.     dev->cdev = cdev;  
13.   
14.     return 0;  
15. }  

主要是做初始化工作以及为pid、vid赋值等。

好像到这里就完成了，都是注册并填充了一些数据、方法等，那何时才相应主机的请求呢？有中断到来的时候。

在sun4i_usb/udc/sw_udc.c中，中断到来就表示主机有请求了，会调用注册的中断函数sw_udc_irq：

[java] view plain copy

1. static irqreturn_t sw_udc_irq(int dummy, void *_dev)  
2. {  
3. 。。。。。。  
4.     if (tx_irq & USBC_INTTx_FLAG_EP0) {  
5.          DMSG_DBG_UDC("USB ep0 irq\n");  
6.   
7.         /* Clear the interrupt bit by setting it to 1 */  
8.         USBC_INT_ClearEpPending(g_sw_udc_io.usb_bsp_hdle, USBC_EP_TYPE_TX, 0);  
9.   
10.         if(dev->gadget.speed == USB_SPEED_UNKNOWN){  
11.             if(USBC_Dev_QueryTransferMode(g_sw_udc_io.usb_bsp_hdle) == USBC_TS_MODE_HS){  
12.                 dev->gadget.speed = USB_SPEED_HIGH;  
13.   
14.             }else{  
15.                 dev->gadget.speed= USB_SPEED_FULL;  
16.             }  
17.         }  
18.   
19.         sw_udc_handle_ep0(dev);  
20.     }  
21. 。。。。。。  
22.     /* tx endpoint data transfers */  
23.     for (i = 1; i < SW_UDC_ENDPOINTS; i++) {  
24.         u32 tmp = 1 << i;  
25.   
26.         if (tx_irq & tmp) {  
27.             DMSG_DBG_UDC("USB tx ep%d irq\n", i);  
28.   
29.             /* Clear the interrupt bit by setting it to 1 */  
30.             USBC_INT_ClearEpPending(g_sw_udc_io.usb_bsp_hdle, USBC_EP_TYPE_TX, i);  
31.   
32.             sw_udc_handle_ep(&dev->ep[i]);  
33.         }  
34.     }  
35.   
36.     /* rx endpoint data transfers */  
37.     for (i = 1; i < SW_UDC_ENDPOINTS; i++) {  
38.         u32 tmp = 1 << i;  
39.   
40.         if (rx_irq & tmp) {  
41.             DMSG_DBG_UDC("USB rx ep%d irq\n", i);  
42.   
43.             /* Clear the interrupt bit by setting it to 1 */  
44.             USBC_INT_ClearEpPending(g_sw_udc_io.usb_bsp_hdle, USBC_EP_TYPE_RX, i);  
45.   
46.             sw_udc_handle_ep(&dev->ep[i]);  
47.         }  
48.     }  
49. 。。。。。。  
50. }  

主机肯定首先要和ep0通讯的。sw_udc_handle_ep0把请求类型做标记保存下来，最终调用的是dev->driver->setup(&dev->gadget, crq)，也就是android.c中的android_setup函数：

[java] view plain copy

1. static int  
2. android_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c)  
3. {  
4. 。。。。。。  
5.     list_for_each_entry(f, &dev->enabled_functions, enabled_list) {                                                                                              
6.         if (f->ctrlrequest) {  
7.             value = f->ctrlrequest(f, cdev, c);  
8.             if (value >= 0)  
9.                 break;  
10.         }  
11.     }  
12. 。。。。。。  
13.     /* Special case the accessory function. 
14.      * It needs to handle control requests before it is enabled. 
15.      */  
16.     if (value < 0)  
17.         value = acc_ctrlrequest(cdev, c);  
18.   
19.     if (value < 0)  
20.         value = composite_setup(gadget, c);  
21.   
22.     spin_lock_irqsave(&cdev->lock, flags);  
23.     if (!dev->connected) {  
24.         dev->connected = 1;  
25.         schedule_work(&dev->work);  
26.     }  
27.     else if (c->bRequest == USB_REQ_SET_CONFIGURATION && cdev->config) {  
28.         schedule_work(&dev->work);  
29.     }  
30.     spin_unlock_irqrestore(&cdev->lock, flags);  
31.   
32.     return value;  
33. }  

enabled_list链表的数据，是上层控制的，上层使用到那个功能才会添加到链表中去，anroid系统常使用到的是mass_storage,adb两个。ctrlrequest方法可以不定义，看具体设备而定。

如果acc_ctrlrequest方法无法处理，最终调用composite_setup来处理，它会相应主机的获取描述符，设置地址等请求。比如获取或者设置接口描述符也在这里完成：

[java] view plain copy

1. case USB_REQ_SET_INTERFACE:  
2.     if (ctrl->bRequestType != USB_RECIP_INTERFACE)  
3.         goto unknown;  
4.     if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)  
5.         break;  
6.     f = cdev->config->interface[intf];  
7.     if (!f)  
8.         break;  
9.     if (w_value && !f->set_alt)  
10.         break;  
11.     value = f->set_alt(f, w_index, w_value);  
12.     if (value == USB_GADGET_DELAYED_STATUS) {  
13.         DBG(cdev,  
14.          "%s: interface %d (%s) requested delayed status\n",  
15.                 __func__, intf, f->name);  
16.         cdev->delayed_status++;  
17.         DBG(cdev, "delayed_status count %d\n",  
18.                 cdev->delayed_status);  
19.     }  
20.     break;  
21. case USB_REQ_GET_INTERFACE:  
22.     if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))  
23.         goto unknown;  
24.     if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)  
25.         break;  
26.     f = cdev->config->interface[intf];  
27.     if (!f)  
28.         break;  
29.     /* lots of interfaces only need altsetting zero... */  
30.     value = f->get_alt ? f->get_alt(f, w_index) : 0;  
31.     if (value < 0)  
32.         break;  
33.     *((u8 *)req->buf) = value;  
34.     value = min(w_length, (u16) 1);  
35.     break;