projects/linux·blob master · refs

1072 lines · 25.1 KiB

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 <[email protected]>
7 * Rajmohan Mani <[email protected]>
8 */
9
10#include <linux/delay.h>
11
12#include "tb.h"
13
14static 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
22static 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
40static 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
58static bool tb_switch_tmu_enhanced_is_supported(const struct tb_switch *sw)
59{
60 return usb4_switch_version(sw) > 1;
61}
62
63static 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
122static 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
135static 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
149static 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
166static 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
183static 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
195static inline int tb_port_tmu_unidirectional_disable(struct tb_port *port)
196{
197 return tb_port_tmu_set_unidirectional(port, false);
198}
199
200static inline int tb_port_tmu_unidirectional_enable(struct tb_port *port)
201{
202 return tb_port_tmu_set_unidirectional(port, true);
203}
204
205static 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
218static 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 */
232static 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
254static 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 */
295static 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
315static 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
322static int tb_port_tmu_time_sync_disable(struct tb_port *port)
323{
324 return tb_port_tmu_time_sync(port, true);
325}
326
327static int tb_port_tmu_time_sync_enable(struct tb_port *port)
328{
329 return tb_port_tmu_time_sync(port, false);
330}
331
332static 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
357static 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 be initialized
404 *
405 * This function must be called before other TMU related functions to
406 * make sure the internal structures are filled in correctly. Does not
407 * change any hardware configuration.
408 *
409 * Return: %0 on success, negative errno otherwise.
410 */
411int tb_switch_tmu_init(struct tb_switch *sw)
412{
413 struct tb_port *port;
414 int ret;
415
416 if (tb_switch_is_icm(sw))
417 return 0;
418
419 ret = tb_switch_find_cap(sw, TB_SWITCH_CAP_TMU);
420 if (ret > 0)
421 sw->tmu.cap = ret;
422
423 tb_switch_for_each_port(sw, port) {
424 int cap;
425
426 cap = tb_port_find_cap(port, TB_PORT_CAP_TIME1);
427 if (cap > 0)
428 port->cap_tmu = cap;
429 }
430
431 ret = tmu_mode_init(sw);
432 if (ret)
433 return ret;
434
435 tb_sw_dbg(sw, "TMU: current mode: %s\n", tmu_mode_name(sw->tmu.mode));
436 return 0;
437}
438
439/**
440 * tb_switch_tmu_post_time() - Update switch local time
441 * @sw: Switch whose time to update
442 *
443 * Updates switch local time using time posting procedure.
444 *
445 * Return: %0 on success, negative errno otherwise.
446 */
447int tb_switch_tmu_post_time(struct tb_switch *sw)
448{
449 unsigned int post_time_high_offset, post_time_high = 0;
450 unsigned int post_local_time_offset, post_time_offset;
451 struct tb_switch *root_switch = sw->tb->root_switch;
452 u64 hi, mid, lo, local_time, post_time;
453 int i, ret, retries = 100;
454 u32 gm_local_time[3];
455
456 if (!tb_route(sw))
457 return 0;
458
459 if (!tb_switch_is_usb4(sw))
460 return 0;
461
462 /* Need to be able to read the grand master time */
463 if (!root_switch->tmu.cap)
464 return 0;
465
466 ret = tb_sw_read(root_switch, gm_local_time, TB_CFG_SWITCH,
467 root_switch->tmu.cap + TMU_RTR_CS_1,
468 ARRAY_SIZE(gm_local_time));
469 if (ret)
470 return ret;
471
472 for (i = 0; i < ARRAY_SIZE(gm_local_time); i++)
473 tb_sw_dbg(root_switch, "TMU: local_time[%d]=0x%08x\n", i,
474 gm_local_time[i]);
475
476 /* Convert to nanoseconds (drop fractional part) */
477 hi = gm_local_time[2] & TMU_RTR_CS_3_LOCAL_TIME_NS_MASK;
478 mid = gm_local_time[1];
479 lo = (gm_local_time[0] & TMU_RTR_CS_1_LOCAL_TIME_NS_MASK) >>
480 TMU_RTR_CS_1_LOCAL_TIME_NS_SHIFT;
481 local_time = hi << 48 | mid << 16 | lo;
482
483 /* Tell the switch that time sync is disrupted for a while */
484 ret = tb_switch_tmu_set_time_disruption(sw, true);
485 if (ret)
486 return ret;
487
488 post_local_time_offset = sw->tmu.cap + TMU_RTR_CS_22;
489 post_time_offset = sw->tmu.cap + TMU_RTR_CS_24;
490 post_time_high_offset = sw->tmu.cap + TMU_RTR_CS_25;
491
492 /*
493 * Write the Grandmaster time to the Post Local Time registers
494 * of the new switch.
495 */
496 ret = tb_sw_write(sw, &local_time, TB_CFG_SWITCH,
497 post_local_time_offset, 2);
498 if (ret)
499 goto out;
500
501 /*
502 * Have the new switch update its local time by:
503 * 1) writing 0x1 to the Post Time Low register and 0xffffffff to
504 * Post Time High register.
505 * 2) write 0 to Post Time High register and then wait for
506 * the completion of the post_time register becomes 0.
507 * This means the time has been converged properly.
508 */
509 post_time = 0xffffffff00000001ULL;
510
511 ret = tb_sw_write(sw, &post_time, TB_CFG_SWITCH, post_time_offset, 2);
512 if (ret)
513 goto out;
514
515 ret = tb_sw_write(sw, &post_time_high, TB_CFG_SWITCH,
516 post_time_high_offset, 1);
517 if (ret)
518 goto out;
519
520 do {
521 usleep_range(5, 10);
522 ret = tb_sw_read(sw, &post_time, TB_CFG_SWITCH,
523 post_time_offset, 2);
524 if (ret)
525 goto out;
526 } while (--retries && post_time);
527
528 if (!retries) {
529 ret = -ETIMEDOUT;
530 goto out;
531 }
532
533 tb_sw_dbg(sw, "TMU: updated local time to %#llx\n", local_time);
534
535out:
536 tb_switch_tmu_set_time_disruption(sw, false);
537 return ret;
538}
539
540static int disable_enhanced(struct tb_port *up, struct tb_port *down)
541{
542 int ret;
543
544 /*
545 * Router may already been disconnected so ignore errors on the
546 * upstream port.
547 */
548 tb_port_tmu_rate_write(up, 0);
549 tb_port_tmu_enhanced_enable(up, false);
550
551 ret = tb_port_tmu_rate_write(down, 0);
552 if (ret)
553 return ret;
554 return tb_port_tmu_enhanced_enable(down, false);
555}
556
557/**
558 * tb_switch_tmu_disable() - Disable TMU of a switch
559 * @sw: Switch whose TMU to disable
560 *
561 * Turns off TMU of @sw if it is enabled. If not enabled does nothing.
562 *
563 * Return: %0 on success, negative errno otherwise.
564 */
565int tb_switch_tmu_disable(struct tb_switch *sw)
566{
567 /* Already disabled? */
568 if (sw->tmu.mode == TB_SWITCH_TMU_MODE_OFF)
569 return 0;
570
571 if (tb_route(sw)) {
572 struct tb_port *down, *up;
573 int ret;
574
575 down = tb_switch_downstream_port(sw);
576 up = tb_upstream_port(sw);
577 /*
578 * In case of uni-directional time sync, TMU handshake is
579 * initiated by upstream router. In case of bi-directional
580 * time sync, TMU handshake is initiated by downstream router.
581 * We change downstream router's rate to off for both uni/bidir
582 * cases although it is needed only for the bi-directional mode.
583 * We avoid changing upstream router's mode since it might
584 * have another downstream router plugged, that is set to
585 * uni-directional mode and we don't want to change it's TMU
586 * mode.
587 */
588 ret = tb_switch_tmu_rate_write(sw, tmu_rates[TB_SWITCH_TMU_MODE_OFF]);
589 if (ret)
590 return ret;
591
592 tb_port_tmu_time_sync_disable(up);
593 ret = tb_port_tmu_time_sync_disable(down);
594 if (ret)
595 return ret;
596
597 switch (sw->tmu.mode) {
598 case TB_SWITCH_TMU_MODE_LOWRES:
599 case TB_SWITCH_TMU_MODE_HIFI_UNI:
600 /* The switch may be unplugged so ignore any errors */
601 tb_port_tmu_unidirectional_disable(up);
602 ret = tb_port_tmu_unidirectional_disable(down);
603 if (ret)
604 return ret;
605 break;
606
607 case TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI:
608 ret = disable_enhanced(up, down);
609 if (ret)
610 return ret;
611 break;
612
613 default:
614 break;
615 }
616 } else {
617 tb_switch_tmu_rate_write(sw, tmu_rates[TB_SWITCH_TMU_MODE_OFF]);
618 }
619
620 sw->tmu.mode = TB_SWITCH_TMU_MODE_OFF;
621
622 tb_sw_dbg(sw, "TMU: disabled\n");
623 return 0;
624}
625
626/* Called only when there is failure enabling requested mode */
627static void tb_switch_tmu_off(struct tb_switch *sw)
628{
629 unsigned int rate = tmu_rates[TB_SWITCH_TMU_MODE_OFF];
630 struct tb_port *down, *up;
631
632 down = tb_switch_downstream_port(sw);
633 up = tb_upstream_port(sw);
634 /*
635 * In case of any failure in one of the steps when setting
636 * bi-directional or uni-directional TMU mode, get back to the TMU
637 * configurations in off mode. In case of additional failures in
638 * the functions below, ignore them since the caller shall already
639 * report a failure.
640 */
641 tb_port_tmu_time_sync_disable(down);
642 tb_port_tmu_time_sync_disable(up);
643
644 switch (sw->tmu.mode_request) {
645 case TB_SWITCH_TMU_MODE_LOWRES:
646 case TB_SWITCH_TMU_MODE_HIFI_UNI:
647 tb_switch_tmu_rate_write(tb_switch_parent(sw), rate);
648 break;
649 case TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI:
650 disable_enhanced(up, down);
651 break;
652 default:
653 break;
654 }
655
656 /* Always set the rate to 0 */
657 tb_switch_tmu_rate_write(sw, rate);
658
659 tb_switch_set_tmu_mode_params(sw, sw->tmu.mode);
660 tb_port_tmu_unidirectional_disable(down);
661 tb_port_tmu_unidirectional_disable(up);
662}
663
664/*
665 * This function is called when the previous TMU mode was
666 * TB_SWITCH_TMU_MODE_OFF.
667 */
668static int tb_switch_tmu_enable_bidirectional(struct tb_switch *sw)
669{
670 struct tb_port *up, *down;
671 int ret;
672
673 up = tb_upstream_port(sw);
674 down = tb_switch_downstream_port(sw);
675
676 ret = tb_port_tmu_unidirectional_disable(up);
677 if (ret)
678 return ret;
679
680 ret = tb_port_tmu_unidirectional_disable(down);
681 if (ret)
682 goto out;
683
684 ret = tb_switch_tmu_rate_write(sw, tmu_rates[TB_SWITCH_TMU_MODE_HIFI_BI]);
685 if (ret)
686 goto out;
687
688 ret = tb_port_tmu_time_sync_enable(up);
689 if (ret)
690 goto out;
691
692 ret = tb_port_tmu_time_sync_enable(down);
693 if (ret)
694 goto out;
695
696 return 0;
697
698out:
699 tb_switch_tmu_off(sw);
700 return ret;
701}
702
703/* Only needed for Titan Ridge */
704static int tb_switch_tmu_disable_objections(struct tb_switch *sw)
705{
706 struct tb_port *up = tb_upstream_port(sw);
707 u32 val;
708 int ret;
709
710 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
711 sw->cap_vsec_tmu + TB_TIME_VSEC_3_CS_9, 1);
712 if (ret)
713 return ret;
714
715 val &= ~TB_TIME_VSEC_3_CS_9_TMU_OBJ_MASK;
716
717 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
718 sw->cap_vsec_tmu + TB_TIME_VSEC_3_CS_9, 1);
719 if (ret)
720 return ret;
721
722 return tb_port_tmu_write(up, TMU_ADP_CS_6,
723 TMU_ADP_CS_6_DISABLE_TMU_OBJ_MASK,
724 TMU_ADP_CS_6_DISABLE_TMU_OBJ_CL1 |
725 TMU_ADP_CS_6_DISABLE_TMU_OBJ_CL2);
726}
727
728/*
729 * This function is called when the previous TMU mode was
730 * TB_SWITCH_TMU_MODE_OFF.
731 */
732static int tb_switch_tmu_enable_unidirectional(struct tb_switch *sw)
733{
734 struct tb_port *up, *down;
735 int ret;
736
737 up = tb_upstream_port(sw);
738 down = tb_switch_downstream_port(sw);
739 ret = tb_switch_tmu_rate_write(tb_switch_parent(sw),
740 tmu_rates[sw->tmu.mode_request]);
741 if (ret)
742 return ret;
743
744 ret = tb_switch_set_tmu_mode_params(sw, sw->tmu.mode_request);
745 if (ret)
746 return ret;
747
748 ret = tb_port_tmu_unidirectional_enable(up);
749 if (ret)
750 goto out;
751
752 ret = tb_port_tmu_time_sync_enable(up);
753 if (ret)
754 goto out;
755
756 ret = tb_port_tmu_unidirectional_enable(down);
757 if (ret)
758 goto out;
759
760 ret = tb_port_tmu_time_sync_enable(down);
761 if (ret)
762 goto out;
763
764 return 0;
765
766out:
767 tb_switch_tmu_off(sw);
768 return ret;
769}
770
771/*
772 * This function is called when the previous TMU mode was
773 * TB_SWITCH_TMU_RATE_OFF.
774 */
775static int tb_switch_tmu_enable_enhanced(struct tb_switch *sw)
776{
777 unsigned int rate = tmu_rates[sw->tmu.mode_request];
778 struct tb_port *up, *down;
779 int ret;
780
781 /* Router specific parameters first */
782 ret = tb_switch_set_tmu_mode_params(sw, sw->tmu.mode_request);
783 if (ret)
784 return ret;
785
786 up = tb_upstream_port(sw);
787 down = tb_switch_downstream_port(sw);
788
789 ret = tb_port_set_tmu_mode_params(up, sw->tmu.mode_request);
790 if (ret)
791 goto out;
792
793 ret = tb_port_tmu_rate_write(up, rate);
794 if (ret)
795 goto out;
796
797 ret = tb_port_tmu_enhanced_enable(up, true);
798 if (ret)
799 goto out;
800
801 ret = tb_port_set_tmu_mode_params(down, sw->tmu.mode_request);
802 if (ret)
803 goto out;
804
805 ret = tb_port_tmu_rate_write(down, rate);
806 if (ret)
807 goto out;
808
809 ret = tb_port_tmu_enhanced_enable(down, true);
810 if (ret)
811 goto out;
812
813 return 0;
814
815out:
816 tb_switch_tmu_off(sw);
817 return ret;
818}
819
820static void tb_switch_tmu_change_mode_prev(struct tb_switch *sw)
821{
822 unsigned int rate = tmu_rates[sw->tmu.mode];
823 struct tb_port *down, *up;
824
825 down = tb_switch_downstream_port(sw);
826 up = tb_upstream_port(sw);
827 /*
828 * In case of any failure in one of the steps when change mode,
829 * get back to the TMU configurations in previous mode.
830 * In case of additional failures in the functions below,
831 * ignore them since the caller shall already report a failure.
832 */
833 switch (sw->tmu.mode) {
834 case TB_SWITCH_TMU_MODE_LOWRES:
835 case TB_SWITCH_TMU_MODE_HIFI_UNI:
836 tb_port_tmu_set_unidirectional(down, true);
837 tb_switch_tmu_rate_write(tb_switch_parent(sw), rate);
838 break;
839
840 case TB_SWITCH_TMU_MODE_HIFI_BI:
841 tb_port_tmu_set_unidirectional(down, false);
842 tb_switch_tmu_rate_write(sw, rate);
843 break;
844
845 default:
846 break;
847 }
848
849 tb_switch_set_tmu_mode_params(sw, sw->tmu.mode);
850
851 switch (sw->tmu.mode) {
852 case TB_SWITCH_TMU_MODE_LOWRES:
853 case TB_SWITCH_TMU_MODE_HIFI_UNI:
854 tb_port_tmu_set_unidirectional(up, true);
855 break;
856
857 case TB_SWITCH_TMU_MODE_HIFI_BI:
858 tb_port_tmu_set_unidirectional(up, false);
859 break;
860
861 default:
862 break;
863 }
864}
865
866static int tb_switch_tmu_change_mode(struct tb_switch *sw)
867{
868 unsigned int rate = tmu_rates[sw->tmu.mode_request];
869 struct tb_port *up, *down;
870 int ret;
871
872 up = tb_upstream_port(sw);
873 down = tb_switch_downstream_port(sw);
874
875 /* Program the upstream router downstream facing lane adapter */
876 switch (sw->tmu.mode_request) {
877 case TB_SWITCH_TMU_MODE_LOWRES:
878 case TB_SWITCH_TMU_MODE_HIFI_UNI:
879 ret = tb_port_tmu_set_unidirectional(down, true);
880 if (ret)
881 goto out;
882 ret = tb_switch_tmu_rate_write(tb_switch_parent(sw), rate);
883 if (ret)
884 goto out;
885 break;
886
887 case TB_SWITCH_TMU_MODE_HIFI_BI:
888 ret = tb_port_tmu_set_unidirectional(down, false);
889 if (ret)
890 goto out;
891 ret = tb_switch_tmu_rate_write(sw, rate);
892 if (ret)
893 goto out;
894 break;
895
896 default:
897 /* Not allowed to change modes from other than above */
898 return -EINVAL;
899 }
900
901 ret = tb_switch_set_tmu_mode_params(sw, sw->tmu.mode_request);
902 if (ret)
903 goto out;
904
905 /* Program the new mode and the downstream router lane adapter */
906 switch (sw->tmu.mode_request) {
907 case TB_SWITCH_TMU_MODE_LOWRES:
908 case TB_SWITCH_TMU_MODE_HIFI_UNI:
909 ret = tb_port_tmu_set_unidirectional(up, true);
910 if (ret)
911 goto out;
912 break;
913
914 case TB_SWITCH_TMU_MODE_HIFI_BI:
915 ret = tb_port_tmu_set_unidirectional(up, false);
916 if (ret)
917 goto out;
918 break;
919
920 default:
921 /* Not allowed to change modes from other than above */
922 return -EINVAL;
923 }
924
925 ret = tb_port_tmu_time_sync_enable(down);
926 if (ret)
927 goto out;
928
929 ret = tb_port_tmu_time_sync_enable(up);
930 if (ret)
931 goto out;
932
933 return 0;
934
935out:
936 tb_switch_tmu_change_mode_prev(sw);
937 return ret;
938}
939
940/**
941 * tb_switch_tmu_enable() - Enable TMU on a router
942 * @sw: Router whose TMU to enable
943 *
944 * Enables TMU of a router to be in uni-directional Normal/HiFi or
945 * bi-directional HiFi mode. Calling tb_switch_tmu_configure() is
946 * required before calling this function.
947 *
948 * Return: %0 on success, negative errno otherwise.
949 */
950int tb_switch_tmu_enable(struct tb_switch *sw)
951{
952 int ret;
953
954 if (tb_switch_tmu_is_enabled(sw))
955 return 0;
956
957 if (tb_switch_is_titan_ridge(sw) &&
958 (sw->tmu.mode_request == TB_SWITCH_TMU_MODE_LOWRES ||
959 sw->tmu.mode_request == TB_SWITCH_TMU_MODE_HIFI_UNI)) {
960 ret = tb_switch_tmu_disable_objections(sw);
961 if (ret)
962 return ret;
963 }
964
965 ret = tb_switch_tmu_set_time_disruption(sw, true);
966 if (ret)
967 return ret;
968
969 if (tb_route(sw)) {
970 /*
971 * The used mode changes are from OFF to
972 * HiFi-Uni/HiFi-BiDir/Normal-Uni or from Normal-Uni to
973 * HiFi-Uni.
974 */
975 if (sw->tmu.mode == TB_SWITCH_TMU_MODE_OFF) {
976 switch (sw->tmu.mode_request) {
977 case TB_SWITCH_TMU_MODE_LOWRES:
978 case TB_SWITCH_TMU_MODE_HIFI_UNI:
979 ret = tb_switch_tmu_enable_unidirectional(sw);
980 break;
981
982 case TB_SWITCH_TMU_MODE_HIFI_BI:
983 ret = tb_switch_tmu_enable_bidirectional(sw);
984 break;
985 case TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI:
986 ret = tb_switch_tmu_enable_enhanced(sw);
987 break;
988 default:
989 ret = -EINVAL;
990 break;
991 }
992 } else if (sw->tmu.mode == TB_SWITCH_TMU_MODE_LOWRES ||
993 sw->tmu.mode == TB_SWITCH_TMU_MODE_HIFI_UNI ||
994 sw->tmu.mode == TB_SWITCH_TMU_MODE_HIFI_BI) {
995 ret = tb_switch_tmu_change_mode(sw);
996 } else {
997 ret = -EINVAL;
998 }
999 } else {
1000 /*
1001 * Host router port configurations are written as
1002 * part of configurations for downstream port of the parent
1003 * of the child node - see above.
1004 * Here only the host router' rate configuration is written.
1005 */
1006 ret = tb_switch_tmu_rate_write(sw, tmu_rates[sw->tmu.mode_request]);
1007 }
1008
1009 if (ret) {
1010 tb_sw_warn(sw, "TMU: failed to enable mode %s: %d\n",
1011 tmu_mode_name(sw->tmu.mode_request), ret);
1012 } else {
1013 sw->tmu.mode = sw->tmu.mode_request;
1014 tb_sw_dbg(sw, "TMU: mode set to: %s\n", tmu_mode_name(sw->tmu.mode));
1015 }
1016
1017 return tb_switch_tmu_set_time_disruption(sw, false);
1018}
1019
1020/**
1021 * tb_switch_tmu_configure() - Configure the TMU mode
1022 * @sw: Router whose mode to change
1023 * @mode: Mode to configure
1024 *
1025 * Selects the TMU mode that is enabled when tb_switch_tmu_enable() is
1026 * next called.
1027 *
1028 * Return:
1029 * * %0 - On success.
1030 * * %-EOPNOTSUPP - If the requested mode is not possible (not supported by
1031 * the router and/or topology).
1032 * * Negative errno - Another error occurred.
1033 */
1034int tb_switch_tmu_configure(struct tb_switch *sw, enum tb_switch_tmu_mode mode)
1035{
1036 switch (mode) {
1037 case TB_SWITCH_TMU_MODE_OFF:
1038 break;
1039
1040 case TB_SWITCH_TMU_MODE_LOWRES:
1041 case TB_SWITCH_TMU_MODE_HIFI_UNI:
1042 if (!sw->tmu.has_ucap)
1043 return -EOPNOTSUPP;
1044 break;
1045
1046 case TB_SWITCH_TMU_MODE_HIFI_BI:
1047 break;
1048
1049 case TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI: {
1050 const struct tb_switch *parent_sw = tb_switch_parent(sw);
1051
1052 if (!parent_sw || !tb_switch_tmu_enhanced_is_supported(parent_sw))
1053 return -EOPNOTSUPP;
1054 if (!tb_switch_tmu_enhanced_is_supported(sw))
1055 return -EOPNOTSUPP;
1056
1057 break;
1058 }
1059
1060 default:
1061 tb_sw_warn(sw, "TMU: unsupported mode %u\n", mode);
1062 return -EINVAL;
1063 }
1064
1065 if (sw->tmu.mode_request != mode) {
1066 tb_sw_dbg(sw, "TMU: mode change %s -> %s requested\n",
1067 tmu_mode_name(sw->tmu.mode), tmu_mode_name(mode));
1068 sw->tmu.mode_request = mode;
1069 }
1070
1071 return 0;
1072}