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