dummy_hcd.c 68.4 KB
Newer Older
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
39
#include <linux/usb.h>
40
#include <linux/usb/gadget.h>
41
#include <linux/usb/hcd.h>
42
#include <linux/scatterlist.h>
L
Linus Torvalds 已提交
43 44

#include <asm/byteorder.h>
45
#include <linux/io.h>
L
Linus Torvalds 已提交
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"
L
Linus Torvalds 已提交
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";
L
Linus Torvalds 已提交
56

57
static const char	gadget_name[] = "dummy_udc";
L
Linus Torvalds 已提交
58

59 60 61
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("David Brownell");
MODULE_LICENSE("GPL");
L
Linus Torvalds 已提交
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");
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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)
L
Linus Torvalds 已提交
102
{
103
	return container_of(_ep, struct dummy_ep, ep);
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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";
L
Linus Torvalds 已提交
129

130
static const char *const ep_name[] = {
L
Linus Torvalds 已提交
131 132
	ep0name,				/* everyone has ep0 */

133
	/* act like a pxa250: fifteen fixed function endpoints */
L
Linus Torvalds 已提交
134 135 136 137 138 139 140
	"ep1in-bulk", "ep2out-bulk", "ep3in-iso", "ep4out-iso", "ep5in-int",
	"ep6in-bulk", "ep7out-bulk", "ep8in-iso", "ep9out-iso", "ep10in-int",
	"ep11in-bulk", "ep12out-bulk", "ep13in-iso", "ep14out-iso",
		"ep15in-int",

	/* or like sa1100: two fixed function endpoints */
	"ep1out-bulk", "ep2in-bulk",
141 142 143 144

	/* and now some generic EPs so we have enough in multi config */
	"ep3out", "ep4in", "ep5out", "ep6out", "ep7in", "ep8out", "ep9in",
	"ep10out", "ep11out", "ep12in", "ep13out", "ep14in", "ep15out",
L
Linus Torvalds 已提交
145
};
146
#define DUMMY_ENDPOINTS	ARRAY_SIZE(ep_name)
L
Linus Torvalds 已提交
147

148 149
/*-------------------------------------------------------------------------*/

L
Linus Torvalds 已提交
150 151 152 153 154
#define FIFO_SIZE		64

struct urbp {
	struct urb		*urb;
	struct list_head	urbp_list;
155 156
	struct sg_mapping_iter	miter;
	u32			miter_started;
L
Linus Torvalds 已提交
157 158
};

159 160 161 162 163 164 165

enum dummy_rh_state {
	DUMMY_RH_RESET,
	DUMMY_RH_SUSPENDED,
	DUMMY_RH_RUNNING
};

166 167 168 169 170 171 172 173 174 175
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;
176 177
	u32				stream_en_ep;
	u8				num_stream[30 / 2];
178 179 180 181 182 183

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

L
Linus Torvalds 已提交
184 185 186 187 188 189
struct dummy {
	spinlock_t			lock;

	/*
	 * SLAVE/GADGET side support
	 */
190
	struct dummy_ep			ep[DUMMY_ENDPOINTS];
L
Linus Torvalds 已提交
191 192 193 194
	int				address;
	struct usb_gadget		gadget;
	struct usb_gadget_driver	*driver;
	struct dummy_request		fifo_req;
195
	u8				fifo_buf[FIFO_SIZE];
L
Linus Torvalds 已提交
196
	u16				devstatus;
197
	unsigned			udc_suspended:1;
198
	unsigned			pullup:1;
L
Linus Torvalds 已提交
199 200 201 202

	/*
	 * MASTER/HOST side support
	 */
203
	struct dummy_hcd		*hs_hcd;
204
	struct dummy_hcd		*ss_hcd;
L
Linus Torvalds 已提交
205 206
};

207
static inline struct dummy_hcd *hcd_to_dummy_hcd(struct usb_hcd *hcd)
L
Linus Torvalds 已提交
208
{
209
	return (struct dummy_hcd *) (hcd->hcd_priv);
L
Linus Torvalds 已提交
210 211
}

212
static inline struct usb_hcd *dummy_hcd_to_hcd(struct dummy_hcd *dum)
L
Linus Torvalds 已提交
213 214 215 216
{
	return container_of((void *) dum, struct usb_hcd, hcd_priv);
}

217
static inline struct device *dummy_dev(struct dummy_hcd *dum)
L
Linus Torvalds 已提交
218
{
219
	return dummy_hcd_to_hcd(dum)->self.controller;
L
Linus Torvalds 已提交
220 221
}

222
static inline struct device *udc_dev(struct dummy *dum)
223 224 225 226
{
	return dum->gadget.dev.parent;
}

227
static inline struct dummy *ep_to_dummy(struct dummy_ep *ep)
L
Linus Torvalds 已提交
228
{
229
	return container_of(ep->gadget, struct dummy, gadget);
L
Linus Torvalds 已提交
230 231
}

232
static inline struct dummy_hcd *gadget_to_dummy_hcd(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
233
{
234
	struct dummy *dum = container_of(gadget, struct dummy, gadget);
235 236 237 238
	if (dum->gadget.speed == USB_SPEED_SUPER)
		return dum->ss_hcd;
	else
		return dum->hs_hcd;
L
Linus Torvalds 已提交
239 240
}

241
static inline struct dummy *gadget_dev_to_dummy(struct device *dev)
L
Linus Torvalds 已提交
242
{
243
	return container_of(dev, struct dummy, gadget.dev);
L
Linus Torvalds 已提交
244 245 246 247
}

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

248 249 250
/* SLAVE/GADGET SIDE UTILITY ROUTINES */

/* called with spinlock held */
251
static void nuke(struct dummy *dum, struct dummy_ep *ep)
252
{
253
	while (!list_empty(&ep->queue)) {
254 255
		struct dummy_request	*req;

256 257
		req = list_entry(ep->queue.next, struct dummy_request, queue);
		list_del_init(&req->queue);
258 259
		req->req.status = -ESHUTDOWN;

260
		spin_unlock(&dum->lock);
261
		usb_gadget_giveback_request(&ep->ep, &req->req);
262
		spin_lock(&dum->lock);
263 264 265 266
	}
}

/* caller must hold lock */
267
static void stop_activity(struct dummy *dum)
268 269 270 271 272 273 274 275 276
{
	struct dummy_ep	*ep;

	/* 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 */
277 278
	list_for_each_entry(ep, &dum->gadget.ep_list, ep.ep_list)
		nuke(dum, ep);
279 280 281 282

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

283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
/**
 * 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;
		}
	}
}

351
/* caller must hold lock */
352
static void set_link_state(struct dummy_hcd *dum_hcd)
353
{
354 355 356
	struct dummy *dum = dum_hcd->dum;

	dum_hcd->active = 0;
357 358 359 360 361 362 363 364
	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);
365

366 367 368
	if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0 ||
	     dum_hcd->active)
		dum_hcd->resuming = 0;
369

370
	/* Currently !connected or in reset */
371 372
	if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0 ||
			(dum_hcd->port_status & USB_PORT_STAT_RESET) != 0) {
373 374 375 376 377 378 379
		unsigned disconnect = USB_PORT_STAT_CONNECTION &
				dum_hcd->old_status & (~dum_hcd->port_status);
		unsigned reset = USB_PORT_STAT_RESET &
				(~dum_hcd->old_status) & dum_hcd->port_status;

		/* Report reset and disconnect events to the driver */
		if (dum->driver && (disconnect || reset)) {
380 381
			stop_activity(dum);
			spin_unlock(&dum->lock);
382 383 384 385
			if (reset)
				usb_gadget_udc_reset(&dum->gadget, dum->driver);
			else
				dum->driver->disconnect(&dum->gadget);
386
			spin_lock(&dum->lock);
387
		}
388 389
	} else if (dum_hcd->active != dum_hcd->old_active) {
		if (dum_hcd->old_active && dum->driver->suspend) {
390 391 392 393 394 395 396
			spin_unlock(&dum->lock);
			dum->driver->suspend(&dum->gadget);
			spin_lock(&dum->lock);
		} else if (!dum_hcd->old_active &&  dum->driver->resume) {
			spin_unlock(&dum->lock);
			dum->driver->resume(&dum->gadget);
			spin_lock(&dum->lock);
397 398 399
		}
	}

400 401
	dum_hcd->old_status = dum_hcd->port_status;
	dum_hcd->old_active = dum_hcd->active;
402 403 404 405
}

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

