Linux驱动之USB鼠标驱动编写

2021年11月21日 阅读数:10
这篇文章主要向大家介绍Linux驱动之USB鼠标驱动编写,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

本篇博客分如下几部分讲解linux

一、介绍USB四大描述数组

二、介绍USB鼠标驱动程序功能及框架缓存

三、介绍程序用到的结构体app

四、介绍程序用到的函数框架

五、编写程序函数

六、测试程序post

 

一、介绍USB四大描述符测试

USB设备驱动程序里定义了许多与驱动程序密切相关的描述符。这里介绍一下四种比较关键的描述符:设备描述符配置描述符接口描述符端点描述符。这几个描述符都位于include\linux\usb\ch9.h中,先看一下每一个描述直接的关系,从图中能够看出每个查到USB主机上的USB设备都有一个设备描述符,设备描述符下面能够接多个配置描述符,配置描述符下面又能够接多个
ui


当USB设备接到USB控制器上后,USB控制器第一次读取到的数据包,总共8字节
/*当USB设备接到USB控制器上后,USB控制器第一次读取到的数据包,总共8字节*/
struct usb_ctrlrequest {
    __u8 bRequestType;
    __u8 bRequest;
    __le16 wValue;
    __le16 wIndex;
    __le16 wLength;
} __attribute__ ((packed));

设备描述符是在设备链接时,主机第一个读取的描述符,包含了主机须要从设备读取的基本信息。设备描述符有14个字段,以下所示。依照功能来分,设备描述符的字段包含了描述符自己、设备、配置以及类别4大类。this

/* USB_DT_DEVICE: Device descriptor */
struct usb_device_descriptor {
    __u8  bLength;          //描述符长度
    __u8  bDescriptorType;  //描述符类型

    __le16 bcdUSB;          //USB规范版本号码,BCD码表示
    __u8  bDeviceClass;     //USB设备类别
    __u8  bDeviceSubClass;  //USB设备子类别
    __u8  bDeviceProtocol;  //USB设备协议码
    __u8  bMaxPacketSize0;  //端点0的最大信息包大小(端点0用于控制传输,既能输出也能输入)
    __le16 idVendor;        //厂商ID
    __le16 idProduct;    //产品ID
    __le16 bcdDevice;       //设备版本编号,BCD码表示
    __u8  iManufacturer;    //制造者的字符串描述符的索引值
    __u8  iProduct;         //产品的字符串描述符的索引值
    __u8  iSerialNumber;    //序号的字符串描述符的索引值
    __u8  bNumConfigurations;//可能配置的数目
} __attribute__ ((packed));

在读取设备描述符后,主机能够读取该设备的配置、接口以及端点描述符。每个设备都至少有一个配置描述符,用来描述该设备的特性与能力。一般一个设置配置就已经足够,不过多用途或模式的设备能够支持多个设置配置,在同一时间只能有一个做用。 每个设置配置都须要一个描述符,此描述符包含设备中的电源使用以及支持的接口数目。每个配置描述符都有附属的描述符,包含一个或多个接口描述符,以及选择性的端点描述符。

struct usb_config_descriptor {
    __u8  bLength;             //描述符长度
    __u8  bDescriptorType;     //描述符类型02

    __le16 wTotalLength;       //此配置传回的全部数据大小(字节)
    __u8  bNumInterfaces;      //此配置支持的接口数目
    __u8  bConfigurationValue; //Set_configuration与get_configuration要求的标识符
    __u8  iConfiguration;      //此配置的字符串描述符的索引值
    __u8  bmAttributes;        //自身电源/总线电源以及远程唤醒设置
    __u8  bMaxPower;           //须要总线电源,标识法为(最大mA/2)
} __attribute__ ((packed));

接口表示被设备的特性或功能所使用的端点、配置的接口描述符,包含该接口所支持的端点信息。每个设置配置必须支持一个接口,对许多设备来讲,一个接口就已经足够,不过一个设置配置,能够同时又多个做用中的接口。每个接口有它本身的接口描述符,此接口所支持的全部端点又各有一个附属描述符。若是一个设备拥有同时多个做用中接口的设置配置,它就是一个复合设备,主机会为每个接口,加载一个驱动程序。

