forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/drivers/usb/core/usb-acpi.c
....@@ -37,6 +37,71 @@
3737 }
3838 EXPORT_SYMBOL_GPL(usb_acpi_power_manageable);
3939 
40
+#define UUID_USB_CONTROLLER_DSM "ce2ee385-00e6-48cb-9f05-2edb927c4899"
41
+#define USB_DSM_DISABLE_U1_U2_FOR_PORT	5
42
+
43
+/**
44
+ * usb_acpi_port_lpm_incapable - check if lpm should be disabled for a port.
45
+ * @hdev: USB device belonging to the usb hub
46
+ * @index: zero based port index
47
+ *
48
+ * Some USB3 ports may not support USB3 link power management U1/U2 states
49
+ * due to different retimer setup. ACPI provides _DSM method which returns 0x01
50
+ * if U1 and U2 states should be disabled. Evaluate _DSM with:
51
+ * Arg0: UUID = ce2ee385-00e6-48cb-9f05-2edb927c4899
52
+ * Arg1: Revision ID = 0
53
+ * Arg2: Function Index = 5
54
+ * Arg3: (empty)
55
+ *
56
+ * Return 1 if USB3 port is LPM incapable, negative on error, otherwise 0
57
+ */
58
+
59
+int usb_acpi_port_lpm_incapable(struct usb_device *hdev, int index)
60
+{
61
+	union acpi_object *obj;
62
+	acpi_handle port_handle;
63
+	int port1 = index + 1;
64
+	guid_t guid;
65
+	int ret;
66
+
67
+	ret = guid_parse(UUID_USB_CONTROLLER_DSM, &guid);
68
+	if (ret)
69
+		return ret;
70
+
71
+	port_handle = usb_get_hub_port_acpi_handle(hdev, port1);
72
+	if (!port_handle) {
73
+		dev_dbg(&hdev->dev, "port-%d no acpi handle\n", port1);
74
+		return -ENODEV;
75
+	}
76
+
77
+	if (!acpi_check_dsm(port_handle, &guid, 0,
78
+			    BIT(USB_DSM_DISABLE_U1_U2_FOR_PORT))) {
79
+		dev_dbg(&hdev->dev, "port-%d no _DSM function %d\n",
80
+			port1, USB_DSM_DISABLE_U1_U2_FOR_PORT);
81
+		return -ENODEV;
82
+	}
83
+
84
+	obj = acpi_evaluate_dsm(port_handle, &guid, 0,
85
+				USB_DSM_DISABLE_U1_U2_FOR_PORT, NULL);
86
+
87
+	if (!obj)
88
+		return -ENODEV;
89
+
90
+	if (obj->type != ACPI_TYPE_INTEGER) {
91
+		dev_dbg(&hdev->dev, "evaluate port-%d _DSM failed\n", port1);
92
+		ACPI_FREE(obj);
93
+		return -EINVAL;
94
+	}
95
+
96
+	if (obj->integer.value == 0x01)
97
+		ret = 1;
98
+
99
+	ACPI_FREE(obj);
100
+
101
+	return ret;
102
+}
103
+EXPORT_SYMBOL_GPL(usb_acpi_port_lpm_incapable);
104
+
40105 /**
41106  * usb_acpi_set_power_state - control usb port's power via acpi power
42107  * resource
....@@ -86,7 +151,7 @@
86151 {
87152 	enum usb_port_connect_type connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
88153 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
89
-	union acpi_object *upc;
154
+	union acpi_object *upc = NULL;
90155 	acpi_status status;
91156 
92157 	/*
....@@ -98,11 +163,12 @@
98163 	 * no connectable, the port would be not used.
99164 	 */
100165 	status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
101
-	upc = buffer.pointer;
102
-	if (!upc || (upc->type != ACPI_TYPE_PACKAGE)
103
-		|| upc->package.count != 4) {
166
+	if (ACPI_FAILURE(status))
104167 		goto out;
105
-	}
168
+
169
+	upc = buffer.pointer;
170
+	if (!upc || (upc->type != ACPI_TYPE_PACKAGE) || upc->package.count != 4)
171
+		goto out;
106172 
107173 	if (upc->package.elements[0].integer.value)
108174 		if (pld->user_visible)
....@@ -139,85 +205,122 @@
139205 	return acpi_find_child_device(parent, raw, false);
140206 }
141207 
142
-static struct acpi_device *usb_acpi_find_companion(struct device *dev)
208
+static struct acpi_device *
209
+usb_acpi_get_companion_for_port(struct usb_port *port_dev)
143210 {
144211 	struct usb_device *udev;
145212 	struct acpi_device *adev;
146213 	acpi_handle *parent_handle;
214
+	int port1;
215
+
216
+	/* Get the struct usb_device point of port's hub */
217
+	udev = to_usb_device(port_dev->dev.parent->parent);
147218 
148219 	/*
149
-	 * In the ACPI DSDT table, only usb root hub and usb ports are
150
-	 * acpi device nodes. The hierarchy like following.
220
+	 * The root hub ports' parent is the root hub. The non-root-hub
221
+	 * ports' parent is the parent hub port which the hub is
222
+	 * connected to.
223
+	 */
224
+	if (!udev->parent) {
225
+		adev = ACPI_COMPANION(&udev->dev);
226
+		port1 = usb_hcd_find_raw_port_number(bus_to_hcd(udev->bus),
227
+						     port_dev->portnum);
228
+	} else {
229
+		parent_handle = usb_get_hub_port_acpi_handle(udev->parent,
230
+							     udev->portnum);
231
+		if (!parent_handle)
232
+			return NULL;
233
+
234
+		acpi_bus_get_device(parent_handle, &adev);
235
+		port1 = port_dev->portnum;
236
+	}
237
+
238
+	return usb_acpi_find_port(adev, port1);
239
+}
240
+
241
+static struct acpi_device *
242
+usb_acpi_find_companion_for_port(struct usb_port *port_dev)
243
+{
244
+	struct acpi_device *adev;
245
+	struct acpi_pld_info *pld;
246
+	acpi_handle *handle;
247
+	acpi_status status;
248
+
249
+	adev = usb_acpi_get_companion_for_port(port_dev);
250
+	if (!adev)
251
+		return NULL;
252
+
253
+	handle = adev->handle;
254
+	status = acpi_get_physical_device_location(handle, &pld);
255
+	if (ACPI_SUCCESS(status) && pld) {
256
+		port_dev->location = USB_ACPI_LOCATION_VALID
257
+			| pld->group_token << 8 | pld->group_position;
258
+		port_dev->connect_type = usb_acpi_get_connect_type(handle, pld);
259
+		ACPI_FREE(pld);
260
+	}
261
+
262
+	return adev;
263
+}
264
+
265
+static struct acpi_device *
266
+usb_acpi_find_companion_for_device(struct usb_device *udev)
267
+{
268
+	struct acpi_device *adev;
269
+	struct usb_port *port_dev;
270
+	struct usb_hub *hub;
271
+
272
+	if (!udev->parent) {
273
+		/* root hub is only child (_ADR=0) under its parent, the HC */
274
+		adev = ACPI_COMPANION(udev->dev.parent);
275
+		return acpi_find_child_device(adev, 0, false);
276
+	}
277
+
278
+	hub = usb_hub_to_struct_hub(udev->parent);
279
+	if (!hub)
280
+		return NULL;
281
+
282
+	/*
283
+	 * This is an embedded USB device connected to a port and such
284
+	 * devices share port's ACPI companion.
285
+	 */
286
+	port_dev = hub->ports[udev->portnum - 1];
287
+	return usb_acpi_get_companion_for_port(port_dev);
288
+}
289
+
290
+static struct acpi_device *usb_acpi_find_companion(struct device *dev)
291
+{
292
+	/*
293
+	 * The USB hierarchy like following:
294
+	 *
151295 	 * Device (EHC1)
152296 	 *	Device (HUBN)
153297 	 *		Device (PR01)
154298 	 *			Device (PR11)
155299 	 *			Device (PR12)
300
+	 *				Device (FN12)
301
+	 *				Device (FN13)
156302 	 *			Device (PR13)
157303 	 *			...
158
-	 * So all binding process is divided into two parts. binding
159
-	 * root hub and usb ports.
304
+	 * where HUBN is root hub, and PRNN are USB ports and devices
305
+	 * connected to them, and FNNN are individualk functions for
306
+	 * connected composite USB devices. PRNN and FNNN may contain
307
+	 * _CRS and other methods describing sideband resources for
308
+	 * the connected device.
309
+	 *
310
+	 * On the kernel side both root hub and embedded USB devices are
311
+	 * represented as instances of usb_device structure, and ports
312
+	 * are represented as usb_port structures, so the whole process
313
+	 * is split into 2 parts: finding companions for devices and
314
+	 * finding companions for ports.
315
+	 *
316
+	 * Note that we do not handle individual functions of composite
317
+	 * devices yet, for that we would need to assign companions to
318
+	 * devices corresponding to USB interfaces.
160319 	 */
161
-	if (is_usb_device(dev)) {
162
-		udev = to_usb_device(dev);
163
-		if (udev->parent)
164
-			return NULL;
165
-
166
-		/* root hub is only child (_ADR=0) under its parent, the HC */
167
-		adev = ACPI_COMPANION(dev->parent);
168
-		return acpi_find_child_device(adev, 0, false);
169
-	} else if (is_usb_port(dev)) {
170
-		struct usb_port *port_dev = to_usb_port(dev);
171
-		int port1 = port_dev->portnum;
172
-		struct acpi_pld_info *pld;
173
-		acpi_handle *handle;
174
-		acpi_status status;
175
-
176
-		/* Get the struct usb_device point of port's hub */
177
-		udev = to_usb_device(dev->parent->parent);
178
-
179
-		/*
180
-		 * The root hub ports' parent is the root hub. The non-root-hub
181
-		 * ports' parent is the parent hub port which the hub is
182
-		 * connected to.
183
-		 */
184
-		if (!udev->parent) {
185
-			struct usb_hcd *hcd = bus_to_hcd(udev->bus);
186
-			int raw;
187
-
188
-			raw = usb_hcd_find_raw_port_number(hcd, port1);
189
-
190
-			adev = usb_acpi_find_port(ACPI_COMPANION(&udev->dev),
191
-						  raw);
192
-
193
-			if (!adev)
194
-				return NULL;
195
-		} else {
196
-			parent_handle =
197
-				usb_get_hub_port_acpi_handle(udev->parent,
198
-				udev->portnum);
199
-			if (!parent_handle)
200
-				return NULL;
201
-
202
-			acpi_bus_get_device(parent_handle, &adev);
203
-
204
-			adev = usb_acpi_find_port(adev, port1);
205
-
206
-			if (!adev)
207
-				return NULL;
208
-		}
209
-		handle = adev->handle;
210
-		status = acpi_get_physical_device_location(handle, &pld);
211
-		if (ACPI_FAILURE(status) || !pld)
212
-			return adev;
213
-
214
-		port_dev->location = USB_ACPI_LOCATION_VALID
215
-			| pld->group_token << 8 | pld->group_position;
216
-		port_dev->connect_type = usb_acpi_get_connect_type(handle, pld);
217
-		ACPI_FREE(pld);
218
-
219
-		return adev;
220
-	}
320
+	if (is_usb_device(dev))
321
+		return usb_acpi_find_companion_for_device(to_usb_device(dev));
322
+	else if (is_usb_port(dev))
323
+		return usb_acpi_find_companion_for_port(to_usb_port(dev));
221324 
222325 	return NULL;
223326 }