]> Git Repo - J-linux.git/blob - drivers/usb/core/usb-acpi.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / drivers / usb / core / usb-acpi.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * USB-ACPI glue code
4  *
5  * Copyright 2012 Red Hat <[email protected]>
6  */
7 #include <linux/module.h>
8 #include <linux/usb.h>
9 #include <linux/device.h>
10 #include <linux/errno.h>
11 #include <linux/kernel.h>
12 #include <linux/acpi.h>
13 #include <linux/pci.h>
14 #include <linux/usb/hcd.h>
15
16 #include "hub.h"
17
18 /**
19  * usb_acpi_power_manageable - check whether usb port has
20  * acpi power resource.
21  * @hdev: USB device belonging to the usb hub
22  * @index: port index based zero
23  *
24  * Return true if the port has acpi power resource and false if no.
25  */
26 bool usb_acpi_power_manageable(struct usb_device *hdev, int index)
27 {
28         acpi_handle port_handle;
29         int port1 = index + 1;
30
31         port_handle = usb_get_hub_port_acpi_handle(hdev,
32                 port1);
33         if (port_handle)
34                 return acpi_bus_power_manageable(port_handle);
35         else
36                 return false;
37 }
38 EXPORT_SYMBOL_GPL(usb_acpi_power_manageable);
39
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_typed(port_handle, &guid, 0,
85                                       USB_DSM_DISABLE_U1_U2_FOR_PORT, NULL,
86                                       ACPI_TYPE_INTEGER);
87         if (!obj) {
88                 dev_dbg(&hdev->dev, "evaluate port-%d _DSM failed\n", port1);
89                 return -EINVAL;
90         }
91
92         if (obj->integer.value == 0x01)
93                 ret = 1;
94
95         ACPI_FREE(obj);
96
97         return ret;
98 }
99 EXPORT_SYMBOL_GPL(usb_acpi_port_lpm_incapable);
100
101 /**
102  * usb_acpi_set_power_state - control usb port's power via acpi power
103  * resource
104  * @hdev: USB device belonging to the usb hub
105  * @index: port index based zero
106  * @enable: power state expected to be set
107  *
108  * Notice to use usb_acpi_power_manageable() to check whether the usb port
109  * has acpi power resource before invoking this function.
110  *
111  * Returns 0 on success, else negative errno.
112  */
113 int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
114 {
115         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
116         struct usb_port *port_dev;
117         acpi_handle port_handle;
118         unsigned char state;
119         int port1 = index + 1;
120         int error = -EINVAL;
121
122         if (!hub)
123                 return -ENODEV;
124         port_dev = hub->ports[port1 - 1];
125
126         port_handle = (acpi_handle) usb_get_hub_port_acpi_handle(hdev, port1);
127         if (!port_handle)
128                 return error;
129
130         if (enable)
131                 state = ACPI_STATE_D0;
132         else
133                 state = ACPI_STATE_D3_COLD;
134
135         error = acpi_bus_set_power(port_handle, state);
136         if (!error)
137                 dev_dbg(&port_dev->dev, "acpi: power was set to %d\n", enable);
138         else
139                 dev_dbg(&port_dev->dev, "acpi: power failed to be set\n");
140
141         return error;
142 }
143 EXPORT_SYMBOL_GPL(usb_acpi_set_power_state);
144
145 /**
146  * usb_acpi_add_usb4_devlink - add device link to USB4 Host Interface for tunneled USB3 devices
147  *
148  * @udev: Tunneled USB3 device connected to a roothub.
149  *
150  * Adds a device link between a tunneled USB3 device and the USB4 Host Interface
151  * device to ensure correct runtime PM suspend and resume order. This function
152  * should only be called for tunneled USB3 devices.
153  * The USB4 Host Interface this tunneled device depends on is found from the roothub
154  * port ACPI device specific data _DSD entry.
155  *
156  * Return: negative error code on failure, 0 otherwise
157  */
158 static int usb_acpi_add_usb4_devlink(struct usb_device *udev)
159 {
160         const struct device_link *link;
161         struct usb_port *port_dev;
162         struct usb_hub *hub;
163
164         if (!udev->parent || udev->parent->parent)
165                 return 0;
166
167         hub = usb_hub_to_struct_hub(udev->parent);
168         port_dev = hub->ports[udev->portnum - 1];
169
170         struct fwnode_handle *nhi_fwnode __free(fwnode_handle) =
171                 fwnode_find_reference(dev_fwnode(&port_dev->dev), "usb4-host-interface", 0);
172
173         if (IS_ERR(nhi_fwnode) || !nhi_fwnode->dev)
174                 return 0;
175
176         link = device_link_add(&port_dev->child->dev, nhi_fwnode->dev,
177                                DL_FLAG_STATELESS |
178                                DL_FLAG_RPM_ACTIVE |
179                                DL_FLAG_PM_RUNTIME);
180         if (!link) {
181                 dev_err(&port_dev->dev, "Failed to created device link from %s to %s\n",
182                         dev_name(&port_dev->child->dev), dev_name(nhi_fwnode->dev));
183                 return -EINVAL;
184         }
185
186         dev_dbg(&port_dev->dev, "Created device link from %s to %s\n",
187                 dev_name(&port_dev->child->dev), dev_name(nhi_fwnode->dev));
188
189         return 0;
190 }
191
192 /*
193  * Private to usb-acpi, all the core needs to know is that
194  * port_dev->location is non-zero when it has been set by the firmware.
195  */
196 #define USB_ACPI_LOCATION_VALID (1 << 31)
197
198 static void
199 usb_acpi_get_connect_type(struct usb_port *port_dev, acpi_handle *handle)
200 {
201         enum usb_port_connect_type connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
202         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
203         union acpi_object *upc = NULL;
204         struct acpi_pld_info *pld = NULL;
205         acpi_status status;
206
207         /*
208          * According to 9.14 in ACPI Spec 6.2. _PLD indicates whether usb port
209          * is user visible and _UPC indicates whether it is connectable. If
210          * the port was visible and connectable, it could be freely connected
211          * and disconnected with USB devices. If no visible and connectable,
212          * a usb device is directly hard-wired to the port. If no visible and
213          * no connectable, the port would be not used.
214          */
215
216         status = acpi_get_physical_device_location(handle, &pld);
217         if (ACPI_SUCCESS(status) && pld)
218                 port_dev->location = USB_ACPI_LOCATION_VALID |
219                         pld->group_token << 8 | pld->group_position;
220
221         status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
222         if (ACPI_FAILURE(status))
223                 goto out;
224
225         upc = buffer.pointer;
226         if (!upc || (upc->type != ACPI_TYPE_PACKAGE) || upc->package.count != 4)
227                 goto out;
228
229         /* UPC states port is connectable */
230         if (upc->package.elements[0].integer.value)
231                 if (!pld)
232                         ; /* keep connect_type as unknown */
233                 else if (pld->user_visible)
234                         connect_type = USB_PORT_CONNECT_TYPE_HOT_PLUG;
235                 else
236                         connect_type = USB_PORT_CONNECT_TYPE_HARD_WIRED;
237         else
238                 connect_type = USB_PORT_NOT_USED;
239 out:
240         port_dev->connect_type = connect_type;
241         kfree(upc);
242         ACPI_FREE(pld);
243 }
244
245 static struct acpi_device *
246 usb_acpi_get_companion_for_port(struct usb_port *port_dev)
247 {
248         struct usb_device *udev;
249         struct acpi_device *adev;
250         acpi_handle *parent_handle;
251         int port1;
252
253         /* Get the struct usb_device point of port's hub */
254         udev = to_usb_device(port_dev->dev.parent->parent);
255
256         /*
257          * The root hub ports' parent is the root hub. The non-root-hub
258          * ports' parent is the parent hub port which the hub is
259          * connected to.
260          */
261         if (!udev->parent) {
262                 adev = ACPI_COMPANION(&udev->dev);
263                 port1 = usb_hcd_find_raw_port_number(bus_to_hcd(udev->bus),
264                                                      port_dev->portnum);
265         } else {
266                 parent_handle = usb_get_hub_port_acpi_handle(udev->parent,
267                                                              udev->portnum);
268                 if (!parent_handle)
269                         return NULL;
270
271                 adev = acpi_fetch_acpi_dev(parent_handle);
272                 port1 = port_dev->portnum;
273         }
274
275         return acpi_find_child_by_adr(adev, port1);
276 }
277
278 static struct acpi_device *
279 usb_acpi_find_companion_for_port(struct usb_port *port_dev)
280 {
281         struct acpi_device *adev;
282
283         adev = usb_acpi_get_companion_for_port(port_dev);
284         if (!adev)
285                 return NULL;
286
287         usb_acpi_get_connect_type(port_dev, adev->handle);
288
289         return adev;
290 }
291
292 static struct acpi_device *
293 usb_acpi_find_companion_for_device(struct usb_device *udev)
294 {
295         struct acpi_device *adev;
296         struct usb_port *port_dev;
297         struct usb_hub *hub;
298
299         if (!udev->parent) {
300                 /*
301                  * root hub is only child (_ADR=0) under its parent, the HC.
302                  * sysdev pointer is the HC as seen from firmware.
303                  */
304                 adev = ACPI_COMPANION(udev->bus->sysdev);
305                 return acpi_find_child_device(adev, 0, false);
306         }
307
308         hub = usb_hub_to_struct_hub(udev->parent);
309         if (!hub)
310                 return NULL;
311
312
313         /* Tunneled USB3 devices depend on USB4 Host Interface, set device link to it */
314         if (udev->speed >= USB_SPEED_SUPER &&
315             udev->tunnel_mode != USB_LINK_NATIVE)
316                 usb_acpi_add_usb4_devlink(udev);
317
318         /*
319          * This is an embedded USB device connected to a port and such
320          * devices share port's ACPI companion.
321          */
322         port_dev = hub->ports[udev->portnum - 1];
323         return usb_acpi_get_companion_for_port(port_dev);
324 }
325
326 static struct acpi_device *usb_acpi_find_companion(struct device *dev)
327 {
328         /*
329          * The USB hierarchy like following:
330          *
331          * Device (EHC1)
332          *      Device (HUBN)
333          *              Device (PR01)
334          *                      Device (PR11)
335          *                      Device (PR12)
336          *                              Device (FN12)
337          *                              Device (FN13)
338          *                      Device (PR13)
339          *                      ...
340          * where HUBN is root hub, and PRNN are USB ports and devices
341          * connected to them, and FNNN are individualk functions for
342          * connected composite USB devices. PRNN and FNNN may contain
343          * _CRS and other methods describing sideband resources for
344          * the connected device.
345          *
346          * On the kernel side both root hub and embedded USB devices are
347          * represented as instances of usb_device structure, and ports
348          * are represented as usb_port structures, so the whole process
349          * is split into 2 parts: finding companions for devices and
350          * finding companions for ports.
351          *
352          * Note that we do not handle individual functions of composite
353          * devices yet, for that we would need to assign companions to
354          * devices corresponding to USB interfaces.
355          */
356         if (is_usb_device(dev))
357                 return usb_acpi_find_companion_for_device(to_usb_device(dev));
358         else if (is_usb_port(dev))
359                 return usb_acpi_find_companion_for_port(to_usb_port(dev));
360
361         return NULL;
362 }
363
364 static bool usb_acpi_bus_match(struct device *dev)
365 {
366         return is_usb_device(dev) || is_usb_port(dev);
367 }
368
369 static struct acpi_bus_type usb_acpi_bus = {
370         .name = "USB",
371         .match = usb_acpi_bus_match,
372         .find_companion = usb_acpi_find_companion,
373 };
374
375 int usb_acpi_register(void)
376 {
377         return register_acpi_bus_type(&usb_acpi_bus);
378 }
379
380 void usb_acpi_unregister(void)
381 {
382         unregister_acpi_bus_type(&usb_acpi_bus);
383 }
This page took 0.047531 seconds and 4 git commands to generate.