add gpio led uart

hc

2024-05-10 748e4f3d702def1a4bff191e0cf93b6a05340f01

 kernel/drivers/usb/core/driver.c
..
..
@@ -34,6 +34,7 @@
34
34
 
35
35
 #include "usb.h"
36
36
 
37
+#include <trace/hooks/usb.h>
37
38
 
38
39
 /*
39
40
  * Adds a new dynamic USBdevice ID to this driver,
..
..
@@ -261,9 +262,41 @@
261
262
 	 */
262
263
 	if (!udriver->supports_autosuspend)
263
264
 		error = usb_autoresume_device(udev);
265
+	if (error)
266
+		return error;
264
267
 
265
-	if (!error)
266
-		error = udriver->probe(udev);
268
+	if (udriver->generic_subclass)
269
+		error = usb_generic_driver_probe(udev);
270
+	if (error)
271
+		return error;
272
+
273
+	/* Probe the USB device with the driver in hand, but only
274
+	 * defer to a generic driver in case the current USB
275
+	 * device driver has an id_table or a match function; i.e.,
276
+	 * when the device driver was explicitly matched against
277
+	 * a device.
278
+	 *
279
+	 * If the device driver does not have either of these,
280
+	 * then we assume that it can bind to any device and is
281
+	 * not truly a more specialized/non-generic driver, so a
282
+	 * return value of -ENODEV should not force the device
283
+	 * to be handled by the generic USB driver, as there
284
+	 * can still be another, more specialized, device driver.
285
+	 *
286
+	 * This accommodates the usbip driver.
287
+	 *
288
+	 * TODO: What if, in the future, there are multiple
289
+	 * specialized USB device drivers for a particular device?
290
+	 * In such cases, there is a need to try all matching
291
+	 * specialised device drivers prior to setting the
292
+	 * use_generic_driver bit.
293
+	 */
294
+	error = udriver->probe(udev);
295
+	if (error == -ENODEV && udriver != &usb_generic_driver &&
296
+	    (udriver->id_table || udriver->match)) {
297
+		udev->use_generic_driver = 1;
298
+		return -EPROBE_DEFER;
299
+	}
267
300
 	return error;
268
301
 }
269
302
 
..
..
@@ -273,7 +306,10 @@
273
306
 	struct usb_device *udev = to_usb_device(dev);
274
307
 	struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
275
308
 
276
-	udriver->disconnect(udev);
309
+	if (udriver->disconnect)
310
+		udriver->disconnect(udev);
311
+	if (udriver->generic_subclass)
312
+		usb_generic_driver_disconnect(udev);
277
313
 	if (!udriver->supports_autosuspend)
278
314
 		usb_autosuspend_device(udev);
279
315
 	return 0;
..
..
@@ -505,7 +541,6 @@
505
541
 				struct usb_interface *iface, void *priv)
506
542
 {
507
543
 	struct device *dev;
508
-	struct usb_device *udev;
509
544
 	int retval = 0;
510
545
 
511
546
 	if (!iface)
..
..
@@ -518,8 +553,6 @@
518
553
 	/* reject claim if interface is not authorized */
519
554
 	if (!iface->authorized)
520
555
 		return -ENODEV;
521
-
522
-	udev = interface_to_usbdev(iface);
523
556
 
524
557
 	dev->driver = &driver->drvwrap.driver;
525
558
 	usb_set_intfdata(iface, priv);
..
..
@@ -793,17 +826,58 @@
793
826
 }
794
827
 EXPORT_SYMBOL_GPL(usb_match_id);
795
828
 
829
+const struct usb_device_id *usb_device_match_id(struct usb_device *udev,
830
+				const struct usb_device_id *id)
831
+{
832
+	if (!id)
833
+		return NULL;
834
+
835
+	for (; id->idVendor || id->idProduct ; id++) {
836
+		if (usb_match_device(udev, id))
837
+			return id;
838
+	}
839
+
840
+	return NULL;
841
+}
842
+
843
+bool usb_driver_applicable(struct usb_device *udev,
844
+			   struct usb_device_driver *udrv)
845
+{
846
+	if (udrv->id_table && udrv->match)
847
+		return usb_device_match_id(udev, udrv->id_table) != NULL &&
848
+		       udrv->match(udev);
849
+
850
+	if (udrv->id_table)
851
+		return usb_device_match_id(udev, udrv->id_table) != NULL;
852
+
853
+	if (udrv->match)
854
+		return udrv->match(udev);
855
+
856
+	return false;
857
+}
858
+
796
859
 static int usb_device_match(struct device *dev, struct device_driver *drv)
