dummy_hcd.c 72.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
/*
 * dummy_hcd.c -- Dummy/Loopback USB host and device emulator driver.
 *
 * Maintainer: Alan Stern <stern@rowland.harvard.edu>
 *
 * Copyright (C) 2003 David Brownell
 * Copyright (C) 2003-2005 Alan Stern
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */


/*
 * This exposes a device side "USB gadget" API, driven by requests to a
 * Linux-USB host controller driver.  USB traffic is simulated; there's
 * no need for USB hardware.  Use this with two other drivers:
 *
 *  - Gadget driver, responding to requests (slave);
 *  - Host-side device driver, as already familiar in Linux.
 *
 * Having this all in one kernel can help some stages of development,
 * bypassing some hardware (and driver) issues.  UML could help too.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/timer.h>
#include <linux/list.h>
#include <linux/interrupt.h>
38
#include <linux/platform_device.h>
Linus Torvalds's avatar
Linus Torvalds committed
39
#include <linux/usb.h>
40
#include <linux/usb/gadget.h>
41
#include <linux/usb/hcd.h>
42
#include <linux/scatterlist.h>
Linus Torvalds's avatar
Linus Torvalds committed
43 44

#include <asm/byteorder.h>
45
#include <linux/io.h>
Linus Torvalds's avatar
Linus Torvalds committed
46 47 48 49
#include <asm/irq.h>
#include <asm/unaligned.h>

#define DRIVER_DESC	"USB Host+Gadget Emulator"
50
#define DRIVER_VERSION	"02 May 2005"
Linus Torvalds's avatar
Linus Torvalds committed
51

52 53
#define POWER_BUDGET	500	/* in mA; use 8 for low-power port testing */

54 55
static const char	driver_name[] = "dummy_hcd";
static const char	driver_desc[] = "USB Host+Gadget Emulator";
Linus Torvalds's avatar
Linus Torvalds committed
56

57
static const char	gadget_name[] = "dummy_udc";
Linus Torvalds's avatar
Linus Torvalds committed
58

59 60 61
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("David Brownell");
MODULE_LICENSE("GPL");
Linus Torvalds's avatar
Linus Torvalds committed
62

63 64
struct dummy_hcd_module_parameters {
	bool is_super_speed;
65
	bool is_high_speed;
66
	unsigned int num;
67 68 69
};

static struct dummy_hcd_module_parameters mod_data = {
70 71
	.is_super_speed = false,
	.is_high_speed = true,
72
	.num = 1,
73 74 75
};
module_param_named(is_super_speed, mod_data.is_super_speed, bool, S_IRUGO);
MODULE_PARM_DESC(is_super_speed, "true to simulate SuperSpeed connection");
76 77
module_param_named(is_high_speed, mod_data.is_high_speed, bool, S_IRUGO);
MODULE_PARM_DESC(is_high_speed, "true to simulate HighSpeed connection");
78 79
module_param_named(num, mod_data.num, uint, S_IRUGO);
MODULE_PARM_DESC(num, "number of emulated controllers");
Linus Torvalds's avatar
Linus Torvalds committed
80 81 82 83 84 85 86 87 88
/*-------------------------------------------------------------------------*/

/* gadget side driver data structres */
struct dummy_ep {
	struct list_head		queue;
	unsigned long			last_io;	/* jiffies timestamp */
	struct usb_gadget		*gadget;
	const struct usb_endpoint_descriptor *desc;
	struct usb_ep			ep;
89 90 91 92
	unsigned			halted:1;
	unsigned			wedged:1;
	unsigned			already_seen:1;
	unsigned			setup_stage:1;
93
	unsigned			stream_en:1;
Linus Torvalds's avatar
Linus Torvalds committed
94 95 96 97 98 99 100
};

struct dummy_request {
	struct list_head		queue;		/* ep's requests */
	struct usb_request		req;
};

101
static inline struct dummy_ep *usb_ep_to_dummy_ep(struct usb_ep *_ep)
Linus Torvalds's avatar
Linus Torvalds committed
102
{
103
	return container_of(_ep, struct dummy_ep, ep);
Linus Torvalds's avatar
Linus Torvalds committed
104 105 106 107 108
}

static inline struct dummy_request *usb_request_to_dummy_request
		(struct usb_request *_req)
{
109
	return container_of(_req, struct dummy_request, req);
Linus Torvalds's avatar
Linus Torvalds committed
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
}

/*-------------------------------------------------------------------------*/

/*
 * Every device has ep0 for control requests, plus up to 30 more endpoints,
 * in one of two types:
 *
 *   - Configurable:  direction (in/out), type (bulk, iso, etc), and endpoint
 *     number can be changed.  Names like "ep-a" are used for this type.
 *
 *   - Fixed Function:  in other cases.  some characteristics may be mutable;
 *     that'd be hardware-specific.  Names like "ep12out-bulk" are used.
 *
 * Gadget drivers are responsible for not setting up conflicting endpoint
 * configurations, illegal or unsupported packet lengths, and so on.
 */

128
static const char ep0name[] = "ep0";
Linus Torvalds's avatar
Linus Torvalds committed
129

130 131 132 133 134 135 136 137 138
static const struct {
	const char *name;
	const struct usb_ep_caps caps;
} ep_info[] = {
#define EP_INFO(_name, _caps) \
	{ \
		.name = _name, \
		.caps = _caps, \
	}
Linus Torvalds's avatar
Linus Torvalds committed
139

140 141 142
	/* everyone has ep0 */
	EP_INFO(ep0name,
		USB_EP_CAPS(USB_EP_CAPS_TYPE_CONTROL, USB_EP_CAPS_DIR_ALL)),
143
	/* act like a pxa250: fifteen fixed function endpoints */
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
	EP_INFO("ep1in-bulk",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep2out-bulk",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep3in-iso",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep4out-iso",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep5in-int",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep6in-bulk",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep7out-bulk",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep8in-iso",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep9out-iso",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep10in-int",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep11in-bulk",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep12out-bulk",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep13in-iso",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep14out-iso",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep15in-int",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)),
Linus Torvalds's avatar
Linus Torvalds committed
174
	/* or like sa1100: two fixed function endpoints */
175 176 177 178
	EP_INFO("ep1out-bulk",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep2in-bulk",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
179
	/* and now some generic EPs so we have enough in multi config */
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
	EP_INFO("ep3out",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep4in",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep5out",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep6out",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep7in",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep8out",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep9in",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep10out",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep11out",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep12in",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep13out",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_OUT)),
	EP_INFO("ep14in",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_IN)),
	EP_INFO("ep15out",
		USB_EP_CAPS(USB_EP_CAPS_TYPE_ALL, USB_EP_CAPS_DIR_OUT)),

#undef EP_INFO
Linus Torvalds's avatar
Linus Torvalds committed
208
};
209 210

#define DUMMY_ENDPOINTS	ARRAY_SIZE(ep_info)
Linus Torvalds's avatar
Linus Torvalds committed
211

212 213
/*-------------------------------------------------------------------------*/

Linus Torvalds's avatar
Linus Torvalds committed
214 215 216 217 218
#define FIFO_SIZE		64

struct urbp {
	struct urb		*urb;
	struct list_head	urbp_list;
219 220
	struct sg_mapping_iter	miter;
	u32			miter_started;
Linus Torvalds's avatar
Linus Torvalds committed
221 222
};

223 224 225 226 227 228 229

enum dummy_rh_state {
	DUMMY_RH_RESET,
	DUMMY_RH_SUSPENDED,
	DUMMY_RH_RUNNING
};

230 231 232 233 234 235 236 237 238 239
struct dummy_hcd {
	struct dummy			*dum;
	enum dummy_rh_state		rh_state;
	struct timer_list		timer;
	u32				port_status;
	u32				old_status;
	unsigned long			re_timeout;

	struct usb_device		*udev;
	struct list_head		urbp_list;
240 241
	struct urbp			*next_frame_urbp;

242 243
	u32				stream_en_ep;
	u8				num_stream[30 / 2];
244 245 246 247 248 249

	unsigned			active:1;
	unsigned			old_active:1;
	unsigned			resuming:1;
};

Linus Torvalds's avatar
Linus Torvalds committed
250 251 252 253 254 255
struct dummy {
	spinlock_t			lock;

	/*
	 * SLAVE/GADGET side support
	 */
256
	struct dummy_ep			ep[DUMMY_ENDPOINTS];
Linus Torvalds's avatar
Linus Torvalds committed
257
	int				address;
258
	int				callback_usage;
Linus Torvalds's avatar
Linus Torvalds committed
259 260 261
	struct usb_gadget		gadget;
	struct usb_gadget_driver	*driver;
	struct dummy_request		fifo_req;
262
	u8				fifo_buf[FIFO_SIZE];
Linus Torvalds's avatar
Linus Torvalds committed
263
	u16				devstatus;
264
	unsigned			ints_enabled:1;
265
	unsigned			udc_suspended:1;
266
	unsigned			pullup:1;
Linus Torvalds's avatar
Linus Torvalds committed
267 268 269 270

	/*
	 * MASTER/HOST side support
	 */
271
	struct dummy_hcd		*hs_hcd;
272
	struct dummy_hcd		*ss_hcd;
Linus Torvalds's avatar
Linus Torvalds committed
273 274
};

275
static inline struct dummy_hcd *hcd_to_dummy_hcd(struct usb_hcd *hcd)
Linus Torvalds's avatar
Linus Torvalds committed
276
{
277
	return (struct dummy_hcd *) (hcd->hcd_priv);
Linus Torvalds's avatar
Linus Torvalds committed
278 279
}

280
static inline struct usb_hcd *dummy_hcd_to_hcd(struct dummy_hcd *dum)
Linus Torvalds's avatar
Linus Torvalds committed
281 282 283 284
{
	return container_of((void *) dum, struct usb_hcd, hcd_priv);
}

285
static inline struct device *dummy_dev(struct dummy_hcd *dum)
Linus Torvalds's avatar
Linus Torvalds committed
286
{
287
	return dummy_hcd_to_hcd(dum)->self.controller;
Linus Torvalds's avatar
Linus Torvalds committed
288 289
}

290
static inline struct device *udc_dev(struct dummy *dum)
291 292 293 294
{
	return dum->gadget.dev.parent;
}

295
static inline struct dummy *ep_to_dummy(struct dummy_ep *ep)
Linus Torvalds's avatar
Linus Torvalds committed
296
{
297
	return container_of(ep->gadget, struct dummy, gadget);
Linus Torvalds's avatar
Linus Torvalds committed
298 299
}

300
static inline struct dummy_hcd *gadget_to_dummy_hcd(struct usb_gadget *gadget)
Linus Torvalds's avatar
Linus Torvalds committed
301
{
302
	struct dummy *dum = container_of(gadget, struct dummy, gadget);
303 304 305 306
	if (dum->gadget.speed == USB_SPEED_SUPER)
		return dum->ss_hcd;
	else
		return dum->hs_hcd;
Linus Torvalds's avatar
Linus Torvalds committed
307 308
}

309
static inline struct dummy *gadget_dev_to_dummy(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
310
{
311
	return container_of(dev, struct dummy, gadget.dev);
Linus Torvalds's avatar
Linus Torvalds committed
312 313 314 315
}

/*-------------------------------------------------------------------------*/

316 317 318
/* SLAVE/GADGET SIDE UTILITY ROUTINES */

/* called with spinlock held */
319
static void nuke(struct dummy *dum, struct dummy_ep *ep)
320
{
321
	while (!list_empty(&ep->queue)) {
322 323
		struct dummy_request	*req;

324 325
		req = list_entry(ep->queue.next, struct dummy_request, queue);
		list_del_init(&req->queue);
326 327
		req->req.status = -ESHUTDOWN;

328
		spin_unlock(&dum->lock);
329
		usb_gadget_giveback_request(&ep->ep, &req->req);
330
		spin_lock(&dum->lock);
331 332 333 334
	}
}

/* caller must hold lock */
335
static void stop_activity(struct dummy *dum)
336
{
337
	int i;
338 339 340 341 342 343 344

	/* prevent any more requests */
	dum->address = 0;

	/* The timer is left running so that outstanding URBs can fail */

	/* nuke any pending requests first, so driver i/o is quiesced */
345 346
	for (i = 0; i < DUMMY_ENDPOINTS; ++i)
		nuke(dum, &dum->ep[i]);
347 348 349 350

	/* driver now does any non-usb quiescing necessary */
}

351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
/**
 * set_link_state_by_speed() - Sets the current state of the link according to
 *	the hcd speed
 * @dum_hcd: pointer to the dummy_hcd structure to update the link state for
 *
 * This function updates the port_status according to the link state and the
 * speed of the hcd.
 */
static void set_link_state_by_speed(struct dummy_hcd *dum_hcd)
{
	struct dummy *dum = dum_hcd->dum;

	if (dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3) {
		if ((dum_hcd->port_status & USB_SS_PORT_STAT_POWER) == 0) {
			dum_hcd->port_status = 0;
		} else if (!dum->pullup || dum->udc_suspended) {
			/* UDC suspend must cause a disconnect */
			dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
						USB_PORT_STAT_ENABLE);
			if ((dum_hcd->old_status &
			     USB_PORT_STAT_CONNECTION) != 0)
				dum_hcd->port_status |=
					(USB_PORT_STAT_C_CONNECTION << 16);
		} else {
			/* device is connected and not suspended */
			dum_hcd->port_status |= (USB_PORT_STAT_CONNECTION |
						 USB_PORT_STAT_SPEED_5GBPS) ;
			if ((dum_hcd->old_status &
			     USB_PORT_STAT_CONNECTION) == 0)
				dum_hcd->port_status |=
					(USB_PORT_STAT_C_CONNECTION << 16);
			if ((dum_hcd->port_status &
			     USB_PORT_STAT_ENABLE) == 1 &&
				(dum_hcd->port_status &
				 USB_SS_PORT_LS_U0) == 1 &&
				dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
				dum_hcd->active = 1;
		}
	} else {
		if ((dum_hcd->port_status & USB_PORT_STAT_POWER) == 0) {
			dum_hcd->port_status = 0;
		} else if (!dum->pullup || dum->udc_suspended) {
			/* UDC suspend must cause a disconnect */
			dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
						USB_PORT_STAT_ENABLE |
						USB_PORT_STAT_LOW_SPEED |
						USB_PORT_STAT_HIGH_SPEED |
						USB_PORT_STAT_SUSPEND);
			if ((dum_hcd->old_status &
			     USB_PORT_STAT_CONNECTION) != 0)
				dum_hcd->port_status |=
					(USB_PORT_STAT_C_CONNECTION << 16);
		} else {
			dum_hcd->port_status |= USB_PORT_STAT_CONNECTION;
			if ((dum_hcd->old_status &
			     USB_PORT_STAT_CONNECTION) == 0)
				dum_hcd->port_status |=
					(USB_PORT_STAT_C_CONNECTION << 16);
			if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0)
				dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
			else if ((dum_hcd->port_status &
				  USB_PORT_STAT_SUSPEND) == 0 &&
					dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
				dum_hcd->active = 1;
		}
	}
}

