usb鼠标驱动注解及获取鼠标坐标

USB鼠标驱动 /drivers/hid/usbhid/usbmouse.c

下面我们分析下USB鼠标驱动，鼠标输入HID类型，其数据传输采用中断URB，鼠标端点类型为IN。好了，我们先看看这个驱动的模块加载部分。

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

static struct usb_driver usb_mouse_driver = {

.name = "usbmouse", //驱动名

.probe = usb_mouse_probe, //探测

.disconnect = usb_mouse_disconnect,

.id_table = usb_mouse_id_table, //支持项

};

关于设备支持项我们前面已经讨论过了

static struct usb_device_id usb_mouse_id_table [] = {

{USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,

USB_INTERFACE_PROTOCOL_MOUSE) },

{ }

};

再细细看看USB_INTERFACE_INFO宏的定义

#define USB_INTERFACE_INFO(cl, sc, pr) \

.match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \

.bInterfaceClass = (cl), \

.bInterfaceSubClass = (sc), \

.bInterfaceProtocol = (pr)

根据宏，我们知道，我们设置的支持项包括接口类，接口子类，接口协议三个匹配项。

好了，我们主要看看usb_driver中定义的probe函数

static int usb_mouse_probe(struct usb_interface *intf, const struct usb_device_id *id)

{

struct usb_device *dev = interface_to_usbdev(intf); //由接口获取usb_device

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); //建立中断输入端点

//返回端点能传输的最大的数据包，鼠标的返回的最大数据包为4个字节

maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));

mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL); //分配mouse结构体

input_dev = input_allocate_device(); //分配input设备空间

if (!mouse || !input_dev)

goto fail1;

mouse->data = usb_buffer_alloc(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)) //拷贝产品ID

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

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;

//evbit表明支持按键事件(EV_KEY)和相对坐标事件(EV_REL)

input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);

//keybit表明按键值包括左键、右键和中键

input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |

BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);

//relbit表明相对坐标事件值包括X坐标和Y坐标

input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);

//keybit表明除了左键、右键和中键，还支持其他按键

input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |

BIT_MASK(BTN_EXTRA);

//relbit表明除了X坐标和Y坐标，还支持中键滚轮的滚动值

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_buffer_free(dev, 8, mouse->data, mouse->data_dma);

fail1:

input_free_device(input_dev);

kfree(mouse);

return error;

}

其实上面这个probe主要是初始化usb设备和input设备，终极目标是为了完成urb的提交和input设备的注册。由于注册为input设备类型，那么当用户层open打开设备时候，最终会调用input中的open实现打开，我们看看input中open的实现

static int usb_mouse_open(struct input_dev *dev)

{

struct usb_mouse *mouse = input_get_drvdata(dev); //获取私有数据

mouse->irq->dev = mouse->usbdev; //获取urb指针

if (usb_submit_urb(mouse->irq, GFP_KERNEL)) //提交urb

return -EIO;

return 0;

}

好了，当用户层open打开这个USB鼠标后，我们就已经将urb提交给了USB核心，那么根据USB数据处理流程知道，当处理完毕后，USB核心会通知USB设备驱动程序，这里我们是响应中断服务程序，这就相当于该URB的回调函数。我们在提交urb时候定义了中断服务程序usb_mouse_irq，我们跟踪看看

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: //成功

break;

case -ECONNRESET: //未连接

case -ENOENT:

case -ESHUTDOWN:

return;

default:

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); //鼠标SIDE

input_report_key(dev, BTN_EXTRA, data[0] & 0x10); //鼠标EXTRA

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的定义

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驱动的支持。特别是这一项

    -*- HID bus support                                                                               
                                [ ]   /dev/hidraw raw HID device support                                                             
                              < >   User-space I/O driver support for HID subsystem                                            
                             <*>   Generic HID driver                                                                            
                                   Special HID drivers  --->                                                                     
                                 USB HID support  --->                                                                         
                               I2C HID support  ---> 

刚开始板子上的 dev/input 下没有关于鼠标的设备节点。就是内核没有选择这个配置。这里通过 cat /proc/bus/input/devices 来查看你的设备对应的设备节点是哪一个。I: Bus=0003 Vendor=093a Product=2510 Version=0111
N: Name="PixArt USB Optical Mouse"
P: Phys=usb-at91-2/input0
S: Sysfs=/devices/ahb.1/600000.ohci/usb2/2-2/2-2:1.0/0003:093A:2510.0001/input/input1
U: Uniq=
H: Handlers=mouse0 event1 evbug 
B: PROP=0
B: EV=17
B: KEY=70000 0 0 0 0 0 0 0 0
B: REL=103
B: MSC=10

H对应的就是你要操作的设备。这里获取鼠标的坐标值，有2种办法。1、是通过libsub读取端点1的数据，2、是通过读取input下的设备节点。

