BNX2X: LIST_HEAD -> LINUX_LIST_HEAD
[akaros.git] / kern / drivers / net / bnx2x / bnx2x_main.c
1 /* bnx2x_main.c: Broadcom Everest network driver.
2  *
3  * Copyright (c) 2007-2013 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: Ariel Elior <ariel.elior@qlogic.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 "akaros_compat.h"
19
20 #include "bnx2x.h"
21 #include "bnx2x_init.h"
22 #include "bnx2x_init_ops.h"
23 #include "bnx2x_cmn.h"
24 #include "bnx2x_vfpf.h"
25 #include "bnx2x_dcb.h"
26 #include "bnx2x_sp.h"
27 #include "bnx2x_fw_file_hdr.h"
28 /* FW files */
29 #define FW_FILE_VERSION                                 \
30         __stringify(BCM_5710_FW_MAJOR_VERSION) "."      \
31         __stringify(BCM_5710_FW_MINOR_VERSION) "."      \
32         __stringify(BCM_5710_FW_REVISION_VERSION) "."   \
33         __stringify(BCM_5710_FW_ENGINEERING_VERSION)
34 #define FW_FILE_NAME_E1         "bnx2x/bnx2x-e1-" FW_FILE_VERSION ".fw"
35 #define FW_FILE_NAME_E1H        "bnx2x/bnx2x-e1h-" FW_FILE_VERSION ".fw"
36 #define FW_FILE_NAME_E2         "bnx2x/bnx2x-e2-" FW_FILE_VERSION ".fw"
37
38 /* Time in jiffies before concluding the transmitter is hung */
39 #define TX_TIMEOUT              (5*HZ)
40
41 static char version[] =
42         "Broadcom NetXtreme II 5771x/578xx 10/20-Gigabit Ethernet Driver "
43         DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
44
45 MODULE_AUTHOR("Eliezer Tamir");
46 MODULE_DESCRIPTION("Broadcom NetXtreme II "
47                    "BCM57710/57711/57711E/"
48                    "57712/57712_MF/57800/57800_MF/57810/57810_MF/"
49                    "57840/57840_MF Driver");
50 MODULE_LICENSE("GPL");
51 MODULE_VERSION(DRV_MODULE_VERSION);
52 MODULE_FIRMWARE(FW_FILE_NAME_E1);
53 MODULE_FIRMWARE(FW_FILE_NAME_E1H);
54 MODULE_FIRMWARE(FW_FILE_NAME_E2);
55
56 int bnx2x_num_queues;
57 module_param_named(num_queues, bnx2x_num_queues, int, S_IRUGO);
58 MODULE_PARM_DESC(num_queues,
59                  " Set number of queues (default is as a number of CPUs)");
60
61 static int disable_tpa;
62 module_param(disable_tpa, int, S_IRUGO);
63 MODULE_PARM_DESC(disable_tpa, " Disable the TPA (LRO) feature");
64
65 static int int_mode;
66 module_param(int_mode, int, S_IRUGO);
67 MODULE_PARM_DESC(int_mode, " Force interrupt mode other than MSI-X "
68                                 "(1 INT#x; 2 MSI)");
69
70 static int dropless_fc;
71 module_param(dropless_fc, int, S_IRUGO);
72 MODULE_PARM_DESC(dropless_fc, " Pause on exhausted host ring");
73
74 static int mrrs = -1;
75 module_param(mrrs, int, S_IRUGO);
76 MODULE_PARM_DESC(mrrs, " Force Max Read Req Size (0..3) (for debug)");
77
78 static int debug;
79 module_param(debug, int, S_IRUGO);
80 MODULE_PARM_DESC(debug, " Default debug msglevel");
81
82 static struct workqueue_struct *bnx2x_wq;
83 struct workqueue_struct *bnx2x_iov_wq;
84
85 struct bnx2x_mac_vals {
86         u32 xmac_addr;
87         u32 xmac_val;
88         u32 emac_addr;
89         u32 emac_val;
90         u32 umac_addr;
91         u32 umac_val;
92         u32 bmac_addr;
93         u32 bmac_val[2];
94 };
95
96 enum bnx2x_board_type {
97         BCM57710 = 0,
98         BCM57711,
99         BCM57711E,
100         BCM57712,
101         BCM57712_MF,
102         BCM57712_VF,
103         BCM57800,
104         BCM57800_MF,
105         BCM57800_VF,
106         BCM57810,
107         BCM57810_MF,
108         BCM57810_VF,
109         BCM57840_4_10,
110         BCM57840_2_20,
111         BCM57840_MF,
112         BCM57840_VF,
113         BCM57811,
114         BCM57811_MF,
115         BCM57840_O,
116         BCM57840_MFO,
117         BCM57811_VF
118 };
119
120 /* indexed by board_type, above */
121 static struct {
122         char *name;
123 } board_info[] = {
124         [BCM57710]      = { "Broadcom NetXtreme II BCM57710 10 Gigabit PCIe [Everest]" },
125         [BCM57711]      = { "Broadcom NetXtreme II BCM57711 10 Gigabit PCIe" },
126         [BCM57711E]     = { "Broadcom NetXtreme II BCM57711E 10 Gigabit PCIe" },
127         [BCM57712]      = { "Broadcom NetXtreme II BCM57712 10 Gigabit Ethernet" },
128         [BCM57712_MF]   = { "Broadcom NetXtreme II BCM57712 10 Gigabit Ethernet Multi Function" },
129         [BCM57712_VF]   = { "Broadcom NetXtreme II BCM57712 10 Gigabit Ethernet Virtual Function" },
130         [BCM57800]      = { "Broadcom NetXtreme II BCM57800 10 Gigabit Ethernet" },
131         [BCM57800_MF]   = { "Broadcom NetXtreme II BCM57800 10 Gigabit Ethernet Multi Function" },
132         [BCM57800_VF]   = { "Broadcom NetXtreme II BCM57800 10 Gigabit Ethernet Virtual Function" },
133         [BCM57810]      = { "Broadcom NetXtreme II BCM57810 10 Gigabit Ethernet" },
134         [BCM57810_MF]   = { "Broadcom NetXtreme II BCM57810 10 Gigabit Ethernet Multi Function" },
135         [BCM57810_VF]   = { "Broadcom NetXtreme II BCM57810 10 Gigabit Ethernet Virtual Function" },
136         [BCM57840_4_10] = { "Broadcom NetXtreme II BCM57840 10 Gigabit Ethernet" },
137         [BCM57840_2_20] = { "Broadcom NetXtreme II BCM57840 20 Gigabit Ethernet" },
138         [BCM57840_MF]   = { "Broadcom NetXtreme II BCM57840 10/20 Gigabit Ethernet Multi Function" },
139         [BCM57840_VF]   = { "Broadcom NetXtreme II BCM57840 10/20 Gigabit Ethernet Virtual Function" },
140         [BCM57811]      = { "Broadcom NetXtreme II BCM57811 10 Gigabit Ethernet" },
141         [BCM57811_MF]   = { "Broadcom NetXtreme II BCM57811 10 Gigabit Ethernet Multi Function" },
142         [BCM57840_O]    = { "Broadcom NetXtreme II BCM57840 10/20 Gigabit Ethernet" },
143         [BCM57840_MFO]  = { "Broadcom NetXtreme II BCM57840 10/20 Gigabit Ethernet Multi Function" },
144         [BCM57811_VF]   = { "Broadcom NetXtreme II BCM57840 10/20 Gigabit Ethernet Virtual Function" }
145 };
146
147 #ifndef PCI_DEVICE_ID_NX2_57710
148 #define PCI_DEVICE_ID_NX2_57710         CHIP_NUM_57710
149 #endif
150 #ifndef PCI_DEVICE_ID_NX2_57711
151 #define PCI_DEVICE_ID_NX2_57711         CHIP_NUM_57711
152 #endif
153 #ifndef PCI_DEVICE_ID_NX2_57711E
154 #define PCI_DEVICE_ID_NX2_57711E        CHIP_NUM_57711E
155 #endif
156 #ifndef PCI_DEVICE_ID_NX2_57712
157 #define PCI_DEVICE_ID_NX2_57712         CHIP_NUM_57712
158 #endif
159 #ifndef PCI_DEVICE_ID_NX2_57712_MF
160 #define PCI_DEVICE_ID_NX2_57712_MF      CHIP_NUM_57712_MF
161 #endif
162 #ifndef PCI_DEVICE_ID_NX2_57712_VF
163 #define PCI_DEVICE_ID_NX2_57712_VF      CHIP_NUM_57712_VF
164 #endif
165 #ifndef PCI_DEVICE_ID_NX2_57800
166 #define PCI_DEVICE_ID_NX2_57800         CHIP_NUM_57800
167 #endif
168 #ifndef PCI_DEVICE_ID_NX2_57800_MF
169 #define PCI_DEVICE_ID_NX2_57800_MF      CHIP_NUM_57800_MF
170 #endif
171 #ifndef PCI_DEVICE_ID_NX2_57800_VF
172 #define PCI_DEVICE_ID_NX2_57800_VF      CHIP_NUM_57800_VF
173 #endif
174 #ifndef PCI_DEVICE_ID_NX2_57810
175 #define PCI_DEVICE_ID_NX2_57810         CHIP_NUM_57810
176 #endif
177 #ifndef PCI_DEVICE_ID_NX2_57810_MF
178 #define PCI_DEVICE_ID_NX2_57810_MF      CHIP_NUM_57810_MF
179 #endif
180 #ifndef PCI_DEVICE_ID_NX2_57840_O
181 #define PCI_DEVICE_ID_NX2_57840_O       CHIP_NUM_57840_OBSOLETE
182 #endif
183 #ifndef PCI_DEVICE_ID_NX2_57810_VF
184 #define PCI_DEVICE_ID_NX2_57810_VF      CHIP_NUM_57810_VF
185 #endif
186 #ifndef PCI_DEVICE_ID_NX2_57840_4_10
187 #define PCI_DEVICE_ID_NX2_57840_4_10    CHIP_NUM_57840_4_10
188 #endif
189 #ifndef PCI_DEVICE_ID_NX2_57840_2_20
190 #define PCI_DEVICE_ID_NX2_57840_2_20    CHIP_NUM_57840_2_20
191 #endif
192 #ifndef PCI_DEVICE_ID_NX2_57840_MFO
193 #define PCI_DEVICE_ID_NX2_57840_MFO     CHIP_NUM_57840_MF_OBSOLETE
194 #endif
195 #ifndef PCI_DEVICE_ID_NX2_57840_MF
196 #define PCI_DEVICE_ID_NX2_57840_MF      CHIP_NUM_57840_MF
197 #endif
198 #ifndef PCI_DEVICE_ID_NX2_57840_VF
199 #define PCI_DEVICE_ID_NX2_57840_VF      CHIP_NUM_57840_VF
200 #endif
201 #ifndef PCI_DEVICE_ID_NX2_57811
202 #define PCI_DEVICE_ID_NX2_57811         CHIP_NUM_57811
203 #endif
204 #ifndef PCI_DEVICE_ID_NX2_57811_MF
205 #define PCI_DEVICE_ID_NX2_57811_MF      CHIP_NUM_57811_MF
206 #endif
207 #ifndef PCI_DEVICE_ID_NX2_57811_VF
208 #define PCI_DEVICE_ID_NX2_57811_VF      CHIP_NUM_57811_VF
209 #endif
210
211 static const struct pci_device_id bnx2x_pci_tbl[] = {
212         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57710), BCM57710 },
213         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711), BCM57711 },
214         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711E), BCM57711E },
215         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712), BCM57712 },
216         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712_MF), BCM57712_MF },
217         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712_VF), BCM57712_VF },
218         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800), BCM57800 },
219         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800_MF), BCM57800_MF },
220         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800_VF), BCM57800_VF },
221         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810), BCM57810 },
222         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810_MF), BCM57810_MF },
223         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_O), BCM57840_O },
224         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_4_10), BCM57840_4_10 },
225         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_2_20), BCM57840_2_20 },
226         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810_VF), BCM57810_VF },
227         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_MFO), BCM57840_MFO },
228         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_MF), BCM57840_MF },
229         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_VF), BCM57840_VF },
230         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57811), BCM57811 },
231         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57811_MF), BCM57811_MF },
232         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57811_VF), BCM57811_VF },
233         { 0 }
234 };
235
236 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
237
238 /* Global resources for unloading a previously loaded device */
239 #define BNX2X_PREV_WAIT_NEEDED 1
240 static DEFINE_SEMAPHORE(bnx2x_prev_sem);
241 static LINUX_LIST_HEAD(bnx2x_prev_list);
242
243 /* Forward declaration */
244 static struct cnic_eth_dev *bnx2x_cnic_probe(struct net_device *dev);
245 static u32 bnx2x_rx_ustorm_prods_offset(struct bnx2x_fastpath *fp);
246 static int bnx2x_set_storm_rx_mode(struct bnx2x *bp);
247
248 /****************************************************************************
249 * General service functions
250 ****************************************************************************/
251
252 static int bnx2x_hwtstamp_ioctl(struct bnx2x *bp, struct ifreq *ifr);
253
254 static void __storm_memset_dma_mapping(struct bnx2x *bp,
255                                        u32 addr, dma_addr_t mapping)
256 {
257         REG_WR(bp,  addr, U64_LO(mapping));
258         REG_WR(bp,  addr + 4, U64_HI(mapping));
259 }
260
261 static void storm_memset_spq_addr(struct bnx2x *bp,
262                                   dma_addr_t mapping, u16 abs_fid)
263 {
264         u32 addr = XSEM_REG_FAST_MEMORY +
265                         XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid);
266
267         __storm_memset_dma_mapping(bp, addr, mapping);
268 }
269
270 static void storm_memset_vf_to_pf(struct bnx2x *bp, u16 abs_fid,
271                                   u16 pf_id)
272 {
273         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid),
274                 pf_id);
275         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid),
276                 pf_id);
277         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid),
278                 pf_id);
279         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid),
280                 pf_id);
281 }
282
283 static void storm_memset_func_en(struct bnx2x *bp, u16 abs_fid,
284                                  u8 enable)
285 {
286         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid),
287                 enable);
288         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid),
289                 enable);
290         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid),
291                 enable);
292         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid),
293                 enable);
294 }
295
296 static void storm_memset_eq_data(struct bnx2x *bp,
297                                  struct event_ring_data *eq_data,
298                                 u16 pfid)
299 {
300         size_t size = sizeof(struct event_ring_data);
301
302         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_DATA_OFFSET(pfid);
303
304         __storm_memset_struct(bp, addr, size, (u32 *)eq_data);
305 }
306
307 static void storm_memset_eq_prod(struct bnx2x *bp, u16 eq_prod,
308                                  u16 pfid)
309 {
310         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_PROD_OFFSET(pfid);
311         REG_WR16(bp, addr, eq_prod);
312 }
313
314 /* used only at init
315  * locking is done by mcp
316  */
317 static void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
318 {
319         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
320         pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
321         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
322                                PCICFG_VENDOR_ID_OFFSET);
323 }
324
325 static u32 bnx2x_reg_rd_ind(struct bnx2x *bp, u32 addr)
326 {
327         u32 val;
328
329         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
330         pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
331         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
332                                PCICFG_VENDOR_ID_OFFSET);
333
334         return val;
335 }
336
337 #define DMAE_DP_SRC_GRC         "grc src_addr [%08x]"
338 #define DMAE_DP_SRC_PCI         "pci src_addr [%x:%08x]"
339 #define DMAE_DP_DST_GRC         "grc dst_addr [%08x]"
340 #define DMAE_DP_DST_PCI         "pci dst_addr [%x:%08x]"
341 #define DMAE_DP_DST_NONE        "dst_addr [none]"
342
343 static void bnx2x_dp_dmae(struct bnx2x *bp,
344                           struct dmae_command *dmae, int msglvl)
345 {
346         u32 src_type = dmae->opcode & DMAE_COMMAND_SRC;
347         int i;
348
349         switch (dmae->opcode & DMAE_COMMAND_DST) {
350         case DMAE_CMD_DST_PCI:
351                 if (src_type == DMAE_CMD_SRC_PCI)
352                         DP(msglvl, "DMAE: opcode 0x%08x\n"
353                            "src [%x:%08x], len [%d*4], dst [%x:%08x]\n"
354                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
355                            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
356                            dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
357                            dmae->comp_addr_hi, dmae->comp_addr_lo,
358                            dmae->comp_val);
359                 else
360                         DP(msglvl, "DMAE: opcode 0x%08x\n"
361                            "src [%08x], len [%d*4], dst [%x:%08x]\n"
362                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
363                            dmae->opcode, dmae->src_addr_lo >> 2,
364                            dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
365                            dmae->comp_addr_hi, dmae->comp_addr_lo,
366                            dmae->comp_val);
367                 break;
368         case DMAE_CMD_DST_GRC:
369                 if (src_type == DMAE_CMD_SRC_PCI)
370                         DP(msglvl, "DMAE: opcode 0x%08x\n"
371                            "src [%x:%08x], len [%d*4], dst_addr [%08x]\n"
372                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
373                            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
374                            dmae->len, dmae->dst_addr_lo >> 2,
375                            dmae->comp_addr_hi, dmae->comp_addr_lo,
376                            dmae->comp_val);
377                 else
378                         DP(msglvl, "DMAE: opcode 0x%08x\n"
379                            "src [%08x], len [%d*4], dst [%08x]\n"
380                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
381                            dmae->opcode, dmae->src_addr_lo >> 2,
382                            dmae->len, dmae->dst_addr_lo >> 2,
383                            dmae->comp_addr_hi, dmae->comp_addr_lo,
384                            dmae->comp_val);
385                 break;
386         default:
387                 if (src_type == DMAE_CMD_SRC_PCI)
388                         DP(msglvl, "DMAE: opcode 0x%08x\n"
389                            "src_addr [%x:%08x]  len [%d * 4]  dst_addr [none]\n"
390                            "comp_addr [%x:%08x]  comp_val 0x%08x\n",
391                            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
392                            dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
393                            dmae->comp_val);
394                 else
395                         DP(msglvl, "DMAE: opcode 0x%08x\n"
396                            "src_addr [%08x]  len [%d * 4]  dst_addr [none]\n"
397                            "comp_addr [%x:%08x]  comp_val 0x%08x\n",
398                            dmae->opcode, dmae->src_addr_lo >> 2,
399                            dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
400                            dmae->comp_val);
401                 break;
402         }
403
404         for (i = 0; i < (sizeof(struct dmae_command)/4); i++)
405                 DP(msglvl, "DMAE RAW [%02d]: 0x%08x\n",
406                    i, *(((u32 *)dmae) + i));
407 }
408
409 /* copy command into DMAE command memory and set DMAE command go */
410 void bnx2x_post_dmae(struct bnx2x *bp, struct dmae_command *dmae, int idx)
411 {
412         u32 cmd_offset;
413         int i;
414
415         cmd_offset = (DMAE_REG_CMD_MEM + sizeof(struct dmae_command) * idx);
416         for (i = 0; i < (sizeof(struct dmae_command)/4); i++) {
417                 REG_WR(bp, cmd_offset + i*4, *(((u32 *)dmae) + i));
418         }
419         REG_WR(bp, dmae_reg_go_c[idx], 1);
420 }
421
422 u32 bnx2x_dmae_opcode_add_comp(u32 opcode, u8 comp_type)
423 {
424         return opcode | ((comp_type << DMAE_COMMAND_C_DST_SHIFT) |
425                            DMAE_CMD_C_ENABLE);
426 }
427
428 u32 bnx2x_dmae_opcode_clr_src_reset(u32 opcode)
429 {
430         return opcode & ~DMAE_CMD_SRC_RESET;
431 }
432
433 u32 bnx2x_dmae_opcode(struct bnx2x *bp, u8 src_type, u8 dst_type,
434                              bool with_comp, u8 comp_type)
435 {
436         u32 opcode = 0;
437
438         opcode |= ((src_type << DMAE_COMMAND_SRC_SHIFT) |
439                    (dst_type << DMAE_COMMAND_DST_SHIFT));
440
441         opcode |= (DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET);
442
443         opcode |= (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0);
444         opcode |= ((BP_VN(bp) << DMAE_CMD_E1HVN_SHIFT) |
445                    (BP_VN(bp) << DMAE_COMMAND_DST_VN_SHIFT));
446         opcode |= (DMAE_COM_SET_ERR << DMAE_COMMAND_ERR_POLICY_SHIFT);
447
448 #ifdef __BIG_ENDIAN
449         opcode |= DMAE_CMD_ENDIANITY_B_DW_SWAP;
450 #else
451         opcode |= DMAE_CMD_ENDIANITY_DW_SWAP;
452 #endif
453         if (with_comp)
454                 opcode = bnx2x_dmae_opcode_add_comp(opcode, comp_type);
455         return opcode;
456 }
457
458 void bnx2x_prep_dmae_with_comp(struct bnx2x *bp,
459                                       struct dmae_command *dmae,
460                                       u8 src_type, u8 dst_type)
461 {
462         memset(dmae, 0, sizeof(struct dmae_command));
463
464         /* set the opcode */
465         dmae->opcode = bnx2x_dmae_opcode(bp, src_type, dst_type,
466                                          true, DMAE_COMP_PCI);
467
468         /* fill in the completion parameters */
469         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
470         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
471         dmae->comp_val = DMAE_COMP_VAL;
472 }
473
474 /* issue a dmae command over the init-channel and wait for completion */
475 int bnx2x_issue_dmae_with_comp(struct bnx2x *bp, struct dmae_command *dmae,
476                                u32 *comp)
477 {
478         int cnt = CHIP_REV_IS_SLOW(bp) ? (400000) : 4000;
479         int rc = 0;
480
481         bnx2x_dp_dmae(bp, dmae, BNX2X_MSG_DMAE);
482
483         /* Lock the dmae channel. Disable BHs to prevent a dead-lock
484          * as long as this code is called both from syscall context and
485          * from ndo_set_rx_mode() flow that may be called from BH.
486          */
487
488         spin_lock_bh(&bp->dmae_lock);
489
490         /* reset completion */
491         *comp = 0;
492
493         /* post the command on the channel used for initializations */
494         bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
495
496         /* wait for completion */
497         udelay(5);
498         while ((*comp & ~DMAE_PCI_ERR_FLAG) != DMAE_COMP_VAL) {
499
500                 if (!cnt ||
501                     (bp->recovery_state != BNX2X_RECOVERY_DONE &&
502                      bp->recovery_state != BNX2X_RECOVERY_NIC_LOADING)) {
503                         BNX2X_ERR("DMAE timeout!\n");
504                         rc = DMAE_TIMEOUT;
505                         goto unlock;
506                 }
507                 cnt--;
508                 udelay(50);
509         }
510         if (*comp & DMAE_PCI_ERR_FLAG) {
511                 BNX2X_ERR("DMAE PCI error!\n");
512                 rc = DMAE_PCI_ERROR;
513         }
514
515 unlock:
516
517         spin_unlock_bh(&bp->dmae_lock);
518
519         return rc;
520 }
521
522 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr, u32 dst_addr,
523                       u32 len32)
524 {
525         int rc;
526         struct dmae_command dmae;
527
528         if (!bp->dmae_ready) {
529                 u32 *data = bnx2x_sp(bp, wb_data[0]);
530
531                 if (CHIP_IS_E1(bp))
532                         bnx2x_init_ind_wr(bp, dst_addr, data, len32);
533                 else
534                         bnx2x_init_str_wr(bp, dst_addr, data, len32);
535                 return;
536         }
537
538         /* set opcode and fixed command fields */
539         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_GRC);
540
541         /* fill in addresses and len */
542         dmae.src_addr_lo = U64_LO(dma_addr);
543         dmae.src_addr_hi = U64_HI(dma_addr);
544         dmae.dst_addr_lo = dst_addr >> 2;
545         dmae.dst_addr_hi = 0;
546         dmae.len = len32;
547
548         /* issue the command and wait for completion */
549         rc = bnx2x_issue_dmae_with_comp(bp, &dmae, bnx2x_sp(bp, wb_comp));
550         if (rc) {
551                 BNX2X_ERR("DMAE returned failure %d\n", rc);
552 #ifdef BNX2X_STOP_ON_ERROR
553                 bnx2x_panic();
554 #endif
555         }
556 }
557
558 void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32)
559 {
560         int rc;
561         struct dmae_command dmae;
562
563         if (!bp->dmae_ready) {
564                 u32 *data = bnx2x_sp(bp, wb_data[0]);
565                 int i;
566
567                 if (CHIP_IS_E1(bp))
568                         for (i = 0; i < len32; i++)
569                                 data[i] = bnx2x_reg_rd_ind(bp, src_addr + i*4);
570                 else
571                         for (i = 0; i < len32; i++)
572                                 data[i] = REG_RD(bp, src_addr + i*4);
573
574                 return;
575         }
576
577         /* set opcode and fixed command fields */
578         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_GRC, DMAE_DST_PCI);
579
580         /* fill in addresses and len */
581         dmae.src_addr_lo = src_addr >> 2;
582         dmae.src_addr_hi = 0;
583         dmae.dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_data));
584         dmae.dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_data));
585         dmae.len = len32;
586
587         /* issue the command and wait for completion */
588         rc = bnx2x_issue_dmae_with_comp(bp, &dmae, bnx2x_sp(bp, wb_comp));
589         if (rc) {
590                 BNX2X_ERR("DMAE returned failure %d\n", rc);
591 #ifdef BNX2X_STOP_ON_ERROR
592                 bnx2x_panic();
593 #endif
594         }
595 }
596
597 static void bnx2x_write_dmae_phys_len(struct bnx2x *bp, dma_addr_t phys_addr,
598                                       u32 addr, u32 len)
599 {
600         int dmae_wr_max = DMAE_LEN32_WR_MAX(bp);
601         int offset = 0;
602
603         while (len > dmae_wr_max) {
604                 bnx2x_write_dmae(bp, phys_addr + offset,
605                                  addr + offset, dmae_wr_max);
606                 offset += dmae_wr_max * 4;
607                 len -= dmae_wr_max;
608         }
609
610         bnx2x_write_dmae(bp, phys_addr + offset, addr + offset, len);
611 }
612
613 enum storms {
614            XSTORM,
615            TSTORM,
616            CSTORM,
617            USTORM,
618            MAX_STORMS
619 };
620
621 #define STORMS_NUM 4
622 #define REGS_IN_ENTRY 4
623
624 static inline int bnx2x_get_assert_list_entry(struct bnx2x *bp,
625                                               enum storms storm,
626                                               int entry)
627 {
628         switch (storm) {
629         case XSTORM:
630                 return XSTORM_ASSERT_LIST_OFFSET(entry);
631         case TSTORM:
632                 return TSTORM_ASSERT_LIST_OFFSET(entry);
633         case CSTORM:
634                 return CSTORM_ASSERT_LIST_OFFSET(entry);
635         case USTORM:
636                 return USTORM_ASSERT_LIST_OFFSET(entry);
637         case MAX_STORMS:
638         default:
639                 BNX2X_ERR("unknown storm\n");
640         }
641         return -EINVAL;
642 }
643
644 static int bnx2x_mc_assert(struct bnx2x *bp)
645 {
646         char last_idx;
647         int i, j, rc = 0;
648         enum storms storm;
649         u32 regs[REGS_IN_ENTRY];
650         u32 bar_storm_intmem[STORMS_NUM] = {
651                 BAR_XSTRORM_INTMEM,
652                 BAR_TSTRORM_INTMEM,
653                 BAR_CSTRORM_INTMEM,
654                 BAR_USTRORM_INTMEM
655         };
656         u32 storm_assert_list_index[STORMS_NUM] = {
657                 XSTORM_ASSERT_LIST_INDEX_OFFSET,
658                 TSTORM_ASSERT_LIST_INDEX_OFFSET,
659                 CSTORM_ASSERT_LIST_INDEX_OFFSET,
660                 USTORM_ASSERT_LIST_INDEX_OFFSET
661         };
662         char *storms_string[STORMS_NUM] = {
663                 "XSTORM",
664                 "TSTORM",
665                 "CSTORM",
666                 "USTORM"
667         };
668
669         for (storm = XSTORM; storm < MAX_STORMS; storm++) {
670                 last_idx = REG_RD8(bp, bar_storm_intmem[storm] +
671                                    storm_assert_list_index[storm]);
672                 if (last_idx)
673                         BNX2X_ERR("%s_ASSERT_LIST_INDEX 0x%x\n",
674                                   storms_string[storm], last_idx);
675
676                 /* print the asserts */
677                 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
678                         /* read a single assert entry */
679                         for (j = 0; j < REGS_IN_ENTRY; j++)
680                                 regs[j] = REG_RD(bp, bar_storm_intmem[storm] +
681                                           bnx2x_get_assert_list_entry(bp,
682                                                                       storm,
683                                                                       i) +
684                                           sizeof(u32) * j);
685
686                         /* log entry if it contains a valid assert */
687                         if (regs[0] != COMMON_ASM_INVALID_ASSERT_OPCODE) {
688                                 BNX2X_ERR("%s_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x\n",
689                                           storms_string[storm], i, regs[3],
690                                           regs[2], regs[1], regs[0]);
691                                 rc++;
692                         } else {
693                                 break;
694                         }
695                 }
696         }
697
698         BNX2X_ERR("Chip Revision: %s, FW Version: %d_%d_%d\n",
699                   CHIP_IS_E1(bp) ? "everest1" :
700                   CHIP_IS_E1H(bp) ? "everest1h" :
701                   CHIP_IS_E2(bp) ? "everest2" : "everest3",
702                   BCM_5710_FW_MAJOR_VERSION,
703                   BCM_5710_FW_MINOR_VERSION,
704                   BCM_5710_FW_REVISION_VERSION);
705
706         return rc;
707 }
708
709 #define MCPR_TRACE_BUFFER_SIZE  (0x800)
710 #define SCRATCH_BUFFER_SIZE(bp) \
711         (CHIP_IS_E1(bp) ? 0x10000 : (CHIP_IS_E1H(bp) ? 0x20000 : 0x28000))
712
713 void bnx2x_fw_dump_lvl(struct bnx2x *bp, const char *lvl)
714 {
715         u32 addr, val;
716         u32 mark, offset;
717         __be32 data[9];
718         int word;
719         u32 trace_shmem_base;
720         if (BP_NOMCP(bp)) {
721                 BNX2X_ERR("NO MCP - can not dump\n");
722                 return;
723         }
724         netdev_printk(lvl, bp->dev, "bc %d.%d.%d\n",
725                 (bp->common.bc_ver & 0xff0000) >> 16,
726                 (bp->common.bc_ver & 0xff00) >> 8,
727                 (bp->common.bc_ver & 0xff));
728
729         val = REG_RD(bp, MCP_REG_MCPR_CPU_PROGRAM_COUNTER);
730         if (val == REG_RD(bp, MCP_REG_MCPR_CPU_PROGRAM_COUNTER))
731                 BNX2X_ERR("%s" "MCP PC at 0x%x\n", lvl, val);
732
733         if (BP_PATH(bp) == 0)
734                 trace_shmem_base = bp->common.shmem_base;
735         else
736                 trace_shmem_base = SHMEM2_RD(bp, other_shmem_base_addr);
737
738         /* sanity */
739         if (trace_shmem_base < MCPR_SCRATCH_BASE(bp) + MCPR_TRACE_BUFFER_SIZE ||
740             trace_shmem_base >= MCPR_SCRATCH_BASE(bp) +
741                                 SCRATCH_BUFFER_SIZE(bp)) {
742                 BNX2X_ERR("Unable to dump trace buffer (mark %x)\n",
743                           trace_shmem_base);
744                 return;
745         }
746
747         addr = trace_shmem_base - MCPR_TRACE_BUFFER_SIZE;
748
749         /* validate TRCB signature */
750         mark = REG_RD(bp, addr);
751         if (mark != MFW_TRACE_SIGNATURE) {
752                 BNX2X_ERR("Trace buffer signature is missing.");
753                 return ;
754         }
755
756         /* read cyclic buffer pointer */
757         addr += 4;
758         mark = REG_RD(bp, addr);
759         mark = MCPR_SCRATCH_BASE(bp) + ((mark + 0x3) & ~0x3) - 0x08000000;
760         if (mark >= trace_shmem_base || mark < addr + 4) {
761                 BNX2X_ERR("Mark doesn't fall inside Trace Buffer\n");
762                 return;
763         }
764         printk("%s" "begin fw dump (mark 0x%x)\n", lvl, mark);
765
766         printk("%s", lvl);
767
768         /* dump buffer after the mark */
769         for (offset = mark; offset < trace_shmem_base; offset += 0x8*4) {
770                 for (word = 0; word < 8; word++)
771                         data[word] = htonl(REG_RD(bp, offset + 4*word));
772                 data[8] = 0x0;
773                 pr_cont("%s", (char *)data);
774         }
775
776         /* dump buffer before the mark */
777         for (offset = addr + 4; offset <= mark; offset += 0x8*4) {
778                 for (word = 0; word < 8; word++)
779                         data[word] = htonl(REG_RD(bp, offset + 4*word));
780                 data[8] = 0x0;
781                 pr_cont("%s", (char *)data);
782         }
783         printk("%s" "end of fw dump\n", lvl);
784 }
785
786 static void bnx2x_fw_dump(struct bnx2x *bp)
787 {
788         bnx2x_fw_dump_lvl(bp, KERN_ERR);
789 }
790
791 static void bnx2x_hc_int_disable(struct bnx2x *bp)
792 {
793         int port = BP_PORT(bp);
794         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
795         u32 val = REG_RD(bp, addr);
796
797         /* in E1 we must use only PCI configuration space to disable
798          * MSI/MSIX capability
799          * It's forbidden to disable IGU_PF_CONF_MSI_MSIX_EN in HC block
800          */
801         if (CHIP_IS_E1(bp)) {
802                 /* Since IGU_PF_CONF_MSI_MSIX_EN still always on
803                  * Use mask register to prevent from HC sending interrupts
804                  * after we exit the function
805                  */
806                 REG_WR(bp, HC_REG_INT_MASK + port*4, 0);
807
808                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
809                          HC_CONFIG_0_REG_INT_LINE_EN_0 |
810                          HC_CONFIG_0_REG_ATTN_BIT_EN_0);
811         } else
812                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
813                          HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
814                          HC_CONFIG_0_REG_INT_LINE_EN_0 |
815                          HC_CONFIG_0_REG_ATTN_BIT_EN_0);
816
817         DP(NETIF_MSG_IFDOWN,
818            "write %x to HC %d (addr 0x%x)\n",
819            val, port, addr);
820
821         /* flush all outstanding writes */
822         mmiowb();
823
824         REG_WR(bp, addr, val);
825         if (REG_RD(bp, addr) != val)
826                 BNX2X_ERR("BUG! Proper val not read from IGU!\n");
827 }
828
829 static void bnx2x_igu_int_disable(struct bnx2x *bp)
830 {
831         u32 val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
832
833         val &= ~(IGU_PF_CONF_MSI_MSIX_EN |
834                  IGU_PF_CONF_INT_LINE_EN |
835                  IGU_PF_CONF_ATTN_BIT_EN);
836
837         DP(NETIF_MSG_IFDOWN, "write %x to IGU\n", val);
838
839         /* flush all outstanding writes */
840         mmiowb();
841
842         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
843         if (REG_RD(bp, IGU_REG_PF_CONFIGURATION) != val)
844                 BNX2X_ERR("BUG! Proper val not read from IGU!\n");
845 }
846
847 static void bnx2x_int_disable(struct bnx2x *bp)
848 {
849         if (bp->common.int_block == INT_BLOCK_HC)
850                 bnx2x_hc_int_disable(bp);
851         else
852                 bnx2x_igu_int_disable(bp);
853 }
854
855 void bnx2x_panic_dump(struct bnx2x *bp, bool disable_int)
856 {
857         int i;
858         u16 j;
859         struct hc_sp_status_block_data sp_sb_data;
860         int func = BP_FUNC(bp);
861 #ifdef BNX2X_STOP_ON_ERROR
862         u16 start = 0, end = 0;
863         u8 cos;
864 #endif
865         if (IS_PF(bp) && disable_int)
866                 bnx2x_int_disable(bp);
867
868         bp->stats_state = STATS_STATE_DISABLED;
869         bp->eth_stats.unrecoverable_error++;
870         DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
871
872         BNX2X_ERR("begin crash dump -----------------\n");
873
874         /* Indices */
875         /* Common */
876         if (IS_PF(bp)) {
877                 struct host_sp_status_block *def_sb = bp->def_status_blk;
878                 int data_size, cstorm_offset;
879
880                 BNX2X_ERR("def_idx(0x%x)  def_att_idx(0x%x)  attn_state(0x%x)  spq_prod_idx(0x%x) next_stats_cnt(0x%x)\n",
881                           bp->def_idx, bp->def_att_idx, bp->attn_state,
882                           bp->spq_prod_idx, bp->stats_counter);
883                 BNX2X_ERR("DSB: attn bits(0x%x)  ack(0x%x)  id(0x%x)  idx(0x%x)\n",
884                           def_sb->atten_status_block.attn_bits,
885                           def_sb->atten_status_block.attn_bits_ack,
886                           def_sb->atten_status_block.status_block_id,
887                           def_sb->atten_status_block.attn_bits_index);
888                 BNX2X_ERR("     def (");
889                 for (i = 0; i < HC_SP_SB_MAX_INDICES; i++)
890                         pr_cont("0x%x%s",
891                                 def_sb->sp_sb.index_values[i],
892                                 (i == HC_SP_SB_MAX_INDICES - 1) ? ")  " : " ");
893
894                 data_size = sizeof(struct hc_sp_status_block_data) /
895                             sizeof(u32);
896                 cstorm_offset = CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func);
897                 for (i = 0; i < data_size; i++)
898                         *((u32 *)&sp_sb_data + i) =
899                                 REG_RD(bp, BAR_CSTRORM_INTMEM + cstorm_offset +
900                                            i * sizeof(u32));
901
902                 pr_cont("igu_sb_id(0x%x)  igu_seg_id(0x%x) pf_id(0x%x)  vnic_id(0x%x)  vf_id(0x%x)  vf_valid (0x%x) state(0x%x)\n",
903                         sp_sb_data.igu_sb_id,
904                         sp_sb_data.igu_seg_id,
905                         sp_sb_data.p_func.pf_id,
906                         sp_sb_data.p_func.vnic_id,
907                         sp_sb_data.p_func.vf_id,
908                         sp_sb_data.p_func.vf_valid,
909                         sp_sb_data.state);
910         }
911
912         for_each_eth_queue(bp, i) {
913                 struct bnx2x_fastpath *fp = &bp->fp[i];
914                 int loop;
915                 struct hc_status_block_data_e2 sb_data_e2;
916                 struct hc_status_block_data_e1x sb_data_e1x;
917                 struct hc_status_block_sm  *hc_sm_p =
918                         CHIP_IS_E1x(bp) ?
919                         sb_data_e1x.common.state_machine :
920                         sb_data_e2.common.state_machine;
921                 struct hc_index_data *hc_index_p =
922                         CHIP_IS_E1x(bp) ?
923                         sb_data_e1x.index_data :
924                         sb_data_e2.index_data;
925                 u8 data_size, cos;
926                 u32 *sb_data_p;
927                 struct bnx2x_fp_txdata txdata;
928
929                 if (!bp->fp)
930                         break;
931
932                 if (!fp->rx_cons_sb)
933                         continue;
934
935                 /* Rx */
936                 BNX2X_ERR("fp%d: rx_bd_prod(0x%x)  rx_bd_cons(0x%x)  rx_comp_prod(0x%x)  rx_comp_cons(0x%x)  *rx_cons_sb(0x%x)\n",
937                           i, fp->rx_bd_prod, fp->rx_bd_cons,
938                           fp->rx_comp_prod,
939                           fp->rx_comp_cons, le16_to_cpu(*fp->rx_cons_sb));
940                 BNX2X_ERR("     rx_sge_prod(0x%x)  last_max_sge(0x%x)  fp_hc_idx(0x%x)\n",
941                           fp->rx_sge_prod, fp->last_max_sge,
942                           le16_to_cpu(fp->fp_hc_idx));
943
944                 /* Tx */
945                 for_each_cos_in_tx_queue(fp, cos)
946                 {
947                         if (!fp->txdata_ptr[cos])
948                                 break;
949
950                         txdata = *fp->txdata_ptr[cos];
951
952                         if (!txdata.tx_cons_sb)
953                                 continue;
954
955                         BNX2X_ERR("fp%d: tx_pkt_prod(0x%x)  tx_pkt_cons(0x%x)  tx_bd_prod(0x%x)  tx_bd_cons(0x%x)  *tx_cons_sb(0x%x)\n",
956                                   i, txdata.tx_pkt_prod,
957                                   txdata.tx_pkt_cons, txdata.tx_bd_prod,
958                                   txdata.tx_bd_cons,
959                                   le16_to_cpu(*txdata.tx_cons_sb));
960                 }
961
962                 loop = CHIP_IS_E1x(bp) ?
963                         HC_SB_MAX_INDICES_E1X : HC_SB_MAX_INDICES_E2;
964
965                 /* host sb data */
966
967                 if (IS_FCOE_FP(fp))
968                         continue;
969
970                 BNX2X_ERR("     run indexes (");
971                 for (j = 0; j < HC_SB_MAX_SM; j++)
972                         pr_cont("0x%x%s",
973                                fp->sb_running_index[j],
974                                (j == HC_SB_MAX_SM - 1) ? ")" : " ");
975
976                 BNX2X_ERR("     indexes (");
977                 for (j = 0; j < loop; j++)
978                         pr_cont("0x%x%s",
979                                fp->sb_index_values[j],
980                                (j == loop - 1) ? ")" : " ");
981
982                 /* VF cannot access FW refelection for status block */
983                 if (IS_VF(bp))
984                         continue;
985
986                 /* fw sb data */
987                 data_size = CHIP_IS_E1x(bp) ?
988                         sizeof(struct hc_status_block_data_e1x) :
989                         sizeof(struct hc_status_block_data_e2);
990                 data_size /= sizeof(u32);
991                 sb_data_p = CHIP_IS_E1x(bp) ?
992                         (u32 *)&sb_data_e1x :
993                         (u32 *)&sb_data_e2;
994                 /* copy sb data in here */
995                 for (j = 0; j < data_size; j++)
996                         *(sb_data_p + j) = REG_RD(bp, BAR_CSTRORM_INTMEM +
997                                 CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id) +
998                                 j * sizeof(u32));
999
1000                 if (!CHIP_IS_E1x(bp)) {
1001                         pr_cont("pf_id(0x%x)  vf_id(0x%x)  vf_valid(0x%x) vnic_id(0x%x)  same_igu_sb_1b(0x%x) state(0x%x)\n",
1002                                 sb_data_e2.common.p_func.pf_id,
1003                                 sb_data_e2.common.p_func.vf_id,
1004                                 sb_data_e2.common.p_func.vf_valid,
1005                                 sb_data_e2.common.p_func.vnic_id,
1006                                 sb_data_e2.common.same_igu_sb_1b,
1007                                 sb_data_e2.common.state);
1008                 } else {
1009                         pr_cont("pf_id(0x%x)  vf_id(0x%x)  vf_valid(0x%x) vnic_id(0x%x)  same_igu_sb_1b(0x%x) state(0x%x)\n",
1010                                 sb_data_e1x.common.p_func.pf_id,
1011                                 sb_data_e1x.common.p_func.vf_id,
1012                                 sb_data_e1x.common.p_func.vf_valid,
1013                                 sb_data_e1x.common.p_func.vnic_id,
1014                                 sb_data_e1x.common.same_igu_sb_1b,
1015                                 sb_data_e1x.common.state);
1016                 }
1017
1018                 /* SB_SMs data */
1019                 for (j = 0; j < HC_SB_MAX_SM; j++) {
1020                         pr_cont("SM[%d] __flags (0x%x) igu_sb_id (0x%x)  igu_seg_id(0x%x) time_to_expire (0x%x) timer_value(0x%x)\n",
1021                                 j, hc_sm_p[j].__flags,
1022                                 hc_sm_p[j].igu_sb_id,
1023                                 hc_sm_p[j].igu_seg_id,
1024                                 hc_sm_p[j].time_to_expire,
1025                                 hc_sm_p[j].timer_value);
1026                 }
1027
1028                 /* Indices data */
1029                 for (j = 0; j < loop; j++) {
1030                         pr_cont("INDEX[%d] flags (0x%x) timeout (0x%x)\n", j,
1031                                hc_index_p[j].flags,
1032                                hc_index_p[j].timeout);
1033                 }
1034         }
1035
1036 #ifdef BNX2X_STOP_ON_ERROR
1037         if (IS_PF(bp)) {
1038                 /* event queue */
1039                 BNX2X_ERR("eq cons %x prod %x\n", bp->eq_cons, bp->eq_prod);
1040                 for (i = 0; i < NUM_EQ_DESC; i++) {
1041                         u32 *data = (u32 *)&bp->eq_ring[i].message.data;
1042
1043                         BNX2X_ERR("event queue [%d]: header: opcode %d, error %d\n",
1044                                   i, bp->eq_ring[i].message.opcode,
1045                                   bp->eq_ring[i].message.error);
1046                         BNX2X_ERR("data: %x %x %x\n",
1047                                   data[0], data[1], data[2]);
1048                 }
1049         }
1050
1051         /* Rings */
1052         /* Rx */
1053         for_each_valid_rx_queue(bp, i) {
1054                 struct bnx2x_fastpath *fp = &bp->fp[i];
1055
1056                 if (!bp->fp)
1057                         break;
1058
1059                 if (!fp->rx_cons_sb)
1060                         continue;
1061
1062                 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
1063                 end = RX_BD(le16_to_cpu(*fp->rx_cons_sb) + 503);
1064                 for (j = start; j != end; j = RX_BD(j + 1)) {
1065                         u32 *rx_bd = (u32 *)&fp->rx_desc_ring[j];
1066                         struct sw_rx_bd *sw_bd = &fp->rx_buf_ring[j];
1067
1068                         BNX2X_ERR("fp%d: rx_bd[%x]=[%x:%x]  sw_bd=[%p]\n",
1069                                   i, j, rx_bd[1], rx_bd[0], sw_bd->data);
1070                 }
1071
1072                 start = RX_SGE(fp->rx_sge_prod);
1073                 end = RX_SGE(fp->last_max_sge);
1074                 for (j = start; j != end; j = RX_SGE(j + 1)) {
1075                         u32 *rx_sge = (u32 *)&fp->rx_sge_ring[j];
1076                         struct sw_rx_page *sw_page = &fp->rx_page_ring[j];
1077
1078                         BNX2X_ERR("fp%d: rx_sge[%x]=[%x:%x]  sw_page=[%p]\n",
1079                                   i, j, rx_sge[1], rx_sge[0], sw_page->page);
1080                 }
1081
1082                 start = RCQ_BD(fp->rx_comp_cons - 10);
1083                 end = RCQ_BD(fp->rx_comp_cons + 503);
1084                 for (j = start; j != end; j = RCQ_BD(j + 1)) {
1085                         u32 *cqe = (u32 *)&fp->rx_comp_ring[j];
1086
1087                         BNX2X_ERR("fp%d: cqe[%x]=[%x:%x:%x:%x]\n",
1088                                   i, j, cqe[0], cqe[1], cqe[2], cqe[3]);
1089                 }
1090         }
1091
1092         /* Tx */
1093         for_each_valid_tx_queue(bp, i) {
1094                 struct bnx2x_fastpath *fp = &bp->fp[i];
1095
1096                 if (!bp->fp)
1097                         break;
1098
1099                 for_each_cos_in_tx_queue(fp, cos) {
1100                         struct bnx2x_fp_txdata *txdata = fp->txdata_ptr[cos];
1101
1102                         if (!fp->txdata_ptr[cos])
1103                                 break;
1104
1105                         if (!txdata->tx_cons_sb)
1106                                 continue;
1107
1108                         start = TX_BD(le16_to_cpu(*txdata->tx_cons_sb) - 10);
1109                         end = TX_BD(le16_to_cpu(*txdata->tx_cons_sb) + 245);
1110                         for (j = start; j != end; j = TX_BD(j + 1)) {
1111                                 struct sw_tx_bd *sw_bd =
1112                                         &txdata->tx_buf_ring[j];
1113
1114                                 BNX2X_ERR("fp%d: txdata %d, packet[%x]=[%p,%x]\n",
1115                                           i, cos, j, sw_bd->skb,
1116                                           sw_bd->first_bd);
1117                         }
1118
1119                         start = TX_BD(txdata->tx_bd_cons - 10);
1120                         end = TX_BD(txdata->tx_bd_cons + 254);
1121                         for (j = start; j != end; j = TX_BD(j + 1)) {
1122                                 u32 *tx_bd = (u32 *)&txdata->tx_desc_ring[j];
1123
1124                                 BNX2X_ERR("fp%d: txdata %d, tx_bd[%x]=[%x:%x:%x:%x]\n",
1125                                           i, cos, j, tx_bd[0], tx_bd[1],
1126                                           tx_bd[2], tx_bd[3]);
1127                         }
1128                 }
1129         }
1130 #endif
1131         if (IS_PF(bp)) {
1132                 bnx2x_fw_dump(bp);
1133                 bnx2x_mc_assert(bp);
1134         }
1135         BNX2X_ERR("end crash dump -----------------\n");
1136 }
1137
1138 /*
1139  * FLR Support for E2
1140  *
1141  * bnx2x_pf_flr_clnup() is called during nic_load in the per function HW
1142  * initialization.
1143  */
1144 #define FLR_WAIT_USEC           10000   /* 10 milliseconds */
1145 #define FLR_WAIT_INTERVAL       50      /* usec */
1146 #define FLR_POLL_CNT            (FLR_WAIT_USEC/FLR_WAIT_INTERVAL) /* 200 */
1147
1148 struct pbf_pN_buf_regs {
1149         int pN;
1150         u32 init_crd;
1151         u32 crd;
1152         u32 crd_freed;
1153 };
1154
1155 struct pbf_pN_cmd_regs {
1156         int pN;
1157         u32 lines_occup;
1158         u32 lines_freed;
1159 };
1160
1161 static void bnx2x_pbf_pN_buf_flushed(struct bnx2x *bp,
1162                                      struct pbf_pN_buf_regs *regs,
1163                                      u32 poll_count)
1164 {
1165         u32 init_crd, crd, crd_start, crd_freed, crd_freed_start;
1166         u32 cur_cnt = poll_count;
1167
1168         crd_freed = crd_freed_start = REG_RD(bp, regs->crd_freed);
1169         crd = crd_start = REG_RD(bp, regs->crd);
1170         init_crd = REG_RD(bp, regs->init_crd);
1171
1172         DP(BNX2X_MSG_SP, "INIT CREDIT[%d] : %x\n", regs->pN, init_crd);
1173         DP(BNX2X_MSG_SP, "CREDIT[%d]      : s:%x\n", regs->pN, crd);
1174         DP(BNX2X_MSG_SP, "CREDIT_FREED[%d]: s:%x\n", regs->pN, crd_freed);
1175
1176         while ((crd != init_crd) && ((u32)SUB_S32(crd_freed, crd_freed_start) <
1177                (init_crd - crd_start))) {
1178                 if (cur_cnt--) {
1179                         udelay(FLR_WAIT_INTERVAL);
1180                         crd = REG_RD(bp, regs->crd);
1181                         crd_freed = REG_RD(bp, regs->crd_freed);
1182                 } else {
1183                         DP(BNX2X_MSG_SP, "PBF tx buffer[%d] timed out\n",
1184                            regs->pN);
1185                         DP(BNX2X_MSG_SP, "CREDIT[%d]      : c:%x\n",
1186                            regs->pN, crd);
1187                         DP(BNX2X_MSG_SP, "CREDIT_FREED[%d]: c:%x\n",
1188                            regs->pN, crd_freed);
1189                         break;
1190                 }
1191         }
1192         DP(BNX2X_MSG_SP, "Waited %d*%d usec for PBF tx buffer[%d]\n",
1193            poll_count-cur_cnt, FLR_WAIT_INTERVAL, regs->pN);
1194 }
1195
1196 static void bnx2x_pbf_pN_cmd_flushed(struct bnx2x *bp,
1197                                      struct pbf_pN_cmd_regs *regs,
1198                                      u32 poll_count)
1199 {
1200         u32 occup, to_free, freed, freed_start;
1201         u32 cur_cnt = poll_count;
1202
1203         occup = to_free = REG_RD(bp, regs->lines_occup);
1204         freed = freed_start = REG_RD(bp, regs->lines_freed);
1205
1206         DP(BNX2X_MSG_SP, "OCCUPANCY[%d]   : s:%x\n", regs->pN, occup);
1207         DP(BNX2X_MSG_SP, "LINES_FREED[%d] : s:%x\n", regs->pN, freed);
1208
1209         while (occup && ((u32)SUB_S32(freed, freed_start) < to_free)) {
1210                 if (cur_cnt--) {
1211                         udelay(FLR_WAIT_INTERVAL);
1212                         occup = REG_RD(bp, regs->lines_occup);
1213                         freed = REG_RD(bp, regs->lines_freed);
1214                 } else {
1215                         DP(BNX2X_MSG_SP, "PBF cmd queue[%d] timed out\n",
1216                            regs->pN);
1217                         DP(BNX2X_MSG_SP, "OCCUPANCY[%d]   : s:%x\n",
1218                            regs->pN, occup);
1219                         DP(BNX2X_MSG_SP, "LINES_FREED[%d] : s:%x\n",
1220                            regs->pN, freed);
1221                         break;
1222                 }
1223         }
1224         DP(BNX2X_MSG_SP, "Waited %d*%d usec for PBF cmd queue[%d]\n",
1225            poll_count-cur_cnt, FLR_WAIT_INTERVAL, regs->pN);
1226 }
1227
1228 static u32 bnx2x_flr_clnup_reg_poll(struct bnx2x *bp, u32 reg,
1229                                     u32 expected, u32 poll_count)
1230 {
1231         u32 cur_cnt = poll_count;
1232         u32 val;
1233
1234         while ((val = REG_RD(bp, reg)) != expected && cur_cnt--)
1235                 udelay(FLR_WAIT_INTERVAL);
1236
1237         return val;
1238 }
1239
1240 int bnx2x_flr_clnup_poll_hw_counter(struct bnx2x *bp, u32 reg,
1241                                     char *msg, u32 poll_cnt)
1242 {
1243         u32 val = bnx2x_flr_clnup_reg_poll(bp, reg, 0, poll_cnt);
1244         if (val != 0) {
1245                 BNX2X_ERR("%s usage count=%d\n", msg, val);
1246                 return 1;
1247         }
1248         return 0;
1249 }
1250
1251 /* Common routines with VF FLR cleanup */
1252 u32 bnx2x_flr_clnup_poll_count(struct bnx2x *bp)
1253 {
1254         /* adjust polling timeout */
1255         if (CHIP_REV_IS_EMUL(bp))
1256                 return FLR_POLL_CNT * 2000;
1257
1258         if (CHIP_REV_IS_FPGA(bp))
1259                 return FLR_POLL_CNT * 120;
1260
1261         return FLR_POLL_CNT;
1262 }
1263
1264 void bnx2x_tx_hw_flushed(struct bnx2x *bp, u32 poll_count)
1265 {
1266         struct pbf_pN_cmd_regs cmd_regs[] = {
1267                 {0, (CHIP_IS_E3B0(bp)) ?
1268                         PBF_REG_TQ_OCCUPANCY_Q0 :
1269                         PBF_REG_P0_TQ_OCCUPANCY,
1270                     (CHIP_IS_E3B0(bp)) ?
1271                         PBF_REG_TQ_LINES_FREED_CNT_Q0 :
1272                         PBF_REG_P0_TQ_LINES_FREED_CNT},
1273                 {1, (CHIP_IS_E3B0(bp)) ?
1274                         PBF_REG_TQ_OCCUPANCY_Q1 :
1275                         PBF_REG_P1_TQ_OCCUPANCY,
1276                     (CHIP_IS_E3B0(bp)) ?
1277                         PBF_REG_TQ_LINES_FREED_CNT_Q1 :
1278                         PBF_REG_P1_TQ_LINES_FREED_CNT},
1279                 {4, (CHIP_IS_E3B0(bp)) ?
1280                         PBF_REG_TQ_OCCUPANCY_LB_Q :
1281                         PBF_REG_P4_TQ_OCCUPANCY,
1282                     (CHIP_IS_E3B0(bp)) ?
1283                         PBF_REG_TQ_LINES_FREED_CNT_LB_Q :
1284                         PBF_REG_P4_TQ_LINES_FREED_CNT}
1285         };
1286
1287         struct pbf_pN_buf_regs buf_regs[] = {
1288                 {0, (CHIP_IS_E3B0(bp)) ?
1289                         PBF_REG_INIT_CRD_Q0 :
1290                         PBF_REG_P0_INIT_CRD ,
1291                     (CHIP_IS_E3B0(bp)) ?
1292                         PBF_REG_CREDIT_Q0 :
1293                         PBF_REG_P0_CREDIT,
1294                     (CHIP_IS_E3B0(bp)) ?
1295                         PBF_REG_INTERNAL_CRD_FREED_CNT_Q0 :
1296                         PBF_REG_P0_INTERNAL_CRD_FREED_CNT},
1297                 {1, (CHIP_IS_E3B0(bp)) ?
1298                         PBF_REG_INIT_CRD_Q1 :
1299                         PBF_REG_P1_INIT_CRD,
1300                     (CHIP_IS_E3B0(bp)) ?
1301                         PBF_REG_CREDIT_Q1 :
1302                         PBF_REG_P1_CREDIT,
1303                     (CHIP_IS_E3B0(bp)) ?
1304                         PBF_REG_INTERNAL_CRD_FREED_CNT_Q1 :
1305                         PBF_REG_P1_INTERNAL_CRD_FREED_CNT},
1306                 {4, (CHIP_IS_E3B0(bp)) ?
1307                         PBF_REG_INIT_CRD_LB_Q :
1308                         PBF_REG_P4_INIT_CRD,
1309                     (CHIP_IS_E3B0(bp)) ?
1310                         PBF_REG_CREDIT_LB_Q :
1311                         PBF_REG_P4_CREDIT,
1312                     (CHIP_IS_E3B0(bp)) ?
1313                         PBF_REG_INTERNAL_CRD_FREED_CNT_LB_Q :
1314                         PBF_REG_P4_INTERNAL_CRD_FREED_CNT},
1315         };
1316
1317         int i;
1318
1319         /* Verify the command queues are flushed P0, P1, P4 */
1320         for (i = 0; i < ARRAY_SIZE(cmd_regs); i++)
1321                 bnx2x_pbf_pN_cmd_flushed(bp, &cmd_regs[i], poll_count);
1322
1323         /* Verify the transmission buffers are flushed P0, P1, P4 */
1324         for (i = 0; i < ARRAY_SIZE(buf_regs); i++)
1325                 bnx2x_pbf_pN_buf_flushed(bp, &buf_regs[i], poll_count);
1326 }
1327
1328 #define OP_GEN_PARAM(param) \
1329         (((param) << SDM_OP_GEN_COMP_PARAM_SHIFT) & SDM_OP_GEN_COMP_PARAM)
1330
1331 #define OP_GEN_TYPE(type) \
1332         (((type) << SDM_OP_GEN_COMP_TYPE_SHIFT) & SDM_OP_GEN_COMP_TYPE)
1333
1334 #define OP_GEN_AGG_VECT(index) \
1335         (((index) << SDM_OP_GEN_AGG_VECT_IDX_SHIFT) & SDM_OP_GEN_AGG_VECT_IDX)
1336
1337 int bnx2x_send_final_clnup(struct bnx2x *bp, u8 clnup_func, u32 poll_cnt)
1338 {
1339         u32 op_gen_command = 0;
1340         u32 comp_addr = BAR_CSTRORM_INTMEM +
1341                         CSTORM_FINAL_CLEANUP_COMPLETE_OFFSET(clnup_func);
1342         int ret = 0;
1343
1344         if (REG_RD(bp, comp_addr)) {
1345                 BNX2X_ERR("Cleanup complete was not 0 before sending\n");
1346                 return 1;
1347         }
1348
1349         op_gen_command |= OP_GEN_PARAM(XSTORM_AGG_INT_FINAL_CLEANUP_INDEX);
1350         op_gen_command |= OP_GEN_TYPE(XSTORM_AGG_INT_FINAL_CLEANUP_COMP_TYPE);
1351         op_gen_command |= OP_GEN_AGG_VECT(clnup_func);
1352         op_gen_command |= 1 << SDM_OP_GEN_AGG_VECT_IDX_VALID_SHIFT;
1353
1354         DP(BNX2X_MSG_SP, "sending FW Final cleanup\n");
1355         REG_WR(bp, XSDM_REG_OPERATION_GEN, op_gen_command);
1356
1357         if (bnx2x_flr_clnup_reg_poll(bp, comp_addr, 1, poll_cnt) != 1) {
1358                 BNX2X_ERR("FW final cleanup did not succeed\n");
1359                 DP(BNX2X_MSG_SP, "At timeout completion address contained %x\n",
1360                    (REG_RD(bp, comp_addr)));
1361                 bnx2x_panic();
1362                 return 1;
1363         }
1364         /* Zero completion for next FLR */
1365         REG_WR(bp, comp_addr, 0);
1366
1367         return ret;
1368 }
1369
1370 u8 bnx2x_is_pcie_pending(struct pci_dev *dev)
1371 {
1372         u16 status;
1373
1374         pcie_capability_read_word(dev, PCI_EXP_DEVSTA, &status);
1375         return status & PCI_EXP_DEVSTA_TRPND;
1376 }
1377
1378 /* PF FLR specific routines
1379 */
1380 static int bnx2x_poll_hw_usage_counters(struct bnx2x *bp, u32 poll_cnt)
1381 {
1382         /* wait for CFC PF usage-counter to zero (includes all the VFs) */
1383         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1384                         CFC_REG_NUM_LCIDS_INSIDE_PF,
1385                         "CFC PF usage counter timed out",
1386                         poll_cnt))
1387                 return 1;
1388
1389         /* Wait for DQ PF usage-counter to zero (until DQ cleanup) */
1390         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1391                         DORQ_REG_PF_USAGE_CNT,
1392                         "DQ PF usage counter timed out",
1393                         poll_cnt))
1394                 return 1;
1395
1396         /* Wait for QM PF usage-counter to zero (until DQ cleanup) */
1397         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1398                         QM_REG_PF_USG_CNT_0 + 4*BP_FUNC(bp),
1399                         "QM PF usage counter timed out",
1400                         poll_cnt))
1401                 return 1;
1402
1403         /* Wait for Timer PF usage-counters to zero (until DQ cleanup) */
1404         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1405                         TM_REG_LIN0_VNIC_UC + 4*BP_PORT(bp),
1406                         "Timers VNIC usage counter timed out",
1407                         poll_cnt))
1408                 return 1;
1409         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1410                         TM_REG_LIN0_NUM_SCANS + 4*BP_PORT(bp),
1411                         "Timers NUM_SCANS usage counter timed out",
1412                         poll_cnt))
1413                 return 1;
1414
1415         /* Wait DMAE PF usage counter to zero */
1416         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1417                         dmae_reg_go_c[INIT_DMAE_C(bp)],
1418                         "DMAE command register timed out",
1419                         poll_cnt))
1420                 return 1;
1421
1422         return 0;
1423 }
1424
1425 static void bnx2x_hw_enable_status(struct bnx2x *bp)
1426 {
1427         u32 val;
1428
1429         val = REG_RD(bp, CFC_REG_WEAK_ENABLE_PF);
1430         DP(BNX2X_MSG_SP, "CFC_REG_WEAK_ENABLE_PF is 0x%x\n", val);
1431
1432         val = REG_RD(bp, PBF_REG_DISABLE_PF);
1433         DP(BNX2X_MSG_SP, "PBF_REG_DISABLE_PF is 0x%x\n", val);
1434
1435         val = REG_RD(bp, IGU_REG_PCI_PF_MSI_EN);
1436         DP(BNX2X_MSG_SP, "IGU_REG_PCI_PF_MSI_EN is 0x%x\n", val);
1437
1438         val = REG_RD(bp, IGU_REG_PCI_PF_MSIX_EN);
1439         DP(BNX2X_MSG_SP, "IGU_REG_PCI_PF_MSIX_EN is 0x%x\n", val);
1440
1441         val = REG_RD(bp, IGU_REG_PCI_PF_MSIX_FUNC_MASK);
1442         DP(BNX2X_MSG_SP, "IGU_REG_PCI_PF_MSIX_FUNC_MASK is 0x%x\n", val);
1443
1444         val = REG_RD(bp, PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR);
1445         DP(BNX2X_MSG_SP, "PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR is 0x%x\n", val);
1446
1447         val = REG_RD(bp, PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR);
1448         DP(BNX2X_MSG_SP, "PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR is 0x%x\n", val);
1449
1450         val = REG_RD(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER);
1451         DP(BNX2X_MSG_SP, "PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER is 0x%x\n",
1452            val);
1453 }
1454
1455 static int bnx2x_pf_flr_clnup(struct bnx2x *bp)
1456 {
1457         u32 poll_cnt = bnx2x_flr_clnup_poll_count(bp);
1458
1459         DP(BNX2X_MSG_SP, "Cleanup after FLR PF[%d]\n", BP_ABS_FUNC(bp));
1460
1461         /* Re-enable PF target read access */
1462         REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_TARGET_READ, 1);
1463
1464         /* Poll HW usage counters */
1465         DP(BNX2X_MSG_SP, "Polling usage counters\n");
1466         if (bnx2x_poll_hw_usage_counters(bp, poll_cnt))
1467                 return -EBUSY;
1468
1469         /* Zero the igu 'trailing edge' and 'leading edge' */
1470
1471         /* Send the FW cleanup command */
1472         if (bnx2x_send_final_clnup(bp, (u8)BP_FUNC(bp), poll_cnt))
1473                 return -EBUSY;
1474
1475         /* ATC cleanup */
1476
1477         /* Verify TX hw is flushed */
1478         bnx2x_tx_hw_flushed(bp, poll_cnt);
1479
1480         /* Wait 100ms (not adjusted according to platform) */
1481         msleep(100);
1482
1483         /* Verify no pending pci transactions */
1484         if (bnx2x_is_pcie_pending(bp->pdev))
1485                 BNX2X_ERR("PCIE Transactions still pending\n");
1486
1487         /* Debug */
1488         bnx2x_hw_enable_status(bp);
1489
1490         /*
1491          * Master enable - Due to WB DMAE writes performed before this
1492          * register is re-initialized as part of the regular function init
1493          */
1494         REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
1495
1496         return 0;
1497 }
1498
1499 static void bnx2x_hc_int_enable(struct bnx2x *bp)
1500 {
1501         int port = BP_PORT(bp);
1502         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
1503         u32 val = REG_RD(bp, addr);
1504         bool msix = (bp->flags & USING_MSIX_FLAG) ? true : false;
1505         bool single_msix = (bp->flags & USING_SINGLE_MSIX_FLAG) ? true : false;
1506         bool msi = (bp->flags & USING_MSI_FLAG) ? true : false;
1507
1508         if (msix) {
1509                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1510                          HC_CONFIG_0_REG_INT_LINE_EN_0);
1511                 val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1512                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1513                 if (single_msix)
1514                         val |= HC_CONFIG_0_REG_SINGLE_ISR_EN_0;
1515         } else if (msi) {
1516                 val &= ~HC_CONFIG_0_REG_INT_LINE_EN_0;
1517                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1518                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1519                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1520         } else {
1521                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1522                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1523                         HC_CONFIG_0_REG_INT_LINE_EN_0 |
1524                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1525
1526                 if (!CHIP_IS_E1(bp)) {
1527                         DP(NETIF_MSG_IFUP,
1528                            "write %x to HC %d (addr 0x%x)\n", val, port, addr);
1529
1530                         REG_WR(bp, addr, val);
1531
1532                         val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
1533                 }
1534         }
1535
1536         if (CHIP_IS_E1(bp))
1537                 REG_WR(bp, HC_REG_INT_MASK + port*4, 0x1FFFF);
1538
1539         DP(NETIF_MSG_IFUP,
1540            "write %x to HC %d (addr 0x%x) mode %s\n", val, port, addr,
1541            (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1542
1543         REG_WR(bp, addr, val);
1544         /*
1545          * Ensure that HC_CONFIG is written before leading/trailing edge config
1546          */
1547         mmiowb();
1548         barrier();
1549
1550         if (!CHIP_IS_E1(bp)) {
1551                 /* init leading/trailing edge */
1552                 if (IS_MF(bp)) {
1553                         val = (0xee0f | (1 << (BP_VN(bp) + 4)));
1554                         if (bp->port.pmf)
1555                                 /* enable nig and gpio3 attention */
1556                                 val |= 0x1100;
1557                 } else
1558                         val = 0xffff;
1559
1560                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
1561                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
1562         }
1563
1564         /* Make sure that interrupts are indeed enabled from here on */
1565         mmiowb();
1566 }
1567
1568 static void bnx2x_igu_int_enable(struct bnx2x *bp)
1569 {
1570         u32 val;
1571         bool msix = (bp->flags & USING_MSIX_FLAG) ? true : false;
1572         bool single_msix = (bp->flags & USING_SINGLE_MSIX_FLAG) ? true : false;
1573         bool msi = (bp->flags & USING_MSI_FLAG) ? true : false;
1574
1575         val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1576
1577         if (msix) {
1578                 val &= ~(IGU_PF_CONF_INT_LINE_EN |
1579                          IGU_PF_CONF_SINGLE_ISR_EN);
1580                 val |= (IGU_PF_CONF_MSI_MSIX_EN |
1581                         IGU_PF_CONF_ATTN_BIT_EN);
1582
1583                 if (single_msix)
1584                         val |= IGU_PF_CONF_SINGLE_ISR_EN;
1585         } else if (msi) {
1586                 val &= ~IGU_PF_CONF_INT_LINE_EN;
1587                 val |= (IGU_PF_CONF_MSI_MSIX_EN |
1588                         IGU_PF_CONF_ATTN_BIT_EN |
1589                         IGU_PF_CONF_SINGLE_ISR_EN);
1590         } else {
1591                 val &= ~IGU_PF_CONF_MSI_MSIX_EN;
1592                 val |= (IGU_PF_CONF_INT_LINE_EN |
1593                         IGU_PF_CONF_ATTN_BIT_EN |
1594                         IGU_PF_CONF_SINGLE_ISR_EN);
1595         }
1596
1597         /* Clean previous status - need to configure igu prior to ack*/
1598         if ((!msix) || single_msix) {
1599                 REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1600                 bnx2x_ack_int(bp);
1601         }
1602
1603         val |= IGU_PF_CONF_FUNC_EN;
1604
1605         DP(NETIF_MSG_IFUP, "write 0x%x to IGU  mode %s\n",
1606            val, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1607
1608         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1609
1610         if (val & IGU_PF_CONF_INT_LINE_EN)
1611                 pci_intx(bp->pdev, true);
1612
1613         barrier();
1614
1615         /* init leading/trailing edge */
1616         if (IS_MF(bp)) {
1617                 val = (0xee0f | (1 << (BP_VN(bp) + 4)));
1618                 if (bp->port.pmf)
1619                         /* enable nig and gpio3 attention */
1620                         val |= 0x1100;
1621         } else
1622                 val = 0xffff;
1623
1624         REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
1625         REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
1626
1627         /* Make sure that interrupts are indeed enabled from here on */
1628         mmiowb();
1629 }
1630
1631 void bnx2x_int_enable(struct bnx2x *bp)
1632 {
1633         if (bp->common.int_block == INT_BLOCK_HC)
1634                 bnx2x_hc_int_enable(bp);
1635         else
1636                 bnx2x_igu_int_enable(bp);
1637 }
1638
1639 void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
1640 {
1641         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1642         int i, offset;
1643
1644         if (disable_hw)
1645                 /* prevent the HW from sending interrupts */
1646                 bnx2x_int_disable(bp);
1647
1648         /* make sure all ISRs are done */
1649         if (msix) {
1650                 synchronize_irq(bp->msix_table[0].vector);
1651                 offset = 1;
1652                 if (CNIC_SUPPORT(bp))
1653                         offset++;
1654                 for_each_eth_queue(bp, i)
1655                         synchronize_irq(bp->msix_table[offset++].vector);
1656         } else
1657                 synchronize_irq(bp->pdev->irq);
1658
1659         /* make sure sp_task is not running */
1660         cancel_delayed_work(&bp->sp_task);
1661         cancel_delayed_work(&bp->period_task);
1662         flush_workqueue(bnx2x_wq);
1663 }
1664
1665 /* fast path */
1666
1667 /*
1668  * General service functions
1669  */
1670
1671 /* Return true if succeeded to acquire the lock */
1672 static bool bnx2x_trylock_hw_lock(struct bnx2x *bp, u32 resource)
1673 {
1674         u32 lock_status;
1675         u32 resource_bit = (1 << resource);
1676         int func = BP_FUNC(bp);
1677         u32 hw_lock_control_reg;
1678
1679         DP(NETIF_MSG_HW | NETIF_MSG_IFUP,
1680            "Trying to take a lock on resource %d\n", resource);
1681
1682         /* Validating that the resource is within range */
1683         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1684                 DP(NETIF_MSG_HW | NETIF_MSG_IFUP,
1685                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1686                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1687                 return false;
1688         }
1689
1690         if (func <= 5)
1691                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1692         else
1693                 hw_lock_control_reg =
1694                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1695
1696         /* Try to acquire the lock */
1697         REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1698         lock_status = REG_RD(bp, hw_lock_control_reg);
1699         if (lock_status & resource_bit)
1700                 return true;
1701
1702         DP(NETIF_MSG_HW | NETIF_MSG_IFUP,
1703            "Failed to get a lock on resource %d\n", resource);
1704         return false;
1705 }
1706
1707 /**
1708  * bnx2x_get_leader_lock_resource - get the recovery leader resource id
1709  *
1710  * @bp: driver handle
1711  *
1712  * Returns the recovery leader resource id according to the engine this function
1713  * belongs to. Currently only only 2 engines is supported.
1714  */
1715 static int bnx2x_get_leader_lock_resource(struct bnx2x *bp)
1716 {
1717         if (BP_PATH(bp))
1718                 return HW_LOCK_RESOURCE_RECOVERY_LEADER_1;
1719         else
1720                 return HW_LOCK_RESOURCE_RECOVERY_LEADER_0;
1721 }
1722
1723 /**
1724  * bnx2x_trylock_leader_lock- try to acquire a leader lock.
1725  *
1726  * @bp: driver handle
1727  *
1728  * Tries to acquire a leader lock for current engine.
1729  */
1730 static bool bnx2x_trylock_leader_lock(struct bnx2x *bp)
1731 {
1732         return bnx2x_trylock_hw_lock(bp, bnx2x_get_leader_lock_resource(bp));
1733 }
1734
1735 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid, u8 err);
1736
1737 /* schedule the sp task and mark that interrupt occurred (runs from ISR) */
1738 static int bnx2x_schedule_sp_task(struct bnx2x *bp)
1739 {
1740         /* Set the interrupt occurred bit for the sp-task to recognize it
1741          * must ack the interrupt and transition according to the IGU
1742          * state machine.
1743          */
1744         atomic_set(&bp->interrupt_occurred, 1);
1745
1746         /* The sp_task must execute only after this bit
1747          * is set, otherwise we will get out of sync and miss all
1748          * further interrupts. Hence, the barrier.
1749          */
1750         smp_wmb();
1751
1752         /* schedule sp_task to workqueue */
1753         return queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
1754 }
1755
1756 void bnx2x_sp_event(struct bnx2x_fastpath *fp, union eth_rx_cqe *rr_cqe)
1757 {
1758         struct bnx2x *bp = fp->bp;
1759         int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1760         int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1761         enum bnx2x_queue_cmd drv_cmd = BNX2X_Q_CMD_MAX;
1762         struct bnx2x_queue_sp_obj *q_obj = &bnx2x_sp_obj(bp, fp).q_obj;
1763
1764         DP(BNX2X_MSG_SP,
1765            "fp %d  cid %d  got ramrod #%d  state is %x  type is %d\n",
1766            fp->index, cid, command, bp->state,
1767            rr_cqe->ramrod_cqe.ramrod_type);
1768
1769         /* If cid is within VF range, replace the slowpath object with the
1770          * one corresponding to this VF
1771          */
1772         if (cid >= BNX2X_FIRST_VF_CID  &&
1773             cid < BNX2X_FIRST_VF_CID + BNX2X_VF_CIDS)
1774                 bnx2x_iov_set_queue_sp_obj(bp, cid, &q_obj);
1775
1776         switch (command) {
1777         case (RAMROD_CMD_ID_ETH_CLIENT_UPDATE):
1778                 DP(BNX2X_MSG_SP, "got UPDATE ramrod. CID %d\n", cid);
1779                 drv_cmd = BNX2X_Q_CMD_UPDATE;
1780                 break;
1781
1782         case (RAMROD_CMD_ID_ETH_CLIENT_SETUP):
1783                 DP(BNX2X_MSG_SP, "got MULTI[%d] setup ramrod\n", cid);
1784                 drv_cmd = BNX2X_Q_CMD_SETUP;
1785                 break;
1786
1787         case (RAMROD_CMD_ID_ETH_TX_QUEUE_SETUP):
1788                 DP(BNX2X_MSG_SP, "got MULTI[%d] tx-only setup ramrod\n", cid);
1789                 drv_cmd = BNX2X_Q_CMD_SETUP_TX_ONLY;
1790                 break;
1791
1792         case (RAMROD_CMD_ID_ETH_HALT):
1793                 DP(BNX2X_MSG_SP, "got MULTI[%d] halt ramrod\n", cid);
1794                 drv_cmd = BNX2X_Q_CMD_HALT;
1795                 break;
1796
1797         case (RAMROD_CMD_ID_ETH_TERMINATE):
1798                 DP(BNX2X_MSG_SP, "got MULTI[%d] terminate ramrod\n", cid);
1799                 drv_cmd = BNX2X_Q_CMD_TERMINATE;
1800                 break;
1801
1802         case (RAMROD_CMD_ID_ETH_EMPTY):
1803                 DP(BNX2X_MSG_SP, "got MULTI[%d] empty ramrod\n", cid);
1804                 drv_cmd = BNX2X_Q_CMD_EMPTY;
1805                 break;
1806
1807         case (RAMROD_CMD_ID_ETH_TPA_UPDATE):
1808                 DP(BNX2X_MSG_SP, "got tpa update ramrod CID=%d\n", cid);
1809                 drv_cmd = BNX2X_Q_CMD_UPDATE_TPA;
1810                 break;
1811
1812         default:
1813                 BNX2X_ERR("unexpected MC reply (%d) on fp[%d]\n",
1814                           command, fp->index);
1815                 return;
1816         }
1817
1818         if ((drv_cmd != BNX2X_Q_CMD_MAX) &&
1819             q_obj->complete_cmd(bp, q_obj, drv_cmd))
1820                 /* q_obj->complete_cmd() failure means that this was
1821                  * an unexpected completion.
1822                  *
1823                  * In this case we don't want to increase the bp->spq_left
1824                  * because apparently we haven't sent this command the first
1825                  * place.
1826                  */
1827 #ifdef BNX2X_STOP_ON_ERROR
1828                 bnx2x_panic();
1829 #else
1830                 return;
1831 #endif
1832
1833         smp_mb__before_atomic();
1834         atomic_inc(&bp->cq_spq_left);
1835         /* push the change in bp->spq_left and towards the memory */
1836         smp_mb__after_atomic();
1837
1838         DP(BNX2X_MSG_SP, "bp->cq_spq_left %x\n", atomic_read(&bp->cq_spq_left));
1839
1840         if ((drv_cmd == BNX2X_Q_CMD_UPDATE) && (IS_FCOE_FP(fp)) &&
1841             (!!test_bit(BNX2X_AFEX_FCOE_Q_UPDATE_PENDING, &bp->sp_state))) {
1842                 /* if Q update ramrod is completed for last Q in AFEX vif set
1843                  * flow, then ACK MCP at the end
1844                  *
1845                  * mark pending ACK to MCP bit.
1846                  * prevent case that both bits are cleared.
1847                  * At the end of load/unload driver checks that
1848                  * sp_state is cleared, and this order prevents
1849                  * races
1850                  */
1851                 smp_mb__before_atomic();
1852                 set_bit(BNX2X_AFEX_PENDING_VIFSET_MCP_ACK, &bp->sp_state);
1853                 wmb();
1854                 clear_bit(BNX2X_AFEX_FCOE_Q_UPDATE_PENDING, &bp->sp_state);
1855                 smp_mb__after_atomic();
1856
1857                 /* schedule the sp task as mcp ack is required */
1858                 bnx2x_schedule_sp_task(bp);
1859         }
1860
1861         return;
1862 }
1863
1864 irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
1865 {
1866         struct bnx2x *bp = netdev_priv(dev_instance);
1867         u16 status = bnx2x_ack_int(bp);
1868         u16 mask;
1869         int i;
1870         u8 cos;
1871
1872         /* Return here if interrupt is shared and it's not for us */
1873         if (unlikely(status == 0)) {
1874                 DP(NETIF_MSG_INTR, "not our interrupt!\n");
1875                 return IRQ_NONE;
1876         }
1877         DP(NETIF_MSG_INTR, "got an interrupt  status 0x%x\n", status);
1878
1879 #ifdef BNX2X_STOP_ON_ERROR
1880         if (unlikely(bp->panic))
1881                 return IRQ_HANDLED;
1882 #endif
1883
1884         for_each_eth_queue(bp, i) {
1885                 struct bnx2x_fastpath *fp = &bp->fp[i];
1886
1887                 mask = 0x2 << (fp->index + CNIC_SUPPORT(bp));
1888                 if (status & mask) {
1889                         /* Handle Rx or Tx according to SB id */
1890                         for_each_cos_in_tx_queue(fp, cos)
1891                                 prefetch(fp->txdata_ptr[cos]->tx_cons_sb);
1892                         prefetch(&fp->sb_running_index[SM_RX_ID]);
1893                         napi_schedule_irqoff(&bnx2x_fp(bp, fp->index, napi));
1894                         status &= ~mask;
1895                 }
1896         }
1897
1898         if (CNIC_SUPPORT(bp)) {
1899                 mask = 0x2;
1900                 if (status & (mask | 0x1)) {
1901                         struct cnic_ops *c_ops = NULL;
1902
1903                         rcu_read_lock();
1904                         c_ops = rcu_dereference(bp->cnic_ops);
1905                         if (c_ops && (bp->cnic_eth_dev.drv_state &
1906                                       CNIC_DRV_STATE_HANDLES_IRQ))
1907                                 c_ops->cnic_handler(bp->cnic_data, NULL);
1908                         rcu_read_unlock();
1909
1910                         status &= ~mask;
1911                 }
1912         }
1913
1914         if (unlikely(status & 0x1)) {
1915
1916                 /* schedule sp task to perform default status block work, ack
1917                  * attentions and enable interrupts.
1918                  */
1919                 bnx2x_schedule_sp_task(bp);
1920
1921                 status &= ~0x1;
1922                 if (!status)
1923                         return IRQ_HANDLED;
1924         }
1925
1926         if (unlikely(status))
1927                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
1928                    status);
1929
1930         return IRQ_HANDLED;
1931 }
1932
1933 /* Link */
1934
1935 /*
1936  * General service functions
1937  */
1938
1939 int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource)
1940 {
1941         u32 lock_status;
1942         u32 resource_bit = (1 << resource);
1943         int func = BP_FUNC(bp);
1944         u32 hw_lock_control_reg;
1945         int cnt;
1946
1947         /* Validating that the resource is within range */
1948         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1949                 BNX2X_ERR("resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1950                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1951                 return -EINVAL;
1952         }
1953
1954         if (func <= 5) {
1955                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1956         } else {
1957                 hw_lock_control_reg =
1958                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1959         }
1960
1961         /* Validating that the resource is not already taken */
1962         lock_status = REG_RD(bp, hw_lock_control_reg);
1963         if (lock_status & resource_bit) {
1964                 BNX2X_ERR("lock_status 0x%x  resource_bit 0x%x\n",
1965                    lock_status, resource_bit);
1966                 return -EEXIST;
1967         }
1968
1969         /* Try for 5 second every 5ms */
1970         for (cnt = 0; cnt < 1000; cnt++) {
1971                 /* Try to acquire the lock */
1972                 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1973                 lock_status = REG_RD(bp, hw_lock_control_reg);
1974                 if (lock_status & resource_bit)
1975                         return 0;
1976
1977                 usleep_range(5000, 10000);
1978         }
1979         BNX2X_ERR("Timeout\n");
1980         return -EAGAIN;
1981 }
1982
1983 int bnx2x_release_leader_lock(struct bnx2x *bp)
1984 {
1985         return bnx2x_release_hw_lock(bp, bnx2x_get_leader_lock_resource(bp));
1986 }
1987
1988 int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource)
1989 {
1990         u32 lock_status;
1991         u32 resource_bit = (1 << resource);
1992         int func = BP_FUNC(bp);
1993         u32 hw_lock_control_reg;
1994
1995         /* Validating that the resource is within range */
1996         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1997                 BNX2X_ERR("resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1998                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1999                 return -EINVAL;
2000         }
2001
2002         if (func <= 5) {
2003                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
2004         } else {
2005                 hw_lock_control_reg =
2006                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
2007         }
2008
2009         /* Validating that the resource is currently taken */
2010         lock_status = REG_RD(bp, hw_lock_control_reg);
2011         if (!(lock_status & resource_bit)) {
2012                 BNX2X_ERR("lock_status 0x%x resource_bit 0x%x. Unlock was called but lock wasn't taken!\n",
2013                           lock_status, resource_bit);
2014                 return -EFAULT;
2015         }
2016
2017         REG_WR(bp, hw_lock_control_reg, resource_bit);
2018         return 0;
2019 }
2020
2021 int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, u8 port)
2022 {
2023         /* The GPIO should be swapped if swap register is set and active */
2024         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
2025                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
2026         int gpio_shift = gpio_num +
2027                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
2028         u32 gpio_mask = (1 << gpio_shift);
2029         u32 gpio_reg;
2030         int value;
2031
2032         if (gpio_num > MISC_REGISTERS_GPIO_3) {
2033                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
2034                 return -EINVAL;
2035         }
2036
2037         /* read GPIO value */
2038         gpio_reg = REG_RD(bp, MISC_REG_GPIO);
2039
2040         /* get the requested pin value */
2041         if ((gpio_reg & gpio_mask) == gpio_mask)
2042                 value = 1;
2043         else
2044                 value = 0;
2045
2046         return value;
2047 }
2048
2049 int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
2050 {
2051         /* The GPIO should be swapped if swap register is set and active */
2052         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
2053                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
2054         int gpio_shift = gpio_num +
2055                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
2056         u32 gpio_mask = (1 << gpio_shift);
2057         u32 gpio_reg;
2058
2059         if (gpio_num > MISC_REGISTERS_GPIO_3) {
2060                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
2061                 return -EINVAL;
2062         }
2063
2064         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2065         /* read GPIO and mask except the float bits */
2066         gpio_reg = (REG_RD(bp, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
2067
2068         switch (mode) {
2069         case MISC_REGISTERS_GPIO_OUTPUT_LOW:
2070                 DP(NETIF_MSG_LINK,
2071                    "Set GPIO %d (shift %d) -> output low\n",
2072                    gpio_num, gpio_shift);
2073                 /* clear FLOAT and set CLR */
2074                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
2075                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
2076                 break;
2077
2078         case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
2079                 DP(NETIF_MSG_LINK,
2080                    "Set GPIO %d (shift %d) -> output high\n",
2081                    gpio_num, gpio_shift);
2082                 /* clear FLOAT and set SET */
2083                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
2084                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
2085                 break;
2086
2087         case MISC_REGISTERS_GPIO_INPUT_HI_Z:
2088                 DP(NETIF_MSG_LINK,
2089                    "Set GPIO %d (shift %d) -> input\n",
2090                    gpio_num, gpio_shift);
2091                 /* set FLOAT */
2092                 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
2093                 break;
2094
2095         default:
2096                 break;
2097         }
2098
2099         REG_WR(bp, MISC_REG_GPIO, gpio_reg);
2100         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2101
2102         return 0;
2103 }
2104
2105 int bnx2x_set_mult_gpio(struct bnx2x *bp, u8 pins, u32 mode)
2106 {
2107         u32 gpio_reg = 0;
2108         int rc = 0;
2109
2110         /* Any port swapping should be handled by caller. */
2111
2112         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2113         /* read GPIO and mask except the float bits */
2114         gpio_reg = REG_RD(bp, MISC_REG_GPIO);
2115         gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_FLOAT_POS);
2116         gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_CLR_POS);
2117         gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_SET_POS);
2118
2119         switch (mode) {
2120         case MISC_REGISTERS_GPIO_OUTPUT_LOW:
2121                 DP(NETIF_MSG_LINK, "Set GPIO 0x%x -> output low\n", pins);
2122                 /* set CLR */
2123                 gpio_reg |= (pins << MISC_REGISTERS_GPIO_CLR_POS);
2124                 break;
2125
2126         case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
2127                 DP(NETIF_MSG_LINK, "Set GPIO 0x%x -> output high\n", pins);
2128                 /* set SET */
2129                 gpio_reg |= (pins << MISC_REGISTERS_GPIO_SET_POS);
2130                 break;
2131
2132         case MISC_REGISTERS_GPIO_INPUT_HI_Z:
2133                 DP(NETIF_MSG_LINK, "Set GPIO 0x%x -> input\n", pins);
2134                 /* set FLOAT */
2135                 gpio_reg |= (pins << MISC_REGISTERS_GPIO_FLOAT_POS);
2136                 break;
2137
2138         default:
2139                 BNX2X_ERR("Invalid GPIO mode assignment %d\n", mode);
2140                 rc = -EINVAL;
2141                 break;
2142         }
2143
2144         if (rc == 0)
2145                 REG_WR(bp, MISC_REG_GPIO, gpio_reg);
2146
2147         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2148
2149         return rc;
2150 }
2151
2152 int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
2153 {
2154         /* The GPIO should be swapped if swap register is set and active */
2155         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
2156                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
2157         int gpio_shift = gpio_num +
2158                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
2159         u32 gpio_mask = (1 << gpio_shift);
2160         u32 gpio_reg;
2161
2162         if (gpio_num > MISC_REGISTERS_GPIO_3) {
2163                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
2164                 return -EINVAL;
2165         }
2166
2167         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2168         /* read GPIO int */
2169         gpio_reg = REG_RD(bp, MISC_REG_GPIO_INT);
2170
2171         switch (mode) {
2172         case MISC_REGISTERS_GPIO_INT_OUTPUT_CLR:
2173                 DP(NETIF_MSG_LINK,
2174                    "Clear GPIO INT %d (shift %d) -> output low\n",
2175                    gpio_num, gpio_shift);
2176                 /* clear SET and set CLR */
2177                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
2178                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
2179                 break;
2180
2181         case MISC_REGISTERS_GPIO_INT_OUTPUT_SET:
2182                 DP(NETIF_MSG_LINK,
2183                    "Set GPIO INT %d (shift %d) -> output high\n",
2184                    gpio_num, gpio_shift);
2185                 /* clear CLR and set SET */
2186                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
2187                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
2188                 break;
2189
2190         default:
2191                 break;
2192         }
2193
2194         REG_WR(bp, MISC_REG_GPIO_INT, gpio_reg);
2195         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2196
2197         return 0;
2198 }
2199
2200 static int bnx2x_set_spio(struct bnx2x *bp, int spio, u32 mode)
2201 {
2202         u32 spio_reg;
2203
2204         /* Only 2 SPIOs are configurable */
2205         if ((spio != MISC_SPIO_SPIO4) && (spio != MISC_SPIO_SPIO5)) {
2206                 BNX2X_ERR("Invalid SPIO 0x%x\n", spio);
2207                 return -EINVAL;
2208         }
2209
2210         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
2211         /* read SPIO and mask except the float bits */
2212         spio_reg = (REG_RD(bp, MISC_REG_SPIO) & MISC_SPIO_FLOAT);
2213
2214         switch (mode) {
2215         case MISC_SPIO_OUTPUT_LOW:
2216                 DP(NETIF_MSG_HW, "Set SPIO 0x%x -> output low\n", spio);
2217                 /* clear FLOAT and set CLR */
2218                 spio_reg &= ~(spio << MISC_SPIO_FLOAT_POS);
2219                 spio_reg |=  (spio << MISC_SPIO_CLR_POS);
2220                 break;
2221
2222         case MISC_SPIO_OUTPUT_HIGH:
2223                 DP(NETIF_MSG_HW, "Set SPIO 0x%x -> output high\n", spio);
2224                 /* clear FLOAT and set SET */
2225                 spio_reg &= ~(spio << MISC_SPIO_FLOAT_POS);
2226                 spio_reg |=  (spio << MISC_SPIO_SET_POS);
2227                 break;
2228
2229         case MISC_SPIO_INPUT_HI_Z:
2230                 DP(NETIF_MSG_HW, "Set SPIO 0x%x -> input\n", spio);
2231                 /* set FLOAT */
2232                 spio_reg |= (spio << MISC_SPIO_FLOAT_POS);
2233                 break;
2234
2235         default:
2236                 break;
2237         }
2238
2239         REG_WR(bp, MISC_REG_SPIO, spio_reg);
2240         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
2241
2242         return 0;
2243 }
2244
2245 void bnx2x_calc_fc_adv(struct bnx2x *bp)
2246 {
2247         u8 cfg_idx = bnx2x_get_link_cfg_idx(bp);
2248         switch (bp->link_vars.ieee_fc &
2249                 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
2250         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
2251                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
2252                                                    ADVERTISED_Pause);
2253                 break;
2254
2255         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
2256                 bp->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
2257                                                   ADVERTISED_Pause);
2258                 break;
2259
2260         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
2261                 bp->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
2262                 break;
2263
2264         default:
2265                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
2266                                                    ADVERTISED_Pause);
2267                 break;
2268         }
2269 }
2270
2271 static void bnx2x_set_requested_fc(struct bnx2x *bp)
2272 {
2273         /* Initialize link parameters structure variables
2274          * It is recommended to turn off RX FC for jumbo frames
2275          *  for better performance
2276          */
2277         if (CHIP_IS_E1x(bp) && (bp->dev->mtu > 5000))
2278                 bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_TX;
2279         else
2280                 bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
2281 }
2282
2283 static void bnx2x_init_dropless_fc(struct bnx2x *bp)
2284 {
2285         u32 pause_enabled = 0;
2286
2287         if (!CHIP_IS_E1(bp) && bp->dropless_fc && bp->link_vars.link_up) {
2288                 if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
2289                         pause_enabled = 1;
2290
2291                 REG_WR(bp, BAR_USTRORM_INTMEM +
2292                            USTORM_ETH_PAUSE_ENABLED_OFFSET(BP_PORT(bp)),
2293                        pause_enabled);
2294         }
2295
2296         DP(NETIF_MSG_IFUP | NETIF_MSG_LINK, "dropless_fc is %s\n",
2297            pause_enabled ? "enabled" : "disabled");
2298 }
2299
2300 int bnx2x_initial_phy_init(struct bnx2x *bp, int load_mode)
2301 {
2302         int rc, cfx_idx = bnx2x_get_link_cfg_idx(bp);
2303         u16 req_line_speed = bp->link_params.req_line_speed[cfx_idx];
2304
2305         if (!BP_NOMCP(bp)) {
2306                 bnx2x_set_requested_fc(bp);
2307                 bnx2x_acquire_phy_lock(bp);
2308
2309                 if (load_mode == LOAD_DIAG) {
2310                         struct link_params *lp = &bp->link_params;
2311                         lp->loopback_mode = LOOPBACK_XGXS;
2312                         /* do PHY loopback at 10G speed, if possible */
2313                         if (lp->req_line_speed[cfx_idx] < SPEED_10000) {
2314                                 if (lp->speed_cap_mask[cfx_idx] &
2315                                     PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
2316                                         lp->req_line_speed[cfx_idx] =
2317                                         SPEED_10000;
2318                                 else
2319                                         lp->req_line_speed[cfx_idx] =
2320                                         SPEED_1000;
2321                         }
2322                 }
2323
2324                 if (load_mode == LOAD_LOOPBACK_EXT) {
2325                         struct link_params *lp = &bp->link_params;
2326                         lp->loopback_mode = LOOPBACK_EXT;
2327                 }
2328
2329                 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
2330
2331                 bnx2x_release_phy_lock(bp);
2332
2333                 bnx2x_init_dropless_fc(bp);
2334
2335                 bnx2x_calc_fc_adv(bp);
2336
2337                 if (bp->link_vars.link_up) {
2338                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2339                         bnx2x_link_report(bp);
2340                 }
2341                 queue_delayed_work(bnx2x_wq, &bp->period_task, 0);
2342                 bp->link_params.req_line_speed[cfx_idx] = req_line_speed;
2343                 return rc;
2344         }
2345         BNX2X_ERR("Bootcode is missing - can not initialize link\n");
2346         return -EINVAL;
2347 }
2348
2349 void bnx2x_link_set(struct bnx2x *bp)
2350 {
2351         if (!BP_NOMCP(bp)) {
2352                 bnx2x_acquire_phy_lock(bp);
2353                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
2354                 bnx2x_release_phy_lock(bp);
2355
2356                 bnx2x_init_dropless_fc(bp);
2357
2358                 bnx2x_calc_fc_adv(bp);
2359         } else
2360                 BNX2X_ERR("Bootcode is missing - can not set link\n");
2361 }
2362
2363 static void bnx2x__link_reset(struct bnx2x *bp)
2364 {
2365         if (!BP_NOMCP(bp)) {
2366                 bnx2x_acquire_phy_lock(bp);
2367                 bnx2x_lfa_reset(&bp->link_params, &bp->link_vars);
2368                 bnx2x_release_phy_lock(bp);
2369         } else
2370                 BNX2X_ERR("Bootcode is missing - can not reset link\n");
2371 }
2372
2373 void bnx2x_force_link_reset(struct bnx2x *bp)
2374 {
2375         bnx2x_acquire_phy_lock(bp);
2376         bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
2377         bnx2x_release_phy_lock(bp);
2378 }
2379
2380 u8 bnx2x_link_test(struct bnx2x *bp, u8 is_serdes)
2381 {
2382         u8 rc = 0;
2383
2384         if (!BP_NOMCP(bp)) {
2385                 bnx2x_acquire_phy_lock(bp);
2386                 rc = bnx2x_test_link(&bp->link_params, &bp->link_vars,
2387                                      is_serdes);
2388                 bnx2x_release_phy_lock(bp);
2389         } else
2390                 BNX2X_ERR("Bootcode is missing - can not test link\n");
2391
2392         return rc;
2393 }
2394
2395 /* Calculates the sum of vn_min_rates.
2396    It's needed for further normalizing of the min_rates.
2397    Returns:
2398      sum of vn_min_rates.
2399        or
2400      0 - if all the min_rates are 0.
2401      In the later case fairness algorithm should be deactivated.
2402      If not all min_rates are zero then those that are zeroes will be set to 1.
2403  */
2404 static void bnx2x_calc_vn_min(struct bnx2x *bp,
2405                                       struct cmng_init_input *input)
2406 {
2407         int all_zero = 1;
2408         int vn;
2409
2410         for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++) {
2411                 u32 vn_cfg = bp->mf_config[vn];
2412                 u32 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
2413                                    FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
2414
2415                 /* Skip hidden vns */
2416                 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
2417                         vn_min_rate = 0;
2418                 /* If min rate is zero - set it to 1 */
2419                 else if (!vn_min_rate)
2420                         vn_min_rate = DEF_MIN_RATE;
2421                 else
2422                         all_zero = 0;
2423
2424                 input->vnic_min_rate[vn] = vn_min_rate;
2425         }
2426
2427         /* if ETS or all min rates are zeros - disable fairness */
2428         if (BNX2X_IS_ETS_ENABLED(bp)) {
2429                 input->flags.cmng_enables &=
2430                                         ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
2431                 DP(NETIF_MSG_IFUP, "Fairness will be disabled due to ETS\n");
2432         } else if (all_zero) {
2433                 input->flags.cmng_enables &=
2434                                         ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
2435                 DP(NETIF_MSG_IFUP,
2436                    "All MIN values are zeroes fairness will be disabled\n");
2437         } else
2438                 input->flags.cmng_enables |=
2439                                         CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
2440 }
2441
2442 static void bnx2x_calc_vn_max(struct bnx2x *bp, int vn,
2443                                     struct cmng_init_input *input)
2444 {
2445         u16 vn_max_rate;
2446         u32 vn_cfg = bp->mf_config[vn];
2447
2448         if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
2449                 vn_max_rate = 0;
2450         else {
2451                 u32 maxCfg = bnx2x_extract_max_cfg(bp, vn_cfg);
2452
2453                 if (IS_MF_SI(bp)) {
2454                         /* maxCfg in percents of linkspeed */
2455                         vn_max_rate = (bp->link_vars.line_speed * maxCfg) / 100;
2456                 } else /* SD modes */
2457                         /* maxCfg is absolute in 100Mb units */
2458                         vn_max_rate = maxCfg * 100;
2459         }
2460
2461         DP(NETIF_MSG_IFUP, "vn %d: vn_max_rate %d\n", vn, vn_max_rate);
2462
2463         input->vnic_max_rate[vn] = vn_max_rate;
2464 }
2465
2466 static int bnx2x_get_cmng_fns_mode(struct bnx2x *bp)
2467 {
2468         if (CHIP_REV_IS_SLOW(bp))
2469                 return CMNG_FNS_NONE;
2470         if (IS_MF(bp))
2471                 return CMNG_FNS_MINMAX;
2472
2473         return CMNG_FNS_NONE;
2474 }
2475
2476 void bnx2x_read_mf_cfg(struct bnx2x *bp)
2477 {
2478         int vn, n = (CHIP_MODE_IS_4_PORT(bp) ? 2 : 1);
2479
2480         if (BP_NOMCP(bp))
2481                 return; /* what should be the default value in this case */
2482
2483         /* For 2 port configuration the absolute function number formula
2484          * is:
2485          *      abs_func = 2 * vn + BP_PORT + BP_PATH
2486          *
2487          *      and there are 4 functions per port
2488          *
2489          * For 4 port configuration it is
2490          *      abs_func = 4 * vn + 2 * BP_PORT + BP_PATH
2491          *
2492          *      and there are 2 functions per port
2493          */
2494         for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++) {
2495                 int /*abs*/func = n * (2 * vn + BP_PORT(bp)) + BP_PATH(bp);
2496
2497                 if (func >= E1H_FUNC_MAX)
2498                         break;
2499
2500                 bp->mf_config[vn] =
2501                         MF_CFG_RD(bp, func_mf_config[func].config);
2502         }
2503         if (bp->mf_config[BP_VN(bp)] & FUNC_MF_CFG_FUNC_DISABLED) {
2504                 DP(NETIF_MSG_IFUP, "mf_cfg function disabled\n");
2505                 bp->flags |= MF_FUNC_DIS;
2506         } else {
2507                 DP(NETIF_MSG_IFUP, "mf_cfg function enabled\n");
2508                 bp->flags &= ~MF_FUNC_DIS;
2509         }
2510 }
2511
2512 static void bnx2x_cmng_fns_init(struct bnx2x *bp, u8 read_cfg, u8 cmng_type)
2513 {
2514         struct cmng_init_input input;
2515         memset(&input, 0, sizeof(struct cmng_init_input));
2516
2517         input.port_rate = bp->link_vars.line_speed;
2518
2519         if (cmng_type == CMNG_FNS_MINMAX && input.port_rate) {
2520                 int vn;
2521
2522                 /* read mf conf from shmem */
2523                 if (read_cfg)
2524                         bnx2x_read_mf_cfg(bp);
2525
2526                 /* vn_weight_sum and enable fairness if not 0 */
2527                 bnx2x_calc_vn_min(bp, &input);
2528
2529                 /* calculate and set min-max rate for each vn */
2530                 if (bp->port.pmf)
2531                         for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++)
2532                                 bnx2x_calc_vn_max(bp, vn, &input);
2533
2534                 /* always enable rate shaping and fairness */
2535                 input.flags.cmng_enables |=
2536                                         CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN;
2537
2538                 bnx2x_init_cmng(&input, &bp->cmng);
2539                 return;
2540         }
2541
2542         /* rate shaping and fairness are disabled */
2543         DP(NETIF_MSG_IFUP,
2544            "rate shaping and fairness are disabled\n");
2545 }
2546
2547 static void storm_memset_cmng(struct bnx2x *bp,
2548                               struct cmng_init *cmng,
2549                               u8 port)
2550 {
2551         int vn;
2552         size_t size = sizeof(struct cmng_struct_per_port);
2553
2554         u32 addr = BAR_XSTRORM_INTMEM +
2555                         XSTORM_CMNG_PER_PORT_VARS_OFFSET(port);
2556
2557         __storm_memset_struct(bp, addr, size, (u32 *)&cmng->port);
2558
2559         for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++) {
2560                 int func = func_by_vn(bp, vn);
2561
2562                 addr = BAR_XSTRORM_INTMEM +
2563                        XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func);
2564                 size = sizeof(struct rate_shaping_vars_per_vn);
2565                 __storm_memset_struct(bp, addr, size,
2566                                       (u32 *)&cmng->vnic.vnic_max_rate[vn]);
2567
2568                 addr = BAR_XSTRORM_INTMEM +
2569                        XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func);
2570                 size = sizeof(struct fairness_vars_per_vn);
2571                 __storm_memset_struct(bp, addr, size,
2572                                       (u32 *)&cmng->vnic.vnic_min_rate[vn]);
2573         }
2574 }
2575
2576 /* init cmng mode in HW according to local configuration */
2577 void bnx2x_set_local_cmng(struct bnx2x *bp)
2578 {
2579         int cmng_fns = bnx2x_get_cmng_fns_mode(bp);
2580
2581         if (cmng_fns != CMNG_FNS_NONE) {
2582                 bnx2x_cmng_fns_init(bp, false, cmng_fns);
2583                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2584         } else {
2585                 /* rate shaping and fairness are disabled */
2586                 DP(NETIF_MSG_IFUP,
2587                    "single function mode without fairness\n");
2588         }
2589 }
2590
2591 /* This function is called upon link interrupt */
2592 static void bnx2x_link_attn(struct bnx2x *bp)
2593 {
2594         /* Make sure that we are synced with the current statistics */
2595         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2596
2597         bnx2x_link_update(&bp->link_params, &bp->link_vars);
2598
2599         bnx2x_init_dropless_fc(bp);
2600
2601         if (bp->link_vars.link_up) {
2602
2603                 if (bp->link_vars.mac_type != MAC_TYPE_EMAC) {
2604                         struct host_port_stats *pstats;
2605
2606                         pstats = bnx2x_sp(bp, port_stats);
2607                         /* reset old mac stats */
2608                         memset(&(pstats->mac_stx[0]), 0,
2609                                sizeof(struct mac_stx));
2610                 }
2611                 if (bp->state == BNX2X_STATE_OPEN)
2612                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2613         }
2614
2615         if (bp->link_vars.link_up && bp->link_vars.line_speed)
2616                 bnx2x_set_local_cmng(bp);
2617
2618         __bnx2x_link_report(bp);
2619
2620         if (IS_MF(bp))
2621                 bnx2x_link_sync_notify(bp);
2622 }
2623
2624 void bnx2x__link_status_update(struct bnx2x *bp)
2625 {
2626         if (bp->state != BNX2X_STATE_OPEN)
2627                 return;
2628
2629         /* read updated dcb configuration */
2630         if (IS_PF(bp)) {
2631                 bnx2x_dcbx_pmf_update(bp);
2632                 bnx2x_link_status_update(&bp->link_params, &bp->link_vars);
2633                 if (bp->link_vars.link_up)
2634                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2635                 else
2636                         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2637                         /* indicate link status */
2638                 bnx2x_link_report(bp);
2639
2640         } else { /* VF */
2641                 bp->port.supported[0] |= (SUPPORTED_10baseT_Half |
2642                                           SUPPORTED_10baseT_Full |
2643                                           SUPPORTED_100baseT_Half |
2644                                           SUPPORTED_100baseT_Full |
2645                                           SUPPORTED_1000baseT_Full |
2646                                           SUPPORTED_2500baseX_Full |
2647                                           SUPPORTED_10000baseT_Full |
2648                                           SUPPORTED_TP |
2649                                           SUPPORTED_FIBRE |
2650                                           SUPPORTED_Autoneg |
2651                                           SUPPORTED_Pause |
2652                                           SUPPORTED_Asym_Pause);
2653                 bp->port.advertising[0] = bp->port.supported[0];
2654
2655                 bp->link_params.bp = bp;
2656                 bp->link_params.port = BP_PORT(bp);
2657                 bp->link_params.req_duplex[0] = DUPLEX_FULL;
2658                 bp->link_params.req_flow_ctrl[0] = BNX2X_FLOW_CTRL_NONE;
2659                 bp->link_params.req_line_speed[0] = SPEED_10000;
2660                 bp->link_params.speed_cap_mask[0] = 0x7f0000;
2661                 bp->link_params.switch_cfg = SWITCH_CFG_10G;
2662                 bp->link_vars.mac_type = MAC_TYPE_BMAC;
2663                 bp->link_vars.line_speed = SPEED_10000;
2664                 bp->link_vars.link_status =
2665                         (LINK_STATUS_LINK_UP |
2666                          LINK_STATUS_SPEED_AND_DUPLEX_10GTFD);
2667                 bp->link_vars.link_up = 1;
2668                 bp->link_vars.duplex = DUPLEX_FULL;
2669                 bp->link_vars.flow_ctrl = BNX2X_FLOW_CTRL_NONE;
2670                 __bnx2x_link_report(bp);
2671
2672                 bnx2x_sample_bulletin(bp);
2673
2674                 /* if bulletin board did not have an update for link status
2675                  * __bnx2x_link_report will report current status
2676                  * but it will NOT duplicate report in case of already reported
2677                  * during sampling bulletin board.
2678                  */
2679                 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2680         }
2681 }
2682
2683 static int bnx2x_afex_func_update(struct bnx2x *bp, u16 vifid,
2684                                   u16 vlan_val, u8 allowed_prio)
2685 {
2686         struct bnx2x_func_state_params func_params = {NULL};
2687         struct bnx2x_func_afex_update_params *f_update_params =
2688                 &func_params.params.afex_update;
2689
2690         func_params.f_obj = &bp->func_obj;
2691         func_params.cmd = BNX2X_F_CMD_AFEX_UPDATE;
2692
2693         /* no need to wait for RAMROD completion, so don't
2694          * set RAMROD_COMP_WAIT flag
2695          */
2696
2697         f_update_params->vif_id = vifid;
2698         f_update_params->afex_default_vlan = vlan_val;
2699         f_update_params->allowed_priorities = allowed_prio;
2700
2701         /* if ramrod can not be sent, response to MCP immediately */
2702         if (bnx2x_func_state_change(bp, &func_params) < 0)
2703                 bnx2x_fw_command(bp, DRV_MSG_CODE_AFEX_VIFSET_ACK, 0);
2704
2705         return 0;
2706 }
2707
2708 static int bnx2x_afex_handle_vif_list_cmd(struct bnx2x *bp, u8 cmd_type,
2709                                           u16 vif_index, u8 func_bit_map)
2710 {
2711         struct bnx2x_func_state_params func_params = {NULL};
2712         struct bnx2x_func_afex_viflists_params *update_params =
2713                 &func_params.params.afex_viflists;
2714         int rc;
2715         u32 drv_msg_code;
2716
2717         /* validate only LIST_SET and LIST_GET are received from switch */
2718         if ((cmd_type != VIF_LIST_RULE_GET) && (cmd_type != VIF_LIST_RULE_SET))
2719                 BNX2X_ERR("BUG! afex_handle_vif_list_cmd invalid type 0x%x\n",
2720                           cmd_type);
2721
2722         func_params.f_obj = &bp->func_obj;
2723         func_params.cmd = BNX2X_F_CMD_AFEX_VIFLISTS;
2724
2725         /* set parameters according to cmd_type */
2726         update_params->afex_vif_list_command = cmd_type;
2727         update_params->vif_list_index = vif_index;
2728         update_params->func_bit_map =
2729                 (cmd_type == VIF_LIST_RULE_GET) ? 0 : func_bit_map;
2730         update_params->func_to_clear = 0;
2731         drv_msg_code =
2732                 (cmd_type == VIF_LIST_RULE_GET) ?
2733                 DRV_MSG_CODE_AFEX_LISTGET_ACK :
2734                 DRV_MSG_CODE_AFEX_LISTSET_ACK;
2735
2736         /* if ramrod can not be sent, respond to MCP immediately for
2737          * SET and GET requests (other are not triggered from MCP)
2738          */
2739         rc = bnx2x_func_state_change(bp, &func_params);
2740         if (rc < 0)
2741                 bnx2x_fw_command(bp, drv_msg_code, 0);
2742
2743         return 0;
2744 }
2745
2746 static void bnx2x_handle_afex_cmd(struct bnx2x *bp, u32 cmd)
2747 {
2748         struct afex_stats afex_stats;
2749         u32 func = BP_ABS_FUNC(bp);
2750         u32 mf_config;
2751         u16 vlan_val;
2752         u32 vlan_prio;
2753         u16 vif_id;
2754         u8 allowed_prio;
2755         u8 vlan_mode;
2756         u32 addr_to_write, vifid, addrs, stats_type, i;
2757
2758         if (cmd & DRV_STATUS_AFEX_LISTGET_REQ) {
2759                 vifid = SHMEM2_RD(bp, afex_param1_to_driver[BP_FW_MB_IDX(bp)]);
2760                 DP(BNX2X_MSG_MCP,
2761                    "afex: got MCP req LISTGET_REQ for vifid 0x%x\n", vifid);
2762                 bnx2x_afex_handle_vif_list_cmd(bp, VIF_LIST_RULE_GET, vifid, 0);
2763         }
2764
2765         if (cmd & DRV_STATUS_AFEX_LISTSET_REQ) {
2766                 vifid = SHMEM2_RD(bp, afex_param1_to_driver[BP_FW_MB_IDX(bp)]);
2767                 addrs = SHMEM2_RD(bp, afex_param2_to_driver[BP_FW_MB_IDX(bp)]);
2768                 DP(BNX2X_MSG_MCP,
2769                    "afex: got MCP req LISTSET_REQ for vifid 0x%x addrs 0x%x\n",
2770                    vifid, addrs);
2771                 bnx2x_afex_handle_vif_list_cmd(bp, VIF_LIST_RULE_SET, vifid,
2772                                                addrs);
2773         }
2774
2775         if (cmd & DRV_STATUS_AFEX_STATSGET_REQ) {
2776                 addr_to_write = SHMEM2_RD(bp,
2777                         afex_scratchpad_addr_to_write[BP_FW_MB_IDX(bp)]);
2778                 stats_type = SHMEM2_RD(bp,
2779                         afex_param1_to_driver[BP_FW_MB_IDX(bp)]);
2780
2781                 DP(BNX2X_MSG_MCP,
2782                    "afex: got MCP req STATSGET_REQ, write to addr 0x%x\n",
2783                    addr_to_write);
2784
2785                 bnx2x_afex_collect_stats(bp, (void *)&afex_stats, stats_type);
2786
2787                 /* write response to scratchpad, for MCP */
2788                 for (i = 0; i < (sizeof(struct afex_stats)/sizeof(u32)); i++)
2789                         REG_WR(bp, addr_to_write + i*sizeof(u32),
2790                                *(((u32 *)(&afex_stats))+i));
2791
2792                 /* send ack message to MCP */
2793                 bnx2x_fw_command(bp, DRV_MSG_CODE_AFEX_STATSGET_ACK, 0);
2794         }
2795
2796         if (cmd & DRV_STATUS_AFEX_VIFSET_REQ) {
2797                 mf_config = MF_CFG_RD(bp, func_mf_config[func].config);
2798                 bp->mf_config[BP_VN(bp)] = mf_config;
2799                 DP(BNX2X_MSG_MCP,
2800                    "afex: got MCP req VIFSET_REQ, mf_config 0x%x\n",
2801                    mf_config);
2802
2803                 /* if VIF_SET is "enabled" */
2804                 if (!(mf_config & FUNC_MF_CFG_FUNC_DISABLED)) {
2805                         /* set rate limit directly to internal RAM */
2806                         struct cmng_init_input cmng_input;
2807                         struct rate_shaping_vars_per_vn m_rs_vn;
2808                         size_t size = sizeof(struct rate_shaping_vars_per_vn);
2809                         u32 addr = BAR_XSTRORM_INTMEM +
2810                             XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(BP_FUNC(bp));
2811
2812                         bp->mf_config[BP_VN(bp)] = mf_config;
2813
2814                         bnx2x_calc_vn_max(bp, BP_VN(bp), &cmng_input);
2815                         m_rs_vn.vn_counter.rate =
2816                                 cmng_input.vnic_max_rate[BP_VN(bp)];
2817                         m_rs_vn.vn_counter.quota =
2818                                 (m_rs_vn.vn_counter.rate *
2819                                  RS_PERIODIC_TIMEOUT_USEC) / 8;
2820
2821                         __storm_memset_struct(bp, addr, size, (u32 *)&m_rs_vn);
2822
2823                         /* read relevant values from mf_cfg struct in shmem */
2824                         vif_id =
2825                                 (MF_CFG_RD(bp, func_mf_config[func].e1hov_tag) &
2826                                  FUNC_MF_CFG_E1HOV_TAG_MASK) >>
2827                                 FUNC_MF_CFG_E1HOV_TAG_SHIFT;
2828                         vlan_val =
2829                                 (MF_CFG_RD(bp, func_mf_config[func].e1hov_tag) &
2830                                  FUNC_MF_CFG_AFEX_VLAN_MASK) >>
2831                                 FUNC_MF_CFG_AFEX_VLAN_SHIFT;
2832                         vlan_prio = (mf_config &
2833                                      FUNC_MF_CFG_TRANSMIT_PRIORITY_MASK) >>
2834                                     FUNC_MF_CFG_TRANSMIT_PRIORITY_SHIFT;
2835                         vlan_val |= (vlan_prio << VLAN_PRIO_SHIFT);
2836                         vlan_mode =
2837                                 (MF_CFG_RD(bp,
2838                                            func_mf_config[func].afex_config) &
2839                                  FUNC_MF_CFG_AFEX_VLAN_MODE_MASK) >>
2840                                 FUNC_MF_CFG_AFEX_VLAN_MODE_SHIFT;
2841                         allowed_prio =
2842                                 (MF_CFG_RD(bp,
2843                                            func_mf_config[func].afex_config) &
2844                                  FUNC_MF_CFG_AFEX_COS_FILTER_MASK) >>
2845                                 FUNC_MF_CFG_AFEX_COS_FILTER_SHIFT;
2846
2847                         /* send ramrod to FW, return in case of failure */
2848                         if (bnx2x_afex_func_update(bp, vif_id, vlan_val,
2849                                                    allowed_prio))
2850                                 return;
2851
2852                         bp->afex_def_vlan_tag = vlan_val;
2853                         bp->afex_vlan_mode = vlan_mode;
2854                 } else {
2855                         /* notify link down because BP->flags is disabled */
2856                         bnx2x_link_report(bp);
2857
2858                         /* send INVALID VIF ramrod to FW */
2859                         bnx2x_afex_func_update(bp, 0xFFFF, 0, 0);
2860
2861                         /* Reset the default afex VLAN */
2862                         bp->afex_def_vlan_tag = -1;
2863                 }
2864         }
2865 }
2866
2867 static void bnx2x_handle_update_svid_cmd(struct bnx2x *bp)
2868 {
2869         struct bnx2x_func_switch_update_params *switch_update_params;
2870         struct bnx2x_func_state_params func_params;
2871
2872         memset(&func_params, 0, sizeof(struct bnx2x_func_state_params));
2873         switch_update_params = &func_params.params.switch_update;
2874         func_params.f_obj = &bp->func_obj;
2875         func_params.cmd = BNX2X_F_CMD_SWITCH_UPDATE;
2876
2877         if (IS_MF_UFP(bp)) {
2878                 int func = BP_ABS_FUNC(bp);
2879                 u32 val;
2880
2881                 /* Re-learn the S-tag from shmem */
2882                 val = MF_CFG_RD(bp, func_mf_config[func].e1hov_tag) &
2883                                 FUNC_MF_CFG_E1HOV_TAG_MASK;
2884                 if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
2885                         bp->mf_ov = val;
2886                 } else {
2887                         BNX2X_ERR("Got an SVID event, but no tag is configured in shmem\n");
2888                         goto fail;
2889                 }
2890
2891                 /* Configure new S-tag in LLH */
2892                 REG_WR(bp, NIG_REG_LLH0_FUNC_VLAN_ID + BP_PORT(bp) * 8,
2893                        bp->mf_ov);
2894
2895                 /* Send Ramrod to update FW of change */
2896                 __set_bit(BNX2X_F_UPDATE_SD_VLAN_TAG_CHNG,
2897                           &switch_update_params->changes);
2898                 switch_update_params->vlan = bp->mf_ov;
2899
2900                 if (bnx2x_func_state_change(bp, &func_params) < 0) {
2901                         BNX2X_ERR("Failed to configure FW of S-tag Change to %02x\n",
2902                                   bp->mf_ov);
2903                         goto fail;
2904                 }
2905
2906                 DP(BNX2X_MSG_MCP, "Configured S-tag %02x\n", bp->mf_ov);
2907
2908                 bnx2x_fw_command(bp, DRV_MSG_CODE_OEM_UPDATE_SVID_OK, 0);
2909
2910                 return;
2911         }
2912
2913         /* not supported by SW yet */
2914 fail:
2915         bnx2x_fw_command(bp, DRV_MSG_CODE_OEM_UPDATE_SVID_FAILURE, 0);
2916 }
2917
2918 static void bnx2x_pmf_update(struct bnx2x *bp)
2919 {
2920         int port = BP_PORT(bp);
2921         u32 val;
2922
2923         bp->port.pmf = 1;
2924         DP(BNX2X_MSG_MCP, "pmf %d\n", bp->port.pmf);
2925
2926         /*
2927          * We need the mb() to ensure the ordering between the writing to
2928          * bp->port.pmf here and reading it from the bnx2x_periodic_task().
2929          */
2930         smp_mb();
2931
2932         /* queue a periodic task */
2933         queue_delayed_work(bnx2x_wq, &bp->period_task, 0);
2934
2935         bnx2x_dcbx_pmf_update(bp);
2936
2937         /* enable nig attention */
2938         val = (0xff0f | (1 << (BP_VN(bp) + 4)));
2939         if (bp->common.int_block == INT_BLOCK_HC) {
2940                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
2941                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
2942         } else if (!CHIP_IS_E1x(bp)) {
2943                 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
2944                 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
2945         }
2946
2947         bnx2x_stats_handle(bp, STATS_EVENT_PMF);
2948 }
2949
2950 /* end of Link */
2951
2952 /* slow path */
2953
2954 /*
2955  * General service functions
2956  */
2957
2958 /* send the MCP a request, block until there is a reply */
2959 u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param)
2960 {
2961         int mb_idx = BP_FW_MB_IDX(bp);
2962         u32 seq;
2963         u32 rc = 0;
2964         u32 cnt = 1;
2965         u8 delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
2966
2967         mutex_lock(&bp->fw_mb_mutex);
2968         seq = ++bp->fw_seq;
2969         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_param, param);
2970         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_header, (command | seq));
2971
2972         DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB param 0x%08x\n",
2973                         (command | seq), param);
2974
2975         do {
2976                 /* let the FW do it's magic ... */
2977                 msleep(delay);
2978
2979                 rc = SHMEM_RD(bp, func_mb[mb_idx].fw_mb_header);
2980
2981                 /* Give the FW up to 5 second (500*10ms) */
2982         } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
2983
2984         DP(BNX2X_MSG_MCP, "[after %d ms] read (%x) seq is (%x) from FW MB\n",
2985            cnt*delay, rc, seq);
2986
2987         /* is this a reply to our command? */
2988         if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK))
2989                 rc &= FW_MSG_CODE_MASK;
2990         else {
2991                 /* FW BUG! */
2992                 BNX2X_ERR("FW failed to respond!\n");
2993                 bnx2x_fw_dump(bp);
2994                 rc = 0;
2995         }
2996         mutex_unlock(&bp->fw_mb_mutex);
2997
2998         return rc;
2999 }
3000
3001 static void storm_memset_func_cfg(struct bnx2x *bp,
3002                                  struct tstorm_eth_function_common_config *tcfg,
3003                                  u16 abs_fid)
3004 {
3005         size_t size = sizeof(struct tstorm_eth_function_common_config);
3006
3007         u32 addr = BAR_TSTRORM_INTMEM +
3008                         TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid);
3009
3010         __storm_memset_struct(bp, addr, size, (u32 *)tcfg);
3011 }
3012
3013 void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p)
3014 {
3015         if (CHIP_IS_E1x(bp)) {
3016                 struct tstorm_eth_function_common_config tcfg = {0};
3017
3018                 storm_memset_func_cfg(bp, &tcfg, p->func_id);
3019         }
3020
3021         /* Enable the function in the FW */
3022         storm_memset_vf_to_pf(bp, p->func_id, p->pf_id);
3023         storm_memset_func_en(bp, p->func_id, 1);
3024
3025         /* spq */
3026         if (p->func_flgs & FUNC_FLG_SPQ) {
3027                 storm_memset_spq_addr(bp, p->spq_map, p->func_id);
3028                 REG_WR(bp, XSEM_REG_FAST_MEMORY +
3029                        XSTORM_SPQ_PROD_OFFSET(p->func_id), p->spq_prod);
3030         }
3031 }
3032
3033 /**
3034  * bnx2x_get_common_flags - Return common flags
3035  *
3036  * @bp          device handle
3037  * @fp          queue handle
3038  * @zero_stats  TRUE if statistics zeroing is needed
3039  *
3040  * Return the flags that are common for the Tx-only and not normal connections.
3041  */
3042 static unsigned long bnx2x_get_common_flags(struct bnx2x *bp,
3043                                             struct bnx2x_fastpath *fp,
3044                                             bool zero_stats)
3045 {
3046         unsigned long flags = 0;
3047
3048         /* PF driver will always initialize the Queue to an ACTIVE state */
3049         __set_bit(BNX2X_Q_FLG_ACTIVE, &flags);
3050
3051         /* tx only connections collect statistics (on the same index as the
3052          * parent connection). The statistics are zeroed when the parent
3053          * connection is initialized.
3054          */
3055
3056         __set_bit(BNX2X_Q_FLG_STATS, &flags);
3057         if (zero_stats)
3058                 __set_bit(BNX2X_Q_FLG_ZERO_STATS, &flags);
3059
3060         if (bp->flags & TX_SWITCHING)
3061                 __set_bit(BNX2X_Q_FLG_TX_SWITCH, &flags);
3062
3063         __set_bit(BNX2X_Q_FLG_PCSUM_ON_PKT, &flags);
3064         __set_bit(BNX2X_Q_FLG_TUN_INC_INNER_IP_ID, &flags);
3065
3066 #ifdef BNX2X_STOP_ON_ERROR
3067         __set_bit(BNX2X_Q_FLG_TX_SEC, &flags);
3068 #endif
3069
3070         return flags;
3071 }
3072
3073 static unsigned long bnx2x_get_q_flags(struct bnx2x *bp,
3074                                        struct bnx2x_fastpath *fp,
3075                                        bool leading)
3076 {
3077         unsigned long flags = 0;
3078
3079         /* calculate other queue flags */
3080         if (IS_MF_SD(bp))
3081                 __set_bit(BNX2X_Q_FLG_OV, &flags);
3082
3083         if (IS_FCOE_FP(fp)) {
3084                 __set_bit(BNX2X_Q_FLG_FCOE, &flags);
3085                 /* For FCoE - force usage of default priority (for afex) */
3086                 __set_bit(BNX2X_Q_FLG_FORCE_DEFAULT_PRI, &flags);
3087         }
3088
3089         if (!fp->disable_tpa) {
3090                 __set_bit(BNX2X_Q_FLG_TPA, &flags);
3091                 __set_bit(BNX2X_Q_FLG_TPA_IPV6, &flags);
3092                 if (fp->mode == TPA_MODE_GRO)
3093                         __set_bit(BNX2X_Q_FLG_TPA_GRO, &flags);
3094         }
3095
3096         if (leading) {
3097                 __set_bit(BNX2X_Q_FLG_LEADING_RSS, &flags);
3098                 __set_bit(BNX2X_Q_FLG_MCAST, &flags);
3099         }
3100
3101         /* Always set HW VLAN stripping */
3102         __set_bit(BNX2X_Q_FLG_VLAN, &flags);
3103
3104         /* configure silent vlan removal */
3105         if (IS_MF_AFEX(bp))
3106                 __set_bit(BNX2X_Q_FLG_SILENT_VLAN_REM, &flags);
3107
3108         return flags | bnx2x_get_common_flags(bp, fp, true);
3109 }
3110
3111 static void bnx2x_pf_q_prep_general(struct bnx2x *bp,
3112         struct bnx2x_fastpath *fp, struct bnx2x_general_setup_params *gen_init,
3113         u8 cos)
3114 {
3115         gen_init->stat_id = bnx2x_stats_id(fp);
3116         gen_init->spcl_id = fp->cl_id;
3117
3118         /* Always use mini-jumbo MTU for FCoE L2 ring */
3119         if (IS_FCOE_FP(fp))
3120                 gen_init->mtu = BNX2X_FCOE_MINI_JUMBO_MTU;
3121         else
3122                 gen_init->mtu = bp->dev->mtu;
3123
3124         gen_init->cos = cos;
3125
3126         gen_init->fp_hsi = ETH_FP_HSI_VERSION;
3127 }
3128
3129 static void bnx2x_pf_rx_q_prep(struct bnx2x *bp,
3130         struct bnx2x_fastpath *fp, struct rxq_pause_params *pause,
3131         struct bnx2x_rxq_setup_params *rxq_init)
3132 {
3133         u8 max_sge = 0;
3134         u16 sge_sz = 0;
3135         u16 tpa_agg_size = 0;
3136
3137         if (!fp->disable_tpa) {
3138                 pause->sge_th_lo = SGE_TH_LO(bp);
3139                 pause->sge_th_hi = SGE_TH_HI(bp);
3140
3141                 /* validate SGE ring has enough to cross high threshold */
3142                 WARN_ON(bp->dropless_fc &&
3143                                 pause->sge_th_hi + FW_PREFETCH_CNT >
3144                                 MAX_RX_SGE_CNT * NUM_RX_SGE_PAGES);
3145
3146                 tpa_agg_size = TPA_AGG_SIZE;
3147                 max_sge = SGE_PAGE_ALIGN(bp->dev->mtu) >>
3148                         SGE_PAGE_SHIFT;
3149                 max_sge = ((max_sge + PAGES_PER_SGE - 1) &
3150                           (~(PAGES_PER_SGE-1))) >> PAGES_PER_SGE_SHIFT;
3151                 sge_sz = (u16)min_t(u32, SGE_PAGES, 0xffff);
3152         }
3153
3154         /* pause - not for e1 */
3155         if (!CHIP_IS_E1(bp)) {
3156                 pause->bd_th_lo = BD_TH_LO(bp);
3157                 pause->bd_th_hi = BD_TH_HI(bp);
3158
3159                 pause->rcq_th_lo = RCQ_TH_LO(bp);
3160                 pause->rcq_th_hi = RCQ_TH_HI(bp);
3161                 /*
3162                  * validate that rings have enough entries to cross
3163                  * high thresholds
3164                  */
3165                 WARN_ON(bp->dropless_fc &&
3166                                 pause->bd_th_hi + FW_PREFETCH_CNT >
3167                                 bp->rx_ring_size);
3168                 WARN_ON(bp->dropless_fc &&
3169                                 pause->rcq_th_hi + FW_PREFETCH_CNT >
3170                                 NUM_RCQ_RINGS * MAX_RCQ_DESC_CNT);
3171
3172                 pause->pri_map = 1;
3173         }
3174
3175         /* rxq setup */
3176         rxq_init->dscr_map = fp->rx_desc_mapping;
3177         rxq_init->sge_map = fp->rx_sge_mapping;
3178         rxq_init->rcq_map = fp->rx_comp_mapping;
3179         rxq_init->rcq_np_map = fp->rx_comp_mapping + BCM_PAGE_SIZE;
3180
3181         /* This should be a maximum number of data bytes that may be
3182          * placed on the BD (not including paddings).
3183          */
3184         rxq_init->buf_sz = fp->rx_buf_size - BNX2X_FW_RX_ALIGN_START -
3185                            BNX2X_FW_RX_ALIGN_END - IP_HEADER_ALIGNMENT_PADDING;
3186
3187         rxq_init->cl_qzone_id = fp->cl_qzone_id;
3188         rxq_init->tpa_agg_sz = tpa_agg_size;
3189         rxq_init->sge_buf_sz = sge_sz;
3190         rxq_init->max_sges_pkt = max_sge;
3191         rxq_init->rss_engine_id = BP_FUNC(bp);
3192         rxq_init->mcast_engine_id = BP_FUNC(bp);
3193
3194         /* Maximum number or simultaneous TPA aggregation for this Queue.
3195          *
3196          * For PF Clients it should be the maximum available number.
3197          * VF driver(s) may want to define it to a smaller value.
3198          */
3199         rxq_init->max_tpa_queues = MAX_AGG_QS(bp);
3200
3201         rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
3202         rxq_init->fw_sb_id = fp->fw_sb_id;
3203
3204         if (IS_FCOE_FP(fp))
3205                 rxq_init->sb_cq_index = HC_SP_INDEX_ETH_FCOE_RX_CQ_CONS;
3206         else
3207                 rxq_init->sb_cq_index = HC_INDEX_ETH_RX_CQ_CONS;
3208         /* configure silent vlan removal
3209          * if multi function mode is afex, then mask default vlan
3210          */
3211         if (IS_MF_AFEX(bp)) {
3212                 rxq_init->silent_removal_value = bp->afex_def_vlan_tag;
3213                 rxq_init->silent_removal_mask = VLAN_VID_MASK;
3214         }
3215 }
3216
3217 static void bnx2x_pf_tx_q_prep(struct bnx2x *bp,
3218         struct bnx2x_fastpath *fp, struct bnx2x_txq_setup_params *txq_init,
3219         u8 cos)
3220 {
3221         txq_init->dscr_map = fp->txdata_ptr[cos]->tx_desc_mapping;
3222         txq_init->sb_cq_index = HC_INDEX_ETH_FIRST_TX_CQ_CONS + cos;
3223         txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
3224         txq_init->fw_sb_id = fp->fw_sb_id;
3225
3226         /*
3227          * set the tss leading client id for TX classification ==
3228          * leading RSS client id
3229          */
3230         txq_init->tss_leading_cl_id = bnx2x_fp(bp, 0, cl_id);
3231
3232         if (IS_FCOE_FP(fp)) {
3233                 txq_init->sb_cq_index = HC_SP_INDEX_ETH_FCOE_TX_CQ_CONS;
3234                 txq_init->traffic_type = LLFC_TRAFFIC_TYPE_FCOE;
3235         }
3236 }
3237
3238 static void bnx2x_pf_init(struct bnx2x *bp)
3239 {
3240         struct bnx2x_func_init_params func_init = {0};
3241         struct event_ring_data eq_data = { {0} };
3242         u16 flags;
3243
3244         if (!CHIP_IS_E1x(bp)) {
3245                 /* reset IGU PF statistics: MSIX + ATTN */
3246                 /* PF */
3247                 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
3248                            BNX2X_IGU_STAS_MSG_VF_CNT*4 +
3249                            (CHIP_MODE_IS_4_PORT(bp) ?
3250                                 BP_FUNC(bp) : BP_VN(bp))*4, 0);
3251                 /* ATTN */
3252                 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
3253                            BNX2X_IGU_STAS_MSG_VF_CNT*4 +
3254                            BNX2X_IGU_STAS_MSG_PF_CNT*4 +
3255                            (CHIP_MODE_IS_4_PORT(bp) ?
3256                                 BP_FUNC(bp) : BP_VN(bp))*4, 0);
3257         }
3258
3259         /* function setup flags */
3260         flags = (FUNC_FLG_STATS | FUNC_FLG_LEADING | FUNC_FLG_SPQ);
3261
3262         /* This flag is relevant for E1x only.
3263          * E2 doesn't have a TPA configuration in a function level.
3264          */
3265         flags |= (bp->flags & TPA_ENABLE_FLAG) ? FUNC_FLG_TPA : 0;
3266
3267         func_init.func_flgs = flags;
3268         func_init.pf_id = BP_FUNC(bp);
3269         func_init.func_id = BP_FUNC(bp);
3270         func_init.spq_map = bp->spq_mapping;
3271         func_init.spq_prod = bp->spq_prod_idx;
3272
3273         bnx2x_func_init(bp, &func_init);
3274
3275         memset(&(bp->cmng), 0, sizeof(struct cmng_struct_per_port));
3276
3277         /*
3278          * Congestion management values depend on the link rate
3279          * There is no active link so initial link rate is set to 10 Gbps.
3280          * When the link comes up The congestion management values are
3281          * re-calculated according to the actual link rate.
3282          */
3283         bp->link_vars.line_speed = SPEED_10000;
3284         bnx2x_cmng_fns_init(bp, true, bnx2x_get_cmng_fns_mode(bp));
3285
3286         /* Only the PMF sets the HW */
3287         if (bp->port.pmf)
3288                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
3289
3290         /* init Event Queue - PCI bus guarantees correct endianity*/
3291         eq_data.base_addr.hi = U64_HI(bp->eq_mapping);
3292         eq_data.base_addr.lo = U64_LO(bp->eq_mapping);
3293         eq_data.producer = bp->eq_prod;
3294         eq_data.index_id = HC_SP_INDEX_EQ_CONS;
3295         eq_data.sb_id = DEF_SB_ID;
3296         storm_memset_eq_data(bp, &eq_data, BP_FUNC(bp));
3297 }
3298
3299 static void bnx2x_e1h_disable(struct bnx2x *bp)
3300 {
3301         int port = BP_PORT(bp);
3302
3303         bnx2x_tx_disable(bp);
3304
3305         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
3306 }
3307
3308 static void bnx2x_e1h_enable(struct bnx2x *bp)
3309 {
3310         int port = BP_PORT(bp);
3311
3312         if (!(IS_MF_UFP(bp) && BNX2X_IS_MF_SD_PROTOCOL_FCOE(bp)))
3313                 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port * 8, 1);
3314
3315         /* Tx queue should be only re-enabled */
3316         netif_tx_wake_all_queues(bp->dev);
3317
3318         /*
3319          * Should not call netif_carrier_on since it will be called if the link
3320          * is up when checking for link state
3321          */
3322 }
3323
3324 #define DRV_INFO_ETH_STAT_NUM_MACS_REQUIRED 3
3325
3326 static void bnx2x_drv_info_ether_stat(struct bnx2x *bp)
3327 {
3328         struct eth_stats_info *ether_stat =
3329                 &bp->slowpath->drv_info_to_mcp.ether_stat;
3330         struct bnx2x_vlan_mac_obj *mac_obj =
3331                 &bp->sp_objs->mac_obj;
3332         int i;
3333
3334         strlcpy(ether_stat->version, DRV_MODULE_VERSION,
3335                 ETH_STAT_INFO_VERSION_LEN);
3336
3337         /* get DRV_INFO_ETH_STAT_NUM_MACS_REQUIRED macs, placing them in the
3338          * mac_local field in ether_stat struct. The base address is offset by 2
3339          * bytes to account for the field being 8 bytes but a mac address is
3340          * only 6 bytes. Likewise, the stride for the get_n_elements function is
3341          * 2 bytes to compensate from the 6 bytes of a mac to the 8 bytes
3342          * allocated by the ether_stat struct, so the macs will land in their
3343          * proper positions.
3344          */
3345         for (i = 0; i < DRV_INFO_ETH_STAT_NUM_MACS_REQUIRED; i++)
3346                 memset(ether_stat->mac_local + i, 0,
3347                        sizeof(ether_stat->mac_local[0]));
3348         mac_obj->get_n_elements(bp, &bp->sp_objs[0].mac_obj,
3349                                 DRV_INFO_ETH_STAT_NUM_MACS_REQUIRED,
3350                                 ether_stat->mac_local + MAC_PAD, MAC_PAD,
3351                                 ETH_ALEN);
3352         ether_stat->mtu_size = bp->dev->mtu;
3353         if (bp->dev->features & NETIF_F_RXCSUM)
3354                 ether_stat->feature_flags |= FEATURE_ETH_CHKSUM_OFFLOAD_MASK;
3355         if (bp->dev->features & NETIF_F_TSO)
3356                 ether_stat->feature_flags |= FEATURE_ETH_LSO_MASK;
3357         ether_stat->feature_flags |= bp->common.boot_mode;
3358
3359         ether_stat->promiscuous_mode = (bp->dev->flags & IFF_PROMISC) ? 1 : 0;
3360
3361         ether_stat->txq_size = bp->tx_ring_size;
3362         ether_stat->rxq_size = bp->rx_ring_size;
3363
3364 #ifdef CONFIG_BNX2X_SRIOV
3365         ether_stat->vf_cnt = IS_SRIOV(bp) ? bp->vfdb->sriov.nr_virtfn : 0;
3366 #endif
3367 }
3368
3369 static void bnx2x_drv_info_fcoe_stat(struct bnx2x *bp)
3370 {
3371         struct bnx2x_dcbx_app_params *app = &bp->dcbx_port_params.app;
3372         struct fcoe_stats_info *fcoe_stat =
3373                 &bp->slowpath->drv_info_to_mcp.fcoe_stat;
3374
3375         if (!CNIC_LOADED(bp))
3376                 return;
3377
3378         memcpy(fcoe_stat->mac_local + MAC_PAD, bp->fip_mac, ETH_ALEN);
3379
3380         fcoe_stat->qos_priority =
3381                 app->traffic_type_priority[LLFC_TRAFFIC_TYPE_FCOE];
3382
3383         /* insert FCoE stats from ramrod response */
3384         if (!NO_FCOE(bp)) {
3385                 struct tstorm_per_queue_stats *fcoe_q_tstorm_stats =
3386                         &bp->fw_stats_data->queue_stats[FCOE_IDX(bp)].
3387                         tstorm_queue_statistics;
3388
3389                 struct xstorm_per_queue_stats *fcoe_q_xstorm_stats =
3390                         &bp->fw_stats_data->queue_stats[FCOE_IDX(bp)].
3391                         xstorm_queue_statistics;
3392
3393                 struct fcoe_statistics_params *fw_fcoe_stat =
3394                         &bp->fw_stats_data->fcoe;
3395
3396                 ADD_64_LE(fcoe_stat->rx_bytes_hi, LE32_0,
3397                           fcoe_stat->rx_bytes_lo,
3398                           fw_fcoe_stat->rx_stat0.fcoe_rx_byte_cnt);
3399
3400                 ADD_64_LE(fcoe_stat->rx_bytes_hi,
3401                           fcoe_q_tstorm_stats->rcv_ucast_bytes.hi,
3402                           fcoe_stat->rx_bytes_lo,
3403                           fcoe_q_tstorm_stats->rcv_ucast_bytes.lo);
3404
3405                 ADD_64_LE(fcoe_stat->rx_bytes_hi,
3406                           fcoe_q_tstorm_stats->rcv_bcast_bytes.hi,
3407                           fcoe_stat->rx_bytes_lo,
3408                           fcoe_q_tstorm_stats->rcv_bcast_bytes.lo);
3409
3410                 ADD_64_LE(fcoe_stat->rx_bytes_hi,
3411                           fcoe_q_tstorm_stats->rcv_mcast_bytes.hi,
3412                           fcoe_stat->rx_bytes_lo,
3413                           fcoe_q_tstorm_stats->rcv_mcast_bytes.lo);
3414
3415                 ADD_64_LE(fcoe_stat->rx_frames_hi, LE32_0,
3416                           fcoe_stat->rx_frames_lo,
3417                           fw_fcoe_stat->rx_stat0.fcoe_rx_pkt_cnt);
3418
3419                 ADD_64_LE(fcoe_stat->rx_frames_hi, LE32_0,
3420                           fcoe_stat->rx_frames_lo,
3421                           fcoe_q_tstorm_stats->rcv_ucast_pkts);
3422
3423                 ADD_64_LE(fcoe_stat->rx_frames_hi, LE32_0,
3424                           fcoe_stat->rx_frames_lo,
3425                           fcoe_q_tstorm_stats->rcv_bcast_pkts);
3426
3427                 ADD_64_LE(fcoe_stat->rx_frames_hi, LE32_0,
3428                           fcoe_stat->rx_frames_lo,
3429                           fcoe_q_tstorm_stats->rcv_mcast_pkts);
3430
3431                 ADD_64_LE(fcoe_stat->tx_bytes_hi, LE32_0,
3432                           fcoe_stat->tx_bytes_lo,
3433                           fw_fcoe_stat->tx_stat.fcoe_tx_byte_cnt);
3434
3435                 ADD_64_LE(fcoe_stat->tx_bytes_hi,
3436                           fcoe_q_xstorm_stats->ucast_bytes_sent.hi,
3437                           fcoe_stat->tx_bytes_lo,
3438                           fcoe_q_xstorm_stats->ucast_bytes_sent.lo);
3439
3440                 ADD_64_LE(fcoe_stat->tx_bytes_hi,
3441                           fcoe_q_xstorm_stats->bcast_bytes_sent.hi,
3442                           fcoe_stat->tx_bytes_lo,
3443                           fcoe_q_xstorm_stats->bcast_bytes_sent.lo);
3444
3445                 ADD_64_LE(fcoe_stat->tx_bytes_hi,
3446                           fcoe_q_xstorm_stats->mcast_bytes_sent.hi,
3447                           fcoe_stat->tx_bytes_lo,
3448                           fcoe_q_xstorm_stats->mcast_bytes_sent.lo);
3449
3450                 ADD_64_LE(fcoe_stat->tx_frames_hi, LE32_0,
3451                           fcoe_stat->tx_frames_lo,
3452                           fw_fcoe_stat->tx_stat.fcoe_tx_pkt_cnt);
3453
3454                 ADD_64_LE(fcoe_stat->tx_frames_hi, LE32_0,
3455                           fcoe_stat->tx_frames_lo,
3456                           fcoe_q_xstorm_stats->ucast_pkts_sent);
3457
3458                 ADD_64_LE(fcoe_stat->tx_frames_hi, LE32_0,
3459                           fcoe_stat->tx_frames_lo,
3460                           fcoe_q_xstorm_stats->bcast_pkts_sent);
3461
3462                 ADD_64_LE(fcoe_stat->tx_frames_hi, LE32_0,
3463                           fcoe_stat->tx_frames_lo,
3464                           fcoe_q_xstorm_stats->mcast_pkts_sent);
3465         }
3466
3467         /* ask L5 driver to add data to the struct */
3468         bnx2x_cnic_notify(bp, CNIC_CTL_FCOE_STATS_GET_CMD);
3469 }
3470
3471 static void bnx2x_drv_info_iscsi_stat(struct bnx2x *bp)
3472 {
3473         struct bnx2x_dcbx_app_params *app = &bp->dcbx_port_params.app;
3474         struct iscsi_stats_info *iscsi_stat =
3475                 &bp->slowpath->drv_info_to_mcp.iscsi_stat;
3476
3477         if (!CNIC_LOADED(bp))
3478                 return;
3479
3480         memcpy(iscsi_stat->mac_local + MAC_PAD, bp->cnic_eth_dev.iscsi_mac,
3481                ETH_ALEN);
3482
3483         iscsi_stat->qos_priority =
3484                 app->traffic_type_priority[LLFC_TRAFFIC_TYPE_ISCSI];
3485
3486         /* ask L5 driver to add data to the struct */
3487         bnx2x_cnic_notify(bp, CNIC_CTL_ISCSI_STATS_GET_CMD);
3488 }
3489
3490 /* called due to MCP event (on pmf):
3491  *      reread new bandwidth configuration
3492  *      configure FW
3493  *      notify others function about the change
3494  */
3495 static void bnx2x_config_mf_bw(struct bnx2x *bp)
3496 {
3497         if (bp->link_vars.link_up) {
3498                 bnx2x_cmng_fns_init(bp, true, CMNG_FNS_MINMAX);
3499                 bnx2x_link_sync_notify(bp);
3500         }
3501         storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
3502 }
3503
3504 static void bnx2x_set_mf_bw(struct bnx2x *bp)
3505 {
3506         bnx2x_config_mf_bw(bp);
3507         bnx2x_fw_command(bp, DRV_MSG_CODE_SET_MF_BW_ACK, 0);
3508 }
3509
3510 static void bnx2x_handle_eee_event(struct bnx2x *bp)
3511 {
3512         DP(BNX2X_MSG_MCP, "EEE - LLDP event\n");
3513         bnx2x_fw_command(bp, DRV_MSG_CODE_EEE_RESULTS_ACK, 0);
3514 }
3515
3516 #define BNX2X_UPDATE_DRV_INFO_IND_LENGTH        (20)
3517 #define BNX2X_UPDATE_DRV_INFO_IND_COUNT         (25)
3518
3519 static void bnx2x_handle_drv_info_req(struct bnx2x *bp)
3520 {
3521         enum drv_info_opcode op_code;
3522         u32 drv_info_ctl = SHMEM2_RD(bp, drv_info_control);
3523         bool release = false;
3524         int wait;
3525
3526         /* if drv_info version supported by MFW doesn't match - send NACK */
3527         if ((drv_info_ctl & DRV_INFO_CONTROL_VER_MASK) != DRV_INFO_CUR_VER) {
3528                 bnx2x_fw_command(bp, DRV_MSG_CODE_DRV_INFO_NACK, 0);
3529                 return;
3530         }
3531
3532         op_code = (drv_info_ctl & DRV_INFO_CONTROL_OP_CODE_MASK) >>
3533                   DRV_INFO_CONTROL_OP_CODE_SHIFT;
3534
3535         /* Must prevent other flows from accessing drv_info_to_mcp */
3536         mutex_lock(&bp->drv_info_mutex);
3537
3538         memset(&bp->slowpath->drv_info_to_mcp, 0,
3539                sizeof(union drv_info_to_mcp));
3540
3541         switch (op_code) {
3542         case ETH_STATS_OPCODE:
3543                 bnx2x_drv_info_ether_stat(bp);
3544                 break;
3545         case FCOE_STATS_OPCODE:
3546                 bnx2x_drv_info_fcoe_stat(bp);
3547                 break;
3548         case ISCSI_STATS_OPCODE:
3549                 bnx2x_drv_info_iscsi_stat(bp);
3550                 break;
3551         default:
3552                 /* if op code isn't supported - send NACK */
3553                 bnx2x_fw_command(bp, DRV_MSG_CODE_DRV_INFO_NACK, 0);
3554                 goto out;
3555         }
3556
3557         /* if we got drv_info attn from MFW then these fields are defined in
3558          * shmem2 for sure
3559          */
3560         SHMEM2_WR(bp, drv_info_host_addr_lo,
3561                 U64_LO(bnx2x_sp_mapping(bp, drv_info_to_mcp)));
3562         SHMEM2_WR(bp, drv_info_host_addr_hi,
3563                 U64_HI(bnx2x_sp_mapping(bp, drv_info_to_mcp)));
3564
3565         bnx2x_fw_command(bp, DRV_MSG_CODE_DRV_INFO_ACK, 0);
3566
3567         /* Since possible management wants both this and get_driver_version
3568          * need to wait until management notifies us it finished utilizing
3569          * the buffer.
3570          */
3571         if (!SHMEM2_HAS(bp, mfw_drv_indication)) {
3572                 DP(BNX2X_MSG_MCP, "Management does not support indication\n");
3573         } else if (!bp->drv_info_mng_owner) {
3574                 u32 bit = MFW_DRV_IND_READ_DONE_OFFSET((BP_ABS_FUNC(bp) >> 1));
3575
3576                 for (wait = 0; wait < BNX2X_UPDATE_DRV_INFO_IND_COUNT; wait++) {
3577                         u32 indication = SHMEM2_RD(bp, mfw_drv_indication);
3578
3579                         /* Management is done; need to clear indication */
3580                         if (indication & bit) {
3581                                 SHMEM2_WR(bp, mfw_drv_indication,
3582                                           indication & ~bit);
3583                                 release = true;
3584                                 break;
3585                         }
3586
3587                         msleep(BNX2X_UPDATE_DRV_INFO_IND_LENGTH);
3588                 }
3589         }
3590         if (!release) {
3591                 DP(BNX2X_MSG_MCP, "Management did not release indication\n");
3592                 bp->drv_info_mng_owner = true;
3593         }
3594
3595 out:
3596         mutex_unlock(&bp->drv_info_mutex);
3597 }
3598
3599 static u32 bnx2x_update_mng_version_utility(u8 *version, bool bnx2x_format)
3600 {
3601         u8 vals[4];
3602         int i = 0;
3603
3604         if (bnx2x_format) {
3605                 i = sscanf(version, "1.%c%hhd.%hhd.%hhd",
3606                            &vals[0], &vals[1], &vals[2], &vals[3]);
3607                 if (i > 0)
3608                         vals[0] -= '0';
3609         } else {
3610                 i = sscanf(version, "%hhd.%hhd.%hhd.%hhd",
3611                            &vals[0], &vals[1], &vals[2], &vals[3]);
3612         }
3613
3614         while (i < 4)
3615                 vals[i++] = 0;
3616
3617         return (vals[0] << 24) | (vals[1] << 16) | (vals[2] << 8) | vals[3];
3618 }
3619
3620 void bnx2x_update_mng_version(struct bnx2x *bp)
3621 {
3622         u32 iscsiver = DRV_VER_NOT_LOADED;
3623         u32 fcoever = DRV_VER_NOT_LOADED;
3624         u32 ethver = DRV_VER_NOT_LOADED;
3625         int idx = BP_FW_MB_IDX(bp);
3626         u8 *version;
3627
3628         if (!SHMEM2_HAS(bp, func_os_drv_ver))
3629                 return;
3630
3631         mutex_lock(&bp->drv_info_mutex);
3632         /* Must not proceed when `bnx2x_handle_drv_info_req' is feasible */
3633         if (bp->drv_info_mng_owner)
3634                 goto out;
3635
3636         if (bp->state != BNX2X_STATE_OPEN)
3637                 goto out;
3638
3639         /* Parse ethernet driver version */
3640         ethver = bnx2x_update_mng_version_utility(DRV_MODULE_VERSION, true);
3641         if (!CNIC_LOADED(bp))
3642                 goto out;
3643
3644         /* Try getting storage driver version via cnic */
3645         memset(&bp->slowpath->drv_info_to_mcp, 0,
3646                sizeof(union drv_info_to_mcp));