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