797
860
 {
798
861
 	/* devices and interfaces are handled separately */
799
862
 	if (is_usb_device(dev)) {
863
+		struct usb_device *udev;
864
+		struct usb_device_driver *udrv;
800
865
 
801
866
 		/* interface drivers never match devices */
802
867
 		if (!is_usb_device_driver(drv))
803
868
 			return 0;
804
869
 
805
-		/* TODO: Add real matching code */
806
-		return 1;
870
+		udev = to_usb_device(dev);
871
+		udrv = to_usb_device_driver(drv);
872
+
873
+		/* If the device driver under consideration does not have a
874
+		 * id_table or a match function, then let the driver's probe
875
+		 * function decide.
876
+		 */
877
+		if (!udrv->id_table && !udrv->match)
878
+			return 1;
879
+
880
+		return usb_driver_applicable(udev, udrv);
807
881
 
808
882
 	} else if (is_usb_interface(dev)) {
809
883
 		struct usb_interface *intf;
..
..
@@ -870,6 +944,27 @@
870
944
 	return 0;
871
945
 }
872
946
 
947
+static int __usb_bus_reprobe_drivers(struct device *dev, void *data)
948
+{
949
+	struct usb_device_driver *new_udriver = data;
950
+	struct usb_device *udev;
951
+	int ret;
952
+
953
+	/* Don't reprobe if current driver isn't usb_generic_driver */
954
+	if (dev->driver != &usb_generic_driver.drvwrap.driver)
955
+		return 0;
956
+
957
+	udev = to_usb_device(dev);
958
+	if (!usb_driver_applicable(udev, new_udriver))
959
+		return 0;
960
+
961
+	ret = device_reprobe(dev);
962
+	if (ret && ret != -EPROBE_DEFER)
963
+		dev_err(dev, "Failed to reprobe device (error %d)\n", ret);
964
+
965
+	return 0;
966
+}
967
+
873
968
 /**
874
969
  * usb_register_device_driver - register a USB device (not interface) driver
875
970
  * @new_udriver: USB operations for the device driver
..
..
@@ -895,16 +990,23 @@
895
990
 	new_udriver->drvwrap.driver.probe = usb_probe_device;
896
991
 	new_udriver->drvwrap.driver.remove = usb_unbind_device;
897
992
 	new_udriver->drvwrap.driver.owner = owner;
993
+	new_udriver->drvwrap.driver.dev_groups = new_udriver->dev_groups;
898
994
 
899
995
 	retval = driver_register(&new_udriver->drvwrap.driver);
900
996
 
901
-	if (!retval)
997
+	if (!retval) {
902
998
 		pr_info("%s: registered new device driver %s\n",
903
999
 			usbcore_name, new_udriver->name);
904
-	else
905
-		printk(KERN_ERR "%s: error %d registering device "
906
-			"	driver %s\n",
1000
+		/*
1001
+		 * Check whether any device could be better served with
1002
+		 * this new driver
1003
+		 */
1004
+		bus_for_each_dev(&usb_bus_type, NULL, new_udriver,
1005
+				 __usb_bus_reprobe_drivers);
1006
+	} else {
1007
+		pr_err("%s: error %d registering device driver %s\n",
907
1008
 			usbcore_name, retval, new_udriver->name);
1009
+	}
908
1010
 
909
1011
 	return retval;
910
1012
 }
..
..
@@ -957,6 +1059,7 @@
957
1059
 	new_driver->drvwrap.driver.remove = usb_unbind_interface;
958
1060
 	new_driver->drvwrap.driver.owner = owner;
959
1061
 	new_driver->drvwrap.driver.mod_name = mod_name;
1062
+	new_driver->drvwrap.driver.dev_groups = new_driver->dev_groups;
960
1063
 	spin_lock_init(&new_driver->dynids.lock);
961
1064
 	INIT_LIST_HEAD(&new_driver->dynids.list);
962
1065
 
