python中urb函数,Python中rb

Python求各位专家解决下这个代码，需要先运行一下

requests包有没有安装？没有的话import会过不了。

创新互联建站专注于企业成都全网营销、网站重做改版、铁西网站定制设计、自适应品牌网站建设、html5、成都做商城网站、集团公司官网建设、外贸网站制作、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为铁西等各大城市提供网站开发制作服务。

倒数第二行【value = value + i】前面加四个空格就好。

更简单的办法是用

value = ''.join(list)

代替

value = ''

for i in list:

value = value + i

这三句

浅析usbhid驱动如何源源不断的获取usb鼠标

浅析usbhid驱动如何源源不断的获取usb鼠标数据

hid_probe

==usb_hid_configure

pipe = usb_rcvintpipe(dev, endpoint-bEndpointAddress);

usb_fill_int_urb(usbhid-urbin, dev, pipe, usbhid-inbuf, insize, // 首先申请interrupt urb内存,并填充下面的有效数据

// 后面的hid_start_in()函数会usb_submit_urb提交该urb,到

// usb host控制器,进而发送interrupt in事物到hid设备[鼠标或键盘]

hid_irq_in, hid, interval); // hid_irq_in为interrupt中断管道数据处理回调函数

// urb-complete = hid_irq_in;

// interval为usbhid driver需要每隔interval毫秒

// 产生一次in读取动作,这只是一个理论上的东西[luther.gliethttp]

// 实际上该interval数值,仅仅用来usb host管理interrupt类型总线带宽

// 时,作为调整系数之一而已,[luther.gliethttp]

// 真正通信是这样的,对该urb执行一次usb_submit_urb()操作,

// 那么usb host将等待interrupt数据返回,如果hid物理设备没有

// 向它的interrupt端点填入指定大小的数据,那么

// usb host将一直等待,直到hid物理设备将指定个数的数据填入

// 它的interrupt端点为止,于是usb host将触发中断,

// 通知usb_submit_urb提交的interrupt类型的urb有数据回来了,

// 同时该urb生命终结,如果不再执行usb_submit_urb提交动作,再次等待

// 下一次interrupt数据到来的话,那么usbhid.ko将只得到

// 一次数据,[luther.gliethttp]

// 于是hid_irq_in函数将被执行,幸运的是,

// hid_irq_in函数中确实又调用了usb_submit_urb,再次将

// 该urb添加usb host事件中,等待下一次hid设备产生数据上传,然后再次调用到这里hid_irq_in处理数据,

// 如果强行将hid_irq_in函数中的usb_submit_urb屏蔽掉,

// 我们可以通过kernel klog看到,鼠标数据只会产生一个[luther.gliethttp]

static void hid_irq_in(struct urb *urb)

