这里bInterval是主机轮询时间１表示125us

修改struct usb_descriptor_header *hidg_hs_descriptors[]加上刚刚增加的endpoint

static struct usb_descriptor_header *hidg_hs_descriptors[] = {

(struct usb_descriptor_header *)&hidg_interface_desc,

(struct usb_descriptor_header *)&hidg_desc,

(struct usb_descriptor_header *)&hidg_hs_in_ep_desc,

#ifdef CONFIG_INTOUT

(struct usb_descriptor_header *)&hidg_hs_out_ep_desc,

#endif

NULL,

};

hs也相应的加上中断out端点

#ifdef CONFIG_INTOUT

static struct usb_endpoint_descriptor hidg_fs_out_ep_desc = {

.bLength  = USB_DT_ENDPOINT_SIZE,

.bDescriptorType = USB_DT_ENDPOINT,

.bEndpointAddress = USB_DIR_OUT,

.bmAttributes  = USB_ENDPOINT_XFER_INT,

/*.wMaxPacketSize = DYNAMIC */

.bInterval  = 1, /* FIXME: Add this field in the

* HID gadget configuration?

* (struct hidg_func_descriptor)

*/

};

#endif

static struct usb_descriptor_header *hidg_fs_descriptors[] = {

(struct usb_descriptor_header *)&hidg_interface_desc,

(struct usb_descriptor_header *)&hidg_desc,

(struct usb_descriptor_header *)&hidg_fs_in_ep_desc,

#ifdef CONFIG_INTOUT

(struct usb_descriptor_header *)&hidg_fs_out_ep_desc,

#endif

NULL,

};

修改hidg_bind函数　增加对中端OUT的一些初始化

static int __init hidg_bind(struct usb_configuration *c, struct usb_function *f)

{

struct usb_ep        *ep;

struct f_hidg        *hidg = func_to_hidg(f);

int            status;

dev_t            dev;

/* allocate instance-specific interface IDs, and patch descriptors */

status = usb_interface_id(c, f);

if (status < 0)

goto fail;

hidg_interface_desc.bInterfaceNumber = status;

/* allocate instance-specific endpoints */

status = -ENODEV;

ep = usb_ep_autoconfig(c->cdev->gadget, &hidg_fs_in_ep_desc);

if (!ep)

goto fail;

ep->driver_data = c->cdev;    /* claim */

hidg->in_ep = ep;

#ifdef CONFIG_INTOUT

status = -ENODEV;

ep = usb_ep_autoconfig(c->cdev->gadget, &hidg_fs_out_ep_desc);

if (!ep)

goto fail;

ep->driver_data = c->cdev;    /* claim */

hidg->out_ep = ep;

/* preallocate request and buffer */

status = -ENOMEM;

hidg->rx_req = usb_ep_alloc_request(hidg->out_ep, GFP_KERNEL);

if (!hidg->rx_req)

goto fail;

hidg->rx_req->buf = kmalloc(hidg->report_length, GFP_KERNEL);

if (!hidg->rx_req->buf)

goto fail;

hidg->rx_req->length = hidg->report_length;

hidg->rx_length = hidg->report_length;

hidg->rx_req->status   = 0;

hidg->rx_req->zero     = 0;

hidg->rx_req->context  = hidg;

hidg->rx_req->complete = hidg_read_complete;

#endif

/* preallocate request and buffer */

status = -ENOMEM;

hidg->req = usb_ep_alloc_request(hidg->in_ep, GFP_KERNEL);

if (!hidg->req)

goto fail;

hidg->req->buf = kmalloc(hidg->report_length, GFP_KERNEL);

if (!hidg->req->buf)

goto fail;

/* set descriptor dynamic values */

hidg_interface_desc.bInterfaceSubClass = hidg->bInterfaceSubClass;

hidg_interface_desc.bInterfaceProtocol = hidg->bInterfaceProtocol;

hidg_hs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);

hidg_fs_in_ep_desc.wMaxPacketSize = cpu_to_le16(64);

#ifdef CONFIG_INTOUT

hidg_hs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);

hidg_fs_out_ep_desc.wMaxPacketSize = cpu_to_le16(64);

#endif

