Linux USB 驱动开发实例（二）—— USB 鼠标驱动注解及测试

参考2.6.14版本中的driver/usb/input/usbmouse.c。鼠标驱动可分为几个部分：驱动加载部分、probe部分、open部分、urb回调函数处理部分。 


一、驱动加载部分

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static int __init usb_mouse_init(void)  
  2. {     
  3.     int retval = usb_register(&usb_mouse_driver);//注册鼠标驱动   
  4.     if (retval == 0)  
  5.     info(DRIVER_VERSION ":" DRIVER_DESC);  
  6.     return retval;  
  7. }  
其中usb_mouse_driver的定义为：
[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static struct usb_driver usb_mouse_driver = {  
  2.     .owner = THIS_MODULE,  
  3.     .name = "usbmouse",  
  4.     .probe = usb_mouse_probe,  
  5.     .disconnect = usb_mouse_disconnect,  
  6.     .id_table = usb_mouse_id_table,  
  7. };  

 

      如果注册成功的话，将会调用usb_mouse_probe。那么什么时候才算注册成功呢？

      和其它驱动注册过程一样，只有在其对应的“总线”上发现匹配的“设备”才会调用probe。总线匹配的方法和具体总线相关，如：platform_bus_type中是判断驱动名称和平台设备名称是否相同；那如何确认usb总线的匹配方法呢？

       Usb设备是注册在usb_bus_type总线下的。查看usb_bus_type的匹配方法。

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. struct bus_type usb_bus_type = {  
  2.     .name = "usb",  
  3.     .match = usb_device_match,  
  4.         .hotplug = usb_hotplug,  
  5.     .suspend = usb_generic_suspend,  
  6.     .resume = usb_generic_resume,  
  7. };  
其中usb_device_match定义了匹配方法
[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static int usb_device_match (struct device *dev, struct device_driver *drv)  
  2. {  
  3.                     struct usb_interface *intf;  
  4.                     struct usb_driver *usb_drv;  
  5.                     const struct usb_device_id *id;  
  6.                     /* check for generic driver, which we don't match any device with */  
  7.                     if (drv == &usb_generic_driver)  
  8.                     return 0;  
  9.                     intf = to_usb_interface(dev);  
  10.                     usb_drv = to_usb_driver(drv);  
  11.                     id = usb_match_id (intf, usb_drv->id_table);  
  12.                     if (id)  
  13.                               return 1;  
  14.                     return 0;  
  15. }  

可以看出usb的匹配方法是usb_match_id (intf, usb_drv->id_table)，也就是说通过比对“dev中intf信息”和“usb_drv->id_table信息”，如果匹配则说明驱动所对应的设备已经添加到总线上了，所以接下了就会调用drv中的probe方法注册usb设备驱动。

usb_mouse_id_table的定义为：

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static struct usb_device_id usb_mouse_id_table[] = {  
  2.                     { USB_INTERFACE_INFO(3, 1, 2) },  
  3.                     { }                              /* Terminating entry */  
  4.           };  
  5.   
  6. #define USB_INTERFACE_INFO(cl,sc,pr) /  
  7.           .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, /  
  8.           .bInterfaceClass = (cl), /  
  9.           .bInterfaceSubClass = (sc), /  
  10.           .bInterfaceProtocol = (pr)  

鼠标设备遵循USB人机接口设备（HID），在HID规范中规定鼠标接口类码为：

接口类：0x03
接口子类：0x01
接口协议：0x02

这样分类的好处是设备厂商可以直接利用标准的驱动程序。除了HID类以外还有Mass storage、printer、audio等

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. #define USB_DEVICE_ID_MATCH_INT_INFO /  
  2.                     (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)  

匹配的过程为：

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. usb_match_id(struct usb_interface *interface, const struct usb_device_id *id)  
  2.           {  
  3.                     struct usb_host_interface *intf;  
  4.                     struct usb_device *dev;  
  5.   
  6.           /* proc_connectinfo in devio.c may call us with id == NULL. */  
  7.                     if (id == NULL)  
  8.                               return NULL;  
  9.   
  10.           intf = interface->cur_altsetting;  
  11.                   dev = interface_to_usbdev(interface);  
  12.   
  13.           /* It is important to check that id->driver_info is nonzero, 
  14.                     since an entry that is all zeroes except for a nonzero 
  15.                     id->driver_info is the way to create an entry that 
  16.                     indicates that the driver want to examine every 
  17.                     device and interface. */  
  18.                   for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass ||  
  19.                            id->driver_info; id++) {  
  20.   
  21.                     if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&  
  22.                                  id->idVendor != le16_to_cpu(dev->descriptor.idVendor))  
  23.                                  continue;  
  24.   
  25.                     if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&  
  26.                                  id->idProduct != le16_to_cpu(dev->descriptor.idProduct))  
  27.                                  continue;  
  28.   
  29.                    /* No need to test id->bcdDevice_lo != 0, since 0 is never greater than any unsigned number. */  
  30.                             if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&  
  31.                                 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))  
  32.                                continue;  
  33.   
  34.                     if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&  
  35.                                  (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))  
  36.                                  continue;  
  37.   
  38.                     if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&  
  39.                                  (id->bDeviceClass != dev->descriptor.bDeviceClass))  
  40.                                  continue;  
  41.   
  42.                     if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&  
  43.                                  (id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass))  
  44.                                  continue;  
  45.   
  46.                     if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&  
  47.                                  (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))  
  48.                                  continue;  
  49.   
  50.                     //接口类  
  51.   
  52.                     if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&  
  53.                                 (id->bInterfaceClass != intf->desc.bInterfaceClass))  
  54.                                 continue;  
  55.   
  56.                     //接口子类  
  57.   
  58.                     if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&  
  59.                                 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))  
  60.                                 continue;  
  61.   
  62.                   //遵循的协议  
  63.   
  64.                     if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&  
  65.                                 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))  
  66.                                 continue;  
  67.   
  68.                   return id;  
  69.                       }  
  70.                       return NULL;  
  71.            }  
