Branch data Line data Source code
1 : : // SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
2 : : /* Copyright (C) 2014-2017 aQuantia Corporation. */
3 : :
4 : : /* File hw_atl_utils.c: Definition of common functions for Atlantic hardware
5 : : * abstraction layer.
6 : : */
7 : :
8 : : #include <stdio.h>
9 : : #include <errno.h>
10 : : #include <stdint.h>
11 : : #include <string.h>
12 : : #include <unistd.h>
13 : : #include <stdarg.h>
14 : : #include <inttypes.h>
15 : : #include <rte_ether.h>
16 : : #include "../atl_hw_regs.h"
17 : :
18 : : #include "hw_atl_llh.h"
19 : : #include "hw_atl_llh_internal.h"
20 : : #include "../atl_logs.h"
21 : :
22 : : #define HW_ATL_UCP_0X370_REG 0x0370U
23 : :
24 : : #define HW_ATL_MIF_CMD 0x0200U
25 : : #define HW_ATL_MIF_ADDR 0x0208U
26 : : #define HW_ATL_MIF_VAL 0x020CU
27 : :
28 : : #define HW_ATL_FW_SM_RAM 0x2U
29 : : #define HW_ATL_MPI_FW_VERSION 0x18
30 : : #define HW_ATL_MPI_CONTROL_ADR 0x0368U
31 : : #define HW_ATL_MPI_STATE_ADR 0x036CU
32 : :
33 : : #define HW_ATL_MPI_STATE_MSK 0x00FFU
34 : : #define HW_ATL_MPI_STATE_SHIFT 0U
35 : : #define HW_ATL_MPI_SPEED_MSK 0x00FF0000U
36 : : #define HW_ATL_MPI_SPEED_SHIFT 16U
37 : : #define HW_ATL_MPI_DIRTY_WAKE_MSK 0x02000000U
38 : :
39 : : #define HW_ATL_MPI_DAISY_CHAIN_STATUS 0x704
40 : : #define HW_ATL_MPI_BOOT_EXIT_CODE 0x388
41 : :
42 : : #define HW_ATL_MAC_PHY_CONTROL 0x4000
43 : : #define HW_ATL_MAC_PHY_MPI_RESET_BIT 0x1D
44 : :
45 : : #define HW_ATL_FW_VER_1X 0x01050006U
46 : : #define HW_ATL_FW_VER_2X 0x02000000U
47 : : #define HW_ATL_FW_VER_3X 0x03000000U
48 : :
49 : : #define FORCE_FLASHLESS 0
50 : :
51 : : static int hw_atl_utils_ver_match(u32 ver_expected, u32 ver_actual);
52 : : static int hw_atl_utils_mpi_set_state(struct aq_hw_s *self,
53 : : enum hal_atl_utils_fw_state_e state);
54 : :
55 : :
56 : 0 : int hw_atl_utils_initfw(struct aq_hw_s *self, const struct aq_fw_ops **fw_ops)
57 : : {
58 : : int err = 0;
59 : :
60 : 0 : err = hw_atl_utils_soft_reset(self);
61 [ # # ]: 0 : if (err)
62 : : return err;
63 : :
64 : 0 : hw_atl_utils_hw_chip_features_init(self,
65 : 0 : &self->chip_features);
66 : :
67 : 0 : hw_atl_utils_get_fw_version(self, &self->fw_ver_actual);
68 : :
69 : 0 : if (hw_atl_utils_ver_match(HW_ATL_FW_VER_1X,
70 : : self->fw_ver_actual) == 0) {
71 : 0 : *fw_ops = &aq_fw_1x_ops;
72 : : } else if (hw_atl_utils_ver_match(HW_ATL_FW_VER_2X,
73 : : self->fw_ver_actual) == 0) {
74 : 0 : *fw_ops = &aq_fw_2x_ops;
75 : : } else if (hw_atl_utils_ver_match(HW_ATL_FW_VER_3X,
76 : : self->fw_ver_actual) == 0) {
77 : 0 : *fw_ops = &aq_fw_2x_ops;
78 : : } else {
79 : 0 : PMD_DRV_LOG(ERR, "Bad FW version detected: %x\n",
80 : : self->fw_ver_actual);
81 : 0 : return -EOPNOTSUPP;
82 : : }
83 : 0 : self->aq_fw_ops = *fw_ops;
84 : 0 : err = self->aq_fw_ops->init(self);
85 : 0 : return err;
86 : : }
87 : :
88 : 0 : static int hw_atl_utils_soft_reset_flb(struct aq_hw_s *self)
89 : : {
90 : : u32 gsr, val;
91 : : int k = 0;
92 : :
93 : 0 : aq_hw_write_reg(self, 0x404, 0x40e1);
94 : : AQ_HW_SLEEP(50);
95 : :
96 : : /* Cleanup SPI */
97 : 0 : val = aq_hw_read_reg(self, 0x53C);
98 : 0 : aq_hw_write_reg(self, 0x53C, val | 0x10);
99 : :
100 : 0 : gsr = aq_hw_read_reg(self, HW_ATL_GLB_SOFT_RES_ADR);
101 : 0 : aq_hw_write_reg(self, HW_ATL_GLB_SOFT_RES_ADR, (gsr & 0xBFFF) | 0x8000);
102 : :
103 : : /* Kickstart MAC */
104 : 0 : aq_hw_write_reg(self, 0x404, 0x80e0);
105 : 0 : aq_hw_write_reg(self, 0x32a8, 0x0);
106 : 0 : aq_hw_write_reg(self, 0x520, 0x1);
107 : :
108 : : /* Reset SPI again because of possible interrupted SPI burst */
109 : 0 : val = aq_hw_read_reg(self, 0x53C);
110 : 0 : aq_hw_write_reg(self, 0x53C, val | 0x10);
111 : : AQ_HW_SLEEP(10);
112 : : /* Clear SPI reset state */
113 : 0 : aq_hw_write_reg(self, 0x53C, val & ~0x10);
114 : :
115 : 0 : aq_hw_write_reg(self, 0x404, 0x180e0);
116 : :
117 [ # # ]: 0 : for (k = 0; k < 1000; k++) {
118 : 0 : u32 flb_status = aq_hw_read_reg(self,
119 : : HW_ATL_MPI_DAISY_CHAIN_STATUS);
120 : :
121 : 0 : flb_status = flb_status & 0x10;
122 [ # # ]: 0 : if (flb_status)
123 : : break;
124 : : AQ_HW_SLEEP(10);
125 : : }
126 [ # # ]: 0 : if (k == 1000) {
127 : 0 : PMD_DRV_LOG(ERR, "MAC kickstart failed\n");
128 : 0 : return -EIO;
129 : : }
130 : :
131 : : /* FW reset */
132 : 0 : aq_hw_write_reg(self, 0x404, 0x80e0);
133 : : AQ_HW_SLEEP(50);
134 : 0 : aq_hw_write_reg(self, 0x3a0, 0x1);
135 : :
136 : : /* Kickstart PHY - skipped */
137 : :
138 : : /* Global software reset*/
139 : 0 : hw_atl_rx_rx_reg_res_dis_set(self, 0U);
140 : 0 : hw_atl_tx_tx_reg_res_dis_set(self, 0U);
141 : 0 : aq_hw_write_reg_bit(self, HW_ATL_MAC_PHY_CONTROL,
142 : : BIT(HW_ATL_MAC_PHY_MPI_RESET_BIT),
143 : : HW_ATL_MAC_PHY_MPI_RESET_BIT, 0x0);
144 : 0 : gsr = aq_hw_read_reg(self, HW_ATL_GLB_SOFT_RES_ADR);
145 : 0 : aq_hw_write_reg(self, HW_ATL_GLB_SOFT_RES_ADR, (gsr & 0xBFFF) | 0x8000);
146 : :
147 [ # # ]: 0 : for (k = 0; k < 1000; k++) {
148 : 0 : u32 fw_state = aq_hw_read_reg(self, HW_ATL_MPI_FW_VERSION);
149 : :
150 [ # # ]: 0 : if (fw_state)
151 : : break;
152 : : AQ_HW_SLEEP(10);
153 : : }
154 [ # # ]: 0 : if (k == 1000) {
155 : 0 : PMD_DRV_LOG(ERR, "FW kickstart failed\n");
156 : 0 : return -EIO;
157 : : }
158 : : /* Old FW requires fixed delay after init */
159 : : AQ_HW_SLEEP(15);
160 : :
161 : 0 : return 0;
162 : : }
163 : :
164 : 0 : static int hw_atl_utils_soft_reset_rbl(struct aq_hw_s *self)
165 : : {
166 : : u32 gsr, val, rbl_status;
167 : : int k;
168 : :
169 : 0 : aq_hw_write_reg(self, 0x404, 0x40e1);
170 : 0 : aq_hw_write_reg(self, 0x3a0, 0x1);
171 : 0 : aq_hw_write_reg(self, 0x32a8, 0x0);
172 : :
173 : : /* Alter RBL status */
174 : 0 : aq_hw_write_reg(self, 0x388, 0xDEAD);
175 : :
176 : : /* Cleanup SPI */
177 : 0 : val = aq_hw_read_reg(self, 0x53C);
178 : 0 : aq_hw_write_reg(self, 0x53C, val | 0x10);
179 : :
180 : : /* Global software reset*/
181 : 0 : hw_atl_rx_rx_reg_res_dis_set(self, 0U);
182 : 0 : hw_atl_tx_tx_reg_res_dis_set(self, 0U);
183 : 0 : aq_hw_write_reg_bit(self, HW_ATL_MAC_PHY_CONTROL,
184 : : BIT(HW_ATL_MAC_PHY_MPI_RESET_BIT),
185 : : HW_ATL_MAC_PHY_MPI_RESET_BIT, 0x0);
186 : 0 : gsr = aq_hw_read_reg(self, HW_ATL_GLB_SOFT_RES_ADR);
187 : 0 : aq_hw_write_reg(self, HW_ATL_GLB_SOFT_RES_ADR,
188 : 0 : (gsr & 0xFFFFBFFF) | 0x8000);
189 : :
190 : : if (FORCE_FLASHLESS)
191 : : aq_hw_write_reg(self, 0x534, 0x0);
192 : :
193 : 0 : aq_hw_write_reg(self, 0x404, 0x40e0);
194 : :
195 : : /* Wait for RBL boot */
196 [ # # ]: 0 : for (k = 0; k < 1000; k++) {
197 : 0 : rbl_status = aq_hw_read_reg(self, 0x388) & 0xFFFF;
198 [ # # ]: 0 : if (rbl_status && rbl_status != 0xDEAD)
199 : : break;
200 : : AQ_HW_SLEEP(10);
201 : : }
202 [ # # ]: 0 : if (!rbl_status || rbl_status == 0xDEAD) {
203 : 0 : PMD_DRV_LOG(ERR, "RBL Restart failed");
204 : 0 : return -EIO;
205 : : }
206 : :
207 : : /* Restore NVR */
208 : : if (FORCE_FLASHLESS)
209 : : aq_hw_write_reg(self, 0x534, 0xA0);
210 : :
211 [ # # ]: 0 : if (rbl_status == 0xF1A7) {
212 : 0 : PMD_DRV_LOG(ERR, "No FW detected. Dynamic FW load not implemented\n");
213 : 0 : return -EOPNOTSUPP;
214 : : }
215 : :
216 [ # # ]: 0 : for (k = 0; k < 1000; k++) {
217 : 0 : u32 fw_state = aq_hw_read_reg(self, HW_ATL_MPI_FW_VERSION);
218 : :
219 [ # # ]: 0 : if (fw_state)
220 : : break;
221 : : AQ_HW_SLEEP(10);
222 : : }
223 [ # # ]: 0 : if (k == 1000) {
224 : 0 : PMD_DRV_LOG(ERR, "FW kickstart failed\n");
225 : 0 : return -EIO;
226 : : }
227 : : /* Old FW requires fixed delay after init */
228 : : AQ_HW_SLEEP(15);
229 : :
230 : 0 : return 0;
231 : : }
232 : :
233 : 0 : int hw_atl_utils_soft_reset(struct aq_hw_s *self)
234 : : {
235 : : int err = 0;
236 : : int k;
237 : : u32 boot_exit_code = 0;
238 : :
239 [ # # ]: 0 : for (k = 0; k < 1000; ++k) {
240 : 0 : u32 flb_status = aq_hw_read_reg(self,
241 : : HW_ATL_MPI_DAISY_CHAIN_STATUS);
242 : 0 : boot_exit_code = aq_hw_read_reg(self,
243 : : HW_ATL_MPI_BOOT_EXIT_CODE);
244 [ # # ]: 0 : if (flb_status != 0x06000000 || boot_exit_code != 0)
245 : : break;
246 : : }
247 : :
248 [ # # ]: 0 : if (k == 1000) {
249 : 0 : PMD_DRV_LOG(ERR, "Neither RBL nor FLB firmware started\n");
250 : 0 : return -EOPNOTSUPP;
251 : : }
252 : :
253 : 0 : self->rbl_enabled = (boot_exit_code != 0);
254 : :
255 : : /* FW 1.x may bootup in an invalid POWER state (WOL feature).
256 : : * We should work around this by forcing its state back to DEINIT
257 : : */
258 : 0 : if (!hw_atl_utils_ver_match(HW_ATL_FW_VER_1X,
259 : : aq_hw_read_reg(self,
260 : : HW_ATL_MPI_FW_VERSION))) {
261 : 0 : hw_atl_utils_mpi_set_state(self, MPI_DEINIT);
262 [ # # # # ]: 0 : AQ_HW_WAIT_FOR((aq_hw_read_reg(self, HW_ATL_MPI_STATE_ADR) &
263 : : HW_ATL_MPI_STATE_MSK) == MPI_DEINIT,
264 : : 10, 1000U);
265 : : }
266 : :
267 [ # # ]: 0 : if (self->rbl_enabled)
268 : 0 : err = hw_atl_utils_soft_reset_rbl(self);
269 : : else
270 : 0 : err = hw_atl_utils_soft_reset_flb(self);
271 : :
272 : : return err;
273 : : }
274 : :
275 : 0 : int hw_atl_utils_fw_downld_dwords(struct aq_hw_s *self, u32 a,
276 : : u32 *p, u32 cnt)
277 : : {
278 : : int err = 0;
279 : :
280 [ # # # # : 0 : AQ_HW_WAIT_FOR(hw_atl_reg_glb_cpu_sem_get(self,
# # ]
281 : : HW_ATL_FW_SM_RAM) == 1U,
282 : : 1U, 10000U);
283 : :
284 : : if (err < 0) {
285 : : bool is_locked;
286 : :
287 : 0 : hw_atl_reg_glb_cpu_sem_set(self, 1U, HW_ATL_FW_SM_RAM);
288 : 0 : is_locked = hw_atl_reg_glb_cpu_sem_get(self, HW_ATL_FW_SM_RAM);
289 [ # # ]: 0 : if (!is_locked) {
290 : : err = -ETIMEDOUT;
291 : 0 : goto err_exit;
292 : : }
293 : : }
294 : :
295 : 0 : aq_hw_write_reg(self, HW_ATL_MIF_ADDR, a);
296 : :
297 [ # # # # ]: 0 : for (++cnt; --cnt && !err;) {
298 : 0 : aq_hw_write_reg(self, HW_ATL_MIF_CMD, 0x00008000U);
299 : :
300 [ # # ]: 0 : if (IS_CHIP_FEATURE(REVISION_B1))
301 [ # # # # : 0 : AQ_HW_WAIT_FOR(a != aq_hw_read_reg(self,
# # ]
302 : : HW_ATL_MIF_ADDR),
303 : : 1, 1000U);
304 : : else
305 [ # # # # : 0 : AQ_HW_WAIT_FOR(!(0x100 & aq_hw_read_reg(self,
# # ]
306 : : HW_ATL_MIF_CMD)),
307 : : 1, 1000U);
308 : : if (err) {
309 : : err = -ETIMEDOUT;
310 : 0 : goto err_exit;
311 : : }
312 : :
313 : 0 : *(p++) = aq_hw_read_reg(self, HW_ATL_MIF_VAL);
314 : 0 : a += 4;
315 : : }
316 : :
317 : 0 : hw_atl_reg_glb_cpu_sem_set(self, 1U, HW_ATL_FW_SM_RAM);
318 : :
319 : 0 : err_exit:
320 : 0 : return err;
321 : : }
322 : :
323 : 0 : int hw_atl_utils_fw_upload_dwords(struct aq_hw_s *self, u32 a, u32 *p,
324 : : u32 cnt)
325 : : {
326 : : int err = 0;
327 : : bool is_locked;
328 : :
329 : 0 : is_locked = hw_atl_reg_glb_cpu_sem_get(self, HW_ATL_FW_SM_RAM);
330 [ # # ]: 0 : if (!is_locked) {
331 : : err = -ETIMEDOUT;
332 : 0 : goto err_exit;
333 : : }
334 [ # # ]: 0 : if (IS_CHIP_FEATURE(REVISION_B1)) {
335 : 0 : u32 mbox_offset = (a - self->rpc_addr) / sizeof(u32);
336 : : u32 data_offset = 0;
337 : :
338 [ # # ]: 0 : for (; data_offset < cnt; ++mbox_offset, ++data_offset) {
339 : 0 : aq_hw_write_reg(self, 0x328, p[data_offset]);
340 : 0 : aq_hw_write_reg(self, 0x32C,
341 : 0 : (0x80000000 | (0xFFFF & (mbox_offset * 4))));
342 : 0 : hw_atl_mcp_up_force_intr_set(self, 1);
343 : : /* 1000 times by 10us = 10ms */
344 [ # # # # : 0 : AQ_HW_WAIT_FOR((aq_hw_read_reg(self,
# # ]
345 : : 0x32C) & 0xF0000000) != 0x80000000,
346 : : 10, 1000);
347 : : }
348 : : } else {
349 : : u32 offset = 0;
350 : :
351 : 0 : aq_hw_write_reg(self, 0x208, a);
352 : :
353 [ # # ]: 0 : for (; offset < cnt; ++offset) {
354 : 0 : aq_hw_write_reg(self, 0x20C, p[offset]);
355 : 0 : aq_hw_write_reg(self, 0x200, 0xC000);
356 : :
357 [ # # # # : 0 : AQ_HW_WAIT_FOR((aq_hw_read_reg(self, 0x200U)
# # ]
358 : : & 0x100) == 0, 10, 1000);
359 : : }
360 : : }
361 : :
362 : 0 : hw_atl_reg_glb_cpu_sem_set(self, 1U, HW_ATL_FW_SM_RAM);
363 : :
364 : 0 : err_exit:
365 : 0 : return err;
366 : : }
367 : :
368 : : static int hw_atl_utils_ver_match(u32 ver_expected, u32 ver_actual)
369 : : {
370 : : int err = 0;
371 : : const u32 dw_major_mask = 0xff000000U;
372 : : const u32 dw_minor_mask = 0x00ffffffU;
373 : :
374 [ # # # # : 0 : err = (dw_major_mask & (ver_expected ^ ver_actual)) ? -EOPNOTSUPP : 0;
# # ]
375 : : if (err < 0)
376 [ # # ]: 0 : goto err_exit;
377 : 0 : err = ((dw_minor_mask & ver_expected) > (dw_minor_mask & ver_actual)) ?
378 [ # # # # ]: 0 : -EOPNOTSUPP : 0;
379 : : err_exit:
380 : : return err;
381 : : }
382 : :
383 : 0 : static int hw_atl_utils_init_ucp(struct aq_hw_s *self)
384 : : {
385 : : int err = 0;
386 : :
387 [ # # ]: 0 : if (!aq_hw_read_reg(self, 0x370U)) {
388 : 0 : unsigned int rnd = (uint32_t)rte_rand();
389 : : unsigned int ucp_0x370 = 0U;
390 : :
391 : 0 : ucp_0x370 = 0x02020202U | (0xFEFEFEFEU & rnd);
392 : 0 : aq_hw_write_reg(self, HW_ATL_UCP_0X370_REG, ucp_0x370);
393 : : }
394 : :
395 : 0 : hw_atl_reg_glb_cpu_scratch_scp_set(self, 0x00000000U, 25U);
396 : :
397 : : /* check 10 times by 1ms */
398 [ # # # # : 0 : AQ_HW_WAIT_FOR(0U != (self->mbox_addr =
# # ]
399 : : aq_hw_read_reg(self, 0x360U)), 1000U, 10U);
400 [ # # # # : 0 : AQ_HW_WAIT_FOR(0U != (self->rpc_addr =
# # ]
401 : : aq_hw_read_reg(self, 0x334U)), 1000U, 100U);
402 : :
403 : 0 : return err;
404 : : }
405 : :
406 : : #define HW_ATL_RPC_CONTROL_ADR 0x0338U
407 : : #define HW_ATL_RPC_STATE_ADR 0x033CU
408 : :
409 : : struct aq_hw_atl_utils_fw_rpc_tid_s {
410 : : union {
411 : : u32 val;
412 : : struct {
413 : : u16 tid;
414 : : u16 len;
415 : : };
416 : : };
417 : : };
418 : :
419 : : #define hw_atl_utils_fw_rpc_init(_H_) hw_atl_utils_fw_rpc_wait(_H_, NULL)
420 : :
421 : 0 : int hw_atl_utils_fw_rpc_call(struct aq_hw_s *self, unsigned int rpc_size)
422 : : {
423 : : int err = 0;
424 : : struct aq_hw_atl_utils_fw_rpc_tid_s sw;
425 : :
426 [ # # ]: 0 : if (!IS_CHIP_FEATURE(MIPS)) {
427 : : err = -1;
428 : 0 : goto err_exit;
429 : : }
430 : 0 : err = hw_atl_utils_fw_upload_dwords(self, self->rpc_addr,
431 : 0 : (u32 *)(void *)&self->rpc,
432 : 0 : (rpc_size + sizeof(u32) -
433 : 0 : sizeof(u8)) / sizeof(u32));
434 [ # # ]: 0 : if (err < 0)
435 : 0 : goto err_exit;
436 : :
437 : 0 : sw.tid = 0xFFFFU & (++self->rpc_tid);
438 : 0 : sw.len = (u16)rpc_size;
439 : 0 : aq_hw_write_reg(self, HW_ATL_RPC_CONTROL_ADR, sw.val);
440 : :
441 : 0 : err_exit:
442 : 0 : return err;
443 : : }
444 : :
445 : 0 : int hw_atl_utils_fw_rpc_wait(struct aq_hw_s *self,
446 : : struct hw_aq_atl_utils_fw_rpc **rpc)
447 : : {
448 : : int err = 0;
449 : : struct aq_hw_atl_utils_fw_rpc_tid_s sw;
450 : : struct aq_hw_atl_utils_fw_rpc_tid_s fw;
451 : :
452 : : do {
453 : 0 : sw.val = aq_hw_read_reg(self, HW_ATL_RPC_CONTROL_ADR);
454 : :
455 : 0 : self->rpc_tid = sw.tid;
456 : :
457 [ # # # # : 0 : AQ_HW_WAIT_FOR(sw.tid ==
# # ]
458 : : (fw.val =
459 : : aq_hw_read_reg(self, HW_ATL_RPC_STATE_ADR),
460 : : fw.tid), 1000U, 100U);
461 : : if (err < 0)
462 : 0 : goto err_exit;
463 : :
464 [ # # ]: 0 : if (fw.len == 0xFFFFU) {
465 : 0 : err = hw_atl_utils_fw_rpc_call(self, sw.len);
466 [ # # ]: 0 : if (err < 0)
467 : 0 : goto err_exit;
468 : : }
469 [ # # # # ]: 0 : } while (sw.tid != fw.tid || 0xFFFFU == fw.len);
470 : :
471 [ # # ]: 0 : if (rpc) {
472 [ # # ]: 0 : if (fw.len) {
473 : : err =
474 : 0 : hw_atl_utils_fw_downld_dwords(self,
475 : : self->rpc_addr,
476 : : (u32 *)(void *)
477 : 0 : &self->rpc,
478 : 0 : (fw.len + sizeof(u32) -
479 : 0 : sizeof(u8)) /
480 : : sizeof(u32));
481 [ # # ]: 0 : if (err < 0)
482 : 0 : goto err_exit;
483 : : }
484 : :
485 : 0 : *rpc = &self->rpc;
486 : : }
487 : :
488 : 0 : err_exit:
489 : 0 : return err;
490 : : }
491 : :
492 : 0 : static int hw_atl_utils_mpi_create(struct aq_hw_s *self)
493 : : {
494 : : int err = 0;
495 : :
496 : 0 : err = hw_atl_utils_init_ucp(self);
497 [ # # ]: 0 : if (err < 0)
498 : 0 : goto err_exit;
499 : :
500 : 0 : err = hw_atl_utils_fw_rpc_init(self);
501 [ # # ]: 0 : if (err < 0)
502 : 0 : goto err_exit;
503 : :
504 : 0 : err_exit:
505 : 0 : return err;
506 : : }
507 : :
508 : 0 : int hw_atl_utils_mpi_read_mbox(struct aq_hw_s *self,
509 : : struct hw_aq_atl_utils_mbox_header *pmbox)
510 : : {
511 : 0 : return hw_atl_utils_fw_downld_dwords(self,
512 : : self->mbox_addr,
513 : : (u32 *)(void *)pmbox,
514 : : sizeof(*pmbox) / sizeof(u32));
515 : : }
516 : :
517 : 0 : void hw_atl_utils_mpi_read_stats(struct aq_hw_s *self,
518 : : struct hw_aq_atl_utils_mbox *pmbox)
519 : : {
520 : : int err = 0;
521 : :
522 : 0 : err = hw_atl_utils_fw_downld_dwords(self,
523 : : self->mbox_addr,
524 : : (u32 *)(void *)pmbox,
525 : : sizeof(*pmbox) / sizeof(u32));
526 [ # # ]: 0 : if (err < 0)
527 : 0 : goto err_exit;
528 : :
529 [ # # ]: 0 : if (IS_CHIP_FEATURE(REVISION_A0)) {
530 : : unsigned int mtu = 1514;
531 : 0 : pmbox->stats.ubrc = pmbox->stats.uprc * mtu;
532 : 0 : pmbox->stats.ubtc = pmbox->stats.uptc * mtu;
533 : : } else {
534 : 0 : pmbox->stats.dpc = hw_atl_rpb_rx_dma_drop_pkt_cnt_get(self);
535 : : }
536 : :
537 : 0 : err_exit:;
538 : 0 : }
539 : :
540 : : static
541 : 0 : int hw_atl_utils_mpi_set_speed(struct aq_hw_s *self, u32 speed)
542 : : {
543 : 0 : u32 val = aq_hw_read_reg(self, HW_ATL_MPI_CONTROL_ADR);
544 : :
545 : 0 : val = val & ~HW_ATL_MPI_SPEED_MSK;
546 : 0 : val |= speed << HW_ATL_MPI_SPEED_SHIFT;
547 : 0 : aq_hw_write_reg(self, HW_ATL_MPI_CONTROL_ADR, val);
548 : :
549 : 0 : return 0;
550 : : }
551 : :
552 : 0 : int hw_atl_utils_mpi_set_state(struct aq_hw_s *self,
553 : : enum hal_atl_utils_fw_state_e state)
554 : : {
555 : : int err = 0;
556 : : u32 transaction_id = 0;
557 : : struct hw_aq_atl_utils_mbox_header mbox;
558 : 0 : u32 val = aq_hw_read_reg(self, HW_ATL_MPI_CONTROL_ADR);
559 : :
560 [ # # ]: 0 : if (state == MPI_RESET) {
561 : 0 : hw_atl_utils_mpi_read_mbox(self, &mbox);
562 : :
563 : 0 : transaction_id = mbox.transaction_id;
564 : :
565 [ # # # # : 0 : AQ_HW_WAIT_FOR(transaction_id !=
# # ]
566 : : (hw_atl_utils_mpi_read_mbox(self, &mbox),
567 : : mbox.transaction_id),
568 : : 1000U, 100U);
569 : : if (err < 0)
570 : 0 : goto err_exit;
571 : : }
572 : : /* On interface DEINIT we disable DW (raise bit)
573 : : * Otherwise enable DW (clear bit)
574 : : */
575 [ # # ]: 0 : if (state == MPI_DEINIT || state == MPI_POWER)
576 : 0 : val |= HW_ATL_MPI_DIRTY_WAKE_MSK;
577 : : else
578 : 0 : val &= ~HW_ATL_MPI_DIRTY_WAKE_MSK;
579 : :
580 : : /* Set new state bits */
581 : 0 : val = val & ~HW_ATL_MPI_STATE_MSK;
582 : 0 : val |= state & HW_ATL_MPI_STATE_MSK;
583 : :
584 : 0 : aq_hw_write_reg(self, HW_ATL_MPI_CONTROL_ADR, val);
585 : 0 : err_exit:
586 : 0 : return err;
587 : : }
588 : :
589 : 0 : int hw_atl_utils_mpi_get_link_status(struct aq_hw_s *self)
590 : : {
591 : 0 : u32 cp0x036C = aq_hw_read_reg(self, HW_ATL_MPI_STATE_ADR);
592 : 0 : u32 link_speed_mask = cp0x036C >> HW_ATL_MPI_SPEED_SHIFT;
593 : : struct aq_hw_link_status_s *link_status = &self->aq_link_status;
594 : :
595 [ # # ]: 0 : if (!link_speed_mask) {
596 : 0 : link_status->mbps = 0U;
597 : : } else {
598 [ # # # # : 0 : switch (link_speed_mask) {
# # ]
599 : 0 : case HAL_ATLANTIC_RATE_10G:
600 : 0 : link_status->mbps = 10000U;
601 : 0 : break;
602 : :
603 : 0 : case HAL_ATLANTIC_RATE_5G:
604 : : case HAL_ATLANTIC_RATE_5GSR:
605 : 0 : link_status->mbps = 5000U;
606 : 0 : break;
607 : :
608 : 0 : case HAL_ATLANTIC_RATE_2GS:
609 : 0 : link_status->mbps = 2500U;
610 : 0 : break;
611 : :
612 : 0 : case HAL_ATLANTIC_RATE_1G:
613 : 0 : link_status->mbps = 1000U;
614 : 0 : break;
615 : :
616 : 0 : case HAL_ATLANTIC_RATE_100M:
617 : 0 : link_status->mbps = 100U;
618 : 0 : break;
619 : :
620 : : default:
621 : : return -EBUSY;
622 : : }
623 : : }
624 : :
625 : : return 0;
626 : : }
627 : :
628 : 0 : static int hw_atl_utils_get_mac_permanent(struct aq_hw_s *self,
629 : : u8 *mac)
630 : : {
631 : : int err = 0;
632 : : u32 h = 0U;
633 : : u32 l = 0U;
634 : : u32 mac_addr[2];
635 : :
636 [ # # ]: 0 : if (!aq_hw_read_reg(self, HW_ATL_UCP_0X370_REG)) {
637 : 0 : unsigned int rnd = (uint32_t)rte_rand();
638 : : unsigned int ucp_0x370 = 0;
639 : :
640 : : //get_random_bytes(&rnd, sizeof(unsigned int));
641 : :
642 : 0 : ucp_0x370 = 0x02020202 | (0xFEFEFEFE & rnd);
643 : 0 : aq_hw_write_reg(self, HW_ATL_UCP_0X370_REG, ucp_0x370);
644 : : }
645 : :
646 : 0 : err = hw_atl_utils_fw_downld_dwords(self,
647 : 0 : aq_hw_read_reg(self, 0x00000374U) +
648 : : (40U * 4U),
649 : : mac_addr,
650 : : ARRAY_SIZE(mac_addr));
651 [ # # ]: 0 : if (err < 0) {
652 : 0 : mac_addr[0] = 0U;
653 : 0 : mac_addr[1] = 0U;
654 : : err = 0;
655 : : } else {
656 : 0 : mac_addr[0] = rte_constant_bswap32(mac_addr[0]);
657 : 0 : mac_addr[1] = rte_constant_bswap32(mac_addr[1]);
658 : : }
659 : :
660 : : rte_ether_addr_copy((struct rte_ether_addr *)mac_addr,
661 : : (struct rte_ether_addr *)mac);
662 : :
663 [ # # # # ]: 0 : if ((mac[0] & 0x01U) || ((mac[0] | mac[1] | mac[2]) == 0x00U)) {
664 : : /* chip revision */
665 : 0 : l = 0xE3000000U
666 : 0 : | (0xFFFFU & aq_hw_read_reg(self, HW_ATL_UCP_0X370_REG))
667 : : | (0x00 << 16);
668 : : h = 0x8001300EU;
669 : :
670 : 0 : mac[5] = (u8)(0xFFU & l);
671 : 0 : l >>= 8;
672 : 0 : mac[4] = (u8)(0xFFU & l);
673 : : l >>= 8;
674 : 0 : mac[3] = (u8)(0xFFU & l);
675 : : l >>= 8;
676 : 0 : mac[2] = (u8)(0xFFU & l);
677 : 0 : mac[1] = (u8)(0xFFU & h);
678 : : h >>= 8;
679 : 0 : mac[0] = (u8)(0xFFU & h);
680 : : }
681 : :
682 : 0 : return err;
683 : : }
684 : :
685 : 0 : unsigned int hw_atl_utils_mbps_2_speed_index(unsigned int mbps)
686 : : {
687 : : unsigned int ret = 0U;
688 : :
689 [ # # # # : 0 : switch (mbps) {
# ]
690 : 0 : case 100U:
691 : : ret = 5U;
692 : 0 : break;
693 : :
694 : 0 : case 1000U:
695 : : ret = 4U;
696 : 0 : break;
697 : :
698 : 0 : case 2500U:
699 : : ret = 3U;
700 : 0 : break;
701 : :
702 : 0 : case 5000U:
703 : : ret = 1U;
704 : 0 : break;
705 : :
706 : : case 10000U:
707 : : ret = 0U;
708 : : break;
709 : :
710 : : default:
711 : : break;
712 : : }
713 : 0 : return ret;
714 : : }
715 : :
716 : 0 : void hw_atl_utils_hw_chip_features_init(struct aq_hw_s *self, u32 *p)
717 : : {
718 : : u32 chip_features = 0U;
719 : 0 : u32 val = hw_atl_reg_glb_mif_id_get(self);
720 : : u32 mif_rev = val & 0xFFU;
721 : :
722 [ # # ]: 0 : if ((0xFU & mif_rev) == 1U) {
723 : : chip_features |= HAL_ATLANTIC_UTILS_CHIP_REVISION_A0 |
724 : : HAL_ATLANTIC_UTILS_CHIP_MPI_AQ |
725 : : HAL_ATLANTIC_UTILS_CHIP_MIPS;
726 [ # # ]: 0 : } else if ((0xFU & mif_rev) == 2U) {
727 : : chip_features |= HAL_ATLANTIC_UTILS_CHIP_REVISION_B0 |
728 : : HAL_ATLANTIC_UTILS_CHIP_MPI_AQ |
729 : : HAL_ATLANTIC_UTILS_CHIP_MIPS |
730 : : HAL_ATLANTIC_UTILS_CHIP_TPO2 |
731 : : HAL_ATLANTIC_UTILS_CHIP_RPF2;
732 [ # # ]: 0 : } else if ((0xFU & mif_rev) == 0xAU) {
733 : : chip_features |= HAL_ATLANTIC_UTILS_CHIP_REVISION_B1 |
734 : : HAL_ATLANTIC_UTILS_CHIP_MPI_AQ |
735 : : HAL_ATLANTIC_UTILS_CHIP_MIPS |
736 : : HAL_ATLANTIC_UTILS_CHIP_TPO2 |
737 : : HAL_ATLANTIC_UTILS_CHIP_RPF2;
738 : : }
739 : :
740 : 0 : *p = chip_features;
741 : 0 : }
742 : :
743 : 0 : static int hw_atl_fw1x_deinit(struct aq_hw_s *self)
744 : : {
745 : 0 : hw_atl_utils_mpi_set_speed(self, 0);
746 : 0 : hw_atl_utils_mpi_set_state(self, MPI_DEINIT);
747 : 0 : return 0;
748 : : }
749 : :
750 : 0 : int hw_atl_utils_update_stats(struct aq_hw_s *self)
751 : : {
752 : : struct hw_aq_atl_utils_mbox mbox;
753 : :
754 : 0 : hw_atl_utils_mpi_read_stats(self, &mbox);
755 : :
756 : : #define AQ_SDELTA(_N_) (self->curr_stats._N_ += \
757 : : mbox.stats._N_ - self->last_stats._N_)
758 : :
759 : : if (1) {//self->aq_link_status.mbps) {
760 : 0 : AQ_SDELTA(uprc);
761 : 0 : AQ_SDELTA(mprc);
762 : 0 : AQ_SDELTA(bprc);
763 : 0 : AQ_SDELTA(erpt);
764 : :
765 : 0 : AQ_SDELTA(uptc);
766 : 0 : AQ_SDELTA(mptc);
767 : 0 : AQ_SDELTA(bptc);
768 : 0 : AQ_SDELTA(erpr);
769 : 0 : AQ_SDELTA(ubrc);
770 : 0 : AQ_SDELTA(ubtc);
771 : 0 : AQ_SDELTA(mbrc);
772 : 0 : AQ_SDELTA(mbtc);
773 : 0 : AQ_SDELTA(bbrc);
774 : 0 : AQ_SDELTA(bbtc);
775 : 0 : AQ_SDELTA(dpc);
776 : : }
777 : : #undef AQ_SDELTA
778 : 0 : self->curr_stats.dma_pkt_rc =
779 : 0 : hw_atl_stats_rx_dma_good_pkt_counterlsw_get(self) +
780 : 0 : ((u64)hw_atl_stats_rx_dma_good_pkt_countermsw_get(self) << 32);
781 : 0 : self->curr_stats.dma_pkt_tc =
782 : 0 : hw_atl_stats_tx_dma_good_pkt_counterlsw_get(self) +
783 : 0 : ((u64)hw_atl_stats_tx_dma_good_pkt_countermsw_get(self) << 32);
784 : 0 : self->curr_stats.dma_oct_rc =
785 : 0 : hw_atl_stats_rx_dma_good_octet_counterlsw_get(self) +
786 : 0 : ((u64)hw_atl_stats_rx_dma_good_octet_countermsw_get(self) << 32);
787 : 0 : self->curr_stats.dma_oct_tc =
788 : 0 : hw_atl_stats_tx_dma_good_octet_counterlsw_get(self) +
789 : 0 : ((u64)hw_atl_stats_tx_dma_good_octet_countermsw_get(self) << 32);
790 : :
791 : 0 : self->curr_stats.dpc = hw_atl_rpb_rx_dma_drop_pkt_cnt_get(self);
792 : :
793 : 0 : memcpy(&self->last_stats, &mbox.stats, sizeof(mbox.stats));
794 : :
795 : 0 : return 0;
796 : : }
797 : :
798 : 0 : struct aq_stats_s *hw_atl_utils_get_hw_stats(struct aq_hw_s *self)
799 : : {
800 : 0 : return &self->curr_stats;
801 : : }
802 : :
803 : : static const u32 hw_atl_utils_hw_mac_regs[] = {
804 : : 0x00005580U, 0x00005590U, 0x000055B0U, 0x000055B4U,
805 : : 0x000055C0U, 0x00005B00U, 0x00005B04U, 0x00005B08U,
806 : : 0x00005B0CU, 0x00005B10U, 0x00005B14U, 0x00005B18U,
807 : : 0x00005B1CU, 0x00005B20U, 0x00005B24U, 0x00005B28U,
808 : : 0x00005B2CU, 0x00005B30U, 0x00005B34U, 0x00005B38U,
809 : : 0x00005B3CU, 0x00005B40U, 0x00005B44U, 0x00005B48U,
810 : : 0x00005B4CU, 0x00005B50U, 0x00005B54U, 0x00005B58U,
811 : : 0x00005B5CU, 0x00005B60U, 0x00005B64U, 0x00005B68U,
812 : : 0x00005B6CU, 0x00005B70U, 0x00005B74U, 0x00005B78U,
813 : : 0x00005B7CU, 0x00007C00U, 0x00007C04U, 0x00007C08U,
814 : : 0x00007C0CU, 0x00007C10U, 0x00007C14U, 0x00007C18U,
815 : : 0x00007C1CU, 0x00007C20U, 0x00007C40U, 0x00007C44U,
816 : : 0x00007C48U, 0x00007C4CU, 0x00007C50U, 0x00007C54U,
817 : : 0x00007C58U, 0x00007C5CU, 0x00007C60U, 0x00007C80U,
818 : : 0x00007C84U, 0x00007C88U, 0x00007C8CU, 0x00007C90U,
819 : : 0x00007C94U, 0x00007C98U, 0x00007C9CU, 0x00007CA0U,
820 : : 0x00007CC0U, 0x00007CC4U, 0x00007CC8U, 0x00007CCCU,
821 : : 0x00007CD0U, 0x00007CD4U, 0x00007CD8U, 0x00007CDCU,
822 : : 0x00007CE0U, 0x00000300U, 0x00000304U, 0x00000308U,
823 : : 0x0000030cU, 0x00000310U, 0x00000314U, 0x00000318U,
824 : : 0x0000031cU, 0x00000360U, 0x00000364U, 0x00000368U,
825 : : 0x0000036cU, 0x00000370U, 0x00000374U, 0x00006900U,
826 : : };
827 : :
828 : 0 : unsigned int hw_atl_utils_hw_get_reg_length(void)
829 : : {
830 : 0 : return ARRAY_SIZE(hw_atl_utils_hw_mac_regs);
831 : : }
832 : :
833 : 0 : int hw_atl_utils_hw_get_regs(struct aq_hw_s *self,
834 : : u32 *regs_buff)
835 : : {
836 : : unsigned int i = 0U;
837 : 0 : unsigned int mac_regs_count = hw_atl_utils_hw_get_reg_length();
838 : :
839 [ # # ]: 0 : for (i = 0; i < mac_regs_count; i++)
840 : 0 : regs_buff[i] = aq_hw_read_reg(self,
841 : 0 : hw_atl_utils_hw_mac_regs[i]);
842 : 0 : return 0;
843 : : }
844 : :
845 : 0 : int hw_atl_utils_get_fw_version(struct aq_hw_s *self, u32 *fw_version)
846 : : {
847 : 0 : *fw_version = aq_hw_read_reg(self, 0x18U);
848 : 0 : return 0;
849 : : }
850 : :
851 : 0 : static int aq_fw1x_set_wol(struct aq_hw_s *self, bool wol_enabled, u8 *mac)
852 : : {
853 : 0 : struct hw_aq_atl_utils_fw_rpc *prpc = NULL;
854 : : unsigned int rpc_size = 0U;
855 : : int err = 0;
856 : :
857 : 0 : err = hw_atl_utils_fw_rpc_wait(self, &prpc);
858 [ # # ]: 0 : if (err < 0)
859 : 0 : goto err_exit;
860 : :
861 [ # # ]: 0 : memset(prpc, 0, sizeof(*prpc));
862 : :
863 [ # # ]: 0 : if (wol_enabled) {
864 : : rpc_size = sizeof(prpc->msg_id) + sizeof(prpc->msg_wol);
865 : :
866 : 0 : prpc->msg_id = HAL_ATLANTIC_UTILS_FW_MSG_WOL_ADD;
867 : 0 : prpc->msg_wol.priority = 0x10000000; /* normal priority */
868 : 0 : prpc->msg_wol.pattern_id = 1U;
869 : 0 : prpc->msg_wol.wol_packet_type = 2U; /* Magic Packet */
870 : :
871 : : rte_ether_addr_copy((struct rte_ether_addr *)mac,
872 : : (struct rte_ether_addr *)&prpc->msg_wol.wol_pattern);
873 : : } else {
874 : : rpc_size = sizeof(prpc->msg_id) + sizeof(prpc->msg_del_id);
875 : :
876 : 0 : prpc->msg_id = HAL_ATLANTIC_UTILS_FW_MSG_WOL_DEL;
877 : 0 : prpc->msg_wol.pattern_id = 1U;
878 : : }
879 : :
880 : 0 : err = hw_atl_utils_fw_rpc_call(self, rpc_size);
881 : :
882 : 0 : err_exit:
883 : 0 : return err;
884 : : }
885 : :
886 : : static
887 : 0 : int aq_fw1x_set_power(struct aq_hw_s *self,
888 : : unsigned int power_state __rte_unused,
889 : : u8 *mac)
890 : : {
891 : 0 : struct hw_aq_atl_utils_fw_rpc *prpc = NULL;
892 : : unsigned int rpc_size = 0U;
893 : : int err = 0;
894 [ # # ]: 0 : if (self->aq_nic_cfg->wol & AQ_NIC_WOL_ENABLED) {
895 : 0 : err = aq_fw1x_set_wol(self, 1, mac);
896 : :
897 [ # # ]: 0 : if (err < 0)
898 : 0 : goto err_exit;
899 : :
900 : : rpc_size = sizeof(prpc->msg_id) +
901 : : sizeof(prpc->msg_enable_wakeup);
902 : :
903 : 0 : err = hw_atl_utils_fw_rpc_wait(self, &prpc);
904 : :
905 [ # # ]: 0 : if (err < 0)
906 : 0 : goto err_exit;
907 : :
908 : 0 : memset(prpc, 0, rpc_size);
909 : :
910 : 0 : prpc->msg_id = HAL_ATLANTIC_UTILS_FW_MSG_ENABLE_WAKEUP;
911 : 0 : prpc->msg_enable_wakeup.pattern_mask = 0x00000002;
912 : :
913 : 0 : err = hw_atl_utils_fw_rpc_call(self, rpc_size);
914 [ # # ]: 0 : if (err < 0)
915 : 0 : goto err_exit;
916 : : }
917 : :
918 : 0 : hw_atl_utils_mpi_set_speed(self, 0);
919 : 0 : hw_atl_utils_mpi_set_state(self, MPI_POWER);
920 : 0 : err_exit:
921 : 0 : return err;
922 : : }
923 : :
924 : :
925 : :
926 : : const struct aq_fw_ops aq_fw_1x_ops = {
927 : : .init = hw_atl_utils_mpi_create,
928 : : .deinit = hw_atl_fw1x_deinit,
929 : : .reset = NULL,
930 : : .get_mac_permanent = hw_atl_utils_get_mac_permanent,
931 : : .set_link_speed = hw_atl_utils_mpi_set_speed,
932 : : .set_state = hw_atl_utils_mpi_set_state,
933 : : .update_link_status = hw_atl_utils_mpi_get_link_status,
934 : : .update_stats = hw_atl_utils_update_stats,
935 : : .set_power = aq_fw1x_set_power,
936 : : .get_temp = NULL,
937 : : .get_cable_len = NULL,
938 : : .set_eee_rate = NULL,
939 : : .get_eee_rate = NULL,
940 : : .set_flow_control = NULL,
941 : : .led_control = NULL,
942 : : .get_eeprom = NULL,
943 : : .set_eeprom = NULL,
944 : : };
|