Chinaunix首页 | 论坛 | 博客

zhanghaoran的ChinaUnix博客

首页　| 　博文目录　| 　关于我

haoran9175

  • 博客访问： 134354
  • 博文数量： 14
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 633
  • 用 户 组： 普通用户
  • 注册时间： 2013-09-05 11:44
文章分类

全部博文（14）

文章存档

2014年（14）

我的朋友
最近访客
推荐博文
相关博文
USB骨架驱动

分类： LINUX

2014-06-25 10:34:36

内核源码中提供了一个USB驱动的例子是drivers/usb/usb-skeleton.c，称为USB骨架程序。

一、USB骨架程序的usb_driver结构体定义

点击(此处)折叠或打开

  1. static struct usb_driver skel_driver = {
  2.     .name =        "skeleton",//驱动名
  3.     .probe =    skel_probe,//探测方法
  4.     .disconnect =    skel_disconnect,//断开连接的方法
  5.     .suspend =    skel_suspend,//挂起方法
  6.     .resume =    skel_resume,//恢复方法
  7.     .pre_reset =    skel_pre_reset,
  8.     .post_reset =    skel_post_reset,//设备重置后调用
  9.     .id_table =    skel_table,//驱动支持的设备ID列表
  10.     .supports_autosuspend = 1,//支持挂起
  11. };
usb_driver的id_table成员指定了驱动支持的USB设备的列表，定义如下：

点击(此处)折叠或打开

  1. /* 定义这些值以匹配您的设备 */
  2. #define USB_SKEL_VENDOR_ID    0xfff0
  3. #define USB_SKEL_PRODUCT_ID    0xfff0
  4. //驱动支持的设备ID列表
  5. static const struct usb_device_id skel_table[] = {
  6.     { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
  7.     { }                    /* Terminating entry */
  8. };
  9. MODULE_DEVICE_TABLE(usb, skel_table);
二、驱动的加载和卸载方法
1、加载方法，将usb_driver结构注册到USB核心

点击(此处)折叠或打开

  1. static int __init usb_skel_init(void)
  2. {
  3.     int result;
  4.     //注册一个USB驱动
  5.     result = usb_register(&skel_driver);
  6.     if (result)
  7.         err("usb_register failed. Error number %d", result);
  8.     return result;
  9. }
2、卸载方法，将usb_driver结构注销

点击(此处)折叠或打开

  1. static void __exit usb_skel_exit(void)
  2. {
  3.     //注销一个USB驱动
  4.     usb_deregister(&skel_driver);
  5. }
三、USB的探测方法
探测方法，当USB设备插入时，USB核心检测到USB设备的属性和对应的USB驱动匹配时，会调用USB驱动的探测方法

点击(此处)折叠或打开

  1. static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
  2. {
  3.     struct usb_skel *dev;
  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;

  10.     //分配私有数据usb_skel空间
  11.     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  12.     if (!dev) {
  13.         err("Out of memory");
  14.         goto error;
  15.     }
  16.     //初始化私有数据结构usb_skel
  17.     kref_init(&dev->kref);//初始化引用计数器
  18.     sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);//初始化信号
  19.     mutex_init(&dev->io_mutex);//初始化互斥体
  20.     spin_lock_init(&dev->err_lock);//初始化错误自旋锁
  21.     init_usb_anchor(&dev->submitted);
  22.     init_completion(&dev->bulk_in_completion);//初始化批量输入端点的地址
  23.     //通过接口得到usb设备结构
  24.     dev->udev = usb_get_dev(interface_to_usbdev(interface));
  25.     dev->interface = interface;//初始化设备的接口

  27.     //设置端点信息
  28.     //仅使用第一个bulk-in和buil-out
  29.     iface_desc = interface->cur_altsetting;//获得当前激活的设置
  30.     //扫描接口中的每一个端点
  31.     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
  32.         endpoint = &iface_desc->endpoint[i].desc;//获得一个端点
  33.         //比较端点是否为输入端点
  34.         if (!dev->bulk_in_endpointAddr &&
  35.          usb_endpoint_is_bulk_in(endpoint)) {
  36.             //找到一个批量的输入端点
  37.             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
  38.             dev->bulk_in_size = buffer_size;
  39.             dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
  40.             dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
  41.             if (!dev->bulk_in_buffer) {
  42.                 err("Could not allocate bulk_in_buffer");
  43.                 goto error;
  44.             }
  45.             dev->bulk_in_urb = usb_alloc_urb(0, GFP_KERNEL);
  46.             if (!dev->bulk_in_urb) {
  47.                 err("Could not allocate bulk_in_urb");
  48.                 goto error;
  49.             }
  50.         }
  51.         //比较端点是否为输出端点
  52.         if (!dev->bulk_out_endpointAddr &&
  53.          usb_endpoint_is_bulk_out(endpoint)) {
  54.             //找到一个批量的输出端点
  55.             dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
  56.         }
  57.     }
  58.     if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
  59.         err("Could not find both bulk-in and bulk-out endpoints");
  60.         goto error;
  61.     }

  63.     /*在接口设备中保存数据指针 */
  64.     usb_set_intfdata(interface, dev);//将usb_skel结构作为接口的私有数据保存

  66.     /* 注册USB设备*/
  67.     retval = usb_register_dev(interface, &skel_class);
  68.     if (retval) {
  69.         /* something prevented us from registering this driver */
  70.         err("Not able to get a minor for this device.");
  71.         usb_set_intfdata(interface, NULL);
  72.         goto error;
  73.     }

  75.     /* let the user know what node this device is now attached to */
  76.     dev_info(&interface->dev,
  77.          "USB Skeleton device now attached to USBSkel-%d",
  78.          interface->minor);
  79.     return 0;

  81. error:
  82.     if (dev)
  83.         /* this frees allocated memory */
  84.         kref_put(&dev->kref, skel_delete);
  85.     return retval;
  86. }
