Linux下 USB设备驱动分析（原创）

之前做过STM32的usb HID复合设备，闲来看看linux下USB设备驱动是怎么一回事，

参考资料基于韦东山JZ2440开发板，以下，有错误欢迎指出。

1、准备知识

1.1USB相关概念：

（1）usb是主从结构，usb的传输都是主机发起；

（2）usb右四种传输类型：控制、批量、中断、实时传输。

（3）usb数据是通过端点进行通讯的，0端点既能输入也能输出，端点都是有传输方向的，

（4）USB驱动程序框架

app：

-----------------------------------------------

内核：USB设备驱动程序---知道数据含义，比如 用户自定义HID数据可以在这里解析；

---------------------------------------------------------------------------------------------------------------

　　　USB总线驱动程序--识别，找到匹配的设备驱动，提供读写函数；

-----------------------------------------------

底层硬件相关：USB主机控制器，具体的USB类--HID、AUDIO、DFU、CDC、MSC等

1.2

2、USB总线驱动概念：

USB 设备驱动程序就是用来支持 “硬件 -- USB 设备”的。但是为了访问底层具体的“USB 设
备”，就要用到了“USB 总线驱动程序”提供的读写函数，将命令或数据发给底层“USB 主机控制
器”，由“USB 主机控制器”产生信号发送给“USB 设备”。

2.1USB总线驱动程序的作用

（1）识别USB设备；

当你插上USB设备时， 硬件上拉电阻触发，进入中断函数，通过端点0主机set 地址，获取相关的描述符，枚举。

这个过程有点复杂，可以看参考USB枚举链接。

（2）查找并安装对应的设备驱动程序；

（3）提供USB读写函数

2.2USB主机控制器

  1. UHC：intel 低速-全速
  2. OHCI：microsoft 低速、全速
  3. EHCI：高速
  • linux内核源码（linux-2.6.22.6）
  • 参考的内核代码：

/*
 * $Id: usbmouse.c,v 1.15 2001/12/27 10:37:41 vojtech Exp $
 *
 *  Copyright (c) 1999-2001 Vojtech Pavlik
 *
 *  USB HIDBP Mouse support
 */

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Should you need to contact me, the author, you can do so either by
 * e-mail - mail your message to <[email protected]>, or by paper mail:
 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
 */

#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>

/*
 * Version Information
 */
#define DRIVER_VERSION "v1.6"
#define DRIVER_AUTHOR "Vojtech Pavlik <[email protected]>"
#define DRIVER_DESC "USB HID Boot Protocol mouse driver"
#define DRIVER_LICENSE "GPL"

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE(DRIVER_LICENSE);

struct usb_mouse {
    char name[128];
    char phys[64];
    struct usb_device *usbdev;
    struct input_dev *dev;
    struct urb *irq;

    signed char *data;
    dma_addr_t data_dma;
};

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:            /* success */
        break;
    case -ECONNRESET:    /* unlink */
    case -ENOENT:
    case -ESHUTDOWN:
        return;
    /* -EPIPE:  should clear the halt */
    default:        /* error */
        goto resubmit;
    }

    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_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);
    if (status)
        err ("can‘t resubmit intr, %s-%s/input0, status %d",
                mouse->usbdev->bus->bus_name,
                mouse->usbdev->devpath, status);
}

static int usb_mouse_open(struct input_dev *dev)
{
    struct usb_mouse *mouse = input_get_drvdata(dev);

    mouse->irq->dev = mouse->usbdev;
    if (usb_submit_urb(mouse->irq, GFP_KERNEL))
        return -EIO;

    return 0;
}

