core.c 41.2 KB
Newer Older
F
Felipe Balbi 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/**
 * udc.c - Core UDC Framework
 *
 * Copyright (C) 2010 Texas Instruments
 * Author: Felipe Balbi <balbi@ti.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2  of
 * the License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/list.h>
#include <linux/err.h>
25
#include <linux/dma-mapping.h>
26
#include <linux/workqueue.h>
F
Felipe Balbi 已提交
27 28 29

#include <linux/usb/ch9.h>
#include <linux/usb/gadget.h>
30
#include <linux/usb.h>
F
Felipe Balbi 已提交
31

32 33
#include "trace.h"

F
Felipe Balbi 已提交
34 35 36 37 38 39
/**
 * struct usb_udc - describes one usb device controller
 * @driver - the gadget driver pointer. For use by the class code
 * @dev - the child device to the actual controller
 * @gadget - the gadget. For use by the class code
 * @list - for use by the udc class driver
P
Peter Chen 已提交
40 41
 * @vbus - for udcs who care about vbus status, this value is real vbus status;
 * for udcs who do not care about vbus status, this value is always true
F
Felipe Balbi 已提交
42 43 44 45 46 47 48 49 50
 *
 * This represents the internal data structure which is used by the UDC-class
 * to hold information about udc driver and gadget together.
 */
struct usb_udc {
	struct usb_gadget_driver	*driver;
	struct usb_gadget		*gadget;
	struct device			dev;
	struct list_head		list;
P
Peter Chen 已提交
51
	bool				vbus;
F
Felipe Balbi 已提交
52 53 54 55
};

static struct class *udc_class;
static LIST_HEAD(udc_list);
56
static LIST_HEAD(gadget_driver_pending_list);
F
Felipe Balbi 已提交
57 58
static DEFINE_MUTEX(udc_lock);

59 60 61
static int udc_bind_to_driver(struct usb_udc *udc,
		struct usb_gadget_driver *driver);

F
Felipe Balbi 已提交
62 63
/* ------------------------------------------------------------------------- */

64 65 66 67 68 69 70 71 72 73 74 75 76
/**
 * usb_ep_set_maxpacket_limit - set maximum packet size limit for endpoint
 * @ep:the endpoint being configured
 * @maxpacket_limit:value of maximum packet size limit
 *
 * This function should be used only in UDC drivers to initialize endpoint
 * (usually in probe function).
 */
void usb_ep_set_maxpacket_limit(struct usb_ep *ep,
					      unsigned maxpacket_limit)
{
	ep->maxpacket_limit = maxpacket_limit;
	ep->maxpacket = maxpacket_limit;
77 78

	trace_usb_ep_set_maxpacket_limit(ep, 0);
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
}
EXPORT_SYMBOL_GPL(usb_ep_set_maxpacket_limit);

/**
 * usb_ep_enable - configure endpoint, making it usable
 * @ep:the endpoint being configured.  may not be the endpoint named "ep0".
 *	drivers discover endpoints through the ep_list of a usb_gadget.
 *
 * When configurations are set, or when interface settings change, the driver
 * will enable or disable the relevant endpoints.  while it is enabled, an
 * endpoint may be used for i/o until the driver receives a disconnect() from
 * the host or until the endpoint is disabled.
 *
 * the ep0 implementation (which calls this routine) must ensure that the
 * hardware capabilities of each endpoint match the descriptor provided
 * for it.  for example, an endpoint named "ep2in-bulk" would be usable
 * for interrupt transfers as well as bulk, but it likely couldn't be used
 * for iso transfers or for endpoint 14.  some endpoints are fully
 * configurable, with more generic names like "ep-a".  (remember that for
 * USB, "in" means "towards the USB master".)
 *
 * returns zero, or a negative error code.
 */
int usb_ep_enable(struct usb_ep *ep)
{
104
	int ret = 0;
105 106

	if (ep->enabled)
107
		goto out;
108 109

	ret = ep->ops->enable(ep, ep->desc);
110 111 112 113
	if (ret) {
		ret = ret;
		goto out;
	}
114 115 116

	ep->enabled = true;

117 118 119 120
out:
	trace_usb_ep_enable(ep, ret);

	return ret;
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
}
EXPORT_SYMBOL_GPL(usb_ep_enable);

/**
 * usb_ep_disable - endpoint is no longer usable
 * @ep:the endpoint being unconfigured.  may not be the endpoint named "ep0".
 *
 * no other task may be using this endpoint when this is called.
 * any pending and uncompleted requests will complete with status
 * indicating disconnect (-ESHUTDOWN) before this call returns.
 * gadget drivers must call usb_ep_enable() again before queueing
 * requests to the endpoint.
 *
 * returns zero, or a negative error code.
 */
int usb_ep_disable(struct usb_ep *ep)
{
138
	int ret = 0;
139 140

	if (!ep->enabled)
141
		goto out;
142 143

	ret = ep->ops->disable(ep);
144 145 146 147
	if (ret) {
		ret = ret;
		goto out;
	}
148 149 150

	ep->enabled = false;

151 152 153 154
out:
	trace_usb_ep_disable(ep, ret);

	return ret;
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
}
EXPORT_SYMBOL_GPL(usb_ep_disable);

/**
 * usb_ep_alloc_request - allocate a request object to use with this endpoint
 * @ep:the endpoint to be used with with the request
 * @gfp_flags:GFP_* flags to use
 *
 * Request objects must be allocated with this call, since they normally
 * need controller-specific setup and may even need endpoint-specific
 * resources such as allocation of DMA descriptors.
 * Requests may be submitted with usb_ep_queue(), and receive a single
 * completion callback.  Free requests with usb_ep_free_request(), when
 * they are no longer needed.
 *
 * Returns the request, or null if one could not be allocated.
 */
struct usb_request *usb_ep_alloc_request(struct usb_ep *ep,
						       gfp_t gfp_flags)
{
175 176 177 178 179 180 181
	struct usb_request *req = NULL;

	req = ep->ops->alloc_request(ep, gfp_flags);

	trace_usb_ep_alloc_request(ep, req, req ? 0 : -ENOMEM);

	return req;
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
}
EXPORT_SYMBOL_GPL(usb_ep_alloc_request);

/**
 * usb_ep_free_request - frees a request object
 * @ep:the endpoint associated with the request
 * @req:the request being freed
 *
 * Reverses the effect of usb_ep_alloc_request().
 * Caller guarantees the request is not queued, and that it will
 * no longer be requeued (or otherwise used).
 */