四、私有数据结构

点击(此处)折叠或打开

  1. struct usb_skel {
  2.     struct usb_device    *udev;            /*这个设备的usb设备 */
  3.     struct usb_interface    *interface;        /* 这个设备的接口*/
  4.     struct semaphore    limit_sem;        /*限制写的数量 */
  5.     struct usb_anchor    submitted;        /* 以防我们需要收回我们的提交*/
  6.     struct urb        *bulk_in_urb;        /* 用于读取数据的URB*/
  7.     unsigned char *bulk_in_buffer;    /*接收数据的缓冲区*/
  8.     size_t            bulk_in_size;        /* 接收缓冲区的大小 */
  9.     size_t            bulk_in_filled;        /*缓冲区的字节数*/
  10.     size_t            bulk_in_copied;        /* 已经复制到用户空间大小 */
  11.     __u8            bulk_in_endpointAddr;    //批量输入端点的地址
  12.     __u8            bulk_out_endpointAddr;    //批量输出端点的地址
  13.     int            errors;            /* the last request tanked */
  14.     int            open_count;        //打开USB设备的数量
  15.     bool            ongoing_read;        //是否在继续读数据
  16.     bool            processed_urb;        //确定是否有未处理的urb
  17.     spinlock_t        err_lock;        //错误自旋锁
  18.     struct kref        kref;//引用计数器
  19.     struct mutex        io_mutex;        //用于断开连接的同步IO
  20.     struct completion    bulk_in_completion;    /* to wait for an ongoing read */
  21. };
五、断开连接的方法
当USB设备拔出时，USB核心会调用USB驱动的断开连接方法

点击(此处)折叠或打开

  1. static void skel_disconnect(struct usb_interface *interface)
  2. {
  3.     struct usb_skel *dev;
  4.     int minor = interface->minor;//获得次设备号
  5.     //获得接口的私有数据
  6.     dev = usb_get_intfdata(interface);
  7.     usb_set_intfdata(interface, NULL);//设置接口的私有数据位空

  9.     //注销USB设备，释放设备号
  10.     usb_deregister_dev(interface, &skel_class);

  12.     //阻止更多的IO动作
  13.     mutex_lock(&dev->io_mutex);
  14.     dev->interface = NULL;
  15.     mutex_unlock(&dev->io_mutex);

  17.     usb_kill_anchored_urbs(&dev->submitted);

  19.     //释放设备号
  20.     kref_put(&dev->kref, skel_delete);

  22.     dev_info(&interface->dev, "USB Skeleton #%d now disconnected", minor);
  23. }
