Lines Matching refs:dev
229 struct printer_dev *dev = container_of(kref, struct printer_dev, kref);
231 kfree(dev);
266 struct printer_dev *dev = ep->driver_data;
270 spin_lock_irqsave(&dev->lock, flags);
279 list_add_tail(&req->list, &dev->rx_buffers);
280 DBG(dev, "G_Printer : rx length %d\n", req->actual);
282 list_add(&req->list, &dev->rx_reqs);
289 VDBG(dev, "rx shutdown, code %d\n", status);
290 list_add(&req->list, &dev->rx_reqs);
295 DBG(dev, "rx %s reset\n", ep->name);
296 list_add(&req->list, &dev->rx_reqs);
304 DBG(dev, "rx status %d\n", status);
305 list_add(&req->list, &dev->rx_reqs);
309 wake_up_interruptible(&dev->rx_wait);
310 spin_unlock_irqrestore(&dev->lock, flags);
315 struct printer_dev *dev = ep->driver_data;
319 VDBG(dev, "tx err %d\n", req->status);
328 spin_lock(&dev->lock);
333 list_add(&req->list, &dev->tx_reqs);
334 wake_up_interruptible(&dev->tx_wait);
335 if (likely(list_empty(&dev->tx_reqs_active)))
336 wake_up_interruptible(&dev->tx_flush_wait);
338 spin_unlock(&dev->lock);
346 struct printer_dev *dev;
350 dev = container_of(inode->i_cdev, struct printer_dev, printer_cdev);
352 spin_lock_irqsave(&dev->lock, flags);
354 if (dev->interface < 0) {
355 spin_unlock_irqrestore(&dev->lock, flags);
359 if (!dev->printer_cdev_open) {
360 dev->printer_cdev_open = 1;
361 fd->private_data = dev;
364 dev->printer_status |= PRINTER_SELECTED;
367 spin_unlock_irqrestore(&dev->lock, flags);
369 kref_get(&dev->kref);
377 struct printer_dev *dev = fd->private_data;
380 spin_lock_irqsave(&dev->lock, flags);
381 dev->printer_cdev_open = 0;
384 dev->printer_status &= ~PRINTER_SELECTED;
385 spin_unlock_irqrestore(&dev->lock, flags);
387 kref_put(&dev->kref, printer_dev_free);
394 setup_rx_reqs(struct printer_dev *dev)
398 while (likely(!list_empty(&dev->rx_reqs))) {
401 req = container_of(dev->rx_reqs.next,
415 spin_unlock(&dev->lock);
416 error = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC);
417 spin_lock(&dev->lock);
419 DBG(dev, "rx submit --> %d\n", error);
420 list_add(&req->list, &dev->rx_reqs);
423 /* if the req is empty, then add it into dev->rx_reqs_active. */
425 list_add(&req->list, &dev->rx_reqs_active);
432 struct printer_dev *dev = fd->private_data;
447 DBG(dev, "printer_read trying to read %d bytes\n", (int)len);
449 mutex_lock(&dev->lock_printer_io);
450 spin_lock_irqsave(&dev->lock, flags);
452 if (dev->interface < 0) {
453 spin_unlock_irqrestore(&dev->lock, flags);
454 mutex_unlock(&dev->lock_printer_io);
461 dev->reset_printer = 0;
463 setup_rx_reqs(dev);
466 current_rx_req = dev->current_rx_req;
467 current_rx_bytes = dev->current_rx_bytes;
468 current_rx_buf = dev->current_rx_buf;
469 dev->current_rx_req = NULL;
470 dev->current_rx_bytes = 0;
471 dev->current_rx_buf = NULL;
480 (likely(list_empty(&dev->rx_buffers)))) {
482 spin_unlock_irqrestore(&dev->lock, flags);
489 mutex_unlock(&dev->lock_printer_io);
494 wait_event_interruptible(dev->rx_wait,
495 (likely(!list_empty(&dev->rx_buffers))));
496 spin_lock_irqsave(&dev->lock, flags);
500 while ((current_rx_bytes || likely(!list_empty(&dev->rx_buffers)))
503 req = container_of(dev->rx_buffers.next,
512 list_add(&req->list, &dev->rx_reqs);
518 spin_unlock_irqrestore(&dev->lock, flags);
530 spin_lock_irqsave(&dev->lock, flags);
533 if (dev->reset_printer) {
534 list_add(¤t_rx_req->list, &dev->rx_reqs);
535 spin_unlock_irqrestore(&dev->lock, flags);
536 mutex_unlock(&dev->lock_printer_io);
549 list_add(¤t_rx_req->list, &dev->rx_reqs);
556 dev->current_rx_req = current_rx_req;
557 dev->current_rx_bytes = current_rx_bytes;
558 dev->current_rx_buf = current_rx_buf;
560 spin_unlock_irqrestore(&dev->lock, flags);
561 mutex_unlock(&dev->lock_printer_io);
563 DBG(dev, "printer_read returned %d bytes\n", (int)bytes_copied);
574 struct printer_dev *dev = fd->private_data;
581 DBG(dev, "printer_write trying to send %d bytes\n", (int)len);
586 mutex_lock(&dev->lock_printer_io);
587 spin_lock_irqsave(&dev->lock, flags);
589 if (dev->interface < 0) {
590 spin_unlock_irqrestore(&dev->lock, flags);
591 mutex_unlock(&dev->lock_printer_io);
596 dev->reset_printer = 0;
599 if (likely(list_empty(&dev->tx_reqs))) {
601 spin_unlock_irqrestore(&dev->lock, flags);
608 mutex_unlock(&dev->lock_printer_io);
613 wait_event_interruptible(dev->tx_wait,
614 (likely(!list_empty(&dev->tx_reqs))));
615 spin_lock_irqsave(&dev->lock, flags);
618 while (likely(!list_empty(&dev->tx_reqs)) && len) {
625 req = container_of(dev->tx_reqs.next, struct usb_request,
640 req->zero = ((len % dev->in_ep->maxpacket) == 0);
643 spin_unlock_irqrestore(&dev->lock, flags);
646 list_add(&req->list, &dev->tx_reqs);
647 mutex_unlock(&dev->lock_printer_io);
655 spin_lock_irqsave(&dev->lock, flags);
658 if (dev->reset_printer) {
659 list_add(&req->list, &dev->tx_reqs);
660 spin_unlock_irqrestore(&dev->lock, flags);
661 mutex_unlock(&dev->lock_printer_io);
665 list_add(&req->list, &dev->tx_reqs_active);
668 spin_unlock(&dev->lock);
669 value = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);
670 spin_lock(&dev->lock);
672 list_move(&req->list, &dev->tx_reqs);
673 spin_unlock_irqrestore(&dev->lock, flags);
674 mutex_unlock(&dev->lock_printer_io);
679 spin_unlock_irqrestore(&dev->lock, flags);
680 mutex_unlock(&dev->lock_printer_io);
682 DBG(dev, "printer_write sent %d bytes\n", (int)bytes_copied);
693 struct printer_dev *dev = fd->private_data;
699 spin_lock_irqsave(&dev->lock, flags);
701 if (dev->interface < 0) {
702 spin_unlock_irqrestore(&dev->lock, flags);
707 tx_list_empty = (likely(list_empty(&dev->tx_reqs)));
708 spin_unlock_irqrestore(&dev->lock, flags);
712 wait_event_interruptible(dev->tx_flush_wait,
713 (likely(list_empty(&dev->tx_reqs_active))));
723 struct printer_dev *dev = fd->private_data;
727 mutex_lock(&dev->lock_printer_io);
728 spin_lock_irqsave(&dev->lock, flags);
730 if (dev->interface < 0) {
731 spin_unlock_irqrestore(&dev->lock, flags);
732 mutex_unlock(&dev->lock_printer_io);
736 setup_rx_reqs(dev);
737 spin_unlock_irqrestore(&dev->lock, flags);
738 mutex_unlock(&dev->lock_printer_io);
740 poll_wait(fd, &dev->rx_wait, wait);
741 poll_wait(fd, &dev->tx_wait, wait);
743 spin_lock_irqsave(&dev->lock, flags);
744 if (likely(!list_empty(&dev->tx_reqs)))
747 if (likely(dev->current_rx_bytes) ||
748 likely(!list_empty(&dev->rx_buffers)))
751 spin_unlock_irqrestore(&dev->lock, flags);
759 struct printer_dev *dev = fd->private_data;
763 DBG(dev, "printer_ioctl: cmd=0x%4.4x, arg=%lu\n", code, arg);
767 spin_lock_irqsave(&dev->lock, flags);
769 if (dev->interface < 0) {
770 spin_unlock_irqrestore(&dev->lock, flags);
776 status = (int)dev->printer_status;
779 dev->printer_status = (u8)arg;
783 DBG(dev, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n",
788 spin_unlock_irqrestore(&dev->lock, flags);
809 set_printer_interface(struct printer_dev *dev)
813 dev->in_ep->desc = ep_desc(dev->gadget, &fs_ep_in_desc, &hs_ep_in_desc,
815 dev->in_ep->driver_data = dev;
817 dev->out_ep->desc = ep_desc(dev->gadget, &fs_ep_out_desc,
819 dev->out_ep->driver_data = dev;
821 result = usb_ep_enable(dev->in_ep);
823 DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
827 result = usb_ep_enable(dev->out_ep);
829 DBG(dev, "enable %s --> %d\n", dev->out_ep->name, result);
836 (void) usb_ep_disable(dev->in_ep);
837 (void) usb_ep_disable(dev->out_ep);
838 dev->in_ep->desc = NULL;
839 dev->out_ep->desc = NULL;
846 static void printer_reset_interface(struct printer_dev *dev)
850 if (dev->interface < 0)
853 if (dev->in_ep->desc)
854 usb_ep_disable(dev->in_ep);
856 if (dev->out_ep->desc)
857 usb_ep_disable(dev->out_ep);
859 spin_lock_irqsave(&dev->lock, flags);
860 dev->in_ep->desc = NULL;
861 dev->out_ep->desc = NULL;
862 dev->interface = -1;
863 spin_unlock_irqrestore(&dev->lock, flags);
867 static int set_interface(struct printer_dev *dev, unsigned number)
872 printer_reset_interface(dev);
874 result = set_printer_interface(dev);
876 printer_reset_interface(dev);
878 dev->interface = number;
881 INFO(dev, "Using interface %x\n", number);
886 static void printer_soft_reset(struct printer_dev *dev)
890 if (usb_ep_disable(dev->in_ep))
891 DBG(dev, "Failed to disable USB in_ep\n");
892 if (usb_ep_disable(dev->out_ep))
893 DBG(dev, "Failed to disable USB out_ep\n");
895 if (dev->current_rx_req != NULL) {
896 list_add(&dev->current_rx_req->list, &dev->rx_reqs);
897 dev->current_rx_req = NULL;
899 dev->current_rx_bytes = 0;
900 dev->current_rx_buf = NULL;
901 dev->reset_printer = 1;
903 while (likely(!(list_empty(&dev->rx_buffers)))) {
904 req = container_of(dev->rx_buffers.next, struct usb_request,
907 list_add(&req->list, &dev->rx_reqs);
910 while (likely(!(list_empty(&dev->rx_reqs_active)))) {
911 req = container_of(dev->rx_buffers.next, struct usb_request,
914 list_add(&req->list, &dev->rx_reqs);
917 while (likely(!(list_empty(&dev->tx_reqs_active)))) {
918 req = container_of(dev->tx_reqs_active.next,
921 list_add(&req->list, &dev->tx_reqs);
924 if (usb_ep_enable(dev->in_ep))
925 DBG(dev, "Failed to enable USB in_ep\n");
926 if (usb_ep_enable(dev->out_ep))
927 DBG(dev, "Failed to enable USB out_ep\n");
929 wake_up_interruptible(&dev->rx_wait);
930 wake_up_interruptible(&dev->tx_wait);
931 wake_up_interruptible(&dev->tx_flush_wait);
940 struct printer_dev *dev = func_to_printer(f);
971 return w_index == dev->interface;
981 struct printer_dev *dev = func_to_printer(f);
990 DBG(dev, "ctrl req%02x.%02x v%04x i%04x l%d\n",
998 if ((wIndex>>8) != dev->interface)
1001 if (!*dev->pnp_string) {
1005 value = strlen(*dev->pnp_string);
1008 memcpy(buf + 2, *dev->pnp_string, value);
1009 DBG(dev, "1284 PNP String: %x %s\n", value,
1010 *dev->pnp_string);
1015 if (wIndex != dev->interface)
1018 buf[0] = dev->printer_status;
1024 if (wIndex != dev->interface)
1027 printer_soft_reset(dev);
1039 VDBG(dev,
1051 ERROR(dev, "%s:%d Error!\n", __func__, __LINE__);
1062 struct printer_dev *dev = func_to_printer(f);
1079 dev->gadget = gadget;
1085 dev_err(&cdev->gadget->dev, "can't autoconfigure on %s\n",
1106 dev->in_ep = in_ep;
1107 dev->out_ep = out_ep;
1110 for (i = 0; i < dev->q_len; i++) {
1111 req = printer_req_alloc(dev->in_ep, USB_BUFSIZE, GFP_KERNEL);
1114 list_add(&req->list, &dev->tx_reqs);
1117 for (i = 0; i < dev->q_len; i++) {
1118 req = printer_req_alloc(dev->out_ep, USB_BUFSIZE, GFP_KERNEL);
1121 list_add(&req->list, &dev->rx_reqs);
1125 devt = MKDEV(major, dev->minor);
1127 NULL, "g_printer%d", dev->minor);
1129 ERROR(dev, "Failed to create device: g_printer\n");
1138 cdev_init(&dev->printer_cdev, &printer_io_operations);
1139 dev->printer_cdev.owner = THIS_MODULE;
1140 ret = cdev_add(&dev->printer_cdev, devt, 1);
1142 ERROR(dev, "Failed to open char device\n");
1152 while (!list_empty(&dev->rx_reqs)) {
1153 req = container_of(dev->rx_reqs.next, struct usb_request, list);
1155 printer_req_free(dev->out_ep, req);
1159 while (!list_empty(&dev->tx_reqs)) {
1160 req = container_of(dev->tx_reqs.next, struct usb_request, list);
1162 printer_req_free(dev->in_ep, req);
1173 struct printer_dev *dev = func_to_printer(f);
1177 ret = set_interface(dev, intf);
1184 struct printer_dev *dev = func_to_printer(f);
1186 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;