20.3.4 USB骨架程序

1 static struct usb_driver skel_driver = 
2 {
3 .name ="skeleton",
4 .probe =skel_probe,
5 .disconnect =skel_disconnect,
6 .id_table =skel_table,
7 };

1  /* 本驱动支持的USB设备列表 */
2  static struct usb_device_id skel_table [] = {
3      { USB_DEVICE(USB_SKEL_VENDOR_ID,
4        USB_SKEL_PRODUCT_ID) },
5      { }                      
6  };
7  MODULE_DEVICE_TABLE (usb, skel_table);

1  static int __init usb_skel_init(void)
2  {
3  int result;
4  
5  /* 注册USB驱动 */
6  result = usb_register(&skel_driver);
7  if (result)
8  err("usb_register failed. Error number %d", result);
9  
10 return result;
11 }
12 static void __exit usb_skel_exit(void)
13 {
14    /* 注销USB驱动 */
15    usb_deregister(&skel_driver);
16 }

1  static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
2  {
3  struct usb_skel *dev = NULL;
4  struct usb_host_interface *iface_desc;
5  struct usb_endpoint_descriptor *endpoint;
6  size_t buffer_size;
7  int i;
8  int retval = -ENOMEM;
9  
10 /* 分配设备状态的内存并初始化 */
11 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
12 if (dev == NULL) {
13 err("Out of memory");
14 goto error;
15 }
16 kref_init(&dev->kref);
17 sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);
18 
19 dev->udev = usb_get_dev(interface_to_usbdev(interface));
20 dev->interface = interface;
21 
22 /* 设置端点信息 */
23 /* 仅使用第一个bulk-in和bulk-out */
24 iface_desc = interface->cur_altsetting;
25 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
26 endpoint = &iface_desc->endpoint[i].desc;
27 
28 if (!dev->bulk_in_endpointAddr &&
29     ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
30 == USB_DIR_IN) &&
31     ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
32 == USB_ENDPOINT_XFER_BULK)) {
33 /* 找到了一个批量IN端点 */
34 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
35 dev->bulk_in_size = buffer_size;
36 dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
37 dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
38 if (!dev->bulk_in_buffer) {
39 err("Could not allocate bulk_in_buffer");
40 goto error;
41 }
42 }
43 
44 if (!dev->bulk_out_endpointAddr &&
45     ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
46 == USB_DIR_OUT) &&
47     ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
48 == USB_ENDPOINT_XFER_BULK)) {
49 /* 找到了一个批量OUT端点 */
50 dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
51 }
52 }
53 if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
54 err("Could not find both bulk-in and bulk-out endpoints");
55 goto error;
56 }
57 
58 /* 在设备结构中保存数据指针 */
59 usb_set_intfdata(interface, dev);
60 
61 /* 注册USB设备 */
62 retval = usb_register_dev(interface, &skel_class);
63 if (retval) {
64 /* something prevented us from registering this driver */
65 err("Not able to get a minor for this device.");
66 usb_set_intfdata(interface, NULL);
67 goto error;
68 }
69 
70 /* 告知用户设备依附于什么node */
71 info("USB Skeleton device now attached to USBSkel-%d", interface->minor);
72 return 0;
73 
74 error:
75 if (dev)
76 kref_put(&dev->kref, skel_delete);
77 return retval;
78 }

1  struct usb_skel 
2  {
3  struct usb_device *udev;/* 该设备的usb_device指针 */
4  struct usb_interface *interface;/* 该设备的usb_interface指针 */
5  struct semaphorelimit_sem;/* 限制进程写的数量 */
6  unsigned char *bulk_in_buffer;/* 接收数据的缓冲区 */
7  size_tbulk_in_size;/* 接收缓冲区大小 */
8  _ _u8bulk_in_endpointAddr;/*批量IN端点的地址 */
9  _ _u8bulk_out_endpointAddr;/* 批量OUT端点的地址 */
10 struct krefkref;
11 };

1  static void skel_disconnect(struct usb_interface *interface)
2  {
3  struct usb_skel *dev;
4  int minor = interface->minor;
5  
6  /* 阻止skel_open()与skel_disconnect()的竞争 */
7  lock_kernel();
8  
9  dev = usb_get_intfdata(interface);
10 usb_set_intfdata(interface, NULL);
11 
12 /* 注销usb设备，释放次设备号 */
13 usb_deregister_dev(interface, &skel_class);
14 
15 unlock_kernel();
16 
17 /* 减少引用计数 */
18 kref_put(&dev->kref, skel_delete);
19 
20 info("USB Skeleton #%d now disconnected", minor);
21 }

1 static struct file_operations skel_fops = 
2 {
3 .owner =THIS_MODULE,
4 .read =skel_read, //读函数
5 .write =skel_write,    //写函数
6 .open =skel_open,  //打开函数
7 .release =skel_release, //释放函数
8 };

