2 * printer.c -- Printer gadget driver
4 * Copyright (C) 2003-2005 David Brownell
5 * Copyright (C) 2006 Craig W. Nadler
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
13 #include <linux/module.h>
14 #include <linux/kernel.h>
15 #include <linux/delay.h>
16 #include <linux/ioport.h>
17 #include <linux/sched.h>
18 #include <linux/slab.h>
19 #include <linux/mutex.h>
20 #include <linux/errno.h>
21 #include <linux/init.h>
22 #include <linux/timer.h>
23 #include <linux/list.h>
24 #include <linux/interrupt.h>
25 #include <linux/device.h>
26 #include <linux/moduleparam.h>
28 #include <linux/poll.h>
29 #include <linux/types.h>
30 #include <linux/ctype.h>
31 #include <linux/cdev.h>
33 #include <asm/byteorder.h>
35 #include <linux/irq.h>
36 #include <linux/uaccess.h>
37 #include <asm/unaligned.h>
39 #include <linux/usb/ch9.h>
40 #include <linux/usb/composite.h>
41 #include <linux/usb/gadget.h>
42 #include <linux/usb/g_printer.h>
44 #include "gadget_chips.h"
46 USB_GADGET_COMPOSITE_OPTIONS();
48 #define DRIVER_DESC "Printer Gadget"
49 #define DRIVER_VERSION "2007 OCT 06"
51 static DEFINE_MUTEX(printer_mutex
);
52 static const char shortname
[] = "printer";
53 static const char driver_desc
[] = DRIVER_DESC
;
55 static dev_t g_printer_devno
;
57 static struct class *usb_gadget_class
;
59 /*-------------------------------------------------------------------------*/
62 spinlock_t lock
; /* lock this structure */
63 /* lock buffer lists during read/write calls */
64 struct mutex lock_printer_io
;
65 struct usb_gadget
*gadget
;
67 struct usb_ep
*in_ep
, *out_ep
;
69 struct list_head rx_reqs
; /* List of free RX structs */
70 struct list_head rx_reqs_active
; /* List of Active RX xfers */
71 struct list_head rx_buffers
; /* List of completed xfers */
72 /* wait until there is data to be read. */
73 wait_queue_head_t rx_wait
;
74 struct list_head tx_reqs
; /* List of free TX structs */
75 struct list_head tx_reqs_active
; /* List of Active TX xfers */
76 /* Wait until there are write buffers available to use. */
77 wait_queue_head_t tx_wait
;
78 /* Wait until all write buffers have been sent. */
79 wait_queue_head_t tx_flush_wait
;
80 struct usb_request
*current_rx_req
;
81 size_t current_rx_bytes
;
85 struct cdev printer_cdev
;
88 wait_queue_head_t wait
;
89 struct usb_function function
;
92 static struct printer_dev usb_printer_gadget
;
94 /*-------------------------------------------------------------------------*/
96 /* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
97 * Instead: allocate your own, using normal USB-IF procedures.
100 /* Thanks to NetChip Technologies for donating this product ID.
102 #define PRINTER_VENDOR_NUM 0x0525 /* NetChip */
103 #define PRINTER_PRODUCT_NUM 0xa4a8 /* Linux-USB Printer Gadget */
105 /* Some systems will want different product identifiers published in the
106 * device descriptor, either numbers or strings or both. These string
107 * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
110 module_param_named(iSerialNum
, coverwrite
.serial_number
, charp
, S_IRUGO
);
111 MODULE_PARM_DESC(iSerialNum
, "1");
113 static char *iPNPstring
;
114 module_param(iPNPstring
, charp
, S_IRUGO
);
115 MODULE_PARM_DESC(iPNPstring
, "MFG:linux;MDL:g_printer;CLS:PRINTER;SN:1;");
117 /* Number of requests to allocate per endpoint, not used for ep0. */
118 static unsigned qlen
= 10;
119 module_param(qlen
, uint
, S_IRUGO
|S_IWUSR
);
123 /*-------------------------------------------------------------------------*/
126 * DESCRIPTORS ... most are static, but strings and (full) configuration
127 * descriptors are built on demand.
130 /* holds our biggest descriptor */
131 #define USB_DESC_BUFSIZE 256
132 #define USB_BUFSIZE 8192
134 static struct usb_device_descriptor device_desc
= {
135 .bLength
= sizeof device_desc
,
136 .bDescriptorType
= USB_DT_DEVICE
,
137 .bcdUSB
= cpu_to_le16(0x0200),
138 .bDeviceClass
= USB_CLASS_PER_INTERFACE
,
139 .bDeviceSubClass
= 0,
140 .bDeviceProtocol
= 0,
141 .idVendor
= cpu_to_le16(PRINTER_VENDOR_NUM
),
142 .idProduct
= cpu_to_le16(PRINTER_PRODUCT_NUM
),
143 .bNumConfigurations
= 1
146 static struct usb_interface_descriptor intf_desc
= {
147 .bLength
= sizeof intf_desc
,
148 .bDescriptorType
= USB_DT_INTERFACE
,
150 .bInterfaceClass
= USB_CLASS_PRINTER
,
151 .bInterfaceSubClass
= 1, /* Printer Sub-Class */
152 .bInterfaceProtocol
= 2, /* Bi-Directional */
156 static struct usb_endpoint_descriptor fs_ep_in_desc
= {
157 .bLength
= USB_DT_ENDPOINT_SIZE
,
158 .bDescriptorType
= USB_DT_ENDPOINT
,
159 .bEndpointAddress
= USB_DIR_IN
,
160 .bmAttributes
= USB_ENDPOINT_XFER_BULK
163 static struct usb_endpoint_descriptor fs_ep_out_desc
= {
164 .bLength
= USB_DT_ENDPOINT_SIZE
,
165 .bDescriptorType
= USB_DT_ENDPOINT
,
166 .bEndpointAddress
= USB_DIR_OUT
,
167 .bmAttributes
= USB_ENDPOINT_XFER_BULK
170 static struct usb_descriptor_header
*fs_printer_function
[] = {
171 (struct usb_descriptor_header
*) &intf_desc
,
172 (struct usb_descriptor_header
*) &fs_ep_in_desc
,
173 (struct usb_descriptor_header
*) &fs_ep_out_desc
,
178 * usb 2.0 devices need to expose both high speed and full speed
179 * descriptors, unless they only run at full speed.
182 static struct usb_endpoint_descriptor hs_ep_in_desc
= {
183 .bLength
= USB_DT_ENDPOINT_SIZE
,
184 .bDescriptorType
= USB_DT_ENDPOINT
,
185 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
186 .wMaxPacketSize
= cpu_to_le16(512)
189 static struct usb_endpoint_descriptor hs_ep_out_desc
= {
190 .bLength
= USB_DT_ENDPOINT_SIZE
,
191 .bDescriptorType
= USB_DT_ENDPOINT
,
192 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
193 .wMaxPacketSize
= cpu_to_le16(512)
196 static struct usb_qualifier_descriptor dev_qualifier
= {
197 .bLength
= sizeof dev_qualifier
,
198 .bDescriptorType
= USB_DT_DEVICE_QUALIFIER
,
199 .bcdUSB
= cpu_to_le16(0x0200),
200 .bDeviceClass
= USB_CLASS_PRINTER
,
201 .bNumConfigurations
= 1
204 static struct usb_descriptor_header
*hs_printer_function
[] = {
205 (struct usb_descriptor_header
*) &intf_desc
,
206 (struct usb_descriptor_header
*) &hs_ep_in_desc
,
207 (struct usb_descriptor_header
*) &hs_ep_out_desc
,
211 static struct usb_otg_descriptor otg_descriptor
= {
212 .bLength
= sizeof otg_descriptor
,
213 .bDescriptorType
= USB_DT_OTG
,
214 .bmAttributes
= USB_OTG_SRP
,
217 static const struct usb_descriptor_header
*otg_desc
[] = {
218 (struct usb_descriptor_header
*) &otg_descriptor
,
222 /* maxpacket and other transfer characteristics vary by speed. */
223 #define ep_desc(g, hs, fs) (((g)->speed == USB_SPEED_HIGH)?(hs):(fs))
225 /*-------------------------------------------------------------------------*/
227 /* descriptors that are built on-demand */
229 static char product_desc
[40] = DRIVER_DESC
;
230 static char serial_num
[40] = "1";
231 static char pnp_string
[1024] =
232 "XXMFG:linux;MDL:g_printer;CLS:PRINTER;SN:1;";
234 /* static strings, in UTF-8 */
235 static struct usb_string strings
[] = {
236 [USB_GADGET_MANUFACTURER_IDX
].s
= "",
237 [USB_GADGET_PRODUCT_IDX
].s
= product_desc
,
238 [USB_GADGET_SERIAL_IDX
].s
= serial_num
,
239 { } /* end of list */
242 static struct usb_gadget_strings stringtab_dev
= {
243 .language
= 0x0409, /* en-us */
247 static struct usb_gadget_strings
*dev_strings
[] = {
252 /*-------------------------------------------------------------------------*/
254 static struct usb_request
*
255 printer_req_alloc(struct usb_ep
*ep
, unsigned len
, gfp_t gfp_flags
)
257 struct usb_request
*req
;
259 req
= usb_ep_alloc_request(ep
, gfp_flags
);
263 req
->buf
= kmalloc(len
, gfp_flags
);
264 if (req
->buf
== NULL
) {
265 usb_ep_free_request(ep
, req
);
274 printer_req_free(struct usb_ep
*ep
, struct usb_request
*req
)
276 if (ep
!= NULL
&& req
!= NULL
) {
278 usb_ep_free_request(ep
, req
);
282 /*-------------------------------------------------------------------------*/
284 static void rx_complete(struct usb_ep
*ep
, struct usb_request
*req
)
286 struct printer_dev
*dev
= ep
->driver_data
;
287 int status
= req
->status
;
290 spin_lock_irqsave(&dev
->lock
, flags
);
292 list_del_init(&req
->list
); /* Remode from Active List */
296 /* normal completion */
298 if (req
->actual
> 0) {
299 list_add_tail(&req
->list
, &dev
->rx_buffers
);
300 DBG(dev
, "G_Printer : rx length %d\n", req
->actual
);
302 list_add(&req
->list
, &dev
->rx_reqs
);
306 /* software-driven interface shutdown */
307 case -ECONNRESET
: /* unlink */
308 case -ESHUTDOWN
: /* disconnect etc */
309 VDBG(dev
, "rx shutdown, code %d\n", status
);
310 list_add(&req
->list
, &dev
->rx_reqs
);
313 /* for hardware automagic (such as pxa) */
314 case -ECONNABORTED
: /* endpoint reset */
315 DBG(dev
, "rx %s reset\n", ep
->name
);
316 list_add(&req
->list
, &dev
->rx_reqs
);
324 DBG(dev
, "rx status %d\n", status
);
325 list_add(&req
->list
, &dev
->rx_reqs
);
329 wake_up_interruptible(&dev
->rx_wait
);
330 spin_unlock_irqrestore(&dev
->lock
, flags
);
333 static void tx_complete(struct usb_ep
*ep
, struct usb_request
*req
)
335 struct printer_dev
*dev
= ep
->driver_data
;
337 switch (req
->status
) {
339 VDBG(dev
, "tx err %d\n", req
->status
);
341 case -ECONNRESET
: /* unlink */
342 case -ESHUTDOWN
: /* disconnect etc */
348 spin_lock(&dev
->lock
);
349 /* Take the request struct off the active list and put it on the
352 list_del_init(&req
->list
);
353 list_add(&req
->list
, &dev
->tx_reqs
);
354 wake_up_interruptible(&dev
->tx_wait
);
355 if (likely(list_empty(&dev
->tx_reqs_active
)))
356 wake_up_interruptible(&dev
->tx_flush_wait
);
358 spin_unlock(&dev
->lock
);
361 /*-------------------------------------------------------------------------*/
364 printer_open(struct inode
*inode
, struct file
*fd
)
366 struct printer_dev
*dev
;
370 mutex_lock(&printer_mutex
);
371 dev
= container_of(inode
->i_cdev
, struct printer_dev
, printer_cdev
);
373 spin_lock_irqsave(&dev
->lock
, flags
);
375 if (!dev
->printer_cdev_open
) {
376 dev
->printer_cdev_open
= 1;
377 fd
->private_data
= dev
;
379 /* Change the printer status to show that it's on-line. */
380 dev
->printer_status
|= PRINTER_SELECTED
;
383 spin_unlock_irqrestore(&dev
->lock
, flags
);
385 DBG(dev
, "printer_open returned %x\n", ret
);
386 mutex_unlock(&printer_mutex
);
391 printer_close(struct inode
*inode
, struct file
*fd
)
393 struct printer_dev
*dev
= fd
->private_data
;
396 spin_lock_irqsave(&dev
->lock
, flags
);
397 dev
->printer_cdev_open
= 0;
398 fd
->private_data
= NULL
;
399 /* Change printer status to show that the printer is off-line. */
400 dev
->printer_status
&= ~PRINTER_SELECTED
;
401 spin_unlock_irqrestore(&dev
->lock
, flags
);
403 DBG(dev
, "printer_close\n");
408 /* This function must be called with interrupts turned off. */
410 setup_rx_reqs(struct printer_dev
*dev
)
412 struct usb_request
*req
;
414 while (likely(!list_empty(&dev
->rx_reqs
))) {
417 req
= container_of(dev
->rx_reqs
.next
,
418 struct usb_request
, list
);
419 list_del_init(&req
->list
);
421 /* The USB Host sends us whatever amount of data it wants to
422 * so we always set the length field to the full USB_BUFSIZE.
423 * If the amount of data is more than the read() caller asked
424 * for it will be stored in the request buffer until it is
425 * asked for by read().
427 req
->length
= USB_BUFSIZE
;
428 req
->complete
= rx_complete
;
430 /* here, we unlock, and only unlock, to avoid deadlock. */
431 spin_unlock(&dev
->lock
);
432 error
= usb_ep_queue(dev
->out_ep
, req
, GFP_ATOMIC
);
433 spin_lock(&dev
->lock
);
435 DBG(dev
, "rx submit --> %d\n", error
);
436 list_add(&req
->list
, &dev
->rx_reqs
);
439 /* if the req is empty, then add it into dev->rx_reqs_active. */
440 else if (list_empty(&req
->list
)) {
441 list_add(&req
->list
, &dev
->rx_reqs_active
);
447 printer_read(struct file
*fd
, char __user
*buf
, size_t len
, loff_t
*ptr
)
449 struct printer_dev
*dev
= fd
->private_data
;
453 struct usb_request
*req
;
454 /* This is a pointer to the current USB rx request. */
455 struct usb_request
*current_rx_req
;
456 /* This is the number of bytes in the current rx buffer. */
457 size_t current_rx_bytes
;
458 /* This is a pointer to the current rx buffer. */
464 DBG(dev
, "printer_read trying to read %d bytes\n", (int)len
);
466 mutex_lock(&dev
->lock_printer_io
);
467 spin_lock_irqsave(&dev
->lock
, flags
);
469 /* We will use this flag later to check if a printer reset happened
470 * after we turn interrupts back on.
472 dev
->reset_printer
= 0;
477 current_rx_req
= dev
->current_rx_req
;
478 current_rx_bytes
= dev
->current_rx_bytes
;
479 current_rx_buf
= dev
->current_rx_buf
;
480 dev
->current_rx_req
= NULL
;
481 dev
->current_rx_bytes
= 0;
482 dev
->current_rx_buf
= NULL
;
484 /* Check if there is any data in the read buffers. Please note that
485 * current_rx_bytes is the number of bytes in the current rx buffer.
486 * If it is zero then check if there are any other rx_buffers that
487 * are on the completed list. We are only out of data if all rx
490 if ((current_rx_bytes
== 0) &&
491 (likely(list_empty(&dev
->rx_buffers
)))) {
492 /* Turn interrupts back on before sleeping. */
493 spin_unlock_irqrestore(&dev
->lock
, flags
);
496 * If no data is available check if this is a NON-Blocking
499 if (fd
->f_flags
& (O_NONBLOCK
|O_NDELAY
)) {
500 mutex_unlock(&dev
->lock_printer_io
);
504 /* Sleep until data is available */
505 wait_event_interruptible(dev
->rx_wait
,
506 (likely(!list_empty(&dev
->rx_buffers
))));
507 spin_lock_irqsave(&dev
->lock
, flags
);
510 /* We have data to return then copy it to the caller's buffer.*/
511 while ((current_rx_bytes
|| likely(!list_empty(&dev
->rx_buffers
)))
513 if (current_rx_bytes
== 0) {
514 req
= container_of(dev
->rx_buffers
.next
,
515 struct usb_request
, list
);
516 list_del_init(&req
->list
);
518 if (req
->actual
&& req
->buf
) {
519 current_rx_req
= req
;
520 current_rx_bytes
= req
->actual
;
521 current_rx_buf
= req
->buf
;
523 list_add(&req
->list
, &dev
->rx_reqs
);
528 /* Don't leave irqs off while doing memory copies */
529 spin_unlock_irqrestore(&dev
->lock
, flags
);
531 if (len
> current_rx_bytes
)
532 size
= current_rx_bytes
;
536 size
-= copy_to_user(buf
, current_rx_buf
, size
);
537 bytes_copied
+= size
;
541 spin_lock_irqsave(&dev
->lock
, flags
);
543 /* We've disconnected or reset so return. */
544 if (dev
->reset_printer
) {
545 list_add(¤t_rx_req
->list
, &dev
->rx_reqs
);
546 spin_unlock_irqrestore(&dev
->lock
, flags
);
547 mutex_unlock(&dev
->lock_printer_io
);
551 /* If we not returning all the data left in this RX request
552 * buffer then adjust the amount of data left in the buffer.
553 * Othewise if we are done with this RX request buffer then
554 * requeue it to get any incoming data from the USB host.
556 if (size
< current_rx_bytes
) {
557 current_rx_bytes
-= size
;
558 current_rx_buf
+= size
;
560 list_add(¤t_rx_req
->list
, &dev
->rx_reqs
);
561 current_rx_bytes
= 0;
562 current_rx_buf
= NULL
;
563 current_rx_req
= NULL
;
567 dev
->current_rx_req
= current_rx_req
;
568 dev
->current_rx_bytes
= current_rx_bytes
;
569 dev
->current_rx_buf
= current_rx_buf
;
571 spin_unlock_irqrestore(&dev
->lock
, flags
);
572 mutex_unlock(&dev
->lock_printer_io
);
574 DBG(dev
, "printer_read returned %d bytes\n", (int)bytes_copied
);
583 printer_write(struct file
*fd
, const char __user
*buf
, size_t len
, loff_t
*ptr
)
585 struct printer_dev
*dev
= fd
->private_data
;
587 size_t size
; /* Amount of data in a TX request. */
588 size_t bytes_copied
= 0;
589 struct usb_request
*req
;
591 DBG(dev
, "printer_write trying to send %d bytes\n", (int)len
);
596 mutex_lock(&dev
->lock_printer_io
);
597 spin_lock_irqsave(&dev
->lock
, flags
);
599 /* Check if a printer reset happens while we have interrupts on */
600 dev
->reset_printer
= 0;
602 /* Check if there is any available write buffers */
603 if (likely(list_empty(&dev
->tx_reqs
))) {
604 /* Turn interrupts back on before sleeping. */
605 spin_unlock_irqrestore(&dev
->lock
, flags
);
608 * If write buffers are available check if this is
609 * a NON-Blocking call or not.
611 if (fd
->f_flags
& (O_NONBLOCK
|O_NDELAY
)) {
612 mutex_unlock(&dev
->lock_printer_io
);
616 /* Sleep until a write buffer is available */
617 wait_event_interruptible(dev
->tx_wait
,
618 (likely(!list_empty(&dev
->tx_reqs
))));
619 spin_lock_irqsave(&dev
->lock
, flags
);
622 while (likely(!list_empty(&dev
->tx_reqs
)) && len
) {
624 if (len
> USB_BUFSIZE
)
629 req
= container_of(dev
->tx_reqs
.next
, struct usb_request
,
631 list_del_init(&req
->list
);
633 req
->complete
= tx_complete
;
636 /* Check if we need to send a zero length packet. */
638 /* They will be more TX requests so no yet. */
641 /* If the data amount is not a multple of the
642 * maxpacket size then send a zero length packet.
644 req
->zero
= ((len
% dev
->in_ep
->maxpacket
) == 0);
646 /* Don't leave irqs off while doing memory copies */
647 spin_unlock_irqrestore(&dev
->lock
, flags
);
649 if (copy_from_user(req
->buf
, buf
, size
)) {
650 list_add(&req
->list
, &dev
->tx_reqs
);
651 mutex_unlock(&dev
->lock_printer_io
);
655 bytes_copied
+= size
;
659 spin_lock_irqsave(&dev
->lock
, flags
);
661 /* We've disconnected or reset so free the req and buffer */
662 if (dev
->reset_printer
) {
663 list_add(&req
->list
, &dev
->tx_reqs
);
664 spin_unlock_irqrestore(&dev
->lock
, flags
);
665 mutex_unlock(&dev
->lock_printer_io
);
669 if (usb_ep_queue(dev
->in_ep
, req
, GFP_ATOMIC
)) {
670 list_add(&req
->list
, &dev
->tx_reqs
);
671 spin_unlock_irqrestore(&dev
->lock
, flags
);
672 mutex_unlock(&dev
->lock_printer_io
);
676 list_add(&req
->list
, &dev
->tx_reqs_active
);
680 spin_unlock_irqrestore(&dev
->lock
, flags
);
681 mutex_unlock(&dev
->lock_printer_io
);
683 DBG(dev
, "printer_write sent %d bytes\n", (int)bytes_copied
);
693 printer_fsync(struct file
*fd
, loff_t start
, loff_t end
, int datasync
)
695 struct printer_dev
*dev
= fd
->private_data
;
696 struct inode
*inode
= file_inode(fd
);
700 mutex_lock(&inode
->i_mutex
);
701 spin_lock_irqsave(&dev
->lock
, flags
);
702 tx_list_empty
= (likely(list_empty(&dev
->tx_reqs
)));
703 spin_unlock_irqrestore(&dev
->lock
, flags
);
705 if (!tx_list_empty
) {
706 /* Sleep until all data has been sent */
707 wait_event_interruptible(dev
->tx_flush_wait
,
708 (likely(list_empty(&dev
->tx_reqs_active
))));
710 mutex_unlock(&inode
->i_mutex
);
716 printer_poll(struct file
*fd
, poll_table
*wait
)
718 struct printer_dev
*dev
= fd
->private_data
;
722 mutex_lock(&dev
->lock_printer_io
);
723 spin_lock_irqsave(&dev
->lock
, flags
);
725 spin_unlock_irqrestore(&dev
->lock
, flags
);
726 mutex_unlock(&dev
->lock_printer_io
);
728 poll_wait(fd
, &dev
->rx_wait
, wait
);
729 poll_wait(fd
, &dev
->tx_wait
, wait
);
731 spin_lock_irqsave(&dev
->lock
, flags
);
732 if (likely(!list_empty(&dev
->tx_reqs
)))
733 status
|= POLLOUT
| POLLWRNORM
;
735 if (likely(dev
->current_rx_bytes
) ||
736 likely(!list_empty(&dev
->rx_buffers
)))
737 status
|= POLLIN
| POLLRDNORM
;
739 spin_unlock_irqrestore(&dev
->lock
, flags
);
745 printer_ioctl(struct file
*fd
, unsigned int code
, unsigned long arg
)
747 struct printer_dev
*dev
= fd
->private_data
;
751 DBG(dev
, "printer_ioctl: cmd=0x%4.4x, arg=%lu\n", code
, arg
);
755 spin_lock_irqsave(&dev
->lock
, flags
);
758 case GADGET_GET_PRINTER_STATUS
:
759 status
= (int)dev
->printer_status
;
761 case GADGET_SET_PRINTER_STATUS
:
762 dev
->printer_status
= (u8
)arg
;
765 /* could not handle ioctl */
766 DBG(dev
, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n",
771 spin_unlock_irqrestore(&dev
->lock
, flags
);
776 /* used after endpoint configuration */
777 static const struct file_operations printer_io_operations
= {
778 .owner
= THIS_MODULE
,
779 .open
= printer_open
,
780 .read
= printer_read
,
781 .write
= printer_write
,
782 .fsync
= printer_fsync
,
783 .poll
= printer_poll
,
784 .unlocked_ioctl
= printer_ioctl
,
785 .release
= printer_close
,
786 .llseek
= noop_llseek
,
789 /*-------------------------------------------------------------------------*/
792 set_printer_interface(struct printer_dev
*dev
)
796 dev
->in_ep
->desc
= ep_desc(dev
->gadget
, &hs_ep_in_desc
, &fs_ep_in_desc
);
797 dev
->in_ep
->driver_data
= dev
;
799 dev
->out_ep
->desc
= ep_desc(dev
->gadget
, &hs_ep_out_desc
,
801 dev
->out_ep
->driver_data
= dev
;
803 result
= usb_ep_enable(dev
->in_ep
);
805 DBG(dev
, "enable %s --> %d\n", dev
->in_ep
->name
, result
);
809 result
= usb_ep_enable(dev
->out_ep
);
811 DBG(dev
, "enable %s --> %d\n", dev
->in_ep
->name
, result
);
816 /* on error, disable any endpoints */
818 (void) usb_ep_disable(dev
->in_ep
);
819 (void) usb_ep_disable(dev
->out_ep
);
820 dev
->in_ep
->desc
= NULL
;
821 dev
->out_ep
->desc
= NULL
;
824 /* caller is responsible for cleanup on error */
828 static void printer_reset_interface(struct printer_dev
*dev
)
830 if (dev
->interface
< 0)
833 DBG(dev
, "%s\n", __func__
);
835 if (dev
->in_ep
->desc
)
836 usb_ep_disable(dev
->in_ep
);
838 if (dev
->out_ep
->desc
)
839 usb_ep_disable(dev
->out_ep
);
841 dev
->in_ep
->desc
= NULL
;
842 dev
->out_ep
->desc
= NULL
;
846 /* Change our operational Interface. */
847 static int set_interface(struct printer_dev
*dev
, unsigned number
)
851 /* Free the current interface */
852 printer_reset_interface(dev
);
854 result
= set_printer_interface(dev
);
856 printer_reset_interface(dev
);
858 dev
->interface
= number
;
861 INFO(dev
, "Using interface %x\n", number
);
866 static void printer_soft_reset(struct printer_dev
*dev
)
868 struct usb_request
*req
;
870 INFO(dev
, "Received Printer Reset Request\n");
872 if (usb_ep_disable(dev
->in_ep
))
873 DBG(dev
, "Failed to disable USB in_ep\n");
874 if (usb_ep_disable(dev
->out_ep
))
875 DBG(dev
, "Failed to disable USB out_ep\n");
877 if (dev
->current_rx_req
!= NULL
) {
878 list_add(&dev
->current_rx_req
->list
, &dev
->rx_reqs
);
879 dev
->current_rx_req
= NULL
;
881 dev
->current_rx_bytes
= 0;
882 dev
->current_rx_buf
= NULL
;
883 dev
->reset_printer
= 1;
885 while (likely(!(list_empty(&dev
->rx_buffers
)))) {
886 req
= container_of(dev
->rx_buffers
.next
, struct usb_request
,
888 list_del_init(&req
->list
);
889 list_add(&req
->list
, &dev
->rx_reqs
);
892 while (likely(!(list_empty(&dev
->rx_reqs_active
)))) {
893 req
= container_of(dev
->rx_buffers
.next
, struct usb_request
,
895 list_del_init(&req
->list
);
896 list_add(&req
->list
, &dev
->rx_reqs
);
899 while (likely(!(list_empty(&dev
->tx_reqs_active
)))) {
900 req
= container_of(dev
->tx_reqs_active
.next
,
901 struct usb_request
, list
);
902 list_del_init(&req
->list
);
903 list_add(&req
->list
, &dev
->tx_reqs
);
906 if (usb_ep_enable(dev
->in_ep
))
907 DBG(dev
, "Failed to enable USB in_ep\n");
908 if (usb_ep_enable(dev
->out_ep
))
909 DBG(dev
, "Failed to enable USB out_ep\n");
911 wake_up_interruptible(&dev
->rx_wait
);
912 wake_up_interruptible(&dev
->tx_wait
);
913 wake_up_interruptible(&dev
->tx_flush_wait
);
916 /*-------------------------------------------------------------------------*/
919 * The setup() callback implements all the ep0 functionality that's not
920 * handled lower down.
922 static int printer_func_setup(struct usb_function
*f
,
923 const struct usb_ctrlrequest
*ctrl
)
925 struct printer_dev
*dev
= container_of(f
, struct printer_dev
, function
);
926 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
927 struct usb_request
*req
= cdev
->req
;
928 int value
= -EOPNOTSUPP
;
929 u16 wIndex
= le16_to_cpu(ctrl
->wIndex
);
930 u16 wValue
= le16_to_cpu(ctrl
->wValue
);
931 u16 wLength
= le16_to_cpu(ctrl
->wLength
);
933 DBG(dev
, "ctrl req%02x.%02x v%04x i%04x l%d\n",
934 ctrl
->bRequestType
, ctrl
->bRequest
, wValue
, wIndex
, wLength
);
936 switch (ctrl
->bRequestType
&USB_TYPE_MASK
) {
938 switch (ctrl
->bRequest
) {
939 case 0: /* Get the IEEE-1284 PNP String */
940 /* Only one printer interface is supported. */
941 if ((wIndex
>>8) != dev
->interface
)
944 value
= (pnp_string
[0]<<8)|pnp_string
[1];
945 memcpy(req
->buf
, pnp_string
, value
);
946 DBG(dev
, "1284 PNP String: %x %s\n", value
,
950 case 1: /* Get Port Status */
951 /* Only one printer interface is supported. */
952 if (wIndex
!= dev
->interface
)
955 *(u8
*)req
->buf
= dev
->printer_status
;
956 value
= min(wLength
, (u16
) 1);
959 case 2: /* Soft Reset */
960 /* Only one printer interface is supported. */
961 if (wIndex
!= dev
->interface
)
964 printer_soft_reset(dev
);
977 "unknown ctrl req%02x.%02x v%04x i%04x l%d\n",
978 ctrl
->bRequestType
, ctrl
->bRequest
,
979 wValue
, wIndex
, wLength
);
982 /* host either stalls (value < 0) or reports success */
986 static int __init
printer_func_bind(struct usb_configuration
*c
,
987 struct usb_function
*f
)
989 struct printer_dev
*dev
= container_of(f
, struct printer_dev
, function
);
990 struct usb_composite_dev
*cdev
= c
->cdev
;
991 struct usb_ep
*in_ep
;
992 struct usb_ep
*out_ep
= NULL
;
996 id
= usb_interface_id(c
, f
);
999 intf_desc
.bInterfaceNumber
= id
;
1001 /* all we really need is bulk IN/OUT */
1002 in_ep
= usb_ep_autoconfig(cdev
->gadget
, &fs_ep_in_desc
);
1005 dev_err(&cdev
->gadget
->dev
, "can't autoconfigure on %s\n",
1006 cdev
->gadget
->name
);
1009 in_ep
->driver_data
= in_ep
; /* claim */
1011 out_ep
= usb_ep_autoconfig(cdev
->gadget
, &fs_ep_out_desc
);
1014 out_ep
->driver_data
= out_ep
; /* claim */
1016 /* assumes that all endpoints are dual-speed */
1017 hs_ep_in_desc
.bEndpointAddress
= fs_ep_in_desc
.bEndpointAddress
;
1018 hs_ep_out_desc
.bEndpointAddress
= fs_ep_out_desc
.bEndpointAddress
;
1020 ret
= usb_assign_descriptors(f
, fs_printer_function
,
1021 hs_printer_function
, NULL
);
1026 dev
->out_ep
= out_ep
;
1030 static void printer_func_unbind(struct usb_configuration
*c
,
1031 struct usb_function
*f
)
1033 usb_free_all_descriptors(f
);
1036 static int printer_func_set_alt(struct usb_function
*f
,
1037 unsigned intf
, unsigned alt
)
1039 struct printer_dev
*dev
= container_of(f
, struct printer_dev
, function
);
1040 int ret
= -ENOTSUPP
;
1043 ret
= set_interface(dev
, intf
);
1048 static void printer_func_disable(struct usb_function
*f
)
1050 struct printer_dev
*dev
= container_of(f
, struct printer_dev
, function
);
1051 unsigned long flags
;
1053 DBG(dev
, "%s\n", __func__
);
1055 spin_lock_irqsave(&dev
->lock
, flags
);
1056 printer_reset_interface(dev
);
1057 spin_unlock_irqrestore(&dev
->lock
, flags
);
1060 static void printer_cfg_unbind(struct usb_configuration
*c
)
1062 struct printer_dev
*dev
;
1063 struct usb_request
*req
;
1065 dev
= &usb_printer_gadget
;
1067 DBG(dev
, "%s\n", __func__
);
1069 /* Remove sysfs files */
1070 device_destroy(usb_gadget_class
, g_printer_devno
);
1072 /* Remove Character Device */
1073 cdev_del(&dev
->printer_cdev
);
1075 /* we must already have been disconnected ... no i/o may be active */
1076 WARN_ON(!list_empty(&dev
->tx_reqs_active
));
1077 WARN_ON(!list_empty(&dev
->rx_reqs_active
));
1079 /* Free all memory for this driver. */
1080 while (!list_empty(&dev
->tx_reqs
)) {
1081 req
= container_of(dev
->tx_reqs
.next
, struct usb_request
,
1083 list_del(&req
->list
);
1084 printer_req_free(dev
->in_ep
, req
);
1087 if (dev
->current_rx_req
!= NULL
)
1088 printer_req_free(dev
->out_ep
, dev
->current_rx_req
);
1090 while (!list_empty(&dev
->rx_reqs
)) {
1091 req
= container_of(dev
->rx_reqs
.next
,
1092 struct usb_request
, list
);
1093 list_del(&req
->list
);
1094 printer_req_free(dev
->out_ep
, req
);
1097 while (!list_empty(&dev
->rx_buffers
)) {
1098 req
= container_of(dev
->rx_buffers
.next
,
1099 struct usb_request
, list
);
1100 list_del(&req
->list
);
1101 printer_req_free(dev
->out_ep
, req
);
1105 static struct usb_configuration printer_cfg_driver
= {
1107 .unbind
= printer_cfg_unbind
,
1108 .bConfigurationValue
= 1,
1109 .bmAttributes
= USB_CONFIG_ATT_ONE
| USB_CONFIG_ATT_SELFPOWER
,
1112 static int __init
printer_bind_config(struct usb_configuration
*c
)
1114 struct usb_gadget
*gadget
= c
->cdev
->gadget
;
1115 struct printer_dev
*dev
;
1116 int status
= -ENOMEM
;
1119 struct usb_request
*req
;
1121 usb_ep_autoconfig_reset(gadget
);
1123 dev
= &usb_printer_gadget
;
1125 dev
->function
.name
= shortname
;
1126 dev
->function
.bind
= printer_func_bind
;
1127 dev
->function
.setup
= printer_func_setup
;
1128 dev
->function
.unbind
= printer_func_unbind
;
1129 dev
->function
.set_alt
= printer_func_set_alt
;
1130 dev
->function
.disable
= printer_func_disable
;
1132 status
= usb_add_function(c
, &dev
->function
);
1136 /* Setup the sysfs files for the printer gadget. */
1137 dev
->pdev
= device_create(usb_gadget_class
, NULL
, g_printer_devno
,
1139 if (IS_ERR(dev
->pdev
)) {
1140 ERROR(dev
, "Failed to create device: g_printer\n");
1141 status
= PTR_ERR(dev
->pdev
);
1146 * Register a character device as an interface to a user mode
1147 * program that handles the printer specific functionality.
1149 cdev_init(&dev
->printer_cdev
, &printer_io_operations
);
1150 dev
->printer_cdev
.owner
= THIS_MODULE
;
1151 status
= cdev_add(&dev
->printer_cdev
, g_printer_devno
, 1);
1153 ERROR(dev
, "Failed to open char device\n");
1158 strlcpy(&pnp_string
[2], iPNPstring
, (sizeof pnp_string
)-2);
1160 len
= strlen(pnp_string
);
1161 pnp_string
[0] = (len
>> 8) & 0xFF;
1162 pnp_string
[1] = len
& 0xFF;
1164 usb_gadget_set_selfpowered(gadget
);
1166 if (gadget_is_otg(gadget
)) {
1167 otg_descriptor
.bmAttributes
|= USB_OTG_HNP
;
1168 printer_cfg_driver
.descriptors
= otg_desc
;
1169 printer_cfg_driver
.bmAttributes
|= USB_CONFIG_ATT_WAKEUP
;
1172 spin_lock_init(&dev
->lock
);
1173 mutex_init(&dev
->lock_printer_io
);
1174 INIT_LIST_HEAD(&dev
->tx_reqs
);
1175 INIT_LIST_HEAD(&dev
->tx_reqs_active
);
1176 INIT_LIST_HEAD(&dev
->rx_reqs
);
1177 INIT_LIST_HEAD(&dev
->rx_reqs_active
);
1178 INIT_LIST_HEAD(&dev
->rx_buffers
);
1179 init_waitqueue_head(&dev
->rx_wait
);
1180 init_waitqueue_head(&dev
->tx_wait
);
1181 init_waitqueue_head(&dev
->tx_flush_wait
);
1183 dev
->interface
= -1;
1184 dev
->printer_cdev_open
= 0;
1185 dev
->printer_status
= PRINTER_NOT_ERROR
;
1186 dev
->current_rx_req
= NULL
;
1187 dev
->current_rx_bytes
= 0;
1188 dev
->current_rx_buf
= NULL
;
1190 for (i
= 0; i
< QLEN
; i
++) {
1191 req
= printer_req_alloc(dev
->in_ep
, USB_BUFSIZE
, GFP_KERNEL
);
1193 while (!list_empty(&dev
->tx_reqs
)) {
1194 req
= container_of(dev
->tx_reqs
.next
,
1195 struct usb_request
, list
);
1196 list_del(&req
->list
);
1197 printer_req_free(dev
->in_ep
, req
);
1201 list_add(&req
->list
, &dev
->tx_reqs
);
1204 for (i
= 0; i
< QLEN
; i
++) {
1205 req
= printer_req_alloc(dev
->out_ep
, USB_BUFSIZE
, GFP_KERNEL
);
1207 while (!list_empty(&dev
->rx_reqs
)) {
1208 req
= container_of(dev
->rx_reqs
.next
,
1209 struct usb_request
, list
);
1210 list_del(&req
->list
);
1211 printer_req_free(dev
->out_ep
, req
);
1215 list_add(&req
->list
, &dev
->rx_reqs
);
1218 /* finish hookup to lower layer ... */
1219 dev
->gadget
= gadget
;
1221 INFO(dev
, "%s, version: " DRIVER_VERSION
"\n", driver_desc
);
1225 printer_cfg_unbind(c
);
1229 static int printer_unbind(struct usb_composite_dev
*cdev
)
1234 static int __init
printer_bind(struct usb_composite_dev
*cdev
)
1238 ret
= usb_string_ids_tab(cdev
, strings
);
1241 device_desc
.iManufacturer
= strings
[USB_GADGET_MANUFACTURER_IDX
].id
;
1242 device_desc
.iProduct
= strings
[USB_GADGET_PRODUCT_IDX
].id
;
1243 device_desc
.iSerialNumber
= strings
[USB_GADGET_SERIAL_IDX
].id
;
1245 ret
= usb_add_config(cdev
, &printer_cfg_driver
, printer_bind_config
);
1248 usb_composite_overwrite_options(cdev
, &coverwrite
);
1252 static __refdata
struct usb_composite_driver printer_driver
= {
1254 .dev
= &device_desc
,
1255 .strings
= dev_strings
,
1256 .max_speed
= USB_SPEED_HIGH
,
1257 .bind
= printer_bind
,
1258 .unbind
= printer_unbind
,
1266 usb_gadget_class
= class_create(THIS_MODULE
, "usb_printer_gadget");
1267 if (IS_ERR(usb_gadget_class
)) {
1268 status
= PTR_ERR(usb_gadget_class
);
1269 pr_err("unable to create usb_gadget class %d\n", status
);
1273 status
= alloc_chrdev_region(&g_printer_devno
, 0, 1,
1274 "USB printer gadget");
1276 pr_err("alloc_chrdev_region %d\n", status
);
1277 class_destroy(usb_gadget_class
);
1281 status
= usb_composite_probe(&printer_driver
);
1283 class_destroy(usb_gadget_class
);
1284 unregister_chrdev_region(g_printer_devno
, 1);
1285 pr_err("usb_gadget_probe_driver %x\n", status
);
1295 mutex_lock(&usb_printer_gadget
.lock_printer_io
);
1296 usb_composite_unregister(&printer_driver
);
1297 unregister_chrdev_region(g_printer_devno
, 1);
1298 class_destroy(usb_gadget_class
);
1299 mutex_unlock(&usb_printer_gadget
.lock_printer_io
);
1301 module_exit(cleanup
);
1303 MODULE_DESCRIPTION(DRIVER_DESC
);
1304 MODULE_AUTHOR("Craig Nadler");
1305 MODULE_LICENSE("GPL");