Lines Matching refs:dev
224 struct printer_dev *dev = container_of(kref, struct printer_dev, kref);
226 kfree(dev);
261 struct printer_dev *dev = ep->driver_data;
265 spin_lock_irqsave(&dev->lock, flags);
274 list_add_tail(&req->list, &dev->rx_buffers);
275 DBG(dev, "G_Printer : rx length %d\n", req->actual);
277 list_add(&req->list, &dev->rx_reqs);
284 VDBG(dev, "rx shutdown, code %d\n", status);
285 list_add(&req->list, &dev->rx_reqs);
290 DBG(dev, "rx %s reset\n", ep->name);
291 list_add(&req->list, &dev->rx_reqs);
299 DBG(dev, "rx status %d\n", status);
300 list_add(&req->list, &dev->rx_reqs);
304 wake_up_interruptible(&dev->rx_wait);
305 spin_unlock_irqrestore(&dev->lock, flags);
310 struct printer_dev *dev = ep->driver_data;
314 VDBG(dev, "tx err %d\n", req->status);
323 spin_lock(&dev->lock);
328 list_add(&req->list, &dev->tx_reqs);
329 wake_up_interruptible(&dev->tx_wait);
330 if (likely(list_empty(&dev->tx_reqs_active)))
331 wake_up_interruptible(&dev->tx_flush_wait);
333 spin_unlock(&dev->lock);
341 struct printer_dev *dev;
345 dev = container_of(inode->i_cdev, struct printer_dev, printer_cdev);
347 spin_lock_irqsave(&dev->lock, flags);
349 if (dev->interface < 0) {
350 spin_unlock_irqrestore(&dev->lock, flags);
354 if (!dev->printer_cdev_open) {
355 dev->printer_cdev_open = 1;
356 fd->private_data = dev;
359 dev->printer_status |= PRINTER_SELECTED;
362 spin_unlock_irqrestore(&dev->lock, flags);
364 kref_get(&dev->kref);
365 DBG(dev, "printer_open returned %x\n", ret);
372 struct printer_dev *dev = fd->private_data;
375 spin_lock_irqsave(&dev->lock, flags);
376 dev->printer_cdev_open = 0;
379 dev->printer_status &= ~PRINTER_SELECTED;
380 spin_unlock_irqrestore(&dev->lock, flags);
382 kref_put(&dev->kref, printer_dev_free);
383 DBG(dev, "printer_close\n");
390 setup_rx_reqs(struct printer_dev *dev)
394 while (likely(!list_empty(&dev->rx_reqs))) {
397 req = container_of(dev->rx_reqs.next,
411 spin_unlock(&dev->lock);
412 error = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC);
413 spin_lock(&dev->lock);
415 DBG(dev, "rx submit --> %d\n", error);
416 list_add(&req->list, &dev->rx_reqs);
419 /* if the req is empty, then add it into dev->rx_reqs_active. */
421 list_add(&req->list, &dev->rx_reqs_active);
428 struct printer_dev *dev = fd->private_data;
443 DBG(dev, "printer_read trying to read %d bytes\n", (int)len);
445 mutex_lock(&dev->lock_printer_io);
446 spin_lock_irqsave(&dev->lock, flags);
448 if (dev->interface < 0) {
449 spin_unlock_irqrestore(&dev->lock, flags);
450 mutex_unlock(&dev->lock_printer_io);
457 dev->reset_printer = 0;
459 setup_rx_reqs(dev);
462 current_rx_req = dev->current_rx_req;
463 current_rx_bytes = dev->current_rx_bytes;
464 current_rx_buf = dev->current_rx_buf;
465 dev->current_rx_req = NULL;
466 dev->current_rx_bytes = 0;
467 dev->current_rx_buf = NULL;
476 (likely(list_empty(&dev->rx_buffers)))) {
478 spin_unlock_irqrestore(&dev->lock, flags);
485 mutex_unlock(&dev->lock_printer_io);
490 wait_event_interruptible(dev->rx_wait,
491 (likely(!list_empty(&dev->rx_buffers))));
492 spin_lock_irqsave(&dev->lock, flags);
496 while ((current_rx_bytes || likely(!list_empty(&dev->rx_buffers)))
499 req = container_of(dev->rx_buffers.next,
508 list_add(&req->list, &dev->rx_reqs);
514 spin_unlock_irqrestore(&dev->lock, flags);
526 spin_lock_irqsave(&dev->lock, flags);
529 if (dev->reset_printer) {
530 list_add(¤t_rx_req->list, &dev->rx_reqs);
531 spin_unlock_irqrestore(&dev->lock, flags);
532 mutex_unlock(&dev->lock_printer_io);
545 list_add(¤t_rx_req->list, &dev->rx_reqs);
552 dev->current_rx_req = current_rx_req;
553 dev->current_rx_bytes = current_rx_bytes;
554 dev->current_rx_buf = current_rx_buf;
556 spin_unlock_irqrestore(&dev->lock, flags);
557 mutex_unlock(&dev->lock_printer_io);
559 DBG(dev, "printer_read returned %d bytes\n", (int)bytes_copied);
570 struct printer_dev *dev = fd->private_data;
577 DBG(dev, "printer_write trying to send %d bytes\n", (int)len);
582 mutex_lock(&dev->lock_printer_io);
583 spin_lock_irqsave(&dev->lock, flags);
585 if (dev->interface < 0) {
586 spin_unlock_irqrestore(&dev->lock, flags);
587 mutex_unlock(&dev->lock_printer_io);
592 dev->reset_printer = 0;
595 if (likely(list_empty(&dev->tx_reqs))) {
597 spin_unlock_irqrestore(&dev->lock, flags);
604 mutex_unlock(&dev->lock_printer_io);
609 wait_event_interruptible(dev->tx_wait,
610 (likely(!list_empty(&dev->tx_reqs))));
611 spin_lock_irqsave(&dev->lock, flags);
614 while (likely(!list_empty(&dev->tx_reqs)) && len) {
621 req = container_of(dev->tx_reqs.next, struct usb_request,
636 req->zero = ((len % dev->in_ep->maxpacket) == 0);
639 spin_unlock_irqrestore(&dev->lock, flags);
642 list_add(&req->list, &dev->tx_reqs);
643 mutex_unlock(&dev->lock_printer_io);
651 spin_lock_irqsave(&dev->lock, flags);
654 if (dev->reset_printer) {
655 list_add(&req->list, &dev->tx_reqs);
656 spin_unlock_irqrestore(&dev->lock, flags);
657 mutex_unlock(&dev->lock_printer_io);
661 list_add(&req->list, &dev->tx_reqs_active);
664 spin_unlock(&dev->lock);
665 value = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);
666 spin_lock(&dev->lock);
669 list_add(&req->list, &dev->tx_reqs);
670 spin_unlock_irqrestore(&dev->lock, flags);
671 mutex_unlock(&dev->lock_printer_io);
676 spin_unlock_irqrestore(&dev->lock, flags);
677 mutex_unlock(&dev->lock_printer_io);
679 DBG(dev, "printer_write sent %d bytes\n", (int)bytes_copied);
690 struct printer_dev *dev = fd->private_data;
696 spin_lock_irqsave(&dev->lock, flags);
698 if (dev->interface < 0) {
699 spin_unlock_irqrestore(&dev->lock, flags);
704 tx_list_empty = (likely(list_empty(&dev->tx_reqs)));
705 spin_unlock_irqrestore(&dev->lock, flags);
709 wait_event_interruptible(dev->tx_flush_wait,
710 (likely(list_empty(&dev->tx_reqs_active))));
720 struct printer_dev *dev = fd->private_data;
724 mutex_lock(&dev->lock_printer_io);
725 spin_lock_irqsave(&dev->lock, flags);
727 if (dev->interface < 0) {
728 spin_unlock_irqrestore(&dev->lock, flags);
729 mutex_unlock(&dev->lock_printer_io);
733 setup_rx_reqs(dev);
734 spin_unlock_irqrestore(&dev->lock, flags);
735 mutex_unlock(&dev->lock_printer_io);
737 poll_wait(fd, &dev->rx_wait, wait);
738 poll_wait(fd, &dev->tx_wait, wait);
740 spin_lock_irqsave(&dev->lock, flags);
741 if (likely(!list_empty(&dev->tx_reqs)))
744 if (likely(dev->current_rx_bytes) ||
745 likely(!list_empty(&dev->rx_buffers)))
748 spin_unlock_irqrestore(&dev->lock, flags);
756 struct printer_dev *dev = fd->private_data;
760 DBG(dev, "printer_ioctl: cmd=0x%4.4x, arg=%lu\n", code, arg);
764 spin_lock_irqsave(&dev->lock, flags);
766 if (dev->interface < 0) {
767 spin_unlock_irqrestore(&dev->lock, flags);
773 status = (int)dev->printer_status;
776 dev->printer_status = (u8)arg;
780 DBG(dev, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n",
785 spin_unlock_irqrestore(&dev->lock, flags);
806 set_printer_interface(struct printer_dev *dev)
810 dev->in_ep->desc = ep_desc(dev->gadget, &fs_ep_in_desc, &hs_ep_in_desc,
812 dev->in_ep->driver_data = dev;
814 dev->out_ep->desc = ep_desc(dev->gadget, &fs_ep_out_desc,
816 dev->out_ep->driver_data = dev;
818 result = usb_ep_enable(dev->in_ep);
820 DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
824 result = usb_ep_enable(dev->out_ep);
826 DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
833 (void) usb_ep_disable(dev->in_ep);
834 (void) usb_ep_disable(dev->out_ep);
835 dev->in_ep->desc = NULL;
836 dev->out_ep->desc = NULL;
843 static void printer_reset_interface(struct printer_dev *dev)
847 if (dev->interface < 0)
850 DBG(dev, "%s\n", __func__);
852 if (dev->in_ep->desc)
853 usb_ep_disable(dev->in_ep);
855 if (dev->out_ep->desc)
856 usb_ep_disable(dev->out_ep);
858 spin_lock_irqsave(&dev->lock, flags);
859 dev->in_ep->desc = NULL;
860 dev->out_ep->desc = NULL;
861 dev->interface = -1;
862 spin_unlock_irqrestore(&dev->lock, flags);
866 static int set_interface(struct printer_dev *dev, unsigned number)
871 printer_reset_interface(dev);
873 result = set_printer_interface(dev);
875 printer_reset_interface(dev);
877 dev->interface = number;
880 INFO(dev, "Using interface %x\n", number);
885 static void printer_soft_reset(struct printer_dev *dev)
889 INFO(dev, "Received Printer Reset Request\n");
891 if (usb_ep_disable(dev->in_ep))
892 DBG(dev, "Failed to disable USB in_ep\n");
893 if (usb_ep_disable(dev->out_ep))
894 DBG(dev, "Failed to disable USB out_ep\n");
896 if (dev->current_rx_req != NULL) {
897 list_add(&dev->current_rx_req->list, &dev->rx_reqs);
898 dev->current_rx_req = NULL;
900 dev->current_rx_bytes = 0;
901 dev->current_rx_buf = NULL;
902 dev->reset_printer = 1;
904 while (likely(!(list_empty(&dev->rx_buffers)))) {
905 req = container_of(dev->rx_buffers.next, struct usb_request,
908 list_add(&req->list, &dev->rx_reqs);
911 while (likely(!(list_empty(&dev->rx_reqs_active)))) {
912 req = container_of(dev->rx_buffers.next, struct usb_request,
915 list_add(&req->list, &dev->rx_reqs);
918 while (likely(!(list_empty(&dev->tx_reqs_active)))) {
919 req = container_of(dev->tx_reqs_active.next,
922 list_add(&req->list, &dev->tx_reqs);
925 if (usb_ep_enable(dev->in_ep))
926 DBG(dev, "Failed to enable USB in_ep\n");
927 if (usb_ep_enable(dev->out_ep))
928 DBG(dev, "Failed to enable USB out_ep\n");
930 wake_up_interruptible(&dev->rx_wait);
931 wake_up_interruptible(&dev->tx_wait);
932 wake_up_interruptible(&dev->tx_flush_wait);
941 struct printer_dev *dev = func_to_printer(f);
972 return w_index == dev->interface;
982 struct printer_dev *dev = func_to_printer(f);
991 DBG(dev, "ctrl req%02x.%02x v%04x i%04x l%d\n",
999 if ((wIndex>>8) != dev->interface)
1002 if (!*dev->pnp_string) {
1006 value = strlen(*dev->pnp_string);
1009 memcpy(buf + 2, *dev->pnp_string, value);
1010 DBG(dev, "1284 PNP String: %x %s\n", value,
1011 *dev->pnp_string);
1016 if (wIndex != dev->interface)
1019 buf[0] = dev->printer_status;
1025 if (wIndex != dev->interface)
1028 printer_soft_reset(dev);
1040 VDBG(dev,
1052 ERROR(dev, "%s:%d Error!\n", __func__, __LINE__);
1063 struct printer_dev *dev = func_to_printer(f);
1080 dev->gadget = gadget;
1086 dev_err(&cdev->gadget->dev, "can't autoconfigure on %s\n",
1107 dev->in_ep = in_ep;
1108 dev->out_ep = out_ep;
1111 for (i = 0; i < dev->q_len; i++) {
1112 req = printer_req_alloc(dev->in_ep, USB_BUFSIZE, GFP_KERNEL);
1115 list_add(&req->list, &dev->tx_reqs);
1118 for (i = 0; i < dev->q_len; i++) {
1119 req = printer_req_alloc(dev->out_ep, USB_BUFSIZE, GFP_KERNEL);
1122 list_add(&req->list, &dev->rx_reqs);
1126 devt = MKDEV(major, dev->minor);
1128 NULL, "g_printer%d", dev->minor);
1130 ERROR(dev, "Failed to create device: g_printer\n");
1139 cdev_init(&dev->printer_cdev, &printer_io_operations);
1140 dev->printer_cdev.owner = THIS_MODULE;
1141 ret = cdev_add(&dev->printer_cdev, devt, 1);
1143 ERROR(dev, "Failed to open char device\n");
1153 while (!list_empty(&dev->rx_reqs)) {
1154 req = container_of(dev->rx_reqs.next, struct usb_request, list);
1156 printer_req_free(dev->out_ep, req);
1160 while (!list_empty(&dev->tx_reqs)) {
1161 req = container_of(dev->tx_reqs.next, struct usb_request, list);
1163 printer_req_free(dev->in_ep, req);
1174 struct printer_dev *dev = func_to_printer(f);
1178 ret = set_interface(dev, intf);
1185 struct printer_dev *dev = func_to_printer(f);
1187 DBG(dev, "%s\n", __func__);
1189 printer_reset_interface(dev);
1397 struct printer_dev *dev = func_to_printer(f);
1402 kref_put(&dev->kref, printer_dev_free);
1411 struct printer_dev *dev;
1414 dev = func_to_printer(f);
1416 device_destroy(usb_gadget_class, MKDEV(major, dev->minor));
1419 cdev_del(&dev->printer_cdev);
1422 WARN_ON(!list_empty(&dev->tx_reqs_active));
1423 WARN_ON(!list_empty(&dev->rx_reqs_active));
1426 while (!list_empty(&dev->tx_reqs)) {
1427 req = container_of(dev->tx_reqs.next, struct usb_request,
1430 printer_req_free(dev->in_ep, req);
1433 if (dev->current_rx_req != NULL)
1434 printer_req_free(dev->out_ep, dev->current_rx_req);
1436 while (!list_empty(&dev->rx_reqs)) {
1437 req = container_of(dev->rx_reqs.next,
1440 printer_req_free(dev->out_ep, req);
1443 while (!list_empty(&dev->rx_buffers)) {
1444 req = container_of(dev->rx_buffers.next,
1447 printer_req_free(dev->out_ep, req);
1454 struct printer_dev *dev;
1465 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1466 if (!dev) {
1471 kref_init(&dev->kref);
1473 dev->minor = opts->minor;
1474 dev->pnp_string = &opts->pnp_string;
1475 dev->q_len = opts->q_len;
1478 dev->function.name = "printer";
1479 dev->function.bind = printer_func_bind;
1480 dev->function.setup = printer_func_setup;
1481 dev->function.unbind = printer_func_unbind;
1482 dev->function.set_alt = printer_func_set_alt;
1483 dev->function.disable = printer_func_disable;
1484 dev->function.req_match = gprinter_req_match;
1485 dev->function.free_func = gprinter_free;
1487 INIT_LIST_HEAD(&dev->tx_reqs);
1488 INIT_LIST_HEAD(&dev->rx_reqs);
1489 INIT_LIST_HEAD(&dev->rx_buffers);
1490 INIT_LIST_HEAD(&dev->tx_reqs_active);
1491 INIT_LIST_HEAD(&dev->rx_reqs_active);
1493 spin_lock_init(&dev->lock);
1494 mutex_init(&dev->lock_printer_io);
1495 init_waitqueue_head(&dev->rx_wait);
1496 init_waitqueue_head(&dev->tx_wait);
1497 init_waitqueue_head(&dev->tx_flush_wait);
1499 dev->interface = -1;
1500 dev->printer_cdev_open = 0;
1501 dev->printer_status = PRINTER_NOT_ERROR;
1502 dev->current_rx_req = NULL;
1503 dev->current_rx_bytes = 0;
1504 dev->current_rx_buf = NULL;
1506 return &dev->function;