bnx2x: change type of spq_left to atomic
[linux-2.6.git] / drivers / net / bnx2x / bnx2x_main.c
1 /* bnx2x_main.c: Broadcom Everest network driver.
2  *
3  * Copyright (c) 2007-2010 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: Eilon Greenstein <eilong@broadcom.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/module.h>
19 #include <linux/moduleparam.h>
20 #include <linux/kernel.h>
21 #include <linux/device.h>  /* for dev_info() */
22 #include <linux/timer.h>
23 #include <linux/errno.h>
24 #include <linux/ioport.h>
25 #include <linux/slab.h>
26 #include <linux/vmalloc.h>
27 #include <linux/interrupt.h>
28 #include <linux/pci.h>
29 #include <linux/init.h>
30 #include <linux/netdevice.h>
31 #include <linux/etherdevice.h>
32 #include <linux/skbuff.h>
33 #include <linux/dma-mapping.h>
34 #include <linux/bitops.h>
35 #include <linux/irq.h>
36 #include <linux/delay.h>
37 #include <asm/byteorder.h>
38 #include <linux/time.h>
39 #include <linux/ethtool.h>
40 #include <linux/mii.h>
41 #include <linux/if_vlan.h>
42 #include <net/ip.h>
43 #include <net/tcp.h>
44 #include <net/checksum.h>
45 #include <net/ip6_checksum.h>
46 #include <linux/workqueue.h>
47 #include <linux/crc32.h>
48 #include <linux/crc32c.h>
49 #include <linux/prefetch.h>
50 #include <linux/zlib.h>
51 #include <linux/io.h>
52 #include <linux/stringify.h>
53
54 #define BNX2X_MAIN
55 #include "bnx2x.h"
56 #include "bnx2x_init.h"
57 #include "bnx2x_init_ops.h"
58 #include "bnx2x_cmn.h"
59
60
61 #include <linux/firmware.h>
62 #include "bnx2x_fw_file_hdr.h"
63 /* FW files */
64 #define FW_FILE_VERSION                                 \
65         __stringify(BCM_5710_FW_MAJOR_VERSION) "."      \
66         __stringify(BCM_5710_FW_MINOR_VERSION) "."      \
67         __stringify(BCM_5710_FW_REVISION_VERSION) "."   \
68         __stringify(BCM_5710_FW_ENGINEERING_VERSION)
69 #define FW_FILE_NAME_E1         "bnx2x/bnx2x-e1-" FW_FILE_VERSION ".fw"
70 #define FW_FILE_NAME_E1H        "bnx2x/bnx2x-e1h-" FW_FILE_VERSION ".fw"
71
72 /* Time in jiffies before concluding the transmitter is hung */
73 #define TX_TIMEOUT              (5*HZ)
74
75 static char version[] __devinitdata =
76         "Broadcom NetXtreme II 5771x 10Gigabit Ethernet Driver "
77         DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
78
79 MODULE_AUTHOR("Eliezer Tamir");
80 MODULE_DESCRIPTION("Broadcom NetXtreme II BCM57710/57711/57711E Driver");
81 MODULE_LICENSE("GPL");
82 MODULE_VERSION(DRV_MODULE_VERSION);
83 MODULE_FIRMWARE(FW_FILE_NAME_E1);
84 MODULE_FIRMWARE(FW_FILE_NAME_E1H);
85
86 static int multi_mode = 1;
87 module_param(multi_mode, int, 0);
88 MODULE_PARM_DESC(multi_mode, " Multi queue mode "
89                              "(0 Disable; 1 Enable (default))");
90
91 static int num_queues;
92 module_param(num_queues, int, 0);
93 MODULE_PARM_DESC(num_queues, " Number of queues for multi_mode=1"
94                                 " (default is as a number of CPUs)");
95
96 static int disable_tpa;
97 module_param(disable_tpa, int, 0);
98 MODULE_PARM_DESC(disable_tpa, " Disable the TPA (LRO) feature");
99
100 static int int_mode;
101 module_param(int_mode, int, 0);
102 MODULE_PARM_DESC(int_mode, " Force interrupt mode other then MSI-X "
103                                 "(1 INT#x; 2 MSI)");
104
105 static int dropless_fc;
106 module_param(dropless_fc, int, 0);
107 MODULE_PARM_DESC(dropless_fc, " Pause on exhausted host ring");
108
109 static int poll;
110 module_param(poll, int, 0);
111 MODULE_PARM_DESC(poll, " Use polling (for debug)");
112
113 static int mrrs = -1;
114 module_param(mrrs, int, 0);
115 MODULE_PARM_DESC(mrrs, " Force Max Read Req Size (0..3) (for debug)");
116
117 static int debug;
118 module_param(debug, int, 0);
119 MODULE_PARM_DESC(debug, " Default debug msglevel");
120
121 static struct workqueue_struct *bnx2x_wq;
122
123 enum bnx2x_board_type {
124         BCM57710 = 0,
125         BCM57711 = 1,
126         BCM57711E = 2,
127 };
128
129 /* indexed by board_type, above */
130 static struct {
131         char *name;
132 } board_info[] __devinitdata = {
133         { "Broadcom NetXtreme II BCM57710 XGb" },
134         { "Broadcom NetXtreme II BCM57711 XGb" },
135         { "Broadcom NetXtreme II BCM57711E XGb" }
136 };
137
138
139 static DEFINE_PCI_DEVICE_TABLE(bnx2x_pci_tbl) = {
140         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57710), BCM57710 },
141         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711), BCM57711 },
142         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711E), BCM57711E },
143         { 0 }
144 };
145
146 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
147
148 /****************************************************************************
149 * General service functions
150 ****************************************************************************/
151
152 static inline void __storm_memset_dma_mapping(struct bnx2x *bp,
153                                        u32 addr, dma_addr_t mapping)
154 {
155         REG_WR(bp,  addr, U64_LO(mapping));
156         REG_WR(bp,  addr + 4, U64_HI(mapping));
157 }
158
159 static inline void __storm_memset_fill(struct bnx2x *bp,
160                                        u32 addr, size_t size, u32 val)
161 {
162         int i;
163         for (i = 0; i < size/4; i++)
164                 REG_WR(bp,  addr + (i * 4), val);
165 }
166
167 static inline void storm_memset_ustats_zero(struct bnx2x *bp,
168                                             u8 port, u16 stat_id)
169 {
170         size_t size = sizeof(struct ustorm_per_client_stats);
171
172         u32 addr = BAR_USTRORM_INTMEM +
173                         USTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
174
175         __storm_memset_fill(bp, addr, size, 0);
176 }
177
178 static inline void storm_memset_tstats_zero(struct bnx2x *bp,
179                                             u8 port, u16 stat_id)
180 {
181         size_t size = sizeof(struct tstorm_per_client_stats);
182
183         u32 addr = BAR_TSTRORM_INTMEM +
184                         TSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
185
186         __storm_memset_fill(bp, addr, size, 0);
187 }
188
189 static inline void storm_memset_xstats_zero(struct bnx2x *bp,
190                                             u8 port, u16 stat_id)
191 {
192         size_t size = sizeof(struct xstorm_per_client_stats);
193
194         u32 addr = BAR_XSTRORM_INTMEM +
195                         XSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
196
197         __storm_memset_fill(bp, addr, size, 0);
198 }
199
200
201 static inline void storm_memset_spq_addr(struct bnx2x *bp,
202                                          dma_addr_t mapping, u16 abs_fid)
203 {
204         u32 addr = XSEM_REG_FAST_MEMORY +
205                         XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid);
206
207         __storm_memset_dma_mapping(bp, addr, mapping);
208 }
209
210 static inline void storm_memset_ov(struct bnx2x *bp, u16 ov, u16 abs_fid)
211 {
212         REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_E1HOV_OFFSET(abs_fid), ov);
213 }
214
215 static inline void storm_memset_func_cfg(struct bnx2x *bp,
216                                 struct tstorm_eth_function_common_config *tcfg,
217                                 u16 abs_fid)
218 {
219         size_t size = sizeof(struct tstorm_eth_function_common_config);
220
221         u32 addr = BAR_TSTRORM_INTMEM +
222                         TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid);
223
224         __storm_memset_struct(bp, addr, size, (u32 *)tcfg);
225 }
226
227 static inline void storm_memset_xstats_flags(struct bnx2x *bp,
228                                 struct stats_indication_flags *flags,
229                                 u16 abs_fid)
230 {
231         size_t size = sizeof(struct stats_indication_flags);
232
233         u32 addr = BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(abs_fid);
234
235         __storm_memset_struct(bp, addr, size, (u32 *)flags);
236 }
237
238 static inline void storm_memset_tstats_flags(struct bnx2x *bp,
239                                 struct stats_indication_flags *flags,
240                                 u16 abs_fid)
241 {
242         size_t size = sizeof(struct stats_indication_flags);
243
244         u32 addr = BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(abs_fid);
245
246         __storm_memset_struct(bp, addr, size, (u32 *)flags);
247 }
248
249 static inline void storm_memset_ustats_flags(struct bnx2x *bp,
250                                 struct stats_indication_flags *flags,
251                                 u16 abs_fid)
252 {
253         size_t size = sizeof(struct stats_indication_flags);
254
255         u32 addr = BAR_USTRORM_INTMEM + USTORM_STATS_FLAGS_OFFSET(abs_fid);
256
257         __storm_memset_struct(bp, addr, size, (u32 *)flags);
258 }
259
260 static inline void storm_memset_cstats_flags(struct bnx2x *bp,
261                                 struct stats_indication_flags *flags,
262                                 u16 abs_fid)
263 {
264         size_t size = sizeof(struct stats_indication_flags);
265
266         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(abs_fid);
267
268         __storm_memset_struct(bp, addr, size, (u32 *)flags);
269 }
270
271 static inline void storm_memset_xstats_addr(struct bnx2x *bp,
272                                            dma_addr_t mapping, u16 abs_fid)
273 {
274         u32 addr = BAR_XSTRORM_INTMEM +
275                 XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
276
277         __storm_memset_dma_mapping(bp, addr, mapping);
278 }
279
280 static inline void storm_memset_tstats_addr(struct bnx2x *bp,
281                                            dma_addr_t mapping, u16 abs_fid)
282 {
283         u32 addr = BAR_TSTRORM_INTMEM +
284                 TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
285
286         __storm_memset_dma_mapping(bp, addr, mapping);
287 }
288
289 static inline void storm_memset_ustats_addr(struct bnx2x *bp,
290                                            dma_addr_t mapping, u16 abs_fid)
291 {
292         u32 addr = BAR_USTRORM_INTMEM +
293                 USTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
294
295         __storm_memset_dma_mapping(bp, addr, mapping);
296 }
297
298 static inline void storm_memset_cstats_addr(struct bnx2x *bp,
299                                            dma_addr_t mapping, u16 abs_fid)
300 {
301         u32 addr = BAR_CSTRORM_INTMEM +
302                 CSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
303
304         __storm_memset_dma_mapping(bp, addr, mapping);
305 }
306
307 static inline void storm_memset_vf_to_pf(struct bnx2x *bp, u16 abs_fid,
308                                          u16 pf_id)
309 {
310         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid),
311                 pf_id);
312         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid),
313                 pf_id);
314         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid),
315                 pf_id);
316         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid),
317                 pf_id);
318 }
319
320 static inline void storm_memset_func_en(struct bnx2x *bp, u16 abs_fid,
321                                         u8 enable)
322 {
323         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid),
324                 enable);
325         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid),
326                 enable);
327         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid),
328                 enable);
329         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid),
330                 enable);
331 }
332
333 static inline void storm_memset_eq_data(struct bnx2x *bp,
334                                 struct event_ring_data *eq_data,
335                                 u16 pfid)
336 {
337         size_t size = sizeof(struct event_ring_data);
338
339         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_DATA_OFFSET(pfid);
340
341         __storm_memset_struct(bp, addr, size, (u32 *)eq_data);
342 }
343
344 static inline void storm_memset_eq_prod(struct bnx2x *bp, u16 eq_prod,
345                                         u16 pfid)
346 {
347         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_PROD_OFFSET(pfid);
348         REG_WR16(bp, addr, eq_prod);
349 }
350
351 static inline void storm_memset_hc_timeout(struct bnx2x *bp, u8 port,
352                                              u16 fw_sb_id, u8 sb_index,
353                                              u8 ticks)
354 {
355
356         int index_offset =
357                 offsetof(struct hc_status_block_data_e1x, index_data);
358         u32 addr = BAR_CSTRORM_INTMEM +
359                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
360                         index_offset +
361                         sizeof(struct hc_index_data)*sb_index +
362                         offsetof(struct hc_index_data, timeout);
363         REG_WR8(bp, addr, ticks);
364         DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d ticks %d\n",
365                           port, fw_sb_id, sb_index, ticks);
366 }
367 static inline void storm_memset_hc_disable(struct bnx2x *bp, u8 port,
368                                              u16 fw_sb_id, u8 sb_index,
369                                              u8 disable)
370 {
371         u32 enable_flag = disable ? 0 : (1 << HC_INDEX_DATA_HC_ENABLED_SHIFT);
372         int index_offset =
373                 offsetof(struct hc_status_block_data_e1x, index_data);
374         u32 addr = BAR_CSTRORM_INTMEM +
375                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
376                         index_offset +
377                         sizeof(struct hc_index_data)*sb_index +
378                         offsetof(struct hc_index_data, flags);
379         u16 flags = REG_RD16(bp, addr);
380         /* clear and set */
381         flags &= ~HC_INDEX_DATA_HC_ENABLED;
382         flags |= enable_flag;
383         REG_WR16(bp, addr, flags);
384         DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d disable %d\n",
385                           port, fw_sb_id, sb_index, disable);
386 }
387
388 /* used only at init
389  * locking is done by mcp
390  */
391 void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
392 {
393         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
394         pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
395         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
396                                PCICFG_VENDOR_ID_OFFSET);
397 }
398
399 static u32 bnx2x_reg_rd_ind(struct bnx2x *bp, u32 addr)
400 {
401         u32 val;
402
403         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
404         pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
405         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
406                                PCICFG_VENDOR_ID_OFFSET);
407
408         return val;
409 }
410
411 const u32 dmae_reg_go_c[] = {
412         DMAE_REG_GO_C0, DMAE_REG_GO_C1, DMAE_REG_GO_C2, DMAE_REG_GO_C3,
413         DMAE_REG_GO_C4, DMAE_REG_GO_C5, DMAE_REG_GO_C6, DMAE_REG_GO_C7,
414         DMAE_REG_GO_C8, DMAE_REG_GO_C9, DMAE_REG_GO_C10, DMAE_REG_GO_C11,
415         DMAE_REG_GO_C12, DMAE_REG_GO_C13, DMAE_REG_GO_C14, DMAE_REG_GO_C15
416 };
417
418 /* copy command into DMAE command memory and set DMAE command go */
419 void bnx2x_post_dmae(struct bnx2x *bp, struct dmae_command *dmae, int idx)
420 {
421         u32 cmd_offset;
422         int i;
423
424         cmd_offset = (DMAE_REG_CMD_MEM + sizeof(struct dmae_command) * idx);
425         for (i = 0; i < (sizeof(struct dmae_command)/4); i++) {
426                 REG_WR(bp, cmd_offset + i*4, *(((u32 *)dmae) + i));
427
428                 DP(BNX2X_MSG_OFF, "DMAE cmd[%d].%d (0x%08x) : 0x%08x\n",
429                    idx, i, cmd_offset + i*4, *(((u32 *)dmae) + i));
430         }
431         REG_WR(bp, dmae_reg_go_c[idx], 1);
432 }
433
434 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr, u32 dst_addr,
435                       u32 len32)
436 {
437         struct dmae_command dmae;
438         u32 *wb_comp = bnx2x_sp(bp, wb_comp);
439         int cnt = 200;
440
441         if (!bp->dmae_ready) {
442                 u32 *data = bnx2x_sp(bp, wb_data[0]);
443
444                 DP(BNX2X_MSG_OFF, "DMAE is not ready (dst_addr %08x  len32 %d)"
445                    "  using indirect\n", dst_addr, len32);
446                 bnx2x_init_ind_wr(bp, dst_addr, data, len32);
447                 return;
448         }
449
450         memset(&dmae, 0, sizeof(struct dmae_command));
451
452         dmae.opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
453                        DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
454                        DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
455 #ifdef __BIG_ENDIAN
456                        DMAE_CMD_ENDIANITY_B_DW_SWAP |
457 #else
458                        DMAE_CMD_ENDIANITY_DW_SWAP |
459 #endif
460                        (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
461                        (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
462         dmae.src_addr_lo = U64_LO(dma_addr);
463         dmae.src_addr_hi = U64_HI(dma_addr);
464         dmae.dst_addr_lo = dst_addr >> 2;
465         dmae.dst_addr_hi = 0;
466         dmae.len = len32;
467         dmae.comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
468         dmae.comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
469         dmae.comp_val = DMAE_COMP_VAL;
470
471         DP(BNX2X_MSG_OFF, "DMAE: opcode 0x%08x\n"
472            DP_LEVEL "src_addr  [%x:%08x]  len [%d *4]  "
473                     "dst_addr [%x:%08x (%08x)]\n"
474            DP_LEVEL "comp_addr [%x:%08x]  comp_val 0x%08x\n",
475            dmae.opcode, dmae.src_addr_hi, dmae.src_addr_lo,
476            dmae.len, dmae.dst_addr_hi, dmae.dst_addr_lo, dst_addr,
477            dmae.comp_addr_hi, dmae.comp_addr_lo, dmae.comp_val);
478         DP(BNX2X_MSG_OFF, "data [0x%08x 0x%08x 0x%08x 0x%08x]\n",
479            bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
480            bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
481
482         mutex_lock(&bp->dmae_mutex);
483
484         *wb_comp = 0;
485
486         bnx2x_post_dmae(bp, &dmae, INIT_DMAE_C(bp));
487
488         udelay(5);
489
490         while (*wb_comp != DMAE_COMP_VAL) {
491                 DP(BNX2X_MSG_OFF, "wb_comp 0x%08x\n", *wb_comp);
492
493                 if (!cnt) {
494                         BNX2X_ERR("DMAE timeout!\n");
495                         break;
496                 }
497                 cnt--;
498                 /* adjust delay for emulation/FPGA */
499                 if (CHIP_REV_IS_SLOW(bp))
500                         msleep(100);
501                 else
502                         udelay(5);
503         }
504
505         mutex_unlock(&bp->dmae_mutex);
506 }
507
508 void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32)
509 {
510         struct dmae_command dmae;
511         u32 *wb_comp = bnx2x_sp(bp, wb_comp);
512         int cnt = 200;
513
514         if (!bp->dmae_ready) {
515                 u32 *data = bnx2x_sp(bp, wb_data[0]);
516                 int i;
517
518                 DP(BNX2X_MSG_OFF, "DMAE is not ready (src_addr %08x  len32 %d)"
519                    "  using indirect\n", src_addr, len32);
520                 for (i = 0; i < len32; i++)
521                         data[i] = bnx2x_reg_rd_ind(bp, src_addr + i*4);
522                 return;
523         }
524
525         memset(&dmae, 0, sizeof(struct dmae_command));
526
527         dmae.opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
528                        DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
529                        DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
530 #ifdef __BIG_ENDIAN
531                        DMAE_CMD_ENDIANITY_B_DW_SWAP |
532 #else
533                        DMAE_CMD_ENDIANITY_DW_SWAP |
534 #endif
535                        (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
536                        (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
537         dmae.src_addr_lo = src_addr >> 2;
538         dmae.src_addr_hi = 0;
539         dmae.dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_data));
540         dmae.dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_data));
541         dmae.len = len32;
542         dmae.comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
543         dmae.comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
544         dmae.comp_val = DMAE_COMP_VAL;
545
546         DP(BNX2X_MSG_OFF, "DMAE: opcode 0x%08x\n"
547            DP_LEVEL "src_addr  [%x:%08x]  len [%d *4]  "
548                     "dst_addr [%x:%08x (%08x)]\n"
549            DP_LEVEL "comp_addr [%x:%08x]  comp_val 0x%08x\n",
550            dmae.opcode, dmae.src_addr_hi, dmae.src_addr_lo,
551            dmae.len, dmae.dst_addr_hi, dmae.dst_addr_lo, src_addr,
552            dmae.comp_addr_hi, dmae.comp_addr_lo, dmae.comp_val);
553
554         mutex_lock(&bp->dmae_mutex);
555
556         memset(bnx2x_sp(bp, wb_data[0]), 0, sizeof(u32) * 4);
557         *wb_comp = 0;
558
559         bnx2x_post_dmae(bp, &dmae, INIT_DMAE_C(bp));
560
561         udelay(5);
562
563         while (*wb_comp != DMAE_COMP_VAL) {
564
565                 if (!cnt) {
566                         BNX2X_ERR("DMAE timeout!\n");
567                         break;
568                 }
569                 cnt--;
570                 /* adjust delay for emulation/FPGA */
571                 if (CHIP_REV_IS_SLOW(bp))
572                         msleep(100);
573                 else
574                         udelay(5);
575         }
576         DP(BNX2X_MSG_OFF, "data [0x%08x 0x%08x 0x%08x 0x%08x]\n",
577            bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
578            bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
579
580         mutex_unlock(&bp->dmae_mutex);
581 }
582
583 void bnx2x_write_dmae_phys_len(struct bnx2x *bp, dma_addr_t phys_addr,
584                                u32 addr, u32 len)
585 {
586         int dmae_wr_max = DMAE_LEN32_WR_MAX(bp);
587         int offset = 0;
588
589         while (len > dmae_wr_max) {
590                 bnx2x_write_dmae(bp, phys_addr + offset,
591                                  addr + offset, dmae_wr_max);
592                 offset += dmae_wr_max * 4;
593                 len -= dmae_wr_max;
594         }
595
596         bnx2x_write_dmae(bp, phys_addr + offset, addr + offset, len);
597 }
598
599 /* used only for slowpath so not inlined */
600 static void bnx2x_wb_wr(struct bnx2x *bp, int reg, u32 val_hi, u32 val_lo)
601 {
602         u32 wb_write[2];
603
604         wb_write[0] = val_hi;
605         wb_write[1] = val_lo;
606         REG_WR_DMAE(bp, reg, wb_write, 2);
607 }
608
609 #ifdef USE_WB_RD
610 static u64 bnx2x_wb_rd(struct bnx2x *bp, int reg)
611 {
612         u32 wb_data[2];
613
614         REG_RD_DMAE(bp, reg, wb_data, 2);
615
616         return HILO_U64(wb_data[0], wb_data[1]);
617 }
618 #endif
619
620 static int bnx2x_mc_assert(struct bnx2x *bp)
621 {
622         char last_idx;
623         int i, rc = 0;
624         u32 row0, row1, row2, row3;
625
626         /* XSTORM */
627         last_idx = REG_RD8(bp, BAR_XSTRORM_INTMEM +
628                            XSTORM_ASSERT_LIST_INDEX_OFFSET);
629         if (last_idx)
630                 BNX2X_ERR("XSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
631
632         /* print the asserts */
633         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
634
635                 row0 = REG_RD(bp, BAR_XSTRORM_INTMEM +
636                               XSTORM_ASSERT_LIST_OFFSET(i));
637                 row1 = REG_RD(bp, BAR_XSTRORM_INTMEM +
638                               XSTORM_ASSERT_LIST_OFFSET(i) + 4);
639                 row2 = REG_RD(bp, BAR_XSTRORM_INTMEM +
640                               XSTORM_ASSERT_LIST_OFFSET(i) + 8);
641                 row3 = REG_RD(bp, BAR_XSTRORM_INTMEM +
642                               XSTORM_ASSERT_LIST_OFFSET(i) + 12);
643
644                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
645                         BNX2X_ERR("XSTORM_ASSERT_INDEX 0x%x = 0x%08x"
646                                   " 0x%08x 0x%08x 0x%08x\n",
647                                   i, row3, row2, row1, row0);
648                         rc++;
649                 } else {
650                         break;
651                 }
652         }
653
654         /* TSTORM */
655         last_idx = REG_RD8(bp, BAR_TSTRORM_INTMEM +
656                            TSTORM_ASSERT_LIST_INDEX_OFFSET);
657         if (last_idx)
658                 BNX2X_ERR("TSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
659
660         /* print the asserts */
661         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
662
663                 row0 = REG_RD(bp, BAR_TSTRORM_INTMEM +
664                               TSTORM_ASSERT_LIST_OFFSET(i));
665                 row1 = REG_RD(bp, BAR_TSTRORM_INTMEM +
666                               TSTORM_ASSERT_LIST_OFFSET(i) + 4);
667                 row2 = REG_RD(bp, BAR_TSTRORM_INTMEM +
668                               TSTORM_ASSERT_LIST_OFFSET(i) + 8);
669                 row3 = REG_RD(bp, BAR_TSTRORM_INTMEM +
670                               TSTORM_ASSERT_LIST_OFFSET(i) + 12);
671
672                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
673                         BNX2X_ERR("TSTORM_ASSERT_INDEX 0x%x = 0x%08x"
674                                   " 0x%08x 0x%08x 0x%08x\n",
675                                   i, row3, row2, row1, row0);
676                         rc++;
677                 } else {
678                         break;
679                 }
680         }
681
682         /* CSTORM */
683         last_idx = REG_RD8(bp, BAR_CSTRORM_INTMEM +
684                            CSTORM_ASSERT_LIST_INDEX_OFFSET);
685         if (last_idx)
686                 BNX2X_ERR("CSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
687
688         /* print the asserts */
689         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
690
691                 row0 = REG_RD(bp, BAR_CSTRORM_INTMEM +
692                               CSTORM_ASSERT_LIST_OFFSET(i));
693                 row1 = REG_RD(bp, BAR_CSTRORM_INTMEM +
694                               CSTORM_ASSERT_LIST_OFFSET(i) + 4);
695                 row2 = REG_RD(bp, BAR_CSTRORM_INTMEM +
696                               CSTORM_ASSERT_LIST_OFFSET(i) + 8);
697                 row3 = REG_RD(bp, BAR_CSTRORM_INTMEM +
698                               CSTORM_ASSERT_LIST_OFFSET(i) + 12);
699
700                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
701                         BNX2X_ERR("CSTORM_ASSERT_INDEX 0x%x = 0x%08x"
702                                   " 0x%08x 0x%08x 0x%08x\n",
703                                   i, row3, row2, row1, row0);
704                         rc++;
705                 } else {
706                         break;
707                 }
708         }
709
710         /* USTORM */
711         last_idx = REG_RD8(bp, BAR_USTRORM_INTMEM +
712                            USTORM_ASSERT_LIST_INDEX_OFFSET);
713         if (last_idx)
714                 BNX2X_ERR("USTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
715
716         /* print the asserts */
717         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
718
719                 row0 = REG_RD(bp, BAR_USTRORM_INTMEM +
720                               USTORM_ASSERT_LIST_OFFSET(i));
721                 row1 = REG_RD(bp, BAR_USTRORM_INTMEM +
722                               USTORM_ASSERT_LIST_OFFSET(i) + 4);
723                 row2 = REG_RD(bp, BAR_USTRORM_INTMEM +
724                               USTORM_ASSERT_LIST_OFFSET(i) + 8);
725                 row3 = REG_RD(bp, BAR_USTRORM_INTMEM +
726                               USTORM_ASSERT_LIST_OFFSET(i) + 12);
727
728                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
729                         BNX2X_ERR("USTORM_ASSERT_INDEX 0x%x = 0x%08x"
730                                   " 0x%08x 0x%08x 0x%08x\n",
731                                   i, row3, row2, row1, row0);
732                         rc++;
733                 } else {
734                         break;
735                 }
736         }
737
738         return rc;
739 }
740
741 static void bnx2x_fw_dump(struct bnx2x *bp)
742 {
743         u32 addr;
744         u32 mark, offset;
745         __be32 data[9];
746         int word;
747
748         if (BP_NOMCP(bp)) {
749                 BNX2X_ERR("NO MCP - can not dump\n");
750                 return;
751         }
752
753         addr = bp->common.shmem_base - 0x0800 + 4;
754         mark = REG_RD(bp, addr);
755         mark = MCP_REG_MCPR_SCRATCH + ((mark + 0x3) & ~0x3) - 0x08000000;
756         pr_err("begin fw dump (mark 0x%x)\n", mark);
757
758         pr_err("");
759         for (offset = mark; offset <= bp->common.shmem_base; offset += 0x8*4) {
760                 for (word = 0; word < 8; word++)
761                         data[word] = htonl(REG_RD(bp, offset + 4*word));
762                 data[8] = 0x0;
763                 pr_cont("%s", (char *)data);
764         }
765         for (offset = addr + 4; offset <= mark; offset += 0x8*4) {
766                 for (word = 0; word < 8; word++)
767                         data[word] = htonl(REG_RD(bp, offset + 4*word));
768                 data[8] = 0x0;
769                 pr_cont("%s", (char *)data);
770         }
771         pr_err("end of fw dump\n");
772 }
773
774 void bnx2x_panic_dump(struct bnx2x *bp)
775 {
776         int i;
777         u16 j;
778         struct hc_sp_status_block_data sp_sb_data;
779         int func = BP_FUNC(bp);
780 #ifdef BNX2X_STOP_ON_ERROR
781         u16 start = 0, end = 0;
782 #endif
783
784         bp->stats_state = STATS_STATE_DISABLED;
785         DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
786
787         BNX2X_ERR("begin crash dump -----------------\n");
788
789         /* Indices */
790         /* Common */
791         BNX2X_ERR("def_idx(0x%x)  def_att_idx(0x%x)  attn_state(0x%x)"
792                   "  spq_prod_idx(0x%x)\n",
793                   bp->def_idx, bp->def_att_idx,
794                   bp->attn_state, bp->spq_prod_idx);
795         BNX2X_ERR("DSB: attn bits(0x%x)  ack(0x%x)  id(0x%x)  idx(0x%x)\n",
796                   bp->def_status_blk->atten_status_block.attn_bits,
797                   bp->def_status_blk->atten_status_block.attn_bits_ack,
798                   bp->def_status_blk->atten_status_block.status_block_id,
799                   bp->def_status_blk->atten_status_block.attn_bits_index);
800         BNX2X_ERR("     def (");
801         for (i = 0; i < HC_SP_SB_MAX_INDICES; i++)
802                 pr_cont("0x%x%s",
803                        bp->def_status_blk->sp_sb.index_values[i],
804                        (i == HC_SP_SB_MAX_INDICES - 1) ? ")  " : " ");
805
806         for (i = 0; i < sizeof(struct hc_sp_status_block_data)/sizeof(u32); i++)
807                 *((u32 *)&sp_sb_data + i) = REG_RD(bp, BAR_CSTRORM_INTMEM +
808                         CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
809                         i*sizeof(u32));
810
811         pr_cont("igu_sb_id(0x%x)  igu_seg_id (0x%x) "
812                          "pf_id(0x%x)  vnic_id(0x%x)  "
813                          "vf_id(0x%x)  vf_valid (0x%x)\n",
814                sp_sb_data.igu_sb_id,
815                sp_sb_data.igu_seg_id,
816                sp_sb_data.p_func.pf_id,
817                sp_sb_data.p_func.vnic_id,
818                sp_sb_data.p_func.vf_id,
819                sp_sb_data.p_func.vf_valid);
820
821
822         for_each_queue(bp, i) {
823                 struct bnx2x_fastpath *fp = &bp->fp[i];
824                 int loop;
825                 struct hc_status_block_data_e1x sb_data_e1x;
826                 struct hc_status_block_sm  *hc_sm_p =
827                         sb_data_e1x.common.state_machine;
828                 struct hc_index_data *hc_index_p =
829                         sb_data_e1x.index_data;
830                 int data_size;
831                 u32 *sb_data_p;
832
833                 /* Rx */
834                 BNX2X_ERR("fp%d: rx_bd_prod(0x%x)  rx_bd_cons(0x%x)"
835                           "  rx_comp_prod(0x%x)"
836                           "  rx_comp_cons(0x%x)  *rx_cons_sb(0x%x)\n",
837                           i, fp->rx_bd_prod, fp->rx_bd_cons,
838                           fp->rx_comp_prod,
839                           fp->rx_comp_cons, le16_to_cpu(*fp->rx_cons_sb));
840                 BNX2X_ERR("     rx_sge_prod(0x%x)  last_max_sge(0x%x)"
841                           "  fp_hc_idx(0x%x)\n",
842                           fp->rx_sge_prod, fp->last_max_sge,
843                           le16_to_cpu(fp->fp_hc_idx));
844
845                 /* Tx */
846                 BNX2X_ERR("fp%d: tx_pkt_prod(0x%x)  tx_pkt_cons(0x%x)"
847                           "  tx_bd_prod(0x%x)  tx_bd_cons(0x%x)"
848                           "  *tx_cons_sb(0x%x)\n",
849                           i, fp->tx_pkt_prod, fp->tx_pkt_cons, fp->tx_bd_prod,
850                           fp->tx_bd_cons, le16_to_cpu(*fp->tx_cons_sb));
851
852                 loop = HC_SB_MAX_INDICES_E1X;
853
854                 /* host sb data */
855
856                 BNX2X_ERR("     run indexes (");
857                 for (j = 0; j < HC_SB_MAX_SM; j++)
858                         pr_cont("0x%x%s",
859                                fp->sb_running_index[j],
860                                (j == HC_SB_MAX_SM - 1) ? ")" : " ");
861
862                 BNX2X_ERR("     indexes (");
863                 for (j = 0; j < loop; j++)
864                         pr_cont("0x%x%s",
865                                fp->sb_index_values[j],
866                                (j == loop - 1) ? ")" : " ");
867                 /* fw sb data */
868                 data_size =
869                         sizeof(struct hc_status_block_data_e1x);
870                 data_size /= sizeof(u32);
871                 sb_data_p = (u32 *)&sb_data_e1x;
872                 /* copy sb data in here */
873                 for (j = 0; j < data_size; j++)
874                         *(sb_data_p + j) = REG_RD(bp, BAR_CSTRORM_INTMEM +
875                                 CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id) +
876                                 j * sizeof(u32));
877
878                 pr_cont("pf_id(0x%x)  vf_id (0x%x)  vf_valid(0x%x) "
879                         "vnic_id(0x%x)  same_igu_sb_1b(0x%x)\n",
880                         sb_data_e1x.common.p_func.pf_id,
881                         sb_data_e1x.common.p_func.vf_id,
882                         sb_data_e1x.common.p_func.vf_valid,
883                         sb_data_e1x.common.p_func.vnic_id,
884                         sb_data_e1x.common.same_igu_sb_1b);
885
886                 /* SB_SMs data */
887                 for (j = 0; j < HC_SB_MAX_SM; j++) {
888                         pr_cont("SM[%d] __flags (0x%x) "
889                                "igu_sb_id (0x%x)  igu_seg_id(0x%x) "
890                                "time_to_expire (0x%x) "
891                                "timer_value(0x%x)\n", j,
892                                hc_sm_p[j].__flags,
893                                hc_sm_p[j].igu_sb_id,
894                                hc_sm_p[j].igu_seg_id,
895                                hc_sm_p[j].time_to_expire,
896                                hc_sm_p[j].timer_value);
897                 }
898
899                 /* Indecies data */
900                 for (j = 0; j < loop; j++) {
901                         pr_cont("INDEX[%d] flags (0x%x) "
902                                          "timeout (0x%x)\n", j,
903                                hc_index_p[j].flags,
904                                hc_index_p[j].timeout);
905                 }
906         }
907
908 #ifdef BNX2X_STOP_ON_ERROR
909         /* Rings */
910         /* Rx */
911         for_each_queue(bp, i) {
912                 struct bnx2x_fastpath *fp = &bp->fp[i];
913
914                 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
915                 end = RX_BD(le16_to_cpu(*fp->rx_cons_sb) + 503);
916                 for (j = start; j != end; j = RX_BD(j + 1)) {
917                         u32 *rx_bd = (u32 *)&fp->rx_desc_ring[j];
918                         struct sw_rx_bd *sw_bd = &fp->rx_buf_ring[j];
919
920                         BNX2X_ERR("fp%d: rx_bd[%x]=[%x:%x]  sw_bd=[%p]\n",
921                                   i, j, rx_bd[1], rx_bd[0], sw_bd->skb);
922                 }
923
924                 start = RX_SGE(fp->rx_sge_prod);
925                 end = RX_SGE(fp->last_max_sge);
926                 for (j = start; j != end; j = RX_SGE(j + 1)) {
927                         u32 *rx_sge = (u32 *)&fp->rx_sge_ring[j];
928                         struct sw_rx_page *sw_page = &fp->rx_page_ring[j];
929
930                         BNX2X_ERR("fp%d: rx_sge[%x]=[%x:%x]  sw_page=[%p]\n",
931                                   i, j, rx_sge[1], rx_sge[0], sw_page->page);
932                 }
933
934                 start = RCQ_BD(fp->rx_comp_cons - 10);
935                 end = RCQ_BD(fp->rx_comp_cons + 503);
936                 for (j = start; j != end; j = RCQ_BD(j + 1)) {
937                         u32 *cqe = (u32 *)&fp->rx_comp_ring[j];
938
939                         BNX2X_ERR("fp%d: cqe[%x]=[%x:%x:%x:%x]\n",
940                                   i, j, cqe[0], cqe[1], cqe[2], cqe[3]);
941                 }
942         }
943
944         /* Tx */
945         for_each_queue(bp, i) {
946                 struct bnx2x_fastpath *fp = &bp->fp[i];
947
948                 start = TX_BD(le16_to_cpu(*fp->tx_cons_sb) - 10);
949                 end = TX_BD(le16_to_cpu(*fp->tx_cons_sb) + 245);
950                 for (j = start; j != end; j = TX_BD(j + 1)) {
951                         struct sw_tx_bd *sw_bd = &fp->tx_buf_ring[j];
952
953                         BNX2X_ERR("fp%d: packet[%x]=[%p,%x]\n",
954                                   i, j, sw_bd->skb, sw_bd->first_bd);
955                 }
956
957                 start = TX_BD(fp->tx_bd_cons - 10);
958                 end = TX_BD(fp->tx_bd_cons + 254);
959                 for (j = start; j != end; j = TX_BD(j + 1)) {
960                         u32 *tx_bd = (u32 *)&fp->tx_desc_ring[j];
961
962                         BNX2X_ERR("fp%d: tx_bd[%x]=[%x:%x:%x:%x]\n",
963                                   i, j, tx_bd[0], tx_bd[1], tx_bd[2], tx_bd[3]);
964                 }
965         }
966 #endif
967         bnx2x_fw_dump(bp);
968         bnx2x_mc_assert(bp);
969         BNX2X_ERR("end crash dump -----------------\n");
970 }
971
972 void bnx2x_int_enable(struct bnx2x *bp)
973 {
974         int port = BP_PORT(bp);
975         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
976         u32 val = REG_RD(bp, addr);
977         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
978         int msi = (bp->flags & USING_MSI_FLAG) ? 1 : 0;
979
980         if (msix) {
981                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
982                          HC_CONFIG_0_REG_INT_LINE_EN_0);
983                 val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
984                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
985         } else if (msi) {
986                 val &= ~HC_CONFIG_0_REG_INT_LINE_EN_0;
987                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
988                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
989                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
990         } else {
991                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
992                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
993                         HC_CONFIG_0_REG_INT_LINE_EN_0 |
994                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
995
996                 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
997                    val, port, addr);
998
999                 REG_WR(bp, addr, val);
1000
1001                 val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
1002         }
1003
1004         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)  mode %s\n",
1005            val, port, addr, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1006
1007         REG_WR(bp, addr, val);
1008         /*
1009          * Ensure that HC_CONFIG is written before leading/trailing edge config
1010          */
1011         mmiowb();
1012         barrier();
1013
1014         if (CHIP_IS_E1H(bp)) {
1015                 /* init leading/trailing edge */
1016                 if (IS_MF(bp)) {
1017                         val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
1018                         if (bp->port.pmf)
1019                                 /* enable nig and gpio3 attention */
1020                                 val |= 0x1100;
1021                 } else
1022                         val = 0xffff;
1023
1024                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
1025                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
1026         }
1027
1028         /* Make sure that interrupts are indeed enabled from here on */
1029         mmiowb();
1030 }
1031
1032 void bnx2x_int_disable(struct bnx2x *bp)
1033 {
1034         int port = BP_PORT(bp);
1035         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
1036         u32 val = REG_RD(bp, addr);
1037
1038         val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1039                  HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1040                  HC_CONFIG_0_REG_INT_LINE_EN_0 |
1041                  HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1042
1043         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
1044            val, port, addr);
1045
1046         /* flush all outstanding writes */
1047         mmiowb();
1048
1049         REG_WR(bp, addr, val);
1050         if (REG_RD(bp, addr) != val)
1051                 BNX2X_ERR("BUG! proper val not read from IGU!\n");
1052 }
1053
1054 void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
1055 {
1056         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1057         int i, offset;
1058
1059         /* disable interrupt handling */
1060         atomic_inc(&bp->intr_sem);
1061         smp_wmb(); /* Ensure that bp->intr_sem update is SMP-safe */
1062
1063         if (disable_hw)
1064                 /* prevent the HW from sending interrupts */
1065                 bnx2x_int_disable(bp);
1066
1067         /* make sure all ISRs are done */
1068         if (msix) {
1069                 synchronize_irq(bp->msix_table[0].vector);
1070                 offset = 1;
1071 #ifdef BCM_CNIC
1072                 offset++;
1073 #endif
1074                 for_each_queue(bp, i)
1075                         synchronize_irq(bp->msix_table[i + offset].vector);
1076         } else
1077                 synchronize_irq(bp->pdev->irq);
1078
1079         /* make sure sp_task is not running */
1080         cancel_delayed_work(&bp->sp_task);
1081         flush_workqueue(bnx2x_wq);
1082 }
1083
1084 /* fast path */
1085
1086 /*
1087  * General service functions
1088  */
1089
1090 /* Return true if succeeded to acquire the lock */
1091 static bool bnx2x_trylock_hw_lock(struct bnx2x *bp, u32 resource)
1092 {
1093         u32 lock_status;
1094         u32 resource_bit = (1 << resource);
1095         int func = BP_FUNC(bp);
1096         u32 hw_lock_control_reg;
1097
1098         DP(NETIF_MSG_HW, "Trying to take a lock on resource %d\n", resource);
1099
1100         /* Validating that the resource is within range */
1101         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1102                 DP(NETIF_MSG_HW,
1103                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1104                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1105                 return false;
1106         }
1107
1108         if (func <= 5)
1109                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1110         else
1111                 hw_lock_control_reg =
1112                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1113
1114         /* Try to acquire the lock */
1115         REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1116         lock_status = REG_RD(bp, hw_lock_control_reg);
1117         if (lock_status & resource_bit)
1118                 return true;
1119
1120         DP(NETIF_MSG_HW, "Failed to get a lock on resource %d\n", resource);
1121         return false;
1122 }
1123
1124
1125 #ifdef BCM_CNIC
1126 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid);
1127 #endif
1128
1129 void bnx2x_sp_event(struct bnx2x_fastpath *fp,
1130                            union eth_rx_cqe *rr_cqe)
1131 {
1132         struct bnx2x *bp = fp->bp;
1133         int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1134         int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1135
1136         DP(BNX2X_MSG_SP,
1137            "fp %d  cid %d  got ramrod #%d  state is %x  type is %d\n",
1138            fp->index, cid, command, bp->state,
1139            rr_cqe->ramrod_cqe.ramrod_type);
1140
1141         switch (command | fp->state) {
1142         case (RAMROD_CMD_ID_ETH_CLIENT_SETUP | BNX2X_FP_STATE_OPENING):
1143                 DP(NETIF_MSG_IFUP, "got MULTI[%d] setup ramrod\n", cid);
1144                 fp->state = BNX2X_FP_STATE_OPEN;
1145                 break;
1146
1147         case (RAMROD_CMD_ID_ETH_HALT | BNX2X_FP_STATE_HALTING):
1148                 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] halt ramrod\n", cid);
1149                 fp->state = BNX2X_FP_STATE_HALTED;
1150                 break;
1151
1152         case (RAMROD_CMD_ID_ETH_TERMINATE | BNX2X_FP_STATE_TERMINATING):
1153                 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] teminate ramrod\n", cid);
1154                 fp->state = BNX2X_FP_STATE_TERMINATED;
1155                 break;
1156
1157         default:
1158                 BNX2X_ERR("unexpected MC reply (%d)  "
1159                           "fp[%d] state is %x\n",
1160                           command, fp->index, fp->state);
1161                 break;
1162         }
1163
1164         smp_mb__before_atomic_inc();
1165         atomic_inc(&bp->spq_left);
1166         /* push the change in fp->state and towards the memory */
1167         smp_wmb();
1168
1169         return;
1170 }
1171
1172 irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
1173 {
1174         struct bnx2x *bp = netdev_priv(dev_instance);
1175         u16 status = bnx2x_ack_int(bp);
1176         u16 mask;
1177         int i;
1178
1179         /* Return here if interrupt is shared and it's not for us */
1180         if (unlikely(status == 0)) {
1181                 DP(NETIF_MSG_INTR, "not our interrupt!\n");
1182                 return IRQ_NONE;
1183         }
1184         DP(NETIF_MSG_INTR, "got an interrupt  status 0x%x\n", status);
1185
1186         /* Return here if interrupt is disabled */
1187         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
1188                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
1189                 return IRQ_HANDLED;
1190         }
1191
1192 #ifdef BNX2X_STOP_ON_ERROR
1193         if (unlikely(bp->panic))
1194                 return IRQ_HANDLED;
1195 #endif
1196
1197         for (i = 0; i < BNX2X_NUM_QUEUES(bp); i++) {
1198                 struct bnx2x_fastpath *fp = &bp->fp[i];
1199
1200                 mask = 0x2 << (fp->index + CNIC_CONTEXT_USE);
1201                 if (status & mask) {
1202                         /* Handle Rx and Tx according to SB id */
1203                         prefetch(fp->rx_cons_sb);
1204                         prefetch(fp->tx_cons_sb);
1205                         prefetch(&fp->sb_running_index[SM_RX_ID]);
1206                         napi_schedule(&bnx2x_fp(bp, fp->index, napi));
1207                         status &= ~mask;
1208                 }
1209         }
1210
1211 #ifdef BCM_CNIC
1212         mask = 0x2;
1213         if (status & (mask | 0x1)) {
1214                 struct cnic_ops *c_ops = NULL;
1215
1216                 rcu_read_lock();
1217                 c_ops = rcu_dereference(bp->cnic_ops);
1218                 if (c_ops)
1219                         c_ops->cnic_handler(bp->cnic_data, NULL);
1220                 rcu_read_unlock();
1221
1222                 status &= ~mask;
1223         }
1224 #endif
1225
1226         if (unlikely(status & 0x1)) {
1227                 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
1228
1229                 status &= ~0x1;
1230                 if (!status)
1231                         return IRQ_HANDLED;
1232         }
1233
1234         if (unlikely(status))
1235                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
1236                    status);
1237
1238         return IRQ_HANDLED;
1239 }
1240
1241 /* end of fast path */
1242
1243
1244 /* Link */
1245
1246 /*
1247  * General service functions
1248  */
1249
1250 int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource)
1251 {
1252         u32 lock_status;
1253         u32 resource_bit = (1 << resource);
1254         int func = BP_FUNC(bp);
1255         u32 hw_lock_control_reg;
1256         int cnt;
1257
1258         /* Validating that the resource is within range */
1259         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1260                 DP(NETIF_MSG_HW,
1261                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1262                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1263                 return -EINVAL;
1264         }
1265
1266         if (func <= 5) {
1267                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1268         } else {
1269                 hw_lock_control_reg =
1270                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1271         }
1272
1273         /* Validating that the resource is not already taken */
1274         lock_status = REG_RD(bp, hw_lock_control_reg);
1275         if (lock_status & resource_bit) {
1276                 DP(NETIF_MSG_HW, "lock_status 0x%x  resource_bit 0x%x\n",
1277                    lock_status, resource_bit);
1278                 return -EEXIST;
1279         }
1280
1281         /* Try for 5 second every 5ms */
1282         for (cnt = 0; cnt < 1000; cnt++) {
1283                 /* Try to acquire the lock */
1284                 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1285                 lock_status = REG_RD(bp, hw_lock_control_reg);
1286                 if (lock_status & resource_bit)
1287                         return 0;
1288
1289                 msleep(5);
1290         }
1291         DP(NETIF_MSG_HW, "Timeout\n");
1292         return -EAGAIN;
1293 }
1294
1295 int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource)
1296 {
1297         u32 lock_status;
1298         u32 resource_bit = (1 << resource);
1299         int func = BP_FUNC(bp);
1300         u32 hw_lock_control_reg;
1301
1302         DP(NETIF_MSG_HW, "Releasing a lock on resource %d\n", resource);
1303
1304         /* Validating that the resource is within range */
1305         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1306                 DP(NETIF_MSG_HW,
1307                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1308                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1309                 return -EINVAL;
1310         }
1311
1312         if (func <= 5) {
1313                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1314         } else {
1315                 hw_lock_control_reg =
1316                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1317         }
1318
1319         /* Validating that the resource is currently taken */
1320         lock_status = REG_RD(bp, hw_lock_control_reg);
1321         if (!(lock_status & resource_bit)) {
1322                 DP(NETIF_MSG_HW, "lock_status 0x%x  resource_bit 0x%x\n",
1323                    lock_status, resource_bit);
1324                 return -EFAULT;
1325         }
1326
1327         REG_WR(bp, hw_lock_control_reg, resource_bit);
1328         return 0;
1329 }
1330
1331
1332 int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, u8 port)
1333 {
1334         /* The GPIO should be swapped if swap register is set and active */
1335         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1336                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1337         int gpio_shift = gpio_num +
1338                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1339         u32 gpio_mask = (1 << gpio_shift);
1340         u32 gpio_reg;
1341         int value;
1342
1343         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1344                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1345                 return -EINVAL;
1346         }
1347
1348         /* read GPIO value */
1349         gpio_reg = REG_RD(bp, MISC_REG_GPIO);
1350
1351         /* get the requested pin value */
1352         if ((gpio_reg & gpio_mask) == gpio_mask)
1353                 value = 1;
1354         else
1355                 value = 0;
1356
1357         DP(NETIF_MSG_LINK, "pin %d  value 0x%x\n", gpio_num, value);
1358
1359         return value;
1360 }
1361
1362 int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1363 {
1364         /* The GPIO should be swapped if swap register is set and active */
1365         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1366                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1367         int gpio_shift = gpio_num +
1368                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1369         u32 gpio_mask = (1 << gpio_shift);
1370         u32 gpio_reg;
1371
1372         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1373                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1374                 return -EINVAL;
1375         }
1376
1377         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1378         /* read GPIO and mask except the float bits */
1379         gpio_reg = (REG_RD(bp, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
1380
1381         switch (mode) {
1382         case MISC_REGISTERS_GPIO_OUTPUT_LOW:
1383                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output low\n",
1384                    gpio_num, gpio_shift);
1385                 /* clear FLOAT and set CLR */
1386                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1387                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
1388                 break;
1389
1390         case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
1391                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output high\n",
1392                    gpio_num, gpio_shift);
1393                 /* clear FLOAT and set SET */
1394                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1395                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
1396                 break;
1397
1398         case MISC_REGISTERS_GPIO_INPUT_HI_Z:
1399                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> input\n",
1400                    gpio_num, gpio_shift);
1401                 /* set FLOAT */
1402                 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1403                 break;
1404
1405         default:
1406                 break;
1407         }
1408
1409         REG_WR(bp, MISC_REG_GPIO, gpio_reg);
1410         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1411
1412         return 0;
1413 }
1414
1415 int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1416 {
1417         /* The GPIO should be swapped if swap register is set and active */
1418         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1419                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1420         int gpio_shift = gpio_num +
1421                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1422         u32 gpio_mask = (1 << gpio_shift);
1423         u32 gpio_reg;
1424
1425         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1426                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1427                 return -EINVAL;
1428         }
1429
1430         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1431         /* read GPIO int */
1432         gpio_reg = REG_RD(bp, MISC_REG_GPIO_INT);
1433
1434         switch (mode) {
1435         case MISC_REGISTERS_GPIO_INT_OUTPUT_CLR:
1436                 DP(NETIF_MSG_LINK, "Clear GPIO INT %d (shift %d) -> "
1437                                    "output low\n", gpio_num, gpio_shift);
1438                 /* clear SET and set CLR */
1439                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1440                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1441                 break;
1442
1443         case MISC_REGISTERS_GPIO_INT_OUTPUT_SET:
1444                 DP(NETIF_MSG_LINK, "Set GPIO INT %d (shift %d) -> "
1445                                    "output high\n", gpio_num, gpio_shift);
1446                 /* clear CLR and set SET */
1447                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1448                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1449                 break;
1450
1451         default:
1452                 break;
1453         }
1454
1455         REG_WR(bp, MISC_REG_GPIO_INT, gpio_reg);
1456         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1457
1458         return 0;
1459 }
1460
1461 static int bnx2x_set_spio(struct bnx2x *bp, int spio_num, u32 mode)
1462 {
1463         u32 spio_mask = (1 << spio_num);
1464         u32 spio_reg;
1465
1466         if ((spio_num < MISC_REGISTERS_SPIO_4) ||
1467             (spio_num > MISC_REGISTERS_SPIO_7)) {
1468                 BNX2X_ERR("Invalid SPIO %d\n", spio_num);
1469                 return -EINVAL;
1470         }
1471
1472         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1473         /* read SPIO and mask except the float bits */
1474         spio_reg = (REG_RD(bp, MISC_REG_SPIO) & MISC_REGISTERS_SPIO_FLOAT);
1475
1476         switch (mode) {
1477         case MISC_REGISTERS_SPIO_OUTPUT_LOW:
1478                 DP(NETIF_MSG_LINK, "Set SPIO %d -> output low\n", spio_num);
1479                 /* clear FLOAT and set CLR */
1480                 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1481                 spio_reg |=  (spio_mask << MISC_REGISTERS_SPIO_CLR_POS);
1482                 break;
1483
1484         case MISC_REGISTERS_SPIO_OUTPUT_HIGH:
1485                 DP(NETIF_MSG_LINK, "Set SPIO %d -> output high\n", spio_num);
1486                 /* clear FLOAT and set SET */
1487                 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1488                 spio_reg |=  (spio_mask << MISC_REGISTERS_SPIO_SET_POS);
1489                 break;
1490
1491         case MISC_REGISTERS_SPIO_INPUT_HI_Z:
1492                 DP(NETIF_MSG_LINK, "Set SPIO %d -> input\n", spio_num);
1493                 /* set FLOAT */
1494                 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1495                 break;
1496
1497         default:
1498                 break;
1499         }
1500
1501         REG_WR(bp, MISC_REG_SPIO, spio_reg);
1502         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1503
1504         return 0;
1505 }
1506
1507 int bnx2x_get_link_cfg_idx(struct bnx2x *bp)
1508 {
1509         u32 sel_phy_idx = 0;
1510         if (bp->link_vars.link_up) {
1511                 sel_phy_idx = EXT_PHY1;
1512                 /* In case link is SERDES, check if the EXT_PHY2 is the one */
1513                 if ((bp->link_vars.link_status & LINK_STATUS_SERDES_LINK) &&
1514                     (bp->link_params.phy[EXT_PHY2].supported & SUPPORTED_FIBRE))
1515                         sel_phy_idx = EXT_PHY2;
1516         } else {
1517
1518                 switch (bnx2x_phy_selection(&bp->link_params)) {
1519                 case PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT:
1520                 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY:
1521                 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY:
1522                        sel_phy_idx = EXT_PHY1;
1523                        break;
1524                 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY:
1525                 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY:
1526                        sel_phy_idx = EXT_PHY2;
1527                        break;
1528                 }
1529         }
1530         /*
1531         * The selected actived PHY is always after swapping (in case PHY
1532         * swapping is enabled). So when swapping is enabled, we need to reverse
1533         * the configuration
1534         */
1535
1536         if (bp->link_params.multi_phy_config &
1537             PORT_HW_CFG_PHY_SWAPPED_ENABLED) {
1538                 if (sel_phy_idx == EXT_PHY1)
1539                         sel_phy_idx = EXT_PHY2;
1540                 else if (sel_phy_idx == EXT_PHY2)
1541                         sel_phy_idx = EXT_PHY1;
1542         }
1543         return LINK_CONFIG_IDX(sel_phy_idx);
1544 }
1545
1546 void bnx2x_calc_fc_adv(struct bnx2x *bp)
1547 {
1548         u8 cfg_idx = bnx2x_get_link_cfg_idx(bp);
1549         switch (bp->link_vars.ieee_fc &
1550                 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
1551         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
1552                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1553                                           ADVERTISED_Pause);
1554                 break;
1555
1556         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
1557                 bp->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
1558                                          ADVERTISED_Pause);
1559                 break;
1560
1561         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
1562                 bp->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
1563                 break;
1564
1565         default:
1566                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1567                                           ADVERTISED_Pause);
1568                 break;
1569         }
1570 }
1571
1572
1573 u8 bnx2x_initial_phy_init(struct bnx2x *bp, int load_mode)
1574 {
1575         if (!BP_NOMCP(bp)) {
1576                 u8 rc;
1577                 int cfx_idx = bnx2x_get_link_cfg_idx(bp);
1578                 u16 req_line_speed = bp->link_params.req_line_speed[cfx_idx];
1579                 /* Initialize link parameters structure variables */
1580                 /* It is recommended to turn off RX FC for jumbo frames
1581                    for better performance */
1582                 if (bp->dev->mtu > 5000)
1583                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_TX;
1584                 else
1585                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
1586
1587                 bnx2x_acquire_phy_lock(bp);
1588
1589                 if (load_mode == LOAD_DIAG) {
1590                         bp->link_params.loopback_mode = LOOPBACK_XGXS;
1591                         bp->link_params.req_line_speed[cfx_idx] = SPEED_10000;
1592                 }
1593
1594                 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1595
1596                 bnx2x_release_phy_lock(bp);
1597
1598                 bnx2x_calc_fc_adv(bp);
1599
1600                 if (CHIP_REV_IS_SLOW(bp) && bp->link_vars.link_up) {
1601                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
1602                         bnx2x_link_report(bp);
1603                 }
1604                 bp->link_params.req_line_speed[cfx_idx] = req_line_speed;
1605                 return rc;
1606         }
1607         BNX2X_ERR("Bootcode is missing - can not initialize link\n");
1608         return -EINVAL;
1609 }
1610
1611 void bnx2x_link_set(struct bnx2x *bp)
1612 {
1613         if (!BP_NOMCP(bp)) {
1614                 bnx2x_acquire_phy_lock(bp);
1615                 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1616                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1617                 bnx2x_release_phy_lock(bp);
1618
1619                 bnx2x_calc_fc_adv(bp);
1620         } else
1621                 BNX2X_ERR("Bootcode is missing - can not set link\n");
1622 }
1623
1624 static void bnx2x__link_reset(struct bnx2x *bp)
1625 {
1626         if (!BP_NOMCP(bp)) {
1627                 bnx2x_acquire_phy_lock(bp);
1628                 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1629                 bnx2x_release_phy_lock(bp);
1630         } else
1631                 BNX2X_ERR("Bootcode is missing - can not reset link\n");
1632 }
1633
1634 u8 bnx2x_link_test(struct bnx2x *bp, u8 is_serdes)
1635 {
1636         u8 rc = 0;
1637
1638         if (!BP_NOMCP(bp)) {
1639                 bnx2x_acquire_phy_lock(bp);
1640                 rc = bnx2x_test_link(&bp->link_params, &bp->link_vars,
1641                                      is_serdes);
1642                 bnx2x_release_phy_lock(bp);
1643         } else
1644                 BNX2X_ERR("Bootcode is missing - can not test link\n");
1645
1646         return rc;
1647 }
1648
1649 static void bnx2x_init_port_minmax(struct bnx2x *bp)
1650 {
1651         u32 r_param = bp->link_vars.line_speed / 8;
1652         u32 fair_periodic_timeout_usec;
1653         u32 t_fair;
1654
1655         memset(&(bp->cmng.rs_vars), 0,
1656                sizeof(struct rate_shaping_vars_per_port));
1657         memset(&(bp->cmng.fair_vars), 0, sizeof(struct fairness_vars_per_port));
1658
1659         /* 100 usec in SDM ticks = 25 since each tick is 4 usec */
1660         bp->cmng.rs_vars.rs_periodic_timeout = RS_PERIODIC_TIMEOUT_USEC / 4;
1661
1662         /* this is the threshold below which no timer arming will occur
1663            1.25 coefficient is for the threshold to be a little bigger
1664            than the real time, to compensate for timer in-accuracy */
1665         bp->cmng.rs_vars.rs_threshold =
1666                                 (RS_PERIODIC_TIMEOUT_USEC * r_param * 5) / 4;
1667
1668         /* resolution of fairness timer */
1669         fair_periodic_timeout_usec = QM_ARB_BYTES / r_param;
1670         /* for 10G it is 1000usec. for 1G it is 10000usec. */
1671         t_fair = T_FAIR_COEF / bp->link_vars.line_speed;
1672
1673         /* this is the threshold below which we won't arm the timer anymore */
1674         bp->cmng.fair_vars.fair_threshold = QM_ARB_BYTES;
1675
1676         /* we multiply by 1e3/8 to get bytes/msec.
1677            We don't want the credits to pass a credit
1678            of the t_fair*FAIR_MEM (algorithm resolution) */
1679         bp->cmng.fair_vars.upper_bound = r_param * t_fair * FAIR_MEM;
1680         /* since each tick is 4 usec */
1681         bp->cmng.fair_vars.fairness_timeout = fair_periodic_timeout_usec / 4;
1682 }
1683
1684 /* Calculates the sum of vn_min_rates.
1685    It's needed for further normalizing of the min_rates.
1686    Returns:
1687      sum of vn_min_rates.
1688        or
1689      0 - if all the min_rates are 0.
1690      In the later case fainess algorithm should be deactivated.
1691      If not all min_rates are zero then those that are zeroes will be set to 1.
1692  */
1693 static void bnx2x_calc_vn_weight_sum(struct bnx2x *bp)
1694 {
1695         int all_zero = 1;
1696         int port = BP_PORT(bp);
1697         int vn;
1698
1699         bp->vn_weight_sum = 0;
1700         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
1701                 int func = 2*vn + port;
1702                 u32 vn_cfg = MF_CFG_RD(bp, func_mf_config[func].config);
1703                 u32 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1704                                    FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1705
1706                 /* Skip hidden vns */
1707                 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
1708                         continue;
1709
1710                 /* If min rate is zero - set it to 1 */
1711                 if (!vn_min_rate)
1712                         vn_min_rate = DEF_MIN_RATE;
1713                 else
1714                         all_zero = 0;
1715
1716                 bp->vn_weight_sum += vn_min_rate;
1717         }
1718
1719         /* ... only if all min rates are zeros - disable fairness */
1720         if (all_zero) {
1721                 bp->cmng.flags.cmng_enables &=
1722                                         ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1723                 DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
1724                    "  fairness will be disabled\n");
1725         } else
1726                 bp->cmng.flags.cmng_enables |=
1727                                         CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1728 }
1729
1730 static void bnx2x_init_vn_minmax(struct bnx2x *bp, int func)
1731 {
1732         struct rate_shaping_vars_per_vn m_rs_vn;
1733         struct fairness_vars_per_vn m_fair_vn;
1734         u32 vn_cfg = MF_CFG_RD(bp, func_mf_config[func].config);
1735         u16 vn_min_rate, vn_max_rate;
1736         int i;
1737
1738         /* If function is hidden - set min and max to zeroes */
1739         if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE) {
1740                 vn_min_rate = 0;
1741                 vn_max_rate = 0;
1742
1743         } else {
1744                 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1745                                 FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1746                 /* If min rate is zero - set it to 1 */
1747                 if (!vn_min_rate)
1748                         vn_min_rate = DEF_MIN_RATE;
1749                 vn_max_rate = ((vn_cfg & FUNC_MF_CFG_MAX_BW_MASK) >>
1750                                 FUNC_MF_CFG_MAX_BW_SHIFT) * 100;
1751         }
1752         DP(NETIF_MSG_IFUP,
1753            "func %d: vn_min_rate %d  vn_max_rate %d  vn_weight_sum %d\n",
1754            func, vn_min_rate, vn_max_rate, bp->vn_weight_sum);
1755
1756         memset(&m_rs_vn, 0, sizeof(struct rate_shaping_vars_per_vn));
1757         memset(&m_fair_vn, 0, sizeof(struct fairness_vars_per_vn));
1758
1759         /* global vn counter - maximal Mbps for this vn */
1760         m_rs_vn.vn_counter.rate = vn_max_rate;
1761
1762         /* quota - number of bytes transmitted in this period */
1763         m_rs_vn.vn_counter.quota =
1764                                 (vn_max_rate * RS_PERIODIC_TIMEOUT_USEC) / 8;
1765
1766         if (bp->vn_weight_sum) {
1767                 /* credit for each period of the fairness algorithm:
1768                    number of bytes in T_FAIR (the vn share the port rate).
1769                    vn_weight_sum should not be larger than 10000, thus
1770                    T_FAIR_COEF / (8 * vn_weight_sum) will always be greater
1771                    than zero */
1772                 m_fair_vn.vn_credit_delta =
1773                         max_t(u32, (vn_min_rate * (T_FAIR_COEF /
1774                                                    (8 * bp->vn_weight_sum))),
1775                               (bp->cmng.fair_vars.fair_threshold * 2));
1776                 DP(NETIF_MSG_IFUP, "m_fair_vn.vn_credit_delta %d\n",
1777                    m_fair_vn.vn_credit_delta);
1778         }
1779
1780         /* Store it to internal memory */
1781         for (i = 0; i < sizeof(struct rate_shaping_vars_per_vn)/4; i++)
1782                 REG_WR(bp, BAR_XSTRORM_INTMEM +
1783                        XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func) + i * 4,
1784                        ((u32 *)(&m_rs_vn))[i]);
1785
1786         for (i = 0; i < sizeof(struct fairness_vars_per_vn)/4; i++)
1787                 REG_WR(bp, BAR_XSTRORM_INTMEM +
1788                        XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func) + i * 4,
1789                        ((u32 *)(&m_fair_vn))[i]);
1790 }
1791 static int bnx2x_get_cmng_fns_mode(struct bnx2x *bp)
1792 {
1793         if (CHIP_REV_IS_SLOW(bp))
1794                 return CMNG_FNS_NONE;
1795         if (IS_MF(bp))
1796                 return CMNG_FNS_MINMAX;
1797
1798         return CMNG_FNS_NONE;
1799 }
1800
1801 static void bnx2x_read_mf_cfg(struct bnx2x *bp)
1802 {
1803         int vn;
1804
1805         if (BP_NOMCP(bp))
1806                 return; /* what should be the default bvalue in this case */
1807
1808         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
1809                 int /*abs*/func = 2*vn + BP_PORT(bp);
1810                 bp->mf_config =
1811                         MF_CFG_RD(bp, func_mf_config[func].config);
1812         }
1813 }
1814
1815 static void bnx2x_cmng_fns_init(struct bnx2x *bp, u8 read_cfg, u8 cmng_type)
1816 {
1817
1818         if (cmng_type == CMNG_FNS_MINMAX) {
1819                 int vn;
1820
1821                 /* clear cmng_enables */
1822                 bp->cmng.flags.cmng_enables = 0;
1823
1824                 /* read mf conf from shmem */
1825                 if (read_cfg)
1826                         bnx2x_read_mf_cfg(bp);
1827
1828                 /* Init rate shaping and fairness contexts */
1829                 bnx2x_init_port_minmax(bp);
1830
1831                 /* vn_weight_sum and enable fairness if not 0 */
1832                 bnx2x_calc_vn_weight_sum(bp);
1833
1834                 /* calculate and set min-max rate for each vn */
1835                 for (vn = VN_0; vn < E1HVN_MAX; vn++)
1836                         bnx2x_init_vn_minmax(bp, vn);
1837
1838                 /* always enable rate shaping and fairness */
1839                 bp->cmng.flags.cmng_enables |=
1840                                         CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN;
1841                 if (!bp->vn_weight_sum)
1842                         DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
1843                                    "  fairness will be disabled\n");
1844                 return;
1845         }
1846
1847         /* rate shaping and fairness are disabled */
1848         DP(NETIF_MSG_IFUP,
1849            "rate shaping and fairness are disabled\n");
1850 }
1851
1852 static inline void bnx2x_link_sync_notify(struct bnx2x *bp)
1853 {
1854         int port = BP_PORT(bp);
1855         int func;
1856         int vn;
1857
1858         /* Set the attention towards other drivers on the same port */
1859         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
1860                 if (vn == BP_E1HVN(bp))
1861                         continue;
1862
1863                 func = ((vn << 1) | port);
1864                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_0 +
1865                        (LINK_SYNC_ATTENTION_BIT_FUNC_0 + func)*4, 1);
1866         }
1867 }
1868
1869 /* This function is called upon link interrupt */
1870 static void bnx2x_link_attn(struct bnx2x *bp)
1871 {
1872         u32 prev_link_status = bp->link_vars.link_status;
1873         /* Make sure that we are synced with the current statistics */
1874         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
1875
1876         bnx2x_link_update(&bp->link_params, &bp->link_vars);
1877
1878         if (bp->link_vars.link_up) {
1879
1880                 /* dropless flow control */
1881                 if (CHIP_IS_E1H(bp) && bp->dropless_fc) {
1882                         int port = BP_PORT(bp);
1883                         u32 pause_enabled = 0;
1884
1885                         if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
1886                                 pause_enabled = 1;
1887
1888                         REG_WR(bp, BAR_USTRORM_INTMEM +
1889                                USTORM_ETH_PAUSE_ENABLED_OFFSET(port),
1890                                pause_enabled);
1891                 }
1892
1893                 if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
1894                         struct host_port_stats *pstats;
1895
1896                         pstats = bnx2x_sp(bp, port_stats);
1897                         /* reset old bmac stats */
1898                         memset(&(pstats->mac_stx[0]), 0,
1899                                sizeof(struct mac_stx));
1900                 }
1901                 if (bp->state == BNX2X_STATE_OPEN)
1902                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
1903         }
1904
1905         /* indicate link status only if link status actually changed */
1906         if (prev_link_status != bp->link_vars.link_status)
1907                 bnx2x_link_report(bp);
1908
1909         if (IS_MF(bp)) {
1910                 int port = BP_PORT(bp);
1911                 int func;
1912                 int vn;
1913
1914                 /* Set the attention towards other drivers on the same port */
1915                 for (vn = VN_0; vn < E1HVN_MAX; vn++) {
1916                         if (vn == BP_E1HVN(bp))
1917                                 continue;
1918
1919                         func = ((vn << 1) | port);
1920                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_0 +
1921                                (LINK_SYNC_ATTENTION_BIT_FUNC_0 + func)*4, 1);
1922                 }
1923
1924                 if (bp->link_vars.link_up) {
1925                         int i;
1926
1927                         /* Init rate shaping and fairness contexts */
1928                         bnx2x_init_port_minmax(bp);
1929
1930                         for (vn = VN_0; vn < E1HVN_MAX; vn++)
1931                                 bnx2x_init_vn_minmax(bp, 2*vn + port);
1932
1933                         /* Store it to internal memory */
1934                         for (i = 0;
1935                              i < sizeof(struct cmng_struct_per_port) / 4; i++)
1936                                 REG_WR(bp, BAR_XSTRORM_INTMEM +
1937                                   XSTORM_CMNG_PER_PORT_VARS_OFFSET(port) + i*4,
1938                                        ((u32 *)(&bp->cmng))[i]);
1939                 }
1940         }
1941 }
1942
1943 void bnx2x__link_status_update(struct bnx2x *bp)
1944 {
1945         if ((bp->state != BNX2X_STATE_OPEN) || (bp->flags & MF_FUNC_DIS))
1946                 return;
1947
1948         bnx2x_link_status_update(&bp->link_params, &bp->link_vars);
1949
1950         if (bp->link_vars.link_up)
1951                 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
1952         else
1953                 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
1954
1955         bnx2x_calc_vn_weight_sum(bp);
1956
1957         /* indicate link status */
1958         bnx2x_link_report(bp);
1959 }
1960
1961 static void bnx2x_pmf_update(struct bnx2x *bp)
1962 {
1963         int port = BP_PORT(bp);
1964         u32 val;
1965
1966         bp->port.pmf = 1;
1967         DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
1968
1969         /* enable nig attention */
1970         val = (0xff0f | (1 << (BP_E1HVN(bp) + 4)));
1971         REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
1972         REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
1973
1974         bnx2x_stats_handle(bp, STATS_EVENT_PMF);
1975 }
1976
1977 /* end of Link */
1978
1979 /* slow path */
1980
1981 /*
1982  * General service functions
1983  */
1984
1985 /* send the MCP a request, block until there is a reply */
1986 u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param)
1987 {
1988         int func = BP_FUNC(bp);
1989         u32 seq = ++bp->fw_seq;
1990         u32 rc = 0;
1991         u32 cnt = 1;
1992         u8 delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
1993
1994         mutex_lock(&bp->fw_mb_mutex);
1995         SHMEM_WR(bp, func_mb[func].drv_mb_param, param);
1996         SHMEM_WR(bp, func_mb[func].drv_mb_header, (command | seq));
1997         DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB\n", (command | seq));
1998
1999         do {
2000                 /* let the FW do it's magic ... */
2001                 msleep(delay);
2002
2003                 rc = SHMEM_RD(bp, func_mb[func].fw_mb_header);
2004
2005                 /* Give the FW up to 5 second (500*10ms) */
2006         } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
2007
2008         DP(BNX2X_MSG_MCP, "[after %d ms] read (%x) seq is (%x) from FW MB\n",
2009            cnt*delay, rc, seq);
2010
2011         /* is this a reply to our command? */
2012         if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK))
2013                 rc &= FW_MSG_CODE_MASK;
2014         else {
2015                 /* FW BUG! */
2016                 BNX2X_ERR("FW failed to respond!\n");
2017                 bnx2x_fw_dump(bp);
2018                 rc = 0;
2019         }
2020         mutex_unlock(&bp->fw_mb_mutex);
2021
2022         return rc;
2023 }
2024
2025 /* must be called under rtnl_lock */
2026 void bnx2x_rxq_set_mac_filters(struct bnx2x *bp, u16 cl_id, u32 filters)
2027 {
2028         u32 mask = (1 << cl_id);
2029
2030         /* initial seeting is BNX2X_ACCEPT_NONE */
2031         u8 drop_all_ucast = 1, drop_all_bcast = 1, drop_all_mcast = 1;
2032         u8 accp_all_ucast = 0, accp_all_bcast = 0, accp_all_mcast = 0;
2033         u8 unmatched_unicast = 0;
2034
2035         if (filters & BNX2X_PROMISCUOUS_MODE) {
2036                 /* promiscious - accept all, drop none */
2037                 drop_all_ucast = drop_all_bcast = drop_all_mcast = 0;
2038                 accp_all_ucast = accp_all_bcast = accp_all_mcast = 1;
2039         }
2040         if (filters & BNX2X_ACCEPT_UNICAST) {
2041                 /* accept matched ucast */
2042                 drop_all_ucast = 0;
2043         }
2044         if (filters & BNX2X_ACCEPT_MULTICAST) {
2045                 /* accept matched mcast */
2046                 drop_all_mcast = 0;
2047         }
2048         if (filters & BNX2X_ACCEPT_ALL_UNICAST) {
2049                 /* accept all mcast */
2050                 drop_all_ucast = 0;
2051                 accp_all_ucast = 1;
2052         }
2053         if (filters & BNX2X_ACCEPT_ALL_MULTICAST) {
2054                 /* accept all mcast */
2055                 drop_all_mcast = 0;
2056                 accp_all_mcast = 1;
2057         }
2058         if (filters & BNX2X_ACCEPT_BROADCAST) {
2059                 /* accept (all) bcast */
2060                 drop_all_bcast = 0;
2061                 accp_all_bcast = 1;
2062         }
2063
2064         bp->mac_filters.ucast_drop_all = drop_all_ucast ?
2065                 bp->mac_filters.ucast_drop_all | mask :
2066                 bp->mac_filters.ucast_drop_all & ~mask;
2067
2068         bp->mac_filters.mcast_drop_all = drop_all_mcast ?
2069                 bp->mac_filters.mcast_drop_all | mask :
2070                 bp->mac_filters.mcast_drop_all & ~mask;
2071
2072         bp->mac_filters.bcast_drop_all = drop_all_bcast ?
2073                 bp->mac_filters.bcast_drop_all | mask :
2074                 bp->mac_filters.bcast_drop_all & ~mask;
2075
2076         bp->mac_filters.ucast_accept_all = accp_all_ucast ?
2077                 bp->mac_filters.ucast_accept_all | mask :
2078                 bp->mac_filters.ucast_accept_all & ~mask;
2079
2080         bp->mac_filters.mcast_accept_all = accp_all_mcast ?
2081                 bp->mac_filters.mcast_accept_all | mask :
2082                 bp->mac_filters.mcast_accept_all & ~mask;
2083
2084         bp->mac_filters.bcast_accept_all = accp_all_bcast ?
2085                 bp->mac_filters.bcast_accept_all | mask :
2086                 bp->mac_filters.bcast_accept_all & ~mask;
2087
2088         bp->mac_filters.unmatched_unicast = unmatched_unicast ?
2089                 bp->mac_filters.unmatched_unicast | mask :
2090                 bp->mac_filters.unmatched_unicast & ~mask;
2091 }
2092
2093 void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p)
2094 {
2095         if (FUNC_CONFIG(p->func_flgs)) {
2096                 struct tstorm_eth_function_common_config tcfg = {0};
2097
2098                 /* tpa */
2099                 if (p->func_flgs & FUNC_FLG_TPA)
2100                         tcfg.config_flags |=
2101                         TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA;
2102
2103                 /* set rss flags */
2104                 if (p->func_flgs & FUNC_FLG_RSS) {
2105                         u16 rss_flgs = (p->rss->mode <<
2106                         TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT);
2107
2108                         if (p->rss->cap & RSS_IPV4_CAP)
2109                                 rss_flgs |= RSS_IPV4_CAP_MASK;
2110                         if (p->rss->cap & RSS_IPV4_TCP_CAP)
2111                                 rss_flgs |= RSS_IPV4_TCP_CAP_MASK;
2112                         if (p->rss->cap & RSS_IPV6_CAP)
2113                                 rss_flgs |= RSS_IPV6_CAP_MASK;
2114                         if (p->rss->cap & RSS_IPV6_TCP_CAP)
2115                                 rss_flgs |= RSS_IPV6_TCP_CAP_MASK;
2116
2117                         tcfg.config_flags |= rss_flgs;
2118                         tcfg.rss_result_mask = p->rss->result_mask;
2119
2120                 }
2121
2122                 storm_memset_func_cfg(bp, &tcfg, p->func_id);
2123         }
2124
2125         /* Enable the function in the FW */
2126         storm_memset_vf_to_pf(bp, p->func_id, p->pf_id);
2127         storm_memset_func_en(bp, p->func_id, 1);
2128
2129         /* statistics */
2130         if (p->func_flgs & FUNC_FLG_STATS) {
2131                 struct stats_indication_flags stats_flags = {0};
2132                 stats_flags.collect_eth = 1;
2133
2134                 storm_memset_xstats_flags(bp, &stats_flags, p->func_id);
2135                 storm_memset_xstats_addr(bp, p->fw_stat_map, p->func_id);
2136
2137                 storm_memset_tstats_flags(bp, &stats_flags, p->func_id);
2138                 storm_memset_tstats_addr(bp, p->fw_stat_map, p->func_id);
2139
2140                 storm_memset_ustats_flags(bp, &stats_flags, p->func_id);
2141                 storm_memset_ustats_addr(bp, p->fw_stat_map, p->func_id);
2142
2143                 storm_memset_cstats_flags(bp, &stats_flags, p->func_id);
2144                 storm_memset_cstats_addr(bp, p->fw_stat_map, p->func_id);
2145         }
2146
2147         /* spq */
2148         if (p->func_flgs & FUNC_FLG_SPQ) {
2149                 storm_memset_spq_addr(bp, p->spq_map, p->func_id);
2150                 REG_WR(bp, XSEM_REG_FAST_MEMORY +
2151                        XSTORM_SPQ_PROD_OFFSET(p->func_id), p->spq_prod);
2152         }
2153 }
2154
2155 static inline u16 bnx2x_get_cl_flags(struct bnx2x *bp,
2156                                      struct bnx2x_fastpath *fp)
2157 {
2158         u16 flags = 0;
2159
2160         /* calculate queue flags */
2161         flags |= QUEUE_FLG_CACHE_ALIGN;
2162         flags |= QUEUE_FLG_HC;
2163         flags |= IS_MF(bp) ? QUEUE_FLG_OV : 0;
2164
2165 #ifdef BCM_VLAN
2166         flags |= QUEUE_FLG_VLAN;
2167         DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
2168 #endif
2169
2170         if (!fp->disable_tpa)
2171                 flags |= QUEUE_FLG_TPA;
2172
2173         flags |= QUEUE_FLG_STATS;
2174
2175         return flags;
2176 }
2177
2178 static void bnx2x_pf_rx_cl_prep(struct bnx2x *bp,
2179         struct bnx2x_fastpath *fp, struct rxq_pause_params *pause,
2180         struct bnx2x_rxq_init_params *rxq_init)
2181 {
2182         u16 max_sge = 0;
2183         u16 sge_sz = 0;
2184         u16 tpa_agg_size = 0;
2185
2186         /* calculate queue flags */
2187         u16 flags = bnx2x_get_cl_flags(bp, fp);
2188
2189         if (!fp->disable_tpa) {
2190                 pause->sge_th_hi = 250;
2191                 pause->sge_th_lo = 150;
2192                 tpa_agg_size = min_t(u32,
2193                         (min_t(u32, 8, MAX_SKB_FRAGS) *
2194                         SGE_PAGE_SIZE * PAGES_PER_SGE), 0xffff);
2195                 max_sge = SGE_PAGE_ALIGN(bp->dev->mtu) >>
2196                         SGE_PAGE_SHIFT;
2197                 max_sge = ((max_sge + PAGES_PER_SGE - 1) &
2198                           (~(PAGES_PER_SGE-1))) >> PAGES_PER_SGE_SHIFT;
2199                 sge_sz = (u16)min_t(u32, SGE_PAGE_SIZE * PAGES_PER_SGE,
2200                                     0xffff);
2201         }
2202
2203         /* pause - not for e1 */
2204         if (!CHIP_IS_E1(bp)) {
2205                 pause->bd_th_hi = 350;
2206                 pause->bd_th_lo = 250;
2207                 pause->rcq_th_hi = 350;
2208                 pause->rcq_th_lo = 250;
2209                 pause->sge_th_hi = 0;
2210                 pause->sge_th_lo = 0;
2211                 pause->pri_map = 1;
2212         }
2213
2214         /* rxq setup */
2215         rxq_init->flags = flags;
2216         rxq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2217         rxq_init->dscr_map = fp->rx_desc_mapping;
2218         rxq_init->sge_map = fp->rx_sge_mapping;
2219         rxq_init->rcq_map = fp->rx_comp_mapping;
2220         rxq_init->rcq_np_map = fp->rx_comp_mapping + BCM_PAGE_SIZE;
2221         rxq_init->mtu = bp->dev->mtu;
2222         rxq_init->buf_sz = bp->rx_buf_size;
2223         rxq_init->cl_qzone_id = fp->cl_qzone_id;
2224         rxq_init->cl_id = fp->cl_id;
2225         rxq_init->spcl_id = fp->cl_id;
2226         rxq_init->stat_id = fp->cl_id;
2227         rxq_init->tpa_agg_sz = tpa_agg_size;
2228         rxq_init->sge_buf_sz = sge_sz;
2229         rxq_init->max_sges_pkt = max_sge;
2230         rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
2231         rxq_init->fw_sb_id = fp->fw_sb_id;
2232
2233         rxq_init->sb_cq_index = U_SB_ETH_RX_CQ_INDEX;
2234
2235         rxq_init->cid = HW_CID(bp, fp->cid);
2236
2237         rxq_init->hc_rate = bp->rx_ticks ? (1000000 / bp->rx_ticks) : 0;
2238 }
2239
2240 static void bnx2x_pf_tx_cl_prep(struct bnx2x *bp,
2241         struct bnx2x_fastpath *fp, struct bnx2x_txq_init_params *txq_init)
2242 {
2243         u16 flags = bnx2x_get_cl_flags(bp, fp);
2244
2245         txq_init->flags = flags;
2246         txq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2247         txq_init->dscr_map = fp->tx_desc_mapping;
2248         txq_init->stat_id = fp->cl_id;
2249         txq_init->cid = HW_CID(bp, fp->cid);
2250         txq_init->sb_cq_index = C_SB_ETH_TX_CQ_INDEX;
2251         txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
2252         txq_init->fw_sb_id = fp->fw_sb_id;
2253         txq_init->hc_rate = bp->tx_ticks ? (1000000 / bp->tx_ticks) : 0;
2254 }
2255
2256 void bnx2x_pf_init(struct bnx2x *bp)
2257 {
2258         struct bnx2x_func_init_params func_init = {0};
2259         struct bnx2x_rss_params rss = {0};
2260         struct event_ring_data eq_data = { {0} };
2261         u16 flags;
2262
2263         /* pf specific setups */
2264         if (!CHIP_IS_E1(bp))
2265                 storm_memset_ov(bp, bp->mf_ov, BP_FUNC(bp));
2266
2267         /* function setup flags */
2268         flags = (FUNC_FLG_STATS | FUNC_FLG_LEADING | FUNC_FLG_SPQ);
2269
2270         flags |= (bp->flags & TPA_ENABLE_FLAG) ? FUNC_FLG_TPA : 0;
2271
2272         /**
2273          * Although RSS is meaningless when there is a single HW queue we
2274          * still need it enabled in order to have HW Rx hash generated.
2275          *
2276          * if (is_eth_multi(bp))
2277          *      flags |= FUNC_FLG_RSS;
2278          */
2279
2280         /* function setup */
2281         if (flags & FUNC_FLG_RSS) {
2282                 rss.cap = (RSS_IPV4_CAP | RSS_IPV4_TCP_CAP |
2283                            RSS_IPV6_CAP | RSS_IPV6_TCP_CAP);
2284                 rss.mode = bp->multi_mode;
2285                 rss.result_mask = MULTI_MASK;
2286                 func_init.rss = &rss;
2287         }
2288
2289         func_init.func_flgs = flags;
2290         func_init.pf_id = BP_FUNC(bp);
2291         func_init.func_id = BP_FUNC(bp);
2292         func_init.fw_stat_map = bnx2x_sp_mapping(bp, fw_stats);
2293         func_init.spq_map = bp->spq_mapping;
2294         func_init.spq_prod = bp->spq_prod_idx;
2295
2296         bnx2x_func_init(bp, &func_init);
2297
2298         memset(&(bp->cmng), 0, sizeof(struct cmng_struct_per_port));
2299
2300         /*
2301         Congestion management values depend on the link rate
2302         There is no active link so initial link rate is set to 10 Gbps.
2303         When the link comes up The congestion management values are
2304         re-calculated according to the actual link rate.
2305         */
2306         bp->link_vars.line_speed = SPEED_10000;
2307         bnx2x_cmng_fns_init(bp, true, bnx2x_get_cmng_fns_mode(bp));
2308
2309         /* Only the PMF sets the HW */
2310         if (bp->port.pmf)
2311                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2312
2313         /* no rx until link is up */
2314         bp->rx_mode = BNX2X_RX_MODE_NONE;
2315         bnx2x_set_storm_rx_mode(bp);
2316
2317         /* init Event Queue */
2318         eq_data.base_addr.hi = U64_HI(bp->eq_mapping);
2319         eq_data.base_addr.lo = U64_LO(bp->eq_mapping);
2320         eq_data.producer = bp->eq_prod;
2321         eq_data.index_id = HC_SP_INDEX_EQ_CONS;
2322         eq_data.sb_id = DEF_SB_ID;
2323         storm_memset_eq_data(bp, &eq_data, BP_FUNC(bp));
2324 }
2325
2326
2327 static void bnx2x_e1h_disable(struct bnx2x *bp)
2328 {
2329         int port = BP_PORT(bp);
2330
2331         netif_tx_disable(bp->dev);
2332
2333         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
2334
2335         netif_carrier_off(bp->dev);
2336 }
2337
2338 static void bnx2x_e1h_enable(struct bnx2x *bp)
2339 {
2340         int port = BP_PORT(bp);
2341
2342         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
2343
2344         /* Tx queue should be only reenabled */
2345         netif_tx_wake_all_queues(bp->dev);
2346
2347         /*
2348          * Should not call netif_carrier_on since it will be called if the link
2349          * is up when checking for link state
2350          */
2351 }
2352
2353 static void bnx2x_dcc_event(struct bnx2x *bp, u32 dcc_event)
2354 {
2355         DP(BNX2X_MSG_MCP, "dcc_event 0x%x\n", dcc_event);
2356
2357         if (dcc_event & DRV_STATUS_DCC_DISABLE_ENABLE_PF) {
2358
2359                 /*
2360                  * This is the only place besides the function initialization
2361                  * where the bp->flags can change so it is done without any
2362                  * locks
2363                  */
2364                 if (bp->mf_config & FUNC_MF_CFG_FUNC_DISABLED) {
2365                         DP(NETIF_MSG_IFDOWN, "mf_cfg function disabled\n");
2366                         bp->flags |= MF_FUNC_DIS;
2367
2368                         bnx2x_e1h_disable(bp);
2369                 } else {
2370                         DP(NETIF_MSG_IFUP, "mf_cfg function enabled\n");
2371                         bp->flags &= ~MF_FUNC_DIS;
2372
2373                         bnx2x_e1h_enable(bp);
2374                 }
2375                 dcc_event &= ~DRV_STATUS_DCC_DISABLE_ENABLE_PF;
2376         }
2377         if (dcc_event & DRV_STATUS_DCC_BANDWIDTH_ALLOCATION) {
2378
2379                 bnx2x_cmng_fns_init(bp, true, CMNG_FNS_MINMAX);
2380                 bnx2x_link_sync_notify(bp);
2381                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2382                 dcc_event &= ~DRV_STATUS_DCC_BANDWIDTH_ALLOCATION;
2383         }
2384
2385         /* Report results to MCP */
2386         if (dcc_event)
2387                 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_FAILURE, 0);
2388         else
2389                 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_OK, 0);
2390 }
2391
2392 /* must be called under the spq lock */
2393 static inline struct eth_spe *bnx2x_sp_get_next(struct bnx2x *bp)
2394 {
2395         struct eth_spe *next_spe = bp->spq_prod_bd;
2396
2397         if (bp->spq_prod_bd == bp->spq_last_bd) {
2398                 bp->spq_prod_bd = bp->spq;
2399                 bp->spq_prod_idx = 0;
2400                 DP(NETIF_MSG_TIMER, "end of spq\n");
2401         } else {
2402                 bp->spq_prod_bd++;
2403                 bp->spq_prod_idx++;
2404         }
2405         return next_spe;
2406 }
2407
2408 /* must be called under the spq lock */
2409 static inline void bnx2x_sp_prod_update(struct bnx2x *bp)
2410 {
2411         int func = BP_FUNC(bp);
2412
2413         /* Make sure that BD data is updated before writing the producer */
2414         wmb();
2415
2416         REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func),
2417                bp->spq_prod_idx);
2418         mmiowb();
2419 }
2420
2421 /* the slow path queue is odd since completions arrive on the fastpath ring */
2422 int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
2423                          u32 data_hi, u32 data_lo, int common)
2424 {
2425         struct eth_spe *spe;
2426         u16 type;
2427
2428 #ifdef BNX2X_STOP_ON_ERROR
2429         if (unlikely(bp->panic))
2430                 return -EIO;
2431 #endif
2432
2433         spin_lock_bh(&bp->spq_lock);
2434
2435         if (!atomic_read(&bp->spq_left)) {
2436                 BNX2X_ERR("BUG! SPQ ring full!\n");
2437                 spin_unlock_bh(&bp->spq_lock);
2438                 bnx2x_panic();
2439                 return -EBUSY;
2440         }
2441
2442         spe = bnx2x_sp_get_next(bp);
2443
2444         /* CID needs port number to be encoded int it */
2445         spe->hdr.conn_and_cmd_data =
2446                         cpu_to_le32((command << SPE_HDR_CMD_ID_SHIFT) |
2447                                     HW_CID(bp, cid));
2448
2449         if (common)
2450                 /* Common ramrods:
2451                  *      FUNC_START, FUNC_STOP, CFC_DEL, STATS, SET_MAC
2452                  *      TRAFFIC_STOP, TRAFFIC_START
2453                  */
2454                 type = (NONE_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2455                         & SPE_HDR_CONN_TYPE;
2456         else
2457                 /* ETH ramrods: SETUP, HALT */
2458                 type = (ETH_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2459                         & SPE_HDR_CONN_TYPE;
2460
2461         type |= ((BP_FUNC(bp) << SPE_HDR_FUNCTION_ID_SHIFT) &
2462                  SPE_HDR_FUNCTION_ID);
2463
2464         spe->hdr.type = cpu_to_le16(type);
2465
2466         spe->data.update_data_addr.hi = cpu_to_le32(data_hi);
2467         spe->data.update_data_addr.lo = cpu_to_le32(data_lo);
2468
2469         /* stats ramrod has it's own slot on the spq */
2470         if (command != RAMROD_CMD_ID_COMMON_STAT_QUERY)
2471                 /* It's ok if the actual decrement is issued towards the memory
2472                  * somewhere between the spin_lock and spin_unlock. Thus no
2473                  * more explict memory barrier is needed.
2474                  */
2475                 atomic_dec(&bp->spq_left);
2476
2477         DP(BNX2X_MSG_SP/*NETIF_MSG_TIMER*/,
2478            "SPQE[%x] (%x:%x)  command %d  hw_cid %x  data (%x:%x) "
2479            "type(0x%x) left %x\n",
2480            bp->spq_prod_idx, (u32)U64_HI(bp->spq_mapping),
2481            (u32)(U64_LO(bp->spq_mapping) +
2482            (void *)bp->spq_prod_bd - (void *)bp->spq), command,
2483            HW_CID(bp, cid), data_hi, data_lo, type, atomic_read(&bp->spq_left));
2484
2485         bnx2x_sp_prod_update(bp);
2486         spin_unlock_bh(&bp->spq_lock);
2487         return 0;
2488 }
2489
2490 /* acquire split MCP access lock register */
2491 static int bnx2x_acquire_alr(struct bnx2x *bp)
2492 {
2493         u32 j, val;
2494         int rc = 0;
2495
2496         might_sleep();
2497         for (j = 0; j < 1000; j++) {
2498                 val = (1UL << 31);
2499                 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
2500                 val = REG_RD(bp, GRCBASE_MCP + 0x9c);
2501                 if (val & (1L << 31))
2502                         break;
2503
2504                 msleep(5);
2505         }
2506         if (!(val & (1L << 31))) {
2507                 BNX2X_ERR("Cannot acquire MCP access lock register\n");
2508                 rc = -EBUSY;
2509         }
2510
2511         return rc;
2512 }
2513
2514 /* release split MCP access lock register */
2515 static void bnx2x_release_alr(struct bnx2x *bp)
2516 {
2517         REG_WR(bp, GRCBASE_MCP + 0x9c, 0);
2518 }
2519
2520 #define BNX2X_DEF_SB_ATT_IDX    0x0001
2521 #define BNX2X_DEF_SB_IDX        0x0002
2522
2523 static inline u16 bnx2x_update_dsb_idx(struct bnx2x *bp)
2524 {
2525         struct host_sp_status_block *def_sb = bp->def_status_blk;
2526         u16 rc = 0;
2527
2528         barrier(); /* status block is written to by the chip */
2529         if (bp->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
2530                 bp->def_att_idx = def_sb->atten_status_block.attn_bits_index;
2531                 rc |= BNX2X_DEF_SB_ATT_IDX;
2532         }
2533
2534         if (bp->def_idx != def_sb->sp_sb.running_index) {
2535                 bp->def_idx = def_sb->sp_sb.running_index;
2536                 rc |= BNX2X_DEF_SB_IDX;
2537         }
2538
2539         /* Do not reorder: indecies reading should complete before handling */
2540         barrier();
2541         return rc;
2542 }
2543
2544 /*
2545  * slow path service functions
2546  */
2547
2548 static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
2549 {
2550         int port = BP_PORT(bp);
2551         u32 hc_addr = (HC_REG_COMMAND_REG + port*32 +
2552                        COMMAND_REG_ATTN_BITS_SET);
2553         u32 aeu_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
2554                               MISC_REG_AEU_MASK_ATTN_FUNC_0;
2555         u32 nig_int_mask_addr = port ? NIG_REG_MASK_INTERRUPT_PORT1 :
2556                                        NIG_REG_MASK_INTERRUPT_PORT0;
2557         u32 aeu_mask;
2558         u32 nig_mask = 0;
2559
2560         if (bp->attn_state & asserted)
2561                 BNX2X_ERR("IGU ERROR\n");
2562
2563         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2564         aeu_mask = REG_RD(bp, aeu_addr);
2565
2566         DP(NETIF_MSG_HW, "aeu_mask %x  newly asserted %x\n",
2567            aeu_mask, asserted);
2568         aeu_mask &= ~(asserted & 0x3ff);
2569         DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
2570
2571         REG_WR(bp, aeu_addr, aeu_mask);
2572         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2573
2574         DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
2575         bp->attn_state |= asserted;
2576         DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
2577
2578         if (asserted & ATTN_HARD_WIRED_MASK) {
2579                 if (asserted & ATTN_NIG_FOR_FUNC) {
2580
2581                         bnx2x_acquire_phy_lock(bp);
2582
2583                         /* save nig interrupt mask */
2584                         nig_mask = REG_RD(bp, nig_int_mask_addr);
2585                         REG_WR(bp, nig_int_mask_addr, 0);
2586
2587                         bnx2x_link_attn(bp);
2588
2589                         /* handle unicore attn? */
2590                 }
2591                 if (asserted & ATTN_SW_TIMER_4_FUNC)
2592                         DP(NETIF_MSG_HW, "ATTN_SW_TIMER_4_FUNC!\n");
2593
2594                 if (asserted & GPIO_2_FUNC)
2595                         DP(NETIF_MSG_HW, "GPIO_2_FUNC!\n");
2596
2597                 if (asserted & GPIO_3_FUNC)
2598                         DP(NETIF_MSG_HW, "GPIO_3_FUNC!\n");
2599
2600                 if (asserted & GPIO_4_FUNC)
2601                         DP(NETIF_MSG_HW, "GPIO_4_FUNC!\n");
2602
2603                 if (port == 0) {
2604                         if (asserted & ATTN_GENERAL_ATTN_1) {
2605                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_1!\n");
2606                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
2607                         }
2608                         if (asserted & ATTN_GENERAL_ATTN_2) {
2609                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_2!\n");
2610                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
2611                         }
2612                         if (asserted & ATTN_GENERAL_ATTN_3) {
2613                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_3!\n");
2614                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
2615                         }
2616                 } else {
2617                         if (asserted & ATTN_GENERAL_ATTN_4) {
2618                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_4!\n");
2619                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
2620                         }
2621                         if (asserted & ATTN_GENERAL_ATTN_5) {
2622                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_5!\n");
2623                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
2624                         }
2625                         if (asserted & ATTN_GENERAL_ATTN_6) {
2626                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_6!\n");
2627                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
2628                         }
2629                 }
2630
2631         } /* if hardwired */
2632
2633         DP(NETIF_MSG_HW, "about to mask 0x%08x at HC addr 0x%x\n",
2634            asserted, hc_addr);
2635         REG_WR(bp, hc_addr, asserted);
2636
2637         /* now set back the mask */
2638         if (asserted & ATTN_NIG_FOR_FUNC) {
2639                 REG_WR(bp, nig_int_mask_addr, nig_mask);
2640                 bnx2x_release_phy_lock(bp);
2641         }
2642 }
2643
2644 static inline void bnx2x_fan_failure(struct bnx2x *bp)
2645 {
2646         int port = BP_PORT(bp);
2647         u32 ext_phy_config;
2648         /* mark the failure */
2649         ext_phy_config =
2650                 SHMEM_RD(bp,
2651                          dev_info.port_hw_config[port].external_phy_config);
2652
2653         ext_phy_config &= ~PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK;
2654         ext_phy_config |= PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE;
2655         SHMEM_WR(bp, dev_info.port_hw_config[port].external_phy_config,
2656                  ext_phy_config);
2657
2658         /* log the failure */
2659         netdev_err(bp->dev, "Fan Failure on Network Controller has caused"
2660                " the driver to shutdown the card to prevent permanent"
2661                " damage.  Please contact OEM Support for assistance\n");
2662 }
2663
2664 static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
2665 {
2666         int port = BP_PORT(bp);
2667         int reg_offset;
2668         u32 val;
2669
2670         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
2671                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
2672
2673         if (attn & AEU_INPUTS_ATTN_BITS_SPIO5) {
2674
2675                 val = REG_RD(bp, reg_offset);
2676                 val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
2677                 REG_WR(bp, reg_offset, val);
2678
2679                 BNX2X_ERR("SPIO5 hw attention\n");
2680
2681                 /* Fan failure attention */
2682                 bnx2x_hw_reset_phy(&bp->link_params);
2683                 bnx2x_fan_failure(bp);
2684         }
2685
2686         if (attn & (AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0 |
2687                     AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1)) {
2688                 bnx2x_acquire_phy_lock(bp);
2689                 bnx2x_handle_module_detect_int(&bp->link_params);
2690                 bnx2x_release_phy_lock(bp);
2691         }
2692
2693         if (attn & HW_INTERRUT_ASSERT_SET_0) {
2694
2695                 val = REG_RD(bp, reg_offset);
2696                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_0);
2697                 REG_WR(bp, reg_offset, val);
2698
2699                 BNX2X_ERR("FATAL HW block attention set0 0x%x\n",
2700                           (u32)(attn & HW_INTERRUT_ASSERT_SET_0));
2701                 bnx2x_panic();
2702         }
2703 }
2704
2705 static inline void bnx2x_attn_int_deasserted1(struct bnx2x *bp, u32 attn)
2706 {
2707         u32 val;
2708
2709         if (attn & AEU_INPUTS_ATTN_BITS_DOORBELLQ_HW_INTERRUPT) {
2710
2711                 val = REG_RD(bp, DORQ_REG_DORQ_INT_STS_CLR);
2712                 BNX2X_ERR("DB hw attention 0x%x\n", val);
2713                 /* DORQ discard attention */
2714                 if (val & 0x2)
2715                         BNX2X_ERR("FATAL error from DORQ\n");
2716         }
2717
2718         if (attn & HW_INTERRUT_ASSERT_SET_1) {
2719
2720                 int port = BP_PORT(bp);
2721                 int reg_offset;
2722
2723                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_1 :
2724                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_1);
2725
2726                 val = REG_RD(bp, reg_offset);
2727                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
2728                 REG_WR(bp, reg_offset, val);
2729
2730                 BNX2X_ERR("FATAL HW block attention set1 0x%x\n",
2731                           (u32)(attn & HW_INTERRUT_ASSERT_SET_1));
2732                 bnx2x_panic();
2733         }
2734 }
2735
2736 static inline void bnx2x_attn_int_deasserted2(struct bnx2x *bp, u32 attn)
2737 {
2738         u32 val;
2739
2740         if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
2741
2742                 val = REG_RD(bp, CFC_REG_CFC_INT_STS_CLR);
2743                 BNX2X_ERR("CFC hw attention 0x%x\n", val);
2744                 /* CFC error attention */
2745                 if (val & 0x2)
2746                         BNX2X_ERR("FATAL error from CFC\n");
2747         }
2748
2749         if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
2750
2751                 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_0);
2752                 BNX2X_ERR("PXP hw attention 0x%x\n", val);
2753                 /* RQ_USDMDP_FIFO_OVERFLOW */
2754                 if (val & 0x18000)
2755                         BNX2X_ERR("FATAL error from PXP\n");
2756         }
2757
2758         if (attn & HW_INTERRUT_ASSERT_SET_2) {
2759
2760                 int port = BP_PORT(bp);
2761                 int reg_offset;
2762
2763                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_2 :
2764                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_2);
2765
2766                 val = REG_RD(bp, reg_offset);
2767                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
2768                 REG_WR(bp, reg_offset, val);
2769
2770                 BNX2X_ERR("FATAL HW block attention set2 0x%x\n",
2771                           (u32)(attn & HW_INTERRUT_ASSERT_SET_2));
2772                 bnx2x_panic();
2773         }
2774 }
2775
2776 static inline void bnx2x_attn_int_deasserted3(struct bnx2x *bp, u32 attn)
2777 {
2778         u32 val;
2779
2780         if (attn & EVEREST_GEN_ATTN_IN_USE_MASK) {
2781
2782                 if (attn & BNX2X_PMF_LINK_ASSERT) {
2783                         int func = BP_FUNC(bp);
2784
2785                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
2786                         bp->mf_config =
2787                                 MF_CFG_RD(bp, func_mf_config[func].config);
2788                         val = SHMEM_RD(bp, func_mb[func].drv_status);
2789                         if (val & DRV_STATUS_DCC_EVENT_MASK)
2790                                 bnx2x_dcc_event(bp,
2791                                             (val & DRV_STATUS_DCC_EVENT_MASK));
2792                         bnx2x__link_status_update(bp);
2793                         if ((bp->port.pmf == 0) && (val & DRV_STATUS_PMF))
2794                                 bnx2x_pmf_update(bp);
2795
2796                 } else if (attn & BNX2X_MC_ASSERT_BITS) {
2797
2798                         BNX2X_ERR("MC assert!\n");
2799                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_10, 0);
2800                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_9, 0);
2801                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_8, 0);
2802                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_7, 0);
2803                         bnx2x_panic();
2804
2805                 } else if (attn & BNX2X_MCP_ASSERT) {
2806
2807                         BNX2X_ERR("MCP assert!\n");
2808                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_11, 0);
2809                         bnx2x_fw_dump(bp);
2810
2811                 } else
2812                         BNX2X_ERR("Unknown HW assert! (attn 0x%x)\n", attn);
2813         }
2814
2815         if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
2816                 BNX2X_ERR("LATCHED attention 0x%08x (masked)\n", attn);
2817                 if (attn & BNX2X_GRC_TIMEOUT) {
2818                         val = CHIP_IS_E1H(bp) ?
2819                                 REG_RD(bp, MISC_REG_GRC_TIMEOUT_ATTN) : 0;
2820                         BNX2X_ERR("GRC time-out 0x%08x\n", val);
2821                 }
2822                 if (attn & BNX2X_GRC_RSV) {
2823                         val = CHIP_IS_E1H(bp) ?
2824                                 REG_RD(bp, MISC_REG_GRC_RSV_ATTN) : 0;
2825                         BNX2X_ERR("GRC reserved 0x%08x\n", val);
2826                 }
2827                 REG_WR(bp, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
2828         }
2829 }
2830
2831 #define BNX2X_MISC_GEN_REG      MISC_REG_GENERIC_POR_1
2832 #define LOAD_COUNTER_BITS       16 /* Number of bits for load counter */
2833 #define LOAD_COUNTER_MASK       (((u32)0x1 << LOAD_COUNTER_BITS) - 1)
2834 #define RESET_DONE_FLAG_MASK    (~LOAD_COUNTER_MASK)
2835 #define RESET_DONE_FLAG_SHIFT   LOAD_COUNTER_BITS
2836 #define CHIP_PARITY_SUPPORTED(bp)   (CHIP_IS_E1(bp) || CHIP_IS_E1H(bp))
2837 /*
2838  * should be run under rtnl lock
2839  */
2840 static inline void bnx2x_set_reset_done(struct bnx2x *bp)
2841 {
2842         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
2843         val &= ~(1 << RESET_DONE_FLAG_SHIFT);
2844         REG_WR(bp, BNX2X_MISC_GEN_REG, val);
2845         barrier();
2846         mmiowb();
2847 }
2848
2849 /*
2850  * should be run under rtnl lock
2851  */
2852 static inline void bnx2x_set_reset_in_progress(struct bnx2x *bp)
2853 {
2854         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
2855         val |= (1 << 16);
2856         REG_WR(bp, BNX2X_MISC_GEN_REG, val);
2857         barrier();
2858         mmiowb();
2859 }
2860
2861 /*
2862  * should be run under rtnl lock
2863  */
2864 bool bnx2x_reset_is_done(struct bnx2x *bp)
2865 {
2866         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
2867         DP(NETIF_MSG_HW, "GEN_REG_VAL=0x%08x\n", val);
2868         return (val & RESET_DONE_FLAG_MASK) ? false : true;
2869 }
2870
2871 /*
2872  * should be run under rtnl lock
2873  */
2874 inline void bnx2x_inc_load_cnt(struct bnx2x *bp)
2875 {
2876         u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
2877
2878         DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
2879
2880         val1 = ((val & LOAD_COUNTER_MASK) + 1) & LOAD_COUNTER_MASK;
2881         REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
2882         barrier();
2883         mmiowb();
2884 }
2885
2886 /*
2887  * should be run under rtnl lock
2888  */
2889 u32 bnx2x_dec_load_cnt(struct bnx2x *bp)
2890 {
2891         u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
2892
2893         DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
2894
2895         val1 = ((val & LOAD_COUNTER_MASK) - 1) & LOAD_COUNTER_MASK;
2896         REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
2897         barrier();
2898         mmiowb();
2899
2900         return val1;
2901 }
2902
2903 /*
2904  * should be run under rtnl lock
2905  */
2906 static inline u32 bnx2x_get_load_cnt(struct bnx2x *bp)
2907 {
2908         return REG_RD(bp, BNX2X_MISC_GEN_REG) & LOAD_COUNTER_MASK;
2909 }
2910
2911 static inline void bnx2x_clear_load_cnt(struct bnx2x *bp)
2912 {
2913         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
2914         REG_WR(bp, BNX2X_MISC_GEN_REG, val & (~LOAD_COUNTER_MASK));
2915 }
2916
2917 static inline void _print_next_block(int idx, const char *blk)
2918 {
2919         if (idx)
2920                 pr_cont(", ");
2921         pr_cont("%s", blk);
2922 }
2923
2924 static inline int bnx2x_print_blocks_with_parity0(u32 sig, int par_num)
2925 {
2926         int i = 0;
2927         u32 cur_bit = 0;
2928         for (i = 0; sig; i++) {
2929                 cur_bit = ((u32)0x1 << i);
2930                 if (sig & cur_bit) {
2931                         switch (cur_bit) {
2932                         case AEU_INPUTS_ATTN_BITS_BRB_PARITY_ERROR:
2933                                 _print_next_block(par_num++, "BRB");
2934                                 break;
2935                         case AEU_INPUTS_ATTN_BITS_PARSER_PARITY_ERROR:
2936                                 _print_next_block(par_num++, "PARSER");
2937                                 break;
2938                         case AEU_INPUTS_ATTN_BITS_TSDM_PARITY_ERROR:
2939                                 _print_next_block(par_num++, "TSDM");
2940                                 break;
2941                         case AEU_INPUTS_ATTN_BITS_SEARCHER_PARITY_ERROR:
2942                                 _print_next_block(par_num++, "SEARCHER");
2943                                 break;
2944                         case AEU_INPUTS_ATTN_BITS_TSEMI_PARITY_ERROR:
2945                                 _print_next_block(par_num++, "TSEMI");
2946                                 break;
2947                         }
2948
2949                         /* Clear the bit */
2950                         sig &= ~cur_bit;
2951                 }
2952         }
2953
2954         return par_num;
2955 }
2956
2957 static inline int bnx2x_print_blocks_with_parity1(u32 sig, int par_num)
2958 {
2959         int i = 0;
2960         u32 cur_bit = 0;
2961         for (i = 0; sig; i++) {
2962                 cur_bit = ((u32)0x1 << i);
2963                 if (sig & cur_bit) {
2964                         switch (cur_bit) {
2965                         case AEU_INPUTS_ATTN_BITS_PBCLIENT_PARITY_ERROR:
2966                                 _print_next_block(par_num++, "PBCLIENT");
2967                                 break;
2968                         case AEU_INPUTS_ATTN_BITS_QM_PARITY_ERROR:
2969                                 _print_next_block(par_num++, "QM");
2970                                 break;
2971                         case AEU_INPUTS_ATTN_BITS_XSDM_PARITY_ERROR:
2972                                 _print_next_block(par_num++, "XSDM");
2973                                 break;
2974                         case AEU_INPUTS_ATTN_BITS_XSEMI_PARITY_ERROR:
2975                                 _print_next_block(par_num++, "XSEMI");
2976                                 break;
2977                         case AEU_INPUTS_ATTN_BITS_DOORBELLQ_PARITY_ERROR:
2978                                 _print_next_block(par_num++, "DOORBELLQ");
2979                                 break;
2980                         case AEU_INPUTS_ATTN_BITS_VAUX_PCI_CORE_PARITY_ERROR:
2981                                 _print_next_block(par_num++, "VAUX PCI CORE");
2982                                 break;
2983                         case AEU_INPUTS_ATTN_BITS_DEBUG_PARITY_ERROR:
2984                                 _print_next_block(par_num++, "DEBUG");
2985                                 break;
2986                         case AEU_INPUTS_ATTN_BITS_USDM_PARITY_ERROR:
2987                                 _print_next_block(par_num++, "USDM");
2988                                 break;
2989                         case AEU_INPUTS_ATTN_BITS_USEMI_PARITY_ERROR:
2990                                 _print_next_block(par_num++, "USEMI");
2991                                 break;
2992                         case AEU_INPUTS_ATTN_BITS_UPB_PARITY_ERROR:
2993                                 _print_next_block(par_num++, "UPB");
2994                                 break;
2995                         case AEU_INPUTS_ATTN_BITS_CSDM_PARITY_ERROR:
2996                                 _print_next_block(par_num++, "CSDM");
2997                                 break;
2998                         }
2999
3000                         /* Clear the bit */
3001                         sig &= ~cur_bit;
3002                 }
3003         }
3004
3005         return par_num;
3006 }
3007
3008 static inline int bnx2x_print_blocks_with_parity2(u32 sig, int par_num)
3009 {
3010         int i = 0;
3011         u32 cur_bit = 0;
3012         for (i = 0; sig; i++) {
3013                 cur_bit = ((u32)0x1 << i);
3014                 if (sig & cur_bit) {
3015                         switch (cur_bit) {
3016                         case AEU_INPUTS_ATTN_BITS_CSEMI_PARITY_ERROR:
3017                                 _print_next_block(par_num++, "CSEMI");
3018                                 break;
3019                         case AEU_INPUTS_ATTN_BITS_PXP_PARITY_ERROR:
3020                                 _print_next_block(par_num++, "PXP");
3021                                 break;
3022                         case AEU_IN_ATTN_BITS_PXPPCICLOCKCLIENT_PARITY_ERROR:
3023                                 _print_next_block(par_num++,
3024                                         "PXPPCICLOCKCLIENT");
3025                                 break;
3026                         case AEU_INPUTS_ATTN_BITS_CFC_PARITY_ERROR:
3027                                 _print_next_block(par_num++, "CFC");
3028                                 break;
3029                         case AEU_INPUTS_ATTN_BITS_CDU_PARITY_ERROR:
3030                                 _print_next_block(par_num++, "CDU");
3031                                 break;
3032                         case AEU_INPUTS_ATTN_BITS_IGU_PARITY_ERROR:
3033                                 _print_next_block(par_num++, "IGU");
3034                                 break;
3035                         case AEU_INPUTS_ATTN_BITS_MISC_PARITY_ERROR:
3036                                 _print_next_block(par_num++, "MISC");
3037                                 break;
3038                         }
3039
3040                         /* Clear the bit */
3041                         sig &= ~cur_bit;
3042                 }
3043         }
3044
3045         return par_num;
3046 }
3047
3048 static inline int bnx2x_print_blocks_with_parity3(u32 sig, int par_num)
3049 {
3050         int i = 0;
3051         u32 cur_bit = 0;
3052         for (i = 0; sig; i++) {
3053                 cur_bit = ((u32)0x1 << i);
3054                 if (sig & cur_bit) {
3055                         switch (cur_bit) {
3056                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_ROM_PARITY:
3057                                 _print_next_block(par_num++, "MCP ROM");
3058                                 break;
3059                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_RX_PARITY:
3060                                 _print_next_block(par_num++, "MCP UMP RX");
3061                                 break;
3062                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_TX_PARITY:
3063                                 _print_next_block(par_num++, "MCP UMP TX");
3064                                 break;
3065                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_SCPAD_PARITY:
3066                                 _print_next_block(par_num++, "MCP SCPAD");
3067                                 break;
3068                         }
3069
3070                         /* Clear the bit */
3071                         sig &= ~cur_bit;
3072                 }
3073         }
3074
3075         return par_num;
3076 }
3077
3078 static inline bool bnx2x_parity_attn(struct bnx2x *bp, u32 sig0, u32 sig1,
3079                                      u32 sig2, u32 sig3)
3080 {
3081         if ((sig0 & HW_PRTY_ASSERT_SET_0) || (sig1 & HW_PRTY_ASSERT_SET_1) ||
3082             (sig2 & HW_PRTY_ASSERT_SET_2) || (sig3 & HW_PRTY_ASSERT_SET_3)) {
3083                 int par_num = 0;
3084                 DP(NETIF_MSG_HW, "Was parity error: HW block parity attention: "
3085                         "[0]:0x%08x [1]:0x%08x "
3086                         "[2]:0x%08x [3]:0x%08x\n",
3087                           sig0 & HW_PRTY_ASSERT_SET_0,
3088                           sig1 & HW_PRTY_ASSERT_SET_1,
3089                           sig2 & HW_PRTY_ASSERT_SET_2,
3090                           sig3 & HW_PRTY_ASSERT_SET_3);
3091                 printk(KERN_ERR"%s: Parity errors detected in blocks: ",
3092                        bp->dev->name);
3093                 par_num = bnx2x_print_blocks_with_parity0(
3094                         sig0 & HW_PRTY_ASSERT_SET_0, par_num);
3095                 par_num = bnx2x_print_blocks_with_parity1(
3096                         sig1 & HW_PRTY_ASSERT_SET_1, par_num);
3097                 par_num = bnx2x_print_blocks_with_parity2(
3098                         sig2 & HW_PRTY_ASSERT_SET_2, par_num);
3099                 par_num = bnx2x_print_blocks_with_parity3(
3100                         sig3 & HW_PRTY_ASSERT_SET_3, par_num);
3101                 printk("\n");
3102                 return true;
3103         } else
3104                 return false;
3105 }
3106
3107 bool bnx2x_chk_parity_attn(struct bnx2x *bp)
3108 {
3109         struct attn_route attn;
3110         int port = BP_PORT(bp);
3111
3112         attn.sig[0] = REG_RD(bp,
3113                 MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 +
3114                              port*4);
3115         attn.sig[1] = REG_RD(bp,
3116                 MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 +
3117                              port*4);
3118         attn.sig[2] = REG_RD(bp,
3119                 MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 +
3120                              port*4);
3121         attn.sig[3] = REG_RD(bp,
3122                 MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 +
3123                              port*4);
3124
3125         return bnx2x_parity_attn(bp, attn.sig[0], attn.sig[1], attn.sig[2],
3126                                         attn.sig[3]);
3127 }
3128
3129 static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
3130 {
3131         struct attn_route attn, *group_mask;
3132         int port = BP_PORT(bp);
3133         int index;
3134         u32 reg_addr;
3135         u32 val;
3136         u32 aeu_mask;
3137
3138         /* need to take HW lock because MCP or other port might also
3139            try to handle this event */
3140         bnx2x_acquire_alr(bp);
3141
3142         if (bnx2x_chk_parity_attn(bp)) {
3143                 bp->recovery_state = BNX2X_RECOVERY_INIT;
3144                 bnx2x_set_reset_in_progress(bp);
3145                 schedule_delayed_work(&bp->reset_task, 0);
3146                 /* Disable HW interrupts */
3147                 bnx2x_int_disable(bp);
3148                 bnx2x_release_alr(bp);
3149                 /* In case of parity errors don't handle attentions so that
3150                  * other function would "see" parity errors.
3151                  */
3152                 return;
3153         }
3154
3155         attn.sig[0] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + port*4);
3156         attn.sig[1] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
3157         attn.sig[2] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
3158         attn.sig[3] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
3159         DP(NETIF_MSG_HW, "attn: %08x %08x %08x %08x\n",
3160            attn.sig[0], attn.sig[1], attn.sig[2], attn.sig[3]);
3161
3162         for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
3163                 if (deasserted & (1 << index)) {
3164                         group_mask = &bp->attn_group[index];
3165
3166                         DP(NETIF_MSG_HW, "group[%d]: %08x %08x %08x %08x\n",
3167                            index, group_mask->sig[0], group_mask->sig[1],
3168                            group_mask->sig[2], group_mask->sig[3]);
3169
3170                         bnx2x_attn_int_deasserted3(bp,
3171                                         attn.sig[3] & group_mask->sig[3]);
3172                         bnx2x_attn_int_deasserted1(bp,
3173                                         attn.sig[1] & group_mask->sig[1]);
3174                         bnx2x_attn_int_deasserted2(bp,
3175                                         attn.sig[2] & group_mask->sig[2]);
3176                         bnx2x_attn_int_deasserted0(bp,
3177                                         attn.sig[0] & group_mask->sig[0]);
3178                 }
3179         }
3180
3181         bnx2x_release_alr(bp);
3182
3183         reg_addr = (HC_REG_COMMAND_REG + port*32 + COMMAND_REG_ATTN_BITS_CLR);
3184
3185         val = ~deasserted;
3186         DP(NETIF_MSG_HW, "about to mask 0x%08x at HC addr 0x%x\n",
3187            val, reg_addr);
3188         REG_WR(bp, reg_addr, val);
3189
3190         if (~bp->attn_state & deasserted)
3191                 BNX2X_ERR("IGU ERROR\n");
3192
3193         reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
3194                           MISC_REG_AEU_MASK_ATTN_FUNC_0;
3195
3196         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
3197         aeu_mask = REG_RD(bp, reg_addr);
3198
3199         DP(NETIF_MSG_HW, "aeu_mask %x  newly deasserted %x\n",
3200            aeu_mask, deasserted);
3201         aeu_mask |= (deasserted & 0x3ff);
3202         DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
3203
3204         REG_WR(bp, reg_addr, aeu_mask);
3205         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
3206
3207         DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
3208         bp->attn_state &= ~deasserted;
3209         DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
3210 }
3211
3212 static void bnx2x_attn_int(struct bnx2x *bp)
3213 {
3214         /* read local copy of bits */
3215         u32 attn_bits = le32_to_cpu(bp->def_status_blk->atten_status_block.
3216                                                                 attn_bits);
3217         u32 attn_ack = le32_to_cpu(bp->def_status_blk->atten_status_block.
3218                                                                 attn_bits_ack);
3219         u32 attn_state = bp->attn_state;
3220
3221         /* look for changed bits */
3222         u32 asserted   =  attn_bits & ~attn_ack & ~attn_state;
3223         u32 deasserted = ~attn_bits &  attn_ack &  attn_state;
3224
3225         DP(NETIF_MSG_HW,
3226            "attn_bits %x  attn_ack %x  asserted %x  deasserted %x\n",
3227            attn_bits, attn_ack, asserted, deasserted);
3228
3229         if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state))
3230                 BNX2X_ERR("BAD attention state\n");
3231
3232         /* handle bits that were raised */
3233         if (asserted)
3234                 bnx2x_attn_int_asserted(bp, asserted);
3235
3236         if (deasserted)
3237                 bnx2x_attn_int_deasserted(bp, deasserted);
3238 }
3239
3240 static inline void bnx2x_update_eq_prod(struct bnx2x *bp, u16 prod)
3241 {
3242         /* No memory barriers */
3243         storm_memset_eq_prod(bp, prod, BP_FUNC(bp));
3244         mmiowb(); /* keep prod updates ordered */
3245 }
3246
3247 #ifdef BCM_CNIC
3248 static int  bnx2x_cnic_handle_cfc_del(struct bnx2x *bp, u32 cid,
3249                                       union event_ring_elem *elem)
3250 {
3251         if (!bp->cnic_eth_dev.starting_cid  ||
3252             cid < bp->cnic_eth_dev.starting_cid)
3253                 return 1;
3254
3255         DP(BNX2X_MSG_SP, "got delete ramrod for CNIC CID %d\n", cid);
3256
3257         if (unlikely(elem->message.data.cfc_del_event.error)) {
3258                 BNX2X_ERR("got delete ramrod for CNIC CID %d with error!\n",
3259                           cid);
3260                 bnx2x_panic_dump(bp);
3261         }
3262         bnx2x_cnic_cfc_comp(bp, cid);
3263         return 0;
3264 }
3265 #endif
3266
3267 static void bnx2x_eq_int(struct bnx2x *bp)
3268 {
3269         u16 hw_cons, sw_cons, sw_prod;
3270         union event_ring_elem *elem;
3271         u32 cid;
3272         u8 opcode;
3273         int spqe_cnt = 0;
3274
3275         hw_cons = le16_to_cpu(*bp->eq_cons_sb);
3276
3277         /* The hw_cos range is 1-255, 257 - the sw_cons range is 0-254, 256.
3278          * when we get the the next-page we nned to adjust so the loop
3279          * condition below will be met. The next element is the size of a
3280          * regular element and hence incrementing by 1
3281          */
3282         if ((hw_cons & EQ_DESC_MAX_PAGE) == EQ_DESC_MAX_PAGE)
3283                 hw_cons++;
3284
3285         /* This function may never run in parralel with itself for a
3286          * specific bp, thus there is no need in "paired" read memory
3287          * barrier here.
3288          */
3289         sw_cons = bp->eq_cons;
3290         sw_prod = bp->eq_prod;
3291
3292         DP(BNX2X_MSG_SP, "EQ:  hw_cons %u  sw_cons %u bp->spq_left %u\n",
3293                         hw_cons, sw_cons, atomic_read(&bp->spq_left));
3294
3295         for (; sw_cons != hw_cons;
3296               sw_prod = NEXT_EQ_IDX(sw_prod), sw_cons = NEXT_EQ_IDX(sw_cons)) {
3297
3298
3299                 elem = &bp->eq_ring[EQ_DESC(sw_cons)];
3300
3301                 cid = SW_CID(elem->message.data.cfc_del_event.cid);
3302                 opcode = elem->message.opcode;
3303
3304
3305                 /* handle eq element */
3306                 switch (opcode) {
3307                 case EVENT_RING_OPCODE_STAT_QUERY:
3308                         DP(NETIF_MSG_TIMER, "got statistics comp event\n");
3309                         /* nothing to do with stats comp */
3310                         continue;
3311
3312                 case EVENT_RING_OPCODE_CFC_DEL:
3313                         /* handle according to cid range */
3314                         /*
3315                          * we may want to verify here that the bp state is
3316                          * HALTING
3317                          */
3318                         DP(NETIF_MSG_IFDOWN,
3319                            "got delete ramrod for MULTI[%d]\n", cid);
3320 #ifdef BCM_CNIC
3321                         if (!bnx2x_cnic_handle_cfc_del(bp, cid, elem))
3322                                 goto next_spqe;
3323 #endif
3324                         bnx2x_fp(bp, cid, state) =
3325                                                 BNX2X_FP_STATE_CLOSED;
3326
3327                         goto next_spqe;
3328                 }
3329
3330                 switch (opcode | bp->state) {
3331                 case (EVENT_RING_OPCODE_FUNCTION_START |
3332                       BNX2X_STATE_OPENING_WAIT4_PORT):
3333                         DP(NETIF_MSG_IFUP, "got setup ramrod\n");
3334                         bp->state = BNX2X_STATE_FUNC_STARTED;
3335                         break;
3336
3337                 case (EVENT_RING_OPCODE_FUNCTION_STOP |
3338                       BNX2X_STATE_CLOSING_WAIT4_HALT):
3339                         DP(NETIF_MSG_IFDOWN, "got halt ramrod\n");
3340                         bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
3341                         break;
3342
3343                 case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_OPEN):
3344                 case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_DIAG):
3345                         DP(NETIF_MSG_IFUP, "got set mac ramrod\n");
3346                         bp->set_mac_pending = 0;
3347                         break;
3348
3349                 case (EVENT_RING_OPCODE_SET_MAC |
3350                       BNX2X_STATE_CLOSING_WAIT4_HALT):
3351                         DP(NETIF_MSG_IFDOWN, "got (un)set mac ramrod\n");
3352                         bp->set_mac_pending = 0;
3353                         break;
3354                 default:
3355                         /* unknown event log error and continue */
3356                         BNX2X_ERR("Unknown EQ event %d\n",
3357                                   elem->message.opcode);
3358                 }
3359 next_spqe:
3360                 spqe_cnt++;
3361         } /* for */
3362
3363         smp_mb__before_atomic_inc();
3364         atomic_add(spqe_cnt, &bp->spq_left);
3365
3366         bp->eq_cons = sw_cons;
3367         bp->eq_prod = sw_prod;
3368         /* Make sure that above mem writes were issued towards the memory */
3369         smp_wmb();
3370
3371         /* update producer */
3372         bnx2x_update_eq_prod(bp, bp->eq_prod);
3373 }
3374
3375 static void bnx2x_sp_task(struct work_struct *work)
3376 {
3377         struct bnx2x *bp = container_of(work, struct bnx2x, sp_task.work);
3378         u16 status;
3379
3380         /* Return here if interrupt is disabled */
3381         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3382                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3383                 return;
3384         }
3385
3386         status = bnx2x_update_dsb_idx(bp);
3387 /*      if (status == 0)                                     */
3388 /*              BNX2X_ERR("spurious slowpath interrupt!\n"); */
3389
3390         DP(NETIF_MSG_INTR, "got a slowpath interrupt (status 0x%x)\n", status);
3391
3392         /* HW attentions */
3393         if (status & BNX2X_DEF_SB_ATT_IDX) {
3394                 bnx2x_attn_int(bp);
3395                 status &= ~BNX2X_DEF_SB_ATT_IDX;
3396         }
3397
3398         /* SP events: STAT_QUERY and others */
3399         if (status & BNX2X_DEF_SB_IDX) {
3400
3401                 /* Handle EQ completions */
3402                 bnx2x_eq_int(bp);
3403
3404                 bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID,
3405                         le16_to_cpu(bp->def_idx), IGU_INT_NOP, 1);
3406
3407                 status &= ~BNX2X_DEF_SB_IDX;
3408         }
3409
3410         if (unlikely(status))
3411                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
3412                    status);
3413
3414         bnx2x_ack_sb(bp, bp->igu_dsb_id, ATTENTION_ID,
3415              le16_to_cpu(bp->def_att_idx), IGU_INT_ENABLE, 1);
3416 }
3417
3418 irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
3419 {
3420         struct net_device *dev = dev_instance;
3421         struct bnx2x *bp = netdev_priv(dev);
3422
3423         /* Return here if interrupt is disabled */
3424         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3425                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3426                 return IRQ_HANDLED;
3427         }
3428
3429         bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID, 0,
3430                      IGU_INT_DISABLE, 0);
3431
3432 #ifdef BNX2X_STOP_ON_ERROR
3433         if (unlikely(bp->panic))
3434                 return IRQ_HANDLED;
3435 #endif
3436
3437 #ifdef BCM_CNIC
3438         {
3439                 struct cnic_ops *c_ops;
3440
3441                 rcu_read_lock();
3442                 c_ops = rcu_dereference(bp->cnic_ops);
3443                 if (c_ops)
3444                         c_ops->cnic_handler(bp->cnic_data, NULL);
3445                 rcu_read_unlock();
3446         }
3447 #endif
3448         queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
3449
3450         return IRQ_HANDLED;
3451 }
3452
3453 /* end of slow path */
3454
3455 static void bnx2x_timer(unsigned long data)
3456 {
3457         struct bnx2x *bp = (struct bnx2x *) data;
3458
3459         if (!netif_running(bp->dev))
3460                 return;
3461
3462         if (atomic_read(&bp->intr_sem) != 0)
3463                 goto timer_restart;
3464
3465         if (poll) {
3466                 struct bnx2x_fastpath *fp = &bp->fp[0];
3467                 int rc;
3468
3469                 bnx2x_tx_int(fp);
3470                 rc = bnx2x_rx_int(fp, 1000);
3471         }
3472
3473         if (!BP_NOMCP(bp)) {
3474                 int func = BP_FUNC(bp);
3475                 u32 drv_pulse;
3476                 u32 mcp_pulse;
3477
3478                 ++bp->fw_drv_pulse_wr_seq;
3479                 bp->fw_drv_pulse_wr_seq &= DRV_PULSE_SEQ_MASK;
3480                 /* TBD - add SYSTEM_TIME */
3481                 drv_pulse = bp->fw_drv_pulse_wr_seq;
3482                 SHMEM_WR(bp, func_mb[func].drv_pulse_mb, drv_pulse);
3483
3484                 mcp_pulse = (SHMEM_RD(bp, func_mb[func].mcp_pulse_mb) &
3485                              MCP_PULSE_SEQ_MASK);
3486                 /* The delta between driver pulse and mcp response
3487                  * should be 1 (before mcp response) or 0 (after mcp response)
3488                  */
3489                 if ((drv_pulse != mcp_pulse) &&
3490                     (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
3491                         /* someone lost a heartbeat... */
3492                         BNX2X_ERR("drv_pulse (0x%x) != mcp_pulse (0x%x)\n",
3493                                   drv_pulse, mcp_pulse);
3494                 }
3495         }
3496
3497         if (bp->state == BNX2X_STATE_OPEN)
3498                 bnx2x_stats_handle(bp, STATS_EVENT_UPDATE);
3499
3500 timer_restart:
3501         mod_timer(&bp->timer, jiffies + bp->current_interval);
3502 }
3503
3504 /* end of Statistics */
3505
3506 /* nic init */
3507
3508 /*
3509  * nic init service functions
3510  */
3511
3512 static inline void bnx2x_fill(struct bnx2x *bp, u32 addr, int fill, u32 len)
3513 {
3514         u32 i;
3515         if (!(len%4) && !(addr%4))
3516                 for (i = 0; i < len; i += 4)
3517                         REG_WR(bp, addr + i, fill);
3518         else
3519                 for (i = 0; i < len; i++)
3520                         REG_WR8(bp, addr + i, fill);
3521
3522 }
3523
3524 /* helper: writes FP SP data to FW - data_size in dwords */
3525 static inline void bnx2x_wr_fp_sb_data(struct bnx2x *bp,
3526                                        int fw_sb_id,
3527                                        u32 *sb_data_p,
3528                                        u32 data_size)
3529 {
3530         int index;
3531         for (index = 0; index < data_size; index++)
3532                 REG_WR(bp, BAR_CSTRORM_INTMEM +
3533                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
3534                         sizeof(u32)*index,
3535                         *(sb_data_p + index));
3536 }
3537
3538 static inline void bnx2x_zero_fp_sb(struct bnx2x *bp, int fw_sb_id)
3539 {
3540         u32 *sb_data_p;
3541         u32 data_size = 0;
3542         struct hc_status_block_data_e1x sb_data_e1x;
3543
3544         /* disable the function first */
3545         memset(&sb_data_e1x, 0,
3546                sizeof(struct hc_status_block_data_e1x));
3547         sb_data_e1x.common.p_func.pf_id = HC_FUNCTION_DISABLED;
3548         sb_data_e1x.common.p_func.vf_id = HC_FUNCTION_DISABLED;
3549         sb_data_e1x.common.p_func.vf_valid = false;
3550         sb_data_p = (u32 *)&sb_data_e1x;
3551         data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
3552
3553         bnx2x_wr_fp_sb_data(bp, fw_sb_id, sb_data_p, data_size);
3554
3555         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3556                         CSTORM_STATUS_BLOCK_OFFSET(fw_sb_id), 0,
3557                         CSTORM_STATUS_BLOCK_SIZE);
3558         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3559                         CSTORM_SYNC_BLOCK_OFFSET(fw_sb_id), 0,
3560                         CSTORM_SYNC_BLOCK_SIZE);
3561 }
3562
3563 /* helper:  writes SP SB data to FW */
3564 static inline void bnx2x_wr_sp_sb_data(struct bnx2x *bp,
3565                 struct hc_sp_status_block_data *sp_sb_data)
3566 {
3567         int func = BP_FUNC(bp);
3568         int i;
3569         for (i = 0; i < sizeof(struct hc_sp_status_block_data)/sizeof(u32); i++)
3570                 REG_WR(bp, BAR_CSTRORM_INTMEM +
3571                         CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
3572                         i*sizeof(u32),
3573                         *((u32 *)sp_sb_data + i));
3574 }
3575
3576 static inline void bnx2x_zero_sp_sb(struct bnx2x *bp)
3577 {
3578         int func = BP_FUNC(bp);
3579         struct hc_sp_status_block_data sp_sb_data;
3580         memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
3581
3582         sp_sb_data.p_func.pf_id = HC_FUNCTION_DISABLED;
3583         sp_sb_data.p_func.vf_id = HC_FUNCTION_DISABLED;
3584         sp_sb_data.p_func.vf_valid = false;
3585
3586         bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
3587
3588         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3589                         CSTORM_SP_STATUS_BLOCK_OFFSET(func), 0,
3590                         CSTORM_SP_STATUS_BLOCK_SIZE);
3591         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3592                         CSTORM_SP_SYNC_BLOCK_OFFSET(func), 0,
3593                         CSTORM_SP_SYNC_BLOCK_SIZE);
3594
3595 }
3596
3597
3598 static inline
3599 void bnx2x_setup_ndsb_state_machine(struct hc_status_block_sm *hc_sm,
3600                                            int igu_sb_id, int igu_seg_id)
3601 {
3602         hc_sm->igu_sb_id = igu_sb_id;
3603         hc_sm->igu_seg_id = igu_seg_id;
3604         hc_sm->timer_value = 0xFF;
3605         hc_sm->time_to_expire = 0xFFFFFFFF;
3606 }
3607
3608 void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
3609                           u8 vf_valid, int fw_sb_id, int igu_sb_id)
3610 {
3611         int igu_seg_id;
3612
3613         struct hc_status_block_data_e1x sb_data_e1x;
3614         struct hc_status_block_sm  *hc_sm_p;
3615         struct hc_index_data *hc_index_p;
3616         int data_size;
3617         u32 *sb_data_p;
3618
3619         igu_seg_id = HC_SEG_ACCESS_NORM;
3620
3621         bnx2x_zero_fp_sb(bp, fw_sb_id);
3622
3623         memset(&sb_data_e1x, 0,
3624                sizeof(struct hc_status_block_data_e1x));
3625         sb_data_e1x.common.p_func.pf_id = BP_FUNC(bp);
3626         sb_data_e1x.common.p_func.vf_id = 0xff;
3627         sb_data_e1x.common.p_func.vf_valid = false;
3628         sb_data_e1x.common.p_func.vnic_id = BP_E1HVN(bp);
3629         sb_data_e1x.common.same_igu_sb_1b = true;
3630         sb_data_e1x.common.host_sb_addr.hi = U64_HI(mapping);
3631         sb_data_e1x.common.host_sb_addr.lo = U64_LO(mapping);
3632         hc_sm_p = sb_data_e1x.common.state_machine;
3633         hc_index_p = sb_data_e1x.index_data;
3634         sb_data_p = (u32 *)&sb_data_e1x;
3635         data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
3636
3637
3638         bnx2x_setup_ndsb_state_machine(&hc_sm_p[SM_RX_ID],
3639                                        igu_sb_id, igu_seg_id);
3640         bnx2x_setup_ndsb_state_machine(&hc_sm_p[SM_TX_ID],
3641                                        igu_sb_id, igu_seg_id);
3642
3643         DP(NETIF_MSG_HW, "Init FW SB %d\n", fw_sb_id);
3644
3645         /* write indecies to HW */
3646         bnx2x_wr_fp_sb_data(bp, fw_sb_id, sb_data_p, data_size);
3647 }
3648
3649 static void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, u16 fw_sb_id,
3650                                         u8 sb_index, u8 disable, u16 usec)
3651 {
3652         int port = BP_PORT(bp);
3653         u8 ticks = usec / BNX2X_BTR;
3654
3655         storm_memset_hc_timeout(bp, port, fw_sb_id, sb_index, ticks);
3656
3657         disable = disable ? 1 : (usec ? 0 : 1);
3658         storm_memset_hc_disable(bp, port, fw_sb_id, sb_index, disable);
3659 }
3660
3661 static void bnx2x_update_coalesce_sb(struct bnx2x *bp, u16 fw_sb_id,
3662                                      u16 tx_usec, u16 rx_usec)
3663 {
3664         bnx2x_update_coalesce_sb_index(bp, fw_sb_id, U_SB_ETH_RX_CQ_INDEX,
3665                                     false, rx_usec);
3666         bnx2x_update_coalesce_sb_index(bp, fw_sb_id, C_SB_ETH_TX_CQ_INDEX,
3667                                     false, tx_usec);
3668 }
3669 static void bnx2x_init_def_sb(struct bnx2x *bp)
3670 {
3671         struct host_sp_status_block *def_sb = bp->def_status_blk;
3672         dma_addr_t mapping = bp->def_status_blk_mapping;
3673         int igu_sp_sb_index;
3674         int igu_seg_id;
3675         int port = BP_PORT(bp);
3676         int func = BP_FUNC(bp);
3677         int reg_offset;
3678         u64 section;
3679         int index;
3680         struct hc_sp_status_block_data sp_sb_data;
3681         memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
3682
3683         igu_sp_sb_index = DEF_SB_IGU_ID;
3684         igu_seg_id = HC_SEG_ACCESS_DEF;
3685
3686         /* ATTN */
3687         section = ((u64)mapping) + offsetof(struct host_sp_status_block,
3688                                             atten_status_block);
3689         def_sb->atten_status_block.status_block_id = igu_sp_sb_index;
3690
3691         bp->attn_state = 0;
3692
3693         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
3694                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
3695         for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
3696                 int sindex;
3697                 /* take care of sig[0]..sig[4] */
3698                 for (sindex = 0; sindex < 4; sindex++)
3699                         bp->attn_group[index].sig[sindex] =
3700                            REG_RD(bp, reg_offset + sindex*0x4 + 0x10*index);
3701         }
3702
3703         reg_offset = (port ? HC_REG_ATTN_MSG1_ADDR_L :
3704                              HC_REG_ATTN_MSG0_ADDR_L);
3705         REG_WR(bp, reg_offset, U64_LO(section));
3706         REG_WR(bp, reg_offset + 4, U64_HI(section));
3707
3708         section = ((u64)mapping) + offsetof(struct host_sp_status_block,
3709                                             sp_sb);
3710
3711         bnx2x_zero_sp_sb(bp);
3712
3713         sp_sb_data.host_sb_addr.lo      = U64_LO(section);
3714         sp_sb_data.host_sb_addr.hi      = U64_HI(section);
3715         sp_sb_data.igu_sb_id            = igu_sp_sb_index;
3716         sp_sb_data.igu_seg_id           = igu_seg_id;
3717         sp_sb_data.p_func.pf_id         = func;
3718         sp_sb_data.p_func.vnic_id       = BP_E1HVN(bp);
3719         sp_sb_data.p_func.vf_id         = 0xff;
3720
3721         bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
3722
3723         bp->stats_pending = 0;
3724         bp->set_mac_pending = 0;
3725
3726         bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
3727 }
3728
3729 void bnx2x_update_coalesce(struct bnx2x *bp)
3730 {
3731         int i;
3732
3733         for_each_queue(bp, i)
3734                 bnx2x_update_coalesce_sb(bp, bp->fp[i].fw_sb_id,
3735                                          bp->rx_ticks, bp->tx_ticks);
3736 }
3737
3738 static void bnx2x_init_sp_ring(struct bnx2x *bp)
3739 {
3740         spin_lock_init(&bp->spq_lock);
3741         atomic_set(&bp->spq_left, MAX_SPQ_PENDING);
3742
3743         bp->spq_prod_idx = 0;
3744         bp->dsb_sp_prod = BNX2X_SP_DSB_INDEX;
3745         bp->spq_prod_bd = bp->spq;
3746         bp->spq_last_bd = bp->spq_prod_bd + MAX_SP_DESC_CNT;
3747 }
3748
3749 static void bnx2x_init_eq_ring(struct bnx2x *bp)
3750 {
3751         int i;
3752         for (i = 1; i <= NUM_EQ_PAGES; i++) {
3753                 union event_ring_elem *elem =
3754                         &bp->eq_ring[EQ_DESC_CNT_PAGE * i - 1];
3755
3756                 elem->next_page.addr.hi =
3757                         cpu_to_le32(U64_HI(bp->eq_mapping +
3758                                    BCM_PAGE_SIZE * (i % NUM_EQ_PAGES)));
3759                 elem->next_page.addr.lo =
3760                         cpu_to_le32(U64_LO(bp->eq_mapping +
3761                                    BCM_PAGE_SIZE*(i % NUM_EQ_PAGES)));
3762         }
3763         bp->eq_cons = 0;
3764         bp->eq_prod = NUM_EQ_DESC;
3765         bp->eq_cons_sb = BNX2X_EQ_INDEX;
3766 }
3767
3768 static void bnx2x_init_ind_table(struct bnx2x *bp)
3769 {
3770         int func = BP_FUNC(bp);
3771         int i;
3772
3773         if (bp->multi_mode == ETH_RSS_MODE_DISABLED)
3774                 return;
3775
3776         DP(NETIF_MSG_IFUP,
3777            "Initializing indirection table  multi_mode %d\n", bp->multi_mode);
3778         for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
3779                 REG_WR8(bp, BAR_TSTRORM_INTMEM +
3780                         TSTORM_INDIRECTION_TABLE_OFFSET(func) + i,
3781                         bp->fp->cl_id + (i % bp->num_queues));
3782 }
3783
3784 void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
3785 {
3786         int mode = bp->rx_mode;
3787         u16 cl_id;
3788
3789         /* All but management unicast packets should pass to the host as well */
3790         u32 llh_mask =
3791                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_BRCST |
3792                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_MLCST |
3793                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_VLAN |
3794                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_NO_VLAN;
3795
3796         switch (mode) {
3797         case BNX2X_RX_MODE_NONE: /* no Rx */
3798                 cl_id = BP_L_ID(bp);
3799                 bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_NONE);
3800                 break;
3801
3802         case BNX2X_RX_MODE_NORMAL:
3803                 cl_id = BP_L_ID(bp);
3804                 bnx2x_rxq_set_mac_filters(bp, cl_id,
3805                         BNX2X_ACCEPT_UNICAST |
3806                         BNX2X_ACCEPT_BROADCAST |
3807                         BNX2X_ACCEPT_MULTICAST);
3808                 break;
3809
3810         case BNX2X_RX_MODE_ALLMULTI:
3811                 cl_id = BP_L_ID(bp);
3812                 bnx2x_rxq_set_mac_filters(bp, cl_id,
3813                         BNX2X_ACCEPT_UNICAST |
3814                         BNX2X_ACCEPT_BROADCAST |
3815                         BNX2X_ACCEPT_ALL_MULTICAST);
3816                 break;
3817
3818         case BNX2X_RX_MODE_PROMISC:
3819                 cl_id = BP_L_ID(bp);
3820                 bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_PROMISCUOUS_MODE);
3821
3822                 /* pass management unicast packets as well */
3823                 llh_mask |= NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_UNCST;
3824                 break;
3825
3826         default:
3827                 BNX2X_ERR("BAD rx mode (%d)\n", mode);
3828                 break;
3829         }
3830
3831         REG_WR(bp,
3832                BP_PORT(bp) ? NIG_REG_LLH1_BRB1_DRV_MASK :
3833                              NIG_REG_LLH0_BRB1_DRV_MASK,
3834                llh_mask);
3835
3836         DP(NETIF_MSG_IFUP, "rx mode %d\n"
3837                 "drop_ucast 0x%x\ndrop_mcast 0x%x\ndrop_bcast 0x%x\n"
3838                 "accp_ucast 0x%x\naccp_mcast 0x%x\naccp_bcast 0x%x\n", mode,
3839                 bp->mac_filters.ucast_drop_all,
3840                 bp->mac_filters.mcast_drop_all,
3841                 bp->mac_filters.bcast_drop_all,
3842                 bp->mac_filters.ucast_accept_all,
3843                 bp->mac_filters.mcast_accept_all,
3844                 bp->mac_filters.bcast_accept_all
3845         );
3846
3847         storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
3848 }
3849
3850 static void bnx2x_init_internal_common(struct bnx2x *bp)
3851 {
3852         int i;
3853
3854         if (!CHIP_IS_E1(bp)) {
3855
3856                 /* xstorm needs to know whether to add  ovlan to packets or not,
3857                  * in switch-independent we'll write 0 to here... */
3858                 REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNCTION_MODE_OFFSET,
3859                         bp->mf_mode);
3860                 REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNCTION_MODE_OFFSET,
3861                         bp->mf_mode);
3862                 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNCTION_MODE_OFFSET,
3863                         bp->mf_mode);
3864                 REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNCTION_MODE_OFFSET,
3865                         bp->mf_mode);
3866         }
3867
3868         /* Zero this manually as its initialization is
3869            currently missing in the initTool */
3870         for (i = 0; i < (USTORM_AGG_DATA_SIZE >> 2); i++)
3871                 REG_WR(bp, BAR_USTRORM_INTMEM +
3872                        USTORM_AGG_DATA_OFFSET + i * 4, 0);
3873 }
3874
3875 static void bnx2x_init_internal_port(struct bnx2x *bp)
3876 {
3877         /* port */
3878 }
3879
3880 static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
3881 {
3882         switch (load_code) {
3883         case FW_MSG_CODE_DRV_LOAD_COMMON:
3884                 bnx2x_init_internal_common(bp);
3885                 /* no break */
3886
3887         case FW_MSG_CODE_DRV_LOAD_PORT:
3888                 bnx2x_init_internal_port(bp);
3889                 /* no break */
3890
3891         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
3892                 /* internal memory per function is
3893                    initialized inside bnx2x_pf_init */
3894                 break;
3895
3896         default:
3897                 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
3898                 break;
3899         }
3900 }
3901
3902 static void bnx2x_init_fp_sb(struct bnx2x *bp, int fp_idx)
3903 {
3904         struct bnx2x_fastpath *fp = &bp->fp[fp_idx];
3905
3906         fp->state = BNX2X_FP_STATE_CLOSED;
3907
3908         fp->index = fp->cid = fp_idx;
3909         fp->cl_id = BP_L_ID(bp) + fp_idx;
3910         fp->fw_sb_id = bp->base_fw_ndsb + fp->cl_id + CNIC_CONTEXT_USE;
3911         fp->igu_sb_id = bp->igu_base_sb + fp_idx + CNIC_CONTEXT_USE;
3912         /* qZone id equals to FW (per path) client id */
3913         fp->cl_qzone_id  = fp->cl_id +
3914                            BP_PORT(bp)*(ETH_MAX_RX_CLIENTS_E1H);
3915         /* init shortcut */
3916         fp->ustorm_rx_prods_offset =
3917                             USTORM_RX_PRODS_E1X_OFFSET(BP_PORT(bp), fp->cl_id);
3918         /* Setup SB indicies */
3919         fp->rx_cons_sb = BNX2X_RX_SB_INDEX;
3920         fp->tx_cons_sb = BNX2X_TX_SB_INDEX;
3921
3922         DP(NETIF_MSG_IFUP, "queue[%d]:  bnx2x_init_sb(%p,%p)  "
3923                                    "cl_id %d  fw_sb %d  igu_sb %d\n",
3924                    fp_idx, bp, fp->status_blk.e1x_sb, fp->cl_id, fp->fw_sb_id,
3925                    fp->igu_sb_id);
3926         bnx2x_init_sb(bp, fp->status_blk_mapping, BNX2X_VF_ID_INVALID, false,
3927                       fp->fw_sb_id, fp->igu_sb_id);
3928
3929         bnx2x_update_fpsb_idx(fp);
3930 }
3931
3932 void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
3933 {
3934         int i;
3935
3936         for_each_queue(bp, i)
3937                 bnx2x_init_fp_sb(bp, i);
3938 #ifdef BCM_CNIC
3939
3940         bnx2x_init_sb(bp, bp->cnic_sb_mapping,
3941                       BNX2X_VF_ID_INVALID, false,
3942                       CNIC_SB_ID(bp), CNIC_IGU_SB_ID(bp));
3943
3944 #endif
3945
3946         /* ensure status block indices were read */
3947         rmb();
3948
3949         bnx2x_init_def_sb(bp);
3950         bnx2x_update_dsb_idx(bp);
3951         bnx2x_init_rx_rings(bp);
3952         bnx2x_init_tx_rings(bp);
3953         bnx2x_init_sp_ring(bp);
3954         bnx2x_init_eq_ring(bp);
3955         bnx2x_init_internal(bp, load_code);
3956         bnx2x_pf_init(bp);
3957         bnx2x_init_ind_table(bp);
3958         bnx2x_stats_init(bp);
3959
3960         /* At this point, we are ready for interrupts */
3961         atomic_set(&bp->intr_sem, 0);
3962
3963         /* flush all before enabling interrupts */
3964         mb();
3965         mmiowb();
3966
3967         bnx2x_int_enable(bp);
3968
3969         /* Check for SPIO5 */
3970         bnx2x_attn_int_deasserted0(bp,
3971                 REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + BP_PORT(bp)*4) &
3972                                    AEU_INPUTS_ATTN_BITS_SPIO5);
3973 }
3974
3975 /* end of nic init */
3976
3977 /*
3978  * gzip service functions
3979  */
3980
3981 static int bnx2x_gunzip_init(struct bnx2x *bp)
3982 {
3983         bp->gunzip_buf = dma_alloc_coherent(&bp->pdev->dev, FW_BUF_SIZE,
3984                                             &bp->gunzip_mapping, GFP_KERNEL);
3985         if (bp->gunzip_buf  == NULL)
3986                 goto gunzip_nomem1;
3987
3988         bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL);
3989         if (bp->strm  == NULL)
3990                 goto gunzip_nomem2;
3991
3992         bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(),
3993                                       GFP_KERNEL);
3994         if (bp->strm->workspace == NULL)
3995                 goto gunzip_nomem3;
3996
3997         return 0;
3998
3999 gunzip_nomem3:
4000         kfree(bp->strm);
4001         bp->strm = NULL;
4002
4003 gunzip_nomem2:
4004         dma_free_coherent(&bp->pdev->dev, FW_BUF_SIZE, bp->gunzip_buf,
4005                           bp->gunzip_mapping);
4006         bp->gunzip_buf = NULL;
4007
4008 gunzip_nomem1:
4009         netdev_err(bp->dev, "Cannot allocate firmware buffer for"
4010                " un-compression\n");
4011         return -ENOMEM;
4012 }
4013
4014 static void bnx2x_gunzip_end(struct bnx2x *bp)
4015 {
4016         kfree(bp->strm->workspace);
4017
4018         kfree(bp->strm);
4019         bp->strm = NULL;
4020
4021         if (bp->gunzip_buf) {
4022                 dma_free_coherent(&bp->pdev->dev, FW_BUF_SIZE, bp->gunzip_buf,
4023                                   bp->gunzip_mapping);
4024                 bp->gunzip_buf = NULL;
4025         }
4026 }
4027
4028 static int bnx2x_gunzip(struct bnx2x *bp, const u8 *zbuf, int len)
4029 {
4030         int n, rc;
4031
4032         /* check gzip header */
4033         if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED)) {
4034                 BNX2X_ERR("Bad gzip header\n");
4035                 return -EINVAL;
4036         }
4037
4038         n = 10;
4039
4040 #define FNAME                           0x8
4041
4042         if (zbuf[3] & FNAME)
4043                 while ((zbuf[n++] != 0) && (n < len));
4044
4045         bp->strm->next_in = (typeof(bp->strm->next_in))zbuf + n;
4046         bp->strm->avail_in = len - n;
4047         bp->strm->next_out = bp->gunzip_buf;
4048         bp->strm->avail_out = FW_BUF_SIZE;
4049
4050         rc = zlib_inflateInit2(bp->strm, -MAX_WBITS);
4051         if (rc != Z_OK)
4052                 return rc;
4053
4054         rc = zlib_inflate(bp->strm, Z_FINISH);
4055         if ((rc != Z_OK) && (rc != Z_STREAM_END))
4056                 netdev_err(bp->dev, "Firmware decompression error: %s\n",
4057                            bp->strm->msg);
4058
4059         bp->gunzip_outlen = (FW_BUF_SIZE - bp->strm->avail_out);
4060         if (bp->gunzip_outlen & 0x3)
4061                 netdev_err(bp->dev, "Firmware decompression error:"
4062                                     " gunzip_outlen (%d) not aligned\n",
4063                                 bp->gunzip_outlen);
4064         bp->gunzip_outlen >>= 2;
4065
4066         zlib_inflateEnd(bp->strm);
4067
4068         if (rc == Z_STREAM_END)
4069                 return 0;
4070
4071         return rc;
4072 }
4073
4074 /* nic load/unload */
4075
4076 /*
4077  * General service functions
4078  */
4079
4080 /* send a NIG loopback debug packet */
4081 static void bnx2x_lb_pckt(struct bnx2x *bp)
4082 {
4083         u32 wb_write[3];
4084
4085         /* Ethernet source and destination addresses */
4086         wb_write[0] = 0x55555555;
4087         wb_write[1] = 0x55555555;
4088         wb_write[2] = 0x20;             /* SOP */
4089         REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4090
4091         /* NON-IP protocol */
4092         wb_write[0] = 0x09000000;
4093         wb_write[1] = 0x55555555;
4094         wb_write[2] = 0x10;             /* EOP, eop_bvalid = 0 */
4095         REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4096 }
4097
4098 /* some of the internal memories
4099  * are not directly readable from the driver
4100  * to test them we send debug packets
4101  */
4102 static int bnx2x_int_mem_test(struct bnx2x *bp)
4103 {
4104         int factor;
4105         int count, i;
4106         u32 val = 0;
4107
4108         if (CHIP_REV_IS_FPGA(bp))
4109                 factor = 120;
4110         else if (CHIP_REV_IS_EMUL(bp))
4111                 factor = 200;
4112         else
4113                 factor = 1;
4114
4115         /* Disable inputs of parser neighbor blocks */
4116         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
4117         REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
4118         REG_WR(bp, CFC_REG_DEBUG0, 0x1);
4119         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
4120
4121         /*  Write 0 to parser credits for CFC search request */
4122         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
4123
4124         /* send Ethernet packet */
4125         bnx2x_lb_pckt(bp);
4126
4127         /* TODO do i reset NIG statistic? */
4128         /* Wait until NIG register shows 1 packet of size 0x10 */
4129         count = 1000 * factor;
4130         while (count) {
4131
4132                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
4133                 val = *bnx2x_sp(bp, wb_data[0]);
4134                 if (val == 0x10)
4135                         break;
4136
4137                 msleep(10);
4138                 count--;
4139         }
4140         if (val != 0x10) {
4141                 BNX2X_ERR("NIG timeout  val = 0x%x\n", val);
4142                 return -1;
4143         }
4144
4145         /* Wait until PRS register shows 1 packet */
4146         count = 1000 * factor;
4147         while (count) {
4148                 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4149                 if (val == 1)
4150                         break;
4151
4152                 msleep(10);
4153                 count--;
4154         }
4155         if (val != 0x1) {
4156                 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
4157                 return -2;
4158         }
4159
4160         /* Reset and init BRB, PRS */
4161         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
4162         msleep(50);
4163         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
4164         msleep(50);
4165         bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
4166         bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
4167
4168         DP(NETIF_MSG_HW, "part2\n");
4169
4170         /* Disable inputs of parser neighbor blocks */
4171         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
4172         REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
4173         REG_WR(bp, CFC_REG_DEBUG0, 0x1);
4174         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
4175
4176         /* Write 0 to parser credits for CFC search request */
4177         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
4178
4179         /* send 10 Ethernet packets */
4180         for (i = 0; i < 10; i++)
4181                 bnx2x_lb_pckt(bp);
4182
4183         /* Wait until NIG register shows 10 + 1
4184            packets of size 11*0x10 = 0xb0 */
4185         count = 1000 * factor;
4186         while (count) {
4187
4188                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
4189                 val = *bnx2x_sp(bp, wb_data[0]);
4190                 if (val == 0xb0)
4191                         break;
4192
4193                 msleep(10);
4194                 count--;
4195         }
4196         if (val != 0xb0) {
4197                 BNX2X_ERR("NIG timeout  val = 0x%x\n", val);
4198                 return -3;
4199         }
4200
4201         /* Wait until PRS register shows 2 packets */
4202         val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4203         if (val != 2)
4204                 BNX2X_ERR("PRS timeout  val = 0x%x\n", val);
4205
4206         /* Write 1 to parser credits for CFC search request */
4207         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x1);
4208
4209         /* Wait until PRS register shows 3 packets */
4210         msleep(10 * factor);
4211         /* Wait until NIG register shows 1 packet of size 0x10 */
4212         val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4213         if (val != 3)
4214                 BNX2X_ERR("PRS timeout  val = 0x%x\n", val);
4215
4216         /* clear NIG EOP FIFO */
4217         for (i = 0; i < 11; i++)
4218                 REG_RD(bp, NIG_REG_INGRESS_EOP_LB_FIFO);
4219         val = REG_RD(bp, NIG_REG_INGRESS_EOP_LB_EMPTY);
4220         if (val != 1) {
4221                 BNX2X_ERR("clear of NIG failed\n");
4222                 return -4;
4223         }
4224
4225         /* Reset and init BRB, PRS, NIG */
4226         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
4227         msleep(50);
4228         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
4229         msleep(50);
4230         bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
4231         bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
4232 #ifndef BCM_CNIC
4233         /* set NIC mode */
4234         REG_WR(bp, PRS_REG_NIC_MODE, 1);
4235 #endif
4236
4237         /* Enable inputs of parser neighbor blocks */
4238         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x7fffffff);
4239         REG_WR(bp, TCM_REG_PRS_IFEN, 0x1);
4240         REG_WR(bp, CFC_REG_DEBUG0, 0x0);
4241         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x1);
4242
4243         DP(NETIF_MSG_HW, "done\n");
4244
4245         return 0; /* OK */
4246 }
4247
4248 static void enable_blocks_attention(struct bnx2x *bp)
4249 {
4250         REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
4251         REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0);
4252         REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
4253         REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
4254         REG_WR(bp, QM_REG_QM_INT_MASK, 0);
4255         REG_WR(bp, TM_REG_TM_INT_MASK, 0);
4256         REG_WR(bp, XSDM_REG_XSDM_INT_MASK_0, 0);
4257         REG_WR(bp, XSDM_REG_XSDM_INT_MASK_1, 0);
4258         REG_WR(bp, XCM_REG_XCM_INT_MASK, 0);
4259 /*      REG_WR(bp, XSEM_REG_XSEM_INT_MASK_0, 0); */
4260 /*      REG_WR(bp, XSEM_REG_XSEM_INT_MASK_1, 0); */
4261         REG_WR(bp, USDM_REG_USDM_INT_MASK_0, 0);
4262         REG_WR(bp, USDM_REG_USDM_INT_MASK_1, 0);
4263         REG_WR(bp, UCM_REG_UCM_INT_MASK, 0);
4264 /*      REG_WR(bp, USEM_REG_USEM_INT_MASK_0, 0); */
4265 /*      REG_WR(bp, USEM_REG_USEM_INT_MASK_1, 0); */
4266         REG_WR(bp, GRCBASE_UPB + PB_REG_PB_INT_MASK, 0);
4267         REG_WR(bp, CSDM_REG_CSDM_INT_MASK_0, 0);
4268         REG_WR(bp, CSDM_REG_CSDM_INT_MASK_1, 0);
4269         REG_WR(bp, CCM_REG_CCM_INT_MASK, 0);
4270 /*      REG_WR(bp, CSEM_REG_CSEM_INT_MASK_0, 0); */
4271 /*      REG_WR(bp, CSEM_REG_CSEM_INT_MASK_1, 0); */
4272         if (CHIP_REV_IS_FPGA(bp))
4273                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x580000);
4274         else
4275                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x480000);
4276         REG_WR(bp, TSDM_REG_TSDM_INT_MASK_0, 0);
4277         REG_WR(bp, TSDM_REG_TSDM_INT_MASK_1, 0);
4278         REG_WR(bp, TCM_REG_TCM_INT_MASK, 0);
4279 /*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_0, 0); */
4280 /*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_1, 0); */
4281         REG_WR(bp, CDU_REG_CDU_INT_MASK, 0);
4282         REG_WR(bp, DMAE_REG_DMAE_INT_MASK, 0);
4283 /*      REG_WR(bp, MISC_REG_MISC_INT_MASK, 0); */
4284         REG_WR(bp, PBF_REG_PBF_INT_MASK, 0X18);         /* bit 3,4 masked */
4285 }
4286
4287 static const struct {
4288         u32 addr;
4289         u32 mask;
4290 } bnx2x_parity_mask[] = {
4291         {PXP_REG_PXP_PRTY_MASK, 0xffffffff},
4292         {PXP2_REG_PXP2_PRTY_MASK_0, 0xffffffff},
4293         {PXP2_REG_PXP2_PRTY_MASK_1, 0xffffffff},
4294         {HC_REG_HC_PRTY_MASK, 0xffffffff},
4295         {MISC_REG_MISC_PRTY_MASK, 0xffffffff},
4296         {QM_REG_QM_PRTY_MASK, 0x0},
4297         {DORQ_REG_DORQ_PRTY_MASK, 0x0},
4298         {GRCBASE_UPB + PB_REG_PB_PRTY_MASK, 0x0},
4299         {GRCBASE_XPB + PB_REG_PB_PRTY_MASK, 0x0},
4300         {SRC_REG_SRC_PRTY_MASK, 0x4}, /* bit 2 */
4301         {CDU_REG_CDU_PRTY_MASK, 0x0},
4302         {CFC_REG_CFC_PRTY_MASK, 0x0},
4303         {DBG_REG_DBG_PRTY_MASK, 0x0},
4304         {DMAE_REG_DMAE_PRTY_MASK, 0x0},
4305         {BRB1_REG_BRB1_PRTY_MASK, 0x0},
4306         {PRS_REG_PRS_PRTY_MASK, (1<<6)},/* bit 6 */
4307         {TSDM_REG_TSDM_PRTY_MASK, 0x18},/* bit 3,4 */
4308         {CSDM_REG_CSDM_PRTY_MASK, 0x8}, /* bit 3 */
4309         {USDM_REG_USDM_PRTY_MASK, 0x38},/* bit 3,4,5 */
4310         {XSDM_REG_XSDM_PRTY_MASK, 0x8}, /* bit 3 */
4311         {TSEM_REG_TSEM_PRTY_MASK_0, 0x0},
4312         {TSEM_REG_TSEM_PRTY_MASK_1, 0x0},
4313         {USEM_REG_USEM_PRTY_MASK_0, 0x0},
4314         {USEM_REG_USEM_PRTY_MASK_1, 0x0},
4315         {CSEM_REG_CSEM_PRTY_MASK_0, 0x0},
4316         {CSEM_REG_CSEM_PRTY_MASK_1, 0x0},
4317         {XSEM_REG_XSEM_PRTY_MASK_0, 0x0},
4318         {XSEM_REG_XSEM_PRTY_MASK_1, 0x0}
4319 };
4320
4321 static void enable_blocks_parity(struct bnx2x *bp)
4322 {
4323         int i;
4324
4325         for (i = 0; i < ARRAY_SIZE(bnx2x_parity_mask); i++)
4326                 REG_WR(bp, bnx2x_parity_mask[i].addr,
4327                         bnx2x_parity_mask[i].mask);
4328 }
4329
4330
4331 static void bnx2x_reset_common(struct bnx2x *bp)
4332 {
4333         /* reset_common */
4334         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
4335                0xd3ffff7f);
4336         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
4337 }
4338
4339 static void bnx2x_init_pxp(struct bnx2x *bp)
4340 {
4341         u16 devctl;
4342         int r_order, w_order;
4343
4344         pci_read_config_word(bp->pdev,
4345                              bp->pcie_cap + PCI_EXP_DEVCTL, &devctl);
4346         DP(NETIF_MSG_HW, "read 0x%x from devctl\n", devctl);
4347         w_order = ((devctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
4348         if (bp->mrrs == -1)
4349                 r_order = ((devctl & PCI_EXP_DEVCTL_READRQ) >> 12);
4350         else {
4351                 DP(NETIF_MSG_HW, "force read order to %d\n", bp->mrrs);
4352                 r_order = bp->mrrs;
4353         }
4354
4355         bnx2x_init_pxp_arb(bp, r_order, w_order);
4356 }
4357
4358 static void bnx2x_setup_fan_failure_detection(struct bnx2x *bp)
4359 {
4360         int is_required;
4361         u32 val;
4362         int port;
4363
4364         if (BP_NOMCP(bp))
4365                 return;
4366
4367         is_required = 0;
4368         val = SHMEM_RD(bp, dev_info.shared_hw_config.config2) &
4369               SHARED_HW_CFG_FAN_FAILURE_MASK;
4370
4371         if (val == SHARED_HW_CFG_FAN_FAILURE_ENABLED)
4372                 is_required = 1;
4373
4374         /*
4375          * The fan failure mechanism is usually related to the PHY type since
4376          * the power consumption of the board is affected by the PHY. Currently,
4377          * fan is required for most designs with SFX7101, BCM8727 and BCM8481.
4378          */
4379         else if (val == SHARED_HW_CFG_FAN_FAILURE_PHY_TYPE)
4380                 for (port = PORT_0; port < PORT_MAX; port++) {
4381                         is_required |=
4382                                 bnx2x_fan_failure_det_req(
4383                                         bp,
4384                                         bp->common.shmem_base,
4385                                         bp->common.shmem2_base,
4386                                         port);
4387                 }
4388
4389         DP(NETIF_MSG_HW, "fan detection setting: %d\n", is_required);
4390
4391         if (is_required == 0)
4392                 return;
4393
4394         /* Fan failure is indicated by SPIO 5 */
4395         bnx2x_set_spio(bp, MISC_REGISTERS_SPIO_5,
4396                        MISC_REGISTERS_SPIO_INPUT_HI_Z);
4397
4398         /* set to active low mode */
4399         val = REG_RD(bp, MISC_REG_SPIO_INT);
4400         val |= ((1 << MISC_REGISTERS_SPIO_5) <<
4401                                         MISC_REGISTERS_SPIO_INT_OLD_SET_POS);
4402         REG_WR(bp, MISC_REG_SPIO_INT, val);
4403
4404         /* enable interrupt to signal the IGU */
4405         val = REG_RD(bp, MISC_REG_SPIO_EVENT_EN);
4406         val |= (1 << MISC_REGISTERS_SPIO_5);
4407         REG_WR(bp, MISC_REG_SPIO_EVENT_EN, val);
4408 }
4409
4410 static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
4411 {
4412         u32 val, i;
4413
4414         DP(BNX2X_MSG_MCP, "starting common init  func %d\n", BP_FUNC(bp));
4415
4416         bnx2x_reset_common(bp);
4417         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
4418         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, 0xfffc);
4419
4420         bnx2x_init_block(bp, MISC_BLOCK, COMMON_STAGE);
4421         if (CHIP_IS_E1H(bp))
4422                 REG_WR(bp, MISC_REG_E1HMF_MODE, IS_MF(bp));
4423
4424         REG_WR(bp, MISC_REG_LCPLL_CTRL_REG_2, 0x100);
4425         msleep(30);
4426         REG_WR(bp, MISC_REG_LCPLL_CTRL_REG_2, 0x0);
4427
4428         bnx2x_init_block(bp, PXP_BLOCK, COMMON_STAGE);
4429         if (CHIP_IS_E1(bp)) {
4430                 /* enable HW interrupt from PXP on USDM overflow
4431                    bit 16 on INT_MASK_0 */
4432                 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
4433         }
4434
4435         bnx2x_init_block(bp, PXP2_BLOCK, COMMON_STAGE);
4436         bnx2x_init_pxp(bp);
4437
4438 #ifdef __BIG_ENDIAN
4439         REG_WR(bp, PXP2_REG_RQ_QM_ENDIAN_M, 1);
4440         REG_WR(bp, PXP2_REG_RQ_TM_ENDIAN_M, 1);
4441         REG_WR(bp, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
4442         REG_WR(bp, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
4443         REG_WR(bp, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
4444         /* make sure this value is 0 */
4445         REG_WR(bp, PXP2_REG_RQ_HC_ENDIAN_M, 0);
4446
4447 /*      REG_WR(bp, PXP2_REG_RD_PBF_SWAP_MODE, 1); */
4448         REG_WR(bp, PXP2_REG_RD_QM_SWAP_MODE, 1);
4449         REG_WR(bp, PXP2_REG_RD_TM_SWAP_MODE, 1);
4450         REG_WR(bp, PXP2_REG_RD_SRC_SWAP_MODE, 1);
4451         REG_WR(bp, PXP2_REG_RD_CDURD_SWAP_MODE, 1);
4452 #endif
4453
4454         bnx2x_ilt_init_page_size(bp, INITOP_SET);
4455
4456
4457         if (CHIP_REV_IS_FPGA(bp) && CHIP_IS_E1H(bp))
4458                 REG_WR(bp, PXP2_REG_PGL_TAGS_LIMIT, 0x1);
4459
4460         /* let the HW do it's magic ... */
4461         msleep(100);
4462         /* finish PXP init */
4463         val = REG_RD(bp, PXP2_REG_RQ_CFG_DONE);
4464         if (val != 1) {
4465                 BNX2X_ERR("PXP2 CFG failed\n");
4466                 return -EBUSY;
4467         }
4468         val = REG_RD(bp, PXP2_REG_RD_INIT_DONE);
4469         if (val != 1) {
4470                 BNX2X_ERR("PXP2 RD_INIT failed\n");
4471                 return -EBUSY;
4472         }
4473
4474         REG_WR(bp, PXP2_REG_RQ_DISABLE_INPUTS, 0);
4475         REG_WR(bp, PXP2_REG_RD_DISABLE_INPUTS, 0);
4476
4477         bnx2x_init_block(bp, DMAE_BLOCK, COMMON_STAGE);
4478
4479         /* clean the DMAE memory */
4480         bp->dmae_ready = 1;
4481         bnx2x_init_fill(bp, TSEM_REG_PRAM, 0, 8);
4482
4483         bnx2x_init_block(bp, TCM_BLOCK, COMMON_STAGE);
4484         bnx2x_init_block(bp, UCM_BLOCK, COMMON_STAGE);
4485         bnx2x_init_block(bp, CCM_BLOCK, COMMON_STAGE);
4486         bnx2x_init_block(bp, XCM_BLOCK, COMMON_STAGE);
4487
4488         bnx2x_read_dmae(bp, XSEM_REG_PASSIVE_BUFFER, 3);
4489         bnx2x_read_dmae(bp, CSEM_REG_PASSIVE_BUFFER, 3);
4490         bnx2x_read_dmae(bp, TSEM_REG_PASSIVE_BUFFER, 3);
4491         bnx2x_read_dmae(bp, USEM_REG_PASSIVE_BUFFER, 3);
4492
4493         bnx2x_init_block(bp, QM_BLOCK, COMMON_STAGE);
4494
4495         /* QM queues pointers table */
4496         bnx2x_qm_init_ptr_table(bp, bp->qm_cid_count, INITOP_SET);
4497
4498         /* soft reset pulse */
4499         REG_WR(bp, QM_REG_SOFT_RESET, 1);
4500         REG_WR(bp, QM_REG_SOFT_RESET, 0);
4501
4502 #ifdef BCM_CNIC
4503         bnx2x_init_block(bp, TIMERS_BLOCK, COMMON_STAGE);
4504 #endif
4505
4506         bnx2x_init_block(bp, DQ_BLOCK, COMMON_STAGE);
4507         REG_WR(bp, DORQ_REG_DPM_CID_OFST, BNX2X_DB_SHIFT);
4508
4509         if (!CHIP_REV_IS_SLOW(bp)) {
4510                 /* enable hw interrupt from doorbell Q */
4511                 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
4512         }
4513
4514         bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
4515         bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
4516         REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
4517 #ifndef BCM_CNIC
4518         /* set NIC mode */
4519         REG_WR(bp, PRS_REG_NIC_MODE, 1);
4520 #endif
4521         if (CHIP_IS_E1H(bp))
4522                 REG_WR(bp, PRS_REG_E1HOV_MODE, IS_MF(bp));
4523
4524         bnx2x_init_block(bp, TSDM_BLOCK, COMMON_STAGE);
4525         bnx2x_init_block(bp, CSDM_BLOCK, COMMON_STAGE);
4526         bnx2x_init_block(bp, USDM_BLOCK, COMMON_STAGE);
4527         bnx2x_init_block(bp, XSDM_BLOCK, COMMON_STAGE);
4528
4529         bnx2x_init_fill(bp, TSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
4530         bnx2x_init_fill(bp, USEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
4531         bnx2x_init_fill(bp, CSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
4532         bnx2x_init_fill(bp, XSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
4533
4534         bnx2x_init_block(bp, TSEM_BLOCK, COMMON_STAGE);
4535         bnx2x_init_block(bp, USEM_BLOCK, COMMON_STAGE);
4536         bnx2x_init_block(bp, CSEM_BLOCK, COMMON_STAGE);
4537         bnx2x_init_block(bp, XSEM_BLOCK, COMMON_STAGE);
4538
4539         /* sync semi rtc */
4540         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
4541                0x80000000);
4542         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
4543                0x80000000);
4544
4545         bnx2x_init_block(bp, UPB_BLOCK, COMMON_STAGE);
4546         bnx2x_init_block(bp, XPB_BLOCK, COMMON_STAGE);
4547         bnx2x_init_block(bp, PBF_BLOCK, COMMON_STAGE);
4548
4549         REG_WR(bp, SRC_REG_SOFT_RST, 1);
4550         for (i = SRC_REG_KEYRSS0_0; i <= SRC_REG_KEYRSS1_9; i += 4)
4551                 REG_WR(bp, i, random32());
4552         bnx2x_init_block(bp, SRCH_BLOCK, COMMON_STAGE);
4553 #ifdef BCM_CNIC
4554         REG_WR(bp, SRC_REG_KEYSEARCH_0, 0x63285672);
4555         REG_WR(bp, SRC_REG_KEYSEARCH_1, 0x24b8f2cc);
4556         REG_WR(bp, SRC_REG_KEYSEARCH_2, 0x223aef9b);
4557         REG_WR(bp, SRC_REG_KEYSEARCH_3, 0x26001e3a);
4558         REG_WR(bp, SRC_REG_KEYSEARCH_4, 0x7ae91116);
4559         REG_WR(bp, SRC_REG_KEYSEARCH_5, 0x5ce5230b);
4560         REG_WR(bp, SRC_REG_KEYSEARCH_6, 0x298d8adf);
4561         REG_WR(bp, SRC_REG_KEYSEARCH_7, 0x6eb0ff09);
4562         REG_WR(bp, SRC_REG_KEYSEARCH_8, 0x1830f82f);
4563         REG_WR(bp, SRC_REG_KEYSEARCH_9, 0x01e46be7);
4564 #endif
4565         REG_WR(bp, SRC_REG_SOFT_RST, 0);
4566
4567         if (sizeof(union cdu_context) != 1024)
4568                 /* we currently assume that a context is 1024 bytes */
4569                 dev_alert(&bp->pdev->dev, "please adjust the size "
4570                                           "of cdu_context(%ld)\n",
4571                          (long)sizeof(union cdu_context));
4572
4573         bnx2x_init_block(bp, CDU_BLOCK, COMMON_STAGE);
4574         val = (4 << 24) + (0 << 12) + 1024;
4575         REG_WR(bp, CDU_REG_CDU_GLOBAL_PARAMS, val);
4576
4577         bnx2x_init_block(bp, CFC_BLOCK, COMMON_STAGE);
4578         REG_WR(bp, CFC_REG_INIT_REG, 0x7FF);
4579         /* enable context validation interrupt from CFC */
4580         REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
4581
4582         /* set the thresholds to prevent CFC/CDU race */
4583         REG_WR(bp, CFC_REG_DEBUG0, 0x20020000);
4584
4585         bnx2x_init_block(bp, HC_BLOCK, COMMON_STAGE);
4586         bnx2x_init_block(bp, MISC_AEU_BLOCK, COMMON_STAGE);
4587
4588         bnx2x_init_block(bp, PXPCS_BLOCK, COMMON_STAGE);
4589         /* Reset PCIE errors for debug */
4590         REG_WR(bp, 0x2814, 0xffffffff);
4591         REG_WR(bp, 0x3820, 0xffffffff);
4592
4593         bnx2x_init_block(bp, EMAC0_BLOCK, COMMON_STAGE);
4594         bnx2x_init_block(bp, EMAC1_BLOCK, COMMON_STAGE);
4595         bnx2x_init_block(bp, DBU_BLOCK, COMMON_STAGE);
4596         bnx2x_init_block(bp, DBG_BLOCK, COMMON_STAGE);
4597
4598         bnx2x_init_block(bp, NIG_BLOCK, COMMON_STAGE);
4599         if (CHIP_IS_E1H(bp)) {
4600                 REG_WR(bp, NIG_REG_LLH_MF_MODE, IS_MF(bp));
4601                 REG_WR(bp, NIG_REG_LLH_E1HOV_MODE, IS_MF(bp));
4602         }
4603
4604         if (CHIP_REV_IS_SLOW(bp))
4605                 msleep(200);
4606
4607         /* finish CFC init */
4608         val = reg_poll(bp, CFC_REG_LL_INIT_DONE, 1, 100, 10);
4609         if (val != 1) {
4610                 BNX2X_ERR("CFC LL_INIT failed\n");
4611                 return -EBUSY;
4612         }
4613         val = reg_poll(bp, CFC_REG_AC_INIT_DONE, 1, 100, 10);
4614         if (val != 1) {
4615                 BNX2X_ERR("CFC AC_INIT failed\n");
4616                 return -EBUSY;
4617         }
4618         val = reg_poll(bp, CFC_REG_CAM_INIT_DONE, 1, 100, 10);
4619         if (val != 1) {
4620                 BNX2X_ERR("CFC CAM_INIT failed\n");
4621                 return -EBUSY;
4622         }
4623         REG_WR(bp, CFC_REG_DEBUG0, 0);
4624
4625         /* read NIG statistic
4626            to see if this is our first up since powerup */
4627         bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
4628         val = *bnx2x_sp(bp, wb_data[0]);
4629
4630         /* do internal memory self test */
4631         if ((CHIP_IS_E1(bp)) && (val == 0) && bnx2x_int_mem_test(bp)) {
4632                 BNX2X_ERR("internal mem self test failed\n");
4633                 return -EBUSY;
4634         }
4635
4636         bp->port.need_hw_lock = bnx2x_hw_lock_required(bp,
4637                                                        bp->common.shmem_base,
4638                                                        bp->common.shmem2_base);
4639
4640         bnx2x_setup_fan_failure_detection(bp);
4641
4642         /* clear PXP2 attentions */
4643         REG_RD(bp, PXP2_REG_PXP2_INT_STS_CLR_0);
4644
4645         enable_blocks_attention(bp);
4646         if (CHIP_PARITY_SUPPORTED(bp))
4647                 enable_blocks_parity(bp);
4648
4649         if (!BP_NOMCP(bp)) {
4650                 bnx2x_acquire_phy_lock(bp);
4651                 bnx2x_common_init_phy(bp, bp->common.shmem_base,
4652                                       bp->common.shmem2_base);
4653                 bnx2x_release_phy_lock(bp);
4654         } else
4655                 BNX2X_ERR("Bootcode is missing - can not initialize link\n");
4656
4657         return 0;
4658 }
4659
4660 static int bnx2x_init_hw_port(struct bnx2x *bp)
4661 {
4662         int port = BP_PORT(bp);
4663         int init_stage = port ? PORT1_STAGE : PORT0_STAGE;
4664         u32 low, high;
4665         u32 val;
4666
4667         DP(BNX2X_MSG_MCP, "starting port init  port %d\n", port);
4668
4669         REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
4670
4671         bnx2x_init_block(bp, PXP_BLOCK, init_stage);
4672         bnx2x_init_block(bp, PXP2_BLOCK, init_stage);
4673
4674         bnx2x_init_block(bp, TCM_BLOCK, init_stage);
4675         bnx2x_init_block(bp, UCM_BLOCK, init_stage);
4676         bnx2x_init_block(bp, CCM_BLOCK, init_stage);
4677         bnx2x_init_block(bp, XCM_BLOCK, init_stage);
4678
4679         /* QM cid (connection) count */
4680         bnx2x_qm_init_cid_count(bp, bp->qm_cid_count, INITOP_SET);
4681
4682 #ifdef BCM_CNIC
4683         bnx2x_init_block(bp, TIMERS_BLOCK, init_stage);
4684         REG_WR(bp, TM_REG_LIN0_SCAN_TIME + port*4, 20);
4685         REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + port*4, 31);
4686 #endif
4687
4688         bnx2x_init_block(bp, DQ_BLOCK, init_stage);
4689
4690         bnx2x_init_block(bp, BRB1_BLOCK, init_stage);
4691         if (CHIP_REV_IS_SLOW(bp) && !CHIP_IS_E1H(bp)) {
4692                 /* no pause for emulation and FPGA */
4693                 low = 0;
4694                 high = 513;
4695         } else {
4696                 if (IS_MF(bp))
4697                         low = ((bp->flags & ONE_PORT_FLAG) ? 160 : 246);
4698                 else if (bp->dev->mtu > 4096) {
4699                         if (bp->flags & ONE_PORT_FLAG)
4700                                 low = 160;
4701                         else {
4702                                 val = bp->dev->mtu;
4703                                 /* (24*1024 + val*4)/256 */
4704                                 low = 96 + (val/64) + ((val % 64) ? 1 : 0);
4705                         }
4706                 } else
4707                         low = ((bp->flags & ONE_PORT_FLAG) ? 80 : 160);
4708                 high = low + 56;        /* 14*1024/256 */
4709         }
4710         REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_0 + port*4, low);
4711         REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_0 + port*4, high);
4712
4713
4714         bnx2x_init_block(bp, PRS_BLOCK, init_stage);
4715
4716         bnx2x_init_block(bp, TSDM_BLOCK, init_stage);
4717         bnx2x_init_block(bp, CSDM_BLOCK, init_stage);
4718         bnx2x_init_block(bp, USDM_BLOCK, init_stage);
4719         bnx2x_init_block(bp, XSDM_BLOCK, init_stage);
4720
4721         bnx2x_init_block(bp, TSEM_BLOCK, init_stage);
4722         bnx2x_init_block(bp, USEM_BLOCK, init_stage);
4723         bnx2x_init_block(bp, CSEM_BLOCK, init_stage);
4724         bnx2x_init_block(bp, XSEM_BLOCK, init_stage);
4725
4726         bnx2x_init_block(bp, UPB_BLOCK, init_stage);
4727         bnx2x_init_block(bp, XPB_BLOCK, init_stage);
4728
4729         bnx2x_init_block(bp, PBF_BLOCK, init_stage);
4730
4731         /* configure PBF to work without PAUSE mtu 9000 */
4732         REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
4733
4734         /* update threshold */
4735         REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, (9040/16));
4736         /* update init credit */
4737         REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, (9040/16) + 553 - 22);
4738
4739         /* probe changes */
4740         REG_WR(bp, PBF_REG_INIT_P0 + port*4, 1);
4741         msleep(5);
4742         REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0);
4743
4744 #ifdef BCM_CNIC
4745         bnx2x_init_block(bp, SRCH_BLOCK, init_stage);
4746 #endif
4747         bnx2x_init_block(bp, CDU_BLOCK, init_stage);
4748         bnx2x_init_block(bp, CFC_BLOCK, init_stage);
4749
4750         if (CHIP_IS_E1(bp)) {
4751                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
4752                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
4753         }
4754         bnx2x_init_block(bp, HC_BLOCK, init_stage);
4755
4756         bnx2x_init_block(bp, MISC_AEU_BLOCK, init_stage);
4757         /* init aeu_mask_attn_func_0/1:
4758          *  - SF mode: bits 3-7 are masked. only bits 0-2 are in use
4759          *  - MF mode: bit 3 is masked. bits 0-2 are in use as in SF
4760          *             bits 4-7 are used for "per vn group attention" */
4761         REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4,
4762                (IS_MF(bp) ? 0xF7 : 0x7));
4763
4764         bnx2x_init_block(bp, PXPCS_BLOCK, init_stage);
4765         bnx2x_init_block(bp, EMAC0_BLOCK, init_stage);
4766         bnx2x_init_block(bp, EMAC1_BLOCK, init_stage);
4767         bnx2x_init_block(bp, DBU_BLOCK, init_stage);
4768         bnx2x_init_block(bp, DBG_BLOCK, init_stage);
4769
4770         bnx2x_init_block(bp, NIG_BLOCK, init_stage);
4771
4772         REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
4773
4774         if (CHIP_IS_E1H(bp)) {
4775                 /* 0x2 disable mf_ov, 0x1 enable */
4776                 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK_MF + port*4,
4777                        (IS_MF(bp) ? 0x1 : 0x2));
4778
4779                 {
4780                         REG_WR(bp, NIG_REG_LLFC_ENABLE_0 + port*4, 0);
4781                         REG_WR(bp, NIG_REG_LLFC_OUT_EN_0 + port*4, 0);
4782                         REG_WR(bp, NIG_REG_PAUSE_ENABLE_0 + port*4, 1);
4783                 }
4784         }
4785
4786         bnx2x_init_block(bp, MCP_BLOCK, init_stage);
4787         bnx2x_init_block(bp, DMAE_BLOCK, init_stage);
4788         bp->port.need_hw_lock = bnx2x_hw_lock_required(bp,
4789                                                        bp->common.shmem_base,
4790                                                        bp->common.shmem2_base);
4791         if (bnx2x_fan_failure_det_req(bp, bp->common.shmem_base,
4792                                       bp->common.shmem2_base, port)) {
4793                 u32 reg_addr = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
4794                                        MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
4795                 val = REG_RD(bp, reg_addr);
4796                 val |= AEU_INPUTS_ATTN_BITS_SPIO5;
4797                 REG_WR(bp, reg_addr, val);
4798         }
4799         bnx2x__link_reset(bp);
4800
4801         return 0;
4802 }
4803
4804 static void bnx2x_ilt_wr(struct bnx2x *bp, u32 index, dma_addr_t addr)
4805 {
4806         int reg;
4807
4808         if (CHIP_IS_E1H(bp))
4809                 reg = PXP2_REG_RQ_ONCHIP_AT_B0 + index*8;
4810         else /* E1 */
4811                 reg = PXP2_REG_RQ_ONCHIP_AT + index*8;
4812
4813         bnx2x_wb_wr(bp, reg, ONCHIP_ADDR1(addr), ONCHIP_ADDR2(addr));
4814 }
4815
4816 static int bnx2x_init_hw_func(struct bnx2x *bp)
4817 {
4818         int port = BP_PORT(bp);
4819         int func = BP_FUNC(bp);
4820         struct bnx2x_ilt *ilt = BP_ILT(bp);
4821         u16 cdu_ilt_start;
4822         u32 addr, val;
4823         int i;
4824
4825         DP(BNX2X_MSG_MCP, "starting func init  func %d\n", func);
4826
4827         /* set MSI reconfigure capability */
4828         addr = (port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0);
4829         val = REG_RD(bp, addr);
4830         val |= HC_CONFIG_0_REG_MSI_ATTN_EN_0;
4831         REG_WR(bp, addr, val);
4832
4833         ilt = BP_ILT(bp);
4834         cdu_ilt_start = ilt->clients[ILT_CLIENT_CDU].start;
4835
4836         for (i = 0; i < L2_ILT_LINES(bp); i++) {
4837                 ilt->lines[cdu_ilt_start + i].page =
4838                         bp->context.vcxt + (ILT_PAGE_CIDS * i);
4839                 ilt->lines[cdu_ilt_start + i].page_mapping =
4840                         bp->context.cxt_mapping + (CDU_ILT_PAGE_SZ * i);
4841                 /* cdu ilt pages are allocated manually so there's no need to
4842                 set the size */
4843         }
4844         bnx2x_ilt_init_op(bp, INITOP_SET);
4845 #ifdef BCM_CNIC
4846         bnx2x_src_init_t2(bp, bp->t2, bp->t2_mapping, SRC_CONN_NUM);
4847
4848         /* T1 hash bits value determines the T1 number of entries */
4849         REG_WR(bp, SRC_REG_NUMBER_HASH_BITS0 + port*4, SRC_HASH_BITS);
4850 #endif
4851
4852 #ifndef BCM_CNIC
4853         /* set NIC mode */
4854         REG_WR(bp, PRS_REG_NIC_MODE, 1);
4855 #endif  /* BCM_CNIC */
4856
4857         bp->dmae_ready = 1;
4858
4859         bnx2x_init_block(bp, PGLUE_B_BLOCK, FUNC0_STAGE + func);
4860
4861         bnx2x_init_block(bp, MISC_BLOCK, FUNC0_STAGE + func);
4862         bnx2x_init_block(bp, TCM_BLOCK, FUNC0_STAGE + func);
4863         bnx2x_init_block(bp, UCM_BLOCK, FUNC0_STAGE + func);
4864         bnx2x_init_block(bp, CCM_BLOCK, FUNC0_STAGE + func);
4865         bnx2x_init_block(bp, XCM_BLOCK, FUNC0_STAGE + func);
4866         bnx2x_init_block(bp, TSEM_BLOCK, FUNC0_STAGE + func);
4867         bnx2x_init_block(bp, USEM_BLOCK, FUNC0_STAGE + func);
4868         bnx2x_init_block(bp, CSEM_BLOCK, FUNC0_STAGE + func);
4869         bnx2x_init_block(bp, XSEM_BLOCK, FUNC0_STAGE + func);
4870
4871         bnx2x_init_block(bp, QM_BLOCK, FUNC0_STAGE + func);
4872         bnx2x_init_block(bp, TIMERS_BLOCK, FUNC0_STAGE + func);
4873         bnx2x_init_block(bp, DQ_BLOCK, FUNC0_STAGE + func);
4874         bnx2x_init_block(bp, BRB1_BLOCK, FUNC0_STAGE + func);
4875         bnx2x_init_block(bp, PRS_BLOCK, FUNC0_STAGE + func);
4876         bnx2x_init_block(bp, TSDM_BLOCK, FUNC0_STAGE + func);
4877         bnx2x_init_block(bp, CSDM_BLOCK, FUNC0_STAGE + func);
4878         bnx2x_init_block(bp, USDM_BLOCK, FUNC0_STAGE + func);
4879         bnx2x_init_block(bp, XSDM_BLOCK, FUNC0_STAGE + func);
4880         bnx2x_init_block(bp, UPB_BLOCK, FUNC0_STAGE + func);
4881         bnx2x_init_block(bp, XPB_BLOCK, FUNC0_STAGE + func);
4882         bnx2x_init_block(bp, PBF_BLOCK, FUNC0_STAGE + func);
4883         bnx2x_init_block(bp, CDU_BLOCK, FUNC0_STAGE + func);
4884
4885         bnx2x_init_block(bp, CFC_BLOCK, FUNC0_STAGE + func);
4886
4887         if (IS_MF(bp)) {
4888                 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
4889                 REG_WR(bp, NIG_REG_LLH0_FUNC_VLAN_ID + port*8, bp->mf_ov);
4890         }
4891
4892         bnx2x_init_block(bp, MISC_AEU_BLOCK, FUNC0_STAGE + func);
4893
4894         /* HC init per function */
4895         if (CHIP_IS_E1H(bp)) {
4896                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
4897
4898                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
4899                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
4900         }
4901         bnx2x_init_block(bp, HC_BLOCK, FUNC0_STAGE + func);
4902
4903         /* Reset PCIE errors for debug */
4904         REG_WR(bp, 0x2114, 0xffffffff);
4905         REG_WR(bp, 0x2120, 0xffffffff);
4906
4907         bnx2x_init_block(bp, EMAC0_BLOCK, FUNC0_STAGE + func);
4908         bnx2x_init_block(bp, EMAC1_BLOCK, FUNC0_STAGE + func);
4909         bnx2x_init_block(bp, DBU_BLOCK, FUNC0_STAGE + func);
4910         bnx2x_init_block(bp, DBG_BLOCK, FUNC0_STAGE + func);
4911         bnx2x_init_block(bp, MCP_BLOCK, FUNC0_STAGE + func);
4912         bnx2x_init_block(bp, DMAE_BLOCK, FUNC0_STAGE + func);
4913
4914         bnx2x_phy_probe(&bp->link_params);
4915         return 0;
4916 }
4917
4918 int bnx2x_init_hw(struct bnx2x *bp, u32 load_code)
4919 {
4920         int rc = 0;
4921
4922         DP(BNX2X_MSG_MCP, "function %d  load_code %x\n",
4923            BP_FUNC(bp), load_code);
4924
4925         bp->dmae_ready = 0;
4926         mutex_init(&bp->dmae_mutex);
4927         rc = bnx2x_gunzip_init(bp);
4928         if (rc)
4929                 return rc;
4930
4931         switch (load_code) {
4932         case FW_MSG_CODE_DRV_LOAD_COMMON:
4933                 rc = bnx2x_init_hw_common(bp, load_code);
4934                 if (rc)
4935                         goto init_hw_err;
4936                 /* no break */
4937
4938         case FW_MSG_CODE_DRV_LOAD_PORT:
4939                 rc = bnx2x_init_hw_port(bp);
4940                 if (rc)
4941                         goto init_hw_err;
4942                 /* no break */
4943
4944         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
4945                 rc = bnx2x_init_hw_func(bp);
4946                 if (rc)
4947                         goto init_hw_err;
4948                 break;
4949
4950         default:
4951                 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
4952                 break;
4953         }
4954
4955         if (!BP_NOMCP(bp)) {
4956                 int func = BP_FUNC(bp);
4957
4958                 bp->fw_drv_pulse_wr_seq =
4959                                 (SHMEM_RD(bp, func_mb[func].drv_pulse_mb) &
4960                                  DRV_PULSE_SEQ_MASK);
4961                 DP(BNX2X_MSG_MCP, "drv_pulse 0x%x\n", bp->fw_drv_pulse_wr_seq);
4962         }
4963
4964 init_hw_err:
4965         bnx2x_gunzip_end(bp);
4966
4967         return rc;
4968 }
4969
4970 void bnx2x_free_mem(struct bnx2x *bp)
4971 {
4972
4973 #define BNX2X_PCI_FREE(x, y, size) \
4974         do { \
4975                 if (x) { \
4976                         dma_free_coherent(&bp->pdev->dev, size, (void *)x, y); \
4977                         x = NULL; \
4978                         y = 0; \
4979                 } \
4980         } while (0)
4981
4982 #define BNX2X_FREE(x) \
4983         do { \
4984                 if (x) { \
4985                         kfree((void *)x); \
4986                         x = NULL; \
4987                 } \
4988         } while (0)
4989
4990         int i;
4991
4992         /* fastpath */
4993         /* Common */
4994         for_each_queue(bp, i) {
4995                 /* status blocks */
4996                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, status_blk.e1x_sb),
4997                                bnx2x_fp(bp, i, status_blk_mapping),
4998                                sizeof(struct host_hc_status_block_e1x));
4999         }
5000         /* Rx */
5001         for_each_queue(bp, i) {
5002
5003                 /* fastpath rx rings: rx_buf rx_desc rx_comp */
5004                 BNX2X_FREE(bnx2x_fp(bp, i, rx_buf_ring));
5005                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_desc_ring),
5006                                bnx2x_fp(bp, i, rx_desc_mapping),
5007                                sizeof(struct eth_rx_bd) * NUM_RX_BD);
5008
5009                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_comp_ring),
5010                                bnx2x_fp(bp, i, rx_comp_mapping),
5011                                sizeof(struct eth_fast_path_rx_cqe) *
5012                                NUM_RCQ_BD);
5013
5014                 /* SGE ring */
5015                 BNX2X_FREE(bnx2x_fp(bp, i, rx_page_ring));
5016                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_sge_ring),
5017                                bnx2x_fp(bp, i, rx_sge_mapping),
5018                                BCM_PAGE_SIZE * NUM_RX_SGE_PAGES);
5019         }
5020         /* Tx */
5021         for_each_queue(bp, i) {
5022
5023                 /* fastpath tx rings: tx_buf tx_desc */
5024                 BNX2X_FREE(bnx2x_fp(bp, i, tx_buf_ring));
5025                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, tx_desc_ring),
5026                                bnx2x_fp(bp, i, tx_desc_mapping),
5027                                sizeof(union eth_tx_bd_types) * NUM_TX_BD);
5028         }
5029         /* end of fastpath */
5030
5031         BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
5032                        sizeof(struct host_sp_status_block));
5033
5034         BNX2X_PCI_FREE(bp->slowpath, bp->slowpath_mapping,
5035                        sizeof(struct bnx2x_slowpath));
5036
5037         BNX2X_PCI_FREE(bp->context.vcxt, bp->context.cxt_mapping,
5038                        bp->context.size);
5039
5040         bnx2x_ilt_mem_op(bp, ILT_MEMOP_FREE);
5041
5042         BNX2X_FREE(bp->ilt->lines);
5043 #ifdef BCM_CNIC
5044
5045         BNX2X_PCI_FREE(bp->cnic_sb.e1x_sb, bp->cnic_sb_mapping,
5046                        sizeof(struct host_hc_status_block_e1x));
5047         BNX2X_PCI_FREE(bp->t2, bp->t2_mapping, SRC_T2_SZ);
5048 #endif
5049         BNX2X_PCI_FREE(bp->spq, bp->spq_mapping, BCM_PAGE_SIZE);
5050
5051         BNX2X_PCI_FREE(bp->eq_ring, bp->eq_mapping,
5052                        BCM_PAGE_SIZE * NUM_EQ_PAGES);
5053
5054 #undef BNX2X_PCI_FREE
5055 #undef BNX2X_KFREE
5056 }
5057
5058 int bnx2x_alloc_mem(struct bnx2x *bp)
5059 {
5060
5061 #define BNX2X_PCI_ALLOC(x, y, size) \
5062         do { \
5063                 x = dma_alloc_coherent(&bp->pdev->dev, size, y, GFP_KERNEL); \
5064                 if (x == NULL) \
5065                         goto alloc_mem_err; \
5066                 memset(x, 0, size); \
5067         } while (0)
5068
5069 #define BNX2X_ALLOC(x, size) \
5070         do { \
5071                 x = kzalloc(size, GFP_KERNEL); \
5072                 if (x == NULL) \
5073                         goto alloc_mem_err; \
5074         } while (0)
5075
5076         int i;
5077         void *p;
5078
5079         /* fastpath */
5080         /* Common */
5081         for_each_queue(bp, i) {
5082                 bnx2x_fp(bp, i, bp) = bp;
5083
5084                 /* status blocks */
5085                 BNX2X_PCI_ALLOC(p,
5086                                 &bnx2x_fp(bp, i, status_blk_mapping),
5087                                 sizeof(struct host_hc_status_block_e1x));
5088
5089                 bnx2x_fp(bp, i, status_blk.e1x_sb) =
5090                                 (struct host_hc_status_block_e1x *)p;
5091
5092                 bnx2x_fp(bp, i, sb_index_values) = (__le16 *)
5093                         (bnx2x_fp(bp, i, status_blk.e1x_sb)->sb.index_values);
5094                 bnx2x_fp(bp, i, sb_running_index) = (__le16 *)
5095                         (bnx2x_fp(bp, i, status_blk.e1x_sb)->sb.running_index);
5096         }
5097         /* Rx */
5098         for_each_queue(bp, i) {
5099
5100                 /* fastpath rx rings: rx_buf rx_desc rx_comp */
5101                 BNX2X_ALLOC(bnx2x_fp(bp, i, rx_buf_ring),
5102                                 sizeof(struct sw_rx_bd) * NUM_RX_BD);
5103                 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_desc_ring),
5104                                 &bnx2x_fp(bp, i, rx_desc_mapping),
5105                                 sizeof(struct eth_rx_bd) * NUM_RX_BD);
5106
5107                 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_comp_ring),
5108                                 &bnx2x_fp(bp, i, rx_comp_mapping),
5109                                 sizeof(struct eth_fast_path_rx_cqe) *
5110                                 NUM_RCQ_BD);
5111
5112                 /* SGE ring */
5113                 BNX2X_ALLOC(bnx2x_fp(bp, i, rx_page_ring),
5114                                 sizeof(struct sw_rx_page) * NUM_RX_SGE);
5115                 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_sge_ring),
5116                                 &bnx2x_fp(bp, i, rx_sge_mapping),
5117                                 BCM_PAGE_SIZE * NUM_RX_SGE_PAGES);
5118         }
5119         /* Tx */
5120         for_each_queue(bp, i) {
5121
5122                 /* fastpath tx rings: tx_buf tx_desc */
5123                 BNX2X_ALLOC(bnx2x_fp(bp, i, tx_buf_ring),
5124                                 sizeof(struct sw_tx_bd) * NUM_TX_BD);
5125                 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, tx_desc_ring),
5126                                 &bnx2x_fp(bp, i, tx_desc_mapping),
5127                                 sizeof(union eth_tx_bd_types) * NUM_TX_BD);
5128         }
5129         /* end of fastpath */
5130
5131 #ifdef BCM_CNIC
5132         BNX2X_PCI_ALLOC(bp->cnic_sb.e1x_sb, &bp->cnic_sb_mapping,
5133                         sizeof(struct host_hc_status_block_e1x));
5134
5135         /* allocate searcher T2 table */
5136         BNX2X_PCI_ALLOC(bp->t2, &bp->t2_mapping, SRC_T2_SZ);
5137 #endif
5138
5139
5140         BNX2X_PCI_ALLOC(bp->def_status_blk, &bp->def_status_blk_mapping,
5141                         sizeof(struct host_sp_status_block));
5142
5143         BNX2X_PCI_ALLOC(bp->slowpath, &bp->slowpath_mapping,
5144                         sizeof(struct bnx2x_slowpath));
5145
5146         bp->context.size = sizeof(union cdu_context) * bp->l2_cid_count;
5147         BNX2X_PCI_ALLOC(bp->context.vcxt, &bp->context.cxt_mapping,
5148                         bp->context.size);
5149
5150         BNX2X_ALLOC(bp->ilt->lines, sizeof(struct ilt_line) * ILT_MAX_LINES);
5151
5152         if (bnx2x_ilt_mem_op(bp, ILT_MEMOP_ALLOC))
5153                 goto alloc_mem_err;
5154
5155         /* Slow path ring */
5156         BNX2X_PCI_ALLOC(bp->spq, &bp->spq_mapping, BCM_PAGE_SIZE);
5157
5158         /* EQ */
5159         BNX2X_PCI_ALLOC(bp->eq_ring, &bp->eq_mapping,
5160                         BCM_PAGE_SIZE * NUM_EQ_PAGES);
5161         return 0;
5162
5163 alloc_mem_err:
5164         bnx2x_free_mem(bp);
5165         return -ENOMEM;
5166
5167 #undef BNX2X_PCI_ALLOC
5168 #undef BNX2X_ALLOC
5169 }
5170
5171 /*
5172  * Init service functions
5173  */
5174 int bnx2x_func_start(struct bnx2x *bp)
5175 {
5176         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_START, 0, 0, 0, 1);
5177
5178         /* Wait for completion */
5179         return bnx2x_wait_ramrod(bp, BNX2X_STATE_FUNC_STARTED, 0, &(bp->state),
5180                                  WAIT_RAMROD_COMMON);
5181 }
5182
5183 int bnx2x_func_stop(struct bnx2x *bp)
5184 {
5185         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_STOP, 0, 0, 0, 1);
5186
5187         /* Wait for completion */
5188         return bnx2x_wait_ramrod(bp, BNX2X_STATE_CLOSING_WAIT4_UNLOAD,
5189                                       0, &(bp->state), WAIT_RAMROD_COMMON);
5190 }
5191
5192 /**
5193  * Sets a MAC in a CAM for a few L2 Clients for E1x chip
5194  *
5195  * @param bp driver descriptor
5196  * @param set set or clear an entry (1 or 0)
5197  * @param mac pointer to a buffer containing a MAC
5198  * @param cl_bit_vec bit vector of clients to register a MAC for
5199  * @param cam_offset offset in a CAM to use
5200  * @param is_bcast is the set MAC a broadcast address (for E1 only)
5201  */
5202 static void bnx2x_set_mac_addr_gen(struct bnx2x *bp, int set, u8 *mac,
5203                                       u32 cl_bit_vec, u8 cam_offset,
5204                                       u8 is_bcast)
5205 {
5206         struct mac_configuration_cmd *config =
5207                 (struct mac_configuration_cmd *)bnx2x_sp(bp, mac_config);
5208         int ramrod_flags = WAIT_RAMROD_COMMON;
5209
5210         bp->set_mac_pending = 1;
5211         smp_wmb();
5212
5213         config->hdr.length = 1 + (is_bcast ? 1 : 0);
5214         config->hdr.offset = cam_offset;
5215         config->hdr.client_id = 0xff;
5216         config->hdr.reserved1 = 0;
5217
5218         config->hdr.length = 1;
5219         config->hdr.offset = cam_offset;
5220         config->hdr.client_id = 0xff;
5221         config->hdr.reserved1 = 0;
5222
5223         /* primary MAC */
5224         config->config_table[0].msb_mac_addr =
5225                                         swab16(*(u16 *)&mac[0]);
5226         config->config_table[0].middle_mac_addr =
5227                                         swab16(*(u16 *)&mac[2]);
5228         config->config_table[0].lsb_mac_addr =
5229                                         swab16(*(u16 *)&mac[4]);
5230         config->config_table[0].clients_bit_vector =
5231                                         cpu_to_le32(cl_bit_vec);
5232         config->config_table[0].vlan_id = 0;
5233         config->config_table[0].pf_id = BP_FUNC(bp);
5234         if (set)
5235                 SET_FLAG(config->config_table[0].flags,
5236                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
5237                         T_ETH_MAC_COMMAND_SET);
5238         else
5239                 SET_FLAG(config->config_table[0].flags,
5240                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
5241                         T_ETH_MAC_COMMAND_INVALIDATE);
5242
5243         if (is_bcast)
5244                 SET_FLAG(config->config_table[0].flags,
5245                         MAC_CONFIGURATION_ENTRY_BROADCAST, 1);
5246
5247         DP(NETIF_MSG_IFUP, "%s MAC (%04x:%04x:%04x)  PF_ID %d  CLID mask %d\n",
5248            (set ? "setting" : "clearing"),
5249            config->config_table[0].msb_mac_addr,
5250            config->config_table[0].middle_mac_addr,
5251            config->config_table[0].lsb_mac_addr, BP_FUNC(bp), cl_bit_vec);
5252
5253         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
5254                       U64_HI(bnx2x_sp_mapping(bp, mac_config)),
5255                       U64_LO(bnx2x_sp_mapping(bp, mac_config)), 1);
5256
5257         /* Wait for a completion */
5258         bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending, ramrod_flags);
5259 }
5260
5261
5262 int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
5263                              int *state_p, int flags)
5264 {
5265         /* can take a while if any port is running */
5266         int cnt = 5000;
5267         u8 poll = flags & WAIT_RAMROD_POLL;
5268         u8 common = flags & WAIT_RAMROD_COMMON;
5269
5270         DP(NETIF_MSG_IFUP, "%s for state to become %x on IDX [%d]\n",
5271            poll ? "polling" : "waiting", state, idx);
5272
5273         might_sleep();
5274         while (cnt--) {
5275                 if (poll) {
5276                         if (common)
5277                                 bnx2x_eq_int(bp);
5278                         else {
5279                                 bnx2x_rx_int(bp->fp, 10);
5280                                 /* if index is different from 0
5281                                  * the reply for some commands will
5282                                  * be on the non default queue
5283                                  */
5284                                 if (idx)
5285                                         bnx2x_rx_int(&bp->fp[idx], 10);
5286                         }
5287                 }
5288
5289                 mb(); /* state is changed by bnx2x_sp_event() */
5290                 if (*state_p == state) {
5291 #ifdef BNX2X_STOP_ON_ERROR
5292                         DP(NETIF_MSG_IFUP, "exit  (cnt %d)\n", 5000 - cnt);
5293 #endif
5294                         return 0;
5295                 }
5296
5297                 msleep(1);
5298
5299                 if (bp->panic)
5300                         return -EIO;
5301         }
5302
5303         /* timeout! */
5304         BNX2X_ERR("timeout %s for state %x on IDX [%d]\n",
5305                   poll ? "polling" : "waiting", state, idx);
5306 #ifdef BNX2X_STOP_ON_ERROR
5307         bnx2x_panic();
5308 #endif
5309
5310         return -EBUSY;
5311 }
5312
5313 u8 bnx2x_e1h_cam_offset(struct bnx2x *bp, u8 rel_offset)
5314 {
5315         return E1H_FUNC_MAX * rel_offset + BP_FUNC(bp);
5316 }
5317
5318 void bnx2x_set_eth_mac(struct bnx2x *bp, int set)
5319 {
5320         u8 cam_offset = (CHIP_IS_E1(bp) ? (BP_PORT(bp) ? 32 : 0) :
5321                          bnx2x_e1h_cam_offset(bp, CAM_ETH_LINE));
5322
5323         /* networking  MAC */
5324         bnx2x_set_mac_addr_gen(bp, set, bp->dev->dev_addr,
5325                                (1 << bp->fp->cl_id), cam_offset , 0);
5326
5327         if (CHIP_IS_E1(bp)) {
5328                 /* broadcast MAC */
5329                 u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
5330                 bnx2x_set_mac_addr_gen(bp, set, bcast, 0, cam_offset + 1, 1);
5331         }
5332 }
5333 static void bnx2x_set_e1_mc_list(struct bnx2x *bp, u8 offset)
5334 {
5335         int i = 0, old;
5336         struct net_device *dev = bp->dev;
5337         struct netdev_hw_addr *ha;
5338         struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, mcast_config);
5339         dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, mcast_config);
5340
5341         netdev_for_each_mc_addr(ha, dev) {
5342                 /* copy mac */
5343                 config_cmd->config_table[i].msb_mac_addr =
5344                         swab16(*(u16 *)&bnx2x_mc_addr(ha)[0]);
5345                 config_cmd->config_table[i].middle_mac_addr =
5346                         swab16(*(u16 *)&bnx2x_mc_addr(ha)[2]);
5347                 config_cmd->config_table[i].lsb_mac_addr =
5348                         swab16(*(u16 *)&bnx2x_mc_addr(ha)[4]);
5349
5350                 config_cmd->config_table[i].vlan_id = 0;
5351                 config_cmd->config_table[i].pf_id = BP_FUNC(bp);
5352                 config_cmd->config_table[i].clients_bit_vector =
5353                         cpu_to_le32(1 << BP_L_ID(bp));
5354
5355                 SET_FLAG(config_cmd->config_table[i].flags,
5356                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
5357                         T_ETH_MAC_COMMAND_SET);
5358
5359                 DP(NETIF_MSG_IFUP,
5360                    "setting MCAST[%d] (%04x:%04x:%04x)\n", i,
5361                    config_cmd->config_table[i].msb_mac_addr,
5362                    config_cmd->config_table[i].middle_mac_addr,
5363                    config_cmd->config_table[i].lsb_mac_addr);
5364                 i++;
5365         }
5366         old = config_cmd->hdr.length;
5367         if (old > i) {
5368                 for (; i < old; i++) {
5369                         if (CAM_IS_INVALID(config_cmd->
5370                                            config_table[i])) {
5371                                 /* already invalidated */
5372                                 break;
5373                         }
5374                         /* invalidate */
5375                         SET_FLAG(config_cmd->config_table[i].flags,
5376                                 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
5377                                 T_ETH_MAC_COMMAND_INVALIDATE);
5378                 }
5379         }
5380
5381         config_cmd->hdr.length = i;
5382         config_cmd->hdr.offset = offset;
5383         config_cmd->hdr.client_id = 0xff;
5384         config_cmd->hdr.reserved1 = 0;
5385
5386         bp->set_mac_pending = 1;
5387         smp_wmb();
5388
5389         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
5390                    U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
5391 }
5392 static void bnx2x_invlidate_e1_mc_list(struct bnx2x *bp)
5393 {
5394         int i;
5395         struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, mcast_config);
5396         dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, mcast_config);
5397         int ramrod_flags = WAIT_RAMROD_COMMON;
5398
5399         bp->set_mac_pending = 1;
5400         smp_wmb();
5401
5402         for (i = 0; i < config_cmd->hdr.length; i++)
5403                 SET_FLAG(config_cmd->config_table[i].flags,
5404                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
5405                         T_ETH_MAC_COMMAND_INVALIDATE);
5406
5407         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
5408                       U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
5409
5410         /* Wait for a completion */
5411         bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending,
5412                                 ramrod_flags);
5413
5414 }
5415
5416
5417 #ifdef BCM_CNIC
5418 /**
5419  * Set iSCSI MAC(s) at the next enties in the CAM after the ETH
5420  * MAC(s). This function will wait until the ramdord completion
5421  * returns.
5422  *
5423  * @param bp driver handle
5424  * @param set set or clear the CAM entry
5425  *
5426  * @return 0 if cussess, -ENODEV if ramrod doesn't return.
5427  */
5428 int bnx2x_set_iscsi_eth_mac_addr(struct bnx2x *bp, int set)
5429 {
5430         u8 cam_offset = (CHIP_IS_E1(bp) ? ((BP_PORT(bp) ? 32 : 0) + 2) :
5431                          bnx2x_e1h_cam_offset(bp, CAM_ISCSI_ETH_LINE));
5432         u32 iscsi_l2_cl_id = BNX2X_ISCSI_ETH_CL_ID;
5433         u32 cl_bit_vec = (1 << iscsi_l2_cl_id);
5434
5435         /* Send a SET_MAC ramrod */
5436         bnx2x_set_mac_addr_gen(bp, set, bp->iscsi_mac, cl_bit_vec,
5437                                cam_offset, 0);
5438         return 0;
5439 }
5440 #endif
5441
5442 static void bnx2x_fill_cl_init_data(struct bnx2x *bp,
5443                                     struct bnx2x_client_init_params *params,
5444                                     u8 activate,
5445                                     struct client_init_ramrod_data *data)
5446 {
5447         /* Clear the buffer */
5448         memset(data, 0, sizeof(*data));
5449
5450         /* general */
5451         data->general.client_id = params->rxq_params.cl_id;
5452         data->general.statistics_counter_id = params->rxq_params.stat_id;
5453         data->general.statistics_en_flg =
5454                 (params->rxq_params.flags & QUEUE_FLG_STATS) ? 1 : 0;
5455         data->general.activate_flg = activate;
5456         data->general.sp_client_id = params->rxq_params.spcl_id;
5457
5458         /* Rx data */
5459         data->rx.tpa_en_flg =
5460                 (params->rxq_params.flags & QUEUE_FLG_TPA) ? 1 : 0;
5461         data->rx.vmqueue_mode_en_flg = 0;
5462         data->rx.cache_line_alignment_log_size =
5463                 params->rxq_params.cache_line_log;
5464         data->rx.enable_dynamic_hc =
5465                 (params->rxq_params.flags & QUEUE_FLG_DHC) ? 1 : 0;
5466         data->rx.max_sges_for_packet = params->rxq_params.max_sges_pkt;
5467         data->rx.client_qzone_id = params->rxq_params.cl_qzone_id;
5468         data->rx.max_agg_size = params->rxq_params.tpa_agg_sz;
5469
5470         /* We don't set drop flags */
5471         data->rx.drop_ip_cs_err_flg = 0;
5472         data->rx.drop_tcp_cs_err_flg = 0;
5473         data->rx.drop_ttl0_flg = 0;
5474         data->rx.drop_udp_cs_err_flg = 0;
5475
5476         data->rx.inner_vlan_removal_enable_flg =
5477                 (params->rxq_params.flags & QUEUE_FLG_VLAN) ? 1 : 0;
5478         data->rx.outer_vlan_removal_enable_flg =
5479                 (params->rxq_params.flags & QUEUE_FLG_OV) ? 1 : 0;
5480         data->rx.status_block_id = params->rxq_params.fw_sb_id;
5481         data->rx.rx_sb_index_number = params->rxq_params.sb_cq_index;
5482         data->rx.bd_buff_size = cpu_to_le16(params->rxq_params.buf_sz);
5483         data->rx.sge_buff_size = cpu_to_le16(params->rxq_params.sge_buf_sz);
5484         data->rx.mtu = cpu_to_le16(params->rxq_params.mtu);
5485         data->rx.bd_page_base.lo =
5486                 cpu_to_le32(U64_LO(params->rxq_params.dscr_map));
5487         data->rx.bd_page_base.hi =
5488                 cpu_to_le32(U64_HI(params->rxq_params.dscr_map));
5489         data->rx.sge_page_base.lo =
5490                 cpu_to_le32(U64_LO(params->rxq_params.sge_map));
5491         data->rx.sge_page_base.hi =
5492                 cpu_to_le32(U64_HI(params->rxq_params.sge_map));
5493         data->rx.cqe_page_base.lo =
5494                 cpu_to_le32(U64_LO(params->rxq_params.rcq_map));
5495         data->rx.cqe_page_base.hi =
5496                 cpu_to_le32(U64_HI(params->rxq_params.rcq_map));
5497         data->rx.is_leading_rss =
5498                 (params->ramrod_params.flags & CLIENT_IS_LEADING_RSS) ? 1 : 0;
5499         data->rx.is_approx_mcast = data->rx.is_leading_rss;
5500
5501         /* Tx data */
5502         data->tx.enforce_security_flg = 0; /* VF specific */
5503         data->tx.tx_status_block_id = params->txq_params.fw_sb_id;
5504         data->tx.tx_sb_index_number = params->txq_params.sb_cq_index;
5505         data->tx.mtu = 0; /* VF specific */
5506         data->tx.tx_bd_page_base.lo =
5507                 cpu_to_le32(U64_LO(params->txq_params.dscr_map));
5508         data->tx.tx_bd_page_base.hi =
5509                 cpu_to_le32(U64_HI(params->txq_params.dscr_map));
5510
5511         /* flow control data */
5512         data->fc.cqe_pause_thr_low = cpu_to_le16(params->pause.rcq_th_lo);
5513         data->fc.cqe_pause_thr_high = cpu_to_le16(params->pause.rcq_th_hi);
5514         data->fc.bd_pause_thr_low = cpu_to_le16(params->pause.bd_th_lo);
5515         data->fc.bd_pause_thr_high = cpu_to_le16(params->pause.bd_th_hi);
5516         data->fc.sge_pause_thr_low = cpu_to_le16(params->pause.sge_th_lo);
5517         data->fc.sge_pause_thr_high = cpu_to_le16(params->pause.sge_th_hi);
5518         data->fc.rx_cos_mask = cpu_to_le16(params->pause.pri_map);
5519
5520         data->fc.safc_group_num = params->txq_params.cos;
5521         data->fc.safc_group_en_flg =
5522                 (params->txq_params.flags & QUEUE_FLG_COS) ? 1 : 0;
5523         data->fc.traffic_type = LLFC_TRAFFIC_TYPE_NW;
5524 }
5525
5526 static inline void bnx2x_set_ctx_validation(struct eth_context *cxt, u32 cid)
5527 {
5528         /* ustorm cxt validation */
5529         cxt->ustorm_ag_context.cdu_usage =
5530                 CDU_RSRVD_VALUE_TYPE_A(cid, CDU_REGION_NUMBER_UCM_AG,
5531                                        ETH_CONNECTION_TYPE);
5532         /* xcontext validation */
5533         cxt->xstorm_ag_context.cdu_reserved =
5534                 CDU_RSRVD_VALUE_TYPE_A(cid, CDU_REGION_NUMBER_XCM_AG,
5535                                        ETH_CONNECTION_TYPE);
5536 }
5537
5538 int bnx2x_setup_fw_client(struct bnx2x *bp,
5539                           struct bnx2x_client_init_params *params,
5540                           u8 activate,
5541                           struct client_init_ramrod_data *data,
5542                           dma_addr_t data_mapping)
5543 {
5544         u16 hc_usec;
5545         int ramrod = RAMROD_CMD_ID_ETH_CLIENT_SETUP;
5546         int ramrod_flags = 0, rc;
5547
5548         /* HC and context validation values */
5549         hc_usec = params->txq_params.hc_rate ?
5550                 1000000 / params->txq_params.hc_rate : 0;
5551         bnx2x_update_coalesce_sb_index(bp,
5552                         params->txq_params.fw_sb_id,
5553                         params->txq_params.sb_cq_index,
5554                         !(params->txq_params.flags & QUEUE_FLG_HC),
5555                         hc_usec);
5556
5557         *(params->ramrod_params.pstate) = BNX2X_FP_STATE_OPENING;
5558
5559         hc_usec = params->rxq_params.hc_rate ?
5560                 1000000 / params->rxq_params.hc_rate : 0;
5561         bnx2x_update_coalesce_sb_index(bp,
5562                         params->rxq_params.fw_sb_id,
5563                         params->rxq_params.sb_cq_index,
5564                         !(params->rxq_params.flags & QUEUE_FLG_HC),
5565                         hc_usec);
5566
5567         bnx2x_set_ctx_validation(params->rxq_params.cxt,
5568                                  params->rxq_params.cid);
5569
5570         /* zero stats */
5571         if (params->txq_params.flags & QUEUE_FLG_STATS)
5572                 storm_memset_xstats_zero(bp, BP_PORT(bp),
5573                                          params->txq_params.stat_id);
5574
5575         if (params->rxq_params.flags & QUEUE_FLG_STATS) {
5576                 storm_memset_ustats_zero(bp, BP_PORT(bp),
5577                                          params->rxq_params.stat_id);
5578                 storm_memset_tstats_zero(bp, BP_PORT(bp),
5579                                          params->rxq_params.stat_id);
5580         }
5581
5582         /* Fill the ramrod data */
5583         bnx2x_fill_cl_init_data(bp, params, activate, data);
5584
5585         /* SETUP ramrod.
5586          *
5587          * bnx2x_sp_post() takes a spin_lock thus no other explict memory
5588          * barrier except from mmiowb() is needed to impose a
5589          * proper ordering of memory operations.
5590          */
5591         mmiowb();
5592
5593
5594         bnx2x_sp_post(bp, ramrod, params->ramrod_params.cid,
5595                       U64_HI(data_mapping), U64_LO(data_mapping), 0);
5596
5597         /* Wait for completion */
5598         rc = bnx2x_wait_ramrod(bp, params->ramrod_params.state,
5599                                  params->ramrod_params.index,
5600                                  params->ramrod_params.pstate,
5601                                  ramrod_flags);
5602         return rc;
5603 }
5604
5605 void bnx2x_set_num_queues_msix(struct bnx2x *bp)
5606 {
5607
5608         switch (bp->multi_mode) {
5609         case ETH_RSS_MODE_DISABLED:
5610                 bp->num_queues = 1;
5611                 break;
5612
5613         case ETH_RSS_MODE_REGULAR:
5614                 if (num_queues)
5615                         bp->num_queues = min_t(u32, num_queues,
5616                                                   BNX2X_MAX_QUEUES(bp));
5617                 else
5618                         bp->num_queues = min_t(u32, num_online_cpus(),
5619                                                   BNX2X_MAX_QUEUES(bp));
5620                 break;
5621
5622
5623         default:
5624                 bp->num_queues = 1;
5625                 break;
5626         }
5627 }
5628
5629 void bnx2x_ilt_set_info(struct bnx2x *bp)
5630 {
5631         struct ilt_client_info *ilt_client;
5632         struct bnx2x_ilt *ilt = BP_ILT(bp);
5633         u16 line = 0;
5634
5635         ilt->start_line = FUNC_ILT_BASE(BP_FUNC(bp));
5636         DP(BNX2X_MSG_SP, "ilt starts at line %d\n", ilt->start_line);
5637
5638         /* CDU */
5639         ilt_client = &ilt->clients[ILT_CLIENT_CDU];
5640         ilt_client->client_num = ILT_CLIENT_CDU;
5641         ilt_client->page_size = CDU_ILT_PAGE_SZ;
5642         ilt_client->flags = ILT_CLIENT_SKIP_MEM;
5643         ilt_client->start = line;
5644         line += L2_ILT_LINES(bp);
5645 #ifdef BCM_CNIC
5646         line += CNIC_ILT_LINES;
5647 #endif
5648         ilt_client->end = line - 1;
5649
5650         DP(BNX2X_MSG_SP, "ilt client[CDU]: start %d, end %d, psz 0x%x, "
5651                                          "flags 0x%x, hw psz %d\n",
5652            ilt_client->start,
5653            ilt_client->end,
5654            ilt_client->page_size,
5655            ilt_client->flags,
5656            ilog2(ilt_client->page_size >> 12));
5657
5658         /* QM */
5659         if (QM_INIT(bp->qm_cid_count)) {
5660                 ilt_client = &ilt->clients[ILT_CLIENT_QM];
5661                 ilt_client->client_num = ILT_CLIENT_QM;
5662                 ilt_client->page_size = QM_ILT_PAGE_SZ;
5663                 ilt_client->flags = 0;
5664                 ilt_client->start = line;
5665
5666                 /* 4 bytes for each cid */
5667                 line += DIV_ROUND_UP(bp->qm_cid_count * QM_QUEUES_PER_FUNC * 4,
5668                                                          QM_ILT_PAGE_SZ);
5669
5670                 ilt_client->end = line - 1;
5671
5672                 DP(BNX2X_MSG_SP, "ilt client[QM]: start %d, end %d, psz 0x%x, "
5673                                                  "flags 0x%x, hw psz %d\n",
5674                    ilt_client->start,
5675                    ilt_client->end,
5676                    ilt_client->page_size,
5677                    ilt_client->flags,
5678                    ilog2(ilt_client->page_size >> 12));
5679
5680         }
5681         /* SRC */
5682         ilt_client = &ilt->clients[ILT_CLIENT_SRC];
5683 #ifdef BCM_CNIC
5684         ilt_client->client_num = ILT_CLIENT_SRC;
5685         ilt_client->page_size = SRC_ILT_PAGE_SZ;
5686         ilt_client->flags = 0;
5687         ilt_client->start = line;
5688         line += SRC_ILT_LINES;
5689         ilt_client->end = line - 1;
5690
5691         DP(BNX2X_MSG_SP, "ilt client[SRC]: start %d, end %d, psz 0x%x, "
5692                                          "flags 0x%x, hw psz %d\n",
5693            ilt_client->start,
5694            ilt_client->end,
5695            ilt_client->page_size,
5696            ilt_client->flags,
5697            ilog2(ilt_client->page_size >> 12));
5698
5699 #else
5700         ilt_client->flags = (ILT_CLIENT_SKIP_INIT | ILT_CLIENT_SKIP_MEM);
5701 #endif
5702
5703         /* TM */
5704         ilt_client = &ilt->clients[ILT_CLIENT_TM];
5705 #ifdef BCM_CNIC
5706         ilt_client->client_num = ILT_CLIENT_TM;
5707         ilt_client->page_size = TM_ILT_PAGE_SZ;
5708         ilt_client->flags = 0;
5709         ilt_client->start = line;
5710         line += TM_ILT_LINES;
5711         ilt_client->end = line - 1;
5712
5713         DP(BNX2X_MSG_SP, "ilt client[TM]: start %d, end %d, psz 0x%x, "
5714                                          "flags 0x%x, hw psz %d\n",
5715            ilt_client->start,
5716            ilt_client->end,
5717            ilt_client->page_size,
5718            ilt_client->flags,
5719            ilog2(ilt_client->page_size >> 12));
5720
5721 #else
5722         ilt_client->flags = (ILT_CLIENT_SKIP_INIT | ILT_CLIENT_SKIP_MEM);
5723 #endif
5724 }
5725 int bnx2x_setup_client(struct bnx2x *bp, struct bnx2x_fastpath *fp,
5726                        int is_leading)
5727 {
5728         struct bnx2x_client_init_params params = { {0} };
5729         int rc;
5730
5731         bnx2x_ack_sb(bp, fp->igu_sb_id, USTORM_ID, 0,
5732                              IGU_INT_ENABLE, 0);
5733
5734         params.ramrod_params.pstate = &fp->state;
5735         params.ramrod_params.state = BNX2X_FP_STATE_OPEN;
5736         params.ramrod_params.index = fp->index;
5737         params.ramrod_params.cid = fp->cid;
5738
5739         if (is_leading)
5740                 params.ramrod_params.flags |= CLIENT_IS_LEADING_RSS;
5741
5742         bnx2x_pf_rx_cl_prep(bp, fp, &params.pause, &params.rxq_params);
5743
5744         bnx2x_pf_tx_cl_prep(bp, fp, &params.txq_params);
5745
5746         rc = bnx2x_setup_fw_client(bp, &params, 1,
5747                                      bnx2x_sp(bp, client_init_data),
5748                                      bnx2x_sp_mapping(bp, client_init_data));
5749         return rc;
5750 }
5751
5752 int bnx2x_stop_fw_client(struct bnx2x *bp, struct bnx2x_client_ramrod_params *p)
5753 {
5754         int rc;
5755
5756         int poll_flag = p->poll ? WAIT_RAMROD_POLL : 0;
5757
5758         /* halt the connection */
5759         *p->pstate = BNX2X_FP_STATE_HALTING;
5760         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, p->cid, 0,
5761                                                   p->cl_id, 0);
5762
5763         /* Wait for completion */
5764         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, p->index,
5765                                p->pstate, poll_flag);
5766         if (rc) /* timeout */
5767                 return rc;
5768
5769         *p->pstate = BNX2X_FP_STATE_TERMINATING;
5770         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_TERMINATE, p->cid, 0,
5771                                                        p->cl_id, 0);
5772         /* Wait for completion */
5773         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_TERMINATED, p->index,
5774                                p->pstate, poll_flag);
5775         if (rc) /* timeout */
5776                 return rc;
5777
5778
5779         /* delete cfc entry */
5780         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_CFC_DEL, p->cid, 0, 0, 1);
5781
5782         /* Wait for completion */
5783         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_CLOSED, p->index,
5784                                p->pstate, WAIT_RAMROD_COMMON);
5785         return rc;
5786 }
5787
5788 static int bnx2x_stop_client(struct bnx2x *bp, int index)
5789 {
5790         struct bnx2x_client_ramrod_params client_stop = {0};
5791         struct bnx2x_fastpath *fp = &bp->fp[index];
5792
5793         client_stop.index = index;
5794         client_stop.cid = fp->cid;
5795         client_stop.cl_id = fp->cl_id;
5796         client_stop.pstate = &(fp->state);
5797         client_stop.poll = 0;
5798
5799         return bnx2x_stop_fw_client(bp, &client_stop);
5800 }
5801
5802
5803 static void bnx2x_reset_func(struct bnx2x *bp)
5804 {
5805         int port = BP_PORT(bp);
5806         int func = BP_FUNC(bp);
5807         int base, i;
5808         int pfunc_offset_fp = offsetof(struct hc_sb_data, p_func) +
5809                          offsetof(struct hc_status_block_data_e1x, common);
5810         int pfunc_offset_sp = offsetof(struct hc_sp_status_block_data, p_func);
5811         int pfid_offset = offsetof(struct pci_entity, pf_id);
5812
5813         /* Disable the function in the FW */
5814         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(func), 0);
5815         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(func), 0);
5816         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(func), 0);
5817         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(func), 0);
5818
5819         /* FP SBs */
5820         for_each_queue(bp, i) {
5821                 struct bnx2x_fastpath *fp = &bp->fp[i];
5822                 REG_WR8(bp,
5823                         BAR_CSTRORM_INTMEM +
5824                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id)
5825                         + pfunc_offset_fp + pfid_offset,
5826                         HC_FUNCTION_DISABLED);
5827         }
5828
5829         /* SP SB */
5830         REG_WR8(bp,
5831                 BAR_CSTRORM_INTMEM +
5832                 CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
5833                 pfunc_offset_sp + pfid_offset,
5834                 HC_FUNCTION_DISABLED);
5835
5836
5837         for (i = 0; i < XSTORM_SPQ_DATA_SIZE / 4; i++)
5838                 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_DATA_OFFSET(func),
5839                        0);
5840
5841         /* Configure IGU */
5842         REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5843         REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5844
5845 #ifdef BCM_CNIC
5846         /* Disable Timer scan */
5847         REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 0);
5848         /*
5849          * Wait for at least 10ms and up to 2 second for the timers scan to
5850          * complete
5851          */
5852         for (i = 0; i < 200; i++) {
5853                 msleep(10);
5854                 if (!REG_RD(bp, TM_REG_LIN0_SCAN_ON + port*4))
5855                         break;
5856         }
5857 #endif
5858         /* Clear ILT */
5859         base = FUNC_ILT_BASE(func);
5860         for (i = base; i < base + ILT_PER_FUNC; i++)
5861                 bnx2x_ilt_wr(bp, i, 0);
5862
5863         bp->dmae_ready = 0;
5864 }
5865
5866 static void bnx2x_reset_port(struct bnx2x *bp)
5867 {
5868         int port = BP_PORT(bp);
5869         u32 val;
5870
5871         REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
5872
5873         /* Do not rcv packets to BRB */
5874         REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK + port*4, 0x0);
5875         /* Do not direct rcv packets that are not for MCP to the BRB */
5876         REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_NOT_MCP :
5877                            NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
5878
5879         /* Configure AEU */
5880         REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, 0);
5881
5882         msleep(100);
5883         /* Check for BRB port occupancy */
5884         val = REG_RD(bp, BRB1_REG_PORT_NUM_OCC_BLOCKS_0 + port*4);
5885         if (val)
5886                 DP(NETIF_MSG_IFDOWN,
5887                    "BRB1 is not empty  %d blocks are occupied\n", val);
5888
5889         /* TODO: Close Doorbell port? */
5890 }
5891
5892 static void bnx2x_reset_chip(struct bnx2x *bp, u32 reset_code)
5893 {
5894         DP(BNX2X_MSG_MCP, "function %d  reset_code %x\n",
5895            BP_FUNC(bp), reset_code);
5896
5897         switch (reset_code) {
5898         case FW_MSG_CODE_DRV_UNLOAD_COMMON:
5899                 bnx2x_reset_port(bp);
5900                 bnx2x_reset_func(bp);
5901                 bnx2x_reset_common(bp);
5902                 break;
5903
5904         case FW_MSG_CODE_DRV_UNLOAD_PORT:
5905                 bnx2x_reset_port(bp);
5906                 bnx2x_reset_func(bp);
5907                 break;
5908
5909         case FW_MSG_CODE_DRV_UNLOAD_FUNCTION:
5910                 bnx2x_reset_func(bp);
5911                 break;
5912
5913         default:
5914                 BNX2X_ERR("Unknown reset_code (0x%x) from MCP\n", reset_code);
5915                 break;
5916         }
5917 }
5918
5919 void bnx2x_chip_cleanup(struct bnx2x *bp, int unload_mode)
5920 {
5921         int port = BP_PORT(bp);
5922         u32 reset_code = 0;
5923         int i, cnt, rc;
5924
5925         /* Wait until tx fastpath tasks complete */
5926         for_each_queue(bp, i) {
5927                 struct bnx2x_fastpath *fp = &bp->fp[i];
5928
5929                 cnt = 1000;
5930                 while (bnx2x_has_tx_work_unload(fp)) {
5931
5932                         if (!cnt) {
5933                                 BNX2X_ERR("timeout waiting for queue[%d]\n",
5934                                           i);
5935 #ifdef BNX2X_STOP_ON_ERROR
5936                                 bnx2x_panic();
5937                                 return -EBUSY;
5938 #else
5939                                 break;
5940 #endif
5941                         }
5942                         cnt--;
5943                         msleep(1);
5944                 }
5945         }
5946         /* Give HW time to discard old tx messages */
5947         msleep(1);
5948
5949         if (CHIP_IS_E1(bp)) {
5950                 /* invalidate mc list,
5951                  * wait and poll (interrupts are off)
5952                  */
5953                 bnx2x_invlidate_e1_mc_list(bp);
5954                 bnx2x_set_eth_mac(bp, 0);
5955
5956         } else {
5957                 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
5958
5959                 bnx2x_set_eth_mac(bp, 0);
5960
5961                 for (i = 0; i < MC_HASH_SIZE; i++)
5962                         REG_WR(bp, MC_HASH_OFFSET(bp, i), 0);
5963         }
5964
5965 #ifdef BCM_CNIC
5966         /* Clear iSCSI L2 MAC */
5967         mutex_lock(&bp->cnic_mutex);
5968         if (bp->cnic_flags & BNX2X_CNIC_FLAG_MAC_SET) {
5969                 bnx2x_set_iscsi_eth_mac_addr(bp, 0);
5970                 bp->cnic_flags &= ~BNX2X_CNIC_FLAG_MAC_SET;
5971         }
5972         mutex_unlock(&bp->cnic_mutex);
5973 #endif
5974
5975         if (unload_mode == UNLOAD_NORMAL)
5976                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
5977
5978         else if (bp->flags & NO_WOL_FLAG)
5979                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
5980
5981         else if (bp->wol) {
5982                 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
5983                 u8 *mac_addr = bp->dev->dev_addr;
5984                 u32 val;
5985                 /* The mac address is written to entries 1-4 to
5986                    preserve entry 0 which is used by the PMF */
5987                 u8 entry = (BP_E1HVN(bp) + 1)*8;
5988
5989                 val = (mac_addr[0] << 8) | mac_addr[1];
5990                 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry, val);
5991
5992                 val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
5993                       (mac_addr[4] << 8) | mac_addr[5];
5994                 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
5995
5996                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
5997
5998         } else
5999                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
6000
6001         /* Close multi and leading connections
6002            Completions for ramrods are collected in a synchronous way */
6003         for_each_queue(bp, i)
6004
6005                 if (bnx2x_stop_client(bp, i))
6006 #ifdef BNX2X_STOP_ON_ERROR
6007                         return;
6008 #else
6009                         goto unload_error;
6010 #endif
6011
6012         rc = bnx2x_func_stop(bp);
6013         if (rc) {
6014                 BNX2X_ERR("Function stop failed!\n");
6015 #ifdef BNX2X_STOP_ON_ERROR
6016                 return;
6017 #else
6018                 goto unload_error;
6019 #endif
6020         }
6021 #ifndef BNX2X_STOP_ON_ERROR
6022 unload_error:
6023 #endif
6024         if (!BP_NOMCP(bp))
6025                 reset_code = bnx2x_fw_command(bp, reset_code, 0);
6026         else {
6027                 DP(NETIF_MSG_IFDOWN, "NO MCP - load counts      %d, %d, %d\n",
6028                    load_count[0], load_count[1], load_count[2]);
6029                 load_count[0]--;
6030                 load_count[1 + port]--;
6031                 DP(NETIF_MSG_IFDOWN, "NO MCP - new load counts  %d, %d, %d\n",
6032                    load_count[0], load_count[1], load_count[2]);
6033                 if (load_count[0] == 0)
6034                         reset_code = FW_MSG_CODE_DRV_UNLOAD_COMMON;
6035                 else if (load_count[1 + port] == 0)
6036                         reset_code = FW_MSG_CODE_DRV_UNLOAD_PORT;
6037                 else
6038                         reset_code = FW_MSG_CODE_DRV_UNLOAD_FUNCTION;
6039         }
6040
6041         if ((reset_code == FW_MSG_CODE_DRV_UNLOAD_COMMON) ||
6042             (reset_code == FW_MSG_CODE_DRV_UNLOAD_PORT))
6043                 bnx2x__link_reset(bp);
6044
6045         /* Disable HW interrupts, NAPI */
6046         bnx2x_netif_stop(bp, 1);
6047
6048         /* Release IRQs */
6049         bnx2x_free_irq(bp, false);
6050
6051         /* Reset the chip */
6052         bnx2x_reset_chip(bp, reset_code);
6053
6054         /* Report UNLOAD_DONE to MCP */
6055         if (!BP_NOMCP(bp))
6056                 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
6057
6058 }
6059
6060 void bnx2x_disable_close_the_gate(struct bnx2x *bp)
6061 {
6062         u32 val;
6063
6064         DP(NETIF_MSG_HW, "Disabling \"close the gates\"\n");
6065
6066         if (CHIP_IS_E1(bp)) {
6067                 int port = BP_PORT(bp);
6068                 u32 addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
6069                         MISC_REG_AEU_MASK_ATTN_FUNC_0;
6070
6071                 val = REG_RD(bp, addr);
6072                 val &= ~(0x300);
6073                 REG_WR(bp, addr, val);
6074         } else if (CHIP_IS_E1H(bp)) {
6075                 val = REG_RD(bp, MISC_REG_AEU_GENERAL_MASK);
6076                 val &= ~(MISC_AEU_GENERAL_MASK_REG_AEU_PXP_CLOSE_MASK |
6077