{

struct hid_device *hid = urb-context;

struct usbhid_device *usbhid = hid-driver_data;

int status;

switch (urb-status) {

case 0: /* success */

usbhid-retry_delay = 0;

hid_input_report(urb-context, HID_INPUT_REPORT, // 提交到更高一级的驱动层处理urb-transfer_buffer数据

urb-transfer_buffer, // 下面是截获的urb-transfer_buffer数据内容,对于我的mouse,每次都是4个字节:

urb-actual_length, 1); // [13602.612302] 00 fe 00 00

break; // [13602.868282] 01 00 00 00

case -EPIPE: /* stall */ // [13602.964277] 00 00 00 00

clear_bit(HID_IN_RUNNING, usbhid-iofl); // [13603.860290] 04 00 00 00

set_bit(HID_CLEAR_HALT, usbhid-iofl); // [13604.052288] 00 00 00 00

schedule_work(usbhid-reset_work); // [13605.332295] 02 00 00 00

return; // [13605.460297] 00 00 00 00

case -ECONNRESET: /* unlink */ // [13605.812292] 00 f9 01 00

case -ENOENT: // [13605.876280] 00 ff 00 00

case -ESHUTDOWN: /* unplug */

clear_bit(HID_IN_RUNNING, usbhid-iofl);

return;

case -EILSEQ: /* protocol error or unplug */

case -EPROTO: /* protocol error or unplug */

case -ETIME: /* protocol error or unplug */

case -ETIMEDOUT: /* Should never happen, but... */

clear_bit(HID_IN_RUNNING, usbhid-iofl);

hid_io_error(hid);

return;

default: /* error */

warn("input irq status %d received", urb-status);

}

status = usb_submit_urb(urb, GFP_ATOMIC); // 再次将该urb提交到usb host上,

if (status) { // 这样才能继续读取下一次鼠标数据[luther.gliethttp]

clear_bit(HID_IN_RUNNING, usbhid-iofl); // 如果将status = usb_submit_urb(urb, GFP_ATOMIC);注释掉

if (status != -EPERM) { // 那么表示urb生命就真的终结在这次了,不会再读到mouse数据了.

err_hid("can't resubmit intr, %s-%s/input%d, status %d", // 因为没有任何urb让usb host做读取mouse的interrupt管道[luther.gliethttp].

hid_to_usb_dev(hid)-bus-bus_name,

hid_to_usb_dev(hid)-devpath,

usbhid-ifnum, status);

hid_io_error(hid);

}

}

}

那hid_irq_in什么时候被调用呢,来看看,对hid_irq_in的调用直接来自物理irq中断[luther.gliethttp]

drivers/usb/host/ohci-s3c2410.c|455| .urb_enqueue = ohci_urb_enqueue,

drivers/usb/host/ohci-ep93xx.c|132| .urb_enqueue = ohci_urb_enqueue

drivers/usb/host/ohci-at91.c|250| .urb_enqueue = ohci_urb_enqueue,

static const struct hc_driver ohci_at91_hc_driver = {

.description = hcd_name,

.product_desc = "AT91 OHCI",

.hcd_priv_size = sizeof(struct ohci_hcd),

/*

* generic hardware linkage

*/

.irq = ohci_irq,

.flags = HCD_USB11 | HCD_MEMORY,

/*

* basic lifecycle operations

*/

.start = ohci_at91_start,

.stop = ohci_stop,

.shutdown = ohci_shutdown,

/*

* managing i/o requests and associated device resources

*/

.urb_enqueue = ohci_urb_enqueue,

.urb_dequeue = ohci_urb_dequeue,

.endpoint_disable = ohci_endpoint_disable,

/*

* scheduling support

*/

.get_frame_number = ohci_get_frame,

/*

* root hub support

*/

.hub_status_data = ohci_hub_status_data,

.hub_control = ohci_hub_control,

.hub_irq_enable = ohci_rhsc_enable,

#ifdef CONFIG_PM

.bus_suspend = ohci_bus_suspend,

.bus_resume = ohci_bus_resume,

#endif

.start_port_reset = ohci_start_port_reset,

};

static struct platform_driver ohci_hcd_at91_driver = {

.probe = ohci_hcd_at91_drv_probe,

.remove = ohci_hcd_at91_drv_remove,

.shutdown = usb_hcd_platform_shutdown,

.suspend = ohci_hcd_at91_drv_suspend,

.resume = ohci_hcd_at91_drv_resume,

.driver = {

.name = "at91_ohci",

.owner = THIS_MODULE,

},

};

ohci_hcd_at91_drv_probe

== usb_hcd_at91_probe(ohci_at91_hc_driver, pdev);

==* usb_add_hcd(hcd, pdev-resource[1].start, IRQF_DISABLED); // pdev-resource[1].start等于irqnum中断号[luther.gliethttp]

==** request_irq(irqnum, usb_hcd_irq, irqflags, hcd-irq_descr, hcd) // 注册物理中断处理函数usb_hcd_irq

所以当usb host有数据或者异常时就会产生物理irq中断,随后kernel调用到usb_hcd_irq中断处理函数

usb_hcd_irq

== hcd-driver-irq (hcd);即ohci_irq

== ohci_irq