L
Linus Torvalds 已提交
406 407 408 409 410 411 412 413 414 415
/* 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)

416 417
static int dummy_enable(struct usb_ep *_ep,
		const struct usb_endpoint_descriptor *desc)
L
Linus Torvalds 已提交
418 419
{
	struct dummy		*dum;
420
	struct dummy_hcd	*dum_hcd;
L
Linus Torvalds 已提交
421 422 423 424
	struct dummy_ep		*ep;
	unsigned		max;
	int			retval;

425
	ep = usb_ep_to_dummy_ep(_ep);
L
Linus Torvalds 已提交
426 427 428
	if (!_ep || !desc || ep->desc || _ep->name == ep0name
			|| desc->bDescriptorType != USB_DT_ENDPOINT)
		return -EINVAL;
429
	dum = ep_to_dummy(ep);
430 431
	if (!dum->driver)
		return -ESHUTDOWN;
432 433

	dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
434
	if (!is_enabled(dum_hcd))
L
Linus Torvalds 已提交
435
		return -ESHUTDOWN;
436 437 438 439

	/*
	 * For HS/FS devices only bits 0..10 of the wMaxPacketSize represent the
	 * maximum packet size.
440
	 * For SS devices the wMaxPacketSize is limited by 1024.
441
	 */
442
	max = usb_endpoint_maxp(desc) & 0x7ff;
L
Linus Torvalds 已提交
443 444 445 446 447 448 449 450 451 452

	/* 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;
453
	switch (usb_endpoint_type(desc)) {
L
Linus Torvalds 已提交
454
	case USB_ENDPOINT_XFER_BULK:
455 456
		if (strstr(ep->ep.name, "-iso")
				|| strstr(ep->ep.name, "-int")) {
L
Linus Torvalds 已提交
457 458 459
			goto done;
		}
		switch (dum->gadget.speed) {
460 461 462 463
		case USB_SPEED_SUPER:
			if (max == 1024)
				break;
			goto done;
L
Linus Torvalds 已提交
464 465 466
		case USB_SPEED_HIGH:
			if (max == 512)
				break;
467 468 469
			goto done;
		case USB_SPEED_FULL:
			if (max == 8 || max == 16 || max == 32 || max == 64)
L
Linus Torvalds 已提交
470 471
				/* we'll fake any legal size */
				break;
472 473 474
			/* save a return statement */
		default:
			goto done;
L
Linus Torvalds 已提交
475 476 477
		}
		break;
	case USB_ENDPOINT_XFER_INT:
478
		if (strstr(ep->ep.name, "-iso")) /* bulk is ok */
L
Linus Torvalds 已提交
479 480 481
			goto done;
		/* real hardware might not handle all packet sizes */
		switch (dum->gadget.speed) {
482
		case USB_SPEED_SUPER:
L
Linus Torvalds 已提交
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
		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:
498 499
		if (strstr(ep->ep.name, "-bulk")
				|| strstr(ep->ep.name, "-int"))
L
Linus Torvalds 已提交
500 501 502
			goto done;
		/* real hardware might not handle all packet sizes */
		switch (dum->gadget.speed) {
503
		case USB_SPEED_SUPER:
L
Linus Torvalds 已提交
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
		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;
522 523 524 525 526 527 528 529
	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;
	}
530
	ep->desc = desc;
L
Linus Torvalds 已提交
531

532
	dev_dbg(udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d stream %s\n",
L
Linus Torvalds 已提交
533 534 535 536
		_ep->name,
		desc->bEndpointAddress & 0x0f,
		(desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
		({ char *val;
537
		 switch (usb_endpoint_type(desc)) {
T
Tatyana Brokhman 已提交
538 539 540 541 542 543 544 545 546 547 548 549
		 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;
J
Joe Perches 已提交
550
		 } val; }),
551
		max, ep->stream_en ? "enabled" : "disabled");
L
Linus Torvalds 已提交
552 553 554 555

	/* at this point real hardware should be NAKing transfers
	 * to that endpoint, until a buffer is queued to it.
	 */
556
	ep->halted = ep->wedged = 0;
L
Linus Torvalds 已提交
557 558 559 560 561
	retval = 0;
done:
	return retval;
}

562
static int dummy_disable(struct usb_ep *_ep)
L
Linus Torvalds 已提交
563 564 565 566 567
{
	struct dummy_ep		*ep;
	struct dummy		*dum;
	unsigned long		flags;

568
	ep = usb_ep_to_dummy_ep(_ep);
L
Linus Torvalds 已提交
569 570
	if (!_ep || !ep->desc || _ep->name == ep0name)
		return -EINVAL;
571
	dum = ep_to_dummy(ep);
L
Linus Torvalds 已提交
572

573
	spin_lock_irqsave(&dum->lock, flags);
L
Linus Torvalds 已提交
574
	ep->desc = NULL;
575
	ep->stream_en = 0;
576 577
	nuke(dum, ep);
	spin_unlock_irqrestore(&dum->lock, flags);
L
Linus Torvalds 已提交
578

579
	dev_dbg(udc_dev(dum), "disabled %s\n", _ep->name);
580
	return 0;
L
Linus Torvalds 已提交
581 582
}

583 584
static struct usb_request *dummy_alloc_request(struct usb_ep *_ep,
		gfp_t mem_flags)
L
Linus Torvalds 已提交
585 586 587 588 589 590
{
	struct dummy_ep		*ep;
	struct dummy_request	*req;

	if (!_ep)
		return NULL;
591
	ep = usb_ep_to_dummy_ep(_ep);
L
Linus Torvalds 已提交
592

593
	req = kzalloc(sizeof(*req), mem_flags);
L
Linus Torvalds 已提交
594 595
	if (!req)
		return NULL;
596
	INIT_LIST_HEAD(&req->queue);
L
Linus Torvalds 已提交
597 598 599
	return &req->req;
}

600
static void dummy_free_request(struct usb_ep *_ep, struct usb_request *_req)
L
Linus Torvalds 已提交
601 602 603
{
	struct dummy_request	*req;

604
	if (!_ep || !_req) {
605
		WARN_ON(1);
L
Linus Torvalds 已提交
606
		return;
607
	}
L
Linus Torvalds 已提交
608

609 610 611
	req = usb_request_to_dummy_request(_req);
	WARN_ON(!list_empty(&req->queue));
	kfree(req);
L
Linus Torvalds 已提交
612 613
}

614
static void fifo_complete(struct usb_ep *ep, struct usb_request *req)
L
Linus Torvalds 已提交
615 616 617
{
}

618
static int dummy_queue(struct usb_ep *_ep, struct usb_request *_req,
A
Al Viro 已提交
619
		gfp_t mem_flags)
L
Linus Torvalds 已提交
620 621 622 623
{
	struct dummy_ep		*ep;
	struct dummy_request	*req;
	struct dummy		*dum;
624
	struct dummy_hcd	*dum_hcd;
L
Linus Torvalds 已提交
625 626
	unsigned long		flags;

627 628
	req = usb_request_to_dummy_request(_req);
	if (!_req || !list_empty(&req->queue) || !_req->complete)
L
Linus Torvalds 已提交
629 630
		return -EINVAL;

631
	ep = usb_ep_to_dummy_ep(_ep);
L
Linus Torvalds 已提交
632 633 634
	if (!_ep || (!ep->desc && _ep->name != ep0name))
		return -EINVAL;

635
	dum = ep_to_dummy(ep);
636
	dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
637
	if (!dum->driver || !is_enabled(dum_hcd))
L
Linus Torvalds 已提交
638 639 640
		return -ESHUTDOWN;

#if 0
641
	dev_dbg(udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n",
L
Linus Torvalds 已提交
642 643 644 645
			ep, _req, _ep->name, _req->length, _req->buf);
#endif
	_req->status = -EINPROGRESS;
	_req->actual = 0;
646
	spin_lock_irqsave(&dum->lock, flags);
L
Linus Torvalds 已提交
647 648 649

	/* implement an emulated single-request FIFO */
	if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
650 651
			list_empty(&dum->fifo_req.queue) &&
			list_empty(&ep->queue) &&
L
Linus Torvalds 已提交
652 653 654 655
			_req->length <= FIFO_SIZE) {
		req = &dum->fifo_req;
		req->req = *_req;
		req->req.buf = dum->fifo_buf;
656
		memcpy(dum->fifo_buf, _req->buf, _req->length);
L
Linus Torvalds 已提交
657 658 659
		req->req.context = dum;
		req->req.complete = fifo_complete;

660
		list_add_tail(&req->queue, &ep->queue);
661
		spin_unlock(&dum->lock);
L
Linus Torvalds 已提交
662 663
		_req->actual = _req->length;
		_req->status = 0;
664
		usb_gadget_giveback_request(_ep, _req);
665
		spin_lock(&dum->lock);
666 667
	}  else
		list_add_tail(&req->queue, &ep->queue);
668
	spin_unlock_irqrestore(&dum->lock, flags);
L
Linus Torvalds 已提交
669 670 671 672 673 674 675

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

676
static int dummy_dequeue(struct usb_ep *_ep, struct usb_request *_req)
L
Linus Torvalds 已提交
677 678 679 680 681 682 683 684 685
{
	struct dummy_ep		*ep;
	struct dummy		*dum;
	int			retval = -EINVAL;
	unsigned long		flags;
	struct dummy_request	*req = NULL;

	if (!_ep || !_req)
		return retval;
686 687
	ep = usb_ep_to_dummy_ep(_ep);
	dum = ep_to_dummy(ep);
L
Linus Torvalds 已提交
688 689 690 691

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

692 693 694
	local_irq_save(flags);
	spin_lock(&dum->lock);
	list_for_each_entry(req, &ep->queue, queue) {
L
Linus Torvalds 已提交
695
		if (&req->req == _req) {
696
			list_del_init(&req->queue);
L
Linus Torvalds 已提交
697 698 699 700 701
			_req->status = -ECONNRESET;
			retval = 0;
			break;
		}
	}
702
	spin_unlock(&dum->lock);
L
Linus Torvalds 已提交
703 704

	if (retval == 0) {
705
		dev_dbg(udc_dev(dum),
L
Linus Torvalds 已提交
706 707
				"dequeued req %p from %s, len %d buf %p\n",
				req, _ep->name, _req->length, _req->buf);
708
		usb_gadget_giveback_request(_ep, _req);
L
Linus Torvalds 已提交
709
	}
710
	local_irq_restore(flags);
L
Linus Torvalds 已提交
711 712 713 714
	return retval;
}

static int
715
dummy_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
L
Linus Torvalds 已提交
716 717 718 719 720 721
{
	struct dummy_ep		*ep;
	struct dummy		*dum;

	if (!_ep)
		return -EINVAL;
722 723
	ep = usb_ep_to_dummy_ep(_ep);
	dum = ep_to_dummy(ep);
L
Linus Torvalds 已提交
724 725 726
	if (!dum->driver)
		return -ESHUTDOWN;
	if (!value)
727
		ep->halted = ep->wedged = 0;
L
Linus Torvalds 已提交
728
	else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
729
			!list_empty(&ep->queue))
L
Linus Torvalds 已提交
730
		return -EAGAIN;
731
	else {
L
Linus Torvalds 已提交
732
		ep->halted = 1;
733 734 735
		if (wedged)
			ep->wedged = 1;
	}
L
Linus Torvalds 已提交
736 737 738 739
	/* FIXME clear emulated data toggle too */
	return 0;
}

