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