Lines Matching refs:hidg
28 .name = "hidg",
93 struct f_hidg *hidg = container_of(dev, struct f_hidg, dev);
95 kfree(hidg->report_desc);
96 kfree(hidg->set_report_buf);
97 kfree(hidg);
295 struct f_hidg *hidg = file->private_data;
304 spin_lock_irqsave(&hidg->read_spinlock, flags);
306 #define READ_COND_INTOUT (!list_empty(&hidg->completed_out_req))
310 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
314 if (wait_event_interruptible(hidg->read_queue, READ_COND_INTOUT))
317 spin_lock_irqsave(&hidg->read_spinlock, flags);
321 list = list_first_entry(&hidg->completed_out_req,
332 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
347 req->length = hidg->report_length;
348 ret = usb_ep_queue(hidg->out_ep, req, GFP_KERNEL);
350 free_ep_req(hidg->out_ep, req);
354 spin_lock_irqsave(&hidg->read_spinlock, flags);
355 list_add(&list->list, &hidg->completed_out_req);
356 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
358 wake_up(&hidg->read_queue);
364 #define READ_COND_SSREPORT (hidg->set_report_buf != NULL)
369 struct f_hidg *hidg = file->private_data;
376 spin_lock_irqsave(&hidg->read_spinlock, flags);
379 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
383 if (wait_event_interruptible(hidg->read_queue, READ_COND_SSREPORT))
386 spin_lock_irqsave(&hidg->read_spinlock, flags);
389 count = min_t(unsigned int, count, hidg->set_report_length);
390 tmp_buf = hidg->set_report_buf;
391 hidg->set_report_buf = NULL;
393 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
402 wake_up(&hidg->read_queue);
410 struct f_hidg *hidg = file->private_data;
412 if (hidg->use_out_ep)
420 struct f_hidg *hidg = (struct f_hidg *)ep->driver_data;
424 ERROR(hidg->func.config->cdev,
428 spin_lock_irqsave(&hidg->write_spinlock, flags);
429 hidg->write_pending = 0;
430 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
431 wake_up(&hidg->write_queue);
437 struct f_hidg *hidg = file->private_data;
442 spin_lock_irqsave(&hidg->write_spinlock, flags);
444 if (!hidg->req) {
445 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
449 #define WRITE_COND (!hidg->write_pending)
453 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
458 hidg->write_queue, WRITE_COND))
461 spin_lock_irqsave(&hidg->write_spinlock, flags);
464 hidg->write_pending = 1;
465 req = hidg->req;
466 count = min_t(unsigned, count, hidg->report_length);
468 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
471 ERROR(hidg->func.config->cdev, "hidg->req is NULL\n");
478 ERROR(hidg->func.config->cdev,
484 spin_lock_irqsave(&hidg->write_spinlock, flags);
487 if (!hidg->req) {
488 free_ep_req(hidg->in_ep, req);
500 req->context = hidg;
502 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
504 if (!hidg->in_ep->enabled) {
505 ERROR(hidg->func.config->cdev, "in_ep is disabled\n");
510 status = usb_ep_queue(hidg->in_ep, req, GFP_ATOMIC);
518 spin_lock_irqsave(&hidg->write_spinlock, flags);
519 hidg->write_pending = 0;
520 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
522 wake_up(&hidg->write_queue);
529 struct f_hidg *hidg = file->private_data;
532 poll_wait(file, &hidg->read_queue, wait);
533 poll_wait(file, &hidg->write_queue, wait);
538 if (hidg->use_out_ep) {
561 struct f_hidg *hidg =
564 fd->private_data = hidg;
580 struct f_hidg *hidg = (struct f_hidg *) req->context;
581 struct usb_composite_dev *cdev = hidg->func.config->cdev;
595 spin_lock_irqsave(&hidg->read_spinlock, flags);
596 list_add_tail(&req_list->list, &hidg->completed_out_req);
597 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
599 wake_up(&hidg->read_queue);
615 struct f_hidg *hidg = (struct f_hidg *)req->context;
616 struct usb_composite_dev *cdev = hidg->func.config->cdev;
627 spin_lock_irqsave(&hidg->read_spinlock, flags);
629 new_buf = krealloc(hidg->set_report_buf, req->actual, GFP_ATOMIC);
631 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
634 hidg->set_report_buf = new_buf;
636 hidg->set_report_length = req->actual;
637 memcpy(hidg->set_report_buf, req->buf, req->actual);
639 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
641 wake_up(&hidg->read_queue);
647 struct f_hidg *hidg = func_to_hidg(f);
666 length = min_t(unsigned, length, hidg->report_length);
676 ((u8 *) req->buf)[0] = hidg->protocol;
684 ((u8 *) req->buf)[0] = hidg->idle;
691 if (hidg->use_out_ep)
694 req->context = hidg;
708 if (hidg->bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) {
709 hidg->protocol = value;
719 hidg->idle = value >> 8;
733 cpu_to_le16(hidg->report_desc_length);
744 hidg->report_desc_length);
745 memcpy(req->buf, hidg->report_desc, length);
778 struct f_hidg *hidg = func_to_hidg(f);
782 usb_ep_disable(hidg->in_ep);
784 if (hidg->out_ep) {
785 usb_ep_disable(hidg->out_ep);
787 spin_lock_irqsave(&hidg->read_spinlock, flags);
788 list_for_each_entry_safe(list, next, &hidg->completed_out_req, list) {
789 free_ep_req(hidg->out_ep, list->req);
793 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
796 spin_lock_irqsave(&hidg->write_spinlock, flags);
797 if (!hidg->write_pending) {
798 free_ep_req(hidg->in_ep, hidg->req);
799 hidg->write_pending = 1;
802 hidg->req = NULL;
803 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
809 struct f_hidg *hidg = func_to_hidg(f);
816 if (hidg->in_ep != NULL) {
818 usb_ep_disable(hidg->in_ep);
821 hidg->in_ep);
826 status = usb_ep_enable(hidg->in_ep);
831 hidg->in_ep->driver_data = hidg;
833 req_in = hidg_alloc_ep_req(hidg->in_ep, hidg->report_length);
840 if (hidg->use_out_ep && hidg->out_ep != NULL) {
842 usb_ep_disable(hidg->out_ep);
845 hidg->out_ep);
850 status = usb_ep_enable(hidg->out_ep);
855 hidg->out_ep->driver_data = hidg;
860 for (i = 0; i < hidg->qlen && status == 0; i++) {
862 hidg_alloc_ep_req(hidg->out_ep,
863 hidg->report_length);
866 req->context = hidg;
867 status = usb_ep_queue(hidg->out_ep, req,
871 hidg->out_ep->name, status);
872 free_ep_req(hidg->out_ep, req);
881 if (hidg->in_ep != NULL) {
882 spin_lock_irqsave(&hidg->write_spinlock, flags);
883 hidg->req = req_in;
884 hidg->write_pending = 0;
885 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
887 wake_up(&hidg->write_queue);
891 if (hidg->out_ep)
892 usb_ep_disable(hidg->out_ep);
895 free_ep_req(hidg->in_ep, req_in);
898 if (hidg->in_ep)
899 usb_ep_disable(hidg->in_ep);
918 struct f_hidg *hidg = func_to_hidg(f);
940 hidg->in_ep = ep;
942 hidg->out_ep = NULL;
943 if (hidg->use_out_ep) {
947 hidg->out_ep = ep;
951 hidg->set_report_buf = NULL;
954 hidg_interface_desc.bInterfaceSubClass = hidg->bInterfaceSubClass;
955 hidg_interface_desc.bInterfaceProtocol = hidg->bInterfaceProtocol;
956 hidg_interface_desc.bNumEndpoints = hidg->use_out_ep ? 2 : 1;
957 hidg->protocol = HID_REPORT_PROTOCOL;
958 hidg->idle = 1;
959 hidg_ss_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
961 cpu_to_le16(hidg->report_length);
962 hidg_hs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
963 hidg_fs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
964 hidg_ss_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
966 cpu_to_le16(hidg->report_length);
967 hidg_hs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
968 hidg_fs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
975 cpu_to_le16(hidg->report_desc_length);
987 if (hidg->use_out_ep)
1003 spin_lock_init(&hidg->write_spinlock);
1004 hidg->write_pending = 1;
1005 hidg->req = NULL;
1006 spin_lock_init(&hidg->read_spinlock);
1007 init_waitqueue_head(&hidg->write_queue);
1008 init_waitqueue_head(&hidg->read_queue);
1009 INIT_LIST_HEAD(&hidg->completed_out_req);
1012 cdev_init(&hidg->cdev, &f_hidg_fops);
1013 status = cdev_device_add(&hidg->cdev, &hidg->dev);
1022 if (hidg->req != NULL)
1023 free_ep_req(hidg->in_ep, hidg->req);
1243 struct f_hidg *hidg;
1246 hidg = func_to_hidg(f);
1248 put_device(&hidg->dev);
1256 struct f_hidg *hidg = func_to_hidg(f);
1258 cdev_device_del(&hidg->cdev, &hidg->dev);
1265 struct f_hidg *hidg;
1270 hidg = kzalloc(sizeof(*hidg), GFP_KERNEL);
1271 if (!hidg)
1278 device_initialize(&hidg->dev);
1279 hidg->dev.release = hidg_release;
1280 hidg->dev.class = &hidg_class;
1281 hidg->dev.devt = MKDEV(major, opts->minor);
1282 ret = dev_set_name(&hidg->dev, "hidg%d", opts->minor);
1286 hidg->bInterfaceSubClass = opts->subclass;
1287 hidg->bInterfaceProtocol = opts->protocol;
1288 hidg->report_length = opts->report_length;
1289 hidg->report_desc_length = opts->report_desc_length;
1291 hidg->report_desc = kmemdup(opts->report_desc,
1294 if (!hidg->report_desc) {
1299 hidg->use_out_ep = !opts->no_out_endpoint;
1304 hidg->func.name = "hid";
1305 hidg->func.bind = hidg_bind;
1306 hidg->func.unbind = hidg_unbind;
1307 hidg->func.set_alt = hidg_set_alt;
1308 hidg->func.disable = hidg_disable;
1309 hidg->func.setup = hidg_setup;
1310 hidg->func.free_func = hidg_free;
1313 hidg->qlen = 4;
1315 return &hidg->func;
1318 put_device(&hidg->dev);
1337 status = alloc_chrdev_region(&dev, 0, count, "hidg");