hidg_desc.desc[0].bDescriptorType = HID_DT_REPORT;

hidg_desc.desc[0].wDescriptorLength =

cpu_to_le16(hidg->report_desc_length);

hidg->set_report_buff = NULL;

/* copy descriptors */

f->descriptors = usb_copy_descriptors(hidg_fs_descriptors);

if (!f->descriptors)

goto fail;

if (gadget_is_dualspeed(c->cdev->gadget)) {

hidg_hs_in_ep_desc.bEndpointAddress =

hidg_fs_in_ep_desc.bEndpointAddress;

#ifdef CONFIG_INTOUT

hidg_hs_out_ep_desc.bEndpointAddress =

hidg_fs_out_ep_desc.bEndpointAddress;

#endif

f->hs_descriptors = usb_copy_descriptors(hidg_hs_descriptors);

if (!f->hs_descriptors)

goto fail;

}

mutex_init(&hidg->lock);

spin_lock_init(&hidg->spinlock);

init_waitqueue_head(&hidg->write_queue);

init_waitqueue_head(&hidg->read_queue);

#ifdef CONFIG_INTOUT

init_waitqueue_head(&hidg->read_wq);

#endif

/* create char device */

cdev_init(&hidg->cdev, &f_hidg_fops);

dev = MKDEV(major, hidg->minor);

status = cdev_add(&hidg->cdev, dev, 1);

if (status)

goto fail;

device_create(hidg_class, NULL, dev, NULL, "%s%d", "hidg", hidg->minor);

#ifdef USE_FIFO

//add by hclydao

status = kfifo_alloc(&recv_fifo, RECV_LEN, GFP_KERNEL);

if (status) {

printk(KERN_ERR "+++++++++++ error kfifo_alloc\n");

goto fail;

}

#endif

return 0;

fail:

ERROR(f->config->cdev, "hidg_bind FAILED\n");

if (hidg->req != NULL) {

kfree(hidg->req->buf);

if (hidg->in_ep != NULL)

usb_ep_free_request(hidg->in_ep, hidg->req);

}

usb_free_descriptors(f->hs_descriptors);

usb_free_descriptors(f->descriptors);

return status;

}

然后修改hidg_set_alt增加中断OUT的使能

static int hidg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)

{

struct usb_composite_dev  *cdev = f->config->cdev;

struct f_hidg    *hidg = func_to_hidg(f);

int status = 0;

VDBG(cdev, "hidg_set_alt intf:%d alt:%d\n", intf, alt);

if (hidg->in_ep != NULL) {

/* restart endpoint */

if (hidg->in_ep->driver_data != NULL)

usb_ep_disable(hidg->in_ep);

status = config_ep_by_speed(f->config->cdev->gadget, f,

hidg->in_ep);

if (status) {

ERROR(cdev, "config_ep_by_speed FAILED!\n");

goto fail;

}

status = usb_ep_enable(hidg->in_ep);

if (status < 0) {

ERROR(cdev, "Enable endpoint FAILED!\n");

goto fail;

}

hidg->in_ep->driver_data = hidg;

}

#ifdef CONFIG_INTOUT

if (hidg->out_ep != NULL) {

/* restart endpoint */

if (hidg->out_ep->driver_data != NULL)

usb_ep_disable(hidg->out_ep);

status = config_ep_by_speed(f->config->cdev->gadget, f,

hidg->out_ep);

if (status) {

ERROR(cdev, "config_ep_by_speed FAILED!\n");

goto fail;

}

status = usb_ep_enable(hidg->out_ep);

if (status < 0) {

ERROR(cdev, "Enable endpoint FAILED!\n");

goto fail;

}

hidg->out_ep->driver_data = hidg;

}

#endif

fail:

return status;

}

我们先把

hidg->rx_req->complete = hidg_read_complete;

注释掉

一般到这里　编译完成下载就可以看到中断out端点了　此时如果使用bushond通过中断端点发送数据不同的平台就会有不同的现象 在这纠结了很久 4418如果到这里用bushond

通过中断OUT发送数据　发送不成功　可以通过USBlyzer监控　这时一直阻塞着　如果是2416第一次可以发送成功　但是第二次就成了阻塞状态了　最后找到原来是没有调用usb_ep_queue把out端点的相关处理加到队列中去

