1 // SPDX-License-Identifier: GPL-2.0
3  * udc.c - Core UDC Framework
17 #include <linux/dma-mapping.h>
32  * struct usb_udc - describes one usb device controller
44  * @connect_lock: protects udc->started, gadget->connect,
45  * gadget->allow_connect and gadget->deactivate. The routines
50  * This represents the internal data structure which is used by the UDC-class
68 /* Protects udc_list, udc->driver, driver->is_bound, and related calls */
71 /* ------------------------------------------------------------------------- */
74  * usb_ep_set_maxpacket_limit - set maximum packet size limit for endpoint
84 	ep->maxpacket_limit = maxpacket_limit;  in usb_ep_set_maxpacket_limit()
85 	ep->maxpacket = maxpacket_limit;  in usb_ep_set_maxpacket_limit()
92  * usb_ep_enable - configure endpoint, making it usable
103  * for it.  for example, an endpoint named "ep2in-bulk" would be usable
106  * configurable, with more generic names like "ep-a".  (remember that for
117 	if (ep->enabled)  in usb_ep_enable()
121 	if (!ep->desc || usb_endpoint_maxp(ep->desc) == 0) {  in usb_ep_enable()
122 		WARN_ONCE(1, "%s: ep%d (%s) has %s\n", __func__, ep->address, ep->name,  in usb_ep_enable()
123 			  (!ep->desc) ? "NULL descriptor" : "maxpacket 0");  in usb_ep_enable()
125 		ret = -EINVAL;  in usb_ep_enable()
129 	ret = ep->ops->enable(ep, ep->desc);  in usb_ep_enable()
133 	ep->enabled = true;  in usb_ep_enable()
143  * usb_ep_disable - endpoint is no longer usable
148  * indicating disconnect (-ESHUTDOWN) before this call returns.
160 	if (!ep->enabled)  in usb_ep_disable()
163 	ret = ep->ops->disable(ep);  in usb_ep_disable()
167 	ep->enabled = false;  in usb_ep_disable()
177  * usb_ep_alloc_request - allocate a request object to use with this endpoint
182  * need controller-specific setup and may even need endpoint-specific
195 	req = ep->ops->alloc_request(ep, gfp_flags);  in usb_ep_alloc_request()
197 	trace_usb_ep_alloc_request(ep, req, req ? 0 : -ENOMEM);  in usb_ep_alloc_request()
204  * usb_ep_free_request - frees a request object
216 	ep->ops->free_request(ep, req);  in usb_ep_free_request()
221  * usb_ep_queue - queues (submits) an I/O request to an endpoint.
225  *	pre-allocate all necessary memory with the request.
252  * Interrupt-only endpoints are less functional than bulk endpoints, for
265  * it may not be possible to trigger a status-stage protocol stall when the
273  * Note that @req's ->complete() callback must never be called from
283  * @req->complete() will be called exactly once, when the Gadget core and
293 	if (!ep->enabled && ep->address) {  in usb_ep_queue()
295 				 ep->address, ep->name);  in usb_ep_queue()
296 		ret = -ESHUTDOWN;  in usb_ep_queue()
300 	ret = ep->ops->queue(ep, req, gfp_flags);  in usb_ep_queue()
310  * usb_ep_dequeue - dequeues (cancels, unlinks) an I/O request from an endpoint
315  * eventually its completion routine is called (with status -ECONNRESET);
330 	ret = ep->ops->dequeue(ep, req);  in usb_ep_dequeue()
338  * usb_ep_set_halt - sets the endpoint halt feature.
339  * @ep: the non-isochronous endpoint being stalled
356  * Attempts to halt IN endpoints will fail (returning -EAGAIN) if any
364 	ret = ep->ops->set_halt(ep, 1);  in usb_ep_set_halt()
372  * usb_ep_clear_halt - clears endpoint halt, and resets toggle
390 	ret = ep->ops->set_halt(ep, 0);  in usb_ep_clear_halt()
398  * usb_ep_set_wedge - sets the halt feature and ignores clear requests
413 	if (ep->ops->set_wedge)  in usb_ep_set_wedge()
414 		ret = ep->ops->set_wedge(ep);  in usb_ep_set_wedge()
416 		ret = ep->ops->set_halt(ep, 1);  in usb_ep_set_wedge()
425  * usb_ep_fifo_status - returns number of bytes in fifo, or error
445 	if (ep->ops->fifo_status)  in usb_ep_fifo_status()
446 		ret = ep->ops->fifo_status(ep);  in usb_ep_fifo_status()
448 		ret = -EOPNOTSUPP;  in usb_ep_fifo_status()
457  * usb_ep_fifo_flush - flushes contents of a fifo
469 	if (ep->ops->fifo_flush)  in usb_ep_fifo_flush()
470 		ep->ops->fifo_flush(ep);  in usb_ep_fifo_flush()
476 /* ------------------------------------------------------------------------- */
479  * usb_gadget_frame_number - returns the current frame number
489 	ret = gadget->ops->get_frame(gadget);  in usb_gadget_frame_number()
498  * usb_gadget_wakeup - tries to wake up the host connected to this gadget
506  * This may also try to use SRP to wake the host and start enumeration,
514 	if (!gadget->ops->wakeup) {  in usb_gadget_wakeup()
515 		ret = -EOPNOTSUPP;  in usb_gadget_wakeup()
519 	ret = gadget->ops->wakeup(gadget);  in usb_gadget_wakeup()
529  * usb_gadget_set_remote_wakeup - configures the device remote wakeup feature.
541 	if (!gadget->ops->set_remote_wakeup) {  in usb_gadget_set_remote_wakeup()
542 		ret = -EOPNOTSUPP;  in usb_gadget_set_remote_wakeup()
546 	ret = gadget->ops->set_remote_wakeup(gadget, set);  in usb_gadget_set_remote_wakeup()
556  * usb_gadget_set_selfpowered - sets the device selfpowered feature.
557  * @gadget:the device being declared as self-powered
568 	if (!gadget->ops->set_selfpowered) {  in usb_gadget_set_selfpowered()
569 		ret = -EOPNOTSUPP;  in usb_gadget_set_selfpowered()
573 	ret = gadget->ops->set_selfpowered(gadget, 1);  in usb_gadget_set_selfpowered()
583  * usb_gadget_clear_selfpowered - clear the device selfpowered feature.
584  * @gadget:the device being declared as bus-powered
587  * some hardware may not support bus-powered operation, in which
596 	if (!gadget->ops->set_selfpowered) {  in usb_gadget_clear_selfpowered()
597 		ret = -EOPNOTSUPP;  in usb_gadget_clear_selfpowered()
601 	ret = gadget->ops->set_selfpowered(gadget, 0);  in usb_gadget_clear_selfpowered()
611  * usb_gadget_vbus_connect - Notify controller that VBUS is powered
617  * resuming the controller, activating the D+ (or D-) pullup to let the
627 	if (!gadget->ops->vbus_session) {  in usb_gadget_vbus_connect()
628 		ret = -EOPNOTSUPP;  in usb_gadget_vbus_connect()
632 	ret = gadget->ops->vbus_session(gadget, 1);  in usb_gadget_vbus_connect()
642  * usb_gadget_vbus_draw - constrain controller's VBUS power usage
657 	if (!gadget->ops->vbus_draw) {  in usb_gadget_vbus_draw()
658 		ret = -EOPNOTSUPP;  in usb_gadget_vbus_draw()
662 	ret = gadget->ops->vbus_draw(gadget, mA);  in usb_gadget_vbus_draw()
664 		gadget->mA = mA;  in usb_gadget_vbus_draw()
674  * usb_gadget_vbus_disconnect - notify controller about VBUS session end
688 	if (!gadget->ops->vbus_session) {  in usb_gadget_vbus_disconnect()
689 		ret = -EOPNOTSUPP;  in usb_gadget_vbus_disconnect()
693 	ret = gadget->ops->vbus_session(gadget, 0);  in usb_gadget_vbus_disconnect()
703 	__must_hold(&gadget->udc->connect_lock)  in usb_gadget_connect_locked()
707 	if (!gadget->ops->pullup) {  in usb_gadget_connect_locked()
708 		ret = -EOPNOTSUPP;  in usb_gadget_connect_locked()
712 	if (gadget->deactivated || !gadget->udc->allow_connect || !gadget->udc->started) {  in usb_gadget_connect_locked()
719 		gadget->connected = true;  in usb_gadget_connect_locked()
723 	ret = gadget->ops->pullup(gadget, 1);  in usb_gadget_connect_locked()
725 		gadget->connected = 1;  in usb_gadget_connect_locked()
734  * usb_gadget_connect - software-controlled connect to USB host
737  * Enables the D+ (or potentially D-) pullup.  The host will start
747 	mutex_lock(&gadget->udc->connect_lock);  in usb_gadget_connect()
749 	mutex_unlock(&gadget->udc->connect_lock);  in usb_gadget_connect()
756 	__must_hold(&gadget->udc->connect_lock)  in usb_gadget_disconnect_locked()
760 	if (!gadget->ops->pullup) {  in usb_gadget_disconnect_locked()
761 		ret = -EOPNOTSUPP;  in usb_gadget_disconnect_locked()
765 	if (!gadget->connected)  in usb_gadget_disconnect_locked()
768 	if (gadget->deactivated || !gadget->udc->started) {  in usb_gadget_disconnect_locked()
773 		gadget->connected = false;  in usb_gadget_disconnect_locked()
777 	ret = gadget->ops->pullup(gadget, 0);  in usb_gadget_disconnect_locked()
779 		gadget->connected = 0;  in usb_gadget_disconnect_locked()
782 	if (gadget->udc->driver)  in usb_gadget_disconnect_locked()
783 		gadget->udc->driver->disconnect(gadget);  in usb_gadget_disconnect_locked()
793  * usb_gadget_disconnect - software-controlled disconnect from USB host
796  * Disables the D+ (or potentially D-) pullup, which the host may see
800  * Following a successful disconnect, invoke the ->disconnect() callback
809 	mutex_lock(&gadget->udc->connect_lock);  in usb_gadget_disconnect()
811 	mutex_unlock(&gadget->udc->connect_lock);  in usb_gadget_disconnect()
818  * usb_gadget_deactivate - deactivate function which is not ready to work
835 	mutex_lock(&gadget->udc->connect_lock);  in usb_gadget_deactivate()
836 	if (gadget->deactivated)  in usb_gadget_deactivate()
839 	if (gadget->connected) {  in usb_gadget_deactivate()
848 		gadget->connected = true;  in usb_gadget_deactivate()
850 	gadget->deactivated = true;  in usb_gadget_deactivate()
853 	mutex_unlock(&gadget->udc->connect_lock);  in usb_gadget_deactivate()
861  * usb_gadget_activate - activate function which is not ready to work
875 	mutex_lock(&gadget->udc->connect_lock);  in usb_gadget_activate()
876 	if (!gadget->deactivated)  in usb_gadget_activate()
879 	gadget->deactivated = false;  in usb_gadget_activate()
885 	if (gadget->connected)  in usb_gadget_activate()
889 	mutex_unlock(&gadget->udc->connect_lock);  in usb_gadget_activate()
896 /* ------------------------------------------------------------------------- */
903 	if (req->length == 0)  in usb_gadget_map_request_by_dev()
906 	if (req->sg_was_mapped) {  in usb_gadget_map_request_by_dev()
907 		req->num_mapped_sgs = req->num_sgs;  in usb_gadget_map_request_by_dev()
911 	if (req->num_sgs) {  in usb_gadget_map_request_by_dev()
914 		mapped = dma_map_sg(dev, req->sg, req->num_sgs,  in usb_gadget_map_request_by_dev()
918 			return -EFAULT;  in usb_gadget_map_request_by_dev()
921 		req->num_mapped_sgs = mapped;  in usb_gadget_map_request_by_dev()
923 		if (is_vmalloc_addr(req->buf)) {  in usb_gadget_map_request_by_dev()
924 			dev_err(dev, "buffer is not dma capable\n");  in usb_gadget_map_request_by_dev()
925 			return -EFAULT;  in usb_gadget_map_request_by_dev()
926 		} else if (object_is_on_stack(req->buf)) {  in usb_gadget_map_request_by_dev()
928 			return -EFAULT;  in usb_gadget_map_request_by_dev()
931 		req->dma = dma_map_single(dev, req->buf, req->length,  in usb_gadget_map_request_by_dev()
934 		if (dma_mapping_error(dev, req->dma)) {  in usb_gadget_map_request_by_dev()
936 			return -EFAULT;  in usb_gadget_map_request_by_dev()
939 		req->dma_mapped = 1;  in usb_gadget_map_request_by_dev()
949 	return usb_gadget_map_request_by_dev(gadget->dev.parent, req, is_in);  in usb_gadget_map_request()
956 	if (req->length == 0 || req->sg_was_mapped)  in usb_gadget_unmap_request_by_dev()
959 	if (req->num_mapped_sgs) {  in usb_gadget_unmap_request_by_dev()
960 		dma_unmap_sg(dev, req->sg, req->num_sgs,  in usb_gadget_unmap_request_by_dev()
963 		req->num_mapped_sgs = 0;  in usb_gadget_unmap_request_by_dev()
964 	} else if (req->dma_mapped) {  in usb_gadget_unmap_request_by_dev()
965 		dma_unmap_single(dev, req->dma, req->length,  in usb_gadget_unmap_request_by_dev()
967 		req->dma_mapped = 0;  in usb_gadget_unmap_request_by_dev()
975 	usb_gadget_unmap_request_by_dev(gadget->dev.parent, req, is_in);  in usb_gadget_unmap_request()
981 /* ------------------------------------------------------------------------- */
984  * usb_gadget_giveback_request - give the request back to the gadget layer
994 	if (likely(req->status == 0))  in usb_gadget_giveback_request()
999 	req->complete(ep, req);  in usb_gadget_giveback_request()
1003 /* ------------------------------------------------------------------------- */
1006  * gadget_find_ep_by_name - returns ep whose name is the same as sting passed
1016 		if (!strcmp(ep->name, name))  in gadget_find_ep_by_name()
1024 /* ------------------------------------------------------------------------- */
1035 	if (ep->claimed)  in usb_gadget_ep_match_desc()
1041 	if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in)  in usb_gadget_ep_match_desc()
1043 	if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out)  in usb_gadget_ep_match_desc()
1046 	if (max > ep->maxpacket_limit)  in usb_gadget_ep_match_desc()
1058 		if (!ep->caps.type_iso)  in usb_gadget_ep_match_desc()
1065 		if (!ep->caps.type_bulk)  in usb_gadget_ep_match_desc()
1072 			num_req_streams = ep_comp->bmAttributes & 0x1f;  in usb_gadget_ep_match_desc()
1073 			if (num_req_streams > ep->max_streams)  in usb_gadget_ep_match_desc()
1079 		 * except the toggle-quirky iso-synch kind  in usb_gadget_ep_match_desc()
1081 		if (!ep->caps.type_int && !ep->caps.type_bulk)  in usb_gadget_ep_match_desc()
1094  * usb_gadget_check_config - checks if the UDC can support the binded
1106 	if (gadget->ops->check_config)  in usb_gadget_check_config()
1107 		return gadget->ops->check_config(gadget);  in usb_gadget_check_config()
1112 /* ------------------------------------------------------------------------- */
1117 	struct usb_udc *udc = gadget->udc;  in usb_gadget_state_work()
1120 		sysfs_notify(&udc->dev.kobj, NULL, "state");  in usb_gadget_state_work()
1126 	gadget->state = state;  in usb_gadget_set_state()
1127 	schedule_work(&gadget->work);  in usb_gadget_set_state()
1131 /* ------------------------------------------------------------------------- */
1134 static int usb_udc_connect_control_locked(struct usb_udc *udc) __must_hold(&udc->connect_lock)  in usb_udc_connect_control_locked()
1136 	if (udc->vbus)  in usb_udc_connect_control_locked()
1137 		return usb_gadget_connect_locked(udc->gadget);  in usb_udc_connect_control_locked()
1139 		return usb_gadget_disconnect_locked(udc->gadget);  in usb_udc_connect_control_locked()
1146 	mutex_lock(&udc->connect_lock);  in vbus_event_work()
1148 	mutex_unlock(&udc->connect_lock);  in vbus_event_work()
1152  * usb_udc_vbus_handler - updates the udc core vbus status, and try to
1162  * non-atomic context due to the following:
1163  * a. Some of the gadget driver implementations expect the ->pullup
1164  * callback to be invoked in non-atomic context.
1170 	struct usb_udc *udc = gadget->udc;  in usb_udc_vbus_handler()
1173 		udc->vbus = status;  in usb_udc_vbus_handler()
1174 		schedule_work(&udc->vbus_work);  in usb_udc_vbus_handler()
1180  * usb_gadget_udc_reset - notifies the udc core that bus reset occurs
1191 	driver->reset(gadget);  in usb_gadget_udc_reset()
1197  * usb_gadget_udc_start_locked - tells usb device controller to start up
1212 	__must_hold(&udc->connect_lock)  in usb_gadget_udc_start_locked()
1216 	if (udc->started) {  in usb_gadget_udc_start_locked()
1217 		dev_err(&udc->dev, "UDC had already started\n");  in usb_gadget_udc_start_locked()
1218 		return -EBUSY;  in usb_gadget_udc_start_locked()
1221 	ret = udc->gadget->ops->udc_start(udc->gadget, udc->driver);  in usb_gadget_udc_start_locked()
1223 		udc->started = true;  in usb_gadget_udc_start_locked()
1229  * usb_gadget_udc_stop_locked - tells usb device controller we don't need it anymore
1242 	__must_hold(&udc->connect_lock)  in usb_gadget_udc_stop_locked()
1244 	if (!udc->started) {  in usb_gadget_udc_stop_locked()
1245 		dev_err(&udc->dev, "UDC had already stopped\n");  in usb_gadget_udc_stop_locked()
1249 	udc->gadget->ops->udc_stop(udc->gadget);  in usb_gadget_udc_stop_locked()
1250 	udc->started = false;  in usb_gadget_udc_stop_locked()
1254  * usb_gadget_udc_set_speed - tells usb device controller speed supported by
1266 	struct usb_gadget *gadget = udc->gadget;  in usb_gadget_udc_set_speed()
1270 		s = gadget->max_speed;  in usb_gadget_udc_set_speed()
1272 		s = min(speed, gadget->max_speed);  in usb_gadget_udc_set_speed()
1274 	if (s == USB_SPEED_SUPER_PLUS && gadget->ops->udc_set_ssp_rate)  in usb_gadget_udc_set_speed()
1275 		gadget->ops->udc_set_ssp_rate(gadget, gadget->max_ssp_rate);  in usb_gadget_udc_set_speed()
1276 	else if (gadget->ops->udc_set_speed)  in usb_gadget_udc_set_speed()
1277 		gadget->ops->udc_set_speed(gadget, s);  in usb_gadget_udc_set_speed()
1281  * usb_gadget_enable_async_callbacks - tell usb device controller to enable asynchronous callbacks
1292 	struct usb_gadget *gadget = udc->gadget;  in usb_gadget_enable_async_callbacks()
1294 	if (gadget->ops->udc_async_callbacks)  in usb_gadget_enable_async_callbacks()
1295 		gadget->ops->udc_async_callbacks(gadget, true);  in usb_gadget_enable_async_callbacks()
1299  * usb_gadget_disable_async_callbacks - tell usb device controller to disable asynchronous callbacks
1303  * The UDC driver doesn't know when the gadget driver's ->unbind callback
1305  * issue a callback (such as ->disconnect) after the unbind has completed.
1307  * After this function runs, the UDC driver must suppress all ->suspend,
1308  * ->resume, ->disconnect, ->reset, and ->setup callbacks to the gadget driver
1309  * until async callbacks are again enabled.  A simple-minded but effective
1314  * to defer them until the request is cancelled, since the pull-up will be
1321 	struct usb_gadget *gadget = udc->gadget;  in usb_gadget_disable_async_callbacks()
1323 	if (gadget->ops->udc_async_callbacks)  in usb_gadget_disable_async_callbacks()
1324 		gadget->ops->udc_async_callbacks(gadget, false);  in usb_gadget_disable_async_callbacks()
1328  * usb_udc_release - release the usb_udc struct
1351  * usb_initialize_gadget - initialize a gadget and its embedded struct device
1360 	INIT_WORK(&gadget->work, usb_gadget_state_work);  in usb_initialize_gadget()
1361 	gadget->dev.parent = parent;  in usb_initialize_gadget()
1364 		gadget->dev.release = release;  in usb_initialize_gadget()
1366 		gadget->dev.release = usb_udc_nop_release;  in usb_initialize_gadget()
1368 	device_initialize(&gadget->dev);  in usb_initialize_gadget()
1369 	gadget->dev.bus = &gadget_bus_type;  in usb_initialize_gadget()
1374  * usb_add_gadget - adds a new gadget to the udc class driver list
1383 	int			ret = -ENOMEM;  in usb_add_gadget()
1389 	device_initialize(&udc->dev);  in usb_add_gadget()
1390 	udc->dev.release = usb_udc_release;  in usb_add_gadget()
1391 	udc->dev.class = &udc_class;  in usb_add_gadget()
1392 	udc->dev.groups = usb_udc_attr_groups;  in usb_add_gadget()
1393 	udc->dev.parent = gadget->dev.parent;  in usb_add_gadget()
1394 	ret = dev_set_name(&udc->dev, "%s",  in usb_add_gadget()
1395 			kobject_name(&gadget->dev.parent->kobj));  in usb_add_gadget()
1399 	udc->gadget = gadget;  in usb_add_gadget()
1400 	gadget->udc = udc;  in usb_add_gadget()
1401 	mutex_init(&udc->connect_lock);  in usb_add_gadget()
1403 	udc->started = false;  in usb_add_gadget()
1406 	list_add_tail(&udc->list, &udc_list);  in usb_add_gadget()
1408 	INIT_WORK(&udc->vbus_work, vbus_event_work);  in usb_add_gadget()
1410 	ret = device_add(&udc->dev);  in usb_add_gadget()
1415 	udc->vbus = true;  in usb_add_gadget()
1420 	gadget->id_number = ret;  in usb_add_gadget()
1421 	dev_set_name(&gadget->dev, "gadget.%d", ret);  in usb_add_gadget()
1423 	ret = device_add(&gadget->dev);  in usb_add_gadget()
1427 	ret = sysfs_create_link(&udc->dev.kobj,  in usb_add_gadget()
1428 				&gadget->dev.kobj, "gadget");  in usb_add_gadget()
1435 	device_del(&gadget->dev);  in usb_add_gadget()
1438 	ida_free(&gadget_id_numbers, gadget->id_number);  in usb_add_gadget()
1441 	flush_work(&gadget->work);  in usb_add_gadget()
1442 	device_del(&udc->dev);  in usb_add_gadget()
1446 	list_del(&udc->list);  in usb_add_gadget()
1450 	put_device(&udc->dev);  in usb_add_gadget()
1458  * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
1481  * usb_get_gadget_udc_name - get the name of the first UDC controller
1500 		if (!udc->driver) {  in usb_get_gadget_udc_name()
1501 			name = kstrdup(udc->gadget->name, GFP_KERNEL);  in usb_get_gadget_udc_name()
1511  * usb_add_gadget_udc - adds a new gadget to the udc class driver list
1525  * usb_del_gadget - deletes a gadget and unregisters its udc
1533 	struct usb_udc *udc = gadget->udc;  in usb_del_gadget()
1538 	dev_vdbg(gadget->dev.parent, "unregistering gadget\n");  in usb_del_gadget()
1541 	list_del(&udc->list);  in usb_del_gadget()
1544 	kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);  in usb_del_gadget()
1545 	sysfs_remove_link(&udc->dev.kobj, "gadget");  in usb_del_gadget()
1546 	device_del(&gadget->dev);  in usb_del_gadget()
1547 	flush_work(&gadget->work);  in usb_del_gadget()
1548 	ida_free(&gadget_id_numbers, gadget->id_number);  in usb_del_gadget()
1549 	cancel_work_sync(&udc->vbus_work);  in usb_del_gadget()
1550 	device_unregister(&udc->dev);  in usb_del_gadget()
1555  * usb_del_gadget_udc - unregisters a gadget
1567 /* ------------------------------------------------------------------------- */
1572 	struct usb_udc *udc = gadget->udc;  in gadget_match_driver()
1577 	if (driver->udc_name &&  in gadget_match_driver()
1578 			strcmp(driver->udc_name, dev_name(&udc->dev)) != 0)  in gadget_match_driver()
1582 	if (driver->is_bound)  in gadget_match_driver()
1592 	struct usb_udc *udc = gadget->udc;  in gadget_bind_driver()
1593 	struct usb_gadget_driver *driver = container_of(dev->driver,  in gadget_bind_driver()
1598 	if (driver->is_bound) {  in gadget_bind_driver()
1600 		return -ENXIO;		/* Driver binds to only one gadget */  in gadget_bind_driver()
1602 	driver->is_bound = true;  in gadget_bind_driver()
1603 	udc->driver = driver;  in gadget_bind_driver()
1606 	dev_dbg(&udc->dev, "binding gadget driver [%s]\n", driver->function);  in gadget_bind_driver()
1608 	usb_gadget_udc_set_speed(udc, driver->max_speed);  in gadget_bind_driver()
1610 	ret = driver->bind(udc->gadget, driver);  in gadget_bind_driver()
1614 	mutex_lock(&udc->connect_lock);  in gadget_bind_driver()
1617 		mutex_unlock(&udc->connect_lock);  in gadget_bind_driver()
1621 	udc->allow_connect = true;  in gadget_bind_driver()
1626 	mutex_unlock(&udc->connect_lock);  in gadget_bind_driver()
1628 	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);  in gadget_bind_driver()
1632 	udc->allow_connect = false;  in gadget_bind_driver()
1634 	if (gadget->irq)  in gadget_bind_driver()
1635 		synchronize_irq(gadget->irq);  in gadget_bind_driver()
1637 	mutex_unlock(&udc->connect_lock);  in gadget_bind_driver()
1640 	driver->unbind(udc->gadget);  in gadget_bind_driver()
1643 	if (ret != -EISNAM)  in gadget_bind_driver()
1644 		dev_err(&udc->dev, "failed to start %s: %d\n",  in gadget_bind_driver()
1645 			driver->function, ret);  in gadget_bind_driver()
1648 	udc->driver = NULL;  in gadget_bind_driver()
1649 	driver->is_bound = false;  in gadget_bind_driver()
1658 	struct usb_udc *udc = gadget->udc;  in gadget_unbind_driver()
1659 	struct usb_gadget_driver *driver = udc->driver;  in gadget_unbind_driver()
1661 	dev_dbg(&udc->dev, "unbinding gadget driver [%s]\n", driver->function);  in gadget_unbind_driver()
1663 	udc->allow_connect = false;  in gadget_unbind_driver()
1664 	cancel_work_sync(&udc->vbus_work);  in gadget_unbind_driver()
1665 	mutex_lock(&udc->connect_lock);  in gadget_unbind_driver()
1668 	if (gadget->irq)  in gadget_unbind_driver()
1669 		synchronize_irq(gadget->irq);  in gadget_unbind_driver()
1670 	mutex_unlock(&udc->connect_lock);  in gadget_unbind_driver()
1672 	udc->driver->unbind(gadget);  in gadget_unbind_driver()
1674 	mutex_lock(&udc->connect_lock);  in gadget_unbind_driver()
1676 	mutex_unlock(&udc->connect_lock);  in gadget_unbind_driver()
1679 	driver->is_bound = false;  in gadget_unbind_driver()
1680 	udc->driver = NULL;  in gadget_unbind_driver()
1683 	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);  in gadget_unbind_driver()
1686 /* ------------------------------------------------------------------------- */
1693 	if (!driver || !driver->bind || !driver->setup)  in usb_gadget_register_driver_owner()
1694 		return -EINVAL;  in usb_gadget_register_driver_owner()
1696 	driver->driver.bus = &gadget_bus_type;  in usb_gadget_register_driver_owner()
1697 	driver->driver.owner = owner;  in usb_gadget_register_driver_owner()
1698 	driver->driver.mod_name = mod_name;  in usb_gadget_register_driver_owner()
1699 	driver->driver.probe_type = PROBE_FORCE_SYNCHRONOUS;  in usb_gadget_register_driver_owner()
1700 	ret = driver_register(&driver->driver);  in usb_gadget_register_driver_owner()
1703 				driver->function, ret);  in usb_gadget_register_driver_owner()
1708 	if (!driver->is_bound) {  in usb_gadget_register_driver_owner()
1709 		if (driver->match_existing_only) {  in usb_gadget_register_driver_owner()
1711 					driver->function);  in usb_gadget_register_driver_owner()
1712 			ret = -EBUSY;  in usb_gadget_register_driver_owner()
1715 					driver->function);  in usb_gadget_register_driver_owner()
1722 		driver_unregister(&driver->driver);  in usb_gadget_register_driver_owner()
1729 	if (!driver || !driver->unbind)  in usb_gadget_unregister_driver()
1730 		return -EINVAL;  in usb_gadget_unregister_driver()
1732 	driver_unregister(&driver->driver);  in usb_gadget_unregister_driver()
1737 /* ------------------------------------------------------------------------- */
1745 		usb_gadget_wakeup(udc->gadget);  in srp_store()
1749 static DEVICE_ATTR_WO(srp);
1757 	device_lock(&udc->gadget->dev);  in soft_connect_store()
1758 	if (!udc->driver) {  in soft_connect_store()
1759 		dev_err(dev, "soft-connect without a gadget driver\n");  in soft_connect_store()
1760 		ret = -EOPNOTSUPP;  in soft_connect_store()
1765 		mutex_lock(&udc->connect_lock);  in soft_connect_store()
1767 		usb_gadget_connect_locked(udc->gadget);  in soft_connect_store()
1768 		mutex_unlock(&udc->connect_lock);  in soft_connect_store()
1770 		mutex_lock(&udc->connect_lock);  in soft_connect_store()
1771 		usb_gadget_disconnect_locked(udc->gadget);  in soft_connect_store()
1773 		mutex_unlock(&udc->connect_lock);  in soft_connect_store()
1776 		ret = -EINVAL;  in soft_connect_store()
1782 	device_unlock(&udc->gadget->dev);  in soft_connect_store()
1791 	struct usb_gadget	*gadget = udc->gadget;  in state_show()
1793 	return sprintf(buf, "%s\n", usb_state_string(gadget->state));  in state_show()
1805 	drv = udc->driver;  in function_show()
1806 	if (drv && drv->function)  in function_show()
1807 		rc = scnprintf(buf, PAGE_SIZE, "%s\n", drv->function);  in function_show()
1819 			usb_speed_string(udc->gadget->param));		\
1831 	struct usb_gadget	*gadget = udc->gadget;		\
1833 	return scnprintf(buf, PAGE_SIZE, "%d\n", gadget->name);	\
1875 	ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);  in usb_udc_uevent()
1882 	if (udc->driver)  in usb_udc_uevent()
1884 				udc->driver->function);  in usb_udc_uevent()