Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2024 Realtek Corporation. All rights reserved
3 : : */
4 : :
5 : : #include <stdio.h>
6 : : #include <errno.h>
7 : : #include <stdint.h>
8 : :
9 : : #include <rte_ether.h>
10 : : #include <ethdev_driver.h>
11 : :
12 : : #include "r8169_hw.h"
13 : : #include "r8169_logs.h"
14 : : #include "r8169_dash.h"
15 : : #include "r8169_fiber.h"
16 : :
17 : : static u32
18 : 0 : rtl_eri_read_with_oob_base_address(struct rtl_hw *hw, int addr, int len,
19 : : int type, const u32 base_address)
20 : : {
21 : : int i, val_shift, shift = 0;
22 : : u32 value1 = 0;
23 : : u32 value2 = 0;
24 : : u32 eri_cmd, tmp, mask;
25 : 0 : const u32 transformed_base_address = ((base_address & 0x00FFF000) << 6) |
26 : 0 : (base_address & 0x000FFF);
27 : :
28 [ # # ]: 0 : if (len > 4 || len <= 0)
29 : : return -1;
30 : :
31 [ # # ]: 0 : while (len > 0) {
32 : 0 : val_shift = addr % ERIAR_Addr_Align;
33 : 0 : addr = addr & ~0x3;
34 : :
35 : 0 : eri_cmd = ERIAR_Read | transformed_base_address |
36 : 0 : type << ERIAR_Type_shift |
37 : 0 : ERIAR_ByteEn << ERIAR_ByteEn_shift |
38 : 0 : (addr & 0x0FFF);
39 [ # # ]: 0 : if (addr & 0xF000) {
40 : : tmp = addr & 0xF000;
41 : : tmp >>= 12;
42 : 0 : eri_cmd |= (tmp << 20) & 0x00F00000;
43 : : }
44 : :
45 : 0 : RTL_W32(hw, ERIAR, eri_cmd);
46 : :
47 [ # # ]: 0 : for (i = 0; i < RTL_CHANNEL_WAIT_COUNT; i++) {
48 : 0 : rte_delay_us(RTL_CHANNEL_WAIT_TIME);
49 : :
50 : : /* Check if the NIC has completed ERI read */
51 [ # # ]: 0 : if (RTL_R32(hw, ERIAR) & ERIAR_Flag)
52 : : break;
53 : : }
54 : :
55 [ # # ]: 0 : if (len == 1)
56 : 0 : mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
57 [ # # ]: 0 : else if (len == 2)
58 : 0 : mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
59 [ # # ]: 0 : else if (len == 3)
60 : 0 : mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
61 : : else
62 : 0 : mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
63 : :
64 : 0 : value1 = RTL_R32(hw, ERIDR) & mask;
65 : 0 : value2 |= (value1 >> val_shift * 8) << shift * 8;
66 : :
67 [ # # ]: 0 : if (len <= 4 - val_shift) {
68 : : len = 0;
69 : : } else {
70 : 0 : len -= (4 - val_shift);
71 : : shift = 4 - val_shift;
72 : 0 : addr += 4;
73 : : }
74 : : }
75 : :
76 : 0 : rte_delay_us(RTL_CHANNEL_EXIT_DELAY_TIME);
77 : :
78 : 0 : return value2;
79 : : }
80 : :
81 : : u32
82 : 0 : rtl_eri_read(struct rtl_hw *hw, int addr, int len, int type)
83 : : {
84 : 0 : return rtl_eri_read_with_oob_base_address(hw, addr, len, type, 0);
85 : : }
86 : :
87 : : static int
88 : 0 : rtl_eri_write_with_oob_base_address(struct rtl_hw *hw, int addr,
89 : : int len, u32 value, int type,
90 : : const u32 base_address)
91 : : {
92 : : int i, val_shift, shift = 0;
93 : : u32 value1 = 0;
94 : : u32 eri_cmd, mask, tmp;
95 : 0 : const u32 transformed_base_address = ((base_address & 0x00FFF000) << 6) |
96 : 0 : (base_address & 0x000FFF);
97 : :
98 [ # # ]: 0 : if (len > 4 || len <= 0)
99 : : return -1;
100 : :
101 [ # # ]: 0 : while (len > 0) {
102 : 0 : val_shift = addr % ERIAR_Addr_Align;
103 : 0 : addr = addr & ~0x3;
104 : :
105 [ # # ]: 0 : if (len == 1)
106 : 0 : mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
107 [ # # ]: 0 : else if (len == 2)
108 : 0 : mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
109 [ # # ]: 0 : else if (len == 3)
110 : 0 : mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
111 : : else
112 : 0 : mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
113 : :
114 : 0 : value1 = rtl_eri_read_with_oob_base_address(hw, addr, 4, type,
115 : 0 : base_address) & ~mask;
116 : 0 : value1 |= ((value << val_shift * 8) >> shift * 8);
117 : :
118 : 0 : RTL_W32(hw, ERIDR, value1);
119 : :
120 : 0 : eri_cmd = ERIAR_Write | transformed_base_address |
121 : 0 : type << ERIAR_Type_shift |
122 : 0 : ERIAR_ByteEn << ERIAR_ByteEn_shift |
123 : 0 : (addr & 0x0FFF);
124 [ # # ]: 0 : if (addr & 0xF000) {
125 : : tmp = addr & 0xF000;
126 : : tmp >>= 12;
127 : 0 : eri_cmd |= (tmp << 20) & 0x00F00000;
128 : : }
129 : :
130 : 0 : RTL_W32(hw, ERIAR, eri_cmd);
131 : :
132 [ # # ]: 0 : for (i = 0; i < RTL_CHANNEL_WAIT_COUNT; i++) {
133 : 0 : rte_delay_us(RTL_CHANNEL_WAIT_TIME);
134 : :
135 : : /* Check if the NIC has completed ERI write */
136 [ # # ]: 0 : if (!(RTL_R32(hw, ERIAR) & ERIAR_Flag))
137 : : break;
138 : : }
139 : :
140 [ # # ]: 0 : if (len <= 4 - val_shift) {
141 : : len = 0;
142 : : } else {
143 : 0 : len -= (4 - val_shift);
144 : : shift = 4 - val_shift;
145 : 0 : addr += 4;
146 : : }
147 : : }
148 : :
149 : 0 : rte_delay_us(RTL_CHANNEL_EXIT_DELAY_TIME);
150 : :
151 : 0 : return 0;
152 : : }
153 : :
154 : : int
155 : 0 : rtl_eri_write(struct rtl_hw *hw, int addr, int len, u32 value, int type)
156 : : {
157 : 0 : return rtl_eri_write_with_oob_base_address(hw, addr, len, value, type,
158 : : NO_BASE_ADDRESS);
159 : : }
160 : :
161 : : static u32
162 : : rtl_ocp_read_with_oob_base_address(struct rtl_hw *hw, u16 addr, u8 len,
163 : : const u32 base_address)
164 : : {
165 : 0 : return rtl_eri_read_with_oob_base_address(hw, addr, len, ERIAR_OOB,
166 : : base_address);
167 : : }
168 : :
169 : : static u32
170 : 0 : rtl8168_real_ocp_read(struct rtl_hw *hw, u16 addr, u8 len)
171 : : {
172 : : int i, val_shift, shift = 0;
173 : : u32 value1, value2, mask;
174 : :
175 : : value1 = 0;
176 : : value2 = 0;
177 : :
178 [ # # ]: 0 : if (len > 4 || len <= 0)
179 : : return -1;
180 : :
181 [ # # ]: 0 : while (len > 0) {
182 : 0 : val_shift = addr % 4;
183 : 0 : addr = addr & ~0x3;
184 : :
185 : 0 : RTL_W32(hw, OCPAR, (0x0F << 12) | (addr & 0xFFF));
186 : :
187 [ # # ]: 0 : for (i = 0; i < 20; i++) {
188 : 0 : rte_delay_us(100);
189 [ # # ]: 0 : if (RTL_R32(hw, OCPAR) & OCPAR_Flag)
190 : : break;
191 : : }
192 : :
193 [ # # ]: 0 : if (len == 1)
194 : 0 : mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
195 [ # # ]: 0 : else if (len == 2)
196 : 0 : mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
197 [ # # ]: 0 : else if (len == 3)
198 : 0 : mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
199 : : else
200 : 0 : mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
201 : :
202 : 0 : value1 = RTL_R32(hw, OCPDR) & mask;
203 : 0 : value2 |= (value1 >> val_shift * 8) << shift * 8;
204 : :
205 [ # # ]: 0 : if (len <= 4 - val_shift) {
206 : : len = 0;
207 : : } else {
208 : 0 : len -= (4 - val_shift);
209 : : shift = 4 - val_shift;
210 : 0 : addr += 4;
211 : : }
212 : : }
213 : :
214 : 0 : rte_delay_us(20);
215 : :
216 : 0 : return value2;
217 : : }
218 : :
219 : : static int
220 : 0 : rtl8168_real_ocp_write(struct rtl_hw *hw, u16 addr, u8 len, u32 value)
221 : : {
222 : : int i, val_shift, shift = 0;
223 : : u32 mask, value1 = 0;
224 : :
225 [ # # ]: 0 : if (len > 4 || len <= 0)
226 : : return -1;
227 : :
228 [ # # ]: 0 : while (len > 0) {
229 : 0 : val_shift = addr % 4;
230 : 0 : addr = addr & ~0x3;
231 : :
232 [ # # ]: 0 : if (len == 1)
233 : 0 : mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;
234 [ # # ]: 0 : else if (len == 2)
235 : 0 : mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;
236 [ # # ]: 0 : else if (len == 3)
237 : 0 : mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
238 : : else
239 : 0 : mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;
240 : :
241 : 0 : value1 = rtl_ocp_read(hw, addr, 4) & ~mask;
242 : 0 : value1 |= ((value << val_shift * 8) >> shift * 8);
243 : :
244 : 0 : RTL_W32(hw, OCPDR, value1);
245 : 0 : RTL_W32(hw, OCPAR, OCPAR_Flag | (0x0F << 12) | (addr & 0xFFF));
246 : :
247 [ # # ]: 0 : for (i = 0; i < 10; i++) {
248 : 0 : rte_delay_us(100);
249 : :
250 : : /* Check if the RTL8168 has completed ERI write */
251 [ # # ]: 0 : if (!(RTL_R32(hw, OCPAR) & OCPAR_Flag))
252 : : break;
253 : : }
254 : :
255 [ # # ]: 0 : if (len <= 4 - val_shift) {
256 : : len = 0;
257 : : } else {
258 : 0 : len -= (4 - val_shift);
259 : : shift = 4 - val_shift;
260 : 0 : addr += 4;
261 : : }
262 : : }
263 : :
264 : 0 : rte_delay_us(20);
265 : :
266 : 0 : return 0;
267 : : }
268 : :
269 : : u32
270 : 0 : rtl_ocp_read(struct rtl_hw *hw, u16 addr, u8 len)
271 : : {
272 : : u32 value = 0;
273 : :
274 [ # # # # ]: 0 : if (rtl_is_8125(hw) && !hw->AllowAccessDashOcp)
275 : : return 0xffffffff;
276 : :
277 [ # # ]: 0 : if (hw->HwSuppOcpChannelVer == 2)
278 : 0 : value = rtl_ocp_read_with_oob_base_address(hw, addr, len,
279 : : NO_BASE_ADDRESS);
280 [ # # ]: 0 : else if (hw->HwSuppOcpChannelVer == 3)
281 : 0 : value = rtl_ocp_read_with_oob_base_address(hw, addr, len,
282 : : RTL8168FP_OOBMAC_BASE);
283 : : else
284 : 0 : value = rtl8168_real_ocp_read(hw, addr, len);
285 : :
286 : : return value;
287 : : }
288 : :
289 : : static u32
290 : : rtl_ocp_write_with_oob_base_address(struct rtl_hw *hw, u16 addr, u8 len,
291 : : u32 value, const u32 base_address)
292 : : {
293 : 0 : return rtl_eri_write_with_oob_base_address(hw, addr, len, value,
294 : : ERIAR_OOB, base_address);
295 : : }
296 : :
297 : : void
298 : 0 : rtl_ocp_write(struct rtl_hw *hw, u16 addr, u8 len, u32 value)
299 : : {
300 [ # # # # ]: 0 : if (rtl_is_8125(hw) && !hw->AllowAccessDashOcp)
301 : : return;
302 : :
303 [ # # ]: 0 : if (hw->HwSuppOcpChannelVer == 2)
304 : 0 : rtl_ocp_write_with_oob_base_address(hw, addr, len, value,
305 : : NO_BASE_ADDRESS);
306 [ # # ]: 0 : else if (hw->HwSuppOcpChannelVer == 3)
307 : 0 : rtl_ocp_write_with_oob_base_address(hw, addr, len, value,
308 : : RTL8168FP_OOBMAC_BASE);
309 : : else
310 : 0 : rtl8168_real_ocp_write(hw, addr, len, value);
311 : : }
312 : :
313 : : void
314 : 0 : rtl_oob_mutex_lock(struct rtl_hw *hw)
315 : : {
316 : : u8 reg_16, reg_a0;
317 : : u16 ocp_reg_mutex_ib;
318 : : u16 ocp_reg_mutex_oob;
319 : : u16 ocp_reg_mutex_prio;
320 : : u32 wait_cnt_0, wait_cnt_1;
321 : :
322 [ # # ]: 0 : if (!hw->DASH)
323 : : return;
324 : :
325 [ # # ]: 0 : switch (hw->mcfg) {
326 : 0 : case CFG_METHOD_23:
327 : : case CFG_METHOD_27:
328 : : case CFG_METHOD_28:
329 : : case CFG_METHOD_31:
330 : : case CFG_METHOD_32:
331 : : case CFG_METHOD_33:
332 : : case CFG_METHOD_34:
333 : : case CFG_METHOD_48:
334 : : case CFG_METHOD_49:
335 : : case CFG_METHOD_52:
336 : : case CFG_METHOD_54:
337 : : case CFG_METHOD_55:
338 : : case CFG_METHOD_58:
339 : : case CFG_METHOD_91:
340 : : ocp_reg_mutex_oob = 0x110;
341 : : ocp_reg_mutex_ib = 0x114;
342 : : ocp_reg_mutex_prio = 0x11C;
343 : : break;
344 : : default:
345 : : return;
346 : : }
347 : :
348 : 0 : rtl_ocp_write(hw, ocp_reg_mutex_ib, 1, BIT_0);
349 : 0 : reg_16 = (u8)rtl_ocp_read(hw, ocp_reg_mutex_oob, 1);
350 : : wait_cnt_0 = 0;
351 [ # # ]: 0 : while (reg_16) {
352 : 0 : reg_a0 = (u8)rtl_ocp_read(hw, ocp_reg_mutex_prio, 1);
353 [ # # ]: 0 : if (reg_a0) {
354 : 0 : rtl_ocp_write(hw, ocp_reg_mutex_ib, 1, 0x00);
355 : 0 : reg_a0 = (u8)rtl_ocp_read(hw, ocp_reg_mutex_prio, 1);
356 : : wait_cnt_1 = 0;
357 [ # # ]: 0 : while (reg_a0) {
358 : 0 : reg_a0 = (u8)rtl_ocp_read(hw, ocp_reg_mutex_prio, 1);
359 : :
360 : 0 : wait_cnt_1++;
361 : :
362 [ # # ]: 0 : if (wait_cnt_1 > 2000)
363 : : break;
364 : : };
365 : 0 : rtl_ocp_write(hw, ocp_reg_mutex_ib, 1, BIT_0);
366 : : }
367 : 0 : reg_16 = (u8)rtl_ocp_read(hw, ocp_reg_mutex_oob, 1);
368 : :
369 : 0 : wait_cnt_0++;
370 : :
371 [ # # ]: 0 : if (wait_cnt_0 > 2000)
372 : : break;
373 : : };
374 : : }
375 : :
376 : : void
377 : 0 : rtl_oob_mutex_unlock(struct rtl_hw *hw)
378 : : {
379 : : u16 ocp_reg_mutex_ib;
380 : : u16 ocp_reg_mutex_prio;
381 : :
382 [ # # ]: 0 : if (!hw->DASH)
383 : : return;
384 : :
385 [ # # ]: 0 : switch (hw->mcfg) {
386 : 0 : case CFG_METHOD_23:
387 : : case CFG_METHOD_27:
388 : : case CFG_METHOD_28:
389 : : case CFG_METHOD_31:
390 : : case CFG_METHOD_32:
391 : : case CFG_METHOD_33:
392 : : case CFG_METHOD_34:
393 : : case CFG_METHOD_48:
394 : : case CFG_METHOD_49:
395 : : case CFG_METHOD_52:
396 : : case CFG_METHOD_54:
397 : : case CFG_METHOD_55:
398 : : case CFG_METHOD_58:
399 : : case CFG_METHOD_91:
400 : : ocp_reg_mutex_ib = 0x114;
401 : : ocp_reg_mutex_prio = 0x11C;
402 : : break;
403 : : default:
404 : : return;
405 : : }
406 : :
407 : 0 : rtl_ocp_write(hw, ocp_reg_mutex_prio, 1, BIT_0);
408 : 0 : rtl_ocp_write(hw, ocp_reg_mutex_ib, 1, 0x00);
409 : : }
410 : :
411 : : void
412 : 0 : rtl_mac_ocp_write(struct rtl_hw *hw, u16 addr, u16 value)
413 : : {
414 : : u32 data32;
415 : :
416 : 0 : data32 = addr / 2;
417 : 0 : data32 <<= OCPR_Addr_Reg_shift;
418 : 0 : data32 += value;
419 : 0 : data32 |= OCPR_Write;
420 : :
421 : 0 : RTL_W32(hw, MACOCP, data32);
422 : 0 : }
423 : :
424 : : u16
425 : 0 : rtl_mac_ocp_read(struct rtl_hw *hw, u16 addr)
426 : : {
427 : : u32 data32;
428 : : u16 data16 = 0;
429 : :
430 : 0 : data32 = addr / 2;
431 : 0 : data32 <<= OCPR_Addr_Reg_shift;
432 : :
433 : 0 : RTL_W32(hw, MACOCP, data32);
434 : 0 : data16 = (u16)RTL_R32(hw, MACOCP);
435 : :
436 : 0 : return data16;
437 : : }
438 : :
439 : : static void
440 : 0 : rtl_clear_set_mac_ocp_bit(struct rtl_hw *hw, u16 addr, u16 clearmask,
441 : : u16 setmask)
442 : : {
443 : : u16 val;
444 : :
445 : 0 : val = rtl_mac_ocp_read(hw, addr);
446 : 0 : val &= ~clearmask;
447 : 0 : val |= setmask;
448 : 0 : rtl_mac_ocp_write(hw, addr, val);
449 : 0 : }
450 : :
451 : : void
452 : 0 : rtl_clear_mac_ocp_bit(struct rtl_hw *hw, u16 addr, u16 mask)
453 : : {
454 : 0 : rtl_clear_set_mac_ocp_bit(hw, addr, mask, 0);
455 : 0 : }
456 : :
457 : : void
458 : 0 : rtl_set_mac_ocp_bit(struct rtl_hw *hw, u16 addr, u16 mask)
459 : : {
460 : 0 : rtl_clear_set_mac_ocp_bit(hw, addr, 0, mask);
461 : 0 : }
462 : :
463 : : u32
464 : 0 : rtl_csi_other_fun_read(struct rtl_hw *hw, u8 multi_fun_sel_bit, u32 addr)
465 : : {
466 : : u32 cmd;
467 : : int i;
468 : : u32 value = 0xffffffff;
469 : :
470 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_60)
471 : 0 : goto exit;
472 : :
473 : 0 : cmd = CSIAR_Read | CSIAR_ByteEn << CSIAR_ByteEn_shift |
474 : : (addr & CSIAR_Addr_Mask);
475 : :
476 [ # # ]: 0 : if (multi_fun_sel_bit > 7)
477 : 0 : goto exit;
478 : :
479 : 0 : cmd |= multi_fun_sel_bit << 16;
480 : :
481 : 0 : RTL_W32(hw, CSIAR, cmd);
482 : :
483 [ # # ]: 0 : for (i = 0; i < RTL_CHANNEL_WAIT_COUNT; i++) {
484 : 0 : rte_delay_us(RTL_CHANNEL_WAIT_TIME);
485 : :
486 : : /* Check if the NIC has completed CSI read */
487 [ # # ]: 0 : if (RTL_R32(hw, CSIAR) & CSIAR_Flag) {
488 : 0 : value = (u32)RTL_R32(hw, CSIDR);
489 : 0 : break;
490 : : }
491 : : }
492 : :
493 : 0 : rte_delay_us(RTL_CHANNEL_EXIT_DELAY_TIME);
494 : :
495 : 0 : exit:
496 : 0 : return value;
497 : : }
498 : :
499 : : u32
500 : 0 : rtl_csi_read(struct rtl_hw *hw, u32 addr)
501 : : {
502 : 0 : return rtl_csi_other_fun_read(hw, hw->function, addr);
503 : : }
504 : :
505 : : void
506 : 0 : rtl_csi_other_fun_write(struct rtl_hw *hw, u8 multi_fun_sel_bit, u32 addr,
507 : : u32 value)
508 : : {
509 : : u32 cmd;
510 : : int i;
511 : :
512 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_60)
513 : : return;
514 : :
515 : 0 : RTL_W32(hw, CSIDR, value);
516 : 0 : cmd = CSIAR_Write | CSIAR_ByteEn << CSIAR_ByteEn_shift |
517 : : (addr & CSIAR_Addr_Mask);
518 : :
519 [ # # ]: 0 : if (multi_fun_sel_bit > 7)
520 : : return;
521 : :
522 : 0 : cmd |= multi_fun_sel_bit << 16;
523 : :
524 : 0 : RTL_W32(hw, CSIAR, cmd);
525 : :
526 [ # # ]: 0 : for (i = 0; i < RTL_CHANNEL_WAIT_COUNT; i++) {
527 : 0 : rte_delay_us(RTL_CHANNEL_WAIT_TIME);
528 : :
529 : : /* Check if the NIC has completed CSI write */
530 [ # # ]: 0 : if (!(RTL_R32(hw, CSIAR) & CSIAR_Flag))
531 : : break;
532 : : }
533 : :
534 : 0 : rte_delay_us(RTL_CHANNEL_EXIT_DELAY_TIME);
535 : : }
536 : :
537 : : void
538 : 0 : rtl_csi_write(struct rtl_hw *hw, u32 addr, u32 value)
539 : : {
540 : 0 : rtl_csi_other_fun_write(hw, hw->function, addr, value);
541 : 0 : }
542 : :
543 : : void
544 : 0 : rtl8168_clear_and_set_mcu_ocp_bit(struct rtl_hw *hw, u16 addr, u16 clearmask,
545 : : u16 setmask)
546 : : {
547 : : u16 reg_value;
548 : :
549 : 0 : reg_value = rtl_mac_ocp_read(hw, addr);
550 : 0 : reg_value &= ~clearmask;
551 : 0 : reg_value |= setmask;
552 : 0 : rtl_mac_ocp_write(hw, addr, reg_value);
553 : 0 : }
554 : :
555 : : void
556 : 0 : rtl8168_clear_mcu_ocp_bit(struct rtl_hw *hw, u16 addr, u16 mask)
557 : : {
558 : 0 : rtl8168_clear_and_set_mcu_ocp_bit(hw, addr, mask, 0);
559 : 0 : }
560 : :
561 : : void
562 : 0 : rtl8168_set_mcu_ocp_bit(struct rtl_hw *hw, u16 addr, u16 mask)
563 : : {
564 : 0 : rtl8168_clear_and_set_mcu_ocp_bit(hw, addr, 0, mask);
565 : 0 : }
566 : :
567 : : static void
568 : 0 : rtl_enable_rxdvgate(struct rtl_hw *hw)
569 : : {
570 : 0 : RTL_W8(hw, 0xF2, RTL_R8(hw, 0xF2) | BIT_3);
571 : :
572 [ # # ]: 0 : if (!rtl_is_8125(hw))
573 : : rte_delay_ms(2);
574 : 0 : }
575 : :
576 : : void
577 : 0 : rtl_disable_rxdvgate(struct rtl_hw *hw)
578 : : {
579 : 0 : RTL_W8(hw, 0xF2, RTL_R8(hw, 0xF2) & ~BIT_3);
580 : :
581 [ # # ]: 0 : if (!rtl_is_8125(hw))
582 : : rte_delay_ms(2);
583 : 0 : }
584 : :
585 : : static void
586 : 0 : rtl_stop_all_request(struct rtl_hw *hw)
587 : : {
588 : : int i;
589 : :
590 [ # # # ]: 0 : switch (hw->mcfg) {
591 : 0 : case CFG_METHOD_48:
592 : : case CFG_METHOD_49:
593 : : case CFG_METHOD_52:
594 : 0 : RTL_W8(hw, ChipCmd, RTL_R8(hw, ChipCmd) | StopReq);
595 [ # # ]: 0 : for (i = 0; i < 20; i++) {
596 : 0 : rte_delay_us(10);
597 [ # # ]: 0 : if (!(RTL_R8(hw, ChipCmd) & StopReq))
598 : : break;
599 : : }
600 : : break;
601 : 0 : case CFG_METHOD_50:
602 : : case CFG_METHOD_51:
603 : : case CFG_METHOD_53:
604 : : case CFG_METHOD_54:
605 : : case CFG_METHOD_55:
606 : : case CFG_METHOD_56:
607 : : case CFG_METHOD_57:
608 : : case CFG_METHOD_58:
609 : : case CFG_METHOD_59:
610 : : case CFG_METHOD_60:
611 : : case CFG_METHOD_61:
612 : : case CFG_METHOD_70:
613 : : case CFG_METHOD_71:
614 : : case CFG_METHOD_91:
615 : 0 : RTL_W8(hw, ChipCmd, RTL_R8(hw, ChipCmd) | StopReq);
616 : 0 : rte_delay_us(200);
617 : 0 : break;
618 : : default:
619 : : rte_delay_ms(2);
620 : : break;
621 : : }
622 : 0 : }
623 : :
624 : : static void
625 : : rtl_clear_stop_all_request(struct rtl_hw *hw)
626 : : {
627 : 0 : RTL_W8(hw, ChipCmd, RTL_R8(hw, ChipCmd) & (CmdTxEnb | CmdRxEnb));
628 : : }
629 : :
630 : : static void
631 : 0 : rtl_wait_txrx_fifo_empty(struct rtl_hw *hw)
632 : : {
633 : : int i;
634 : :
635 [ # # ]: 0 : if (rtl_is_8125(hw)) {
636 [ # # ]: 0 : for (i = 0; i < 3000; i++) {
637 : 0 : rte_delay_us(50);
638 [ # # ]: 0 : if ((RTL_R8(hw, MCUCmd_reg) & (Txfifo_empty | Rxfifo_empty)) ==
639 : : (Txfifo_empty | Rxfifo_empty))
640 : : break;
641 : : }
642 : : } else {
643 [ # # ]: 0 : for (i = 0; i < 10; i++) {
644 : 0 : rte_delay_us(100);
645 [ # # ]: 0 : if (RTL_R32(hw, TxConfig) & BIT_11)
646 : : break;
647 : : }
648 : :
649 [ # # ]: 0 : for (i = 0; i < 10; i++) {
650 : 0 : rte_delay_us(100);
651 [ # # ]: 0 : if ((RTL_R8(hw, MCUCmd_reg) & (Txfifo_empty | Rxfifo_empty)) ==
652 : : (Txfifo_empty | Rxfifo_empty))
653 : : break;
654 : : }
655 : :
656 : : rte_delay_ms(1);
657 : : }
658 : :
659 [ # # ]: 0 : switch (hw->mcfg) {
660 : : case CFG_METHOD_50:
661 : : case CFG_METHOD_51:
662 : : case CFG_METHOD_53:
663 : : case CFG_METHOD_54:
664 : : case CFG_METHOD_55:
665 : : case CFG_METHOD_56:
666 : : case CFG_METHOD_57:
667 : : case CFG_METHOD_58:
668 : : case CFG_METHOD_59:
669 : : case CFG_METHOD_60:
670 : : case CFG_METHOD_61:
671 : : case CFG_METHOD_70:
672 : : case CFG_METHOD_71:
673 : : case CFG_METHOD_91:
674 [ # # ]: 0 : for (i = 0; i < 3000; i++) {
675 : 0 : rte_delay_us(50);
676 [ # # ]: 0 : if ((RTL_R16(hw, IntrMitigate) & (BIT_0 | BIT_1 | BIT_8)) ==
677 : : (BIT_0 | BIT_1 | BIT_8))
678 : : break;
679 : : }
680 : : break;
681 : : }
682 : 0 : }
683 : :
684 : : static void
685 : : rtl_disable_rx_packet_filter(struct rtl_hw *hw)
686 : : {
687 : 0 : RTL_W32(hw, RxConfig, RTL_R32(hw, RxConfig) &
688 : : ~(AcceptErr | AcceptRunt | AcceptBroadcast | AcceptMulticast |
689 : : AcceptMyPhys | AcceptAllPhys));
690 : : }
691 : :
692 : : void
693 : 0 : rtl_nic_reset(struct rtl_hw *hw)
694 : : {
695 : : int i;
696 : :
697 : : rtl_disable_rx_packet_filter(hw);
698 : :
699 : 0 : rtl_enable_rxdvgate(hw);
700 : :
701 : 0 : rtl_stop_all_request(hw);
702 : :
703 : 0 : rtl_wait_txrx_fifo_empty(hw);
704 : :
705 : : rtl_clear_stop_all_request(hw);
706 : :
707 : : /* Soft reset the chip. */
708 : 0 : RTL_W8(hw, ChipCmd, CmdReset);
709 : :
710 : : /* Check that the chip has finished the reset. */
711 [ # # ]: 0 : for (i = 100; i > 0; i--) {
712 : 0 : rte_delay_us(100);
713 [ # # ]: 0 : if ((RTL_R8(hw, ChipCmd) & CmdReset) == 0)
714 : : break;
715 : : }
716 : 0 : }
717 : :
718 : : void
719 : 0 : rtl_enable_cfg9346_write(struct rtl_hw *hw)
720 : : {
721 : 0 : RTL_W8(hw, Cfg9346, RTL_R8(hw, Cfg9346) | Cfg9346_Unlock);
722 : 0 : }
723 : :
724 : : void
725 : 0 : rtl_disable_cfg9346_write(struct rtl_hw *hw)
726 : : {
727 : 0 : RTL_W8(hw, Cfg9346, RTL_R8(hw, Cfg9346) & ~Cfg9346_Unlock);
728 : 0 : }
729 : :
730 : : static void
731 : : rtl_enable_force_clkreq(struct rtl_hw *hw, bool enable)
732 : : {
733 : : if (enable)
734 : : RTL_W8(hw, 0xF1, RTL_R8(hw, 0xF1) | BIT_7);
735 : : else
736 : 0 : RTL_W8(hw, 0xF1, RTL_R8(hw, 0xF1) & ~BIT_7);
737 : : }
738 : :
739 : : static void
740 : 0 : rtl_enable_aspm_clkreq_lock(struct rtl_hw *hw, bool enable)
741 : : {
742 : : bool unlock_cfg_wr;
743 : :
744 [ # # ]: 0 : if ((RTL_R8(hw, Cfg9346) & Cfg9346_EEM_MASK) == Cfg9346_Unlock)
745 : : unlock_cfg_wr = false;
746 : : else
747 : : unlock_cfg_wr = true;
748 : :
749 : : if (unlock_cfg_wr)
750 : 0 : rtl_enable_cfg9346_write(hw);
751 : :
752 [ # # # # ]: 0 : if (hw->mcfg == CFG_METHOD_58 || hw->mcfg == CFG_METHOD_70 ||
753 [ # # ]: 0 : hw->mcfg == CFG_METHOD_71 || hw->mcfg == CFG_METHOD_91) {
754 [ # # ]: 0 : if (enable) {
755 : 0 : RTL_W8(hw, INT_CFG0_8125, RTL_R8(hw, INT_CFG0_8125) | BIT_3);
756 : 0 : RTL_W8(hw, Config5, RTL_R8(hw, Config5) | BIT_0);
757 : : } else {
758 : 0 : RTL_W8(hw, INT_CFG0_8125, RTL_R8(hw, INT_CFG0_8125) & ~BIT_3);
759 : 0 : RTL_W8(hw, Config5, RTL_R8(hw, Config5) & ~BIT_0);
760 : : }
761 : : } else {
762 [ # # ]: 0 : if (enable) {
763 : 0 : RTL_W8(hw, Config2, RTL_R8(hw, Config2) | BIT_7);
764 : 0 : RTL_W8(hw, Config5, RTL_R8(hw, Config5) | BIT_0);
765 : : } else {
766 : 0 : RTL_W8(hw, Config2, RTL_R8(hw, Config2) & ~BIT_7);
767 : 0 : RTL_W8(hw, Config5, RTL_R8(hw, Config5) & ~BIT_0);
768 : : }
769 : :
770 [ # # ]: 0 : if (!rtl_is_8125(hw))
771 : 0 : rte_delay_us(10);
772 : : }
773 : :
774 [ # # ]: 0 : if (unlock_cfg_wr)
775 : 0 : rtl_disable_cfg9346_write(hw);
776 : 0 : }
777 : :
778 : : static void
779 : 0 : rtl_disable_l1_timeout(struct rtl_hw *hw)
780 : : {
781 : 0 : rtl_csi_write(hw, 0x890, rtl_csi_read(hw, 0x890) & ~BIT_0);
782 : 0 : }
783 : :
784 : : static void
785 : 0 : rtl8125_disable_eee_plus(struct rtl_hw *hw)
786 : : {
787 : 0 : rtl_mac_ocp_write(hw, 0xE080, rtl_mac_ocp_read(hw, 0xE080) & ~BIT_1);
788 : 0 : }
789 : :
790 : : static void
791 : 0 : rtl_hw_clear_timer_int(struct rtl_hw *hw)
792 : : {
793 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_21 && hw->mcfg <= CFG_METHOD_37) {
794 : 0 : RTL_W32(hw, TimeInt0, 0x0000);
795 : 0 : RTL_W32(hw, TimeInt1, 0x0000);
796 : 0 : RTL_W32(hw, TimeInt2, 0x0000);
797 : 0 : RTL_W32(hw, TimeInt3, 0x0000);
798 : : } else {
799 : 0 : RTL_W32(hw, TIMER_INT0_8125, 0x0000);
800 : 0 : RTL_W32(hw, TIMER_INT1_8125, 0x0000);
801 : 0 : RTL_W32(hw, TIMER_INT2_8125, 0x0000);
802 : 0 : RTL_W32(hw, TIMER_INT3_8125, 0x0000);
803 : : }
804 : 0 : }
805 : :
806 : : static void
807 : 0 : rtl8125_hw_clear_int_miti(struct rtl_hw *hw)
808 : : {
809 : : int i;
810 : :
811 [ # # # ]: 0 : switch (hw->HwSuppIntMitiVer) {
812 : : case 3:
813 : : case 6:
814 : : /* IntMITI_0-IntMITI_31 */
815 [ # # ]: 0 : for (i = 0xA00; i < 0xB00; i += 4)
816 : 0 : RTL_W32(hw, i, 0x0000);
817 : : break;
818 : : case 4:
819 : : case 5:
820 : : /* IntMITI_0-IntMITI_15 */
821 [ # # ]: 0 : for (i = 0xA00; i < 0xA80; i += 4)
822 : 0 : RTL_W32(hw, i, 0x0000);
823 : :
824 [ # # ]: 0 : if (hw->HwSuppIntMitiVer == 5)
825 : 0 : RTL_W8(hw, INT_CFG0_8125, RTL_R8(hw, INT_CFG0_8125) &
826 : : ~(INT_CFG0_TIMEOUT0_BYPASS_8125 |
827 : : INT_CFG0_MITIGATION_BYPASS_8125 |
828 : : INT_CFG0_RDU_BYPASS_8126));
829 : : else
830 : 0 : RTL_W8(hw, INT_CFG0_8125, RTL_R8(hw, INT_CFG0_8125) &
831 : : ~(INT_CFG0_TIMEOUT0_BYPASS_8125 | INT_CFG0_MITIGATION_BYPASS_8125));
832 : :
833 : 0 : RTL_W16(hw, INT_CFG1_8125, 0x0000);
834 : : break;
835 : : }
836 : 0 : }
837 : :
838 : : static void
839 : 0 : rtl8125_set_rss_hash_opt(struct rtl_hw *hw, u16 nb_rx_queues)
840 : : {
841 : : u32 hash_mask_len;
842 : : u32 rss_ctrl;
843 : :
844 [ # # ]: 0 : rss_ctrl = rte_log2_u32(nb_rx_queues);
845 : : rss_ctrl &= (BIT_0 | BIT_1 | BIT_2);
846 : 0 : rss_ctrl <<= RSS_CPU_NUM_OFFSET;
847 : :
848 : : /* Perform hash on these packet types */
849 : : rss_ctrl |= RTL_RSS_CTRL_OFFLOAD_ALL;
850 : :
851 : : hash_mask_len = rte_log2_u32(RTL_MAX_INDIRECTION_TABLE_ENTRIES);
852 : : hash_mask_len &= (BIT_0 | BIT_1 | BIT_2);
853 : 0 : rss_ctrl |= hash_mask_len << RSS_MASK_BITS_OFFSET;
854 : :
855 : 0 : RTL_W32(hw, RSS_CTRL_8125, rss_ctrl);
856 : 0 : }
857 : :
858 : : static void
859 : 0 : rtl8125_store_reta(struct rtl_hw *hw)
860 : : {
861 : : u32 reta;
862 : : int i;
863 : :
864 [ # # ]: 0 : for (i = 0; i < RTL_MAX_INDIRECTION_TABLE_ENTRIES; i += 4) {
865 : 0 : reta = hw->rss_indir_tbl[i];
866 : 0 : reta |= hw->rss_indir_tbl[i + 1] << 8;
867 : 0 : reta |= hw->rss_indir_tbl[i + 2] << 16;
868 : 0 : reta |= hw->rss_indir_tbl[i + 3] << 24;
869 : 0 : RTL_W32(hw, RSS_INDIRECTION_TBL_8125_V2 + i, reta);
870 : : }
871 : 0 : }
872 : :
873 : : void
874 : 0 : rtl8125_store_rss_key(struct rtl_hw *hw)
875 : : {
876 : : u32 rss_key;
877 : : int i;
878 : :
879 [ # # ]: 0 : for (i = 0; i < RTL_RSS_KEY_SIZE; i += 4) {
880 : 0 : rss_key = hw->rss_key[i];
881 : 0 : rss_key |= hw->rss_key[i + 1] << 8;
882 : 0 : rss_key |= hw->rss_key[i + 2] << 16;
883 : 0 : rss_key |= hw->rss_key[i + 3] << 24;
884 : 0 : RTL_W32(hw, RSS_KEY_8125 + i, rss_key);
885 : : }
886 : 0 : }
887 : :
888 : : void
889 : 0 : rtl8125_config_rss(struct rtl_hw *hw, u16 nb_rx_queues)
890 : : {
891 : 0 : rtl8125_set_rss_hash_opt(hw, nb_rx_queues);
892 : :
893 : 0 : rtl8125_store_reta(hw);
894 : :
895 : 0 : rtl8125_store_rss_key(hw);
896 : 0 : }
897 : :
898 : : static void
899 : 0 : rtl8125_set_rx_desc_type(struct rtl_hw *hw)
900 : : {
901 [ # # # ]: 0 : switch (hw->mcfg) {
902 : 0 : case CFG_METHOD_54:
903 : : case CFG_METHOD_55:
904 : : case CFG_METHOD_56:
905 : : case CFG_METHOD_57:
906 : : case CFG_METHOD_58:
907 : : case CFG_METHOD_59:
908 : : case CFG_METHOD_60:
909 : : case CFG_METHOD_61:
910 : 0 : RTL_W8(hw, 0xD8, RTL_R8(hw, 0xD8) & ~EnableRxDescV4_0);
911 : : break;
912 : 0 : case CFG_METHOD_70:
913 : : case CFG_METHOD_71:
914 : : case CFG_METHOD_91:
915 : 0 : RTL_W8(hw, 0xD8, RTL_R8(hw, 0xD8) | EnableRxDescV4_0);
916 : : break;
917 : : }
918 : 0 : }
919 : :
920 : : static void
921 : 0 : rtl8125_set_rx_crc_drop(struct rtl_hw *hw, bool enable)
922 : : {
923 [ # # ]: 0 : switch (hw->mcfg) {
924 : 0 : case CFG_METHOD_54:
925 : : case CFG_METHOD_55:
926 : : case CFG_METHOD_56:
927 : : case CFG_METHOD_57:
928 : : case CFG_METHOD_58:
929 : : case CFG_METHOD_59:
930 : : case CFG_METHOD_60:
931 : : case CFG_METHOD_61:
932 : : case CFG_METHOD_70:
933 : : case CFG_METHOD_71:
934 : : case CFG_METHOD_91:
935 [ # # ]: 0 : if (enable)
936 : 0 : RTL_W8(hw, 0xD8, RTL_R8(hw, 0xD8) | RX_CRC_DROP_EN);
937 : : else
938 : 0 : RTL_W8(hw, 0xD8, RTL_R8(hw, 0xD8) & ~RX_CRC_DROP_EN);
939 : : break;
940 : : }
941 : 0 : }
942 : :
943 : : static void
944 : 0 : rtl8125_hw_config(struct rtl_hw *hw)
945 : : {
946 : : u32 mac_ocp_data;
947 : :
948 : 0 : rtl_nic_reset(hw);
949 : :
950 : 0 : rtl_enable_cfg9346_write(hw);
951 : :
952 : : /* Disable aspm clkreq internal */
953 : : rtl_enable_force_clkreq(hw, 0);
954 : 0 : rtl_enable_aspm_clkreq_lock(hw, 0);
955 : :
956 : : /* Disable magic packet */
957 : 0 : rtl_mac_ocp_write(hw, 0xC0B6, 0);
958 : :
959 : : /* Set DMA burst size and interframe gap time */
960 : 0 : RTL_W32(hw, TxConfig, (TX_DMA_BURST_unlimited << TxDMAShift) |
961 : : (InterFrameGap << TxInterFrameGapShift));
962 : :
963 [ # # ]: 0 : if (hw->EnableTxNoClose)
964 : 0 : RTL_W32(hw, TxConfig, (RTL_R32(hw, TxConfig) | BIT_6));
965 : :
966 : : /* TCAM */
967 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_48 && hw->mcfg <= CFG_METHOD_53)
968 : 0 : RTL_W16(hw, 0x382, 0x221B);
969 : :
970 [ # # ]: 0 : if ((hw->mcfg >= CFG_METHOD_70 && hw->mcfg <= CFG_METHOD_71) ||
971 : : hw->mcfg == CFG_METHOD_91)
972 : 0 : rtl_disable_l1_timeout(hw);
973 : :
974 : : /* Disable speed down */
975 : 0 : RTL_W8(hw, Config1, RTL_R8(hw, Config1) & ~0x10);
976 : :
977 : : /* CRC disable set */
978 : 0 : rtl_mac_ocp_write(hw, 0xC140, 0xFFFF);
979 : 0 : rtl_mac_ocp_write(hw, 0xC142, 0xFFFF);
980 : :
981 : : /* Disable new TX desc format */
982 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xEB58);
983 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_70 || hw->mcfg == CFG_METHOD_71 ||
984 : : hw->mcfg == CFG_METHOD_91)
985 : 0 : mac_ocp_data &= ~(BIT_0 | BIT_1);
986 : : else
987 : 0 : mac_ocp_data &= ~BIT_0;
988 : 0 : rtl_mac_ocp_write(hw, 0xEB58, mac_ocp_data);
989 : :
990 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_91) {
991 [ # # ]: 0 : if (hw->EnableTxNoClose)
992 : 0 : RTL_W8(hw, 0x20E4, RTL_R8(hw, 0x20E4) | BIT_2);
993 : : else
994 : 0 : RTL_W8(hw, 0x20E4, RTL_R8(hw, 0x20E4) & ~BIT_2);
995 : : }
996 : :
997 : 0 : rtl8125_set_rx_desc_type(hw);
998 : :
999 : 0 : rtl8125_set_rx_crc_drop(hw, false);
1000 : :
1001 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_58 || hw->mcfg == CFG_METHOD_91) {
1002 : 0 : rtl_clear_mac_ocp_bit(hw, 0xE00C, BIT_12);
1003 : 0 : rtl_clear_mac_ocp_bit(hw, 0xC0C2, BIT_6);
1004 : : }
1005 : :
1006 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xE63E);
1007 : 0 : mac_ocp_data &= ~(BIT_5 | BIT_4);
1008 : 0 : mac_ocp_data |= ((0x02 & 0x03) << 4);
1009 : 0 : rtl_mac_ocp_write(hw, 0xE63E, mac_ocp_data);
1010 : :
1011 : : /*
1012 : : * FTR_MCU_CTRL
1013 : : * 3-2 txpla packet valid start
1014 : : */
1015 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xC0B4);
1016 : 0 : mac_ocp_data &= ~BIT_0;
1017 : 0 : rtl_mac_ocp_write(hw, 0xC0B4, mac_ocp_data);
1018 : 0 : mac_ocp_data |= BIT_0;
1019 : 0 : rtl_mac_ocp_write(hw, 0xC0B4, mac_ocp_data);
1020 : :
1021 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xC0B4);
1022 : : mac_ocp_data |= (BIT_3 | BIT_2);
1023 : 0 : rtl_mac_ocp_write(hw, 0xC0B4, mac_ocp_data);
1024 : :
1025 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xEB6A);
1026 : 0 : mac_ocp_data &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4 | BIT_3 | BIT_2 |
1027 : : BIT_1 | BIT_0);
1028 : 0 : mac_ocp_data |= (BIT_5 | BIT_4 | BIT_1 | BIT_0);
1029 : 0 : rtl_mac_ocp_write(hw, 0xEB6A, mac_ocp_data);
1030 : :
1031 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xEB50);
1032 : 0 : mac_ocp_data &= ~(BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5);
1033 : 0 : mac_ocp_data |= BIT_6;
1034 : 0 : rtl_mac_ocp_write(hw, 0xEB50, mac_ocp_data);
1035 : :
1036 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xE056);
1037 : 0 : mac_ocp_data &= ~(BIT_7 | BIT_6 | BIT_5 | BIT_4);
1038 : 0 : rtl_mac_ocp_write(hw, 0xE056, mac_ocp_data);
1039 : :
1040 : : /* EEE_CR */
1041 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xE040);
1042 : 0 : mac_ocp_data &= ~BIT_12;
1043 : 0 : rtl_mac_ocp_write(hw, 0xE040, mac_ocp_data);
1044 : :
1045 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xEA1C);
1046 : 0 : mac_ocp_data &= ~(BIT_1 | BIT_0);
1047 : 0 : mac_ocp_data |= BIT_0;
1048 : 0 : rtl_mac_ocp_write(hw, 0xEA1C, mac_ocp_data);
1049 : :
1050 : 0 : rtl_oob_mutex_lock(hw);
1051 : :
1052 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_56 || hw->mcfg == CFG_METHOD_57 ||
1053 [ # # # # ]: 0 : hw->mcfg == CFG_METHOD_59 || hw->mcfg == CFG_METHOD_60 ||
1054 : : hw->mcfg == CFG_METHOD_61)
1055 : 0 : rtl_mac_ocp_write(hw, 0xE0C0, 0x4403);
1056 : : else
1057 : 0 : rtl_mac_ocp_write(hw, 0xE0C0, 0x4000);
1058 : :
1059 : 0 : rtl_set_mac_ocp_bit(hw, 0xE052, (BIT_6 | BIT_5));
1060 : 0 : rtl_clear_mac_ocp_bit(hw, 0xE052, (BIT_3 | BIT_7));
1061 : :
1062 : 0 : rtl_oob_mutex_unlock(hw);
1063 : :
1064 : : /*
1065 : : * DMY_PWR_REG_0
1066 : : * (1)ERI(0xD4)(OCP 0xC0AC).bit[7:12]=6'b111111, L1 Mask
1067 : : */
1068 : 0 : rtl_set_mac_ocp_bit(hw, 0xC0AC, (BIT_7 | BIT_8 | BIT_9 | BIT_10 |
1069 : : BIT_11 | BIT_12));
1070 : :
1071 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xD430);
1072 : 0 : mac_ocp_data &= ~(BIT_11 | BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 |
1073 : : BIT_5 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
1074 : 0 : mac_ocp_data |= 0x45F;
1075 : 0 : rtl_mac_ocp_write(hw, 0xD430, mac_ocp_data);
1076 : :
1077 [ # # ]: 0 : if (hw->DASH) {
1078 : 0 : RTL_W8(hw, 0xD0, RTL_R8(hw, 0xD0) & ~BIT_6);
1079 : 0 : RTL_W8(hw, 0xF2, RTL_R8(hw, 0xF2) & ~BIT_6);
1080 : 0 : RTL_W8(hw, 0xD0, RTL_R8(hw, 0xD0) & ~BIT_7);
1081 : : } else {
1082 : 0 : RTL_W8(hw, 0xD0, RTL_R8(hw, 0xD0) | BIT_6);
1083 : 0 : RTL_W8(hw, 0xF2, RTL_R8(hw, 0xF2) | BIT_6);
1084 : 0 : RTL_W8(hw, 0xD0, RTL_R8(hw, 0xD0) | BIT_7);
1085 : : }
1086 : :
1087 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_48 || hw->mcfg == CFG_METHOD_49 ||
1088 : : hw->mcfg == CFG_METHOD_52)
1089 : 0 : RTL_W8(hw, MCUCmd_reg, RTL_R8(hw, MCUCmd_reg) | BIT_0);
1090 : :
1091 : 0 : rtl8125_disable_eee_plus(hw);
1092 : :
1093 : 0 : mac_ocp_data = rtl_mac_ocp_read(hw, 0xEA1C);
1094 : 0 : mac_ocp_data &= ~BIT_2;
1095 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_70 || hw->mcfg == CFG_METHOD_71 ||
1096 : : hw->mcfg == CFG_METHOD_91)
1097 : 0 : mac_ocp_data &= ~(BIT_9 | BIT_8);
1098 : 0 : rtl_mac_ocp_write(hw, 0xEA1C, mac_ocp_data);
1099 : :
1100 : : /* Clear TCAM entries */
1101 : 0 : rtl_set_mac_ocp_bit(hw, 0xEB54, BIT_0);
1102 : 0 : rte_delay_us(1);
1103 : 0 : rtl_clear_mac_ocp_bit(hw, 0xEB54, BIT_0);
1104 : :
1105 : 0 : RTL_W16(hw, 0x1880, RTL_R16(hw, 0x1880) & ~(BIT_4 | BIT_5));
1106 : :
1107 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_91)
1108 : 0 : rtl_clear_set_mac_ocp_bit(hw, 0xD40C, 0xE038, 0x8020);
1109 : :
1110 : : /* Other hw parameters */
1111 : 0 : rtl_hw_clear_timer_int(hw);
1112 : :
1113 : 0 : rtl8125_hw_clear_int_miti(hw);
1114 : :
1115 : 0 : rtl_mac_ocp_write(hw, 0xE098, 0xC302);
1116 : :
1117 : : /* Ensure the old mapping is used. */
1118 : 0 : RTL_W8(hw, INT_CFG0_8125, RTL_R8(hw, INT_CFG0_8125) & ~BIT_0);
1119 : :
1120 : 0 : rtl_disable_cfg9346_write(hw);
1121 : :
1122 : 0 : rte_delay_us(10);
1123 : 0 : }
1124 : :
1125 : : static void
1126 : 0 : rtl8168_hw_config(struct rtl_hw *hw)
1127 : : {
1128 : : u32 csi_tmp;
1129 : : int timeout;
1130 : :
1131 : 0 : rtl_nic_reset(hw);
1132 : :
1133 : 0 : rtl_enable_cfg9346_write(hw);
1134 : :
1135 : : /* Disable aspm clkreq internal */
1136 : : rtl_enable_force_clkreq(hw, 0);
1137 : 0 : rtl_enable_aspm_clkreq_lock(hw, 0);
1138 : :
1139 : : /* Clear io_rdy_l23 */
1140 : 0 : RTL_W8(hw, Config3, RTL_R8(hw, Config3) & ~BIT_1);
1141 : :
1142 : : /* Keep magic packet only */
1143 : 0 : csi_tmp = rtl_eri_read(hw, 0xDE, 1, ERIAR_ExGMAC);
1144 : 0 : csi_tmp &= BIT_0;
1145 : 0 : rtl_eri_write(hw, 0xDE, 1, csi_tmp, ERIAR_ExGMAC);
1146 : :
1147 : : /* Set TxConfig to default */
1148 : 0 : RTL_W32(hw, TxConfig, (TX_DMA_BURST_unlimited << TxDMAShift) |
1149 : : (InterFrameGap << TxInterFrameGapShift));
1150 : :
1151 : 0 : hw->hw_ops.hw_config(hw);
1152 : :
1153 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_21 && hw->mcfg <= CFG_METHOD_28)
1154 : 0 : rtl_eri_write(hw, 0x2F8, 2, 0x1D8F, ERIAR_ExGMAC);
1155 : :
1156 : 0 : rtl_hw_clear_timer_int(hw);
1157 : :
1158 : : /* Clkreq exit masks */
1159 : 0 : csi_tmp = rtl_eri_read(hw, 0xD4, 4, ERIAR_ExGMAC);
1160 : 0 : csi_tmp |= (BIT_7 | BIT_8 | BIT_9 | BIT_10 | BIT_11 | BIT_12);
1161 : 0 : rtl_eri_write(hw, 0xD4, 4, csi_tmp, ERIAR_ExGMAC);
1162 : :
1163 [ # # # # ]: 0 : switch (hw->mcfg) {
1164 : 0 : case CFG_METHOD_25:
1165 : 0 : rtl_mac_ocp_write(hw, 0xD3C0, 0x0B00);
1166 : 0 : rtl_mac_ocp_write(hw, 0xD3C2, 0x0000);
1167 : 0 : break;
1168 : 0 : case CFG_METHOD_29:
1169 : : case CFG_METHOD_30:
1170 : : case CFG_METHOD_35:
1171 : : case CFG_METHOD_36:
1172 : : case CFG_METHOD_37:
1173 : 0 : rtl_mac_ocp_write(hw, 0xE098, 0x0AA2);
1174 : 0 : break;
1175 : 0 : case CFG_METHOD_31:
1176 : : case CFG_METHOD_32:
1177 : : case CFG_METHOD_33:
1178 : : case CFG_METHOD_34:
1179 : 0 : rtl_mac_ocp_write(hw, 0xE098, 0xC302);
1180 : 0 : break;
1181 : : }
1182 : :
1183 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_21 || hw->mcfg == CFG_METHOD_22 ||
1184 [ # # # # ]: 0 : hw->mcfg == CFG_METHOD_24 || hw->mcfg == CFG_METHOD_25 ||
1185 : : hw->mcfg == CFG_METHOD_26) {
1186 [ # # ]: 0 : for (timeout = 0; timeout < 10; timeout++) {
1187 [ # # ]: 0 : if ((rtl_eri_read(hw, 0x1AE, 2, ERIAR_ExGMAC) & BIT_13) == 0)
1188 : : break;
1189 : : rte_delay_ms(1);
1190 : : }
1191 : : }
1192 : :
1193 : 0 : rtl_disable_cfg9346_write(hw);
1194 : :
1195 : 0 : rte_delay_us(10);
1196 : 0 : }
1197 : :
1198 : : void
1199 : 0 : rtl_hw_config(struct rtl_hw *hw)
1200 : : {
1201 [ # # ]: 0 : if (rtl_is_8125(hw))
1202 : 0 : rtl8125_hw_config(hw);
1203 : : else
1204 : 0 : rtl8168_hw_config(hw);
1205 : 0 : }
1206 : :
1207 : : int
1208 : 0 : rtl_set_hw_ops(struct rtl_hw *hw)
1209 : : {
1210 [ # # # # : 0 : switch (hw->mcfg) {
# # # # #
# # # # #
# ]
1211 : : /* 8168G */
1212 : 0 : case CFG_METHOD_21:
1213 : : case CFG_METHOD_22:
1214 : : /* 8168GU */
1215 : : case CFG_METHOD_24:
1216 : : case CFG_METHOD_25:
1217 : 0 : hw->hw_ops = rtl8168g_ops;
1218 : 0 : return 0;
1219 : : /* 8168EP */
1220 : 0 : case CFG_METHOD_23:
1221 : : case CFG_METHOD_27:
1222 : : case CFG_METHOD_28:
1223 : 0 : hw->hw_ops = rtl8168ep_ops;
1224 : 0 : return 0;
1225 : : /* 8168H */
1226 : 0 : case CFG_METHOD_29:
1227 : : case CFG_METHOD_30:
1228 : : case CFG_METHOD_35:
1229 : : case CFG_METHOD_36:
1230 : 0 : hw->hw_ops = rtl8168h_ops;
1231 : 0 : return 0;
1232 : : /* 8168FP */
1233 : 0 : case CFG_METHOD_31:
1234 : : case CFG_METHOD_32:
1235 : : case CFG_METHOD_33:
1236 : : case CFG_METHOD_34:
1237 : 0 : hw->hw_ops = rtl8168fp_ops;
1238 : 0 : return 0;
1239 : : /* 8168M */
1240 : 0 : case CFG_METHOD_37:
1241 : 0 : hw->hw_ops = rtl8168m_ops;
1242 : 0 : return 0;
1243 : : /* 8125A */
1244 : 0 : case CFG_METHOD_48:
1245 : : case CFG_METHOD_49:
1246 : 0 : hw->hw_ops = rtl8125a_ops;
1247 : 0 : return 0;
1248 : : /* 8125B */
1249 : 0 : case CFG_METHOD_50:
1250 : : case CFG_METHOD_51:
1251 : 0 : hw->hw_ops = rtl8125b_ops;
1252 : 0 : return 0;
1253 : : /* 8168KB */
1254 : 0 : case CFG_METHOD_52:
1255 : : case CFG_METHOD_53:
1256 : 0 : hw->hw_ops = rtl8168kb_ops;
1257 : 0 : return 0;
1258 : : /* 8125BP */
1259 : 0 : case CFG_METHOD_54:
1260 : : case CFG_METHOD_55:
1261 : 0 : hw->hw_ops = rtl8125bp_ops;
1262 : 0 : return 0;
1263 : : /* 8125D, 8168KD, 8125K */
1264 : 0 : case CFG_METHOD_56:
1265 : : case CFG_METHOD_57:
1266 : : case CFG_METHOD_59:
1267 : : case CFG_METHOD_61:
1268 : 0 : hw->hw_ops = rtl8125d_ops;
1269 : 0 : return 0;
1270 : : /* 8125CP */
1271 : 0 : case CFG_METHOD_58:
1272 : 0 : hw->hw_ops = rtl8125cp_ops;
1273 : 0 : return 0;
1274 : : /* 9151A */
1275 : 0 : case CFG_METHOD_60:
1276 : 0 : hw->hw_ops = rtl9151a_ops;
1277 : 0 : return 0;
1278 : : /* 8126A */
1279 : 0 : case CFG_METHOD_70:
1280 : : case CFG_METHOD_71:
1281 : 0 : hw->hw_ops = rtl8126a_ops;
1282 : 0 : return 0;
1283 : 0 : case CFG_METHOD_91:
1284 : 0 : hw->hw_ops = rtl8127_ops;
1285 : 0 : return 0;
1286 : : default:
1287 : : return -ENOTSUP;
1288 : : }
1289 : : }
1290 : :
1291 : : void
1292 : 0 : rtl_hw_disable_mac_mcu_bps(struct rtl_hw *hw)
1293 : : {
1294 : : u16 reg_addr;
1295 : :
1296 : 0 : rtl_enable_aspm_clkreq_lock(hw, 0);
1297 : :
1298 [ # # ]: 0 : if (rtl_is_8125(hw))
1299 : 0 : rtl_mac_ocp_write(hw, 0xFC48, 0x0000);
1300 [ # # ]: 0 : else if (hw->mcfg >= CFG_METHOD_29)
1301 : 0 : rtl_mac_ocp_write(hw, 0xFC38, 0x0000);
1302 : :
1303 [ # # ]: 0 : if (rtl_is_8125(hw)) {
1304 [ # # ]: 0 : for (reg_addr = 0xFC28; reg_addr < 0xFC48; reg_addr += 2)
1305 : 0 : rtl_mac_ocp_write(hw, reg_addr, 0x0000);
1306 : : } else {
1307 [ # # ]: 0 : for (reg_addr = 0xFC28; reg_addr < 0xFC38; reg_addr += 2)
1308 : 0 : rtl_mac_ocp_write(hw, reg_addr, 0x0000);
1309 : : }
1310 : :
1311 : : rte_delay_ms(3);
1312 : 0 : rtl_mac_ocp_write(hw, 0xFC26, 0x0000);
1313 : 0 : }
1314 : :
1315 : : static void
1316 : 0 : rtl_switch_mac_mcu_ram_code_page(struct rtl_hw *hw, u16 page)
1317 : : {
1318 : : u16 tmp_ushort;
1319 : :
1320 : 0 : page &= (BIT_1 | BIT_0);
1321 : 0 : tmp_ushort = rtl_mac_ocp_read(hw, 0xE446);
1322 : 0 : tmp_ushort &= ~(BIT_1 | BIT_0);
1323 : 0 : tmp_ushort |= page;
1324 : 0 : rtl_mac_ocp_write(hw, 0xE446, tmp_ushort);
1325 : 0 : }
1326 : :
1327 : : static void
1328 : 0 : _rtl_write_mac_mcu_ram_code(struct rtl_hw *hw, const u16 *entry, u16 entry_cnt)
1329 : : {
1330 : : u16 i;
1331 : :
1332 [ # # ]: 0 : for (i = 0; i < entry_cnt; i++)
1333 : 0 : rtl_mac_ocp_write(hw, 0xF800 + i * 2, entry[i]);
1334 : 0 : }
1335 : :
1336 : : static void
1337 : 0 : _rtl_write_mac_mcu_ram_code_with_page(struct rtl_hw *hw, const u16 *entry,
1338 : : u16 entry_cnt, u16 page_size)
1339 : : {
1340 : : u16 i;
1341 : : u16 offset;
1342 : : u16 page;
1343 : :
1344 [ # # ]: 0 : if (page_size == 0)
1345 : : return;
1346 : :
1347 [ # # ]: 0 : for (i = 0; i < entry_cnt; i++) {
1348 : 0 : offset = i % page_size;
1349 [ # # ]: 0 : if (offset == 0) {
1350 : 0 : page = (i / page_size);
1351 : 0 : rtl_switch_mac_mcu_ram_code_page(hw, page);
1352 : : }
1353 : 0 : rtl_mac_ocp_write(hw, 0xF800 + offset * 2, entry[i]);
1354 : : }
1355 : : }
1356 : :
1357 : : static void
1358 : 0 : _rtl_set_hw_mcu_patch_code_ver(struct rtl_hw *hw, u64 ver)
1359 : : {
1360 : : int i;
1361 : :
1362 : : /* Switch to page 2 */
1363 : 0 : rtl_switch_mac_mcu_ram_code_page(hw, 2);
1364 : :
1365 [ # # ]: 0 : for (i = 0; i < 8; i += 2) {
1366 : 0 : rtl_mac_ocp_write(hw, 0xF9F8 + 6 - i, (u16)ver);
1367 : 0 : ver >>= 16;
1368 : : }
1369 : :
1370 : : /* Switch back to page 0 */
1371 : 0 : rtl_switch_mac_mcu_ram_code_page(hw, 0);
1372 : 0 : }
1373 : :
1374 : : static void
1375 : : rtl_set_hw_mcu_patch_code_ver(struct rtl_hw *hw, u64 ver)
1376 : : {
1377 : 0 : _rtl_set_hw_mcu_patch_code_ver(hw, ver);
1378 : :
1379 : 0 : hw->hw_mcu_patch_code_ver = ver;
1380 : 0 : }
1381 : :
1382 : : void
1383 : 0 : rtl_write_mac_mcu_ram_code(struct rtl_hw *hw, const u16 *entry, u16 entry_cnt)
1384 : : {
1385 [ # # ]: 0 : if (!HW_SUPPORT_MAC_MCU(hw))
1386 : : return;
1387 [ # # ]: 0 : if (!entry || entry_cnt == 0)
1388 : : return;
1389 : :
1390 [ # # ]: 0 : if (hw->MacMcuPageSize > 0)
1391 : 0 : _rtl_write_mac_mcu_ram_code_with_page(hw, entry, entry_cnt,
1392 : : hw->MacMcuPageSize);
1393 : : else
1394 : 0 : _rtl_write_mac_mcu_ram_code(hw, entry, entry_cnt);
1395 : :
1396 [ # # ]: 0 : if (hw->bin_mcu_patch_code_ver > 0)
1397 : : rtl_set_hw_mcu_patch_code_ver(hw, hw->bin_mcu_patch_code_ver);
1398 : : }
1399 : :
1400 : : bool
1401 : 0 : rtl_is_speed_mode_valid(struct rtl_hw *hw, u32 speed)
1402 : : {
1403 [ # # ]: 0 : if (HW_FIBER_MODE_ENABLED(hw)) {
1404 [ # # ]: 0 : switch (speed) {
1405 : : case SPEED_10000:
1406 : : case SPEED_1000:
1407 : : return true;
1408 : 0 : default:
1409 : 0 : return false;
1410 : : }
1411 : : } else {
1412 [ # # ]: 0 : switch (speed) {
1413 : : case SPEED_10000:
1414 : : case SPEED_5000:
1415 : : case SPEED_2500:
1416 : : case SPEED_1000:
1417 : : case SPEED_100:
1418 : : case SPEED_10:
1419 : : return true;
1420 : 0 : default:
1421 : 0 : return false;
1422 : : }
1423 : : }
1424 : : }
1425 : :
1426 : : static bool
1427 : : rtl_is_duplex_mode_valid(u8 duplex)
1428 : : {
1429 [ # # ]: 0 : switch (duplex) {
1430 : : case DUPLEX_FULL:
1431 : : case DUPLEX_HALF:
1432 : : return true;
1433 : : default:
1434 : : return false;
1435 : : }
1436 : : }
1437 : :
1438 : : static bool
1439 : : rtl_is_autoneg_mode_valid(u32 autoneg)
1440 : : {
1441 : : switch (autoneg) {
1442 : : case AUTONEG_ENABLE:
1443 : : case AUTONEG_DISABLE:
1444 : : return true;
1445 : : default:
1446 : : return false;
1447 : : }
1448 : : }
1449 : :
1450 : : void
1451 : 0 : rtl_set_link_option(struct rtl_hw *hw, u8 autoneg, u32 speed, u8 duplex,
1452 : : enum rtl_fc_mode fc)
1453 : : {
1454 : : u64 adv = 0;
1455 : :
1456 [ # # ]: 0 : if (!rtl_is_speed_mode_valid(hw, speed))
1457 : 0 : speed = hw->HwSuppMaxPhyLinkSpeed;
1458 : :
1459 : : if (!rtl_is_duplex_mode_valid(duplex))
1460 : : duplex = DUPLEX_FULL;
1461 : :
1462 : : if (!rtl_is_autoneg_mode_valid(autoneg))
1463 : : autoneg = AUTONEG_ENABLE;
1464 : :
1465 : 0 : speed = RTE_MIN(speed, hw->HwSuppMaxPhyLinkSpeed);
1466 : :
1467 [ # # ]: 0 : if (HW_FIBER_MODE_ENABLED(hw)) {
1468 [ # # # ]: 0 : switch (speed) {
1469 : 0 : case SPEED_10000:
1470 : : adv |= ADVERTISE_10000_FULL;
1471 : : /* Fall through */
1472 : 0 : case SPEED_1000:
1473 : 0 : adv |= ADVERTISE_1000_FULL;
1474 : 0 : break;
1475 : : default:
1476 : : break;
1477 : : }
1478 : : } else {
1479 [ # # # # ]: 0 : switch (speed) {
1480 : 0 : case SPEED_10000:
1481 : : adv |= ADVERTISE_10000_FULL;
1482 : : /* Fall through */
1483 : 0 : case SPEED_5000:
1484 : 0 : adv |= ADVERTISE_5000_FULL;
1485 : : /* Fall through */
1486 : 0 : case SPEED_2500:
1487 : 0 : adv |= ADVERTISE_2500_FULL;
1488 : : /* Fall through */
1489 : 0 : default:
1490 : 0 : adv |= (ADVERTISE_10_HALF | ADVERTISE_10_FULL |
1491 : : ADVERTISE_100_HALF | ADVERTISE_100_FULL |
1492 : : ADVERTISE_1000_HALF | ADVERTISE_1000_FULL);
1493 : 0 : break;
1494 : : }
1495 : : }
1496 : :
1497 : 0 : hw->autoneg = autoneg;
1498 : 0 : hw->speed = speed;
1499 : 0 : hw->duplex = duplex;
1500 : 0 : hw->advertising = adv;
1501 : 0 : hw->fcpause = fc;
1502 : 0 : }
1503 : :
1504 : : static void
1505 : 0 : rtl_init_software_variable(struct rtl_hw *hw, struct rte_pci_device *pci_dev)
1506 : : {
1507 : : int tx_no_close_enable = 1;
1508 : : unsigned int speed_mode;
1509 : : unsigned int duplex_mode = DUPLEX_FULL;
1510 : : unsigned int autoneg_mode = AUTONEG_ENABLE;
1511 : : u32 tmp;
1512 : :
1513 [ # # # # : 0 : switch (hw->mcfg) {
# # # # #
# # # # #
# # # ]
1514 : 0 : case CFG_METHOD_21:
1515 : : case CFG_METHOD_22:
1516 : : case CFG_METHOD_24:
1517 : : case CFG_METHOD_25:
1518 : 0 : hw->chipset_name = RTL8168G;
1519 : 0 : break;
1520 : 0 : case CFG_METHOD_23:
1521 : : case CFG_METHOD_27:
1522 : : case CFG_METHOD_28:
1523 : 0 : hw->chipset_name = RTL8168EP;
1524 : 0 : break;
1525 : 0 : case CFG_METHOD_29:
1526 : : case CFG_METHOD_30:
1527 : : case CFG_METHOD_35:
1528 : : case CFG_METHOD_36:
1529 : 0 : hw->chipset_name = RTL8168H;
1530 : 0 : break;
1531 : 0 : case CFG_METHOD_31:
1532 : : case CFG_METHOD_32:
1533 : : case CFG_METHOD_33:
1534 : : case CFG_METHOD_34:
1535 : 0 : hw->chipset_name = RTL8168FP;
1536 : 0 : break;
1537 : 0 : case CFG_METHOD_37:
1538 : 0 : hw->chipset_name = RTL8168M;
1539 : 0 : break;
1540 : 0 : case CFG_METHOD_48:
1541 : : case CFG_METHOD_49:
1542 : 0 : hw->chipset_name = RTL8125A;
1543 : 0 : break;
1544 : 0 : case CFG_METHOD_50:
1545 : : case CFG_METHOD_51:
1546 : 0 : hw->chipset_name = RTL8125B;
1547 : 0 : break;
1548 : 0 : case CFG_METHOD_52:
1549 : : case CFG_METHOD_53:
1550 : 0 : hw->chipset_name = RTL8168KB;
1551 : 0 : break;
1552 : 0 : case CFG_METHOD_54:
1553 : : case CFG_METHOD_55:
1554 : 0 : hw->chipset_name = RTL8125BP;
1555 : 0 : break;
1556 : 0 : case CFG_METHOD_56:
1557 : : case CFG_METHOD_57:
1558 : 0 : hw->chipset_name = RTL8125D;
1559 : 0 : break;
1560 : 0 : case CFG_METHOD_58:
1561 : 0 : hw->chipset_name = RTL8125CP;
1562 : 0 : break;
1563 : 0 : case CFG_METHOD_59:
1564 : 0 : hw->chipset_name = RTL8168KD;
1565 : 0 : break;
1566 : 0 : case CFG_METHOD_60:
1567 : 0 : hw->chipset_name = RTL9151A;
1568 : 0 : break;
1569 : 0 : case CFG_METHOD_61:
1570 : 0 : hw->chipset_name = RTL8125K;
1571 : 0 : break;
1572 : 0 : case CFG_METHOD_70:
1573 : : case CFG_METHOD_71:
1574 : 0 : hw->chipset_name = RTL8126A;
1575 : 0 : break;
1576 : 0 : case CFG_METHOD_91:
1577 : 0 : hw->chipset_name = RTL8127;
1578 : 0 : break;
1579 : 0 : default:
1580 : 0 : hw->chipset_name = UNKNOWN;
1581 : 0 : break;
1582 : : }
1583 : :
1584 [ # # # # ]: 0 : switch (hw->chipset_name) {
1585 : : case RTL8125A:
1586 : : case RTL8125B:
1587 : : case RTL8125BP:
1588 : : case RTL8125D:
1589 : : case RTL8125CP:
1590 : : case RTL9151A:
1591 : : case RTL8125K:
1592 : : speed_mode = SPEED_2500;
1593 : : break;
1594 : 0 : case RTL8126A:
1595 : : speed_mode = SPEED_5000;
1596 : 0 : break;
1597 : 0 : case RTL8127:
1598 : : speed_mode = SPEED_10000;
1599 : 0 : break;
1600 : 0 : default:
1601 : : speed_mode = SPEED_1000;
1602 : 0 : break;
1603 : : }
1604 : :
1605 : 0 : hw->HwSuppMaxPhyLinkSpeed = speed_mode;
1606 : :
1607 [ # # # # : 0 : switch (hw->mcfg) {
# ]
1608 : 0 : case CFG_METHOD_23:
1609 : : case CFG_METHOD_27:
1610 : : case CFG_METHOD_28:
1611 : 0 : hw->HwSuppDashVer = 2;
1612 : 0 : break;
1613 : 0 : case CFG_METHOD_31:
1614 : : case CFG_METHOD_32:
1615 : : case CFG_METHOD_33:
1616 : : case CFG_METHOD_34:
1617 : 0 : hw->HwSuppDashVer = 3;
1618 : 0 : break;
1619 : 0 : case CFG_METHOD_48:
1620 : : case CFG_METHOD_49:
1621 : : case CFG_METHOD_91:
1622 : 0 : tmp = (u8)rtl_mac_ocp_read(hw, 0xD006);
1623 [ # # ]: 0 : if (tmp == 0x02 || tmp == 0x04)
1624 : 0 : hw->HwSuppDashVer = 2;
1625 [ # # ]: 0 : else if (tmp == 0x03)
1626 : 0 : hw->HwSuppDashVer = 4;
1627 : : break;
1628 : 0 : case CFG_METHOD_54:
1629 : : case CFG_METHOD_55:
1630 : 0 : hw->HwSuppDashVer = 4;
1631 : 0 : break;
1632 : 0 : default:
1633 : 0 : hw->HwSuppDashVer = 0;
1634 : 0 : break;
1635 : : }
1636 : :
1637 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_31 && hw->mcfg <= CFG_METHOD_34) {
1638 : 0 : tmp = rtl_mac_ocp_read(hw, 0xDC00);
1639 : 0 : hw->HwPkgDet = (tmp >> 3) & 0x0F;
1640 : : }
1641 : :
1642 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_32 && hw->mcfg <= CFG_METHOD_34) {
1643 [ # # ]: 0 : if (hw->HwPkgDet == 0x06) {
1644 : 0 : tmp = rtl_eri_read(hw, 0xE6, 1, ERIAR_ExGMAC);
1645 [ # # ]: 0 : if (tmp == 0x02)
1646 : 0 : hw->HwSuppSerDesPhyVer = 1;
1647 [ # # ]: 0 : else if (tmp == 0x00)
1648 : 0 : hw->HwSuppSerDesPhyVer = 2;
1649 : : }
1650 : : }
1651 : :
1652 [ # # # # ]: 0 : switch (hw->mcfg) {
1653 : 0 : case CFG_METHOD_23:
1654 : : case CFG_METHOD_27:
1655 : : case CFG_METHOD_28:
1656 : : case CFG_METHOD_54:
1657 : : case CFG_METHOD_55:
1658 : : case CFG_METHOD_58:
1659 : 0 : hw->HwSuppOcpChannelVer = 2;
1660 : 0 : break;
1661 : 0 : case CFG_METHOD_31:
1662 : : case CFG_METHOD_32:
1663 : : case CFG_METHOD_33:
1664 : : case CFG_METHOD_34:
1665 : 0 : hw->HwSuppOcpChannelVer = 3;
1666 : 0 : break;
1667 : 0 : case CFG_METHOD_48:
1668 : : case CFG_METHOD_49:
1669 : : case CFG_METHOD_91:
1670 [ # # ]: 0 : if (HW_DASH_SUPPORT_DASH(hw))
1671 : 0 : hw->HwSuppOcpChannelVer = 2;
1672 : : break;
1673 : 0 : default:
1674 : 0 : hw->HwSuppOcpChannelVer = 0;
1675 : 0 : break;
1676 : : }
1677 : :
1678 [ # # ]: 0 : if (rtl_is_8125(hw))
1679 : 0 : hw->AllowAccessDashOcp = rtl_is_allow_access_dash_ocp(hw);
1680 : :
1681 [ # # # # ]: 0 : if (HW_DASH_SUPPORT_DASH(hw) && rtl_check_dash(hw))
1682 : 0 : hw->DASH = 1;
1683 : : else
1684 : 0 : hw->DASH = 0;
1685 : :
1686 [ # # ]: 0 : if (HW_DASH_SUPPORT_TYPE_2(hw))
1687 : 0 : hw->cmac_ioaddr = hw->mmio_addr;
1688 : :
1689 : 0 : hw->HwSuppNowIsOobVer = 1;
1690 : :
1691 [ # # ]: 0 : switch (hw->mcfg) {
1692 : 0 : case CFG_METHOD_21:
1693 : : case CFG_METHOD_22:
1694 : : case CFG_METHOD_24:
1695 : : case CFG_METHOD_25:
1696 : : case CFG_METHOD_26:
1697 : : case CFG_METHOD_29:
1698 : : case CFG_METHOD_30:
1699 : : case CFG_METHOD_35:
1700 : : case CFG_METHOD_36:
1701 : : case CFG_METHOD_37:
1702 : 0 : hw->HwSuppCheckPhyDisableModeVer = 2;
1703 : 0 : break;
1704 : 0 : default:
1705 : 0 : hw->HwSuppCheckPhyDisableModeVer = 3;
1706 : 0 : break;
1707 : : }
1708 : :
1709 [ # # # # ]: 0 : switch (hw->mcfg) {
1710 : 0 : case CFG_METHOD_48:
1711 : : case CFG_METHOD_49:
1712 : : case CFG_METHOD_50:
1713 : : case CFG_METHOD_51:
1714 : : case CFG_METHOD_52:
1715 : : case CFG_METHOD_53:
1716 : 0 : hw->HwSuppTxNoCloseVer = 3;
1717 : 0 : break;
1718 : 0 : case CFG_METHOD_54:
1719 : : case CFG_METHOD_55:
1720 : : case CFG_METHOD_56:
1721 : : case CFG_METHOD_57:
1722 : : case CFG_METHOD_58:
1723 : : case CFG_METHOD_59:
1724 : : case CFG_METHOD_60:
1725 : : case CFG_METHOD_61:
1726 : : case CFG_METHOD_91:
1727 : 0 : hw->HwSuppTxNoCloseVer = 6;
1728 : 0 : break;
1729 : 0 : case CFG_METHOD_70:
1730 : : case CFG_METHOD_71:
1731 : 0 : hw->HwSuppTxNoCloseVer = 5;
1732 : 0 : break;
1733 : : }
1734 : :
1735 [ # # # # ]: 0 : switch (hw->HwSuppTxNoCloseVer) {
1736 : 0 : case 5:
1737 : : case 6:
1738 : 0 : hw->MaxTxDescPtrMask = MAX_TX_NO_CLOSE_DESC_PTR_MASK_V4;
1739 : 0 : break;
1740 : 0 : case 4:
1741 : 0 : hw->MaxTxDescPtrMask = MAX_TX_NO_CLOSE_DESC_PTR_MASK_V3;
1742 : 0 : break;
1743 : 0 : case 3:
1744 : 0 : hw->MaxTxDescPtrMask = MAX_TX_NO_CLOSE_DESC_PTR_MASK_V2;
1745 : 0 : break;
1746 : : default:
1747 : : tx_no_close_enable = 0;
1748 : : break;
1749 : : }
1750 : :
1751 [ # # # # ]: 0 : if (hw->HwSuppTxNoCloseVer > 0 && tx_no_close_enable == 1)
1752 : 0 : hw->EnableTxNoClose = TRUE;
1753 : :
1754 [ # # # # : 0 : switch (hw->mcfg) {
# # # # #
# # # # #
# # # # #
# # # # ]
1755 : 0 : case CFG_METHOD_21:
1756 : : case CFG_METHOD_22:
1757 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_21;
1758 : 0 : break;
1759 : 0 : case CFG_METHOD_23:
1760 : : case CFG_METHOD_27:
1761 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_23;
1762 : 0 : break;
1763 : 0 : case CFG_METHOD_24:
1764 : : case CFG_METHOD_25:
1765 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_24;
1766 : 0 : break;
1767 : 0 : case CFG_METHOD_26:
1768 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_26;
1769 : 0 : break;
1770 : 0 : case CFG_METHOD_28:
1771 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_28;
1772 : 0 : break;
1773 : 0 : case CFG_METHOD_29:
1774 : : case CFG_METHOD_30:
1775 : : case CFG_METHOD_37:
1776 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_29;
1777 : 0 : break;
1778 : 0 : case CFG_METHOD_31:
1779 : : case CFG_METHOD_32:
1780 : : case CFG_METHOD_33:
1781 : : case CFG_METHOD_34:
1782 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_31;
1783 : 0 : break;
1784 : 0 : case CFG_METHOD_35:
1785 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_35;
1786 : 0 : break;
1787 : 0 : case CFG_METHOD_36:
1788 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_36;
1789 : 0 : break;
1790 : 0 : case CFG_METHOD_48:
1791 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_48;
1792 : 0 : break;
1793 : 0 : case CFG_METHOD_49:
1794 : : case CFG_METHOD_52:
1795 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_49;
1796 : 0 : break;
1797 : 0 : case CFG_METHOD_50:
1798 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_50;
1799 : 0 : break;
1800 : 0 : case CFG_METHOD_51:
1801 : : case CFG_METHOD_53:
1802 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_51;
1803 : 0 : break;
1804 : 0 : case CFG_METHOD_54:
1805 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_54;
1806 : 0 : break;
1807 : 0 : case CFG_METHOD_55:
1808 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_55;
1809 : 0 : break;
1810 : 0 : case CFG_METHOD_56:
1811 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_56;
1812 : 0 : break;
1813 : 0 : case CFG_METHOD_57:
1814 : : case CFG_METHOD_59:
1815 : : case CFG_METHOD_61:
1816 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_57;
1817 : 0 : break;
1818 : 0 : case CFG_METHOD_58:
1819 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_58;
1820 : 0 : break;
1821 : 0 : case CFG_METHOD_60:
1822 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_60;
1823 : 0 : break;
1824 : 0 : case CFG_METHOD_70:
1825 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_70;
1826 : 0 : break;
1827 : 0 : case CFG_METHOD_71:
1828 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_71;
1829 : 0 : break;
1830 : 0 : case CFG_METHOD_91:
1831 : 0 : hw->sw_ram_code_ver = NIC_RAMCODE_VERSION_CFG_METHOD_91;
1832 : 0 : break;
1833 : : }
1834 : :
1835 [ # # ]: 0 : if (hw->HwIcVerUnknown) {
1836 : 0 : hw->NotWrRamCodeToMicroP = TRUE;
1837 : 0 : hw->NotWrMcuPatchCode = TRUE;
1838 : : }
1839 : :
1840 [ # # ]: 0 : if (rtl_is_8125(hw)) {
1841 : 0 : hw->HwSuppMacMcuVer = 2;
1842 : 0 : hw->MacMcuPageSize = RTL_MAC_MCU_PAGE_SIZE;
1843 : 0 : hw->mcu_pme_setting = rtl_mac_ocp_read(hw, 0xE00A);
1844 : : }
1845 : :
1846 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_70)
1847 : 0 : hw->EnableRss = 1;
1848 : : else
1849 : 0 : hw->EnableRss = 0;
1850 : :
1851 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_49 || hw->mcfg == CFG_METHOD_52) {
1852 [ # # ]: 0 : if ((rtl_mac_ocp_read(hw, 0xD442) & BIT_5) &&
1853 [ # # ]: 0 : (rtl_mdio_direct_read_phy_ocp(hw, 0xD068) & BIT_1))
1854 : 0 : hw->RequirePhyMdiSwapPatch = TRUE;
1855 : : }
1856 : :
1857 [ # # # # : 0 : switch (hw->mcfg) {
# ]
1858 : 0 : case CFG_METHOD_48:
1859 : : case CFG_METHOD_49:
1860 : : case CFG_METHOD_52:
1861 : 0 : hw->HwSuppIntMitiVer = 3;
1862 : 0 : break;
1863 : 0 : case CFG_METHOD_50:
1864 : : case CFG_METHOD_51:
1865 : : case CFG_METHOD_53:
1866 : 0 : hw->HwSuppIntMitiVer = 4;
1867 : 0 : break;
1868 : 0 : case CFG_METHOD_54:
1869 : : case CFG_METHOD_55:
1870 : : case CFG_METHOD_56:
1871 : : case CFG_METHOD_57:
1872 : : case CFG_METHOD_58:
1873 : : case CFG_METHOD_59:
1874 : : case CFG_METHOD_60:
1875 : : case CFG_METHOD_61:
1876 : : case CFG_METHOD_91:
1877 : 0 : hw->HwSuppIntMitiVer = 6;
1878 : 0 : break;
1879 : 0 : case CFG_METHOD_70:
1880 : : case CFG_METHOD_71:
1881 : 0 : hw->HwSuppIntMitiVer = 5;
1882 : 0 : break;
1883 : : }
1884 : :
1885 [ # # ]: 0 : switch (hw->mcfg) {
1886 : 0 : case CFG_METHOD_70:
1887 : : case CFG_METHOD_71:
1888 : : case CFG_METHOD_91:
1889 : 0 : hw->HwSuppRxDescType = RX_DESC_RING_TYPE_4;
1890 : 0 : hw->RxDescLength = RX_DESC_LEN_TYPE_4;
1891 : 0 : break;
1892 : 0 : default:
1893 : 0 : hw->HwSuppRxDescType = RX_DESC_RING_TYPE_1;
1894 : 0 : hw->RxDescLength = RX_DESC_LEN_TYPE_1;
1895 : 0 : break;
1896 : : }
1897 : :
1898 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_91) {
1899 : 0 : tmp = (u8)rtl_mac_ocp_read(hw, 0xD006);
1900 [ # # ]: 0 : if (tmp == 0x07)
1901 : 0 : hw->HwFiberModeVer = FIBER_MODE_RTL8127ATF;
1902 : : }
1903 : :
1904 : 0 : rtl_set_link_option(hw, autoneg_mode, speed_mode, duplex_mode, rtl_fc_full);
1905 : :
1906 : 0 : hw->mtu = RTL_DEFAULT_MTU;
1907 : :
1908 : 0 : hw->function = pci_dev->addr.function;
1909 : 0 : }
1910 : :
1911 : : static void
1912 : 0 : rtl_exit_realwow(struct rtl_hw *hw)
1913 : : {
1914 : : u32 csi_tmp;
1915 : :
1916 : : /* Disable realwow function */
1917 [ # # ]: 0 : if (rtl_is_8125(hw)) {
1918 : 0 : rtl_mac_ocp_write(hw, 0xC0BC, 0x00FF);
1919 [ # # ]: 0 : } else if (hw->mcfg == CFG_METHOD_21 || hw->mcfg == CFG_METHOD_22) {
1920 : 0 : RTL_W32(hw, MACOCP, 0x605E0000);
1921 : 0 : RTL_W32(hw, MACOCP, (0xE05E << 16) |
1922 : : (RTL_R32(hw, MACOCP) & 0xFFFE));
1923 : 0 : RTL_W32(hw, MACOCP, 0xE9720000);
1924 : 0 : RTL_W32(hw, MACOCP, 0xF2140010);
1925 [ # # ]: 0 : } else if (hw->mcfg == CFG_METHOD_26) {
1926 : 0 : RTL_W32(hw, MACOCP, 0xE05E00FF);
1927 : 0 : RTL_W32(hw, MACOCP, 0xE9720000);
1928 : 0 : rtl_mac_ocp_write(hw, 0xE428, 0x0010);
1929 : : }
1930 : :
1931 [ # # # # ]: 0 : switch (hw->mcfg) {
1932 : 0 : case CFG_METHOD_21:
1933 : : case CFG_METHOD_22:
1934 : 0 : rtl_eri_write(hw, 0x174, 2, 0x0000, ERIAR_ExGMAC);
1935 : 0 : rtl_mac_ocp_write(hw, 0xE428, 0x0010);
1936 : 0 : break;
1937 : 0 : case CFG_METHOD_24:
1938 : : case CFG_METHOD_25:
1939 : : case CFG_METHOD_26:
1940 : : case CFG_METHOD_28:
1941 : : case CFG_METHOD_31:
1942 : : case CFG_METHOD_32:
1943 : : case CFG_METHOD_33:
1944 : : case CFG_METHOD_34:
1945 : 0 : rtl_eri_write(hw, 0x174, 2, 0x00FF, ERIAR_ExGMAC);
1946 : 0 : rtl_mac_ocp_write(hw, 0xE428, 0x0010);
1947 : 0 : break;
1948 : 0 : case CFG_METHOD_29:
1949 : : case CFG_METHOD_30:
1950 : : case CFG_METHOD_35:
1951 : : case CFG_METHOD_36:
1952 : : case CFG_METHOD_37:
1953 : 0 : csi_tmp = rtl_eri_read(hw, 0x174, 2, ERIAR_ExGMAC);
1954 : 0 : csi_tmp &= ~BIT_8;
1955 : 0 : csi_tmp |= BIT_15;
1956 : 0 : rtl_eri_write(hw, 0x174, 2, csi_tmp, ERIAR_ExGMAC);
1957 : 0 : rtl_mac_ocp_write(hw, 0xE428, 0x0010);
1958 : 0 : break;
1959 : : }
1960 : 0 : }
1961 : :
1962 : : static void
1963 : : rtl_disable_now_is_oob(struct rtl_hw *hw)
1964 : : {
1965 [ # # ]: 0 : if (hw->HwSuppNowIsOobVer == 1)
1966 : 0 : RTL_W8(hw, MCUCmd_reg, RTL_R8(hw, MCUCmd_reg) & ~Now_is_oob);
1967 : : }
1968 : :
1969 : : static void
1970 : : rtl_wait_ll_share_fifo_ready(struct rtl_hw *hw)
1971 : : {
1972 : : int i;
1973 : :
1974 [ # # # # ]: 0 : for (i = 0; i < 10; i++) {
1975 : 0 : rte_delay_us(100);
1976 [ # # # # ]: 0 : if (RTL_R16(hw, 0xD2) & BIT_9)
1977 : : break;
1978 : : }
1979 : : }
1980 : :
1981 : : static void
1982 : 0 : rtl8168_switch_to_sgmii_mode(struct rtl_hw *hw)
1983 : : {
1984 : 0 : rtl_mac_ocp_write(hw, 0xEB00, 0x2);
1985 : 0 : rtl8168_set_mcu_ocp_bit(hw, 0xEB16, BIT_1);
1986 : 0 : }
1987 : :
1988 : : static u16
1989 : 0 : rtl8125_get_fifo_nf(struct rtl_hw *hw)
1990 : : {
1991 : : u32 magic = 0;
1992 : : u32 mtu;
1993 : :
1994 : 0 : mtu = hw->mtu;
1995 : :
1996 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_48 && hw->mcfg <= CFG_METHOD_61) {
1997 [ # # ]: 0 : if (mtu < 9500)
1998 : 0 : magic = 14215 + mtu;
1999 : : else
2000 : : return 0x5CA;
2001 [ # # ]: 0 : } else if (hw->mcfg >= CFG_METHOD_70 && hw->mcfg <= CFG_METHOD_71) {
2002 [ # # ]: 0 : if (mtu < 9500)
2003 : : magic = 14447;
2004 : : else
2005 : : magic = 4947;
2006 : :
2007 [ # # ]: 0 : magic += mtu * (mtu < 9500 ? 1 : 2);
2008 [ # # ]: 0 : } else if (hw->mcfg >= CFG_METHOD_91) {
2009 [ # # ]: 0 : if (mtu < 9500)
2010 : : magic = 17171;
2011 : : else
2012 : : magic = 7671;
2013 : :
2014 [ # # ]: 0 : magic += mtu * (mtu < 9500 ? 1 : 2);
2015 : : }
2016 : :
2017 : 0 : return (u16)(magic >> 4);
2018 : : }
2019 : :
2020 : : static u16
2021 : : rtl8125_get_fifo_ne(struct rtl_hw *hw)
2022 : : {
2023 : : u32 magic = 0;
2024 : : u32 mtu;
2025 : :
2026 : 0 : mtu = hw->mtu;
2027 : :
2028 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_48 && hw->mcfg <= CFG_METHOD_61) {
2029 : : return 0x6BE;
2030 [ # # ]: 0 : } else if (hw->mcfg >= CFG_METHOD_70 && hw->mcfg <= CFG_METHOD_71) {
2031 [ # # ]: 0 : if (mtu < 9500)
2032 : : return 0x107C;
2033 : :
2034 : : magic = 77033;
2035 [ # # ]: 0 : } else if (hw->mcfg >= CFG_METHOD_91) {
2036 [ # # ]: 0 : if (mtu < 9500)
2037 : : return 0x2C4A;
2038 : :
2039 : : magic = 190910;
2040 : : }
2041 : :
2042 [ # # ]: 0 : if (magic > mtu)
2043 : 0 : return (u16)((magic - mtu) >> 4);
2044 : : else
2045 : : return 0;
2046 : : }
2047 : :
2048 : : static void
2049 : 0 : rtl_exit_oob(struct rtl_hw *hw)
2050 : : {
2051 : : u16 data16;
2052 : :
2053 : : rtl_disable_rx_packet_filter(hw);
2054 : :
2055 [ # # ]: 0 : if (HW_SUPP_SERDES_PHY(hw)) {
2056 [ # # ]: 0 : if (hw->HwSuppSerDesPhyVer == 1)
2057 : 0 : rtl8168_switch_to_sgmii_mode(hw);
2058 : : }
2059 : :
2060 [ # # ]: 0 : if (HW_DASH_SUPPORT_DASH(hw)) {
2061 : 0 : rtl_driver_start(hw);
2062 : 0 : rtl_dash2_disable_txrx(hw);
2063 : : }
2064 : :
2065 : 0 : rtl_exit_realwow(hw);
2066 : :
2067 : 0 : rtl_nic_reset(hw);
2068 : :
2069 : : rtl_disable_now_is_oob(hw);
2070 : :
2071 : 0 : data16 = rtl_mac_ocp_read(hw, 0xE8DE) & ~BIT_14;
2072 : 0 : rtl_mac_ocp_write(hw, 0xE8DE, data16);
2073 : : rtl_wait_ll_share_fifo_ready(hw);
2074 : :
2075 [ # # ]: 0 : if (rtl_is_8125(hw)) {
2076 : 0 : rtl_mac_ocp_write(hw, 0xC0A6, rtl8125_get_fifo_nf(hw));
2077 : 0 : rtl_mac_ocp_write(hw, 0xC0AA, rtl8125_get_fifo_ne(hw));
2078 : 0 : rtl_mac_ocp_write(hw, 0xC01E, 0x5555);
2079 : : } else {
2080 : 0 : data16 = rtl_mac_ocp_read(hw, 0xE8DE) | BIT_15;
2081 : 0 : rtl_mac_ocp_write(hw, 0xE8DE, data16);
2082 : : }
2083 : :
2084 : : rtl_wait_ll_share_fifo_ready(hw);
2085 : 0 : }
2086 : :
2087 : : static void
2088 : 0 : rtl_disable_ups(struct rtl_hw *hw)
2089 : : {
2090 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_29 && hw->mcfg <= CFG_METHOD_36)
2091 : 0 : rtl_mac_ocp_write(hw, 0xD400,
2092 : 0 : rtl_mac_ocp_read(hw, 0xD400) & ~BIT_0);
2093 [ # # ]: 0 : else if (rtl_is_8125(hw))
2094 : 0 : rtl_mac_ocp_write(hw, 0xD40A,
2095 : 0 : rtl_mac_ocp_read(hw, 0xD40A) & ~BIT_4);
2096 : 0 : }
2097 : :
2098 : : static void
2099 : 0 : rtl_disable_ocp_phy_power_saving(struct rtl_hw *hw)
2100 : : {
2101 : : u16 val;
2102 : :
2103 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_25 && hw->mcfg <= CFG_METHOD_37) {
2104 : 0 : val = rtl_mdio_real_read_phy_ocp(hw, 0x0C41, 0x13);
2105 [ # # ]: 0 : if (val != 0x0500) {
2106 : 0 : rtl_set_phy_mcu_patch_request(hw);
2107 : 0 : rtl_mdio_real_write_phy_ocp(hw, 0x0C41, 0x13, 0x0000);
2108 : 0 : rtl_mdio_real_write_phy_ocp(hw, 0x0C41, 0x13, 0x0500);
2109 : 0 : rtl_clear_phy_mcu_patch_request(hw);
2110 : : }
2111 [ # # ]: 0 : } else if (hw->mcfg == CFG_METHOD_48 || hw->mcfg == CFG_METHOD_49 ||
2112 : : hw->mcfg == CFG_METHOD_52) {
2113 : 0 : val = rtl_mdio_direct_read_phy_ocp(hw, 0xC416);
2114 [ # # ]: 0 : if (val != 0x0050) {
2115 : 0 : rtl_set_phy_mcu_patch_request(hw);
2116 : 0 : rtl_mdio_direct_write_phy_ocp(hw, 0xC416, 0x0000);
2117 : 0 : rtl_mdio_direct_write_phy_ocp(hw, 0xC416, 0x0500);
2118 : 0 : rtl_clear_phy_mcu_patch_request(hw);
2119 : : }
2120 : : }
2121 : 0 : }
2122 : :
2123 : : static void
2124 : 0 : rtl8168_disable_dma_agg(struct rtl_hw *hw)
2125 : : {
2126 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_29 && hw->mcfg <= CFG_METHOD_37) {
2127 : 0 : rtl_mac_ocp_write(hw, 0xE63E, rtl_mac_ocp_read(hw, 0xE63E) &
2128 : : ~(BIT_3 | BIT_2 | BIT_1));
2129 : 0 : rtl_mac_ocp_write(hw, 0xE63E,
2130 : 0 : rtl_mac_ocp_read(hw, 0xE63E) | (BIT_0));
2131 : 0 : rtl_mac_ocp_write(hw, 0xE63E,
2132 : 0 : rtl_mac_ocp_read(hw, 0xE63E) & ~(BIT_0));
2133 : 0 : rtl_mac_ocp_write(hw, 0xC094, 0x0);
2134 : 0 : rtl_mac_ocp_write(hw, 0xC09E, 0x0);
2135 : : }
2136 : 0 : }
2137 : :
2138 : : static void
2139 : 0 : rtl_hw_init(struct rtl_hw *hw)
2140 : : {
2141 : : u32 csi_tmp;
2142 : :
2143 : : /* Disable aspm clkreq internal */
2144 : : rtl_enable_force_clkreq(hw, 0);
2145 : 0 : rtl_enable_aspm_clkreq_lock(hw, 0);
2146 : :
2147 : 0 : rtl_disable_ups(hw);
2148 : :
2149 : : /* Disable DMA aggregation */
2150 : 0 : rtl8168_disable_dma_agg(hw);
2151 : :
2152 : 0 : hw->hw_ops.hw_mac_mcu_config(hw);
2153 : :
2154 : : /* Disable ocp phy power saving */
2155 : 0 : rtl_disable_ocp_phy_power_saving(hw);
2156 : :
2157 : : /* Set PCIE uncorrectable error status mask pcie 0x108 */
2158 : 0 : csi_tmp = rtl_csi_read(hw, 0x108);
2159 : 0 : csi_tmp |= BIT_20;
2160 : 0 : rtl_csi_write(hw, 0x108, csi_tmp);
2161 : :
2162 : : /* MCU PME setting */
2163 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_21 && hw->mcfg <= CFG_METHOD_24) {
2164 : 0 : csi_tmp = rtl_eri_read(hw, 0x1AB, 1, ERIAR_ExGMAC);
2165 : 0 : csi_tmp |= (BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
2166 : 0 : rtl_eri_write(hw, 0x1AB, 1, csi_tmp, ERIAR_ExGMAC);
2167 [ # # ]: 0 : } else if (hw->mcfg == CFG_METHOD_25 ||
2168 : : (hw->mcfg >= CFG_METHOD_27 && hw->mcfg <= CFG_METHOD_37)) {
2169 : 0 : csi_tmp = rtl_eri_read(hw, 0x1AB, 1, ERIAR_ExGMAC);
2170 : 0 : csi_tmp |= (BIT_3 | BIT_6);
2171 : 0 : rtl_eri_write(hw, 0x1AB, 1, csi_tmp, ERIAR_ExGMAC);
2172 : : }
2173 : 0 : }
2174 : :
2175 : : void
2176 : 0 : rtl_hw_initialize(struct rtl_hw *hw, struct rte_pci_device *pci_dev)
2177 : : {
2178 : 0 : rtl_init_software_variable(hw, pci_dev);
2179 : :
2180 : 0 : rtl_exit_oob(hw);
2181 : :
2182 : 0 : rtl_hw_init(hw);
2183 : :
2184 : 0 : rtl_nic_reset(hw);
2185 : 0 : }
2186 : :
2187 : : static void
2188 : : rtl8125_get_mac_version_v2(struct rtl_hw *hw)
2189 : : {
2190 : : u32 reg, val32;
2191 : : u32 ic_version_id;
2192 : :
2193 : 0 : val32 = RTL_R32(hw, TxConfigV2);
2194 : 0 : reg = val32 & 0x7fffffc0;
2195 : 0 : ic_version_id = val32 & 0x3f;
2196 : :
2197 : : RTE_ASSERT(val32 != UINT_MAX &&
2198 : : (val32 & RTL_R32(hw, TxConfig) & 0x7c800000) == 0x7c800000);
2199 : :
2200 [ # # ]: 0 : if (val32 == UINT_MAX)
2201 : : return;
2202 : :
2203 [ # # ]: 0 : switch (reg) {
2204 : 0 : case 0x00000000:
2205 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2206 : 0 : hw->mcfg = CFG_METHOD_60;
2207 : : } else {
2208 : 0 : hw->mcfg = CFG_METHOD_60;
2209 : 0 : hw->HwIcVerUnknown = TRUE;
2210 : : }
2211 : : break;
2212 : : default:
2213 : : break;
2214 : : }
2215 : : }
2216 : :
2217 : : void
2218 : 0 : rtl_get_mac_version(struct rtl_hw *hw, struct rte_pci_device *pci_dev)
2219 : : {
2220 : : u32 reg, val32;
2221 : : u32 ic_version_id;
2222 : :
2223 : 0 : val32 = RTL_R32(hw, TxConfig);
2224 : 0 : reg = val32 & 0x7c800000;
2225 : 0 : ic_version_id = val32 & 0x00700000;
2226 : :
2227 : 0 : hw->mcfg = CFG_METHOD_DEFAULT;
2228 : :
2229 : : RTE_ASSERT(val32 != UINT_MAX);
2230 : :
2231 [ # # ]: 0 : if (val32 == UINT_MAX)
2232 : 0 : goto exit;
2233 : :
2234 [ # # # # : 0 : switch (reg) {
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
2235 : 0 : case 0x30000000:
2236 : 0 : hw->mcfg = CFG_METHOD_1;
2237 : 0 : break;
2238 : 0 : case 0x38000000:
2239 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2240 : 0 : hw->mcfg = CFG_METHOD_2;
2241 [ # # ]: 0 : } else if (ic_version_id == 0x00500000) {
2242 : 0 : hw->mcfg = CFG_METHOD_3;
2243 : : } else {
2244 : 0 : hw->mcfg = CFG_METHOD_3;
2245 : 0 : hw->HwIcVerUnknown = TRUE;
2246 : : }
2247 : : break;
2248 : 0 : case 0x3C000000:
2249 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2250 : 0 : hw->mcfg = CFG_METHOD_4;
2251 [ # # ]: 0 : } else if (ic_version_id == 0x00200000) {
2252 : 0 : hw->mcfg = CFG_METHOD_5;
2253 [ # # ]: 0 : } else if (ic_version_id == 0x00400000) {
2254 : 0 : hw->mcfg = CFG_METHOD_6;
2255 : : } else {
2256 : 0 : hw->mcfg = CFG_METHOD_6;
2257 : 0 : hw->HwIcVerUnknown = TRUE;
2258 : : }
2259 : : break;
2260 : 0 : case 0x3C800000:
2261 [ # # ]: 0 : if (ic_version_id == 0x00100000) {
2262 : 0 : hw->mcfg = CFG_METHOD_7;
2263 [ # # ]: 0 : } else if (ic_version_id == 0x00300000) {
2264 : 0 : hw->mcfg = CFG_METHOD_8;
2265 : : } else {
2266 : 0 : hw->mcfg = CFG_METHOD_8;
2267 : 0 : hw->HwIcVerUnknown = TRUE;
2268 : : }
2269 : : break;
2270 : 0 : case 0x28000000:
2271 [ # # ]: 0 : if (ic_version_id == 0x00100000) {
2272 : 0 : hw->mcfg = CFG_METHOD_9;
2273 [ # # ]: 0 : } else if (ic_version_id == 0x00300000) {
2274 : 0 : hw->mcfg = CFG_METHOD_10;
2275 : : } else {
2276 : 0 : hw->mcfg = CFG_METHOD_10;
2277 : 0 : hw->HwIcVerUnknown = TRUE;
2278 : : }
2279 : : break;
2280 : 0 : case 0x28800000:
2281 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2282 : 0 : hw->mcfg = CFG_METHOD_11;
2283 [ # # ]: 0 : } else if (ic_version_id == 0x00200000) {
2284 : 0 : hw->mcfg = CFG_METHOD_12;
2285 : 0 : RTL_W32(hw, 0xD0, RTL_R32(hw, 0xD0) | 0x00020000);
2286 [ # # ]: 0 : } else if (ic_version_id == 0x00300000) {
2287 : 0 : hw->mcfg = CFG_METHOD_13;
2288 : : } else {
2289 : 0 : hw->mcfg = CFG_METHOD_13;
2290 : 0 : hw->HwIcVerUnknown = TRUE;
2291 : : }
2292 : : break;
2293 : 0 : case 0x2C000000:
2294 [ # # ]: 0 : if (ic_version_id == 0x00100000) {
2295 : 0 : hw->mcfg = CFG_METHOD_14;
2296 [ # # ]: 0 : } else if (ic_version_id == 0x00200000) {
2297 : 0 : hw->mcfg = CFG_METHOD_15;
2298 : : } else {
2299 : 0 : hw->mcfg = CFG_METHOD_15;
2300 : 0 : hw->HwIcVerUnknown = TRUE;
2301 : : }
2302 : : break;
2303 : 0 : case 0x2C800000:
2304 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2305 : 0 : hw->mcfg = CFG_METHOD_16;
2306 [ # # ]: 0 : } else if (ic_version_id == 0x00100000) {
2307 : 0 : hw->mcfg = CFG_METHOD_17;
2308 : : } else {
2309 : 0 : hw->mcfg = CFG_METHOD_17;
2310 : 0 : hw->HwIcVerUnknown = TRUE;
2311 : : }
2312 : : break;
2313 : 0 : case 0x48000000:
2314 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2315 : 0 : hw->mcfg = CFG_METHOD_18;
2316 [ # # ]: 0 : } else if (ic_version_id == 0x00100000) {
2317 : 0 : hw->mcfg = CFG_METHOD_19;
2318 : : } else {
2319 : 0 : hw->mcfg = CFG_METHOD_19;
2320 : 0 : hw->HwIcVerUnknown = TRUE;
2321 : : }
2322 : : break;
2323 : 0 : case 0x48800000:
2324 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2325 : 0 : hw->mcfg = CFG_METHOD_20;
2326 : : } else {
2327 : 0 : hw->mcfg = CFG_METHOD_20;
2328 : 0 : hw->HwIcVerUnknown = TRUE;
2329 : : }
2330 : : break;
2331 : 0 : case 0x4C000000:
2332 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2333 : 0 : hw->mcfg = CFG_METHOD_21;
2334 [ # # ]: 0 : } else if (ic_version_id == 0x00100000) {
2335 : 0 : hw->mcfg = CFG_METHOD_22;
2336 : : } else {
2337 : 0 : hw->mcfg = CFG_METHOD_22;
2338 : 0 : hw->HwIcVerUnknown = TRUE;
2339 : : }
2340 : : break;
2341 : 0 : case 0x50000000:
2342 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2343 : 0 : hw->mcfg = CFG_METHOD_23;
2344 [ # # ]: 0 : } else if (ic_version_id == 0x00100000) {
2345 : 0 : hw->mcfg = CFG_METHOD_27;
2346 [ # # ]: 0 : } else if (ic_version_id == 0x00200000) {
2347 : 0 : hw->mcfg = CFG_METHOD_28;
2348 : : } else {
2349 : 0 : hw->mcfg = CFG_METHOD_28;
2350 : 0 : hw->HwIcVerUnknown = TRUE;
2351 : : }
2352 : : break;
2353 : 0 : case 0x50800000:
2354 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2355 : 0 : hw->mcfg = CFG_METHOD_24;
2356 [ # # ]: 0 : } else if (ic_version_id == 0x00100000) {
2357 : 0 : hw->mcfg = CFG_METHOD_25;
2358 : : } else {
2359 : 0 : hw->mcfg = CFG_METHOD_25;
2360 : 0 : hw->HwIcVerUnknown = TRUE;
2361 : : }
2362 : : break;
2363 : 0 : case 0x5C800000:
2364 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2365 : 0 : hw->mcfg = CFG_METHOD_26;
2366 : : } else {
2367 : 0 : hw->mcfg = CFG_METHOD_26;
2368 : 0 : hw->HwIcVerUnknown = TRUE;
2369 : : }
2370 : : break;
2371 : 0 : case 0x54000000:
2372 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2373 : 0 : hw->mcfg = CFG_METHOD_29;
2374 [ # # ]: 0 : } else if (ic_version_id == 0x00100000) {
2375 : 0 : hw->mcfg = CFG_METHOD_30;
2376 : : } else {
2377 : 0 : hw->mcfg = CFG_METHOD_30;
2378 : 0 : hw->HwIcVerUnknown = TRUE;
2379 : : }
2380 : :
2381 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_30) {
2382 [ # # ]: 0 : if ((rtl_mac_ocp_read(hw, 0xD006) & 0xFF00) == 0x0100)
2383 : 0 : hw->mcfg = CFG_METHOD_35;
2384 [ # # ]: 0 : else if ((rtl_mac_ocp_read(hw, 0xD006) & 0xFF00) == 0x0300)
2385 : 0 : hw->mcfg = CFG_METHOD_36;
2386 : : }
2387 : : break;
2388 : 0 : case 0x6C000000:
2389 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2390 : 0 : hw->mcfg = CFG_METHOD_37;
2391 : : } else {
2392 : 0 : hw->mcfg = CFG_METHOD_37;
2393 : 0 : hw->HwIcVerUnknown = TRUE;
2394 : : }
2395 : : break;
2396 : 0 : case 0x54800000:
2397 [ # # ]: 0 : if (ic_version_id == 0x00100000) {
2398 : 0 : hw->mcfg = CFG_METHOD_31;
2399 [ # # ]: 0 : } else if (ic_version_id == 0x00200000) {
2400 : 0 : hw->mcfg = CFG_METHOD_32;
2401 [ # # ]: 0 : } else if (ic_version_id == 0x00300000) {
2402 : 0 : hw->mcfg = CFG_METHOD_33;
2403 [ # # ]: 0 : } else if (ic_version_id == 0x00400000) {
2404 : 0 : hw->mcfg = CFG_METHOD_34;
2405 : : } else {
2406 : 0 : hw->mcfg = CFG_METHOD_34;
2407 : 0 : hw->HwIcVerUnknown = TRUE;
2408 : : }
2409 : : break;
2410 : 0 : case 0x60800000:
2411 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2412 : 0 : hw->mcfg = CFG_METHOD_48;
2413 [ # # ]: 0 : } else if (ic_version_id == 0x100000) {
2414 : 0 : hw->mcfg = CFG_METHOD_49;
2415 : : } else {
2416 : 0 : hw->mcfg = CFG_METHOD_49;
2417 : 0 : hw->HwIcVerUnknown = TRUE;
2418 : : }
2419 : : break;
2420 : 0 : case 0x64000000:
2421 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2422 : 0 : hw->mcfg = CFG_METHOD_50;
2423 [ # # ]: 0 : } else if (ic_version_id == 0x100000) {
2424 : 0 : hw->mcfg = CFG_METHOD_51;
2425 : : } else {
2426 : 0 : hw->mcfg = CFG_METHOD_51;
2427 : 0 : hw->HwIcVerUnknown = TRUE;
2428 : : }
2429 : : break;
2430 : 0 : case 0x68000000:
2431 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2432 : 0 : hw->mcfg = CFG_METHOD_54;
2433 [ # # ]: 0 : } else if (ic_version_id == 0x100000) {
2434 : 0 : hw->mcfg = CFG_METHOD_55;
2435 : : } else {
2436 : 0 : hw->mcfg = CFG_METHOD_55;
2437 : 0 : hw->HwIcVerUnknown = TRUE;
2438 : : }
2439 : : break;
2440 : 0 : case 0x68800000:
2441 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2442 : 0 : hw->mcfg = CFG_METHOD_56;
2443 [ # # ]: 0 : } else if (ic_version_id == 0x100000) {
2444 : 0 : hw->mcfg = CFG_METHOD_57;
2445 [ # # ]: 0 : } else if (ic_version_id == 0x200000) {
2446 : 0 : hw->mcfg = CFG_METHOD_61;
2447 [ # # ]: 0 : } else if (ic_version_id == 0x300000) {
2448 : 0 : hw->mcfg = CFG_METHOD_60;
2449 : : } else {
2450 : 0 : hw->mcfg = CFG_METHOD_61;
2451 : 0 : hw->HwIcVerUnknown = TRUE;
2452 : : }
2453 : : break;
2454 : 0 : case 0x70800000:
2455 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2456 : 0 : hw->mcfg = CFG_METHOD_58;
2457 : : } else {
2458 : 0 : hw->mcfg = CFG_METHOD_58;
2459 : 0 : hw->HwIcVerUnknown = TRUE;
2460 : : }
2461 : : break;
2462 : 0 : case 0x64800000:
2463 [ # # ]: 0 : if (ic_version_id == 0x00000000) {
2464 : : hw->mcfg = CFG_METHOD_DEFAULT;
2465 [ # # ]: 0 : } else if (ic_version_id == 0x100000) {
2466 : 0 : hw->mcfg = CFG_METHOD_70;
2467 [ # # ]: 0 : } else if (ic_version_id == 0x200000) {
2468 : 0 : hw->mcfg = CFG_METHOD_71;
2469 : : } else {
2470 : 0 : hw->mcfg = CFG_METHOD_71;
2471 : 0 : hw->HwIcVerUnknown = TRUE;
2472 : : }
2473 : : break;
2474 : 0 : case 0x6C800000:
2475 [ # # ]: 0 : if (ic_version_id == 0x100000) {
2476 : 0 : hw->mcfg = CFG_METHOD_91;
2477 : : } else {
2478 : 0 : hw->mcfg = CFG_METHOD_91;
2479 : 0 : hw->HwIcVerUnknown = TRUE;
2480 : : }
2481 : : break;
2482 : : case 0x7C800000:
2483 : : rtl8125_get_mac_version_v2(hw);
2484 : : break;
2485 : : default:
2486 : : break;
2487 : : }
2488 : :
2489 : 0 : exit:
2490 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_DEFAULT) {
2491 : 0 : PMD_INIT_LOG(NOTICE, "unknown chip version (%x)", reg);
2492 : 0 : hw->HwIcVerUnknown = TRUE;
2493 : : }
2494 : :
2495 [ # # ]: 0 : if (pci_dev->id.device_id == 0x8162) {
2496 [ # # ]: 0 : if (hw->mcfg == CFG_METHOD_49)
2497 : 0 : hw->mcfg = CFG_METHOD_52;
2498 [ # # ]: 0 : else if (hw->mcfg == CFG_METHOD_51)
2499 : 0 : hw->mcfg = CFG_METHOD_53;
2500 [ # # ]: 0 : else if (hw->mcfg == CFG_METHOD_57)
2501 : 0 : hw->mcfg = CFG_METHOD_59;
2502 : : }
2503 : 0 : }
2504 : :
2505 : : int
2506 : 0 : rtl_get_mac_address(struct rtl_hw *hw, struct rte_ether_addr *ea)
2507 : : {
2508 : : u8 mac_addr[RTE_ETHER_ADDR_LEN] = {0};
2509 : :
2510 [ # # ]: 0 : if (rtl_is_8125(hw)) {
2511 : 0 : *(u32 *)&mac_addr[0] = RTL_R32(hw, BACKUP_ADDR0_8125);
2512 : 0 : *(u16 *)&mac_addr[4] = RTL_R16(hw, BACKUP_ADDR1_8125);
2513 : : } else {
2514 : 0 : *(u32 *)&mac_addr[0] = rtl_eri_read(hw, 0xE0, 4, ERIAR_ExGMAC);
2515 : 0 : *(u16 *)&mac_addr[4] = rtl_eri_read(hw, 0xE4, 2, ERIAR_ExGMAC);
2516 : : }
2517 : :
2518 : : rte_ether_addr_copy((struct rte_ether_addr *)mac_addr, ea);
2519 : :
2520 : 0 : return 0;
2521 : : }
2522 : :
2523 : : /* Puts an ethernet address into a receive address register. */
2524 : : void
2525 : 0 : rtl_rar_set(struct rtl_hw *hw, uint8_t *addr)
2526 : : {
2527 : : uint32_t rar_low = 0;
2528 : : uint32_t rar_high = 0;
2529 : :
2530 : 0 : rar_low = ((uint32_t)addr[0] | ((uint32_t)addr[1] << 8) |
2531 : 0 : ((uint32_t)addr[2] << 16) | ((uint32_t)addr[3] << 24));
2532 : :
2533 : 0 : rar_high = ((uint32_t)addr[4] | ((uint32_t)addr[5] << 8));
2534 : :
2535 : 0 : rtl_enable_cfg9346_write(hw);
2536 : :
2537 : 0 : RTL_W32(hw, MAC0, rar_low);
2538 : 0 : RTL_W32(hw, MAC4, rar_high);
2539 : :
2540 : 0 : rtl_disable_cfg9346_write(hw);
2541 : 0 : }
2542 : :
2543 : : void
2544 : 0 : rtl_get_tally_stats(struct rtl_hw *hw, struct rte_eth_stats *rte_stats)
2545 : : {
2546 : : struct rtl_counters *counters;
2547 : : uint64_t paddr;
2548 : : u32 cmd;
2549 : : u32 wait_cnt;
2550 : :
2551 : 0 : counters = hw->tally_vaddr;
2552 : 0 : paddr = hw->tally_paddr;
2553 [ # # ]: 0 : if (!counters)
2554 : : return;
2555 : :
2556 : 0 : RTL_W32(hw, CounterAddrHigh, (u64)paddr >> 32);
2557 : 0 : cmd = (u64)paddr & DMA_BIT_MASK(32);
2558 : 0 : RTL_W32(hw, CounterAddrLow, cmd);
2559 : 0 : RTL_W32(hw, CounterAddrLow, cmd | CounterDump);
2560 : :
2561 : : wait_cnt = 0;
2562 [ # # ]: 0 : while (RTL_R32(hw, CounterAddrLow) & CounterDump) {
2563 : 0 : rte_delay_us(10);
2564 : :
2565 : 0 : wait_cnt++;
2566 [ # # ]: 0 : if (wait_cnt > 20)
2567 : : break;
2568 : : }
2569 : :
2570 : : /* RX errors */
2571 : 0 : rte_stats->imissed = rte_le_to_cpu_64(counters->rx_missed);
2572 : 0 : rte_stats->ierrors = rte_le_to_cpu_64(counters->rx_errors);
2573 : :
2574 : : /* TX errors */
2575 : 0 : rte_stats->oerrors = rte_le_to_cpu_64(counters->tx_errors);
2576 : :
2577 : 0 : rte_stats->ipackets = rte_le_to_cpu_64(counters->rx_packets);
2578 : 0 : rte_stats->opackets = rte_le_to_cpu_64(counters->tx_packets);
2579 : : }
2580 : :
2581 : : void
2582 : 0 : rtl_clear_tally_stats(struct rtl_hw *hw)
2583 : : {
2584 [ # # ]: 0 : if (!hw->tally_paddr)
2585 : : return;
2586 : :
2587 : 0 : RTL_W32(hw, CounterAddrHigh, (u64)hw->tally_paddr >> 32);
2588 : 0 : RTL_W32(hw, CounterAddrLow,
2589 : : ((u64)hw->tally_paddr & (DMA_BIT_MASK(32))) | CounterReset);
2590 : : }
2591 : :
2592 : : int
2593 : 0 : rtl_tally_init(struct rte_eth_dev *dev)
2594 : : {
2595 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
2596 : 0 : struct rtl_hw *hw = &adapter->hw;
2597 : : const struct rte_memzone *mz;
2598 : :
2599 : 0 : mz = rte_eth_dma_zone_reserve(dev, "tally_counters", 0,
2600 : 0 : sizeof(struct rtl_counters), 64, rte_socket_id());
2601 [ # # ]: 0 : if (mz == NULL)
2602 : : return -ENOMEM;
2603 : :
2604 : 0 : hw->tally_vaddr = mz->addr;
2605 : 0 : hw->tally_paddr = mz->iova;
2606 : :
2607 : : /* Fill tally addrs */
2608 : 0 : RTL_W32(hw, CounterAddrHigh, (u64)hw->tally_paddr >> 32);
2609 : 0 : RTL_W32(hw, CounterAddrLow, (u64)hw->tally_paddr & (DMA_BIT_MASK(32)));
2610 : :
2611 : : /* Reset the hw statistics */
2612 : 0 : rtl_clear_tally_stats(hw);
2613 : :
2614 : 0 : return 0;
2615 : : }
2616 : :
2617 : : void
2618 : 0 : rtl_tally_free(struct rte_eth_dev *dev)
2619 : : {
2620 : 0 : rte_eth_dma_zone_free(dev, "tally_counters", 0);
2621 : 0 : }
2622 : :
2623 : : bool
2624 : 0 : rtl_is_8125(struct rtl_hw *hw)
2625 : : {
2626 : 0 : return hw->mcfg >= CFG_METHOD_48;
2627 : : }
2628 : :
2629 : : u64
2630 : 0 : rtl_get_hw_mcu_patch_code_ver(struct rtl_hw *hw)
2631 : : {
2632 : : u64 ver;
2633 : : int i;
2634 : :
2635 : : /* Switch to page 2 */
2636 : 0 : rtl_switch_mac_mcu_ram_code_page(hw, 2);
2637 : :
2638 : : ver = 0;
2639 [ # # ]: 0 : for (i = 0; i < 8; i += 2) {
2640 : 0 : ver <<= 16;
2641 : 0 : ver |= rtl_mac_ocp_read(hw, 0xF9F8 + i);
2642 : : }
2643 : :
2644 : : /* Switch back to page 0 */
2645 : 0 : rtl_switch_mac_mcu_ram_code_page(hw, 0);
2646 : :
2647 : 0 : return ver;
2648 : : }
2649 : :
2650 : : u64
2651 : 0 : rtl_get_bin_mcu_patch_code_ver(const u16 *entry, u16 entry_cnt)
2652 : : {
2653 : : u64 ver;
2654 : : int i;
2655 : :
2656 [ # # # # ]: 0 : if (!entry || entry_cnt == 0 || entry_cnt < 4)
2657 : : return 0;
2658 : :
2659 : : ver = 0;
2660 [ # # ]: 0 : for (i = 0; i < 4; i++) {
2661 : 0 : ver <<= 16;
2662 : 0 : ver |= entry[entry_cnt - 4 + i];
2663 : : }
2664 : :
2665 : : return ver;
2666 : : }
|
