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 /**
  20  * tb_retimer_nvm_read() - Read contents of retimer NVM
  21  * @rt: Retimer device
  22  * @address: NVM address (in bytes) to start reading
  23  * @buf: Data read from NVM is stored here
  24  * @size: Number of bytes to read
  25  *
  26  * Reads retimer NVM and copies the contents to @buf. Returns %0 if the
  27  * read was successful and negative errno in case of failure.
  28  */
  29 int tb_retimer_nvm_read(struct tb_retimer *rt, unsigned int address, void *buf,
  30                         size_t size)
  31 {
  32         return usb4_port_retimer_nvm_read(rt->port, rt->index, address, buf, size);
  33 }
  34
  35 static int nvm_read(void *priv, unsigned int offset, void *val, size_t bytes)
  36 {
  37         struct tb_nvm *nvm = priv;
  38         struct tb_retimer *rt = tb_to_retimer(nvm->dev);
  39         int ret;
  40
  41         pm_runtime_get_sync(&rt->dev);
  42
  43         if (!mutex_trylock(&rt->tb->lock)) {
  44                 ret = restart_syscall();
  45                 goto out;
  46         }
  47
  48         ret = tb_retimer_nvm_read(rt, offset, val, bytes);
  49         mutex_unlock(&rt->tb->lock);
  50
  51 out:
  52         pm_runtime_mark_last_busy(&rt->dev);
  53         pm_runtime_put_autosuspend(&rt->dev);
  54
  55         return ret;
  56 }
  57
  58 static int nvm_write(void *priv, unsigned int offset, void *val, size_t bytes)
  59 {
  60         struct tb_nvm *nvm = priv;
  61         struct tb_retimer *rt = tb_to_retimer(nvm->dev);
  62         int ret = 0;
  63
  64         if (!mutex_trylock(&rt->tb->lock))
  65                 return restart_syscall();
  66
  67         ret = tb_nvm_write_buf(nvm, offset, val, bytes);
  68         mutex_unlock(&rt->tb->lock);
  69
  70         return ret;
  71 }
  72
  73 static int tb_retimer_nvm_add(struct tb_retimer *rt)
  74 {
  75         struct tb_nvm *nvm;
  76         int ret;
  77
  78         nvm = tb_nvm_alloc(&rt->dev);
  79         if (IS_ERR(nvm)) {
  80                 ret = PTR_ERR(nvm) == -EOPNOTSUPP ? 0 : PTR_ERR(nvm);
  81                 goto err_nvm;
  82         }
  83
  84         ret = tb_nvm_read_version(nvm);
  85         if (ret)
  86                 goto err_nvm;
  87
  88         ret = tb_nvm_add_active(nvm, nvm_read);
  89         if (ret)
  90                 goto err_nvm;
  91
  92         ret = tb_nvm_add_non_active(nvm, nvm_write);
  93         if (ret)
  94                 goto err_nvm;
  95
  96         rt->nvm = nvm;
  97         return 0;
  98
  99 err_nvm:
 100         dev_dbg(&rt->dev, "NVM upgrade disabled\n");
 101         if (!IS_ERR(nvm))
 102                 tb_nvm_free(nvm);
 103
 104         return ret;
 105 }
 106
 107 static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt)
 108 {
 109         unsigned int image_size;
 110         const u8 *buf;
 111         int ret;
 112
 113         ret = tb_nvm_validate(rt->nvm);
 114         if (ret)
 115                 return ret;
 116
 117         buf = rt->nvm->buf_data_start;
 118         image_size = rt->nvm->buf_data_size;
 119
 120         ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf,
 121                                          image_size);
 122         if (ret)
 123                 return ret;
 124
 125         rt->nvm->flushed = true;
 126         return 0;
 127 }
 128
 129 static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only)
 130 {
 131         u32 status;
 132         int ret;
 133
 134         if (auth_only) {
 135                 ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0);
 136                 if (ret)
 137                         return ret;
 138         }
 139
 140         ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index);
 141         if (ret)
 142                 return ret;
 143
 144         usleep_range(100, 150);
 145
 146         /*
 147          * Check the status now if we still can access the retimer. It
 148          * is expected that the below fails.
 149          */
 150         ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index,
 151                                                         &status);
 152         if (!ret) {
 153                 rt->auth_status = status;
 154                 return status ? -EINVAL : 0;
 155         }
 156
 157         return 0;
 158 }
 159
 160 static ssize_t device_show(struct device *dev, struct device_attribute *attr,
 161                            char *buf)
 162 {
 163         struct tb_retimer *rt = tb_to_retimer(dev);
 164
 165         return sysfs_emit(buf, "%#x\n", rt->device);
 166 }
 167 static DEVICE_ATTR_RO(device);
 168
 169 static ssize_t nvm_authenticate_show(struct device *dev,
 170         struct device_attribute *attr, char *buf)
 171 {
 172         struct tb_retimer *rt = tb_to_retimer(dev);
 173         int ret;
 174
 175         if (!mutex_trylock(&rt->tb->lock))
 176                 return restart_syscall();
 177
 178         if (!rt->nvm)
 179                 ret = -EAGAIN;
 180         else if (rt->no_nvm_upgrade)
 181                 ret = -EOPNOTSUPP;
 182         else
 183                 ret = sysfs_emit(buf, "%#x\n", rt->auth_status);
 184
 185         mutex_unlock(&rt->tb->lock);
 186
 187         return ret;
 188 }
 189
 190 static void tb_retimer_nvm_authenticate_status(struct tb_port *port, u32 *status)
 191 {
 192         int i;
 193
 194         tb_port_dbg(port, "reading NVM authentication status of retimers\n");
 195
 196         /*
 197          * Before doing anything else, read the authentication status.
 198          * If the retimer has it set, store it for the new retimer
 199          * device instance.
 200          */
 201         for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
 202                 usb4_port_retimer_nvm_authenticate_status(port, i, &status[i]);
 203 }
 204
 205 static void tb_retimer_set_inbound_sbtx(struct tb_port *port)
 206 {
 207         int i;
 208
 209         /*
 210          * When USB4 port is online sideband communications are
 211          * already up.
 212          */
 213         if (!usb4_port_device_is_offline(port->usb4))
 214                 return;
 215
 216         tb_port_dbg(port, "enabling sideband transactions\n");
 217
 218         for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
 219                 usb4_port_retimer_set_inbound_sbtx(port, i);
 220 }
 221
 222 static void tb_retimer_unset_inbound_sbtx(struct tb_port *port)
 223 {
 224         int i;
 225
 226         /*
 227          * When USB4 port is offline we need to keep the sideband
 228          * communications up to make it possible to communicate with
 229          * the connected retimers.
 230          */
 231         if (usb4_port_device_is_offline(port->usb4))
 232                 return;
 233
 234         tb_port_dbg(port, "disabling sideband transactions\n");
 235
 236         for (i = TB_MAX_RETIMER_INDEX; i >= 1; i--)
 237                 usb4_port_retimer_unset_inbound_sbtx(port, i);
 238 }
 239
 240 static ssize_t nvm_authenticate_store(struct device *dev,
 241         struct device_attribute *attr, const char *buf, size_t count)
 242 {
 243         struct tb_retimer *rt = tb_to_retimer(dev);
 244         int val, ret;
 245
 246         pm_runtime_get_sync(&rt->dev);
 247
 248         if (!mutex_trylock(&rt->tb->lock)) {
 249                 ret = restart_syscall();
 250                 goto exit_rpm;
 251         }
 252
 253         if (!rt->nvm) {
 254                 ret = -EAGAIN;
 255                 goto exit_unlock;
 256         }
 257
 258         ret = kstrtoint(buf, 10, &val);
 259         if (ret)
 260                 goto exit_unlock;
 261
 262         /* Always clear status */
 263         rt->auth_status = 0;
 264
 265         if (val) {
 266                 /*
 267                  * When NVM authentication starts the retimer is not
 268                  * accessible so calling tb_retimer_unset_inbound_sbtx()
 269                  * will fail and therefore we do not call it. Exception
 270                  * is when the validation fails or we only write the new
 271                  * NVM image without authentication.
 272                  */
 273                 tb_retimer_set_inbound_sbtx(rt->port);
 274                 if (val == AUTHENTICATE_ONLY) {
 275                         ret = tb_retimer_nvm_authenticate(rt, true);
 276                 } else {
 277                         if (!rt->nvm->flushed) {
 278                                 if (!rt->nvm->buf) {
 279                                         ret = -EINVAL;
 280                                         goto exit_unlock;
 281                                 }
 282
 283                                 ret = tb_retimer_nvm_validate_and_write(rt);
 284                                 if (ret || val == WRITE_ONLY)
 285                                         goto exit_unlock;
 286                         }
 287                         if (val == WRITE_AND_AUTHENTICATE)
 288                                 ret = tb_retimer_nvm_authenticate(rt, false);
 289                 }
 290         }
 291
 292 exit_unlock:
 293         if (ret || val == WRITE_ONLY)
 294                 tb_retimer_unset_inbound_sbtx(rt->port);
 295         mutex_unlock(&rt->tb->lock);
 296 exit_rpm:
 297         pm_runtime_mark_last_busy(&rt->dev);
 298         pm_runtime_put_autosuspend(&rt->dev);
 299
 300         if (ret)
 301                 return ret;
 302         return count;
 303 }
 304 static DEVICE_ATTR_RW(nvm_authenticate);
 305
 306 static ssize_t nvm_version_show(struct device *dev,
 307                                 struct device_attribute *attr, char *buf)
 308 {
 309         struct tb_retimer *rt = tb_to_retimer(dev);
 310         int ret;
 311
 312         if (!mutex_trylock(&rt->tb->lock))
 313                 return restart_syscall();
 314
 315         if (!rt->nvm)
 316                 ret = -EAGAIN;
 317         else
 318                 ret = sysfs_emit(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);
 319
 320         mutex_unlock(&rt->tb->lock);
 321         return ret;
 322 }
 323 static DEVICE_ATTR_RO(nvm_version);
 324
 325 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
 326                            char *buf)
 327 {
 328         struct tb_retimer *rt = tb_to_retimer(dev);
 329
 330         return sysfs_emit(buf, "%#x\n", rt->vendor);
 331 }
 332 static DEVICE_ATTR_RO(vendor);
 333
 334 static struct attribute *retimer_attrs[] = {
 335         &dev_attr_device.attr,
 336         &dev_attr_nvm_authenticate.attr,
 337         &dev_attr_nvm_version.attr,
 338         &dev_attr_vendor.attr,
 339         NULL
 340 };
 341
 342 static const struct attribute_group retimer_group = {
 343         .attrs = retimer_attrs,
 344 };
 345
 346 static const struct attribute_group *retimer_groups[] = {
 347         &retimer_group,
 348         NULL
 349 };
 350
 351 static void tb_retimer_release(struct device *dev)
 352 {
 353         struct tb_retimer *rt = tb_to_retimer(dev);
 354
 355         kfree(rt);
 356 }
 357
 358 struct device_type tb_retimer_type = {
 359         .name = "thunderbolt_retimer",
 360         .groups = retimer_groups,
 361         .release = tb_retimer_release,
 362 };
 363
 364 static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status)
 365 {
 366         struct tb_retimer *rt;
 367         u32 vendor, device;
 368         int ret;
 369
 370         ret = usb4_port_retimer_read(port, index, USB4_SB_VENDOR_ID, &vendor,
 371                                      sizeof(vendor));
 372         if (ret) {
 373                 if (ret != -ENODEV)
 374                         tb_port_warn(port, "failed read retimer VendorId: %d\n", ret);
 375                 return ret;
 376         }
 377
 378         ret = usb4_port_retimer_read(port, index, USB4_SB_PRODUCT_ID, &device,
 379                                      sizeof(device));
 380         if (ret) {
 381                 if (ret != -ENODEV)
 382                         tb_port_warn(port, "failed read retimer ProductId: %d\n", ret);
 383                 return ret;
 384         }
 385
 386         /*
 387          * Check that it supports NVM operations. If not then don't add
 388          * the device at all.
 389          */
 390         ret = usb4_port_retimer_nvm_sector_size(port, index);
 391         if (ret < 0)
 392                 return ret;
 393
 394         rt = kzalloc(sizeof(*rt), GFP_KERNEL);
 395         if (!rt)
 396                 return -ENOMEM;
 397
 398         rt->index = index;
 399         rt->vendor = vendor;
 400         rt->device = device;
 401         rt->auth_status = auth_status;
 402         rt->port = port;
 403         rt->tb = port->sw->tb;
 404
 405         rt->dev.parent = &port->usb4->dev;
 406         rt->dev.bus = &tb_bus_type;
 407         rt->dev.type = &tb_retimer_type;
 408         dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev),
 409                      port->port, index);
 410
 411         ret = device_register(&rt->dev);
 412         if (ret) {
 413                 dev_err(&rt->dev, "failed to register retimer: %d\n", ret);
 414                 put_device(&rt->dev);
 415                 return ret;
 416         }
 417
 418         ret = tb_retimer_nvm_add(rt);
 419         if (ret) {
 420                 dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret);
 421                 device_unregister(&rt->dev);
 422                 return ret;
 423         }
 424
 425         dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n",
 426                  rt->vendor, rt->device);
 427
 428         pm_runtime_no_callbacks(&rt->dev);
 429         pm_runtime_set_active(&rt->dev);
 430         pm_runtime_enable(&rt->dev);
 431         pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY);
 432         pm_runtime_mark_last_busy(&rt->dev);
 433         pm_runtime_use_autosuspend(&rt->dev);
 434
 435         return 0;
 436 }
 437
 438 static void tb_retimer_remove(struct tb_retimer *rt)
 439 {
 440         dev_info(&rt->dev, "retimer disconnected\n");
 441         tb_nvm_free(rt->nvm);
 442         device_unregister(&rt->dev);
 443 }
 444
 445 struct tb_retimer_lookup {
 446         const struct tb_port *port;
 447         u8 index;
 448 };
 449
 450 static int retimer_match(struct device *dev, void *data)
 451 {
 452         const struct tb_retimer_lookup *lookup = data;
 453         struct tb_retimer *rt = tb_to_retimer(dev);
 454
 455         return rt && rt->port == lookup->port && rt->index == lookup->index;
 456 }
 457
 458 static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index)
 459 {
 460         struct tb_retimer_lookup lookup = { .port = port, .index = index };
 461         struct device *dev;
 462
 463         dev = device_find_child(&port->usb4->dev, &lookup, retimer_match);
 464         if (dev)
 465                 return tb_to_retimer(dev);
 466
 467         return NULL;
 468 }
 469
 470 /**
 471  * tb_retimer_scan() - Scan for on-board retimers under port
 472  * @port: USB4 port to scan
 473  * @add: If true also registers found retimers
 474  *
 475  * Brings the sideband into a state where retimers can be accessed.
 476  * Then Tries to enumerate on-board retimers connected to @port. Found
 477  * retimers are registered as children of @port if @add is set.  Does
 478  * not scan for cable retimers for now.
 479  */
 480 int tb_retimer_scan(struct tb_port *port, bool add)
 481 {
 482         u32 status[TB_MAX_RETIMER_INDEX + 1] = {};
 483         int ret, i, last_idx = 0;
 484
 485         /*
 486          * Send broadcast RT to make sure retimer indices facing this
 487          * port are set.
 488          */
 489         ret = usb4_port_enumerate_retimers(port);
 490         if (ret)
 491                 return ret;
 492
 493         /*
 494          * Immediately after sending enumerate retimers read the
 495          * authentication status of each retimer.
 496          */
 497         tb_retimer_nvm_authenticate_status(port, status);
 498
 499         /*
 500          * Enable sideband channel for each retimer. We can do this
 501          * regardless whether there is device connected or not.
 502          */
 503         tb_retimer_set_inbound_sbtx(port);
 504
 505         for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) {
 506                 /*
 507                  * Last retimer is true only for the last on-board
 508                  * retimer (the one connected directly to the Type-C
 509                  * port).
 510                  */
 511                 ret = usb4_port_retimer_is_last(port, i);
 512                 if (ret > 0)
 513                         last_idx = i;
 514                 else if (ret < 0)
 515                         break;
 516         }
 517
 518         tb_retimer_unset_inbound_sbtx(port);
 519
 520         if (!last_idx)
 521                 return 0;
 522
 523         /* Add on-board retimers if they do not exist already */
 524         ret = 0;
 525         for (i = 1; i <= last_idx; i++) {
 526                 struct tb_retimer *rt;
 527
 528                 rt = tb_port_find_retimer(port, i);
 529                 if (rt) {
 530                         put_device(&rt->dev);
 531                 } else if (add) {
 532                         ret = tb_retimer_add(port, i, status[i]);
 533                         if (ret && ret != -EOPNOTSUPP)
 534                                 break;
 535                 }
 536         }
 537
 538         return ret;
 539 }
 540
 541 static int remove_retimer(struct device *dev, void *data)
 542 {
 543         struct tb_retimer *rt = tb_to_retimer(dev);
 544         struct tb_port *port = data;
 545
 546         if (rt && rt->port == port)
 547                 tb_retimer_remove(rt);
 548         return 0;
 549 }
 550
 551 /**
 552  * tb_retimer_remove_all() - Remove all retimers under port
 553  * @port: USB4 port whose retimers to remove
 554  *
 555  * This removes all previously added retimers under @port.
 556  */
 557 void tb_retimer_remove_all(struct tb_port *port)
 558 {
 559         struct usb4_port *usb4;
 560
 561         usb4 = port->usb4;
 562         if (usb4)
 563                 device_for_each_child_reverse(&usb4->dev, port,
 564                                               remove_retimer);
 565 }