..
..
@@ -977,9 +1080,8 @@
977
1080
 out_newid:
978
1081
 	driver_unregister(&new_driver->drvwrap.driver);
979
1082
 
980
-	printk(KERN_ERR "%s: error %d registering interface "
981
-			"	driver %s\n",
982
-			usbcore_name, retval, new_driver->name);
1083
+	pr_err("%s: error %d registering interface driver %s\n",
1084
+		usbcore_name, retval, new_driver->name);
983
1085
 	goto out;
984
1086
 }
985
1087
 EXPORT_SYMBOL_GPL(usb_register_driver);
..
..
@@ -1150,7 +1252,10 @@
1150
1252
 		udev->do_remote_wakeup = 0;
1151
1253
 		udriver = &usb_generic_driver;
1152
1254
 	}
1153
-	status = udriver->suspend(udev, msg);
1255
+	if (udriver->suspend)
1256
+		status = udriver->suspend(udev, msg);
1257
+	if (status == 0 && udriver->generic_subclass)
1258
+		status = usb_generic_driver_suspend(udev, msg);
1154
1259
 
1155
1260
  done:
1156
1261
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
..
..
@@ -1182,7 +1287,10 @@
1182
1287
 		udev->reset_resume = 1;
1183
1288
 
1184
1289
 	udriver = to_usb_device_driver(udev->dev.driver);
1185
-	status = udriver->resume(udev, msg);
1290
+	if (udriver->generic_subclass)
1291
+		status = usb_generic_driver_resume(udev, msg);
1292
+	if (status == 0 && udriver->resume)
1293
+		status = udriver->resume(udev, msg);
1186
1294
 
1187
1295
  done:
1188
1296
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
..
..
@@ -1296,9 +1404,14 @@
1296
1404
 	int			status = 0;
1297
1405
 	int			i = 0, n = 0;
1298
1406
 	struct usb_interface	*intf;
1407
+	int			bypass = 0;
1299
1408
 
1300
1409
 	if (udev->state == USB_STATE_NOTATTACHED ||
1301
1410
 			udev->state == USB_STATE_SUSPENDED)
1411
+		goto done;
1412
+
1413
+	trace_android_vh_usb_dev_suspend(udev, msg, &bypass);
1414
+	if (bypass)
1302
1415
 		goto done;
1303
1416
 
1304
1417
 	/* Suspend all the interfaces and then udev itself */
..
..
@@ -1397,11 +1510,17 @@
1397
1510
 	int			status = 0;
1398
1511
 	int			i;
1399
1512
 	struct usb_interface	*intf;
1513
+	int			bypass = 0;
1400
1514
 
1401
1515
 	if (udev->state == USB_STATE_NOTATTACHED) {
1402
1516
 		status = -ENODEV;
1403
1517
 		goto done;
1404
1518
 	}
1519
+
1520
+	trace_android_vh_usb_dev_resume(udev, msg, &bypass);
1521
+	if (bypass)
1522
+		goto done;
1523
+
1405
1524
 	udev->can_submit = 1;
1406
1525
 
1407
1526
 	/* Resume the device */
..
..
@@ -1458,9 +1577,6 @@
1458
1577
 	struct usb_device	*udev = to_usb_device(dev);
1459
1578
 	int r;
1460
1579
 
1461
-	if (udev->bus->skip_resume && udev->state == USB_STATE_SUSPENDED)
1462
-		return 0;
1463
-
1464
1580
 	unbind_no_pm_drivers_interfaces(udev);
1465
1581
 
1466
1582
 	/* From now on we are sure all drivers support suspend/resume
..
..
@@ -1496,15 +1612,6 @@
1496
1612
 {
1497
1613
 	struct usb_device	*udev = to_usb_device(dev);
1498
1614
 	int			status;
1499
-
1500
-	/*
1501
-	 * Some buses would like to keep their devices in suspend
1502
-	 * state after system resume.  Their resume happen when
1503
-	 * a remote wakeup is detected or interface driver start
1504
-	 * I/O.
1505
-	 */
1506
-	if (udev->bus->skip_resume)
1507
-		return 0;
1508
1615
 
1509
1616
 	/* For all calls, take the device back to full power and
1510
1617
 	 * tell the PM core in case it was autosuspended previously.