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