linxu_usb驅動之框架
USB骨架程序可以被看做一個最簡單的USB設備驅動的實例。
首先看看USB骨架程序的usb_driver的定義
[cpp] view plain copy
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,
};
[cpp] view plain copy
/* Define these values to match your devices */
#define USB_SKEL_VENDOR_ID 0xfff0
#define USB_SKEL_PRODUCT_ID 0xfff0
/* table of devices that work with this driver */
static const struct usb_device_id skel_table[] = {
{ USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
{ } /* Terminating entry */
};
MODULE_DEVICE_TABLE(usb, skel_table);
由上面代碼可見，通過USB_DEVICE宏定義了設備支持項。
對上面usb_driver的注冊和注銷發送在USB骨架程序的模塊加載和卸載函數中。
[cpp] view plain copy
static int __init usb_skel_init(void)
{
int result;
/* register this driver with the USB subsystem */
result = usb_register(&skel_driver); //將該驅動掛在USB總線上
if (result)
err("usb_register failed. Error number %d", result);
return result;
}
一個設備被安裝或者有設備插入后，當USB總線上經過match匹配成功，就會調用設備驅動程序中的probe探測函數，向探測函數傳遞設備的信息，以便確定驅動程序是否支持該設備。
[cpp] view plain copy
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;
/* allocate memory for our device state and initialize it */
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結構體
/* set up the endpoint information */
/* use only the first bulk-in and bulk-out endpoints */
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)) { //如果端點為批量輸入端點
/* we found a 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)) { //如果端點為批量輸出端點
/* 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;
}
/* save our data pointer in this interface device */
usb_set_intfdata(interface, dev); //將特定設備結構體設置為接口的私有數據
/* we can register the device now, as it is ready */
retval = usb_register_dev(interface, &skel_class); //注冊USB設備
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;
}
/* let the user know what node this device is now attached to */
dev_info(&interface->dev,
"USB Skeleton device now attached to USBSkel-%d",
interface->minor);
return 0;
error:
if (dev)
/* this frees allocated memory */
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結構體
[cpp] view plain copy
/* Structure to hold all of our device specific stuff */
struct usb_skel {
struct usb_device *udev; /* the usb device for this device */
struct usb_interface *interface; /* the interface for this device */
struct semaphore limit_sem; /* limiting the number of writes in progress */
struct usb_anchor submitted; /* in case we need to retract our submissions */
struct urb *bulk_in_urb; /* the urb to read data with */
unsigned char *bulk_in_buffer; /* the buffer to receive data */
size_t bulk_in_size; /* the size of the receive buffer */
size_t bulk_in_filled; /* number of bytes in the buffer */
size_t bulk_in_copied; /* already copied to user space */
__u8 bulk_in_endpointAddr; /* the address of the bulk in endpoint */
__u8 bulk_out_endpointAddr; /* the address of the bulk out endpoint */
int errors; /* the last request tanked */
int open_count; /* count the number of openers */
bool ongoing_read; /* a read is going on */
bool processed_urb; /* indicates we haven't processed the urb */
spinlock_t err_lock; /* lock for errors */
struct kref kref;
struct mutex io_mutex; /* synchronize I/O with disconnect */
struct completion bulk_in_completion; /* to wait for an ongoing read */
};
#define to_skel_dev(d) container_of(d, struct usb_skel, kref)
好了看完了probe，我們再看看disconnect函數
[cpp] view plain copy
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); //設置接口的私有數據為空
/* give back our minor */
usb_deregister_dev(interface, &skel_class); //注銷USB設備
/* prevent more I/O from starting */
mutex_lock(&dev->io_mutex);
dev->interface = NULL;
mutex_unlock(&dev->io_mutex);
usb_kill_anchored_urbs(&dev->submitted);
/* decrement our usage count */
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的定義
[cpp] view plain copy
/*
* usb class driver info in order to get a minor number from the usb core,
* and to have the device registered with the driver core
*/
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,
.llseek = noop_llseek,
};
根據上面代碼我們知道，其實我們在probe中注冊USB設備的時候使用的skel_class是一個包含file_operations的結構體，而這個結構體正是字符設備文件操作結構體。
我們先來看看這個file_operations中open函數的實現
[cpp] view plain copy
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_ske
if (!dev) {
retval = -ENODEV;
goto exit;
}
/* increment our usage count for the device */
kref_get(&dev->kref);
/* lock the device to allow correctly handling errors
* in resumption */
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;
}
} /* else { //uncomment this block if you want exclusive open
retval = -EBUSY;
dev->open_count--;
mutex_unlock(&dev->io_mutex);
kref_put(&dev->kref, skel_delete);
goto exit;
} */
/* prevent the device from being autosuspended */
/* save our object in the file's private structure */
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的分配、初始化和提交的操作
[cpp] view plain copy
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 = file->private_data; //獲取文件的私有數據
/* verify that we actually have some data to write */
if (count == 0)
goto exit;
/*
* limit the number of URBs in flight to stop a user from using up all
* RAM
*/
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) {
/* any error is reported once */
dev->errors = 0;
/* to preserve notifications about reset */
retval = (retval == -EPIPE) ? retval : -EIO;
}
spin_unlock_irq(&dev->err_lock); //開中斷
if (retval < 0)
goto error;
/* create a urb, and a buffer for it, and copy the data to the urb */
urb = usb_alloc_urb(0, GFP_KERNEL); //分配urb
if (!urb) {
retval = -ENOMEM;
goto error;
}
buf = usb_alloc_coherent(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;
}
/* this lock makes sure we don't submit URBs to gone devices */
mutex_lock(&dev->io_mutex);
if (!dev->interface) { /* disconnect() was called */
mutex_unlock(&dev->io_mutex);
retval = -ENODEV;
goto error;
}
/* initialize the urb properly */
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);
/* send the data out the bulk port */
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;
}
/*
* release our reference to this urb, the USB core will eventually free
* it entirely
*/
usb_free_urb(urb);
return writesize;
error_unanchor:
usb_unanchor_urb(urb);
error:
if (urb) {
usb_free_coherent(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會被調用，我們繼續跟蹤
[cpp] view plain copy
static void skel_write_bulk_callback(struct urb *urb)
{
struct usb_skel *dev;
dev = urb->context;
/* sync/async unlink faults aren't errors */
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);
}
/* free up our allocated buffer */
usb_free_coherent(urb->dev, urb->transfer_buffer_length,
urb->transfer_buffer, urb->transfer_dma);
up(&dev->limit_sem);
}
很明顯，skel_write_bulk_callback主要對urb->status進行判斷，根據錯誤提示顯示錯誤信息，然后釋放urb空間。
接着，我們看看USB骨架程序的字符設備的read函數
[cpp] view plain copy
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 = file->private_data; //獲得文件私有數據
/* if we cannot read at all, return EOF */
if (!dev->bulk_in_urb || !count) //正在寫的時候禁止讀操作
return 0;
/* no concurrent readers */
rv = mutex_lock_interruptible(&dev->io_mutex);
if (rv < 0)
return rv;
if (!dev->interface) { /* disconnect() was called */
rv = -ENODEV;
goto exit;
}
/* if IO is under way, we must not touch things */
retry:
spin_lock_irq(&dev->err_lock);
ongoing_io = dev->ongoing_read;
spin_unlock_irq(&dev->err_lock);
if (ongoing_io) { //USB core正在讀取數據，數據沒准備好
/* nonblocking IO shall not wait */
if (file->f_flags & O_NONBLOCK) {
rv = -EAGAIN;
goto exit;
}
/*
* IO may take forever
* hence wait in an interruptible state
*/
rv = wait_for_completion_interruptible(&dev->bulk_in_completion);
if (rv < 0)
goto exit;
/*
* by waiting we also semiprocessed the urb
* we must finish now
*/
dev->bulk_in_copied = 0; //拷貝到用戶空間操作已成功
dev->processed_urb = 1; //目前已處理好urb
}
if (!dev->processed_urb) { //目前還未處理好urb
/*
* the URB hasn't been processed
* do it now
*/
wait_for_completion(&dev->bulk_in_completion); //等待完成
dev->bulk_in_copied = 0; //拷貝到用戶空間操作已成功
dev->processed_urb = 1; //目前已處理好urb
}
/* errors must be reported */
rv = dev->errors;
if (rv < 0) {
/* any error is reported once */
dev->errors = 0;
/* to preserve notifications about reset */
rv = (rv == -EPIPE) ? rv : -EIO;
/* no data to deliver */
dev->bulk_in_filled = 0;
/* report it */
goto exit;
}
/*
* if the buffer is filled we may satisfy the read
* else we need to start IO
*/
if (dev->bulk_in_filled) { //緩沖區有內容
/* we had read data */
//可讀數據大小為緩沖區內容減去已經拷貝到用戶空間的數據大小
size_t available = dev->bulk_in_filled - dev->bulk_in_copied;
size_t chunk = min(available, count); //真正讀取的數據大小
if (!available) {
/*
* all data has been used
* actual IO needs to be done
*/
rv = skel_do_read_io(dev, count);
if (rv < 0)
goto exit;
else
goto retry;
}
/*
* data is available
* chunk tells us how much shall be copied
*/
//拷貝緩沖區數據到用戶空間
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 we are asked for more than we have,
* we start IO but don't wait
*/
if (available < count)
skel_do_read_io(dev, count - chunk);
} else {
/* no data in the buffer */
rv = skel_do_read_io(dev, count);
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函數。
[cpp] view plain copy
static int skel_do_read_io(struct usb_skel *dev, size_t count)
{
int rv;
/* prepare a read */
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
/* tell everybody to leave the URB alone */
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 core讀取到了數據后，會調用填充urb時設置的回調函數skel_read_bulk_callback。
[cpp] view plain copy
static void skel_read_bulk_callback(struct urb *urb)
{
struct usb_skel *dev;
dev = urb->context;
spin_lock(&dev->err_lock);
/* sync/async unlink faults aren't errors */
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的設計。
linxu_usb驅動之鼠標驅動
原文鏈接：http://www.linuxidc.com/Linux/2012-12/76197p7.htm
drivers/hid/usbhid/usbmouse.c
下面我們分析下USB鼠標驅動，鼠標輸入HID類型，其數據傳輸采用中斷URB，鼠標端點類型為IN。我們先看看這個驅動的模塊加載部分。
[cpp] view plain copy
static int __init usb_mouse_init(void)
{
int retval = usb_register(&usb_mouse_driver);
if (retval == 0)
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
DRIVER_DESC "\n");
return retval;
}
模塊加載部分仍然是調用usb_register注冊USB驅動，我們跟蹤看看被注冊的usb_mouse_driver
[cpp] view plain copy
static struct usb_driver usb_mouse_driver = {
.name = "usbmouse", //驅動名
.probe = usb_mouse_probe,
.disconnect = usb_mouse_disconnect,
.id_table = usb_mouse_id_table, //支持項
};
關於設備支持項我們前面已經討論過了
[cpp] view plain copy
static struct usb_device_id usb_mouse_id_table [] = {
{ USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
USB_INTERFACE_PROTOCOL_MOUSE) },
{ } /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, usb_mouse_id_table);
再細細看看USB_INTERFACE_INFO宏的定義
[cpp] view plain copy
/**
* USB_INTERFACE_INFO - macro used to describe a class of usb interfaces
* @cl: bInterfaceClass value
* @sc: bInterfaceSubClass value
* @pr: bInterfaceProtocol value
*
* This macro is used to create a struct usb_device_id that matches a
* specific class of interfaces.
*/
#define USB_INTERFACE_INFO(cl, sc, pr) \
.match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \
.bInterfaceClass = (cl), \
.bInterfaceSubClass = (sc), \
.bInterfaceProtocol = (pr)
根據宏，我們知道，我們設置的支持項包括接口類，接口子類，接口協議三個匹配項。
主要看看usb_driver中定義的probe函數
[cpp] view plain copy
static int usb_mouse_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
struct usb_device *dev = interface_to_usbdev(intf);//由接口獲取usb_dev
struct usb_host_interface *interface;
struct usb_endpoint_descriptor *endpoint;
struct usb_mouse *mouse; //該驅動私有結構體
struct input_dev *input_dev; //輸入結構體
int pipe, maxp;
int error = -ENOMEM;
interface = intf->cur_altsetting; //獲取設置
if (interface->desc.bNumEndpoints != 1) //鼠標端點只有1個
return -ENODEV;
endpoint = &interface->endpoint[0].desc; //獲取端點描述符
if (!usb_endpoint_is_int_in(endpoint)) //檢查該端點是否是中斷輸入端點
return -ENODEV;
pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress); //建立中斷輸入端點
maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe)); //端點能傳輸的最大數據包(Mouse為4個)
mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL); //分配usb_mouse結構體
input_dev = input_allocate_device(); //分配input設備空間
if (!mouse || !input_dev)
goto fail1;
mouse->data = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &mouse->data_dma); //分配緩沖區
if (!mouse->data)
goto fail1;
mouse->irq = usb_alloc_urb(0, GFP_KERNEL); //分配urb
if (!mouse->irq)
goto fail2;
mouse->usbdev = dev; //填充mouse的usb_device結構體
mouse->dev = input_dev; //填充mouse的input結構體
if (dev->manufacturer) //復制廠商ID
strlcpy(mouse->name, dev->manufacturer, sizeof(mouse->name));
if (dev->product) { //復制產品ID
if (dev->manufacturer)
strlcat(mouse->name, " ", sizeof(mouse->name));
strlcat(mouse->name, dev->product, sizeof(mouse->name));
}
if (!strlen(mouse->name))
snprintf(mouse->name, sizeof(mouse->name),
"USB HIDBP Mouse %04x:%04x",
le16_to_cpu(dev->descriptor.idVendor),
le16_to_cpu(dev->descriptor.idProduct));
usb_make_path(dev, mouse->phys, sizeof(mouse->phys));
strlcat(mouse->phys, "/input0", sizeof(mouse->phys)); //獲取usb_mouse的設備節點
input_dev->name = mouse->name; //將鼠標名賦給內嵌input結構體
input_dev->phys = mouse->phys; //將鼠標設備節點名賦給內嵌input結構體
usb_to_input_id(dev, &input_dev->id); //將usb_driver的支持項拷貝給input
input_dev->dev.parent = &intf->dev;
input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); //支持按鍵事件和相對坐標事件
input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE); //表明按鍵值包括左鍵、中鍵和右鍵
input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y); //表明相對坐標包括X坐標和Y坐標
input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
BIT_MASK(BTN_EXTRA); //表明除了左鍵、右鍵和中鍵，還支持其他按鍵
input_dev->relbit[0] |= BIT_MASK(REL_WHEEL); //表明還支持中鍵滾輪的滾動值
input_set_drvdata(input_dev, mouse); //將mouse設為input的私有數據
input_dev->open = usb_mouse_open; //input設備的open操作函數
input_dev->close = usb_mouse_close;
usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,
(maxp > 8 ? 8 : maxp),
usb_mouse_irq, mouse, endpoint->bInterval); //填充urb
mouse->irq->transfer_dma = mouse->data_dma;
mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; //使用transfer_dma
error = input_register_device(mouse->dev); //注冊input設備
if (error)
goto fail3;
usb_set_intfdata(intf, mouse);
return 0;
fail3:
usb_free_urb(mouse->irq);
fail2:
usb_free_coherent(dev, 8, mouse->data, mouse->data_dma);
fail1:
input_free_device(input_dev);
kfree(mouse);
return error;
}
在探討probe實現的功能時，我們先看看urb填充函數usb_fill_int_urb
[cpp] view plain copy
/**
* usb_fill_int_urb - macro to help initialize a interrupt urb
* @urb: pointer to the urb to initialize.
* @dev: pointer to the struct usb_device for this urb.
* @pipe: the endpoint pipe
* @transfer_buffer: pointer to the transfer buffer
* @buffer_length: length of the transfer buffer
* @complete_fn: pointer to the usb_complete_t function
* @context: what to set the urb context to.
* @interval: what to set the urb interval to, encoded like
* the endpoint descriptor's bInterval value.
*
* Initializes a interrupt urb with the proper information needed to submit
* it to a device.
*
* Note that High Speed and SuperSpeed interrupt endpoints use a logarithmic
* encoding of the endpoint interval, and express polling intervals in
* microframes (eight per millisecond) rather than in frames (one per
* millisecond).
*
* Wireless USB also uses the logarithmic encoding, but specifies it in units of
* 128us instead of 125us. For Wireless USB devices, the interval is passed
* through to the host controller, rather than being translated into microframe
* units.
*/
static inline void usb_fill_int_urb(struct urb *urb,
struct usb_device *dev,
unsigned int pipe,
void *transfer_buffer,
int buffer_length,
usb_complete_t complete_fn,
void *context,
int interval)
{
urb->dev = dev;
urb->pipe = pipe;
urb->transfer_buffer = transfer_buffer;
urb->transfer_buffer_length = buffer_length;
urb->complete = complete_fn;
urb->context = context;
if (dev->speed == USB_SPEED_HIGH || dev->speed == USB_SPEED_SUPER)
urb->interval = 1 << (interval - 1);
else
urb->interval = interval;
urb->start_frame = -1;
}
其實probe主要是初始化usb設備和input設備，終極目標是為了完成urb的提交和input設備的注冊。由於注冊為input設備類型，那么當用戶層open打開設備時候，最終會調用input中的open實現打開，我們看看input中open的實現
[cpp] view plain copy
static int usb_mouse_open(struct input_dev *dev)
{
struct usb_mouse *mouse = input_get_drvdata(dev); //獲取私有數據
mouse->irq->dev = mouse->usbdev; //獲取utb指針
if (usb_submit_urb(mouse->irq, GFP_KERNEL)) //提交urb
return -EIO;
return 0;
}
當用戶層open打開這個USB鼠標后，我們就已經將urb提交給了USB core，那么根據USB數據處理流程知道，當處理完畢后，USB core會通知USB設備驅動程序，這里我們是響應中斷服務程序，這就相當於該URB的回調函數。我們在提交urb時候定義了中斷服務程序 usb_mouse_irq，我們跟蹤看看
[cpp] view plain copy
static void usb_mouse_irq(struct urb *urb)
{
struct usb_mouse *mouse = urb->context;
signed char *data = mouse->data;
struct input_dev *dev = mouse->dev;
int status;
switch (urb->status) {
case 0: /* success */
break;
case -ECONNRESET: /* unlink */
case -ENOENT:
case -ESHUTDOWN:
return;
/* -EPIPE: should clear the halt */
default: /* error */
goto resubmit; //數據處理沒成功，重新提交urb
}
input_report_key(dev, BTN_LEFT, data[0] & 0x01); //左鍵
input_report_key(dev, BTN_RIGHT, data[0] & 0x02); //
input_report_key(dev, BTN_MIDDLE, data[0] & 0x04); //
input_report_key(dev, BTN_SIDE, data[0] & 0x08); //
input_report_key(dev, BTN_EXTRA, data[0] & 0x10); //
input_report_rel(dev, REL_X, data[1]); //鼠標的水平位移
input_report_rel(dev, REL_Y, data[2]); //鼠標的垂直位移
input_report_rel(dev, REL_WHEEL, data[3]); //鼠標滾輪的滾動值
input_sync(dev); //同步事件，完成一次上報
resubmit:
status = usb_submit_urb (urb, GFP_ATOMIC); //再次提交urb，等待下次響應
if (status)
err ("can't resubmit intr, %s-%s/input0, status %d",
mouse->usbdev->bus->bus_name,
mouse->usbdev->devpath, status);
}
根據上面的中斷服務程序，我們應該知道，系統是周期性地獲取鼠標的事件信息，因此在URB回調函數的末尾再次提交URB請求塊，這樣又會調用新的回調函數，周而復始。在回調函數中提交URB只能是GFP_ATOMIC優先級，因為URB回調函數運行於中斷上下文中禁止導致睡眠的行為。而在提交URB 過程中可能會需要申請內存、保持信號量，這些操作或許會導致USB內核睡眠。
最后我們再看看這個驅動的私有數據mouse的定義
[cpp] view plain copy
struct usb_mouse {
char name[128]; //名字
char phys[64]; //設備節點
struct usb_device *usbdev; //內嵌usb_device設備
struct input_dev *dev; //內嵌input_dev設備
struct urb *irq; //urb結構體
signed char *data; //transfer_buffer緩沖區
dma_addr_t data_dma; //transfer _dma緩沖區
};
在上面這個結構體中，每一個成員的作用都應該很清楚了，尤其最后兩個的使用區別和作用，前面也已經說過。
如果最終需要測試這個USB鼠標驅動，需要在內核中配置USB支持、對HID接口的支持、對OHCI HCD驅動的支持。另外，將驅動移植到開發板之后，由於采用的是input設備模型，所以還需要開發板帶LCD屏才能測試。
Linux_
usb驅動之鍵盤驅動
跟USB鼠標類型一樣，USB鍵盤也屬於HID類型，代碼在/dirver/hid/usbhid/usbkbd.c下。USB鍵盤除了提交中斷URB外，還需要提交控制URB。不多話，我們看代碼
[cpp] view plain copy
static int __init usb_kbd_init(void)
{
int result = usb_register(&usb_kbd_driver);
if (result == 0)
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
DRIVER_DESC "\n");
return result;
}
[cpp] view plain copy
static struct usb_driver usb_kbd_driver = {
.name = "usbkbd",
.probe = usb_kbd_probe,
.disconnect = usb_kbd_disconnect,
.id_table = usb_kbd_id_table, //驅動設備ID表,用來指定設備或接口
};
下面跟蹤usb_driver中的probe
[cpp] view plain copy
static int usb_kbd_probe(struct usb_interface *iface,
const struct usb_device_id *id)
{
struct usb_device *dev = interface_to_usbdev(iface); //通過接口獲取USB設備指針
struct usb_host_interface *interface; //設置
struct usb_endpoint_descriptor *endpoint; //端點描述符
struct usb_kbd *kbd; //usb_kbd私有數據
struct input_dev *input_dev; //input設備
int i, pipe, maxp;
int error = -ENOMEM;
interface = iface->cur_altsetting; //獲取設置
if (interface->desc.bNumEndpoints != 1) //與mouse一樣只有一個端點
return -ENODEV;
endpoint = &interface->endpoint[0].desc; //獲取端點描述符
if (!usb_endpoint_is_int_in(endpoint)) //檢查端點是否為中斷輸入端點
return -ENODEV;
pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress); //將endpoint設置為中斷IN端點
maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe)); //端點傳輸的最大數據包
kbd = kzalloc(sizeof(struct usb_kbd), GFP_KERNEL); //分配urb
input_dev = input_allocate_device(); //分配input設備空間
if (!kbd || !input_dev)
goto fail1;
if (usb_kbd_alloc_mem(dev, kbd)) //分配urb空間和其他緩沖區
goto fail2;
kbd->usbdev = dev; //給內嵌結構體賦值
kbd->dev = input_dev;
if (dev->manufacturer) //拷貝廠商ID
strlcpy(kbd->name, dev->manufacturer, sizeof(kbd->name));
if (dev->product) { //拷貝產品ID
if (dev->manufacturer)
strlcat(kbd->name, " ", sizeof(kbd->name));
strlcat(kbd->name, dev->product, sizeof(kbd->name));
}
if (!strlen(kbd->name)) //檢測不到廠商名字
snprintf(kbd->name, sizeof(kbd->name),
"USB HIDBP Keyboard %04x:%04x",
le16_to_cpu(dev->descriptor.idVendor),
le16_to_cpu(dev->descriptor.idProduct));
//設備鏈接地址
usb_make_path(dev, kbd->phys, sizeof(kbd->phys));
strlcat(kbd->phys, "/input0", sizeof(kbd->phys));
input_dev->name = kbd->name; //給input_dev結構體賦值
input_dev->phys = kbd->phys;
usb_to_input_id(dev, &input_dev->id); //拷貝usb_driver的支持給input,設置bustype,vendo,product等
input_dev->dev.parent = &iface->dev;
input_set_drvdata(input_dev, kbd); //將kbd設置為input的私有數據
input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) |
BIT_MASK(EV_REP); //支持的按鍵事件類型
input_dev->ledbit[0] = BIT_MASK(LED_NUML) | BIT_MASK(LED_CAPSL) |
BIT_MASK(LED_SCROLLL) | BIT_MASK(LED_COMPOSE) |
BIT_MASK(LED_KANA); //EV_LED事件支持的事件碼
for (i = 0; i < 255; i++)
set_bit(usb_kbd_keycode[i], input_dev->keybit); //EV_KEY事件支持的事件碼(即設置支持的鍵盤碼)
clear_bit(0, input_dev->keybit);
input_dev->event = usb_kbd_event; //定義event函數
input_dev->open = usb_kbd_open;
input_dev->close = usb_kbd_close;
usb_fill_int_urb(kbd->irq, dev, pipe,
kbd->new, (maxp > 8 ? 8 : maxp),
usb_kbd_irq, kbd, endpoint->bInterval);//填充中斷urb
kbd->irq->transfer_dma = kbd->new_dma;
kbd->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
kbd->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
kbd->cr->bRequest = 0x09;//設置控制請求的格式
kbd->cr->wValue = cpu_to_le16(0x200);
kbd->cr->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
kbd->cr->wLength = cpu_to_le16(1);
usb_fill_control_urb(kbd->led, dev, usb_sndctrlpipe(dev, 0),
(void *) kbd->cr, kbd->leds, 1,
usb_kbd_led, kbd);//填充控制urb
kbd->led->transfer_dma = kbd->leds_dma;
kbd->led->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
error = input_register_device(kbd->dev);
if (error)
goto fail2;
usb_set_intfdata(iface, kbd);
device_set_wakeup_enable(&dev->dev, 1);
return 0;
fail2:
usb_kbd_free_mem(dev, kbd);
fail1:
input_free_device(input_dev);
kfree(kbd);
return error;
}
在上面的probe中，我們主要是初始化一些結構體，然后提交中斷urb和控制urb，並注冊input設備。其中有幾個地方需要細看下，其一，usb_kbd_alloc_mem的實現。其二，設置控制請求的格式。
先來看看usb_kbd_alloc_mem的實現
[cpp] view plain copy
static int usb_kbd_alloc_mem(struct usb_device *dev, struct usb_kbd *kbd)
{
if (!(kbd->irq = usb_alloc_urb(0, GFP_KERNEL))) //分配中斷urb
return -1;
if (!(kbd->led = usb_alloc_urb(0, GFP_KERNEL))) //分配控制urb
return -1;
if (!(kbd->new = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &kbd->new_dma)))
return -1; //分配中斷urb使用的緩沖區
if (!(kbd->cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
return -1; //分配控制urb使用的控制請求描述符
if (!(kbd->leds = usb_alloc_coherent(dev, 1, GFP_ATOMIC, &kbd->leds_dma)))
return -1; //分配控制urb使用的緩沖區
return 0;
}
這里我們需要明白中斷urb和控制urb需要分配不同的urb結構體，同時在提交urb之前，需要填充的內容也不同，中斷urb填充的是緩沖區和中斷處理函數，控制urb填充的是控制請求描述符與回調函數。
設置控制請求的格式。cr是struct usb_ctrlrequest結構的指針，USB協議中規定一個控制請求的格式為一個8個字節的數據包，其定義如下
[cpp] view plain copy
/**
* struct usb_ctrlrequest - SETUP data for a USB device control request
* @bRequestType: matches the USB bmRequestType field
* @bRequest: matches the USB bRequest field
* @wValue: matches the USB wValue field (le16 byte order)
* @wIndex: matches the USB wIndex field (le16 byte order)
* @wLength: matches the USB wLength field (le16 byte order)
*
* This structure is used to send control requests to a USB device. It matches
* the different fields of the USB 2.0 Spec section 9.3, table 9-2. See the
* USB spec for a fuller description of the different fields, and what they are
* used for.
*
* Note that the driver for any interface can issue control requests.
* For most devices, interfaces don't coordinate with each other, so
* such requests may be made at any time.
*/
struct usb_ctrlrequest {
__u8 bRequestType; //設定傳輸方向、請求類型等
__u8 bRequest; //指定哪個請求，可以是規定的標准值也可以是廠家定義的值
__le16 wValue; //即將寫到寄存器的數據
__le16 wIndex; //接口數量，也就是寄存器的偏移地址
__le16 wLength; //數據傳輸階段傳輸多少個字節
} __attribute__ ((packed));
USB協議中規定，所有的USB設備都會響應主機的一些請求，這些請求來自USB主機控制器，主機控制器通過設備的默認控制管道發出這些請求。默認的管道為0號端口對應的那個管道。
同樣這個input設備首先由用戶層調用open函數，所以先看看input中定義的open
[cpp] view plain copy
static int usb_kbd_open(struct input_dev *dev)
{
struct usb_kbd *kbd = input_get_drvdata(dev);
kbd->irq->dev = kbd->usbdev;
if (usb_submit_urb(kbd->irq, GFP_KERNEL))
return -EIO;
return 0;
}
因為這個驅動里面有一個中斷urb一個控制urb，我們先看中斷urb的處理流程。中斷urb在input的open中被提交后，當USB core處理完畢，會通知這個USB設備驅動，然后執行回調函數，也就是中斷處理函數usb_kbd_irq
[cpp] view plain copy
static void usb_kbd_irq(struct urb *urb)
{
struct usb_kbd *kbd = urb->context;
int i;
switch (urb->status) {
case 0: /* success */
break;
case -ECONNRESET: /* unlink */
case -ENOENT:
case -ESHUTDOWN:
return;
/* -EPIPE: should clear the halt */
default: /* error */
goto resubmit;
}
//報告usb_kbd_keycode[224..231]8按鍵狀態
//KEY_LEFTCTRL,KEY_LEFTSHIFT,KEY_LEFTALT,KEY_LEFTMETA,
//KEY_RIGHTCTRL,KEY_RIGHTSHIFT,KEY_RIGHTALT,KEY_RIGHTMETA
for (i = 0; i < 8; i++)
input_report_key(kbd->dev, usb_kbd_keycode[i + 224], (kbd->new[0] >> i) & 1);
//若同時只按下1個按鍵則在第[2]個字節,若同時有兩個按鍵則第二個在第[3]字節，類推最多可有6個按鍵同時按下
for (i = 2; i < 8; i++) {
//獲取鍵盤離開的中斷
//同時沒有該KEY的按下狀態
if (kbd->old[i] > 3 && memscan(kbd->new + 2, kbd->old[i], 6) == kbd->new + 8) {
if (usb_kbd_keycode[kbd->old[i]])
input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
else
hid_info(urb->dev,
"Unknown key (scancode %#x) released.\n",
kbd->old[i]);
}
//獲取鍵盤按下的中斷
//同時沒有該KEY的離開狀態
if (kbd->new[i] > 3 && memscan(kbd->old + 2, kbd->new[i], 6) == kbd->old + 8) {
if (usb_kbd_keycode[kbd->new[i]])
input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
else
hid_info(urb->dev,
"Unknown key (scancode %#x) released.\n",
kbd->new[i]);
}
}
input_sync(kbd->dev); //同步設備,告知事件的接收者驅動已經發出了一個完整的報告
memcpy(kbd->old, kbd->new, 8); //防止未松開時被當成新的按鍵處理
resubmit:
i = usb_submit_urb (urb, GFP_ATOMIC);
if (i)
hid_err(urb->dev, "can't resubmit intr, %s-%s/input0, status %d",
kbd->usbdev->bus->bus_name,
kbd->usbdev->devpath, i);
}
這個就是中斷urb的處理流程，跟前面講的的USB鼠標中斷處理流程類似。好了，我們再來看看剩下的控制urb處理流程吧。
我們有個疑問，我們知道在probe中，我們填充了中斷urb和控制urb，但是在input的open中，我們只提交了中斷urb，那么控制urb什么時候提交呢？
我們知道對於input子系統，如果有事件被響應，我們會調用事件處理層的event函數，而該函數最終調用的是input下的event。所以，對於input設備，我們在USB鍵盤驅動中只設置了支持LED選項，也就是ledbit項，這是怎么回事呢？剛才我們分析的那個中斷urb其實跟這個 input基本沒啥關系，中斷urb並不是像講鍵盤input實現的那樣屬於input下的中斷。我們在USB鍵盤驅動中的input子系統中只設計了 LED選項，那么當input子系統有按鍵選項的時候必然會使得內核調用調用事件處理層的event函數，最終調用input下的event。好了，那我們來看看input下的event干了些什么。
[cpp] view plain copy
static int usb_kbd_event(struct input_dev *dev, unsigned int type,
unsigned int code, int value)
{
struct usb_kbd *kbd = input_get_drvdata(dev);
if (type != EV_LED)//不支持LED事件
return -1;
//獲取指示燈的目標狀態
kbd->newleds = (!!test_bit(LED_KANA, dev->led) << 3) | (!!test_bit(LED_COMPOSE, dev->led) << 3) |
(!!test_bit(LED_SCROLLL, dev->led) << 2) | (!!test_bit(LED_CAPSL, dev->led) << 1) |
(!!test_bit(LED_NUML, dev->led));
if (kbd->led->status == -EINPROGRESS)
return 0;
//指示燈狀態已經是目標狀態則不需要再做任何操作
if (*(kbd->leds) == kbd->newleds)
return 0;
*(kbd->leds) = kbd->newleds;
kbd->led->dev = kbd->usbdev;
if (usb_submit_urb(kbd->led, GFP_ATOMIC))
pr_err("usb_submit_urb(leds) failed\n");
//提交控制urb
return 0;
}
當在input的event里提交了控制urb后，經過URB處理流程，最后返回給USB設備驅動的回調函數，也就是在probe中定義的usb_kbd_led
[cpp] view plain copy
static void usb_kbd_led(struct urb *urb)
{
struct usb_kbd *kbd = urb->context;
if (urb->status)
hid_warn(urb->dev, "led urb status %d received\n",
urb->status);
if (*(kbd->leds) == kbd->newleds)
return;
*(kbd->leds) = kbd->newleds;
kbd->led->dev = kbd->usbdev;
if (usb_submit_urb(kbd->led, GFP_ATOMIC))
hid_err(urb->dev, "usb_submit_urb(leds) failed\n");
}
總結下，我們的控制urb走的是先由input的event提交，觸發后由控制urb的回調函數再次提交。好了，通過USB鼠標，我們已經知道了控制urb和中斷urb的設計和處理流程。
<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">