从中可以看出，只有当设备的接口类、接口子类、接口协议匹配鼠标驱动时鼠标驱动才会调用probe方法。


二、probe部分

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  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);  
  4.          struct usb_host_interface *interface;  
  5.          struct usb_endpoint_descriptor *endpoint;  
  6.          struct usb_mouse *mouse;  
  7.          int pipe, maxp;  
  8.          char path[64];  
  9.   
  10.          interface = intf->cur_altsetting;  
  11.   
  12. /* 以下是网络的一段对cur_altsettin的解释，下面就借花献佛。usb 设备有一个configuration 的概念,表示配置，一个设备可以有多个配置，但只能同时激活一个，如：一些设备可以下载固件，或可以设置不同的全局模式，就像手机可以被设定为静音模式或响铃模式一样。而这里又有一个setting,咋一看有些奇怪,这两个词不是一回事吗.还是拿我们最熟悉的手机来打比方,configuration 不说了,setting,一个手机可能各种配置都确定了,是振动还是铃声已经确定了,各种功能都确定了,但是声音的大小还可以变吧,通常手机的音量是一格一格的变动,大概也就5,6 格,那么这个可以算一个setting 吧.这里cur_altsetting 就是表示的当前的这个setting,或者说设置。可以查看原码中usb_interface 结构定义的说明部分。从说明中可以看到一个接口可以有多种setting*/  
  13.   
  14.          if (interface->desc.bNumEndpoints != 1)  
  15.         return -ENODEV;  
  16.   
  17. /*根据HID规则，期望鼠标只有一个端点即中断端点bNumEndpoints 就是接口描述符中的成员,表示这个接口有多少个端点，不过这其中不包括0 号端点，0号端点是任何一个usb 设备都必须是提供的,这个端点专门用于进行控制传输,即它是一个控制端点.正因为如此,所以即使一个设备没有进行任何设置，usb 主机也可以开始跟它进行一些通信,因为即使不知道其它的端点，但至少知道它一定有一个0号端点，或者说一个控制端点。 
  18.          */  
  19.   
  20.          endpoint = &interface->endpoint[0].desc;//端点0描述符，此处的0表示中断端点   
  21.          if (!(endpoint->bEndpointAddress & 0x80))  
  22.         return -ENODEV;  
  23.   
  24. /*先看bEndpointAddress,这个struct usb_endpoint_descriptor 中的一个成员,是8个bit，或者说1 个byte，其中bit7 表示 *的是这个端点的方向，0 表示OUT，1 表示IN，OUT 与IN 是对主机而言。OUT 就是从主机到设备，IN 就是从设备到主机。而宏  
  25.  *USB_DIR_IN 来自 
  26.  *include/linux/usb_ch9.h 
  27.  * USB directions 
  28.  * This bit flag is used in endpoint descriptors' bEndpointAddress field. 
  29.  * It's also one of three fields in control requests bRequestType. 
  30.  *#define USB_DIR_OUT 0 /* to device */  
  31.  *#define USB_DIR_IN 0x80 /* to host */   
  32.  */  
  33.   
  34.     if ((endpoint->bmAttributes & 3) != 3)? //判断是否是中断类型   
  35.         return -ENODEV;  
  36.   
  37. /* bmAttributes 表示属性,总共8位,其中bit1和bit0 共同称为Transfer Type,即传输类型,即00 表示控制,01 表示等时,10 表示批量,11 表示中断*/  
  38.   
  39.     pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);//构造中断端点的输入pipe  
  40.   
  41.     maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));  
  42.   
  43. /*跟踪usb_maxpacket 
  44.     usb_maxpacket(struct usb_device *udev, int pipe, int is_out) 
  45.     { 
  46.         struct usb_host_endpoint         *ep; 
  47.         unsigned                  epnum = usb_pipeendpoint(pipe); 
  48.         /* 
  49.                   得到的自然就是原来pipe 里边的15 至18 位.一个pipe 的15 位至18 位是endpoint 号,(一共16 个endpoint,)所以很显然,这里就是得到endpoint 号  
  50.                   */  
  51.         if (is_out) {  
  52.             WARN_ON(usb_pipein(pipe));  
  53.             ep = udev->ep_out[epnum];  
  54.         } else {  
  55.             WARN_ON(usb_pipeout(pipe));  
  56.             ep = udev->ep_in[epnum];  
  57.         }  
  58.         if (!ep)  
  59.             return 0;  
  60.                   /* NOTE:? only 0x07ff bits are for packet size... */  
  61.             return le16_to_cpu(ep->desc.wMaxPacketSize);  
  62.          }  
  63.          */  
  64.          //返回对应端点能够传输的最大的数据包，鼠标的返回的最大数据包为4个字节，   
  65.          第0个字节：bit 0、1、2、3、4分别代表左、右、中、SIDE、EXTRA键的按下情况   
  66.          第1个字节：表示鼠标的水平位移   
  67.          第2个字节：表示鼠标的垂直位移   
  68.          第3个字节：REL_WHEEL位移  
  69.   
  70.     if (!(mouse = kmalloc(sizeof(struct usb_mouse), GFP_KERNEL)))  
  71.         return -ENOMEM;  
  72.     memset(mouse, 0, sizeof(struct usb_mouse));  
  73.     mouse->data = usb_buffer_alloc(dev, 8, SLAB_ATOMIC, &mouse->data_dma);  
  74.   
  75.     /* 
  76.          申请用于urb用于数据传输的内存，注意：这里将返回“mouse->data”和“mouse->data_dma”  
  77.          mouse->data：记录了用于普通传输用的内存指针  
  78.          mouse->data_dma：记录了用于DMA传输的内存指针  
  79.          如果是DMA 方式的传输，那么usb core 就应该使用mouse->data_dma 
  80.          */  
  81.   
  82.     if (!mouse->data) {  
  83.         kfree(mouse);  
  84.         return -ENOMEM;  
  85.          }  
  86.          mouse->irq = usb_alloc_urb(0, GFP_KERNEL);  
  87.          if (!mouse->irq) {  
  88.         usb_buffer_free(dev, 8, mouse->data, mouse->data_dma);  
  89.         kfree(mouse);  
  90.         return -ENODEV;  
  91.          }  
  92.          mouse->usbdev = dev;  
  93.          mouse->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);  
  94.   
  95.     //设置input系统响应按键和REL（相对结果）事件  
  96.   
  97.     mouse->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE);  
  98.     mouse->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y);  
  99.     mouse->dev.keybit[LONG(BTN_MOUSE)] |= BIT(BTN_SIDE) | BIT(BTN_EXTRA);  
  100.     mouse->dev.relbit[0] |= BIT(REL_WHEEL);  
  101.   
  102.     //设置input系统响应的码表及rel表  
  103.   
  104.     mouse->dev.private = mouse;  
  105.     mouse->dev.open = usb_mouse_open;  
  106.     mouse->dev.close = usb_mouse_close;  
  107.   
  108.     usb_make_path(dev, path, 64);  
  109.     sprintf(mouse->phys, "%s/input0", path);  
  110.   
  111.     mouse->dev.name = mouse->name;  
  112.     mouse->dev.phys = mouse->phys;  
  113.     usb_to_input_id(dev, &mouse->dev.id);  
  114.   
  115. /* 
  116.     usb_to_input_id(const struct usb_device *dev, struct input_id *id) 
  117.     { 
  118.                   id->bustype = BUS_USB; 
  119.                   id->vendor = le16_to_cpu(dev->descriptor.idVendor); 
  120.                   id->product = le16_to_cpu(dev->descriptor.idProduct); 
  121.                   id->version = le16_to_cpu(dev->descriptor.bcdDevice); 
  122.          } 
  123.  
  124. struct usb_device 中有一个成员struct usb_device_descriptor,而struct usb_device_descriptor 中的成员__u16 bcdDevice,表示的是制造商指定的产品的版本号,制造商id 和产品id 来标志一个设备.bcdDevice 一共16 位,是以bcd码的方式保存的信息,也就是说,每4 位代表一个十进制的数,比如0011 0110 1001 0111 就代表的3697. 
  125.  
  126. 业内为每家公司编一个号,这样便于管理,比如三星的编号就是0x0839,那么三星的产品中就会在其设备描述符中idVendor 的烙上0x0839.而三星自己的每种产品也会有个编号,和Digimax 410 对应的编号就是0x000a,而bcdDevice_lo 和bcdDevice_hi 共同组成一个具体设备的编号(device release 
  127. number),bcd 就意味着这个编号是二进制的格式. 
  128.          */  
  129.   
  130.     mouse->dev.dev = &intf->dev;  
  131.   
  132.     if (dev->manufacturer)  
  133.         strcat(mouse->name, dev->manufacturer);  
  134.     if (dev->product)  
  135.         sprintf(mouse->name, "%s %s", mouse->name, dev->product);  
  136.   
  137.     if (!strlen(mouse->name))  
  138.         sprintf(mouse->name, "USB HIDBP Mouse %04x:%04x",  
  139.                            mouse->dev.id.vendor, mouse->dev.id.product);  
  140.   
  141.     usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,  
  142.                                     (maxp > 8 ? 8 : maxp),  
  143.                                     usb_mouse_irq, mouse, endpoint->bInterval);  
  144.   
  145. /* 
  146.          static inline void usb_fill_int_urb (struct urb *urb, 
  147.                                         struct usb_device *dev, 
  148.                                         unsigned int pipe, 
  149.                                         void *transfer_buffer, 
  150.                                         int buffer_length, 
  151.                                         usb_complete_t complete, 
  152.                                         void *context, 
  153.                                         int interval) 
  154.          { 
  155.                   spin_lock_init(&urb->lock); 
  156.                   urb->dev = dev; 
  157.                   urb->pipe = pipe; 
  158.                   urb->transfer_buffer = transfer_buffer;//如果不使用DMA传输方式，则使用这个缓冲指针。如何用DMA则使用transfer_DMA，这个值会在后面单独给URB赋 
  159.  
  160.          urb->transfer_buffer_length = buffer_length; 
  161.                   urb->complete = complete; 
  162.                   urb->context = context; 
  163.                   if (dev->speed == USB_SPEED_HIGH) 
  164.                            urb->interval = 1 << (interval - 1); 
  165.                   else 
  166.                            urb->interval = interval; 
  167.                   urb->start_frame = -1; 
  168.  
  169.     } 
  170.  
  171.     此处只是构建好一个urb，在open方法中会实现向usb core递交urb 
  172.          */  
  173.   
  174.     mouse->irq->transfer_dma = mouse->data_dma;  
  175.     mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;  
  176.   
  177. /* 
  178.          #define URB_NO_TRANSFER_DMA_MAP 0x0004? //urb->transfer_dma valid on submit  
  179.          #define URB_NO_SETUP_DMA_MAP??? 0x0008? //urb->setup_dma valid on submit  
  180. ,         这里是两个DMA 相关的flag,一个是URB_NO_SETUP_DMA_MAP,而另一个是  
  181.          URB_NO_TRANSFER_DMA_MAP.注意这两个是不一样的,前一个是专门为控制传输准备的,因为只有控制传输需要有这么一个setup 阶段需要准备一个setup packet。  
  182.          transfer_buffer 是给各种传输方式中真正用来数据传输的,而setup_packet 仅仅是在控制传输中发送setup 的包,控制传输除了setup 阶段之外,也会有数据传输阶段,这一阶段要传输数据还是得靠transfer_buffer,而如果使用dma 方式,那么就是使用transfer_dma. 
  183.          因为这里使用了mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP,所以应该给urb的transfer_dma赋值。所以用了： 
  184.          mouse->irq->transfer_dma = mouse->data_dma; 
  185.          */  
  186.   
  187.     input_register_device(&mouse->dev);  
  188.   
  189.     //向input系统注册input设备  
  190.   
  191.     printk(KERN_INFO "input: %s on %s/n", mouse->name, path);  
  192.   
  193.     usb_set_intfdata(intf, mouse);  
  194.   
  195. /* 
  196.     usb_set_intfdata().的结果就是使得  
  197.          %intf->dev->driver_data= mouse,而其它函数中会调用usb_get_intfdata(intf)的作用就是把mouse从中取出来 
  198.          */  
  199.   
  200.     return 0;  
  201. }  



