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