1 /* 2 * usb port device code 3 * 4 * Copyright (C) 2012 Intel Corp 5 * 6 * Author: Lan Tianyu <tianyu.lan@intel.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 * for more details. 16 * 17 */ 18 19 #include <linux/slab.h> 20 #include <linux/pm_qos.h> 21 22 #include "hub.h" 23 24 static const struct attribute_group *port_dev_group[]; 25 26 static ssize_t show_port_connect_type(struct device *dev, 27 struct device_attribute *attr, char *buf) 28 { 29 struct usb_port *port_dev = to_usb_port(dev); 30 char *result; 31 32 switch (port_dev->connect_type) { 33 case USB_PORT_CONNECT_TYPE_HOT_PLUG: 34 result = "hotplug"; 35 break; 36 case USB_PORT_CONNECT_TYPE_HARD_WIRED: 37 result = "hardwired"; 38 break; 39 case USB_PORT_NOT_USED: 40 result = "not used"; 41 break; 42 default: 43 result = "unknown"; 44 break; 45 } 46 47 return sprintf(buf, "%s\n", result); 48 } 49 static DEVICE_ATTR(connect_type, S_IRUGO, show_port_connect_type, 50 NULL); 51 52 static struct attribute *port_dev_attrs[] = { 53 &dev_attr_connect_type.attr, 54 NULL, 55 }; 56 57 static struct attribute_group port_dev_attr_grp = { 58 .attrs = port_dev_attrs, 59 }; 60 61 static const struct attribute_group *port_dev_group[] = { 62 &port_dev_attr_grp, 63 NULL, 64 }; 65 66 static void usb_port_device_release(struct device *dev) 67 { 68 struct usb_port *port_dev = to_usb_port(dev); 69 70 kfree(port_dev); 71 } 72 73 #ifdef CONFIG_PM_RUNTIME 74 static int usb_port_runtime_resume(struct device *dev) 75 { 76 struct usb_port *port_dev = to_usb_port(dev); 77 struct usb_device *hdev = to_usb_device(dev->parent->parent); 78 struct usb_interface *intf = to_usb_interface(dev->parent); 79 struct usb_hub *hub = usb_hub_to_struct_hub(hdev); 80 int port1 = port_dev->portnum; 81 int retval; 82 83 if (!hub) 84 return -EINVAL; 85 86 usb_autopm_get_interface(intf); 87 set_bit(port1, hub->busy_bits); 88 89 retval = usb_hub_set_port_power(hdev, port1, true); 90 if (port_dev->child && !retval) { 91 /* 92 * Wait for usb hub port to be reconnected in order to make 93 * the resume procedure successful. 94 */ 95 retval = hub_port_debounce_be_connected(hub, port1); 96 if (retval < 0) { 97 dev_dbg(&port_dev->dev, "can't get reconnection after setting port power on, status %d\n", 98 retval); 99 goto out; 100 } 101 usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE); 102 103 /* Set return value to 0 if debounce successful */ 104 retval = 0; 105 } 106 107 out: 108 clear_bit(port1, hub->busy_bits); 109 usb_autopm_put_interface(intf); 110 return retval; 111 } 112 113 static int usb_port_runtime_suspend(struct device *dev) 114 { 115 struct usb_port *port_dev = to_usb_port(dev); 116 struct usb_device *hdev = to_usb_device(dev->parent->parent); 117 struct usb_interface *intf = to_usb_interface(dev->parent); 118 struct usb_hub *hub = usb_hub_to_struct_hub(hdev); 119 int port1 = port_dev->portnum; 120 int retval; 121 122 if (!hub) 123 return -EINVAL; 124 125 if (dev_pm_qos_flags(&port_dev->dev, PM_QOS_FLAG_NO_POWER_OFF) 126 == PM_QOS_FLAGS_ALL) 127 return -EAGAIN; 128 129 usb_autopm_get_interface(intf); 130 set_bit(port1, hub->busy_bits); 131 retval = usb_hub_set_port_power(hdev, port1, false); 132 usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION); 133 usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE); 134 clear_bit(port1, hub->busy_bits); 135 usb_autopm_put_interface(intf); 136 return retval; 137 } 138 #endif 139 140 static const struct dev_pm_ops usb_port_pm_ops = { 141 #ifdef CONFIG_PM_RUNTIME 142 .runtime_suspend = usb_port_runtime_suspend, 143 .runtime_resume = usb_port_runtime_resume, 144 .runtime_idle = pm_generic_runtime_idle, 145 #endif 146 }; 147 148 struct device_type usb_port_device_type = { 149 .name = "usb_port", 150 .release = usb_port_device_release, 151 .pm = &usb_port_pm_ops, 152 }; 153 154 int usb_hub_create_port_device(struct usb_hub *hub, int port1) 155 { 156 struct usb_port *port_dev = NULL; 157 int retval; 158 159 port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL); 160 if (!port_dev) { 161 retval = -ENOMEM; 162 goto exit; 163 } 164 165 hub->ports[port1 - 1] = port_dev; 166 port_dev->portnum = port1; 167 port_dev->power_is_on = true; 168 port_dev->dev.parent = hub->intfdev; 169 port_dev->dev.groups = port_dev_group; 170 port_dev->dev.type = &usb_port_device_type; 171 dev_set_name(&port_dev->dev, "port%d", port1); 172 173 retval = device_register(&port_dev->dev); 174 if (retval) 175 goto error_register; 176 177 pm_runtime_set_active(&port_dev->dev); 178 179 /* It would be dangerous if user space couldn't 180 * prevent usb device from being powered off. So don't 181 * enable port runtime pm if failed to expose port's pm qos. 182 */ 183 if (!dev_pm_qos_expose_flags(&port_dev->dev, 184 PM_QOS_FLAG_NO_POWER_OFF)) 185 pm_runtime_enable(&port_dev->dev); 186 187 device_enable_async_suspend(&port_dev->dev); 188 return 0; 189 190 error_register: 191 put_device(&port_dev->dev); 192 exit: 193 return retval; 194 } 195 196 void usb_hub_remove_port_device(struct usb_hub *hub, 197 int port1) 198 { 199 device_unregister(&hub->ports[port1 - 1]->dev); 200 } 201 202