bnx2x: Add 57712 support
[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
60 #include <linux/firmware.h>
61 #include "bnx2x_fw_file_hdr.h"
62 /* FW files */
63 #define FW_FILE_VERSION                                 \
64         __stringify(BCM_5710_FW_MAJOR_VERSION) "."      \
65         __stringify(BCM_5710_FW_MINOR_VERSION) "."      \
66         __stringify(BCM_5710_FW_REVISION_VERSION) "."   \
67         __stringify(BCM_5710_FW_ENGINEERING_VERSION)
68 #define FW_FILE_NAME_E1         "bnx2x/bnx2x-e1-" FW_FILE_VERSION ".fw"
69 #define FW_FILE_NAME_E1H        "bnx2x/bnx2x-e1h-" FW_FILE_VERSION ".fw"
70 #define FW_FILE_NAME_E2         "bnx2x/bnx2x-e2-" FW_FILE_VERSION ".fw"
71
72 /* Time in jiffies before concluding the transmitter is hung */
73 #define TX_TIMEOUT              (5*HZ)
74
75 static char version[] __devinitdata =
76         "Broadcom NetXtreme II 5771x 10Gigabit Ethernet Driver "
77         DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
78
79 MODULE_AUTHOR("Eliezer Tamir");
80 MODULE_DESCRIPTION("Broadcom NetXtreme II "
81                    "BCM57710/57711/57711E/57712/57712E Driver");
82 MODULE_LICENSE("GPL");
83 MODULE_VERSION(DRV_MODULE_VERSION);
84 MODULE_FIRMWARE(FW_FILE_NAME_E1);
85 MODULE_FIRMWARE(FW_FILE_NAME_E1H);
86 MODULE_FIRMWARE(FW_FILE_NAME_E2);
87
88 static int multi_mode = 1;
89 module_param(multi_mode, int, 0);
90 MODULE_PARM_DESC(multi_mode, " Multi queue mode "
91                              "(0 Disable; 1 Enable (default))");
92
93 static int num_queues;
94 module_param(num_queues, int, 0);
95 MODULE_PARM_DESC(num_queues, " Number of queues for multi_mode=1"
96                                 " (default is as a number of CPUs)");
97
98 static int disable_tpa;
99 module_param(disable_tpa, int, 0);
100 MODULE_PARM_DESC(disable_tpa, " Disable the TPA (LRO) feature");
101
102 static int int_mode;
103 module_param(int_mode, int, 0);
104 MODULE_PARM_DESC(int_mode, " Force interrupt mode other then MSI-X "
105                                 "(1 INT#x; 2 MSI)");
106
107 static int dropless_fc;
108 module_param(dropless_fc, int, 0);
109 MODULE_PARM_DESC(dropless_fc, " Pause on exhausted host ring");
110
111 static int poll;
112 module_param(poll, int, 0);
113 MODULE_PARM_DESC(poll, " Use polling (for debug)");
114
115 static int mrrs = -1;
116 module_param(mrrs, int, 0);
117 MODULE_PARM_DESC(mrrs, " Force Max Read Req Size (0..3) (for debug)");
118
119 static int debug;
120 module_param(debug, int, 0);
121 MODULE_PARM_DESC(debug, " Default debug msglevel");
122
123 static struct workqueue_struct *bnx2x_wq;
124
125 enum bnx2x_board_type {
126         BCM57710 = 0,
127         BCM57711 = 1,
128         BCM57711E = 2,
129         BCM57712 = 3,
130         BCM57712E = 4
131 };
132
133 /* indexed by board_type, above */
134 static struct {
135         char *name;
136 } board_info[] __devinitdata = {
137         { "Broadcom NetXtreme II BCM57710 XGb" },
138         { "Broadcom NetXtreme II BCM57711 XGb" },
139         { "Broadcom NetXtreme II BCM57711E XGb" },
140         { "Broadcom NetXtreme II BCM57712 XGb" },
141         { "Broadcom NetXtreme II BCM57712E XGb" }
142 };
143
144 #ifndef PCI_DEVICE_ID_NX2_57712
145 #define PCI_DEVICE_ID_NX2_57712         0x1662
146 #endif
147 #ifndef PCI_DEVICE_ID_NX2_57712E
148 #define PCI_DEVICE_ID_NX2_57712E        0x1663
149 #endif
150
151 static DEFINE_PCI_DEVICE_TABLE(bnx2x_pci_tbl) = {
152         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57710), BCM57710 },
153         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711), BCM57711 },
154         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711E), BCM57711E },
155         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712), BCM57712 },
156         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712E), BCM57712E },
157         { 0 }
158 };
159
160 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
161
162 /****************************************************************************
163 * General service functions
164 ****************************************************************************/
165
166 static inline void __storm_memset_dma_mapping(struct bnx2x *bp,
167                                        u32 addr, dma_addr_t mapping)
168 {
169         REG_WR(bp,  addr, U64_LO(mapping));
170         REG_WR(bp,  addr + 4, U64_HI(mapping));
171 }
172
173 static inline void __storm_memset_fill(struct bnx2x *bp,
174                                        u32 addr, size_t size, u32 val)
175 {
176         int i;
177         for (i = 0; i < size/4; i++)
178                 REG_WR(bp,  addr + (i * 4), val);
179 }
180
181 static inline void storm_memset_ustats_zero(struct bnx2x *bp,
182                                             u8 port, u16 stat_id)
183 {
184         size_t size = sizeof(struct ustorm_per_client_stats);
185
186         u32 addr = BAR_USTRORM_INTMEM +
187                         USTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
188
189         __storm_memset_fill(bp, addr, size, 0);
190 }
191
192 static inline void storm_memset_tstats_zero(struct bnx2x *bp,
193                                             u8 port, u16 stat_id)
194 {
195         size_t size = sizeof(struct tstorm_per_client_stats);
196
197         u32 addr = BAR_TSTRORM_INTMEM +
198                         TSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
199
200         __storm_memset_fill(bp, addr, size, 0);
201 }
202
203 static inline void storm_memset_xstats_zero(struct bnx2x *bp,
204                                             u8 port, u16 stat_id)
205 {
206         size_t size = sizeof(struct xstorm_per_client_stats);
207
208         u32 addr = BAR_XSTRORM_INTMEM +
209                         XSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
210
211         __storm_memset_fill(bp, addr, size, 0);
212 }
213
214
215 static inline void storm_memset_spq_addr(struct bnx2x *bp,
216                                          dma_addr_t mapping, u16 abs_fid)
217 {
218         u32 addr = XSEM_REG_FAST_MEMORY +
219                         XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid);
220
221         __storm_memset_dma_mapping(bp, addr, mapping);
222 }
223
224 static inline void storm_memset_ov(struct bnx2x *bp, u16 ov, u16 abs_fid)
225 {
226         REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_E1HOV_OFFSET(abs_fid), ov);
227 }
228
229 static inline void storm_memset_func_cfg(struct bnx2x *bp,
230                                 struct tstorm_eth_function_common_config *tcfg,
231                                 u16 abs_fid)
232 {
233         size_t size = sizeof(struct tstorm_eth_function_common_config);
234
235         u32 addr = BAR_TSTRORM_INTMEM +
236                         TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid);
237
238         __storm_memset_struct(bp, addr, size, (u32 *)tcfg);
239 }
240
241 static inline void storm_memset_xstats_flags(struct bnx2x *bp,
242                                 struct stats_indication_flags *flags,
243                                 u16 abs_fid)
244 {
245         size_t size = sizeof(struct stats_indication_flags);
246
247         u32 addr = BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(abs_fid);
248
249         __storm_memset_struct(bp, addr, size, (u32 *)flags);
250 }
251
252 static inline void storm_memset_tstats_flags(struct bnx2x *bp,
253                                 struct stats_indication_flags *flags,
254                                 u16 abs_fid)
255 {
256         size_t size = sizeof(struct stats_indication_flags);
257
258         u32 addr = BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(abs_fid);
259
260         __storm_memset_struct(bp, addr, size, (u32 *)flags);
261 }
262
263 static inline void storm_memset_ustats_flags(struct bnx2x *bp,
264                                 struct stats_indication_flags *flags,
265                                 u16 abs_fid)
266 {
267         size_t size = sizeof(struct stats_indication_flags);
268
269         u32 addr = BAR_USTRORM_INTMEM + USTORM_STATS_FLAGS_OFFSET(abs_fid);
270
271         __storm_memset_struct(bp, addr, size, (u32 *)flags);
272 }
273
274 static inline void storm_memset_cstats_flags(struct bnx2x *bp,
275                                 struct stats_indication_flags *flags,
276                                 u16 abs_fid)
277 {
278         size_t size = sizeof(struct stats_indication_flags);
279
280         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(abs_fid);
281
282         __storm_memset_struct(bp, addr, size, (u32 *)flags);
283 }
284
285 static inline void storm_memset_xstats_addr(struct bnx2x *bp,
286                                            dma_addr_t mapping, u16 abs_fid)
287 {
288         u32 addr = BAR_XSTRORM_INTMEM +
289                 XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
290
291         __storm_memset_dma_mapping(bp, addr, mapping);
292 }
293
294 static inline void storm_memset_tstats_addr(struct bnx2x *bp,
295                                            dma_addr_t mapping, u16 abs_fid)
296 {
297         u32 addr = BAR_TSTRORM_INTMEM +
298                 TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
299
300         __storm_memset_dma_mapping(bp, addr, mapping);
301 }
302
303 static inline void storm_memset_ustats_addr(struct bnx2x *bp,
304                                            dma_addr_t mapping, u16 abs_fid)
305 {
306         u32 addr = BAR_USTRORM_INTMEM +
307                 USTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
308
309         __storm_memset_dma_mapping(bp, addr, mapping);
310 }
311
312 static inline void storm_memset_cstats_addr(struct bnx2x *bp,
313                                            dma_addr_t mapping, u16 abs_fid)
314 {
315         u32 addr = BAR_CSTRORM_INTMEM +
316                 CSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
317
318         __storm_memset_dma_mapping(bp, addr, mapping);
319 }
320
321 static inline void storm_memset_vf_to_pf(struct bnx2x *bp, u16 abs_fid,
322                                          u16 pf_id)
323 {
324         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid),
325                 pf_id);
326         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid),
327                 pf_id);
328         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid),
329                 pf_id);
330         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid),
331                 pf_id);
332 }
333
334 static inline void storm_memset_func_en(struct bnx2x *bp, u16 abs_fid,
335                                         u8 enable)
336 {
337         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid),
338                 enable);
339         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid),
340                 enable);
341         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid),
342                 enable);
343         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid),
344                 enable);
345 }
346
347 static inline void storm_memset_eq_data(struct bnx2x *bp,
348                                 struct event_ring_data *eq_data,
349                                 u16 pfid)
350 {
351         size_t size = sizeof(struct event_ring_data);
352
353         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_DATA_OFFSET(pfid);
354
355         __storm_memset_struct(bp, addr, size, (u32 *)eq_data);
356 }
357
358 static inline void storm_memset_eq_prod(struct bnx2x *bp, u16 eq_prod,
359                                         u16 pfid)
360 {
361         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_PROD_OFFSET(pfid);
362         REG_WR16(bp, addr, eq_prod);
363 }
364
365 static inline void storm_memset_hc_timeout(struct bnx2x *bp, u8 port,
366                                              u16 fw_sb_id, u8 sb_index,
367                                              u8 ticks)
368 {
369
370         int index_offset = CHIP_IS_E2(bp) ?
371                 offsetof(struct hc_status_block_data_e2, index_data) :
372                 offsetof(struct hc_status_block_data_e1x, index_data);
373         u32 addr = BAR_CSTRORM_INTMEM +
374                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
375                         index_offset +
376                         sizeof(struct hc_index_data)*sb_index +
377                         offsetof(struct hc_index_data, timeout);
378         REG_WR8(bp, addr, ticks);
379         DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d ticks %d\n",
380                           port, fw_sb_id, sb_index, ticks);
381 }
382 static inline void storm_memset_hc_disable(struct bnx2x *bp, u8 port,
383                                              u16 fw_sb_id, u8 sb_index,
384                                              u8 disable)
385 {
386         u32 enable_flag = disable ? 0 : (1 << HC_INDEX_DATA_HC_ENABLED_SHIFT);
387         int index_offset = CHIP_IS_E2(bp) ?
388                 offsetof(struct hc_status_block_data_e2, index_data) :
389                 offsetof(struct hc_status_block_data_e1x, index_data);
390         u32 addr = BAR_CSTRORM_INTMEM +
391                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
392                         index_offset +
393                         sizeof(struct hc_index_data)*sb_index +
394                         offsetof(struct hc_index_data, flags);
395         u16 flags = REG_RD16(bp, addr);
396         /* clear and set */
397         flags &= ~HC_INDEX_DATA_HC_ENABLED;
398         flags |= enable_flag;
399         REG_WR16(bp, addr, flags);
400         DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d disable %d\n",
401                           port, fw_sb_id, sb_index, disable);
402 }
403
404 /* used only at init
405  * locking is done by mcp
406  */
407 void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
408 {
409         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
410         pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
411         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
412                                PCICFG_VENDOR_ID_OFFSET);
413 }
414
415 static u32 bnx2x_reg_rd_ind(struct bnx2x *bp, u32 addr)
416 {
417         u32 val;
418
419         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
420         pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
421         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
422                                PCICFG_VENDOR_ID_OFFSET);
423
424         return val;
425 }
426
427 #define DMAE_DP_SRC_GRC         "grc src_addr [%08x]"
428 #define DMAE_DP_SRC_PCI         "pci src_addr [%x:%08x]"
429 #define DMAE_DP_DST_GRC         "grc dst_addr [%08x]"
430 #define DMAE_DP_DST_PCI         "pci dst_addr [%x:%08x]"
431 #define DMAE_DP_DST_NONE        "dst_addr [none]"
432
433 void bnx2x_dp_dmae(struct bnx2x *bp, struct dmae_command *dmae, 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 void bnx2x_prep_dmae_with_comp(struct bnx2x *bp, struct dmae_command *dmae,
556                                u8 src_type, u8 dst_type)
557 {
558         memset(dmae, 0, sizeof(struct dmae_command));
559
560         /* set the opcode */
561         dmae->opcode = bnx2x_dmae_opcode(bp, src_type, dst_type,
562                                          true, DMAE_COMP_PCI);
563
564         /* fill in the completion parameters */
565         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
566         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
567         dmae->comp_val = DMAE_COMP_VAL;
568 }
569
570 /* issue a dmae command over the init-channel and wailt for completion */
571 int bnx2x_issue_dmae_with_comp(struct bnx2x *bp, struct dmae_command *dmae)
572 {
573         u32 *wb_comp = bnx2x_sp(bp, wb_comp);
574         int cnt = CHIP_REV_IS_SLOW(bp) ? (400000) : 40;
575         int rc = 0;
576
577         DP(BNX2X_MSG_OFF, "data before [0x%08x 0x%08x 0x%08x 0x%08x]\n",
578            bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
579            bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
580
581         /* lock the dmae channel */
582         mutex_lock(&bp->dmae_mutex);
583
584         /* reset completion */
585         *wb_comp = 0;
586
587         /* post the command on the channel used for initializations */
588         bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
589
590         /* wait for completion */
591         udelay(5);
592         while ((*wb_comp & ~DMAE_PCI_ERR_FLAG) != DMAE_COMP_VAL) {
593                 DP(BNX2X_MSG_OFF, "wb_comp 0x%08x\n", *wb_comp);
594
595                 if (!cnt) {
596                         BNX2X_ERR("DMAE timeout!\n");
597                         rc = DMAE_TIMEOUT;
598                         goto unlock;
599                 }
600                 cnt--;
601                 udelay(50);
602         }
603         if (*wb_comp & DMAE_PCI_ERR_FLAG) {
604                 BNX2X_ERR("DMAE PCI error!\n");
605                 rc = DMAE_PCI_ERROR;
606         }
607
608         DP(BNX2X_MSG_OFF, "data after [0x%08x 0x%08x 0x%08x 0x%08x]\n",
609            bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
610            bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
611
612 unlock:
613         mutex_unlock(&bp->dmae_mutex);
614         return rc;
615 }
616
617 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr, u32 dst_addr,
618                       u32 len32)
619 {
620         struct dmae_command dmae;
621
622         if (!bp->dmae_ready) {
623                 u32 *data = bnx2x_sp(bp, wb_data[0]);
624
625                 DP(BNX2X_MSG_OFF, "DMAE is not ready (dst_addr %08x  len32 %d)"
626                    "  using indirect\n", dst_addr, len32);
627                 bnx2x_init_ind_wr(bp, dst_addr, data, len32);
628                 return;
629         }
630
631         /* set opcode and fixed command fields */
632         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_GRC);
633
634         /* fill in addresses and len */
635         dmae.src_addr_lo = U64_LO(dma_addr);
636         dmae.src_addr_hi = U64_HI(dma_addr);
637         dmae.dst_addr_lo = dst_addr >> 2;
638         dmae.dst_addr_hi = 0;
639         dmae.len = len32;
640
641         bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_OFF);
642
643         /* issue the command and wait for completion */
644         bnx2x_issue_dmae_with_comp(bp, &dmae);
645 }
646
647 void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32)
648 {
649         struct dmae_command dmae;
650
651         if (!bp->dmae_ready) {
652                 u32 *data = bnx2x_sp(bp, wb_data[0]);
653                 int i;
654
655                 DP(BNX2X_MSG_OFF, "DMAE is not ready (src_addr %08x  len32 %d)"
656                    "  using indirect\n", src_addr, len32);
657                 for (i = 0; i < len32; i++)
658                         data[i] = bnx2x_reg_rd_ind(bp, src_addr + i*4);
659                 return;
660         }
661
662         /* set opcode and fixed command fields */
663         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_GRC, DMAE_DST_PCI);
664
665         /* fill in addresses and len */
666         dmae.src_addr_lo = src_addr >> 2;
667         dmae.src_addr_hi = 0;
668         dmae.dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_data));
669         dmae.dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_data));
670         dmae.len = len32;
671
672         bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_OFF);
673
674         /* issue the command and wait for completion */
675         bnx2x_issue_dmae_with_comp(bp, &dmae);
676 }
677
678 void bnx2x_write_dmae_phys_len(struct bnx2x *bp, dma_addr_t phys_addr,
679                                u32 addr, u32 len)
680 {
681         int dmae_wr_max = DMAE_LEN32_WR_MAX(bp);
682         int offset = 0;
683
684         while (len > dmae_wr_max) {
685                 bnx2x_write_dmae(bp, phys_addr + offset,
686                                  addr + offset, dmae_wr_max);
687                 offset += dmae_wr_max * 4;
688                 len -= dmae_wr_max;
689         }
690
691         bnx2x_write_dmae(bp, phys_addr + offset, addr + offset, len);
692 }
693
694 /* used only for slowpath so not inlined */
695 static void bnx2x_wb_wr(struct bnx2x *bp, int reg, u32 val_hi, u32 val_lo)
696 {
697         u32 wb_write[2];
698
699         wb_write[0] = val_hi;
700         wb_write[1] = val_lo;
701         REG_WR_DMAE(bp, reg, wb_write, 2);
702 }
703
704 #ifdef USE_WB_RD
705 static u64 bnx2x_wb_rd(struct bnx2x *bp, int reg)
706 {
707         u32 wb_data[2];
708
709         REG_RD_DMAE(bp, reg, wb_data, 2);
710
711         return HILO_U64(wb_data[0], wb_data[1]);
712 }
713 #endif
714
715 static int bnx2x_mc_assert(struct bnx2x *bp)
716 {
717         char last_idx;
718         int i, rc = 0;
719         u32 row0, row1, row2, row3;
720
721         /* XSTORM */
722         last_idx = REG_RD8(bp, BAR_XSTRORM_INTMEM +
723                            XSTORM_ASSERT_LIST_INDEX_OFFSET);
724         if (last_idx)
725                 BNX2X_ERR("XSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
726
727         /* print the asserts */
728         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
729
730                 row0 = REG_RD(bp, BAR_XSTRORM_INTMEM +
731                               XSTORM_ASSERT_LIST_OFFSET(i));
732                 row1 = REG_RD(bp, BAR_XSTRORM_INTMEM +
733                               XSTORM_ASSERT_LIST_OFFSET(i) + 4);
734                 row2 = REG_RD(bp, BAR_XSTRORM_INTMEM +
735                               XSTORM_ASSERT_LIST_OFFSET(i) + 8);
736                 row3 = REG_RD(bp, BAR_XSTRORM_INTMEM +
737                               XSTORM_ASSERT_LIST_OFFSET(i) + 12);
738
739                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
740                         BNX2X_ERR("XSTORM_ASSERT_INDEX 0x%x = 0x%08x"
741                                   " 0x%08x 0x%08x 0x%08x\n",
742                                   i, row3, row2, row1, row0);
743                         rc++;
744                 } else {
745                         break;
746                 }
747         }
748
749         /* TSTORM */
750         last_idx = REG_RD8(bp, BAR_TSTRORM_INTMEM +
751                            TSTORM_ASSERT_LIST_INDEX_OFFSET);
752         if (last_idx)
753                 BNX2X_ERR("TSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
754
755         /* print the asserts */
756         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
757
758                 row0 = REG_RD(bp, BAR_TSTRORM_INTMEM +
759                               TSTORM_ASSERT_LIST_OFFSET(i));
760                 row1 = REG_RD(bp, BAR_TSTRORM_INTMEM +
761                               TSTORM_ASSERT_LIST_OFFSET(i) + 4);
762                 row2 = REG_RD(bp, BAR_TSTRORM_INTMEM +
763                               TSTORM_ASSERT_LIST_OFFSET(i) + 8);
764                 row3 = REG_RD(bp, BAR_TSTRORM_INTMEM +
765                               TSTORM_ASSERT_LIST_OFFSET(i) + 12);
766
767                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
768                         BNX2X_ERR("TSTORM_ASSERT_INDEX 0x%x = 0x%08x"
769                                   " 0x%08x 0x%08x 0x%08x\n",
770                                   i, row3, row2, row1, row0);
771                         rc++;
772                 } else {
773                         break;
774                 }
775         }
776
777         /* CSTORM */
778         last_idx = REG_RD8(bp, BAR_CSTRORM_INTMEM +
779                            CSTORM_ASSERT_LIST_INDEX_OFFSET);
780         if (last_idx)
781                 BNX2X_ERR("CSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
782
783         /* print the asserts */
784         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
785
786                 row0 = REG_RD(bp, BAR_CSTRORM_INTMEM +
787                               CSTORM_ASSERT_LIST_OFFSET(i));
788                 row1 = REG_RD(bp, BAR_CSTRORM_INTMEM +
789                               CSTORM_ASSERT_LIST_OFFSET(i) + 4);
790                 row2 = REG_RD(bp, BAR_CSTRORM_INTMEM +
791                               CSTORM_ASSERT_LIST_OFFSET(i) + 8);
792                 row3 = REG_RD(bp, BAR_CSTRORM_INTMEM +
793                               CSTORM_ASSERT_LIST_OFFSET(i) + 12);
794
795                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
796                         BNX2X_ERR("CSTORM_ASSERT_INDEX 0x%x = 0x%08x"
797                                   " 0x%08x 0x%08x 0x%08x\n",
798                                   i, row3, row2, row1, row0);
799                         rc++;
800                 } else {
801                         break;
802                 }
803         }
804
805         /* USTORM */
806         last_idx = REG_RD8(bp, BAR_USTRORM_INTMEM +
807                            USTORM_ASSERT_LIST_INDEX_OFFSET);
808         if (last_idx)
809                 BNX2X_ERR("USTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
810
811         /* print the asserts */
812         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
813
814                 row0 = REG_RD(bp, BAR_USTRORM_INTMEM +
815                               USTORM_ASSERT_LIST_OFFSET(i));
816                 row1 = REG_RD(bp, BAR_USTRORM_INTMEM +
817                               USTORM_ASSERT_LIST_OFFSET(i) + 4);
818                 row2 = REG_RD(bp, BAR_USTRORM_INTMEM +
819                               USTORM_ASSERT_LIST_OFFSET(i) + 8);
820                 row3 = REG_RD(bp, BAR_USTRORM_INTMEM +
821                               USTORM_ASSERT_LIST_OFFSET(i) + 12);
822
823                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
824                         BNX2X_ERR("USTORM_ASSERT_INDEX 0x%x = 0x%08x"
825                                   " 0x%08x 0x%08x 0x%08x\n",
826                                   i, row3, row2, row1, row0);
827                         rc++;
828                 } else {
829                         break;
830                 }
831         }
832
833         return rc;
834 }
835
836 static void bnx2x_fw_dump(struct bnx2x *bp)
837 {
838         u32 addr;
839         u32 mark, offset;
840         __be32 data[9];
841         int word;
842         u32 trace_shmem_base;
843         if (BP_NOMCP(bp)) {
844                 BNX2X_ERR("NO MCP - can not dump\n");
845                 return;
846         }
847
848         if (BP_PATH(bp) == 0)
849                 trace_shmem_base = bp->common.shmem_base;
850         else
851                 trace_shmem_base = SHMEM2_RD(bp, other_shmem_base_addr);
852         addr = trace_shmem_base - 0x0800 + 4;
853         mark = REG_RD(bp, addr);
854         mark = (CHIP_IS_E1x(bp) ? MCP_REG_MCPR_SCRATCH : MCP_A_REG_MCPR_SCRATCH)
855                         + ((mark + 0x3) & ~0x3) - 0x08000000;
856         pr_err("begin fw dump (mark 0x%x)\n", mark);
857
858         pr_err("");
859         for (offset = mark; offset <= trace_shmem_base; offset += 0x8*4) {
860                 for (word = 0; word < 8; word++)
861                         data[word] = htonl(REG_RD(bp, offset + 4*word));
862                 data[8] = 0x0;
863                 pr_cont("%s", (char *)data);
864         }
865         for (offset = addr + 4; offset <= mark; offset += 0x8*4) {
866                 for (word = 0; word < 8; word++)
867                         data[word] = htonl(REG_RD(bp, offset + 4*word));
868                 data[8] = 0x0;
869                 pr_cont("%s", (char *)data);
870         }
871         pr_err("end of fw dump\n");
872 }
873
874 void bnx2x_panic_dump(struct bnx2x *bp)
875 {
876         int i;
877         u16 j;
878         struct hc_sp_status_block_data sp_sb_data;
879         int func = BP_FUNC(bp);
880 #ifdef BNX2X_STOP_ON_ERROR
881         u16 start = 0, end = 0;
882 #endif
883
884         bp->stats_state = STATS_STATE_DISABLED;
885         DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
886
887         BNX2X_ERR("begin crash dump -----------------\n");
888
889         /* Indices */
890         /* Common */
891         BNX2X_ERR("def_idx(0x%x)  def_att_idx(0x%x)  attn_state(0x%x)"
892                   "  spq_prod_idx(0x%x)\n",
893                   bp->def_idx, bp->def_att_idx,
894                   bp->attn_state, bp->spq_prod_idx);
895         BNX2X_ERR("DSB: attn bits(0x%x)  ack(0x%x)  id(0x%x)  idx(0x%x)\n",
896                   bp->def_status_blk->atten_status_block.attn_bits,
897                   bp->def_status_blk->atten_status_block.attn_bits_ack,
898                   bp->def_status_blk->atten_status_block.status_block_id,
899                   bp->def_status_blk->atten_status_block.attn_bits_index);
900         BNX2X_ERR("     def (");
901         for (i = 0; i < HC_SP_SB_MAX_INDICES; i++)
902                 pr_cont("0x%x%s",
903                        bp->def_status_blk->sp_sb.index_values[i],
904                        (i == HC_SP_SB_MAX_INDICES - 1) ? ")  " : " ");
905
906         for (i = 0; i < sizeof(struct hc_sp_status_block_data)/sizeof(u32); i++)
907                 *((u32 *)&sp_sb_data + i) = REG_RD(bp, BAR_CSTRORM_INTMEM +
908                         CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
909                         i*sizeof(u32));
910
911         pr_cont("igu_sb_id(0x%x)  igu_seg_id (0x%x) "
912                          "pf_id(0x%x)  vnic_id(0x%x)  "
913                          "vf_id(0x%x)  vf_valid (0x%x)\n",
914                sp_sb_data.igu_sb_id,
915                sp_sb_data.igu_seg_id,
916                sp_sb_data.p_func.pf_id,
917                sp_sb_data.p_func.vnic_id,
918                sp_sb_data.p_func.vf_id,
919                sp_sb_data.p_func.vf_valid);
920
921
922         for_each_queue(bp, i) {
923                 struct bnx2x_fastpath *fp = &bp->fp[i];
924                 int loop;
925                 struct hc_status_block_data_e2 sb_data_e2;
926                 struct hc_status_block_data_e1x sb_data_e1x;
927                 struct hc_status_block_sm  *hc_sm_p =
928                         CHIP_IS_E2(bp) ?
929                         sb_data_e2.common.state_machine :
930                         sb_data_e1x.common.state_machine;
931                 struct hc_index_data *hc_index_p =
932                         CHIP_IS_E2(bp) ?
933                         sb_data_e2.index_data :
934                         sb_data_e1x.index_data;
935                 int data_size;
936                 u32 *sb_data_p;
937
938                 /* Rx */
939                 BNX2X_ERR("fp%d: rx_bd_prod(0x%x)  rx_bd_cons(0x%x)"
940                           "  rx_comp_prod(0x%x)"
941                           "  rx_comp_cons(0x%x)  *rx_cons_sb(0x%x)\n",
942                           i, fp->rx_bd_prod, fp->rx_bd_cons,
943                           fp->rx_comp_prod,
944                           fp->rx_comp_cons, le16_to_cpu(*fp->rx_cons_sb));
945                 BNX2X_ERR("     rx_sge_prod(0x%x)  last_max_sge(0x%x)"
946                           "  fp_hc_idx(0x%x)\n",
947                           fp->rx_sge_prod, fp->last_max_sge,
948                           le16_to_cpu(fp->fp_hc_idx));
949
950                 /* Tx */
951                 BNX2X_ERR("fp%d: tx_pkt_prod(0x%x)  tx_pkt_cons(0x%x)"
952                           "  tx_bd_prod(0x%x)  tx_bd_cons(0x%x)"
953                           "  *tx_cons_sb(0x%x)\n",
954                           i, fp->tx_pkt_prod, fp->tx_pkt_cons, fp->tx_bd_prod,
955                           fp->tx_bd_cons, le16_to_cpu(*fp->tx_cons_sb));
956
957                 loop = CHIP_IS_E2(bp) ?
958                         HC_SB_MAX_INDICES_E2 : HC_SB_MAX_INDICES_E1X;
959
960                 /* host sb data */
961
962                 BNX2X_ERR("     run indexes (");
963                 for (j = 0; j < HC_SB_MAX_SM; j++)
964                         pr_cont("0x%x%s",
965                                fp->sb_running_index[j],
966                                (j == HC_SB_MAX_SM - 1) ? ")" : " ");
967
968                 BNX2X_ERR("     indexes (");
969                 for (j = 0; j < loop; j++)
970                         pr_cont("0x%x%s",
971                                fp->sb_index_values[j],
972                                (j == loop - 1) ? ")" : " ");
973                 /* fw sb data */
974                 data_size = CHIP_IS_E2(bp) ?
975                         sizeof(struct hc_status_block_data_e2) :
976                         sizeof(struct hc_status_block_data_e1x);
977                 data_size /= sizeof(u32);
978                 sb_data_p = CHIP_IS_E2(bp) ?
979                         (u32 *)&sb_data_e2 :
980                         (u32 *)&sb_data_e1x;
981                 /* copy sb data in here */
982                 for (j = 0; j < data_size; j++)
983                         *(sb_data_p + j) = REG_RD(bp, BAR_CSTRORM_INTMEM +
984                                 CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id) +
985                                 j * sizeof(u32));
986
987                 if (CHIP_IS_E2(bp)) {
988                         pr_cont("pf_id(0x%x)  vf_id (0x%x)  vf_valid(0x%x) "
989                                 "vnic_id(0x%x)  same_igu_sb_1b(0x%x)\n",
990                                 sb_data_e2.common.p_func.pf_id,
991                                 sb_data_e2.common.p_func.vf_id,
992                                 sb_data_e2.common.p_func.vf_valid,
993                                 sb_data_e2.common.p_func.vnic_id,
994                                 sb_data_e2.common.same_igu_sb_1b);
995                 } else {
996                         pr_cont("pf_id(0x%x)  vf_id (0x%x)  vf_valid(0x%x) "
997                                 "vnic_id(0x%x)  same_igu_sb_1b(0x%x)\n",
998                                 sb_data_e1x.common.p_func.pf_id,
999                                 sb_data_e1x.common.p_func.vf_id,
1000                                 sb_data_e1x.common.p_func.vf_valid,
1001                                 sb_data_e1x.common.p_func.vnic_id,
1002                                 sb_data_e1x.common.same_igu_sb_1b);
1003                 }
1004
1005                 /* SB_SMs data */
1006                 for (j = 0; j < HC_SB_MAX_SM; j++) {
1007                         pr_cont("SM[%d] __flags (0x%x) "
1008                                "igu_sb_id (0x%x)  igu_seg_id(0x%x) "
1009                                "time_to_expire (0x%x) "
1010                                "timer_value(0x%x)\n", j,
1011                                hc_sm_p[j].__flags,
1012                                hc_sm_p[j].igu_sb_id,
1013                                hc_sm_p[j].igu_seg_id,
1014                                hc_sm_p[j].time_to_expire,
1015                                hc_sm_p[j].timer_value);
1016                 }
1017
1018                 /* Indecies data */
1019                 for (j = 0; j < loop; j++) {
1020                         pr_cont("INDEX[%d] flags (0x%x) "
1021                                          "timeout (0x%x)\n", j,
1022                                hc_index_p[j].flags,
1023                                hc_index_p[j].timeout);
1024                 }
1025         }
1026
1027 #ifdef BNX2X_STOP_ON_ERROR
1028         /* Rings */
1029         /* Rx */
1030         for_each_queue(bp, i) {
1031                 struct bnx2x_fastpath *fp = &bp->fp[i];
1032
1033                 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
1034                 end = RX_BD(le16_to_cpu(*fp->rx_cons_sb) + 503);
1035                 for (j = start; j != end; j = RX_BD(j + 1)) {
1036                         u32 *rx_bd = (u32 *)&fp->rx_desc_ring[j];
1037                         struct sw_rx_bd *sw_bd = &fp->rx_buf_ring[j];
1038
1039                         BNX2X_ERR("fp%d: rx_bd[%x]=[%x:%x]  sw_bd=[%p]\n",
1040                                   i, j, rx_bd[1], rx_bd[0], sw_bd->skb);
1041                 }
1042
1043                 start = RX_SGE(fp->rx_sge_prod);
1044                 end = RX_SGE(fp->last_max_sge);
1045                 for (j = start; j != end; j = RX_SGE(j + 1)) {
1046                         u32 *rx_sge = (u32 *)&fp->rx_sge_ring[j];
1047                         struct sw_rx_page *sw_page = &fp->rx_page_ring[j];
1048
1049                         BNX2X_ERR("fp%d: rx_sge[%x]=[%x:%x]  sw_page=[%p]\n",
1050                                   i, j, rx_sge[1], rx_sge[0], sw_page->page);
1051                 }
1052
1053                 start = RCQ_BD(fp->rx_comp_cons - 10);
1054                 end = RCQ_BD(fp->rx_comp_cons + 503);
1055                 for (j = start; j != end; j = RCQ_BD(j + 1)) {
1056                         u32 *cqe = (u32 *)&fp->rx_comp_ring[j];
1057
1058                         BNX2X_ERR("fp%d: cqe[%x]=[%x:%x:%x:%x]\n",
1059                                   i, j, cqe[0], cqe[1], cqe[2], cqe[3]);
1060                 }
1061         }
1062
1063         /* Tx */
1064         for_each_queue(bp, i) {
1065                 struct bnx2x_fastpath *fp = &bp->fp[i];
1066
1067                 start = TX_BD(le16_to_cpu(*fp->tx_cons_sb) - 10);
1068                 end = TX_BD(le16_to_cpu(*fp->tx_cons_sb) + 245);
1069                 for (j = start; j != end; j = TX_BD(j + 1)) {
1070                         struct sw_tx_bd *sw_bd = &fp->tx_buf_ring[j];
1071
1072                         BNX2X_ERR("fp%d: packet[%x]=[%p,%x]\n",
1073                                   i, j, sw_bd->skb, sw_bd->first_bd);
1074                 }
1075
1076                 start = TX_BD(fp->tx_bd_cons - 10);
1077                 end = TX_BD(fp->tx_bd_cons + 254);
1078                 for (j = start; j != end; j = TX_BD(j + 1)) {
1079                         u32 *tx_bd = (u32 *)&fp->tx_desc_ring[j];
1080
1081                         BNX2X_ERR("fp%d: tx_bd[%x]=[%x:%x:%x:%x]\n",
1082                                   i, j, tx_bd[0], tx_bd[1], tx_bd[2], tx_bd[3]);
1083                 }
1084         }
1085 #endif
1086         bnx2x_fw_dump(bp);
1087         bnx2x_mc_assert(bp);
1088         BNX2X_ERR("end crash dump -----------------\n");
1089 }
1090
1091 static void bnx2x_hc_int_enable(struct bnx2x *bp)
1092 {
1093         int port = BP_PORT(bp);
1094         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
1095         u32 val = REG_RD(bp, addr);
1096         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1097         int msi = (bp->flags & USING_MSI_FLAG) ? 1 : 0;
1098
1099         if (msix) {
1100                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1101                          HC_CONFIG_0_REG_INT_LINE_EN_0);
1102                 val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1103                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1104         } else if (msi) {
1105                 val &= ~HC_CONFIG_0_REG_INT_LINE_EN_0;
1106                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1107                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1108                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1109         } else {
1110                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1111                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1112                         HC_CONFIG_0_REG_INT_LINE_EN_0 |
1113                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1114
1115                 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
1116                    val, port, addr);
1117
1118                 REG_WR(bp, addr, val);
1119
1120                 val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
1121         }
1122
1123         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)  mode %s\n",
1124            val, port, addr, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1125
1126         REG_WR(bp, addr, val);
1127         /*
1128          * Ensure that HC_CONFIG is written before leading/trailing edge config
1129          */
1130         mmiowb();
1131         barrier();
1132
1133         if (!CHIP_IS_E1(bp)) {
1134                 /* init leading/trailing edge */
1135                 if (IS_MF(bp)) {
1136                         val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
1137                         if (bp->port.pmf)
1138                                 /* enable nig and gpio3 attention */
1139                                 val |= 0x1100;
1140                 } else
1141                         val = 0xffff;
1142
1143                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
1144                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
1145         }
1146
1147         /* Make sure that interrupts are indeed enabled from here on */
1148         mmiowb();
1149 }
1150
1151 static void bnx2x_igu_int_enable(struct bnx2x *bp)
1152 {
1153         u32 val;
1154         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1155         int msi = (bp->flags & USING_MSI_FLAG) ? 1 : 0;
1156
1157         val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1158
1159         if (msix) {
1160                 val &= ~(IGU_PF_CONF_INT_LINE_EN |
1161                          IGU_PF_CONF_SINGLE_ISR_EN);
1162                 val |= (IGU_PF_CONF_FUNC_EN |
1163                         IGU_PF_CONF_MSI_MSIX_EN |
1164                         IGU_PF_CONF_ATTN_BIT_EN);
1165         } else if (msi) {
1166                 val &= ~IGU_PF_CONF_INT_LINE_EN;
1167                 val |= (IGU_PF_CONF_FUNC_EN |
1168                         IGU_PF_CONF_MSI_MSIX_EN |
1169                         IGU_PF_CONF_ATTN_BIT_EN |
1170                         IGU_PF_CONF_SINGLE_ISR_EN);
1171         } else {
1172                 val &= ~IGU_PF_CONF_MSI_MSIX_EN;
1173                 val |= (IGU_PF_CONF_FUNC_EN |
1174                         IGU_PF_CONF_INT_LINE_EN |
1175                         IGU_PF_CONF_ATTN_BIT_EN |
1176                         IGU_PF_CONF_SINGLE_ISR_EN);
1177         }
1178
1179         DP(NETIF_MSG_INTR, "write 0x%x to IGU  mode %s\n",
1180            val, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1181
1182         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1183
1184         barrier();
1185
1186         /* init leading/trailing edge */
1187         if (IS_MF(bp)) {
1188                 val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
1189                 if (bp->port.pmf)
1190                         /* enable nig and gpio3 attention */
1191                         val |= 0x1100;
1192         } else
1193                 val = 0xffff;
1194
1195         REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
1196         REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
1197
1198         /* Make sure that interrupts are indeed enabled from here on */
1199         mmiowb();
1200 }
1201
1202 void bnx2x_int_enable(struct bnx2x *bp)
1203 {
1204         if (bp->common.int_block == INT_BLOCK_HC)
1205                 bnx2x_hc_int_enable(bp);
1206         else
1207                 bnx2x_igu_int_enable(bp);
1208 }
1209
1210 static void bnx2x_hc_int_disable(struct bnx2x *bp)
1211 {
1212         int port = BP_PORT(bp);
1213         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
1214         u32 val = REG_RD(bp, addr);
1215
1216         val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1217                  HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1218                  HC_CONFIG_0_REG_INT_LINE_EN_0 |
1219                  HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1220
1221         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
1222            val, port, addr);
1223
1224         /* flush all outstanding writes */
1225         mmiowb();
1226
1227         REG_WR(bp, addr, val);
1228         if (REG_RD(bp, addr) != val)
1229                 BNX2X_ERR("BUG! proper val not read from IGU!\n");
1230 }
1231
1232 static void bnx2x_igu_int_disable(struct bnx2x *bp)
1233 {
1234         u32 val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1235
1236         val &= ~(IGU_PF_CONF_MSI_MSIX_EN |
1237                  IGU_PF_CONF_INT_LINE_EN |
1238                  IGU_PF_CONF_ATTN_BIT_EN);
1239
1240         DP(NETIF_MSG_INTR, "write %x to IGU\n", val);
1241
1242         /* flush all outstanding writes */
1243         mmiowb();
1244
1245         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1246         if (REG_RD(bp, IGU_REG_PF_CONFIGURATION) != val)
1247                 BNX2X_ERR("BUG! proper val not read from IGU!\n");
1248 }
1249
1250 void bnx2x_int_disable(struct bnx2x *bp)
1251 {
1252         if (bp->common.int_block == INT_BLOCK_HC)
1253                 bnx2x_hc_int_disable(bp);
1254         else
1255                 bnx2x_igu_int_disable(bp);
1256 }
1257
1258 void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
1259 {
1260         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1261         int i, offset;
1262
1263         /* disable interrupt handling */
1264         atomic_inc(&bp->intr_sem);
1265         smp_wmb(); /* Ensure that bp->intr_sem update is SMP-safe */
1266
1267         if (disable_hw)
1268                 /* prevent the HW from sending interrupts */
1269                 bnx2x_int_disable(bp);
1270
1271         /* make sure all ISRs are done */
1272         if (msix) {
1273                 synchronize_irq(bp->msix_table[0].vector);
1274                 offset = 1;
1275 #ifdef BCM_CNIC
1276                 offset++;
1277 #endif
1278                 for_each_queue(bp, i)
1279                         synchronize_irq(bp->msix_table[i + offset].vector);
1280         } else
1281                 synchronize_irq(bp->pdev->irq);
1282
1283         /* make sure sp_task is not running */
1284         cancel_delayed_work(&bp->sp_task);
1285         flush_workqueue(bnx2x_wq);
1286 }
1287
1288 /* fast path */
1289
1290 /*
1291  * General service functions
1292  */
1293
1294 /* Return true if succeeded to acquire the lock */
1295 static bool bnx2x_trylock_hw_lock(struct bnx2x *bp, u32 resource)
1296 {
1297         u32 lock_status;
1298         u32 resource_bit = (1 << resource);
1299         int func = BP_FUNC(bp);
1300         u32 hw_lock_control_reg;
1301
1302         DP(NETIF_MSG_HW, "Trying to take a lock on resource %d\n", resource);
1303
1304         /* Validating that the resource is within range */
1305         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1306                 DP(NETIF_MSG_HW,
1307                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1308                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1309                 return false;
1310         }
1311
1312         if (func <= 5)
1313                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1314         else
1315                 hw_lock_control_reg =
1316                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1317
1318         /* Try to acquire the lock */
1319         REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1320         lock_status = REG_RD(bp, hw_lock_control_reg);
1321         if (lock_status & resource_bit)
1322                 return true;
1323
1324         DP(NETIF_MSG_HW, "Failed to get a lock on resource %d\n", resource);
1325         return false;
1326 }
1327
1328
1329 #ifdef BCM_CNIC
1330 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid);
1331 #endif
1332
1333 void bnx2x_sp_event(struct bnx2x_fastpath *fp,
1334                            union eth_rx_cqe *rr_cqe)
1335 {
1336         struct bnx2x *bp = fp->bp;
1337         int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1338         int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1339
1340         DP(BNX2X_MSG_SP,
1341            "fp %d  cid %d  got ramrod #%d  state is %x  type is %d\n",
1342            fp->index, cid, command, bp->state,
1343            rr_cqe->ramrod_cqe.ramrod_type);
1344
1345         switch (command | fp->state) {
1346         case (RAMROD_CMD_ID_ETH_CLIENT_SETUP | BNX2X_FP_STATE_OPENING):
1347                 DP(NETIF_MSG_IFUP, "got MULTI[%d] setup ramrod\n", cid);
1348                 fp->state = BNX2X_FP_STATE_OPEN;
1349                 break;
1350
1351         case (RAMROD_CMD_ID_ETH_HALT | BNX2X_FP_STATE_HALTING):
1352                 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] halt ramrod\n", cid);
1353                 fp->state = BNX2X_FP_STATE_HALTED;
1354                 break;
1355
1356         case (RAMROD_CMD_ID_ETH_TERMINATE | BNX2X_FP_STATE_TERMINATING):
1357                 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] teminate ramrod\n", cid);
1358                 fp->state = BNX2X_FP_STATE_TERMINATED;
1359                 break;
1360
1361         default:
1362                 BNX2X_ERR("unexpected MC reply (%d)  "
1363                           "fp[%d] state is %x\n",
1364                           command, fp->index, fp->state);
1365                 break;
1366         }
1367
1368         smp_mb__before_atomic_inc();
1369         atomic_inc(&bp->spq_left);
1370         /* push the change in fp->state and towards the memory */
1371         smp_wmb();
1372
1373         return;
1374 }
1375
1376 irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
1377 {
1378         struct bnx2x *bp = netdev_priv(dev_instance);
1379         u16 status = bnx2x_ack_int(bp);
1380         u16 mask;
1381         int i;
1382
1383         /* Return here if interrupt is shared and it's not for us */
1384         if (unlikely(status == 0)) {
1385                 DP(NETIF_MSG_INTR, "not our interrupt!\n");
1386                 return IRQ_NONE;
1387         }
1388         DP(NETIF_MSG_INTR, "got an interrupt  status 0x%x\n", status);
1389
1390         /* Return here if interrupt is disabled */
1391         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
1392                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
1393                 return IRQ_HANDLED;
1394         }
1395
1396 #ifdef BNX2X_STOP_ON_ERROR
1397         if (unlikely(bp->panic))
1398                 return IRQ_HANDLED;
1399 #endif
1400
1401         for_each_queue(bp, i) {
1402                 struct bnx2x_fastpath *fp = &bp->fp[i];
1403
1404                 mask = 0x2 << (fp->index + CNIC_CONTEXT_USE);
1405                 if (status & mask) {
1406                         /* Handle Rx and Tx according to SB id */
1407                         prefetch(fp->rx_cons_sb);
1408                         prefetch(fp->tx_cons_sb);
1409                         prefetch(&fp->sb_running_index[SM_RX_ID]);
1410                         napi_schedule(&bnx2x_fp(bp, fp->index, napi));
1411                         status &= ~mask;
1412                 }
1413         }
1414
1415 #ifdef BCM_CNIC
1416         mask = 0x2;
1417         if (status & (mask | 0x1)) {
1418                 struct cnic_ops *c_ops = NULL;
1419
1420                 rcu_read_lock();
1421                 c_ops = rcu_dereference(bp->cnic_ops);
1422                 if (c_ops)
1423                         c_ops->cnic_handler(bp->cnic_data, NULL);
1424                 rcu_read_unlock();
1425
1426                 status &= ~mask;
1427         }
1428 #endif
1429
1430         if (unlikely(status & 0x1)) {
1431                 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
1432
1433                 status &= ~0x1;
1434                 if (!status)
1435                         return IRQ_HANDLED;
1436         }
1437
1438         if (unlikely(status))
1439                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
1440                    status);
1441
1442         return IRQ_HANDLED;
1443 }
1444
1445 /* end of fast path */
1446
1447
1448 /* Link */
1449
1450 /*
1451  * General service functions
1452  */
1453
1454 int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource)
1455 {
1456         u32 lock_status;
1457         u32 resource_bit = (1 << resource);
1458         int func = BP_FUNC(bp);
1459         u32 hw_lock_control_reg;
1460         int cnt;
1461
1462         /* Validating that the resource is within range */
1463         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1464                 DP(NETIF_MSG_HW,
1465                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1466                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1467                 return -EINVAL;
1468         }
1469
1470         if (func <= 5) {
1471                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1472         } else {
1473                 hw_lock_control_reg =
1474                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1475         }
1476
1477         /* Validating that the resource is not already taken */
1478         lock_status = REG_RD(bp, hw_lock_control_reg);
1479         if (lock_status & resource_bit) {
1480                 DP(NETIF_MSG_HW, "lock_status 0x%x  resource_bit 0x%x\n",
1481                    lock_status, resource_bit);
1482                 return -EEXIST;
1483         }
1484
1485         /* Try for 5 second every 5ms */
1486         for (cnt = 0; cnt < 1000; cnt++) {
1487                 /* Try to acquire the lock */
1488                 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1489                 lock_status = REG_RD(bp, hw_lock_control_reg);
1490                 if (lock_status & resource_bit)
1491                         return 0;
1492
1493                 msleep(5);
1494         }
1495         DP(NETIF_MSG_HW, "Timeout\n");
1496         return -EAGAIN;
1497 }
1498
1499 int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource)
1500 {
1501         u32 lock_status;
1502         u32 resource_bit = (1 << resource);
1503         int func = BP_FUNC(bp);
1504         u32 hw_lock_control_reg;
1505
1506         DP(NETIF_MSG_HW, "Releasing a lock on resource %d\n", resource);
1507
1508         /* Validating that the resource is within range */
1509         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1510                 DP(NETIF_MSG_HW,
1511                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1512                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1513                 return -EINVAL;
1514         }
1515
1516         if (func <= 5) {
1517                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1518         } else {
1519                 hw_lock_control_reg =
1520                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1521         }
1522
1523         /* Validating that the resource is currently taken */
1524         lock_status = REG_RD(bp, hw_lock_control_reg);
1525         if (!(lock_status & resource_bit)) {
1526                 DP(NETIF_MSG_HW, "lock_status 0x%x  resource_bit 0x%x\n",
1527                    lock_status, resource_bit);
1528                 return -EFAULT;
1529         }
1530
1531         REG_WR(bp, hw_lock_control_reg, resource_bit);
1532         return 0;
1533 }
1534
1535
1536 int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, u8 port)
1537 {
1538         /* The GPIO should be swapped if swap register is set and active */
1539         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1540                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1541         int gpio_shift = gpio_num +
1542                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1543         u32 gpio_mask = (1 << gpio_shift);
1544         u32 gpio_reg;
1545         int value;
1546
1547         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1548                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1549                 return -EINVAL;
1550         }
1551
1552         /* read GPIO value */
1553         gpio_reg = REG_RD(bp, MISC_REG_GPIO);
1554
1555         /* get the requested pin value */
1556         if ((gpio_reg & gpio_mask) == gpio_mask)
1557                 value = 1;
1558         else
1559                 value = 0;
1560
1561         DP(NETIF_MSG_LINK, "pin %d  value 0x%x\n", gpio_num, value);
1562
1563         return value;
1564 }
1565
1566 int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1567 {
1568         /* The GPIO should be swapped if swap register is set and active */
1569         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1570                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1571         int gpio_shift = gpio_num +
1572                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1573         u32 gpio_mask = (1 << gpio_shift);
1574         u32 gpio_reg;
1575
1576         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1577                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1578                 return -EINVAL;
1579         }
1580
1581         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1582         /* read GPIO and mask except the float bits */
1583         gpio_reg = (REG_RD(bp, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
1584
1585         switch (mode) {
1586         case MISC_REGISTERS_GPIO_OUTPUT_LOW:
1587                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output low\n",
1588                    gpio_num, gpio_shift);
1589                 /* clear FLOAT and set CLR */
1590                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1591                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
1592                 break;
1593
1594         case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
1595                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output high\n",
1596                    gpio_num, gpio_shift);
1597                 /* clear FLOAT and set SET */
1598                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1599                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
1600                 break;
1601
1602         case MISC_REGISTERS_GPIO_INPUT_HI_Z:
1603                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> input\n",
1604                    gpio_num, gpio_shift);
1605                 /* set FLOAT */
1606                 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1607                 break;
1608
1609         default:
1610                 break;
1611         }
1612
1613         REG_WR(bp, MISC_REG_GPIO, gpio_reg);
1614         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1615
1616         return 0;
1617 }
1618
1619 int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1620 {
1621         /* The GPIO should be swapped if swap register is set and active */
1622         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1623                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1624         int gpio_shift = gpio_num +
1625                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1626         u32 gpio_mask = (1 << gpio_shift);
1627         u32 gpio_reg;
1628
1629         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1630                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1631                 return -EINVAL;
1632         }
1633
1634         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1635         /* read GPIO int */
1636         gpio_reg = REG_RD(bp, MISC_REG_GPIO_INT);
1637
1638         switch (mode) {
1639         case MISC_REGISTERS_GPIO_INT_OUTPUT_CLR:
1640                 DP(NETIF_MSG_LINK, "Clear GPIO INT %d (shift %d) -> "
1641                                    "output low\n", gpio_num, gpio_shift);
1642                 /* clear SET and set CLR */
1643                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1644                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1645                 break;
1646
1647         case MISC_REGISTERS_GPIO_INT_OUTPUT_SET:
1648                 DP(NETIF_MSG_LINK, "Set GPIO INT %d (shift %d) -> "
1649                                    "output high\n", gpio_num, gpio_shift);
1650                 /* clear CLR and set SET */
1651                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1652                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1653                 break;
1654
1655         default:
1656                 break;
1657         }
1658
1659         REG_WR(bp, MISC_REG_GPIO_INT, gpio_reg);
1660         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1661
1662         return 0;
1663 }
1664
1665 static int bnx2x_set_spio(struct bnx2x *bp, int spio_num, u32 mode)
1666 {
1667         u32 spio_mask = (1 << spio_num);
1668         u32 spio_reg;
1669
1670         if ((spio_num < MISC_REGISTERS_SPIO_4) ||
1671             (spio_num > MISC_REGISTERS_SPIO_7)) {
1672                 BNX2X_ERR("Invalid SPIO %d\n", spio_num);
1673                 return -EINVAL;
1674         }
1675
1676         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1677         /* read SPIO and mask except the float bits */
1678         spio_reg = (REG_RD(bp, MISC_REG_SPIO) & MISC_REGISTERS_SPIO_FLOAT);
1679
1680         switch (mode) {
1681         case MISC_REGISTERS_SPIO_OUTPUT_LOW:
1682                 DP(NETIF_MSG_LINK, "Set SPIO %d -> output low\n", spio_num);
1683                 /* clear FLOAT and set CLR */
1684                 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1685                 spio_reg |=  (spio_mask << MISC_REGISTERS_SPIO_CLR_POS);
1686                 break;
1687
1688         case MISC_REGISTERS_SPIO_OUTPUT_HIGH:
1689                 DP(NETIF_MSG_LINK, "Set SPIO %d -> output high\n", spio_num);
1690                 /* clear FLOAT and set SET */
1691                 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1692                 spio_reg |=  (spio_mask << MISC_REGISTERS_SPIO_SET_POS);
1693                 break;
1694
1695         case MISC_REGISTERS_SPIO_INPUT_HI_Z:
1696                 DP(NETIF_MSG_LINK, "Set SPIO %d -> input\n", spio_num);
1697                 /* set FLOAT */
1698                 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1699                 break;
1700
1701         default:
1702                 break;
1703         }
1704
1705         REG_WR(bp, MISC_REG_SPIO, spio_reg);
1706         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1707
1708         return 0;
1709 }
1710
1711 int bnx2x_get_link_cfg_idx(struct bnx2x *bp)
1712 {
1713         u32 sel_phy_idx = 0;
1714         if (bp->link_vars.link_up) {
1715                 sel_phy_idx = EXT_PHY1;
1716                 /* In case link is SERDES, check if the EXT_PHY2 is the one */
1717                 if ((bp->link_vars.link_status & LINK_STATUS_SERDES_LINK) &&
1718                     (bp->link_params.phy[EXT_PHY2].supported & SUPPORTED_FIBRE))
1719                         sel_phy_idx = EXT_PHY2;
1720         } else {
1721
1722                 switch (bnx2x_phy_selection(&bp->link_params)) {
1723                 case PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT:
1724                 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY:
1725                 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY:
1726                        sel_phy_idx = EXT_PHY1;
1727                        break;
1728                 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY:
1729                 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY:
1730                        sel_phy_idx = EXT_PHY2;
1731                        break;
1732                 }
1733         }
1734         /*
1735         * The selected actived PHY is always after swapping (in case PHY
1736         * swapping is enabled). So when swapping is enabled, we need to reverse
1737         * the configuration
1738         */
1739
1740         if (bp->link_params.multi_phy_config &
1741             PORT_HW_CFG_PHY_SWAPPED_ENABLED) {
1742                 if (sel_phy_idx == EXT_PHY1)
1743                         sel_phy_idx = EXT_PHY2;
1744                 else if (sel_phy_idx == EXT_PHY2)
1745                         sel_phy_idx = EXT_PHY1;
1746         }
1747         return LINK_CONFIG_IDX(sel_phy_idx);
1748 }
1749
1750 void bnx2x_calc_fc_adv(struct bnx2x *bp)
1751 {
1752         u8 cfg_idx = bnx2x_get_link_cfg_idx(bp);
1753         switch (bp->link_vars.ieee_fc &
1754                 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
1755         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
1756                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1757                                           ADVERTISED_Pause);
1758                 break;
1759
1760         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
1761                 bp->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
1762                                          ADVERTISED_Pause);
1763                 break;
1764
1765         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
1766                 bp->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
1767                 break;
1768
1769         default:
1770                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1771                                           ADVERTISED_Pause);
1772                 break;
1773         }
1774 }
1775
1776
1777 u8 bnx2x_initial_phy_init(struct bnx2x *bp, int load_mode)
1778 {
1779         if (!BP_NOMCP(bp)) {
1780                 u8 rc;
1781                 int cfx_idx = bnx2x_get_link_cfg_idx(bp);
1782                 u16 req_line_speed = bp->link_params.req_line_speed[cfx_idx];
1783                 /* Initialize link parameters structure variables */
1784                 /* It is recommended to turn off RX FC for jumbo frames
1785                    for better performance */
1786                 if ((CHIP_IS_E1x(bp)) && (bp->dev->mtu > 5000))
1787                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_TX;
1788                 else
1789                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
1790
1791                 bnx2x_acquire_phy_lock(bp);
1792
1793                 if (load_mode == LOAD_DIAG) {
1794                         bp->link_params.loopback_mode = LOOPBACK_XGXS;
1795                         bp->link_params.req_line_speed[cfx_idx] = SPEED_10000;
1796                 }
1797
1798                 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1799
1800                 bnx2x_release_phy_lock(bp);
1801
1802                 bnx2x_calc_fc_adv(bp);
1803
1804                 if (CHIP_REV_IS_SLOW(bp) && bp->link_vars.link_up) {
1805                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
1806                         bnx2x_link_report(bp);
1807                 }
1808                 bp->link_params.req_line_speed[cfx_idx] = req_line_speed;
1809                 return rc;
1810         }
1811         BNX2X_ERR("Bootcode is missing - can not initialize link\n");
1812         return -EINVAL;
1813 }
1814
1815 void bnx2x_link_set(struct bnx2x *bp)
1816 {
1817         if (!BP_NOMCP(bp)) {
1818                 bnx2x_acquire_phy_lock(bp);
1819                 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1820                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1821                 bnx2x_release_phy_lock(bp);
1822
1823                 bnx2x_calc_fc_adv(bp);
1824         } else
1825                 BNX2X_ERR("Bootcode is missing - can not set link\n");
1826 }
1827
1828 static void bnx2x__link_reset(struct bnx2x *bp)
1829 {
1830         if (!BP_NOMCP(bp)) {
1831                 bnx2x_acquire_phy_lock(bp);
1832                 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1833                 bnx2x_release_phy_lock(bp);
1834         } else
1835                 BNX2X_ERR("Bootcode is missing - can not reset link\n");
1836 }
1837
1838 u8 bnx2x_link_test(struct bnx2x *bp, u8 is_serdes)
1839 {
1840         u8 rc = 0;
1841
1842         if (!BP_NOMCP(bp)) {
1843                 bnx2x_acquire_phy_lock(bp);
1844                 rc = bnx2x_test_link(&bp->link_params, &bp->link_vars,
1845                                      is_serdes);
1846                 bnx2x_release_phy_lock(bp);
1847         } else
1848                 BNX2X_ERR("Bootcode is missing - can not test link\n");
1849
1850         return rc;
1851 }
1852
1853 static void bnx2x_init_port_minmax(struct bnx2x *bp)
1854 {
1855         u32 r_param = bp->link_vars.line_speed / 8;
1856         u32 fair_periodic_timeout_usec;
1857         u32 t_fair;
1858
1859         memset(&(bp->cmng.rs_vars), 0,
1860                sizeof(struct rate_shaping_vars_per_port));
1861         memset(&(bp->cmng.fair_vars), 0, sizeof(struct fairness_vars_per_port));
1862
1863         /* 100 usec in SDM ticks = 25 since each tick is 4 usec */
1864         bp->cmng.rs_vars.rs_periodic_timeout = RS_PERIODIC_TIMEOUT_USEC / 4;
1865
1866         /* this is the threshold below which no timer arming will occur
1867            1.25 coefficient is for the threshold to be a little bigger
1868            than the real time, to compensate for timer in-accuracy */
1869         bp->cmng.rs_vars.rs_threshold =
1870                                 (RS_PERIODIC_TIMEOUT_USEC * r_param * 5) / 4;
1871
1872         /* resolution of fairness timer */
1873         fair_periodic_timeout_usec = QM_ARB_BYTES / r_param;
1874         /* for 10G it is 1000usec. for 1G it is 10000usec. */
1875         t_fair = T_FAIR_COEF / bp->link_vars.line_speed;
1876
1877         /* this is the threshold below which we won't arm the timer anymore */
1878         bp->cmng.fair_vars.fair_threshold = QM_ARB_BYTES;
1879
1880         /* we multiply by 1e3/8 to get bytes/msec.
1881            We don't want the credits to pass a credit
1882            of the t_fair*FAIR_MEM (algorithm resolution) */
1883         bp->cmng.fair_vars.upper_bound = r_param * t_fair * FAIR_MEM;
1884         /* since each tick is 4 usec */
1885         bp->cmng.fair_vars.fairness_timeout = fair_periodic_timeout_usec / 4;
1886 }
1887
1888 /* Calculates the sum of vn_min_rates.
1889    It's needed for further normalizing of the min_rates.
1890    Returns:
1891      sum of vn_min_rates.
1892        or
1893      0 - if all the min_rates are 0.
1894      In the later case fainess algorithm should be deactivated.
1895      If not all min_rates are zero then those that are zeroes will be set to 1.
1896  */
1897 static void bnx2x_calc_vn_weight_sum(struct bnx2x *bp)
1898 {
1899         int all_zero = 1;
1900         int vn;
1901
1902         bp->vn_weight_sum = 0;
1903         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
1904                 u32 vn_cfg = bp->mf_config[vn];
1905                 u32 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1906                                    FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1907
1908                 /* Skip hidden vns */
1909                 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
1910                         continue;
1911
1912                 /* If min rate is zero - set it to 1 */
1913                 if (!vn_min_rate)
1914                         vn_min_rate = DEF_MIN_RATE;
1915                 else
1916                         all_zero = 0;
1917
1918                 bp->vn_weight_sum += vn_min_rate;
1919         }
1920
1921         /* ... only if all min rates are zeros - disable fairness */
1922         if (all_zero) {
1923                 bp->cmng.flags.cmng_enables &=
1924                                         ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1925                 DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
1926                    "  fairness will be disabled\n");
1927         } else
1928                 bp->cmng.flags.cmng_enables |=
1929                                         CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1930 }
1931
1932 static void bnx2x_init_vn_minmax(struct bnx2x *bp, int vn)
1933 {
1934         struct rate_shaping_vars_per_vn m_rs_vn;
1935         struct fairness_vars_per_vn m_fair_vn;
1936         u32 vn_cfg = bp->mf_config[vn];
1937         int func = 2*vn + BP_PORT(bp);
1938         u16 vn_min_rate, vn_max_rate;
1939         int i;
1940
1941         /* If function is hidden - set min and max to zeroes */
1942         if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE) {
1943                 vn_min_rate = 0;
1944                 vn_max_rate = 0;
1945
1946         } else {
1947                 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1948                                 FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1949                 /* If min rate is zero - set it to 1 */
1950                 if (bp->vn_weight_sum && (vn_min_rate == 0))
1951                         vn_min_rate = DEF_MIN_RATE;
1952                 vn_max_rate = ((vn_cfg & FUNC_MF_CFG_MAX_BW_MASK) >>
1953                                 FUNC_MF_CFG_MAX_BW_SHIFT) * 100;
1954         }
1955         DP(NETIF_MSG_IFUP,
1956            "func %d: vn_min_rate %d  vn_max_rate %d  vn_weight_sum %d\n",
1957            func, vn_min_rate, vn_max_rate, bp->vn_weight_sum);
1958
1959         memset(&m_rs_vn, 0, sizeof(struct rate_shaping_vars_per_vn));
1960         memset(&m_fair_vn, 0, sizeof(struct fairness_vars_per_vn));
1961
1962         /* global vn counter - maximal Mbps for this vn */
1963         m_rs_vn.vn_counter.rate = vn_max_rate;
1964
1965         /* quota - number of bytes transmitted in this period */
1966         m_rs_vn.vn_counter.quota =
1967                                 (vn_max_rate * RS_PERIODIC_TIMEOUT_USEC) / 8;
1968
1969         if (bp->vn_weight_sum) {
1970                 /* credit for each period of the fairness algorithm:
1971                    number of bytes in T_FAIR (the vn share the port rate).
1972                    vn_weight_sum should not be larger than 10000, thus
1973                    T_FAIR_COEF / (8 * vn_weight_sum) will always be greater
1974                    than zero */
1975                 m_fair_vn.vn_credit_delta =
1976                         max_t(u32, (vn_min_rate * (T_FAIR_COEF /
1977                                                    (8 * bp->vn_weight_sum))),
1978                               (bp->cmng.fair_vars.fair_threshold * 2));
1979                 DP(NETIF_MSG_IFUP, "m_fair_vn.vn_credit_delta %d\n",
1980                    m_fair_vn.vn_credit_delta);
1981         }
1982
1983         /* Store it to internal memory */
1984         for (i = 0; i < sizeof(struct rate_shaping_vars_per_vn)/4; i++)
1985                 REG_WR(bp, BAR_XSTRORM_INTMEM +
1986                        XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func) + i * 4,
1987                        ((u32 *)(&m_rs_vn))[i]);
1988
1989         for (i = 0; i < sizeof(struct fairness_vars_per_vn)/4; i++)
1990                 REG_WR(bp, BAR_XSTRORM_INTMEM +
1991                        XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func) + i * 4,
1992                        ((u32 *)(&m_fair_vn))[i]);
1993 }
1994 static int bnx2x_get_cmng_fns_mode(struct bnx2x *bp)
1995 {
1996         if (CHIP_REV_IS_SLOW(bp))
1997                 return CMNG_FNS_NONE;
1998         if (IS_MF(bp))
1999                 return CMNG_FNS_MINMAX;
2000
2001         return CMNG_FNS_NONE;
2002 }
2003
2004 static void bnx2x_read_mf_cfg(struct bnx2x *bp)
2005 {
2006         int vn;
2007
2008         if (BP_NOMCP(bp))
2009                 return; /* what should be the default bvalue in this case */
2010
2011         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2012                 int /*abs*/func = 2*vn + BP_PORT(bp);
2013                 bp->mf_config[vn] =
2014                         MF_CFG_RD(bp, func_mf_config[func].config);
2015         }
2016 }
2017
2018 static void bnx2x_cmng_fns_init(struct bnx2x *bp, u8 read_cfg, u8 cmng_type)
2019 {
2020
2021         if (cmng_type == CMNG_FNS_MINMAX) {
2022                 int vn;
2023
2024                 /* clear cmng_enables */
2025                 bp->cmng.flags.cmng_enables = 0;
2026
2027                 /* read mf conf from shmem */
2028                 if (read_cfg)
2029                         bnx2x_read_mf_cfg(bp);
2030
2031                 /* Init rate shaping and fairness contexts */
2032                 bnx2x_init_port_minmax(bp);
2033
2034                 /* vn_weight_sum and enable fairness if not 0 */
2035                 bnx2x_calc_vn_weight_sum(bp);
2036
2037                 /* calculate and set min-max rate for each vn */
2038                 for (vn = VN_0; vn < E1HVN_MAX; vn++)
2039                         bnx2x_init_vn_minmax(bp, vn);
2040
2041                 /* always enable rate shaping and fairness */
2042                 bp->cmng.flags.cmng_enables |=
2043                                         CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN;
2044                 if (!bp->vn_weight_sum)
2045                         DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
2046                                    "  fairness will be disabled\n");
2047                 return;
2048         }
2049
2050         /* rate shaping and fairness are disabled */
2051         DP(NETIF_MSG_IFUP,
2052            "rate shaping and fairness are disabled\n");
2053 }
2054
2055 static inline void bnx2x_link_sync_notify(struct bnx2x *bp)
2056 {
2057         int port = BP_PORT(bp);
2058         int func;
2059         int vn;
2060
2061         /* Set the attention towards other drivers on the same port */
2062         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2063                 if (vn == BP_E1HVN(bp))
2064                         continue;
2065
2066                 func = ((vn << 1) | port);
2067                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_0 +
2068                        (LINK_SYNC_ATTENTION_BIT_FUNC_0 + func)*4, 1);
2069         }
2070 }
2071
2072 /* This function is called upon link interrupt */
2073 static void bnx2x_link_attn(struct bnx2x *bp)
2074 {
2075         u32 prev_link_status = bp->link_vars.link_status;
2076         /* Make sure that we are synced with the current statistics */
2077         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2078
2079         bnx2x_link_update(&bp->link_params, &bp->link_vars);
2080
2081         if (bp->link_vars.link_up) {
2082
2083                 /* dropless flow control */
2084                 if (!CHIP_IS_E1(bp) && bp->dropless_fc) {
2085                         int port = BP_PORT(bp);
2086                         u32 pause_enabled = 0;
2087
2088                         if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
2089                                 pause_enabled = 1;
2090
2091                         REG_WR(bp, BAR_USTRORM_INTMEM +
2092                                USTORM_ETH_PAUSE_ENABLED_OFFSET(port),
2093                                pause_enabled);
2094                 }
2095
2096                 if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
2097                         struct host_port_stats *pstats;
2098
2099                         pstats = bnx2x_sp(bp, port_stats);
2100                         /* reset old bmac stats */
2101                         memset(&(pstats->mac_stx[0]), 0,
2102                                sizeof(struct mac_stx));
2103                 }
2104                 if (bp->state == BNX2X_STATE_OPEN)
2105                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2106         }
2107
2108         /* indicate link status only if link status actually changed */
2109         if (prev_link_status != bp->link_vars.link_status)
2110                 bnx2x_link_report(bp);
2111
2112         if (IS_MF(bp))
2113                 bnx2x_link_sync_notify(bp);
2114
2115         if (bp->link_vars.link_up && bp->link_vars.line_speed) {
2116                 int cmng_fns = bnx2x_get_cmng_fns_mode(bp);
2117
2118                 if (cmng_fns != CMNG_FNS_NONE) {
2119                         bnx2x_cmng_fns_init(bp, false, cmng_fns);
2120                         storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2121                 } else
2122                         /* rate shaping and fairness are disabled */
2123                         DP(NETIF_MSG_IFUP,
2124                            "single function mode without fairness\n");
2125         }
2126 }
2127
2128 void bnx2x__link_status_update(struct bnx2x *bp)
2129 {
2130         if ((bp->state != BNX2X_STATE_OPEN) || (bp->flags & MF_FUNC_DIS))
2131                 return;
2132
2133         bnx2x_link_status_update(&bp->link_params, &bp->link_vars);
2134
2135         if (bp->link_vars.link_up)
2136                 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2137         else
2138                 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2139
2140         /* the link status update could be the result of a DCC event
2141            hence re-read the shmem mf configuration */
2142         bnx2x_read_mf_cfg(bp);
2143
2144         /* indicate link status */
2145         bnx2x_link_report(bp);
2146 }
2147
2148 static void bnx2x_pmf_update(struct bnx2x *bp)
2149 {
2150         int port = BP_PORT(bp);
2151         u32 val;
2152
2153         bp->port.pmf = 1;
2154         DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
2155
2156         /* enable nig attention */
2157         val = (0xff0f | (1 << (BP_E1HVN(bp) + 4)));
2158         if (bp->common.int_block == INT_BLOCK_HC) {
2159                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
2160                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
2161         } else if (CHIP_IS_E2(bp)) {
2162                 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
2163                 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
2164         }
2165
2166         bnx2x_stats_handle(bp, STATS_EVENT_PMF);
2167 }
2168
2169 /* end of Link */
2170
2171 /* slow path */
2172
2173 /*
2174  * General service functions
2175  */
2176
2177 /* send the MCP a request, block until there is a reply */
2178 u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param)
2179 {
2180         int mb_idx = BP_FW_MB_IDX(bp);
2181         u32 seq = ++bp->fw_seq;
2182         u32 rc = 0;
2183         u32 cnt = 1;
2184         u8 delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
2185
2186         mutex_lock(&bp->fw_mb_mutex);
2187         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_param, param);
2188         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_header, (command | seq));
2189
2190         DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB\n", (command | seq));
2191
2192         do {
2193                 /* let the FW do it's magic ... */
2194                 msleep(delay);
2195
2196                 rc = SHMEM_RD(bp, func_mb[mb_idx].fw_mb_header);
2197
2198                 /* Give the FW up to 5 second (500*10ms) */
2199         } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
2200
2201         DP(BNX2X_MSG_MCP, "[after %d ms] read (%x) seq is (%x) from FW MB\n",
2202            cnt*delay, rc, seq);
2203
2204         /* is this a reply to our command? */
2205         if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK))
2206                 rc &= FW_MSG_CODE_MASK;
2207         else {
2208                 /* FW BUG! */
2209                 BNX2X_ERR("FW failed to respond!\n");
2210                 bnx2x_fw_dump(bp);
2211                 rc = 0;
2212         }
2213         mutex_unlock(&bp->fw_mb_mutex);
2214
2215         return rc;
2216 }
2217
2218 /* must be called under rtnl_lock */
2219 void bnx2x_rxq_set_mac_filters(struct bnx2x *bp, u16 cl_id, u32 filters)
2220 {
2221         u32 mask = (1 << cl_id);
2222
2223         /* initial seeting is BNX2X_ACCEPT_NONE */
2224         u8 drop_all_ucast = 1, drop_all_bcast = 1, drop_all_mcast = 1;
2225         u8 accp_all_ucast = 0, accp_all_bcast = 0, accp_all_mcast = 0;
2226         u8 unmatched_unicast = 0;
2227
2228         if (filters & BNX2X_PROMISCUOUS_MODE) {
2229                 /* promiscious - accept all, drop none */
2230                 drop_all_ucast = drop_all_bcast = drop_all_mcast = 0;
2231                 accp_all_ucast = accp_all_bcast = accp_all_mcast = 1;
2232         }
2233         if (filters & BNX2X_ACCEPT_UNICAST) {
2234                 /* accept matched ucast */
2235                 drop_all_ucast = 0;
2236         }
2237         if (filters & BNX2X_ACCEPT_MULTICAST) {
2238                 /* accept matched mcast */
2239                 drop_all_mcast = 0;
2240         }
2241         if (filters & BNX2X_ACCEPT_ALL_UNICAST) {
2242                 /* accept all mcast */
2243                 drop_all_ucast = 0;
2244                 accp_all_ucast = 1;
2245         }
2246         if (filters & BNX2X_ACCEPT_ALL_MULTICAST) {
2247                 /* accept all mcast */
2248                 drop_all_mcast = 0;
2249                 accp_all_mcast = 1;
2250         }
2251         if (filters & BNX2X_ACCEPT_BROADCAST) {
2252                 /* accept (all) bcast */
2253                 drop_all_bcast = 0;
2254                 accp_all_bcast = 1;
2255         }
2256
2257         bp->mac_filters.ucast_drop_all = drop_all_ucast ?
2258                 bp->mac_filters.ucast_drop_all | mask :
2259                 bp->mac_filters.ucast_drop_all & ~mask;
2260
2261         bp->mac_filters.mcast_drop_all = drop_all_mcast ?
2262                 bp->mac_filters.mcast_drop_all | mask :
2263                 bp->mac_filters.mcast_drop_all & ~mask;
2264
2265         bp->mac_filters.bcast_drop_all = drop_all_bcast ?
2266                 bp->mac_filters.bcast_drop_all | mask :
2267                 bp->mac_filters.bcast_drop_all & ~mask;
2268
2269         bp->mac_filters.ucast_accept_all = accp_all_ucast ?
2270                 bp->mac_filters.ucast_accept_all | mask :
2271                 bp->mac_filters.ucast_accept_all & ~mask;
2272
2273         bp->mac_filters.mcast_accept_all = accp_all_mcast ?
2274                 bp->mac_filters.mcast_accept_all | mask :
2275                 bp->mac_filters.mcast_accept_all & ~mask;
2276
2277         bp->mac_filters.bcast_accept_all = accp_all_bcast ?
2278                 bp->mac_filters.bcast_accept_all | mask :
2279                 bp->mac_filters.bcast_accept_all & ~mask;
2280
2281         bp->mac_filters.unmatched_unicast = unmatched_unicast ?
2282                 bp->mac_filters.unmatched_unicast | mask :
2283                 bp->mac_filters.unmatched_unicast & ~mask;
2284 }
2285
2286 void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p)
2287 {
2288         if (FUNC_CONFIG(p->func_flgs)) {
2289                 struct tstorm_eth_function_common_config tcfg = {0};
2290
2291                 /* tpa */
2292                 if (p->func_flgs & FUNC_FLG_TPA)
2293                         tcfg.config_flags |=
2294                         TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA;
2295
2296                 /* set rss flags */
2297                 if (p->func_flgs & FUNC_FLG_RSS) {
2298                         u16 rss_flgs = (p->rss->mode <<
2299                         TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT);
2300
2301                         if (p->rss->cap & RSS_IPV4_CAP)
2302                                 rss_flgs |= RSS_IPV4_CAP_MASK;
2303                         if (p->rss->cap & RSS_IPV4_TCP_CAP)
2304                                 rss_flgs |= RSS_IPV4_TCP_CAP_MASK;
2305                         if (p->rss->cap & RSS_IPV6_CAP)
2306                                 rss_flgs |= RSS_IPV6_CAP_MASK;
2307                         if (p->rss->cap & RSS_IPV6_TCP_CAP)
2308                                 rss_flgs |= RSS_IPV6_TCP_CAP_MASK;
2309
2310                         tcfg.config_flags |= rss_flgs;
2311                         tcfg.rss_result_mask = p->rss->result_mask;
2312
2313                 }
2314
2315                 storm_memset_func_cfg(bp, &tcfg, p->func_id);
2316         }
2317
2318         /* Enable the function in the FW */
2319         storm_memset_vf_to_pf(bp, p->func_id, p->pf_id);
2320         storm_memset_func_en(bp, p->func_id, 1);
2321
2322         /* statistics */
2323         if (p->func_flgs & FUNC_FLG_STATS) {
2324                 struct stats_indication_flags stats_flags = {0};
2325                 stats_flags.collect_eth = 1;
2326
2327                 storm_memset_xstats_flags(bp, &stats_flags, p->func_id);
2328                 storm_memset_xstats_addr(bp, p->fw_stat_map, p->func_id);
2329
2330                 storm_memset_tstats_flags(bp, &stats_flags, p->func_id);
2331                 storm_memset_tstats_addr(bp, p->fw_stat_map, p->func_id);
2332
2333                 storm_memset_ustats_flags(bp, &stats_flags, p->func_id);
2334                 storm_memset_ustats_addr(bp, p->fw_stat_map, p->func_id);
2335
2336                 storm_memset_cstats_flags(bp, &stats_flags, p->func_id);
2337                 storm_memset_cstats_addr(bp, p->fw_stat_map, p->func_id);
2338         }
2339
2340         /* spq */
2341         if (p->func_flgs & FUNC_FLG_SPQ) {
2342                 storm_memset_spq_addr(bp, p->spq_map, p->func_id);
2343                 REG_WR(bp, XSEM_REG_FAST_MEMORY +
2344                        XSTORM_SPQ_PROD_OFFSET(p->func_id), p->spq_prod);
2345         }
2346 }
2347
2348 static inline u16 bnx2x_get_cl_flags(struct bnx2x *bp,
2349                                      struct bnx2x_fastpath *fp)
2350 {
2351         u16 flags = 0;
2352
2353         /* calculate queue flags */
2354         flags |= QUEUE_FLG_CACHE_ALIGN;
2355         flags |= QUEUE_FLG_HC;
2356         flags |= IS_MF(bp) ? QUEUE_FLG_OV : 0;
2357
2358 #ifdef BCM_VLAN
2359         flags |= QUEUE_FLG_VLAN;
2360         DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
2361 #endif
2362
2363         if (!fp->disable_tpa)
2364                 flags |= QUEUE_FLG_TPA;
2365
2366         flags |= QUEUE_FLG_STATS;
2367
2368         return flags;
2369 }
2370
2371 static void bnx2x_pf_rx_cl_prep(struct bnx2x *bp,
2372         struct bnx2x_fastpath *fp, struct rxq_pause_params *pause,
2373         struct bnx2x_rxq_init_params *rxq_init)
2374 {
2375         u16 max_sge = 0;
2376         u16 sge_sz = 0;
2377         u16 tpa_agg_size = 0;
2378
2379         /* calculate queue flags */
2380         u16 flags = bnx2x_get_cl_flags(bp, fp);
2381
2382         if (!fp->disable_tpa) {
2383                 pause->sge_th_hi = 250;
2384                 pause->sge_th_lo = 150;
2385                 tpa_agg_size = min_t(u32,
2386                         (min_t(u32, 8, MAX_SKB_FRAGS) *
2387                         SGE_PAGE_SIZE * PAGES_PER_SGE), 0xffff);
2388                 max_sge = SGE_PAGE_ALIGN(bp->dev->mtu) >>
2389                         SGE_PAGE_SHIFT;
2390                 max_sge = ((max_sge + PAGES_PER_SGE - 1) &
2391                           (~(PAGES_PER_SGE-1))) >> PAGES_PER_SGE_SHIFT;
2392                 sge_sz = (u16)min_t(u32, SGE_PAGE_SIZE * PAGES_PER_SGE,
2393                                     0xffff);
2394         }
2395
2396         /* pause - not for e1 */
2397         if (!CHIP_IS_E1(bp)) {
2398                 pause->bd_th_hi = 350;
2399                 pause->bd_th_lo = 250;
2400                 pause->rcq_th_hi = 350;
2401                 pause->rcq_th_lo = 250;
2402                 pause->sge_th_hi = 0;
2403                 pause->sge_th_lo = 0;
2404                 pause->pri_map = 1;
2405         }
2406
2407         /* rxq setup */
2408         rxq_init->flags = flags;
2409         rxq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2410         rxq_init->dscr_map = fp->rx_desc_mapping;
2411         rxq_init->sge_map = fp->rx_sge_mapping;
2412         rxq_init->rcq_map = fp->rx_comp_mapping;
2413         rxq_init->rcq_np_map = fp->rx_comp_mapping + BCM_PAGE_SIZE;
2414         rxq_init->mtu = bp->dev->mtu;
2415         rxq_init->buf_sz = bp->rx_buf_size;
2416         rxq_init->cl_qzone_id = fp->cl_qzone_id;
2417         rxq_init->cl_id = fp->cl_id;
2418         rxq_init->spcl_id = fp->cl_id;
2419         rxq_init->stat_id = fp->cl_id;
2420         rxq_init->tpa_agg_sz = tpa_agg_size;
2421         rxq_init->sge_buf_sz = sge_sz;
2422         rxq_init->max_sges_pkt = max_sge;
2423         rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
2424         rxq_init->fw_sb_id = fp->fw_sb_id;
2425
2426         rxq_init->sb_cq_index = U_SB_ETH_RX_CQ_INDEX;
2427
2428         rxq_init->cid = HW_CID(bp, fp->cid);
2429
2430         rxq_init->hc_rate = bp->rx_ticks ? (1000000 / bp->rx_ticks) : 0;
2431 }
2432
2433 static void bnx2x_pf_tx_cl_prep(struct bnx2x *bp,
2434         struct bnx2x_fastpath *fp, struct bnx2x_txq_init_params *txq_init)
2435 {
2436         u16 flags = bnx2x_get_cl_flags(bp, fp);
2437
2438         txq_init->flags = flags;
2439         txq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2440         txq_init->dscr_map = fp->tx_desc_mapping;
2441         txq_init->stat_id = fp->cl_id;
2442         txq_init->cid = HW_CID(bp, fp->cid);
2443         txq_init->sb_cq_index = C_SB_ETH_TX_CQ_INDEX;
2444         txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
2445         txq_init->fw_sb_id = fp->fw_sb_id;
2446         txq_init->hc_rate = bp->tx_ticks ? (1000000 / bp->tx_ticks) : 0;
2447 }
2448
2449 void bnx2x_pf_init(struct bnx2x *bp)
2450 {
2451         struct bnx2x_func_init_params func_init = {0};
2452         struct bnx2x_rss_params rss = {0};
2453         struct event_ring_data eq_data = { {0} };
2454         u16 flags;
2455
2456         /* pf specific setups */
2457         if (!CHIP_IS_E1(bp))
2458                 storm_memset_ov(bp, bp->mf_ov, BP_FUNC(bp));
2459
2460         if (CHIP_IS_E2(bp)) {
2461                 /* reset IGU PF statistics: MSIX + ATTN */
2462                 /* PF */
2463                 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
2464                            BNX2X_IGU_STAS_MSG_VF_CNT*4 +
2465                            (CHIP_MODE_IS_4_PORT(bp) ?
2466                                 BP_FUNC(bp) : BP_VN(bp))*4, 0);
2467                 /* ATTN */
2468                 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
2469                            BNX2X_IGU_STAS_MSG_VF_CNT*4 +
2470                            BNX2X_IGU_STAS_MSG_PF_CNT*4 +
2471                            (CHIP_MODE_IS_4_PORT(bp) ?
2472                                 BP_FUNC(bp) : BP_VN(bp))*4, 0);
2473         }
2474
2475         /* function setup flags */
2476         flags = (FUNC_FLG_STATS | FUNC_FLG_LEADING | FUNC_FLG_SPQ);
2477
2478         if (CHIP_IS_E1x(bp))
2479                 flags |= (bp->flags & TPA_ENABLE_FLAG) ? FUNC_FLG_TPA : 0;
2480         else
2481                 flags |= FUNC_FLG_TPA;
2482
2483         /**
2484          * Although RSS is meaningless when there is a single HW queue we
2485          * still need it enabled in order to have HW Rx hash generated.
2486          *
2487          * if (is_eth_multi(bp))
2488          *      flags |= FUNC_FLG_RSS;
2489          */
2490
2491         /* function setup */
2492         if (flags & FUNC_FLG_RSS) {
2493                 rss.cap = (RSS_IPV4_CAP | RSS_IPV4_TCP_CAP |
2494                            RSS_IPV6_CAP | RSS_IPV6_TCP_CAP);
2495                 rss.mode = bp->multi_mode;
2496                 rss.result_mask = MULTI_MASK;
2497                 func_init.rss = &rss;
2498         }
2499
2500         func_init.func_flgs = flags;
2501         func_init.pf_id = BP_FUNC(bp);
2502         func_init.func_id = BP_FUNC(bp);
2503         func_init.fw_stat_map = bnx2x_sp_mapping(bp, fw_stats);
2504         func_init.spq_map = bp->spq_mapping;
2505         func_init.spq_prod = bp->spq_prod_idx;
2506
2507         bnx2x_func_init(bp, &func_init);
2508
2509         memset(&(bp->cmng), 0, sizeof(struct cmng_struct_per_port));
2510
2511         /*
2512         Congestion management values depend on the link rate
2513         There is no active link so initial link rate is set to 10 Gbps.
2514         When the link comes up The congestion management values are
2515         re-calculated according to the actual link rate.
2516         */
2517         bp->link_vars.line_speed = SPEED_10000;
2518         bnx2x_cmng_fns_init(bp, true, bnx2x_get_cmng_fns_mode(bp));
2519
2520         /* Only the PMF sets the HW */
2521         if (bp->port.pmf)
2522                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2523
2524         /* no rx until link is up */
2525         bp->rx_mode = BNX2X_RX_MODE_NONE;
2526         bnx2x_set_storm_rx_mode(bp);
2527
2528         /* init Event Queue */
2529         eq_data.base_addr.hi = U64_HI(bp->eq_mapping);
2530         eq_data.base_addr.lo = U64_LO(bp->eq_mapping);
2531         eq_data.producer = bp->eq_prod;
2532         eq_data.index_id = HC_SP_INDEX_EQ_CONS;
2533         eq_data.sb_id = DEF_SB_ID;
2534         storm_memset_eq_data(bp, &eq_data, BP_FUNC(bp));
2535 }
2536
2537
2538 static void bnx2x_e1h_disable(struct bnx2x *bp)
2539 {
2540         int port = BP_PORT(bp);
2541
2542         netif_tx_disable(bp->dev);
2543
2544         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
2545
2546         netif_carrier_off(bp->dev);
2547 }
2548
2549 static void bnx2x_e1h_enable(struct bnx2x *bp)
2550 {
2551         int port = BP_PORT(bp);
2552
2553         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
2554
2555         /* Tx queue should be only reenabled */
2556         netif_tx_wake_all_queues(bp->dev);
2557
2558         /*
2559          * Should not call netif_carrier_on since it will be called if the link
2560          * is up when checking for link state
2561          */
2562 }
2563
2564 static void bnx2x_dcc_event(struct bnx2x *bp, u32 dcc_event)
2565 {
2566         DP(BNX2X_MSG_MCP, "dcc_event 0x%x\n", dcc_event);
2567
2568         if (dcc_event & DRV_STATUS_DCC_DISABLE_ENABLE_PF) {
2569
2570                 /*
2571                  * This is the only place besides the function initialization
2572                  * where the bp->flags can change so it is done without any
2573                  * locks
2574                  */
2575                 if (bp->mf_config[BP_VN(bp)] & FUNC_MF_CFG_FUNC_DISABLED) {
2576                         DP(NETIF_MSG_IFDOWN, "mf_cfg function disabled\n");
2577                         bp->flags |= MF_FUNC_DIS;
2578
2579                         bnx2x_e1h_disable(bp);
2580                 } else {
2581                         DP(NETIF_MSG_IFUP, "mf_cfg function enabled\n");
2582                         bp->flags &= ~MF_FUNC_DIS;
2583
2584                         bnx2x_e1h_enable(bp);
2585                 }
2586                 dcc_event &= ~DRV_STATUS_DCC_DISABLE_ENABLE_PF;
2587         }
2588         if (dcc_event & DRV_STATUS_DCC_BANDWIDTH_ALLOCATION) {
2589
2590                 bnx2x_cmng_fns_init(bp, true, CMNG_FNS_MINMAX);
2591                 bnx2x_link_sync_notify(bp);
2592                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2593                 dcc_event &= ~DRV_STATUS_DCC_BANDWIDTH_ALLOCATION;
2594         }
2595
2596         /* Report results to MCP */
2597         if (dcc_event)
2598                 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_FAILURE, 0);
2599         else
2600                 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_OK, 0);
2601 }
2602
2603 /* must be called under the spq lock */
2604 static inline struct eth_spe *bnx2x_sp_get_next(struct bnx2x *bp)
2605 {
2606         struct eth_spe *next_spe = bp->spq_prod_bd;
2607
2608         if (bp->spq_prod_bd == bp->spq_last_bd) {
2609                 bp->spq_prod_bd = bp->spq;
2610                 bp->spq_prod_idx = 0;
2611                 DP(NETIF_MSG_TIMER, "end of spq\n");
2612         } else {
2613                 bp->spq_prod_bd++;
2614                 bp->spq_prod_idx++;
2615         }
2616         return next_spe;
2617 }
2618
2619 /* must be called under the spq lock */
2620 static inline void bnx2x_sp_prod_update(struct bnx2x *bp)
2621 {
2622         int func = BP_FUNC(bp);
2623
2624         /* Make sure that BD data is updated before writing the producer */
2625         wmb();
2626
2627         REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func),
2628                bp->spq_prod_idx);
2629         mmiowb();
2630 }
2631
2632 /* the slow path queue is odd since completions arrive on the fastpath ring */
2633 int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
2634                          u32 data_hi, u32 data_lo, int common)
2635 {
2636         struct eth_spe *spe;
2637         u16 type;
2638
2639 #ifdef BNX2X_STOP_ON_ERROR
2640         if (unlikely(bp->panic))
2641                 return -EIO;
2642 #endif
2643
2644         spin_lock_bh(&bp->spq_lock);
2645
2646         if (!atomic_read(&bp->spq_left)) {
2647                 BNX2X_ERR("BUG! SPQ ring full!\n");
2648                 spin_unlock_bh(&bp->spq_lock);
2649                 bnx2x_panic();
2650                 return -EBUSY;
2651         }
2652
2653         spe = bnx2x_sp_get_next(bp);
2654
2655         /* CID needs port number to be encoded int it */
2656         spe->hdr.conn_and_cmd_data =
2657                         cpu_to_le32((command << SPE_HDR_CMD_ID_SHIFT) |
2658                                     HW_CID(bp, cid));
2659
2660         if (common)
2661                 /* Common ramrods:
2662                  *      FUNC_START, FUNC_STOP, CFC_DEL, STATS, SET_MAC
2663                  *      TRAFFIC_STOP, TRAFFIC_START
2664                  */
2665                 type = (NONE_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2666                         & SPE_HDR_CONN_TYPE;
2667         else
2668                 /* ETH ramrods: SETUP, HALT */
2669                 type = (ETH_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2670                         & SPE_HDR_CONN_TYPE;
2671
2672         type |= ((BP_FUNC(bp) << SPE_HDR_FUNCTION_ID_SHIFT) &
2673                  SPE_HDR_FUNCTION_ID);
2674
2675         spe->hdr.type = cpu_to_le16(type);
2676
2677         spe->data.update_data_addr.hi = cpu_to_le32(data_hi);
2678         spe->data.update_data_addr.lo = cpu_to_le32(data_lo);
2679
2680         /* stats ramrod has it's own slot on the spq */
2681         if (command != RAMROD_CMD_ID_COMMON_STAT_QUERY)
2682                 /* It's ok if the actual decrement is issued towards the memory
2683                  * somewhere between the spin_lock and spin_unlock. Thus no
2684                  * more explict memory barrier is needed.
2685                  */
2686                 atomic_dec(&bp->spq_left);
2687
2688         DP(BNX2X_MSG_SP/*NETIF_MSG_TIMER*/,
2689            "SPQE[%x] (%x:%x)  command %d  hw_cid %x  data (%x:%x) "
2690            "type(0x%x) left %x\n",
2691            bp->spq_prod_idx, (u32)U64_HI(bp->spq_mapping),
2692            (u32)(U64_LO(bp->spq_mapping) +
2693            (void *)bp->spq_prod_bd - (void *)bp->spq), command,
2694            HW_CID(bp, cid), data_hi, data_lo, type, atomic_read(&bp->spq_left));
2695
2696         bnx2x_sp_prod_update(bp);
2697         spin_unlock_bh(&bp->spq_lock);
2698         return 0;
2699 }
2700
2701 /* acquire split MCP access lock register */
2702 static int bnx2x_acquire_alr(struct bnx2x *bp)
2703 {
2704         u32 j, val;
2705         int rc = 0;
2706
2707         might_sleep();
2708         for (j = 0; j < 1000; j++) {
2709                 val = (1UL << 31);
2710                 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
2711                 val = REG_RD(bp, GRCBASE_MCP + 0x9c);
2712                 if (val & (1L << 31))
2713                         break;
2714
2715                 msleep(5);
2716         }
2717         if (!(val & (1L << 31))) {
2718                 BNX2X_ERR("Cannot acquire MCP access lock register\n");
2719                 rc = -EBUSY;
2720         }
2721
2722         return rc;
2723 }
2724
2725 /* release split MCP access lock register */
2726 static void bnx2x_release_alr(struct bnx2x *bp)
2727 {
2728         REG_WR(bp, GRCBASE_MCP + 0x9c, 0);
2729 }
2730
2731 #define BNX2X_DEF_SB_ATT_IDX    0x0001
2732 #define BNX2X_DEF_SB_IDX        0x0002
2733
2734 static inline u16 bnx2x_update_dsb_idx(struct bnx2x *bp)
2735 {
2736         struct host_sp_status_block *def_sb = bp->def_status_blk;
2737         u16 rc = 0;
2738
2739         barrier(); /* status block is written to by the chip */
2740         if (bp->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
2741                 bp->def_att_idx = def_sb->atten_status_block.attn_bits_index;
2742                 rc |= BNX2X_DEF_SB_ATT_IDX;
2743         }
2744
2745         if (bp->def_idx != def_sb->sp_sb.running_index) {
2746                 bp->def_idx = def_sb->sp_sb.running_index;
2747                 rc |= BNX2X_DEF_SB_IDX;
2748         }
2749
2750         /* Do not reorder: indecies reading should complete before handling */
2751         barrier();
2752         return rc;
2753 }
2754
2755 /*
2756  * slow path service functions
2757  */
2758
2759 static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
2760 {
2761         int port = BP_PORT(bp);
2762         u32 aeu_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
2763                               MISC_REG_AEU_MASK_ATTN_FUNC_0;
2764         u32 nig_int_mask_addr = port ? NIG_REG_MASK_INTERRUPT_PORT1 :
2765                                        NIG_REG_MASK_INTERRUPT_PORT0;
2766         u32 aeu_mask;
2767         u32 nig_mask = 0;
2768         u32 reg_addr;
2769
2770         if (bp->attn_state & asserted)
2771                 BNX2X_ERR("IGU ERROR\n");
2772
2773         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2774         aeu_mask = REG_RD(bp, aeu_addr);
2775
2776         DP(NETIF_MSG_HW, "aeu_mask %x  newly asserted %x\n",
2777            aeu_mask, asserted);
2778         aeu_mask &= ~(asserted & 0x3ff);
2779         DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
2780
2781         REG_WR(bp, aeu_addr, aeu_mask);
2782         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2783
2784         DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
2785         bp->attn_state |= asserted;
2786         DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
2787
2788         if (asserted & ATTN_HARD_WIRED_MASK) {
2789                 if (asserted & ATTN_NIG_FOR_FUNC) {
2790
2791                         bnx2x_acquire_phy_lock(bp);
2792
2793                         /* save nig interrupt mask */
2794                         nig_mask = REG_RD(bp, nig_int_mask_addr);
2795                         REG_WR(bp, nig_int_mask_addr, 0);
2796
2797                         bnx2x_link_attn(bp);
2798
2799                         /* handle unicore attn? */
2800                 }
2801                 if (asserted & ATTN_SW_TIMER_4_FUNC)
2802                         DP(NETIF_MSG_HW, "ATTN_SW_TIMER_4_FUNC!\n");
2803
2804                 if (asserted & GPIO_2_FUNC)
2805                         DP(NETIF_MSG_HW, "GPIO_2_FUNC!\n");
2806
2807                 if (asserted & GPIO_3_FUNC)
2808                         DP(NETIF_MSG_HW, "GPIO_3_FUNC!\n");
2809
2810                 if (asserted & GPIO_4_FUNC)
2811                         DP(NETIF_MSG_HW, "GPIO_4_FUNC!\n");
2812
2813                 if (port == 0) {
2814                         if (asserted & ATTN_GENERAL_ATTN_1) {
2815                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_1!\n");
2816                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
2817                         }
2818                         if (asserted & ATTN_GENERAL_ATTN_2) {
2819                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_2!\n");
2820                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
2821                         }
2822                         if (asserted & ATTN_GENERAL_ATTN_3) {
2823                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_3!\n");
2824                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
2825                         }
2826                 } else {
2827                         if (asserted & ATTN_GENERAL_ATTN_4) {
2828                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_4!\n");
2829                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
2830                         }
2831                         if (asserted & ATTN_GENERAL_ATTN_5) {
2832                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_5!\n");
2833                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
2834                         }
2835                         if (asserted & ATTN_GENERAL_ATTN_6) {
2836                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_6!\n");
2837                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
2838                         }
2839                 }
2840
2841         } /* if hardwired */
2842
2843         if (bp->common.int_block == INT_BLOCK_HC)
2844                 reg_addr = (HC_REG_COMMAND_REG + port*32 +
2845                             COMMAND_REG_ATTN_BITS_SET);
2846         else
2847                 reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_SET_UPPER*8);
2848
2849         DP(NETIF_MSG_HW, "about to mask 0x%08x at %s addr 0x%x\n", asserted,
2850            (bp->common.int_block == INT_BLOCK_HC) ? "HC" : "IGU", reg_addr);
2851         REG_WR(bp, reg_addr, asserted);
2852
2853         /* now set back the mask */
2854         if (asserted & ATTN_NIG_FOR_FUNC) {
2855                 REG_WR(bp, nig_int_mask_addr, nig_mask);
2856                 bnx2x_release_phy_lock(bp);
2857         }
2858 }
2859
2860 static inline void bnx2x_fan_failure(struct bnx2x *bp)
2861 {
2862         int port = BP_PORT(bp);
2863         u32 ext_phy_config;
2864         /* mark the failure */
2865         ext_phy_config =
2866                 SHMEM_RD(bp,
2867                          dev_info.port_hw_config[port].external_phy_config);
2868
2869         ext_phy_config &= ~PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK;
2870         ext_phy_config |= PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE;
2871         SHMEM_WR(bp, dev_info.port_hw_config[port].external_phy_config,
2872                  ext_phy_config);
2873
2874         /* log the failure */
2875         netdev_err(bp->dev, "Fan Failure on Network Controller has caused"
2876                " the driver to shutdown the card to prevent permanent"
2877                " damage.  Please contact OEM Support for assistance\n");
2878 }
2879
2880 static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
2881 {
2882         int port = BP_PORT(bp);
2883         int reg_offset;
2884         u32 val;
2885
2886         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
2887                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
2888
2889         if (attn & AEU_INPUTS_ATTN_BITS_SPIO5) {
2890
2891                 val = REG_RD(bp, reg_offset);
2892                 val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
2893                 REG_WR(bp, reg_offset, val);
2894
2895                 BNX2X_ERR("SPIO5 hw attention\n");
2896
2897                 /* Fan failure attention */
2898                 bnx2x_hw_reset_phy(&bp->link_params);
2899                 bnx2x_fan_failure(bp);
2900         }
2901
2902         if (attn & (AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0 |
2903                     AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1)) {
2904                 bnx2x_acquire_phy_lock(bp);
2905                 bnx2x_handle_module_detect_int(&bp->link_params);
2906                 bnx2x_release_phy_lock(bp);
2907         }
2908
2909         if (attn & HW_INTERRUT_ASSERT_SET_0) {
2910
2911                 val = REG_RD(bp, reg_offset);
2912                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_0);
2913                 REG_WR(bp, reg_offset, val);
2914
2915                 BNX2X_ERR("FATAL HW block attention set0 0x%x\n",
2916                           (u32)(attn & HW_INTERRUT_ASSERT_SET_0));
2917                 bnx2x_panic();
2918         }
2919 }
2920
2921 static inline void bnx2x_attn_int_deasserted1(struct bnx2x *bp, u32 attn)
2922 {
2923         u32 val;
2924
2925         if (attn & AEU_INPUTS_ATTN_BITS_DOORBELLQ_HW_INTERRUPT) {
2926
2927                 val = REG_RD(bp, DORQ_REG_DORQ_INT_STS_CLR);
2928                 BNX2X_ERR("DB hw attention 0x%x\n", val);
2929                 /* DORQ discard attention */
2930                 if (val & 0x2)
2931                         BNX2X_ERR("FATAL error from DORQ\n");
2932         }
2933
2934         if (attn & HW_INTERRUT_ASSERT_SET_1) {
2935
2936                 int port = BP_PORT(bp);
2937                 int reg_offset;
2938
2939                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_1 :
2940                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_1);
2941
2942                 val = REG_RD(bp, reg_offset);
2943                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
2944                 REG_WR(bp, reg_offset, val);
2945
2946                 BNX2X_ERR("FATAL HW block attention set1 0x%x\n",
2947                           (u32)(attn & HW_INTERRUT_ASSERT_SET_1));
2948                 bnx2x_panic();
2949         }
2950 }
2951
2952 static inline void bnx2x_attn_int_deasserted2(struct bnx2x *bp, u32 attn)
2953 {
2954         u32 val;
2955
2956         if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
2957
2958                 val = REG_RD(bp, CFC_REG_CFC_INT_STS_CLR);
2959                 BNX2X_ERR("CFC hw attention 0x%x\n", val);
2960                 /* CFC error attention */
2961                 if (val & 0x2)
2962                         BNX2X_ERR("FATAL error from CFC\n");
2963         }
2964
2965         if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
2966
2967                 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_0);
2968                 BNX2X_ERR("PXP hw attention 0x%x\n", val);
2969                 /* RQ_USDMDP_FIFO_OVERFLOW */
2970                 if (val & 0x18000)
2971                         BNX2X_ERR("FATAL error from PXP\n");
2972                 if (CHIP_IS_E2(bp)) {
2973                         val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_1);
2974                         BNX2X_ERR("PXP hw attention-1 0x%x\n", val);
2975                 }
2976         }
2977
2978         if (attn & HW_INTERRUT_ASSERT_SET_2) {
2979
2980                 int port = BP_PORT(bp);
2981                 int reg_offset;
2982
2983                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_2 :
2984                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_2);
2985
2986                 val = REG_RD(bp, reg_offset);
2987                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
2988                 REG_WR(bp, reg_offset, val);
2989
2990                 BNX2X_ERR("FATAL HW block attention set2 0x%x\n",
2991                           (u32)(attn & HW_INTERRUT_ASSERT_SET_2));
2992                 bnx2x_panic();
2993         }
2994 }
2995
2996 static inline void bnx2x_attn_int_deasserted3(struct bnx2x *bp, u32 attn)
2997 {
2998         u32 val;
2999
3000         if (attn & EVEREST_GEN_ATTN_IN_USE_MASK) {
3001
3002                 if (attn & BNX2X_PMF_LINK_ASSERT) {
3003                         int func = BP_FUNC(bp);
3004
3005                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
3006                         bp->mf_config[BP_VN(bp)] = MF_CFG_RD(bp,
3007                                         func_mf_config[BP_ABS_FUNC(bp)].config);
3008                         val = SHMEM_RD(bp,
3009                                        func_mb[BP_FW_MB_IDX(bp)].drv_status);
3010                         if (val & DRV_STATUS_DCC_EVENT_MASK)
3011                                 bnx2x_dcc_event(bp,
3012                                             (val & DRV_STATUS_DCC_EVENT_MASK));
3013                         bnx2x__link_status_update(bp);
3014                         if ((bp->port.pmf == 0) && (val & DRV_STATUS_PMF))
3015                                 bnx2x_pmf_update(bp);
3016
3017                 } else if (attn & BNX2X_MC_ASSERT_BITS) {
3018
3019                         BNX2X_ERR("MC assert!\n");
3020                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_10, 0);
3021                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_9, 0);
3022                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_8, 0);
3023                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_7, 0);
3024                         bnx2x_panic();
3025
3026                 } else if (attn & BNX2X_MCP_ASSERT) {
3027
3028                         BNX2X_ERR("MCP assert!\n");
3029                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_11, 0);
3030                         bnx2x_fw_dump(bp);
3031
3032                 } else
3033                         BNX2X_ERR("Unknown HW assert! (attn 0x%x)\n", attn);
3034         }
3035
3036         if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
3037                 BNX2X_ERR("LATCHED attention 0x%08x (masked)\n", attn);
3038                 if (attn & BNX2X_GRC_TIMEOUT) {
3039                         val = CHIP_IS_E1(bp) ? 0 :
3040                                         REG_RD(bp, MISC_REG_GRC_TIMEOUT_ATTN);
3041                         BNX2X_ERR("GRC time-out 0x%08x\n", val);
3042                 }
3043                 if (attn & BNX2X_GRC_RSV) {
3044                         val = CHIP_IS_E1(bp) ? 0 :
3045                                         REG_RD(bp, MISC_REG_GRC_RSV_ATTN);
3046                         BNX2X_ERR("GRC reserved 0x%08x\n", val);
3047                 }
3048                 REG_WR(bp, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
3049         }
3050 }
3051
3052 #define BNX2X_MISC_GEN_REG      MISC_REG_GENERIC_POR_1
3053 #define LOAD_COUNTER_BITS       16 /* Number of bits for load counter */
3054 #define LOAD_COUNTER_MASK       (((u32)0x1 << LOAD_COUNTER_BITS) - 1)
3055 #define RESET_DONE_FLAG_MASK    (~LOAD_COUNTER_MASK)
3056 #define RESET_DONE_FLAG_SHIFT   LOAD_COUNTER_BITS
3057 #define CHIP_PARITY_SUPPORTED(bp)   (CHIP_IS_E1(bp) || CHIP_IS_E1H(bp))
3058 /*
3059  * should be run under rtnl lock
3060  */
3061 static inline void bnx2x_set_reset_done(struct bnx2x *bp)
3062 {
3063         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3064         val &= ~(1 << RESET_DONE_FLAG_SHIFT);
3065         REG_WR(bp, BNX2X_MISC_GEN_REG, val);
3066         barrier();
3067         mmiowb();
3068 }
3069
3070 /*
3071  * should be run under rtnl lock
3072  */
3073 static inline void bnx2x_set_reset_in_progress(struct bnx2x *bp)
3074 {
3075         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3076         val |= (1 << 16);
3077         REG_WR(bp, BNX2X_MISC_GEN_REG, val);
3078         barrier();
3079         mmiowb();
3080 }
3081
3082 /*
3083  * should be run under rtnl lock
3084  */
3085 bool bnx2x_reset_is_done(struct bnx2x *bp)
3086 {
3087         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3088         DP(NETIF_MSG_HW, "GEN_REG_VAL=0x%08x\n", val);
3089         return (val & RESET_DONE_FLAG_MASK) ? false : true;
3090 }
3091
3092 /*
3093  * should be run under rtnl lock
3094  */
3095 inline void bnx2x_inc_load_cnt(struct bnx2x *bp)
3096 {
3097         u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3098
3099         DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
3100
3101         val1 = ((val & LOAD_COUNTER_MASK) + 1) & LOAD_COUNTER_MASK;
3102         REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
3103         barrier();
3104         mmiowb();
3105 }
3106
3107 /*
3108  * should be run under rtnl lock
3109  */
3110 u32 bnx2x_dec_load_cnt(struct bnx2x *bp)
3111 {
3112         u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3113
3114         DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
3115
3116         val1 = ((val & LOAD_COUNTER_MASK) - 1) & LOAD_COUNTER_MASK;
3117         REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
3118         barrier();
3119         mmiowb();
3120
3121         return val1;
3122 }
3123
3124 /*
3125  * should be run under rtnl lock
3126  */
3127 static inline u32 bnx2x_get_load_cnt(struct bnx2x *bp)
3128 {
3129         return REG_RD(bp, BNX2X_MISC_GEN_REG) & LOAD_COUNTER_MASK;
3130 }
3131
3132 static inline void bnx2x_clear_load_cnt(struct bnx2x *bp)
3133 {
3134         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3135         REG_WR(bp, BNX2X_MISC_GEN_REG, val & (~LOAD_COUNTER_MASK));
3136 }
3137
3138 static inline void _print_next_block(int idx, const char *blk)
3139 {
3140         if (idx)
3141                 pr_cont(", ");
3142         pr_cont("%s", blk);
3143 }
3144
3145 static inline int bnx2x_print_blocks_with_parity0(u32 sig, int par_num)
3146 {
3147         int i = 0;
3148         u32 cur_bit = 0;
3149         for (i = 0; sig; i++) {
3150                 cur_bit = ((u32)0x1 << i);
3151                 if (sig & cur_bit) {
3152                         switch (cur_bit) {
3153                         case AEU_INPUTS_ATTN_BITS_BRB_PARITY_ERROR:
3154                                 _print_next_block(par_num++, "BRB");
3155                                 break;
3156                         case AEU_INPUTS_ATTN_BITS_PARSER_PARITY_ERROR:
3157                                 _print_next_block(par_num++, "PARSER");
3158                                 break;
3159                         case AEU_INPUTS_ATTN_BITS_TSDM_PARITY_ERROR:
3160                                 _print_next_block(par_num++, "TSDM");
3161                                 break;
3162                         case AEU_INPUTS_ATTN_BITS_SEARCHER_PARITY_ERROR:
3163                                 _print_next_block(par_num++, "SEARCHER");
3164                                 break;
3165                         case AEU_INPUTS_ATTN_BITS_TSEMI_PARITY_ERROR:
3166                                 _print_next_block(par_num++, "TSEMI");
3167                                 break;
3168                         }
3169
3170                         /* Clear the bit */
3171                         sig &= ~cur_bit;
3172                 }
3173         }
3174
3175         return par_num;
3176 }
3177
3178 static inline int bnx2x_print_blocks_with_parity1(u32 sig, int par_num)
3179 {
3180         int i = 0;
3181         u32 cur_bit = 0;
3182         for (i = 0; sig; i++) {
3183                 cur_bit = ((u32)0x1 << i);
3184                 if (sig & cur_bit) {
3185                         switch (cur_bit) {
3186                         case AEU_INPUTS_ATTN_BITS_PBCLIENT_PARITY_ERROR:
3187                                 _print_next_block(par_num++, "PBCLIENT");
3188                                 break;
3189                         case AEU_INPUTS_ATTN_BITS_QM_PARITY_ERROR:
3190                                 _print_next_block(par_num++, "QM");
3191                                 break;
3192                         case AEU_INPUTS_ATTN_BITS_XSDM_PARITY_ERROR:
3193                                 _print_next_block(par_num++, "XSDM");
3194                                 break;
3195                         case AEU_INPUTS_ATTN_BITS_XSEMI_PARITY_ERROR:
3196                                 _print_next_block(par_num++, "XSEMI");
3197                                 break;
3198                         case AEU_INPUTS_ATTN_BITS_DOORBELLQ_PARITY_ERROR:
3199                                 _print_next_block(par_num++, "DOORBELLQ");
3200                                 break;
3201                         case AEU_INPUTS_ATTN_BITS_VAUX_PCI_CORE_PARITY_ERROR:
3202                                 _print_next_block(par_num++, "VAUX PCI CORE");
3203                                 break;
3204                         case AEU_INPUTS_ATTN_BITS_DEBUG_PARITY_ERROR:
3205                                 _print_next_block(par_num++, "DEBUG");
3206                                 break;
3207                         case AEU_INPUTS_ATTN_BITS_USDM_PARITY_ERROR:
3208                                 _print_next_block(par_num++, "USDM");
3209                                 break;
3210                         case AEU_INPUTS_ATTN_BITS_USEMI_PARITY_ERROR:
3211                                 _print_next_block(par_num++, "USEMI");
3212                                 break;
3213                         case AEU_INPUTS_ATTN_BITS_UPB_PARITY_ERROR:
3214                                 _print_next_block(par_num++, "UPB");
3215                                 break;
3216                         case AEU_INPUTS_ATTN_BITS_CSDM_PARITY_ERROR:
3217                                 _print_next_block(par_num++, "CSDM");
3218                                 break;
3219                         }
3220
3221                         /* Clear the bit */
3222                         sig &= ~cur_bit;
3223                 }
3224         }
3225
3226         return par_num;
3227 }
3228
3229 static inline int bnx2x_print_blocks_with_parity2(u32 sig, int par_num)
3230 {
3231         int i = 0;
3232         u32 cur_bit = 0;
3233         for (i = 0; sig; i++) {
3234                 cur_bit = ((u32)0x1 << i);
3235                 if (sig & cur_bit) {
3236                         switch (cur_bit) {
3237                         case AEU_INPUTS_ATTN_BITS_CSEMI_PARITY_ERROR:
3238                                 _print_next_block(par_num++, "CSEMI");
3239                                 break;
3240                         case AEU_INPUTS_ATTN_BITS_PXP_PARITY_ERROR:
3241                                 _print_next_block(par_num++, "PXP");
3242                                 break;
3243                         case AEU_IN_ATTN_BITS_PXPPCICLOCKCLIENT_PARITY_ERROR:
3244                                 _print_next_block(par_num++,
3245                                         "PXPPCICLOCKCLIENT");
3246                                 break;
3247                         case AEU_INPUTS_ATTN_BITS_CFC_PARITY_ERROR:
3248                                 _print_next_block(par_num++, "CFC");
3249                                 break;
3250                         case AEU_INPUTS_ATTN_BITS_CDU_PARITY_ERROR:
3251                                 _print_next_block(par_num++, "CDU");
3252                                 break;
3253                         case AEU_INPUTS_ATTN_BITS_IGU_PARITY_ERROR:
3254                                 _print_next_block(par_num++, "IGU");
3255                                 break;
3256                         case AEU_INPUTS_ATTN_BITS_MISC_PARITY_ERROR:
3257                                 _print_next_block(par_num++, "MISC");
3258                                 break;
3259                         }
3260
3261                         /* Clear the bit */
3262                         sig &= ~cur_bit;
3263                 }
3264         }
3265
3266         return par_num;
3267 }
3268
3269 static inline int bnx2x_print_blocks_with_parity3(u32 sig, int par_num)
3270 {
3271         int i = 0;
3272         u32 cur_bit = 0;
3273         for (i = 0; sig; i++) {
3274                 cur_bit = ((u32)0x1 << i);
3275                 if (sig & cur_bit) {
3276                         switch (cur_bit) {
3277                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_ROM_PARITY:
3278                                 _print_next_block(par_num++, "MCP ROM");
3279                                 break;
3280                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_RX_PARITY:
3281                                 _print_next_block(par_num++, "MCP UMP RX");
3282                                 break;
3283                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_TX_PARITY:
3284                                 _print_next_block(par_num++, "MCP UMP TX");
3285                                 break;
3286                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_SCPAD_PARITY:
3287                                 _print_next_block(par_num++, "MCP SCPAD");
3288                                 break;
3289                         }
3290
3291                         /* Clear the bit */
3292                         sig &= ~cur_bit;
3293                 }
3294         }
3295
3296         return par_num;
3297 }
3298
3299 static inline bool bnx2x_parity_attn(struct bnx2x *bp, u32 sig0, u32 sig1,
3300                                      u32 sig2, u32 sig3)
3301 {
3302         if ((sig0 & HW_PRTY_ASSERT_SET_0) || (sig1 & HW_PRTY_ASSERT_SET_1) ||
3303             (sig2 & HW_PRTY_ASSERT_SET_2) || (sig3 & HW_PRTY_ASSERT_SET_3)) {
3304                 int par_num = 0;
3305                 DP(NETIF_MSG_HW, "Was parity error: HW block parity attention: "
3306                         "[0]:0x%08x [1]:0x%08x "
3307                         "[2]:0x%08x [3]:0x%08x\n",
3308                           sig0 & HW_PRTY_ASSERT_SET_0,
3309                           sig1 & HW_PRTY_ASSERT_SET_1,
3310                           sig2 & HW_PRTY_ASSERT_SET_2,
3311                           sig3 & HW_PRTY_ASSERT_SET_3);
3312                 printk(KERN_ERR"%s: Parity errors detected in blocks: ",
3313                        bp->dev->name);
3314                 par_num = bnx2x_print_blocks_with_parity0(
3315                         sig0 & HW_PRTY_ASSERT_SET_0, par_num);
3316                 par_num = bnx2x_print_blocks_with_parity1(
3317                         sig1 & HW_PRTY_ASSERT_SET_1, par_num);
3318                 par_num = bnx2x_print_blocks_with_parity2(
3319                         sig2 & HW_PRTY_ASSERT_SET_2, par_num);
3320                 par_num = bnx2x_print_blocks_with_parity3(
3321                         sig3 & HW_PRTY_ASSERT_SET_3, par_num);
3322                 printk("\n");
3323                 return true;
3324         } else
3325                 return false;
3326 }
3327
3328 bool bnx2x_chk_parity_attn(struct bnx2x *bp)
3329 {
3330         struct attn_route attn;
3331         int port = BP_PORT(bp);
3332
3333         attn.sig[0] = REG_RD(bp,
3334                 MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 +
3335                              port*4);
3336         attn.sig[1] = REG_RD(bp,
3337                 MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 +
3338                              port*4);
3339         attn.sig[2] = REG_RD(bp,
3340                 MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 +
3341                              port*4);
3342         attn.sig[3] = REG_RD(bp,
3343                 MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 +
3344                              port*4);
3345
3346         return bnx2x_parity_attn(bp, attn.sig[0], attn.sig[1], attn.sig[2],
3347                                         attn.sig[3]);
3348 }
3349
3350
3351 static inline void bnx2x_attn_int_deasserted4(struct bnx2x *bp, u32 attn)
3352 {
3353         u32 val;
3354         if (attn & AEU_INPUTS_ATTN_BITS_PGLUE_HW_INTERRUPT) {
3355
3356                 val = REG_RD(bp, PGLUE_B_REG_PGLUE_B_INT_STS_CLR);
3357                 BNX2X_ERR("PGLUE hw attention 0x%x\n", val);
3358                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_ADDRESS_ERROR)
3359                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3360                                   "ADDRESS_ERROR\n");
3361                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_INCORRECT_RCV_BEHAVIOR)
3362                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3363                                   "INCORRECT_RCV_BEHAVIOR\n");
3364                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN)
3365                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3366                                   "WAS_ERROR_ATTN\n");
3367                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_VF_LENGTH_VIOLATION_ATTN)
3368                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3369                                   "VF_LENGTH_VIOLATION_ATTN\n");
3370                 if (val &
3371                     PGLUE_B_PGLUE_B_INT_STS_REG_VF_GRC_SPACE_VIOLATION_ATTN)
3372                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3373                                   "VF_GRC_SPACE_VIOLATION_ATTN\n");
3374                 if (val &
3375                     PGLUE_B_PGLUE_B_INT_STS_REG_VF_MSIX_BAR_VIOLATION_ATTN)
3376                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3377                                   "VF_MSIX_BAR_VIOLATION_ATTN\n");
3378                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_ERROR_ATTN)
3379                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3380                                   "TCPL_ERROR_ATTN\n");
3381                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_IN_TWO_RCBS_ATTN)
3382                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3383                                   "TCPL_IN_TWO_RCBS_ATTN\n");
3384                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_CSSNOOP_FIFO_OVERFLOW)
3385                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3386                                   "CSSNOOP_FIFO_OVERFLOW\n");
3387         }
3388         if (attn & AEU_INPUTS_ATTN_BITS_ATC_HW_INTERRUPT) {
3389                 val = REG_RD(bp, ATC_REG_ATC_INT_STS_CLR);
3390                 BNX2X_ERR("ATC hw attention 0x%x\n", val);
3391                 if (val & ATC_ATC_INT_STS_REG_ADDRESS_ERROR)
3392                         BNX2X_ERR("ATC_ATC_INT_STS_REG_ADDRESS_ERROR\n");
3393                 if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_TO_NOT_PEND)
3394                         BNX2X_ERR("ATC_ATC_INT_STS_REG"
3395                                   "_ATC_TCPL_TO_NOT_PEND\n");
3396                 if (val & ATC_ATC_INT_STS_REG_ATC_GPA_MULTIPLE_HITS)
3397                         BNX2X_ERR("ATC_ATC_INT_STS_REG_"
3398                                   "ATC_GPA_MULTIPLE_HITS\n");
3399                 if (val & ATC_ATC_INT_STS_REG_ATC_RCPL_TO_EMPTY_CNT)
3400                         BNX2X_ERR("ATC_ATC_INT_STS_REG_"
3401                                   "ATC_RCPL_TO_EMPTY_CNT\n");
3402                 if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR)
3403                         BNX2X_ERR("ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR\n");
3404                 if (val & ATC_ATC_INT_STS_REG_ATC_IREQ_LESS_THAN_STU)
3405                         BNX2X_ERR("ATC_ATC_INT_STS_REG_"
3406                                   "ATC_IREQ_LESS_THAN_STU\n");
3407         }
3408
3409         if (attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
3410                     AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)) {
3411                 BNX2X_ERR("FATAL parity attention set4 0x%x\n",
3412                 (u32)(attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
3413                     AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)));
3414         }
3415
3416 }
3417
3418 static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
3419 {
3420         struct attn_route attn, *group_mask;
3421         int port = BP_PORT(bp);
3422         int index;
3423         u32 reg_addr;
3424         u32 val;
3425         u32 aeu_mask;
3426
3427         /* need to take HW lock because MCP or other port might also
3428            try to handle this event */
3429         bnx2x_acquire_alr(bp);
3430
3431         if (bnx2x_chk_parity_attn(bp)) {
3432                 bp->recovery_state = BNX2X_RECOVERY_INIT;
3433                 bnx2x_set_reset_in_progress(bp);
3434                 schedule_delayed_work(&bp->reset_task, 0);
3435                 /* Disable HW interrupts */
3436                 bnx2x_int_disable(bp);
3437                 bnx2x_release_alr(bp);
3438                 /* In case of parity errors don't handle attentions so that
3439                  * other function would "see" parity errors.
3440                  */
3441                 return;
3442         }
3443
3444         attn.sig[0] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + port*4);
3445         attn.sig[1] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
3446         attn.sig[2] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
3447         attn.sig[3] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
3448         if (CHIP_IS_E2(bp))
3449                 attn.sig[4] =
3450                       REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_5_FUNC_0 + port*4);
3451         else
3452                 attn.sig[4] = 0;
3453
3454         DP(NETIF_MSG_HW, "attn: %08x %08x %08x %08x %08x\n",
3455            attn.sig[0], attn.sig[1], attn.sig[2], attn.sig[3], attn.sig[4]);
3456
3457         for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
3458                 if (deasserted & (1 << index)) {
3459                         group_mask = &bp->attn_group[index];
3460
3461                         DP(NETIF_MSG_HW, "group[%d]: %08x %08x "
3462                                          "%08x %08x %08x\n",
3463                            index,
3464                            group_mask->sig[0], group_mask->sig[1],
3465                            group_mask->sig[2], group_mask->sig[3],
3466                            group_mask->sig[4]);
3467
3468                         bnx2x_attn_int_deasserted4(bp,
3469                                         attn.sig[4] & group_mask->sig[4]);
3470                         bnx2x_attn_int_deasserted3(bp,
3471                                         attn.sig[3] & group_mask->sig[3]);
3472                         bnx2x_attn_int_deasserted1(bp,
3473                                         attn.sig[1] & group_mask->sig[1]);
3474                         bnx2x_attn_int_deasserted2(bp,
3475                                         attn.sig[2] & group_mask->sig[2]);
3476                         bnx2x_attn_int_deasserted0(bp,
3477                                         attn.sig[0] & group_mask->sig[0]);
3478                 }
3479         }
3480
3481         bnx2x_release_alr(bp);
3482
3483         if (bp->common.int_block == INT_BLOCK_HC)
3484                 reg_addr = (HC_REG_COMMAND_REG + port*32 +
3485                             COMMAND_REG_ATTN_BITS_CLR);
3486         else
3487                 reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_CLR_UPPER*8);
3488
3489         val = ~deasserted;
3490         DP(NETIF_MSG_HW, "about to mask 0x%08x at %s addr 0x%x\n", val,
3491            (bp->common.int_block == INT_BLOCK_HC) ? "HC" : "IGU", reg_addr);
3492         REG_WR(bp, reg_addr, val);
3493
3494         if (~bp->attn_state & deasserted)
3495                 BNX2X_ERR("IGU ERROR\n");
3496
3497         reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
3498                           MISC_REG_AEU_MASK_ATTN_FUNC_0;
3499
3500         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
3501         aeu_mask = REG_RD(bp, reg_addr);
3502
3503         DP(NETIF_MSG_HW, "aeu_mask %x  newly deasserted %x\n",
3504            aeu_mask, deasserted);
3505         aeu_mask |= (deasserted & 0x3ff);
3506         DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
3507
3508         REG_WR(bp, reg_addr, aeu_mask);
3509         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
3510
3511         DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
3512         bp->attn_state &= ~deasserted;
3513         DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
3514 }
3515
3516 static void bnx2x_attn_int(struct bnx2x *bp)
3517 {
3518         /* read local copy of bits */
3519         u32 attn_bits = le32_to_cpu(bp->def_status_blk->atten_status_block.
3520                                                                 attn_bits);
3521         u32 attn_ack = le32_to_cpu(bp->def_status_blk->atten_status_block.
3522                                                                 attn_bits_ack);
3523         u32 attn_state = bp->attn_state;
3524
3525         /* look for changed bits */
3526         u32 asserted   =  attn_bits & ~attn_ack & ~attn_state;
3527         u32 deasserted = ~attn_bits &  attn_ack &  attn_state;
3528
3529         DP(NETIF_MSG_HW,
3530            "attn_bits %x  attn_ack %x  asserted %x  deasserted %x\n",
3531            attn_bits, attn_ack, asserted, deasserted);
3532
3533         if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state))
3534                 BNX2X_ERR("BAD attention state\n");
3535
3536         /* handle bits that were raised */
3537         if (asserted)
3538                 bnx2x_attn_int_asserted(bp, asserted);
3539
3540         if (deasserted)
3541                 bnx2x_attn_int_deasserted(bp, deasserted);
3542 }
3543
3544 static inline void bnx2x_update_eq_prod(struct bnx2x *bp, u16 prod)
3545 {
3546         /* No memory barriers */
3547         storm_memset_eq_prod(bp, prod, BP_FUNC(bp));
3548         mmiowb(); /* keep prod updates ordered */
3549 }
3550
3551 #ifdef BCM_CNIC
3552 static int  bnx2x_cnic_handle_cfc_del(struct bnx2x *bp, u32 cid,
3553                                       union event_ring_elem *elem)
3554 {
3555         if (!bp->cnic_eth_dev.starting_cid  ||
3556             cid < bp->cnic_eth_dev.starting_cid)
3557                 return 1;
3558
3559         DP(BNX2X_MSG_SP, "got delete ramrod for CNIC CID %d\n", cid);
3560
3561         if (unlikely(elem->message.data.cfc_del_event.error)) {
3562                 BNX2X_ERR("got delete ramrod for CNIC CID %d with error!\n",
3563                           cid);
3564                 bnx2x_panic_dump(bp);
3565         }
3566         bnx2x_cnic_cfc_comp(bp, cid);
3567         return 0;
3568 }
3569 #endif
3570
3571 static void bnx2x_eq_int(struct bnx2x *bp)
3572 {
3573         u16 hw_cons, sw_cons, sw_prod;
3574         union event_ring_elem *elem;
3575         u32 cid;
3576         u8 opcode;
3577         int spqe_cnt = 0;
3578
3579         hw_cons = le16_to_cpu(*bp->eq_cons_sb);
3580
3581         /* The hw_cos range is 1-255, 257 - the sw_cons range is 0-254, 256.
3582          * when we get the the next-page we nned to adjust so the loop
3583          * condition below will be met. The next element is the size of a
3584          * regular element and hence incrementing by 1
3585          */
3586         if ((hw_cons & EQ_DESC_MAX_PAGE) == EQ_DESC_MAX_PAGE)
3587                 hw_cons++;
3588
3589         /* This function may never run in parralel with itself for a
3590          * specific bp, thus there is no need in "paired" read memory
3591          * barrier here.
3592          */
3593         sw_cons = bp->eq_cons;
3594         sw_prod = bp->eq_prod;
3595
3596         DP(BNX2X_MSG_SP, "EQ:  hw_cons %u  sw_cons %u bp->spq_left %u\n",
3597                         hw_cons, sw_cons, atomic_read(&bp->spq_left));
3598
3599         for (; sw_cons != hw_cons;
3600               sw_prod = NEXT_EQ_IDX(sw_prod), sw_cons = NEXT_EQ_IDX(sw_cons)) {
3601
3602
3603                 elem = &bp->eq_ring[EQ_DESC(sw_cons)];
3604
3605                 cid = SW_CID(elem->message.data.cfc_del_event.cid);
3606                 opcode = elem->message.opcode;
3607
3608
3609                 /* handle eq element */
3610                 switch (opcode) {
3611                 case EVENT_RING_OPCODE_STAT_QUERY:
3612                         DP(NETIF_MSG_TIMER, "got statistics comp event\n");
3613                         /* nothing to do with stats comp */
3614                         continue;
3615
3616                 case EVENT_RING_OPCODE_CFC_DEL:
3617                         /* handle according to cid range */
3618                         /*
3619                          * we may want to verify here that the bp state is
3620                          * HALTING
3621                          */
3622                         DP(NETIF_MSG_IFDOWN,
3623                            "got delete ramrod for MULTI[%d]\n", cid);
3624 #ifdef BCM_CNIC
3625                         if (!bnx2x_cnic_handle_cfc_del(bp, cid, elem))
3626                                 goto next_spqe;
3627 #endif
3628                         bnx2x_fp(bp, cid, state) =
3629                                                 BNX2X_FP_STATE_CLOSED;
3630
3631                         goto next_spqe;
3632                 }
3633
3634                 switch (opcode | bp->state) {
3635                 case (EVENT_RING_OPCODE_FUNCTION_START |
3636                       BNX2X_STATE_OPENING_WAIT4_PORT):
3637                         DP(NETIF_MSG_IFUP, "got setup ramrod\n");
3638                         bp->state = BNX2X_STATE_FUNC_STARTED;
3639                         break;
3640
3641                 case (EVENT_RING_OPCODE_FUNCTION_STOP |
3642                       BNX2X_STATE_CLOSING_WAIT4_HALT):
3643                         DP(NETIF_MSG_IFDOWN, "got halt ramrod\n");
3644                         bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
3645                         break;
3646
3647                 case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_OPEN):
3648                 case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_DIAG):
3649                         DP(NETIF_MSG_IFUP, "got set mac ramrod\n");
3650                         bp->set_mac_pending = 0;
3651                         break;
3652
3653                 case (EVENT_RING_OPCODE_SET_MAC |
3654                       BNX2X_STATE_CLOSING_WAIT4_HALT):
3655                         DP(NETIF_MSG_IFDOWN, "got (un)set mac ramrod\n");
3656                         bp->set_mac_pending = 0;
3657                         break;
3658                 default:
3659                         /* unknown event log error and continue */
3660                         BNX2X_ERR("Unknown EQ event %d\n",
3661                                   elem->message.opcode);
3662                 }
3663 next_spqe:
3664                 spqe_cnt++;
3665         } /* for */
3666
3667         smp_mb__before_atomic_inc();
3668         atomic_add(spqe_cnt, &bp->spq_left);
3669
3670         bp->eq_cons = sw_cons;
3671         bp->eq_prod = sw_prod;
3672         /* Make sure that above mem writes were issued towards the memory */
3673         smp_wmb();
3674
3675         /* update producer */
3676         bnx2x_update_eq_prod(bp, bp->eq_prod);
3677 }
3678
3679 static void bnx2x_sp_task(struct work_struct *work)
3680 {
3681         struct bnx2x *bp = container_of(work, struct bnx2x, sp_task.work);
3682         u16 status;
3683
3684         /* Return here if interrupt is disabled */
3685         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3686                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3687                 return;
3688         }
3689
3690         status = bnx2x_update_dsb_idx(bp);
3691 /*      if (status == 0)                                     */
3692 /*              BNX2X_ERR("spurious slowpath interrupt!\n"); */
3693
3694         DP(NETIF_MSG_INTR, "got a slowpath interrupt (status 0x%x)\n", status);
3695
3696         /* HW attentions */
3697         if (status & BNX2X_DEF_SB_ATT_IDX) {
3698                 bnx2x_attn_int(bp);
3699                 status &= ~BNX2X_DEF_SB_ATT_IDX;
3700         }
3701
3702         /* SP events: STAT_QUERY and others */
3703         if (status & BNX2X_DEF_SB_IDX) {
3704
3705                 /* Handle EQ completions */
3706                 bnx2x_eq_int(bp);
3707
3708                 bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID,
3709                         le16_to_cpu(bp->def_idx), IGU_INT_NOP, 1);
3710
3711                 status &= ~BNX2X_DEF_SB_IDX;
3712         }
3713
3714         if (unlikely(status))
3715                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
3716                    status);
3717
3718         bnx2x_ack_sb(bp, bp->igu_dsb_id, ATTENTION_ID,
3719              le16_to_cpu(bp->def_att_idx), IGU_INT_ENABLE, 1);
3720 }
3721
3722 irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
3723 {
3724         struct net_device *dev = dev_instance;
3725         struct bnx2x *bp = netdev_priv(dev);
3726
3727         /* Return here if interrupt is disabled */
3728         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3729                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3730                 return IRQ_HANDLED;
3731         }
3732
3733         bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID, 0,
3734                      IGU_INT_DISABLE, 0);
3735
3736 #ifdef BNX2X_STOP_ON_ERROR
3737         if (unlikely(bp->panic))
3738                 return IRQ_HANDLED;
3739 #endif
3740
3741 #ifdef BCM_CNIC
3742         {
3743                 struct cnic_ops *c_ops;
3744
3745                 rcu_read_lock();
3746                 c_ops = rcu_dereference(bp->cnic_ops);
3747                 if (c_ops)
3748                         c_ops->cnic_handler(bp->cnic_data, NULL);
3749                 rcu_read_unlock();
3750         }
3751 #endif
3752         queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
3753
3754         return IRQ_HANDLED;
3755 }
3756
3757 /* end of slow path */
3758
3759 static void bnx2x_timer(unsigned long data)
3760 {
3761         struct bnx2x *bp = (struct bnx2x *) data;
3762
3763         if (!netif_running(bp->dev))
3764                 return;
3765
3766         if (atomic_read(&bp->intr_sem) != 0)
3767                 goto timer_restart;
3768
3769         if (poll) {
3770                 struct bnx2x_fastpath *fp = &bp->fp[0];
3771                 int rc;
3772
3773                 bnx2x_tx_int(fp);
3774                 rc = bnx2x_rx_int(fp, 1000);
3775         }
3776
3777         if (!BP_NOMCP(bp)) {
3778                 int mb_idx = BP_FW_MB_IDX(bp);
3779                 u32 drv_pulse;
3780                 u32 mcp_pulse;
3781
3782                 ++bp->fw_drv_pulse_wr_seq;
3783                 bp->fw_drv_pulse_wr_seq &= DRV_PULSE_SEQ_MASK;
3784                 /* TBD - add SYSTEM_TIME */
3785                 drv_pulse = bp->fw_drv_pulse_wr_seq;
3786                 SHMEM_WR(bp, func_mb[mb_idx].drv_pulse_mb, drv_pulse);
3787
3788                 mcp_pulse = (SHMEM_RD(bp, func_mb[mb_idx].mcp_pulse_mb) &
3789                              MCP_PULSE_SEQ_MASK);
3790                 /* The delta between driver pulse and mcp response
3791                  * should be 1 (before mcp response) or 0 (after mcp response)
3792                  */
3793                 if ((drv_pulse != mcp_pulse) &&
3794                     (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
3795                         /* someone lost a heartbeat... */
3796                         BNX2X_ERR("drv_pulse (0x%x) != mcp_pulse (0x%x)\n",
3797                                   drv_pulse, mcp_pulse);
3798                 }
3799         }
3800
3801         if (bp->state == BNX2X_STATE_OPEN)
3802                 bnx2x_stats_handle(bp, STATS_EVENT_UPDATE);
3803
3804 timer_restart:
3805         mod_timer(&bp->timer, jiffies + bp->current_interval);
3806 }
3807
3808 /* end of Statistics */
3809
3810 /* nic init */
3811
3812 /*
3813  * nic init service functions
3814  */
3815
3816 static inline void bnx2x_fill(struct bnx2x *bp, u32 addr, int fill, u32 len)
3817 {
3818         u32 i;
3819         if (!(len%4) && !(addr%4))
3820                 for (i = 0; i < len; i += 4)
3821                         REG_WR(bp, addr + i, fill);
3822         else
3823                 for (i = 0; i < len; i++)
3824                         REG_WR8(bp, addr + i, fill);
3825
3826 }
3827
3828 /* helper: writes FP SP data to FW - data_size in dwords */
3829 static inline void bnx2x_wr_fp_sb_data(struct bnx2x *bp,
3830                                        int fw_sb_id,
3831                                        u32 *sb_data_p,
3832                                        u32 data_size)
3833 {
3834         int index;
3835         for (index = 0; index < data_size; index++)
3836                 REG_WR(bp, BAR_CSTRORM_INTMEM +
3837                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
3838                         sizeof(u32)*index,
3839                         *(sb_data_p + index));
3840 }
3841
3842 static inline void bnx2x_zero_fp_sb(struct bnx2x *bp, int fw_sb_id)
3843 {
3844         u32 *sb_data_p;
3845         u32 data_size = 0;
3846         struct hc_status_block_data_e2 sb_data_e2;
3847         struct hc_status_block_data_e1x sb_data_e1x;
3848
3849         /* disable the function first */
3850         if (CHIP_IS_E2(bp)) {
3851                 memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
3852                 sb_data_e2.common.p_func.pf_id = HC_FUNCTION_DISABLED;
3853                 sb_data_e2.common.p_func.vf_id = HC_FUNCTION_DISABLED;
3854                 sb_data_e2.common.p_func.vf_valid = false;
3855                 sb_data_p = (u32 *)&sb_data_e2;
3856                 data_size = sizeof(struct hc_status_block_data_e2)/sizeof(u32);
3857         } else {
3858                 memset(&sb_data_e1x, 0,
3859                        sizeof(struct hc_status_block_data_e1x));
3860                 sb_data_e1x.common.p_func.pf_id = HC_FUNCTION_DISABLED;
3861                 sb_data_e1x.common.p_func.vf_id = HC_FUNCTION_DISABLED;
3862                 sb_data_e1x.common.p_func.vf_valid = false;
3863                 sb_data_p = (u32 *)&sb_data_e1x;
3864                 data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
3865         }
3866         bnx2x_wr_fp_sb_data(bp, fw_sb_id, sb_data_p, data_size);
3867
3868         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3869                         CSTORM_STATUS_BLOCK_OFFSET(fw_sb_id), 0,
3870                         CSTORM_STATUS_BLOCK_SIZE);
3871         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3872                         CSTORM_SYNC_BLOCK_OFFSET(fw_sb_id), 0,
3873                         CSTORM_SYNC_BLOCK_SIZE);
3874 }
3875
3876 /* helper:  writes SP SB data to FW */
3877 static inline void bnx2x_wr_sp_sb_data(struct bnx2x *bp,
3878                 struct hc_sp_status_block_data *sp_sb_data)
3879 {
3880         int func = BP_FUNC(bp);
3881         int i;
3882         for (i = 0; i < sizeof(struct hc_sp_status_block_data)/sizeof(u32); i++)
3883                 REG_WR(bp, BAR_CSTRORM_INTMEM +
3884                         CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
3885                         i*sizeof(u32),
3886                         *((u32 *)sp_sb_data + i));
3887 }
3888
3889 static inline void bnx2x_zero_sp_sb(struct bnx2x *bp)
3890 {
3891         int func = BP_FUNC(bp);
3892         struct hc_sp_status_block_data sp_sb_data;
3893         memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
3894
3895         sp_sb_data.p_func.pf_id = HC_FUNCTION_DISABLED;
3896         sp_sb_data.p_func.vf_id = HC_FUNCTION_DISABLED;
3897         sp_sb_data.p_func.vf_valid = false;
3898
3899         bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
3900
3901         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3902                         CSTORM_SP_STATUS_BLOCK_OFFSET(func), 0,
3903                         CSTORM_SP_STATUS_BLOCK_SIZE);
3904         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3905                         CSTORM_SP_SYNC_BLOCK_OFFSET(func), 0,
3906                         CSTORM_SP_SYNC_BLOCK_SIZE);
3907
3908 }
3909
3910
3911 static inline
3912 void bnx2x_setup_ndsb_state_machine(struct hc_status_block_sm *hc_sm,
3913                                            int igu_sb_id, int igu_seg_id)
3914 {
3915         hc_sm->igu_sb_id = igu_sb_id;
3916         hc_sm->igu_seg_id = igu_seg_id;
3917         hc_sm->timer_value = 0xFF;
3918         hc_sm->time_to_expire = 0xFFFFFFFF;
3919 }
3920
3921 void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
3922                           u8 vf_valid, int fw_sb_id, int igu_sb_id)
3923 {
3924         int igu_seg_id;
3925
3926         struct hc_status_block_data_e2 sb_data_e2;
3927         struct hc_status_block_data_e1x sb_data_e1x;
3928         struct hc_status_block_sm  *hc_sm_p;
3929         struct hc_index_data *hc_index_p;
3930         int data_size;
3931         u32 *sb_data_p;
3932
3933         if (CHIP_INT_MODE_IS_BC(bp))
3934                 igu_seg_id = HC_SEG_ACCESS_NORM;
3935         else
3936                 igu_seg_id = IGU_SEG_ACCESS_NORM;
3937
3938         bnx2x_zero_fp_sb(bp, fw_sb_id);
3939
3940         if (CHIP_IS_E2(bp)) {
3941                 memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
3942                 sb_data_e2.common.p_func.pf_id = BP_FUNC(bp);
3943                 sb_data_e2.common.p_func.vf_id = vfid;
3944                 sb_data_e2.common.p_func.vf_valid = vf_valid;
3945                 sb_data_e2.common.p_func.vnic_id = BP_VN(bp);
3946                 sb_data_e2.common.same_igu_sb_1b = true;
3947                 sb_data_e2.common.host_sb_addr.hi = U64_HI(mapping);
3948                 sb_data_e2.common.host_sb_addr.lo = U64_LO(mapping);
3949                 hc_sm_p = sb_data_e2.common.state_machine;
3950                 hc_index_p = sb_data_e2.index_data;
3951                 sb_data_p = (u32 *)&sb_data_e2;
3952                 data_size = sizeof(struct hc_status_block_data_e2)/sizeof(u32);
3953         } else {
3954                 memset(&sb_data_e1x, 0,
3955                        sizeof(struct hc_status_block_data_e1x));
3956                 sb_data_e1x.common.p_func.pf_id = BP_FUNC(bp);
3957                 sb_data_e1x.common.p_func.vf_id = 0xff;
3958                 sb_data_e1x.common.p_func.vf_valid = false;
3959                 sb_data_e1x.common.p_func.vnic_id = BP_VN(bp);
3960                 sb_data_e1x.common.same_igu_sb_1b = true;
3961                 sb_data_e1x.common.host_sb_addr.hi = U64_HI(mapping);
3962                 sb_data_e1x.common.host_sb_addr.lo = U64_LO(mapping);
3963                 hc_sm_p = sb_data_e1x.common.state_machine;
3964                 hc_index_p = sb_data_e1x.index_data;
3965                 sb_data_p = (u32 *)&sb_data_e1x;
3966                 data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
3967         }
3968
3969         bnx2x_setup_ndsb_state_machine(&hc_sm_p[SM_RX_ID],
3970                                        igu_sb_id, igu_seg_id);
3971         bnx2x_setup_ndsb_state_machine(&hc_sm_p[SM_TX_ID],
3972                                        igu_sb_id, igu_seg_id);
3973
3974         DP(NETIF_MSG_HW, "Init FW SB %d\n", fw_sb_id);
3975
3976         /* write indecies to HW */
3977         bnx2x_wr_fp_sb_data(bp, fw_sb_id, sb_data_p, data_size);
3978 }
3979
3980 static void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, u16 fw_sb_id,
3981                                         u8 sb_index, u8 disable, u16 usec)
3982 {
3983         int port = BP_PORT(bp);
3984         u8 ticks = usec / BNX2X_BTR;
3985
3986         storm_memset_hc_timeout(bp, port, fw_sb_id, sb_index, ticks);
3987
3988         disable = disable ? 1 : (usec ? 0 : 1);
3989         storm_memset_hc_disable(bp, port, fw_sb_id, sb_index, disable);
3990 }
3991
3992 static void bnx2x_update_coalesce_sb(struct bnx2x *bp, u16 fw_sb_id,
3993                                      u16 tx_usec, u16 rx_usec)
3994 {
3995         bnx2x_update_coalesce_sb_index(bp, fw_sb_id, U_SB_ETH_RX_CQ_INDEX,
3996                                     false, rx_usec);
3997         bnx2x_update_coalesce_sb_index(bp, fw_sb_id, C_SB_ETH_TX_CQ_INDEX,
3998                                     false, tx_usec);
3999 }
4000
4001 static void bnx2x_init_def_sb(struct bnx2x *bp)
4002 {
4003         struct host_sp_status_block *def_sb = bp->def_status_blk;
4004         dma_addr_t mapping = bp->def_status_blk_mapping;
4005         int igu_sp_sb_index;
4006         int igu_seg_id;
4007         int port = BP_PORT(bp);
4008         int func = BP_FUNC(bp);
4009         int reg_offset;
4010         u64 section;
4011         int index;
4012         struct hc_sp_status_block_data sp_sb_data;
4013         memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
4014
4015         if (CHIP_INT_MODE_IS_BC(bp)) {
4016                 igu_sp_sb_index = DEF_SB_IGU_ID;
4017                 igu_seg_id = HC_SEG_ACCESS_DEF;
4018         } else {
4019                 igu_sp_sb_index = bp->igu_dsb_id;
4020                 igu_seg_id = IGU_SEG_ACCESS_DEF;
4021         }
4022
4023         /* ATTN */
4024         section = ((u64)mapping) + offsetof(struct host_sp_status_block,
4025                                             atten_status_block);
4026         def_sb->atten_status_block.status_block_id = igu_sp_sb_index;
4027
4028         bp->attn_state = 0;
4029
4030         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
4031                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
4032         for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
4033                 int sindex;
4034                 /* take care of sig[0]..sig[4] */
4035                 for (sindex = 0; sindex < 4; sindex++)
4036                         bp->attn_group[index].sig[sindex] =
4037                            REG_RD(bp, reg_offset + sindex*0x4 + 0x10*index);
4038
4039                 if (CHIP_IS_E2(bp))
4040                         /*
4041                          * enable5 is separate from the rest of the registers,
4042                          * and therefore the address skip is 4
4043                          * and not 16 between the different groups
4044                          */
4045                         bp->attn_group[index].sig[4] = REG_RD(bp,
4046                                         reg_offset + 0x10 + 0x4*index);
4047                 else
4048                         bp->attn_group[index].sig[4] = 0;
4049         }
4050
4051         if (bp->common.int_block == INT_BLOCK_HC) {
4052                 reg_offset = (port ? HC_REG_ATTN_MSG1_ADDR_L :
4053                                      HC_REG_ATTN_MSG0_ADDR_L);
4054
4055                 REG_WR(bp, reg_offset, U64_LO(section));
4056                 REG_WR(bp, reg_offset + 4, U64_HI(section));
4057         } else if (CHIP_IS_E2(bp)) {
4058                 REG_WR(bp, IGU_REG_ATTN_MSG_ADDR_L, U64_LO(section));
4059                 REG_WR(bp, IGU_REG_ATTN_MSG_ADDR_H, U64_HI(section));
4060         }
4061
4062         section = ((u64)mapping) + offsetof(struct host_sp_status_block,
4063                                             sp_sb);
4064
4065         bnx2x_zero_sp_sb(bp);
4066
4067         sp_sb_data.host_sb_addr.lo      = U64_LO(section);
4068         sp_sb_data.host_sb_addr.hi      = U64_HI(section);
4069         sp_sb_data.igu_sb_id            = igu_sp_sb_index;
4070         sp_sb_data.igu_seg_id           = igu_seg_id;
4071         sp_sb_data.p_func.pf_id         = func;
4072         sp_sb_data.p_func.vnic_id       = BP_VN(bp);
4073         sp_sb_data.p_func.vf_id         = 0xff;
4074
4075         bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
4076
4077         bp->stats_pending = 0;
4078         bp->set_mac_pending = 0;
4079
4080         bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
4081 }
4082
4083 void bnx2x_update_coalesce(struct bnx2x *bp)
4084 {
4085         int i;
4086
4087         for_each_queue(bp, i)
4088                 bnx2x_update_coalesce_sb(bp, bp->fp[i].fw_sb_id,
4089                                          bp->rx_ticks, bp->tx_ticks);
4090 }
4091
4092 static void bnx2x_init_sp_ring(struct bnx2x *bp)
4093 {
4094         spin_lock_init(&bp->spq_lock);
4095         atomic_set(&bp->spq_left, MAX_SPQ_PENDING);
4096
4097         bp->spq_prod_idx = 0;
4098         bp->dsb_sp_prod = BNX2X_SP_DSB_INDEX;
4099         bp->spq_prod_bd = bp->spq;
4100         bp->spq_last_bd = bp->spq_prod_bd + MAX_SP_DESC_CNT;
4101 }
4102
4103 static void bnx2x_init_eq_ring(struct bnx2x *bp)
4104 {
4105         int i;
4106         for (i = 1; i <= NUM_EQ_PAGES; i++) {
4107                 union event_ring_elem *elem =
4108                         &bp->eq_ring[EQ_DESC_CNT_PAGE * i - 1];
4109
4110                 elem->next_page.addr.hi =
4111                         cpu_to_le32(U64_HI(bp->eq_mapping +
4112                                    BCM_PAGE_SIZE * (i % NUM_EQ_PAGES)));
4113                 elem->next_page.addr.lo =
4114                         cpu_to_le32(U64_LO(bp->eq_mapping +
4115                                    BCM_PAGE_SIZE*(i % NUM_EQ_PAGES)));
4116         }
4117         bp->eq_cons = 0;
4118         bp->eq_prod = NUM_EQ_DESC;
4119         bp->eq_cons_sb = BNX2X_EQ_INDEX;
4120 }
4121
4122 static void bnx2x_init_ind_table(struct bnx2x *bp)
4123 {
4124         int func = BP_FUNC(bp);
4125         int i;
4126
4127         if (bp->multi_mode == ETH_RSS_MODE_DISABLED)
4128                 return;
4129
4130         DP(NETIF_MSG_IFUP,
4131            "Initializing indirection table  multi_mode %d\n", bp->multi_mode);
4132         for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
4133                 REG_WR8(bp, BAR_TSTRORM_INTMEM +
4134                         TSTORM_INDIRECTION_TABLE_OFFSET(func) + i,
4135                         bp->fp->cl_id + (i % bp->num_queues));
4136 }
4137
4138 void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
4139 {
4140         int mode = bp->rx_mode;
4141         u16 cl_id;
4142
4143         /* All but management unicast packets should pass to the host as well */
4144         u32 llh_mask =
4145                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_BRCST |
4146                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_MLCST |
4147                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_VLAN |
4148                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_NO_VLAN;
4149
4150         switch (mode) {
4151         case BNX2X_RX_MODE_NONE: /* no Rx */
4152                 cl_id = BP_L_ID(bp);
4153                 bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_NONE);
4154                 break;
4155
4156         case BNX2X_RX_MODE_NORMAL:
4157                 cl_id = BP_L_ID(bp);
4158                 bnx2x_rxq_set_mac_filters(bp, cl_id,
4159                         BNX2X_ACCEPT_UNICAST |
4160                         BNX2X_ACCEPT_BROADCAST |
4161                         BNX2X_ACCEPT_MULTICAST);
4162                 break;
4163
4164         case BNX2X_RX_MODE_ALLMULTI:
4165                 cl_id = BP_L_ID(bp);
4166                 bnx2x_rxq_set_mac_filters(bp, cl_id,
4167                         BNX2X_ACCEPT_UNICAST |
4168                         BNX2X_ACCEPT_BROADCAST |
4169                         BNX2X_ACCEPT_ALL_MULTICAST);
4170                 break;
4171
4172         case BNX2X_RX_MODE_PROMISC:
4173                 cl_id = BP_L_ID(bp);
4174                 bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_PROMISCUOUS_MODE);
4175
4176                 /* pass management unicast packets as well */
4177                 llh_mask |= NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_UNCST;
4178                 break;
4179
4180         default:
4181                 BNX2X_ERR("BAD rx mode (%d)\n", mode);
4182                 break;
4183         }
4184
4185         REG_WR(bp,
4186                BP_PORT(bp) ? NIG_REG_LLH1_BRB1_DRV_MASK :
4187                              NIG_REG_LLH0_BRB1_DRV_MASK,
4188                llh_mask);
4189
4190         DP(NETIF_MSG_IFUP, "rx mode %d\n"
4191                 "drop_ucast 0x%x\ndrop_mcast 0x%x\ndrop_bcast 0x%x\n"
4192                 "accp_ucast 0x%x\naccp_mcast 0x%x\naccp_bcast 0x%x\n", mode,
4193                 bp->mac_filters.ucast_drop_all,
4194                 bp->mac_filters.mcast_drop_all,
4195                 bp->mac_filters.bcast_drop_all,
4196                 bp->mac_filters.ucast_accept_all,
4197                 bp->mac_filters.mcast_accept_all,
4198                 bp->mac_filters.bcast_accept_all
4199         );
4200
4201         storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
4202 }
4203
4204 static void bnx2x_init_internal_common(struct bnx2x *bp)
4205 {
4206         int i;
4207
4208         if (!CHIP_IS_E1(bp)) {
4209
4210                 /* xstorm needs to know whether to add  ovlan to packets or not,
4211                  * in switch-independent we'll write 0 to here... */
4212                 REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNCTION_MODE_OFFSET,
4213                         bp->mf_mode);
4214                 REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNCTION_MODE_OFFSET,
4215                         bp->mf_mode);
4216                 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNCTION_MODE_OFFSET,
4217                         bp->mf_mode);
4218                 REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNCTION_MODE_OFFSET,
4219                         bp->mf_mode);
4220         }
4221
4222         /* Zero this manually as its initialization is
4223            currently missing in the initTool */
4224         for (i = 0; i < (USTORM_AGG_DATA_SIZE >> 2); i++)
4225                 REG_WR(bp, BAR_USTRORM_INTMEM +
4226                        USTORM_AGG_DATA_OFFSET + i * 4, 0);
4227         if (CHIP_IS_E2(bp)) {
4228                 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_IGU_MODE_OFFSET,
4229                         CHIP_INT_MODE_IS_BC(bp) ?
4230                         HC_IGU_BC_MODE : HC_IGU_NBC_MODE);
4231         }
4232 }
4233
4234 static void bnx2x_init_internal_port(struct bnx2x *bp)
4235 {
4236         /* port */
4237 }
4238
4239 static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
4240 {
4241         switch (load_code) {
4242         case FW_MSG_CODE_DRV_LOAD_COMMON:
4243         case FW_MSG_CODE_DRV_LOAD_COMMON_CHIP:
4244                 bnx2x_init_internal_common(bp);
4245                 /* no break */
4246
4247         case FW_MSG_CODE_DRV_LOAD_PORT:
4248                 bnx2x_init_internal_port(bp);
4249                 /* no break */
4250
4251         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
4252                 /* internal memory per function is
4253                    initialized inside bnx2x_pf_init */
4254                 break;
4255
4256         default:
4257                 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
4258                 break;
4259         }
4260 }
4261
4262 static void bnx2x_init_fp_sb(struct bnx2x *bp, int fp_idx)
4263 {
4264         struct bnx2x_fastpath *fp = &bp->fp[fp_idx];
4265
4266         fp->state = BNX2X_FP_STATE_CLOSED;
4267
4268         fp->index = fp->cid = fp_idx;
4269         fp->cl_id = BP_L_ID(bp) + fp_idx;
4270         fp->fw_sb_id = bp->base_fw_ndsb + fp->cl_id + CNIC_CONTEXT_USE;
4271         fp->igu_sb_id = bp->igu_base_sb + fp_idx + CNIC_CONTEXT_USE;
4272         /* qZone id equals to FW (per path) client id */
4273         fp->cl_qzone_id  = fp->cl_id +
4274                            BP_PORT(bp)*(CHIP_IS_E2(bp) ? ETH_MAX_RX_CLIENTS_E2 :
4275                                 ETH_MAX_RX_CLIENTS_E1H);
4276         /* init shortcut */
4277         fp->ustorm_rx_prods_offset = CHIP_IS_E2(bp) ?
4278                             USTORM_RX_PRODS_E2_OFFSET(fp->cl_qzone_id) :
4279                             USTORM_RX_PRODS_E1X_OFFSET(BP_PORT(bp), fp->cl_id);
4280         /* Setup SB indicies */
4281         fp->rx_cons_sb = BNX2X_RX_SB_INDEX;
4282         fp->tx_cons_sb = BNX2X_TX_SB_INDEX;
4283
4284         DP(NETIF_MSG_IFUP, "queue[%d]:  bnx2x_init_sb(%p,%p)  "
4285                                    "cl_id %d  fw_sb %d  igu_sb %d\n",
4286                    fp_idx, bp, fp->status_blk.e1x_sb, fp->cl_id, fp->fw_sb_id,
4287                    fp->igu_sb_id);
4288         bnx2x_init_sb(bp, fp->status_blk_mapping, BNX2X_VF_ID_INVALID, false,
4289                       fp->fw_sb_id, fp->igu_sb_id);
4290
4291         bnx2x_update_fpsb_idx(fp);
4292 }
4293
4294 void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
4295 {
4296         int i;
4297
4298         for_each_queue(bp, i)
4299                 bnx2x_init_fp_sb(bp, i);
4300 #ifdef BCM_CNIC
4301
4302         bnx2x_init_sb(bp, bp->cnic_sb_mapping,
4303                       BNX2X_VF_ID_INVALID, false,
4304                       CNIC_SB_ID(bp), CNIC_IGU_SB_ID(bp));
4305
4306 #endif
4307
4308         /* ensure status block indices were read */
4309         rmb();
4310
4311         bnx2x_init_def_sb(bp);
4312         bnx2x_update_dsb_idx(bp);
4313         bnx2x_init_rx_rings(bp);
4314         bnx2x_init_tx_rings(bp);
4315         bnx2x_init_sp_ring(bp);
4316         bnx2x_init_eq_ring(bp);
4317         bnx2x_init_internal(bp, load_code);
4318         bnx2x_pf_init(bp);
4319         bnx2x_init_ind_table(bp);
4320         bnx2x_stats_init(bp);
4321
4322         /* At this point, we are ready for interrupts */
4323         atomic_set(&bp->intr_sem, 0);
4324
4325         /* flush all before enabling interrupts */
4326         mb();
4327         mmiowb();
4328
4329         bnx2x_int_enable(bp);
4330
4331         /* Check for SPIO5 */
4332         bnx2x_attn_int_deasserted0(bp,
4333                 REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + BP_PORT(bp)*4) &
4334                                    AEU_INPUTS_ATTN_BITS_SPIO5);
4335 }
4336
4337 /* end of nic init */
4338
4339 /*
4340  * gzip service functions
4341  */
4342
4343 static int bnx2x_gunzip_init(struct bnx2x *bp)
4344 {
4345         bp->gunzip_buf = dma_alloc_coherent(&bp->pdev->dev, FW_BUF_SIZE,
4346                                             &bp->gunzip_mapping, GFP_KERNEL);
4347         if (bp->gunzip_buf  == NULL)
4348                 goto gunzip_nomem1;
4349
4350         bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL);
4351         if (bp->strm  == NULL)
4352                 goto gunzip_nomem2;
4353
4354         bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(),
4355                                       GFP_KERNEL);
4356         if (bp->strm->workspace == NULL)
4357                 goto gunzip_nomem3;
4358
4359         return 0;
4360
4361 gunzip_nomem3:
4362         kfree(bp->strm);
4363         bp->strm = NULL;
4364
4365 gunzip_nomem2:
4366         dma_free_coherent(&bp->pdev->dev, FW_BUF_SIZE, bp->gunzip_buf,
4367                           bp->gunzip_mapping);
4368         bp->gunzip_buf = NULL;
4369
4370 gunzip_nomem1:
4371         netdev_err(bp->dev, "Cannot allocate firmware buffer for"
4372                " un-compression\n");
4373         return -ENOMEM;
4374 }
4375
4376 static void bnx2x_gunzip_end(struct bnx2x *bp)
4377 {
4378         kfree(bp->strm->workspace);
4379
4380         kfree(bp->strm);
4381         bp->strm = NULL;
4382
4383         if (bp->gunzip_buf) {
4384                 dma_free_coherent(&bp->pdev->dev, FW_BUF_SIZE, bp->gunzip_buf,
4385                                   bp->gunzip_mapping);
4386                 bp->gunzip_buf = NULL;
4387         }
4388 }
4389
4390 static int bnx2x_gunzip(struct bnx2x *bp, const u8 *zbuf, int len)
4391 {
4392         int n, rc;
4393
4394         /* check gzip header */
4395         if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED)) {
4396                 BNX2X_ERR("Bad gzip header\n");
4397                 return -EINVAL;
4398         }
4399
4400         n = 10;
4401
4402 #define FNAME                           0x8
4403
4404         if (zbuf[3] & FNAME)
4405                 while ((zbuf[n++] != 0) && (n < len));
4406
4407         bp->strm->next_in = (typeof(bp->strm->next_in))zbuf + n;
4408         bp->strm->avail_in = len - n;
4409         bp->strm->next_out = bp->gunzip_buf;
4410         bp->strm->avail_out = FW_BUF_SIZE;
4411
4412         rc = zlib_inflateInit2(bp->strm, -MAX_WBITS);
4413         if (rc != Z_OK)
4414                 return rc;
4415
4416         rc = zlib_inflate(bp->strm, Z_FINISH);
4417         if ((rc != Z_OK) && (rc != Z_STREAM_END))
4418                 netdev_err(bp->dev, "Firmware decompression error: %s\n",
4419                            bp->strm->msg);
4420
4421         bp->gunzip_outlen = (FW_BUF_SIZE - bp->strm->avail_out);
4422         if (bp->gunzip_outlen & 0x3)
4423                 netdev_err(bp->dev, "Firmware decompression error:"
4424                                     " gunzip_outlen (%d) not aligned\n",
4425                                 bp->gunzip_outlen);
4426         bp->gunzip_outlen >>= 2;
4427
4428         zlib_inflateEnd(bp->strm);
4429
4430         if (rc == Z_STREAM_END)
4431                 return 0;
4432
4433         return rc;
4434 }
4435
4436 /* nic load/unload */
4437
4438 /*
4439  * General service functions
4440  */
4441
4442 /* send a NIG loopback debug packet */
4443 static void bnx2x_lb_pckt(struct bnx2x *bp)
4444 {
4445         u32 wb_write[3];
4446
4447         /* Ethernet source and destination addresses */
4448         wb_write[0] = 0x55555555;
4449         wb_write[1] = 0x55555555;
4450         wb_write[2] = 0x20;             /* SOP */
4451         REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4452
4453         /* NON-IP protocol */
4454         wb_write[0] = 0x09000000;
4455         wb_write[1] = 0x55555555;
4456         wb_write[2] = 0x10;             /* EOP, eop_bvalid = 0 */
4457         REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4458 }
4459
4460 /* some of the internal memories
4461  * are not directly readable from the driver
4462  * to test them we send debug packets
4463  */
4464 static int bnx2x_int_mem_test(struct bnx2x *bp)
4465 {
4466         int factor;
4467         int count, i;
4468         u32 val = 0;
4469
4470         if (CHIP_REV_IS_FPGA(bp))
4471                 factor = 120;
4472         else if (CHIP_REV_IS_EMUL(bp))
4473                 factor = 200;
4474         else
4475                 factor = 1;
4476
4477         /* Disable inputs of parser neighbor blocks */
4478         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
4479         REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
4480         REG_WR(bp, CFC_REG_DEBUG0, 0x1);
4481         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
4482
4483         /*  Write 0 to parser credits for CFC search request */
4484         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
4485
4486         /* send Ethernet packet */
4487         bnx2x_lb_pckt(bp);
4488
4489         /* TODO do i reset NIG statistic? */
4490         /* Wait until NIG register shows 1 packet of size 0x10 */
4491         count = 1000 * factor;
4492         while (count) {
4493
4494                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
4495                 val = *bnx2x_sp(bp, wb_data[0]);
4496                 if (val == 0x10)
4497                         break;
4498
4499                 msleep(10);
4500                 count--;
4501         }
4502         if (val != 0x10) {
4503                 BNX2X_ERR("NIG timeout  val = 0x%x\n", val);
4504                 return -1;
4505         }
4506
4507         /* Wait until PRS register shows 1 packet */
4508         count = 1000 * factor;
4509         while (count) {
4510                 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4511                 if (val == 1)
4512                         break;
4513
4514                 msleep(10);
4515                 count--;
4516         }
4517         if (val != 0x1) {
4518                 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
4519                 return -2;
4520         }
4521
4522         /* Reset and init BRB, PRS */
4523         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
4524         msleep(50);
4525         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
4526         msleep(50);
4527         bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
4528         bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
4529
4530         DP(NETIF_MSG_HW, "part2\n");
4531
4532         /* Disable inputs of parser neighbor blocks */
4533         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
4534         REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
4535         REG_WR(bp, CFC_REG_DEBUG0, 0x1);
4536         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
4537
4538         /* Write 0 to parser credits for CFC search request */
4539         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
4540
4541         /* send 10 Ethernet packets */
4542         for (i = 0; i < 10; i++)
4543                 bnx2x_lb_pckt(bp);
4544
4545         /* Wait until NIG register shows 10 + 1
4546            packets of size 11*0x10 = 0xb0 */
4547         count = 1000 * factor;
4548         while (count) {
4549
4550                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
4551                 val = *bnx2x_sp(bp, wb_data[0]);
4552                 if (val == 0xb0)
4553                         break;
4554
4555                 msleep(10);
4556                 count--;
4557         }
4558         if (val != 0xb0) {
4559                 BNX2X_ERR("NIG timeout  val = 0x%x\n", val);
4560                 return -3;
4561         }
4562
4563         /* Wait until PRS register shows 2 packets */
4564         val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4565         if (val != 2)
4566                 BNX2X_ERR("PRS timeout  val = 0x%x\n", val);
4567
4568         /* Write 1 to parser credits for CFC search request */
4569         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x1);
4570
4571         /* Wait until PRS register shows 3 packets */
4572         msleep(10 * factor);
4573         /* Wait until NIG register shows 1 packet of size 0x10 */
4574         val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4575         if (val != 3)
4576                 BNX2X_ERR("PRS timeout  val = 0x%x\n", val);
4577
4578         /* clear NIG EOP FIFO */
4579         for (i = 0; i < 11; i++)
4580                 REG_RD(bp, NIG_REG_INGRESS_EOP_LB_FIFO);
4581         val = REG_RD(bp, NIG_REG_INGRESS_EOP_LB_EMPTY);
4582         if (val != 1) {
4583                 BNX2X_ERR("clear of NIG failed\n");
4584                 return -4;
4585         }
4586
4587         /* Reset and init BRB, PRS, NIG */
4588         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
4589         msleep(50);
4590         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
4591         msleep(50);
4592         bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
4593         bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
4594 #ifndef BCM_CNIC
4595         /* set NIC mode */
4596         REG_WR(bp, PRS_REG_NIC_MODE, 1);
4597 #endif
4598
4599         /* Enable inputs of parser neighbor blocks */
4600         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x7fffffff);
4601         REG_WR(bp, TCM_REG_PRS_IFEN, 0x1);
4602         REG_WR(bp, CFC_REG_DEBUG0, 0x0);
4603         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x1);
4604
4605         DP(NETIF_MSG_HW, "done\n");
4606
4607         return 0; /* OK */
4608 }
4609
4610 static void enable_blocks_attention(struct bnx2x *bp)
4611 {
4612         REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
4613         if (CHIP_IS_E2(bp))
4614                 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0x40);
4615         else
4616                 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0);
4617         REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
4618         REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
4619         /*
4620          * mask read length error interrupts in brb for parser
4621          * (parsing unit and 'checksum and crc' unit)
4622          * these errors are legal (PU reads fixed length and CAC can cause
4623          * read length error on truncated packets)
4624          */
4625         REG_WR(bp, BRB1_REG_BRB1_INT_MASK, 0xFC00);
4626         REG_WR(bp, QM_REG_QM_INT_MASK, 0);
4627         REG_WR(bp, TM_REG_TM_INT_MASK, 0);
4628         REG_WR(bp, XSDM_REG_XSDM_INT_MASK_0, 0);
4629         REG_WR(bp, XSDM_REG_XSDM_INT_MASK_1, 0);
4630         REG_WR(bp, XCM_REG_XCM_INT_MASK, 0);
4631 /*      REG_WR(bp, XSEM_REG_XSEM_INT_MASK_0, 0); */
4632 /*      REG_WR(bp, XSEM_REG_XSEM_INT_MASK_1, 0); */
4633         REG_WR(bp, USDM_REG_USDM_INT_MASK_0, 0);
4634         REG_WR(bp, USDM_REG_USDM_INT_MASK_1, 0);
4635         REG_WR(bp, UCM_REG_UCM_INT_MASK, 0);
4636 /*      REG_WR(bp, USEM_REG_USEM_INT_MASK_0, 0); */
4637 /*      REG_WR(bp, USEM_REG_USEM_INT_MASK_1, 0); */
4638         REG_WR(bp, GRCBASE_UPB + PB_REG_PB_INT_MASK, 0);
4639         REG_WR(bp, CSDM_REG_CSDM_INT_MASK_0, 0);
4640         REG_WR(bp, CSDM_REG_CSDM_INT_MASK_1, 0);
4641         REG_WR(bp, CCM_REG_CCM_INT_MASK, 0);
4642 /*      REG_WR(bp, CSEM_REG_CSEM_INT_MASK_0, 0); */
4643 /*      REG_WR(bp, CSEM_REG_CSEM_INT_MASK_1, 0); */
4644         if (CHIP_REV_IS_FPGA(bp))
4645                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x580000);
4646         else if (CHIP_IS_E2(bp))
4647                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0,
4648                            (PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_OF
4649                                 | PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_AFT
4650                                 | PXP2_PXP2_INT_MASK_0_REG_PGL_PCIE_ATTN
4651                                 | PXP2_PXP2_INT_MASK_0_REG_PGL_READ_BLOCKED
4652                                 | PXP2_PXP2_INT_MASK_0_REG_PGL_WRITE_BLOCKED));
4653         else
4654                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x480000);
4655         REG_WR(bp, TSDM_REG_TSDM_INT_MASK_0, 0);
4656         REG_WR(bp, TSDM_REG_TSDM_INT_MASK_1, 0);
4657         REG_WR(bp, TCM_REG_TCM_INT_MASK, 0);
4658 /*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_0, 0); */
4659 /*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_1, 0); */
4660         REG_WR(bp, CDU_REG_CDU_INT_MASK, 0);
4661         REG_WR(bp, DMAE_REG_DMAE_INT_MASK, 0);
4662 /*      REG_WR(bp, MISC_REG_MISC_INT_MASK, 0); */
4663         REG_WR(bp, PBF_REG_PBF_INT_MASK, 0X18);         /* bit 3,4 masked */
4664 }
4665
4666 static const struct {
4667         u32 addr;
4668         u32 mask;
4669 } bnx2x_parity_mask[] = {
4670         {PXP_REG_PXP_PRTY_MASK,         0x3ffffff},
4671         {PXP2_REG_PXP2_PRTY_MASK_0,     0xffffffff},
4672         {PXP2_REG_PXP2_PRTY_MASK_1,     0x7f},
4673         {HC_REG_HC_PRTY_MASK,           0x7},
4674         {MISC_REG_MISC_PRTY_MASK,       0x1},
4675         {QM_REG_QM_PRTY_MASK, 0x0},
4676         {DORQ_REG_DORQ_PRTY_MASK, 0x0},
4677         {GRCBASE_UPB + PB_REG_PB_PRTY_MASK, 0x0},
4678         {GRCBASE_XPB + PB_REG_PB_PRTY_MASK, 0x0},
4679         {SRC_REG_SRC_PRTY_MASK, 0x4}, /* bit 2 */
4680         {CDU_REG_CDU_PRTY_MASK, 0x0},
4681         {CFC_REG_CFC_PRTY_MASK, 0x0},
4682         {DBG_REG_DBG_PRTY_MASK, 0x0},
4683         {DMAE_REG_DMAE_PRTY_MASK, 0x0},
4684         {BRB1_REG_BRB1_PRTY_MASK, 0x0},
4685         {PRS_REG_PRS_PRTY_MASK, (1<<6)},/* bit 6 */
4686         {TSDM_REG_TSDM_PRTY_MASK, 0x18},/* bit 3,4 */
4687         {CSDM_REG_CSDM_PRTY_MASK, 0x8}, /* bit 3 */
4688         {USDM_REG_USDM_PRTY_MASK, 0x38},/* bit 3,4,5 */
4689         {XSDM_REG_XSDM_PRTY_MASK, 0x8}, /* bit 3 */
4690         {TSEM_REG_TSEM_PRTY_MASK_0, 0x0},
4691         {TSEM_REG_TSEM_PRTY_MASK_1, 0x0},
4692         {USEM_REG_USEM_PRTY_MASK_0, 0x0},
4693         {USEM_REG_USEM_PRTY_MASK_1, 0x0},
4694         {CSEM_REG_CSEM_PRTY_MASK_0, 0x0},
4695         {CSEM_REG_CSEM_PRTY_MASK_1, 0x0},
4696         {XSEM_REG_XSEM_PRTY_MASK_0, 0x0},
4697         {XSEM_REG_XSEM_PRTY_MASK_1, 0x0}
4698 };
4699
4700 static void enable_blocks_parity(struct bnx2x *bp)
4701 {
4702         int i;
4703
4704         for (i = 0; i < ARRAY_SIZE(bnx2x_parity_mask); i++)
4705                 REG_WR(bp, bnx2x_parity_mask[i].addr,
4706                         bnx2x_parity_mask[i].mask);
4707 }
4708
4709
4710 static void bnx2x_reset_common(struct bnx2x *bp)
4711 {
4712         /* reset_common */
4713         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
4714                0xd3ffff7f);
4715         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
4716 }
4717
4718 static void bnx2x_init_pxp(struct bnx2x *bp)
4719 {
4720         u16 devctl;
4721         int r_order, w_order;
4722
4723         pci_read_config_word(bp->pdev,
4724                              bp->pcie_cap + PCI_EXP_DEVCTL, &devctl);
4725         DP(NETIF_MSG_HW, "read 0x%x from devctl\n", devctl);
4726         w_order = ((devctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
4727         if (bp->mrrs == -1)
4728                 r_order = ((devctl & PCI_EXP_DEVCTL_READRQ) >> 12);
4729         else {
4730                 DP(NETIF_MSG_HW, "force read order to %d\n", bp->mrrs);
4731                 r_order = bp->mrrs;
4732         }
4733
4734         bnx2x_init_pxp_arb(bp, r_order, w_order);
4735 }
4736
4737 static void bnx2x_setup_fan_failure_detection(struct bnx2x *bp)
4738 {
4739         int is_required;
4740         u32 val;
4741         int port;
4742
4743         if (BP_NOMCP(bp))
4744                 return;
4745
4746         is_required = 0;
4747         val = SHMEM_RD(bp, dev_info.shared_hw_config.config2) &
4748               SHARED_HW_CFG_FAN_FAILURE_MASK;
4749
4750         if (val == SHARED_HW_CFG_FAN_FAILURE_ENABLED)
4751                 is_required = 1;
4752
4753         /*
4754          * The fan failure mechanism is usually related to the PHY type since
4755          * the power consumption of the board is affected by the PHY. Currently,
4756          * fan is required for most designs with SFX7101, BCM8727 and BCM8481.
4757          */
4758         else if (val == SHARED_HW_CFG_FAN_FAILURE_PHY_TYPE)
4759                 for (port = PORT_0; port < PORT_MAX; port++) {
4760                         is_required |=
4761                                 bnx2x_fan_failure_det_req(
4762                                         bp,
4763                                         bp->common.shmem_base,
4764                                         bp->common.shmem2_base,
4765                                         port);
4766                 }
4767
4768         DP(NETIF_MSG_HW, "fan detection setting: %d\n", is_required);
4769
4770         if (is_required == 0)
4771                 return;
4772
4773         /* Fan failure is indicated by SPIO 5 */
4774         bnx2x_set_spio(bp, MISC_REGISTERS_SPIO_5,
4775                        MISC_REGISTERS_SPIO_INPUT_HI_Z);
4776
4777         /* set to active low mode */
4778         val = REG_RD(bp, MISC_REG_SPIO_INT);
4779         val |= ((1 << MISC_REGISTERS_SPIO_5) <<
4780                                         MISC_REGISTERS_SPIO_INT_OLD_SET_POS);
4781         REG_WR(bp, MISC_REG_SPIO_INT, val);
4782
4783         /* enable interrupt to signal the IGU */
4784         val = REG_RD(bp, MISC_REG_SPIO_EVENT_EN);
4785         val |= (1 << MISC_REGISTERS_SPIO_5);
4786         REG_WR(bp, MISC_REG_SPIO_EVENT_EN, val);
4787 }
4788
4789 static void bnx2x_pretend_func(struct bnx2x *bp, u8 pretend_func_num)
4790 {
4791         u32 offset = 0;
4792
4793         if (CHIP_IS_E1(bp))
4794                 return;
4795         if (CHIP_IS_E1H(bp) && (pretend_func_num >= E1H_FUNC_MAX))
4796                 return;
4797
4798         switch (BP_ABS_FUNC(bp)) {
4799         case 0:
4800                 offset = PXP2_REG_PGL_PRETEND_FUNC_F0;
4801                 break;
4802         case 1:
4803                 offset = PXP2_REG_PGL_PRETEND_FUNC_F1;
4804                 break;
4805         case 2:
4806                 offset = PXP2_REG_PGL_PRETEND_FUNC_F2;
4807                 break;
4808         case 3:
4809                 offset = PXP2_REG_PGL_PRETEND_FUNC_F3;
4810                 break;
4811         case 4:
4812                 offset = PXP2_REG_PGL_PRETEND_FUNC_F4;
4813                 break;
4814         case 5:
4815                 offset = PXP2_REG_PGL_PRETEND_FUNC_F5;
4816                 break;
4817         case 6:
4818                 offset = PXP2_REG_PGL_PRETEND_FUNC_F6;
4819                 break;
4820         case 7:
4821                 offset = PXP2_REG_PGL_PRETEND_FUNC_F7;
4822                 break;
4823         default:
4824                 return;
4825         }
4826
4827         REG_WR(bp, offset, pretend_func_num);
4828         REG_RD(bp, offset);
4829         DP(NETIF_MSG_HW, "Pretending to func %d\n", pretend_func_num);
4830 }
4831
4832 static void bnx2x_pf_disable(struct bnx2x *bp)
4833 {
4834         u32 val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
4835         val &= ~IGU_PF_CONF_FUNC_EN;
4836
4837         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
4838         REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 0);
4839         REG_WR(bp, CFC_REG_WEAK_ENABLE_PF, 0);
4840 }
4841
4842 static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
4843 {
4844         u32 val, i;
4845
4846         DP(BNX2X_MSG_MCP, "starting common init  func %d\n", BP_ABS_FUNC(bp));
4847
4848         bnx2x_reset_common(bp);
4849         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
4850         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, 0xfffc);
4851
4852         bnx2x_init_block(bp, MISC_BLOCK, COMMON_STAGE);
4853         if (!CHIP_IS_E1(bp))
4854                 REG_WR(bp, MISC_REG_E1HMF_MODE, IS_MF(bp));
4855
4856         if (CHIP_IS_E2(bp)) {
4857                 u8 fid;
4858
4859                 /**
4860                  * 4-port mode or 2-port mode we need to turn of master-enable
4861                  * for everyone, after that, turn it back on for self.
4862                  * so, we disregard multi-function or not, and always disable
4863                  * for all functions on the given path, this means 0,2,4,6 for
4864                  * path 0 and 1,3,5,7 for path 1
4865                  */
4866                 for (fid = BP_PATH(bp); fid  < E2_FUNC_MAX*2; fid += 2) {
4867                         if (fid == BP_ABS_FUNC(bp)) {
4868                                 REG_WR(bp,
4869                                     PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER,
4870                                     1);
4871                                 continue;
4872                         }
4873
4874                         bnx2x_pretend_func(bp, fid);
4875                         /* clear pf enable */
4876                         bnx2x_pf_disable(bp);
4877                         bnx2x_pretend_func(bp, BP_ABS_FUNC(bp));
4878                 }
4879         }
4880
4881         bnx2x_init_block(bp, PXP_BLOCK, COMMON_STAGE);
4882         if (CHIP_IS_E1(bp)) {
4883                 /* enable HW interrupt from PXP on USDM overflow
4884                    bit 16 on INT_MASK_0 */
4885                 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
4886         }
4887
4888         bnx2x_init_block(bp, PXP2_BLOCK, COMMON_STAGE);
4889         bnx2x_init_pxp(bp);
4890
4891 #ifdef __BIG_ENDIAN
4892         REG_WR(bp, PXP2_REG_RQ_QM_ENDIAN_M, 1);
4893         REG_WR(bp, PXP2_REG_RQ_TM_ENDIAN_M, 1);
4894         REG_WR(bp, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
4895         REG_WR(bp, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
4896         REG_WR(bp, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
4897         /* make sure this value is 0 */
4898         REG_WR(bp, PXP2_REG_RQ_HC_ENDIAN_M, 0);
4899
4900 /*      REG_WR(bp, PXP2_REG_RD_PBF_SWAP_MODE, 1); */
4901         REG_WR(bp, PXP2_REG_RD_QM_SWAP_MODE, 1);
4902         REG_WR(bp, PXP2_REG_RD_TM_SWAP_MODE, 1);
4903         REG_WR(bp, PXP2_REG_RD_SRC_SWAP_MODE, 1);
4904         REG_WR(bp, PXP2_REG_RD_CDURD_SWAP_MODE, 1);
4905 #endif
4906
4907         bnx2x_ilt_init_page_size(bp, INITOP_SET);
4908
4909
4910         if (CHIP_REV_IS_FPGA(bp) && CHIP_IS_E1H(bp))
4911                 REG_WR(bp, PXP2_REG_PGL_TAGS_LIMIT, 0x1);
4912
4913         /* let the HW do it's magic ... */
4914         msleep(100);
4915         /* finish PXP init */
4916         val = REG_RD(bp, PXP2_REG_RQ_CFG_DONE);
4917         if (val != 1) {
4918                 BNX2X_ERR("PXP2 CFG failed\n");
4919                 return -EBUSY;
4920         }
4921         val = REG_RD(bp, PXP2_REG_RD_INIT_DONE);
4922         if (val != 1) {
4923                 BNX2X_ERR("PXP2 RD_INIT failed\n");
4924                 return -EBUSY;
4925         }
4926
4927         /* Timers bug workaround E2 only. We need to set the entire ILT to
4928          * have entries with value "0" and valid bit on.
4929          * This needs to be done by the first PF that is loaded in a path
4930          * (i.e. common phase)
4931          */
4932         if (CHIP_IS_E2(bp)) {
4933                 struct ilt_client_info ilt_cli;
4934                 struct bnx2x_ilt ilt;
4935                 memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
4936                 memset(&ilt, 0, sizeof(struct bnx2x_ilt));
4937
4938                 /* initalize dummy TM client */
4939                 ilt_cli.start = 0;
4940                 ilt_cli.end = ILT_NUM_PAGE_ENTRIES - 1;
4941                 ilt_cli.client_num = ILT_CLIENT_TM;
4942
4943                 /* Step 1: set zeroes to all ilt page entries with valid bit on
4944                  * Step 2: set the timers first/last ilt entry to point
4945                  * to the entire range to prevent ILT range error for 3rd/4th
4946                  * vnic (this code assumes existance of the vnic)
4947                  *
4948                  * both steps performed by call to bnx2x_ilt_client_init_op()
4949                  * with dummy TM client
4950                  *
4951                  * we must use pretend since PXP2_REG_RQ_##blk##_FIRST_ILT
4952                  * and his brother are split registers
4953                  */
4954                 bnx2x_pretend_func(bp, (BP_PATH(bp) + 6));
4955                 bnx2x_ilt_client_init_op_ilt(bp, &ilt, &ilt_cli, INITOP_CLEAR);
4956                 bnx2x_pretend_func(bp, BP_ABS_FUNC(bp));
4957
4958                 REG_WR(bp, PXP2_REG_RQ_DRAM_ALIGN, BNX2X_PXP_DRAM_ALIGN);
4959                 REG_WR(bp, PXP2_REG_RQ_DRAM_ALIGN_RD, BNX2X_PXP_DRAM_ALIGN);
4960                 REG_WR(bp, PXP2_REG_RQ_DRAM_ALIGN_SEL, 1);
4961         }
4962
4963
4964         REG_WR(bp, PXP2_REG_RQ_DISABLE_INPUTS, 0);
4965         REG_WR(bp, PXP2_REG_RD_DISABLE_INPUTS, 0);
4966
4967         if (CHIP_IS_E2(bp)) {
4968                 int factor = CHIP_REV_IS_EMUL(bp) ? 1000 :
4969                                 (CHIP_REV_IS_FPGA(bp) ? 400 : 0);
4970                 bnx2x_init_block(bp, PGLUE_B_BLOCK, COMMON_STAGE);
4971
4972                 bnx2x_init_block(bp, ATC_BLOCK, COMMON_STAGE);
4973
4974                 /* let the HW do it's magic ... */
4975                 do {
4976                         msleep(200);
4977                         val = REG_RD(bp, ATC_REG_ATC_INIT_DONE);
4978                 } while (factor-- && (val != 1));
4979
4980                 if (val != 1) {
4981                         BNX2X_ERR("ATC_INIT failed\n");
4982                         return -EBUSY;
4983                 }
4984         }
4985
4986         bnx2x_init_block(bp, DMAE_BLOCK, COMMON_STAGE);
4987
4988         /* clean the DMAE memory */
4989         bp->dmae_ready = 1;
4990         bnx2x_init_fill(bp, TSEM_REG_PRAM, 0, 8);
4991
4992         bnx2x_init_block(bp, TCM_BLOCK, COMMON_STAGE);
4993         bnx2x_init_block(bp, UCM_BLOCK, COMMON_STAGE);
4994         bnx2x_init_block(bp, CCM_BLOCK, COMMON_STAGE);
4995         bnx2x_init_block(bp, XCM_BLOCK, COMMON_STAGE);
4996
4997         bnx2x_read_dmae(bp, XSEM_REG_PASSIVE_BUFFER, 3);
4998         bnx2x_read_dmae(bp, CSEM_REG_PASSIVE_BUFFER, 3);
4999         bnx2x_read_dmae(bp, TSEM_REG_PASSIVE_BUFFER, 3);
5000         bnx2x_read_dmae(bp, USEM_REG_PASSIVE_BUFFER, 3);
5001
5002         bnx2x_init_block(bp, QM_BLOCK, COMMON_STAGE);
5003
5004         if (CHIP_MODE_IS_4_PORT(bp))
5005                 bnx2x_init_block(bp, QM_4PORT_BLOCK, COMMON_STAGE);
5006         /* QM queues pointers table */
5007         bnx2x_qm_init_ptr_table(bp, bp->qm_cid_count, INITOP_SET);
5008
5009         /* soft reset pulse */
5010         REG_WR(bp, QM_REG_SOFT_RESET, 1);
5011         REG_WR(bp, QM_REG_SOFT_RESET, 0);
5012
5013 #ifdef BCM_CNIC
5014         bnx2x_init_block(bp, TIMERS_BLOCK, COMMON_STAGE);
5015 #endif
5016
5017         bnx2x_init_block(bp, DQ_BLOCK, COMMON_STAGE);
5018         REG_WR(bp, DORQ_REG_DPM_CID_OFST, BNX2X_DB_SHIFT);
5019
5020         if (!CHIP_REV_IS_SLOW(bp)) {
5021                 /* enable hw interrupt from doorbell Q */
5022                 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
5023         }
5024
5025         bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
5026         if (CHIP_MODE_IS_4_PORT(bp)) {
5027                 REG_WR(bp, BRB1_REG_FULL_LB_XOFF_THRESHOLD, 248);
5028                 REG_WR(bp, BRB1_REG_FULL_LB_XON_THRESHOLD, 328);
5029         }
5030
5031         bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
5032         REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
5033 #ifndef BCM_CNIC
5034         /* set NIC mode */
5035         REG_WR(bp, PRS_REG_NIC_MODE, 1);
5036 #endif
5037         if (!CHIP_IS_E1(bp))
5038                 REG_WR(bp, PRS_REG_E1HOV_MODE, IS_MF(bp));
5039         if (CHIP_IS_E2(bp)) {
5040                 /* Bit-map indicating which L2 hdrs may appear after the
5041                    basic Ethernet header */
5042                 int has_ovlan = IS_MF(bp);
5043                 REG_WR(bp, PRS_REG_HDRS_AFTER_BASIC, (has_ovlan ? 7 : 6));
5044                 REG_WR(bp, PRS_REG_MUST_HAVE_HDRS, (has_ovlan ? 1 : 0));
5045         }
5046
5047         bnx2x_init_block(bp, TSDM_BLOCK, COMMON_STAGE);
5048         bnx2x_init_block(bp, CSDM_BLOCK, COMMON_STAGE);
5049         bnx2x_init_block(bp, USDM_BLOCK, COMMON_STAGE);
5050         bnx2x_init_block(bp, XSDM_BLOCK, COMMON_STAGE);
5051
5052         bnx2x_init_fill(bp, TSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5053         bnx2x_init_fill(bp, USEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5054         bnx2x_init_fill(bp, CSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5055         bnx2x_init_fill(bp, XSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5056
5057         bnx2x_init_block(bp, TSEM_BLOCK, COMMON_STAGE);
5058         bnx2x_init_block(bp, USEM_BLOCK, COMMON_STAGE);
5059         bnx2x_init_block(bp, CSEM_BLOCK, COMMON_STAGE);
5060         bnx2x_init_block(bp, XSEM_BLOCK, COMMON_STAGE);
5061
5062         if (CHIP_MODE_IS_4_PORT(bp))
5063                 bnx2x_init_block(bp, XSEM_4PORT_BLOCK, COMMON_STAGE);
5064
5065         /* sync semi rtc */
5066         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
5067                0x80000000);
5068         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
5069                0x80000000);
5070
5071         bnx2x_init_block(bp, UPB_BLOCK, COMMON_STAGE);
5072         bnx2x_init_block(bp, XPB_BLOCK, COMMON_STAGE);
5073         bnx2x_init_block(bp, PBF_BLOCK, COMMON_STAGE);
5074
5075         if (CHIP_IS_E2(bp)) {
5076                 int has_ovlan = IS_MF(bp);
5077                 REG_WR(bp, PBF_REG_HDRS_AFTER_BASIC, (has_ovlan ? 7 : 6));
5078                 REG_WR(bp, PBF_REG_MUST_HAVE_HDRS, (has_ovlan ? 1 : 0));
5079         }
5080
5081         REG_WR(bp, SRC_REG_SOFT_RST, 1);
5082         for (i = SRC_REG_KEYRSS0_0; i <= SRC_REG_KEYRSS1_9; i += 4)
5083                 REG_WR(bp, i, random32());
5084         bnx2x_init_block(bp, SRCH_BLOCK, COMMON_STAGE);
5085 #ifdef BCM_CNIC
5086         REG_WR(bp, SRC_REG_KEYSEARCH_0, 0x63285672);
5087         REG_WR(bp, SRC_REG_KEYSEARCH_1, 0x24b8f2cc);
5088         REG_WR(bp, SRC_REG_KEYSEARCH_2, 0x223aef9b);
5089         REG_WR(bp, SRC_REG_KEYSEARCH_3, 0x26001e3a);
5090         REG_WR(bp, SRC_REG_KEYSEARCH_4, 0x7ae91116);
5091         REG_WR(bp, SRC_REG_KEYSEARCH_5, 0x5ce5230b);
5092         REG_WR(bp, SRC_REG_KEYSEARCH_6, 0x298d8adf);
5093         REG_WR(bp, SRC_REG_KEYSEARCH_7, 0x6eb0ff09);
5094         REG_WR(bp, SRC_REG_KEYSEARCH_8, 0x1830f82f);
5095         REG_WR(bp, SRC_REG_KEYSEARCH_9, 0x01e46be7);
5096 #endif
5097         REG_WR(bp, SRC_REG_SOFT_RST, 0);
5098
5099         if (sizeof(union cdu_context) != 1024)
5100                 /* we currently assume that a context is 1024 bytes */
5101                 dev_alert(&bp->pdev->dev, "please adjust the size "
5102                                           "of cdu_context(%ld)\n",
5103                          (long)sizeof(union cdu_context));
5104
5105         bnx2x_init_block(bp, CDU_BLOCK, COMMON_STAGE);
5106         val = (4 << 24) + (0 << 12) + 1024;
5107         REG_WR(bp, CDU_REG_CDU_GLOBAL_PARAMS, val);
5108
5109         bnx2x_init_block(bp, CFC_BLOCK, COMMON_STAGE);
5110         REG_WR(bp, CFC_REG_INIT_REG, 0x7FF);
5111         /* enable context validation interrupt from CFC */
5112         REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
5113
5114         /* set the thresholds to prevent CFC/CDU race */
5115         REG_WR(bp, CFC_REG_DEBUG0, 0x20020000);
5116
5117         bnx2x_init_block(bp, HC_BLOCK, COMMON_STAGE);
5118
5119         if (CHIP_IS_E2(bp) && BP_NOMCP(bp))
5120                 REG_WR(bp, IGU_REG_RESET_MEMORIES, 0x36);
5121
5122         bnx2x_init_block(bp, IGU_BLOCK, COMMON_STAGE);
5123         bnx2x_init_block(bp, MISC_AEU_BLOCK, COMMON_STAGE);
5124
5125         bnx2x_init_block(bp, PXPCS_BLOCK, COMMON_STAGE);
5126         /* Reset PCIE errors for debug */
5127         REG_WR(bp, 0x2814, 0xffffffff);
5128         REG_WR(bp, 0x3820, 0xffffffff);
5129
5130         if (CHIP_IS_E2(bp)) {
5131                 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_CONTROL_5,
5132                            (PXPCS_TL_CONTROL_5_ERR_UNSPPORT1 |
5133                                 PXPCS_TL_CONTROL_5_ERR_UNSPPORT));
5134                 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_FUNC345_STAT,
5135                            (PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT4 |
5136                                 PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT3 |
5137                                 PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT2));
5138                 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_FUNC678_STAT,
5139                            (PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT7 |
5140                                 PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT6 |
5141                                 PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT5));
5142         }
5143
5144         bnx2x_init_block(bp, EMAC0_BLOCK, COMMON_STAGE);
5145         bnx2x_init_block(bp, EMAC1_BLOCK, COMMON_STAGE);
5146         bnx2x_init_block(bp, DBU_BLOCK, COMMON_STAGE);
5147         bnx2x_init_block(bp, DBG_BLOCK, COMMON_STAGE);
5148
5149         bnx2x_init_block(bp, NIG_BLOCK, COMMON_STAGE);
5150         if (!CHIP_IS_E1(bp)) {
5151                 REG_WR(bp, NIG_REG_LLH_MF_MODE, IS_MF(bp));
5152                 REG_WR(bp, NIG_REG_LLH_E1HOV_MODE, IS_MF(bp));
5153         }
5154         if (CHIP_IS_E2(bp)) {
5155                 /* Bit-map indicating which L2 hdrs may appear after the
5156                    basic Ethernet header */
5157                 REG_WR(bp, NIG_REG_P0_HDRS_AFTER_BASIC, (IS_MF(bp) ? 7 : 6));
5158         }
5159
5160         if (CHIP_REV_IS_SLOW(bp))
5161                 msleep(200);
5162
5163         /* finish CFC init */
5164         val = reg_poll(bp, CFC_REG_LL_INIT_DONE, 1, 100, 10);
5165         if (val != 1) {
5166                 BNX2X_ERR("CFC LL_INIT failed\n");
5167                 return -EBUSY;
5168         }
5169         val = reg_poll(bp, CFC_REG_AC_INIT_DONE, 1, 100, 10);
5170         if (val != 1) {
5171                 BNX2X_ERR("CFC AC_INIT failed\n");
5172                 return -EBUSY;
5173         }
5174         val = reg_poll(bp, CFC_REG_CAM_INIT_DONE, 1, 100, 10);
5175         if (val != 1) {
5176                 BNX2X_ERR("CFC CAM_INIT failed\n");
5177                 return -EBUSY;
5178         }
5179         REG_WR(bp, CFC_REG_DEBUG0, 0);
5180
5181         if (CHIP_IS_E1(bp)) {
5182                 /* read NIG statistic
5183                    to see if this is our first up since powerup */
5184                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5185                 val = *bnx2x_sp(bp, wb_data[0]);
5186
5187                 /* do internal memory self test */
5188                 if ((val == 0) && bnx2x_int_mem_test(bp)) {
5189                         BNX2X_ERR("internal mem self test failed\n");
5190                         return -EBUSY;
5191                 }
5192         }
5193
5194         bp->port.need_hw_lock = bnx2x_hw_lock_required(bp,
5195                                                        bp->common.shmem_base,
5196                                                        bp->common.shmem2_base);
5197
5198         bnx2x_setup_fan_failure_detection(bp);
5199
5200         /* clear PXP2 attentions */
5201         REG_RD(bp, PXP2_REG_PXP2_INT_STS_CLR_0);
5202
5203         enable_blocks_attention(bp);
5204         if (CHIP_PARITY_SUPPORTED(bp))
5205                 enable_blocks_parity(bp);
5206
5207         if (!BP_NOMCP(bp)) {
5208                 /* In E2 2-PORT mode, same ext phy is used for the two paths */
5209                 if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) ||
5210                     CHIP_IS_E1x(bp)) {
5211                         u32 shmem_base[2], shmem2_base[2];
5212                         shmem_base[0] =  bp->common.shmem_base;
5213                         shmem2_base[0] = bp->common.shmem2_base;
5214                         if (CHIP_IS_E2(bp)) {
5215                                 shmem_base[1] =
5216                                         SHMEM2_RD(bp, other_shmem_base_addr);
5217                                 shmem2_base[1] =
5218                                         SHMEM2_RD(bp, other_shmem2_base_addr);
5219                         }
5220                         bnx2x_acquire_phy_lock(bp);
5221                         bnx2x_common_init_phy(bp, shmem_base, shmem2_base,
5222                                               bp->common.chip_id);
5223                         bnx2x_release_phy_lock(bp);
5224                 }
5225         } else
5226                 BNX2X_ERR("Bootcode is missing - can not initialize link\n");
5227
5228         return 0;
5229 }
5230
5231 static int bnx2x_init_hw_port(struct bnx2x *bp)
5232 {
5233         int port = BP_PORT(bp);
5234         int init_stage = port ? PORT1_STAGE : PORT0_STAGE;
5235         u32 low, high;
5236         u32 val;
5237
5238         DP(BNX2X_MSG_MCP, "starting port init  port %d\n", port);
5239
5240         REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
5241
5242         bnx2x_init_block(bp, PXP_BLOCK, init_stage);
5243         bnx2x_init_block(bp, PXP2_BLOCK, init_stage);
5244
5245         /* Timers bug workaround: disables the pf_master bit in pglue at
5246          * common phase, we need to enable it here before any dmae access are
5247          * attempted. Therefore we manually added the enable-master to the
5248          * port phase (it also happens in the function phase)
5249          */
5250         if (CHIP_IS_E2(bp))
5251                 REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
5252
5253         bnx2x_init_block(bp, TCM_BLOCK, init_stage);
5254         bnx2x_init_block(bp, UCM_BLOCK, init_stage);
5255         bnx2x_init_block(bp, CCM_BLOCK, init_stage);
5256         bnx2x_init_block(bp, XCM_BLOCK, init_stage);
5257
5258         /* QM cid (connection) count */
5259         bnx2x_qm_init_cid_count(bp, bp->qm_cid_count, INITOP_SET);
5260
5261 #ifdef BCM_CNIC
5262         bnx2x_init_block(bp, TIMERS_BLOCK, init_stage);
5263         REG_WR(bp, TM_REG_LIN0_SCAN_TIME + port*4, 20);
5264         REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + port*4, 31);
5265 #endif
5266
5267         bnx2x_init_block(bp, DQ_BLOCK, init_stage);
5268
5269         if (CHIP_MODE_IS_4_PORT(bp))
5270                 bnx2x_init_block(bp, QM_4PORT_BLOCK, init_stage);
5271
5272         if (CHIP_IS_E1(bp) || CHIP_IS_E1H(bp)) {
5273                 bnx2x_init_block(bp, BRB1_BLOCK, init_stage);
5274                 if (CHIP_REV_IS_SLOW(bp) && CHIP_IS_E1(bp)) {
5275                         /* no pause for emulation and FPGA */
5276                         low = 0;
5277                         high = 513;
5278                 } else {
5279                         if (IS_MF(bp))
5280                                 low = ((bp->flags & ONE_PORT_FLAG) ? 160 : 246);
5281                         else if (bp->dev->mtu > 4096) {
5282                                 if (bp->flags & ONE_PORT_FLAG)
5283                                         low = 160;
5284                                 else {
5285                                         val = bp->dev->mtu;
5286                                         /* (24*1024 + val*4)/256 */
5287                                         low = 96 + (val/64) +
5288                                                         ((val % 64) ? 1 : 0);
5289                                 }
5290                         } else
5291                                 low = ((bp->flags & ONE_PORT_FLAG) ? 80 : 160);
5292                         high = low + 56;        /* 14*1024/256 */
5293                 }
5294                 REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_0 + port*4, low);
5295                 REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_0 + port*4, high);
5296         }
5297
5298         if (CHIP_MODE_IS_4_PORT(bp)) {
5299                 REG_WR(bp, BRB1_REG_PAUSE_0_XOFF_THRESHOLD_0 + port*8, 248);
5300                 REG_WR(bp, BRB1_REG_PAUSE_0_XON_THRESHOLD_0 + port*8, 328);
5301                 REG_WR(bp, (BP_PORT(bp) ? BRB1_REG_MAC_GUARANTIED_1 :
5302                                           BRB1_REG_MAC_GUARANTIED_0), 40);
5303         }
5304
5305         bnx2x_init_block(bp, PRS_BLOCK, init_stage);
5306
5307         bnx2x_init_block(bp, TSDM_BLOCK, init_stage);
5308         bnx2x_init_block(bp, CSDM_BLOCK, init_stage);
5309         bnx2x_init_block(bp, USDM_BLOCK, init_stage);
5310         bnx2x_init_block(bp, XSDM_BLOCK, init_stage);
5311
5312         bnx2x_init_block(bp, TSEM_BLOCK, init_stage);
5313         bnx2x_init_block(bp, USEM_BLOCK, init_stage);
5314         bnx2x_init_block(bp, CSEM_BLOCK, init_stage);
5315         bnx2x_init_block(bp, XSEM_BLOCK, init_stage);
5316         if (CHIP_MODE_IS_4_PORT(bp))
5317                 bnx2x_init_block(bp, XSEM_4PORT_BLOCK, init_stage);
5318
5319         bnx2x_init_block(bp, UPB_BLOCK, init_stage);
5320         bnx2x_init_block(bp, XPB_BLOCK, init_stage);
5321
5322         bnx2x_init_block(bp, PBF_BLOCK, init_stage);
5323
5324         if (!CHIP_IS_E2(bp)) {
5325                 /* configure PBF to work without PAUSE mtu 9000 */
5326                 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
5327
5328                 /* update threshold */
5329                 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, (9040/16));
5330                 /* update init credit */
5331                 REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, (9040/16) + 553 - 22);
5332
5333                 /* probe changes */
5334                 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 1);
5335                 udelay(50);
5336                 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0);
5337         }
5338
5339 #ifdef BCM_CNIC
5340         bnx2x_init_block(bp, SRCH_BLOCK, init_stage);
5341 #endif
5342         bnx2x_init_block(bp, CDU_BLOCK, init_stage);
5343         bnx2x_init_block(bp, CFC_BLOCK, init_stage);
5344
5345         if (CHIP_IS_E1(bp)) {
5346                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5347                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5348         }
5349         bnx2x_init_block(bp, HC_BLOCK, init_stage);
5350
5351         bnx2x_init_block(bp, IGU_BLOCK, init_stage);
5352
5353         bnx2x_init_block(bp, MISC_AEU_BLOCK, init_stage);
5354         /* init aeu_mask_attn_func_0/1:
5355          *  - SF mode: bits 3-7 are masked. only bits 0-2 are in use
5356          *  - MF mode: bit 3 is masked. bits 0-2 are in use as in SF
5357          *             bits 4-7 are used for "per vn group attention" */
5358         REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4,
5359                (IS_MF(bp) ? 0xF7 : 0x7));
5360
5361         bnx2x_init_block(bp, PXPCS_BLOCK, init_stage);
5362         bnx2x_init_block(bp, EMAC0_BLOCK, init_stage);
5363         bnx2x_init_block(bp, EMAC1_BLOCK, init_stage);
5364         bnx2x_init_block(bp, DBU_BLOCK, init_stage);
5365         bnx2x_init_block(bp, DBG_BLOCK, init_stage);
5366
5367         bnx2x_init_block(bp, NIG_BLOCK, init_stage);
5368
5369         REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
5370
5371         if (!CHIP_IS_E1(bp)) {
5372                 /* 0x2 disable mf_ov, 0x1 enable */
5373                 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK_MF + port*4,
5374                        (IS_MF(bp) ? 0x1 : 0x2));
5375
5376                 if (CHIP_IS_E2(bp)) {
5377                         val = 0;
5378                         switch (bp->mf_mode) {
5379                         case MULTI_FUNCTION_SD:
5380                                 val = 1;
5381                                 break;
5382                         case MULTI_FUNCTION_SI:
5383                                 val = 2;
5384                                 break;
5385                         }
5386
5387                         REG_WR(bp, (BP_PORT(bp) ? NIG_REG_LLH1_CLS_TYPE :
5388                                                   NIG_REG_LLH0_CLS_TYPE), val);
5389                 }
5390                 {
5391                         REG_WR(bp, NIG_REG_LLFC_ENABLE_0 + port*4, 0);
5392                         REG_WR(bp, NIG_REG_LLFC_OUT_EN_0 + port*4, 0);
5393                         REG_WR(bp, NIG_REG_PAUSE_ENABLE_0 + port*4, 1);
5394                 }
5395         }
5396
5397         bnx2x_init_block(bp, MCP_BLOCK, init_stage);
5398         bnx2x_init_block(bp, DMAE_BLOCK, init_stage);
5399         bp->port.need_hw_lock = bnx2x_hw_lock_required(bp,
5400                                                        bp->common.shmem_base,
5401                                                        bp->common.shmem2_base);
5402         if (bnx2x_fan_failure_det_req(bp, bp->common.shmem_base,
5403                                       bp->common.shmem2_base, port)) {
5404                 u32 reg_addr = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
5405                                        MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
5406                 val = REG_RD(bp, reg_addr);
5407                 val |= AEU_INPUTS_ATTN_BITS_SPIO5;
5408                 REG_WR(bp, reg_addr, val);
5409         }
5410         bnx2x__link_reset(bp);
5411
5412         return 0;
5413 }
5414
5415 static void bnx2x_ilt_wr(struct bnx2x *bp, u32 index, dma_addr_t addr)
5416 {
5417         int reg;
5418
5419         if (CHIP_IS_E1(bp))
5420                 reg = PXP2_REG_RQ_ONCHIP_AT + index*8;
5421         else
5422                 reg = PXP2_REG_RQ_ONCHIP_AT_B0 + index*8;
5423
5424         bnx2x_wb_wr(bp, reg, ONCHIP_ADDR1(addr), ONCHIP_ADDR2(addr));
5425 }
5426
5427 static inline void bnx2x_igu_clear_sb(struct bnx2x *bp, u8 idu_sb_id)
5428 {
5429         bnx2x_igu_clear_sb_gen(bp, idu_sb_id, true /*PF*/);
5430 }
5431
5432 static inline void bnx2x_clear_func_ilt(struct bnx2x *bp, u32 func)
5433 {
5434         u32 i, base = FUNC_ILT_BASE(func);
5435         for (i = base; i < base + ILT_PER_FUNC; i++)
5436                 bnx2x_ilt_wr(bp, i, 0);
5437 }
5438
5439 static int bnx2x_init_hw_func(struct bnx2x *bp)
5440 {
5441         int port = BP_PORT(bp);
5442         int func = BP_FUNC(bp);
5443         struct bnx2x_ilt *ilt = BP_ILT(bp);
5444         u16 cdu_ilt_start;
5445         u32 addr, val;
5446         int i;
5447
5448         DP(BNX2X_MSG_MCP, "starting func init  func %d\n", func);
5449
5450         /* set MSI reconfigure capability */
5451         if (bp->common.int_block == INT_BLOCK_HC) {
5452                 addr = (port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0);
5453                 val = REG_RD(bp, addr);
5454                 val |= HC_CONFIG_0_REG_MSI_ATTN_EN_0;
5455                 REG_WR(bp, addr, val);
5456         }
5457
5458         ilt = BP_ILT(bp);
5459         cdu_ilt_start = ilt->clients[ILT_CLIENT_CDU].start;
5460
5461         for (i = 0; i < L2_ILT_LINES(bp); i++) {
5462                 ilt->lines[cdu_ilt_start + i].page =
5463                         bp->context.vcxt + (ILT_PAGE_CIDS * i);
5464                 ilt->lines[cdu_ilt_start + i].page_mapping =
5465                         bp->context.cxt_mapping + (CDU_ILT_PAGE_SZ * i);
5466                 /* cdu ilt pages are allocated manually so there's no need to
5467                 set the size */
5468         }
5469         bnx2x_ilt_init_op(bp, INITOP_SET);
5470 #ifdef BCM_CNIC
5471         bnx2x_src_init_t2(bp, bp->t2, bp->t2_mapping, SRC_CONN_NUM);
5472
5473         /* T1 hash bits value determines the T1 number of entries */
5474         REG_WR(bp, SRC_REG_NUMBER_HASH_BITS0 + port*4, SRC_HASH_BITS);
5475 #endif
5476
5477 #ifndef BCM_CNIC
5478         /* set NIC mode */
5479         REG_WR(bp, PRS_REG_NIC_MODE, 1);
5480 #endif  /* BCM_CNIC */
5481
5482         if (CHIP_IS_E2(bp)) {
5483                 u32 pf_conf = IGU_PF_CONF_FUNC_EN;
5484
5485                 /* Turn on a single ISR mode in IGU if driver is going to use
5486                  * INT#x or MSI
5487                  */
5488                 if (!(bp->flags & USING_MSIX_FLAG))
5489                         pf_conf |= IGU_PF_CONF_SINGLE_ISR_EN;
5490                 /*
5491                  * Timers workaround bug: function init part.
5492                  * Need to wait 20msec after initializing ILT,
5493                  * needed to make sure there are no requests in
5494                  * one of the PXP internal queues with "old" ILT addresses
5495                  */
5496                 msleep(20);
5497                 /*
5498                  * Master enable - Due to WB DMAE writes performed before this
5499                  * register is re-initialized as part of the regular function
5500                  * init
5501                  */
5502                 REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
5503                 /* Enable the function in IGU */
5504                 REG_WR(bp, IGU_REG_PF_CONFIGURATION, pf_conf);
5505         }
5506
5507         bp->dmae_ready = 1;
5508
5509         bnx2x_init_block(bp, PGLUE_B_BLOCK, FUNC0_STAGE + func);
5510
5511         if (CHIP_IS_E2(bp))
5512                 REG_WR(bp, PGLUE_B_REG_WAS_ERROR_PF_7_0_CLR, func);
5513
5514         bnx2x_init_block(bp, MISC_BLOCK, FUNC0_STAGE + func);
5515         bnx2x_init_block(bp, TCM_BLOCK, FUNC0_STAGE + func);
5516         bnx2x_init_block(bp, UCM_BLOCK, FUNC0_STAGE + func);
5517         bnx2x_init_block(bp, CCM_BLOCK, FUNC0_STAGE + func);
5518         bnx2x_init_block(bp, XCM_BLOCK, FUNC0_STAGE + func);
5519         bnx2x_init_block(bp, TSEM_BLOCK, FUNC0_STAGE + func);
5520         bnx2x_init_block(bp, USEM_BLOCK, FUNC0_STAGE + func);
5521         bnx2x_init_block(bp, CSEM_BLOCK, FUNC0_STAGE + func);
5522         bnx2x_init_block(bp, XSEM_BLOCK, FUNC0_STAGE + func);
5523
5524         if (CHIP_IS_E2(bp)) {
5525                 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_PATH_ID_OFFSET,
5526                                                                 BP_PATH(bp));
5527                 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_PATH_ID_OFFSET,
5528                                                                 BP_PATH(bp));
5529         }
5530
5531         if (CHIP_MODE_IS_4_PORT(bp))
5532                 bnx2x_init_block(bp, XSEM_4PORT_BLOCK, FUNC0_STAGE + func);
5533
5534         if (CHIP_IS_E2(bp))
5535                 REG_WR(bp, QM_REG_PF_EN, 1);
5536
5537         bnx2x_init_block(bp, QM_BLOCK, FUNC0_STAGE + func);
5538
5539         if (CHIP_MODE_IS_4_PORT(bp))
5540                 bnx2x_init_block(bp, QM_4PORT_BLOCK, FUNC0_STAGE + func);
5541
5542         bnx2x_init_block(bp, TIMERS_BLOCK, FUNC0_STAGE + func);
5543         bnx2x_init_block(bp, DQ_BLOCK, FUNC0_STAGE + func);
5544         bnx2x_init_block(bp, BRB1_BLOCK, FUNC0_STAGE + func);
5545         bnx2x_init_block(bp, PRS_BLOCK, FUNC0_STAGE + func);
5546         bnx2x_init_block(bp, TSDM_BLOCK, FUNC0_STAGE + func);
5547         bnx2x_init_block(bp, CSDM_BLOCK, FUNC0_STAGE + func);
5548         bnx2x_init_block(bp, USDM_BLOCK, FUNC0_STAGE + func);
5549         bnx2x_init_block(bp, XSDM_BLOCK, FUNC0_STAGE + func);
5550         bnx2x_init_block(bp, UPB_BLOCK, FUNC0_STAGE + func);
5551         bnx2x_init_block(bp, XPB_BLOCK, FUNC0_STAGE + func);
5552         bnx2x_init_block(bp, PBF_BLOCK, FUNC0_STAGE + func);
5553         if (CHIP_IS_E2(bp))
5554                 REG_WR(bp, PBF_REG_DISABLE_PF, 0);
5555
5556         bnx2x_init_block(bp, CDU_BLOCK, FUNC0_STAGE + func);
5557
5558         bnx2x_init_block(bp, CFC_BLOCK, FUNC0_STAGE + func);
5559
5560         if (CHIP_IS_E2(bp))
5561                 REG_WR(bp, CFC_REG_WEAK_ENABLE_PF, 1);
5562
5563         if (IS_MF(bp)) {
5564                 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
5565                 REG_WR(bp, NIG_REG_LLH0_FUNC_VLAN_ID + port*8, bp->mf_ov);
5566         }
5567
5568         bnx2x_init_block(bp, MISC_AEU_BLOCK, FUNC0_STAGE + func);
5569
5570         /* HC init per function */
5571         if (bp->common.int_block == INT_BLOCK_HC) {
5572                 if (CHIP_IS_E1H(bp)) {
5573                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
5574
5575                         REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5576                         REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5577                 }
5578                 bnx2x_init_block(bp, HC_BLOCK, FUNC0_STAGE + func);
5579
5580         } else {
5581                 int num_segs, sb_idx, prod_offset;
5582
5583                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
5584
5585                 if (CHIP_IS_E2(bp)) {
5586                         REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, 0);
5587                         REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, 0);
5588                 }
5589
5590                 bnx2x_init_block(bp, IGU_BLOCK, FUNC0_STAGE + func);
5591
5592                 if (CHIP_IS_E2(bp)) {
5593                         int dsb_idx = 0;
5594                         /**
5595                          * Producer memory:
5596                          * E2 mode: address 0-135 match to the mapping memory;
5597                          * 136 - PF0 default prod; 137 - PF1 default prod;
5598                          * 138 - PF2 default prod; 139 - PF3 default prod;
5599                          * 140 - PF0 attn prod;    141 - PF1 attn prod;
5600                          * 142 - PF2 attn prod;    143 - PF3 attn prod;
5601                          * 144-147 reserved.
5602                          *
5603                          * E1.5 mode - In backward compatible mode;
5604                          * for non default SB; each even line in the memory
5605                          * holds the U producer and each odd line hold
5606                          * the C producer. The first 128 producers are for
5607                          * NDSB (PF0 - 0-31; PF1 - 32-63 and so on). The last 20
5608                          * producers are for the DSB for each PF.
5609                          * Each PF has five segments: (the order inside each
5610                          * segment is PF0; PF1; PF2; PF3) - 128-131 U prods;
5611                          * 132-135 C prods; 136-139 X prods; 140-143 T prods;
5612                          * 144-147 attn prods;
5613                          */
5614                         /* non-default-status-blocks */
5615                         num_segs = CHIP_INT_MODE_IS_BC(bp) ?
5616                                 IGU_BC_NDSB_NUM_SEGS : IGU_NORM_NDSB_NUM_SEGS;
5617                         for (sb_idx = 0; sb_idx < bp->igu_sb_cnt; sb_idx++) {
5618                                 prod_offset = (bp->igu_base_sb + sb_idx) *
5619                                         num_segs;
5620
5621                                 for (i = 0; i < num_segs; i++) {
5622                                         addr = IGU_REG_PROD_CONS_MEMORY +
5623                                                         (prod_offset + i) * 4;
5624                                         REG_WR(bp, addr, 0);
5625                                 }
5626                                 /* send consumer update with value 0 */
5627                                 bnx2x_ack_sb(bp, bp->igu_base_sb + sb_idx,
5628                                              USTORM_ID, 0, IGU_INT_NOP, 1);
5629                                 bnx2x_igu_clear_sb(bp,
5630                                                    bp->igu_base_sb + sb_idx);
5631                         }
5632
5633                         /* default-status-blocks */
5634                         num_segs = CHIP_INT_MODE_IS_BC(bp) ?
5635                                 IGU_BC_DSB_NUM_SEGS : IGU_NORM_DSB_NUM_SEGS;
5636
5637                         if (CHIP_MODE_IS_4_PORT(bp))
5638                                 dsb_idx = BP_FUNC(bp);
5639                         else
5640                                 dsb_idx = BP_E1HVN(bp);
5641
5642                         prod_offset = (CHIP_INT_MODE_IS_BC(bp) ?
5643                                        IGU_BC_BASE_DSB_PROD + dsb_idx :
5644                                        IGU_NORM_BASE_DSB_PROD + dsb_idx);
5645
5646                         for (i = 0; i < (num_segs * E1HVN_MAX);
5647                              i += E1HVN_MAX) {
5648                                 addr = IGU_REG_PROD_CONS_MEMORY +
5649                                                         (prod_offset + i)*4;
5650                                 REG_WR(bp, addr, 0);
5651                         }
5652                         /* send consumer update with 0 */
5653                         if (CHIP_INT_MODE_IS_BC(bp)) {
5654                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5655                                              USTORM_ID, 0, IGU_INT_NOP, 1);
5656                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5657                                              CSTORM_ID, 0, IGU_INT_NOP, 1);
5658                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5659                                              XSTORM_ID, 0, IGU_INT_NOP, 1);
5660                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5661                                              TSTORM_ID, 0, IGU_INT_NOP, 1);
5662                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5663                                              ATTENTION_ID, 0, IGU_INT_NOP, 1);
5664                         } else {
5665                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5666                                              USTORM_ID, 0, IGU_INT_NOP, 1);
5667                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5668                                              ATTENTION_ID, 0, IGU_INT_NOP, 1);
5669                         }
5670                         bnx2x_igu_clear_sb(bp, bp->igu_dsb_id);
5671
5672                         /* !!! these should become driver const once
5673                            rf-tool supports split-68 const */
5674                         REG_WR(bp, IGU_REG_SB_INT_BEFORE_MASK_LSB, 0);
5675                         REG_WR(bp, IGU_REG_SB_INT_BEFORE_MASK_MSB, 0);
5676                         REG_WR(bp, IGU_REG_SB_MASK_LSB, 0);
5677                         REG_WR(bp, IGU_REG_SB_MASK_MSB, 0);
5678                         REG_WR(bp, IGU_REG_PBA_STATUS_LSB, 0);
5679                         REG_WR(bp, IGU_REG_PBA_STATUS_MSB, 0);
5680                 }
5681         }
5682
5683         /* Reset PCIE errors for debug */
5684         REG_WR(bp, 0x2114, 0xffffffff);
5685         REG_WR(bp, 0x2120, 0xffffffff);
5686
5687         bnx2x_init_block(bp, EMAC0_BLOCK, FUNC0_STAGE + func);
5688         bnx2x_init_block(bp, EMAC1_BLOCK, FUNC0_STAGE + func);
5689         bnx2x_init_block(bp, DBU_BLOCK, FUNC0_STAGE + func);
5690         bnx2x_init_block(bp, DBG_BLOCK, FUNC0_STAGE + func);
5691         bnx2x_init_block(bp, MCP_BLOCK, FUNC0_STAGE + func);
5692         bnx2x_init_block(bp, DMAE_BLOCK, FUNC0_STAGE + func);
5693
5694         bnx2x_phy_probe(&bp->link_params);
5695         return 0;
5696 }
5697
5698 int bnx2x_init_hw(struct bnx2x *bp, u32 load_code)
5699 {
5700         int rc = 0;
5701
5702         DP(BNX2X_MSG_MCP, "function %d  load_code %x\n",
5703            BP_ABS_FUNC(bp), load_code);
5704
5705         bp->dmae_ready = 0;
5706         mutex_init(&bp->dmae_mutex);
5707         rc = bnx2x_gunzip_init(bp);
5708         if (rc)
5709                 return rc;
5710
5711         switch (load_code) {
5712         case FW_MSG_CODE_DRV_LOAD_COMMON:
5713         case FW_MSG_CODE_DRV_LOAD_COMMON_CHIP:
5714                 rc = bnx2x_init_hw_common(bp, load_code);
5715                 if (rc)
5716                         goto init_hw_err;
5717                 /* no break */
5718
5719         case FW_MSG_CODE_DRV_LOAD_PORT:
5720                 rc = bnx2x_init_hw_port(bp);
5721                 if (rc)
5722                         goto init_hw_err;
5723                 /* no break */
5724
5725         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
5726                 rc = bnx2x_init_hw_func(bp);
5727                 if (rc)
5728                         goto init_hw_err;
5729                 break;
5730
5731         default:
5732                 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
5733                 break;
5734         }
5735
5736         if (!BP_NOMCP(bp)) {
5737                 int mb_idx = BP_FW_MB_IDX(bp);
5738
5739                 bp->fw_drv_pulse_wr_seq =
5740                                 (SHMEM_RD(bp, func_mb[mb_idx].drv_pulse_mb) &
5741                                  DRV_PULSE_SEQ_MASK);
5742                 DP(BNX2X_MSG_MCP, "drv_pulse 0x%x\n", bp->fw_drv_pulse_wr_seq);
5743         }
5744
5745 init_hw_err:
5746         bnx2x_gunzip_end(bp);
5747
5748         return rc;
5749 }
5750
5751 void bnx2x_free_mem(struct bnx2x *bp)
5752 {
5753
5754 #define BNX2X_PCI_FREE(x, y, size) \
5755         do { \
5756                 if (x) { \
5757                         dma_free_coherent(&bp->pdev->dev, size, (void *)x, y); \
5758                         x = NULL; \
5759                         y = 0; \
5760                 } \
5761         } while (0)
5762
5763 #define BNX2X_FREE(x) \
5764         do { \
5765                 if (x) { \
5766                         kfree((void *)x); \
5767                         x = NULL; \
5768                 } \
5769         } while (0)
5770
5771         int i;
5772
5773         /* fastpath */
5774         /* Common */
5775         for_each_queue(bp, i) {
5776                 /* status blocks */
5777                 if (CHIP_IS_E2(bp))
5778                         BNX2X_PCI_FREE(bnx2x_fp(bp, i, status_blk.e2_sb),
5779                                        bnx2x_fp(bp, i, status_blk_mapping),
5780                                        sizeof(struct host_hc_status_block_e2));
5781                 else
5782                         BNX2X_PCI_FREE(bnx2x_fp(bp, i, status_blk.e1x_sb),
5783                                        bnx2x_fp(bp, i, status_blk_mapping),
5784                                        sizeof(struct host_hc_status_block_e1x));
5785         }
5786         /* Rx */
5787         for_each_queue(bp, i) {
5788
5789                 /* fastpath rx rings: rx_buf rx_desc rx_comp */
5790                 BNX2X_FREE(bnx2x_fp(bp, i, rx_buf_ring));
5791                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_desc_ring),
5792                                bnx2x_fp(bp, i, rx_desc_mapping),
5793                                sizeof(struct eth_rx_bd) * NUM_RX_BD);
5794
5795                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_comp_ring),
5796                                bnx2x_fp(bp, i, rx_comp_mapping),
5797                                sizeof(struct eth_fast_path_rx_cqe) *
5798                                NUM_RCQ_BD);
5799
5800                 /* SGE ring */
5801                 BNX2X_FREE(bnx2x_fp(bp, i, rx_page_ring));
5802                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_sge_ring),
5803                                bnx2x_fp(bp, i, rx_sge_mapping),
5804                                BCM_PAGE_SIZE * NUM_RX_SGE_PAGES);
5805         }
5806         /* Tx */
5807         for_each_queue(bp, i) {
5808
5809                 /* fastpath tx rings: tx_buf tx_desc */
5810                 BNX2X_FREE(bnx2x_fp(bp, i, tx_buf_ring));
5811                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, tx_desc_ring),
5812                                bnx2x_fp(bp, i, tx_desc_mapping),
5813                                sizeof(union eth_tx_bd_types) * NUM_TX_BD);
5814         }
5815         /* end of fastpath */
5816
5817         BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
5818                        sizeof(struct host_sp_status_block));
5819
5820         BNX2X_PCI_FREE(bp->slowpath, bp->slowpath_mapping,
5821                        sizeof(struct bnx2x_slowpath));
5822
5823         BNX2X_PCI_FREE(bp->context.vcxt, bp->context.cxt_mapping,
5824                        bp->context.size);
5825
5826         bnx2x_ilt_mem_op(bp, ILT_MEMOP_FREE);
5827
5828         BNX2X_FREE(bp->ilt->lines);
5829 #ifdef BCM_CNIC
5830         if (CHIP_IS_E2(bp))
5831                 BNX2X_PCI_FREE(bp->cnic_sb.e2_sb, bp->cnic_sb_mapping,
5832                                sizeof(struct host_hc_status_block_e2));
5833         else
5834                 BNX2X_PCI_FREE(bp->cnic_sb.e1x_sb, bp->cnic_sb_mapping,
5835                                sizeof(struct host_hc_status_block_e1x));
5836         BNX2X_PCI_FREE(bp->t2, bp->t2_mapping, SRC_T2_SZ);
5837 #endif
5838         BNX2X_PCI_FREE(bp->spq, bp->spq_mapping, BCM_PAGE_SIZE);
5839
5840         BNX2X_PCI_FREE(bp->eq_ring, bp->eq_mapping,
5841                        BCM_PAGE_SIZE * NUM_EQ_PAGES);
5842
5843 #undef BNX2X_PCI_FREE
5844 #undef BNX2X_KFREE
5845 }
5846
5847 static inline void set_sb_shortcuts(struct bnx2x *bp, int index)
5848 {
5849         union host_hc_status_block status_blk = bnx2x_fp(bp, index, status_blk);
5850         if (CHIP_IS_E2(bp)) {
5851                 bnx2x_fp(bp, index, sb_index_values) =
5852                         (__le16 *)status_blk.e2_sb->sb.index_values;
5853                 bnx2x_fp(bp, index, sb_running_index) =
5854                         (__le16 *)status_blk.e2_sb->sb.running_index;
5855         } else {
5856                 bnx2x_fp(bp, index, sb_index_values) =
5857                         (__le16 *)status_blk.e1x_sb->sb.index_values;
5858                 bnx2x_fp(bp, index, sb_running_index) =
5859                         (__le16 *)status_blk.e1x_sb->sb.running_index;
5860         }
5861 }
5862
5863 int bnx2x_alloc_mem(struct bnx2x *bp)
5864 {
5865
5866 #define BNX2X_PCI_ALLOC(x, y, size) \
5867         do { \
5868                 x = dma_alloc_coherent(&bp->pdev->dev, size, y, GFP_KERNEL); \
5869                 if (x == NULL) \
5870                         goto alloc_mem_err; \
5871                 memset(x, 0, size); \
5872         } while (0)
5873
5874 #define BNX2X_ALLOC(x, size) \
5875         do { \
5876                 x = kzalloc(size, GFP_KERNEL); \
5877                 if (x == NULL) \
5878                         goto alloc_mem_err; \