static void usb_mouse_close(struct input_dev *dev)
{
    struct usb_mouse *mouse = input_get_drvdata(dev);

    usb_kill_urb(mouse->irq);
}

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;
    struct input_dev *input_dev;
    int pipe, maxp;
    int error = -ENOMEM;

    interface = intf->cur_altsetting;

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

    mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL);
    input_dev = input_allocate_device();
    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);
    if (!mouse->irq)
        goto fail2;

    mouse->usbdev = dev;
    mouse->dev = input_dev;

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

    if (dev->product) {
        if (dev->manufacturer)
            strlcat(mouse->name, " ", sizeof(mouse->name));
        strlcat(mouse->name, dev->product, sizeof(mouse->name));
    }

    if (!strlen(mouse->name))
        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_dev->phys = mouse->phys;
    usb_to_input_id(dev, &input_dev->id);
    input_dev->dev.parent = &intf->dev;

    input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
    input_dev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE);
    input_dev->relbit[0] = BIT(REL_X) | BIT(REL_Y);
    input_dev->keybit[LONG(BTN_MOUSE)] |= BIT(BTN_SIDE) | BIT(BTN_EXTRA);
    input_dev->relbit[0] |= BIT(REL_WHEEL);

    input_set_drvdata(input_dev, mouse);

    input_dev->open = usb_mouse_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);
    mouse->irq->transfer_dma = mouse->data_dma;
    mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

    error = input_register_device(mouse->dev);
    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;
}

static void usb_mouse_disconnect(struct usb_interface *intf)
{
    struct usb_mouse *mouse = usb_get_intfdata (intf);

    usb_set_intfdata(intf, NULL);
    if (mouse) {
        usb_kill_urb(mouse->irq);
        input_unregister_device(mouse->dev);
        usb_free_urb(mouse->irq);
        usb_buffer_free(interface_to_usbdev(intf), 8, mouse->data, mouse->data_dma);
        kfree(mouse);
    }
}

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

MODULE_DEVICE_TABLE (usb, usb_mouse_id_table);

static struct usb_driver usb_mouse_driver = {
    .name        = "usbmouse",
    .probe        = usb_mouse_probe,
    .disconnect    = usb_mouse_disconnect,
    .id_table    = usb_mouse_id_table,
};

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 void __exit usb_mouse_exit(void)
{
    usb_deregister(&usb_mouse_driver);
}

module_init(usb_mouse_init);
module_exit(usb_mouse_exit);

2.3其它概念-HUB概念-USB描述符概念

3、USB设备驱动代码框架分析

以上属于平台设备“总线-设备-驱动”模型；

可以百度下--驱动程序分层分离概念

以上是总线设备驱动模型；

当接上一个 USB 设备时，就会产生一个中断（hub_irq（）） ,在中断里会分配一个编
号地址(choose_address（udev） )。
再然后把这个地址告诉 USB 设备(hub_set_address（） )。
接着发出各种命令获取 USB 设备的“设备描述符” (usb_get_device_descriptor
（） )。
再然后注册一个 device(device_add（） )。这个被注册的 device 会被放到 USB 总线
（usb_bus_type）的“设备链表”。并且会从总线（usb_bus_type）的“驱动链表”中取
出"usb_driver" - USB 设备驱动结构， 把 usb_interface 和 usb_driver 的 id_table 比
较，若能匹配就去调用“usb_driver”结构中的“.probe”函数。 --接着可以在probe函数实现自己想要的功能

4、实现一个简单的USB鼠标驱动代码分析

4.1 USB 总线驱动程序，在接入 USB 设备时，会帮我们构造一个新的 usb_dev 注册到“usb_bus_type”里去。这部分是内核做好的。

4.2 我们要做的是，构造一个 usb_driver 结构体，注册到“usb_bus_type”中去。在“usb_driver”结构体中有“id_table”表示他能支持哪些设备，

 4.3  .match。当 USB 设备能匹配 id_table 中某一个设备时，就会调用我们构造的“usb_driver”结构体中的“.probe” (自已确定在 probe 中做的事情)等函数，如当 拔掉

USB 设备时，就会调用其中的“.disconnect”函数

5、现在要实现的是：

USB 鼠标用作按键： (相当于输入子系统)。
左键 -- L
右键 -- S
中键 -- Enter

代码框架：

#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 usb_device_id usbmouse_as_key_id_table [] = {
    { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
        USB_INTERFACE_PROTOCOL_MOUSE) },
    //{USB_DEVICE(0x1234,0x5678)},
    { }    /* Terminating entry */
};