==* dl_done_list (ohci);

==** takeback_td(ohci, td);

==*** finish_urb(ohci, urb, status); // 如果ed-td_list.next链表上没有任何控制管道,bulk等数据发送时,调用该函数[luther.gliethtt]

==**** usb_hcd_giveback_urb(ohci_to_hcd(ohci), urb, status);

==***** urb-complete (urb);即hid_irq_in // 调用回调函数, hid_irq_in会调用usb_submit_urb(urb, GFP_ATOMIC);

// 再次让usb host等待hid硬件设备的interrupt数据到来.[luther.gliethttp]

URB处理流程 linux？

URB参数是指向URB的指针，mem flags参数与传递给kmalloc ()函数参数的意义相同，它用于告知USB核心如何在此时分配内存缓冲区。

在提交URB到USB核心后，直到完成函数被调用之前，不要访问URB中的任何成员。

usb_submit_urb ()在原子上下文和进程上下文中都可以被调用，mem_flags变量需根据调用环境进行相应的设置，如下所示。

·GFP_ATOMIC:在中断处理函数、底半部、tasklet、定时器处理函数以及URB完成函数中，在调用者持有自旋锁或者读写锁时以及当驱动将current-state修改为非TASK_RUNNING时，应使用此标志。

·GFP_NOIO:在存储设备的块IO和错误处理路径中，应使用此标志;

·GFP_KERNEL:如果没有任何理由使用GFP_ATOMIC和GFP_NOIO，就使用GFP_KERNEL。

如果usb_submit_urb ()调用成功，即URB的控制权被移交给USB核心，该函数返回0;否则，返回错误号。

4）提交由USB核心指定的USB主机控制器驱动。

5）被USB主机控制器处理，进行一次到USB设备的传送。

第4）~5）步由USB核心和主机控制器完成，不受USB设备驱动的控制。

6）当URB完成，USB主机控制器驱动通知USB设备驱动。

怎样写linux下的USB设备驱动程序

你好，方法如下：

写一个USB的驱动程序最 基本的要做四件事：

驱动程序要支持的设备、注册USB驱动程序、探测和断开、提交和控制urb（USB请求块）

驱动程序支持的设备：有一个结构体struct usb_device_id，这个结构体提供了一列不同类型的该驱动程序支持的USB设备，对于一个只控制一个特定的USB设备的驱动程序来说，struct usb_device_id表被定义为：

/* 驱动程序支持的设备列表 */

static struct usb_device_id skel_table [] = {

{ USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },

{ } /* 终止入口 */

};

MODULE_DEVICE_TABLE (usb, skel_table);

对 于PC驱动程序，MODULE_DEVICE_TABLE是必需的，而且usb必需为该宏的第一个值，而USB_SKEL_VENDOR_ID和 USB_SKEL_PRODUCT_ID就是这个特殊设备的制造商和产品的ID了，我们在程序中把定义的值改为我们这款USB的，如：

/* 定义制造商和产品的ID号 */

#define USB_SKEL_VENDOR_ID 0x1234

#define USB_SKEL_PRODUCT_ID 0x2345

这两个值可以通过命令lsusb，当然你得先把USB设备先插到主机上了。或者查看厂商的USB设备的手册也能得到，在我机器上运行lsusb是这样的结果：

Bus 004 Device 001: ID 0000:0000

Bus 003 Device 002: ID 1234:2345 Abc Corp.

Bus 002 Device 001: ID 0000:0000

Bus 001 Device 001: ID 0000:0000

得到这两个值后把它定义到程序里就可以了。

注册USB驱动程序：所 有的USB驱动程序都必须创建的结构体是struct usb_driver。这个结构体必须由USB驱动程序来填写，包括许多回调函数和变量，它们向USB核心代码描述USB驱动程序。创建一个有效的 struct usb_driver结构体，只须要初始化五个字段就可以了，在框架程序中是这样的：

