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#define DEBUG 38 39#include <linux/module.h> 40#include <linux/kernel.h> 41#include <linux/delay.h> 42#include <linux/ioport.h> 43#include <linux/slab.h> 44#include <linux/errno.h> 45#include <linux/init.h> 46#include <linux/timer.h> 47#include <linux/list.h> 48#include <linux/interrupt.h> 49#include <linux/platform_device.h> 50#include <linux/usb.h> 51#include <linux/usb_gadget.h> 52 53#include <asm/byteorder.h> 54#include <asm/io.h> 55#include <asm/irq.h> 56#include <asm/system.h> 57#include <asm/unaligned.h> 58 59 60#include "../core/hcd.h" 61 62 63#define DRIVER_DESC "USB Host+Gadget Emulator" 64#define DRIVER_VERSION "02 May 2005" 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 * 501dummy_alloc_buffer ( 502 struct usb_ep *_ep, 503 unsigned bytes, 504 dma_addr_t *dma, 505 gfp_t mem_flags 506) { 507 char *retval; 508 struct dummy_ep *ep; 509 struct dummy *dum; 510 511 ep = usb_ep_to_dummy_ep (_ep); 512 dum = ep_to_dummy (ep); 513 514 if (!dum->driver) 515 return NULL; 516 retval = kmalloc (bytes, mem_flags); 517 *dma = (dma_addr_t) retval; 518 return retval; 519} 520 521static void 522dummy_free_buffer ( 523 struct usb_ep *_ep, 524 void *buf, 525 dma_addr_t dma, 526 unsigned bytes 527) { 528 if (bytes) 529 kfree (buf); 530} 531 532static void 533fifo_complete (struct usb_ep *ep, struct usb_request *req) 534{ 535} 536 537static int 538dummy_queue (struct usb_ep *_ep, struct usb_request *_req, 539 gfp_t mem_flags) 540{ 541 struct dummy_ep *ep; 542 struct dummy_request *req; 543 struct dummy *dum; 544 unsigned long flags; 545 546 req = usb_request_to_dummy_request (_req); 547 if (!_req || !list_empty (&req->queue) || !_req->complete) 548 return -EINVAL; 549 550 ep = usb_ep_to_dummy_ep (_ep); 551 if (!_ep || (!ep->desc && _ep->name != ep0name)) 552 return -EINVAL; 553 554 dum = ep_to_dummy (ep); 555 if (!dum->driver || !is_enabled (dum)) 556 return -ESHUTDOWN; 557 558 559 _req->status = -EINPROGRESS; 560 _req->actual = 0; 561 spin_lock_irqsave (&dum->lock, flags); 562 563 /* implement an emulated single-request FIFO */ 564 if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) && 565 list_empty (&dum->fifo_req.queue) && 566 list_empty (&ep->queue) && 567 _req->length <= FIFO_SIZE) { 568 req = &dum->fifo_req; 569 req->req = *_req; 570 req->req.buf = dum->fifo_buf; 571 memcpy (dum->fifo_buf, _req->buf, _req->length); 572 req->req.context = dum; 573 req->req.complete = fifo_complete; 574 575 spin_unlock (&dum->lock); 576 _req->actual = _req->length; 577 _req->status = 0; 578 _req->complete (_ep, _req); 579 spin_lock (&dum->lock); 580 } 581 list_add_tail (&req->queue, &ep->queue); 582 spin_unlock_irqrestore (&dum->lock, flags); 583 584 /* real hardware would likely enable transfers here, in case 585 * it'd been left NAKing. 586 */ 587 return 0; 588} 589 590static int dummy_dequeue (struct usb_ep *_ep, struct usb_request *_req) 591{ 592 struct dummy_ep *ep; 593 struct dummy *dum; 594 int retval = -EINVAL; 595 unsigned long flags; 596 struct dummy_request *req = NULL; 597 598 if (!_ep || !_req) 599 return retval; 600 ep = usb_ep_to_dummy_ep (_ep); 601 dum = ep_to_dummy (ep); 602 603 if (!dum->driver) 604 return -ESHUTDOWN; 605 606 local_irq_save (flags); 607 spin_lock (&dum->lock); 608 list_for_each_entry (req, &ep->queue, queue) { 609 if (&req->req == _req) { 610 list_del_init (&req->queue); 611 _req->status = -ECONNRESET; 612 retval = 0; 613 break; 614 } 615 } 616 spin_unlock (&dum->lock); 617 618 if (retval == 0) { 619 dev_dbg (udc_dev(dum), 620 "dequeued req %p from %s, len %d buf %p\n", 621 req, _ep->name, _req->length, _req->buf); 622 _req->complete (_ep, _req); 623 } 624 local_irq_restore (flags); 625 return retval; 626} 627 628static int 629dummy_set_halt (struct usb_ep *_ep, int value) 630{ 631 struct dummy_ep *ep; 632 struct dummy *dum; 633 634 if (!_ep) 635 return -EINVAL; 636 ep = usb_ep_to_dummy_ep (_ep); 637 dum = ep_to_dummy (ep); 638 if (!dum->driver) 639 return -ESHUTDOWN; 640 if (!value) 641 ep->halted = 0; 642 else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) && 643 !list_empty (&ep->queue)) 644 return -EAGAIN; 645 else 646 ep->halted = 1; 647 return 0; 648} 649 650static const struct usb_ep_ops dummy_ep_ops = { 651 .enable = dummy_enable, 652 .disable = dummy_disable, 653 654 .alloc_request = dummy_alloc_request, 655 .free_request = dummy_free_request, 656 657 .alloc_buffer = dummy_alloc_buffer, 658 .free_buffer = dummy_free_buffer, 659 /* map, unmap, ... eventually hook the "generic" dma calls */ 660 661 .queue = dummy_queue, 662 .dequeue = dummy_dequeue, 663 664 .set_halt = dummy_set_halt, 665}; 666 667/*-------------------------------------------------------------------------*/ 668 669/* there are both host and device side versions of this call ... */ 670static int dummy_g_get_frame (struct usb_gadget *_gadget) 671{ 672 struct timeval tv; 673 674 do_gettimeofday (&tv); 675 return tv.tv_usec / 1000; 676} 677 678static int dummy_wakeup (struct usb_gadget *_gadget) 679{ 680 struct dummy *dum; 681 682 dum = gadget_to_dummy (_gadget); 683 if (!(dum->devstatus & ( (1 << USB_DEVICE_B_HNP_ENABLE) 684 | (1 << USB_DEVICE_REMOTE_WAKEUP)))) 685 return -EINVAL; 686 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0) 687 return -ENOLINK; 688 if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 && 689 dum->rh_state != DUMMY_RH_SUSPENDED) 690 return -EIO; 691 692 693 /* hub notices our request, issues downstream resume, etc */ 694 dum->resuming = 1; 695 dum->re_timeout = jiffies + msecs_to_jiffies(20); 696 mod_timer (&dummy_to_hcd (dum)->rh_timer, dum->re_timeout); 697 return 0; 698} 699 700static int dummy_set_selfpowered (struct usb_gadget *_gadget, int value) 701{ 702 struct dummy *dum; 703 704 dum = gadget_to_dummy (_gadget); 705 if (value) 706 dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED); 707 else 708 dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED); 709 return 0; 710} 711 712static int dummy_pullup (struct usb_gadget *_gadget, int value) 713{ 714 struct dummy *dum; 715 unsigned long flags; 716 717 dum = gadget_to_dummy (_gadget); 718 spin_lock_irqsave (&dum->lock, flags); 719 dum->pullup = (value != 0); 720 set_link_state (dum); 721 spin_unlock_irqrestore (&dum->lock, flags); 722 723 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 724 return 0; 725} 726 727static const struct usb_gadget_ops dummy_ops = { 728 .get_frame = dummy_g_get_frame, 729 .wakeup = dummy_wakeup, 730 .set_selfpowered = dummy_set_selfpowered, 731 .pullup = dummy_pullup, 732}; 733 734/*-------------------------------------------------------------------------*/ 735 736/* "function" sysfs attribute */ 737static ssize_t 738show_function (struct device *dev, struct device_attribute *attr, char *buf) 739{ 740 struct dummy *dum = gadget_dev_to_dummy (dev); 741 742 if (!dum->driver || !dum->driver->function) 743 return 0; 744 return scnprintf (buf, PAGE_SIZE, "%s\n", dum->driver->function); 745} 746static DEVICE_ATTR (function, S_IRUGO, show_function, NULL); 747 748/*-------------------------------------------------------------------------*/ 749 750/* 751 * Driver registration/unregistration. 752 * 753 * This is basically hardware-specific; there's usually only one real USB 754 * device (not host) controller since that's how USB devices are intended 755 * to work. So most implementations of these api calls will rely on the 756 * fact that only one driver will ever bind to the hardware. But curious 757 * hardware can be built with discrete components, so the gadget API doesn't 758 * require that assumption. 759 * 760 * For this emulator, it might be convenient to create a usb slave device 761 * for each driver that registers: just add to a big root hub. 762 */ 763 764int 765usb_gadget_register_driver (struct usb_gadget_driver *driver) 766{ 767 struct dummy *dum = the_controller; 768 int retval, i; 769 770 if (!dum) 771 return -EINVAL; 772 if (dum->driver) 773 return -EBUSY; 774 if (!driver->bind || !driver->setup 775 || driver->speed == USB_SPEED_UNKNOWN) 776 return -EINVAL; 777 778 /* 779 * SLAVE side init ... the layer above hardware, which 780 * can't enumerate without help from the driver we're binding. 781 */ 782 783 dum->devstatus = 0; 784 785 INIT_LIST_HEAD (&dum->gadget.ep_list); 786 for (i = 0; i < DUMMY_ENDPOINTS; i++) { 787 struct dummy_ep *ep = &dum->ep [i]; 788 789 if (!ep_name [i]) 790 break; 791 ep->ep.name = ep_name [i]; 792 ep->ep.ops = &dummy_ep_ops; 793 list_add_tail (&ep->ep.ep_list, &dum->gadget.ep_list); 794 ep->halted = ep->already_seen = ep->setup_stage = 0; 795 ep->ep.maxpacket = ~0; 796 ep->last_io = jiffies; 797 ep->gadget = &dum->gadget; 798 ep->desc = NULL; 799 INIT_LIST_HEAD (&ep->queue); 800 } 801 802 dum->gadget.ep0 = &dum->ep [0].ep; 803 dum->ep [0].ep.maxpacket = 64; 804 list_del_init (&dum->ep [0].ep.ep_list); 805 INIT_LIST_HEAD(&dum->fifo_req.queue); 806 807 dum->driver = driver; 808 dum->gadget.dev.driver = &driver->driver; 809 dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n", 810 driver->driver.name); 811 if ((retval = driver->bind (&dum->gadget)) != 0) 812 goto err_bind_gadget; 813 814 driver->driver.bus = dum->gadget.dev.parent->bus; 815 if ((retval = driver_register (&driver->driver)) != 0) 816 goto err_register; 817 if ((retval = device_bind_driver (&dum->gadget.dev)) != 0) 818 goto err_bind_driver; 819 820 /* khubd will enumerate this in a while */ 821 spin_lock_irq (&dum->lock); 822 dum->pullup = 1; 823 set_link_state (dum); 824 spin_unlock_irq (&dum->lock); 825 826 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 827 return 0; 828 829err_bind_driver: 830 driver_unregister (&driver->driver); 831err_register: 832 if (driver->unbind) 833 driver->unbind (&dum->gadget); 834 spin_lock_irq (&dum->lock); 835 dum->pullup = 0; 836 set_link_state (dum); 837 spin_unlock_irq (&dum->lock); 838err_bind_gadget: 839 dum->driver = NULL; 840 dum->gadget.dev.driver = NULL; 841 return retval; 842} 843EXPORT_SYMBOL (usb_gadget_register_driver); 844 845int 846usb_gadget_unregister_driver (struct usb_gadget_driver *driver) 847{ 848 struct dummy *dum = the_controller; 849 unsigned long flags; 850 851 if (!dum) 852 return -ENODEV; 853 if (!driver || driver != dum->driver || !driver->unbind) 854 return -EINVAL; 855 856 dev_dbg (udc_dev(dum), "unregister gadget driver '%s'\n", 857 driver->driver.name); 858 859 spin_lock_irqsave (&dum->lock, flags); 860 dum->pullup = 0; 861 set_link_state (dum); 862 spin_unlock_irqrestore (&dum->lock, flags); 863 864 driver->unbind (&dum->gadget); 865 dum->driver = NULL; 866 867 device_release_driver (&dum->gadget.dev); 868 driver_unregister (&driver->driver); 869 870 spin_lock_irqsave (&dum->lock, flags); 871 dum->pullup = 0; 872 set_link_state (dum); 873 spin_unlock_irqrestore (&dum->lock, flags); 874 875 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 876 return 0; 877} 878EXPORT_SYMBOL (usb_gadget_unregister_driver); 879 880#undef is_enabled 881 882/* just declare this in any driver that really need it */ 883extern int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode); 884 885int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode) 886{ 887 return -ENOSYS; 888} 889EXPORT_SYMBOL (net2280_set_fifo_mode); 890 891 892/* The gadget structure is stored inside the hcd structure and will be 893 * released along with it. */ 894static void 895dummy_gadget_release (struct device *dev) 896{ 897 struct dummy *dum = gadget_dev_to_dummy (dev); 898 899 usb_put_hcd (dummy_to_hcd (dum)); 900} 901 902static int dummy_udc_probe (struct platform_device *pdev) 903{ 904 struct dummy *dum = the_controller; 905 int rc; 906 907 dum->gadget.name = gadget_name; 908 dum->gadget.ops = &dummy_ops; 909 dum->gadget.is_dualspeed = 1; 910 911 /* maybe claim OTG support, though we won't complete HNP */ 912 dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0); 913 914 strcpy (dum->gadget.dev.bus_id, "gadget"); 915 dum->gadget.dev.parent = &pdev->dev; 916 dum->gadget.dev.release = dummy_gadget_release; 917 rc = device_register (&dum->gadget.dev); 918 if (rc < 0) 919 return rc; 920 921 usb_get_hcd (dummy_to_hcd (dum)); 922 923 platform_set_drvdata (pdev, dum); 924 rc = device_create_file (&dum->gadget.dev, &dev_attr_function); 925 if (rc < 0) 926 device_unregister (&dum->gadget.dev); 927 return rc; 928} 929 930static int dummy_udc_remove (struct platform_device *pdev) 931{ 932 struct dummy *dum = platform_get_drvdata (pdev); 933 934 platform_set_drvdata (pdev, NULL); 935 device_remove_file (&dum->gadget.dev, &dev_attr_function); 936 device_unregister (&dum->gadget.dev); 937 return 0; 938} 939 940static int dummy_udc_suspend (struct platform_device *pdev, pm_message_t state) 941{ 942 struct dummy *dum = platform_get_drvdata(pdev); 943 944 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); 945 spin_lock_irq (&dum->lock); 946 dum->udc_suspended = 1; 947 set_link_state (dum); 948 spin_unlock_irq (&dum->lock); 949 950 pdev->dev.power.power_state = state; 951 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 952 return 0; 953} 954 955static int dummy_udc_resume (struct platform_device *pdev) 956{ 957 struct dummy *dum = platform_get_drvdata(pdev); 958 959 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); 960 spin_lock_irq (&dum->lock); 961 dum->udc_suspended = 0; 962 set_link_state (dum); 963 spin_unlock_irq (&dum->lock); 964 965 pdev->dev.power.power_state = PMSG_ON; 966 usb_hcd_poll_rh_status (dummy_to_hcd (dum)); 967 return 0; 968} 969 970static struct platform_driver dummy_udc_driver = { 971 .probe = dummy_udc_probe, 972 .remove = dummy_udc_remove, 973 .suspend = dummy_udc_suspend, 974 .resume = dummy_udc_resume, 975 .driver = { 976 .name = (char *) gadget_name, 977 .owner = THIS_MODULE, 978 }, 979}; 980 981/*-------------------------------------------------------------------------*/ 982 983/* MASTER/HOST SIDE DRIVER 984 * 985 * this uses the hcd framework to hook up to host side drivers. 986 * its root hub will only have one device, otherwise it acts like 987 * a normal host controller. 988 * 989 * when urbs are queued, they're just stuck on a list that we 990 * scan in a timer callback. that callback connects writes from 991 * the host with reads from the device, and so on, based on the 992 * usb 2.0 rules. 993 */ 994 995static int dummy_urb_enqueue ( 996 struct usb_hcd *hcd, 997 struct usb_host_endpoint *ep, 998 struct urb *urb, 999 gfp_t mem_flags 1000) { 1001 struct dummy *dum; 1002 struct urbp *urbp; 1003 unsigned long flags; 1004 1005 if (!urb->transfer_buffer && urb->transfer_buffer_length) 1006 return -EINVAL; 1007 1008 urbp = kmalloc (sizeof *urbp, mem_flags); 1009 if (!urbp) 1010 return -ENOMEM; 1011 urbp->urb = urb; 1012 1013 dum = hcd_to_dummy (hcd); 1014 spin_lock_irqsave (&dum->lock, flags); 1015 1016 if (!dum->udev) { 1017 dum->udev = urb->dev; 1018 usb_get_dev (dum->udev); 1019 } else if (unlikely (dum->udev != urb->dev)) 1020 dev_err (dummy_dev(dum), "usb_device address has changed!\n"); 1021 1022 list_add_tail (&urbp->urbp_list, &dum->urbp_list); 1023 urb->hcpriv = urbp; 1024 if (usb_pipetype (urb->pipe) == PIPE_CONTROL) 1025 urb->error_count = 1; /* mark as a new urb */ 1026 1027 /* kick the scheduler, it'll do the rest */ 1028 if (!timer_pending (&dum->timer)) 1029 mod_timer (&dum->timer, jiffies + 1); 1030 1031 spin_unlock_irqrestore (&dum->lock, flags); 1032 return 0; 1033} 1034 1035static int dummy_urb_dequeue (struct usb_hcd *hcd, struct urb *urb) 1036{ 1037 struct dummy *dum; 1038 unsigned long flags; 1039 1040 /* giveback happens automatically in timer callback, 1041 * so make sure the callback happens */ 1042 dum = hcd_to_dummy (hcd); 1043 spin_lock_irqsave (&dum->lock, flags); 1044 if (dum->rh_state != DUMMY_RH_RUNNING && !list_empty(&dum->urbp_list)) 1045 mod_timer (&dum->timer, jiffies); 1046 spin_unlock_irqrestore (&dum->lock, flags); 1047 return 0; 1048} 1049 1050static void maybe_set_status (struct urb *urb, int status) 1051{ 1052 spin_lock (&urb->lock); 1053 if (urb->status == -EINPROGRESS) 1054 urb->status = status; 1055 spin_unlock (&urb->lock); 1056} 1057 1058/* transfer up to a frame's worth; caller must own lock */ 1059static int 1060transfer (struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit) 1061{ 1062 struct dummy_request *req; 1063 1064top: 1065 /* if there's no request queued, the device is NAKing; return */ 1066 list_for_each_entry (req, &ep->queue, queue) { 1067 unsigned host_len, dev_len, len; 1068 int is_short, to_host; 1069 int rescan = 0; 1070 1071 /* 1..N packets of ep->ep.maxpacket each ... the last one 1072 * may be short (including zero length). 1073 * 1074 * writer can send a zlp explicitly (length 0) or implicitly 1075 * (length mod maxpacket zero, and 'zero' flag); they always 1076 * terminate reads. 1077 */ 1078 host_len = urb->transfer_buffer_length - urb->actual_length; 1079 dev_len = req->req.length - req->req.actual; 1080 len = min (host_len, dev_len); 1081 1082 1083 to_host = usb_pipein (urb->pipe); 1084 if (unlikely (len == 0)) 1085 is_short = 1; 1086 else { 1087 char *ubuf, *rbuf; 1088 1089 /* not enough bandwidth left? */ 1090 if (limit < ep->ep.maxpacket && limit < len) 1091 break; 1092 len = min (len, (unsigned) limit); 1093 if (len == 0) 1094 break; 1095 1096 /* use an extra pass for the final short packet */ 1097 if (len > ep->ep.maxpacket) { 1098 rescan = 1; 1099 len -= (len % ep->ep.maxpacket); 1100 } 1101 is_short = (len % ep->ep.maxpacket) != 0; 1102 1103 /* else transfer packet(s) */ 1104 ubuf = urb->transfer_buffer + urb->actual_length; 1105 rbuf = req->req.buf + req->req.actual; 1106 if (to_host) 1107 memcpy (ubuf, rbuf, len); 1108 else 1109 memcpy (rbuf, ubuf, len); 1110 ep->last_io = jiffies; 1111 1112 limit -= len; 1113 urb->actual_length += len; 1114 req->req.actual += len; 1115 } 1116 1117 /* short packets terminate, maybe with overflow/underflow. 1118 * it's only really an error to write too much. 1119 * 1120 * partially filling a buffer optionally blocks queue advances 1121 * (so completion handlers can clean up the queue) but we don't 1122 * need to emulate such data-in-flight. so we only show part 1123 * of the URB_SHORT_NOT_OK effect: completion status. 1124 */ 1125 if (is_short) { 1126 if (host_len == dev_len) { 1127 req->req.status = 0; 1128 maybe_set_status (urb, 0); 1129 } else if (to_host) { 1130 req->req.status = 0; 1131 if (dev_len > host_len) 1132 maybe_set_status (urb, -EOVERFLOW); 1133 else 1134 maybe_set_status (urb, 1135 (urb->transfer_flags 1136 & URB_SHORT_NOT_OK) 1137 ? -EREMOTEIO : 0); 1138 } else if (!to_host) { 1139 maybe_set_status (urb, 0); 1140 if (host_len > dev_len) 1141 req->req.status = -EOVERFLOW; 1142 else 1143 req->req.status = 0; 1144 } 1145 1146 /* many requests terminate without a short packet */ 1147 } else { 1148 if (req->req.length == req->req.actual 1149 && !req->req.zero) 1150 req->req.status = 0; 1151 if (urb->transfer_buffer_length == urb->actual_length 1152 && !(urb->transfer_flags 1153 & URB_ZERO_PACKET)) { 1154 maybe_set_status (urb, 0); 1155 } 1156 } 1157 1158 /* device side completion --> continuable */ 1159 if (req->req.status != -EINPROGRESS) { 1160 list_del_init (&req->queue); 1161 1162 spin_unlock (&dum->lock); 1163 req->req.complete (&ep->ep, &req->req); 1164 spin_lock (&dum->lock); 1165 1166 /* requests might have been unlinked... */ 1167 rescan = 1; 1168 } 1169 1170 /* host side completion --> terminate */ 1171 if (urb->status != -EINPROGRESS) 1172 break; 1173 1174 /* rescan to continue with any other queued i/o */ 1175 if (rescan) 1176 goto top; 1177 } 1178 return limit; 1179} 1180 1181static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep) 1182{ 1183 int limit = ep->ep.maxpacket; 1184 1185 if (dum->gadget.speed == USB_SPEED_HIGH) { 1186 int tmp; 1187 1188 /* high bandwidth mode */ 1189 tmp = le16_to_cpu(ep->desc->wMaxPacketSize); 1190 tmp = (tmp >> 11) & 0x03; 1191 tmp *= 8 /* applies to entire frame */; 1192 limit += limit * tmp; 1193 } 1194 return limit; 1195} 1196 1197#define is_active(dum) ((dum->port_status & \ 1198 (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE | \ 1199 USB_PORT_STAT_SUSPEND)) \ 1200 == (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE)) 1201 1202static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address) 1203{ 1204 int i; 1205 1206 if (!is_active (dum)) 1207 return NULL; 1208 if ((address & ~USB_DIR_IN) == 0) 1209 return &dum->ep [0]; 1210 for (i = 1; i < DUMMY_ENDPOINTS; i++) { 1211 struct dummy_ep *ep = &dum->ep [i]; 1212 1213 if (!ep->desc) 1214 continue; 1215 if (ep->desc->bEndpointAddress == address) 1216 return ep; 1217 } 1218 return NULL; 1219} 1220 1221#undef is_active 1222 1223#define Dev_Request (USB_TYPE_STANDARD | USB_RECIP_DEVICE) 1224#define Dev_InRequest (Dev_Request | USB_DIR_IN) 1225#define Intf_Request (USB_TYPE_STANDARD | USB_RECIP_INTERFACE) 1226#define Intf_InRequest (Intf_Request | USB_DIR_IN) 1227#define Ep_Request (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT) 1228#define Ep_InRequest (Ep_Request | USB_DIR_IN) 1229 1230/* drive both sides of the transfers; looks like irq handlers to 1231 * both drivers except the callbacks aren't in_irq(). 1232 */ 1233static void dummy_timer (unsigned long _dum) 1234{ 1235 struct dummy *dum = (struct dummy *) _dum; 1236 struct urbp *urbp, *tmp; 1237 unsigned long flags; 1238 int limit, total; 1239 int i; 1240 1241 /* simplistic model for one frame's bandwidth */ 1242 switch (dum->gadget.speed) { 1243 case USB_SPEED_LOW: 1244 total = 8/*bytes*/ * 12/*packets*/; 1245 break; 1246 case USB_SPEED_FULL: 1247 total = 64/*bytes*/ * 19/*packets*/; 1248 break; 1249 case USB_SPEED_HIGH: 1250 total = 512/*bytes*/ * 13/*packets*/ * 8/*uframes*/; 1251 break; 1252 default: 1253 dev_err (dummy_dev(dum), "bogus device speed\n"); 1254 return; 1255 } 1256 1257 1258 /* look at each urb queued by the host side driver */ 1259 spin_lock_irqsave (&dum->lock, flags); 1260 1261 if (!dum->udev) { 1262 dev_err (dummy_dev(dum), 1263 "timer fired with no URBs pending?\n"); 1264 spin_unlock_irqrestore (&dum->lock, flags); 1265 return; 1266 } 1267 1268 for (i = 0; i < DUMMY_ENDPOINTS; i++) { 1269 if (!ep_name [i]) 1270 break; 1271 dum->ep [i].already_seen = 0; 1272 } 1273 1274restart: 1275 list_for_each_entry_safe (urbp, tmp, &dum->urbp_list, urbp_list) { 1276 struct urb *urb; 1277 struct dummy_request *req; 1278 u8 address; 1279 struct dummy_ep *ep = NULL; 1280 int type; 1281 1282 urb = urbp->urb; 1283 if (urb->status != -EINPROGRESS) { 1284 /* likely it was just unlinked */ 1285 goto return_urb; 1286 } else if (dum->rh_state != DUMMY_RH_RUNNING) 1287 continue; 1288 type = usb_pipetype (urb->pipe); 1289 1290 if (total <= 0 && type == PIPE_BULK) 1291 continue; 1292 1293 /* find the gadget's ep for this request (if configured) */ 1294 address = usb_pipeendpoint (urb->pipe); 1295 if (usb_pipein (urb->pipe)) 1296 address |= USB_DIR_IN; 1297 ep = find_endpoint(dum, address); 1298 if (!ep) { 1299 /* set_configuration() disagreement */ 1300 dev_dbg (dummy_dev(dum), 1301 "no ep configured for urb %p\n", 1302 urb); 1303 maybe_set_status (urb, -EPROTO); 1304 goto return_urb; 1305 } 1306 1307 if (ep->already_seen) 1308 continue; 1309 ep->already_seen = 1; 1310 if (ep == &dum->ep [0] && urb->error_count) { 1311 ep->setup_stage = 1; /* a new urb */ 1312 urb->error_count = 0; 1313 } 1314 if (ep->halted && !ep->setup_stage) { 1315 /* NOTE: must not be iso! */ 1316 dev_dbg (dummy_dev(dum), "ep %s halted, urb %p\n", 1317 ep->ep.name, urb); 1318 maybe_set_status (urb, -EPIPE); 1319 goto return_urb; 1320 } 1321 1322 /* handle control requests */ 1323 if (ep == &dum->ep [0] && ep->setup_stage) { 1324 struct usb_ctrlrequest setup; 1325 int value = 1; 1326 struct dummy_ep *ep2; 1327 unsigned w_index; 1328 unsigned w_value; 1329 1330 setup = *(struct usb_ctrlrequest*) urb->setup_packet; 1331 w_index = le16_to_cpu(setup.wIndex); 1332 w_value = le16_to_cpu(setup.wValue); 1333 if (le16_to_cpu(setup.wLength) != 1334 urb->transfer_buffer_length) { 1335 maybe_set_status (urb, -EOVERFLOW); 1336 goto return_urb; 1337 } 1338 1339 /* paranoia, in case of stale queued data */ 1340 list_for_each_entry (req, &ep->queue, queue) { 1341 list_del_init (&req->queue); 1342 req->req.status = -EOVERFLOW; 1343 dev_dbg (udc_dev(dum), "stale req = %p\n", 1344 req); 1345 1346 spin_unlock (&dum->lock); 1347 req->req.complete (&ep->ep, &req->req); 1348 spin_lock (&dum->lock); 1349 ep->already_seen = 0; 1350 goto restart; 1351 } 1352 1353 /* gadget driver never sees set_address or operations 1354 * on standard feature flags. some hardware doesn't 1355 * even expose them. 1356 */ 1357 ep->last_io = jiffies; 1358 ep->setup_stage = 0; 1359 ep->halted = 0; 1360 switch (setup.bRequest) { 1361 case USB_REQ_SET_ADDRESS: 1362 if (setup.bRequestType != Dev_Request) 1363 break; 1364 dum->address = w_value; 1365 maybe_set_status (urb, 0); 1366 dev_dbg (udc_dev(dum), "set_address = %d\n", 1367 w_value); 1368 value = 0; 1369 break; 1370 case USB_REQ_SET_FEATURE: 1371 if (setup.bRequestType == Dev_Request) { 1372 value = 0; 1373 switch (w_value) { 1374 case USB_DEVICE_REMOTE_WAKEUP: 1375 break; 1376 case USB_DEVICE_B_HNP_ENABLE: 1377 dum->gadget.b_hnp_enable = 1; 1378 break; 1379 case USB_DEVICE_A_HNP_SUPPORT: 1380 dum->gadget.a_hnp_support = 1; 1381 break; 1382 case USB_DEVICE_A_ALT_HNP_SUPPORT: 1383 dum->gadget.a_alt_hnp_support 1384 = 1; 1385 break; 1386 default: 1387 value = -EOPNOTSUPP; 1388 } 1389 if (value == 0) { 1390 dum->devstatus |= 1391 (1 << w_value); 1392 maybe_set_status (urb, 0); 1393 } 1394 1395 } else if (setup.bRequestType == Ep_Request) { 1396 // endpoint halt 1397 ep2 = find_endpoint (dum, w_index); 1398 if (!ep2) { 1399 value = -EOPNOTSUPP; 1400 break; 1401 } 1402 ep2->halted = 1; 1403 value = 0; 1404 maybe_set_status (urb, 0); 1405 } 1406 break; 1407 case USB_REQ_CLEAR_FEATURE: 1408 if (setup.bRequestType == Dev_Request) { 1409 switch (w_value) { 1410 case USB_DEVICE_REMOTE_WAKEUP: 1411 dum->devstatus &= ~(1 << 1412 USB_DEVICE_REMOTE_WAKEUP); 1413 value = 0; 1414 maybe_set_status (urb, 0); 1415 break; 1416 default: 1417 value = -EOPNOTSUPP; 1418 break; 1419 } 1420 } else if (setup.bRequestType == Ep_Request) { 1421 // endpoint halt 1422 ep2 = find_endpoint (dum, w_index); 1423 if (!ep2) { 1424 value = -EOPNOTSUPP; 1425 break; 1426 } 1427 ep2->halted = 0; 1428 value = 0; 1429 maybe_set_status (urb, 0); 1430 } 1431 break; 1432 case USB_REQ_GET_STATUS: 1433 if (setup.bRequestType == Dev_InRequest 1434 || setup.bRequestType 1435 == Intf_InRequest 1436 || setup.bRequestType 1437 == Ep_InRequest 1438 ) { 1439 char *buf; 1440 1441 // device: remote wakeup, selfpowered 1442 // interface: nothing 1443 // endpoint: halt 1444 buf = (char *)urb->transfer_buffer; 1445 if (urb->transfer_buffer_length > 0) { 1446 if (setup.bRequestType == 1447 Ep_InRequest) { 1448 ep2 = find_endpoint (dum, w_index); 1449 if (!ep2) { 1450 value = -EOPNOTSUPP; 1451 break; 1452 } 1453 buf [0] = ep2->halted; 1454 } else if (setup.bRequestType == 1455 Dev_InRequest) { 1456 buf [0] = (u8) 1457 dum->devstatus; 1458 } else 1459 buf [0] = 0; 1460 } 1461 if (urb->transfer_buffer_length > 1) 1462 buf [1] = 0; 1463 urb->actual_length = min (2, 1464 urb->transfer_buffer_length); 1465 value = 0; 1466 maybe_set_status (urb, 0); 1467 } 1468 break; 1469 } 1470 1471 /* gadget driver handles all other requests. block 1472 * until setup() returns; no reentrancy issues etc. 1473 */ 1474 if (value > 0) { 1475 spin_unlock (&dum->lock); 1476 value = dum->driver->setup (&dum->gadget, 1477 &setup); 1478 spin_lock (&dum->lock); 1479 1480 if (value >= 0) { 1481 /* no delays (max 64KB data stage) */ 1482 limit = 64*1024; 1483 goto treat_control_like_bulk; 1484 } 1485 /* error, see below */ 1486 } 1487 1488 if (value < 0) { 1489 if (value != -EOPNOTSUPP) 1490 dev_dbg (udc_dev(dum), 1491 "setup --> %d\n", 1492 value); 1493 maybe_set_status (urb, -EPIPE); 1494 urb->actual_length = 0; 1495 } 1496 1497 goto return_urb; 1498 } 1499 1500 /* non-control requests */ 1501 limit = total; 1502 switch (usb_pipetype (urb->pipe)) { 1503 case PIPE_ISOCHRONOUS: 1504 limit = max (limit, periodic_bytes (dum, ep)); 1505 maybe_set_status (urb, -ENOSYS); 1506 break; 1507 1508 case PIPE_INTERRUPT: 1509 limit = max (limit, periodic_bytes (dum, ep)); 1510 /* FALLTHROUGH */ 1511 1512 // case PIPE_BULK: case PIPE_CONTROL: 1513 default: 1514 treat_control_like_bulk: 1515 ep->last_io = jiffies; 1516 total = transfer (dum, urb, ep, limit); 1517 break; 1518 } 1519 1520 /* incomplete transfer? */ 1521 if (urb->status == -EINPROGRESS) 1522 continue; 1523 1524return_urb: 1525 urb->hcpriv = NULL; 1526 list_del (&urbp->urbp_list); 1527 kfree (urbp); 1528 if (ep) 1529 ep->already_seen = ep->setup_stage = 0; 1530 1531 spin_unlock (&dum->lock); 1532 usb_hcd_giveback_urb (dummy_to_hcd(dum), urb); 1533 spin_lock (&dum->lock); 1534 1535 goto restart; 1536 } 1537 1538 if (list_empty (&dum->urbp_list)) { 1539 usb_put_dev (dum->udev); 1540 dum->udev = NULL; 1541 } else if (dum->rh_state == DUMMY_RH_RUNNING) { 1542 /* want a 1 msec delay here */ 1543 mod_timer (&dum->timer, jiffies + msecs_to_jiffies(1)); 1544 } 1545 1546 spin_unlock_irqrestore (&dum->lock, flags); 1547} 1548 1549/*-------------------------------------------------------------------------*/ 1550 1551#define PORT_C_MASK \ 1552 ((USB_PORT_STAT_C_CONNECTION \ 1553 | USB_PORT_STAT_C_ENABLE \ 1554 | USB_PORT_STAT_C_SUSPEND \ 1555 | USB_PORT_STAT_C_OVERCURRENT \ 1556 | USB_PORT_STAT_C_RESET) << 16) 1557 1558static int dummy_hub_status (struct usb_hcd *hcd, char *buf) 1559{ 1560 struct dummy *dum; 1561 unsigned long flags; 1562 int retval = 0; 1563 1564 dum = hcd_to_dummy (hcd); 1565 1566 spin_lock_irqsave (&dum->lock, flags); 1567 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) 1568 goto done; 1569 1570 if (dum->resuming && time_after_eq (jiffies, dum->re_timeout)) { 1571 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16); 1572 dum->port_status &= ~USB_PORT_STAT_SUSPEND; 1573 set_link_state (dum); 1574 } 1575 1576 if ((dum->port_status & PORT_C_MASK) != 0) { 1577 *buf = (1 << 1); 1578 dev_dbg (dummy_dev(dum), "port status 0x%08x has changes\n", 1579 dum->port_status); 1580 retval = 1; 1581 if (dum->rh_state == DUMMY_RH_SUSPENDED) 1582 usb_hcd_resume_root_hub (hcd); 1583 } 1584done: 1585 spin_unlock_irqrestore (&dum->lock, flags); 1586 return retval; 1587} 1588 1589static inline void 1590hub_descriptor (struct usb_hub_descriptor *desc) 1591{ 1592 memset (desc, 0, sizeof *desc); 1593 desc->bDescriptorType = 0x29; 1594 desc->bDescLength = 9; 1595 desc->wHubCharacteristics = (__force __u16) 1596 (__constant_cpu_to_le16 (0x0001)); 1597 desc->bNbrPorts = 1; 1598 desc->bitmap [0] = 0xff; 1599 desc->bitmap [1] = 0xff; 1600} 1601 1602static int dummy_hub_control ( 1603 struct usb_hcd *hcd, 1604 u16 typeReq, 1605 u16 wValue, 1606 u16 wIndex, 1607 char *buf, 1608 u16 wLength 1609) { 1610 struct dummy *dum; 1611 int retval = 0; 1612 unsigned long flags; 1613 1614 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) 1615 return -ETIMEDOUT; 1616 1617 dum = hcd_to_dummy (hcd); 1618 spin_lock_irqsave (&dum->lock, flags); 1619 switch (typeReq) { 1620 case ClearHubFeature: 1621 break; 1622 case ClearPortFeature: 1623 switch (wValue) { 1624 case USB_PORT_FEAT_SUSPEND: 1625 if (dum->port_status & USB_PORT_STAT_SUSPEND) { 1626 /* 20msec resume signaling */ 1627 dum->resuming = 1; 1628 dum->re_timeout = jiffies + 1629 msecs_to_jiffies(20); 1630 } 1631 break; 1632 case USB_PORT_FEAT_POWER: 1633 if (dum->port_status & USB_PORT_STAT_POWER) 1634 dev_dbg (dummy_dev(dum), "power-off\n"); 1635 /* FALLS THROUGH */ 1636 default: 1637 dum->port_status &= ~(1 << wValue); 1638 set_link_state (dum); 1639 } 1640 break; 1641 case GetHubDescriptor: 1642 hub_descriptor ((struct usb_hub_descriptor *) buf); 1643 break; 1644 case GetHubStatus: 1645 *(__le32 *) buf = __constant_cpu_to_le32 (0); 1646 break; 1647 case GetPortStatus: 1648 if (wIndex != 1) 1649 retval = -EPIPE; 1650 1651 /* whoever resets or resumes must GetPortStatus to 1652 * complete it!! 1653 */ 1654 if (dum->resuming && 1655 time_after_eq (jiffies, dum->re_timeout)) { 1656 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16); 1657 dum->port_status &= ~USB_PORT_STAT_SUSPEND; 1658 } 1659 if ((dum->port_status & USB_PORT_STAT_RESET) != 0 && 1660 time_after_eq (jiffies, dum->re_timeout)) { 1661 dum->port_status |= (USB_PORT_STAT_C_RESET << 16); 1662 dum->port_status &= ~USB_PORT_STAT_RESET; 1663 if (dum->pullup) { 1664 dum->port_status |= USB_PORT_STAT_ENABLE; 1665 /* give it the best speed we agree on */ 1666 dum->gadget.speed = dum->driver->speed; 1667 dum->gadget.ep0->maxpacket = 64; 1668 switch (dum->gadget.speed) { 1669 case USB_SPEED_HIGH: 1670 dum->port_status |= 1671 USB_PORT_STAT_HIGH_SPEED; 1672 break; 1673 case USB_SPEED_LOW: 1674 dum->gadget.ep0->maxpacket = 8; 1675 dum->port_status |= 1676 USB_PORT_STAT_LOW_SPEED; 1677 break; 1678 default: 1679 dum->gadget.speed = USB_SPEED_FULL; 1680 break; 1681 } 1682 } 1683 } 1684 set_link_state (dum); 1685 ((__le16 *) buf)[0] = cpu_to_le16 (dum->port_status); 1686 ((__le16 *) buf)[1] = cpu_to_le16 (dum->port_status >> 16); 1687 break; 1688 case SetHubFeature: 1689 retval = -EPIPE; 1690 break; 1691 case SetPortFeature: 1692 switch (wValue) { 1693 case USB_PORT_FEAT_SUSPEND: 1694 if (dum->active) { 1695 dum->port_status |= USB_PORT_STAT_SUSPEND; 1696 1697 /* HNP would happen here; for now we 1698 * assume b_bus_req is always true. 1699 */ 1700 set_link_state (dum); 1701 if (((1 << USB_DEVICE_B_HNP_ENABLE) 1702 & dum->devstatus) != 0) 1703 dev_dbg (dummy_dev(dum), 1704 "no HNP yet!\n"); 1705 } 1706 break; 1707 case USB_PORT_FEAT_POWER: 1708 dum->port_status |= USB_PORT_STAT_POWER; 1709 set_link_state (dum); 1710 break; 1711 case USB_PORT_FEAT_RESET: 1712 /* if it's already enabled, disable */ 1713 dum->port_status &= ~(USB_PORT_STAT_ENABLE 1714 | USB_PORT_STAT_LOW_SPEED 1715 | USB_PORT_STAT_HIGH_SPEED); 1716 dum->devstatus = 0; 1717 /* 50msec reset signaling */ 1718 dum->re_timeout = jiffies + msecs_to_jiffies(50); 1719 /* FALLS THROUGH */ 1720 default: 1721 if ((dum->port_status & USB_PORT_STAT_POWER) != 0) { 1722 dum->port_status |= (1 << wValue); 1723 set_link_state (dum); 1724 } 1725 } 1726 break; 1727 1728 default: 1729 dev_dbg (dummy_dev(dum), 1730 "hub control req%04x v%04x i%04x l%d\n", 1731 typeReq, wValue, wIndex, wLength); 1732 1733 /* "protocol stall" on error */ 1734 retval = -EPIPE; 1735 } 1736 spin_unlock_irqrestore (&dum->lock, flags); 1737 1738 if ((dum->port_status & PORT_C_MASK) != 0) 1739 usb_hcd_poll_rh_status (hcd); 1740 return retval; 1741} 1742 1743static int dummy_bus_suspend (struct usb_hcd *hcd) 1744{ 1745 struct dummy *dum = hcd_to_dummy (hcd); 1746 1747 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__); 1748 1749 spin_lock_irq (&dum->lock); 1750 dum->rh_state = DUMMY_RH_SUSPENDED; 1751 set_link_state (dum); 1752 hcd->state = HC_STATE_SUSPENDED; 1753 spin_unlock_irq (&dum->lock); 1754 return 0; 1755} 1756 1757static int dummy_bus_resume (struct usb_hcd *hcd) 1758{ 1759 struct dummy *dum = hcd_to_dummy (hcd); 1760 int rc = 0; 1761 1762 dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__); 1763 1764 spin_lock_irq (&dum->lock); 1765 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) { 1766 dev_warn (&hcd->self.root_hub->dev, "HC isn't running!\n"); 1767 rc = -ENODEV; 1768 } else { 1769 dum->rh_state = DUMMY_RH_RUNNING; 1770 set_link_state (dum); 1771 if (!list_empty(&dum->urbp_list)) 1772 mod_timer (&dum->timer, jiffies); 1773 hcd->state = HC_STATE_RUNNING; 1774 } 1775 spin_unlock_irq (&dum->lock); 1776 return rc; 1777} 1778 1779/*-------------------------------------------------------------------------*/ 1780 1781static inline ssize_t 1782show_urb (char *buf, size_t size, struct urb *urb) 1783{ 1784 int ep = usb_pipeendpoint (urb->pipe); 1785 1786 return snprintf (buf, size, 1787 "urb/%p %s ep%d%s%s len %d/%d\n", 1788 urb, 1789 ({ char *s; 1790 switch (urb->dev->speed) { 1791 case USB_SPEED_LOW: s = "ls"; break; 1792 case USB_SPEED_FULL: s = "fs"; break; 1793 case USB_SPEED_HIGH: s = "hs"; break; 1794 default: s = "?"; break; 1795 }; s; }), 1796 ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "", 1797 ({ char *s; \ 1798 switch (usb_pipetype (urb->pipe)) { \ 1799 case PIPE_CONTROL: s = ""; break; \ 1800 case PIPE_BULK: s = "-bulk"; break; \ 1801 case PIPE_INTERRUPT: s = "-int"; break; \ 1802 default: s = "-iso"; break; \ 1803 }; s;}), 1804 urb->actual_length, urb->transfer_buffer_length); 1805} 1806 1807static ssize_t 1808show_urbs (struct device *dev, struct device_attribute *attr, char *buf) 1809{ 1810 struct usb_hcd *hcd = dev_get_drvdata (dev); 1811 struct dummy *dum = hcd_to_dummy (hcd); 1812 struct urbp *urbp; 1813 size_t size = 0; 1814 unsigned long flags; 1815 1816 spin_lock_irqsave (&dum->lock, flags); 1817 list_for_each_entry (urbp, &dum->urbp_list, urbp_list) { 1818 size_t temp; 1819 1820 temp = show_urb (buf, PAGE_SIZE - size, urbp->urb); 1821 buf += temp; 1822 size += temp; 1823 } 1824 spin_unlock_irqrestore (&dum->lock, flags); 1825 1826 return size; 1827} 1828static DEVICE_ATTR (urbs, S_IRUGO, show_urbs, NULL); 1829 1830static int dummy_start (struct usb_hcd *hcd) 1831{ 1832 struct dummy *dum; 1833 1834 dum = hcd_to_dummy (hcd); 1835 1836 /* 1837 * MASTER side init ... we emulate a root hub that'll only ever 1838 * talk to one device (the slave side). Also appears in sysfs, 1839 * just like more familiar pci-based HCDs. 1840 */ 1841 spin_lock_init (&dum->lock); 1842 init_timer (&dum->timer); 1843 dum->timer.function = dummy_timer; 1844 dum->timer.data = (unsigned long) dum; 1845 dum->rh_state = DUMMY_RH_RUNNING; 1846 1847 INIT_LIST_HEAD (&dum->urbp_list); 1848 1849 /* only show a low-power port: just 8mA */ 1850 hcd->power_budget = 8; 1851 hcd->state = HC_STATE_RUNNING; 1852 hcd->uses_new_polling = 1; 1853 1854#ifdef CONFIG_USB_OTG 1855 hcd->self.otg_port = 1; 1856#endif 1857 1858 return device_create_file (dummy_dev(dum), &dev_attr_urbs); 1859} 1860 1861static void dummy_stop (struct usb_hcd *hcd) 1862{ 1863 struct dummy *dum; 1864 1865 dum = hcd_to_dummy (hcd); 1866 1867 device_remove_file (dummy_dev(dum), &dev_attr_urbs); 1868 usb_gadget_unregister_driver (dum->driver); 1869 dev_info (dummy_dev(dum), "stopped\n"); 1870} 1871 1872/*-------------------------------------------------------------------------*/ 1873 1874static int dummy_h_get_frame (struct usb_hcd *hcd) 1875{ 1876 return dummy_g_get_frame (NULL); 1877} 1878 1879static const struct hc_driver dummy_hcd = { 1880 .description = (char *) driver_name, 1881 .product_desc = "Dummy host controller", 1882 .hcd_priv_size = sizeof(struct dummy), 1883 1884 .flags = HCD_USB2, 1885 1886 .start = dummy_start, 1887 .stop = dummy_stop, 1888 1889 .urb_enqueue = dummy_urb_enqueue, 1890 .urb_dequeue = dummy_urb_dequeue, 1891 1892 .get_frame_number = dummy_h_get_frame, 1893 1894 .hub_status_data = dummy_hub_status, 1895 .hub_control = dummy_hub_control, 1896 .bus_suspend = dummy_bus_suspend, 1897 .bus_resume = dummy_bus_resume, 1898}; 1899 1900static int dummy_hcd_probe(struct platform_device *pdev) 1901{ 1902 struct usb_hcd *hcd; 1903 int retval; 1904 1905 dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc); 1906 1907 hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, pdev->dev.bus_id); 1908 if (!hcd) 1909 return -ENOMEM; 1910 the_controller = hcd_to_dummy (hcd); 1911 1912 retval = usb_add_hcd(hcd, 0, 0); 1913 if (retval != 0) { 1914 usb_put_hcd (hcd); 1915 the_controller = NULL; 1916 } 1917 return retval; 1918} 1919 1920static int dummy_hcd_remove (struct platform_device *pdev) 1921{ 1922 struct usb_hcd *hcd; 1923 1924 hcd = platform_get_drvdata (pdev); 1925 usb_remove_hcd (hcd); 1926 usb_put_hcd (hcd); 1927 the_controller = NULL; 1928 return 0; 1929} 1930 1931static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state) 1932{ 1933 struct usb_hcd *hcd; 1934 struct dummy *dum; 1935 int rc = 0; 1936 1937 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); 1938 1939 hcd = platform_get_drvdata (pdev); 1940 dum = hcd_to_dummy (hcd); 1941 if (dum->rh_state == DUMMY_RH_RUNNING) { 1942 dev_warn(&pdev->dev, "Root hub isn't suspended!\n"); 1943 rc = -EBUSY; 1944 } else 1945 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); 1946 return rc; 1947} 1948 1949static int dummy_hcd_resume (struct platform_device *pdev) 1950{ 1951 struct usb_hcd *hcd; 1952 1953 dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); 1954 1955 hcd = platform_get_drvdata (pdev); 1956 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); 1957 usb_hcd_poll_rh_status (hcd); 1958 return 0; 1959} 1960 1961static struct platform_driver dummy_hcd_driver = { 1962 .probe = dummy_hcd_probe, 1963 .remove = dummy_hcd_remove, 1964 .suspend = dummy_hcd_suspend, 1965 .resume = dummy_hcd_resume, 1966 .driver = { 1967 .name = (char *) driver_name, 1968 .owner = THIS_MODULE, 1969 }, 1970}; 1971 1972/*-------------------------------------------------------------------------*/ 1973 1974/* These don't need to do anything because the pdev structures are 1975 * statically allocated. */ 1976static void 1977dummy_udc_release (struct device *dev) {} 1978 1979static void 1980dummy_hcd_release (struct device *dev) {} 1981 1982static struct platform_device the_udc_pdev = { 1983 .name = (char *) gadget_name, 1984 .id = -1, 1985 .dev = { 1986 .release = dummy_udc_release, 1987 }, 1988}; 1989 1990static struct platform_device the_hcd_pdev = { 1991 .name = (char *) driver_name, 1992 .id = -1, 1993 .dev = { 1994 .release = dummy_hcd_release, 1995 }, 1996}; 1997 1998static int __init init (void) 1999{ 2000 int retval; 2001 2002 if (usb_disabled ()) 2003 return -ENODEV; 2004 2005 retval = platform_driver_register (&dummy_hcd_driver); 2006 if (retval < 0) 2007 return retval; 2008 2009 retval = platform_driver_register (&dummy_udc_driver); 2010 if (retval < 0) 2011 goto err_register_udc_driver; 2012 2013 retval = platform_device_register (&the_hcd_pdev); 2014 if (retval < 0) 2015 goto err_register_hcd; 2016 2017 retval = platform_device_register (&the_udc_pdev); 2018 if (retval < 0) 2019 goto err_register_udc; 2020 return retval; 2021 2022err_register_udc: 2023 platform_device_unregister (&the_hcd_pdev); 2024err_register_hcd: 2025 platform_driver_unregister (&dummy_udc_driver); 2026err_register_udc_driver: 2027 platform_driver_unregister (&dummy_hcd_driver); 2028 return retval; 2029} 2030module_init (init); 2031 2032static void __exit cleanup (void) 2033{ 2034 platform_device_unregister (&the_udc_pdev); 2035 platform_device_unregister (&the_hcd_pdev); 2036 platform_driver_unregister (&dummy_udc_driver); 2037 platform_driver_unregister (&dummy_hcd_driver); 2038} 2039module_exit (cleanup); 2040