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