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