drivers/thunderbolt/usb4_port.c

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