static int usbmouse_as_key_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
    printk("found usbmouse!\n");
    return 0;
}

static void usbmouse_as_key_disconnect(struct usb_interface *intf)
{
    printk("disconnect usbmouse!\n");
}

/* 1.分配设置usb_driver */
static struct usb_driver usbmouse_as_key_driver = {
    .name        = "usbmouse_as_key_",
    .probe        = usbmouse_as_key_probe,
    .disconnect    = usbmouse_as_key_disconnect,
    .id_table    = usbmouse_as_key_id_table,
};

static int usbmouse_as_key_init(void)
{
    /* 2.注册 */
    usb_register(&usbmouse_as_key_driver);
    return 0;
}

static void usbmouse_as_key_exit(void)
{
    usb_deregister(&usbmouse_as_key_driver);
}

module_init(usbmouse_as_key_init);
module_exit(usbmouse_as_key_exit);

MODULE_LICENSE("GPL");

接着填充usb_driver 里面的函数，
5.1 id_table：

#define USB_INTERFACE_INFO(cl,sc,pr) \
    .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, .bInterfaceClass = (cl),     .bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)

".match_flags"：表示要匹配“设备描述符”中的哪一项。“USB_DEVICE_ID_MATCH_INT_INFO”： INT 是接口意思， INT_INFO 就是指接口的信息。接口的信息就在“接口描述符”里。“.bInterfaceClass”：只要“接口描述符”里的“类”是（cl）。“.bInterfaceSubClass”：子类是 (sc) 。“.bInterfaceProtocol”：协议是 (pr) 。

所以，鼠标mouse接口描述符里类是--HID类，子类--boot，协议--mouse 这个id_table能支持

5.1 usbmouse_as_key_probe函数：

static int usbmouse_as_key_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;
    int pipe;

    interface = intf->cur_altsetting;
    endpoint = &interface->endpoint[0].desc;

    /* a. 分配一个input_dev */
    uk_dev = input_allocate_device();

    /* 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);
    set_bit(KEY_S, uk_dev->keybit);
    set_bit(KEY_ENTER, uk_dev->keybit);

    /* c. 注册 */
    input_register_device(uk_dev);

    /* d. 硬件相关操作 */
    /* 数据传输3要素: 源,目的,长度 */
    /* 源: USB设备的某个端点 */
    pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);

    /* 长度: */
    len = endpoint->wMaxPacketSize;

    /* 目的: */
    usb_buf = usb_buffer_alloc(dev, len, GFP_ATOMIC, &usb_buf_phys);

    /* 使用"3要素" */
    /* 分配usb request block */
    uk_urb = usb_alloc_urb(0, GFP_KERNEL);
    /* 使用"3要素设置urb" */
    usb_fill_int_urb(uk_urb, dev, pipe, usb_buf, len, usbmouse_as_key_irq, NULL, endpoint->bInterval);
    uk_urb->transfer_dma = usb_buf_phys;
    uk_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

    /* 使用URB */
    usb_submit_urb(uk_urb, GFP_KERNEL);

    return 0;
}

原文地址：https://www.cnblogs.com/linxw-blog/p/10603141.html

时间： 2024-10-15 12:41:55

Linux下 USB设备驱动分析（原创）的相关文章

linux下USB设备驱动

