1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Thunderbolt Time Management Unit (TMU) support 4 * 5 * Copyright (C) 2019, Intel Corporation 6 * Authors: Mika Westerberg <mika.westerberg@linux.intel.com> 7 * Rajmohan Mani <rajmohan.mani@intel.com> 8 */ 9 10 #include <linux/delay.h> 11 12 #include "tb.h" 13 14 static const unsigned int tmu_rates[] = { 15 [TB_SWITCH_TMU_MODE_OFF] = 0, 16 [TB_SWITCH_TMU_MODE_LOWRES] = 1000, 17 [TB_SWITCH_TMU_MODE_HIFI_UNI] = 16, 18 [TB_SWITCH_TMU_MODE_HIFI_BI] = 16, 19 [TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI] = 16, 20 }; 21 22 static const struct { 23 unsigned int freq_meas_window; 24 unsigned int avg_const; 25 unsigned int delta_avg_const; 26 unsigned int repl_timeout; 27 unsigned int repl_threshold; 28 unsigned int repl_n; 29 unsigned int dirswitch_n; 30 } tmu_params[] = { 31 [TB_SWITCH_TMU_MODE_OFF] = { }, 32 [TB_SWITCH_TMU_MODE_LOWRES] = { 30, 4, }, 33 [TB_SWITCH_TMU_MODE_HIFI_UNI] = { 800, 8, }, 34 [TB_SWITCH_TMU_MODE_HIFI_BI] = { 800, 8, }, 35 [TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI] = { 36 800, 4, 0, 3125, 25, 128, 255, 37 }, 38 }; 39 40 static const char *tmu_mode_name(enum tb_switch_tmu_mode mode) 41 { 42 switch (mode) { 43 case TB_SWITCH_TMU_MODE_OFF: 44 return "off"; 45 case TB_SWITCH_TMU_MODE_LOWRES: 46 return "uni-directional, LowRes"; 47 case TB_SWITCH_TMU_MODE_HIFI_UNI: 48 return "uni-directional, HiFi"; 49 case TB_SWITCH_TMU_MODE_HIFI_BI: 50 return "bi-directional, HiFi"; 51 case TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI: 52 return "enhanced uni-directional, MedRes"; 53 default: 54 return "unknown"; 55 } 56 } 57 58 static bool tb_switch_tmu_enhanced_is_supported(const struct tb_switch *sw) 59 { 60 return usb4_switch_version(sw) > 1; 61 } 62 63 static int tb_switch_set_tmu_mode_params(struct tb_switch *sw, 64 enum tb_switch_tmu_mode mode) 65 { 66 u32 freq, avg, val; 67 int ret; 68 69 freq = tmu_params[mode].freq_meas_window; 70 avg = tmu_params[mode].avg_const; 71 72 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, 73 sw->tmu.cap + TMU_RTR_CS_0, 1); 74 if (ret) 75 return ret; 76 77 val &= ~TMU_RTR_CS_0_FREQ_WIND_MASK; 78 val |= FIELD_PREP(TMU_RTR_CS_0_FREQ_WIND_MASK, freq); 79 80 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, 81 sw->tmu.cap + TMU_RTR_CS_0, 1); 82 if (ret) 83 return ret; 84 85 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, 86 sw->tmu.cap + TMU_RTR_CS_15, 1); 87 if (ret) 88 return ret; 89 90 val &= ~TMU_RTR_CS_15_FREQ_AVG_MASK & 91 ~TMU_RTR_CS_15_DELAY_AVG_MASK & 92 ~TMU_RTR_CS_15_OFFSET_AVG_MASK & 93 ~TMU_RTR_CS_15_ERROR_AVG_MASK; 94 val |= FIELD_PREP(TMU_RTR_CS_15_FREQ_AVG_MASK, avg) | 95 FIELD_PREP(TMU_RTR_CS_15_DELAY_AVG_MASK, avg) | 96 FIELD_PREP(TMU_RTR_CS_15_OFFSET_AVG_MASK, avg) | 97 FIELD_PREP(TMU_RTR_CS_15_ERROR_AVG_MASK, avg); 98 99 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, 100 sw->tmu.cap + TMU_RTR_CS_15, 1); 101 if (ret) 102 return ret; 103 104 if (tb_switch_tmu_enhanced_is_supported(sw)) { 105 u32 delta_avg = tmu_params[mode].delta_avg_const; 106 107 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, 108 sw->tmu.cap + TMU_RTR_CS_18, 1); 109 if (ret) 110 return ret; 111 112 val &= ~TMU_RTR_CS_18_DELTA_AVG_CONST_MASK; 113 val |= FIELD_PREP(TMU_RTR_CS_18_DELTA_AVG_CONST_MASK, delta_avg); 114 115 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, 116 sw->tmu.cap + TMU_RTR_CS_18, 1); 117 } 118 119 return ret; 120 } 121 122 static bool tb_switch_tmu_ucap_is_supported(struct tb_switch *sw) 123 { 124 int ret; 125 u32 val; 126 127 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, 128 sw->tmu.cap + TMU_RTR_CS_0, 1); 129 if (ret) 130 return false; 131 132 return !!(val & TMU_RTR_CS_0_UCAP); 133 } 134 135 static int tb_switch_tmu_rate_read(struct tb_switch *sw) 136 { 137 int ret; 138 u32 val; 139 140 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, 141 sw->tmu.cap + TMU_RTR_CS_3, 1); 142 if (ret) 143 return ret; 144 145 val >>= TMU_RTR_CS_3_TS_PACKET_INTERVAL_SHIFT; 146 return val; 147 } 148 149 static int tb_switch_tmu_rate_write(struct tb_switch *sw, int rate) 150 { 151 int ret; 152 u32 val; 153 154 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, 155 sw->tmu.cap + TMU_RTR_CS_3, 1); 156 if (ret) 157 return ret; 158 159 val &= ~TMU_RTR_CS_3_TS_PACKET_INTERVAL_MASK; 160 val |= rate << TMU_RTR_CS_3_TS_PACKET_INTERVAL_SHIFT; 161 162 return tb_sw_write(sw, &val, TB_CFG_SWITCH, 163 sw->tmu.cap + TMU_RTR_CS_3, 1); 164 } 165 166 static int tb_port_tmu_write(struct tb_port *port, u8 offset, u32 mask, 167 u32 value) 168 { 169 u32 data; 170 int ret; 171 172 ret = tb_port_read(port, &data, TB_CFG_PORT, port->cap_tmu + offset, 1); 173 if (ret) 174 return ret; 175 176 data &= ~mask; 177 data |= value; 178 179 return tb_port_write(port, &data, TB_CFG_PORT, 180 port->cap_tmu + offset, 1); 181 } 182 183 static int tb_port_tmu_set_unidirectional(struct tb_port *port, 184 bool unidirectional) 185 { 186 u32 val; 187 188 if (!port->sw->tmu.has_ucap) 189 return 0; 190 191 val = unidirectional ? TMU_ADP_CS_3_UDM : 0; 192 return tb_port_tmu_write(port, TMU_ADP_CS_3, TMU_ADP_CS_3_UDM, val); 193 } 194 195 static inline int tb_port_tmu_unidirectional_disable(struct tb_port *port) 196 { 197 return tb_port_tmu_set_unidirectional(port, false); 198 } 199 200 static inline int tb_port_tmu_unidirectional_enable(struct tb_port *port) 201 { 202 return tb_port_tmu_set_unidirectional(port, true); 203 } 204 205 static bool tb_port_tmu_is_unidirectional(struct tb_port *port) 206 { 207 int ret; 208 u32 val; 209 210 ret = tb_port_read(port, &val, TB_CFG_PORT, 211 port->cap_tmu + TMU_ADP_CS_3, 1); 212 if (ret) 213 return false; 214 215 return val & TMU_ADP_CS_3_UDM; 216 } 217 218 static bool tb_port_tmu_is_enhanced(struct tb_port *port) 219 { 220 int ret; 221 u32 val; 222 223 ret = tb_port_read(port, &val, TB_CFG_PORT, 224 port->cap_tmu + TMU_ADP_CS_8, 1); 225 if (ret) 226 return false; 227 228 return val & TMU_ADP_CS_8_EUDM; 229 } 230 231 /* Can be called to non-v2 lane adapters too */ 232 static int tb_port_tmu_enhanced_enable(struct tb_port *port, bool enable) 233 { 234 int ret; 235 u32 val; 236 237 if (!tb_switch_tmu_enhanced_is_supported(port->sw)) 238 return 0; 239 240 ret = tb_port_read(port, &val, TB_CFG_PORT, 241 port->cap_tmu + TMU_ADP_CS_8, 1); 242 if (ret) 243 return ret; 244 245 if (enable) 246 val |= TMU_ADP_CS_8_EUDM; 247 else 248 val &= ~TMU_ADP_CS_8_EUDM; 249 250 return tb_port_write(port, &val, TB_CFG_PORT, 251 port->cap_tmu + TMU_ADP_CS_8, 1); 252 } 253 254 static int tb_port_set_tmu_mode_params(struct tb_port *port, 255 enum tb_switch_tmu_mode mode) 256 { 257 u32 repl_timeout, repl_threshold, repl_n, dirswitch_n, val; 258 int ret; 259 260 repl_timeout = tmu_params[mode].repl_timeout; 261 repl_threshold = tmu_params[mode].repl_threshold; 262 repl_n = tmu_params[mode].repl_n; 263 dirswitch_n = tmu_params[mode].dirswitch_n; 264 265 ret = tb_port_read(port, &val, TB_CFG_PORT, 266 port->cap_tmu + TMU_ADP_CS_8, 1); 267 if (ret) 268 return ret; 269 270 val &= ~TMU_ADP_CS_8_REPL_TIMEOUT_MASK; 271 val &= ~TMU_ADP_CS_8_REPL_THRESHOLD_MASK; 272 val |= FIELD_PREP(TMU_ADP_CS_8_REPL_TIMEOUT_MASK, repl_timeout); 273 val |= FIELD_PREP(TMU_ADP_CS_8_REPL_THRESHOLD_MASK, repl_threshold); 274 275 ret = tb_port_write(port, &val, TB_CFG_PORT, 276 port->cap_tmu + TMU_ADP_CS_8, 1); 277 if (ret) 278 return ret; 279 280 ret = tb_port_read(port, &val, TB_CFG_PORT, 281 port->cap_tmu + TMU_ADP_CS_9, 1); 282 if (ret) 283 return ret; 284 285 val &= ~TMU_ADP_CS_9_REPL_N_MASK; 286 val &= ~TMU_ADP_CS_9_DIRSWITCH_N_MASK; 287 val |= FIELD_PREP(TMU_ADP_CS_9_REPL_N_MASK, repl_n); 288 val |= FIELD_PREP(TMU_ADP_CS_9_DIRSWITCH_N_MASK, dirswitch_n); 289 290 return tb_port_write(port, &val, TB_CFG_PORT, 291 port->cap_tmu + TMU_ADP_CS_9, 1); 292 } 293 294 /* Can be called to non-v2 lane adapters too */ 295 static int tb_port_tmu_rate_write(struct tb_port *port, int rate) 296 { 297 int ret; 298 u32 val; 299 300 if (!tb_switch_tmu_enhanced_is_supported(port->sw)) 301 return 0; 302 303 ret = tb_port_read(port, &val, TB_CFG_PORT, 304 port->cap_tmu + TMU_ADP_CS_9, 1); 305 if (ret) 306 return ret; 307 308 val &= ~TMU_ADP_CS_9_ADP_TS_INTERVAL_MASK; 309 val |= FIELD_PREP(TMU_ADP_CS_9_ADP_TS_INTERVAL_MASK, rate); 310 311 return tb_port_write(port, &val, TB_CFG_PORT, 312 port->cap_tmu + TMU_ADP_CS_9, 1); 313 } 314 315 static int tb_port_tmu_time_sync(struct tb_port *port, bool time_sync) 316 { 317 u32 val = time_sync ? TMU_ADP_CS_6_DTS : 0; 318 319 return tb_port_tmu_write(port, TMU_ADP_CS_6, TMU_ADP_CS_6_DTS, val); 320 } 321 322 static int tb_port_tmu_time_sync_disable(struct tb_port *port) 323 { 324 return tb_port_tmu_time_sync(port, true); 325 } 326 327 static int tb_port_tmu_time_sync_enable(struct tb_port *port) 328 { 329 return tb_port_tmu_time_sync(port, false); 330 } 331 332 static int tb_switch_tmu_set_time_disruption(struct tb_switch *sw, bool set) 333 { 334 u32 val, offset, bit; 335 int ret; 336 337 if (tb_switch_is_usb4(sw)) { 338 offset = sw->tmu.cap + TMU_RTR_CS_0; 339 bit = TMU_RTR_CS_0_TD; 340 } else { 341 offset = sw->cap_vsec_tmu + TB_TIME_VSEC_3_CS_26; 342 bit = TB_TIME_VSEC_3_CS_26_TD; 343 } 344 345 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, offset, 1); 346 if (ret) 347 return ret; 348 349 if (set) 350 val |= bit; 351 else 352 val &= ~bit; 353 354 return tb_sw_write(sw, &val, TB_CFG_SWITCH, offset, 1); 355 } 356 357 static int tmu_mode_init(struct tb_switch *sw) 358 { 359 bool enhanced, ucap; 360 int ret, rate; 361 362 ucap = tb_switch_tmu_ucap_is_supported(sw); 363 if (ucap) 364 tb_sw_dbg(sw, "TMU: supports uni-directional mode\n"); 365 enhanced = tb_switch_tmu_enhanced_is_supported(sw); 366 if (enhanced) 367 tb_sw_dbg(sw, "TMU: supports enhanced uni-directional mode\n"); 368 369 ret = tb_switch_tmu_rate_read(sw); 370 if (ret < 0) 371 return ret; 372 rate = ret; 373 374 /* Off by default */ 375 sw->tmu.mode = TB_SWITCH_TMU_MODE_OFF; 376 377 if (tb_route(sw)) { 378 struct tb_port *up = tb_upstream_port(sw); 379 380 if (enhanced && tb_port_tmu_is_enhanced(up)) { 381 sw->tmu.mode = TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI; 382 } else if (ucap && tb_port_tmu_is_unidirectional(up)) { 383 if (tmu_rates[TB_SWITCH_TMU_MODE_LOWRES] == rate) 384 sw->tmu.mode = TB_SWITCH_TMU_MODE_LOWRES; 385 else if (tmu_rates[TB_SWITCH_TMU_MODE_HIFI_UNI] == rate) 386 sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_UNI; 387 } else if (rate) { 388 sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_BI; 389 } 390 } else if (rate) { 391 sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_BI; 392 } 393 394 /* Update the initial request to match the current mode */ 395 sw->tmu.mode_request = sw->tmu.mode; 396 sw->tmu.has_ucap = ucap; 397 398 return 0; 399 } 400 401 /** 402 * tb_switch_tmu_init() - Initialize switch TMU structures 403 * @sw: Switch to initialized 404 * 405 * This function must be called before other TMU related functions to 406 * makes the internal structures are filled in correctly. Does not 407 * change any hardware configuration. 408 */ 409 int tb_switch_tmu_init(struct tb_switch *sw) 410 { 411 struct tb_port *port; 412 int ret; 413 414 if (tb_switch_is_icm(sw)) 415 return 0; 416 417 ret = tb_switch_find_cap(sw, TB_SWITCH_CAP_TMU); 418 if (ret > 0) 419 sw->tmu.cap = ret; 420 421 tb_switch_for_each_port(sw, port) { 422 int cap; 423 424 cap = tb_port_find_cap(port, TB_PORT_CAP_TIME1); 425 if (cap > 0) 426 port->cap_tmu = cap; 427 } 428 429 ret = tmu_mode_init(sw); 430 if (ret) 431 return ret; 432 433 tb_sw_dbg(sw, "TMU: current mode: %s\n", tmu_mode_name(sw->tmu.mode)); 434 return 0; 435 } 436 437 /** 438 * tb_switch_tmu_post_time() - Update switch local time 439 * @sw: Switch whose time to update 440 * 441 * Updates switch local time using time posting procedure. 442 */ 443 int tb_switch_tmu_post_time(struct tb_switch *sw) 444 { 445 unsigned int post_time_high_offset, post_time_high = 0; 446 unsigned int post_local_time_offset, post_time_offset; 447 struct tb_switch *root_switch = sw->tb->root_switch; 448 u64 hi, mid, lo, local_time, post_time; 449 int i, ret, retries = 100; 450 u32 gm_local_time[3]; 451 452 if (!tb_route(sw)) 453 return 0; 454 455 if (!tb_switch_is_usb4(sw)) 456 return 0; 457 458 /* Need to be able to read the grand master time */ 459 if (!root_switch->tmu.cap) 460 return 0; 461 462 ret = tb_sw_read(root_switch, gm_local_time, TB_CFG_SWITCH, 463 root_switch->tmu.cap + TMU_RTR_CS_1, 464 ARRAY_SIZE(gm_local_time)); 465 if (ret) 466 return ret; 467 468 for (i = 0; i < ARRAY_SIZE(gm_local_time); i++) 469 tb_sw_dbg(root_switch, "TMU: local_time[%d]=0x%08x\n", i, 470 gm_local_time[i]); 471 472 /* Convert to nanoseconds (drop fractional part) */ 473 hi = gm_local_time[2] & TMU_RTR_CS_3_LOCAL_TIME_NS_MASK; 474 mid = gm_local_time[1]; 475 lo = (gm_local_time[0] & TMU_RTR_CS_1_LOCAL_TIME_NS_MASK) >> 476 TMU_RTR_CS_1_LOCAL_TIME_NS_SHIFT; 477 local_time = hi << 48 | mid << 16 | lo; 478 479 /* Tell the switch that time sync is disrupted for a while */ 480 ret = tb_switch_tmu_set_time_disruption(sw, true); 481 if (ret) 482 return ret; 483 484 post_local_time_offset = sw->tmu.cap + TMU_RTR_CS_22; 485 post_time_offset = sw->tmu.cap + TMU_RTR_CS_24; 486 post_time_high_offset = sw->tmu.cap + TMU_RTR_CS_25; 487 488 /* 489 * Write the Grandmaster time to the Post Local Time registers 490 * of the new switch. 491 */ 492 ret = tb_sw_write(sw, &local_time, TB_CFG_SWITCH, 493 post_local_time_offset, 2); 494 if (ret) 495 goto out; 496 497 /* 498 * Have the new switch update its local time by: 499 * 1) writing 0x1 to the Post Time Low register and 0xffffffff to 500 * Post Time High register. 501 * 2) write 0 to Post Time High register and then wait for 502 * the completion of the post_time register becomes 0. 503 * This means the time has been converged properly. 504 */ 505 post_time = 0xffffffff00000001ULL; 506 507 ret = tb_sw_write(sw, &post_time, TB_CFG_SWITCH, post_time_offset, 2); 508 if (ret) 509 goto out; 510 511 ret = tb_sw_write(sw, &post_time_high, TB_CFG_SWITCH, 512 post_time_high_offset, 1); 513 if (ret) 514 goto out; 515 516 do { 517 usleep_range(5, 10); 518 ret = tb_sw_read(sw, &post_time, TB_CFG_SWITCH, 519 post_time_offset, 2); 520 if (ret) 521 goto out; 522 } while (--retries && post_time); 523 524 if (!retries) { 525 ret = -ETIMEDOUT; 526 goto out; 527 } 528 529 tb_sw_dbg(sw, "TMU: updated local time to %#llx\n", local_time); 530 531 out: 532 tb_switch_tmu_set_time_disruption(sw, false); 533 return ret; 534 } 535 536 static int disable_enhanced(struct tb_port *up, struct tb_port *down) 537 { 538 int ret; 539 540 /* 541 * Router may already been disconnected so ignore errors on the 542 * upstream port. 543 */ 544 tb_port_tmu_rate_write(up, 0); 545 tb_port_tmu_enhanced_enable(up, false); 546 547 ret = tb_port_tmu_rate_write(down, 0); 548 if (ret) 549 return ret; 550 return tb_port_tmu_enhanced_enable(down, false); 551 } 552 553 /** 554 * tb_switch_tmu_disable() - Disable TMU of a switch 555 * @sw: Switch whose TMU to disable 556 * 557 * Turns off TMU of @sw if it is enabled. If not enabled does nothing. 558 */ 559 int tb_switch_tmu_disable(struct tb_switch *sw) 560 { 561 /* Already disabled? */ 562 if (sw->tmu.mode == TB_SWITCH_TMU_MODE_OFF) 563 return 0; 564 565 if (tb_route(sw)) { 566 struct tb_port *down, *up; 567 int ret; 568 569 down = tb_switch_downstream_port(sw); 570 up = tb_upstream_port(sw); 571 /* 572 * In case of uni-directional time sync, TMU handshake is 573 * initiated by upstream router. In case of bi-directional 574 * time sync, TMU handshake is initiated by downstream router. 575 * We change downstream router's rate to off for both uni/bidir 576 * cases although it is needed only for the bi-directional mode. 577 * We avoid changing upstream router's mode since it might 578 * have another downstream router plugged, that is set to 579 * uni-directional mode and we don't want to change it's TMU 580 * mode. 581 */ 582 ret = tb_switch_tmu_rate_write(sw, tmu_rates[TB_SWITCH_TMU_MODE_OFF]); 583 if (ret) 584 return ret; 585 586 tb_port_tmu_time_sync_disable(up); 587 ret = tb_port_tmu_time_sync_disable(down); 588 if (ret) 589 return ret; 590 591 switch (sw->tmu.mode) { 592 case TB_SWITCH_TMU_MODE_LOWRES: 593 case TB_SWITCH_TMU_MODE_HIFI_UNI: 594 /* The switch may be unplugged so ignore any errors */ 595 tb_port_tmu_unidirectional_disable(up); 596 ret = tb_port_tmu_unidirectional_disable(down); 597 if (ret) 598 return ret; 599 break; 600 601 case TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI: 602 ret = disable_enhanced(up, down); 603 if (ret) 604 return ret; 605 break; 606 607 default: 608 break; 609 } 610 } else { 611 tb_switch_tmu_rate_write(sw, tmu_rates[TB_SWITCH_TMU_MODE_OFF]); 612 } 613 614 sw->tmu.mode = TB_SWITCH_TMU_MODE_OFF; 615 616 tb_sw_dbg(sw, "TMU: disabled\n"); 617 return 0; 618 } 619 620 /* Called only when there is failure enabling requested mode */ 621 static void tb_switch_tmu_off(struct tb_switch *sw) 622 { 623 unsigned int rate = tmu_rates[TB_SWITCH_TMU_MODE_OFF]; 624 struct tb_port *down, *up; 625 626 down = tb_switch_downstream_port(sw); 627 up = tb_upstream_port(sw); 628 /* 629 * In case of any failure in one of the steps when setting 630 * bi-directional or uni-directional TMU mode, get back to the TMU 631 * configurations in off mode. In case of additional failures in 632 * the functions below, ignore them since the caller shall already 633 * report a failure. 634 */ 635 tb_port_tmu_time_sync_disable(down); 636 tb_port_tmu_time_sync_disable(up); 637 638 switch (sw->tmu.mode_request) { 639 case TB_SWITCH_TMU_MODE_LOWRES: 640 case TB_SWITCH_TMU_MODE_HIFI_UNI: 641 tb_switch_tmu_rate_write(tb_switch_parent(sw), rate); 642 break; 643 case TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI: 644 disable_enhanced(up, down); 645 break; 646 default: 647 break; 648 } 649 650 /* Always set the rate to 0 */ 651 tb_switch_tmu_rate_write(sw, rate); 652 653 tb_switch_set_tmu_mode_params(sw, sw->tmu.mode); 654 tb_port_tmu_unidirectional_disable(down); 655 tb_port_tmu_unidirectional_disable(up); 656 } 657 658 /* 659 * This function is called when the previous TMU mode was 660 * TB_SWITCH_TMU_MODE_OFF. 661 */ 662 static int tb_switch_tmu_enable_bidirectional(struct tb_switch *sw) 663 { 664 struct tb_port *up, *down; 665 int ret; 666 667 up = tb_upstream_port(sw); 668 down = tb_switch_downstream_port(sw); 669 670 ret = tb_port_tmu_unidirectional_disable(up); 671 if (ret) 672 return ret; 673 674 ret = tb_port_tmu_unidirectional_disable(down); 675 if (ret) 676 goto out; 677 678 ret = tb_switch_tmu_rate_write(sw, tmu_rates[TB_SWITCH_TMU_MODE_HIFI_BI]); 679 if (ret) 680 goto out; 681 682 ret = tb_port_tmu_time_sync_enable(up); 683 if (ret) 684 goto out; 685 686 ret = tb_port_tmu_time_sync_enable(down); 687 if (ret) 688 goto out; 689 690 return 0; 691 692 out: 693 tb_switch_tmu_off(sw); 694 return ret; 695 } 696 697 /* Only needed for Titan Ridge */ 698 static int tb_switch_tmu_disable_objections(struct tb_switch *sw) 699 { 700 struct tb_port *up = tb_upstream_port(sw); 701 u32 val; 702 int ret; 703 704 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, 705 sw->cap_vsec_tmu + TB_TIME_VSEC_3_CS_9, 1); 706 if (ret) 707 return ret; 708 709 val &= ~TB_TIME_VSEC_3_CS_9_TMU_OBJ_MASK; 710 711 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, 712 sw->cap_vsec_tmu + TB_TIME_VSEC_3_CS_9, 1); 713 if (ret) 714 return ret; 715 716 return tb_port_tmu_write(up, TMU_ADP_CS_6, 717 TMU_ADP_CS_6_DISABLE_TMU_OBJ_MASK, 718 TMU_ADP_CS_6_DISABLE_TMU_OBJ_CL1 | 719 TMU_ADP_CS_6_DISABLE_TMU_OBJ_CL2); 720 } 721 722 /* 723 * This function is called when the previous TMU mode was 724 * TB_SWITCH_TMU_MODE_OFF. 725 */ 726 static int tb_switch_tmu_enable_unidirectional(struct tb_switch *sw) 727 { 728 struct tb_port *up, *down; 729 int ret; 730 731 up = tb_upstream_port(sw); 732 down = tb_switch_downstream_port(sw); 733 ret = tb_switch_tmu_rate_write(tb_switch_parent(sw), 734 tmu_rates[sw->tmu.mode_request]); 735 if (ret) 736 return ret; 737 738 ret = tb_switch_set_tmu_mode_params(sw, sw->tmu.mode_request); 739 if (ret) 740 return ret; 741 742 ret = tb_port_tmu_unidirectional_enable(up); 743 if (ret) 744 goto out; 745 746 ret = tb_port_tmu_time_sync_enable(up); 747 if (ret) 748 goto out; 749 750 ret = tb_port_tmu_unidirectional_enable(down); 751 if (ret) 752 goto out; 753 754 ret = tb_port_tmu_time_sync_enable(down); 755 if (ret) 756 goto out; 757 758 return 0; 759 760 out: 761 tb_switch_tmu_off(sw); 762 return ret; 763 } 764 765 /* 766 * This function is called when the previous TMU mode was 767 * TB_SWITCH_TMU_RATE_OFF. 768 */ 769 static int tb_switch_tmu_enable_enhanced(struct tb_switch *sw) 770 { 771 unsigned int rate = tmu_rates[sw->tmu.mode_request]; 772 struct tb_port *up, *down; 773 int ret; 774 775 /* Router specific parameters first */ 776 ret = tb_switch_set_tmu_mode_params(sw, sw->tmu.mode_request); 777 if (ret) 778 return ret; 779 780 up = tb_upstream_port(sw); 781 down = tb_switch_downstream_port(sw); 782 783 ret = tb_port_set_tmu_mode_params(up, sw->tmu.mode_request); 784 if (ret) 785 goto out; 786 787 ret = tb_port_tmu_rate_write(up, rate); 788 if (ret) 789 goto out; 790 791 ret = tb_port_tmu_enhanced_enable(up, true); 792 if (ret) 793 goto out; 794 795 ret = tb_port_set_tmu_mode_params(down, sw->tmu.mode_request); 796 if (ret) 797 goto out; 798 799 ret = tb_port_tmu_rate_write(down, rate); 800 if (ret) 801 goto out; 802 803 ret = tb_port_tmu_enhanced_enable(down, true); 804 if (ret) 805 goto out; 806 807 return 0; 808 809 out: 810 tb_switch_tmu_off(sw); 811 return ret; 812 } 813 814 static void tb_switch_tmu_change_mode_prev(struct tb_switch *sw) 815 { 816 unsigned int rate = tmu_rates[sw->tmu.mode]; 817 struct tb_port *down, *up; 818 819 down = tb_switch_downstream_port(sw); 820 up = tb_upstream_port(sw); 821 /* 822 * In case of any failure in one of the steps when change mode, 823 * get back to the TMU configurations in previous mode. 824 * In case of additional failures in the functions below, 825 * ignore them since the caller shall already report a failure. 826 */ 827 switch (sw->tmu.mode) { 828 case TB_SWITCH_TMU_MODE_LOWRES: 829 case TB_SWITCH_TMU_MODE_HIFI_UNI: 830 tb_port_tmu_set_unidirectional(down, true); 831 tb_switch_tmu_rate_write(tb_switch_parent(sw), rate); 832 break; 833 834 case TB_SWITCH_TMU_MODE_HIFI_BI: 835 tb_port_tmu_set_unidirectional(down, false); 836 tb_switch_tmu_rate_write(sw, rate); 837 break; 838 839 default: 840 break; 841 } 842 843 tb_switch_set_tmu_mode_params(sw, sw->tmu.mode); 844 845 switch (sw->tmu.mode) { 846 case TB_SWITCH_TMU_MODE_LOWRES: 847 case TB_SWITCH_TMU_MODE_HIFI_UNI: 848 tb_port_tmu_set_unidirectional(up, true); 849 break; 850 851 case TB_SWITCH_TMU_MODE_HIFI_BI: 852 tb_port_tmu_set_unidirectional(up, false); 853 break; 854 855 default: 856 break; 857 } 858 } 859 860 static int tb_switch_tmu_change_mode(struct tb_switch *sw) 861 { 862 unsigned int rate = tmu_rates[sw->tmu.mode_request]; 863 struct tb_port *up, *down; 864 int ret; 865 866 up = tb_upstream_port(sw); 867 down = tb_switch_downstream_port(sw); 868 869 /* Program the upstream router downstream facing lane adapter */ 870 switch (sw->tmu.mode_request) { 871 case TB_SWITCH_TMU_MODE_LOWRES: 872 case TB_SWITCH_TMU_MODE_HIFI_UNI: 873 ret = tb_port_tmu_set_unidirectional(down, true); 874 if (ret) 875 goto out; 876 ret = tb_switch_tmu_rate_write(tb_switch_parent(sw), rate); 877 if (ret) 878 goto out; 879 break; 880 881 case TB_SWITCH_TMU_MODE_HIFI_BI: 882 ret = tb_port_tmu_set_unidirectional(down, false); 883 if (ret) 884 goto out; 885 ret = tb_switch_tmu_rate_write(sw, rate); 886 if (ret) 887 goto out; 888 break; 889 890 default: 891 /* Not allowed to change modes from other than above */ 892 return -EINVAL; 893 } 894 895 ret = tb_switch_set_tmu_mode_params(sw, sw->tmu.mode_request); 896 if (ret) 897 goto out; 898 899 /* Program the new mode and the downstream router lane adapter */ 900 switch (sw->tmu.mode_request) { 901 case TB_SWITCH_TMU_MODE_LOWRES: 902 case TB_SWITCH_TMU_MODE_HIFI_UNI: 903 ret = tb_port_tmu_set_unidirectional(up, true); 904 if (ret) 905 goto out; 906 break; 907 908 case TB_SWITCH_TMU_MODE_HIFI_BI: 909 ret = tb_port_tmu_set_unidirectional(up, false); 910 if (ret) 911 goto out; 912 break; 913 914 default: 915 /* Not allowed to change modes from other than above */ 916 return -EINVAL; 917 } 918 919 ret = tb_port_tmu_time_sync_enable(down); 920 if (ret) 921 goto out; 922 923 ret = tb_port_tmu_time_sync_enable(up); 924 if (ret) 925 goto out; 926 927 return 0; 928 929 out: 930 tb_switch_tmu_change_mode_prev(sw); 931 return ret; 932 } 933 934 /** 935 * tb_switch_tmu_enable() - Enable TMU on a router 936 * @sw: Router whose TMU to enable 937 * 938 * Enables TMU of a router to be in uni-directional Normal/HiFi or 939 * bi-directional HiFi mode. Calling tb_switch_tmu_configure() is 940 * required before calling this function. 941 */ 942 int tb_switch_tmu_enable(struct tb_switch *sw) 943 { 944 int ret; 945 946 if (tb_switch_tmu_is_enabled(sw)) 947 return 0; 948 949 if (tb_switch_is_titan_ridge(sw) && 950 (sw->tmu.mode_request == TB_SWITCH_TMU_MODE_LOWRES || 951 sw->tmu.mode_request == TB_SWITCH_TMU_MODE_HIFI_UNI)) { 952 ret = tb_switch_tmu_disable_objections(sw); 953 if (ret) 954 return ret; 955 } 956 957 ret = tb_switch_tmu_set_time_disruption(sw, true); 958 if (ret) 959 return ret; 960 961 if (tb_route(sw)) { 962 /* 963 * The used mode changes are from OFF to 964 * HiFi-Uni/HiFi-BiDir/Normal-Uni or from Normal-Uni to 965 * HiFi-Uni. 966 */ 967 if (sw->tmu.mode == TB_SWITCH_TMU_MODE_OFF) { 968 switch (sw->tmu.mode_request) { 969 case TB_SWITCH_TMU_MODE_LOWRES: 970 case TB_SWITCH_TMU_MODE_HIFI_UNI: 971 ret = tb_switch_tmu_enable_unidirectional(sw); 972 break; 973 974 case TB_SWITCH_TMU_MODE_HIFI_BI: 975 ret = tb_switch_tmu_enable_bidirectional(sw); 976 break; 977 case TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI: 978 ret = tb_switch_tmu_enable_enhanced(sw); 979 break; 980 default: 981 ret = -EINVAL; 982 break; 983 } 984 } else if (sw->tmu.mode == TB_SWITCH_TMU_MODE_LOWRES || 985 sw->tmu.mode == TB_SWITCH_TMU_MODE_HIFI_UNI || 986 sw->tmu.mode == TB_SWITCH_TMU_MODE_HIFI_BI) { 987 ret = tb_switch_tmu_change_mode(sw); 988 } else { 989 ret = -EINVAL; 990 } 991 } else { 992 /* 993 * Host router port configurations are written as 994 * part of configurations for downstream port of the parent 995 * of the child node - see above. 996 * Here only the host router' rate configuration is written. 997 */ 998 ret = tb_switch_tmu_rate_write(sw, tmu_rates[sw->tmu.mode_request]); 999 } 1000 1001 if (ret) { 1002 tb_sw_warn(sw, "TMU: failed to enable mode %s: %d\n", 1003 tmu_mode_name(sw->tmu.mode_request), ret); 1004 } else { 1005 sw->tmu.mode = sw->tmu.mode_request; 1006 tb_sw_dbg(sw, "TMU: mode set to: %s\n", tmu_mode_name(sw->tmu.mode)); 1007 } 1008 1009 return tb_switch_tmu_set_time_disruption(sw, false); 1010 } 1011 1012 /** 1013 * tb_switch_tmu_configure() - Configure the TMU mode 1014 * @sw: Router whose mode to change 1015 * @mode: Mode to configure 1016 * 1017 * Selects the TMU mode that is enabled when tb_switch_tmu_enable() is 1018 * next called. 1019 * 1020 * Returns %0 in success and negative errno otherwise. Specifically 1021 * returns %-EOPNOTSUPP if the requested mode is not possible (not 1022 * supported by the router and/or topology). 1023 */ 1024 int tb_switch_tmu_configure(struct tb_switch *sw, enum tb_switch_tmu_mode mode) 1025 { 1026 switch (mode) { 1027 case TB_SWITCH_TMU_MODE_OFF: 1028 break; 1029 1030 case TB_SWITCH_TMU_MODE_LOWRES: 1031 case TB_SWITCH_TMU_MODE_HIFI_UNI: 1032 if (!sw->tmu.has_ucap) 1033 return -EOPNOTSUPP; 1034 break; 1035 1036 case TB_SWITCH_TMU_MODE_HIFI_BI: 1037 break; 1038 1039 case TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI: { 1040 const struct tb_switch *parent_sw = tb_switch_parent(sw); 1041 1042 if (!parent_sw || !tb_switch_tmu_enhanced_is_supported(parent_sw)) 1043 return -EOPNOTSUPP; 1044 if (!tb_switch_tmu_enhanced_is_supported(sw)) 1045 return -EOPNOTSUPP; 1046 1047 break; 1048 } 1049 1050 default: 1051 tb_sw_warn(sw, "TMU: unsupported mode %u\n", mode); 1052 return -EINVAL; 1053 } 1054 1055 if (sw->tmu.mode_request != mode) { 1056 tb_sw_dbg(sw, "TMU: mode change %s -> %s requested\n", 1057 tmu_mode_name(sw->tmu.mode), tmu_mode_name(mode)); 1058 sw->tmu.mode_request = mode; 1059 } 1060 1061 return 0; 1062 } 1063