如何在嵌入式linux（mini2440）开发板上使用USB键盘呢？

一、驱动加载部分

static int __init u***_mouse_init(void)
         {
                  int retval = u***_register(&u***_mouse_driver);//注册鼠标驱动
                  if (retval == 0)
                  info(DRIVER_VERSION ":" DRIVER_DESC);
                  return retval;
          }

其中u***_mouse_driver的定义为：

static struct u***_driver u***_mouse_driver = {
        .owner                  = THIS_MODULE,
         .name                  = "u***mouse",
         .probe                  = u***_mouse_probe,
         .disconnect         = u***_mouse_disconnect,
          .id_table              = u***_mouse_id_table,
         };

如果注册成功的话，将会调用u***_mouse_probe。那么什么时候才算注册成功呢？

和其它驱动注册过程一样，只有在其对应的“总线”上发现匹配的“设备”才会调用probe。总线匹配的方法和具体总线相关，如：platform_bus_type中是判断驱动名称和平台设备名称是否相同；那如何确认u***总线的匹配方法呢？

U***设备是注册在u***_bus_type总线下的。查看u***_bus_type的匹配方法。

struct bus_type u***_bus_type = {
         .name =                "u***",
         .match =               u***_device_match,
         .hotplug =            u***_hotplug,
         .suspend =         u***_generic_suspend,
         .resume =           u***_generic_resume,
          };

其中u***_device_match定义了匹配方法

static int u***_device_match (struct device *dev, struct device_driver *drv)
          {
                    struct u***_interface *intf;
                    struct u***_driver *u***_drv;
                    const struct u***_device_id *id;
                    /* check for generic driver, which we don't match any device with */
                    if (drv == &u***_generic_driver)
                    return 0;
                    intf = to_u***_interface(dev);
                    u***_drv = to_u***_driver(drv);
                    id = u***_match_id (intf, u***_drv->id_table);
                    if (id)
                              return 1;
                    return 0;
          }

可以看出u***的匹配方法是u***_match_id (intf, u***_drv->id_table)，也就是说通过比对“dev中intf信息”和“u***_drv->id_table信息”，如果匹配则说明驱动所对应的设备已经添加到总线上了，所以接下了就会调用drv中的probe方法注册u***设备驱动。

u***_mouse_id_table的定义为：

static struct u***_device_id u***_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)

匹配的过程为：

