BNX2X: spatch changes for BUG and WARN
[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 const struct pci_device_id *srch_linux_pci_tbl(const struct pci_device_id *tbl,
237                                                struct pci_device *needle)
238 {
239         const struct pci_device_id *i;
240         for (i = tbl; i->vendor; i++) {
241                 if ((needle->ven_id == i->vendor) && (needle->dev_id == i->device))
242                         break;
243         }
244         if (i->vendor)
245                 return i;
246         return 0;
247 }
248
249 const struct pci_device_id *srch_bnx2x_pci_tbl(struct pci_device *needle)
250 {
251         const struct pci_device_id *tbl = bnx2x_pci_tbl;
252         return srch_linux_pci_tbl(tbl, needle);
253 }
254
255 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
256
257 /* Global resources for unloading a previously loaded device */
258 #define BNX2X_PREV_WAIT_NEEDED 1
259 static DEFINE_SEMAPHORE(bnx2x_prev_sem);
260 static LINUX_LIST_HEAD(bnx2x_prev_list);
261
262 /* Forward declaration */
263 static struct cnic_eth_dev *bnx2x_cnic_probe(struct ether *dev);
264 static uint32_t bnx2x_rx_ustorm_prods_offset(struct bnx2x_fastpath *fp);
265 static int bnx2x_set_storm_rx_mode(struct bnx2x *bp);
266
267 /****************************************************************************
268 * General service functions
269 ****************************************************************************/
270
271 static int bnx2x_hwtstamp_ioctl(struct bnx2x *bp, struct ifreq *ifr);
272
273 static void __storm_memset_dma_mapping(struct bnx2x *bp,
274                                        uint32_t addr, dma_addr_t mapping)
275 {
276         REG_WR(bp,  addr, U64_LO(mapping));
277         REG_WR(bp,  addr + 4, U64_HI(mapping));
278 }
279
280 static void storm_memset_spq_addr(struct bnx2x *bp,
281                                   dma_addr_t mapping, uint16_t abs_fid)
282 {
283         uint32_t addr = XSEM_REG_FAST_MEMORY +
284                         XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid);
285
286         __storm_memset_dma_mapping(bp, addr, mapping);
287 }
288
289 static void storm_memset_vf_to_pf(struct bnx2x *bp, uint16_t abs_fid,
290                                   uint16_t pf_id)
291 {
292         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid),
293                 pf_id);
294         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid),
295                 pf_id);
296         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid),
297                 pf_id);
298         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid),
299                 pf_id);
300 }
301
302 static void storm_memset_func_en(struct bnx2x *bp, uint16_t abs_fid,
303                                  uint8_t enable)
304 {
305         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid),
306                 enable);
307         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid),
308                 enable);
309         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid),
310                 enable);
311         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid),
312                 enable);
313 }
314
315 static void storm_memset_eq_data(struct bnx2x *bp,
316                                  struct event_ring_data *eq_data,
317                                 uint16_t pfid)
318 {
319         size_t size = sizeof(struct event_ring_data);
320
321         uint32_t addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_DATA_OFFSET(pfid);
322
323         __storm_memset_struct(bp, addr, size, (uint32_t *)eq_data);
324 }
325
326 static void storm_memset_eq_prod(struct bnx2x *bp, uint16_t eq_prod,
327                                  uint16_t pfid)
328 {
329         uint32_t addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_PROD_OFFSET(pfid);
330         REG_WR16(bp, addr, eq_prod);
331 }
332
333 /* used only at init
334  * locking is done by mcp
335  */
336 static void bnx2x_reg_wr_ind(struct bnx2x *bp, uint32_t addr, uint32_t val)
337 {
338         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
339         pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
340         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
341                                PCICFG_VENDOR_ID_OFFSET);
342 }
343
344 static uint32_t bnx2x_reg_rd_ind(struct bnx2x *bp, uint32_t addr)
345 {
346         uint32_t val;
347
348         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
349         pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
350         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
351                                PCICFG_VENDOR_ID_OFFSET);
352
353         return val;
354 }
355
356 #define DMAE_DP_SRC_GRC         "grc src_addr [%08x]"
357 #define DMAE_DP_SRC_PCI         "pci src_addr [%x:%08x]"
358 #define DMAE_DP_DST_GRC         "grc dst_addr [%08x]"
359 #define DMAE_DP_DST_PCI         "pci dst_addr [%x:%08x]"
360 #define DMAE_DP_DST_NONE        "dst_addr [none]"
361
362 static void bnx2x_dp_dmae(struct bnx2x *bp,
363                           struct dmae_command *dmae, int msglvl)
364 {
365         uint32_t src_type = dmae->opcode & DMAE_COMMAND_SRC;
366         int i;
367
368         switch (dmae->opcode & DMAE_COMMAND_DST) {
369         case DMAE_CMD_DST_PCI:
370                 if (src_type == DMAE_CMD_SRC_PCI)
371                         DP(msglvl, "DMAE: opcode 0x%08x\n"
372                            "src [%x:%08x], len [%d*4], dst [%x:%08x]\n"
373                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
374                            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
375                            dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
376                            dmae->comp_addr_hi, dmae->comp_addr_lo,
377                            dmae->comp_val);
378                 else
379                         DP(msglvl, "DMAE: opcode 0x%08x\n"
380                            "src [%08x], len [%d*4], dst [%x:%08x]\n"
381                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
382                            dmae->opcode, dmae->src_addr_lo >> 2,
383                            dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
384                            dmae->comp_addr_hi, dmae->comp_addr_lo,
385                            dmae->comp_val);
386                 break;
387         case DMAE_CMD_DST_GRC:
388                 if (src_type == DMAE_CMD_SRC_PCI)
389                         DP(msglvl, "DMAE: opcode 0x%08x\n"
390                            "src [%x:%08x], len [%d*4], dst_addr [%08x]\n"
391                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
392                            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
393                            dmae->len, dmae->dst_addr_lo >> 2,
394                            dmae->comp_addr_hi, dmae->comp_addr_lo,
395                            dmae->comp_val);
396                 else
397                         DP(msglvl, "DMAE: opcode 0x%08x\n"
398                            "src [%08x], len [%d*4], dst [%08x]\n"
399                            "comp_addr [%x:%08x], comp_val 0x%08x\n",
400                            dmae->opcode, dmae->src_addr_lo >> 2,
401                            dmae->len, dmae->dst_addr_lo >> 2,
402                            dmae->comp_addr_hi, dmae->comp_addr_lo,
403                            dmae->comp_val);
404                 break;
405         default:
406                 if (src_type == DMAE_CMD_SRC_PCI)
407                         DP(msglvl, "DMAE: opcode 0x%08x\n"
408                            "src_addr [%x:%08x]  len [%d * 4]  dst_addr [none]\n"
409                            "comp_addr [%x:%08x]  comp_val 0x%08x\n",
410                            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
411                            dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
412                            dmae->comp_val);
413                 else
414                         DP(msglvl, "DMAE: opcode 0x%08x\n"
415                            "src_addr [%08x]  len [%d * 4]  dst_addr [none]\n"
416                            "comp_addr [%x:%08x]  comp_val 0x%08x\n",
417                            dmae->opcode, dmae->src_addr_lo >> 2,
418                            dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
419                            dmae->comp_val);
420                 break;
421         }
422
423         for (i = 0; i < (sizeof(struct dmae_command)/4); i++)
424                 DP(msglvl, "DMAE RAW [%02d]: 0x%08x\n",
425                    i, *(((uint32_t *)dmae) + i));
426 }
427
428 /* copy command into DMAE command memory and set DMAE command go */
429 void bnx2x_post_dmae(struct bnx2x *bp, struct dmae_command *dmae, int idx)
430 {
431         uint32_t cmd_offset;
432         int i;
433
434         cmd_offset = (DMAE_REG_CMD_MEM + sizeof(struct dmae_command) * idx);
435         for (i = 0; i < (sizeof(struct dmae_command)/4); i++) {
436                 REG_WR(bp, cmd_offset + i*4, *(((uint32_t *)dmae) + i));
437         }
438         REG_WR(bp, dmae_reg_go_c[idx], 1);
439 }
440
441 uint32_t bnx2x_dmae_opcode_add_comp(uint32_t opcode, uint8_t comp_type)
442 {
443         return opcode | ((comp_type << DMAE_COMMAND_C_DST_SHIFT) |
444                            DMAE_CMD_C_ENABLE);
445 }
446
447 uint32_t bnx2x_dmae_opcode_clr_src_reset(uint32_t opcode)
448 {
449         return opcode & ~DMAE_CMD_SRC_RESET;
450 }
451
452 uint32_t bnx2x_dmae_opcode(struct bnx2x *bp, uint8_t src_type, uint8_t dst_type,
453                              bool with_comp, uint8_t comp_type)
454 {
455         uint32_t opcode = 0;
456
457         opcode |= ((src_type << DMAE_COMMAND_SRC_SHIFT) |
458                    (dst_type << DMAE_COMMAND_DST_SHIFT));
459
460         opcode |= (DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET);
461
462         opcode |= (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0);
463         opcode |= ((BP_VN(bp) << DMAE_CMD_E1HVN_SHIFT) |
464                    (BP_VN(bp) << DMAE_COMMAND_DST_VN_SHIFT));
465         opcode |= (DMAE_COM_SET_ERR << DMAE_COMMAND_ERR_POLICY_SHIFT);
466
467 #ifdef __BIG_ENDIAN
468         opcode |= DMAE_CMD_ENDIANITY_B_DW_SWAP;
469 #else
470         opcode |= DMAE_CMD_ENDIANITY_DW_SWAP;
471 #endif
472         if (with_comp)
473                 opcode = bnx2x_dmae_opcode_add_comp(opcode, comp_type);
474         return opcode;
475 }
476
477 void bnx2x_prep_dmae_with_comp(struct bnx2x *bp,
478                                       struct dmae_command *dmae,
479                                       uint8_t src_type, uint8_t dst_type)
480 {
481         memset(dmae, 0, sizeof(struct dmae_command));
482
483         /* set the opcode */
484         dmae->opcode = bnx2x_dmae_opcode(bp, src_type, dst_type,
485                                          true, DMAE_COMP_PCI);
486
487         /* fill in the completion parameters */
488         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
489         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
490         dmae->comp_val = DMAE_COMP_VAL;
491 }
492
493 /* issue a dmae command over the init-channel and wait for completion */
494 int bnx2x_issue_dmae_with_comp(struct bnx2x *bp, struct dmae_command *dmae,
495                                uint32_t *comp)
496 {
497         int cnt = CHIP_REV_IS_SLOW(bp) ? (400000) : 4000;
498         int rc = 0;
499
500         bnx2x_dp_dmae(bp, dmae, BNX2X_MSG_DMAE);
501
502         /* Lock the dmae channel. Disable BHs to prevent a dead-lock
503          * as long as this code is called both from syscall context and
504          * from ndo_set_rx_mode() flow that may be called from BH.
505          */
506
507         spin_lock(&bp->dmae_lock);
508
509         /* reset completion */
510         *comp = 0;
511
512         /* post the command on the channel used for initializations */
513         bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
514
515         /* wait for completion */
516         udelay(5);
517         while ((*comp & ~DMAE_PCI_ERR_FLAG) != DMAE_COMP_VAL) {
518
519                 if (!cnt ||
520                     (bp->recovery_state != BNX2X_RECOVERY_DONE &&
521                      bp->recovery_state != BNX2X_RECOVERY_NIC_LOADING)) {
522                         BNX2X_ERR("DMAE timeout!\n");
523                         rc = DMAE_TIMEOUT;
524                         goto unlock;
525                 }
526                 cnt--;
527                 udelay(50);
528         }
529         if (*comp & DMAE_PCI_ERR_FLAG) {
530                 BNX2X_ERR("DMAE PCI error!\n");
531                 rc = DMAE_PCI_ERROR;
532         }
533
534 unlock:
535
536         spin_unlock(&bp->dmae_lock);
537
538         return rc;
539 }
540
541 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr,
542                       uint32_t dst_addr,
543                       uint32_t len32)
544 {
545         int rc;
546         struct dmae_command dmae;
547
548         if (!bp->dmae_ready) {
549                 uint32_t *data = bnx2x_sp(bp, wb_data[0]);
550
551                 if (CHIP_IS_E1(bp))
552                         bnx2x_init_ind_wr(bp, dst_addr, data, len32);
553                 else
554                         bnx2x_init_str_wr(bp, dst_addr, data, len32);
555                 return;
556         }
557
558         /* set opcode and fixed command fields */
559         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_GRC);
560
561         /* fill in addresses and len */
562         dmae.src_addr_lo = U64_LO(dma_addr);
563         dmae.src_addr_hi = U64_HI(dma_addr);
564         dmae.dst_addr_lo = dst_addr >> 2;
565         dmae.dst_addr_hi = 0;
566         dmae.len = len32;
567
568         /* issue the command and wait for completion */
569         rc = bnx2x_issue_dmae_with_comp(bp, &dmae, bnx2x_sp(bp, wb_comp));
570         if (rc) {
571                 BNX2X_ERR("DMAE returned failure %d\n", rc);
572 #ifdef BNX2X_STOP_ON_ERROR
573                 bnx2x_panic();
574 #endif
575         }
576 }
577
578 void bnx2x_read_dmae(struct bnx2x *bp, uint32_t src_addr, uint32_t len32)
579 {
580         int rc;
581         struct dmae_command dmae;
582
583         if (!bp->dmae_ready) {
584                 uint32_t *data = bnx2x_sp(bp, wb_data[0]);
585                 int i;
586
587                 if (CHIP_IS_E1(bp))
588                         for (i = 0; i < len32; i++)
589                                 data[i] = bnx2x_reg_rd_ind(bp, src_addr + i*4);
590                 else
591                         for (i = 0; i < len32; i++)
592                                 data[i] = REG_RD(bp, src_addr + i*4);
593
594                 return;
595         }
596
597         /* set opcode and fixed command fields */
598         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_GRC, DMAE_DST_PCI);
599
600         /* fill in addresses and len */
601         dmae.src_addr_lo = src_addr >> 2;
602         dmae.src_addr_hi = 0;
603         dmae.dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_data));
604         dmae.dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_data));
605         dmae.len = len32;
606
607         /* issue the command and wait for completion */
608         rc = bnx2x_issue_dmae_with_comp(bp, &dmae, bnx2x_sp(bp, wb_comp));
609         if (rc) {
610                 BNX2X_ERR("DMAE returned failure %d\n", rc);
611 #ifdef BNX2X_STOP_ON_ERROR
612                 bnx2x_panic();
613 #endif
614         }
615 }
616
617 static void bnx2x_write_dmae_phys_len(struct bnx2x *bp, dma_addr_t phys_addr,
618                                       uint32_t addr, uint32_t len)
619 {
620         int dmae_wr_max = DMAE_LEN32_WR_MAX(bp);
621         int offset = 0;
622
623         while (len > dmae_wr_max) {
624                 bnx2x_write_dmae(bp, phys_addr + offset,
625                                  addr + offset, dmae_wr_max);
626                 offset += dmae_wr_max * 4;
627                 len -= dmae_wr_max;
628         }
629
630         bnx2x_write_dmae(bp, phys_addr + offset, addr + offset, len);
631 }
632
633 enum storms {
634            XSTORM,
635            TSTORM,
636            CSTORM,
637            USTORM,
638            MAX_STORMS
639 };
640
641 #define STORMS_NUM 4
642 #define REGS_IN_ENTRY 4
643
644 static inline int bnx2x_get_assert_list_entry(struct bnx2x *bp,
645                                               enum storms storm,
646                                               int entry)
647 {
648         switch (storm) {
649         case XSTORM:
650                 return XSTORM_ASSERT_LIST_OFFSET(entry);
651         case TSTORM:
652                 return TSTORM_ASSERT_LIST_OFFSET(entry);
653         case CSTORM:
654                 return CSTORM_ASSERT_LIST_OFFSET(entry);
655         case USTORM:
656                 return USTORM_ASSERT_LIST_OFFSET(entry);
657         case MAX_STORMS:
658         default:
659                 BNX2X_ERR("unknown storm\n");
660         }
661         return -EINVAL;
662 }
663
664 static int bnx2x_mc_assert(struct bnx2x *bp)
665 {
666         char last_idx;
667         int i, j, rc = 0;
668         enum storms storm;
669         uint32_t regs[REGS_IN_ENTRY];
670         uint32_t bar_storm_intmem[STORMS_NUM] = {
671                 BAR_XSTRORM_INTMEM,
672                 BAR_TSTRORM_INTMEM,
673                 BAR_CSTRORM_INTMEM,
674                 BAR_USTRORM_INTMEM
675         };
676         uint32_t storm_assert_list_index[STORMS_NUM] = {
677                 XSTORM_ASSERT_LIST_INDEX_OFFSET,
678                 TSTORM_ASSERT_LIST_INDEX_OFFSET,
679                 CSTORM_ASSERT_LIST_INDEX_OFFSET,
680                 USTORM_ASSERT_LIST_INDEX_OFFSET
681         };
682         char *storms_string[STORMS_NUM] = {
683                 "XSTORM",
684                 "TSTORM",
685                 "CSTORM",
686                 "USTORM"
687         };
688
689         for (storm = XSTORM; storm < MAX_STORMS; storm++) {
690                 last_idx = REG_RD8(bp, bar_storm_intmem[storm] +
691                                    storm_assert_list_index[storm]);
692                 if (last_idx)
693                         BNX2X_ERR("%s_ASSERT_LIST_INDEX 0x%x\n",
694                                   storms_string[storm], last_idx);
695
696                 /* print the asserts */
697                 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
698                         /* read a single assert entry */
699                         for (j = 0; j < REGS_IN_ENTRY; j++)
700                                 regs[j] = REG_RD(bp, bar_storm_intmem[storm] +
701                                           bnx2x_get_assert_list_entry(bp,
702                                                                       storm,
703                                                                       i) +
704                                           sizeof(uint32_t) * j);
705
706                         /* log entry if it contains a valid assert */
707                         if (regs[0] != COMMON_ASM_INVALID_ASSERT_OPCODE) {
708                                 BNX2X_ERR("%s_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x\n",
709                                           storms_string[storm], i, regs[3],
710                                           regs[2], regs[1], regs[0]);
711                                 rc++;
712                         } else {
713                                 break;
714                         }
715                 }
716         }
717
718         BNX2X_ERR("Chip Revision: %s, FW Version: %d_%d_%d\n",
719                   CHIP_IS_E1(bp) ? "everest1" :
720                   CHIP_IS_E1H(bp) ? "everest1h" :
721                   CHIP_IS_E2(bp) ? "everest2" : "everest3",
722                   BCM_5710_FW_MAJOR_VERSION,
723                   BCM_5710_FW_MINOR_VERSION,
724                   BCM_5710_FW_REVISION_VERSION);
725
726         return rc;
727 }
728
729 #define MCPR_TRACE_BUFFER_SIZE  (0x800)
730 #define SCRATCH_BUFFER_SIZE(bp) \
731         (CHIP_IS_E1(bp) ? 0x10000 : (CHIP_IS_E1H(bp) ? 0x20000 : 0x28000))
732
733 void bnx2x_fw_dump_lvl(struct bnx2x *bp, const char *lvl)
734 {
735         uint32_t addr, val;
736         uint32_t mark, offset;
737         __be32 data[9];
738         int word;
739         uint32_t trace_shmem_base;
740         if (BP_NOMCP(bp)) {
741                 BNX2X_ERR("NO MCP - can not dump\n");
742                 return;
743         }
744         netdev_printk(lvl, bp->dev, "bc %d.%d.%d\n",
745                 (bp->common.bc_ver & 0xff0000) >> 16,
746                 (bp->common.bc_ver & 0xff00) >> 8,
747                 (bp->common.bc_ver & 0xff));
748
749         val = REG_RD(bp, MCP_REG_MCPR_CPU_PROGRAM_COUNTER);
750         if (val == REG_RD(bp, MCP_REG_MCPR_CPU_PROGRAM_COUNTER))
751                 BNX2X_ERR("%s" "MCP PC at 0x%x\n", lvl, val);
752
753         if (BP_PATH(bp) == 0)
754                 trace_shmem_base = bp->common.shmem_base;
755         else
756                 trace_shmem_base = SHMEM2_RD(bp, other_shmem_base_addr);
757
758         /* sanity */
759         if (trace_shmem_base < MCPR_SCRATCH_BASE(bp) + MCPR_TRACE_BUFFER_SIZE ||
760             trace_shmem_base >= MCPR_SCRATCH_BASE(bp) +
761                                 SCRATCH_BUFFER_SIZE(bp)) {
762                 BNX2X_ERR("Unable to dump trace buffer (mark %x)\n",
763                           trace_shmem_base);
764                 return;
765         }
766
767         addr = trace_shmem_base - MCPR_TRACE_BUFFER_SIZE;
768
769         /* validate TRCB signature */
770         mark = REG_RD(bp, addr);
771         if (mark != MFW_TRACE_SIGNATURE) {
772                 BNX2X_ERR("Trace buffer signature is missing.");
773                 return ;
774         }
775
776         /* read cyclic buffer pointer */
777         addr += 4;
778         mark = REG_RD(bp, addr);
779         mark = MCPR_SCRATCH_BASE(bp) + ((mark + 0x3) & ~0x3) - 0x08000000;
780         if (mark >= trace_shmem_base || mark < addr + 4) {
781                 BNX2X_ERR("Mark doesn't fall inside Trace Buffer\n");
782                 return;
783         }
784         printk("%s" "begin fw dump (mark 0x%x)\n", lvl, mark);
785
786         printk("%s", lvl);
787
788         /* dump buffer after the mark */
789         for (offset = mark; offset < trace_shmem_base; offset += 0x8*4) {
790                 for (word = 0; word < 8; word++)
791                         data[word] = cpu_to_be32(REG_RD(bp,
792                                                  offset + 4 * word));
793                 data[8] = 0x0;
794                 pr_cont("%s", (char *)data);
795         }
796
797         /* dump buffer before the mark */
798         for (offset = addr + 4; offset <= mark; offset += 0x8*4) {
799                 for (word = 0; word < 8; word++)
800                         data[word] = cpu_to_be32(REG_RD(bp,
801                                                  offset + 4 * word));
802                 data[8] = 0x0;
803                 pr_cont("%s", (char *)data);
804         }
805         printk("%s" "end of fw dump\n", lvl);
806 }
807
808 static void bnx2x_fw_dump(struct bnx2x *bp)
809 {
810         bnx2x_fw_dump_lvl(bp, KERN_ERR);
811 }
812
813 static void bnx2x_hc_int_disable(struct bnx2x *bp)
814 {
815         int port = BP_PORT(bp);
816         uint32_t addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
817         uint32_t val = REG_RD(bp, addr);
818
819         /* in E1 we must use only PCI configuration space to disable
820          * MSI/MSIX capability
821          * It's forbidden to disable IGU_PF_CONF_MSI_MSIX_EN in HC block
822          */
823         if (CHIP_IS_E1(bp)) {
824                 /* Since IGU_PF_CONF_MSI_MSIX_EN still always on
825                  * Use mask register to prevent from HC sending interrupts
826                  * after we exit the function
827                  */
828                 REG_WR(bp, HC_REG_INT_MASK + port*4, 0);
829
830                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
831                          HC_CONFIG_0_REG_INT_LINE_EN_0 |
832                          HC_CONFIG_0_REG_ATTN_BIT_EN_0);
833         } else
834                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
835                          HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
836                          HC_CONFIG_0_REG_INT_LINE_EN_0 |
837                          HC_CONFIG_0_REG_ATTN_BIT_EN_0);
838
839         DP(NETIF_MSG_IFDOWN,
840            "write %x to HC %d (addr 0x%x)\n",
841            val, port, addr);
842
843         /* flush all outstanding writes */
844         bus_wmb();
845
846         REG_WR(bp, addr, val);
847         if (REG_RD(bp, addr) != val)
848                 BNX2X_ERR("BUG! Proper val not read from IGU!\n");
849 }
850
851 static void bnx2x_igu_int_disable(struct bnx2x *bp)
852 {
853         uint32_t val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
854
855         val &= ~(IGU_PF_CONF_MSI_MSIX_EN |
856                  IGU_PF_CONF_INT_LINE_EN |
857                  IGU_PF_CONF_ATTN_BIT_EN);
858
859         DP(NETIF_MSG_IFDOWN, "write %x to IGU\n", val);
860
861         /* flush all outstanding writes */
862         bus_wmb();
863
864         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
865         if (REG_RD(bp, IGU_REG_PF_CONFIGURATION) != val)
866                 BNX2X_ERR("BUG! Proper val not read from IGU!\n");
867 }
868
869 static void bnx2x_int_disable(struct bnx2x *bp)
870 {
871         if (bp->common.int_block == INT_BLOCK_HC)
872                 bnx2x_hc_int_disable(bp);
873         else
874                 bnx2x_igu_int_disable(bp);
875 }
876
877 void bnx2x_panic_dump(struct bnx2x *bp, bool disable_int)
878 {
879         int i;
880         uint16_t j;
881         struct hc_sp_status_block_data sp_sb_data;
882         int func = BP_FUNC(bp);
883 #ifdef BNX2X_STOP_ON_ERROR
884         uint16_t start = 0, end = 0;
885         uint8_t cos;
886 #endif
887         if (IS_PF(bp) && disable_int)
888                 bnx2x_int_disable(bp);
889
890         bp->stats_state = STATS_STATE_DISABLED;
891         bp->eth_stats.unrecoverable_error++;
892         DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
893
894         BNX2X_ERR("begin crash dump -----------------\n");
895
896         /* Indices */
897         /* Common */
898         if (IS_PF(bp)) {
899                 struct host_sp_status_block *def_sb = bp->def_status_blk;
900                 int data_size, cstorm_offset;
901
902                 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",
903                           bp->def_idx, bp->def_att_idx, bp->attn_state,
904                           bp->spq_prod_idx, bp->stats_counter);
905                 BNX2X_ERR("DSB: attn bits(0x%x)  ack(0x%x)  id(0x%x)  idx(0x%x)\n",
906                           def_sb->atten_status_block.attn_bits,
907                           def_sb->atten_status_block.attn_bits_ack,
908                           def_sb->atten_status_block.status_block_id,
909                           def_sb->atten_status_block.attn_bits_index);
910                 BNX2X_ERR("     def (");
911                 for (i = 0; i < HC_SP_SB_MAX_INDICES; i++)
912                         pr_cont("0x%x%s",
913                                 def_sb->sp_sb.index_values[i],
914                                 (i == HC_SP_SB_MAX_INDICES - 1) ? ")  " : " ");
915
916                 data_size = sizeof(struct hc_sp_status_block_data) /
917                             sizeof(uint32_t);
918                 cstorm_offset = CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func);
919                 for (i = 0; i < data_size; i++)
920                         *((uint32_t *)&sp_sb_data + i) =
921                                 REG_RD(bp, BAR_CSTRORM_INTMEM + cstorm_offset +
922                                            i * sizeof(uint32_t));
923
924                 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",
925                         sp_sb_data.igu_sb_id,
926                         sp_sb_data.igu_seg_id,
927                         sp_sb_data.p_func.pf_id,
928                         sp_sb_data.p_func.vnic_id,
929                         sp_sb_data.p_func.vf_id,
930                         sp_sb_data.p_func.vf_valid,
931                         sp_sb_data.state);
932         }
933
934         for_each_eth_queue(bp, i) {
935                 struct bnx2x_fastpath *fp = &bp->fp[i];
936                 int loop;
937                 struct hc_status_block_data_e2 sb_data_e2;
938                 struct hc_status_block_data_e1x sb_data_e1x;
939                 struct hc_status_block_sm  *hc_sm_p =
940                         CHIP_IS_E1x(bp) ?
941                         sb_data_e1x.common.state_machine :
942                         sb_data_e2.common.state_machine;
943                 struct hc_index_data *hc_index_p =
944                         CHIP_IS_E1x(bp) ?
945                         sb_data_e1x.index_data :
946                         sb_data_e2.index_data;
947                 uint8_t data_size, cos;
948                 uint32_t *sb_data_p;
949                 struct bnx2x_fp_txdata txdata;
950
951                 if (!bp->fp)
952                         break;
953
954                 if (!fp->rx_cons_sb)
955                         continue;
956
957                 /* Rx */
958                 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",
959                           i, fp->rx_bd_prod, fp->rx_bd_cons,
960                           fp->rx_comp_prod,
961                           fp->rx_comp_cons, le16_to_cpu(*fp->rx_cons_sb));
962                 BNX2X_ERR("     rx_sge_prod(0x%x)  last_max_sge(0x%x)  fp_hc_idx(0x%x)\n",
963                           fp->rx_sge_prod, fp->last_max_sge,
964                           le16_to_cpu(fp->fp_hc_idx));
965
966                 /* Tx */
967                 for_each_cos_in_tx_queue(fp, cos)
968                 {
969                         if (!fp->txdata_ptr[cos])
970                                 break;
971
972                         txdata = *fp->txdata_ptr[cos];
973
974                         if (!txdata.tx_cons_sb)
975                                 continue;
976
977                         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",
978                                   i, txdata.tx_pkt_prod,
979                                   txdata.tx_pkt_cons, txdata.tx_bd_prod,
980                                   txdata.tx_bd_cons,
981                                   le16_to_cpu(*txdata.tx_cons_sb));
982                 }
983
984                 loop = CHIP_IS_E1x(bp) ?
985                         HC_SB_MAX_INDICES_E1X : HC_SB_MAX_INDICES_E2;
986
987                 /* host sb data */
988
989                 if (IS_FCOE_FP(fp))
990                         continue;
991
992                 BNX2X_ERR("     run indexes (");
993                 for (j = 0; j < HC_SB_MAX_SM; j++)
994                         pr_cont("0x%x%s",
995                                fp->sb_running_index[j],
996                                (j == HC_SB_MAX_SM - 1) ? ")" : " ");
997
998                 BNX2X_ERR("     indexes (");
999                 for (j = 0; j < loop; j++)
1000                         pr_cont("0x%x%s",
1001                                fp->sb_index_values[j],
1002                                (j == loop - 1) ? ")" : " ");
1003
1004                 /* VF cannot access FW refelection for status block */
1005                 if (IS_VF(bp))
1006                         continue;
1007
1008                 /* fw sb data */
1009                 data_size = CHIP_IS_E1x(bp) ?
1010                         sizeof(struct hc_status_block_data_e1x) :
1011                         sizeof(struct hc_status_block_data_e2);
1012                 data_size /= sizeof(uint32_t);
1013                 sb_data_p = CHIP_IS_E1x(bp) ?
1014                         (uint32_t *)&sb_data_e1x :
1015                         (uint32_t *)&sb_data_e2;
1016                 /* copy sb data in here */
1017                 for (j = 0; j < data_size; j++)
1018                         *(sb_data_p + j) = REG_RD(bp, BAR_CSTRORM_INTMEM +
1019                                 CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id) +
1020                                 j * sizeof(uint32_t));
1021
1022                 if (!CHIP_IS_E1x(bp)) {
1023                         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",
1024                                 sb_data_e2.common.p_func.pf_id,
1025                                 sb_data_e2.common.p_func.vf_id,
1026                                 sb_data_e2.common.p_func.vf_valid,
1027                                 sb_data_e2.common.p_func.vnic_id,
1028                                 sb_data_e2.common.same_igu_sb_1b,
1029                                 sb_data_e2.common.state);
1030                 } else {
1031                         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",
1032                                 sb_data_e1x.common.p_func.pf_id,
1033                                 sb_data_e1x.common.p_func.vf_id,
1034                                 sb_data_e1x.common.p_func.vf_valid,
1035                                 sb_data_e1x.common.p_func.vnic_id,
1036                                 sb_data_e1x.common.same_igu_sb_1b,
1037                                 sb_data_e1x.common.state);
1038                 }
1039
1040                 /* SB_SMs data */
1041                 for (j = 0; j < HC_SB_MAX_SM; j++) {
1042                         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",
1043                                 j, hc_sm_p[j].__flags,
1044                                 hc_sm_p[j].igu_sb_id,
1045                                 hc_sm_p[j].igu_seg_id,
1046                                 hc_sm_p[j].time_to_expire,
1047                                 hc_sm_p[j].timer_value);
1048                 }
1049
1050                 /* Indices data */
1051                 for (j = 0; j < loop; j++) {
1052                         pr_cont("INDEX[%d] flags (0x%x) timeout (0x%x)\n", j,
1053                                hc_index_p[j].flags,
1054                                hc_index_p[j].timeout);
1055                 }
1056         }
1057
1058 #ifdef BNX2X_STOP_ON_ERROR
1059         if (IS_PF(bp)) {
1060                 /* event queue */
1061                 BNX2X_ERR("eq cons %x prod %x\n", bp->eq_cons, bp->eq_prod);
1062                 for (i = 0; i < NUM_EQ_DESC; i++) {
1063                         uint32_t *data = (uint32_t *)&bp->eq_ring[i].message.data;
1064
1065                         BNX2X_ERR("event queue [%d]: header: opcode %d, error %d\n",
1066                                   i, bp->eq_ring[i].message.opcode,
1067                                   bp->eq_ring[i].message.error);
1068                         BNX2X_ERR("data: %x %x %x\n",
1069                                   data[0], data[1], data[2]);
1070                 }
1071         }
1072
1073         /* Rings */
1074         /* Rx */
1075         for_each_valid_rx_queue(bp, i) {
1076                 struct bnx2x_fastpath *fp = &bp->fp[i];
1077
1078                 if (!bp->fp)
1079                         break;
1080
1081                 if (!fp->rx_cons_sb)
1082                         continue;
1083
1084                 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
1085                 end = RX_BD(le16_to_cpu(*fp->rx_cons_sb) + 503);
1086                 for (j = start; j != end; j = RX_BD(j + 1)) {
1087                         uint32_t *rx_bd = (uint32_t *)&fp->rx_desc_ring[j];
1088                         struct sw_rx_bd *sw_bd = &fp->rx_buf_ring[j];
1089
1090                         BNX2X_ERR("fp%d: rx_bd[%x]=[%x:%x]  sw_bd=[%p]\n",
1091                                   i, j, rx_bd[1], rx_bd[0], sw_bd->data);
1092                 }
1093
1094                 start = RX_SGE(fp->rx_sge_prod);
1095                 end = RX_SGE(fp->last_max_sge);
1096                 for (j = start; j != end; j = RX_SGE(j + 1)) {
1097                         uint32_t *rx_sge = (uint32_t *)&fp->rx_sge_ring[j];
1098                         struct sw_rx_page *sw_page = &fp->rx_page_ring[j];
1099
1100                         BNX2X_ERR("fp%d: rx_sge[%x]=[%x:%x]  sw_page=[%p]\n",
1101                                   i, j, rx_sge[1], rx_sge[0], sw_page->page);
1102                 }
1103
1104                 start = RCQ_BD(fp->rx_comp_cons - 10);
1105                 end = RCQ_BD(fp->rx_comp_cons + 503);
1106                 for (j = start; j != end; j = RCQ_BD(j + 1)) {
1107                         uint32_t *cqe = (uint32_t *)&fp->rx_comp_ring[j];
1108
1109                         BNX2X_ERR("fp%d: cqe[%x]=[%x:%x:%x:%x]\n",
1110                                   i, j, cqe[0], cqe[1], cqe[2], cqe[3]);
1111                 }
1112         }
1113
1114         /* Tx */
1115         for_each_valid_tx_queue(bp, i) {
1116                 struct bnx2x_fastpath *fp = &bp->fp[i];
1117
1118                 if (!bp->fp)
1119                         break;
1120
1121                 for_each_cos_in_tx_queue(fp, cos) {
1122                         struct bnx2x_fp_txdata *txdata = fp->txdata_ptr[cos];
1123
1124                         if (!fp->txdata_ptr[cos])
1125                                 break;
1126
1127                         if (!txdata->tx_cons_sb)
1128                                 continue;
1129
1130                         start = TX_BD(le16_to_cpu(*txdata->tx_cons_sb) - 10);
1131                         end = TX_BD(le16_to_cpu(*txdata->tx_cons_sb) + 245);
1132                         for (j = start; j != end; j = TX_BD(j + 1)) {
1133                                 struct sw_tx_bd *sw_bd =
1134                                         &txdata->tx_buf_ring[j];
1135
1136                                 BNX2X_ERR("fp%d: txdata %d, packet[%x]=[%p,%x]\n",
1137                                           i, cos, j, sw_bd->skb,
1138                                           sw_bd->first_bd);
1139                         }
1140
1141                         start = TX_BD(txdata->tx_bd_cons - 10);
1142                         end = TX_BD(txdata->tx_bd_cons + 254);
1143                         for (j = start; j != end; j = TX_BD(j + 1)) {
1144                                 uint32_t *tx_bd = (uint32_t *)&txdata->tx_desc_ring[j];
1145
1146                                 BNX2X_ERR("fp%d: txdata %d, tx_bd[%x]=[%x:%x:%x:%x]\n",
1147                                           i, cos, j, tx_bd[0], tx_bd[1],
1148                                           tx_bd[2], tx_bd[3]);
1149                         }
1150                 }
1151         }
1152 #endif
1153         if (IS_PF(bp)) {
1154                 bnx2x_fw_dump(bp);
1155                 bnx2x_mc_assert(bp);
1156         }
1157         BNX2X_ERR("end crash dump -----------------\n");
1158 }
1159
1160 /*
1161  * FLR Support for E2
1162  *
1163  * bnx2x_pf_flr_clnup() is called during nic_load in the per function HW
1164  * initialization.
1165  */
1166 #define FLR_WAIT_USEC           10000   /* 10 milliseconds */
1167 #define FLR_WAIT_INTERVAL       50      /* usec */
1168 #define FLR_POLL_CNT            (FLR_WAIT_USEC/FLR_WAIT_INTERVAL) /* 200 */
1169
1170 struct pbf_pN_buf_regs {
1171         int pN;
1172         uint32_t init_crd;
1173         uint32_t crd;
1174         uint32_t crd_freed;
1175 };
1176
1177 struct pbf_pN_cmd_regs {
1178         int pN;
1179         uint32_t lines_occup;
1180         uint32_t lines_freed;
1181 };
1182
1183 static void bnx2x_pbf_pN_buf_flushed(struct bnx2x *bp,
1184                                      struct pbf_pN_buf_regs *regs,
1185                                      uint32_t poll_count)
1186 {
1187         uint32_t init_crd, crd, crd_start, crd_freed, crd_freed_start;
1188         uint32_t cur_cnt = poll_count;
1189
1190         crd_freed = crd_freed_start = REG_RD(bp, regs->crd_freed);
1191         crd = crd_start = REG_RD(bp, regs->crd);
1192         init_crd = REG_RD(bp, regs->init_crd);
1193
1194         DP(BNX2X_MSG_SP, "INIT CREDIT[%d] : %x\n", regs->pN, init_crd);
1195         DP(BNX2X_MSG_SP, "CREDIT[%d]      : s:%x\n", regs->pN, crd);
1196         DP(BNX2X_MSG_SP, "CREDIT_FREED[%d]: s:%x\n", regs->pN, crd_freed);
1197
1198         while ((crd != init_crd) && ((uint32_t)SUB_S32(crd_freed, crd_freed_start) <
1199                (init_crd - crd_start))) {
1200                 if (cur_cnt--) {
1201                         udelay(FLR_WAIT_INTERVAL);
1202                         crd = REG_RD(bp, regs->crd);
1203                         crd_freed = REG_RD(bp, regs->crd_freed);
1204                 } else {
1205                         DP(BNX2X_MSG_SP, "PBF tx buffer[%d] timed out\n",
1206                            regs->pN);
1207                         DP(BNX2X_MSG_SP, "CREDIT[%d]      : c:%x\n",
1208                            regs->pN, crd);
1209                         DP(BNX2X_MSG_SP, "CREDIT_FREED[%d]: c:%x\n",
1210                            regs->pN, crd_freed);
1211                         break;
1212                 }
1213         }
1214         DP(BNX2X_MSG_SP, "Waited %d*%d usec for PBF tx buffer[%d]\n",
1215            poll_count-cur_cnt, FLR_WAIT_INTERVAL, regs->pN);
1216 }
1217
1218 static void bnx2x_pbf_pN_cmd_flushed(struct bnx2x *bp,
1219                                      struct pbf_pN_cmd_regs *regs,
1220                                      uint32_t poll_count)
1221 {
1222         uint32_t occup, to_free, freed, freed_start;
1223         uint32_t cur_cnt = poll_count;
1224
1225         occup = to_free = REG_RD(bp, regs->lines_occup);
1226         freed = freed_start = REG_RD(bp, regs->lines_freed);
1227
1228         DP(BNX2X_MSG_SP, "OCCUPANCY[%d]   : s:%x\n", regs->pN, occup);
1229         DP(BNX2X_MSG_SP, "LINES_FREED[%d] : s:%x\n", regs->pN, freed);
1230
1231         while (occup && ((uint32_t)SUB_S32(freed, freed_start) < to_free)) {
1232                 if (cur_cnt--) {
1233                         udelay(FLR_WAIT_INTERVAL);
1234                         occup = REG_RD(bp, regs->lines_occup);
1235                         freed = REG_RD(bp, regs->lines_freed);
1236                 } else {
1237                         DP(BNX2X_MSG_SP, "PBF cmd queue[%d] timed out\n",
1238                            regs->pN);
1239                         DP(BNX2X_MSG_SP, "OCCUPANCY[%d]   : s:%x\n",
1240                            regs->pN, occup);
1241                         DP(BNX2X_MSG_SP, "LINES_FREED[%d] : s:%x\n",
1242                            regs->pN, freed);
1243                         break;
1244                 }
1245         }
1246         DP(BNX2X_MSG_SP, "Waited %d*%d usec for PBF cmd queue[%d]\n",
1247            poll_count-cur_cnt, FLR_WAIT_INTERVAL, regs->pN);
1248 }
1249
1250 static uint32_t bnx2x_flr_clnup_reg_poll(struct bnx2x *bp, uint32_t reg,
1251                                     uint32_t expected, uint32_t poll_count)
1252 {
1253         uint32_t cur_cnt = poll_count;
1254         uint32_t val;
1255
1256         while ((val = REG_RD(bp, reg)) != expected && cur_cnt--)
1257                 udelay(FLR_WAIT_INTERVAL);
1258
1259         return val;
1260 }
1261
1262 int bnx2x_flr_clnup_poll_hw_counter(struct bnx2x *bp, uint32_t reg,
1263                                     char *msg, uint32_t poll_cnt)
1264 {
1265         uint32_t val = bnx2x_flr_clnup_reg_poll(bp, reg, 0, poll_cnt);
1266         if (val != 0) {
1267                 BNX2X_ERR("%s usage count=%d\n", msg, val);
1268                 return 1;
1269         }
1270         return 0;
1271 }
1272
1273 /* Common routines with VF FLR cleanup */
1274 uint32_t bnx2x_flr_clnup_poll_count(struct bnx2x *bp)
1275 {
1276         /* adjust polling timeout */
1277         if (CHIP_REV_IS_EMUL(bp))
1278                 return FLR_POLL_CNT * 2000;
1279
1280         if (CHIP_REV_IS_FPGA(bp))
1281                 return FLR_POLL_CNT * 120;
1282
1283         return FLR_POLL_CNT;
1284 }
1285
1286 void bnx2x_tx_hw_flushed(struct bnx2x *bp, uint32_t poll_count)
1287 {
1288         struct pbf_pN_cmd_regs cmd_regs[] = {
1289                 {0, (CHIP_IS_E3B0(bp)) ?
1290                         PBF_REG_TQ_OCCUPANCY_Q0 :
1291                         PBF_REG_P0_TQ_OCCUPANCY,
1292                     (CHIP_IS_E3B0(bp)) ?
1293                         PBF_REG_TQ_LINES_FREED_CNT_Q0 :
1294                         PBF_REG_P0_TQ_LINES_FREED_CNT},
1295                 {1, (CHIP_IS_E3B0(bp)) ?
1296                         PBF_REG_TQ_OCCUPANCY_Q1 :
1297                         PBF_REG_P1_TQ_OCCUPANCY,
1298                     (CHIP_IS_E3B0(bp)) ?
1299                         PBF_REG_TQ_LINES_FREED_CNT_Q1 :
1300                         PBF_REG_P1_TQ_LINES_FREED_CNT},
1301                 {4, (CHIP_IS_E3B0(bp)) ?
1302                         PBF_REG_TQ_OCCUPANCY_LB_Q :
1303                         PBF_REG_P4_TQ_OCCUPANCY,
1304                     (CHIP_IS_E3B0(bp)) ?
1305                         PBF_REG_TQ_LINES_FREED_CNT_LB_Q :
1306                         PBF_REG_P4_TQ_LINES_FREED_CNT}
1307         };
1308
1309         struct pbf_pN_buf_regs buf_regs[] = {
1310                 {0, (CHIP_IS_E3B0(bp)) ?
1311                         PBF_REG_INIT_CRD_Q0 :
1312                         PBF_REG_P0_INIT_CRD ,
1313                     (CHIP_IS_E3B0(bp)) ?
1314                         PBF_REG_CREDIT_Q0 :
1315                         PBF_REG_P0_CREDIT,
1316                     (CHIP_IS_E3B0(bp)) ?
1317                         PBF_REG_INTERNAL_CRD_FREED_CNT_Q0 :
1318                         PBF_REG_P0_INTERNAL_CRD_FREED_CNT},
1319                 {1, (CHIP_IS_E3B0(bp)) ?
1320                         PBF_REG_INIT_CRD_Q1 :
1321                         PBF_REG_P1_INIT_CRD,
1322                     (CHIP_IS_E3B0(bp)) ?
1323                         PBF_REG_CREDIT_Q1 :
1324                         PBF_REG_P1_CREDIT,
1325                     (CHIP_IS_E3B0(bp)) ?
1326                         PBF_REG_INTERNAL_CRD_FREED_CNT_Q1 :
1327                         PBF_REG_P1_INTERNAL_CRD_FREED_CNT},
1328                 {4, (CHIP_IS_E3B0(bp)) ?
1329                         PBF_REG_INIT_CRD_LB_Q :
1330                         PBF_REG_P4_INIT_CRD,
1331                     (CHIP_IS_E3B0(bp)) ?
1332                         PBF_REG_CREDIT_LB_Q :
1333                         PBF_REG_P4_CREDIT,
1334                     (CHIP_IS_E3B0(bp)) ?
1335                         PBF_REG_INTERNAL_CRD_FREED_CNT_LB_Q :
1336                         PBF_REG_P4_INTERNAL_CRD_FREED_CNT},
1337         };
1338
1339         int i;
1340
1341         /* Verify the command queues are flushed P0, P1, P4 */
1342         for (i = 0; i < ARRAY_SIZE(cmd_regs); i++)
1343                 bnx2x_pbf_pN_cmd_flushed(bp, &cmd_regs[i], poll_count);
1344
1345         /* Verify the transmission buffers are flushed P0, P1, P4 */
1346         for (i = 0; i < ARRAY_SIZE(buf_regs); i++)
1347                 bnx2x_pbf_pN_buf_flushed(bp, &buf_regs[i], poll_count);
1348 }
1349
1350 #define OP_GEN_PARAM(param) \
1351         (((param) << SDM_OP_GEN_COMP_PARAM_SHIFT) & SDM_OP_GEN_COMP_PARAM)
1352
1353 #define OP_GEN_TYPE(type) \
1354         (((type) << SDM_OP_GEN_COMP_TYPE_SHIFT) & SDM_OP_GEN_COMP_TYPE)
1355
1356 #define OP_GEN_AGG_VECT(index) \
1357         (((index) << SDM_OP_GEN_AGG_VECT_IDX_SHIFT) & SDM_OP_GEN_AGG_VECT_IDX)
1358
1359 int bnx2x_send_final_clnup(struct bnx2x *bp, uint8_t clnup_func,
1360                            uint32_t poll_cnt)
1361 {
1362         uint32_t op_gen_command = 0;
1363         uint32_t comp_addr = BAR_CSTRORM_INTMEM +
1364                         CSTORM_FINAL_CLEANUP_COMPLETE_OFFSET(clnup_func);
1365         int ret = 0;
1366
1367         if (REG_RD(bp, comp_addr)) {
1368                 BNX2X_ERR("Cleanup complete was not 0 before sending\n");
1369                 return 1;
1370         }
1371
1372         op_gen_command |= OP_GEN_PARAM(XSTORM_AGG_INT_FINAL_CLEANUP_INDEX);
1373         op_gen_command |= OP_GEN_TYPE(XSTORM_AGG_INT_FINAL_CLEANUP_COMP_TYPE);
1374         op_gen_command |= OP_GEN_AGG_VECT(clnup_func);
1375         op_gen_command |= 1 << SDM_OP_GEN_AGG_VECT_IDX_VALID_SHIFT;
1376
1377         DP(BNX2X_MSG_SP, "sending FW Final cleanup\n");
1378         REG_WR(bp, XSDM_REG_OPERATION_GEN, op_gen_command);
1379
1380         if (bnx2x_flr_clnup_reg_poll(bp, comp_addr, 1, poll_cnt) != 1) {
1381                 BNX2X_ERR("FW final cleanup did not succeed\n");
1382                 DP(BNX2X_MSG_SP, "At timeout completion address contained %x\n",
1383                    (REG_RD(bp, comp_addr)));
1384                 bnx2x_panic();
1385                 return 1;
1386         }
1387         /* Zero completion for next FLR */
1388         REG_WR(bp, comp_addr, 0);
1389
1390         return ret;
1391 }
1392
1393 uint8_t bnx2x_is_pcie_pending(struct pci_device *dev)
1394 {
1395 panic("Not implemented");
1396 #if 0 // AKAROS_PORT
1397         uint16_t status;
1398
1399         pcie_capability_read_word(dev, PCI_EXP_DEVSTA, &status);
1400         return status & PCI_EXP_DEVSTA_TRPND;
1401 #endif
1402 }
1403
1404 /* PF FLR specific routines
1405 */
1406 static int bnx2x_poll_hw_usage_counters(struct bnx2x *bp, uint32_t poll_cnt)
1407 {
1408         /* wait for CFC PF usage-counter to zero (includes all the VFs) */
1409         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1410                         CFC_REG_NUM_LCIDS_INSIDE_PF,
1411                         "CFC PF usage counter timed out",
1412                         poll_cnt))
1413                 return 1;
1414
1415         /* Wait for DQ PF usage-counter to zero (until DQ cleanup) */
1416         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1417                         DORQ_REG_PF_USAGE_CNT,
1418                         "DQ PF usage counter timed out",
1419                         poll_cnt))
1420                 return 1;
1421
1422         /* Wait for QM PF usage-counter to zero (until DQ cleanup) */
1423         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1424                         QM_REG_PF_USG_CNT_0 + 4*BP_FUNC(bp),
1425                         "QM PF usage counter timed out",
1426                         poll_cnt))
1427                 return 1;
1428
1429         /* Wait for Timer PF usage-counters to zero (until DQ cleanup) */
1430         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1431                         TM_REG_LIN0_VNIC_UC + 4*BP_PORT(bp),
1432                         "Timers VNIC usage counter timed out",
1433                         poll_cnt))
1434                 return 1;
1435         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1436                         TM_REG_LIN0_NUM_SCANS + 4*BP_PORT(bp),
1437                         "Timers NUM_SCANS usage counter timed out",
1438                         poll_cnt))
1439                 return 1;
1440
1441         /* Wait DMAE PF usage counter to zero */
1442         if (bnx2x_flr_clnup_poll_hw_counter(bp,
1443                         dmae_reg_go_c[INIT_DMAE_C(bp)],
1444                         "DMAE command register timed out",
1445                         poll_cnt))
1446                 return 1;
1447
1448         return 0;
1449 }
1450
1451 static void bnx2x_hw_enable_status(struct bnx2x *bp)
1452 {
1453         uint32_t val;
1454
1455         val = REG_RD(bp, CFC_REG_WEAK_ENABLE_PF);
1456         DP(BNX2X_MSG_SP, "CFC_REG_WEAK_ENABLE_PF is 0x%x\n", val);
1457
1458         val = REG_RD(bp, PBF_REG_DISABLE_PF);
1459         DP(BNX2X_MSG_SP, "PBF_REG_DISABLE_PF is 0x%x\n", val);
1460
1461         val = REG_RD(bp, IGU_REG_PCI_PF_MSI_EN);
1462         DP(BNX2X_MSG_SP, "IGU_REG_PCI_PF_MSI_EN is 0x%x\n", val);
1463
1464         val = REG_RD(bp, IGU_REG_PCI_PF_MSIX_EN);
1465         DP(BNX2X_MSG_SP, "IGU_REG_PCI_PF_MSIX_EN is 0x%x\n", val);
1466
1467         val = REG_RD(bp, IGU_REG_PCI_PF_MSIX_FUNC_MASK);
1468         DP(BNX2X_MSG_SP, "IGU_REG_PCI_PF_MSIX_FUNC_MASK is 0x%x\n", val);
1469
1470         val = REG_RD(bp, PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR);
1471         DP(BNX2X_MSG_SP, "PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR is 0x%x\n", val);
1472
1473         val = REG_RD(bp, PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR);
1474         DP(BNX2X_MSG_SP, "PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR is 0x%x\n", val);
1475
1476         val = REG_RD(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER);
1477         DP(BNX2X_MSG_SP, "PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER is 0x%x\n",
1478            val);
1479 }
1480
1481 static int bnx2x_pf_flr_clnup(struct bnx2x *bp)
1482 {
1483         uint32_t poll_cnt = bnx2x_flr_clnup_poll_count(bp);
1484
1485         DP(BNX2X_MSG_SP, "Cleanup after FLR PF[%d]\n", BP_ABS_FUNC(bp));
1486
1487         /* Re-enable PF target read access */
1488         REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_TARGET_READ, 1);
1489
1490         /* Poll HW usage counters */
1491         DP(BNX2X_MSG_SP, "Polling usage counters\n");
1492         if (bnx2x_poll_hw_usage_counters(bp, poll_cnt))
1493                 return -EBUSY;
1494
1495         /* Zero the igu 'trailing edge' and 'leading edge' */
1496
1497         /* Send the FW cleanup command */
1498         if (bnx2x_send_final_clnup(bp, (uint8_t)BP_FUNC(bp), poll_cnt))
1499                 return -EBUSY;
1500
1501         /* ATC cleanup */
1502
1503         /* Verify TX hw is flushed */
1504         bnx2x_tx_hw_flushed(bp, poll_cnt);
1505
1506         /* Wait 100ms (not adjusted according to platform) */
1507         kthread_usleep(1000 * 100);
1508
1509         /* Verify no pending pci transactions */
1510         if (bnx2x_is_pcie_pending(bp->pdev))
1511                 BNX2X_ERR("PCIE Transactions still pending\n");
1512
1513         /* Debug */
1514         bnx2x_hw_enable_status(bp);
1515
1516         /*
1517          * Master enable - Due to WB DMAE writes performed before this
1518          * register is re-initialized as part of the regular function init
1519          */
1520         REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
1521
1522         return 0;
1523 }
1524
1525 static void bnx2x_hc_int_enable(struct bnx2x *bp)
1526 {
1527         int port = BP_PORT(bp);
1528         uint32_t addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
1529         uint32_t val = REG_RD(bp, addr);
1530         bool msix = (bp->flags & USING_MSIX_FLAG) ? true : false;
1531         bool single_msix = (bp->flags & USING_SINGLE_MSIX_FLAG) ? true : false;
1532         bool msi = (bp->flags & USING_MSI_FLAG) ? true : false;
1533
1534         if (msix) {
1535                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1536                          HC_CONFIG_0_REG_INT_LINE_EN_0);
1537                 val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1538                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1539                 if (single_msix)
1540                         val |= HC_CONFIG_0_REG_SINGLE_ISR_EN_0;
1541         } else if (msi) {
1542                 val &= ~HC_CONFIG_0_REG_INT_LINE_EN_0;
1543                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1544                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1545                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1546         } else {
1547                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1548                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1549                         HC_CONFIG_0_REG_INT_LINE_EN_0 |
1550                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1551
1552                 if (!CHIP_IS_E1(bp)) {
1553                         DP(NETIF_MSG_IFUP,
1554                            "write %x to HC %d (addr 0x%x)\n", val, port, addr);
1555
1556                         REG_WR(bp, addr, val);
1557
1558                         val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
1559                 }
1560         }
1561
1562         if (CHIP_IS_E1(bp))
1563                 REG_WR(bp, HC_REG_INT_MASK + port*4, 0x1FFFF);
1564
1565         DP(NETIF_MSG_IFUP,
1566            "write %x to HC %d (addr 0x%x) mode %s\n", val, port, addr,
1567            (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1568
1569         REG_WR(bp, addr, val);
1570         /*
1571          * Ensure that HC_CONFIG is written before leading/trailing edge config
1572          */
1573         bus_wmb();
1574         cmb();
1575
1576         if (!CHIP_IS_E1(bp)) {
1577                 /* init leading/trailing edge */
1578                 if (IS_MF(bp)) {
1579                         val = (0xee0f | (1 << (BP_VN(bp) + 4)));
1580                         if (bp->port.pmf)
1581                                 /* enable nig and gpio3 attention */
1582                                 val |= 0x1100;
1583                 } else
1584                         val = 0xffff;
1585
1586                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
1587                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
1588         }
1589
1590         /* Make sure that interrupts are indeed enabled from here on */
1591         bus_wmb();
1592 }
1593
1594 static void bnx2x_igu_int_enable(struct bnx2x *bp)
1595 {
1596 panic("Not implemented");
1597 #if 0 // AKAROS_PORT
1598         uint32_t val;
1599         bool msix = (bp->flags & USING_MSIX_FLAG) ? true : false;
1600         bool single_msix = (bp->flags & USING_SINGLE_MSIX_FLAG) ? true : false;
1601         bool msi = (bp->flags & USING_MSI_FLAG) ? true : false;
1602
1603         val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1604
1605         if (msix) {
1606                 val &= ~(IGU_PF_CONF_INT_LINE_EN |
1607                          IGU_PF_CONF_SINGLE_ISR_EN);
1608                 val |= (IGU_PF_CONF_MSI_MSIX_EN |
1609                         IGU_PF_CONF_ATTN_BIT_EN);
1610
1611                 if (single_msix)
1612                         val |= IGU_PF_CONF_SINGLE_ISR_EN;
1613         } else if (msi) {
1614                 val &= ~IGU_PF_CONF_INT_LINE_EN;
1615                 val |= (IGU_PF_CONF_MSI_MSIX_EN |
1616                         IGU_PF_CONF_ATTN_BIT_EN |
1617                         IGU_PF_CONF_SINGLE_ISR_EN);
1618         } else {
1619                 val &= ~IGU_PF_CONF_MSI_MSIX_EN;
1620                 val |= (IGU_PF_CONF_INT_LINE_EN |
1621                         IGU_PF_CONF_ATTN_BIT_EN |
1622                         IGU_PF_CONF_SINGLE_ISR_EN);
1623         }
1624
1625         /* Clean previous status - need to configure igu prior to ack*/
1626         if ((!msix) || single_msix) {
1627                 REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1628                 bnx2x_ack_int(bp);
1629         }
1630
1631         val |= IGU_PF_CONF_FUNC_EN;
1632
1633         DP(NETIF_MSG_IFUP, "write 0x%x to IGU  mode %s\n",
1634            val, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1635
1636         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1637
1638         if (val & IGU_PF_CONF_INT_LINE_EN)
1639                 pci_intx(bp->pdev, true);
1640
1641         cmb();
1642
1643         /* init leading/trailing edge */
1644         if (IS_MF(bp)) {
1645                 val = (0xee0f | (1 << (BP_VN(bp) + 4)));
1646                 if (bp->port.pmf)
1647                         /* enable nig and gpio3 attention */
1648                         val |= 0x1100;
1649         } else
1650                 val = 0xffff;
1651
1652         REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
1653         REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
1654
1655         /* Make sure that interrupts are indeed enabled from here on */
1656         bus_wmb();
1657 #endif
1658 }
1659
1660 void bnx2x_int_enable(struct bnx2x *bp)
1661 {
1662         if (bp->common.int_block == INT_BLOCK_HC)
1663                 bnx2x_hc_int_enable(bp);
1664         else
1665                 bnx2x_igu_int_enable(bp);
1666 }
1667
1668 void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
1669 {
1670         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1671         int i, offset;
1672
1673         if (disable_hw)
1674                 /* prevent the HW from sending interrupts */
1675                 bnx2x_int_disable(bp);
1676
1677         /* make sure all ISRs are done */
1678         if (msix) {
1679                 synchronize_irq(bp->msix_table[0].vector);
1680                 offset = 1;
1681                 if (CNIC_SUPPORT(bp))
1682                         offset++;
1683                 for_each_eth_queue(bp, i)
1684                         synchronize_irq(bp->msix_table[offset++].vector);
1685         } else
1686                 synchronize_irq(bp->pdev->irqline);
1687
1688         /* make sure sp_task is not running */
1689         cancel_delayed_work(&bp->sp_task);
1690         cancel_delayed_work(&bp->period_task);
1691         flush_workqueue(bnx2x_wq);
1692 }
1693
1694 /* fast path */
1695
1696 /*
1697  * General service functions
1698  */
1699
1700 /* Return true if succeeded to acquire the lock */
1701 static bool bnx2x_trylock_hw_lock(struct bnx2x *bp, uint32_t resource)
1702 {
1703         uint32_t lock_status;
1704         uint32_t resource_bit = (1 << resource);
1705         int func = BP_FUNC(bp);
1706         uint32_t hw_lock_control_reg;
1707
1708         DP(NETIF_MSG_HW | NETIF_MSG_IFUP,
1709            "Trying to take a lock on resource %d\n", resource);
1710
1711         /* Validating that the resource is within range */
1712         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1713                 DP(NETIF_MSG_HW | NETIF_MSG_IFUP,
1714                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1715                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1716                 return false;
1717         }
1718
1719         if (func <= 5)
1720                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1721         else
1722                 hw_lock_control_reg =
1723                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1724
1725         /* Try to acquire the lock */
1726         REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1727         lock_status = REG_RD(bp, hw_lock_control_reg);
1728         if (lock_status & resource_bit)
1729                 return true;
1730
1731         DP(NETIF_MSG_HW | NETIF_MSG_IFUP,
1732            "Failed to get a lock on resource %d\n", resource);
1733         return false;
1734 }
1735
1736 /**
1737  * bnx2x_get_leader_lock_resource - get the recovery leader resource id
1738  *
1739  * @bp: driver handle
1740  *
1741  * Returns the recovery leader resource id according to the engine this function
1742  * belongs to. Currently only only 2 engines is supported.
1743  */
1744 static int bnx2x_get_leader_lock_resource(struct bnx2x *bp)
1745 {
1746         if (BP_PATH(bp))
1747                 return HW_LOCK_RESOURCE_RECOVERY_LEADER_1;
1748         else
1749                 return HW_LOCK_RESOURCE_RECOVERY_LEADER_0;
1750 }
1751
1752 /**
1753  * bnx2x_trylock_leader_lock- try to acquire a leader lock.
1754  *
1755  * @bp: driver handle
1756  *
1757  * Tries to acquire a leader lock for current engine.
1758  */
1759 static bool bnx2x_trylock_leader_lock(struct bnx2x *bp)
1760 {
1761         return bnx2x_trylock_hw_lock(bp, bnx2x_get_leader_lock_resource(bp));
1762 }
1763
1764 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid, uint8_t err);
1765
1766 /* schedule the sp task and mark that interrupt occurred (runs from ISR) */
1767 static int bnx2x_schedule_sp_task(struct bnx2x *bp)
1768 {
1769         /* Set the interrupt occurred bit for the sp-task to recognize it
1770          * must ack the interrupt and transition according to the IGU
1771          * state machine.
1772          */
1773         atomic_set(&bp->interrupt_occurred, 1);
1774
1775         /* The sp_task must execute only after this bit
1776          * is set, otherwise we will get out of sync and miss all
1777          * further interrupts. Hence, the barrier.
1778          */
1779         wmb();
1780
1781         /* schedule sp_task to workqueue */
1782         return queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
1783 }
1784
1785 void bnx2x_sp_event(struct bnx2x_fastpath *fp, union eth_rx_cqe *rr_cqe)
1786 {
1787         struct bnx2x *bp = fp->bp;
1788         int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1789         int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1790         enum bnx2x_queue_cmd drv_cmd = BNX2X_Q_CMD_MAX;
1791         struct bnx2x_queue_sp_obj *q_obj = &bnx2x_sp_obj(bp, fp).q_obj;
1792
1793         DP(BNX2X_MSG_SP,
1794            "fp %d  cid %d  got ramrod #%d  state is %x  type is %d\n",
1795            fp->index, cid, command, bp->state,
1796            rr_cqe->ramrod_cqe.ramrod_type);
1797
1798         /* If cid is within VF range, replace the slowpath object with the
1799          * one corresponding to this VF
1800          */
1801         if (cid >= BNX2X_FIRST_VF_CID  &&
1802             cid < BNX2X_FIRST_VF_CID + BNX2X_VF_CIDS)
1803                 bnx2x_iov_set_queue_sp_obj(bp, cid, &q_obj);
1804
1805         switch (command) {
1806         case (RAMROD_CMD_ID_ETH_CLIENT_UPDATE):
1807                 DP(BNX2X_MSG_SP, "got UPDATE ramrod. CID %d\n", cid);
1808                 drv_cmd = BNX2X_Q_CMD_UPDATE;
1809                 break;
1810
1811         case (RAMROD_CMD_ID_ETH_CLIENT_SETUP):
1812                 DP(BNX2X_MSG_SP, "got MULTI[%d] setup ramrod\n", cid);
1813                 drv_cmd = BNX2X_Q_CMD_SETUP;
1814                 break;
1815
1816         case (RAMROD_CMD_ID_ETH_TX_QUEUE_SETUP):
1817                 DP(BNX2X_MSG_SP, "got MULTI[%d] tx-only setup ramrod\n", cid);
1818                 drv_cmd = BNX2X_Q_CMD_SETUP_TX_ONLY;
1819                 break;
1820
1821         case (RAMROD_CMD_ID_ETH_HALT):
1822                 DP(BNX2X_MSG_SP, "got MULTI[%d] halt ramrod\n", cid);
1823                 drv_cmd = BNX2X_Q_CMD_HALT;
1824                 break;
1825
1826         case (RAMROD_CMD_ID_ETH_TERMINATE):
1827                 DP(BNX2X_MSG_SP, "got MULTI[%d] terminate ramrod\n", cid);
1828                 drv_cmd = BNX2X_Q_CMD_TERMINATE;
1829                 break;
1830
1831         case (RAMROD_CMD_ID_ETH_EMPTY):
1832                 DP(BNX2X_MSG_SP, "got MULTI[%d] empty ramrod\n", cid);
1833                 drv_cmd = BNX2X_Q_CMD_EMPTY;
1834                 break;
1835
1836         case (RAMROD_CMD_ID_ETH_TPA_UPDATE):
1837                 DP(BNX2X_MSG_SP, "got tpa update ramrod CID=%d\n", cid);
1838                 drv_cmd = BNX2X_Q_CMD_UPDATE_TPA;
1839                 break;
1840
1841         default:
1842                 BNX2X_ERR("unexpected MC reply (%d) on fp[%d]\n",
1843                           command, fp->index);
1844                 return;
1845         }
1846
1847         if ((drv_cmd != BNX2X_Q_CMD_MAX) &&
1848             q_obj->complete_cmd(bp, q_obj, drv_cmd))
1849                 /* q_obj->complete_cmd() failure means that this was
1850                  * an unexpected completion.
1851                  *
1852                  * In this case we don't want to increase the bp->spq_left
1853                  * because apparently we haven't sent this command the first
1854                  * place.
1855                  */
1856 #ifdef BNX2X_STOP_ON_ERROR
1857                 bnx2x_panic();
1858 #else
1859                 return;
1860 #endif
1861
1862         cmb();
1863         atomic_inc(&bp->cq_spq_left);
1864         /* push the change in bp->spq_left and towards the memory */
1865         cmb();
1866
1867         DP(BNX2X_MSG_SP, "bp->cq_spq_left %x\n", atomic_read(&bp->cq_spq_left));
1868
1869         if ((drv_cmd == BNX2X_Q_CMD_UPDATE) && (IS_FCOE_FP(fp)) &&
1870             (!!test_bit(BNX2X_AFEX_FCOE_Q_UPDATE_PENDING, &bp->sp_state))) {
1871                 /* if Q update ramrod is completed for last Q in AFEX vif set
1872                  * flow, then ACK MCP at the end
1873                  *
1874                  * mark pending ACK to MCP bit.
1875                  * prevent case that both bits are cleared.
1876                  * At the end of load/unload driver checks that
1877                  * sp_state is cleared, and this order prevents
1878                  * races
1879                  */
1880                 cmb();
1881                 set_bit(BNX2X_AFEX_PENDING_VIFSET_MCP_ACK, &bp->sp_state);
1882                 wmb();
1883                 clear_bit(BNX2X_AFEX_FCOE_Q_UPDATE_PENDING, &bp->sp_state);
1884                 cmb();
1885
1886                 /* schedule the sp task as mcp ack is required */
1887                 bnx2x_schedule_sp_task(bp);
1888         }
1889
1890         return;
1891 }
1892
1893 void bnx2x_interrupt(struct hw_trapframe *hw_tf, void *dev_instance)
1894 {
1895 panic("Not implemented");
1896 #if 0 // AKAROS_PORT
1897         struct bnx2x *bp = netdev_priv(dev_instance);
1898         uint16_t status = bnx2x_ack_int(bp);
1899         uint16_t mask;
1900         int i;
1901         uint8_t cos;
1902
1903         /* Return here if interrupt is shared and it's not for us */
1904         if (unlikely(status == 0)) {
1905                 DP(NETIF_MSG_INTR, "not our interrupt!\n");
1906                 return;
1907         }
1908         DP(NETIF_MSG_INTR, "got an interrupt  status 0x%x\n", status);
1909
1910 #ifdef BNX2X_STOP_ON_ERROR
1911         if (unlikely(bp->panic))
1912                 return;
1913 #endif
1914
1915         for_each_eth_queue(bp, i) {
1916                 struct bnx2x_fastpath *fp = &bp->fp[i];
1917
1918                 mask = 0x2 << (fp->index + CNIC_SUPPORT(bp));
1919                 if (status & mask) {
1920                         /* Handle Rx or Tx according to SB id */
1921                         for_each_cos_in_tx_queue(fp, cos)
1922                                 prefetch(fp->txdata_ptr[cos]->tx_cons_sb);
1923                         prefetch(&fp->sb_running_index[SM_RX_ID]);
1924                         napi_schedule_irqoff(&bnx2x_fp(bp, fp->index, napi));
1925                         status &= ~mask;
1926                 }
1927         }
1928
1929         if (CNIC_SUPPORT(bp)) {
1930                 mask = 0x2;
1931                 if (status & (mask | 0x1)) {
1932                         struct cnic_ops *c_ops = NULL;
1933
1934                         rcu_read_lock();
1935                         c_ops = rcu_dereference(bp->cnic_ops);
1936                         if (c_ops && (bp->cnic_eth_dev.drv_state &
1937                                       CNIC_DRV_STATE_HANDLES_IRQ))
1938                                 c_ops->cnic_handler(bp->cnic_data, NULL);
1939                         rcu_read_unlock();
1940
1941                         status &= ~mask;
1942                 }
1943         }
1944
1945         if (unlikely(status & 0x1)) {
1946
1947                 /* schedule sp task to perform default status block work, ack
1948                  * attentions and enable interrupts.
1949                  */
1950                 bnx2x_schedule_sp_task(bp);
1951
1952                 status &= ~0x1;
1953                 if (!status)
1954                         return;
1955         }
1956
1957         if (unlikely(status))
1958                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
1959                    status);
1960
1961         return;
1962 #endif
1963 }
1964
1965 /* Link */
1966
1967 /*
1968  * General service functions
1969  */
1970
1971 int bnx2x_acquire_hw_lock(struct bnx2x *bp, uint32_t resource)
1972 {
1973         uint32_t lock_status;
1974         uint32_t resource_bit = (1 << resource);
1975         int func = BP_FUNC(bp);
1976         uint32_t hw_lock_control_reg;
1977         int cnt;
1978
1979         /* Validating that the resource is within range */
1980         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1981                 BNX2X_ERR("resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1982                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1983                 return -EINVAL;
1984         }
1985
1986         if (func <= 5) {
1987                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1988         } else {
1989                 hw_lock_control_reg =
1990                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1991         }
1992
1993         /* Validating that the resource is not already taken */
1994         lock_status = REG_RD(bp, hw_lock_control_reg);
1995         if (lock_status & resource_bit) {
1996                 BNX2X_ERR("lock_status 0x%x  resource_bit 0x%x\n",
1997                    lock_status, resource_bit);
1998                 return -EEXIST;
1999         }
2000
2001         /* Try for 5 second every 5ms */
2002         for (cnt = 0; cnt < 1000; cnt++) {
2003                 /* Try to acquire the lock */
2004                 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
2005                 lock_status = REG_RD(bp, hw_lock_control_reg);
2006                 if (lock_status & resource_bit)
2007                         return 0;
2008
2009                 kthread_usleep(5000);
2010         }
2011         BNX2X_ERR("Timeout\n");
2012         return -EAGAIN;
2013 }
2014
2015 int bnx2x_release_leader_lock(struct bnx2x *bp)
2016 {
2017         return bnx2x_release_hw_lock(bp, bnx2x_get_leader_lock_resource(bp));
2018 }
2019
2020 int bnx2x_release_hw_lock(struct bnx2x *bp, uint32_t resource)
2021 {
2022         uint32_t lock_status;
2023         uint32_t resource_bit = (1 << resource);
2024         int func = BP_FUNC(bp);
2025         uint32_t hw_lock_control_reg;
2026
2027         /* Validating that the resource is within range */
2028         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
2029                 BNX2X_ERR("resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
2030                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
2031                 return -EINVAL;
2032         }
2033
2034         if (func <= 5) {
2035                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
2036         } else {
2037                 hw_lock_control_reg =
2038                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
2039         }
2040
2041         /* Validating that the resource is currently taken */
2042         lock_status = REG_RD(bp, hw_lock_control_reg);
2043         if (!(lock_status & resource_bit)) {
2044                 BNX2X_ERR("lock_status 0x%x resource_bit 0x%x. Unlock was called but lock wasn't taken!\n",
2045                           lock_status, resource_bit);
2046                 return -EFAULT;
2047         }
2048
2049         REG_WR(bp, hw_lock_control_reg, resource_bit);
2050         return 0;
2051 }
2052
2053 int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, uint8_t port)
2054 {
2055         /* The GPIO should be swapped if swap register is set and active */
2056         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
2057                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
2058         int gpio_shift = gpio_num +
2059                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
2060         uint32_t gpio_mask = (1 << gpio_shift);
2061         uint32_t gpio_reg;
2062         int value;
2063
2064         if (gpio_num > MISC_REGISTERS_GPIO_3) {
2065                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
2066                 return -EINVAL;
2067         }
2068
2069         /* read GPIO value */
2070         gpio_reg = REG_RD(bp, MISC_REG_GPIO);
2071
2072         /* get the requested pin value */
2073         if ((gpio_reg & gpio_mask) == gpio_mask)
2074                 value = 1;
2075         else
2076                 value = 0;
2077
2078         return value;
2079 }
2080
2081 int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, uint32_t mode,
2082                    uint8_t port)
2083 {
2084         /* The GPIO should be swapped if swap register is set and active */
2085         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
2086                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
2087         int gpio_shift = gpio_num +
2088                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
2089         uint32_t gpio_mask = (1 << gpio_shift);
2090         uint32_t gpio_reg;
2091
2092         if (gpio_num > MISC_REGISTERS_GPIO_3) {
2093                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
2094                 return -EINVAL;
2095         }
2096
2097         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2098         /* read GPIO and mask except the float bits */
2099         gpio_reg = (REG_RD(bp, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
2100
2101         switch (mode) {
2102         case MISC_REGISTERS_GPIO_OUTPUT_LOW:
2103                 DP(NETIF_MSG_LINK,
2104                    "Set GPIO %d (shift %d) -> output low\n",
2105                    gpio_num, gpio_shift);
2106                 /* clear FLOAT and set CLR */
2107                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
2108                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
2109                 break;
2110
2111         case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
2112                 DP(NETIF_MSG_LINK,
2113                    "Set GPIO %d (shift %d) -> output high\n",
2114                    gpio_num, gpio_shift);
2115                 /* clear FLOAT and set SET */
2116                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
2117                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
2118                 break;
2119
2120         case MISC_REGISTERS_GPIO_INPUT_HI_Z:
2121                 DP(NETIF_MSG_LINK,
2122                    "Set GPIO %d (shift %d) -> input\n",
2123                    gpio_num, gpio_shift);
2124                 /* set FLOAT */
2125                 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
2126                 break;
2127
2128         default:
2129                 break;
2130         }
2131
2132         REG_WR(bp, MISC_REG_GPIO, gpio_reg);
2133         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2134
2135         return 0;
2136 }
2137
2138 int bnx2x_set_mult_gpio(struct bnx2x *bp, uint8_t pins, uint32_t mode)
2139 {
2140         uint32_t gpio_reg = 0;
2141         int rc = 0;
2142
2143         /* Any port swapping should be handled by caller. */
2144
2145         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2146         /* read GPIO and mask except the float bits */
2147         gpio_reg = REG_RD(bp, MISC_REG_GPIO);
2148         gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_FLOAT_POS);
2149         gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_CLR_POS);
2150         gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_SET_POS);
2151
2152         switch (mode) {
2153         case MISC_REGISTERS_GPIO_OUTPUT_LOW:
2154                 DP(NETIF_MSG_LINK, "Set GPIO 0x%x -> output low\n", pins);
2155                 /* set CLR */
2156                 gpio_reg |= (pins << MISC_REGISTERS_GPIO_CLR_POS);
2157                 break;
2158
2159         case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
2160                 DP(NETIF_MSG_LINK, "Set GPIO 0x%x -> output high\n", pins);
2161                 /* set SET */
2162                 gpio_reg |= (pins << MISC_REGISTERS_GPIO_SET_POS);
2163                 break;
2164
2165         case MISC_REGISTERS_GPIO_INPUT_HI_Z:
2166                 DP(NETIF_MSG_LINK, "Set GPIO 0x%x -> input\n", pins);
2167                 /* set FLOAT */
2168                 gpio_reg |= (pins << MISC_REGISTERS_GPIO_FLOAT_POS);
2169                 break;
2170
2171         default:
2172                 BNX2X_ERR("Invalid GPIO mode assignment %d\n", mode);
2173                 rc = -EINVAL;
2174                 break;
2175         }
2176
2177         if (rc == 0)
2178                 REG_WR(bp, MISC_REG_GPIO, gpio_reg);
2179
2180         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2181
2182         return rc;
2183 }
2184
2185 int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, uint32_t mode,
2186                        uint8_t port)
2187 {
2188         /* The GPIO should be swapped if swap register is set and active */
2189         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
2190                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
2191         int gpio_shift = gpio_num +
2192                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
2193         uint32_t gpio_mask = (1 << gpio_shift);
2194         uint32_t gpio_reg;
2195
2196         if (gpio_num > MISC_REGISTERS_GPIO_3) {
2197                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
2198                 return -EINVAL;
2199         }
2200
2201         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2202         /* read GPIO int */
2203         gpio_reg = REG_RD(bp, MISC_REG_GPIO_INT);
2204
2205         switch (mode) {
2206         case MISC_REGISTERS_GPIO_INT_OUTPUT_CLR:
2207                 DP(NETIF_MSG_LINK,
2208                    "Clear GPIO INT %d (shift %d) -> output low\n",
2209                    gpio_num, gpio_shift);
2210                 /* clear SET and set CLR */
2211                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
2212                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
2213                 break;
2214
2215         case MISC_REGISTERS_GPIO_INT_OUTPUT_SET:
2216                 DP(NETIF_MSG_LINK,
2217                    "Set GPIO INT %d (shift %d) -> output high\n",
2218                    gpio_num, gpio_shift);
2219                 /* clear CLR and set SET */
2220                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
2221                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
2222                 break;
2223
2224         default:
2225                 break;
2226         }
2227
2228         REG_WR(bp, MISC_REG_GPIO_INT, gpio_reg);
2229         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
2230
2231         return 0;
2232 }
2233
2234 static int bnx2x_set_spio(struct bnx2x *bp, int spio, uint32_t mode)
2235 {
2236         uint32_t spio_reg;
2237
2238         /* Only 2 SPIOs are configurable */
2239         if ((spio != MISC_SPIO_SPIO4) && (spio != MISC_SPIO_SPIO5)) {
2240                 BNX2X_ERR("Invalid SPIO 0x%x\n", spio);
2241                 return -EINVAL;
2242         }
2243
2244         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
2245         /* read SPIO and mask except the float bits */
2246         spio_reg = (REG_RD(bp, MISC_REG_SPIO) & MISC_SPIO_FLOAT);
2247
2248         switch (mode) {
2249         case MISC_SPIO_OUTPUT_LOW:
2250                 DP(NETIF_MSG_HW, "Set SPIO 0x%x -> output low\n", spio);
2251                 /* clear FLOAT and set CLR */
2252                 spio_reg &= ~(spio << MISC_SPIO_FLOAT_POS);
2253                 spio_reg |=  (spio << MISC_SPIO_CLR_POS);
2254                 break;
2255
2256         case MISC_SPIO_OUTPUT_HIGH:
2257                 DP(NETIF_MSG_HW, "Set SPIO 0x%x -> output high\n", spio);
2258                 /* clear FLOAT and set SET */
2259                 spio_reg &= ~(spio << MISC_SPIO_FLOAT_POS);
2260                 spio_reg |=  (spio << MISC_SPIO_SET_POS);
2261                 break;
2262
2263         case MISC_SPIO_INPUT_HI_Z:
2264                 DP(NETIF_MSG_HW, "Set SPIO 0x%x -> input\n", spio);
2265                 /* set FLOAT */
2266                 spio_reg |= (spio << MISC_SPIO_FLOAT_POS);
2267                 break;
2268
2269         default:
2270                 break;
2271         }
2272
2273         REG_WR(bp, MISC_REG_SPIO, spio_reg);
2274         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
2275
2276         return 0;
2277 }
2278
2279 void bnx2x_calc_fc_adv(struct bnx2x *bp)
2280 {
2281 panic("Not implemented");
2282 #if 0 // AKAROS_PORT
2283         uint8_t cfg_idx = bnx2x_get_link_cfg_idx(bp);
2284         switch (bp->link_vars.ieee_fc &
2285                 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
2286         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
2287                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
2288                                                    ADVERTISED_Pause);
2289                 break;
2290
2291         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
2292                 bp->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
2293                                                   ADVERTISED_Pause);
2294                 break;
2295
2296         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
2297                 bp->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
2298                 break;
2299
2300         default:
2301                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
2302                                                    ADVERTISED_Pause);
2303                 break;
2304         }
2305 #endif
2306 }
2307
2308 static void bnx2x_set_requested_fc(struct bnx2x *bp)
2309 {
2310         /* Initialize link parameters structure variables
2311          * It is recommended to turn off RX FC for jumbo frames
2312          *  for better performance
2313          */
2314         if (CHIP_IS_E1x(bp) && (bp->dev->maxmtu > 5000))
2315                 bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_TX;
2316         else
2317                 bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
2318 }
2319
2320 static void bnx2x_init_dropless_fc(struct bnx2x *bp)
2321 {
2322         uint32_t pause_enabled = 0;
2323
2324         if (!CHIP_IS_E1(bp) && bp->dropless_fc && bp->link_vars.link_up) {
2325                 if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
2326                         pause_enabled = 1;
2327
2328                 REG_WR(bp, BAR_USTRORM_INTMEM +
2329                            USTORM_ETH_PAUSE_ENABLED_OFFSET(BP_PORT(bp)),
2330                        pause_enabled);
2331         }
2332
2333         DP(NETIF_MSG_IFUP | NETIF_MSG_LINK, "dropless_fc is %s\n",
2334            pause_enabled ? "enabled" : "disabled");
2335 }
2336
2337 int bnx2x_initial_phy_init(struct bnx2x *bp, int load_mode)
2338 {
2339         int rc, cfx_idx = bnx2x_get_link_cfg_idx(bp);
2340         uint16_t req_line_speed = bp->link_params.req_line_speed[cfx_idx];
2341
2342         if (!BP_NOMCP(bp)) {
2343                 bnx2x_set_requested_fc(bp);
2344                 bnx2x_acquire_phy_lock(bp);
2345
2346                 if (load_mode == LOAD_DIAG) {
2347                         struct link_params *lp = &bp->link_params;
2348                         lp->loopback_mode = LOOPBACK_XGXS;
2349                         /* do PHY loopback at 10G speed, if possible */
2350                         if (lp->req_line_speed[cfx_idx] < SPEED_10000) {
2351                                 if (lp->speed_cap_mask[cfx_idx] &
2352                                     PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
2353                                         lp->req_line_speed[cfx_idx] =
2354                                         SPEED_10000;
2355                                 else
2356                                         lp->req_line_speed[cfx_idx] =
2357                                         SPEED_1000;
2358                         }
2359                 }
2360
2361                 if (load_mode == LOAD_LOOPBACK_EXT) {
2362                         struct link_params *lp = &bp->link_params;
2363                         lp->loopback_mode = LOOPBACK_EXT;
2364                 }
2365
2366                 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
2367
2368                 bnx2x_release_phy_lock(bp);
2369
2370                 bnx2x_init_dropless_fc(bp);
2371
2372                 bnx2x_calc_fc_adv(bp);
2373
2374                 if (bp->link_vars.link_up) {
2375                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2376                         bnx2x_link_report(bp);
2377                 }
2378                 queue_delayed_work(bnx2x_wq, &bp->period_task, 0);
2379                 bp->link_params.req_line_speed[cfx_idx] = req_line_speed;
2380                 return rc;
2381         }
2382         BNX2X_ERR("Bootcode is missing - can not initialize link\n");
2383         return -EINVAL;
2384 }
2385
2386 void bnx2x_link_set(struct bnx2x *bp)
2387 {
2388         if (!BP_NOMCP(bp)) {
2389                 bnx2x_acquire_phy_lock(bp);
2390                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
2391                 bnx2x_release_phy_lock(bp);
2392
2393                 bnx2x_init_dropless_fc(bp);
2394
2395                 bnx2x_calc_fc_adv(bp);
2396         } else
2397                 BNX2X_ERR("Bootcode is missing - can not set link\n");
2398 }
2399
2400 static void bnx2x__link_reset(struct bnx2x *bp)
2401 {
2402         if (!BP_NOMCP(bp)) {
2403                 bnx2x_acquire_phy_lock(bp);
2404                 bnx2x_lfa_reset(&bp->link_params, &bp->link_vars);
2405                 bnx2x_release_phy_lock(bp);
2406         } else
2407                 BNX2X_ERR("Bootcode is missing - can not reset link\n");
2408 }
2409
2410 void bnx2x_force_link_reset(struct bnx2x *bp)
2411 {
2412         bnx2x_acquire_phy_lock(bp);
2413         bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
2414         bnx2x_release_phy_lock(bp);
2415 }
2416
2417 uint8_t bnx2x_link_test(struct bnx2x *bp, uint8_t is_serdes)
2418 {
2419         uint8_t rc = 0;
2420
2421         if (!BP_NOMCP(bp)) {
2422                 bnx2x_acquire_phy_lock(bp);
2423                 rc = bnx2x_test_link(&bp->link_params, &bp->link_vars,
2424                                      is_serdes);
2425                 bnx2x_release_phy_lock(bp);
2426         } else
2427                 BNX2X_ERR("Bootcode is missing - can not test link\n");
2428
2429         return rc;
2430 }
2431
2432 /* Calculates the sum of vn_min_rates.
2433    It's needed for further normalizing of the min_rates.
2434    Returns:
2435      sum of vn_min_rates.
2436        or
2437      0 - if all the min_rates are 0.
2438      In the later case fairness algorithm should be deactivated.
2439      If not all min_rates are zero then those that are zeroes will be set to 1.
2440  */
2441 static void bnx2x_calc_vn_min(struct bnx2x *bp,
2442                                       struct cmng_init_input *input)
2443 {
2444         int all_zero = 1;
2445         int vn;
2446
2447         for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++) {
2448                 uint32_t vn_cfg = bp->mf_config[vn];
2449                 uint32_t vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
2450                                    FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
2451
2452                 /* Skip hidden vns */
2453                 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
2454                         vn_min_rate = 0;
2455                 /* If min rate is zero - set it to 1 */
2456                 else if (!vn_min_rate)
2457                         vn_min_rate = DEF_MIN_RATE;
2458                 else
2459                         all_zero = 0;
2460
2461                 input->vnic_min_rate[vn] = vn_min_rate;
2462         }
2463
2464         /* if ETS or all min rates are zeros - disable fairness */
2465         if (BNX2X_IS_ETS_ENABLED(bp)) {
2466                 input->flags.cmng_enables &=
2467                                         ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
2468                 DP(NETIF_MSG_IFUP, "Fairness will be disabled due to ETS\n");
2469         } else if (all_zero) {
2470                 input->flags.cmng_enables &=
2471                                         ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
2472                 DP(NETIF_MSG_IFUP,
2473                    "All MIN values are zeroes fairness will be disabled\n");
2474         } else
2475                 input->flags.cmng_enables |=
2476                                         CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
2477 }
2478
2479 static void bnx2x_calc_vn_max(struct bnx2x *bp, int vn,
2480                                     struct cmng_init_input *input)
2481 {
2482         uint16_t vn_max_rate;
2483         uint32_t vn_cfg = bp->mf_config[vn];
2484
2485         if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
2486                 vn_max_rate = 0;
2487         else {
2488                 uint32_t maxCfg = bnx2x_extract_max_cfg(bp, vn_cfg);
2489
2490                 if (IS_MF_SI(bp)) {
2491                         /* maxCfg in percents of linkspeed */
2492                         vn_max_rate = (bp->link_vars.line_speed * maxCfg) / 100;
2493                 } else /* SD modes */
2494                         /* maxCfg is absolute in 100Mb units */
2495                         vn_max_rate = maxCfg * 100;
2496         }
2497
2498         DP(NETIF_MSG_IFUP, "vn %d: vn_max_rate %d\n", vn, vn_max_rate);
2499
2500         input->vnic_max_rate[vn] = vn_max_rate;
2501 }
2502
2503 static int bnx2x_get_cmng_fns_mode(struct bnx2x *bp)
2504 {
2505         if (CHIP_REV_IS_SLOW(bp))
2506                 return CMNG_FNS_NONE;
2507         if (IS_MF(bp))
2508                 return CMNG_FNS_MINMAX;
2509
2510         return CMNG_FNS_NONE;
2511 }
2512
2513 void bnx2x_read_mf_cfg(struct bnx2x *bp)
2514 {
2515         int vn, n = (CHIP_MODE_IS_4_PORT(bp) ? 2 : 1);
2516
2517         if (BP_NOMCP(bp))
2518                 return; /* what should be the default value in this case */
2519
2520         /* For 2 port configuration the absolute function number formula
2521          * is:
2522          *      abs_func = 2 * vn + BP_PORT + BP_PATH
2523          *
2524          *      and there are 4 functions per port
2525          *
2526          * For 4 port configuration it is
2527          *      abs_func = 4 * vn + 2 * BP_PORT + BP_PATH
2528          *
2529          *      and there are 2 functions per port
2530          */
2531         for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++) {
2532                 int /*abs*/func = n * (2 * vn + BP_PORT(bp)) + BP_PATH(bp);
2533
2534                 if (func >= E1H_FUNC_MAX)
2535                         break;
2536
2537                 bp->mf_config[vn] =
2538                         MF_CFG_RD(bp, func_mf_config[func].config);
2539         }
2540         if (bp->mf_config[BP_VN(bp)] & FUNC_MF_CFG_FUNC_DISABLED) {
2541                 DP(NETIF_MSG_IFUP, "mf_cfg function disabled\n");
2542                 bp->flags |= MF_FUNC_DIS;
2543         } else {
2544                 DP(NETIF_MSG_IFUP, "mf_cfg function enabled\n");
2545                 bp->flags &= ~MF_FUNC_DIS;
2546         }
2547 }
2548
2549 static void bnx2x_cmng_fns_init(struct bnx2x *bp, uint8_t read_cfg,
2550                                 uint8_t cmng_type)
2551 {
2552         struct cmng_init_input input;
2553         memset(&input, 0, sizeof(struct cmng_init_input));
2554
2555         input.port_rate = bp->link_vars.line_speed;
2556
2557         if (cmng_type == CMNG_FNS_MINMAX && input.port_rate) {
2558                 int vn;
2559
2560                 /* read mf conf from shmem */
2561                 if (read_cfg)
2562                         bnx2x_read_mf_cfg(bp);
2563
2564                 /* vn_weight_sum and enable fairness if not 0 */
2565                 bnx2x_calc_vn_min(bp, &input);
2566
2567                 /* calculate and set min-max rate for each vn */
2568                 if (bp->port.pmf)
2569                         for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++)
2570                                 bnx2x_calc_vn_max(bp, vn, &input);
2571
2572                 /* always enable rate shaping and fairness */
2573                 input.flags.cmng_enables |=
2574                                         CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN;
2575
2576                 bnx2x_init_cmng(&input, &bp->cmng);
2577                 return;
2578         }
2579
2580         /* rate shaping and fairness are disabled */
2581         DP(NETIF_MSG_IFUP,
2582            "rate shaping and fairness are disabled\n");
2583 }
2584
2585 static void storm_memset_cmng(struct bnx2x *bp,
2586                               struct cmng_init *cmng,
2587                               uint8_t port)
2588 {
2589         int vn;
2590         size_t size = sizeof(struct cmng_struct_per_port);
2591
2592         uint32_t addr = BAR_XSTRORM_INTMEM +
2593                         XSTORM_CMNG_PER_PORT_VARS_OFFSET(port);
2594
2595         __storm_memset_struct(bp, addr, size, (uint32_t *)&cmng->port);
2596
2597         for (vn = VN_0; vn < BP_MAX_VN_NUM(bp); vn++) {
2598                 int func = func_by_vn(bp, vn);
2599
2600                 addr = BAR_XSTRORM_INTMEM +
2601                        XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func);
2602                 size = sizeof(struct rate_shaping_vars_per_vn);
2603                 __storm_memset_struct(bp, addr, size,
2604                                       (uint32_t *)&cmng->vnic.vnic_max_rate[vn]);
2605
2606                 addr = BAR_XSTRORM_INTMEM +
2607                        XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func);
2608                 size = sizeof(struct fairness_vars_per_vn);
2609                 __storm_memset_struct(bp, addr, size,
2610                                       (uint32_t *)&cmng->vnic.vnic_min_rate[vn]);
2611         }
2612 }
2613
2614 /* init cmng mode in HW according to local configuration */
2615 void bnx2x_set_local_cmng(struct bnx2x *bp)
2616 {
2617         int cmng_fns = bnx2x_get_cmng_fns_mode(bp);
2618
2619         if (cmng_fns != CMNG_FNS_NONE) {
2620                 bnx2x_cmng_fns_init(bp, false, cmng_fns);
2621                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2622         } else {
2623                 /* rate shaping and fairness are disabled */
2624                 DP(NETIF_MSG_IFUP,
2625                    "single function mode without fairness\n");
2626         }
2627 }
2628
2629 /* This function is called upon link interrupt */
2630 static void bnx2x_link_attn(struct bnx2x *bp)
2631 {
2632         /* Make sure that we are synced with the current statistics */
2633         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2634
2635         bnx2x_link_update(&bp->link_params, &bp->link_vars);
2636
2637         bnx2x_init_dropless_fc(bp);
2638
2639         if (bp->link_vars.link_up) {
2640
2641                 if (bp->link_vars.mac_type != MAC_TYPE_EMAC) {
2642                         struct host_port_stats *pstats;
2643
2644                         pstats = bnx2x_sp(bp, port_stats);
2645                         /* reset old mac stats */
2646                         memset(&(pstats->mac_stx[0]), 0,
2647                                sizeof(struct mac_stx));
2648                 }
2649                 if (bp->state == BNX2X_STATE_OPEN)
2650                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2651         }
2652
2653         if (bp->link_vars.link_up && bp->link_vars.line_speed)
2654                 bnx2x_set_local_cmng(bp);
2655
2656         __bnx2x_link_report(bp);
2657
2658         if (IS_MF(bp))
2659                 bnx2x_link_sync_notify(bp);
2660 }
2661
2662 void bnx2x__link_status_update(struct bnx2x *bp)
2663 {
2664 panic("Not implemented");
2665 #if 0 // AKAROS_PORT
2666         if (bp->state != BNX2X_STATE_OPEN)
2667                 return;
2668
2669         /* read updated dcb configuration */
2670         if (IS_PF(bp)) {
2671                 bnx2x_dcbx_pmf_update(bp);
2672                 bnx2x_link_status_update(&bp->link_params, &bp->link_vars);
2673                 if (bp->link_vars.link_up)
2674                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2675                 else
2676                         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2677                         /* indicate link status */
2678                 bnx2x_link_report(bp);
2679
2680         } else { /* VF */
2681                 bp->port.supported[0] |= (SUPPORTED_10baseT_Half |
2682                                           SUPPORTED_10baseT_Full |
2683                                           SUPPORTED_100baseT_Half |
2684                                           SUPPORTED_100baseT_Full |
2685                                           SUPPORTED_1000baseT_Full |
2686                                           SUPPORTED_2500baseX_Full |
2687                                           SUPPORTED_10000baseT_Full |
2688                                           SUPPORTED_TP |
2689                                           SUPPORTED_FIBRE |
2690                                           SUPPORTED_Autoneg |
2691                                           SUPPORTED_Pause |
2692                                           SUPPORTED_Asym_Pause);
2693                 bp->port.advertising[0] = bp->port.supported[0];
2694
2695                 bp->link_params.bp = bp;
2696                 bp->link_params.port = BP_PORT(bp);
2697                 bp->link_params.req_duplex[0] = DUPLEX_FULL;
2698                 bp->link_params.req_flow_ctrl[0] = BNX2X_FLOW_CTRL_NONE;
2699                 bp->link_params.req_line_speed[0] = SPEED_10000;
2700                 bp->link_params.speed_cap_mask[0] = 0x7f0000;
2701                 bp->link_params.switch_cfg = SWITCH_CFG_10G;
2702                 bp->link_vars.mac_type = MAC_TYPE_BMAC;
2703                 bp->link_vars.line_speed = SPEED_10000;
2704                 bp->link_vars.link_status =
2705                         (LINK_STATUS_LINK_UP |
2706                          LINK_STATUS_SPEED_AND_DUPLEX_10GTFD);
2707                 bp->link_vars.link_up = 1;
2708                 bp->link_vars.duplex = DUPLEX_FULL;
2709                 bp->link_vars.flow_ctrl = BNX2X_FLOW_CTRL_NONE;
2710                 __bnx2x_link_report(bp);
2711
2712                 bnx2x_sample_bulletin(bp);
2713
2714                 /* if bulletin board did not have an update for link status
2715                  * __bnx2x_link_report will report current status
2716                  * but it will NOT duplicate report in case of already reported
2717                  * during sampling bulletin board.
2718                  */
2719                 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2720         }
2721 #endif
2722 }
2723
2724 static int bnx2x_afex_func_update(struct bnx2x *bp, uint16_t vifid,
2725                                   uint16_t vlan_val, uint8_t allowed_prio)
2726 {
2727         struct bnx2x_func_state_params func_params = {NULL};
2728         struct bnx2x_func_afex_update_params *f_update_params =
2729                 &func_params.params.afex_update;
2730
2731         func_params.f_obj = &bp->func_obj;
2732         func_params.cmd = BNX2X_F_CMD_AFEX_UPDATE;
2733
2734         /* no need to wait for RAMROD completion, so don't
2735          * set RAMROD_COMP_WAIT flag
2736          */
2737
2738         f_update_params->vif_id = vifid;
2739         f_update_params->afex_default_vlan = vlan_val;
2740         f_update_params->allowed_priorities = allowed_prio;
2741
2742         /* if ramrod can not be sent, response to MCP immediately */
2743         if (bnx2x_func_state_change(bp, &func_params) < 0)
2744                 bnx2x_fw_command(bp, DRV_MSG_CODE_AFEX_VIFSET_ACK, 0);
2745
2746         return 0;
2747 }
2748
2749 static int bnx2x_afex_handle_vif_list_cmd(struct bnx2x *bp, uint8_t cmd_type,
2750                                           uint16_t vif_index,
2751                                           uint8_t func_bit_map)
2752 {
2753         struct bnx2x_func_state_params func_params = {NULL};
2754         struct bnx2x_func_afex_viflists_params *update_params =
2755                 &func_params.params.afex_viflists;
2756         int rc;
2757         uint32_t drv_msg_code;
2758
2759         /* validate only LIST_SET and LIST_GET are received from switch */
2760         if ((cmd_type != VIF_LIST_RULE_GET) && (cmd_type != VIF_LIST_RULE_SET))
2761                 BNX2X_ERR("BUG! afex_handle_vif_list_cmd invalid type 0x%x\n",
2762                           cmd_type);
2763
2764         func_params.f_obj = &bp->func_obj;
2765         func_params.cmd = BNX2X_F_CMD_AFEX_VIFLISTS;
2766
2767         /* set parameters according to cmd_type */
2768         update_params->afex_vif_list_command = cmd_type;
2769         update_params->vif_list_index = vif_index;
2770         update_params->func_bit_map =
2771                 (cmd_type == VIF_LIST_RULE_GET) ? 0 : func_bit_map;
2772         update_params->func_to_clear = 0;
2773         drv_msg_code =
2774                 (cmd_type == VIF_LIST_RULE_GET) ?
2775                 DRV_MSG_CODE_AFEX_LISTGET_ACK :
2776                 DRV_MSG_CODE_AFEX_LISTSET_ACK;
2777
2778         /* if ramrod can not be sent, respond to MCP immediately for
2779          * SET and GET requests (other are not triggered from MCP)
2780          */
2781         rc = bnx2x_func_state_change(bp, &func_params);
2782         if (rc < 0)
2783                 bnx2x_fw_command(bp, drv_msg_code, 0);
2784
2785         return 0;
2786 }
2787
2788 static void bnx2x_handle_afex_cmd(struct bnx2x *bp, uint32_t cmd)
2789 {
2790 panic("Not implemented");
2791 #if 0 // AKAROS_PORT
2792         struct afex_stats afex_stats;
2793         uint32_t func = BP_ABS_FUNC(bp);
2794         uint32_t mf_config;
2795         uint16_t vlan_val;
2796         uint32_t vlan_prio;
2797         uint16_t vif_id;
2798         uint8_t allowed_prio;
2799         uint8_t vlan_mode;
2800         uint32_t addr_to_write, vifid, addrs, stats_type, i;
2801
2802         if (cmd & DRV_STATUS_AFEX_LISTGET_REQ) {
2803                 vifid = SHMEM2_RD(bp, afex_param1_to_driver[BP_FW_MB_IDX(bp)]);
2804                 DP(BNX2X_MSG_MCP,
2805                    "afex: got MCP req LISTGET_REQ for vifid 0x%x\n", vifid);
2806                 bnx2x_afex_handle_vif_list_cmd(bp, VIF_LIST_RULE_GET, vifid, 0);
2807         }
2808
2809         if (cmd & DRV_STATUS_AFEX_LISTSET_REQ) {
2810                 vifid = SHMEM2_RD(bp, afex_param1_to_driver[BP_FW_MB_IDX(bp)]);
2811                 addrs = SHMEM2_RD(bp, afex_param2_to_driver[BP_FW_MB_IDX(bp)]);
2812                 DP(BNX2X_MSG_MCP,
2813                    "afex: got MCP req LISTSET_REQ for vifid 0x%x addrs 0x%x\n",
2814                    vifid, addrs);
2815                 bnx2x_afex_handle_vif_list_cmd(bp, VIF_LIST_RULE_SET, vifid,
2816                                                addrs);
2817         }
2818
2819         if (cmd & DRV_STATUS_AFEX_STATSGET_REQ) {
2820                 addr_to_write = SHMEM2_RD(bp,
2821                         afex_scratchpad_addr_to_write[BP_FW_MB_IDX(bp)]);
2822                 stats_type = SHMEM2_RD(bp,
2823                         afex_param1_to_driver[BP_FW_MB_IDX(bp)]);
2824
2825                 DP(BNX2X_MSG_MCP,
2826                    "afex: got MCP req STATSGET_REQ, write to addr 0x%x\n",
2827                    addr_to_write);
2828
2829                 bnx2x_afex_collect_stats(bp, (void *)&afex_stats, stats_type);
2830
2831                 /* write response to scratchpad, for MCP */
2832                 for (i = 0; i < (sizeof(struct afex_stats)/sizeof(uint32_t)); i++)
2833                         REG_WR(bp, addr_to_write + i*sizeof(uint32_t),
2834                                *(((uint32_t *)(&afex_stats))+i));
2835
2836                 /* send ack message to MCP */
2837                 bnx2x_fw_command(bp, DRV_MSG_CODE_AFEX_STATSGET_ACK, 0);
2838         }
2839
2840         if (cmd & DRV_STATUS_AFEX_VIFSET_REQ) {
2841                 mf_config = MF_CFG_RD(bp, func_mf_config[func].config);
2842                 bp->mf_config[BP_VN(bp)] = mf_config;
2843                 DP(BNX2X_MSG_MCP,
2844                    "afex: got MCP req VIFSET_REQ, mf_config 0x%x\n",
2845                    mf_config);
2846
2847                 /* if VIF_SET is "enabled" */
2848                 if (!(mf_config & FUNC_MF_CFG_FUNC_DISABLED)) {
2849                         /* set rate limit directly to internal RAM */
2850                         struct cmng_init_input cmng_input;
2851                         struct rate_shaping_vars_per_vn m_rs_vn;
2852                         size_t size = sizeof(struct rate_shaping_vars_per_vn);
2853                         uint32_t addr = BAR_XSTRORM_INTMEM +
2854                             XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(BP_FUNC(bp));
2855
2856                         bp->mf_config[BP_VN(bp)] = mf_config;
2857
2858                         bnx2x_calc_vn_max(bp, BP_VN(bp), &cmng_input);
2859                         m_rs_vn.vn_counter.rate =
2860                                 cmng_input.vnic_max_rate[BP_VN(bp)];
2861                         m_rs_vn.vn_counter.quota =
2862                                 (m_rs_vn.vn_counter.rate *
2863                                  RS_PERIODIC_TIMEOUT_USEC) / 8;
2864
2865                         __storm_memset_struct(bp, addr, size,
2866                                               (uint32_t *)&m_rs_vn);
2867
2868                         /* read relevant values from mf_cfg struct in shmem */
2869                         vif_id =
2870                                 (MF_CFG_RD(bp, func_mf_config[func].e1hov_tag) &
2871                                  FUNC_MF_CFG_E1HOV_TAG_MASK) >>
2872                                 FUNC_MF_CFG_E1HOV_TAG_SHIFT;
2873                         vlan_val =
2874                                 (MF_CFG_RD(bp, func_mf_config[func].e1hov_tag) &
2875                                  FUNC_MF_CFG_AFEX_VLAN_MASK) >>
2876                                 FUNC_MF_CFG_AFEX_VLAN_SHIFT;
2877                         vlan_prio = (mf_config &
2878                                      FUNC_MF_CFG_TRANSMIT_PRIORITY_MASK) >>
2879                                     FUNC_MF_CFG_TRANSMIT_PRIORITY_SHIFT;
2880                         vlan_val |= (vlan_prio << VLAN_PRIO_SHIFT);
2881                         vlan_mode =
2882                                 (MF_CFG_RD(bp,
2883                                            func_mf_config[func].afex_config) &
2884                                  FUNC_MF_CFG_AFEX_VLAN_MODE_MASK) >>
2885                                 FUNC_MF_CFG_AFEX_VLAN_MODE_SHIFT;
2886                         allowed_prio =
2887                                 (MF_CFG_RD(bp,
2888                                            func_mf_config[func].afex_config) &
2889                                  FUNC_MF_CFG_AFEX_COS_FILTER_MASK) >>
2890                                 FUNC_MF_CFG_AFEX_COS_FILTER_SHIFT;
2891
2892                         /* send ramrod to FW, return in case of failure */
2893                         if (bnx2x_afex_func_update(bp, vif_id, vlan_val,
2894                                                    allowed_prio))
2895                                 return;
2896
2897                         bp->afex_def_vlan_tag = vlan_val;
2898                         bp->afex_vlan_mode = vlan_mode;
2899                 } else {
2900                         /* notify link down because BP->flags is disabled */
2901                         bnx2x_link_report(bp);
2902
2903                         /* send INVALID VIF ramrod to FW */
2904                         bnx2x_afex_func_update(bp, 0xFFFF, 0, 0);
2905
2906                         /* Reset the default afex VLAN */
2907                         bp->afex_def_vlan_tag = -1;
2908                 }
2909         }
2910 #endif
2911 }
2912
2913 static void bnx2x_handle_update_svid_cmd(struct bnx2x *bp)
2914 {
2915         struct bnx2x_func_switch_update_params *switch_update_params;
2916         struct bnx2x_func_state_params func_params;
2917
2918         memset(&func_params, 0, sizeof(struct bnx2x_func_state_params));
2919         switch_update_params = &func_params.params.switch_update;
2920         func_params.f_obj = &bp->func_obj;
2921         func_params.cmd = BNX2X_F_CMD_SWITCH_UPDATE;
2922
2923         if (IS_MF_UFP(bp)) {
2924                 int func = BP_ABS_FUNC(bp);
2925                 uint32_t val;
2926
2927                 /* Re-learn the S-tag from shmem */
2928                 val = MF_CFG_RD(bp, func_mf_config[func].e1hov_tag) &
2929                                 FUNC_MF_CFG_E1HOV_TAG_MASK;
2930                 if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
2931                         bp->mf_ov = val;
2932                 } else {
2933                         BNX2X_ERR("Got an SVID event, but no tag is configured in shmem\n");
2934                         goto fail;
2935                 }
2936
2937                 /* Configure new S-tag in LLH */
2938                 REG_WR(bp, NIG_REG_LLH0_FUNC_VLAN_ID + BP_PORT(bp) * 8,
2939                        bp->mf_ov);
2940
2941                 /* Send Ramrod to update FW of change */
2942                 __set_bit(BNX2X_F_UPDATE_SD_VLAN_TAG_CHNG,
2943                           &switch_update_params->changes);
2944                 switch_update_params->vlan = bp->mf_ov;
2945
2946                 if (bnx2x_func_state_change(bp, &func_params) < 0) {
2947                         BNX2X_ERR("Failed to configure FW of S-tag Change to %02x\n",
2948                                   bp->mf_ov);
2949                         goto fail;
2950                 }
2951
2952                 DP(BNX2X_MSG_MCP, "Configured S-tag %02x\n", bp->mf_ov);
2953
2954                 bnx2x_fw_command(bp, DRV_MSG_CODE_OEM_UPDATE_SVID_OK, 0);
2955
2956                 return;
2957         }
2958
2959         /* not supported by SW yet */
2960 fail:
2961         bnx2x_fw_command(bp, DRV_MSG_CODE_OEM_UPDATE_SVID_FAILURE, 0);
2962 }
2963
2964 static void bnx2x_pmf_update(struct bnx2x *bp)
2965 {
2966         int port = BP_PORT(bp);
2967         uint32_t val;
2968
2969         bp->port.pmf = 1;
2970         DP(BNX2X_MSG_MCP, "pmf %d\n", bp->port.pmf);
2971
2972         /*
2973          * We need the mb() to ensure the ordering between the writing to
2974          * bp->port.pmf here and reading it from the bnx2x_periodic_task().
2975          */
2976         mb();
2977
2978         /* queue a periodic task */
2979         queue_delayed_work(bnx2x_wq, &bp->period_task, 0);
2980
2981         bnx2x_dcbx_pmf_update(bp);
2982
2983         /* enable nig attention */
2984         val = (0xff0f | (1 << (BP_VN(bp) + 4)));
2985         if (bp->common.int_block == INT_BLOCK_HC) {
2986                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
2987                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
2988         } else if (!CHIP_IS_E1x(bp)) {
2989                 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
2990                 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
2991         }
2992
2993         bnx2x_stats_handle(bp, STATS_EVENT_PMF);
2994 }
2995
2996 /* end of Link */
2997
2998 /* slow path */
2999
3000 /*
3001  * General service functions
3002  */
3003
3004 /* send the MCP a request, block until there is a reply */
3005 uint32_t bnx2x_fw_command(struct bnx2x *bp, uint32_t command, uint32_t param)
3006 {
3007         int mb_idx = BP_FW_MB_IDX(bp);
3008         uint32_t seq;
3009         uint32_t rc = 0;
3010         uint32_t cnt = 1;
3011         uint8_t delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
3012
3013         qlock(&bp->fw_mb_mutex);
3014         seq = ++bp->fw_seq;
3015         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_param, param);
3016         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_header, (command | seq));
3017
3018         DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB param 0x%08x\n",
3019                         (command | seq), param);
3020
3021         do {
3022                 /* let the FW do it's magic ... */
3023                 kthread_usleep(1000 * delay);
3024
3025                 rc = SHMEM_RD(bp, func_mb[mb_idx].fw_mb_header);
3026
3027                 /* Give the FW up to 5 second (500*10ms) */
3028         } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
3029
3030         DP(BNX2X_MSG_MCP, "[after %d ms] read (%x) seq is (%x) from FW MB\n",
3031            cnt*delay, rc, seq);
3032
3033         /* is this a reply to our command? */
3034         if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK))
3035                 rc &= FW_MSG_CODE_MASK;
3036         else {
3037                 /* FW BUG! */
3038                 BNX2X_ERR("FW failed to respond!\n");
3039                 bnx2x_fw_dump(bp);
3040                 rc = 0;
3041         }
3042         qunlock(&bp->fw_mb_mutex);
3043
3044         return rc;
3045 }
3046
3047 static void storm_memset_func_cfg(struct bnx2x *bp,
3048                                  struct tstorm_eth_function_common_config *tcfg,
3049                                  uint16_t abs_fid)
3050 {
3051         size_t size = sizeof(struct tstorm_eth_function_common_config);
3052
3053         uint32_t addr = BAR_TSTRORM_INTMEM +
3054                         TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid);
3055
3056         __storm_memset_struct(bp, addr, size, (uint32_t *)tcfg);
3057 }
3058
3059 void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p)
3060 {
3061         if (CHIP_IS_E1x(bp)) {
3062                 struct tstorm_eth_function_common_config tcfg = {0};
3063
3064                 storm_memset_func_cfg(bp, &tcfg, p->func_id);
3065         }
3066
3067         /* Enable the function in the FW */
3068         storm_memset_vf_to_pf(bp, p->func_id, p->pf_id);
3069         storm_memset_func_en(bp, p->func_id, 1);
3070
3071         /* spq */
3072         if (p->func_flgs & FUNC_FLG_SPQ) {
3073                 storm_memset_spq_addr(bp, p->spq_map, p->func_id);
3074                 REG_WR(bp, XSEM_REG_FAST_MEMORY +
3075                        XSTORM_SPQ_PROD_OFFSET(p->func_id), p->spq_prod);
3076         }
3077 }
3078
3079 /**
3080  * bnx2x_get_common_flags - Return common flags
3081  *
3082  * @bp          device handle
3083  * @fp          queue handle
3084  * @zero_stats  TRUE if statistics zeroing is needed
3085  *
3086  * Return the flags that are common for the Tx-only and not normal connections.
3087  */
3088 static unsigned long bnx2x_get_common_flags(struct bnx2x *bp,
3089                                             struct bnx2x_fastpath *fp,
3090                                             bool zero_stats)
3091 {
3092         unsigned long flags = 0;
3093
3094         /* PF driver will always initialize the Queue to an ACTIVE state */
3095         __set_bit(BNX2X_Q_FLG_ACTIVE, &flags);
3096
3097         /* tx only connections collect statistics (on the same index as the
3098          * parent connection). The statistics are zeroed when the parent
3099          * connection is initialized.
3100          */
3101
3102         __set_bit(BNX2X_Q_FLG_STATS, &flags);
3103         if (zero_stats)
3104                 __set_bit(BNX2X_Q_FLG_ZERO_STATS, &flags);
3105
3106         if (bp->flags & TX_SWITCHING)
3107                 __set_bit(BNX2X_Q_FLG_TX_SWITCH, &flags);
3108
3109         __set_bit(BNX2X_Q_FLG_PCSUM_ON_PKT, &flags);
3110         __set_bit(BNX2X_Q_FLG_TUN_INC_INNER_IP_ID, &flags);
3111
3112 #ifdef BNX2X_STOP_ON_ERROR
3113         __set_bit(BNX2X_Q_FLG_TX_SEC, &flags);
3114 #endif
3115
3116         return flags;
3117 }
3118
3119 static unsigned long bnx2x_get_q_flags(struct bnx2x *bp,
3120                                        struct bnx2x_fastpath *fp,
3121                                        bool leading)
3122 {
3123         unsigned long flags = 0;
3124
3125         /* calculate other queue flags */
3126         if (IS_MF_SD(bp))
3127                 __set_bit(BNX2X_Q_FLG_OV, &flags);
3128
3129         if (IS_FCOE_FP(fp)) {
3130                 __set_bit(BNX2X_Q_FLG_FCOE, &flags);
3131                 /* For FCoE - force usage of default priority (for afex) */
3132                 __set_bit(BNX2X_Q_FLG_FORCE_DEFAULT_PRI, &flags);
3133         }
3134
3135         if (!fp->disable_tpa) {
3136                 __set_bit(BNX2X_Q_FLG_TPA, &flags);
3137                 __set_bit(BNX2X_Q_FLG_TPA_IPV6, &flags);
3138                 if (fp->mode == TPA_MODE_GRO)
3139                         __set_bit(BNX2X_Q_FLG_TPA_GRO, &flags);
3140         }
3141
3142         if (leading) {
3143                 __set_bit(BNX2X_Q_FLG_LEADING_RSS, &flags);
3144                 __set_bit(BNX2X_Q_FLG_MCAST, &flags);
3145         }
3146
3147         /* Always set HW VLAN stripping */
3148         __set_bit(BNX2X_Q_FLG_VLAN, &flags);
3149
3150         /* configure silent vlan removal */
3151         if (IS_MF_AFEX(bp))
3152                 __set_bit(BNX2X_Q_FLG_SILENT_VLAN_REM, &flags);
3153
3154         return flags | bnx2x_get_common_flags(bp, fp, true);
3155 }
3156
3157 static void bnx2x_pf_q_prep_general(struct bnx2x *bp,
3158         struct bnx2x_fastpath *fp, struct bnx2x_general_setup_params *gen_init,
3159         uint8_t cos)
3160 {
3161         gen_init->stat_id = bnx2x_stats_id(fp);
3162         gen_init->spcl_id = fp->cl_id;
3163
3164         /* Always use mini-jumbo MTU for FCoE L2 ring */
3165         if (IS_FCOE_FP(fp))