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