/* USB_DT_INTERFACE: Interface descriptor */
struct usb_interface_descriptor {
    __u8  bLength;                     //描述符长度
    __u8  bDescriptorType;   //描述符类型04

    __u8  bInterfaceNumber;  //识别此接口的数量
    __u8  bAlternateSetting; //用来选择一个替代设置的数值
    __u8  bNumEndpoints;     //除了端点0外,支持的端点数量
    __u8  bInterfaceClass;   //接口类别码
    __u8  bInterfaceSubClass;//接口子类别码
    __u8  bInterfaceProtocol;//接口协议码
    __u8  iInterface;                 //此接口的字符串描述符的索引值
} __attribute__ ((packed));

每个指定在接口描述符内的端点,都有一个端点描述符。端点0没有端点描述符,由于每个端点都必须支持断点0。设备描述符包含最大信息包大小的信息,而端点描述符则是定义端点的其余信息。

/* USB_DT_ENDPOINT: Endpoint descriptor */
struct usb_endpoint_descriptor {
    __u8  bLength;                //描述符长度
    __u8  bDescriptorType;//描述符类型05

    __u8  bEndpointAddress;//端点数目与方向
    __u8  bmAttributes;         //支持的传输类型
    __le16 wMaxPacketSize; //支持的最大信息包大小
    __u8  bInterval;             //最大延迟/轮询时距/NAK速率

    /* NOTE:  these two are _only_ in audio endpoints. */
    /* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */
    __u8  bRefresh;
    __u8  bSynchAddress;
} __attribute__ ((packed));

 

 二、介绍USB鼠标驱动程序功能及框架

USB鼠标一共有三个按键:左键、右键、中键。在这里把这三个分别做为l、s、enter键。这就是这个USB设备驱动程序的功能。

要实现这个功能,仍是须要用到输入子系统的框架,与触摸屏驱动同样,再回顾一下输入系统的框架

 输入子系统按框架能够分为设备驱动层、事件层、以及核心层。

整个调用过程以下:

app_read->evdev_read->kbtab_irq->input_report_key->input_event->evdev_event->evdev_read

应用层           事件层          设备层         核心层                   核心层            事件层          事件层

若是要本身添加一个输入子系统的设备,只须要添加设备层的文件便可。

一、在里面添加设备层input_dev结构并初始化

二、编写中断处理程序

 在USB驱动程序中,中断处理程序就不是真正的CPU中断的处理程序了。而是USB总线驱动程序接收完成一包数据后的回调函数。

编写程序步骤:其中硬件相关的设置就是设置USB驱动设备传输的数据来源、数据存放地址、数据长度、怎么样处理数据

/* a、分配一个 input_dev结构体*/

/* b、设置 */
/* b.1 能产生哪类事件 */
/* b.2 能产生哪些事件 */

/* c、注册 */

/* d、硬件相关的设置 */

 

三、介绍程序用到的结构体

 一、struct input_dev结构体

struct input_dev {

    void *private;

    const char *name;//设备名字
    const char *phys;//文件路径,好比 input/buttons
    const char *uniq;
    struct input_id id;

    unsigned long evbit[NBITS(EV_MAX)];//表示支持哪类事件,经常使用于如下几种事件(能够多选)
    //EV_SYN      同步事件,当使用input_event()函数后,就要使用这个上报个同步事件
    //EV_KEY       键盘事件
    //EV_REL       (relative)相对坐标事件,好比鼠标
    //EV_ABS       (absolute)绝对坐标事件,好比摇杆、触摸屏感应
    
