?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: move U300 GPIO driver to drivers/gpio
[linux-2.6/libata-dev.git] / drivers / usb / gadget / printer.c
blob271ef94668e719867d12c00a9ce9c1681c825f23
1 /*
2 * printer.c -- Printer gadget driver
3 *
4 * Copyright (C) 2003-2005 David Brownell
5 * Copyright (C) 2006 Craig W. Nadler
6 *
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.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/delay.h>
25 #include <linux/ioport.h>
26 #include <linux/sched.h>
27 #include <linux/slab.h>
28 #include <linux/mutex.h>
29 #include <linux/errno.h>
30 #include <linux/init.h>
31 #include <linux/timer.h>
32 #include <linux/list.h>
33 #include <linux/interrupt.h>
34 #include <linux/utsname.h>
35 #include <linux/device.h>
36 #include <linux/moduleparam.h>
37 #include <linux/fs.h>
38 #include <linux/poll.h>
39 #include <linux/types.h>
40 #include <linux/ctype.h>
41 #include <linux/cdev.h>
42
43 #include <asm/byteorder.h>
44 #include <linux/io.h>
45 #include <linux/irq.h>
46 #include <asm/system.h>
47 #include <linux/uaccess.h>
48 #include <asm/unaligned.h>
49
50 #include <linux/usb/ch9.h>
51 #include <linux/usb/gadget.h>
52 #include <linux/usb/g_printer.h>
53
54 #include "gadget_chips.h"
55
56
57 /*
58 * Kbuild is not very cooperative with respect to linking separately
59 * compiled library objects into one module. So for now we won't use
60 * separate compilation ... ensuring init/exit sections work to shrink
61 * the runtime footprint, and giving us at least some parts of what
62 * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
63 */
64 #include "usbstring.c"
65 #include "config.c"
66 #include "epautoconf.c"
67
68 /*-------------------------------------------------------------------------*/
69
70 #define DRIVER_DESC "Printer Gadget"
71 #define DRIVER_VERSION "2007 OCT 06"
72
73 static DEFINE_MUTEX(printer_mutex);
74 static const char shortname [] = "printer";
75 static const char driver_desc [] = DRIVER_DESC;
76
77 static dev_t g_printer_devno;
78
79 static struct class *usb_gadget_class;
80
81 /*-------------------------------------------------------------------------*/
82
83 struct printer_dev {
84 spinlock_t lock; /* lock this structure */
85 /* lock buffer lists during read/write calls */
86 struct mutex lock_printer_io;
87 struct usb_gadget *gadget;
88 struct usb_request *req; /* for control responses */
89 u8 config;
90 s8 interface;
91 struct usb_ep *in_ep, *out_ep;
92 const struct usb_endpoint_descriptor
93 *in, *out;
94 struct list_head rx_reqs; /* List of free RX structs */
95 struct list_head rx_reqs_active; /* List of Active RX xfers */
96 struct list_head rx_buffers; /* List of completed xfers */
97 /* wait until there is data to be read. */
98 wait_queue_head_t rx_wait;
99 struct list_head tx_reqs; /* List of free TX structs */
100 struct list_head tx_reqs_active; /* List of Active TX xfers */
101 /* Wait until there are write buffers available to use. */
102 wait_queue_head_t tx_wait;
103 /* Wait until all write buffers have been sent. */
104 wait_queue_head_t tx_flush_wait;
105 struct usb_request *current_rx_req;
106 size_t current_rx_bytes;
107 u8 *current_rx_buf;
108 u8 printer_status;
109 u8 reset_printer;
110 struct cdev printer_cdev;
111 struct device *pdev;
112 u8 printer_cdev_open;
113 wait_queue_head_t wait;
114 };
115
116 static struct printer_dev usb_printer_gadget;
117
118 /*-------------------------------------------------------------------------*/
119
120 /* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
121 * Instead: allocate your own, using normal USB-IF procedures.
122 */
123
124 /* Thanks to NetChip Technologies for donating this product ID.
125 */
126 #define PRINTER_VENDOR_NUM 0x0525 /* NetChip */
127 #define PRINTER_PRODUCT_NUM 0xa4a8 /* Linux-USB Printer Gadget */
128
129 /* Some systems will want different product identifiers published in the
130 * device descriptor, either numbers or strings or both. These string
131 * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
132 */
133
134 static ushort idVendor;
135 module_param(idVendor, ushort, S_IRUGO);
136 MODULE_PARM_DESC(idVendor, "USB Vendor ID");
137
138 static ushort idProduct;
139 module_param(idProduct, ushort, S_IRUGO);
140 MODULE_PARM_DESC(idProduct, "USB Product ID");
141
142 static ushort bcdDevice;
143 module_param(bcdDevice, ushort, S_IRUGO);
144 MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
145
146 static char *iManufacturer;
147 module_param(iManufacturer, charp, S_IRUGO);
148 MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
149
150 static char *iProduct;
151 module_param(iProduct, charp, S_IRUGO);
152 MODULE_PARM_DESC(iProduct, "USB Product string");
153
154 static char *iSerialNum;
155 module_param(iSerialNum, charp, S_IRUGO);
156 MODULE_PARM_DESC(iSerialNum, "1");
157
158 static char *iPNPstring;
159 module_param(iPNPstring, charp, S_IRUGO);
160 MODULE_PARM_DESC(iPNPstring, "MFG:linux;MDL:g_printer;CLS:PRINTER;SN:1;");
161
162 /* Number of requests to allocate per endpoint, not used for ep0. */
163 static unsigned qlen = 10;
164 module_param(qlen, uint, S_IRUGO|S_IWUSR);
165
166 #define QLEN qlen
167
168 #ifdef CONFIG_USB_GADGET_DUALSPEED
169 #define DEVSPEED USB_SPEED_HIGH
170 #else /* full speed (low speed doesn't do bulk) */
171 #define DEVSPEED USB_SPEED_FULL
172 #endif
173
174 /*-------------------------------------------------------------------------*/
175
176 #define xprintk(d, level, fmt, args...) \
177 printk(level "%s: " fmt, DRIVER_DESC, ## args)
178
179 #ifdef DEBUG
180 #define DBG(dev, fmt, args...) \
181 xprintk(dev, KERN_DEBUG, fmt, ## args)
182 #else
183 #define DBG(dev, fmt, args...) \
184 do { } while (0)
185 #endif /* DEBUG */
186
187 #ifdef VERBOSE
188 #define VDBG(dev, fmt, args...) \
189 xprintk(dev, KERN_DEBUG, fmt, ## args)
190 #else
191 #define VDBG(dev, fmt, args...) \
192 do { } while (0)
193 #endif /* VERBOSE */
194
195 #define ERROR(dev, fmt, args...) \
196 xprintk(dev, KERN_ERR, fmt, ## args)
197 #define WARNING(dev, fmt, args...) \
198 xprintk(dev, KERN_WARNING, fmt, ## args)
199 #define INFO(dev, fmt, args...) \
200 xprintk(dev, KERN_INFO, fmt, ## args)
201
202 /*-------------------------------------------------------------------------*/
203
204 /* USB DRIVER HOOKUP (to the hardware driver, below us), mostly
205 * ep0 implementation: descriptors, config management, setup().
206 * also optional class-specific notification interrupt transfer.
207 */
208
209 /*
210 * DESCRIPTORS ... most are static, but strings and (full) configuration
211 * descriptors are built on demand.
212 */
213
214 #define STRING_MANUFACTURER 1
215 #define STRING_PRODUCT 2
216 #define STRING_SERIALNUM 3
217
218 /* holds our biggest descriptor */
219 #define USB_DESC_BUFSIZE 256
220 #define USB_BUFSIZE 8192
221
222 /* This device advertises one configuration. */
223 #define DEV_CONFIG_VALUE 1
224 #define PRINTER_INTERFACE 0
225
226 static struct usb_device_descriptor device_desc = {
227 .bLength = sizeof device_desc,
228 .bDescriptorType = USB_DT_DEVICE,
229 .bcdUSB = cpu_to_le16(0x0200),
230 .bDeviceClass = USB_CLASS_PER_INTERFACE,
231 .bDeviceSubClass = 0,
232 .bDeviceProtocol = 0,
233 .idVendor = cpu_to_le16(PRINTER_VENDOR_NUM),
234 .idProduct = cpu_to_le16(PRINTER_PRODUCT_NUM),
235 .iManufacturer = STRING_MANUFACTURER,
236 .iProduct = STRING_PRODUCT,
237 .iSerialNumber = STRING_SERIALNUM,
238 .bNumConfigurations = 1
239 };
240
241 static struct usb_otg_descriptor otg_desc = {
242 .bLength = sizeof otg_desc,
243 .bDescriptorType = USB_DT_OTG,
244 .bmAttributes = USB_OTG_SRP
245 };
246
247 static struct usb_config_descriptor config_desc = {
248 .bLength = sizeof config_desc,
249 .bDescriptorType = USB_DT_CONFIG,
250
251 /* compute wTotalLength on the fly */
252 .bNumInterfaces = 1,
253 .bConfigurationValue = DEV_CONFIG_VALUE,
254 .iConfiguration = 0,
255 .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
256 .bMaxPower = CONFIG_USB_GADGET_VBUS_DRAW / 2,
257 };
258
259 static struct usb_interface_descriptor intf_desc = {
260 .bLength = sizeof intf_desc,
261 .bDescriptorType = USB_DT_INTERFACE,
262 .bInterfaceNumber = PRINTER_INTERFACE,
263 .bNumEndpoints = 2,
264 .bInterfaceClass = USB_CLASS_PRINTER,
265 .bInterfaceSubClass = 1, /* Printer Sub-Class */
266 .bInterfaceProtocol = 2, /* Bi-Directional */
267 .iInterface = 0
268 };
269
270 static struct usb_endpoint_descriptor fs_ep_in_desc = {
271 .bLength = USB_DT_ENDPOINT_SIZE,
272 .bDescriptorType = USB_DT_ENDPOINT,
273 .bEndpointAddress = USB_DIR_IN,
274 .bmAttributes = USB_ENDPOINT_XFER_BULK
275 };
276
277 static struct usb_endpoint_descriptor fs_ep_out_desc = {
278 .bLength = USB_DT_ENDPOINT_SIZE,
279 .bDescriptorType = USB_DT_ENDPOINT,
280 .bEndpointAddress = USB_DIR_OUT,
281 .bmAttributes = USB_ENDPOINT_XFER_BULK
282 };
283
284 static const struct usb_descriptor_header *fs_printer_function [11] = {
285 (struct usb_descriptor_header *) &otg_desc,
286 (struct usb_descriptor_header *) &intf_desc,
287 (struct usb_descriptor_header *) &fs_ep_in_desc,
288 (struct usb_descriptor_header *) &fs_ep_out_desc,
289 NULL
290 };
291
292 #ifdef CONFIG_USB_GADGET_DUALSPEED
293
294 /*
295 * usb 2.0 devices need to expose both high speed and full speed
296 * descriptors, unless they only run at full speed.
297 */
298
299 static struct usb_endpoint_descriptor hs_ep_in_desc = {
300 .bLength = USB_DT_ENDPOINT_SIZE,
301 .bDescriptorType = USB_DT_ENDPOINT,
302 .bmAttributes = USB_ENDPOINT_XFER_BULK,
303 .wMaxPacketSize = cpu_to_le16(512)
304 };
305
306 static struct usb_endpoint_descriptor hs_ep_out_desc = {
307 .bLength = USB_DT_ENDPOINT_SIZE,
308 .bDescriptorType = USB_DT_ENDPOINT,
309 .bmAttributes = USB_ENDPOINT_XFER_BULK,
310 .wMaxPacketSize = cpu_to_le16(512)
311 };
312
313 static struct usb_qualifier_descriptor dev_qualifier = {
314 .bLength = sizeof dev_qualifier,
315 .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
316 .bcdUSB = cpu_to_le16(0x0200),
317 .bDeviceClass = USB_CLASS_PRINTER,
318 .bNumConfigurations = 1
319 };
320
321 static const struct usb_descriptor_header *hs_printer_function [11] = {
322 (struct usb_descriptor_header *) &otg_desc,
323 (struct usb_descriptor_header *) &intf_desc,
324 (struct usb_descriptor_header *) &hs_ep_in_desc,
325 (struct usb_descriptor_header *) &hs_ep_out_desc,
326 NULL
327 };
328
329 /* maxpacket and other transfer characteristics vary by speed. */
330 #define ep_desc(g, hs, fs) (((g)->speed == USB_SPEED_HIGH)?(hs):(fs))
331
332 #else
333
334 /* if there's no high speed support, maxpacket doesn't change. */
335 #define ep_desc(g, hs, fs) (((void)(g)), (fs))
336
337 #endif /* !CONFIG_USB_GADGET_DUALSPEED */
338
339 /*-------------------------------------------------------------------------*/
340
341 /* descriptors that are built on-demand */
342
343 static char manufacturer [50];
344 static char product_desc [40] = DRIVER_DESC;
345 static char serial_num [40] = "1";
346 static char pnp_string [1024] =
347 "XXMFG:linux;MDL:g_printer;CLS:PRINTER;SN:1;";
348
349 /* static strings, in UTF-8 */
350 static struct usb_string strings [] = {
351 { STRING_MANUFACTURER, manufacturer, },
352 { STRING_PRODUCT, product_desc, },
353 { STRING_SERIALNUM, serial_num, },
354 { } /* end of list */
355 };
356
357 static struct usb_gadget_strings stringtab = {
358 .language = 0x0409, /* en-us */
359 .strings = strings,
360 };
361
362 /*-------------------------------------------------------------------------*/
363
364 static struct usb_request *
365 printer_req_alloc(struct usb_ep *ep, unsigned len, gfp_t gfp_flags)
366 {
367 struct usb_request *req;
368
369 req = usb_ep_alloc_request(ep, gfp_flags);
370
371 if (req != NULL) {
372 req->length = len;
373 req->buf = kmalloc(len, gfp_flags);
374 if (req->buf == NULL) {
375 usb_ep_free_request(ep, req);
376 return NULL;
377 }
378 }
379
380 return req;
381 }
382
383 static void
384 printer_req_free(struct usb_ep *ep, struct usb_request *req)
385 {
386 if (ep != NULL && req != NULL) {
387 kfree(req->buf);
388 usb_ep_free_request(ep, req);
389 }
390 }
391
392 /*-------------------------------------------------------------------------*/
393
394 static void rx_complete(struct usb_ep *ep, struct usb_request *req)
395 {
396 struct printer_dev *dev = ep->driver_data;
397 int status = req->status;
398 unsigned long flags;
399
400 spin_lock_irqsave(&dev->lock, flags);
401
402 list_del_init(&req->list); /* Remode from Active List */
403
404 switch (status) {
405
406 /* normal completion */
407 case 0:
408 if (req->actual > 0) {
409 list_add_tail(&req->list, &dev->rx_buffers);
410 DBG(dev, "G_Printer : rx length %d\n", req->actual);
411 } else {
412 list_add(&req->list, &dev->rx_reqs);
413 }
414 break;
415
416 /* software-driven interface shutdown */
417 case -ECONNRESET: /* unlink */
418 case -ESHUTDOWN: /* disconnect etc */
419 VDBG(dev, "rx shutdown, code %d\n", status);
420 list_add(&req->list, &dev->rx_reqs);
421 break;
422
423 /* for hardware automagic (such as pxa) */
424 case -ECONNABORTED: /* endpoint reset */
425 DBG(dev, "rx %s reset\n", ep->name);
426 list_add(&req->list, &dev->rx_reqs);
427 break;
428
429 /* data overrun */
430 case -EOVERFLOW:
431 /* FALLTHROUGH */
432
433 default:
434 DBG(dev, "rx status %d\n", status);
435 list_add(&req->list, &dev->rx_reqs);
436 break;
437 }
438
439 wake_up_interruptible(&dev->rx_wait);
440 spin_unlock_irqrestore(&dev->lock, flags);
441 }
442
443 static void tx_complete(struct usb_ep *ep, struct usb_request *req)
444 {
445 struct printer_dev *dev = ep->driver_data;
446
447 switch (req->status) {
448 default:
449 VDBG(dev, "tx err %d\n", req->status);
450 /* FALLTHROUGH */
451 case -ECONNRESET: /* unlink */
452 case -ESHUTDOWN: /* disconnect etc */
453 break;
454 case 0:
455 break;
456 }
457
458 spin_lock(&dev->lock);
459 /* Take the request struct off the active list and put it on the
460 * free list.
461 */
462 list_del_init(&req->list);
463 list_add(&req->list, &dev->tx_reqs);
464 wake_up_interruptible(&dev->tx_wait);
465 if (likely(list_empty(&dev->tx_reqs_active)))
466 wake_up_interruptible(&dev->tx_flush_wait);
467
468 spin_unlock(&dev->lock);
469 }
470
471 /*-------------------------------------------------------------------------*/
472
473 static int
474 printer_open(struct inode *inode, struct file *fd)
475 {
476 struct printer_dev *dev;
477 unsigned long flags;
478 int ret = -EBUSY;
479
480 mutex_lock(&printer_mutex);
481 dev = container_of(inode->i_cdev, struct printer_dev, printer_cdev);
482
483 spin_lock_irqsave(&dev->lock, flags);
484
485 if (!dev->printer_cdev_open) {
486 dev->printer_cdev_open = 1;
487 fd->private_data = dev;
488 ret = 0;
489 /* Change the printer status to show that it's on-line. */
490 dev->printer_status |= PRINTER_SELECTED;
491 }
492
493 spin_unlock_irqrestore(&dev->lock, flags);
494
495 DBG(dev, "printer_open returned %x\n", ret);
496 mutex_unlock(&printer_mutex);
497 return ret;
498 }
499
500 static int
501 printer_close(struct inode *inode, struct file *fd)
502 {
503 struct printer_dev *dev = fd->private_data;
504 unsigned long flags;
505
506 spin_lock_irqsave(&dev->lock, flags);
507 dev->printer_cdev_open = 0;
508 fd->private_data = NULL;
509 /* Change printer status to show that the printer is off-line. */
510 dev->printer_status &= ~PRINTER_SELECTED;
511 spin_unlock_irqrestore(&dev->lock, flags);
512
513 DBG(dev, "printer_close\n");
514
515 return 0;
516 }
517
518 /* This function must be called with interrupts turned off. */
519 static void
520 setup_rx_reqs(struct printer_dev *dev)
521 {
522 struct usb_request *req;
523
524 while (likely(!list_empty(&dev->rx_reqs))) {
525 int error;
526
527 req = container_of(dev->rx_reqs.next,
528 struct usb_request, list);
529 list_del_init(&req->list);
530
531 /* The USB Host sends us whatever amount of data it wants to
532 * so we always set the length field to the full USB_BUFSIZE.
533 * If the amount of data is more than the read() caller asked
534 * for it will be stored in the request buffer until it is
535 * asked for by read().
536 */
537 req->length = USB_BUFSIZE;
538 req->complete = rx_complete;
539
540 error = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC);
541 if (error) {
542 DBG(dev, "rx submit --> %d\n", error);
543 list_add(&req->list, &dev->rx_reqs);
544 break;
545 } else {
546 list_add(&req->list, &dev->rx_reqs_active);
547 }
548 }
549 }
550
551 static ssize_t
552 printer_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr)
553 {
554 struct printer_dev *dev = fd->private_data;
555 unsigned long flags;
556 size_t size;
557 size_t bytes_copied;
558 struct usb_request *req;
559 /* This is a pointer to the current USB rx request. */
560 struct usb_request *current_rx_req;
561 /* This is the number of bytes in the current rx buffer. */
562 size_t current_rx_bytes;
563 /* This is a pointer to the current rx buffer. */
564 u8 *current_rx_buf;
565
566 if (len == 0)
567 return -EINVAL;
568
569 DBG(dev, "printer_read trying to read %d bytes\n", (int)len);
570
571 mutex_lock(&dev->lock_printer_io);
572 spin_lock_irqsave(&dev->lock, flags);
573
574 /* We will use this flag later to check if a printer reset happened
575 * after we turn interrupts back on.
576 */
577 dev->reset_printer = 0;
578
579 setup_rx_reqs(dev);
580
581 bytes_copied = 0;
582 current_rx_req = dev->current_rx_req;
583 current_rx_bytes = dev->current_rx_bytes;
584 current_rx_buf = dev->current_rx_buf;
585 dev->current_rx_req = NULL;
586 dev->current_rx_bytes = 0;
587 dev->current_rx_buf = NULL;
588
589 /* Check if there is any data in the read buffers. Please note that
590 * current_rx_bytes is the number of bytes in the current rx buffer.
591 * If it is zero then check if there are any other rx_buffers that
592 * are on the completed list. We are only out of data if all rx
593 * buffers are empty.
594 */
595 if ((current_rx_bytes == 0) &&
596 (likely(list_empty(&dev->rx_buffers)))) {
597 /* Turn interrupts back on before sleeping. */
598 spin_unlock_irqrestore(&dev->lock, flags);
599
600 /*
601 * If no data is available check if this is a NON-Blocking
602 * call or not.
603 */
604 if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) {
605 mutex_unlock(&dev->lock_printer_io);
606 return -EAGAIN;
607 }
608
609 /* Sleep until data is available */
610 wait_event_interruptible(dev->rx_wait,
611 (likely(!list_empty(&dev->rx_buffers))));
612 spin_lock_irqsave(&dev->lock, flags);
613 }
614
615 /* We have data to return then copy it to the caller's buffer.*/
616 while ((current_rx_bytes || likely(!list_empty(&dev->rx_buffers)))
617 && len) {
618 if (current_rx_bytes == 0) {
619 req = container_of(dev->rx_buffers.next,
620 struct usb_request, list);
621 list_del_init(&req->list);
622
623 if (req->actual && req->buf) {
624 current_rx_req = req;
625 current_rx_bytes = req->actual;
626 current_rx_buf = req->buf;
627 } else {
628 list_add(&req->list, &dev->rx_reqs);
629 continue;
630 }
631 }
632
633 /* Don't leave irqs off while doing memory copies */
634 spin_unlock_irqrestore(&dev->lock, flags);
635
636 if (len > current_rx_bytes)
637 size = current_rx_bytes;
638 else
639 size = len;
640
641 size -= copy_to_user(buf, current_rx_buf, size);
642 bytes_copied += size;
643 len -= size;
644 buf += size;
645
646 spin_lock_irqsave(&dev->lock, flags);
647
648 /* We've disconnected or reset so return. */
649 if (dev->reset_printer) {
650 list_add(&current_rx_req->list, &dev->rx_reqs);
651 spin_unlock_irqrestore(&dev->lock, flags);
652 mutex_unlock(&dev->lock_printer_io);
653 return -EAGAIN;
654 }
655
656 /* If we not returning all the data left in this RX request
657 * buffer then adjust the amount of data left in the buffer.
658 * Othewise if we are done with this RX request buffer then
659 * requeue it to get any incoming data from the USB host.
660 */
661 if (size < current_rx_bytes) {
662 current_rx_bytes -= size;
663 current_rx_buf += size;
664 } else {
665 list_add(&current_rx_req->list, &dev->rx_reqs);
666 current_rx_bytes = 0;
667 current_rx_buf = NULL;
668 current_rx_req = NULL;
669 }
670 }
671
672 dev->current_rx_req = current_rx_req;
673 dev->current_rx_bytes = current_rx_bytes;
674 dev->current_rx_buf = current_rx_buf;
675
676 spin_unlock_irqrestore(&dev->lock, flags);
677 mutex_unlock(&dev->lock_printer_io);
678
679 DBG(dev, "printer_read returned %d bytes\n", (int)bytes_copied);
680
681 if (bytes_copied)
682 return bytes_copied;
683 else
684 return -EAGAIN;
685 }
686
687 static ssize_t
688 printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
689 {
690 struct printer_dev *dev = fd->private_data;
691 unsigned long flags;
692 size_t size; /* Amount of data in a TX request. */
693 size_t bytes_copied = 0;
694 struct usb_request *req;
695
696 DBG(dev, "printer_write trying to send %d bytes\n", (int)len);
697
698 if (len == 0)
699 return -EINVAL;
700
701 mutex_lock(&dev->lock_printer_io);
702 spin_lock_irqsave(&dev->lock, flags);
703
704 /* Check if a printer reset happens while we have interrupts on */
705 dev->reset_printer = 0;
706
707 /* Check if there is any available write buffers */
708 if (likely(list_empty(&dev->tx_reqs))) {
709 /* Turn interrupts back on before sleeping. */
710 spin_unlock_irqrestore(&dev->lock, flags);
711
712 /*
713 * If write buffers are available check if this is
714 * a NON-Blocking call or not.
715 */
716 if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) {
717 mutex_unlock(&dev->lock_printer_io);
718 return -EAGAIN;
719 }
720
721 /* Sleep until a write buffer is available */
722 wait_event_interruptible(dev->tx_wait,
723 (likely(!list_empty(&dev->tx_reqs))));
724 spin_lock_irqsave(&dev->lock, flags);
725 }
726
727 while (likely(!list_empty(&dev->tx_reqs)) && len) {
728
729 if (len > USB_BUFSIZE)
730 size = USB_BUFSIZE;
731 else
732 size = len;
733
734 req = container_of(dev->tx_reqs.next, struct usb_request,
735 list);
736 list_del_init(&req->list);
737
738 req->complete = tx_complete;
739 req->length = size;
740
741 /* Check if we need to send a zero length packet. */
742 if (len > size)
743 /* They will be more TX requests so no yet. */
744 req->zero = 0;
745 else
746 /* If the data amount is not a multple of the
747 * maxpacket size then send a zero length packet.
748 */
749 req->zero = ((len % dev->in_ep->maxpacket) == 0);
750
751 /* Don't leave irqs off while doing memory copies */
752 spin_unlock_irqrestore(&dev->lock, flags);
753
754 if (copy_from_user(req->buf, buf, size)) {
755 list_add(&req->list, &dev->tx_reqs);
756 mutex_unlock(&dev->lock_printer_io);
757 return bytes_copied;
758 }
759
760 bytes_copied += size;
761 len -= size;
762 buf += size;
763
764 spin_lock_irqsave(&dev->lock, flags);
765
766 /* We've disconnected or reset so free the req and buffer */
767 if (dev->reset_printer) {
768 list_add(&req->list, &dev->tx_reqs);
769 spin_unlock_irqrestore(&dev->lock, flags);
770 mutex_unlock(&dev->lock_printer_io);
771 return -EAGAIN;
772 }
773
774 if (usb_ep_queue(dev->in_ep, req, GFP_ATOMIC)) {
775 list_add(&req->list, &dev->tx_reqs);
776 spin_unlock_irqrestore(&dev->lock, flags);
777 mutex_unlock(&dev->lock_printer_io);
778 return -EAGAIN;
779 }
780
781 list_add(&req->list, &dev->tx_reqs_active);
782
783 }
784
785 spin_unlock_irqrestore(&dev->lock, flags);
786 mutex_unlock(&dev->lock_printer_io);
787
788 DBG(dev, "printer_write sent %d bytes\n", (int)bytes_copied);
789
790 if (bytes_copied) {
791 return bytes_copied;
792 } else {
793 return -EAGAIN;
794 }
795 }
796
797 static int
798 printer_fsync(struct file *fd, int datasync)
799 {
800 struct printer_dev *dev = fd->private_data;
801 unsigned long flags;
802 int tx_list_empty;
803
804 spin_lock_irqsave(&dev->lock, flags);
805 tx_list_empty = (likely(list_empty(&dev->tx_reqs)));
806 spin_unlock_irqrestore(&dev->lock, flags);
807
808 if (!tx_list_empty) {
809 /* Sleep until all data has been sent */
810 wait_event_interruptible(dev->tx_flush_wait,
811 (likely(list_empty(&dev->tx_reqs_active))));
812 }
813
814 return 0;
815 }
816
817 static unsigned int
818 printer_poll(struct file *fd, poll_table *wait)
819 {
820 struct printer_dev *dev = fd->private_data;
821 unsigned long flags;
822 int status = 0;
823
824 mutex_lock(&dev->lock_printer_io);
825 spin_lock_irqsave(&dev->lock, flags);
826 setup_rx_reqs(dev);
827 spin_unlock_irqrestore(&dev->lock, flags);
828 mutex_unlock(&dev->lock_printer_io);
829
830 poll_wait(fd, &dev->rx_wait, wait);
831 poll_wait(fd, &dev->tx_wait, wait);
832
833 spin_lock_irqsave(&dev->lock, flags);
834 if (likely(!list_empty(&dev->tx_reqs)))
835 status |= POLLOUT | POLLWRNORM;
836
837 if (likely(dev->current_rx_bytes) ||
838 likely(!list_empty(&dev->rx_buffers)))
839 status |= POLLIN | POLLRDNORM;
840
841 spin_unlock_irqrestore(&dev->lock, flags);
842
843 return status;
844 }
845
846 static long
847 printer_ioctl(struct file *fd, unsigned int code, unsigned long arg)
848 {
849 struct printer_dev *dev = fd->private_data;
850 unsigned long flags;
851 int status = 0;
852
853 DBG(dev, "printer_ioctl: cmd=0x%4.4x, arg=%lu\n", code, arg);
854
855 /* handle ioctls */
856
857 spin_lock_irqsave(&dev->lock, flags);
858
859 switch (code) {
860 case GADGET_GET_PRINTER_STATUS:
861 status = (int)dev->printer_status;
862 break;
863 case GADGET_SET_PRINTER_STATUS:
864 dev->printer_status = (u8)arg;
865 break;
866 default:
867 /* could not handle ioctl */
868 DBG(dev, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n",
869 code);
870 status = -ENOTTY;
871 }
872
873 spin_unlock_irqrestore(&dev->lock, flags);
874
875 return status;
876 }
877
878 /* used after endpoint configuration */
879 static const struct file_operations printer_io_operations = {
880 .owner = THIS_MODULE,
881 .open = printer_open,
882 .read = printer_read,
883 .write = printer_write,
884 .fsync = printer_fsync,
885 .poll = printer_poll,
886 .unlocked_ioctl = printer_ioctl,
887 .release = printer_close,
888 .llseek = noop_llseek,
889 };
890
891 /*-------------------------------------------------------------------------*/
892
893 static int
894 set_printer_interface(struct printer_dev *dev)
895 {
896 int result = 0;
897
898 dev->in = ep_desc(dev->gadget, &hs_ep_in_desc, &fs_ep_in_desc);
899 dev->in_ep->driver_data = dev;
900
901 dev->out = ep_desc(dev->gadget, &hs_ep_out_desc, &fs_ep_out_desc);
902 dev->out_ep->driver_data = dev;
903
904 result = usb_ep_enable(dev->in_ep, dev->in);
905 if (result != 0) {
906 DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
907 goto done;
908 }
909
910 result = usb_ep_enable(dev->out_ep, dev->out);
911 if (result != 0) {
912 DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
913 goto done;
914 }
915
916 done:
917 /* on error, disable any endpoints */
918 if (result != 0) {
919 (void) usb_ep_disable(dev->in_ep);
920 (void) usb_ep_disable(dev->out_ep);
921 dev->in = NULL;
922 dev->out = NULL;
923 }
924
925 /* caller is responsible for cleanup on error */
926 return result;
927 }
928
929 static void printer_reset_interface(struct printer_dev *dev)
930 {
931 if (dev->interface < 0)
932 return;
933
934 DBG(dev, "%s\n", __func__);
935
936 if (dev->in)
937 usb_ep_disable(dev->in_ep);
938
939 if (dev->out)
940 usb_ep_disable(dev->out_ep);
941
942 dev->interface = -1;
943 }
944
945 /* change our operational config. must agree with the code
946 * that returns config descriptors, and altsetting code.
947 */
948 static int
949 printer_set_config(struct printer_dev *dev, unsigned number)
950 {
951 int result = 0;
952 struct usb_gadget *gadget = dev->gadget;
953
954 switch (number) {
955 case DEV_CONFIG_VALUE:
956 result = 0;
957 break;
958 default:
959 result = -EINVAL;
960 /* FALL THROUGH */
961 case 0:
962 break;
963 }
964
965 if (result) {
966 usb_gadget_vbus_draw(dev->gadget,
967 dev->gadget->is_otg ? 8 : 100);
968 } else {
969 char *speed;
970 unsigned power;
971
972 power = 2 * config_desc.bMaxPower;
973 usb_gadget_vbus_draw(dev->gadget, power);
974
975 switch (gadget->speed) {
976 case USB_SPEED_FULL: speed = "full"; break;
977 #ifdef CONFIG_USB_GADGET_DUALSPEED
978 case USB_SPEED_HIGH: speed = "high"; break;
979 #endif
980 default: speed = "?"; break;
981 }
982
983 dev->config = number;
984 INFO(dev, "%s speed config #%d: %d mA, %s\n",
985 speed, number, power, driver_desc);
986 }
987 return result;
988 }
989
990 static int
991 config_buf(enum usb_device_speed speed, u8 *buf, u8 type, unsigned index,
992 int is_otg)
993 {
994 int len;
995 const struct usb_descriptor_header **function;
996 #ifdef CONFIG_USB_GADGET_DUALSPEED
997 int hs = (speed == USB_SPEED_HIGH);
998
999 if (type == USB_DT_OTHER_SPEED_CONFIG)
1000 hs = !hs;
1001
1002 if (hs) {
1003 function = hs_printer_function;
1004 } else {
1005 function = fs_printer_function;
1006 }
1007 #else
1008 function = fs_printer_function;
1009 #endif
1010
1011 if (index >= device_desc.bNumConfigurations)
1012 return -EINVAL;
1013
1014 /* for now, don't advertise srp-only devices */
1015 if (!is_otg)
1016 function++;
1017
1018 len = usb_gadget_config_buf(&config_desc, buf, USB_DESC_BUFSIZE,
1019 function);
1020 if (len < 0)
1021 return len;
1022 ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
1023 return len;
1024 }
1025
1026 /* Change our operational Interface. */
1027 static int
1028 set_interface(struct printer_dev *dev, unsigned number)
1029 {
1030 int result = 0;
1031
1032 /* Free the current interface */
1033 switch (dev->interface) {
1034 case PRINTER_INTERFACE:
1035 printer_reset_interface(dev);
1036 break;
1037 }
1038
1039 switch (number) {
1040 case PRINTER_INTERFACE:
1041 result = set_printer_interface(dev);
1042 if (result) {
1043 printer_reset_interface(dev);
1044 } else {
1045 dev->interface = PRINTER_INTERFACE;
1046 }
1047 break;
1048 default:
1049 result = -EINVAL;
1050 /* FALL THROUGH */
1051 }
1052
1053 if (!result)
1054 INFO(dev, "Using interface %x\n", number);
1055
1056 return result;
1057 }
1058
1059 static void printer_setup_complete(struct usb_ep *ep, struct usb_request *req)
1060 {
1061 if (req->status || req->actual != req->length)
1062 DBG((struct printer_dev *) ep->driver_data,
1063 "setup complete --> %d, %d/%d\n",
1064 req->status, req->actual, req->length);
1065 }
1066
1067 static void printer_soft_reset(struct printer_dev *dev)
1068 {
1069 struct usb_request *req;
1070
1071 INFO(dev, "Received Printer Reset Request\n");
1072
1073 if (usb_ep_disable(dev->in_ep))
1074 DBG(dev, "Failed to disable USB in_ep\n");
1075 if (usb_ep_disable(dev->out_ep))
1076 DBG(dev, "Failed to disable USB out_ep\n");
1077
1078 if (dev->current_rx_req != NULL) {
1079 list_add(&dev->current_rx_req->list, &dev->rx_reqs);
1080 dev->current_rx_req = NULL;
1081 }
1082 dev->current_rx_bytes = 0;
1083 dev->current_rx_buf = NULL;
1084 dev->reset_printer = 1;
1085
1086 while (likely(!(list_empty(&dev->rx_buffers)))) {
1087 req = container_of(dev->rx_buffers.next, struct usb_request,
1088 list);
1089 list_del_init(&req->list);
1090 list_add(&req->list, &dev->rx_reqs);
1091 }
1092
1093 while (likely(!(list_empty(&dev->rx_reqs_active)))) {
1094 req = container_of(dev->rx_buffers.next, struct usb_request,
1095 list);
1096 list_del_init(&req->list);
1097 list_add(&req->list, &dev->rx_reqs);
1098 }
1099
1100 while (likely(!(list_empty(&dev->tx_reqs_active)))) {
1101 req = container_of(dev->tx_reqs_active.next,
1102 struct usb_request, list);
1103 list_del_init(&req->list);
1104 list_add(&req->list, &dev->tx_reqs);
1105 }
1106
1107 if (usb_ep_enable(dev->in_ep, dev->in))
1108 DBG(dev, "Failed to enable USB in_ep\n");
1109 if (usb_ep_enable(dev->out_ep, dev->out))
1110 DBG(dev, "Failed to enable USB out_ep\n");
1111
1112 wake_up_interruptible(&dev->rx_wait);
1113 wake_up_interruptible(&dev->tx_wait);
1114 wake_up_interruptible(&dev->tx_flush_wait);
1115 }
1116
1117 /*-------------------------------------------------------------------------*/
1118
1119 /*
1120 * The setup() callback implements all the ep0 functionality that's not
1121 * handled lower down.
1122 */
1123 static int
1124 printer_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1125 {
1126 struct printer_dev *dev = get_gadget_data(gadget);
1127 struct usb_request *req = dev->req;
1128 int value = -EOPNOTSUPP;
1129 u16 wIndex = le16_to_cpu(ctrl->wIndex);
1130 u16 wValue = le16_to_cpu(ctrl->wValue);
1131 u16 wLength = le16_to_cpu(ctrl->wLength);
1132
1133 DBG(dev, "ctrl req%02x.%02x v%04x i%04x l%d\n",
1134 ctrl->bRequestType, ctrl->bRequest, wValue, wIndex, wLength);
1135
1136 req->complete = printer_setup_complete;
1137
1138 switch (ctrl->bRequestType&USB_TYPE_MASK) {
1139
1140 case USB_TYPE_STANDARD:
1141 switch (ctrl->bRequest) {
1142
1143 case USB_REQ_GET_DESCRIPTOR:
1144 if (ctrl->bRequestType != USB_DIR_IN)
1145 break;
1146 switch (wValue >> 8) {
1147
1148 case USB_DT_DEVICE:
1149 value = min(wLength, (u16) sizeof device_desc);
1150 memcpy(req->buf, &device_desc, value);
1151 break;
1152 #ifdef CONFIG_USB_GADGET_DUALSPEED
1153 case USB_DT_DEVICE_QUALIFIER:
1154 if (!gadget->is_dualspeed)
1155 break;
1156 value = min(wLength,
1157 (u16) sizeof dev_qualifier);
1158 memcpy(req->buf, &dev_qualifier, value);
1159 break;
1160
1161 case USB_DT_OTHER_SPEED_CONFIG:
1162 if (!gadget->is_dualspeed)
1163 break;
1164 /* FALLTHROUGH */
1165 #endif /* CONFIG_USB_GADGET_DUALSPEED */
1166 case USB_DT_CONFIG:
1167 value = config_buf(gadget->speed, req->buf,
1168 wValue >> 8,
1169 wValue & 0xff,
1170 gadget->is_otg);
1171 if (value >= 0)
1172 value = min(wLength, (u16) value);
1173 break;
1174
1175 case USB_DT_STRING:
1176 value = usb_gadget_get_string(&stringtab,
1177 wValue & 0xff, req->buf);
1178 if (value >= 0)
1179 value = min(wLength, (u16) value);
1180 break;
1181 }
1182 break;
1183
1184 case USB_REQ_SET_CONFIGURATION:
1185 if (ctrl->bRequestType != 0)
1186 break;
1187 if (gadget->a_hnp_support)
1188 DBG(dev, "HNP available\n");
1189 else if (gadget->a_alt_hnp_support)
1190 DBG(dev, "HNP needs a different root port\n");
1191 value = printer_set_config(dev, wValue);
1192 if (!value)
1193 value = set_interface(dev, PRINTER_INTERFACE);
1194 break;
1195 case USB_REQ_GET_CONFIGURATION:
1196 if (ctrl->bRequestType != USB_DIR_IN)
1197 break;
1198 *(u8 *)req->buf = dev->config;
1199 value = min(wLength, (u16) 1);
1200 break;
1201
1202 case USB_REQ_SET_INTERFACE:
1203 if (ctrl->bRequestType != USB_RECIP_INTERFACE ||
1204 !dev->config)
1205 break;
1206
1207 value = set_interface(dev, PRINTER_INTERFACE);
1208 break;
1209 case USB_REQ_GET_INTERFACE:
1210 if (ctrl->bRequestType !=
1211 (USB_DIR_IN|USB_RECIP_INTERFACE)
1212 || !dev->config)
1213 break;
1214
1215 *(u8 *)req->buf = dev->interface;
1216 value = min(wLength, (u16) 1);
1217 break;
1218
1219 default:
1220 goto unknown;
1221 }
1222 break;
1223
1224 case USB_TYPE_CLASS:
1225 switch (ctrl->bRequest) {
1226 case 0: /* Get the IEEE-1284 PNP String */
1227 /* Only one printer interface is supported. */
1228 if ((wIndex>>8) != PRINTER_INTERFACE)
1229 break;
1230
1231 value = (pnp_string[0]<<8)|pnp_string[1];
1232 memcpy(req->buf, pnp_string, value);
1233 DBG(dev, "1284 PNP String: %x %s\n", value,
1234 &pnp_string[2]);
1235 break;
1236
1237 case 1: /* Get Port Status */
1238 /* Only one printer interface is supported. */
1239 if (wIndex != PRINTER_INTERFACE)
1240 break;
1241
1242 *(u8 *)req->buf = dev->printer_status;
1243 value = min(wLength, (u16) 1);
1244 break;
1245
1246 case 2: /* Soft Reset */
1247 /* Only one printer interface is supported. */
1248 if (wIndex != PRINTER_INTERFACE)
1249 break;
1250
1251 printer_soft_reset(dev);
1252
1253 value = 0;
1254 break;
1255
1256 default:
1257 goto unknown;
1258 }
1259 break;
1260
1261 default:
1262 unknown:
1263 VDBG(dev,
1264 "unknown ctrl req%02x.%02x v%04x i%04x l%d\n",
1265 ctrl->bRequestType, ctrl->bRequest,
1266 wValue, wIndex, wLength);
1267 break;
1268 }
1269
1270 /* respond with data transfer before status phase? */
1271 if (value >= 0) {
1272 req->length = value;
1273 req->zero = value < wLength;
1274 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1275 if (value < 0) {
1276 DBG(dev, "ep_queue --> %d\n", value);
1277 req->status = 0;
1278 printer_setup_complete(gadget->ep0, req);
1279 }
1280 }
1281
1282 /* host either stalls (value < 0) or reports success */
1283 return value;
1284 }
1285
1286 static void
1287 printer_disconnect(struct usb_gadget *gadget)
1288 {
1289 struct printer_dev *dev = get_gadget_data(gadget);
1290 unsigned long flags;
1291
1292 DBG(dev, "%s\n", __func__);
1293
1294 spin_lock_irqsave(&dev->lock, flags);
1295
1296 printer_reset_interface(dev);
1297
1298 spin_unlock_irqrestore(&dev->lock, flags);
1299 }
1300
1301 static void
1302 printer_unbind(struct usb_gadget *gadget)
1303 {
1304 struct printer_dev *dev = get_gadget_data(gadget);
1305 struct usb_request *req;
1306
1307
1308 DBG(dev, "%s\n", __func__);
1309
1310 /* Remove sysfs files */
1311 device_destroy(usb_gadget_class, g_printer_devno);
1312
1313 /* Remove Character Device */
1314 cdev_del(&dev->printer_cdev);
1315
1316 /* we must already have been disconnected ... no i/o may be active */
1317 WARN_ON(!list_empty(&dev->tx_reqs_active));
1318 WARN_ON(!list_empty(&dev->rx_reqs_active));
1319
1320 /* Free all memory for this driver. */
1321 while (!list_empty(&dev->tx_reqs)) {
1322 req = container_of(dev->tx_reqs.next, struct usb_request,
1323 list);
1324 list_del(&req->list);
1325 printer_req_free(dev->in_ep, req);
1326 }
1327
1328 if (dev->current_rx_req != NULL)
1329 printer_req_free(dev->out_ep, dev->current_rx_req);
1330
1331 while (!list_empty(&dev->rx_reqs)) {
1332 req = container_of(dev->rx_reqs.next,
1333 struct usb_request, list);
1334 list_del(&req->list);
1335 printer_req_free(dev->out_ep, req);
1336 }
1337
1338 while (!list_empty(&dev->rx_buffers)) {
1339 req = container_of(dev->rx_buffers.next,
1340 struct usb_request, list);
1341 list_del(&req->list);
1342 printer_req_free(dev->out_ep, req);
1343 }
1344
1345 if (dev->req) {
1346 printer_req_free(gadget->ep0, dev->req);
1347 dev->req = NULL;
1348 }
1349
1350 set_gadget_data(gadget, NULL);
1351 }
1352
1353 static int __init
1354 printer_bind(struct usb_gadget *gadget)
1355 {
1356 struct printer_dev *dev;
1357 struct usb_ep *in_ep, *out_ep;
1358 int status = -ENOMEM;
1359 int gcnum;
1360 size_t len;
1361 u32 i;
1362 struct usb_request *req;
1363
1364 dev = &usb_printer_gadget;
1365
1366
1367 /* Setup the sysfs files for the printer gadget. */
1368 dev->pdev = device_create(usb_gadget_class, NULL, g_printer_devno,
1369 NULL, "g_printer");
1370 if (IS_ERR(dev->pdev)) {
1371 ERROR(dev, "Failed to create device: g_printer\n");
1372 goto fail;
1373 }
1374
1375 /*
1376 * Register a character device as an interface to a user mode
1377 * program that handles the printer specific functionality.
1378 */
1379 cdev_init(&dev->printer_cdev, &printer_io_operations);
1380 dev->printer_cdev.owner = THIS_MODULE;
1381 status = cdev_add(&dev->printer_cdev, g_printer_devno, 1);
1382 if (status) {
1383 ERROR(dev, "Failed to open char device\n");
1384 goto fail;
1385 }
1386
1387 gcnum = usb_gadget_controller_number(gadget);
1388 if (gcnum >= 0) {
1389 device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
1390 } else {
1391 dev_warn(&gadget->dev, "controller '%s' not recognized\n",
1392 gadget->name);
1393 /* unrecognized, but safe unless bulk is REALLY quirky */
1394 device_desc.bcdDevice =
1395 cpu_to_le16(0xFFFF);
1396 }
1397 snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
1398 init_utsname()->sysname, init_utsname()->release,
1399 gadget->name);
1400
1401 device_desc.idVendor =
1402 cpu_to_le16(PRINTER_VENDOR_NUM);
1403 device_desc.idProduct =
1404 cpu_to_le16(PRINTER_PRODUCT_NUM);
1405
1406 /* support optional vendor/distro customization */
1407 if (idVendor) {
1408 if (!idProduct) {
1409 dev_err(&gadget->dev, "idVendor needs idProduct!\n");
1410 return -ENODEV;
1411 }
1412 device_desc.idVendor = cpu_to_le16(idVendor);
1413 device_desc.idProduct = cpu_to_le16(idProduct);
1414 if (bcdDevice)
1415 device_desc.bcdDevice = cpu_to_le16(bcdDevice);
1416 }
1417
1418 if (iManufacturer)
1419 strlcpy(manufacturer, iManufacturer, sizeof manufacturer);
1420
1421 if (iProduct)
1422 strlcpy(product_desc, iProduct, sizeof product_desc);
1423
1424 if (iSerialNum)
1425 strlcpy(serial_num, iSerialNum, sizeof serial_num);
1426
1427 if (iPNPstring)
1428 strlcpy(&pnp_string[2], iPNPstring, (sizeof pnp_string)-2);
1429
1430 len = strlen(pnp_string);
1431 pnp_string[0] = (len >> 8) & 0xFF;
1432 pnp_string[1] = len & 0xFF;
1433
1434 /* all we really need is bulk IN/OUT */
1435 usb_ep_autoconfig_reset(gadget);
1436 in_ep = usb_ep_autoconfig(gadget, &fs_ep_in_desc);
1437 if (!in_ep) {
1438 autoconf_fail:
1439 dev_err(&gadget->dev, "can't autoconfigure on %s\n",
1440 gadget->name);
1441 return -ENODEV;
1442 }
1443 in_ep->driver_data = in_ep; /* claim */
1444
1445 out_ep = usb_ep_autoconfig(gadget, &fs_ep_out_desc);
1446 if (!out_ep)
1447 goto autoconf_fail;
1448 out_ep->driver_data = out_ep; /* claim */
1449
1450 #ifdef CONFIG_USB_GADGET_DUALSPEED
1451 /* assumes ep0 uses the same value for both speeds ... */
1452 dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
1453
1454 /* and that all endpoints are dual-speed */
1455 hs_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
1456 hs_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
1457 #endif /* DUALSPEED */
1458
1459 device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1460 usb_gadget_set_selfpowered(gadget);
1461
1462 if (gadget->is_otg) {
1463 otg_desc.bmAttributes |= USB_OTG_HNP,
1464 config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1465 }
1466
1467 spin_lock_init(&dev->lock);
1468 mutex_init(&dev->lock_printer_io);
1469 INIT_LIST_HEAD(&dev->tx_reqs);
1470 INIT_LIST_HEAD(&dev->tx_reqs_active);
1471 INIT_LIST_HEAD(&dev->rx_reqs);
1472 INIT_LIST_HEAD(&dev->rx_reqs_active);
1473 INIT_LIST_HEAD(&dev->rx_buffers);
1474 init_waitqueue_head(&dev->rx_wait);
1475 init_waitqueue_head(&dev->tx_wait);
1476 init_waitqueue_head(&dev->tx_flush_wait);
1477
1478 dev->config = 0;
1479 dev->interface = -1;
1480 dev->printer_cdev_open = 0;
1481 dev->printer_status = PRINTER_NOT_ERROR;
1482 dev->current_rx_req = NULL;
1483 dev->current_rx_bytes = 0;
1484 dev->current_rx_buf = NULL;
1485
1486 dev->in_ep = in_ep;
1487 dev->out_ep = out_ep;
1488
1489 /* preallocate control message data and buffer */
1490 dev->req = printer_req_alloc(gadget->ep0, USB_DESC_BUFSIZE,
1491 GFP_KERNEL);
1492 if (!dev->req) {
1493 status = -ENOMEM;
1494 goto fail;
1495 }
1496
1497 for (i = 0; i < QLEN; i++) {
1498 req = printer_req_alloc(dev->in_ep, USB_BUFSIZE, GFP_KERNEL);
1499 if (!req) {
1500 while (!list_empty(&dev->tx_reqs)) {
1501 req = container_of(dev->tx_reqs.next,
1502 struct usb_request, list);
1503 list_del(&req->list);
1504 printer_req_free(dev->in_ep, req);
1505 }
1506 return -ENOMEM;
1507 }
1508 list_add(&req->list, &dev->tx_reqs);
1509 }
1510
1511 for (i = 0; i < QLEN; i++) {
1512 req = printer_req_alloc(dev->out_ep, USB_BUFSIZE, GFP_KERNEL);
1513 if (!req) {
1514 while (!list_empty(&dev->rx_reqs)) {
1515 req = container_of(dev->rx_reqs.next,
1516 struct usb_request, list);
1517 list_del(&req->list);
1518 printer_req_free(dev->out_ep, req);
1519 }
1520 return -ENOMEM;
1521 }
1522 list_add(&req->list, &dev->rx_reqs);
1523 }
1524
1525 dev->req->complete = printer_setup_complete;
1526
1527 /* finish hookup to lower layer ... */
1528 dev->gadget = gadget;
1529 set_gadget_data(gadget, dev);
1530 gadget->ep0->driver_data = dev;
1531
1532 INFO(dev, "%s, version: " DRIVER_VERSION "\n", driver_desc);
1533 INFO(dev, "using %s, OUT %s IN %s\n", gadget->name, out_ep->name,
1534 in_ep->name);
1535
1536 return 0;
1537
1538 fail:
1539 printer_unbind(gadget);
1540 return status;
1541 }
1542
1543 /*-------------------------------------------------------------------------*/
1544
1545 static struct usb_gadget_driver printer_driver = {
1546 .speed = DEVSPEED,
1547
1548 .function = (char *) driver_desc,
1549 .unbind = printer_unbind,
1550
1551 .setup = printer_setup,
1552 .disconnect = printer_disconnect,
1553
1554 .driver = {
1555 .name = (char *) shortname,
1556 .owner = THIS_MODULE,
1557 },
1558 };
1559
1560 MODULE_DESCRIPTION(DRIVER_DESC);
1561 MODULE_AUTHOR("Craig Nadler");
1562 MODULE_LICENSE("GPL");
1563
1564 static int __init
1565 init(void)
1566 {
1567 int status;
1568
1569 usb_gadget_class = class_create(THIS_MODULE, "usb_printer_gadget");
1570 if (IS_ERR(usb_gadget_class)) {
1571 status = PTR_ERR(usb_gadget_class);
1572 ERROR(dev, "unable to create usb_gadget class %d\n", status);
1573 return status;
1574 }
1575
1576 status = alloc_chrdev_region(&g_printer_devno, 0, 1,
1577 "USB printer gadget");
1578 if (status) {
1579 ERROR(dev, "alloc_chrdev_region %d\n", status);
1580 class_destroy(usb_gadget_class);
1581 return status;
1582 }
1583
1584 status = usb_gadget_probe_driver(&printer_driver, printer_bind);
1585 if (status) {
1586 class_destroy(usb_gadget_class);
1587 unregister_chrdev_region(g_printer_devno, 1);
1588 DBG(dev, "usb_gadget_probe_driver %x\n", status);
1589 }
1590
1591 return status;
1592 }
1593 module_init(init);
1594
1595 static void __exit
1596 cleanup(void)
1597 {
1598 int status;
1599
1600 mutex_lock(&usb_printer_gadget.lock_printer_io);
1601 status = usb_gadget_unregister_driver(&printer_driver);
1602 if (status)
1603 ERROR(dev, "usb_gadget_unregister_driver %x\n", status);
1604
1605 unregister_chrdev_region(g_printer_devno, 2);
1606 class_destroy(usb_gadget_class);
1607 mutex_unlock(&usb_printer_gadget.lock_printer_io);
1608 }
1609 module_exit(cleanup);
Linux 2.6 libata-dev (mirror)