drivers/usb/gadget/udc/core.c

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