    unsigned long keybit[NBITS(KEY_MAX)];//存放支持的键盘按键值
    //键盘变量定义在:include/linux/input.h, 好比: KEY_L(按键L)、BTN_TOUCH(触摸屏的按键)
    
    
    unsigned long relbit[NBITS(REL_MAX)];//存放支持的相对坐标值
    unsigned long absbit[NBITS(ABS_MAX)];//存放支持的绝对坐标值
    unsigned long mscbit[NBITS(MSC_MAX)];
    unsigned long ledbit[NBITS(LED_MAX)];
    unsigned long sndbit[NBITS(SND_MAX)];
    unsigned long ffbit[NBITS(FF_MAX)];
    unsigned long swbit[NBITS(SW_MAX)];

    ...
    ...

    int absmax[ABS_MAX + 1];//绝对坐标的最大值
    int absmin[ABS_MAX + 1];//绝对坐标的最小值
    int absfuzz[ABS_MAX + 1];//绝对坐标的干扰值,默认为0,
    int absflat[ABS_MAX + 1];//绝对坐标的平焊位置,默认为0
    
    ...
    ...
};

二、struct usb_device结构体,描述整个USB设备的结构体,通常不会用到里面的变量,这里不作详细注释。

三、struct usb_interface结构体,这个结构体是由USB核心传递给USB驱动程序的,用它来描述USB接口。USB驱动程序负责后续的控制。

struct usb_interface {
    /* array of alternate settings for this interface,
     * stored in no particular order */
    struct usb_host_interface *altsetting;//一个接口结构体数组,包含了全部可能用于该接口的可选设置

    struct usb_host_interface *cur_altsetting;    /* the currently active alternate setting *///表示该接口的当前活动设置
    unsigned num_altsetting;    /* number of alternate settings *///可选设置数量

    int minor;            /* minor number this interface is bound to */      //USB核心分配的次设备号
    enum usb_interface_condition condition;        /* state of binding */   
    unsigned is_active:1;        /* the interface is not suspended */
    unsigned needs_remote_wakeup:1;    /* driver requires remote wakeup */

    struct device dev;        /* interface specific device info */
    struct device *usb_dev;        /* pointer to the usb class's device, if any */
    int pm_usage_cnt;        /* usage counter for autosuspend */
};

四、struct usb_host_interface结构体,主要用来描述USB接口

struct usb_host_interface {
    struct usb_interface_descriptor    desc;//接口描述符

    /* array of desc.bNumEndpoint endpoints associated with this
     * interface setting.  these will be in no particular order.
     */
    struct usb_host_endpoint *endpoint;//端点描述符指针

    char *string;        /* iInterface string, if present *///接口描述符的名字字符指针
    unsigned char *extra;   /* Extra descriptors *///额外的描述字符指针
    int extralen;//额外描述大小
};

五、usb_host_endpoint ,主要用来描述USB端点

struct usb_host_endpoint {
    struct usb_endpoint_descriptor    desc;//端点描述符
    struct list_head        urb_list;//端点描述符列表指针,能够根据这个结构体找到全部的处于同一指针链表的usb_host_endpoint结构
    void                *hcpriv;
    struct ep_device         *ep_dev;    /* For sysfs info */

    unsigned char *extra;   /* Extra descriptors */
    int extralen;
};

六、struct usb_endpoint_descriptor结构体,端点描述符

/* USB_DT_ENDPOINT: Endpoint descriptor */
struct usb_endpoint_descriptor {
    __u8  bLength;                //描述符长度
    __u8  bDescriptorType;//描述符类型05

    __u8  bEndpointAddress;//端点数目与方向
    __u8  bmAttributes;         //支持的传输类型
    __le16 wMaxPacketSize; //支持的最大信息包大小
    __u8  bInterval;             //最大延迟/轮询时距/NAK速率

    /* NOTE:  these two are _only_ in audio endpoints. */
    /* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */
    __u8  bRefresh;
    __u8  bSynchAddress;
} __attribute__ ((packed));

七、struct urb结构体,是一个USB请求块,做用是和全部的USB设备通信。

struct urb
{
    /* private: usb core and host controller only fields in the urb */
    struct kref kref;        /* reference count of the URB */
    spinlock_t lock;        /* lock for the URB */
    void *hcpriv;            /* private data for host controller */
    atomic_t use_count;        /* concurrent submissions counter */
    u8 reject;            /* submissions will fail */

