1
2
3
4
5
6#ifndef _BXNT_DBG_H_
7#define _BXNT_DBG_H_
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#if \
25 defined(DEBUG_PCI) || \
26 defined(DEBUG_MEMORY) || \
27 defined(DEBUG_LINK) || \
28 defined(DEBUG_CHIP) || \
29 defined(DEBUG_FAIL) || \
30 defined(DEBUG_HWRM_CMDS) || \
31 defined(DEBUG_HWRM_DUMP) || \
32 defined(DEBUG_CQ) || \
33 defined(DEBUG_CQ_DUMP) || \
34 defined(DEBUG_TX) || \
35 defined(DEBUG_TX_DUMP) || \
36 defined(DEBUG_RX) || \
37 defined(DEBUG_RX_DUMP)
38#define DEBUG_DEFAULT
39#endif
40
41#if defined(DEBUG_DEFAULT)
42#define dbg_prn printf
43#define MAX_CHAR_SIZE(a) (u32)((1 << (a)) - 1)
44#define DISP_U8 0x00
45#define DISP_U16 0x01
46#define DISP_U32 0x02
47#define DISP_U64 0x03
48
49void dumpmemory1(u8 *buffer, u32 length, u8 flag)
50{
51 u32 jj = 0;
52 u8 i, c;
53
54 printf("\n %p:", buffer);
55 for (jj = 0; jj < 16; jj++) {
56 if (!(jj & MAX_CHAR_SIZE(flag)))
57 printf(" ");
58 if (jj < length)
59 printf("%02x", buffer[jj]);
60 else
61 printf(" ");
62 if ((jj & 0xF) == 0xF) {
63 printf(" ");
64 for (i = 0; i < 16; i++) {
65 if (i < length) {
66 c = buffer[jj + i - 15];
67 if (c >= 0x20 && c < 0x7F)
68 ;
69 else
70 c = '.';
71 printf("%c", c);
72 }
73 }
74 }
75 }
76}
77
78void dump_mem(u8 *buffer, u32 length, u8 flag)
79{
80 u32 length16, remlen, jj;
81
82 length16 = length & 0xFFFFFFF0;
83 remlen = length & 0xF;
84 for (jj = 0; jj < length16; jj += 16)
85 dumpmemory1((u8 *)&buffer[jj], 16, flag);
86 if (remlen)
87 dumpmemory1((u8 *)&buffer[length16], remlen, flag);
88 if (length16 || remlen)
89 printf("\n");
90}
91#endif
92
93#if defined(DEBUG_PCI)
94void dbg_pci(struct bnxt *bp, const char *func, u16 cmd_reg)
95{
96 printf("- %s()\n", func);
97 printf(" Vendor id : %04X\n", bp->vendor_id);
98 printf(" Device id : %04X\n", bp->device_id);
99 printf(" Irq : %d\n", bp->irq);
100 printf(" PCI Command Reg : %04X %04X\n", bp->cmd_reg, cmd_reg);
101 printf(" Sub Vendor id : %04X\n", bp->subsystem_vendor);
102 printf(" Sub Device id : %04X\n", bp->subsystem_device);
103 printf(" BAR (0) : %p\n", bp->bar0);
104 printf(" BAR (1) : %p\n", bp->bar1);
105 printf(" BAR (2) : %p\n", bp->bar2);
106}
107#else
108#define dbg_pci(bp, func, creg)
109#endif
110
111#if defined(DEBUG_MEMORY)
112void dbg_mem(struct bnxt *bp, const char *func)
113{
114 printf("- %s()\n", func);
115 printf(" bp Addr : %p", bp);
116 printf(" Len %4d", (u16)sizeof(struct bnxt));
117 printf(" phy %llx\n", virt_to_bus(bp));
118 printf(" bp->hwrm_req_addr : %p", bp->hwrm_addr_req);
119 printf(" Len %4d", (u16)REQ_BUFFER_SIZE);
120 printf(" phy %llx\n", bp->req_addr_mapping);
121 printf(" bp->hwrm_resp_addr : %p", bp->hwrm_addr_resp);
122 printf(" Len %4d", (u16)RESP_BUFFER_SIZE);
123 printf(" phy %llx\n", bp->resp_addr_mapping);
124 printf(" bp->tx.bd_virt : %p", bp->tx.bd_virt);
125 printf(" Len %4d", (u16)TX_RING_DMA_BUFFER_SIZE);
126 printf(" phy %llx\n", virt_to_bus(bp->tx.bd_virt));
127 printf(" bp->rx.bd_virt : %p", bp->rx.bd_virt);
128 printf(" Len %4d", (u16)RX_RING_DMA_BUFFER_SIZE);
129 printf(" phy %llx\n", virt_to_bus(bp->rx.bd_virt));
130 printf(" bp->cq.bd_virt : %p", bp->cq.bd_virt);
131 printf(" Len %4d", (u16)CQ_RING_DMA_BUFFER_SIZE);
132 printf(" phy %llx\n", virt_to_bus(bp->cq.bd_virt));
133}
134#else
135#define dbg_mem(bp, func)
136#endif
137
138#if defined(DEBUG_CHIP)
139void print_fw_ver(struct hwrm_ver_get_output *resp, u32 tmo)
140{
141 if (resp->hwrm_intf_maj_8b < 1) {
142 dbg_prn(" HWRM interface %d.%d.%d is older than 1.0.0.\n",
143 resp->hwrm_intf_maj_8b, resp->hwrm_intf_min_8b,
144 resp->hwrm_intf_upd_8b);
145 dbg_prn(" Update FW with HWRM interface 1.0.0 or newer.\n");
146 }
147 dbg_prn(" FW Version : %d.%d.%d.%d\n",
148 resp->hwrm_fw_maj_8b, resp->hwrm_fw_min_8b,
149 resp->hwrm_fw_bld_8b, resp->hwrm_fw_rsvd_8b);
150 printf(" cmd timeout : %d\n", tmo);
151}
152
153void dbg_func_resource_qcaps(struct bnxt *bp)
154{
155
156 printf(" min_hw_ring_grps : %d\n", bp->min_hw_ring_grps);
157 printf(" max_hw_ring_grps : %d\n", bp->max_hw_ring_grps);
158
159 printf(" min_tx_rings : %d\n", bp->min_tx_rings);
160 printf(" max_tx_rings : %d\n", bp->max_tx_rings);
161
162 printf(" min_rx_rings : %d\n", bp->min_rx_rings);
163 printf(" max_rx_rings : %d\n", bp->max_rx_rings);
164
165 printf(" min_cq_rings : %d\n", bp->min_cp_rings);
166 printf(" max_cq_rings : %d\n", bp->max_cp_rings);
167
168 printf(" min_stat_ctxs : %d\n", bp->min_stat_ctxs);
169 printf(" max_stat_ctxs : %d\n", bp->max_stat_ctxs);
170}
171
172void print_func_qcaps(struct bnxt *bp)
173{
174 printf(" Port Number : %d\n", bp->port_idx);
175 printf(" fid : 0x%04x\n", bp->fid);
176 dbg_prn(" PF MAC : %02x:%02x:%02x:%02x:%02x:%02x\n",
177 bp->mac_addr[0],
178 bp->mac_addr[1],
179 bp->mac_addr[2],
180 bp->mac_addr[3],
181 bp->mac_addr[4],
182 bp->mac_addr[5]);
183}
184
185void print_func_qcfg(struct bnxt *bp)
186{
187 printf(" ordinal_value : %d\n", bp->ordinal_value);
188 printf(" stat_ctx_id : %x\n", bp->stat_ctx_id);
189 dbg_prn(" FW MAC : %02x:%02x:%02x:%02x:%02x:%02x\n",
190 bp->mac_addr[0],
191 bp->mac_addr[1],
192 bp->mac_addr[2],
193 bp->mac_addr[3],
194 bp->mac_addr[4],
195 bp->mac_addr[5]);
196}
197
198void dbg_set_speed(u32 speed)
199{
200 u32 speed1 = ((speed & LINK_SPEED_DRV_MASK) >> LINK_SPEED_DRV_SHIFT);
201
202 printf(" Set Link Speed : ");
203 switch (speed & LINK_SPEED_DRV_MASK) {
204 case LINK_SPEED_DRV_1G:
205 printf("1 GBPS");
206 break;
207 case LINK_SPEED_DRV_10G:
208 printf("10 GBPS");
209 break;
210 case LINK_SPEED_DRV_25G:
211 printf("25 GBPS");
212 break;
213 case LINK_SPEED_DRV_40G:
214 printf("40 GBPS");
215 break;
216 case LINK_SPEED_DRV_50G:
217 printf("50 GBPS");
218 break;
219 case LINK_SPEED_DRV_100G:
220 printf("100 GBPS");
221 break;
222 case LINK_SPEED_DRV_AUTONEG:
223 printf("AUTONEG");
224 break;
225 default:
226 printf("%x", speed1);
227 break;
228 }
229 printf("\n");
230}
231
232void dbg_chip_info(struct bnxt *bp)
233{
234 printf(" Stat Ctx ID : %d\n", bp->stat_ctx_id);
235 printf(" Grp ID : %d\n", bp->ring_grp_id);
236 printf(" CQ Ring Id : %d\n", bp->cq_ring_id);
237 printf(" Tx Ring Id : %d\n", bp->tx_ring_id);
238 printf(" Rx ring Id : %d\n", bp->rx_ring_id);
239}
240
241void print_num_rings(struct bnxt *bp)
242{
243 printf(" num_cmpl_rings : %d\n", bp->num_cmpl_rings);
244 printf(" num_tx_rings : %d\n", bp->num_tx_rings);
245 printf(" num_rx_rings : %d\n", bp->num_rx_rings);
246 printf(" num_ring_grps : %d\n", bp->num_hw_ring_grps);
247 printf(" num_stat_ctxs : %d\n", bp->num_stat_ctxs);
248}
249
250void dbg_flags(const char *func, u32 flags)
251{
252 printf("- %s()\n", func);
253 printf(" bp->flags : 0x%04x\n", flags);
254}
255#else
256#define print_fw_ver(resp, tmo)
257#define dbg_func_resource_qcaps(bp)
258#define print_func_qcaps(bp)
259#define print_func_qcfg(bp)
260#define dbg_set_speed(speed)
261#define dbg_chip_info(bp)
262#define print_num_rings(bp)
263#define dbg_flags(func, flags)
264#endif
265
266#if defined(DEBUG_HWRM_CMDS) || defined(DEBUG_FAIL)
267void dump_hwrm_req(struct bnxt *bp, const char *func, u32 len, u32 tmo)
268{
269 dbg_prn("- %s(0x%04x) cmd_len %d cmd_tmo %d",
270 func, (u16)((struct input *)bp->hwrm_addr_req)->req_type,
271 len, tmo);
272#if defined(DEBUG_HWRM_DUMP)
273 dump_mem((u8 *)bp->hwrm_addr_req, len, DISP_U8);
274#else
275 printf("\n");
276#endif
277}
278
279void debug_resp(struct bnxt *bp, const char *func, u32 resp_len, u16 err)
280{
281 dbg_prn("- %s(0x%04x) - ",
282 func, (u16)((struct input *)bp->hwrm_addr_req)->req_type);
283 if (err == STATUS_SUCCESS)
284 printf("Done");
285 else if (err != STATUS_TIMEOUT)
286 printf("Fail err 0x%04x", err);
287 else
288 printf("timedout");
289#if defined(DEBUG_HWRM_DUMP)
290 if (err != STATUS_TIMEOUT)
291 dump_mem((u8 *)bp->hwrm_addr_resp, resp_len, DISP_U8);
292 else
293 printf("\n");
294#else
295 printf("\n");
296#endif
297}
298
299void dbg_hw_cmd(struct bnxt *bp,
300 const char *func, u16 cmd_len,
301 u16 resp_len, u32 cmd_tmo, u16 err)
302{
303#if !defined(DEBUG_HWRM_CMDS)
304 if (err && err != STATUS_TIMEOUT)
305#endif
306 {
307 dump_hwrm_req(bp, func, cmd_len, cmd_tmo);
308 debug_resp(bp, func, resp_len, err);
309 }
310}
311#else
312#define dbg_hw_cmd(bp, func, cmd_len, resp_len, cmd_tmo, err)
313#endif
314
315#if defined(DEBUG_HWRM_CMDS)
316void dbg_short_cmd(u8 *req, const char *func, u32 len)
317{
318 struct hwrm_short_input *sreq;
319
320 sreq = (struct hwrm_short_input *)req;
321 dbg_prn("- %s(0x%04x) short_cmd_len %d",
322 func,
323 sreq->req_type,
324 (int)len);
325#if defined(DEBUG_HWRM_DUMP)
326 dump_mem((u8 *)sreq, len, DISP_U8);
327#else
328 printf("\n");
329#endif
330}
331#else
332#define dbg_short_cmd(sreq, func, len)
333#endif
334
335#if defined(DEBUG_RX)
336void dump_rx_bd(struct rx_pkt_cmpl *rx_cmp,
337 struct rx_pkt_cmpl_hi *rx_cmp_hi,
338 u32 desc_idx)
339{
340 printf(" RX desc_idx %d\n", desc_idx);
341 printf("- rx_cmp %llx", virt_to_bus(rx_cmp));
342#if defined(DEBUG_RX_DUMP)
343 dump_mem((u8 *)rx_cmp, (u32)sizeof(struct rx_pkt_cmpl), DISP_U8);
344#else
345 printf("\n");
346#endif
347 printf("- rx_cmp_hi %llx", virt_to_bus(rx_cmp_hi));
348#if defined(DEBUG_RX_DUMP)
349 dump_mem((u8 *)rx_cmp_hi, (u32)sizeof(struct rx_pkt_cmpl_hi), DISP_U8);
350#else
351 printf("\n");
352#endif
353}
354
355void dbg_rxp(u8 *iob, u16 rx_len, u16 flag)
356{
357 printf("- RX iob %llx Len %d ", virt_to_bus(iob), rx_len);
358 if (flag == PKT_RECEIVED)
359 printf(" PKT RECEIVED");
360 else if (flag == PKT_DROPPED)
361 printf(" PKT DROPPED");
362#if defined(DEBUG_RX_DUMP)
363 dump_mem(iob, (u32)rx_len, DISP_U8);
364#else
365 printf("\n");
366#endif
367}
368
369void dbg_rx_cid(u16 idx, u16 cid)
370{
371 dbg_prn("- RX old cid %d new cid %d\n", idx, cid);
372}
373
374void dbg_rx_alloc_iob_fail(u16 idx, u16 cid)
375{
376 dbg_prn(" Rx alloc_iob (%d) failed", idx);
377 dbg_prn(" for cons_id %d\n", cid);
378}
379
380void dbg_rx_iob(void *iob, u16 idx, u16 cid)
381{
382 dbg_prn(" Rx alloc_iob (%d) %p bd_virt (%d)\n",
383 idx, iob, cid);
384}
385
386void dbg_rx_pkt(struct bnxt *bp, const char *func, uchar *pkt, int len)
387{
388 if (bp->rx.iob_recv == PKT_RECEIVED) {
389 dbg_prn("- %s: %llx %d\n", func,
390 virt_to_bus(pkt), len);
391 }
392}
393#else
394#define dump_rx_bd(rx_cmp, rx_cmp_hi, desc_idx)
395#define dbg_rxp(iob, rx_len, flag)
396#define dbg_rx_cid(idx, cid)
397#define dbg_rx_alloc_iob_fail(idx, cid)
398#define dbg_rx_iob(iob, idx, cid)
399#define dbg_rx_pkt(bp, func, pkt, len)
400#endif
401
402#if defined(DEBUG_CQ)
403void dump_CQ(struct cmpl_base *cmp, u16 cons_idx)
404{
405 printf("- CQ Type ");
406
407 switch (cmp->type & CMPL_BASE_TYPE_MASK) {
408 case CMPL_BASE_TYPE_STAT_EJECT:
409 printf("(se)");
410 break;
411 case CMPL_BASE_TYPE_HWRM_ASYNC_EVENT:
412 printf("(ae)");
413 break;
414 case CMPL_BASE_TYPE_TX_L2:
415 printf("(tx)");
416 break;
417 case CMPL_BASE_TYPE_RX_L2:
418 printf("(rx)");
419 break;
420 default:
421 printf("%04x", (u16)(cmp->type & CMPL_BASE_TYPE_MASK));
422 break;
423 }
424 printf(" cid %d", cons_idx);
425#if defined(DEBUG_CQ_DUMP)
426 dump_mem((u8 *)cmp, (u32)sizeof(struct cmpl_base), DISP_U8);
427#else
428 printf("\n");
429#endif
430}
431#else
432#define dump_CQ(cq, id)
433#endif
434
435#if defined(DEBUG_TX)
436void dump_tx_stat(struct bnxt *bp)
437{
438 printf(" TX stats cnt %d req_cnt %d", bp->tx.cnt, bp->tx.cnt_req);
439 printf(" prod_id %d cons_id %d\n", bp->tx.prod_id, bp->tx.cons_id);
440}
441
442void dump_tx_pkt(void *packet, dma_addr_t mapping, int len)
443{
444 printf(" TX Addr %llx Size %d", mapping, len);
445#if defined(DEBUG_TX_DUMP)
446 dump_mem((u8 *)packet, len, DISP_U8);
447#else
448 printf("\n");
449#endif
450}
451
452void dump_tx_bd(struct tx_bd_short *tx_bd, u16 len)
453{
454 printf(" Tx BD Addr %llx Size %d", virt_to_bus(tx_bd), len);
455#if defined(DEBUG_TX_DUMP)
456 dump_mem((u8 *)tx_bd, (u32)len, DISP_U8);
457#else
458 printf("\n");
459#endif
460}
461
462void dbg_no_tx_bd(void)
463{
464 printf(" Tx ring full\n");
465}
466#else
467#define dump_tx_stat(bp)
468#define dump_tx_pkt(packet, mapping, len)
469#define dump_tx_bd(prod_bd, len)
470#define dbg_no_tx_bd()
471#endif
472
473#if defined(DEBUG_MEMORY)
474void dbg_mem_free_done(const char *func)
475{
476 printf("- %s - Done\n", func);
477}
478#else
479#define dbg_mem_free_done(func)
480#endif
481
482#if defined(DEBUG_FAIL)
483void dbg_mem_alloc_fail(const char *func)
484{
485 printf("- %s() Fail\n", func);
486}
487#else
488#define dbg_mem_alloc_fail(func)
489#endif
490
491#if defined(DEBUG_LINK)
492static void dump_evt(u8 *cmp, u32 type, u16 cid)
493{
494 u32 size = sizeof(struct cmpl_base);
495 u8 c = 'C';
496
497 switch (type) {
498 case CMPL_BASE_TYPE_HWRM_ASYNC_EVENT:
499 break;
500 default:
501 return;
502 }
503 dbg_prn("- %cQ Type (ae) cid %d", c, cid);
504 dump_mem(cmp, size, DISP_U8);
505}
506
507void dbg_link_status(struct bnxt *bp)
508{
509 dbg_prn(" Port(%d) : Link", bp->port_idx);
510 if (bp->link_status == STATUS_LINK_ACTIVE) {
511 dbg_prn("Up");
512 } else {
513 dbg_prn("Down\n");
514 dbg_prn(" media_detect : %x", bp->media_detect);
515 }
516 dbg_prn("\n");
517}
518
519void dbg_link_state(struct bnxt *bp, u32 tmo)
520{
521 if (bp->link_status == STATUS_LINK_ACTIVE)
522 printf(" Link wait time : %d ms\n", tmo);
523}
524
525void dbg_phy_speed(struct bnxt *bp, char *name)
526{
527 printf(" Current Speed : %s\n", name);
528}
529#else
530#define dump_evt(cmp, ty, cid)
531#define dbg_link_status(bp)
532#define dbg_link_state(bp, tmo)
533#define dbg_phy_speed(bp, name)
534#endif
535
536#endif
537