740 741 742 743 744 745 746 747 748 749 750 751 752
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);
}

L
Linus Torvalds 已提交
753 754 755 756 757 758 759 760 761 762 763
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,
764
	.set_wedge	= dummy_set_wedge,
L
Linus Torvalds 已提交
765 766 767 768 769
};

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

/* there are both host and device side versions of this call ... */
770
static int dummy_g_get_frame(struct usb_gadget *_gadget)
L
Linus Torvalds 已提交
771 772 773
{
	struct timeval	tv;

774
	do_gettimeofday(&tv);
L
Linus Torvalds 已提交
775 776 777
	return tv.tv_usec / 1000;
}

778
static int dummy_wakeup(struct usb_gadget *_gadget)
L
Linus Torvalds 已提交
779
{
780
	struct dummy_hcd *dum_hcd;
L
Linus Torvalds 已提交
781

782 783
	dum_hcd = gadget_to_dummy_hcd(_gadget);
	if (!(dum_hcd->dum->devstatus & ((1 << USB_DEVICE_B_HNP_ENABLE)
784
				| (1 << USB_DEVICE_REMOTE_WAKEUP))))
L
Linus Torvalds 已提交
785
		return -EINVAL;
786
	if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0)
787
		return -ENOLINK;
788 789
	if ((dum_hcd->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
			 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
790 791 792
		return -EIO;

	/* FIXME: What if the root hub is suspended but the port isn't? */
L
Linus Torvalds 已提交
793 794

	/* hub notices our request, issues downstream resume, etc */
795 796 797
	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);
L
Linus Torvalds 已提交
798 799 800
	return 0;
}

801
static int dummy_set_selfpowered(struct usb_gadget *_gadget, int value)
L
Linus Torvalds 已提交
802 803 804
{
	struct dummy	*dum;

805
	_gadget->is_selfpowered = (value != 0);
806
	dum = gadget_to_dummy_hcd(_gadget)->dum;
L
Linus Torvalds 已提交
807 808 809 810 811 812 813
	if (value)
		dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
	else
		dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
	return 0;
}

814
static void dummy_udc_update_ep0(struct dummy *dum)
815
{
816
	if (dum->gadget.speed == USB_SPEED_SUPER)
817
		dum->ep[0].ep.maxpacket = 9;
818
	else
819 820 821
		dum->ep[0].ep.maxpacket = 64;
}

822
static int dummy_pullup(struct usb_gadget *_gadget, int value)
823
{
824
	struct dummy_hcd *dum_hcd;
825 826 827
	struct dummy	*dum;
	unsigned long	flags;

828 829 830 831
	dum = gadget_dev_to_dummy(&_gadget->dev);

	if (value && dum->driver) {
		if (mod_data.is_super_speed)
832
			dum->gadget.speed = dum->driver->max_speed;
833 834
		else if (mod_data.is_high_speed)
			dum->gadget.speed = min_t(u8, USB_SPEED_HIGH,
835
					dum->driver->max_speed);
836 837
		else
			dum->gadget.speed = USB_SPEED_FULL;
838
		dummy_udc_update_ep0(dum);
839

840
		if (dum->gadget.speed < dum->driver->max_speed)
841
			dev_dbg(udc_dev(dum), "This device can perform faster"
842 843
				" if you connect it to a %s port...\n",
				usb_speed_string(dum->driver->max_speed));
844
	}
845 846
	dum_hcd = gadget_to_dummy_hcd(_gadget);

847
	spin_lock_irqsave(&dum->lock, flags);
848
	dum->pullup = (value != 0);
849
	set_link_state(dum_hcd);
850
	spin_unlock_irqrestore(&dum->lock, flags);
851

852
	usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
853 854 855
	return 0;
}

856 857
static int dummy_udc_start(struct usb_gadget *g,
		struct usb_gadget_driver *driver);
858
static int dummy_udc_stop(struct usb_gadget *g);
859

L
Linus Torvalds 已提交
860 861 862 863
static const struct usb_gadget_ops dummy_ops = {
	.get_frame	= dummy_g_get_frame,
	.wakeup		= dummy_wakeup,
	.set_selfpowered = dummy_set_selfpowered,
864
	.pullup		= dummy_pullup,
865 866
	.udc_start	= dummy_udc_start,
	.udc_stop	= dummy_udc_stop,
L
Linus Torvalds 已提交
867 868 869 870 871
};

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

/* "function" sysfs attribute */
872
static ssize_t function_show(struct device *dev, struct device_attribute *attr,
873
		char *buf)
L
Linus Torvalds 已提交
874
{
875
	struct dummy	*dum = gadget_dev_to_dummy(dev);
L
Linus Torvalds 已提交
876 877 878

	if (!dum->driver || !dum->driver->function)
		return 0;
879
	return scnprintf(buf, PAGE_SIZE, "%s\n", dum->driver->function);
L
Linus Torvalds 已提交
880
}
881
static DEVICE_ATTR_RO(function);
L
Linus Torvalds 已提交
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898

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

/*
 * 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.
 */

899 900
static int dummy_udc_start(struct usb_gadget *g,
		struct usb_gadget_driver *driver)
L
Linus Torvalds 已提交
901
{
902 903
	struct dummy_hcd	*dum_hcd = gadget_to_dummy_hcd(g);
	struct dummy		*dum = dum_hcd->dum;
L
Linus Torvalds 已提交
904

905
	if (driver->max_speed == USB_SPEED_UNKNOWN)
L
Linus Torvalds 已提交
906 907 908 909 910 911
		return -EINVAL;

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

L
Linus Torvalds 已提交
913 914
	dum->devstatus = 0;
	dum->driver = driver;
915

L
Linus Torvalds 已提交
916 917 918
	return 0;
}

919
static int dummy_udc_stop(struct usb_gadget *g)
L
Linus Torvalds 已提交
920
{
921 922
	struct dummy_hcd	*dum_hcd = gadget_to_dummy_hcd(g);
	struct dummy		*dum = dum_hcd->dum;
L
Linus Torvalds 已提交
923 924

	dum->driver = NULL;
925

L
Linus Torvalds 已提交
926 927 928 929 930
	return 0;
}

#undef is_enabled

931 932
/* The gadget structure is stored inside the hcd structure and will be
 * released along with it. */
933 934 935 936 937 938 939 940 941 942 943 944 945 946 947
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];

		if (!ep_name[i])
			break;
		ep->ep.name = ep_name[i];
		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;
948
		usb_ep_set_maxpacket_limit(&ep->ep, ~0);
949
		ep->ep.max_streams = 16;
950 951 952 953 954 955 956 957 958
		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);
959 960 961 962

#ifdef CONFIG_USB_OTG
	dum->gadget.is_otg = 1;
#endif
963 964
}