三、open部分

当应用层打开鼠标设备时，usb_mouse_open将被调用

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static int usb_mouse_open(struct input_dev *dev)  
  2. {  
  3.          struct usb_mouse *mouse = dev->private;  
  4.   
  5.          mouse->irq->dev = mouse->usbdev;  
  6.          if (usb_submit_urb(mouse->irq, GFP_KERNEL))  
  7.                   return -EIO;  
  8.   
  9. //向usb core递交了在probe中构建好的中断urb，注意：此处是成功递交给usb core以后就返回，而不是等到从设备取得鼠标数据。  
  10.   
  11.          return 0;  
  12. }  


四、urb回调函数处理部分

当出现传输错误或获取到鼠标数据后，urb回调函数将被执行 

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static void usb_mouse_irq(struct urb *urb, struct pt_regs *regs)  
  2. {  
  3.          struct usb_mouse *mouse = urb->context;  
  4.   
  5. //在usb_fill_int_urb中有对urb->context赋值  
  6.   
  7.          signed char *data = mouse->data;  
  8.          struct input_dev *dev = &mouse->dev;  
  9.          int status;  
  10.          switch (urb->status) {  
  11.          case 0:                  /* success */  
  12.                   break;  
  13.          case -ECONNRESET:         /* unlink */  
  14.          case -ENOENT:  
  15.          case -ESHUTDOWN:  
  16.                   return;  
  17.          /* -EPIPE:? should clear the halt */  
  18.          default:         /* error */  
  19.                   goto resubmit;  
  20. }  
  21.   
  22. input_regs(dev, regs);  
  23.   
  24. input_report_key(dev, BTN_LEFT,         data[0] & 0x01);  
  25.          input_report_key(dev, BTN_RIGHT,         data[0] & 0x02);  
  26.          input_report_key(dev, BTN_MIDDLE,      data[0] & 0x04);  
  27.          input_report_key(dev, BTN_SIDE,         data[0] & 0x08);  
  28.          input_report_key(dev, BTN_EXTRA,         data[0] & 0x10);  
  29.          //向input系统报告key事件，分别是鼠标LEFT、RIGHT、MIDDLE、SIDE、EXTRA键,  
  30.          static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)中的value非0时表示按下，0表示释放   
  31.          input_report_rel(dev, REL_X,         data[1]);  
  32.          input_report_rel(dev, REL_Y,         data[2]);  
  33.          input_report_rel(dev, REL_WHEEL, data[3]);  
  34.          //向input系统报告rel事件，分别是x方向位移、y方向位移、wheel值   
  35.          input_sync(dev);  
  36.          //最后需要向事件接受者发送一个完整的报告。这是input系统的要求。   
  37.          resubmit:  
  38.          status = usb_submit_urb (urb, SLAB_ATOMIC);  
  39.          //重新递交urb  
  40.          if (status)  
  41.                   err ("can't resubmit intr, %s-%s/input0, status %d",  
  42.                            mouse->usbdev->bus->bus_name,  
  43.                            mouse->usbdev->devpath, status);  
  44. }  