    /* public: documented fields in the urb that can be used by drivers */
    struct list_head urb_list;    /* list head for use by the urb's
                     * current owner */
    struct usb_device *dev;     /* (in) pointer to associated device *///urb所发送的目标usb_devices指针
    unsigned int pipe;        /* (in) pipe information */                //端点信息,能够设置为控制、批量、中断、等时等端点输入或输出
    int status;            /* (return) non-ISO status */                    //当urb结束后或者正在被USB核心处理时,该变量被设置为当前的状态
    unsigned int transfer_flags;    /* (in) URB_SHORT_NOT_OK | ...*/   //USB数据传输标志,能够经过这个标志判断数据传输状况
    void *transfer_buffer;        /* (in) associated data buffer */      //以DMA方式传输数据到USB设备的缓存区指针,必须用kmalloc来建立
    dma_addr_t transfer_dma;    /* (in) dma addr for transfer_buffer *///以DMA方式传输数据到USB设备的地址
    int transfer_buffer_length;    /* (in) data buffer length */        //以DMA方式传输数据到USB设备的缓冲区的长度
    int actual_length;        /* (return) actual transfer length */             //当urb结束后,实际接收到的或者发送的数据长度
    unsigned char *setup_packet;    /* (in) setup packet (control only) *///
    dma_addr_t setup_dma;        /* (in) dma addr for setup_packet */
    int start_frame;        /* (modify) start frame (ISO) */
    int number_of_packets;        /* (in) number of ISO packets */
    int interval;            /* (modify) transfer interval  * (INT/ISO) */  //urb被轮询的时间间隔,仅对中断或者等时urb有效
    int error_count;        /* (return) number of ISO errors */          //用于等时urb结束后,报告的类型错误的数量
    void *context;            /* (in) context for completion */  //指向一个可用被USB驱动程序设置的数据块
    usb_complete_t complete;    /* (in) completion routine *///指向一个结束处理例程的指针,当urb被彻底传输或者错误时调用这个函数
    struct usb_iso_packet_descriptor iso_frame_desc[0];    //
                    /* (in) ISO ONLY */
};

八、struct usb_device_id结构体,提供不一样类型的该驱动程序支持的USB设备,USB核心使用该列表来判断对于一个设备改使用哪个驱动程序

struct usb_device_id {
    /* which fields to match against? */
    __u16        match_flags;//在设备插上后须要匹配下面的哪几个参数来匹配驱动

    /* Used for product specific matches; range is inclusive */
    __u16        idVendor;//USB制造商ID
    __u16        idProduct;//USB产品ID
    __u16        bcdDevice_lo;//产品版本号最低值
    __u16        bcdDevice_hi;//产品版本号最高值

    /* Used for device class matches */
    __u8        bDeviceClass;//设备的类型
    __u8        bDeviceSubClass;//设备的子类型
    __u8        bDeviceProtocol;//设备的协议

    /* Used for interface class matches */
    __u8        bInterfaceClass;//接口类型
    __u8        bInterfaceSubClass;//接口子类型
    __u8        bInterfaceProtocol;//接口协议

    /* not matched against */
    kernel_ulong_t    driver_info;//
};

九、struct usb_driver结构体,USB驱动程序必须建立的主要结构体,它向USB核心代码描述USB驱动程序。

struct usb_driver {
    const char *name;//执行驱动程序名字的指针

    int (*probe) (struct usb_interface *intf,
              const struct usb_device_id *id);//指向USB驱动程序中的探测函数的指针

    void (*disconnect) (struct usb_interface *intf);//指向USB驱动程序中的断开函数的指针

    int (*ioctl) (struct usb_interface *intf, unsigned int code,
            void *buf);//执行USB驱动程序中的ioctl指针

    int (*suspend) (struct usb_interface *intf, pm_message_t message);//指向USB驱动程序中的挂起函数指针
    int (*resume) (struct usb_interface *intf);//指向USB驱动程序中的恢复函数指针