1  static int skel_open(struct inode *inode, struct file *file)
2  {
3  struct usb_skel *dev;
4  struct usb_interface *interface;
5  int subminor;
6  int retval = 0;
7  
8  subminor = iminor(inode);
9  
10 interface = usb_find_interface(&skel_driver, subminor);
11 if (!interface) {
12 err ("%s - error, can't find device for minor %d",
13      _ _FUNCTION_ _, subminor);
14 retval = -ENODEV;
15 goto exit;
16 }
17 
18 dev = usb_get_intfdata(interface);/*获得接口数据*/
19 if (!dev) {
20 retval = -ENODEV;
21 goto exit;
22 }
23 
24 /* 增加设备的引用计数 */
25 kref_get(&dev->kref);
26 
27 /* 将接口数据保存在file->private_data中 */
28 file->private_data = dev;
29 
30 exit:
31 return retval;
32 }

1  static int skel_release(struct inode *inode, struct file *file)
2  {
3  struct usb_skel *dev;
4  
5  dev = (struct usb_skel *)file->private_data;
6  if (dev == NULL)
7  return -ENODEV;
8  
9  /* 减少设备的引用计数 */
10 kref_put(&dev->kref, skel_delete);
11 return 0;
12 }

1       static ssize_t skel_write

(struct file *file, const char *user_buffer, size_t count, loff_t *ppos)
2  {
3  struct usb_skel *dev;
4  int retval = 0;
5  struct urb *urb = NULL;
6  char *buf = NULL;
7  size_t writesize = min(count, (size_t)MAX_TRANSFER);
8  
9  dev = (struct usb_skel *)file->private_data;
10 
11 /* 验证实际上有数据要写入USB设备 */
12 if (count == 0)
13 goto exit;
14 
15 /* 限制urb的数量，防止一个用户用完所有的RAM */
16 if (down_interruptible(&dev->limit_sem)) {
17 retval = -ERESTARTSYS;
18 goto exit;
19 }
20 
21 /* 创建urb、urb的缓冲区，将数据复制给urb */
22 urb = usb_alloc_urb(0, GFP_KERNEL);
23 if (!urb) {
24 retval = -ENOMEM;
25 goto error;
26 }
27 
28 buf = usb_buffer_alloc(dev->udev, writesize, GFP_KERNEL, &urb->transfer_dma);
29 if (!buf) {
30 retval = -ENOMEM;
31 goto error;
32 }
33 
34 if (copy_from_user(buf, user_buffer, writesize)) {
35 retval = -EFAULT;
36 goto error;
37 }
38 
39 /* 恰当地初始化urb */
40 usb_fill_bulk_urb(urb, dev->udev,
41   usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
42   buf, writesize, skel_write_bulk_callback, dev);
43 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
44 
45 /* 将数据发送到批量端口 */
46 retval = usb_submit_urb(urb, GFP_KERNEL);
47 if (retval) {
48 err("%s - failed submitting write urb, error %d", _ _FUNCTION_ _, retval);
49 goto error;
50 }
51 
52 /* 释放对urb的引用 */
53 usb_free_urb(urb);
54 
55 exit:
56 return writesize;
57 
58 error:
59 usb_buffer_free(dev->udev, writesize, buf, urb->transfer_dma);
60 usb_free_urb(urb);
61 up(&dev->limit_sem);
62 return retval;
63 }

1  static void skel_write_bulk_callback(struct urb *urb, struct pt_regs *regs)
2  {
3  struct usb_skel *dev;
4  
5  dev = (struct usb_skel *)urb->context;
6  
7  /* sync/async去除链路故障，不是错误 */
8  if (urb->status && 
9      !(urb->status == -ENOENT || 
10       urb->status == -ECONNRESET ||
11       urb->status == -ESHUTDOWN)) {
12 dbg("%s - nonzero write bulk status received: %d",
13     _ _FUNCTION_ _, urb->status);
14 }
15 
16 /* 释放被分配的内存 */
17 usb_buffer_free(urb->dev, urb->transfer_buffer_length, 
18 urb->transfer_buffer, urb->transfer_dma);
19 up(&dev->limit_sem);
20 }

1  static ssize_t skel_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
2  {
3  struct usb_skel *dev;
4  int retval = 0;
5  int bytes_read;
6  
7  dev = (struct usb_skel *)file->private_data;
8  
9  /* 从设备进行一次阻塞的批量读 */
10 retval = usb_bulk_msg(dev->udev,
11       usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
12       dev->bulk_in_buffer,
13       min(dev->bulk_in_size, count),
14       &bytes_read, 10000);
15 
16 /* 如果读成功，将数据复制到用户空间 */
17 if (!retval) {
18 if (copy_to_user(buffer, dev->bulk_in_buffer, bytes_read))
19 retval = -EFAULT;
20 else
21 retval = bytes_read;
22 }
23 
24 return retval;
25 }