dummy_hcd.c revision caf29f62655e7aa57996821535d11fa3b0537b6b
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 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 */ 23 24 25/* 26 * This exposes a device side "USB gadget" API, driven by requests to a 27 * Linux-USB host controller driver. USB traffic is simulated; there's 28 * no need for USB hardware. Use this with two other drivers: 29 * 30 * - Gadget driver, responding to requests (slave); 31 * - Host-side device driver, as already familiar in Linux. 32 * 33 * Having this all in one kernel can help some stages of development, 34 * bypassing some hardware (and driver) issues. UML could help too. 35 */ 36 37#include <linux/module.h> 38#include <linux/kernel.h> 39#include <linux/delay.h> 40#include <linux/ioport.h> 41#include <linux/slab.h> 42#include <linux/errno.h> 43#include <linux/init.h> 44#include <linux/timer.h> 45#include <linux/list.h> 46#include <linux/interrupt.h> 47#include <linux/platform_device.h> 48#include <linux/usb.h> 49#include <linux/usb/gadget.h> 50 51#include <asm/byteorder.h> 52#include <asm/io.h> 53#include <asm/irq.h> 54#include <asm/system.h> 55#include <asm/unaligned.h> 56 57 58#include "../core/hcd.h" 59 60 61#define DRIVER_DESC "USB Host+Gadget Emulator" 62#define DRIVER_VERSION "02 May 2005" 63 64#define POWER_BUDGET 500 /* in mA; use 8 for low-power port testing */ 65 66static const char driver_name [] = "dummy_hcd"; 67static const char driver_desc [] = "USB Host+Gadget Emulator"; 68 69static const char gadget_name [] = "dummy_udc"; 70 71MODULE_DESCRIPTION (DRIVER_DESC); 72MODULE_AUTHOR ("David Brownell"); 73MODULE_LICENSE ("GPL"); 74 75/*-------------------------------------------------------------------------*/ 76 77/* gadget side driver data structres */ 78struct dummy_ep { 79 struct list_head queue; 80 unsigned long last_io; /* jiffies timestamp */ 81 struct usb_gadget *gadget; 82 const struct usb_endpoint_descriptor *desc; 83 struct usb_ep ep; 84 unsigned halted : 1; 85 unsigned already_seen : 1; 86 unsigned setup_stage : 1; 87}; 88 89struct dummy_request { 90 struct list_head queue; /* ep's requests */ 91 struct usb_request req; 92}; 93 94static inline struct dummy_ep *usb_ep_to_dummy_ep (struct usb_ep *_ep) 95{ 96 return container_of (_ep, struct dummy_ep, ep); 97} 98 99static inline struct dummy_request *usb_request_to_dummy_request 100 (struct usb_request *_req) 101{ 102 return container_of (_req, struct dummy_request, req); 103} 104 105/*-------------------------------------------------------------------------*/ 106 107/* 108 * Every device has ep0 for control requests, plus up to 30 more endpoints, 109 * in one of two types: 110 * 111 * - Configurable: direction (in/out), type (bulk, iso, etc), and endpoint 112 * number can be changed. Names like "ep-a" are used for this type. 113 * 114 * - Fixed Function: in other cases. some characteristics may be mutable; 115 * that'd be hardware-specific. Names like "ep12out-bulk" are used. 116 * 117 * Gadget drivers are responsible for not setting up conflicting endpoint 118 * configurations, illegal or unsupported packet lengths, and so on. 119 */ 120 121static const char ep0name [] = "ep0"; 122 123static const char *const ep_name [] = { 124 ep0name, /* everyone has ep0 */ 125 126 /* act like a net2280: high speed, six configurable endpoints */ 127 "ep-a", "ep-b", "ep-c", "ep-d", "ep-e", "ep-f", 128 129 /* or like pxa250: fifteen fixed function endpoints */ 130 "ep1in-bulk", "ep2out-bulk", "ep3in-iso", "ep4out-iso", "ep5in-int", 131 "ep6in-bulk", "ep7out-bulk", "ep8in-iso", "ep9out-iso", "ep10in-int", 132 "ep11in-bulk", "ep12out-bulk", "ep13in-iso", "ep14out-iso", 133 "ep15in-int", 134 135 /* or like sa1100: two fixed function endpoints */ 136 "ep1out-bulk", "ep2in-bulk", 137}; 138#define DUMMY_ENDPOINTS ARRAY_SIZE(ep_name) 139 140/*-------------------------------------------------------------------------*/ 141 142#define FIFO_SIZE 64 143 144struct urbp { 145 struct urb *urb; 146 struct list_head urbp_list; 147}; 148 149 150enum dummy_rh_state { 151 DUMMY_RH_RESET, 152 DUMMY_RH_SUSPENDED, 153 DUMMY_RH_RUNNING 154}; 155 156struct dummy { 157 spinlock_t lock; 158 159 /* 160 * SLAVE/GADGET side support 161 */ 162 struct dummy_ep ep [DUMMY_ENDPOINTS]; 163 int address; 164 struct usb_gadget gadget; 165 struct usb_gadget_driver *driver; 166 struct dummy_request fifo_req; 167 u8 fifo_buf [FIFO_SIZE]; 168 u16 devstatus; 169 unsigned udc_suspended:1; 170 unsigned pullup:1; 171 unsigned active:1; 172 unsigned old_active:1; 173 174 /* 175 * MASTER/HOST side support 176 */ 177 enum dummy_rh_state rh_state; 178 struct timer_list timer; 179 u32 port_status; 180 u32 old_status; 181 unsigned resuming:1; 182 unsigned long re_timeout; 183 184 struct usb_device *udev; 185 struct list_head urbp_list; 186}; 187 188static inline struct dummy *hcd_to_dummy (struct usb_hcd *hcd) 189{ 190 return (struct dummy *) (hcd->hcd_priv); 191} 192 193static inline struct usb_hcd *dummy_to_hcd (struct dummy *dum) 194{ 195 return container_of((void *) dum, struct usb_hcd, hcd_priv); 196} 197 198static inline struct device *dummy_dev (struct dummy *dum) 199{ 200 return dummy_to_hcd(dum)->self.controller; 201} 202 203static inline struct device *udc_dev (struct dummy *dum) 204{ 205 return dum->gadget.dev.parent; 206} 207 208static inline struct dummy *ep_to_dummy (struct dummy_ep *ep) 209{ 210 return container_of (ep->gadget, struct dummy, gadget); 211} 212 213static inline struct dummy *gadget_to_dummy (struct usb_gadget *gadget) 214{ 215 return container_of (gadget, struct dummy, gadget); 216} 217 218static inline struct dummy *gadget_dev_to_dummy (struct device *dev) 219{ 220 return container_of (dev, struct dummy, gadget.dev); 221} 222 223static struct dummy *the_controller; 224 225/*-------------------------------------------------------------------------*/ 226 227/* SLAVE/GADGET SIDE UTILITY ROUTINES */ 228 229/* called with spinlock held */ 230static void nuke (struct dummy *dum, struct dummy_ep *ep) 231{ 232 while (!list_empty (&ep->queue)) { 233 struct dummy_request *req; 234 235 req = list_entry (ep->queue.next, struct dummy_request, queue); 236 list_del_init (&req->queue); 237 req->req.status = -ESHUTDOWN; 238 239 spin_unlock (&dum->lock); 240 req->req.complete (&ep->ep, &req->req); 241 spin_lock (&dum->lock); 242 } 243} 244 245/* caller must hold lock */ 246static void 247stop_activity (struct dummy *dum) 248{ 249 struct dummy_ep *ep; 250 251 /* prevent any more requests */ 252 dum->address = 0; 253 254 /* The timer is left running so that outstanding URBs can fail */ 255 256 /* nuke any pending requests first, so driver i/o is quiesced */ 257 list_for_each_entry (ep, &dum->gadget.ep_list, ep.ep_list) 258 nuke (dum, ep); 259 260 /* driver now does any non-usb quiescing necessary */ 261} 262 263/* caller must hold lock */ 264static void 265set_link_state (struct dummy *dum) 266{ 267 dum->active = 0; 268 if ((dum->port_status & USB_PORT_STAT_POWER) == 0) 269 dum->port_status = 0; 270 271 /* UDC suspend must cause a disconnect */ 272 else if (!dum->pullup || dum->udc_suspended) { 273 dum->port_status &= ~(USB_PORT_STAT_CONNECTION | 274 USB_PORT_STAT_ENABLE | 275 USB_PORT_STAT_LOW_SPEED | 276 USB_PORT_STAT_HIGH_SPEED | 277 USB_PORT_STAT_SUSPEND); 278 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0) 279 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16); 280 } else { 281 dum->port_status |= USB_PORT_STAT_CONNECTION; 282 if ((dum->old_status & USB_PORT_STAT_CONNECTION) == 0) 283 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16); 284 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0) 285 dum->port_status &= ~USB_PORT_STAT_SUSPEND; 286 else if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 && 287 dum->rh_state != DUMMY_RH_SUSPENDED) 288 dum->active = 1; 289 } 290 291 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0 || dum->active) 292 dum->resuming = 0; 293 294 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0 || 295 (dum->port_status & USB_PORT_STAT_RESET) != 0) { 296 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0 && 297 (dum->old_status & USB_PORT_STAT_RESET) == 0 && 298 dum->driver) { 299 stop_activity (dum); 300 spin_unlock (&dum->lock); 301 dum->driver->disconnect (&dum->gadget); 302 spin_lock (&dum->lock); 303 } 304 } else if (dum->active != dum->old_active) { 305 if (dum->old_active && dum->driver->suspend) { 306 spin_unlock (&dum->lock); 307 dum->driver->suspend (&dum->gadget); 308 spin_lock (&dum->lock); 309 } else if (!dum->old_active && dum->driver->resume) { 310 spin_unlock (&dum->lock); 311 dum->driver->resume (&dum->gadget); 312 spin_lock (&dum->lock); 313 } 314 } 315 316 dum->old_status = dum->port_status; 317 dum->old_active = dum->active; 318} 319 320/*-------------------------------------------------------------------------*/ 321 322/* SLAVE/GADGET SIDE DRIVER 323 * 324 * This only tracks gadget state. All the work is done when the host 325 * side tries some (emulated) i/o operation. Real device controller 326 * drivers would do real i/o using dma, fifos, irqs, timers, etc. 327 */ 328 329#define is_enabled(dum) \ 330 (dum->port_status & USB_PORT_STAT_ENABLE) 331 332static int 333dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) 334{ 335 struct dummy *dum; 336 struct dummy_ep *ep; 337 unsigned max; 338 int retval; 339 340 ep = usb_ep_to_dummy_ep (_ep); 341 if (!_ep || !desc || ep->desc || _ep->name == ep0name 342 || desc->bDescriptorType != USB_DT_ENDPOINT) 343 return -EINVAL; 344 dum = ep_to_dummy (ep); 345 if (!dum->driver || !is_enabled (dum)) 346 return -ESHUTDOWN; 347 max = le16_to_cpu(desc->wMaxPacketSize) & 0x3ff; 348 349 /* drivers must not request bad settings, since lower levels 350 * (hardware or its drivers) may not check. some endpoints 351 * can't do iso, many have maxpacket limitations, etc. 352 * 353 * since this "hardware" driver is here to help debugging, we 354 * have some extra sanity checks. (there could be more though, 355 * especially for "ep9out" style fixed function ones.) 356 */ 357 retval = -EINVAL; 358 switch (desc->bmAttributes & 0x03) { 359 case USB_ENDPOINT_XFER_BULK: 360 if (strstr (ep->ep.name, "-iso") 361 || strstr (ep->ep.name, "-int")) { 362 goto done; 363 } 364 switch (dum->gadget.speed) { 365 case USB_SPEED_HIGH: 366 if (max == 512) 367 break; 368 /* conserve return statements */ 369 default: 370 switch (max) { 371 case 8: case 16: case 32: case 64: 372 /* we'll fake any legal size */ 373 break; 374 default: 375 case USB_SPEED_LOW: 376 goto done; 377 } 378 } 379 break; 380 case USB_ENDPOINT_XFER_INT: 381 if (strstr (ep->ep.name, "-iso")) /* bulk is ok */ 382 goto done; 383 /* real hardware might not handle all packet sizes */ 384 switch (dum->gadget.speed) { 385 case USB_SPEED_HIGH: 386 if (max <= 1024) 387 break; 388 /* save a return statement */ 389 case USB_SPEED_FULL: 390 if (max <= 64) 391 break; 392 /* save a return statement */ 393 default: 394 if (max <= 8) 395 break; 396 goto done; 397 } 398 break; 399 case USB_ENDPOINT_XFER_ISOC: 400 if (strstr (ep->ep.name, "-bulk") 401 || strstr (ep->ep.name, "-int")) 402 goto done; 403 /* real hardware might not handle all packet sizes */ 404 switch (dum->gadget.speed) { 405 case USB_SPEED_HIGH: 406 if (max <= 1024) 407 break; 408 /* save a return statement */ 409 case USB_SPEED_FULL: 410 if (max <= 1023) 411 break; 412 /* save a return statement */ 413 default: 414 goto done; 415 } 416 break; 417 default: 418 /* few chips support control except on ep0 */ 419 goto done; 420 } 421 422 _ep->maxpacket = max; 423 ep->desc = desc; 424 425 dev_dbg (udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d\n", 426 _ep->name, 427 desc->bEndpointAddress & 0x0f, 428 (desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out", 429 ({ char *val; 430 switch (desc->bmAttributes & 0x03) { 431 case USB_ENDPOINT_XFER_BULK: val = "bulk"; break; 432 case USB_ENDPOINT_XFER_ISOC: val = "iso"; break; 433 case USB_ENDPOINT_XFER_INT: val = "intr"; break; 434 default: val = "ctrl"; break; 435 }; val; }), 436 max); 437 438 /* at this point real hardware should be NAKing transfers 439 * to that endpoint, until a buffer is queued to it. 440 */ 441 retval = 0; 442done: 443 return retval; 444} 445 446static int dummy_disable (struct usb_ep *_ep) 447{ 448 struct dummy_ep *ep; 449 struct dummy *dum; 450 unsigned long flags; 451 int retval; 452 453 ep = usb_ep_to_dummy_ep (_ep); 454 if (!_ep || !ep->desc || _ep->name == ep0name) 455 return -EINVAL; 456 dum = ep_to_dummy (ep); 457 458 spin_lock_irqsave (&dum->lock, flags); 459 ep->desc = NULL; 460 retval = 0; 461 nuke (dum, ep); 462 spin_unlock_irqrestore (&dum->lock, flags); 463 464 dev_dbg (udc_dev(dum), "disabled %s\n", _ep->name); 465 return retval; 466} 467 468static struct usb_request * 469dummy_alloc_request (struct usb_ep *_ep, gfp_t mem_flags) 470{ 471 struct dummy_ep *ep; 472 struct dummy_request *req; 473 474 if (!_ep) 475 return NULL; 476 ep = usb_ep_to_dummy_ep (_ep); 477 478 req = kzalloc(sizeof(*req), mem_flags); 479 if (!req) 480 return NULL; 481 INIT_LIST_HEAD (&req->queue); 482 return &req->req; 483} 484 485static void 486dummy_free_request (struct usb_ep *_ep, struct usb_request *_req) 487{ 488 struct dummy_ep *ep; 489 struct dummy_request *req; 490 491 ep = usb_ep_to_dummy_ep (_ep); 492 if (!ep || !_req || (!ep->desc && _ep->name != ep0name)) 493 return; 494 495 req = usb_request_to_dummy_request (_req); 496 WARN_ON (!list_empty (&req->queue)); 497 kfree (req); 498} 499 500static void 501fifo_complete (struct usb_ep *ep, struct usb_request *req) 502{ 503} 504 505static int 506dummy_queue (struct usb_ep *_ep, struct usb_request *_req, 507 gfp_t mem_flags) 508{ 509 struct dummy_ep *ep; 510 struct dummy_request *req; 511 struct dummy *dum; 512 unsigned long flags; 513 514 req = usb_request_to_dummy_request (_req); 515 if (!_req || !list_empty (&req->queue) || !_req->complete) 516 return -EINVAL; 517 518 ep = usb_ep_to_dummy_ep (_ep); 519 if (!_ep || (!ep->desc && _ep->name != ep0name)) 520 return -EINVAL; 521 522 dum = ep_to_dummy (ep); 523 if (!dum->driver || !is_enabled (dum)) 524 return -ESHUTDOWN; 525 526#if 0 527 dev_dbg (udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n", 528 ep, _req, _ep->name, _req->length, _req->buf); 529#endif 530 531 _req->status = -EINPROGRESS; 532 _req->actual = 0; 533 spin_lock_irqsave (&dum->lock, flags); 534 535 /* implement an emulated single-request FIFO */ 536 if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) && 537 list_empty (&dum->fifo_req.queue) && 538 list_empty (&ep->queue) && 539 _req->length <= FIFO_SIZE) { 540 req = &dum->fifo_req; 541 req->req = *_req; 542 req->req.buf = dum->fifo_buf; 543 memcpy (dum->fifo_buf, _req->buf, _req->length); 544 req->req.context = dum; 545 req->req.complete = fifo_complete; 546 547 spin_unlock (&dum->lock); 548 _req->actual = _req->length; 549 _req->status = 0; 550 _req->complete (_ep, _req); 551 spin_lock (&dum->lock); 552 } 553 list_add_tail (&req->queue, &ep->queue); 554 spin_unlock_irqrestore (&dum->lock, flags); 555 556 /* real hardware would likely enable transfers here, in case 557 * it'd been left NAKing. 558 */ 559 return 0; 560} 561 562static int dummy_dequeue (struct usb_ep *_ep, struct usb_request *_req) 563{ 564 struct dummy_ep *ep; 565 struct dummy *dum; 566 int retval = -EINVAL; 567 unsigned long flags; 568 struct dummy_request *req = NULL; 569 570 if (!_ep || !_req) 571 return retval; 572 ep = usb_ep_to_dummy_ep (_ep); 573 dum = ep_to_dummy (ep); 574 575 if (!dum->driver) 576 return -ESHUTDOWN; 577 578 local_irq_save (flags); 579 spin_lock (&dum->lock); 580 list_for_each_entry (req, &ep->queue, queue) { 581 if (&req->req == _req) { 582 list_del_init (&req->queue); 583 _req->status = -ECONNRESET; 584 retval = 0; 585 break; 586 } 587 } 588 spin_unlock (&dum->lock); 589 590 if (retval == 0) { 591 dev_dbg (udc_dev(dum), 592 "dequeued req %p from %s, len %d buf %p\n", 593 req, _ep->name, _req->length, _req->buf); 594 _req->complete (_ep, _req); 595 } 596 local_irq_restore (flags); 597 return retval; 598} 599 600static int 601dummy_set_halt (struct usb_ep *_ep, int value) 602{ 603 struct dummy_ep *ep; 604 struct dummy *dum; 605 606 if (!_ep) 607 return -EINVAL; 608 ep = usb_ep_to_dummy_ep (_ep); 609 dum = ep_to_dummy (ep); 610 if (!dum->driver) 611 return -ESHUTDOWN; 612 if (!value) 613 ep->halted = 0; 614 else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) && 615 !list_empty (&ep->queue)) 616 return -EAGAIN; 617 else 618 ep->halted = 1; 619 /* FIXME clear emulated data toggle too */ 620 return 0; 621} 622 623static const struct usb_ep_ops dummy_ep_ops = { 624 .enable = dummy_enable, 625 .disable = dummy_disable, 626 627 .alloc_request = dummy_alloc_request, 628 .free_request = dummy_free_request, 629 630 .queue = dummy_queue, 631 .dequeue = dummy_dequeue, 632 633 .set_halt = dummy_set_halt, 634}; 635 636/*-------------------------------------------------------------------------*/ 637 638/* there are both host and device side versions of this call ... */ 639static int dummy_g_get_frame (struct usb_gadget *_gadget) 640{ 641 struct timeval tv; 642 643 do_gettimeofday (&tv); 644 return tv.tv_usec / 1000; 645} 646 647static int dummy_wakeup (struct usb_gadget *_gadget) 648{ 649 struct dummy *dum; 650 651 dum = gadget_to_dummy (_gadget); 652 if (!(dum->devstatus & ( (1 << USB_DEVICE_B_HNP_ENABLE) 653 | (1 << USB_DEVICE_REMOTE_WAKEUP)))) 654 return -EINVAL; 655 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0) 656 return -ENOLINK; 657 if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 && 658 dum->rh_state != DUMMY_RH_SUSPENDED) 659 return -EIO; 660 661 /* FIXME: What if the root hub is suspended but the port isn't? */ 662 663 /* hub notices our request, issues downstream resume, etc */ 664 dum->resuming = 1; 665 dum->re_timeout = jiffies + msecs_to_jiffies(20); 666 mod_timer (&dummy_to_hcd (dum)->rh_timer, dum->re_timeout); 667 return 0; 668} 669 670static int dummy_set_selfpowered (struct usb_gadget *_gadget, int value) 671{ 672 struct dummy *dum; 673 674 dum = gadget_to_dummy (_gadget); 675 if (value) 676 dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED); 677 else 678 dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED); 679 return 0; 680} 681 682static int dummy_pullup (struct usb_gadget *_gadget, int value) 683{ 684 struct dummy *dum; 685 unsigned long flags; 686 687 dum = gadget_to_dummy (_gadget); 688 spin_lock_irqsave (&dum->lock, flags); 689 dum->pullup = (value != 0); 690 set_link_state (dum); 691 spin_unlock_irqrestore (&dum->lock, flags); 692 693 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 694 return 0; 695} 696 697static const struct usb_gadget_ops dummy_ops = { 698 .get_frame = dummy_g_get_frame, 699 .wakeup = dummy_wakeup, 700 .set_selfpowered = dummy_set_selfpowered, 701 .pullup = dummy_pullup, 702}; 703 704/*-------------------------------------------------------------------------*/ 705 706/* "function" sysfs attribute */ 707static ssize_t 708show_function (struct device *dev, struct device_attribute *attr, char *buf) 709{ 710 struct dummy *dum = gadget_dev_to_dummy (dev); 711 712 if (!dum->driver || !dum->driver->function) 713 return 0; 714 return scnprintf (buf, PAGE_SIZE, "%s\n", dum->driver->function); 715} 716static DEVICE_ATTR (function, S_IRUGO, show_function, NULL); 717 718/*-------------------------------------------------------------------------*/ 719 720/* 721 * Driver registration/unregistration. 722 * 723 * This is basically hardware-specific; there's usually only one real USB 724 * device (not host) controller since that's how USB devices are intended 725 * to work. So most implementations of these api calls will rely on the 726 * fact that only one driver will ever bind to the hardware. But curious 727 * hardware can be built with discrete components, so the gadget API doesn't 728 * require that assumption. 729 * 730 * For this emulator, it might be convenient to create a usb slave device 731 * for each driver that registers: just add to a big root hub. 732 */ 733 734int 735usb_gadget_register_driver (struct usb_gadget_driver *driver) 736{ 737 struct dummy *dum = the_controller; 738 int retval, i; 739 740 if (!dum) 741 return -EINVAL; 742 if (dum->driver) 743 return -EBUSY; 744 if (!driver->bind || !driver->setup 745 || driver->speed == USB_SPEED_UNKNOWN) 746 return -EINVAL; 747 748 /* 749 * SLAVE side init ... the layer above hardware, which 750 * can't enumerate without help from the driver we're binding. 751 */ 752 753 dum->devstatus = 0; 754 755 INIT_LIST_HEAD (&dum->gadget.ep_list); 756 for (i = 0; i < DUMMY_ENDPOINTS; i++) { 757 struct dummy_ep *ep = &dum->ep [i]; 758 759 if (!ep_name [i]) 760 break; 761 ep->ep.name = ep_name [i]; 762 ep->ep.ops = &dummy_ep_ops; 763 list_add_tail (&ep->ep.ep_list, &dum->gadget.ep_list); 764 ep->halted = ep->already_seen = ep->setup_stage = 0; 765 ep->ep.maxpacket = ~0; 766 ep->last_io = jiffies; 767 ep->gadget = &dum->gadget; 768 ep->desc = NULL; 769 INIT_LIST_HEAD (&ep->queue); 770 } 771 772 dum->gadget.ep0 = &dum->ep [0].ep; 773 dum->ep [0].ep.maxpacket = 64; 774 list_del_init (&dum->ep [0].ep.ep_list); 775 INIT_LIST_HEAD(&dum->fifo_req.queue); 776 777 driver->driver.bus = NULL; 778 dum->driver = driver; 779 dum->gadget.dev.driver = &driver->driver; 780 dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n", 781 driver->driver.name); 782 retval = driver->bind(&dum->gadget); 783 if (retval) { 784 dum->driver = NULL; 785 dum->gadget.dev.driver = NULL; 786 return retval; 787 } 788 789 /* khubd will enumerate this in a while */ 790 spin_lock_irq (&dum->lock); 791 dum->pullup = 1; 792 set_link_state (dum); 793 spin_unlock_irq (&dum->lock); 794 795 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 796 return 0; 797} 798EXPORT_SYMBOL (usb_gadget_register_driver); 799 800int 801usb_gadget_unregister_driver (struct usb_gadget_driver *driver) 802{ 803 struct dummy *dum = the_controller; 804 unsigned long flags; 805 806 if (!dum) 807 return -ENODEV; 808 if (!driver || driver != dum->driver || !driver->unbind) 809 return -EINVAL; 810 811 dev_dbg (udc_dev(dum), "unregister gadget driver '%s'\n", 812 driver->driver.name); 813 814 spin_lock_irqsave (&dum->lock, flags); 815 dum->pullup = 0; 816 set_link_state (dum); 817 spin_unlock_irqrestore (&dum->lock, flags); 818 819 driver->unbind (&dum->gadget); 820 dum->gadget.dev.driver = NULL; 821 dum->driver = NULL; 822 823 spin_lock_irqsave (&dum->lock, flags); 824 dum->pullup = 0; 825 set_link_state (dum); 826 spin_unlock_irqrestore (&dum->lock, flags); 827 828 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 829 return 0; 830} 831EXPORT_SYMBOL (usb_gadget_unregister_driver); 832 833#undef is_enabled 834 835/* just declare this in any driver that really need it */ 836extern int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode); 837 838int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode) 839{ 840 return -ENOSYS; 841} 842EXPORT_SYMBOL (net2280_set_fifo_mode); 843 844 845/* The gadget structure is stored inside the hcd structure and will be 846 * released along with it. */ 847static void 848dummy_gadget_release (struct device *dev) 849{ 850 struct dummy *dum = gadget_dev_to_dummy (dev); 851 852 usb_put_hcd (dummy_to_hcd (dum)); 853} 854 855static int dummy_udc_probe (struct platform_device *pdev) 856{ 857 struct dummy *dum = the_controller; 858 int rc; 859 860 dum->gadget.name = gadget_name; 861 dum->gadget.ops = &dummy_ops; 862 dum->gadget.is_dualspeed = 1; 863 864 /* maybe claim OTG support, though we won't complete HNP */ 865 dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0); 866 867 strcpy (dum->gadget.dev.bus_id, "gadget"); 868 dum->gadget.dev.parent = &pdev->dev; 869 dum->gadget.dev.release = dummy_gadget_release; 870 rc = device_register (&dum->gadget.dev); 871 if (rc < 0) 872 return rc; 873 874 usb_get_hcd (dummy_to_hcd (dum)); 875 876 platform_set_drvdata (pdev, dum); 877 rc = device_create_file (&dum->gadget.dev, &dev_attr_function); 878 if (rc < 0) 879 device_unregister (&dum->gadget.dev); 880 return rc; 881} 882 883static int dummy_udc_remove (struct platform_device *pdev) 884{ 885 struct dummy *dum = platform_get_drvdata (pdev); 886 887 platform_set_drvdata (pdev, NULL); 888 device_remove_file (&dum->gadget.dev, &dev_attr_function); 889 device_unregister (&dum->gadget.dev); 890 return 0; 891} 892 893static int dummy_udc_suspend (struct platform_device *pdev, pm_message_t state) 894{ 895 struct dummy *dum = platform_get_drvdata(pdev); 896 897 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); 898 spin_lock_irq (&dum->lock); 899 dum->udc_suspended = 1; 900 set_link_state (dum); 901 spin_unlock_irq (&dum->lock); 902 903 pdev->dev.power.power_state = state; 904 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 905 return 0; 906} 907 908static int dummy_udc_resume (struct platform_device *pdev) 909{ 910 struct dummy *dum = platform_get_drvdata(pdev); 911 912 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); 913 spin_lock_irq (&dum->lock); 914 dum->udc_suspended = 0; 915 set_link_state (dum); 916 spin_unlock_irq (&dum->lock); 917 918 pdev->dev.power.power_state = PMSG_ON; 919 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 920 return 0; 921} 922 923static struct platform_driver dummy_udc_driver = { 924 .probe = dummy_udc_probe, 925 .remove = dummy_udc_remove, 926 .suspend = dummy_udc_suspend, 927 .resume = dummy_udc_resume, 928 .driver = { 929 .name = (char *) gadget_name, 930 .owner = THIS_MODULE, 931 }, 932}; 933 934/*-------------------------------------------------------------------------*/ 935 936/* MASTER/HOST SIDE DRIVER 937 * 938 * this uses the hcd framework to hook up to host side drivers. 939 * its root hub will only have one device, otherwise it acts like 940 * a normal host controller. 941 * 942 * when urbs are queued, they're just stuck on a list that we 943 * scan in a timer callback. that callback connects writes from 944 * the host with reads from the device, and so on, based on the 945 * usb 2.0 rules. 946 */ 947 948static int dummy_urb_enqueue ( 949 struct usb_hcd *hcd, 950 struct urb *urb, 951 gfp_t mem_flags 952) { 953 struct dummy *dum; 954 struct urbp *urbp; 955 unsigned long flags; 956 int rc; 957 958 if (!urb->transfer_buffer && urb->transfer_buffer_length) 959 return -EINVAL; 960 961 urbp = kmalloc (sizeof *urbp, mem_flags); 962 if (!urbp) 963 return -ENOMEM; 964 urbp->urb = urb; 965 966 dum = hcd_to_dummy (hcd); 967 spin_lock_irqsave (&dum->lock, flags); 968 rc = usb_hcd_link_urb_to_ep(hcd, urb); 969 if (rc) { 970 kfree(urbp); 971 goto done; 972 } 973 974 if (!dum->udev) { 975 dum->udev = urb->dev; 976 usb_get_dev (dum->udev); 977 } else if (unlikely (dum->udev != urb->dev)) 978 dev_err (dummy_dev(dum), "usb_device address has changed!\n"); 979 980 list_add_tail (&urbp->urbp_list, &dum->urbp_list); 981 urb->hcpriv = urbp; 982 if (usb_pipetype (urb->pipe) == PIPE_CONTROL) 983 urb->error_count = 1; /* mark as a new urb */ 984 985 /* kick the scheduler, it'll do the rest */ 986 if (!timer_pending (&dum->timer)) 987 mod_timer (&dum->timer, jiffies + 1); 988 989 done: 990 spin_unlock_irqrestore(&dum->lock, flags); 991 return rc; 992} 993 994static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) 995{ 996 struct dummy *dum; 997 unsigned long flags; 998 int rc; 999 1000 /* giveback happens automatically in timer callback, 1001 * so make sure the callback happens */ 1002 dum = hcd_to_dummy (hcd); 1003 spin_lock_irqsave (&dum->lock, flags); 1004 1005 rc = usb_hcd_check_unlink_urb(hcd, urb, status); 1006 if (!rc && dum->rh_state != DUMMY_RH_RUNNING && 1007 !list_empty(&dum->urbp_list)) 1008 mod_timer (&dum->timer, jiffies); 1009 1010 spin_unlock_irqrestore (&dum->lock, flags); 1011 return rc; 1012} 1013 1014/* transfer up to a frame's worth; caller must own lock */ 1015static int 1016transfer(struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit, 1017 int *status) 1018{ 1019 struct dummy_request *req; 1020 1021top: 1022 /* if there's no request queued, the device is NAKing; return */ 1023 list_for_each_entry (req, &ep->queue, queue) { 1024 unsigned host_len, dev_len, len; 1025 int is_short, to_host; 1026 int rescan = 0; 1027 1028 /* 1..N packets of ep->ep.maxpacket each ... the last one 1029 * may be short (including zero length). 1030 * 1031 * writer can send a zlp explicitly (length 0) or implicitly 1032 * (length mod maxpacket zero, and 'zero' flag); they always 1033 * terminate reads. 1034 */ 1035 host_len = urb->transfer_buffer_length - urb->actual_length; 1036 dev_len = req->req.length - req->req.actual; 1037 len = min (host_len, dev_len); 1038 1039 /* FIXME update emulated data toggle too */ 1040 1041 to_host = usb_pipein (urb->pipe); 1042 if (unlikely (len == 0)) 1043 is_short = 1; 1044 else { 1045 char *ubuf, *rbuf; 1046 1047 /* not enough bandwidth left? */ 1048 if (limit < ep->ep.maxpacket && limit < len) 1049 break; 1050 len = min (len, (unsigned) limit); 1051 if (len == 0) 1052 break; 1053 1054 /* use an extra pass for the final short packet */ 1055 if (len > ep->ep.maxpacket) { 1056 rescan = 1; 1057 len -= (len % ep->ep.maxpacket); 1058 } 1059 is_short = (len % ep->ep.maxpacket) != 0; 1060 1061 /* else transfer packet(s) */ 1062 ubuf = urb->transfer_buffer + urb->actual_length; 1063 rbuf = req->req.buf + req->req.actual; 1064 if (to_host) 1065 memcpy (ubuf, rbuf, len); 1066 else 1067 memcpy (rbuf, ubuf, len); 1068 ep->last_io = jiffies; 1069 1070 limit -= len; 1071 urb->actual_length += len; 1072 req->req.actual += len; 1073 } 1074 1075 /* short packets terminate, maybe with overflow/underflow. 1076 * it's only really an error to write too much. 1077 * 1078 * partially filling a buffer optionally blocks queue advances 1079 * (so completion handlers can clean up the queue) but we don't 1080 * need to emulate such data-in-flight. 1081 */ 1082 if (is_short) { 1083 if (host_len == dev_len) { 1084 req->req.status = 0; 1085 *status = 0; 1086 } else if (to_host) { 1087 req->req.status = 0; 1088 if (dev_len > host_len) 1089 *status = -EOVERFLOW; 1090 else 1091 *status = 0; 1092 } else if (!to_host) { 1093 *status = 0; 1094 if (host_len > dev_len) 1095 req->req.status = -EOVERFLOW; 1096 else 1097 req->req.status = 0; 1098 } 1099 1100 /* many requests terminate without a short packet */ 1101 } else { 1102 if (req->req.length == req->req.actual 1103 && !req->req.zero) 1104 req->req.status = 0; 1105 if (urb->transfer_buffer_length == urb->actual_length 1106 && !(urb->transfer_flags 1107 & URB_ZERO_PACKET)) 1108 *status = 0; 1109 } 1110 1111 /* device side completion --> continuable */ 1112 if (req->req.status != -EINPROGRESS) { 1113 list_del_init (&req->queue); 1114 1115 spin_unlock (&dum->lock); 1116 req->req.complete (&ep->ep, &req->req); 1117 spin_lock (&dum->lock); 1118 1119 /* requests might have been unlinked... */ 1120 rescan = 1; 1121 } 1122 1123 /* host side completion --> terminate */ 1124 if (*status != -EINPROGRESS) 1125 break; 1126 1127 /* rescan to continue with any other queued i/o */ 1128 if (rescan) 1129 goto top; 1130 } 1131 return limit; 1132} 1133 1134static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep) 1135{ 1136 int limit = ep->ep.maxpacket; 1137 1138 if (dum->gadget.speed == USB_SPEED_HIGH) { 1139 int tmp; 1140 1141 /* high bandwidth mode */ 1142 tmp = le16_to_cpu(ep->desc->wMaxPacketSize); 1143 tmp = (tmp >> 11) & 0x03; 1144 tmp *= 8 /* applies to entire frame */; 1145 limit += limit * tmp; 1146 } 1147 return limit; 1148} 1149 1150#define is_active(dum) ((dum->port_status & \ 1151 (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \ 1152 USB_PORT_STAT_SUSPEND)) \ 1153 == (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE)) 1154 1155static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address) 1156{ 1157 int i; 1158 1159 if (!is_active (dum)) 1160 return NULL; 1161 if ((address & ~USB_DIR_IN) == 0) 1162 return &dum->ep [0]; 1163 for (i = 1; i < DUMMY_ENDPOINTS; i++) { 1164 struct dummy_ep *ep = &dum->ep [i]; 1165 1166 if (!ep->desc) 1167 continue; 1168 if (ep->desc->bEndpointAddress == address) 1169 return ep; 1170 } 1171 return NULL; 1172} 1173 1174#undef is_active 1175 1176#define Dev_Request (USB_TYPE_STANDARD | USB_RECIP_DEVICE) 1177#define Dev_InRequest (Dev_Request | USB_DIR_IN) 1178#define Intf_Request (USB_TYPE_STANDARD | USB_RECIP_INTERFACE) 1179#define Intf_InRequest (Intf_Request | USB_DIR_IN) 1180#define Ep_Request (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT) 1181#define Ep_InRequest (Ep_Request | USB_DIR_IN) 1182 1183/* drive both sides of the transfers; looks like irq handlers to 1184 * both drivers except the callbacks aren't in_irq(). 1185 */ 1186static void dummy_timer (unsigned long _dum) 1187{ 1188 struct dummy *dum = (struct dummy *) _dum; 1189 struct urbp *urbp, *tmp; 1190 unsigned long flags; 1191 int limit, total; 1192 int i; 1193 1194 /* simplistic model for one frame's bandwidth */ 1195 switch (dum->gadget.speed) { 1196 case USB_SPEED_LOW: 1197 total = 8/*bytes*/ * 12/*packets*/; 1198 break; 1199 case USB_SPEED_FULL: 1200 total = 64/*bytes*/ * 19/*packets*/; 1201 break; 1202 case USB_SPEED_HIGH: 1203 total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/; 1204 break; 1205 default: 1206 dev_err (dummy_dev(dum), "bogus device speed\n"); 1207 return; 1208 } 1209 1210 /* FIXME if HZ != 1000 this will probably misbehave ... */ 1211 1212 /* look at each urb queued by the host side driver */ 1213 spin_lock_irqsave (&dum->lock, flags); 1214 1215 if (!dum->udev) { 1216 dev_err (dummy_dev(dum), 1217 "timer fired with no URBs pending?\n"); 1218 spin_unlock_irqrestore (&dum->lock, flags); 1219 return; 1220 } 1221 1222 for (i = 0; i < DUMMY_ENDPOINTS; i++) { 1223 if (!ep_name [i]) 1224 break; 1225 dum->ep [i].already_seen = 0; 1226 } 1227 1228restart: 1229 list_for_each_entry_safe (urbp, tmp, &dum->urbp_list, urbp_list) { 1230 struct urb *urb; 1231 struct dummy_request *req; 1232 u8 address; 1233 struct dummy_ep *ep = NULL; 1234 int type; 1235 int status = -EINPROGRESS; 1236 1237 urb = urbp->urb; 1238 if (urb->unlinked) 1239 goto return_urb; 1240 else if (dum->rh_state != DUMMY_RH_RUNNING) 1241 continue; 1242 type = usb_pipetype (urb->pipe); 1243 1244 /* used up this frame's non-periodic bandwidth? 1245 * FIXME there's infinite bandwidth for control and 1246 * periodic transfers ... unrealistic. 1247 */ 1248 if (total <= 0 && type == PIPE_BULK) 1249 continue; 1250 1251 /* find the gadget's ep for this request (if configured) */ 1252 address = usb_pipeendpoint (urb->pipe); 1253 if (usb_pipein (urb->pipe)) 1254 address |= USB_DIR_IN; 1255 ep = find_endpoint(dum, address); 1256 if (!ep) { 1257 /* set_configuration() disagreement */ 1258 dev_dbg (dummy_dev(dum), 1259 "no ep configured for urb %p\n", 1260 urb); 1261 status = -EPROTO; 1262 goto return_urb; 1263 } 1264 1265 if (ep->already_seen) 1266 continue; 1267 ep->already_seen = 1; 1268 if (ep == &dum->ep [0] && urb->error_count) { 1269 ep->setup_stage = 1; /* a new urb */ 1270 urb->error_count = 0; 1271 } 1272 if (ep->halted && !ep->setup_stage) { 1273 /* NOTE: must not be iso! */ 1274 dev_dbg (dummy_dev(dum), "ep %s halted, urb %p\n", 1275 ep->ep.name, urb); 1276 status = -EPIPE; 1277 goto return_urb; 1278 } 1279 /* FIXME make sure both ends agree on maxpacket */ 1280 1281 /* handle control requests */ 1282 if (ep == &dum->ep [0] && ep->setup_stage) { 1283 struct usb_ctrlrequest setup; 1284 int value = 1; 1285 struct dummy_ep *ep2; 1286 unsigned w_index; 1287 unsigned w_value; 1288 1289 setup = *(struct usb_ctrlrequest*) urb->setup_packet; 1290 w_index = le16_to_cpu(setup.wIndex); 1291 w_value = le16_to_cpu(setup.wValue); 1292 if (le16_to_cpu(setup.wLength) != 1293 urb->transfer_buffer_length) { 1294 status = -EOVERFLOW; 1295 goto return_urb; 1296 } 1297 1298 /* paranoia, in case of stale queued data */ 1299 list_for_each_entry (req, &ep->queue, queue) { 1300 list_del_init (&req->queue); 1301 req->req.status = -EOVERFLOW; 1302 dev_dbg (udc_dev(dum), "stale req = %p\n", 1303 req); 1304 1305 spin_unlock (&dum->lock); 1306 req->req.complete (&ep->ep, &req->req); 1307 spin_lock (&dum->lock); 1308 ep->already_seen = 0; 1309 goto restart; 1310 } 1311 1312 /* gadget driver never sees set_address or operations 1313 * on standard feature flags. some hardware doesn't 1314 * even expose them. 1315 */ 1316 ep->last_io = jiffies; 1317 ep->setup_stage = 0; 1318 ep->halted = 0; 1319 switch (setup.bRequest) { 1320 case USB_REQ_SET_ADDRESS: 1321 if (setup.bRequestType != Dev_Request) 1322 break; 1323 dum->address = w_value; 1324 status = 0; 1325 dev_dbg (udc_dev(dum), "set_address = %d\n", 1326 w_value); 1327 value = 0; 1328 break; 1329 case USB_REQ_SET_FEATURE: 1330 if (setup.bRequestType == Dev_Request) { 1331 value = 0; 1332 switch (w_value) { 1333 case USB_DEVICE_REMOTE_WAKEUP: 1334 break; 1335 case USB_DEVICE_B_HNP_ENABLE: 1336 dum->gadget.b_hnp_enable = 1; 1337 break; 1338 case USB_DEVICE_A_HNP_SUPPORT: 1339 dum->gadget.a_hnp_support = 1; 1340 break; 1341 case USB_DEVICE_A_ALT_HNP_SUPPORT: 1342 dum->gadget.a_alt_hnp_support 1343 = 1; 1344 break; 1345 default: 1346 value = -EOPNOTSUPP; 1347 } 1348 if (value == 0) { 1349 dum->devstatus |= 1350 (1 << w_value); 1351 status = 0; 1352 } 1353 1354 } else if (setup.bRequestType == Ep_Request) { 1355 // endpoint halt 1356 ep2 = find_endpoint (dum, w_index); 1357 if (!ep2) { 1358 value = -EOPNOTSUPP; 1359 break; 1360 } 1361 ep2->halted = 1; 1362 value = 0; 1363 status = 0; 1364 } 1365 break; 1366 case USB_REQ_CLEAR_FEATURE: 1367 if (setup.bRequestType == Dev_Request) { 1368 switch (w_value) { 1369 case USB_DEVICE_REMOTE_WAKEUP: 1370 dum->devstatus &= ~(1 << 1371 USB_DEVICE_REMOTE_WAKEUP); 1372 value = 0; 1373 status = 0; 1374 break; 1375 default: 1376 value = -EOPNOTSUPP; 1377 break; 1378 } 1379 } else if (setup.bRequestType == Ep_Request) { 1380 // endpoint halt 1381 ep2 = find_endpoint (dum, w_index); 1382 if (!ep2) { 1383 value = -EOPNOTSUPP; 1384 break; 1385 } 1386 ep2->halted = 0; 1387 value = 0; 1388 status = 0; 1389 } 1390 break; 1391 case USB_REQ_GET_STATUS: 1392 if (setup.bRequestType == Dev_InRequest 1393 || setup.bRequestType 1394 == Intf_InRequest 1395 || setup.bRequestType 1396 == Ep_InRequest 1397 ) { 1398 char *buf; 1399 1400 // device: remote wakeup, selfpowered 1401 // interface: nothing 1402 // endpoint: halt 1403 buf = (char *)urb->transfer_buffer; 1404 if (urb->transfer_buffer_length > 0) { 1405 if (setup.bRequestType == 1406 Ep_InRequest) { 1407 ep2 = find_endpoint (dum, w_index); 1408 if (!ep2) { 1409 value = -EOPNOTSUPP; 1410 break; 1411 } 1412 buf [0] = ep2->halted; 1413 } else if (setup.bRequestType == 1414 Dev_InRequest) { 1415 buf [0] = (u8) 1416 dum->devstatus; 1417 } else 1418 buf [0] = 0; 1419 } 1420 if (urb->transfer_buffer_length > 1) 1421 buf [1] = 0; 1422 urb->actual_length = min (2, 1423 urb->transfer_buffer_length); 1424 value = 0; 1425 status = 0; 1426 } 1427 break; 1428 } 1429 1430 /* gadget driver handles all other requests. block 1431 * until setup() returns; no reentrancy issues etc. 1432 */ 1433 if (value > 0) { 1434 spin_unlock (&dum->lock); 1435 value = dum->driver->setup (&dum->gadget, 1436 &setup); 1437 spin_lock (&dum->lock); 1438 1439 if (value >= 0) { 1440 /* no delays (max 64KB data stage) */ 1441 limit = 64*1024; 1442 goto treat_control_like_bulk; 1443 } 1444 /* error, see below */ 1445 } 1446 1447 if (value < 0) { 1448 if (value != -EOPNOTSUPP) 1449 dev_dbg (udc_dev(dum), 1450 "setup --> %d\n", 1451 value); 1452 status = -EPIPE; 1453 urb->actual_length = 0; 1454 } 1455 1456 goto return_urb; 1457 } 1458 1459 /* non-control requests */ 1460 limit = total; 1461 switch (usb_pipetype (urb->pipe)) { 1462 case PIPE_ISOCHRONOUS: 1463 /* FIXME is it urb->interval since the last xfer? 1464 * use urb->iso_frame_desc[i]. 1465 * complete whether or not ep has requests queued. 1466 * report random errors, to debug drivers. 1467 */ 1468 limit = max (limit, periodic_bytes (dum, ep)); 1469 status = -ENOSYS; 1470 break; 1471 1472 case PIPE_INTERRUPT: 1473 /* FIXME is it urb->interval since the last xfer? 1474 * this almost certainly polls too fast. 1475 */ 1476 limit = max (limit, periodic_bytes (dum, ep)); 1477 /* FALLTHROUGH */ 1478 1479 // case PIPE_BULK: case PIPE_CONTROL: 1480 default: 1481 treat_control_like_bulk: 1482 ep->last_io = jiffies; 1483 total = transfer(dum, urb, ep, limit, &status); 1484 break; 1485 } 1486 1487 /* incomplete transfer? */ 1488 if (status == -EINPROGRESS) 1489 continue; 1490 1491return_urb: 1492 list_del (&urbp->urbp_list); 1493 kfree (urbp); 1494 if (ep) 1495 ep->already_seen = ep->setup_stage = 0; 1496 1497 usb_hcd_unlink_urb_from_ep(dummy_to_hcd(dum), urb); 1498 spin_unlock (&dum->lock); 1499 usb_hcd_giveback_urb(dummy_to_hcd(dum), urb, status); 1500 spin_lock (&dum->lock); 1501 1502 goto restart; 1503 } 1504 1505 if (list_empty (&dum->urbp_list)) { 1506 usb_put_dev (dum->udev); 1507 dum->udev = NULL; 1508 } else if (dum->rh_state == DUMMY_RH_RUNNING) { 1509 /* want a 1 msec delay here */ 1510 mod_timer (&dum->timer, jiffies + msecs_to_jiffies(1)); 1511 } 1512 1513 spin_unlock_irqrestore (&dum->lock, flags); 1514} 1515 1516/*-------------------------------------------------------------------------*/ 1517 1518#define PORT_C_MASK \ 1519 ((USB_PORT_STAT_C_CONNECTION \ 1520 | USB_PORT_STAT_C_ENABLE \ 1521 | USB_PORT_STAT_C_SUSPEND \ 1522 | USB_PORT_STAT_C_OVERCURRENT \ 1523 | USB_PORT_STAT_C_RESET) << 16) 1524 1525static int dummy_hub_status (struct usb_hcd *hcd, char *buf) 1526{ 1527 struct dummy *dum; 1528 unsigned long flags; 1529 int retval = 0; 1530 1531 dum = hcd_to_dummy (hcd); 1532 1533 spin_lock_irqsave (&dum->lock, flags); 1534 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) 1535 goto done; 1536 1537 if (dum->resuming && time_after_eq (jiffies, dum->re_timeout)) { 1538 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16); 1539 dum->port_status &= ~USB_PORT_STAT_SUSPEND; 1540 set_link_state (dum); 1541 } 1542 1543 if ((dum->port_status & PORT_C_MASK) != 0) { 1544 *buf = (1 << 1); 1545 dev_dbg (dummy_dev(dum), "port status 0x%08x has changes\n", 1546 dum->port_status); 1547 retval = 1; 1548 if (dum->rh_state == DUMMY_RH_SUSPENDED) 1549 usb_hcd_resume_root_hub (hcd); 1550 } 1551done: 1552 spin_unlock_irqrestore (&dum->lock, flags); 1553 return retval; 1554} 1555 1556static inline void 1557hub_descriptor (struct usb_hub_descriptor *desc) 1558{ 1559 memset (desc, 0, sizeof *desc); 1560 desc->bDescriptorType = 0x29; 1561 desc->bDescLength = 9; 1562 desc->wHubCharacteristics = (__force __u16) 1563 (__constant_cpu_to_le16 (0x0001)); 1564 desc->bNbrPorts = 1; 1565 desc->bitmap [0] = 0xff; 1566 desc->bitmap [1] = 0xff; 1567} 1568 1569static int dummy_hub_control ( 1570 struct usb_hcd *hcd, 1571 u16 typeReq, 1572 u16 wValue, 1573 u16 wIndex, 1574 char *buf, 1575 u16 wLength 1576) { 1577 struct dummy *dum; 1578 int retval = 0; 1579 unsigned long flags; 1580 1581 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) 1582 return -ETIMEDOUT; 1583 1584 dum = hcd_to_dummy (hcd); 1585 spin_lock_irqsave (&dum->lock, flags); 1586 switch (typeReq) { 1587 case ClearHubFeature: 1588 break; 1589 case ClearPortFeature: 1590 switch (wValue) { 1591 case USB_PORT_FEAT_SUSPEND: 1592 if (dum->port_status & USB_PORT_STAT_SUSPEND) { 1593 /* 20msec resume signaling */ 1594 dum->resuming = 1; 1595 dum->re_timeout = jiffies + 1596 msecs_to_jiffies(20); 1597 } 1598 break; 1599 case USB_PORT_FEAT_POWER: 1600 if (dum->port_status & USB_PORT_STAT_POWER) 1601 dev_dbg (dummy_dev(dum), "power-off\n"); 1602 /* FALLS THROUGH */ 1603 default: 1604 dum->port_status &= ~(1 << wValue); 1605 set_link_state (dum); 1606 } 1607 break; 1608 case GetHubDescriptor: 1609 hub_descriptor ((struct usb_hub_descriptor *) buf); 1610 break; 1611 case GetHubStatus: 1612 *(__le32 *) buf = __constant_cpu_to_le32 (0); 1613 break; 1614 case GetPortStatus: 1615 if (wIndex != 1) 1616 retval = -EPIPE; 1617 1618 /* whoever resets or resumes must GetPortStatus to 1619 * complete it!! 1620 */ 1621 if (dum->resuming && 1622 time_after_eq (jiffies, dum->re_timeout)) { 1623 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16); 1624 dum->port_status &= ~USB_PORT_STAT_SUSPEND; 1625 } 1626 if ((dum->port_status & USB_PORT_STAT_RESET) != 0 && 1627 time_after_eq (jiffies, dum->re_timeout)) { 1628 dum->port_status |= (USB_PORT_STAT_C_RESET << 16); 1629 dum->port_status &= ~USB_PORT_STAT_RESET; 1630 if (dum->pullup) { 1631 dum->port_status |= USB_PORT_STAT_ENABLE; 1632 /* give it the best speed we agree on */ 1633 dum->gadget.speed = dum->driver->speed; 1634 dum->gadget.ep0->maxpacket = 64; 1635 switch (dum->gadget.speed) { 1636 case USB_SPEED_HIGH: 1637 dum->port_status |= 1638 USB_PORT_STAT_HIGH_SPEED; 1639 break; 1640 case USB_SPEED_LOW: 1641 dum->gadget.ep0->maxpacket = 8; 1642 dum->port_status |= 1643 USB_PORT_STAT_LOW_SPEED; 1644 break; 1645 default: 1646 dum->gadget.speed = USB_SPEED_FULL; 1647 break; 1648 } 1649 } 1650 } 1651 set_link_state (dum); 1652 ((__le16 *) buf)[0] = cpu_to_le16 (dum->port_status); 1653 ((__le16 *) buf)[1] = cpu_to_le16 (dum->port_status >> 16); 1654 break; 1655 case SetHubFeature: 1656 retval = -EPIPE; 1657 break; 1658 case SetPortFeature: 1659 switch (wValue) { 1660 case USB_PORT_FEAT_SUSPEND: 1661 if (dum->active) { 1662 dum->port_status |= USB_PORT_STAT_SUSPEND; 1663 1664 /* HNP would happen here; for now we 1665 * assume b_bus_req is always true. 1666 */ 1667 set_link_state (dum); 1668 if (((1 << USB_DEVICE_B_HNP_ENABLE) 1669 & dum->devstatus) != 0) 1670 dev_dbg (dummy_dev(dum), 1671 "no HNP yet!\n"); 1672 } 1673 break; 1674 case USB_PORT_FEAT_POWER: 1675 dum->port_status |= USB_PORT_STAT_POWER; 1676 set_link_state (dum); 1677 break; 1678 case USB_PORT_FEAT_RESET: 1679 /* if it's already enabled, disable */ 1680 dum->port_status &= ~(USB_PORT_STAT_ENABLE 1681 | USB_PORT_STAT_LOW_SPEED 1682 | USB_PORT_STAT_HIGH_SPEED); 1683 dum->devstatus = 0; 1684 /* 50msec reset signaling */ 1685 dum->re_timeout = jiffies + msecs_to_jiffies(50); 1686 /* FALLS THROUGH */ 1687 default: 1688 if ((dum->port_status & USB_PORT_STAT_POWER) != 0) { 1689 dum->port_status |= (1 << wValue); 1690 set_link_state (dum); 1691 } 1692 } 1693 break; 1694 1695 default: 1696 dev_dbg (dummy_dev(dum), 1697 "hub control req%04x v%04x i%04x l%d\n", 1698 typeReq, wValue, wIndex, wLength); 1699 1700 /* "protocol stall" on error */ 1701 retval = -EPIPE; 1702 } 1703 spin_unlock_irqrestore (&dum->lock, flags); 1704 1705 if ((dum->port_status & PORT_C_MASK) != 0) 1706 usb_hcd_poll_rh_status (hcd); 1707 return retval; 1708} 1709 1710static int dummy_bus_suspend (struct usb_hcd *hcd) 1711{ 1712 struct dummy *dum = hcd_to_dummy (hcd); 1713 1714 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__); 1715 1716 spin_lock_irq (&dum->lock); 1717 dum->rh_state = DUMMY_RH_SUSPENDED; 1718 set_link_state (dum); 1719 hcd->state = HC_STATE_SUSPENDED; 1720 spin_unlock_irq (&dum->lock); 1721 return 0; 1722} 1723 1724static int dummy_bus_resume (struct usb_hcd *hcd) 1725{ 1726 struct dummy *dum = hcd_to_dummy (hcd); 1727 int rc = 0; 1728 1729 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__); 1730 1731 spin_lock_irq (&dum->lock); 1732 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) { 1733 rc = -ESHUTDOWN; 1734 } else { 1735 dum->rh_state = DUMMY_RH_RUNNING; 1736 set_link_state (dum); 1737 if (!list_empty(&dum->urbp_list)) 1738 mod_timer (&dum->timer, jiffies); 1739 hcd->state = HC_STATE_RUNNING; 1740 } 1741 spin_unlock_irq (&dum->lock); 1742 return rc; 1743} 1744 1745/*-------------------------------------------------------------------------*/ 1746 1747static inline ssize_t 1748show_urb (char *buf, size_t size, struct urb *urb) 1749{ 1750 int ep = usb_pipeendpoint (urb->pipe); 1751 1752 return snprintf (buf, size, 1753 "urb/%p %s ep%d%s%s len %d/%d\n", 1754 urb, 1755 ({ char *s; 1756 switch (urb->dev->speed) { 1757 case USB_SPEED_LOW: s = "ls"; break; 1758 case USB_SPEED_FULL: s = "fs"; break; 1759 case USB_SPEED_HIGH: s = "hs"; break; 1760 default: s = "?"; break; 1761 }; s; }), 1762 ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "", 1763 ({ char *s; \ 1764 switch (usb_pipetype (urb->pipe)) { \ 1765 case PIPE_CONTROL: s = ""; break; \ 1766 case PIPE_BULK: s = "-bulk"; break; \ 1767 case PIPE_INTERRUPT: s = "-int"; break; \ 1768 default: s = "-iso"; break; \ 1769 }; s;}), 1770 urb->actual_length, urb->transfer_buffer_length); 1771} 1772 1773static ssize_t 1774show_urbs (struct device *dev, struct device_attribute *attr, char *buf) 1775{ 1776 struct usb_hcd *hcd = dev_get_drvdata (dev); 1777 struct dummy *dum = hcd_to_dummy (hcd); 1778 struct urbp *urbp; 1779 size_t size = 0; 1780 unsigned long flags; 1781 1782 spin_lock_irqsave (&dum->lock, flags); 1783 list_for_each_entry (urbp, &dum->urbp_list, urbp_list) { 1784 size_t temp; 1785 1786 temp = show_urb (buf, PAGE_SIZE - size, urbp->urb); 1787 buf += temp; 1788 size += temp; 1789 } 1790 spin_unlock_irqrestore (&dum->lock, flags); 1791 1792 return size; 1793} 1794static DEVICE_ATTR (urbs, S_IRUGO, show_urbs, NULL); 1795 1796static int dummy_start (struct usb_hcd *hcd) 1797{ 1798 struct dummy *dum; 1799 1800 dum = hcd_to_dummy (hcd); 1801 1802 /* 1803 * MASTER side init ... we emulate a root hub that'll only ever 1804 * talk to one device (the slave side). Also appears in sysfs, 1805 * just like more familiar pci-based HCDs. 1806 */ 1807 spin_lock_init (&dum->lock); 1808 init_timer (&dum->timer); 1809 dum->timer.function = dummy_timer; 1810 dum->timer.data = (unsigned long) dum; 1811 dum->rh_state = DUMMY_RH_RUNNING; 1812 1813 INIT_LIST_HEAD (&dum->urbp_list); 1814 1815 hcd->power_budget = POWER_BUDGET; 1816 hcd->state = HC_STATE_RUNNING; 1817 hcd->uses_new_polling = 1; 1818 1819#ifdef CONFIG_USB_OTG 1820 hcd->self.otg_port = 1; 1821#endif 1822 1823 /* FIXME 'urbs' should be a per-device thing, maybe in usbcore */ 1824 return device_create_file (dummy_dev(dum), &dev_attr_urbs); 1825} 1826 1827static void dummy_stop (struct usb_hcd *hcd) 1828{ 1829 struct dummy *dum; 1830 1831 dum = hcd_to_dummy (hcd); 1832 1833 device_remove_file (dummy_dev(dum), &dev_attr_urbs); 1834 usb_gadget_unregister_driver (dum->driver); 1835 dev_info (dummy_dev(dum), "stopped\n"); 1836} 1837 1838/*-------------------------------------------------------------------------*/ 1839 1840static int dummy_h_get_frame (struct usb_hcd *hcd) 1841{ 1842 return dummy_g_get_frame (NULL); 1843} 1844 1845static const struct hc_driver dummy_hcd = { 1846 .description = (char *) driver_name, 1847 .product_desc = "Dummy host controller", 1848 .hcd_priv_size = sizeof(struct dummy), 1849 1850 .flags = HCD_USB2, 1851 1852 .start = dummy_start, 1853 .stop = dummy_stop, 1854 1855 .urb_enqueue = dummy_urb_enqueue, 1856 .urb_dequeue = dummy_urb_dequeue, 1857 1858 .get_frame_number = dummy_h_get_frame, 1859 1860 .hub_status_data = dummy_hub_status, 1861 .hub_control = dummy_hub_control, 1862 .bus_suspend = dummy_bus_suspend, 1863 .bus_resume = dummy_bus_resume, 1864}; 1865 1866static int dummy_hcd_probe(struct platform_device *pdev) 1867{ 1868 struct usb_hcd *hcd; 1869 int retval; 1870 1871 dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc); 1872 1873 hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, pdev->dev.bus_id); 1874 if (!hcd) 1875 return -ENOMEM; 1876 the_controller = hcd_to_dummy (hcd); 1877 1878 retval = usb_add_hcd(hcd, 0, 0); 1879 if (retval != 0) { 1880 usb_put_hcd (hcd); 1881 the_controller = NULL; 1882 } 1883 return retval; 1884} 1885 1886static int dummy_hcd_remove (struct platform_device *pdev) 1887{ 1888 struct usb_hcd *hcd; 1889 1890 hcd = platform_get_drvdata (pdev); 1891 usb_remove_hcd (hcd); 1892 usb_put_hcd (hcd); 1893 the_controller = NULL; 1894 return 0; 1895} 1896 1897static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state) 1898{ 1899 struct usb_hcd *hcd; 1900 struct dummy *dum; 1901 int rc = 0; 1902 1903 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); 1904 1905 hcd = platform_get_drvdata (pdev); 1906 dum = hcd_to_dummy (hcd); 1907 if (dum->rh_state == DUMMY_RH_RUNNING) { 1908 dev_warn(&pdev->dev, "Root hub isn't suspended!\n"); 1909 rc = -EBUSY; 1910 } else 1911 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); 1912 return rc; 1913} 1914 1915static int dummy_hcd_resume (struct platform_device *pdev) 1916{ 1917 struct usb_hcd *hcd; 1918 1919 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); 1920 1921 hcd = platform_get_drvdata (pdev); 1922 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); 1923 usb_hcd_poll_rh_status (hcd); 1924 return 0; 1925} 1926 1927static struct platform_driver dummy_hcd_driver = { 1928 .probe = dummy_hcd_probe, 1929 .remove = dummy_hcd_remove, 1930 .suspend = dummy_hcd_suspend, 1931 .resume = dummy_hcd_resume, 1932 .driver = { 1933 .name = (char *) driver_name, 1934 .owner = THIS_MODULE, 1935 }, 1936}; 1937 1938/*-------------------------------------------------------------------------*/ 1939 1940/* These don't need to do anything because the pdev structures are 1941 * statically allocated. */ 1942static void 1943dummy_udc_release (struct device *dev) {} 1944 1945static void 1946dummy_hcd_release (struct device *dev) {} 1947 1948static struct platform_device the_udc_pdev = { 1949 .name = (char *) gadget_name, 1950 .id = -1, 1951 .dev = { 1952 .release = dummy_udc_release, 1953 }, 1954}; 1955 1956static struct platform_device the_hcd_pdev = { 1957 .name = (char *) driver_name, 1958 .id = -1, 1959 .dev = { 1960 .release = dummy_hcd_release, 1961 }, 1962}; 1963 1964static int __init init (void) 1965{ 1966 int retval; 1967 1968 if (usb_disabled ()) 1969 return -ENODEV; 1970 1971 retval = platform_driver_register (&dummy_hcd_driver); 1972 if (retval < 0) 1973 return retval; 1974 1975 retval = platform_driver_register (&dummy_udc_driver); 1976 if (retval < 0) 1977 goto err_register_udc_driver; 1978 1979 retval = platform_device_register (&the_hcd_pdev); 1980 if (retval < 0) 1981 goto err_register_hcd; 1982 1983 retval = platform_device_register (&the_udc_pdev); 1984 if (retval < 0) 1985 goto err_register_udc; 1986 return retval; 1987 1988err_register_udc: 1989 platform_device_unregister (&the_hcd_pdev); 1990err_register_hcd: 1991 platform_driver_unregister (&dummy_udc_driver); 1992err_register_udc_driver: 1993 platform_driver_unregister (&dummy_hcd_driver); 1994 return retval; 1995} 1996module_init (init); 1997 1998static void __exit cleanup (void) 1999{ 2000 platform_device_unregister (&the_udc_pdev); 2001 platform_device_unregister (&the_hcd_pdev); 2002 platform_driver_unregister (&dummy_udc_driver); 2003 platform_driver_unregister (&dummy_hcd_driver); 2004} 2005module_exit (cleanup); 2006