965
static int dummy_udc_probe(struct platform_device *pdev)
966
{
967
	struct dummy	*dum;
968 969
	int		rc;

970
	dum = *((void **)dev_get_platdata(&pdev->dev));
971 972
	dum->gadget.name = gadget_name;
	dum->gadget.ops = &dummy_ops;
973
	dum->gadget.max_speed = USB_SPEED_SUPER;
974

975
	dum->gadget.dev.parent = &pdev->dev;
976 977
	init_dummy_udc_hw(dum);

978 979 980 981
	rc = usb_add_gadget_udc(&pdev->dev, &dum->gadget);
	if (rc < 0)
		goto err_udc;

982
	rc = device_create_file(&dum->gadget.dev, &dev_attr_function);
983
	if (rc < 0)
984 985 986 987 988 989 990
		goto err_dev;
	platform_set_drvdata(pdev, dum);
	return rc;

err_dev:
	usb_del_gadget_udc(&dum->gadget);
err_udc:
991 992 993
	return rc;
}

994
static int dummy_udc_remove(struct platform_device *pdev)
995
{
996
	struct dummy	*dum = platform_get_drvdata(pdev);
997

998
	device_remove_file(&dum->gadget.dev, &dev_attr_function);
999
	usb_del_gadget_udc(&dum->gadget);
1000 1001 1002
	return 0;
}

1003 1004
static void dummy_udc_pm(struct dummy *dum, struct dummy_hcd *dum_hcd,
		int suspend)
1005
{
1006 1007
	spin_lock_irq(&dum->lock);
	dum->udc_suspended = suspend;
1008
	set_link_state(dum_hcd);
1009 1010 1011 1012 1013 1014 1015
	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);
1016

1017 1018
	dev_dbg(&pdev->dev, "%s\n", __func__);
	dummy_udc_pm(dum, dum_hcd, 1);
1019
	usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1020 1021 1022
	return 0;
}

1023
static int dummy_udc_resume(struct platform_device *pdev)
1024
{
1025 1026
	struct dummy		*dum = platform_get_drvdata(pdev);
	struct dummy_hcd	*dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
1027

1028 1029
	dev_dbg(&pdev->dev, "%s\n", __func__);
	dummy_udc_pm(dum, dum_hcd, 0);
1030
	usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1031 1032 1033
	return 0;
}

1034
static struct platform_driver dummy_udc_driver = {
1035 1036
	.probe		= dummy_udc_probe,
	.remove		= dummy_udc_remove,
1037 1038
	.suspend	= dummy_udc_suspend,
	.resume		= dummy_udc_resume,
1039 1040 1041
	.driver		= {
		.name	= (char *) gadget_name,
	},
1042 1043
};

L
Linus Torvalds 已提交
1044 1045
/*-------------------------------------------------------------------------*/

1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
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;
}

L
Linus Torvalds 已提交
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
/* 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.
 */

1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
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;
}

1143
static int dummy_urb_enqueue(
L
Linus Torvalds 已提交
1144 1145
	struct usb_hcd			*hcd,
	struct urb			*urb,
A
Al Viro 已提交
1146
	gfp_t				mem_flags
L
Linus Torvalds 已提交
1147
) {
1148
	struct dummy_hcd *dum_hcd;
L
Linus Torvalds 已提交
1149 1150
	struct urbp	*urbp;
	unsigned long	flags;
1151
	int		rc;
L
Linus Torvalds 已提交
1152

1153
	urbp = kmalloc(sizeof *urbp, mem_flags);
L
Linus Torvalds 已提交
1154 1155 1156
	if (!urbp)
		return -ENOMEM;
	urbp->urb = urb;
1157
	urbp->miter_started = 0;
L
Linus Torvalds 已提交
1158

1159 1160
	dum_hcd = hcd_to_dummy_hcd(hcd);
	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1161 1162 1163 1164 1165 1166 1167

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

1168 1169 1170 1171 1172
	rc = usb_hcd_link_urb_to_ep(hcd, urb);
	if (rc) {
		kfree(urbp);
		goto done;
	}
L
Linus Torvalds 已提交
1173

1174 1175 1176 1177 1178
	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");
L
Linus Torvalds 已提交
1179

1180
	list_add_tail(&urbp->urbp_list, &dum_hcd->urbp_list);
L
Linus Torvalds 已提交
1181
	urb->hcpriv = urbp;
1182
	if (usb_pipetype(urb->pipe) == PIPE_CONTROL)
L
Linus Torvalds 已提交
1183 1184 1185
		urb->error_count = 1;		/* mark as a new urb */

	/* kick the scheduler, it'll do the rest */
1186 1187
	if (!timer_pending(&dum_hcd->timer))
		mod_timer(&dum_hcd->timer, jiffies + 1);
L
Linus Torvalds 已提交
1188

1189
 done:
1190
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1191
	return rc;
L
Linus Torvalds 已提交
1192 1193
}

1194
static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
L
Linus Torvalds 已提交
1195
{
1196
	struct dummy_hcd *dum_hcd;
1197
	unsigned long	flags;
1198
	int		rc;
1199 1200 1201

	/* giveback happens automatically in timer callback,
	 * so make sure the callback happens */
1202 1203
	dum_hcd = hcd_to_dummy_hcd(hcd);
	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1204 1205

	rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1206 1207 1208
	if (!rc && dum_hcd->rh_state != DUMMY_RH_RUNNING &&
			!list_empty(&dum_hcd->urbp_list))
		mod_timer(&dum_hcd->timer, jiffies);
1209

1210
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1211
	return rc;
L
Linus Torvalds 已提交
1212 1213
}

1214 1215 1216 1217
static int dummy_perform_transfer(struct urb *urb, struct dummy_request *req,
		u32 len)
{
	void *ubuf, *rbuf;
1218
	struct urbp *urbp = urb->hcpriv;
1219
	int to_host;
1220 1221 1222 1223
	struct sg_mapping_iter *miter = &urbp->miter;
	u32 trans = 0;
	u32 this_sg;
	bool next_sg;
1224 1225 1226 1227

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

1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
	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;
1278 1279
}

L
Linus Torvalds 已提交
1280
/* transfer up to a frame's worth; caller must own lock */
1281 1282
static int transfer(struct dummy_hcd *dum_hcd, struct urb *urb,
		struct dummy_ep *ep, int limit, int *status)
L
Linus Torvalds 已提交
1283
{
1284
	struct dummy		*dum = dum_hcd->dum;
L
Linus Torvalds 已提交
1285 1286 1287 1288
	struct dummy_request	*req;

top:
	/* if there's no request queued, the device is NAKing; return */
1289
	list_for_each_entry(req, &ep->queue, queue) {
L
Linus Torvalds 已提交
1290 1291 1292 1293
		unsigned	host_len, dev_len, len;
		int		is_short, to_host;
		int		rescan = 0;

1294 1295 1296 1297 1298
		if (dummy_ep_stream_en(dum_hcd, urb)) {
			if ((urb->stream_id != req->req.stream_id))
				continue;
		}

L
Linus Torvalds 已提交
1299 1300 1301 1302 1303 1304 1305 1306 1307
		/* 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;
1308
		len = min(host_len, dev_len);
L
Linus Torvalds 已提交
1309 1310 1311

		/* FIXME update emulated data toggle too */

1312 1313
		to_host = usb_pipein(urb->pipe);
		if (unlikely(len == 0))
L
Linus Torvalds 已提交
1314 1315 1316 1317 1318
			is_short = 1;
		else {
			/* not enough bandwidth left? */
			if (limit < ep->ep.maxpacket && limit < len)
				break;
1319
			len = min_t(unsigned, len, limit);
L
Linus Torvalds 已提交
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
			if (len == 0)
				break;

			/* use an extra pass for the final short packet */
			if (len > ep->ep.maxpacket) {
				rescan = 1;
				len -= (len % ep->ep.maxpacket);
			}
			is_short = (len % ep->ep.maxpacket) != 0;

1330 1331
			len = dummy_perform_transfer(urb, req, len);

L
Linus Torvalds 已提交
1332
			ep->last_io = jiffies;
1333
			if ((int)len < 0) {
1334 1335 1336 1337 1338 1339
				req->req.status = len;
			} else {
				limit -= len;
				urb->actual_length += len;
				req->req.actual += len;
			}
L
Linus Torvalds 已提交
1340 1341 1342 1343 1344 1345 1346
		}

		/* 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
A
Alan Stern 已提交
1347
		 * need to emulate such data-in-flight.
L
Linus Torvalds 已提交
1348 1349 1350 1351
		 */
		if (is_short) {
			if (host_len == dev_len) {
				req->req.status = 0;
1352
				*status = 0;
L
Linus Torvalds 已提交
1353 1354 1355
			} else if (to_host) {
				req->req.status = 0;
				if (dev_len > host_len)
1356
					*status = -EOVERFLOW;
L
Linus Torvalds 已提交
1357
				else
1358
					*status = 0;
L
Linus Torvalds 已提交
1359
			} else if (!to_host) {
1360
				*status = 0;
L
Linus Torvalds 已提交
1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373
				if (host_len > dev_len)
					req->req.status = -EOVERFLOW;
				else
					req->req.status = 0;
			}

		/* many requests terminate without a short packet */
		} else {
			if (req->req.length == req->req.actual
					&& !req->req.zero)
				req->req.status = 0;
			if (urb->transfer_buffer_length == urb->actual_length
					&& !(urb->transfer_flags
1374 1375
						& URB_ZERO_PACKET))
				*status = 0;
L
Linus Torvalds 已提交
1376 1377 1378 1379
		}

		/* device side completion --> continuable */
		if (req->req.status != -EINPROGRESS) {
1380
			list_del_init(&req->queue);
L
Linus Torvalds 已提交
1381

1382
			spin_unlock(&dum->lock);
1383
			usb_gadget_giveback_request(&ep->ep, &req->req);
1384
			spin_lock(&dum->lock);
L
Linus Torvalds 已提交
1385 1386 1387 1388 1389 1390

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

		/* host side completion --> terminate */
1391
		if (*status != -EINPROGRESS)
L
Linus Torvalds 已提交
1392 1393 1394 1395 1396 1397 1398 1399 1400
			break;

		/* rescan to continue with any other queued i/o */
		if (rescan)
			goto top;
	}
	return limit;
}

1401
static int periodic_bytes(struct dummy *dum, struct dummy_ep *ep)
L
Linus Torvalds 已提交
1402 1403 1404 1405 1406 1407 1408
{
	int	limit = ep->ep.maxpacket;

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

		/* high bandwidth mode */
1409
		tmp = usb_endpoint_maxp(ep->desc);
L
Linus Torvalds 已提交
1410 1411 1412 1413
		tmp = (tmp >> 11) & 0x03;
		tmp *= 8 /* applies to entire frame */;
		limit += limit * tmp;
	}
1414
	if (dum->gadget.speed == USB_SPEED_SUPER) {
1415
		switch (usb_endpoint_type(ep->desc)) {
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428
		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;
		}
	}
L
Linus Torvalds 已提交
1429 1430 1431
	return limit;
}