五、应用层测试代码编写

在应用层编写测试鼠标的测试程序，在我的系统中，鼠标设备为/dev/input/event3. 测试代码如下：

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. /* 
  2.  * usb_mouse_test.c 
  3.  * by lht 
  4.  */  
  5.   
  6. #include <stdio.h>  
  7. #include <sys/types.h>  
  8. #include <unistd.h>  
  9. #include <fcntl.h>  
  10. #include <linux/input.h>  
  11.   
  12. int main (void)   
  13. {  
  14.     int fd,i,count;  
  15.     struct input_event ev_mouse[2];  
  16.     fd = open ("/dev/input/event3",O_RDWR);  
  17.     if (fd < 0) {  
  18.         printf ("fd open failed/n");  
  19.         exit(0);  
  20.     }  
  21.     printf ("/nmouse opened, fd=%d/n",fd);  
  22.     while(1)  
  23.     {  
  24.         printf(".............................................../n");  
  25.         count=read(fd, ev_mouse, sizeof(struct input_event));  
  26.         for(i=0;i<(int)count/sizeof(struct input_event);i++)  
  27.         {  
  28.             printf("type=%d/n",ev_mouse[i].type);  
  29.             if(EV_REL==ev_mouse[i].type)  
  30.             {  
  31.                 printf("time:%ld.%d",ev_mouse[i].time.tv_sec,ev_mouse[i].time.tv_usec);  
  32.                 printf(" type:%d code:%d value:%d/n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);  
  33.             }  
  34.             if(EV_KEY==ev_mouse[i].type)  
  35.             {  
  36.                 printf("time:%ld.%d",ev_mouse[i].time.tv_sec,ev_mouse[i].time.tv_usec);  
  37.                 printf(" type:%d code:%d value:%d/n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);  
  38.             }  
  39.         }  
  40.     }  
  41.     close (fd);  
  42.     return 0;  
  43. }  

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/401925.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

MySQL5.6 更改字段属性仍旧会锁全表，注意这个坑！

MySQL5.6 更改字段属性仍旧会锁全表，注意这个坑！

如图&#xff1a;如果开发让修改表字段属性&#xff0c;建议用pt-online-schema-change。MySQL5.6的在线DDL会锁全表。注意这个坑。另外&#xff0c;增加、删除字段或索引不会锁全表&#xff0c;删除主键会锁全表。
阅读更多...
Linux USB 驱动开发实例 （三）—— 基于USB总线的无线网卡浅析

Linux USB 驱动开发实例 （三）—— 基于USB总线的无线网卡浅析

回顾一下USB的相关知识 USB(Universal Serial Bus)总线又叫通用串行外部总线&#xff0c;它是20世纪90年代发展起来的。USB接口现在得到了广泛的应用和普及&#xff0c;现在的PC机中都带有大量的USB接口。它最大的特点就是方便通用、支持热插拔并且可以在一个接口上插上多个设备…
阅读更多...
Linux 设备驱动开发思想 —— 驱动分层与驱动分离

Linux 设备驱动开发思想 —— 驱动分层与驱动分离

前面我们学习I2C、USB、SD驱动时&#xff0c;有没有发现一个共性&#xff0c;就是在驱动开发时&#xff0c;每个驱动都分层三部分&#xff0c;由上到下分别是&#xff1a; 1、XXX 设备驱动 2、XXX 核心层 3、XXX 主机控制器驱动 而需要我们编写的主要是设备驱动部分&#xff0c…
阅读更多...
CortexM0开发 —— UART时序分析

CortexM0开发 —— UART时序分析

通用异步收发传输器(UniversalAsynchronousReceiver/Transmitter)&#xff0c;通常称作UART&#xff0c;是一种异步收发传输器。将数据由串行通信与并行通信间作传输转换&#xff0c;作为并行输入成为串行输出的芯片UART是一种通用串行数据总线&#xff0c;用于异步通信。该总线…
阅读更多...
CortexM0开发 —— LPC11C14的UART使用方法

CortexM0开发 —— LPC11C14的UART使用方法

LPC1100系列微控制器UART LPC1100系列Cortex-M0微控制器具有一个符合16C550工业标准的异步串行口&#xff08;UART&#xff09;。此口同时增加了调制解调器&#xff08;Modem&#xff09;接口&#xff0c;DSR、DCD和RI Modem信号是只用于LQFP48和PLCC44封装的管脚配置。 特性…
阅读更多...
Linux SD卡驱动开发(一) —— SD 相关基础概念

Linux SD卡驱动开发(一) —— SD 相关基础概念

一.SD/MMC卡基础概念 1.1.什么是MMC卡 MMC&#xff1a;MMC就是MultiMediaCard的缩写&#xff0c;即多媒体卡。它是一种非易失性存储器件&#xff0c;体积小巧(24mm*32mm*1.4mm)&#xff0c;容量大,耗电量低,传输速度快&#xff0c;广泛应用于消费类电子产品中。 1.2.什么是SD卡…
阅读更多...
Linux SD卡驱动开发(二) —— SD 卡驱动分析HOST篇

Linux SD卡驱动开发(二) —— SD 卡驱动分析HOST篇

回顾一下前面的知识&#xff0c;MMC 子系统范围三个部分&#xff1a; HOST 部分是针对不同主机的驱动程序&#xff0c;这一部是驱动程序工程师需要根据自己的特点平台来完成的。 CORE 部分: 这是整个MMC 的核心存&#xff0c;这部分完成了不同协议和规范的实现&#xff0c;并为…
阅读更多...
MVC应用程序显示RealPlayer(rm)视频

MVC应用程序显示RealPlayer(rm)视频

本篇博文是演示MVC应用程序显示RealPlayer视频。 客户端能观看到RealPlayer视频&#xff0c;前提条件是需要安装RealPlayer客户端&#xff0c;就是想看Falsh或理WMV视频一样&#xff0c;均要安装客户端或相关插件等。 Insus.NET实现方法&#xff0c;还是在控制器中Render RealP…
阅读更多...
Linux从入门到精通系列之PPTP

Linux从入门到精通系列之PPTP

Linux从入门到精通系列之PPTP今天我们来说下怎么在linux环境下如何搭建PPTP-&#xff0c;PPTP&#xff08;Point to Point Tunneling Protocol&#xff09;&#xff0c;即点对点隧道协议。该协议是在PPP协议的基础上开发的一种新的增强型安全协议&#xff0c;支持多协议虚拟专用…
阅读更多...
Linux SD卡驱动开发(三) —— SD 卡驱动分析CORE篇

Linux SD卡驱动开发(三) —— SD 卡驱动分析CORE篇

废话不多说&#xff0c;直接切进主题&#xff1a; Linux在内核源码的drivers/mmc/core文件夹下为我们的提供了一系列SD卡的接口服务函数。可以查看Makefile如下 可见&#xff0c;core文件夹下有针对总线的服务bus.c&#xff0c;针对主控制器的服务host.c&#xff0c;针对SD卡的…
阅读更多...
Python数值计算:一 使用Pylab绘图(1)

Python数值计算:一 使用Pylab绘图(1)

Pylab的使用 学习使用Python进行科学计算&#xff0c;然而很难找到简单实用&#xff0c;又循序渐进的例子。正好手边有一本《Matlab可视化大学物理学》&#xff0c;里面的例子非常清晰地解释了Matlab在物理学中的应用。重新使用Python实现这些例子&#xff0c;学习了Python&…
阅读更多...
Linux SD卡驱动开发(四) —— SD 控制器之真正的硬件操作

Linux SD卡驱动开发(四) —— SD 控制器之真正的硬件操作

前面对SD卡控制器有了一个基本的介绍。其实SD控制器层更过的意义是为core层提供一种操作SD卡硬件的一种方法&#xff0c;当然不同的控制器对硬件控制的方法不尽相同&#xff0c;但是他们最终都能像core层提交一个统一的封装有操作方法的数据结构&#xff0c;那便是即将闪亮登场…
阅读更多...
Linux SD卡驱动开发(五) —— SD 卡驱动分析Core补充篇

Linux SD卡驱动开发(五) —— SD 卡驱动分析Core补充篇

Core层中有两个重要函数 mmc_alloc_host 用于构造host&#xff0c;前面已经学习过&#xff0c;这里不再阐述&#xff1b;另一个就是 mmc_add_host,用于注册host 前面探测函数s3cmci_probe&#xff0c;现在就来回顾一下这个函数的作用。先简要的概括一下这个函数的功能&#xff…
阅读更多...
navicat连接oracle 报 ORA-12737 set CHS16GBK

navicat连接oracle 报 ORA-12737 set CHS16GBK

2019独角兽企业重金招聘Python工程师标准>>> 1首 先&#xff0c;我们打开“工具”-->"选项"菜单&#xff0c;见到如下界面&#xff0c;依据OCI library(oci.dll) 路径&#xff0c;导航到 navicat oci 目录下&#xff0c;备份里面的文件&#xff08;通过…
阅读更多...
Linux SD卡驱动开发(六) —— SD卡启动过程总体分析

Linux SD卡驱动开发(六) —— SD卡启动过程总体分析

一、工作流程 mmc驱动主要文件包括 drivers/mmc/card/block.c drivers/mmc/card/queue.c drivers/mmc/core/core.c drivers/mmc/core/host.c drivers/mmc/core/ 内核启动时&#xff0c;首先执行core/core.c的mmc_init&#xff0c;注册mmc、sd总线&#xff0c;以及一个host clas…
阅读更多...
svn怎么上传文件 — 百度经验无耻推广

svn怎么上传文件 — 百度经验无耻推广

2019独角兽企业重金招聘Python工程师标准>>> svn怎么上传文件 — 欢乐地点进去捧场 PS&#xff1a;觉得笔者太无耻&#xff0c;直接在下方评论抨击 转载于:https://my.oschina.net/cenqingbo/blog/212284
阅读更多...
apache 重写和虚拟目录配置

apache 重写和虚拟目录配置

要求&#xff1a;假如我请求一个地址&#xff1a;www.lxy.com/news-sport-id123.html转成&#xff1a;www.lxy.com/show.php?catenews&classsport&id123步骤&#xff1a;①首先我们需要在apache中启用rewrite模块打开apache的httpd.conf文件&#xff0c;找到#LoadModu…
阅读更多...
JavaScript代码片段

JavaScript代码片段

简介&#xff1a;本文收集了我常用的JavaScript代码片段&#xff0c;欢迎提意见&#xff01; 大灰狼边敲门边说&#xff1a;“小兔子乖乖&#xff0c;把门儿开开&#xff01;” 小兔子听到后&#xff0c;连忙去开门&#xff1a;“来喽&#xff01;” 兔妈妈对小兔子喊道&#x…
阅读更多...
路由器开发（一）—— 路由器硬件结构及软件体系

路由器开发（一）—— 路由器硬件结构及软件体系

一、路由器的硬件构成 路由器主要由以下几个部分组成&#xff1a;输入/输出接口部分、包转发或交换结构部分&#xff08;switching fabric&#xff09;、路由计算或处理部分。如图所示 图1 路由器的基本组成 输入端口是物理链路和输入包的进口处。端口通常由线卡提供&#…
阅读更多...
路由器开发（二）—— 路由器工作原理

路由器开发（二）—— 路由器工作原理

当信息需要在两个网络之间传输时&#xff0c;常用路由器这种互连设备来负责数据的传输。路由器的主要工作是&#xff1a;路径的决定和数据包的转发&#xff08;从路由器一个接口输入&#xff0c;然后选择合适接口输出&#xff09;&#xff1b;维护路由表。 路由器工作的方式非常…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023