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