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