在Linux上读取USB批量消息

我正在尝试USB上的课程，遇到了这个问题-在阅读时，USB_bulk_msg返回错误22-参数无效。写入操作成功

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/usb.h>

#define MIN(a,b) (((a) <= (b)) ? (a) : (b))
#define BULK_EP_OUT 0x01
#define BULK_EP_IN 0x82
#define MAX_PKT_SIZE 512

static struct usb_device *device;
static struct usb_class_driver class;
static unsigned char bulk_buf[MAX_PKT_SIZE];

static int pen_open(struct inode *i, struct file *f)
{
    return 0;
}
static int pen_close(struct inode *i, struct file *f)
{
    return 0;
}
static ssize_t pen_read(struct file *f, char __user *buf, size_t cnt, loff_t *off)
{
    int retval;
    int read_cnt;

    /* Read the data from the bulk endpoint */
    retval = usb_bulk_msg(device, usb_rcvbulkpipe(device, BULK_EP_IN),
            bulk_buf, MAX_PKT_SIZE, &read_cnt, 5000);
    if (retval)
    {
        printk(KERN_ERR "Bulk message returned %d\n", retval);
        return retval;
    }
    if (copy_to_user(buf, bulk_buf, MIN(cnt, read_cnt)))
    {
        return -EFAULT;
    }

    return MIN(cnt, read_cnt);
}
static ssize_t pen_write(struct file *f, const char __user *buf, size_t cnt, loff_t *off)
{
    int retval;
    int wrote_cnt = MIN(cnt, MAX_PKT_SIZE);

    if (copy_from_user(bulk_buf, buf, MIN(cnt, MAX_PKT_SIZE)))
    {
        return -EFAULT;
    }

    /* Write the data into the bulk endpoint */
    retval = usb_bulk_msg(device, usb_sndbulkpipe(device, BULK_EP_OUT),
            bulk_buf, MIN(cnt, MAX_PKT_SIZE), &wrote_cnt, 5000);
    if (retval)
    {
        printk(KERN_ERR "Bulk message returned %d\n", retval);
        return retval;
    }

    return wrote_cnt;
}

static struct file_operations fops =
{
    .open = pen_open,
    .release = pen_close,
    .read = pen_read,
    .write = pen_write,
};

static int pen_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
    int retval;

    device = interface_to_usbdev(interface);

    class.name = "usb/pen%d";
    class.fops = &fops;
    if ((retval = usb_register_dev(interface, &class)) < 0)
    {
        /* Something prevented us from registering this driver */
        err("Not able to get a minor for this device.");
    }
    else
    {
        printk(KERN_INFO "Minor obtained: %d\n", interface->minor);
    }

    return retval;
}

static void pen_disconnect(struct usb_interface *interface)
{
    usb_deregister_dev(interface, &class);
}

/* Table of devices that work with this driver */
static struct usb_device_id pen_table[] =
{
    { USB_DEVICE(0x058F, 0x6387) },
    {} /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, pen_table);

static struct usb_driver pen_driver =
{
    .name = "pen_driver",
    .probe = pen_probe,
    .disconnect = pen_disconnect,
    .id_table = pen_table,
};

static int __init pen_init(void)
{
    int result;

    /* Register this driver with the USB subsystem */
    if ((result = usb_register(&pen_driver)))
    {
        err("usb_register failed. Error number %d", result);
    }
    return result;
}

static void __exit pen_exit(void)
{
    /* Deregister this driver with the USB subsystem */
    usb_deregister(&pen_driver);
}

module_init(pen_init);
module_exit(pen_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Anil Kumar Pugalia <email_at_sarika-pugs_dot_com>");
MODULE_DESCRIPTION("USB Pen Device Driver");  

#包括
#包括
#包括
#定义最小值（a，b）（（a）小调）；
}
返回返回；
}
静态无效笔断开连接（结构usb接口*接口）
{
usb注销器开发（接口和类）；
}
/*使用此驱动程序的设备表*/
静态结构usb_设备_id笔_表[]=
{
{USB_设备（0x058F，0x6387）}，
{}/*终止项*/
};
模块设备桌（usb、笔桌）；
静态结构usb_驱动程序笔_驱动程序=
{
.name=“笔驱动程序”，
.probe=笔式探头，
.disconnect=笔\断开连接，
.id_table=笔_table，
};
静态整数初始化钢笔初始化（无效）
{
int结果；
/*向USB子系统注册此驱动程序*/
如果（（结果=usb_寄存器（&pen_驱动程序）））
{
错误（“usb_寄存器失败。错误号%d”，结果）；
}
返回结果；
}
静态无效uu退出笔u退出（无效）
{
/*在USB子系统中注销此驱动程序*/
usb_注销器（&pen_驱动程序）；
}
模块初始化（笔初始化）；
模块出口（笔出口）；
模块许可证（“GPL”）；
模块作者（“Anil Kumar Pugalia”）；
模块描述（“USB笔设备驱动程序”）；

导致此错误的原因可能有很多，但在我的情况下，大容量IP地址是错误的。我建议在探测函数中设置端点地址，而不是硬编码。请参考以下代码来设置大容量端点地址

static void
set_bulk_address (
    struct my_device *dev,
    struct usb_interface *interface)
{
    struct usb_endpoint_descriptor *endpoint;
    struct usb_host_interface *iface_desc;
    int i;

    iface_desc = interface->cur_altsetting;
    for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
        endpoint = &iface_desc->endpoint[i].desc;

        /* check for bulk endpoint */
        if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 
            == USB_ENDPOINT_XFER_BULK){

            /* bulk in */
            if(endpoint->bEndpointAddress & USB_DIR_IN) {
                dev->bulk_in_add = endpoint->bEndpointAddress;
                dev->bulk_in_size = endpoint->wMaxPacketSize;
                dev->bulk_in_buffer = kmalloc(dev->bulk_in_size,
                                GFP_KERNEL);
                if (!dev->bulk_in_buffer)
                    print("Could not allocate bulk buffer");
            }

            /* bulk out */
            else
                dev->bulk_out_add = endpoint->bEndpointAddress; 
        }
    }
}

---

出现错误的原因是，您必须根据usb设备而不是示例代码中给出的设备提及正确的批量端点。 为此，您可以检查

/sys/kernel/debug/usb/devices

文件或

/proc/bus/usb/devices

。 在文件中，检查包含设备供应商ID和产品ID的部分，并在该部分检查端点的

E

段。 在该段中，带有

（I）

的段将是

大容量EP\u In

值，带有

（O）

的段将是

大容量EP\u OUT

值

struct my_device {
    struct usb_device   *udev;      /* usb device for this device */
    struct usb_interface    *interface; /* interface for this device */
    unsigned char       minor;      /* minor value */
    unsigned char *     bulk_in_buffer; /* the buffer to in data */
    size_t          bulk_in_size;   /* the size of the in buffer */
    __u8            bulk_in_add;    /* bulk in endpoint address */
    __u8            bulk_out_add;   /* bulk out endpoint address */
    struct kref     kref;       /* module references counter */
};