1432
#define is_active(dum_hcd)	((dum_hcd->port_status & \
L
Linus Torvalds 已提交
1433 1434 1435 1436
		(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \
			USB_PORT_STAT_SUSPEND)) \
		== (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))

1437
static struct dummy_ep *find_endpoint(struct dummy *dum, u8 address)
L
Linus Torvalds 已提交
1438 1439 1440
{
	int		i;

1441 1442
	if (!is_active((dum->gadget.speed == USB_SPEED_SUPER ?
			dum->ss_hcd : dum->hs_hcd)))
L
Linus Torvalds 已提交
1443 1444
		return NULL;
	if ((address & ~USB_DIR_IN) == 0)
1445
		return &dum->ep[0];
L
Linus Torvalds 已提交
1446
	for (i = 1; i < DUMMY_ENDPOINTS; i++) {
1447
		struct dummy_ep	*ep = &dum->ep[i];
L
Linus Torvalds 已提交
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465

		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)

1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478

/**
 * 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
 */
1479
static int handle_control_request(struct dummy_hcd *dum_hcd, struct urb *urb,
1480 1481 1482 1483
				  struct usb_ctrlrequest *setup,
				  int *status)
{
	struct dummy_ep		*ep2;
1484
	struct dummy		*dum = dum_hcd->dum;
1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
	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;
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536
			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;
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
			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;
1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
			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;
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 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 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
			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;
}

L
Linus Torvalds 已提交
1642 1643 1644
/* drive both sides of the transfers; looks like irq handlers to
 * both drivers except the callbacks aren't in_irq().
 */
1645
static void dummy_timer(unsigned long _dum_hcd)
L
Linus Torvalds 已提交
1646
{
1647 1648
	struct dummy_hcd	*dum_hcd = (struct dummy_hcd *) _dum_hcd;
	struct dummy		*dum = dum_hcd->dum;
L
Linus Torvalds 已提交
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
	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;
1665 1666 1667 1668
	case USB_SPEED_SUPER:
		/* Bus speed is 500000 bytes/ms, so use a little less */
		total = 490000;
		break;
L
Linus Torvalds 已提交
1669
	default:
1670
		dev_err(dummy_dev(dum_hcd), "bogus device speed\n");
L
Linus Torvalds 已提交
1671 1672 1673 1674 1675 1676
		return;
	}

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

	/* look at each urb queued by the host side driver */
1677
	spin_lock_irqsave(&dum->lock, flags);
L
Linus Torvalds 已提交
1678

1679 1680
	if (!dum_hcd->udev) {
		dev_err(dummy_dev(dum_hcd),
L
Linus Torvalds 已提交
1681
				"timer fired with no URBs pending?\n");
1682
		spin_unlock_irqrestore(&dum->lock, flags);
L
Linus Torvalds 已提交
1683 1684 1685 1686
		return;
	}

	for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1687
		if (!ep_name[i])
L
Linus Torvalds 已提交
1688
			break;
1689
		dum->ep[i].already_seen = 0;
L
Linus Torvalds 已提交
1690 1691 1692
	}

restart:
1693
	list_for_each_entry_safe(urbp, tmp, &dum_hcd->urbp_list, urbp_list) {
L
Linus Torvalds 已提交
1694 1695 1696 1697 1698
		struct urb		*urb;
		struct dummy_request	*req;
		u8			address;
		struct dummy_ep		*ep = NULL;
		int			type;
1699
		int			status = -EINPROGRESS;
L
Linus Torvalds 已提交
1700 1701

		urb = urbp->urb;
A
Alan Stern 已提交
1702
		if (urb->unlinked)
L
Linus Torvalds 已提交
1703
			goto return_urb;
1704
		else if (dum_hcd->rh_state != DUMMY_RH_RUNNING)
1705
			continue;
1706
		type = usb_pipetype(urb->pipe);
L
Linus Torvalds 已提交
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716

		/* 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);
1717
		if (usb_pipein(urb->pipe))
L
Linus Torvalds 已提交
1718 1719 1720 1721
			address |= USB_DIR_IN;
		ep = find_endpoint(dum, address);
		if (!ep) {
			/* set_configuration() disagreement */
1722
			dev_dbg(dummy_dev(dum_hcd),
L
Linus Torvalds 已提交
1723 1724
				"no ep configured for urb %p\n",
				urb);
1725
			status = -EPROTO;
L
Linus Torvalds 已提交
1726 1727 1728 1729 1730 1731
			goto return_urb;
		}

		if (ep->already_seen)
			continue;
		ep->already_seen = 1;
1732
		if (ep == &dum->ep[0] && urb->error_count) {
L
Linus Torvalds 已提交
1733 1734 1735 1736 1737
			ep->setup_stage = 1;	/* a new urb */
			urb->error_count = 0;
		}
		if (ep->halted && !ep->setup_stage) {
			/* NOTE: must not be iso! */
1738
			dev_dbg(dummy_dev(dum_hcd), "ep %s halted, urb %p\n",
L
Linus Torvalds 已提交
1739
					ep->ep.name, urb);
1740
			status = -EPIPE;
L
Linus Torvalds 已提交
1741 1742 1743 1744 1745
			goto return_urb;
		}
		/* FIXME make sure both ends agree on maxpacket */

		/* handle control requests */
1746
		if (ep == &dum->ep[0] && ep->setup_stage) {
L
Linus Torvalds 已提交
1747 1748 1749
			struct usb_ctrlrequest		setup;
			int				value = 1;

1750
			setup = *(struct usb_ctrlrequest *) urb->setup_packet;
L
Linus Torvalds 已提交
1751
			/* paranoia, in case of stale queued data */
1752 1753
			list_for_each_entry(req, &ep->queue, queue) {
				list_del_init(&req->queue);
L
Linus Torvalds 已提交
1754
				req->req.status = -EOVERFLOW;
1755
				dev_dbg(udc_dev(dum), "stale req = %p\n",
L
Linus Torvalds 已提交
1756 1757
						req);

1758
				spin_unlock(&dum->lock);
1759
				usb_gadget_giveback_request(&ep->ep, &req->req);
1760
				spin_lock(&dum->lock);
L
Linus Torvalds 已提交
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772
				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;

1773
			value = handle_control_request(dum_hcd, urb, &setup,
1774
						       &status);
L
Linus Torvalds 已提交
1775 1776 1777 1778 1779

			/* gadget driver handles all other requests.  block
			 * until setup() returns; no reentrancy issues etc.
			 */
			if (value > 0) {
1780 1781
				spin_unlock(&dum->lock);
				value = dum->driver->setup(&dum->gadget,
L
Linus Torvalds 已提交
1782
						&setup);
1783
				spin_lock(&dum->lock);
L
Linus Torvalds 已提交
1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794

				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)
1795
					dev_dbg(udc_dev(dum),
L
Linus Torvalds 已提交
1796 1797
						"setup --> %d\n",
						value);
1798
				status = -EPIPE;
L
Linus Torvalds 已提交
1799 1800 1801 1802 1803 1804 1805 1806
				urb->actual_length = 0;
			}

			goto return_urb;
		}

		/* non-control requests */
		limit = total;
