Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * USB-ACPI glue code
4 *
5 * Copyright 2012 Red Hat <mjg@redhat.com>
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 */
26bool 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}
38EXPORT_SYMBOL_GPL(usb_acpi_power_manageable);
39
40/**
41 * usb_acpi_set_power_state - control usb port's power via acpi power
42 * resource
43 * @hdev: USB device belonging to the usb hub
44 * @index: port index based zero
45 * @enable: power state expected to be set
46 *
47 * Notice to use usb_acpi_power_manageable() to check whether the usb port
48 * has acpi power resource before invoking this function.
49 *
50 * Returns 0 on success, else negative errno.
51 */
52int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
53{
54 struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
55 struct usb_port *port_dev;
56 acpi_handle port_handle;
57 unsigned char state;
58 int port1 = index + 1;
59 int error = -EINVAL;
60
61 if (!hub)
62 return -ENODEV;
63 port_dev = hub->ports[port1 - 1];
64
65 port_handle = (acpi_handle) usb_get_hub_port_acpi_handle(hdev, port1);
66 if (!port_handle)
67 return error;
68
69 if (enable)
70 state = ACPI_STATE_D0;
71 else
72 state = ACPI_STATE_D3_COLD;
73
74 error = acpi_bus_set_power(port_handle, state);
75 if (!error)
76 dev_dbg(&port_dev->dev, "acpi: power was set to %d\n", enable);
77 else
78 dev_dbg(&port_dev->dev, "acpi: power failed to be set\n");
79
80 return error;
81}
82EXPORT_SYMBOL_GPL(usb_acpi_set_power_state);
83
84static enum usb_port_connect_type usb_acpi_get_connect_type(acpi_handle handle,
85 struct acpi_pld_info *pld)
86{
87 enum usb_port_connect_type connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
88 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
89 union acpi_object *upc = NULL;
90 acpi_status status;
91
92 /*
93 * According to 9.14 in ACPI Spec 6.2. _PLD indicates whether usb port
94 * is user visible and _UPC indicates whether it is connectable. If
95 * the port was visible and connectable, it could be freely connected
96 * and disconnected with USB devices. If no visible and connectable,
97 * a usb device is directly hard-wired to the port. If no visible and
98 * no connectable, the port would be not used.
99 */
100 status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
101 if (ACPI_FAILURE(status))
102 goto out;
103
104 upc = buffer.pointer;
105 if (!upc || (upc->type != ACPI_TYPE_PACKAGE) || upc->package.count != 4)
106 goto out;
107
108 if (upc->package.elements[0].integer.value)
109 if (pld->user_visible)
110 connect_type = USB_PORT_CONNECT_TYPE_HOT_PLUG;
111 else
112 connect_type = USB_PORT_CONNECT_TYPE_HARD_WIRED;
113 else if (!pld->user_visible)
114 connect_type = USB_PORT_NOT_USED;
115out:
116 kfree(upc);
117 return connect_type;
118}
119
120
121/*
122 * Private to usb-acpi, all the core needs to know is that
123 * port_dev->location is non-zero when it has been set by the firmware.
124 */
125#define USB_ACPI_LOCATION_VALID (1 << 31)
126
127static struct acpi_device *usb_acpi_find_port(struct acpi_device *parent,
128 int raw)
129{
130 struct acpi_device *adev;
131
132 if (!parent)
133 return NULL;
134
135 list_for_each_entry(adev, &parent->children, node) {
136 if (acpi_device_adr(adev) == raw)
137 return adev;
138 }
139
140 return acpi_find_child_device(parent, raw, false);
141}
142
143static struct acpi_device *
144usb_acpi_get_companion_for_port(struct usb_port *port_dev)
145{
146 struct usb_device *udev;
147 struct acpi_device *adev;
148 acpi_handle *parent_handle;
149 int port1;
150
151 /* Get the struct usb_device point of port's hub */
152 udev = to_usb_device(port_dev->dev.parent->parent);
153
154 /*
155 * The root hub ports' parent is the root hub. The non-root-hub
156 * ports' parent is the parent hub port which the hub is
157 * connected to.
158 */
159 if (!udev->parent) {
160 adev = ACPI_COMPANION(&udev->dev);
161 port1 = usb_hcd_find_raw_port_number(bus_to_hcd(udev->bus),
162 port_dev->portnum);
163 } else {
164 parent_handle = usb_get_hub_port_acpi_handle(udev->parent,
165 udev->portnum);
166 if (!parent_handle)
167 return NULL;
168
169 acpi_bus_get_device(parent_handle, &adev);
170 port1 = port_dev->portnum;
171 }
172
173 return usb_acpi_find_port(adev, port1);
174}
175
176static struct acpi_device *
177usb_acpi_find_companion_for_port(struct usb_port *port_dev)
178{
179 struct acpi_device *adev;
180 struct acpi_pld_info *pld;
181 acpi_handle *handle;
182 acpi_status status;
183
184 adev = usb_acpi_get_companion_for_port(port_dev);
185 if (!adev)
186 return NULL;
187
188 handle = adev->handle;
189 status = acpi_get_physical_device_location(handle, &pld);
190 if (ACPI_SUCCESS(status) && pld) {
191 port_dev->location = USB_ACPI_LOCATION_VALID
192 | pld->group_token << 8 | pld->group_position;
193 port_dev->connect_type = usb_acpi_get_connect_type(handle, pld);
194 ACPI_FREE(pld);
195 }
196
197 return adev;
198}
199
200static struct acpi_device *
201usb_acpi_find_companion_for_device(struct usb_device *udev)
202{
203 struct acpi_device *adev;
204 struct usb_port *port_dev;
205 struct usb_hub *hub;
206
207 if (!udev->parent) {
208 /* root hub is only child (_ADR=0) under its parent, the HC */
209 adev = ACPI_COMPANION(udev->dev.parent);
210 return acpi_find_child_device(adev, 0, false);
211 }
212
213 hub = usb_hub_to_struct_hub(udev->parent);
214 if (!hub)
215 return NULL;
216
217 /*
218 * This is an embedded USB device connected to a port and such
219 * devices share port's ACPI companion.
220 */
221 port_dev = hub->ports[udev->portnum - 1];
222 return usb_acpi_get_companion_for_port(port_dev);
223}
224
225static struct acpi_device *usb_acpi_find_companion(struct device *dev)
226{
227 /*
228 * The USB hierarchy like following:
229 *
230 * Device (EHC1)
231 * Device (HUBN)
232 * Device (PR01)
233 * Device (PR11)
234 * Device (PR12)
235 * Device (FN12)
236 * Device (FN13)
237 * Device (PR13)
238 * ...
239 * where HUBN is root hub, and PRNN are USB ports and devices
240 * connected to them, and FNNN are individualk functions for
241 * connected composite USB devices. PRNN and FNNN may contain
242 * _CRS and other methods describing sideband resources for
243 * the connected device.
244 *
245 * On the kernel side both root hub and embedded USB devices are
246 * represented as instances of usb_device structure, and ports
247 * are represented as usb_port structures, so the whole process
248 * is split into 2 parts: finding companions for devices and
249 * finding companions for ports.
250 *
251 * Note that we do not handle individual functions of composite
252 * devices yet, for that we would need to assign companions to
253 * devices corresponding to USB interfaces.
254 */
255 if (is_usb_device(dev))
256 return usb_acpi_find_companion_for_device(to_usb_device(dev));
257 else if (is_usb_port(dev))
258 return usb_acpi_find_companion_for_port(to_usb_port(dev));
259
260 return NULL;
261}
262
263static bool usb_acpi_bus_match(struct device *dev)
264{
265 return is_usb_device(dev) || is_usb_port(dev);
266}
267
268static struct acpi_bus_type usb_acpi_bus = {
269 .name = "USB",
270 .match = usb_acpi_bus_match,
271 .find_companion = usb_acpi_find_companion,
272};
273
274int usb_acpi_register(void)
275{
276 return register_acpi_bus_type(&usb_acpi_bus);
277}
278
279void usb_acpi_unregister(void)
280{
281 unregister_acpi_bus_type(&usb_acpi_bus);
282}
1/*
2 * USB-ACPI glue code
3 *
4 * Copyright 2012 Red Hat <mjg@redhat.com>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation, version 2.
9 *
10 */
11#include <linux/module.h>
12#include <linux/usb.h>
13#include <linux/device.h>
14#include <linux/errno.h>
15#include <linux/kernel.h>
16#include <linux/acpi.h>
17#include <linux/pci.h>
18#include <linux/usb/hcd.h>
19
20#include "usb.h"
21
22/**
23 * usb_acpi_power_manageable - check whether usb port has
24 * acpi power resource.
25 * @hdev: USB device belonging to the usb hub
26 * @index: port index based zero
27 *
28 * Return true if the port has acpi power resource and false if no.
29 */
30bool usb_acpi_power_manageable(struct usb_device *hdev, int index)
31{
32 acpi_handle port_handle;
33 int port1 = index + 1;
34
35 port_handle = usb_get_hub_port_acpi_handle(hdev,
36 port1);
37 if (port_handle)
38 return acpi_bus_power_manageable(port_handle);
39 else
40 return false;
41}
42EXPORT_SYMBOL_GPL(usb_acpi_power_manageable);
43
44/**
45 * usb_acpi_set_power_state - control usb port's power via acpi power
46 * resource
47 * @hdev: USB device belonging to the usb hub
48 * @index: port index based zero
49 * @enable: power state expected to be set
50 *
51 * Notice to use usb_acpi_power_manageable() to check whether the usb port
52 * has acpi power resource before invoking this function.
53 *
54 * Returns 0 on success, else negative errno.
55 */
56int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
57{
58 acpi_handle port_handle;
59 unsigned char state;
60 int port1 = index + 1;
61 int error = -EINVAL;
62
63 port_handle = (acpi_handle)usb_get_hub_port_acpi_handle(hdev,
64 port1);
65 if (!port_handle)
66 return error;
67
68 if (enable)
69 state = ACPI_STATE_D0;
70 else
71 state = ACPI_STATE_D3_COLD;
72
73 error = acpi_bus_set_power(port_handle, state);
74 if (!error)
75 dev_dbg(&hdev->dev, "The power of hub port %d was set to %d\n",
76 port1, enable);
77 else
78 dev_dbg(&hdev->dev, "The power of hub port failed to be set\n");
79
80 return error;
81}
82EXPORT_SYMBOL_GPL(usb_acpi_set_power_state);
83
84static int usb_acpi_check_port_connect_type(struct usb_device *hdev,
85 acpi_handle handle, int port1)
86{
87 acpi_status status;
88 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
89 union acpi_object *upc;
90 struct acpi_pld_info *pld;
91 int ret = 0;
92
93 /*
94 * According to ACPI Spec 9.13. PLD indicates whether usb port is
95 * user visible and _UPC indicates whether it is connectable. If
96 * the port was visible and connectable, it could be freely connected
97 * and disconnected with USB devices. If no visible and connectable,
98 * a usb device is directly hard-wired to the port. If no visible and
99 * no connectable, the port would be not used.
100 */
101 status = acpi_get_physical_device_location(handle, &pld);
102 if (ACPI_FAILURE(status))
103 return -ENODEV;
104
105 status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
106 upc = buffer.pointer;
107 if (!upc || (upc->type != ACPI_TYPE_PACKAGE)
108 || upc->package.count != 4) {
109 ret = -EINVAL;
110 goto out;
111 }
112
113 if (upc->package.elements[0].integer.value)
114 if (pld->user_visible)
115 usb_set_hub_port_connect_type(hdev, port1,
116 USB_PORT_CONNECT_TYPE_HOT_PLUG);
117 else
118 usb_set_hub_port_connect_type(hdev, port1,
119 USB_PORT_CONNECT_TYPE_HARD_WIRED);
120 else if (!pld->user_visible)
121 usb_set_hub_port_connect_type(hdev, port1, USB_PORT_NOT_USED);
122
123out:
124 ACPI_FREE(pld);
125 kfree(upc);
126 return ret;
127}
128
129static struct acpi_device *usb_acpi_find_companion(struct device *dev)
130{
131 struct usb_device *udev;
132 acpi_handle *parent_handle;
133 int port_num;
134
135 /*
136 * In the ACPI DSDT table, only usb root hub and usb ports are
137 * acpi device nodes. The hierarchy like following.
138 * Device (EHC1)
139 * Device (HUBN)
140 * Device (PR01)
141 * Device (PR11)
142 * Device (PR12)
143 * Device (PR13)
144 * ...
145 * So all binding process is divided into two parts. binding
146 * root hub and usb ports.
147 */
148 if (is_usb_device(dev)) {
149 udev = to_usb_device(dev);
150 if (udev->parent) {
151 enum usb_port_connect_type type;
152
153 /*
154 * According usb port's connect type to set usb device's
155 * removability.
156 */
157 type = usb_get_hub_port_connect_type(udev->parent,
158 udev->portnum);
159 switch (type) {
160 case USB_PORT_CONNECT_TYPE_HOT_PLUG:
161 udev->removable = USB_DEVICE_REMOVABLE;
162 break;
163 case USB_PORT_CONNECT_TYPE_HARD_WIRED:
164 udev->removable = USB_DEVICE_FIXED;
165 break;
166 default:
167 udev->removable = USB_DEVICE_REMOVABLE_UNKNOWN;
168 break;
169 }
170
171 return NULL;
172 }
173
174 /* root hub's parent is the usb hcd. */
175 return acpi_find_child_device(ACPI_COMPANION(dev->parent),
176 udev->portnum, false);
177 } else if (is_usb_port(dev)) {
178 struct acpi_device *adev = NULL;
179
180 sscanf(dev_name(dev), "port%d", &port_num);
181 /* Get the struct usb_device point of port's hub */
182 udev = to_usb_device(dev->parent->parent);
183
184 /*
185 * The root hub ports' parent is the root hub. The non-root-hub
186 * ports' parent is the parent hub port which the hub is
187 * connected to.
188 */
189 if (!udev->parent) {
190 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
191 int raw_port_num;
192
193 raw_port_num = usb_hcd_find_raw_port_number(hcd,
194 port_num);
195 adev = acpi_find_child_device(ACPI_COMPANION(&udev->dev),
196 raw_port_num, false);
197 if (!adev)
198 return NULL;
199 } else {
200 parent_handle =
201 usb_get_hub_port_acpi_handle(udev->parent,
202 udev->portnum);
203 if (!parent_handle)
204 return NULL;
205
206 acpi_bus_get_device(parent_handle, &adev);
207 adev = acpi_find_child_device(adev, port_num, false);
208 if (!adev)
209 return NULL;
210 }
211 usb_acpi_check_port_connect_type(udev, adev->handle, port_num);
212 return adev;
213 }
214
215 return NULL;
216}
217
218static bool usb_acpi_bus_match(struct device *dev)
219{
220 return is_usb_device(dev) || is_usb_port(dev);
221}
222
223static struct acpi_bus_type usb_acpi_bus = {
224 .name = "USB",
225 .match = usb_acpi_bus_match,
226 .find_companion = usb_acpi_find_companion,
227};
228
229int usb_acpi_register(void)
230{
231 return register_acpi_bus_type(&usb_acpi_bus);
232}
233
234void usb_acpi_unregister(void)
235{
236 unregister_acpi_bus_type(&usb_acpi_bus);
237}