    void (*pre_reset) (struct usb_interface *intf);//
    void (*post_reset) (struct usb_interface *intf);

    const struct usb_device_id *id_table;//指向struct usb_device_id表的指针

    struct usb_dynids dynids;
    struct usbdrv_wrap drvwrap;
    unsigned int no_dynamic_id:1;
    unsigned int supports_autosuspend:1;
};

 

四、介绍程序用到的函数

一、输入子系统相关的函数

struct input_dev *input_allocate_device(void);//分配一个struct input_dev结构体,返回的是struct input_dev *
inline void set_bit(int nr, volatile unsigned long *addr);//这是一个内联函数,在调用的时候展开,功能为设置*addr的nr位为1
int input_register_device(struct input_dev *dev);//注册输入子系统设备驱动,输入参数为struct input_dev *
void input_unregister_device(struct input_dev *dev);//反注册输入子系统的设备驱动,输入参数为struct input_dev *
void input_free_device(s3c_ts_input);//释放分配的input_dev结构,,输入参数为struct input_dev *

static inline void input_sync(struct input_dev *dev);//上传同步事件,表示此次事件数据已经传送完成了
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value);//上传输入事件
//struct input_dev *dev表示哪一个输入子系统设备的事件上传
//unsigned int type,表示上传的事件类型
//unsigned int code,表示事件类型中的哪类事件
//value表示事件的值

 

二、USB核心相关的函数

static inline int usb_register(struct usb_driver *driver);//注册一个usb驱动结构体driver到USB核心
void usb_deregister(struct usb_driver *driver);//从USB核心释放一个usb驱动结构体driver
usb_rcvintpipe(dev,endpoint);//这是一个宏。设置usb设备dev的端点endpoint为中断IN端点
void *usb_buffer_alloc(struct usb_device *dev,size_t size,gfp_t mem_flags,dma_addr_t *dma);//分配一个地址做为USB接收到的数据,返回分配地址的首地址
//struct usb_device *dev是USB设备结构体
//size_t size分配的内存的大小
//gfp_t mem_flags是分配的标志
//dma_addr_t *dma是分配完成后返回的物理地址
struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags);//分配一个urb结构体
//int iso_packets是等时数据包
//gfp_t mem_flags内存分配标志
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);//初始化即将被发送到USB设备的中断端点的urb
//struct urb *urb是指向须要初始化的urb的指针
//struct usb_device *dev是该urb所发送的目标USB设备
//unsigned int pipe是该urb所发送的目标USB设备的特色端点。该值由usb_sndintpipe或usb_rcvintpipe函数建立
//void *transfer_buffer用于保存外发数据或接收数据的缓冲区的指针
//int buffer_length是transfer_buffer指针所指向缓存区的大小
//usb_complete_t complete_fn指向当该urb结束以后调用的结束处理例程的指针
//void *context指向一个小数据块,该块被添加到urb结构体中以便进行结束处理例程后面的查找
//int interval该urb应该被调度的间隔
int usb_submit_urb(struct urb *urb, gfp_t mem_flags);//提交urb
//struct urb *urb表示须要提交的urb控制块
//gfp_t mem_flags内存分配标志
void usb_buffer_free(struct usb_device *dev,size_t size,void *addr,dma_addr_t dma);//释放分配的usb缓存数据
//struct usb_device *dev表示目标USB设备
//size_t size释放的缓冲区的大小
//void *addr指向释放的缓冲区的指针
//dma_addr_t dma表示释放的缓冲区的物理地址
int usb_unlink_urb(struct urb *urb);//释放urb请求块
//struct urb *urb表示指向释放的urb请求块的指针

 

五、编写程序

直接放出程序源码,能够看到这个程序的结构和输入子系统的结构差很少。

一、首先加载这个模块后,会调用usb_mouse_as_key_init函数,而后usb_mouse_as_key_driver 结构体被注册到USB核心

二、当插上USB鼠标设备后,若是此设备和此驱动的接口类、接口子类、接口协议相同(位于usb_mouse_as_key_id_table ),那么usb_mouse_as_key_probe函数被调用