六、skel_class结构
注册USB驱动的时候需要传递一个usb_class_driver结构

点击(此处)折叠或打开

  1. static struct usb_class_driver skel_class = {
  2.     .name =        "skel%d",
  3.     .fops =        &skel_fops,//USB设备文件操作函数集合
  4.     .minor_base =    USB_SKEL_MINOR_BASE,//usb次设备号基址
  5. };
  6. static const struct file_operations skel_fops = {
  7.     .owner =    THIS_MODULE,
  8.     .read =        skel_read,//读函数
  9.     .write =    skel_write,//写函数
  10.     .open =        skel_open,//打开
  11.     .release =    skel_release,//关闭
  12.     .flush =    skel_flush,//刷新
  13.     .llseek =    noop_llseek,//重定位
  14. };
七、打开函数

点击(此处)折叠或打开

  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;

  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.          __func__, 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.     }

  24.     //增加引用计数
  25.     kref_get(&dev->kref);

  27.     /* lock the device to allow correctly handling errors
  28.      * in resumption */
  29.     mutex_lock(&dev->io_mutex);
  30.     //增加打开次数
  31.     if (!dev->open_count++) {
  32.         retval = usb_autopm_get_interface(interface);
  33.             if (retval) {
  34.                 dev->open_count--;
  35.                 mutex_unlock(&dev->io_mutex);
  36.                 kref_put(&dev->kref, skel_delete);
  37.                 goto exit;
  38.             }
  39.     } /* else { //uncomment this block if you want exclusive open
  40.         retval = -EBUSY;
  41.         dev->open_count--;
  42.         mutex_unlock(&dev->io_mutex);
  43.         kref_put(&dev->kref, skel_delete);
  44.         goto exit;
  45.     } */
  46.     /* prevent the device from being autosuspended */

  48.     /* save our object in the file's private structure */
  49.     file->private_data = dev;//设置文件的私有数据
  50.     mutex_unlock(&dev->io_mutex);

  52. exit:
  53.     return retval;
  54. }
八、关闭方法

点击(此处)折叠或打开

  1. static int skel_release(struct inode *inode, struct file *file)
  2. {
  3.     struct usb_skel *dev;

  5.     dev = file->private_data;//获得私有数据
  6.     if (dev == NULL)
  7.         return -ENODEV;

  9.     //减少打开次数
  10.     mutex_lock(&dev->io_mutex);
  11.     if (!--dev->open_count && dev->interface)
  12.         usb_autopm_put_interface(dev->interface);
  13.     mutex_unlock(&dev->io_mutex);

  15.     //减少引用次数
  16.     kref_put(&dev->kref, skel_delete);
  17.     return 0;
  18. }
九、写方法