static struct usb_driver skel_driver = {

.owner = THIS_MODULE,

.name = "skeleton",

.probe = skel_probe,

.disconnect = skel_disconnect,

.id_table = skel_table,

};

探测和断开：当 一个设备被安装而USB核心认为该驱动程序应该处理时，探测函数被调用，探测函数检查传递给它的设备信息，确定驱动程序是否真的适合该设备。当驱动程序因 为某种原因不应该控制设备时，断开函数被调用，它可以做一些清理工作。探测回调函数中，USB驱动程序初始化任何可能用于控制USB设备的局部结构体，它 还把所需的任何设备相关信息保存到一个局部结构体中，

提交和控制urb：当驱动程序有数据要发送到USB设备时（大多数情况是在驱动程序的写函数中），要分配一个urb来把数据传输给设备：

/* 创建一个urb,并且给它分配一个缓存*/

urb = usb_alloc_urb(0, GFP_KERNEL);

if (!urb) {

retval = -ENOMEM;

goto error;

}

当urb被成功分配后，还要创建一个DMA缓冲区来以高效的方式发送数据到设备，传递给驱动程序的数据要复制到这块缓冲中去：

buf = usb_buffer_alloc(dev-udev, count, GFP_KERNEL, urb-transfer_dma);

if (!buf) {

retval = -ENOMEM;

goto error;

}

if (copy_from_user(buf, user_buffer, count)) {

retval = -EFAULT;

goto error;

}

当数据从用户空间正确复制到局部缓冲区后，urb必须在可以被提交给USB核心之前被正确初始化：

/* 初始化urb */

usb_fill_bulk_urb(urb, dev-udev,

usb_sndbulkpipe(dev-udev, dev-bulk_out_endpointAddr),

buf, count, skel_write_bulk_callback, dev);

urb-transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

然后urb就可以被提交给USB核心以传输到设备了：

/* 把数据从批量OUT端口发出 */

retval = usb_submit_urb(urb, GFP_KERNEL);

if (retval) {

err("%s - failed submitting write urb, error %d", __FUNCTION__, retval);

goto error;

}

当urb被成功传输到USB设备之后，urb回调函数将被USB核心调用，在我们的例子中，我们初始化urb，使它指向skel_write_bulk_callback函数，以下就是该函数：

static void skel_write_bulk_callback(struct urb *urb, struct pt_regs *regs)

{

struct usb_skel *dev;

dev = (struct usb_skel *)urb-context;

if (urb-status

!(urb-status == -ENOENT ||

urb-status == -ECONNRESET ||

urb-status == -ESHUTDOWN)) {

dbg("%s - nonzero write bulk status received: %d",

__FUNCTION__, urb-status);

}

/* 释放已分配的缓冲区 */

usb_buffer_free(urb-dev, urb-transfer_buffer_length,

urb-transfer_buffer, urb-transfer_dma);

}

有时候USB驱动程序只是要发送或者接收一些简单的数据，驱动程序也可以不用urb来进行数据的传输，这是里涉及到两个简单的接口函数：usb_bulk_msg和usb_control_msg ，在这个USB框架程序里读操作就是这样的一个应用：

/* 进行阻塞的批量读以从设备获取数据 */

retval = usb_bulk_msg(dev-udev,

usb_rcvbulkpipe(dev-udev, dev-bulk_in_endpointAddr),

dev-bulk_in_buffer,

min(dev-bulk_in_size, count),

count, HZ*10);

/*如果读成功，复制到用户空间 */

if (!retval) {

if (copy_to_user(buffer, dev-bulk_in_buffer, count))

retval = -EFAULT;

else

retval = count;

}

usb_bulk_msg接口函数的定义如下：

int usb_bulk_msg(struct usb_device *usb_dev,unsigned int pipe,

void *data,int len,int *actual_length,int timeout);

其参数为：

struct usb_device *usb_dev：指向批量消息所发送的目标USB设备指针。

unsigned int pipe：批量消息所发送目标USB设备的特定端点，此值是调用usb_sndbulkpipe或者usb_rcvbulkpipe来创建的。

