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