xref: /openbmc/linux/drivers/usb/gadget/udc/dummy_hcd.c (revision 2dd3f64f)
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 
usb_ep_to_dummy_ep(struct usb_ep * _ep)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 
usb_request_to_dummy_request(struct usb_request * _req)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 
hcd_to_dummy_hcd(struct usb_hcd * hcd)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 
dummy_hcd_to_hcd(struct dummy_hcd * dum)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 
dummy_dev(struct dummy_hcd * dum)295 static inline struct device *dummy_dev(struct dummy_hcd *dum)
296 {
297 	return dummy_hcd_to_hcd(dum)->self.controller;
298 }
299 
udc_dev(struct dummy * dum)300 static inline struct device *udc_dev(struct dummy *dum)
301 {
302 	return dum->gadget.dev.parent;
303 }
304 
ep_to_dummy(struct dummy_ep * ep)305 static inline struct dummy *ep_to_dummy(struct dummy_ep *ep)
306 {
307 	return container_of(ep->gadget, struct dummy, gadget);
308 }
309 
gadget_to_dummy_hcd(struct usb_gadget * gadget)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 
gadget_dev_to_dummy(struct device * dev)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 */
nuke(struct dummy * dum,struct dummy_ep * ep)329 static void nuke(struct dummy *dum, struct dummy_ep *ep)
330 {
331 	while (!list_empty(&ep->queue)) {
332 		struct dummy_request	*req;
333 
334 		req = list_entry(ep->queue.next, struct dummy_request, queue);
335 		list_del_init(&req->queue);
336 		req->req.status = -ESHUTDOWN;
337 
338 		spin_unlock(&dum->lock);
339 		usb_gadget_giveback_request(&ep->ep, &req->req);
340 		spin_lock(&dum->lock);
341 	}
342 }
343 
344 /* caller must hold lock */
stop_activity(struct dummy * dum)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, &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  */
set_link_state_by_speed(struct dummy_hcd * dum_hcd)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_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 */
set_link_state(struct dummy_hcd * dum_hcd)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_hcd)->speed == HCD_USB3 &&
438 		     dum->gadget.speed != USB_SPEED_SUPER) ||
439 		    (dummy_hcd_to_hcd(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_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(&dum->lock);
464 			if (reset)
465 				usb_gadget_udc_reset(&dum->gadget, dum->driver);
466 			else
467 				dum->driver->disconnect(&dum->gadget);
468 			spin_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(&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(&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 
dummy_enable(struct usb_ep * _ep,const struct usb_endpoint_descriptor * desc)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(&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(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(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(_ep->comp_desc)) {
611 		if (!usb_endpoint_xfer_bulk(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 
dummy_disable(struct usb_ep * _ep)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(&dum->lock, flags);
652 
653 	dev_dbg(udc_dev(dum), "disabled %s\n", _ep->name);
654 	return 0;
655 }
656 
dummy_alloc_request(struct usb_ep * _ep,gfp_t mem_flags)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(sizeof(*req), mem_flags);
666 	if (!req)
667 		return NULL;
668 	INIT_LIST_HEAD(&req->queue);
669 	return &req->req;
670 }
671 
dummy_free_request(struct usb_ep * _ep,struct usb_request * _req)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(req);
684 }
685 
fifo_complete(struct usb_ep * ep,struct usb_request * req)686 static void fifo_complete(struct usb_ep *ep, struct usb_request *req)
687 {
688 }
689 
dummy_queue(struct usb_ep * _ep,struct usb_request * _req,gfp_t mem_flags)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(&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(&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(&dum->fifo_req.queue) &&
723 			list_empty(&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(&req->queue, &ep->queue);
733 		spin_unlock(&dum->lock);
734 		_req->actual = _req->length;
735 		_req->status = 0;
736 		usb_gadget_giveback_request(_ep, _req);
737 		spin_lock(&dum->lock);
738 	}  else
739 		list_add_tail(&req->queue, &ep->queue);
740 	spin_unlock_irqrestore(&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 
dummy_dequeue(struct usb_ep * _ep,struct usb_request * _req)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(&dum->lock);
766 	list_for_each_entry(iter, &ep->queue, queue) {
767 		if (&iter->req != _req)
768 			continue;
769 		list_del_init(&iter->queue);
770 		_req->status = -ECONNRESET;
771 		req = iter;
772 		retval = 0;
773 		break;
774 	}
775 	spin_unlock(&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, _req);
782 	}
783 	local_irq_restore(flags);
784 	return retval;
785 }
786 
787 static int
dummy_set_halt_and_wedge(struct usb_ep * _ep,int value,int wedged)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(&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
dummy_set_halt(struct usb_ep * _ep,int value)814 dummy_set_halt(struct usb_ep *_ep, int value)
815 {
816 	return dummy_set_halt_and_wedge(_ep, value, 0);
817 }
818 
dummy_set_wedge(struct usb_ep * _ep)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, 1, 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 ... */
dummy_g_get_frame(struct usb_gadget * _gadget)843 static int dummy_g_get_frame(struct usb_gadget *_gadget)
844 {
845 	struct timespec64 ts64;
846 
847 	ktime_get_ts64(&ts64);
848 	return ts64.tv_nsec / NSEC_PER_MSEC;
849 }
850 
dummy_wakeup(struct usb_gadget * _gadget)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);
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(20);
870 	mod_timer(&dummy_hcd_to_hcd(dum_hcd)->rh_timer, dum_hcd->re_timeout);
871 	return 0;
872 }
873 
dummy_set_selfpowered(struct usb_gadget * _gadget,int value)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)->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 
dummy_udc_update_ep0(struct dummy * dum)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 
dummy_pullup(struct usb_gadget * _gadget,int value)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(&_gadget->dev);
902 	dum_hcd = gadget_to_dummy_hcd(_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(&dum->lock, flags);
918 			usleep_range(1000, 2000);
919 			spin_lock_irqsave(&dum->lock, flags);
920 		}
921 	}
922 	spin_unlock_irqrestore(&dum->lock, flags);
923 
924 	usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
925 	return 0;
926 }
927 
dummy_udc_set_speed(struct usb_gadget * _gadget,enum usb_device_speed speed)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(&_gadget->dev);
934 	dum->gadget.speed = speed;
935 	dummy_udc_update_ep0(dum);
936 }
937 
dummy_udc_async_callbacks(struct usb_gadget * _gadget,bool enable)938 static void dummy_udc_async_callbacks(struct usb_gadget *_gadget, bool enable)
939 {
940 	struct dummy	*dum = gadget_dev_to_dummy(&_gadget->dev);
941 
942 	spin_lock_irq(&dum->lock);
943 	dum->ints_enabled = enable;
944 	spin_unlock_irq(&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 */
function_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%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 
dummy_udc_start(struct usb_gadget * g,struct usb_gadget_driver * driver)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(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(&dum->lock);
1017 	dum->devstatus = 0;
1018 	dum->driver = driver;
1019 	spin_unlock_irq(&dum->lock);
1020 
1021 	return 0;
1022 }
1023 
dummy_udc_stop(struct usb_gadget * g)1024 static int dummy_udc_stop(struct usb_gadget *g)
1025 {
1026 	struct dummy_hcd	*dum_hcd = gadget_to_dummy_hcd(g);
1027 	struct dummy		*dum = dum_hcd->dum;
1028 
1029 	spin_lock_irq(&dum->lock);
1030 	dum->ints_enabled = 0;
1031 	stop_activity(dum);
1032 	dum->driver = NULL;
1033 	spin_unlock_irq(&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. */
init_dummy_udc_hw(struct dummy * dum)1042 static void init_dummy_udc_hw(struct dummy *dum)
1043 {
1044 	int i;
1045 
1046 	INIT_LIST_HEAD(&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(&ep->ep.ep_list, &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, ~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(&ep->queue);
1064 	}
1065 
1066 	dum->gadget.ep0 = &dum->ep[0].ep;
1067 	list_del_init(&dum->ep[0].ep.ep_list);
1068 	INIT_LIST_HEAD(&dum->fifo_req.queue);
1069 
1070 #ifdef CONFIG_USB_OTG
1071 	dum->gadget.is_otg = 1;
1072 #endif
1073 }
1074 
dummy_udc_probe(struct platform_device * pdev)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(&pdev->dev));
1081 	/* Clear usb_gadget region for new registration to udc-core */
1082 	memzero_explicit(&dum->gadget, 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(&pdev->dev, &dum->gadget);
1096 	if (rc < 0)
1097 		goto err_udc;
1098 
1099 	rc = device_create_file(&dum->gadget.dev, &dev_attr_function);
1100 	if (rc < 0)
1101 		goto err_dev;
1102 	platform_set_drvdata(pdev, dum);
1103 	return rc;
1104 
1105 err_dev:
1106 	usb_del_gadget_udc(&dum->gadget);
1107 err_udc:
1108 	return rc;
1109 }
1110 
dummy_udc_remove(struct platform_device * pdev)1111 static void dummy_udc_remove(struct platform_device *pdev)
1112 {
1113 	struct dummy	*dum = platform_get_drvdata(pdev);
1114 
1115 	device_remove_file(&dum->gadget.dev, &dev_attr_function);
1116 	usb_del_gadget_udc(&dum->gadget);
1117 }
1118 
dummy_udc_pm(struct dummy * dum,struct dummy_hcd * dum_hcd,int suspend)1119 static void dummy_udc_pm(struct dummy *dum, struct dummy_hcd *dum_hcd,
1120 		int suspend)
1121 {
1122 	spin_lock_irq(&dum->lock);
1123 	dum->udc_suspended = suspend;
1124 	set_link_state(dum_hcd);
1125 	spin_unlock_irq(&dum->lock);
1126 }
1127 
dummy_udc_suspend(struct platform_device * pdev,pm_message_t state)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(&dum->gadget);
1132 
1133 	dev_dbg(&pdev->dev, "%s\n", __func__);
1134 	dummy_udc_pm(dum, dum_hcd, 1);
1135 	usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1136 	return 0;
1137 }
1138 
dummy_udc_resume(struct platform_device * pdev)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(&dum->gadget);
1143 
1144 	dev_dbg(&pdev->dev, "%s\n", __func__);
1145 	dummy_udc_pm(dum, dum_hcd, 0);
1146 	usb_hcd_poll_rh_status(dummy_hcd_to_hcd(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 
dummy_get_ep_idx(const struct usb_endpoint_descriptor * desc)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(desc) << 1;
1167 	if (usb_endpoint_dir_in(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 
dummy_ep_stream_en(struct dummy_hcd * dum_hcd,struct urb * urb)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(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  */
get_max_streams_for_pipe(struct dummy_hcd * dum_hcd,unsigned int pipe)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 
set_max_streams_for_pipe(struct dummy_hcd * dum_hcd,unsigned int pipe,unsigned int streams)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 
dummy_validate_stream(struct dummy_hcd * dum_hcd,struct urb * urb)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 
dummy_urb_enqueue(struct usb_hcd * hcd,struct urb * urb,gfp_t mem_flags)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(sizeof *urbp, 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(urbp);
1281 		goto done;
1282 	}
1283 
1284 	rc = usb_hcd_link_urb_to_ep(hcd, urb);
1285 	if (rc) {
1286 		kfree(urbp);
1287 		goto done;
1288 	}
1289 
1290 	if (!dum_hcd->udev) {
1291 		dum_hcd->udev = urb->dev;
1292 		usb_get_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(&urbp->urbp_list, &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(&dum_hcd->timer))
1305 		mod_timer(&dum_hcd->timer, jiffies + 1);
1306 
1307  done:
1308 	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1309 	return rc;
1310 }
1311 
dummy_urb_dequeue(struct usb_hcd * hcd,struct urb * urb,int status)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(&dum_hcd->urbp_list))
1326 		mod_timer(&dum_hcd->timer, jiffies);
1327 
1328 	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1329 	return rc;
1330 }
1331 
dummy_perform_transfer(struct urb * urb,struct dummy_request * req,u32 len)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, urb->sg, 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 */
transfer(struct dummy_hcd * dum_hcd,struct urb * urb,struct dummy_ep * ep,int limit,int * status)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(&req->queue);
1513 
1514 			spin_unlock(&dum->lock);
1515 			usb_gadget_giveback_request(&ep->ep, &req->req);
1516 			spin_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 
periodic_bytes(struct dummy * dum,struct dummy_ep * ep)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(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(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 
find_endpoint(struct dummy * dum,u8 address)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  */
handle_control_request(struct dummy_hcd * dum_hcd,struct urb * urb,struct usb_ctrlrequest * setup,int * status)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_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_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_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, 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_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_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_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, 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, 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  */
dummy_timer(struct timer_list * t)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(&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(&req->queue);
1891 				req->req.status = -EOVERFLOW;
1892 				dev_dbg(udc_dev(dum), "stale req = %p\n",
1893 						req);
1894 
1895 				spin_unlock(&dum->lock);
1896 				usb_gadget_giveback_request(&ep->ep, &req->req);
1897 				spin_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,
1911 						       &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(&dum->lock);
1919 				value = dum->driver->setup(&dum->gadget,
1920 						&setup);
1921 				spin_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);
1972 			break;
1973 		}
1974 
1975 		/* incomplete transfer? */
1976 		if (status == -EINPROGRESS)
1977 			continue;
1978 
1979 return_urb:
1980 		list_del(&urbp->urbp_list);
1981 		kfree(urbp);
1982 		if (ep)
1983 			ep->already_seen = ep->setup_stage = 0;
1984 
1985 		usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd), urb);
1986 		spin_unlock(&dum->lock);
1987 		usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd), urb, status);
1988 		spin_lock(&dum->lock);
1989 
1990 		goto restart;
1991 	}
1992 
1993 	if (list_empty(&dum_hcd->urbp_list)) {
1994 		usb_put_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(&dum_hcd->timer, jiffies + msecs_to_jiffies(1));
1999 	}
2000 
2001 	spin_unlock_irqrestore(&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 
dummy_hub_status(struct usb_hcd * hcd,char * buf)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(&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
ss_hub_descriptor(struct usb_hub_descriptor * desc)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 
hub_descriptor(struct usb_hub_descriptor * desc)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 
dummy_hub_control(struct usb_hcd * hcd,u16 typeReq,u16 wValue,u16 wIndex,char * buf,u16 wLength)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(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((struct usb_hub_descriptor *) buf);
2165 		else
2166 			hub_descriptor((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(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(&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 
dummy_bus_suspend(struct usb_hcd * hcd)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(&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(&dum_hcd->dum->lock);
2373 	return 0;
2374 }
2375 
dummy_bus_resume(struct usb_hcd * hcd)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(&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(&dum_hcd->urbp_list))
2390 			mod_timer(&dum_hcd->timer, jiffies);
2391 		hcd->state = HC_STATE_RUNNING;
2392 	}
2393 	spin_unlock_irq(&dum_hcd->dum->lock);
2394 	return rc;
2395 }
2396 
2397 /*-------------------------------------------------------------------------*/
2398 
show_urb(char * buf,size_t size,struct urb * urb)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 		"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 
urbs_show(struct device * dev,struct device_attribute * attr,char * buf)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, urbp->urb);
2457 		buf += temp;
2458 		size += temp;
2459 	}
2460 	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2461 
2462 	return size;
2463 }
2464 static DEVICE_ATTR_RO(urbs);
2465 
dummy_start_ss(struct dummy_hcd * dum_hcd)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(&dum_hcd->urbp_list);
2472 	dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET_3;
2473 	dummy_hcd_to_hcd(dum_hcd)->state = HC_STATE_RUNNING;
2474 	dummy_hcd_to_hcd(dum_hcd)->uses_new_polling = 1;
2475 #ifdef CONFIG_USB_OTG
2476 	dummy_hcd_to_hcd(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(dummy_dev(dum_hcd), &dev_attr_urbs);
2482 }
2483 
dummy_start(struct usb_hcd * hcd)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(&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(dummy_dev(dum_hcd), &dev_attr_urbs);
2512 }
2513 
dummy_stop(struct usb_hcd * hcd)2514 static void dummy_stop(struct usb_hcd *hcd)
2515 {
2516 	device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd)), &dev_attr_urbs);
2517 	dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n");
2518 }
2519 
2520 /*-------------------------------------------------------------------------*/
2521 
dummy_h_get_frame(struct usb_hcd * hcd)2522 static int dummy_h_get_frame(struct usb_hcd *hcd)
2523 {
2524 	return dummy_g_get_frame(NULL);
2525 }
2526 
dummy_setup(struct usb_hcd * hcd)2527 static int dummy_setup(struct usb_hcd *hcd)
2528 {
2529 	struct dummy *dum;
2530 
2531 	dum = *((void **)dev_get_platdata(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 */
dummy_alloc_streams(struct usb_hcd * hcd,struct usb_device * udev,struct usb_host_endpoint ** eps,unsigned int num_eps,unsigned int num_streams,gfp_t mem_flags)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(&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(&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(&eps[i]->desc);
2590 		dum_hcd->stream_en_ep |= 1 << index;
2591 		set_max_streams_for_pipe(dum_hcd,
2592 				usb_endpoint_num(&eps[i]->desc), ret_streams);
2593 	}
2594 out:
2595 	spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2596 	return ret_streams;
2597 }
2598 
2599 /* Reverts a group of bulk endpoints back to not using stream IDs. */
dummy_free_streams(struct usb_hcd * hcd,struct usb_device * udev,struct usb_host_endpoint ** eps,unsigned int num_eps,gfp_t mem_flags)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(&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(&eps[i]->desc);
2621 		dum_hcd->stream_en_ep &= ~(1 << index);
2622 		set_max_streams_for_pipe(dum_hcd,
2623 				usb_endpoint_num(&eps[i]->desc), 0);
2624 	}
2625 	ret = 0;
2626 out:
2627 	spin_unlock_irqrestore(&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 
dummy_hcd_probe(struct platform_device * pdev)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(&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(&dummy_hcd, &pdev->dev, dev_name(&pdev->dev));
2671 	if (!hs_hcd)
2672 		return -ENOMEM;
2673 	hs_hcd->has_tt = 1;
2674 
2675 	retval = usb_add_hcd(hs_hcd, 0, 0);
2676 	if (retval)
2677 		goto put_usb2_hcd;
2678 
2679 	if (mod_data.is_super_speed) {
2680 		ss_hcd = usb_create_shared_hcd(&dummy_hcd, &pdev->dev,
2681 					dev_name(&pdev->dev), hs_hcd);
2682 		if (!ss_hcd) {
2683 			retval = -ENOMEM;
2684 			goto dealloc_usb2_hcd;
2685 		}
2686 
2687 		retval = usb_add_hcd(ss_hcd, 0, 0);
2688 		if (retval)
2689 			goto put_usb3_hcd;
2690 	}
2691 	return 0;
2692 
2693 put_usb3_hcd:
2694 	usb_put_hcd(ss_hcd);
2695 dealloc_usb2_hcd:
2696 	usb_remove_hcd(hs_hcd);
2697 put_usb2_hcd:
2698 	usb_put_hcd(hs_hcd);
2699 	dum->hs_hcd = dum->ss_hcd = NULL;
2700 	return retval;
2701 }
2702 
dummy_hcd_remove(struct platform_device * pdev)2703 static void dummy_hcd_remove(struct platform_device *pdev)
2704 {
2705 	struct dummy		*dum;
2706 
2707 	dum = hcd_to_dummy_hcd(platform_get_drvdata(pdev))->dum;
2708 
2709 	if (dum->ss_hcd) {
2710 		usb_remove_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
2711 		usb_put_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
2712 	}
2713 
2714 	usb_remove_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2715 	usb_put_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2716 
2717 	dum->hs_hcd = NULL;
2718 	dum->ss_hcd = NULL;
2719 }
2720 
dummy_hcd_suspend(struct platform_device * pdev,pm_message_t state)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, &hcd->flags);
2736 	return rc;
2737 }
2738 
dummy_hcd_resume(struct platform_device * pdev)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, &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 
dummy_hcd_init(void)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(driver_name, i);
2786 		if (!the_hcd_pdev[i]) {
2787 			i--;
2788 			while (i >= 0)
2789 				platform_device_put(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(gadget_name, i);
2795 		if (!the_udc_pdev[i]) {
2796 			i--;
2797 			while (i >= 0)
2798 				platform_device_put(the_udc_pdev[i--]);
2799 			goto err_alloc_udc;
2800 		}
2801 	}
2802 	for (i = 0; i < mod_data.num; i++) {
2803 		dum[i] = kzalloc(sizeof(struct dummy), GFP_KERNEL);
2804 		if (!dum[i]) {
2805 			retval = -ENOMEM;
2806 			goto err_add_pdata;
2807 		}
2808 		retval = platform_device_add_data(the_hcd_pdev[i], &dum[i],
2809 				sizeof(void *));
2810 		if (retval)
2811 			goto err_add_pdata;
2812 		retval = platform_device_add_data(the_udc_pdev[i], &dum[i],
2813 				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(the_hcd_pdev[i]);
2827 		if (retval < 0) {
2828 			i--;
2829 			while (i >= 0)
2830 				platform_device_del(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(the_udc_pdev[i]);
2848 		if (retval < 0) {
2849 			i--;
2850 			while (i >= 0)
2851 				platform_device_del(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(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(the_udc_pdev[i]);
2871 err_add_udc:
2872 	for (i = 0; i < mod_data.num; i++)
2873 		platform_device_del(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(dum[i]);
2881 	for (i = 0; i < mod_data.num; i++)
2882 		platform_device_put(the_udc_pdev[i]);
2883 err_alloc_udc:
2884 	for (i = 0; i < mod_data.num; i++)
2885 		platform_device_put(the_hcd_pdev[i]);
2886 	return retval;
2887 }
2888 module_init(dummy_hcd_init);
2889 
dummy_hcd_cleanup(void)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(&the_udc_pdev[i]->dev));
2898 
2899 		platform_device_unregister(the_udc_pdev[i]);
2900 		platform_device_unregister(the_hcd_pdev[i]);
2901 		kfree(dum);
2902 	}
2903 	platform_driver_unregister(&dummy_udc_driver);
2904 	platform_driver_unregister(&dummy_hcd_driver);
2905 }
2906 module_exit(dummy_hcd_cleanup);
2907