aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/gadget/dummy_hcd.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/usb/gadget/dummy_hcd.c')
-rw-r--r--drivers/usb/gadget/dummy_hcd.c1162
1 files changed, 794 insertions, 368 deletions
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index d3dcabc1a5fc..e755a9d267fc 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -70,6 +70,19 @@ MODULE_DESCRIPTION (DRIVER_DESC);
70MODULE_AUTHOR ("David Brownell"); 70MODULE_AUTHOR ("David Brownell");
71MODULE_LICENSE ("GPL"); 71MODULE_LICENSE ("GPL");
72 72
73struct dummy_hcd_module_parameters {
74 bool is_super_speed;
75 bool is_high_speed;
76};
77
78static struct dummy_hcd_module_parameters mod_data = {
79 .is_super_speed = false,
80 .is_high_speed = true,
81};
82module_param_named(is_super_speed, mod_data.is_super_speed, bool, S_IRUGO);
83MODULE_PARM_DESC(is_super_speed, "true to simulate SuperSpeed connection");
84module_param_named(is_high_speed, mod_data.is_high_speed, bool, S_IRUGO);
85MODULE_PARM_DESC(is_high_speed, "true to simulate HighSpeed connection");
73/*-------------------------------------------------------------------------*/ 86/*-------------------------------------------------------------------------*/
74 87
75/* gadget side driver data structres */ 88/* gadget side driver data structres */
@@ -152,6 +165,22 @@ enum dummy_rh_state {
152 DUMMY_RH_RUNNING 165 DUMMY_RH_RUNNING
153}; 166};
154 167
168struct dummy_hcd {
169 struct dummy *dum;
170 enum dummy_rh_state rh_state;
171 struct timer_list timer;
172 u32 port_status;
173 u32 old_status;
174 unsigned long re_timeout;
175
176 struct usb_device *udev;
177 struct list_head urbp_list;
178
179 unsigned active:1;
180 unsigned old_active:1;
181 unsigned resuming:1;
182};
183
155struct dummy { 184struct dummy {
156 spinlock_t lock; 185 spinlock_t lock;
157 186
@@ -167,36 +196,27 @@ struct dummy {
167 u16 devstatus; 196 u16 devstatus;
168 unsigned udc_suspended:1; 197 unsigned udc_suspended:1;
169 unsigned pullup:1; 198 unsigned pullup:1;
170 unsigned active:1;
171 unsigned old_active:1;
172 199
173 /* 200 /*
174 * MASTER/HOST side support 201 * MASTER/HOST side support
175 */ 202 */
176 enum dummy_rh_state rh_state; 203 struct dummy_hcd *hs_hcd;
177 struct timer_list timer; 204 struct dummy_hcd *ss_hcd;
178 u32 port_status;
179 u32 old_status;
180 unsigned resuming:1;
181 unsigned long re_timeout;
182
183 struct usb_device *udev;
184 struct list_head urbp_list;
185}; 205};
186 206
187static inline struct dummy *hcd_to_dummy (struct usb_hcd *hcd) 207static inline struct dummy_hcd *hcd_to_dummy_hcd(struct usb_hcd *hcd)
188{ 208{
189 return (struct dummy *) (hcd->hcd_priv); 209 return (struct dummy_hcd *) (hcd->hcd_priv);
190} 210}
191 211
192static inline struct usb_hcd *dummy_to_hcd (struct dummy *dum) 212static inline struct usb_hcd *dummy_hcd_to_hcd(struct dummy_hcd *dum)
193{ 213{
194 return container_of((void *) dum, struct usb_hcd, hcd_priv); 214 return container_of((void *) dum, struct usb_hcd, hcd_priv);
195} 215}
196 216
197static inline struct device *dummy_dev (struct dummy *dum) 217static inline struct device *dummy_dev(struct dummy_hcd *dum)
198{ 218{
199 return dummy_to_hcd(dum)->self.controller; 219 return dummy_hcd_to_hcd(dum)->self.controller;
200} 220}
201 221
202static inline struct device *udc_dev (struct dummy *dum) 222static inline struct device *udc_dev (struct dummy *dum)
@@ -209,9 +229,13 @@ static inline struct dummy *ep_to_dummy (struct dummy_ep *ep)
209 return container_of (ep->gadget, struct dummy, gadget); 229 return container_of (ep->gadget, struct dummy, gadget);
210} 230}
211 231
212static inline struct dummy *gadget_to_dummy (struct usb_gadget *gadget) 232static inline struct dummy_hcd *gadget_to_dummy_hcd(struct usb_gadget *gadget)
213{ 233{
214 return container_of (gadget, struct dummy, gadget); 234 struct dummy *dum = container_of(gadget, struct dummy, gadget);
235 if (dum->gadget.speed == USB_SPEED_SUPER)
236 return dum->ss_hcd;
237 else
238 return dum->hs_hcd;
215} 239}
216 240
217static inline struct dummy *gadget_dev_to_dummy (struct device *dev) 241static inline struct dummy *gadget_dev_to_dummy (struct device *dev)
@@ -219,7 +243,7 @@ static inline struct dummy *gadget_dev_to_dummy (struct device *dev)
219 return container_of (dev, struct dummy, gadget.dev); 243 return container_of (dev, struct dummy, gadget.dev);
220} 244}
221 245
222static struct dummy *the_controller; 246static struct dummy the_controller;
223 247
224/*-------------------------------------------------------------------------*/ 248/*-------------------------------------------------------------------------*/
225 249
@@ -259,61 +283,122 @@ stop_activity (struct dummy *dum)
259 /* driver now does any non-usb quiescing necessary */ 283 /* driver now does any non-usb quiescing necessary */
260} 284}
261 285
262/* caller must hold lock */ 286/**
263static void 287 * set_link_state_by_speed() - Sets the current state of the link according to
264set_link_state (struct dummy *dum) 288 * the hcd speed
265{ 289 * @dum_hcd: pointer to the dummy_hcd structure to update the link state for
266 dum->active = 0; 290 *
267 if ((dum->port_status & USB_PORT_STAT_POWER) == 0) 291 * This function updates the port_status according to the link state and the
268 dum->port_status = 0; 292 * speed of the hcd.
269 293 */
270 /* UDC suspend must cause a disconnect */ 294static void set_link_state_by_speed(struct dummy_hcd *dum_hcd)
271 else if (!dum->pullup || dum->udc_suspended) { 295{
272 dum->port_status &= ~(USB_PORT_STAT_CONNECTION | 296 struct dummy *dum = dum_hcd->dum;
273 USB_PORT_STAT_ENABLE | 297
274 USB_PORT_STAT_LOW_SPEED | 298 if (dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3) {
275 USB_PORT_STAT_HIGH_SPEED | 299 if ((dum_hcd->port_status & USB_SS_PORT_STAT_POWER) == 0) {
276 USB_PORT_STAT_SUSPEND); 300 dum_hcd->port_status = 0;
277 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0) 301 } else if (!dum->pullup || dum->udc_suspended) {
278 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16); 302 /* UDC suspend must cause a disconnect */
303 dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
304 USB_PORT_STAT_ENABLE);
305 if ((dum_hcd->old_status &
306 USB_PORT_STAT_CONNECTION) != 0)
307 dum_hcd->port_status |=
308 (USB_PORT_STAT_C_CONNECTION << 16);
309 } else {
310 /* device is connected and not suspended */
311 dum_hcd->port_status |= (USB_PORT_STAT_CONNECTION |
312 USB_PORT_STAT_SPEED_5GBPS) ;
313 if ((dum_hcd->old_status &
314 USB_PORT_STAT_CONNECTION) == 0)
315 dum_hcd->port_status |=
316 (USB_PORT_STAT_C_CONNECTION << 16);
317 if ((dum_hcd->port_status &
318 USB_PORT_STAT_ENABLE) == 1 &&
319 (dum_hcd->port_status &
320 USB_SS_PORT_LS_U0) == 1 &&
321 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
322 dum_hcd->active = 1;
323 }
279 } else { 324 } else {
280 dum->port_status |= USB_PORT_STAT_CONNECTION; 325 if ((dum_hcd->port_status & USB_PORT_STAT_POWER) == 0) {
281 if ((dum->old_status & USB_PORT_STAT_CONNECTION) == 0) 326 dum_hcd->port_status = 0;
282 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16); 327 } else if (!dum->pullup || dum->udc_suspended) {
283 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0) 328 /* UDC suspend must cause a disconnect */
284 dum->port_status &= ~USB_PORT_STAT_SUSPEND; 329 dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
285 else if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 && 330 USB_PORT_STAT_ENABLE |
286 dum->rh_state != DUMMY_RH_SUSPENDED) 331 USB_PORT_STAT_LOW_SPEED |
287 dum->active = 1; 332 USB_PORT_STAT_HIGH_SPEED |
333 USB_PORT_STAT_SUSPEND);
334 if ((dum_hcd->old_status &
335 USB_PORT_STAT_CONNECTION) != 0)
336 dum_hcd->port_status |=
337 (USB_PORT_STAT_C_CONNECTION << 16);
338 } else {
339 dum_hcd->port_status |= USB_PORT_STAT_CONNECTION;
340 if ((dum_hcd->old_status &
341 USB_PORT_STAT_CONNECTION) == 0)
342 dum_hcd->port_status |=
343 (USB_PORT_STAT_C_CONNECTION << 16);
344 if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0)
345 dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
346 else if ((dum_hcd->port_status &
347 USB_PORT_STAT_SUSPEND) == 0 &&
348 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
349 dum_hcd->active = 1;
350 }
288 } 351 }
352}
353
354/* caller must hold lock */
355static void set_link_state(struct dummy_hcd *dum_hcd)
356{
357 struct dummy *dum = dum_hcd->dum;
289 358
290 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0 || dum->active) 359 dum_hcd->active = 0;
291 dum->resuming = 0; 360 if (dum->pullup)
361 if ((dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3 &&
362 dum->gadget.speed != USB_SPEED_SUPER) ||
363 (dummy_hcd_to_hcd(dum_hcd)->speed != HCD_USB3 &&
364 dum->gadget.speed == USB_SPEED_SUPER))
365 return;
292 366
293 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0 || 367 set_link_state_by_speed(dum_hcd);
294 (dum->port_status & USB_PORT_STAT_RESET) != 0) { 368
295 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0 && 369 if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0 ||
296 (dum->old_status & USB_PORT_STAT_RESET) == 0 && 370 dum_hcd->active)
297 dum->driver) { 371 dum_hcd->resuming = 0;
298 stop_activity (dum); 372
299 spin_unlock (&dum->lock); 373 /* if !connected or reset */
300 dum->driver->disconnect (&dum->gadget); 374 if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0 ||
301 spin_lock (&dum->lock); 375 (dum_hcd->port_status & USB_PORT_STAT_RESET) != 0) {
376 /*
377 * We're connected and not reset (reset occurred now),
378 * and driver attached - disconnect!
379 */
380 if ((dum_hcd->old_status & USB_PORT_STAT_CONNECTION) != 0 &&
381 (dum_hcd->old_status & USB_PORT_STAT_RESET) == 0 &&
382 dum->driver) {
383 stop_activity(dum);
384 spin_unlock(&dum->lock);
385 dum->driver->disconnect(&dum->gadget);
386 spin_lock(&dum->lock);
302 } 387 }
303 } else if (dum->active != dum->old_active) { 388 } else if (dum_hcd->active != dum_hcd->old_active) {
304 if (dum->old_active && dum->driver->suspend) { 389 if (dum_hcd->old_active && dum->driver->suspend) {
305 spin_unlock (&dum->lock); 390 spin_unlock(&dum->lock);
306 dum->driver->suspend (&dum->gadget); 391 dum->driver->suspend(&dum->gadget);
307 spin_lock (&dum->lock); 392 spin_lock(&dum->lock);
308 } else if (!dum->old_active && dum->driver->resume) { 393 } else if (!dum_hcd->old_active && dum->driver->resume) {
309 spin_unlock (&dum->lock); 394 spin_unlock(&dum->lock);
310 dum->driver->resume (&dum->gadget); 395 dum->driver->resume(&dum->gadget);
311 spin_lock (&dum->lock); 396 spin_lock(&dum->lock);
312 } 397 }
313 } 398 }
314 399
315 dum->old_status = dum->port_status; 400 dum_hcd->old_status = dum_hcd->port_status;
316 dum->old_active = dum->active; 401 dum_hcd->old_active = dum_hcd->active;
317} 402}
318 403
319/*-------------------------------------------------------------------------*/ 404/*-------------------------------------------------------------------------*/
@@ -332,6 +417,7 @@ static int
332dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) 417dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
333{ 418{
334 struct dummy *dum; 419 struct dummy *dum;
420 struct dummy_hcd *dum_hcd;
335 struct dummy_ep *ep; 421 struct dummy_ep *ep;
336 unsigned max; 422 unsigned max;
337 int retval; 423 int retval;
@@ -341,9 +427,19 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
341 || desc->bDescriptorType != USB_DT_ENDPOINT) 427 || desc->bDescriptorType != USB_DT_ENDPOINT)
342 return -EINVAL; 428 return -EINVAL;
343 dum = ep_to_dummy (ep); 429 dum = ep_to_dummy (ep);
344 if (!dum->driver || !is_enabled (dum)) 430 if (!dum->driver)
431 return -ESHUTDOWN;
432
433 dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
434 if (!is_enabled(dum_hcd))
345 return -ESHUTDOWN; 435 return -ESHUTDOWN;
346 max = le16_to_cpu(desc->wMaxPacketSize) & 0x3ff; 436
437 /*
438 * For HS/FS devices only bits 0..10 of the wMaxPacketSize represent the
439 * maximum packet size.
440 * For SS devices the wMaxPacketSize is limited by 1024.
441 */
442 max = le16_to_cpu(desc->wMaxPacketSize) & 0x7ff;
347 443
348 /* drivers must not request bad settings, since lower levels 444 /* drivers must not request bad settings, since lower levels
349 * (hardware or its drivers) may not check. some endpoints 445 * (hardware or its drivers) may not check. some endpoints
@@ -361,6 +457,10 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
361 goto done; 457 goto done;
362 } 458 }
363 switch (dum->gadget.speed) { 459 switch (dum->gadget.speed) {
460 case USB_SPEED_SUPER:
461 if (max == 1024)
462 break;
463 goto done;
364 case USB_SPEED_HIGH: 464 case USB_SPEED_HIGH:
365 if (max == 512) 465 if (max == 512)
366 break; 466 break;
@@ -379,6 +479,7 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
379 goto done; 479 goto done;
380 /* real hardware might not handle all packet sizes */ 480 /* real hardware might not handle all packet sizes */
381 switch (dum->gadget.speed) { 481 switch (dum->gadget.speed) {
482 case USB_SPEED_SUPER:
382 case USB_SPEED_HIGH: 483 case USB_SPEED_HIGH:
383 if (max <= 1024) 484 if (max <= 1024)
384 break; 485 break;
@@ -399,6 +500,7 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
399 goto done; 500 goto done;
400 /* real hardware might not handle all packet sizes */ 501 /* real hardware might not handle all packet sizes */
401 switch (dum->gadget.speed) { 502 switch (dum->gadget.speed) {
503 case USB_SPEED_SUPER:
402 case USB_SPEED_HIGH: 504 case USB_SPEED_HIGH:
403 if (max <= 1024) 505 if (max <= 1024)
404 break; 506 break;
@@ -425,10 +527,18 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
425 (desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out", 527 (desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
426 ({ char *val; 528 ({ char *val;
427 switch (desc->bmAttributes & 0x03) { 529 switch (desc->bmAttributes & 0x03) {
428 case USB_ENDPOINT_XFER_BULK: val = "bulk"; break; 530 case USB_ENDPOINT_XFER_BULK:
429 case USB_ENDPOINT_XFER_ISOC: val = "iso"; break; 531 val = "bulk";
430 case USB_ENDPOINT_XFER_INT: val = "intr"; break; 532 break;
431 default: val = "ctrl"; break; 533 case USB_ENDPOINT_XFER_ISOC:
534 val = "iso";
535 break;
536 case USB_ENDPOINT_XFER_INT:
537 val = "intr";
538 break;
539 default:
540 val = "ctrl";
541 break;
432 }; val; }), 542 }; val; }),
433 max); 543 max);
434 544
@@ -507,6 +617,7 @@ dummy_queue (struct usb_ep *_ep, struct usb_request *_req,
507 struct dummy_ep *ep; 617 struct dummy_ep *ep;
508 struct dummy_request *req; 618 struct dummy_request *req;
509 struct dummy *dum; 619 struct dummy *dum;
620 struct dummy_hcd *dum_hcd;
510 unsigned long flags; 621 unsigned long flags;
511 622
512 req = usb_request_to_dummy_request (_req); 623 req = usb_request_to_dummy_request (_req);
@@ -518,7 +629,8 @@ dummy_queue (struct usb_ep *_ep, struct usb_request *_req,
518 return -EINVAL; 629 return -EINVAL;
519 630
520 dum = ep_to_dummy (ep); 631 dum = ep_to_dummy (ep);
521 if (!dum->driver || !is_enabled (dum)) 632 dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
633 if (!dum->driver || !is_enabled(dum_hcd))
522 return -ESHUTDOWN; 634 return -ESHUTDOWN;
523 635
524#if 0 636#if 0
@@ -662,24 +774,24 @@ static int dummy_g_get_frame (struct usb_gadget *_gadget)
662 774
663static int dummy_wakeup (struct usb_gadget *_gadget) 775static int dummy_wakeup (struct usb_gadget *_gadget)
664{ 776{
665 struct dummy *dum; 777 struct dummy_hcd *dum_hcd;
666 778
667 dum = gadget_to_dummy (_gadget); 779 dum_hcd = gadget_to_dummy_hcd(_gadget);
668 if (!(dum->devstatus & ( (1 << USB_DEVICE_B_HNP_ENABLE) 780 if (!(dum_hcd->dum->devstatus & ((1 << USB_DEVICE_B_HNP_ENABLE)
669 | (1 << USB_DEVICE_REMOTE_WAKEUP)))) 781 | (1 << USB_DEVICE_REMOTE_WAKEUP))))
670 return -EINVAL; 782 return -EINVAL;
671 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0) 783 if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0)
672 return -ENOLINK; 784 return -ENOLINK;
673 if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 && 785 if ((dum_hcd->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
674 dum->rh_state != DUMMY_RH_SUSPENDED) 786 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
675 return -EIO; 787 return -EIO;
676 788
677 /* FIXME: What if the root hub is suspended but the port isn't? */ 789 /* FIXME: What if the root hub is suspended but the port isn't? */
678 790
679 /* hub notices our request, issues downstream resume, etc */ 791 /* hub notices our request, issues downstream resume, etc */
680 dum->resuming = 1; 792 dum_hcd->resuming = 1;
681 dum->re_timeout = jiffies + msecs_to_jiffies(20); 793 dum_hcd->re_timeout = jiffies + msecs_to_jiffies(20);
682 mod_timer (&dummy_to_hcd (dum)->rh_timer, dum->re_timeout); 794 mod_timer(&dummy_hcd_to_hcd(dum_hcd)->rh_timer, dum_hcd->re_timeout);
683 return 0; 795 return 0;
684} 796}
685 797
@@ -687,7 +799,7 @@ static int dummy_set_selfpowered (struct usb_gadget *_gadget, int value)
687{ 799{
688 struct dummy *dum; 800 struct dummy *dum;
689 801
690 dum = gadget_to_dummy (_gadget); 802 dum = (gadget_to_dummy_hcd(_gadget))->dum;
691 if (value) 803 if (value)
692 dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED); 804 dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
693 else 805 else
@@ -695,26 +807,68 @@ static int dummy_set_selfpowered (struct usb_gadget *_gadget, int value)
695 return 0; 807 return 0;
696} 808}
697 809
810static void dummy_udc_udpate_ep0(struct dummy *dum)
811{
812 u32 i;
813
814 if (dum->gadget.speed == USB_SPEED_SUPER) {
815 for (i = 0; i < DUMMY_ENDPOINTS; i++)
816 dum->ep[i].ep.max_streams = 0x10;
817 dum->ep[0].ep.maxpacket = 9;
818 } else {
819 for (i = 0; i < DUMMY_ENDPOINTS; i++)
820 dum->ep[i].ep.max_streams = 0;
821 dum->ep[0].ep.maxpacket = 64;
822 }
823}
824
698static int dummy_pullup (struct usb_gadget *_gadget, int value) 825static int dummy_pullup (struct usb_gadget *_gadget, int value)
699{ 826{
827 struct dummy_hcd *dum_hcd;
700 struct dummy *dum; 828 struct dummy *dum;
701 unsigned long flags; 829 unsigned long flags;
702 830
703 dum = gadget_to_dummy (_gadget); 831 dum = gadget_dev_to_dummy(&_gadget->dev);
832
833 if (value && dum->driver) {
834 if (mod_data.is_super_speed)
835 dum->gadget.speed = dum->driver->speed;
836 else if (mod_data.is_high_speed)
837 dum->gadget.speed = min_t(u8, USB_SPEED_HIGH,
838 dum->driver->speed);
839 else
840 dum->gadget.speed = USB_SPEED_FULL;
841 dummy_udc_udpate_ep0(dum);
842
843 if (dum->gadget.speed < dum->driver->speed)
844 dev_dbg(udc_dev(dum), "This device can perform faster"
845 " if you connect it to a %s port...\n",
846 (dum->driver->speed == USB_SPEED_SUPER ?
847 "SuperSpeed" : "HighSpeed"));
848 }
849 dum_hcd = gadget_to_dummy_hcd(_gadget);
850
704 spin_lock_irqsave (&dum->lock, flags); 851 spin_lock_irqsave (&dum->lock, flags);
705 dum->pullup = (value != 0); 852 dum->pullup = (value != 0);
706 set_link_state (dum); 853 set_link_state(dum_hcd);
707 spin_unlock_irqrestore (&dum->lock, flags); 854 spin_unlock_irqrestore (&dum->lock, flags);
708 855
709 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 856 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
710 return 0; 857 return 0;
711} 858}
712 859
860static int dummy_udc_start(struct usb_gadget *g,
861 struct usb_gadget_driver *driver);
862static int dummy_udc_stop(struct usb_gadget *g,
863 struct usb_gadget_driver *driver);
864
713static const struct usb_gadget_ops dummy_ops = { 865static const struct usb_gadget_ops dummy_ops = {
714 .get_frame = dummy_g_get_frame, 866 .get_frame = dummy_g_get_frame,
715 .wakeup = dummy_wakeup, 867 .wakeup = dummy_wakeup,
716 .set_selfpowered = dummy_set_selfpowered, 868 .set_selfpowered = dummy_set_selfpowered,
717 .pullup = dummy_pullup, 869 .pullup = dummy_pullup,
870 .udc_start = dummy_udc_start,
871 .udc_stop = dummy_udc_stop,
718}; 872};
719 873
720/*-------------------------------------------------------------------------*/ 874/*-------------------------------------------------------------------------*/
@@ -747,18 +901,13 @@ static DEVICE_ATTR (function, S_IRUGO, show_function, NULL);
747 * for each driver that registers: just add to a big root hub. 901 * for each driver that registers: just add to a big root hub.
748 */ 902 */
749 903
750int 904static int dummy_udc_start(struct usb_gadget *g,
751usb_gadget_probe_driver(struct usb_gadget_driver *driver, 905 struct usb_gadget_driver *driver)
752 int (*bind)(struct usb_gadget *))
753{ 906{
754 struct dummy *dum = the_controller; 907 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
755 int retval, i; 908 struct dummy *dum = dum_hcd->dum;
756 909
757 if (!dum) 910 if (driver->speed == USB_SPEED_UNKNOWN)
758 return -EINVAL;
759 if (dum->driver)
760 return -EBUSY;
761 if (!bind || !driver->setup || driver->speed == USB_SPEED_UNKNOWN)
762 return -EINVAL; 911 return -EINVAL;
763 912
764 /* 913 /*
@@ -768,121 +917,77 @@ usb_gadget_probe_driver(struct usb_gadget_driver *driver,
768 917
769 dum->devstatus = 0; 918 dum->devstatus = 0;
770 919
771 INIT_LIST_HEAD (&dum->gadget.ep_list);
772 for (i = 0; i < DUMMY_ENDPOINTS; i++) {
773 struct dummy_ep *ep = &dum->ep [i];
774
775 if (!ep_name [i])
776 break;
777 ep->ep.name = ep_name [i];
778 ep->ep.ops = &dummy_ep_ops;
779 list_add_tail (&ep->ep.ep_list, &dum->gadget.ep_list);
780 ep->halted = ep->wedged = ep->already_seen =
781 ep->setup_stage = 0;
782 ep->ep.maxpacket = ~0;
783 ep->last_io = jiffies;
784 ep->gadget = &dum->gadget;
785 ep->desc = NULL;
786 INIT_LIST_HEAD (&ep->queue);
787 }
788
789 dum->gadget.ep0 = &dum->ep [0].ep;
790 dum->ep [0].ep.maxpacket = 64;
791 list_del_init (&dum->ep [0].ep.ep_list);
792 INIT_LIST_HEAD(&dum->fifo_req.queue);
793
794 driver->driver.bus = NULL;
795 dum->driver = driver; 920 dum->driver = driver;
796 dum->gadget.dev.driver = &driver->driver;
797 dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n", 921 dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n",
798 driver->driver.name); 922 driver->driver.name);
799 retval = bind(&dum->gadget);
800 if (retval) {
801 dum->driver = NULL;
802 dum->gadget.dev.driver = NULL;
803 return retval;
804 }
805
806 /* khubd will enumerate this in a while */
807 spin_lock_irq (&dum->lock);
808 dum->pullup = 1;
809 set_link_state (dum);
810 spin_unlock_irq (&dum->lock);
811
812 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
813 return 0; 923 return 0;
814} 924}
815EXPORT_SYMBOL(usb_gadget_probe_driver);
816 925
817int 926static int dummy_udc_stop(struct usb_gadget *g,
818usb_gadget_unregister_driver (struct usb_gadget_driver *driver) 927 struct usb_gadget_driver *driver)
819{ 928{
820 struct dummy *dum = the_controller; 929 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
821 unsigned long flags; 930 struct dummy *dum = dum_hcd->dum;
822
823 if (!dum)
824 return -ENODEV;
825 if (!driver || driver != dum->driver || !driver->unbind)
826 return -EINVAL;
827 931
828 dev_dbg (udc_dev(dum), "unregister gadget driver '%s'\n", 932 dev_dbg (udc_dev(dum), "unregister gadget driver '%s'\n",
829 driver->driver.name); 933 driver->driver.name);
830 934
831 spin_lock_irqsave (&dum->lock, flags);
832 dum->pullup = 0;
833 set_link_state (dum);
834 spin_unlock_irqrestore (&dum->lock, flags);
835
836 driver->unbind (&dum->gadget);
837 dum->gadget.dev.driver = NULL;
838 dum->driver = NULL; 935 dum->driver = NULL;
839 936
840 spin_lock_irqsave (&dum->lock, flags); 937 dummy_pullup(&dum->gadget, 0);
841 dum->pullup = 0;
842 set_link_state (dum);
843 spin_unlock_irqrestore (&dum->lock, flags);
844
845 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
846 return 0; 938 return 0;
847} 939}
848EXPORT_SYMBOL (usb_gadget_unregister_driver);
849 940
850#undef is_enabled 941#undef is_enabled
851 942
852/* just declare this in any driver that really need it */
853extern int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode);
854
855int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode)
856{
857 return -ENOSYS;
858}
859EXPORT_SYMBOL (net2280_set_fifo_mode);
860
861
862/* The gadget structure is stored inside the hcd structure and will be 943/* The gadget structure is stored inside the hcd structure and will be
863 * released along with it. */ 944 * released along with it. */
864static void 945static void
865dummy_gadget_release (struct device *dev) 946dummy_gadget_release (struct device *dev)
866{ 947{
867 struct dummy *dum = gadget_dev_to_dummy (dev); 948 return;
949}
950
951static void init_dummy_udc_hw(struct dummy *dum)
952{
953 int i;
954
955 INIT_LIST_HEAD(&dum->gadget.ep_list);
956 for (i = 0; i < DUMMY_ENDPOINTS; i++) {
957 struct dummy_ep *ep = &dum->ep[i];
958
959 if (!ep_name[i])
960 break;
961 ep->ep.name = ep_name[i];
962 ep->ep.ops = &dummy_ep_ops;
963 list_add_tail(&ep->ep.ep_list, &dum->gadget.ep_list);
964 ep->halted = ep->wedged = ep->already_seen =
965 ep->setup_stage = 0;
966 ep->ep.maxpacket = ~0;
967 ep->last_io = jiffies;
968 ep->gadget = &dum->gadget;
969 ep->desc = NULL;
970 INIT_LIST_HEAD(&ep->queue);
971 }
972
973 dum->gadget.ep0 = &dum->ep[0].ep;
974 list_del_init(&dum->ep[0].ep.ep_list);
975 INIT_LIST_HEAD(&dum->fifo_req.queue);
868 976
869 usb_put_hcd (dummy_to_hcd (dum)); 977#ifdef CONFIG_USB_OTG
978 dum->gadget.is_otg = 1;
979#endif
870} 980}
871 981
872static int dummy_udc_probe (struct platform_device *pdev) 982static int dummy_udc_probe (struct platform_device *pdev)
873{ 983{
874 struct dummy *dum = the_controller; 984 struct dummy *dum = &the_controller;
875 int rc; 985 int rc;
876 986
877 usb_get_hcd(dummy_to_hcd(dum));
878
879 dum->gadget.name = gadget_name; 987 dum->gadget.name = gadget_name;
880 dum->gadget.ops = &dummy_ops; 988 dum->gadget.ops = &dummy_ops;
881 dum->gadget.is_dualspeed = 1; 989 dum->gadget.is_dualspeed = 1;
882 990
883 /* maybe claim OTG support, though we won't complete HNP */
884 dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0);
885
886 dev_set_name(&dum->gadget.dev, "gadget"); 991 dev_set_name(&dum->gadget.dev, "gadget");
887 dum->gadget.dev.parent = &pdev->dev; 992 dum->gadget.dev.parent = &pdev->dev;
888 dum->gadget.dev.release = dummy_gadget_release; 993 dum->gadget.dev.release = dummy_gadget_release;
@@ -892,11 +997,22 @@ static int dummy_udc_probe (struct platform_device *pdev)
892 return rc; 997 return rc;
893 } 998 }
894 999
1000 init_dummy_udc_hw(dum);
1001
1002 rc = usb_add_gadget_udc(&pdev->dev, &dum->gadget);
1003 if (rc < 0)
1004 goto err_udc;
1005
895 rc = device_create_file (&dum->gadget.dev, &dev_attr_function); 1006 rc = device_create_file (&dum->gadget.dev, &dev_attr_function);
896 if (rc < 0) 1007 if (rc < 0)
897 device_unregister (&dum->gadget.dev); 1008 goto err_dev;
898 else 1009 platform_set_drvdata(pdev, dum);
899 platform_set_drvdata(pdev, dum); 1010 return rc;
1011
1012err_dev:
1013 usb_del_gadget_udc(&dum->gadget);
1014err_udc:
1015 device_unregister(&dum->gadget.dev);
900 return rc; 1016 return rc;
901} 1017}
902 1018
@@ -904,37 +1020,41 @@ static int dummy_udc_remove (struct platform_device *pdev)
904{ 1020{
905 struct dummy *dum = platform_get_drvdata (pdev); 1021 struct dummy *dum = platform_get_drvdata (pdev);
906 1022
1023 usb_del_gadget_udc(&dum->gadget);
907 platform_set_drvdata (pdev, NULL); 1024 platform_set_drvdata (pdev, NULL);
908 device_remove_file (&dum->gadget.dev, &dev_attr_function); 1025 device_remove_file (&dum->gadget.dev, &dev_attr_function);
909 device_unregister (&dum->gadget.dev); 1026 device_unregister (&dum->gadget.dev);
910 return 0; 1027 return 0;
911} 1028}
912 1029
913static int dummy_udc_suspend (struct platform_device *pdev, pm_message_t state) 1030static void dummy_udc_pm(struct dummy *dum, struct dummy_hcd *dum_hcd,
1031 int suspend)
914{ 1032{
915 struct dummy *dum = platform_get_drvdata(pdev); 1033 spin_lock_irq(&dum->lock);
1034 dum->udc_suspended = suspend;
1035 set_link_state(dum_hcd);
1036 spin_unlock_irq(&dum->lock);
1037}
916 1038
917 dev_dbg (&pdev->dev, "%s\n", __func__); 1039static int dummy_udc_suspend(struct platform_device *pdev, pm_message_t state)
918 spin_lock_irq (&dum->lock); 1040{
919 dum->udc_suspended = 1; 1041 struct dummy *dum = platform_get_drvdata(pdev);
920 set_link_state (dum); 1042 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
921 spin_unlock_irq (&dum->lock);
922 1043
923 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 1044 dev_dbg(&pdev->dev, "%s\n", __func__);
1045 dummy_udc_pm(dum, dum_hcd, 1);
1046 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
924 return 0; 1047 return 0;
925} 1048}
926 1049
927static int dummy_udc_resume (struct platform_device *pdev) 1050static int dummy_udc_resume(struct platform_device *pdev)
928{ 1051{
929 struct dummy *dum = platform_get_drvdata(pdev); 1052 struct dummy *dum = platform_get_drvdata(pdev);
1053 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
930 1054
931 dev_dbg (&pdev->dev, "%s\n", __func__); 1055 dev_dbg(&pdev->dev, "%s\n", __func__);
932 spin_lock_irq (&dum->lock); 1056 dummy_udc_pm(dum, dum_hcd, 0);
933 dum->udc_suspended = 0; 1057 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
934 set_link_state (dum);
935 spin_unlock_irq (&dum->lock);
936
937 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
938 return 0; 1058 return 0;
939} 1059}
940 1060
@@ -968,7 +1088,7 @@ static int dummy_urb_enqueue (
968 struct urb *urb, 1088 struct urb *urb,
969 gfp_t mem_flags 1089 gfp_t mem_flags
970) { 1090) {
971 struct dummy *dum; 1091 struct dummy_hcd *dum_hcd;
972 struct urbp *urbp; 1092 struct urbp *urbp;
973 unsigned long flags; 1093 unsigned long flags;
974 int rc; 1094 int rc;
@@ -981,51 +1101,51 @@ static int dummy_urb_enqueue (
981 return -ENOMEM; 1101 return -ENOMEM;
982 urbp->urb = urb; 1102 urbp->urb = urb;
983 1103
984 dum = hcd_to_dummy (hcd); 1104 dum_hcd = hcd_to_dummy_hcd(hcd);
985 spin_lock_irqsave (&dum->lock, flags); 1105 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
986 rc = usb_hcd_link_urb_to_ep(hcd, urb); 1106 rc = usb_hcd_link_urb_to_ep(hcd, urb);
987 if (rc) { 1107 if (rc) {
988 kfree(urbp); 1108 kfree(urbp);
989 goto done; 1109 goto done;
990 } 1110 }
991 1111
992 if (!dum->udev) { 1112 if (!dum_hcd->udev) {
993 dum->udev = urb->dev; 1113 dum_hcd->udev = urb->dev;
994 usb_get_dev (dum->udev); 1114 usb_get_dev(dum_hcd->udev);
995 } else if (unlikely (dum->udev != urb->dev)) 1115 } else if (unlikely(dum_hcd->udev != urb->dev))
996 dev_err (dummy_dev(dum), "usb_device address has changed!\n"); 1116 dev_err(dummy_dev(dum_hcd), "usb_device address has changed!\n");
997 1117
998 list_add_tail (&urbp->urbp_list, &dum->urbp_list); 1118 list_add_tail(&urbp->urbp_list, &dum_hcd->urbp_list);
999 urb->hcpriv = urbp; 1119 urb->hcpriv = urbp;
1000 if (usb_pipetype (urb->pipe) == PIPE_CONTROL) 1120 if (usb_pipetype (urb->pipe) == PIPE_CONTROL)
1001 urb->error_count = 1; /* mark as a new urb */ 1121 urb->error_count = 1; /* mark as a new urb */
1002 1122
1003 /* kick the scheduler, it'll do the rest */ 1123 /* kick the scheduler, it'll do the rest */
1004 if (!timer_pending (&dum->timer)) 1124 if (!timer_pending(&dum_hcd->timer))
1005 mod_timer (&dum->timer, jiffies + 1); 1125 mod_timer(&dum_hcd->timer, jiffies + 1);
1006 1126
1007 done: 1127 done:
1008 spin_unlock_irqrestore(&dum->lock, flags); 1128 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1009 return rc; 1129 return rc;
1010} 1130}
1011 1131
1012static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) 1132static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1013{ 1133{
1014 struct dummy *dum; 1134 struct dummy_hcd *dum_hcd;
1015 unsigned long flags; 1135 unsigned long flags;
1016 int rc; 1136 int rc;
1017 1137
1018 /* giveback happens automatically in timer callback, 1138 /* giveback happens automatically in timer callback,
1019 * so make sure the callback happens */ 1139 * so make sure the callback happens */
1020 dum = hcd_to_dummy (hcd); 1140 dum_hcd = hcd_to_dummy_hcd(hcd);
1021 spin_lock_irqsave (&dum->lock, flags); 1141 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1022 1142
1023 rc = usb_hcd_check_unlink_urb(hcd, urb, status); 1143 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1024 if (!rc && dum->rh_state != DUMMY_RH_RUNNING && 1144 if (!rc && dum_hcd->rh_state != DUMMY_RH_RUNNING &&
1025 !list_empty(&dum->urbp_list)) 1145 !list_empty(&dum_hcd->urbp_list))
1026 mod_timer (&dum->timer, jiffies); 1146 mod_timer(&dum_hcd->timer, jiffies);
1027 1147
1028 spin_unlock_irqrestore (&dum->lock, flags); 1148 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1029 return rc; 1149 return rc;
1030} 1150}
1031 1151
@@ -1162,10 +1282,25 @@ static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep)
1162 tmp *= 8 /* applies to entire frame */; 1282 tmp *= 8 /* applies to entire frame */;
1163 limit += limit * tmp; 1283 limit += limit * tmp;
1164 } 1284 }
1285 if (dum->gadget.speed == USB_SPEED_SUPER) {
1286 switch (ep->desc->bmAttributes & 0x03) {
1287 case USB_ENDPOINT_XFER_ISOC:
1288 /* Sec. 4.4.8.2 USB3.0 Spec */
1289 limit = 3 * 16 * 1024 * 8;
1290 break;
1291 case USB_ENDPOINT_XFER_INT:
1292 /* Sec. 4.4.7.2 USB3.0 Spec */
1293 limit = 3 * 1024 * 8;
1294 break;
1295 case USB_ENDPOINT_XFER_BULK:
1296 default:
1297 break;
1298 }
1299 }
1165 return limit; 1300 return limit;
1166} 1301}
1167 1302
1168#define is_active(dum) ((dum->port_status & \ 1303#define is_active(dum_hcd) ((dum_hcd->port_status & \
1169 (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \ 1304 (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \
1170 USB_PORT_STAT_SUSPEND)) \ 1305 USB_PORT_STAT_SUSPEND)) \
1171 == (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE)) 1306 == (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))
@@ -1174,7 +1309,8 @@ static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
1174{ 1309{
1175 int i; 1310 int i;
1176 1311
1177 if (!is_active (dum)) 1312 if (!is_active((dum->gadget.speed == USB_SPEED_SUPER ?
1313 dum->ss_hcd : dum->hs_hcd)))
1178 return NULL; 1314 return NULL;
1179 if ((address & ~USB_DIR_IN) == 0) 1315 if ((address & ~USB_DIR_IN) == 0)
1180 return &dum->ep [0]; 1316 return &dum->ep [0];
@@ -1211,11 +1347,12 @@ static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
1211 * 1 - if the request wasn't handles 1347 * 1 - if the request wasn't handles
1212 * error code on error 1348 * error code on error
1213 */ 1349 */
1214static int handle_control_request(struct dummy *dum, struct urb *urb, 1350static int handle_control_request(struct dummy_hcd *dum_hcd, struct urb *urb,
1215 struct usb_ctrlrequest *setup, 1351 struct usb_ctrlrequest *setup,
1216 int *status) 1352 int *status)
1217{ 1353{
1218 struct dummy_ep *ep2; 1354 struct dummy_ep *ep2;
1355 struct dummy *dum = dum_hcd->dum;
1219 int ret_val = 1; 1356 int ret_val = 1;
1220 unsigned w_index; 1357 unsigned w_index;
1221 unsigned w_value; 1358 unsigned w_value;
@@ -1247,6 +1384,27 @@ static int handle_control_request(struct dummy *dum, struct urb *urb,
1247 case USB_DEVICE_A_ALT_HNP_SUPPORT: 1384 case USB_DEVICE_A_ALT_HNP_SUPPORT:
1248 dum->gadget.a_alt_hnp_support = 1; 1385 dum->gadget.a_alt_hnp_support = 1;
1249 break; 1386 break;
1387 case USB_DEVICE_U1_ENABLE:
1388 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1389 HCD_USB3)
1390 w_value = USB_DEV_STAT_U1_ENABLED;
1391 else
1392 ret_val = -EOPNOTSUPP;
1393 break;
1394 case USB_DEVICE_U2_ENABLE:
1395 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1396 HCD_USB3)
1397 w_value = USB_DEV_STAT_U2_ENABLED;
1398 else
1399 ret_val = -EOPNOTSUPP;
1400 break;
1401 case USB_DEVICE_LTM_ENABLE:
1402 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1403 HCD_USB3)
1404 w_value = USB_DEV_STAT_LTM_ENABLED;
1405 else
1406 ret_val = -EOPNOTSUPP;
1407 break;
1250 default: 1408 default:
1251 ret_val = -EOPNOTSUPP; 1409 ret_val = -EOPNOTSUPP;
1252 } 1410 }
@@ -1273,6 +1431,27 @@ static int handle_control_request(struct dummy *dum, struct urb *urb,
1273 case USB_DEVICE_REMOTE_WAKEUP: 1431 case USB_DEVICE_REMOTE_WAKEUP:
1274 w_value = USB_DEVICE_REMOTE_WAKEUP; 1432 w_value = USB_DEVICE_REMOTE_WAKEUP;
1275 break; 1433 break;
1434 case USB_DEVICE_U1_ENABLE:
1435 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1436 HCD_USB3)
1437 w_value = USB_DEV_STAT_U1_ENABLED;
1438 else
1439 ret_val = -EOPNOTSUPP;
1440 break;
1441 case USB_DEVICE_U2_ENABLE:
1442 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1443 HCD_USB3)
1444 w_value = USB_DEV_STAT_U2_ENABLED;
1445 else
1446 ret_val = -EOPNOTSUPP;
1447 break;
1448 case USB_DEVICE_LTM_ENABLE:
1449 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1450 HCD_USB3)
1451 w_value = USB_DEV_STAT_LTM_ENABLED;
1452 else
1453 ret_val = -EOPNOTSUPP;
1454 break;
1276 default: 1455 default:
1277 ret_val = -EOPNOTSUPP; 1456 ret_val = -EOPNOTSUPP;
1278 break; 1457 break;
@@ -1334,9 +1513,10 @@ static int handle_control_request(struct dummy *dum, struct urb *urb,
1334/* drive both sides of the transfers; looks like irq handlers to 1513/* drive both sides of the transfers; looks like irq handlers to
1335 * both drivers except the callbacks aren't in_irq(). 1514 * both drivers except the callbacks aren't in_irq().
1336 */ 1515 */
1337static void dummy_timer (unsigned long _dum) 1516static void dummy_timer(unsigned long _dum_hcd)
1338{ 1517{
1339 struct dummy *dum = (struct dummy *) _dum; 1518 struct dummy_hcd *dum_hcd = (struct dummy_hcd *) _dum_hcd;
1519 struct dummy *dum = dum_hcd->dum;
1340 struct urbp *urbp, *tmp; 1520 struct urbp *urbp, *tmp;
1341 unsigned long flags; 1521 unsigned long flags;
1342 int limit, total; 1522 int limit, total;
@@ -1353,8 +1533,12 @@ static void dummy_timer (unsigned long _dum)
1353 case USB_SPEED_HIGH: 1533 case USB_SPEED_HIGH:
1354 total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/; 1534 total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/;
1355 break; 1535 break;
1536 case USB_SPEED_SUPER:
1537 /* Bus speed is 500000 bytes/ms, so use a little less */
1538 total = 490000;
1539 break;
1356 default: 1540 default:
1357 dev_err (dummy_dev(dum), "bogus device speed\n"); 1541 dev_err(dummy_dev(dum_hcd), "bogus device speed\n");
1358 return; 1542 return;
1359 } 1543 }
1360 1544
@@ -1363,8 +1547,8 @@ static void dummy_timer (unsigned long _dum)
1363 /* look at each urb queued by the host side driver */ 1547 /* look at each urb queued by the host side driver */
1364 spin_lock_irqsave (&dum->lock, flags); 1548 spin_lock_irqsave (&dum->lock, flags);
1365 1549
1366 if (!dum->udev) { 1550 if (!dum_hcd->udev) {
1367 dev_err (dummy_dev(dum), 1551 dev_err(dummy_dev(dum_hcd),
1368 "timer fired with no URBs pending?\n"); 1552 "timer fired with no URBs pending?\n");
1369 spin_unlock_irqrestore (&dum->lock, flags); 1553 spin_unlock_irqrestore (&dum->lock, flags);
1370 return; 1554 return;
@@ -1377,7 +1561,7 @@ static void dummy_timer (unsigned long _dum)
1377 } 1561 }
1378 1562
1379restart: 1563restart:
1380 list_for_each_entry_safe (urbp, tmp, &dum->urbp_list, urbp_list) { 1564 list_for_each_entry_safe(urbp, tmp, &dum_hcd->urbp_list, urbp_list) {
1381 struct urb *urb; 1565 struct urb *urb;
1382 struct dummy_request *req; 1566 struct dummy_request *req;
1383 u8 address; 1567 u8 address;
@@ -1388,7 +1572,7 @@ restart:
1388 urb = urbp->urb; 1572 urb = urbp->urb;
1389 if (urb->unlinked) 1573 if (urb->unlinked)
1390 goto return_urb; 1574 goto return_urb;
1391 else if (dum->rh_state != DUMMY_RH_RUNNING) 1575 else if (dum_hcd->rh_state != DUMMY_RH_RUNNING)
1392 continue; 1576 continue;
1393 type = usb_pipetype (urb->pipe); 1577 type = usb_pipetype (urb->pipe);
1394 1578
@@ -1406,7 +1590,7 @@ restart:
1406 ep = find_endpoint(dum, address); 1590 ep = find_endpoint(dum, address);
1407 if (!ep) { 1591 if (!ep) {
1408 /* set_configuration() disagreement */ 1592 /* set_configuration() disagreement */
1409 dev_dbg (dummy_dev(dum), 1593 dev_dbg(dummy_dev(dum_hcd),
1410 "no ep configured for urb %p\n", 1594 "no ep configured for urb %p\n",
1411 urb); 1595 urb);
1412 status = -EPROTO; 1596 status = -EPROTO;
@@ -1422,7 +1606,7 @@ restart:
1422 } 1606 }
1423 if (ep->halted && !ep->setup_stage) { 1607 if (ep->halted && !ep->setup_stage) {
1424 /* NOTE: must not be iso! */ 1608 /* NOTE: must not be iso! */
1425 dev_dbg (dummy_dev(dum), "ep %s halted, urb %p\n", 1609 dev_dbg(dummy_dev(dum_hcd), "ep %s halted, urb %p\n",
1426 ep->ep.name, urb); 1610 ep->ep.name, urb);
1427 status = -EPIPE; 1611 status = -EPIPE;
1428 goto return_urb; 1612 goto return_urb;
@@ -1457,7 +1641,7 @@ restart:
1457 ep->setup_stage = 0; 1641 ep->setup_stage = 0;
1458 ep->halted = 0; 1642 ep->halted = 0;
1459 1643
1460 value = handle_control_request(dum, urb, &setup, 1644 value = handle_control_request(dum_hcd, urb, &setup,
1461 &status); 1645 &status);
1462 1646
1463 /* gadget driver handles all other requests. block 1647 /* gadget driver handles all other requests. block
@@ -1527,20 +1711,20 @@ return_urb:
1527 if (ep) 1711 if (ep)
1528 ep->already_seen = ep->setup_stage = 0; 1712 ep->already_seen = ep->setup_stage = 0;
1529 1713
1530 usb_hcd_unlink_urb_from_ep(dummy_to_hcd(dum), urb); 1714 usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd), urb);
1531 spin_unlock (&dum->lock); 1715 spin_unlock (&dum->lock);
1532 usb_hcd_giveback_urb(dummy_to_hcd(dum), urb, status); 1716 usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd), urb, status);
1533 spin_lock (&dum->lock); 1717 spin_lock (&dum->lock);
1534 1718
1535 goto restart; 1719 goto restart;
1536 } 1720 }
1537 1721
1538 if (list_empty (&dum->urbp_list)) { 1722 if (list_empty(&dum_hcd->urbp_list)) {
1539 usb_put_dev (dum->udev); 1723 usb_put_dev(dum_hcd->udev);
1540 dum->udev = NULL; 1724 dum_hcd->udev = NULL;
1541 } else if (dum->rh_state == DUMMY_RH_RUNNING) { 1725 } else if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
1542 /* want a 1 msec delay here */ 1726 /* want a 1 msec delay here */
1543 mod_timer (&dum->timer, jiffies + msecs_to_jiffies(1)); 1727 mod_timer(&dum_hcd->timer, jiffies + msecs_to_jiffies(1));
1544 } 1728 }
1545 1729
1546 spin_unlock_irqrestore (&dum->lock, flags); 1730 spin_unlock_irqrestore (&dum->lock, flags);
@@ -1557,36 +1741,48 @@ return_urb:
1557 1741
1558static int dummy_hub_status (struct usb_hcd *hcd, char *buf) 1742static int dummy_hub_status (struct usb_hcd *hcd, char *buf)
1559{ 1743{
1560 struct dummy *dum; 1744 struct dummy_hcd *dum_hcd;
1561 unsigned long flags; 1745 unsigned long flags;
1562 int retval = 0; 1746 int retval = 0;
1563 1747
1564 dum = hcd_to_dummy (hcd); 1748 dum_hcd = hcd_to_dummy_hcd(hcd);
1565 1749
1566 spin_lock_irqsave (&dum->lock, flags); 1750 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1567 if (!HCD_HW_ACCESSIBLE(hcd)) 1751 if (!HCD_HW_ACCESSIBLE(hcd))
1568 goto done; 1752 goto done;
1569 1753
1570 if (dum->resuming && time_after_eq (jiffies, dum->re_timeout)) { 1754 if (dum_hcd->resuming && time_after_eq(jiffies, dum_hcd->re_timeout)) {
1571 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16); 1755 dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1572 dum->port_status &= ~USB_PORT_STAT_SUSPEND; 1756 dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
1573 set_link_state (dum); 1757 set_link_state(dum_hcd);
1574 } 1758 }
1575 1759
1576 if ((dum->port_status & PORT_C_MASK) != 0) { 1760 if ((dum_hcd->port_status & PORT_C_MASK) != 0) {
1577 *buf = (1 << 1); 1761 *buf = (1 << 1);
1578 dev_dbg (dummy_dev(dum), "port status 0x%08x has changes\n", 1762 dev_dbg(dummy_dev(dum_hcd), "port status 0x%08x has changes\n",
1579 dum->port_status); 1763 dum_hcd->port_status);
1580 retval = 1; 1764 retval = 1;
1581 if (dum->rh_state == DUMMY_RH_SUSPENDED) 1765 if (dum_hcd->rh_state == DUMMY_RH_SUSPENDED)
1582 usb_hcd_resume_root_hub (hcd); 1766 usb_hcd_resume_root_hub (hcd);
1583 } 1767 }
1584done: 1768done:
1585 spin_unlock_irqrestore (&dum->lock, flags); 1769 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1586 return retval; 1770 return retval;
1587} 1771}
1588 1772
1589static inline void 1773static inline void
1774ss_hub_descriptor(struct usb_hub_descriptor *desc)
1775{
1776 memset(desc, 0, sizeof *desc);
1777 desc->bDescriptorType = 0x2a;
1778 desc->bDescLength = 12;
1779 desc->wHubCharacteristics = cpu_to_le16(0x0001);
1780 desc->bNbrPorts = 1;
1781 desc->u.ss.bHubHdrDecLat = 0x04; /* Worst case: 0.4 micro sec*/
1782 desc->u.ss.DeviceRemovable = 0xffff;
1783}
1784
1785static inline void
1590hub_descriptor (struct usb_hub_descriptor *desc) 1786hub_descriptor (struct usb_hub_descriptor *desc)
1591{ 1787{
1592 memset (desc, 0, sizeof *desc); 1788 memset (desc, 0, sizeof *desc);
@@ -1606,39 +1802,64 @@ static int dummy_hub_control (
1606 char *buf, 1802 char *buf,
1607 u16 wLength 1803 u16 wLength
1608) { 1804) {
1609 struct dummy *dum; 1805 struct dummy_hcd *dum_hcd;
1610 int retval = 0; 1806 int retval = 0;
1611 unsigned long flags; 1807 unsigned long flags;
1612 1808
1613 if (!HCD_HW_ACCESSIBLE(hcd)) 1809 if (!HCD_HW_ACCESSIBLE(hcd))
1614 return -ETIMEDOUT; 1810 return -ETIMEDOUT;
1615 1811
1616 dum = hcd_to_dummy (hcd); 1812 dum_hcd = hcd_to_dummy_hcd(hcd);
1617 spin_lock_irqsave (&dum->lock, flags); 1813
1814 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1618 switch (typeReq) { 1815 switch (typeReq) {
1619 case ClearHubFeature: 1816 case ClearHubFeature:
1620 break; 1817 break;
1621 case ClearPortFeature: 1818 case ClearPortFeature:
1622 switch (wValue) { 1819 switch (wValue) {
1623 case USB_PORT_FEAT_SUSPEND: 1820 case USB_PORT_FEAT_SUSPEND:
1624 if (dum->port_status & USB_PORT_STAT_SUSPEND) { 1821 if (hcd->speed == HCD_USB3) {
1822 dev_dbg(dummy_dev(dum_hcd),
1823 "USB_PORT_FEAT_SUSPEND req not "
1824 "supported for USB 3.0 roothub\n");
1825 goto error;
1826 }
1827 if (dum_hcd->port_status & USB_PORT_STAT_SUSPEND) {
1625 /* 20msec resume signaling */ 1828 /* 20msec resume signaling */
1626 dum->resuming = 1; 1829 dum_hcd->resuming = 1;
1627 dum->re_timeout = jiffies + 1830 dum_hcd->re_timeout = jiffies +
1628 msecs_to_jiffies(20); 1831 msecs_to_jiffies(20);
1629 } 1832 }
1630 break; 1833 break;
1631 case USB_PORT_FEAT_POWER: 1834 case USB_PORT_FEAT_POWER:
1632 if (dum->port_status & USB_PORT_STAT_POWER) 1835 if (hcd->speed == HCD_USB3) {
1633 dev_dbg (dummy_dev(dum), "power-off\n"); 1836 if (dum_hcd->port_status & USB_PORT_STAT_POWER)
1837 dev_dbg(dummy_dev(dum_hcd),
1838 "power-off\n");
1839 } else
1840 if (dum_hcd->port_status &
1841 USB_SS_PORT_STAT_POWER)
1842 dev_dbg(dummy_dev(dum_hcd),
1843 "power-off\n");
1634 /* FALLS THROUGH */ 1844 /* FALLS THROUGH */
1635 default: 1845 default:
1636 dum->port_status &= ~(1 << wValue); 1846 dum_hcd->port_status &= ~(1 << wValue);
1637 set_link_state (dum); 1847 set_link_state(dum_hcd);
1638 } 1848 }
1639 break; 1849 break;
1640 case GetHubDescriptor: 1850 case GetHubDescriptor:
1641 hub_descriptor ((struct usb_hub_descriptor *) buf); 1851 if (hcd->speed == HCD_USB3 &&
1852 (wLength < USB_DT_SS_HUB_SIZE ||
1853 wValue != (USB_DT_SS_HUB << 8))) {
1854 dev_dbg(dummy_dev(dum_hcd),
1855 "Wrong hub descriptor type for "
1856 "USB 3.0 roothub.\n");
1857 goto error;
1858 }
1859 if (hcd->speed == HCD_USB3)
1860 ss_hub_descriptor((struct usb_hub_descriptor *) buf);
1861 else
1862 hub_descriptor((struct usb_hub_descriptor *) buf);
1642 break; 1863 break;
1643 case GetHubStatus: 1864 case GetHubStatus:
1644 *(__le32 *) buf = cpu_to_le32 (0); 1865 *(__le32 *) buf = cpu_to_le32 (0);
@@ -1650,127 +1871,210 @@ static int dummy_hub_control (
1650 /* whoever resets or resumes must GetPortStatus to 1871 /* whoever resets or resumes must GetPortStatus to
1651 * complete it!! 1872 * complete it!!
1652 */ 1873 */
1653 if (dum->resuming && 1874 if (dum_hcd->resuming &&
1654 time_after_eq (jiffies, dum->re_timeout)) { 1875 time_after_eq(jiffies, dum_hcd->re_timeout)) {
1655 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16); 1876 dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1656 dum->port_status &= ~USB_PORT_STAT_SUSPEND; 1877 dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
1657 } 1878 }
1658 if ((dum->port_status & USB_PORT_STAT_RESET) != 0 && 1879 if ((dum_hcd->port_status & USB_PORT_STAT_RESET) != 0 &&
1659 time_after_eq (jiffies, dum->re_timeout)) { 1880 time_after_eq(jiffies, dum_hcd->re_timeout)) {
1660 dum->port_status |= (USB_PORT_STAT_C_RESET << 16); 1881 dum_hcd->port_status |= (USB_PORT_STAT_C_RESET << 16);
1661 dum->port_status &= ~USB_PORT_STAT_RESET; 1882 dum_hcd->port_status &= ~USB_PORT_STAT_RESET;
1662 if (dum->pullup) { 1883 if (dum_hcd->dum->pullup) {
1663 dum->port_status |= USB_PORT_STAT_ENABLE; 1884 dum_hcd->port_status |= USB_PORT_STAT_ENABLE;
1664 /* give it the best speed we agree on */ 1885
1665 dum->gadget.speed = dum->driver->speed; 1886 if (hcd->speed < HCD_USB3) {
1666 dum->gadget.ep0->maxpacket = 64; 1887 switch (dum_hcd->dum->gadget.speed) {
1667 switch (dum->gadget.speed) { 1888 case USB_SPEED_HIGH:
1668 case USB_SPEED_HIGH: 1889 dum_hcd->port_status |=
1669 dum->port_status |= 1890 USB_PORT_STAT_HIGH_SPEED;
1670 USB_PORT_STAT_HIGH_SPEED; 1891 break;
1671 break; 1892 case USB_SPEED_LOW:
1672 case USB_SPEED_LOW: 1893 dum_hcd->dum->gadget.ep0->
1673 dum->gadget.ep0->maxpacket = 8; 1894 maxpacket = 8;
1674 dum->port_status |= 1895 dum_hcd->port_status |=
1675 USB_PORT_STAT_LOW_SPEED; 1896 USB_PORT_STAT_LOW_SPEED;
1676 break; 1897 break;
1677 default: 1898 default:
1678 dum->gadget.speed = USB_SPEED_FULL; 1899 dum_hcd->dum->gadget.speed =
1679 break; 1900 USB_SPEED_FULL;
1901 break;
1902 }
1680 } 1903 }
1681 } 1904 }
1682 } 1905 }
1683 set_link_state (dum); 1906 set_link_state(dum_hcd);
1684 ((__le16 *) buf)[0] = cpu_to_le16 (dum->port_status); 1907 ((__le16 *) buf)[0] = cpu_to_le16 (dum_hcd->port_status);
1685 ((__le16 *) buf)[1] = cpu_to_le16 (dum->port_status >> 16); 1908 ((__le16 *) buf)[1] = cpu_to_le16 (dum_hcd->port_status >> 16);
1686 break; 1909 break;
1687 case SetHubFeature: 1910 case SetHubFeature:
1688 retval = -EPIPE; 1911 retval = -EPIPE;
1689 break; 1912 break;
1690 case SetPortFeature: 1913 case SetPortFeature:
1691 switch (wValue) { 1914 switch (wValue) {
1915 case USB_PORT_FEAT_LINK_STATE:
1916 if (hcd->speed != HCD_USB3) {
1917 dev_dbg(dummy_dev(dum_hcd),
1918 "USB_PORT_FEAT_LINK_STATE req not "
1919 "supported for USB 2.0 roothub\n");
1920 goto error;
1921 }
1922 /*
1923 * Since this is dummy we don't have an actual link so
1924 * there is nothing to do for the SET_LINK_STATE cmd
1925 */
1926 break;
1927 case USB_PORT_FEAT_U1_TIMEOUT:
1928 case USB_PORT_FEAT_U2_TIMEOUT:
1929 /* TODO: add suspend/resume support! */
1930 if (hcd->speed != HCD_USB3) {
1931 dev_dbg(dummy_dev(dum_hcd),
1932 "USB_PORT_FEAT_U1/2_TIMEOUT req not "
1933 "supported for USB 2.0 roothub\n");
1934 goto error;
1935 }
1936 break;
1692 case USB_PORT_FEAT_SUSPEND: 1937 case USB_PORT_FEAT_SUSPEND:
1693 if (dum->active) { 1938 /* Applicable only for USB2.0 hub */
1694 dum->port_status |= USB_PORT_STAT_SUSPEND; 1939 if (hcd->speed == HCD_USB3) {
1940 dev_dbg(dummy_dev(dum_hcd),
1941 "USB_PORT_FEAT_SUSPEND req not "
1942 "supported for USB 3.0 roothub\n");
1943 goto error;
1944 }
1945 if (dum_hcd->active) {
1946 dum_hcd->port_status |= USB_PORT_STAT_SUSPEND;
1695 1947
1696 /* HNP would happen here; for now we 1948 /* HNP would happen here; for now we
1697 * assume b_bus_req is always true. 1949 * assume b_bus_req is always true.
1698 */ 1950 */
1699 set_link_state (dum); 1951 set_link_state(dum_hcd);
1700 if (((1 << USB_DEVICE_B_HNP_ENABLE) 1952 if (((1 << USB_DEVICE_B_HNP_ENABLE)
1701 & dum->devstatus) != 0) 1953 & dum_hcd->dum->devstatus) != 0)
1702 dev_dbg (dummy_dev(dum), 1954 dev_dbg(dummy_dev(dum_hcd),
1703 "no HNP yet!\n"); 1955 "no HNP yet!\n");
1704 } 1956 }
1705 break; 1957 break;
1706 case USB_PORT_FEAT_POWER: 1958 case USB_PORT_FEAT_POWER:
1707 dum->port_status |= USB_PORT_STAT_POWER; 1959 if (hcd->speed == HCD_USB3)
1708 set_link_state (dum); 1960 dum_hcd->port_status |= USB_SS_PORT_STAT_POWER;
1961 else
1962 dum_hcd->port_status |= USB_PORT_STAT_POWER;
1963 set_link_state(dum_hcd);
1709 break; 1964 break;
1965 case USB_PORT_FEAT_BH_PORT_RESET:
1966 /* Applicable only for USB3.0 hub */
1967 if (hcd->speed != HCD_USB3) {
1968 dev_dbg(dummy_dev(dum_hcd),
1969 "USB_PORT_FEAT_BH_PORT_RESET req not "
1970 "supported for USB 2.0 roothub\n");
1971 goto error;
1972 }
1973 /* FALLS THROUGH */
1710 case USB_PORT_FEAT_RESET: 1974 case USB_PORT_FEAT_RESET:
1711 /* if it's already enabled, disable */ 1975 /* if it's already enabled, disable */
1712 dum->port_status &= ~(USB_PORT_STAT_ENABLE 1976 if (hcd->speed == HCD_USB3) {
1977 dum_hcd->port_status = 0;
1978 dum_hcd->port_status =
1979 (USB_SS_PORT_STAT_POWER |
1980 USB_PORT_STAT_CONNECTION |
1981 USB_PORT_STAT_RESET);
1982 } else
1983 dum_hcd->port_status &= ~(USB_PORT_STAT_ENABLE
1713 | USB_PORT_STAT_LOW_SPEED 1984 | USB_PORT_STAT_LOW_SPEED
1714 | USB_PORT_STAT_HIGH_SPEED); 1985 | USB_PORT_STAT_HIGH_SPEED);
1715 dum->devstatus = 0; 1986 /*
1716 /* 50msec reset signaling */ 1987 * We want to reset device status. All but the
1717 dum->re_timeout = jiffies + msecs_to_jiffies(50); 1988 * Self powered feature
1989 */
1990 dum_hcd->dum->devstatus &=
1991 (1 << USB_DEVICE_SELF_POWERED);
1992 /*
1993 * FIXME USB3.0: what is the correct reset signaling
1994 * interval? Is it still 50msec as for HS?
1995 */
1996 dum_hcd->re_timeout = jiffies + msecs_to_jiffies(50);
1718 /* FALLS THROUGH */ 1997 /* FALLS THROUGH */
1719 default: 1998 default:
1720 if ((dum->port_status & USB_PORT_STAT_POWER) != 0) { 1999 if (hcd->speed == HCD_USB3) {
1721 dum->port_status |= (1 << wValue); 2000 if ((dum_hcd->port_status &
1722 set_link_state (dum); 2001 USB_SS_PORT_STAT_POWER) != 0) {
1723 } 2002 dum_hcd->port_status |= (1 << wValue);
2003 set_link_state(dum_hcd);
2004 }
2005 } else
2006 if ((dum_hcd->port_status &
2007 USB_PORT_STAT_POWER) != 0) {
2008 dum_hcd->port_status |= (1 << wValue);
2009 set_link_state(dum_hcd);
2010 }
2011 }
2012 break;
2013 case GetPortErrorCount:
2014 if (hcd->speed != HCD_USB3) {
2015 dev_dbg(dummy_dev(dum_hcd),
2016 "GetPortErrorCount req not "
2017 "supported for USB 2.0 roothub\n");
2018 goto error;
2019 }
2020 /* We'll always return 0 since this is a dummy hub */
2021 *(__le32 *) buf = cpu_to_le32(0);
2022 break;
2023 case SetHubDepth:
2024 if (hcd->speed != HCD_USB3) {
2025 dev_dbg(dummy_dev(dum_hcd),
2026 "SetHubDepth req not supported for "
2027 "USB 2.0 roothub\n");
2028 goto error;
1724 } 2029 }
1725 break; 2030 break;
1726
1727 default: 2031 default:
1728 dev_dbg (dummy_dev(dum), 2032 dev_dbg(dummy_dev(dum_hcd),
1729 "hub control req%04x v%04x i%04x l%d\n", 2033 "hub control req%04x v%04x i%04x l%d\n",
1730 typeReq, wValue, wIndex, wLength); 2034 typeReq, wValue, wIndex, wLength);
1731 2035error:
1732 /* "protocol stall" on error */ 2036 /* "protocol stall" on error */
1733 retval = -EPIPE; 2037 retval = -EPIPE;
1734 } 2038 }
1735 spin_unlock_irqrestore (&dum->lock, flags); 2039 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1736 2040
1737 if ((dum->port_status & PORT_C_MASK) != 0) 2041 if ((dum_hcd->port_status & PORT_C_MASK) != 0)
1738 usb_hcd_poll_rh_status (hcd); 2042 usb_hcd_poll_rh_status (hcd);
1739 return retval; 2043 return retval;
1740} 2044}
1741 2045
1742static int dummy_bus_suspend (struct usb_hcd *hcd) 2046static int dummy_bus_suspend (struct usb_hcd *hcd)
1743{ 2047{
1744 struct dummy *dum = hcd_to_dummy (hcd); 2048 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
1745 2049
1746 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__); 2050 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__);
1747 2051
1748 spin_lock_irq (&dum->lock); 2052 spin_lock_irq(&dum_hcd->dum->lock);
1749 dum->rh_state = DUMMY_RH_SUSPENDED; 2053 dum_hcd->rh_state = DUMMY_RH_SUSPENDED;
1750 set_link_state (dum); 2054 set_link_state(dum_hcd);
1751 hcd->state = HC_STATE_SUSPENDED; 2055 hcd->state = HC_STATE_SUSPENDED;
1752 spin_unlock_irq (&dum->lock); 2056 spin_unlock_irq(&dum_hcd->dum->lock);
1753 return 0; 2057 return 0;
1754} 2058}
1755 2059
1756static int dummy_bus_resume (struct usb_hcd *hcd) 2060static int dummy_bus_resume (struct usb_hcd *hcd)
1757{ 2061{
1758 struct dummy *dum = hcd_to_dummy (hcd); 2062 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
1759 int rc = 0; 2063 int rc = 0;
1760 2064
1761 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__); 2065 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__);
1762 2066
1763 spin_lock_irq (&dum->lock); 2067 spin_lock_irq(&dum_hcd->dum->lock);
1764 if (!HCD_HW_ACCESSIBLE(hcd)) { 2068 if (!HCD_HW_ACCESSIBLE(hcd)) {
1765 rc = -ESHUTDOWN; 2069 rc = -ESHUTDOWN;
1766 } else { 2070 } else {
1767 dum->rh_state = DUMMY_RH_RUNNING; 2071 dum_hcd->rh_state = DUMMY_RH_RUNNING;
1768 set_link_state (dum); 2072 set_link_state(dum_hcd);
1769 if (!list_empty(&dum->urbp_list)) 2073 if (!list_empty(&dum_hcd->urbp_list))
1770 mod_timer (&dum->timer, jiffies); 2074 mod_timer(&dum_hcd->timer, jiffies);
1771 hcd->state = HC_STATE_RUNNING; 2075 hcd->state = HC_STATE_RUNNING;
1772 } 2076 }
1773 spin_unlock_irq (&dum->lock); 2077 spin_unlock_irq(&dum_hcd->dum->lock);
1774 return rc; 2078 return rc;
1775} 2079}
1776 2080
@@ -1786,18 +2090,37 @@ show_urb (char *buf, size_t size, struct urb *urb)
1786 urb, 2090 urb,
1787 ({ char *s; 2091 ({ char *s;
1788 switch (urb->dev->speed) { 2092 switch (urb->dev->speed) {
1789 case USB_SPEED_LOW: s = "ls"; break; 2093 case USB_SPEED_LOW:
1790 case USB_SPEED_FULL: s = "fs"; break; 2094 s = "ls";
1791 case USB_SPEED_HIGH: s = "hs"; break; 2095 break;
1792 default: s = "?"; break; 2096 case USB_SPEED_FULL:
2097 s = "fs";
2098 break;
2099 case USB_SPEED_HIGH:
2100 s = "hs";
2101 break;
2102 case USB_SPEED_SUPER:
2103 s = "ss";
2104 break;
2105 default:
2106 s = "?";
2107 break;
1793 }; s; }), 2108 }; s; }),
1794 ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "", 2109 ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "",
1795 ({ char *s; \ 2110 ({ char *s; \
1796 switch (usb_pipetype (urb->pipe)) { \ 2111 switch (usb_pipetype (urb->pipe)) { \
1797 case PIPE_CONTROL: s = ""; break; \ 2112 case PIPE_CONTROL: \
1798 case PIPE_BULK: s = "-bulk"; break; \ 2113 s = ""; \
1799 case PIPE_INTERRUPT: s = "-int"; break; \ 2114 break; \
1800 default: s = "-iso"; break; \ 2115 case PIPE_BULK: \
2116 s = "-bulk"; \
2117 break; \
2118 case PIPE_INTERRUPT: \
2119 s = "-int"; \
2120 break; \
2121 default: \
2122 s = "-iso"; \
2123 break; \
1801 }; s;}), 2124 }; s;}),
1802 urb->actual_length, urb->transfer_buffer_length); 2125 urb->actual_length, urb->transfer_buffer_length);
1803} 2126}
@@ -1806,43 +2129,63 @@ static ssize_t
1806show_urbs (struct device *dev, struct device_attribute *attr, char *buf) 2129show_urbs (struct device *dev, struct device_attribute *attr, char *buf)
1807{ 2130{
1808 struct usb_hcd *hcd = dev_get_drvdata (dev); 2131 struct usb_hcd *hcd = dev_get_drvdata (dev);
1809 struct dummy *dum = hcd_to_dummy (hcd); 2132 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
1810 struct urbp *urbp; 2133 struct urbp *urbp;
1811 size_t size = 0; 2134 size_t size = 0;
1812 unsigned long flags; 2135 unsigned long flags;
1813 2136
1814 spin_lock_irqsave (&dum->lock, flags); 2137 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1815 list_for_each_entry (urbp, &dum->urbp_list, urbp_list) { 2138 list_for_each_entry(urbp, &dum_hcd->urbp_list, urbp_list) {
1816 size_t temp; 2139 size_t temp;
1817 2140
1818 temp = show_urb (buf, PAGE_SIZE - size, urbp->urb); 2141 temp = show_urb (buf, PAGE_SIZE - size, urbp->urb);
1819 buf += temp; 2142 buf += temp;
1820 size += temp; 2143 size += temp;
1821 } 2144 }
1822 spin_unlock_irqrestore (&dum->lock, flags); 2145 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1823 2146
1824 return size; 2147 return size;
1825} 2148}
1826static DEVICE_ATTR (urbs, S_IRUGO, show_urbs, NULL); 2149static DEVICE_ATTR (urbs, S_IRUGO, show_urbs, NULL);
1827 2150
1828static int dummy_start (struct usb_hcd *hcd) 2151static int dummy_start_ss(struct dummy_hcd *dum_hcd)
1829{ 2152{
1830 struct dummy *dum; 2153 init_timer(&dum_hcd->timer);
2154 dum_hcd->timer.function = dummy_timer;
2155 dum_hcd->timer.data = (unsigned long)dum_hcd;
2156 dum_hcd->rh_state = DUMMY_RH_RUNNING;
2157 INIT_LIST_HEAD(&dum_hcd->urbp_list);
2158 dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET;
2159 dummy_hcd_to_hcd(dum_hcd)->state = HC_STATE_RUNNING;
2160 dummy_hcd_to_hcd(dum_hcd)->uses_new_polling = 1;
2161#ifdef CONFIG_USB_OTG
2162 dummy_hcd_to_hcd(dum_hcd)->self.otg_port = 1;
2163#endif
2164 return 0;
2165
2166 /* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
2167 return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
2168}
1831 2169
1832 dum = hcd_to_dummy (hcd); 2170static int dummy_start(struct usb_hcd *hcd)
2171{
2172 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
1833 2173
1834 /* 2174 /*
1835 * MASTER side init ... we emulate a root hub that'll only ever 2175 * MASTER side init ... we emulate a root hub that'll only ever
1836 * talk to one device (the slave side). Also appears in sysfs, 2176 * talk to one device (the slave side). Also appears in sysfs,
1837 * just like more familiar pci-based HCDs. 2177 * just like more familiar pci-based HCDs.
1838 */ 2178 */
1839 spin_lock_init (&dum->lock); 2179 if (!usb_hcd_is_primary_hcd(hcd))
1840 init_timer (&dum->timer); 2180 return dummy_start_ss(dum_hcd);
1841 dum->timer.function = dummy_timer;
1842 dum->timer.data = (unsigned long) dum;
1843 dum->rh_state = DUMMY_RH_RUNNING;
1844 2181
1845 INIT_LIST_HEAD (&dum->urbp_list); 2182 spin_lock_init(&dum_hcd->dum->lock);
2183 init_timer(&dum_hcd->timer);
2184 dum_hcd->timer.function = dummy_timer;
2185 dum_hcd->timer.data = (unsigned long)dum_hcd;
2186 dum_hcd->rh_state = DUMMY_RH_RUNNING;
2187
2188 INIT_LIST_HEAD(&dum_hcd->urbp_list);
1846 2189
1847 hcd->power_budget = POWER_BUDGET; 2190 hcd->power_budget = POWER_BUDGET;
1848 hcd->state = HC_STATE_RUNNING; 2191 hcd->state = HC_STATE_RUNNING;
@@ -1853,18 +2196,17 @@ static int dummy_start (struct usb_hcd *hcd)
1853#endif 2196#endif
1854 2197
1855 /* FIXME 'urbs' should be a per-device thing, maybe in usbcore */ 2198 /* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
1856 return device_create_file (dummy_dev(dum), &dev_attr_urbs); 2199 return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
1857} 2200}
1858 2201
1859static void dummy_stop (struct usb_hcd *hcd) 2202static void dummy_stop (struct usb_hcd *hcd)
1860{ 2203{
1861 struct dummy *dum; 2204 struct dummy *dum;
1862 2205
1863 dum = hcd_to_dummy (hcd); 2206 dum = (hcd_to_dummy_hcd(hcd))->dum;
1864 2207 device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd)), &dev_attr_urbs);
1865 device_remove_file (dummy_dev(dum), &dev_attr_urbs); 2208 usb_gadget_unregister_driver(dum->driver);
1866 usb_gadget_unregister_driver (dum->driver); 2209 dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n");
1867 dev_info (dummy_dev(dum), "stopped\n");
1868} 2210}
1869 2211
1870/*-------------------------------------------------------------------------*/ 2212/*-------------------------------------------------------------------------*/
@@ -1874,13 +2216,59 @@ static int dummy_h_get_frame (struct usb_hcd *hcd)
1874 return dummy_g_get_frame (NULL); 2216 return dummy_g_get_frame (NULL);
1875} 2217}
1876 2218
1877static const struct hc_driver dummy_hcd = { 2219static int dummy_setup(struct usb_hcd *hcd)
2220{
2221 if (usb_hcd_is_primary_hcd(hcd)) {
2222 the_controller.hs_hcd = hcd_to_dummy_hcd(hcd);
2223 the_controller.hs_hcd->dum = &the_controller;
2224 /*
2225 * Mark the first roothub as being USB 2.0.
2226 * The USB 3.0 roothub will be registered later by
2227 * dummy_hcd_probe()
2228 */
2229 hcd->speed = HCD_USB2;
2230 hcd->self.root_hub->speed = USB_SPEED_HIGH;
2231 } else {
2232 the_controller.ss_hcd = hcd_to_dummy_hcd(hcd);
2233 the_controller.ss_hcd->dum = &the_controller;
2234 hcd->speed = HCD_USB3;
2235 hcd->self.root_hub->speed = USB_SPEED_SUPER;
2236 }
2237 return 0;
2238}
2239
2240/* Change a group of bulk endpoints to support multiple stream IDs */
2241int dummy_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
2242 struct usb_host_endpoint **eps, unsigned int num_eps,
2243 unsigned int num_streams, gfp_t mem_flags)
2244{
2245 if (hcd->speed != HCD_USB3)
2246 dev_dbg(dummy_dev(hcd_to_dummy_hcd(hcd)),
2247 "%s() - ERROR! Not supported for USB2.0 roothub\n",
2248 __func__);
2249 return 0;
2250}
2251
2252/* Reverts a group of bulk endpoints back to not using stream IDs. */
2253int dummy_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
2254 struct usb_host_endpoint **eps, unsigned int num_eps,
2255 gfp_t mem_flags)
2256{
2257 if (hcd->speed != HCD_USB3)
2258 dev_dbg(dummy_dev(hcd_to_dummy_hcd(hcd)),
2259 "%s() - ERROR! Not supported for USB2.0 roothub\n",
2260 __func__);
2261 return 0;
2262}
2263
2264static struct hc_driver dummy_hcd = {
1878 .description = (char *) driver_name, 2265 .description = (char *) driver_name,
1879 .product_desc = "Dummy host controller", 2266 .product_desc = "Dummy host controller",
1880 .hcd_priv_size = sizeof(struct dummy), 2267 .hcd_priv_size = sizeof(struct dummy_hcd),
1881 2268
1882 .flags = HCD_USB2, 2269 .flags = HCD_USB3 | HCD_SHARED,
1883 2270
2271 .reset = dummy_setup,
1884 .start = dummy_start, 2272 .start = dummy_start,
1885 .stop = dummy_stop, 2273 .stop = dummy_stop,
1886 2274
@@ -1893,51 +2281,85 @@ static const struct hc_driver dummy_hcd = {
1893 .hub_control = dummy_hub_control, 2281 .hub_control = dummy_hub_control,
1894 .bus_suspend = dummy_bus_suspend, 2282 .bus_suspend = dummy_bus_suspend,
1895 .bus_resume = dummy_bus_resume, 2283 .bus_resume = dummy_bus_resume,
2284
2285 .alloc_streams = dummy_alloc_streams,
2286 .free_streams = dummy_free_streams,
1896}; 2287};
1897 2288
1898static int dummy_hcd_probe(struct platform_device *pdev) 2289static int dummy_hcd_probe(struct platform_device *pdev)
1899{ 2290{
1900 struct usb_hcd *hcd; 2291 struct usb_hcd *hs_hcd;
2292 struct usb_hcd *ss_hcd;
1901 int retval; 2293 int retval;
1902 2294
1903 dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc); 2295 dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
1904 2296
1905 hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, dev_name(&pdev->dev)); 2297 if (!mod_data.is_super_speed)
1906 if (!hcd) 2298 dummy_hcd.flags = HCD_USB2;
2299 hs_hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, dev_name(&pdev->dev));
2300 if (!hs_hcd)
1907 return -ENOMEM; 2301 return -ENOMEM;
1908 the_controller = hcd_to_dummy (hcd); 2302 hs_hcd->has_tt = 1;
1909 hcd->has_tt = 1;
1910 2303
1911 retval = usb_add_hcd(hcd, 0, 0); 2304 retval = usb_add_hcd(hs_hcd, 0, 0);
1912 if (retval != 0) { 2305 if (retval != 0) {
1913 usb_put_hcd (hcd); 2306 usb_put_hcd(hs_hcd);
1914 the_controller = NULL; 2307 return retval;
2308 }
2309
2310 if (mod_data.is_super_speed) {
2311 ss_hcd = usb_create_shared_hcd(&dummy_hcd, &pdev->dev,
2312 dev_name(&pdev->dev), hs_hcd);
2313 if (!ss_hcd) {
2314 retval = -ENOMEM;
2315 goto dealloc_usb2_hcd;
2316 }
2317
2318 retval = usb_add_hcd(ss_hcd, 0, 0);
2319 if (retval)
2320 goto put_usb3_hcd;
1915 } 2321 }
2322 return 0;
2323
2324put_usb3_hcd:
2325 usb_put_hcd(ss_hcd);
2326dealloc_usb2_hcd:
2327 usb_put_hcd(hs_hcd);
2328 the_controller.hs_hcd = the_controller.ss_hcd = NULL;
1916 return retval; 2329 return retval;
1917} 2330}
1918 2331
1919static int dummy_hcd_remove (struct platform_device *pdev) 2332static int dummy_hcd_remove(struct platform_device *pdev)
1920{ 2333{
1921 struct usb_hcd *hcd; 2334 struct dummy *dum;
2335
2336 dum = (hcd_to_dummy_hcd(platform_get_drvdata(pdev)))->dum;
2337
2338 if (dum->ss_hcd) {
2339 usb_remove_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
2340 usb_put_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
2341 }
2342
2343 usb_remove_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2344 usb_put_hcd(dummy_hcd_to_hcd(dum->hs_hcd));
2345
2346 the_controller.hs_hcd = NULL;
2347 the_controller.ss_hcd = NULL;
1922 2348
1923 hcd = platform_get_drvdata (pdev);
1924 usb_remove_hcd (hcd);
1925 usb_put_hcd (hcd);
1926 the_controller = NULL;
1927 return 0; 2349 return 0;
1928} 2350}
1929 2351
1930static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state) 2352static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state)
1931{ 2353{
1932 struct usb_hcd *hcd; 2354 struct usb_hcd *hcd;
1933 struct dummy *dum; 2355 struct dummy_hcd *dum_hcd;
1934 int rc = 0; 2356 int rc = 0;
1935 2357
1936 dev_dbg (&pdev->dev, "%s\n", __func__); 2358 dev_dbg (&pdev->dev, "%s\n", __func__);
1937 2359
1938 hcd = platform_get_drvdata (pdev); 2360 hcd = platform_get_drvdata (pdev);
1939 dum = hcd_to_dummy (hcd); 2361 dum_hcd = hcd_to_dummy_hcd(hcd);
1940 if (dum->rh_state == DUMMY_RH_RUNNING) { 2362 if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
1941 dev_warn(&pdev->dev, "Root hub isn't suspended!\n"); 2363 dev_warn(&pdev->dev, "Root hub isn't suspended!\n");
1942 rc = -EBUSY; 2364 rc = -EBUSY;
1943 } else 2365 } else
@@ -1980,6 +2402,9 @@ static int __init init (void)
1980 if (usb_disabled ()) 2402 if (usb_disabled ())
1981 return -ENODEV; 2403 return -ENODEV;
1982 2404
2405 if (!mod_data.is_high_speed && mod_data.is_super_speed)
2406 return -EINVAL;
2407
1983 the_hcd_pdev = platform_device_alloc(driver_name, -1); 2408 the_hcd_pdev = platform_device_alloc(driver_name, -1);
1984 if (!the_hcd_pdev) 2409 if (!the_hcd_pdev)
1985 return retval; 2410 return retval;
@@ -1997,7 +2422,8 @@ static int __init init (void)
1997 retval = platform_device_add(the_hcd_pdev); 2422 retval = platform_device_add(the_hcd_pdev);
1998 if (retval < 0) 2423 if (retval < 0)
1999 goto err_add_hcd; 2424 goto err_add_hcd;
2000 if (!the_controller) { 2425 if (!the_controller.hs_hcd ||
2426 (!the_controller.ss_hcd && mod_data.is_super_speed)) {
2001 /* 2427 /*
2002 * The hcd was added successfully but its probe function failed 2428 * The hcd was added successfully but its probe function failed
2003 * for some reason. 2429 * for some reason.
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-06 22:08:07 -0500