Linux驱动程序--USB设备驱动程序

首先注册USB驱动

// 定义USB设备ID
#define USB_SKEL_VENDOR_ID  0x0483
#define USB_SKEL_PRODUCT_ID 0x5740

// 定义使用本驱动程序的USB设备列表
static struct usb_device_id skel_table [] = {
    { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
    { }
};
              
static struct usb_driver skel_driver = {
    .name = "skeleton",
    .id_table = skel_table,
    .probe = skel_probe,
    .disconnect = skel_disconnect,
};
    
static int __init usb_skel_init(void)
{
    int result;
        
    printk("usb_skel_init\r\n");
      
    // 注册USB驱动
    result = usb_register(&skel_driver);
    if (result){
        printk("usb_register failed. Error number %d", result);
    }
             
    return result;
}

static void __exit usb_skel_exit(void)
{
    /* deregister this driver with the USB subsystem */
    usb_deregister(&skel_driver);
    
    printk("usb_skel_exit\r\n");
}

module_init (usb_skel_init);
module_exit (usb_skel_exit);    
MODULE_LICENSE("GPL");

probe与disconnect接口

static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
    struct usb_skel *dev = NULL;
    struct usb_host_interface *iface_desc;
    struct usb_endpoint_descriptor *endpoint;
    size_t buffer_size;
    int i;
    int retval = -ENOMEM;

    // 为每个设备分配内存，用于保存参数
    dev = kmalloc(sizeof(struct usb_skel), GFP_KERNEL);
    if (dev == NULL) {
        err("Out of memory");
        goto error;
    }
    memset(dev, 0x00, sizeof (*dev));
    kref_init(&dev->kref);

    dev->udev = usb_get_dev(interface_to_usbdev(interface));
    dev->interface = interface;

    // 查到可用端点信息，以保证设备与驱动的一致性
    iface_desc = interface->cur_altsetting;
    for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
        endpoint = &iface_desc->endpoint[i].desc;

        if (!dev->bulk_in_endpointAddr &&
            (endpoint->bEndpointAddress & USB_DIR_IN) &&
            ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
                    == USB_ENDPOINT_XFER_BULK)) {
            /* we found a bulk in endpoint */
            buffer_size = endpoint->wMaxPacketSize;
            dev->bulk_in_size = buffer_size;
            dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
            dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
            if (!dev->bulk_in_buffer) {
                err("Could not allocate bulk_in_buffer");
                goto error;
            }
        }

        if (!dev->bulk_out_endpointAddr &&
            !(endpoint->bEndpointAddress & USB_DIR_IN) &&
            ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
                    == USB_ENDPOINT_XFER_BULK)) {
            /* we found a bulk out endpoint */
            dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
        }
    }
    if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
        err("Could not find both bulk-in and bulk-out endpoints");
        goto error;
    }

    // 保存相关参数
    usb_set_intfdata(interface, dev);

    // 注册设备文件
    retval = usb_register_dev(interface, &skel_class);
    if (retval) {
        /* something prevented us from registering this driver */
        err("Not able to get a minor for this device.");
        usb_set_intfdata(interface, NULL);
        goto error;
    }

    printk("USB Skeleton device now attached to USBSkel-%d", interface->minor);
    return 0;

error:
    if (dev)
        kref_put(&dev->kref, skel_delete);
    return retval;
}

static void skel_disconnect(struct usb_interface *interface)
{
    struct usb_skel *dev;
    int minor = interface->minor;

    /* prevent skel_open() from racing skel_disconnect() */
    lock_kernel();

    dev = usb_get_intfdata(interface);
    usb_set_intfdata(interface, NULL);

    /* give back our minor */
    usb_deregister_dev(interface, &skel_class);

    unlock_kernel();

    /* decrement our usage count */
    kref_put(&dev->kref, skel_delete);

    printk("USB Skeleton #%d now disconnected", minor);
}

Write接口(发送数据)

// 数据发送完成回调函数
static void skel_write_bulk_callback(struct urb *urb, struct pt_regs *regs)
{
  printk("skel write callback.\r\n");
  /* sync/async unlink faults aren't errors */
  if (urb->status && 
      !(urb->status == -ENOENT || 
        urb->status == -ECONNRESET ||
        urb->status == -ESHUTDOWN)) {
    printk("%s - nonzero write bulk status received: %d",
        __FUNCTION__, urb->status);
  }

  /* free up our allocated buffer */
  usb_free_coherent(urb->dev, urb->transfer_buffer_length, 
      urb->transfer_buffer, urb->transfer_dma);
}

static ssize_t skel_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *ppos)
{
  struct usb_skel *dev;
  int retval = 0;
  struct urb *urb = NULL;
  char *buf = NULL;

  dev = (struct usb_skel *)file->private_data;

  printk("skel is write.\r\n");

  /* verify that we actually have some data to write */
  if (count == 0){
    goto exit;
  }

  /* 创建URB */
  urb = usb_alloc_urb(0, GFP_KERNEL);
  if (!urb) {
    retval = -ENOMEM;
    goto error;
  }

  // 动态分配内存
  buf = usb_alloc_coherent(dev->udev, count, GFP_KERNEL, &urb->transfer_dma);
  if (!buf) {
    retval = -ENOMEM;
    goto error;
  }

  if (copy_from_user(buf, user_buffer, count)) {
    retval = -EFAULT;
    goto error;
  }

  /* 初始化URB为批量 */
  usb_fill_bulk_urb(
          urb,
          dev->udev,
          usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
          buf,
          count,
          (usb_complete_t)skel_write_bulk_callback, dev);

  urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

  /* 提交urb数据（发送数据） */
  retval = usb_submit_urb(urb, GFP_KERNEL);
  if (retval) {
    printk("%s - failed submitting write urb, error %d", __FUNCTION__, retval);
    goto error;
  }

  // 释放urb
  usb_free_urb(urb);

exit:
  return count;

error:
  usb_free_coherent(dev->udev, count, buf, urb->transfer_dma);
  usb_free_urb(urb);
  kfree(buf);
  return retval;
}

注意事项：
usb_buffer_alloc/usb_buffer_free在新的内核版本中函数名称修改为
usb_alloc_coherent/usb_free_coherent，参数列表不变；