Linux USB设备驱动

1、USB基础介绍

1-1、USB硬件接口介绍

        USB接口在硬件上总共有四根线组成VCC、D 、D-、GND，通过计算D 和D-的差值来确定数据。USB设备在传输速率上可以分为低速(1.5Mbps)、全速(12Mbps)，高速(480Mbps)。在USB主机控制器端D 和D-都接有一个下拉电阻，在USB设备端的D 或D-接了一个上拉电阻，USB设备插入后USB主机控制器的D 或D-会被拉高，这样USB主机控制器就能发现有设备接入。USB设备是主从式的设备，主机是在host端的主机控制器，从机就是如鼠标、键盘，hub之类的设备。从设备采用拓扑模式连接在USB主机控制器上。

1-2、USB接入时的探测过程

        当USB设备插入时，USB主机控制器的D 或D-被拉高，在主机控制器端会产生一个中断发现一个新设备并通过端点0给新设备分配一个地址和获取USB设备的设备描述符，解析设备描述符并通过device_add()将其添加到usb_bus_type链表中，并且匹配链表上的driver程序，匹配成功后调用driver的probe函数，这部分过程类似Platform平台总线驱动。

        下面图例所示是一个鼠标插入开发板时的打印信息。通过这个信息我们可以知道这是一个低速设备，并且分配的设备地址是2，通过获取设备的描述符，主机控制器还了解到这是一个USB鼠标。

2、USB设备驱动框架

        USB设备驱动通过端点和设备进行通讯，端点只能单向传输数据，有点类似pipe，对于端点的输入和输出方向是以USB主机控制器的角度来确定的。USB协议为适配不同的设备设计了四种不同的传输方式或者说端点类型：

控制：控制端点主要是用于控制设备，比如获取设备描述符，或者配置设备。端点0就是一个控制端点。

中断：中断端点是以一个固定的时间轮询设备，来传输少量数据。鼠标，键盘等就是使用中断端点进行传输。

批量：批量传输使用的设备一般使用于大量数据的传输，虽然时间长短没有保证，但会保证数据传输完成。U盘，打印机使用此类端点。

等时：等时端点的特点是实时但数据有可能会丢失。摄像头和音响等设备使用等时端点实现。

        对于一个USB设备来说，一个设备可以拥有一个以上的配置，配置可以拥有一个以上的接口，接口上有无端点都可以。这边说的配置，接口，端点都有一个对应的结构体来描述。

2-1、配置描述符

        配置可以认为是一种模式，就比如说我们的笔记本电脑可以有性能模式，省电模式等。驱动程序可以为同一个USB设备实现不同的配置。

1.  
   struct usb_config_descriptor {
2.  
       __u8  bLength; /* 描述符长度 */
3.  
       __u8  bDescriptorType; /* 配置类型 */
4.  
    
5.  
       __le16 wTotalLength;
6.  
       __u8  bNumInterfaces; /* 接口数量 */
7.  
       __u8  bConfigurationValue;
8.  
       __u8  iConfiguration;
9.  
       __u8  bmAttributes;
10.  
        __u8  bMaxPower;
11.  
    }

2-2、接口描述符

        接口可以认为是USB设备的功能，一个USB设备拥有几种功能，在驱动端就要为其实现几种接口，USB设备的每一个接口都有一个独立的驱动程序实现。就比如一个音响可以录音和播放，在驱动端就要为音响实现两个接口，也就是需要实现两个驱动程序来对应音响这个设备。

1.  
   struct usb_interface_descriptor {
2.  
       __u8  bLength; /* 接口描述符长度 */
3.  
       __u8  bDescriptorType; /* 接口类型 */
4.  
    
5.  
       __u8  bInterfaceNumber; /* 接口数量 */
6.  
       __u8  bAlternateSetting;
7.  
       __u8  bNumEndpoints; /* 端点数量 */
8.  
       __u8  bInterfaceClass; /* 接口的类 */
9.  
       __u8  bInterfaceSubClass; /* 接口的子类 */
10.  
        __u8  bInterfaceProtocol; /* 设备类型 */
11.  
        __u8  iInterface;
12.  
    }

