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 (usb_endpoint_maxp(ep->desc) == 0) {  in usb_ep_enable()
127 		ret = -EINVAL;  in usb_ep_enable()
131 	ret = ep->ops->enable(ep, ep->desc);  in usb_ep_enable()
135 	ep->enabled = true;  in usb_ep_enable()
145  * usb_ep_disable - endpoint is no longer usable
150  * indicating disconnect (-ESHUTDOWN) before this call returns.
162 	if (!ep->enabled)  in usb_ep_disable()
165 	ret = ep->ops->disable(ep);  in usb_ep_disable()
169 	ep->enabled = false;  in usb_ep_disable()
179  * usb_ep_alloc_request - allocate a request object to use with this endpoint
184  * need controller-specific setup and may even need endpoint-specific
197 	req = ep->ops->alloc_request(ep, gfp_flags);  in usb_ep_alloc_request()
199 	trace_usb_ep_alloc_request(ep, req, req ? 0 : -ENOMEM);  in usb_ep_alloc_request()
206  * usb_ep_free_request - frees a request object
218 	ep->ops->free_request(ep, req);  in usb_ep_free_request()
223  * usb_ep_queue - queues (submits) an I/O request to an endpoint.
227  *	pre-allocate all necessary memory with the request.
254  * Interrupt-only endpoints are less functional than bulk endpoints, for
267  * it may not be possible to trigger a status-stage protocol stall when the
275  * Note that @req's ->complete() callback must never be called from
285  * @req->complete() will be called exactly once, when the Gadget core and
295 	if (WARN_ON_ONCE(!ep->enabled && ep->address)) {  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->num_sgs) {  in usb_gadget_map_request_by_dev()
909 		mapped = dma_map_sg(dev, req->sg, req->num_sgs,  in usb_gadget_map_request_by_dev()
913 			return -EFAULT;  in usb_gadget_map_request_by_dev()
916 		req->num_mapped_sgs = mapped;  in usb_gadget_map_request_by_dev()
918 		if (is_vmalloc_addr(req->buf)) {  in usb_gadget_map_request_by_dev()
919 			dev_err(dev, "buffer is not dma capable\n");  in usb_gadget_map_request_by_dev()
920 			return -EFAULT;  in usb_gadget_map_request_by_dev()
921 		} else if (object_is_on_stack(req->buf)) {  in usb_gadget_map_request_by_dev()
923 			return -EFAULT;  in usb_gadget_map_request_by_dev()
926 		req->dma = dma_map_single(dev, req->buf, req->length,  in usb_gadget_map_request_by_dev()
929 		if (dma_mapping_error(dev, req->dma)) {  in usb_gadget_map_request_by_dev()
931 			return -EFAULT;  in usb_gadget_map_request_by_dev()
934 		req->dma_mapped = 1;  in usb_gadget_map_request_by_dev()
944 	return usb_gadget_map_request_by_dev(gadget->dev.parent, req, is_in);  in usb_gadget_map_request()
951 	if (req->length == 0)  in usb_gadget_unmap_request_by_dev()
954 	if (req->num_mapped_sgs) {  in usb_gadget_unmap_request_by_dev()
955 		dma_unmap_sg(dev, req->sg, req->num_sgs,  in usb_gadget_unmap_request_by_dev()
958 		req->num_mapped_sgs = 0;  in usb_gadget_unmap_request_by_dev()
959 	} else if (req->dma_mapped) {  in usb_gadget_unmap_request_by_dev()
960 		dma_unmap_single(dev, req->dma, req->length,  in usb_gadget_unmap_request_by_dev()
962 		req->dma_mapped = 0;  in usb_gadget_unmap_request_by_dev()
970 	usb_gadget_unmap_request_by_dev(gadget->dev.parent, req, is_in);  in usb_gadget_unmap_request()
976 /* ------------------------------------------------------------------------- */
979  * usb_gadget_giveback_request - give the request back to the gadget layer
989 	if (likely(req->status == 0))  in usb_gadget_giveback_request()
994 	req->complete(ep, req);  in usb_gadget_giveback_request()
998 /* ------------------------------------------------------------------------- */
1001  * gadget_find_ep_by_name - returns ep whose name is the same as sting passed
1011 		if (!strcmp(ep->name, name))  in gadget_find_ep_by_name()
1019 /* ------------------------------------------------------------------------- */
1030 	if (ep->claimed)  in usb_gadget_ep_match_desc()
1036 	if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in)  in usb_gadget_ep_match_desc()
1038 	if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out)  in usb_gadget_ep_match_desc()
1041 	if (max > ep->maxpacket_limit)  in usb_gadget_ep_match_desc()
1053 		if (!ep->caps.type_iso)  in usb_gadget_ep_match_desc()
1060 		if (!ep->caps.type_bulk)  in usb_gadget_ep_match_desc()
1067 			num_req_streams = ep_comp->bmAttributes & 0x1f;  in usb_gadget_ep_match_desc()
1068 			if (num_req_streams > ep->max_streams)  in usb_gadget_ep_match_desc()
1074 		 * except the toggle-quirky iso-synch kind  in usb_gadget_ep_match_desc()
1076 		if (!ep->caps.type_int && !ep->caps.type_bulk)  in usb_gadget_ep_match_desc()
1089  * usb_gadget_check_config - checks if the UDC can support the binded
1101 	if (gadget->ops->check_config)  in usb_gadget_check_config()
1102 		return gadget->ops->check_config(gadget);  in usb_gadget_check_config()
1107 /* ------------------------------------------------------------------------- */
1112 	struct usb_udc *udc = gadget->udc;  in usb_gadget_state_work()
1115 		sysfs_notify(&udc->dev.kobj, NULL, "state");  in usb_gadget_state_work()
1121 	gadget->state = state;  in usb_gadget_set_state()
1122 	schedule_work(&gadget->work);  in usb_gadget_set_state()
1126 /* ------------------------------------------------------------------------- */
1129 static int usb_udc_connect_control_locked(struct usb_udc *udc) __must_hold(&udc->connect_lock)  in usb_udc_connect_control_locked()
1131 	if (udc->vbus)  in usb_udc_connect_control_locked()
1132 		return usb_gadget_connect_locked(udc->gadget);  in usb_udc_connect_control_locked()
1134 		return usb_gadget_disconnect_locked(udc->gadget);  in usb_udc_connect_control_locked()
1141 	mutex_lock(&udc->connect_lock);  in vbus_event_work()
1143 	mutex_unlock(&udc->connect_lock);  in vbus_event_work()
1147  * usb_udc_vbus_handler - updates the udc core vbus status, and try to
1157  * non-atomic context due to the following:
1158  * a. Some of the gadget driver implementations expect the ->pullup
1159  * callback to be invoked in non-atomic context.
1165 	struct usb_udc *udc = gadget->udc;  in usb_udc_vbus_handler()
1168 		udc->vbus = status;  in usb_udc_vbus_handler()
1169 		schedule_work(&udc->vbus_work);  in usb_udc_vbus_handler()
1175  * usb_gadget_udc_reset - notifies the udc core that bus reset occurs
1186 	driver->reset(gadget);  in usb_gadget_udc_reset()
1192  * usb_gadget_udc_start_locked - tells usb device controller to start up
1207 	__must_hold(&udc->connect_lock)  in usb_gadget_udc_start_locked()
1211 	if (udc->started) {  in usb_gadget_udc_start_locked()
1212 		dev_err(&udc->dev, "UDC had already started\n");  in usb_gadget_udc_start_locked()
1213 		return -EBUSY;  in usb_gadget_udc_start_locked()
1216 	ret = udc->gadget->ops->udc_start(udc->gadget, udc->driver);  in usb_gadget_udc_start_locked()
1218 		udc->started = true;  in usb_gadget_udc_start_locked()
1224  * usb_gadget_udc_stop_locked - tells usb device controller we don't need it anymore
1237 	__must_hold(&udc->connect_lock)  in usb_gadget_udc_stop_locked()
1239 	if (!udc->started) {  in usb_gadget_udc_stop_locked()
1240 		dev_err(&udc->dev, "UDC had already stopped\n");  in usb_gadget_udc_stop_locked()
1244 	udc->gadget->ops->udc_stop(udc->gadget);  in usb_gadget_udc_stop_locked()
1245 	udc->started = false;  in usb_gadget_udc_stop_locked()
1249  * usb_gadget_udc_set_speed - tells usb device controller speed supported by
1261 	struct usb_gadget *gadget = udc->gadget;  in usb_gadget_udc_set_speed()
1265 		s = gadget->max_speed;  in usb_gadget_udc_set_speed()
1267 		s = min(speed, gadget->max_speed);  in usb_gadget_udc_set_speed()
1269 	if (s == USB_SPEED_SUPER_PLUS && gadget->ops->udc_set_ssp_rate)  in usb_gadget_udc_set_speed()
1270 		gadget->ops->udc_set_ssp_rate(gadget, gadget->max_ssp_rate);  in usb_gadget_udc_set_speed()
1271 	else if (gadget->ops->udc_set_speed)  in usb_gadget_udc_set_speed()
1272 		gadget->ops->udc_set_speed(gadget, s);  in usb_gadget_udc_set_speed()
1276  * usb_gadget_enable_async_callbacks - tell usb device controller to enable asynchronous callbacks
1287 	struct usb_gadget *gadget = udc->gadget;  in usb_gadget_enable_async_callbacks()
1289 	if (gadget->ops->udc_async_callbacks)  in usb_gadget_enable_async_callbacks()
1290 		gadget->ops->udc_async_callbacks(gadget, true);  in usb_gadget_enable_async_callbacks()
1294  * usb_gadget_disable_async_callbacks - tell usb device controller to disable asynchronous callbacks
1298  * The UDC driver doesn't know when the gadget driver's ->unbind callback
1300  * issue a callback (such as ->disconnect) after the unbind has completed.
1302  * After this function runs, the UDC driver must suppress all ->suspend,
1303  * ->resume, ->disconnect, ->reset, and ->setup callbacks to the gadget driver
1304  * until async callbacks are again enabled.  A simple-minded but effective
1309  * to defer them until the request is cancelled, since the pull-up will be
1316 	struct usb_gadget *gadget = udc->gadget;  in usb_gadget_disable_async_callbacks()
1318 	if (gadget->ops->udc_async_callbacks)  in usb_gadget_disable_async_callbacks()
1319 		gadget->ops->udc_async_callbacks(gadget, false);  in usb_gadget_disable_async_callbacks()
1323  * usb_udc_release - release the usb_udc struct
1346  * usb_initialize_gadget - initialize a gadget and its embedded struct device
1355 	INIT_WORK(&gadget->work, usb_gadget_state_work);  in usb_initialize_gadget()
1356 	gadget->dev.parent = parent;  in usb_initialize_gadget()
1359 		gadget->dev.release = release;  in usb_initialize_gadget()
1361 		gadget->dev.release = usb_udc_nop_release;  in usb_initialize_gadget()
1363 	device_initialize(&gadget->dev);  in usb_initialize_gadget()
1364 	gadget->dev.bus = &gadget_bus_type;  in usb_initialize_gadget()
1369  * usb_add_gadget - adds a new gadget to the udc class driver list
1378 	int			ret = -ENOMEM;  in usb_add_gadget()
1384 	device_initialize(&udc->dev);  in usb_add_gadget()
1385 	udc->dev.release = usb_udc_release;  in usb_add_gadget()
1386 	udc->dev.class = &udc_class;  in usb_add_gadget()
1387 	udc->dev.groups = usb_udc_attr_groups;  in usb_add_gadget()
1388 	udc->dev.parent = gadget->dev.parent;  in usb_add_gadget()
1389 	ret = dev_set_name(&udc->dev, "%s",  in usb_add_gadget()
1390 			kobject_name(&gadget->dev.parent->kobj));  in usb_add_gadget()
1394 	udc->gadget = gadget;  in usb_add_gadget()
1395 	gadget->udc = udc;  in usb_add_gadget()
1396 	mutex_init(&udc->connect_lock);  in usb_add_gadget()
1398 	udc->started = false;  in usb_add_gadget()
1401 	list_add_tail(&udc->list, &udc_list);  in usb_add_gadget()
1403 	INIT_WORK(&udc->vbus_work, vbus_event_work);  in usb_add_gadget()
1405 	ret = device_add(&udc->dev);  in usb_add_gadget()
1410 	udc->vbus = true;  in usb_add_gadget()
1415 	gadget->id_number = ret;  in usb_add_gadget()
1416 	dev_set_name(&gadget->dev, "gadget.%d", ret);  in usb_add_gadget()
1418 	ret = device_add(&gadget->dev);  in usb_add_gadget()
1425 	ida_free(&gadget_id_numbers, gadget->id_number);  in usb_add_gadget()
1428 	flush_work(&gadget->work);  in usb_add_gadget()
1429 	device_del(&udc->dev);  in usb_add_gadget()
1433 	list_del(&udc->list);  in usb_add_gadget()
1437 	put_device(&udc->dev);  in usb_add_gadget()
1445  * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
1468  * usb_get_gadget_udc_name - get the name of the first UDC controller
1487 		if (!udc->driver) {  in usb_get_gadget_udc_name()
1488 			name = kstrdup(udc->gadget->name, GFP_KERNEL);  in usb_get_gadget_udc_name()
1498  * usb_add_gadget_udc - adds a new gadget to the udc class driver list
1512  * usb_del_gadget - deletes a gadget and unregisters its udc
1520 	struct usb_udc *udc = gadget->udc;  in usb_del_gadget()
1525 	dev_vdbg(gadget->dev.parent, "unregistering gadget\n");  in usb_del_gadget()
1528 	list_del(&udc->list);  in usb_del_gadget()
1531 	kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);  in usb_del_gadget()
1532 	flush_work(&gadget->work);  in usb_del_gadget()
1533 	device_del(&gadget->dev);  in usb_del_gadget()
1534 	ida_free(&gadget_id_numbers, gadget->id_number);  in usb_del_gadget()
1535 	cancel_work_sync(&udc->vbus_work);  in usb_del_gadget()
1536 	device_unregister(&udc->dev);  in usb_del_gadget()
1541  * usb_del_gadget_udc - unregisters a gadget
1553 /* ------------------------------------------------------------------------- */
1558 	struct usb_udc *udc = gadget->udc;  in gadget_match_driver()
1563 	if (driver->udc_name &&  in gadget_match_driver()
1564 			strcmp(driver->udc_name, dev_name(&udc->dev)) != 0)  in gadget_match_driver()
1568 	if (driver->is_bound)  in gadget_match_driver()
1578 	struct usb_udc *udc = gadget->udc;  in gadget_bind_driver()
1579 	struct usb_gadget_driver *driver = container_of(dev->driver,  in gadget_bind_driver()
1584 	if (driver->is_bound) {  in gadget_bind_driver()
1586 		return -ENXIO;		/* Driver binds to only one gadget */  in gadget_bind_driver()
1588 	driver->is_bound = true;  in gadget_bind_driver()
1589 	udc->driver = driver;  in gadget_bind_driver()
1592 	dev_dbg(&udc->dev, "binding gadget driver [%s]\n", driver->function);  in gadget_bind_driver()
1594 	usb_gadget_udc_set_speed(udc, driver->max_speed);  in gadget_bind_driver()
1596 	ret = driver->bind(udc->gadget, driver);  in gadget_bind_driver()
1600 	mutex_lock(&udc->connect_lock);  in gadget_bind_driver()
1603 		mutex_unlock(&udc->connect_lock);  in gadget_bind_driver()
1607 	udc->allow_connect = true;  in gadget_bind_driver()
1612 	mutex_unlock(&udc->connect_lock);  in gadget_bind_driver()
1614 	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);  in gadget_bind_driver()
1618 	udc->allow_connect = false;  in gadget_bind_driver()
1620 	if (gadget->irq)  in gadget_bind_driver()
1621 		synchronize_irq(gadget->irq);  in gadget_bind_driver()
1623 	mutex_unlock(&udc->connect_lock);  in gadget_bind_driver()
1626 	driver->unbind(udc->gadget);  in gadget_bind_driver()
1629 	if (ret != -EISNAM)  in gadget_bind_driver()
1630 		dev_err(&udc->dev, "failed to start %s: %d\n",  in gadget_bind_driver()
1631 			driver->function, ret);  in gadget_bind_driver()
1634 	udc->driver = NULL;  in gadget_bind_driver()
1635 	driver->is_bound = false;  in gadget_bind_driver()
1644 	struct usb_udc *udc = gadget->udc;  in gadget_unbind_driver()
1645 	struct usb_gadget_driver *driver = udc->driver;  in gadget_unbind_driver()
1647 	dev_dbg(&udc->dev, "unbinding gadget driver [%s]\n", driver->function);  in gadget_unbind_driver()
1649 	udc->allow_connect = false;  in gadget_unbind_driver()
1650 	cancel_work_sync(&udc->vbus_work);  in gadget_unbind_driver()
1651 	mutex_lock(&udc->connect_lock);  in gadget_unbind_driver()
1654 	if (gadget->irq)  in gadget_unbind_driver()
1655 		synchronize_irq(gadget->irq);  in gadget_unbind_driver()
1656 	mutex_unlock(&udc->connect_lock);  in gadget_unbind_driver()
1658 	udc->driver->unbind(gadget);  in gadget_unbind_driver()
1660 	mutex_lock(&udc->connect_lock);  in gadget_unbind_driver()
1662 	mutex_unlock(&udc->connect_lock);  in gadget_unbind_driver()
1665 	driver->is_bound = false;  in gadget_unbind_driver()
1666 	udc->driver = NULL;  in gadget_unbind_driver()
1669 	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);  in gadget_unbind_driver()
1672 /* ------------------------------------------------------------------------- */
1679 	if (!driver || !driver->bind || !driver->setup)  in usb_gadget_register_driver_owner()
1680 		return -EINVAL;  in usb_gadget_register_driver_owner()
1682 	driver->driver.bus = &gadget_bus_type;  in usb_gadget_register_driver_owner()
1683 	driver->driver.owner = owner;  in usb_gadget_register_driver_owner()
1684 	driver->driver.mod_name = mod_name;  in usb_gadget_register_driver_owner()
1685 	ret = driver_register(&driver->driver);  in usb_gadget_register_driver_owner()
1688 				driver->function, ret);  in usb_gadget_register_driver_owner()
1693 	if (!driver->is_bound) {  in usb_gadget_register_driver_owner()
1694 		if (driver->match_existing_only) {  in usb_gadget_register_driver_owner()
1696 					driver->function);  in usb_gadget_register_driver_owner()
1697 			ret = -EBUSY;  in usb_gadget_register_driver_owner()
1700 					driver->function);  in usb_gadget_register_driver_owner()
1707 		driver_unregister(&driver->driver);  in usb_gadget_register_driver_owner()
1714 	if (!driver || !driver->unbind)  in usb_gadget_unregister_driver()
1715 		return -EINVAL;  in usb_gadget_unregister_driver()
1717 	driver_unregister(&driver->driver);  in usb_gadget_unregister_driver()
1722 /* ------------------------------------------------------------------------- */
1730 		usb_gadget_wakeup(udc->gadget);  in srp_store()
1734 static DEVICE_ATTR_WO(srp);
1742 	device_lock(&udc->gadget->dev);  in soft_connect_store()
1743 	if (!udc->driver) {  in soft_connect_store()
1744 		dev_err(dev, "soft-connect without a gadget driver\n");  in soft_connect_store()
1745 		ret = -EOPNOTSUPP;  in soft_connect_store()
1750 		mutex_lock(&udc->connect_lock);  in soft_connect_store()
1752 		usb_gadget_connect_locked(udc->gadget);  in soft_connect_store()
1753 		mutex_unlock(&udc->connect_lock);  in soft_connect_store()
1755 		mutex_lock(&udc->connect_lock);  in soft_connect_store()
1756 		usb_gadget_disconnect_locked(udc->gadget);  in soft_connect_store()
1758 		mutex_unlock(&udc->connect_lock);  in soft_connect_store()
1761 		ret = -EINVAL;  in soft_connect_store()
1767 	device_unlock(&udc->gadget->dev);  in soft_connect_store()
1776 	struct usb_gadget	*gadget = udc->gadget;  in state_show()
1778 	return sprintf(buf, "%s\n", usb_state_string(gadget->state));  in state_show()
1790 	drv = udc->driver;  in function_show()
1791 	if (drv && drv->function)  in function_show()
1792 		rc = scnprintf(buf, PAGE_SIZE, "%s\n", drv->function);  in function_show()
1804 			usb_speed_string(udc->gadget->param));		\
1816 	struct usb_gadget	*gadget = udc->gadget;		\
1818 	return scnprintf(buf, PAGE_SIZE, "%d\n", gadget->name);	\
1860 	ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);  in usb_udc_uevent()
1867 	if (udc->driver)  in usb_udc_uevent()
1869 				udc->driver->function);  in usb_udc_uevent()