419
/* caller must hold lock */
420
static void set_link_state(struct dummy_hcd *dum_hcd)
421
{
422
	struct dummy *dum = dum_hcd->dum;
423
	unsigned int power_bit;
424 425

	dum_hcd->active = 0;
426 427 428 429 430 431 432 433
	if (dum->pullup)
		if ((dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3 &&
		     dum->gadget.speed != USB_SPEED_SUPER) ||
		    (dummy_hcd_to_hcd(dum_hcd)->speed != HCD_USB3 &&
		     dum->gadget.speed == USB_SPEED_SUPER))
			return;

	set_link_state_by_speed(dum_hcd);
434 435
	power_bit = (dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3 ?
			USB_SS_PORT_STAT_POWER : USB_PORT_STAT_POWER);
436

437 438 439
	if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0 ||
	     dum_hcd->active)
		dum_hcd->resuming = 0;
440

441
	/* Currently !connected or in reset */
442
	if ((dum_hcd->port_status & power_bit) == 0 ||
443
			(dum_hcd->port_status & USB_PORT_STAT_RESET) != 0) {
444
		unsigned int disconnect = power_bit &
445
				dum_hcd->old_status & (~dum_hcd->port_status);
446
		unsigned int reset = USB_PORT_STAT_RESET &
447 448 449
				(~dum_hcd->old_status) & dum_hcd->port_status;

		/* Report reset and disconnect events to the driver */
450
		if (dum->ints_enabled && (disconnect || reset)) {
451
			stop_activity(dum);
452 453
			++dum->callback_usage;
			spin_unlock(&dum->lock);
454 455 456 457
			if (reset)
				usb_gadget_udc_reset(&dum->gadget, dum->driver);
			else
				dum->driver->disconnect(&dum->gadget);
458 459
			spin_lock(&dum->lock);
			--dum->callback_usage;
460
		}
461 462 463 464
	} else if (dum_hcd->active != dum_hcd->old_active &&
			dum->ints_enabled) {
		++dum->callback_usage;
		spin_unlock(&dum->lock);
465
		if (dum_hcd->old_active && dum->driver->suspend)
466
			dum->driver->suspend(&dum->gadget);
467
		else if (!dum_hcd->old_active &&  dum->driver->resume)
468
			dum->driver->resume(&dum->gadget);
469 470
		spin_lock(&dum->lock);
		--dum->callback_usage;
471 472
	}

473 474
	dum_hcd->old_status = dum_hcd->port_status;
	dum_hcd->old_active = dum_hcd->active;
475 476 477 478
}

/*-------------------------------------------------------------------------*/

Linus Torvalds's avatar
Linus Torvalds committed
479 480 481 482 483 484 485 486 487 488
/* SLAVE/GADGET SIDE DRIVER
 *
 * This only tracks gadget state.  All the work is done when the host
 * side tries some (emulated) i/o operation.  Real device controller
 * drivers would do real i/o using dma, fifos, irqs, timers, etc.
 */

#define is_enabled(dum) \
	(dum->port_status & USB_PORT_STAT_ENABLE)

489 490
static int dummy_enable(struct usb_ep *_ep,
		const struct usb_endpoint_descriptor *desc)
