]>
Commit | Line | Data |
---|---|---|
5fd54ace | 1 | // SPDX-License-Identifier: GPL-2.0 |
6e30d7cb LT |
2 | /* |
3 | * usb port device code | |
4 | * | |
5 | * Copyright (C) 2012 Intel Corp | |
6 | * | |
7 | * Author: Lan Tianyu <tianyu.lan@intel.com> | |
6e30d7cb LT |
8 | */ |
9 | ||
372488c6 | 10 | #include <linux/kstrtox.h> |
9f7344fb | 11 | #include <linux/slab.h> |
971fcd49 | 12 | #include <linux/pm_qos.h> |
8c67d06f | 13 | #include <linux/component.h> |
9f7344fb | 14 | |
6e30d7cb LT |
15 | #include "hub.h" |
16 | ||
6c79fe4a DW |
17 | static int usb_port_block_power_off; |
18 | ||
cef7468c LT |
19 | static const struct attribute_group *port_dev_group[]; |
20 | ||
430d57f5 RC |
21 | static ssize_t early_stop_show(struct device *dev, |
22 | struct device_attribute *attr, char *buf) | |
23 | { | |
24 | struct usb_port *port_dev = to_usb_port(dev); | |
25 | ||
26 | return sysfs_emit(buf, "%s\n", port_dev->early_stop ? "yes" : "no"); | |
27 | } | |
28 | ||
29 | static ssize_t early_stop_store(struct device *dev, struct device_attribute *attr, | |
30 | const char *buf, size_t count) | |
31 | { | |
32 | struct usb_port *port_dev = to_usb_port(dev); | |
33 | bool value; | |
34 | ||
35 | if (kstrtobool(buf, &value)) | |
36 | return -EINVAL; | |
37 | ||
38 | if (value) | |
39 | port_dev->early_stop = 1; | |
40 | else | |
41 | port_dev->early_stop = 0; | |
42 | ||
43 | return count; | |
44 | } | |
45 | static DEVICE_ATTR_RW(early_stop); | |
46 | ||
f061f43d MG |
47 | static ssize_t disable_show(struct device *dev, |
48 | struct device_attribute *attr, char *buf) | |
49 | { | |
50 | struct usb_port *port_dev = to_usb_port(dev); | |
51 | struct usb_device *hdev = to_usb_device(dev->parent->parent); | |
52 | struct usb_hub *hub = usb_hub_to_struct_hub(hdev); | |
53 | struct usb_interface *intf = to_usb_interface(hub->intfdev); | |
54 | int port1 = port_dev->portnum; | |
55 | u16 portstatus, unused; | |
56 | bool disabled; | |
57 | int rc; | |
58 | ||
59 | rc = usb_autopm_get_interface(intf); | |
60 | if (rc < 0) | |
61 | return rc; | |
62 | ||
63 | usb_lock_device(hdev); | |
64 | if (hub->disconnected) { | |
65 | rc = -ENODEV; | |
66 | goto out_hdev_lock; | |
67 | } | |
68 | ||
69 | usb_hub_port_status(hub, port1, &portstatus, &unused); | |
70 | disabled = !usb_port_is_power_on(hub, portstatus); | |
71 | ||
72 | out_hdev_lock: | |
73 | usb_unlock_device(hdev); | |
74 | usb_autopm_put_interface(intf); | |
75 | ||
76 | if (rc) | |
77 | return rc; | |
78 | ||
79 | return sysfs_emit(buf, "%s\n", disabled ? "1" : "0"); | |
80 | } | |
81 | ||
82 | static ssize_t disable_store(struct device *dev, struct device_attribute *attr, | |
83 | const char *buf, size_t count) | |
84 | { | |
85 | struct usb_port *port_dev = to_usb_port(dev); | |
86 | struct usb_device *hdev = to_usb_device(dev->parent->parent); | |
87 | struct usb_hub *hub = usb_hub_to_struct_hub(hdev); | |
88 | struct usb_interface *intf = to_usb_interface(hub->intfdev); | |
89 | int port1 = port_dev->portnum; | |
90 | bool disabled; | |
91 | int rc; | |
92 | ||
372488c6 | 93 | rc = kstrtobool(buf, &disabled); |
f061f43d MG |
94 | if (rc) |
95 | return rc; | |
96 | ||
97 | rc = usb_autopm_get_interface(intf); | |
98 | if (rc < 0) | |
99 | return rc; | |
100 | ||
101 | usb_lock_device(hdev); | |
102 | if (hub->disconnected) { | |
103 | rc = -ENODEV; | |
104 | goto out_hdev_lock; | |
105 | } | |
106 | ||
107 | if (disabled && port_dev->child) | |
108 | usb_disconnect(&port_dev->child); | |
109 | ||
110 | rc = usb_hub_set_port_power(hdev, hub, port1, !disabled); | |
111 | ||
112 | if (disabled) { | |
113 | usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION); | |
114 | if (!port_dev->is_superspeed) | |
115 | usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE); | |
116 | } | |
117 | ||
118 | if (!rc) | |
119 | rc = count; | |
120 | ||
121 | out_hdev_lock: | |
122 | usb_unlock_device(hdev); | |
123 | usb_autopm_put_interface(intf); | |
124 | ||
125 | return rc; | |
126 | } | |
127 | static DEVICE_ATTR_RW(disable); | |
128 | ||
355c74e5 BM |
129 | static ssize_t location_show(struct device *dev, |
130 | struct device_attribute *attr, char *buf) | |
131 | { | |
132 | struct usb_port *port_dev = to_usb_port(dev); | |
133 | ||
134 | return sprintf(buf, "0x%08x\n", port_dev->location); | |
135 | } | |
136 | static DEVICE_ATTR_RO(location); | |
137 | ||
d03f254f GKH |
138 | static ssize_t connect_type_show(struct device *dev, |
139 | struct device_attribute *attr, char *buf) | |
cef7468c LT |
140 | { |
141 | struct usb_port *port_dev = to_usb_port(dev); | |
142 | char *result; | |
143 | ||
144 | switch (port_dev->connect_type) { | |
145 | case USB_PORT_CONNECT_TYPE_HOT_PLUG: | |
146 | result = "hotplug"; | |
147 | break; | |
148 | case USB_PORT_CONNECT_TYPE_HARD_WIRED: | |
149 | result = "hardwired"; | |
150 | break; | |
151 | case USB_PORT_NOT_USED: | |
152 | result = "not used"; | |
153 | break; | |
154 | default: | |
155 | result = "unknown"; | |
156 | break; | |
157 | } | |
158 | ||
159 | return sprintf(buf, "%s\n", result); | |
160 | } | |
d03f254f | 161 | static DEVICE_ATTR_RO(connect_type); |
cef7468c | 162 | |
1cbd53c8 RL |
163 | static ssize_t over_current_count_show(struct device *dev, |
164 | struct device_attribute *attr, char *buf) | |
165 | { | |
166 | struct usb_port *port_dev = to_usb_port(dev); | |
167 | ||
168 | return sprintf(buf, "%u\n", port_dev->over_current_count); | |
169 | } | |
170 | static DEVICE_ATTR_RO(over_current_count); | |
171 | ||
25244227 NB |
172 | static ssize_t quirks_show(struct device *dev, |
173 | struct device_attribute *attr, char *buf) | |
174 | { | |
175 | struct usb_port *port_dev = to_usb_port(dev); | |
176 | ||
177 | return sprintf(buf, "%08x\n", port_dev->quirks); | |
178 | } | |
179 | ||
180 | static ssize_t quirks_store(struct device *dev, struct device_attribute *attr, | |
181 | const char *buf, size_t count) | |
182 | { | |
183 | struct usb_port *port_dev = to_usb_port(dev); | |
184 | u32 value; | |
185 | ||
186 | if (kstrtou32(buf, 16, &value)) | |
187 | return -EINVAL; | |
188 | ||
189 | port_dev->quirks = value; | |
190 | return count; | |
191 | } | |
192 | static DEVICE_ATTR_RW(quirks); | |
193 | ||
513072d9 LB |
194 | static ssize_t usb3_lpm_permit_show(struct device *dev, |
195 | struct device_attribute *attr, char *buf) | |
196 | { | |
197 | struct usb_port *port_dev = to_usb_port(dev); | |
198 | const char *p; | |
199 | ||
200 | if (port_dev->usb3_lpm_u1_permit) { | |
201 | if (port_dev->usb3_lpm_u2_permit) | |
202 | p = "u1_u2"; | |
203 | else | |
204 | p = "u1"; | |
205 | } else { | |
206 | if (port_dev->usb3_lpm_u2_permit) | |
207 | p = "u2"; | |
208 | else | |
209 | p = "0"; | |
210 | } | |
211 | ||
212 | return sprintf(buf, "%s\n", p); | |
213 | } | |
214 | ||
215 | static ssize_t usb3_lpm_permit_store(struct device *dev, | |
216 | struct device_attribute *attr, | |
217 | const char *buf, size_t count) | |
218 | { | |
219 | struct usb_port *port_dev = to_usb_port(dev); | |
220 | struct usb_device *udev = port_dev->child; | |
221 | struct usb_hcd *hcd; | |
222 | ||
223 | if (!strncmp(buf, "u1_u2", 5)) { | |
224 | port_dev->usb3_lpm_u1_permit = 1; | |
225 | port_dev->usb3_lpm_u2_permit = 1; | |
226 | ||
227 | } else if (!strncmp(buf, "u1", 2)) { | |
228 | port_dev->usb3_lpm_u1_permit = 1; | |
229 | port_dev->usb3_lpm_u2_permit = 0; | |
230 | ||
231 | } else if (!strncmp(buf, "u2", 2)) { | |
232 | port_dev->usb3_lpm_u1_permit = 0; | |
233 | port_dev->usb3_lpm_u2_permit = 1; | |
234 | ||
235 | } else if (!strncmp(buf, "0", 1)) { | |
236 | port_dev->usb3_lpm_u1_permit = 0; | |
237 | port_dev->usb3_lpm_u2_permit = 0; | |
238 | } else | |
239 | return -EINVAL; | |
240 | ||
241 | /* If device is connected to the port, disable or enable lpm | |
242 | * to make new u1 u2 setting take effect immediately. | |
243 | */ | |
244 | if (udev) { | |
245 | hcd = bus_to_hcd(udev->bus); | |
246 | if (!hcd) | |
247 | return -EINVAL; | |
248 | usb_lock_device(udev); | |
249 | mutex_lock(hcd->bandwidth_mutex); | |
250 | if (!usb_disable_lpm(udev)) | |
251 | usb_enable_lpm(udev); | |
252 | mutex_unlock(hcd->bandwidth_mutex); | |
253 | usb_unlock_device(udev); | |
254 | } | |
255 | ||
256 | return count; | |
257 | } | |
258 | static DEVICE_ATTR_RW(usb3_lpm_permit); | |
259 | ||
cef7468c LT |
260 | static struct attribute *port_dev_attrs[] = { |
261 | &dev_attr_connect_type.attr, | |
355c74e5 | 262 | &dev_attr_location.attr, |
25244227 | 263 | &dev_attr_quirks.attr, |
1cbd53c8 | 264 | &dev_attr_over_current_count.attr, |
f061f43d | 265 | &dev_attr_disable.attr, |
430d57f5 | 266 | &dev_attr_early_stop.attr, |
cef7468c LT |
267 | NULL, |
268 | }; | |
269 | ||
4154a4f7 | 270 | static const struct attribute_group port_dev_attr_grp = { |
cef7468c LT |
271 | .attrs = port_dev_attrs, |
272 | }; | |
273 | ||
274 | static const struct attribute_group *port_dev_group[] = { | |
275 | &port_dev_attr_grp, | |
276 | NULL, | |
277 | }; | |
278 | ||
513072d9 LB |
279 | static struct attribute *port_dev_usb3_attrs[] = { |
280 | &dev_attr_usb3_lpm_permit.attr, | |
281 | NULL, | |
282 | }; | |
283 | ||
4154a4f7 | 284 | static const struct attribute_group port_dev_usb3_attr_grp = { |
513072d9 LB |
285 | .attrs = port_dev_usb3_attrs, |
286 | }; | |
287 | ||
288 | static const struct attribute_group *port_dev_usb3_group[] = { | |
289 | &port_dev_attr_grp, | |
290 | &port_dev_usb3_attr_grp, | |
291 | NULL, | |
292 | }; | |
293 | ||
6e30d7cb LT |
294 | static void usb_port_device_release(struct device *dev) |
295 | { | |
296 | struct usb_port *port_dev = to_usb_port(dev); | |
297 | ||
e3d10505 | 298 | kfree(port_dev->req); |
6e30d7cb LT |
299 | kfree(port_dev); |
300 | } | |
301 | ||
ceb6c9c8 | 302 | #ifdef CONFIG_PM |
971fcd49 LT |
303 | static int usb_port_runtime_resume(struct device *dev) |
304 | { | |
305 | struct usb_port *port_dev = to_usb_port(dev); | |
306 | struct usb_device *hdev = to_usb_device(dev->parent->parent); | |
307 | struct usb_interface *intf = to_usb_interface(dev->parent); | |
ad493e5e | 308 | struct usb_hub *hub = usb_hub_to_struct_hub(hdev); |
7027df36 | 309 | struct usb_device *udev = port_dev->child; |
7ad3c470 | 310 | struct usb_port *peer = port_dev->peer; |
ad493e5e | 311 | int port1 = port_dev->portnum; |
971fcd49 LT |
312 | int retval; |
313 | ||
ad493e5e LT |
314 | if (!hub) |
315 | return -EINVAL; | |
600856c2 | 316 | if (hub->in_reset) { |
d5c3834e | 317 | set_bit(port1, hub->power_bits); |
600856c2 AS |
318 | return 0; |
319 | } | |
ad493e5e | 320 | |
7ad3c470 DW |
321 | /* |
322 | * Power on our usb3 peer before this usb2 port to prevent a usb3 | |
323 | * device from degrading to its usb2 connection | |
324 | */ | |
325 | if (!port_dev->is_superspeed && peer) | |
326 | pm_runtime_get_sync(&peer->dev); | |
327 | ||
1f8b39bc ER |
328 | retval = usb_autopm_get_interface(intf); |
329 | if (retval < 0) | |
330 | return retval; | |
331 | ||
41341261 | 332 | retval = usb_hub_set_port_power(hdev, hub, port1, true); |
7ad3c470 | 333 | msleep(hub_power_on_good_delay(hub)); |
7027df36 | 334 | if (udev && !retval) { |
ad493e5e | 335 | /* |
3cd12f91 DW |
336 | * Our preference is to simply wait for the port to reconnect, |
337 | * as that is the lowest latency method to restart the port. | |
338 | * However, there are cases where toggling port power results in | |
339 | * the host port and the device port getting out of sync causing | |
340 | * a link training live lock. Upon timeout, flag the port as | |
341 | * needing warm reset recovery (to be performed later by | |
342 | * usb_port_resume() as requested via usb_wakeup_notification()) | |
ad493e5e | 343 | */ |
3cd12f91 DW |
344 | if (hub_port_debounce_be_connected(hub, port1) < 0) { |
345 | dev_dbg(&port_dev->dev, "reconnect timeout\n"); | |
346 | if (hub_is_superspeed(hdev)) | |
347 | set_bit(port1, hub->warm_reset_bits); | |
348 | } | |
7027df36 DW |
349 | |
350 | /* Force the child awake to revalidate after the power loss. */ | |
351 | if (!test_and_set_bit(port1, hub->child_usage_bits)) { | |
352 | pm_runtime_get_noresume(&port_dev->dev); | |
353 | pm_request_resume(&udev->dev); | |
354 | } | |
ad493e5e LT |
355 | } |
356 | ||
971fcd49 | 357 | usb_autopm_put_interface(intf); |
7ad3c470 | 358 | |
971fcd49 LT |
359 | return retval; |
360 | } | |
361 | ||
362 | static int usb_port_runtime_suspend(struct device *dev) | |
363 | { | |
364 | struct usb_port *port_dev = to_usb_port(dev); | |
365 | struct usb_device *hdev = to_usb_device(dev->parent->parent); | |
366 | struct usb_interface *intf = to_usb_interface(dev->parent); | |
ad493e5e | 367 | struct usb_hub *hub = usb_hub_to_struct_hub(hdev); |
7ad3c470 | 368 | struct usb_port *peer = port_dev->peer; |
ad493e5e | 369 | int port1 = port_dev->portnum; |
971fcd49 LT |
370 | int retval; |
371 | ||
ad493e5e LT |
372 | if (!hub) |
373 | return -EINVAL; | |
600856c2 AS |
374 | if (hub->in_reset) |
375 | return -EBUSY; | |
ad493e5e | 376 | |
971fcd49 LT |
377 | if (dev_pm_qos_flags(&port_dev->dev, PM_QOS_FLAG_NO_POWER_OFF) |
378 | == PM_QOS_FLAGS_ALL) | |
379 | return -EAGAIN; | |
380 | ||
6c79fe4a DW |
381 | if (usb_port_block_power_off) |
382 | return -EBUSY; | |
383 | ||
1f8b39bc ER |
384 | retval = usb_autopm_get_interface(intf); |
385 | if (retval < 0) | |
386 | return retval; | |
387 | ||
41341261 | 388 | retval = usb_hub_set_port_power(hdev, hub, port1, false); |
ad493e5e | 389 | usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION); |
69080584 DW |
390 | if (!port_dev->is_superspeed) |
391 | usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE); | |
971fcd49 | 392 | usb_autopm_put_interface(intf); |
7ad3c470 DW |
393 | |
394 | /* | |
395 | * Our peer usb3 port may now be able to suspend, so | |
396 | * asynchronously queue a suspend request to observe that this | |
397 | * usb2 port is now off. | |
398 | */ | |
399 | if (!port_dev->is_superspeed && peer) | |
400 | pm_runtime_put(&peer->dev); | |
401 | ||
971fcd49 LT |
402 | return retval; |
403 | } | |
404 | #endif | |
405 | ||
582ee9c5 KHF |
406 | static void usb_port_shutdown(struct device *dev) |
407 | { | |
408 | struct usb_port *port_dev = to_usb_port(dev); | |
409 | ||
410 | if (port_dev->child) | |
411 | usb_disable_usb2_hardware_lpm(port_dev->child); | |
412 | } | |
413 | ||
971fcd49 | 414 | static const struct dev_pm_ops usb_port_pm_ops = { |
ceb6c9c8 | 415 | #ifdef CONFIG_PM |
971fcd49 LT |
416 | .runtime_suspend = usb_port_runtime_suspend, |
417 | .runtime_resume = usb_port_runtime_resume, | |
971fcd49 LT |
418 | #endif |
419 | }; | |
420 | ||
6e30d7cb LT |
421 | struct device_type usb_port_device_type = { |
422 | .name = "usb_port", | |
423 | .release = usb_port_device_release, | |
971fcd49 | 424 | .pm = &usb_port_pm_ops, |
6e30d7cb LT |
425 | }; |
426 | ||
d99f6b41 DW |
427 | static struct device_driver usb_port_driver = { |
428 | .name = "usb", | |
429 | .owner = THIS_MODULE, | |
582ee9c5 | 430 | .shutdown = usb_port_shutdown, |
d99f6b41 DW |
431 | }; |
432 | ||
b7e38eac | 433 | static int link_peers(struct usb_port *left, struct usb_port *right) |
d8521afe | 434 | { |
7ad3c470 | 435 | struct usb_port *ss_port, *hs_port; |
b7e38eac DW |
436 | int rc; |
437 | ||
d8521afe | 438 | if (left->peer == right && right->peer == left) |
b7e38eac | 439 | return 0; |
d8521afe DW |
440 | |
441 | if (left->peer || right->peer) { | |
442 | struct usb_port *lpeer = left->peer; | |
443 | struct usb_port *rpeer = right->peer; | |
6c79fe4a DW |
444 | char *method; |
445 | ||
446 | if (left->location && left->location == right->location) | |
447 | method = "location"; | |
448 | else | |
449 | method = "default"; | |
450 | ||
6406eeb3 | 451 | pr_debug("usb: failed to peer %s and %s by %s (%s:%s) (%s:%s)\n", |
6c79fe4a DW |
452 | dev_name(&left->dev), dev_name(&right->dev), method, |
453 | dev_name(&left->dev), | |
454 | lpeer ? dev_name(&lpeer->dev) : "none", | |
455 | dev_name(&right->dev), | |
456 | rpeer ? dev_name(&rpeer->dev) : "none"); | |
b7e38eac DW |
457 | return -EBUSY; |
458 | } | |
459 | ||
460 | rc = sysfs_create_link(&left->dev.kobj, &right->dev.kobj, "peer"); | |
461 | if (rc) | |
462 | return rc; | |
463 | rc = sysfs_create_link(&right->dev.kobj, &left->dev.kobj, "peer"); | |
464 | if (rc) { | |
465 | sysfs_remove_link(&left->dev.kobj, "peer"); | |
466 | return rc; | |
d8521afe DW |
467 | } |
468 | ||
7ad3c470 DW |
469 | /* |
470 | * We need to wake the HiSpeed port to make sure we don't race | |
471 | * setting ->peer with usb_port_runtime_suspend(). Otherwise we | |
472 | * may miss a suspend event for the SuperSpeed port. | |
473 | */ | |
474 | if (left->is_superspeed) { | |
475 | ss_port = left; | |
476 | WARN_ON(right->is_superspeed); | |
477 | hs_port = right; | |
478 | } else { | |
479 | ss_port = right; | |
480 | WARN_ON(!right->is_superspeed); | |
481 | hs_port = left; | |
482 | } | |
483 | pm_runtime_get_sync(&hs_port->dev); | |
484 | ||
d8521afe DW |
485 | left->peer = right; |
486 | right->peer = left; | |
b7e38eac | 487 | |
7ad3c470 DW |
488 | /* |
489 | * The SuperSpeed reference is dropped when the HiSpeed port in | |
490 | * this relationship suspends, i.e. when it is safe to allow a | |
491 | * SuperSpeed connection to drop since there is no risk of a | |
492 | * device degrading to its powered-off HiSpeed connection. | |
493 | * | |
494 | * Also, drop the HiSpeed ref taken above. | |
495 | */ | |
496 | pm_runtime_get_sync(&ss_port->dev); | |
497 | pm_runtime_put(&hs_port->dev); | |
498 | ||
b7e38eac DW |
499 | return 0; |
500 | } | |
501 | ||
502 | static void link_peers_report(struct usb_port *left, struct usb_port *right) | |
503 | { | |
504 | int rc; | |
505 | ||
506 | rc = link_peers(left, right); | |
507 | if (rc == 0) { | |
508 | dev_dbg(&left->dev, "peered to %s\n", dev_name(&right->dev)); | |
509 | } else { | |
6406eeb3 | 510 | dev_dbg(&left->dev, "failed to peer to %s (%d)\n", |
b7e38eac DW |
511 | dev_name(&right->dev), rc); |
512 | pr_warn_once("usb: port power management may be unreliable\n"); | |
6c79fe4a | 513 | usb_port_block_power_off = 1; |
b7e38eac | 514 | } |
d8521afe DW |
515 | } |
516 | ||
517 | static void unlink_peers(struct usb_port *left, struct usb_port *right) | |
518 | { | |
7ad3c470 DW |
519 | struct usb_port *ss_port, *hs_port; |
520 | ||
d8521afe DW |
521 | WARN(right->peer != left || left->peer != right, |
522 | "%s and %s are not peers?\n", | |
523 | dev_name(&left->dev), dev_name(&right->dev)); | |
524 | ||
7ad3c470 DW |
525 | /* |
526 | * We wake the HiSpeed port to make sure we don't race its | |
527 | * usb_port_runtime_resume() event which takes a SuperSpeed ref | |
528 | * when ->peer is !NULL. | |
529 | */ | |
530 | if (left->is_superspeed) { | |
531 | ss_port = left; | |
532 | hs_port = right; | |
533 | } else { | |
534 | ss_port = right; | |
535 | hs_port = left; | |
536 | } | |
537 | ||
538 | pm_runtime_get_sync(&hs_port->dev); | |
539 | ||
b7e38eac | 540 | sysfs_remove_link(&left->dev.kobj, "peer"); |
d8521afe | 541 | right->peer = NULL; |
b7e38eac | 542 | sysfs_remove_link(&right->dev.kobj, "peer"); |
d8521afe | 543 | left->peer = NULL; |
7ad3c470 DW |
544 | |
545 | /* Drop the SuperSpeed ref held on behalf of the active HiSpeed port */ | |
546 | pm_runtime_put(&ss_port->dev); | |
547 | ||
548 | /* Drop the ref taken above */ | |
549 | pm_runtime_put(&hs_port->dev); | |
d8521afe DW |
550 | } |
551 | ||
8b1ba80c | 552 | /* |
3bfd659b DW |
553 | * For each usb hub device in the system check to see if it is in the |
554 | * peer domain of the given port_dev, and if it is check to see if it | |
555 | * has a port that matches the given port by location | |
556 | */ | |
557 | static int match_location(struct usb_device *peer_hdev, void *p) | |
558 | { | |
559 | int port1; | |
560 | struct usb_hcd *hcd, *peer_hcd; | |
561 | struct usb_port *port_dev = p, *peer; | |
562 | struct usb_hub *peer_hub = usb_hub_to_struct_hub(peer_hdev); | |
563 | struct usb_device *hdev = to_usb_device(port_dev->dev.parent->parent); | |
564 | ||
565 | if (!peer_hub) | |
566 | return 0; | |
567 | ||
568 | hcd = bus_to_hcd(hdev->bus); | |
569 | peer_hcd = bus_to_hcd(peer_hdev->bus); | |
570 | /* peer_hcd is provisional until we verify it against the known peer */ | |
571 | if (peer_hcd != hcd->shared_hcd) | |
572 | return 0; | |
573 | ||
574 | for (port1 = 1; port1 <= peer_hdev->maxchild; port1++) { | |
575 | peer = peer_hub->ports[port1 - 1]; | |
576 | if (peer && peer->location == port_dev->location) { | |
b7e38eac | 577 | link_peers_report(port_dev, peer); |
3bfd659b DW |
578 | return 1; /* done */ |
579 | } | |
580 | } | |
581 | ||
582 | return 0; | |
583 | } | |
584 | ||
585 | /* | |
586 | * Find the peer port either via explicit platform firmware "location" | |
587 | * data, the peer hcd for root hubs, or the upstream peer relationship | |
588 | * for all other hubs. | |
8b1ba80c | 589 | */ |
d8521afe DW |
590 | static void find_and_link_peer(struct usb_hub *hub, int port1) |
591 | { | |
592 | struct usb_port *port_dev = hub->ports[port1 - 1], *peer; | |
593 | struct usb_device *hdev = hub->hdev; | |
8b1ba80c DW |
594 | struct usb_device *peer_hdev; |
595 | struct usb_hub *peer_hub; | |
d8521afe | 596 | |
3bfd659b DW |
597 | /* |
598 | * If location data is available then we can only peer this port | |
599 | * by a location match, not the default peer (lest we create a | |
600 | * situation where we need to go back and undo a default peering | |
601 | * when the port is later peered by location data) | |
602 | */ | |
603 | if (port_dev->location) { | |
604 | /* we link the peer in match_location() if found */ | |
605 | usb_for_each_dev(port_dev, match_location); | |
606 | return; | |
607 | } else if (!hdev->parent) { | |
d8521afe DW |
608 | struct usb_hcd *hcd = bus_to_hcd(hdev->bus); |
609 | struct usb_hcd *peer_hcd = hcd->shared_hcd; | |
610 | ||
611 | if (!peer_hcd) | |
612 | return; | |
613 | ||
614 | peer_hdev = peer_hcd->self.root_hub; | |
8b1ba80c DW |
615 | } else { |
616 | struct usb_port *upstream; | |
617 | struct usb_device *parent = hdev->parent; | |
618 | struct usb_hub *parent_hub = usb_hub_to_struct_hub(parent); | |
619 | ||
620 | if (!parent_hub) | |
d8521afe DW |
621 | return; |
622 | ||
8b1ba80c DW |
623 | upstream = parent_hub->ports[hdev->portnum - 1]; |
624 | if (!upstream || !upstream->peer) | |
625 | return; | |
d8521afe | 626 | |
8b1ba80c | 627 | peer_hdev = upstream->peer->child; |
d8521afe | 628 | } |
8b1ba80c DW |
629 | |
630 | peer_hub = usb_hub_to_struct_hub(peer_hdev); | |
631 | if (!peer_hub || port1 > peer_hdev->maxchild) | |
632 | return; | |
633 | ||
3bfd659b DW |
634 | /* |
635 | * we found a valid default peer, last check is to make sure it | |
636 | * does not have location data | |
637 | */ | |
8b1ba80c | 638 | peer = peer_hub->ports[port1 - 1]; |
3bfd659b | 639 | if (peer && peer->location == 0) |
b7e38eac | 640 | link_peers_report(port_dev, peer); |
d8521afe DW |
641 | } |
642 | ||
8c67d06f HK |
643 | static int connector_bind(struct device *dev, struct device *connector, void *data) |
644 | { | |
645 | int ret; | |
646 | ||
647 | ret = sysfs_create_link(&dev->kobj, &connector->kobj, "connector"); | |
648 | if (ret) | |
649 | return ret; | |
650 | ||
651 | ret = sysfs_create_link(&connector->kobj, &dev->kobj, dev_name(dev)); | |
652 | if (ret) | |
653 | sysfs_remove_link(&dev->kobj, "connector"); | |
654 | ||
655 | return ret; | |
656 | } | |
657 | ||
658 | static void connector_unbind(struct device *dev, struct device *connector, void *data) | |
659 | { | |
660 | sysfs_remove_link(&connector->kobj, dev_name(dev)); | |
661 | sysfs_remove_link(&dev->kobj, "connector"); | |
662 | } | |
663 | ||
664 | static const struct component_ops connector_ops = { | |
665 | .bind = connector_bind, | |
666 | .unbind = connector_unbind, | |
667 | }; | |
668 | ||
6e30d7cb LT |
669 | int usb_hub_create_port_device(struct usb_hub *hub, int port1) |
670 | { | |
d8521afe | 671 | struct usb_port *port_dev; |
513072d9 | 672 | struct usb_device *hdev = hub->hdev; |
6e30d7cb LT |
673 | int retval; |
674 | ||
675 | port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL); | |
e3d10505 DW |
676 | if (!port_dev) |
677 | return -ENOMEM; | |
678 | ||
679 | port_dev->req = kzalloc(sizeof(*(port_dev->req)), GFP_KERNEL); | |
680 | if (!port_dev->req) { | |
681 | kfree(port_dev); | |
682 | return -ENOMEM; | |
6e30d7cb LT |
683 | } |
684 | ||
685 | hub->ports[port1 - 1] = port_dev; | |
971fcd49 | 686 | port_dev->portnum = port1; |
d5c3834e | 687 | set_bit(port1, hub->power_bits); |
6e30d7cb | 688 | port_dev->dev.parent = hub->intfdev; |
513072d9 LB |
689 | if (hub_is_superspeed(hdev)) { |
690 | port_dev->usb3_lpm_u1_permit = 1; | |
691 | port_dev->usb3_lpm_u2_permit = 1; | |
692 | port_dev->dev.groups = port_dev_usb3_group; | |
693 | } else | |
694 | port_dev->dev.groups = port_dev_group; | |
6e30d7cb | 695 | port_dev->dev.type = &usb_port_device_type; |
d99f6b41 | 696 | port_dev->dev.driver = &usb_port_driver; |
7ad3c470 DW |
697 | if (hub_is_superspeed(hub->hdev)) |
698 | port_dev->is_superspeed = 1; | |
d99f6b41 DW |
699 | dev_set_name(&port_dev->dev, "%s-port%d", dev_name(&hub->hdev->dev), |
700 | port1); | |
5c79a1e3 | 701 | mutex_init(&port_dev->status_lock); |
6e30d7cb | 702 | retval = device_register(&port_dev->dev); |
e3d10505 DW |
703 | if (retval) { |
704 | put_device(&port_dev->dev); | |
705 | return retval; | |
706 | } | |
707 | ||
708 | /* Set default policy of port-poweroff disabled. */ | |
709 | retval = dev_pm_qos_add_request(&port_dev->dev, port_dev->req, | |
710 | DEV_PM_QOS_FLAGS, PM_QOS_FLAG_NO_POWER_OFF); | |
711 | if (retval < 0) { | |
712 | device_unregister(&port_dev->dev); | |
713 | return retval; | |
714 | } | |
6e30d7cb | 715 | |
8c67d06f | 716 | retval = component_add(&port_dev->dev, &connector_ops); |
c853685d | 717 | if (retval) { |
8c67d06f | 718 | dev_warn(&port_dev->dev, "failed to add component\n"); |
c853685d FDF |
719 | device_unregister(&port_dev->dev); |
720 | return retval; | |
721 | } | |
722 | ||
723 | find_and_link_peer(hub, port1); | |
8c67d06f | 724 | |
e3d10505 DW |
725 | /* |
726 | * Enable runtime pm and hold a refernce that hub_configure() | |
727 | * will drop once the PM_QOS_NO_POWER_OFF flag state has been set | |
728 | * and the hub has been fully registered (hdev->maxchild set). | |
729 | */ | |
971fcd49 | 730 | pm_runtime_set_active(&port_dev->dev); |
e3d10505 DW |
731 | pm_runtime_get_noresume(&port_dev->dev); |
732 | pm_runtime_enable(&port_dev->dev); | |
733 | device_enable_async_suspend(&port_dev->dev); | |
f6cced1a | 734 | |
9262c19d | 735 | /* |
e3d10505 DW |
736 | * Keep hidden the ability to enable port-poweroff if the hub |
737 | * does not support power switching. | |
f6cced1a | 738 | */ |
e3d10505 DW |
739 | if (!hub_is_port_power_switchable(hub)) |
740 | return 0; | |
f6cced1a | 741 | |
e3d10505 DW |
742 | /* Attempt to let userspace take over the policy. */ |
743 | retval = dev_pm_qos_expose_flags(&port_dev->dev, | |
744 | PM_QOS_FLAG_NO_POWER_OFF); | |
745 | if (retval < 0) { | |
746 | dev_warn(&port_dev->dev, "failed to expose pm_qos_no_poweroff\n"); | |
747 | return 0; | |
748 | } | |
6e30d7cb | 749 | |
e3d10505 DW |
750 | /* Userspace owns the policy, drop the kernel 'no_poweroff' request. */ |
751 | retval = dev_pm_qos_remove_request(port_dev->req); | |
752 | if (retval >= 0) { | |
753 | kfree(port_dev->req); | |
754 | port_dev->req = NULL; | |
755 | } | |
756 | return 0; | |
6e30d7cb LT |
757 | } |
758 | ||
d8521afe | 759 | void usb_hub_remove_port_device(struct usb_hub *hub, int port1) |
6e30d7cb | 760 | { |
d8521afe DW |
761 | struct usb_port *port_dev = hub->ports[port1 - 1]; |
762 | struct usb_port *peer; | |
6e30d7cb | 763 | |
d8521afe DW |
764 | peer = port_dev->peer; |
765 | if (peer) | |
766 | unlink_peers(port_dev, peer); | |
8c67d06f | 767 | component_del(&port_dev->dev, &connector_ops); |
d8521afe DW |
768 | device_unregister(&port_dev->dev); |
769 | } |