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