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