Lines Matching refs:sw
58 static bool tb_switch_tmu_enhanced_is_supported(const struct tb_switch *sw)
60 return usb4_switch_version(sw) > 1;
63 static int tb_switch_set_tmu_mode_params(struct tb_switch *sw,
72 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
73 sw->tmu.cap + TMU_RTR_CS_0, 1);
80 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
81 sw->tmu.cap + TMU_RTR_CS_0, 1);
85 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
86 sw->tmu.cap + TMU_RTR_CS_15, 1);
99 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
100 sw->tmu.cap + TMU_RTR_CS_15, 1);
104 if (tb_switch_tmu_enhanced_is_supported(sw)) {
107 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
108 sw->tmu.cap + TMU_RTR_CS_18, 1);
115 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
116 sw->tmu.cap + TMU_RTR_CS_18, 1);
122 static bool tb_switch_tmu_ucap_is_supported(struct tb_switch *sw)
127 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
128 sw->tmu.cap + TMU_RTR_CS_0, 1);
135 static int tb_switch_tmu_rate_read(struct tb_switch *sw)
140 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
141 sw->tmu.cap + TMU_RTR_CS_3, 1);
149 static int tb_switch_tmu_rate_write(struct tb_switch *sw, int rate)
154 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
155 sw->tmu.cap + TMU_RTR_CS_3, 1);
162 return tb_sw_write(sw, &val, TB_CFG_SWITCH,
163 sw->tmu.cap + TMU_RTR_CS_3, 1);
188 if (!port->sw->tmu.has_ucap)
237 if (!tb_switch_tmu_enhanced_is_supported(port->sw))
300 if (!tb_switch_tmu_enhanced_is_supported(port->sw))
332 static int tb_switch_tmu_set_time_disruption(struct tb_switch *sw, bool set)
337 if (tb_switch_is_usb4(sw)) {
338 offset = sw->tmu.cap + TMU_RTR_CS_0;
341 offset = sw->cap_vsec_tmu + TB_TIME_VSEC_3_CS_26;
345 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, offset, 1);
354 return tb_sw_write(sw, &val, TB_CFG_SWITCH, offset, 1);
357 static int tmu_mode_init(struct tb_switch *sw)
362 ucap = tb_switch_tmu_ucap_is_supported(sw);
364 tb_sw_dbg(sw, "TMU: supports uni-directional mode\n");
365 enhanced = tb_switch_tmu_enhanced_is_supported(sw);
367 tb_sw_dbg(sw, "TMU: supports enhanced uni-directional mode\n");
369 ret = tb_switch_tmu_rate_read(sw);
375 sw->tmu.mode = TB_SWITCH_TMU_MODE_OFF;
377 if (tb_route(sw)) {
378 struct tb_port *up = tb_upstream_port(sw);
381 sw->tmu.mode = TB_SWITCH_TMU_MODE_MEDRES_ENHANCED_UNI;
384 sw->tmu.mode = TB_SWITCH_TMU_MODE_LOWRES;
386 sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_UNI;
388 sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_BI;
391 sw->tmu.mode = TB_SWITCH_TMU_MODE_HIFI_BI;
395 sw->tmu.mode_request = sw->tmu.mode;
396 sw->tmu.has_ucap = ucap;
403 * @sw: Switch to initialized
409 int tb_switch_tmu_init(struct tb_switch *sw)
414 if (tb_switch_is_icm(sw))
417 ret = tb_switch_find_cap(sw, TB_SWITCH_CAP_TMU);
419 sw->tmu.cap = ret;
421 tb_switch_for_each_port(sw, port) {
429 ret = tmu_mode_init(sw);
433 tb_sw_dbg(sw, "TMU: current mode: %s\n", tmu_mode_name(sw->tmu.mode));
439 * @sw: Switch whose time to update
443 int tb_switch_tmu_post_time(struct tb_switch *sw)
447 struct tb_switch *root_switch = sw->tb->root_switch;
452 if (!tb_route(sw))
455 if (!tb_switch_is_usb4(sw))
480 ret = tb_switch_tmu_set_time_disruption(sw, true);
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;
492 ret = tb_sw_write(sw, &local_time, TB_CFG_SWITCH,
507 ret = tb_sw_write(sw, &post_time, TB_CFG_SWITCH, post_time_offset, 2);
511 ret = tb_sw_write(sw, &post_time_high, TB_CFG_SWITCH,
518 ret = tb_sw_read(sw, &post_time, TB_CFG_SWITCH,
529 tb_sw_dbg(sw, "TMU: updated local time to %#llx\n", local_time);
532 tb_switch_tmu_set_time_disruption(sw, false);
555 * @sw: Switch whose TMU to disable
557 * Turns off TMU of @sw if it is enabled. If not enabled does nothing.
559 int tb_switch_tmu_disable(struct tb_switch *sw)
562 if (sw->tmu.mode == TB_SWITCH_TMU_MODE_OFF)
565 if (tb_route(sw)) {
569 down = tb_switch_downstream_port(sw);
570 up = tb_upstream_port(sw);
582 ret = tb_switch_tmu_rate_write(sw, tmu_rates[TB_SWITCH_TMU_MODE_OFF]);
591 switch (sw->tmu.mode) {
611 tb_switch_tmu_rate_write(sw, tmu_rates[TB_SWITCH_TMU_MODE_OFF]);
614 sw->tmu.mode = TB_SWITCH_TMU_MODE_OFF;
616 tb_sw_dbg(sw, "TMU: disabled\n");
621 static void tb_switch_tmu_off(struct tb_switch *sw)
626 down = tb_switch_downstream_port(sw);
627 up = tb_upstream_port(sw);
638 switch (sw->tmu.mode_request) {
641 tb_switch_tmu_rate_write(tb_switch_parent(sw), rate);
651 tb_switch_tmu_rate_write(sw, rate);
653 tb_switch_set_tmu_mode_params(sw, sw->tmu.mode);
662 static int tb_switch_tmu_enable_bidirectional(struct tb_switch *sw)
667 up = tb_upstream_port(sw);
668 down = tb_switch_downstream_port(sw);
678 ret = tb_switch_tmu_rate_write(sw, tmu_rates[TB_SWITCH_TMU_MODE_HIFI_BI]);
693 tb_switch_tmu_off(sw);
698 static int tb_switch_tmu_disable_objections(struct tb_switch *sw)
700 struct tb_port *up = tb_upstream_port(sw);
704 ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
705 sw->cap_vsec_tmu + TB_TIME_VSEC_3_CS_9, 1);
711 ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
712 sw->cap_vsec_tmu + TB_TIME_VSEC_3_CS_9, 1);
726 static int tb_switch_tmu_enable_unidirectional(struct tb_switch *sw)
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]);
738 ret = tb_switch_set_tmu_mode_params(sw, sw->tmu.mode_request);
761 tb_switch_tmu_off(sw);
769 static int tb_switch_tmu_enable_enhanced(struct tb_switch *sw)
771 unsigned int rate = tmu_rates[sw->tmu.mode_request];
776 ret = tb_switch_set_tmu_mode_params(sw, sw->tmu.mode_request);
780 up = tb_upstream_port(sw);
781 down = tb_switch_downstream_port(sw);
783 ret = tb_port_set_tmu_mode_params(up, sw->tmu.mode_request);
795 ret = tb_port_set_tmu_mode_params(down, sw->tmu.mode_request);
810 tb_switch_tmu_off(sw);
814 static void tb_switch_tmu_change_mode_prev(struct tb_switch *sw)
816 unsigned int rate = tmu_rates[sw->tmu.mode];
819 down = tb_switch_downstream_port(sw);
820 up = tb_upstream_port(sw);
827 switch (sw->tmu.mode) {
831 tb_switch_tmu_rate_write(tb_switch_parent(sw), rate);
836 tb_switch_tmu_rate_write(sw, rate);
843 tb_switch_set_tmu_mode_params(sw, sw->tmu.mode);
845 switch (sw->tmu.mode) {
860 static int tb_switch_tmu_change_mode(struct tb_switch *sw)
862 unsigned int rate = tmu_rates[sw->tmu.mode_request];
866 up = tb_upstream_port(sw);
867 down = tb_switch_downstream_port(sw);
870 switch (sw->tmu.mode_request) {
876 ret = tb_switch_tmu_rate_write(tb_switch_parent(sw), rate);
885 ret = tb_switch_tmu_rate_write(sw, rate);
895 ret = tb_switch_set_tmu_mode_params(sw, sw->tmu.mode_request);
900 switch (sw->tmu.mode_request) {
930 tb_switch_tmu_change_mode_prev(sw);
936 * @sw: Router whose TMU to enable
942 int tb_switch_tmu_enable(struct tb_switch *sw)
946 if (tb_switch_tmu_is_enabled(sw))
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);
957 ret = tb_switch_tmu_set_time_disruption(sw, true);
961 if (tb_route(sw)) {
967 if (sw->tmu.mode == TB_SWITCH_TMU_MODE_OFF) {
968 switch (sw->tmu.mode_request) {
971 ret = tb_switch_tmu_enable_unidirectional(sw);
975 ret = tb_switch_tmu_enable_bidirectional(sw);
978 ret = tb_switch_tmu_enable_enhanced(sw);
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);
998 ret = tb_switch_tmu_rate_write(sw, tmu_rates[sw->tmu.mode_request]);
1002 tb_sw_warn(sw, "TMU: failed to enable mode %s: %d\n",
1003 tmu_mode_name(sw->tmu.mode_request), ret);
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));
1009 return tb_switch_tmu_set_time_disruption(sw, false);
1014 * @sw: Router whose mode to change
1024 int tb_switch_tmu_configure(struct tb_switch *sw, enum tb_switch_tmu_mode mode)
1032 if (!sw->tmu.has_ucap)
1040 const struct tb_switch *parent_sw = tb_switch_parent(sw);
1044 if (!tb_switch_tmu_enhanced_is_supported(sw))
1051 tb_sw_warn(sw, "TMU: unsupported mode %u\n", mode);
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;