void usb_ep_free_request(struct usb_ep *ep,
				       struct usb_request *req)
{
	ep->ops->free_request(ep, req);
198
	trace_usb_ep_free_request(ep, req, 0);
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
}
EXPORT_SYMBOL_GPL(usb_ep_free_request);

/**
 * usb_ep_queue - queues (submits) an I/O request to an endpoint.
 * @ep:the endpoint associated with the request
 * @req:the request being submitted
 * @gfp_flags: GFP_* flags to use in case the lower level driver couldn't
 *	pre-allocate all necessary memory with the request.
 *
 * This tells the device controller to perform the specified request through
 * that endpoint (reading or writing a buffer).  When the request completes,
 * including being canceled by usb_ep_dequeue(), the request's completion
 * routine is called to return the request to the driver.  Any endpoint
 * (except control endpoints like ep0) may have more than one transfer
 * request queued; they complete in FIFO order.  Once a gadget driver
 * submits a request, that request may not be examined or modified until it
 * is given back to that driver through the completion callback.
 *
 * Each request is turned into one or more packets.  The controller driver
 * never merges adjacent requests into the same packet.  OUT transfers
 * will sometimes use data that's already buffered in the hardware.
 * Drivers can rely on the fact that the first byte of the request's buffer
 * always corresponds to the first byte of some USB packet, for both
 * IN and OUT transfers.
 *
 * Bulk endpoints can queue any amount of data; the transfer is packetized
 * automatically.  The last packet will be short if the request doesn't fill it
 * out completely.  Zero length packets (ZLPs) should be avoided in portable
 * protocols since not all usb hardware can successfully handle zero length
 * packets.  (ZLPs may be explicitly written, and may be implicitly written if
 * the request 'zero' flag is set.)  Bulk endpoints may also be used
 * for interrupt transfers; but the reverse is not true, and some endpoints
 * won't support every interrupt transfer.  (Such as 768 byte packets.)
 *
 * Interrupt-only endpoints are less functional than bulk endpoints, for
 * example by not supporting queueing or not handling buffers that are
 * larger than the endpoint's maxpacket size.  They may also treat data
 * toggle differently.
 *
 * Control endpoints ... after getting a setup() callback, the driver queues
 * one response (even if it would be zero length).  That enables the
 * status ack, after transferring data as specified in the response.  Setup
 * functions may return negative error codes to generate protocol stalls.
 * (Note that some USB device controllers disallow protocol stall responses
 * in some cases.)  When control responses are deferred (the response is
 * written after the setup callback returns), then usb_ep_set_halt() may be
 * used on ep0 to trigger protocol stalls.  Depending on the controller,
 * it may not be possible to trigger a status-stage protocol stall when the
 * data stage is over, that is, from within the response's completion
 * routine.
 *
 * For periodic endpoints, like interrupt or isochronous ones, the usb host
 * arranges to poll once per interval, and the gadget driver usually will
 * have queued some data to transfer at that time.
 *
 * Returns zero, or a negative error code.  Endpoints that are not enabled
 * report errors; errors will also be
 * reported when the usb peripheral is disconnected.
 */
int usb_ep_queue(struct usb_ep *ep,
			       struct usb_request *req, gfp_t gfp_flags)
{
262 263 264 265 266 267 268 269 270 271 272
	int ret = 0;

	if (WARN_ON_ONCE(!ep->enabled && ep->address)) {
		ret = -ESHUTDOWN;
		goto out;
	}

	ret = ep->ops->queue(ep, req, gfp_flags);

out:
	trace_usb_ep_queue(ep, req, ret);
273

274
	return ret;
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
}
EXPORT_SYMBOL_GPL(usb_ep_queue);

/**
 * usb_ep_dequeue - dequeues (cancels, unlinks) an I/O request from an endpoint
 * @ep:the endpoint associated with the request
 * @req:the request being canceled
 *
 * If the request is still active on the endpoint, it is dequeued and its
 * completion routine is called (with status -ECONNRESET); else a negative
 * error code is returned. This is guaranteed to happen before the call to
 * usb_ep_dequeue() returns.
 *
 * Note that some hardware can't clear out write fifos (to unlink the request
 * at the head of the queue) except as part of disconnecting from usb. Such
 * restrictions prevent drivers from supporting configuration changes,
 * even to configuration zero (a "chapter 9" requirement).
 */
int usb_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
{
295 296 297 298 299 300
	int ret;

	ret = ep->ops->dequeue(ep, req);
	trace_usb_ep_dequeue(ep, req, ret);

	return ret;
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
}
EXPORT_SYMBOL_GPL(usb_ep_dequeue);

/**
 * usb_ep_set_halt - sets the endpoint halt feature.
 * @ep: the non-isochronous endpoint being stalled
 *
 * Use this to stall an endpoint, perhaps as an error report.
 * Except for control endpoints,
 * the endpoint stays halted (will not stream any data) until the host
 * clears this feature; drivers may need to empty the endpoint's request
 * queue first, to make sure no inappropriate transfers happen.
 *
 * Note that while an endpoint CLEAR_FEATURE will be invisible to the
 * gadget driver, a SET_INTERFACE will not be.  To reset endpoints for the
 * current altsetting, see usb_ep_clear_halt().  When switching altsettings,
 * it's simplest to use usb_ep_enable() or usb_ep_disable() for the endpoints.
 *
 * Returns zero, or a negative error code.  On success, this call sets
 * underlying hardware state that blocks data transfers.
 * Attempts to halt IN endpoints will fail (returning -EAGAIN) if any
 * transfer requests are still queued, or if the controller hardware
 * (usually a FIFO) still holds bytes that the host hasn't collected.
 */
int usb_ep_set_halt(struct usb_ep *ep)
{
327 328 329 330 331 332
	int ret;

	ret = ep->ops->set_halt(ep, 1);
	trace_usb_ep_set_halt(ep, ret);

	return ret;
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
}
EXPORT_SYMBOL_GPL(usb_ep_set_halt);

/**
 * usb_ep_clear_halt - clears endpoint halt, and resets toggle
 * @ep:the bulk or interrupt endpoint being reset
 *
 * Use this when responding to the standard usb "set interface" request,
 * for endpoints that aren't reconfigured, after clearing any other state
 * in the endpoint's i/o queue.
 *
 * Returns zero, or a negative error code.  On success, this call clears
 * the underlying hardware state reflecting endpoint halt and data toggle.
 * Note that some hardware can't support this request (like pxa2xx_udc),
 * and accordingly can't correctly implement interface altsettings.
 */
int usb_ep_clear_halt(struct usb_ep *ep)
{
351 352 353 354 355 356
	int ret;

	ret = ep->ops->set_halt(ep, 0);
	trace_usb_ep_clear_halt(ep, ret);

	return ret;
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
}
EXPORT_SYMBOL_GPL(usb_ep_clear_halt);