点击(此处)折叠或打开

  1. static ssize_t skel_write(struct file *file, const char *user_buffer,
  2.              size_t count, loff_t *ppos)
  3. {
  4.     struct usb_skel *dev;
  5.     int retval = 0;
  6.     struct urb *urb = NULL;
  7.     char *buf = NULL;
  8.     size_t writesize = min(count, (size_t)MAX_TRANSFER);//计算写入大小

  10.     dev = file->private_data;//获得私有数据

  12.     /* verify that we actually have some data to write */
  13.     if (count == 0)//写入大小为0时退出
  14.         goto exit;

  16.     /*
  17.      * limit the number of URBs in flight to stop a user from using up all
  18.      * RAM
  19.      */
  20.      //判断文件类型是否为阻塞的
  21.     if (!(file->f_flags & O_NONBLOCK)) {
  22.         //获得信号量
  23.         if (down_interruptible(&dev->limit_sem)) {
  24.             retval = -ERESTARTSYS;
  25.             goto exit;
  26.         }
  27.     } else {
  28.         //尝试获得信号量
  29.         if (down_trylock(&dev->limit_sem)) {
  30.             retval = -EAGAIN;
  31.             goto exit;
  32.         }
  33.     }

  35.     spin_lock_irq(&dev->err_lock);
  36.     retval = dev->errors;
  37.     if (retval < 0) {
  38.         /* any error is reported once */
  39.         dev->errors = 0;
  40.         /* to preserve notifications about reset */
  41.         retval = (retval == -EPIPE) ? retval : -EIO;
  42.     }
  43.     spin_unlock_irq(&dev->err_lock);
  44.     if (retval < 0)
  45.         goto error;

  47.     /* 创建一个urb,一个缓冲区,并将数据复制到urb */
  48.     urb = usb_alloc_urb(0, GFP_KERNEL);
  49.     if (!urb) {
  50.         retval = -ENOMEM;
  51.         goto error;
  52.     }
  53.     //分配一个缓冲区
  54.     buf = usb_alloc_coherent(dev->udev, writesize, GFP_KERNEL,
  55.                  &urb->transfer_dma);
  56.     if (!buf) {
  57.         retval = -ENOMEM;
  58.         goto error;
  59.     }
  60.     //从用户控件复制数据到缓冲区
  61.     if (copy_from_user(buf, user_buffer, writesize)) {
  62.         retval = -EFAULT;
  63.         goto error;
  64.     }

  66.     /* this lock makes sure we don't submit URBs to gone devices */
  67.     mutex_lock(&dev->io_mutex);
  68.     if (!dev->interface) {        /* disconnect() was called */
  69.         mutex_unlock(&dev->io_mutex);
  70.         retval = -ENODEV;
  71.         goto error;
  72.     }

  74.     //批量urb初始化
  75.     usb_fill_bulk_urb(urb, dev->udev,
  76.              usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
  77.              buf, writesize, skel_write_bulk_callback, dev);
  78.     urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  79.     usb_anchor_urb(urb, &dev->submitted);

  81.     //提交urb到核心
  82.     retval = usb_submit_urb(urb, GFP_KERNEL);
  83.     mutex_unlock(&dev->io_mutex);
  84.     if (retval) {
  85.         err("%s - failed submitting write urb, error %d", __func__,
  86.          retval);
  87.         goto error_unanchor;
  88.     }

  90.     //释放urb
  91.     usb_free_urb(urb);

  93.     return writesize;

  95. error_unanchor:
  96.     usb_unanchor_urb(urb);
  97. error:
  98.     if (urb) {
  99.         usb_free_coherent(dev->udev, writesize, buf, urb->transfer_dma);
  100.         usb_free_urb(urb);
  101.     }
  102.     up(&dev->limit_sem);

  104. exit:
  105.     return retval;
  106. }

  108. //写完成回调函数，当URB传输完成后调用
  109. static void skel_write_bulk_callback(struct urb *urb)
  110. {
  111.     struct usb_skel *dev;

  113.     dev = urb->context;

  115.     //判断urb状态
  116.     if (urb->status) {
  117.         if (!(urb->status == -ENOENT ||
  118.          urb->status == -ECONNRESET ||
  119.          urb->status == -ESHUTDOWN))
  120.             err("%s - nonzero write bulk status received: %d",
  121.              __func__, urb->status);

  123.         spin_lock(&dev->err_lock);
  124.         dev->errors = urb->status;
  125.         spin_unlock(&dev->err_lock);
  126.     }

  128.     /*释放我们的分配缓冲区*/
  129.     usb_free_coherent(urb->dev, urb->transfer_buffer_length,
  130.              urb->transfer_buffer, urb->transfer_dma);
  131.     up(&dev->limit_sem);
  132. }
十、读方法

