Linux下的USB总线驱动(03)——USB鼠标驱动 usbmouse.c

USB鼠标驱动 usbmouse.c

原文链接：http://www.linuxidc.com/Linux/2012-12/76197p7.htm

 

drivers/hid/usbhid/usbmouse.c

下面我们分析下USB鼠标驱动，鼠标输入HID类型，其数据传输采用中断URB，鼠标端点类型为IN。我们先看看这个驱动的模块加载部分。

 

[cpp] view plaincopy
  1. static int __init usb_mouse_init(void)  
  2. {  
  3.     int retval = usb_register(&usb_mouse_driver);  
  4.     if (retval == 0)  
  5.         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"  
  6.                 DRIVER_DESC "\n");  
  7.     return retval;  
  8. }  

 

模块加载部分仍然是调用usb_register注册USB驱动，我们跟踪看看被注册的usb_mouse_driver

 

[cpp] view plaincopy
  1. static struct usb_driver usb_mouse_driver = {  
  2.     .name       = "usbmouse",           //驱动名  
  3.     .probe      = usb_mouse_probe,  
  4.     .disconnect = usb_mouse_disconnect,  
  5.     .id_table   = usb_mouse_id_table,   //支持项  
  6. };  

关于设备支持项我们前面已经讨论过了

 

 

[cpp] view plaincopy
  1. static struct usb_device_id usb_mouse_id_table [] = {  
  2.     { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,  
  3.         USB_INTERFACE_PROTOCOL_MOUSE) },  
  4.     { } /* Terminating entry */  
  5. };  
  6.   
  7. MODULE_DEVICE_TABLE (usb, usb_mouse_id_table);  

再细细看看USB_INTERFACE_INFO宏的定义

 

 

[cpp] view plaincopy
  1. /** 
  2.  * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces 
  3.  * @cl: bInterfaceClass value 
  4.  * @sc: bInterfaceSubClass value 
  5.  * @pr: bInterfaceProtocol value 
  6.  * 
  7.  * This macro is used to create a struct usb_device_id that matches a 
  8.  * specific class of interfaces. 
  9.  */  
  10. #define USB_INTERFACE_INFO(cl, sc, pr) \  
  11.     .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \  
  12.     .bInterfaceClass = (cl), \  
  13.     .bInterfaceSubClass = (sc), \  
  14.     .bInterfaceProtocol = (pr)  

 

根据宏，我们知道，我们设置的支持项包括接口类，接口子类，接口协议三个匹配项。

主要看看usb_driver中定义的probe函数