/**
 * usb_ep_set_wedge - sets the halt feature and ignores clear requests
 * @ep: the endpoint being wedged
 *
 * Use this to stall an endpoint and ignore CLEAR_FEATURE(HALT_ENDPOINT)
 * requests. If the gadget driver clears the halt status, it will
 * automatically unwedge the endpoint.
 *
 * Returns zero on success, else negative errno.
 */
int usb_ep_set_wedge(struct usb_ep *ep)
{
372 373
	int ret;

374
	if (ep->ops->set_wedge)
375
		ret = ep->ops->set_wedge(ep);
376
	else
377 378 379 380 381
		ret = ep->ops->set_halt(ep, 1);

	trace_usb_ep_set_wedge(ep, ret);

	return ret;
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
}
EXPORT_SYMBOL_GPL(usb_ep_set_wedge);

/**
 * usb_ep_fifo_status - returns number of bytes in fifo, or error
 * @ep: the endpoint whose fifo status is being checked.
 *
 * FIFO endpoints may have "unclaimed data" in them in certain cases,
 * such as after aborted transfers.  Hosts may not have collected all
 * the IN data written by the gadget driver (and reported by a request
 * completion).  The gadget driver may not have collected all the data
 * written OUT to it by the host.  Drivers that need precise handling for
 * fault reporting or recovery may need to use this call.
 *
 * This returns the number of such bytes in the fifo, or a negative
 * errno if the endpoint doesn't use a FIFO or doesn't support such
 * precise handling.
 */
int usb_ep_fifo_status(struct usb_ep *ep)
{
402 403
	int ret;

404
	if (ep->ops->fifo_status)
405
		ret = ep->ops->fifo_status(ep);
406
	else
407 408 409 410 411
		ret = -EOPNOTSUPP;

	trace_usb_ep_fifo_status(ep, ret);

	return ret;
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
}
EXPORT_SYMBOL_GPL(usb_ep_fifo_status);

/**
 * usb_ep_fifo_flush - flushes contents of a fifo
 * @ep: the endpoint whose fifo is being flushed.
 *
 * This call may be used to flush the "unclaimed data" that may exist in
 * an endpoint fifo after abnormal transaction terminations.  The call
 * must never be used except when endpoint is not being used for any
 * protocol translation.
 */
void usb_ep_fifo_flush(struct usb_ep *ep)
{
	if (ep->ops->fifo_flush)
		ep->ops->fifo_flush(ep);
428 429

	trace_usb_ep_fifo_flush(ep, 0);
430 431 432 433 434 435 436 437 438 439 440 441 442 443
}
EXPORT_SYMBOL_GPL(usb_ep_fifo_flush);

/* ------------------------------------------------------------------------- */

/**
 * usb_gadget_frame_number - returns the current frame number
 * @gadget: controller that reports the frame number
 *
 * Returns the usb frame number, normally eleven bits from a SOF packet,
 * or negative errno if this device doesn't support this capability.
 */
int usb_gadget_frame_number(struct usb_gadget *gadget)
{
444 445 446 447 448 449 450
	int ret;

	ret = gadget->ops->get_frame(gadget);

	trace_usb_gadget_frame_number(gadget, ret);

	return ret;
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
}
EXPORT_SYMBOL_GPL(usb_gadget_frame_number);

/**
 * usb_gadget_wakeup - tries to wake up the host connected to this gadget
 * @gadget: controller used to wake up the host
 *
 * Returns zero on success, else negative error code if the hardware
 * doesn't support such attempts, or its support has not been enabled
 * by the usb host.  Drivers must return device descriptors that report
 * their ability to support this, or hosts won't enable it.
 *
 * This may also try to use SRP to wake the host and start enumeration,
 * even if OTG isn't otherwise in use.  OTG devices may also start
 * remote wakeup even when hosts don't explicitly enable it.
 */
int usb_gadget_wakeup(struct usb_gadget *gadget)
{
469 470 471 472 473 474 475 476 477 478 479 480 481
	int ret = 0;

	if (!gadget->ops->wakeup) {
		ret = -EOPNOTSUPP;
		goto out;
	}

	ret = gadget->ops->wakeup(gadget);

out:
	trace_usb_gadget_wakeup(gadget, ret);

	return ret;
482 483 484 485 486 487 488 489 490 491 492 493 494 495
}
EXPORT_SYMBOL_GPL(usb_gadget_wakeup);

/**
 * usb_gadget_set_selfpowered - sets the device selfpowered feature.
 * @gadget:the device being declared as self-powered
 *
 * this affects the device status reported by the hardware driver
 * to reflect that it now has a local power supply.
 *
 * returns zero on success, else negative errno.
 */
int usb_gadget_set_selfpowered(struct usb_gadget *gadget)
{
496 497 498 499 500 501 502 503 504 505 506 507 508
	int ret = 0;

	if (!gadget->ops->set_selfpowered) {
		ret = -EOPNOTSUPP;
		goto out;
	}

	ret = gadget->ops->set_selfpowered(gadget, 1);

out:
	trace_usb_gadget_set_selfpowered(gadget, ret);

	return ret;
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
}
EXPORT_SYMBOL_GPL(usb_gadget_set_selfpowered);

/**
 * usb_gadget_clear_selfpowered - clear the device selfpowered feature.
 * @gadget:the device being declared as bus-powered
 *
 * this affects the device status reported by the hardware driver.
 * some hardware may not support bus-powered operation, in which
 * case this feature's value can never change.
 *
 * returns zero on success, else negative errno.
 */
int usb_gadget_clear_selfpowered(struct usb_gadget *gadget)
{
524 525 526 527 528 529 530 531 532 533 534 535 536
	int ret = 0;

	if (!gadget->ops->set_selfpowered) {
		ret = -EOPNOTSUPP;
		goto out;
	}

	ret = gadget->ops->set_selfpowered(gadget, 0);

out:
	trace_usb_gadget_clear_selfpowered(gadget, ret);

	return ret;
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
}
EXPORT_SYMBOL_GPL(usb_gadget_clear_selfpowered);

/**
 * usb_gadget_vbus_connect - Notify controller that VBUS is powered
 * @gadget:The device which now has VBUS power.
 * Context: can sleep
 *
 * This call is used by a driver for an external transceiver (or GPIO)
 * that detects a VBUS power session starting.  Common responses include
 * resuming the controller, activating the D+ (or D-) pullup to let the
 * host detect that a USB device is attached, and starting to draw power
 * (8mA or possibly more, especially after SET_CONFIGURATION).
 *
 * Returns zero on success, else negative errno.
 */