Linus Torvalds's avatar
Linus Torvalds committed
491 492
{
	struct dummy		*dum;
493
	struct dummy_hcd	*dum_hcd;
Linus Torvalds's avatar
Linus Torvalds committed
494 495 496 497
	struct dummy_ep		*ep;
	unsigned		max;
	int			retval;

498
	ep = usb_ep_to_dummy_ep(_ep);
Linus Torvalds's avatar
Linus Torvalds committed
499 500 501
	if (!_ep || !desc || ep->desc || _ep->name == ep0name
			|| desc->bDescriptorType != USB_DT_ENDPOINT)
		return -EINVAL;
502
	dum = ep_to_dummy(ep);
503 504
	if (!dum->driver)
		return -ESHUTDOWN;
505 506

	dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
507
	if (!is_enabled(dum_hcd))
Linus Torvalds's avatar
Linus Torvalds committed
508
		return -ESHUTDOWN;
509 510 511 512

	/*
	 * For HS/FS devices only bits 0..10 of the wMaxPacketSize represent the
	 * maximum packet size.
513
	 * For SS devices the wMaxPacketSize is limited by 1024.
514
	 */
515
	max = usb_endpoint_maxp(desc) & 0x7ff;
Linus Torvalds's avatar
Linus Torvalds committed
516 517 518 519 520 521 522 523 524 525

	/* drivers must not request bad settings, since lower levels
	 * (hardware or its drivers) may not check.  some endpoints
	 * can't do iso, many have maxpacket limitations, etc.
	 *
	 * since this "hardware" driver is here to help debugging, we
	 * have some extra sanity checks.  (there could be more though,
	 * especially for "ep9out" style fixed function ones.)
	 */
	retval = -EINVAL;
526
	switch (usb_endpoint_type(desc)) {
Linus Torvalds's avatar
Linus Torvalds committed
527
	case USB_ENDPOINT_XFER_BULK:
528 529
		if (strstr(ep->ep.name, "-iso")
				|| strstr(ep->ep.name, "-int")) {
Linus Torvalds's avatar
Linus Torvalds committed
530 531 532
			goto done;
		}
		switch (dum->gadget.speed) {
533 534 535 536
		case USB_SPEED_SUPER:
			if (max == 1024)
				break;
			goto done;
Linus Torvalds's avatar
Linus Torvalds committed
537 538 539
		case USB_SPEED_HIGH:
			if (max == 512)
				break;
540 541 542
			goto done;
		case USB_SPEED_FULL:
			if (max == 8 || max == 16 || max == 32 || max == 64)
Linus Torvalds's avatar
Linus Torvalds committed
543 544
				/* we'll fake any legal size */
				break;
545 546 547
			/* save a return statement */
		default:
			goto done;
Linus Torvalds's avatar
Linus Torvalds committed
548 549 550
		}
		break;
	case USB_ENDPOINT_XFER_INT:
551
		if (strstr(ep->ep.name, "-iso")) /* bulk is ok */
Linus Torvalds's avatar
Linus Torvalds committed
552 553 554
			goto done;
		/* real hardware might not handle all packet sizes */
		switch (dum->gadget.speed) {
555
		case USB_SPEED_SUPER:
Linus Torvalds's avatar
Linus Torvalds committed
556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
		case USB_SPEED_HIGH:
			if (max <= 1024)
				break;
			/* save a return statement */
		case USB_SPEED_FULL:
			if (max <= 64)
				break;
			/* save a return statement */
		default:
			if (max <= 8)
				break;
			goto done;
		}
		break;
	case USB_ENDPOINT_XFER_ISOC:
571 572
		if (strstr(ep->ep.name, "-bulk")
				|| strstr(ep->ep.name, "-int"))
Linus Torvalds's avatar
Linus Torvalds committed
573 574 575
			goto done;
		/* real hardware might not handle all packet sizes */
		switch (dum->gadget.speed) {
576
		case USB_SPEED_SUPER:
Linus Torvalds's avatar
Linus Torvalds committed
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594
		case USB_SPEED_HIGH:
			if (max <= 1024)
				break;
			/* save a return statement */
		case USB_SPEED_FULL:
			if (max <= 1023)
				break;
			/* save a return statement */
		default:
			goto done;
		}
		break;
	default:
		/* few chips support control except on ep0 */
		goto done;
	}

	_ep->maxpacket = max;
595 596 597 598 599 600 601 602
	if (usb_ss_max_streams(_ep->comp_desc)) {
		if (!usb_endpoint_xfer_bulk(desc)) {
			dev_err(udc_dev(dum), "Can't enable stream support on "
					"non-bulk ep %s\n", _ep->name);
			return -EINVAL;
		}
		ep->stream_en = 1;
	}
603
	ep->desc = desc;
Linus Torvalds's avatar
Linus Torvalds committed
604

605
	dev_dbg(udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d stream %s\n",
Linus Torvalds's avatar
Linus Torvalds committed
606 607 608 609
		_ep->name,
		desc->bEndpointAddress & 0x0f,
		(desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
		({ char *val;
610
		 switch (usb_endpoint_type(desc)) {
611 612 613 614 615 616 617 618 619 620 621 622
		 case USB_ENDPOINT_XFER_BULK:
			 val = "bulk";
			 break;
		 case USB_ENDPOINT_XFER_ISOC:
			 val = "iso";
			 break;
		 case USB_ENDPOINT_XFER_INT:
			 val = "intr";
			 break;
		 default:
			 val = "ctrl";
			 break;
623
		 } val; }),
624
		max, ep->stream_en ? "enabled" : "disabled");
Linus Torvalds's avatar
Linus Torvalds committed
625 626 627 628

	/* at this point real hardware should be NAKing transfers
	 * to that endpoint, until a buffer is queued to it.
	 */
629
	ep->halted = ep->wedged = 0;
Linus Torvalds's avatar
Linus Torvalds committed
630 631 632 633 634
	retval = 0;
done:
	return retval;
}

635
static int dummy_disable(struct usb_ep *_ep)
Linus Torvalds's avatar
Linus Torvalds committed
636 637 638 639 640
{
	struct dummy_ep		*ep;
	struct dummy		*dum;
	unsigned long		flags;

641
	ep = usb_ep_to_dummy_ep(_ep);
Linus Torvalds's avatar
Linus Torvalds committed
642 643
	if (!_ep || !ep->desc || _ep->name == ep0name)
		return -EINVAL;
644
	dum = ep_to_dummy(ep);
Linus Torvalds's avatar
Linus Torvalds committed
645

646
	spin_lock_irqsave(&dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
647
	ep->desc = NULL;
648
	ep->stream_en = 0;
649 650
	nuke(dum, ep);
	spin_unlock_irqrestore(&dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
651

652
	dev_dbg(udc_dev(dum), "disabled %s\n", _ep->name);
653
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
654 655
}

656 657
static struct usb_request *dummy_alloc_request(struct usb_ep *_ep,
		gfp_t mem_flags)
Linus Torvalds's avatar
Linus Torvalds committed
658 659 660 661 662 663
{
	struct dummy_ep		*ep;
	struct dummy_request	*req;

	if (!_ep)
		return NULL;
664
	ep = usb_ep_to_dummy_ep(_ep);
Linus Torvalds's avatar
Linus Torvalds committed
665

666
	req = kzalloc(sizeof(*req), mem_flags);
Linus Torvalds's avatar
Linus Torvalds committed
667 668
	if (!req)
		return NULL;
669
	INIT_LIST_HEAD(&req->queue);
Linus Torvalds's avatar
Linus Torvalds committed
670 671 672
	return &req->req;
}

673
static void dummy_free_request(struct usb_ep *_ep, struct usb_request *_req)
Linus Torvalds's avatar
Linus Torvalds committed
674 675 676
{
	struct dummy_request	*req;

677
	if (!_ep || !_req) {
678
		WARN_ON(1);
Linus Torvalds's avatar
Linus Torvalds committed
679
		return;
680
	}
Linus Torvalds's avatar
Linus Torvalds committed
681

682 683 684
	req = usb_request_to_dummy_request(_req);
	WARN_ON(!list_empty(&req->queue));
	kfree(req);
Linus Torvalds's avatar
Linus Torvalds committed
685 686
}

687
static void fifo_complete(struct usb_ep *ep, struct usb_request *req)
Linus Torvalds's avatar
Linus Torvalds committed
688 689 690
{
}

691
static int dummy_queue(struct usb_ep *_ep, struct usb_request *_req,
Al Viro's avatar
Al Viro committed
692
		gfp_t mem_flags)
Linus Torvalds's avatar
Linus Torvalds committed
693 694 695 696
{
	struct dummy_ep		*ep;
	struct dummy_request	*req;
	struct dummy		*dum;
697
	struct dummy_hcd	*dum_hcd;
Linus Torvalds's avatar
Linus Torvalds committed
698 699
	unsigned long		flags;

700 701
	req = usb_request_to_dummy_request(_req);
	if (!_req || !list_empty(&req->queue) || !_req->complete)
Linus Torvalds's avatar
Linus Torvalds committed
702 703
		return -EINVAL;

704
	ep = usb_ep_to_dummy_ep(_ep);
Linus Torvalds's avatar
Linus Torvalds committed
705 706 707
	if (!_ep || (!ep->desc && _ep->name != ep0name))
		return -EINVAL;

708
	dum = ep_to_dummy(ep);
709
	dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
710
	if (!dum->driver || !is_enabled(dum_hcd))
Linus Torvalds's avatar
Linus Torvalds committed
711 712 713
		return -ESHUTDOWN;

#if 0
714
	dev_dbg(udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n",
Linus Torvalds's avatar
Linus Torvalds committed
715 716 717 718
			ep, _req, _ep->name, _req->length, _req->buf);
#endif
	_req->status = -EINPROGRESS;
	_req->actual = 0;
719
	spin_lock_irqsave(&dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
720 721 722

	/* implement an emulated single-request FIFO */
	if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
723 724
			list_empty(&dum->fifo_req.queue) &&
			list_empty(&ep->queue) &&
Linus Torvalds's avatar
Linus Torvalds committed
725 726 727 728
			_req->length <= FIFO_SIZE) {
		req = &dum->fifo_req;
		req->req = *_req;
		req->req.buf = dum->fifo_buf;
729
		memcpy(dum->fifo_buf, _req->buf, _req->length);
Linus Torvalds's avatar
Linus Torvalds committed
730 731 732
		req->req.context = dum;
		req->req.complete = fifo_complete;

733
		list_add_tail(&req->queue, &ep->queue);
734
		spin_unlock(&dum->lock);
Linus Torvalds's avatar
Linus Torvalds committed
735 736
		_req->actual = _req->length;
		_req->status = 0;
737
		usb_gadget_giveback_request(_ep, _req);
738
		spin_lock(&dum->lock);
739 740
	}  else
		list_add_tail(&req->queue, &ep->queue);
741
	spin_unlock_irqrestore(&dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
742 743 744 745 746 747 748

	/* real hardware would likely enable transfers here, in case
	 * it'd been left NAKing.
	 */
	return 0;
}

749
static int dummy_dequeue(struct usb_ep *_ep, struct usb_request *_req)
Linus Torvalds's avatar
Linus Torvalds committed
750 751 752 753 754 755 756 757 758
{
	struct dummy_ep		*ep;
	struct dummy		*dum;
	int			retval = -EINVAL;
	unsigned long		flags;
	struct dummy_request	*req = NULL;

	if (!_ep || !_req)
		return retval;
759 760
	ep = usb_ep_to_dummy_ep(_ep);
	dum = ep_to_dummy(ep);
Linus Torvalds's avatar
Linus Torvalds committed
761 762 763 764

	if (!dum->driver)
		return -ESHUTDOWN;

765 766 767
	local_irq_save(flags);
	spin_lock(&dum->lock);
	list_for_each_entry(req, &ep->queue, queue) {
Linus Torvalds's avatar
Linus Torvalds committed
768
		if (&req->req == _req) {
769
			list_del_init(&req->queue);
Linus Torvalds's avatar
Linus Torvalds committed
770 771 772 773 774
			_req->status = -ECONNRESET;
			retval = 0;
			break;
		}
	}
775
	spin_unlock(&dum->lock);
Linus Torvalds's avatar
Linus Torvalds committed
776 777

	if (retval == 0) {
778
		dev_dbg(udc_dev(dum),
Linus Torvalds's avatar
Linus Torvalds committed
779 780
				"dequeued req %p from %s, len %d buf %p\n",
				req, _ep->name, _req->length, _req->buf);
781
		usb_gadget_giveback_request(_ep, _req);
Linus Torvalds's avatar
Linus Torvalds committed
782
	}
783
	local_irq_restore(flags);
Linus Torvalds's avatar
Linus Torvalds committed
784 785 786 787
	return retval;
}

static int
788
dummy_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
Linus Torvalds's avatar
Linus Torvalds committed
789 790 791 792 793 794
{
	struct dummy_ep		*ep;
	struct dummy		*dum;

	if (!_ep)
		return -EINVAL;
795 796
	ep = usb_ep_to_dummy_ep(_ep);
	dum = ep_to_dummy(ep);
Linus Torvalds's avatar
Linus Torvalds committed
797 798 799
	if (!dum->driver)
		return -ESHUTDOWN;
	if (!value)
800
		ep->halted = ep->wedged = 0;
Linus Torvalds's avatar
Linus Torvalds committed
801
	else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
802
			!list_empty(&ep->queue))
Linus Torvalds's avatar
Linus Torvalds committed
803
		return -EAGAIN;
804
	else {
Linus Torvalds's avatar
Linus Torvalds committed
805
		ep->halted = 1;
806 807 808
		if (wedged)
			ep->wedged = 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
809 810 811 812
	/* FIXME clear emulated data toggle too */
	return 0;
}

813 814 815 816 817 818 819 820 821 822 823 824 825
static int
dummy_set_halt(struct usb_ep *_ep, int value)
{
	return dummy_set_halt_and_wedge(_ep, value, 0);
}

static int dummy_set_wedge(struct usb_ep *_ep)
{
	if (!_ep || _ep->name == ep0name)
		return -EINVAL;
	return dummy_set_halt_and_wedge(_ep, 1, 1);
}

Linus Torvalds's avatar
Linus Torvalds committed
826 827 828 829 830 831 832 833 834 835 836
static const struct usb_ep_ops dummy_ep_ops = {
	.enable		= dummy_enable,
	.disable	= dummy_disable,

	.alloc_request	= dummy_alloc_request,
	.free_request	= dummy_free_request,

	.queue		= dummy_queue,
	.dequeue	= dummy_dequeue,

	.set_halt	= dummy_set_halt,
837
	.set_wedge	= dummy_set_wedge,
Linus Torvalds's avatar
Linus Torvalds committed
838 839 840 841 842
};

/*-------------------------------------------------------------------------*/

/* there are both host and device side versions of this call ... */
843
static int dummy_g_get_frame(struct usb_gadget *_gadget)
Linus Torvalds's avatar
Linus Torvalds committed
844
{
845
	struct timespec64 ts64;
Linus Torvalds's avatar
Linus Torvalds committed
846

847 848
	ktime_get_ts64(&ts64);
	return ts64.tv_nsec / NSEC_PER_MSEC;
Linus Torvalds's avatar
Linus Torvalds committed
849 850
}

851
static int dummy_wakeup(struct usb_gadget *_gadget)
Linus Torvalds's avatar
Linus Torvalds committed
852
{
853
	struct dummy_hcd *dum_hcd;
Linus Torvalds's avatar
Linus Torvalds committed
854

855 856
	dum_hcd = gadget_to_dummy_hcd(_gadget);
	if (!(dum_hcd->dum->devstatus & ((1 << USB_DEVICE_B_HNP_ENABLE)
857
				| (1 << USB_DEVICE_REMOTE_WAKEUP))))
Linus Torvalds's avatar
Linus Torvalds committed
858
		return -EINVAL;
859
	if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0)
860
		return -ENOLINK;
861 862
	if ((dum_hcd->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
			 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
863 864 865
		return -EIO;

	/* FIXME: What if the root hub is suspended but the port isn't? */
Linus Torvalds's avatar
Linus Torvalds committed
866 867

	/* hub notices our request, issues downstream resume, etc */
868 869 870
	dum_hcd->resuming = 1;
	dum_hcd->re_timeout = jiffies + msecs_to_jiffies(20);
	mod_timer(&dummy_hcd_to_hcd(dum_hcd)->rh_timer, dum_hcd->re_timeout);
Linus Torvalds's avatar
Linus Torvalds committed
871 872 873
	return 0;
}

874
static int dummy_set_selfpowered(struct usb_gadget *_gadget, int value)
Linus Torvalds's avatar
Linus Torvalds committed
875 876 877
{
	struct dummy	*dum;

878
	_gadget->is_selfpowered = (value != 0);
879
	dum = gadget_to_dummy_hcd(_gadget)->dum;
Linus Torvalds's avatar
Linus Torvalds committed
880 881 882 883 884 885 886
	if (value)
		dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
	else
		dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
	return 0;
}

887
static void dummy_udc_update_ep0(struct dummy *dum)
888
{
889
	if (dum->gadget.speed == USB_SPEED_SUPER)
890
		dum->ep[0].ep.maxpacket = 9;
891
	else
892 893 894
		dum->ep[0].ep.maxpacket = 64;
}

895
static int dummy_pullup(struct usb_gadget *_gadget, int value)
896
{
897
	struct dummy_hcd *dum_hcd;
898 899 900
	struct dummy	*dum;
	unsigned long	flags;

901 902 903 904
	dum = gadget_dev_to_dummy(&_gadget->dev);

	if (value && dum->driver) {
		if (mod_data.is_super_speed)
905
			dum->gadget.speed = dum->driver->max_speed;
906 907
		else if (mod_data.is_high_speed)
			dum->gadget.speed = min_t(u8, USB_SPEED_HIGH,
908
					dum->driver->max_speed);
909 910
		else
			dum->gadget.speed = USB_SPEED_FULL;
911
		dummy_udc_update_ep0(dum);
912

913
		if (dum->gadget.speed < dum->driver->max_speed)
914
			dev_dbg(udc_dev(dum), "This device can perform faster"
915 916
				" if you connect it to a %s port...\n",
				usb_speed_string(dum->driver->max_speed));
917
	}
918 919
	dum_hcd = gadget_to_dummy_hcd(_gadget);

920
	spin_lock_irqsave(&dum->lock, flags);
921
	dum->pullup = (value != 0);
922
	set_link_state(dum_hcd);
923
	spin_unlock_irqrestore(&dum->lock, flags);
924

925
	usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
926 927 928
	return 0;
}

929 930
static int dummy_udc_start(struct usb_gadget *g,
		struct usb_gadget_driver *driver);
931
static int dummy_udc_stop(struct usb_gadget *g);
932

Linus Torvalds's avatar
Linus Torvalds committed
933 934 935 936
static const struct usb_gadget_ops dummy_ops = {
	.get_frame	= dummy_g_get_frame,
	.wakeup		= dummy_wakeup,
	.set_selfpowered = dummy_set_selfpowered,
937
	.pullup		= dummy_pullup,
938 939
	.udc_start	= dummy_udc_start,
	.udc_stop	= dummy_udc_stop,
Linus Torvalds's avatar
Linus Torvalds committed
940 941 942 943 944
};

/*-------------------------------------------------------------------------*/

/* "function" sysfs attribute */
945
static ssize_t function_show(struct device *dev, struct device_attribute *attr,
946
		char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
947
{
948
	struct dummy	*dum = gadget_dev_to_dummy(dev);
Linus Torvalds's avatar
Linus Torvalds committed
949 950 951

	if (!dum->driver || !dum->driver->function)
		return 0;
952
	return scnprintf(buf, PAGE_SIZE, "%s\n", dum->driver->function);
Linus Torvalds's avatar
Linus Torvalds committed
953
}
954
static DEVICE_ATTR_RO(function);
Linus Torvalds's avatar
Linus Torvalds committed
955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971

/*-------------------------------------------------------------------------*/

/*
 * Driver registration/unregistration.
 *
 * This is basically hardware-specific; there's usually only one real USB
 * device (not host) controller since that's how USB devices are intended
 * to work.  So most implementations of these api calls will rely on the
 * fact that only one driver will ever bind to the hardware.  But curious
 * hardware can be built with discrete components, so the gadget API doesn't
 * require that assumption.
 *
 * For this emulator, it might be convenient to create a usb slave device
 * for each driver that registers:  just add to a big root hub.
 */

972 973
static int dummy_udc_start(struct usb_gadget *g,
		struct usb_gadget_driver *driver)
Linus Torvalds's avatar
Linus Torvalds committed
974
{
975 976
	struct dummy_hcd	*dum_hcd = gadget_to_dummy_hcd(g);
	struct dummy		*dum = dum_hcd->dum;
Linus Torvalds's avatar
Linus Torvalds committed
977

978
	if (driver->max_speed == USB_SPEED_UNKNOWN)
Linus Torvalds's avatar
Linus Torvalds committed
979 980 981 982 983 984
		return -EINVAL;

	/*
	 * SLAVE side init ... the layer above hardware, which
	 * can't enumerate without help from the driver we're binding.
	 */
985

986
	spin_lock_irq(&dum->lock);
Linus Torvalds's avatar
Linus Torvalds committed
987 988
	dum->devstatus = 0;
	dum->driver = driver;
989 990
	dum->ints_enabled = 1;
	spin_unlock_irq(&dum->lock);
991

Linus Torvalds's avatar
Linus Torvalds committed
992 993 994
	return 0;
}

995
static int dummy_udc_stop(struct usb_gadget *g)
Linus Torvalds's avatar
Linus Torvalds committed
996
{
997 998
	struct dummy_hcd	*dum_hcd = gadget_to_dummy_hcd(g);
	struct dummy		*dum = dum_hcd->dum;
Linus Torvalds's avatar
Linus Torvalds committed
999

1000
	spin_lock_irq(&dum->lock);
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
	dum->ints_enabled = 0;
	stop_activity(dum);

	/* emulate synchronize_irq(): wait for callbacks to finish */
	while (dum->callback_usage > 0) {
		spin_unlock_irq(&dum->lock);
		usleep_range(1000, 2000);
		spin_lock_irq(&dum->lock);
	}

Linus Torvalds's avatar
Linus Torvalds committed
1011
	dum->driver = NULL;
1012
	spin_unlock_irq(&dum->lock);
1013

Linus Torvalds's avatar
Linus Torvalds committed
1014 1015 1016 1017 1018
	return 0;
}

#undef is_enabled

1019 1020
/* The gadget structure is stored inside the hcd structure and will be
 * released along with it. */
1021 1022 1023 1024 1025 1026 1027 1028
static void init_dummy_udc_hw(struct dummy *dum)
{
	int i;

	INIT_LIST_HEAD(&dum->gadget.ep_list);
	for (i = 0; i < DUMMY_ENDPOINTS; i++) {
		struct dummy_ep	*ep = &dum->ep[i];

1029
		if (!ep_info[i].name)
1030
			break;
1031 1032
		ep->ep.name = ep_info[i].name;
		ep->ep.caps = ep_info[i].caps;
1033 1034 1035 1036
		ep->ep.ops = &dummy_ep_ops;
		list_add_tail(&ep->ep.ep_list, &dum->gadget.ep_list);
		ep->halted = ep->wedged = ep->already_seen =
				ep->setup_stage = 0;
1037
		usb_ep_set_maxpacket_limit(&ep->ep, ~0);
1038
		ep->ep.max_streams = 16;
1039 1040 1041 1042 1043 1044 1045 1046 1047
		ep->last_io = jiffies;
		ep->gadget = &dum->gadget;
		ep->desc = NULL;
		INIT_LIST_HEAD(&ep->queue);
	}

	dum->gadget.ep0 = &dum->ep[0].ep;
	list_del_init(&dum->ep[0].ep.ep_list);
	INIT_LIST_HEAD(&dum->fifo_req.queue);
1048 1049 1050 1051

#ifdef CONFIG_USB_OTG
	dum->gadget.is_otg = 1;
#endif
1052 1053
}

1054
static int dummy_udc_probe(struct platform_device *pdev)
1055
{
1056
	struct dummy	*dum;
1057 1058
	int		rc;

1059
	dum = *((void **)dev_get_platdata(&pdev->dev));
1060 1061
	/* Clear usb_gadget region for new registration to udc-core */
	memzero_explicit(&dum->gadget, sizeof(struct usb_gadget));
1062 1063
	dum->gadget.name = gadget_name;
	dum->gadget.ops = &dummy_ops;
1064 1065 1066 1067 1068 1069
	if (mod_data.is_super_speed)
		dum->gadget.max_speed = USB_SPEED_SUPER;
	else if (mod_data.is_high_speed)
		dum->gadget.max_speed = USB_SPEED_HIGH;
	else
		dum->gadget.max_speed = USB_SPEED_FULL;
1070

1071
	dum->gadget.dev.parent = &pdev->dev;
1072 1073
	init_dummy_udc_hw(dum);

1074 1075 1076 1077
	rc = usb_add_gadget_udc(&pdev->dev, &dum->gadget);
	if (rc < 0)
		goto err_udc;

1078
	rc = device_create_file(&dum->gadget.dev, &dev_attr_function);
1079
	if (rc < 0)
1080 1081 1082 1083 1084 1085 1086
		goto err_dev;
	platform_set_drvdata(pdev, dum);
	return rc;

err_dev:
	usb_del_gadget_udc(&dum->gadget);
err_udc:
1087 1088 1089
	return rc;
}

1090
static int dummy_udc_remove(struct platform_device *pdev)
1091
{
1092
	struct dummy	*dum = platform_get_drvdata(pdev);
1093

1094
	device_remove_file(&dum->gadget.dev, &dev_attr_function);
1095
	usb_del_gadget_udc(&dum->gadget);
1096 1097 1098
	return 0;
}

1099 1100
static void dummy_udc_pm(struct dummy *dum, struct dummy_hcd *dum_hcd,
		int suspend)
1101
{
1102 1103
	spin_lock_irq(&dum->lock);
	dum->udc_suspended = suspend;
1104
	set_link_state(dum_hcd);
1105 1106 1107 1108 1109 1110 1111
	spin_unlock_irq(&dum->lock);
}

static int dummy_udc_suspend(struct platform_device *pdev, pm_message_t state)
{
	struct dummy		*dum = platform_get_drvdata(pdev);
	struct dummy_hcd	*dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
1112

1113 1114
	dev_dbg(&pdev->dev, "%s\n", __func__);
	dummy_udc_pm(dum, dum_hcd, 1);
1115
	usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1116 1117 1118
	return 0;
}

1119
static int dummy_udc_resume(struct platform_device *pdev)
1120
{
1121 1122
	struct dummy		*dum = platform_get_drvdata(pdev);
	struct dummy_hcd	*dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
1123

1124 1125
	dev_dbg(&pdev->dev, "%s\n", __func__);
	dummy_udc_pm(dum, dum_hcd, 0);
1126
	usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1127 1128 1129
	return 0;
}

1130
static struct platform_driver dummy_udc_driver = {
1131 1132
	.probe		= dummy_udc_probe,
	.remove		= dummy_udc_remove,
1133 1134
	.suspend	= dummy_udc_suspend,
	.resume		= dummy_udc_resume,
1135 1136 1137
	.driver		= {
		.name	= (char *) gadget_name,
	},
1138 1139
};

Linus Torvalds's avatar
Linus Torvalds committed
1140 1141
/*-------------------------------------------------------------------------*/

1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
static unsigned int dummy_get_ep_idx(const struct usb_endpoint_descriptor *desc)
{
	unsigned int index;

	index = usb_endpoint_num(desc) << 1;
	if (usb_endpoint_dir_in(desc))
		index |= 1;
	return index;
}

Linus Torvalds's avatar
Linus Torvalds committed
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
/* MASTER/HOST SIDE DRIVER
 *
 * this uses the hcd framework to hook up to host side drivers.
 * its root hub will only have one device, otherwise it acts like
 * a normal host controller.
 *
 * when urbs are queued, they're just stuck on a list that we
 * scan in a timer callback.  that callback connects writes from
 * the host with reads from the device, and so on, based on the
 * usb 2.0 rules.
 */

1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
static int dummy_ep_stream_en(struct dummy_hcd *dum_hcd, struct urb *urb)
{
	const struct usb_endpoint_descriptor *desc = &urb->ep->desc;
	u32 index;

	if (!usb_endpoint_xfer_bulk(desc))
		return 0;

	index = dummy_get_ep_idx(desc);
	return (1 << index) & dum_hcd->stream_en_ep;
}

/*
 * The max stream number is saved as a nibble so for the 30 possible endpoints
 * we only 15 bytes of memory. Therefore we are limited to max 16 streams (0
 * means we use only 1 stream). The maximum according to the spec is 16bit so
 * if the 16 stream limit is about to go, the array size should be incremented
 * to 30 elements of type u16.
 */
static int get_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
		unsigned int pipe)
{
	int max_streams;

	max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
	if (usb_pipeout(pipe))
		max_streams >>= 4;
	else
		max_streams &= 0xf;
	max_streams++;
	return max_streams;
}

static void set_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
		unsigned int pipe, unsigned int streams)
{
	int max_streams;

	streams--;
	max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
	if (usb_pipeout(pipe)) {
		streams <<= 4;
		max_streams &= 0xf;
	} else {
		max_streams &= 0xf0;
	}
	max_streams |= streams;
	dum_hcd->num_stream[usb_pipeendpoint(pipe)] = max_streams;
}

static int dummy_validate_stream(struct dummy_hcd *dum_hcd, struct urb *urb)
{
	unsigned int max_streams;
	int enabled;

	enabled = dummy_ep_stream_en(dum_hcd, urb);
	if (!urb->stream_id) {
		if (enabled)
			return -EINVAL;
		return 0;
	}
	if (!enabled)
		return -EINVAL;

	max_streams = get_max_streams_for_pipe(dum_hcd,
			usb_pipeendpoint(urb->pipe));
	if (urb->stream_id > max_streams) {
		dev_err(dummy_dev(dum_hcd), "Stream id %d is out of range.\n",
				urb->stream_id);
		BUG();
		return -EINVAL;
	}
	return 0;
}

1239
static int dummy_urb_enqueue(
Linus Torvalds's avatar
Linus Torvalds committed
1240 1241
	struct usb_hcd			*hcd,
	struct urb			*urb,
Al Viro's avatar
Al Viro committed
1242
	gfp_t				mem_flags
Linus Torvalds's avatar
Linus Torvalds committed
1243
) {
1244
	struct dummy_hcd *dum_hcd;
Linus Torvalds's avatar
Linus Torvalds committed
1245 1246
	struct urbp	*urbp;
	unsigned long	flags;
1247
	int		rc;
Linus Torvalds's avatar
Linus Torvalds committed
1248

1249
	urbp = kmalloc(sizeof *urbp, mem_flags);
Linus Torvalds's avatar
Linus Torvalds committed
1250 1251 1252
	if (!urbp)
		return -ENOMEM;
	urbp->urb = urb;
1253
	urbp->miter_started = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1254

1255 1256
	dum_hcd = hcd_to_dummy_hcd(hcd);
	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1257 1258 1259 1260 1261 1262 1263

	rc = dummy_validate_stream(dum_hcd, urb);
	if (rc) {
		kfree(urbp);
		goto done;
	}

1264 1265 1266 1267 1268
	rc = usb_hcd_link_urb_to_ep(hcd, urb);
	if (rc) {
		kfree(urbp);
		goto done;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1269

1270 1271 1272 1273 1274
	if (!dum_hcd->udev) {
		dum_hcd->udev = urb->dev;
		usb_get_dev(dum_hcd->udev);
	} else if (unlikely(dum_hcd->udev != urb->dev))
		dev_err(dummy_dev(dum_hcd), "usb_device address has changed!\n");
Linus Torvalds's avatar
Linus Torvalds committed
1275

1276
	list_add_tail(&urbp->urbp_list, &dum_hcd->urbp_list);
Linus Torvalds's avatar
Linus Torvalds committed
1277
	urb->hcpriv = urbp;
1278 1279
	if (!dum_hcd->next_frame_urbp)
		dum_hcd->next_frame_urbp = urbp;
1280
	if (usb_pipetype(urb->pipe) == PIPE_CONTROL)
Linus Torvalds's avatar
Linus Torvalds committed
1281 1282 1283
		urb->error_count = 1;		/* mark as a new urb */

	/* kick the scheduler, it'll do the rest */
1284 1285
	if (!timer_pending(&dum_hcd->timer))
		mod_timer(&dum_hcd->timer, jiffies + 1);
Linus Torvalds's avatar
Linus Torvalds committed
1286

1287
 done:
1288
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1289
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
1290 1291
}

1292
static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
Linus Torvalds's avatar
Linus Torvalds committed
1293
{
1294
	struct dummy_hcd *dum_hcd;
1295
	unsigned long	flags;
1296
	int		rc;
1297 1298 1299

	/* giveback happens automatically in timer callback,
	 * so make sure the callback happens */
1300 1301
	dum_hcd = hcd_to_dummy_hcd(hcd);
	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1302 1303

	rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1304 1305 1306
	if (!rc && dum_hcd->rh_state != DUMMY_RH_RUNNING &&
			!list_empty(&dum_hcd->urbp_list))
		mod_timer(&dum_hcd->timer, jiffies);
1307

1308
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1309
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
1310 1311
}

1312 1313 1314 1315
static int dummy_perform_transfer(struct urb *urb, struct dummy_request *req,
		u32 len)
{
	void *ubuf, *rbuf;
1316
	struct urbp *urbp = urb->hcpriv;
1317
	int to_host;
1318 1319 1320 1321
	struct sg_mapping_iter *miter = &urbp->miter;
	u32 trans = 0;
	u32 this_sg;
	bool next_sg;
1322 1323 1324 1325

	to_host = usb_pipein(urb->pipe);
	rbuf = req->req.buf + req->req.actual;

1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
	if (!urb->num_sgs) {
		ubuf = urb->transfer_buffer + urb->actual_length;
		if (to_host)
			memcpy(ubuf, rbuf, len);
		else
			memcpy(rbuf, ubuf, len);
		return len;
	}

	if (!urbp->miter_started) {
		u32 flags = SG_MITER_ATOMIC;

		if (to_host)
			flags |= SG_MITER_TO_SG;
		else
			flags |= SG_MITER_FROM_SG;

		sg_miter_start(miter, urb->sg, urb->num_sgs, flags);
		urbp->miter_started = 1;
	}
	next_sg = sg_miter_next(miter);
	if (next_sg == false) {
		WARN_ON_ONCE(1);
		return -EINVAL;
	}
	do {
		ubuf = miter->addr;
		this_sg = min_t(u32, len, miter->length);
		miter->consumed = this_sg;
		trans += this_sg;

		if (to_host)
			memcpy(ubuf, rbuf, this_sg);
		else
			memcpy(rbuf, ubuf, this_sg);
		len -= this_sg;

		if (!len)
			break;
		next_sg = sg_miter_next(miter);
		if (next_sg == false) {
			WARN_ON_ONCE(1);
			return -EINVAL;
		}

		rbuf += this_sg;
	} while (1);

	sg_miter_stop(miter);
	return trans;
1376 1377
}

Linus Torvalds's avatar
Linus Torvalds committed
1378
/* transfer up to a frame's worth; caller must own lock */
1379 1380
static int transfer(struct dummy_hcd *dum_hcd, struct urb *urb,
		struct dummy_ep *ep, int limit, int *status)
Linus Torvalds's avatar
Linus Torvalds committed
1381
{
1382
	struct dummy		*dum = dum_hcd->dum;
Linus Torvalds's avatar
Linus Torvalds committed
1383
	struct dummy_request	*req;
1384
	int			sent = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1385 1386 1387

top:
	/* if there's no request queued, the device is NAKing; return */
1388
	list_for_each_entry(req, &ep->queue, queue) {
Linus Torvalds's avatar
Linus Torvalds committed
1389 1390 1391 1392
		unsigned	host_len, dev_len, len;
		int		is_short, to_host;
		int		rescan = 0;

1393 1394 1395 1396 1397
		if (dummy_ep_stream_en(dum_hcd, urb)) {
			if ((urb->stream_id != req->req.stream_id))
				continue;
		}

Linus Torvalds's avatar
Linus Torvalds committed
1398 1399 1400 1401 1402 1403 1404 1405 1406
		/* 1..N packets of ep->ep.maxpacket each ... the last one
		 * may be short (including zero length).
		 *
		 * writer can send a zlp explicitly (length 0) or implicitly
		 * (length mod maxpacket zero, and 'zero' flag); they always
		 * terminate reads.
		 */
		host_len = urb->transfer_buffer_length - urb->actual_length;
		dev_len = req->req.length - req->req.actual;
1407
		len = min(host_len, dev_len);
Linus Torvalds's avatar
Linus Torvalds committed
1408 1409 1410

		/* FIXME update emulated data toggle too */

1411 1412
		to_host = usb_pipein(urb->pipe);
		if (unlikely(len == 0))
Linus Torvalds's avatar
Linus Torvalds committed
1413 1414 1415 1416 1417
			is_short = 1;
		else {
			/* not enough bandwidth left? */
			if (limit < ep->ep.maxpacket && limit < len)
				break;
1418
			len = min_t(unsigned, len, limit);
Linus Torvalds's avatar
Linus Torvalds committed
1419 1420 1421
			if (len == 0)
				break;

1422 1423 1424 1425 1426 1427 1428 1429
			/* send multiple of maxpacket first, then remainder */
			if (len >= ep->ep.maxpacket) {
				is_short = 0;
				if (len % ep->ep.maxpacket)
					rescan = 1;
				len -= len % ep->ep.maxpacket;
			} else {
				is_short = 1;
Linus Torvalds's avatar
Linus Torvalds committed
1430 1431
			}

1432 1433
			len = dummy_perform_transfer(urb, req, len);

Linus Torvalds's avatar
Linus Torvalds committed
1434
			ep->last_io = jiffies;
1435
			if ((int)len < 0) {
1436 1437 1438
				req->req.status = len;
			} else {
				limit -= len;
1439
				sent += len;
1440 1441 1442
				urb->actual_length += len;
				req->req.actual += len;
			}
Linus Torvalds's avatar
Linus Torvalds committed
1443 1444 1445 1446 1447 1448 1449
		}

		/* short packets terminate, maybe with overflow/underflow.
		 * it's only really an error to write too much.
		 *
		 * partially filling a buffer optionally blocks queue advances
		 * (so completion handlers can clean up the queue) but we don't
1450
		 * need to emulate such data-in-flight.
Linus Torvalds's avatar
Linus Torvalds committed
1451 1452 1453 1454
		 */
		if (is_short) {
			if (host_len == dev_len) {
				req->req.status = 0;
1455
				*status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1456 1457 1458
			} else if (to_host) {
				req->req.status = 0;
				if (dev_len > host_len)
1459
					*status = -EOVERFLOW;
Linus Torvalds's avatar
Linus Torvalds committed
1460
				else
1461
					*status = 0;
1462
			} else {
1463
				*status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1464 1465 1466 1467 1468 1469
				if (host_len > dev_len)
					req->req.status = -EOVERFLOW;
				else
					req->req.status = 0;
			}

1470 1471 1472 1473
		/*
		 * many requests terminate without a short packet.
		 * send a zlp if demanded by flags.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
1474
		} else {
1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487
			if (req->req.length == req->req.actual) {
				if (req->req.zero && to_host)
					rescan = 1;
				else
					req->req.status = 0;
			}
			if (urb->transfer_buffer_length == urb->actual_length) {
				if (urb->transfer_flags & URB_ZERO_PACKET &&
				    !to_host)
					rescan = 1;
				else
					*status = 0;
			}
Linus Torvalds's avatar
Linus Torvalds committed
1488 1489 1490 1491
		}

		/* device side completion --> continuable */
		if (req->req.status != -EINPROGRESS) {
1492
			list_del_init(&req->queue);
Linus Torvalds's avatar
Linus Torvalds committed
1493

1494
			spin_unlock(&dum->lock);
1495
			usb_gadget_giveback_request(&ep->ep, &req->req);
1496
			spin_lock(&dum->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1497 1498 1499 1500 1501 1502

			/* requests might have been unlinked... */
			rescan = 1;
		}

		/* host side completion --> terminate */
1503
		if (*status != -EINPROGRESS)
Linus Torvalds's avatar
Linus Torvalds committed
1504 1505 1506 1507 1508 1509
			break;

		/* rescan to continue with any other queued i/o */
		if (rescan)
			goto top;
	}
1510
	return sent;
Linus Torvalds's avatar
Linus Torvalds committed
1511 1512
}

1513
static int periodic_bytes(struct dummy *dum, struct dummy_ep *ep)
Linus Torvalds's avatar
Linus Torvalds committed
1514 1515 1516 1517 1518 1519 1520
{
	int	limit = ep->ep.maxpacket;

	if (dum->gadget.speed == USB_SPEED_HIGH) {
		int	tmp;

		/* high bandwidth mode */
1521
		tmp = usb_endpoint_maxp(ep->desc);
Linus Torvalds's avatar
Linus Torvalds committed
1522 1523 1524 1525
		tmp = (tmp >> 11) & 0x03;
		tmp *= 8 /* applies to entire frame */;
		limit += limit * tmp;
	}
1526
	if (dum->gadget.speed == USB_SPEED_SUPER) {
1527
		switch (usb_endpoint_type(ep->desc)) {
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
		case USB_ENDPOINT_XFER_ISOC:
			/* Sec. 4.4.8.2 USB3.0 Spec */
			limit = 3 * 16 * 1024 * 8;
			break;
		case USB_ENDPOINT_XFER_INT:
			/* Sec. 4.4.7.2 USB3.0 Spec */
			limit = 3 * 1024 * 8;
			break;
		case USB_ENDPOINT_XFER_BULK:
		default:
			break;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
1541 1542 1543
	return limit;
}

1544
#define is_active(dum_hcd)	((dum_hcd->port_status & \
Linus Torvalds's avatar
Linus Torvalds committed
1545 1546 1547 1548
		(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \
			USB_PORT_STAT_SUSPEND)) \
		== (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))

1549
static struct dummy_ep *find_endpoint(struct dummy *dum, u8 address)
Linus Torvalds's avatar
Linus Torvalds committed
1550 1551 1552
{
	int		i;

1553 1554
	if (!is_active((dum->gadget.speed == USB_SPEED_SUPER ?
			dum->ss_hcd : dum->hs_hcd)))
Linus Torvalds's avatar
Linus Torvalds committed
1555
		return NULL;
1556 1557
	if (!dum->ints_enabled)
		return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1558
	if ((address & ~USB_DIR_IN) == 0)
1559
		return &dum->ep[0];
Linus Torvalds's avatar
Linus Torvalds committed
1560
	for (i = 1; i < DUMMY_ENDPOINTS; i++) {
1561
		struct dummy_ep	*ep = &dum->ep[i];
Linus Torvalds's avatar
Linus Torvalds committed
1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579

		if (!ep->desc)
			continue;
		if (ep->desc->bEndpointAddress == address)
			return ep;
	}
	return NULL;
}

#undef is_active

#define Dev_Request	(USB_TYPE_STANDARD | USB_RECIP_DEVICE)
#define Dev_InRequest	(Dev_Request | USB_DIR_IN)
#define Intf_Request	(USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
#define Intf_InRequest	(Intf_Request | USB_DIR_IN)
#define Ep_Request	(USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
#define Ep_InRequest	(Ep_Request | USB_DIR_IN)

1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592

/**
 * handle_control_request() - handles all control transfers
 * @dum: pointer to dummy (the_controller)
 * @urb: the urb request to handle
 * @setup: pointer to the setup data for a USB device control
 *	 request
 * @status: pointer to request handling status
 *
 * Return 0 - if the request was handled
 *	  1 - if the request wasn't handles
 *	  error code on error
 */
1593
static int handle_control_request(struct dummy_hcd *dum_hcd, struct urb *urb,
1594 1595 1596 1597
				  struct usb_ctrlrequest *setup,
				  int *status)
{
	struct dummy_ep		*ep2;
1598
	struct dummy		*dum = dum_hcd->dum;
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
	int			ret_val = 1;
	unsigned	w_index;
	unsigned	w_value;

	w_index = le16_to_cpu(setup->wIndex);
	w_value = le16_to_cpu(setup->wValue);
	switch (setup->bRequest) {
	case USB_REQ_SET_ADDRESS:
		if (setup->bRequestType != Dev_Request)
			break;
		dum->address = w_value;
		*status = 0;
		dev_dbg(udc_dev(dum), "set_address = %d\n",
				w_value);
		ret_val = 0;
		break;
	case USB_REQ_SET_FEATURE:
		if (setup->bRequestType == Dev_Request) {
			ret_val = 0;
			switch (w_value) {
			case USB_DEVICE_REMOTE_WAKEUP:
				break;
			case USB_DEVICE_B_HNP_ENABLE:
				dum->gadget.b_hnp_enable = 1;
				break;
			case USB_DEVICE_A_HNP_SUPPORT:
				dum->gadget.a_hnp_support = 1;
				break;
			case USB_DEVICE_A_ALT_HNP_SUPPORT:
				dum->gadget.a_alt_hnp_support = 1;
				break;
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
			case USB_DEVICE_U1_ENABLE:
				if (dummy_hcd_to_hcd(dum_hcd)->speed ==
				    HCD_USB3)
					w_value = USB_DEV_STAT_U1_ENABLED;
				else
					ret_val = -EOPNOTSUPP;
				break;
			case USB_DEVICE_U2_ENABLE:
				if (dummy_hcd_to_hcd(dum_hcd)->speed ==
				    HCD_USB3)
					w_value = USB_DEV_STAT_U2_ENABLED;
				else
					ret_val = -EOPNOTSUPP;
				break;
			case USB_DEVICE_LTM_ENABLE:
				if (dummy_hcd_to_hcd(dum_hcd)->speed ==
				    HCD_USB3)
					w_value = USB_DEV_STAT_LTM_ENABLED;
				else
					ret_val = -EOPNOTSUPP;
				break;
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
			default:
				ret_val = -EOPNOTSUPP;
			}
			if (ret_val == 0) {
				dum->devstatus |= (1 << w_value);
				*status = 0;
			}
		} else if (setup->bRequestType == Ep_Request) {
			/* endpoint halt */
			ep2 = find_endpoint(dum, w_index);
			if (!ep2 || ep2->ep.name == ep0name) {
				ret_val = -EOPNOTSUPP;
				break;
			}
			ep2->halted = 1;
			ret_val = 0;
			*status = 0;
		}
		break;
	case USB_REQ_CLEAR_FEATURE:
		if (setup->bRequestType == Dev_Request) {
			ret_val = 0;
			switch (w_value) {
			case USB_DEVICE_REMOTE_WAKEUP:
				w_value = USB_DEVICE_REMOTE_WAKEUP;
				break;
1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697
			case USB_DEVICE_U1_ENABLE:
				if (dummy_hcd_to_hcd(dum_hcd)->speed ==
				    HCD_USB3)
					w_value = USB_DEV_STAT_U1_ENABLED;
				else
					ret_val = -EOPNOTSUPP;
				break;
			case USB_DEVICE_U2_ENABLE:
				if (dummy_hcd_to_hcd(dum_hcd)->speed ==
				    HCD_USB3)
					w_value = USB_DEV_STAT_U2_ENABLED;
				else
					ret_val = -EOPNOTSUPP;
				break;
			case USB_DEVICE_LTM_ENABLE:
				if (dummy_hcd_to_hcd(dum_hcd)->speed ==
				    HCD_USB3)
					w_value = USB_DEV_STAT_LTM_ENABLED;
				else
					ret_val = -EOPNOTSUPP;
				break;
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755
			default:
				ret_val = -EOPNOTSUPP;
				break;
			}
			if (ret_val == 0) {
				dum->devstatus &= ~(1 << w_value);
				*status = 0;
			}
		} else if (setup->bRequestType == Ep_Request) {
			/* endpoint halt */
			ep2 = find_endpoint(dum, w_index);
			if (!ep2) {
				ret_val = -EOPNOTSUPP;
				break;
			}
			if (!ep2->wedged)
				ep2->halted = 0;
			ret_val = 0;
			*status = 0;
		}
		break;
	case USB_REQ_GET_STATUS:
		if (setup->bRequestType == Dev_InRequest
				|| setup->bRequestType == Intf_InRequest
				|| setup->bRequestType == Ep_InRequest) {
			char *buf;
			/*
			 * device: remote wakeup, selfpowered
			 * interface: nothing
			 * endpoint: halt
			 */
			buf = (char *)urb->transfer_buffer;
			if (urb->transfer_buffer_length > 0) {
				if (setup->bRequestType == Ep_InRequest) {
					ep2 = find_endpoint(dum, w_index);
					if (!ep2) {
						ret_val = -EOPNOTSUPP;
						break;
					}
					buf[0] = ep2->halted;
				} else if (setup->bRequestType ==
					   Dev_InRequest) {
					buf[0] = (u8)dum->devstatus;
				} else
					buf[0] = 0;
			}
			if (urb->transfer_buffer_length > 1)
				buf[1] = 0;
			urb->actual_length = min_t(u32, 2,
				urb->transfer_buffer_length);
			ret_val = 0;
			*status = 0;
		}
		break;
	}
	return ret_val;
}

Linus Torvalds's avatar
Linus Torvalds committed
1756 1757 1758
/* drive both sides of the transfers; looks like irq handlers to
 * both drivers except the callbacks aren't in_irq().
 */
1759
static void dummy_timer(unsigned long _dum_hcd)
Linus Torvalds's avatar
Linus Torvalds committed
1760
{
1761 1762
	struct dummy_hcd	*dum_hcd = (struct dummy_hcd *) _dum_hcd;
	struct dummy		*dum = dum_hcd->dum;
Linus Torvalds's avatar
Linus Torvalds committed
1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
	struct urbp		*urbp, *tmp;
	unsigned long		flags;
	int			limit, total;
	int			i;

	/* simplistic model for one frame's bandwidth */
	switch (dum->gadget.speed) {
	case USB_SPEED_LOW:
		total = 8/*bytes*/ * 12/*packets*/;
		break;
	case USB_SPEED_FULL:
		total = 64/*bytes*/ * 19/*packets*/;
		break;
	case USB_SPEED_HIGH:
		total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/;
		break;
1779 1780 1781 1782
	case USB_SPEED_SUPER:
		/* Bus speed is 500000 bytes/ms, so use a little less */
		total = 490000;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
1783
	default:
1784
		dev_err(dummy_dev(dum_hcd), "bogus device speed\n");
Linus Torvalds's avatar
Linus Torvalds committed
1785 1786 1787 1788 1789 1790
		return;
	}

	/* FIXME if HZ != 1000 this will probably misbehave ... */

	/* look at each urb queued by the host side driver */
1791
	spin_lock_irqsave(&dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1792

1793 1794
	if (!dum_hcd->udev) {
		dev_err(dummy_dev(dum_hcd),
Linus Torvalds's avatar
Linus Torvalds committed
1795
				"timer fired with no URBs pending?\n");
1796
		spin_unlock_irqrestore(&dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1797 1798
		return;
	}
1799
	dum_hcd->next_frame_urbp = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1800 1801

	for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1802
		if (!ep_info[i].name)
Linus Torvalds's avatar
Linus Torvalds committed
1803
			break;
1804
		dum->ep[i].already_seen = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1805 1806 1807
	}

restart:
1808
	list_for_each_entry_safe(urbp, tmp, &dum_hcd->urbp_list, urbp_list) {
Linus Torvalds's avatar
Linus Torvalds committed
1809 1810 1811 1812 1813
		struct urb		*urb;
		struct dummy_request	*req;
		u8			address;
		struct dummy_ep		*ep = NULL;
		int			type;
1814
		int			status = -EINPROGRESS;
Linus Torvalds's avatar
Linus Torvalds committed
1815

1816 1817 1818 1819
		/* stop when we reach URBs queued after the timer interrupt */
		if (urbp == dum_hcd->next_frame_urbp)
			break;

Linus Torvalds's avatar
Linus Torvalds committed
1820
		urb = urbp->urb;
Alan Stern's avatar
Alan Stern committed
1821
		if (urb->unlinked)
Linus Torvalds's avatar
Linus Torvalds committed
1822
			goto return_urb;
1823
		else if (dum_hcd->rh_state != DUMMY_RH_RUNNING)
1824
			continue;
1825
		type = usb_pipetype(urb->pipe);
Linus Torvalds's avatar
Linus Torvalds committed
1826 1827 1828 1829 1830 1831 1832 1833 1834 1835

		/* used up this frame's non-periodic bandwidth?
		 * FIXME there's infinite bandwidth for control and
		 * periodic transfers ... unrealistic.
		 */
		if (total <= 0 && type == PIPE_BULK)
			continue;

		/* find the gadget's ep for this request (if configured) */
		address = usb_pipeendpoint (urb->pipe);
1836
		if (usb_pipein(urb->pipe))
Linus Torvalds's avatar
Linus Torvalds committed
1837 1838 1839 1840
			address |= USB_DIR_IN;
		ep = find_endpoint(dum, address);
		if (!ep) {
			/* set_configuration() disagreement */
1841
			dev_dbg(dummy_dev(dum_hcd),
Linus Torvalds's avatar
Linus Torvalds committed
1842 1843
				"no ep configured for urb %p\n",
				urb);
1844
			status = -EPROTO;
Linus Torvalds's avatar
Linus Torvalds committed
1845 1846 1847 1848 1849 1850
			goto return_urb;
		}

		if (ep->already_seen)
			continue;
		ep->already_seen = 1;
1851
		if (ep == &dum->ep[0] && urb->error_count) {
Linus Torvalds's avatar
Linus Torvalds committed
1852 1853 1854 1855 1856
			ep->setup_stage = 1;	/* a new urb */
			urb->error_count = 0;
		}
		if (ep->halted && !ep->setup_stage) {
			/* NOTE: must not be iso! */
1857
			dev_dbg(dummy_dev(dum_hcd), "ep %s halted, urb %p\n",
Linus Torvalds's avatar
Linus Torvalds committed
1858
					ep->ep.name, urb);
1859
			status = -EPIPE;
Linus Torvalds's avatar
Linus Torvalds committed
1860 1861 1862 1863 1864
			goto return_urb;
		}
		/* FIXME make sure both ends agree on maxpacket */

		/* handle control requests */
1865
		if (ep == &dum->ep[0] && ep->setup_stage) {
Linus Torvalds's avatar
Linus Torvalds committed
1866 1867 1868
			struct usb_ctrlrequest		setup;
			int				value = 1;

1869
			setup = *(struct usb_ctrlrequest *) urb->setup_packet;
Linus Torvalds's avatar
Linus Torvalds committed
1870
			/* paranoia, in case of stale queued data */
1871 1872
			list_for_each_entry(req, &ep->queue, queue) {
				list_del_init(&req->queue);
Linus Torvalds's avatar
Linus Torvalds committed
1873
				req->req.status = -EOVERFLOW;
1874
				dev_dbg(udc_dev(dum), "stale req = %p\n",
Linus Torvalds's avatar
Linus Torvalds committed
1875 1876
						req);

1877
				spin_unlock(&dum->lock);
1878
				usb_gadget_giveback_request(&ep->ep, &req->req);
1879
				spin_lock(&dum->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891
				ep->already_seen = 0;
				goto restart;
			}

			/* gadget driver never sees set_address or operations
			 * on standard feature flags.  some hardware doesn't
			 * even expose them.
			 */
			ep->last_io = jiffies;
			ep->setup_stage = 0;
			ep->halted = 0;

1892
			value = handle_control_request(dum_hcd, urb, &setup,
1893
						       &status);
Linus Torvalds's avatar
Linus Torvalds committed
1894 1895 1896 1897 1898

			/* gadget driver handles all other requests.  block
			 * until setup() returns; no reentrancy issues etc.
			 */
			if (value > 0) {
1899
				++dum->callback_usage;
1900 1901
				spin_unlock(&dum->lock);
				value = dum->driver->setup(&dum->gadget,
Linus Torvalds's avatar
Linus Torvalds committed
1902
						&setup);
1903
				spin_lock(&dum->lock);
1904
				--dum->callback_usage;
Linus Torvalds's avatar
Linus Torvalds committed
1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915

				if (value >= 0) {
					/* no delays (max 64KB data stage) */
					limit = 64*1024;
					goto treat_control_like_bulk;
				}
				/* error, see below */
			}

			if (value < 0) {
				if (value != -EOPNOTSUPP)
1916
					dev_dbg(udc_dev(dum),
Linus Torvalds's avatar
Linus Torvalds committed
1917 1918
						"setup --> %d\n",
						value);
1919
				status = -EPIPE;
Linus Torvalds's avatar
Linus Torvalds committed
1920 1921 1922 1923 1924 1925 1926 1927
				urb->actual_length = 0;
			}

			goto return_urb;
		}

		/* non-control requests */
		limit = total;
1928
		switch (usb_pipetype(urb->pipe)) {
Linus Torvalds's avatar
Linus Torvalds committed
1929 1930 1931 1932 1933 1934
		case PIPE_ISOCHRONOUS:
			/* FIXME is it urb->interval since the last xfer?
			 * use urb->iso_frame_desc[i].
			 * complete whether or not ep has requests queued.
			 * report random errors, to debug drivers.
			 */
1935
			limit = max(limit, periodic_bytes(dum, ep));
1936
			status = -ENOSYS;
Linus Torvalds's avatar
Linus Torvalds committed
1937 1938 1939 1940 1941 1942
			break;

		case PIPE_INTERRUPT:
			/* FIXME is it urb->interval since the last xfer?
			 * this almost certainly polls too fast.
			 */
1943
			limit = max(limit, periodic_bytes(dum, ep));
Linus Torvalds's avatar
Linus Torvalds committed
1944 1945 1946
			/* FALLTHROUGH */

		default:
1947
treat_control_like_bulk:
Linus Torvalds's avatar
Linus Torvalds committed
1948
			ep->last_io = jiffies;
1949
			total -= transfer(dum_hcd, urb, ep, limit, &status);
Linus Torvalds's avatar
Linus Torvalds committed
1950 1951 1952 1953
			break;
		}

		/* incomplete transfer? */
1954
		if (status == -EINPROGRESS)
Linus Torvalds's avatar
Linus Torvalds committed
1955 1956 1957
			continue;

return_urb:
1958 1959
		list_del(&urbp->urbp_list);
		kfree(urbp);
Linus Torvalds's avatar
Linus Torvalds committed
1960 1961 1962
		if (ep)
			ep->already_seen = ep->setup_stage = 0;

1963
		usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd), urb);
1964
		spin_unlock(&dum->lock);
1965
		usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd), urb, status);
1966
		spin_lock(&dum->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1967 1968 1969 1970

		goto restart;
	}

1971 1972 1973 1974
	if (list_empty(&dum_hcd->urbp_list)) {
		usb_put_dev(dum_hcd->udev);
		dum_hcd->udev = NULL;
	} else if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
1975
		/* want a 1 msec delay here */
1976
		mod_timer(&dum_hcd->timer, jiffies + msecs_to_jiffies(1));
Linus Torvalds's avatar
Linus Torvalds committed
1977 1978
	}

1979
	spin_unlock_irqrestore(&dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1980 1981 1982 1983 1984
}

/*-------------------------------------------------------------------------*/

#define PORT_C_MASK \
1985 1986 1987 1988 1989
	((USB_PORT_STAT_C_CONNECTION \
	| USB_PORT_STAT_C_ENABLE \
	| USB_PORT_STAT_C_SUSPEND \
	| USB_PORT_STAT_C_OVERCURRENT \
	| USB_PORT_STAT_C_RESET) << 16)
Linus Torvalds's avatar
Linus Torvalds committed
1990

1991
static int dummy_hub_status(struct usb_hcd *hcd, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
1992
{
1993
	struct dummy_hcd	*dum_hcd;
Linus Torvalds's avatar
Linus Torvalds committed
1994
	unsigned long		flags;
1995
	int			retval = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1996

1997
	dum_hcd = hcd_to_dummy_hcd(hcd);
Linus Torvalds's avatar
Linus Torvalds committed
1998

1999
	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2000
	if (!HCD_HW_ACCESSIBLE(hcd))
2001
		goto done;
2002

2003 2004 2005 2006
	if (dum_hcd->resuming && time_after_eq(jiffies, dum_hcd->re_timeout)) {
		dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
		dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
		set_link_state(dum_hcd);
2007 2008
	}

2009
	if ((dum_hcd->port_status & PORT_C_MASK) != 0) {
Linus Torvalds's avatar
Linus Torvalds committed
2010
		*buf = (1 << 1);
2011 2012
		dev_dbg(dummy_dev(dum_hcd), "port status 0x%08x has changes\n",
				dum_hcd->port_status);
Linus Torvalds's avatar
Linus Torvalds committed
2013
		retval = 1;
2014
		if (dum_hcd->rh_state == DUMMY_RH_SUSPENDED)
2015
			usb_hcd_resume_root_hub(hcd);
Linus Torvalds's avatar
Linus Torvalds committed
2016
	}
2017
done:
2018
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
2019 2020 2021
	return retval;
}

2022
/* usb 3.0 root hub device descriptor */
2023
static struct {
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042
	struct usb_bos_descriptor bos;
	struct usb_ss_cap_descriptor ss_cap;
} __packed usb3_bos_desc = {

	.bos = {
		.bLength		= USB_DT_BOS_SIZE,
		.bDescriptorType	= USB_DT_BOS,
		.wTotalLength		= cpu_to_le16(sizeof(usb3_bos_desc)),
		.bNumDeviceCaps		= 1,
	},
	.ss_cap = {
		.bLength		= USB_DT_USB_SS_CAP_SIZE,
		.bDescriptorType	= USB_DT_DEVICE_CAPABILITY,
		.bDevCapabilityType	= USB_SS_CAP_TYPE,
		.wSpeedSupported	= cpu_to_le16(USB_5GBPS_OPERATION),
		.bFunctionalitySupport	= ilog2(USB_5GBPS_OPERATION),
	},
};

2043 2044 2045 2046
static inline void
ss_hub_descriptor(struct usb_hub_descriptor *desc)
{
	memset(desc, 0, sizeof *desc);
2047
	desc->bDescriptorType = USB_DT_SS_HUB;
2048
	desc->bDescLength = 12;
2049 2050 2051
	desc->wHubCharacteristics = cpu_to_le16(
			HUB_CHAR_INDV_PORT_LPSM |
			HUB_CHAR_COMMON_OCPM);
2052 2053
	desc->bNbrPorts = 1;
	desc->u.ss.bHubHdrDecLat = 0x04; /* Worst case: 0.4 micro sec*/
2054
	desc->u.ss.DeviceRemovable = 0;
2055 2056
}

2057
static inline void hub_descriptor(struct usb_hub_descriptor *desc)
Linus Torvalds's avatar
Linus Torvalds committed
2058
{
2059
	memset(desc, 0, sizeof *desc);
2060
	desc->bDescriptorType = USB_DT_HUB;
Linus Torvalds's avatar
Linus Torvalds committed
2061
	desc->bDescLength = 9;
2062 2063 2064
	desc->wHubCharacteristics = cpu_to_le16(
			HUB_CHAR_INDV_PORT_LPSM |
			HUB_CHAR_COMMON_OCPM);
Linus Torvalds's avatar
Linus Torvalds committed
2065
	desc->bNbrPorts = 1;
2066 2067
	desc->u.hs.DeviceRemovable[0] = 0;
	desc->u.hs.DeviceRemovable[1] = 0xff;	/* PortPwrCtrlMask */
Linus Torvalds's avatar
Linus Torvalds committed
2068 2069
}

2070
static int dummy_hub_control(
Linus Torvalds's avatar
Linus Torvalds committed
2071 2072 2073 2074 2075 2076 2077
	struct usb_hcd	*hcd,
	u16		typeReq,
	u16		wValue,
	u16		wIndex,
	char		*buf,
	u16		wLength
) {
2078
	struct dummy_hcd *dum_hcd;
Linus Torvalds's avatar
Linus Torvalds committed
2079 2080 2081
	int		retval = 0;
	unsigned long	flags;

2082
	if (!HCD_HW_ACCESSIBLE(hcd))
2083 2084
		return -ETIMEDOUT;

2085 2086 2087
	dum_hcd = hcd_to_dummy_hcd(hcd);

	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
2088 2089 2090 2091 2092 2093
	switch (typeReq) {
	case ClearHubFeature:
		break;
	case ClearPortFeature:
		switch (wValue) {
		case USB_PORT_FEAT_SUSPEND:
2094 2095 2096 2097 2098 2099
			if (hcd->speed == HCD_USB3) {
				dev_dbg(dummy_dev(dum_hcd),
					 "USB_PORT_FEAT_SUSPEND req not "
					 "supported for USB 3.0 roothub\n");
				goto error;
			}
2100
			if (dum_hcd->port_status & USB_PORT_STAT_SUSPEND) {
Linus Torvalds's avatar
Linus Torvalds committed
2101
				/* 20msec resume signaling */
2102 2103
				dum_hcd->resuming = 1;
				dum_hcd->re_timeout = jiffies +
2104
						msecs_to_jiffies(20);
Linus Torvalds's avatar
Linus Torvalds committed
2105 2106 2107
			}
			break;
		case USB_PORT_FEAT_POWER:
2108 2109 2110 2111 2112 2113 2114 2115 2116
			if (hcd->speed == HCD_USB3) {
				if (dum_hcd->port_status & USB_PORT_STAT_POWER)
					dev_dbg(dummy_dev(dum_hcd),
						"power-off\n");
			} else
				if (dum_hcd->port_status &
							USB_SS_PORT_STAT_POWER)
					dev_dbg(dummy_dev(dum_hcd),
						"power-off\n");
2117
			/* FALLS THROUGH */
Linus Torvalds's avatar
Linus Torvalds committed
2118
		default:
2119 2120
			dum_hcd->port_status &= ~(1 << wValue);
			set_link_state(dum_hcd);
Linus Torvalds's avatar
Linus Torvalds committed
2121 2122 2123
		}
		break;
	case GetHubDescriptor:
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
		if (hcd->speed == HCD_USB3 &&
				(wLength < USB_DT_SS_HUB_SIZE ||
				 wValue != (USB_DT_SS_HUB << 8))) {
			dev_dbg(dummy_dev(dum_hcd),
				"Wrong hub descriptor type for "
				"USB 3.0 roothub.\n");
			goto error;
		}
		if (hcd->speed == HCD_USB3)
			ss_hub_descriptor((struct usb_hub_descriptor *) buf);
		else
			hub_descriptor((struct usb_hub_descriptor *) buf);
Linus Torvalds's avatar
Linus Torvalds committed
2136
		break;
2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148

	case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
		if (hcd->speed != HCD_USB3)
			goto error;

		if ((wValue >> 8) != USB_DT_BOS)
			goto error;

		memcpy(buf, &usb3_bos_desc, sizeof(usb3_bos_desc));
		retval = sizeof(usb3_bos_desc);
		break;

Linus Torvalds's avatar
Linus Torvalds committed
2149
	case GetHubStatus:
2150
		*(__le32 *) buf = cpu_to_le32(0);
Linus Torvalds's avatar
Linus Torvalds committed
2151 2152 2153 2154 2155 2156 2157 2158
		break;
	case GetPortStatus:
		if (wIndex != 1)
			retval = -EPIPE;

		/* whoever resets or resumes must GetPortStatus to
		 * complete it!!
		 */
2159 2160 2161 2162
		if (dum_hcd->resuming &&
				time_after_eq(jiffies, dum_hcd->re_timeout)) {
			dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
			dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
Linus Torvalds's avatar
Linus Torvalds committed
2163
		}
2164 2165 2166 2167 2168 2169
		if ((dum_hcd->port_status & USB_PORT_STAT_RESET) != 0 &&
				time_after_eq(jiffies, dum_hcd->re_timeout)) {
			dum_hcd->port_status |= (USB_PORT_STAT_C_RESET << 16);
			dum_hcd->port_status &= ~USB_PORT_STAT_RESET;
			if (dum_hcd->dum->pullup) {
				dum_hcd->port_status |= USB_PORT_STAT_ENABLE;
2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187

				if (hcd->speed < HCD_USB3) {
					switch (dum_hcd->dum->gadget.speed) {
					case USB_SPEED_HIGH:
						dum_hcd->port_status |=
						      USB_PORT_STAT_HIGH_SPEED;
						break;
					case USB_SPEED_LOW:
						dum_hcd->dum->gadget.ep0->
							maxpacket = 8;
						dum_hcd->port_status |=
							USB_PORT_STAT_LOW_SPEED;
						break;
					default:
						dum_hcd->dum->gadget.speed =
							USB_SPEED_FULL;
						break;
					}
Linus Torvalds's avatar
Linus Torvalds committed
2188 2189 2190
				}
			}
		}
2191
		set_link_state(dum_hcd);
2192 2193
		((__le16 *) buf)[0] = cpu_to_le16(dum_hcd->port_status);
		((__le16 *) buf)[1] = cpu_to_le16(dum_hcd->port_status >> 16);
Linus Torvalds's avatar
Linus Torvalds committed
2194 2195 2196 2197 2198 2199
		break;
	case SetHubFeature:
		retval = -EPIPE;
		break;
	case SetPortFeature:
		switch (wValue) {
2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
		case USB_PORT_FEAT_LINK_STATE:
			if (hcd->speed != HCD_USB3) {
				dev_dbg(dummy_dev(dum_hcd),
					 "USB_PORT_FEAT_LINK_STATE req not "
					 "supported for USB 2.0 roothub\n");
				goto error;
			}
			/*
			 * Since this is dummy we don't have an actual link so
			 * there is nothing to do for the SET_LINK_STATE cmd
			 */
			break;
		case USB_PORT_FEAT_U1_TIMEOUT:
		case USB_PORT_FEAT_U2_TIMEOUT:
			/* TODO: add suspend/resume support! */
			if (hcd->speed != HCD_USB3) {
				dev_dbg(dummy_dev(dum_hcd),
					 "USB_PORT_FEAT_U1/2_TIMEOUT req not "
					 "supported for USB 2.0 roothub\n");
				goto error;
			}
			break;
Linus Torvalds's avatar
Linus Torvalds committed
2222
		case USB_PORT_FEAT_SUSPEND:
2223 2224 2225 2226 2227 2228 2229
			/* Applicable only for USB2.0 hub */
			if (hcd->speed == HCD_USB3) {
				dev_dbg(dummy_dev(dum_hcd),
					 "USB_PORT_FEAT_SUSPEND req not "
					 "supported for USB 3.0 roothub\n");
				goto error;
			}
2230 2231
			if (dum_hcd->active) {
				dum_hcd->port_status |= USB_PORT_STAT_SUSPEND;
2232 2233 2234 2235

				/* HNP would happen here; for now we
				 * assume b_bus_req is always true.
				 */
2236
				set_link_state(dum_hcd);
2237
				if (((1 << USB_DEVICE_B_HNP_ENABLE)
2238 2239
						& dum_hcd->dum->devstatus) != 0)
					dev_dbg(dummy_dev(dum_hcd),
2240
							"no HNP yet!\n");
Linus Torvalds's avatar
Linus Torvalds committed
2241 2242
			}
			break;
2243
		case USB_PORT_FEAT_POWER:
2244 2245 2246 2247
			if (hcd->speed == HCD_USB3)
				dum_hcd->port_status |= USB_SS_PORT_STAT_POWER;
			else
				dum_hcd->port_status |= USB_PORT_STAT_POWER;
2248
			set_link_state(dum_hcd);
2249
			break;
2250 2251 2252 2253 2254 2255 2256 2257 2258
		case USB_PORT_FEAT_BH_PORT_RESET:
			/* Applicable only for USB3.0 hub */
			if (hcd->speed != HCD_USB3) {
				dev_dbg(dummy_dev(dum_hcd),
					 "USB_PORT_FEAT_BH_PORT_RESET req not "
					 "supported for USB 2.0 roothub\n");
				goto error;
			}
			/* FALLS THROUGH */
Linus Torvalds's avatar
Linus Torvalds committed
2259
		case USB_PORT_FEAT_RESET:
2260
			/* if it's already enabled, disable */
2261 2262 2263 2264 2265 2266 2267 2268
			if (hcd->speed == HCD_USB3) {
				dum_hcd->port_status = 0;
				dum_hcd->port_status =
					(USB_SS_PORT_STAT_POWER |
					 USB_PORT_STAT_CONNECTION |
					 USB_PORT_STAT_RESET);
			} else
				dum_hcd->port_status &= ~(USB_PORT_STAT_ENABLE
2269 2270
					| USB_PORT_STAT_LOW_SPEED
					| USB_PORT_STAT_HIGH_SPEED);
2271 2272 2273 2274 2275 2276
			/*
			 * We want to reset device status. All but the
			 * Self powered feature
			 */
			dum_hcd->dum->devstatus &=
				(1 << USB_DEVICE_SELF_POWERED);
2277 2278 2279 2280
			/*
			 * FIXME USB3.0: what is the correct reset signaling
			 * interval? Is it still 50msec as for HS?
			 */
2281
			dum_hcd->re_timeout = jiffies + msecs_to_jiffies(50);
2282
			/* FALLS THROUGH */
Linus Torvalds's avatar
Linus Torvalds committed
2283
		default:
2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
			if (hcd->speed == HCD_USB3) {
				if ((dum_hcd->port_status &
				     USB_SS_PORT_STAT_POWER) != 0) {
					dum_hcd->port_status |= (1 << wValue);
					set_link_state(dum_hcd);
				}
			} else
				if ((dum_hcd->port_status &
				     USB_PORT_STAT_POWER) != 0) {
					dum_hcd->port_status |= (1 << wValue);
					set_link_state(dum_hcd);
				}
		}
		break;
	case GetPortErrorCount:
		if (hcd->speed != HCD_USB3) {
			dev_dbg(dummy_dev(dum_hcd),
				 "GetPortErrorCount req not "
				 "supported for USB 2.0 roothub\n");
			goto error;
		}
		/* We'll always return 0 since this is a dummy hub */
		*(__le32 *) buf = cpu_to_le32(0);
		break;
	case SetHubDepth:
		if (hcd->speed != HCD_USB3) {
			dev_dbg(dummy_dev(dum_hcd),
				 "SetHubDepth req not supported for "
				 "USB 2.0 roothub\n");
			goto error;
Linus Torvalds's avatar
Linus Torvalds committed
2314 2315 2316
		}
		break;
	default:
2317
		dev_dbg(dummy_dev(dum_hcd),
Linus Torvalds's avatar
Linus Torvalds committed
2318 2319
			"hub control req%04x v%04x i%04x l%d\n",
			typeReq, wValue, wIndex, wLength);
2320
error:
Linus Torvalds's avatar
Linus Torvalds committed
2321 2322 2323
		/* "protocol stall" on error */
		retval = -EPIPE;
	}
2324
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2325

2326
	if ((dum_hcd->port_status & PORT_C_MASK) != 0)
2327
		usb_hcd_poll_rh_status(hcd);
Linus Torvalds's avatar
Linus Torvalds committed
2328 2329 2330
	return retval;
}

2331
static int dummy_bus_suspend(struct usb_hcd *hcd)
2332
{
2333
	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2334

2335
	dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
2336

2337 2338 2339
	spin_lock_irq(&dum_hcd->dum->lock);
	dum_hcd->rh_state = DUMMY_RH_SUSPENDED;
	set_link_state(dum_hcd);
2340
	hcd->state = HC_STATE_SUSPENDED;
2341
	spin_unlock_irq(&dum_hcd->dum->lock);
2342 2343 2344
	return 0;
}

2345
static int dummy_bus_resume(struct usb_hcd *hcd)
2346
{
2347
	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2348 2349
	int rc = 0;

2350
	dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
2351

2352
	spin_lock_irq(&dum_hcd->dum->lock);
2353
	if (!HCD_HW_ACCESSIBLE(hcd)) {
2354
		rc = -ESHUTDOWN;
2355
	} else {
2356 2357 2358 2359
		dum_hcd->rh_state = DUMMY_RH_RUNNING;
		set_link_state(dum_hcd);
		if (!list_empty(&dum_hcd->urbp_list))
			mod_timer(&dum_hcd->timer, jiffies);
2360 2361
		hcd->state = HC_STATE_RUNNING;
	}
2362
	spin_unlock_irq(&dum_hcd->dum->lock);
2363
	return rc;
2364
}
Linus Torvalds's avatar
Linus Torvalds committed
2365 2366 2367

/*-------------------------------------------------------------------------*/

2368
static inline ssize_t show_urb(char *buf, size_t size, struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
2369
{
2370
	int ep = usb_pipeendpoint(urb->pipe);
Linus Torvalds's avatar
Linus Torvalds committed
2371

2372
	return snprintf(buf, size,
Linus Torvalds's avatar
Linus Torvalds committed
2373 2374 2375
		"urb/%p %s ep%d%s%s len %d/%d\n",
		urb,
		({ char *s;
2376 2377
		switch (urb->dev->speed) {
		case USB_SPEED_LOW:
2378 2379
			s = "ls";
			break;
2380
		case USB_SPEED_FULL:
2381 2382
			s = "fs";
			break;
2383
		case USB_SPEED_HIGH:
2384 2385
			s = "hs";
			break;
2386
		case USB_SPEED_SUPER:
2387 2388
			s = "ss";
			break;
2389
		default:
2390 2391
			s = "?";
			break;
2392
		 } s; }),
2393
		ep, ep ? (usb_pipein(urb->pipe) ? "in" : "out") : "",
Linus Torvalds's avatar
Linus Torvalds committed
2394
		({ char *s; \
2395 2396
		switch (usb_pipetype(urb->pipe)) { \
		case PIPE_CONTROL: \
2397 2398
			s = ""; \
			break; \
2399
		case PIPE_BULK: \
2400 2401
			s = "-bulk"; \
			break; \
2402
		case PIPE_INTERRUPT: \
2403 2404
			s = "-int"; \
			break; \
2405
		default: \
2406 2407
			s = "-iso"; \
			break; \
2408
		} s; }),
Linus Torvalds's avatar
Linus Torvalds committed
2409 2410 2411
		urb->actual_length, urb->transfer_buffer_length);
}

2412
static ssize_t urbs_show(struct device *dev, struct device_attribute *attr,
2413
		char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
2414
{
2415
	struct usb_hcd		*hcd = dev_get_drvdata(dev);
2416
	struct dummy_hcd	*dum_hcd = hcd_to_dummy_hcd(hcd);
Linus Torvalds's avatar
Linus Torvalds committed
2417 2418 2419 2420
	struct urbp		*urbp;
	size_t			size = 0;
	unsigned long		flags;

2421 2422
	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
	list_for_each_entry(urbp, &dum_hcd->urbp_list, urbp_list) {
Linus Torvalds's avatar
Linus Torvalds committed
2423 2424
		size_t		temp;

2425
		temp = show_urb(buf, PAGE_SIZE - size, urbp->urb);
Linus Torvalds's avatar
Linus Torvalds committed
2426 2427 2428
		buf += temp;
		size += temp;
	}
2429
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
2430 2431 2432

	return size;
}
2433
static DEVICE_ATTR_RO(urbs);
Linus Torvalds's avatar
Linus Torvalds committed
2434

2435 2436 2437 2438 2439 2440
static int dummy_start_ss(struct dummy_hcd *dum_hcd)
{
	init_timer(&dum_hcd->timer);
	dum_hcd->timer.function = dummy_timer;
	dum_hcd->timer.data = (unsigned long)dum_hcd;
	dum_hcd->rh_state = DUMMY_RH_RUNNING;
2441
	dum_hcd->stream_en_ep = 0;
2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454
	INIT_LIST_HEAD(&dum_hcd->urbp_list);
	dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET;
	dummy_hcd_to_hcd(dum_hcd)->state = HC_STATE_RUNNING;
	dummy_hcd_to_hcd(dum_hcd)->uses_new_polling = 1;
#ifdef CONFIG_USB_OTG
	dummy_hcd_to_hcd(dum_hcd)->self.otg_port = 1;
#endif
	return 0;

	/* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
	return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
}

2455
static int dummy_start(struct usb_hcd *hcd)
Linus Torvalds's avatar
Linus Torvalds committed
2456
{
2457
	struct dummy_hcd	*dum_hcd = hcd_to_dummy_hcd(hcd);
Linus Torvalds's avatar
Linus Torvalds committed
2458 2459 2460 2461 2462 2463

	/*
	 * MASTER side init ... we emulate a root hub that'll only ever
	 * talk to one device (the slave side).  Also appears in sysfs,
	 * just like more familiar pci-based HCDs.
	 */
2464 2465 2466
	if (!usb_hcd_is_primary_hcd(hcd))
		return dummy_start_ss(dum_hcd);

2467 2468 2469 2470 2471
	spin_lock_init(&dum_hcd->dum->lock);
	init_timer(&dum_hcd->timer);
	dum_hcd->timer.function = dummy_timer;
	dum_hcd->timer.data = (unsigned long)dum_hcd;
	dum_hcd->rh_state = DUMMY_RH_RUNNING;
Linus Torvalds's avatar
Linus Torvalds committed
2472

2473
	INIT_LIST_HEAD(&dum_hcd->urbp_list);
Linus Torvalds's avatar
Linus Torvalds committed
2474

2475
	hcd->power_budget = POWER_BUDGET;
Linus Torvalds's avatar
Linus Torvalds committed
2476
	hcd->state = HC_STATE_RUNNING;
2477
	hcd->uses_new_polling = 1;
Linus Torvalds's avatar
Linus Torvalds committed
2478

2479 2480 2481 2482
#ifdef CONFIG_USB_OTG
	hcd->self.otg_port = 1;
#endif

Linus Torvalds's avatar
Linus Torvalds committed
2483
	/* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
2484
	return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
Linus Torvalds's avatar
Linus Torvalds committed
2485 2486
}

2487
static void dummy_stop(struct usb_hcd *hcd)
Linus Torvalds's avatar
Linus Torvalds committed
2488 2489 2490
{
	struct dummy		*dum;

2491
	dum = hcd_to_dummy_hcd(hcd)->dum;
2492 2493
	device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd)), &dev_attr_urbs);
	dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n");
Linus Torvalds's avatar
Linus Torvalds committed
2494 2495 2496 2497
}

/*-------------------------------------------------------------------------*/

2498
static int dummy_h_get_frame(struct usb_hcd *hcd)
Linus Torvalds's avatar
Linus Torvalds committed
2499
{
2500
	return dummy_g_get_frame(NULL);
Linus Torvalds's avatar
Linus Torvalds committed
2501 2502
}

2503 2504
static int dummy_setup(struct usb_hcd *hcd)
{
2505 2506 2507
	struct dummy *dum;

	dum = *((void **)dev_get_platdata(hcd->self.controller));
2508
	hcd->self.sg_tablesize = ~0;
2509
	if (usb_hcd_is_primary_hcd(hcd)) {
2510 2511
		dum->hs_hcd = hcd_to_dummy_hcd(hcd);
		dum->hs_hcd->dum = dum;
2512 2513 2514 2515 2516
		/*
		 * Mark the first roothub as being USB 2.0.
		 * The USB 3.0 roothub will be registered later by
		 * dummy_hcd_probe()
		 */
2517 2518
		hcd->speed = HCD_USB2;
		hcd->self.root_hub->speed = USB_SPEED_HIGH;
2519
	} else {
2520 2521
		dum->ss_hcd = hcd_to_dummy_hcd(hcd);
		dum->ss_hcd->dum = dum;
2522 2523
		hcd->speed = HCD_USB3;
		hcd->self.root_hub->speed = USB_SPEED_SUPER;
2524 2525 2526 2527
	}
	return 0;
}

2528
/* Change a group of bulk endpoints to support multiple stream IDs */
2529
static int dummy_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
2530 2531 2532
	struct usb_host_endpoint **eps, unsigned int num_eps,
	unsigned int num_streams, gfp_t mem_flags)
{
2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572
	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
	unsigned long flags;
	int max_stream;
	int ret_streams = num_streams;
	unsigned int index;
	unsigned int i;

	if (!num_eps)
		return -EINVAL;

	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
	for (i = 0; i < num_eps; i++) {
		index = dummy_get_ep_idx(&eps[i]->desc);
		if ((1 << index) & dum_hcd->stream_en_ep) {
			ret_streams = -EINVAL;
			goto out;
		}
		max_stream = usb_ss_max_streams(&eps[i]->ss_ep_comp);
		if (!max_stream) {
			ret_streams = -EINVAL;
			goto out;
		}
		if (max_stream < ret_streams) {
			dev_dbg(dummy_dev(dum_hcd), "Ep 0x%x only supports %u "
					"stream IDs.\n",
					eps[i]->desc.bEndpointAddress,
					max_stream);
			ret_streams = max_stream;
		}
	}

	for (i = 0; i < num_eps; i++) {
		index = dummy_get_ep_idx(&eps[i]->desc);
		dum_hcd->stream_en_ep |= 1 << index;
		set_max_streams_for_pipe(dum_hcd,
				usb_endpoint_num(&eps[i]->desc), ret_streams);
	}
out:
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
	return ret_streams;
2573 2574 2575
}

/* Reverts a group of bulk endpoints back to not using stream IDs. */
2576
static int dummy_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
2577 2578 2579
	struct usb_host_endpoint **eps, unsigned int num_eps,
	gfp_t mem_flags)
{
2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604
	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
	unsigned long flags;
	int ret;
	unsigned int index;
	unsigned int i;

	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
	for (i = 0; i < num_eps; i++) {
		index = dummy_get_ep_idx(&eps[i]->desc);
		if (!((1 << index) & dum_hcd->stream_en_ep)) {
			ret = -EINVAL;
			goto out;
		}
	}

	for (i = 0; i < num_eps; i++) {
		index = dummy_get_ep_idx(&eps[i]->desc);
		dum_hcd->stream_en_ep &= ~(1 << index);
		set_max_streams_for_pipe(dum_hcd,
				usb_endpoint_num(&eps[i]->desc), 0);
	}
	ret = 0;
out:
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
	return ret;
2605 2606 2607
}

static struct hc_driver dummy_hcd = {
Linus Torvalds's avatar
Linus Torvalds committed
2608 2609
	.description =		(char *) driver_name,
	.product_desc =		"Dummy host controller",
2610
	.hcd_priv_size =	sizeof(struct dummy_hcd),
Linus Torvalds's avatar
Linus Torvalds committed
2611

2612
	.reset =		dummy_setup,
Linus Torvalds's avatar
Linus Torvalds committed
2613 2614 2615
	.start =		dummy_start,
	.stop =			dummy_stop,

2616 2617
	.urb_enqueue =		dummy_urb_enqueue,
	.urb_dequeue =		dummy_urb_dequeue,
Linus Torvalds's avatar
Linus Torvalds committed
2618

2619
	.get_frame_number =	dummy_h_get_frame,
Linus Torvalds's avatar
Linus Torvalds committed
2620

2621 2622
	.hub_status_data =	dummy_hub_status,
	.hub_control =		dummy_hub_control,
2623 2624
	.bus_suspend =		dummy_bus_suspend,
	.bus_resume =		dummy_bus_resume,
2625 2626 2627

	.alloc_streams =	dummy_alloc_streams,
	.free_streams =		dummy_free_streams,
Linus Torvalds's avatar
Linus Torvalds committed
2628 2629
};

2630
static int dummy_hcd_probe(struct platform_device *pdev)
Linus Torvalds's avatar
Linus Torvalds committed
2631
{
2632
	struct dummy		*dum;
2633
	struct usb_hcd		*hs_hcd;
2634
	struct usb_hcd		*ss_hcd;
Linus Torvalds's avatar
Linus Torvalds committed
2635 2636
	int			retval;

2637
	dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
2638
	dum = *((void **)dev_get_platdata(&pdev->dev));
Linus Torvalds's avatar
Linus Torvalds committed
2639

2640 2641 2642
	if (mod_data.is_super_speed)
		dummy_hcd.flags = HCD_USB3 | HCD_SHARED;
	else if (mod_data.is_high_speed)
2643
		dummy_hcd.flags = HCD_USB2;
2644 2645
	else
		dummy_hcd.flags = HCD_USB11;
2646 2647
	hs_hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, dev_name(&pdev->dev));
	if (!hs_hcd)
Linus Torvalds's avatar
Linus Torvalds committed
2648
		return -ENOMEM;
2649
	hs_hcd->has_tt = 1;
Linus Torvalds's avatar
Linus Torvalds committed
2650

2651
	retval = usb_add_hcd(hs_hcd, 0, 0);
2652 2653
	if (retval)
		goto put_usb2_hcd;
2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671

	if (mod_data.is_super_speed) {
		ss_hcd = usb_create_shared_hcd(&dummy_hcd, &pdev->dev,
					dev_name(&pdev->dev), hs_hcd);
		if (!ss_hcd) {
			retval = -ENOMEM;
			goto dealloc_usb2_hcd;
		}

		retval = usb_add_hcd(ss_hcd, 0, 0);
		if (retval)
			goto put_usb3_hcd;
	}
	return 0;

put_usb3_hcd:
	usb_put_hcd(ss_hcd);
dealloc_usb2_hcd:
2672 2673
	usb_remove_hcd(hs_hcd);
put_usb2_hcd:
2674
	usb_put_hcd(hs_hcd);
2675
	dum->hs_hcd = dum->ss_hcd = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
2676 2677 2678
	return retval;
}

2679
static int dummy_hcd_remove(struct platform_device *pdev)
Linus Torvalds's avatar
Linus Torvalds committed
2680
{
2681 2682
	struct dummy		*dum;

2683
	dum = hcd_to_dummy_hcd(platform_get_drvdata(pdev))->dum;
2684 2685 2686 2687 2688 2689

	if (dum->ss_hcd) {
		usb_remove_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
		usb_put_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
	}

2690 2691
	usb_remove_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
	usb_put_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2692

2693 2694
	dum->hs_hcd = NULL;
	dum->ss_hcd = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
2695

2696
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
2697 2698
}

2699
static int dummy_hcd_suspend(struct platform_device *pdev, pm_message_t state)
2700 2701
{
	struct usb_hcd		*hcd;
2702
	struct dummy_hcd	*dum_hcd;
2703
	int			rc = 0;
2704

2705
	dev_dbg(&pdev->dev, "%s\n", __func__);
2706

2707
	hcd = platform_get_drvdata(pdev);
2708 2709
	dum_hcd = hcd_to_dummy_hcd(hcd);
	if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
2710 2711 2712 2713 2714
		dev_warn(&pdev->dev, "Root hub isn't suspended!\n");
		rc = -EBUSY;
	} else
		clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
	return rc;
2715 2716
}

2717
static int dummy_hcd_resume(struct platform_device *pdev)
2718 2719 2720
{
	struct usb_hcd		*hcd;

2721
	dev_dbg(&pdev->dev, "%s\n", __func__);
2722

2723
	hcd = platform_get_drvdata(pdev);
2724
	set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2725
	usb_hcd_poll_rh_status(hcd);
2726 2727 2728
	return 0;
}

2729
static struct platform_driver dummy_hcd_driver = {
2730 2731
	.probe		= dummy_hcd_probe,
	.remove		= dummy_hcd_remove,
2732 2733
	.suspend	= dummy_hcd_suspend,
	.resume		= dummy_hcd_resume,
2734 2735 2736
	.driver		= {
		.name	= (char *) driver_name,
	},
2737
};
Linus Torvalds's avatar
Linus Torvalds committed
2738

2739
/*-------------------------------------------------------------------------*/
2740
#define MAX_NUM_UDC	2
2741 2742
static struct platform_device *the_udc_pdev[MAX_NUM_UDC];
static struct platform_device *the_hcd_pdev[MAX_NUM_UDC];
Linus Torvalds's avatar
Linus Torvalds committed
2743

2744
static int __init init(void)
Linus Torvalds's avatar
Linus Torvalds committed
2745
{
2746
	int	retval = -ENOMEM;
2747
	int	i;
2748
	struct	dummy *dum[MAX_NUM_UDC];
Linus Torvalds's avatar
Linus Torvalds committed
2749

2750
	if (usb_disabled())
Linus Torvalds's avatar
Linus Torvalds committed
2751
		return -ENODEV;
2752

2753 2754 2755
	if (!mod_data.is_high_speed && mod_data.is_super_speed)
		return -EINVAL;

2756
	if (mod_data.num < 1 || mod_data.num > MAX_NUM_UDC) {
2757
		pr_err("Number of emulated UDC must be in range of 1...%d\n",
2758 2759 2760
				MAX_NUM_UDC);
		return -EINVAL;
	}
2761

2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779
	for (i = 0; i < mod_data.num; i++) {
		the_hcd_pdev[i] = platform_device_alloc(driver_name, i);
		if (!the_hcd_pdev[i]) {
			i--;
			while (i >= 0)
				platform_device_put(the_hcd_pdev[i--]);
			return retval;
		}
	}
	for (i = 0; i < mod_data.num; i++) {
		the_udc_pdev[i] = platform_device_alloc(gadget_name, i);
		if (!the_udc_pdev[i]) {
			i--;
			while (i >= 0)
				platform_device_put(the_udc_pdev[i--]);
			goto err_alloc_udc;
		}
	}
2780 2781
	for (i = 0; i < mod_data.num; i++) {
		dum[i] = kzalloc(sizeof(struct dummy), GFP_KERNEL);
2782 2783
		if (!dum[i]) {
			retval = -ENOMEM;
2784
			goto err_add_pdata;
2785
		}
2786 2787 2788 2789 2790 2791 2792 2793 2794
		retval = platform_device_add_data(the_hcd_pdev[i], &dum[i],
				sizeof(void *));
		if (retval)
			goto err_add_pdata;
		retval = platform_device_add_data(the_udc_pdev[i], &dum[i],
				sizeof(void *));
		if (retval)
			goto err_add_pdata;
	}
2795

2796 2797
	retval = platform_driver_register(&dummy_hcd_driver);
	if (retval < 0)
2798
		goto err_add_pdata;
2799
	retval = platform_driver_register(&dummy_udc_driver);
2800 2801 2802
	if (retval < 0)
		goto err_register_udc_driver;

2803 2804 2805 2806 2807 2808 2809 2810 2811
	for (i = 0; i < mod_data.num; i++) {
		retval = platform_device_add(the_hcd_pdev[i]);
		if (retval < 0) {
			i--;
			while (i >= 0)
				platform_device_del(the_hcd_pdev[i--]);
			goto err_add_hcd;
		}
	}
2812 2813 2814 2815 2816 2817 2818 2819 2820 2821
	for (i = 0; i < mod_data.num; i++) {
		if (!dum[i]->hs_hcd ||
				(!dum[i]->ss_hcd && mod_data.is_super_speed)) {
			/*
			 * The hcd was added successfully but its probe
			 * function failed for some reason.
			 */
			retval = -EINVAL;
			goto err_add_udc;
		}
2822
	}
2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842

	for (i = 0; i < mod_data.num; i++) {
		retval = platform_device_add(the_udc_pdev[i]);
		if (retval < 0) {
			i--;
			while (i >= 0)
				platform_device_del(the_udc_pdev[i]);
			goto err_add_udc;
		}
	}

	for (i = 0; i < mod_data.num; i++) {
		if (!platform_get_drvdata(the_udc_pdev[i])) {
			/*
			 * The udc was added successfully but its probe
			 * function failed for some reason.
			 */
			retval = -EINVAL;
			goto err_probe_udc;
		}
2843
	}
2844 2845
	return retval;

2846
err_probe_udc:
2847 2848
	for (i = 0; i < mod_data.num; i++)
		platform_device_del(the_udc_pdev[i]);
2849
err_add_udc:
2850 2851
	for (i = 0; i < mod_data.num; i++)
		platform_device_del(the_hcd_pdev[i]);
2852 2853
err_add_hcd:
	platform_driver_unregister(&dummy_udc_driver);
2854
err_register_udc_driver:
2855
	platform_driver_unregister(&dummy_hcd_driver);
2856 2857 2858
err_add_pdata:
	for (i = 0; i < mod_data.num; i++)
		kfree(dum[i]);
2859 2860
	for (i = 0; i < mod_data.num; i++)
		platform_device_put(the_udc_pdev[i]);
2861
err_alloc_udc:
2862 2863
	for (i = 0; i < mod_data.num; i++)
		platform_device_put(the_hcd_pdev[i]);
Linus Torvalds's avatar
Linus Torvalds committed
2864 2865
	return retval;
}
2866
module_init(init);
Linus Torvalds's avatar
Linus Torvalds committed
2867

2868
static void __exit cleanup(void)
Linus Torvalds's avatar
Linus Torvalds committed
2869
{
2870 2871 2872
	int i;

	for (i = 0; i < mod_data.num; i++) {
2873 2874 2875 2876
		struct dummy *dum;

		dum = *((void **)dev_get_platdata(&the_udc_pdev[i]->dev));

2877 2878
		platform_device_unregister(the_udc_pdev[i]);
		platform_device_unregister(the_hcd_pdev[i]);
2879
		kfree(dum);
2880
	}
2881 2882
	platform_driver_unregister(&dummy_udc_driver);
	platform_driver_unregister(&dummy_hcd_driver);
Linus Torvalds's avatar
Linus Torvalds committed
2883
}
2884
module_exit(cleanup);