[cpp] view plaincopy
  1. static int usb_mouse_probe(struct usb_interface *intf, const struct usb_device_id *id)  
  2. {  
  3.     struct usb_device *dev = interface_to_usbdev(intf);//由接口获取usb_dev  
  4.     struct usb_host_interface *interface;  
  5.     struct usb_endpoint_descriptor *endpoint;  
  6.     struct usb_mouse *mouse;                           //该驱动私有结构体  
  7.     struct input_dev *input_dev;                       //输入结构体  
  8.     int pipe, maxp;  
  9.     int error = -ENOMEM;  
  10.   
  11.     interface = intf->cur_altsetting;                   //获取设置  
  12.   
  13.     if (interface->desc.bNumEndpoints != 1)             //鼠标端点只有1个  
  14.         return -ENODEV;  
  15.   
  16.     endpoint = &interface->endpoint[0].desc;            //获取端点描述符  
  17.     if (!usb_endpoint_is_int_in(endpoint))              //检查该端点是否是中断输入端点  
  18.         return -ENODEV;  
  19.   
  20.     pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);  //建立中断输入端点  
  21.     maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));      //端点能传输的最大数据包(Mouse为4个)  
  22.   
  23.     mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL);   //分配usb_mouse结构体  
  24.     input_dev = input_allocate_device();                     //分配input设备空间  
  25.     if (!mouse || !input_dev)  
  26.         goto fail1;  
  27.   
  28.     mouse->data = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &mouse->data_dma); //分配缓冲区  
  29.     if (!mouse->data)  
  30.         goto fail1;  
  31.   
  32.     mouse->irq = usb_alloc_urb(0, GFP_KERNEL);                              //分配urb  
  33.     if (!mouse->irq)  
  34.         goto fail2;  
  35.   
  36.     mouse->usbdev = dev;         //填充mouse的usb_device结构体  
  37.     mouse->dev = input_dev;      //填充mouse的input结构体  
  38.   
  39.     if (dev->manufacturer)       //复制厂商ID  
  40.         strlcpy(mouse->name, dev->manufacturer, sizeof(mouse->name));  
  41.   
  42.     if (dev->product) {          //复制产品ID  
  43.         if (dev->manufacturer)  
  44.             strlcat(mouse->name, " ", sizeof(mouse->name));  
  45.         strlcat(mouse->name, dev->product, sizeof(mouse->name));  
  46.     }  
  47.   
  48.     if (!strlen(mouse->name))  
  49.         snprintf(mouse->name, sizeof(mouse->name),  
  50.              "USB HIDBP Mouse %04x:%04x",  
  51.              le16_to_cpu(dev->descriptor.idVendor),  
  52.              le16_to_cpu(dev->descriptor.idProduct));  
  53.   
  54.     usb_make_path(dev, mouse->phys, sizeof(mouse->phys));  
  55.     strlcat(mouse->phys, "/input0", sizeof(mouse->phys)); //获取usb_mouse的设备节点  
  56.   
  57.     input_dev->name = mouse->name;                        //将鼠标名赋给内嵌input结构体  
  58.     input_dev->phys = mouse->phys;                        //将鼠标设备节点名赋给内嵌input结构体  
  59.     usb_to_input_id(dev, &input_dev->id);                 //将usb_driver的支持项拷贝给input  
  60.     input_dev->dev.parent = &intf->dev;  
  61.   
  62.     input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);     //支持按键事件和相对坐标事件  
  63.     input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |  
  64.         BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);            //表明按键值包括左键、中键和右键  
  65.     input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);      //表明相对坐标包括X坐标和Y坐标  
  66.     input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |  
  67.         BIT_MASK(BTN_EXTRA);                                   //表明除了左键、右键和中键，还支持其他按键  
  68.     input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);                   //表明还支持中键滚轮的滚动值  
  69.   
  70.     input_set_drvdata(input_dev, mouse);                           //将mouse设为input的私有数据  
  71.   
  72.     input_dev->open = usb_mouse_open;                              //input设备的open操作函数  
  73.     input_dev->close = usb_mouse_close;  
  74.   
  75.     usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,  
  76.              (maxp > 8 ? 8 : maxp),  
  77.              usb_mouse_irq, mouse, endpoint->bInterval);   //填充urb  
  78.     mouse->irq->transfer_dma = mouse->data_dma;  
  79.     mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;         //使用transfer_dma  
  80.   
  81.     error = input_register_device(mouse->dev);                     //注册input设备  
  82.     if (error)  
  83.         goto fail3;  
  84.   
  85.     usb_set_intfdata(intf, mouse);  
  86.     return 0;  
  87.   
  88. fail3:    
  89.     usb_free_urb(mouse->irq);  
  90. fail2:    
  91.     usb_free_coherent(dev, 8, mouse->data, mouse->data_dma);  
  92. fail1:    
  93.     input_free_device(input_dev);  
  94.     kfree(mouse);  
  95.     return error;  
  96. }  

在探讨probe实现的功能时，我们先看看urb填充函数usb_fill_int_urb

[cpp] view plaincopy
  1. /** 
  2.  * usb_fill_int_urb - macro to help initialize a interrupt urb 
  3.  * @urb: pointer to the urb to initialize. 
  4.  * @dev: pointer to the struct usb_device for this urb. 
  5.  * @pipe: the endpoint pipe 
  6.  * @transfer_buffer: pointer to the transfer buffer 
  7.  * @buffer_length: length of the transfer buffer 
  8.  * @complete_fn: pointer to the usb_complete_t function 
  9.  * @context: what to set the urb context to. 
  10.  * @interval: what to set the urb interval to, encoded like 
  11.  *  the endpoint descriptor's bInterval value. 
  12.  * 
  13.  * Initializes a interrupt urb with the proper information needed to submit 
  14.  * it to a device. 
  15.  * 
  16.  * Note that High Speed and SuperSpeed interrupt endpoints use a logarithmic 
  17.  * encoding of the endpoint interval, and express polling intervals in 
  18.  * microframes (eight per millisecond) rather than in frames (one per 
  19.  * millisecond). 
  20.  * 
  21.  * Wireless USB also uses the logarithmic encoding, but specifies it in units of 
  22.  * 128us instead of 125us.  For Wireless USB devices, the interval is passed 
  23.  * through to the host controller, rather than being translated into microframe 
  24.  * units. 
  25.  */  
  26. static inline void usb_fill_int_urb(struct urb *urb,  
  27.                     struct usb_device *dev,  
  28.                     unsigned int pipe,  
  29.                     void *transfer_buffer,  
  30.                     int buffer_length,  
  31.                     usb_complete_t complete_fn,  
  32.                     void *context,  
  33.                     int interval)  
  34. {  
  35.     urb->dev = dev;  
  36.     urb->pipe = pipe;  
  37.     urb->transfer_buffer = transfer_buffer;  
  38.     urb->transfer_buffer_length = buffer_length;  
  39.     urb->complete = complete_fn;  
  40.     urb->context = context;  
  41.     if (dev->speed == USB_SPEED_HIGH || dev->speed == USB_SPEED_SUPER)  
  42.         urb->interval = 1 << (interval - 1);  
  43.     else  
  44.         urb->interval = interval;  
  45.     urb->start_frame = -1;  
  46. }  

