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