Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2024-2026 Beijing WangXun Technology Co., Ltd.
3 : : */
4 : :
5 : : #include "txgbe_e56.h"
6 : : #include "txgbe_e56_bp.h"
7 : : #include "../txgbe_logs.h"
8 : :
9 : : /*
10 : : * compare function for qsort()
11 : : */
12 : : static inline
13 : 0 : int txgbe_e56_int_cmp(const void *a, const void *b)
14 : : {
15 : : const int *num1 = (const int *)a;
16 : : const int *num2 = (const int *)b;
17 : :
18 [ # # ]: 0 : if (*num1 < *num2)
19 : : return -1;
20 : :
21 [ # # ]: 0 : else if (*num1 > *num2)
22 : : return 1;
23 : :
24 : : else
25 : 0 : return 0;
26 : : }
27 : :
28 : 0 : s32 txgbe_e56_check_phy_link(struct txgbe_hw *hw, u32 *speed,
29 : : bool *link_up)
30 : : {
31 : : u32 rdata = 0;
32 : : u32 links_reg = 0;
33 : :
34 : : /* must read it twice because the state may
35 : : * not be correct the first time you read it
36 : : */
37 : : rdata = rd32_epcs(hw, 0x30001);
38 : : rdata = rd32_epcs(hw, 0x30001);
39 : :
40 [ # # ]: 0 : if (rdata & TXGBE_E56_PHY_LINK_UP)
41 : 0 : *link_up = true;
42 : : else
43 : 0 : *link_up = false;
44 : :
45 [ # # ]: 0 : if (!hw->link_valid)
46 : 0 : *link_up = false;
47 : :
48 : : links_reg = rd32(hw, TXGBE_PORTSTAT);
49 [ # # ]: 0 : if (*link_up) {
50 [ # # ]: 0 : if ((links_reg & TXGBE_CFG_PORT_ST_AML_LINK_40G) ==
51 : : TXGBE_CFG_PORT_ST_AML_LINK_40G)
52 : 0 : *speed = TXGBE_LINK_SPEED_40GB_FULL;
53 [ # # ]: 0 : else if ((links_reg & TXGBE_CFG_PORT_ST_AML_LINK_25G) ==
54 : : TXGBE_CFG_PORT_ST_AML_LINK_25G)
55 : 0 : *speed = TXGBE_LINK_SPEED_25GB_FULL;
56 [ # # ]: 0 : else if ((links_reg & TXGBE_CFG_PORT_ST_AML_LINK_10G) ==
57 : : TXGBE_CFG_PORT_ST_AML_LINK_10G)
58 : 0 : *speed = TXGBE_LINK_SPEED_10GB_FULL;
59 : : } else {
60 : 0 : *speed = TXGBE_LINK_SPEED_UNKNOWN;
61 : : }
62 : :
63 : 0 : return 0;
64 : : }
65 : :
66 : 0 : u32 txgbe_e56_tx_ffe_cfg(struct txgbe_hw *hw, u32 speed)
67 : : {
68 : : u32 ffe_main = 0, pre1 = 0, pre2 = 0, post = 0;
69 : :
70 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_10GB_FULL) {
71 : : ffe_main = S10G_TX_FFE_CFG_MAIN;
72 : : pre1 = S10G_TX_FFE_CFG_PRE1;
73 : : pre2 = S10G_TX_FFE_CFG_PRE2;
74 : : post = S10G_TX_FFE_CFG_POST;
75 [ # # ]: 0 : } else if (speed == TXGBE_LINK_SPEED_25GB_FULL) {
76 [ # # ]: 0 : if (hw->phy.sfp_type == txgbe_sfp_type_da_cu_core0 ||
77 [ # # ]: 0 : hw->phy.sfp_type == txgbe_sfp_type_da_cu_core1 ||
78 : 0 : txgbe_is_backplane(hw)) {
79 : : ffe_main = S25G_TX_FFE_CFG_DAC_MAIN;
80 : : pre1 = S25G_TX_FFE_CFG_DAC_PRE1;
81 : : pre2 = S25G_TX_FFE_CFG_DAC_PRE2;
82 : : post = S25G_TX_FFE_CFG_DAC_POST;
83 : : } else {
84 : : ffe_main = S25G_TX_FFE_CFG_MAIN;
85 : : pre1 = S25G_TX_FFE_CFG_PRE1;
86 : : pre2 = S25G_TX_FFE_CFG_PRE2;
87 : : post = S25G_TX_FFE_CFG_POST;
88 : : }
89 [ # # ]: 0 : } else if (speed == TXGBE_LINK_SPEED_40GB_FULL) {
90 : : ffe_main = S10G_TX_FFE_CFG_MAIN;
91 : : pre1 = S10G_TX_FFE_CFG_PRE1;
92 : : pre2 = S10G_TX_FFE_CFG_PRE2;
93 : : post = S10G_TX_FFE_CFG_POST;
94 : :
95 [ # # ]: 0 : if (hw->phy.sfp_type == txgbe_qsfp_type_40g_cu_core0 ||
96 [ # # ]: 0 : hw->phy.sfp_type == txgbe_qsfp_type_40g_cu_core1 ||
97 : 0 : txgbe_is_backplane(hw)) {
98 : : ffe_main = S40G_TX_FFE_CFG_MAIN;
99 : : pre1 = S40G_TX_FFE_CFG_PRE1;
100 : : pre2 = S40G_TX_FFE_CFG_PRE2;
101 : : post = S40G_TX_FFE_CFG_POST;
102 : : }
103 : : }
104 : :
105 [ # # ]: 0 : if (hw->phy.ffe_set) {
106 : 0 : ffe_main = hw->phy.ffe_main;
107 : 0 : pre1 = hw->phy.ffe_pre;
108 : 0 : pre2 = hw->phy.ffe_pre2;
109 : 0 : post = hw->phy.ffe_post;
110 : : }
111 : :
112 : 0 : DEBUGOUT("main = 0x%x, pre1 = 0x%x, pre2 = 0x%x, post = 0x%x",
113 : : ffe_main, pre1, pre2, post);
114 : :
115 : : wr32_ephy(hw, E56G__PMD_TX_FFE_CFG_1_ADDR, ffe_main);
116 : : wr32_ephy(hw, E56G__PMD_TX_FFE_CFG_2_ADDR, pre1);
117 : : wr32_ephy(hw, E56G__PMD_TX_FFE_CFG_3_ADDR, pre2);
118 : : wr32_ephy(hw, E56G__PMD_TX_FFE_CFG_4_ADDR, post);
119 : :
120 : 0 : return 0;
121 : : }
122 : :
123 : : int
124 : 0 : txgbe_e56_get_temp(struct txgbe_hw *hw, int *temp)
125 : : {
126 : : int data_code, temp_data, temp_fraction;
127 : : u32 rdata;
128 : : u32 timer = 0;
129 : :
130 : : while (1) {
131 : : rdata = rd32(hw, 0x1033c);
132 [ # # ]: 0 : if (((rdata >> 12) & 0x1) != 0)
133 : : break;
134 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
135 : : return -1;
136 : : }
137 : :
138 : 0 : data_code = rdata & 0xFFF;
139 : 0 : temp_data = 419400 + 2205 * (data_code * 1000 / 4094 - 500);
140 : :
141 : : /* Change double Temperature to int */
142 : 0 : *temp = temp_data / 10000;
143 : 0 : temp_fraction = temp_data - (*temp * 10000);
144 [ # # ]: 0 : if (temp_fraction >= 5000)
145 : 0 : *temp += 1;
146 : :
147 : : return 0;
148 : : }
149 : :
150 : 0 : u32 txgbe_e56_cfg_40g(struct txgbe_hw *hw)
151 : : {
152 : : u32 addr;
153 : : u32 rdata = 0;
154 : : int i;
155 : :
156 : : /* CMS config */
157 : : addr = E56G_CMS_ANA_OVRDVAL_7_ADDR;
158 : 0 : rdata = rd32_ephy(hw, addr);
159 : 0 : ((E56G_CMS_ANA_OVRDVAL_7 *)&rdata)->ana_lcpll_lf_vco_swing_ctrl_i = 0xf;
160 : 0 : wr32_ephy(hw, addr, rdata);
161 : :
162 : : addr = E56G_CMS_ANA_OVRDEN_1_ADDR;
163 : 0 : rdata = rd32_ephy(hw, addr);
164 : 0 : ((E56G_CMS_ANA_OVRDEN_1 *)&rdata)->ovrd_en_ana_lcpll_lf_vco_swing_ctrl_i = 0x1;
165 : 0 : wr32_ephy(hw, addr, rdata);
166 : :
167 : : addr = E56G_CMS_ANA_OVRDVAL_9_ADDR;
168 : 0 : rdata = rd32_ephy(hw, addr);
169 : : set_fields_e56(&rdata, 23, 0, 0x260000);
170 : : wr32_ephy(hw, addr, rdata);
171 : :
172 : : addr = E56G_CMS_ANA_OVRDEN_1_ADDR;
173 : 0 : rdata = rd32_ephy(hw, addr);
174 : 0 : ((E56G_CMS_ANA_OVRDEN_1 *)&rdata)->ovrd_en_ana_lcpll_lf_test_in_i = 0x1;
175 : 0 : wr32_ephy(hw, addr, rdata);
176 : :
177 : : /* TXS config */
178 [ # # ]: 0 : for (i = 0; i < 4; i++) {
179 : 0 : addr = E56PHY_TXS_TXS_CFG_1_ADDR + (E56PHY_TXS_OFFSET * i);
180 : 0 : rdata = rd32_ephy(hw, addr);
181 : : set_fields_e56(&rdata, E56PHY_TXS_TXS_CFG_1_ADAPTATION_WAIT_CNT_X256, 0xf);
182 : : wr32_ephy(hw, addr, rdata);
183 : :
184 : 0 : addr = E56PHY_TXS_WKUP_CNT_ADDR + (E56PHY_TXS_OFFSET * i);
185 : 0 : rdata = rd32_ephy(hw, addr);
186 : : set_fields_e56(&rdata, E56PHY_TXS_WKUP_CNTLDO_WKUP_CNT_X32, 0xff);
187 : : set_fields_e56(&rdata, E56PHY_TXS_WKUP_CNTDCC_WKUP_CNT_X32, 0xff);
188 : : wr32_ephy(hw, addr, rdata);
189 : :
190 : 0 : addr = E56PHY_TXS_PIN_OVRDVAL_6_ADDR + (E56PHY_TXS_OFFSET * i);
191 : 0 : rdata = rd32_ephy(hw, addr);
192 : : set_fields_e56(&rdata, 19, 16, 0x6);
193 : : wr32_ephy(hw, addr, rdata);
194 : :
195 : 0 : addr = E56PHY_TXS_PIN_OVRDEN_0_ADDR + (E56PHY_TXS_OFFSET * i);
196 : : rdata = rd32_ephy(hw, addr);
197 : : set_fields_e56(&rdata, E56PHY_TXS_PIN_OVRDEN_0_OVRD_EN_TX0_EFUSE_BITS_I, 0x1);
198 : : wr32_ephy(hw, addr, rdata);
199 : :
200 : 0 : addr = E56PHY_TXS_ANA_OVRDVAL_1_ADDR + (E56PHY_TXS_OFFSET * i);
201 : 0 : rdata = rd32_ephy(hw, addr);
202 : : set_fields_e56(&rdata, E56PHY_TXS_ANA_OVRDVAL_1_ANA_TEST_DAC_I, 0x1);
203 : : wr32_ephy(hw, addr, rdata);
204 : :
205 : 0 : addr = E56PHY_TXS_ANA_OVRDEN_0_ADDR + (E56PHY_TXS_OFFSET * i);
206 : : rdata = rd32_ephy(hw, addr);
207 : : set_fields_e56(&rdata, E56PHY_TXS_ANA_OVRDEN_0_OVRD_EN_ANA_TEST_DAC_I, 0x1);
208 : : wr32_ephy(hw, addr, rdata);
209 : : }
210 : : /* Setting TX FFE */
211 : 0 : txgbe_e56_tx_ffe_cfg(hw, TXGBE_LINK_SPEED_40GB_FULL);
212 : :
213 : : /* RXS config */
214 [ # # ]: 0 : for (i = 0; i < 4; i++) {
215 : 0 : addr = E56PHY_RXS_RXS_CFG_0_ADDR + (E56PHY_RXS_OFFSET * i);
216 : : rdata = rd32_ephy(hw, addr);
217 : : set_fields_e56(&rdata, E56PHY_RXS_RXS_CFG_0_DSER_DATA_SEL, 0x0);
218 : : set_fields_e56(&rdata, E56PHY_RXS_RXS_CFG_0_TRAIN_CLK_GATE_BYPASS_EN, 0x1fff);
219 : : wr32_ephy(hw, addr, rdata);
220 : :
221 : 0 : addr = E56PHY_RXS_OSC_CAL_N_CDR_1_ADDR + (E56PHY_RXS_OFFSET * i);
222 : : rdata = rd32_ephy(hw, addr);
223 : : ((E56G_RXS0_OSC_CAL_N_CDR_0 *)&rdata)->prediv0 = 0xfa0;
224 : : ((E56G_RXS0_OSC_CAL_N_CDR_0 *)&rdata)->target_cnt0 = 0x203a;
225 : : wr32_ephy(hw, addr, rdata);
226 : :
227 : 0 : addr = E56PHY_RXS_OSC_CAL_N_CDR_4_ADDR + (E56PHY_RXS_OFFSET * i);
228 : 0 : rdata = rd32_ephy(hw, addr);
229 : 0 : ((E56G_RXS0_OSC_CAL_N_CDR_4 *)&rdata)->osc_range_sel0 = 0x2;
230 : 0 : ((E56G_RXS0_OSC_CAL_N_CDR_4 *)&rdata)->vco_code_init = 0x7ff;
231 : 0 : ((E56G_RXS0_OSC_CAL_N_CDR_4 *)&rdata)->osc_current_boost_en0 = 0x1;
232 : 0 : ((E56G_RXS0_OSC_CAL_N_CDR_4 *)&rdata)->bbcdr_current_boost0 = 0x0;
233 : 0 : wr32_ephy(hw, addr, rdata);
234 : :
235 : 0 : addr = E56PHY_RXS_OSC_CAL_N_CDR_5_ADDR + (E56PHY_RXS_OFFSET * i);
236 : 0 : rdata = rd32_ephy(hw, addr);
237 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_SDM_WIDTH, 0x3);
238 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_PROP_STEP_PRELOCK, 0xf);
239 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_PROP_STEP_POSTLOCK, 0xf);
240 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_GAIN_CTRL_POSTLOCK, 0xc);
241 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_GAIN_CTRL_PRELOCK, 0xf);
242 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BBCDR_RDY_CNT, 0x3);
243 : : wr32_ephy(hw, addr, rdata);
244 : :
245 : 0 : addr = E56PHY_RXS_OSC_CAL_N_CDR_6_ADDR + (E56PHY_RXS_OFFSET * i);
246 : 0 : rdata = rd32_ephy(hw, addr);
247 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_6_PI_GAIN_CTRL_PRELOCK, 0x7);
248 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_6_PI_GAIN_CTRL_POSTLOCK, 0x5);
249 : : wr32_ephy(hw, addr, rdata);
250 : :
251 : 0 : addr = E56PHY_RXS_INTL_CONFIG_0_ADDR + (E56PHY_RXS_OFFSET * i);
252 : 0 : rdata = rd32_ephy(hw, addr);
253 : 0 : ((E56G_RXS0_INTL_CONFIG_0 *)&rdata)->adc_intl2slice_delay0 = 0x5555;
254 : 0 : wr32_ephy(hw, addr, rdata);
255 : :
256 : 0 : addr = E56PHY_RXS_INTL_CONFIG_2_ADDR + (E56PHY_RXS_OFFSET * i);
257 : 0 : rdata = rd32_ephy(hw, addr);
258 : 0 : ((E56G_RXS0_INTL_CONFIG_2 *)&rdata)->interleaver_hbw_disable0 = 0x1;
259 : 0 : wr32_ephy(hw, addr, rdata);
260 : :
261 : : rdata = 0x0000;
262 : 0 : addr = E56PHY_RXS_TXFFE_TRAINING_0_ADDR + (E56PHY_RXS_OFFSET * i);
263 : 0 : rdata = rd32_ephy(hw, addr);
264 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_0_ADC_DATA_PEAK_LTH, 0x56);
265 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_0_ADC_DATA_PEAK_UTH, 0x6a);
266 : : wr32_ephy(hw, addr, rdata);
267 : :
268 : : rdata = 0x0000;
269 : 0 : addr = E56PHY_RXS_TXFFE_TRAINING_1_ADDR + (E56PHY_RXS_OFFSET * i);
270 : 0 : rdata = rd32_ephy(hw, addr);
271 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_1_C1_LTH, 0x1e8);
272 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_1_C1_UTH, 0x78);
273 : : wr32_ephy(hw, addr, rdata);
274 : :
275 : : rdata = 0x0000;
276 : 0 : addr = E56PHY_RXS_TXFFE_TRAINING_2_ADDR + (E56PHY_RXS_OFFSET * i);
277 : 0 : rdata = rd32_ephy(hw, addr);
278 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_2_CM1_LTH, 0x100);
279 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_2_CM1_UTH, 0xff);
280 : : wr32_ephy(hw, addr, rdata);
281 : :
282 : : rdata = 0x0000;
283 : 0 : addr = E56PHY_RXS_TXFFE_TRAINING_3_ADDR + (E56PHY_RXS_OFFSET * i);
284 : 0 : rdata = rd32_ephy(hw, addr);
285 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_3_CM2_LTH, 0x4);
286 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_3_CM2_UTH, 0x37);
287 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_3_TXFFE_TRAIN_MOD_TYPE, 0x38);
288 : : wr32_ephy(hw, addr, rdata);
289 : :
290 : : rdata = 0x0000;
291 : 0 : addr = E56PHY_RXS_VGA_TRAINING_0_ADDR + (E56PHY_RXS_OFFSET * i);
292 : 0 : rdata = rd32_ephy(hw, addr);
293 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_0_VGA_TARGET, 0x34);
294 : : wr32_ephy(hw, addr, rdata);
295 : :
296 : : rdata = 0x0000;
297 : 0 : addr = E56PHY_RXS_VGA_TRAINING_1_ADDR + (E56PHY_RXS_OFFSET * i);
298 : 0 : rdata = rd32_ephy(hw, addr);
299 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA1_CODE_INIT0, 0xa);
300 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA2_CODE_INIT0, 0xa);
301 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA1_CODE_INIT123, 0xa);
302 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA2_CODE_INIT123, 0xa);
303 : : wr32_ephy(hw, addr, rdata);
304 : :
305 : 0 : addr = E56PHY_RXS_CTLE_TRAINING_0_ADDR + (E56PHY_RXS_OFFSET * i);
306 : 0 : rdata = rd32_ephy(hw, addr);
307 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_0_CTLE_CODE_INIT0, 0x9);
308 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_0_CTLE_CODE_INIT123, 0x9);
309 : : wr32_ephy(hw, addr, rdata);
310 : :
311 : 0 : addr = E56PHY_RXS_CTLE_TRAINING_1_ADDR + (E56PHY_RXS_OFFSET * i);
312 : 0 : rdata = rd32_ephy(hw, addr);
313 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_1_LFEQ_LUT, 0x1ffffea);
314 : : wr32_ephy(hw, addr, rdata);
315 : :
316 : 0 : addr = E56PHY_RXS_CTLE_TRAINING_2_ADDR + (E56PHY_RXS_OFFSET * i);
317 : 0 : rdata = rd32_ephy(hw, addr);
318 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_2_ISI_TH_FRAC_P1,
319 : : S10G_PHY_RX_CTLE_TAP_FRACP1);
320 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_2_ISI_TH_FRAC_P2,
321 : : S10G_PHY_RX_CTLE_TAP_FRACP2);
322 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_2_ISI_TH_FRAC_P3,
323 : : S10G_PHY_RX_CTLE_TAP_FRACP3);
324 : : wr32_ephy(hw, addr, rdata);
325 : :
326 : 0 : addr = E56PHY_RXS_CTLE_TRAINING_3_ADDR + (E56PHY_RXS_OFFSET * i);
327 : 0 : rdata = rd32_ephy(hw, addr);
328 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_3_TAP_WEIGHT_P1,
329 : : S10G_PHY_RX_CTLE_TAPWT_WEIGHT1);
330 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_3_TAP_WEIGHT_P2,
331 : : S10G_PHY_RX_CTLE_TAPWT_WEIGHT2);
332 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_3_TAP_WEIGHT_P3,
333 : : S10G_PHY_RX_CTLE_TAPWT_WEIGHT3);
334 : : wr32_ephy(hw, addr, rdata);
335 : :
336 : 0 : addr = E56PHY_RXS_OFFSET_N_GAIN_CAL_0_ADDR + (E56PHY_RXS_OFFSET * i);
337 : 0 : rdata = rd32_ephy(hw, addr);
338 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_0_ADC_SLICE_DATA_AVG_CNT, 0x3);
339 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_0_ADC_DATA_AVG_CNT, 0x3);
340 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_0_FE_OFFSET_DAC_CLK_CNT_X8,
341 : : 0xc);
342 : : wr32_ephy(hw, addr, rdata);
343 : :
344 : 0 : addr = E56PHY_RXS_OFFSET_N_GAIN_CAL_1_ADDR + (E56PHY_RXS_OFFSET * i);
345 : 0 : rdata = rd32_ephy(hw, addr);
346 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_1_SAMP_ADAPT_CFG, 0x5);
347 : : wr32_ephy(hw, addr, rdata);
348 : :
349 : 0 : addr = E56PHY_RXS_FFE_TRAINING_0_ADDR + (E56PHY_RXS_OFFSET * i);
350 : 0 : rdata = rd32_ephy(hw, addr);
351 : : set_fields_e56(&rdata, E56PHY_RXS_FFE_TRAINING_0_FFE_TAP_EN, 0xf9ff);
352 : : wr32_ephy(hw, addr, rdata);
353 : :
354 : 0 : addr = E56PHY_RXS_IDLE_DETECT_1_ADDR + (E56PHY_RXS_OFFSET * i);
355 : 0 : rdata = rd32_ephy(hw, addr);
356 : : set_fields_e56(&rdata, E56PHY_RXS_IDLE_DETECT_1_IDLE_TH_ADC_PEAK_MAX, 0xa);
357 : : set_fields_e56(&rdata, E56PHY_RXS_IDLE_DETECT_1_IDLE_TH_ADC_PEAK_MIN, 0x5);
358 : : wr32_ephy(hw, addr, rdata);
359 : :
360 : 0 : addr = E56G__RXS3_ANA_OVRDVAL_11_ADDR + (E56PHY_RXS_OFFSET * i);
361 : 0 : rdata = rd32_ephy(hw, addr);
362 : 0 : ((E56G__RXS3_ANA_OVRDVAL_11 *)&rdata)->ana_test_adc_clkgen_i = 0x0;
363 : 0 : wr32_ephy(hw, addr, rdata);
364 : :
365 : 0 : addr = E56G__RXS0_ANA_OVRDEN_2_ADDR + (E56PHY_RXS_OFFSET * i);
366 : 0 : rdata = rd32_ephy(hw, addr);
367 : 0 : ((E56G__RXS0_ANA_OVRDEN_2 *)&rdata)->ovrd_en_ana_test_adc_clkgen_i = 0x0;
368 : 0 : wr32_ephy(hw, addr, rdata);
369 : :
370 : 0 : addr = E56PHY_RXS_ANA_OVRDVAL_0_ADDR + (E56PHY_RXS_OFFSET * i);
371 : : rdata = rd32_ephy(hw, addr);
372 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDVAL_0_ANA_EN_RTERM_I, 0x1);
373 : : wr32_ephy(hw, addr, rdata);
374 : :
375 : 0 : addr = E56PHY_RXS_ANA_OVRDEN_0_ADDR + (E56PHY_RXS_OFFSET * i);
376 : : rdata = rd32_ephy(hw, addr);
377 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_0_OVRD_EN_ANA_EN_RTERM_I, 0x1);
378 : : wr32_ephy(hw, addr, rdata);
379 : :
380 : 0 : addr = E56PHY_RXS_ANA_OVRDVAL_6_ADDR + (E56PHY_RXS_OFFSET * i);
381 : 0 : rdata = rd32_ephy(hw, addr);
382 : : set_fields_e56(&rdata, 4, 0, 0x6);
383 : : set_fields_e56(&rdata, 14, 13, 0x2);
384 : : wr32_ephy(hw, addr, rdata);
385 : :
386 : 0 : addr = E56PHY_RXS_ANA_OVRDEN_1_ADDR + (E56PHY_RXS_OFFSET * i);
387 : : rdata = rd32_ephy(hw, addr);
388 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_1_OVRD_EN_ANA_BBCDR_VCOFILT_BYP_I,
389 : : 0x1);
390 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_1_OVRD_EN_ANA_TEST_BBCDR_I, 0x1);
391 : : wr32_ephy(hw, addr, rdata);
392 : :
393 : 0 : addr = E56PHY_RXS_ANA_OVRDVAL_15_ADDR + (E56PHY_RXS_OFFSET * i);
394 : 0 : rdata = rd32_ephy(hw, addr);
395 : : set_fields_e56(&rdata, 2, 0, 0x1);
396 : : wr32_ephy(hw, addr, rdata);
397 : :
398 : 0 : addr = E56PHY_RXS_ANA_OVRDVAL_17_ADDR + (E56PHY_RXS_OFFSET * i);
399 : 0 : rdata = rd32_ephy(hw, addr);
400 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDVAL_17_ANA_VGA2_BOOST_CSTM_I, 0x0);
401 : : wr32_ephy(hw, addr, rdata);
402 : :
403 : 0 : addr = E56PHY_RXS_ANA_OVRDEN_3_ADDR + (E56PHY_RXS_OFFSET * i);
404 : : rdata = rd32_ephy(hw, addr);
405 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_3_OVRD_EN_ANA_ANABS_CONFIG_I, 0x1);
406 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_3_OVRD_EN_ANA_VGA2_BOOST_CSTM_I, 0x1);
407 : : wr32_ephy(hw, addr, rdata);
408 : :
409 : 0 : addr = E56PHY_RXS_ANA_OVRDVAL_14_ADDR + (E56PHY_RXS_OFFSET * i);
410 : : rdata = rd32_ephy(hw, addr);
411 : : set_fields_e56(&rdata, 13, 13, 0x1);
412 : : wr32_ephy(hw, addr, rdata);
413 : :
414 : 0 : addr = E56PHY_RXS_ANA_OVRDEN_4_ADDR + (E56PHY_RXS_OFFSET * i);
415 : : rdata = rd32_ephy(hw, addr);
416 : : set_fields_e56(&rdata, 13, 13, 0x1);
417 : : wr32_ephy(hw, addr, rdata);
418 : :
419 : 0 : addr = E56PHY_RXS_EYE_SCAN_1_ADDR + (E56PHY_RXS_OFFSET * i);
420 : 0 : rdata = rd32_ephy(hw, addr);
421 : : set_fields_e56(&rdata, E56PHY_RXS_EYE_SCAN_1_EYE_SCAN_REF_TIMER, 0x400);
422 : : wr32_ephy(hw, addr, rdata);
423 : :
424 : 0 : addr = E56PHY_RXS_RINGO_0_ADDR + (E56PHY_RXS_OFFSET * i);
425 : 0 : rdata = rd32_ephy(hw, addr);
426 : : set_fields_e56(&rdata, 9, 4, 0x366);
427 : : wr32_ephy(hw, addr, rdata);
428 : : }
429 : :
430 : : /* PDIG config */
431 : : addr = E56PHY_PMD_CFG_3_ADDR;
432 : 0 : rdata = rd32_ephy(hw, addr);
433 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_3_CTRL_FSM_TIMEOUT_X64K, 0x80);
434 : : wr32_ephy(hw, addr, rdata);
435 : :
436 : : addr = E56PHY_PMD_CFG_4_ADDR;
437 : 0 : rdata = rd32_ephy(hw, addr);
438 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_4_TRAIN_DC_ON_PERIOD_X64K, 0x18);
439 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_4_TRAIN_DC_PERIOD_X512K, 0x3e);
440 : : wr32_ephy(hw, addr, rdata);
441 : :
442 : : addr = E56PHY_PMD_CFG_5_ADDR;
443 : : rdata = rd32_ephy(hw, addr);
444 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_5_USE_RECENT_MARKER_OFFSET, 0x1);
445 : : wr32_ephy(hw, addr, rdata);
446 : :
447 : : addr = E56PHY_CTRL_FSM_CFG_0_ADDR;
448 : : rdata = rd32_ephy(hw, addr);
449 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_0_CONT_ON_ADC_GAIN_CAL_ERR, 0x1);
450 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_0_DO_RX_ADC_OFST_CAL, 0x3);
451 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_0_RX_ERR_ACTION_EN, 0x40);
452 : : wr32_ephy(hw, addr, rdata);
453 : :
454 : : addr = E56PHY_CTRL_FSM_CFG_1_ADDR;
455 : 0 : rdata = rd32_ephy(hw, addr);
456 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST0_WAIT_CNT_X4096, 0xff);
457 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST1_WAIT_CNT_X4096, 0xff);
458 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST2_WAIT_CNT_X4096, 0xff);
459 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST3_WAIT_CNT_X4096, 0xff);
460 : : wr32_ephy(hw, addr, rdata);
461 : :
462 : : addr = E56PHY_CTRL_FSM_CFG_2_ADDR;
463 : 0 : rdata = rd32_ephy(hw, addr);
464 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST4_WAIT_CNT_X4096, 0x1);
465 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST5_WAIT_CNT_X4096, 0x4);
466 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST6_WAIT_CNT_X4096, 0x4);
467 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST7_WAIT_CNT_X4096, 0x4);
468 : : wr32_ephy(hw, addr, rdata);
469 : :
470 : : addr = E56PHY_CTRL_FSM_CFG_3_ADDR;
471 : 0 : rdata = rd32_ephy(hw, addr);
472 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST8_WAIT_CNT_X4096, 0x4);
473 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST9_WAIT_CNT_X4096, 0x4);
474 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST10_WAIT_CNT_X4096, 0x4);
475 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST11_WAIT_CNT_X4096, 0x4);
476 : : wr32_ephy(hw, addr, rdata);
477 : :
478 : : addr = E56PHY_CTRL_FSM_CFG_4_ADDR;
479 : 0 : rdata = rd32_ephy(hw, addr);
480 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST12_WAIT_CNT_X4096, 0x4);
481 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST13_WAIT_CNT_X4096, 0x4);
482 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST14_WAIT_CNT_X4096, 0x4);
483 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST15_WAIT_CNT_X4096, 0x4);
484 : : wr32_ephy(hw, addr, rdata);
485 : :
486 : : addr = E56PHY_CTRL_FSM_CFG_7_ADDR;
487 : 0 : rdata = rd32_ephy(hw, addr);
488 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_7_TRAIN_ST4_EN, 0x4bf);
489 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_7_TRAIN_ST5_EN, 0xc4bf);
490 : : wr32_ephy(hw, addr, rdata);
491 : :
492 : : addr = E56PHY_CTRL_FSM_CFG_8_ADDR;
493 : 0 : rdata = rd32_ephy(hw, addr);
494 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_8_TRAIN_ST7_EN, 0x47ff);
495 : : wr32_ephy(hw, addr, rdata);
496 : :
497 : : addr = E56PHY_CTRL_FSM_CFG_12_ADDR;
498 : 0 : rdata = rd32_ephy(hw, addr);
499 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_12_TRAIN_ST15_EN, 0x67ff);
500 : : wr32_ephy(hw, addr, rdata);
501 : :
502 : : addr = E56PHY_CTRL_FSM_CFG_13_ADDR;
503 : 0 : rdata = rd32_ephy(hw, addr);
504 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_13_TRAIN_ST0_DONE_EN, 0x8001);
505 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_13_TRAIN_ST1_DONE_EN, 0x8002);
506 : : wr32_ephy(hw, addr, rdata);
507 : :
508 : : addr = E56PHY_CTRL_FSM_CFG_14_ADDR;
509 : 0 : rdata = rd32_ephy(hw, addr);
510 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_14_TRAIN_ST3_DONE_EN, 0x8008);
511 : : wr32_ephy(hw, addr, rdata);
512 : :
513 : : addr = E56PHY_CTRL_FSM_CFG_15_ADDR;
514 : 0 : rdata = rd32_ephy(hw, addr);
515 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_15_TRAIN_ST4_DONE_EN, 0x8004);
516 : : wr32_ephy(hw, addr, rdata);
517 : :
518 : : addr = E56PHY_CTRL_FSM_CFG_17_ADDR;
519 : 0 : rdata = rd32_ephy(hw, addr);
520 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_17_TRAIN_ST8_DONE_EN, 0x20c0);
521 : : wr32_ephy(hw, addr, rdata);
522 : :
523 : : addr = E56PHY_CTRL_FSM_CFG_18_ADDR;
524 : 0 : rdata = rd32_ephy(hw, addr);
525 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_18_TRAIN_ST10_DONE_EN, 0x0);
526 : : wr32_ephy(hw, addr, rdata);
527 : :
528 : : addr = E56PHY_CTRL_FSM_CFG_29_ADDR;
529 : 0 : rdata = rd32_ephy(hw, addr);
530 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_29_TRAIN_ST15_DC_EN, 0x3f6d);
531 : : wr32_ephy(hw, addr, rdata);
532 : :
533 : : addr = E56PHY_CTRL_FSM_CFG_33_ADDR;
534 : 0 : rdata = rd32_ephy(hw, addr);
535 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_33_TRAIN0_RATE_SEL, 0x8000);
536 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_33_TRAIN1_RATE_SEL, 0x8000);
537 : : wr32_ephy(hw, addr, rdata);
538 : :
539 : : addr = E56PHY_CTRL_FSM_CFG_34_ADDR;
540 : 0 : rdata = rd32_ephy(hw, addr);
541 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_34_TRAIN2_RATE_SEL, 0x8000);
542 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_34_TRAIN3_RATE_SEL, 0x8000);
543 : : wr32_ephy(hw, addr, rdata);
544 : :
545 : : addr = E56PHY_KRT_TFSM_CFG_ADDR;
546 : 0 : rdata = rd32_ephy(hw, addr);
547 : : set_fields_e56(&rdata, E56PHY_KRT_TFSM_CFGKRT_TFSM_MAX_WAIT_TIMER_X1000K, 0x49);
548 : : set_fields_e56(&rdata, E56PHY_KRT_TFSM_CFGKRT_TFSM_MAX_WAIT_TIMER_X8000K, 0x37);
549 : : set_fields_e56(&rdata, E56PHY_KRT_TFSM_CFGKRT_TFSM_HOLDOFF_TIMER_X256K, 0x2f);
550 : : wr32_ephy(hw, addr, rdata);
551 : :
552 : : addr = E56PHY_FETX_FFE_TRAIN_CFG_0_ADDR;
553 : 0 : rdata = rd32_ephy(hw, addr);
554 : : set_fields_e56(&rdata, E56PHY_FETX_FFE_TRAIN_CFG_0_KRT_FETX_INIT_FFE_CFG_2, 0x2);
555 : : wr32_ephy(hw, addr, rdata);
556 : :
557 : 0 : return 0;
558 : : }
559 : :
560 : : u32
561 : 0 : txgbe_e56_cfg_25g(struct txgbe_hw *hw)
562 : : {
563 : : u32 addr;
564 : : u32 rdata = 0;
565 : :
566 : : addr = E56PHY_CMS_PIN_OVRDVAL_0_ADDR;
567 : : rdata = rd32_ephy(hw, addr);
568 : : set_fields_e56(&rdata, E56PHY_CMS_PIN_OVRDVAL_0_INT_PLL0_TX_SIGNAL_TYPE_I, 0x0);
569 : : wr32_ephy(hw, addr, rdata);
570 : :
571 : : addr = E56PHY_CMS_PIN_OVRDEN_0_ADDR;
572 : : rdata = rd32_ephy(hw, addr);
573 : : set_fields_e56(&rdata, E56PHY_CMS_PIN_OVRDEN_0_OVRD_EN_PLL0_TX_SIGNAL_TYPE_I,
574 : : 0x0);
575 : : wr32_ephy(hw, addr, rdata);
576 : :
577 : : addr = E56PHY_CMS_ANA_OVRDVAL_2_ADDR;
578 : 0 : rdata = rd32_ephy(hw, addr);
579 : : set_fields_e56(&rdata, E56PHY_CMS_ANA_OVRDVAL_2_ANA_LCPLL_HF_VCO_SWING_CTRL_I,
580 : : 0xf);
581 : : wr32_ephy(hw, addr, rdata);
582 : :
583 : : addr = E56PHY_CMS_ANA_OVRDEN_0_ADDR;
584 : : rdata = rd32_ephy(hw, addr);
585 : : set_fields_e56(&rdata,
586 : : E56PHY_CMS_ANA_OVRDEN_0_OVRD_EN_ANA_LCPLL_HF_VCO_SWING_CTRL_I, 0x1);
587 : : wr32_ephy(hw, addr, rdata);
588 : :
589 : : addr = E56PHY_CMS_ANA_OVRDVAL_4_ADDR;
590 : 0 : rdata = rd32_ephy(hw, addr);
591 : : set_fields_e56(&rdata, 23, 0, 0x260000);
592 : : wr32_ephy(hw, addr, rdata);
593 : :
594 : : addr = E56PHY_CMS_ANA_OVRDEN_1_ADDR;
595 : : rdata = rd32_ephy(hw, addr);
596 : : set_fields_e56(&rdata, E56PHY_CMS_ANA_OVRDEN_1_OVRD_EN_ANA_LCPLL_HF_TEST_IN_I,
597 : : 0x1);
598 : : wr32_ephy(hw, addr, rdata);
599 : :
600 : : addr = E56PHY_TXS_TXS_CFG_1_ADDR;
601 : 0 : rdata = rd32_ephy(hw, addr);
602 : : set_fields_e56(&rdata, E56PHY_TXS_TXS_CFG_1_ADAPTATION_WAIT_CNT_X256, 0xf);
603 : : wr32_ephy(hw, addr, rdata);
604 : :
605 : : addr = E56PHY_TXS_WKUP_CNT_ADDR;
606 : 0 : rdata = rd32_ephy(hw, addr);
607 : : set_fields_e56(&rdata, E56PHY_TXS_WKUP_CNTLDO_WKUP_CNT_X32, 0xff);
608 : : set_fields_e56(&rdata, E56PHY_TXS_WKUP_CNTDCC_WKUP_CNT_X32, 0xff);
609 : : wr32_ephy(hw, addr, rdata);
610 : :
611 : : addr = E56PHY_TXS_PIN_OVRDVAL_6_ADDR;
612 : 0 : rdata = rd32_ephy(hw, addr);
613 : : set_fields_e56(&rdata, 27, 24, 0x5);
614 : : wr32_ephy(hw, addr, rdata);
615 : :
616 : : addr = E56PHY_TXS_PIN_OVRDEN_0_ADDR;
617 : : rdata = rd32_ephy(hw, addr);
618 : : set_fields_e56(&rdata, E56PHY_TXS_PIN_OVRDEN_0_OVRD_EN_TX0_EFUSE_BITS_I, 0x1);
619 : : wr32_ephy(hw, addr, rdata);
620 : :
621 : : addr = E56PHY_TXS_ANA_OVRDVAL_1_ADDR;
622 : 0 : rdata = rd32_ephy(hw, addr);
623 : : set_fields_e56(&rdata, E56PHY_TXS_ANA_OVRDVAL_1_ANA_TEST_DAC_I, 0x1);
624 : : wr32_ephy(hw, addr, rdata);
625 : :
626 : : addr = E56PHY_TXS_ANA_OVRDEN_0_ADDR;
627 : : rdata = rd32_ephy(hw, addr);
628 : : set_fields_e56(&rdata, E56PHY_TXS_ANA_OVRDEN_0_OVRD_EN_ANA_TEST_DAC_I, 0x1);
629 : : wr32_ephy(hw, addr, rdata);
630 : :
631 : 0 : txgbe_e56_tx_ffe_cfg(hw, TXGBE_LINK_SPEED_25GB_FULL);
632 : :
633 : : addr = E56PHY_RXS_RXS_CFG_0_ADDR;
634 : : rdata = rd32_ephy(hw, addr);
635 : : set_fields_e56(&rdata, E56PHY_RXS_RXS_CFG_0_DSER_DATA_SEL, 0x0);
636 : : set_fields_e56(&rdata, E56PHY_RXS_RXS_CFG_0_TRAIN_CLK_GATE_BYPASS_EN, 0x1fff);
637 : : wr32_ephy(hw, addr, rdata);
638 : :
639 : : addr = E56PHY_RXS_OSC_CAL_N_CDR_1_ADDR;
640 : 0 : rdata = rd32_ephy(hw, addr);
641 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_1_PREDIV1, 0x700);
642 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_1_TARGET_CNT1, 0x2418);
643 : : wr32_ephy(hw, addr, rdata);
644 : :
645 : : addr = E56PHY_RXS_OSC_CAL_N_CDR_4_ADDR;
646 : 0 : rdata = rd32_ephy(hw, addr);
647 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_4_OSC_RANGE_SEL1, 0x1);
648 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_4_VCO_CODE_INIT, 0x7fb);
649 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_4_OSC_CURRENT_BOOST_EN1, 0x0);
650 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_4_BBCDR_CURRENT_BOOST1, 0x0);
651 : : wr32_ephy(hw, addr, rdata);
652 : :
653 : : addr = E56PHY_RXS_OSC_CAL_N_CDR_5_ADDR;
654 : 0 : rdata = rd32_ephy(hw, addr);
655 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_SDM_WIDTH, 0x3);
656 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_PROP_STEP_PRELOCK,
657 : : 0xf);
658 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_PROP_STEP_POSTLOCK,
659 : : 0x3);
660 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_GAIN_CTRL_POSTLOCK,
661 : : 0xa);
662 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_GAIN_CTRL_PRELOCK,
663 : : 0xf);
664 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BBCDR_RDY_CNT, 0x3);
665 : : wr32_ephy(hw, addr, rdata);
666 : :
667 : : addr = E56PHY_RXS_OSC_CAL_N_CDR_6_ADDR;
668 : 0 : rdata = rd32_ephy(hw, addr);
669 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_6_PI_GAIN_CTRL_PRELOCK, 0x7);
670 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_6_PI_GAIN_CTRL_POSTLOCK, 0x5);
671 : : wr32_ephy(hw, addr, rdata);
672 : :
673 : : addr = E56PHY_RXS_INTL_CONFIG_0_ADDR;
674 : 0 : rdata = rd32_ephy(hw, addr);
675 : : set_fields_e56(&rdata, E56PHY_RXS_INTL_CONFIG_0_ADC_INTL2SLICE_DELAY1, 0x3333);
676 : : wr32_ephy(hw, addr, rdata);
677 : :
678 : : addr = E56PHY_RXS_INTL_CONFIG_2_ADDR;
679 : : rdata = rd32_ephy(hw, addr);
680 : : set_fields_e56(&rdata, E56PHY_RXS_INTL_CONFIG_2_INTERLEAVER_HBW_DISABLE1, 0x0);
681 : : wr32_ephy(hw, addr, rdata);
682 : :
683 : : addr = E56PHY_RXS_TXFFE_TRAINING_0_ADDR;
684 : 0 : rdata = rd32_ephy(hw, addr);
685 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_0_ADC_DATA_PEAK_LTH, 0x56);
686 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_0_ADC_DATA_PEAK_UTH, 0x6a);
687 : : wr32_ephy(hw, addr, rdata);
688 : :
689 : : addr = E56PHY_RXS_TXFFE_TRAINING_1_ADDR;
690 : 0 : rdata = rd32_ephy(hw, addr);
691 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_1_C1_LTH, 0x1f8);
692 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_1_C1_UTH, 0xf0);
693 : : wr32_ephy(hw, addr, rdata);
694 : :
695 : : addr = E56PHY_RXS_TXFFE_TRAINING_2_ADDR;
696 : 0 : rdata = rd32_ephy(hw, addr);
697 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_2_CM1_LTH, 0x100);
698 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_2_CM1_UTH, 0xff);
699 : : wr32_ephy(hw, addr, rdata);
700 : :
701 : : addr = E56PHY_RXS_TXFFE_TRAINING_3_ADDR;
702 : 0 : rdata = rd32_ephy(hw, addr);
703 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_3_CM2_LTH, 0x4);
704 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_3_CM2_UTH, 0x37);
705 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_3_TXFFE_TRAIN_MOD_TYPE, 0x38);
706 : : wr32_ephy(hw, addr, rdata);
707 : :
708 : : addr = E56G__RXS0_FOM_18__ADDR;
709 : 0 : rdata = rd32_ephy(hw, addr);
710 : : set_fields_e56(&rdata, E56G__RXS0_FOM_18__DFE_COEFFL_HINT__MSB,
711 : : E56G__RXS0_FOM_18__DFE_COEFFL_HINT__LSB, 0x0);
712 : : /* change 0x90 to 0x0 to fix 25G link up keep when cable unplugged */
713 : : set_fields_e56(&rdata, E56G__RXS0_FOM_18__DFE_COEFFH_HINT__MSB,
714 : : E56G__RXS0_FOM_18__DFE_COEFFH_HINT__LSB, 0x0);
715 : : set_fields_e56(&rdata, E56G__RXS0_FOM_18__DFE_COEFF_HINT_LOAD__MSB,
716 : : E56G__RXS0_FOM_18__DFE_COEFF_HINT_LOAD__LSB, 0x1);
717 : : wr32_ephy(hw, addr, rdata);
718 : :
719 : : addr = E56PHY_RXS_VGA_TRAINING_0_ADDR;
720 : 0 : rdata = rd32_ephy(hw, addr);
721 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_0_VGA_TARGET, 0x34);
722 : : wr32_ephy(hw, addr, rdata);
723 : :
724 : : addr = E56PHY_RXS_VGA_TRAINING_1_ADDR;
725 : 0 : rdata = rd32_ephy(hw, addr);
726 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA1_CODE_INIT0, 0xa);
727 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA2_CODE_INIT0, 0xa);
728 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA1_CODE_INIT123, 0xa);
729 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA2_CODE_INIT123, 0xa);
730 : : wr32_ephy(hw, addr, rdata);
731 : :
732 : : addr = E56PHY_RXS_CTLE_TRAINING_0_ADDR;
733 : 0 : rdata = rd32_ephy(hw, addr);
734 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_0_CTLE_CODE_INIT0, 0x9);
735 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_0_CTLE_CODE_INIT123, 0x9);
736 : : wr32_ephy(hw, addr, rdata);
737 : :
738 : : addr = E56PHY_RXS_CTLE_TRAINING_1_ADDR;
739 : 0 : rdata = rd32_ephy(hw, addr);
740 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_1_LFEQ_LUT, 0x1ffffea);
741 : : wr32_ephy(hw, addr, rdata);
742 : :
743 : : addr = E56PHY_RXS_CTLE_TRAINING_2_ADDR;
744 : 0 : rdata = rd32_ephy(hw, addr);
745 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_2_ISI_TH_FRAC_P1,
746 : : S25G_PHY_RX_CTLE_TAP_FRACP1);
747 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_2_ISI_TH_FRAC_P2,
748 : : S25G_PHY_RX_CTLE_TAP_FRACP2);
749 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_2_ISI_TH_FRAC_P3,
750 : : S25G_PHY_RX_CTLE_TAP_FRACP3);
751 : : wr32_ephy(hw, addr, rdata);
752 : :
753 : : addr = E56PHY_RXS_CTLE_TRAINING_3_ADDR;
754 : 0 : rdata = rd32_ephy(hw, addr);
755 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_3_TAP_WEIGHT_P1,
756 : : S25G_PHY_RX_CTLE_TAPWT_WEIGHT1);
757 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_3_TAP_WEIGHT_P2,
758 : : S25G_PHY_RX_CTLE_TAPWT_WEIGHT2);
759 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_3_TAP_WEIGHT_P3,
760 : : S25G_PHY_RX_CTLE_TAPWT_WEIGHT3);
761 : : wr32_ephy(hw, addr, rdata);
762 : :
763 : : addr = E56PHY_RXS_OFFSET_N_GAIN_CAL_0_ADDR;
764 : 0 : rdata = rd32_ephy(hw, addr);
765 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_0_ADC_SLICE_DATA_AVG_CNT,
766 : : 0x3);
767 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_0_ADC_DATA_AVG_CNT, 0x3);
768 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_0_FE_OFFSET_DAC_CLK_CNT_X8,
769 : : 0xc);
770 : : wr32_ephy(hw, addr, rdata);
771 : :
772 : : addr = E56PHY_RXS_OFFSET_N_GAIN_CAL_1_ADDR;
773 : 0 : rdata = rd32_ephy(hw, addr);
774 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_1_SAMP_ADAPT_CFG, 0x5);
775 : : wr32_ephy(hw, addr, rdata);
776 : :
777 : : addr = E56PHY_RXS_FFE_TRAINING_0_ADDR;
778 : 0 : rdata = rd32_ephy(hw, addr);
779 : : set_fields_e56(&rdata, E56PHY_RXS_FFE_TRAINING_0_FFE_TAP_EN, 0xf9ff);
780 : : wr32_ephy(hw, addr, rdata);
781 : :
782 : : addr = E56PHY_RXS_IDLE_DETECT_1_ADDR;
783 : 0 : rdata = rd32_ephy(hw, addr);
784 : : set_fields_e56(&rdata, E56PHY_RXS_IDLE_DETECT_1_IDLE_TH_ADC_PEAK_MAX, 0xa);
785 : : set_fields_e56(&rdata, E56PHY_RXS_IDLE_DETECT_1_IDLE_TH_ADC_PEAK_MIN, 0x5);
786 : : wr32_ephy(hw, addr, rdata);
787 : :
788 : 0 : txgbe_e56_ephy_config(E56G__RXS3_ANA_OVRDVAL_11, ana_test_adc_clkgen_i, 0x0);
789 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDEN_2, ovrd_en_ana_test_adc_clkgen_i,
790 : : 0x0);
791 : :
792 : : addr = E56PHY_RXS_ANA_OVRDVAL_0_ADDR;
793 : : rdata = rd32_ephy(hw, addr);
794 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDVAL_0_ANA_EN_RTERM_I, 0x1);
795 : : wr32_ephy(hw, addr, rdata);
796 : :
797 : : rdata = 0x0000;
798 : : addr = E56PHY_RXS_ANA_OVRDEN_0_ADDR;
799 : : rdata = rd32_ephy(hw, addr);
800 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_0_OVRD_EN_ANA_EN_RTERM_I, 0x1);
801 : : wr32_ephy(hw, addr, rdata);
802 : :
803 : : addr = E56PHY_RXS_ANA_OVRDVAL_6_ADDR;
804 : 0 : rdata = rd32_ephy(hw, addr);
805 : : set_fields_e56(&rdata, 4, 0, 0x0);
806 : : set_fields_e56(&rdata, 14, 13, 0x0);
807 : : wr32_ephy(hw, addr, rdata);
808 : :
809 : : addr = E56PHY_RXS_ANA_OVRDEN_1_ADDR;
810 : : rdata = rd32_ephy(hw, addr);
811 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_1_OVRD_EN_ANA_BBCDR_VCOFILT_BYP_I,
812 : : 0x1);
813 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_1_OVRD_EN_ANA_TEST_BBCDR_I, 0x1);
814 : : wr32_ephy(hw, addr, rdata);
815 : :
816 : : addr = E56PHY_RXS_ANA_OVRDVAL_15_ADDR;
817 : 0 : rdata = rd32_ephy(hw, addr);
818 : : set_fields_e56(&rdata, 2, 0, 0x1);
819 : : wr32_ephy(hw, addr, rdata);
820 : :
821 : : addr = E56PHY_RXS_ANA_OVRDVAL_17_ADDR;
822 : 0 : rdata = rd32_ephy(hw, addr);
823 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDVAL_17_ANA_VGA2_BOOST_CSTM_I, 0x0);
824 : : wr32_ephy(hw, addr, rdata);
825 : :
826 : : addr = E56PHY_RXS_ANA_OVRDEN_3_ADDR;
827 : : rdata = rd32_ephy(hw, addr);
828 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_3_OVRD_EN_ANA_ANABS_CONFIG_I, 0x1);
829 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_3_OVRD_EN_ANA_VGA2_BOOST_CSTM_I,
830 : : 0x1);
831 : : wr32_ephy(hw, addr, rdata);
832 : :
833 : : addr = E56PHY_RXS_ANA_OVRDVAL_14_ADDR;
834 : : rdata = rd32_ephy(hw, addr);
835 : : set_fields_e56(&rdata, 13, 13, 0x0);
836 : : wr32_ephy(hw, addr, rdata);
837 : :
838 : : addr = E56PHY_RXS_ANA_OVRDEN_4_ADDR;
839 : : rdata = rd32_ephy(hw, addr);
840 : : set_fields_e56(&rdata, 13, 13, 0x1);
841 : : wr32_ephy(hw, addr, rdata);
842 : :
843 : : addr = E56PHY_RXS_EYE_SCAN_1_ADDR;
844 : 0 : rdata = rd32_ephy(hw, addr);
845 : : set_fields_e56(&rdata, E56PHY_RXS_EYE_SCAN_1_EYE_SCAN_REF_TIMER, 0x400);
846 : : wr32_ephy(hw, addr, rdata);
847 : :
848 : : addr = E56PHY_RXS_RINGO_0_ADDR;
849 : 0 : rdata = rd32_ephy(hw, addr);
850 : : set_fields_e56(&rdata, 21, 12, 0x366);
851 : : wr32_ephy(hw, addr, rdata);
852 : :
853 : : addr = E56PHY_PMD_CFG_3_ADDR;
854 : 0 : rdata = rd32_ephy(hw, addr);
855 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_3_CTRL_FSM_TIMEOUT_X64K, 0x80);
856 : : wr32_ephy(hw, addr, rdata);
857 : :
858 : : addr = E56PHY_PMD_CFG_4_ADDR;
859 : 0 : rdata = rd32_ephy(hw, addr);
860 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_4_TRAIN_DC_ON_PERIOD_X64K, 0x18);
861 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_4_TRAIN_DC_PERIOD_X512K, 0x3e);
862 : : wr32_ephy(hw, addr, rdata);
863 : :
864 : : addr = E56PHY_PMD_CFG_5_ADDR;
865 : : rdata = rd32_ephy(hw, addr);
866 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_5_USE_RECENT_MARKER_OFFSET, 0x1);
867 : : wr32_ephy(hw, addr, rdata);
868 : :
869 : : addr = E56PHY_CTRL_FSM_CFG_0_ADDR;
870 : : rdata = rd32_ephy(hw, addr);
871 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_0_CONT_ON_ADC_GAIN_CAL_ERR, 0x1);
872 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_0_DO_RX_ADC_OFST_CAL, 0x3);
873 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_0_RX_ERR_ACTION_EN, 0x40);
874 : : wr32_ephy(hw, addr, rdata);
875 : :
876 : : addr = E56PHY_CTRL_FSM_CFG_1_ADDR;
877 : 0 : rdata = rd32_ephy(hw, addr);
878 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST0_WAIT_CNT_X4096, 0xff);
879 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST1_WAIT_CNT_X4096, 0xff);
880 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST2_WAIT_CNT_X4096, 0xff);
881 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST3_WAIT_CNT_X4096, 0xff);
882 : : wr32_ephy(hw, addr, rdata);
883 : :
884 : : addr = E56PHY_CTRL_FSM_CFG_2_ADDR;
885 : 0 : rdata = rd32_ephy(hw, addr);
886 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST4_WAIT_CNT_X4096, 0x1);
887 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST5_WAIT_CNT_X4096, 0x4);
888 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST6_WAIT_CNT_X4096, 0x4);
889 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST7_WAIT_CNT_X4096, 0x4);
890 : : wr32_ephy(hw, addr, rdata);
891 : :
892 : : addr = E56PHY_CTRL_FSM_CFG_3_ADDR;
893 : 0 : rdata = rd32_ephy(hw, addr);
894 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST8_WAIT_CNT_X4096, 0x4);
895 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST9_WAIT_CNT_X4096, 0x4);
896 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST10_WAIT_CNT_X4096, 0x4);
897 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST11_WAIT_CNT_X4096, 0x4);
898 : : wr32_ephy(hw, addr, rdata);
899 : :
900 : : addr = E56PHY_CTRL_FSM_CFG_4_ADDR;
901 : 0 : rdata = rd32_ephy(hw, addr);
902 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST12_WAIT_CNT_X4096, 0x4);
903 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST13_WAIT_CNT_X4096, 0x4);
904 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST14_WAIT_CNT_X4096, 0x4);
905 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST15_WAIT_CNT_X4096, 0x4);
906 : : wr32_ephy(hw, addr, rdata);
907 : :
908 : : addr = E56PHY_CTRL_FSM_CFG_7_ADDR;
909 : 0 : rdata = rd32_ephy(hw, addr);
910 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_7_TRAIN_ST4_EN, 0x4bf);
911 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_7_TRAIN_ST5_EN, 0xc4bf);
912 : : wr32_ephy(hw, addr, rdata);
913 : :
914 : : addr = E56PHY_CTRL_FSM_CFG_8_ADDR;
915 : 0 : rdata = rd32_ephy(hw, addr);
916 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_8_TRAIN_ST7_EN, 0x47ff);
917 : : wr32_ephy(hw, addr, rdata);
918 : :
919 : : addr = E56PHY_CTRL_FSM_CFG_12_ADDR;
920 : 0 : rdata = rd32_ephy(hw, addr);
921 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_12_TRAIN_ST15_EN, 0x67ff);
922 : : wr32_ephy(hw, addr, rdata);
923 : :
924 : : addr = E56PHY_CTRL_FSM_CFG_13_ADDR;
925 : 0 : rdata = rd32_ephy(hw, addr);
926 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_13_TRAIN_ST0_DONE_EN, 0x8001);
927 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_13_TRAIN_ST1_DONE_EN, 0x8002);
928 : : wr32_ephy(hw, addr, rdata);
929 : :
930 : : addr = E56PHY_CTRL_FSM_CFG_14_ADDR;
931 : 0 : rdata = rd32_ephy(hw, addr);
932 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_14_TRAIN_ST3_DONE_EN, 0x8008);
933 : : wr32_ephy(hw, addr, rdata);
934 : :
935 : : addr = E56PHY_CTRL_FSM_CFG_15_ADDR;
936 : 0 : rdata = rd32_ephy(hw, addr);
937 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_15_TRAIN_ST4_DONE_EN, 0x8004);
938 : : wr32_ephy(hw, addr, rdata);
939 : :
940 : : addr = E56PHY_CTRL_FSM_CFG_17_ADDR;
941 : 0 : rdata = rd32_ephy(hw, addr);
942 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_17_TRAIN_ST8_DONE_EN, 0x20c0);
943 : : wr32_ephy(hw, addr, rdata);
944 : :
945 : : addr = E56PHY_CTRL_FSM_CFG_18_ADDR;
946 : 0 : rdata = rd32_ephy(hw, addr);
947 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_18_TRAIN_ST10_DONE_EN, 0x0);
948 : : wr32_ephy(hw, addr, rdata);
949 : :
950 : : addr = E56PHY_CTRL_FSM_CFG_29_ADDR;
951 : 0 : rdata = rd32_ephy(hw, addr);
952 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_29_TRAIN_ST15_DC_EN, 0x3f6d);
953 : : wr32_ephy(hw, addr, rdata);
954 : :
955 : : addr = E56PHY_CTRL_FSM_CFG_33_ADDR;
956 : 0 : rdata = rd32_ephy(hw, addr);
957 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_33_TRAIN0_RATE_SEL, 0x8000);
958 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_33_TRAIN1_RATE_SEL, 0x8000);
959 : : wr32_ephy(hw, addr, rdata);
960 : :
961 : : addr = E56PHY_CTRL_FSM_CFG_34_ADDR;
962 : 0 : rdata = rd32_ephy(hw, addr);
963 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_34_TRAIN2_RATE_SEL, 0x8000);
964 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_34_TRAIN3_RATE_SEL, 0x8000);
965 : : wr32_ephy(hw, addr, rdata);
966 : :
967 : : addr = E56PHY_KRT_TFSM_CFG_ADDR;
968 : 0 : rdata = rd32_ephy(hw, addr);
969 : : set_fields_e56(&rdata, E56PHY_KRT_TFSM_CFGKRT_TFSM_MAX_WAIT_TIMER_X1000K, 0x49);
970 : : set_fields_e56(&rdata, E56PHY_KRT_TFSM_CFGKRT_TFSM_MAX_WAIT_TIMER_X8000K, 0x37);
971 : : set_fields_e56(&rdata, E56PHY_KRT_TFSM_CFGKRT_TFSM_HOLDOFF_TIMER_X256K, 0x2f);
972 : : wr32_ephy(hw, addr, rdata);
973 : :
974 : : addr = E56PHY_FETX_FFE_TRAIN_CFG_0_ADDR;
975 : 0 : rdata = rd32_ephy(hw, addr);
976 : : set_fields_e56(&rdata, E56PHY_FETX_FFE_TRAIN_CFG_0_KRT_FETX_INIT_FFE_CFG_2,
977 : : 0x2);
978 : : wr32_ephy(hw, addr, rdata);
979 : :
980 : 0 : return 0;
981 : : }
982 : :
983 : : u32
984 : 0 : txgbe_e56_cfg_10g(struct txgbe_hw *hw)
985 : : {
986 : : u32 addr;
987 : : u32 rdata = 0;
988 : :
989 : : addr = E56G_CMS_ANA_OVRDVAL_7_ADDR;
990 : 0 : rdata = rd32_ephy(hw, addr);
991 : 0 : ((E56G_CMS_ANA_OVRDVAL_7 *)&rdata)->ana_lcpll_lf_vco_swing_ctrl_i = 0xf;
992 : 0 : wr32_ephy(hw, addr, rdata);
993 : :
994 : : addr = E56G_CMS_ANA_OVRDEN_1_ADDR;
995 : 0 : rdata = rd32_ephy(hw, addr);
996 : 0 : ((E56G_CMS_ANA_OVRDEN_1 *)&rdata)->ovrd_en_ana_lcpll_lf_vco_swing_ctrl_i = 0x1;
997 : 0 : wr32_ephy(hw, addr, rdata);
998 : :
999 : : addr = E56G_CMS_ANA_OVRDVAL_9_ADDR;
1000 : 0 : rdata = rd32_ephy(hw, addr);
1001 : : set_fields_e56(&rdata, 23, 0, 0x260000);
1002 : : wr32_ephy(hw, addr, rdata);
1003 : :
1004 : : addr = E56G_CMS_ANA_OVRDEN_1_ADDR;
1005 : 0 : rdata = rd32_ephy(hw, addr);
1006 : 0 : ((E56G_CMS_ANA_OVRDEN_1 *)&rdata)->ovrd_en_ana_lcpll_lf_test_in_i = 0x1;
1007 : 0 : wr32_ephy(hw, addr, rdata);
1008 : :
1009 : : addr = E56PHY_TXS_TXS_CFG_1_ADDR;
1010 : 0 : rdata = rd32_ephy(hw, addr);
1011 : : set_fields_e56(&rdata, E56PHY_TXS_TXS_CFG_1_ADAPTATION_WAIT_CNT_X256, 0xf);
1012 : : wr32_ephy(hw, addr, rdata);
1013 : :
1014 : : addr = E56PHY_TXS_WKUP_CNT_ADDR;
1015 : 0 : rdata = rd32_ephy(hw, addr);
1016 : : set_fields_e56(&rdata, E56PHY_TXS_WKUP_CNTLDO_WKUP_CNT_X32, 0xff);
1017 : : set_fields_e56(&rdata, E56PHY_TXS_WKUP_CNTDCC_WKUP_CNT_X32, 0xff);
1018 : : wr32_ephy(hw, addr, rdata);
1019 : :
1020 : : addr = E56PHY_TXS_PIN_OVRDVAL_6_ADDR;
1021 : 0 : rdata = rd32_ephy(hw, addr);
1022 : : set_fields_e56(&rdata, 19, 16, 0x6);
1023 : : wr32_ephy(hw, addr, rdata);
1024 : :
1025 : : addr = E56PHY_TXS_PIN_OVRDEN_0_ADDR;
1026 : : rdata = rd32_ephy(hw, addr);
1027 : : set_fields_e56(&rdata, E56PHY_TXS_PIN_OVRDEN_0_OVRD_EN_TX0_EFUSE_BITS_I, 0x1);
1028 : : wr32_ephy(hw, addr, rdata);
1029 : :
1030 : : addr = E56PHY_TXS_ANA_OVRDVAL_1_ADDR;
1031 : 0 : rdata = rd32_ephy(hw, addr);
1032 : : set_fields_e56(&rdata, E56PHY_TXS_ANA_OVRDVAL_1_ANA_TEST_DAC_I, 0x1);
1033 : : wr32_ephy(hw, addr, rdata);
1034 : :
1035 : : addr = E56PHY_TXS_ANA_OVRDEN_0_ADDR;
1036 : : rdata = rd32_ephy(hw, addr);
1037 : : set_fields_e56(&rdata, E56PHY_TXS_ANA_OVRDEN_0_OVRD_EN_ANA_TEST_DAC_I, 0x1);
1038 : : wr32_ephy(hw, addr, rdata);
1039 : :
1040 : : /* Setting TX FFE */
1041 : 0 : txgbe_e56_tx_ffe_cfg(hw, TXGBE_LINK_SPEED_10GB_FULL);
1042 : :
1043 : : addr = E56PHY_RXS_RXS_CFG_0_ADDR;
1044 : : rdata = rd32_ephy(hw, addr);
1045 : : set_fields_e56(&rdata, E56PHY_RXS_RXS_CFG_0_DSER_DATA_SEL, 0x0);
1046 : : set_fields_e56(&rdata, E56PHY_RXS_RXS_CFG_0_TRAIN_CLK_GATE_BYPASS_EN, 0x1fff);
1047 : : wr32_ephy(hw, addr, rdata);
1048 : :
1049 : : addr = E56PHY_RXS_OSC_CAL_N_CDR_1_ADDR;
1050 : : rdata = rd32_ephy(hw, addr);
1051 : : ((E56G_RXS0_OSC_CAL_N_CDR_0 *)&rdata)->prediv0 = 0xfa0;
1052 : : ((E56G_RXS0_OSC_CAL_N_CDR_0 *)&rdata)->target_cnt0 = 0x203a;
1053 : : wr32_ephy(hw, addr, rdata);
1054 : :
1055 : : addr = E56PHY_RXS_OSC_CAL_N_CDR_4_ADDR;
1056 : 0 : rdata = rd32_ephy(hw, addr);
1057 : 0 : ((E56G_RXS0_OSC_CAL_N_CDR_4 *)&rdata)->osc_range_sel0 = 0x2;
1058 : 0 : ((E56G_RXS0_OSC_CAL_N_CDR_4 *)&rdata)->vco_code_init = 0x7ff;
1059 : 0 : ((E56G_RXS0_OSC_CAL_N_CDR_4 *)&rdata)->osc_current_boost_en0 = 0x1;
1060 : 0 : ((E56G_RXS0_OSC_CAL_N_CDR_4 *)&rdata)->bbcdr_current_boost0 = 0x0;
1061 : 0 : wr32_ephy(hw, addr, rdata);
1062 : :
1063 : : addr = E56PHY_RXS_OSC_CAL_N_CDR_5_ADDR;
1064 : 0 : rdata = rd32_ephy(hw, addr);
1065 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_SDM_WIDTH, 0x3);
1066 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_PROP_STEP_PRELOCK,
1067 : : 0xf);
1068 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_PROP_STEP_POSTLOCK,
1069 : : 0xf);
1070 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_GAIN_CTRL_POSTLOCK,
1071 : : 0xc);
1072 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BB_CDR_GAIN_CTRL_PRELOCK,
1073 : : 0xf);
1074 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_5_BBCDR_RDY_CNT, 0x3);
1075 : : wr32_ephy(hw, addr, rdata);
1076 : :
1077 : : addr = E56PHY_RXS_OSC_CAL_N_CDR_6_ADDR;
1078 : 0 : rdata = rd32_ephy(hw, addr);
1079 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_6_PI_GAIN_CTRL_PRELOCK, 0x7);
1080 : : set_fields_e56(&rdata, E56PHY_RXS_OSC_CAL_N_CDR_6_PI_GAIN_CTRL_POSTLOCK, 0x5);
1081 : : wr32_ephy(hw, addr, rdata);
1082 : :
1083 : : addr = E56PHY_RXS_INTL_CONFIG_0_ADDR;
1084 : 0 : rdata = rd32_ephy(hw, addr);
1085 : 0 : ((E56G_RXS0_INTL_CONFIG_0 *)&rdata)->adc_intl2slice_delay0 = 0x5555;
1086 : 0 : wr32_ephy(hw, addr, rdata);
1087 : :
1088 : : addr = E56PHY_RXS_INTL_CONFIG_2_ADDR;
1089 : 0 : rdata = rd32_ephy(hw, addr);
1090 : 0 : ((E56G_RXS0_INTL_CONFIG_2 *)&rdata)->interleaver_hbw_disable0 = 0x1;
1091 : 0 : wr32_ephy(hw, addr, rdata);
1092 : :
1093 : : rdata = 0x0000;
1094 : : addr = E56PHY_RXS_TXFFE_TRAINING_0_ADDR;
1095 : 0 : rdata = rd32_ephy(hw, addr);
1096 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_0_ADC_DATA_PEAK_LTH, 0x56);
1097 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_0_ADC_DATA_PEAK_UTH, 0x6a);
1098 : : wr32_ephy(hw, addr, rdata);
1099 : :
1100 : : rdata = 0x0000;
1101 : : addr = E56PHY_RXS_TXFFE_TRAINING_1_ADDR;
1102 : 0 : rdata = rd32_ephy(hw, addr);
1103 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_1_C1_LTH, 0x1e8);
1104 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_1_C1_UTH, 0x78);
1105 : : wr32_ephy(hw, addr, rdata);
1106 : :
1107 : : rdata = 0x0000;
1108 : : addr = E56PHY_RXS_TXFFE_TRAINING_2_ADDR;
1109 : 0 : rdata = rd32_ephy(hw, addr);
1110 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_2_CM1_LTH, 0x100);
1111 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_2_CM1_UTH, 0xff);
1112 : : wr32_ephy(hw, addr, rdata);
1113 : :
1114 : : rdata = 0x0000;
1115 : : addr = E56PHY_RXS_TXFFE_TRAINING_3_ADDR;
1116 : 0 : rdata = rd32_ephy(hw, addr);
1117 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_3_CM2_LTH, 0x4);
1118 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_3_CM2_UTH, 0x37);
1119 : : set_fields_e56(&rdata, E56PHY_RXS_TXFFE_TRAINING_3_TXFFE_TRAIN_MOD_TYPE, 0x38);
1120 : : wr32_ephy(hw, addr, rdata);
1121 : :
1122 : : rdata = 0x0000;
1123 : : addr = E56PHY_RXS_VGA_TRAINING_0_ADDR;
1124 : 0 : rdata = rd32_ephy(hw, addr);
1125 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_0_VGA_TARGET, 0x34);
1126 : : wr32_ephy(hw, addr, rdata);
1127 : :
1128 : : rdata = 0x0000;
1129 : : addr = E56PHY_RXS_VGA_TRAINING_1_ADDR;
1130 : 0 : rdata = rd32_ephy(hw, addr);
1131 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA1_CODE_INIT0, 0xa);
1132 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA2_CODE_INIT0, 0xa);
1133 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA1_CODE_INIT123, 0xa);
1134 : : set_fields_e56(&rdata, E56PHY_RXS_VGA_TRAINING_1_VGA2_CODE_INIT123, 0xa);
1135 : : wr32_ephy(hw, addr, rdata);
1136 : :
1137 : : addr = E56PHY_RXS_CTLE_TRAINING_0_ADDR;
1138 : 0 : rdata = rd32_ephy(hw, addr);
1139 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_0_CTLE_CODE_INIT0, 0x9);
1140 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_0_CTLE_CODE_INIT123, 0x9);
1141 : : wr32_ephy(hw, addr, rdata);
1142 : :
1143 : : addr = E56PHY_RXS_CTLE_TRAINING_1_ADDR;
1144 : 0 : rdata = rd32_ephy(hw, addr);
1145 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_1_LFEQ_LUT, 0x1ffffea);
1146 : : wr32_ephy(hw, addr, rdata);
1147 : :
1148 : : addr = E56PHY_RXS_CTLE_TRAINING_2_ADDR;
1149 : 0 : rdata = rd32_ephy(hw, addr);
1150 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_2_ISI_TH_FRAC_P1,
1151 : : S10G_PHY_RX_CTLE_TAP_FRACP1);
1152 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_2_ISI_TH_FRAC_P2,
1153 : : S10G_PHY_RX_CTLE_TAP_FRACP2);
1154 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_2_ISI_TH_FRAC_P3,
1155 : : S10G_PHY_RX_CTLE_TAP_FRACP3);
1156 : : wr32_ephy(hw, addr, rdata);
1157 : :
1158 : : addr = E56PHY_RXS_CTLE_TRAINING_3_ADDR;
1159 : 0 : rdata = rd32_ephy(hw, addr);
1160 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_3_TAP_WEIGHT_P1,
1161 : : S10G_PHY_RX_CTLE_TAPWT_WEIGHT1);
1162 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_3_TAP_WEIGHT_P2,
1163 : : S10G_PHY_RX_CTLE_TAPWT_WEIGHT2);
1164 : : set_fields_e56(&rdata, E56PHY_RXS_CTLE_TRAINING_3_TAP_WEIGHT_P3,
1165 : : S10G_PHY_RX_CTLE_TAPWT_WEIGHT3);
1166 : : wr32_ephy(hw, addr, rdata);
1167 : :
1168 : : addr = E56PHY_RXS_OFFSET_N_GAIN_CAL_0_ADDR;
1169 : 0 : rdata = rd32_ephy(hw, addr);
1170 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_0_ADC_SLICE_DATA_AVG_CNT,
1171 : : 0x3);
1172 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_0_ADC_DATA_AVG_CNT, 0x3);
1173 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_0_FE_OFFSET_DAC_CLK_CNT_X8,
1174 : : 0xc);
1175 : : wr32_ephy(hw, addr, rdata);
1176 : :
1177 : : addr = E56PHY_RXS_OFFSET_N_GAIN_CAL_1_ADDR;
1178 : 0 : rdata = rd32_ephy(hw, addr);
1179 : : set_fields_e56(&rdata, E56PHY_RXS_OFFSET_N_GAIN_CAL_1_SAMP_ADAPT_CFG, 0x5);
1180 : : wr32_ephy(hw, addr, rdata);
1181 : :
1182 : : addr = E56PHY_RXS_FFE_TRAINING_0_ADDR;
1183 : 0 : rdata = rd32_ephy(hw, addr);
1184 : : set_fields_e56(&rdata, E56PHY_RXS_FFE_TRAINING_0_FFE_TAP_EN, 0xf9ff);
1185 : : wr32_ephy(hw, addr, rdata);
1186 : :
1187 : : addr = E56PHY_RXS_IDLE_DETECT_1_ADDR;
1188 : 0 : rdata = rd32_ephy(hw, addr);
1189 : : set_fields_e56(&rdata, E56PHY_RXS_IDLE_DETECT_1_IDLE_TH_ADC_PEAK_MAX, 0xa);
1190 : : set_fields_e56(&rdata, E56PHY_RXS_IDLE_DETECT_1_IDLE_TH_ADC_PEAK_MIN, 0x5);
1191 : : wr32_ephy(hw, addr, rdata);
1192 : :
1193 : 0 : txgbe_e56_ephy_config(E56G__RXS3_ANA_OVRDVAL_11, ana_test_adc_clkgen_i, 0x0);
1194 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDEN_2, ovrd_en_ana_test_adc_clkgen_i,
1195 : : 0x0);
1196 : :
1197 : : addr = E56PHY_RXS_ANA_OVRDVAL_0_ADDR;
1198 : : rdata = rd32_ephy(hw, addr);
1199 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDVAL_0_ANA_EN_RTERM_I, 0x1);
1200 : : wr32_ephy(hw, addr, rdata);
1201 : :
1202 : : addr = E56PHY_RXS_ANA_OVRDEN_0_ADDR;
1203 : : rdata = rd32_ephy(hw, addr);
1204 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_0_OVRD_EN_ANA_EN_RTERM_I, 0x1);
1205 : : wr32_ephy(hw, addr, rdata);
1206 : :
1207 : : addr = E56PHY_RXS_ANA_OVRDVAL_6_ADDR;
1208 : 0 : rdata = rd32_ephy(hw, addr);
1209 : : set_fields_e56(&rdata, 4, 0, 0x6);
1210 : : set_fields_e56(&rdata, 14, 13, 0x2);
1211 : : wr32_ephy(hw, addr, rdata);
1212 : :
1213 : : addr = E56PHY_RXS_ANA_OVRDEN_1_ADDR;
1214 : : rdata = rd32_ephy(hw, addr);
1215 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_1_OVRD_EN_ANA_BBCDR_VCOFILT_BYP_I,
1216 : : 0x1);
1217 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_1_OVRD_EN_ANA_TEST_BBCDR_I, 0x1);
1218 : : wr32_ephy(hw, addr, rdata);
1219 : :
1220 : : addr = E56PHY_RXS_ANA_OVRDVAL_15_ADDR;
1221 : 0 : rdata = rd32_ephy(hw, addr);
1222 : : set_fields_e56(&rdata, 2, 0, 0x1);
1223 : : wr32_ephy(hw, addr, rdata);
1224 : :
1225 : : addr = E56PHY_RXS_ANA_OVRDVAL_17_ADDR;
1226 : 0 : rdata = rd32_ephy(hw, addr);
1227 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDVAL_17_ANA_VGA2_BOOST_CSTM_I, 0x0);
1228 : : wr32_ephy(hw, addr, rdata);
1229 : :
1230 : : addr = E56PHY_RXS_ANA_OVRDEN_3_ADDR;
1231 : : rdata = rd32_ephy(hw, addr);
1232 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_3_OVRD_EN_ANA_ANABS_CONFIG_I, 0x1);
1233 : : set_fields_e56(&rdata, E56PHY_RXS_ANA_OVRDEN_3_OVRD_EN_ANA_VGA2_BOOST_CSTM_I,
1234 : : 0x1);
1235 : : wr32_ephy(hw, addr, rdata);
1236 : :
1237 : : addr = E56PHY_RXS_ANA_OVRDVAL_14_ADDR;
1238 : : rdata = rd32_ephy(hw, addr);
1239 : : set_fields_e56(&rdata, 13, 13, 0x1);
1240 : : wr32_ephy(hw, addr, rdata);
1241 : :
1242 : : addr = E56PHY_RXS_ANA_OVRDEN_4_ADDR;
1243 : : rdata = rd32_ephy(hw, addr);
1244 : : set_fields_e56(&rdata, 13, 13, 0x1);
1245 : : wr32_ephy(hw, addr, rdata);
1246 : :
1247 : : addr = E56PHY_RXS_EYE_SCAN_1_ADDR;
1248 : 0 : rdata = rd32_ephy(hw, addr);
1249 : : set_fields_e56(&rdata, E56PHY_RXS_EYE_SCAN_1_EYE_SCAN_REF_TIMER, 0x400);
1250 : : wr32_ephy(hw, addr, rdata);
1251 : :
1252 : : addr = E56PHY_RXS_RINGO_0_ADDR;
1253 : 0 : rdata = rd32_ephy(hw, addr);
1254 : : set_fields_e56(&rdata, 9, 4, 0x366);
1255 : : wr32_ephy(hw, addr, rdata);
1256 : :
1257 : : addr = E56PHY_PMD_CFG_3_ADDR;
1258 : 0 : rdata = rd32_ephy(hw, addr);
1259 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_3_CTRL_FSM_TIMEOUT_X64K, 0x80);
1260 : : wr32_ephy(hw, addr, rdata);
1261 : :
1262 : : addr = E56PHY_PMD_CFG_4_ADDR;
1263 : 0 : rdata = rd32_ephy(hw, addr);
1264 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_4_TRAIN_DC_ON_PERIOD_X64K, 0x18);
1265 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_4_TRAIN_DC_PERIOD_X512K, 0x3e);
1266 : : wr32_ephy(hw, addr, rdata);
1267 : :
1268 : : addr = E56PHY_PMD_CFG_5_ADDR;
1269 : : rdata = rd32_ephy(hw, addr);
1270 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_5_USE_RECENT_MARKER_OFFSET, 0x1);
1271 : : wr32_ephy(hw, addr, rdata);
1272 : :
1273 : : addr = E56PHY_CTRL_FSM_CFG_0_ADDR;
1274 : : rdata = rd32_ephy(hw, addr);
1275 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_0_CONT_ON_ADC_GAIN_CAL_ERR, 0x1);
1276 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_0_DO_RX_ADC_OFST_CAL, 0x3);
1277 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_0_RX_ERR_ACTION_EN, 0x40);
1278 : : wr32_ephy(hw, addr, rdata);
1279 : :
1280 : : addr = E56PHY_CTRL_FSM_CFG_1_ADDR;
1281 : 0 : rdata = rd32_ephy(hw, addr);
1282 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST0_WAIT_CNT_X4096, 0xff);
1283 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST1_WAIT_CNT_X4096, 0xff);
1284 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST2_WAIT_CNT_X4096, 0xff);
1285 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_1_TRAIN_ST3_WAIT_CNT_X4096, 0xff);
1286 : : wr32_ephy(hw, addr, rdata);
1287 : :
1288 : : addr = E56PHY_CTRL_FSM_CFG_2_ADDR;
1289 : 0 : rdata = rd32_ephy(hw, addr);
1290 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST4_WAIT_CNT_X4096, 0x1);
1291 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST5_WAIT_CNT_X4096, 0x4);
1292 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST6_WAIT_CNT_X4096, 0x4);
1293 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_2_TRAIN_ST7_WAIT_CNT_X4096, 0x4);
1294 : : wr32_ephy(hw, addr, rdata);
1295 : :
1296 : : addr = E56PHY_CTRL_FSM_CFG_3_ADDR;
1297 : 0 : rdata = rd32_ephy(hw, addr);
1298 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST8_WAIT_CNT_X4096, 0x4);
1299 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST9_WAIT_CNT_X4096, 0x4);
1300 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST10_WAIT_CNT_X4096, 0x4);
1301 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_3_TRAIN_ST11_WAIT_CNT_X4096, 0x4);
1302 : : wr32_ephy(hw, addr, rdata);
1303 : :
1304 : : addr = E56PHY_CTRL_FSM_CFG_4_ADDR;
1305 : 0 : rdata = rd32_ephy(hw, addr);
1306 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST12_WAIT_CNT_X4096, 0x4);
1307 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST13_WAIT_CNT_X4096, 0x4);
1308 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST14_WAIT_CNT_X4096, 0x4);
1309 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_4_TRAIN_ST15_WAIT_CNT_X4096, 0x4);
1310 : : wr32_ephy(hw, addr, rdata);
1311 : :
1312 : : addr = E56PHY_CTRL_FSM_CFG_7_ADDR;
1313 : 0 : rdata = rd32_ephy(hw, addr);
1314 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_7_TRAIN_ST4_EN, 0x4bf);
1315 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_7_TRAIN_ST5_EN, 0xc4bf);
1316 : : wr32_ephy(hw, addr, rdata);
1317 : :
1318 : : addr = E56PHY_CTRL_FSM_CFG_8_ADDR;
1319 : 0 : rdata = rd32_ephy(hw, addr);
1320 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_8_TRAIN_ST7_EN, 0x47ff);
1321 : : wr32_ephy(hw, addr, rdata);
1322 : :
1323 : : addr = E56PHY_CTRL_FSM_CFG_12_ADDR;
1324 : 0 : rdata = rd32_ephy(hw, addr);
1325 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_12_TRAIN_ST15_EN, 0x67ff);
1326 : : wr32_ephy(hw, addr, rdata);
1327 : :
1328 : : addr = E56PHY_CTRL_FSM_CFG_13_ADDR;
1329 : 0 : rdata = rd32_ephy(hw, addr);
1330 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_13_TRAIN_ST0_DONE_EN, 0x8001);
1331 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_13_TRAIN_ST1_DONE_EN, 0x8002);
1332 : : wr32_ephy(hw, addr, rdata);
1333 : :
1334 : : addr = E56PHY_CTRL_FSM_CFG_14_ADDR;
1335 : 0 : rdata = rd32_ephy(hw, addr);
1336 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_14_TRAIN_ST3_DONE_EN, 0x8008);
1337 : : wr32_ephy(hw, addr, rdata);
1338 : :
1339 : : addr = E56PHY_CTRL_FSM_CFG_15_ADDR;
1340 : 0 : rdata = rd32_ephy(hw, addr);
1341 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_15_TRAIN_ST4_DONE_EN, 0x8004);
1342 : : wr32_ephy(hw, addr, rdata);
1343 : :
1344 : : addr = E56PHY_CTRL_FSM_CFG_17_ADDR;
1345 : 0 : rdata = rd32_ephy(hw, addr);
1346 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_17_TRAIN_ST8_DONE_EN, 0x20c0);
1347 : : wr32_ephy(hw, addr, rdata);
1348 : :
1349 : : addr = E56PHY_CTRL_FSM_CFG_18_ADDR;
1350 : 0 : rdata = rd32_ephy(hw, addr);
1351 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_18_TRAIN_ST10_DONE_EN, 0x0);
1352 : : wr32_ephy(hw, addr, rdata);
1353 : :
1354 : : addr = E56PHY_CTRL_FSM_CFG_29_ADDR;
1355 : 0 : rdata = rd32_ephy(hw, addr);
1356 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_29_TRAIN_ST15_DC_EN, 0x3f6d);
1357 : : wr32_ephy(hw, addr, rdata);
1358 : :
1359 : : addr = E56PHY_CTRL_FSM_CFG_33_ADDR;
1360 : 0 : rdata = rd32_ephy(hw, addr);
1361 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_33_TRAIN0_RATE_SEL, 0x8000);
1362 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_33_TRAIN1_RATE_SEL, 0x8000);
1363 : : wr32_ephy(hw, addr, rdata);
1364 : :
1365 : : addr = E56PHY_CTRL_FSM_CFG_34_ADDR;
1366 : 0 : rdata = rd32_ephy(hw, addr);
1367 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_34_TRAIN2_RATE_SEL, 0x8000);
1368 : : set_fields_e56(&rdata, E56PHY_CTRL_FSM_CFG_34_TRAIN3_RATE_SEL, 0x8000);
1369 : : wr32_ephy(hw, addr, rdata);
1370 : :
1371 : : addr = E56PHY_KRT_TFSM_CFG_ADDR;
1372 : 0 : rdata = rd32_ephy(hw, addr);
1373 : : set_fields_e56(&rdata, E56PHY_KRT_TFSM_CFGKRT_TFSM_MAX_WAIT_TIMER_X1000K, 0x49);
1374 : : set_fields_e56(&rdata, E56PHY_KRT_TFSM_CFGKRT_TFSM_MAX_WAIT_TIMER_X8000K, 0x37);
1375 : : set_fields_e56(&rdata, E56PHY_KRT_TFSM_CFGKRT_TFSM_HOLDOFF_TIMER_X256K, 0x2f);
1376 : : wr32_ephy(hw, addr, rdata);
1377 : :
1378 : : addr = E56PHY_FETX_FFE_TRAIN_CFG_0_ADDR;
1379 : 0 : rdata = rd32_ephy(hw, addr);
1380 : : set_fields_e56(&rdata, E56PHY_FETX_FFE_TRAIN_CFG_0_KRT_FETX_INIT_FFE_CFG_2,
1381 : : 0x2);
1382 : : wr32_ephy(hw, addr, rdata);
1383 : :
1384 : 0 : return 0;
1385 : : }
1386 : :
1387 : : static inline int
1388 : 0 : txgbe_e56_rxs_osc_init_for_temp_track_range(struct txgbe_hw *hw, u32 speed)
1389 : : {
1390 : : int status = 0;
1391 : : unsigned int addr, rdata, timer;
1392 : 0 : int T = 40;
1393 : : int RX_COARSE_MID_TD, CMVAR_RANGE_H = 0, CMVAR_RANGE_L = 0;
1394 : : int OFFSET_CENTRE_RANGE_H, OFFSET_CENTRE_RANGE_L, RANGE_FINAL;
1395 : : int i = 0;
1396 : : int lane_num = 1;
1397 : : /* 1. Read the temperature T just before RXS is enabled. */
1398 : 0 : txgbe_e56_get_temp(hw, &T);
1399 : :
1400 : : /*
1401 : : * 2. Define software variable RX_COARSE_MID_TD
1402 : : * (RX Coarse Code mid value dependent upon temperature)
1403 : : */
1404 [ # # ]: 0 : if (T < -5)
1405 : : RX_COARSE_MID_TD = 10;
1406 [ # # ]: 0 : else if (T < 30)
1407 : : RX_COARSE_MID_TD = 9;
1408 [ # # ]: 0 : else if (T < 65)
1409 : : RX_COARSE_MID_TD = 8;
1410 [ # # ]: 0 : else if (T < 100)
1411 : : RX_COARSE_MID_TD = 7;
1412 : : else
1413 : : RX_COARSE_MID_TD = 6;
1414 : :
1415 : : /* Set CMVAR_RANGE_H/L based on the link speed mode */
1416 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_10GB_FULL || speed == TXGBE_LINK_SPEED_40GB_FULL) {
1417 : : CMVAR_RANGE_H = S10G_CMVAR_RANGE_H;
1418 : : CMVAR_RANGE_L = S10G_CMVAR_RANGE_L;
1419 [ # # ]: 0 : } else if (speed == TXGBE_LINK_SPEED_25GB_FULL) {
1420 : : CMVAR_RANGE_H = S25G_CMVAR_RANGE_H;
1421 : : CMVAR_RANGE_L = S25G_CMVAR_RANGE_L;
1422 : : }
1423 : :
1424 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_40GB_FULL)
1425 : : lane_num = 4;
1426 : :
1427 : : /* 3. Program ALIAS::RXS::RANGE_SEL = CMVAR::RANGE_H */
1428 [ # # ]: 0 : for (i = 0; i < lane_num; i++) {
1429 : : rdata = 0x0000;
1430 : 0 : addr = E56PHY_RXS_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1431 : : rdata = rd32_ephy(hw, addr);
1432 : 0 : set_fields_e56(&rdata,
1433 : : E56PHY_RXS_ANA_OVRDVAL_5_ANA_BBCDR_OSC_RANGE_SEL_I, CMVAR_RANGE_H);
1434 : : wr32_ephy(hw, addr, rdata);
1435 : :
1436 : : rdata = 0x0000;
1437 : 0 : addr = E56PHY_RXS_ANA_OVRDEN_0_ADDR + (E56PHY_RXS_OFFSET * i);
1438 : : rdata = rd32_ephy(hw, addr);
1439 : : set_fields_e56(&rdata,
1440 : : E56PHY_RXS_ANA_OVRDEN_0_OVRD_EN_ANA_BBCDR_OSC_RANGE_SEL_I, 0x1);
1441 : : wr32_ephy(hw, addr, rdata);
1442 : :
1443 : : /*
1444 : : * 4. Do SEQ::RX_ENABLE to enable RXS, and let it stop after oscillator calibration.
1445 : : * This needs to be done by blocking the RX power-up fsm at the state following
1446 : : * the oscillator calibration state.
1447 : : * Follow below steps to do the same before SEQ::RX_ENABLE.
1448 : : * a. ALIAS::PDIG::CTRL_FSM_RX_ST can be stopped at RX_SAMP_CAL_ST which is the
1449 : : * state after RX_OSC_CAL_ST by configuring ALIAS::RXS::SAMP_CAL_DONE=0b0
1450 : : */
1451 : : rdata = 0x0000;
1452 : 0 : addr = E56PHY_RXS0_OVRDVAL_0_ADDR + (E56PHY_PMD_RX_OFFSET * i);
1453 : : rdata = rd32_ephy(hw, addr);
1454 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_0_RXS0_RX0_SAMP_CAL_DONE_O, 0x0);
1455 : : wr32_ephy(hw, addr, rdata);
1456 : :
1457 : : rdata = 0x0000;
1458 : 0 : addr = E56PHY_RXS0_OVRDEN_0_ADDR + (E56PHY_PMD_RX_OFFSET * i);
1459 : : rdata = rd32_ephy(hw, addr);
1460 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_0_OVRD_EN_RXS0_RX0_SAMP_CAL_DONE_O, 0x1);
1461 : : wr32_ephy(hw, addr, rdata);
1462 : :
1463 : : /* Do SEQ::RX_ENABLE to enable RXS */
1464 : : rdata = 0;
1465 : : addr = E56PHY_PMD_CFG_0_ADDR;
1466 : : rdata = rd32_ephy(hw, addr);
1467 : 0 : set_fields_e56(&rdata, E56PHY_PMD_CFG_0_RX_EN_CFG, (0x1 << i));
1468 : : wr32_ephy(hw, addr, rdata);
1469 : :
1470 : : /* b. Poll ALIAS::PDIG::CTRL_FSM_RX_ST and confirm its value is RX_SAMP_CAL_ST */
1471 : : rdata = 0;
1472 : : timer = 0;
1473 [ # # ]: 0 : while ((rdata >> (i * 8) & 0x3f) != 0x9) {
1474 : 0 : usec_delay(500);
1475 : : rdata = 0;
1476 : : addr = E56PHY_INTR_0_ADDR;
1477 : : rdata = rd32_ephy(hw, addr);
1478 [ # # ]: 0 : if (rdata & (0x100 << i))
1479 : : break;
1480 : :
1481 : : rdata = 0;
1482 : : addr = E56PHY_CTRL_FSM_RX_STAT_0_ADDR;
1483 : : rdata = rd32_ephy(hw, addr);
1484 : :
1485 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT) {
1486 : 0 : DEBUGOUT("ERROR: Wait E56PHY_CTRL_FSM_RX_STAT_0_ADDR Timeout!");
1487 : 0 : return -1;
1488 : : }
1489 : : }
1490 : :
1491 : : /* 5/6.Define software variable as OFFSET_CENTRE_RANGE_H = ALIAS::RXS::COARSE */
1492 : : rdata = 0;
1493 : : addr = E56PHY_RXS_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1494 : : rdata = rd32_ephy(hw, addr);
1495 : 0 : OFFSET_CENTRE_RANGE_H = (rdata >> 4) & 0xf;
1496 [ # # ]: 0 : if (OFFSET_CENTRE_RANGE_H > RX_COARSE_MID_TD)
1497 : 0 : OFFSET_CENTRE_RANGE_H = OFFSET_CENTRE_RANGE_H - RX_COARSE_MID_TD;
1498 : : else
1499 : 0 : OFFSET_CENTRE_RANGE_H = RX_COARSE_MID_TD - OFFSET_CENTRE_RANGE_H;
1500 : :
1501 : : /*
1502 : : * 7. Do SEQ::RX_DISABLE to disable RXS.
1503 : : * Poll ALIAS::PDIG::CTRL_FSM_RX_ST and confirm.
1504 : : */
1505 : : rdata = 0;
1506 : : addr = E56PHY_PMD_CFG_0_ADDR;
1507 : : rdata = rd32_ephy(hw, addr);
1508 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_0_RX_EN_CFG, 0x0);
1509 : : wr32_ephy(hw, addr, rdata);
1510 : :
1511 : : timer = 0;
1512 : : while (1) {
1513 : 0 : usec_delay(500);
1514 : : rdata = 0;
1515 : : addr = E56PHY_CTRL_FSM_RX_STAT_0_ADDR;
1516 : : rdata = rd32_ephy(hw, addr);
1517 [ # # ]: 0 : if (((rdata >> (i * 8)) & 0x3f) == 0x21)
1518 : : break;
1519 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT) {
1520 : 0 : DEBUGOUT("ERROR: Wait E56PHY_CTRL_FSM_RX_STAT_0_ADDR Timeout!");
1521 : 0 : return -1;
1522 : : }
1523 : : }
1524 : :
1525 : : /*
1526 : : * 8. Since RX power-up fsm is stopped in RX_SAMP_CAL_ST,
1527 : : * it is possible the timeout interrupt is set.
1528 : : * Clear the same by clearing ALIAS::PDIG::INTR_CTRL_FSM_RX_ERR.
1529 : : * Also clear ALIAS::PDIG::INTR_RX_OSC_FREQ_ERR which could also be set.
1530 : : */
1531 : 0 : usec_delay(500);
1532 : : rdata = 0;
1533 : : addr = E56PHY_INTR_0_ADDR;
1534 : : rdata = rd32_ephy(hw, addr);
1535 : :
1536 : 0 : usec_delay(500);
1537 : : addr = E56PHY_INTR_0_ADDR;
1538 : : wr32_ephy(hw, addr, rdata);
1539 : :
1540 : 0 : usec_delay(500);
1541 : : rdata = 0;
1542 : : addr = E56PHY_INTR_0_ADDR;
1543 : : rdata = rd32_ephy(hw, addr);
1544 : :
1545 : : /* 9. Program ALIAS::RXS::RANGE_SEL = CMVAR::RANGE_L */
1546 : : rdata = 0x0000;
1547 : : addr = E56PHY_RXS_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1548 : : rdata = rd32_ephy(hw, addr);
1549 : 0 : set_fields_e56(&rdata,
1550 : : E56PHY_RXS_ANA_OVRDVAL_5_ANA_BBCDR_OSC_RANGE_SEL_I, CMVAR_RANGE_L);
1551 : : wr32_ephy(hw, addr, rdata);
1552 : :
1553 : : rdata = 0x0000;
1554 : : addr = E56PHY_RXS_ANA_OVRDEN_0_ADDR + (E56PHY_RXS_OFFSET * i);
1555 : : rdata = rd32_ephy(hw, addr);
1556 : : set_fields_e56(&rdata,
1557 : : E56PHY_RXS_ANA_OVRDEN_0_OVRD_EN_ANA_BBCDR_OSC_RANGE_SEL_I, 0x1);
1558 : : wr32_ephy(hw, addr, rdata);
1559 : :
1560 : : /*
1561 : : * 10. Do SEQ::RX_ENABLE to enable RXS,
1562 : : * and let it stop after oscillator calibration.
1563 : : */
1564 : : rdata = 0x0000;
1565 : : addr = E56PHY_RXS0_OVRDVAL_0_ADDR + (E56PHY_PMD_RX_OFFSET * i);
1566 : : rdata = rd32_ephy(hw, addr);
1567 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_0_RXS0_RX0_SAMP_CAL_DONE_O, 0x0);
1568 : : wr32_ephy(hw, addr, rdata);
1569 : :
1570 : : rdata = 0x0000;
1571 : : addr = E56PHY_RXS0_OVRDEN_0_ADDR + (E56PHY_PMD_RX_OFFSET * i);
1572 : : rdata = rd32_ephy(hw, addr);
1573 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_0_OVRD_EN_RXS0_RX0_SAMP_CAL_DONE_O, 0x1);
1574 : : wr32_ephy(hw, addr, rdata);
1575 : :
1576 : : rdata = 0;
1577 : : addr = E56PHY_PMD_CFG_0_ADDR;
1578 : : rdata = rd32_ephy(hw, addr);
1579 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_0_RX_EN_CFG, (0x1 << i));
1580 : : wr32_ephy(hw, addr, rdata);
1581 : :
1582 : : /* poll CTRL_FSM_RX_ST */
1583 : : timer = 0;
1584 [ # # ]: 0 : while (((rdata >> (i * 8)) & 0x3f) != 0x9) {
1585 : 0 : usec_delay(500);
1586 : : rdata = 0;
1587 : : addr = E56PHY_INTR_0_ADDR;
1588 : : rdata = rd32_ephy(hw, addr);
1589 [ # # ]: 0 : if ((rdata & 0x100) == 0x100)
1590 : : break;
1591 : :
1592 : : rdata = 0;
1593 : : addr = E56PHY_CTRL_FSM_RX_STAT_0_ADDR;
1594 : : rdata = rd32_ephy(hw, addr);
1595 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT) {
1596 : 0 : DEBUGOUT("ERROR: Wait E56PHY_CTRL_FSM_RX_STAT_0_ADDR Timeout!");
1597 : 0 : return -1;
1598 : : }
1599 : : }
1600 : :
1601 : : /*
1602 : : * 11/12.Define software variable as OFFSET_CENTRE_RANGE_L = ALIAS::RXS::COARSE -
1603 : : * RX_COARSE_MID_TD. Clear the INTR.
1604 : : */
1605 : : rdata = 0;
1606 : : addr = E56PHY_RXS_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1607 : : rdata = rd32_ephy(hw, addr);
1608 : 0 : OFFSET_CENTRE_RANGE_L = (rdata >> 4) & 0xf;
1609 [ # # ]: 0 : if (OFFSET_CENTRE_RANGE_L > RX_COARSE_MID_TD)
1610 : 0 : OFFSET_CENTRE_RANGE_L = OFFSET_CENTRE_RANGE_L - RX_COARSE_MID_TD;
1611 : : else
1612 : 0 : OFFSET_CENTRE_RANGE_L = RX_COARSE_MID_TD - OFFSET_CENTRE_RANGE_L;
1613 : :
1614 : : /*
1615 : : * 13. Perform below calculation in software. Goal is to pick range value
1616 : : * which is closer to RX_COARSE_MID_TD.
1617 : : */
1618 [ # # ]: 0 : if (OFFSET_CENTRE_RANGE_L < OFFSET_CENTRE_RANGE_H)
1619 : : RANGE_FINAL = CMVAR_RANGE_L;
1620 : : else
1621 : : RANGE_FINAL = CMVAR_RANGE_H;
1622 : :
1623 : : /*
1624 : : * 14. Do SEQ::RX_DISABLE to disable RXS. Poll ALIAS::PDIG::CTRL_FSM_RX_ST
1625 : : * and confirm its value is POWERDN_ST
1626 : : */
1627 : : rdata = 0;
1628 : : addr = E56PHY_PMD_CFG_0_ADDR;
1629 : : rdata = rd32_ephy(hw, addr);
1630 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_0_RX_EN_CFG, 0x0);
1631 : : wr32_ephy(hw, addr, rdata);
1632 : :
1633 : : timer = 0;
1634 : : while (1) {
1635 : 0 : usec_delay(500);
1636 : : rdata = 0;
1637 : : addr = E56PHY_CTRL_FSM_RX_STAT_0_ADDR;
1638 : : rdata = rd32_ephy(hw, addr);
1639 [ # # ]: 0 : if (((rdata >> (i * 8)) & 0x3f) == 0x21)
1640 : : break;
1641 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT) {
1642 : 0 : DEBUGOUT("ERROR: Wait E56PHY_CTRL_FSM_RX_STAT_0_ADDR Timeout!");
1643 : 0 : return -1;
1644 : : }
1645 : : }
1646 : :
1647 : : /*
1648 : : * 15. Since RX power-up fsm is stopped in RX_SAMP_CAL_ST,
1649 : : * it is possible the timeout interrupt is set. Clear the same by clearing
1650 : : * ALIAS::PDIG::INTR_CTRL_FSM_RX_ERR. Also clear ALIAS::PDIG::INTR_RX_OSC_FREQ_ERR
1651 : : * which could also be set.
1652 : : */
1653 : 0 : usec_delay(500);
1654 : : rdata = 0;
1655 : : addr = E56PHY_INTR_0_ADDR;
1656 : : rdata = rd32_ephy(hw, addr);
1657 : 0 : usec_delay(500);
1658 : : wr32_ephy(hw, addr, rdata);
1659 : :
1660 : 0 : usec_delay(500);
1661 : : rdata = 0;
1662 : : addr = E56PHY_INTR_0_ADDR;
1663 : : rdata = rd32_ephy(hw, addr);
1664 : :
1665 : : /* 16. Program ALIAS::RXS::RANGE_SEL = RANGE_FINAL */
1666 : : rdata = 0x0000;
1667 : : addr = E56PHY_RXS_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1668 : : rdata = rd32_ephy(hw, addr);
1669 : 0 : set_fields_e56(&rdata,
1670 : : E56PHY_RXS_ANA_OVRDVAL_5_ANA_BBCDR_OSC_RANGE_SEL_I, RANGE_FINAL);
1671 : : wr32_ephy(hw, addr, rdata);
1672 : :
1673 : : /*
1674 : : * 17. Program following before enabling RXS. Purpose is to disable power-up
1675 : : * FSM control on ADC offset adaptation.
1676 : : * Note: this step will be done in 2.3.3 RXS calibration and adaptation sequence
1677 : : * 18. After this SEQ::RX_ENABLE can be done at any time. Note to ensure that
1678 : : * ALIAS::RXS::RANGE_SEL = RANGE_FINAL configuration is retained.
1679 : : * Rmove the OVRDEN on rxs0_rx0_samp_cal_done_o
1680 : : */
1681 : : rdata = 0x0000;
1682 : : addr = E56PHY_RXS0_OVRDEN_0_ADDR + (E56PHY_PMD_RX_OFFSET * i);
1683 : : rdata = rd32_ephy(hw, addr);
1684 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_0_OVRD_EN_RXS0_RX0_SAMP_CAL_DONE_O, 0x0);
1685 : : wr32_ephy(hw, addr, rdata);
1686 : : }
1687 : :
1688 : : rdata = 0;
1689 : : addr = E56PHY_PMD_CFG_0_ADDR;
1690 : : rdata = rd32_ephy(hw, addr);
1691 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_40GB_FULL)
1692 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_0_RX_EN_CFG, 0xf);
1693 : : else
1694 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_0_RX_EN_CFG, 0x1);
1695 : : wr32_ephy(hw, addr, rdata);
1696 : :
1697 : 0 : return status;
1698 : : }
1699 : :
1700 : 0 : static int txgbe_e56_set_rxs_ufine_le_max_40g(struct txgbe_hw *hw, u32 speed)
1701 : : {
1702 : : int status = 0;
1703 : : unsigned int rdata;
1704 : : unsigned int ULTRAFINE_CODE;
1705 : : int i = 0;
1706 : : unsigned int CMVAR_UFINE_MAX = 0;
1707 : : u32 addr;
1708 : :
1709 [ # # ]: 0 : for (i = 0; i < 4; i++) {
1710 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_10GB_FULL || speed == TXGBE_LINK_SPEED_40GB_FULL)
1711 : : CMVAR_UFINE_MAX = S10G_CMVAR_UFINE_MAX;
1712 [ # # ]: 0 : else if (speed == TXGBE_LINK_SPEED_25GB_FULL)
1713 : : CMVAR_UFINE_MAX = S25G_CMVAR_UFINE_MAX;
1714 : :
1715 : : /* a. Assign software defined variables as below */
1716 : 0 : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1717 : 0 : rdata = rd32_ephy(hw, addr);
1718 : 0 : ULTRAFINE_CODE = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_ultrafine_i);
1719 : :
1720 : : /* b. Perform the below logic sequence */
1721 [ # # ]: 0 : while (ULTRAFINE_CODE > CMVAR_UFINE_MAX) {
1722 : 0 : ULTRAFINE_CODE = ULTRAFINE_CODE - 1;
1723 : : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1724 : 0 : rdata = rd32_ephy(hw, addr);
1725 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_ultrafine_i) = ULTRAFINE_CODE;
1726 : 0 : wr32_ephy(hw, addr, rdata);
1727 : :
1728 : 0 : addr = E56G__RXS0_ANA_OVRDEN_1_ADDR + (E56PHY_RXS_OFFSET * i);
1729 : 0 : rdata = rd32_ephy(hw, addr);
1730 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i) = 1;
1731 : 0 : wr32_ephy(hw, addr, rdata);
1732 : :
1733 : : /* Wait until 1milliseconds or greater */
1734 : : msleep(10);
1735 : : }
1736 : : }
1737 : 0 : return status;
1738 : : }
1739 : :
1740 : : static inline
1741 : 0 : int txgbe_e56_set_rxs_ufine_le_max(struct txgbe_hw *hw, u32 speed)
1742 : : {
1743 : : int status = 0;
1744 : : unsigned int rdata;
1745 : : unsigned int ULTRAFINE_CODE;
1746 : :
1747 : : unsigned int CMVAR_UFINE_MAX = 0;
1748 : :
1749 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_10GB_FULL)
1750 : : CMVAR_UFINE_MAX = S10G_CMVAR_UFINE_MAX;
1751 [ # # ]: 0 : else if (speed == TXGBE_LINK_SPEED_25GB_FULL)
1752 : : CMVAR_UFINE_MAX = S25G_CMVAR_UFINE_MAX;
1753 : :
1754 : : /* a. Assign software defined variables as below */
1755 : : /* ii. ULTRAFINE_CODE = ALIAS::RXS::ULTRAFINE */
1756 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDVAL_5);
1757 : 0 : ULTRAFINE_CODE = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_ultrafine_i);
1758 : :
1759 : : /* b. Perform the below logic sequence */
1760 [ # # ]: 0 : while (ULTRAFINE_CODE > CMVAR_UFINE_MAX) {
1761 : 0 : ULTRAFINE_CODE = ULTRAFINE_CODE - 1;
1762 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_ultrafine_i,
1763 : : ULTRAFINE_CODE);
1764 : : /* Set ovrd_en=1 to override ASIC value */
1765 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i,
1766 : : 1);
1767 : : /* Wait until 1milliseconds or greater */
1768 : : msleep(10);
1769 : : }
1770 : :
1771 : 0 : return status;
1772 : : }
1773 : :
1774 : : #define RXS_READ_COUNT 5
1775 : :
1776 : 0 : void txgbe_e56_rx_rd_second_code_40g(struct txgbe_hw *hw, int *SECOND_CODE, int lane)
1777 : : {
1778 : : int i, median;
1779 : : unsigned int rdata;
1780 : : u32 addr;
1781 : : int RXS_BBCDR_SECOND_ORDER_ST[RXS_READ_COUNT];
1782 : :
1783 : : /* Set ovrd_en=0 to read ASIC value */
1784 : 0 : addr = E56G__RXS0_ANA_OVRDEN_1_ADDR + (lane * E56PHY_RXS_OFFSET);
1785 : 0 : rdata = rd32_ephy(hw, addr);
1786 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_int_cstm_i) = 0;
1787 : 0 : wr32_ephy(hw, addr, rdata);
1788 : :
1789 : : /*
1790 : : * As status update from RXS hardware is asynchronous to read status of SECOND_ORDER,
1791 : : * follow sequence mentioned below.
1792 : : */
1793 [ # # ]: 0 : for (i = 0; i < RXS_READ_COUNT; i = i + 1) {
1794 : 0 : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (lane * E56PHY_RXS_OFFSET);
1795 : 0 : rdata = rd32_ephy(hw, addr);
1796 : 0 : RXS_BBCDR_SECOND_ORDER_ST[i] = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1797 : : ana_bbcdr_int_cstm_i);
1798 : 0 : usec_delay(100);
1799 : : }
1800 : :
1801 : : /* sort array RXS_BBCDR_SECOND_ORDER_ST[i] */
1802 : 0 : qsort(RXS_BBCDR_SECOND_ORDER_ST, RXS_READ_COUNT, sizeof(int), txgbe_e56_int_cmp);
1803 : :
1804 : : median = ((RXS_READ_COUNT + 1) / 2) - 1;
1805 : 0 : *SECOND_CODE = RXS_BBCDR_SECOND_ORDER_ST[median];
1806 : :
1807 : 0 : return;
1808 : : }
1809 : :
1810 : 0 : void txgbe_e56_rx_rd_second_code(struct txgbe_hw *hw, int *SECOND_CODE)
1811 : : {
1812 : : int i, median;
1813 : : unsigned int rdata;
1814 : : int RXS_BBCDR_SECOND_ORDER_ST[RXS_READ_COUNT];
1815 : :
1816 : : /* Set ovrd_en=0 to read ASIC value */
1817 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_int_cstm_i, 0);
1818 : :
1819 : : /*
1820 : : * As status update from RXS hardware is asynchronous to read status
1821 : : * of SECOND_ORDER, follow sequence mentioned below.
1822 : : */
1823 [ # # ]: 0 : for (i = 0; i < RXS_READ_COUNT; i = i + 1) {
1824 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDVAL_5);
1825 : 0 : RXS_BBCDR_SECOND_ORDER_ST[i] = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1826 : : ana_bbcdr_int_cstm_i);
1827 : 0 : usec_delay(100);
1828 : : }
1829 : :
1830 : : /* sort array RXS_BBCDR_SECOND_ORDER_ST[i] */
1831 : 0 : qsort(RXS_BBCDR_SECOND_ORDER_ST, RXS_READ_COUNT, sizeof(int), txgbe_e56_int_cmp);
1832 : :
1833 : : median = ((RXS_READ_COUNT + 1) / 2) - 1;
1834 : 0 : *SECOND_CODE = RXS_BBCDR_SECOND_ORDER_ST[median];
1835 : :
1836 : 0 : return;
1837 : : }
1838 : :
1839 : : /*
1840 : : * 2.3.4 RXS post CDR lock temperature tracking sequence
1841 : : *
1842 : : * Below sequence must be run before the temperature drifts by >5degC
1843 : : * after the CDR locks for the first time or after the ious time this
1844 : : * sequence was run. It is recommended to call this sequence periodically
1845 : : * (eg: once every 100ms) or trigger sequence if the temperature drifts
1846 : : * by >=5degC. Temperature must be read from an on-die temperature sensor.
1847 : : */
1848 : 0 : int txgbe_temp_track_seq_40g(struct txgbe_hw *hw, u32 speed)
1849 : : {
1850 : : int status = 0;
1851 : : unsigned int rdata;
1852 : : int SECOND_CODE;
1853 : : int COARSE_CODE;
1854 : : int FINE_CODE;
1855 : : int ULTRAFINE_CODE;
1856 : :
1857 : : int CMVAR_SEC_LOW_TH;
1858 : : int CMVAR_UFINE_MAX = 0;
1859 : : int CMVAR_FINE_MAX;
1860 : : int CMVAR_UFINE_UMAX_WRAP = 0;
1861 : : int CMVAR_COARSE_MAX;
1862 : : int CMVAR_UFINE_FMAX_WRAP = 0;
1863 : : int CMVAR_FINE_FMAX_WRAP = 0;
1864 : : int CMVAR_SEC_HIGH_TH;
1865 : : int CMVAR_UFINE_MIN;
1866 : : int CMVAR_FINE_MIN;
1867 : : int CMVAR_UFINE_UMIN_WRAP;
1868 : : int CMVAR_COARSE_MIN;
1869 : : int CMVAR_UFINE_FMIN_WRAP;
1870 : : int CMVAR_FINE_FMIN_WRAP;
1871 : : int i;
1872 : : u32 addr;
1873 : : int temperature;
1874 : :
1875 [ # # ]: 0 : for (i = 0; i < 4; i++) {
1876 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_10GB_FULL || speed == TXGBE_LINK_SPEED_40GB_FULL) {
1877 : : CMVAR_SEC_LOW_TH = S10G_CMVAR_SEC_LOW_TH;
1878 : : CMVAR_UFINE_MAX = S10G_CMVAR_UFINE_MAX;
1879 : : CMVAR_FINE_MAX = S10G_CMVAR_FINE_MAX;
1880 : : CMVAR_UFINE_UMAX_WRAP = S10G_CMVAR_UFINE_UMAX_WRAP;
1881 : : CMVAR_COARSE_MAX = S10G_CMVAR_COARSE_MAX;
1882 : : CMVAR_UFINE_FMAX_WRAP = S10G_CMVAR_UFINE_FMAX_WRAP;
1883 : : CMVAR_FINE_FMAX_WRAP = S10G_CMVAR_FINE_FMAX_WRAP;
1884 : : CMVAR_SEC_HIGH_TH = S10G_CMVAR_SEC_HIGH_TH;
1885 : : CMVAR_UFINE_MIN = S10G_CMVAR_UFINE_MIN;
1886 : : CMVAR_FINE_MIN = S10G_CMVAR_FINE_MIN;
1887 : : CMVAR_UFINE_UMIN_WRAP = S10G_CMVAR_UFINE_UMIN_WRAP;
1888 : : CMVAR_COARSE_MIN = S10G_CMVAR_COARSE_MIN;
1889 : : CMVAR_UFINE_FMIN_WRAP = S10G_CMVAR_UFINE_FMIN_WRAP;
1890 : : CMVAR_FINE_FMIN_WRAP = S10G_CMVAR_FINE_FMIN_WRAP;
1891 [ # # ]: 0 : } else if (speed == TXGBE_LINK_SPEED_25GB_FULL) {
1892 : : CMVAR_SEC_LOW_TH = S25G_CMVAR_SEC_LOW_TH;
1893 : : CMVAR_UFINE_MAX = S25G_CMVAR_UFINE_MAX;
1894 : : CMVAR_FINE_MAX = S25G_CMVAR_FINE_MAX;
1895 : : CMVAR_UFINE_UMAX_WRAP = S25G_CMVAR_UFINE_UMAX_WRAP;
1896 : : CMVAR_COARSE_MAX = S25G_CMVAR_COARSE_MAX;
1897 : : CMVAR_UFINE_FMAX_WRAP = S25G_CMVAR_UFINE_FMAX_WRAP;
1898 : : CMVAR_FINE_FMAX_WRAP = S25G_CMVAR_FINE_FMAX_WRAP;
1899 : : CMVAR_SEC_HIGH_TH = S25G_CMVAR_SEC_HIGH_TH;
1900 : : CMVAR_UFINE_MIN = S25G_CMVAR_UFINE_MIN;
1901 : : CMVAR_FINE_MIN = S25G_CMVAR_FINE_MIN;
1902 : : CMVAR_UFINE_UMIN_WRAP = S25G_CMVAR_UFINE_UMIN_WRAP;
1903 : : CMVAR_COARSE_MIN = S25G_CMVAR_COARSE_MIN;
1904 : : CMVAR_UFINE_FMIN_WRAP = S25G_CMVAR_UFINE_FMIN_WRAP;
1905 : : CMVAR_FINE_FMIN_WRAP = S25G_CMVAR_FINE_FMIN_WRAP;
1906 : : } else {
1907 : 0 : DEBUGOUT("Error Speed");
1908 : 0 : return 0;
1909 : : }
1910 : :
1911 : 0 : status = txgbe_e56_get_temp(hw, &temperature);
1912 [ # # ]: 0 : if (status)
1913 : : return 0;
1914 : :
1915 : 0 : hw->temperature = temperature;
1916 : :
1917 : : /* Assign software defined variables as below */
1918 : : /* a. SECOND_CODE = ALIAS::RXS::SECOND_ORDER */
1919 : 0 : txgbe_e56_rx_rd_second_code_40g(hw, &SECOND_CODE, i);
1920 : :
1921 : : /*
1922 : : * b. COARSE_CODE = ALIAS::RXS::COARSE
1923 : : * c. FINE_CODE = ALIAS::RXS::FINE
1924 : : * d. ULTRAFINE_CODE = ALIAS::RXS::ULTRAFINE
1925 : : */
1926 : 0 : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1927 : 0 : rdata = rd32_ephy(hw, addr);
1928 : 0 : COARSE_CODE = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_coarse_i);
1929 : 0 : FINE_CODE = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_fine_i);
1930 : 0 : ULTRAFINE_CODE = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_ultrafine_i);
1931 : :
1932 [ # # ]: 0 : if (SECOND_CODE <= CMVAR_SEC_LOW_TH) {
1933 [ # # ]: 0 : if (ULTRAFINE_CODE < CMVAR_UFINE_MAX) {
1934 : : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1935 : 0 : rdata = rd32_ephy(hw, addr);
1936 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1937 : 0 : ana_bbcdr_ultrafine_i) = ULTRAFINE_CODE + 1;
1938 : 0 : wr32_ephy(hw, addr, rdata);
1939 : :
1940 : : /* Set ovrd_en=1 to override ASIC value */
1941 : 0 : addr = E56G__RXS0_ANA_OVRDEN_1_ADDR + (E56PHY_RXS_OFFSET * i);
1942 : 0 : rdata = rd32_ephy(hw, addr);
1943 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1,
1944 : 0 : ovrd_en_ana_bbcdr_ultrafine_i) = 1;
1945 : 0 : wr32_ephy(hw, addr, rdata);
1946 [ # # ]: 0 : } else if (FINE_CODE < CMVAR_FINE_MAX) {
1947 : : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1948 : 0 : rdata = rd32_ephy(hw, addr);
1949 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1950 : 0 : ana_bbcdr_ultrafine_i) = CMVAR_UFINE_UMAX_WRAP;
1951 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1952 : 0 : ana_bbcdr_fine_i) = FINE_CODE + 1;
1953 : 0 : wr32_ephy(hw, addr, rdata);
1954 : 0 : addr = E56G__RXS0_ANA_OVRDEN_1_ADDR + (E56PHY_RXS_OFFSET * i);
1955 : 0 : rdata = rd32_ephy(hw, addr);
1956 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 1;
1957 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1,
1958 : 0 : ovrd_en_ana_bbcdr_ultrafine_i) = 1;
1959 : 0 : wr32_ephy(hw, addr, rdata);
1960 [ # # ]: 0 : } else if (COARSE_CODE < CMVAR_COARSE_MAX) {
1961 : : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1962 : 0 : rdata = rd32_ephy(hw, addr);
1963 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1964 : 0 : ana_bbcdr_ultrafine_i) = CMVAR_UFINE_FMAX_WRAP;
1965 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1966 : 0 : ana_bbcdr_fine_i) = CMVAR_FINE_FMAX_WRAP;
1967 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1968 : 0 : ana_bbcdr_coarse_i) = COARSE_CODE + 1;
1969 : 0 : wr32_ephy(hw, addr, rdata);
1970 : :
1971 : 0 : addr = E56G__RXS0_ANA_OVRDEN_1_ADDR + (E56PHY_RXS_OFFSET * i);
1972 : 0 : rdata = rd32_ephy(hw, addr);
1973 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_coarse_i) = 1;
1974 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 1;
1975 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1,
1976 : 0 : ovrd_en_ana_bbcdr_ultrafine_i) = 1;
1977 : 0 : wr32_ephy(hw, addr, rdata);
1978 : : } else {
1979 : 0 : DEBUGOUT("ERROR: (SECOND_CODE <= CMVAR_SEC_LOW_TH) temperature "
1980 : : "tracking occurs Error condition");
1981 : : }
1982 [ # # ]: 0 : } else if (SECOND_CODE >= CMVAR_SEC_HIGH_TH) {
1983 [ # # ]: 0 : if (ULTRAFINE_CODE > CMVAR_UFINE_MIN) {
1984 : : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1985 : 0 : rdata = rd32_ephy(hw, addr);
1986 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1987 : 0 : ana_bbcdr_ultrafine_i) = ULTRAFINE_CODE - 1;
1988 : 0 : wr32_ephy(hw, addr, rdata);
1989 : :
1990 : 0 : addr = E56G__RXS0_ANA_OVRDEN_1_ADDR + (E56PHY_RXS_OFFSET * i);
1991 : 0 : rdata = rd32_ephy(hw, addr);
1992 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1,
1993 : 0 : ovrd_en_ana_bbcdr_ultrafine_i) = 1;
1994 : 0 : wr32_ephy(hw, addr, rdata);
1995 [ # # ]: 0 : } else if (FINE_CODE > CMVAR_FINE_MIN) {
1996 : : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
1997 : 0 : rdata = rd32_ephy(hw, addr);
1998 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
1999 : 0 : ana_bbcdr_ultrafine_i) = CMVAR_UFINE_UMIN_WRAP;
2000 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2001 : 0 : ana_bbcdr_fine_i) = FINE_CODE - 1;
2002 : 0 : wr32_ephy(hw, addr, rdata);
2003 : :
2004 : 0 : addr = E56G__RXS0_ANA_OVRDEN_1_ADDR + (E56PHY_RXS_OFFSET * i);
2005 : 0 : rdata = rd32_ephy(hw, addr);
2006 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 1;
2007 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1,
2008 : 0 : ovrd_en_ana_bbcdr_ultrafine_i) = 1;
2009 : 0 : wr32_ephy(hw, addr, rdata);
2010 [ # # ]: 0 : } else if (COARSE_CODE > CMVAR_COARSE_MIN) {
2011 : : addr = E56G__RXS0_ANA_OVRDVAL_5_ADDR + (E56PHY_RXS_OFFSET * i);
2012 : 0 : rdata = rd32_ephy(hw, addr);
2013 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2014 : 0 : ana_bbcdr_ultrafine_i) = CMVAR_UFINE_FMIN_WRAP;
2015 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2016 : 0 : ana_bbcdr_fine_i) = CMVAR_FINE_FMIN_WRAP;
2017 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2018 : 0 : ana_bbcdr_coarse_i) = COARSE_CODE - 1;
2019 : 0 : wr32_ephy(hw, addr, rdata);
2020 : :
2021 : 0 : addr = E56G__RXS0_ANA_OVRDEN_1_ADDR + (E56PHY_RXS_OFFSET * i);
2022 : 0 : rdata = rd32_ephy(hw, addr);
2023 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_coarse_i) = 1;
2024 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 1;
2025 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1,
2026 : 0 : ovrd_en_ana_bbcdr_ultrafine_i) = 1;
2027 : 0 : wr32_ephy(hw, addr, rdata);
2028 : : } else {
2029 : 0 : DEBUGOUT("ERROR: (SECOND_CODE >= CMVAR_SEC_HIGH_TH) temperature "
2030 : : "tracking occurs Error condition");
2031 : : }
2032 : : }
2033 : : }
2034 : :
2035 : : return status;
2036 : : }
2037 : :
2038 : : /*
2039 : : * 2.3.4 RXS post CDR lock temperature tracking sequence
2040 : : *
2041 : : * Below sequence must be run before the temperature drifts by >5degC
2042 : : * after the CDR locks for the first time or after the ious time this
2043 : : * sequence was run. It is recommended to call this sequence periodically
2044 : : * (eg: once every 100ms) or trigger sequence if the temperature drifts
2045 : : * by >=5degC. Temperature must be read from an on-die temperature sensor.
2046 : : */
2047 : :
2048 : 0 : int txgbe_temp_track_seq(struct txgbe_hw *hw, u32 speed)
2049 : : {
2050 : : int status = 0;
2051 : : unsigned int rdata;
2052 : : int SECOND_CODE;
2053 : : int COARSE_CODE;
2054 : : int FINE_CODE;
2055 : : int ULTRAFINE_CODE;
2056 : :
2057 : : int CMVAR_SEC_LOW_TH;
2058 : : int CMVAR_UFINE_MAX = 0;
2059 : : int CMVAR_FINE_MAX;
2060 : : int CMVAR_UFINE_UMAX_WRAP = 0;
2061 : : int CMVAR_COARSE_MAX;
2062 : : int CMVAR_UFINE_FMAX_WRAP = 0;
2063 : : int CMVAR_FINE_FMAX_WRAP = 0;
2064 : : int CMVAR_SEC_HIGH_TH;
2065 : : int CMVAR_UFINE_MIN;
2066 : : int CMVAR_FINE_MIN;
2067 : : int CMVAR_UFINE_UMIN_WRAP;
2068 : : int CMVAR_COARSE_MIN;
2069 : : int CMVAR_UFINE_FMIN_WRAP;
2070 : : int CMVAR_FINE_FMIN_WRAP;
2071 : : int temperature;
2072 : :
2073 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_10GB_FULL) {
2074 : : CMVAR_SEC_LOW_TH = S10G_CMVAR_SEC_LOW_TH;
2075 : : CMVAR_UFINE_MAX = S10G_CMVAR_UFINE_MAX;
2076 : : CMVAR_FINE_MAX = S10G_CMVAR_FINE_MAX;
2077 : : CMVAR_UFINE_UMAX_WRAP = S10G_CMVAR_UFINE_UMAX_WRAP;
2078 : : CMVAR_COARSE_MAX = S10G_CMVAR_COARSE_MAX;
2079 : : CMVAR_UFINE_FMAX_WRAP = S10G_CMVAR_UFINE_FMAX_WRAP;
2080 : : CMVAR_FINE_FMAX_WRAP = S10G_CMVAR_FINE_FMAX_WRAP;
2081 : : CMVAR_SEC_HIGH_TH = S10G_CMVAR_SEC_HIGH_TH;
2082 : : CMVAR_UFINE_MIN = S10G_CMVAR_UFINE_MIN;
2083 : : CMVAR_FINE_MIN = S10G_CMVAR_FINE_MIN;
2084 : : CMVAR_UFINE_UMIN_WRAP = S10G_CMVAR_UFINE_UMIN_WRAP;
2085 : : CMVAR_COARSE_MIN = S10G_CMVAR_COARSE_MIN;
2086 : : CMVAR_UFINE_FMIN_WRAP = S10G_CMVAR_UFINE_FMIN_WRAP;
2087 : : CMVAR_FINE_FMIN_WRAP = S10G_CMVAR_FINE_FMIN_WRAP;
2088 [ # # ]: 0 : } else if (speed == TXGBE_LINK_SPEED_25GB_FULL) {
2089 : : CMVAR_SEC_LOW_TH = S25G_CMVAR_SEC_LOW_TH;
2090 : : CMVAR_UFINE_MAX = S25G_CMVAR_UFINE_MAX;
2091 : : CMVAR_FINE_MAX = S25G_CMVAR_FINE_MAX;
2092 : : CMVAR_UFINE_UMAX_WRAP = S25G_CMVAR_UFINE_UMAX_WRAP;
2093 : : CMVAR_COARSE_MAX = S25G_CMVAR_COARSE_MAX;
2094 : : CMVAR_UFINE_FMAX_WRAP = S25G_CMVAR_UFINE_FMAX_WRAP;
2095 : : CMVAR_FINE_FMAX_WRAP = S25G_CMVAR_FINE_FMAX_WRAP;
2096 : : CMVAR_SEC_HIGH_TH = S25G_CMVAR_SEC_HIGH_TH;
2097 : : CMVAR_UFINE_MIN = S25G_CMVAR_UFINE_MIN;
2098 : : CMVAR_FINE_MIN = S25G_CMVAR_FINE_MIN;
2099 : : CMVAR_UFINE_UMIN_WRAP = S25G_CMVAR_UFINE_UMIN_WRAP;
2100 : : CMVAR_COARSE_MIN = S25G_CMVAR_COARSE_MIN;
2101 : : CMVAR_UFINE_FMIN_WRAP = S25G_CMVAR_UFINE_FMIN_WRAP;
2102 : : CMVAR_FINE_FMIN_WRAP = S25G_CMVAR_FINE_FMIN_WRAP;
2103 : : } else {
2104 : 0 : PMD_DRV_LOG(ERR, "Error Speed");
2105 : 0 : return 0;
2106 : : }
2107 : :
2108 : 0 : status = txgbe_e56_get_temp(hw, &temperature);
2109 [ # # ]: 0 : if (status)
2110 : : return 0;
2111 : :
2112 : 0 : hw->temperature = temperature;
2113 : :
2114 : : /*
2115 : : * Assign software defined variables as below
2116 : : * a. SECOND_CODE = ALIAS::RXS::SECOND_ORDER
2117 : : */
2118 : 0 : txgbe_e56_rx_rd_second_code(hw, &SECOND_CODE);
2119 : :
2120 : : /*
2121 : : * b. COARSE_CODE = ALIAS::RXS::COARSE
2122 : : * c. FINE_CODE = ALIAS::RXS::FINE
2123 : : * d. ULTRAFINE_CODE = ALIAS::RXS::ULTRAFINE
2124 : : */
2125 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDVAL_5);
2126 : 0 : COARSE_CODE = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_coarse_i);
2127 : 0 : FINE_CODE = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_fine_i);
2128 : 0 : ULTRAFINE_CODE = EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_ultrafine_i);
2129 : :
2130 [ # # ]: 0 : if (SECOND_CODE <= CMVAR_SEC_LOW_TH) {
2131 [ # # ]: 0 : if (ULTRAFINE_CODE < CMVAR_UFINE_MAX) {
2132 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_ultrafine_i,
2133 : : ULTRAFINE_CODE + 1);
2134 : : /* Set ovrd_en=1 to override ASIC value */
2135 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDEN_1);
2136 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i) = 1;
2137 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDEN_1);
2138 [ # # ]: 0 : } else if (FINE_CODE < CMVAR_FINE_MAX) {
2139 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDVAL_5);
2140 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2141 : 0 : ana_bbcdr_ultrafine_i) = CMVAR_UFINE_UMAX_WRAP;
2142 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_fine_i) = FINE_CODE + 1;
2143 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDVAL_5);
2144 : : /*
2145 : : * Note: All two of above code updates should be written
2146 : : * in a single register write
2147 : : * Set ovrd_en=1 to override ASIC value
2148 : : */
2149 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDEN_1);
2150 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 1;
2151 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i) = 1;
2152 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDEN_1);
2153 [ # # ]: 0 : } else if (COARSE_CODE < CMVAR_COARSE_MAX) {
2154 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDVAL_5);
2155 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2156 : 0 : ana_bbcdr_ultrafine_i) = CMVAR_UFINE_FMAX_WRAP;
2157 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2158 : 0 : ana_bbcdr_fine_i) = CMVAR_FINE_FMAX_WRAP;
2159 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_coarse_i) = COARSE_CODE + 1;
2160 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDVAL_5);
2161 : : /*
2162 : : * Note: All three of above code updates should be written
2163 : : * in a single register write
2164 : : * Set ovrd_en=1 to override ASIC value
2165 : : */
2166 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDEN_1);
2167 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_coarse_i) = 1;
2168 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 1;
2169 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i) = 1;
2170 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDEN_1);
2171 : : } else {
2172 : 0 : PMD_DRV_LOG(ERR, "ERROR: (SECOND_CODE <= CMVAR_SEC_LOW_TH) temperature "
2173 : : "tracking occurs Error condition");
2174 : : }
2175 [ # # ]: 0 : } else if (SECOND_CODE >= CMVAR_SEC_HIGH_TH) {
2176 [ # # ]: 0 : if (ULTRAFINE_CODE > CMVAR_UFINE_MIN) {
2177 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_ultrafine_i,
2178 : : ULTRAFINE_CODE - 1);
2179 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDEN_1);
2180 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i) = 1;
2181 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDEN_1);
2182 [ # # ]: 0 : } else if (FINE_CODE > CMVAR_FINE_MIN) {
2183 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDVAL_5);
2184 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2185 : 0 : ana_bbcdr_ultrafine_i) = CMVAR_UFINE_UMIN_WRAP;
2186 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_fine_i) = FINE_CODE - 1;
2187 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDVAL_5);
2188 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDEN_1);
2189 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 1;
2190 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i) = 1;
2191 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDEN_1);
2192 [ # # ]: 0 : } else if (COARSE_CODE > CMVAR_COARSE_MIN) {
2193 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDVAL_5);
2194 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2195 : 0 : ana_bbcdr_ultrafine_i) = CMVAR_UFINE_FMIN_WRAP;
2196 : : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5,
2197 : 0 : ana_bbcdr_fine_i) = CMVAR_FINE_FMIN_WRAP;
2198 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDVAL_5, ana_bbcdr_coarse_i) = COARSE_CODE - 1;
2199 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDVAL_5);
2200 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDEN_1);
2201 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_coarse_i) = 1;
2202 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 1;
2203 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i) = 1;
2204 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDEN_1);
2205 : : } else {
2206 : 0 : PMD_DRV_LOG(ERR, "ERROR: (SECOND_CODE >= CMVAR_SEC_HIGH_TH) "
2207 : : "temperature tracking occurs Error condition");
2208 : : }
2209 : : }
2210 : :
2211 : : return status;
2212 : : }
2213 : :
2214 : : static inline int
2215 : 0 : txgbe_e56_ctle_bypass_seq(struct txgbe_hw *hw, u32 speed)
2216 : : {
2217 : : unsigned int rdata;
2218 : :
2219 : : /* 1. Program the following RXS registers as mentioned below. */
2220 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDVAL_0, ana_ctle_bypass_i, 1);
2221 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDEN_0, ovrd_en_ana_ctle_bypass_i, 1);
2222 : :
2223 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDVAL_3, ana_ctle_cz_cstm_i, 0);
2224 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDEN_0, ovrd_en_ana_ctle_cz_cstm_i, 1);
2225 : :
2226 : : /* 2. Program the following PDIG registers as mentioned below. */
2227 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDVAL_1);
2228 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_ctle_train_en_i) = 0;
2229 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_ctle_train_done_o) = 1;
2230 : 0 : EPHY_WREG(E56G__PMD_RXS0_OVRDVAL_1);
2231 : :
2232 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDEN_1);
2233 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_ctle_train_en_i) = 1;
2234 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_ctle_train_done_o) = 1;
2235 : 0 : EPHY_WREG(E56G__PMD_RXS0_OVRDEN_1);
2236 : :
2237 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_40GB_FULL) {
2238 : : /* 1. Program the following RXS registers as mentioned below. */
2239 : 0 : txgbe_e56_ephy_config(E56G__RXS1_ANA_OVRDVAL_0, ana_ctle_bypass_i, 1);
2240 : 0 : txgbe_e56_ephy_config(E56G__RXS1_ANA_OVRDEN_0, ovrd_en_ana_ctle_bypass_i, 1);
2241 : 0 : txgbe_e56_ephy_config(E56G__RXS2_ANA_OVRDVAL_0, ana_ctle_bypass_i, 1);
2242 : 0 : txgbe_e56_ephy_config(E56G__RXS2_ANA_OVRDEN_0, ovrd_en_ana_ctle_bypass_i, 1);
2243 : 0 : txgbe_e56_ephy_config(E56G__RXS3_ANA_OVRDVAL_0, ana_ctle_bypass_i, 1);
2244 : 0 : txgbe_e56_ephy_config(E56G__RXS3_ANA_OVRDEN_0, ovrd_en_ana_ctle_bypass_i, 1);
2245 : :
2246 : 0 : txgbe_e56_ephy_config(E56G__RXS1_ANA_OVRDVAL_3, ana_ctle_cz_cstm_i, 0);
2247 : 0 : txgbe_e56_ephy_config(E56G__RXS1_ANA_OVRDEN_0, ovrd_en_ana_ctle_cz_cstm_i, 1);
2248 : 0 : txgbe_e56_ephy_config(E56G__RXS2_ANA_OVRDVAL_3, ana_ctle_cz_cstm_i, 0);
2249 : 0 : txgbe_e56_ephy_config(E56G__RXS2_ANA_OVRDEN_0, ovrd_en_ana_ctle_cz_cstm_i, 1);
2250 : 0 : txgbe_e56_ephy_config(E56G__RXS3_ANA_OVRDVAL_3, ana_ctle_cz_cstm_i, 0);
2251 : 0 : txgbe_e56_ephy_config(E56G__RXS3_ANA_OVRDEN_0, ovrd_en_ana_ctle_cz_cstm_i, 1);
2252 : :
2253 : : /* 2. Program the following PDIG registers as mentioned below. */
2254 : 0 : EPHY_RREG(E56G__PMD_RXS1_OVRDVAL_1);
2255 : 0 : EPHY_XFLD(E56G__PMD_RXS1_OVRDVAL_1, rxs1_rx0_ctle_train_en_i) = 0;
2256 : 0 : EPHY_XFLD(E56G__PMD_RXS1_OVRDVAL_1, rxs1_rx0_ctle_train_done_o) = 1;
2257 : 0 : EPHY_WREG(E56G__PMD_RXS1_OVRDVAL_1);
2258 : 0 : EPHY_RREG(E56G__PMD_RXS2_OVRDVAL_1);
2259 : 0 : EPHY_XFLD(E56G__PMD_RXS2_OVRDVAL_1, rxs2_rx0_ctle_train_en_i) = 0;
2260 : 0 : EPHY_XFLD(E56G__PMD_RXS2_OVRDVAL_1, rxs2_rx0_ctle_train_done_o) = 1;
2261 : 0 : EPHY_WREG(E56G__PMD_RXS2_OVRDVAL_1);
2262 : 0 : EPHY_RREG(E56G__PMD_RXS3_OVRDVAL_1);
2263 : 0 : EPHY_XFLD(E56G__PMD_RXS3_OVRDVAL_1, rxs3_rx0_ctle_train_en_i) = 0;
2264 : 0 : EPHY_XFLD(E56G__PMD_RXS3_OVRDVAL_1, rxs3_rx0_ctle_train_done_o) = 1;
2265 : 0 : EPHY_WREG(E56G__PMD_RXS3_OVRDVAL_1);
2266 : :
2267 : 0 : EPHY_RREG(E56G__PMD_RXS1_OVRDEN_1);
2268 : 0 : EPHY_XFLD(E56G__PMD_RXS1_OVRDEN_1, ovrd_en_rxs1_rx0_ctle_train_en_i) = 1;
2269 : 0 : EPHY_XFLD(E56G__PMD_RXS1_OVRDEN_1, ovrd_en_rxs1_rx0_ctle_train_done_o) = 1;
2270 : 0 : EPHY_WREG(E56G__PMD_RXS1_OVRDEN_1);
2271 : 0 : EPHY_RREG(E56G__PMD_RXS2_OVRDEN_1);
2272 : 0 : EPHY_XFLD(E56G__PMD_RXS2_OVRDEN_1, ovrd_en_rxs2_rx0_ctle_train_en_i) = 1;
2273 : 0 : EPHY_XFLD(E56G__PMD_RXS2_OVRDEN_1, ovrd_en_rxs2_rx0_ctle_train_done_o) = 1;
2274 : 0 : EPHY_WREG(E56G__PMD_RXS2_OVRDEN_1);
2275 : 0 : EPHY_RREG(E56G__PMD_RXS3_OVRDEN_1);
2276 : 0 : EPHY_XFLD(E56G__PMD_RXS3_OVRDEN_1, ovrd_en_rxs3_rx0_ctle_train_en_i) = 1;
2277 : 0 : EPHY_XFLD(E56G__PMD_RXS3_OVRDEN_1, ovrd_en_rxs3_rx0_ctle_train_done_o) = 1;
2278 : 0 : EPHY_WREG(E56G__PMD_RXS3_OVRDEN_1);
2279 : : }
2280 : 0 : return 0;
2281 : : }
2282 : :
2283 : 0 : static int txgbe_e56_rxs_calib_adapt_seq_40G(struct txgbe_hw *hw, u32 speed)
2284 : : {
2285 : : int status = 0, i, j;
2286 : : u32 addr, timer;
2287 : : u32 rdata = 0x0;
2288 : : const bool bypass_ctle = true;
2289 : :
2290 [ # # ]: 0 : for (i = 0; i < 4; i++) {
2291 : : rdata = 0x0000;
2292 : 0 : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2293 : : rdata = rd32_ephy(hw, addr);
2294 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_OFST_ADAPT_EN_I, 0x0);
2295 : : wr32_ephy(hw, addr, rdata);
2296 : :
2297 : 0 : addr = E56PHY_RXS0_OVRDEN_2_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2298 : : rdata = rd32_ephy(hw, addr);
2299 : : set_fields_e56(&rdata,
2300 : : E56PHY_RXS0_OVRDEN_2_OVRD_EN_RXS0_RX0_ADC_OFST_ADAPT_EN_I, 0x1);
2301 : : wr32_ephy(hw, addr, rdata);
2302 : :
2303 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2304 : : rdata = rd32_ephy(hw, addr);
2305 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_GAIN_ADAPT_EN_I, 0x0);
2306 : : wr32_ephy(hw, addr, rdata);
2307 : :
2308 : : addr = E56PHY_RXS0_OVRDEN_2_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2309 : : rdata = rd32_ephy(hw, addr);
2310 : : set_fields_e56(&rdata,
2311 : : E56PHY_RXS0_OVRDEN_2_OVRD_EN_RXS0_RX0_ADC_GAIN_ADAPT_EN_I, 0x1);
2312 : : wr32_ephy(hw, addr, rdata);
2313 : :
2314 : : rdata = 0x0000;
2315 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2316 : : rdata = rd32_ephy(hw, addr);
2317 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_CAL_EN_I, 0x0);
2318 : : wr32_ephy(hw, addr, rdata);
2319 : :
2320 : 0 : addr = E56PHY_RXS0_OVRDEN_1_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2321 : : rdata = rd32_ephy(hw, addr);
2322 : : set_fields_e56(&rdata,
2323 : : E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_ADC_INTL_CAL_EN_I, 0x1);
2324 : : wr32_ephy(hw, addr, rdata);
2325 : :
2326 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2327 : : rdata = rd32_ephy(hw, addr);
2328 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_CAL_DONE_O, 0x1);
2329 : : wr32_ephy(hw, addr, rdata);
2330 : :
2331 : : addr = E56PHY_RXS0_OVRDEN_1_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2332 : : rdata = rd32_ephy(hw, addr);
2333 : : set_fields_e56(&rdata,
2334 : : E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_ADC_INTL_CAL_DONE_O, 0x1);
2335 : : wr32_ephy(hw, addr, rdata);
2336 : :
2337 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2338 : : rdata = rd32_ephy(hw, addr);
2339 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_ADAPT_EN_I, 0x0);
2340 : : wr32_ephy(hw, addr, rdata);
2341 : :
2342 : : addr = E56PHY_RXS0_OVRDEN_2_ADDR + (i * E56PHY_PMD_RX_OFFSET);
2343 : : rdata = rd32_ephy(hw, addr);
2344 : : set_fields_e56(&rdata,
2345 : : E56PHY_RXS0_OVRDEN_2_OVRD_EN_RXS0_RX0_ADC_INTL_ADAPT_EN_I, 0x1);
2346 : : wr32_ephy(hw, addr, rdata);
2347 : : }
2348 : :
2349 : : if (bypass_ctle == 1)
2350 : 0 : txgbe_e56_ctle_bypass_seq(hw, speed);
2351 : :
2352 : : /*
2353 : : * 2. Follow sequence described in 2.3.2 RXS Osc Initialization for temperature tracking
2354 : : * range here. RXS would be enabled at the end of this sequence. For the case when PAM4 KR
2355 : : * training is not enabled (including PAM4 mode without KR training), wait until
2356 : : * ALIAS::PDIG::CTRL_FSM_RX_ST would return RX_TRAIN_15_ST (RX_RDY_ST).
2357 : : */
2358 : 0 : txgbe_e56_rxs_osc_init_for_temp_track_range(hw, speed);
2359 : :
2360 : : addr = E56PHY_CTRL_FSM_RX_STAT_0_ADDR;
2361 : : timer = 0;
2362 : 0 : rdata = 0;
2363 : 0 : while (EPHY_XFLD(E56G__PMD_CTRL_FSM_RX_STAT_0, ctrl_fsm_rx0_st) != E56PHY_RX_RDY_ST ||
2364 : : EPHY_XFLD(E56G__PMD_CTRL_FSM_RX_STAT_0, ctrl_fsm_rx1_st) != E56PHY_RX_RDY_ST ||
2365 [ # # ]: 0 : EPHY_XFLD(E56G__PMD_CTRL_FSM_RX_STAT_0, ctrl_fsm_rx2_st) != E56PHY_RX_RDY_ST ||
2366 : : EPHY_XFLD(E56G__PMD_CTRL_FSM_RX_STAT_0, ctrl_fsm_rx3_st) != E56PHY_RX_RDY_ST) {
2367 : 0 : rdata = rd32_ephy(hw, addr);
2368 : 0 : usec_delay(500);
2369 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT) {
2370 : : rdata = 0;
2371 : : addr = E56PHY_PMD_CFG_0_ADDR;
2372 : 0 : rdata = rd32_ephy(hw, addr);
2373 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_0_RX_EN_CFG, 0x0);
2374 : : wr32_ephy(hw, addr, rdata);
2375 : 0 : return TXGBE_ERR_TIMEOUT;
2376 : : }
2377 : : }
2378 : :
2379 : 0 : rdata = 0;
2380 : : timer = 0;
2381 [ # # ]: 0 : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_cdr_rdy_o) != 1) {
2382 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDVAL_1);
2383 : 0 : usec_delay(500);
2384 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2385 : : return TXGBE_ERR_TIMEOUT;
2386 : : }
2387 : :
2388 : 0 : rdata = 0;
2389 : : timer = 0;
2390 [ # # ]: 0 : while (EPHY_XFLD(E56G__PMD_RXS1_OVRDVAL_1, rxs1_rx0_cdr_rdy_o) != 1) {
2391 : 0 : EPHY_RREG(E56G__PMD_RXS1_OVRDVAL_1);
2392 : 0 : usec_delay(500);
2393 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2394 : : return TXGBE_ERR_TIMEOUT;
2395 : : }
2396 : :
2397 : 0 : rdata = 0;
2398 : : timer = 0;
2399 [ # # ]: 0 : while (EPHY_XFLD(E56G__PMD_RXS2_OVRDVAL_1, rxs2_rx0_cdr_rdy_o) != 1) {
2400 : 0 : EPHY_RREG(E56G__PMD_RXS2_OVRDVAL_1);
2401 : 0 : usec_delay(500);
2402 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2403 : : return TXGBE_ERR_TIMEOUT;
2404 : : }
2405 : :
2406 : 0 : rdata = 0;
2407 : : timer = 0;
2408 [ # # ]: 0 : while (EPHY_XFLD(E56G__PMD_RXS3_OVRDVAL_1, rxs3_rx0_cdr_rdy_o) != 1) {
2409 : 0 : EPHY_RREG(E56G__PMD_RXS3_OVRDVAL_1);
2410 : 0 : usec_delay(500);
2411 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2412 : : return TXGBE_ERR_TIMEOUT;
2413 : : }
2414 : :
2415 [ # # ]: 0 : for (i = 0; i < 4; i++) {
2416 : : /* 4. Disable VGA and CTLE training so they don't interfere with ADC calibration */
2417 : : /* a. Set ALIAS::RXS::VGA_TRAIN_EN = 0b0 */
2418 : 0 : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2419 : : rdata = rd32_ephy(hw, addr);
2420 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_VGA_TRAIN_EN_I, 0x0);
2421 : : wr32_ephy(hw, addr, rdata);
2422 : :
2423 : 0 : addr = E56PHY_RXS0_OVRDEN_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2424 : : rdata = rd32_ephy(hw, addr);
2425 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_VGA_TRAIN_EN_I, 0x1);
2426 : : wr32_ephy(hw, addr, rdata);
2427 : :
2428 : : /* b. Set ALIAS::RXS::CTLE_TRAIN_EN = 0b0 */
2429 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2430 : : rdata = rd32_ephy(hw, addr);
2431 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_CTLE_TRAIN_EN_I, 0x0);
2432 : : wr32_ephy(hw, addr, rdata);
2433 : :
2434 : : addr = E56PHY_RXS0_OVRDEN_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2435 : : rdata = rd32_ephy(hw, addr);
2436 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_CTLE_TRAIN_EN_I, 0x1);
2437 : : wr32_ephy(hw, addr, rdata);
2438 : :
2439 : : /* 5. Perform ADC interleaver calibration */
2440 : : /* a. Remove the OVERRIDE on ALIAS::RXS::ADC_INTL_CAL_DONE */
2441 : : addr = E56PHY_RXS0_OVRDEN_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2442 : : rdata = rd32_ephy(hw, addr);
2443 : : set_fields_e56(&rdata,
2444 : : E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_ADC_INTL_CAL_DONE_O, 0x0);
2445 : : wr32_ephy(hw, addr, rdata);
2446 : :
2447 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2448 : : rdata = rd32_ephy(hw, addr);
2449 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_CAL_EN_I, 0x1);
2450 : : wr32_ephy(hw, addr, rdata);
2451 : :
2452 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2453 : : timer = 0;
2454 : 0 : while (((rdata >> E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_CAL_DONE_O_LSB)
2455 [ # # ]: 0 : & 1) != 1) {
2456 : 0 : rdata = rd32_ephy(hw, addr);
2457 : 0 : usec_delay(1000);
2458 : :
2459 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2460 : : break;
2461 : : }
2462 : :
2463 : : /*
2464 : : * 6. Perform ADC offset adaptation and ADC gain adaptation, repeat them a few
2465 : : * times and after that keep it disabled.
2466 : : */
2467 [ # # ]: 0 : for (j = 0; j < 16; j++) {
2468 : : /* a. ALIAS::RXS::ADC_OFST_ADAPT_EN = 0b1 */
2469 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2470 : : rdata = rd32_ephy(hw, addr);
2471 : : set_fields_e56(&rdata,
2472 : : E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_OFST_ADAPT_EN_I, 0x1);
2473 : : wr32_ephy(hw, addr, rdata);
2474 : :
2475 : : /* b. Wait for 1ms or greater */
2476 : 0 : addr = E56G__PMD_RXS0_OVRDEN_2_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2477 : 0 : rdata = rd32_ephy(hw, addr);
2478 : : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_2,
2479 : 0 : ovrd_en_rxs0_rx0_adc_ofst_adapt_done_o) = 0;
2480 : 0 : wr32_ephy(hw, addr, rdata);
2481 : :
2482 : 0 : rdata = 0;
2483 : : addr = E56G__PMD_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2484 : : timer = 0;
2485 : 0 : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1,
2486 [ # # ]: 0 : rxs0_rx0_adc_ofst_adapt_done_o) != 1) {
2487 : 0 : rdata = rd32_ephy(hw, addr);
2488 : 0 : usec_delay(500);
2489 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2490 : : break;
2491 : : }
2492 : :
2493 : : /* c. ALIAS::RXS::ADC_OFST_ADAPT_EN = 0b0 */
2494 : : rdata = 0x0000;
2495 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2496 : : rdata = rd32_ephy(hw, addr);
2497 : : set_fields_e56(&rdata,
2498 : : E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_OFST_ADAPT_EN_I, 0x0);
2499 : : wr32_ephy(hw, addr, rdata);
2500 : :
2501 : : /* d. ALIAS::RXS::ADC_GAIN_ADAPT_EN = 0b1 */
2502 : : rdata = 0x0000;
2503 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2504 : : rdata = rd32_ephy(hw, addr);
2505 : : set_fields_e56(&rdata,
2506 : : E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_GAIN_ADAPT_EN_I, 0x1);
2507 : : wr32_ephy(hw, addr, rdata);
2508 : :
2509 : : /* e. Wait for 1ms or greater */
2510 : : addr = E56G__PMD_RXS0_OVRDEN_2_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2511 : 0 : rdata = rd32_ephy(hw, addr);
2512 : : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_2,
2513 : 0 : ovrd_en_rxs0_rx0_adc_ofst_adapt_done_o) = 0;
2514 : 0 : wr32_ephy(hw, addr, rdata);
2515 : :
2516 : 0 : rdata = 0;
2517 : : timer = 0;
2518 : : addr = E56G__PMD_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2519 : 0 : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1,
2520 [ # # ]: 0 : rxs0_rx0_adc_gain_adapt_done_o) != 1) {
2521 : 0 : rdata = rd32_ephy(hw, addr);
2522 : 0 : usec_delay(500);
2523 : :
2524 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2525 : : break;
2526 : : }
2527 : :
2528 : : /* f. ALIAS::RXS::ADC_GAIN_ADAPT_EN = 0b0 */
2529 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2530 : : rdata = rd32_ephy(hw, addr);
2531 : : set_fields_e56(&rdata,
2532 : : E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_GAIN_ADAPT_EN_I, 0x0);
2533 : : wr32_ephy(hw, addr, rdata);
2534 : : /* g. Repeat #a to #f total 16 times */
2535 : : }
2536 : :
2537 : : /*
2538 : : * 7. Perform ADC interleaver adaptation for 10ms or greater,
2539 : : * and after that disable it
2540 : : * a. ALIAS::RXS::ADC_INTL_ADAPT_EN = 0b1
2541 : : */
2542 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2543 : : rdata = rd32_ephy(hw, addr);
2544 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_ADAPT_EN_I, 0x1);
2545 : : wr32_ephy(hw, addr, rdata);
2546 : : /* b. Wait for 10ms or greater */
2547 : : msleep(10);
2548 : :
2549 : : /* c. ALIAS::RXS::ADC_INTL_ADAPT_EN = 0b0 */
2550 : 0 : addr = E56G__PMD_RXS0_OVRDEN_2_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2551 : 0 : rdata = rd32_ephy(hw, addr);
2552 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_2, ovrd_en_rxs0_rx0_adc_intl_adapt_en_i) = 0;
2553 : 0 : wr32_ephy(hw, addr, rdata);
2554 : :
2555 : : /*
2556 : : * 8. Now re-enable VGA and CTLE trainings, so that it continues to adapt tracking
2557 : : * changes in temperature or voltage
2558 : : */
2559 : : addr = E56G__PMD_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2560 : 0 : rdata = rd32_ephy(hw, addr);
2561 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_vga_train_en_i) = 1;
2562 : : if (bypass_ctle == 0)
2563 : : EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_ctle_train_en_i) = 1;
2564 : 0 : wr32_ephy(hw, addr, rdata);
2565 : :
2566 : : addr = E56G__PMD_RXS0_OVRDEN_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2567 : 0 : rdata = rd32_ephy(hw, addr);
2568 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_vga_train_done_o) = 0;
2569 : 0 : wr32_ephy(hw, addr, rdata);
2570 : :
2571 : 0 : rdata = 0;
2572 : : timer = 0;
2573 : : addr = E56G__PMD_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2574 [ # # ]: 0 : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_vga_train_done_o) != 1) {
2575 : 0 : rdata = rd32_ephy(hw, addr);
2576 : 0 : usec_delay(500);
2577 : :
2578 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2579 : : break;
2580 : : }
2581 : :
2582 : : if (bypass_ctle == 0) {
2583 : : addr = E56G__PMD_RXS0_OVRDEN_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2584 : : rdata = rd32_ephy(hw, addr);
2585 : : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_ctle_train_done_o) = 0;
2586 : : wr32_ephy(hw, addr, rdata);
2587 : :
2588 : : rdata = 0;
2589 : : timer = 0;
2590 : : addr = E56G__PMD_RXS0_OVRDVAL_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2591 : : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1,
2592 : : rxs0_rx0_ctle_train_done_o) != 1) {
2593 : : rdata = rd32_ephy(hw, addr);
2594 : : usec_delay(500);
2595 : :
2596 : : if (timer++ > PHYINIT_TIMEOUT)
2597 : : break;
2598 : : }
2599 : : }
2600 : :
2601 : : /* a. Remove the OVERRIDE on ALIAS::RXS::VGA_TRAIN_EN */
2602 : : addr = E56G__PMD_RXS0_OVRDEN_1_ADDR + (E56PHY_PMD_RX_OFFSET * i);
2603 : 0 : rdata = rd32_ephy(hw, addr);
2604 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_vga_train_en_i) = 0;
2605 : : /* b. Remove the OVERRIDE on ALIAS::RXS::CTLE_TRAIN_EN */
2606 : : if (bypass_ctle == 0)
2607 : : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_ctle_train_en_i) = 0;
2608 : 0 : wr32_ephy(hw, addr, rdata);
2609 : :
2610 : : }
2611 : : return status;
2612 : : }
2613 : :
2614 : : static inline int
2615 : 0 : txgbe_e56_rxs_calib_adapt_seq(struct txgbe_hw *hw, u32 speed)
2616 : : {
2617 : : int status = 0, i;
2618 : : u32 addr, timer;
2619 : : u32 rdata = 0x0;
2620 : : bool bypass_ctle = true;
2621 : :
2622 [ # # ]: 0 : if (hw->phy.sfp_type == txgbe_sfp_type_da_cu_core0 ||
2623 : : hw->phy.sfp_type == txgbe_sfp_type_da_cu_core1)
2624 : : bypass_ctle = 0;
2625 : :
2626 [ # # ]: 0 : if (hw->mac.type == txgbe_mac_aml) {
2627 : : msleep(350);
2628 : : rdata = rd32(hw, TXGBE_GPIOEXT);
2629 [ # # ]: 0 : if (rdata & (TXGBE_SFP1_MOD_ABS_LS | TXGBE_SFP1_RX_LOS_LS)) {
2630 [ # # ]: 0 : if (rdata & TXGBE_SFP1_MOD_ABS_LS)
2631 : 0 : DEBUGOUT("E56phyRxsCalibAdaptSeq TXGBE_SFP1_MOD_ABS_LS");
2632 [ # # ]: 0 : else if (rdata & TXGBE_SFP1_RX_LOS_LS)
2633 : 0 : DEBUGOUT("E56phyRxsCalibAdaptSeq TXGBE_SFP1_RX_LOS_LS");
2634 : 0 : return TXGBE_ERR_PHY_INIT_NOT_DONE;
2635 : : }
2636 : : }
2637 : :
2638 : : rdata = 0;
2639 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2640 : : rdata = rd32_ephy(hw, addr);
2641 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_OFST_ADAPT_EN_I, 0x0);
2642 : : wr32_ephy(hw, addr, rdata);
2643 : :
2644 : : addr = E56PHY_RXS0_OVRDEN_2_ADDR;
2645 : : rdata = rd32_ephy(hw, addr);
2646 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_2_OVRD_EN_RXS0_RX0_ADC_OFST_ADAPT_EN_I
2647 : : , 0x1);
2648 : : wr32_ephy(hw, addr, rdata);
2649 : :
2650 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2651 : : rdata = rd32_ephy(hw, addr);
2652 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_GAIN_ADAPT_EN_I, 0x0);
2653 : : wr32_ephy(hw, addr, rdata);
2654 : :
2655 : : addr = E56PHY_RXS0_OVRDEN_2_ADDR;
2656 : : rdata = rd32_ephy(hw, addr);
2657 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_2_OVRD_EN_RXS0_RX0_ADC_GAIN_ADAPT_EN_I
2658 : : , 0x1);
2659 : : wr32_ephy(hw, addr, rdata);
2660 : :
2661 : : rdata = 0;
2662 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2663 : : rdata = rd32_ephy(hw, addr);
2664 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_CAL_EN_I, 0x0);
2665 : : wr32_ephy(hw, addr, rdata);
2666 : :
2667 : : addr = E56PHY_RXS0_OVRDEN_1_ADDR;
2668 : : rdata = rd32_ephy(hw, addr);
2669 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_ADC_INTL_CAL_EN_I,
2670 : : 0x1);
2671 : : wr32_ephy(hw, addr, rdata);
2672 : :
2673 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2674 : : rdata = rd32_ephy(hw, addr);
2675 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_CAL_DONE_O, 0x1);
2676 : : wr32_ephy(hw, addr, rdata);
2677 : :
2678 : : addr = E56PHY_RXS0_OVRDEN_1_ADDR;
2679 : : rdata = rd32_ephy(hw, addr);
2680 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_ADC_INTL_CAL_DONE_O
2681 : : , 0x1);
2682 : : wr32_ephy(hw, addr, rdata);
2683 : :
2684 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2685 : : rdata = rd32_ephy(hw, addr);
2686 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_ADAPT_EN_I, 0x0);
2687 : : wr32_ephy(hw, addr, rdata);
2688 : :
2689 : : addr = E56PHY_RXS0_OVRDEN_2_ADDR;
2690 : : rdata = rd32_ephy(hw, addr);
2691 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_2_OVRD_EN_RXS0_RX0_ADC_INTL_ADAPT_EN_I
2692 : : , 0x1);
2693 : : wr32_ephy(hw, addr, rdata);
2694 : :
2695 [ # # ]: 0 : if (bypass_ctle == 1)
2696 : 0 : txgbe_e56_ctle_bypass_seq(hw, speed);
2697 : :
2698 : : /*
2699 : : * 2. Follow sequence described in 2.3.2 RXS Osc Initialization for temperature
2700 : : * tracking range here. RXS would be enabled at the end of this sequence. For the case
2701 : : * when PAM4 KR training is not enabled (including PAM4 mode without KR training),
2702 : : * wait until ALIAS::PDIG::CTRL_FSM_RX_ST would return RX_TRAIN_15_ST (RX_RDY_ST).
2703 : : */
2704 : 0 : status |= txgbe_e56_rxs_osc_init_for_temp_track_range(hw, speed);
2705 : :
2706 : : addr = E56PHY_CTRL_FSM_RX_STAT_0_ADDR;
2707 : : timer = 0;
2708 : 0 : rdata = 0;
2709 : 0 : while (EPHY_XFLD(E56G__PMD_CTRL_FSM_RX_STAT_0,
2710 [ # # ]: 0 : ctrl_fsm_rx0_st) != E56PHY_RX_RDY_ST) {
2711 : : rdata = rd32_ephy(hw, addr);
2712 : 0 : usec_delay(500);
2713 : 0 : EPHY_RREG(E56G__PMD_CTRL_FSM_RX_STAT_0);
2714 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT) {
2715 : : rdata = 0;
2716 : : addr = E56PHY_PMD_CFG_0_ADDR;
2717 : 0 : rdata = rd32_ephy(hw, addr);
2718 : : set_fields_e56(&rdata, E56PHY_PMD_CFG_0_RX_EN_CFG, 0x0);
2719 : : wr32_ephy(hw, addr, rdata);
2720 : 0 : return TXGBE_ERR_TIMEOUT;
2721 : : }
2722 : : }
2723 : :
2724 : 0 : rdata = 0;
2725 : : timer = 0;
2726 [ # # ]: 0 : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_cdr_rdy_o) != 1) {
2727 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDVAL_1);
2728 : 0 : usec_delay(500);
2729 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2730 : : return TXGBE_ERR_TIMEOUT;
2731 : : }
2732 : :
2733 : : /*
2734 : : * 4. Disable VGA and CTLE training so that they don't interfere with ADC calibration
2735 : : * a. Set ALIAS::RXS::VGA_TRAIN_EN = 0b0
2736 : : */
2737 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2738 : : rdata = rd32_ephy(hw, addr);
2739 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_VGA_TRAIN_EN_I, 0x0);
2740 : : wr32_ephy(hw, addr, rdata);
2741 : :
2742 : : addr = E56PHY_RXS0_OVRDEN_1_ADDR;
2743 : : rdata = rd32_ephy(hw, addr);
2744 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_VGA_TRAIN_EN_I,
2745 : : 0x1);
2746 : : wr32_ephy(hw, addr, rdata);
2747 : :
2748 : : /* b. Set ALIAS::RXS::CTLE_TRAIN_EN = 0b0 */
2749 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2750 : : rdata = rd32_ephy(hw, addr);
2751 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_CTLE_TRAIN_EN_I, 0x0);
2752 : : wr32_ephy(hw, addr, rdata);
2753 : :
2754 : : addr = E56PHY_RXS0_OVRDEN_1_ADDR;
2755 : : rdata = rd32_ephy(hw, addr);
2756 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_CTLE_TRAIN_EN_I,
2757 : : 0x1);
2758 : : wr32_ephy(hw, addr, rdata);
2759 : :
2760 : : /*
2761 : : * 5. Perform ADC interleaver calibration
2762 : : * a. Remove the OVERRIDE on ALIAS::RXS::ADC_INTL_CAL_DONE
2763 : : */
2764 : : addr = E56PHY_RXS0_OVRDEN_1_ADDR;
2765 : : rdata = rd32_ephy(hw, addr);
2766 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDEN_1_OVRD_EN_RXS0_RX0_ADC_INTL_CAL_DONE_O
2767 : : , 0x0);
2768 : : wr32_ephy(hw, addr, rdata);
2769 : :
2770 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2771 : : rdata = rd32_ephy(hw, addr);
2772 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_CAL_EN_I, 0x1);
2773 : : wr32_ephy(hw, addr, rdata);
2774 : :
2775 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2776 : : timer = 0;
2777 : 0 : while (((rdata >> E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_CAL_DONE_O_LSB) & 1)
2778 [ # # ]: 0 : != 1) {
2779 : 0 : rdata = rd32_ephy(hw, addr);
2780 : 0 : usec_delay(1000);
2781 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2782 : : break;
2783 : : }
2784 : :
2785 : : /*
2786 : : * 6. Perform ADC offset adaptation and ADC gain adaptation,
2787 : : * repeat them a few times and after that keep it disabled.
2788 : : */
2789 [ # # ]: 0 : for (i = 0; i < 16; i++) {
2790 : : /* a. ALIAS::RXS::ADC_OFST_ADAPT_EN = 0b1 */
2791 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2792 : : rdata = rd32_ephy(hw, addr);
2793 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_OFST_ADAPT_EN_I, 0x1);
2794 : : wr32_ephy(hw, addr, rdata);
2795 : :
2796 : : /* b. Wait for 1ms or greater */
2797 : 0 : txgbe_e56_ephy_config(E56G__PMD_RXS0_OVRDEN_2,
2798 : : ovrd_en_rxs0_rx0_adc_ofst_adapt_done_o, 0);
2799 : 0 : rdata = 0;
2800 : : timer = 0;
2801 : 0 : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1,
2802 [ # # ]: 0 : rxs0_rx0_adc_ofst_adapt_done_o) != 1) {
2803 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDVAL_1);
2804 : 0 : usec_delay(500);
2805 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2806 : : break;
2807 : : }
2808 : :
2809 : : /* c. ALIAS::RXS::ADC_OFST_ADAPT_EN = 0b0 */
2810 : : rdata = 0x0000;
2811 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2812 : : rdata = rd32_ephy(hw, addr);
2813 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_OFST_ADAPT_EN_I, 0x0);
2814 : : wr32_ephy(hw, addr, rdata);
2815 : :
2816 : : /* d. ALIAS::RXS::ADC_GAIN_ADAPT_EN = 0b1 */
2817 : : rdata = 0x0000;
2818 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2819 : : rdata = rd32_ephy(hw, addr);
2820 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_GAIN_ADAPT_EN_I, 0x1);
2821 : : wr32_ephy(hw, addr, rdata);
2822 : :
2823 : : /* e. Wait for 1ms or greater */
2824 : 0 : txgbe_e56_ephy_config(E56G__PMD_RXS0_OVRDEN_2,
2825 : : ovrd_en_rxs0_rx0_adc_ofst_adapt_done_o, 0);
2826 : 0 : rdata = 0;
2827 : : timer = 0;
2828 : 0 : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1,
2829 [ # # ]: 0 : rxs0_rx0_adc_gain_adapt_done_o) != 1) {
2830 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDVAL_1);
2831 : 0 : usec_delay(500);
2832 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2833 : : break;
2834 : : }
2835 : :
2836 : : /* f. ALIAS::RXS::ADC_GAIN_ADAPT_EN = 0b0 */
2837 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2838 : : rdata = rd32_ephy(hw, addr);
2839 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_GAIN_ADAPT_EN_I, 0x0);
2840 : : wr32_ephy(hw, addr, rdata);
2841 : : /* g. Repeat #a to #f total 16 times */
2842 : : }
2843 : :
2844 : : /*
2845 : : * 7. Perform ADC interleaver adaptation for 10ms or greater, and after that disable it
2846 : : * a. ALIAS::RXS::ADC_INTL_ADAPT_EN = 0b1
2847 : : */
2848 : : addr = E56PHY_RXS0_OVRDVAL_1_ADDR;
2849 : : rdata = rd32_ephy(hw, addr);
2850 : : set_fields_e56(&rdata, E56PHY_RXS0_OVRDVAL_1_RXS0_RX0_ADC_INTL_ADAPT_EN_I, 0x1);
2851 : : wr32_ephy(hw, addr, rdata);
2852 : : /* b. Wait for 10ms or greater */
2853 : : msleep(10);
2854 : :
2855 : : /* c. ALIAS::RXS::ADC_INTL_ADAPT_EN = 0b0 */
2856 : 0 : txgbe_e56_ephy_config(E56G__PMD_RXS0_OVRDEN_2,
2857 : : ovrd_en_rxs0_rx0_adc_intl_adapt_en_i, 0);
2858 : :
2859 : : /*
2860 : : * 8. Now re-enable VGA and CTLE trainings, so that it continues to adapt tracking
2861 : : * changes in temperature or voltage
2862 : : * <1> Set ALIAS::RXS::VGA_TRAIN_EN = 0b1
2863 : : * Set ALIAS::RXS::CTLE_TRAIN_EN = 0b1
2864 : : */
2865 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDVAL_1);
2866 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_vga_train_en_i) = 1;
2867 [ # # ]: 0 : if (bypass_ctle == 0)
2868 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_ctle_train_en_i) = 1;
2869 : 0 : EPHY_WREG(E56G__PMD_RXS0_OVRDVAL_1);
2870 : :
2871 : : /*
2872 : : * <2> wait for ALIAS::RXS::VGA_TRAIN_DONE = 1
2873 : : * wait for ALIAS::RXS::CTLE_TRAIN_DONE = 1
2874 : : */
2875 : 0 : txgbe_e56_ephy_config(E56G__PMD_RXS0_OVRDEN_1,
2876 : : ovrd_en_rxs0_rx0_vga_train_done_o, 0);
2877 : 0 : rdata = 0;
2878 : : timer = 0;
2879 [ # # ]: 0 : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_vga_train_done_o) != 1) {
2880 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDVAL_1);
2881 : 0 : usec_delay(500);
2882 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2883 : : break;
2884 : : }
2885 : :
2886 [ # # ]: 0 : if (bypass_ctle == 0) {
2887 : 0 : txgbe_e56_ephy_config(E56G__PMD_RXS0_OVRDEN_1,
2888 : : ovrd_en_rxs0_rx0_ctle_train_done_o, 0);
2889 : 0 : rdata = 0;
2890 : : timer = 0;
2891 [ # # ]: 0 : while (EPHY_XFLD(E56G__PMD_RXS0_OVRDVAL_1, rxs0_rx0_ctle_train_done_o) != 1) {
2892 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDVAL_1);
2893 : 0 : usec_delay(500);
2894 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT)
2895 : : break;
2896 : : }
2897 : : }
2898 : :
2899 : : /* a. Remove the OVERRIDE on ALIAS::RXS::VGA_TRAIN_EN */
2900 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDEN_1);
2901 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_vga_train_en_i) = 0;
2902 : : /* b. Remove the OVERRIDE on ALIAS::RXS::CTLE_TRAIN_EN */
2903 [ # # ]: 0 : if (bypass_ctle == 0)
2904 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_ctle_train_en_i) = 0;
2905 : 0 : EPHY_WREG(E56G__PMD_RXS0_OVRDEN_1);
2906 : :
2907 : 0 : return status;
2908 : : }
2909 : :
2910 : : static inline u32
2911 : 0 : txgbe_e56_cfg_temp(struct txgbe_hw *hw)
2912 : : {
2913 : : u32 status;
2914 : : u32 value;
2915 : : int temp;
2916 : :
2917 : 0 : status = txgbe_e56_get_temp(hw, &temp);
2918 [ # # ]: 0 : if (status)
2919 : 0 : temp = DEFAULT_TEMP;
2920 : :
2921 [ # # ]: 0 : if (temp < DEFAULT_TEMP) {
2922 : : value = rd32_ephy(hw, CMS_ANA_OVRDEN0);
2923 : : set_fields_e56(&value, 25, 25, 0x1);
2924 : : wr32_ephy(hw, CMS_ANA_OVRDEN0, value);
2925 : :
2926 : : value = rd32_ephy(hw, CMS_ANA_OVRDVAL2);
2927 : : set_fields_e56(&value, 20, 16, 0x1);
2928 : : wr32_ephy(hw, CMS_ANA_OVRDVAL2, value);
2929 : :
2930 : : value = rd32_ephy(hw, CMS_ANA_OVRDEN1);
2931 : : set_fields_e56(&value, 12, 12, 0x1);
2932 : : wr32_ephy(hw, CMS_ANA_OVRDEN1, value);
2933 : :
2934 : : value = rd32_ephy(hw, CMS_ANA_OVRDVAL7);
2935 : : set_fields_e56(&value, 8, 4, 0x1);
2936 : : wr32_ephy(hw, CMS_ANA_OVRDVAL7, value);
2937 [ # # ]: 0 : } else if (temp > HIGH_TEMP) {
2938 : : value = rd32_ephy(hw, CMS_ANA_OVRDEN0);
2939 : : set_fields_e56(&value, 25, 25, 0x1);
2940 : : wr32_ephy(hw, CMS_ANA_OVRDEN0, value);
2941 : :
2942 : : value = rd32_ephy(hw, CMS_ANA_OVRDVAL2);
2943 : : set_fields_e56(&value, 20, 16, 0x3);
2944 : : wr32_ephy(hw, CMS_ANA_OVRDVAL2, value);
2945 : :
2946 : : value = rd32_ephy(hw, CMS_ANA_OVRDEN1);
2947 : : set_fields_e56(&value, 12, 12, 0x1);
2948 : : wr32_ephy(hw, CMS_ANA_OVRDEN1, value);
2949 : :
2950 : : value = rd32_ephy(hw, CMS_ANA_OVRDVAL7);
2951 : : set_fields_e56(&value, 8, 4, 0x3);
2952 : : wr32_ephy(hw, CMS_ANA_OVRDVAL7, value);
2953 : : } else {
2954 : : value = rd32_ephy(hw, CMS_ANA_OVRDEN1);
2955 : : set_fields_e56(&value, 4, 4, 0x1);
2956 : : wr32_ephy(hw, CMS_ANA_OVRDEN1, value);
2957 : :
2958 : : value = rd32_ephy(hw, CMS_ANA_OVRDVAL4);
2959 : : set_fields_e56(&value, 24, 24, 0x1);
2960 : : set_fields_e56(&value, 31, 29, 0x4);
2961 : : wr32_ephy(hw, CMS_ANA_OVRDVAL4, value);
2962 : :
2963 : : value = rd32_ephy(hw, CMS_ANA_OVRDVAL5);
2964 : : set_fields_e56(&value, 1, 0, 0x0);
2965 : : wr32_ephy(hw, CMS_ANA_OVRDVAL5, value);
2966 : :
2967 : : value = rd32_ephy(hw, CMS_ANA_OVRDEN1);
2968 : : set_fields_e56(&value, 23, 23, 0x1);
2969 : : wr32_ephy(hw, CMS_ANA_OVRDEN1, value);
2970 : :
2971 : : value = rd32_ephy(hw, CMS_ANA_OVRDVAL9);
2972 : : set_fields_e56(&value, 24, 24, 0x1);
2973 : : set_fields_e56(&value, 31, 29, 0x4);
2974 : : wr32_ephy(hw, CMS_ANA_OVRDVAL9, value);
2975 : :
2976 : : value = rd32_ephy(hw, CMS_ANA_OVRDVAL10);
2977 : : set_fields_e56(&value, 1, 0, 0x0);
2978 : : wr32_ephy(hw, CMS_ANA_OVRDVAL10, value);
2979 : : }
2980 : :
2981 : 0 : return 0;
2982 : : }
2983 : :
2984 : 0 : static int txgbe_e56_config_rx_40G(struct txgbe_hw *hw, u32 speed)
2985 : : {
2986 : : s32 status;
2987 : :
2988 : 0 : status = txgbe_e56_rxs_calib_adapt_seq_40G(hw, speed);
2989 [ # # ]: 0 : if (status)
2990 : : return status;
2991 : :
2992 : : /* Step 2 of 2.3.4 */
2993 : 0 : txgbe_e56_set_rxs_ufine_le_max_40g(hw, speed);
2994 : :
2995 : : /* 2.3.4 RXS post CDR lock temperature tracking sequence */
2996 : 0 : txgbe_temp_track_seq_40g(hw, speed);
2997 : :
2998 : 0 : hw->link_valid = true;
2999 : :
3000 : 0 : return 0;
3001 : : }
3002 : :
3003 : 0 : static int txgbe_e56_config_rx(struct txgbe_hw *hw, u32 speed)
3004 : : {
3005 : : s32 status;
3006 : :
3007 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_40GB_FULL) {
3008 : 0 : status = txgbe_e56_config_rx_40G(hw, speed);
3009 [ # # ]: 0 : if (status)
3010 : 0 : return status;
3011 : : } else {
3012 : 0 : status = txgbe_e56_rxs_calib_adapt_seq(hw, speed);
3013 [ # # ]: 0 : if (status)
3014 : : return status;
3015 : :
3016 : : /* Step 2 of 2.3.4 */
3017 : 0 : txgbe_e56_set_rxs_ufine_le_max(hw, speed);
3018 : :
3019 : : /* 2.3.4 RXS post CDR lock temperature tracking sequence */
3020 : 0 : txgbe_temp_track_seq(hw, speed);
3021 : : }
3022 : : return 0;
3023 : : }
3024 : :
3025 : : /*
3026 : : * 2.2.10 SEQ::RX_DISABLE
3027 : : * Use PDIG::PMD_CFG[0]::rx_en_cfg[<lane no.>] = 0b0 to powerdown specific RXS lanes.
3028 : : * Completion of RXS powerdown can be confirmed by
3029 : : * observing ALIAS::PDIG::CTRL_FSM_RX_ST = POWERDN_ST
3030 : : */
3031 : 0 : static int txgbe_e56_disable_rx40G(struct txgbe_hw *hw)
3032 : : {
3033 : : int status = 0;
3034 : : unsigned int rdata, timer;
3035 : : unsigned int addr, temp;
3036 : : int i;
3037 : :
3038 [ # # ]: 0 : for (i = 0; i < 4; i++) {
3039 : : /* 1. Disable OVERRIDE on below aliases */
3040 : : /* a. ALIAS::RXS::RANGE_SEL */
3041 : : rdata = 0x0000;
3042 : 0 : addr = E56G__RXS0_ANA_OVRDEN_0_ADDR + (i * E56PHY_RXS_OFFSET);
3043 : 0 : rdata = rd32_ephy(hw, addr);
3044 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_0, ovrd_en_ana_bbcdr_osc_range_sel_i) = 0;
3045 : 0 : wr32_ephy(hw, addr, rdata);
3046 : :
3047 : 0 : addr = E56G__RXS0_ANA_OVRDEN_1_ADDR + (i * E56PHY_RXS_OFFSET);
3048 : 0 : rdata = rd32_ephy(hw, addr);
3049 : : /* b. ALIAS::RXS::COARSE */
3050 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_coarse_i) = 0;
3051 : : /* c. ALIAS::RXS::FINE */
3052 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 0;
3053 : : /* d. ALIAS::RXS::ULTRAFINE */
3054 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i) = 0;
3055 : 0 : wr32_ephy(hw, addr, rdata);
3056 : :
3057 : : /* e. ALIAS::RXS::SAMP_CAL_DONE */
3058 : 0 : addr = E56G__PMD_RXS0_OVRDEN_0_ADDR + (i * E56PHY_PMD_RX_OFFSET);
3059 : 0 : rdata = rd32_ephy(hw, addr);
3060 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_0, ovrd_en_rxs0_rx0_samp_cal_done_o) = 0;
3061 : 0 : wr32_ephy(hw, addr, rdata);
3062 : :
3063 : 0 : addr = E56G__PMD_RXS0_OVRDEN_2_ADDR + (i * E56PHY_PMD_RX_OFFSET);
3064 : 0 : rdata = rd32_ephy(hw, addr);
3065 : : /* f. ALIAS::RXS::ADC_OFST_ADAPT_EN */
3066 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_2, ovrd_en_rxs0_rx0_adc_ofst_adapt_en_i) = 0;
3067 : : /* g. ALIAS::RXS::ADC_GAIN_ADAPT_EN */
3068 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_2, ovrd_en_rxs0_rx0_adc_gain_adapt_en_i) = 0;
3069 : : /* j. ALIAS::RXS::ADC_INTL_ADAPT_EN */
3070 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_2, ovrd_en_rxs0_rx0_adc_intl_adapt_en_i) = 0;
3071 : 0 : wr32_ephy(hw, addr, rdata);
3072 : :
3073 : 0 : addr = E56G__PMD_RXS0_OVRDEN_1_ADDR + (i * E56PHY_PMD_RX_OFFSET);
3074 : 0 : rdata = rd32_ephy(hw, addr);
3075 : : /* h. ALIAS::RXS::ADC_INTL_CAL_EN */
3076 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_adc_intl_cal_en_i) = 0;
3077 : : /* i. ALIAS::RXS::ADC_INTL_CAL_DONE */
3078 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_adc_intl_cal_done_o) = 0;
3079 : : /* k. ALIAS::RXS::CDR_EN */
3080 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_cdr_en_i) = 0;
3081 : : /* l. ALIAS::RXS::VGA_TRAIN_EN */
3082 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_vga_train_en_i) = 0;
3083 : : /* m. ALIAS::RXS::CTLE_TRAIN_EN */
3084 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_ctle_train_en_i) = 0;
3085 : : /* p. ALIAS::RXS::RX_FETX_TRAIN_DONE */
3086 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_txffe_train_done_o) = 0;
3087 : : /* r. ALIAS::RXS::RX_TXFFE_COEFF_CHANGE */
3088 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_txffe_coeff_change_o) = 0;
3089 : : /* s. ALIAS::RXS::RX_TXFFE_TRAIN_ENACK */
3090 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_txffe_train_enack_o) = 0;
3091 : 0 : wr32_ephy(hw, addr, rdata);
3092 : :
3093 : 0 : addr = E56G__PMD_RXS0_OVRDEN_3_ADDR + (i * E56PHY_PMD_RX_OFFSET);
3094 : 0 : rdata = rd32_ephy(hw, addr);
3095 : : /* n. ALIAS::RXS::RX_FETX_MOD_TYPE */
3096 : : /* o. ALIAS::RXS::RX_FETX_MOD_TYPE_UPDATE */
3097 : : temp = EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_3, ovrd_en_rxs0_rx0_spareout_o);
3098 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_3, ovrd_en_rxs0_rx0_spareout_o) = temp & 0x8F;
3099 : 0 : wr32_ephy(hw, addr, rdata);
3100 : :
3101 : 0 : addr = E56G__RXS0_DIG_OVRDEN_1_ADDR + (i * E56PHY_RXS_OFFSET);
3102 : 0 : rdata = rd32_ephy(hw, addr);
3103 : : /* q. ALIAS::RXS::SLICER_THRESHOLD_OVRD_EN */
3104 : 0 : EPHY_XFLD(E56G__RXS0_DIG_OVRDEN_1, top_comp_th_ovrd_en) = 0;
3105 : 0 : EPHY_XFLD(E56G__RXS0_DIG_OVRDEN_1, mid_comp_th_ovrd_en) = 0;
3106 : 0 : EPHY_XFLD(E56G__RXS0_DIG_OVRDEN_1, bot_comp_th_ovrd_en) = 0;
3107 : 0 : wr32_ephy(hw, addr, rdata);
3108 : :
3109 : : /* 2. Disable pattern checker */
3110 : 0 : addr = E56G__RXS0_DFT_1_ADDR + (i * E56PHY_RXS_OFFSET);
3111 : 0 : rdata = rd32_ephy(hw, addr);
3112 : 0 : EPHY_XFLD(E56G__RXS0_DFT_1, ber_en) = 0;
3113 : 0 : wr32_ephy(hw, addr, rdata);
3114 : :
3115 : : /* 3. Disable internal serial loopback mode */
3116 : 0 : addr = E56G__RXS0_ANA_OVRDEN_3_ADDR + (i * E56PHY_RXS_OFFSET);
3117 : 0 : rdata = rd32_ephy(hw, addr);
3118 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_3, ovrd_en_ana_sel_lpbk_i) = 0;
3119 : 0 : wr32_ephy(hw, addr, rdata);
3120 : :
3121 : 0 : addr = E56G__RXS0_ANA_OVRDEN_2_ADDR + (i * E56PHY_RXS_OFFSET);
3122 : 0 : rdata = rd32_ephy(hw, addr);
3123 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_2, ovrd_en_ana_en_adccal_lpbk_i) = 0;
3124 : 0 : wr32_ephy(hw, addr, rdata);
3125 : :
3126 : : /* 4. Enable bypass of clock gates in RXS - */
3127 : 0 : addr = E56G__RXS0_RXS_CFG_0_ADDR + (i * E56PHY_RXS_OFFSET);
3128 : 0 : rdata = rd32_ephy(hw, addr);
3129 : 0 : EPHY_XFLD(E56G__RXS0_RXS_CFG_0, train_clk_gate_bypass_en) = 0x1FFF;
3130 : 0 : wr32_ephy(hw, addr, rdata);
3131 : : }
3132 : :
3133 : : /* 5. Disable KR training mode */
3134 : : /* a. ALIAS::PDIG::KR_TRAINING_MODE = 0b0 */
3135 : : addr = E56G__PMD_BASER_PMD_CONTROL_ADDR;
3136 : 0 : rdata = rd32_ephy(hw, addr);
3137 : 0 : EPHY_XFLD(E56G__PMD_BASER_PMD_CONTROL, training_enable_ln0) = 0;
3138 : 0 : EPHY_XFLD(E56G__PMD_BASER_PMD_CONTROL, training_enable_ln1) = 0;
3139 : 0 : EPHY_XFLD(E56G__PMD_BASER_PMD_CONTROL, training_enable_ln2) = 0;
3140 : 0 : EPHY_XFLD(E56G__PMD_BASER_PMD_CONTROL, training_enable_ln3) = 0;
3141 : 0 : wr32_ephy(hw, addr, rdata);
3142 : :
3143 : : /* 6. Disable RX to TX parallel loopback */
3144 : : /* a. ALIAS::PDIG::RX_TO_TX_LPBK_EN = 0b0 */
3145 : : addr = E56G__PMD_PMD_CFG_5_ADDR;
3146 : 0 : rdata = rd32_ephy(hw, addr);
3147 : 0 : EPHY_XFLD(E56G__PMD_PMD_CFG_5, rx_to_tx_lpbk_en) = 0x0;
3148 : 0 : wr32_ephy(hw, addr, rdata);
3149 : :
3150 : : /*
3151 : : * The FSM to disable RXS is present in PDIG. The FSM disables the RXS when
3152 : : * PDIG::PMD_CFG[0]::rx_en_cfg[<lane no.>] = 0b0
3153 : : */
3154 : 0 : txgbe_e56_ephy_config(E56G__PMD_PMD_CFG_0, rx_en_cfg, 0);
3155 : :
3156 : : /* Wait RX FSM to be POWERDN_ST */
3157 : : timer = 0;
3158 : :
3159 : 0 : while (EPHY_XFLD(E56G__PMD_CTRL_FSM_RX_STAT_0, ctrl_fsm_rx0_st) != 0x21 ||
3160 : : EPHY_XFLD(E56G__PMD_CTRL_FSM_RX_STAT_0, ctrl_fsm_rx1_st) != 0x21 ||
3161 [ # # ]: 0 : EPHY_XFLD(E56G__PMD_CTRL_FSM_RX_STAT_0, ctrl_fsm_rx2_st) != 0x21 ||
3162 : : EPHY_XFLD(E56G__PMD_CTRL_FSM_RX_STAT_0, ctrl_fsm_rx3_st) != 0x21) {
3163 : : rdata = 0;
3164 : : addr = E56PHY_CTRL_FSM_RX_STAT_0_ADDR;
3165 : 0 : rdata = rd32_ephy(hw, addr);
3166 : 0 : usec_delay(100);
3167 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT) {
3168 : 0 : DEBUGOUT("ERROR: Wait E56PHY_CTRL_FSM_RX_STAT_0_ADDR Timeout!");
3169 : 0 : break;
3170 : : }
3171 : : }
3172 : :
3173 : 0 : return status;
3174 : : }
3175 : :
3176 : 0 : static int txgbe_e56_disable_rx(struct txgbe_hw *hw)
3177 : : {
3178 : : int status = 0;
3179 : : unsigned int rdata, timer;
3180 : : unsigned int addr, temp;
3181 : :
3182 : : /* 1. Disable OVERRIDE on below aliases */
3183 : : /* a. ALIAS::RXS::RANGE_SEL */
3184 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDEN_0, ovrd_en_ana_bbcdr_osc_range_sel_i, 0);
3185 : :
3186 : 0 : EPHY_RREG(E56G__RXS0_ANA_OVRDEN_1);
3187 : : /* b. ALIAS::RXS::COARSE */
3188 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_coarse_i) = 0;
3189 : : /* c. ALIAS::RXS::FINE */
3190 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_fine_i) = 0;
3191 : : /* d. ALIAS::RXS::ULTRAFINE */
3192 : 0 : EPHY_XFLD(E56G__RXS0_ANA_OVRDEN_1, ovrd_en_ana_bbcdr_ultrafine_i) = 0;
3193 : 0 : EPHY_WREG(E56G__RXS0_ANA_OVRDEN_1);
3194 : :
3195 : : /* e. ALIAS::RXS::SAMP_CAL_DONE */
3196 : 0 : txgbe_e56_ephy_config(E56G__PMD_RXS0_OVRDEN_0, ovrd_en_rxs0_rx0_samp_cal_done_o, 0);
3197 : :
3198 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDEN_2);
3199 : : /* f. ALIAS::RXS::ADC_OFST_ADAPT_EN */
3200 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_2, ovrd_en_rxs0_rx0_adc_ofst_adapt_en_i) = 0;
3201 : : /* g. ALIAS::RXS::ADC_GAIN_ADAPT_EN */
3202 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_2, ovrd_en_rxs0_rx0_adc_gain_adapt_en_i) = 0;
3203 : : /* j. ALIAS::RXS::ADC_INTL_ADAPT_EN */
3204 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_2, ovrd_en_rxs0_rx0_adc_intl_adapt_en_i) = 0;
3205 : 0 : EPHY_WREG(E56G__PMD_RXS0_OVRDEN_2);
3206 : :
3207 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDEN_1);
3208 : : /* h. ALIAS::RXS::ADC_INTL_CAL_EN */
3209 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_adc_intl_cal_en_i) = 0;
3210 : : /* i. ALIAS::RXS::ADC_INTL_CAL_DONE */
3211 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_adc_intl_cal_done_o) = 0;
3212 : : /* k. ALIAS::RXS::CDR_EN */
3213 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_cdr_en_i) = 0;
3214 : : /* l. ALIAS::RXS::VGA_TRAIN_EN */
3215 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_vga_train_en_i) = 0;
3216 : : /* m. ALIAS::RXS::CTLE_TRAIN_EN */
3217 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_ctle_train_en_i) = 0;
3218 : : /* p. ALIAS::RXS::RX_FETX_TRAIN_DONE */
3219 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_txffe_train_done_o) = 0;
3220 : : /* r. ALIAS::RXS::RX_TXFFE_COEFF_CHANGE */
3221 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_txffe_coeff_change_o) = 0;
3222 : : /* s. ALIAS::RXS::RX_TXFFE_TRAIN_ENACK */
3223 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_1, ovrd_en_rxs0_rx0_txffe_train_enack_o) = 0;
3224 : 0 : EPHY_WREG(E56G__PMD_RXS0_OVRDEN_1);
3225 : :
3226 : 0 : EPHY_RREG(E56G__PMD_RXS0_OVRDEN_3);
3227 : : /* n. ALIAS::RXS::RX_FETX_MOD_TYPE */
3228 : : /* o. ALIAS::RXS::RX_FETX_MOD_TYPE_UPDATE */
3229 : : temp = EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_3, ovrd_en_rxs0_rx0_spareout_o);
3230 : 0 : EPHY_XFLD(E56G__PMD_RXS0_OVRDEN_3, ovrd_en_rxs0_rx0_spareout_o) = temp & 0x8F;
3231 : 0 : EPHY_WREG(E56G__PMD_RXS0_OVRDEN_3);
3232 : :
3233 : : /* q. ALIAS::RXS::SLICER_THRESHOLD_OVRD_EN */
3234 : 0 : EPHY_RREG(E56G__RXS0_DIG_OVRDEN_1);
3235 : 0 : EPHY_XFLD(E56G__RXS0_DIG_OVRDEN_1, top_comp_th_ovrd_en) = 0;
3236 : 0 : EPHY_XFLD(E56G__RXS0_DIG_OVRDEN_1, mid_comp_th_ovrd_en) = 0;
3237 : 0 : EPHY_XFLD(E56G__RXS0_DIG_OVRDEN_1, bot_comp_th_ovrd_en) = 0;
3238 : 0 : EPHY_WREG(E56G__RXS0_DIG_OVRDEN_1);
3239 : :
3240 : : /* 2. Disable pattern checker */
3241 : 0 : txgbe_e56_ephy_config(E56G__RXS0_DFT_1, ber_en, 0);
3242 : :
3243 : : /* 3. Disable internal serial loopback mode */
3244 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDEN_3, ovrd_en_ana_sel_lpbk_i, 0);
3245 : 0 : txgbe_e56_ephy_config(E56G__RXS0_ANA_OVRDEN_2, ovrd_en_ana_en_adccal_lpbk_i, 0);
3246 : :
3247 : : /* 4. Enable bypass of clock gates in RXS */
3248 : 0 : txgbe_e56_ephy_config(E56G__RXS0_RXS_CFG_0, train_clk_gate_bypass_en, 0x1FFF);
3249 : :
3250 : : /* 5. Disable KR training mode */
3251 : : /* a. ALIAS::PDIG::KR_TRAINING_MODE = 0b0 */
3252 : 0 : txgbe_e56_ephy_config(E56G__PMD_BASER_PMD_CONTROL, training_enable_ln0, 0);
3253 : :
3254 : : /* 6. Disable RX to TX parallel loopback */
3255 : : /* a. ALIAS::PDIG::RX_TO_TX_LPBK_EN = 0b0 */
3256 : 0 : txgbe_e56_ephy_config(E56G__PMD_PMD_CFG_5, rx_to_tx_lpbk_en, 0);
3257 : :
3258 : : /*
3259 : : * The FSM to disable RXS is present in PDIG. The FSM disables the RXS when
3260 : : * PDIG::PMD_CFG[0]::rx_en_cfg[<lane no.>] = 0b0
3261 : : */
3262 : 0 : txgbe_e56_ephy_config(E56G__PMD_PMD_CFG_0, rx_en_cfg, 0);
3263 : :
3264 : : /* Wait RX FSM to be POWERDN_ST */
3265 : : timer = 0;
3266 : : while (1) {
3267 : : rdata = 0;
3268 : : addr = E56PHY_CTRL_FSM_RX_STAT_0_ADDR;
3269 : : rdata = rd32_ephy(hw, addr);
3270 [ # # ]: 0 : if ((rdata & 0x3f) == 0x21)
3271 : : break;
3272 : 0 : usec_delay(100);
3273 [ # # ]: 0 : if (timer++ > PHYINIT_TIMEOUT) {
3274 : 0 : DEBUGOUT("ERROR: Wait E56PHY_CTRL_FSM_RX_STAT_0_ADDR Timeout!");
3275 : 0 : break;
3276 : : }
3277 : : }
3278 : :
3279 : 0 : return status;
3280 : : }
3281 : :
3282 : 0 : int txgbe_e56_reconfig_rx(struct txgbe_hw *hw, u32 speed)
3283 : : {
3284 : : u32 addr;
3285 : : u32 rdata;
3286 : : int status = 0;
3287 : :
3288 : : wr32m(hw, TXGBE_MACTXCFG, TXGBE_MACTXCFG_TXE,
3289 : : ~TXGBE_MACTXCFG_TXE);
3290 : : wr32m(hw, TXGBE_MACRXCFG, TXGBE_MACRXCFG_ENA,
3291 : : ~TXGBE_MACRXCFG_ENA);
3292 : :
3293 : 0 : hw->mac.disable_sec_tx_path(hw);
3294 : :
3295 [ # # ]: 0 : if (hw->mac.type == txgbe_mac_aml) {
3296 : : rdata = rd32(hw, TXGBE_GPIOEXT);
3297 [ # # ]: 0 : if (rdata & (TXGBE_SFP1_MOD_ABS_LS | TXGBE_SFP1_RX_LOS_LS))
3298 : : return TXGBE_ERR_TIMEOUT;
3299 : : }
3300 : :
3301 : : wr32_ephy(hw, E56PHY_INTR_0_ENABLE_ADDR, 0x0);
3302 : : wr32_ephy(hw, E56PHY_INTR_1_ENABLE_ADDR, 0x0);
3303 : :
3304 : : /*
3305 : : * 14. Do SEQ::RX_DISABLE to disable RXS. Poll ALIAS::PDIG::CTRL_FSM_RX_ST
3306 : : * and confirm its value is POWERDN_ST
3307 : : */
3308 [ # # ]: 0 : if (hw->mac.type == txgbe_mac_aml40) {
3309 : 0 : txgbe_e56_disable_rx40G(hw);
3310 : 0 : status = txgbe_e56_config_rx_40G(hw, speed);
3311 : : } else {
3312 : 0 : txgbe_e56_disable_rx(hw);
3313 : 0 : status = txgbe_e56_config_rx(hw, speed);
3314 : : }
3315 : :
3316 : : addr = E56PHY_INTR_0_ADDR;
3317 : : wr32_ephy(hw, addr, E56PHY_INTR_0_IDLE_ENTRY1);
3318 : :
3319 : : addr = E56PHY_INTR_1_ADDR;
3320 : : wr32_ephy(hw, addr, E56PHY_INTR_1_IDLE_EXIT1);
3321 : :
3322 : : wr32_ephy(hw, E56PHY_INTR_0_ENABLE_ADDR, E56PHY_INTR_0_IDLE_ENTRY1);
3323 : : wr32_ephy(hw, E56PHY_INTR_1_ENABLE_ADDR, E56PHY_INTR_1_IDLE_EXIT1);
3324 : :
3325 : 0 : hw->mac.enable_sec_tx_path(hw);
3326 : :
3327 : 0 : return status;
3328 : : }
3329 : :
3330 : 0 : int txgbe_set_link_to_amlite(struct txgbe_hw *hw, u32 speed)
3331 : : {
3332 : : u32 value = 0;
3333 : : u32 ppl_lock = false;
3334 : : int status = 0;
3335 : : u32 reset = 0;
3336 : :
3337 : 0 : DEBUGOUT("port[%d] force set speed: 0x%x", hw->bus.lan_id, speed);
3338 : :
3339 [ # # ]: 0 : if ((rd32(hw, TXGBE_EPHY_STAT) & TXGBE_EPHY_STAT_PPL_LOCK) ==
3340 : : TXGBE_EPHY_STAT_PPL_LOCK) {
3341 : : ppl_lock = true;
3342 : : wr32m(hw, TXGBE_MACTXCFG, TXGBE_MACTXCFG_TXE,
3343 : : ~TXGBE_MACTXCFG_TXE);
3344 : : wr32m(hw, TXGBE_MACRXCFG, TXGBE_MACRXCFG_ENA,
3345 : : ~TXGBE_MACRXCFG_ENA);
3346 : :
3347 : 0 : hw->mac.disable_sec_tx_path(hw);
3348 : : }
3349 : :
3350 [ # # ]: 0 : if (hw->mac.type == txgbe_mac_aml)
3351 : 0 : hw->mac.disable_tx_laser(hw);
3352 : :
3353 [ # # ]: 0 : if (hw->bus.lan_id == 0)
3354 : : reset = TXGBE_RST_EPHY_LAN_0;
3355 : :
3356 : : else
3357 : : reset = TXGBE_RST_EPHY_LAN_1;
3358 : :
3359 : 0 : wr32(hw, TXGBE_RST,
3360 : : reset | rd32(hw, TXGBE_RST));
3361 : : txgbe_flush(hw);
3362 : 0 : usec_delay(10);
3363 : :
3364 : : /* XLGPCS REGS Start */
3365 : : value = rd32_epcs(hw, VR_PCS_DIG_CTRL1);
3366 : 0 : value |= 0x8000;
3367 : : wr32_epcs(hw, VR_PCS_DIG_CTRL1, value);
3368 : :
3369 : 0 : usec_delay(1000);
3370 : : value = rd32_epcs(hw, VR_PCS_DIG_CTRL1);
3371 [ # # ]: 0 : if ((value & 0x8000)) {
3372 : : status = TXGBE_ERR_PHY_INIT_NOT_DONE;
3373 : 0 : hw->mac.enable_tx_laser(hw);
3374 : 0 : goto out;
3375 : : }
3376 : :
3377 : : value = rd32_epcs(hw, SR_AN_CTRL);
3378 : : set_fields_e56(&value, 12, 12, 0);
3379 : : wr32_epcs(hw, SR_AN_CTRL, value);
3380 : :
3381 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_40GB_FULL) {
3382 : : value = rd32_epcs(hw, SR_PCS_CTRL1);
3383 : : set_fields_e56(&value, 5, 2, 0x3);
3384 : : wr32_epcs(hw, SR_PCS_CTRL1, value);
3385 : :
3386 : : value = rd32_epcs(hw, SR_PCS_CTRL2);
3387 : : set_fields_e56(&value, 3, 0, 0x4);
3388 : : wr32_epcs(hw, SR_PCS_CTRL2, value);
3389 : :
3390 : : value = rd32_ephy(hw, ANA_OVRDVAL0);
3391 : : set_fields_e56(&value, 29, 29, 0x1);
3392 : : set_fields_e56(&value, 1, 1, 0x1);
3393 : : wr32_ephy(hw, ANA_OVRDVAL0, value);
3394 : :
3395 : : value = rd32_ephy(hw, ANA_OVRDVAL5);
3396 : : set_fields_e56(&value, 24, 24, 0x1);
3397 : : wr32_ephy(hw, ANA_OVRDVAL5, value);
3398 : :
3399 : : value = rd32_ephy(hw, ANA_OVRDEN0);
3400 : : set_fields_e56(&value, 1, 1, 0x1);
3401 : : wr32_ephy(hw, ANA_OVRDEN0, value);
3402 : :
3403 : : value = rd32_ephy(hw, ANA_OVRDEN1);
3404 : : set_fields_e56(&value, 30, 30, 0x1);
3405 : : set_fields_e56(&value, 25, 25, 0x1);
3406 : : wr32_ephy(hw, ANA_OVRDEN1, value);
3407 : :
3408 : : value = rd32_ephy(hw, PLL0_CFG0);
3409 : : set_fields_e56(&value, 25, 24, 0x1);
3410 : : set_fields_e56(&value, 17, 16, 0x3);
3411 : : wr32_ephy(hw, PLL0_CFG0, value);
3412 : :
3413 : : value = rd32_ephy(hw, PLL0_CFG2);
3414 : : set_fields_e56(&value, 12, 8, 0x4);
3415 : : wr32_ephy(hw, PLL0_CFG2, value);
3416 : :
3417 : : value = rd32_ephy(hw, PLL1_CFG0);
3418 : : set_fields_e56(&value, 25, 24, 0x1);
3419 : : set_fields_e56(&value, 17, 16, 0x3);
3420 : : wr32_ephy(hw, PLL1_CFG0, value);
3421 : :
3422 : : value = rd32_ephy(hw, PLL1_CFG2);
3423 : : set_fields_e56(&value, 12, 8, 0x8);
3424 : : wr32_ephy(hw, PLL1_CFG2, value);
3425 : :
3426 : : value = rd32_ephy(hw, PLL0_DIV_CFG0);
3427 : : set_fields_e56(&value, 18, 8, 0x294);
3428 : : set_fields_e56(&value, 4, 0, 0x8);
3429 : : wr32_ephy(hw, PLL0_DIV_CFG0, value);
3430 : :
3431 : : value = rd32_ephy(hw, DATAPATH_CFG0);
3432 : : set_fields_e56(&value, 30, 28, 0x7);
3433 : : set_fields_e56(&value, 26, 24, 0x5);
3434 : : set_fields_e56(&value, 18, 16, 0x5);
3435 : : set_fields_e56(&value, 14, 12, 0x5);
3436 : : set_fields_e56(&value, 10, 8, 0x5);
3437 : : wr32_ephy(hw, DATAPATH_CFG0, value);
3438 : :
3439 : : value = rd32_ephy(hw, DATAPATH_CFG1);
3440 : : set_fields_e56(&value, 26, 24, 0x5);
3441 : : set_fields_e56(&value, 10, 8, 0x5);
3442 : : set_fields_e56(&value, 18, 16, 0x5);
3443 : : set_fields_e56(&value, 2, 0, 0x5);
3444 : : wr32_ephy(hw, DATAPATH_CFG1, value);
3445 : :
3446 : : value = rd32_ephy(hw, AN_CFG1);
3447 : : set_fields_e56(&value, 4, 0, 0x2);
3448 : : wr32_ephy(hw, AN_CFG1, value);
3449 : :
3450 : 0 : txgbe_e56_cfg_temp(hw);
3451 : 0 : txgbe_e56_cfg_40g(hw);
3452 : :
3453 : : value = rd32_ephy(hw, PMD_CFG0);
3454 : : set_fields_e56(&value, 21, 20, 0x3);
3455 : : set_fields_e56(&value, 19, 12, 0xf);
3456 : : set_fields_e56(&value, 8, 8, 0x0);
3457 : : set_fields_e56(&value, 1, 1, 0x1);
3458 : : wr32_ephy(hw, PMD_CFG0, value);
3459 : : }
3460 : :
3461 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_25GB_FULL) {
3462 : : value = rd32_epcs(hw, SR_PCS_CTRL1);
3463 : : set_fields_e56(&value, 5, 2, 5);
3464 : : wr32_epcs(hw, SR_PCS_CTRL1, value);
3465 : :
3466 : : value = rd32_epcs(hw, SR_PCS_CTRL2);
3467 : : set_fields_e56(&value, 3, 0, 7);
3468 : : wr32_epcs(hw, SR_PCS_CTRL2, value);
3469 : :
3470 : : value = rd32_epcs(hw, SR_PMA_CTRL2);
3471 : : set_fields_e56(&value, 6, 0, 0x39);
3472 : : wr32_epcs(hw, SR_PMA_CTRL2, value);
3473 : :
3474 : : value = rd32_ephy(hw, ANA_OVRDVAL0);
3475 : : set_fields_e56(&value, 29, 29, 0x1);
3476 : : set_fields_e56(&value, 1, 1, 0x1);
3477 : : wr32_ephy(hw, ANA_OVRDVAL0, value);
3478 : :
3479 : : value = rd32_ephy(hw, ANA_OVRDVAL5);
3480 : : /* Update to 0 for PIN CLKP/N: Enable the termination of the input buffer */
3481 : : set_fields_e56(&value, 24, 24, 0x1);
3482 : : wr32_ephy(hw, ANA_OVRDVAL5, value);
3483 : :
3484 : : value = rd32_ephy(hw, ANA_OVRDEN0);
3485 : : set_fields_e56(&value, 1, 1, 0x1);
3486 : : wr32_ephy(hw, ANA_OVRDEN0, value);
3487 : :
3488 : : value = rd32_ephy(hw, ANA_OVRDEN1);
3489 : : set_fields_e56(&value, 30, 30, 0x1);
3490 : : set_fields_e56(&value, 25, 25, 0x1);
3491 : : wr32_ephy(hw, ANA_OVRDEN1, value);
3492 : :
3493 : : value = rd32_ephy(hw, PLL0_CFG0);
3494 : : set_fields_e56(&value, 25, 24, 0x1);
3495 : : set_fields_e56(&value, 17, 16, 0x3);
3496 : : wr32_ephy(hw, PLL0_CFG0, value);
3497 : :
3498 : : value = rd32_ephy(hw, PLL0_CFG2);
3499 : : set_fields_e56(&value, 12, 8, 0x4);
3500 : : wr32_ephy(hw, PLL0_CFG2, value);
3501 : :
3502 : : value = rd32_ephy(hw, PLL1_CFG0);
3503 : : set_fields_e56(&value, 25, 24, 0x1);
3504 : : set_fields_e56(&value, 17, 16, 0x3);
3505 : : wr32_ephy(hw, PLL1_CFG0, value);
3506 : :
3507 : : value = rd32_ephy(hw, PLL1_CFG2);
3508 : : set_fields_e56(&value, 12, 8, 0x8);
3509 : : wr32_ephy(hw, PLL1_CFG2, value);
3510 : :
3511 : : value = rd32_ephy(hw, PLL0_DIV_CFG0);
3512 : : set_fields_e56(&value, 18, 8, 0x294);
3513 : : set_fields_e56(&value, 4, 0, 0x8);
3514 : : wr32_ephy(hw, PLL0_DIV_CFG0, value);
3515 : :
3516 : : value = rd32_ephy(hw, DATAPATH_CFG0);
3517 : : set_fields_e56(&value, 30, 28, 0x7);
3518 : : set_fields_e56(&value, 26, 24, 0x5);
3519 : : set_fields_e56(&value, 18, 16, 0x3);
3520 : : set_fields_e56(&value, 14, 12, 0x5);
3521 : : set_fields_e56(&value, 10, 8, 0x5);
3522 : : wr32_ephy(hw, DATAPATH_CFG0, value);
3523 : :
3524 : : value = rd32_ephy(hw, DATAPATH_CFG1);
3525 : : set_fields_e56(&value, 26, 24, 0x5);
3526 : : set_fields_e56(&value, 10, 8, 0x5);
3527 : : set_fields_e56(&value, 18, 16, 0x3);
3528 : : set_fields_e56(&value, 2, 0, 0x3);
3529 : : wr32_ephy(hw, DATAPATH_CFG1, value);
3530 : :
3531 : : value = rd32_ephy(hw, AN_CFG1);
3532 : : set_fields_e56(&value, 4, 0, 0x9);
3533 : : wr32_ephy(hw, AN_CFG1, value);
3534 : :
3535 : 0 : txgbe_e56_cfg_temp(hw);
3536 : 0 : txgbe_e56_cfg_25g(hw);
3537 : :
3538 : : value = rd32_ephy(hw, PMD_CFG0);
3539 : : set_fields_e56(&value, 21, 20, 0x3);
3540 : : set_fields_e56(&value, 19, 12, 0x1); /* TX_EN set */
3541 : : set_fields_e56(&value, 8, 8, 0x0);
3542 : : set_fields_e56(&value, 1, 1, 0x1);
3543 : : wr32_ephy(hw, PMD_CFG0, value);
3544 : : }
3545 : :
3546 [ # # ]: 0 : if (speed == TXGBE_LINK_SPEED_10GB_FULL) {
3547 : : value = rd32_epcs(hw, SR_PCS_CTRL1);
3548 : : set_fields_e56(&value, 5, 2, 0);
3549 : : wr32_epcs(hw, SR_PCS_CTRL1, value);
3550 : :
3551 : : value = rd32_epcs(hw, SR_PCS_CTRL2);
3552 : : set_fields_e56(&value, 3, 0, 0);
3553 : : wr32_epcs(hw, SR_PCS_CTRL2, value);
3554 : :
3555 : : value = rd32_epcs(hw, SR_PMA_CTRL2);
3556 : : set_fields_e56(&value, 6, 0, 0xb);
3557 : : wr32_epcs(hw, SR_PMA_CTRL2, value);
3558 : :
3559 : : value = rd32_ephy(hw, ANA_OVRDVAL0);
3560 : : set_fields_e56(&value, 29, 29, 0x1);
3561 : : set_fields_e56(&value, 1, 1, 0x1);
3562 : : wr32_ephy(hw, ANA_OVRDVAL0, value);
3563 : :
3564 : : value = rd32_ephy(hw, ANA_OVRDVAL5);
3565 : : set_fields_e56(&value, 24, 24, 0x1);
3566 : : wr32_ephy(hw, ANA_OVRDVAL5, value);
3567 : :
3568 : : value = rd32_ephy(hw, ANA_OVRDEN0);
3569 : : set_fields_e56(&value, 1, 1, 0x1);
3570 : : wr32_ephy(hw, ANA_OVRDEN0, value);
3571 : :
3572 : : value = rd32_ephy(hw, ANA_OVRDEN1);
3573 : : set_fields_e56(&value, 30, 30, 0x1);
3574 : : set_fields_e56(&value, 25, 25, 0x1);
3575 : : wr32_ephy(hw, ANA_OVRDEN1, value);
3576 : :
3577 : : value = rd32_ephy(hw, PLL0_CFG0);
3578 : : set_fields_e56(&value, 25, 24, 0x1);
3579 : : set_fields_e56(&value, 17, 16, 0x3);
3580 : : wr32_ephy(hw, PLL0_CFG0, value);
3581 : :
3582 : : value = rd32_ephy(hw, PLL0_CFG2);
3583 : : set_fields_e56(&value, 12, 8, 0x4);
3584 : : wr32_ephy(hw, PLL0_CFG2, value);
3585 : :
3586 : : value = rd32_ephy(hw, PLL1_CFG0);
3587 : : set_fields_e56(&value, 25, 24, 0x1);
3588 : : set_fields_e56(&value, 17, 16, 0x3);
3589 : : wr32_ephy(hw, PLL1_CFG0, value);
3590 : :
3591 : : value = rd32_ephy(hw, PLL1_CFG2);
3592 : : set_fields_e56(&value, 12, 8, 0x8);
3593 : : wr32_ephy(hw, PLL1_CFG2, value);
3594 : :
3595 : : value = rd32_ephy(hw, PLL0_DIV_CFG0);
3596 : : set_fields_e56(&value, 18, 8, 0x294);
3597 : : set_fields_e56(&value, 4, 0, 0x8);
3598 : : wr32_ephy(hw, PLL0_DIV_CFG0, value);
3599 : :
3600 : : value = rd32_ephy(hw, DATAPATH_CFG0);
3601 : : set_fields_e56(&value, 30, 28, 0x7);
3602 : : set_fields_e56(&value, 26, 24, 0x5);
3603 : : set_fields_e56(&value, 18, 16, 0x5);
3604 : : set_fields_e56(&value, 14, 12, 0x5);
3605 : : set_fields_e56(&value, 10, 8, 0x5);
3606 : : wr32_ephy(hw, DATAPATH_CFG0, value);
3607 : :
3608 : : value = rd32_ephy(hw, DATAPATH_CFG1);
3609 : : set_fields_e56(&value, 26, 24, 0x5);
3610 : : set_fields_e56(&value, 10, 8, 0x5);
3611 : : set_fields_e56(&value, 18, 16, 0x5);
3612 : : set_fields_e56(&value, 2, 0, 0x5);
3613 : : wr32_ephy(hw, DATAPATH_CFG1, value);
3614 : :
3615 : : value = rd32_ephy(hw, AN_CFG1);
3616 : : set_fields_e56(&value, 4, 0, 0x2);
3617 : : wr32_ephy(hw, AN_CFG1, value);
3618 : :
3619 : 0 : txgbe_e56_cfg_temp(hw);
3620 : 0 : txgbe_e56_cfg_10g(hw);
3621 : :
3622 : : value = rd32_ephy(hw, PMD_CFG0);
3623 : : set_fields_e56(&value, 21, 20, 0x3);
3624 : : set_fields_e56(&value, 19, 12, 0x1); /* TX_EN set */
3625 : : set_fields_e56(&value, 8, 8, 0x0);
3626 : : set_fields_e56(&value, 1, 1, 0x1);
3627 : : wr32_ephy(hw, PMD_CFG0, value);
3628 : : }
3629 : :
3630 [ # # ]: 0 : if (hw->mac.type == txgbe_mac_aml)
3631 : 0 : hw->mac.enable_tx_laser(hw);
3632 : :
3633 : 0 : status = txgbe_e56_config_rx(hw, speed);
3634 : :
3635 : : value = rd32_ephy(hw, E56PHY_RXS_IDLE_DETECT_1_ADDR);
3636 : : set_fields_e56(&value, E56PHY_RXS_IDLE_DETECT_1_IDLE_TH_ADC_PEAK_MAX, 0x28);
3637 : : set_fields_e56(&value, E56PHY_RXS_IDLE_DETECT_1_IDLE_TH_ADC_PEAK_MIN, 0xa);
3638 : : wr32_ephy(hw, E56PHY_RXS_IDLE_DETECT_1_ADDR, value);
3639 : :
3640 : : wr32_ephy(hw, E56PHY_INTR_0_ADDR, E56PHY_INTR_0_IDLE_ENTRY1);
3641 : : wr32_ephy(hw, E56PHY_INTR_1_ADDR, E56PHY_INTR_1_IDLE_EXIT1);
3642 : : wr32_ephy(hw, E56PHY_INTR_0_ENABLE_ADDR, E56PHY_INTR_0_IDLE_ENTRY1);
3643 : : wr32_ephy(hw, E56PHY_INTR_1_ENABLE_ADDR, E56PHY_INTR_1_IDLE_EXIT1);
3644 : :
3645 [ # # ]: 0 : if (hw->fec_mode != TXGBE_PHY_FEC_AUTO) {
3646 : 0 : hw->cur_fec_link = hw->fec_mode;
3647 : 0 : txgbe_e56_fec_set(hw);
3648 : : }
3649 : :
3650 : 0 : out:
3651 [ # # ]: 0 : if (ppl_lock) {
3652 : 0 : hw->mac.enable_sec_tx_path(hw);
3653 : : wr32m(hw, TXGBE_MACRXCFG, TXGBE_MACRXCFG_ENA,
3654 : : TXGBE_MACRXCFG_ENA);
3655 : : }
3656 : :
3657 : 0 : return status;
3658 : : }
3659 : :
3660 : 0 : s32 txgbe_e56_fec_set(struct txgbe_hw *hw)
3661 : : {
3662 : : u32 value;
3663 : :
3664 [ # # ]: 0 : if (hw->cur_fec_link & TXGBE_PHY_FEC_RS) {
3665 : : /* disable BASER FEC */
3666 : : value = rd32_epcs(hw, SR_PMA_KR_FEC_CTRL);
3667 : : set_fields_e56(&value, 0, 0, 0);
3668 : : wr32_epcs(hw, SR_PMA_KR_FEC_CTRL, value);
3669 : :
3670 : : /* enable RS FEC */
3671 : : wr32_epcs(hw, 0x180a3, 0x68c1);
3672 : : wr32_epcs(hw, 0x180a4, 0x3321);
3673 : : wr32_epcs(hw, 0x180a5, 0x973e);
3674 : : wr32_epcs(hw, 0x180a6, 0xccde);
3675 : :
3676 : : wr32_epcs(hw, 0x38018, 1024);
3677 : : value = rd32_epcs(hw, 0x100c8);
3678 : : set_fields_e56(&value, 2, 2, 1);
3679 : : wr32_epcs(hw, 0x100c8, value);
3680 [ # # ]: 0 : } else if (hw->cur_fec_link & TXGBE_PHY_FEC_BASER) {
3681 : : /* disable RS FEC */
3682 : : wr32_epcs(hw, 0x180a3, 0x7690);
3683 : : wr32_epcs(hw, 0x180a4, 0x3347);
3684 : : wr32_epcs(hw, 0x180a5, 0x896f);
3685 : : wr32_epcs(hw, 0x180a6, 0xccb8);
3686 : : wr32_epcs(hw, 0x38018, 0x3fff);
3687 : : value = rd32_epcs(hw, 0x100c8);
3688 : : set_fields_e56(&value, 2, 2, 0);
3689 : : wr32_epcs(hw, 0x100c8, value);
3690 : :
3691 : : /* enable BASER FEC */
3692 : : value = rd32_epcs(hw, SR_PMA_KR_FEC_CTRL);
3693 : : set_fields_e56(&value, 0, 0, 1);
3694 : : wr32_epcs(hw, SR_PMA_KR_FEC_CTRL, value);
3695 : : } else {
3696 : : /* disable RS FEC */
3697 : : wr32_epcs(hw, 0x180a3, 0x7690);
3698 : : wr32_epcs(hw, 0x180a4, 0x3347);
3699 : : wr32_epcs(hw, 0x180a5, 0x896f);
3700 : : wr32_epcs(hw, 0x180a6, 0xccb8);
3701 : : wr32_epcs(hw, 0x38018, 0x3fff);
3702 : : value = rd32_epcs(hw, 0x100c8);
3703 : : set_fields_e56(&value, 2, 2, 0);
3704 : : wr32_epcs(hw, 0x100c8, value);
3705 : :
3706 : : /* disable BASER FEC */
3707 : : value = rd32_epcs(hw, SR_PMA_KR_FEC_CTRL);
3708 : : set_fields_e56(&value, 0, 0, 0);
3709 : : wr32_epcs(hw, SR_PMA_KR_FEC_CTRL, value);
3710 : : }
3711 : :
3712 : 0 : return 0;
3713 : : }
3714 : :
3715 : 0 : s32 txgbe_e56_fec_polling(struct txgbe_hw *hw, bool *link_up)
3716 : : {
3717 : 0 : u32 link_speed = TXGBE_LINK_SPEED_UNKNOWN;
3718 : : s32 i = 0, j = 0;
3719 : :
3720 : : do {
3721 [ # # ]: 0 : if (!(hw->fec_mode & BIT(j))) {
3722 : 0 : j += 1;
3723 : 0 : continue;
3724 : : }
3725 : :
3726 : 0 : hw->cur_fec_link = hw->fec_mode & BIT(j);
3727 : :
3728 : : /*
3729 : : * If in fec auto mode, try another fec mode after no link in 1s
3730 : : * for lr sfp, enable KR-FEC to link up with mellonax and intel
3731 : : */
3732 : 0 : rte_spinlock_lock(&hw->phy_lock);
3733 : 0 : txgbe_e56_fec_set(hw);
3734 : : rte_spinlock_unlock(&hw->phy_lock);
3735 : :
3736 [ # # ]: 0 : for (i = 0; i < 4; i++) {
3737 : : msleep(250);
3738 : 0 : txgbe_e56_check_phy_link(hw, &link_speed, link_up);
3739 [ # # ]: 0 : if (*link_up)
3740 : : return 0;
3741 : : }
3742 : 0 : j += 1;
3743 [ # # ]: 0 : } while (j < 3);
3744 : :
3745 : : return 0;
3746 : : }
|
