Commit | Line | Data |
---|---|---|
da0af6e7 MG |
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 <acpi/acpi_bus.h> | |
19 | ||
20 | #include "usb.h" | |
21 | ||
f7ac7787 LT |
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 | */ | |
30 | bool 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 | } | |
42 | EXPORT_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 | */ | |
56 | int 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 | } | |
82 | EXPORT_SYMBOL_GPL(usb_acpi_set_power_state); | |
83 | ||
05f91689 LT |
84 | static int usb_acpi_check_port_connect_type(struct usb_device *hdev, |
85 | acpi_handle handle, int port1) | |
54d3f8c6 MG |
86 | { |
87 | acpi_status status; | |
88 | struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; | |
89 | union acpi_object *upc; | |
d8dc91b7 | 90 | struct acpi_pld_info *pld; |
54d3f8c6 MG |
91 | int ret = 0; |
92 | ||
05f91689 LT |
93 | /* |
94 | * Accoding 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); | |
54d3f8c6 MG |
102 | if (ACPI_FAILURE(status)) |
103 | return -ENODEV; | |
104 | ||
05f91689 | 105 | status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer); |
54d3f8c6 | 106 | upc = buffer.pointer; |
54d3f8c6 MG |
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) | |
d8dc91b7 | 114 | if (pld->user_visible) |
05f91689 LT |
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); | |
d8dc91b7 | 120 | else if (!pld->user_visible) |
05f91689 | 121 | usb_set_hub_port_connect_type(hdev, port1, USB_PORT_NOT_USED); |
54d3f8c6 MG |
122 | |
123 | out: | |
d8dc91b7 | 124 | ACPI_FREE(pld); |
54d3f8c6 MG |
125 | kfree(upc); |
126 | return ret; | |
127 | } | |
128 | ||
da0af6e7 MG |
129 | static int usb_acpi_find_device(struct device *dev, acpi_handle *handle) |
130 | { | |
131 | struct usb_device *udev; | |
da0af6e7 | 132 | acpi_handle *parent_handle; |
d5575424 | 133 | int port_num; |
da0af6e7 | 134 | |
d5575424 LT |
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); | |
05f91689 LT |
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 | ||
d5575424 | 171 | return -ENODEV; |
05f91689 LT |
172 | } |
173 | ||
d5575424 LT |
174 | /* root hub's parent is the usb hcd. */ |
175 | parent_handle = DEVICE_ACPI_HANDLE(dev->parent); | |
176 | *handle = acpi_get_child(parent_handle, udev->portnum); | |
177 | if (!*handle) | |
178 | return -ENODEV; | |
179 | return 0; | |
180 | } else if (is_usb_port(dev)) { | |
181 | sscanf(dev_name(dev), "port%d", &port_num); | |
182 | /* Get the struct usb_device point of port's hub */ | |
183 | udev = to_usb_device(dev->parent->parent); | |
184 | ||
185 | /* | |
186 | * The root hub ports' parent is the root hub. The non-root-hub | |
187 | * ports' parent is the parent hub port which the hub is | |
188 | * connected to. | |
189 | */ | |
190 | if (!udev->parent) { | |
191 | *handle = acpi_get_child(DEVICE_ACPI_HANDLE(&udev->dev), | |
192 | port_num); | |
193 | if (!*handle) | |
194 | return -ENODEV; | |
195 | } else { | |
196 | parent_handle = | |
197 | usb_get_hub_port_acpi_handle(udev->parent, | |
198 | udev->portnum); | |
199 | if (!parent_handle) | |
200 | return -ENODEV; | |
201 | ||
202 | *handle = acpi_get_child(parent_handle, port_num); | |
203 | if (!*handle) | |
204 | return -ENODEV; | |
205 | } | |
05f91689 | 206 | usb_acpi_check_port_connect_type(udev, *handle, port_num); |
d5575424 | 207 | } else |
da0af6e7 MG |
208 | return -ENODEV; |
209 | ||
210 | return 0; | |
211 | } | |
212 | ||
213 | static struct acpi_bus_type usb_acpi_bus = { | |
214 | .bus = &usb_bus_type, | |
d5575424 | 215 | .find_bridge = usb_acpi_find_device, |
da0af6e7 MG |
216 | .find_device = usb_acpi_find_device, |
217 | }; | |
218 | ||
219 | int usb_acpi_register(void) | |
220 | { | |
221 | return register_acpi_bus_type(&usb_acpi_bus); | |
222 | } | |
223 | ||
224 | void usb_acpi_unregister(void) | |
225 | { | |
226 | unregister_acpi_bus_type(&usb_acpi_bus); | |
227 | } |