int usb_gadget_vbus_connect(struct usb_gadget *gadget)
{
555 556 557 558 559 560 561 562 563 564 565 566 567
	int ret = 0;

	if (!gadget->ops->vbus_session) {
		ret = -EOPNOTSUPP;
		goto out;
	}

	ret = gadget->ops->vbus_session(gadget, 1);

out:
	trace_usb_gadget_vbus_connect(gadget, ret);

	return ret;
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
}
EXPORT_SYMBOL_GPL(usb_gadget_vbus_connect);

/**
 * usb_gadget_vbus_draw - constrain controller's VBUS power usage
 * @gadget:The device whose VBUS usage is being described
 * @mA:How much current to draw, in milliAmperes.  This should be twice
 *	the value listed in the configuration descriptor bMaxPower field.
 *
 * This call is used by gadget drivers during SET_CONFIGURATION calls,
 * reporting how much power the device may consume.  For example, this
 * could affect how quickly batteries are recharged.
 *
 * Returns zero on success, else negative errno.
 */
int usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
{
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
	int ret = 0;

	if (!gadget->ops->vbus_draw) {
		ret = -EOPNOTSUPP;
		goto out;
	}

	ret = gadget->ops->vbus_draw(gadget, mA);
	if (!ret)
		gadget->mA = mA;

out:
	trace_usb_gadget_vbus_draw(gadget, ret);

	return ret;
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
}
EXPORT_SYMBOL_GPL(usb_gadget_vbus_draw);

/**
 * usb_gadget_vbus_disconnect - notify controller about VBUS session end
 * @gadget:the device whose VBUS supply is being described
 * Context: can sleep
 *
 * This call is used by a driver for an external transceiver (or GPIO)
 * that detects a VBUS power session ending.  Common responses include
 * reversing everything done in usb_gadget_vbus_connect().
 *
 * Returns zero on success, else negative errno.
 */
int usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
{
616 617 618 619 620 621 622 623 624 625 626 627 628
	int ret = 0;

	if (!gadget->ops->vbus_session) {
		ret = -EOPNOTSUPP;
		goto out;
	}

	ret = gadget->ops->vbus_session(gadget, 0);

out:
	trace_usb_gadget_vbus_disconnect(gadget, ret);

	return ret;
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
}
EXPORT_SYMBOL_GPL(usb_gadget_vbus_disconnect);

/**
 * usb_gadget_connect - software-controlled connect to USB host
 * @gadget:the peripheral being connected
 *
 * Enables the D+ (or potentially D-) pullup.  The host will start
 * enumerating this gadget when the pullup is active and a VBUS session
 * is active (the link is powered).  This pullup is always enabled unless
 * usb_gadget_disconnect() has been used to disable it.
 *
 * Returns zero on success, else negative errno.
 */
int usb_gadget_connect(struct usb_gadget *gadget)
{
645
	int ret = 0;
646

647 648 649 650
	if (!gadget->ops->pullup) {
		ret = -EOPNOTSUPP;
		goto out;
	}
651 652 653 654 655 656 657

	if (gadget->deactivated) {
		/*
		 * If gadget is deactivated we only save new state.
		 * Gadget will be connected automatically after activation.
		 */
		gadget->connected = true;
658
		goto out;
659 660 661 662 663
	}

	ret = gadget->ops->pullup(gadget, 1);
	if (!ret)
		gadget->connected = 1;
664 665 666 667

out:
	trace_usb_gadget_connect(gadget, ret);

668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
	return ret;
}
EXPORT_SYMBOL_GPL(usb_gadget_connect);

/**
 * usb_gadget_disconnect - software-controlled disconnect from USB host
 * @gadget:the peripheral being disconnected
 *
 * Disables the D+ (or potentially D-) pullup, which the host may see
 * as a disconnect (when a VBUS session is active).  Not all systems
 * support software pullup controls.
 *
 * Returns zero on success, else negative errno.
 */
int usb_gadget_disconnect(struct usb_gadget *gadget)
{
684
	int ret = 0;
685

686 687 688 689
	if (!gadget->ops->pullup) {
		ret = -EOPNOTSUPP;
		goto out;
	}
690 691 692 693 694 695 696

	if (gadget->deactivated) {
		/*
		 * If gadget is deactivated we only save new state.
		 * Gadget will stay disconnected after activation.
		 */
		gadget->connected = false;
697
		goto out;
698 699 700 701 702
	}

	ret = gadget->ops->pullup(gadget, 0);
	if (!ret)
		gadget->connected = 0;
703 704 705 706

out:
	trace_usb_gadget_disconnect(gadget, ret);

707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723
	return ret;
}
EXPORT_SYMBOL_GPL(usb_gadget_disconnect);

/**
 * usb_gadget_deactivate - deactivate function which is not ready to work
 * @gadget: the peripheral being deactivated
 *
 * This routine may be used during the gadget driver bind() call to prevent
 * the peripheral from ever being visible to the USB host, unless later
 * usb_gadget_activate() is called.  For example, user mode components may
 * need to be activated before the system can talk to hosts.
 *
 * Returns zero on success, else negative errno.
 */
int usb_gadget_deactivate(struct usb_gadget *gadget)
{
724
	int ret = 0;
725 726

	if (gadget->deactivated)
727
		goto out;
728 729 730 731

	if (gadget->connected) {
		ret = usb_gadget_disconnect(gadget);
		if (ret)
732 733
			goto out;

734 735 736 737 738 739 740 741
		/*
		 * If gadget was being connected before deactivation, we want
		 * to reconnect it in usb_gadget_activate().
		 */
		gadget->connected = true;
	}
	gadget->deactivated = true;

742 743 744 745
out:
	trace_usb_gadget_deactivate(gadget, ret);

	return ret;
746 747 748 749 750 751 752 753 754 755 756 757 758 759
}
EXPORT_SYMBOL_GPL(usb_gadget_deactivate);

/**
 * usb_gadget_activate - activate function which is not ready to work
 * @gadget: the peripheral being activated
 *
 * This routine activates gadget which was previously deactivated with
 * usb_gadget_deactivate() call. It calls usb_gadget_connect() if needed.
 *
 * Returns zero on success, else negative errno.
 */
