?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fs: push i_mutex and filemap_write_and_wait down into ->fsync() handlers
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / gadget / printer.c
blob978e6a101bf2ff45811af75acff3e6265f951734
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, loff_t start, loff_t end, int datasync)
799 {
800 struct printer_dev *dev = fd->private_data;
801 struct inode *inode = fd->f_path.dentry->d_inode;
802 unsigned long flags;
803 int tx_list_empty;
804
805 mutex_lock(&inode->i_mutex);
806 spin_lock_irqsave(&dev->lock, flags);
807 tx_list_empty = (likely(list_empty(&dev->tx_reqs)));
808 spin_unlock_irqrestore(&dev->lock, flags);
809
810 if (!tx_list_empty) {
811 /* Sleep until all data has been sent */
812 wait_event_interruptible(dev->tx_flush_wait,
813 (likely(list_empty(&dev->tx_reqs_active))));
814 }
815 mutex_unlock(&inode->i_mutex);
816
817 return 0;
818 }
819
820 static unsigned int
821 printer_poll(struct file *fd, poll_table *wait)
822 {
823 struct printer_dev *dev = fd->private_data;
824 unsigned long flags;
825 int status = 0;
826
827 mutex_lock(&dev->lock_printer_io);
828 spin_lock_irqsave(&dev->lock, flags);
829 setup_rx_reqs(dev);
830 spin_unlock_irqrestore(&dev->lock, flags);
831 mutex_unlock(&dev->lock_printer_io);
832
833 poll_wait(fd, &dev->rx_wait, wait);
834 poll_wait(fd, &dev->tx_wait, wait);
835
836 spin_lock_irqsave(&dev->lock, flags);
837 if (likely(!list_empty(&dev->tx_reqs)))
838 status |= POLLOUT | POLLWRNORM;
839
840 if (likely(dev->current_rx_bytes) ||
841 likely(!list_empty(&dev->rx_buffers)))
842 status |= POLLIN | POLLRDNORM;
843
844 spin_unlock_irqrestore(&dev->lock, flags);
845
846 return status;
847 }
848
849 static long
850 printer_ioctl(struct file *fd, unsigned int code, unsigned long arg)
851 {
852 struct printer_dev *dev = fd->private_data;
853 unsigned long flags;
854 int status = 0;
855
856 DBG(dev, "printer_ioctl: cmd=0x%4.4x, arg=%lu\n", code, arg);
857
858 /* handle ioctls */
859
860 spin_lock_irqsave(&dev->lock, flags);
861
862 switch (code) {
863 case GADGET_GET_PRINTER_STATUS:
864 status = (int)dev->printer_status;
865 break;
866 case GADGET_SET_PRINTER_STATUS:
867 dev->printer_status = (u8)arg;
868 break;
869 default:
870 /* could not handle ioctl */
871 DBG(dev, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n",
872 code);
873 status = -ENOTTY;
874 }
875
876 spin_unlock_irqrestore(&dev->lock, flags);
877
878 return status;
879 }
880
881 /* used after endpoint configuration */
882 static const struct file_operations printer_io_operations = {
883 .owner = THIS_MODULE,
884 .open = printer_open,
885 .read = printer_read,
886 .write = printer_write,
887 .fsync = printer_fsync,
888 .poll = printer_poll,
889 .unlocked_ioctl = printer_ioctl,
890 .release = printer_close,
891 .llseek = noop_llseek,
892 };
893
894 /*-------------------------------------------------------------------------*/
895
896 static int
897 set_printer_interface(struct printer_dev *dev)
898 {
899 int result = 0;
900
901 dev->in = ep_desc(dev->gadget, &hs_ep_in_desc, &fs_ep_in_desc);
902 dev->in_ep->driver_data = dev;
903
904 dev->out = ep_desc(dev->gadget, &hs_ep_out_desc, &fs_ep_out_desc);
905 dev->out_ep->driver_data = dev;
906
907 result = usb_ep_enable(dev->in_ep, dev->in);
908 if (result != 0) {
909 DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
910 goto done;
911 }
912
913 result = usb_ep_enable(dev->out_ep, dev->out);
914 if (result != 0) {
915 DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
916 goto done;
917 }
918
919 done:
920 /* on error, disable any endpoints */
921 if (result != 0) {
922 (void) usb_ep_disable(dev->in_ep);
923 (void) usb_ep_disable(dev->out_ep);
924 dev->in = NULL;
925 dev->out = NULL;
926 }
927
928 /* caller is responsible for cleanup on error */
929 return result;
930 }
931
932 static void printer_reset_interface(struct printer_dev *dev)
933 {
934 if (dev->interface < 0)
935 return;
936
937 DBG(dev, "%s\n", __func__);
938
939 if (dev->in)
940 usb_ep_disable(dev->in_ep);
941
942 if (dev->out)
943 usb_ep_disable(dev->out_ep);
944
945 dev->interface = -1;
946 }
947
948 /* change our operational config. must agree with the code
949 * that returns config descriptors, and altsetting code.
950 */
951 static int
952 printer_set_config(struct printer_dev *dev, unsigned number)
953 {
954 int result = 0;
955 struct usb_gadget *gadget = dev->gadget;
956
957 switch (number) {
958 case DEV_CONFIG_VALUE:
959 result = 0;
960 break;
961 default:
962 result = -EINVAL;
963 /* FALL THROUGH */
964 case 0:
965 break;
966 }
967
968 if (result) {
969 usb_gadget_vbus_draw(dev->gadget,
970 dev->gadget->is_otg ? 8 : 100);
971 } else {
972 char *speed;
973 unsigned power;
974
975 power = 2 * config_desc.bMaxPower;
976 usb_gadget_vbus_draw(dev->gadget, power);
977
978 switch (gadget->speed) {
979 case USB_SPEED_FULL: speed = "full"; break;
980 #ifdef CONFIG_USB_GADGET_DUALSPEED
981 case USB_SPEED_HIGH: speed = "high"; break;
982 #endif
983 default: speed = "?"; break;
984 }
985
986 dev->config = number;
987 INFO(dev, "%s speed config #%d: %d mA, %s\n",
988 speed, number, power, driver_desc);
989 }
990 return result;
991 }
992
993 static int
994 config_buf(enum usb_device_speed speed, u8 *buf, u8 type, unsigned index,
995 int is_otg)
996 {
997 int len;
998 const struct usb_descriptor_header **function;
999 #ifdef CONFIG_USB_GADGET_DUALSPEED
1000 int hs = (speed == USB_SPEED_HIGH);
1001
1002 if (type == USB_DT_OTHER_SPEED_CONFIG)
1003 hs = !hs;
1004
1005 if (hs) {
1006 function = hs_printer_function;
1007 } else {
1008 function = fs_printer_function;
1009 }
1010 #else
1011 function = fs_printer_function;
1012 #endif
1013
1014 if (index >= device_desc.bNumConfigurations)
1015 return -EINVAL;
1016
1017 /* for now, don't advertise srp-only devices */
1018 if (!is_otg)
1019 function++;
1020
1021 len = usb_gadget_config_buf(&config_desc, buf, USB_DESC_BUFSIZE,
1022 function);
1023 if (len < 0)
1024 return len;
1025 ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
1026 return len;
1027 }
1028
1029 /* Change our operational Interface. */
1030 static int
1031 set_interface(struct printer_dev *dev, unsigned number)
1032 {
1033 int result = 0;
1034
1035 /* Free the current interface */
1036 switch (dev->interface) {
1037 case PRINTER_INTERFACE:
1038 printer_reset_interface(dev);
1039 break;
1040 }
1041
1042 switch (number) {
1043 case PRINTER_INTERFACE:
1044 result = set_printer_interface(dev);
1045 if (result) {
1046 printer_reset_interface(dev);
1047 } else {
1048 dev->interface = PRINTER_INTERFACE;
1049 }
1050 break;
1051 default:
1052 result = -EINVAL;
1053 /* FALL THROUGH */
1054 }
1055
1056 if (!result)
1057 INFO(dev, "Using interface %x\n", number);
1058
1059 return result;
1060 }
1061
1062 static void printer_setup_complete(struct usb_ep *ep, struct usb_request *req)
1063 {
1064 if (req->status || req->actual != req->length)
1065 DBG((struct printer_dev *) ep->driver_data,
1066 "setup complete --> %d, %d/%d\n",
1067 req->status, req->actual, req->length);
1068 }
1069
1070 static void printer_soft_reset(struct printer_dev *dev)
1071 {
1072 struct usb_request *req;
1073
1074 INFO(dev, "Received Printer Reset Request\n");
1075
1076 if (usb_ep_disable(dev->in_ep))
1077 DBG(dev, "Failed to disable USB in_ep\n");
1078 if (usb_ep_disable(dev->out_ep))
1079 DBG(dev, "Failed to disable USB out_ep\n");
1080
1081 if (dev->current_rx_req != NULL) {
1082 list_add(&dev->current_rx_req->list, &dev->rx_reqs);
1083 dev->current_rx_req = NULL;
1084 }
1085 dev->current_rx_bytes = 0;
1086 dev->current_rx_buf = NULL;
1087 dev->reset_printer = 1;
1088
1089 while (likely(!(list_empty(&dev->rx_buffers)))) {
1090 req = container_of(dev->rx_buffers.next, struct usb_request,
1091 list);
1092 list_del_init(&req->list);
1093 list_add(&req->list, &dev->rx_reqs);
1094 }
1095
1096 while (likely(!(list_empty(&dev->rx_reqs_active)))) {
1097 req = container_of(dev->rx_buffers.next, struct usb_request,
1098 list);
1099 list_del_init(&req->list);
1100 list_add(&req->list, &dev->rx_reqs);
1101 }
1102
1103 while (likely(!(list_empty(&dev->tx_reqs_active)))) {
1104 req = container_of(dev->tx_reqs_active.next,
1105 struct usb_request, list);
1106 list_del_init(&req->list);
1107 list_add(&req->list, &dev->tx_reqs);
1108 }
1109
1110 if (usb_ep_enable(dev->in_ep, dev->in))
1111 DBG(dev, "Failed to enable USB in_ep\n");
1112 if (usb_ep_enable(dev->out_ep, dev->out))
1113 DBG(dev, "Failed to enable USB out_ep\n");
1114
1115 wake_up_interruptible(&dev->rx_wait);
1116 wake_up_interruptible(&dev->tx_wait);
1117 wake_up_interruptible(&dev->tx_flush_wait);
1118 }
1119
1120 /*-------------------------------------------------------------------------*/
1121
1122 /*
1123 * The setup() callback implements all the ep0 functionality that's not
1124 * handled lower down.
1125 */
1126 static int
1127 printer_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1128 {
1129 struct printer_dev *dev = get_gadget_data(gadget);
1130 struct usb_request *req = dev->req;
1131 int value = -EOPNOTSUPP;
1132 u16 wIndex = le16_to_cpu(ctrl->wIndex);
1133 u16 wValue = le16_to_cpu(ctrl->wValue);
1134 u16 wLength = le16_to_cpu(ctrl->wLength);
1135
1136 DBG(dev, "ctrl req%02x.%02x v%04x i%04x l%d\n",
1137 ctrl->bRequestType, ctrl->bRequest, wValue, wIndex, wLength);
1138
1139 req->complete = printer_setup_complete;
1140
1141 switch (ctrl->bRequestType&USB_TYPE_MASK) {
1142
1143 case USB_TYPE_STANDARD:
1144 switch (ctrl->bRequest) {
1145
1146 case USB_REQ_GET_DESCRIPTOR:
1147 if (ctrl->bRequestType != USB_DIR_IN)
1148 break;
1149 switch (wValue >> 8) {
1150
1151 case USB_DT_DEVICE:
1152 value = min(wLength, (u16) sizeof device_desc);
1153 memcpy(req->buf, &device_desc, value);
1154 break;
1155 #ifdef CONFIG_USB_GADGET_DUALSPEED
1156 case USB_DT_DEVICE_QUALIFIER:
1157 if (!gadget->is_dualspeed)
1158 break;
1159 value = min(wLength,
1160 (u16) sizeof dev_qualifier);
1161 memcpy(req->buf, &dev_qualifier, value);
1162 break;
1163
1164 case USB_DT_OTHER_SPEED_CONFIG:
1165 if (!gadget->is_dualspeed)
1166 break;
1167 /* FALLTHROUGH */
1168 #endif /* CONFIG_USB_GADGET_DUALSPEED */
1169 case USB_DT_CONFIG:
1170 value = config_buf(gadget->speed, req->buf,
1171 wValue >> 8,
1172 wValue & 0xff,
1173 gadget->is_otg);
1174 if (value >= 0)
1175 value = min(wLength, (u16) value);
1176 break;
1177
1178 case USB_DT_STRING:
1179 value = usb_gadget_get_string(&stringtab,
1180 wValue & 0xff, req->buf);
1181 if (value >= 0)
1182 value = min(wLength, (u16) value);
1183 break;
1184 }
1185 break;
1186
1187 case USB_REQ_SET_CONFIGURATION:
1188 if (ctrl->bRequestType != 0)
1189 break;
1190 if (gadget->a_hnp_support)
1191 DBG(dev, "HNP available\n");
1192 else if (gadget->a_alt_hnp_support)
1193 DBG(dev, "HNP needs a different root port\n");
1194 value = printer_set_config(dev, wValue);
1195 if (!value)
1196 value = set_interface(dev, PRINTER_INTERFACE);
1197 break;
1198 case USB_REQ_GET_CONFIGURATION:
1199 if (ctrl->bRequestType != USB_DIR_IN)
1200 break;
1201 *(u8 *)req->buf = dev->config;
1202 value = min(wLength, (u16) 1);
1203 break;
1204
1205 case USB_REQ_SET_INTERFACE:
1206 if (ctrl->bRequestType != USB_RECIP_INTERFACE ||
1207 !dev->config)
1208 break;
1209
1210 value = set_interface(dev, PRINTER_INTERFACE);
1211 break;
1212 case USB_REQ_GET_INTERFACE:
1213 if (ctrl->bRequestType !=
1214 (USB_DIR_IN|USB_RECIP_INTERFACE)
1215 || !dev->config)
1216 break;
1217
1218 *(u8 *)req->buf = dev->interface;
1219 value = min(wLength, (u16) 1);
1220 break;
1221
1222 default:
1223 goto unknown;
1224 }
1225 break;
1226
1227 case USB_TYPE_CLASS:
1228 switch (ctrl->bRequest) {
1229 case 0: /* Get the IEEE-1284 PNP String */
1230 /* Only one printer interface is supported. */
1231 if ((wIndex>>8) != PRINTER_INTERFACE)
1232 break;
1233
1234 value = (pnp_string[0]<<8)|pnp_string[1];
1235 memcpy(req->buf, pnp_string, value);
1236 DBG(dev, "1284 PNP String: %x %s\n", value,
1237 &pnp_string[2]);
1238 break;
1239
1240 case 1: /* Get Port Status */
1241 /* Only one printer interface is supported. */
1242 if (wIndex != PRINTER_INTERFACE)
1243 break;
1244
1245 *(u8 *)req->buf = dev->printer_status;
1246 value = min(wLength, (u16) 1);
1247 break;
1248
1249 case 2: /* Soft Reset */
1250 /* Only one printer interface is supported. */
1251 if (wIndex != PRINTER_INTERFACE)
1252 break;
1253
1254 printer_soft_reset(dev);
1255
1256 value = 0;
1257 break;
1258
1259 default:
1260 goto unknown;
1261 }
1262 break;
1263
1264 default:
1265 unknown:
1266 VDBG(dev,
1267 "unknown ctrl req%02x.%02x v%04x i%04x l%d\n",
1268 ctrl->bRequestType, ctrl->bRequest,
1269 wValue, wIndex, wLength);
1270 break;
1271 }
1272
1273 /* respond with data transfer before status phase? */
1274 if (value >= 0) {
1275 req->length = value;
1276 req->zero = value < wLength;
1277 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1278 if (value < 0) {
1279 DBG(dev, "ep_queue --> %d\n", value);
1280 req->status = 0;
1281 printer_setup_complete(gadget->ep0, req);
1282 }
1283 }
1284
1285 /* host either stalls (value < 0) or reports success */
1286 return value;
1287 }
1288
1289 static void
1290 printer_disconnect(struct usb_gadget *gadget)
1291 {
1292 struct printer_dev *dev = get_gadget_data(gadget);
1293 unsigned long flags;
1294
1295 DBG(dev, "%s\n", __func__);
1296
1297 spin_lock_irqsave(&dev->lock, flags);
1298
1299 printer_reset_interface(dev);
1300
1301 spin_unlock_irqrestore(&dev->lock, flags);
1302 }
1303
1304 static void
1305 printer_unbind(struct usb_gadget *gadget)
1306 {
1307 struct printer_dev *dev = get_gadget_data(gadget);
1308 struct usb_request *req;
1309
1310
1311 DBG(dev, "%s\n", __func__);
1312
1313 /* Remove sysfs files */
1314 device_destroy(usb_gadget_class, g_printer_devno);
1315
1316 /* Remove Character Device */
1317 cdev_del(&dev->printer_cdev);
1318
1319 /* we must already have been disconnected ... no i/o may be active */
1320 WARN_ON(!list_empty(&dev->tx_reqs_active));
1321 WARN_ON(!list_empty(&dev->rx_reqs_active));
1322
1323 /* Free all memory for this driver. */
1324 while (!list_empty(&dev->tx_reqs)) {
1325 req = container_of(dev->tx_reqs.next, struct usb_request,
1326 list);
1327 list_del(&req->list);
1328 printer_req_free(dev->in_ep, req);
1329 }
1330
1331 if (dev->current_rx_req != NULL)
1332 printer_req_free(dev->out_ep, dev->current_rx_req);
1333
1334 while (!list_empty(&dev->rx_reqs)) {
1335 req = container_of(dev->rx_reqs.next,
1336 struct usb_request, list);
1337 list_del(&req->list);
1338 printer_req_free(dev->out_ep, req);
1339 }
1340
1341 while (!list_empty(&dev->rx_buffers)) {
1342 req = container_of(dev->rx_buffers.next,
1343 struct usb_request, list);
1344 list_del(&req->list);
1345 printer_req_free(dev->out_ep, req);
1346 }
1347
1348 if (dev->req) {
1349 printer_req_free(gadget->ep0, dev->req);
1350 dev->req = NULL;
1351 }
1352
1353 set_gadget_data(gadget, NULL);
1354 }
1355
1356 static int __init
1357 printer_bind(struct usb_gadget *gadget)
1358 {
1359 struct printer_dev *dev;
1360 struct usb_ep *in_ep, *out_ep;
1361 int status = -ENOMEM;
1362 int gcnum;
1363 size_t len;
1364 u32 i;
1365 struct usb_request *req;
1366
1367 dev = &usb_printer_gadget;
1368
1369
1370 /* Setup the sysfs files for the printer gadget. */
1371 dev->pdev = device_create(usb_gadget_class, NULL, g_printer_devno,
1372 NULL, "g_printer");
1373 if (IS_ERR(dev->pdev)) {
1374 ERROR(dev, "Failed to create device: g_printer\n");
1375 goto fail;
1376 }
1377
1378 /*
1379 * Register a character device as an interface to a user mode
1380 * program that handles the printer specific functionality.
1381 */
1382 cdev_init(&dev->printer_cdev, &printer_io_operations);
1383 dev->printer_cdev.owner = THIS_MODULE;
1384 status = cdev_add(&dev->printer_cdev, g_printer_devno, 1);
1385 if (status) {
1386 ERROR(dev, "Failed to open char device\n");
1387 goto fail;
1388 }
1389
1390 gcnum = usb_gadget_controller_number(gadget);
1391 if (gcnum >= 0) {
1392 device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
1393 } else {
1394 dev_warn(&gadget->dev, "controller '%s' not recognized\n",
1395 gadget->name);
1396 /* unrecognized, but safe unless bulk is REALLY quirky */
1397 device_desc.bcdDevice =
1398 cpu_to_le16(0xFFFF);
1399 }
1400 snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
1401 init_utsname()->sysname, init_utsname()->release,
1402 gadget->name);
1403
1404 device_desc.idVendor =
1405 cpu_to_le16(PRINTER_VENDOR_NUM);
1406 device_desc.idProduct =
1407 cpu_to_le16(PRINTER_PRODUCT_NUM);
1408
1409 /* support optional vendor/distro customization */
1410 if (idVendor) {
1411 if (!idProduct) {
1412 dev_err(&gadget->dev, "idVendor needs idProduct!\n");
1413 return -ENODEV;
1414 }
1415 device_desc.idVendor = cpu_to_le16(idVendor);
1416 device_desc.idProduct = cpu_to_le16(idProduct);
1417 if (bcdDevice)
1418 device_desc.bcdDevice = cpu_to_le16(bcdDevice);
1419 }
1420
1421 if (iManufacturer)
1422 strlcpy(manufacturer, iManufacturer, sizeof manufacturer);
1423
1424 if (iProduct)
1425 strlcpy(product_desc, iProduct, sizeof product_desc);
1426
1427 if (iSerialNum)
1428 strlcpy(serial_num, iSerialNum, sizeof serial_num);
1429
1430 if (iPNPstring)
1431 strlcpy(&pnp_string[2], iPNPstring, (sizeof pnp_string)-2);
1432
1433 len = strlen(pnp_string);
1434 pnp_string[0] = (len >> 8) & 0xFF;
1435 pnp_string[1] = len & 0xFF;
1436
1437 /* all we really need is bulk IN/OUT */
1438 usb_ep_autoconfig_reset(gadget);
1439 in_ep = usb_ep_autoconfig(gadget, &fs_ep_in_desc);
1440 if (!in_ep) {
1441 autoconf_fail:
1442 dev_err(&gadget->dev, "can't autoconfigure on %s\n",
1443 gadget->name);
1444 return -ENODEV;
1445 }
1446 in_ep->driver_data = in_ep; /* claim */
1447
1448 out_ep = usb_ep_autoconfig(gadget, &fs_ep_out_desc);
1449 if (!out_ep)
1450 goto autoconf_fail;
1451 out_ep->driver_data = out_ep; /* claim */
1452
1453 #ifdef CONFIG_USB_GADGET_DUALSPEED
1454 /* assumes ep0 uses the same value for both speeds ... */
1455 dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
1456
1457 /* and that all endpoints are dual-speed */
1458 hs_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
1459 hs_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
1460 #endif /* DUALSPEED */
1461
1462 device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1463 usb_gadget_set_selfpowered(gadget);
1464
1465 if (gadget->is_otg) {
1466 otg_desc.bmAttributes |= USB_OTG_HNP,
1467 config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1468 }
1469
1470 spin_lock_init(&dev->lock);
1471 mutex_init(&dev->lock_printer_io);
1472 INIT_LIST_HEAD(&dev->tx_reqs);
1473 INIT_LIST_HEAD(&dev->tx_reqs_active);
1474 INIT_LIST_HEAD(&dev->rx_reqs);
1475 INIT_LIST_HEAD(&dev->rx_reqs_active);
1476 INIT_LIST_HEAD(&dev->rx_buffers);
1477 init_waitqueue_head(&dev->rx_wait);
1478 init_waitqueue_head(&dev->tx_wait);
1479 init_waitqueue_head(&dev->tx_flush_wait);
1480
1481 dev->config = 0;
1482 dev->interface = -1;
1483 dev->printer_cdev_open = 0;
1484 dev->printer_status = PRINTER_NOT_ERROR;
1485 dev->current_rx_req = NULL;
1486 dev->current_rx_bytes = 0;
1487 dev->current_rx_buf = NULL;
1488
1489 dev->in_ep = in_ep;
1490 dev->out_ep = out_ep;
1491
1492 /* preallocate control message data and buffer */
1493 dev->req = printer_req_alloc(gadget->ep0, USB_DESC_BUFSIZE,
1494 GFP_KERNEL);
1495 if (!dev->req) {
1496 status = -ENOMEM;
1497 goto fail;
1498 }
1499
1500 for (i = 0; i < QLEN; i++) {
1501 req = printer_req_alloc(dev->in_ep, USB_BUFSIZE, GFP_KERNEL);
1502 if (!req) {
1503 while (!list_empty(&dev->tx_reqs)) {
1504 req = container_of(dev->tx_reqs.next,
1505 struct usb_request, list);
1506 list_del(&req->list);
1507 printer_req_free(dev->in_ep, req);
1508 }
1509 return -ENOMEM;
1510 }
1511 list_add(&req->list, &dev->tx_reqs);
1512 }
1513
1514 for (i = 0; i < QLEN; i++) {
1515 req = printer_req_alloc(dev->out_ep, USB_BUFSIZE, GFP_KERNEL);
1516 if (!req) {
1517 while (!list_empty(&dev->rx_reqs)) {
1518 req = container_of(dev->rx_reqs.next,
1519 struct usb_request, list);
1520 list_del(&req->list);
1521 printer_req_free(dev->out_ep, req);
1522 }
1523 return -ENOMEM;
1524 }
1525 list_add(&req->list, &dev->rx_reqs);
1526 }
1527
1528 dev->req->complete = printer_setup_complete;
1529
1530 /* finish hookup to lower layer ... */
1531 dev->gadget = gadget;
1532 set_gadget_data(gadget, dev);
1533 gadget->ep0->driver_data = dev;
1534
1535 INFO(dev, "%s, version: " DRIVER_VERSION "\n", driver_desc);
1536 INFO(dev, "using %s, OUT %s IN %s\n", gadget->name, out_ep->name,
1537 in_ep->name);
1538
1539 return 0;
1540
1541 fail:
1542 printer_unbind(gadget);
1543 return status;
1544 }
1545
1546 /*-------------------------------------------------------------------------*/
1547
1548 static struct usb_gadget_driver printer_driver = {
1549 .speed = DEVSPEED,
1550
1551 .function = (char *) driver_desc,
1552 .unbind = printer_unbind,
1553
1554 .setup = printer_setup,
1555 .disconnect = printer_disconnect,
1556
1557 .driver = {
1558 .name = (char *) shortname,
1559 .owner = THIS_MODULE,
1560 },
1561 };
1562
1563 MODULE_DESCRIPTION(DRIVER_DESC);
1564 MODULE_AUTHOR("Craig Nadler");
1565 MODULE_LICENSE("GPL");
1566
1567 static int __init
1568 init(void)
1569 {
1570 int status;
1571
1572 usb_gadget_class = class_create(THIS_MODULE, "usb_printer_gadget");
1573 if (IS_ERR(usb_gadget_class)) {
1574 status = PTR_ERR(usb_gadget_class);
1575 ERROR(dev, "unable to create usb_gadget class %d\n", status);
1576 return status;
1577 }
1578
1579 status = alloc_chrdev_region(&g_printer_devno, 0, 1,
1580 "USB printer gadget");
1581 if (status) {
1582 ERROR(dev, "alloc_chrdev_region %d\n", status);
1583 class_destroy(usb_gadget_class);
1584 return status;
1585 }
1586
1587 status = usb_gadget_probe_driver(&printer_driver, printer_bind);
1588 if (status) {
1589 class_destroy(usb_gadget_class);
1590 unregister_chrdev_region(g_printer_devno, 1);
1591 DBG(dev, "usb_gadget_probe_driver %x\n", status);
1592 }
1593
1594 return status;
1595 }
1596 module_init(init);
1597
1598 static void __exit
1599 cleanup(void)
1600 {
1601 int status;
1602
1603 mutex_lock(&usb_printer_gadget.lock_printer_io);
1604 status = usb_gadget_unregister_driver(&printer_driver);
1605 if (status)
1606 ERROR(dev, "usb_gadget_unregister_driver %x\n", status);
1607
1608 unregister_chrdev_region(g_printer_devno, 2);
1609 class_destroy(usb_gadget_class);
1610 mutex_unlock(&usb_printer_gadget.lock_printer_io);
1611 }
1612 module_exit(cleanup);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree