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

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

一、驱动加载部分

[cpp] view
plain copy

  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
plain copy

  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
plain copy

  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
plain copy

  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
plain copy

  1. static struct usb_device_id usb_mouse_id_table[] = {
  2. { USB_INTERFACE_INFO(3, 1, 2) },
  3. { }                              /* Terminating entry */
  4. };
  5. #define USB_INTERFACE_INFO(cl,sc,pr) /
  6. .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, /
  7. .bInterfaceClass = (cl), /
  8. .bInterfaceSubClass = (sc), /
  9. .bInterfaceProtocol = (pr)

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

接口类：0x03

接口子类：0x01

接口协议：0x02

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

[cpp] view
plain copy

  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
plain copy

  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. /* proc_connectinfo in devio.c may call us with id == NULL. */
  6. if (id == NULL)
  7. return NULL;
  8. intf = interface->cur_altsetting;
  9. dev = interface_to_usbdev(interface);
  10. /* It is important to check that id->driver_info is nonzero,
  11. since an entry that is all zeroes except for a nonzero
  12. id->driver_info is the way to create an entry that
  13. indicates that the driver want to examine every
  14. device and interface. */
  15. for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass ||
  16. id->driver_info; id++) {
  17. if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
  18. id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
  19. continue;
  20. if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
  21. id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
  22. continue;
  23. /* No need to test id->bcdDevice_lo != 0, since 0 is never greater than any unsigned number. */
  24. if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
  25. (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
  26. continue;
  27. if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
  28. (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
  29. continue;
  30. if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
  31. (id->bDeviceClass != dev->descriptor.bDeviceClass))
  32. continue;
  33. if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
  34. (id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass))
  35. continue;
  36. if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
  37. (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
  38. continue;
  39. //接口类
  40. if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
  41. (id->bInterfaceClass != intf->desc.bInterfaceClass))
  42. continue;
  43. //接口子类
  44. if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
  45. (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
  46. continue;
  47. //遵循的协议
  48. if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
  49. (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
  50. continue;
  51. return id;
  52. }
  53. return NULL;
  54. }

从中可以看出，只有当设备的接口类、接口子类、接口协议匹配鼠标驱动时鼠标驱动才会调用probe方法。

二、probe部分

[cpp] view
plain copy

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

三、open部分

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

[cpp] view
plain copy

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

四、urb回调函数处理部分

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

[cpp] view
plain copy

  1. static void usb_mouse_irq(struct urb *urb, struct pt_regs *regs)
  2. {
  3. struct usb_mouse *mouse = urb->context;
  4. //在usb_fill_int_urb中有对urb->context赋值
  5. signed char *data = mouse->data;
  6. struct input_dev *dev = &mouse->dev;
  7. int status;
  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;
  18. }
  19. input_regs(dev, regs);
  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. //向input系统报告key事件，分别是鼠标LEFT、RIGHT、MIDDLE、SIDE、EXTRA键,
  26. static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)中的value非0时表示按下，0表示释放
  27. input_report_rel(dev, REL_X,         data[1]);
  28. input_report_rel(dev, REL_Y,         data[2]);
  29. input_report_rel(dev, REL_WHEEL, data[3]);
  30. //向input系统报告rel事件，分别是x方向位移、y方向位移、wheel值
  31. input_sync(dev);
  32. //最后需要向事件接受者发送一个完整的报告。这是input系统的要求。
  33. resubmit:
  34. status = usb_submit_urb (urb, SLAB_ATOMIC);
  35. //重新递交urb
  36. if (status)
  37. err ("can‘t resubmit intr, %s-%s/input0, status %d",
  38. mouse->usbdev->bus->bus_name,
  39. mouse->usbdev->devpath, status);
  40. }

五、应用层测试代码编写

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

[cpp] view
plain copy

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

Linux USB 驱动开发实例（二）—— USB 鼠标驱动注解及测试的相关文章

Exynos4412 IIC总线驱动开发（二）—— IIC 驱动开发