通过libusb：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <termios.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include "usb.h"


#define IdVendor 0x093A   //这是我设备的厂商号
#define IdProduct 0x2510   //这是我设备的产品号，当你的usb设备接入电脑时，使用lsusb -v命令来查看设备信息，请看下面第三张图片中的0079:0006
char buf8[8],enp_num[8],is_change=0;


static int read_interupt(struct usb_device *dev)
{
    usb_dev_handle *udev;
   


    int  i;
    udev=usb_open(dev);
    //使用libusb驱动前必须使接口脱离linux内核驱动
    usb_detach_kernel_driver_np(udev,0);
    //操作libusb接口函数时需要声明接口
    usb_claim_interface(udev,0);
    //读中断端点1
    usb_interrupt_read(udev,1,buf8,8,0x0a);
   //printf("%d\n",ret);
    usb_release_interface(udev,0);


    for(i=0;i<8;i++)
    {
        if(i==2)    //为了消除第二项不稳定因素
            continue;
        if(enp_num[i]!=buf8[i])
        {
            is_change=1;
            break;
        }
    }
   
    if(is_change==1)
    {
        is_change=0;
        for(i=0;i<8;i++)
        {
            enp_num[i]=buf8[i];
            printf("%d ",enp_num[i]);
                       
        }
         printf("\n");
        //printf("Button type = %d, X = %d, Y = %d,W= %d\n", buf8[0] , buf8[1], buf8[2],buf8[3]);
      //usleep(500*1000);
    }


      //printf("Button type = %d, X = %d, Y = %d,W= %d\n", buf8[0] , buf8[1], buf8[2],buf8[3]);
      
    
    //usleep(500*1000);
    if (udev)
        usb_close(udev);
    return 0;
}




int main(int argc, char *argv[])
{   
    int fd;
    int ret;
    int i;
    struct usb_bus *bus;
    struct usb_device *dev;
    unsigned char send_buf[64]={0x01,0xad,0x00};
    unsigned char crc=0x00;
    usb_init();
    usb_find_busses();
    usb_find_devices();
    memset(enp_num,0,sizeof(enp_num));
    memset(buf8,0,sizeof(buf8));
    for (bus = usb_busses; bus; bus = bus->next) {       
       for (dev = bus->devices; dev; dev = dev->next)     
           {  
              printf("dev->descriptor.idVendor=0x%0x           dev->descriptor.idProduct=0x%0x\n", dev->descriptor.idVendor,dev->descriptor.idProduct);
               if((dev->descriptor.idVendor==IdVendor)&&(dev->descriptor.idProduct==IdProduct))
               {     printf("-----------%d\n",__LINE__ );                                    
                    while(1)
                    {
                        read_interupt(dev);
                       
                    }              
               }
           }
       }
   printf("*****************************\n");
  
   return 0;
}

通过  操作设备节点：

#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/event1",O_RDWR);
  if (fd < 0) {
  printf ("fd open failed\n");
  return -1;
  }
  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++)
    {
        
        if(EV_REL==ev_mouse[i].type)
        {
          if(ev_mouse[i].code==0x00)
          {
            if (ev_mouse[i].value>0)
            {
              printf(" 鼠标向右移动%d",abs(ev_mouse[i].value));
            }
            else if(ev_mouse[i].value<0)
            {
              printf(" 鼠标向左移动%d",abs(ev_mouse[i].value));
            }


          }
        if(ev_mouse[i].code==0x01)
        {
            if (ev_mouse[i].value>0)
            {
              printf(" 鼠标向下移动%d",abs(ev_mouse[i].value));
            }
            else if(ev_mouse[i].value<0)
            {
              printf(" 鼠标向上移动%d",abs(ev_mouse[i].value));
            }
          
        }
        if(ev_mouse[i].code==0x08)
        {
             if (ev_mouse[i].value>0)
            {
              printf("滚轮向上移动%d",abs(ev_mouse[i].value));
            }
            else if(ev_mouse[i].value<0)
            {
              printf(" 滚轮向下移动%d",abs(ev_mouse[i].value));
            }
        }
          
        }
        printf(" \n");
        }
        if(EV_KEY==ev_mouse[i].type)
        {
        if(ev_mouse[i].code==0x110)
          printf("BTN_LEFT\n");
        if(ev_mouse[i].code==0x111)
          printf("BTN_RIGHT\n");
        if(ev_mouse[i].code==0x112)
          printf("BTN_MIDDLE\n");
        //printf(" type:%d code:%d value:%d\n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);
      }
    
  }
  close (fd);
  return 0;
}

当然这些读到的数据都是相对坐标，还要根据你的具体显示屏的尺寸来划分坐标。