void *data：如果是一个OUT端点，它是指向即将发送到设备的数据的指针。如果是IN端点，它是指向从设备读取的数据应该存放的位置的指针。

int len：data参数所指缓冲区的大小。

int *actual_length：指向保存实际传输字节数的位置的指针，至于是传输到设备还是从设备接收取决于端点的方向。

int timeout：以Jiffies为单位的等待的超时时间，如果该值为0，该函数一直等待消息的结束。

如果该接口函数调用成功，返回值为0，否则返回一个负的错误值。

usb_control_msg接口函数定义如下：

int usb_control_msg(struct usb_device *dev,unsigned int pipe,__u8 request,__u8requesttype,__u16 value,__u16 index,void *data,__u16 size,int timeout)

除了允许驱动程序发送和接收USB控制消息之外，usb_control_msg函数的运作和usb_bulk_msg函数类似，其参数和usb_bulk_msg的参数有几个重要区别：

struct usb_device *dev：指向控制消息所发送的目标USB设备的指针。

unsigned int pipe：控制消息所发送的目标USB设备的特定端点，该值是调用usb_sndctrlpipe或usb_rcvctrlpipe来创建的。

__u8 request：控制消息的USB请求值。

__u8 requesttype：控制消息的USB请求类型值。

__u16 value：控制消息的USB消息值。

__u16 index：控制消息的USB消息索引值。

void *data：如果是一个OUT端点，它是指身即将发送到设备的数据的指针。如果是一个IN端点，它是指向从设备读取的数据应该存放的位置的指针。

__u16 size：data参数所指缓冲区的大小。

int timeout：以Jiffies为单位的应该等待的超时时间，如果为0，该函数将一直等待消息结束。

如果该接口函数调用成功，返回传输到设备或者从设备读取的字节数；如果不成功它返回一个负的错误值。

这两个接口函数都不能在一个中断上下文中或者持有自旋锁的情况下调用，同样，该函数也不能被任何其它函数取消，使用时要谨慎。

我们要给未知的USB设备写驱动程序，只需要把这个框架程序稍做修改就可以用了，前面我们已经说过要修改制造商和产品的ID号，把0xfff0这两个值改为未知USB的ID号。

#define USB_SKEL_VENDOR_ID 0xfff0

#define USB_SKEL_PRODUCT_ID 0xfff0

还 有就是在探测函数中把需要探测的接口端点类型写好，在这个框架程序中只探测了批量（USB_ENDPOINT_XFER_BULK）IN和OUT端点，可 以在此处使用掩码（USB_ENDPOINT_XFERTYPE_MASK）让其探测其它的端点类型，驱动程序会对USB设备的每一个接口进行一次探测， 当探测成功后，驱动程序就被绑定到这个接口上。再有就是urb的初始化问题，如果你只写简单的USB驱动，这块不用多加考虑，框架程序里的东西已经够用 了，这里我们简单介绍三个初始化urb的辅助函数：

usb_fill_int_urb ：它的函数原型是这样的：

void usb_fill_int_urb(struct urb *urb,struct usb_device *dev,

unsigned int pipe,void *transfer_buff,

int buffer_length,usb_complete_t complete,

void *context,int interval);

这个函数用来正确的初始化即将被发送到USB设备的中断端点的urb。

usb_fill_bulk_urb ：它的函数原型是这样的：

void usb_fill_bulk_urb(struct urb *urb,struct usb_device *dev,

unsigned int pipe,void *transfer_buffer,

int buffer_length,usb_complete_t complete)

这个函数是用来正确的初始化批量urb端点的。

usb_fill_control_urb ：它的函数原型是这样的：

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,void *context);

这个函数是用来正确初始化控制urb端点的。

还有一个初始化等时urb的，它现在还没有初始化函数，所以它们在被提交到USB核心前，必须在驱动程序中手工地进行初始化，可以参考内核源代码树下的/usr/src/~/drivers/usb/media下的konicawc.c文件。