Lines Matching refs:hidg
89 struct f_hidg *hidg = container_of(dev, struct f_hidg, dev);
91 kfree(hidg->report_desc);
92 kfree(hidg->set_report_buf);
93 kfree(hidg);
291 struct f_hidg *hidg = file->private_data;
300 spin_lock_irqsave(&hidg->read_spinlock, flags);
302 #define READ_COND_INTOUT (!list_empty(&hidg->completed_out_req))
306 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
310 if (wait_event_interruptible(hidg->read_queue, READ_COND_INTOUT))
313 spin_lock_irqsave(&hidg->read_spinlock, flags);
317 list = list_first_entry(&hidg->completed_out_req,
328 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
343 req->length = hidg->report_length;
344 ret = usb_ep_queue(hidg->out_ep, req, GFP_KERNEL);
346 free_ep_req(hidg->out_ep, req);
350 spin_lock_irqsave(&hidg->read_spinlock, flags);
351 list_add(&list->list, &hidg->completed_out_req);
352 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
354 wake_up(&hidg->read_queue);
360 #define READ_COND_SSREPORT (hidg->set_report_buf != NULL)
365 struct f_hidg *hidg = file->private_data;
372 spin_lock_irqsave(&hidg->read_spinlock, flags);
375 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
379 if (wait_event_interruptible(hidg->read_queue, READ_COND_SSREPORT))
382 spin_lock_irqsave(&hidg->read_spinlock, flags);
385 count = min_t(unsigned int, count, hidg->set_report_length);
386 tmp_buf = hidg->set_report_buf;
387 hidg->set_report_buf = NULL;
389 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
398 wake_up(&hidg->read_queue);
406 struct f_hidg *hidg = file->private_data;
408 if (hidg->use_out_ep)
416 struct f_hidg *hidg = (struct f_hidg *)ep->driver_data;
420 ERROR(hidg->func.config->cdev,
424 spin_lock_irqsave(&hidg->write_spinlock, flags);
425 hidg->write_pending = 0;
426 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
427 wake_up(&hidg->write_queue);
433 struct f_hidg *hidg = file->private_data;
438 spin_lock_irqsave(&hidg->write_spinlock, flags);
440 if (!hidg->req) {
441 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
445 #define WRITE_COND (!hidg->write_pending)
449 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
454 hidg->write_queue, WRITE_COND))
457 spin_lock_irqsave(&hidg->write_spinlock, flags);
460 hidg->write_pending = 1;
461 req = hidg->req;
462 count = min_t(unsigned, count, hidg->report_length);
464 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
467 ERROR(hidg->func.config->cdev, "hidg->req is NULL\n");
474 ERROR(hidg->func.config->cdev,
480 spin_lock_irqsave(&hidg->write_spinlock, flags);
483 if (!hidg->req) {
484 free_ep_req(hidg->in_ep, req);
496 req->context = hidg;
498 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
500 if (!hidg->in_ep->enabled) {
501 ERROR(hidg->func.config->cdev, "in_ep is disabled\n");
506 status = usb_ep_queue(hidg->in_ep, req, GFP_ATOMIC);
514 spin_lock_irqsave(&hidg->write_spinlock, flags);
515 hidg->write_pending = 0;
516 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
518 wake_up(&hidg->write_queue);
525 struct f_hidg *hidg = file->private_data;
528 poll_wait(file, &hidg->read_queue, wait);
529 poll_wait(file, &hidg->write_queue, wait);
534 if (hidg->use_out_ep) {
557 struct f_hidg *hidg =
560 fd->private_data = hidg;
576 struct f_hidg *hidg = (struct f_hidg *) req->context;
577 struct usb_composite_dev *cdev = hidg->func.config->cdev;
591 spin_lock_irqsave(&hidg->read_spinlock, flags);
592 list_add_tail(&req_list->list, &hidg->completed_out_req);
593 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
595 wake_up(&hidg->read_queue);
611 struct f_hidg *hidg = (struct f_hidg *)req->context;
612 struct usb_composite_dev *cdev = hidg->func.config->cdev;
623 spin_lock_irqsave(&hidg->read_spinlock, flags);
625 new_buf = krealloc(hidg->set_report_buf, req->actual, GFP_ATOMIC);
627 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
630 hidg->set_report_buf = new_buf;
632 hidg->set_report_length = req->actual;
633 memcpy(hidg->set_report_buf, req->buf, req->actual);
635 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
637 wake_up(&hidg->read_queue);
643 struct f_hidg *hidg = func_to_hidg(f);
662 length = min_t(unsigned, length, hidg->report_length);
672 ((u8 *) req->buf)[0] = hidg->protocol;
680 ((u8 *) req->buf)[0] = hidg->idle;
687 if (hidg->use_out_ep)
690 req->context = hidg;
704 if (hidg->bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) {
705 hidg->protocol = value;
715 hidg->idle = value >> 8;
729 cpu_to_le16(hidg->report_desc_length);
740 hidg->report_desc_length);
741 memcpy(req->buf, hidg->report_desc, length);
774 struct f_hidg *hidg = func_to_hidg(f);
778 usb_ep_disable(hidg->in_ep);
780 if (hidg->out_ep) {
781 usb_ep_disable(hidg->out_ep);
783 spin_lock_irqsave(&hidg->read_spinlock, flags);
784 list_for_each_entry_safe(list, next, &hidg->completed_out_req, list) {
785 free_ep_req(hidg->out_ep, list->req);
789 spin_unlock_irqrestore(&hidg->read_spinlock, flags);
792 spin_lock_irqsave(&hidg->write_spinlock, flags);
793 if (!hidg->write_pending) {
794 free_ep_req(hidg->in_ep, hidg->req);
795 hidg->write_pending = 1;
798 hidg->req = NULL;
799 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
805 struct f_hidg *hidg = func_to_hidg(f);
812 if (hidg->in_ep != NULL) {
814 usb_ep_disable(hidg->in_ep);
817 hidg->in_ep);
822 status = usb_ep_enable(hidg->in_ep);
827 hidg->in_ep->driver_data = hidg;
829 req_in = hidg_alloc_ep_req(hidg->in_ep, hidg->report_length);
836 if (hidg->use_out_ep && hidg->out_ep != NULL) {
838 usb_ep_disable(hidg->out_ep);
841 hidg->out_ep);
846 status = usb_ep_enable(hidg->out_ep);
851 hidg->out_ep->driver_data = hidg;
856 for (i = 0; i < hidg->qlen && status == 0; i++) {
858 hidg_alloc_ep_req(hidg->out_ep,
859 hidg->report_length);
862 req->context = hidg;
863 status = usb_ep_queue(hidg->out_ep, req,
867 hidg->out_ep->name, status);
868 free_ep_req(hidg->out_ep, req);
877 if (hidg->in_ep != NULL) {
878 spin_lock_irqsave(&hidg->write_spinlock, flags);
879 hidg->req = req_in;
880 hidg->write_pending = 0;
881 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
883 wake_up(&hidg->write_queue);
887 if (hidg->out_ep)
888 usb_ep_disable(hidg->out_ep);
891 free_ep_req(hidg->in_ep, req_in);
894 if (hidg->in_ep)
895 usb_ep_disable(hidg->in_ep);
914 struct f_hidg *hidg = func_to_hidg(f);
936 hidg->in_ep = ep;
938 hidg->out_ep = NULL;
939 if (hidg->use_out_ep) {
943 hidg->out_ep = ep;
947 hidg->set_report_buf = NULL;
950 hidg_interface_desc.bInterfaceSubClass = hidg->bInterfaceSubClass;
951 hidg_interface_desc.bInterfaceProtocol = hidg->bInterfaceProtocol;
952 hidg_interface_desc.bNumEndpoints = hidg->use_out_ep ? 2 : 1;
953 hidg->protocol = HID_REPORT_PROTOCOL;
954 hidg->idle = 1;
955 hidg_ss_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
957 cpu_to_le16(hidg->report_length);
958 hidg_hs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
959 hidg_fs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
960 hidg_ss_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
962 cpu_to_le16(hidg->report_length);
963 hidg_hs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
964 hidg_fs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
971 cpu_to_le16(hidg->report_desc_length);
983 if (hidg->use_out_ep)
999 spin_lock_init(&hidg->write_spinlock);
1000 hidg->write_pending = 1;
1001 hidg->req = NULL;
1002 spin_lock_init(&hidg->read_spinlock);
1003 init_waitqueue_head(&hidg->write_queue);
1004 init_waitqueue_head(&hidg->read_queue);
1005 INIT_LIST_HEAD(&hidg->completed_out_req);
1008 cdev_init(&hidg->cdev, &f_hidg_fops);
1009 status = cdev_device_add(&hidg->cdev, &hidg->dev);
1018 if (hidg->req != NULL)
1019 free_ep_req(hidg->in_ep, hidg->req);
1239 struct f_hidg *hidg;
1242 hidg = func_to_hidg(f);
1244 put_device(&hidg->dev);
1252 struct f_hidg *hidg = func_to_hidg(f);
1254 cdev_device_del(&hidg->cdev, &hidg->dev);
1261 struct f_hidg *hidg;
1266 hidg = kzalloc(sizeof(*hidg), GFP_KERNEL);
1267 if (!hidg)
1275 device_initialize(&hidg->dev);
1276 hidg->dev.release = hidg_release;
1277 hidg->dev.class = hidg_class;
1278 hidg->dev.devt = MKDEV(major, opts->minor);
1279 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) {
1295 put_device(&hidg->dev);
1301 hidg->use_out_ep = !opts->no_out_endpoint;
1305 hidg->func.name = "hid";
1306 hidg->func.bind = hidg_bind;
1307 hidg->func.unbind = hidg_unbind;
1308 hidg->func.set_alt = hidg_set_alt;
1309 hidg->func.disable = hidg_disable;
1310 hidg->func.setup = hidg_setup;
1311 hidg->func.free_func = hidg_free;
1314 hidg->qlen = 4;
1316 return &hidg->func;
1328 hidg_class = class_create(THIS_MODULE, "hidg");
1335 status = alloc_chrdev_region(&dev, 0, count, "hidg");