三、usb_mouse_as_key_probe函数是核心函数,在里面作许多事情,具体看代码

/* a、分配一个 input_dev结构体*/

/* b、设置 */
/* b.1 能产生哪类事件 */
/* b.2 能产生哪些事件 */

/* c、注册 */

/* d、硬件相关的设置 */

四、当按下USB按键后在第三步中设置的usb_mouse_as_key_irq函数被调用

五、数据包会在usb_mouse_as_key_irq回调函数被处理。至于数据的含义须要本身根据USB设备来判断而后定义,我用的鼠标按键的值位于usb_buf[1]中,因此能够根据这个值判断是哪个按键被按下或松开,而后上传事件到输入子系统。

详细的解释能够参考以下代码:

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/usb/input.h>
#include <linux/hid.h>

static struct input_dev *uk_dev; //定义一个输入子系统设备结构体
static dma_addr_t usb_buf_phys; //物理地址
static char *usb_buf;                  //从USB主控制器接收到的数据存放的致使
static int len;                             //从USB主控制器接收到的数据的长度
static struct urb *uk_urb;           //定义一个USB请求块



/* 一包数据接收完成后处理函数*/
 static void usb_mouse_as_key_irq(struct urb *urb)
 {
//    int i;
//    static int cnt = 0;

//    printk("data cnt %d: ", ++cnt);
//    for (i = 0; i < len; i++)
//    {
//        printk("%02x ", usb_buf[i]);
//    }
//    printk("\n");

    /* 
      * USB鼠标数据含义
     *  data[0]: bit0-左键, 1-按下, 0-松开
     *          bit1-右键, 1-按下, 0-松开
     *          bit2-中键, 1-按下, 0-松开 
     */
     
    static unsigned char pre_val;//前一个按键的按键值,每当按键值变化才上传

    if((pre_val & (1<<0)) != (usb_buf[1] & (1<<0)))//左键发生变化
    {
         input_event(uk_dev,EV_KEY, KEY_L, (usb_buf[1]?1:0));
         input_sync(uk_dev);                                                    //上传同步事件
    }

    if((pre_val & (1<<1)) != (usb_buf[1] & (1<<1)))//右键发生变化
    {
         input_event(uk_dev,EV_KEY, KEY_S, (usb_buf[1]?1:0));
         input_sync(uk_dev);                                                    //上传同步事件
    }

    if((pre_val & (1<<2)) != (usb_buf[1] & (1<<2)))//中键发生变化
    {
         input_event(uk_dev,EV_KEY, KEY_ENTER, (usb_buf[1]?1:0));
         input_sync(uk_dev);                                                    //上传同步事件
    }
    pre_val = usb_buf[1];
    
     /* 从新提交urb */
    usb_submit_urb(uk_urb, GFP_KERNEL);//提交URB,将URB的控制还给USB核心处理程序
 }
 
