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