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 int ret; 107 108 image_size = rt->nvm->buf_data_size; 109 if (image_size < NVM_MIN_SIZE || image_size > NVM_MAX_SIZE) 110 return -EINVAL; 111 112 /* 113 * FARB pointer must point inside the image and must at least 114 * contain parts of the digital section we will be reading here. 115 */ 116 hdr_size = (*(u32 *)buf) & 0xffffff; 117 if (hdr_size + NVM_DEVID + 2 >= image_size) 118 return -EINVAL; 119 120 /* Digital section start should be aligned to 4k page */ 121 if (!IS_ALIGNED(hdr_size, SZ_4K)) 122 return -EINVAL; 123 124 /* 125 * Read digital section size and check that it also fits inside 126 * the image. 127 */ 128 ds_size = *(u16 *)(buf + hdr_size); 129 if (ds_size >= image_size) 130 return -EINVAL; 131 132 /* 133 * Make sure the device ID in the image matches the retimer 134 * hardware. 135 */ 136 device = *(u16 *)(buf + hdr_size + NVM_DEVID); 137 if (device != rt->device) 138 return -EINVAL; 139 140 /* Skip headers in the image */ 141 buf += hdr_size; 142 image_size -= hdr_size; 143 144 ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf, 145 image_size); 146 if (!ret) 147 rt->nvm->flushed = true; 148 149 return ret; 150 } 151 152 static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only) 153 { 154 u32 status; 155 int ret; 156 157 if (auth_only) { 158 ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0); 159 if (ret) 160 return ret; 161 } 162 163 ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index); 164 if (ret) 165 return ret; 166 167 usleep_range(100, 150); 168 169 /* 170 * Check the status now if we still can access the retimer. It 171 * is expected that the below fails. 172 */ 173 ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index, 174 &status); 175 if (!ret) { 176 rt->auth_status = status; 177 return status ? -EINVAL : 0; 178 } 179 180 return 0; 181 } 182 183 static ssize_t device_show(struct device *dev, struct device_attribute *attr, 184 char *buf) 185 { 186 struct tb_retimer *rt = tb_to_retimer(dev); 187 188 return sprintf(buf, "%#x\n", rt->device); 189 } 190 static DEVICE_ATTR_RO(device); 191 192 static ssize_t nvm_authenticate_show(struct device *dev, 193 struct device_attribute *attr, char *buf) 194 { 195 struct tb_retimer *rt = tb_to_retimer(dev); 196 int ret; 197 198 if (!mutex_trylock(&rt->tb->lock)) 199 return restart_syscall(); 200 201 if (!rt->nvm) 202 ret = -EAGAIN; 203 else 204 ret = sprintf(buf, "%#x\n", rt->auth_status); 205 206 mutex_unlock(&rt->tb->lock); 207 208 return ret; 209 } 210 211 static ssize_t nvm_authenticate_store(struct device *dev, 212 struct device_attribute *attr, const char *buf, size_t count) 213 { 214 struct tb_retimer *rt = tb_to_retimer(dev); 215 int val, ret; 216 217 pm_runtime_get_sync(&rt->dev); 218 219 if (!mutex_trylock(&rt->tb->lock)) { 220 ret = restart_syscall(); 221 goto exit_rpm; 222 } 223 224 if (!rt->nvm) { 225 ret = -EAGAIN; 226 goto exit_unlock; 227 } 228 229 ret = kstrtoint(buf, 10, &val); 230 if (ret) 231 goto exit_unlock; 232 233 /* Always clear status */ 234 rt->auth_status = 0; 235 236 if (val) { 237 if (val == AUTHENTICATE_ONLY) { 238 ret = tb_retimer_nvm_authenticate(rt, true); 239 } else { 240 if (!rt->nvm->flushed) { 241 if (!rt->nvm->buf) { 242 ret = -EINVAL; 243 goto exit_unlock; 244 } 245 246 ret = tb_retimer_nvm_validate_and_write(rt); 247 if (ret || val == WRITE_ONLY) 248 goto exit_unlock; 249 } 250 if (val == WRITE_AND_AUTHENTICATE) 251 ret = tb_retimer_nvm_authenticate(rt, false); 252 } 253 } 254 255 exit_unlock: 256 mutex_unlock(&rt->tb->lock); 257 exit_rpm: 258 pm_runtime_mark_last_busy(&rt->dev); 259 pm_runtime_put_autosuspend(&rt->dev); 260 261 if (ret) 262 return ret; 263 return count; 264 } 265 static DEVICE_ATTR_RW(nvm_authenticate); 266 267 static ssize_t nvm_version_show(struct device *dev, 268 struct device_attribute *attr, char *buf) 269 { 270 struct tb_retimer *rt = tb_to_retimer(dev); 271 int ret; 272 273 if (!mutex_trylock(&rt->tb->lock)) 274 return restart_syscall(); 275 276 if (!rt->nvm) 277 ret = -EAGAIN; 278 else 279 ret = sprintf(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor); 280 281 mutex_unlock(&rt->tb->lock); 282 return ret; 283 } 284 static DEVICE_ATTR_RO(nvm_version); 285 286 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr, 287 char *buf) 288 { 289 struct tb_retimer *rt = tb_to_retimer(dev); 290 291 return sprintf(buf, "%#x\n", rt->vendor); 292 } 293 static DEVICE_ATTR_RO(vendor); 294 295 static struct attribute *retimer_attrs[] = { 296 &dev_attr_device.attr, 297 &dev_attr_nvm_authenticate.attr, 298 &dev_attr_nvm_version.attr, 299 &dev_attr_vendor.attr, 300 NULL 301 }; 302 303 static const struct attribute_group retimer_group = { 304 .attrs = retimer_attrs, 305 }; 306 307 static const struct attribute_group *retimer_groups[] = { 308 &retimer_group, 309 NULL 310 }; 311 312 static void tb_retimer_release(struct device *dev) 313 { 314 struct tb_retimer *rt = tb_to_retimer(dev); 315 316 kfree(rt); 317 } 318 319 struct device_type tb_retimer_type = { 320 .name = "thunderbolt_retimer", 321 .groups = retimer_groups, 322 .release = tb_retimer_release, 323 }; 324 325 static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status) 326 { 327 struct tb_retimer *rt; 328 u32 vendor, device; 329 int ret; 330 331 ret = usb4_port_retimer_read(port, index, USB4_SB_VENDOR_ID, &vendor, 332 sizeof(vendor)); 333 if (ret) { 334 if (ret != -ENODEV) 335 tb_port_warn(port, "failed read retimer VendorId: %d\n", ret); 336 return ret; 337 } 338 339 ret = usb4_port_retimer_read(port, index, USB4_SB_PRODUCT_ID, &device, 340 sizeof(device)); 341 if (ret) { 342 if (ret != -ENODEV) 343 tb_port_warn(port, "failed read retimer ProductId: %d\n", ret); 344 return ret; 345 } 346 347 if (vendor != PCI_VENDOR_ID_INTEL && vendor != 0x8087) { 348 tb_port_info(port, "retimer NVM format of vendor %#x is not supported\n", 349 vendor); 350 return -EOPNOTSUPP; 351 } 352 353 /* 354 * Check that it supports NVM operations. If not then don't add 355 * the device at all. 356 */ 357 ret = usb4_port_retimer_nvm_sector_size(port, index); 358 if (ret < 0) 359 return ret; 360 361 rt = kzalloc(sizeof(*rt), GFP_KERNEL); 362 if (!rt) 363 return -ENOMEM; 364 365 rt->index = index; 366 rt->vendor = vendor; 367 rt->device = device; 368 rt->auth_status = auth_status; 369 rt->port = port; 370 rt->tb = port->sw->tb; 371 372 rt->dev.parent = &port->usb4->dev; 373 rt->dev.bus = &tb_bus_type; 374 rt->dev.type = &tb_retimer_type; 375 dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev), 376 port->port, index); 377 378 ret = device_register(&rt->dev); 379 if (ret) { 380 dev_err(&rt->dev, "failed to register retimer: %d\n", ret); 381 put_device(&rt->dev); 382 return ret; 383 } 384 385 ret = tb_retimer_nvm_add(rt); 386 if (ret) { 387 dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret); 388 device_unregister(&rt->dev); 389 return ret; 390 } 391 392 dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n", 393 rt->vendor, rt->device); 394 395 pm_runtime_no_callbacks(&rt->dev); 396 pm_runtime_set_active(&rt->dev); 397 pm_runtime_enable(&rt->dev); 398 pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY); 399 pm_runtime_mark_last_busy(&rt->dev); 400 pm_runtime_use_autosuspend(&rt->dev); 401 402 return 0; 403 } 404 405 static void tb_retimer_remove(struct tb_retimer *rt) 406 { 407 dev_info(&rt->dev, "retimer disconnected\n"); 408 tb_nvm_free(rt->nvm); 409 device_unregister(&rt->dev); 410 } 411 412 struct tb_retimer_lookup { 413 const struct tb_port *port; 414 u8 index; 415 }; 416 417 static int retimer_match(struct device *dev, void *data) 418 { 419 const struct tb_retimer_lookup *lookup = data; 420 struct tb_retimer *rt = tb_to_retimer(dev); 421 422 return rt && rt->port == lookup->port && rt->index == lookup->index; 423 } 424 425 static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index) 426 { 427 struct tb_retimer_lookup lookup = { .port = port, .index = index }; 428 struct device *dev; 429 430 dev = device_find_child(&port->usb4->dev, &lookup, retimer_match); 431 if (dev) 432 return tb_to_retimer(dev); 433 434 return NULL; 435 } 436 437 /** 438 * tb_retimer_scan() - Scan for on-board retimers under port 439 * @port: USB4 port to scan 440 * @add: If true also registers found retimers 441 * 442 * Brings the sideband into a state where retimers can be accessed. 443 * Then Tries to enumerate on-board retimers connected to @port. Found 444 * retimers are registered as children of @port if @add is set. Does 445 * not scan for cable retimers for now. 446 */ 447 int tb_retimer_scan(struct tb_port *port, bool add) 448 { 449 u32 status[TB_MAX_RETIMER_INDEX + 1] = {}; 450 int ret, i, last_idx = 0; 451 struct usb4_port *usb4; 452 453 usb4 = port->usb4; 454 if (!usb4) 455 return 0; 456 457 pm_runtime_get_sync(&usb4->dev); 458 459 /* 460 * Send broadcast RT to make sure retimer indices facing this 461 * port are set. 462 */ 463 ret = usb4_port_enumerate_retimers(port); 464 if (ret) 465 goto out; 466 467 /* 468 * Enable sideband channel for each retimer. We can do this 469 * regardless whether there is device connected or not. 470 */ 471 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) 472 usb4_port_retimer_set_inbound_sbtx(port, i); 473 474 /* 475 * Before doing anything else, read the authentication status. 476 * If the retimer has it set, store it for the new retimer 477 * device instance. 478 */ 479 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) 480 usb4_port_retimer_nvm_authenticate_status(port, i, &status[i]); 481 482 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) { 483 /* 484 * Last retimer is true only for the last on-board 485 * retimer (the one connected directly to the Type-C 486 * port). 487 */ 488 ret = usb4_port_retimer_is_last(port, i); 489 if (ret > 0) 490 last_idx = i; 491 else if (ret < 0) 492 break; 493 } 494 495 if (!last_idx) { 496 ret = 0; 497 goto out; 498 } 499 500 /* Add on-board retimers if they do not exist already */ 501 for (i = 1; i <= last_idx; i++) { 502 struct tb_retimer *rt; 503 504 rt = tb_port_find_retimer(port, i); 505 if (rt) { 506 put_device(&rt->dev); 507 } else if (add) { 508 ret = tb_retimer_add(port, i, status[i]); 509 if (ret && ret != -EOPNOTSUPP) 510 break; 511 } 512 } 513 514 out: 515 pm_runtime_mark_last_busy(&usb4->dev); 516 pm_runtime_put_autosuspend(&usb4->dev); 517 518 return ret; 519 } 520 521 static int remove_retimer(struct device *dev, void *data) 522 { 523 struct tb_retimer *rt = tb_to_retimer(dev); 524 struct tb_port *port = data; 525 526 if (rt && rt->port == port) 527 tb_retimer_remove(rt); 528 return 0; 529 } 530 531 /** 532 * tb_retimer_remove_all() - Remove all retimers under port 533 * @port: USB4 port whose retimers to remove 534 * 535 * This removes all previously added retimers under @port. 536 */ 537 void tb_retimer_remove_all(struct tb_port *port) 538 { 539 struct usb4_port *usb4; 540 541 usb4 = port->usb4; 542 if (usb4) 543 device_for_each_child_reverse(&usb4->dev, port, 544 remove_retimer); 545 } 546