2-3、端点描述符

        一个接口可以拥有多个端点或没有端点。例如一个接口可以同时拥有中断和等时端点。

1.  
   struct usb_endpoint_descriptor {
2.  
   __u8 bLength; /* 端点描述符长度 */
3.  
   __u8 bDescriptorType; /* 端点类型 */
4.  
    
5.  
   __u8 bEndpointAddress; /* 端点地址 */
6.  
   __u8 bmAttributes; /* 端点属性 */
7.  
   __le16 wMaxPacketSize;
8.  
   __u8 bInterval; /* 轮询时间间隔，单位是ms */
9.  
    
10.  
    /* NOTE: these two are _only_ in audio endpoints. */
11.  
    /* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */
12.  
    __u8 bRefresh;
13.  
    __u8 bSynchAddress;
14.  
    }

2-4、通信方式urb

        urb是设备驱动程序和设备之间用一种特定的端点进行通信的一种方式，驱动程序把urb提交给USB主机控制器，USB主机控制器根据这个urb对USB设备进行读或写操作，结束之后USB主机控制器会通知USB设备驱动程序。

urb的创建：

1.  
   /*
2.  
   * iso_packets：等时端点包的数量，对于非等时端点给0即可
3.  
   * mem_flags：用于kmalloc() 。通常用GFP_KERNEL，需要进行原子操作时使用GFP_ATOMIC
4.  
   */
5.  
   struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags)；
6.  
    
7.  
   /*
8.  
   * urb的销毁
9.  
   */
10.  
    void usb_free_urb(struct urb *urb)；

urb初始化：

        中断，批量和控制urb拥有初始化函数，等时urb没有初始化函数需要手动初始化。这个函数只是初始化部分成员，有些成员还是需要自己手动初始化。下面说明中断urb初始化函数参数。

1.  
   static inline void usb_fill_int_urb (struct urb *urb, // usb_alloc_urb()申请的urb
2.  
                        struct usb_device *dev, // 可以通过interface_to_usbdev()得到
3.  
                        unsigned int pipe, // 用来传输的特定端点通过宏usb_rcvintpipe()获得
4.  
                        void *transfer_buffer, // 用于存放读取或写入数据的缓冲区，由函数usb_buffer_alloc()申请;
5.  
                        int buffer_length, // 缓冲区长度
6.  
                        usb_complete_t complete_fn,// urb传输结束后的回调函数
7.  
                        void *context, // 私有数据
8.  
                        int interval // 轮询间隔，单位 1/8ms
9.  
   )；
10.  
     
11.  
    /*
12.  
    * dev: struct usb_device
13.  
    * endpoint: usb_endpoint_descriptor的成员bEndpointAddress
14.  
    */
15.  
    usb_rcvintpipe(dev,endpoint);

urb回调函数只有在一下三种情况下会被调用：

a、urb的输入或输出操作执行成功。

b、urb处理过程输错

c、调用了取消函数usb_unlink_urb()或usb_kill_urb()

提交urb

urb初始化完成后需要提交给USB主机控制器驱动

1.  
   /*
2.  
   * mem_flags只有三个只可以用：GFP_KERNEL，GFP_ATOMIC，GFP_NOIO
3.  
   * GFP_ATOMIC：中断处理函数，定时器回调。持有读写锁或自旋锁。
4.  
   * GFP_NOIO：位于I/O块路径时
5.  
   * GFP_KERNEL: 其他情况
6.  
   */
7.  
   int usb_submit_urb(struct urb *urb, gfp_t mem_flags)；

3、实例：USB鼠标驱动

文件路径：/drivers/hid/usbhid/usbmouse.c

让我们从init函数开始分析一个完整的基础usb设备驱动程序：

1.  
   #include <linux/kernel.h>
2.  
   #include <linux/slab.h>