u***_match_id(struct u***_interface *interface, const struct u***_device_id *id)
          {
                    struct u***_host_interface *intf;
                    struct u***_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_u***dev(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 u***_mouse_probe(struct u***_interface * intf, const struct u***_device_id * id)
         {
                  struct u***_device * dev = interface_to_u***dev(intf);
                  struct u***_host_interface *interface;
                  struct u***_endpoint_descriptor *endpoint;
                  struct u***_mouse *mouse;
                  int pipe, maxp;
                  char path[64];

         interface = intf->cur_altsetting;

/* 以下是网络的一段对cur_altsettin的解释，下面就借花献佛。u*** 设备有一个configuration 的概念,表示配置，一个设备可以有多个配置，但只能同时激活一个，如：一些设备可以下载固件，或可以设置不同的全局模式，就像手机可以被设定为静音模式或响铃模式一样。而这里又有一个setting,咋一看有些奇怪,这两个词不是一回事吗.还是拿我们最熟悉的手机来打比方,configuration 不说了,setting,一个手机可能各种配置都确定了,是振动还是铃声已经确定了,各种功能都确定了,但是声音的大小还可以变吧,通常手机的音量是一格一格的变动,大概也就5,6 格,那么这个可以算一个setting 吧.这里cur_altsetting 就是表示的当前的这个setting,或者说设置。可以查看原码中u***_interface 结构定义的说明部分。从说明中可以看到一个接口可以有多种setting*/

         if (interface->desc.bNumEndpoints != 1)
                           return -ENODEV;

/*根据HID规则，期望鼠标只有一个端点即中断端点bNumEndpoints 就是接口描述符中的成员,表示这个接口有多少个端点，不过这其中不包括0 号端点，0号端点是任何一个u*** 设备都必须是提供的,这个端点专门用于进行控制传输,即它是一个控制端点.正因为如此,所以即使一个设备没有进行任何设置，u*** 主机也可以开始跟它进行一些通信,因为即使不知道其它的端点，但至少知道它一定有一个0号端点，或者说一个控制端点。
         */

endpoint = &interface->endpoint[0].desc;//端点0描述符，此处的0表示中断端点
         if (!(endpoint->bEndpointAddress & 0x80))
         return -ENODEV;

/*先看bEndpointAddress,这个struct u***_endpoint_descriptor 中的一个成员,是8个bit，或者说1 个byte，其中bit7 表示的是这个端点的方向，0 表示OUT，1 表示IN，OUT 与IN 是对主机而言。OUT 就是从主机到设备，IN 就是从设备到主机。而宏*USB_DIR_IN 来自
         *include/linux/u***_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 = u***_rcvintpipe(dev, endpoint->bEndpointAddress);//构造中断端点的输入pipe

maxp = u***_maxpacket(dev, pipe, u***_pipeout(pipe));

/*跟踪u***_maxpacket
         u***_maxpacket(struct u***_device *udev, int pipe, int is_out)
         {
                  struct u***_host_endpoint         *ep;
                  unsigned                  epnum = u***_pipeendpoint(pipe);
                  /*
                  得到的自然就是原来pipe 里边的15 至18 位.一个pipe 的15 位至18 位是endpoint 号,(一共16 个endpoint,)所以很显然,这里就是得到endpoint 号
                  */
                  if (is_out) {
                  WARN_ON(u***_pipein(pipe));
                  ep = udev->ep_out[epnum];
                  } else {
                  WARN_ON(u***_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 u***_mouse), GFP_KERNEL)))
                  return -ENOMEM;
         memset(mouse, 0, sizeof(struct u***_mouse));
         mouse->data = u***_buffer_alloc(dev, 8, SLAB_ATOMIC, &mouse->data_dma);

/*
         申请用于urb用于数据传输的内存，注意：这里将返回“mouse->data”和“mouse->data_dma”
         mouse->data：记录了用于普通传输用的内存指针
         mouse->data_dma：记录了用于DMA传输的内存指针
         如果是DMA 方式的传输，那么u*** core 就应该使用mouse->data_dma
         */

if (!mouse->data) {
                  kfree(mouse);
                  return -ENOMEM;
         }
         mouse->irq = u***_alloc_urb(0, GFP_KERNEL);
         if (!mouse->irq) {
                  u***_buffer_free(dev, 8, mouse->data, mouse->data_dma);
                  kfree(mouse);
                  return -ENODEV;
         }
         mouse->u***dev = 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 = u***_mouse_open;
         mouse->dev.close = u***_mouse_close;

u***_make_path(dev, path, 64);
         sprintf(mouse->phys, "%s/input0", path);

mouse->dev.name = mouse->name;
         mouse->dev.phys = mouse->phys;
         u***_to_input_id(dev, &mouse->dev.id);

/*
         u***_to_input_id(const struct u***_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 u***_device 中有一个成员struct u***_device_descriptor,而struct u***_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);

u***_fill_int_urb(mouse->irq, dev, pipe, mouse->data,
                                    (maxp > 8 ? 8 : maxp),
                                    u***_mouse_irq, mouse, endpoint->bInterval);

/*
         static inline void u***_fill_int_urb (struct urb *urb,
                                        struct u***_device *dev,
                                        unsigned int pipe,
                                        void *transfer_buffer,
                                        int buffer_length,
                                        u***_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方法中会实现向u*** 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);

u***_set_intfdata(intf, mouse);

/*
         u***_set_intfdata().的结果就是使得
         %intf->dev->driver_data= mouse,而其它函数中会调用u***_get_intfdata(intf)的作用就是把mouse从中取出来
         */

         return 0;
         }

当应用层打开鼠标设备时，u***_mouse_open将被调用

static int u***_mouse_open(struct input_dev *dev)
         {
                  struct u***_mouse *mouse = dev->private;

         mouse->irq->dev = mouse->u***dev;
         if (u***_submit_urb(mouse->irq, GFP_KERNEL))
                  return -EIO;

//向u*** core递交了在probe中构建好的中断urb，注意：此处是成功递交给u*** core以后就返回，而不是等到从设备取得鼠标数据。

         return 0;
         }

四、urb回调函数处理部分

当出现传输错误或获取到鼠标数据后，urb回调函数将被执行
         static void u***_mouse_irq(struct urb *urb, struct pt_regs *regs)
         {
                  struct u***_mouse *mouse = urb->context;

//在u***_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 = u***_submit_urb (urb, SLAB_ATOMIC);
         //重新递交urb
         if (status)
                  err ("can't resubmit intr, %s-%s/input0, status %d",
                           mouse->u***dev->bus->bus_name,
                           mouse->u***dev->devpath, status);
         }

在应用层编写测试鼠标的测试程序，在我的系统中，鼠标设备为/dev/input/event3. 测试代码如下：

/*
         * u***_mouse_test.c
         *by lht
         */

#include
         #include
         #include
         #include
         #include

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.type);
                                      if(EV_REL==ev_mouse.type)
                                      {
               printf("time:%ld.%d",ev_mouse.time.tv_sec,ev_mouse.time.tv_usec);
                                                    printf(" type:%d code:%d value:%d/n",ev_mouse.type,ev_mouse.code,ev_mouse.value);
                                       }
                                      if(EV_KEY==ev_mouse.type)
                                      {
                                      printf("time:%ld.%d",ev_mouse.time.tv_sec,ev_mouse.time.tv_usec);
                                      printf(" type:%d code:%d value:%d/n",ev_mouse.type,ev_mouse.code,ev_mouse.value);
                                      }
                     }
                     }
               close (fd);
               return 0;
      }