int usb_gadget_activate(struct usb_gadget *gadget)
{
760 761
	int ret = 0;

762
	if (!gadget->deactivated)
763
		goto out;
764 765 766 767 768 769 770 771

	gadget->deactivated = false;

	/*
	 * If gadget has been connected before deactivation, or became connected
	 * while it was being deactivated, we call usb_gadget_connect().
	 */
	if (gadget->connected)
772
		ret = usb_gadget_connect(gadget);
773

774 775 776 777
out:
	trace_usb_gadget_activate(gadget, ret);

	return ret;
778 779 780 781 782
}
EXPORT_SYMBOL_GPL(usb_gadget_activate);

/* ------------------------------------------------------------------------- */

783 784
#ifdef	CONFIG_HAS_DMA

785
int usb_gadget_map_request_by_dev(struct device *dev,
786 787 788 789 790 791 792 793
		struct usb_request *req, int is_in)
{
	if (req->length == 0)
		return 0;

	if (req->num_sgs) {
		int     mapped;

794
		mapped = dma_map_sg(dev, req->sg, req->num_sgs,
795 796
				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
		if (mapped == 0) {
797
			dev_err(dev, "failed to map SGs\n");
798 799 800 801 802
			return -EFAULT;
		}

		req->num_mapped_sgs = mapped;
	} else {
803
		req->dma = dma_map_single(dev, req->buf, req->length,
804 805
				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);

806 807
		if (dma_mapping_error(dev, req->dma)) {
			dev_err(dev, "failed to map buffer\n");
808 809 810 811 812 813
			return -EFAULT;
		}
	}

	return 0;
}
814 815 816 817 818 819 820
EXPORT_SYMBOL_GPL(usb_gadget_map_request_by_dev);

int usb_gadget_map_request(struct usb_gadget *gadget,
		struct usb_request *req, int is_in)
{
	return usb_gadget_map_request_by_dev(gadget->dev.parent, req, is_in);
}
821 822
EXPORT_SYMBOL_GPL(usb_gadget_map_request);

823
void usb_gadget_unmap_request_by_dev(struct device *dev,
824 825 826 827 828 829
		struct usb_request *req, int is_in)
{
	if (req->length == 0)
		return;

	if (req->num_mapped_sgs) {
830
		dma_unmap_sg(dev, req->sg, req->num_mapped_sgs,
831 832 833 834
				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);

		req->num_mapped_sgs = 0;
	} else {
835
		dma_unmap_single(dev, req->dma, req->length,
836 837 838
				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
	}
}
839 840 841 842 843 844 845
EXPORT_SYMBOL_GPL(usb_gadget_unmap_request_by_dev);

void usb_gadget_unmap_request(struct usb_gadget *gadget,
		struct usb_request *req, int is_in)
{
	usb_gadget_unmap_request_by_dev(gadget->dev.parent, req, is_in);
}
846 847
EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);

848 849
#endif	/* CONFIG_HAS_DMA */

850 851
/* ------------------------------------------------------------------------- */

852 853 854 855 856 857 858 859 860 861
/**
 * usb_gadget_giveback_request - give the request back to the gadget layer
 * Context: in_interrupt()
 *
 * This is called by device controller drivers in order to return the
 * completed request back to the gadget layer.
 */
void usb_gadget_giveback_request(struct usb_ep *ep,
		struct usb_request *req)
{
862 863 864
	if (likely(req->status == 0))
		usb_led_activity(USB_LED_EVENT_GADGET);

865 866
	trace_usb_gadget_giveback_request(ep, req, 0);

867 868 869 870 871 872
	req->complete(ep, req);
}
EXPORT_SYMBOL_GPL(usb_gadget_giveback_request);

/* ------------------------------------------------------------------------- */

873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893
/**
 * gadget_find_ep_by_name - returns ep whose name is the same as sting passed
 *	in second parameter or NULL if searched endpoint not found
 * @g: controller to check for quirk
 * @name: name of searched endpoint
 */
struct usb_ep *gadget_find_ep_by_name(struct usb_gadget *g, const char *name)
{
	struct usb_ep *ep;

	gadget_for_each_ep(ep, g) {
		if (!strcmp(ep->name, name))
			return ep;
	}

	return NULL;
}
EXPORT_SYMBOL_GPL(gadget_find_ep_by_name);

/* ------------------------------------------------------------------------- */

894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
int usb_gadget_ep_match_desc(struct usb_gadget *gadget,
		struct usb_ep *ep, struct usb_endpoint_descriptor *desc,
		struct usb_ss_ep_comp_descriptor *ep_comp)
{
	u8		type;
	u16		max;
	int		num_req_streams = 0;

	/* endpoint already claimed? */
	if (ep->claimed)
		return 0;

	type = usb_endpoint_type(desc);
	max = 0x7ff & usb_endpoint_maxp(desc);

	if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in)
		return 0;
	if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out)
		return 0;

	if (max > ep->maxpacket_limit)
		return 0;

	/* "high bandwidth" works only at high speed */
	if (!gadget_is_dualspeed(gadget) && usb_endpoint_maxp(desc) & (3<<11))
		return 0;

	switch (type) {
	case USB_ENDPOINT_XFER_CONTROL:
		/* only support ep0 for portable CONTROL traffic */
		return 0;
	case USB_ENDPOINT_XFER_ISOC:
		if (!ep->caps.type_iso)
			return 0;
		/* ISO:  limit 1023 bytes full speed, 1024 high/super speed */
		if (!gadget_is_dualspeed(gadget) && max > 1023)
			return 0;
		break;
	case USB_ENDPOINT_XFER_BULK:
		if (!ep->caps.type_bulk)
			return 0;
		if (ep_comp && gadget_is_superspeed(gadget)) {
			/* Get the number of required streams from the
			 * EP companion descriptor and see if the EP
			 * matches it
			 */
			num_req_streams = ep_comp->bmAttributes & 0x1f;
			if (num_req_streams > ep->max_streams)
				return 0;
		}
		break;
	case USB_ENDPOINT_XFER_INT:
		/* Bulk endpoints handle interrupt transfers,
		 * except the toggle-quirky iso-synch kind
		 */
		if (!ep->caps.type_int && !ep->caps.type_bulk)
			return 0;
		/* INT:  limit 64 bytes full speed, 1024 high/super speed */
		if (!gadget_is_dualspeed(gadget) && max > 64)
			return 0;
		break;
	}

	return 1;
}
EXPORT_SYMBOL_GPL(usb_gadget_ep_match_desc);

/* ------------------------------------------------------------------------- */

963 964
static void usb_gadget_state_work(struct work_struct *work)
{
965 966
	struct usb_gadget *gadget = work_to_gadget(work);
	struct usb_udc *udc = gadget->udc;
967

968 969
	if (udc)
		sysfs_notify(&udc->dev.kobj, NULL, "state");
970 971
}