点击(此处)折叠或打开

  1. static ssize_t skel_read(struct file *file, char *buffer, size_t count,
  2.              loff_t *ppos)
  3. {
  4.     struct usb_skel *dev;
  5.     int rv;
  6.     bool ongoing_io;

  8.     dev = file->private_data;//获得私有数据

  10.     //判断读取的数量为0，或用于读取的URB未分配
  11.     if (!dev->bulk_in_urb || !count)
  12.         return 0;

  14.     //互斥体
  15.     rv = mutex_lock_interruptible(&dev->io_mutex);
  16.     if (rv < 0)
  17.         return rv;
  18.     //判断接口是否为空
  19.     if (!dev->interface) {        /* disconnect() was called */
  20.         rv = -ENODEV;
  21.         goto exit;
  22.     }

  24.     /* if IO is under way, we must not touch things */
  25. retry:
  26.     spin_lock_irq(&dev->err_lock);
  27.     ongoing_io = dev->ongoing_read;
  28.     spin_unlock_irq(&dev->err_lock);
  29.     //判断是否在进行IO操作
  30.     if (ongoing_io) {
  31.         /* 非阻塞IO不等待*/
  32.         if (file->f_flags & O_NONBLOCK) {
  33.             rv = -EAGAIN;
  34.             goto exit;
  35.         }
  36.         //如果是阻塞的，阻塞IO
  37.         rv = wait_for_completion_interruptible(&dev->bulk_in_completion);
  38.         if (rv < 0)
  39.             goto exit;
  40.         /*
  41.          * by waiting we also semiprocessed the urb
  42.          * we must finish now
  43.          */
  44.         dev->bulk_in_copied = 0;
  45.         dev->processed_urb = 1;
  46.     }
  47.     //判断是否有未完成的urb
  48.     if (!dev->processed_urb) {
  49.         /*
  50.          * the URB hasn't been processed
  51.          * do it now
  52.          */
  53.         wait_for_completion(&dev->bulk_in_completion);
  54.         dev->bulk_in_copied = 0;
  55.         dev->processed_urb = 1;
  56.     }

  58.     /* errors must be reported */
  59.     rv = dev->errors;
  60.     if (rv < 0) {
  61.         /* any error is reported once */
  62.         dev->errors = 0;
  63.         /* to preserve notifications about reset */
  64.         rv = (rv == -EPIPE) ? rv : -EIO;
  65.         /* no data to deliver */
  66.         dev->bulk_in_filled = 0;
  67.         /* report it */
  68.         goto exit;
  69.     }

  71.     /*
  72.      * if the buffer is filled we may satisfy the read
  73.      * else we need to start IO
  74.      */
  75.     //判断缓冲区的字节数
  76.     if (dev->bulk_in_filled) {
  77.         //得到需要读取数据的大小
  78.         size_t available = dev->bulk_in_filled - dev->bulk_in_copied;
  79.         size_t chunk = min(available, count);

  81.         if (!available) {
  82.             /*
  83.              * all data has been used
  84.              * actual IO needs to be done
  85.              */
  86.             rv = skel_do_read_io(dev, count);
  87.             if (rv < 0)
  88.                 goto exit;
  89.             else
  90.                 goto retry;
  91.         }
  92.         /*
  93.          * data is available
  94.          * chunk tells us how much shall be copied
  95.          */

  97.         if (copy_to_user(buffer,
  98.                  dev->bulk_in_buffer + dev->bulk_in_copied,
  99.                  chunk))
  100.             rv = -EFAULT;
  101.         else
  102.             rv = chunk;

  104.         dev->bulk_in_copied += chunk;

  106.         /*
  107.          * if we are asked for more than we have,
  108.          * we start IO but don't wait
  109.          */
  110.         if (available < count)
  111.             skel_do_read_io(dev, count - chunk);
  112.     } else {
  113.         /* no data in the buffer */
  114.         rv = skel_do_read_io(dev, count);
  115.         if (rv < 0)
  116.             goto exit;
  117.         else if (!(file->f_flags & O_NONBLOCK))
  118.             goto retry;
  119.         rv = -EAGAIN;
  120.     }
  121. exit:
  122.     mutex_unlock(&dev->io_mutex);
  123.     return rv;
  124. }
  125. //读IO方法
  126. static int skel_do_read_io(struct usb_skel *dev, size_t count)
  127. {
  128.     int rv;

  130.     //批量urb初始化
  131.     usb_fill_bulk_urb(dev->bulk_in_urb,
  132.             dev->udev,
  133.             usb_rcvbulkpipe(dev->udev,
  134.                 dev->bulk_in_endpointAddr),
  135.             dev->bulk_in_buffer,
  136.             min(dev->bulk_in_size, count),
  137.             skel_read_bulk_callback,
  138.             dev);
  139.     //设置IO操作标志
  140.     spin_lock_irq(&dev->err_lock);
  141.     dev->ongoing_read = 1;
  142.     spin_unlock_irq(&dev->err_lock);

  144.     //提交urb到核心
  145.     rv = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL);
  146.     if (rv < 0) {
  147.         err("%s - failed submitting read urb, error %d",
  148.             __func__, rv);
  149.         dev->bulk_in_filled = 0;
  150.         rv = (rv == -ENOMEM) ? rv : -EIO;
  151.         spin_lock_irq(&dev->err_lock);
  152.         dev->ongoing_read = 0;
  153.         spin_unlock_irq(&dev->err_lock);
  154.     }

  156.     return rv;
  157. }
  158. //读完成回调方法
  159. static void skel_read_bulk_callback(struct urb *urb)
  160. {
  161.     struct usb_skel *dev;

  163.     dev = urb->context;

  165.     spin_lock(&dev->err_lock);
  166.     //判断URB
  167.     if (urb->status) {
  168.         if (!(urb->status == -ENOENT ||
  169.          urb->status == -ECONNRESET ||
  170.          urb->status == -ESHUTDOWN))
  171.             err("%s - nonzero write bulk status received: %d",
  172.              __func__, urb->status);

  174.         dev->errors = urb->status;
  175.     } else {
  176.         dev->bulk_in_filled = urb->actual_length;
  177.     }
  178.     dev->ongoing_read = 0;
  179.     spin_unlock(&dev->err_lock);

  181.     complete(&dev->bulk_in_completion);
  182. }
