drivers/thunderbolt/retimer.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Thunderbolt/USB4 retimer support.
   4  *
   5  * Copyright (C) 2020, Intel Corporation
   6  * Authors: Kranthi Kuntala <kranthi.kuntala@intel.com>
   7  *          Mika Westerberg <mika.westerberg@linux.intel.com>
   8  */
   9
  10 #include <linux/delay.h>
  11 #include <linux/pm_runtime.h>
  12 #include <linux/sched/signal.h>
  13
  14 #include "sb_regs.h"
  15 #include "tb.h"
  16
  17 #define TB_MAX_RETIMER_INDEX    6
  18
  19 static int tb_retimer_nvm_read(void *priv, unsigned int offset, void *val,
  20                                size_t bytes)
  21 {
  22         struct tb_nvm *nvm = priv;
  23         struct tb_retimer *rt = tb_to_retimer(nvm->dev);
  24         int ret;
  25
  26         pm_runtime_get_sync(&rt->dev);
  27
  28         if (!mutex_trylock(&rt->tb->lock)) {
  29                 ret = restart_syscall();
  30                 goto out;
  31         }
  32
  33         ret = usb4_port_retimer_nvm_read(rt->port, rt->index, offset, val, bytes);
  34         mutex_unlock(&rt->tb->lock);
  35
  36 out:
  37         pm_runtime_mark_last_busy(&rt->dev);
  38         pm_runtime_put_autosuspend(&rt->dev);
  39
  40         return ret;
  41 }
  42
  43 static int tb_retimer_nvm_write(void *priv, unsigned int offset, void *val,
  44                                 size_t bytes)
  45 {
  46         struct tb_nvm *nvm = priv;
  47         struct tb_retimer *rt = tb_to_retimer(nvm->dev);
  48         int ret = 0;
  49
  50         if (!mutex_trylock(&rt->tb->lock))
  51                 return restart_syscall();
  52
  53         ret = tb_nvm_write_buf(nvm, offset, val, bytes);
  54         mutex_unlock(&rt->tb->lock);
  55
  56         return ret;
  57 }
  58
  59 static int tb_retimer_nvm_add(struct tb_retimer *rt)
  60 {
  61         struct tb_nvm *nvm;
  62         u32 val, nvm_size;
  63         int ret;
  64
  65         nvm = tb_nvm_alloc(&rt->dev);
  66         if (IS_ERR(nvm))
  67                 return PTR_ERR(nvm);
  68
  69         ret = usb4_port_retimer_nvm_read(rt->port, rt->index, NVM_VERSION, &val,
  70                                          sizeof(val));
  71         if (ret)
  72                 goto err_nvm;
  73
  74         nvm->major = val >> 16;
  75         nvm->minor = val >> 8;
  76
  77         ret = usb4_port_retimer_nvm_read(rt->port, rt->index, NVM_FLASH_SIZE,
  78                                          &val, sizeof(val));
  79         if (ret)
  80                 goto err_nvm;
  81
  82         nvm_size = (SZ_1M << (val & 7)) / 8;
  83         nvm_size = (nvm_size - SZ_16K) / 2;
  84
  85         ret = tb_nvm_add_active(nvm, nvm_size, tb_retimer_nvm_read);
  86         if (ret)
  87                 goto err_nvm;
  88
  89         ret = tb_nvm_add_non_active(nvm, NVM_MAX_SIZE, tb_retimer_nvm_write);
  90         if (ret)
  91                 goto err_nvm;
  92
  93         rt->nvm = nvm;
  94         return 0;
  95
  96 err_nvm:
  97         tb_nvm_free(nvm);
  98         return ret;
  99 }
 100
 101 static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt)
 102 {
 103         unsigned int image_size, hdr_size;
 104         const u8 *buf = rt->nvm->buf;
 105         u16 ds_size, device;
 106
 107         image_size = rt->nvm->buf_data_size;
 108         if (image_size < NVM_MIN_SIZE || image_size > NVM_MAX_SIZE)
 109                 return -EINVAL;
 110
 111         /*
 112          * FARB pointer must point inside the image and must at least
 113          * contain parts of the digital section we will be reading here.
 114          */
 115         hdr_size = (*(u32 *)buf) & 0xffffff;
 116         if (hdr_size + NVM_DEVID + 2 >= image_size)
 117                 return -EINVAL;
 118
 119         /* Digital section start should be aligned to 4k page */
 120         if (!IS_ALIGNED(hdr_size, SZ_4K))
 121                 return -EINVAL;
 122
 123         /*
 124          * Read digital section size and check that it also fits inside
 125          * the image.
 126          */
 127         ds_size = *(u16 *)(buf + hdr_size);
 128         if (ds_size >= image_size)
 129                 return -EINVAL;
 130
 131         /*
 132          * Make sure the device ID in the image matches the retimer
 133          * hardware.
 134          */
 135         device = *(u16 *)(buf + hdr_size + NVM_DEVID);
 136         if (device != rt->device)
 137                 return -EINVAL;
 138
 139         /* Skip headers in the image */
 140         buf += hdr_size;
 141         image_size -= hdr_size;
 142
 143         return usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf,
 144                                            image_size);
 145 }
 146
 147 static ssize_t device_show(struct device *dev, struct device_attribute *attr,
 148                            char *buf)
 149 {
 150         struct tb_retimer *rt = tb_to_retimer(dev);
 151
 152         return sprintf(buf, "%#x\n", rt->device);
 153 }
 154 static DEVICE_ATTR_RO(device);
 155
 156 static ssize_t nvm_authenticate_show(struct device *dev,
 157         struct device_attribute *attr, char *buf)
 158 {
 159         struct tb_retimer *rt = tb_to_retimer(dev);
 160         int ret;
 161
 162         if (!mutex_trylock(&rt->tb->lock))
 163                 return restart_syscall();
 164
 165         if (!rt->nvm)
 166                 ret = -EAGAIN;
 167         else
 168                 ret = sprintf(buf, "%#x\n", rt->auth_status);
 169
 170         mutex_unlock(&rt->tb->lock);
 171
 172         return ret;
 173 }
 174
 175 static ssize_t nvm_authenticate_store(struct device *dev,
 176         struct device_attribute *attr, const char *buf, size_t count)
 177 {
 178         struct tb_retimer *rt = tb_to_retimer(dev);
 179         bool val;
 180         int ret;
 181
 182         pm_runtime_get_sync(&rt->dev);
 183
 184         if (!mutex_trylock(&rt->tb->lock)) {
 185                 ret = restart_syscall();
 186                 goto exit_rpm;
 187         }
 188
 189         if (!rt->nvm) {
 190                 ret = -EAGAIN;
 191                 goto exit_unlock;
 192         }
 193
 194         ret = kstrtobool(buf, &val);
 195         if (ret)
 196                 goto exit_unlock;
 197
 198         /* Always clear status */
 199         rt->auth_status = 0;
 200
 201         if (val) {
 202                 if (!rt->nvm->buf) {
 203                         ret = -EINVAL;
 204                         goto exit_unlock;
 205                 }
 206
 207                 ret = tb_retimer_nvm_validate_and_write(rt);
 208                 if (ret)
 209                         goto exit_unlock;
 210
 211                 ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index);
 212         }
 213
 214 exit_unlock:
 215         mutex_unlock(&rt->tb->lock);
 216 exit_rpm:
 217         pm_runtime_mark_last_busy(&rt->dev);
 218         pm_runtime_put_autosuspend(&rt->dev);
 219
 220         if (ret)
 221                 return ret;
 222         return count;
 223 }
 224 static DEVICE_ATTR_RW(nvm_authenticate);
 225
 226 static ssize_t nvm_version_show(struct device *dev,
 227                                 struct device_attribute *attr, char *buf)
 228 {
 229         struct tb_retimer *rt = tb_to_retimer(dev);
 230         int ret;
 231
 232         if (!mutex_trylock(&rt->tb->lock))
 233                 return restart_syscall();
 234
 235         if (!rt->nvm)
 236                 ret = -EAGAIN;
 237         else
 238                 ret = sprintf(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);
 239
 240         mutex_unlock(&rt->tb->lock);
 241         return ret;
 242 }
 243 static DEVICE_ATTR_RO(nvm_version);
 244
 245 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
 246                            char *buf)
 247 {
 248         struct tb_retimer *rt = tb_to_retimer(dev);
 249
 250         return sprintf(buf, "%#x\n", rt->vendor);
 251 }
 252 static DEVICE_ATTR_RO(vendor);
 253
 254 static struct attribute *retimer_attrs[] = {
 255         &dev_attr_device.attr,
 256         &dev_attr_nvm_authenticate.attr,
 257         &dev_attr_nvm_version.attr,
 258         &dev_attr_vendor.attr,
 259         NULL
 260 };
 261
 262 static const struct attribute_group retimer_group = {
 263         .attrs = retimer_attrs,
 264 };
 265
 266 static const struct attribute_group *retimer_groups[] = {
 267         &retimer_group,
 268         NULL
 269 };
 270
 271 static void tb_retimer_release(struct device *dev)
 272 {
 273         struct tb_retimer *rt = tb_to_retimer(dev);
 274
 275         kfree(rt);
 276 }
 277
 278 struct device_type tb_retimer_type = {
 279         .name = "thunderbolt_retimer",
 280         .groups = retimer_groups,
 281         .release = tb_retimer_release,
 282 };
 283
 284 static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status)
 285 {
 286         struct tb_retimer *rt;
 287         u32 vendor, device;
 288         int ret;
 289
 290         if (!port->cap_usb4)
 291                 return -EINVAL;
 292
 293         ret = usb4_port_retimer_read(port, index, USB4_SB_VENDOR_ID, &vendor,
 294                                      sizeof(vendor));
 295         if (ret) {
 296                 if (ret != -ENODEV)
 297                         tb_port_warn(port, "failed read retimer VendorId: %d\n", ret);
 298                 return ret;
 299         }
 300
 301         ret = usb4_port_retimer_read(port, index, USB4_SB_PRODUCT_ID, &device,
 302                                      sizeof(device));
 303         if (ret) {
 304                 if (ret != -ENODEV)
 305                         tb_port_warn(port, "failed read retimer ProductId: %d\n", ret);
 306                 return ret;
 307         }
 308
 309         if (vendor != PCI_VENDOR_ID_INTEL && vendor != 0x8087) {
 310                 tb_port_info(port, "retimer NVM format of vendor %#x is not supported\n",
 311                              vendor);
 312                 return -EOPNOTSUPP;
 313         }
 314
 315         /*
 316          * Check that it supports NVM operations. If not then don't add
 317          * the device at all.
 318          */
 319         ret = usb4_port_retimer_nvm_sector_size(port, index);
 320         if (ret < 0)
 321                 return ret;
 322
 323         rt = kzalloc(sizeof(*rt), GFP_KERNEL);
 324         if (!rt)
 325                 return -ENOMEM;
 326
 327         rt->index = index;
 328         rt->vendor = vendor;
 329         rt->device = device;
 330         rt->auth_status = auth_status;
 331         rt->port = port;
 332         rt->tb = port->sw->tb;
 333
 334         rt->dev.parent = &port->sw->dev;
 335         rt->dev.bus = &tb_bus_type;
 336         rt->dev.type = &tb_retimer_type;
 337         dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev),
 338                      port->port, index);
 339
 340         ret = device_register(&rt->dev);
 341         if (ret) {
 342                 dev_err(&rt->dev, "failed to register retimer: %d\n", ret);
 343                 put_device(&rt->dev);
 344                 return ret;
 345         }
 346
 347         ret = tb_retimer_nvm_add(rt);
 348         if (ret) {
 349                 dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret);
 350                 device_del(&rt->dev);
 351                 return ret;
 352         }
 353
 354         dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n",
 355                  rt->vendor, rt->device);
 356
 357         pm_runtime_no_callbacks(&rt->dev);
 358         pm_runtime_set_active(&rt->dev);
 359         pm_runtime_enable(&rt->dev);
 360         pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY);
 361         pm_runtime_mark_last_busy(&rt->dev);
 362         pm_runtime_use_autosuspend(&rt->dev);
 363
 364         return 0;
 365 }
 366
 367 static void tb_retimer_remove(struct tb_retimer *rt)
 368 {
 369         dev_info(&rt->dev, "retimer disconnected\n");
 370         tb_nvm_free(rt->nvm);
 371         device_unregister(&rt->dev);
 372 }
 373
 374 struct tb_retimer_lookup {
 375         const struct tb_port *port;
 376         u8 index;
 377 };
 378
 379 static int retimer_match(struct device *dev, void *data)
 380 {
 381         const struct tb_retimer_lookup *lookup = data;
 382         struct tb_retimer *rt = tb_to_retimer(dev);
 383
 384         return rt && rt->port == lookup->port && rt->index == lookup->index;
 385 }
 386
 387 static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index)
 388 {
 389         struct tb_retimer_lookup lookup = { .port = port, .index = index };
 390         struct device *dev;
 391
 392         dev = device_find_child(&port->sw->dev, &lookup, retimer_match);
 393         if (dev)
 394                 return tb_to_retimer(dev);
 395
 396         return NULL;
 397 }
 398
 399 /**
 400  * tb_retimer_scan() - Scan for on-board retimers under port
 401  * @port: USB4 port to scan
 402  *
 403  * Tries to enumerate on-board retimers connected to @port. Found
 404  * retimers are registered as children of @port. Does not scan for cable
 405  * retimers for now.
 406  */
 407 int tb_retimer_scan(struct tb_port *port)
 408 {
 409         u32 status[TB_MAX_RETIMER_INDEX] = {};
 410         int ret, i, last_idx = 0;
 411
 412         if (!port->cap_usb4)
 413                 return 0;
 414
 415         /*
 416          * Send broadcast RT to make sure retimer indices facing this
 417          * port are set.
 418          */
 419         ret = usb4_port_enumerate_retimers(port);
 420         if (ret)
 421                 return ret;
 422
 423         /*
 424          * Before doing anything else, read the authentication status.
 425          * If the retimer has it set, store it for the new retimer
 426          * device instance.
 427          */
 428         for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
 429                 usb4_port_retimer_nvm_authenticate_status(port, i, &status[i]);
 430
 431         for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) {
 432                 /*
 433                  * Last retimer is true only for the last on-board
 434                  * retimer (the one connected directly to the Type-C
 435                  * port).
 436                  */
 437                 ret = usb4_port_retimer_is_last(port, i);
 438                 if (ret > 0)
 439                         last_idx = i;
 440                 else if (ret < 0)
 441                         break;
 442         }
 443
 444         if (!last_idx)
 445                 return 0;
 446
 447         /* Add on-board retimers if they do not exist already */
 448         for (i = 1; i <= last_idx; i++) {
 449                 struct tb_retimer *rt;
 450
 451                 rt = tb_port_find_retimer(port, i);
 452                 if (rt) {
 453                         put_device(&rt->dev);
 454                 } else {
 455                         ret = tb_retimer_add(port, i, status[i]);
 456                         if (ret && ret != -EOPNOTSUPP)
 457                                 return ret;
 458                 }
 459         }
 460
 461         return 0;
 462 }
 463
 464 static int remove_retimer(struct device *dev, void *data)
 465 {
 466         struct tb_retimer *rt = tb_to_retimer(dev);
 467         struct tb_port *port = data;
 468
 469         if (rt && rt->port == port)
 470                 tb_retimer_remove(rt);
 471         return 0;
 472 }
 473
 474 /**
 475  * tb_retimer_remove_all() - Remove all retimers under port
 476  * @port: USB4 port whose retimers to remove
 477  *
 478  * This removes all previously added retimers under @port.
 479  */
 480 void tb_retimer_remove_all(struct tb_port *port)
 481 {
 482         if (port->cap_usb4)
 483                 device_for_each_child_reverse(&port->sw->dev, port,
 484                                               remove_retimer);
 485 }