1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * USB4 port device 4 * 5 * Copyright (C) 2021, Intel Corporation 6 * Author: Mika Westerberg <mika.westerberg@linux.intel.com> 7 */ 8 9 #include <linux/pm_runtime.h> 10 #include <linux/component.h> 11 #include <linux/property.h> 12 13 #include "tb.h" 14 15 static int connector_bind(struct device *dev, struct device *connector, void *data) 16 { 17 int ret; 18 19 ret = sysfs_create_link(&dev->kobj, &connector->kobj, "connector"); 20 if (ret) 21 return ret; 22 23 ret = sysfs_create_link(&connector->kobj, &dev->kobj, dev_name(dev)); 24 if (ret) 25 sysfs_remove_link(&dev->kobj, "connector"); 26 27 return ret; 28 } 29 30 static void connector_unbind(struct device *dev, struct device *connector, void *data) 31 { 32 sysfs_remove_link(&connector->kobj, dev_name(dev)); 33 sysfs_remove_link(&dev->kobj, "connector"); 34 } 35 36 static const struct component_ops connector_ops = { 37 .bind = connector_bind, 38 .unbind = connector_unbind, 39 }; 40 41 static ssize_t link_show(struct device *dev, struct device_attribute *attr, 42 char *buf) 43 { 44 struct usb4_port *usb4 = tb_to_usb4_port_device(dev); 45 struct tb_port *port = usb4->port; 46 struct tb *tb = port->sw->tb; 47 const char *link; 48 49 if (mutex_lock_interruptible(&tb->lock)) 50 return -ERESTARTSYS; 51 52 if (tb_is_upstream_port(port)) 53 link = port->sw->link_usb4 ? "usb4" : "tbt"; 54 else if (tb_port_has_remote(port)) 55 link = port->remote->sw->link_usb4 ? "usb4" : "tbt"; 56 else if (port->xdomain) 57 link = port->xdomain->link_usb4 ? "usb4" : "tbt"; 58 else 59 link = "none"; 60 61 mutex_unlock(&tb->lock); 62 63 return sysfs_emit(buf, "%s\n", link); 64 } 65 static DEVICE_ATTR_RO(link); 66 67 static struct attribute *common_attrs[] = { 68 &dev_attr_link.attr, 69 NULL 70 }; 71 72 static const struct attribute_group common_group = { 73 .attrs = common_attrs, 74 }; 75 76 static int usb4_port_offline(struct usb4_port *usb4) 77 { 78 struct tb_port *port = usb4->port; 79 int ret; 80 81 ret = tb_acpi_power_on_retimers(port); 82 if (ret) 83 return ret; 84 85 ret = usb4_port_router_offline(port); 86 if (ret) { 87 tb_acpi_power_off_retimers(port); 88 return ret; 89 } 90 91 ret = tb_retimer_scan(port, false); 92 if (ret) { 93 usb4_port_router_online(port); 94 tb_acpi_power_off_retimers(port); 95 } 96 97 return ret; 98 } 99 100 static void usb4_port_online(struct usb4_port *usb4) 101 { 102 struct tb_port *port = usb4->port; 103 104 usb4_port_router_online(port); 105 tb_acpi_power_off_retimers(port); 106 } 107 108 static ssize_t offline_show(struct device *dev, 109 struct device_attribute *attr, char *buf) 110 { 111 struct usb4_port *usb4 = tb_to_usb4_port_device(dev); 112 113 return sysfs_emit(buf, "%d\n", usb4->offline); 114 } 115 116 static ssize_t offline_store(struct device *dev, 117 struct device_attribute *attr, const char *buf, size_t count) 118 { 119 struct usb4_port *usb4 = tb_to_usb4_port_device(dev); 120 struct tb_port *port = usb4->port; 121 struct tb *tb = port->sw->tb; 122 bool val; 123 int ret; 124 125 ret = kstrtobool(buf, &val); 126 if (ret) 127 return ret; 128 129 pm_runtime_get_sync(&usb4->dev); 130 131 if (mutex_lock_interruptible(&tb->lock)) { 132 ret = -ERESTARTSYS; 133 goto out_rpm; 134 } 135 136 if (val == usb4->offline) 137 goto out_unlock; 138 139 /* Offline mode works only for ports that are not connected */ 140 if (tb_port_has_remote(port)) { 141 ret = -EBUSY; 142 goto out_unlock; 143 } 144 145 if (val) { 146 ret = usb4_port_offline(usb4); 147 if (ret) 148 goto out_unlock; 149 } else { 150 usb4_port_online(usb4); 151 tb_retimer_remove_all(port); 152 } 153 154 usb4->offline = val; 155 tb_port_dbg(port, "%s offline mode\n", val ? "enter" : "exit"); 156 157 out_unlock: 158 mutex_unlock(&tb->lock); 159 out_rpm: 160 pm_runtime_mark_last_busy(&usb4->dev); 161 pm_runtime_put_autosuspend(&usb4->dev); 162 163 return ret ? ret : count; 164 } 165 static DEVICE_ATTR_RW(offline); 166 167 static ssize_t rescan_store(struct device *dev, 168 struct device_attribute *attr, const char *buf, size_t count) 169 { 170 struct usb4_port *usb4 = tb_to_usb4_port_device(dev); 171 struct tb_port *port = usb4->port; 172 struct tb *tb = port->sw->tb; 173 bool val; 174 int ret; 175 176 ret = kstrtobool(buf, &val); 177 if (ret) 178 return ret; 179 180 if (!val) 181 return count; 182 183 pm_runtime_get_sync(&usb4->dev); 184 185 if (mutex_lock_interruptible(&tb->lock)) { 186 ret = -ERESTARTSYS; 187 goto out_rpm; 188 } 189 190 /* Must be in offline mode already */ 191 if (!usb4->offline) { 192 ret = -EINVAL; 193 goto out_unlock; 194 } 195 196 tb_retimer_remove_all(port); 197 ret = tb_retimer_scan(port, true); 198 199 out_unlock: 200 mutex_unlock(&tb->lock); 201 out_rpm: 202 pm_runtime_mark_last_busy(&usb4->dev); 203 pm_runtime_put_autosuspend(&usb4->dev); 204 205 return ret ? ret : count; 206 } 207 static DEVICE_ATTR_WO(rescan); 208 209 static struct attribute *service_attrs[] = { 210 &dev_attr_offline.attr, 211 &dev_attr_rescan.attr, 212 NULL 213 }; 214 215 static umode_t service_attr_is_visible(struct kobject *kobj, 216 struct attribute *attr, int n) 217 { 218 struct device *dev = kobj_to_dev(kobj); 219 struct usb4_port *usb4 = tb_to_usb4_port_device(dev); 220 221 /* 222 * Always need some platform help to cycle the modes so that 223 * retimers can be accessed through the sideband. 224 */ 225 return usb4->can_offline ? attr->mode : 0; 226 } 227 228 static const struct attribute_group service_group = { 229 .attrs = service_attrs, 230 .is_visible = service_attr_is_visible, 231 }; 232 233 static const struct attribute_group *usb4_port_device_groups[] = { 234 &common_group, 235 &service_group, 236 NULL 237 }; 238 239 static void usb4_port_device_release(struct device *dev) 240 { 241 struct usb4_port *usb4 = container_of(dev, struct usb4_port, dev); 242 243 kfree(usb4); 244 } 245 246 const struct device_type usb4_port_device_type = { 247 .name = "usb4_port", 248 .groups = usb4_port_device_groups, 249 .release = usb4_port_device_release, 250 }; 251 252 /** 253 * usb4_port_device_add() - Add USB4 port device 254 * @port: Lane 0 adapter port to add the USB4 port 255 * 256 * Creates and registers a USB4 port device for @port. Returns the new 257 * USB4 port device pointer or ERR_PTR() in case of error. 258 */ 259 struct usb4_port *usb4_port_device_add(struct tb_port *port) 260 { 261 struct usb4_port *usb4; 262 int ret; 263 264 usb4 = kzalloc(sizeof(*usb4), GFP_KERNEL); 265 if (!usb4) 266 return ERR_PTR(-ENOMEM); 267 268 usb4->port = port; 269 usb4->dev.type = &usb4_port_device_type; 270 usb4->dev.parent = &port->sw->dev; 271 dev_set_name(&usb4->dev, "usb4_port%d", port->port); 272 273 ret = device_register(&usb4->dev); 274 if (ret) { 275 put_device(&usb4->dev); 276 return ERR_PTR(ret); 277 } 278 279 if (dev_fwnode(&usb4->dev)) { 280 ret = component_add(&usb4->dev, &connector_ops); 281 if (ret) { 282 dev_err(&usb4->dev, "failed to add component\n"); 283 device_unregister(&usb4->dev); 284 } 285 } 286 287 if (!tb_is_upstream_port(port)) 288 device_set_wakeup_capable(&usb4->dev, true); 289 290 pm_runtime_no_callbacks(&usb4->dev); 291 pm_runtime_set_active(&usb4->dev); 292 pm_runtime_enable(&usb4->dev); 293 pm_runtime_set_autosuspend_delay(&usb4->dev, TB_AUTOSUSPEND_DELAY); 294 pm_runtime_mark_last_busy(&usb4->dev); 295 pm_runtime_use_autosuspend(&usb4->dev); 296 297 return usb4; 298 } 299 300 /** 301 * usb4_port_device_remove() - Removes USB4 port device 302 * @usb4: USB4 port device 303 * 304 * Unregisters the USB4 port device from the system. The device will be 305 * released when the last reference is dropped. 306 */ 307 void usb4_port_device_remove(struct usb4_port *usb4) 308 { 309 if (dev_fwnode(&usb4->dev)) 310 component_del(&usb4->dev, &connector_ops); 311 device_unregister(&usb4->dev); 312 } 313 314 /** 315 * usb4_port_device_resume() - Resumes USB4 port device 316 * @usb4: USB4 port device 317 * 318 * Used to resume USB4 port device after sleep state. 319 */ 320 int usb4_port_device_resume(struct usb4_port *usb4) 321 { 322 return usb4->offline ? usb4_port_offline(usb4) : 0; 323 } 324