1807
		switch (usb_pipetype(urb->pipe)) {
L
Linus Torvalds 已提交
1808 1809 1810 1811 1812 1813
		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.
			 */
1814
			limit = max(limit, periodic_bytes(dum, ep));
1815
			status = -ENOSYS;
L
Linus Torvalds 已提交
1816 1817 1818 1819 1820 1821
			break;

		case PIPE_INTERRUPT:
			/* FIXME is it urb->interval since the last xfer?
			 * this almost certainly polls too fast.
			 */
1822
			limit = max(limit, periodic_bytes(dum, ep));
L
Linus Torvalds 已提交
1823 1824 1825
			/* FALLTHROUGH */

		default:
1826
treat_control_like_bulk:
L
Linus Torvalds 已提交
1827
			ep->last_io = jiffies;
1828
			total = transfer(dum_hcd, urb, ep, limit, &status);
L
Linus Torvalds 已提交
1829 1830 1831 1832
			break;
		}

		/* incomplete transfer? */
1833
		if (status == -EINPROGRESS)
L
Linus Torvalds 已提交
1834 1835 1836
			continue;

return_urb:
1837 1838
		list_del(&urbp->urbp_list);
		kfree(urbp);
L
Linus Torvalds 已提交
1839 1840 1841
		if (ep)
			ep->already_seen = ep->setup_stage = 0;

1842
		usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd), urb);
1843
		spin_unlock(&dum->lock);
1844
		usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd), urb, status);
1845
		spin_lock(&dum->lock);
L
Linus Torvalds 已提交
1846 1847 1848 1849

		goto restart;
	}

1850 1851 1852 1853
	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) {
1854
		/* want a 1 msec delay here */
1855
		mod_timer(&dum_hcd->timer, jiffies + msecs_to_jiffies(1));
L
Linus Torvalds 已提交
1856 1857
	}

1858
	spin_unlock_irqrestore(&dum->lock, flags);
L
Linus Torvalds 已提交
1859 1860 1861 1862 1863
}

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

#define PORT_C_MASK \
1864 1865 1866 1867 1868
	((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)
L
Linus Torvalds 已提交
1869

1870
static int dummy_hub_status(struct usb_hcd *hcd, char *buf)
L
Linus Torvalds 已提交
1871
{
1872
	struct dummy_hcd	*dum_hcd;
L
Linus Torvalds 已提交
1873
	unsigned long		flags;
1874
	int			retval = 0;
L
Linus Torvalds 已提交
1875

1876
	dum_hcd = hcd_to_dummy_hcd(hcd);
L
Linus Torvalds 已提交
1877

1878
	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1879
	if (!HCD_HW_ACCESSIBLE(hcd))
1880
		goto done;
1881

1882 1883 1884 1885
	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);
1886 1887
	}

1888
	if ((dum_hcd->port_status & PORT_C_MASK) != 0) {
L
Linus Torvalds 已提交
1889
		*buf = (1 << 1);
1890 1891
		dev_dbg(dummy_dev(dum_hcd), "port status 0x%08x has changes\n",
				dum_hcd->port_status);
L
Linus Torvalds 已提交
1892
		retval = 1;
1893
		if (dum_hcd->rh_state == DUMMY_RH_SUSPENDED)
1894
			usb_hcd_resume_root_hub(hcd);
L
Linus Torvalds 已提交
1895
	}
1896
done:
1897
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
L
Linus Torvalds 已提交
1898 1899 1900
	return retval;
}

1901
/* usb 3.0 root hub device descriptor */
1902
static struct {
1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
	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),
	},
};

1922 1923 1924 1925 1926 1927
static inline void
ss_hub_descriptor(struct usb_hub_descriptor *desc)
{
	memset(desc, 0, sizeof *desc);
	desc->bDescriptorType = 0x2a;
	desc->bDescLength = 12;
S
Sergei Shtylyov 已提交
1928 1929 1930
	desc->wHubCharacteristics = cpu_to_le16(
			HUB_CHAR_INDV_PORT_LPSM |
			HUB_CHAR_COMMON_OCPM);
1931 1932 1933 1934 1935
	desc->bNbrPorts = 1;
	desc->u.ss.bHubHdrDecLat = 0x04; /* Worst case: 0.4 micro sec*/
	desc->u.ss.DeviceRemovable = 0xffff;
}

1936
static inline void hub_descriptor(struct usb_hub_descriptor *desc)
L
Linus Torvalds 已提交
1937
{
1938
	memset(desc, 0, sizeof *desc);
L
Linus Torvalds 已提交
1939 1940
	desc->bDescriptorType = 0x29;
	desc->bDescLength = 9;
S
Sergei Shtylyov 已提交
1941 1942 1943
	desc->wHubCharacteristics = cpu_to_le16(
			HUB_CHAR_INDV_PORT_LPSM |
			HUB_CHAR_COMMON_OCPM);
L
Linus Torvalds 已提交
1944
	desc->bNbrPorts = 1;
J
John Youn 已提交
1945 1946
	desc->u.hs.DeviceRemovable[0] = 0xff;
	desc->u.hs.DeviceRemovable[1] = 0xff;
L
Linus Torvalds 已提交
1947 1948
}

1949
static int dummy_hub_control(
L
Linus Torvalds 已提交
1950 1951 1952 1953 1954 1955 1956
	struct usb_hcd	*hcd,
	u16		typeReq,
	u16		wValue,
	u16		wIndex,
	char		*buf,
	u16		wLength
) {
1957
	struct dummy_hcd *dum_hcd;
L
Linus Torvalds 已提交
1958 1959 1960
	int		retval = 0;
	unsigned long	flags;

1961
	if (!HCD_HW_ACCESSIBLE(hcd))
1962 1963
		return -ETIMEDOUT;

1964 1965 1966
	dum_hcd = hcd_to_dummy_hcd(hcd);

	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
L
Linus Torvalds 已提交
1967 1968 1969 1970 1971 1972
	switch (typeReq) {
	case ClearHubFeature:
		break;
	case ClearPortFeature:
		switch (wValue) {
		case USB_PORT_FEAT_SUSPEND:
1973 1974 1975 1976 1977 1978
			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;
			}
1979
			if (dum_hcd->port_status & USB_PORT_STAT_SUSPEND) {
L
Linus Torvalds 已提交
1980
				/* 20msec resume signaling */
1981 1982
				dum_hcd->resuming = 1;
				dum_hcd->re_timeout = jiffies +
1983
						msecs_to_jiffies(20);
L
Linus Torvalds 已提交
1984 1985 1986
			}
			break;
		case USB_PORT_FEAT_POWER:
1987 1988 1989 1990 1991 1992 1993 1994 1995
			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");
1996
			/* FALLS THROUGH */
L
Linus Torvalds 已提交
1997
		default:
1998 1999
			dum_hcd->port_status &= ~(1 << wValue);
			set_link_state(dum_hcd);
L
Linus Torvalds 已提交
2000 2001 2002
		}
		break;
	case GetHubDescriptor:
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
		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);
L
Linus Torvalds 已提交
2015
		break;
2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027

	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;

L
Linus Torvalds 已提交
2028
	case GetHubStatus:
2029
		*(__le32 *) buf = cpu_to_le32(0);
L
Linus Torvalds 已提交
2030 2031 2032 2033 2034 2035 2036 2037
		break;
	case GetPortStatus:
		if (wIndex != 1)
			retval = -EPIPE;

		/* whoever resets or resumes must GetPortStatus to
		 * complete it!!
		 */
2038 2039 2040 2041
		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;
L
Linus Torvalds 已提交
2042
		}
2043 2044 2045 2046 2047 2048
		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;
2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066

				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;
					}
L
Linus Torvalds 已提交
2067 2068 2069
				}
			}
		}
2070
		set_link_state(dum_hcd);
2071 2072
		((__le16 *) buf)[0] = cpu_to_le16(dum_hcd->port_status);
		((__le16 *) buf)[1] = cpu_to_le16(dum_hcd->port_status >> 16);
L
Linus Torvalds 已提交
2073 2074 2075 2076 2077 2078
		break;
	case SetHubFeature:
		retval = -EPIPE;
		break;
	case SetPortFeature:
		switch (wValue) {
2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
		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;
L
Linus Torvalds 已提交
2101
		case USB_PORT_FEAT_SUSPEND:
2102 2103 2104 2105 2106 2107 2108
			/* 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;
			}
2109 2110
			if (dum_hcd->active) {
				dum_hcd->port_status |= USB_PORT_STAT_SUSPEND;
2111 2112 2113 2114

				/* HNP would happen here; for now we
				 * assume b_bus_req is always true.
				 */
2115
				set_link_state(dum_hcd);
2116
				if (((1 << USB_DEVICE_B_HNP_ENABLE)
2117 2118
						& dum_hcd->dum->devstatus) != 0)
					dev_dbg(dummy_dev(dum_hcd),
2119
							"no HNP yet!\n");
L
Linus Torvalds 已提交
2120 2121
			}
			break;
2122
		case USB_PORT_FEAT_POWER:
2123 2124 2125 2126
			if (hcd->speed == HCD_USB3)
				dum_hcd->port_status |= USB_SS_PORT_STAT_POWER;
			else
				dum_hcd->port_status |= USB_PORT_STAT_POWER;
2127
			set_link_state(dum_hcd);
2128
			break;
2129 2130 2131 2132 2133 2134 2135 2136 2137
		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 */
L
Linus Torvalds 已提交
2138
		case USB_PORT_FEAT_RESET:
2139
			/* if it's already enabled, disable */
2140 2141 2142 2143 2144 2145 2146 2147
			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
2148 2149
					| USB_PORT_STAT_LOW_SPEED
					| USB_PORT_STAT_HIGH_SPEED);
2150 2151 2152 2153 2154 2155
			/*
			 * We want to reset device status. All but the
			 * Self powered feature
			 */
			dum_hcd->dum->devstatus &=
				(1 << USB_DEVICE_SELF_POWERED);
2156 2157 2158 2159
			/*
			 * FIXME USB3.0: what is the correct reset signaling
			 * interval? Is it still 50msec as for HS?
			 */
2160
			dum_hcd->re_timeout = jiffies + msecs_to_jiffies(50);
2161
			/* FALLS THROUGH */
L
Linus Torvalds 已提交
2162
		default:
2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192
			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;
L
Linus Torvalds 已提交
2193 2194 2195
		}
		break;
	default:
2196
		dev_dbg(dummy_dev(dum_hcd),
L
Linus Torvalds 已提交
2197 2198
			"hub control req%04x v%04x i%04x l%d\n",
			typeReq, wValue, wIndex, wLength);
2199
error:
L
Linus Torvalds 已提交
2200 2201 2202
		/* "protocol stall" on error */
		retval = -EPIPE;
	}
2203
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2204

2205
	if ((dum_hcd->port_status & PORT_C_MASK) != 0)
2206
		usb_hcd_poll_rh_status(hcd);
L
Linus Torvalds 已提交
2207 2208 2209
	return retval;
}

2210
static int dummy_bus_suspend(struct usb_hcd *hcd)
2211
{
2212
	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2213

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

2216 2217 2218
	spin_lock_irq(&dum_hcd->dum->lock);
	dum_hcd->rh_state = DUMMY_RH_SUSPENDED;
	set_link_state(dum_hcd);
2219
	hcd->state = HC_STATE_SUSPENDED;
2220
	spin_unlock_irq(&dum_hcd->dum->lock);
2221 2222 2223
	return 0;
}

2224
static int dummy_bus_resume(struct usb_hcd *hcd)
2225
{
2226
	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2227 2228
	int rc = 0;

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

2231
	spin_lock_irq(&dum_hcd->dum->lock);
2232
	if (!HCD_HW_ACCESSIBLE(hcd)) {
2233
		rc = -ESHUTDOWN;
2234
	} else {
2235 2236 2237 2238
		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);
2239 2240
		hcd->state = HC_STATE_RUNNING;
	}
2241
	spin_unlock_irq(&dum_hcd->dum->lock);
2242
	return rc;
2243
}
L
Linus Torvalds 已提交
2244 2245 2246

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

2247
static inline ssize_t show_urb(char *buf, size_t size, struct urb *urb)
L
Linus Torvalds 已提交
2248
{
2249
	int ep = usb_pipeendpoint(urb->pipe);
L
Linus Torvalds 已提交
2250

2251
	return snprintf(buf, size,
L
Linus Torvalds 已提交
2252 2253 2254
		"urb/%p %s ep%d%s%s len %d/%d\n",
		urb,
		({ char *s;
2255 2256
		switch (urb->dev->speed) {
		case USB_SPEED_LOW:
T
Tatyana Brokhman 已提交
2257 2258
			s = "ls";
			break;
2259
		case USB_SPEED_FULL:
T
Tatyana Brokhman 已提交
2260 2261
			s = "fs";
			break;
2262
		case USB_SPEED_HIGH:
T
Tatyana Brokhman 已提交
2263 2264
			s = "hs";
			break;
2265
		case USB_SPEED_SUPER:
2266 2267
			s = "ss";
			break;
2268
		default:
T
Tatyana Brokhman 已提交
2269 2270
			s = "?";
			break;
J
Joe Perches 已提交
2271
		 } s; }),
2272
		ep, ep ? (usb_pipein(urb->pipe) ? "in" : "out") : "",
L
Linus Torvalds 已提交
2273
		({ char *s; \
2274 2275
		switch (usb_pipetype(urb->pipe)) { \
		case PIPE_CONTROL: \
T
Tatyana Brokhman 已提交
2276 2277
			s = ""; \
			break; \
2278
		case PIPE_BULK: \
T
Tatyana Brokhman 已提交
2279 2280
			s = "-bulk"; \
			break; \
2281
		case PIPE_INTERRUPT: \
T
Tatyana Brokhman 已提交
2282 2283
			s = "-int"; \
			break; \
2284
		default: \
T
Tatyana Brokhman 已提交
2285 2286
			s = "-iso"; \
			break; \
J
Joe Perches 已提交
2287
		} s; }),
L
Linus Torvalds 已提交
2288 2289 2290
		urb->actual_length, urb->transfer_buffer_length);
}

2291
static ssize_t urbs_show(struct device *dev, struct device_attribute *attr,
2292
		char *buf)
L
Linus Torvalds 已提交
2293
{
2294
	struct usb_hcd		*hcd = dev_get_drvdata(dev);
2295
	struct dummy_hcd	*dum_hcd = hcd_to_dummy_hcd(hcd);
L
Linus Torvalds 已提交
2296 2297 2298 2299
	struct urbp		*urbp;
	size_t			size = 0;
	unsigned long		flags;

2300 2301
	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
	list_for_each_entry(urbp, &dum_hcd->urbp_list, urbp_list) {
L
Linus Torvalds 已提交
2302 2303
		size_t		temp;

2304
		temp = show_urb(buf, PAGE_SIZE - size, urbp->urb);
L
Linus Torvalds 已提交
2305 2306 2307
		buf += temp;
		size += temp;
	}
2308
	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
L
Linus Torvalds 已提交
2309 2310 2311

	return size;
}
2312
static DEVICE_ATTR_RO(urbs);
L
Linus Torvalds 已提交
2313

2314 2315 2316 2317 2318 2319
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;
2320
	dum_hcd->stream_en_ep = 0;
2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333
	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);
}

2334
static int dummy_start(struct usb_hcd *hcd)
L
Linus Torvalds 已提交
2335
{
2336
	struct dummy_hcd	*dum_hcd = hcd_to_dummy_hcd(hcd);
L
Linus Torvalds 已提交
2337 2338 2339 2340 2341 2342

	/*
	 * 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.
	 */
2343 2344 2345
	if (!usb_hcd_is_primary_hcd(hcd))
		return dummy_start_ss(dum_hcd);

2346 2347 2348 2349 2350
	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;
L
Linus Torvalds 已提交
2351

2352
	INIT_LIST_HEAD(&dum_hcd->urbp_list);
L
Linus Torvalds 已提交
2353

2354
	hcd->power_budget = POWER_BUDGET;
L
Linus Torvalds 已提交
2355
	hcd->state = HC_STATE_RUNNING;
2356
	hcd->uses_new_polling = 1;
L
Linus Torvalds 已提交
2357

2358 2359 2360 2361
#ifdef CONFIG_USB_OTG
	hcd->self.otg_port = 1;
#endif

L
Linus Torvalds 已提交
2362
	/* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
2363
	return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
L
Linus Torvalds 已提交
2364 2365
}

2366
static void dummy_stop(struct usb_hcd *hcd)
L
Linus Torvalds 已提交
2367 2368 2369
{
	struct dummy		*dum;

2370
	dum = hcd_to_dummy_hcd(hcd)->dum;
2371 2372
	device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd)), &dev_attr_urbs);
	dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n");
L
Linus Torvalds 已提交
2373 2374 2375 2376
}

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

2377
static int dummy_h_get_frame(struct usb_hcd *hcd)
L
Linus Torvalds 已提交
2378
{
2379
	return dummy_g_get_frame(NULL);
L
Linus Torvalds 已提交
2380 2381
}

2382 2383
static int dummy_setup(struct usb_hcd *hcd)
{
2384 2385 2386
	struct dummy *dum;

	dum = *((void **)dev_get_platdata(hcd->self.controller));
2387
	hcd->self.sg_tablesize = ~0;
2388
	if (usb_hcd_is_primary_hcd(hcd)) {
2389 2390
		dum->hs_hcd = hcd_to_dummy_hcd(hcd);
		dum->hs_hcd->dum = dum;
2391 2392 2393 2394 2395
		/*
		 * Mark the first roothub as being USB 2.0.
		 * The USB 3.0 roothub will be registered later by
		 * dummy_hcd_probe()
		 */
2396 2397
		hcd->speed = HCD_USB2;
		hcd->self.root_hub->speed = USB_SPEED_HIGH;
2398
	} else {
2399 2400
		dum->ss_hcd = hcd_to_dummy_hcd(hcd);
		dum->ss_hcd->dum = dum;
2401 2402
		hcd->speed = HCD_USB3;
		hcd->self.root_hub->speed = USB_SPEED_SUPER;
2403 2404 2405 2406
	}
	return 0;
}