十一、USB驱动的模板
通过对USB骨架驱动的分析，可总结出USB模板

点击(此处)折叠或打开

  1. //驱动支持的设备ID列表
  2. static const struct usb_device_id xxx_table[] = {
  3.     { USB_DEVICE(USB_XXX_VENDOR_ID, USB_XXX_PRODUCT_ID) },
  4.     { }                    /* Terminating entry */
  5. };
  6. MODULE_DEVICE_TABLE(usb, xxx_table);

  8. //打开方法
  9. static int xxx_open(struct inode *inode, struct file *file)
  10. {
  11.     。。。
  12.     //增加引用计数
  13.     kref_get(&dev->kref);

  15.     file->private_data = dev;//设置文件的私有数据
  16.     。。。
  17. }
  18. //关闭方法
  19. static int xxx_release(struct inode *inode, struct file *file)
  20. {
  21.     dev = file->private_data;//获得私有数据
  22.     if (dev == NULL)
  23.         return -ENODEV;

  25.     //减少引用次数
  26.     kref_put(&dev->kref, xxx_delete);
  27.     。。。
  28. }

  30. //读完成回调方法
  31. static void xxx_read_bulk_callback(struct urb *urb)
  32. {
  33.     。。。
  34.     //判断URB
  35.     if (urb->status) {
  36.         。。。
  37.     }
  38.     complete(&dev->bulk_in_completion);
  39. }

  41. //读方法
  42. static ssize_t skel_read(struct file *file, char *buffer, size_t count,
  43.              loff_t *ppos)
  44. {
  45.     。。。
  46.         //批量urb初始化
  47.     usb_fill_bulk_urb(dev->bulk_in_urb,
  48.             dev->udev,
  49.             usb_rcvbulkpipe(dev->udev,
  50.                 dev->bulk_in_endpointAddr),
  51.             dev->bulk_in_buffer,
  52.             min(dev->bulk_in_size, count),
  53.             xxx_read_bulk_callback,
  54.             dev);
  55.     //提交urb到核心
  56.     rv = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL);
  57.     
  58.     copy_to_user(buffer,dev->bulk_in_buffer + dev->bulk_in_copied,chunk);
  59.     。。。
  60. }

  62. //写完成回调函数，当URB传输完成后调用
  63. static void xxx_write_bulk_callback(struct urb *urb)
  64. {
  65.     。。。

  67.     /*释放我们的分配缓冲区*/
  68.     usb_free_coherent(urb->dev, urb->transfer_buffer_length,
  69.              urb->transfer_buffer, urb->transfer_dma);
  70.     。。。
  71. }
  72. //写方法
  73. static ssize_t xxx_write(struct file *file, const char *user_buffer,
  74.              size_t count, loff_t *ppos)
  75. {
  76.     。。。
  77.     /* 创建一个urb */
  78.     urb = usb_alloc_urb(0, GFP_KERNEL);
  79.     if (!urb) {
  80.         retval = -ENOMEM;
  81.         goto error;
  82.     }
  83.     //分配一个缓冲区
  84.     buf = usb_alloc_coherent(dev->udev, writesize, GFP_KERNEL,
  85.                  &urb->transfer_dma);
  86.     if (!buf) {
  87.         retval = -ENOMEM;
  88.         goto error;
  89.     }
  90.     //从用户控件复制数据到缓冲区
  91.     if (copy_from_user(buf, user_buffer, writesize)) {
  92.         retval = -EFAULT;
  93.         goto error;
  94.     }

  96.     //批量urb初始化
  97.     usb_fill_bulk_urb(urb, dev->udev,
  98.              usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
  99.              buf, writesize,xxx_write_bulk_callback, dev);
  100.     urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  101.     usb_anchor_urb(urb, &dev->submitted);

  103.     //提交urb到核心
  104.     retval = usb_submit_urb(urb, GFP_KERNEL);
  105.     mutex_unlock(&dev->io_mutex);
  106.     if (retval) {
  107.         err("%s - failed submitting write urb, error %d", __func__,
  108.          retval);
  109.         goto error_unanchor;
  110.     }

  112.     //释放urb
  113.     usb_free_urb(urb);

  115.     。。。
  116. }

  118. static const struct file_operations xxx_fops = {
  119.     .owner =    THIS_MODULE,
  120.     .read =        xxx_read,//读函数
  121.     .write =    xxx_write,//写函数
  122.     .open =        xxx_open,//打开
  123.     .release =    xxx_release,//关闭
  124.     。。。
  125. };

  127. static struct usb_class_driver xxx_class = {
  128.     .name =        "xxx%d",
  129.     .fops =        &xxx_fops,//USB设备文件操作函数集合
  130.     .minor_base =    USB_XXX_MINOR_BASE,//usb次设备号基址
  131. };

  133. //探测方法，当USB设备插入时，USB核心检测到USB设备的属性和对应的USB驱动匹配时，会调用USB驱动的探测方法
  134. static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
  135. {
  136.     。。。
  137.     
  138.     /* 注册USB设备*/
  139.     retval = usb_register_dev(interface, &xxx_class);
  140.     if (retval) {
  141.         /* something prevented us from registering this driver */
  142.         err("Not able to get a minor for this device.");
  143.         usb_set_intfdata(interface, NULL);
  144.         goto error;
  145.     }
  146.     。。。
  147. }

  149. //驱动结构体
  150. static struct usb_driver xxx_driver = {
  151.     .name =        "xxx",//驱动名
  152.     .probe =    xxx_probe,//探测方法
  153.     .disconnect =    xxx_disconnect,//断开连接的方法
  154.     .suspend =    xxx_suspend,//挂起方法
  155.     .resume =    xxx_resume,//恢复方法
  156.     .id_table =    xxx_table,//驱动支持的设备ID列表
  157.     。。。
  158. };

  160. //驱动加载函数
  161. static int __init usb_xxx_init(void)
  162. {
  163.     int result;

  165.     //注册一个USB驱动
  166.     result = usb_register(&xxx_driver);
  167.     if (result)
  168.         err("usb_register failed. Error number %d", result);

  170.     return result;
  171. }

  173. //驱动卸载函数
  174. static void __exit usb_xxx_exit(void)
  175. {
  176.     //注销一个USB驱动
  177.     usb_deregister(&xxx_driver);
  178. }

  180. module_init(usb_xxx_init);
  181. module_exit(usb_xxx_exit);













阅读(2467) | 评论(0) | 转发(0) |
1

上一篇：linux GPIO驱动

下一篇：input输入设备驱动

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6