972 973 974 975
void usb_gadget_set_state(struct usb_gadget *gadget,
		enum usb_device_state state)
{
	gadget->state = state;
976
	schedule_work(&gadget->work);
977 978 979 980 981
}
EXPORT_SYMBOL_GPL(usb_gadget_set_state);

/* ------------------------------------------------------------------------- */

P
Peter Chen 已提交
982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
static void usb_udc_connect_control(struct usb_udc *udc)
{
	if (udc->vbus)
		usb_gadget_connect(udc->gadget);
	else
		usb_gadget_disconnect(udc->gadget);
}

/**
 * usb_udc_vbus_handler - updates the udc core vbus status, and try to
 * connect or disconnect gadget
 * @gadget: The gadget which vbus change occurs
 * @status: The vbus status
 *
 * The udc driver calls it when it wants to connect or disconnect gadget
 * according to vbus status.
 */
void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status)
{
	struct usb_udc *udc = gadget->udc;

	if (udc) {
		udc->vbus = status;
		usb_udc_connect_control(udc);
	}
}
EXPORT_SYMBOL_GPL(usb_udc_vbus_handler);

1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
/**
 * usb_gadget_udc_reset - notifies the udc core that bus reset occurs
 * @gadget: The gadget which bus reset occurs
 * @driver: The gadget driver we want to notify
 *
 * If the udc driver has bus reset handler, it needs to call this when the bus
 * reset occurs, it notifies the gadget driver that the bus reset occurs as
 * well as updates gadget state.
 */
void usb_gadget_udc_reset(struct usb_gadget *gadget,
		struct usb_gadget_driver *driver)
{
	driver->reset(gadget);
	usb_gadget_set_state(gadget, USB_STATE_DEFAULT);
}
EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);

1027 1028
/**
 * usb_gadget_udc_start - tells usb device controller to start up
1029
 * @udc: The UDC to be started
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
 *
 * This call is issued by the UDC Class driver when it's about
 * to register a gadget driver to the device controller, before
 * calling gadget driver's bind() method.
 *
 * It allows the controller to be powered off until strictly
 * necessary to have it powered on.
 *
 * Returns zero on success, else negative errno.
 */
1040
static inline int usb_gadget_udc_start(struct usb_udc *udc)
1041
{
1042
	return udc->gadget->ops->udc_start(udc->gadget, udc->driver);
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
}

/**
 * usb_gadget_udc_stop - tells usb device controller we don't need it anymore
 * @gadget: The device we want to stop activity
 * @driver: The driver to unbind from @gadget
 *
 * This call is issued by the UDC Class driver after calling
 * gadget driver's unbind() method.
 *
 * The details are implementation specific, but it can go as
 * far as powering off UDC completely and disable its data
 * line pullups.
 */
1057
static inline void usb_gadget_udc_stop(struct usb_udc *udc)
1058
{
1059
	udc->gadget->ops->udc_stop(udc->gadget);
1060 1061
}

F
Felipe Balbi 已提交
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
/**
 * usb_udc_release - release the usb_udc struct
 * @dev: the dev member within usb_udc
 *
 * This is called by driver's core in order to free memory once the last
 * reference is released.
 */
static void usb_udc_release(struct device *dev)
{
	struct usb_udc *udc;

	udc = container_of(dev, struct usb_udc, dev);
	dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
	kfree(udc);
}

1078
static const struct attribute_group *usb_udc_attr_groups[];
1079 1080 1081 1082 1083 1084

static void usb_udc_nop_release(struct device *dev)
{
	dev_vdbg(dev, "%s\n", __func__);
}

F
Felipe Balbi 已提交
1085
/**
1086 1087 1088 1089 1090
 * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
 * @parent: the parent device to this udc. Usually the controller driver's
 * device.
 * @gadget: the gadget to be added to the list.
 * @release: a gadget release function.
F
Felipe Balbi 已提交
1091 1092 1093
 *
 * Returns zero on success, negative errno otherwise.
 */
1094 1095
int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
		void (*release)(struct device *dev))
F
Felipe Balbi 已提交
1096 1097
{
	struct usb_udc		*udc;
1098
	struct usb_gadget_driver *driver;
F
Felipe Balbi 已提交
1099 1100 1101 1102 1103 1104
	int			ret = -ENOMEM;

	udc = kzalloc(sizeof(*udc), GFP_KERNEL);
	if (!udc)
		goto err1;

1105
	dev_set_name(&gadget->dev, "gadget");
1106
	INIT_WORK(&gadget->work, usb_gadget_state_work);
1107
	gadget->dev.parent = parent;
1108

1109
	if (release)
1110
		gadget->dev.release = release;
1111 1112
	else
		gadget->dev.release = usb_udc_nop_release;
1113

1114 1115 1116
	ret = device_register(&gadget->dev);
	if (ret)
		goto err2;
1117

F
Felipe Balbi 已提交
1118 1119 1120
	device_initialize(&udc->dev);
	udc->dev.release = usb_udc_release;
	udc->dev.class = udc_class;
1121
	udc->dev.groups = usb_udc_attr_groups;
F
Felipe Balbi 已提交
1122 1123 1124
	udc->dev.parent = parent;
	ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
	if (ret)
1125
		goto err3;
F
Felipe Balbi 已提交
1126 1127

	udc->gadget = gadget;
1128
	gadget->udc = udc;
F
Felipe Balbi 已提交
1129 1130 1131 1132 1133 1134

	mutex_lock(&udc_lock);
	list_add_tail(&udc->list, &udc_list);

	ret = device_add(&udc->dev);
	if (ret)
1135
		goto err4;
F
Felipe Balbi 已提交
1136

1137
	usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
P
Peter Chen 已提交
1138
	udc->vbus = true;
F
Felipe Balbi 已提交
1139

1140 1141 1142 1143 1144
	/* pick up one of pending gadget drivers */
	list_for_each_entry(driver, &gadget_driver_pending_list, pending) {
		if (!driver->udc_name || strcmp(driver->udc_name,
						dev_name(&udc->dev)) == 0) {
			ret = udc_bind_to_driver(udc, driver);
1145 1146
			if (ret != -EPROBE_DEFER)
				list_del(&driver->pending);
1147
			if (ret)
P
Peter Chen 已提交
1148
				goto err5;
1149 1150 1151 1152
			break;
		}
	}

F
Felipe Balbi 已提交
1153 1154 1155
	mutex_unlock(&udc_lock);

	return 0;
1156

P
Peter Chen 已提交
1157 1158 1159
err5:
	device_del(&udc->dev);

1160
err4:
F
Felipe Balbi 已提交
1161 1162 1163
	list_del(&udc->list);
	mutex_unlock(&udc_lock);

1164
err3:
F
Felipe Balbi 已提交
1165
	put_device(&udc->dev);
1166
	device_del(&gadget->dev);
F
Felipe Balbi 已提交
1167

1168
err2:
1169
	put_device(&gadget->dev);
1170
	kfree(udc);
1171

F
Felipe Balbi 已提交
1172 1173 1174
err1:
	return ret;
}
1175 1176
EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release);

