net: bnx2x: fix error value sign
[linux-2.6.git] / drivers / net / bnx2x / bnx2x_main.c
1 /* bnx2x_main.c: Broadcom Everest network driver.
2  *
3  * Copyright (c) 2007-2010 Broadcom Corporation
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation.
8  *
9  * Maintained by: Eilon Greenstein <eilong@broadcom.com>
10  * Written by: Eliezer Tamir
11  * Based on code from Michael Chan's bnx2 driver
12  * UDP CSUM errata workaround by Arik Gendelman
13  * Slowpath and fastpath rework by Vladislav Zolotarov
14  * Statistics and Link management by Yitchak Gertner
15  *
16  */
17
18 #include <linux/module.h>
19 #include <linux/moduleparam.h>
20 #include <linux/kernel.h>
21 #include <linux/device.h>  /* for dev_info() */
22 #include <linux/timer.h>
23 #include <linux/errno.h>
24 #include <linux/ioport.h>
25 #include <linux/slab.h>
26 #include <linux/interrupt.h>
27 #include <linux/pci.h>
28 #include <linux/init.h>
29 #include <linux/netdevice.h>
30 #include <linux/etherdevice.h>
31 #include <linux/skbuff.h>
32 #include <linux/dma-mapping.h>
33 #include <linux/bitops.h>
34 #include <linux/irq.h>
35 #include <linux/delay.h>
36 #include <asm/byteorder.h>
37 #include <linux/time.h>
38 #include <linux/ethtool.h>
39 #include <linux/mii.h>
40 #include <linux/if_vlan.h>
41 #include <net/ip.h>
42 #include <net/tcp.h>
43 #include <net/checksum.h>
44 #include <net/ip6_checksum.h>
45 #include <linux/workqueue.h>
46 #include <linux/crc32.h>
47 #include <linux/crc32c.h>
48 #include <linux/prefetch.h>
49 #include <linux/zlib.h>
50 #include <linux/io.h>
51 #include <linux/stringify.h>
52
53 #define BNX2X_MAIN
54 #include "bnx2x.h"
55 #include "bnx2x_init.h"
56 #include "bnx2x_init_ops.h"
57 #include "bnx2x_cmn.h"
58
59 #include <linux/firmware.h>
60 #include "bnx2x_fw_file_hdr.h"
61 /* FW files */
62 #define FW_FILE_VERSION                                 \
63         __stringify(BCM_5710_FW_MAJOR_VERSION) "."      \
64         __stringify(BCM_5710_FW_MINOR_VERSION) "."      \
65         __stringify(BCM_5710_FW_REVISION_VERSION) "."   \
66         __stringify(BCM_5710_FW_ENGINEERING_VERSION)
67 #define FW_FILE_NAME_E1         "bnx2x/bnx2x-e1-" FW_FILE_VERSION ".fw"
68 #define FW_FILE_NAME_E1H        "bnx2x/bnx2x-e1h-" FW_FILE_VERSION ".fw"
69 #define FW_FILE_NAME_E2         "bnx2x/bnx2x-e2-" FW_FILE_VERSION ".fw"
70
71 /* Time in jiffies before concluding the transmitter is hung */
72 #define TX_TIMEOUT              (5*HZ)
73
74 static char version[] __devinitdata =
75         "Broadcom NetXtreme II 5771x 10Gigabit Ethernet Driver "
76         DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
77
78 MODULE_AUTHOR("Eliezer Tamir");
79 MODULE_DESCRIPTION("Broadcom NetXtreme II "
80                    "BCM57710/57711/57711E/57712/57712E Driver");
81 MODULE_LICENSE("GPL");
82 MODULE_VERSION(DRV_MODULE_VERSION);
83 MODULE_FIRMWARE(FW_FILE_NAME_E1);
84 MODULE_FIRMWARE(FW_FILE_NAME_E1H);
85 MODULE_FIRMWARE(FW_FILE_NAME_E2);
86
87 static int multi_mode = 1;
88 module_param(multi_mode, int, 0);
89 MODULE_PARM_DESC(multi_mode, " Multi queue mode "
90                              "(0 Disable; 1 Enable (default))");
91
92 int num_queues;
93 module_param(num_queues, int, 0);
94 MODULE_PARM_DESC(num_queues, " Number of queues for multi_mode=1"
95                                 " (default is as a number of CPUs)");
96
97 static int disable_tpa;
98 module_param(disable_tpa, int, 0);
99 MODULE_PARM_DESC(disable_tpa, " Disable the TPA (LRO) feature");
100
101 static int int_mode;
102 module_param(int_mode, int, 0);
103 MODULE_PARM_DESC(int_mode, " Force interrupt mode other then MSI-X "
104                                 "(1 INT#x; 2 MSI)");
105
106 static int dropless_fc;
107 module_param(dropless_fc, int, 0);
108 MODULE_PARM_DESC(dropless_fc, " Pause on exhausted host ring");
109
110 static int poll;
111 module_param(poll, int, 0);
112 MODULE_PARM_DESC(poll, " Use polling (for debug)");
113
114 static int mrrs = -1;
115 module_param(mrrs, int, 0);
116 MODULE_PARM_DESC(mrrs, " Force Max Read Req Size (0..3) (for debug)");
117
118 static int debug;
119 module_param(debug, int, 0);
120 MODULE_PARM_DESC(debug, " Default debug msglevel");
121
122 static struct workqueue_struct *bnx2x_wq;
123
124 enum bnx2x_board_type {
125         BCM57710 = 0,
126         BCM57711 = 1,
127         BCM57711E = 2,
128         BCM57712 = 3,
129         BCM57712E = 4
130 };
131
132 /* indexed by board_type, above */
133 static struct {
134         char *name;
135 } board_info[] __devinitdata = {
136         { "Broadcom NetXtreme II BCM57710 XGb" },
137         { "Broadcom NetXtreme II BCM57711 XGb" },
138         { "Broadcom NetXtreme II BCM57711E XGb" },
139         { "Broadcom NetXtreme II BCM57712 XGb" },
140         { "Broadcom NetXtreme II BCM57712E XGb" }
141 };
142
143 #ifndef PCI_DEVICE_ID_NX2_57712
144 #define PCI_DEVICE_ID_NX2_57712         0x1662
145 #endif
146 #ifndef PCI_DEVICE_ID_NX2_57712E
147 #define PCI_DEVICE_ID_NX2_57712E        0x1663
148 #endif
149
150 static DEFINE_PCI_DEVICE_TABLE(bnx2x_pci_tbl) = {
151         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57710), BCM57710 },
152         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711), BCM57711 },
153         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711E), BCM57711E },
154         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712), BCM57712 },
155         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712E), BCM57712E },
156         { 0 }
157 };
158
159 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
160
161 /****************************************************************************
162 * General service functions
163 ****************************************************************************/
164
165 static inline void __storm_memset_dma_mapping(struct bnx2x *bp,
166                                        u32 addr, dma_addr_t mapping)
167 {
168         REG_WR(bp,  addr, U64_LO(mapping));
169         REG_WR(bp,  addr + 4, U64_HI(mapping));
170 }
171
172 static inline void __storm_memset_fill(struct bnx2x *bp,
173                                        u32 addr, size_t size, u32 val)
174 {
175         int i;
176         for (i = 0; i < size/4; i++)
177                 REG_WR(bp,  addr + (i * 4), val);
178 }
179
180 static inline void storm_memset_ustats_zero(struct bnx2x *bp,
181                                             u8 port, u16 stat_id)
182 {
183         size_t size = sizeof(struct ustorm_per_client_stats);
184
185         u32 addr = BAR_USTRORM_INTMEM +
186                         USTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
187
188         __storm_memset_fill(bp, addr, size, 0);
189 }
190
191 static inline void storm_memset_tstats_zero(struct bnx2x *bp,
192                                             u8 port, u16 stat_id)
193 {
194         size_t size = sizeof(struct tstorm_per_client_stats);
195
196         u32 addr = BAR_TSTRORM_INTMEM +
197                         TSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
198
199         __storm_memset_fill(bp, addr, size, 0);
200 }
201
202 static inline void storm_memset_xstats_zero(struct bnx2x *bp,
203                                             u8 port, u16 stat_id)
204 {
205         size_t size = sizeof(struct xstorm_per_client_stats);
206
207         u32 addr = BAR_XSTRORM_INTMEM +
208                         XSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
209
210         __storm_memset_fill(bp, addr, size, 0);
211 }
212
213
214 static inline void storm_memset_spq_addr(struct bnx2x *bp,
215                                          dma_addr_t mapping, u16 abs_fid)
216 {
217         u32 addr = XSEM_REG_FAST_MEMORY +
218                         XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid);
219
220         __storm_memset_dma_mapping(bp, addr, mapping);
221 }
222
223 static inline void storm_memset_ov(struct bnx2x *bp, u16 ov, u16 abs_fid)
224 {
225         REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_E1HOV_OFFSET(abs_fid), ov);
226 }
227
228 static inline void storm_memset_func_cfg(struct bnx2x *bp,
229                                 struct tstorm_eth_function_common_config *tcfg,
230                                 u16 abs_fid)
231 {
232         size_t size = sizeof(struct tstorm_eth_function_common_config);
233
234         u32 addr = BAR_TSTRORM_INTMEM +
235                         TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid);
236
237         __storm_memset_struct(bp, addr, size, (u32 *)tcfg);
238 }
239
240 static inline void storm_memset_xstats_flags(struct bnx2x *bp,
241                                 struct stats_indication_flags *flags,
242                                 u16 abs_fid)
243 {
244         size_t size = sizeof(struct stats_indication_flags);
245
246         u32 addr = BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(abs_fid);
247
248         __storm_memset_struct(bp, addr, size, (u32 *)flags);
249 }
250
251 static inline void storm_memset_tstats_flags(struct bnx2x *bp,
252                                 struct stats_indication_flags *flags,
253                                 u16 abs_fid)
254 {
255         size_t size = sizeof(struct stats_indication_flags);
256
257         u32 addr = BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(abs_fid);
258
259         __storm_memset_struct(bp, addr, size, (u32 *)flags);
260 }
261
262 static inline void storm_memset_ustats_flags(struct bnx2x *bp,
263                                 struct stats_indication_flags *flags,
264                                 u16 abs_fid)
265 {
266         size_t size = sizeof(struct stats_indication_flags);
267
268         u32 addr = BAR_USTRORM_INTMEM + USTORM_STATS_FLAGS_OFFSET(abs_fid);
269
270         __storm_memset_struct(bp, addr, size, (u32 *)flags);
271 }
272
273 static inline void storm_memset_cstats_flags(struct bnx2x *bp,
274                                 struct stats_indication_flags *flags,
275                                 u16 abs_fid)
276 {
277         size_t size = sizeof(struct stats_indication_flags);
278
279         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(abs_fid);
280
281         __storm_memset_struct(bp, addr, size, (u32 *)flags);
282 }
283
284 static inline void storm_memset_xstats_addr(struct bnx2x *bp,
285                                            dma_addr_t mapping, u16 abs_fid)
286 {
287         u32 addr = BAR_XSTRORM_INTMEM +
288                 XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
289
290         __storm_memset_dma_mapping(bp, addr, mapping);
291 }
292
293 static inline void storm_memset_tstats_addr(struct bnx2x *bp,
294                                            dma_addr_t mapping, u16 abs_fid)
295 {
296         u32 addr = BAR_TSTRORM_INTMEM +
297                 TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
298
299         __storm_memset_dma_mapping(bp, addr, mapping);
300 }
301
302 static inline void storm_memset_ustats_addr(struct bnx2x *bp,
303                                            dma_addr_t mapping, u16 abs_fid)
304 {
305         u32 addr = BAR_USTRORM_INTMEM +
306                 USTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
307
308         __storm_memset_dma_mapping(bp, addr, mapping);
309 }
310
311 static inline void storm_memset_cstats_addr(struct bnx2x *bp,
312                                            dma_addr_t mapping, u16 abs_fid)
313 {
314         u32 addr = BAR_CSTRORM_INTMEM +
315                 CSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
316
317         __storm_memset_dma_mapping(bp, addr, mapping);
318 }
319
320 static inline void storm_memset_vf_to_pf(struct bnx2x *bp, u16 abs_fid,
321                                          u16 pf_id)
322 {
323         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid),
324                 pf_id);
325         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid),
326                 pf_id);
327         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid),
328                 pf_id);
329         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid),
330                 pf_id);
331 }
332
333 static inline void storm_memset_func_en(struct bnx2x *bp, u16 abs_fid,
334                                         u8 enable)
335 {
336         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid),
337                 enable);
338         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid),
339                 enable);
340         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid),
341                 enable);
342         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid),
343                 enable);
344 }
345
346 static inline void storm_memset_eq_data(struct bnx2x *bp,
347                                 struct event_ring_data *eq_data,
348                                 u16 pfid)
349 {
350         size_t size = sizeof(struct event_ring_data);
351
352         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_DATA_OFFSET(pfid);
353
354         __storm_memset_struct(bp, addr, size, (u32 *)eq_data);
355 }
356
357 static inline void storm_memset_eq_prod(struct bnx2x *bp, u16 eq_prod,
358                                         u16 pfid)
359 {
360         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_PROD_OFFSET(pfid);
361         REG_WR16(bp, addr, eq_prod);
362 }
363
364 static inline void storm_memset_hc_timeout(struct bnx2x *bp, u8 port,
365                                              u16 fw_sb_id, u8 sb_index,
366                                              u8 ticks)
367 {
368
369         int index_offset = CHIP_IS_E2(bp) ?
370                 offsetof(struct hc_status_block_data_e2, index_data) :
371                 offsetof(struct hc_status_block_data_e1x, index_data);
372         u32 addr = BAR_CSTRORM_INTMEM +
373                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
374                         index_offset +
375                         sizeof(struct hc_index_data)*sb_index +
376                         offsetof(struct hc_index_data, timeout);
377         REG_WR8(bp, addr, ticks);
378         DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d ticks %d\n",
379                           port, fw_sb_id, sb_index, ticks);
380 }
381 static inline void storm_memset_hc_disable(struct bnx2x *bp, u8 port,
382                                              u16 fw_sb_id, u8 sb_index,
383                                              u8 disable)
384 {
385         u32 enable_flag = disable ? 0 : (1 << HC_INDEX_DATA_HC_ENABLED_SHIFT);
386         int index_offset = CHIP_IS_E2(bp) ?
387                 offsetof(struct hc_status_block_data_e2, index_data) :
388                 offsetof(struct hc_status_block_data_e1x, index_data);
389         u32 addr = BAR_CSTRORM_INTMEM +
390                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
391                         index_offset +
392                         sizeof(struct hc_index_data)*sb_index +
393                         offsetof(struct hc_index_data, flags);
394         u16 flags = REG_RD16(bp, addr);
395         /* clear and set */
396         flags &= ~HC_INDEX_DATA_HC_ENABLED;
397         flags |= enable_flag;
398         REG_WR16(bp, addr, flags);
399         DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d disable %d\n",
400                           port, fw_sb_id, sb_index, disable);
401 }
402
403 /* used only at init
404  * locking is done by mcp
405  */
406 static void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
407 {
408         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
409         pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
410         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
411                                PCICFG_VENDOR_ID_OFFSET);
412 }
413
414 static u32 bnx2x_reg_rd_ind(struct bnx2x *bp, u32 addr)
415 {
416         u32 val;
417
418         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
419         pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
420         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
421                                PCICFG_VENDOR_ID_OFFSET);
422
423         return val;
424 }
425
426 #define DMAE_DP_SRC_GRC         "grc src_addr [%08x]"
427 #define DMAE_DP_SRC_PCI         "pci src_addr [%x:%08x]"
428 #define DMAE_DP_DST_GRC         "grc dst_addr [%08x]"
429 #define DMAE_DP_DST_PCI         "pci dst_addr [%x:%08x]"
430 #define DMAE_DP_DST_NONE        "dst_addr [none]"
431
432 static void bnx2x_dp_dmae(struct bnx2x *bp, struct dmae_command *dmae,
433                           int msglvl)
434 {
435         u32 src_type = dmae->opcode & DMAE_COMMAND_SRC;
436
437         switch (dmae->opcode & DMAE_COMMAND_DST) {
438         case DMAE_CMD_DST_PCI:
439                 if (src_type == DMAE_CMD_SRC_PCI)
440                         DP(msglvl, "DMAE: opcode 0x%08x\n"
441                            "src [%x:%08x], len [%d*4], dst [%x:%08x]\n"
442                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
443                            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
444                            dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
445                            dmae->comp_addr_hi, dmae->comp_addr_lo,
446                            dmae->comp_val);
447                 else
448                         DP(msglvl, "DMAE: opcode 0x%08x\n"
449                            "src [%08x], len [%d*4], dst [%x:%08x]\n"
450                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
451                            dmae->opcode, dmae->src_addr_lo >> 2,
452                            dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
453                            dmae->comp_addr_hi, dmae->comp_addr_lo,
454                            dmae->comp_val);
455                 break;
456         case DMAE_CMD_DST_GRC:
457                 if (src_type == DMAE_CMD_SRC_PCI)
458                         DP(msglvl, "DMAE: opcode 0x%08x\n"
459                            "src [%x:%08x], len [%d*4], dst_addr [%08x]\n"
460                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
461                            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
462                            dmae->len, dmae->dst_addr_lo >> 2,
463                            dmae->comp_addr_hi, dmae->comp_addr_lo,
464                            dmae->comp_val);
465                 else
466                         DP(msglvl, "DMAE: opcode 0x%08x\n"
467                            "src [%08x], len [%d*4], dst [%08x]\n"
468                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
469                            dmae->opcode, dmae->src_addr_lo >> 2,
470                            dmae->len, dmae->dst_addr_lo >> 2,
471                            dmae->comp_addr_hi, dmae->comp_addr_lo,
472                            dmae->comp_val);
473                 break;
474         default:
475                 if (src_type == DMAE_CMD_SRC_PCI)
476                         DP(msglvl, "DMAE: opcode 0x%08x\n"
477                            DP_LEVEL "src_addr [%x:%08x]  len [%d * 4]  "
478                                     "dst_addr [none]\n"
479                            DP_LEVEL "comp_addr [%x:%08x]  comp_val 0x%08x\n",
480                            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
481                            dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
482                            dmae->comp_val);
483                 else
484                         DP(msglvl, "DMAE: opcode 0x%08x\n"
485                            DP_LEVEL "src_addr [%08x]  len [%d * 4]  "
486                                     "dst_addr [none]\n"
487                            DP_LEVEL "comp_addr [%x:%08x]  comp_val 0x%08x\n",
488                            dmae->opcode, dmae->src_addr_lo >> 2,
489                            dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
490                            dmae->comp_val);
491                 break;
492         }
493
494 }
495
496 const u32 dmae_reg_go_c[] = {
497         DMAE_REG_GO_C0, DMAE_REG_GO_C1, DMAE_REG_GO_C2, DMAE_REG_GO_C3,
498         DMAE_REG_GO_C4, DMAE_REG_GO_C5, DMAE_REG_GO_C6, DMAE_REG_GO_C7,
499         DMAE_REG_GO_C8, DMAE_REG_GO_C9, DMAE_REG_GO_C10, DMAE_REG_GO_C11,
500         DMAE_REG_GO_C12, DMAE_REG_GO_C13, DMAE_REG_GO_C14, DMAE_REG_GO_C15
501 };
502
503 /* copy command into DMAE command memory and set DMAE command go */
504 void bnx2x_post_dmae(struct bnx2x *bp, struct dmae_command *dmae, int idx)
505 {
506         u32 cmd_offset;
507         int i;
508
509         cmd_offset = (DMAE_REG_CMD_MEM + sizeof(struct dmae_command) * idx);
510         for (i = 0; i < (sizeof(struct dmae_command)/4); i++) {
511                 REG_WR(bp, cmd_offset + i*4, *(((u32 *)dmae) + i));
512
513                 DP(BNX2X_MSG_OFF, "DMAE cmd[%d].%d (0x%08x) : 0x%08x\n",
514                    idx, i, cmd_offset + i*4, *(((u32 *)dmae) + i));
515         }
516         REG_WR(bp, dmae_reg_go_c[idx], 1);
517 }
518
519 u32 bnx2x_dmae_opcode_add_comp(u32 opcode, u8 comp_type)
520 {
521         return opcode | ((comp_type << DMAE_COMMAND_C_DST_SHIFT) |
522                            DMAE_CMD_C_ENABLE);
523 }
524
525 u32 bnx2x_dmae_opcode_clr_src_reset(u32 opcode)
526 {
527         return opcode & ~DMAE_CMD_SRC_RESET;
528 }
529
530 u32 bnx2x_dmae_opcode(struct bnx2x *bp, u8 src_type, u8 dst_type,
531                              bool with_comp, u8 comp_type)
532 {
533         u32 opcode = 0;
534
535         opcode |= ((src_type << DMAE_COMMAND_SRC_SHIFT) |
536                    (dst_type << DMAE_COMMAND_DST_SHIFT));
537
538         opcode |= (DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET);
539
540         opcode |= (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0);
541         opcode |= ((BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT) |
542                    (BP_E1HVN(bp) << DMAE_COMMAND_DST_VN_SHIFT));
543         opcode |= (DMAE_COM_SET_ERR << DMAE_COMMAND_ERR_POLICY_SHIFT);
544
545 #ifdef __BIG_ENDIAN
546         opcode |= DMAE_CMD_ENDIANITY_B_DW_SWAP;
547 #else
548         opcode |= DMAE_CMD_ENDIANITY_DW_SWAP;
549 #endif
550         if (with_comp)
551                 opcode = bnx2x_dmae_opcode_add_comp(opcode, comp_type);
552         return opcode;
553 }
554
555 static void bnx2x_prep_dmae_with_comp(struct bnx2x *bp,
556                                       struct dmae_command *dmae,
557                                       u8 src_type, u8 dst_type)
558 {
559         memset(dmae, 0, sizeof(struct dmae_command));
560
561         /* set the opcode */
562         dmae->opcode = bnx2x_dmae_opcode(bp, src_type, dst_type,
563                                          true, DMAE_COMP_PCI);
564
565         /* fill in the completion parameters */
566         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
567         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
568         dmae->comp_val = DMAE_COMP_VAL;
569 }
570
571 /* issue a dmae command over the init-channel and wailt for completion */
572 static int bnx2x_issue_dmae_with_comp(struct bnx2x *bp,
573                                       struct dmae_command *dmae)
574 {
575         u32 *wb_comp = bnx2x_sp(bp, wb_comp);
576         int cnt = CHIP_REV_IS_SLOW(bp) ? (400000) : 40;
577         int rc = 0;
578
579         DP(BNX2X_MSG_OFF, "data before [0x%08x 0x%08x 0x%08x 0x%08x]\n",
580            bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
581            bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
582
583         /* lock the dmae channel */
584         mutex_lock(&bp->dmae_mutex);
585
586         /* reset completion */
587         *wb_comp = 0;
588
589         /* post the command on the channel used for initializations */
590         bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
591
592         /* wait for completion */
593         udelay(5);
594         while ((*wb_comp & ~DMAE_PCI_ERR_FLAG) != DMAE_COMP_VAL) {
595                 DP(BNX2X_MSG_OFF, "wb_comp 0x%08x\n", *wb_comp);
596
597                 if (!cnt) {
598                         BNX2X_ERR("DMAE timeout!\n");
599                         rc = DMAE_TIMEOUT;
600                         goto unlock;
601                 }
602                 cnt--;
603                 udelay(50);
604         }
605         if (*wb_comp & DMAE_PCI_ERR_FLAG) {
606                 BNX2X_ERR("DMAE PCI error!\n");
607                 rc = DMAE_PCI_ERROR;
608         }
609
610         DP(BNX2X_MSG_OFF, "data after [0x%08x 0x%08x 0x%08x 0x%08x]\n",
611            bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
612            bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
613
614 unlock:
615         mutex_unlock(&bp->dmae_mutex);
616         return rc;
617 }
618
619 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr, u32 dst_addr,
620                       u32 len32)
621 {
622         struct dmae_command dmae;
623
624         if (!bp->dmae_ready) {
625                 u32 *data = bnx2x_sp(bp, wb_data[0]);
626
627                 DP(BNX2X_MSG_OFF, "DMAE is not ready (dst_addr %08x  len32 %d)"
628                    "  using indirect\n", dst_addr, len32);
629                 bnx2x_init_ind_wr(bp, dst_addr, data, len32);
630                 return;
631         }
632
633         /* set opcode and fixed command fields */
634         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_GRC);
635
636         /* fill in addresses and len */
637         dmae.src_addr_lo = U64_LO(dma_addr);
638         dmae.src_addr_hi = U64_HI(dma_addr);
639         dmae.dst_addr_lo = dst_addr >> 2;
640         dmae.dst_addr_hi = 0;
641         dmae.len = len32;
642
643         bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_OFF);
644
645         /* issue the command and wait for completion */
646         bnx2x_issue_dmae_with_comp(bp, &dmae);
647 }
648
649 void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32)
650 {
651         struct dmae_command dmae;
652
653         if (!bp->dmae_ready) {
654                 u32 *data = bnx2x_sp(bp, wb_data[0]);
655                 int i;
656
657                 DP(BNX2X_MSG_OFF, "DMAE is not ready (src_addr %08x  len32 %d)"
658                    "  using indirect\n", src_addr, len32);
659                 for (i = 0; i < len32; i++)
660                         data[i] = bnx2x_reg_rd_ind(bp, src_addr + i*4);
661                 return;
662         }
663
664         /* set opcode and fixed command fields */
665         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_GRC, DMAE_DST_PCI);
666
667         /* fill in addresses and len */
668         dmae.src_addr_lo = src_addr >> 2;
669         dmae.src_addr_hi = 0;
670         dmae.dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_data));
671         dmae.dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_data));
672         dmae.len = len32;
673
674         bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_OFF);
675
676         /* issue the command and wait for completion */
677         bnx2x_issue_dmae_with_comp(bp, &dmae);
678 }
679
680 static void bnx2x_write_dmae_phys_len(struct bnx2x *bp, dma_addr_t phys_addr,
681                                       u32 addr, u32 len)
682 {
683         int dmae_wr_max = DMAE_LEN32_WR_MAX(bp);
684         int offset = 0;
685
686         while (len > dmae_wr_max) {
687                 bnx2x_write_dmae(bp, phys_addr + offset,
688                                  addr + offset, dmae_wr_max);
689                 offset += dmae_wr_max * 4;
690                 len -= dmae_wr_max;
691         }
692
693         bnx2x_write_dmae(bp, phys_addr + offset, addr + offset, len);
694 }
695
696 /* used only for slowpath so not inlined */
697 static void bnx2x_wb_wr(struct bnx2x *bp, int reg, u32 val_hi, u32 val_lo)
698 {
699         u32 wb_write[2];
700
701         wb_write[0] = val_hi;
702         wb_write[1] = val_lo;
703         REG_WR_DMAE(bp, reg, wb_write, 2);
704 }
705
706 #ifdef USE_WB_RD
707 static u64 bnx2x_wb_rd(struct bnx2x *bp, int reg)
708 {
709         u32 wb_data[2];
710
711         REG_RD_DMAE(bp, reg, wb_data, 2);
712
713         return HILO_U64(wb_data[0], wb_data[1]);
714 }
715 #endif
716
717 static int bnx2x_mc_assert(struct bnx2x *bp)
718 {
719         char last_idx;
720         int i, rc = 0;
721         u32 row0, row1, row2, row3;
722
723         /* XSTORM */
724         last_idx = REG_RD8(bp, BAR_XSTRORM_INTMEM +
725                            XSTORM_ASSERT_LIST_INDEX_OFFSET);
726         if (last_idx)
727                 BNX2X_ERR("XSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
728
729         /* print the asserts */
730         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
731
732                 row0 = REG_RD(bp, BAR_XSTRORM_INTMEM +
733                               XSTORM_ASSERT_LIST_OFFSET(i));
734                 row1 = REG_RD(bp, BAR_XSTRORM_INTMEM +
735                               XSTORM_ASSERT_LIST_OFFSET(i) + 4);
736                 row2 = REG_RD(bp, BAR_XSTRORM_INTMEM +
737                               XSTORM_ASSERT_LIST_OFFSET(i) + 8);
738                 row3 = REG_RD(bp, BAR_XSTRORM_INTMEM +
739                               XSTORM_ASSERT_LIST_OFFSET(i) + 12);
740
741                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
742                         BNX2X_ERR("XSTORM_ASSERT_INDEX 0x%x = 0x%08x"
743                                   " 0x%08x 0x%08x 0x%08x\n",
744                                   i, row3, row2, row1, row0);
745                         rc++;
746                 } else {
747                         break;
748                 }
749         }
750
751         /* TSTORM */
752         last_idx = REG_RD8(bp, BAR_TSTRORM_INTMEM +
753                            TSTORM_ASSERT_LIST_INDEX_OFFSET);
754         if (last_idx)
755                 BNX2X_ERR("TSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
756
757         /* print the asserts */
758         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
759
760                 row0 = REG_RD(bp, BAR_TSTRORM_INTMEM +
761                               TSTORM_ASSERT_LIST_OFFSET(i));
762                 row1 = REG_RD(bp, BAR_TSTRORM_INTMEM +
763                               TSTORM_ASSERT_LIST_OFFSET(i) + 4);
764                 row2 = REG_RD(bp, BAR_TSTRORM_INTMEM +
765                               TSTORM_ASSERT_LIST_OFFSET(i) + 8);
766                 row3 = REG_RD(bp, BAR_TSTRORM_INTMEM +
767                               TSTORM_ASSERT_LIST_OFFSET(i) + 12);
768
769                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
770                         BNX2X_ERR("TSTORM_ASSERT_INDEX 0x%x = 0x%08x"
771                                   " 0x%08x 0x%08x 0x%08x\n",
772                                   i, row3, row2, row1, row0);
773                         rc++;
774                 } else {
775                         break;
776                 }
777         }
778
779         /* CSTORM */
780         last_idx = REG_RD8(bp, BAR_CSTRORM_INTMEM +
781                            CSTORM_ASSERT_LIST_INDEX_OFFSET);
782         if (last_idx)
783                 BNX2X_ERR("CSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
784
785         /* print the asserts */
786         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
787
788                 row0 = REG_RD(bp, BAR_CSTRORM_INTMEM +
789                               CSTORM_ASSERT_LIST_OFFSET(i));
790                 row1 = REG_RD(bp, BAR_CSTRORM_INTMEM +
791                               CSTORM_ASSERT_LIST_OFFSET(i) + 4);
792                 row2 = REG_RD(bp, BAR_CSTRORM_INTMEM +
793                               CSTORM_ASSERT_LIST_OFFSET(i) + 8);
794                 row3 = REG_RD(bp, BAR_CSTRORM_INTMEM +
795                               CSTORM_ASSERT_LIST_OFFSET(i) + 12);
796
797                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
798                         BNX2X_ERR("CSTORM_ASSERT_INDEX 0x%x = 0x%08x"
799                                   " 0x%08x 0x%08x 0x%08x\n",
800                                   i, row3, row2, row1, row0);
801                         rc++;
802                 } else {
803                         break;
804                 }
805         }
806
807         /* USTORM */
808         last_idx = REG_RD8(bp, BAR_USTRORM_INTMEM +
809                            USTORM_ASSERT_LIST_INDEX_OFFSET);
810         if (last_idx)
811                 BNX2X_ERR("USTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
812
813         /* print the asserts */
814         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
815
816                 row0 = REG_RD(bp, BAR_USTRORM_INTMEM +
817                               USTORM_ASSERT_LIST_OFFSET(i));
818                 row1 = REG_RD(bp, BAR_USTRORM_INTMEM +
819                               USTORM_ASSERT_LIST_OFFSET(i) + 4);
820                 row2 = REG_RD(bp, BAR_USTRORM_INTMEM +
821                               USTORM_ASSERT_LIST_OFFSET(i) + 8);
822                 row3 = REG_RD(bp, BAR_USTRORM_INTMEM +
823                               USTORM_ASSERT_LIST_OFFSET(i) + 12);
824
825                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
826                         BNX2X_ERR("USTORM_ASSERT_INDEX 0x%x = 0x%08x"
827                                   " 0x%08x 0x%08x 0x%08x\n",
828                                   i, row3, row2, row1, row0);
829                         rc++;
830                 } else {
831                         break;
832                 }
833         }
834
835         return rc;
836 }
837
838 static void bnx2x_fw_dump(struct bnx2x *bp)
839 {
840         u32 addr;
841         u32 mark, offset;
842         __be32 data[9];
843         int word;
844         u32 trace_shmem_base;
845         if (BP_NOMCP(bp)) {
846                 BNX2X_ERR("NO MCP - can not dump\n");
847                 return;
848         }
849
850         if (BP_PATH(bp) == 0)
851                 trace_shmem_base = bp->common.shmem_base;
852         else
853                 trace_shmem_base = SHMEM2_RD(bp, other_shmem_base_addr);
854         addr = trace_shmem_base - 0x0800 + 4;
855         mark = REG_RD(bp, addr);
856         mark = (CHIP_IS_E1x(bp) ? MCP_REG_MCPR_SCRATCH : MCP_A_REG_MCPR_SCRATCH)
857                         + ((mark + 0x3) & ~0x3) - 0x08000000;
858         pr_err("begin fw dump (mark 0x%x)\n", mark);
859
860         pr_err("");
861         for (offset = mark; offset <= trace_shmem_base; offset += 0x8*4) {
862                 for (word = 0; word < 8; word++)
863                         data[word] = htonl(REG_RD(bp, offset + 4*word));
864                 data[8] = 0x0;
865                 pr_cont("%s", (char *)data);
866         }
867         for (offset = addr + 4; offset <= mark; offset += 0x8*4) {
868                 for (word = 0; word < 8; word++)
869                         data[word] = htonl(REG_RD(bp, offset + 4*word));
870                 data[8] = 0x0;
871                 pr_cont("%s", (char *)data);
872         }
873         pr_err("end of fw dump\n");
874 }
875
876 void bnx2x_panic_dump(struct bnx2x *bp)
877 {
878         int i;
879         u16 j;
880         struct hc_sp_status_block_data sp_sb_data;
881         int func = BP_FUNC(bp);
882 #ifdef BNX2X_STOP_ON_ERROR
883         u16 start = 0, end = 0;
884 #endif
885
886         bp->stats_state = STATS_STATE_DISABLED;
887         DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
888
889         BNX2X_ERR("begin crash dump -----------------\n");
890
891         /* Indices */
892         /* Common */
893         BNX2X_ERR("def_idx(0x%x)  def_att_idx(0x%x)  attn_state(0x%x)"
894                   "  spq_prod_idx(0x%x)\n",
895                   bp->def_idx, bp->def_att_idx,
896                   bp->attn_state, bp->spq_prod_idx);
897         BNX2X_ERR("DSB: attn bits(0x%x)  ack(0x%x)  id(0x%x)  idx(0x%x)\n",
898                   bp->def_status_blk->atten_status_block.attn_bits,
899                   bp->def_status_blk->atten_status_block.attn_bits_ack,
900                   bp->def_status_blk->atten_status_block.status_block_id,
901                   bp->def_status_blk->atten_status_block.attn_bits_index);
902         BNX2X_ERR("     def (");
903         for (i = 0; i < HC_SP_SB_MAX_INDICES; i++)
904                 pr_cont("0x%x%s",
905                        bp->def_status_blk->sp_sb.index_values[i],
906                        (i == HC_SP_SB_MAX_INDICES - 1) ? ")  " : " ");
907
908         for (i = 0; i < sizeof(struct hc_sp_status_block_data)/sizeof(u32); i++)
909                 *((u32 *)&sp_sb_data + i) = REG_RD(bp, BAR_CSTRORM_INTMEM +
910                         CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
911                         i*sizeof(u32));
912
913         pr_cont("igu_sb_id(0x%x)  igu_seg_id (0x%x) "
914                          "pf_id(0x%x)  vnic_id(0x%x)  "
915                          "vf_id(0x%x)  vf_valid (0x%x)\n",
916                sp_sb_data.igu_sb_id,
917                sp_sb_data.igu_seg_id,
918                sp_sb_data.p_func.pf_id,
919                sp_sb_data.p_func.vnic_id,
920                sp_sb_data.p_func.vf_id,
921                sp_sb_data.p_func.vf_valid);
922
923
924         for_each_queue(bp, i) {
925                 struct bnx2x_fastpath *fp = &bp->fp[i];
926                 int loop;
927                 struct hc_status_block_data_e2 sb_data_e2;
928                 struct hc_status_block_data_e1x sb_data_e1x;
929                 struct hc_status_block_sm  *hc_sm_p =
930                         CHIP_IS_E2(bp) ?
931                         sb_data_e2.common.state_machine :
932                         sb_data_e1x.common.state_machine;
933                 struct hc_index_data *hc_index_p =
934                         CHIP_IS_E2(bp) ?
935                         sb_data_e2.index_data :
936                         sb_data_e1x.index_data;
937                 int data_size;
938                 u32 *sb_data_p;
939
940                 /* Rx */
941                 BNX2X_ERR("fp%d: rx_bd_prod(0x%x)  rx_bd_cons(0x%x)"
942                           "  rx_comp_prod(0x%x)"
943                           "  rx_comp_cons(0x%x)  *rx_cons_sb(0x%x)\n",
944                           i, fp->rx_bd_prod, fp->rx_bd_cons,
945                           fp->rx_comp_prod,
946                           fp->rx_comp_cons, le16_to_cpu(*fp->rx_cons_sb));
947                 BNX2X_ERR("     rx_sge_prod(0x%x)  last_max_sge(0x%x)"
948                           "  fp_hc_idx(0x%x)\n",
949                           fp->rx_sge_prod, fp->last_max_sge,
950                           le16_to_cpu(fp->fp_hc_idx));
951
952                 /* Tx */
953                 BNX2X_ERR("fp%d: tx_pkt_prod(0x%x)  tx_pkt_cons(0x%x)"
954                           "  tx_bd_prod(0x%x)  tx_bd_cons(0x%x)"
955                           "  *tx_cons_sb(0x%x)\n",
956                           i, fp->tx_pkt_prod, fp->tx_pkt_cons, fp->tx_bd_prod,
957                           fp->tx_bd_cons, le16_to_cpu(*fp->tx_cons_sb));
958
959                 loop = CHIP_IS_E2(bp) ?
960                         HC_SB_MAX_INDICES_E2 : HC_SB_MAX_INDICES_E1X;
961
962                 /* host sb data */
963
964                 BNX2X_ERR("     run indexes (");
965                 for (j = 0; j < HC_SB_MAX_SM; j++)
966                         pr_cont("0x%x%s",
967                                fp->sb_running_index[j],
968                                (j == HC_SB_MAX_SM - 1) ? ")" : " ");
969
970                 BNX2X_ERR("     indexes (");
971                 for (j = 0; j < loop; j++)
972                         pr_cont("0x%x%s",
973                                fp->sb_index_values[j],
974                                (j == loop - 1) ? ")" : " ");
975                 /* fw sb data */
976                 data_size = CHIP_IS_E2(bp) ?
977                         sizeof(struct hc_status_block_data_e2) :
978                         sizeof(struct hc_status_block_data_e1x);
979                 data_size /= sizeof(u32);
980                 sb_data_p = CHIP_IS_E2(bp) ?
981                         (u32 *)&sb_data_e2 :
982                         (u32 *)&sb_data_e1x;
983                 /* copy sb data in here */
984                 for (j = 0; j < data_size; j++)
985                         *(sb_data_p + j) = REG_RD(bp, BAR_CSTRORM_INTMEM +
986                                 CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id) +
987                                 j * sizeof(u32));
988
989                 if (CHIP_IS_E2(bp)) {
990                         pr_cont("pf_id(0x%x)  vf_id (0x%x)  vf_valid(0x%x) "
991                                 "vnic_id(0x%x)  same_igu_sb_1b(0x%x)\n",
992                                 sb_data_e2.common.p_func.pf_id,
993                                 sb_data_e2.common.p_func.vf_id,
994                                 sb_data_e2.common.p_func.vf_valid,
995                                 sb_data_e2.common.p_func.vnic_id,
996                                 sb_data_e2.common.same_igu_sb_1b);
997                 } else {
998                         pr_cont("pf_id(0x%x)  vf_id (0x%x)  vf_valid(0x%x) "
999                                 "vnic_id(0x%x)  same_igu_sb_1b(0x%x)\n",
1000                                 sb_data_e1x.common.p_func.pf_id,
1001                                 sb_data_e1x.common.p_func.vf_id,
1002                                 sb_data_e1x.common.p_func.vf_valid,
1003                                 sb_data_e1x.common.p_func.vnic_id,
1004                                 sb_data_e1x.common.same_igu_sb_1b);
1005                 }
1006
1007                 /* SB_SMs data */
1008                 for (j = 0; j < HC_SB_MAX_SM; j++) {
1009                         pr_cont("SM[%d] __flags (0x%x) "
1010                                "igu_sb_id (0x%x)  igu_seg_id(0x%x) "
1011                                "time_to_expire (0x%x) "
1012                                "timer_value(0x%x)\n", j,
1013                                hc_sm_p[j].__flags,
1014                                hc_sm_p[j].igu_sb_id,
1015                                hc_sm_p[j].igu_seg_id,
1016                                hc_sm_p[j].time_to_expire,
1017                                hc_sm_p[j].timer_value);
1018                 }
1019
1020                 /* Indecies data */
1021                 for (j = 0; j < loop; j++) {
1022                         pr_cont("INDEX[%d] flags (0x%x) "
1023                                          "timeout (0x%x)\n", j,
1024                                hc_index_p[j].flags,
1025                                hc_index_p[j].timeout);
1026                 }
1027         }
1028
1029 #ifdef BNX2X_STOP_ON_ERROR
1030         /* Rings */
1031         /* Rx */
1032         for_each_queue(bp, i) {
1033                 struct bnx2x_fastpath *fp = &bp->fp[i];
1034
1035                 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
1036                 end = RX_BD(le16_to_cpu(*fp->rx_cons_sb) + 503);
1037                 for (j = start; j != end; j = RX_BD(j + 1)) {
1038                         u32 *rx_bd = (u32 *)&fp->rx_desc_ring[j];
1039                         struct sw_rx_bd *sw_bd = &fp->rx_buf_ring[j];
1040
1041                         BNX2X_ERR("fp%d: rx_bd[%x]=[%x:%x]  sw_bd=[%p]\n",
1042                                   i, j, rx_bd[1], rx_bd[0], sw_bd->skb);
1043                 }
1044
1045                 start = RX_SGE(fp->rx_sge_prod);
1046                 end = RX_SGE(fp->last_max_sge);
1047                 for (j = start; j != end; j = RX_SGE(j + 1)) {
1048                         u32 *rx_sge = (u32 *)&fp->rx_sge_ring[j];
1049                         struct sw_rx_page *sw_page = &fp->rx_page_ring[j];
1050
1051                         BNX2X_ERR("fp%d: rx_sge[%x]=[%x:%x]  sw_page=[%p]\n",
1052                                   i, j, rx_sge[1], rx_sge[0], sw_page->page);
1053                 }
1054
1055                 start = RCQ_BD(fp->rx_comp_cons - 10);
1056                 end = RCQ_BD(fp->rx_comp_cons + 503);
1057                 for (j = start; j != end; j = RCQ_BD(j + 1)) {
1058                         u32 *cqe = (u32 *)&fp->rx_comp_ring[j];
1059
1060                         BNX2X_ERR("fp%d: cqe[%x]=[%x:%x:%x:%x]\n",
1061                                   i, j, cqe[0], cqe[1], cqe[2], cqe[3]);
1062                 }
1063         }
1064
1065         /* Tx */
1066         for_each_queue(bp, i) {
1067                 struct bnx2x_fastpath *fp = &bp->fp[i];
1068
1069                 start = TX_BD(le16_to_cpu(*fp->tx_cons_sb) - 10);
1070                 end = TX_BD(le16_to_cpu(*fp->tx_cons_sb) + 245);
1071                 for (j = start; j != end; j = TX_BD(j + 1)) {
1072                         struct sw_tx_bd *sw_bd = &fp->tx_buf_ring[j];
1073
1074                         BNX2X_ERR("fp%d: packet[%x]=[%p,%x]\n",
1075                                   i, j, sw_bd->skb, sw_bd->first_bd);
1076                 }
1077
1078                 start = TX_BD(fp->tx_bd_cons - 10);
1079                 end = TX_BD(fp->tx_bd_cons + 254);
1080                 for (j = start; j != end; j = TX_BD(j + 1)) {
1081                         u32 *tx_bd = (u32 *)&fp->tx_desc_ring[j];
1082
1083                         BNX2X_ERR("fp%d: tx_bd[%x]=[%x:%x:%x:%x]\n",
1084                                   i, j, tx_bd[0], tx_bd[1], tx_bd[2], tx_bd[3]);
1085                 }
1086         }
1087 #endif
1088         bnx2x_fw_dump(bp);
1089         bnx2x_mc_assert(bp);
1090         BNX2X_ERR("end crash dump -----------------\n");
1091 }
1092
1093 static void bnx2x_hc_int_enable(struct bnx2x *bp)
1094 {
1095         int port = BP_PORT(bp);
1096         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
1097         u32 val = REG_RD(bp, addr);
1098         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1099         int msi = (bp->flags & USING_MSI_FLAG) ? 1 : 0;
1100
1101         if (msix) {
1102                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1103                          HC_CONFIG_0_REG_INT_LINE_EN_0);
1104                 val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1105                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1106         } else if (msi) {
1107                 val &= ~HC_CONFIG_0_REG_INT_LINE_EN_0;
1108                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1109                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1110                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1111         } else {
1112                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1113                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1114                         HC_CONFIG_0_REG_INT_LINE_EN_0 |
1115                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1116
1117                 if (!CHIP_IS_E1(bp)) {
1118                         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
1119                            val, port, addr);
1120
1121                         REG_WR(bp, addr, val);
1122
1123                         val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
1124                 }
1125         }
1126
1127         if (CHIP_IS_E1(bp))
1128                 REG_WR(bp, HC_REG_INT_MASK + port*4, 0x1FFFF);
1129
1130         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)  mode %s\n",
1131            val, port, addr, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1132
1133         REG_WR(bp, addr, val);
1134         /*
1135          * Ensure that HC_CONFIG is written before leading/trailing edge config
1136          */
1137         mmiowb();
1138         barrier();
1139
1140         if (!CHIP_IS_E1(bp)) {
1141                 /* init leading/trailing edge */
1142                 if (IS_MF(bp)) {
1143                         val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
1144                         if (bp->port.pmf)
1145                                 /* enable nig and gpio3 attention */
1146                                 val |= 0x1100;
1147                 } else
1148                         val = 0xffff;
1149
1150                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
1151                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
1152         }
1153
1154         /* Make sure that interrupts are indeed enabled from here on */
1155         mmiowb();
1156 }
1157
1158 static void bnx2x_igu_int_enable(struct bnx2x *bp)
1159 {
1160         u32 val;
1161         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1162         int msi = (bp->flags & USING_MSI_FLAG) ? 1 : 0;
1163
1164         val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1165
1166         if (msix) {
1167                 val &= ~(IGU_PF_CONF_INT_LINE_EN |
1168                          IGU_PF_CONF_SINGLE_ISR_EN);
1169                 val |= (IGU_PF_CONF_FUNC_EN |
1170                         IGU_PF_CONF_MSI_MSIX_EN |
1171                         IGU_PF_CONF_ATTN_BIT_EN);
1172         } else if (msi) {
1173                 val &= ~IGU_PF_CONF_INT_LINE_EN;
1174                 val |= (IGU_PF_CONF_FUNC_EN |
1175                         IGU_PF_CONF_MSI_MSIX_EN |
1176                         IGU_PF_CONF_ATTN_BIT_EN |
1177                         IGU_PF_CONF_SINGLE_ISR_EN);
1178         } else {
1179                 val &= ~IGU_PF_CONF_MSI_MSIX_EN;
1180                 val |= (IGU_PF_CONF_FUNC_EN |
1181                         IGU_PF_CONF_INT_LINE_EN |
1182                         IGU_PF_CONF_ATTN_BIT_EN |
1183                         IGU_PF_CONF_SINGLE_ISR_EN);
1184         }
1185
1186         DP(NETIF_MSG_INTR, "write 0x%x to IGU  mode %s\n",
1187            val, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1188
1189         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1190
1191         barrier();
1192
1193         /* init leading/trailing edge */
1194         if (IS_MF(bp)) {
1195                 val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
1196                 if (bp->port.pmf)
1197                         /* enable nig and gpio3 attention */
1198                         val |= 0x1100;
1199         } else
1200                 val = 0xffff;
1201
1202         REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
1203         REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
1204
1205         /* Make sure that interrupts are indeed enabled from here on */
1206         mmiowb();
1207 }
1208
1209 void bnx2x_int_enable(struct bnx2x *bp)
1210 {
1211         if (bp->common.int_block == INT_BLOCK_HC)
1212                 bnx2x_hc_int_enable(bp);
1213         else
1214                 bnx2x_igu_int_enable(bp);
1215 }
1216
1217 static void bnx2x_hc_int_disable(struct bnx2x *bp)
1218 {
1219         int port = BP_PORT(bp);
1220         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
1221         u32 val = REG_RD(bp, addr);
1222
1223         /*
1224          * in E1 we must use only PCI configuration space to disable
1225          * MSI/MSIX capablility
1226          * It's forbitten to disable IGU_PF_CONF_MSI_MSIX_EN in HC block
1227          */
1228         if (CHIP_IS_E1(bp)) {
1229                 /*  Since IGU_PF_CONF_MSI_MSIX_EN still always on
1230                  *  Use mask register to prevent from HC sending interrupts
1231                  *  after we exit the function
1232                  */
1233                 REG_WR(bp, HC_REG_INT_MASK + port*4, 0);
1234
1235                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1236                          HC_CONFIG_0_REG_INT_LINE_EN_0 |
1237                          HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1238         } else
1239                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1240                          HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1241                          HC_CONFIG_0_REG_INT_LINE_EN_0 |
1242                          HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1243
1244         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
1245            val, port, addr);
1246
1247         /* flush all outstanding writes */
1248         mmiowb();
1249
1250         REG_WR(bp, addr, val);
1251         if (REG_RD(bp, addr) != val)
1252                 BNX2X_ERR("BUG! proper val not read from IGU!\n");
1253 }
1254
1255 static void bnx2x_igu_int_disable(struct bnx2x *bp)
1256 {
1257         u32 val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1258
1259         val &= ~(IGU_PF_CONF_MSI_MSIX_EN |
1260                  IGU_PF_CONF_INT_LINE_EN |
1261                  IGU_PF_CONF_ATTN_BIT_EN);
1262
1263         DP(NETIF_MSG_INTR, "write %x to IGU\n", val);
1264
1265         /* flush all outstanding writes */
1266         mmiowb();
1267
1268         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1269         if (REG_RD(bp, IGU_REG_PF_CONFIGURATION) != val)
1270                 BNX2X_ERR("BUG! proper val not read from IGU!\n");
1271 }
1272
1273 static void bnx2x_int_disable(struct bnx2x *bp)
1274 {
1275         if (bp->common.int_block == INT_BLOCK_HC)
1276                 bnx2x_hc_int_disable(bp);
1277         else
1278                 bnx2x_igu_int_disable(bp);
1279 }
1280
1281 void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
1282 {
1283         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1284         int i, offset;
1285
1286         /* disable interrupt handling */
1287         atomic_inc(&bp->intr_sem);
1288         smp_wmb(); /* Ensure that bp->intr_sem update is SMP-safe */
1289
1290         if (disable_hw)
1291                 /* prevent the HW from sending interrupts */
1292                 bnx2x_int_disable(bp);
1293
1294         /* make sure all ISRs are done */
1295         if (msix) {
1296                 synchronize_irq(bp->msix_table[0].vector);
1297                 offset = 1;
1298 #ifdef BCM_CNIC
1299                 offset++;
1300 #endif
1301                 for_each_queue(bp, i)
1302                         synchronize_irq(bp->msix_table[i + offset].vector);
1303         } else
1304                 synchronize_irq(bp->pdev->irq);
1305
1306         /* make sure sp_task is not running */
1307         cancel_delayed_work(&bp->sp_task);
1308         flush_workqueue(bnx2x_wq);
1309 }
1310
1311 /* fast path */
1312
1313 /*
1314  * General service functions
1315  */
1316
1317 /* Return true if succeeded to acquire the lock */
1318 static bool bnx2x_trylock_hw_lock(struct bnx2x *bp, u32 resource)
1319 {
1320         u32 lock_status;
1321         u32 resource_bit = (1 << resource);
1322         int func = BP_FUNC(bp);
1323         u32 hw_lock_control_reg;
1324
1325         DP(NETIF_MSG_HW, "Trying to take a lock on resource %d\n", resource);
1326
1327         /* Validating that the resource is within range */
1328         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1329                 DP(NETIF_MSG_HW,
1330                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1331                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1332                 return false;
1333         }
1334
1335         if (func <= 5)
1336                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1337         else
1338                 hw_lock_control_reg =
1339                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1340
1341         /* Try to acquire the lock */
1342         REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1343         lock_status = REG_RD(bp, hw_lock_control_reg);
1344         if (lock_status & resource_bit)
1345                 return true;
1346
1347         DP(NETIF_MSG_HW, "Failed to get a lock on resource %d\n", resource);
1348         return false;
1349 }
1350
1351 #ifdef BCM_CNIC
1352 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid);
1353 #endif
1354
1355 void bnx2x_sp_event(struct bnx2x_fastpath *fp,
1356                            union eth_rx_cqe *rr_cqe)
1357 {
1358         struct bnx2x *bp = fp->bp;
1359         int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1360         int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1361
1362         DP(BNX2X_MSG_SP,
1363            "fp %d  cid %d  got ramrod #%d  state is %x  type is %d\n",
1364            fp->index, cid, command, bp->state,
1365            rr_cqe->ramrod_cqe.ramrod_type);
1366
1367         switch (command | fp->state) {
1368         case (RAMROD_CMD_ID_ETH_CLIENT_SETUP | BNX2X_FP_STATE_OPENING):
1369                 DP(NETIF_MSG_IFUP, "got MULTI[%d] setup ramrod\n", cid);
1370                 fp->state = BNX2X_FP_STATE_OPEN;
1371                 break;
1372
1373         case (RAMROD_CMD_ID_ETH_HALT | BNX2X_FP_STATE_HALTING):
1374                 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] halt ramrod\n", cid);
1375                 fp->state = BNX2X_FP_STATE_HALTED;
1376                 break;
1377
1378         case (RAMROD_CMD_ID_ETH_TERMINATE | BNX2X_FP_STATE_TERMINATING):
1379                 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] teminate ramrod\n", cid);
1380                 fp->state = BNX2X_FP_STATE_TERMINATED;
1381                 break;
1382
1383         default:
1384                 BNX2X_ERR("unexpected MC reply (%d)  "
1385                           "fp[%d] state is %x\n",
1386                           command, fp->index, fp->state);
1387                 break;
1388         }
1389
1390         smp_mb__before_atomic_inc();
1391         atomic_inc(&bp->spq_left);
1392         /* push the change in fp->state and towards the memory */
1393         smp_wmb();
1394
1395         return;
1396 }
1397
1398 irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
1399 {
1400         struct bnx2x *bp = netdev_priv(dev_instance);
1401         u16 status = bnx2x_ack_int(bp);
1402         u16 mask;
1403         int i;
1404
1405         /* Return here if interrupt is shared and it's not for us */
1406         if (unlikely(status == 0)) {
1407                 DP(NETIF_MSG_INTR, "not our interrupt!\n");
1408                 return IRQ_NONE;
1409         }
1410         DP(NETIF_MSG_INTR, "got an interrupt  status 0x%x\n", status);
1411
1412         /* Return here if interrupt is disabled */
1413         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
1414                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
1415                 return IRQ_HANDLED;
1416         }
1417
1418 #ifdef BNX2X_STOP_ON_ERROR
1419         if (unlikely(bp->panic))
1420                 return IRQ_HANDLED;
1421 #endif
1422
1423         for_each_queue(bp, i) {
1424                 struct bnx2x_fastpath *fp = &bp->fp[i];
1425
1426                 mask = 0x2 << (fp->index + CNIC_CONTEXT_USE);
1427                 if (status & mask) {
1428                         /* Handle Rx and Tx according to SB id */
1429                         prefetch(fp->rx_cons_sb);
1430                         prefetch(fp->tx_cons_sb);
1431                         prefetch(&fp->sb_running_index[SM_RX_ID]);
1432                         napi_schedule(&bnx2x_fp(bp, fp->index, napi));
1433                         status &= ~mask;
1434                 }
1435         }
1436
1437 #ifdef BCM_CNIC
1438         mask = 0x2;
1439         if (status & (mask | 0x1)) {
1440                 struct cnic_ops *c_ops = NULL;
1441
1442                 rcu_read_lock();
1443                 c_ops = rcu_dereference(bp->cnic_ops);
1444                 if (c_ops)
1445                         c_ops->cnic_handler(bp->cnic_data, NULL);
1446                 rcu_read_unlock();
1447
1448                 status &= ~mask;
1449         }
1450 #endif
1451
1452         if (unlikely(status & 0x1)) {
1453                 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
1454
1455                 status &= ~0x1;
1456                 if (!status)
1457                         return IRQ_HANDLED;
1458         }
1459
1460         if (unlikely(status))
1461                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
1462                    status);
1463
1464         return IRQ_HANDLED;
1465 }
1466
1467 /* end of fast path */
1468
1469
1470 /* Link */
1471
1472 /*
1473  * General service functions
1474  */
1475
1476 int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource)
1477 {
1478         u32 lock_status;
1479         u32 resource_bit = (1 << resource);
1480         int func = BP_FUNC(bp);
1481         u32 hw_lock_control_reg;
1482         int cnt;
1483
1484         /* Validating that the resource is within range */
1485         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1486                 DP(NETIF_MSG_HW,
1487                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1488                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1489                 return -EINVAL;
1490         }
1491
1492         if (func <= 5) {
1493                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1494         } else {
1495                 hw_lock_control_reg =
1496                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1497         }
1498
1499         /* Validating that the resource is not already taken */
1500         lock_status = REG_RD(bp, hw_lock_control_reg);
1501         if (lock_status & resource_bit) {
1502                 DP(NETIF_MSG_HW, "lock_status 0x%x  resource_bit 0x%x\n",
1503                    lock_status, resource_bit);
1504                 return -EEXIST;
1505         }
1506
1507         /* Try for 5 second every 5ms */
1508         for (cnt = 0; cnt < 1000; cnt++) {
1509                 /* Try to acquire the lock */
1510                 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1511                 lock_status = REG_RD(bp, hw_lock_control_reg);
1512                 if (lock_status & resource_bit)
1513                         return 0;
1514
1515                 msleep(5);
1516         }
1517         DP(NETIF_MSG_HW, "Timeout\n");
1518         return -EAGAIN;
1519 }
1520
1521 int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource)
1522 {
1523         u32 lock_status;
1524         u32 resource_bit = (1 << resource);
1525         int func = BP_FUNC(bp);
1526         u32 hw_lock_control_reg;
1527
1528         DP(NETIF_MSG_HW, "Releasing a lock on resource %d\n", resource);
1529
1530         /* Validating that the resource is within range */
1531         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1532                 DP(NETIF_MSG_HW,
1533                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1534                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1535                 return -EINVAL;
1536         }
1537
1538         if (func <= 5) {
1539                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1540         } else {
1541                 hw_lock_control_reg =
1542                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1543         }
1544
1545         /* Validating that the resource is currently taken */
1546         lock_status = REG_RD(bp, hw_lock_control_reg);
1547         if (!(lock_status & resource_bit)) {
1548                 DP(NETIF_MSG_HW, "lock_status 0x%x  resource_bit 0x%x\n",
1549                    lock_status, resource_bit);
1550                 return -EFAULT;
1551         }
1552
1553         REG_WR(bp, hw_lock_control_reg, resource_bit);
1554         return 0;
1555 }
1556
1557
1558 int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, u8 port)
1559 {
1560         /* The GPIO should be swapped if swap register is set and active */
1561         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1562                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1563         int gpio_shift = gpio_num +
1564                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1565         u32 gpio_mask = (1 << gpio_shift);
1566         u32 gpio_reg;
1567         int value;
1568
1569         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1570                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1571                 return -EINVAL;
1572         }
1573
1574         /* read GPIO value */
1575         gpio_reg = REG_RD(bp, MISC_REG_GPIO);
1576
1577         /* get the requested pin value */
1578         if ((gpio_reg & gpio_mask) == gpio_mask)
1579                 value = 1;
1580         else
1581                 value = 0;
1582
1583         DP(NETIF_MSG_LINK, "pin %d  value 0x%x\n", gpio_num, value);
1584
1585         return value;
1586 }
1587
1588 int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1589 {
1590         /* The GPIO should be swapped if swap register is set and active */
1591         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1592                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1593         int gpio_shift = gpio_num +
1594                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1595         u32 gpio_mask = (1 << gpio_shift);
1596         u32 gpio_reg;
1597
1598         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1599                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1600                 return -EINVAL;
1601         }
1602
1603         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1604         /* read GPIO and mask except the float bits */
1605         gpio_reg = (REG_RD(bp, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
1606
1607         switch (mode) {
1608         case MISC_REGISTERS_GPIO_OUTPUT_LOW:
1609                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output low\n",
1610                    gpio_num, gpio_shift);
1611                 /* clear FLOAT and set CLR */
1612                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1613                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
1614                 break;
1615
1616         case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
1617                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output high\n",
1618                    gpio_num, gpio_shift);
1619                 /* clear FLOAT and set SET */
1620                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1621                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
1622                 break;
1623
1624         case MISC_REGISTERS_GPIO_INPUT_HI_Z:
1625                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> input\n",
1626                    gpio_num, gpio_shift);
1627                 /* set FLOAT */
1628                 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1629                 break;
1630
1631         default:
1632                 break;
1633         }
1634
1635         REG_WR(bp, MISC_REG_GPIO, gpio_reg);
1636         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1637
1638         return 0;
1639 }
1640
1641 int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1642 {
1643         /* The GPIO should be swapped if swap register is set and active */
1644         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1645                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1646         int gpio_shift = gpio_num +
1647                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1648         u32 gpio_mask = (1 << gpio_shift);
1649         u32 gpio_reg;
1650
1651         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1652                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1653                 return -EINVAL;
1654         }
1655
1656         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1657         /* read GPIO int */
1658         gpio_reg = REG_RD(bp, MISC_REG_GPIO_INT);
1659
1660         switch (mode) {
1661         case MISC_REGISTERS_GPIO_INT_OUTPUT_CLR:
1662                 DP(NETIF_MSG_LINK, "Clear GPIO INT %d (shift %d) -> "
1663                                    "output low\n", gpio_num, gpio_shift);
1664                 /* clear SET and set CLR */
1665                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1666                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1667                 break;
1668
1669         case MISC_REGISTERS_GPIO_INT_OUTPUT_SET:
1670                 DP(NETIF_MSG_LINK, "Set GPIO INT %d (shift %d) -> "
1671                                    "output high\n", gpio_num, gpio_shift);
1672                 /* clear CLR and set SET */
1673                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1674                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1675                 break;
1676
1677         default:
1678                 break;
1679         }
1680
1681         REG_WR(bp, MISC_REG_GPIO_INT, gpio_reg);
1682         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1683
1684         return 0;
1685 }
1686
1687 static int bnx2x_set_spio(struct bnx2x *bp, int spio_num, u32 mode)
1688 {
1689         u32 spio_mask = (1 << spio_num);
1690         u32 spio_reg;
1691
1692         if ((spio_num < MISC_REGISTERS_SPIO_4) ||
1693             (spio_num > MISC_REGISTERS_SPIO_7)) {
1694                 BNX2X_ERR("Invalid SPIO %d\n", spio_num);
1695                 return -EINVAL;
1696         }
1697
1698         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1699         /* read SPIO and mask except the float bits */
1700         spio_reg = (REG_RD(bp, MISC_REG_SPIO) & MISC_REGISTERS_SPIO_FLOAT);
1701
1702         switch (mode) {
1703         case MISC_REGISTERS_SPIO_OUTPUT_LOW:
1704                 DP(NETIF_MSG_LINK, "Set SPIO %d -> output low\n", spio_num);
1705                 /* clear FLOAT and set CLR */
1706                 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1707                 spio_reg |=  (spio_mask << MISC_REGISTERS_SPIO_CLR_POS);
1708                 break;
1709
1710         case MISC_REGISTERS_SPIO_OUTPUT_HIGH:
1711                 DP(NETIF_MSG_LINK, "Set SPIO %d -> output high\n", spio_num);
1712                 /* clear FLOAT and set SET */
1713                 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1714                 spio_reg |=  (spio_mask << MISC_REGISTERS_SPIO_SET_POS);
1715                 break;
1716
1717         case MISC_REGISTERS_SPIO_INPUT_HI_Z:
1718                 DP(NETIF_MSG_LINK, "Set SPIO %d -> input\n", spio_num);
1719                 /* set FLOAT */
1720                 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1721                 break;
1722
1723         default:
1724                 break;
1725         }
1726
1727         REG_WR(bp, MISC_REG_SPIO, spio_reg);
1728         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1729
1730         return 0;
1731 }
1732
1733 int bnx2x_get_link_cfg_idx(struct bnx2x *bp)
1734 {
1735         u32 sel_phy_idx = 0;
1736         if (bp->link_vars.link_up) {
1737                 sel_phy_idx = EXT_PHY1;
1738                 /* In case link is SERDES, check if the EXT_PHY2 is the one */
1739                 if ((bp->link_vars.link_status & LINK_STATUS_SERDES_LINK) &&
1740                     (bp->link_params.phy[EXT_PHY2].supported & SUPPORTED_FIBRE))
1741                         sel_phy_idx = EXT_PHY2;
1742         } else {
1743
1744                 switch (bnx2x_phy_selection(&bp->link_params)) {
1745                 case PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT:
1746                 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY:
1747                 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY:
1748                        sel_phy_idx = EXT_PHY1;
1749                        break;
1750                 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY:
1751                 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY:
1752                        sel_phy_idx = EXT_PHY2;
1753                        break;
1754                 }
1755         }
1756         /*
1757         * The selected actived PHY is always after swapping (in case PHY
1758         * swapping is enabled). So when swapping is enabled, we need to reverse
1759         * the configuration
1760         */
1761
1762         if (bp->link_params.multi_phy_config &
1763             PORT_HW_CFG_PHY_SWAPPED_ENABLED) {
1764                 if (sel_phy_idx == EXT_PHY1)
1765                         sel_phy_idx = EXT_PHY2;
1766                 else if (sel_phy_idx == EXT_PHY2)
1767                         sel_phy_idx = EXT_PHY1;
1768         }
1769         return LINK_CONFIG_IDX(sel_phy_idx);
1770 }
1771
1772 void bnx2x_calc_fc_adv(struct bnx2x *bp)
1773 {
1774         u8 cfg_idx = bnx2x_get_link_cfg_idx(bp);
1775         switch (bp->link_vars.ieee_fc &
1776                 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
1777         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
1778                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1779                                                    ADVERTISED_Pause);
1780                 break;
1781
1782         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
1783                 bp->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
1784                                                   ADVERTISED_Pause);
1785                 break;
1786
1787         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
1788                 bp->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
1789                 break;
1790
1791         default:
1792                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1793                                                    ADVERTISED_Pause);
1794                 break;
1795         }
1796 }
1797
1798 u8 bnx2x_initial_phy_init(struct bnx2x *bp, int load_mode)
1799 {
1800         if (!BP_NOMCP(bp)) {
1801                 u8 rc;
1802                 int cfx_idx = bnx2x_get_link_cfg_idx(bp);
1803                 u16 req_line_speed = bp->link_params.req_line_speed[cfx_idx];
1804                 /* Initialize link parameters structure variables */
1805                 /* It is recommended to turn off RX FC for jumbo frames
1806                    for better performance */
1807                 if ((CHIP_IS_E1x(bp)) && (bp->dev->mtu > 5000))
1808                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_TX;
1809                 else
1810                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
1811
1812                 bnx2x_acquire_phy_lock(bp);
1813
1814                 if (load_mode == LOAD_DIAG) {
1815                         bp->link_params.loopback_mode = LOOPBACK_XGXS;
1816                         bp->link_params.req_line_speed[cfx_idx] = SPEED_10000;
1817                 }
1818
1819                 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1820
1821                 bnx2x_release_phy_lock(bp);
1822
1823                 bnx2x_calc_fc_adv(bp);
1824
1825                 if (CHIP_REV_IS_SLOW(bp) && bp->link_vars.link_up) {
1826                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
1827                         bnx2x_link_report(bp);
1828                 }
1829                 bp->link_params.req_line_speed[cfx_idx] = req_line_speed;
1830                 return rc;
1831         }
1832         BNX2X_ERR("Bootcode is missing - can not initialize link\n");
1833         return -EINVAL;
1834 }
1835
1836 void bnx2x_link_set(struct bnx2x *bp)
1837 {
1838         if (!BP_NOMCP(bp)) {
1839                 bnx2x_acquire_phy_lock(bp);
1840                 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1841                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1842                 bnx2x_release_phy_lock(bp);
1843
1844                 bnx2x_calc_fc_adv(bp);
1845         } else
1846                 BNX2X_ERR("Bootcode is missing - can not set link\n");
1847 }
1848
1849 static void bnx2x__link_reset(struct bnx2x *bp)
1850 {
1851         if (!BP_NOMCP(bp)) {
1852                 bnx2x_acquire_phy_lock(bp);
1853                 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1854                 bnx2x_release_phy_lock(bp);
1855         } else
1856                 BNX2X_ERR("Bootcode is missing - can not reset link\n");
1857 }
1858
1859 u8 bnx2x_link_test(struct bnx2x *bp, u8 is_serdes)
1860 {
1861         u8 rc = 0;
1862
1863         if (!BP_NOMCP(bp)) {
1864                 bnx2x_acquire_phy_lock(bp);
1865                 rc = bnx2x_test_link(&bp->link_params, &bp->link_vars,
1866                                      is_serdes);
1867                 bnx2x_release_phy_lock(bp);
1868         } else
1869                 BNX2X_ERR("Bootcode is missing - can not test link\n");
1870
1871         return rc;
1872 }
1873
1874 static void bnx2x_init_port_minmax(struct bnx2x *bp)
1875 {
1876         u32 r_param = bp->link_vars.line_speed / 8;
1877         u32 fair_periodic_timeout_usec;
1878         u32 t_fair;
1879
1880         memset(&(bp->cmng.rs_vars), 0,
1881                sizeof(struct rate_shaping_vars_per_port));
1882         memset(&(bp->cmng.fair_vars), 0, sizeof(struct fairness_vars_per_port));
1883
1884         /* 100 usec in SDM ticks = 25 since each tick is 4 usec */
1885         bp->cmng.rs_vars.rs_periodic_timeout = RS_PERIODIC_TIMEOUT_USEC / 4;
1886
1887         /* this is the threshold below which no timer arming will occur
1888            1.25 coefficient is for the threshold to be a little bigger
1889            than the real time, to compensate for timer in-accuracy */
1890         bp->cmng.rs_vars.rs_threshold =
1891                                 (RS_PERIODIC_TIMEOUT_USEC * r_param * 5) / 4;
1892
1893         /* resolution of fairness timer */
1894         fair_periodic_timeout_usec = QM_ARB_BYTES / r_param;
1895         /* for 10G it is 1000usec. for 1G it is 10000usec. */
1896         t_fair = T_FAIR_COEF / bp->link_vars.line_speed;
1897
1898         /* this is the threshold below which we won't arm the timer anymore */
1899         bp->cmng.fair_vars.fair_threshold = QM_ARB_BYTES;
1900
1901         /* we multiply by 1e3/8 to get bytes/msec.
1902            We don't want the credits to pass a credit
1903            of the t_fair*FAIR_MEM (algorithm resolution) */
1904         bp->cmng.fair_vars.upper_bound = r_param * t_fair * FAIR_MEM;
1905         /* since each tick is 4 usec */
1906         bp->cmng.fair_vars.fairness_timeout = fair_periodic_timeout_usec / 4;
1907 }
1908
1909 /* Calculates the sum of vn_min_rates.
1910    It's needed for further normalizing of the min_rates.
1911    Returns:
1912      sum of vn_min_rates.
1913        or
1914      0 - if all the min_rates are 0.
1915      In the later case fainess algorithm should be deactivated.
1916      If not all min_rates are zero then those that are zeroes will be set to 1.
1917  */
1918 static void bnx2x_calc_vn_weight_sum(struct bnx2x *bp)
1919 {
1920         int all_zero = 1;
1921         int vn;
1922
1923         bp->vn_weight_sum = 0;
1924         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
1925                 u32 vn_cfg = bp->mf_config[vn];
1926                 u32 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1927                                    FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1928
1929                 /* Skip hidden vns */
1930                 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
1931                         continue;
1932
1933                 /* If min rate is zero - set it to 1 */
1934                 if (!vn_min_rate)
1935                         vn_min_rate = DEF_MIN_RATE;
1936                 else
1937                         all_zero = 0;
1938
1939                 bp->vn_weight_sum += vn_min_rate;
1940         }
1941
1942         /* ... only if all min rates are zeros - disable fairness */
1943         if (all_zero) {
1944                 bp->cmng.flags.cmng_enables &=
1945                                         ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1946                 DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
1947                    "  fairness will be disabled\n");
1948         } else
1949                 bp->cmng.flags.cmng_enables |=
1950                                         CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1951 }
1952
1953 static void bnx2x_init_vn_minmax(struct bnx2x *bp, int vn)
1954 {
1955         struct rate_shaping_vars_per_vn m_rs_vn;
1956         struct fairness_vars_per_vn m_fair_vn;
1957         u32 vn_cfg = bp->mf_config[vn];
1958         int func = 2*vn + BP_PORT(bp);
1959         u16 vn_min_rate, vn_max_rate;
1960         int i;
1961
1962         /* If function is hidden - set min and max to zeroes */
1963         if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE) {
1964                 vn_min_rate = 0;
1965                 vn_max_rate = 0;
1966
1967         } else {
1968                 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1969                                 FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1970                 /* If min rate is zero - set it to 1 */
1971                 if (bp->vn_weight_sum && (vn_min_rate == 0))
1972                         vn_min_rate = DEF_MIN_RATE;
1973                 vn_max_rate = ((vn_cfg & FUNC_MF_CFG_MAX_BW_MASK) >>
1974                                 FUNC_MF_CFG_MAX_BW_SHIFT) * 100;
1975         }
1976
1977         DP(NETIF_MSG_IFUP,
1978            "func %d: vn_min_rate %d  vn_max_rate %d  vn_weight_sum %d\n",
1979            func, vn_min_rate, vn_max_rate, bp->vn_weight_sum);
1980
1981         memset(&m_rs_vn, 0, sizeof(struct rate_shaping_vars_per_vn));
1982         memset(&m_fair_vn, 0, sizeof(struct fairness_vars_per_vn));
1983
1984         /* global vn counter - maximal Mbps for this vn */
1985         m_rs_vn.vn_counter.rate = vn_max_rate;
1986
1987         /* quota - number of bytes transmitted in this period */
1988         m_rs_vn.vn_counter.quota =
1989                                 (vn_max_rate * RS_PERIODIC_TIMEOUT_USEC) / 8;
1990
1991         if (bp->vn_weight_sum) {
1992                 /* credit for each period of the fairness algorithm:
1993                    number of bytes in T_FAIR (the vn share the port rate).
1994                    vn_weight_sum should not be larger than 10000, thus
1995                    T_FAIR_COEF / (8 * vn_weight_sum) will always be greater
1996                    than zero */
1997                 m_fair_vn.vn_credit_delta =
1998                         max_t(u32, (vn_min_rate * (T_FAIR_COEF /
1999                                                    (8 * bp->vn_weight_sum))),
2000                               (bp->cmng.fair_vars.fair_threshold * 2));
2001                 DP(NETIF_MSG_IFUP, "m_fair_vn.vn_credit_delta %d\n",
2002                    m_fair_vn.vn_credit_delta);
2003         }
2004
2005         /* Store it to internal memory */
2006         for (i = 0; i < sizeof(struct rate_shaping_vars_per_vn)/4; i++)
2007                 REG_WR(bp, BAR_XSTRORM_INTMEM +
2008                        XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func) + i * 4,
2009                        ((u32 *)(&m_rs_vn))[i]);
2010
2011         for (i = 0; i < sizeof(struct fairness_vars_per_vn)/4; i++)
2012                 REG_WR(bp, BAR_XSTRORM_INTMEM +
2013                        XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func) + i * 4,
2014                        ((u32 *)(&m_fair_vn))[i]);
2015 }
2016
2017 static int bnx2x_get_cmng_fns_mode(struct bnx2x *bp)
2018 {
2019         if (CHIP_REV_IS_SLOW(bp))
2020                 return CMNG_FNS_NONE;
2021         if (IS_MF(bp))
2022                 return CMNG_FNS_MINMAX;
2023
2024         return CMNG_FNS_NONE;
2025 }
2026
2027 static void bnx2x_read_mf_cfg(struct bnx2x *bp)
2028 {
2029         int vn;
2030
2031         if (BP_NOMCP(bp))
2032                 return; /* what should be the default bvalue in this case */
2033
2034         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2035                 int /*abs*/func = 2*vn + BP_PORT(bp);
2036                 bp->mf_config[vn] =
2037                         MF_CFG_RD(bp, func_mf_config[func].config);
2038         }
2039 }
2040
2041 static void bnx2x_cmng_fns_init(struct bnx2x *bp, u8 read_cfg, u8 cmng_type)
2042 {
2043
2044         if (cmng_type == CMNG_FNS_MINMAX) {
2045                 int vn;
2046
2047                 /* clear cmng_enables */
2048                 bp->cmng.flags.cmng_enables = 0;
2049
2050                 /* read mf conf from shmem */
2051                 if (read_cfg)
2052                         bnx2x_read_mf_cfg(bp);
2053
2054                 /* Init rate shaping and fairness contexts */
2055                 bnx2x_init_port_minmax(bp);
2056
2057                 /* vn_weight_sum and enable fairness if not 0 */
2058                 bnx2x_calc_vn_weight_sum(bp);
2059
2060                 /* calculate and set min-max rate for each vn */
2061                 for (vn = VN_0; vn < E1HVN_MAX; vn++)
2062                         bnx2x_init_vn_minmax(bp, vn);
2063
2064                 /* always enable rate shaping and fairness */
2065                 bp->cmng.flags.cmng_enables |=
2066                                         CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN;
2067                 if (!bp->vn_weight_sum)
2068                         DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
2069                                    "  fairness will be disabled\n");
2070                 return;
2071         }
2072
2073         /* rate shaping and fairness are disabled */
2074         DP(NETIF_MSG_IFUP,
2075            "rate shaping and fairness are disabled\n");
2076 }
2077
2078 static inline void bnx2x_link_sync_notify(struct bnx2x *bp)
2079 {
2080         int port = BP_PORT(bp);
2081         int func;
2082         int vn;
2083
2084         /* Set the attention towards other drivers on the same port */
2085         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2086                 if (vn == BP_E1HVN(bp))
2087                         continue;
2088
2089                 func = ((vn << 1) | port);
2090                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_0 +
2091                        (LINK_SYNC_ATTENTION_BIT_FUNC_0 + func)*4, 1);
2092         }
2093 }
2094
2095 /* This function is called upon link interrupt */
2096 static void bnx2x_link_attn(struct bnx2x *bp)
2097 {
2098         u32 prev_link_status = bp->link_vars.link_status;
2099         /* Make sure that we are synced with the current statistics */
2100         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2101
2102         bnx2x_link_update(&bp->link_params, &bp->link_vars);
2103
2104         if (bp->link_vars.link_up) {
2105
2106                 /* dropless flow control */
2107                 if (!CHIP_IS_E1(bp) && bp->dropless_fc) {
2108                         int port = BP_PORT(bp);
2109                         u32 pause_enabled = 0;
2110
2111                         if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
2112                                 pause_enabled = 1;
2113
2114                         REG_WR(bp, BAR_USTRORM_INTMEM +
2115                                USTORM_ETH_PAUSE_ENABLED_OFFSET(port),
2116                                pause_enabled);
2117                 }
2118
2119                 if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
2120                         struct host_port_stats *pstats;
2121
2122                         pstats = bnx2x_sp(bp, port_stats);
2123                         /* reset old bmac stats */
2124                         memset(&(pstats->mac_stx[0]), 0,
2125                                sizeof(struct mac_stx));
2126                 }
2127                 if (bp->state == BNX2X_STATE_OPEN)
2128                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2129         }
2130
2131         /* indicate link status only if link status actually changed */
2132         if (prev_link_status != bp->link_vars.link_status)
2133                 bnx2x_link_report(bp);
2134
2135         if (IS_MF(bp))
2136                 bnx2x_link_sync_notify(bp);
2137
2138         if (bp->link_vars.link_up && bp->link_vars.line_speed) {
2139                 int cmng_fns = bnx2x_get_cmng_fns_mode(bp);
2140
2141                 if (cmng_fns != CMNG_FNS_NONE) {
2142                         bnx2x_cmng_fns_init(bp, false, cmng_fns);
2143                         storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2144                 } else
2145                         /* rate shaping and fairness are disabled */
2146                         DP(NETIF_MSG_IFUP,
2147                            "single function mode without fairness\n");
2148         }
2149 }
2150
2151 void bnx2x__link_status_update(struct bnx2x *bp)
2152 {
2153         if ((bp->state != BNX2X_STATE_OPEN) || (bp->flags & MF_FUNC_DIS))
2154                 return;
2155
2156         bnx2x_link_status_update(&bp->link_params, &bp->link_vars);
2157
2158         if (bp->link_vars.link_up)
2159                 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2160         else
2161                 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2162
2163         /* the link status update could be the result of a DCC event
2164            hence re-read the shmem mf configuration */
2165         bnx2x_read_mf_cfg(bp);
2166
2167         /* indicate link status */
2168         bnx2x_link_report(bp);
2169 }
2170
2171 static void bnx2x_pmf_update(struct bnx2x *bp)
2172 {
2173         int port = BP_PORT(bp);
2174         u32 val;
2175
2176         bp->port.pmf = 1;
2177         DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
2178
2179         /* enable nig attention */
2180         val = (0xff0f | (1 << (BP_E1HVN(bp) + 4)));
2181         if (bp->common.int_block == INT_BLOCK_HC) {
2182                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
2183                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
2184         } else if (CHIP_IS_E2(bp)) {
2185                 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
2186                 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
2187         }
2188
2189         bnx2x_stats_handle(bp, STATS_EVENT_PMF);
2190 }
2191
2192 /* end of Link */
2193
2194 /* slow path */
2195
2196 /*
2197  * General service functions
2198  */
2199
2200 /* send the MCP a request, block until there is a reply */
2201 u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param)
2202 {
2203         int mb_idx = BP_FW_MB_IDX(bp);
2204         u32 seq = ++bp->fw_seq;
2205         u32 rc = 0;
2206         u32 cnt = 1;
2207         u8 delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
2208
2209         mutex_lock(&bp->fw_mb_mutex);
2210         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_param, param);
2211         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_header, (command | seq));
2212
2213         DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB\n", (command | seq));
2214
2215         do {
2216                 /* let the FW do it's magic ... */
2217                 msleep(delay);
2218
2219                 rc = SHMEM_RD(bp, func_mb[mb_idx].fw_mb_header);
2220
2221                 /* Give the FW up to 5 second (500*10ms) */
2222         } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
2223
2224         DP(BNX2X_MSG_MCP, "[after %d ms] read (%x) seq is (%x) from FW MB\n",
2225            cnt*delay, rc, seq);
2226
2227         /* is this a reply to our command? */
2228         if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK))
2229                 rc &= FW_MSG_CODE_MASK;
2230         else {
2231                 /* FW BUG! */
2232                 BNX2X_ERR("FW failed to respond!\n");
2233                 bnx2x_fw_dump(bp);
2234                 rc = 0;
2235         }
2236         mutex_unlock(&bp->fw_mb_mutex);
2237
2238         return rc;
2239 }
2240
2241 /* must be called under rtnl_lock */
2242 static void bnx2x_rxq_set_mac_filters(struct bnx2x *bp, u16 cl_id, u32 filters)
2243 {
2244         u32 mask = (1 << cl_id);
2245
2246         /* initial seeting is BNX2X_ACCEPT_NONE */
2247         u8 drop_all_ucast = 1, drop_all_bcast = 1, drop_all_mcast = 1;
2248         u8 accp_all_ucast = 0, accp_all_bcast = 0, accp_all_mcast = 0;
2249         u8 unmatched_unicast = 0;
2250
2251         if (filters & BNX2X_PROMISCUOUS_MODE) {
2252                 /* promiscious - accept all, drop none */
2253                 drop_all_ucast = drop_all_bcast = drop_all_mcast = 0;
2254                 accp_all_ucast = accp_all_bcast = accp_all_mcast = 1;
2255         }
2256         if (filters & BNX2X_ACCEPT_UNICAST) {
2257                 /* accept matched ucast */
2258                 drop_all_ucast = 0;
2259         }
2260         if (filters & BNX2X_ACCEPT_MULTICAST) {
2261                 /* accept matched mcast */
2262                 drop_all_mcast = 0;
2263         }
2264         if (filters & BNX2X_ACCEPT_ALL_UNICAST) {
2265                 /* accept all mcast */
2266                 drop_all_ucast = 0;
2267                 accp_all_ucast = 1;
2268         }
2269         if (filters & BNX2X_ACCEPT_ALL_MULTICAST) {
2270                 /* accept all mcast */
2271                 drop_all_mcast = 0;
2272                 accp_all_mcast = 1;
2273         }
2274         if (filters & BNX2X_ACCEPT_BROADCAST) {
2275                 /* accept (all) bcast */
2276                 drop_all_bcast = 0;
2277                 accp_all_bcast = 1;
2278         }
2279
2280         bp->mac_filters.ucast_drop_all = drop_all_ucast ?
2281                 bp->mac_filters.ucast_drop_all | mask :
2282                 bp->mac_filters.ucast_drop_all & ~mask;
2283
2284         bp->mac_filters.mcast_drop_all = drop_all_mcast ?
2285                 bp->mac_filters.mcast_drop_all | mask :
2286                 bp->mac_filters.mcast_drop_all & ~mask;
2287
2288         bp->mac_filters.bcast_drop_all = drop_all_bcast ?
2289                 bp->mac_filters.bcast_drop_all | mask :
2290                 bp->mac_filters.bcast_drop_all & ~mask;
2291
2292         bp->mac_filters.ucast_accept_all = accp_all_ucast ?
2293                 bp->mac_filters.ucast_accept_all | mask :
2294                 bp->mac_filters.ucast_accept_all & ~mask;
2295
2296         bp->mac_filters.mcast_accept_all = accp_all_mcast ?
2297                 bp->mac_filters.mcast_accept_all | mask :
2298                 bp->mac_filters.mcast_accept_all & ~mask;
2299
2300         bp->mac_filters.bcast_accept_all = accp_all_bcast ?
2301                 bp->mac_filters.bcast_accept_all | mask :
2302                 bp->mac_filters.bcast_accept_all & ~mask;
2303
2304         bp->mac_filters.unmatched_unicast = unmatched_unicast ?
2305                 bp->mac_filters.unmatched_unicast | mask :
2306                 bp->mac_filters.unmatched_unicast & ~mask;
2307 }
2308
2309 static void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p)
2310 {
2311         struct tstorm_eth_function_common_config tcfg = {0};
2312         u16 rss_flgs;
2313
2314         /* tpa */
2315         if (p->func_flgs & FUNC_FLG_TPA)
2316                 tcfg.config_flags |=
2317                 TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA;
2318
2319         /* set rss flags */
2320         rss_flgs = (p->rss->mode <<
2321                 TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT);
2322
2323         if (p->rss->cap & RSS_IPV4_CAP)
2324                 rss_flgs |= RSS_IPV4_CAP_MASK;
2325         if (p->rss->cap & RSS_IPV4_TCP_CAP)
2326                 rss_flgs |= RSS_IPV4_TCP_CAP_MASK;
2327         if (p->rss->cap & RSS_IPV6_CAP)
2328                 rss_flgs |= RSS_IPV6_CAP_MASK;
2329         if (p->rss->cap & RSS_IPV6_TCP_CAP)
2330                 rss_flgs |= RSS_IPV6_TCP_CAP_MASK;
2331
2332         tcfg.config_flags |= rss_flgs;
2333         tcfg.rss_result_mask = p->rss->result_mask;
2334
2335         storm_memset_func_cfg(bp, &tcfg, p->func_id);
2336
2337         /* Enable the function in the FW */
2338         storm_memset_vf_to_pf(bp, p->func_id, p->pf_id);
2339         storm_memset_func_en(bp, p->func_id, 1);
2340
2341         /* statistics */
2342         if (p->func_flgs & FUNC_FLG_STATS) {
2343                 struct stats_indication_flags stats_flags = {0};
2344                 stats_flags.collect_eth = 1;
2345
2346                 storm_memset_xstats_flags(bp, &stats_flags, p->func_id);
2347                 storm_memset_xstats_addr(bp, p->fw_stat_map, p->func_id);
2348
2349                 storm_memset_tstats_flags(bp, &stats_flags, p->func_id);
2350                 storm_memset_tstats_addr(bp, p->fw_stat_map, p->func_id);
2351
2352                 storm_memset_ustats_flags(bp, &stats_flags, p->func_id);
2353                 storm_memset_ustats_addr(bp, p->fw_stat_map, p->func_id);
2354
2355                 storm_memset_cstats_flags(bp, &stats_flags, p->func_id);
2356                 storm_memset_cstats_addr(bp, p->fw_stat_map, p->func_id);
2357         }
2358
2359         /* spq */
2360         if (p->func_flgs & FUNC_FLG_SPQ) {
2361                 storm_memset_spq_addr(bp, p->spq_map, p->func_id);
2362                 REG_WR(bp, XSEM_REG_FAST_MEMORY +
2363                        XSTORM_SPQ_PROD_OFFSET(p->func_id), p->spq_prod);
2364         }
2365 }
2366
2367 static inline u16 bnx2x_get_cl_flags(struct bnx2x *bp,
2368                                      struct bnx2x_fastpath *fp)
2369 {
2370         u16 flags = 0;
2371
2372         /* calculate queue flags */
2373         flags |= QUEUE_FLG_CACHE_ALIGN;
2374         flags |= QUEUE_FLG_HC;
2375         flags |= IS_MF(bp) ? QUEUE_FLG_OV : 0;
2376
2377         flags |= QUEUE_FLG_VLAN;
2378         DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
2379
2380         if (!fp->disable_tpa)
2381                 flags |= QUEUE_FLG_TPA;
2382
2383         flags |= QUEUE_FLG_STATS;
2384
2385         return flags;
2386 }
2387
2388 static void bnx2x_pf_rx_cl_prep(struct bnx2x *bp,
2389         struct bnx2x_fastpath *fp, struct rxq_pause_params *pause,
2390         struct bnx2x_rxq_init_params *rxq_init)
2391 {
2392         u16 max_sge = 0;
2393         u16 sge_sz = 0;
2394         u16 tpa_agg_size = 0;
2395
2396         /* calculate queue flags */
2397         u16 flags = bnx2x_get_cl_flags(bp, fp);
2398
2399         if (!fp->disable_tpa) {
2400                 pause->sge_th_hi = 250;
2401                 pause->sge_th_lo = 150;
2402                 tpa_agg_size = min_t(u32,
2403                         (min_t(u32, 8, MAX_SKB_FRAGS) *
2404                         SGE_PAGE_SIZE * PAGES_PER_SGE), 0xffff);
2405                 max_sge = SGE_PAGE_ALIGN(bp->dev->mtu) >>
2406                         SGE_PAGE_SHIFT;
2407                 max_sge = ((max_sge + PAGES_PER_SGE - 1) &
2408                           (~(PAGES_PER_SGE-1))) >> PAGES_PER_SGE_SHIFT;
2409                 sge_sz = (u16)min_t(u32, SGE_PAGE_SIZE * PAGES_PER_SGE,
2410                                     0xffff);
2411         }
2412
2413         /* pause - not for e1 */
2414         if (!CHIP_IS_E1(bp)) {
2415                 pause->bd_th_hi = 350;
2416                 pause->bd_th_lo = 250;
2417                 pause->rcq_th_hi = 350;
2418                 pause->rcq_th_lo = 250;
2419                 pause->sge_th_hi = 0;
2420                 pause->sge_th_lo = 0;
2421                 pause->pri_map = 1;
2422         }
2423
2424         /* rxq setup */
2425         rxq_init->flags = flags;
2426         rxq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2427         rxq_init->dscr_map = fp->rx_desc_mapping;
2428         rxq_init->sge_map = fp->rx_sge_mapping;
2429         rxq_init->rcq_map = fp->rx_comp_mapping;
2430         rxq_init->rcq_np_map = fp->rx_comp_mapping + BCM_PAGE_SIZE;
2431         rxq_init->mtu = bp->dev->mtu;
2432         rxq_init->buf_sz = bp->rx_buf_size;
2433         rxq_init->cl_qzone_id = fp->cl_qzone_id;
2434         rxq_init->cl_id = fp->cl_id;
2435         rxq_init->spcl_id = fp->cl_id;
2436         rxq_init->stat_id = fp->cl_id;
2437         rxq_init->tpa_agg_sz = tpa_agg_size;
2438         rxq_init->sge_buf_sz = sge_sz;
2439         rxq_init->max_sges_pkt = max_sge;
2440         rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
2441         rxq_init->fw_sb_id = fp->fw_sb_id;
2442
2443         rxq_init->sb_cq_index = U_SB_ETH_RX_CQ_INDEX;
2444
2445         rxq_init->cid = HW_CID(bp, fp->cid);
2446
2447         rxq_init->hc_rate = bp->rx_ticks ? (1000000 / bp->rx_ticks) : 0;
2448 }
2449
2450 static void bnx2x_pf_tx_cl_prep(struct bnx2x *bp,
2451         struct bnx2x_fastpath *fp, struct bnx2x_txq_init_params *txq_init)
2452 {
2453         u16 flags = bnx2x_get_cl_flags(bp, fp);
2454
2455         txq_init->flags = flags;
2456         txq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2457         txq_init->dscr_map = fp->tx_desc_mapping;
2458         txq_init->stat_id = fp->cl_id;
2459         txq_init->cid = HW_CID(bp, fp->cid);
2460         txq_init->sb_cq_index = C_SB_ETH_TX_CQ_INDEX;
2461         txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
2462         txq_init->fw_sb_id = fp->fw_sb_id;
2463         txq_init->hc_rate = bp->tx_ticks ? (1000000 / bp->tx_ticks) : 0;
2464 }
2465
2466 static void bnx2x_pf_init(struct bnx2x *bp)
2467 {
2468         struct bnx2x_func_init_params func_init = {0};
2469         struct bnx2x_rss_params rss = {0};
2470         struct event_ring_data eq_data = { {0} };
2471         u16 flags;
2472
2473         /* pf specific setups */
2474         if (!CHIP_IS_E1(bp))
2475                 storm_memset_ov(bp, bp->mf_ov, BP_FUNC(bp));
2476
2477         if (CHIP_IS_E2(bp)) {
2478                 /* reset IGU PF statistics: MSIX + ATTN */
2479                 /* PF */
2480                 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
2481                            BNX2X_IGU_STAS_MSG_VF_CNT*4 +
2482                            (CHIP_MODE_IS_4_PORT(bp) ?
2483                                 BP_FUNC(bp) : BP_VN(bp))*4, 0);
2484                 /* ATTN */
2485                 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
2486                            BNX2X_IGU_STAS_MSG_VF_CNT*4 +
2487                            BNX2X_IGU_STAS_MSG_PF_CNT*4 +
2488                            (CHIP_MODE_IS_4_PORT(bp) ?
2489                                 BP_FUNC(bp) : BP_VN(bp))*4, 0);
2490         }
2491
2492         /* function setup flags */
2493         flags = (FUNC_FLG_STATS | FUNC_FLG_LEADING | FUNC_FLG_SPQ);
2494
2495         if (CHIP_IS_E1x(bp))
2496                 flags |= (bp->flags & TPA_ENABLE_FLAG) ? FUNC_FLG_TPA : 0;
2497         else
2498                 flags |= FUNC_FLG_TPA;
2499
2500         /* function setup */
2501
2502         /**
2503          * Although RSS is meaningless when there is a single HW queue we
2504          * still need it enabled in order to have HW Rx hash generated.
2505          */
2506         rss.cap = (RSS_IPV4_CAP | RSS_IPV4_TCP_CAP |
2507                    RSS_IPV6_CAP | RSS_IPV6_TCP_CAP);
2508         rss.mode = bp->multi_mode;
2509         rss.result_mask = MULTI_MASK;
2510         func_init.rss = &rss;
2511
2512         func_init.func_flgs = flags;
2513         func_init.pf_id = BP_FUNC(bp);
2514         func_init.func_id = BP_FUNC(bp);
2515         func_init.fw_stat_map = bnx2x_sp_mapping(bp, fw_stats);
2516         func_init.spq_map = bp->spq_mapping;
2517         func_init.spq_prod = bp->spq_prod_idx;
2518
2519         bnx2x_func_init(bp, &func_init);
2520
2521         memset(&(bp->cmng), 0, sizeof(struct cmng_struct_per_port));
2522
2523         /*
2524         Congestion management values depend on the link rate
2525         There is no active link so initial link rate is set to 10 Gbps.
2526         When the link comes up The congestion management values are
2527         re-calculated according to the actual link rate.
2528         */
2529         bp->link_vars.line_speed = SPEED_10000;
2530         bnx2x_cmng_fns_init(bp, true, bnx2x_get_cmng_fns_mode(bp));
2531
2532         /* Only the PMF sets the HW */
2533         if (bp->port.pmf)
2534                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2535
2536         /* no rx until link is up */
2537         bp->rx_mode = BNX2X_RX_MODE_NONE;
2538         bnx2x_set_storm_rx_mode(bp);
2539
2540         /* init Event Queue */
2541         eq_data.base_addr.hi = U64_HI(bp->eq_mapping);
2542         eq_data.base_addr.lo = U64_LO(bp->eq_mapping);
2543         eq_data.producer = bp->eq_prod;
2544         eq_data.index_id = HC_SP_INDEX_EQ_CONS;
2545         eq_data.sb_id = DEF_SB_ID;
2546         storm_memset_eq_data(bp, &eq_data, BP_FUNC(bp));
2547 }
2548
2549
2550 static void bnx2x_e1h_disable(struct bnx2x *bp)
2551 {
2552         int port = BP_PORT(bp);
2553
2554         netif_tx_disable(bp->dev);
2555
2556         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
2557
2558         netif_carrier_off(bp->dev);
2559 }
2560
2561 static void bnx2x_e1h_enable(struct bnx2x *bp)
2562 {
2563         int port = BP_PORT(bp);
2564
2565         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
2566
2567         /* Tx queue should be only reenabled */
2568         netif_tx_wake_all_queues(bp->dev);
2569
2570         /*
2571          * Should not call netif_carrier_on since it will be called if the link
2572          * is up when checking for link state
2573          */
2574 }
2575
2576 static void bnx2x_dcc_event(struct bnx2x *bp, u32 dcc_event)
2577 {
2578         DP(BNX2X_MSG_MCP, "dcc_event 0x%x\n", dcc_event);
2579
2580         if (dcc_event & DRV_STATUS_DCC_DISABLE_ENABLE_PF) {
2581
2582                 /*
2583                  * This is the only place besides the function initialization
2584                  * where the bp->flags can change so it is done without any
2585                  * locks
2586                  */
2587                 if (bp->mf_config[BP_VN(bp)] & FUNC_MF_CFG_FUNC_DISABLED) {
2588                         DP(NETIF_MSG_IFDOWN, "mf_cfg function disabled\n");
2589                         bp->flags |= MF_FUNC_DIS;
2590
2591                         bnx2x_e1h_disable(bp);
2592                 } else {
2593                         DP(NETIF_MSG_IFUP, "mf_cfg function enabled\n");
2594                         bp->flags &= ~MF_FUNC_DIS;
2595
2596                         bnx2x_e1h_enable(bp);
2597                 }
2598                 dcc_event &= ~DRV_STATUS_DCC_DISABLE_ENABLE_PF;
2599         }
2600         if (dcc_event & DRV_STATUS_DCC_BANDWIDTH_ALLOCATION) {
2601
2602                 bnx2x_cmng_fns_init(bp, true, CMNG_FNS_MINMAX);
2603                 bnx2x_link_sync_notify(bp);
2604                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2605                 dcc_event &= ~DRV_STATUS_DCC_BANDWIDTH_ALLOCATION;
2606         }
2607
2608         /* Report results to MCP */
2609         if (dcc_event)
2610                 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_FAILURE, 0);
2611         else
2612                 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_OK, 0);
2613 }
2614
2615 /* must be called under the spq lock */
2616 static inline struct eth_spe *bnx2x_sp_get_next(struct bnx2x *bp)
2617 {
2618         struct eth_spe *next_spe = bp->spq_prod_bd;
2619
2620         if (bp->spq_prod_bd == bp->spq_last_bd) {
2621                 bp->spq_prod_bd = bp->spq;
2622                 bp->spq_prod_idx = 0;
2623                 DP(NETIF_MSG_TIMER, "end of spq\n");
2624         } else {
2625                 bp->spq_prod_bd++;
2626                 bp->spq_prod_idx++;
2627         }
2628         return next_spe;
2629 }
2630
2631 /* must be called under the spq lock */
2632 static inline void bnx2x_sp_prod_update(struct bnx2x *bp)
2633 {
2634         int func = BP_FUNC(bp);
2635
2636         /* Make sure that BD data is updated before writing the producer */
2637         wmb();
2638
2639         REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func),
2640                  bp->spq_prod_idx);
2641         mmiowb();
2642 }
2643
2644 /* the slow path queue is odd since completions arrive on the fastpath ring */
2645 int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
2646                   u32 data_hi, u32 data_lo, int common)
2647 {
2648         struct eth_spe *spe;
2649         u16 type;
2650
2651 #ifdef BNX2X_STOP_ON_ERROR
2652         if (unlikely(bp->panic))
2653                 return -EIO;
2654 #endif
2655
2656         spin_lock_bh(&bp->spq_lock);
2657
2658         if (!atomic_read(&bp->spq_left)) {
2659                 BNX2X_ERR("BUG! SPQ ring full!\n");
2660                 spin_unlock_bh(&bp->spq_lock);
2661                 bnx2x_panic();
2662                 return -EBUSY;
2663         }
2664
2665         spe = bnx2x_sp_get_next(bp);
2666
2667         /* CID needs port number to be encoded int it */
2668         spe->hdr.conn_and_cmd_data =
2669                         cpu_to_le32((command << SPE_HDR_CMD_ID_SHIFT) |
2670                                     HW_CID(bp, cid));
2671
2672         if (common)
2673                 /* Common ramrods:
2674                  *      FUNC_START, FUNC_STOP, CFC_DEL, STATS, SET_MAC
2675                  *      TRAFFIC_STOP, TRAFFIC_START
2676                  */
2677                 type = (NONE_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2678                         & SPE_HDR_CONN_TYPE;
2679         else
2680                 /* ETH ramrods: SETUP, HALT */
2681                 type = (ETH_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2682                         & SPE_HDR_CONN_TYPE;
2683
2684         type |= ((BP_FUNC(bp) << SPE_HDR_FUNCTION_ID_SHIFT) &
2685                  SPE_HDR_FUNCTION_ID);
2686
2687         spe->hdr.type = cpu_to_le16(type);
2688
2689         spe->data.update_data_addr.hi = cpu_to_le32(data_hi);
2690         spe->data.update_data_addr.lo = cpu_to_le32(data_lo);
2691
2692         /* stats ramrod has it's own slot on the spq */
2693         if (command != RAMROD_CMD_ID_COMMON_STAT_QUERY)
2694                 /* It's ok if the actual decrement is issued towards the memory
2695                  * somewhere between the spin_lock and spin_unlock. Thus no
2696                  * more explict memory barrier is needed.
2697                  */
2698                 atomic_dec(&bp->spq_left);
2699
2700         DP(BNX2X_MSG_SP/*NETIF_MSG_TIMER*/,
2701            "SPQE[%x] (%x:%x)  command %d  hw_cid %x  data (%x:%x) "
2702            "type(0x%x) left %x\n",
2703            bp->spq_prod_idx, (u32)U64_HI(bp->spq_mapping),
2704            (u32)(U64_LO(bp->spq_mapping) +
2705            (void *)bp->spq_prod_bd - (void *)bp->spq), command,
2706            HW_CID(bp, cid), data_hi, data_lo, type, atomic_read(&bp->spq_left));
2707
2708         bnx2x_sp_prod_update(bp);
2709         spin_unlock_bh(&bp->spq_lock);
2710         return 0;
2711 }
2712
2713 /* acquire split MCP access lock register */
2714 static int bnx2x_acquire_alr(struct bnx2x *bp)
2715 {
2716         u32 j, val;
2717         int rc = 0;
2718
2719         might_sleep();
2720         for (j = 0; j < 1000; j++) {
2721                 val = (1UL << 31);
2722                 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
2723                 val = REG_RD(bp, GRCBASE_MCP + 0x9c);
2724                 if (val & (1L << 31))
2725                         break;
2726
2727                 msleep(5);
2728         }
2729         if (!(val & (1L << 31))) {
2730                 BNX2X_ERR("Cannot acquire MCP access lock register\n");
2731                 rc = -EBUSY;
2732         }
2733
2734         return rc;
2735 }
2736
2737 /* release split MCP access lock register */
2738 static void bnx2x_release_alr(struct bnx2x *bp)
2739 {
2740         REG_WR(bp, GRCBASE_MCP + 0x9c, 0);
2741 }
2742
2743 #define BNX2X_DEF_SB_ATT_IDX    0x0001
2744 #define BNX2X_DEF_SB_IDX        0x0002
2745
2746 static inline u16 bnx2x_update_dsb_idx(struct bnx2x *bp)
2747 {
2748         struct host_sp_status_block *def_sb = bp->def_status_blk;
2749         u16 rc = 0;
2750
2751         barrier(); /* status block is written to by the chip */
2752         if (bp->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
2753                 bp->def_att_idx = def_sb->atten_status_block.attn_bits_index;
2754                 rc |= BNX2X_DEF_SB_ATT_IDX;
2755         }
2756
2757         if (bp->def_idx != def_sb->sp_sb.running_index) {
2758                 bp->def_idx = def_sb->sp_sb.running_index;
2759                 rc |= BNX2X_DEF_SB_IDX;
2760         }
2761
2762         /* Do not reorder: indecies reading should complete before handling */
2763         barrier();
2764         return rc;
2765 }
2766
2767 /*
2768  * slow path service functions
2769  */
2770
2771 static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
2772 {
2773         int port = BP_PORT(bp);
2774         u32 aeu_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
2775                               MISC_REG_AEU_MASK_ATTN_FUNC_0;
2776         u32 nig_int_mask_addr = port ? NIG_REG_MASK_INTERRUPT_PORT1 :
2777                                        NIG_REG_MASK_INTERRUPT_PORT0;
2778         u32 aeu_mask;
2779         u32 nig_mask = 0;
2780         u32 reg_addr;
2781
2782         if (bp->attn_state & asserted)
2783                 BNX2X_ERR("IGU ERROR\n");
2784
2785         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2786         aeu_mask = REG_RD(bp, aeu_addr);
2787
2788         DP(NETIF_MSG_HW, "aeu_mask %x  newly asserted %x\n",
2789            aeu_mask, asserted);
2790         aeu_mask &= ~(asserted & 0x3ff);
2791         DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
2792
2793         REG_WR(bp, aeu_addr, aeu_mask);
2794         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2795
2796         DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
2797         bp->attn_state |= asserted;
2798         DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
2799
2800         if (asserted & ATTN_HARD_WIRED_MASK) {
2801                 if (asserted & ATTN_NIG_FOR_FUNC) {
2802
2803                         bnx2x_acquire_phy_lock(bp);
2804
2805                         /* save nig interrupt mask */
2806                         nig_mask = REG_RD(bp, nig_int_mask_addr);
2807                         REG_WR(bp, nig_int_mask_addr, 0);
2808
2809                         bnx2x_link_attn(bp);
2810
2811                         /* handle unicore attn? */
2812                 }
2813                 if (asserted & ATTN_SW_TIMER_4_FUNC)
2814                         DP(NETIF_MSG_HW, "ATTN_SW_TIMER_4_FUNC!\n");
2815
2816                 if (asserted & GPIO_2_FUNC)
2817                         DP(NETIF_MSG_HW, "GPIO_2_FUNC!\n");
2818
2819                 if (asserted & GPIO_3_FUNC)
2820                         DP(NETIF_MSG_HW, "GPIO_3_FUNC!\n");
2821
2822                 if (asserted & GPIO_4_FUNC)
2823                         DP(NETIF_MSG_HW, "GPIO_4_FUNC!\n");
2824
2825                 if (port == 0) {
2826                         if (asserted & ATTN_GENERAL_ATTN_1) {
2827                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_1!\n");
2828                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
2829                         }
2830                         if (asserted & ATTN_GENERAL_ATTN_2) {
2831                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_2!\n");
2832                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
2833                         }
2834                         if (asserted & ATTN_GENERAL_ATTN_3) {
2835                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_3!\n");
2836                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
2837                         }
2838                 } else {
2839                         if (asserted & ATTN_GENERAL_ATTN_4) {
2840                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_4!\n");
2841                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
2842                         }
2843                         if (asserted & ATTN_GENERAL_ATTN_5) {
2844                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_5!\n");
2845                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
2846                         }
2847                         if (asserted & ATTN_GENERAL_ATTN_6) {
2848                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_6!\n");
2849                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
2850                         }
2851                 }
2852
2853         } /* if hardwired */
2854
2855         if (bp->common.int_block == INT_BLOCK_HC)
2856                 reg_addr = (HC_REG_COMMAND_REG + port*32 +
2857                             COMMAND_REG_ATTN_BITS_SET);
2858         else
2859                 reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_SET_UPPER*8);
2860
2861         DP(NETIF_MSG_HW, "about to mask 0x%08x at %s addr 0x%x\n", asserted,
2862            (bp->common.int_block == INT_BLOCK_HC) ? "HC" : "IGU", reg_addr);
2863         REG_WR(bp, reg_addr, asserted);
2864
2865         /* now set back the mask */
2866         if (asserted & ATTN_NIG_FOR_FUNC) {
2867                 REG_WR(bp, nig_int_mask_addr, nig_mask);
2868                 bnx2x_release_phy_lock(bp);
2869         }
2870 }
2871
2872 static inline void bnx2x_fan_failure(struct bnx2x *bp)
2873 {
2874         int port = BP_PORT(bp);
2875         u32 ext_phy_config;
2876         /* mark the failure */
2877         ext_phy_config =
2878                 SHMEM_RD(bp,
2879                          dev_info.port_hw_config[port].external_phy_config);
2880
2881         ext_phy_config &= ~PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK;
2882         ext_phy_config |= PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE;
2883         SHMEM_WR(bp, dev_info.port_hw_config[port].external_phy_config,
2884                  ext_phy_config);
2885
2886         /* log the failure */
2887         netdev_err(bp->dev, "Fan Failure on Network Controller has caused"
2888                " the driver to shutdown the card to prevent permanent"
2889                " damage.  Please contact OEM Support for assistance\n");
2890 }
2891
2892 static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
2893 {
2894         int port = BP_PORT(bp);
2895         int reg_offset;
2896         u32 val;
2897
2898         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
2899                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
2900
2901         if (attn & AEU_INPUTS_ATTN_BITS_SPIO5) {
2902
2903                 val = REG_RD(bp, reg_offset);
2904                 val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
2905                 REG_WR(bp, reg_offset, val);
2906
2907                 BNX2X_ERR("SPIO5 hw attention\n");
2908
2909                 /* Fan failure attention */
2910                 bnx2x_hw_reset_phy(&bp->link_params);
2911                 bnx2x_fan_failure(bp);
2912         }
2913
2914         if (attn & (AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0 |
2915                     AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1)) {
2916                 bnx2x_acquire_phy_lock(bp);
2917                 bnx2x_handle_module_detect_int(&bp->link_params);
2918                 bnx2x_release_phy_lock(bp);
2919         }
2920
2921         if (attn & HW_INTERRUT_ASSERT_SET_0) {
2922
2923                 val = REG_RD(bp, reg_offset);
2924                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_0);
2925                 REG_WR(bp, reg_offset, val);
2926
2927                 BNX2X_ERR("FATAL HW block attention set0 0x%x\n",
2928                           (u32)(attn & HW_INTERRUT_ASSERT_SET_0));
2929                 bnx2x_panic();
2930         }
2931 }
2932
2933 static inline void bnx2x_attn_int_deasserted1(struct bnx2x *bp, u32 attn)
2934 {
2935         u32 val;
2936
2937         if (attn & AEU_INPUTS_ATTN_BITS_DOORBELLQ_HW_INTERRUPT) {
2938
2939                 val = REG_RD(bp, DORQ_REG_DORQ_INT_STS_CLR);
2940                 BNX2X_ERR("DB hw attention 0x%x\n", val);
2941                 /* DORQ discard attention */
2942                 if (val & 0x2)
2943                         BNX2X_ERR("FATAL error from DORQ\n");
2944         }
2945
2946         if (attn & HW_INTERRUT_ASSERT_SET_1) {
2947
2948                 int port = BP_PORT(bp);
2949                 int reg_offset;
2950
2951                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_1 :
2952                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_1);
2953
2954                 val = REG_RD(bp, reg_offset);
2955                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
2956                 REG_WR(bp, reg_offset, val);
2957
2958                 BNX2X_ERR("FATAL HW block attention set1 0x%x\n",
2959                           (u32)(attn & HW_INTERRUT_ASSERT_SET_1));
2960                 bnx2x_panic();
2961         }
2962 }
2963
2964 static inline void bnx2x_attn_int_deasserted2(struct bnx2x *bp, u32 attn)
2965 {
2966         u32 val;
2967
2968         if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
2969
2970                 val = REG_RD(bp, CFC_REG_CFC_INT_STS_CLR);
2971                 BNX2X_ERR("CFC hw attention 0x%x\n", val);
2972                 /* CFC error attention */
2973                 if (val & 0x2)
2974                         BNX2X_ERR("FATAL error from CFC\n");
2975         }
2976
2977         if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
2978
2979                 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_0);
2980                 BNX2X_ERR("PXP hw attention 0x%x\n", val);
2981                 /* RQ_USDMDP_FIFO_OVERFLOW */
2982                 if (val & 0x18000)
2983                         BNX2X_ERR("FATAL error from PXP\n");
2984                 if (CHIP_IS_E2(bp)) {
2985                         val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_1);
2986                         BNX2X_ERR("PXP hw attention-1 0x%x\n", val);
2987                 }
2988         }
2989
2990         if (attn & HW_INTERRUT_ASSERT_SET_2) {
2991
2992                 int port = BP_PORT(bp);
2993                 int reg_offset;
2994
2995                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_2 :
2996                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_2);
2997
2998                 val = REG_RD(bp, reg_offset);
2999                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
3000                 REG_WR(bp, reg_offset, val);
3001
3002                 BNX2X_ERR("FATAL HW block attention set2 0x%x\n",
3003                           (u32)(attn & HW_INTERRUT_ASSERT_SET_2));
3004                 bnx2x_panic();
3005         }
3006 }
3007
3008 static inline void bnx2x_attn_int_deasserted3(struct bnx2x *bp, u32 attn)
3009 {
3010         u32 val;
3011
3012         if (attn & EVEREST_GEN_ATTN_IN_USE_MASK) {
3013
3014                 if (attn & BNX2X_PMF_LINK_ASSERT) {
3015                         int func = BP_FUNC(bp);
3016
3017                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
3018                         bp->mf_config[BP_VN(bp)] = MF_CFG_RD(bp,
3019                                         func_mf_config[BP_ABS_FUNC(bp)].config);
3020                         val = SHMEM_RD(bp,
3021                                        func_mb[BP_FW_MB_IDX(bp)].drv_status);
3022                         if (val & DRV_STATUS_DCC_EVENT_MASK)
3023                                 bnx2x_dcc_event(bp,
3024                                             (val & DRV_STATUS_DCC_EVENT_MASK));
3025                         bnx2x__link_status_update(bp);
3026                         if ((bp->port.pmf == 0) && (val & DRV_STATUS_PMF))
3027                                 bnx2x_pmf_update(bp);
3028
3029                 } else if (attn & BNX2X_MC_ASSERT_BITS) {
3030
3031                         BNX2X_ERR("MC assert!\n");
3032                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_10, 0);
3033                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_9, 0);
3034                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_8, 0);
3035                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_7, 0);
3036                         bnx2x_panic();
3037
3038                 } else if (attn & BNX2X_MCP_ASSERT) {
3039
3040                         BNX2X_ERR("MCP assert!\n");
3041                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_11, 0);
3042                         bnx2x_fw_dump(bp);
3043
3044                 } else
3045                         BNX2X_ERR("Unknown HW assert! (attn 0x%x)\n", attn);
3046         }
3047
3048         if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
3049                 BNX2X_ERR("LATCHED attention 0x%08x (masked)\n", attn);
3050                 if (attn & BNX2X_GRC_TIMEOUT) {
3051                         val = CHIP_IS_E1(bp) ? 0 :
3052                                         REG_RD(bp, MISC_REG_GRC_TIMEOUT_ATTN);
3053                         BNX2X_ERR("GRC time-out 0x%08x\n", val);
3054                 }
3055                 if (attn & BNX2X_GRC_RSV) {
3056                         val = CHIP_IS_E1(bp) ? 0 :
3057                                         REG_RD(bp, MISC_REG_GRC_RSV_ATTN);
3058                         BNX2X_ERR("GRC reserved 0x%08x\n", val);
3059                 }
3060                 REG_WR(bp, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
3061         }
3062 }
3063
3064 #define BNX2X_MISC_GEN_REG      MISC_REG_GENERIC_POR_1
3065 #define LOAD_COUNTER_BITS       16 /* Number of bits for load counter */
3066 #define LOAD_COUNTER_MASK       (((u32)0x1 << LOAD_COUNTER_BITS) - 1)
3067 #define RESET_DONE_FLAG_MASK    (~LOAD_COUNTER_MASK)
3068 #define RESET_DONE_FLAG_SHIFT   LOAD_COUNTER_BITS
3069 #define CHIP_PARITY_SUPPORTED(bp)   (CHIP_IS_E1(bp) || CHIP_IS_E1H(bp))
3070
3071 /*
3072  * should be run under rtnl lock
3073  */
3074 static inline void bnx2x_set_reset_done(struct bnx2x *bp)
3075 {
3076         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3077         val &= ~(1 << RESET_DONE_FLAG_SHIFT);
3078         REG_WR(bp, BNX2X_MISC_GEN_REG, val);
3079         barrier();
3080         mmiowb();
3081 }
3082
3083 /*
3084  * should be run under rtnl lock
3085  */
3086 static inline void bnx2x_set_reset_in_progress(struct bnx2x *bp)
3087 {
3088         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3089         val |= (1 << 16);
3090         REG_WR(bp, BNX2X_MISC_GEN_REG, val);
3091         barrier();
3092         mmiowb();
3093 }
3094
3095 /*
3096  * should be run under rtnl lock
3097  */
3098 bool bnx2x_reset_is_done(struct bnx2x *bp)
3099 {
3100         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3101         DP(NETIF_MSG_HW, "GEN_REG_VAL=0x%08x\n", val);
3102         return (val & RESET_DONE_FLAG_MASK) ? false : true;
3103 }
3104
3105 /*
3106  * should be run under rtnl lock
3107  */
3108 inline void bnx2x_inc_load_cnt(struct bnx2x *bp)
3109 {
3110         u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3111
3112         DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
3113
3114         val1 = ((val & LOAD_COUNTER_MASK) + 1) & LOAD_COUNTER_MASK;
3115         REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
3116         barrier();
3117         mmiowb();
3118 }
3119
3120 /*
3121  * should be run under rtnl lock
3122  */
3123 u32 bnx2x_dec_load_cnt(struct bnx2x *bp)
3124 {
3125         u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3126
3127         DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
3128
3129         val1 = ((val & LOAD_COUNTER_MASK) - 1) & LOAD_COUNTER_MASK;
3130         REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
3131         barrier();
3132         mmiowb();
3133
3134         return val1;
3135 }
3136
3137 /*
3138  * should be run under rtnl lock
3139  */
3140 static inline u32 bnx2x_get_load_cnt(struct bnx2x *bp)
3141 {
3142         return REG_RD(bp, BNX2X_MISC_GEN_REG) & LOAD_COUNTER_MASK;
3143 }
3144
3145 static inline void bnx2x_clear_load_cnt(struct bnx2x *bp)
3146 {
3147         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3148         REG_WR(bp, BNX2X_MISC_GEN_REG, val & (~LOAD_COUNTER_MASK));
3149 }
3150
3151 static inline void _print_next_block(int idx, const char *blk)
3152 {
3153         if (idx)
3154                 pr_cont(", ");
3155         pr_cont("%s", blk);
3156 }
3157
3158 static inline int bnx2x_print_blocks_with_parity0(u32 sig, int par_num)
3159 {
3160         int i = 0;
3161         u32 cur_bit = 0;
3162         for (i = 0; sig; i++) {
3163                 cur_bit = ((u32)0x1 << i);
3164                 if (sig & cur_bit) {
3165                         switch (cur_bit) {
3166                         case AEU_INPUTS_ATTN_BITS_BRB_PARITY_ERROR:
3167                                 _print_next_block(par_num++, "BRB");
3168                                 break;
3169                         case AEU_INPUTS_ATTN_BITS_PARSER_PARITY_ERROR:
3170                                 _print_next_block(par_num++, "PARSER");
3171                                 break;
3172                         case AEU_INPUTS_ATTN_BITS_TSDM_PARITY_ERROR:
3173                                 _print_next_block(par_num++, "TSDM");
3174                                 break;
3175                         case AEU_INPUTS_ATTN_BITS_SEARCHER_PARITY_ERROR:
3176                                 _print_next_block(par_num++, "SEARCHER");
3177                                 break;
3178                         case AEU_INPUTS_ATTN_BITS_TSEMI_PARITY_ERROR:
3179                                 _print_next_block(par_num++, "TSEMI");
3180                                 break;
3181                         }
3182
3183                         /* Clear the bit */
3184                         sig &= ~cur_bit;
3185                 }
3186         }
3187
3188         return par_num;
3189 }
3190
3191 static inline int bnx2x_print_blocks_with_parity1(u32 sig, int par_num)
3192 {
3193         int i = 0;
3194         u32 cur_bit = 0;
3195         for (i = 0; sig; i++) {
3196                 cur_bit = ((u32)0x1 << i);
3197                 if (sig & cur_bit) {
3198                         switch (cur_bit) {
3199                         case AEU_INPUTS_ATTN_BITS_PBCLIENT_PARITY_ERROR:
3200                                 _print_next_block(par_num++, "PBCLIENT");
3201                                 break;
3202                         case AEU_INPUTS_ATTN_BITS_QM_PARITY_ERROR:
3203                                 _print_next_block(par_num++, "QM");
3204                                 break;
3205                         case AEU_INPUTS_ATTN_BITS_XSDM_PARITY_ERROR:
3206                                 _print_next_block(par_num++, "XSDM");