3.  
   #include <linux/module.h>
4.  
   #include <linux/init.h>
5.  
   #include <linux/usb/input.h>
6.  
   #include <linux/hid.h>
7.  
    
8.  
   /*
9.  
   * Version Information
10.  
    */
11.  
    #define DRIVER_VERSION "v1.6"
12.  
    #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
13.  
    #define DRIVER_DESC "USB HID Boot Protocol mouse driver"
14.  
    #define DRIVER_LICENSE "GPL"
15.  
     
16.  
    MODULE_AUTHOR(DRIVER_AUTHOR);
17.  
    MODULE_DESCRIPTION(DRIVER_DESC);
18.  
    MODULE_LICENSE(DRIVER_LICENSE);
19.  
     
20.  
    struct usb_mouse {
21.  
    char name[128];
22.  
    char phys[64];
23.  
    struct usb_device *usbdev;
24.  
    struct input_dev *dev;
25.  
    struct urb *irq;
26.  
     
27.  
    signed char *data;
28.  
    dma_addr_t data_dma;
29.  
    };
30.  
     
31.  
    /* urb结束之后调用 */
32.  
    static void usb_mouse_irq(struct urb *urb)
33.  
    {
34.  
    struct usb_mouse *mouse = urb->context;
35.  
    signed char *data = mouse->data; /* 填充进urb的缓冲区 */
36.  
    struct input_dev *dev = mouse->dev;
37.  
    int status;
38.  
     
39.  
    /* 判断urb的结束状态 */
40.  
    switch (urb->status) {
41.  
    case 0: /* success */
42.  
    break;
43.  
    case -ECONNRESET: /* unlink */
44.  
    case -ENOENT:
45.  
    case -ESHUTDOWN:
46.  
    return;
47.  
    /* -EPIPE: should clear the halt */
48.  
    default: /* error */
49.  
    goto resubmit;
50.  
    }
51.  
     
52.  
    /* 上报事件 */
53.  
    input_report_key(dev, BTN_LEFT, data[0] & 0x01);
54.  
    input_report_key(dev, BTN_RIGHT, data[0] & 0x02);
55.  
    input_report_key(dev, BTN_MIDDLE, data[0] & 0x04);
56.  
    input_report_key(dev, BTN_SIDE, data[0] & 0x08);
57.  
    input_report_key(dev, BTN_EXTRA, data[0] & 0x10);
58.  
     
59.  
    input_report_rel(dev, REL_X, data[1]);
60.  
    input_report_rel(dev, REL_Y, data[2]);
61.  
    input_report_rel(dev, REL_WHEEL, data[3]);
62.  
     
63.  
    input_sync(dev);
64.  
    resubmit:
65.  
    /* 重新提交urb，这是一个中断处理函数，因此要是用原子操作 */
66.  
    status = usb_submit_urb (urb, GFP_ATOMIC);
67.  
    if (status)
68.  
    err ("can't resubmit intr, %s-%s/input0, status %d",
69.  
    mouse->usbdev->bus->bus_name,
70.  
    mouse->usbdev->devpath, status);
71.  
    }
72.  
     
73.  
    /* 在客户端调用open()函数时会调用到 */
74.  
    static int usb_mouse_open(struct input_dev *dev)
75.  
    {
76.  
    struct usb_mouse *mouse = input_get_drvdata(dev);
77.  
     
78.  
    mouse->irq->dev = mouse->usbdev;
79.  
     
80.  
    /* 提交urb */
81.  
    if (usb_submit_urb(mouse->irq, GFP_KERNEL))
82.  
    return -EIO;
83.  
     
84.  
    return 0;
85.  
    }
86.  
     
87.  
    /* 在客户端调用close()函数时会调用到 */
88.  
    static void usb_mouse_close(struct input_dev *dev)
89.  
    {
90.  
    struct usb_mouse *mouse = input_get_drvdata(dev);
91.  
     
92.  
    /* 取消urb */
93.  
    usb_kill_urb(mouse->irq);
94.  
    }