2407
/* Change a group of bulk endpoints to support multiple stream IDs */
2408
static int dummy_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
2409 2410 2411
	struct usb_host_endpoint **eps, unsigned int num_eps,
	unsigned int num_streams, gfp_t mem_flags)
{
2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451
	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;
2452 2453 2454
}

/* Reverts a group of bulk endpoints back to not using stream IDs. */
2455
static int dummy_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
2456 2457 2458
	struct usb_host_endpoint **eps, unsigned int num_eps,
	gfp_t mem_flags)
{
2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483
	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;
2484 2485 2486
}

static struct hc_driver dummy_hcd = {
L
Linus Torvalds 已提交
2487 2488
	.description =		(char *) driver_name,
	.product_desc =		"Dummy host controller",
2489
	.hcd_priv_size =	sizeof(struct dummy_hcd),
L
Linus Torvalds 已提交
2490

2491
	.flags =		HCD_USB3 | HCD_SHARED,
L
Linus Torvalds 已提交
2492

2493
	.reset =		dummy_setup,
L
Linus Torvalds 已提交
2494 2495 2496
	.start =		dummy_start,
	.stop =			dummy_stop,

2497 2498
	.urb_enqueue =		dummy_urb_enqueue,
	.urb_dequeue =		dummy_urb_dequeue,
L
Linus Torvalds 已提交
2499

2500
	.get_frame_number =	dummy_h_get_frame,
L
Linus Torvalds 已提交
2501

2502 2503
	.hub_status_data =	dummy_hub_status,
	.hub_control =		dummy_hub_control,
2504 2505
	.bus_suspend =		dummy_bus_suspend,
	.bus_resume =		dummy_bus_resume,
2506 2507 2508

	.alloc_streams =	dummy_alloc_streams,
	.free_streams =		dummy_free_streams,
L
Linus Torvalds 已提交
2509 2510
};

2511
static int dummy_hcd_probe(struct platform_device *pdev)
L
Linus Torvalds 已提交
2512
{
2513
	struct dummy		*dum;
2514
	struct usb_hcd		*hs_hcd;
2515
	struct usb_hcd		*ss_hcd;
L
Linus Torvalds 已提交
2516 2517
	int			retval;

2518
	dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
2519
	dum = *((void **)dev_get_platdata(&pdev->dev));
L
Linus Torvalds 已提交
2520

2521 2522
	if (!mod_data.is_super_speed)
		dummy_hcd.flags = HCD_USB2;
2523 2524
	hs_hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, dev_name(&pdev->dev));
	if (!hs_hcd)
L
Linus Torvalds 已提交
2525
		return -ENOMEM;
2526
	hs_hcd->has_tt = 1;
L
Linus Torvalds 已提交
2527

2528
	retval = usb_add_hcd(hs_hcd, 0, 0);
2529 2530
	if (retval)
		goto put_usb2_hcd;
2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548

	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:
2549 2550
	usb_remove_hcd(hs_hcd);
put_usb2_hcd:
2551
	usb_put_hcd(hs_hcd);
2552
	dum->hs_hcd = dum->ss_hcd = NULL;
L
Linus Torvalds 已提交
2553 2554 2555
	return retval;
}

2556
static int dummy_hcd_remove(struct platform_device *pdev)
L
Linus Torvalds 已提交
2557
{
2558 2559
	struct dummy		*dum;

2560
	dum = hcd_to_dummy_hcd(platform_get_drvdata(pdev))->dum;
2561 2562 2563 2564 2565 2566

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

2567 2568
	usb_remove_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
	usb_put_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2569

2570 2571
	dum->hs_hcd = NULL;
	dum->ss_hcd = NULL;
L
Linus Torvalds 已提交
2572

2573
	return 0;
L
Linus Torvalds 已提交
2574 2575
}

2576
static int dummy_hcd_suspend(struct platform_device *pdev, pm_message_t state)
2577 2578
{
	struct usb_hcd		*hcd;
2579
	struct dummy_hcd	*dum_hcd;
2580
	int			rc = 0;
2581

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

2584
	hcd = platform_get_drvdata(pdev);
2585 2586
	dum_hcd = hcd_to_dummy_hcd(hcd);
	if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
2587 2588 2589 2590 2591
		dev_warn(&pdev->dev, "Root hub isn't suspended!\n");
		rc = -EBUSY;
	} else
		clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
	return rc;
2592 2593
}

2594
static int dummy_hcd_resume(struct platform_device *pdev)
2595 2596 2597
{
	struct usb_hcd		*hcd;

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

2600
	hcd = platform_get_drvdata(pdev);
2601
	set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2602
	usb_hcd_poll_rh_status(hcd);
2603 2604 2605
	return 0;
}

2606
static struct platform_driver dummy_hcd_driver = {
2607 2608
	.probe		= dummy_hcd_probe,
	.remove		= dummy_hcd_remove,
2609 2610
	.suspend	= dummy_hcd_suspend,
	.resume		= dummy_hcd_resume,
2611 2612 2613
	.driver		= {
		.name	= (char *) driver_name,
	},
2614
};
L
Linus Torvalds 已提交
2615

2616
/*-------------------------------------------------------------------------*/
2617
#define MAX_NUM_UDC	2
2618 2619
static struct platform_device *the_udc_pdev[MAX_NUM_UDC];
static struct platform_device *the_hcd_pdev[MAX_NUM_UDC];
L
Linus Torvalds 已提交
2620

2621
static int __init init(void)
L
Linus Torvalds 已提交
2622
{
2623
	int	retval = -ENOMEM;
2624
	int	i;
2625
	struct	dummy *dum[MAX_NUM_UDC];
L
Linus Torvalds 已提交
2626

2627
	if (usb_disabled())
L
Linus Torvalds 已提交
2628
		return -ENODEV;
2629

2630 2631 2632
	if (!mod_data.is_high_speed && mod_data.is_super_speed)
		return -EINVAL;

2633
	if (mod_data.num < 1 || mod_data.num > MAX_NUM_UDC) {
2634
		pr_err("Number of emulated UDC must be in range of 1...%d\n",
2635 2636 2637
				MAX_NUM_UDC);
		return -EINVAL;
	}
2638

2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
	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;
		}
	}
2657 2658
	for (i = 0; i < mod_data.num; i++) {
		dum[i] = kzalloc(sizeof(struct dummy), GFP_KERNEL);
2659 2660
		if (!dum[i]) {
			retval = -ENOMEM;
2661
			goto err_add_pdata;
2662
		}
2663 2664 2665 2666 2667 2668 2669 2670 2671
		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;
	}
2672

2673 2674
	retval = platform_driver_register(&dummy_hcd_driver);
	if (retval < 0)
2675
		goto err_add_pdata;
2676
	retval = platform_driver_register(&dummy_udc_driver);
2677 2678 2679
	if (retval < 0)
		goto err_register_udc_driver;

2680 2681 2682 2683 2684 2685 2686 2687 2688
	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;
		}
	}
2689 2690 2691 2692 2693 2694 2695 2696 2697 2698
	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;
		}
2699
	}
2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719

	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;
		}
2720
	}
2721 2722
	return retval;

2723
err_probe_udc:
2724 2725
	for (i = 0; i < mod_data.num; i++)
		platform_device_del(the_udc_pdev[i]);
2726
err_add_udc:
2727 2728
	for (i = 0; i < mod_data.num; i++)
		platform_device_del(the_hcd_pdev[i]);
2729 2730
err_add_hcd:
	platform_driver_unregister(&dummy_udc_driver);
2731
err_register_udc_driver:
2732
	platform_driver_unregister(&dummy_hcd_driver);
2733 2734 2735
err_add_pdata:
	for (i = 0; i < mod_data.num; i++)
		kfree(dum[i]);
2736 2737
	for (i = 0; i < mod_data.num; i++)
		platform_device_put(the_udc_pdev[i]);
2738
err_alloc_udc:
2739 2740
	for (i = 0; i < mod_data.num; i++)
		platform_device_put(the_hcd_pdev[i]);
L
Linus Torvalds 已提交
2741 2742
	return retval;
}
2743
module_init(init);
L
Linus Torvalds 已提交
2744

2745
static void __exit cleanup(void)
L
Linus Torvalds 已提交
2746
{
2747 2748 2749
	int i;

	for (i = 0; i < mod_data.num; i++) {
2750 2751 2752 2753
		struct dummy *dum;

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

2754 2755
		platform_device_unregister(the_udc_pdev[i]);
		platform_device_unregister(the_hcd_pdev[i]);
2756
		kfree(dum);
2757
	}
2758 2759
	platform_driver_unregister(&dummy_udc_driver);
	platform_driver_unregister(&dummy_hcd_driver);
L
Linus Torvalds 已提交
2760
}
2761
module_exit(cleanup);