PageRenderTime 120ms CodeModel.GetById 33ms app.highlight 70ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/usb/gadget/printer.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
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(&current_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(&current_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);