1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
/**
 * usb_get_gadget_udc_name - get the name of the first UDC controller
 * This functions returns the name of the first UDC controller in the system.
 * Please note that this interface is usefull only for legacy drivers which
 * assume that there is only one UDC controller in the system and they need to
 * get its name before initialization. There is no guarantee that the UDC
 * of the returned name will be still available, when gadget driver registers
 * itself.
 *
 * Returns pointer to string with UDC controller name on success, NULL
 * otherwise. Caller should kfree() returned string.
 */
char *usb_get_gadget_udc_name(void)
{
	struct usb_udc *udc;
	char *name = NULL;

	/* For now we take the first available UDC */
	mutex_lock(&udc_lock);
	list_for_each_entry(udc, &udc_list, list) {
		if (!udc->driver) {
			name = kstrdup(udc->gadget->name, GFP_KERNEL);
			break;
		}
	}
	mutex_unlock(&udc_lock);
	return name;
}
EXPORT_SYMBOL_GPL(usb_get_gadget_udc_name);

1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
/**
 * usb_add_gadget_udc - adds a new gadget to the udc class driver list
 * @parent: the parent device to this udc. Usually the controller
 * driver's device.
 * @gadget: the gadget to be added to the list
 *
 * Returns zero on success, negative errno otherwise.
 */
int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
{
	return usb_add_gadget_udc_release(parent, gadget, NULL);
}
F
Felipe Balbi 已提交
1219 1220 1221 1222 1223
EXPORT_SYMBOL_GPL(usb_add_gadget_udc);

static void usb_gadget_remove_driver(struct usb_udc *udc)
{
	dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n",
1224
			udc->driver->function);
F
Felipe Balbi 已提交
1225 1226 1227

	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);

1228 1229 1230
	usb_gadget_disconnect(udc->gadget);
	udc->driver->disconnect(udc->gadget);
	udc->driver->unbind(udc->gadget);
1231
	usb_gadget_udc_stop(udc);
F
Felipe Balbi 已提交
1232 1233 1234

	udc->driver = NULL;
	udc->dev.driver = NULL;
1235
	udc->gadget->dev.driver = NULL;
F
Felipe Balbi 已提交
1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
}

/**
 * usb_del_gadget_udc - deletes @udc from udc_list
 * @gadget: the gadget to be removed.
 *
 * This, will call usb_gadget_unregister_driver() if
 * the @udc is still busy.
 */
void usb_del_gadget_udc(struct usb_gadget *gadget)
{
1247
	struct usb_udc *udc = gadget->udc;
F
Felipe Balbi 已提交
1248

1249 1250
	if (!udc)
		return;
F
Felipe Balbi 已提交
1251 1252 1253

	dev_vdbg(gadget->dev.parent, "unregistering gadget\n");

1254
	mutex_lock(&udc_lock);
F
Felipe Balbi 已提交
1255 1256
	list_del(&udc->list);

1257 1258 1259
	if (udc->driver) {
		struct usb_gadget_driver *driver = udc->driver;

F
Felipe Balbi 已提交
1260
		usb_gadget_remove_driver(udc);
1261 1262 1263
		list_add(&driver->pending, &gadget_driver_pending_list);
	}
	mutex_unlock(&udc_lock);
F
Felipe Balbi 已提交
1264 1265

	kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
1266
	flush_work(&gadget->work);
F
Felipe Balbi 已提交
1267
	device_unregister(&udc->dev);
1268
	device_unregister(&gadget->dev);
F
Felipe Balbi 已提交
1269 1270 1271 1272 1273
}
EXPORT_SYMBOL_GPL(usb_del_gadget_udc);

/* ------------------------------------------------------------------------- */

1274
static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver)
F
Felipe Balbi 已提交
1275
{
1276
	int ret;
F
Felipe Balbi 已提交
1277 1278 1279 1280 1281 1282

	dev_dbg(&udc->dev, "registering UDC driver [%s]\n",
			driver->function);

	udc->driver = driver;
	udc->dev.driver = &driver->driver;
1283
	udc->gadget->dev.driver = &driver->driver;
F
Felipe Balbi 已提交
1284

1285 1286 1287
	ret = driver->bind(udc->gadget, driver);
	if (ret)
		goto err1;
1288
	ret = usb_gadget_udc_start(udc);
1289 1290 1291
	if (ret) {
		driver->unbind(udc->gadget);
		goto err1;
1292
	}
P
Peter Chen 已提交
1293
	usb_udc_connect_control(udc);
F
Felipe Balbi 已提交
1294 1295 1296 1297

	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
	return 0;
err1:
1298 1299
	if (ret != -EISNAM)
		dev_err(&udc->dev, "failed to start %s: %d\n",
F
Felipe Balbi 已提交
1300 1301 1302
			udc->driver->function, ret);
	udc->driver = NULL;
	udc->dev.driver = NULL;
1303
	udc->gadget->dev.driver = NULL;
1304 1305 1306 1307 1308 1309
	return ret;
}

int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
{
	struct usb_udc		*udc = NULL;
1310
	int			ret = -ENODEV;
1311 1312 1313 1314 1315

	if (!driver || !driver->bind || !driver->setup)
		return -EINVAL;

	mutex_lock(&udc_lock);
1316 1317 1318 1319 1320 1321
	if (driver->udc_name) {
		list_for_each_entry(udc, &udc_list, list) {
			ret = strcmp(driver->udc_name, dev_name(&udc->dev));
			if (!ret)
				break;
		}
1322
		if (!ret && !udc->driver)
1323
			goto found;
1324 1325 1326 1327 1328 1329
	} else {
		list_for_each_entry(udc, &udc_list, list) {
			/* For now we take the first one */
			if (!udc->driver)
				goto found;
		}
1330 1331
	}

1332 1333 1334 1335 1336 1337 1338
	if (!driver->match_existing_only) {
		list_add_tail(&driver->pending, &gadget_driver_pending_list);
		pr_info("udc-core: couldn't find an available UDC - added [%s] to list of pending drivers\n",
			driver->function);
		ret = 0;
	}

1339
	mutex_unlock(&udc_lock);
1340
	return ret;
1341 1342
found:
	ret = udc_bind_to_driver(udc, driver);
F
Felipe Balbi 已提交
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
	mutex_unlock(&udc_lock);
	return ret;
}
EXPORT_SYMBOL_GPL(usb_gadget_probe_driver);