95.  
     
96.  
    /* 和插入usb设备的描述符信息匹配成功后调用 */
97.  
    static int usb_mouse_probe(struct usb_interface *intf, const struct usb_device_id *id)
98.  
    {
99.  
    struct usb_device *dev = interface_to_usbdev(intf);
100.  
     struct usb_host_interface *interface;
101.  
     struct usb_endpoint_descriptor *endpoint;
102.  
     struct usb_mouse *mouse;
103.  
     struct input_dev *input_dev;
104.  
     int pipe, maxp;
105.  
     int error = -ENOMEM;
106.  
      
107.  
     interface = intf->cur_altsetting;
108.  
      
109.  
     /* 检查端点数量，鼠标只有一个中断输入端点 */
110.  
     if (interface->desc.bNumEndpoints != 1)
111.  
     return -ENODEV;
112.  
      
113.  
     endpoint = &interface->endpoint[0].desc;
114.  
      
115.  
     /* 检查端点是否为中断输入端点 */
116.  
     if (!usb_endpoint_is_int_in(endpoint))
117.  
     return -ENODEV;
118.  
     /* 得到一个中断端点pipe */
119.  
     pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
120.  
      
121.  
     /* 获取消息缓冲区的最大值 */
122.  
     maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
123.  
      
124.  
     mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL);
125.  
     input_dev = input_allocate_device(); /* 申请一个input_dev */
126.  
     if (!mouse || !input_dev)
127.  
     goto fail1;
128.  
      
129.  
     /* 申请数据缓冲区 */
130.  
     mouse->data = usb_buffer_alloc(dev, 8, GFP_ATOMIC, &mouse->data_dma);
131.  
     if (!mouse->data)
132.  
     goto fail1;
133.  
      
134.  
     /* 申请urb */
135.  
     mouse->irq = usb_alloc_urb(0, GFP_KERNEL);
136.  
     if (!mouse->irq)
137.  
     goto fail2;
138.  
      
139.  
     mouse->usbdev = dev;
140.  
     mouse->dev = input_dev;
141.  
      
142.  
     if (dev->manufacturer)
143.  
     strlcpy(mouse->name, dev->manufacturer, sizeof(mouse->name));
144.  
      
145.  
     if (dev->product) {
146.  
     if (dev->manufacturer)
147.  
     strlcat(mouse->name, " ", sizeof(mouse->name));
148.  
     strlcat(mouse->name, dev->product, sizeof(mouse->name));
149.  
     }
150.  
      
151.  
     if (!strlen(mouse->name))
152.  
     snprintf(mouse->name, sizeof(mouse->name),
153.  
     "USB HIDBP Mouse x:x",
154.  
     le16_to_cpu(dev->descriptor.idVendor),
155.  
     le16_to_cpu(dev->descriptor.idProduct));
156.  
      
157.  
     usb_make_path(dev, mouse->phys, sizeof(mouse->phys));
158.  
     strlcat(mouse->phys, "/input0", sizeof(mouse->phys));
159.  
      
160.  
     input_dev->name = mouse->name;
161.  
     input_dev->phys = mouse->phys;
162.  
      
163.  
     /* 根据插入设备的信息初始化input_dev的id表用于匹配输入handler */
164.  
     usb_to_input_id(dev, &input_dev->id);
165.  
     input_dev->dev.parent = &intf->dev;
166.  
      
167.  
     /* 设置输入事件和各个事件值 */
168.  
     input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
169.  
     input_dev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE);
170.  
     input_dev->relbit[0] = BIT(REL_X) | BIT(REL_Y);
171.  
     input_dev->keybit[LONG(BTN_MOUSE)] |= BIT(BTN_SIDE) | BIT(BTN_EXTRA);
172.  
     input_dev->relbit[0] |= BIT(REL_WHEEL);
173.  
      
174.  
     /* 设置input_dev的私有数据 */
175.  
     input_set_drvdata(input_dev, mouse);
176.  
      
