forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da 
 kernel/drivers/usb/gadget/udc/core.c
....@@ -1,5 +1,5 @@
11 // SPDX-License-Identifier: GPL-2.0
2
-/**
2
+/*
33  * udc.c - Core UDC Framework
44  *
55  * Copyright (C) 2010 Texas Instruments
....@@ -23,12 +23,13 @@
2323 
2424 /**
2525  * struct usb_udc - describes one usb device controller
26
- * @driver - the gadget driver pointer. For use by the class code
27
- * @dev - the child device to the actual controller
28
- * @gadget - the gadget. For use by the class code
29
- * @list - for use by the udc class driver
30
- * @vbus - for udcs who care about vbus status, this value is real vbus status;
26
+ * @driver: the gadget driver pointer. For use by the class code
27
+ * @dev: the child device to the actual controller
28
+ * @gadget: the gadget. For use by the class code
29
+ * @list: for use by the udc class driver
30
+ * @vbus: for udcs who care about vbus status, this value is real vbus status;
3131  * for udcs who do not care about vbus status, this value is always true
32
+ * @started: the UDC's started state. True if the UDC had started.
3233  *
3334  * This represents the internal data structure which is used by the UDC-class
3435  * to hold information about udc driver and gadget together.
....@@ -39,6 +40,7 @@
3940 	struct device			dev;
4041 	struct list_head		list;
4142 	bool				vbus;
43
+	bool				started;
4244 };
4345 
4446 static struct class *udc_class;
....@@ -85,9 +87,9 @@
8587  * for interrupt transfers as well as bulk, but it likely couldn't be used
8688  * for iso transfers or for endpoint 14.  some endpoints are fully
8789  * configurable, with more generic names like "ep-a".  (remember that for
88
- * USB, "in" means "towards the USB master".)
90
+ * USB, "in" means "towards the USB host".)
8991  *
90
- * This routine must be called in process context.
92
+ * This routine may be called in an atomic (interrupt) context.
9193  *
9294  * returns zero, or a negative error code.
9395  */
....@@ -132,7 +134,7 @@
132134  * gadget drivers must call usb_ep_enable() again before queueing
133135  * requests to the endpoint.
134136  *
135
- * This routine must be called in process context.
137
+ * This routine may be called in an atomic (interrupt) context.
136138  *
137139  * returns zero, or a negative error code.
138140  */
....@@ -292,10 +294,10 @@
292294  * @ep:the endpoint associated with the request
293295  * @req:the request being canceled
294296  *
295
- * If the request is still active on the endpoint, it is dequeued and its
296
- * completion routine is called (with status -ECONNRESET); else a negative
297
- * error code is returned. This is guaranteed to happen before the call to
298
- * usb_ep_dequeue() returns.
297
+ * If the request is still active on the endpoint, it is dequeued and
298
+ * eventually its completion routine is called (with status -ECONNRESET);
299
+ * else a negative error code is returned.  This routine is asynchronous,
300
+ * that is, it may return before the completion routine runs.
299301  *
300302  * Note that some hardware can't clear out write fifos (to unlink the request
301303  * at the head of the queue) except as part of disconnecting from usb. Such
....@@ -507,43 +509,6 @@
507509 EXPORT_SYMBOL_GPL(usb_gadget_wakeup);
508510 
509511 /**
510
- * usb_gsi_ep_op - performs operation on GSI accelerated EP based on EP op code
511
- *
512
- * Operations such as EP configuration, TRB allocation, StartXfer etc.
513
- * See gsi_ep_op for more details.
514
- */
515
-int usb_gsi_ep_op(struct usb_ep *ep,
516
-		struct usb_gsi_request *req, enum gsi_ep_op op)
517
-{
518
-	if (ep && ep->ops && ep->ops->gsi_ep_op)
519
-		return ep->ops->gsi_ep_op(ep, req, op);
520
-
521
-	return -EOPNOTSUPP;
522
-}
523
-EXPORT_SYMBOL_GPL(usb_gsi_ep_op);
524
-
525
-/**
526
- * usb_gadget_func_wakeup - send a function remote wakeup up notification
527
- * to the host connected to this gadget
528
- * @gadget: controller used to wake up the host
529
- * @interface_id: the interface which triggered the remote wakeup event
530
- *
531
- * Returns zero on success. Otherwise, negative error code is returned.
532
- */
533
-int usb_gadget_func_wakeup(struct usb_gadget *gadget,
534
-	int interface_id)
535
-{
536
-	if (!gadget || (gadget->speed != USB_SPEED_SUPER))
537
-		return -EOPNOTSUPP;
538
-
539
-	if (!gadget->ops || !gadget->ops->func_wakeup)
540
-		return -EOPNOTSUPP;
541
-
542
-	return gadget->ops->func_wakeup(gadget, interface_id);
543
-}
544
-EXPORT_SYMBOL_GPL(usb_gadget_func_wakeup);
545
-
546
-/**
547512  * usb_gadget_set_selfpowered - sets the device selfpowered feature.
548513  * @gadget:the device being declared as self-powered
549514  *
....@@ -738,6 +703,9 @@
738703  * as a disconnect (when a VBUS session is active).  Not all systems
739704  * support software pullup controls.
740705  *
706
+ * Following a successful disconnect, invoke the ->disconnect() callback
707
+ * for the current gadget driver so that UDC drivers don't need to.
708
+ *
741709  * Returns zero on success, else negative errno.
742710  */
743711 int usb_gadget_disconnect(struct usb_gadget *gadget)
....@@ -748,6 +716,9 @@
748716 		ret = -EOPNOTSUPP;
749717 		goto out;
750718 	}
719
+
720
+	if (!gadget->connected)
721
+		goto out;
751722 
752723 	if (gadget->deactivated) {
753724 		/*
....@@ -761,6 +732,9 @@
761732 	ret = gadget->ops->pullup(gadget, 0);
762733 	if (!ret)
763734 		gadget->connected = 0;
735
+
736
+	if (gadget->udc->driver)
737
+		gadget->udc->driver->disconnect(gadget);
764738 
765739 out:
766740 	trace_usb_gadget_disconnect(gadget, ret);
....@@ -787,7 +761,7 @@
787761 	if (!gadget || gadget->deactivated)
788762 		goto out;
789763 
790
-	if (gadget->connected && !gadget->uvc_enabled) {
764
+	if (gadget->connected) {
791765 		ret = usb_gadget_disconnect(gadget);
792766 		if (ret)
793767 			goto out;
....@@ -923,6 +897,9 @@
923897 
924898 /**
925899  * usb_gadget_giveback_request - give the request back to the gadget layer
900
+ * @ep: the endpoint to be used with with the request
901
+ * @req: the request being given back
902
+ *
926903  * Context: in_interrupt()
927904  *
928905  * This is called by device controller drivers in order to return the
....@@ -1030,6 +1007,25 @@
10301007 }
10311008 EXPORT_SYMBOL_GPL(usb_gadget_ep_match_desc);
10321009 
1010
+/**
1011
+ * usb_gadget_check_config - checks if the UDC can support the binded
1012
+ *	configuration
1013
+ * @gadget: controller to check the USB configuration
1014
+ *
1015
+ * Ensure that a UDC is able to support the requested resources by a
1016
+ * configuration, and that there are no resource limitations, such as
1017
+ * internal memory allocated to all requested endpoints.
1018
+ *
1019
+ * Returns zero on success, else a negative errno.
1020
+ */
1021
+int usb_gadget_check_config(struct usb_gadget *gadget)
1022
+{
1023
+	if (gadget->ops->check_config)
1024
+		return gadget->ops->check_config(gadget);
1025
+	return 0;
1026
+}
1027
+EXPORT_SYMBOL_GPL(usb_gadget_check_config);
1028
+
10331029 /* ------------------------------------------------------------------------- */
10341030 
10351031 static void usb_gadget_state_work(struct work_struct *work)
....@@ -1051,12 +1047,16 @@
10511047 
10521048 /* ------------------------------------------------------------------------- */
10531049 
1054
-static void usb_udc_connect_control(struct usb_udc *udc)
1050
+static int usb_udc_connect_control(struct usb_udc *udc)
10551051 {
1052
+	int ret;
1053
+
10561054 	if (udc->vbus)
1057
-		usb_gadget_connect(udc->gadget);
1055
+		ret = usb_gadget_connect(udc->gadget);
10581056 	else
1059
-		usb_gadget_disconnect(udc->gadget);
1057
+		ret = usb_gadget_disconnect(udc->gadget);
1058
+
1059
+	return ret;
10601060 }
10611061 
10621062 /**
....@@ -1111,13 +1111,23 @@
11111111  */
11121112 static inline int usb_gadget_udc_start(struct usb_udc *udc)
11131113 {
1114
-	return udc->gadget->ops->udc_start(udc->gadget, udc->driver);
1114
+	int ret;
1115
+
1116
+	if (udc->started) {
1117
+		dev_err(&udc->dev, "UDC had already started\n");
1118
+		return -EBUSY;
1119
+	}
1120
+
1121
+	ret = udc->gadget->ops->udc_start(udc->gadget, udc->driver);
1122
+	if (!ret)
1123
+		udc->started = true;
1124
+
1125
+	return ret;
11151126 }
11161127 
11171128 /**
11181129  * usb_gadget_udc_stop - tells usb device controller we don't need it anymore
1119
- * @gadget: The device we want to stop activity
1120
- * @driver: The driver to unbind from @gadget
1130
+ * @udc: The UDC to be stopped
11211131  *
11221132  * This call is issued by the UDC Class driver after calling
11231133  * gadget driver's unbind() method.
....@@ -1128,7 +1138,13 @@
11281138  */
11291139 static inline void usb_gadget_udc_stop(struct usb_udc *udc)
11301140 {
1141
+	if (!udc->started) {
1142
+		dev_err(&udc->dev, "UDC had already stopped\n");
1143
+		return;
1144
+	}
1145
+
11311146 	udc->gadget->ops->udc_stop(udc->gadget);
1147
+	udc->started = false;
11321148 }
11331149 
11341150 /**
....@@ -1144,12 +1160,65 @@
11441160 static inline void usb_gadget_udc_set_speed(struct usb_udc *udc,
11451161 					    enum usb_device_speed speed)
11461162 {
1147
-	if (udc->gadget->ops->udc_set_speed) {
1148
-		enum usb_device_speed s;
1163
+	struct usb_gadget *gadget = udc->gadget;
1164
+	enum usb_device_speed s;
11491165 
1150
-		s = min(speed, udc->gadget->max_speed);
1151
-		udc->gadget->ops->udc_set_speed(udc->gadget, s);
1152
-	}
1166
+	if (speed == USB_SPEED_UNKNOWN)
1167
+		s = gadget->max_speed;
1168
+	else
1169
+		s = min(speed, gadget->max_speed);
1170
+
1171
+	if (s == USB_SPEED_SUPER_PLUS && gadget->ops->udc_set_ssp_rate)
1172
+		gadget->ops->udc_set_ssp_rate(gadget, gadget->max_ssp_rate);
1173
+	else if (gadget->ops->udc_set_speed)
1174
+		gadget->ops->udc_set_speed(gadget, s);
1175
+}
1176
+
1177
+/**
1178
+ * usb_gadget_enable_async_callbacks - tell usb device controller to enable asynchronous callbacks
1179
+ * @udc: The UDC which should enable async callbacks
1180
+ *
1181
+ * This routine is used when binding gadget drivers.  It undoes the effect
1182
+ * of usb_gadget_disable_async_callbacks(); the UDC driver should enable IRQs
1183
+ * (if necessary) and resume issuing callbacks.
1184
+ *
1185
+ * This routine will always be called in process context.
1186
+ */
1187
+static inline void usb_gadget_enable_async_callbacks(struct usb_udc *udc)
1188
+{
1189
+	struct usb_gadget *gadget = udc->gadget;
1190
+
1191
+	if (gadget->ops->udc_async_callbacks)
1192
+		gadget->ops->udc_async_callbacks(gadget, true);
1193
+}
1194
+
1195
+/**
1196
+ * usb_gadget_disable_async_callbacks - tell usb device controller to disable asynchronous callbacks
1197
+ * @udc: The UDC which should disable async callbacks
1198
+ *
1199
+ * This routine is used when unbinding gadget drivers.  It prevents a race:
1200
+ * The UDC driver doesn't know when the gadget driver's ->unbind callback
1201
+ * runs, so unless it is told to disable asynchronous callbacks, it might
1202
+ * issue a callback (such as ->disconnect) after the unbind has completed.
1203
+ *
1204
+ * After this function runs, the UDC driver must suppress all ->suspend,
1205
+ * ->resume, ->disconnect, ->reset, and ->setup callbacks to the gadget driver
1206
+ * until async callbacks are again enabled.  A simple-minded but effective
1207
+ * way to accomplish this is to tell the UDC hardware not to generate any
1208
+ * more IRQs.
1209
+ *
1210
+ * Request completion callbacks must still be issued.  However, it's okay
1211
+ * to defer them until the request is cancelled, since the pull-up will be
1212
+ * turned off during the time period when async callbacks are disabled.
1213
+ *
1214
+ * This routine will always be called in process context.
1215
+ */
1216
+static inline void usb_gadget_disable_async_callbacks(struct usb_udc *udc)
1217
+{
1218
+	struct usb_gadget *gadget = udc->gadget;
1219
+
1220
+	if (gadget->ops->udc_async_callbacks)
1221
+		gadget->ops->udc_async_callbacks(gadget, false);
11531222 }
11541223 
11551224 /**
....@@ -1194,21 +1263,18 @@
11941263 }
11951264 
11961265 /**
1197
- * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
1266
+ * usb_initialize_gadget - initialize a gadget and its embedded struct device
11981267  * @parent: the parent device to this udc. Usually the controller driver's
11991268  * device.
1200
- * @gadget: the gadget to be added to the list.
1269
+ * @gadget: the gadget to be initialized.
12011270  * @release: a gadget release function.
12021271  *
12031272  * Returns zero on success, negative errno otherwise.
12041273  * Calls the gadget release function in the latter case.
12051274  */
1206
-int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
1275
+void usb_initialize_gadget(struct device *parent, struct usb_gadget *gadget,
12071276 		void (*release)(struct device *dev))
12081277 {
1209
-	struct usb_udc		*udc;
1210
-	int			ret = -ENOMEM;
1211
-
12121278 	dev_set_name(&gadget->dev, "gadget");
12131279 	INIT_WORK(&gadget->work, usb_gadget_state_work);
12141280 	gadget->dev.parent = parent;
....@@ -1219,17 +1285,32 @@
12191285 		gadget->dev.release = usb_udc_nop_release;
12201286 
12211287 	device_initialize(&gadget->dev);
1288
+}
1289
+EXPORT_SYMBOL_GPL(usb_initialize_gadget);
1290
+
1291
+/**
1292
+ * usb_add_gadget - adds a new gadget to the udc class driver list
1293
+ * @gadget: the gadget to be added to the list.
1294
+ *
1295
+ * Returns zero on success, negative errno otherwise.
1296
+ * Does not do a final usb_put_gadget() if an error occurs.
1297
+ */
1298
+int usb_add_gadget(struct usb_gadget *gadget)
1299
+{
1300
+	struct usb_udc		*udc;
1301
+	int			ret = -ENOMEM;
12221302 
12231303 	udc = kzalloc(sizeof(*udc), GFP_KERNEL);
12241304 	if (!udc)
1225
-		goto err_put_gadget;
1305
+		goto error;
12261306 
12271307 	device_initialize(&udc->dev);
12281308 	udc->dev.release = usb_udc_release;
12291309 	udc->dev.class = udc_class;
12301310 	udc->dev.groups = usb_udc_attr_groups;
1231
-	udc->dev.parent = parent;
1232
-	ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
1311
+	udc->dev.parent = gadget->dev.parent;
1312
+	ret = dev_set_name(&udc->dev, "%s",
1313
+			kobject_name(&gadget->dev.parent->kobj));
12331314 	if (ret)
12341315 		goto err_put_udc;
12351316 
....@@ -1239,6 +1320,8 @@
12391320 
12401321 	udc->gadget = gadget;
12411322 	gadget->udc = udc;
1323
+
1324
+	udc->started = false;
12421325 
12431326 	mutex_lock(&udc_lock);
12441327 	list_add_tail(&udc->list, &udc_list);
....@@ -1260,6 +1343,7 @@
12601343 	return 0;
12611344 
12621345  err_del_udc:
1346
+	flush_work(&gadget->work);
12631347 	device_del(&udc->dev);
12641348 
12651349  err_unlist_udc:
....@@ -1271,8 +1355,30 @@
12711355  err_put_udc:
12721356 	put_device(&udc->dev);
12731357 
1274
- err_put_gadget:
1275
-	put_device(&gadget->dev);
1358
+ error:
1359
+	return ret;
1360
+}
1361
+EXPORT_SYMBOL_GPL(usb_add_gadget);
1362
+
1363
+/**
1364
+ * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
1365
+ * @parent: the parent device to this udc. Usually the controller driver's
1366
+ * device.
1367
+ * @gadget: the gadget to be added to the list.
1368
+ * @release: a gadget release function.
1369
+ *
1370
+ * Returns zero on success, negative errno otherwise.
1371
+ * Calls the gadget release function in the latter case.
1372
+ */
1373
+int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
1374
+		void (*release)(struct device *dev))
1375
+{
1376
+	int	ret;
1377
+
1378
+	usb_initialize_gadget(parent, gadget, release);
1379
+	ret = usb_add_gadget(gadget);
1380
+	if (ret)
1381
+		usb_put_gadget(gadget);
12761382 	return ret;
12771383 }
12781384 EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release);
....@@ -1329,23 +1435,25 @@
13291435 	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
13301436 
13311437 	usb_gadget_disconnect(udc->gadget);
1332
-	udc->driver->disconnect(udc->gadget);
1438
+	usb_gadget_disable_async_callbacks(udc);
1439
+	if (udc->gadget->irq)
1440
+		synchronize_irq(udc->gadget->irq);
13331441 	udc->driver->unbind(udc->gadget);
13341442 	usb_gadget_udc_stop(udc);
13351443 
13361444 	udc->driver = NULL;
1337
-	udc->dev.driver = NULL;
13381445 	udc->gadget->dev.driver = NULL;
13391446 }
13401447 
13411448 /**
1342
- * usb_del_gadget_udc - deletes @udc from udc_list
1449
+ * usb_del_gadget - deletes @udc from udc_list
13431450  * @gadget: the gadget to be removed.
13441451  *
1345
- * This, will call usb_gadget_unregister_driver() if
1452
+ * This will call usb_gadget_unregister_driver() if
13461453  * the @udc is still busy.
1454
+ * It will not do a final usb_put_gadget().
13471455  */
1348
-void usb_del_gadget_udc(struct usb_gadget *gadget)
1456
+void usb_del_gadget(struct usb_gadget *gadget)
13491457 {
13501458 	struct usb_udc *udc = gadget->udc;
13511459 
....@@ -1368,8 +1476,20 @@
13681476 	kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
13691477 	flush_work(&gadget->work);
13701478 	device_unregister(&udc->dev);
1371
-	device_unregister(&gadget->dev);
1372
-	memset(&gadget->dev, 0x00, sizeof(gadget->dev));
1479
+	device_del(&gadget->dev);
1480
+}
1481
+EXPORT_SYMBOL_GPL(usb_del_gadget);
1482
+
1483
+/**
1484
+ * usb_del_gadget_udc - deletes @udc from udc_list
1485
+ * @gadget: the gadget to be removed.
1486
+ *
1487
+ * Calls usb_del_gadget() and does a final usb_put_gadget().
1488
+ */
1489
+void usb_del_gadget_udc(struct usb_gadget *gadget)
1490
+{
1491
+	usb_del_gadget(gadget);
1492
+	usb_put_gadget(gadget);
13731493 }
13741494 EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
13751495 
....@@ -1383,7 +1503,6 @@
13831503 			driver->function);
13841504 
13851505 	udc->driver = driver;
1386
-	udc->dev.driver = &driver->driver;
13871506 	udc->gadget->dev.driver = &driver->driver;
13881507 
13891508 	usb_gadget_udc_set_speed(udc, driver->max_speed);
....@@ -1392,20 +1511,31 @@
13921511 	if (ret)
13931512 		goto err1;
13941513 	ret = usb_gadget_udc_start(udc);
1395
-	if (ret) {
1396
-		driver->unbind(udc->gadget);
1397
-		goto err1;
1398
-	}
1399
-	usb_udc_connect_control(udc);
1514
+	if (ret)
1515
+		goto err_start;
1516
+
1517
+	usb_gadget_enable_async_callbacks(udc);
1518
+	ret = usb_udc_connect_control(udc);
1519
+	if (ret)
1520
+		goto err_connect_control;
14001521 
14011522 	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
14021523 	return 0;
1524
+
1525
+err_connect_control:
1526
+	usb_gadget_disable_async_callbacks(udc);
1527
+	if (udc->gadget->irq)
1528
+		synchronize_irq(udc->gadget->irq);
1529
+	usb_gadget_udc_stop(udc);
1530
+
1531
+err_start:
1532
+	driver->unbind(udc->gadget);
1533
+
14031534 err1:
14041535 	if (ret != -EISNAM)
14051536 		dev_err(&udc->dev, "failed to start %s: %d\n",
14061537 			udc->driver->function, ret);
14071538 	udc->driver = NULL;
1408
-	udc->dev.driver = NULL;
14091539 	udc->gadget->dev.driver = NULL;
14101540 	return ret;
14111541 }
....@@ -1447,6 +1577,8 @@
14471577 	}
14481578 
14491579 	mutex_unlock(&udc_lock);
1580
+	if (ret)
1581
+		pr_warn("udc-core: couldn't find an available UDC or it's busy\n");
14501582 	return ret;
14511583 found:
14521584 	ret = udc_bind_to_driver(udc, driver);
....@@ -1522,7 +1654,6 @@
15221654 		usb_gadget_connect(udc->gadget);
15231655 	} else if (sysfs_streq(buf, "disconnect")) {
15241656 		usb_gadget_disconnect(udc->gadget);
1525
-		udc->driver->disconnect(udc->gadget);
15261657 		usb_gadget_udc_stop(udc);
15271658 	} else {
15281659 		dev_err(dev, "unsupported command '%s'\n", buf);