Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2018-2021 HiSilicon Limited.
3 : : */
4 : :
5 : : #include <ethdev_pci.h>
6 : : #include <rte_io.h>
7 : :
8 : : #include "hns3_ethdev.h"
9 : : #include "hns3_logs.h"
10 : : #include "hns3_rxtx.h"
11 : : #include "hns3_regs.h"
12 : :
13 : : #define MAX_SEPARATE_NUM 4
14 : : #define SEPARATOR_VALUE 0xFFFFFFFF
15 : : #define REG_NUM_PER_LINE 4
16 : : #define REG_LEN_PER_LINE (REG_NUM_PER_LINE * sizeof(uint32_t))
17 : :
18 : : static int hns3_get_dfx_reg_line(struct hns3_hw *hw, uint32_t *lines);
19 : :
20 : : static const uint32_t cmdq_reg_addrs[] = {HNS3_CMDQ_TX_ADDR_L_REG,
21 : : HNS3_CMDQ_TX_ADDR_H_REG,
22 : : HNS3_CMDQ_TX_DEPTH_REG,
23 : : HNS3_CMDQ_TX_TAIL_REG,
24 : : HNS3_CMDQ_TX_HEAD_REG,
25 : : HNS3_CMDQ_RX_ADDR_L_REG,
26 : : HNS3_CMDQ_RX_ADDR_H_REG,
27 : : HNS3_CMDQ_RX_DEPTH_REG,
28 : : HNS3_CMDQ_RX_TAIL_REG,
29 : : HNS3_CMDQ_RX_HEAD_REG,
30 : : HNS3_VECTOR0_CMDQ_SRC_REG,
31 : : HNS3_CMDQ_INTR_STS_REG,
32 : : HNS3_CMDQ_INTR_EN_REG,
33 : : HNS3_CMDQ_INTR_GEN_REG};
34 : :
35 : : static const uint32_t common_reg_addrs[] = {HNS3_MISC_VECTOR_REG_BASE,
36 : : HNS3_VECTOR0_OTER_EN_REG,
37 : : HNS3_MISC_RESET_STS_REG,
38 : : HNS3_VECTOR0_OTHER_INT_STS_REG,
39 : : HNS3_GLOBAL_RESET_REG,
40 : : HNS3_FUN_RST_ING,
41 : : HNS3_GRO_EN_REG};
42 : :
43 : : static const uint32_t common_vf_reg_addrs[] = {HNS3_MISC_VECTOR_REG_BASE,
44 : : HNS3_FUN_RST_ING,
45 : : HNS3_GRO_EN_REG};
46 : :
47 : : static const uint32_t ring_reg_addrs[] = {HNS3_RING_RX_BASEADDR_L_REG,
48 : : HNS3_RING_RX_BASEADDR_H_REG,
49 : : HNS3_RING_RX_BD_NUM_REG,
50 : : HNS3_RING_RX_BD_LEN_REG,
51 : : HNS3_RING_RX_EN_REG,
52 : : HNS3_RING_RX_MERGE_EN_REG,
53 : : HNS3_RING_RX_TAIL_REG,
54 : : HNS3_RING_RX_HEAD_REG,
55 : : HNS3_RING_RX_FBDNUM_REG,
56 : : HNS3_RING_RX_OFFSET_REG,
57 : : HNS3_RING_RX_FBD_OFFSET_REG,
58 : : HNS3_RING_RX_STASH_REG,
59 : : HNS3_RING_RX_BD_ERR_REG,
60 : : HNS3_RING_TX_BASEADDR_L_REG,
61 : : HNS3_RING_TX_BASEADDR_H_REG,
62 : : HNS3_RING_TX_BD_NUM_REG,
63 : : HNS3_RING_TX_EN_REG,
64 : : HNS3_RING_TX_PRIORITY_REG,
65 : : HNS3_RING_TX_TC_REG,
66 : : HNS3_RING_TX_MERGE_EN_REG,
67 : : HNS3_RING_TX_TAIL_REG,
68 : : HNS3_RING_TX_HEAD_REG,
69 : : HNS3_RING_TX_FBDNUM_REG,
70 : : HNS3_RING_TX_OFFSET_REG,
71 : : HNS3_RING_TX_EBD_NUM_REG,
72 : : HNS3_RING_TX_EBD_OFFSET_REG,
73 : : HNS3_RING_TX_BD_ERR_REG,
74 : : HNS3_RING_EN_REG};
75 : :
76 : : static const uint32_t tqp_intr_reg_addrs[] = {HNS3_TQP_INTR_CTRL_REG,
77 : : HNS3_TQP_INTR_GL0_REG,
78 : : HNS3_TQP_INTR_GL1_REG,
79 : : HNS3_TQP_INTR_GL2_REG,
80 : : HNS3_TQP_INTR_RL_REG};
81 : :
82 : : static const uint32_t hns3_dfx_reg_opcode_list[] = {
83 : : HNS3_OPC_DFX_BIOS_COMMON_REG,
84 : : HNS3_OPC_DFX_SSU_REG_0,
85 : : HNS3_OPC_DFX_SSU_REG_1,
86 : : HNS3_OPC_DFX_IGU_EGU_REG,
87 : : HNS3_OPC_DFX_RPU_REG_0,
88 : : HNS3_OPC_DFX_RPU_REG_1,
89 : : HNS3_OPC_DFX_NCSI_REG,
90 : : HNS3_OPC_DFX_RTC_REG,
91 : : HNS3_OPC_DFX_PPP_REG,
92 : : HNS3_OPC_DFX_RCB_REG,
93 : : HNS3_OPC_DFX_TQP_REG,
94 : : HNS3_OPC_DFX_SSU_REG_2
95 : : };
96 : :
97 : : static int
98 : 0 : hns3_get_regs_num(struct hns3_hw *hw, uint32_t *regs_num_32_bit,
99 : : uint32_t *regs_num_64_bit)
100 : : {
101 : : struct hns3_cmd_desc desc;
102 : : int ret;
103 : :
104 : 0 : hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_QUERY_REG_NUM, true);
105 : 0 : ret = hns3_cmd_send(hw, &desc, 1);
106 [ # # ]: 0 : if (ret) {
107 : 0 : hns3_err(hw, "Query register number cmd failed, ret = %d",
108 : : ret);
109 : 0 : return ret;
110 : : }
111 : :
112 : 0 : *regs_num_32_bit = rte_le_to_cpu_32(desc.data[0]);
113 : 0 : *regs_num_64_bit = rte_le_to_cpu_32(desc.data[1]);
114 : :
115 : 0 : return 0;
116 : : }
117 : :
118 : : static int
119 : 0 : hns3_get_regs_length(struct hns3_hw *hw, uint32_t *length)
120 : : {
121 : : struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw);
122 : : uint32_t cmdq_lines, common_lines, ring_lines, tqp_intr_lines;
123 : : uint32_t regs_num_32_bit, regs_num_64_bit;
124 : : uint32_t dfx_reg_lines;
125 : : uint32_t len;
126 : : int ret;
127 : :
128 : : cmdq_lines = sizeof(cmdq_reg_addrs) / REG_LEN_PER_LINE + 1;
129 [ # # ]: 0 : if (hns->is_vf)
130 : : common_lines =
131 : : sizeof(common_vf_reg_addrs) / REG_LEN_PER_LINE + 1;
132 : : else
133 : : common_lines = sizeof(common_reg_addrs) / REG_LEN_PER_LINE + 1;
134 : : ring_lines = sizeof(ring_reg_addrs) / REG_LEN_PER_LINE + 1;
135 : : tqp_intr_lines = sizeof(tqp_intr_reg_addrs) / REG_LEN_PER_LINE + 1;
136 : :
137 : 0 : len = (cmdq_lines + common_lines + ring_lines * hw->tqps_num +
138 : 0 : tqp_intr_lines * hw->num_msi) * REG_NUM_PER_LINE;
139 : :
140 [ # # ]: 0 : if (!hns->is_vf) {
141 : 0 : ret = hns3_get_regs_num(hw, ®s_num_32_bit, ®s_num_64_bit);
142 [ # # ]: 0 : if (ret) {
143 : 0 : hns3_err(hw, "fail to get the number of registers, "
144 : : "ret = %d.", ret);
145 : 0 : return ret;
146 : : }
147 : 0 : dfx_reg_lines = regs_num_32_bit * sizeof(uint32_t) /
148 : 0 : REG_LEN_PER_LINE + 1;
149 : 0 : dfx_reg_lines += regs_num_64_bit * sizeof(uint64_t) /
150 : : REG_LEN_PER_LINE + 1;
151 : :
152 : 0 : ret = hns3_get_dfx_reg_line(hw, &dfx_reg_lines);
153 [ # # ]: 0 : if (ret) {
154 : 0 : hns3_err(hw, "fail to get the number of dfx registers, "
155 : : "ret = %d.", ret);
156 : 0 : return ret;
157 : : }
158 : 0 : len += dfx_reg_lines * REG_NUM_PER_LINE;
159 : : }
160 : :
161 : 0 : *length = len;
162 : 0 : return 0;
163 : : }
164 : :
165 : : static int
166 : 0 : hns3_get_32_bit_regs(struct hns3_hw *hw, uint32_t regs_num, void *data)
167 : : {
168 : : #define HNS3_32_BIT_REG_RTN_DATANUM 8
169 : : #define HNS3_32_BIT_DESC_NODATA_LEN 2
170 : : struct hns3_cmd_desc *desc;
171 : : uint32_t *reg_val = data;
172 : : uint32_t *desc_data;
173 : : int cmd_num;
174 : : int i, k, n;
175 : : int ret;
176 : :
177 [ # # ]: 0 : if (regs_num == 0)
178 : : return 0;
179 : :
180 : 0 : cmd_num = DIV_ROUND_UP(regs_num + HNS3_32_BIT_DESC_NODATA_LEN,
181 : : HNS3_32_BIT_REG_RTN_DATANUM);
182 : 0 : desc = rte_zmalloc("hns3-32bit-regs",
183 : : sizeof(struct hns3_cmd_desc) * cmd_num, 0);
184 [ # # ]: 0 : if (desc == NULL) {
185 : 0 : hns3_err(hw, "Failed to allocate %zx bytes needed to "
186 : : "store 32bit regs",
187 : : sizeof(struct hns3_cmd_desc) * cmd_num);
188 : 0 : return -ENOMEM;
189 : : }
190 : :
191 : 0 : hns3_cmd_setup_basic_desc(&desc[0], HNS3_OPC_QUERY_32_BIT_REG, true);
192 : 0 : ret = hns3_cmd_send(hw, desc, cmd_num);
193 [ # # ]: 0 : if (ret) {
194 : 0 : hns3_err(hw, "Query 32 bit register cmd failed, ret = %d",
195 : : ret);
196 : 0 : rte_free(desc);
197 : 0 : return ret;
198 : : }
199 : :
200 [ # # ]: 0 : for (i = 0; i < cmd_num; i++) {
201 [ # # ]: 0 : if (i == 0) {
202 : 0 : desc_data = &desc[i].data[0];
203 : : n = HNS3_32_BIT_REG_RTN_DATANUM -
204 : : HNS3_32_BIT_DESC_NODATA_LEN;
205 : : } else {
206 : 0 : desc_data = (uint32_t *)(&desc[i]);
207 : : n = HNS3_32_BIT_REG_RTN_DATANUM;
208 : : }
209 [ # # ]: 0 : for (k = 0; k < n; k++) {
210 : 0 : *reg_val++ = rte_le_to_cpu_32(*desc_data++);
211 : :
212 : 0 : regs_num--;
213 [ # # ]: 0 : if (regs_num == 0)
214 : : break;
215 : : }
216 : : }
217 : :
218 : 0 : rte_free(desc);
219 : 0 : return 0;
220 : : }
221 : :
222 : : static int
223 : 0 : hns3_get_64_bit_regs(struct hns3_hw *hw, uint32_t regs_num, void *data)
224 : : {
225 : : #define HNS3_64_BIT_REG_RTN_DATANUM 4
226 : : #define HNS3_64_BIT_DESC_NODATA_LEN 1
227 : : struct hns3_cmd_desc *desc;
228 : : uint64_t *reg_val = data;
229 : : uint64_t *desc_data;
230 : : int cmd_num;
231 : : int i, k, n;
232 : : int ret;
233 : :
234 [ # # ]: 0 : if (regs_num == 0)
235 : : return 0;
236 : :
237 : 0 : cmd_num = DIV_ROUND_UP(regs_num + HNS3_64_BIT_DESC_NODATA_LEN,
238 : : HNS3_64_BIT_REG_RTN_DATANUM);
239 : 0 : desc = rte_zmalloc("hns3-64bit-regs",
240 : : sizeof(struct hns3_cmd_desc) * cmd_num, 0);
241 [ # # ]: 0 : if (desc == NULL) {
242 : 0 : hns3_err(hw, "Failed to allocate %zx bytes needed to "
243 : : "store 64bit regs",
244 : : sizeof(struct hns3_cmd_desc) * cmd_num);
245 : 0 : return -ENOMEM;
246 : : }
247 : :
248 : 0 : hns3_cmd_setup_basic_desc(&desc[0], HNS3_OPC_QUERY_64_BIT_REG, true);
249 : 0 : ret = hns3_cmd_send(hw, desc, cmd_num);
250 [ # # ]: 0 : if (ret) {
251 : 0 : hns3_err(hw, "Query 64 bit register cmd failed, ret = %d",
252 : : ret);
253 : 0 : rte_free(desc);
254 : 0 : return ret;
255 : : }
256 : :
257 [ # # ]: 0 : for (i = 0; i < cmd_num; i++) {
258 [ # # ]: 0 : if (i == 0) {
259 : 0 : desc_data = (uint64_t *)(&desc[i].data[0]);
260 : : n = HNS3_64_BIT_REG_RTN_DATANUM -
261 : : HNS3_64_BIT_DESC_NODATA_LEN;
262 : : } else {
263 : 0 : desc_data = (uint64_t *)(&desc[i]);
264 : : n = HNS3_64_BIT_REG_RTN_DATANUM;
265 : : }
266 [ # # ]: 0 : for (k = 0; k < n; k++) {
267 : 0 : *reg_val++ = rte_le_to_cpu_64(*desc_data++);
268 : :
269 : 0 : regs_num--;
270 [ # # ]: 0 : if (!regs_num)
271 : : break;
272 : : }
273 : : }
274 : :
275 : 0 : rte_free(desc);
276 : 0 : return 0;
277 : : }
278 : :
279 : : static int
280 : : hns3_insert_reg_separator(int reg_num, uint32_t *data)
281 : : {
282 : : int separator_num;
283 : : int i;
284 : :
285 : 0 : separator_num = MAX_SEPARATE_NUM - reg_num % REG_NUM_PER_LINE;
286 [ # # # # : 0 : for (i = 0; i < separator_num; i++)
# # # # #
# # # #
# ]
287 : 0 : *data++ = SEPARATOR_VALUE;
288 : : return separator_num;
289 : : }
290 : :
291 : : static int
292 : 0 : hns3_direct_access_regs(struct hns3_hw *hw, uint32_t *data)
293 : : {
294 : : struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw);
295 : : uint32_t *origin_data_ptr = data;
296 : : uint32_t reg_offset;
297 : : size_t reg_num;
298 : : uint16_t j;
299 : : size_t i;
300 : :
301 : : /* fetching per-PF registers values from PF PCIe register space */
302 : : reg_num = sizeof(cmdq_reg_addrs) / sizeof(uint32_t);
303 [ # # ]: 0 : for (i = 0; i < reg_num; i++)
304 : 0 : *data++ = hns3_read_dev(hw, cmdq_reg_addrs[i]);
305 : 0 : data += hns3_insert_reg_separator(reg_num, data);
306 : :
307 [ # # ]: 0 : if (hns->is_vf)
308 : : reg_num = sizeof(common_vf_reg_addrs) / sizeof(uint32_t);
309 : : else
310 : : reg_num = sizeof(common_reg_addrs) / sizeof(uint32_t);
311 [ # # ]: 0 : for (i = 0; i < reg_num; i++)
312 [ # # ]: 0 : if (hns->is_vf)
313 : 0 : *data++ = hns3_read_dev(hw, common_vf_reg_addrs[i]);
314 : : else
315 : 0 : *data++ = hns3_read_dev(hw, common_reg_addrs[i]);
316 : 0 : data += hns3_insert_reg_separator(reg_num, data);
317 : :
318 : : reg_num = sizeof(ring_reg_addrs) / sizeof(uint32_t);
319 [ # # ]: 0 : for (j = 0; j < hw->tqps_num; j++) {
320 : 0 : reg_offset = hns3_get_tqp_reg_offset(j);
321 [ # # ]: 0 : for (i = 0; i < reg_num; i++)
322 : 0 : *data++ = hns3_read_dev(hw,
323 : : ring_reg_addrs[i] + reg_offset);
324 : 0 : data += hns3_insert_reg_separator(reg_num, data);
325 : : }
326 : :
327 : : reg_num = sizeof(tqp_intr_reg_addrs) / sizeof(uint32_t);
328 [ # # ]: 0 : for (j = 0; j < hw->intr_tqps_num; j++) {
329 : 0 : reg_offset = hns3_get_tqp_intr_reg_offset(j);
330 [ # # ]: 0 : for (i = 0; i < reg_num; i++)
331 : 0 : *data++ = hns3_read_dev(hw, tqp_intr_reg_addrs[i] +
332 : : reg_offset);
333 : 0 : data += hns3_insert_reg_separator(reg_num, data);
334 : : }
335 : 0 : return data - origin_data_ptr;
336 : : }
337 : :
338 : : static int
339 : 0 : hns3_get_dfx_reg_bd_num(struct hns3_hw *hw, uint32_t *bd_num_list,
340 : : uint32_t list_size)
341 : : {
342 : : #define HNS3_GET_DFX_REG_BD_NUM_SIZE 4
343 : : struct hns3_cmd_desc desc[HNS3_GET_DFX_REG_BD_NUM_SIZE];
344 : : uint32_t index, desc_index;
345 : : uint32_t bd_num;
346 : : uint32_t i;
347 : : int ret;
348 : :
349 [ # # ]: 0 : for (i = 0; i < HNS3_GET_DFX_REG_BD_NUM_SIZE - 1; i++) {
350 : 0 : hns3_cmd_setup_basic_desc(&desc[i], HNS3_OPC_DFX_BD_NUM, true);
351 : 0 : desc[i].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT);
352 : : }
353 : : /* The last BD does not need a next flag */
354 : 0 : hns3_cmd_setup_basic_desc(&desc[i], HNS3_OPC_DFX_BD_NUM, true);
355 : :
356 : 0 : ret = hns3_cmd_send(hw, desc, HNS3_GET_DFX_REG_BD_NUM_SIZE);
357 [ # # ]: 0 : if (ret) {
358 : 0 : hns3_err(hw, "fail to get dfx bd num, ret = %d.\n", ret);
359 : 0 : return ret;
360 : : }
361 : :
362 : : /* The first data in the first BD is a reserved field */
363 [ # # ]: 0 : for (i = 1; i <= list_size; i++) {
364 : 0 : desc_index = i / HNS3_CMD_DESC_DATA_NUM;
365 : 0 : index = i % HNS3_CMD_DESC_DATA_NUM;
366 : 0 : bd_num = rte_le_to_cpu_32(desc[desc_index].data[index]);
367 : 0 : bd_num_list[i - 1] = bd_num;
368 : : }
369 : :
370 : : return 0;
371 : : }
372 : :
373 : : static int
374 : 0 : hns3_dfx_reg_cmd_send(struct hns3_hw *hw, struct hns3_cmd_desc *desc,
375 : : int bd_num, uint32_t opcode)
376 : : {
377 : : int ret;
378 : : int i;
379 : :
380 [ # # ]: 0 : for (i = 0; i < bd_num - 1; i++) {
381 : 0 : hns3_cmd_setup_basic_desc(&desc[i], opcode, true);
382 : 0 : desc[i].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT);
383 : : }
384 : : /* The last BD does not need a next flag */
385 : 0 : hns3_cmd_setup_basic_desc(&desc[i], opcode, true);
386 : :
387 : 0 : ret = hns3_cmd_send(hw, desc, bd_num);
388 [ # # ]: 0 : if (ret)
389 : 0 : hns3_err(hw, "fail to query dfx registers, opcode = 0x%04X, "
390 : : "ret = %d.\n", opcode, ret);
391 : :
392 : 0 : return ret;
393 : : }
394 : :
395 : : static int
396 : 0 : hns3_dfx_reg_fetch_data(struct hns3_cmd_desc *desc, int bd_num, uint32_t *reg)
397 : : {
398 : : int desc_index;
399 : : int reg_num;
400 : : int index;
401 : : int i;
402 : :
403 : 0 : reg_num = bd_num * HNS3_CMD_DESC_DATA_NUM;
404 [ # # ]: 0 : for (i = 0; i < reg_num; i++) {
405 : 0 : desc_index = i / HNS3_CMD_DESC_DATA_NUM;
406 : 0 : index = i % HNS3_CMD_DESC_DATA_NUM;
407 : 0 : *reg++ = desc[desc_index].data[index];
408 : : }
409 : 0 : reg_num += hns3_insert_reg_separator(reg_num, reg);
410 : :
411 : 0 : return reg_num;
412 : : }
413 : :
414 : : static int
415 : 0 : hns3_get_dfx_reg_line(struct hns3_hw *hw, uint32_t *lines)
416 : 0 : {
417 : : int opcode_num = RTE_DIM(hns3_dfx_reg_opcode_list);
418 : 0 : uint32_t bd_num_list[opcode_num];
419 : : uint32_t bd_num, data_len;
420 : : int ret;
421 : : int i;
422 : :
423 : 0 : ret = hns3_get_dfx_reg_bd_num(hw, bd_num_list, opcode_num);
424 [ # # ]: 0 : if (ret)
425 : : return ret;
426 : :
427 [ # # ]: 0 : for (i = 0; i < opcode_num; i++) {
428 : 0 : bd_num = bd_num_list[i];
429 : 0 : data_len = bd_num * HNS3_CMD_DESC_DATA_NUM * sizeof(uint32_t);
430 : 0 : *lines += data_len / REG_LEN_PER_LINE + 1;
431 : : }
432 : :
433 : : return 0;
434 : : }
435 : :
436 : : static int
437 : 0 : hns3_get_dfx_regs(struct hns3_hw *hw, void **data)
438 : 0 : {
439 : : int opcode_num = RTE_DIM(hns3_dfx_reg_opcode_list);
440 : : uint32_t max_bd_num, bd_num, opcode;
441 : 0 : uint32_t bd_num_list[opcode_num];
442 : : struct hns3_cmd_desc *cmd_descs;
443 : 0 : uint32_t *reg_val = (uint32_t *)*data;
444 : : int ret;
445 : : int i;
446 : :
447 : 0 : ret = hns3_get_dfx_reg_bd_num(hw, bd_num_list, opcode_num);
448 [ # # ]: 0 : if (ret)
449 : : return ret;
450 : :
451 : : max_bd_num = 0;
452 [ # # ]: 0 : for (i = 0; i < opcode_num; i++)
453 : 0 : max_bd_num = RTE_MAX(bd_num_list[i], max_bd_num);
454 : :
455 : 0 : cmd_descs = rte_zmalloc(NULL, sizeof(*cmd_descs) * max_bd_num, 0);
456 [ # # ]: 0 : if (cmd_descs == NULL)
457 : : return -ENOMEM;
458 : :
459 [ # # ]: 0 : for (i = 0; i < opcode_num; i++) {
460 : 0 : opcode = hns3_dfx_reg_opcode_list[i];
461 : 0 : bd_num = bd_num_list[i];
462 [ # # ]: 0 : if (bd_num == 0)
463 : 0 : continue;
464 : 0 : ret = hns3_dfx_reg_cmd_send(hw, cmd_descs, bd_num, opcode);
465 [ # # ]: 0 : if (ret)
466 : : break;
467 : 0 : reg_val += hns3_dfx_reg_fetch_data(cmd_descs, bd_num, reg_val);
468 : : }
469 : 0 : rte_free(cmd_descs);
470 : 0 : *data = (void *)reg_val;
471 : :
472 : 0 : return ret;
473 : : }
474 : :
475 : : int
476 : 0 : hns3_get_regs(struct rte_eth_dev *eth_dev, struct rte_dev_reg_info *regs)
477 : : {
478 : : #define HNS3_64_BIT_REG_SIZE (sizeof(uint64_t) / sizeof(uint32_t))
479 : 0 : struct hns3_adapter *hns = eth_dev->data->dev_private;
480 : 0 : struct hns3_hw *hw = &hns->hw;
481 : : uint32_t regs_num_32_bit;
482 : : uint32_t regs_num_64_bit;
483 : : uint32_t length;
484 : : uint32_t *data;
485 : : int ret;
486 : :
487 : 0 : ret = hns3_get_regs_length(hw, &length);
488 [ # # ]: 0 : if (ret)
489 : : return ret;
490 : :
491 : 0 : data = regs->data;
492 [ # # ]: 0 : if (data == NULL) {
493 : 0 : regs->length = length;
494 : 0 : regs->width = sizeof(uint32_t);
495 : 0 : return 0;
496 : : }
497 : :
498 : : /* Only full register dump is supported */
499 [ # # # # ]: 0 : if (regs->length && regs->length != length)
500 : : return -ENOTSUP;
501 : :
502 : 0 : regs->version = hw->fw_version;
503 : :
504 : : /* fetching per-PF registers values from PF PCIe register space */
505 : 0 : data += hns3_direct_access_regs(hw, data);
506 : :
507 [ # # ]: 0 : if (hns->is_vf)
508 : : return 0;
509 : :
510 : 0 : ret = hns3_get_regs_num(hw, ®s_num_32_bit, ®s_num_64_bit);
511 [ # # ]: 0 : if (ret) {
512 : 0 : hns3_err(hw, "Get register number failed, ret = %d", ret);
513 : 0 : return ret;
514 : : }
515 : :
516 : : /* fetching PF common registers values from firmware */
517 : 0 : ret = hns3_get_32_bit_regs(hw, regs_num_32_bit, data);
518 [ # # ]: 0 : if (ret) {
519 : 0 : hns3_err(hw, "Get 32 bit register failed, ret = %d", ret);
520 : 0 : return ret;
521 : : }
522 : 0 : data += regs_num_32_bit;
523 : 0 : data += hns3_insert_reg_separator(regs_num_32_bit, data);
524 : :
525 : 0 : ret = hns3_get_64_bit_regs(hw, regs_num_64_bit, data);
526 [ # # ]: 0 : if (ret) {
527 : 0 : hns3_err(hw, "Get 64 bit register failed, ret = %d", ret);
528 : 0 : return ret;
529 : : }
530 : 0 : data += regs_num_64_bit * HNS3_64_BIT_REG_SIZE;
531 : 0 : data += hns3_insert_reg_separator(regs_num_64_bit *
532 : : HNS3_64_BIT_REG_SIZE, data);
533 : :
534 : 0 : return hns3_get_dfx_regs(hw, (void **)&data);
535 : : }
|