其实probe主要是初始化usb设备和input设备，终极目标是为了完成urb的提交和input设备的注册。由于注册为input设备类型，那么当用户层open打开设备时候，最终会调用input中的open实现打开，我们看看input中open的实现

 

[cpp] view plaincopy
  1. static int usb_mouse_open(struct input_dev *dev)  
  2. {  
  3.     struct usb_mouse *mouse = input_get_drvdata(dev);   //获取私有数据  
  4.   
  5.     mouse->irq->dev = mouse->usbdev;                    //获取utb指针  
  6.     if (usb_submit_urb(mouse->irq, GFP_KERNEL))         //提交urb  
  7.         return -EIO;  
  8.   
  9.     return 0;  
  10. }  

当用户层open打开这个USB鼠标后，我们就已经将urb提交给了USB core，那么根据USB数据处理流程知道，当处理完毕后，USB core会通知USB设备驱动程序，这里我们是响应中断服务程序，这就相当于该URB的回调函数。我们在提交urb时候定义了中断服务程序 usb_mouse_irq，我们跟踪看看

 

[cpp] view plaincopy
  1. static void usb_mouse_irq(struct urb *urb)  
  2. {  
  3.     struct usb_mouse *mouse = urb->context;  
  4.     signed char *data = mouse->data;  
  5.     struct input_dev *dev = mouse->dev;  
  6.     int status;  
  7.   
  8.     switch (urb->status) {  
  9.     case 0:         /* success */  
  10.         break;  
  11.     case -ECONNRESET:   /* unlink */  
  12.     case -ENOENT:  
  13.     case -ESHUTDOWN:  
  14.         return;  
  15.     /* -EPIPE:  should clear the halt */  
  16.     default:        /* error */  
  17.         goto resubmit;                             //数据处理没成功，重新提交urb  
  18.     }  
  19.   
  20.     input_report_key(dev, BTN_LEFT,   data[0] & 0x01); //左键  
  21.     input_report_key(dev, BTN_RIGHT,  data[0] & 0x02); //  
  22.     input_report_key(dev, BTN_MIDDLE, data[0] & 0x04); //  
  23.     input_report_key(dev, BTN_SIDE,   data[0] & 0x08); //  
  24.     input_report_key(dev, BTN_EXTRA,  data[0] & 0x10); //  
  25.   
  26.     input_report_rel(dev, REL_X,     data[1]);         //鼠标的水平位移  
  27.     input_report_rel(dev, REL_Y,     data[2]);         //鼠标的垂直位移  
  28.     input_report_rel(dev, REL_WHEEL, data[3]);         //鼠标滚轮的滚动值  
  29.   
  30.     input_sync(dev);                                   //同步事件，完成一次上报  
  31. resubmit:  
  32.     status = usb_submit_urb (urb, GFP_ATOMIC);         //再次提交urb，等待下次响应  
  33.     if (status)  
  34.         err ("can't resubmit intr, %s-%s/input0, status %d",  
  35.                 mouse->usbdev->bus->bus_name,  
  36.                 mouse->usbdev->devpath, status);  
  37. }  

 

根据上面的中断服务程序，我们应该知道，系统是周期性地获取鼠标的事件信息，因此在URB回调函数的末尾再次提交URB请求块，这样又会调用新的回调函数，周而复始。在回调函数中提交URB只能是GFP_ATOMIC优先级，因为URB回调函数运行于中断上下文中禁止导致睡眠的行为。而在提交URB 过程中可能会需要申请内存、保持信号量，这些操作或许会导致USB内核睡眠。

最后我们再看看这个驱动的私有数据mouse的定义

 

[cpp] view plaincopy
  1. struct usb_mouse {  
  2.     char name[128];             //名字  
  3.     char phys[64];              //设备节点  
  4.     struct usb_device *usbdev;  //内嵌usb_device设备  
  5.     struct input_dev *dev;      //内嵌input_dev设备  
  6.     struct urb *irq;            //urb结构体  
  7.   
  8.     signed char *data;          //transfer_buffer缓冲区  
  9.     dma_addr_t data_dma;        //transfer _dma缓冲区  
  10. };  

 

在上面这个结构体中，每一个成员的作用都应该很清楚了，尤其最后两个的使用区别和作用，前面也已经说过。

如果最终需要测试这个USB鼠标驱动，需要在内核中配置USB支持、对HID接口的支持、对OHCI HCD驱动的支持。另外，将驱动移植到开发板之后，由于采用的是input设备模型，所以还需要开发板带LCD屏才能测试。

posted on 2013-03-09 17:05  lightsalt2011  阅读(902)  评论(0)  编辑  收藏  举报

导航