打开刚刚的注释　下面两个函数同时修改hidg_poll

#ifdef CONFIG_INTOUT

static ssize_t hidg_read(struct file *file, char __user *buffer,

size_t count, loff_t *ptr)

{

struct f_hidg *hidg     = file->private_data;

char  *tmp_buff = NULL;

unsigned long flags;

unsigned int copied;

if (!count)

return 0;

if (!access_ok(VERIFY_WRITE, buffer, count))

return -EFAULT;

spin_lock_irqsave(&hidg->spinlock, flags);

#ifndef USE_FIFO

#define READ_COND (hidg->set_report_buff != NULL)

#else

#define READ_COND (!kfifo_is_empty(&recv_fifo))

#endif

while (!READ_COND) {

spin_unlock_irqrestore(&hidg->spinlock, flags);

if (file->f_flags & O_NONBLOCK)

return -EAGAIN;

if (wait_event_interruptible(hidg->read_wq, READ_COND))

return -ERESTARTSYS;

spin_lock_irqsave(&hidg->spinlock, flags);

}

count = min_t(unsigned, count, hidg->rx_length);

tmp_buff = hidg->set_report_buff;

hidg->set_report_buff = NULL;

spin_unlock_irqrestore(&hidg->spinlock, flags);

if (tmp_buff != NULL) {

/* copy to user outside spinlock */

count -= copy_to_user(buffer, tmp_buff, count);

kfree(tmp_buff);

} else

count = -ENOMEM;

#ifdef USE_FIFO

//add by hclydao

count = kfifo_to_user(&recv_fifo,buffer,hidg->rx_length,&copied);

return copied;

#else

return count;

#endif

}

static void hidg_read_complete(struct usb_ep *ep, struct usb_request *req)

{

struct f_hidg *hidg = (struct f_hidg *)req->context;

int ret;

if (req->status != 0 || req->buf == NULL || req->actual == 0) {

ERROR(hidg->func.config->cdev,"%s FAILED\n", __func__);

return;

}

spin_lock(&hidg->spinlock);

//hclydao

kfifo_in(&recv_fifo, req->buf, req->actual);

spin_unlock(&hidg->spinlock);

wake_up(&hidg->read_wq);

hidg->rx_req->zero = 0;

hidg->rx_req->length = hidg->rx_length;

ret = usb_ep_queue(hidg->out_ep, hidg->rx_req, GFP_ATOMIC);

if (ret < 0)

ERROR(hidg->func.config->cdev, "usb_ep_queue error on ep0 %d\n", ret);

}

#endif

static unsigned int f_hidg_poll(struct file *file, poll_table *wait)

{

struct f_hidg *hidg  = file->private_data;

unsigned int ret = 0;

#ifdef CONFIG_INTOUT

poll_wait(file, &hidg->read_wq, wait);

#else

poll_wait(file, &hidg->read_queue, wait);

#endif

poll_wait(file, &hidg->write_queue, wait);

if (WRITE_COND)

ret |= POLLOUT | POLLWRNORM;

if (READ_COND)

ret |= POLLIN | POLLRDNORM;

return ret;

}

同时还需要修改hidg_setup函数

case HID_DT_REPORT:

VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT\n");

length = min_t(unsigned short, length,

hidg->report_desc_length);

memcpy(req->buf, hidg->report_desc, length);

if (usb_ep_queue(hidg->out_ep, hidg->rx_req, GFP_ATOMIC) < 0) {

printk("+++usb_ep_queue error on ep out\n");

return -1;

}

goto respond;

break;

当hidg设备被识别后　需要queue一次out端点　才能正常发送数据　也可以在hidg_open中增加queue函数　但是热插拔就会出问题　所以加到这里.这样基本上就可以了　最后修改hid.c中的你自己的struct hidg_func_descriptor中

.report_length  = 1024,

同时修改.report_desc中的报告大小

0x75, 0x40,

Report Size 64位以及

0x95, 0x80,

所有的REPORT_COUNT (128)　由于ＰＣ端的测试程序最后是读取这个里面的参数确定每次发送的数据大小　这样最后就是64x128=1024B

经测试速度可以达到900KB/s