版权所有，转载请说明转自 http://my.csdn.net/weiqing1981127
一．USB理论
1. USB概念概述
USB1.0版本速度1.5Mbps（低速USB） USB1.1版本速度12Mbps（全速USB） USB2.0版本速度480Mbps（高速USB）
USB驱动由USB主机控制器驱动和USB设备驱动组成。USB主机控制器是用来控制USB设备和CPU之间通信的，USB主机控制器驱动主要用来驱动芯片上的主机控制器硬件。USB设备驱动主要是指具体的例如USB鼠标，USB键盘灯设备的驱动。
一般的通用的Linux设备，如U盘、USB鼠标、USB键盘，都不需要工程师再编写驱动，需要编写的是特定厂商、特定芯片的驱动，而且往往也可以参考内核中已经提供的驱动模板。USB只是一个总线，真正的USB设备驱动的主体工作仍然是USB设备本身所属类型的驱动，如字符设备、tty设备、块设备、输入设备等。
2. USB主机控制器
USB主机控制器属于南桥芯片的一部分，通过PCI总线和处理器通信。USB主机控制器分为UHCI（英特尔提出）、OHCI（康柏和微软提出）、 EHCI。其中OHCI驱动程序用来为非PC系统上以及带有SiS和ALi芯片组的PC主办上的USB芯片提供支持。UHCI驱动程序多用来为大多数其他PC主板（包括Intel和Via）上的USB芯片提供支持。ENCI兼容OHCI和UHCI。UHCI的硬件线路比OHCI简单，所以成本较低，但需要较复杂的驱动程序，CPU负荷稍重。主机控制器驱动程序完成的功能主要包括：解析和维护URB，根据不同的端点进行分类缓存URB；负责不同USB传输类型的调度工作；负责USB数据的实际传输工作；实现虚拟跟HUB的功能。
3. USB设备与USB驱动的匹配
USB设备与USB驱动怎么匹配的呢？实际上USB设备中有一个模块叫固件，是固件信息和USB驱动进行的匹配。固件是固化在集成电路内部的程序代码，USB固件中包含了USB设备的出厂信息，标识该设备的厂商ID、产品ID、主版本号和次版本号等。另外固件中还包含一组程序，这组程序主要完成USB协议的处理和设备的读写操作。USB设备固件和USB驱动之间通信的规范是通过USB协议来完成的。
4. USB设备的逻辑结构和端点的传输方式
USB设备的逻辑结构包括设备、配置、接口和端点，分别用usb_device、usb_host_config、usb_interface、usb_host_endpoint表示。
端点的传输方式包括控制传输、中断传输、批量传输、等时传输。
控制传输主要用于向设备发送配置信息、获取设备信息、发送命令道设备，或者获取设备的状态报告。控制传输一般发送的数据量较小，当USB设备插入时，USB核心使用端点0对设备进行配置，另外，端口0与其他端点不一样，端点0可以双向传输。
中断传输就是中断端点以一个固定的速度来传输较少的数据，USB键盘和鼠标就是使用这个传输方式。这里说的中断和硬件上下文中的中断不一样，它不是设备主动发送一个中断请求，而是主机控制器在保证不大于某个时间间隔内安排一次传输。中断传输对时间要求比较严格，所以可以用中断传输来不断地检测某个设备，当条件满足后再使用批量传输传输大量的数据。
批量传输通常用在数据量大、对数据实时性要求不高的场合，例如USB打印机、扫描仪、大容量存储设备、U盘等。
等时传输同样可以传输大批量数据，但是对数据是否到达没有保证，它对实时性的要求很高，例如音频、视频等设备。
5. USB的URB请求块
USB请求块（USB request block，urb）是USB主机控制器和设备通信的主要数据结构，主机和设备之间通过urb进行数据传输。当主机控制器需要与设备交互时，只需要填充一个urb结构，然后将其提交给USB核心，由USB核心负责对其进行处理。
URB处理流程：
Step1：创建一个URB结构体 usb_alloc_urb()
Step2：初始化，被安排一个特定的USB设备的特定端点。fill_int/bulk/control_urb()
Step3：被USB设备驱动提交给USB核心usb_submit_urb()，注意GPF_ATOMIC,GPF_NOIO,GPF_KERNEL的使用区别。
Step4：提交由USB核心指定的USB主机控制器驱动，被主机控制器驱动处理，进行一次到USB设备的传输，该过程由USB核心和主机控制器完成，不受USB设备驱动控制
Step5：当urb完成，USB主机控制器驱动通知USB设备驱动。
简单的批量与控制URB
有时候USB驱动程序只是从USB设备上接收或发送一些简单的数据，这时候可以使用usb_bulk/control_msg()完成，这两个函数是同步的，因此不能在中断上下文和持有自旋锁的情况下使用。
6. USB的枚举过程
内核辅助线程khubd用来监视与该集线器连接的所有端口，通常情况下，该线程处于休眠状态，当集线器驱动程序检测到USB端口状态变化后，该内核线程立马唤醒。
USB的枚举过程：USB的枚举过程是热插拔USB设备的起始步骤，该过程中，主机控制器获取设备的相关信息并配置好设备，集线器驱动程序负责该枚举过程。枚举过程主要分如下几步：
Step1：根集线器报告插入设备导致的端口电流变化，集线器驱动程序检测到这一状态变化后，唤醒khubd线程。
Step2：khubd识别出电流变化的那个端口
Step3：khubd通过给控制端点0发送控制URB来实现从1-127中选出一个数作为插入设备的批量端点
Step4：khubd利用端口0使用的控制URB从插入的设备那里获得设备描述符，然后获得配置描述符，并选择一个合适的。
Step5：khubd请求USB核心把对应的客户驱动程序和该USB设备挂钩。
二．USB驱动分析
内核代码分析包括USB驱动框架、鼠标驱动、键盘驱动、U盘驱动。
USB驱动编写的主要框架usb-skeleton.c
USB鼠标驱动 usbmouse.c
USB键盘驱动usbkbd.c
USB Mass Storage是一类USB存储设备， U盘便是其中之一，主要分析的驱动文件是usb.c
1.USB驱动框架usb-skeleton.c
USB骨架程序可以被看做一个最简单的USB设备驱动的实例。
首先看看USB骨架程序的usb_driver的定义
static struct usb_driver skel_driver = {
.name = "skeleton",
.probe = skel_probe, //设备探测
.disconnect = skel_disconnect,
.suspend = skel_suspend,
.resume = skel_resume,
.pre_reset = skel_pre_reset,
.post_reset = skel_post_reset,
.id_table = skel_table, //设备支持项
.supports_autosuspend = 1,
};
#define USB_SKEL_VENDOR_ID 0xfff0
#define USB_SKEL_PRODUCT_ID 0xfff0
static struct usb_device_id skel_table[] = {
{ USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
{ }
};
MODULE_DEVICE_TABLE(usb, skel_table);
由上面代码可见，通过USB_DEVICE宏定义了设备支持项。
对上面usb_driver的注册和注销发送在USB骨架程序的模块加载和卸载函数中。
static int __init usb_skel_init(void)
{
int result;
result = usb_register(&skel_driver); //将该驱动挂在USB总线上
if (result)
err("usb_register failed. Error number %d", result);
return result;
}
一个设备被安装或者有设备插入后，当USB总线上经过match匹配成功，就会调用设备驱动程序中的probe探测函数，向探测函数传递设备的信息，以便确定驱动程序是否支持该设备。
static int skel_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
struct usb_skel *dev; //特定设备结构体
struct usb_host_interface *iface_desc; //设置结构体
struct usb_endpoint_descriptor *endpoint; //端点描述符
size_t buffer_size;
int i;
int retval = -ENOMEM;
dev = kzalloc(sizeof(*dev), GFP_KERNEL); //分配内存
if (!dev) {
err("Out of memory");
goto error;
}
kref_init(&dev->kref);
sema_init(&dev->limit_sem, WRITES_IN_FLIGHT); //初始化信号量
mutex_init(&dev->io_mutex); //初始化互斥锁
spin_lock_init(&dev->err_lock); //初始化信号量
init_usb_anchor(&dev->submitted);
init_completion(&dev->bulk_in_completion); //初始化完成量
dev->udev = usb_get_dev(interface_to_usbdev(interface)); //获取usb_device结构体
dev->interface = interface; //获取usb_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 &&
usb_endpoint_is_bulk_in(endpoint)) { //如果该端点为批量输入端点
buffer_size = le16_to_cpu(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;
}
dev->bulk_in_urb = usb_alloc_urb(0, GFP_KERNEL); //分配urb空间
if (!dev->bulk_in_urb) {
err("Could not allocate bulk_in_urb");
goto error;
}
}
if (!dev->bulk_out_endpointAddr &&
usb_endpoint_is_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); //注册USB设备
if (retval) {
err("Not able to get a minor for this device.");
usb_set_intfdata(interface, NULL);
goto error;
}
dev_info(&interface->dev,
"USB Skeleton device now attached to USBSkel-%d",
interface->minor);
return 0;
error:
if (dev)
kref_put(&dev->kref, skel_delete);
return retval;
}
通过上面分析，我们知道，usb_driver的probe函数中根据usb_interface的成员寻找第一个批量输入和输出的端点，将端点地址、缓冲区等信息存入USB骨架程序定义的usb_skel结构体中，并将usb_skel通过usb_set_intfdata传为USB接口的私有数据，最后注册USB设备。
我们来看看这个USB骨架程序定义的usb_skel结构体
struct usb_skel {
struct usb_device *udev; //该设备的usb_device指针
struct usb_interface *interface; //该设备的usb_interface指针
struct semaphore limit_sem; //限制进程写的数量
struct usb_anchor submitted;
struct urb *bulk_in_urb;
unsigned char *bulk_in_buffer; //接收数据缓冲区
size_t bulk_in_size; //接收数据大小
size_t bulk_in_filled;
size_t bulk_in_copied;
__u8 bulk_in_endpointAddr; //批量输入端点地址
__u8 bulk_out_endpointAddr; //批量输出端点地址
int errors;
int open_count;
bool ongoing_read;
bool processed_urb;
spinlock_t err_lock;
struct kref kref;
struct mutex io_mutex;
struct completion bulk_in_completion; //完成量
};
好了看完了probe，我们再看看disconnect函数
static void skel_disconnect(struct usb_interface *interface)
{
struct usb_skel *dev;
int minor = interface->minor; //获得接口的次设备号
dev = usb_get_intfdata(interface); //获取接口的私有数据
usb_set_intfdata(interface, NULL); //设置接口的私有数据为空
usb_deregister_dev(interface, &skel_class); //注销USB设备
mutex_lock(&dev->io_mutex);
dev->interface = NULL;
mutex_unlock(&dev->io_mutex);
usb_kill_anchored_urbs(&dev->submitted);
kref_put(&dev->kref, skel_delete);
dev_info(&interface->dev, "USB Skeleton #%d now disconnected", minor);
}
我们在skel_probe中最后执行了usb_register_dev(interface, &skel_class)来注册了一个USB设备，我们看看skel_class的定义
static struct usb_class_driver skel_class = {
.name = "skel%d",
.fops = &skel_fops,
.minor_base = USB_SKEL_MINOR_BASE,
};
static const struct file_operations skel_fops = {
.owner = THIS_MODULE,
.read = skel_read,
.write = skel_write,
.open = skel_open,
.release = skel_release,
.flush = skel_flush,
};
根据上面代码我们知道，其实我们在probe中注册USB设备的时候使用的skel_class是一个包含file_operations的结构体，而这个结构体正是字符设备文件操作结构体。
我们先来看看这个file_operations中open函数的实现
static int skel_open(struct inode *inode, struct file *file)
{
struct usb_skel *dev;
struct usb_interface *interface;
int subminor;
int retval = 0;
subminor = iminor(inode); //获得次设备号
//根据usb_driver和次设备号获取设备的接口
interface = usb_find_interface(&skel_driver, subminor);
if (!interface) {
err("%s - error, can't find device for minor %d",
__func__, subminor);
retval = -ENODEV;
goto exit;
}
dev = usb_get_intfdata(interface); //获取接口的私有数据usb_skel
if (!dev) {
retval = -ENODEV;
goto exit;
}
kref_get(&dev->kref);
mutex_lock(&dev->io_mutex);
if (!dev->open_count++) {
retval = usb_autopm_get_interface(interface);
if (retval) {
dev->open_count--;
mutex_unlock(&dev->io_mutex);
kref_put(&dev->kref, skel_delete);
goto exit;
}
}
file->private_data = dev; //将usb_skel设置为文件的私有数据
mutex_unlock(&dev->io_mutex);
exit:
return retval;
}
这个open函数实现非常简单，它根据usb_driver和次设备号通过usb_find_interface获取USB接口，然后通过usb_get_intfdata获得接口的私有数据并赋值给文件。
好了，我们看看write函数，在write函数中，我们进行了urb的分配、初始化和提交的操作
static ssize_t skel_write(struct file *file, const char *user_buffer,
size_t count, loff_t *ppos)
{
struct usb_skel *dev;
int retval = 0;
struct urb *urb = NULL;
char *buf = NULL;
size_t writesize = min(count, (size_t)MAX_TRANSFER); //待写数据大小
dev = (struct usb_skel *)file->private_data; //获取文件的私有数据
if (count == 0)
goto exit;
if (!file->f_flags & O_NONBLOCK) { //如果文件采用非阻塞方式
if (down_interruptible(&dev->limit_sem)) { //获取限制读的次数的信号量
retval = -ERESTARTSYS;
goto exit;
}
} else {
if (down_trylock(&dev->limit_sem)) {
retval = -EAGAIN;
goto exit;
}
}
spin_lock_irq(&dev->err_lock); //关中断
retval = dev->errors;
if (retval < 0) {
dev->errors = 0;
retval = (retval == -EPIPE) ? retval : -EIO;
}
spin_unlock_irq(&dev->err_lock); //开中断
if (retval < 0)
goto error;
urb = usb_alloc_urb(0, GFP_KERNEL); //分配urb
if (!urb) {
retval = -ENOMEM;
goto error;
}
buf = usb_buffer_alloc(dev->udev, writesize, GFP_KERNEL,
&urb->transfer_dma); //分配写缓冲区
if (!buf) {
retval = -ENOMEM;
goto error;
}
if (copy_from_user(buf, user_buffer, writesize)) { //将用户空间数据拷贝到缓冲区
retval = -EFAULT;
goto error;
}
mutex_lock(&dev->io_mutex);
if (!dev->interface) { /* disconnect() was called */
mutex_unlock(&dev->io_mutex);
retval = -ENODEV;
goto error;
}
usb_fill_bulk_urb(urb, dev->udev,
usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
buf, writesize, skel_write_bulk_callback, dev); //填充urb
urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; //urb->transfer_dma有效 usb_anchor_urb(urb, &dev->submitted);
retval = usb_submit_urb(urb, GFP_KERNEL); //提交urb
mutex_unlock(&dev->io_mutex);
if (retval) {
err("%s - failed submitting write urb, error %d", __func__,
retval);
goto error_unanchor;
}
usb_free_urb(urb);
return writesize;
error_unanchor:
usb_unanchor_urb(urb);
error:
if (urb) {
usb_buffer_free(dev->udev, writesize, buf, urb->transfer_dma);
usb_free_urb(urb);
}
up(&dev->limit_sem);
exit:
return retval;
}
首先说明一个问题，填充urb后，设置了transfer_flags标志，当transfer_flags中的URB_NO_TRANSFER_DMA_MAP被设置，USB核心使用transfer_dma指向的缓冲区而不是使用transfer_buffer指向的缓冲区，这表明即将传输DMA缓冲区。当transfer_flags中的URB_NO_SETUP_DMA_MAP被设置，如果控制urb有DMA缓冲区，USB核心将使用setup_dma指向的缓冲区而不是使用setup_packet指向的缓冲区。
另外，通过上面这个write函数我们知道，当写函数发起的urb结束后，其完成函数skel_write_bulk_callback会被调用，我们继续跟踪
static void skel_write_bulk_callback(struct urb *urb)
{
struct usb_skel *dev;
dev = urb->context;
if (urb->status) {
if (!(urb->status == -ENOENT ||
urb->status == -ECONNRESET ||
urb->status == -ESHUTDOWN))
err("%s - nonzero write bulk status received: %d",
__func__, urb->status); //出错显示
spin_lock(&dev->err_lock);
dev->errors = urb->status;
spin_unlock(&dev->err_lock);
}
usb_buffer_free(urb->dev, urb->transfer_buffer_length,
urb->transfer_buffer, urb->transfer_dma); //释放urb空间
up(&dev->limit_sem);
}
很明显，skel_write_bulk_callback主要对urb->status进行判断，根据错误提示显示错误信息，然后释放urb空间。
接着，我们看看USB骨架程序的字符设备的read函数
static ssize_t skel_read(struct file *file, char *buffer, size_t count,
loff_t *ppos)
{
struct usb_skel *dev;
int rv;
bool ongoing_io;
dev = (struct usb_skel *)file->private_data; //获得文件私有数据
if (!dev->bulk_in_urb || !count) //正在写的时候禁止读操作
return 0;
rv = mutex_lock_interruptible(&dev->io_mutex); //获得锁
if (rv < 0)
return rv;
if (!dev->interface) {
rv = -ENODEV;
goto exit;
}
retry:
spin_lock_irq(&dev->err_lock);
ongoing_io = dev->ongoing_read;
spin_unlock_irq(&dev->err_lock);
if (ongoing_io) { //USB核正在读取数据中，数据没准备好
if (file->f_flags & O_NONBLOCK) { //如果为非阻塞，则结束
rv = -EAGAIN;
goto exit;
}
rv = wait_for_completion_interruptible(&dev->bulk_in_completion); //等待
if (rv < 0)
goto exit;
dev->bulk_in_copied = 0; //拷贝到用户空间操作已成功
dev->processed_urb = 1; //目前已处理好urb
}
if (!dev->processed_urb) { //目前还没已处理好urb
wait_for_completion(&dev->bulk_in_completion); //等待完成
dev->bulk_in_copied = 0; //拷贝到用户空间操作已成功
dev->processed_urb = 1; //目前已处理好urb
}
rv = dev->errors;
if (rv < 0) {
dev->errors = 0;
rv = (rv == -EPIPE) ? rv : -EIO;
dev->bulk_in_filled = 0;
goto exit;
}
if (dev->bulk_in_filled) { //缓冲区有内容
//可读数据大小为缓冲区内容减去已经拷贝到用户空间的数据大小
size_t available = dev->bulk_in_filled - dev->bulk_in_copied;
size_t chunk = min(available, count); //真正读取数据大小
if (!available) {
rv = skel_do_read_io(dev, count); //没可读数据则调用IO操作
if (rv < 0)
goto exit;
else
goto retry;
}
//拷贝缓冲区数据到用户空间
if (copy_to_user(buffer, dev->bulk_in_buffer + dev->bulk_in_copied,chunk)) rv = -EFAULT;
else
rv = chunk;
dev->bulk_in_copied += chunk; //目前拷贝完成的数据大小
if (available < count) //剩下可用数据小于用户需要的数据
skel_do_read_io(dev, count - chunk); //调用IO操作
} else {
rv = skel_do_read_io(dev, count); //缓冲区没数据则调用IO操作
if (rv < 0)
goto exit;
else if (!file->f_flags & O_NONBLOCK)
goto retry;
rv = -EAGAIN;
}
exit:
mutex_unlock(&dev->io_mutex);
return rv;
}
通过上面read函数，我们知道，在读取数据时候，如果发现缓冲区没有数据，或者缓冲区的数据小于用户需要读取的数据量时，则会调用IO操作，也就是skel_do_read_io函数。
static int skel_do_read_io(struct usb_skel *dev, size_t count)
{
int rv;
usb_fill_bulk_urb(dev->bulk_in_urb,dev->udev,usb_rcvbulkpipe(dev->udev,
dev->bulk_in_endpointAddr),dev->bulk_in_buffer,
min(dev->bulk_in_size, count),skel_read_bulk_callback,dev); //填充urb
spin_lock_irq(&dev->err_lock);
dev->ongoing_read = 1; //标志正在读取数据中
spin_unlock_irq(&dev->err_lock);
rv = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL); //提交urb
if (rv < 0) {
err("%s - failed submitting read urb, error %d",
__func__, rv);
dev->bulk_in_filled = 0;
rv = (rv == -ENOMEM) ? rv : -EIO;
spin_lock_irq(&dev->err_lock);
dev->ongoing_read = 0;
spin_unlock_irq(&dev->err_lock);
}
return rv;
}
好了，其实skel_do_read_io只是完成了urb的填充和提交，USB核心读取到了数据后，会调用填充urb时设置的回调函数skel_read_bulk_callback。
static void skel_read_bulk_callback(struct urb *urb)
{
struct usb_skel *dev;
dev = urb->context;
spin_lock(&dev->err_lock);
if (urb->status) { //根据返回状态判断是否出错
if (!(urb->status == -ENOENT ||
urb->status == -ECONNRESET ||
urb->status == -ESHUTDOWN))
err("%s - nonzero write bulk status received: %d",
__func__, urb->status);
dev->errors = urb->status;
} else {
dev->bulk_in_filled = urb->actual_length; //记录缓冲区的大小
}
dev->ongoing_read = 0; //已经读取数据完毕
spin_unlock(&dev->err_lock);
complete(&dev->bulk_in_completion); //唤醒skel_read函数
}
好了，到目前为止，我们已经把USB驱动框架usb-skeleton.c分析完了，总结下，其实很简单，在模块加载里面注册usb_driver，然后在probe函数里初始化一些参数，最重要的是注册了USB设备，这个USB设备相当于一个字符设备，提供file_operations接口。然后设计open，close，read，write函数，这个open里基本没做什么事情，在write中，通过分配urb、填充urb和提交urb。注意读的urb的分配在probe里申请空间，写的urb的分配在write里申请空间。在这个驱动程序中，我们重点掌握usb_fill_bulk_urb的设计。