177.  
     input_dev->open = usb_mouse_open;
178.  
     input_dev->close = usb_mouse_close;
179.  
      
180.  
     /* 初始化urb */
181.  
     usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,
182.  
     (maxp > 8 ? 8 : maxp),
183.  
     usb_mouse_irq, mouse, endpoint->bInterval);
184.  
     mouse->irq->transfer_dma = mouse->data_dma;
185.  
     mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
186.  
      
187.  
     error = input_register_device(mouse->dev);
188.  
     if (error)
189.  
     goto fail3;
190.  
      
191.  
     /* 设置usb驱动的私有数据 */
192.  
     usb_set_intfdata(intf, mouse);
193.  
     return 0;
194.  
      
195.  
     fail3:
196.  
     usb_free_urb(mouse->irq);
197.  
     fail2:
198.  
     usb_buffer_free(dev, 8, mouse->data, mouse->data_dma);
199.  
     fail1:
200.  
     input_free_device(input_dev);
201.  
     kfree(mouse);
202.  
     return error;
203.  
     }
204.  
      
205.  
     /* usb设备拔出时调用，进行清理工作 */
206.  
     static void usb_mouse_disconnect(struct usb_interface *intf)
207.  
     {
208.  
     struct usb_mouse *mouse = usb_get_intfdata (intf);
209.  
      
210.  
     usb_set_intfdata(intf, NULL);
211.  
     if (mouse) {
212.  
     usb_kill_urb(mouse->irq);
213.  
     input_unregister_device(mouse->dev);
214.  
     usb_free_urb(mouse->irq);
215.  
     usb_buffer_free(interface_to_usbdev(intf), 8, mouse->data, mouse->data_dma);
216.  
     kfree(mouse);
217.  
     }
218.  
     }
219.  
      
220.  
     /* 定义一个id_table用于在usb设备插入时和插入设备的设备描述信息进行匹配 */
221.  
     static struct usb_device_id usb_mouse_id_table [] = {
222.  
     /* 将宏USB_INTERFACE_INFO()展开
223.  
     * .match_flags (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL),
224.  
     * .bInterfaceClass = USB_INTERFACE_CLASS_HID,
225.  
     * .bInterfaceSubClass = USB_INTERFACE_SUBCLASS_BOOT,
226.  
     * .bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE
227.  
     */
228.  
     { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
229.  
     USB_INTERFACE_PROTOCOL_MOUSE) },
230.  
     { } /* Terminating entry */
231.  
     };
232.  
      
233.  
     /* id_table的内容加入到外设队列并告知内核设备支持热插拔 */
234.  
     MODULE_DEVICE_TABLE (usb, usb_mouse_id_table);
235.  
      
236.  
     static struct usb_driver usb_mouse_driver = {
237.  
     .name = "usbmouse",
238.  
     .probe = usb_mouse_probe, /* usb设备插入时，id_table信息匹配成功则调用 */
239.  
     .disconnect = usb_mouse_disconnect, /* usb设备拔出时调用 */
240.  
     .id_table = usb_mouse_id_table, /* id_table,用于匹配设备描述符 */
241.  
     };
242.  
      
243.  
     static int __init usb_mouse_init(void)
244.  
     {
245.  
     int retval = usb_register(&usb_mouse_driver); /* 注册usb设备驱动，不申请设备号 */
246.  
     if (retval == 0)
247.  
     info(DRIVER_VERSION ":" DRIVER_DESC);
248.  
     return retval;
249.  
     }
250.  
      
251.  
     static void __exit usb_mouse_exit(void)
252.  
     {
253.  
     usb_deregister(&usb_mouse_driver); /* 卸载usb驱动 */
254.  
     }
255.  
      
256.  
     module_init(usb_mouse_init);
257.  
     module_exit(usb_mouse_exit);

恭喜获得知识点 1

若有讲解不妥之处烦请在评论区指正！

如果有收获那就一键三连鼓励一下吧！

这篇好文章是转载于：学新通技术网