1 /** 2 * udc.c - Core UDC Framework 3 * 4 * Copyright (C) 2010 Texas Instruments 5 * Author: Felipe Balbi <balbi@ti.com> 6 * 7 * This program is free software: you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 of 9 * the License as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include <linux/kernel.h> 21 #include <linux/module.h> 22 #include <linux/device.h> 23 #include <linux/list.h> 24 #include <linux/err.h> 25 #include <linux/dma-mapping.h> 26 #include <linux/workqueue.h> 27 28 #include <linux/usb/ch9.h> 29 #include <linux/usb/gadget.h> 30 #include <linux/usb.h> 31 32 #include "trace.h" 33 34 /** 35 * struct usb_udc - describes one usb device controller 36 * @driver - the gadget driver pointer. For use by the class code 37 * @dev - the child device to the actual controller 38 * @gadget - the gadget. For use by the class code 39 * @list - for use by the udc class driver 40 * @vbus - for udcs who care about vbus status, this value is real vbus status; 41 * for udcs who do not care about vbus status, this value is always true 42 * 43 * This represents the internal data structure which is used by the UDC-class 44 * to hold information about udc driver and gadget together. 45 */ 46 struct usb_udc { 47 struct usb_gadget_driver *driver; 48 struct usb_gadget *gadget; 49 struct device dev; 50 struct list_head list; 51 bool vbus; 52 }; 53 54 static struct class *udc_class; 55 static LIST_HEAD(udc_list); 56 static LIST_HEAD(gadget_driver_pending_list); 57 static DEFINE_MUTEX(udc_lock); 58 59 static int udc_bind_to_driver(struct usb_udc *udc, 60 struct usb_gadget_driver *driver); 61 62 /* ------------------------------------------------------------------------- */ 63 64 /** 65 * usb_ep_set_maxpacket_limit - set maximum packet size limit for endpoint 66 * @ep:the endpoint being configured 67 * @maxpacket_limit:value of maximum packet size limit 68 * 69 * This function should be used only in UDC drivers to initialize endpoint 70 * (usually in probe function). 71 */ 72 void usb_ep_set_maxpacket_limit(struct usb_ep *ep, 73 unsigned maxpacket_limit) 74 { 75 ep->maxpacket_limit = maxpacket_limit; 76 ep->maxpacket = maxpacket_limit; 77 78 trace_usb_ep_set_maxpacket_limit(ep, 0); 79 } 80 EXPORT_SYMBOL_GPL(usb_ep_set_maxpacket_limit); 81 82 /** 83 * usb_ep_enable - configure endpoint, making it usable 84 * @ep:the endpoint being configured. may not be the endpoint named "ep0". 85 * drivers discover endpoints through the ep_list of a usb_gadget. 86 * 87 * When configurations are set, or when interface settings change, the driver 88 * will enable or disable the relevant endpoints. while it is enabled, an 89 * endpoint may be used for i/o until the driver receives a disconnect() from 90 * the host or until the endpoint is disabled. 91 * 92 * the ep0 implementation (which calls this routine) must ensure that the 93 * hardware capabilities of each endpoint match the descriptor provided 94 * for it. for example, an endpoint named "ep2in-bulk" would be usable 95 * for interrupt transfers as well as bulk, but it likely couldn't be used 96 * for iso transfers or for endpoint 14. some endpoints are fully 97 * configurable, with more generic names like "ep-a". (remember that for 98 * USB, "in" means "towards the USB master".) 99 * 100 * returns zero, or a negative error code. 101 */ 102 int usb_ep_enable(struct usb_ep *ep) 103 { 104 int ret = 0; 105 106 if (ep->enabled) 107 goto out; 108 109 ret = ep->ops->enable(ep, ep->desc); 110 if (ret) 111 goto out; 112 113 ep->enabled = true; 114 115 out: 116 trace_usb_ep_enable(ep, ret); 117 118 return ret; 119 } 120 EXPORT_SYMBOL_GPL(usb_ep_enable); 121 122 /** 123 * usb_ep_disable - endpoint is no longer usable 124 * @ep:the endpoint being unconfigured. may not be the endpoint named "ep0". 125 * 126 * no other task may be using this endpoint when this is called. 127 * any pending and uncompleted requests will complete with status 128 * indicating disconnect (-ESHUTDOWN) before this call returns. 129 * gadget drivers must call usb_ep_enable() again before queueing 130 * requests to the endpoint. 131 * 132 * returns zero, or a negative error code. 133 */ 134 int usb_ep_disable(struct usb_ep *ep) 135 { 136 int ret = 0; 137 138 if (!ep->enabled) 139 goto out; 140 141 ret = ep->ops->disable(ep); 142 if (ret) { 143 ret = ret; 144 goto out; 145 } 146 147 ep->enabled = false; 148 149 out: 150 trace_usb_ep_disable(ep, ret); 151 152 return ret; 153 } 154 EXPORT_SYMBOL_GPL(usb_ep_disable); 155 156 /** 157 * usb_ep_alloc_request - allocate a request object to use with this endpoint 158 * @ep:the endpoint to be used with with the request 159 * @gfp_flags:GFP_* flags to use 160 * 161 * Request objects must be allocated with this call, since they normally 162 * need controller-specific setup and may even need endpoint-specific 163 * resources such as allocation of DMA descriptors. 164 * Requests may be submitted with usb_ep_queue(), and receive a single 165 * completion callback. Free requests with usb_ep_free_request(), when 166 * they are no longer needed. 167 * 168 * Returns the request, or null if one could not be allocated. 169 */ 170 struct usb_request *usb_ep_alloc_request(struct usb_ep *ep, 171 gfp_t gfp_flags) 172 { 173 struct usb_request *req = NULL; 174 175 req = ep->ops->alloc_request(ep, gfp_flags); 176 177 trace_usb_ep_alloc_request(ep, req, req ? 0 : -ENOMEM); 178 179 return req; 180 } 181 EXPORT_SYMBOL_GPL(usb_ep_alloc_request); 182 183 /** 184 * usb_ep_free_request - frees a request object 185 * @ep:the endpoint associated with the request 186 * @req:the request being freed 187 * 188 * Reverses the effect of usb_ep_alloc_request(). 189 * Caller guarantees the request is not queued, and that it will 190 * no longer be requeued (or otherwise used). 191 */ 192 void usb_ep_free_request(struct usb_ep *ep, 193 struct usb_request *req) 194 { 195 ep->ops->free_request(ep, req); 196 trace_usb_ep_free_request(ep, req, 0); 197 } 198 EXPORT_SYMBOL_GPL(usb_ep_free_request); 199 200 /** 201 * usb_ep_queue - queues (submits) an I/O request to an endpoint. 202 * @ep:the endpoint associated with the request 203 * @req:the request being submitted 204 * @gfp_flags: GFP_* flags to use in case the lower level driver couldn't 205 * pre-allocate all necessary memory with the request. 206 * 207 * This tells the device controller to perform the specified request through 208 * that endpoint (reading or writing a buffer). When the request completes, 209 * including being canceled by usb_ep_dequeue(), the request's completion 210 * routine is called to return the request to the driver. Any endpoint 211 * (except control endpoints like ep0) may have more than one transfer 212 * request queued; they complete in FIFO order. Once a gadget driver 213 * submits a request, that request may not be examined or modified until it 214 * is given back to that driver through the completion callback. 215 * 216 * Each request is turned into one or more packets. The controller driver 217 * never merges adjacent requests into the same packet. OUT transfers 218 * will sometimes use data that's already buffered in the hardware. 219 * Drivers can rely on the fact that the first byte of the request's buffer 220 * always corresponds to the first byte of some USB packet, for both 221 * IN and OUT transfers. 222 * 223 * Bulk endpoints can queue any amount of data; the transfer is packetized 224 * automatically. The last packet will be short if the request doesn't fill it 225 * out completely. Zero length packets (ZLPs) should be avoided in portable 226 * protocols since not all usb hardware can successfully handle zero length 227 * packets. (ZLPs may be explicitly written, and may be implicitly written if 228 * the request 'zero' flag is set.) Bulk endpoints may also be used 229 * for interrupt transfers; but the reverse is not true, and some endpoints 230 * won't support every interrupt transfer. (Such as 768 byte packets.) 231 * 232 * Interrupt-only endpoints are less functional than bulk endpoints, for 233 * example by not supporting queueing or not handling buffers that are 234 * larger than the endpoint's maxpacket size. They may also treat data 235 * toggle differently. 236 * 237 * Control endpoints ... after getting a setup() callback, the driver queues 238 * one response (even if it would be zero length). That enables the 239 * status ack, after transferring data as specified in the response. Setup 240 * functions may return negative error codes to generate protocol stalls. 241 * (Note that some USB device controllers disallow protocol stall responses 242 * in some cases.) When control responses are deferred (the response is 243 * written after the setup callback returns), then usb_ep_set_halt() may be 244 * used on ep0 to trigger protocol stalls. Depending on the controller, 245 * it may not be possible to trigger a status-stage protocol stall when the 246 * data stage is over, that is, from within the response's completion 247 * routine. 248 * 249 * For periodic endpoints, like interrupt or isochronous ones, the usb host 250 * arranges to poll once per interval, and the gadget driver usually will 251 * have queued some data to transfer at that time. 252 * 253 * Returns zero, or a negative error code. Endpoints that are not enabled 254 * report errors; errors will also be 255 * reported when the usb peripheral is disconnected. 256 */ 257 int usb_ep_queue(struct usb_ep *ep, 258 struct usb_request *req, gfp_t gfp_flags) 259 { 260 int ret = 0; 261 262 if (WARN_ON_ONCE(!ep->enabled && ep->address)) { 263 ret = -ESHUTDOWN; 264 goto out; 265 } 266 267 ret = ep->ops->queue(ep, req, gfp_flags); 268 269 out: 270 trace_usb_ep_queue(ep, req, ret); 271 272 return ret; 273 } 274 EXPORT_SYMBOL_GPL(usb_ep_queue); 275 276 /** 277 * usb_ep_dequeue - dequeues (cancels, unlinks) an I/O request from an endpoint 278 * @ep:the endpoint associated with the request 279 * @req:the request being canceled 280 * 281 * If the request is still active on the endpoint, it is dequeued and its 282 * completion routine is called (with status -ECONNRESET); else a negative 283 * error code is returned. This is guaranteed to happen before the call to 284 * usb_ep_dequeue() returns. 285 * 286 * Note that some hardware can't clear out write fifos (to unlink the request 287 * at the head of the queue) except as part of disconnecting from usb. Such 288 * restrictions prevent drivers from supporting configuration changes, 289 * even to configuration zero (a "chapter 9" requirement). 290 */ 291 int usb_ep_dequeue(struct usb_ep *ep, struct usb_request *req) 292 { 293 int ret; 294 295 ret = ep->ops->dequeue(ep, req); 296 trace_usb_ep_dequeue(ep, req, ret); 297 298 return ret; 299 } 300 EXPORT_SYMBOL_GPL(usb_ep_dequeue); 301 302 /** 303 * usb_ep_set_halt - sets the endpoint halt feature. 304 * @ep: the non-isochronous endpoint being stalled 305 * 306 * Use this to stall an endpoint, perhaps as an error report. 307 * Except for control endpoints, 308 * the endpoint stays halted (will not stream any data) until the host 309 * clears this feature; drivers may need to empty the endpoint's request 310 * queue first, to make sure no inappropriate transfers happen. 311 * 312 * Note that while an endpoint CLEAR_FEATURE will be invisible to the 313 * gadget driver, a SET_INTERFACE will not be. To reset endpoints for the 314 * current altsetting, see usb_ep_clear_halt(). When switching altsettings, 315 * it's simplest to use usb_ep_enable() or usb_ep_disable() for the endpoints. 316 * 317 * Returns zero, or a negative error code. On success, this call sets 318 * underlying hardware state that blocks data transfers. 319 * Attempts to halt IN endpoints will fail (returning -EAGAIN) if any 320 * transfer requests are still queued, or if the controller hardware 321 * (usually a FIFO) still holds bytes that the host hasn't collected. 322 */ 323 int usb_ep_set_halt(struct usb_ep *ep) 324 { 325 int ret; 326 327 ret = ep->ops->set_halt(ep, 1); 328 trace_usb_ep_set_halt(ep, ret); 329 330 return ret; 331 } 332 EXPORT_SYMBOL_GPL(usb_ep_set_halt); 333 334 /** 335 * usb_ep_clear_halt - clears endpoint halt, and resets toggle 336 * @ep:the bulk or interrupt endpoint being reset 337 * 338 * Use this when responding to the standard usb "set interface" request, 339 * for endpoints that aren't reconfigured, after clearing any other state 340 * in the endpoint's i/o queue. 341 * 342 * Returns zero, or a negative error code. On success, this call clears 343 * the underlying hardware state reflecting endpoint halt and data toggle. 344 * Note that some hardware can't support this request (like pxa2xx_udc), 345 * and accordingly can't correctly implement interface altsettings. 346 */ 347 int usb_ep_clear_halt(struct usb_ep *ep) 348 { 349 int ret; 350 351 ret = ep->ops->set_halt(ep, 0); 352 trace_usb_ep_clear_halt(ep, ret); 353 354 return ret; 355 } 356 EXPORT_SYMBOL_GPL(usb_ep_clear_halt); 357 358 /** 359 * usb_ep_set_wedge - sets the halt feature and ignores clear requests 360 * @ep: the endpoint being wedged 361 * 362 * Use this to stall an endpoint and ignore CLEAR_FEATURE(HALT_ENDPOINT) 363 * requests. If the gadget driver clears the halt status, it will 364 * automatically unwedge the endpoint. 365 * 366 * Returns zero on success, else negative errno. 367 */ 368 int usb_ep_set_wedge(struct usb_ep *ep) 369 { 370 int ret; 371 372 if (ep->ops->set_wedge) 373 ret = ep->ops->set_wedge(ep); 374 else 375 ret = ep->ops->set_halt(ep, 1); 376 377 trace_usb_ep_set_wedge(ep, ret); 378 379 return ret; 380 } 381 EXPORT_SYMBOL_GPL(usb_ep_set_wedge); 382 383 /** 384 * usb_ep_fifo_status - returns number of bytes in fifo, or error 385 * @ep: the endpoint whose fifo status is being checked. 386 * 387 * FIFO endpoints may have "unclaimed data" in them in certain cases, 388 * such as after aborted transfers. Hosts may not have collected all 389 * the IN data written by the gadget driver (and reported by a request 390 * completion). The gadget driver may not have collected all the data 391 * written OUT to it by the host. Drivers that need precise handling for 392 * fault reporting or recovery may need to use this call. 393 * 394 * This returns the number of such bytes in the fifo, or a negative 395 * errno if the endpoint doesn't use a FIFO or doesn't support such 396 * precise handling. 397 */ 398 int usb_ep_fifo_status(struct usb_ep *ep) 399 { 400 int ret; 401 402 if (ep->ops->fifo_status) 403 ret = ep->ops->fifo_status(ep); 404 else 405 ret = -EOPNOTSUPP; 406 407 trace_usb_ep_fifo_status(ep, ret); 408 409 return ret; 410 } 411 EXPORT_SYMBOL_GPL(usb_ep_fifo_status); 412 413 /** 414 * usb_ep_fifo_flush - flushes contents of a fifo 415 * @ep: the endpoint whose fifo is being flushed. 416 * 417 * This call may be used to flush the "unclaimed data" that may exist in 418 * an endpoint fifo after abnormal transaction terminations. The call 419 * must never be used except when endpoint is not being used for any 420 * protocol translation. 421 */ 422 void usb_ep_fifo_flush(struct usb_ep *ep) 423 { 424 if (ep->ops->fifo_flush) 425 ep->ops->fifo_flush(ep); 426 427 trace_usb_ep_fifo_flush(ep, 0); 428 } 429 EXPORT_SYMBOL_GPL(usb_ep_fifo_flush); 430 431 /* ------------------------------------------------------------------------- */ 432 433 /** 434 * usb_gadget_frame_number - returns the current frame number 435 * @gadget: controller that reports the frame number 436 * 437 * Returns the usb frame number, normally eleven bits from a SOF packet, 438 * or negative errno if this device doesn't support this capability. 439 */ 440 int usb_gadget_frame_number(struct usb_gadget *gadget) 441 { 442 int ret; 443 444 ret = gadget->ops->get_frame(gadget); 445 446 trace_usb_gadget_frame_number(gadget, ret); 447 448 return ret; 449 } 450 EXPORT_SYMBOL_GPL(usb_gadget_frame_number); 451 452 /** 453 * usb_gadget_wakeup - tries to wake up the host connected to this gadget 454 * @gadget: controller used to wake up the host 455 * 456 * Returns zero on success, else negative error code if the hardware 457 * doesn't support such attempts, or its support has not been enabled 458 * by the usb host. Drivers must return device descriptors that report 459 * their ability to support this, or hosts won't enable it. 460 * 461 * This may also try to use SRP to wake the host and start enumeration, 462 * even if OTG isn't otherwise in use. OTG devices may also start 463 * remote wakeup even when hosts don't explicitly enable it. 464 */ 465 int usb_gadget_wakeup(struct usb_gadget *gadget) 466 { 467 int ret = 0; 468 469 if (!gadget->ops->wakeup) { 470 ret = -EOPNOTSUPP; 471 goto out; 472 } 473 474 ret = gadget->ops->wakeup(gadget); 475 476 out: 477 trace_usb_gadget_wakeup(gadget, ret); 478 479 return ret; 480 } 481 EXPORT_SYMBOL_GPL(usb_gadget_wakeup); 482 483 /** 484 * usb_gadget_set_selfpowered - sets the device selfpowered feature. 485 * @gadget:the device being declared as self-powered 486 * 487 * this affects the device status reported by the hardware driver 488 * to reflect that it now has a local power supply. 489 * 490 * returns zero on success, else negative errno. 491 */ 492 int usb_gadget_set_selfpowered(struct usb_gadget *gadget) 493 { 494 int ret = 0; 495 496 if (!gadget->ops->set_selfpowered) { 497 ret = -EOPNOTSUPP; 498 goto out; 499 } 500 501 ret = gadget->ops->set_selfpowered(gadget, 1); 502 503 out: 504 trace_usb_gadget_set_selfpowered(gadget, ret); 505 506 return ret; 507 } 508 EXPORT_SYMBOL_GPL(usb_gadget_set_selfpowered); 509 510 /** 511 * usb_gadget_clear_selfpowered - clear the device selfpowered feature. 512 * @gadget:the device being declared as bus-powered 513 * 514 * this affects the device status reported by the hardware driver. 515 * some hardware may not support bus-powered operation, in which 516 * case this feature's value can never change. 517 * 518 * returns zero on success, else negative errno. 519 */ 520 int usb_gadget_clear_selfpowered(struct usb_gadget *gadget) 521 { 522 int ret = 0; 523 524 if (!gadget->ops->set_selfpowered) { 525 ret = -EOPNOTSUPP; 526 goto out; 527 } 528 529 ret = gadget->ops->set_selfpowered(gadget, 0); 530 531 out: 532 trace_usb_gadget_clear_selfpowered(gadget, ret); 533 534 return ret; 535 } 536 EXPORT_SYMBOL_GPL(usb_gadget_clear_selfpowered); 537 538 /** 539 * usb_gadget_vbus_connect - Notify controller that VBUS is powered 540 * @gadget:The device which now has VBUS power. 541 * Context: can sleep 542 * 543 * This call is used by a driver for an external transceiver (or GPIO) 544 * that detects a VBUS power session starting. Common responses include 545 * resuming the controller, activating the D+ (or D-) pullup to let the 546 * host detect that a USB device is attached, and starting to draw power 547 * (8mA or possibly more, especially after SET_CONFIGURATION). 548 * 549 * Returns zero on success, else negative errno. 550 */ 551 int usb_gadget_vbus_connect(struct usb_gadget *gadget) 552 { 553 int ret = 0; 554 555 if (!gadget->ops->vbus_session) { 556 ret = -EOPNOTSUPP; 557 goto out; 558 } 559 560 ret = gadget->ops->vbus_session(gadget, 1); 561 562 out: 563 trace_usb_gadget_vbus_connect(gadget, ret); 564 565 return ret; 566 } 567 EXPORT_SYMBOL_GPL(usb_gadget_vbus_connect); 568 569 /** 570 * usb_gadget_vbus_draw - constrain controller's VBUS power usage 571 * @gadget:The device whose VBUS usage is being described 572 * @mA:How much current to draw, in milliAmperes. This should be twice 573 * the value listed in the configuration descriptor bMaxPower field. 574 * 575 * This call is used by gadget drivers during SET_CONFIGURATION calls, 576 * reporting how much power the device may consume. For example, this 577 * could affect how quickly batteries are recharged. 578 * 579 * Returns zero on success, else negative errno. 580 */ 581 int usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA) 582 { 583 int ret = 0; 584 585 if (!gadget->ops->vbus_draw) { 586 ret = -EOPNOTSUPP; 587 goto out; 588 } 589 590 ret = gadget->ops->vbus_draw(gadget, mA); 591 if (!ret) 592 gadget->mA = mA; 593 594 out: 595 trace_usb_gadget_vbus_draw(gadget, ret); 596 597 return ret; 598 } 599 EXPORT_SYMBOL_GPL(usb_gadget_vbus_draw); 600 601 /** 602 * usb_gadget_vbus_disconnect - notify controller about VBUS session end 603 * @gadget:the device whose VBUS supply is being described 604 * Context: can sleep 605 * 606 * This call is used by a driver for an external transceiver (or GPIO) 607 * that detects a VBUS power session ending. Common responses include 608 * reversing everything done in usb_gadget_vbus_connect(). 609 * 610 * Returns zero on success, else negative errno. 611 */ 612 int usb_gadget_vbus_disconnect(struct usb_gadget *gadget) 613 { 614 int ret = 0; 615 616 if (!gadget->ops->vbus_session) { 617 ret = -EOPNOTSUPP; 618 goto out; 619 } 620 621 ret = gadget->ops->vbus_session(gadget, 0); 622 623 out: 624 trace_usb_gadget_vbus_disconnect(gadget, ret); 625 626 return ret; 627 } 628 EXPORT_SYMBOL_GPL(usb_gadget_vbus_disconnect); 629 630 /** 631 * usb_gadget_connect - software-controlled connect to USB host 632 * @gadget:the peripheral being connected 633 * 634 * Enables the D+ (or potentially D-) pullup. The host will start 635 * enumerating this gadget when the pullup is active and a VBUS session 636 * is active (the link is powered). This pullup is always enabled unless 637 * usb_gadget_disconnect() has been used to disable it. 638 * 639 * Returns zero on success, else negative errno. 640 */ 641 int usb_gadget_connect(struct usb_gadget *gadget) 642 { 643 int ret = 0; 644 645 if (!gadget->ops->pullup) { 646 ret = -EOPNOTSUPP; 647 goto out; 648 } 649 650 if (gadget->deactivated) { 651 /* 652 * If gadget is deactivated we only save new state. 653 * Gadget will be connected automatically after activation. 654 */ 655 gadget->connected = true; 656 goto out; 657 } 658 659 ret = gadget->ops->pullup(gadget, 1); 660 if (!ret) 661 gadget->connected = 1; 662 663 out: 664 trace_usb_gadget_connect(gadget, ret); 665 666 return ret; 667 } 668 EXPORT_SYMBOL_GPL(usb_gadget_connect); 669 670 /** 671 * usb_gadget_disconnect - software-controlled disconnect from USB host 672 * @gadget:the peripheral being disconnected 673 * 674 * Disables the D+ (or potentially D-) pullup, which the host may see 675 * as a disconnect (when a VBUS session is active). Not all systems 676 * support software pullup controls. 677 * 678 * Returns zero on success, else negative errno. 679 */ 680 int usb_gadget_disconnect(struct usb_gadget *gadget) 681 { 682 int ret = 0; 683 684 if (!gadget->ops->pullup) { 685 ret = -EOPNOTSUPP; 686 goto out; 687 } 688 689 if (gadget->deactivated) { 690 /* 691 * If gadget is deactivated we only save new state. 692 * Gadget will stay disconnected after activation. 693 */ 694 gadget->connected = false; 695 goto out; 696 } 697 698 ret = gadget->ops->pullup(gadget, 0); 699 if (!ret) 700 gadget->connected = 0; 701 702 out: 703 trace_usb_gadget_disconnect(gadget, ret); 704 705 return ret; 706 } 707 EXPORT_SYMBOL_GPL(usb_gadget_disconnect); 708 709 /** 710 * usb_gadget_deactivate - deactivate function which is not ready to work 711 * @gadget: the peripheral being deactivated 712 * 713 * This routine may be used during the gadget driver bind() call to prevent 714 * the peripheral from ever being visible to the USB host, unless later 715 * usb_gadget_activate() is called. For example, user mode components may 716 * need to be activated before the system can talk to hosts. 717 * 718 * Returns zero on success, else negative errno. 719 */ 720 int usb_gadget_deactivate(struct usb_gadget *gadget) 721 { 722 int ret = 0; 723 724 if (gadget->deactivated) 725 goto out; 726 727 if (gadget->connected) { 728 ret = usb_gadget_disconnect(gadget); 729 if (ret) 730 goto out; 731 732 /* 733 * If gadget was being connected before deactivation, we want 734 * to reconnect it in usb_gadget_activate(). 735 */ 736 gadget->connected = true; 737 } 738 gadget->deactivated = true; 739 740 out: 741 trace_usb_gadget_deactivate(gadget, ret); 742 743 return ret; 744 } 745 EXPORT_SYMBOL_GPL(usb_gadget_deactivate); 746 747 /** 748 * usb_gadget_activate - activate function which is not ready to work 749 * @gadget: the peripheral being activated 750 * 751 * This routine activates gadget which was previously deactivated with 752 * usb_gadget_deactivate() call. It calls usb_gadget_connect() if needed. 753 * 754 * Returns zero on success, else negative errno. 755 */ 756 int usb_gadget_activate(struct usb_gadget *gadget) 757 { 758 int ret = 0; 759 760 if (!gadget->deactivated) 761 goto out; 762 763 gadget->deactivated = false; 764 765 /* 766 * If gadget has been connected before deactivation, or became connected 767 * while it was being deactivated, we call usb_gadget_connect(). 768 */ 769 if (gadget->connected) 770 ret = usb_gadget_connect(gadget); 771 772 out: 773 trace_usb_gadget_activate(gadget, ret); 774 775 return ret; 776 } 777 EXPORT_SYMBOL_GPL(usb_gadget_activate); 778 779 /* ------------------------------------------------------------------------- */ 780 781 #ifdef CONFIG_HAS_DMA 782 783 int usb_gadget_map_request_by_dev(struct device *dev, 784 struct usb_request *req, int is_in) 785 { 786 if (req->length == 0) 787 return 0; 788 789 if (req->num_sgs) { 790 int mapped; 791 792 mapped = dma_map_sg(dev, req->sg, req->num_sgs, 793 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE); 794 if (mapped == 0) { 795 dev_err(dev, "failed to map SGs\n"); 796 return -EFAULT; 797 } 798 799 req->num_mapped_sgs = mapped; 800 } else { 801 req->dma = dma_map_single(dev, req->buf, req->length, 802 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE); 803 804 if (dma_mapping_error(dev, req->dma)) { 805 dev_err(dev, "failed to map buffer\n"); 806 return -EFAULT; 807 } 808 } 809 810 return 0; 811 } 812 EXPORT_SYMBOL_GPL(usb_gadget_map_request_by_dev); 813 814 int usb_gadget_map_request(struct usb_gadget *gadget, 815 struct usb_request *req, int is_in) 816 { 817 return usb_gadget_map_request_by_dev(gadget->dev.parent, req, is_in); 818 } 819 EXPORT_SYMBOL_GPL(usb_gadget_map_request); 820 821 void usb_gadget_unmap_request_by_dev(struct device *dev, 822 struct usb_request *req, int is_in) 823 { 824 if (req->length == 0) 825 return; 826 827 if (req->num_mapped_sgs) { 828 dma_unmap_sg(dev, req->sg, req->num_sgs, 829 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE); 830 831 req->num_mapped_sgs = 0; 832 } else { 833 dma_unmap_single(dev, req->dma, req->length, 834 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE); 835 } 836 } 837 EXPORT_SYMBOL_GPL(usb_gadget_unmap_request_by_dev); 838 839 void usb_gadget_unmap_request(struct usb_gadget *gadget, 840 struct usb_request *req, int is_in) 841 { 842 usb_gadget_unmap_request_by_dev(gadget->dev.parent, req, is_in); 843 } 844 EXPORT_SYMBOL_GPL(usb_gadget_unmap_request); 845 846 #endif /* CONFIG_HAS_DMA */ 847 848 /* ------------------------------------------------------------------------- */ 849 850 /** 851 * usb_gadget_giveback_request - give the request back to the gadget layer 852 * Context: in_interrupt() 853 * 854 * This is called by device controller drivers in order to return the 855 * completed request back to the gadget layer. 856 */ 857 void usb_gadget_giveback_request(struct usb_ep *ep, 858 struct usb_request *req) 859 { 860 if (likely(req->status == 0)) 861 usb_led_activity(USB_LED_EVENT_GADGET); 862 863 trace_usb_gadget_giveback_request(ep, req, 0); 864 865 req->complete(ep, req); 866 } 867 EXPORT_SYMBOL_GPL(usb_gadget_giveback_request); 868 869 /* ------------------------------------------------------------------------- */ 870 871 /** 872 * gadget_find_ep_by_name - returns ep whose name is the same as sting passed 873 * in second parameter or NULL if searched endpoint not found 874 * @g: controller to check for quirk 875 * @name: name of searched endpoint 876 */ 877 struct usb_ep *gadget_find_ep_by_name(struct usb_gadget *g, const char *name) 878 { 879 struct usb_ep *ep; 880 881 gadget_for_each_ep(ep, g) { 882 if (!strcmp(ep->name, name)) 883 return ep; 884 } 885 886 return NULL; 887 } 888 EXPORT_SYMBOL_GPL(gadget_find_ep_by_name); 889 890 /* ------------------------------------------------------------------------- */ 891 892 int usb_gadget_ep_match_desc(struct usb_gadget *gadget, 893 struct usb_ep *ep, struct usb_endpoint_descriptor *desc, 894 struct usb_ss_ep_comp_descriptor *ep_comp) 895 { 896 u8 type; 897 u16 max; 898 int num_req_streams = 0; 899 900 /* endpoint already claimed? */ 901 if (ep->claimed) 902 return 0; 903 904 type = usb_endpoint_type(desc); 905 max = 0x7ff & usb_endpoint_maxp(desc); 906 907 if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in) 908 return 0; 909 if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out) 910 return 0; 911 912 if (max > ep->maxpacket_limit) 913 return 0; 914 915 /* "high bandwidth" works only at high speed */ 916 if (!gadget_is_dualspeed(gadget) && usb_endpoint_maxp(desc) & (3<<11)) 917 return 0; 918 919 switch (type) { 920 case USB_ENDPOINT_XFER_CONTROL: 921 /* only support ep0 for portable CONTROL traffic */ 922 return 0; 923 case USB_ENDPOINT_XFER_ISOC: 924 if (!ep->caps.type_iso) 925 return 0; 926 /* ISO: limit 1023 bytes full speed, 1024 high/super speed */ 927 if (!gadget_is_dualspeed(gadget) && max > 1023) 928 return 0; 929 break; 930 case USB_ENDPOINT_XFER_BULK: 931 if (!ep->caps.type_bulk) 932 return 0; 933 if (ep_comp && gadget_is_superspeed(gadget)) { 934 /* Get the number of required streams from the 935 * EP companion descriptor and see if the EP 936 * matches it 937 */ 938 num_req_streams = ep_comp->bmAttributes & 0x1f; 939 if (num_req_streams > ep->max_streams) 940 return 0; 941 } 942 break; 943 case USB_ENDPOINT_XFER_INT: 944 /* Bulk endpoints handle interrupt transfers, 945 * except the toggle-quirky iso-synch kind 946 */ 947 if (!ep->caps.type_int && !ep->caps.type_bulk) 948 return 0; 949 /* INT: limit 64 bytes full speed, 1024 high/super speed */ 950 if (!gadget_is_dualspeed(gadget) && max > 64) 951 return 0; 952 break; 953 } 954 955 return 1; 956 } 957 EXPORT_SYMBOL_GPL(usb_gadget_ep_match_desc); 958 959 /* ------------------------------------------------------------------------- */ 960 961 static void usb_gadget_state_work(struct work_struct *work) 962 { 963 struct usb_gadget *gadget = work_to_gadget(work); 964 struct usb_udc *udc = gadget->udc; 965 966 if (udc) 967 sysfs_notify(&udc->dev.kobj, NULL, "state"); 968 } 969 970 void usb_gadget_set_state(struct usb_gadget *gadget, 971 enum usb_device_state state) 972 { 973 gadget->state = state; 974 schedule_work(&gadget->work); 975 } 976 EXPORT_SYMBOL_GPL(usb_gadget_set_state); 977 978 /* ------------------------------------------------------------------------- */ 979 980 static void usb_udc_connect_control(struct usb_udc *udc) 981 { 982 if (udc->vbus) 983 usb_gadget_connect(udc->gadget); 984 else 985 usb_gadget_disconnect(udc->gadget); 986 } 987 988 /** 989 * usb_udc_vbus_handler - updates the udc core vbus status, and try to 990 * connect or disconnect gadget 991 * @gadget: The gadget which vbus change occurs 992 * @status: The vbus status 993 * 994 * The udc driver calls it when it wants to connect or disconnect gadget 995 * according to vbus status. 996 */ 997 void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status) 998 { 999 struct usb_udc *udc = gadget->udc; 1000 1001 if (udc) { 1002 udc->vbus = status; 1003 usb_udc_connect_control(udc); 1004 } 1005 } 1006 EXPORT_SYMBOL_GPL(usb_udc_vbus_handler); 1007 1008 /** 1009 * usb_gadget_udc_reset - notifies the udc core that bus reset occurs 1010 * @gadget: The gadget which bus reset occurs 1011 * @driver: The gadget driver we want to notify 1012 * 1013 * If the udc driver has bus reset handler, it needs to call this when the bus 1014 * reset occurs, it notifies the gadget driver that the bus reset occurs as 1015 * well as updates gadget state. 1016 */ 1017 void usb_gadget_udc_reset(struct usb_gadget *gadget, 1018 struct usb_gadget_driver *driver) 1019 { 1020 driver->reset(gadget); 1021 usb_gadget_set_state(gadget, USB_STATE_DEFAULT); 1022 } 1023 EXPORT_SYMBOL_GPL(usb_gadget_udc_reset); 1024 1025 /** 1026 * usb_gadget_udc_start - tells usb device controller to start up 1027 * @udc: The UDC to be started 1028 * 1029 * This call is issued by the UDC Class driver when it's about 1030 * to register a gadget driver to the device controller, before 1031 * calling gadget driver's bind() method. 1032 * 1033 * It allows the controller to be powered off until strictly 1034 * necessary to have it powered on. 1035 * 1036 * Returns zero on success, else negative errno. 1037 */ 1038 static inline int usb_gadget_udc_start(struct usb_udc *udc) 1039 { 1040 return udc->gadget->ops->udc_start(udc->gadget, udc->driver); 1041 } 1042 1043 /** 1044 * usb_gadget_udc_stop - tells usb device controller we don't need it anymore 1045 * @gadget: The device we want to stop activity 1046 * @driver: The driver to unbind from @gadget 1047 * 1048 * This call is issued by the UDC Class driver after calling 1049 * gadget driver's unbind() method. 1050 * 1051 * The details are implementation specific, but it can go as 1052 * far as powering off UDC completely and disable its data 1053 * line pullups. 1054 */ 1055 static inline void usb_gadget_udc_stop(struct usb_udc *udc) 1056 { 1057 udc->gadget->ops->udc_stop(udc->gadget); 1058 } 1059 1060 /** 1061 * usb_udc_release - release the usb_udc struct 1062 * @dev: the dev member within usb_udc 1063 * 1064 * This is called by driver's core in order to free memory once the last 1065 * reference is released. 1066 */ 1067 static void usb_udc_release(struct device *dev) 1068 { 1069 struct usb_udc *udc; 1070 1071 udc = container_of(dev, struct usb_udc, dev); 1072 dev_dbg(dev, "releasing '%s'\n", dev_name(dev)); 1073 kfree(udc); 1074 } 1075 1076 static const struct attribute_group *usb_udc_attr_groups[]; 1077 1078 static void usb_udc_nop_release(struct device *dev) 1079 { 1080 dev_vdbg(dev, "%s\n", __func__); 1081 } 1082 1083 /* should be called with udc_lock held */ 1084 static int check_pending_gadget_drivers(struct usb_udc *udc) 1085 { 1086 struct usb_gadget_driver *driver; 1087 int ret = 0; 1088 1089 list_for_each_entry(driver, &gadget_driver_pending_list, pending) 1090 if (!driver->udc_name || strcmp(driver->udc_name, 1091 dev_name(&udc->dev)) == 0) { 1092 ret = udc_bind_to_driver(udc, driver); 1093 if (ret != -EPROBE_DEFER) 1094 list_del(&driver->pending); 1095 break; 1096 } 1097 1098 return ret; 1099 } 1100 1101 /** 1102 * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list 1103 * @parent: the parent device to this udc. Usually the controller driver's 1104 * device. 1105 * @gadget: the gadget to be added to the list. 1106 * @release: a gadget release function. 1107 * 1108 * Returns zero on success, negative errno otherwise. 1109 */ 1110 int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget, 1111 void (*release)(struct device *dev)) 1112 { 1113 struct usb_udc *udc; 1114 int ret = -ENOMEM; 1115 1116 udc = kzalloc(sizeof(*udc), GFP_KERNEL); 1117 if (!udc) 1118 goto err1; 1119 1120 dev_set_name(&gadget->dev, "gadget"); 1121 INIT_WORK(&gadget->work, usb_gadget_state_work); 1122 gadget->dev.parent = parent; 1123 1124 if (release) 1125 gadget->dev.release = release; 1126 else 1127 gadget->dev.release = usb_udc_nop_release; 1128 1129 ret = device_register(&gadget->dev); 1130 if (ret) 1131 goto err2; 1132 1133 device_initialize(&udc->dev); 1134 udc->dev.release = usb_udc_release; 1135 udc->dev.class = udc_class; 1136 udc->dev.groups = usb_udc_attr_groups; 1137 udc->dev.parent = parent; 1138 ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj)); 1139 if (ret) 1140 goto err3; 1141 1142 udc->gadget = gadget; 1143 gadget->udc = udc; 1144 1145 mutex_lock(&udc_lock); 1146 list_add_tail(&udc->list, &udc_list); 1147 1148 ret = device_add(&udc->dev); 1149 if (ret) 1150 goto err4; 1151 1152 usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED); 1153 udc->vbus = true; 1154 1155 /* pick up one of pending gadget drivers */ 1156 ret = check_pending_gadget_drivers(udc); 1157 if (ret) 1158 goto err5; 1159 1160 mutex_unlock(&udc_lock); 1161 1162 return 0; 1163 1164 err5: 1165 device_del(&udc->dev); 1166 1167 err4: 1168 list_del(&udc->list); 1169 mutex_unlock(&udc_lock); 1170 1171 err3: 1172 put_device(&udc->dev); 1173 device_del(&gadget->dev); 1174 1175 err2: 1176 put_device(&gadget->dev); 1177 kfree(udc); 1178 1179 err1: 1180 return ret; 1181 } 1182 EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release); 1183 1184 /** 1185 * usb_get_gadget_udc_name - get the name of the first UDC controller 1186 * This functions returns the name of the first UDC controller in the system. 1187 * Please note that this interface is usefull only for legacy drivers which 1188 * assume that there is only one UDC controller in the system and they need to 1189 * get its name before initialization. There is no guarantee that the UDC 1190 * of the returned name will be still available, when gadget driver registers 1191 * itself. 1192 * 1193 * Returns pointer to string with UDC controller name on success, NULL 1194 * otherwise. Caller should kfree() returned string. 1195 */ 1196 char *usb_get_gadget_udc_name(void) 1197 { 1198 struct usb_udc *udc; 1199 char *name = NULL; 1200 1201 /* For now we take the first available UDC */ 1202 mutex_lock(&udc_lock); 1203 list_for_each_entry(udc, &udc_list, list) { 1204 if (!udc->driver) { 1205 name = kstrdup(udc->gadget->name, GFP_KERNEL); 1206 break; 1207 } 1208 } 1209 mutex_unlock(&udc_lock); 1210 return name; 1211 } 1212 EXPORT_SYMBOL_GPL(usb_get_gadget_udc_name); 1213 1214 /** 1215 * usb_add_gadget_udc - adds a new gadget to the udc class driver list 1216 * @parent: the parent device to this udc. Usually the controller 1217 * driver's device. 1218 * @gadget: the gadget to be added to the list 1219 * 1220 * Returns zero on success, negative errno otherwise. 1221 */ 1222 int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget) 1223 { 1224 return usb_add_gadget_udc_release(parent, gadget, NULL); 1225 } 1226 EXPORT_SYMBOL_GPL(usb_add_gadget_udc); 1227 1228 static void usb_gadget_remove_driver(struct usb_udc *udc) 1229 { 1230 dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n", 1231 udc->driver->function); 1232 1233 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE); 1234 1235 usb_gadget_disconnect(udc->gadget); 1236 udc->driver->disconnect(udc->gadget); 1237 udc->driver->unbind(udc->gadget); 1238 usb_gadget_udc_stop(udc); 1239 1240 udc->driver = NULL; 1241 udc->dev.driver = NULL; 1242 udc->gadget->dev.driver = NULL; 1243 } 1244 1245 /** 1246 * usb_del_gadget_udc - deletes @udc from udc_list 1247 * @gadget: the gadget to be removed. 1248 * 1249 * This, will call usb_gadget_unregister_driver() if 1250 * the @udc is still busy. 1251 */ 1252 void usb_del_gadget_udc(struct usb_gadget *gadget) 1253 { 1254 struct usb_udc *udc = gadget->udc; 1255 1256 if (!udc) 1257 return; 1258 1259 dev_vdbg(gadget->dev.parent, "unregistering gadget\n"); 1260 1261 mutex_lock(&udc_lock); 1262 list_del(&udc->list); 1263 1264 if (udc->driver) { 1265 struct usb_gadget_driver *driver = udc->driver; 1266 1267 usb_gadget_remove_driver(udc); 1268 list_add(&driver->pending, &gadget_driver_pending_list); 1269 } 1270 mutex_unlock(&udc_lock); 1271 1272 kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE); 1273 flush_work(&gadget->work); 1274 device_unregister(&udc->dev); 1275 device_unregister(&gadget->dev); 1276 } 1277 EXPORT_SYMBOL_GPL(usb_del_gadget_udc); 1278 1279 /* ------------------------------------------------------------------------- */ 1280 1281 static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver) 1282 { 1283 int ret; 1284 1285 dev_dbg(&udc->dev, "registering UDC driver [%s]\n", 1286 driver->function); 1287 1288 udc->driver = driver; 1289 udc->dev.driver = &driver->driver; 1290 udc->gadget->dev.driver = &driver->driver; 1291 1292 ret = driver->bind(udc->gadget, driver); 1293 if (ret) 1294 goto err1; 1295 ret = usb_gadget_udc_start(udc); 1296 if (ret) { 1297 driver->unbind(udc->gadget); 1298 goto err1; 1299 } 1300 usb_udc_connect_control(udc); 1301 1302 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE); 1303 return 0; 1304 err1: 1305 if (ret != -EISNAM) 1306 dev_err(&udc->dev, "failed to start %s: %d\n", 1307 udc->driver->function, ret); 1308 udc->driver = NULL; 1309 udc->dev.driver = NULL; 1310 udc->gadget->dev.driver = NULL; 1311 return ret; 1312 } 1313 1314 int usb_gadget_probe_driver(struct usb_gadget_driver *driver) 1315 { 1316 struct usb_udc *udc = NULL; 1317 int ret = -ENODEV; 1318 1319 if (!driver || !driver->bind || !driver->setup) 1320 return -EINVAL; 1321 1322 mutex_lock(&udc_lock); 1323 if (driver->udc_name) { 1324 list_for_each_entry(udc, &udc_list, list) { 1325 ret = strcmp(driver->udc_name, dev_name(&udc->dev)); 1326 if (!ret) 1327 break; 1328 } 1329 if (ret) 1330 ret = -ENODEV; 1331 else if (udc->driver) 1332 ret = -EBUSY; 1333 else 1334 goto found; 1335 } else { 1336 list_for_each_entry(udc, &udc_list, list) { 1337 /* For now we take the first one */ 1338 if (!udc->driver) 1339 goto found; 1340 } 1341 } 1342 1343 if (!driver->match_existing_only) { 1344 list_add_tail(&driver->pending, &gadget_driver_pending_list); 1345 pr_info("udc-core: couldn't find an available UDC - added [%s] to list of pending drivers\n", 1346 driver->function); 1347 ret = 0; 1348 } 1349 1350 mutex_unlock(&udc_lock); 1351 return ret; 1352 found: 1353 ret = udc_bind_to_driver(udc, driver); 1354 mutex_unlock(&udc_lock); 1355 return ret; 1356 } 1357 EXPORT_SYMBOL_GPL(usb_gadget_probe_driver); 1358 1359 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) 1360 { 1361 struct usb_udc *udc = NULL; 1362 int ret = -ENODEV; 1363 1364 if (!driver || !driver->unbind) 1365 return -EINVAL; 1366 1367 mutex_lock(&udc_lock); 1368 list_for_each_entry(udc, &udc_list, list) { 1369 if (udc->driver == driver) { 1370 usb_gadget_remove_driver(udc); 1371 usb_gadget_set_state(udc->gadget, 1372 USB_STATE_NOTATTACHED); 1373 1374 /* Maybe there is someone waiting for this UDC? */ 1375 check_pending_gadget_drivers(udc); 1376 /* 1377 * For now we ignore bind errors as probably it's 1378 * not a valid reason to fail other's gadget unbind 1379 */ 1380 ret = 0; 1381 break; 1382 } 1383 } 1384 1385 if (ret) { 1386 list_del(&driver->pending); 1387 ret = 0; 1388 } 1389 mutex_unlock(&udc_lock); 1390 return ret; 1391 } 1392 EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver); 1393 1394 /* ------------------------------------------------------------------------- */ 1395 1396 static ssize_t usb_udc_srp_store(struct device *dev, 1397 struct device_attribute *attr, const char *buf, size_t n) 1398 { 1399 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); 1400 1401 if (sysfs_streq(buf, "1")) 1402 usb_gadget_wakeup(udc->gadget); 1403 1404 return n; 1405 } 1406 static DEVICE_ATTR(srp, S_IWUSR, NULL, usb_udc_srp_store); 1407 1408 static ssize_t usb_udc_softconn_store(struct device *dev, 1409 struct device_attribute *attr, const char *buf, size_t n) 1410 { 1411 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); 1412 1413 if (!udc->driver) { 1414 dev_err(dev, "soft-connect without a gadget driver\n"); 1415 return -EOPNOTSUPP; 1416 } 1417 1418 if (sysfs_streq(buf, "connect")) { 1419 usb_gadget_udc_start(udc); 1420 usb_gadget_connect(udc->gadget); 1421 } else if (sysfs_streq(buf, "disconnect")) { 1422 usb_gadget_disconnect(udc->gadget); 1423 udc->driver->disconnect(udc->gadget); 1424 usb_gadget_udc_stop(udc); 1425 } else { 1426 dev_err(dev, "unsupported command '%s'\n", buf); 1427 return -EINVAL; 1428 } 1429 1430 return n; 1431 } 1432 static DEVICE_ATTR(soft_connect, S_IWUSR, NULL, usb_udc_softconn_store); 1433 1434 static ssize_t state_show(struct device *dev, struct device_attribute *attr, 1435 char *buf) 1436 { 1437 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); 1438 struct usb_gadget *gadget = udc->gadget; 1439 1440 return sprintf(buf, "%s\n", usb_state_string(gadget->state)); 1441 } 1442 static DEVICE_ATTR_RO(state); 1443 1444 #define USB_UDC_SPEED_ATTR(name, param) \ 1445 ssize_t name##_show(struct device *dev, \ 1446 struct device_attribute *attr, char *buf) \ 1447 { \ 1448 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \ 1449 return snprintf(buf, PAGE_SIZE, "%s\n", \ 1450 usb_speed_string(udc->gadget->param)); \ 1451 } \ 1452 static DEVICE_ATTR_RO(name) 1453 1454 static USB_UDC_SPEED_ATTR(current_speed, speed); 1455 static USB_UDC_SPEED_ATTR(maximum_speed, max_speed); 1456 1457 #define USB_UDC_ATTR(name) \ 1458 ssize_t name##_show(struct device *dev, \ 1459 struct device_attribute *attr, char *buf) \ 1460 { \ 1461 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \ 1462 struct usb_gadget *gadget = udc->gadget; \ 1463 \ 1464 return snprintf(buf, PAGE_SIZE, "%d\n", gadget->name); \ 1465 } \ 1466 static DEVICE_ATTR_RO(name) 1467 1468 static USB_UDC_ATTR(is_otg); 1469 static USB_UDC_ATTR(is_a_peripheral); 1470 static USB_UDC_ATTR(b_hnp_enable); 1471 static USB_UDC_ATTR(a_hnp_support); 1472 static USB_UDC_ATTR(a_alt_hnp_support); 1473 static USB_UDC_ATTR(is_selfpowered); 1474 1475 static struct attribute *usb_udc_attrs[] = { 1476 &dev_attr_srp.attr, 1477 &dev_attr_soft_connect.attr, 1478 &dev_attr_state.attr, 1479 &dev_attr_current_speed.attr, 1480 &dev_attr_maximum_speed.attr, 1481 1482 &dev_attr_is_otg.attr, 1483 &dev_attr_is_a_peripheral.attr, 1484 &dev_attr_b_hnp_enable.attr, 1485 &dev_attr_a_hnp_support.attr, 1486 &dev_attr_a_alt_hnp_support.attr, 1487 &dev_attr_is_selfpowered.attr, 1488 NULL, 1489 }; 1490 1491 static const struct attribute_group usb_udc_attr_group = { 1492 .attrs = usb_udc_attrs, 1493 }; 1494 1495 static const struct attribute_group *usb_udc_attr_groups[] = { 1496 &usb_udc_attr_group, 1497 NULL, 1498 }; 1499 1500 static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env) 1501 { 1502 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); 1503 int ret; 1504 1505 ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name); 1506 if (ret) { 1507 dev_err(dev, "failed to add uevent USB_UDC_NAME\n"); 1508 return ret; 1509 } 1510 1511 if (udc->driver) { 1512 ret = add_uevent_var(env, "USB_UDC_DRIVER=%s", 1513 udc->driver->function); 1514 if (ret) { 1515 dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n"); 1516 return ret; 1517 } 1518 } 1519 1520 return 0; 1521 } 1522 1523 static int __init usb_udc_init(void) 1524 { 1525 udc_class = class_create(THIS_MODULE, "udc"); 1526 if (IS_ERR(udc_class)) { 1527 pr_err("failed to create udc class --> %ld\n", 1528 PTR_ERR(udc_class)); 1529 return PTR_ERR(udc_class); 1530 } 1531 1532 udc_class->dev_uevent = usb_udc_uevent; 1533 return 0; 1534 } 1535 subsys_initcall(usb_udc_init); 1536 1537 static void __exit usb_udc_exit(void) 1538 { 1539 class_destroy(udc_class); 1540 } 1541 module_exit(usb_udc_exit); 1542 1543 MODULE_DESCRIPTION("UDC Framework"); 1544 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>"); 1545 MODULE_LICENSE("GPL v2"); 1546