前面在Exynos4412 IIC总线驱动开发(一)-- IIC 基础概念及驱动架构分析 中学习了IIC驱动的架构,下面进入我们的驱动开发过程 首先看一张代码层次图,有助于我们的理解 上面这些代码的展示是告诉我们:linux内核和芯片提供商为我们的的驱动程序提供了 i2c驱动的框架,以及框架底层与硬件相关的代码的实现.  剩下的就是针对挂载在i2c两线上的i2c设备了device,而编写的即具体设备驱动了,这里的设备就是硬件接口外挂载的设备,而非硬件接口本身(soc硬件接口本身的驱动可以理解为总

Windows驱动开发（二）

本节主要介绍驱动开发的一些基础知识. 1. 驱动程序的基本组成 1.1. 最经常见到的数据结构 a. DRIVER_OBJECT驱动对象 [cpp] view plaincopy // WDK中对驱动对象的定义 // 每个驱动程序都会有一个唯一的驱动对象与之对应 // 它是在驱动加载时被内核对象管理程序创建的 typedef struct _DRIVER_OBJECT { CSHORT Type; CSHORT Size; // // The following links all of the

Spring注解驱动开发（二）--组件注入

一.前言 上一篇我们搭建了一个简单的Spring项目,并简单的使用了 组件注册.这一篇中,我们来详细的讲解组件注入. 二.组件注入 1. @ComponentScan 在上一篇中,我们使用了@Configuration和@Bean实现了组件注入.但是如果需要注入的组件很多的情况下,每个组件都需要通过一个@Bean注解进行注入,这样就会很麻烦.所以Spring提供了@ComponentScan注解. @ComponentScan可以指定需要扫描的包,在这些包下,@Component注解标注的组件都

arm-linux字符设备驱动开发之---简单字符设备驱动

一.linux系统将设备分为3类:字符设备.块设备.网络设备.使用驱动程序: 1.字符设备:是指只能一个字节一个字节读写的设备,不能随机读取设备内存中的某一数据,读取数据需要按照先后数据.字符设备是面向流的设备,常见的字符设备有鼠标.键盘.串口.控制台和LED设备等.2.块设备:是指可以从设备的任意位置读取一定长度数据的设备.块设备包括硬盘.磁盘.U盘和SD卡等. 每一个字符设备或块设备都在/dev目录下对应一个设备文件.linux用户程序通过设备文件(或称设备节点)来使用驱动程序操作字符设备和

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

回顾一下USB的相关知识   USB(Universal Serial Bus)总线又叫通用串行外部总线,它是20世纪90年代发展起来的.USB接口现在得到了广泛的应用和普及,现在的PC机中都带有大量的USB接口.它最大的特点就是方便通用.支持热插拔并且可以在一个接口上插上多个设备.当设备用电量小的时候,它还可以充当电源.它的众多优点使得它得到了广泛的应用. 在PC机器内部有个USB中央控制器,这个中央控制器负责管理插到USB接口上的设备.当主机要向设备发送或接受数据时,都是向USB中央控制器发

USB设备驱动开发之远程访问USB设备（二 USB设备虚拟端）

By Fanxiushu 2016-05-22 转载或引用请注明原始作者 接上文, 在处理好USB数据采集端的问题之后,接下来进入核心的部分,虚拟USB设备端的开发工作. 上文简单介绍过,需要开发虚拟总线驱动来模拟USB设备. 所谓虚拟总线驱动,就是安装于System系统设备下的一个驱动,由PnP管理器创建出一个虚拟的总线PDO设备, 我们的虚拟总线驱动Attach到这个PDO上,形成一个FDO功能设备驱动, 然后在我们的驱动中,根据需要创建出若干个 Child PDO设备, 这些 Child

USB设备驱动开发之远程访问USB设备（一）

By Fanxiushu 2016 05-15  转载或引用本文,请注明原始作者. 使用过vmware的人都应该知道,vmware虚拟机有这样的一个功能, 当在宿主机上插入一个USB设备的时候,通过设置,可以在vmware的虚拟机系统里边能访问到这个USB设备, 而且访问这个USB设备,就跟真的把这个USB设备插入到这个虚拟系统中一样,跟真实的几乎没任何区别. 再看一种情况,假设有两台机器C和S,C 机器是你正在使用的机器, S机器在远端,你只能通过远程控制S. S机器的配置和功能都很强大,大部

Linux驱动开发（二）—DMA的使用（一）

1 DMA概念 DMA顾名思义就是指设备和内存之间.内存和外部存储设备之间进行直接的数据读写操作,而不需要CPU的参与. 2 DMA原理 DMA传输需要由DMA控制器DMAC进行,当需要进行DMA传输的时候,DMA控制器会发出占用总线的请求,当CPU响应DMA的请求时,暂时放弃对总线的控制权,当DMA传输结束的时候,DMAC会向I/O接口发出结束命令,并将总线控制权交还给CPU.一个完整的DMA传输过程必须经过DMA请求.DMA响应.DMA传输.DMA结束4个步骤. 3 DMA传输过程 4 DM

C++第三十九篇 -- 研究一下Windows驱动开发（二）-- 驱动程序中重要的数据结构

数据结构是计算机程序的核心,I/O管理器定义了一些数据结构,这些数据结构是编写驱动程序时所必须掌握的.驱动程序经常要创建和维护这些数据结构的实例. 一.驱动对象(DRIVER_OBJECT) 每个驱动程序会有唯一的驱动对象与之对应,并且这个驱动对象是在驱动加载的时候,被内核中的对象管理程序所创建的. 驱动对象用DRIVER_OBJECT数据结构表示,它作为驱动的一个实例被内核加载,并且内核对一个驱动只加载一个实例.确切地说,是由内核中的I/O管理器负责加载的.驱动程序需要在DriverEntry