USB驱动——键盘驱动（控制传输）

    本文以 usbkbd.c 为例，分析 usb 键盘驱动程序。

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;
}

static struct usb_driver usb_kbd_driver = {
.name =		"usbkbd",
.probe =	usb_kbd_probe,
.disconnect =	usb_kbd_disconnect,
.id_table =	usb_kbd_id_table,
};

    还是来看一下 id_table ，与鼠标相比，仅仅是协议不一样。

static struct usb_device_id usb_kbd_id_table [] = {
{ USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
USB_INTERFACE_PROTOCOL_KEYBOARD) },
{ }						/* Terminating entry */
};

    下面来看probe函数

static int usb_kbd_probe(struct usb_interface *iface,
const struct usb_device_id *id)
{
/* 获得usb_device */
struct usb_device *dev = interface_to_usbdev(iface);

/* 接口的设置 */
struct usb_host_interface *interface;

/* 端点描述符 */
struct usb_endpoint_descriptor *endpoint;

/* 键盘结构体 */
struct usb_kbd *kbd;

/* 输入设备 */
struct input_dev *input_dev;

int i, pipe, maxp;
int error = -ENOMEM;

/* 获取该接口当前的设置 */
interface = iface->cur_altsetting;

/* 如果当前设置的端点数量不是1，那么错误，返回 */
if (interface->desc.bNumEndpoints != 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));

/* 为键盘结构体分配空间 */
kbd = kzalloc(sizeof(struct usb_kbd), GFP_KERNEL);

/* 分配一个输入设备 */
input_dev = input_allocate_device();

/*
kbd->irq = usb_alloc_urb(0, GFP_KERNEL)
kbd->led = usb_alloc_urb(0, GFP_KERNEL)
kbd->new = usb_buffer_alloc(dev, 8, GFP_ATOMIC, &kbd->new_dma)
kbd->cr = usb_buffer_alloc(dev, sizeof(struct usb_ctrlrequest), GFP_ATOMIC, &kbd->cr_dma)
kbd->leds = usb_buffer_alloc(dev, 1, GFP_ATOMIC, &kbd->leds_dma)
*/
if (usb_kbd_alloc_mem(dev, kbd))
goto fail2;

/* 填充键盘结构体。以及一些字符串 */
kbd->usbdev = dev;
kbd->dev = input_dev;

if (dev->manufacturer)
strlcpy(kbd->name, dev->manufacturer, sizeof(kbd->name));

if (dev->product) {
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));
strlcpy(kbd->phys, "/input0", sizeof(kbd->phys));

/* 填充输入设备 */
input_dev->name = kbd->name;
input_dev->phys = kbd->phys;
usb_to_input_id(dev, &input_dev->id);
input_dev->dev.parent = &iface->dev;

input_set_drvdata(input_dev, kbd);

/* 设置它支持的事件类型和具体事件 1、按键类事件 2、LED灯（大小写灯等）3、重复上报*/
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);

for (i = 0; i < 255; i++)
set_bit(usb_kbd_keycode[i], input_dev->keybit);
clear_bit(0, input_dev->keybit);

/* 对于LED类型的事件，首先会调用到dev->event 然后再调用事件处理层的event */
input_dev->event = usb_kbd_event;
input_dev->open = usb_kbd_open;
input_dev->close = usb_kbd_close;

/* 填充中断类型Urb */
usb_fill_int_urb(kbd->irq, dev, pipe,
kbd->new, (maxp > 8 ? 8 : maxp),
usb_kbd_irq, kbd, endpoint->bInterval);
kbd->irq->transfer_dma = kbd->new_dma;
kbd->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

/*
* 	bit7 	控制传输 data 阶段的方向 0 主机到设备 1设备到主机，	这里 0 主机到设备
*	bit5-6	表示 request 类型，是标准的还是厂家定义的，			这里为hid class定义
*	bit0-4	表示这个请求针对的是设备、接口还是端点 ，			这里是接口
*/
kbd->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE;	// 0x01 << 5 |