int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
{
	struct usb_udc		*udc = NULL;
	int			ret = -ENODEV;

	if (!driver || !driver->unbind)
		return -EINVAL;

	mutex_lock(&udc_lock);
	list_for_each_entry(udc, &udc_list, list)
		if (udc->driver == driver) {
			usb_gadget_remove_driver(udc);
1360 1361
			usb_gadget_set_state(udc->gadget,
					USB_STATE_NOTATTACHED);
F
Felipe Balbi 已提交
1362 1363 1364 1365
			ret = 0;
			break;
		}

1366 1367 1368 1369
	if (ret) {
		list_del(&driver->pending);
		ret = 0;
	}
F
Felipe Balbi 已提交
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
	mutex_unlock(&udc_lock);
	return ret;
}
EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);

/* ------------------------------------------------------------------------- */

static ssize_t usb_udc_srp_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t n)
{
1380
	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev);
F
Felipe Balbi 已提交
1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391

	if (sysfs_streq(buf, "1"))
		usb_gadget_wakeup(udc->gadget);

	return n;
}
static DEVICE_ATTR(srp, S_IWUSR, NULL, usb_udc_srp_store);

static ssize_t usb_udc_softconn_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t n)
{
1392
	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev);
F
Felipe Balbi 已提交
1393

1394 1395 1396 1397 1398
	if (!udc->driver) {
		dev_err(dev, "soft-connect without a gadget driver\n");
		return -EOPNOTSUPP;
	}

F
Felipe Balbi 已提交
1399
	if (sysfs_streq(buf, "connect")) {
1400
		usb_gadget_udc_start(udc);
F
Felipe Balbi 已提交
1401 1402
		usb_gadget_connect(udc->gadget);
	} else if (sysfs_streq(buf, "disconnect")) {
1403
		usb_gadget_disconnect(udc->gadget);
1404
		udc->driver->disconnect(udc->gadget);
1405
		usb_gadget_udc_stop(udc);
F
Felipe Balbi 已提交
1406 1407 1408 1409 1410 1411 1412 1413 1414
	} else {
		dev_err(dev, "unsupported command '%s'\n", buf);
		return -EINVAL;
	}

	return n;
}
static DEVICE_ATTR(soft_connect, S_IWUSR, NULL, usb_udc_softconn_store);

1415 1416
static ssize_t state_show(struct device *dev, struct device_attribute *attr,
			  char *buf)
1417 1418 1419 1420 1421 1422
{
	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev);
	struct usb_gadget	*gadget = udc->gadget;

	return sprintf(buf, "%s\n", usb_state_string(gadget->state));
}
1423
static DEVICE_ATTR_RO(state);
1424

1425
#define USB_UDC_SPEED_ATTR(name, param)					\
1426
ssize_t name##_show(struct device *dev,					\
1427 1428 1429 1430 1431 1432
		struct device_attribute *attr, char *buf)		\
{									\
	struct usb_udc *udc = container_of(dev, struct usb_udc, dev);	\
	return snprintf(buf, PAGE_SIZE, "%s\n",				\
			usb_speed_string(udc->gadget->param));		\
}									\
1433
static DEVICE_ATTR_RO(name)
1434 1435 1436 1437

static USB_UDC_SPEED_ATTR(current_speed, speed);
static USB_UDC_SPEED_ATTR(maximum_speed, max_speed);

F
Felipe Balbi 已提交
1438
#define USB_UDC_ATTR(name)					\
1439
ssize_t name##_show(struct device *dev,				\
F
Felipe Balbi 已提交
1440 1441
		struct device_attribute *attr, char *buf)	\
{								\
1442
	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev); \
F
Felipe Balbi 已提交
1443 1444 1445 1446
	struct usb_gadget	*gadget = udc->gadget;		\
								\
	return snprintf(buf, PAGE_SIZE, "%d\n", gadget->name);	\
}								\
1447
static DEVICE_ATTR_RO(name)
F
Felipe Balbi 已提交
1448 1449 1450 1451 1452 1453

static USB_UDC_ATTR(is_otg);
static USB_UDC_ATTR(is_a_peripheral);
static USB_UDC_ATTR(b_hnp_enable);
static USB_UDC_ATTR(a_hnp_support);
static USB_UDC_ATTR(a_alt_hnp_support);
1454
static USB_UDC_ATTR(is_selfpowered);
F
Felipe Balbi 已提交
1455 1456 1457 1458

static struct attribute *usb_udc_attrs[] = {
	&dev_attr_srp.attr,
	&dev_attr_soft_connect.attr,
1459
	&dev_attr_state.attr,
1460 1461
	&dev_attr_current_speed.attr,
	&dev_attr_maximum_speed.attr,
F
Felipe Balbi 已提交
1462 1463 1464 1465 1466 1467

	&dev_attr_is_otg.attr,
	&dev_attr_is_a_peripheral.attr,
	&dev_attr_b_hnp_enable.attr,
	&dev_attr_a_hnp_support.attr,
	&dev_attr_a_alt_hnp_support.attr,
1468
	&dev_attr_is_selfpowered.attr,
F
Felipe Balbi 已提交
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
	NULL,
};

static const struct attribute_group usb_udc_attr_group = {
	.attrs = usb_udc_attrs,
};

static const struct attribute_group *usb_udc_attr_groups[] = {
	&usb_udc_attr_group,
	NULL,
};

static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev);
	int			ret;

	ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);
	if (ret) {
		dev_err(dev, "failed to add uevent USB_UDC_NAME\n");
		return ret;
	}

	if (udc->driver) {
		ret = add_uevent_var(env, "USB_UDC_DRIVER=%s",
				udc->driver->function);
		if (ret) {
			dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n");
			return ret;
		}
	}

	return 0;
}

static int __init usb_udc_init(void)
{
	udc_class = class_create(THIS_MODULE, "udc");
	if (IS_ERR(udc_class)) {
		pr_err("failed to create udc class --> %ld\n",
				PTR_ERR(udc_class));
		return PTR_ERR(udc_class);
	}

	udc_class->dev_uevent = usb_udc_uevent;
	return 0;
}
subsys_initcall(usb_udc_init);

static void __exit usb_udc_exit(void)
{
	class_destroy(udc_class);
}
module_exit(usb_udc_exit);

MODULE_DESCRIPTION("UDC Framework");
MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
MODULE_LICENSE("GPL v2");