本文以USB鼠标讲解USB设备驱动. 驱动程序中调用usb_register(struct usb_driver *)函数时,先判断USB总线驱动程序是否支持usb_driver里定义的id_table,若支持,调用usb_driver的probe函数. 所以首先要定义并初始化usb_driver结构体: static struct usb_driver usbmouse_as_key_driver = { .name = "usbmouse_as_key", .probe = usb

linux下usb转串口驱动分析【转】

转自:http://blog.csdn.net/txxm520/article/details/8934706 首先说一下linux的风格,个人理解 1. linux大小结构体其实是面向对象的方法,(如果把struct 比作类,kmalloc就是类的实例化,结构体里面的函数指针就是方法,还有重构,多态) 2. 在linux里面,设备是对象,驱动也是对象,并且这两个是分开的 现在我们来看驱动的总体架构 并不用太在意这个图,对用户来说usb_serial设备就是普通的串口设备 我们可以看驱动里面几个

利用 PlxSdk 工具包开发 Linux 下 PCI 设备驱动

最近实验室需要做一个 Linux 与 FPGA 之间的快速接口,考虑高速的特性,选择了 PCI 接口实现. FPGA 选择 altera 的 EP2C20F484C8 PCI 接口芯片选择 PLX8311 操作系统选择 ubuntu10.04 1.Linux 检测 PCI 将板卡插入到主机 PCI 插槽内,开机,通过 lspci 命令可以检测到当前系统下所有的 PCI 设备. 02:00.0 PCI bridge: PLX Technology, Inc. PEX 8111 PCI Expres

Linux下的硬件驱动——USB设备（转载）

usb_bulk_msg函数 当对usb设备进行一次读或者写时,usb_bulk_msg 函数是非常有用的; 然而, 当你需要连续地对设备进行读/写时,建议你建立一个自己的urbs,同时将urbs 提交给usb子系统. 转载于此http://os.chinaunix.net/a2003/0630/1056/000001056933.shtml Linux下的硬件驱动——USB设备(上)(驱动配置部分) USB设备越来越多,而Linux在硬件配置上仍然没有做到完全即插即用,对于Linux怎样配置和

转: 嵌入式linux下usb驱动开发方法--看完少走弯路【转】

转自:http://blog.csdn.net/jimmy_1986/article/details/5838297 嵌入式linux下的usb属于所有驱动中相当复杂的一个子系统,要想将她彻底征服,至少需要个把月的时间,不信?那是你没做过. 本人做过2年的嵌入式驱动开发,usb占了一大半的时间.期间走了不少弯路,下面将我的血的经验教训总结下,为要从事和正在从事的战友们做一点点贡献吧:) 首先,扫盲: 要做的是阅读usb Spec(英文的哦,其实很多文章.书籍和资料真有水平的还是原创的好,就像食品

Linux usb子系统（二）：USB设备驱动usb-skeleton.c

usb驱动分为通过usbfs操作设备的用户空间驱动,内核空间的内核驱动.两者不能同时进行,否则容易引发对共享资源访问的问题,死锁!使用了内核驱动,就不能在usbfs里驱动该设备. 下面转载的一篇分析usb-skeleton.c文章. 初次接触与OS相关的设备驱动编写,感觉还挺有意思的,为了不至于忘掉看过的东西,笔记跟总结当然不可缺,更何况我决定为嵌入式卖命了.好,言归正传,我说一说这段时间的收获,跟大家分享一下Linux的驱动开发.但这次只先针对Linux的USB子系统作分析,因为周五研讨老板催

linux input设备驱动分析

linux input设备驱动分析 工作机制 输入设备工作机制: 输入动作–>产生中断–>CPU通过总线或者IO读取数据到缓冲区 构架层次 app //-------------------- input_event_driver //-------------------- input_core //-------------------- input_device_driver //-------------------- hardware 数据结构 输入设备对象 struct input

Linux下hp打印机驱动hplip分析

Hplip分析 版本是2.14,源码位置:http://hplipopensource.com.图的来源:http://hplipopensource.com/node/128. 1.D-Bus初始化流程 D-Bus的初始化同样是在ui4/devmgr5.py开始的. ui4/devmgr5.py 01 class DevMgr5(QMainWindow,  Ui_MainWindow): 02     ...... 03     # TODO: Make sbus init mandatory

虚拟机下Linux读取USB设备的问题虚拟机下Linux无法读取USB设备的解决方案

我们在虚拟机中识别USB设备有三种情况导致Linux系统不能读取到USB设备: 1. .当虚拟机的USB服务没有开启的时候 2. 若虚拟机的USB连接的设置选项没有设置好 3. Widows抢先一步,被Windows读取到虚拟机下Linux读取USB设备的问题 还有一种是虚拟机USB读取服务文件出现了问题,这个见链接 http://blog.csdn.net/limb99/article/details/7723600 1.当虚拟机的USB服务没有开启的时候,是无法读取到的,必须将其打开 2.若