/*
#define USB_REQ_GET_STATUS		0x00
#define USB_REQ_CLEAR_FEATURE		0x01
#define USB_REQ_SET_FEATURE		0x03
#define USB_REQ_SET_ADDRESS		0x05
#define USB_REQ_GET_DESCRIPTOR		0x06
#define USB_REQ_SET_DESCRIPTOR		0x07
#define USB_REQ_GET_CONFIGURATION	0x08
#define USB_REQ_SET_CONFIGURATION	0x09
#define USB_REQ_GET_INTERFACE		0x0A
#define USB_REQ_SET_INTERFACE		0x0B
#define USB_REQ_SYNCH_FRAME		0x0C
*/
kbd->cr->bRequest = USB_REQ_SET_CONFIGURATION;

/* request 的参数 */
kbd->cr->wValue = cpu_to_le16(0x200);

/* bRequestType 中，针对接口、端点时，它表示那个接口或端点 */
kbd->cr->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);

/* data阶段数据长度 */
kbd->cr->wLength = cpu_to_le16(1);

/*
static inline void usb_fill_control_urb(
struct urb *urb,
struct usb_device *dev,
unsigned int pipe,
unsigned char *setup_packet,
void *transfer_buffer,
int buffer_length,
usb_complete_t complete_fn,
void *context)
*/
/* 这里使用的是默认端点0 */
usb_fill_control_urb(kbd->led, dev, usb_sndctrlpipe(dev, 0),(void *) kbd->cr, kbd->leds, 1, usb_kbd_led, kbd);
kbd->led->setup_dma = kbd->cr_dma;
kbd->led->transfer_dma = kbd->leds_dma;
kbd->led->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);

error = input_register_device(kbd->dev);

usb_set_intfdata(iface, kbd);
return 0;
}

    这里与鼠标驱动程序相比，多了一个控制传输过程，而且，这个控制传输的 bRequestType 中说明了这个传输不是标准的请求，而是Class，我们的键盘是HID类型，因此还要看USB HID协议中，关于这个请求是如何定义的，才能知道wValue 、wIndex等是什么意思（参考：http://blog.csdn.net/leo_wonty/article/details/6721214），这就是就将knd->leds
内的一字节数据发送给从设备。在鼠标驱动程序中，中断 urb 是在open函数中提交的，这里也不例外。

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;
}

    中断传输完成之后会调用完成函数，usb_kbd_irq

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);
}

    这里，都是上报的按键类事件，我们在前边的Probe函数中，设置了输入设备支持按键类事件，还有一个LED类事件，但是搜遍代码也没有找到，LED类事件是在哪里上报的。还有，probe函数中定义了一个dev->event函数，在浏览资料时发现，有些人说在input_event时，调用事件处理层的event函数的同时会调用dev->event，我认为这种说法是不正确的，看过input_event代码的同学应该不难发现，只有上报LED类等事件的时候才会触发dev->event，我们这里单纯上报的按键类事件并不会触发dev->event
。那么，probe 函数里定义的 dev->event 函数岂不是成了摆设么？确实，我暂时没发现它有什么用。手头没有usb键盘，这个后边实验证实。

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)
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))
err_hid("usb_submit_urb(leds) failed");

return 0;
}

    这里的 dev->led 记录的是led的状态，比如，我们上报一个LED事件时，input_event 中会将对应的事件记录在 dev->led 中。这里检测LED事件是否发生，然后通过控制传输将1字节数据传送给usb键盘，Usb键盘的灯相应做出改变。但是，说到底，代码里没有上报过LED类事件，一切都是白扯。

static void usb_kbd_led(struct urb *urb)
{
struct usb_kbd *kbd = urb->context;

if (urb->status)
dev_warn(&urb->dev->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))
err_hid("usb_submit_urb(leds) failed");
}

    这里的控制传输完成函数也是个累赘？每次有LED事件上报的话，那么控制传输urb就自动提交了。那么，*（kbd->leds）== kbd->newleds 必然是相等的，除非又有新的事件上报了，但是新事件上报时，在usb_kbd_event 函数里urb不就自动提交了么? 会出现不相等的情况？

    此篇文章存在诸多疑问，如果有大神看到，还请解答一下。