Linux USB 驅動開發例項（二）—— USB 滑鼠驅動註解及測試
阿新 • • 發佈：2019-02-02
參考2.6.14版本中的driver/usb/input/usbmouse.c。滑鼠驅動可分為幾個部分：驅動載入部分、probe部分、open部分、urb回撥函式處理部分。
一、驅動載入部分
static int __init usb_mouse_init(void)
{
int retval = usb_register(&usb_mouse_driver);//註冊滑鼠驅動
if (retval == 0)
info(DRIVER_VERSION ":" DRIVER_DESC);
return retval;
}
static struct usb_driver usb_mouse_driver = { .owner = THIS_MODULE, .name = "usbmouse", .probe = usb_mouse_probe, .disconnect = usb_mouse_disconnect, .id_table = usb_mouse_id_table, };
如果註冊成功的話，將會呼叫usb_mouse_probe。那麼什麼時候才算註冊成功呢？
和其它驅動註冊過程一樣，只有在其對應的“匯流排”上發現匹配的“裝置”才會呼叫probe。匯流排匹配的方法和具體匯流排相關，如：platform_bus_type中是判斷驅動名稱和平臺裝置名稱是否相同；那如何確認usb匯流排的匹配方法呢？
Usb裝置是註冊在usb_bus_type匯流排下的。檢視usb_bus_type的匹配方法。
其中usb_device_match定義了匹配方法struct bus_type usb_bus_type = { .name = "usb", .match = usb_device_match, .hotplug = usb_hotplug, .suspend = usb_generic_suspend, .resume = usb_generic_resume, };
static int usb_device_match (struct device *dev, struct device_driver *drv) { struct usb_interface *intf; struct usb_driver *usb_drv; const struct usb_device_id *id; /* check for generic driver, which we don't match any device with */ if (drv == &usb_generic_driver) return 0; intf = to_usb_interface(dev); usb_drv = to_usb_driver(drv); id = usb_match_id (intf, usb_drv->id_table); if (id) return 1; return 0; }
可以看出usb的匹配方法是usb_match_id (intf, usb_drv->id_table)，也就是說通過比對“dev中intf資訊”和“usb_drv->id_table資訊”，如果匹配則說明驅動所對應的裝置已經新增到總線上了，所以接下了就會呼叫drv中的probe方法註冊usb裝置驅動。
usb_mouse_id_table的定義為：
static struct usb_device_id usb_mouse_id_table[] = {
{ USB_INTERFACE_INFO(3, 1, 2) },
{ } /* Terminating entry */
};
#define USB_INTERFACE_INFO(cl,sc,pr) /
.match_flags = USB_DEVICE_ID_MATCH_INT_INFO, /
.bInterfaceClass = (cl), /
.bInterfaceSubClass = (sc), /
.bInterfaceProtocol = (pr)滑鼠裝置遵循USB人機介面裝置（HID），在HID規範中規定滑鼠介面類碼為：
介面類：0x03
介面子類：0x01
介面協議：0x02
這樣分類的好處是裝置廠商可以直接利用標準的驅動程式。除了HID類以外還有Mass storage、printer、audio等
#define USB_DEVICE_ID_MATCH_INT_INFO /
(USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)匹配的過程為：
usb_match_id(struct usb_interface *interface, const struct usb_device_id *id)
{
struct usb_host_interface *intf;
struct usb_device *dev;
/* proc_connectinfo in devio.c may call us with id == NULL. */
if (id == NULL)
return NULL;
intf = interface->cur_altsetting;
dev = interface_to_usbdev(interface);
/* It is important to check that id->driver_info is nonzero,
since an entry that is all zeroes except for a nonzero
id->driver_info is the way to create an entry that
indicates that the driver want to examine every
device and interface. */
for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass ||
id->driver_info; id++) {
if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
continue;
/* No need to test id->bcdDevice_lo != 0, since 0 is never greater than any unsigned number. */
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
(id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
(id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
(id->bDeviceClass != dev->descriptor.bDeviceClass))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
(id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
(id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
continue;
//介面類
if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
(id->bInterfaceClass != intf->desc.bInterfaceClass))
continue;
//介面子類
if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
(id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
continue;
//遵循的協議
if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
(id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
continue;
return id;
}
return NULL;
}
二、probe部分
static int usb_mouse_probe(struct usb_interface * intf, const struct usb_device_id * id)
{
struct usb_device * dev = interface_to_usbdev(intf);
struct usb_host_interface *interface;
struct usb_endpoint_descriptor *endpoint;
struct usb_mouse *mouse;
int pipe, maxp;
char path[64];
interface = intf->cur_altsetting;
/* 以下是網路的一段對cur_altsettin的解釋，下面就借花獻佛。usb 裝置有一個configuration 的概念,表示配置，一個裝置可以有多個配置，但只能同時啟用一個，如：一些裝置可以下載韌體，或可以設定不同的全域性模式，就像手機可以被設定為靜音模式或響鈴模式一樣。而這裡又有一個setting,咋一看有些奇怪,這兩個詞不是一回事嗎.還是拿我們最熟悉的手機來打比方,configuration 不說了,setting,一個手機可能各種配置都確定了,是振動還是鈴聲已經確定了,各種功能都確定了,但是聲音的大小還可以變吧,通常手機的音量是一格一格的變動,大概也就5,6 格,那麼這個可以算一個setting 吧.這裡cur_altsetting 就是表示的當前的這個setting,或者說設定。可以檢視原碼中usb_interface 結構定義的說明部分。從說明中可以看到一個介面可以有多種setting*/
if (interface->desc.bNumEndpoints != 1)
return -ENODEV;
/*根據HID規則，期望滑鼠只有一個端點即中斷端點bNumEndpoints 就是介面描述符中的成員,表示這個介面有多少個端點，不過這其中不包括0 號端點，0號端點是任何一個usb 裝置都必須是提供的,這個端點專門用於進行控制傳輸,即它是一個控制端點.正因為如此,所以即使一個裝置沒有進行任何設定，usb 主機也可以開始跟它進行一些通訊,因為即使不知道其它的端點，但至少知道它一定有一個0號端點，或者說一個控制端點。
*/
endpoint = &interface->endpoint[0].desc;//端點0描述符，此處的0表示中斷端點
if (!(endpoint->bEndpointAddress & 0x80))
return -ENODEV;
/*先看bEndpointAddress,這個struct usb_endpoint_descriptor 中的一個成員,是8個bit，或者說1 個byte，其中bit7 表示 *的是這個端點的方向，0 表示OUT，1 表示IN，OUT 與IN 是對主機而言。OUT 就是從主機到裝置，IN 就是從裝置到主機。而巨集
*USB_DIR_IN 來自
*include/linux/usb_ch9.h
* USB directions
* This bit flag is used in endpoint descriptors' bEndpointAddress field.
* It's also one of three fields in control requests bRequestType.
*#define USB_DIR_OUT 0 /* to device */
*#define USB_DIR_IN 0x80 /* to host */
*/
if ((endpoint->bmAttributes & 3) != 3)? //判斷是否是中斷型別
return -ENODEV;
/* bmAttributes 表示屬性,總共8位,其中bit1和bit0 共同稱為Transfer Type,即傳輸型別,即00 表示控制,01 表示等時,10 表示批量,11 表示中斷*/
pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);//構造中斷端點的輸入pipe
maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
/*跟蹤usb_maxpacket
usb_maxpacket(struct usb_device *udev, int pipe, int is_out)
{
struct usb_host_endpoint *ep;
unsigned epnum = usb_pipeendpoint(pipe);
/*
得到的自然就是原來pipe 裡邊的15 至18 位.一個pipe 的15 位至18 位是endpoint 號,(一共16 個endpoint,)所以很顯然,這裡就是得到endpoint 號
*/
if (is_out) {
WARN_ON(usb_pipein(pipe));
ep = udev->ep_out[epnum];
} else {
WARN_ON(usb_pipeout(pipe));
ep = udev->ep_in[epnum];
}
if (!ep)
return 0;
/* NOTE:? only 0x07ff bits are for packet size... */
return le16_to_cpu(ep->desc.wMaxPacketSize);
}
*/
//返回對應端點能夠傳輸的最大的資料包，滑鼠的返回的最大資料包為4個位元組，
第0個位元組：bit 0、1、2、3、4分別代表左、右、中、SIDE、EXTRA鍵的按下情況
第1個位元組：表示滑鼠的水平位移
第2個位元組：表示滑鼠的垂直位移
第3個位元組：REL_WHEEL位移
if (!(mouse = kmalloc(sizeof(struct usb_mouse), GFP_KERNEL)))
return -ENOMEM;
memset(mouse, 0, sizeof(struct usb_mouse));
mouse->data = usb_buffer_alloc(dev, 8, SLAB_ATOMIC, &mouse->data_dma);
/*
申請用於urb用於資料傳輸的記憶體，注意：這裡將返回“mouse->data”和“mouse->data_dma”
mouse->data：記錄了用於普通傳輸用的記憶體指標
mouse->data_dma：記錄了用於DMA傳輸的記憶體指標
如果是DMA 方式的傳輸，那麼usb core 就應該使用mouse->data_dma
*/
if (!mouse->data) {
kfree(mouse);
return -ENOMEM;
}
mouse->irq = usb_alloc_urb(0, GFP_KERNEL);
if (!mouse->irq) {
usb_buffer_free(dev, 8, mouse->data, mouse->data_dma);
kfree(mouse);
return -ENODEV;
}
mouse->usbdev = dev;
mouse->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
//設定input系統響應按鍵和REL（相對結果）事件
mouse->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE);
mouse->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y);
mouse->dev.keybit[LONG(BTN_MOUSE)] |= BIT(BTN_SIDE) | BIT(BTN_EXTRA);
mouse->dev.relbit[0] |= BIT(REL_WHEEL);
//設定input系統響應的碼錶及rel表
mouse->dev.private = mouse;
mouse->dev.open = usb_mouse_open;
mouse->dev.close = usb_mouse_close;
usb_make_path(dev, path, 64);
sprintf(mouse->phys, "%s/input0", path);
mouse->dev.name = mouse->name;
mouse->dev.phys = mouse->phys;
usb_to_input_id(dev, &mouse->dev.id);
/*
usb_to_input_id(const struct usb_device *dev, struct input_id *id)
{
id->bustype = BUS_USB;
id->vendor = le16_to_cpu(dev->descriptor.idVendor);
id->product = le16_to_cpu(dev->descriptor.idProduct);
id->version = le16_to_cpu(dev->descriptor.bcdDevice);
}
struct usb_device 中有一個成員struct usb_device_descriptor,而struct usb_device_descriptor 中的成員__u16 bcdDevice,表示的是製造商指定的產品的版本號,製造商id 和產品id 來標誌一個裝置.bcdDevice 一共16 位,是以bcd碼的方式儲存的資訊,也就是說,每4 位代表一個十進位制的數,比如0011 0110 1001 0111 就代表的3697.
業內為每家公司編一個號,這樣便於管理,比如三星的編號就是0x0839,那麼三星的產品中就會在其裝置描述符中idVendor 的烙上0x0839.而三星自己的每種產品也會有個編號,和Digimax 410 對應的編號就是0x000a,而bcdDevice_lo 和bcdDevice_hi 共同組成一個具體裝置的編號(device release
number),bcd 就意味著這個編號是二進位制的格式.
*/
mouse->dev.dev = &intf->dev;
if (dev->manufacturer)
strcat(mouse->name, dev->manufacturer);
if (dev->product)
sprintf(mouse->name, "%s %s", mouse->name, dev->product);
if (!strlen(mouse->name))
sprintf(mouse->name, "USB HIDBP Mouse %04x:%04x",
mouse->dev.id.vendor, mouse->dev.id.product);
usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,
(maxp > 8 ? 8 : maxp),
usb_mouse_irq, mouse, endpoint->bInterval);
/*
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,
void *context,
int interval)
{
spin_lock_init(&urb->lock);
urb->dev = dev;
urb->pipe = pipe;
urb->transfer_buffer = transfer_buffer;//如果不使用DMA傳輸方式，則使用這個緩衝指標。如何用DMA則使用transfer_DMA，這個值會在後面單獨給URB賦
urb->transfer_buffer_length = buffer_length;
urb->complete = complete;
urb->context = context;
if (dev->speed == USB_SPEED_HIGH)
urb->interval = 1 << (interval - 1);
else
urb->interval = interval;
urb->start_frame = -1;
}
此處只是構建好一個urb，在open方法中會實現向usb core遞交urb
*/
mouse->irq->transfer_dma = mouse->data_dma;
mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
/*
#define URB_NO_TRANSFER_DMA_MAP 0x0004? //urb->transfer_dma valid on submit
#define URB_NO_SETUP_DMA_MAP??? 0x0008? //urb->setup_dma valid on submit
, 這裡是兩個DMA 相關的flag,一個是URB_NO_SETUP_DMA_MAP,而另一個是
URB_NO_TRANSFER_DMA_MAP.注意這兩個是不一樣的,前一個是專門為控制傳輸準備的,因為只有控制傳輸需要有這麼一個setup 階段需要準備一個setup packet。
transfer_buffer 是給各種傳輸方式中真正用來資料傳輸的,而setup_packet 僅僅是在控制傳輸中傳送setup 的包,控制傳輸除了setup 階段之外,也會有資料傳輸階段,這一階段要傳輸資料還是得靠transfer_buffer,而如果使用dma 方式,那麼就是使用transfer_dma.
因為這裡使用了mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP,所以應該給urb的transfer_dma賦值。所以用了：
mouse->irq->transfer_dma = mouse->data_dma;
*/
input_register_device(&mouse->dev);
//向input系統註冊input裝置
printk(KERN_INFO "input: %s on %s/n", mouse->name, path);
usb_set_intfdata(intf, mouse);
/*
usb_set_intfdata().的結果就是使得
%intf->dev->driver_data= mouse,而其它函式中會呼叫usb_get_intfdata(intf)的作用就是把mouse從中取出來
*/
return 0;
}三、open部分
當應用層開啟滑鼠裝置時，usb_mouse_open將被呼叫
static int usb_mouse_open(struct input_dev *dev)
{
struct usb_mouse *mouse = dev->private;
mouse->irq->dev = mouse->usbdev;
if (usb_submit_urb(mouse->irq, GFP_KERNEL))
return -EIO;
//向usb core遞交了在probe中構建好的中斷urb，注意：此處是成功遞交給usb core以後就返回，而不是等到從裝置取得滑鼠資料。
return 0;
}四、urb回撥函式處理部分
當出現傳輸錯誤或獲取到滑鼠資料後，urb回撥函式將被執行
static void usb_mouse_irq(struct urb *urb, struct pt_regs *regs)
{
struct usb_mouse *mouse = urb->context;
//在usb_fill_int_urb中有對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;
}
input_regs(dev, regs);
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系統報告key事件，分別是滑鼠LEFT、RIGHT、MIDDLE、SIDE、EXTRA鍵,
static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)中的value非0時表示按下，0表示釋放
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系統報告rel事件，分別是x方向位移、y方向位移、wheel值
input_sync(dev);
//最後需要向事件接受者傳送一個完整的報告。這是input系統的要求。
resubmit:
status = usb_submit_urb (urb, SLAB_ATOMIC);
//重新遞交urb
if (status)
err ("can't resubmit intr, %s-%s/input0, status %d",
mouse->usbdev->bus->bus_name,
mouse->usbdev->devpath, status);
}在應用層編寫測試滑鼠的測試程式，在我的系統中，滑鼠裝置為/dev/input/event3. 測試程式碼如下：
/*
* usb_mouse_test.c
* by lht
*/
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/input.h>
int main (void)
{
int fd,i,count;
struct input_event ev_mouse[2];
fd = open ("/dev/input/event3",O_RDWR);
if (fd < 0) {
printf ("fd open failed/n");
exit(0);
}
printf ("/nmouse opened, fd=%d/n",fd);
while(1)
{
printf(".............................................../n");
count=read(fd, ev_mouse, sizeof(struct input_event));
for(i=0;i<(int)count/sizeof(struct input_event);i++)
{
printf("type=%d/n",ev_mouse[i].type);
if(EV_REL==ev_mouse[i].type)
{
printf("time:%ld.%d",ev_mouse[i].time.tv_sec,ev_mouse[i].time.tv_usec);
printf(" type:%d code:%d value:%d/n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);
}
if(EV_KEY==ev_mouse[i].type)
{
printf("time:%ld.%d",ev_mouse[i].time.tv_sec,ev_mouse[i].time.tv_usec);
printf(" type:%d code:%d value:%d/n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);
}
}
}
close (fd);
return 0;
}