static int usb_mouse_as_key_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
    struct usb_device *dev  = interface_to_usbdev(intf);//根据usb接口,取得usb设备
    struct usb_host_interface *interface;                        //定义一个USB主机控制器接口描述符
    struct usb_endpoint_descriptor *endpoint;                 //定义一个端点描述符
    int pipe;
    
    interface = intf->cur_altsetting;                               //得到usb控制器的接口描述符

    endpoint = &interface->endpoint[0].desc;//取得usb 控制器的第一个端点描述符
    
    
    printk("found usbmouse!\n");

    printk("bcdUSB = %x\n",dev->descriptor.bcdUSB);  //从USB设备描述符中获取USB版本
    printk("vidUSB = %x\n",dev->descriptor.idVendor); //从USB设备描述符中获取厂商ID
    printk("pidUSB = %x\n",dev->descriptor.idProduct);//从USB设备描述符中获取产品ID

    printk("bdcUSB = %x\n",intf->cur_altsetting->desc.bInterfaceClass);//从USB设备获取设备类
    printk("bdsUSB = %x\n",intf->cur_altsetting->desc.bInterfaceSubClass);//从USB设备获取设备从类
    printk("bdpUSB = %x\n",intf->cur_altsetting->desc.bInterfaceProtocol);//从USB设备获取设备协议

    /* a、分配一个 input_dev结构体*/
    uk_dev = input_allocate_device();//分配一个input_dev结构体

    /* b、设置 */
        /* b.1 能产生哪类事件 */
    set_bit(EV_KEY, uk_dev->evbit);//产生按键事件
    set_bit(EV_REP, uk_dev->evbit);//产生重复事件
        /* b.2 能产生哪些事件 */
    set_bit(KEY_L, uk_dev->keybit);//产生按键事件的L事件
    set_bit(KEY_S, uk_dev->keybit);//产生按键事件的S事件
    set_bit(KEY_ENTER, uk_dev->keybit);//产生按键事件的ENTER时间
    /* c、注册 */
    input_register_device(uk_dev);//注册一个输入设备
    
    /* d、硬件相关的设置 */
    /* 数据传输三要素: 源、目的、长度*/
    /* 源:USB设备某个端点 */
    pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);//设置端点为中断IN端点
    
    /* 长度 */
    len = endpoint->wMaxPacketSize;//长度为最大包长度
    
    /* 目的 */
    usb_buf = usb_buffer_alloc(dev, len, GFP_ATOMIC, &usb_buf_phys);//分配一个地址做为USB接收到的数据
    
    /* 使用三要素*/
    uk_urb= usb_alloc_urb(0, GFP_KERNEL);              //分配一个USB请求块
    
    /* 使用三要素,设置urb */
    usb_fill_int_urb(uk_urb, dev, pipe, usb_buf,
                len,usb_mouse_as_key_irq, NULL, endpoint->bInterval);//初始化即将被发送到USB设备的中断端点的URB
    
    uk_urb->transfer_dma = usb_buf_phys;            //usb控制器完成数据接收后将数据存放的物理地址
    uk_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; //当URB包含一个即将传输的DMA缓冲区时应该设置URB_NO_TRANSFER_DMA_MAP
    
    /* 使用URB */
    ret = usb_submit_urb(uk_urb, GFP_KERNEL);//提交urb
    if(ret)
        return -1;
    return 0;
}

static void usb_mouse_as_key_disconnect(struct usb_interface *intf)
{
    struct usb_device *dev = interface_to_usbdev(intf);
    
    input_free_device(uk_dev);//释放一个input_dev结构体
    input_unregister_device(uk_dev);//反注册一个输入设备
    usb_buffer_free(dev, len, usb_buf, usb_buf_phys);//释放分配的usb缓存数据
    usb_unlink_urb(uk_urb);//不使用urb控制块
    
    printk("disconnetc usbmouse\n");
}

static struct usb_device_id usb_mouse_as_key_id_table [] = {
    { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
        USB_INTERFACE_PROTOCOL_MOUSE) },
    { }    /* Terminating entry *///终止入口项*/
};




static struct usb_driver usb_mouse_as_key_driver = {
    .name        = "usbmouse_askey",
    .probe        = usb_mouse_as_key_probe,
    .disconnect    = usb_mouse_as_key_disconnect,
    .id_table    = usb_mouse_as_key_id_table,
};

static int __init usb_mouse_as_key_init(void)
{
    int retval = usb_register(&usb_mouse_as_key_driver);//注册一个usb驱动
    return retval;
}

static void __exit usb_mouse_as_key_exit(void)
{
    usb_deregister(&usb_mouse_as_key_driver);
}

module_init(usb_mouse_as_key_init);
module_exit(usb_mouse_as_key_exit);

MODULE_LICENSE("GPL");

 

六、测试程序

测试流程以下:

一、insmod 11th_usbmouse_as_key_drv.ko

二、ls /dev/event*

三、接上USB鼠标

四、ls /dev/event*后能够看到新增了一个event1

五、cat dev/tty1 而后按鼠标按键,左键、右键、中键分别为l、s、enter

六、测试成功