1	// SPDX-License-Identifier: GPL-2.0+
2	/*
3	* dummy_hcd.c -- Dummy/Loopback USB host and device emulator driver.
4	*
5	* Maintainer: Alan Stern <stern@rowland.harvard.edu>
6	*
7	* Copyright (C) 2003 David Brownell
8	* Copyright (C) 2003-2005 Alan Stern
9	*/
10
11
12	/*
13	* This exposes a device side "USB gadget" API, driven by requests to a
14	* Linux-USB host controller driver. USB traffic is simulated; there's
15	* no need for USB hardware. Use this with two other drivers:
16	*
17	* - Gadget driver, responding to requests (device);
18	* - Host-side device driver, as already familiar in Linux.
19	*
20	* Having this all in one kernel can help some stages of development,
21	* bypassing some hardware (and driver) issues. UML could help too.
22	*
23	* Note: The emulation does not include isochronous transfers!
24	*/
25
26	#include <linux/module.h>
27	#include <linux/kernel.h>
28	#include <linux/delay.h>
29	#include <linux/ioport.h>
30	#include <linux/slab.h>
31	#include <linux/errno.h>
32	#include <linux/init.h>
33	#include <linux/timer.h>
34	#include <linux/list.h>
35	#include <linux/interrupt.h>
36	#include <linux/platform_device.h>
37	#include <linux/usb.h>
38	#include <linux/usb/gadget.h>
39	#include <linux/usb/hcd.h>
40	#include <linux/scatterlist.h>
41
42	#include <asm/byteorder.h>
43	#include <linux/io.h>
44	#include <asm/irq.h>
45	#include <asm/unaligned.h>
46
47	#define DRIVER_DESC "USB Host+Gadget Emulator"
48	#define DRIVER_VERSION "02 May 2005"
49
50	#define POWER_BUDGET 500 /* in mA; use 8 for low-power port testing */
51	#define POWER_BUDGET_3 900 /* in mA */
52
53	static const char driver_name[] = "dummy_hcd";
54	static const char driver_desc[] = "USB Host+Gadget Emulator";
55
56	static const char gadget_name[] = "dummy_udc";
57
58	MODULE_DESCRIPTION(DRIVER_DESC);
59	MODULE_AUTHOR("David Brownell");
60	MODULE_LICENSE("GPL");
61
62	struct dummy_hcd_module_parameters {
63	bool is_super_speed;
64	bool is_high_speed;
65	unsigned int num;
66	};
67
68	static struct dummy_hcd_module_parameters mod_data = {
69	.is_super_speed = false,
70	.is_high_speed = true,
71	.num = 1,
72	};
73	module_param_named(is_super_speed, mod_data.is_super_speed, bool, S_IRUGO);
74	MODULE_PARM_DESC(is_super_speed, "true to simulate SuperSpeed connection");
75	module_param_named(is_high_speed, mod_data.is_high_speed, bool, S_IRUGO);
76	MODULE_PARM_DESC(is_high_speed, "true to simulate HighSpeed connection");
77	module_param_named(num, mod_data.num, uint, S_IRUGO);
78	MODULE_PARM_DESC(num, "number of emulated controllers");
79	/*-------------------------------------------------------------------------*/
80
81	/* gadget side driver data structres */
82	struct dummy_ep {
83	struct list_head queue;
84	unsigned long last_io; /* jiffies timestamp */
85	struct usb_gadget *gadget;
86	const struct usb_endpoint_descriptor *desc;
87	struct usb_ep ep;
88	unsigned halted:1;
89	unsigned wedged:1;
90	unsigned already_seen:1;
91	unsigned setup_stage:1;
92	unsigned stream_en:1;
93	};
94
95	struct dummy_request {
96	struct list_head queue; /* ep's requests */
97	struct usb_request req;
98	};
99
100	static inline struct dummy_ep *usb_ep_to_dummy_ep(struct usb_ep *_ep)
101	{
102	return container_of(_ep, struct dummy_ep, ep);
103	}
104
105	static inline struct dummy_request *usb_request_to_dummy_request
106	(struct usb_request *_req)
107	{
108	return container_of(_req, struct dummy_request, req);
109	}
110
111	/*-------------------------------------------------------------------------*/
112
113	/*
114	* Every device has ep0 for control requests, plus up to 30 more endpoints,
115	* in one of two types:
116	*
117	* - Configurable: direction (in/out), type (bulk, iso, etc), and endpoint
118	* number can be changed. Names like "ep-a" are used for this type.
119	*
120	* - Fixed Function: in other cases. some characteristics may be mutable;
121	* that'd be hardware-specific. Names like "ep12out-bulk" are used.
122	*
123	* Gadget drivers are responsible for not setting up conflicting endpoint
124	* configurations, illegal or unsupported packet lengths, and so on.
125	*/
126
127	static const char ep0name[] = "ep0";
128
129	static const struct {
130	const char *name;
131	const struct usb_ep_caps caps;
132	} ep_info[] = {
133	#define EP_INFO(_name, _caps) \
134	{ \
135	.name = _name, \
136	.caps = _caps, \
137	}
138
139	/* we don't provide isochronous endpoints since we don't support them */
140	#define TYPE_BULK_OR_INT (USB_EP_CAPS_TYPE_BULK | USB_EP_CAPS_TYPE_INT)
141
142	/* everyone has ep0 */
143	EP_INFO(ep0name,
144	USB_EP_CAPS(USB_EP_CAPS_TYPE_CONTROL, USB_EP_CAPS_DIR_ALL)),
145	/* act like a pxa250: fifteen fixed function endpoints */
146	EP_INFO("ep1in-bulk",
147	USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
148	EP_INFO("ep2out-bulk",
149	USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
150	/*
151	EP_INFO("ep3in-iso",
152	USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_IN)),
153	EP_INFO("ep4out-iso",
154	USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_OUT)),
155	*/
156	EP_INFO("ep5in-int",
157	USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)),
158	EP_INFO("ep6in-bulk",
159	USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
160	EP_INFO("ep7out-bulk",
161	USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
162	/*
163	EP_INFO("ep8in-iso",
164	USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_IN)),
165	EP_INFO("ep9out-iso",
166	USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_OUT)),
167	*/
168	EP_INFO("ep10in-int",
169	USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)),
170	EP_INFO("ep11in-bulk",
171	USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
172	EP_INFO("ep12out-bulk",
173	USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
174	/*
175	EP_INFO("ep13in-iso",
176	USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_IN)),
177	EP_INFO("ep14out-iso",
178	USB_EP_CAPS(USB_EP_CAPS_TYPE_ISO, USB_EP_CAPS_DIR_OUT)),
179	*/
180	EP_INFO("ep15in-int",
181	USB_EP_CAPS(USB_EP_CAPS_TYPE_INT, USB_EP_CAPS_DIR_IN)),
182
183	/* or like sa1100: two fixed function endpoints */
184	EP_INFO("ep1out-bulk",
185	USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_OUT)),
186	EP_INFO("ep2in-bulk",
187	USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK, USB_EP_CAPS_DIR_IN)),
188
189	/* and now some generic EPs so we have enough in multi config */
190	EP_INFO("ep-aout",
191	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
192	EP_INFO("ep-bin",
193	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
194	EP_INFO("ep-cout",
195	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
196	EP_INFO("ep-dout",
197	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
198	EP_INFO("ep-ein",
199	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
200	EP_INFO("ep-fout",
201	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
202	EP_INFO("ep-gin",
203	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
204	EP_INFO("ep-hout",
205	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
206	EP_INFO("ep-iout",
207	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
208	EP_INFO("ep-jin",
209	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
210	EP_INFO("ep-kout",
211	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
212	EP_INFO("ep-lin",
213	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_IN)),
214	EP_INFO("ep-mout",
215	USB_EP_CAPS(TYPE_BULK_OR_INT, USB_EP_CAPS_DIR_OUT)),
216
217	#undef EP_INFO
218	};
219
220	#define DUMMY_ENDPOINTS ARRAY_SIZE(ep_info)
221
222	/*-------------------------------------------------------------------------*/
223
224	#define FIFO_SIZE 64
225
226	struct urbp {
227	struct urb *urb;
228	struct list_head urbp_list;
229	struct sg_mapping_iter miter;
230	u32 miter_started;
231	};
232
233
234	enum dummy_rh_state {
235	DUMMY_RH_RESET,
236	DUMMY_RH_SUSPENDED,
237	DUMMY_RH_RUNNING
238	};
239
240	struct dummy_hcd {
241	struct dummy *dum;
242	enum dummy_rh_state rh_state;
243	struct timer_list timer;
244	u32 port_status;
245	u32 old_status;
246	unsigned long re_timeout;
247
248	struct usb_device *udev;
249	struct list_head urbp_list;
250	struct urbp *next_frame_urbp;
251
252	u32 stream_en_ep;
253	u8 num_stream[30 / 2];
254
255	unsigned active:1;
256	unsigned old_active:1;
257	unsigned resuming:1;
258	};
259
260	struct dummy {
261	spinlock_t lock;
262
263	/*
264	* DEVICE/GADGET side support
265	*/
266	struct dummy_ep ep[DUMMY_ENDPOINTS];
267	int address;
268	int callback_usage;
269	struct usb_gadget gadget;
270	struct usb_gadget_driver *driver;
271	struct dummy_request fifo_req;
272	u8 fifo_buf[FIFO_SIZE];
273	u16 devstatus;
274	unsigned ints_enabled:1;
275	unsigned udc_suspended:1;
276	unsigned pullup:1;
277
278	/*
279	* HOST side support
280	*/
281	struct dummy_hcd *hs_hcd;
282	struct dummy_hcd *ss_hcd;
283	};
284
285	static inline struct dummy_hcd *hcd_to_dummy_hcd(struct usb_hcd *hcd)
286	{
287	return (struct dummy_hcd *) (hcd->hcd_priv);
288	}
289
290	static inline struct usb_hcd *dummy_hcd_to_hcd(struct dummy_hcd *dum)
291	{
292	return container_of((void *) dum, struct usb_hcd, hcd_priv);
293	}
294
295	static inline struct device *dummy_dev(struct dummy_hcd *dum)
296	{
297	return dummy_hcd_to_hcd(dum)->self.controller;
298	}
299
300	static inline struct device *udc_dev(struct dummy *dum)
301	{
302	return dum->gadget.dev.parent;
303	}
304
305	static inline struct dummy *ep_to_dummy(struct dummy_ep *ep)
306	{
307	return container_of(ep->gadget, struct dummy, gadget);
308	}
309
310	static inline struct dummy_hcd *gadget_to_dummy_hcd(struct usb_gadget *gadget)
311	{
312	struct dummy *dum = container_of(gadget, struct dummy, gadget);
313	if (dum->gadget.speed == USB_SPEED_SUPER)
314	return dum->ss_hcd;
315	else
316	return dum->hs_hcd;
317	}
318
319	static inline struct dummy *gadget_dev_to_dummy(struct device *dev)
320	{
321	return container_of(dev, struct dummy, gadget.dev);
322	}
323
324	/*-------------------------------------------------------------------------*/
325
326	/* DEVICE/GADGET SIDE UTILITY ROUTINES */
327
328	/* called with spinlock held */
329	static void nuke(struct dummy *dum, struct dummy_ep *ep)
330	{
331	while (!list_empty(head: &ep->queue)) {
332	struct dummy_request *req;
333
334	req = list_entry(ep->queue.next, struct dummy_request, queue);
335	list_del_init(entry: &req->queue);
336	req->req.status = -ESHUTDOWN;
337
338	spin_unlock(lock: &dum->lock);
339	usb_gadget_giveback_request(ep: &ep->ep, req: &req->req);
340	spin_lock(lock: &dum->lock);
341	}
342	}
343
344	/* caller must hold lock */
345	static void stop_activity(struct dummy *dum)
346	{
347	int i;
348
349	/* prevent any more requests */
350	dum->address = 0;
351
352	/* The timer is left running so that outstanding URBs can fail */
353
354	/* nuke any pending requests first, so driver i/o is quiesced */
355	for (i = 0; i < DUMMY_ENDPOINTS; ++i)
356	nuke(dum, ep: &dum->ep[i]);
357
358	/* driver now does any non-usb quiescing necessary */
359	}
360
361	/**
362	* set_link_state_by_speed() - Sets the current state of the link according to
363	* the hcd speed
364	* @dum_hcd: pointer to the dummy_hcd structure to update the link state for
365	*
366	* This function updates the port_status according to the link state and the
367	* speed of the hcd.
368	*/
369	static void set_link_state_by_speed(struct dummy_hcd *dum_hcd)
370	{
371	struct dummy *dum = dum_hcd->dum;
372
373	if (dummy_hcd_to_hcd(dum: dum_hcd)->speed == HCD_USB3) {
374	if ((dum_hcd->port_status & USB_SS_PORT_STAT_POWER) == 0) {
375	dum_hcd->port_status = 0;
376	} else if (!dum->pullup || dum->udc_suspended) {
377	/* UDC suspend must cause a disconnect */
378	dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
379	USB_PORT_STAT_ENABLE);
380	if ((dum_hcd->old_status &
381	USB_PORT_STAT_CONNECTION) != 0)
382	dum_hcd->port_status |=
383	(USB_PORT_STAT_C_CONNECTION << 16);
384	} else {
385	/* device is connected and not suspended */
386	dum_hcd->port_status |= (USB_PORT_STAT_CONNECTION |
387	USB_PORT_STAT_SPEED_5GBPS) ;
388	if ((dum_hcd->old_status &
389	USB_PORT_STAT_CONNECTION) == 0)
390	dum_hcd->port_status |=
391	(USB_PORT_STAT_C_CONNECTION << 16);
392	if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) &&
393	(dum_hcd->port_status &
394	USB_PORT_STAT_LINK_STATE) == USB_SS_PORT_LS_U0 &&
395	dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
396	dum_hcd->active = 1;
397	}
398	} else {
399	if ((dum_hcd->port_status & USB_PORT_STAT_POWER) == 0) {
400	dum_hcd->port_status = 0;
401	} else if (!dum->pullup || dum->udc_suspended) {
402	/* UDC suspend must cause a disconnect */
403	dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
404	USB_PORT_STAT_ENABLE |
405	USB_PORT_STAT_LOW_SPEED |
406	USB_PORT_STAT_HIGH_SPEED |
407	USB_PORT_STAT_SUSPEND);
408	if ((dum_hcd->old_status &
409	USB_PORT_STAT_CONNECTION) != 0)
410	dum_hcd->port_status |=
411	(USB_PORT_STAT_C_CONNECTION << 16);
412	} else {
413	dum_hcd->port_status |= USB_PORT_STAT_CONNECTION;
414	if ((dum_hcd->old_status &
415	USB_PORT_STAT_CONNECTION) == 0)
416	dum_hcd->port_status |=
417	(USB_PORT_STAT_C_CONNECTION << 16);
418	if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0)
419	dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
420	else if ((dum_hcd->port_status &
421	USB_PORT_STAT_SUSPEND) == 0 &&
422	dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
423	dum_hcd->active = 1;
424	}
425	}
426	}
427
428	/* caller must hold lock */
429	static void set_link_state(struct dummy_hcd *dum_hcd)
430	__must_hold(&dum->lock)
431	{
432	struct dummy *dum = dum_hcd->dum;
433	unsigned int power_bit;
434
435	dum_hcd->active = 0;
436	if (dum->pullup)
437	if ((dummy_hcd_to_hcd(dum: dum_hcd)->speed == HCD_USB3 &&
438	dum->gadget.speed != USB_SPEED_SUPER) ||
439	(dummy_hcd_to_hcd(dum: dum_hcd)->speed != HCD_USB3 &&
440	dum->gadget.speed == USB_SPEED_SUPER))
441	return;
442
443	set_link_state_by_speed(dum_hcd);
444	power_bit = (dummy_hcd_to_hcd(dum: dum_hcd)->speed == HCD_USB3 ?
445	USB_SS_PORT_STAT_POWER : USB_PORT_STAT_POWER);
446
447	if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0 ||
448	dum_hcd->active)
449	dum_hcd->resuming = 0;
450
451	/* Currently !connected or in reset */
452	if ((dum_hcd->port_status & power_bit) == 0 ||
453	(dum_hcd->port_status & USB_PORT_STAT_RESET) != 0) {
454	unsigned int disconnect = power_bit &
455	dum_hcd->old_status & (~dum_hcd->port_status);
456	unsigned int reset = USB_PORT_STAT_RESET &
457	(~dum_hcd->old_status) & dum_hcd->port_status;
458
459	/* Report reset and disconnect events to the driver */
460	if (dum->ints_enabled && (disconnect || reset)) {
461	stop_activity(dum);
462	++dum->callback_usage;
463	spin_unlock(lock: &dum->lock);
464	if (reset)
465	usb_gadget_udc_reset(gadget: &dum->gadget, driver: dum->driver);
466	else
467	dum->driver->disconnect(&dum->gadget);
468	spin_lock(lock: &dum->lock);
469	--dum->callback_usage;
470	}
471	} else if (dum_hcd->active != dum_hcd->old_active &&
472	dum->ints_enabled) {
473	++dum->callback_usage;
474	spin_unlock(lock: &dum->lock);
475	if (dum_hcd->old_active && dum->driver->suspend)
476	dum->driver->suspend(&dum->gadget);
477	else if (!dum_hcd->old_active && dum->driver->resume)
478	dum->driver->resume(&dum->gadget);
479	spin_lock(lock: &dum->lock);
480	--dum->callback_usage;
481	}
482
483	dum_hcd->old_status = dum_hcd->port_status;
484	dum_hcd->old_active = dum_hcd->active;
485	}
486
487	/*-------------------------------------------------------------------------*/
488
489	/* DEVICE/GADGET SIDE DRIVER
490	*
491	* This only tracks gadget state. All the work is done when the host
492	* side tries some (emulated) i/o operation. Real device controller
493	* drivers would do real i/o using dma, fifos, irqs, timers, etc.
494	*/
495
496	#define is_enabled(dum) \
497	(dum->port_status & USB_PORT_STAT_ENABLE)
498
499	static int dummy_enable(struct usb_ep *_ep,
500	const struct usb_endpoint_descriptor *desc)
501	{
502	struct dummy *dum;
503	struct dummy_hcd *dum_hcd;
504	struct dummy_ep *ep;
505	unsigned max;
506	int retval;
507
508	ep = usb_ep_to_dummy_ep(_ep);
509	if (!_ep || !desc || ep->desc || _ep->name == ep0name
510	|| desc->bDescriptorType != USB_DT_ENDPOINT)
511	return -EINVAL;
512	dum = ep_to_dummy(ep);
513	if (!dum->driver)
514	return -ESHUTDOWN;
515
516	dum_hcd = gadget_to_dummy_hcd(gadget: &dum->gadget);
517	if (!is_enabled(dum_hcd))
518	return -ESHUTDOWN;
519
520	/*
521	* For HS/FS devices only bits 0..10 of the wMaxPacketSize represent the
522	* maximum packet size.
523	* For SS devices the wMaxPacketSize is limited by 1024.
524	*/
525	max = usb_endpoint_maxp(epd: desc);
526
527	/* drivers must not request bad settings, since lower levels
528	* (hardware or its drivers) may not check. some endpoints
529	* can't do iso, many have maxpacket limitations, etc.
530	*
531	* since this "hardware" driver is here to help debugging, we
532	* have some extra sanity checks. (there could be more though,
533	* especially for "ep9out" style fixed function ones.)
534	*/
535	retval = -EINVAL;
536	switch (usb_endpoint_type(epd: desc)) {
537	case USB_ENDPOINT_XFER_BULK:
538	if (strstr(ep->ep.name, "-iso")
539	|| strstr(ep->ep.name, "-int")) {
540	goto done;
541	}
542	switch (dum->gadget.speed) {
543	case USB_SPEED_SUPER:
544	if (max == 1024)
545	break;
546	goto done;
547	case USB_SPEED_HIGH:
548	if (max == 512)
549	break;
550	goto done;
551	case USB_SPEED_FULL:
552	if (max == 8 || max == 16 || max == 32 || max == 64)
553	/* we'll fake any legal size */
554	break;
555	/* save a return statement */
556	fallthrough;
557	default:
558	goto done;
559	}
560	break;
561	case USB_ENDPOINT_XFER_INT:
562	if (strstr(ep->ep.name, "-iso")) /* bulk is ok */
563	goto done;
564	/* real hardware might not handle all packet sizes */
565	switch (dum->gadget.speed) {
566	case USB_SPEED_SUPER:
567	case USB_SPEED_HIGH:
568	if (max <= 1024)
569	break;
570	/* save a return statement */
571	fallthrough;
572	case USB_SPEED_FULL:
573	if (max <= 64)
574	break;
575	/* save a return statement */
576	fallthrough;
577	default:
578	if (max <= 8)
579	break;
580	goto done;
581	}
582	break;
583	case USB_ENDPOINT_XFER_ISOC:
584	if (strstr(ep->ep.name, "-bulk")
585	|| strstr(ep->ep.name, "-int"))
586	goto done;
587	/* real hardware might not handle all packet sizes */
588	switch (dum->gadget.speed) {
589	case USB_SPEED_SUPER:
590	case USB_SPEED_HIGH:
591	if (max <= 1024)
592	break;
593	/* save a return statement */
594	fallthrough;
595	case USB_SPEED_FULL:
596	if (max <= 1023)
597	break;
598	/* save a return statement */
599	fallthrough;
600	default:
601	goto done;
602	}
603	break;
604	default:
605	/* few chips support control except on ep0 */
606	goto done;
607	}
608
609	_ep->maxpacket = max;
610	if (usb_ss_max_streams(comp: _ep->comp_desc)) {
611	if (!usb_endpoint_xfer_bulk(epd: desc)) {
612	dev_err(udc_dev(dum), "Can't enable stream support on "
613	"non-bulk ep %s\n", _ep->name);
614	return -EINVAL;
615	}
616	ep->stream_en = 1;
617	}
618	ep->desc = desc;
619
620	dev_dbg(udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d stream %s\n",
621	_ep->name,
622	desc->bEndpointAddress & 0x0f,
623	(desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
624	usb_ep_type_string(usb_endpoint_type(desc)),
625	max, ep->stream_en ? "enabled" : "disabled");
626
627	/* at this point real hardware should be NAKing transfers
628	* to that endpoint, until a buffer is queued to it.
629	*/
630	ep->halted = ep->wedged = 0;
631	retval = 0;
632	done:
633	return retval;
634	}
635
636	static int dummy_disable(struct usb_ep *_ep)
637	{
638	struct dummy_ep *ep;
639	struct dummy *dum;
640	unsigned long flags;
641
642	ep = usb_ep_to_dummy_ep(_ep);
643	if (!_ep || !ep->desc || _ep->name == ep0name)
644	return -EINVAL;
645	dum = ep_to_dummy(ep);
646
647	spin_lock_irqsave(&dum->lock, flags);
648	ep->desc = NULL;
649	ep->stream_en = 0;
650	nuke(dum, ep);
651	spin_unlock_irqrestore(lock: &dum->lock, flags);
652
653	dev_dbg(udc_dev(dum), "disabled %s\n", _ep->name);
654	return 0;
655	}
656
657	static struct usb_request *dummy_alloc_request(struct usb_ep *_ep,
658	gfp_t mem_flags)
659	{
660	struct dummy_request *req;
661
662	if (!_ep)
663	return NULL;
664
665	req = kzalloc(size: sizeof(*req), flags: mem_flags);
666	if (!req)
667	return NULL;
668	INIT_LIST_HEAD(list: &req->queue);
669	return &req->req;
670	}
671
672	static void dummy_free_request(struct usb_ep *_ep, struct usb_request *_req)
673	{
674	struct dummy_request *req;
675
676	if (!_ep || !_req) {
677	WARN_ON(1);
678	return;
679	}
680
681	req = usb_request_to_dummy_request(_req);
682	WARN_ON(!list_empty(&req->queue));
683	kfree(objp: req);
684	}
685
686	static void fifo_complete(struct usb_ep *ep, struct usb_request *req)
687	{
688	}
689
690	static int dummy_queue(struct usb_ep *_ep, struct usb_request *_req,
691	gfp_t mem_flags)
692	{
693	struct dummy_ep *ep;
694	struct dummy_request *req;
695	struct dummy *dum;
696	struct dummy_hcd *dum_hcd;
697	unsigned long flags;
698
699	req = usb_request_to_dummy_request(_req);
700	if (!_req || !list_empty(head: &req->queue) || !_req->complete)
701	return -EINVAL;
702
703	ep = usb_ep_to_dummy_ep(_ep);
704	if (!_ep || (!ep->desc && _ep->name != ep0name))
705	return -EINVAL;
706
707	dum = ep_to_dummy(ep);
708	dum_hcd = gadget_to_dummy_hcd(gadget: &dum->gadget);
709	if (!dum->driver || !is_enabled(dum_hcd))
710	return -ESHUTDOWN;
711
712	#if 0
713	dev_dbg(udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n",
714	ep, _req, _ep->name, _req->length, _req->buf);
715	#endif
716	_req->status = -EINPROGRESS;
717	_req->actual = 0;
718	spin_lock_irqsave(&dum->lock, flags);
719
720	/* implement an emulated single-request FIFO */
721	if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
722	list_empty(head: &dum->fifo_req.queue) &&
723	list_empty(head: &ep->queue) &&
724	_req->length <= FIFO_SIZE) {
725	req = &dum->fifo_req;
726	req->req = *_req;
727	req->req.buf = dum->fifo_buf;
728	memcpy(dum->fifo_buf, _req->buf, _req->length);
729	req->req.context = dum;
730	req->req.complete = fifo_complete;
731
732	list_add_tail(new: &req->queue, head: &ep->queue);
733	spin_unlock(lock: &dum->lock);
734	_req->actual = _req->length;
735	_req->status = 0;
736	usb_gadget_giveback_request(ep: _ep, req: _req);
737	spin_lock(lock: &dum->lock);
738	} else
739	list_add_tail(new: &req->queue, head: &ep->queue);
740	spin_unlock_irqrestore(lock: &dum->lock, flags);
741
742	/* real hardware would likely enable transfers here, in case
743	* it'd been left NAKing.
744	*/
745	return 0;
746	}
747
748	static int dummy_dequeue(struct usb_ep *_ep, struct usb_request *_req)
749	{
750	struct dummy_ep *ep;
751	struct dummy *dum;
752	int retval = -EINVAL;
753	unsigned long flags;
754	struct dummy_request *req = NULL, *iter;
755
756	if (!_ep || !_req)
757	return retval;
758	ep = usb_ep_to_dummy_ep(_ep);
759	dum = ep_to_dummy(ep);
760
761	if (!dum->driver)
762	return -ESHUTDOWN;
763
764	local_irq_save(flags);
765	spin_lock(lock: &dum->lock);
766	list_for_each_entry(iter, &ep->queue, queue) {
767	if (&iter->req != _req)
768	continue;
769	list_del_init(entry: &iter->queue);
770	_req->status = -ECONNRESET;
771	req = iter;
772	retval = 0;
773	break;
774	}
775	spin_unlock(lock: &dum->lock);
776
777	if (retval == 0) {
778	dev_dbg(udc_dev(dum),
779	"dequeued req %p from %s, len %d buf %p\n",
780	req, _ep->name, _req->length, _req->buf);
781	usb_gadget_giveback_request(ep: _ep, req: _req);
782	}
783	local_irq_restore(flags);
784	return retval;
785	}
786
787	static int
788	dummy_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
789	{
790	struct dummy_ep *ep;
791	struct dummy *dum;
792
793	if (!_ep)
794	return -EINVAL;
795	ep = usb_ep_to_dummy_ep(_ep);
796	dum = ep_to_dummy(ep);
797	if (!dum->driver)
798	return -ESHUTDOWN;
799	if (!value)
800	ep->halted = ep->wedged = 0;
801	else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
802	!list_empty(head: &ep->queue))
803	return -EAGAIN;
804	else {
805	ep->halted = 1;
806	if (wedged)
807	ep->wedged = 1;
808	}
809	/* FIXME clear emulated data toggle too */
810	return 0;
811	}
812
813	static int
814	dummy_set_halt(struct usb_ep *_ep, int value)
815	{
816	return dummy_set_halt_and_wedge(_ep, value, wedged: 0);
817	}
818
819	static int dummy_set_wedge(struct usb_ep *_ep)
820	{
821	if (!_ep || _ep->name == ep0name)
822	return -EINVAL;
823	return dummy_set_halt_and_wedge(_ep, value: 1, wedged: 1);
824	}
825
826	static const struct usb_ep_ops dummy_ep_ops = {
827	.enable = dummy_enable,
828	.disable = dummy_disable,
829
830	.alloc_request = dummy_alloc_request,
831	.free_request = dummy_free_request,
832
833	.queue = dummy_queue,
834	.dequeue = dummy_dequeue,
835
836	.set_halt = dummy_set_halt,
837	.set_wedge = dummy_set_wedge,
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)
844	{
845	struct timespec64 ts64;
846
847	ktime_get_ts64(ts: &ts64);
848	return ts64.tv_nsec / NSEC_PER_MSEC;
849	}
850
851	static int dummy_wakeup(struct usb_gadget *_gadget)
852	{
853	struct dummy_hcd *dum_hcd;
854
855	dum_hcd = gadget_to_dummy_hcd(gadget: _gadget);
856	if (!(dum_hcd->dum->devstatus & ((1 << USB_DEVICE_B_HNP_ENABLE)
857	| (1 << USB_DEVICE_REMOTE_WAKEUP))))
858	return -EINVAL;
859	if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0)
860	return -ENOLINK;
861	if ((dum_hcd->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
862	dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
863	return -EIO;
864
865	/* FIXME: What if the root hub is suspended but the port isn't? */
866
867	/* hub notices our request, issues downstream resume, etc */
868	dum_hcd->resuming = 1;
869	dum_hcd->re_timeout = jiffies + msecs_to_jiffies(m: 20);
870	mod_timer(timer: &dummy_hcd_to_hcd(dum: dum_hcd)->rh_timer, expires: dum_hcd->re_timeout);
871	return 0;
872	}
873
874	static int dummy_set_selfpowered(struct usb_gadget *_gadget, int value)
875	{
876	struct dummy *dum;
877
878	_gadget->is_selfpowered = (value != 0);
879	dum = gadget_to_dummy_hcd(gadget: _gadget)->dum;
880	if (value)
881	dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
882	else
883	dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
884	return 0;
885	}
886
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	dum->ep[0].ep.maxpacket = 64;
893	}
894
895	static int dummy_pullup(struct usb_gadget *_gadget, int value)
896	{
897	struct dummy_hcd *dum_hcd;
898	struct dummy *dum;
899	unsigned long flags;
900
901	dum = gadget_dev_to_dummy(dev: &_gadget->dev);
902	dum_hcd = gadget_to_dummy_hcd(gadget: _gadget);
903
904	spin_lock_irqsave(&dum->lock, flags);
905	dum->pullup = (value != 0);
906	set_link_state(dum_hcd);
907	if (value == 0) {
908	/*
909	* Emulate synchronize_irq(): wait for callbacks to finish.
910	* This seems to be the best place to emulate the call to
911	* synchronize_irq() that's in usb_gadget_remove_driver().
912	* Doing it in dummy_udc_stop() would be too late since it
913	* is called after the unbind callback and unbind shouldn't
914	* be invoked until all the other callbacks are finished.
915	*/
916	while (dum->callback_usage > 0) {
917	spin_unlock_irqrestore(lock: &dum->lock, flags);
918	usleep_range(min: 1000, max: 2000);
919	spin_lock_irqsave(&dum->lock, flags);
920	}
921	}
922	spin_unlock_irqrestore(lock: &dum->lock, flags);
923
924	usb_hcd_poll_rh_status(hcd: dummy_hcd_to_hcd(dum: dum_hcd));
925	return 0;
926	}
927
928	static void dummy_udc_set_speed(struct usb_gadget *_gadget,
929	enum usb_device_speed speed)
930	{
931	struct dummy *dum;
932
933	dum = gadget_dev_to_dummy(dev: &_gadget->dev);
934	dum->gadget.speed = speed;
935	dummy_udc_update_ep0(dum);
936	}
937
938	static void dummy_udc_async_callbacks(struct usb_gadget *_gadget, bool enable)
939	{
940	struct dummy *dum = gadget_dev_to_dummy(dev: &_gadget->dev);
941
942	spin_lock_irq(lock: &dum->lock);
943	dum->ints_enabled = enable;
944	spin_unlock_irq(lock: &dum->lock);
945	}
946
947	static int dummy_udc_start(struct usb_gadget *g,
948	struct usb_gadget_driver *driver);
949	static int dummy_udc_stop(struct usb_gadget *g);
950
951	static const struct usb_gadget_ops dummy_ops = {
952	.get_frame = dummy_g_get_frame,
953	.wakeup = dummy_wakeup,
954	.set_selfpowered = dummy_set_selfpowered,
955	.pullup = dummy_pullup,
956	.udc_start = dummy_udc_start,
957	.udc_stop = dummy_udc_stop,
958	.udc_set_speed = dummy_udc_set_speed,
959	.udc_async_callbacks = dummy_udc_async_callbacks,
960	};
961
962	/*-------------------------------------------------------------------------*/
963
964	/* "function" sysfs attribute */
965	static ssize_t function_show(struct device *dev, struct device_attribute *attr,
966	char *buf)
967	{
968	struct dummy *dum = gadget_dev_to_dummy(dev);
969
970	if (!dum->driver || !dum->driver->function)
971	return 0;
972	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n", dum->driver->function);
973	}
974	static DEVICE_ATTR_RO(function);
975
976	/*-------------------------------------------------------------------------*/
977
978	/*
979	* Driver registration/unregistration.
980	*
981	* This is basically hardware-specific; there's usually only one real USB
982	* device (not host) controller since that's how USB devices are intended
983	* to work. So most implementations of these api calls will rely on the
984	* fact that only one driver will ever bind to the hardware. But curious
985	* hardware can be built with discrete components, so the gadget API doesn't
986	* require that assumption.
987	*
988	* For this emulator, it might be convenient to create a usb device
989	* for each driver that registers: just add to a big root hub.
990	*/
991
992	static int dummy_udc_start(struct usb_gadget *g,
993	struct usb_gadget_driver *driver)
994	{
995	struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(gadget: g);
996	struct dummy *dum = dum_hcd->dum;
997
998	switch (g->speed) {
999	/* All the speeds we support */
1000	case USB_SPEED_LOW:
1001	case USB_SPEED_FULL:
1002	case USB_SPEED_HIGH:
1003	case USB_SPEED_SUPER:
1004	break;
1005	default:
1006	dev_err(dummy_dev(dum_hcd), "Unsupported driver max speed %d\n",
1007	driver->max_speed);
1008	return -EINVAL;
1009	}
1010
1011	/*
1012	* DEVICE side init ... the layer above hardware, which
1013	* can't enumerate without help from the driver we're binding.
1014	*/
1015
1016	spin_lock_irq(lock: &dum->lock);
1017	dum->devstatus = 0;
1018	dum->driver = driver;
1019	spin_unlock_irq(lock: &dum->lock);
1020
1021	return 0;
1022	}
1023
1024	static int dummy_udc_stop(struct usb_gadget *g)
1025	{
1026	struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(gadget: g);
1027	struct dummy *dum = dum_hcd->dum;
1028
1029	spin_lock_irq(lock: &dum->lock);
1030	dum->ints_enabled = 0;
1031	stop_activity(dum);
1032	dum->driver = NULL;
1033	spin_unlock_irq(lock: &dum->lock);
1034
1035	return 0;
1036	}
1037
1038	#undef is_enabled
1039
1040	/* The gadget structure is stored inside the hcd structure and will be
1041	* released along with it. */
1042	static void init_dummy_udc_hw(struct dummy *dum)
1043	{
1044	int i;
1045
1046	INIT_LIST_HEAD(list: &dum->gadget.ep_list);
1047	for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1048	struct dummy_ep *ep = &dum->ep[i];
1049
1050	if (!ep_info[i].name)
1051	break;
1052	ep->ep.name = ep_info[i].name;
1053	ep->ep.caps = ep_info[i].caps;
1054	ep->ep.ops = &dummy_ep_ops;
1055	list_add_tail(new: &ep->ep.ep_list, head: &dum->gadget.ep_list);
1056	ep->halted = ep->wedged = ep->already_seen =
1057	ep->setup_stage = 0;
1058	usb_ep_set_maxpacket_limit(ep: &ep->ep, maxpacket_limit: ~0);
1059	ep->ep.max_streams = 16;
1060	ep->last_io = jiffies;
1061	ep->gadget = &dum->gadget;
1062	ep->desc = NULL;
1063	INIT_LIST_HEAD(list: &ep->queue);
1064	}
1065
1066	dum->gadget.ep0 = &dum->ep[0].ep;
1067	list_del_init(entry: &dum->ep[0].ep.ep_list);
1068	INIT_LIST_HEAD(list: &dum->fifo_req.queue);
1069
1070	#ifdef CONFIG_USB_OTG
1071	dum->gadget.is_otg = 1;
1072	#endif
1073	}
1074
1075	static int dummy_udc_probe(struct platform_device *pdev)
1076	{
1077	struct dummy *dum;
1078	int rc;
1079
1080	dum = *((void **)dev_get_platdata(dev: &pdev->dev));
1081	/* Clear usb_gadget region for new registration to udc-core */
1082	memzero_explicit(s: &dum->gadget, count: sizeof(struct usb_gadget));
1083	dum->gadget.name = gadget_name;
1084	dum->gadget.ops = &dummy_ops;
1085	if (mod_data.is_super_speed)
1086	dum->gadget.max_speed = USB_SPEED_SUPER;
1087	else if (mod_data.is_high_speed)
1088	dum->gadget.max_speed = USB_SPEED_HIGH;
1089	else
1090	dum->gadget.max_speed = USB_SPEED_FULL;
1091
1092	dum->gadget.dev.parent = &pdev->dev;
1093	init_dummy_udc_hw(dum);
1094
1095	rc = usb_add_gadget_udc(parent: &pdev->dev, gadget: &dum->gadget);
1096	if (rc < 0)
1097	goto err_udc;
1098
1099	rc = device_create_file(device: &dum->gadget.dev, entry: &dev_attr_function);
1100	if (rc < 0)
1101	goto err_dev;
1102	platform_set_drvdata(pdev, data: dum);
1103	return rc;
1104
1105	err_dev:
1106	usb_del_gadget_udc(gadget: &dum->gadget);
1107	err_udc:
1108	return rc;
1109	}
1110
1111	static void dummy_udc_remove(struct platform_device *pdev)
1112	{
1113	struct dummy *dum = platform_get_drvdata(pdev);
1114
1115	device_remove_file(dev: &dum->gadget.dev, attr: &dev_attr_function);
1116	usb_del_gadget_udc(gadget: &dum->gadget);
1117	}
1118
1119	static void dummy_udc_pm(struct dummy *dum, struct dummy_hcd *dum_hcd,
1120	int suspend)
1121	{
1122	spin_lock_irq(lock: &dum->lock);
1123	dum->udc_suspended = suspend;
1124	set_link_state(dum_hcd);
1125	spin_unlock_irq(lock: &dum->lock);
1126	}
1127
1128	static int dummy_udc_suspend(struct platform_device *pdev, pm_message_t state)
1129	{
1130	struct dummy *dum = platform_get_drvdata(pdev);
1131	struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(gadget: &dum->gadget);
1132
1133	dev_dbg(&pdev->dev, "%s\n", __func__);
1134	dummy_udc_pm(dum, dum_hcd, suspend: 1);
1135	usb_hcd_poll_rh_status(hcd: dummy_hcd_to_hcd(dum: dum_hcd));
1136	return 0;
1137	}
1138
1139	static int dummy_udc_resume(struct platform_device *pdev)
1140	{
1141	struct dummy *dum = platform_get_drvdata(pdev);
1142	struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(gadget: &dum->gadget);
1143
1144	dev_dbg(&pdev->dev, "%s\n", __func__);
1145	dummy_udc_pm(dum, dum_hcd, suspend: 0);
1146	usb_hcd_poll_rh_status(hcd: dummy_hcd_to_hcd(dum: dum_hcd));
1147	return 0;
1148	}
1149
1150	static struct platform_driver dummy_udc_driver = {
1151	.probe = dummy_udc_probe,
1152	.remove_new = dummy_udc_remove,
1153	.suspend = dummy_udc_suspend,
1154	.resume = dummy_udc_resume,
1155	.driver = {
1156	.name = gadget_name,
1157	},
1158	};
1159
1160	/*-------------------------------------------------------------------------*/
1161
1162	static unsigned int dummy_get_ep_idx(const struct usb_endpoint_descriptor *desc)
1163	{
1164	unsigned int index;
1165
1166	index = usb_endpoint_num(epd: desc) << 1;
1167	if (usb_endpoint_dir_in(epd: desc))
1168	index |= 1;
1169	return index;
1170	}
1171
1172	/* HOST SIDE DRIVER
1173	*
1174	* this uses the hcd framework to hook up to host side drivers.
1175	* its root hub will only have one device, otherwise it acts like
1176	* a normal host controller.
1177	*
1178	* when urbs are queued, they're just stuck on a list that we
1179	* scan in a timer callback. that callback connects writes from
1180	* the host with reads from the device, and so on, based on the
1181	* usb 2.0 rules.
1182	*/
1183
1184	static int dummy_ep_stream_en(struct dummy_hcd *dum_hcd, struct urb *urb)
1185	{
1186	const struct usb_endpoint_descriptor *desc = &urb->ep->desc;
1187	u32 index;
1188
1189	if (!usb_endpoint_xfer_bulk(epd: desc))
1190	return 0;
1191
1192	index = dummy_get_ep_idx(desc);
1193	return (1 << index) & dum_hcd->stream_en_ep;
1194	}
1195
1196	/*
1197	* The max stream number is saved as a nibble so for the 30 possible endpoints
1198	* we only 15 bytes of memory. Therefore we are limited to max 16 streams (0
1199	* means we use only 1 stream). The maximum according to the spec is 16bit so
1200	* if the 16 stream limit is about to go, the array size should be incremented
1201	* to 30 elements of type u16.
1202	*/
1203	static int get_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
1204	unsigned int pipe)
1205	{
1206	int max_streams;
1207
1208	max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
1209	if (usb_pipeout(pipe))
1210	max_streams >>= 4;
1211	else
1212	max_streams &= 0xf;
1213	max_streams++;
1214	return max_streams;
1215	}
1216
1217	static void set_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
1218	unsigned int pipe, unsigned int streams)
1219	{
1220	int max_streams;
1221
1222	streams--;
1223	max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
1224	if (usb_pipeout(pipe)) {
1225	streams <<= 4;
1226	max_streams &= 0xf;
1227	} else {
1228	max_streams &= 0xf0;
1229	}
1230	max_streams |= streams;
1231	dum_hcd->num_stream[usb_pipeendpoint(pipe)] = max_streams;
1232	}
1233
1234	static int dummy_validate_stream(struct dummy_hcd *dum_hcd, struct urb *urb)
1235	{
1236	unsigned int max_streams;
1237	int enabled;
1238
1239	enabled = dummy_ep_stream_en(dum_hcd, urb);
1240	if (!urb->stream_id) {
1241	if (enabled)
1242	return -EINVAL;
1243	return 0;
1244	}
1245	if (!enabled)
1246	return -EINVAL;
1247
1248	max_streams = get_max_streams_for_pipe(dum_hcd,
1249	usb_pipeendpoint(urb->pipe));
1250	if (urb->stream_id > max_streams) {
1251	dev_err(dummy_dev(dum_hcd), "Stream id %d is out of range.\n",
1252	urb->stream_id);
1253	BUG();
1254	return -EINVAL;
1255	}
1256	return 0;
1257	}
1258
1259	static int dummy_urb_enqueue(
1260	struct usb_hcd *hcd,
1261	struct urb *urb,
1262	gfp_t mem_flags
1263	) {
1264	struct dummy_hcd *dum_hcd;
1265	struct urbp *urbp;
1266	unsigned long flags;
1267	int rc;
1268
1269	urbp = kmalloc(size: sizeof *urbp, flags: mem_flags);
1270	if (!urbp)
1271	return -ENOMEM;
1272	urbp->urb = urb;
1273	urbp->miter_started = 0;
1274
1275	dum_hcd = hcd_to_dummy_hcd(hcd);
1276	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1277
1278	rc = dummy_validate_stream(dum_hcd, urb);
1279	if (rc) {
1280	kfree(objp: urbp);
1281	goto done;
1282	}
1283
1284	rc = usb_hcd_link_urb_to_ep(hcd, urb);
1285	if (rc) {
1286	kfree(objp: urbp);
1287	goto done;
1288	}
1289
1290	if (!dum_hcd->udev) {
1291	dum_hcd->udev = urb->dev;
1292	usb_get_dev(dev: dum_hcd->udev);
1293	} else if (unlikely(dum_hcd->udev != urb->dev))
1294	dev_err(dummy_dev(dum_hcd), "usb_device address has changed!\n");
1295
1296	list_add_tail(new: &urbp->urbp_list, head: &dum_hcd->urbp_list);
1297	urb->hcpriv = urbp;
1298	if (!dum_hcd->next_frame_urbp)
1299	dum_hcd->next_frame_urbp = urbp;
1300	if (usb_pipetype(urb->pipe) == PIPE_CONTROL)
1301	urb->error_count = 1; /* mark as a new urb */
1302
1303	/* kick the scheduler, it'll do the rest */
1304	if (!timer_pending(timer: &dum_hcd->timer))
1305	mod_timer(timer: &dum_hcd->timer, expires: jiffies + 1);
1306
1307	done:
1308	spin_unlock_irqrestore(lock: &dum_hcd->dum->lock, flags);
1309	return rc;
1310	}
1311
1312	static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1313	{
1314	struct dummy_hcd *dum_hcd;
1315	unsigned long flags;
1316	int rc;
1317
1318	/* giveback happens automatically in timer callback,
1319	* so make sure the callback happens */
1320	dum_hcd = hcd_to_dummy_hcd(hcd);
1321	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1322
1323	rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1324	if (!rc && dum_hcd->rh_state != DUMMY_RH_RUNNING &&
1325	!list_empty(head: &dum_hcd->urbp_list))
1326	mod_timer(timer: &dum_hcd->timer, expires: jiffies);
1327
1328	spin_unlock_irqrestore(lock: &dum_hcd->dum->lock, flags);
1329	return rc;
1330	}
1331
1332	static int dummy_perform_transfer(struct urb *urb, struct dummy_request *req,
1333	u32 len)
1334	{
1335	void *ubuf, *rbuf;
1336	struct urbp *urbp = urb->hcpriv;
1337	int to_host;
1338	struct sg_mapping_iter *miter = &urbp->miter;
1339	u32 trans = 0;
1340	u32 this_sg;
1341	bool next_sg;
1342
1343	to_host = usb_urb_dir_in(urb);
1344	rbuf = req->req.buf + req->req.actual;
1345
1346	if (!urb->num_sgs) {
1347	ubuf = urb->transfer_buffer + urb->actual_length;
1348	if (to_host)
1349	memcpy(ubuf, rbuf, len);
1350	else
1351	memcpy(rbuf, ubuf, len);
1352	return len;
1353	}
1354
1355	if (!urbp->miter_started) {
1356	u32 flags = SG_MITER_ATOMIC;
1357
1358	if (to_host)
1359	flags |= SG_MITER_TO_SG;
1360	else
1361	flags |= SG_MITER_FROM_SG;
1362
1363	sg_miter_start(miter, sgl: urb->sg, nents: urb->num_sgs, flags);
1364	urbp->miter_started = 1;
1365	}
1366	next_sg = sg_miter_next(miter);
1367	if (next_sg == false) {
1368	WARN_ON_ONCE(1);
1369	return -EINVAL;
1370	}
1371	do {
1372	ubuf = miter->addr;
1373	this_sg = min_t(u32, len, miter->length);
1374	miter->consumed = this_sg;
1375	trans += this_sg;
1376
1377	if (to_host)
1378	memcpy(ubuf, rbuf, this_sg);
1379	else
1380	memcpy(rbuf, ubuf, this_sg);
1381	len -= this_sg;
1382
1383	if (!len)
1384	break;
1385	next_sg = sg_miter_next(miter);
1386	if (next_sg == false) {
1387	WARN_ON_ONCE(1);
1388	return -EINVAL;
1389	}
1390
1391	rbuf += this_sg;
1392	} while (1);
1393
1394	sg_miter_stop(miter);
1395	return trans;
1396	}
1397
1398	/* transfer up to a frame's worth; caller must own lock */
1399	static int transfer(struct dummy_hcd *dum_hcd, struct urb *urb,
1400	struct dummy_ep *ep, int limit, int *status)
1401	{
1402	struct dummy *dum = dum_hcd->dum;
1403	struct dummy_request *req;
1404	int sent = 0;
1405
1406	top:
1407	/* if there's no request queued, the device is NAKing; return */
1408	list_for_each_entry(req, &ep->queue, queue) {
1409	unsigned host_len, dev_len, len;
1410	int is_short, to_host;
1411	int rescan = 0;
1412
1413	if (dummy_ep_stream_en(dum_hcd, urb)) {
1414	if ((urb->stream_id != req->req.stream_id))
1415	continue;
1416	}
1417
1418	/* 1..N packets of ep->ep.maxpacket each ... the last one
1419	* may be short (including zero length).
1420	*
1421	* writer can send a zlp explicitly (length 0) or implicitly
1422	* (length mod maxpacket zero, and 'zero' flag); they always
1423	* terminate reads.
1424	*/
1425	host_len = urb->transfer_buffer_length - urb->actual_length;
1426	dev_len = req->req.length - req->req.actual;
1427	len = min(host_len, dev_len);
1428
1429	/* FIXME update emulated data toggle too */
1430
1431	to_host = usb_urb_dir_in(urb);
1432	if (unlikely(len == 0))
1433	is_short = 1;
1434	else {
1435	/* not enough bandwidth left? */
1436	if (limit < ep->ep.maxpacket && limit < len)
1437	break;
1438	len = min_t(unsigned, len, limit);
1439	if (len == 0)
1440	break;
1441
1442	/* send multiple of maxpacket first, then remainder */
1443	if (len >= ep->ep.maxpacket) {
1444	is_short = 0;
1445	if (len % ep->ep.maxpacket)
1446	rescan = 1;
1447	len -= len % ep->ep.maxpacket;
1448	} else {
1449	is_short = 1;
1450	}
1451
1452	len = dummy_perform_transfer(urb, req, len);
1453
1454	ep->last_io = jiffies;
1455	if ((int)len < 0) {
1456	req->req.status = len;
1457	} else {
1458	limit -= len;
1459	sent += len;
1460	urb->actual_length += len;
1461	req->req.actual += len;
1462	}
1463	}
1464
1465	/* short packets terminate, maybe with overflow/underflow.
1466	* it's only really an error to write too much.
1467	*
1468	* partially filling a buffer optionally blocks queue advances
1469	* (so completion handlers can clean up the queue) but we don't
1470	* need to emulate such data-in-flight.
1471	*/
1472	if (is_short) {
1473	if (host_len == dev_len) {
1474	req->req.status = 0;
1475	*status = 0;
1476	} else if (to_host) {
1477	req->req.status = 0;
1478	if (dev_len > host_len)
1479	*status = -EOVERFLOW;
1480	else
1481	*status = 0;
1482	} else {
1483	*status = 0;
1484	if (host_len > dev_len)
1485	req->req.status = -EOVERFLOW;
1486	else
1487	req->req.status = 0;
1488	}
1489
1490	/*
1491	* many requests terminate without a short packet.
1492	* send a zlp if demanded by flags.
1493	*/
1494	} else {
1495	if (req->req.length == req->req.actual) {
1496	if (req->req.zero && to_host)
1497	rescan = 1;
1498	else
1499	req->req.status = 0;
1500	}
1501	if (urb->transfer_buffer_length == urb->actual_length) {
1502	if (urb->transfer_flags & URB_ZERO_PACKET &&
1503	!to_host)
1504	rescan = 1;
1505	else
1506	*status = 0;
1507	}
1508	}
1509
1510	/* device side completion --> continuable */
1511	if (req->req.status != -EINPROGRESS) {
1512	list_del_init(entry: &req->queue);
1513
1514	spin_unlock(lock: &dum->lock);
1515	usb_gadget_giveback_request(ep: &ep->ep, req: &req->req);
1516	spin_lock(lock: &dum->lock);
1517
1518	/* requests might have been unlinked... */
1519	rescan = 1;
1520	}
1521
1522	/* host side completion --> terminate */
1523	if (*status != -EINPROGRESS)
1524	break;
1525
1526	/* rescan to continue with any other queued i/o */
1527	if (rescan)
1528	goto top;
1529	}
1530	return sent;
1531	}
1532
1533	static int periodic_bytes(struct dummy *dum, struct dummy_ep *ep)
1534	{
1535	int limit = ep->ep.maxpacket;
1536
1537	if (dum->gadget.speed == USB_SPEED_HIGH) {
1538	int tmp;
1539
1540	/* high bandwidth mode */
1541	tmp = usb_endpoint_maxp_mult(epd: ep->desc);
1542	tmp *= 8 /* applies to entire frame */;
1543	limit += limit * tmp;
1544	}
1545	if (dum->gadget.speed == USB_SPEED_SUPER) {
1546	switch (usb_endpoint_type(epd: ep->desc)) {
1547	case USB_ENDPOINT_XFER_ISOC:
1548	/* Sec. 4.4.8.2 USB3.0 Spec */
1549	limit = 3 * 16 * 1024 * 8;
1550	break;
1551	case USB_ENDPOINT_XFER_INT:
1552	/* Sec. 4.4.7.2 USB3.0 Spec */
1553	limit = 3 * 1024 * 8;
1554	break;
1555	case USB_ENDPOINT_XFER_BULK:
1556	default:
1557	break;
1558	}
1559	}
1560	return limit;
1561	}
1562
1563	#define is_active(dum_hcd) ((dum_hcd->port_status & \
1564	(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \
1565	USB_PORT_STAT_SUSPEND)) \
1566	== (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))
1567
1568	static struct dummy_ep *find_endpoint(struct dummy *dum, u8 address)
1569	{
1570	int i;
1571
1572	if (!is_active((dum->gadget.speed == USB_SPEED_SUPER ?
1573	dum->ss_hcd : dum->hs_hcd)))
1574	return NULL;
1575	if (!dum->ints_enabled)
1576	return NULL;
1577	if ((address & ~USB_DIR_IN) == 0)
1578	return &dum->ep[0];
1579	for (i = 1; i < DUMMY_ENDPOINTS; i++) {
1580	struct dummy_ep *ep = &dum->ep[i];
1581
1582	if (!ep->desc)
1583	continue;
1584	if (ep->desc->bEndpointAddress == address)
1585	return ep;
1586	}
1587	return NULL;
1588	}
1589
1590	#undef is_active
1591
1592	#define Dev_Request (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
1593	#define Dev_InRequest (Dev_Request | USB_DIR_IN)
1594	#define Intf_Request (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
1595	#define Intf_InRequest (Intf_Request | USB_DIR_IN)
1596	#define Ep_Request (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
1597	#define Ep_InRequest (Ep_Request | USB_DIR_IN)
1598
1599
1600	/**
1601	* handle_control_request() - handles all control transfers
1602	* @dum_hcd: pointer to dummy (the_controller)
1603	* @urb: the urb request to handle
1604	* @setup: pointer to the setup data for a USB device control
1605	* request
1606	* @status: pointer to request handling status
1607	*
1608	* Return 0 - if the request was handled
1609	* 1 - if the request wasn't handles
1610	* error code on error
1611	*/
1612	static int handle_control_request(struct dummy_hcd *dum_hcd, struct urb *urb,
1613	struct usb_ctrlrequest *setup,
1614	int *status)
1615	{
1616	struct dummy_ep *ep2;
1617	struct dummy *dum = dum_hcd->dum;
1618	int ret_val = 1;
1619	unsigned w_index;
1620	unsigned w_value;
1621
1622	w_index = le16_to_cpu(setup->wIndex);
1623	w_value = le16_to_cpu(setup->wValue);
1624	switch (setup->bRequest) {
1625	case USB_REQ_SET_ADDRESS:
1626	if (setup->bRequestType != Dev_Request)
1627	break;
1628	dum->address = w_value;
1629	*status = 0;
1630	dev_dbg(udc_dev(dum), "set_address = %d\n",
1631	w_value);
1632	ret_val = 0;
1633	break;
1634	case USB_REQ_SET_FEATURE:
1635	if (setup->bRequestType == Dev_Request) {
1636	ret_val = 0;
1637	switch (w_value) {
1638	case USB_DEVICE_REMOTE_WAKEUP:
1639	break;
1640	case USB_DEVICE_B_HNP_ENABLE:
1641	dum->gadget.b_hnp_enable = 1;
1642	break;
1643	case USB_DEVICE_A_HNP_SUPPORT:
1644	dum->gadget.a_hnp_support = 1;
1645	break;
1646	case USB_DEVICE_A_ALT_HNP_SUPPORT:
1647	dum->gadget.a_alt_hnp_support = 1;
1648	break;
1649	case USB_DEVICE_U1_ENABLE:
1650	if (dummy_hcd_to_hcd(dum: dum_hcd)->speed ==
1651	HCD_USB3)
1652	w_value = USB_DEV_STAT_U1_ENABLED;
1653	else
1654	ret_val = -EOPNOTSUPP;
1655	break;
1656	case USB_DEVICE_U2_ENABLE:
1657	if (dummy_hcd_to_hcd(dum: dum_hcd)->speed ==
1658	HCD_USB3)
1659	w_value = USB_DEV_STAT_U2_ENABLED;
1660	else
1661	ret_val = -EOPNOTSUPP;
1662	break;
1663	case USB_DEVICE_LTM_ENABLE:
1664	if (dummy_hcd_to_hcd(dum: dum_hcd)->speed ==
1665	HCD_USB3)
1666	w_value = USB_DEV_STAT_LTM_ENABLED;
1667	else
1668	ret_val = -EOPNOTSUPP;
1669	break;
1670	default:
1671	ret_val = -EOPNOTSUPP;
1672	}
1673	if (ret_val == 0) {
1674	dum->devstatus |= (1 << w_value);
1675	*status = 0;
1676	}
1677	} else if (setup->bRequestType == Ep_Request) {
1678	/* endpoint halt */
1679	ep2 = find_endpoint(dum, address: w_index);
1680	if (!ep2 || ep2->ep.name == ep0name) {
1681	ret_val = -EOPNOTSUPP;
1682	break;
1683	}
1684	ep2->halted = 1;
1685	ret_val = 0;
1686	*status = 0;
1687	}
1688	break;
1689	case USB_REQ_CLEAR_FEATURE:
1690	if (setup->bRequestType == Dev_Request) {
1691	ret_val = 0;
1692	switch (w_value) {
1693	case USB_DEVICE_REMOTE_WAKEUP:
1694	w_value = USB_DEVICE_REMOTE_WAKEUP;
1695	break;
1696	case USB_DEVICE_U1_ENABLE:
1697	if (dummy_hcd_to_hcd(dum: dum_hcd)->speed ==
1698	HCD_USB3)
1699	w_value = USB_DEV_STAT_U1_ENABLED;
1700	else
1701	ret_val = -EOPNOTSUPP;
1702	break;
1703	case USB_DEVICE_U2_ENABLE:
1704	if (dummy_hcd_to_hcd(dum: dum_hcd)->speed ==
1705	HCD_USB3)
1706	w_value = USB_DEV_STAT_U2_ENABLED;
1707	else
1708	ret_val = -EOPNOTSUPP;
1709	break;
1710	case USB_DEVICE_LTM_ENABLE:
1711	if (dummy_hcd_to_hcd(dum: dum_hcd)->speed ==
1712	HCD_USB3)
1713	w_value = USB_DEV_STAT_LTM_ENABLED;
1714	else
1715	ret_val = -EOPNOTSUPP;
1716	break;
1717	default:
1718	ret_val = -EOPNOTSUPP;
1719	break;
1720	}
1721	if (ret_val == 0) {
1722	dum->devstatus &= ~(1 << w_value);
1723	*status = 0;
1724	}
1725	} else if (setup->bRequestType == Ep_Request) {
1726	/* endpoint halt */
1727	ep2 = find_endpoint(dum, address: w_index);
1728	if (!ep2) {
1729	ret_val = -EOPNOTSUPP;
1730	break;
1731	}
1732	if (!ep2->wedged)
1733	ep2->halted = 0;
1734	ret_val = 0;
1735	*status = 0;
1736	}
1737	break;
1738	case USB_REQ_GET_STATUS:
1739	if (setup->bRequestType == Dev_InRequest
1740	|| setup->bRequestType == Intf_InRequest
1741	|| setup->bRequestType == Ep_InRequest) {
1742	char *buf;
1743	/*
1744	* device: remote wakeup, selfpowered
1745	* interface: nothing
1746	* endpoint: halt
1747	*/
1748	buf = (char *)urb->transfer_buffer;
1749	if (urb->transfer_buffer_length > 0) {
1750	if (setup->bRequestType == Ep_InRequest) {
1751	ep2 = find_endpoint(dum, address: w_index);
1752	if (!ep2) {
1753	ret_val = -EOPNOTSUPP;
1754	break;
1755	}
1756	buf[0] = ep2->halted;
1757	} else if (setup->bRequestType ==
1758	Dev_InRequest) {
1759	buf[0] = (u8)dum->devstatus;
1760	} else
1761	buf[0] = 0;
1762	}
1763	if (urb->transfer_buffer_length > 1)
1764	buf[1] = 0;
1765	urb->actual_length = min_t(u32, 2,
1766	urb->transfer_buffer_length);
1767	ret_val = 0;
1768	*status = 0;
1769	}
1770	break;
1771	}
1772	return ret_val;
1773	}
1774
1775	/*
1776	* Drive both sides of the transfers; looks like irq handlers to both
1777	* drivers except that the callbacks are invoked from soft interrupt
1778	* context.
1779	*/
1780	static void dummy_timer(struct timer_list *t)
1781	{
1782	struct dummy_hcd *dum_hcd = from_timer(dum_hcd, t, timer);
1783	struct dummy *dum = dum_hcd->dum;
1784	struct urbp *urbp, *tmp;
1785	unsigned long flags;
1786	int limit, total;
1787	int i;
1788
1789	/* simplistic model for one frame's bandwidth */
1790	/* FIXME: account for transaction and packet overhead */
1791	switch (dum->gadget.speed) {
1792	case USB_SPEED_LOW:
1793	total = 8/*bytes*/ * 12/*packets*/;
1794	break;
1795	case USB_SPEED_FULL:
1796	total = 64/*bytes*/ * 19/*packets*/;
1797	break;
1798	case USB_SPEED_HIGH:
1799	total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/;
1800	break;
1801	case USB_SPEED_SUPER:
1802	/* Bus speed is 500000 bytes/ms, so use a little less */
1803	total = 490000;
1804	break;
1805	default: /* Can't happen */
1806	dev_err(dummy_dev(dum_hcd), "bogus device speed\n");
1807	total = 0;
1808	break;
1809	}
1810
1811	/* FIXME if HZ != 1000 this will probably misbehave ... */
1812
1813	/* look at each urb queued by the host side driver */
1814	spin_lock_irqsave(&dum->lock, flags);
1815
1816	if (!dum_hcd->udev) {
1817	dev_err(dummy_dev(dum_hcd),
1818	"timer fired with no URBs pending?\n");
1819	spin_unlock_irqrestore(lock: &dum->lock, flags);
1820	return;
1821	}
1822	dum_hcd->next_frame_urbp = NULL;
1823
1824	for (i = 0; i < DUMMY_ENDPOINTS; i++) {
1825	if (!ep_info[i].name)
1826	break;
1827	dum->ep[i].already_seen = 0;
1828	}
1829
1830	restart:
1831	list_for_each_entry_safe(urbp, tmp, &dum_hcd->urbp_list, urbp_list) {
1832	struct urb *urb;
1833	struct dummy_request *req;
1834	u8 address;
1835	struct dummy_ep *ep = NULL;
1836	int status = -EINPROGRESS;
1837
1838	/* stop when we reach URBs queued after the timer interrupt */
1839	if (urbp == dum_hcd->next_frame_urbp)
1840	break;
1841
1842	urb = urbp->urb;
1843	if (urb->unlinked)
1844	goto return_urb;
1845	else if (dum_hcd->rh_state != DUMMY_RH_RUNNING)
1846	continue;
1847
1848	/* Used up this frame's bandwidth? */
1849	if (total <= 0)
1850	continue;
1851
1852	/* find the gadget's ep for this request (if configured) */
1853	address = usb_pipeendpoint (urb->pipe);
1854	if (usb_urb_dir_in(urb))
1855	address |= USB_DIR_IN;
1856	ep = find_endpoint(dum, address);
1857	if (!ep) {
1858	/* set_configuration() disagreement */
1859	dev_dbg(dummy_dev(dum_hcd),
1860	"no ep configured for urb %p\n",
1861	urb);
1862	status = -EPROTO;
1863	goto return_urb;
1864	}
1865
1866	if (ep->already_seen)
1867	continue;
1868	ep->already_seen = 1;
1869	if (ep == &dum->ep[0] && urb->error_count) {
1870	ep->setup_stage = 1; /* a new urb */
1871	urb->error_count = 0;
1872	}
1873	if (ep->halted && !ep->setup_stage) {
1874	/* NOTE: must not be iso! */
1875	dev_dbg(dummy_dev(dum_hcd), "ep %s halted, urb %p\n",
1876	ep->ep.name, urb);
1877	status = -EPIPE;
1878	goto return_urb;
1879	}
1880	/* FIXME make sure both ends agree on maxpacket */
1881
1882	/* handle control requests */
1883	if (ep == &dum->ep[0] && ep->setup_stage) {
1884	struct usb_ctrlrequest setup;
1885	int value;
1886
1887	setup = *(struct usb_ctrlrequest *) urb->setup_packet;
1888	/* paranoia, in case of stale queued data */
1889	list_for_each_entry(req, &ep->queue, queue) {
1890	list_del_init(entry: &req->queue);
1891	req->req.status = -EOVERFLOW;
1892	dev_dbg(udc_dev(dum), "stale req = %p\n",
1893	req);
1894
1895	spin_unlock(lock: &dum->lock);
1896	usb_gadget_giveback_request(ep: &ep->ep, req: &req->req);
1897	spin_lock(lock: &dum->lock);
1898	ep->already_seen = 0;
1899	goto restart;
1900	}
1901
1902	/* gadget driver never sees set_address or operations
1903	* on standard feature flags. some hardware doesn't
1904	* even expose them.
1905	*/
1906	ep->last_io = jiffies;
1907	ep->setup_stage = 0;
1908	ep->halted = 0;
1909
1910	value = handle_control_request(dum_hcd, urb, setup: &setup,
1911	status: &status);
1912
1913	/* gadget driver handles all other requests. block
1914	* until setup() returns; no reentrancy issues etc.
1915	*/
1916	if (value > 0) {
1917	++dum->callback_usage;
1918	spin_unlock(lock: &dum->lock);
1919	value = dum->driver->setup(&dum->gadget,
1920	&setup);
1921	spin_lock(lock: &dum->lock);
1922	--dum->callback_usage;
1923
1924	if (value >= 0) {
1925	/* no delays (max 64KB data stage) */
1926	limit = 64*1024;
1927	goto treat_control_like_bulk;
1928	}
1929	/* error, see below */
1930	}
1931
1932	if (value < 0) {
1933	if (value != -EOPNOTSUPP)
1934	dev_dbg(udc_dev(dum),
1935	"setup --> %d\n",
1936	value);
1937	status = -EPIPE;
1938	urb->actual_length = 0;
1939	}
1940
1941	goto return_urb;
1942	}
1943
1944	/* non-control requests */
1945	limit = total;
1946	switch (usb_pipetype(urb->pipe)) {
1947	case PIPE_ISOCHRONOUS:
1948	/*
1949	* We don't support isochronous. But if we did,
1950	* here are some of the issues we'd have to face:
1951	*
1952	* Is it urb->interval since the last xfer?
1953	* Use urb->iso_frame_desc[i].
1954	* Complete whether or not ep has requests queued.
1955	* Report random errors, to debug drivers.
1956	*/
1957	limit = max(limit, periodic_bytes(dum, ep));
1958	status = -EINVAL; /* fail all xfers */
1959	break;
1960
1961	case PIPE_INTERRUPT:
1962	/* FIXME is it urb->interval since the last xfer?
1963	* this almost certainly polls too fast.
1964	*/
1965	limit = max(limit, periodic_bytes(dum, ep));
1966	fallthrough;
1967
1968	default:
1969	treat_control_like_bulk:
1970	ep->last_io = jiffies;
1971	total -= transfer(dum_hcd, urb, ep, limit, status: &status);
1972	break;
1973	}
1974
1975	/* incomplete transfer? */
1976	if (status == -EINPROGRESS)
1977	continue;
1978
1979	return_urb:
1980	list_del(entry: &urbp->urbp_list);
1981	kfree(objp: urbp);
1982	if (ep)
1983	ep->already_seen = ep->setup_stage = 0;
1984
1985	usb_hcd_unlink_urb_from_ep(hcd: dummy_hcd_to_hcd(dum: dum_hcd), urb);
1986	spin_unlock(lock: &dum->lock);
1987	usb_hcd_giveback_urb(hcd: dummy_hcd_to_hcd(dum: dum_hcd), urb, status);
1988	spin_lock(lock: &dum->lock);
1989
1990	goto restart;
1991	}
1992
1993	if (list_empty(head: &dum_hcd->urbp_list)) {
1994	usb_put_dev(dev: dum_hcd->udev);
1995	dum_hcd->udev = NULL;
1996	} else if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
1997	/* want a 1 msec delay here */
1998	mod_timer(timer: &dum_hcd->timer, expires: jiffies + msecs_to_jiffies(m: 1));
1999	}
2000
2001	spin_unlock_irqrestore(lock: &dum->lock, flags);
2002	}
2003
2004	/*-------------------------------------------------------------------------*/
2005
2006	#define PORT_C_MASK \
2007	((USB_PORT_STAT_C_CONNECTION \
2008	| USB_PORT_STAT_C_ENABLE \
2009	| USB_PORT_STAT_C_SUSPEND \
2010	| USB_PORT_STAT_C_OVERCURRENT \
2011	| USB_PORT_STAT_C_RESET) << 16)
2012
2013	static int dummy_hub_status(struct usb_hcd *hcd, char *buf)
2014	{
2015	struct dummy_hcd *dum_hcd;
2016	unsigned long flags;
2017	int retval = 0;
2018
2019	dum_hcd = hcd_to_dummy_hcd(hcd);
2020
2021	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2022	if (!HCD_HW_ACCESSIBLE(hcd))
2023	goto done;
2024
2025	if (dum_hcd->resuming && time_after_eq(jiffies, dum_hcd->re_timeout)) {
2026	dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
2027	dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
2028	set_link_state(dum_hcd);
2029	}
2030
2031	if ((dum_hcd->port_status & PORT_C_MASK) != 0) {
2032	*buf = (1 << 1);
2033	dev_dbg(dummy_dev(dum_hcd), "port status 0x%08x has changes\n",
2034	dum_hcd->port_status);
2035	retval = 1;
2036	if (dum_hcd->rh_state == DUMMY_RH_SUSPENDED)
2037	usb_hcd_resume_root_hub(hcd);
2038	}
2039	done:
2040	spin_unlock_irqrestore(lock: &dum_hcd->dum->lock, flags);
2041	return retval;
2042	}
2043
2044	/* usb 3.0 root hub device descriptor */
2045	static struct {
2046	struct usb_bos_descriptor bos;
2047	struct usb_ss_cap_descriptor ss_cap;
2048	} __packed usb3_bos_desc = {
2049
2050	.bos = {
2051	.bLength = USB_DT_BOS_SIZE,
2052	.bDescriptorType = USB_DT_BOS,
2053	.wTotalLength = cpu_to_le16(sizeof(usb3_bos_desc)),
2054	.bNumDeviceCaps = 1,
2055	},
2056	.ss_cap = {
2057	.bLength = USB_DT_USB_SS_CAP_SIZE,
2058	.bDescriptorType = USB_DT_DEVICE_CAPABILITY,
2059	.bDevCapabilityType = USB_SS_CAP_TYPE,
2060	.wSpeedSupported = cpu_to_le16(USB_5GBPS_OPERATION),
2061	.bFunctionalitySupport = ilog2(USB_5GBPS_OPERATION),
2062	},
2063	};
2064
2065	static inline void
2066	ss_hub_descriptor(struct usb_hub_descriptor *desc)
2067	{
2068	memset(desc, 0, sizeof *desc);
2069	desc->bDescriptorType = USB_DT_SS_HUB;
2070	desc->bDescLength = 12;
2071	desc->wHubCharacteristics = cpu_to_le16(
2072	HUB_CHAR_INDV_PORT_LPSM |
2073	HUB_CHAR_COMMON_OCPM);
2074	desc->bNbrPorts = 1;
2075	desc->u.ss.bHubHdrDecLat = 0x04; /* Worst case: 0.4 micro sec*/
2076	desc->u.ss.DeviceRemovable = 0;
2077	}
2078
2079	static inline void hub_descriptor(struct usb_hub_descriptor *desc)
2080	{
2081	memset(desc, 0, sizeof *desc);
2082	desc->bDescriptorType = USB_DT_HUB;
2083	desc->bDescLength = 9;
2084	desc->wHubCharacteristics = cpu_to_le16(
2085	HUB_CHAR_INDV_PORT_LPSM |
2086	HUB_CHAR_COMMON_OCPM);
2087	desc->bNbrPorts = 1;
2088	desc->u.hs.DeviceRemovable[0] = 0;
2089	desc->u.hs.DeviceRemovable[1] = 0xff; /* PortPwrCtrlMask */
2090	}
2091
2092	static int dummy_hub_control(
2093	struct usb_hcd *hcd,
2094	u16 typeReq,
2095	u16 wValue,
2096	u16 wIndex,
2097	char *buf,
2098	u16 wLength
2099	) {
2100	struct dummy_hcd *dum_hcd;
2101	int retval = 0;
2102	unsigned long flags;
2103
2104	if (!HCD_HW_ACCESSIBLE(hcd))
2105	return -ETIMEDOUT;
2106
2107	dum_hcd = hcd_to_dummy_hcd(hcd);
2108
2109	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2110	switch (typeReq) {
2111	case ClearHubFeature:
2112	break;
2113	case ClearPortFeature:
2114	switch (wValue) {
2115	case USB_PORT_FEAT_SUSPEND:
2116	if (hcd->speed == HCD_USB3) {
2117	dev_dbg(dummy_dev(dum_hcd),
2118	"USB_PORT_FEAT_SUSPEND req not "
2119	"supported for USB 3.0 roothub\n");
2120	goto error;
2121	}
2122	if (dum_hcd->port_status & USB_PORT_STAT_SUSPEND) {
2123	/* 20msec resume signaling */
2124	dum_hcd->resuming = 1;
2125	dum_hcd->re_timeout = jiffies +
2126	msecs_to_jiffies(m: 20);
2127	}
2128	break;
2129	case USB_PORT_FEAT_POWER:
2130	dev_dbg(dummy_dev(dum_hcd), "power-off\n");
2131	if (hcd->speed == HCD_USB3)
2132	dum_hcd->port_status &= ~USB_SS_PORT_STAT_POWER;
2133	else
2134	dum_hcd->port_status &= ~USB_PORT_STAT_POWER;
2135	set_link_state(dum_hcd);
2136	break;
2137	case USB_PORT_FEAT_ENABLE:
2138	case USB_PORT_FEAT_C_ENABLE:
2139	case USB_PORT_FEAT_C_SUSPEND:
2140	/* Not allowed for USB-3 */
2141	if (hcd->speed == HCD_USB3)
2142	goto error;
2143	fallthrough;
2144	case USB_PORT_FEAT_C_CONNECTION:
2145	case USB_PORT_FEAT_C_RESET:
2146	dum_hcd->port_status &= ~(1 << wValue);
2147	set_link_state(dum_hcd);
2148	break;
2149	default:
2150	/* Disallow INDICATOR and C_OVER_CURRENT */
2151	goto error;
2152	}
2153	break;
2154	case GetHubDescriptor:
2155	if (hcd->speed == HCD_USB3 &&
2156	(wLength < USB_DT_SS_HUB_SIZE ||
2157	wValue != (USB_DT_SS_HUB << 8))) {
2158	dev_dbg(dummy_dev(dum_hcd),
2159	"Wrong hub descriptor type for "
2160	"USB 3.0 roothub.\n");
2161	goto error;
2162	}
2163	if (hcd->speed == HCD_USB3)
2164	ss_hub_descriptor(desc: (struct usb_hub_descriptor *) buf);
2165	else
2166	hub_descriptor(desc: (struct usb_hub_descriptor *) buf);
2167	break;
2168
2169	case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
2170	if (hcd->speed != HCD_USB3)
2171	goto error;
2172
2173	if ((wValue >> 8) != USB_DT_BOS)
2174	goto error;
2175
2176	memcpy(buf, &usb3_bos_desc, sizeof(usb3_bos_desc));
2177	retval = sizeof(usb3_bos_desc);
2178	break;
2179
2180	case GetHubStatus:
2181	*(__le32 *) buf = cpu_to_le32(0);
2182	break;
2183	case GetPortStatus:
2184	if (wIndex != 1)
2185	retval = -EPIPE;
2186
2187	/* whoever resets or resumes must GetPortStatus to
2188	* complete it!!
2189	*/
2190	if (dum_hcd->resuming &&
2191	time_after_eq(jiffies, dum_hcd->re_timeout)) {
2192	dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
2193	dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
2194	}
2195	if ((dum_hcd->port_status & USB_PORT_STAT_RESET) != 0 &&
2196	time_after_eq(jiffies, dum_hcd->re_timeout)) {
2197	dum_hcd->port_status |= (USB_PORT_STAT_C_RESET << 16);
2198	dum_hcd->port_status &= ~USB_PORT_STAT_RESET;
2199	if (dum_hcd->dum->pullup) {
2200	dum_hcd->port_status |= USB_PORT_STAT_ENABLE;
2201
2202	if (hcd->speed < HCD_USB3) {
2203	switch (dum_hcd->dum->gadget.speed) {
2204	case USB_SPEED_HIGH:
2205	dum_hcd->port_status |=
2206	USB_PORT_STAT_HIGH_SPEED;
2207	break;
2208	case USB_SPEED_LOW:
2209	dum_hcd->dum->gadget.ep0->
2210	maxpacket = 8;
2211	dum_hcd->port_status |=
2212	USB_PORT_STAT_LOW_SPEED;
2213	break;
2214	default:
2215	break;
2216	}
2217	}
2218	}
2219	}
2220	set_link_state(dum_hcd);
2221	((__le16 *) buf)[0] = cpu_to_le16(dum_hcd->port_status);
2222	((__le16 *) buf)[1] = cpu_to_le16(dum_hcd->port_status >> 16);
2223	break;
2224	case SetHubFeature:
2225	retval = -EPIPE;
2226	break;
2227	case SetPortFeature:
2228	switch (wValue) {
2229	case USB_PORT_FEAT_LINK_STATE:
2230	if (hcd->speed != HCD_USB3) {
2231	dev_dbg(dummy_dev(dum_hcd),
2232	"USB_PORT_FEAT_LINK_STATE req not "
2233	"supported for USB 2.0 roothub\n");
2234	goto error;
2235	}
2236	/*
2237	* Since this is dummy we don't have an actual link so
2238	* there is nothing to do for the SET_LINK_STATE cmd
2239	*/
2240	break;
2241	case USB_PORT_FEAT_U1_TIMEOUT:
2242	case USB_PORT_FEAT_U2_TIMEOUT:
2243	/* TODO: add suspend/resume support! */
2244	if (hcd->speed != HCD_USB3) {
2245	dev_dbg(dummy_dev(dum_hcd),
2246	"USB_PORT_FEAT_U1/2_TIMEOUT req not "
2247	"supported for USB 2.0 roothub\n");
2248	goto error;
2249	}
2250	break;
2251	case USB_PORT_FEAT_SUSPEND:
2252	/* Applicable only for USB2.0 hub */
2253	if (hcd->speed == HCD_USB3) {
2254	dev_dbg(dummy_dev(dum_hcd),
2255	"USB_PORT_FEAT_SUSPEND req not "
2256	"supported for USB 3.0 roothub\n");
2257	goto error;
2258	}
2259	if (dum_hcd->active) {
2260	dum_hcd->port_status |= USB_PORT_STAT_SUSPEND;
2261
2262	/* HNP would happen here; for now we
2263	* assume b_bus_req is always true.
2264	*/
2265	set_link_state(dum_hcd);
2266	if (((1 << USB_DEVICE_B_HNP_ENABLE)
2267	& dum_hcd->dum->devstatus) != 0)
2268	dev_dbg(dummy_dev(dum_hcd),
2269	"no HNP yet!\n");
2270	}
2271	break;
2272	case USB_PORT_FEAT_POWER:
2273	if (hcd->speed == HCD_USB3)
2274	dum_hcd->port_status |= USB_SS_PORT_STAT_POWER;
2275	else
2276	dum_hcd->port_status |= USB_PORT_STAT_POWER;
2277	set_link_state(dum_hcd);
2278	break;
2279	case USB_PORT_FEAT_BH_PORT_RESET:
2280	/* Applicable only for USB3.0 hub */
2281	if (hcd->speed != HCD_USB3) {
2282	dev_dbg(dummy_dev(dum_hcd),
2283	"USB_PORT_FEAT_BH_PORT_RESET req not "
2284	"supported for USB 2.0 roothub\n");
2285	goto error;
2286	}
2287	fallthrough;
2288	case USB_PORT_FEAT_RESET:
2289	if (!(dum_hcd->port_status & USB_PORT_STAT_CONNECTION))
2290	break;
2291	/* if it's already enabled, disable */
2292	if (hcd->speed == HCD_USB3) {
2293	dum_hcd->port_status =
2294	(USB_SS_PORT_STAT_POWER |
2295	USB_PORT_STAT_CONNECTION |
2296	USB_PORT_STAT_RESET);
2297	} else {
2298	dum_hcd->port_status &= ~(USB_PORT_STAT_ENABLE
2299	| USB_PORT_STAT_LOW_SPEED
2300	| USB_PORT_STAT_HIGH_SPEED);
2301	dum_hcd->port_status |= USB_PORT_STAT_RESET;
2302	}
2303	/*
2304	* We want to reset device status. All but the
2305	* Self powered feature
2306	*/
2307	dum_hcd->dum->devstatus &=
2308	(1 << USB_DEVICE_SELF_POWERED);
2309	/*
2310	* FIXME USB3.0: what is the correct reset signaling
2311	* interval? Is it still 50msec as for HS?
2312	*/
2313	dum_hcd->re_timeout = jiffies + msecs_to_jiffies(m: 50);
2314	set_link_state(dum_hcd);
2315	break;
2316	case USB_PORT_FEAT_C_CONNECTION:
2317	case USB_PORT_FEAT_C_RESET:
2318	case USB_PORT_FEAT_C_ENABLE:
2319	case USB_PORT_FEAT_C_SUSPEND:
2320	/* Not allowed for USB-3, and ignored for USB-2 */
2321	if (hcd->speed == HCD_USB3)
2322	goto error;
2323	break;
2324	default:
2325	/* Disallow TEST, INDICATOR, and C_OVER_CURRENT */
2326	goto error;
2327	}
2328	break;
2329	case GetPortErrorCount:
2330	if (hcd->speed != HCD_USB3) {
2331	dev_dbg(dummy_dev(dum_hcd),
2332	"GetPortErrorCount req not "
2333	"supported for USB 2.0 roothub\n");
2334	goto error;
2335	}
2336	/* We'll always return 0 since this is a dummy hub */
2337	*(__le32 *) buf = cpu_to_le32(0);
2338	break;
2339	case SetHubDepth:
2340	if (hcd->speed != HCD_USB3) {
2341	dev_dbg(dummy_dev(dum_hcd),
2342	"SetHubDepth req not supported for "
2343	"USB 2.0 roothub\n");
2344	goto error;
2345	}
2346	break;
2347	default:
2348	dev_dbg(dummy_dev(dum_hcd),
2349	"hub control req%04x v%04x i%04x l%d\n",
2350	typeReq, wValue, wIndex, wLength);
2351	error:
2352	/* "protocol stall" on error */
2353	retval = -EPIPE;
2354	}
2355	spin_unlock_irqrestore(lock: &dum_hcd->dum->lock, flags);
2356
2357	if ((dum_hcd->port_status & PORT_C_MASK) != 0)
2358	usb_hcd_poll_rh_status(hcd);
2359	return retval;
2360	}
2361
2362	static int dummy_bus_suspend(struct usb_hcd *hcd)
2363	{
2364	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2365
2366	dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
2367
2368	spin_lock_irq(lock: &dum_hcd->dum->lock);
2369	dum_hcd->rh_state = DUMMY_RH_SUSPENDED;
2370	set_link_state(dum_hcd);
2371	hcd->state = HC_STATE_SUSPENDED;
2372	spin_unlock_irq(lock: &dum_hcd->dum->lock);
2373	return 0;
2374	}
2375
2376	static int dummy_bus_resume(struct usb_hcd *hcd)
2377	{
2378	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2379	int rc = 0;
2380
2381	dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
2382
2383	spin_lock_irq(lock: &dum_hcd->dum->lock);
2384	if (!HCD_HW_ACCESSIBLE(hcd)) {
2385	rc = -ESHUTDOWN;
2386	} else {
2387	dum_hcd->rh_state = DUMMY_RH_RUNNING;
2388	set_link_state(dum_hcd);
2389	if (!list_empty(head: &dum_hcd->urbp_list))
2390	mod_timer(timer: &dum_hcd->timer, expires: jiffies);
2391	hcd->state = HC_STATE_RUNNING;
2392	}
2393	spin_unlock_irq(lock: &dum_hcd->dum->lock);
2394	return rc;
2395	}
2396
2397	/*-------------------------------------------------------------------------*/
2398
2399	static inline ssize_t show_urb(char *buf, size_t size, struct urb *urb)
2400	{
2401	int ep = usb_pipeendpoint(urb->pipe);
2402
2403	return scnprintf(buf, size,
2404	fmt: "urb/%p %s ep%d%s%s len %d/%d\n",
2405	urb,
2406	({ char *s;
2407	switch (urb->dev->speed) {
2408	case USB_SPEED_LOW:
2409	s = "ls";
2410	break;
2411	case USB_SPEED_FULL:
2412	s = "fs";
2413	break;
2414	case USB_SPEED_HIGH:
2415	s = "hs";
2416	break;
2417	case USB_SPEED_SUPER:
2418	s = "ss";
2419	break;
2420	default:
2421	s = "?";
2422	break;
2423	} s; }),
2424	ep, ep ? (usb_urb_dir_in(urb) ? "in" : "out") : "",
2425	({ char *s; \
2426	switch (usb_pipetype(urb->pipe)) { \
2427	case PIPE_CONTROL: \
2428	s = ""; \
2429	break; \
2430	case PIPE_BULK: \
2431	s = "-bulk"; \
2432	break; \
2433	case PIPE_INTERRUPT: \
2434	s = "-int"; \
2435	break; \
2436	default: \
2437	s = "-iso"; \
2438	break; \
2439	} s; }),
2440	urb->actual_length, urb->transfer_buffer_length);
2441	}
2442
2443	static ssize_t urbs_show(struct device *dev, struct device_attribute *attr,
2444	char *buf)
2445	{
2446	struct usb_hcd *hcd = dev_get_drvdata(dev);
2447	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2448	struct urbp *urbp;
2449	size_t size = 0;
2450	unsigned long flags;
2451
2452	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2453	list_for_each_entry(urbp, &dum_hcd->urbp_list, urbp_list) {
2454	size_t temp;
2455
2456	temp = show_urb(buf, PAGE_SIZE - size, urb: urbp->urb);
2457	buf += temp;
2458	size += temp;
2459	}
2460	spin_unlock_irqrestore(lock: &dum_hcd->dum->lock, flags);
2461
2462	return size;
2463	}
2464	static DEVICE_ATTR_RO(urbs);
2465
2466	static int dummy_start_ss(struct dummy_hcd *dum_hcd)
2467	{
2468	timer_setup(&dum_hcd->timer, dummy_timer, 0);
2469	dum_hcd->rh_state = DUMMY_RH_RUNNING;
2470	dum_hcd->stream_en_ep = 0;
2471	INIT_LIST_HEAD(list: &dum_hcd->urbp_list);
2472	dummy_hcd_to_hcd(dum: dum_hcd)->power_budget = POWER_BUDGET_3;
2473	dummy_hcd_to_hcd(dum: dum_hcd)->state = HC_STATE_RUNNING;
2474	dummy_hcd_to_hcd(dum: dum_hcd)->uses_new_polling = 1;
2475	#ifdef CONFIG_USB_OTG
2476	dummy_hcd_to_hcd(dum: dum_hcd)->self.otg_port = 1;
2477	#endif
2478	return 0;
2479
2480	/* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
2481	return device_create_file(device: dummy_dev(dum: dum_hcd), entry: &dev_attr_urbs);
2482	}
2483
2484	static int dummy_start(struct usb_hcd *hcd)
2485	{
2486	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2487
2488	/*
2489	* HOST side init ... we emulate a root hub that'll only ever
2490	* talk to one device (the gadget side). Also appears in sysfs,
2491	* just like more familiar pci-based HCDs.
2492	*/
2493	if (!usb_hcd_is_primary_hcd(hcd))
2494	return dummy_start_ss(dum_hcd);
2495
2496	spin_lock_init(&dum_hcd->dum->lock);
2497	timer_setup(&dum_hcd->timer, dummy_timer, 0);
2498	dum_hcd->rh_state = DUMMY_RH_RUNNING;
2499
2500	INIT_LIST_HEAD(list: &dum_hcd->urbp_list);
2501
2502	hcd->power_budget = POWER_BUDGET;
2503	hcd->state = HC_STATE_RUNNING;
2504	hcd->uses_new_polling = 1;
2505
2506	#ifdef CONFIG_USB_OTG
2507	hcd->self.otg_port = 1;
2508	#endif
2509
2510	/* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
2511	return device_create_file(device: dummy_dev(dum: dum_hcd), entry: &dev_attr_urbs);
2512	}
2513
2514	static void dummy_stop(struct usb_hcd *hcd)
2515	{
2516	device_remove_file(dev: dummy_dev(dum: hcd_to_dummy_hcd(hcd)), attr: &dev_attr_urbs);
2517	dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n");
2518	}
2519
2520	/*-------------------------------------------------------------------------*/
2521
2522	static int dummy_h_get_frame(struct usb_hcd *hcd)
2523	{
2524	return dummy_g_get_frame(NULL);
2525	}
2526
2527	static int dummy_setup(struct usb_hcd *hcd)
2528	{
2529	struct dummy *dum;
2530
2531	dum = *((void **)dev_get_platdata(dev: hcd->self.controller));
2532	hcd->self.sg_tablesize = ~0;
2533	if (usb_hcd_is_primary_hcd(hcd)) {
2534	dum->hs_hcd = hcd_to_dummy_hcd(hcd);
2535	dum->hs_hcd->dum = dum;
2536	/*
2537	* Mark the first roothub as being USB 2.0.
2538	* The USB 3.0 roothub will be registered later by
2539	* dummy_hcd_probe()
2540	*/
2541	hcd->speed = HCD_USB2;
2542	hcd->self.root_hub->speed = USB_SPEED_HIGH;
2543	} else {
2544	dum->ss_hcd = hcd_to_dummy_hcd(hcd);
2545	dum->ss_hcd->dum = dum;
2546	hcd->speed = HCD_USB3;
2547	hcd->self.root_hub->speed = USB_SPEED_SUPER;
2548	}
2549	return 0;
2550	}
2551
2552	/* Change a group of bulk endpoints to support multiple stream IDs */
2553	static int dummy_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
2554	struct usb_host_endpoint **eps, unsigned int num_eps,
2555	unsigned int num_streams, gfp_t mem_flags)
2556	{
2557	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2558	unsigned long flags;
2559	int max_stream;
2560	int ret_streams = num_streams;
2561	unsigned int index;
2562	unsigned int i;
2563
2564	if (!num_eps)
2565	return -EINVAL;
2566
2567	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2568	for (i = 0; i < num_eps; i++) {
2569	index = dummy_get_ep_idx(desc: &eps[i]->desc);
2570	if ((1 << index) & dum_hcd->stream_en_ep) {
2571	ret_streams = -EINVAL;
2572	goto out;
2573	}
2574	max_stream = usb_ss_max_streams(comp: &eps[i]->ss_ep_comp);
2575	if (!max_stream) {
2576	ret_streams = -EINVAL;
2577	goto out;
2578	}
2579	if (max_stream < ret_streams) {
2580	dev_dbg(dummy_dev(dum_hcd), "Ep 0x%x only supports %u "
2581	"stream IDs.\n",
2582	eps[i]->desc.bEndpointAddress,
2583	max_stream);
2584	ret_streams = max_stream;
2585	}
2586	}
2587
2588	for (i = 0; i < num_eps; i++) {
2589	index = dummy_get_ep_idx(desc: &eps[i]->desc);
2590	dum_hcd->stream_en_ep |= 1 << index;
2591	set_max_streams_for_pipe(dum_hcd,
2592	pipe: usb_endpoint_num(epd: &eps[i]->desc), streams: ret_streams);
2593	}
2594	out:
2595	spin_unlock_irqrestore(lock: &dum_hcd->dum->lock, flags);
2596	return ret_streams;
2597	}
2598
2599	/* Reverts a group of bulk endpoints back to not using stream IDs. */
2600	static int dummy_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
2601	struct usb_host_endpoint **eps, unsigned int num_eps,
2602	gfp_t mem_flags)
2603	{
2604	struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2605	unsigned long flags;
2606	int ret;
2607	unsigned int index;
2608	unsigned int i;
2609
2610	spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2611	for (i = 0; i < num_eps; i++) {
2612	index = dummy_get_ep_idx(desc: &eps[i]->desc);
2613	if (!((1 << index) & dum_hcd->stream_en_ep)) {
2614	ret = -EINVAL;
2615	goto out;
2616	}
2617	}
2618
2619	for (i = 0; i < num_eps; i++) {
2620	index = dummy_get_ep_idx(desc: &eps[i]->desc);
2621	dum_hcd->stream_en_ep &= ~(1 << index);
2622	set_max_streams_for_pipe(dum_hcd,
2623	pipe: usb_endpoint_num(epd: &eps[i]->desc), streams: 0);
2624	}
2625	ret = 0;
2626	out:
2627	spin_unlock_irqrestore(lock: &dum_hcd->dum->lock, flags);
2628	return ret;
2629	}
2630
2631	static struct hc_driver dummy_hcd = {
2632	.description = (char *) driver_name,
2633	.product_desc = "Dummy host controller",
2634	.hcd_priv_size = sizeof(struct dummy_hcd),
2635
2636	.reset = dummy_setup,
2637	.start = dummy_start,
2638	.stop = dummy_stop,
2639
2640	.urb_enqueue = dummy_urb_enqueue,
2641	.urb_dequeue = dummy_urb_dequeue,
2642
2643	.get_frame_number = dummy_h_get_frame,
2644
2645	.hub_status_data = dummy_hub_status,
2646	.hub_control = dummy_hub_control,
2647	.bus_suspend = dummy_bus_suspend,
2648	.bus_resume = dummy_bus_resume,
2649
2650	.alloc_streams = dummy_alloc_streams,
2651	.free_streams = dummy_free_streams,
2652	};
2653
2654	static int dummy_hcd_probe(struct platform_device *pdev)
2655	{
2656	struct dummy *dum;
2657	struct usb_hcd *hs_hcd;
2658	struct usb_hcd *ss_hcd;
2659	int retval;
2660
2661	dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
2662	dum = *((void **)dev_get_platdata(dev: &pdev->dev));
2663
2664	if (mod_data.is_super_speed)
2665	dummy_hcd.flags = HCD_USB3 | HCD_SHARED;
2666	else if (mod_data.is_high_speed)
2667	dummy_hcd.flags = HCD_USB2;
2668	else
2669	dummy_hcd.flags = HCD_USB11;
2670	hs_hcd = usb_create_hcd(driver: &dummy_hcd, dev: &pdev->dev, bus_name: dev_name(dev: &pdev->dev));
2671	if (!hs_hcd)
2672	return -ENOMEM;
2673	hs_hcd->has_tt = 1;
2674
2675	retval = usb_add_hcd(hcd: hs_hcd, irqnum: 0, irqflags: 0);
2676	if (retval)
2677	goto put_usb2_hcd;
2678
2679	if (mod_data.is_super_speed) {
2680	ss_hcd = usb_create_shared_hcd(driver: &dummy_hcd, dev: &pdev->dev,
2681	bus_name: dev_name(dev: &pdev->dev), shared_hcd: hs_hcd);
2682	if (!ss_hcd) {
2683	retval = -ENOMEM;
2684	goto dealloc_usb2_hcd;
2685	}
2686
2687	retval = usb_add_hcd(hcd: ss_hcd, irqnum: 0, irqflags: 0);
2688	if (retval)
2689	goto put_usb3_hcd;
2690	}
2691	return 0;
2692
2693	put_usb3_hcd:
2694	usb_put_hcd(hcd: ss_hcd);
2695	dealloc_usb2_hcd:
2696	usb_remove_hcd(hcd: hs_hcd);
2697	put_usb2_hcd:
2698	usb_put_hcd(hcd: hs_hcd);
2699	dum->hs_hcd = dum->ss_hcd = NULL;
2700	return retval;
2701	}
2702
2703	static void dummy_hcd_remove(struct platform_device *pdev)
2704	{
2705	struct dummy *dum;
2706
2707	dum = hcd_to_dummy_hcd(hcd: platform_get_drvdata(pdev))->dum;
2708
2709	if (dum->ss_hcd) {
2710	usb_remove_hcd(hcd: dummy_hcd_to_hcd(dum: dum->ss_hcd));
2711	usb_put_hcd(hcd: dummy_hcd_to_hcd(dum: dum->ss_hcd));
2712	}
2713
2714	usb_remove_hcd(hcd: dummy_hcd_to_hcd(dum: dum->hs_hcd));
2715	usb_put_hcd(hcd: dummy_hcd_to_hcd(dum: dum->hs_hcd));
2716
2717	dum->hs_hcd = NULL;
2718	dum->ss_hcd = NULL;
2719	}
2720
2721	static int dummy_hcd_suspend(struct platform_device *pdev, pm_message_t state)
2722	{
2723	struct usb_hcd *hcd;
2724	struct dummy_hcd *dum_hcd;
2725	int rc = 0;
2726
2727	dev_dbg(&pdev->dev, "%s\n", __func__);
2728
2729	hcd = platform_get_drvdata(pdev);
2730	dum_hcd = hcd_to_dummy_hcd(hcd);
2731	if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
2732	dev_warn(&pdev->dev, "Root hub isn't suspended!\n");
2733	rc = -EBUSY;
2734	} else
2735	clear_bit(HCD_FLAG_HW_ACCESSIBLE, addr: &hcd->flags);
2736	return rc;
2737	}
2738
2739	static int dummy_hcd_resume(struct platform_device *pdev)
2740	{
2741	struct usb_hcd *hcd;
2742
2743	dev_dbg(&pdev->dev, "%s\n", __func__);
2744
2745	hcd = platform_get_drvdata(pdev);
2746	set_bit(HCD_FLAG_HW_ACCESSIBLE, addr: &hcd->flags);
2747	usb_hcd_poll_rh_status(hcd);
2748	return 0;
2749	}
2750
2751	static struct platform_driver dummy_hcd_driver = {
2752	.probe = dummy_hcd_probe,
2753	.remove_new = dummy_hcd_remove,
2754	.suspend = dummy_hcd_suspend,
2755	.resume = dummy_hcd_resume,
2756	.driver = {
2757	.name = driver_name,
2758	},
2759	};
2760
2761	/*-------------------------------------------------------------------------*/
2762	#define MAX_NUM_UDC 32
2763	static struct platform_device *the_udc_pdev[MAX_NUM_UDC];
2764	static struct platform_device *the_hcd_pdev[MAX_NUM_UDC];
2765
2766	static int __init dummy_hcd_init(void)
2767	{
2768	int retval = -ENOMEM;
2769	int i;
2770	struct dummy *dum[MAX_NUM_UDC] = {};
2771
2772	if (usb_disabled())
2773	return -ENODEV;
2774
2775	if (!mod_data.is_high_speed && mod_data.is_super_speed)
2776	return -EINVAL;
2777
2778	if (mod_data.num < 1 || mod_data.num > MAX_NUM_UDC) {
2779	pr_err("Number of emulated UDC must be in range of 1...%d\n",
2780	MAX_NUM_UDC);
2781	return -EINVAL;
2782	}
2783
2784	for (i = 0; i < mod_data.num; i++) {
2785	the_hcd_pdev[i] = platform_device_alloc(name: driver_name, id: i);
2786	if (!the_hcd_pdev[i]) {
2787	i--;
2788	while (i >= 0)
2789	platform_device_put(pdev: the_hcd_pdev[i--]);
2790	return retval;
2791	}
2792	}
2793	for (i = 0; i < mod_data.num; i++) {
2794	the_udc_pdev[i] = platform_device_alloc(name: gadget_name, id: i);
2795	if (!the_udc_pdev[i]) {
2796	i--;
2797	while (i >= 0)
2798	platform_device_put(pdev: the_udc_pdev[i--]);
2799	goto err_alloc_udc;
2800	}
2801	}
2802	for (i = 0; i < mod_data.num; i++) {
2803	dum[i] = kzalloc(size: sizeof(struct dummy), GFP_KERNEL);
2804	if (!dum[i]) {
2805	retval = -ENOMEM;
2806	goto err_add_pdata;
2807	}
2808	retval = platform_device_add_data(pdev: the_hcd_pdev[i], data: &dum[i],
2809	size: sizeof(void *));
2810	if (retval)
2811	goto err_add_pdata;
2812	retval = platform_device_add_data(pdev: the_udc_pdev[i], data: &dum[i],
2813	size: sizeof(void *));
2814	if (retval)
2815	goto err_add_pdata;
2816	}
2817
2818	retval = platform_driver_register(&dummy_hcd_driver);
2819	if (retval < 0)
2820	goto err_add_pdata;
2821	retval = platform_driver_register(&dummy_udc_driver);
2822	if (retval < 0)
2823	goto err_register_udc_driver;
2824
2825	for (i = 0; i < mod_data.num; i++) {
2826	retval = platform_device_add(pdev: the_hcd_pdev[i]);
2827	if (retval < 0) {
2828	i--;
2829	while (i >= 0)
2830	platform_device_del(pdev: the_hcd_pdev[i--]);
2831	goto err_add_hcd;
2832	}
2833	}
2834	for (i = 0; i < mod_data.num; i++) {
2835	if (!dum[i]->hs_hcd ||
2836	(!dum[i]->ss_hcd && mod_data.is_super_speed)) {
2837	/*
2838	* The hcd was added successfully but its probe
2839	* function failed for some reason.
2840	*/
2841	retval = -EINVAL;
2842	goto err_add_udc;
2843	}
2844	}
2845
2846	for (i = 0; i < mod_data.num; i++) {
2847	retval = platform_device_add(pdev: the_udc_pdev[i]);
2848	if (retval < 0) {
2849	i--;
2850	while (i >= 0)
2851	platform_device_del(pdev: the_udc_pdev[i--]);
2852	goto err_add_udc;
2853	}
2854	}
2855
2856	for (i = 0; i < mod_data.num; i++) {
2857	if (!platform_get_drvdata(pdev: the_udc_pdev[i])) {
2858	/*
2859	* The udc was added successfully but its probe
2860	* function failed for some reason.
2861	*/
2862	retval = -EINVAL;
2863	goto err_probe_udc;
2864	}
2865	}
2866	return retval;
2867
2868	err_probe_udc:
2869	for (i = 0; i < mod_data.num; i++)
2870	platform_device_del(pdev: the_udc_pdev[i]);
2871	err_add_udc:
2872	for (i = 0; i < mod_data.num; i++)
2873	platform_device_del(pdev: the_hcd_pdev[i]);
2874	err_add_hcd:
2875	platform_driver_unregister(&dummy_udc_driver);
2876	err_register_udc_driver:
2877	platform_driver_unregister(&dummy_hcd_driver);
2878	err_add_pdata:
2879	for (i = 0; i < mod_data.num; i++)
2880	kfree(objp: dum[i]);
2881	for (i = 0; i < mod_data.num; i++)
2882	platform_device_put(pdev: the_udc_pdev[i]);
2883	err_alloc_udc:
2884	for (i = 0; i < mod_data.num; i++)
2885	platform_device_put(pdev: the_hcd_pdev[i]);
2886	return retval;
2887	}
2888	module_init(dummy_hcd_init);
2889
2890	static void __exit dummy_hcd_cleanup(void)
2891	{
2892	int i;
2893
2894	for (i = 0; i < mod_data.num; i++) {
2895	struct dummy *dum;
2896
2897	dum = *((void **)dev_get_platdata(dev: &the_udc_pdev[i]->dev));
2898
2899	platform_device_unregister(the_udc_pdev[i]);
2900	platform_device_unregister(the_hcd_pdev[i]);
2901	kfree(objp: dum);
2902	}
2903	platform_driver_unregister(&dummy_udc_driver);
2904	platform_driver_unregister(&dummy_hcd_driver);
2905	}
2906	module_exit(dummy_hcd_cleanup);
2907