1 /* bnx2x_main.c: Broadcom Everest network driver.
3 * Copyright (c) 2007-2011 Broadcom Corporation
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.
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
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/interrupt.h>
27 #include <linux/pci.h>
28 #include <linux/init.h>
29 #include <linux/netdevice.h>
30 #include <linux/etherdevice.h>
31 #include <linux/skbuff.h>
32 #include <linux/dma-mapping.h>
33 #include <linux/bitops.h>
34 #include <linux/irq.h>
35 #include <linux/delay.h>
36 #include <asm/byteorder.h>
37 #include <linux/time.h>
38 #include <linux/ethtool.h>
39 #include <linux/mii.h>
40 #include <linux/if_vlan.h>
43 #include <net/checksum.h>
44 #include <net/ip6_checksum.h>
45 #include <linux/workqueue.h>
46 #include <linux/crc32.h>
47 #include <linux/crc32c.h>
48 #include <linux/prefetch.h>
49 #include <linux/zlib.h>
51 #include <linux/stringify.h>
55 #include "bnx2x_init.h"
56 #include "bnx2x_init_ops.h"
57 #include "bnx2x_cmn.h"
58 #include "bnx2x_dcb.h"
60 #include <linux/firmware.h>
61 #include "bnx2x_fw_file_hdr.h"
63 #define FW_FILE_VERSION \
64 __stringify(BCM_5710_FW_MAJOR_VERSION) "." \
65 __stringify(BCM_5710_FW_MINOR_VERSION) "." \
66 __stringify(BCM_5710_FW_REVISION_VERSION) "." \
67 __stringify(BCM_5710_FW_ENGINEERING_VERSION)
68 #define FW_FILE_NAME_E1 "bnx2x/bnx2x-e1-" FW_FILE_VERSION ".fw"
69 #define FW_FILE_NAME_E1H "bnx2x/bnx2x-e1h-" FW_FILE_VERSION ".fw"
70 #define FW_FILE_NAME_E2 "bnx2x/bnx2x-e2-" FW_FILE_VERSION ".fw"
72 /* Time in jiffies before concluding the transmitter is hung */
73 #define TX_TIMEOUT (5*HZ)
75 static char version[] __devinitdata =
76 "Broadcom NetXtreme II 5771x 10Gigabit Ethernet Driver "
77 DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
79 MODULE_AUTHOR("Eliezer Tamir");
80 MODULE_DESCRIPTION("Broadcom NetXtreme II "
81 "BCM57710/57711/57711E/57712/57712E Driver");
82 MODULE_LICENSE("GPL");
83 MODULE_VERSION(DRV_MODULE_VERSION);
84 MODULE_FIRMWARE(FW_FILE_NAME_E1);
85 MODULE_FIRMWARE(FW_FILE_NAME_E1H);
86 MODULE_FIRMWARE(FW_FILE_NAME_E2);
88 static int multi_mode = 1;
89 module_param(multi_mode, int, 0);
90 MODULE_PARM_DESC(multi_mode, " Multi queue mode "
91 "(0 Disable; 1 Enable (default))");
94 module_param(num_queues, int, 0);
95 MODULE_PARM_DESC(num_queues, " Number of queues for multi_mode=1"
96 " (default is as a number of CPUs)");
98 static int disable_tpa;
99 module_param(disable_tpa, int, 0);
100 MODULE_PARM_DESC(disable_tpa, " Disable the TPA (LRO) feature");
103 module_param(int_mode, int, 0);
104 MODULE_PARM_DESC(int_mode, " Force interrupt mode other then MSI-X "
107 static int dropless_fc;
108 module_param(dropless_fc, int, 0);
109 MODULE_PARM_DESC(dropless_fc, " Pause on exhausted host ring");
112 module_param(poll, int, 0);
113 MODULE_PARM_DESC(poll, " Use polling (for debug)");
115 static int mrrs = -1;
116 module_param(mrrs, int, 0);
117 MODULE_PARM_DESC(mrrs, " Force Max Read Req Size (0..3) (for debug)");
120 module_param(debug, int, 0);
121 MODULE_PARM_DESC(debug, " Default debug msglevel");
123 static struct workqueue_struct *bnx2x_wq;
126 static u8 ALL_ENODE_MACS[] = {0x01, 0x10, 0x18, 0x01, 0x00, 0x01};
129 enum bnx2x_board_type {
137 /* indexed by board_type, above */
140 } board_info[] __devinitdata = {
141 { "Broadcom NetXtreme II BCM57710 XGb" },
142 { "Broadcom NetXtreme II BCM57711 XGb" },
143 { "Broadcom NetXtreme II BCM57711E XGb" },
144 { "Broadcom NetXtreme II BCM57712 XGb" },
145 { "Broadcom NetXtreme II BCM57712E XGb" }
148 static DEFINE_PCI_DEVICE_TABLE(bnx2x_pci_tbl) = {
149 { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57710), BCM57710 },
150 { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711), BCM57711 },
151 { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711E), BCM57711E },
152 { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712), BCM57712 },
153 { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712E), BCM57712E },
157 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
159 /****************************************************************************
160 * General service functions
161 ****************************************************************************/
163 static inline void __storm_memset_dma_mapping(struct bnx2x *bp,
164 u32 addr, dma_addr_t mapping)
166 REG_WR(bp, addr, U64_LO(mapping));
167 REG_WR(bp, addr + 4, U64_HI(mapping));
170 static inline void __storm_memset_fill(struct bnx2x *bp,
171 u32 addr, size_t size, u32 val)
174 for (i = 0; i < size/4; i++)
175 REG_WR(bp, addr + (i * 4), val);
178 static inline void storm_memset_ustats_zero(struct bnx2x *bp,
179 u8 port, u16 stat_id)
181 size_t size = sizeof(struct ustorm_per_client_stats);
183 u32 addr = BAR_USTRORM_INTMEM +
184 USTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
186 __storm_memset_fill(bp, addr, size, 0);
189 static inline void storm_memset_tstats_zero(struct bnx2x *bp,
190 u8 port, u16 stat_id)
192 size_t size = sizeof(struct tstorm_per_client_stats);
194 u32 addr = BAR_TSTRORM_INTMEM +
195 TSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
197 __storm_memset_fill(bp, addr, size, 0);
200 static inline void storm_memset_xstats_zero(struct bnx2x *bp,
201 u8 port, u16 stat_id)
203 size_t size = sizeof(struct xstorm_per_client_stats);
205 u32 addr = BAR_XSTRORM_INTMEM +
206 XSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
208 __storm_memset_fill(bp, addr, size, 0);
212 static inline void storm_memset_spq_addr(struct bnx2x *bp,
213 dma_addr_t mapping, u16 abs_fid)
215 u32 addr = XSEM_REG_FAST_MEMORY +
216 XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid);
218 __storm_memset_dma_mapping(bp, addr, mapping);
221 static inline void storm_memset_ov(struct bnx2x *bp, u16 ov, u16 abs_fid)
223 REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_E1HOV_OFFSET(abs_fid), ov);
226 static inline void storm_memset_func_cfg(struct bnx2x *bp,
227 struct tstorm_eth_function_common_config *tcfg,
230 size_t size = sizeof(struct tstorm_eth_function_common_config);
232 u32 addr = BAR_TSTRORM_INTMEM +
233 TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid);
235 __storm_memset_struct(bp, addr, size, (u32 *)tcfg);
238 static inline void storm_memset_xstats_flags(struct bnx2x *bp,
239 struct stats_indication_flags *flags,
242 size_t size = sizeof(struct stats_indication_flags);
244 u32 addr = BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(abs_fid);
246 __storm_memset_struct(bp, addr, size, (u32 *)flags);
249 static inline void storm_memset_tstats_flags(struct bnx2x *bp,
250 struct stats_indication_flags *flags,
253 size_t size = sizeof(struct stats_indication_flags);
255 u32 addr = BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(abs_fid);
257 __storm_memset_struct(bp, addr, size, (u32 *)flags);
260 static inline void storm_memset_ustats_flags(struct bnx2x *bp,
261 struct stats_indication_flags *flags,
264 size_t size = sizeof(struct stats_indication_flags);
266 u32 addr = BAR_USTRORM_INTMEM + USTORM_STATS_FLAGS_OFFSET(abs_fid);
268 __storm_memset_struct(bp, addr, size, (u32 *)flags);
271 static inline void storm_memset_cstats_flags(struct bnx2x *bp,
272 struct stats_indication_flags *flags,
275 size_t size = sizeof(struct stats_indication_flags);
277 u32 addr = BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(abs_fid);
279 __storm_memset_struct(bp, addr, size, (u32 *)flags);
282 static inline void storm_memset_xstats_addr(struct bnx2x *bp,
283 dma_addr_t mapping, u16 abs_fid)
285 u32 addr = BAR_XSTRORM_INTMEM +
286 XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
288 __storm_memset_dma_mapping(bp, addr, mapping);
291 static inline void storm_memset_tstats_addr(struct bnx2x *bp,
292 dma_addr_t mapping, u16 abs_fid)
294 u32 addr = BAR_TSTRORM_INTMEM +
295 TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
297 __storm_memset_dma_mapping(bp, addr, mapping);
300 static inline void storm_memset_ustats_addr(struct bnx2x *bp,
301 dma_addr_t mapping, u16 abs_fid)
303 u32 addr = BAR_USTRORM_INTMEM +
304 USTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
306 __storm_memset_dma_mapping(bp, addr, mapping);
309 static inline void storm_memset_cstats_addr(struct bnx2x *bp,
310 dma_addr_t mapping, u16 abs_fid)
312 u32 addr = BAR_CSTRORM_INTMEM +
313 CSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
315 __storm_memset_dma_mapping(bp, addr, mapping);
318 static inline void storm_memset_vf_to_pf(struct bnx2x *bp, u16 abs_fid,
321 REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid),
323 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid),
325 REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid),
327 REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid),
331 static inline void storm_memset_func_en(struct bnx2x *bp, u16 abs_fid,
334 REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid),
336 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid),
338 REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid),
340 REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid),
344 static inline void storm_memset_eq_data(struct bnx2x *bp,
345 struct event_ring_data *eq_data,
348 size_t size = sizeof(struct event_ring_data);
350 u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_DATA_OFFSET(pfid);
352 __storm_memset_struct(bp, addr, size, (u32 *)eq_data);
355 static inline void storm_memset_eq_prod(struct bnx2x *bp, u16 eq_prod,
358 u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_PROD_OFFSET(pfid);
359 REG_WR16(bp, addr, eq_prod);
362 static inline void storm_memset_hc_timeout(struct bnx2x *bp, u8 port,
363 u16 fw_sb_id, u8 sb_index,
367 int index_offset = CHIP_IS_E2(bp) ?
368 offsetof(struct hc_status_block_data_e2, index_data) :
369 offsetof(struct hc_status_block_data_e1x, index_data);
370 u32 addr = BAR_CSTRORM_INTMEM +
371 CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
373 sizeof(struct hc_index_data)*sb_index +
374 offsetof(struct hc_index_data, timeout);
375 REG_WR8(bp, addr, ticks);
376 DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d ticks %d\n",
377 port, fw_sb_id, sb_index, ticks);
379 static inline void storm_memset_hc_disable(struct bnx2x *bp, u8 port,
380 u16 fw_sb_id, u8 sb_index,
383 u32 enable_flag = disable ? 0 : (1 << HC_INDEX_DATA_HC_ENABLED_SHIFT);
384 int index_offset = CHIP_IS_E2(bp) ?
385 offsetof(struct hc_status_block_data_e2, index_data) :
386 offsetof(struct hc_status_block_data_e1x, index_data);
387 u32 addr = BAR_CSTRORM_INTMEM +
388 CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
390 sizeof(struct hc_index_data)*sb_index +
391 offsetof(struct hc_index_data, flags);
392 u16 flags = REG_RD16(bp, addr);
394 flags &= ~HC_INDEX_DATA_HC_ENABLED;
395 flags |= enable_flag;
396 REG_WR16(bp, addr, flags);
397 DP(NETIF_MSG_HW, "port %x fw_sb_id %d sb_index %d disable %d\n",
398 port, fw_sb_id, sb_index, disable);
402 * locking is done by mcp
404 static void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
406 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
407 pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
408 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
409 PCICFG_VENDOR_ID_OFFSET);
412 static u32 bnx2x_reg_rd_ind(struct bnx2x *bp, u32 addr)
416 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
417 pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
418 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
419 PCICFG_VENDOR_ID_OFFSET);
424 #define DMAE_DP_SRC_GRC "grc src_addr [%08x]"
425 #define DMAE_DP_SRC_PCI "pci src_addr [%x:%08x]"
426 #define DMAE_DP_DST_GRC "grc dst_addr [%08x]"
427 #define DMAE_DP_DST_PCI "pci dst_addr [%x:%08x]"
428 #define DMAE_DP_DST_NONE "dst_addr [none]"
430 static void bnx2x_dp_dmae(struct bnx2x *bp, struct dmae_command *dmae,
433 u32 src_type = dmae->opcode & DMAE_COMMAND_SRC;
435 switch (dmae->opcode & DMAE_COMMAND_DST) {
436 case DMAE_CMD_DST_PCI:
437 if (src_type == DMAE_CMD_SRC_PCI)
438 DP(msglvl, "DMAE: opcode 0x%08x\n"
439 "src [%x:%08x], len [%d*4], dst [%x:%08x]\n"
440 "comp_addr [%x:%08x], comp_val 0x%08x\n",
441 dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
442 dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
443 dmae->comp_addr_hi, dmae->comp_addr_lo,
446 DP(msglvl, "DMAE: opcode 0x%08x\n"
447 "src [%08x], len [%d*4], dst [%x:%08x]\n"
448 "comp_addr [%x:%08x], comp_val 0x%08x\n",
449 dmae->opcode, dmae->src_addr_lo >> 2,
450 dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo,
451 dmae->comp_addr_hi, dmae->comp_addr_lo,
454 case DMAE_CMD_DST_GRC:
455 if (src_type == DMAE_CMD_SRC_PCI)
456 DP(msglvl, "DMAE: opcode 0x%08x\n"
457 "src [%x:%08x], len [%d*4], dst_addr [%08x]\n"
458 "comp_addr [%x:%08x], comp_val 0x%08x\n",
459 dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
460 dmae->len, dmae->dst_addr_lo >> 2,
461 dmae->comp_addr_hi, dmae->comp_addr_lo,
464 DP(msglvl, "DMAE: opcode 0x%08x\n"
465 "src [%08x], len [%d*4], dst [%08x]\n"
466 "comp_addr [%x:%08x], comp_val 0x%08x\n",
467 dmae->opcode, dmae->src_addr_lo >> 2,
468 dmae->len, dmae->dst_addr_lo >> 2,
469 dmae->comp_addr_hi, dmae->comp_addr_lo,
473 if (src_type == DMAE_CMD_SRC_PCI)
474 DP(msglvl, "DMAE: opcode 0x%08x\n"
475 DP_LEVEL "src_addr [%x:%08x] len [%d * 4] "
477 DP_LEVEL "comp_addr [%x:%08x] comp_val 0x%08x\n",
478 dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
479 dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
482 DP(msglvl, "DMAE: opcode 0x%08x\n"
483 DP_LEVEL "src_addr [%08x] len [%d * 4] "
485 DP_LEVEL "comp_addr [%x:%08x] comp_val 0x%08x\n",
486 dmae->opcode, dmae->src_addr_lo >> 2,
487 dmae->len, dmae->comp_addr_hi, dmae->comp_addr_lo,
494 const u32 dmae_reg_go_c[] = {
495 DMAE_REG_GO_C0, DMAE_REG_GO_C1, DMAE_REG_GO_C2, DMAE_REG_GO_C3,
496 DMAE_REG_GO_C4, DMAE_REG_GO_C5, DMAE_REG_GO_C6, DMAE_REG_GO_C7,
497 DMAE_REG_GO_C8, DMAE_REG_GO_C9, DMAE_REG_GO_C10, DMAE_REG_GO_C11,
498 DMAE_REG_GO_C12, DMAE_REG_GO_C13, DMAE_REG_GO_C14, DMAE_REG_GO_C15
501 /* copy command into DMAE command memory and set DMAE command go */
502 void bnx2x_post_dmae(struct bnx2x *bp, struct dmae_command *dmae, int idx)
507 cmd_offset = (DMAE_REG_CMD_MEM + sizeof(struct dmae_command) * idx);
508 for (i = 0; i < (sizeof(struct dmae_command)/4); i++) {
509 REG_WR(bp, cmd_offset + i*4, *(((u32 *)dmae) + i));
511 DP(BNX2X_MSG_OFF, "DMAE cmd[%d].%d (0x%08x) : 0x%08x\n",
512 idx, i, cmd_offset + i*4, *(((u32 *)dmae) + i));
514 REG_WR(bp, dmae_reg_go_c[idx], 1);
517 u32 bnx2x_dmae_opcode_add_comp(u32 opcode, u8 comp_type)
519 return opcode | ((comp_type << DMAE_COMMAND_C_DST_SHIFT) |
523 u32 bnx2x_dmae_opcode_clr_src_reset(u32 opcode)
525 return opcode & ~DMAE_CMD_SRC_RESET;
528 u32 bnx2x_dmae_opcode(struct bnx2x *bp, u8 src_type, u8 dst_type,
529 bool with_comp, u8 comp_type)
533 opcode |= ((src_type << DMAE_COMMAND_SRC_SHIFT) |
534 (dst_type << DMAE_COMMAND_DST_SHIFT));
536 opcode |= (DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET);
538 opcode |= (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0);
539 opcode |= ((BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT) |
540 (BP_E1HVN(bp) << DMAE_COMMAND_DST_VN_SHIFT));
541 opcode |= (DMAE_COM_SET_ERR << DMAE_COMMAND_ERR_POLICY_SHIFT);
544 opcode |= DMAE_CMD_ENDIANITY_B_DW_SWAP;
546 opcode |= DMAE_CMD_ENDIANITY_DW_SWAP;
549 opcode = bnx2x_dmae_opcode_add_comp(opcode, comp_type);
553 static void bnx2x_prep_dmae_with_comp(struct bnx2x *bp,
554 struct dmae_command *dmae,
555 u8 src_type, u8 dst_type)
557 memset(dmae, 0, sizeof(struct dmae_command));
560 dmae->opcode = bnx2x_dmae_opcode(bp, src_type, dst_type,
561 true, DMAE_COMP_PCI);
563 /* fill in the completion parameters */
564 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
565 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
566 dmae->comp_val = DMAE_COMP_VAL;
569 /* issue a dmae command over the init-channel and wailt for completion */
570 static int bnx2x_issue_dmae_with_comp(struct bnx2x *bp,
571 struct dmae_command *dmae)
573 u32 *wb_comp = bnx2x_sp(bp, wb_comp);
574 int cnt = CHIP_REV_IS_SLOW(bp) ? (400000) : 4000;
577 DP(BNX2X_MSG_OFF, "data before [0x%08x 0x%08x 0x%08x 0x%08x]\n",
578 bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
579 bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
581 /* lock the dmae channel */
582 spin_lock_bh(&bp->dmae_lock);
584 /* reset completion */
587 /* post the command on the channel used for initializations */
588 bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
590 /* wait for completion */
592 while ((*wb_comp & ~DMAE_PCI_ERR_FLAG) != DMAE_COMP_VAL) {
593 DP(BNX2X_MSG_OFF, "wb_comp 0x%08x\n", *wb_comp);
596 BNX2X_ERR("DMAE timeout!\n");
603 if (*wb_comp & DMAE_PCI_ERR_FLAG) {
604 BNX2X_ERR("DMAE PCI error!\n");
608 DP(BNX2X_MSG_OFF, "data after [0x%08x 0x%08x 0x%08x 0x%08x]\n",
609 bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
610 bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
613 spin_unlock_bh(&bp->dmae_lock);
617 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr, u32 dst_addr,
620 struct dmae_command dmae;
622 if (!bp->dmae_ready) {
623 u32 *data = bnx2x_sp(bp, wb_data[0]);
625 DP(BNX2X_MSG_OFF, "DMAE is not ready (dst_addr %08x len32 %d)"
626 " using indirect\n", dst_addr, len32);
627 bnx2x_init_ind_wr(bp, dst_addr, data, len32);
631 /* set opcode and fixed command fields */
632 bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_GRC);
634 /* fill in addresses and len */
635 dmae.src_addr_lo = U64_LO(dma_addr);
636 dmae.src_addr_hi = U64_HI(dma_addr);
637 dmae.dst_addr_lo = dst_addr >> 2;
638 dmae.dst_addr_hi = 0;
641 bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_OFF);
643 /* issue the command and wait for completion */
644 bnx2x_issue_dmae_with_comp(bp, &dmae);
647 void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32)
649 struct dmae_command dmae;
651 if (!bp->dmae_ready) {
652 u32 *data = bnx2x_sp(bp, wb_data[0]);
655 DP(BNX2X_MSG_OFF, "DMAE is not ready (src_addr %08x len32 %d)"
656 " using indirect\n", src_addr, len32);
657 for (i = 0; i < len32; i++)
658 data[i] = bnx2x_reg_rd_ind(bp, src_addr + i*4);
662 /* set opcode and fixed command fields */
663 bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_GRC, DMAE_DST_PCI);
665 /* fill in addresses and len */
666 dmae.src_addr_lo = src_addr >> 2;
667 dmae.src_addr_hi = 0;
668 dmae.dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_data));
669 dmae.dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_data));
672 bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_OFF);
674 /* issue the command and wait for completion */
675 bnx2x_issue_dmae_with_comp(bp, &dmae);
678 static void bnx2x_write_dmae_phys_len(struct bnx2x *bp, dma_addr_t phys_addr,
681 int dmae_wr_max = DMAE_LEN32_WR_MAX(bp);
684 while (len > dmae_wr_max) {
685 bnx2x_write_dmae(bp, phys_addr + offset,
686 addr + offset, dmae_wr_max);
687 offset += dmae_wr_max * 4;
691 bnx2x_write_dmae(bp, phys_addr + offset, addr + offset, len);
694 /* used only for slowpath so not inlined */
695 static void bnx2x_wb_wr(struct bnx2x *bp, int reg, u32 val_hi, u32 val_lo)
699 wb_write[0] = val_hi;
700 wb_write[1] = val_lo;
701 REG_WR_DMAE(bp, reg, wb_write, 2);
705 static u64 bnx2x_wb_rd(struct bnx2x *bp, int reg)
709 REG_RD_DMAE(bp, reg, wb_data, 2);
711 return HILO_U64(wb_data[0], wb_data[1]);
715 static int bnx2x_mc_assert(struct bnx2x *bp)
719 u32 row0, row1, row2, row3;
722 last_idx = REG_RD8(bp, BAR_XSTRORM_INTMEM +
723 XSTORM_ASSERT_LIST_INDEX_OFFSET);
725 BNX2X_ERR("XSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
727 /* print the asserts */
728 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
730 row0 = REG_RD(bp, BAR_XSTRORM_INTMEM +
731 XSTORM_ASSERT_LIST_OFFSET(i));
732 row1 = REG_RD(bp, BAR_XSTRORM_INTMEM +
733 XSTORM_ASSERT_LIST_OFFSET(i) + 4);
734 row2 = REG_RD(bp, BAR_XSTRORM_INTMEM +
735 XSTORM_ASSERT_LIST_OFFSET(i) + 8);
736 row3 = REG_RD(bp, BAR_XSTRORM_INTMEM +
737 XSTORM_ASSERT_LIST_OFFSET(i) + 12);
739 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
740 BNX2X_ERR("XSTORM_ASSERT_INDEX 0x%x = 0x%08x"
741 " 0x%08x 0x%08x 0x%08x\n",
742 i, row3, row2, row1, row0);
750 last_idx = REG_RD8(bp, BAR_TSTRORM_INTMEM +
751 TSTORM_ASSERT_LIST_INDEX_OFFSET);
753 BNX2X_ERR("TSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
755 /* print the asserts */
756 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
758 row0 = REG_RD(bp, BAR_TSTRORM_INTMEM +
759 TSTORM_ASSERT_LIST_OFFSET(i));
760 row1 = REG_RD(bp, BAR_TSTRORM_INTMEM +
761 TSTORM_ASSERT_LIST_OFFSET(i) + 4);
762 row2 = REG_RD(bp, BAR_TSTRORM_INTMEM +
763 TSTORM_ASSERT_LIST_OFFSET(i) + 8);
764 row3 = REG_RD(bp, BAR_TSTRORM_INTMEM +
765 TSTORM_ASSERT_LIST_OFFSET(i) + 12);
767 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
768 BNX2X_ERR("TSTORM_ASSERT_INDEX 0x%x = 0x%08x"
769 " 0x%08x 0x%08x 0x%08x\n",
770 i, row3, row2, row1, row0);
778 last_idx = REG_RD8(bp, BAR_CSTRORM_INTMEM +
779 CSTORM_ASSERT_LIST_INDEX_OFFSET);
781 BNX2X_ERR("CSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
783 /* print the asserts */
784 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
786 row0 = REG_RD(bp, BAR_CSTRORM_INTMEM +
787 CSTORM_ASSERT_LIST_OFFSET(i));
788 row1 = REG_RD(bp, BAR_CSTRORM_INTMEM +
789 CSTORM_ASSERT_LIST_OFFSET(i) + 4);
790 row2 = REG_RD(bp, BAR_CSTRORM_INTMEM +
791 CSTORM_ASSERT_LIST_OFFSET(i) + 8);
792 row3 = REG_RD(bp, BAR_CSTRORM_INTMEM +
793 CSTORM_ASSERT_LIST_OFFSET(i) + 12);
795 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
796 BNX2X_ERR("CSTORM_ASSERT_INDEX 0x%x = 0x%08x"
797 " 0x%08x 0x%08x 0x%08x\n",
798 i, row3, row2, row1, row0);
806 last_idx = REG_RD8(bp, BAR_USTRORM_INTMEM +
807 USTORM_ASSERT_LIST_INDEX_OFFSET);
809 BNX2X_ERR("USTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
811 /* print the asserts */
812 for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
814 row0 = REG_RD(bp, BAR_USTRORM_INTMEM +
815 USTORM_ASSERT_LIST_OFFSET(i));
816 row1 = REG_RD(bp, BAR_USTRORM_INTMEM +
817 USTORM_ASSERT_LIST_OFFSET(i) + 4);
818 row2 = REG_RD(bp, BAR_USTRORM_INTMEM +
819 USTORM_ASSERT_LIST_OFFSET(i) + 8);
820 row3 = REG_RD(bp, BAR_USTRORM_INTMEM +
821 USTORM_ASSERT_LIST_OFFSET(i) + 12);
823 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
824 BNX2X_ERR("USTORM_ASSERT_INDEX 0x%x = 0x%08x"
825 " 0x%08x 0x%08x 0x%08x\n",
826 i, row3, row2, row1, row0);
836 static void bnx2x_fw_dump(struct bnx2x *bp)
842 u32 trace_shmem_base;
844 BNX2X_ERR("NO MCP - can not dump\n");
848 if (BP_PATH(bp) == 0)
849 trace_shmem_base = bp->common.shmem_base;
851 trace_shmem_base = SHMEM2_RD(bp, other_shmem_base_addr);
852 addr = trace_shmem_base - 0x0800 + 4;
853 mark = REG_RD(bp, addr);
854 mark = (CHIP_IS_E1x(bp) ? MCP_REG_MCPR_SCRATCH : MCP_A_REG_MCPR_SCRATCH)
855 + ((mark + 0x3) & ~0x3) - 0x08000000;
856 pr_err("begin fw dump (mark 0x%x)\n", mark);
859 for (offset = mark; offset <= trace_shmem_base; offset += 0x8*4) {
860 for (word = 0; word < 8; word++)
861 data[word] = htonl(REG_RD(bp, offset + 4*word));
863 pr_cont("%s", (char *)data);
865 for (offset = addr + 4; offset <= mark; offset += 0x8*4) {
866 for (word = 0; word < 8; word++)
867 data[word] = htonl(REG_RD(bp, offset + 4*word));
869 pr_cont("%s", (char *)data);
871 pr_err("end of fw dump\n");
874 void bnx2x_panic_dump(struct bnx2x *bp)
878 struct hc_sp_status_block_data sp_sb_data;
879 int func = BP_FUNC(bp);
880 #ifdef BNX2X_STOP_ON_ERROR
881 u16 start = 0, end = 0;
884 bp->stats_state = STATS_STATE_DISABLED;
885 DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
887 BNX2X_ERR("begin crash dump -----------------\n");
891 BNX2X_ERR("def_idx(0x%x) def_att_idx(0x%x) attn_state(0x%x)"
892 " spq_prod_idx(0x%x)\n",
893 bp->def_idx, bp->def_att_idx,
894 bp->attn_state, bp->spq_prod_idx);
895 BNX2X_ERR("DSB: attn bits(0x%x) ack(0x%x) id(0x%x) idx(0x%x)\n",
896 bp->def_status_blk->atten_status_block.attn_bits,
897 bp->def_status_blk->atten_status_block.attn_bits_ack,
898 bp->def_status_blk->atten_status_block.status_block_id,
899 bp->def_status_blk->atten_status_block.attn_bits_index);
901 for (i = 0; i < HC_SP_SB_MAX_INDICES; i++)
903 bp->def_status_blk->sp_sb.index_values[i],
904 (i == HC_SP_SB_MAX_INDICES - 1) ? ") " : " ");
906 for (i = 0; i < sizeof(struct hc_sp_status_block_data)/sizeof(u32); i++)
907 *((u32 *)&sp_sb_data + i) = REG_RD(bp, BAR_CSTRORM_INTMEM +
908 CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
911 pr_cont("igu_sb_id(0x%x) igu_seg_id (0x%x) "
912 "pf_id(0x%x) vnic_id(0x%x) "
913 "vf_id(0x%x) vf_valid (0x%x)\n",
914 sp_sb_data.igu_sb_id,
915 sp_sb_data.igu_seg_id,
916 sp_sb_data.p_func.pf_id,
917 sp_sb_data.p_func.vnic_id,
918 sp_sb_data.p_func.vf_id,
919 sp_sb_data.p_func.vf_valid);
922 for_each_eth_queue(bp, i) {
923 struct bnx2x_fastpath *fp = &bp->fp[i];
925 struct hc_status_block_data_e2 sb_data_e2;
926 struct hc_status_block_data_e1x sb_data_e1x;
927 struct hc_status_block_sm *hc_sm_p =
929 sb_data_e2.common.state_machine :
930 sb_data_e1x.common.state_machine;
931 struct hc_index_data *hc_index_p =
933 sb_data_e2.index_data :
934 sb_data_e1x.index_data;
939 BNX2X_ERR("fp%d: rx_bd_prod(0x%x) rx_bd_cons(0x%x)"
940 " rx_comp_prod(0x%x)"
941 " rx_comp_cons(0x%x) *rx_cons_sb(0x%x)\n",
942 i, fp->rx_bd_prod, fp->rx_bd_cons,
944 fp->rx_comp_cons, le16_to_cpu(*fp->rx_cons_sb));
945 BNX2X_ERR(" rx_sge_prod(0x%x) last_max_sge(0x%x)"
946 " fp_hc_idx(0x%x)\n",
947 fp->rx_sge_prod, fp->last_max_sge,
948 le16_to_cpu(fp->fp_hc_idx));
951 BNX2X_ERR("fp%d: tx_pkt_prod(0x%x) tx_pkt_cons(0x%x)"
952 " tx_bd_prod(0x%x) tx_bd_cons(0x%x)"
953 " *tx_cons_sb(0x%x)\n",
954 i, fp->tx_pkt_prod, fp->tx_pkt_cons, fp->tx_bd_prod,
955 fp->tx_bd_cons, le16_to_cpu(*fp->tx_cons_sb));
957 loop = CHIP_IS_E2(bp) ?
958 HC_SB_MAX_INDICES_E2 : HC_SB_MAX_INDICES_E1X;
966 BNX2X_ERR(" run indexes (");
967 for (j = 0; j < HC_SB_MAX_SM; j++)
969 fp->sb_running_index[j],
970 (j == HC_SB_MAX_SM - 1) ? ")" : " ");
972 BNX2X_ERR(" indexes (");
973 for (j = 0; j < loop; j++)
975 fp->sb_index_values[j],
976 (j == loop - 1) ? ")" : " ");
978 data_size = CHIP_IS_E2(bp) ?
979 sizeof(struct hc_status_block_data_e2) :
980 sizeof(struct hc_status_block_data_e1x);
981 data_size /= sizeof(u32);
982 sb_data_p = CHIP_IS_E2(bp) ?
985 /* copy sb data in here */
986 for (j = 0; j < data_size; j++)
987 *(sb_data_p + j) = REG_RD(bp, BAR_CSTRORM_INTMEM +
988 CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id) +
991 if (CHIP_IS_E2(bp)) {
992 pr_cont("pf_id(0x%x) vf_id (0x%x) vf_valid(0x%x) "
993 "vnic_id(0x%x) same_igu_sb_1b(0x%x)\n",
994 sb_data_e2.common.p_func.pf_id,
995 sb_data_e2.common.p_func.vf_id,
996 sb_data_e2.common.p_func.vf_valid,
997 sb_data_e2.common.p_func.vnic_id,
998 sb_data_e2.common.same_igu_sb_1b);
1000 pr_cont("pf_id(0x%x) vf_id (0x%x) vf_valid(0x%x) "
1001 "vnic_id(0x%x) same_igu_sb_1b(0x%x)\n",
1002 sb_data_e1x.common.p_func.pf_id,
1003 sb_data_e1x.common.p_func.vf_id,
1004 sb_data_e1x.common.p_func.vf_valid,
1005 sb_data_e1x.common.p_func.vnic_id,
1006 sb_data_e1x.common.same_igu_sb_1b);
1010 for (j = 0; j < HC_SB_MAX_SM; j++) {
1011 pr_cont("SM[%d] __flags (0x%x) "
1012 "igu_sb_id (0x%x) igu_seg_id(0x%x) "
1013 "time_to_expire (0x%x) "
1014 "timer_value(0x%x)\n", j,
1016 hc_sm_p[j].igu_sb_id,
1017 hc_sm_p[j].igu_seg_id,
1018 hc_sm_p[j].time_to_expire,
1019 hc_sm_p[j].timer_value);
1023 for (j = 0; j < loop; j++) {
1024 pr_cont("INDEX[%d] flags (0x%x) "
1025 "timeout (0x%x)\n", j,
1026 hc_index_p[j].flags,
1027 hc_index_p[j].timeout);
1031 #ifdef BNX2X_STOP_ON_ERROR
1034 for_each_rx_queue(bp, i) {
1035 struct bnx2x_fastpath *fp = &bp->fp[i];
1037 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
1038 end = RX_BD(le16_to_cpu(*fp->rx_cons_sb) + 503);
1039 for (j = start; j != end; j = RX_BD(j + 1)) {
1040 u32 *rx_bd = (u32 *)&fp->rx_desc_ring[j];
1041 struct sw_rx_bd *sw_bd = &fp->rx_buf_ring[j];
1043 BNX2X_ERR("fp%d: rx_bd[%x]=[%x:%x] sw_bd=[%p]\n",
1044 i, j, rx_bd[1], rx_bd[0], sw_bd->skb);
1047 start = RX_SGE(fp->rx_sge_prod);
1048 end = RX_SGE(fp->last_max_sge);
1049 for (j = start; j != end; j = RX_SGE(j + 1)) {
1050 u32 *rx_sge = (u32 *)&fp->rx_sge_ring[j];
1051 struct sw_rx_page *sw_page = &fp->rx_page_ring[j];
1053 BNX2X_ERR("fp%d: rx_sge[%x]=[%x:%x] sw_page=[%p]\n",
1054 i, j, rx_sge[1], rx_sge[0], sw_page->page);
1057 start = RCQ_BD(fp->rx_comp_cons - 10);
1058 end = RCQ_BD(fp->rx_comp_cons + 503);
1059 for (j = start; j != end; j = RCQ_BD(j + 1)) {
1060 u32 *cqe = (u32 *)&fp->rx_comp_ring[j];
1062 BNX2X_ERR("fp%d: cqe[%x]=[%x:%x:%x:%x]\n",
1063 i, j, cqe[0], cqe[1], cqe[2], cqe[3]);
1068 for_each_tx_queue(bp, i) {
1069 struct bnx2x_fastpath *fp = &bp->fp[i];
1071 start = TX_BD(le16_to_cpu(*fp->tx_cons_sb) - 10);
1072 end = TX_BD(le16_to_cpu(*fp->tx_cons_sb) + 245);
1073 for (j = start; j != end; j = TX_BD(j + 1)) {
1074 struct sw_tx_bd *sw_bd = &fp->tx_buf_ring[j];
1076 BNX2X_ERR("fp%d: packet[%x]=[%p,%x]\n",
1077 i, j, sw_bd->skb, sw_bd->first_bd);
1080 start = TX_BD(fp->tx_bd_cons - 10);
1081 end = TX_BD(fp->tx_bd_cons + 254);
1082 for (j = start; j != end; j = TX_BD(j + 1)) {
1083 u32 *tx_bd = (u32 *)&fp->tx_desc_ring[j];
1085 BNX2X_ERR("fp%d: tx_bd[%x]=[%x:%x:%x:%x]\n",
1086 i, j, tx_bd[0], tx_bd[1], tx_bd[2], tx_bd[3]);
1091 bnx2x_mc_assert(bp);
1092 BNX2X_ERR("end crash dump -----------------\n");
1095 static void bnx2x_hc_int_enable(struct bnx2x *bp)
1097 int port = BP_PORT(bp);
1098 u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
1099 u32 val = REG_RD(bp, addr);
1100 int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1101 int msi = (bp->flags & USING_MSI_FLAG) ? 1 : 0;
1104 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1105 HC_CONFIG_0_REG_INT_LINE_EN_0);
1106 val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1107 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1109 val &= ~HC_CONFIG_0_REG_INT_LINE_EN_0;
1110 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1111 HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1112 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1114 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1115 HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1116 HC_CONFIG_0_REG_INT_LINE_EN_0 |
1117 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1119 if (!CHIP_IS_E1(bp)) {
1120 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
1123 REG_WR(bp, addr, val);
1125 val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
1130 REG_WR(bp, HC_REG_INT_MASK + port*4, 0x1FFFF);
1132 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x) mode %s\n",
1133 val, port, addr, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1135 REG_WR(bp, addr, val);
1137 * Ensure that HC_CONFIG is written before leading/trailing edge config
1142 if (!CHIP_IS_E1(bp)) {
1143 /* init leading/trailing edge */
1145 val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
1147 /* enable nig and gpio3 attention */
1152 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
1153 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
1156 /* Make sure that interrupts are indeed enabled from here on */
1160 static void bnx2x_igu_int_enable(struct bnx2x *bp)
1163 int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1164 int msi = (bp->flags & USING_MSI_FLAG) ? 1 : 0;
1166 val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1169 val &= ~(IGU_PF_CONF_INT_LINE_EN |
1170 IGU_PF_CONF_SINGLE_ISR_EN);
1171 val |= (IGU_PF_CONF_FUNC_EN |
1172 IGU_PF_CONF_MSI_MSIX_EN |
1173 IGU_PF_CONF_ATTN_BIT_EN);
1175 val &= ~IGU_PF_CONF_INT_LINE_EN;
1176 val |= (IGU_PF_CONF_FUNC_EN |
1177 IGU_PF_CONF_MSI_MSIX_EN |
1178 IGU_PF_CONF_ATTN_BIT_EN |
1179 IGU_PF_CONF_SINGLE_ISR_EN);
1181 val &= ~IGU_PF_CONF_MSI_MSIX_EN;
1182 val |= (IGU_PF_CONF_FUNC_EN |
1183 IGU_PF_CONF_INT_LINE_EN |
1184 IGU_PF_CONF_ATTN_BIT_EN |
1185 IGU_PF_CONF_SINGLE_ISR_EN);
1188 DP(NETIF_MSG_INTR, "write 0x%x to IGU mode %s\n",
1189 val, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1191 REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1195 /* init leading/trailing edge */
1197 val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
1199 /* enable nig and gpio3 attention */
1204 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
1205 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
1207 /* Make sure that interrupts are indeed enabled from here on */
1211 void bnx2x_int_enable(struct bnx2x *bp)
1213 if (bp->common.int_block == INT_BLOCK_HC)
1214 bnx2x_hc_int_enable(bp);
1216 bnx2x_igu_int_enable(bp);
1219 static void bnx2x_hc_int_disable(struct bnx2x *bp)
1221 int port = BP_PORT(bp);
1222 u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
1223 u32 val = REG_RD(bp, addr);
1226 * in E1 we must use only PCI configuration space to disable
1227 * MSI/MSIX capablility
1228 * It's forbitten to disable IGU_PF_CONF_MSI_MSIX_EN in HC block
1230 if (CHIP_IS_E1(bp)) {
1231 /* Since IGU_PF_CONF_MSI_MSIX_EN still always on
1232 * Use mask register to prevent from HC sending interrupts
1233 * after we exit the function
1235 REG_WR(bp, HC_REG_INT_MASK + port*4, 0);
1237 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1238 HC_CONFIG_0_REG_INT_LINE_EN_0 |
1239 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1241 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
1242 HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
1243 HC_CONFIG_0_REG_INT_LINE_EN_0 |
1244 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
1246 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
1249 /* flush all outstanding writes */
1252 REG_WR(bp, addr, val);
1253 if (REG_RD(bp, addr) != val)
1254 BNX2X_ERR("BUG! proper val not read from IGU!\n");
1257 static void bnx2x_igu_int_disable(struct bnx2x *bp)
1259 u32 val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1261 val &= ~(IGU_PF_CONF_MSI_MSIX_EN |
1262 IGU_PF_CONF_INT_LINE_EN |
1263 IGU_PF_CONF_ATTN_BIT_EN);
1265 DP(NETIF_MSG_INTR, "write %x to IGU\n", val);
1267 /* flush all outstanding writes */
1270 REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1271 if (REG_RD(bp, IGU_REG_PF_CONFIGURATION) != val)
1272 BNX2X_ERR("BUG! proper val not read from IGU!\n");
1275 static void bnx2x_int_disable(struct bnx2x *bp)
1277 if (bp->common.int_block == INT_BLOCK_HC)
1278 bnx2x_hc_int_disable(bp);
1280 bnx2x_igu_int_disable(bp);
1283 void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
1285 int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1288 /* disable interrupt handling */
1289 atomic_inc(&bp->intr_sem);
1290 smp_wmb(); /* Ensure that bp->intr_sem update is SMP-safe */
1293 /* prevent the HW from sending interrupts */
1294 bnx2x_int_disable(bp);
1296 /* make sure all ISRs are done */
1298 synchronize_irq(bp->msix_table[0].vector);
1303 for_each_eth_queue(bp, i)
1304 synchronize_irq(bp->msix_table[i + offset].vector);
1306 synchronize_irq(bp->pdev->irq);
1308 /* make sure sp_task is not running */
1309 cancel_delayed_work(&bp->sp_task);
1310 flush_workqueue(bnx2x_wq);
1316 * General service functions
1319 /* Return true if succeeded to acquire the lock */
1320 static bool bnx2x_trylock_hw_lock(struct bnx2x *bp, u32 resource)
1323 u32 resource_bit = (1 << resource);
1324 int func = BP_FUNC(bp);
1325 u32 hw_lock_control_reg;
1327 DP(NETIF_MSG_HW, "Trying to take a lock on resource %d\n", resource);
1329 /* Validating that the resource is within range */
1330 if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1332 "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1333 resource, HW_LOCK_MAX_RESOURCE_VALUE);
1338 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1340 hw_lock_control_reg =
1341 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1343 /* Try to acquire the lock */
1344 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1345 lock_status = REG_RD(bp, hw_lock_control_reg);
1346 if (lock_status & resource_bit)
1349 DP(NETIF_MSG_HW, "Failed to get a lock on resource %d\n", resource);
1354 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid);
1357 void bnx2x_sp_event(struct bnx2x_fastpath *fp,
1358 union eth_rx_cqe *rr_cqe)
1360 struct bnx2x *bp = fp->bp;
1361 int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1362 int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
1365 "fp %d cid %d got ramrod #%d state is %x type is %d\n",
1366 fp->index, cid, command, bp->state,
1367 rr_cqe->ramrod_cqe.ramrod_type);
1369 switch (command | fp->state) {
1370 case (RAMROD_CMD_ID_ETH_CLIENT_SETUP | BNX2X_FP_STATE_OPENING):
1371 DP(NETIF_MSG_IFUP, "got MULTI[%d] setup ramrod\n", cid);
1372 fp->state = BNX2X_FP_STATE_OPEN;
1375 case (RAMROD_CMD_ID_ETH_HALT | BNX2X_FP_STATE_HALTING):
1376 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] halt ramrod\n", cid);
1377 fp->state = BNX2X_FP_STATE_HALTED;
1380 case (RAMROD_CMD_ID_ETH_TERMINATE | BNX2X_FP_STATE_TERMINATING):
1381 DP(NETIF_MSG_IFDOWN, "got MULTI[%d] teminate ramrod\n", cid);
1382 fp->state = BNX2X_FP_STATE_TERMINATED;
1386 BNX2X_ERR("unexpected MC reply (%d) "
1387 "fp[%d] state is %x\n",
1388 command, fp->index, fp->state);
1392 smp_mb__before_atomic_inc();
1393 atomic_inc(&bp->cq_spq_left);
1394 /* push the change in fp->state and towards the memory */
1400 irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
1402 struct bnx2x *bp = netdev_priv(dev_instance);
1403 u16 status = bnx2x_ack_int(bp);
1407 /* Return here if interrupt is shared and it's not for us */
1408 if (unlikely(status == 0)) {
1409 DP(NETIF_MSG_INTR, "not our interrupt!\n");
1412 DP(NETIF_MSG_INTR, "got an interrupt status 0x%x\n", status);
1414 /* Return here if interrupt is disabled */
1415 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
1416 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
1420 #ifdef BNX2X_STOP_ON_ERROR
1421 if (unlikely(bp->panic))
1425 for_each_eth_queue(bp, i) {
1426 struct bnx2x_fastpath *fp = &bp->fp[i];
1428 mask = 0x2 << (fp->index + CNIC_CONTEXT_USE);
1429 if (status & mask) {
1430 /* Handle Rx and Tx according to SB id */
1431 prefetch(fp->rx_cons_sb);
1432 prefetch(fp->tx_cons_sb);
1433 prefetch(&fp->sb_running_index[SM_RX_ID]);
1434 napi_schedule(&bnx2x_fp(bp, fp->index, napi));
1441 if (status & (mask | 0x1)) {
1442 struct cnic_ops *c_ops = NULL;
1445 c_ops = rcu_dereference(bp->cnic_ops);
1447 c_ops->cnic_handler(bp->cnic_data, NULL);
1454 if (unlikely(status & 0x1)) {
1455 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
1462 if (unlikely(status))
1463 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
1469 /* end of fast path */
1475 * General service functions
1478 int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource)
1481 u32 resource_bit = (1 << resource);
1482 int func = BP_FUNC(bp);
1483 u32 hw_lock_control_reg;
1486 /* Validating that the resource is within range */
1487 if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1489 "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1490 resource, HW_LOCK_MAX_RESOURCE_VALUE);
1495 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1497 hw_lock_control_reg =
1498 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1501 /* Validating that the resource is not already taken */
1502 lock_status = REG_RD(bp, hw_lock_control_reg);
1503 if (lock_status & resource_bit) {
1504 DP(NETIF_MSG_HW, "lock_status 0x%x resource_bit 0x%x\n",
1505 lock_status, resource_bit);
1509 /* Try for 5 second every 5ms */
1510 for (cnt = 0; cnt < 1000; cnt++) {
1511 /* Try to acquire the lock */
1512 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1513 lock_status = REG_RD(bp, hw_lock_control_reg);
1514 if (lock_status & resource_bit)
1519 DP(NETIF_MSG_HW, "Timeout\n");
1523 int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource)
1526 u32 resource_bit = (1 << resource);
1527 int func = BP_FUNC(bp);
1528 u32 hw_lock_control_reg;
1530 DP(NETIF_MSG_HW, "Releasing a lock on resource %d\n", resource);
1532 /* Validating that the resource is within range */
1533 if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1535 "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1536 resource, HW_LOCK_MAX_RESOURCE_VALUE);
1541 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1543 hw_lock_control_reg =
1544 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1547 /* Validating that the resource is currently taken */
1548 lock_status = REG_RD(bp, hw_lock_control_reg);
1549 if (!(lock_status & resource_bit)) {
1550 DP(NETIF_MSG_HW, "lock_status 0x%x resource_bit 0x%x\n",
1551 lock_status, resource_bit);
1555 REG_WR(bp, hw_lock_control_reg, resource_bit);
1560 int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, u8 port)
1562 /* The GPIO should be swapped if swap register is set and active */
1563 int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1564 REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1565 int gpio_shift = gpio_num +
1566 (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1567 u32 gpio_mask = (1 << gpio_shift);
1571 if (gpio_num > MISC_REGISTERS_GPIO_3) {
1572 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1576 /* read GPIO value */
1577 gpio_reg = REG_RD(bp, MISC_REG_GPIO);
1579 /* get the requested pin value */
1580 if ((gpio_reg & gpio_mask) == gpio_mask)
1585 DP(NETIF_MSG_LINK, "pin %d value 0x%x\n", gpio_num, value);
1590 int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1592 /* The GPIO should be swapped if swap register is set and active */
1593 int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1594 REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1595 int gpio_shift = gpio_num +
1596 (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1597 u32 gpio_mask = (1 << gpio_shift);
1600 if (gpio_num > MISC_REGISTERS_GPIO_3) {
1601 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1605 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1606 /* read GPIO and mask except the float bits */
1607 gpio_reg = (REG_RD(bp, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
1610 case MISC_REGISTERS_GPIO_OUTPUT_LOW:
1611 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output low\n",
1612 gpio_num, gpio_shift);
1613 /* clear FLOAT and set CLR */
1614 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1615 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
1618 case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
1619 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output high\n",
1620 gpio_num, gpio_shift);
1621 /* clear FLOAT and set SET */
1622 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1623 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
1626 case MISC_REGISTERS_GPIO_INPUT_HI_Z:
1627 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> input\n",
1628 gpio_num, gpio_shift);
1630 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1637 REG_WR(bp, MISC_REG_GPIO, gpio_reg);
1638 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1643 int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1645 /* The GPIO should be swapped if swap register is set and active */
1646 int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1647 REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1648 int gpio_shift = gpio_num +
1649 (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1650 u32 gpio_mask = (1 << gpio_shift);
1653 if (gpio_num > MISC_REGISTERS_GPIO_3) {
1654 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1658 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1660 gpio_reg = REG_RD(bp, MISC_REG_GPIO_INT);
1663 case MISC_REGISTERS_GPIO_INT_OUTPUT_CLR:
1664 DP(NETIF_MSG_LINK, "Clear GPIO INT %d (shift %d) -> "
1665 "output low\n", gpio_num, gpio_shift);
1666 /* clear SET and set CLR */
1667 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1668 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1671 case MISC_REGISTERS_GPIO_INT_OUTPUT_SET:
1672 DP(NETIF_MSG_LINK, "Set GPIO INT %d (shift %d) -> "
1673 "output high\n", gpio_num, gpio_shift);
1674 /* clear CLR and set SET */
1675 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1676 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1683 REG_WR(bp, MISC_REG_GPIO_INT, gpio_reg);
1684 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1689 static int bnx2x_set_spio(struct bnx2x *bp, int spio_num, u32 mode)
1691 u32 spio_mask = (1 << spio_num);
1694 if ((spio_num < MISC_REGISTERS_SPIO_4) ||
1695 (spio_num > MISC_REGISTERS_SPIO_7)) {
1696 BNX2X_ERR("Invalid SPIO %d\n", spio_num);
1700 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1701 /* read SPIO and mask except the float bits */
1702 spio_reg = (REG_RD(bp, MISC_REG_SPIO) & MISC_REGISTERS_SPIO_FLOAT);
1705 case MISC_REGISTERS_SPIO_OUTPUT_LOW:
1706 DP(NETIF_MSG_LINK, "Set SPIO %d -> output low\n", spio_num);
1707 /* clear FLOAT and set CLR */
1708 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1709 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_CLR_POS);
1712 case MISC_REGISTERS_SPIO_OUTPUT_HIGH:
1713 DP(NETIF_MSG_LINK, "Set SPIO %d -> output high\n", spio_num);
1714 /* clear FLOAT and set SET */
1715 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1716 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_SET_POS);
1719 case MISC_REGISTERS_SPIO_INPUT_HI_Z:
1720 DP(NETIF_MSG_LINK, "Set SPIO %d -> input\n", spio_num);
1722 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1729 REG_WR(bp, MISC_REG_SPIO, spio_reg);
1730 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1735 void bnx2x_calc_fc_adv(struct bnx2x *bp)
1737 u8 cfg_idx = bnx2x_get_link_cfg_idx(bp);
1738 switch (bp->link_vars.ieee_fc &
1739 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
1740 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
1741 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1745 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
1746 bp->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
1750 case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
1751 bp->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
1755 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1761 u8 bnx2x_initial_phy_init(struct bnx2x *bp, int load_mode)
1763 if (!BP_NOMCP(bp)) {
1765 int cfx_idx = bnx2x_get_link_cfg_idx(bp);
1766 u16 req_line_speed = bp->link_params.req_line_speed[cfx_idx];
1767 /* Initialize link parameters structure variables */
1768 /* It is recommended to turn off RX FC for jumbo frames
1769 for better performance */
1770 if ((CHIP_IS_E1x(bp)) && (bp->dev->mtu > 5000))
1771 bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_TX;
1773 bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
1775 bnx2x_acquire_phy_lock(bp);
1777 if (load_mode == LOAD_DIAG) {
1778 bp->link_params.loopback_mode = LOOPBACK_XGXS;
1779 bp->link_params.req_line_speed[cfx_idx] = SPEED_10000;
1782 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1784 bnx2x_release_phy_lock(bp);
1786 bnx2x_calc_fc_adv(bp);
1788 if (CHIP_REV_IS_SLOW(bp) && bp->link_vars.link_up) {
1789 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
1790 bnx2x_link_report(bp);
1792 bp->link_params.req_line_speed[cfx_idx] = req_line_speed;
1795 BNX2X_ERR("Bootcode is missing - can not initialize link\n");
1799 void bnx2x_link_set(struct bnx2x *bp)
1801 if (!BP_NOMCP(bp)) {
1802 bnx2x_acquire_phy_lock(bp);
1803 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1804 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1805 bnx2x_release_phy_lock(bp);
1807 bnx2x_calc_fc_adv(bp);
1809 BNX2X_ERR("Bootcode is missing - can not set link\n");
1812 static void bnx2x__link_reset(struct bnx2x *bp)
1814 if (!BP_NOMCP(bp)) {
1815 bnx2x_acquire_phy_lock(bp);
1816 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1817 bnx2x_release_phy_lock(bp);
1819 BNX2X_ERR("Bootcode is missing - can not reset link\n");
1822 u8 bnx2x_link_test(struct bnx2x *bp, u8 is_serdes)
1826 if (!BP_NOMCP(bp)) {
1827 bnx2x_acquire_phy_lock(bp);
1828 rc = bnx2x_test_link(&bp->link_params, &bp->link_vars,
1830 bnx2x_release_phy_lock(bp);
1832 BNX2X_ERR("Bootcode is missing - can not test link\n");
1837 static void bnx2x_init_port_minmax(struct bnx2x *bp)
1839 u32 r_param = bp->link_vars.line_speed / 8;
1840 u32 fair_periodic_timeout_usec;
1843 memset(&(bp->cmng.rs_vars), 0,
1844 sizeof(struct rate_shaping_vars_per_port));
1845 memset(&(bp->cmng.fair_vars), 0, sizeof(struct fairness_vars_per_port));
1847 /* 100 usec in SDM ticks = 25 since each tick is 4 usec */
1848 bp->cmng.rs_vars.rs_periodic_timeout = RS_PERIODIC_TIMEOUT_USEC / 4;
1850 /* this is the threshold below which no timer arming will occur
1851 1.25 coefficient is for the threshold to be a little bigger
1852 than the real time, to compensate for timer in-accuracy */
1853 bp->cmng.rs_vars.rs_threshold =
1854 (RS_PERIODIC_TIMEOUT_USEC * r_param * 5) / 4;
1856 /* resolution of fairness timer */
1857 fair_periodic_timeout_usec = QM_ARB_BYTES / r_param;
1858 /* for 10G it is 1000usec. for 1G it is 10000usec. */
1859 t_fair = T_FAIR_COEF / bp->link_vars.line_speed;
1861 /* this is the threshold below which we won't arm the timer anymore */
1862 bp->cmng.fair_vars.fair_threshold = QM_ARB_BYTES;
1864 /* we multiply by 1e3/8 to get bytes/msec.
1865 We don't want the credits to pass a credit
1866 of the t_fair*FAIR_MEM (algorithm resolution) */
1867 bp->cmng.fair_vars.upper_bound = r_param * t_fair * FAIR_MEM;
1868 /* since each tick is 4 usec */
1869 bp->cmng.fair_vars.fairness_timeout = fair_periodic_timeout_usec / 4;
1872 /* Calculates the sum of vn_min_rates.
1873 It's needed for further normalizing of the min_rates.
1875 sum of vn_min_rates.
1877 0 - if all the min_rates are 0.
1878 In the later case fainess algorithm should be deactivated.
1879 If not all min_rates are zero then those that are zeroes will be set to 1.
1881 static void bnx2x_calc_vn_weight_sum(struct bnx2x *bp)
1886 bp->vn_weight_sum = 0;
1887 for (vn = VN_0; vn < E1HVN_MAX; vn++) {
1888 u32 vn_cfg = bp->mf_config[vn];
1889 u32 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1890 FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1892 /* Skip hidden vns */
1893 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
1896 /* If min rate is zero - set it to 1 */
1898 vn_min_rate = DEF_MIN_RATE;
1902 bp->vn_weight_sum += vn_min_rate;
1905 /* ... only if all min rates are zeros - disable fairness */
1907 bp->cmng.flags.cmng_enables &=
1908 ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1909 DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
1910 " fairness will be disabled\n");
1912 bp->cmng.flags.cmng_enables |=
1913 CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1916 static void bnx2x_init_vn_minmax(struct bnx2x *bp, int vn)
1918 struct rate_shaping_vars_per_vn m_rs_vn;
1919 struct fairness_vars_per_vn m_fair_vn;
1920 u32 vn_cfg = bp->mf_config[vn];
1921 int func = 2*vn + BP_PORT(bp);
1922 u16 vn_min_rate, vn_max_rate;
1925 /* If function is hidden - set min and max to zeroes */
1926 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE) {
1931 u32 maxCfg = bnx2x_extract_max_cfg(bp, vn_cfg);
1933 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1934 FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1935 /* If fairness is enabled (not all min rates are zeroes) and
1936 if current min rate is zero - set it to 1.
1937 This is a requirement of the algorithm. */
1938 if (bp->vn_weight_sum && (vn_min_rate == 0))
1939 vn_min_rate = DEF_MIN_RATE;
1942 /* maxCfg in percents of linkspeed */
1943 vn_max_rate = (bp->link_vars.line_speed * maxCfg) / 100;
1945 /* maxCfg is absolute in 100Mb units */
1946 vn_max_rate = maxCfg * 100;
1950 "func %d: vn_min_rate %d vn_max_rate %d vn_weight_sum %d\n",
1951 func, vn_min_rate, vn_max_rate, bp->vn_weight_sum);
1953 memset(&m_rs_vn, 0, sizeof(struct rate_shaping_vars_per_vn));
1954 memset(&m_fair_vn, 0, sizeof(struct fairness_vars_per_vn));
1956 /* global vn counter - maximal Mbps for this vn */
1957 m_rs_vn.vn_counter.rate = vn_max_rate;
1959 /* quota - number of bytes transmitted in this period */
1960 m_rs_vn.vn_counter.quota =
1961 (vn_max_rate * RS_PERIODIC_TIMEOUT_USEC) / 8;
1963 if (bp->vn_weight_sum) {
1964 /* credit for each period of the fairness algorithm:
1965 number of bytes in T_FAIR (the vn share the port rate).
1966 vn_weight_sum should not be larger than 10000, thus
1967 T_FAIR_COEF / (8 * vn_weight_sum) will always be greater
1969 m_fair_vn.vn_credit_delta =
1970 max_t(u32, (vn_min_rate * (T_FAIR_COEF /
1971 (8 * bp->vn_weight_sum))),
1972 (bp->cmng.fair_vars.fair_threshold +
1974 DP(NETIF_MSG_IFUP, "m_fair_vn.vn_credit_delta %d\n",
1975 m_fair_vn.vn_credit_delta);
1978 /* Store it to internal memory */
1979 for (i = 0; i < sizeof(struct rate_shaping_vars_per_vn)/4; i++)
1980 REG_WR(bp, BAR_XSTRORM_INTMEM +
1981 XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func) + i * 4,
1982 ((u32 *)(&m_rs_vn))[i]);
1984 for (i = 0; i < sizeof(struct fairness_vars_per_vn)/4; i++)
1985 REG_WR(bp, BAR_XSTRORM_INTMEM +
1986 XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func) + i * 4,
1987 ((u32 *)(&m_fair_vn))[i]);
1990 static int bnx2x_get_cmng_fns_mode(struct bnx2x *bp)
1992 if (CHIP_REV_IS_SLOW(bp))
1993 return CMNG_FNS_NONE;
1995 return CMNG_FNS_MINMAX;
1997 return CMNG_FNS_NONE;
2000 void bnx2x_read_mf_cfg(struct bnx2x *bp)
2002 int vn, n = (CHIP_MODE_IS_4_PORT(bp) ? 2 : 1);
2005 return; /* what should be the default bvalue in this case */
2007 /* For 2 port configuration the absolute function number formula
2009 * abs_func = 2 * vn + BP_PORT + BP_PATH
2011 * and there are 4 functions per port
2013 * For 4 port configuration it is
2014 * abs_func = 4 * vn + 2 * BP_PORT + BP_PATH
2016 * and there are 2 functions per port
2018 for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2019 int /*abs*/func = n * (2 * vn + BP_PORT(bp)) + BP_PATH(bp);
2021 if (func >= E1H_FUNC_MAX)
2025 MF_CFG_RD(bp, func_mf_config[func].config);
2029 static void bnx2x_cmng_fns_init(struct bnx2x *bp, u8 read_cfg, u8 cmng_type)
2032 if (cmng_type == CMNG_FNS_MINMAX) {
2035 /* clear cmng_enables */
2036 bp->cmng.flags.cmng_enables = 0;
2038 /* read mf conf from shmem */
2040 bnx2x_read_mf_cfg(bp);
2042 /* Init rate shaping and fairness contexts */
2043 bnx2x_init_port_minmax(bp);
2045 /* vn_weight_sum and enable fairness if not 0 */
2046 bnx2x_calc_vn_weight_sum(bp);
2048 /* calculate and set min-max rate for each vn */
2050 for (vn = VN_0; vn < E1HVN_MAX; vn++)
2051 bnx2x_init_vn_minmax(bp, vn);
2053 /* always enable rate shaping and fairness */
2054 bp->cmng.flags.cmng_enables |=
2055 CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN;
2056 if (!bp->vn_weight_sum)
2057 DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
2058 " fairness will be disabled\n");
2062 /* rate shaping and fairness are disabled */
2064 "rate shaping and fairness are disabled\n");
2067 static inline void bnx2x_link_sync_notify(struct bnx2x *bp)
2069 int port = BP_PORT(bp);
2073 /* Set the attention towards other drivers on the same port */
2074 for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2075 if (vn == BP_E1HVN(bp))
2078 func = ((vn << 1) | port);
2079 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_0 +
2080 (LINK_SYNC_ATTENTION_BIT_FUNC_0 + func)*4, 1);
2084 /* This function is called upon link interrupt */
2085 static void bnx2x_link_attn(struct bnx2x *bp)
2087 /* Make sure that we are synced with the current statistics */
2088 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2090 bnx2x_link_update(&bp->link_params, &bp->link_vars);
2092 if (bp->link_vars.link_up) {
2094 /* dropless flow control */
2095 if (!CHIP_IS_E1(bp) && bp->dropless_fc) {
2096 int port = BP_PORT(bp);
2097 u32 pause_enabled = 0;
2099 if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
2102 REG_WR(bp, BAR_USTRORM_INTMEM +
2103 USTORM_ETH_PAUSE_ENABLED_OFFSET(port),
2107 if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
2108 struct host_port_stats *pstats;
2110 pstats = bnx2x_sp(bp, port_stats);
2111 /* reset old bmac stats */
2112 memset(&(pstats->mac_stx[0]), 0,
2113 sizeof(struct mac_stx));
2115 if (bp->state == BNX2X_STATE_OPEN)
2116 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2119 if (bp->link_vars.link_up && bp->link_vars.line_speed) {
2120 int cmng_fns = bnx2x_get_cmng_fns_mode(bp);
2122 if (cmng_fns != CMNG_FNS_NONE) {
2123 bnx2x_cmng_fns_init(bp, false, cmng_fns);
2124 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2126 /* rate shaping and fairness are disabled */
2128 "single function mode without fairness\n");
2131 __bnx2x_link_report(bp);
2134 bnx2x_link_sync_notify(bp);
2137 void bnx2x__link_status_update(struct bnx2x *bp)
2139 if (bp->state != BNX2X_STATE_OPEN)
2142 bnx2x_link_status_update(&bp->link_params, &bp->link_vars);
2144 if (bp->link_vars.link_up)
2145 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2147 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2149 /* indicate link status */
2150 bnx2x_link_report(bp);
2153 static void bnx2x_pmf_update(struct bnx2x *bp)
2155 int port = BP_PORT(bp);
2159 DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
2161 /* enable nig attention */
2162 val = (0xff0f | (1 << (BP_E1HVN(bp) + 4)));
2163 if (bp->common.int_block == INT_BLOCK_HC) {
2164 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
2165 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
2166 } else if (CHIP_IS_E2(bp)) {
2167 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
2168 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
2171 bnx2x_stats_handle(bp, STATS_EVENT_PMF);
2179 * General service functions
2182 /* send the MCP a request, block until there is a reply */
2183 u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param)
2185 int mb_idx = BP_FW_MB_IDX(bp);
2189 u8 delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
2191 mutex_lock(&bp->fw_mb_mutex);
2193 SHMEM_WR(bp, func_mb[mb_idx].drv_mb_param, param);
2194 SHMEM_WR(bp, func_mb[mb_idx].drv_mb_header, (command | seq));
2196 DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB\n", (command | seq));
2199 /* let the FW do it's magic ... */
2202 rc = SHMEM_RD(bp, func_mb[mb_idx].fw_mb_header);
2204 /* Give the FW up to 5 second (500*10ms) */
2205 } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
2207 DP(BNX2X_MSG_MCP, "[after %d ms] read (%x) seq is (%x) from FW MB\n",
2208 cnt*delay, rc, seq);
2210 /* is this a reply to our command? */
2211 if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK))
2212 rc &= FW_MSG_CODE_MASK;
2215 BNX2X_ERR("FW failed to respond!\n");
2219 mutex_unlock(&bp->fw_mb_mutex);
2224 static u8 stat_counter_valid(struct bnx2x *bp, struct bnx2x_fastpath *fp)
2227 if (IS_FCOE_FP(fp) && IS_MF(bp))
2233 /* must be called under rtnl_lock */
2234 static void bnx2x_rxq_set_mac_filters(struct bnx2x *bp, u16 cl_id, u32 filters)
2236 u32 mask = (1 << cl_id);
2238 /* initial seeting is BNX2X_ACCEPT_NONE */
2239 u8 drop_all_ucast = 1, drop_all_bcast = 1, drop_all_mcast = 1;
2240 u8 accp_all_ucast = 0, accp_all_bcast = 0, accp_all_mcast = 0;
2241 u8 unmatched_unicast = 0;
2243 if (filters & BNX2X_ACCEPT_UNMATCHED_UCAST)
2244 unmatched_unicast = 1;
2246 if (filters & BNX2X_PROMISCUOUS_MODE) {
2247 /* promiscious - accept all, drop none */
2248 drop_all_ucast = drop_all_bcast = drop_all_mcast = 0;
2249 accp_all_ucast = accp_all_bcast = accp_all_mcast = 1;
2252 * SI mode defines to accept in promiscuos mode
2253 * only unmatched packets
2255 unmatched_unicast = 1;
2259 if (filters & BNX2X_ACCEPT_UNICAST) {
2260 /* accept matched ucast */
2263 if (filters & BNX2X_ACCEPT_MULTICAST)
2264 /* accept matched mcast */
2267 if (filters & BNX2X_ACCEPT_ALL_UNICAST) {
2268 /* accept all mcast */
2272 if (filters & BNX2X_ACCEPT_ALL_MULTICAST) {
2273 /* accept all mcast */
2277 if (filters & BNX2X_ACCEPT_BROADCAST) {
2278 /* accept (all) bcast */
2283 bp->mac_filters.ucast_drop_all = drop_all_ucast ?
2284 bp->mac_filters.ucast_drop_all | mask :
2285 bp->mac_filters.ucast_drop_all & ~mask;
2287 bp->mac_filters.mcast_drop_all = drop_all_mcast ?
2288 bp->mac_filters.mcast_drop_all | mask :
2289 bp->mac_filters.mcast_drop_all & ~mask;
2291 bp->mac_filters.bcast_drop_all = drop_all_bcast ?
2292 bp->mac_filters.bcast_drop_all | mask :
2293 bp->mac_filters.bcast_drop_all & ~mask;
2295 bp->mac_filters.ucast_accept_all = accp_all_ucast ?
2296 bp->mac_filters.ucast_accept_all | mask :
2297 bp->mac_filters.ucast_accept_all & ~mask;
2299 bp->mac_filters.mcast_accept_all = accp_all_mcast ?
2300 bp->mac_filters.mcast_accept_all | mask :
2301 bp->mac_filters.mcast_accept_all & ~mask;
2303 bp->mac_filters.bcast_accept_all = accp_all_bcast ?
2304 bp->mac_filters.bcast_accept_all | mask :
2305 bp->mac_filters.bcast_accept_all & ~mask;
2307 bp->mac_filters.unmatched_unicast = unmatched_unicast ?
2308 bp->mac_filters.unmatched_unicast | mask :
2309 bp->mac_filters.unmatched_unicast & ~mask;
2312 static void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p)
2314 struct tstorm_eth_function_common_config tcfg = {0};
2318 if (p->func_flgs & FUNC_FLG_TPA)
2319 tcfg.config_flags |=
2320 TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA;
2323 rss_flgs = (p->rss->mode <<
2324 TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT);
2326 if (p->rss->cap & RSS_IPV4_CAP)
2327 rss_flgs |= RSS_IPV4_CAP_MASK;
2328 if (p->rss->cap & RSS_IPV4_TCP_CAP)
2329 rss_flgs |= RSS_IPV4_TCP_CAP_MASK;
2330 if (p->rss->cap & RSS_IPV6_CAP)
2331 rss_flgs |= RSS_IPV6_CAP_MASK;
2332 if (p->rss->cap & RSS_IPV6_TCP_CAP)
2333 rss_flgs |= RSS_IPV6_TCP_CAP_MASK;
2335 tcfg.config_flags |= rss_flgs;
2336 tcfg.rss_result_mask = p->rss->result_mask;
2338 storm_memset_func_cfg(bp, &tcfg, p->func_id);
2340 /* Enable the function in the FW */
2341 storm_memset_vf_to_pf(bp, p->func_id, p->pf_id);
2342 storm_memset_func_en(bp, p->func_id, 1);
2345 if (p->func_flgs & FUNC_FLG_STATS) {
2346 struct stats_indication_flags stats_flags = {0};
2347 stats_flags.collect_eth = 1;
2349 storm_memset_xstats_flags(bp, &stats_flags, p->func_id);
2350 storm_memset_xstats_addr(bp, p->fw_stat_map, p->func_id);
2352 storm_memset_tstats_flags(bp, &stats_flags, p->func_id);
2353 storm_memset_tstats_addr(bp, p->fw_stat_map, p->func_id);
2355 storm_memset_ustats_flags(bp, &stats_flags, p->func_id);
2356 storm_memset_ustats_addr(bp, p->fw_stat_map, p->func_id);
2358 storm_memset_cstats_flags(bp, &stats_flags, p->func_id);
2359 storm_memset_cstats_addr(bp, p->fw_stat_map, p->func_id);
2363 if (p->func_flgs & FUNC_FLG_SPQ) {
2364 storm_memset_spq_addr(bp, p->spq_map, p->func_id);
2365 REG_WR(bp, XSEM_REG_FAST_MEMORY +
2366 XSTORM_SPQ_PROD_OFFSET(p->func_id), p->spq_prod);
2370 static inline u16 bnx2x_get_cl_flags(struct bnx2x *bp,
2371 struct bnx2x_fastpath *fp)
2375 /* calculate queue flags */
2376 flags |= QUEUE_FLG_CACHE_ALIGN;
2377 flags |= QUEUE_FLG_HC;
2378 flags |= IS_MF_SD(bp) ? QUEUE_FLG_OV : 0;
2380 flags |= QUEUE_FLG_VLAN;
2381 DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
2383 if (!fp->disable_tpa)
2384 flags |= QUEUE_FLG_TPA;
2386 flags = stat_counter_valid(bp, fp) ?
2387 (flags | QUEUE_FLG_STATS) : (flags & ~QUEUE_FLG_STATS);
2392 static void bnx2x_pf_rx_cl_prep(struct bnx2x *bp,
2393 struct bnx2x_fastpath *fp, struct rxq_pause_params *pause,
2394 struct bnx2x_rxq_init_params *rxq_init)
2398 u16 tpa_agg_size = 0;
2400 /* calculate queue flags */
2401 u16 flags = bnx2x_get_cl_flags(bp, fp);
2403 if (!fp->disable_tpa) {
2404 pause->sge_th_hi = 250;
2405 pause->sge_th_lo = 150;
2406 tpa_agg_size = min_t(u32,
2407 (min_t(u32, 8, MAX_SKB_FRAGS) *
2408 SGE_PAGE_SIZE * PAGES_PER_SGE), 0xffff);
2409 max_sge = SGE_PAGE_ALIGN(bp->dev->mtu) >>
2411 max_sge = ((max_sge + PAGES_PER_SGE - 1) &
2412 (~(PAGES_PER_SGE-1))) >> PAGES_PER_SGE_SHIFT;
2413 sge_sz = (u16)min_t(u32, SGE_PAGE_SIZE * PAGES_PER_SGE,
2417 /* pause - not for e1 */
2418 if (!CHIP_IS_E1(bp)) {
2419 pause->bd_th_hi = 350;
2420 pause->bd_th_lo = 250;
2421 pause->rcq_th_hi = 350;
2422 pause->rcq_th_lo = 250;
2423 pause->sge_th_hi = 0;
2424 pause->sge_th_lo = 0;
2429 rxq_init->flags = flags;
2430 rxq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2431 rxq_init->dscr_map = fp->rx_desc_mapping;
2432 rxq_init->sge_map = fp->rx_sge_mapping;
2433 rxq_init->rcq_map = fp->rx_comp_mapping;
2434 rxq_init->rcq_np_map = fp->rx_comp_mapping + BCM_PAGE_SIZE;
2436 /* Always use mini-jumbo MTU for FCoE L2 ring */
2438 rxq_init->mtu = BNX2X_FCOE_MINI_JUMBO_MTU;
2440 rxq_init->mtu = bp->dev->mtu;
2442 rxq_init->buf_sz = fp->rx_buf_size;
2443 rxq_init->cl_qzone_id = fp->cl_qzone_id;
2444 rxq_init->cl_id = fp->cl_id;
2445 rxq_init->spcl_id = fp->cl_id;
2446 rxq_init->stat_id = fp->cl_id;
2447 rxq_init->tpa_agg_sz = tpa_agg_size;
2448 rxq_init->sge_buf_sz = sge_sz;
2449 rxq_init->max_sges_pkt = max_sge;
2450 rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
2451 rxq_init->fw_sb_id = fp->fw_sb_id;
2454 rxq_init->sb_cq_index = HC_SP_INDEX_ETH_FCOE_RX_CQ_CONS;
2456 rxq_init->sb_cq_index = U_SB_ETH_RX_CQ_INDEX;
2458 rxq_init->cid = HW_CID(bp, fp->cid);
2460 rxq_init->hc_rate = bp->rx_ticks ? (1000000 / bp->rx_ticks) : 0;
2463 static void bnx2x_pf_tx_cl_prep(struct bnx2x *bp,
2464 struct bnx2x_fastpath *fp, struct bnx2x_txq_init_params *txq_init)
2466 u16 flags = bnx2x_get_cl_flags(bp, fp);
2468 txq_init->flags = flags;
2469 txq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2470 txq_init->dscr_map = fp->tx_desc_mapping;
2471 txq_init->stat_id = fp->cl_id;
2472 txq_init->cid = HW_CID(bp, fp->cid);
2473 txq_init->sb_cq_index = C_SB_ETH_TX_CQ_INDEX;
2474 txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
2475 txq_init->fw_sb_id = fp->fw_sb_id;
2477 if (IS_FCOE_FP(fp)) {
2478 txq_init->sb_cq_index = HC_SP_INDEX_ETH_FCOE_TX_CQ_CONS;
2479 txq_init->traffic_type = LLFC_TRAFFIC_TYPE_FCOE;
2482 txq_init->hc_rate = bp->tx_ticks ? (1000000 / bp->tx_ticks) : 0;
2485 static void bnx2x_pf_init(struct bnx2x *bp)
2487 struct bnx2x_func_init_params func_init = {0};
2488 struct bnx2x_rss_params rss = {0};
2489 struct event_ring_data eq_data = { {0} };
2492 /* pf specific setups */
2493 if (!CHIP_IS_E1(bp))
2494 storm_memset_ov(bp, bp->mf_ov, BP_FUNC(bp));
2496 if (CHIP_IS_E2(bp)) {
2497 /* reset IGU PF statistics: MSIX + ATTN */
2499 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
2500 BNX2X_IGU_STAS_MSG_VF_CNT*4 +
2501 (CHIP_MODE_IS_4_PORT(bp) ?
2502 BP_FUNC(bp) : BP_VN(bp))*4, 0);
2504 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
2505 BNX2X_IGU_STAS_MSG_VF_CNT*4 +
2506 BNX2X_IGU_STAS_MSG_PF_CNT*4 +
2507 (CHIP_MODE_IS_4_PORT(bp) ?
2508 BP_FUNC(bp) : BP_VN(bp))*4, 0);
2511 /* function setup flags */
2512 flags = (FUNC_FLG_STATS | FUNC_FLG_LEADING | FUNC_FLG_SPQ);
2514 if (CHIP_IS_E1x(bp))
2515 flags |= (bp->flags & TPA_ENABLE_FLAG) ? FUNC_FLG_TPA : 0;
2517 flags |= FUNC_FLG_TPA;
2519 /* function setup */
2522 * Although RSS is meaningless when there is a single HW queue we
2523 * still need it enabled in order to have HW Rx hash generated.
2525 rss.cap = (RSS_IPV4_CAP | RSS_IPV4_TCP_CAP |
2526 RSS_IPV6_CAP | RSS_IPV6_TCP_CAP);
2527 rss.mode = bp->multi_mode;
2528 rss.result_mask = MULTI_MASK;
2529 func_init.rss = &rss;
2531 func_init.func_flgs = flags;
2532 func_init.pf_id = BP_FUNC(bp);
2533 func_init.func_id = BP_FUNC(bp);
2534 func_init.fw_stat_map = bnx2x_sp_mapping(bp, fw_stats);
2535 func_init.spq_map = bp->spq_mapping;
2536 func_init.spq_prod = bp->spq_prod_idx;
2538 bnx2x_func_init(bp, &func_init);
2540 memset(&(bp->cmng), 0, sizeof(struct cmng_struct_per_port));
2543 Congestion management values depend on the link rate
2544 There is no active link so initial link rate is set to 10 Gbps.
2545 When the link comes up The congestion management values are
2546 re-calculated according to the actual link rate.
2548 bp->link_vars.line_speed = SPEED_10000;
2549 bnx2x_cmng_fns_init(bp, true, bnx2x_get_cmng_fns_mode(bp));
2551 /* Only the PMF sets the HW */
2553 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2555 /* no rx until link is up */
2556 bp->rx_mode = BNX2X_RX_MODE_NONE;
2557 bnx2x_set_storm_rx_mode(bp);
2559 /* init Event Queue */
2560 eq_data.base_addr.hi = U64_HI(bp->eq_mapping);
2561 eq_data.base_addr.lo = U64_LO(bp->eq_mapping);
2562 eq_data.producer = bp->eq_prod;
2563 eq_data.index_id = HC_SP_INDEX_EQ_CONS;
2564 eq_data.sb_id = DEF_SB_ID;
2565 storm_memset_eq_data(bp, &eq_data, BP_FUNC(bp));
2569 static void bnx2x_e1h_disable(struct bnx2x *bp)
2571 int port = BP_PORT(bp);
2573 netif_tx_disable(bp->dev);
2575 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
2577 netif_carrier_off(bp->dev);
2580 static void bnx2x_e1h_enable(struct bnx2x *bp)
2582 int port = BP_PORT(bp);
2584 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
2586 /* Tx queue should be only reenabled */
2587 netif_tx_wake_all_queues(bp->dev);
2590 * Should not call netif_carrier_on since it will be called if the link
2591 * is up when checking for link state
2595 /* called due to MCP event (on pmf):
2596 * reread new bandwidth configuration
2598 * notify others function about the change
2600 static inline void bnx2x_config_mf_bw(struct bnx2x *bp)
2602 if (bp->link_vars.link_up) {
2603 bnx2x_cmng_fns_init(bp, true, CMNG_FNS_MINMAX);
2604 bnx2x_link_sync_notify(bp);
2606 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2609 static inline void bnx2x_set_mf_bw(struct bnx2x *bp)
2611 bnx2x_config_mf_bw(bp);
2612 bnx2x_fw_command(bp, DRV_MSG_CODE_SET_MF_BW_ACK, 0);
2615 static void bnx2x_dcc_event(struct bnx2x *bp, u32 dcc_event)
2617 DP(BNX2X_MSG_MCP, "dcc_event 0x%x\n", dcc_event);
2619 if (dcc_event & DRV_STATUS_DCC_DISABLE_ENABLE_PF) {
2622 * This is the only place besides the function initialization
2623 * where the bp->flags can change so it is done without any
2626 if (bp->mf_config[BP_VN(bp)] & FUNC_MF_CFG_FUNC_DISABLED) {
2627 DP(NETIF_MSG_IFDOWN, "mf_cfg function disabled\n");
2628 bp->flags |= MF_FUNC_DIS;
2630 bnx2x_e1h_disable(bp);
2632 DP(NETIF_MSG_IFUP, "mf_cfg function enabled\n");
2633 bp->flags &= ~MF_FUNC_DIS;
2635 bnx2x_e1h_enable(bp);
2637 dcc_event &= ~DRV_STATUS_DCC_DISABLE_ENABLE_PF;
2639 if (dcc_event & DRV_STATUS_DCC_BANDWIDTH_ALLOCATION) {
2640 bnx2x_config_mf_bw(bp);
2641 dcc_event &= ~DRV_STATUS_DCC_BANDWIDTH_ALLOCATION;
2644 /* Report results to MCP */
2646 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_FAILURE, 0);
2648 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_OK, 0);
2651 /* must be called under the spq lock */
2652 static inline struct eth_spe *bnx2x_sp_get_next(struct bnx2x *bp)
2654 struct eth_spe *next_spe = bp->spq_prod_bd;
2656 if (bp->spq_prod_bd == bp->spq_last_bd) {
2657 bp->spq_prod_bd = bp->spq;
2658 bp->spq_prod_idx = 0;
2659 DP(NETIF_MSG_TIMER, "end of spq\n");
2667 /* must be called under the spq lock */
2668 static inline void bnx2x_sp_prod_update(struct bnx2x *bp)
2670 int func = BP_FUNC(bp);
2672 /* Make sure that BD data is updated before writing the producer */
2675 REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func),
2680 /* the slow path queue is odd since completions arrive on the fastpath ring */
2681 int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
2682 u32 data_hi, u32 data_lo, int common)
2684 struct eth_spe *spe;
2687 #ifdef BNX2X_STOP_ON_ERROR
2688 if (unlikely(bp->panic))
2692 spin_lock_bh(&bp->spq_lock);
2695 if (!atomic_read(&bp->eq_spq_left)) {
2696 BNX2X_ERR("BUG! EQ ring full!\n");
2697 spin_unlock_bh(&bp->spq_lock);
2701 } else if (!atomic_read(&bp->cq_spq_left)) {
2702 BNX2X_ERR("BUG! SPQ ring full!\n");
2703 spin_unlock_bh(&bp->spq_lock);
2708 spe = bnx2x_sp_get_next(bp);
2710 /* CID needs port number to be encoded int it */
2711 spe->hdr.conn_and_cmd_data =
2712 cpu_to_le32((command << SPE_HDR_CMD_ID_SHIFT) |
2717 * FUNC_START, FUNC_STOP, CFC_DEL, STATS, SET_MAC
2718 * TRAFFIC_STOP, TRAFFIC_START
2720 type = (NONE_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2721 & SPE_HDR_CONN_TYPE;
2723 /* ETH ramrods: SETUP, HALT */
2724 type = (ETH_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2725 & SPE_HDR_CONN_TYPE;
2727 type |= ((BP_FUNC(bp) << SPE_HDR_FUNCTION_ID_SHIFT) &
2728 SPE_HDR_FUNCTION_ID);
2730 spe->hdr.type = cpu_to_le16(type);
2732 spe->data.update_data_addr.hi = cpu_to_le32(data_hi);
2733 spe->data.update_data_addr.lo = cpu_to_le32(data_lo);
2735 /* stats ramrod has it's own slot on the spq */
2736 if (command != RAMROD_CMD_ID_COMMON_STAT_QUERY) {
2737 /* It's ok if the actual decrement is issued towards the memory
2738 * somewhere between the spin_lock and spin_unlock. Thus no
2739 * more explict memory barrier is needed.
2742 atomic_dec(&bp->eq_spq_left);
2744 atomic_dec(&bp->cq_spq_left);
2748 DP(BNX2X_MSG_SP/*NETIF_MSG_TIMER*/,
2749 "SPQE[%x] (%x:%x) command %d hw_cid %x data (%x:%x) "
2750 "type(0x%x) left (ETH, COMMON) (%x,%x)\n",
2751 bp->spq_prod_idx, (u32)U64_HI(bp->spq_mapping),
2752 (u32)(U64_LO(bp->spq_mapping) +
2753 (void *)bp->spq_prod_bd - (void *)bp->spq), command,
2754 HW_CID(bp, cid), data_hi, data_lo, type,
2755 atomic_read(&bp->cq_spq_left), atomic_read(&bp->eq_spq_left));
2757 bnx2x_sp_prod_update(bp);
2758 spin_unlock_bh(&bp->spq_lock);
2762 /* acquire split MCP access lock register */
2763 static int bnx2x_acquire_alr(struct bnx2x *bp)
2769 for (j = 0; j < 1000; j++) {
2771 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
2772 val = REG_RD(bp, GRCBASE_MCP + 0x9c);
2773 if (val & (1L << 31))
2778 if (!(val & (1L << 31))) {
2779 BNX2X_ERR("Cannot acquire MCP access lock register\n");
2786 /* release split MCP access lock register */
2787 static void bnx2x_release_alr(struct bnx2x *bp)
2789 REG_WR(bp, GRCBASE_MCP + 0x9c, 0);
2792 #define BNX2X_DEF_SB_ATT_IDX 0x0001
2793 #define BNX2X_DEF_SB_IDX 0x0002
2795 static inline u16 bnx2x_update_dsb_idx(struct bnx2x *bp)
2797 struct host_sp_status_block *def_sb = bp->def_status_blk;
2800 barrier(); /* status block is written to by the chip */
2801 if (bp->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
2802 bp->def_att_idx = def_sb->atten_status_block.attn_bits_index;
2803 rc |= BNX2X_DEF_SB_ATT_IDX;
2806 if (bp->def_idx != def_sb->sp_sb.running_index) {
2807 bp->def_idx = def_sb->sp_sb.running_index;
2808 rc |= BNX2X_DEF_SB_IDX;
2811 /* Do not reorder: indecies reading should complete before handling */
2817 * slow path service functions
2820 static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
2822 int port = BP_PORT(bp);
2823 u32 aeu_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
2824 MISC_REG_AEU_MASK_ATTN_FUNC_0;
2825 u32 nig_int_mask_addr = port ? NIG_REG_MASK_INTERRUPT_PORT1 :
2826 NIG_REG_MASK_INTERRUPT_PORT0;
2831 if (bp->attn_state & asserted)
2832 BNX2X_ERR("IGU ERROR\n");
2834 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2835 aeu_mask = REG_RD(bp, aeu_addr);
2837 DP(NETIF_MSG_HW, "aeu_mask %x newly asserted %x\n",
2838 aeu_mask, asserted);
2839 aeu_mask &= ~(asserted & 0x3ff);
2840 DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
2842 REG_WR(bp, aeu_addr, aeu_mask);
2843 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2845 DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
2846 bp->attn_state |= asserted;
2847 DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
2849 if (asserted & ATTN_HARD_WIRED_MASK) {
2850 if (asserted & ATTN_NIG_FOR_FUNC) {
2852 bnx2x_acquire_phy_lock(bp);
2854 /* save nig interrupt mask */
2855 nig_mask = REG_RD(bp, nig_int_mask_addr);
2856 REG_WR(bp, nig_int_mask_addr, 0);
2858 bnx2x_link_attn(bp);
2860 /* handle unicore attn? */
2862 if (asserted & ATTN_SW_TIMER_4_FUNC)
2863 DP(NETIF_MSG_HW, "ATTN_SW_TIMER_4_FUNC!\n");
2865 if (asserted & GPIO_2_FUNC)
2866 DP(NETIF_MSG_HW, "GPIO_2_FUNC!\n");
2868 if (asserted & GPIO_3_FUNC)
2869 DP(NETIF_MSG_HW, "GPIO_3_FUNC!\n");
2871 if (asserted & GPIO_4_FUNC)
2872 DP(NETIF_MSG_HW, "GPIO_4_FUNC!\n");
2875 if (asserted & ATTN_GENERAL_ATTN_1) {
2876 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_1!\n");
2877 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
2879 if (asserted & ATTN_GENERAL_ATTN_2) {
2880 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_2!\n");
2881 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
2883 if (asserted & ATTN_GENERAL_ATTN_3) {
2884 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_3!\n");
2885 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
2888 if (asserted & ATTN_GENERAL_ATTN_4) {
2889 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_4!\n");
2890 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
2892 if (asserted & ATTN_GENERAL_ATTN_5) {
2893 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_5!\n");
2894 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
2896 if (asserted & ATTN_GENERAL_ATTN_6) {
2897 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_6!\n");
2898 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
2902 } /* if hardwired */
2904 if (bp->common.int_block == INT_BLOCK_HC)
2905 reg_addr = (HC_REG_COMMAND_REG + port*32 +
2906 COMMAND_REG_ATTN_BITS_SET);
2908 reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_SET_UPPER*8);
2910 DP(NETIF_MSG_HW, "about to mask 0x%08x at %s addr 0x%x\n", asserted,
2911 (bp->common.int_block == INT_BLOCK_HC) ? "HC" : "IGU", reg_addr);
2912 REG_WR(bp, reg_addr, asserted);
2914 /* now set back the mask */
2915 if (asserted & ATTN_NIG_FOR_FUNC) {
2916 REG_WR(bp, nig_int_mask_addr, nig_mask);
2917 bnx2x_release_phy_lock(bp);
2921 static inline void bnx2x_fan_failure(struct bnx2x *bp)
2923 int port = BP_PORT(bp);
2925 /* mark the failure */
2928 dev_info.port_hw_config[port].external_phy_config);
2930 ext_phy_config &= ~PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK;
2931 ext_phy_config |= PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE;
2932 SHMEM_WR(bp, dev_info.port_hw_config[port].external_phy_config,
2935 /* log the failure */
2936 netdev_err(bp->dev, "Fan Failure on Network Controller has caused"
2937 " the driver to shutdown the card to prevent permanent"
2938 " damage. Please contact OEM Support for assistance\n");
2941 static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
2943 int port = BP_PORT(bp);
2947 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
2948 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
2950 if (attn & AEU_INPUTS_ATTN_BITS_SPIO5) {
2952 val = REG_RD(bp, reg_offset);
2953 val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
2954 REG_WR(bp, reg_offset, val);
2956 BNX2X_ERR("SPIO5 hw attention\n");
2958 /* Fan failure attention */
2959 bnx2x_hw_reset_phy(&bp->link_params);
2960 bnx2x_fan_failure(bp);
2963 if (attn & (AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0 |
2964 AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1)) {
2965 bnx2x_acquire_phy_lock(bp);
2966 bnx2x_handle_module_detect_int(&bp->link_params);
2967 bnx2x_release_phy_lock(bp);
2970 if (attn & HW_INTERRUT_ASSERT_SET_0) {
2972 val = REG_RD(bp, reg_offset);
2973 val &= ~(attn & HW_INTERRUT_ASSERT_SET_0);
2974 REG_WR(bp, reg_offset, val);
2976 BNX2X_ERR("FATAL HW block attention set0 0x%x\n",
2977 (u32)(attn & HW_INTERRUT_ASSERT_SET_0));
2982 static inline void bnx2x_attn_int_deasserted1(struct bnx2x *bp, u32 attn)
2986 if (attn & AEU_INPUTS_ATTN_BITS_DOORBELLQ_HW_INTERRUPT) {
2988 val = REG_RD(bp, DORQ_REG_DORQ_INT_STS_CLR);
2989 BNX2X_ERR("DB hw attention 0x%x\n", val);
2990 /* DORQ discard attention */
2992 BNX2X_ERR("FATAL error from DORQ\n");
2995 if (attn & HW_INTERRUT_ASSERT_SET_1) {
2997 int port = BP_PORT(bp);
3000 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_1 :
3001 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_1);
3003 val = REG_RD(bp, reg_offset);
3004 val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
3005 REG_WR(bp, reg_offset, val);
3007 BNX2X_ERR("FATAL HW block attention set1 0x%x\n",
3008 (u32)(attn & HW_INTERRUT_ASSERT_SET_1));
3013 static inline void bnx2x_attn_int_deasserted2(struct bnx2x *bp, u32 attn)
3017 if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
3019 val = REG_RD(bp, CFC_REG_CFC_INT_STS_CLR);
3020 BNX2X_ERR("CFC hw attention 0x%x\n", val);
3021 /* CFC error attention */
3023 BNX2X_ERR("FATAL error from CFC\n");
3026 if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
3028 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_0);
3029 BNX2X_ERR("PXP hw attention 0x%x\n", val);
3030 /* RQ_USDMDP_FIFO_OVERFLOW */
3032 BNX2X_ERR("FATAL error from PXP\n");
3033 if (CHIP_IS_E2(bp)) {
3034 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_1);
3035 BNX2X_ERR("PXP hw attention-1 0x%x\n", val);
3039 if (attn & HW_INTERRUT_ASSERT_SET_2) {
3041 int port = BP_PORT(bp);
3044 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_2 :
3045 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_2);
3047 val = REG_RD(bp, reg_offset);
3048 val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
3049 REG_WR(bp, reg_offset, val);
3051 BNX2X_ERR("FATAL HW block attention set2 0x%x\n",
3052 (u32)(attn & HW_INTERRUT_ASSERT_SET_2));
3057 static inline void bnx2x_attn_int_deasserted3(struct bnx2x *bp, u32 attn)
3061 if (attn & EVEREST_GEN_ATTN_IN_USE_MASK) {
3063 if (attn & BNX2X_PMF_LINK_ASSERT) {
3064 int func = BP_FUNC(bp);
3066 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
3067 bp->mf_config[BP_VN(bp)] = MF_CFG_RD(bp,
3068 func_mf_config[BP_ABS_FUNC(bp)].config);
3070 func_mb[BP_FW_MB_IDX(bp)].drv_status);
3071 if (val & DRV_STATUS_DCC_EVENT_MASK)
3073 (val & DRV_STATUS_DCC_EVENT_MASK));
3075 if (val & DRV_STATUS_SET_MF_BW)
3076 bnx2x_set_mf_bw(bp);
3078 if ((bp->port.pmf == 0) && (val & DRV_STATUS_PMF))
3079 bnx2x_pmf_update(bp);
3081 /* Always call it here: bnx2x_link_report() will
3082 * prevent the link indication duplication.
3084 bnx2x__link_status_update(bp);
3087 (val & DRV_STATUS_DCBX_NEGOTIATION_RESULTS) &&
3088 bp->dcbx_enabled > 0)
3089 /* start dcbx state machine */
3090 bnx2x_dcbx_set_params(bp,
3091 BNX2X_DCBX_STATE_NEG_RECEIVED);
3092 } else if (attn & BNX2X_MC_ASSERT_BITS) {
3094 BNX2X_ERR("MC assert!\n");
3095 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_10, 0);
3096 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_9, 0);
3097 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_8, 0);
3098 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_7, 0);
3101 } else if (attn & BNX2X_MCP_ASSERT) {
3103 BNX2X_ERR("MCP assert!\n");
3104 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_11, 0);
3108 BNX2X_ERR("Unknown HW assert! (attn 0x%x)\n", attn);
3111 if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
3112 BNX2X_ERR("LATCHED attention 0x%08x (masked)\n", attn);
3113 if (attn & BNX2X_GRC_TIMEOUT) {
3114 val = CHIP_IS_E1(bp) ? 0 :
3115 REG_RD(bp, MISC_REG_GRC_TIMEOUT_ATTN);
3116 BNX2X_ERR("GRC time-out 0x%08x\n", val);
3118 if (attn & BNX2X_GRC_RSV) {
3119 val = CHIP_IS_E1(bp) ? 0 :
3120 REG_RD(bp, MISC_REG_GRC_RSV_ATTN);
3121 BNX2X_ERR("GRC reserved 0x%08x\n", val);
3123 REG_WR(bp, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
3127 #define BNX2X_MISC_GEN_REG MISC_REG_GENERIC_POR_1
3128 #define LOAD_COUNTER_BITS 16 /* Number of bits for load counter */
3129 #define LOAD_COUNTER_MASK (((u32)0x1 << LOAD_COUNTER_BITS) - 1)
3130 #define RESET_DONE_FLAG_MASK (~LOAD_COUNTER_MASK)
3131 #define RESET_DONE_FLAG_SHIFT LOAD_COUNTER_BITS
3134 * should be run under rtnl lock
3136 static inline void bnx2x_set_reset_done(struct bnx2x *bp)
3138 u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3139 val &= ~(1 << RESET_DONE_FLAG_SHIFT);
3140 REG_WR(bp, BNX2X_MISC_GEN_REG, val);
3146 * should be run under rtnl lock
3148 static inline void bnx2x_set_reset_in_progress(struct bnx2x *bp)
3150 u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3152 REG_WR(bp, BNX2X_MISC_GEN_REG, val);
3158 * should be run under rtnl lock
3160 bool bnx2x_reset_is_done(struct bnx2x *bp)
3162 u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3163 DP(NETIF_MSG_HW, "GEN_REG_VAL=0x%08x\n", val);
3164 return (val & RESET_DONE_FLAG_MASK) ? false : true;
3168 * should be run under rtnl lock
3170 inline void bnx2x_inc_load_cnt(struct bnx2x *bp)
3172 u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3174 DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
3176 val1 = ((val & LOAD_COUNTER_MASK) + 1) & LOAD_COUNTER_MASK;
3177 REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
3183 * should be run under rtnl lock
3185 u32 bnx2x_dec_load_cnt(struct bnx2x *bp)
3187 u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3189 DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
3191 val1 = ((val & LOAD_COUNTER_MASK) - 1) & LOAD_COUNTER_MASK;
3192 REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
3200 * should be run under rtnl lock
3202 static inline u32 bnx2x_get_load_cnt(struct bnx2x *bp)
3204 return REG_RD(bp, BNX2X_MISC_GEN_REG) & LOAD_COUNTER_MASK;
3207 static inline void bnx2x_clear_load_cnt(struct bnx2x *bp)
3209 u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3210 REG_WR(bp, BNX2X_MISC_GEN_REG, val & (~LOAD_COUNTER_MASK));
3213 static inline void _print_next_block(int idx, const char *blk)
3220 static inline int bnx2x_print_blocks_with_parity0(u32 sig, int par_num)
3224 for (i = 0; sig; i++) {
3225 cur_bit = ((u32)0x1 << i);
3226 if (sig & cur_bit) {
3228 case AEU_INPUTS_ATTN_BITS_BRB_PARITY_ERROR:
3229 _print_next_block(par_num++, "BRB");
3231 case AEU_INPUTS_ATTN_BITS_PARSER_PARITY_ERROR:
3232 _print_next_block(par_num++, "PARSER");
3234 case AEU_INPUTS_ATTN_BITS_TSDM_PARITY_ERROR:
3235 _print_next_block(par_num++, "TSDM");
3237 case AEU_INPUTS_ATTN_BITS_SEARCHER_PARITY_ERROR:
3238 _print_next_block(par_num++, "SEARCHER");
3240 case AEU_INPUTS_ATTN_BITS_TSEMI_PARITY_ERROR:
3241 _print_next_block(par_num++, "TSEMI");
3253 static inline int bnx2x_print_blocks_with_parity1(u32 sig, int par_num)
3257 for (i = 0; sig; i++) {
3258 cur_bit = ((u32)0x1 << i);
3259 if (sig & cur_bit) {
3261 case AEU_INPUTS_ATTN_BITS_PBCLIENT_PARITY_ERROR:
3262 _print_next_block(par_num++, "PBCLIENT");
3264 case AEU_INPUTS_ATTN_BITS_QM_PARITY_ERROR:
3265 _print_next_block(par_num++, "QM");
3267 case AEU_INPUTS_ATTN_BITS_XSDM_PARITY_ERROR:
3268 _print_next_block(par_num++, "XSDM");
3270 case AEU_INPUTS_ATTN_BITS_XSEMI_PARITY_ERROR:
3271 _print_next_block(par_num++, "XSEMI");
3273 case AEU_INPUTS_ATTN_BITS_DOORBELLQ_PARITY_ERROR:
3274 _print_next_block(par_num++, "DOORBELLQ");
3276 case AEU_INPUTS_ATTN_BITS_VAUX_PCI_CORE_PARITY_ERROR:
3277 _print_next_block(par_num++, "VAUX PCI CORE");
3279 case AEU_INPUTS_ATTN_BITS_DEBUG_PARITY_ERROR:
3280 _print_next_block(par_num++, "DEBUG");
3282 case AEU_INPUTS_ATTN_BITS_USDM_PARITY_ERROR:
3283 _print_next_block(par_num++, "USDM");
3285 case AEU_INPUTS_ATTN_BITS_USEMI_PARITY_ERROR:
3286 _print_next_block(par_num++, "USEMI");
3288 case AEU_INPUTS_ATTN_BITS_UPB_PARITY_ERROR:
3289 _print_next_block(par_num++, "UPB");
3291 case AEU_INPUTS_ATTN_BITS_CSDM_PARITY_ERROR:
3292 _print_next_block(par_num++, "CSDM");
3304 static inline int bnx2x_print_blocks_with_parity2(u32 sig, int par_num)
3308 for (i = 0; sig; i++) {
3309 cur_bit = ((u32)0x1 << i);
3310 if (sig & cur_bit) {
3312 case AEU_INPUTS_ATTN_BITS_CSEMI_PARITY_ERROR:
3313 _print_next_block(par_num++, "CSEMI");
3315 case AEU_INPUTS_ATTN_BITS_PXP_PARITY_ERROR:
3316 _print_next_block(par_num++, "PXP");
3318 case AEU_IN_ATTN_BITS_PXPPCICLOCKCLIENT_PARITY_ERROR:
3319 _print_next_block(par_num++,
3320 "PXPPCICLOCKCLIENT");
3322 case AEU_INPUTS_ATTN_BITS_CFC_PARITY_ERROR:
3323 _print_next_block(par_num++, "CFC");
3325 case AEU_INPUTS_ATTN_BITS_CDU_PARITY_ERROR:
3326 _print_next_block(par_num++, "CDU");
3328 case AEU_INPUTS_ATTN_BITS_IGU_PARITY_ERROR:
3329 _print_next_block(par_num++, "IGU");
3331 case AEU_INPUTS_ATTN_BITS_MISC_PARITY_ERROR:
3332 _print_next_block(par_num++, "MISC");
3344 static inline int bnx2x_print_blocks_with_parity3(u32 sig, int par_num)
3348 for (i = 0; sig; i++) {
3349 cur_bit = ((u32)0x1 << i);
3350 if (sig & cur_bit) {
3352 case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_ROM_PARITY:
3353 _print_next_block(par_num++, "MCP ROM");
3355 case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_RX_PARITY:
3356 _print_next_block(par_num++, "MCP UMP RX");
3358 case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_TX_PARITY:
3359 _print_next_block(par_num++, "MCP UMP TX");
3361 case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_SCPAD_PARITY:
3362 _print_next_block(par_num++, "MCP SCPAD");
3374 static inline bool bnx2x_parity_attn(struct bnx2x *bp, u32 sig0, u32 sig1,
3377 if ((sig0 & HW_PRTY_ASSERT_SET_0) || (sig1 & HW_PRTY_ASSERT_SET_1) ||
3378 (sig2 & HW_PRTY_ASSERT_SET_2) || (sig3 & HW_PRTY_ASSERT_SET_3)) {
3380 DP(NETIF_MSG_HW, "Was parity error: HW block parity attention: "
3381 "[0]:0x%08x [1]:0x%08x "
3382 "[2]:0x%08x [3]:0x%08x\n",
3383 sig0 & HW_PRTY_ASSERT_SET_0,
3384 sig1 & HW_PRTY_ASSERT_SET_1,
3385 sig2 & HW_PRTY_ASSERT_SET_2,
3386 sig3 & HW_PRTY_ASSERT_SET_3);
3387 printk(KERN_ERR"%s: Parity errors detected in blocks: ",
3389 par_num = bnx2x_print_blocks_with_parity0(
3390 sig0 & HW_PRTY_ASSERT_SET_0, par_num);
3391 par_num = bnx2x_print_blocks_with_parity1(
3392 sig1 & HW_PRTY_ASSERT_SET_1, par_num);
3393 par_num = bnx2x_print_blocks_with_parity2(
3394 sig2 & HW_PRTY_ASSERT_SET_2, par_num);
3395 par_num = bnx2x_print_blocks_with_parity3(
3396 sig3 & HW_PRTY_ASSERT_SET_3, par_num);
3403 bool bnx2x_chk_parity_attn(struct bnx2x *bp)
3405 struct attn_route attn;
3406 int port = BP_PORT(bp);
3408 attn.sig[0] = REG_RD(bp,
3409 MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 +
3411 attn.sig[1] = REG_RD(bp,
3412 MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 +
3414 attn.sig[2] = REG_RD(bp,
3415 MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 +
3417 attn.sig[3] = REG_RD(bp,
3418 MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 +
3421 return bnx2x_parity_attn(bp, attn.sig[0], attn.sig[1], attn.sig[2],
3426 static inline void bnx2x_attn_int_deasserted4(struct bnx2x *bp, u32 attn)
3429 if (attn & AEU_INPUTS_ATTN_BITS_PGLUE_HW_INTERRUPT) {
3431 val = REG_RD(bp, PGLUE_B_REG_PGLUE_B_INT_STS_CLR);
3432 BNX2X_ERR("PGLUE hw attention 0x%x\n", val);
3433 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_ADDRESS_ERROR)
3434 BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3436 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_INCORRECT_RCV_BEHAVIOR)
3437 BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3438 "INCORRECT_RCV_BEHAVIOR\n");
3439 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN)
3440 BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3441 "WAS_ERROR_ATTN\n");
3442 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_VF_LENGTH_VIOLATION_ATTN)
3443 BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3444 "VF_LENGTH_VIOLATION_ATTN\n");
3446 PGLUE_B_PGLUE_B_INT_STS_REG_VF_GRC_SPACE_VIOLATION_ATTN)
3447 BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3448 "VF_GRC_SPACE_VIOLATION_ATTN\n");
3450 PGLUE_B_PGLUE_B_INT_STS_REG_VF_MSIX_BAR_VIOLATION_ATTN)
3451 BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3452 "VF_MSIX_BAR_VIOLATION_ATTN\n");
3453 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_ERROR_ATTN)
3454 BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3455 "TCPL_ERROR_ATTN\n");
3456 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_IN_TWO_RCBS_ATTN)
3457 BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3458 "TCPL_IN_TWO_RCBS_ATTN\n");
3459 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_CSSNOOP_FIFO_OVERFLOW)
3460 BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3461 "CSSNOOP_FIFO_OVERFLOW\n");
3463 if (attn & AEU_INPUTS_ATTN_BITS_ATC_HW_INTERRUPT) {
3464 val = REG_RD(bp, ATC_REG_ATC_INT_STS_CLR);
3465 BNX2X_ERR("ATC hw attention 0x%x\n", val);
3466 if (val & ATC_ATC_INT_STS_REG_ADDRESS_ERROR)
3467 BNX2X_ERR("ATC_ATC_INT_STS_REG_ADDRESS_ERROR\n");
3468 if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_TO_NOT_PEND)
3469 BNX2X_ERR("ATC_ATC_INT_STS_REG"
3470 "_ATC_TCPL_TO_NOT_PEND\n");
3471 if (val & ATC_ATC_INT_STS_REG_ATC_GPA_MULTIPLE_HITS)
3472 BNX2X_ERR("ATC_ATC_INT_STS_REG_"
3473 "ATC_GPA_MULTIPLE_HITS\n");
3474 if (val & ATC_ATC_INT_STS_REG_ATC_RCPL_TO_EMPTY_CNT)
3475 BNX2X_ERR("ATC_ATC_INT_STS_REG_"
3476 "ATC_RCPL_TO_EMPTY_CNT\n");
3477 if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR)
3478 BNX2X_ERR("ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR\n");
3479 if (val & ATC_ATC_INT_STS_REG_ATC_IREQ_LESS_THAN_STU)
3480 BNX2X_ERR("ATC_ATC_INT_STS_REG_"
3481 "ATC_IREQ_LESS_THAN_STU\n");
3484 if (attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
3485 AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)) {
3486 BNX2X_ERR("FATAL parity attention set4 0x%x\n",
3487 (u32)(attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
3488 AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)));
3493 static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
3495 struct attn_route attn, *group_mask;
3496 int port = BP_PORT(bp);
3502 /* need to take HW lock because MCP or other port might also
3503 try to handle this event */
3504 bnx2x_acquire_alr(bp);
3506 if (CHIP_PARITY_ENABLED(bp) && bnx2x_chk_parity_attn(bp)) {
3507 bp->recovery_state = BNX2X_RECOVERY_INIT;
3508 bnx2x_set_reset_in_progress(bp);
3509 schedule_delayed_work(&bp->reset_task, 0);
3510 /* Disable HW interrupts */
3511 bnx2x_int_disable(bp);
3512 bnx2x_release_alr(bp);
3513 /* In case of parity errors don't handle attentions so that
3514 * other function would "see" parity errors.
3519 attn.sig[0] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + port*4);
3520 attn.sig[1] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
3521 attn.sig[2] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
3522 attn.sig[3] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
3525 REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_5_FUNC_0 + port*4);
3529 DP(NETIF_MSG_HW, "attn: %08x %08x %08x %08x %08x\n",
3530 attn.sig[0], attn.sig[1], attn.sig[2], attn.sig[3], attn.sig[4]);
3532 for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
3533 if (deasserted & (1 << index)) {
3534 group_mask = &bp->attn_group[index];
3536 DP(NETIF_MSG_HW, "group[%d]: %08x %08x "
3539 group_mask->sig[0], group_mask->sig[1],
3540 group_mask->sig[2], group_mask->sig[3],
3541 group_mask->sig[4]);
3543 bnx2x_attn_int_deasserted4(bp,
3544 attn.sig[4] & group_mask->sig[4]);
3545 bnx2x_attn_int_deasserted3(bp,
3546 attn.sig[3] & group_mask->sig[3]);
3547 bnx2x_attn_int_deasserted1(bp,
3548 attn.sig[1] & group_mask->sig[1]);
3549 bnx2x_attn_int_deasserted2(bp,
3550 attn.sig[2] & group_mask->sig[2]);
3551 bnx2x_attn_int_deasserted0(bp,
3552 attn.sig[0] & group_mask->sig[0]);
3556 bnx2x_release_alr(bp);
3558 if (bp->common.int_block == INT_BLOCK_HC)
3559 reg_addr = (HC_REG_COMMAND_REG + port*32 +
3560 COMMAND_REG_ATTN_BITS_CLR);
3562 reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_CLR_UPPER*8);
3565 DP(NETIF_MSG_HW, "about to mask 0x%08x at %s addr 0x%x\n", val,
3566 (bp->common.int_block == INT_BLOCK_HC) ? "HC" : "IGU", reg_addr);
3567 REG_WR(bp, reg_addr, val);
3569 if (~bp->attn_state & deasserted)
3570 BNX2X_ERR("IGU ERROR\n");
3572 reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
3573 MISC_REG_AEU_MASK_ATTN_FUNC_0;
3575 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
3576 aeu_mask = REG_RD(bp, reg_addr);
3578 DP(NETIF_MSG_HW, "aeu_mask %x newly deasserted %x\n",
3579 aeu_mask, deasserted);
3580 aeu_mask |= (deasserted & 0x3ff);
3581 DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
3583 REG_WR(bp, reg_addr, aeu_mask);
3584 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
3586 DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
3587 bp->attn_state &= ~deasserted;
3588 DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
3591 static void bnx2x_attn_int(struct bnx2x *bp)
3593 /* read local copy of bits */
3594 u32 attn_bits = le32_to_cpu(bp->def_status_blk->atten_status_block.
3596 u32 attn_ack = le32_to_cpu(bp->def_status_blk->atten_status_block.
3598 u32 attn_state = bp->attn_state;
3600 /* look for changed bits */
3601 u32 asserted = attn_bits & ~attn_ack & ~attn_state;
3602 u32 deasserted = ~attn_bits & attn_ack & attn_state;
3605 "attn_bits %x attn_ack %x asserted %x deasserted %x\n",
3606 attn_bits, attn_ack, asserted, deasserted);
3608 if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state))
3609 BNX2X_ERR("BAD attention state\n");
3611 /* handle bits that were raised */
3613 bnx2x_attn_int_asserted(bp, asserted);
3616 bnx2x_attn_int_deasserted(bp, deasserted);
3619 static inline void bnx2x_update_eq_prod(struct bnx2x *bp, u16 prod)
3621 /* No memory barriers */
3622 storm_memset_eq_prod(bp, prod, BP_FUNC(bp));
3623 mmiowb(); /* keep prod updates ordered */
3627 static int bnx2x_cnic_handle_cfc_del(struct bnx2x *bp, u32 cid,
3628 union event_ring_elem *elem)
3630 if (!bp->cnic_eth_dev.starting_cid ||
3631 (cid < bp->cnic_eth_dev.starting_cid &&
3632 cid != bp->cnic_eth_dev.iscsi_l2_cid))
3635 DP(BNX2X_MSG_SP, "got delete ramrod for CNIC CID %d\n", cid);
3637 if (unlikely(elem->message.data.cfc_del_event.error)) {
3638 BNX2X_ERR("got delete ramrod for CNIC CID %d with error!\n",
3640 bnx2x_panic_dump(bp);
3642 bnx2x_cnic_cfc_comp(bp, cid);
3647 static void bnx2x_eq_int(struct bnx2x *bp)
3649 u16 hw_cons, sw_cons, sw_prod;
3650 union event_ring_elem *elem;
3655 hw_cons = le16_to_cpu(*bp->eq_cons_sb);
3657 /* The hw_cos range is 1-255, 257 - the sw_cons range is 0-254, 256.
3658 * when we get the the next-page we nned to adjust so the loop
3659 * condition below will be met. The next element is the size of a
3660 * regular element and hence incrementing by 1
3662 if ((hw_cons & EQ_DESC_MAX_PAGE) == EQ_DESC_MAX_PAGE)
3665 /* This function may never run in parallel with itself for a
3666 * specific bp, thus there is no need in "paired" read memory
3669 sw_cons = bp->eq_cons;
3670 sw_prod = bp->eq_prod;
3672 DP(BNX2X_MSG_SP, "EQ: hw_cons %u sw_cons %u bp->cq_spq_left %u\n",
3673 hw_cons, sw_cons, atomic_read(&bp->eq_spq_left));
3675 for (; sw_cons != hw_cons;
3676 sw_prod = NEXT_EQ_IDX(sw_prod), sw_cons = NEXT_EQ_IDX(sw_cons)) {
3679 elem = &bp->eq_ring[EQ_DESC(sw_cons)];
3681 cid = SW_CID(elem->message.data.cfc_del_event.cid);
3682 opcode = elem->message.opcode;
3685 /* handle eq element */
3687 case EVENT_RING_OPCODE_STAT_QUERY:
3688 DP(NETIF_MSG_TIMER, "got statistics comp event\n");
3689 /* nothing to do with stats comp */
3692 case EVENT_RING_OPCODE_CFC_DEL:
3693 /* handle according to cid range */
3695 * we may want to verify here that the bp state is
3698 DP(NETIF_MSG_IFDOWN,
3699 "got delete ramrod for MULTI[%d]\n", cid);
3701 if (!bnx2x_cnic_handle_cfc_del(bp, cid, elem))
3703 if (cid == BNX2X_FCOE_ETH_CID)
3704 bnx2x_fcoe(bp, state) = BNX2X_FP_STATE_CLOSED;
3707 bnx2x_fp(bp, cid, state) =
3708 BNX2X_FP_STATE_CLOSED;
3712 case EVENT_RING_OPCODE_STOP_TRAFFIC:
3713 DP(NETIF_MSG_IFUP, "got STOP TRAFFIC\n");
3714 bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_TX_PAUSED);
3716 case EVENT_RING_OPCODE_START_TRAFFIC:
3717 DP(NETIF_MSG_IFUP, "got START TRAFFIC\n");
3718 bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_TX_RELEASED);
3722 switch (opcode | bp->state) {
3723 case (EVENT_RING_OPCODE_FUNCTION_START |
3724 BNX2X_STATE_OPENING_WAIT4_PORT):
3725 DP(NETIF_MSG_IFUP, "got setup ramrod\n");
3726 bp->state = BNX2X_STATE_FUNC_STARTED;
3729 case (EVENT_RING_OPCODE_FUNCTION_STOP |
3730 BNX2X_STATE_CLOSING_WAIT4_HALT):
3731 DP(NETIF_MSG_IFDOWN, "got halt ramrod\n");
3732 bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
3735 case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_OPEN):
3736 case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_DIAG):
3737 DP(NETIF_MSG_IFUP, "got set mac ramrod\n");
3738 if (elem->message.data.set_mac_event.echo)
3739 bp->set_mac_pending = 0;
3742 case (EVENT_RING_OPCODE_SET_MAC |
3743 BNX2X_STATE_CLOSING_WAIT4_HALT):
3744 DP(NETIF_MSG_IFDOWN, "got (un)set mac ramrod\n");
3745 if (elem->message.data.set_mac_event.echo)
3746 bp->set_mac_pending = 0;
3749 /* unknown event log error and continue */
3750 BNX2X_ERR("Unknown EQ event %d\n",
3751 elem->message.opcode);
3757 smp_mb__before_atomic_inc();
3758 atomic_add(spqe_cnt, &bp->eq_spq_left);
3760 bp->eq_cons = sw_cons;
3761 bp->eq_prod = sw_prod;
3762 /* Make sure that above mem writes were issued towards the memory */
3765 /* update producer */
3766 bnx2x_update_eq_prod(bp, bp->eq_prod);
3769 static void bnx2x_sp_task(struct work_struct *work)
3771 struct bnx2x *bp = container_of(work, struct bnx2x, sp_task.work);
3774 /* Return here if interrupt is disabled */
3775 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3776 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3780 status = bnx2x_update_dsb_idx(bp);
3781 /* if (status == 0) */
3782 /* BNX2X_ERR("spurious slowpath interrupt!\n"); */
3784 DP(NETIF_MSG_INTR, "got a slowpath interrupt (status 0x%x)\n", status);
3787 if (status & BNX2X_DEF_SB_ATT_IDX) {
3789 status &= ~BNX2X_DEF_SB_ATT_IDX;
3792 /* SP events: STAT_QUERY and others */
3793 if (status & BNX2X_DEF_SB_IDX) {
3795 struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);
3797 if ((!NO_FCOE(bp)) &&
3798 (bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp)))
3799 napi_schedule(&bnx2x_fcoe(bp, napi));
3801 /* Handle EQ completions */
3804 bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID,
3805 le16_to_cpu(bp->def_idx), IGU_INT_NOP, 1);
3807 status &= ~BNX2X_DEF_SB_IDX;
3810 if (unlikely(status))
3811 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
3814 bnx2x_ack_sb(bp, bp->igu_dsb_id, ATTENTION_ID,
3815 le16_to_cpu(bp->def_att_idx), IGU_INT_ENABLE, 1);
3818 irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
3820 struct net_device *dev = dev_instance;
3821 struct bnx2x *bp = netdev_priv(dev);
3823 /* Return here if interrupt is disabled */
3824 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3825 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3829 bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID, 0,
3830 IGU_INT_DISABLE, 0);
3832 #ifdef BNX2X_STOP_ON_ERROR
3833 if (unlikely(bp->panic))
3839 struct cnic_ops *c_ops;
3842 c_ops = rcu_dereference(bp->cnic_ops);
3844 c_ops->cnic_handler(bp->cnic_data, NULL);
3848 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
3853 /* end of slow path */
3855 static void bnx2x_timer(unsigned long data)
3857 struct bnx2x *bp = (struct bnx2x *) data;
3859 if (!netif_running(bp->dev))
3862 if (atomic_read(&bp->intr_sem) != 0)
3866 struct bnx2x_fastpath *fp = &bp->fp[0];
3869 bnx2x_rx_int(fp, 1000);
3872 if (!BP_NOMCP(bp)) {
3873 int mb_idx = BP_FW_MB_IDX(bp);
3877 ++bp->fw_drv_pulse_wr_seq;
3878 bp->fw_drv_pulse_wr_seq &= DRV_PULSE_SEQ_MASK;
3879 /* TBD - add SYSTEM_TIME */
3880 drv_pulse = bp->fw_drv_pulse_wr_seq;
3881 SHMEM_WR(bp, func_mb[mb_idx].drv_pulse_mb, drv_pulse);
3883 mcp_pulse = (SHMEM_RD(bp, func_mb[mb_idx].mcp_pulse_mb) &
3884 MCP_PULSE_SEQ_MASK);
3885 /* The delta between driver pulse and mcp response
3886 * should be 1 (before mcp response) or 0 (after mcp response)
3888 if ((drv_pulse != mcp_pulse) &&
3889 (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
3890 /* someone lost a heartbeat... */
3891 BNX2X_ERR("drv_pulse (0x%x) != mcp_pulse (0x%x)\n",
3892 drv_pulse, mcp_pulse);
3896 if (bp->state == BNX2X_STATE_OPEN)
3897 bnx2x_stats_handle(bp, STATS_EVENT_UPDATE);
3900 mod_timer(&bp->timer, jiffies + bp->current_interval);
3903 /* end of Statistics */
3908 * nic init service functions
3911 static inline void bnx2x_fill(struct bnx2x *bp, u32 addr, int fill, u32 len)
3914 if (!(len%4) && !(addr%4))
3915 for (i = 0; i < len; i += 4)
3916 REG_WR(bp, addr + i, fill);
3918 for (i = 0; i < len; i++)
3919 REG_WR8(bp, addr + i, fill);
3923 /* helper: writes FP SP data to FW - data_size in dwords */
3924 static inline void bnx2x_wr_fp_sb_data(struct bnx2x *bp,
3930 for (index = 0; index < data_size; index++)
3931 REG_WR(bp, BAR_CSTRORM_INTMEM +
3932 CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
3934 *(sb_data_p + index));
3937 static inline void bnx2x_zero_fp_sb(struct bnx2x *bp, int fw_sb_id)
3941 struct hc_status_block_data_e2 sb_data_e2;
3942 struct hc_status_block_data_e1x sb_data_e1x;
3944 /* disable the function first */
3945 if (CHIP_IS_E2(bp)) {
3946 memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
3947 sb_data_e2.common.p_func.pf_id = HC_FUNCTION_DISABLED;
3948 sb_data_e2.common.p_func.vf_id = HC_FUNCTION_DISABLED;
3949 sb_data_e2.common.p_func.vf_valid = false;
3950 sb_data_p = (u32 *)&sb_data_e2;
3951 data_size = sizeof(struct hc_status_block_data_e2)/sizeof(u32);
3953 memset(&sb_data_e1x, 0,
3954 sizeof(struct hc_status_block_data_e1x));
3955 sb_data_e1x.common.p_func.pf_id = HC_FUNCTION_DISABLED;
3956 sb_data_e1x.common.p_func.vf_id = HC_FUNCTION_DISABLED;
3957 sb_data_e1x.common.p_func.vf_valid = false;
3958 sb_data_p = (u32 *)&sb_data_e1x;
3959 data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
3961 bnx2x_wr_fp_sb_data(bp, fw_sb_id, sb_data_p, data_size);
3963 bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3964 CSTORM_STATUS_BLOCK_OFFSET(fw_sb_id), 0,
3965 CSTORM_STATUS_BLOCK_SIZE);
3966 bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3967 CSTORM_SYNC_BLOCK_OFFSET(fw_sb_id), 0,
3968 CSTORM_SYNC_BLOCK_SIZE);
3971 /* helper: writes SP SB data to FW */
3972 static inline void bnx2x_wr_sp_sb_data(struct bnx2x *bp,
3973 struct hc_sp_status_block_data *sp_sb_data)
3975 int func = BP_FUNC(bp);
3977 for (i = 0; i < sizeof(struct hc_sp_status_block_data)/sizeof(u32); i++)
3978 REG_WR(bp, BAR_CSTRORM_INTMEM +
3979 CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
3981 *((u32 *)sp_sb_data + i));
3984 static inline void bnx2x_zero_sp_sb(struct bnx2x *bp)
3986 int func = BP_FUNC(bp);
3987 struct hc_sp_status_block_data sp_sb_data;
3988 memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
3990 sp_sb_data.p_func.pf_id = HC_FUNCTION_DISABLED;
3991 sp_sb_data.p_func.vf_id = HC_FUNCTION_DISABLED;
3992 sp_sb_data.p_func.vf_valid = false;
3994 bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
3996 bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
3997 CSTORM_SP_STATUS_BLOCK_OFFSET(func), 0,
3998 CSTORM_SP_STATUS_BLOCK_SIZE);
3999 bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
4000 CSTORM_SP_SYNC_BLOCK_OFFSET(func), 0,
4001 CSTORM_SP_SYNC_BLOCK_SIZE);
4007 void bnx2x_setup_ndsb_state_machine(struct hc_status_block_sm *hc_sm,
4008 int igu_sb_id, int igu_seg_id)
4010 hc_sm->igu_sb_id = igu_sb_id;
4011 hc_sm->igu_seg_id = igu_seg_id;
4012 hc_sm->timer_value = 0xFF;
4013 hc_sm->time_to_expire = 0xFFFFFFFF;
4016 static void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
4017 u8 vf_valid, int fw_sb_id, int igu_sb_id)
4021 struct hc_status_block_data_e2 sb_data_e2;
4022 struct hc_status_block_data_e1x sb_data_e1x;
4023 struct hc_status_block_sm *hc_sm_p;
4027 if (CHIP_INT_MODE_IS_BC(bp))
4028 igu_seg_id = HC_SEG_ACCESS_NORM;
4030 igu_seg_id = IGU_SEG_ACCESS_NORM;
4032 bnx2x_zero_fp_sb(bp, fw_sb_id);
4034 if (CHIP_IS_E2(bp)) {
4035 memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
4036 sb_data_e2.common.p_func.pf_id = BP_FUNC(bp);
4037 sb_data_e2.common.p_func.vf_id = vfid;
4038 sb_data_e2.common.p_func.vf_valid = vf_valid;
4039 sb_data_e2.common.p_func.vnic_id = BP_VN(bp);
4040 sb_data_e2.common.same_igu_sb_1b = true;
4041 sb_data_e2.common.host_sb_addr.hi = U64_HI(mapping);
4042 sb_data_e2.common.host_sb_addr.lo = U64_LO(mapping);
4043 hc_sm_p = sb_data_e2.common.state_machine;
4044 sb_data_p = (u32 *)&sb_data_e2;
4045 data_size = sizeof(struct hc_status_block_data_e2)/sizeof(u32);
4047 memset(&sb_data_e1x, 0,
4048 sizeof(struct hc_status_block_data_e1x));
4049 sb_data_e1x.common.p_func.pf_id = BP_FUNC(bp);
4050 sb_data_e1x.common.p_func.vf_id = 0xff;
4051 sb_data_e1x.common.p_func.vf_valid = false;
4052 sb_data_e1x.common.p_func.vnic_id = BP_VN(bp);
4053 sb_data_e1x.common.same_igu_sb_1b = true;
4054 sb_data_e1x.common.host_sb_addr.hi = U64_HI(mapping);
4055 sb_data_e1x.common.host_sb_addr.lo = U64_LO(mapping);
4056 hc_sm_p = sb_data_e1x.common.state_machine;
4057 sb_data_p = (u32 *)&sb_data_e1x;
4058 data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
4061 bnx2x_setup_ndsb_state_machine(&hc_sm_p[SM_RX_ID],
4062 igu_sb_id, igu_seg_id);
4063 bnx2x_setup_ndsb_state_machine(&hc_sm_p[SM_TX_ID],
4064 igu_sb_id, igu_seg_id);
4066 DP(NETIF_MSG_HW, "Init FW SB %d\n", fw_sb_id);
4068 /* write indecies to HW */
4069 bnx2x_wr_fp_sb_data(bp, fw_sb_id, sb_data_p, data_size);
4072 static void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, u16 fw_sb_id,
4073 u8 sb_index, u8 disable, u16 usec)
4075 int port = BP_PORT(bp);
4076 u8 ticks = usec / BNX2X_BTR;
4078 storm_memset_hc_timeout(bp, port, fw_sb_id, sb_index, ticks);
4080 disable = disable ? 1 : (usec ? 0 : 1);
4081 storm_memset_hc_disable(bp, port, fw_sb_id, sb_index, disable);
4084 static void bnx2x_update_coalesce_sb(struct bnx2x *bp, u16 fw_sb_id,
4085 u16 tx_usec, u16 rx_usec)
4087 bnx2x_update_coalesce_sb_index(bp, fw_sb_id, U_SB_ETH_RX_CQ_INDEX,
4089 bnx2x_update_coalesce_sb_index(bp, fw_sb_id, C_SB_ETH_TX_CQ_INDEX,
4093 static void bnx2x_init_def_sb(struct bnx2x *bp)
4095 struct host_sp_status_block *def_sb = bp->def_status_blk;
4096 dma_addr_t mapping = bp->def_status_blk_mapping;
4097 int igu_sp_sb_index;
4099 int port = BP_PORT(bp);
4100 int func = BP_FUNC(bp);
4104 struct hc_sp_status_block_data sp_sb_data;
4105 memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
4107 if (CHIP_INT_MODE_IS_BC(bp)) {
4108 igu_sp_sb_index = DEF_SB_IGU_ID;
4109 igu_seg_id = HC_SEG_ACCESS_DEF;
4111 igu_sp_sb_index = bp->igu_dsb_id;
4112 igu_seg_id = IGU_SEG_ACCESS_DEF;
4116 section = ((u64)mapping) + offsetof(struct host_sp_status_block,
4117 atten_status_block);
4118 def_sb->atten_status_block.status_block_id = igu_sp_sb_index;
4122 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
4123 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
4124 for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
4126 /* take care of sig[0]..sig[4] */
4127 for (sindex = 0; sindex < 4; sindex++)
4128 bp->attn_group[index].sig[sindex] =
4129 REG_RD(bp, reg_offset + sindex*0x4 + 0x10*index);
4133 * enable5 is separate from the rest of the registers,
4134 * and therefore the address skip is 4
4135 * and not 16 between the different groups
4137 bp->attn_group[index].sig[4] = REG_RD(bp,
4138 reg_offset + 0x10 + 0x4*index);
4140 bp->attn_group[index].sig[4] = 0;
4143 if (bp->common.int_block == INT_BLOCK_HC) {
4144 reg_offset = (port ? HC_REG_ATTN_MSG1_ADDR_L :
4145 HC_REG_ATTN_MSG0_ADDR_L);
4147 REG_WR(bp, reg_offset, U64_LO(section));
4148 REG_WR(bp, reg_offset + 4, U64_HI(section));
4149 } else if (CHIP_IS_E2(bp)) {
4150 REG_WR(bp, IGU_REG_ATTN_MSG_ADDR_L, U64_LO(section));
4151 REG_WR(bp, IGU_REG_ATTN_MSG_ADDR_H, U64_HI(section));
4154 section = ((u64)mapping) + offsetof(struct host_sp_status_block,
4157 bnx2x_zero_sp_sb(bp);
4159 sp_sb_data.host_sb_addr.lo = U64_LO(section);
4160 sp_sb_data.host_sb_addr.hi = U64_HI(section);
4161 sp_sb_data.igu_sb_id = igu_sp_sb_index;
4162 sp_sb_data.igu_seg_id = igu_seg_id;
4163 sp_sb_data.p_func.pf_id = func;
4164 sp_sb_data.p_func.vnic_id = BP_VN(bp);
4165 sp_sb_data.p_func.vf_id = 0xff;
4167 bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
4169 bp->stats_pending = 0;
4170 bp->set_mac_pending = 0;
4172 bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
4175 void bnx2x_update_coalesce(struct bnx2x *bp)
4179 for_each_eth_queue(bp, i)
4180 bnx2x_update_coalesce_sb(bp, bp->fp[i].fw_sb_id,
4181 bp->tx_ticks, bp->rx_ticks);
4184 static void bnx2x_init_sp_ring(struct bnx2x *bp)
4186 spin_lock_init(&bp->spq_lock);
4187 atomic_set(&bp->cq_spq_left, MAX_SPQ_PENDING);
4189 bp->spq_prod_idx = 0;
4190 bp->dsb_sp_prod = BNX2X_SP_DSB_INDEX;
4191 bp->spq_prod_bd = bp->spq;
4192 bp->spq_last_bd = bp->spq_prod_bd + MAX_SP_DESC_CNT;
4195 static void bnx2x_init_eq_ring(struct bnx2x *bp)
4198 for (i = 1; i <= NUM_EQ_PAGES; i++) {
4199 union event_ring_elem *elem =
4200 &bp->eq_ring[EQ_DESC_CNT_PAGE * i - 1];
4202 elem->next_page.addr.hi =
4203 cpu_to_le32(U64_HI(bp->eq_mapping +
4204 BCM_PAGE_SIZE * (i % NUM_EQ_PAGES)));
4205 elem->next_page.addr.lo =
4206 cpu_to_le32(U64_LO(bp->eq_mapping +
4207 BCM_PAGE_SIZE*(i % NUM_EQ_PAGES)));
4210 bp->eq_prod = NUM_EQ_DESC;
4211 bp->eq_cons_sb = BNX2X_EQ_INDEX;
4212 /* we want a warning message before it gets rought... */
4213 atomic_set(&bp->eq_spq_left,
4214 min_t(int, MAX_SP_DESC_CNT - MAX_SPQ_PENDING, NUM_EQ_DESC) - 1);
4217 void bnx2x_push_indir_table(struct bnx2x *bp)
4219 int func = BP_FUNC(bp);
4222 if (bp->multi_mode == ETH_RSS_MODE_DISABLED)
4225 for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
4226 REG_WR8(bp, BAR_TSTRORM_INTMEM +
4227 TSTORM_INDIRECTION_TABLE_OFFSET(func) + i,
4228 bp->fp->cl_id + bp->rx_indir_table[i]);
4231 static void bnx2x_init_ind_table(struct bnx2x *bp)
4235 for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
4236 bp->rx_indir_table[i] = i % BNX2X_NUM_ETH_QUEUES(bp);
4238 bnx2x_push_indir_table(bp);
4241 void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
4243 int mode = bp->rx_mode;
4244 int port = BP_PORT(bp);
4246 u32 def_q_filters = 0;
4248 /* All but management unicast packets should pass to the host as well */
4250 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_BRCST |
4251 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_MLCST |
4252 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_VLAN |
4253 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_NO_VLAN;
4256 case BNX2X_RX_MODE_NONE: /* no Rx */
4257 def_q_filters = BNX2X_ACCEPT_NONE;
4260 cl_id = bnx2x_fcoe(bp, cl_id);
4261 bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_NONE);
4266 case BNX2X_RX_MODE_NORMAL:
4267 def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST |
4268 BNX2X_ACCEPT_MULTICAST;
4271 cl_id = bnx2x_fcoe(bp, cl_id);
4272 bnx2x_rxq_set_mac_filters(bp, cl_id,
4273 BNX2X_ACCEPT_UNICAST |
4274 BNX2X_ACCEPT_MULTICAST);
4279 case BNX2X_RX_MODE_ALLMULTI:
4280 def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST |
4281 BNX2X_ACCEPT_ALL_MULTICAST;
4284 * Prevent duplication of multicast packets by configuring FCoE
4285 * L2 Client to receive only matched unicast frames.
4288 cl_id = bnx2x_fcoe(bp, cl_id);
4289 bnx2x_rxq_set_mac_filters(bp, cl_id,
4290 BNX2X_ACCEPT_UNICAST);
4295 case BNX2X_RX_MODE_PROMISC:
4296 def_q_filters |= BNX2X_PROMISCUOUS_MODE;
4299 * Prevent packets duplication by configuring DROP_ALL for FCoE
4303 cl_id = bnx2x_fcoe(bp, cl_id);
4304 bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_NONE);
4307 /* pass management unicast packets as well */
4308 llh_mask |= NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_UNCST;
4312 BNX2X_ERR("BAD rx mode (%d)\n", mode);
4316 cl_id = BP_L_ID(bp);
4317 bnx2x_rxq_set_mac_filters(bp, cl_id, def_q_filters);
4320 (port ? NIG_REG_LLH1_BRB1_DRV_MASK :
4321 NIG_REG_LLH0_BRB1_DRV_MASK), llh_mask);
4323 DP(NETIF_MSG_IFUP, "rx mode %d\n"
4324 "drop_ucast 0x%x\ndrop_mcast 0x%x\ndrop_bcast 0x%x\n"
4325 "accp_ucast 0x%x\naccp_mcast 0x%x\naccp_bcast 0x%x\n"
4326 "unmatched_ucast 0x%x\n", mode,
4327 bp->mac_filters.ucast_drop_all,
4328 bp->mac_filters.mcast_drop_all,
4329 bp->mac_filters.bcast_drop_all,
4330 bp->mac_filters.ucast_accept_all,
4331 bp->mac_filters.mcast_accept_all,
4332 bp->mac_filters.bcast_accept_all,
4333 bp->mac_filters.unmatched_unicast
4336 storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
4339 static void bnx2x_init_internal_common(struct bnx2x *bp)
4343 if (!CHIP_IS_E1(bp)) {
4345 /* xstorm needs to know whether to add ovlan to packets or not,
4346 * in switch-independent we'll write 0 to here... */
4347 REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNCTION_MODE_OFFSET,
4349 REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNCTION_MODE_OFFSET,
4351 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNCTION_MODE_OFFSET,
4353 REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNCTION_MODE_OFFSET,
4359 * In switch independent mode, the TSTORM needs to accept
4360 * packets that failed classification, since approximate match
4361 * mac addresses aren't written to NIG LLH
4363 REG_WR8(bp, BAR_TSTRORM_INTMEM +
4364 TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET, 2);
4366 /* Zero this manually as its initialization is
4367 currently missing in the initTool */
4368 for (i = 0; i < (USTORM_AGG_DATA_SIZE >> 2); i++)
4369 REG_WR(bp, BAR_USTRORM_INTMEM +
4370 USTORM_AGG_DATA_OFFSET + i * 4, 0);
4371 if (CHIP_IS_E2(bp)) {
4372 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_IGU_MODE_OFFSET,
4373 CHIP_INT_MODE_IS_BC(bp) ?
4374 HC_IGU_BC_MODE : HC_IGU_NBC_MODE);
4378 static void bnx2x_init_internal_port(struct bnx2x *bp)
4381 bnx2x_dcb_init_intmem_pfc(bp);
4384 static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
4386 switch (load_code) {
4387 case FW_MSG_CODE_DRV_LOAD_COMMON:
4388 case FW_MSG_CODE_DRV_LOAD_COMMON_CHIP:
4389 bnx2x_init_internal_common(bp);
4392 case FW_MSG_CODE_DRV_LOAD_PORT:
4393 bnx2x_init_internal_port(bp);
4396 case FW_MSG_CODE_DRV_LOAD_FUNCTION:
4397 /* internal memory per function is
4398 initialized inside bnx2x_pf_init */
4402 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
4407 static void bnx2x_init_fp_sb(struct bnx2x *bp, int fp_idx)
4409 struct bnx2x_fastpath *fp = &bp->fp[fp_idx];
4411 fp->state = BNX2X_FP_STATE_CLOSED;
4414 fp->cl_id = BP_L_ID(bp) + fp_idx;
4415 fp->fw_sb_id = bp->base_fw_ndsb + fp->cl_id + CNIC_CONTEXT_USE;
4416 fp->igu_sb_id = bp->igu_base_sb + fp_idx + CNIC_CONTEXT_USE;
4417 /* qZone id equals to FW (per path) client id */
4418 fp->cl_qzone_id = fp->cl_id +
4419 BP_PORT(bp)*(CHIP_IS_E2(bp) ? ETH_MAX_RX_CLIENTS_E2 :
4420 ETH_MAX_RX_CLIENTS_E1H);
4422 fp->ustorm_rx_prods_offset = CHIP_IS_E2(bp) ?
4423 USTORM_RX_PRODS_E2_OFFSET(fp->cl_qzone_id) :
4424 USTORM_RX_PRODS_E1X_OFFSET(BP_PORT(bp), fp->cl_id);
4425 /* Setup SB indicies */
4426 fp->rx_cons_sb = BNX2X_RX_SB_INDEX;
4427 fp->tx_cons_sb = BNX2X_TX_SB_INDEX;
4429 DP(NETIF_MSG_IFUP, "queue[%d]: bnx2x_init_sb(%p,%p) "
4430 "cl_id %d fw_sb %d igu_sb %d\n",
4431 fp_idx, bp, fp->status_blk.e1x_sb, fp->cl_id, fp->fw_sb_id,
4433 bnx2x_init_sb(bp, fp->status_blk_mapping, BNX2X_VF_ID_INVALID, false,
4434 fp->fw_sb_id, fp->igu_sb_id);
4436 bnx2x_update_fpsb_idx(fp);
4439 void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
4443 for_each_eth_queue(bp, i)
4444 bnx2x_init_fp_sb(bp, i);
4447 bnx2x_init_fcoe_fp(bp);
4449 bnx2x_init_sb(bp, bp->cnic_sb_mapping,
4450 BNX2X_VF_ID_INVALID, false,
4451 CNIC_SB_ID(bp), CNIC_IGU_SB_ID(bp));
4455 /* ensure status block indices were read */
4458 bnx2x_init_def_sb(bp);
4459 bnx2x_update_dsb_idx(bp);
4460 bnx2x_init_rx_rings(bp);
4461 bnx2x_init_tx_rings(bp);
4462 bnx2x_init_sp_ring(bp);
4463 bnx2x_init_eq_ring(bp);
4464 bnx2x_init_internal(bp, load_code);
4466 bnx2x_init_ind_table(bp);
4467 bnx2x_stats_init(bp);
4469 /* At this point, we are ready for interrupts */
4470 atomic_set(&bp->intr_sem, 0);
4472 /* flush all before enabling interrupts */
4476 bnx2x_int_enable(bp);
4478 /* Check for SPIO5 */
4479 bnx2x_attn_int_deasserted0(bp,
4480 REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + BP_PORT(bp)*4) &
4481 AEU_INPUTS_ATTN_BITS_SPIO5);
4484 /* end of nic init */
4487 * gzip service functions
4490 static int bnx2x_gunzip_init(struct bnx2x *bp)
4492 bp->gunzip_buf = dma_alloc_coherent(&bp->pdev->dev, FW_BUF_SIZE,
4493 &bp->gunzip_mapping, GFP_KERNEL);
4494 if (bp->gunzip_buf == NULL)
4497 bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL);
4498 if (bp->strm == NULL)
4501 bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(),
4503 if (bp->strm->workspace == NULL)
4513 dma_free_coherent(&bp->pdev->dev, FW_BUF_SIZE, bp->gunzip_buf,
4514 bp->gunzip_mapping);
4515 bp->gunzip_buf = NULL;
4518 netdev_err(bp->dev, "Cannot allocate firmware buffer for"
4519 " un-compression\n");
4523 static void bnx2x_gunzip_end(struct bnx2x *bp)
4526 kfree(bp->strm->workspace);
4531 if (bp->gunzip_buf) {
4532 dma_free_coherent(&bp->pdev->dev, FW_BUF_SIZE, bp->gunzip_buf,
4533 bp->gunzip_mapping);
4534 bp->gunzip_buf = NULL;
4538 static int bnx2x_gunzip(struct bnx2x *bp, const u8 *zbuf, int len)
4542 /* check gzip header */
4543 if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED)) {
4544 BNX2X_ERR("Bad gzip header\n");
4552 if (zbuf[3] & FNAME)
4553 while ((zbuf[n++] != 0) && (n < len));
4555 bp->strm->next_in = (typeof(bp->strm->next_in))zbuf + n;
4556 bp->strm->avail_in = len - n;
4557 bp->strm->next_out = bp->gunzip_buf;
4558 bp->strm->avail_out = FW_BUF_SIZE;
4560 rc = zlib_inflateInit2(bp->strm, -MAX_WBITS);
4564 rc = zlib_inflate(bp->strm, Z_FINISH);
4565 if ((rc != Z_OK) && (rc != Z_STREAM_END))
4566 netdev_err(bp->dev, "Firmware decompression error: %s\n",
4569 bp->gunzip_outlen = (FW_BUF_SIZE - bp->strm->avail_out);
4570 if (bp->gunzip_outlen & 0x3)
4571 netdev_err(bp->dev, "Firmware decompression error:"
4572 " gunzip_outlen (%d) not aligned\n",
4574 bp->gunzip_outlen >>= 2;
4576 zlib_inflateEnd(bp->strm);
4578 if (rc == Z_STREAM_END)
4584 /* nic load/unload */
4587 * General service functions
4590 /* send a NIG loopback debug packet */
4591 static void bnx2x_lb_pckt(struct bnx2x *bp)
4595 /* Ethernet source and destination addresses */
4596 wb_write[0] = 0x55555555;
4597 wb_write[1] = 0x55555555;
4598 wb_write[2] = 0x20; /* SOP */
4599 REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4601 /* NON-IP protocol */
4602 wb_write[0] = 0x09000000;
4603 wb_write[1] = 0x55555555;
4604 wb_write[2] = 0x10; /* EOP, eop_bvalid = 0 */
4605 REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4608 /* some of the internal memories
4609 * are not directly readable from the driver
4610 * to test them we send debug packets
4612 static int bnx2x_int_mem_test(struct bnx2x *bp)
4618 if (CHIP_REV_IS_FPGA(bp))
4620 else if (CHIP_REV_IS_EMUL(bp))
4625 /* Disable inputs of parser neighbor blocks */
4626 REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
4627 REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
4628 REG_WR(bp, CFC_REG_DEBUG0, 0x1);
4629 REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
4631 /* Write 0 to parser credits for CFC search request */
4632 REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
4634 /* send Ethernet packet */
4637 /* TODO do i reset NIG statistic? */
4638 /* Wait until NIG register shows 1 packet of size 0x10 */
4639 count = 1000 * factor;
4642 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
4643 val = *bnx2x_sp(bp, wb_data[0]);
4651 BNX2X_ERR("NIG timeout val = 0x%x\n", val);
4655 /* Wait until PRS register shows 1 packet */
4656 count = 1000 * factor;
4658 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4666 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
4670 /* Reset and init BRB, PRS */
4671 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
4673 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
4675 bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
4676 bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
4678 DP(NETIF_MSG_HW, "part2\n");
4680 /* Disable inputs of parser neighbor blocks */
4681 REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
4682 REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
4683 REG_WR(bp, CFC_REG_DEBUG0, 0x1);
4684 REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
4686 /* Write 0 to parser credits for CFC search request */
4687 REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
4689 /* send 10 Ethernet packets */
4690 for (i = 0; i < 10; i++)
4693 /* Wait until NIG register shows 10 + 1
4694 packets of size 11*0x10 = 0xb0 */
4695 count = 1000 * factor;
4698 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
4699 val = *bnx2x_sp(bp, wb_data[0]);
4707 BNX2X_ERR("NIG timeout val = 0x%x\n", val);
4711 /* Wait until PRS register shows 2 packets */
4712 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4714 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
4716 /* Write 1 to parser credits for CFC search request */
4717 REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x1);
4719 /* Wait until PRS register shows 3 packets */
4720 msleep(10 * factor);
4721 /* Wait until NIG register shows 1 packet of size 0x10 */
4722 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4724 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
4726 /* clear NIG EOP FIFO */
4727 for (i = 0; i < 11; i++)
4728 REG_RD(bp, NIG_REG_INGRESS_EOP_LB_FIFO);
4729 val = REG_RD(bp, NIG_REG_INGRESS_EOP_LB_EMPTY);
4731 BNX2X_ERR("clear of NIG failed\n");
4735 /* Reset and init BRB, PRS, NIG */
4736 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
4738 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
4740 bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
4741 bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
4744 REG_WR(bp, PRS_REG_NIC_MODE, 1);
4747 /* Enable inputs of parser neighbor blocks */
4748 REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x7fffffff);
4749 REG_WR(bp, TCM_REG_PRS_IFEN, 0x1);
4750 REG_WR(bp, CFC_REG_DEBUG0, 0x0);
4751 REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x1);
4753 DP(NETIF_MSG_HW, "done\n");
4758 static void bnx2x_enable_blocks_attention(struct bnx2x *bp)
4760 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
4762 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0x40);
4764 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0);
4765 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
4766 REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
4768 * mask read length error interrupts in brb for parser
4769 * (parsing unit and 'checksum and crc' unit)
4770 * these errors are legal (PU reads fixed length and CAC can cause
4771 * read length error on truncated packets)
4773 REG_WR(bp, BRB1_REG_BRB1_INT_MASK, 0xFC00);
4774 REG_WR(bp, QM_REG_QM_INT_MASK, 0);
4775 REG_WR(bp, TM_REG_TM_INT_MASK, 0);
4776 REG_WR(bp, XSDM_REG_XSDM_INT_MASK_0, 0);
4777 REG_WR(bp, XSDM_REG_XSDM_INT_MASK_1, 0);
4778 REG_WR(bp, XCM_REG_XCM_INT_MASK, 0);
4779 /* REG_WR(bp, XSEM_REG_XSEM_INT_MASK_0, 0); */
4780 /* REG_WR(bp, XSEM_REG_XSEM_INT_MASK_1, 0); */
4781 REG_WR(bp, USDM_REG_USDM_INT_MASK_0, 0);
4782 REG_WR(bp, USDM_REG_USDM_INT_MASK_1, 0);
4783 REG_WR(bp, UCM_REG_UCM_INT_MASK, 0);
4784 /* REG_WR(bp, USEM_REG_USEM_INT_MASK_0, 0); */
4785 /* REG_WR(bp, USEM_REG_USEM_INT_MASK_1, 0); */
4786 REG_WR(bp, GRCBASE_UPB + PB_REG_PB_INT_MASK, 0);
4787 REG_WR(bp, CSDM_REG_CSDM_INT_MASK_0, 0);
4788 REG_WR(bp, CSDM_REG_CSDM_INT_MASK_1, 0);
4789 REG_WR(bp, CCM_REG_CCM_INT_MASK, 0);
4790 /* REG_WR(bp, CSEM_REG_CSEM_INT_MASK_0, 0); */
4791 /* REG_WR(bp, CSEM_REG_CSEM_INT_MASK_1, 0); */
4793 if (CHIP_REV_IS_FPGA(bp))
4794 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x580000);
4795 else if (CHIP_IS_E2(bp))
4796 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0,
4797 (PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_OF
4798 | PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_AFT
4799 | PXP2_PXP2_INT_MASK_0_REG_PGL_PCIE_ATTN
4800 | PXP2_PXP2_INT_MASK_0_REG_PGL_READ_BLOCKED
4801 | PXP2_PXP2_INT_MASK_0_REG_PGL_WRITE_BLOCKED));
4803 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x480000);
4804 REG_WR(bp, TSDM_REG_TSDM_INT_MASK_0, 0);
4805 REG_WR(bp, TSDM_REG_TSDM_INT_MASK_1, 0);
4806 REG_WR(bp, TCM_REG_TCM_INT_MASK, 0);
4807 /* REG_WR(bp, TSEM_REG_TSEM_INT_MASK_0, 0); */
4808 /* REG_WR(bp, TSEM_REG_TSEM_INT_MASK_1, 0); */
4809 REG_WR(bp, CDU_REG_CDU_INT_MASK, 0);
4810 REG_WR(bp, DMAE_REG_DMAE_INT_MASK, 0);
4811 /* REG_WR(bp, MISC_REG_MISC_INT_MASK, 0); */
4812 REG_WR(bp, PBF_REG_PBF_INT_MASK, 0x18); /* bit 3,4 masked */
4815 static void bnx2x_reset_common(struct bnx2x *bp)
4818 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
4820 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
4823 static void bnx2x_init_pxp(struct bnx2x *bp)
4826 int r_order, w_order;
4828 pci_read_config_word(bp->pdev,
4829 bp->pcie_cap + PCI_EXP_DEVCTL, &devctl);
4830 DP(NETIF_MSG_HW, "read 0x%x from devctl\n", devctl);
4831 w_order = ((devctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
4833 r_order = ((devctl & PCI_EXP_DEVCTL_READRQ) >> 12);
4835 DP(NETIF_MSG_HW, "force read order to %d\n", bp->mrrs);
4839 bnx2x_init_pxp_arb(bp, r_order, w_order);
4842 static void bnx2x_setup_fan_failure_detection(struct bnx2x *bp)
4852 val = SHMEM_RD(bp, dev_info.shared_hw_config.config2) &
4853 SHARED_HW_CFG_FAN_FAILURE_MASK;
4855 if (val == SHARED_HW_CFG_FAN_FAILURE_ENABLED)
4859 * The fan failure mechanism is usually related to the PHY type since
4860 * the power consumption of the board is affected by the PHY. Currently,
4861 * fan is required for most designs with SFX7101, BCM8727 and BCM8481.
4863 else if (val == SHARED_HW_CFG_FAN_FAILURE_PHY_TYPE)
4864 for (port = PORT_0; port < PORT_MAX; port++) {
4866 bnx2x_fan_failure_det_req(
4868 bp->common.shmem_base,
4869 bp->common.shmem2_base,
4873 DP(NETIF_MSG_HW, "fan detection setting: %d\n", is_required);
4875 if (is_required == 0)
4878 /* Fan failure is indicated by SPIO 5 */
4879 bnx2x_set_spio(bp, MISC_REGISTERS_SPIO_5,
4880 MISC_REGISTERS_SPIO_INPUT_HI_Z);
4882 /* set to active low mode */
4883 val = REG_RD(bp, MISC_REG_SPIO_INT);
4884 val |= ((1 << MISC_REGISTERS_SPIO_5) <<
4885 MISC_REGISTERS_SPIO_INT_OLD_SET_POS);
4886 REG_WR(bp, MISC_REG_SPIO_INT, val);
4888 /* enable interrupt to signal the IGU */
4889 val = REG_RD(bp, MISC_REG_SPIO_EVENT_EN);
4890 val |= (1 << MISC_REGISTERS_SPIO_5);
4891 REG_WR(bp, MISC_REG_SPIO_EVENT_EN, val);
4894 static void bnx2x_pretend_func(struct bnx2x *bp, u8 pretend_func_num)
4900 if (CHIP_IS_E1H(bp) && (pretend_func_num >= E1H_FUNC_MAX))
4903 switch (BP_ABS_FUNC(bp)) {
4905 offset = PXP2_REG_PGL_PRETEND_FUNC_F0;
4908 offset = PXP2_REG_PGL_PRETEND_FUNC_F1;
4911 offset = PXP2_REG_PGL_PRETEND_FUNC_F2;
4914 offset = PXP2_REG_PGL_PRETEND_FUNC_F3;
4917 offset = PXP2_REG_PGL_PRETEND_FUNC_F4;
4920 offset = PXP2_REG_PGL_PRETEND_FUNC_F5;
4923 offset = PXP2_REG_PGL_PRETEND_FUNC_F6;
4926 offset = PXP2_REG_PGL_PRETEND_FUNC_F7;
4932 REG_WR(bp, offset, pretend_func_num);
4934 DP(NETIF_MSG_HW, "Pretending to func %d\n", pretend_func_num);
4937 static void bnx2x_pf_disable(struct bnx2x *bp)
4939 u32 val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
4940 val &= ~IGU_PF_CONF_FUNC_EN;
4942 REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
4943 REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 0);
4944 REG_WR(bp, CFC_REG_WEAK_ENABLE_PF, 0);
4947 static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
4951 DP(BNX2X_MSG_MCP, "starting common init func %d\n", BP_ABS_FUNC(bp));
4953 bnx2x_reset_common(bp);
4954 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
4955 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, 0xfffc);
4957 bnx2x_init_block(bp, MISC_BLOCK, COMMON_STAGE);
4958 if (!CHIP_IS_E1(bp))
4959 REG_WR(bp, MISC_REG_E1HMF_MODE, IS_MF(bp));
4961 if (CHIP_IS_E2(bp)) {
4965 * 4-port mode or 2-port mode we need to turn of master-enable
4966 * for everyone, after that, turn it back on for self.
4967 * so, we disregard multi-function or not, and always disable
4968 * for all functions on the given path, this means 0,2,4,6 for
4969 * path 0 and 1,3,5,7 for path 1
4971 for (fid = BP_PATH(bp); fid < E2_FUNC_MAX*2; fid += 2) {
4972 if (fid == BP_ABS_FUNC(bp)) {
4974 PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER,
4979 bnx2x_pretend_func(bp, fid);
4980 /* clear pf enable */
4981 bnx2x_pf_disable(bp);
4982 bnx2x_pretend_func(bp, BP_ABS_FUNC(bp));
4986 bnx2x_init_block(bp, PXP_BLOCK, COMMON_STAGE);
4987 if (CHIP_IS_E1(bp)) {
4988 /* enable HW interrupt from PXP on USDM overflow
4989 bit 16 on INT_MASK_0 */
4990 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
4993 bnx2x_init_block(bp, PXP2_BLOCK, COMMON_STAGE);
4997 REG_WR(bp, PXP2_REG_RQ_QM_ENDIAN_M, 1);
4998 REG_WR(bp, PXP2_REG_RQ_TM_ENDIAN_M, 1);
4999 REG_WR(bp, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
5000 REG_WR(bp, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
5001 REG_WR(bp, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
5002 /* make sure this value is 0 */
5003 REG_WR(bp, PXP2_REG_RQ_HC_ENDIAN_M, 0);
5005 /* REG_WR(bp, PXP2_REG_RD_PBF_SWAP_MODE, 1); */
5006 REG_WR(bp, PXP2_REG_RD_QM_SWAP_MODE, 1);
5007 REG_WR(bp, PXP2_REG_RD_TM_SWAP_MODE, 1);
5008 REG_WR(bp, PXP2_REG_RD_SRC_SWAP_MODE, 1);
5009 REG_WR(bp, PXP2_REG_RD_CDURD_SWAP_MODE, 1);
5012 bnx2x_ilt_init_page_size(bp, INITOP_SET);
5014 if (CHIP_REV_IS_FPGA(bp) && CHIP_IS_E1H(bp))
5015 REG_WR(bp, PXP2_REG_PGL_TAGS_LIMIT, 0x1);
5017 /* let the HW do it's magic ... */
5019 /* finish PXP init */
5020 val = REG_RD(bp, PXP2_REG_RQ_CFG_DONE);
5022 BNX2X_ERR("PXP2 CFG failed\n");
5025 val = REG_RD(bp, PXP2_REG_RD_INIT_DONE);
5027 BNX2X_ERR("PXP2 RD_INIT failed\n");
5031 /* Timers bug workaround E2 only. We need to set the entire ILT to
5032 * have entries with value "0" and valid bit on.
5033 * This needs to be done by the first PF that is loaded in a path
5034 * (i.e. common phase)
5036 if (CHIP_IS_E2(bp)) {
5037 struct ilt_client_info ilt_cli;
5038 struct bnx2x_ilt ilt;
5039 memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
5040 memset(&ilt, 0, sizeof(struct bnx2x_ilt));
5042 /* initialize dummy TM client */
5044 ilt_cli.end = ILT_NUM_PAGE_ENTRIES - 1;
5045 ilt_cli.client_num = ILT_CLIENT_TM;
5047 /* Step 1: set zeroes to all ilt page entries with valid bit on
5048 * Step 2: set the timers first/last ilt entry to point
5049 * to the entire range to prevent ILT range error for 3rd/4th
5050 * vnic (this code assumes existence of the vnic)
5052 * both steps performed by call to bnx2x_ilt_client_init_op()
5053 * with dummy TM client
5055 * we must use pretend since PXP2_REG_RQ_##blk##_FIRST_ILT
5056 * and his brother are split registers
5058 bnx2x_pretend_func(bp, (BP_PATH(bp) + 6));
5059 bnx2x_ilt_client_init_op_ilt(bp, &ilt, &ilt_cli, INITOP_CLEAR);
5060 bnx2x_pretend_func(bp, BP_ABS_FUNC(bp));
5062 REG_WR(bp, PXP2_REG_RQ_DRAM_ALIGN, BNX2X_PXP_DRAM_ALIGN);
5063 REG_WR(bp, PXP2_REG_RQ_DRAM_ALIGN_RD, BNX2X_PXP_DRAM_ALIGN);
5064 REG_WR(bp, PXP2_REG_RQ_DRAM_ALIGN_SEL, 1);
5068 REG_WR(bp, PXP2_REG_RQ_DISABLE_INPUTS, 0);
5069 REG_WR(bp, PXP2_REG_RD_DISABLE_INPUTS, 0);
5071 if (CHIP_IS_E2(bp)) {
5072 int factor = CHIP_REV_IS_EMUL(bp) ? 1000 :
5073 (CHIP_REV_IS_FPGA(bp) ? 400 : 0);
5074 bnx2x_init_block(bp, PGLUE_B_BLOCK, COMMON_STAGE);
5076 bnx2x_init_block(bp, ATC_BLOCK, COMMON_STAGE);
5078 /* let the HW do it's magic ... */
5081 val = REG_RD(bp, ATC_REG_ATC_INIT_DONE);
5082 } while (factor-- && (val != 1));
5085 BNX2X_ERR("ATC_INIT failed\n");
5090 bnx2x_init_block(bp, DMAE_BLOCK, COMMON_STAGE);
5092 /* clean the DMAE memory */
5094 bnx2x_init_fill(bp, TSEM_REG_PRAM, 0, 8);
5096 bnx2x_init_block(bp, TCM_BLOCK, COMMON_STAGE);
5097 bnx2x_init_block(bp, UCM_BLOCK, COMMON_STAGE);
5098 bnx2x_init_block(bp, CCM_BLOCK, COMMON_STAGE);
5099 bnx2x_init_block(bp, XCM_BLOCK, COMMON_STAGE);
5101 bnx2x_read_dmae(bp, XSEM_REG_PASSIVE_BUFFER, 3);
5102 bnx2x_read_dmae(bp, CSEM_REG_PASSIVE_BUFFER, 3);
5103 bnx2x_read_dmae(bp, TSEM_REG_PASSIVE_BUFFER, 3);
5104 bnx2x_read_dmae(bp, USEM_REG_PASSIVE_BUFFER, 3);
5106 bnx2x_init_block(bp, QM_BLOCK, COMMON_STAGE);
5108 if (CHIP_MODE_IS_4_PORT(bp))
5109 bnx2x_init_block(bp, QM_4PORT_BLOCK, COMMON_STAGE);
5111 /* QM queues pointers table */
5112 bnx2x_qm_init_ptr_table(bp, bp->qm_cid_count, INITOP_SET);
5114 /* soft reset pulse */
5115 REG_WR(bp, QM_REG_SOFT_RESET, 1);
5116 REG_WR(bp, QM_REG_SOFT_RESET, 0);
5119 bnx2x_init_block(bp, TIMERS_BLOCK, COMMON_STAGE);
5122 bnx2x_init_block(bp, DQ_BLOCK, COMMON_STAGE);
5123 REG_WR(bp, DORQ_REG_DPM_CID_OFST, BNX2X_DB_SHIFT);
5125 if (!CHIP_REV_IS_SLOW(bp)) {
5126 /* enable hw interrupt from doorbell Q */
5127 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
5130 bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
5131 if (CHIP_MODE_IS_4_PORT(bp)) {
5132 REG_WR(bp, BRB1_REG_FULL_LB_XOFF_THRESHOLD, 248);
5133 REG_WR(bp, BRB1_REG_FULL_LB_XON_THRESHOLD, 328);
5136 bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
5137 REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
5140 REG_WR(bp, PRS_REG_NIC_MODE, 1);
5142 if (!CHIP_IS_E1(bp))
5143 REG_WR(bp, PRS_REG_E1HOV_MODE, IS_MF_SD(bp));
5145 if (CHIP_IS_E2(bp)) {
5146 /* Bit-map indicating which L2 hdrs may appear after the
5147 basic Ethernet header */
5148 int has_ovlan = IS_MF_SD(bp);
5149 REG_WR(bp, PRS_REG_HDRS_AFTER_BASIC, (has_ovlan ? 7 : 6));
5150 REG_WR(bp, PRS_REG_MUST_HAVE_HDRS, (has_ovlan ? 1 : 0));
5153 bnx2x_init_block(bp, TSDM_BLOCK, COMMON_STAGE);
5154 bnx2x_init_block(bp, CSDM_BLOCK, COMMON_STAGE);
5155 bnx2x_init_block(bp, USDM_BLOCK, COMMON_STAGE);
5156 bnx2x_init_block(bp, XSDM_BLOCK, COMMON_STAGE);
5158 bnx2x_init_fill(bp, TSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5159 bnx2x_init_fill(bp, USEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5160 bnx2x_init_fill(bp, CSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5161 bnx2x_init_fill(bp, XSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5163 bnx2x_init_block(bp, TSEM_BLOCK, COMMON_STAGE);
5164 bnx2x_init_block(bp, USEM_BLOCK, COMMON_STAGE);
5165 bnx2x_init_block(bp, CSEM_BLOCK, COMMON_STAGE);
5166 bnx2x_init_block(bp, XSEM_BLOCK, COMMON_STAGE);
5168 if (CHIP_MODE_IS_4_PORT(bp))
5169 bnx2x_init_block(bp, XSEM_4PORT_BLOCK, COMMON_STAGE);
5172 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
5174 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
5177 bnx2x_init_block(bp, UPB_BLOCK, COMMON_STAGE);
5178 bnx2x_init_block(bp, XPB_BLOCK, COMMON_STAGE);
5179 bnx2x_init_block(bp, PBF_BLOCK, COMMON_STAGE);
5181 if (CHIP_IS_E2(bp)) {
5182 int has_ovlan = IS_MF_SD(bp);
5183 REG_WR(bp, PBF_REG_HDRS_AFTER_BASIC, (has_ovlan ? 7 : 6));
5184 REG_WR(bp, PBF_REG_MUST_HAVE_HDRS, (has_ovlan ? 1 : 0));
5187 REG_WR(bp, SRC_REG_SOFT_RST, 1);
5188 for (i = SRC_REG_KEYRSS0_0; i <= SRC_REG_KEYRSS1_9; i += 4)
5189 REG_WR(bp, i, random32());
5191 bnx2x_init_block(bp, SRCH_BLOCK, COMMON_STAGE);
5193 REG_WR(bp, SRC_REG_KEYSEARCH_0, 0x63285672);
5194 REG_WR(bp, SRC_REG_KEYSEARCH_1, 0x24b8f2cc);
5195 REG_WR(bp, SRC_REG_KEYSEARCH_2, 0x223aef9b);
5196 REG_WR(bp, SRC_REG_KEYSEARCH_3, 0x26001e3a);
5197 REG_WR(bp, SRC_REG_KEYSEARCH_4, 0x7ae91116);
5198 REG_WR(bp, SRC_REG_KEYSEARCH_5, 0x5ce5230b);
5199 REG_WR(bp, SRC_REG_KEYSEARCH_6, 0x298d8adf);
5200 REG_WR(bp, SRC_REG_KEYSEARCH_7, 0x6eb0ff09);
5201 REG_WR(bp, SRC_REG_KEYSEARCH_8, 0x1830f82f);
5202 REG_WR(bp, SRC_REG_KEYSEARCH_9, 0x01e46be7);
5204 REG_WR(bp, SRC_REG_SOFT_RST, 0);
5206 if (sizeof(union cdu_context) != 1024)
5207 /* we currently assume that a context is 1024 bytes */
5208 dev_alert(&bp->pdev->dev, "please adjust the size "
5209 "of cdu_context(%ld)\n",
5210 (long)sizeof(union cdu_context));
5212 bnx2x_init_block(bp, CDU_BLOCK, COMMON_STAGE);
5213 val = (4 << 24) + (0 << 12) + 1024;
5214 REG_WR(bp, CDU_REG_CDU_GLOBAL_PARAMS, val);
5216 bnx2x_init_block(bp, CFC_BLOCK, COMMON_STAGE);
5217 REG_WR(bp, CFC_REG_INIT_REG, 0x7FF);
5218 /* enable context validation interrupt from CFC */
5219 REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
5221 /* set the thresholds to prevent CFC/CDU race */
5222 REG_WR(bp, CFC_REG_DEBUG0, 0x20020000);
5224 bnx2x_init_block(bp, HC_BLOCK, COMMON_STAGE);
5226 if (CHIP_IS_E2(bp) && BP_NOMCP(bp))
5227 REG_WR(bp, IGU_REG_RESET_MEMORIES, 0x36);
5229 bnx2x_init_block(bp, IGU_BLOCK, COMMON_STAGE);
5230 bnx2x_init_block(bp, MISC_AEU_BLOCK, COMMON_STAGE);
5232 bnx2x_init_block(bp, PXPCS_BLOCK, COMMON_STAGE);
5233 /* Reset PCIE errors for debug */
5234 REG_WR(bp, 0x2814, 0xffffffff);
5235 REG_WR(bp, 0x3820, 0xffffffff);
5237 if (CHIP_IS_E2(bp)) {
5238 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_CONTROL_5,
5239 (PXPCS_TL_CONTROL_5_ERR_UNSPPORT1 |
5240 PXPCS_TL_CONTROL_5_ERR_UNSPPORT));
5241 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_FUNC345_STAT,
5242 (PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT4 |
5243 PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT3 |
5244 PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT2));
5245 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_FUNC678_STAT,
5246 (PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT7 |
5247 PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT6 |
5248 PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT5));
5251 bnx2x_init_block(bp, EMAC0_BLOCK, COMMON_STAGE);
5252 bnx2x_init_block(bp, EMAC1_BLOCK, COMMON_STAGE);
5253 bnx2x_init_block(bp, DBU_BLOCK, COMMON_STAGE);
5254 bnx2x_init_block(bp, DBG_BLOCK, COMMON_STAGE);
5256 bnx2x_init_block(bp, NIG_BLOCK, COMMON_STAGE);
5257 if (!CHIP_IS_E1(bp)) {
5258 REG_WR(bp, NIG_REG_LLH_MF_MODE, IS_MF(bp));
5259 REG_WR(bp, NIG_REG_LLH_E1HOV_MODE, IS_MF_SD(bp));
5261 if (CHIP_IS_E2(bp)) {
5262 /* Bit-map indicating which L2 hdrs may appear after the
5263 basic Ethernet header */
5264 REG_WR(bp, NIG_REG_P0_HDRS_AFTER_BASIC, (IS_MF_SD(bp) ? 7 : 6));
5267 if (CHIP_REV_IS_SLOW(bp))
5270 /* finish CFC init */
5271 val = reg_poll(bp, CFC_REG_LL_INIT_DONE, 1, 100, 10);
5273 BNX2X_ERR("CFC LL_INIT failed\n");
5276 val = reg_poll(bp, CFC_REG_AC_INIT_DONE, 1, 100, 10);
5278 BNX2X_ERR("CFC AC_INIT failed\n");
5281 val = reg_poll(bp, CFC_REG_CAM_INIT_DONE, 1, 100, 10);
5283 BNX2X_ERR("CFC CAM_INIT failed\n");
5286 REG_WR(bp, CFC_REG_DEBUG0, 0);
5288 if (CHIP_IS_E1(bp)) {
5289 /* read NIG statistic
5290 to see if this is our first up since powerup */
5291 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5292 val = *bnx2x_sp(bp, wb_data[0]);
5294 /* do internal memory self test */
5295 if ((val == 0) && bnx2x_int_mem_test(bp)) {
5296 BNX2X_ERR("internal mem self test failed\n");
5301 bnx2x_setup_fan_failure_detection(bp);
5303 /* clear PXP2 attentions */
5304 REG_RD(bp, PXP2_REG_PXP2_INT_STS_CLR_0);
5306 bnx2x_enable_blocks_attention(bp);
5307 if (CHIP_PARITY_ENABLED(bp))
5308 bnx2x_enable_blocks_parity(bp);
5310 if (!BP_NOMCP(bp)) {
5311 /* In E2 2-PORT mode, same ext phy is used for the two paths */
5312 if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) ||
5314 u32 shmem_base[2], shmem2_base[2];
5315 shmem_base[0] = bp->common.shmem_base;
5316 shmem2_base[0] = bp->common.shmem2_base;
5317 if (CHIP_IS_E2(bp)) {
5319 SHMEM2_RD(bp, other_shmem_base_addr);
5321 SHMEM2_RD(bp, other_shmem2_base_addr);
5323 bnx2x_acquire_phy_lock(bp);
5324 bnx2x_common_init_phy(bp, shmem_base, shmem2_base,
5325 bp->common.chip_id);
5326 bnx2x_release_phy_lock(bp);
5329 BNX2X_ERR("Bootcode is missing - can not initialize link\n");
5334 static int bnx2x_init_hw_port(struct bnx2x *bp)
5336 int port = BP_PORT(bp);
5337 int init_stage = port ? PORT1_STAGE : PORT0_STAGE;
5341 DP(BNX2X_MSG_MCP, "starting port init port %d\n", port);
5343 REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
5345 bnx2x_init_block(bp, PXP_BLOCK, init_stage);
5346 bnx2x_init_block(bp, PXP2_BLOCK, init_stage);
5348 /* Timers bug workaround: disables the pf_master bit in pglue at
5349 * common phase, we need to enable it here before any dmae access are
5350 * attempted. Therefore we manually added the enable-master to the
5351 * port phase (it also happens in the function phase)
5354 REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
5356 bnx2x_init_block(bp, TCM_BLOCK, init_stage);
5357 bnx2x_init_block(bp, UCM_BLOCK, init_stage);
5358 bnx2x_init_block(bp, CCM_BLOCK, init_stage);
5359 bnx2x_init_block(bp, XCM_BLOCK, init_stage);
5361 /* QM cid (connection) count */
5362 bnx2x_qm_init_cid_count(bp, bp->qm_cid_count, INITOP_SET);
5365 bnx2x_init_block(bp, TIMERS_BLOCK, init_stage);
5366 REG_WR(bp, TM_REG_LIN0_SCAN_TIME + port*4, 20);
5367 REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + port*4, 31);
5370 bnx2x_init_block(bp, DQ_BLOCK, init_stage);
5372 if (CHIP_MODE_IS_4_PORT(bp))
5373 bnx2x_init_block(bp, QM_4PORT_BLOCK, init_stage);
5375 if (CHIP_IS_E1(bp) || CHIP_IS_E1H(bp)) {
5376 bnx2x_init_block(bp, BRB1_BLOCK, init_stage);
5377 if (CHIP_REV_IS_SLOW(bp) && CHIP_IS_E1(bp)) {
5378 /* no pause for emulation and FPGA */
5383 low = ((bp->flags & ONE_PORT_FLAG) ? 160 : 246);
5384 else if (bp->dev->mtu > 4096) {
5385 if (bp->flags & ONE_PORT_FLAG)
5389 /* (24*1024 + val*4)/256 */
5390 low = 96 + (val/64) +
5391 ((val % 64) ? 1 : 0);
5394 low = ((bp->flags & ONE_PORT_FLAG) ? 80 : 160);
5395 high = low + 56; /* 14*1024/256 */
5397 REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_0 + port*4, low);
5398 REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_0 + port*4, high);
5401 if (CHIP_MODE_IS_4_PORT(bp)) {
5402 REG_WR(bp, BRB1_REG_PAUSE_0_XOFF_THRESHOLD_0 + port*8, 248);
5403 REG_WR(bp, BRB1_REG_PAUSE_0_XON_THRESHOLD_0 + port*8, 328);
5404 REG_WR(bp, (BP_PORT(bp) ? BRB1_REG_MAC_GUARANTIED_1 :
5405 BRB1_REG_MAC_GUARANTIED_0), 40);
5408 bnx2x_init_block(bp, PRS_BLOCK, init_stage);
5410 bnx2x_init_block(bp, TSDM_BLOCK, init_stage);
5411 bnx2x_init_block(bp, CSDM_BLOCK, init_stage);
5412 bnx2x_init_block(bp, USDM_BLOCK, init_stage);
5413 bnx2x_init_block(bp, XSDM_BLOCK, init_stage);
5415 bnx2x_init_block(bp, TSEM_BLOCK, init_stage);
5416 bnx2x_init_block(bp, USEM_BLOCK, init_stage);
5417 bnx2x_init_block(bp, CSEM_BLOCK, init_stage);
5418 bnx2x_init_block(bp, XSEM_BLOCK, init_stage);
5419 if (CHIP_MODE_IS_4_PORT(bp))
5420 bnx2x_init_block(bp, XSEM_4PORT_BLOCK, init_stage);
5422 bnx2x_init_block(bp, UPB_BLOCK, init_stage);
5423 bnx2x_init_block(bp, XPB_BLOCK, init_stage);
5425 bnx2x_init_block(bp, PBF_BLOCK, init_stage);
5427 if (!CHIP_IS_E2(bp)) {
5428 /* configure PBF to work without PAUSE mtu 9000 */
5429 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
5431 /* update threshold */
5432 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, (9040/16));
5433 /* update init credit */
5434 REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, (9040/16) + 553 - 22);
5437 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 1);
5439 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0);
5443 bnx2x_init_block(bp, SRCH_BLOCK, init_stage);
5445 bnx2x_init_block(bp, CDU_BLOCK, init_stage);
5446 bnx2x_init_block(bp, CFC_BLOCK, init_stage);
5448 if (CHIP_IS_E1(bp)) {
5449 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5450 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5452 bnx2x_init_block(bp, HC_BLOCK, init_stage);
5454 bnx2x_init_block(bp, IGU_BLOCK, init_stage);
5456 bnx2x_init_block(bp, MISC_AEU_BLOCK, init_stage);
5457 /* init aeu_mask_attn_func_0/1:
5458 * - SF mode: bits 3-7 are masked. only bits 0-2 are in use
5459 * - MF mode: bit 3 is masked. bits 0-2 are in use as in SF
5460 * bits 4-7 are used for "per vn group attention" */
5461 val = IS_MF(bp) ? 0xF7 : 0x7;
5462 /* Enable DCBX attention for all but E1 */
5463 val |= CHIP_IS_E1(bp) ? 0 : 0x10;
5464 REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, val);
5466 bnx2x_init_block(bp, PXPCS_BLOCK, init_stage);
5467 bnx2x_init_block(bp, EMAC0_BLOCK, init_stage);
5468 bnx2x_init_block(bp, EMAC1_BLOCK, init_stage);
5469 bnx2x_init_block(bp, DBU_BLOCK, init_stage);
5470 bnx2x_init_block(bp, DBG_BLOCK, init_stage);
5472 bnx2x_init_block(bp, NIG_BLOCK, init_stage);
5474 REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
5476 if (!CHIP_IS_E1(bp)) {
5477 /* 0x2 disable mf_ov, 0x1 enable */
5478 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK_MF + port*4,
5479 (IS_MF_SD(bp) ? 0x1 : 0x2));
5481 if (CHIP_IS_E2(bp)) {
5483 switch (bp->mf_mode) {
5484 case MULTI_FUNCTION_SD:
5487 case MULTI_FUNCTION_SI:
5492 REG_WR(bp, (BP_PORT(bp) ? NIG_REG_LLH1_CLS_TYPE :
5493 NIG_REG_LLH0_CLS_TYPE), val);
5496 REG_WR(bp, NIG_REG_LLFC_ENABLE_0 + port*4, 0);
5497 REG_WR(bp, NIG_REG_LLFC_OUT_EN_0 + port*4, 0);
5498 REG_WR(bp, NIG_REG_PAUSE_ENABLE_0 + port*4, 1);
5502 bnx2x_init_block(bp, MCP_BLOCK, init_stage);
5503 bnx2x_init_block(bp, DMAE_BLOCK, init_stage);
5504 if (bnx2x_fan_failure_det_req(bp, bp->common.shmem_base,
5505 bp->common.shmem2_base, port)) {
5506 u32 reg_addr = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
5507 MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
5508 val = REG_RD(bp, reg_addr);
5509 val |= AEU_INPUTS_ATTN_BITS_SPIO5;
5510 REG_WR(bp, reg_addr, val);
5512 bnx2x__link_reset(bp);
5517 static void bnx2x_ilt_wr(struct bnx2x *bp, u32 index, dma_addr_t addr)
5522 reg = PXP2_REG_RQ_ONCHIP_AT + index*8;
5524 reg = PXP2_REG_RQ_ONCHIP_AT_B0 + index*8;
5526 bnx2x_wb_wr(bp, reg, ONCHIP_ADDR1(addr), ONCHIP_ADDR2(addr));
5529 static inline void bnx2x_igu_clear_sb(struct bnx2x *bp, u8 idu_sb_id)
5531 bnx2x_igu_clear_sb_gen(bp, idu_sb_id, true /*PF*/);
5534 static inline void bnx2x_clear_func_ilt(struct bnx2x *bp, u32 func)
5536 u32 i, base = FUNC_ILT_BASE(func);
5537 for (i = base; i < base + ILT_PER_FUNC; i++)
5538 bnx2x_ilt_wr(bp, i, 0);
5541 static int bnx2x_init_hw_func(struct bnx2x *bp)
5543 int port = BP_PORT(bp);
5544 int func = BP_FUNC(bp);
5545 struct bnx2x_ilt *ilt = BP_ILT(bp);
5548 u32 main_mem_base, main_mem_size, main_mem_prty_clr;
5549 int i, main_mem_width;
5551 DP(BNX2X_MSG_MCP, "starting func init func %d\n", func);
5553 /* set MSI reconfigure capability */
5554 if (bp->common.int_block == INT_BLOCK_HC) {
5555 addr = (port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0);
5556 val = REG_RD(bp, addr);
5557 val |= HC_CONFIG_0_REG_MSI_ATTN_EN_0;
5558 REG_WR(bp, addr, val);
5562 cdu_ilt_start = ilt->clients[ILT_CLIENT_CDU].start;
5564 for (i = 0; i < L2_ILT_LINES(bp); i++) {
5565 ilt->lines[cdu_ilt_start + i].page =
5566 bp->context.vcxt + (ILT_PAGE_CIDS * i);
5567 ilt->lines[cdu_ilt_start + i].page_mapping =
5568 bp->context.cxt_mapping + (CDU_ILT_PAGE_SZ * i);
5569 /* cdu ilt pages are allocated manually so there's no need to
5572 bnx2x_ilt_init_op(bp, INITOP_SET);
5575 bnx2x_src_init_t2(bp, bp->t2, bp->t2_mapping, SRC_CONN_NUM);
5577 /* T1 hash bits value determines the T1 number of entries */
5578 REG_WR(bp, SRC_REG_NUMBER_HASH_BITS0 + port*4, SRC_HASH_BITS);
5583 REG_WR(bp, PRS_REG_NIC_MODE, 1);
5584 #endif /* BCM_CNIC */
5586 if (CHIP_IS_E2(bp)) {
5587 u32 pf_conf = IGU_PF_CONF_FUNC_EN;
5589 /* Turn on a single ISR mode in IGU if driver is going to use
5592 if (!(bp->flags & USING_MSIX_FLAG))
5593 pf_conf |= IGU_PF_CONF_SINGLE_ISR_EN;
5595 * Timers workaround bug: function init part.
5596 * Need to wait 20msec after initializing ILT,
5597 * needed to make sure there are no requests in
5598 * one of the PXP internal queues with "old" ILT addresses
5602 * Master enable - Due to WB DMAE writes performed before this
5603 * register is re-initialized as part of the regular function
5606 REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
5607 /* Enable the function in IGU */
5608 REG_WR(bp, IGU_REG_PF_CONFIGURATION, pf_conf);
5613 bnx2x_init_block(bp, PGLUE_B_BLOCK, FUNC0_STAGE + func);
5616 REG_WR(bp, PGLUE_B_REG_WAS_ERROR_PF_7_0_CLR, func);
5618 bnx2x_init_block(bp, MISC_BLOCK, FUNC0_STAGE + func);
5619 bnx2x_init_block(bp, TCM_BLOCK, FUNC0_STAGE + func);
5620 bnx2x_init_block(bp, UCM_BLOCK, FUNC0_STAGE + func);
5621 bnx2x_init_block(bp, CCM_BLOCK, FUNC0_STAGE + func);
5622 bnx2x_init_block(bp, XCM_BLOCK, FUNC0_STAGE + func);
5623 bnx2x_init_block(bp, TSEM_BLOCK, FUNC0_STAGE + func);
5624 bnx2x_init_block(bp, USEM_BLOCK, FUNC0_STAGE + func);
5625 bnx2x_init_block(bp, CSEM_BLOCK, FUNC0_STAGE + func);
5626 bnx2x_init_block(bp, XSEM_BLOCK, FUNC0_STAGE + func);
5628 if (CHIP_IS_E2(bp)) {
5629 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_PATH_ID_OFFSET,
5631 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_PATH_ID_OFFSET,
5635 if (CHIP_MODE_IS_4_PORT(bp))
5636 bnx2x_init_block(bp, XSEM_4PORT_BLOCK, FUNC0_STAGE + func);
5639 REG_WR(bp, QM_REG_PF_EN, 1);
5641 bnx2x_init_block(bp, QM_BLOCK, FUNC0_STAGE + func);
5643 if (CHIP_MODE_IS_4_PORT(bp))
5644 bnx2x_init_block(bp, QM_4PORT_BLOCK, FUNC0_STAGE + func);
5646 bnx2x_init_block(bp, TIMERS_BLOCK, FUNC0_STAGE + func);
5647 bnx2x_init_block(bp, DQ_BLOCK, FUNC0_STAGE + func);
5648 bnx2x_init_block(bp, BRB1_BLOCK, FUNC0_STAGE + func);
5649 bnx2x_init_block(bp, PRS_BLOCK, FUNC0_STAGE + func);
5650 bnx2x_init_block(bp, TSDM_BLOCK, FUNC0_STAGE + func);
5651 bnx2x_init_block(bp, CSDM_BLOCK, FUNC0_STAGE + func);
5652 bnx2x_init_block(bp, USDM_BLOCK, FUNC0_STAGE + func);
5653 bnx2x_init_block(bp, XSDM_BLOCK, FUNC0_STAGE + func);
5654 bnx2x_init_block(bp, UPB_BLOCK, FUNC0_STAGE + func);
5655 bnx2x_init_block(bp, XPB_BLOCK, FUNC0_STAGE + func);
5656 bnx2x_init_block(bp, PBF_BLOCK, FUNC0_STAGE + func);
5658 REG_WR(bp, PBF_REG_DISABLE_PF, 0);
5660 bnx2x_init_block(bp, CDU_BLOCK, FUNC0_STAGE + func);
5662 bnx2x_init_block(bp, CFC_BLOCK, FUNC0_STAGE + func);
5665 REG_WR(bp, CFC_REG_WEAK_ENABLE_PF, 1);
5668 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
5669 REG_WR(bp, NIG_REG_LLH0_FUNC_VLAN_ID + port*8, bp->mf_ov);
5672 bnx2x_init_block(bp, MISC_AEU_BLOCK, FUNC0_STAGE + func);
5674 /* HC init per function */
5675 if (bp->common.int_block == INT_BLOCK_HC) {
5676 if (CHIP_IS_E1H(bp)) {
5677 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
5679 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5680 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5682 bnx2x_init_block(bp, HC_BLOCK, FUNC0_STAGE + func);
5685 int num_segs, sb_idx, prod_offset;
5687 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
5689 if (CHIP_IS_E2(bp)) {
5690 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, 0);
5691 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, 0);
5694 bnx2x_init_block(bp, IGU_BLOCK, FUNC0_STAGE + func);
5696 if (CHIP_IS_E2(bp)) {
5700 * E2 mode: address 0-135 match to the mapping memory;
5701 * 136 - PF0 default prod; 137 - PF1 default prod;
5702 * 138 - PF2 default prod; 139 - PF3 default prod;
5703 * 140 - PF0 attn prod; 141 - PF1 attn prod;
5704 * 142 - PF2 attn prod; 143 - PF3 attn prod;
5707 * E1.5 mode - In backward compatible mode;
5708 * for non default SB; each even line in the memory
5709 * holds the U producer and each odd line hold
5710 * the C producer. The first 128 producers are for
5711 * NDSB (PF0 - 0-31; PF1 - 32-63 and so on). The last 20
5712 * producers are for the DSB for each PF.
5713 * Each PF has five segments: (the order inside each
5714 * segment is PF0; PF1; PF2; PF3) - 128-131 U prods;
5715 * 132-135 C prods; 136-139 X prods; 140-143 T prods;
5716 * 144-147 attn prods;
5718 /* non-default-status-blocks */
5719 num_segs = CHIP_INT_MODE_IS_BC(bp) ?
5720 IGU_BC_NDSB_NUM_SEGS : IGU_NORM_NDSB_NUM_SEGS;
5721 for (sb_idx = 0; sb_idx < bp->igu_sb_cnt; sb_idx++) {
5722 prod_offset = (bp->igu_base_sb + sb_idx) *
5725 for (i = 0; i < num_segs; i++) {
5726 addr = IGU_REG_PROD_CONS_MEMORY +
5727 (prod_offset + i) * 4;
5728 REG_WR(bp, addr, 0);
5730 /* send consumer update with value 0 */
5731 bnx2x_ack_sb(bp, bp->igu_base_sb + sb_idx,
5732 USTORM_ID, 0, IGU_INT_NOP, 1);
5733 bnx2x_igu_clear_sb(bp,
5734 bp->igu_base_sb + sb_idx);
5737 /* default-status-blocks */
5738 num_segs = CHIP_INT_MODE_IS_BC(bp) ?
5739 IGU_BC_DSB_NUM_SEGS : IGU_NORM_DSB_NUM_SEGS;
5741 if (CHIP_MODE_IS_4_PORT(bp))
5742 dsb_idx = BP_FUNC(bp);
5744 dsb_idx = BP_E1HVN(bp);
5746 prod_offset = (CHIP_INT_MODE_IS_BC(bp) ?
5747 IGU_BC_BASE_DSB_PROD + dsb_idx :
5748 IGU_NORM_BASE_DSB_PROD + dsb_idx);
5750 for (i = 0; i < (num_segs * E1HVN_MAX);
5752 addr = IGU_REG_PROD_CONS_MEMORY +
5753 (prod_offset + i)*4;
5754 REG_WR(bp, addr, 0);
5756 /* send consumer update with 0 */
5757 if (CHIP_INT_MODE_IS_BC(bp)) {
5758 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5759 USTORM_ID, 0, IGU_INT_NOP, 1);
5760 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5761 CSTORM_ID, 0, IGU_INT_NOP, 1);
5762 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5763 XSTORM_ID, 0, IGU_INT_NOP, 1);
5764 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5765 TSTORM_ID, 0, IGU_INT_NOP, 1);
5766 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5767 ATTENTION_ID, 0, IGU_INT_NOP, 1);
5769 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5770 USTORM_ID, 0, IGU_INT_NOP, 1);
5771 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5772 ATTENTION_ID, 0, IGU_INT_NOP, 1);
5774 bnx2x_igu_clear_sb(bp, bp->igu_dsb_id);
5776 /* !!! these should become driver const once
5777 rf-tool supports split-68 const */
5778 REG_WR(bp, IGU_REG_SB_INT_BEFORE_MASK_LSB, 0);
5779 REG_WR(bp, IGU_REG_SB_INT_BEFORE_MASK_MSB, 0);
5780 REG_WR(bp, IGU_REG_SB_MASK_LSB, 0);
5781 REG_WR(bp, IGU_REG_SB_MASK_MSB, 0);
5782 REG_WR(bp, IGU_REG_PBA_STATUS_LSB, 0);
5783 REG_WR(bp, IGU_REG_PBA_STATUS_MSB, 0);
5787 /* Reset PCIE errors for debug */
5788 REG_WR(bp, 0x2114, 0xffffffff);
5789 REG_WR(bp, 0x2120, 0xffffffff);
5791 bnx2x_init_block(bp, EMAC0_BLOCK, FUNC0_STAGE + func);
5792 bnx2x_init_block(bp, EMAC1_BLOCK, FUNC0_STAGE + func);
5793 bnx2x_init_block(bp, DBU_BLOCK, FUNC0_STAGE + func);
5794 bnx2x_init_block(bp, DBG_BLOCK, FUNC0_STAGE + func);
5795 bnx2x_init_block(bp, MCP_BLOCK, FUNC0_STAGE + func);
5796 bnx2x_init_block(bp, DMAE_BLOCK, FUNC0_STAGE + func);
5798 if (CHIP_IS_E1x(bp)) {
5799 main_mem_size = HC_REG_MAIN_MEMORY_SIZE / 2; /*dwords*/
5800 main_mem_base = HC_REG_MAIN_MEMORY +
5801 BP_PORT(bp) * (main_mem_size * 4);
5802 main_mem_prty_clr = HC_REG_HC_PRTY_STS_CLR;
5805 val = REG_RD(bp, main_mem_prty_clr);
5807 DP(BNX2X_MSG_MCP, "Hmmm... Parity errors in HC "
5809 "function init (0x%x)!\n", val);
5811 /* Clear "false" parity errors in MSI-X table */
5812 for (i = main_mem_base;
5813 i < main_mem_base + main_mem_size * 4;
5814 i += main_mem_width) {
5815 bnx2x_read_dmae(bp, i, main_mem_width / 4);
5816 bnx2x_write_dmae(bp, bnx2x_sp_mapping(bp, wb_data),
5817 i, main_mem_width / 4);
5819 /* Clear HC parity attention */
5820 REG_RD(bp, main_mem_prty_clr);
5823 bnx2x_phy_probe(&bp->link_params);
5828 int bnx2x_init_hw(struct bnx2x *bp, u32 load_code)
5832 DP(BNX2X_MSG_MCP, "function %d load_code %x\n",
5833 BP_ABS_FUNC(bp), load_code);
5836 spin_lock_init(&bp->dmae_lock);
5838 switch (load_code) {
5839 case FW_MSG_CODE_DRV_LOAD_COMMON:
5840 case FW_MSG_CODE_DRV_LOAD_COMMON_CHIP:
5841 rc = bnx2x_init_hw_common(bp, load_code);
5846 case FW_MSG_CODE_DRV_LOAD_PORT:
5847 rc = bnx2x_init_hw_port(bp);
5852 case FW_MSG_CODE_DRV_LOAD_FUNCTION:
5853 rc = bnx2x_init_hw_func(bp);
5859 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
5863 if (!BP_NOMCP(bp)) {
5864 int mb_idx = BP_FW_MB_IDX(bp);
5866 bp->fw_drv_pulse_wr_seq =
5867 (SHMEM_RD(bp, func_mb[mb_idx].drv_pulse_mb) &
5868 DRV_PULSE_SEQ_MASK);
5869 DP(BNX2X_MSG_MCP, "drv_pulse 0x%x\n", bp->fw_drv_pulse_wr_seq);
5873 bnx2x_gunzip_end(bp);
5878 void bnx2x_free_mem(struct bnx2x *bp)
5880 bnx2x_gunzip_end(bp);
5883 bnx2x_free_fp_mem(bp);
5884 /* end of fastpath */
5886 BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
5887 sizeof(struct host_sp_status_block));
5889 BNX2X_PCI_FREE(bp->slowpath, bp->slowpath_mapping,
5890 sizeof(struct bnx2x_slowpath));
5892 BNX2X_PCI_FREE(bp->context.vcxt, bp->context.cxt_mapping,
5895 bnx2x_ilt_mem_op(bp, ILT_MEMOP_FREE);
5897 BNX2X_FREE(bp->ilt->lines);
5901 BNX2X_PCI_FREE(bp->cnic_sb.e2_sb, bp->cnic_sb_mapping,
5902 sizeof(struct host_hc_status_block_e2));
5904 BNX2X_PCI_FREE(bp->cnic_sb.e1x_sb, bp->cnic_sb_mapping,
5905 sizeof(struct host_hc_status_block_e1x));
5907 BNX2X_PCI_FREE(bp->t2, bp->t2_mapping, SRC_T2_SZ);
5910 BNX2X_PCI_FREE(bp->spq, bp->spq_mapping, BCM_PAGE_SIZE);
5912 BNX2X_PCI_FREE(bp->eq_ring, bp->eq_mapping,
5913 BCM_PAGE_SIZE * NUM_EQ_PAGES);
5915 BNX2X_FREE(bp->rx_indir_table);
5919 int bnx2x_alloc_mem(struct bnx2x *bp)
5921 if (bnx2x_gunzip_init(bp))
5926 BNX2X_PCI_ALLOC(bp->cnic_sb.e2_sb, &bp->cnic_sb_mapping,
5927 sizeof(struct host_hc_status_block_e2));
5929 BNX2X_PCI_ALLOC(bp->cnic_sb.e1x_sb, &bp->cnic_sb_mapping,
5930 sizeof(struct host_hc_status_block_e1x));
5932 /* allocate searcher T2 table */
5933 BNX2X_PCI_ALLOC(bp->t2, &bp->t2_mapping, SRC_T2_SZ);
5937 BNX2X_PCI_ALLOC(bp->def_status_blk, &bp->def_status_blk_mapping,
5938 sizeof(struct host_sp_status_block));
5940 BNX2X_PCI_ALLOC(bp->slowpath, &bp->slowpath_mapping,
5941 sizeof(struct bnx2x_slowpath));
5943 bp->context.size = sizeof(union cdu_context) * bp->l2_cid_count;
5945 BNX2X_PCI_ALLOC(bp->context.vcxt, &bp->context.cxt_mapping,
5948 BNX2X_ALLOC(bp->ilt->lines, sizeof(struct ilt_line) * ILT_MAX_LINES);
5950 if (bnx2x_ilt_mem_op(bp, ILT_MEMOP_ALLOC))
5953 /* Slow path ring */
5954 BNX2X_PCI_ALLOC(bp->spq, &bp->spq_mapping, BCM_PAGE_SIZE);
5957 BNX2X_PCI_ALLOC(bp->eq_ring, &bp->eq_mapping,
5958 BCM_PAGE_SIZE * NUM_EQ_PAGES);
5960 BNX2X_ALLOC(bp->rx_indir_table, sizeof(bp->rx_indir_table[0]) *
5961 TSTORM_INDIRECTION_TABLE_SIZE);
5964 /* need to be done at the end, since it's self adjusting to amount
5965 * of memory available for RSS queues
5967 if (bnx2x_alloc_fp_mem(bp))
5977 * Init service functions
5979 static int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
5980 int *state_p, int flags);
5982 int bnx2x_func_start(struct bnx2x *bp)
5984 bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_START, 0, 0, 0, 1);
5986 /* Wait for completion */
5987 return bnx2x_wait_ramrod(bp, BNX2X_STATE_FUNC_STARTED, 0, &(bp->state),
5988 WAIT_RAMROD_COMMON);
5991 static int bnx2x_func_stop(struct bnx2x *bp)
5993 bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_STOP, 0, 0, 0, 1);
5995 /* Wait for completion */
5996 return bnx2x_wait_ramrod(bp, BNX2X_STATE_CLOSING_WAIT4_UNLOAD,
5997 0, &(bp->state), WAIT_RAMROD_COMMON);
6001 * bnx2x_set_mac_addr_gen - set a MAC in a CAM for a few L2 Clients for E1x chips
6003 * @bp: driver handle
6004 * @set: set or clear an entry (1 or 0)
6005 * @mac: pointer to a buffer containing a MAC
6006 * @cl_bit_vec: bit vector of clients to register a MAC for
6007 * @cam_offset: offset in a CAM to use
6008 * @is_bcast: is the set MAC a broadcast address (for E1 only)
6010 static void bnx2x_set_mac_addr_gen(struct bnx2x *bp, int set, const u8 *mac,
6011 u32 cl_bit_vec, u8 cam_offset,
6014 struct mac_configuration_cmd *config =
6015 (struct mac_configuration_cmd *)bnx2x_sp(bp, mac_config);
6016 int ramrod_flags = WAIT_RAMROD_COMMON;
6018 bp->set_mac_pending = 1;
6020 config->hdr.length = 1;
6021 config->hdr.offset = cam_offset;
6022 config->hdr.client_id = 0xff;
6023 /* Mark the single MAC configuration ramrod as opposed to a
6024 * UC/MC list configuration).
6026 config->hdr.echo = 1;
6029 config->config_table[0].msb_mac_addr =
6030 swab16(*(u16 *)&mac[0]);
6031 config->config_table[0].middle_mac_addr =
6032 swab16(*(u16 *)&mac[2]);
6033 config->config_table[0].lsb_mac_addr =
6034 swab16(*(u16 *)&mac[4]);
6035 config->config_table[0].clients_bit_vector =
6036 cpu_to_le32(cl_bit_vec);
6037 config->config_table[0].vlan_id = 0;
6038 config->config_table[0].pf_id = BP_FUNC(bp);
6040 SET_FLAG(config->config_table[0].flags,
6041 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6042 T_ETH_MAC_COMMAND_SET);
6044 SET_FLAG(config->config_table[0].flags,
6045 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6046 T_ETH_MAC_COMMAND_INVALIDATE);
6049 SET_FLAG(config->config_table[0].flags,
6050 MAC_CONFIGURATION_ENTRY_BROADCAST, 1);
6052 DP(NETIF_MSG_IFUP, "%s MAC (%04x:%04x:%04x) PF_ID %d CLID mask %d\n",
6053 (set ? "setting" : "clearing"),
6054 config->config_table[0].msb_mac_addr,
6055 config->config_table[0].middle_mac_addr,
6056 config->config_table[0].lsb_mac_addr, BP_FUNC(bp), cl_bit_vec);
6060 bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
6061 U64_HI(bnx2x_sp_mapping(bp, mac_config)),
6062 U64_LO(bnx2x_sp_mapping(bp, mac_config)), 1);
6064 /* Wait for a completion */
6065 bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending, ramrod_flags);
6068 static int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
6069 int *state_p, int flags)
6071 /* can take a while if any port is running */
6073 u8 poll = flags & WAIT_RAMROD_POLL;
6074 u8 common = flags & WAIT_RAMROD_COMMON;
6076 DP(NETIF_MSG_IFUP, "%s for state to become %x on IDX [%d]\n",
6077 poll ? "polling" : "waiting", state, idx);
6085 bnx2x_rx_int(bp->fp, 10);
6086 /* if index is different from 0
6087 * the reply for some commands will
6088 * be on the non default queue
6091 bnx2x_rx_int(&bp->fp[idx], 10);
6095 mb(); /* state is changed by bnx2x_sp_event() */
6096 if (*state_p == state) {
6097 #ifdef BNX2X_STOP_ON_ERROR
6098 DP(NETIF_MSG_IFUP, "exit (cnt %d)\n", 5000 - cnt);
6110 BNX2X_ERR("timeout %s for state %x on IDX [%d]\n",
6111 poll ? "polling" : "waiting", state, idx);
6112 #ifdef BNX2X_STOP_ON_ERROR
6119 static u8 bnx2x_e1h_cam_offset(struct bnx2x *bp, u8 rel_offset)
6121 if (CHIP_IS_E1H(bp))
6122 return E1H_FUNC_MAX * rel_offset + BP_FUNC(bp);
6123 else if (CHIP_MODE_IS_4_PORT(bp))
6124 return E2_FUNC_MAX * rel_offset + BP_FUNC(bp);
6126 return E2_FUNC_MAX * rel_offset + BP_VN(bp);
6130 * LLH CAM line allocations: currently only iSCSI and ETH macs are
6131 * relevant. In addition, current implementation is tuned for a
6135 LLH_CAM_ISCSI_ETH_LINE = 0,
6137 LLH_CAM_MAX_PF_LINE = NIG_REG_LLH1_FUNC_MEM_SIZE
6140 static void bnx2x_set_mac_in_nig(struct bnx2x *bp,
6142 unsigned char *dev_addr,
6146 u32 mem_offset, ena_offset, mem_index;
6149 * 0..7 - goes to MEM
6150 * 8..15 - goes to MEM2
6153 if (!IS_MF_SI(bp) || index > LLH_CAM_MAX_PF_LINE)
6156 /* calculate memory start offset according to the mapping
6157 * and index in the memory */
6158 if (index < NIG_LLH_FUNC_MEM_MAX_OFFSET) {
6159 mem_offset = BP_PORT(bp) ? NIG_REG_LLH1_FUNC_MEM :
6160 NIG_REG_LLH0_FUNC_MEM;
6161 ena_offset = BP_PORT(bp) ? NIG_REG_LLH1_FUNC_MEM_ENABLE :
6162 NIG_REG_LLH0_FUNC_MEM_ENABLE;
6165 mem_offset = BP_PORT(bp) ? NIG_REG_P1_LLH_FUNC_MEM2 :
6166 NIG_REG_P0_LLH_FUNC_MEM2;
6167 ena_offset = BP_PORT(bp) ? NIG_REG_P1_LLH_FUNC_MEM2_ENABLE :
6168 NIG_REG_P0_LLH_FUNC_MEM2_ENABLE;
6169 mem_index = index - NIG_LLH_FUNC_MEM_MAX_OFFSET;
6173 /* LLH_FUNC_MEM is a u64 WB register */
6174 mem_offset += 8*mem_index;
6176 wb_data[0] = ((dev_addr[2] << 24) | (dev_addr[3] << 16) |
6177 (dev_addr[4] << 8) | dev_addr[5]);
6178 wb_data[1] = ((dev_addr[0] << 8) | dev_addr[1]);
6180 REG_WR_DMAE(bp, mem_offset, wb_data, 2);
6183 /* enable/disable the entry */
6184 REG_WR(bp, ena_offset + 4*mem_index, set);
6188 void bnx2x_set_eth_mac(struct bnx2x *bp, int set)
6190 u8 cam_offset = (CHIP_IS_E1(bp) ? (BP_PORT(bp) ? 32 : 0) :
6191 bnx2x_e1h_cam_offset(bp, CAM_ETH_LINE));
6193 /* networking MAC */
6194 bnx2x_set_mac_addr_gen(bp, set, bp->dev->dev_addr,
6195 (1 << bp->fp->cl_id), cam_offset , 0);
6197 bnx2x_set_mac_in_nig(bp, set, bp->dev->dev_addr, LLH_CAM_ETH_LINE);
6199 if (CHIP_IS_E1(bp)) {
6201 static const u8 bcast[ETH_ALEN] = {
6202 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
6204 bnx2x_set_mac_addr_gen(bp, set, bcast, 0, cam_offset + 1, 1);
6208 static inline u8 bnx2x_e1_cam_mc_offset(struct bnx2x *bp)
6210 return CHIP_REV_IS_SLOW(bp) ?
6211 (BNX2X_MAX_EMUL_MULTI * (1 + BP_PORT(bp))) :
6212 (BNX2X_MAX_MULTICAST * (1 + BP_PORT(bp)));
6215 /* set mc list, do not wait as wait implies sleep and
6216 * set_rx_mode can be invoked from non-sleepable context.
6218 * Instead we use the same ramrod data buffer each time we need
6219 * to configure a list of addresses, and use the fact that the
6220 * list of MACs is changed in an incremental way and that the
6221 * function is called under the netif_addr_lock. A temporary
6222 * inconsistent CAM configuration (possible in case of a very fast
6223 * sequence of add/del/add on the host side) will shortly be
6224 * restored by the handler of the last ramrod.
6226 static int bnx2x_set_e1_mc_list(struct bnx2x *bp)
6229 struct net_device *dev = bp->dev;
6230 u8 offset = bnx2x_e1_cam_mc_offset(bp);
6231 struct netdev_hw_addr *ha;
6232 struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, mcast_config);
6233 dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, mcast_config);
6235 if (netdev_mc_count(dev) > BNX2X_MAX_MULTICAST)
6238 netdev_for_each_mc_addr(ha, dev) {
6240 config_cmd->config_table[i].msb_mac_addr =
6241 swab16(*(u16 *)&bnx2x_mc_addr(ha)[0]);
6242 config_cmd->config_table[i].middle_mac_addr =
6243 swab16(*(u16 *)&bnx2x_mc_addr(ha)[2]);
6244 config_cmd->config_table[i].lsb_mac_addr =
6245 swab16(*(u16 *)&bnx2x_mc_addr(ha)[4]);
6247 config_cmd->config_table[i].vlan_id = 0;
6248 config_cmd->config_table[i].pf_id = BP_FUNC(bp);
6249 config_cmd->config_table[i].clients_bit_vector =
6250 cpu_to_le32(1 << BP_L_ID(bp));
6252 SET_FLAG(config_cmd->config_table[i].flags,
6253 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6254 T_ETH_MAC_COMMAND_SET);
6257 "setting MCAST[%d] (%04x:%04x:%04x)\n", i,
6258 config_cmd->config_table[i].msb_mac_addr,
6259 config_cmd->config_table[i].middle_mac_addr,
6260 config_cmd->config_table[i].lsb_mac_addr);
6263 old = config_cmd->hdr.length;
6265 for (; i < old; i++) {
6266 if (CAM_IS_INVALID(config_cmd->
6268 /* already invalidated */
6272 SET_FLAG(config_cmd->config_table[i].flags,
6273 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6274 T_ETH_MAC_COMMAND_INVALIDATE);
6280 config_cmd->hdr.length = i;
6281 config_cmd->hdr.offset = offset;
6282 config_cmd->hdr.client_id = 0xff;
6283 /* Mark that this ramrod doesn't use bp->set_mac_pending for
6286 config_cmd->hdr.echo = 0;
6290 return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
6291 U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
6294 void bnx2x_invalidate_e1_mc_list(struct bnx2x *bp)
6297 struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, mcast_config);
6298 dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, mcast_config);
6299 int ramrod_flags = WAIT_RAMROD_COMMON;
6300 u8 offset = bnx2x_e1_cam_mc_offset(bp);
6302 for (i = 0; i < BNX2X_MAX_MULTICAST; i++)
6303 SET_FLAG(config_cmd->config_table[i].flags,
6304 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6305 T_ETH_MAC_COMMAND_INVALIDATE);
6309 config_cmd->hdr.length = BNX2X_MAX_MULTICAST;
6310 config_cmd->hdr.offset = offset;
6311 config_cmd->hdr.client_id = 0xff;
6312 /* We'll wait for a completion this time... */
6313 config_cmd->hdr.echo = 1;
6315 bp->set_mac_pending = 1;
6319 bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
6320 U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
6322 /* Wait for a completion */
6323 bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending,
6328 /* Accept one or more multicasts */
6329 static int bnx2x_set_e1h_mc_list(struct bnx2x *bp)
6331 struct net_device *dev = bp->dev;
6332 struct netdev_hw_addr *ha;
6333 u32 mc_filter[MC_HASH_SIZE];
6334 u32 crc, bit, regidx;
6337 memset(mc_filter, 0, 4 * MC_HASH_SIZE);
6339 netdev_for_each_mc_addr(ha, dev) {
6340 DP(NETIF_MSG_IFUP, "Adding mcast MAC: %pM\n",
6343 crc = crc32c_le(0, bnx2x_mc_addr(ha),
6345 bit = (crc >> 24) & 0xff;
6348 mc_filter[regidx] |= (1 << bit);
6351 for (i = 0; i < MC_HASH_SIZE; i++)
6352 REG_WR(bp, MC_HASH_OFFSET(bp, i),
6358 void bnx2x_invalidate_e1h_mc_list(struct bnx2x *bp)
6362 for (i = 0; i < MC_HASH_SIZE; i++)
6363 REG_WR(bp, MC_HASH_OFFSET(bp, i), 0);
6368 * bnx2x_set_iscsi_eth_mac_addr - set iSCSI MAC(s).
6370 * @bp: driver handle
6371 * @set: set or clear the CAM entry
6373 * This function will wait until the ramdord completion returns.
6374 * Return 0 if success, -ENODEV if ramrod doesn't return.
6376 static int bnx2x_set_iscsi_eth_mac_addr(struct bnx2x *bp, int set)
6378 u8 cam_offset = (CHIP_IS_E1(bp) ? ((BP_PORT(bp) ? 32 : 0) + 2) :
6379 bnx2x_e1h_cam_offset(bp, CAM_ISCSI_ETH_LINE));
6380 u32 iscsi_l2_cl_id = BNX2X_ISCSI_ETH_CL_ID +
6381 BP_E1HVN(bp) * NONE_ETH_CONTEXT_USE;
6382 u32 cl_bit_vec = (1 << iscsi_l2_cl_id);
6383 u8 *iscsi_mac = bp->cnic_eth_dev.iscsi_mac;
6385 /* Send a SET_MAC ramrod */
6386 bnx2x_set_mac_addr_gen(bp, set, iscsi_mac, cl_bit_vec,
6389 bnx2x_set_mac_in_nig(bp, set, iscsi_mac, LLH_CAM_ISCSI_ETH_LINE);
6395 * bnx2x_set_fip_eth_mac_addr - set FCoE L2 MAC(s)
6397 * @bp: driver handle
6398 * @set: set or clear the CAM entry
6400 * This function will wait until the ramrod completion returns.
6401 * Returns 0 if success, -ENODEV if ramrod doesn't return.
6403 int bnx2x_set_fip_eth_mac_addr(struct bnx2x *bp, int set)
6405 u32 cl_bit_vec = (1 << bnx2x_fcoe(bp, cl_id));
6407 * CAM allocation for E1H
6408 * eth unicasts: by func number
6409 * iscsi: by func number
6410 * fip unicast: by func number
6411 * fip multicast: by func number
6413 bnx2x_set_mac_addr_gen(bp, set, bp->fip_mac,
6414 cl_bit_vec, bnx2x_e1h_cam_offset(bp, CAM_FIP_ETH_LINE), 0);
6419 int bnx2x_set_all_enode_macs(struct bnx2x *bp, int set)
6421 u32 cl_bit_vec = (1 << bnx2x_fcoe(bp, cl_id));
6424 * CAM allocation for E1H
6425 * eth unicasts: by func number
6426 * iscsi: by func number
6427 * fip unicast: by func number
6428 * fip multicast: by func number
6430 bnx2x_set_mac_addr_gen(bp, set, ALL_ENODE_MACS, cl_bit_vec,
6431 bnx2x_e1h_cam_offset(bp, CAM_FIP_MCAST_LINE), 0);
6437 static void bnx2x_fill_cl_init_data(struct bnx2x *bp,
6438 struct bnx2x_client_init_params *params,
6440 struct client_init_ramrod_data *data)
6442 /* Clear the buffer */
6443 memset(data, 0, sizeof(*data));
6446 data->general.client_id = params->rxq_params.cl_id;
6447 data->general.statistics_counter_id = params->rxq_params.stat_id;
6448 data->general.statistics_en_flg =
6449 (params->rxq_params.flags & QUEUE_FLG_STATS) ? 1 : 0;
6450 data->general.is_fcoe_flg =
6451 (params->ramrod_params.flags & CLIENT_IS_FCOE) ? 1 : 0;
6452 data->general.activate_flg = activate;
6453 data->general.sp_client_id = params->rxq_params.spcl_id;
6456 data->rx.tpa_en_flg =
6457 (params->rxq_params.flags & QUEUE_FLG_TPA) ? 1 : 0;
6458 data->rx.vmqueue_mode_en_flg = 0;
6459 data->rx.cache_line_alignment_log_size =
6460 params->rxq_params.cache_line_log;
6461 data->rx.enable_dynamic_hc =
6462 (params->rxq_params.flags & QUEUE_FLG_DHC) ? 1 : 0;
6463 data->rx.max_sges_for_packet = params->rxq_params.max_sges_pkt;
6464 data->rx.client_qzone_id = params->rxq_params.cl_qzone_id;
6465 data->rx.max_agg_size = params->rxq_params.tpa_agg_sz;
6467 /* We don't set drop flags */
6468 data->rx.drop_ip_cs_err_flg = 0;
6469 data->rx.drop_tcp_cs_err_flg = 0;
6470 data->rx.drop_ttl0_flg = 0;
6471 data->rx.drop_udp_cs_err_flg = 0;
6473 data->rx.inner_vlan_removal_enable_flg =
6474 (params->rxq_params.flags & QUEUE_FLG_VLAN) ? 1 : 0;
6475 data->rx.outer_vlan_removal_enable_flg =
6476 (params->rxq_params.flags & QUEUE_FLG_OV) ? 1 : 0;
6477 data->rx.status_block_id = params->rxq_params.fw_sb_id;
6478 data->rx.rx_sb_index_number = params->rxq_params.sb_cq_index;
6479 data->rx.bd_buff_size = cpu_to_le16(params->rxq_params.buf_sz);
6480 data->rx.sge_buff_size = cpu_to_le16(params->rxq_params.sge_buf_sz);
6481 data->rx.mtu = cpu_to_le16(params->rxq_params.mtu);
6482 data->rx.bd_page_base.lo =
6483 cpu_to_le32(U64_LO(params->rxq_params.dscr_map));
6484 data->rx.bd_page_base.hi =
6485 cpu_to_le32(U64_HI(params->rxq_params.dscr_map));
6486 data->rx.sge_page_base.lo =
6487 cpu_to_le32(U64_LO(params->rxq_params.sge_map));
6488 data->rx.sge_page_base.hi =
6489 cpu_to_le32(U64_HI(params->rxq_params.sge_map));
6490 data->rx.cqe_page_base.lo =
6491 cpu_to_le32(U64_LO(params->rxq_params.rcq_map));
6492 data->rx.cqe_page_base.hi =
6493 cpu_to_le32(U64_HI(params->rxq_params.rcq_map));
6494 data->rx.is_leading_rss =
6495 (params->ramrod_params.flags & CLIENT_IS_LEADING_RSS) ? 1 : 0;
6496 data->rx.is_approx_mcast = data->rx.is_leading_rss;
6499 data->tx.enforce_security_flg = 0; /* VF specific */
6500 data->tx.tx_status_block_id = params->txq_params.fw_sb_id;
6501 data->tx.tx_sb_index_number = params->txq_params.sb_cq_index;
6502 data->tx.mtu = 0; /* VF specific */
6503 data->tx.tx_bd_page_base.lo =
6504 cpu_to_le32(U64_LO(params->txq_params.dscr_map));
6505 data->tx.tx_bd_page_base.hi =
6506 cpu_to_le32(U64_HI(params->txq_params.dscr_map));
6508 /* flow control data */
6509 data->fc.cqe_pause_thr_low = cpu_to_le16(params->pause.rcq_th_lo);
6510 data->fc.cqe_pause_thr_high = cpu_to_le16(params->pause.rcq_th_hi);
6511 data->fc.bd_pause_thr_low = cpu_to_le16(params->pause.bd_th_lo);
6512 data->fc.bd_pause_thr_high = cpu_to_le16(params->pause.bd_th_hi);
6513 data->fc.sge_pause_thr_low = cpu_to_le16(params->pause.sge_th_lo);
6514 data->fc.sge_pause_thr_high = cpu_to_le16(params->pause.sge_th_hi);
6515 data->fc.rx_cos_mask = cpu_to_le16(params->pause.pri_map);
6517 data->fc.safc_group_num = params->txq_params.cos;
6518 data->fc.safc_group_en_flg =
6519 (params->txq_params.flags & QUEUE_FLG_COS) ? 1 : 0;
6520 data->fc.traffic_type =
6521 (params->ramrod_params.flags & CLIENT_IS_FCOE) ?
6522 LLFC_TRAFFIC_TYPE_FCOE : LLFC_TRAFFIC_TYPE_NW;
6525 static inline void bnx2x_set_ctx_validation(struct eth_context *cxt, u32 cid)
6527 /* ustorm cxt validation */
6528 cxt->ustorm_ag_context.cdu_usage =
6529 CDU_RSRVD_VALUE_TYPE_A(cid, CDU_REGION_NUMBER_UCM_AG,
6530 ETH_CONNECTION_TYPE);
6531 /* xcontext validation */
6532 cxt->xstorm_ag_context.cdu_reserved =
6533 CDU_RSRVD_VALUE_TYPE_A(cid, CDU_REGION_NUMBER_XCM_AG,
6534 ETH_CONNECTION_TYPE);
6537 static int bnx2x_setup_fw_client(struct bnx2x *bp,
6538 struct bnx2x_client_init_params *params,
6540 struct client_init_ramrod_data *data,
6541 dma_addr_t data_mapping)
6544 int ramrod = RAMROD_CMD_ID_ETH_CLIENT_SETUP;
6545 int ramrod_flags = 0, rc;
6547 /* HC and context validation values */
6548 hc_usec = params->txq_params.hc_rate ?
6549 1000000 / params->txq_params.hc_rate : 0;
6550 bnx2x_update_coalesce_sb_index(bp,
6551 params->txq_params.fw_sb_id,
6552 params->txq_params.sb_cq_index,
6553 !(params->txq_params.flags & QUEUE_FLG_HC),
6556 *(params->ramrod_params.pstate) = BNX2X_FP_STATE_OPENING;
6558 hc_usec = params->rxq_params.hc_rate ?
6559 1000000 / params->rxq_params.hc_rate : 0;
6560 bnx2x_update_coalesce_sb_index(bp,
6561 params->rxq_params.fw_sb_id,
6562 params->rxq_params.sb_cq_index,
6563 !(params->rxq_params.flags & QUEUE_FLG_HC),
6566 bnx2x_set_ctx_validation(params->rxq_params.cxt,
6567 params->rxq_params.cid);
6570 if (params->txq_params.flags & QUEUE_FLG_STATS)
6571 storm_memset_xstats_zero(bp, BP_PORT(bp),
6572 params->txq_params.stat_id);
6574 if (params->rxq_params.flags & QUEUE_FLG_STATS) {
6575 storm_memset_ustats_zero(bp, BP_PORT(bp),
6576 params->rxq_params.stat_id);
6577 storm_memset_tstats_zero(bp, BP_PORT(bp),
6578 params->rxq_params.stat_id);
6581 /* Fill the ramrod data */
6582 bnx2x_fill_cl_init_data(bp, params, activate, data);
6586 * bnx2x_sp_post() takes a spin_lock thus no other explict memory
6587 * barrier except from mmiowb() is needed to impose a
6588 * proper ordering of memory operations.
6593 bnx2x_sp_post(bp, ramrod, params->ramrod_params.cid,
6594 U64_HI(data_mapping), U64_LO(data_mapping), 0);
6596 /* Wait for completion */
6597 rc = bnx2x_wait_ramrod(bp, params->ramrod_params.state,
6598 params->ramrod_params.index,
6599 params->ramrod_params.pstate,
6605 * bnx2x_set_int_mode - configure interrupt mode
6607 * @bp: driver handle
6609 * In case of MSI-X it will also try to enable MSI-X.
6611 static int __devinit bnx2x_set_int_mode(struct bnx2x *bp)
6615 switch (bp->int_mode) {
6617 bnx2x_enable_msi(bp);
6618 /* falling through... */
6620 bp->num_queues = 1 + NONE_ETH_CONTEXT_USE;
6621 DP(NETIF_MSG_IFUP, "set number of queues to 1\n");
6624 /* Set number of queues according to bp->multi_mode value */
6625 bnx2x_set_num_queues(bp);
6627 DP(NETIF_MSG_IFUP, "set number of queues to %d\n",
6630 /* if we can't use MSI-X we only need one fp,
6631 * so try to enable MSI-X with the requested number of fp's
6632 * and fallback to MSI or legacy INTx with one fp
6634 rc = bnx2x_enable_msix(bp);
6636 /* failed to enable MSI-X */
6639 "Multi requested but failed to "
6640 "enable MSI-X (%d), "
6641 "set number of queues to %d\n",
6643 1 + NONE_ETH_CONTEXT_USE);
6644 bp->num_queues = 1 + NONE_ETH_CONTEXT_USE;
6646 if (!(bp->flags & DISABLE_MSI_FLAG))
6647 bnx2x_enable_msi(bp);
6656 /* must be called prioir to any HW initializations */
6657 static inline u16 bnx2x_cid_ilt_lines(struct bnx2x *bp)
6659 return L2_ILT_LINES(bp);
6662 void bnx2x_ilt_set_info(struct bnx2x *bp)
6664 struct ilt_client_info *ilt_client;
6665 struct bnx2x_ilt *ilt = BP_ILT(bp);
6668 ilt->start_line = FUNC_ILT_BASE(BP_FUNC(bp));
6669 DP(BNX2X_MSG_SP, "ilt starts at line %d\n", ilt->start_line);
6672 ilt_client = &ilt->clients[ILT_CLIENT_CDU];
6673 ilt_client->client_num = ILT_CLIENT_CDU;
6674 ilt_client->page_size = CDU_ILT_PAGE_SZ;
6675 ilt_client->flags = ILT_CLIENT_SKIP_MEM;
6676 ilt_client->start = line;
6677 line += L2_ILT_LINES(bp);
6679 line += CNIC_ILT_LINES;
6681 ilt_client->end = line - 1;
6683 DP(BNX2X_MSG_SP, "ilt client[CDU]: start %d, end %d, psz 0x%x, "
6684 "flags 0x%x, hw psz %d\n",
6687 ilt_client->page_size,
6689 ilog2(ilt_client->page_size >> 12));
6692 if (QM_INIT(bp->qm_cid_count)) {
6693 ilt_client = &ilt->clients[ILT_CLIENT_QM];
6694 ilt_client->client_num = ILT_CLIENT_QM;
6695 ilt_client->page_size = QM_ILT_PAGE_SZ;
6696 ilt_client->flags = 0;
6697 ilt_client->start = line;
6699 /* 4 bytes for each cid */
6700 line += DIV_ROUND_UP(bp->qm_cid_count * QM_QUEUES_PER_FUNC * 4,
6703 ilt_client->end = line - 1;
6705 DP(BNX2X_MSG_SP, "ilt client[QM]: start %d, end %d, psz 0x%x, "
6706 "flags 0x%x, hw psz %d\n",
6709 ilt_client->page_size,
6711 ilog2(ilt_client->page_size >> 12));
6715 ilt_client = &ilt->clients[ILT_CLIENT_SRC];
6717 ilt_client->client_num = ILT_CLIENT_SRC;
6718 ilt_client->page_size = SRC_ILT_PAGE_SZ;
6719 ilt_client->flags = 0;
6720 ilt_client->start = line;
6721 line += SRC_ILT_LINES;
6722 ilt_client->end = line - 1;
6724 DP(BNX2X_MSG_SP, "ilt client[SRC]: start %d, end %d, psz 0x%x, "
6725 "flags 0x%x, hw psz %d\n",
6728 ilt_client->page_size,
6730 ilog2(ilt_client->page_size >> 12));
6733 ilt_client->flags = (ILT_CLIENT_SKIP_INIT | ILT_CLIENT_SKIP_MEM);
6737 ilt_client = &ilt->clients[ILT_CLIENT_TM];
6739 ilt_client->client_num = ILT_CLIENT_TM;
6740 ilt_client->page_size = TM_ILT_PAGE_SZ;
6741 ilt_client->flags = 0;
6742 ilt_client->start = line;
6743 line += TM_ILT_LINES;
6744 ilt_client->end = line - 1;
6746 DP(BNX2X_MSG_SP, "ilt client[TM]: start %d, end %d, psz 0x%x, "
6747 "flags 0x%x, hw psz %d\n",
6750 ilt_client->page_size,
6752 ilog2(ilt_client->page_size >> 12));
6755 ilt_client->flags = (ILT_CLIENT_SKIP_INIT | ILT_CLIENT_SKIP_MEM);
6759 int bnx2x_setup_client(struct bnx2x *bp, struct bnx2x_fastpath *fp,
6762 struct bnx2x_client_init_params params = { {0} };
6765 /* reset IGU state skip FCoE L2 queue */
6766 if (!IS_FCOE_FP(fp))
6767 bnx2x_ack_sb(bp, fp->igu_sb_id, USTORM_ID, 0,
6770 params.ramrod_params.pstate = &fp->state;
6771 params.ramrod_params.state = BNX2X_FP_STATE_OPEN;
6772 params.ramrod_params.index = fp->index;
6773 params.ramrod_params.cid = fp->cid;
6777 params.ramrod_params.flags |= CLIENT_IS_FCOE;
6782 params.ramrod_params.flags |= CLIENT_IS_LEADING_RSS;
6784 bnx2x_pf_rx_cl_prep(bp, fp, ¶ms.pause, ¶ms.rxq_params);
6786 bnx2x_pf_tx_cl_prep(bp, fp, ¶ms.txq_params);
6788 rc = bnx2x_setup_fw_client(bp, ¶ms, 1,
6789 bnx2x_sp(bp, client_init_data),
6790 bnx2x_sp_mapping(bp, client_init_data));
6794 static int bnx2x_stop_fw_client(struct bnx2x *bp,
6795 struct bnx2x_client_ramrod_params *p)
6799 int poll_flag = p->poll ? WAIT_RAMROD_POLL : 0;
6801 /* halt the connection */
6802 *p->pstate = BNX2X_FP_STATE_HALTING;
6803 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, p->cid, 0,
6806 /* Wait for completion */
6807 rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, p->index,
6808 p->pstate, poll_flag);
6809 if (rc) /* timeout */
6812 *p->pstate = BNX2X_FP_STATE_TERMINATING;
6813 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_TERMINATE, p->cid, 0,
6815 /* Wait for completion */
6816 rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_TERMINATED, p->index,
6817 p->pstate, poll_flag);
6818 if (rc) /* timeout */
6822 /* delete cfc entry */
6823 bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_CFC_DEL, p->cid, 0, 0, 1);
6825 /* Wait for completion */
6826 rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_CLOSED, p->index,
6827 p->pstate, WAIT_RAMROD_COMMON);
6831 static int bnx2x_stop_client(struct bnx2x *bp, int index)
6833 struct bnx2x_client_ramrod_params client_stop = {0};
6834 struct bnx2x_fastpath *fp = &bp->fp[index];
6836 client_stop.index = index;
6837 client_stop.cid = fp->cid;
6838 client_stop.cl_id = fp->cl_id;
6839 client_stop.pstate = &(fp->state);
6840 client_stop.poll = 0;
6842 return bnx2x_stop_fw_client(bp, &client_stop);
6846 static void bnx2x_reset_func(struct bnx2x *bp)
6848 int port = BP_PORT(bp);
6849 int func = BP_FUNC(bp);
6851 int pfunc_offset_fp = offsetof(struct hc_sb_data, p_func) +
6853 offsetof(struct hc_status_block_data_e2, common) :
6854 offsetof(struct hc_status_block_data_e1x, common));
6855 int pfunc_offset_sp = offsetof(struct hc_sp_status_block_data, p_func);
6856 int pfid_offset = offsetof(struct pci_entity, pf_id);
6858 /* Disable the function in the FW */
6859 REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(func), 0);
6860 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(func), 0);
6861 REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(func), 0);
6862 REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(func), 0);
6865 for_each_eth_queue(bp, i) {
6866 struct bnx2x_fastpath *fp = &bp->fp[i];
6868 BAR_CSTRORM_INTMEM +
6869 CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id)
6870 + pfunc_offset_fp + pfid_offset,
6871 HC_FUNCTION_DISABLED);
6876 BAR_CSTRORM_INTMEM +
6877 CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
6878 pfunc_offset_sp + pfid_offset,
6879 HC_FUNCTION_DISABLED);
6882 for (i = 0; i < XSTORM_SPQ_DATA_SIZE / 4; i++)
6883 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_DATA_OFFSET(func),
6887 if (bp->common.int_block == INT_BLOCK_HC) {
6888 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
6889 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
6891 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, 0);
6892 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, 0);
6896 /* Disable Timer scan */
6897 REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 0);
6899 * Wait for at least 10ms and up to 2 second for the timers scan to
6902 for (i = 0; i < 200; i++) {
6904 if (!REG_RD(bp, TM_REG_LIN0_SCAN_ON + port*4))
6909 bnx2x_clear_func_ilt(bp, func);
6911 /* Timers workaround bug for E2: if this is vnic-3,
6912 * we need to set the entire ilt range for this timers.
6914 if (CHIP_IS_E2(bp) && BP_VN(bp) == 3) {
6915 struct ilt_client_info ilt_cli;
6916 /* use dummy TM client */
6917 memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
6919 ilt_cli.end = ILT_NUM_PAGE_ENTRIES - 1;
6920 ilt_cli.client_num = ILT_CLIENT_TM;
6922 bnx2x_ilt_boundry_init_op(bp, &ilt_cli, 0, INITOP_CLEAR);
6925 /* this assumes that reset_port() called before reset_func()*/
6927 bnx2x_pf_disable(bp);
6932 static void bnx2x_reset_port(struct bnx2x *bp)
6934 int port = BP_PORT(bp);
6937 REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
6939 /* Do not rcv packets to BRB */
6940 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK + port*4, 0x0);
6941 /* Do not direct rcv packets that are not for MCP to the BRB */
6942 REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_NOT_MCP :
6943 NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
6946 REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, 0);
6949 /* Check for BRB port occupancy */
6950 val = REG_RD(bp, BRB1_REG_PORT_NUM_OCC_BLOCKS_0 + port*4);
6952 DP(NETIF_MSG_IFDOWN,
6953 "BRB1 is not empty %d blocks are occupied\n", val);
6955 /* TODO: Close Doorbell port? */
6958 static void bnx2x_reset_chip(struct bnx2x *bp, u32 reset_code)
6960 DP(BNX2X_MSG_MCP, "function %d reset_code %x\n",
6961 BP_ABS_FUNC(bp), reset_code);
6963 switch (reset_code) {
6964 case FW_MSG_CODE_DRV_UNLOAD_COMMON:
6965 bnx2x_reset_port(bp);
6966 bnx2x_reset_func(bp);
6967 bnx2x_reset_common(bp);
6970 case FW_MSG_CODE_DRV_UNLOAD_PORT:
6971 bnx2x_reset_port(bp);
6972 bnx2x_reset_func(bp);
6975 case FW_MSG_CODE_DRV_UNLOAD_FUNCTION:
6976 bnx2x_reset_func(bp);
6980 BNX2X_ERR("Unknown reset_code (0x%x) from MCP\n", reset_code);
6986 static inline void bnx2x_del_fcoe_eth_macs(struct bnx2x *bp)
6988 if (bp->flags & FCOE_MACS_SET) {
6990 bnx2x_set_fip_eth_mac_addr(bp, 0);
6992 bnx2x_set_all_enode_macs(bp, 0);
6994 bp->flags &= ~FCOE_MACS_SET;
6999 void bnx2x_chip_cleanup(struct bnx2x *bp, int unload_mode)
7001 int port = BP_PORT(bp);
7005 /* Wait until tx fastpath tasks complete */
7006 for_each_tx_queue(bp, i) {
7007 struct bnx2x_fastpath *fp = &bp->fp[i];
7010 while (bnx2x_has_tx_work_unload(fp)) {
7013 BNX2X_ERR("timeout waiting for queue[%d]\n",
7015 #ifdef BNX2X_STOP_ON_ERROR
7026 /* Give HW time to discard old tx messages */
7029 bnx2x_set_eth_mac(bp, 0);
7031 bnx2x_invalidate_uc_list(bp);
7034 bnx2x_invalidate_e1_mc_list(bp);
7036 bnx2x_invalidate_e1h_mc_list(bp);
7037 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
7041 bnx2x_del_fcoe_eth_macs(bp);
7044 if (unload_mode == UNLOAD_NORMAL)
7045 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7047 else if (bp->flags & NO_WOL_FLAG)
7048 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
7051 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
7052 u8 *mac_addr = bp->dev->dev_addr;
7054 /* The mac address is written to entries 1-4 to
7055 preserve entry 0 which is used by the PMF */
7056 u8 entry = (BP_E1HVN(bp) + 1)*8;
7058 val = (mac_addr[0] << 8) | mac_addr[1];
7059 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry, val);
7061 val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
7062 (mac_addr[4] << 8) | mac_addr[5];
7063 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
7065 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
7068 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7070 /* Close multi and leading connections
7071 Completions for ramrods are collected in a synchronous way */
7072 for_each_queue(bp, i)
7074 if (bnx2x_stop_client(bp, i))
7075 #ifdef BNX2X_STOP_ON_ERROR
7081 rc = bnx2x_func_stop(bp);
7083 BNX2X_ERR("Function stop failed!\n");
7084 #ifdef BNX2X_STOP_ON_ERROR
7090 #ifndef BNX2X_STOP_ON_ERROR
7094 reset_code = bnx2x_fw_command(bp, reset_code, 0);
7096 DP(NETIF_MSG_IFDOWN, "NO MCP - load counts[%d] "
7097 "%d, %d, %d\n", BP_PATH(bp),
7098 load_count[BP_PATH(bp)][0],
7099 load_count[BP_PATH(bp)][1],
7100 load_count[BP_PATH(bp)][2]);
7101 load_count[BP_PATH(bp)][0]--;
7102 load_count[BP_PATH(bp)][1 + port]--;
7103 DP(NETIF_MSG_IFDOWN, "NO MCP - new load counts[%d] "
7104 "%d, %d, %d\n", BP_PATH(bp),
7105 load_count[BP_PATH(bp)][0], load_count[BP_PATH(bp)][1],
7106 load_count[BP_PATH(bp)][2]);
7107 if (load_count[BP_PATH(bp)][0] == 0)
7108 reset_code = FW_MSG_CODE_DRV_UNLOAD_COMMON;
7109 else if (load_count[BP_PATH(bp)][1 + port] == 0)
7110 reset_code = FW_MSG_CODE_DRV_UNLOAD_PORT;
7112 reset_code = FW_MSG_CODE_DRV_UNLOAD_FUNCTION;
7115 if ((reset_code == FW_MSG_CODE_DRV_UNLOAD_COMMON) ||
7116 (reset_code == FW_MSG_CODE_DRV_UNLOAD_PORT))
7117 bnx2x__link_reset(bp);
7119 /* Disable HW interrupts, NAPI */
7120 bnx2x_netif_stop(bp, 1);
7125 /* Reset the chip */
7126 bnx2x_reset_chip(bp, reset_code);
7128 /* Report UNLOAD_DONE to MCP */
7130 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
7134 void bnx2x_disable_close_the_gate(struct bnx2x *bp)
7138 DP(NETIF_MSG_HW, "Disabling \"close the gates\"\n");
7140 if (CHIP_IS_E1(bp)) {
7141 int port = BP_PORT(bp);
7142 u32 addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
7143 MISC_REG_AEU_MASK_ATTN_FUNC_0;
7145 val = REG_RD(bp, addr);
7147 REG_WR(bp, addr, val);
7148 } else if (CHIP_IS_E1H(bp)) {
7149 val = REG_RD(bp, MISC_REG_AEU_GENERAL_MASK);
7150 val &= ~(MISC_AEU_GENERAL_MASK_REG_AEU_PXP_CLOSE_MASK |
7151 MISC_AEU_GENERAL_MASK_REG_AEU_NIG_CLOSE_MASK);
7152 REG_WR(bp, MISC_REG_AEU_GENERAL_MASK, val);
7156 /* Close gates #2, #3 and #4: */
7157 static void bnx2x_set_234_gates(struct bnx2x *bp, bool close)
7161 /* Gates #2 and #4a are closed/opened for "not E1" only */
7162 if (!CHIP_IS_E1(bp)) {
7164 val = REG_RD(bp, PXP_REG_HST_DISCARD_DOORBELLS);
7165 REG_WR(bp, PXP_REG_HST_DISCARD_DOORBELLS,
7166 close ? (val | 0x1) : (val & (~(u32)1)));
7168 val = REG_RD(bp, PXP_REG_HST_DISCARD_INTERNAL_WRITES);
7169 REG_WR(bp, PXP_REG_HST_DISCARD_INTERNAL_WRITES,
7170 close ? (val | 0x1) : (val & (~(u32)1)));
7174 addr = BP_PORT(bp) ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
7175 val = REG_RD(bp, addr);
7176 REG_WR(bp, addr, (!close) ? (val | 0x1) : (val & (~(u32)1)));
7178 DP(NETIF_MSG_HW, "%s gates #2, #3 and #4\n",
7179 close ? "closing" : "opening");
7183 #define SHARED_MF_CLP_MAGIC 0x80000000 /* `magic' bit */
7185 static void bnx2x_clp_reset_prep(struct bnx2x *bp, u32 *magic_val)
7187 /* Do some magic... */
7188 u32 val = MF_CFG_RD(bp, shared_mf_config.clp_mb);
7189 *magic_val = val & SHARED_MF_CLP_MAGIC;
7190 MF_CFG_WR(bp, shared_mf_config.clp_mb, val | SHARED_MF_CLP_MAGIC);
7194 * bnx2x_clp_reset_done - restore the value of the `magic' bit.
7196 * @bp: driver handle
7197 * @magic_val: old value of the `magic' bit.
7199 static void bnx2x_clp_reset_done(struct bnx2x *bp, u32 magic_val)
7201 /* Restore the `magic' bit value... */
7202 u32 val = MF_CFG_RD(bp, shared_mf_config.clp_mb);
7203 MF_CFG_WR(bp, shared_mf_config.clp_mb,
7204 (val & (~SHARED_MF_CLP_MAGIC)) | magic_val);
7208 * bnx2x_reset_mcp_prep - prepare for MCP reset.
7210 * @bp: driver handle
7211 * @magic_val: old value of 'magic' bit.
7213 * Takes care of CLP configurations.
7215 static void bnx2x_reset_mcp_prep(struct bnx2x *bp, u32 *magic_val)
7218 u32 validity_offset;
7220 DP(NETIF_MSG_HW, "Starting\n");
7222 /* Set `magic' bit in order to save MF config */
7223 if (!CHIP_IS_E1(bp))
7224 bnx2x_clp_reset_prep(bp, magic_val);
7226 /* Get shmem offset */
7227 shmem = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
7228 validity_offset = offsetof(struct shmem_region, validity_map[0]);
7230 /* Clear validity map flags */
7232 REG_WR(bp, shmem + validity_offset, 0);
7235 #define MCP_TIMEOUT 5000 /* 5 seconds (in ms) */
7236 #define MCP_ONE_TIMEOUT 100 /* 100 ms */
7239 * bnx2x_mcp_wait_one - wait for MCP_ONE_TIMEOUT
7241 * @bp: driver handle
7243 static inline void bnx2x_mcp_wait_one(struct bnx2x *bp)
7245 /* special handling for emulation and FPGA,
7246 wait 10 times longer */
7247 if (CHIP_REV_IS_SLOW(bp))
7248 msleep(MCP_ONE_TIMEOUT*10);
7250 msleep(MCP_ONE_TIMEOUT);
7254 * initializes bp->common.shmem_base and waits for validity signature to appear
7256 static int bnx2x_init_shmem(struct bnx2x *bp)
7262 bp->common.shmem_base = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
7263 if (bp->common.shmem_base) {
7264 val = SHMEM_RD(bp, validity_map[BP_PORT(bp)]);
7265 if (val & SHR_MEM_VALIDITY_MB)
7269 bnx2x_mcp_wait_one(bp);
7271 } while (cnt++ < (MCP_TIMEOUT / MCP_ONE_TIMEOUT));
7273 BNX2X_ERR("BAD MCP validity signature\n");
7278 static int bnx2x_reset_mcp_comp(struct bnx2x *bp, u32 magic_val)
7280 int rc = bnx2x_init_shmem(bp);
7282 /* Restore the `magic' bit value */
7283 if (!CHIP_IS_E1(bp))
7284 bnx2x_clp_reset_done(bp, magic_val);
7289 static void bnx2x_pxp_prep(struct bnx2x *bp)
7291 if (!CHIP_IS_E1(bp)) {
7292 REG_WR(bp, PXP2_REG_RD_START_INIT, 0);
7293 REG_WR(bp, PXP2_REG_RQ_RBC_DONE, 0);
7294 REG_WR(bp, PXP2_REG_RQ_CFG_DONE, 0);
7300 * Reset the whole chip except for:
7302 * - PCI Glue, PSWHST, PXP/PXP2 RF (all controlled by
7305 * - MISC (including AEU)
7309 static void bnx2x_process_kill_chip_reset(struct bnx2x *bp)
7311 u32 not_reset_mask1, reset_mask1, not_reset_mask2, reset_mask2;
7314 MISC_REGISTERS_RESET_REG_1_RST_HC |
7315 MISC_REGISTERS_RESET_REG_1_RST_PXPV |
7316 MISC_REGISTERS_RESET_REG_1_RST_PXP;
7319 MISC_REGISTERS_RESET_REG_2_RST_MDIO |
7320 MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE |
7321 MISC_REGISTERS_RESET_REG_2_RST_EMAC1_HARD_CORE |
7322 MISC_REGISTERS_RESET_REG_2_RST_MISC_CORE |
7323 MISC_REGISTERS_RESET_REG_2_RST_RBCN |
7324 MISC_REGISTERS_RESET_REG_2_RST_GRC |
7325 MISC_REGISTERS_RESET_REG_2_RST_MCP_N_RESET_REG_HARD_CORE |
7326 MISC_REGISTERS_RESET_REG_2_RST_MCP_N_HARD_CORE_RST_B;
7328 reset_mask1 = 0xffffffff;
7331 reset_mask2 = 0xffff;
7333 reset_mask2 = 0x1ffff;
7335 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
7336 reset_mask1 & (~not_reset_mask1));
7337 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
7338 reset_mask2 & (~not_reset_mask2));
7343 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, reset_mask1);
7344 REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, reset_mask2);
7348 static int bnx2x_process_kill(struct bnx2x *bp)
7352 u32 sr_cnt, blk_cnt, port_is_idle_0, port_is_idle_1, pgl_exp_rom2;
7355 /* Empty the Tetris buffer, wait for 1s */
7357 sr_cnt = REG_RD(bp, PXP2_REG_RD_SR_CNT);
7358 blk_cnt = REG_RD(bp, PXP2_REG_RD_BLK_CNT);
7359 port_is_idle_0 = REG_RD(bp, PXP2_REG_RD_PORT_IS_IDLE_0);
7360 port_is_idle_1 = REG_RD(bp, PXP2_REG_RD_PORT_IS_IDLE_1);
7361 pgl_exp_rom2 = REG_RD(bp, PXP2_REG_PGL_EXP_ROM2);
7362 if ((sr_cnt == 0x7e) && (blk_cnt == 0xa0) &&
7363 ((port_is_idle_0 & 0x1) == 0x1) &&
7364 ((port_is_idle_1 & 0x1) == 0x1) &&
7365 (pgl_exp_rom2 == 0xffffffff))
7368 } while (cnt-- > 0);
7371 DP(NETIF_MSG_HW, "Tetris buffer didn't get empty or there"
7373 " outstanding read requests after 1s!\n");
7374 DP(NETIF_MSG_HW, "sr_cnt=0x%08x, blk_cnt=0x%08x,"
7375 " port_is_idle_0=0x%08x,"
7376 " port_is_idle_1=0x%08x, pgl_exp_rom2=0x%08x\n",
7377 sr_cnt, blk_cnt, port_is_idle_0, port_is_idle_1,
7384 /* Close gates #2, #3 and #4 */
7385 bnx2x_set_234_gates(bp, true);
7387 /* TBD: Indicate that "process kill" is in progress to MCP */
7389 /* Clear "unprepared" bit */
7390 REG_WR(bp, MISC_REG_UNPREPARED, 0);
7393 /* Make sure all is written to the chip before the reset */
7396 /* Wait for 1ms to empty GLUE and PCI-E core queues,
7397 * PSWHST, GRC and PSWRD Tetris buffer.
7401 /* Prepare to chip reset: */
7403 bnx2x_reset_mcp_prep(bp, &val);
7409 /* reset the chip */
7410 bnx2x_process_kill_chip_reset(bp);
7413 /* Recover after reset: */
7415 if (bnx2x_reset_mcp_comp(bp, val))
7421 /* Open the gates #2, #3 and #4 */
7422 bnx2x_set_234_gates(bp, false);
7424 /* TBD: IGU/AEU preparation bring back the AEU/IGU to a
7425 * reset state, re-enable attentions. */
7430 static int bnx2x_leader_reset(struct bnx2x *bp)
7433 /* Try to recover after the failure */
7434 if (bnx2x_process_kill(bp)) {
7435 printk(KERN_ERR "%s: Something bad had happen! Aii!\n",
7438 goto exit_leader_reset;
7441 /* Clear "reset is in progress" bit and update the driver state */
7442 bnx2x_set_reset_done(bp);
7443 bp->recovery_state = BNX2X_RECOVERY_DONE;
7447 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_RESERVED_08);
7452 /* Assumption: runs under rtnl lock. This together with the fact
7453 * that it's called only from bnx2x_reset_task() ensure that it
7454 * will never be called when netif_running(bp->dev) is false.
7456 static void bnx2x_parity_recover(struct bnx2x *bp)
7458 DP(NETIF_MSG_HW, "Handling parity\n");
7460 switch (bp->recovery_state) {
7461 case BNX2X_RECOVERY_INIT:
7462 DP(NETIF_MSG_HW, "State is BNX2X_RECOVERY_INIT\n");
7463 /* Try to get a LEADER_LOCK HW lock */
7464 if (bnx2x_trylock_hw_lock(bp,
7465 HW_LOCK_RESOURCE_RESERVED_08))
7468 /* Stop the driver */
7469 /* If interface has been removed - break */
7470 if (bnx2x_nic_unload(bp, UNLOAD_RECOVERY))
7473 bp->recovery_state = BNX2X_RECOVERY_WAIT;
7474 /* Ensure "is_leader" and "recovery_state"
7475 * update values are seen on other CPUs
7480 case BNX2X_RECOVERY_WAIT:
7481 DP(NETIF_MSG_HW, "State is BNX2X_RECOVERY_WAIT\n");
7482 if (bp->is_leader) {
7483 u32 load_counter = bnx2x_get_load_cnt(bp);
7485 /* Wait until all other functions get
7488 schedule_delayed_work(&bp->reset_task,
7492 /* If all other functions got down -
7493 * try to bring the chip back to
7494 * normal. In any case it's an exit
7495 * point for a leader.
7497 if (bnx2x_leader_reset(bp) ||
7498 bnx2x_nic_load(bp, LOAD_NORMAL)) {
7499 printk(KERN_ERR"%s: Recovery "
7500 "has failed. Power cycle is "
7501 "needed.\n", bp->dev->name);
7502 /* Disconnect this device */
7503 netif_device_detach(bp->dev);
7504 /* Block ifup for all function
7505 * of this ASIC until
7506 * "process kill" or power
7509 bnx2x_set_reset_in_progress(bp);
7510 /* Shut down the power */
7511 bnx2x_set_power_state(bp,
7518 } else { /* non-leader */
7519 if (!bnx2x_reset_is_done(bp)) {
7520 /* Try to get a LEADER_LOCK HW lock as
7521 * long as a former leader may have
7522 * been unloaded by the user or
7523 * released a leadership by another
7526 if (bnx2x_trylock_hw_lock(bp,
7527 HW_LOCK_RESOURCE_RESERVED_08)) {
7528 /* I'm a leader now! Restart a
7535 schedule_delayed_work(&bp->reset_task,
7539 } else { /* A leader has completed
7540 * the "process kill". It's an exit
7541 * point for a non-leader.
7543 bnx2x_nic_load(bp, LOAD_NORMAL);
7544 bp->recovery_state =
7545 BNX2X_RECOVERY_DONE;
7556 /* bnx2x_nic_unload() flushes the bnx2x_wq, thus reset task is
7557 * scheduled on a general queue in order to prevent a dead lock.
7559 static void bnx2x_reset_task(struct work_struct *work)
7561 struct bnx2x *bp = container_of(work, struct bnx2x, reset_task.work);
7563 #ifdef BNX2X_STOP_ON_ERROR
7564 BNX2X_ERR("reset task called but STOP_ON_ERROR defined"
7565 " so reset not done to allow debug dump,\n"
7566 KERN_ERR " you will need to reboot when done\n");
7572 if (!netif_running(bp->dev))
7573 goto reset_task_exit;
7575 if (unlikely(bp->recovery_state != BNX2X_RECOVERY_DONE))
7576 bnx2x_parity_recover(bp);
7578 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
7579 bnx2x_nic_load(bp, LOAD_NORMAL);
7586 /* end of nic load/unload */
7589 * Init service functions
7592 static u32 bnx2x_get_pretend_reg(struct bnx2x *bp)
7594 u32 base = PXP2_REG_PGL_PRETEND_FUNC_F0;
7595 u32 stride = PXP2_REG_PGL_PRETEND_FUNC_F1 - base;
7596 return base + (BP_ABS_FUNC(bp)) * stride;
7599 static void bnx2x_undi_int_disable_e1h(struct bnx2x *bp)
7601 u32 reg = bnx2x_get_pretend_reg(bp);
7603 /* Flush all outstanding writes */
7606 /* Pretend to be function 0 */
7608 REG_RD(bp, reg); /* Flush the GRC transaction (in the chip) */
7610 /* From now we are in the "like-E1" mode */
7611 bnx2x_int_disable(bp);
7613 /* Flush all outstanding writes */
7616 /* Restore the original function */
7617 REG_WR(bp, reg, BP_ABS_FUNC(bp));
7621 static inline void bnx2x_undi_int_disable(struct bnx2x *bp)
7624 bnx2x_int_disable(bp);
7626 bnx2x_undi_int_disable_e1h(bp);
7629 static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
7633 /* Check if there is any driver already loaded */
7634 val = REG_RD(bp, MISC_REG_UNPREPARED);
7636 /* Check if it is the UNDI driver
7637 * UNDI driver initializes CID offset for normal bell to 0x7
7639 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7640 val = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
7642 u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7643 /* save our pf_num */
7644 int orig_pf_num = bp->pf_num;
7648 /* clear the UNDI indication */
7649 REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
7651 BNX2X_DEV_INFO("UNDI is active! reset device\n");
7653 /* try unload UNDI on port 0 */
7656 (SHMEM_RD(bp, func_mb[bp->pf_num].drv_mb_header) &
7657 DRV_MSG_SEQ_NUMBER_MASK);
7658 reset_code = bnx2x_fw_command(bp, reset_code, 0);
7660 /* if UNDI is loaded on the other port */
7661 if (reset_code != FW_MSG_CODE_DRV_UNLOAD_COMMON) {
7663 /* send "DONE" for previous unload */
7664 bnx2x_fw_command(bp,
7665 DRV_MSG_CODE_UNLOAD_DONE, 0);
7667 /* unload UNDI on port 1 */
7670 (SHMEM_RD(bp, func_mb[bp->pf_num].drv_mb_header) &
7671 DRV_MSG_SEQ_NUMBER_MASK);
7672 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7674 bnx2x_fw_command(bp, reset_code, 0);
7677 /* now it's safe to release the lock */
7678 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7680 bnx2x_undi_int_disable(bp);
7682 /* close input traffic and wait for it */
7683 /* Do not rcv packets to BRB */
7685 (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_DRV_MASK :
7686 NIG_REG_LLH0_BRB1_DRV_MASK), 0x0);
7687 /* Do not direct rcv packets that are not for MCP to
7690 (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_NOT_MCP :
7691 NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
7694 (BP_PORT(bp) ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
7695 MISC_REG_AEU_MASK_ATTN_FUNC_0), 0);
7698 /* save NIG port swap info */
7699 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
7700 swap_en = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
7703 GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
7706 GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
7708 /* take the NIG out of reset and restore swap values */
7710 GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
7711 MISC_REGISTERS_RESET_REG_1_RST_NIG);
7712 REG_WR(bp, NIG_REG_PORT_SWAP, swap_val);
7713 REG_WR(bp, NIG_REG_STRAP_OVERRIDE, swap_en);
7715 /* send unload done to the MCP */
7716 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
7718 /* restore our func and fw_seq */
7719 bp->pf_num = orig_pf_num;
7721 (SHMEM_RD(bp, func_mb[bp->pf_num].drv_mb_header) &
7722 DRV_MSG_SEQ_NUMBER_MASK);
7724 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7728 static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
7730 u32 val, val2, val3, val4, id;
7733 /* Get the chip revision id and number. */
7734 /* chip num:16-31, rev:12-15, metal:4-11, bond_id:0-3 */
7735 val = REG_RD(bp, MISC_REG_CHIP_NUM);
7736 id = ((val & 0xffff) << 16);
7737 val = REG_RD(bp, MISC_REG_CHIP_REV);
7738 id |= ((val & 0xf) << 12);
7739 val = REG_RD(bp, MISC_REG_CHIP_METAL);
7740 id |= ((val & 0xff) << 4);
7741 val = REG_RD(bp, MISC_REG_BOND_ID);
7743 bp->common.chip_id = id;
7745 /* Set doorbell size */
7746 bp->db_size = (1 << BNX2X_DB_SHIFT);
7748 if (CHIP_IS_E2(bp)) {
7749 val = REG_RD(bp, MISC_REG_PORT4MODE_EN_OVWR);
7751 val = REG_RD(bp, MISC_REG_PORT4MODE_EN);
7753 val = (val >> 1) & 1;
7754 BNX2X_DEV_INFO("chip is in %s\n", val ? "4_PORT_MODE" :
7756 bp->common.chip_port_mode = val ? CHIP_4_PORT_MODE :
7759 if (CHIP_MODE_IS_4_PORT(bp))
7760 bp->pfid = (bp->pf_num >> 1); /* 0..3 */
7762 bp->pfid = (bp->pf_num & 0x6); /* 0, 2, 4, 6 */
7764 bp->common.chip_port_mode = CHIP_PORT_MODE_NONE; /* N/A */
7765 bp->pfid = bp->pf_num; /* 0..7 */
7769 * set base FW non-default (fast path) status block id, this value is
7770 * used to initialize the fw_sb_id saved on the fp/queue structure to
7771 * determine the id used by the FW.
7773 if (CHIP_IS_E1x(bp))
7774 bp->base_fw_ndsb = BP_PORT(bp) * FP_SB_MAX_E1x;
7776 bp->base_fw_ndsb = BP_PORT(bp) * FP_SB_MAX_E2;
7778 bp->link_params.chip_id = bp->common.chip_id;
7779 BNX2X_DEV_INFO("chip ID is 0x%x\n", id);
7781 val = (REG_RD(bp, 0x2874) & 0x55);
7782 if ((bp->common.chip_id & 0x1) ||
7783 (CHIP_IS_E1(bp) && val) || (CHIP_IS_E1H(bp) && (val == 0x55))) {
7784 bp->flags |= ONE_PORT_FLAG;
7785 BNX2X_DEV_INFO("single port device\n");
7788 val = REG_RD(bp, MCP_REG_MCPR_NVM_CFG4);
7789 bp->common.flash_size = (NVRAM_1MB_SIZE <<
7790 (val & MCPR_NVM_CFG4_FLASH_SIZE));
7791 BNX2X_DEV_INFO("flash_size 0x%x (%d)\n",
7792 bp->common.flash_size, bp->common.flash_size);
7794 bnx2x_init_shmem(bp);
7796 bp->common.shmem2_base = REG_RD(bp, (BP_PATH(bp) ?
7797 MISC_REG_GENERIC_CR_1 :
7798 MISC_REG_GENERIC_CR_0));
7800 bp->link_params.shmem_base = bp->common.shmem_base;
7801 bp->link_params.shmem2_base = bp->common.shmem2_base;
7802 BNX2X_DEV_INFO("shmem offset 0x%x shmem2 offset 0x%x\n",
7803 bp->common.shmem_base, bp->common.shmem2_base);
7805 if (!bp->common.shmem_base) {
7806 BNX2X_DEV_INFO("MCP not active\n");
7807 bp->flags |= NO_MCP_FLAG;
7811 bp->common.hw_config = SHMEM_RD(bp, dev_info.shared_hw_config.config);
7812 BNX2X_DEV_INFO("hw_config 0x%08x\n", bp->common.hw_config);
7814 bp->link_params.hw_led_mode = ((bp->common.hw_config &
7815 SHARED_HW_CFG_LED_MODE_MASK) >>
7816 SHARED_HW_CFG_LED_MODE_SHIFT);
7818 bp->link_params.feature_config_flags = 0;
7819 val = SHMEM_RD(bp, dev_info.shared_feature_config.config);
7820 if (val & SHARED_FEAT_CFG_OVERRIDE_PREEMPHASIS_CFG_ENABLED)
7821 bp->link_params.feature_config_flags |=
7822 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED;
7824 bp->link_params.feature_config_flags &=
7825 ~FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED;
7827 val = SHMEM_RD(bp, dev_info.bc_rev) >> 8;
7828 bp->common.bc_ver = val;
7829 BNX2X_DEV_INFO("bc_ver %X\n", val);
7830 if (val < BNX2X_BC_VER) {
7831 /* for now only warn
7832 * later we might need to enforce this */
7833 BNX2X_ERR("This driver needs bc_ver %X but found %X, "
7834 "please upgrade BC\n", BNX2X_BC_VER, val);
7836 bp->link_params.feature_config_flags |=
7837 (val >= REQ_BC_VER_4_VRFY_FIRST_PHY_OPT_MDL) ?
7838 FEATURE_CONFIG_BC_SUPPORTS_OPT_MDL_VRFY : 0;
7840 bp->link_params.feature_config_flags |=
7841 (val >= REQ_BC_VER_4_VRFY_SPECIFIC_PHY_OPT_MDL) ?
7842 FEATURE_CONFIG_BC_SUPPORTS_DUAL_PHY_OPT_MDL_VRFY : 0;
7844 pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_PMC, &pmc);
7845 bp->flags |= (pmc & PCI_PM_CAP_PME_D3cold) ? 0 : NO_WOL_FLAG;
7847 BNX2X_DEV_INFO("%sWoL capable\n",
7848 (bp->flags & NO_WOL_FLAG) ? "not " : "");
7850 val = SHMEM_RD(bp, dev_info.shared_hw_config.part_num);
7851 val2 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[4]);
7852 val3 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[8]);
7853 val4 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[12]);
7855 dev_info(&bp->pdev->dev, "part number %X-%X-%X-%X\n",
7856 val, val2, val3, val4);
7859 #define IGU_FID(val) GET_FIELD((val), IGU_REG_MAPPING_MEMORY_FID)
7860 #define IGU_VEC(val) GET_FIELD((val), IGU_REG_MAPPING_MEMORY_VECTOR)
7862 static void __devinit bnx2x_get_igu_cam_info(struct bnx2x *bp)
7864 int pfid = BP_FUNC(bp);
7865 int vn = BP_E1HVN(bp);
7870 bp->igu_base_sb = 0xff;
7872 if (CHIP_INT_MODE_IS_BC(bp)) {
7873 bp->igu_sb_cnt = min_t(u8, FP_SB_MAX_E1x,
7874 NUM_IGU_SB_REQUIRED(bp->l2_cid_count));
7876 bp->igu_base_sb = (CHIP_MODE_IS_4_PORT(bp) ? pfid : vn) *
7879 bp->igu_dsb_id = E1HVN_MAX * FP_SB_MAX_E1x +
7880 (CHIP_MODE_IS_4_PORT(bp) ? pfid : vn);
7885 /* IGU in normal mode - read CAM */
7886 for (igu_sb_id = 0; igu_sb_id < IGU_REG_MAPPING_MEMORY_SIZE;
7888 val = REG_RD(bp, IGU_REG_MAPPING_MEMORY + igu_sb_id * 4);
7889 if (!(val & IGU_REG_MAPPING_MEMORY_VALID))
7892 if ((fid & IGU_FID_ENCODE_IS_PF)) {
7893 if ((fid & IGU_FID_PF_NUM_MASK) != pfid)
7895 if (IGU_VEC(val) == 0)
7896 /* default status block */
7897 bp->igu_dsb_id = igu_sb_id;
7899 if (bp->igu_base_sb == 0xff)
7900 bp->igu_base_sb = igu_sb_id;
7905 bp->igu_sb_cnt = min_t(u8, bp->igu_sb_cnt,
7906 NUM_IGU_SB_REQUIRED(bp->l2_cid_count));
7907 if (bp->igu_sb_cnt == 0)
7908 BNX2X_ERR("CAM configuration error\n");
7911 static void __devinit bnx2x_link_settings_supported(struct bnx2x *bp,
7914 int cfg_size = 0, idx, port = BP_PORT(bp);
7916 /* Aggregation of supported attributes of all external phys */
7917 bp->port.supported[0] = 0;
7918 bp->port.supported[1] = 0;
7919 switch (bp->link_params.num_phys) {
7921 bp->port.supported[0] = bp->link_params.phy[INT_PHY].supported;
7925 bp->port.supported[0] = bp->link_params.phy[EXT_PHY1].supported;
7929 if (bp->link_params.multi_phy_config &
7930 PORT_HW_CFG_PHY_SWAPPED_ENABLED) {
7931 bp->port.supported[1] =
7932 bp->link_params.phy[EXT_PHY1].supported;
7933 bp->port.supported[0] =
7934 bp->link_params.phy[EXT_PHY2].supported;
7936 bp->port.supported[0] =
7937 bp->link_params.phy[EXT_PHY1].supported;
7938 bp->port.supported[1] =
7939 bp->link_params.phy[EXT_PHY2].supported;
7945 if (!(bp->port.supported[0] || bp->port.supported[1])) {
7946 BNX2X_ERR("NVRAM config error. BAD phy config."
7947 "PHY1 config 0x%x, PHY2 config 0x%x\n",
7949 dev_info.port_hw_config[port].external_phy_config),
7951 dev_info.port_hw_config[port].external_phy_config2));
7955 switch (switch_cfg) {
7957 bp->port.phy_addr = REG_RD(bp, NIG_REG_SERDES0_CTRL_PHY_ADDR +
7959 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
7962 case SWITCH_CFG_10G:
7963 bp->port.phy_addr = REG_RD(bp, NIG_REG_XGXS0_CTRL_PHY_ADDR +
7965 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
7969 BNX2X_ERR("BAD switch_cfg link_config 0x%x\n",
7970 bp->port.link_config[0]);
7973 /* mask what we support according to speed_cap_mask per configuration */
7974 for (idx = 0; idx < cfg_size; idx++) {
7975 if (!(bp->link_params.speed_cap_mask[idx] &
7976 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF))
7977 bp->port.supported[idx] &= ~SUPPORTED_10baseT_Half;
7979 if (!(bp->link_params.speed_cap_mask[idx] &
7980 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL))
7981 bp->port.supported[idx] &= ~SUPPORTED_10baseT_Full;
7983 if (!(bp->link_params.speed_cap_mask[idx] &
7984 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF))
7985 bp->port.supported[idx] &= ~SUPPORTED_100baseT_Half;
7987 if (!(bp->link_params.speed_cap_mask[idx] &
7988 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL))
7989 bp->port.supported[idx] &= ~SUPPORTED_100baseT_Full;
7991 if (!(bp->link_params.speed_cap_mask[idx] &
7992 PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))
7993 bp->port.supported[idx] &= ~(SUPPORTED_1000baseT_Half |
7994 SUPPORTED_1000baseT_Full);
7996 if (!(bp->link_params.speed_cap_mask[idx] &
7997 PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
7998 bp->port.supported[idx] &= ~SUPPORTED_2500baseX_Full;
8000 if (!(bp->link_params.speed_cap_mask[idx] &
8001 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G))
8002 bp->port.supported[idx] &= ~SUPPORTED_10000baseT_Full;
8006 BNX2X_DEV_INFO("supported 0x%x 0x%x\n", bp->port.supported[0],
8007 bp->port.supported[1]);
8010 static void __devinit bnx2x_link_settings_requested(struct bnx2x *bp)
8012 u32 link_config, idx, cfg_size = 0;
8013 bp->port.advertising[0] = 0;
8014 bp->port.advertising[1] = 0;
8015 switch (bp->link_params.num_phys) {
8024 for (idx = 0; idx < cfg_size; idx++) {
8025 bp->link_params.req_duplex[idx] = DUPLEX_FULL;
8026 link_config = bp->port.link_config[idx];
8027 switch (link_config & PORT_FEATURE_LINK_SPEED_MASK) {
8028 case PORT_FEATURE_LINK_SPEED_AUTO:
8029 if (bp->port.supported[idx] & SUPPORTED_Autoneg) {
8030 bp->link_params.req_line_speed[idx] =
8032 bp->port.advertising[idx] |=
8033 bp->port.supported[idx];
8035 /* force 10G, no AN */
8036 bp->link_params.req_line_speed[idx] =
8038 bp->port.advertising[idx] |=
8039 (ADVERTISED_10000baseT_Full |
8045 case PORT_FEATURE_LINK_SPEED_10M_FULL:
8046 if (bp->port.supported[idx] & SUPPORTED_10baseT_Full) {
8047 bp->link_params.req_line_speed[idx] =
8049 bp->port.advertising[idx] |=
8050 (ADVERTISED_10baseT_Full |
8053 BNX2X_ERROR("NVRAM config error. "
8054 "Invalid link_config 0x%x"
8055 " speed_cap_mask 0x%x\n",
8057 bp->link_params.speed_cap_mask[idx]);
8062 case PORT_FEATURE_LINK_SPEED_10M_HALF:
8063 if (bp->port.supported[idx] & SUPPORTED_10baseT_Half) {
8064 bp->link_params.req_line_speed[idx] =
8066 bp->link_params.req_duplex[idx] =
8068 bp->port.advertising[idx] |=
8069 (ADVERTISED_10baseT_Half |
8072 BNX2X_ERROR("NVRAM config error. "
8073 "Invalid link_config 0x%x"
8074 " speed_cap_mask 0x%x\n",
8076 bp->link_params.speed_cap_mask[idx]);
8081 case PORT_FEATURE_LINK_SPEED_100M_FULL:
8082 if (bp->port.supported[idx] &
8083 SUPPORTED_100baseT_Full) {
8084 bp->link_params.req_line_speed[idx] =
8086 bp->port.advertising[idx] |=
8087 (ADVERTISED_100baseT_Full |
8090 BNX2X_ERROR("NVRAM config error. "
8091 "Invalid link_config 0x%x"
8092 " speed_cap_mask 0x%x\n",
8094 bp->link_params.speed_cap_mask[idx]);
8099 case PORT_FEATURE_LINK_SPEED_100M_HALF:
8100 if (bp->port.supported[idx] &
8101 SUPPORTED_100baseT_Half) {
8102 bp->link_params.req_line_speed[idx] =
8104 bp->link_params.req_duplex[idx] =
8106 bp->port.advertising[idx] |=
8107 (ADVERTISED_100baseT_Half |
8110 BNX2X_ERROR("NVRAM config error. "
8111 "Invalid link_config 0x%x"
8112 " speed_cap_mask 0x%x\n",
8114 bp->link_params.speed_cap_mask[idx]);
8119 case PORT_FEATURE_LINK_SPEED_1G:
8120 if (bp->port.supported[idx] &
8121 SUPPORTED_1000baseT_Full) {
8122 bp->link_params.req_line_speed[idx] =
8124 bp->port.advertising[idx] |=
8125 (ADVERTISED_1000baseT_Full |
8128 BNX2X_ERROR("NVRAM config error. "
8129 "Invalid link_config 0x%x"
8130 " speed_cap_mask 0x%x\n",
8132 bp->link_params.speed_cap_mask[idx]);
8137 case PORT_FEATURE_LINK_SPEED_2_5G:
8138 if (bp->port.supported[idx] &
8139 SUPPORTED_2500baseX_Full) {
8140 bp->link_params.req_line_speed[idx] =
8142 bp->port.advertising[idx] |=
8143 (ADVERTISED_2500baseX_Full |
8146 BNX2X_ERROR("NVRAM config error. "
8147 "Invalid link_config 0x%x"
8148 " speed_cap_mask 0x%x\n",
8150 bp->link_params.speed_cap_mask[idx]);
8155 case PORT_FEATURE_LINK_SPEED_10G_CX4:
8156 case PORT_FEATURE_LINK_SPEED_10G_KX4:
8157 case PORT_FEATURE_LINK_SPEED_10G_KR:
8158 if (bp->port.supported[idx] &
8159 SUPPORTED_10000baseT_Full) {
8160 bp->link_params.req_line_speed[idx] =
8162 bp->port.advertising[idx] |=
8163 (ADVERTISED_10000baseT_Full |
8166 BNX2X_ERROR("NVRAM config error. "
8167 "Invalid link_config 0x%x"
8168 " speed_cap_mask 0x%x\n",
8170 bp->link_params.speed_cap_mask[idx]);
8176 BNX2X_ERROR("NVRAM config error. "
8177 "BAD link speed link_config 0x%x\n",
8179 bp->link_params.req_line_speed[idx] =
8181 bp->port.advertising[idx] =
8182 bp->port.supported[idx];
8186 bp->link_params.req_flow_ctrl[idx] = (link_config &
8187 PORT_FEATURE_FLOW_CONTROL_MASK);
8188 if ((bp->link_params.req_flow_ctrl[idx] ==
8189 BNX2X_FLOW_CTRL_AUTO) &&
8190 !(bp->port.supported[idx] & SUPPORTED_Autoneg)) {
8191 bp->link_params.req_flow_ctrl[idx] =
8192 BNX2X_FLOW_CTRL_NONE;
8195 BNX2X_DEV_INFO("req_line_speed %d req_duplex %d req_flow_ctrl"
8196 " 0x%x advertising 0x%x\n",
8197 bp->link_params.req_line_speed[idx],
8198 bp->link_params.req_duplex[idx],
8199 bp->link_params.req_flow_ctrl[idx],
8200 bp->port.advertising[idx]);
8204 static void __devinit bnx2x_set_mac_buf(u8 *mac_buf, u32 mac_lo, u16 mac_hi)
8206 mac_hi = cpu_to_be16(mac_hi);
8207 mac_lo = cpu_to_be32(mac_lo);
8208 memcpy(mac_buf, &mac_hi, sizeof(mac_hi));
8209 memcpy(mac_buf + sizeof(mac_hi), &mac_lo, sizeof(mac_lo));
8212 static void __devinit bnx2x_get_port_hwinfo(struct bnx2x *bp)
8214 int port = BP_PORT(bp);
8216 u32 ext_phy_type, ext_phy_config;
8218 bp->link_params.bp = bp;
8219 bp->link_params.port = port;
8221 bp->link_params.lane_config =
8222 SHMEM_RD(bp, dev_info.port_hw_config[port].lane_config);
8224 bp->link_params.speed_cap_mask[0] =
8226 dev_info.port_hw_config[port].speed_capability_mask);
8227 bp->link_params.speed_cap_mask[1] =
8229 dev_info.port_hw_config[port].speed_capability_mask2);
8230 bp->port.link_config[0] =
8231 SHMEM_RD(bp, dev_info.port_feature_config[port].link_config);
8233 bp->port.link_config[1] =
8234 SHMEM_RD(bp, dev_info.port_feature_config[port].link_config2);
8236 bp->link_params.multi_phy_config =
8237 SHMEM_RD(bp, dev_info.port_hw_config[port].multi_phy_config);
8238 /* If the device is capable of WoL, set the default state according
8241 config = SHMEM_RD(bp, dev_info.port_feature_config[port].config);
8242 bp->wol = (!(bp->flags & NO_WOL_FLAG) &&
8243 (config & PORT_FEATURE_WOL_ENABLED));
8245 BNX2X_DEV_INFO("lane_config 0x%08x "
8246 "speed_cap_mask0 0x%08x link_config0 0x%08x\n",
8247 bp->link_params.lane_config,
8248 bp->link_params.speed_cap_mask[0],
8249 bp->port.link_config[0]);
8251 bp->link_params.switch_cfg = (bp->port.link_config[0] &
8252 PORT_FEATURE_CONNECTED_SWITCH_MASK);
8253 bnx2x_phy_probe(&bp->link_params);
8254 bnx2x_link_settings_supported(bp, bp->link_params.switch_cfg);
8256 bnx2x_link_settings_requested(bp);
8259 * If connected directly, work with the internal PHY, otherwise, work
8260 * with the external PHY
8264 dev_info.port_hw_config[port].external_phy_config);
8265 ext_phy_type = XGXS_EXT_PHY_TYPE(ext_phy_config);
8266 if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT)
8267 bp->mdio.prtad = bp->port.phy_addr;
8269 else if ((ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) &&
8270 (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN))
8272 XGXS_EXT_PHY_ADDR(ext_phy_config);
8275 * Check if hw lock is required to access MDC/MDIO bus to the PHY(s)
8276 * In MF mode, it is set to cover self test cases
8279 bp->port.need_hw_lock = 1;
8281 bp->port.need_hw_lock = bnx2x_hw_lock_required(bp,
8282 bp->common.shmem_base,
8283 bp->common.shmem2_base);
8287 static void __devinit bnx2x_get_cnic_info(struct bnx2x *bp)
8289 u32 max_iscsi_conn = FW_ENCODE_32BIT_PATTERN ^ SHMEM_RD(bp,
8290 drv_lic_key[BP_PORT(bp)].max_iscsi_conn);
8291 u32 max_fcoe_conn = FW_ENCODE_32BIT_PATTERN ^ SHMEM_RD(bp,
8292 drv_lic_key[BP_PORT(bp)].max_fcoe_conn);
8294 /* Get the number of maximum allowed iSCSI and FCoE connections */
8295 bp->cnic_eth_dev.max_iscsi_conn =
8296 (max_iscsi_conn & BNX2X_MAX_ISCSI_INIT_CONN_MASK) >>
8297 BNX2X_MAX_ISCSI_INIT_CONN_SHIFT;
8299 bp->cnic_eth_dev.max_fcoe_conn =
8300 (max_fcoe_conn & BNX2X_MAX_FCOE_INIT_CONN_MASK) >>
8301 BNX2X_MAX_FCOE_INIT_CONN_SHIFT;
8303 BNX2X_DEV_INFO("max_iscsi_conn 0x%x max_fcoe_conn 0x%x\n",
8304 bp->cnic_eth_dev.max_iscsi_conn,
8305 bp->cnic_eth_dev.max_fcoe_conn);
8307 /* If mamimum allowed number of connections is zero -
8308 * disable the feature.
8310 if (!bp->cnic_eth_dev.max_iscsi_conn)
8311 bp->flags |= NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG;
8313 if (!bp->cnic_eth_dev.max_fcoe_conn)
8314 bp->flags |= NO_FCOE_FLAG;
8318 static void __devinit bnx2x_get_mac_hwinfo(struct bnx2x *bp)
8321 int func = BP_ABS_FUNC(bp);
8322 int port = BP_PORT(bp);
8324 u8 *iscsi_mac = bp->cnic_eth_dev.iscsi_mac;
8325 u8 *fip_mac = bp->fip_mac;
8329 BNX2X_ERROR("warning: random MAC workaround active\n");
8330 random_ether_addr(bp->dev->dev_addr);
8331 } else if (IS_MF(bp)) {
8332 val2 = MF_CFG_RD(bp, func_mf_config[func].mac_upper);
8333 val = MF_CFG_RD(bp, func_mf_config[func].mac_lower);
8334 if ((val2 != FUNC_MF_CFG_UPPERMAC_DEFAULT) &&
8335 (val != FUNC_MF_CFG_LOWERMAC_DEFAULT))
8336 bnx2x_set_mac_buf(bp->dev->dev_addr, val, val2);
8339 /* iSCSI and FCoE NPAR MACs: if there is no either iSCSI or
8340 * FCoE MAC then the appropriate feature should be disabled.
8343 u32 cfg = MF_CFG_RD(bp, func_ext_config[func].func_cfg);
8344 if (cfg & MACP_FUNC_CFG_FLAGS_ISCSI_OFFLOAD) {
8345 val2 = MF_CFG_RD(bp, func_ext_config[func].
8346 iscsi_mac_addr_upper);
8347 val = MF_CFG_RD(bp, func_ext_config[func].
8348 iscsi_mac_addr_lower);
8349 BNX2X_DEV_INFO("Read iSCSI MAC: "
8350 "0x%x:0x%04x\n", val2, val);
8351 bnx2x_set_mac_buf(iscsi_mac, val, val2);
8353 bp->flags |= NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG;
8355 if (cfg & MACP_FUNC_CFG_FLAGS_FCOE_OFFLOAD) {
8356 val2 = MF_CFG_RD(bp, func_ext_config[func].
8357 fcoe_mac_addr_upper);
8358 val = MF_CFG_RD(bp, func_ext_config[func].
8359 fcoe_mac_addr_lower);
8360 BNX2X_DEV_INFO("Read FCoE MAC to "
8361 "0x%x:0x%04x\n", val2, val);
8362 bnx2x_set_mac_buf(fip_mac, val, val2);
8365 bp->flags |= NO_FCOE_FLAG;
8369 /* in SF read MACs from port configuration */
8370 val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_upper);
8371 val = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_lower);
8372 bnx2x_set_mac_buf(bp->dev->dev_addr, val, val2);
8375 val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].
8377 val = SHMEM_RD(bp, dev_info.port_hw_config[port].
8379 bnx2x_set_mac_buf(iscsi_mac, val, val2);
8383 memcpy(bp->link_params.mac_addr, bp->dev->dev_addr, ETH_ALEN);
8384 memcpy(bp->dev->perm_addr, bp->dev->dev_addr, ETH_ALEN);
8387 /* Set the FCoE MAC in modes other then MF_SI */
8388 if (!CHIP_IS_E1x(bp)) {
8390 memcpy(fip_mac, bp->dev->dev_addr, ETH_ALEN);
8391 else if (!IS_MF(bp))
8392 memcpy(fip_mac, iscsi_mac, ETH_ALEN);
8395 /* Disable iSCSI if MAC configuration is
8398 if (!is_valid_ether_addr(iscsi_mac)) {
8399 bp->flags |= NO_ISCSI_FLAG;
8400 memset(iscsi_mac, 0, ETH_ALEN);
8403 /* Disable FCoE if MAC configuration is
8406 if (!is_valid_ether_addr(fip_mac)) {
8407 bp->flags |= NO_FCOE_FLAG;
8408 memset(bp->fip_mac, 0, ETH_ALEN);
8413 static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
8415 int /*abs*/func = BP_ABS_FUNC(bp);
8420 bnx2x_get_common_hwinfo(bp);
8422 if (CHIP_IS_E1x(bp)) {
8423 bp->common.int_block = INT_BLOCK_HC;
8425 bp->igu_dsb_id = DEF_SB_IGU_ID;
8426 bp->igu_base_sb = 0;
8427 bp->igu_sb_cnt = min_t(u8, FP_SB_MAX_E1x,
8428 NUM_IGU_SB_REQUIRED(bp->l2_cid_count));
8430 bp->common.int_block = INT_BLOCK_IGU;
8431 val = REG_RD(bp, IGU_REG_BLOCK_CONFIGURATION);
8432 if (val & IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN) {
8433 DP(NETIF_MSG_PROBE, "IGU Backward Compatible Mode\n");
8434 bp->common.int_block |= INT_BLOCK_MODE_BW_COMP;
8436 DP(NETIF_MSG_PROBE, "IGU Normal Mode\n");
8438 bnx2x_get_igu_cam_info(bp);
8441 DP(NETIF_MSG_PROBE, "igu_dsb_id %d igu_base_sb %d igu_sb_cnt %d\n",
8442 bp->igu_dsb_id, bp->igu_base_sb, bp->igu_sb_cnt);
8445 * Initialize MF configuration
8452 if (!CHIP_IS_E1(bp) && !BP_NOMCP(bp)) {
8454 "shmem2base 0x%x, size %d, mfcfg offset %d\n",
8455 bp->common.shmem2_base, SHMEM2_RD(bp, size),
8456 (u32)offsetof(struct shmem2_region, mf_cfg_addr));
8457 if (SHMEM2_HAS(bp, mf_cfg_addr))
8458 bp->common.mf_cfg_base = SHMEM2_RD(bp, mf_cfg_addr);
8460 bp->common.mf_cfg_base = bp->common.shmem_base +
8461 offsetof(struct shmem_region, func_mb) +
8462 E1H_FUNC_MAX * sizeof(struct drv_func_mb);
8464 * get mf configuration:
8465 * 1. existence of MF configuration
8466 * 2. MAC address must be legal (check only upper bytes)
8467 * for Switch-Independent mode;
8468 * OVLAN must be legal for Switch-Dependent mode
8469 * 3. SF_MODE configures specific MF mode
8471 if (bp->common.mf_cfg_base != SHMEM_MF_CFG_ADDR_NONE) {
8472 /* get mf configuration */
8474 dev_info.shared_feature_config.config);
8475 val &= SHARED_FEAT_CFG_FORCE_SF_MODE_MASK;
8478 case SHARED_FEAT_CFG_FORCE_SF_MODE_SWITCH_INDEPT:
8479 val = MF_CFG_RD(bp, func_mf_config[func].
8481 /* check for legal mac (upper bytes)*/
8482 if (val != 0xffff) {
8483 bp->mf_mode = MULTI_FUNCTION_SI;
8484 bp->mf_config[vn] = MF_CFG_RD(bp,
8485 func_mf_config[func].config);
8487 DP(NETIF_MSG_PROBE, "illegal MAC "
8488 "address for SI\n");
8490 case SHARED_FEAT_CFG_FORCE_SF_MODE_MF_ALLOWED:
8491 /* get OV configuration */
8493 func_mf_config[FUNC_0].e1hov_tag);
8494 val &= FUNC_MF_CFG_E1HOV_TAG_MASK;
8496 if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
8497 bp->mf_mode = MULTI_FUNCTION_SD;
8498 bp->mf_config[vn] = MF_CFG_RD(bp,
8499 func_mf_config[func].config);
8501 DP(NETIF_MSG_PROBE, "illegal OV for "
8505 /* Unknown configuration: reset mf_config */
8506 bp->mf_config[vn] = 0;
8507 DP(NETIF_MSG_PROBE, "Unknown MF mode 0x%x\n",
8512 BNX2X_DEV_INFO("%s function mode\n",
8513 IS_MF(bp) ? "multi" : "single");
8515 switch (bp->mf_mode) {
8516 case MULTI_FUNCTION_SD:
8517 val = MF_CFG_RD(bp, func_mf_config[func].e1hov_tag) &
8518 FUNC_MF_CFG_E1HOV_TAG_MASK;
8519 if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
8521 BNX2X_DEV_INFO("MF OV for func %d is %d"
8522 " (0x%04x)\n", func,
8523 bp->mf_ov, bp->mf_ov);
8525 BNX2X_ERR("No valid MF OV for func %d,"
8526 " aborting\n", func);
8530 case MULTI_FUNCTION_SI:
8531 BNX2X_DEV_INFO("func %d is in MF "
8532 "switch-independent mode\n", func);
8536 BNX2X_ERR("VN %d in single function mode,"
8545 /* adjust igu_sb_cnt to MF for E1x */
8546 if (CHIP_IS_E1x(bp) && IS_MF(bp))
8547 bp->igu_sb_cnt /= E1HVN_MAX;
8550 * adjust E2 sb count: to be removed when FW will support
8551 * more then 16 L2 clients
8553 #define MAX_L2_CLIENTS 16
8555 bp->igu_sb_cnt = min_t(u8, bp->igu_sb_cnt,
8556 MAX_L2_CLIENTS / (IS_MF(bp) ? 4 : 1));
8558 if (!BP_NOMCP(bp)) {
8559 bnx2x_get_port_hwinfo(bp);
8562 (SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
8563 DRV_MSG_SEQ_NUMBER_MASK);
8564 BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
8567 /* Get MAC addresses */
8568 bnx2x_get_mac_hwinfo(bp);
8571 bnx2x_get_cnic_info(bp);
8577 static void __devinit bnx2x_read_fwinfo(struct bnx2x *bp)
8579 int cnt, i, block_end, rodi;
8580 char vpd_data[BNX2X_VPD_LEN+1];
8581 char str_id_reg[VENDOR_ID_LEN+1];
8582 char str_id_cap[VENDOR_ID_LEN+1];
8585 cnt = pci_read_vpd(bp->pdev, 0, BNX2X_VPD_LEN, vpd_data);
8586 memset(bp->fw_ver, 0, sizeof(bp->fw_ver));
8588 if (cnt < BNX2X_VPD_LEN)
8591 i = pci_vpd_find_tag(vpd_data, 0, BNX2X_VPD_LEN,
8592 PCI_VPD_LRDT_RO_DATA);
8597 block_end = i + PCI_VPD_LRDT_TAG_SIZE +
8598 pci_vpd_lrdt_size(&vpd_data[i]);
8600 i += PCI_VPD_LRDT_TAG_SIZE;
8602 if (block_end > BNX2X_VPD_LEN)
8605 rodi = pci_vpd_find_info_keyword(vpd_data, i, block_end,
8606 PCI_VPD_RO_KEYWORD_MFR_ID);
8610 len = pci_vpd_info_field_size(&vpd_data[rodi]);
8612 if (len != VENDOR_ID_LEN)
8615 rodi += PCI_VPD_INFO_FLD_HDR_SIZE;
8617 /* vendor specific info */
8618 snprintf(str_id_reg, VENDOR_ID_LEN + 1, "%04x", PCI_VENDOR_ID_DELL);
8619 snprintf(str_id_cap, VENDOR_ID_LEN + 1, "%04X", PCI_VENDOR_ID_DELL);
8620 if (!strncmp(str_id_reg, &vpd_data[rodi], VENDOR_ID_LEN) ||
8621 !strncmp(str_id_cap, &vpd_data[rodi], VENDOR_ID_LEN)) {
8623 rodi = pci_vpd_find_info_keyword(vpd_data, i, block_end,
8624 PCI_VPD_RO_KEYWORD_VENDOR0);
8626 len = pci_vpd_info_field_size(&vpd_data[rodi]);
8628 rodi += PCI_VPD_INFO_FLD_HDR_SIZE;
8630 if (len < 32 && (len + rodi) <= BNX2X_VPD_LEN) {
8631 memcpy(bp->fw_ver, &vpd_data[rodi], len);
8632 bp->fw_ver[len] = ' ';
8641 static int __devinit bnx2x_init_bp(struct bnx2x *bp)
8647 /* Disable interrupt handling until HW is initialized */
8648 atomic_set(&bp->intr_sem, 1);
8649 smp_wmb(); /* Ensure that bp->intr_sem update is SMP-safe */
8651 mutex_init(&bp->port.phy_mutex);
8652 mutex_init(&bp->fw_mb_mutex);
8653 spin_lock_init(&bp->stats_lock);
8655 mutex_init(&bp->cnic_mutex);
8658 INIT_DELAYED_WORK(&bp->sp_task, bnx2x_sp_task);
8659 INIT_DELAYED_WORK(&bp->reset_task, bnx2x_reset_task);
8661 rc = bnx2x_get_hwinfo(bp);
8664 rc = bnx2x_alloc_mem_bp(bp);
8666 bnx2x_read_fwinfo(bp);
8670 /* need to reset chip if undi was active */
8672 bnx2x_undi_unload(bp);
8674 if (CHIP_REV_IS_FPGA(bp))
8675 dev_err(&bp->pdev->dev, "FPGA detected\n");
8677 if (BP_NOMCP(bp) && (func == 0))
8678 dev_err(&bp->pdev->dev, "MCP disabled, "
8679 "must load devices in order!\n");
8681 bp->multi_mode = multi_mode;
8682 bp->int_mode = int_mode;
8686 bp->flags &= ~TPA_ENABLE_FLAG;
8687 bp->dev->features &= ~NETIF_F_LRO;
8689 bp->flags |= TPA_ENABLE_FLAG;
8690 bp->dev->features |= NETIF_F_LRO;
8692 bp->disable_tpa = disable_tpa;
8695 bp->dropless_fc = 0;
8697 bp->dropless_fc = dropless_fc;
8701 bp->tx_ring_size = MAX_TX_AVAIL;
8703 /* make sure that the numbers are in the right granularity */
8704 bp->tx_ticks = (50 / BNX2X_BTR) * BNX2X_BTR;
8705 bp->rx_ticks = (25 / BNX2X_BTR) * BNX2X_BTR;
8707 timer_interval = (CHIP_REV_IS_SLOW(bp) ? 5*HZ : HZ);
8708 bp->current_interval = (poll ? poll : timer_interval);
8710 init_timer(&bp->timer);
8711 bp->timer.expires = jiffies + bp->current_interval;
8712 bp->timer.data = (unsigned long) bp;
8713 bp->timer.function = bnx2x_timer;
8715 bnx2x_dcbx_set_state(bp, true, BNX2X_DCBX_ENABLED_ON_NEG_ON);
8716 bnx2x_dcbx_init_params(bp);
8722 /****************************************************************************
8723 * General service functions
8724 ****************************************************************************/
8726 /* called with rtnl_lock */
8727 static int bnx2x_open(struct net_device *dev)
8729 struct bnx2x *bp = netdev_priv(dev);
8731 netif_carrier_off(dev);
8733 bnx2x_set_power_state(bp, PCI_D0);
8735 if (!bnx2x_reset_is_done(bp)) {
8737 /* Reset MCP mail box sequence if there is on going
8742 /* If it's the first function to load and reset done
8743 * is still not cleared it may mean that. We don't
8744 * check the attention state here because it may have
8745 * already been cleared by a "common" reset but we
8746 * shell proceed with "process kill" anyway.
8748 if ((bnx2x_get_load_cnt(bp) == 0) &&
8749 bnx2x_trylock_hw_lock(bp,
8750 HW_LOCK_RESOURCE_RESERVED_08) &&
8751 (!bnx2x_leader_reset(bp))) {
8752 DP(NETIF_MSG_HW, "Recovered in open\n");
8756 bnx2x_set_power_state(bp, PCI_D3hot);
8758 printk(KERN_ERR"%s: Recovery flow hasn't been properly"
8759 " completed yet. Try again later. If u still see this"
8760 " message after a few retries then power cycle is"
8761 " required.\n", bp->dev->name);
8767 bp->recovery_state = BNX2X_RECOVERY_DONE;
8769 return bnx2x_nic_load(bp, LOAD_OPEN);
8772 /* called with rtnl_lock */
8773 static int bnx2x_close(struct net_device *dev)
8775 struct bnx2x *bp = netdev_priv(dev);
8777 /* Unload the driver, release IRQs */
8778 bnx2x_nic_unload(bp, UNLOAD_CLOSE);
8779 bnx2x_set_power_state(bp, PCI_D3hot);
8784 #define E1_MAX_UC_LIST 29
8785 #define E1H_MAX_UC_LIST 30
8786 #define E2_MAX_UC_LIST 14
8787 static inline u8 bnx2x_max_uc_list(struct bnx2x *bp)
8790 return E1_MAX_UC_LIST;
8791 else if (CHIP_IS_E1H(bp))
8792 return E1H_MAX_UC_LIST;
8794 return E2_MAX_UC_LIST;
8798 static inline u8 bnx2x_uc_list_cam_offset(struct bnx2x *bp)
8801 /* CAM Entries for Port0:
8804 * 2 - iSCSI L2 ring ETH MAC
8807 * Port1 entries are allocated the same way starting from
8810 return 3 + 32 * BP_PORT(bp);
8811 else if (CHIP_IS_E1H(bp)) {
8813 * 0-7 - prim ETH MAC for each function
8814 * 8-15 - iSCSI L2 ring ETH MAC for each function
8815 * 16 till 255 UC MAC lists for each function
8817 * Remark: There is no FCoE support for E1H, thus FCoE related
8818 * MACs are not considered.
8820 return E1H_FUNC_MAX * (CAM_ISCSI_ETH_LINE + 1) +
8821 bnx2x_max_uc_list(bp) * BP_FUNC(bp);
8823 /* CAM Entries (there is a separate CAM per engine):
8824 * 0-4 - prim ETH MAC for each function
8825 * 4-7 - iSCSI L2 ring ETH MAC for each function
8826 * 8-11 - FIP ucast L2 MAC for each function
8827 * 12-15 - ALL_ENODE_MACS mcast MAC for each function
8828 * 16 till 71 UC MAC lists for each function
8831 (CHIP_MODE_IS_4_PORT(bp) ? BP_FUNC(bp) : BP_VN(bp));
8833 return E2_FUNC_MAX * (CAM_MAX_PF_LINE + 1) +
8834 bnx2x_max_uc_list(bp) * func_idx;
8838 /* set uc list, do not wait as wait implies sleep and
8839 * set_rx_mode can be invoked from non-sleepable context.
8841 * Instead we use the same ramrod data buffer each time we need
8842 * to configure a list of addresses, and use the fact that the
8843 * list of MACs is changed in an incremental way and that the
8844 * function is called under the netif_addr_lock. A temporary
8845 * inconsistent CAM configuration (possible in case of very fast
8846 * sequence of add/del/add on the host side) will shortly be
8847 * restored by the handler of the last ramrod.
8849 static int bnx2x_set_uc_list(struct bnx2x *bp)
8852 struct net_device *dev = bp->dev;
8853 u8 offset = bnx2x_uc_list_cam_offset(bp);
8854 struct netdev_hw_addr *ha;
8855 struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, uc_mac_config);
8856 dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, uc_mac_config);
8858 if (netdev_uc_count(dev) > bnx2x_max_uc_list(bp))
8861 netdev_for_each_uc_addr(ha, dev) {
8863 config_cmd->config_table[i].msb_mac_addr =
8864 swab16(*(u16 *)&bnx2x_uc_addr(ha)[0]);
8865 config_cmd->config_table[i].middle_mac_addr =
8866 swab16(*(u16 *)&bnx2x_uc_addr(ha)[2]);
8867 config_cmd->config_table[i].lsb_mac_addr =
8868 swab16(*(u16 *)&bnx2x_uc_addr(ha)[4]);
8870 config_cmd->config_table[i].vlan_id = 0;
8871 config_cmd->config_table[i].pf_id = BP_FUNC(bp);
8872 config_cmd->config_table[i].clients_bit_vector =
8873 cpu_to_le32(1 << BP_L_ID(bp));
8875 SET_FLAG(config_cmd->config_table[i].flags,
8876 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
8877 T_ETH_MAC_COMMAND_SET);
8880 "setting UCAST[%d] (%04x:%04x:%04x)\n", i,
8881 config_cmd->config_table[i].msb_mac_addr,
8882 config_cmd->config_table[i].middle_mac_addr,
8883 config_cmd->config_table[i].lsb_mac_addr);
8887 /* Set uc MAC in NIG */
8888 bnx2x_set_mac_in_nig(bp, 1, bnx2x_uc_addr(ha),
8889 LLH_CAM_ETH_LINE + i);
8891 old = config_cmd->hdr.length;
8893 for (; i < old; i++) {
8894 if (CAM_IS_INVALID(config_cmd->
8896 /* already invalidated */
8900 SET_FLAG(config_cmd->config_table[i].flags,
8901 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
8902 T_ETH_MAC_COMMAND_INVALIDATE);
8908 config_cmd->hdr.length = i;
8909 config_cmd->hdr.offset = offset;
8910 config_cmd->hdr.client_id = 0xff;
8911 /* Mark that this ramrod doesn't use bp->set_mac_pending for
8914 config_cmd->hdr.echo = 0;
8918 return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
8919 U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
8923 void bnx2x_invalidate_uc_list(struct bnx2x *bp)
8926 struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, uc_mac_config);
8927 dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, uc_mac_config);
8928 int ramrod_flags = WAIT_RAMROD_COMMON;
8929 u8 offset = bnx2x_uc_list_cam_offset(bp);
8930 u8 max_list_size = bnx2x_max_uc_list(bp);
8932 for (i = 0; i < max_list_size; i++) {
8933 SET_FLAG(config_cmd->config_table[i].flags,
8934 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
8935 T_ETH_MAC_COMMAND_INVALIDATE);
8936 bnx2x_set_mac_in_nig(bp, 0, NULL, LLH_CAM_ETH_LINE + 1 + i);
8941 config_cmd->hdr.length = max_list_size;
8942 config_cmd->hdr.offset = offset;
8943 config_cmd->hdr.client_id = 0xff;
8944 /* We'll wait for a completion this time... */
8945 config_cmd->hdr.echo = 1;
8947 bp->set_mac_pending = 1;
8951 bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
8952 U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
8954 /* Wait for a completion */
8955 bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending,
8960 static inline int bnx2x_set_mc_list(struct bnx2x *bp)
8962 /* some multicasts */
8963 if (CHIP_IS_E1(bp)) {
8964 return bnx2x_set_e1_mc_list(bp);
8965 } else { /* E1H and newer */
8966 return bnx2x_set_e1h_mc_list(bp);
8970 /* called with netif_tx_lock from dev_mcast.c */
8971 void bnx2x_set_rx_mode(struct net_device *dev)
8973 struct bnx2x *bp = netdev_priv(dev);
8974 u32 rx_mode = BNX2X_RX_MODE_NORMAL;
8976 if (bp->state != BNX2X_STATE_OPEN) {
8977 DP(NETIF_MSG_IFUP, "state is %x, returning\n", bp->state);
8981 DP(NETIF_MSG_IFUP, "dev->flags = %x\n", dev->flags);
8983 if (dev->flags & IFF_PROMISC)
8984 rx_mode = BNX2X_RX_MODE_PROMISC;
8985 else if (dev->flags & IFF_ALLMULTI)
8986 rx_mode = BNX2X_RX_MODE_ALLMULTI;
8988 /* some multicasts */
8989 if (bnx2x_set_mc_list(bp))
8990 rx_mode = BNX2X_RX_MODE_ALLMULTI;
8993 if (bnx2x_set_uc_list(bp))
8994 rx_mode = BNX2X_RX_MODE_PROMISC;
8997 bp->rx_mode = rx_mode;
8998 bnx2x_set_storm_rx_mode(bp);
9001 /* called with rtnl_lock */
9002 static int bnx2x_mdio_read(struct net_device *netdev, int prtad,
9003 int devad, u16 addr)
9005 struct bnx2x *bp = netdev_priv(netdev);
9009 DP(NETIF_MSG_LINK, "mdio_read: prtad 0x%x, devad 0x%x, addr 0x%x\n",
9010 prtad, devad, addr);
9012 /* The HW expects different devad if CL22 is used */
9013 devad = (devad == MDIO_DEVAD_NONE) ? DEFAULT_PHY_DEV_ADDR : devad;
9015 bnx2x_acquire_phy_lock(bp);
9016 rc = bnx2x_phy_read(&bp->link_params, prtad, devad, addr, &value);
9017 bnx2x_release_phy_lock(bp);
9018 DP(NETIF_MSG_LINK, "mdio_read_val 0x%x rc = 0x%x\n", value, rc);
9025 /* called with rtnl_lock */
9026 static int bnx2x_mdio_write(struct net_device *netdev, int prtad, int devad,
9027 u16 addr, u16 value)
9029 struct bnx2x *bp = netdev_priv(netdev);
9032 DP(NETIF_MSG_LINK, "mdio_write: prtad 0x%x, devad 0x%x, addr 0x%x,"
9033 " value 0x%x\n", prtad, devad, addr, value);
9035 /* The HW expects different devad if CL22 is used */
9036 devad = (devad == MDIO_DEVAD_NONE) ? DEFAULT_PHY_DEV_ADDR : devad;
9038 bnx2x_acquire_phy_lock(bp);
9039 rc = bnx2x_phy_write(&bp->link_params, prtad, devad, addr, value);
9040 bnx2x_release_phy_lock(bp);
9044 /* called with rtnl_lock */
9045 static int bnx2x_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
9047 struct bnx2x *bp = netdev_priv(dev);
9048 struct mii_ioctl_data *mdio = if_mii(ifr);
9050 DP(NETIF_MSG_LINK, "ioctl: phy id 0x%x, reg 0x%x, val_in 0x%x\n",
9051 mdio->phy_id, mdio->reg_num, mdio->val_in);
9053 if (!netif_running(dev))
9056 return mdio_mii_ioctl(&bp->mdio, mdio, cmd);
9059 #ifdef CONFIG_NET_POLL_CONTROLLER
9060 static void poll_bnx2x(struct net_device *dev)
9062 struct bnx2x *bp = netdev_priv(dev);
9064 disable_irq(bp->pdev->irq);
9065 bnx2x_interrupt(bp->pdev->irq, dev);
9066 enable_irq(bp->pdev->irq);
9070 static const struct net_device_ops bnx2x_netdev_ops = {
9071 .ndo_open = bnx2x_open,
9072 .ndo_stop = bnx2x_close,
9073 .ndo_start_xmit = bnx2x_start_xmit,
9074 .ndo_select_queue = bnx2x_select_queue,
9075 .ndo_set_rx_mode = bnx2x_set_rx_mode,
9076 .ndo_set_mac_address = bnx2x_change_mac_addr,
9077 .ndo_validate_addr = eth_validate_addr,
9078 .ndo_do_ioctl = bnx2x_ioctl,
9079 .ndo_change_mtu = bnx2x_change_mtu,
9080 .ndo_fix_features = bnx2x_fix_features,
9081 .ndo_set_features = bnx2x_set_features,
9082 .ndo_tx_timeout = bnx2x_tx_timeout,
9083 #ifdef CONFIG_NET_POLL_CONTROLLER
9084 .ndo_poll_controller = poll_bnx2x,
9088 static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
9089 struct net_device *dev)
9094 SET_NETDEV_DEV(dev, &pdev->dev);
9095 bp = netdev_priv(dev);
9100 bp->pf_num = PCI_FUNC(pdev->devfn);
9102 rc = pci_enable_device(pdev);
9104 dev_err(&bp->pdev->dev,
9105 "Cannot enable PCI device, aborting\n");
9109 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
9110 dev_err(&bp->pdev->dev,
9111 "Cannot find PCI device base address, aborting\n");
9113 goto err_out_disable;
9116 if (!(pci_resource_flags(pdev, 2) & IORESOURCE_MEM)) {
9117 dev_err(&bp->pdev->dev, "Cannot find second PCI device"
9118 " base address, aborting\n");
9120 goto err_out_disable;
9123 if (atomic_read(&pdev->enable_cnt) == 1) {
9124 rc = pci_request_regions(pdev, DRV_MODULE_NAME);
9126 dev_err(&bp->pdev->dev,
9127 "Cannot obtain PCI resources, aborting\n");
9128 goto err_out_disable;
9131 pci_set_master(pdev);
9132 pci_save_state(pdev);
9135 bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
9136 if (bp->pm_cap == 0) {
9137 dev_err(&bp->pdev->dev,
9138 "Cannot find power management capability, aborting\n");
9140 goto err_out_release;
9143 bp->pcie_cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
9144 if (bp->pcie_cap == 0) {
9145 dev_err(&bp->pdev->dev,
9146 "Cannot find PCI Express capability, aborting\n");
9148 goto err_out_release;
9151 if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)) == 0) {
9152 bp->flags |= USING_DAC_FLAG;
9153 if (dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64)) != 0) {
9154 dev_err(&bp->pdev->dev, "dma_set_coherent_mask"
9155 " failed, aborting\n");
9157 goto err_out_release;
9160 } else if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)) != 0) {
9161 dev_err(&bp->pdev->dev,
9162 "System does not support DMA, aborting\n");
9164 goto err_out_release;
9167 dev->mem_start = pci_resource_start(pdev, 0);
9168 dev->base_addr = dev->mem_start;
9169 dev->mem_end = pci_resource_end(pdev, 0);
9171 dev->irq = pdev->irq;
9173 bp->regview = pci_ioremap_bar(pdev, 0);
9175 dev_err(&bp->pdev->dev,
9176 "Cannot map register space, aborting\n");
9178 goto err_out_release;
9181 bp->doorbells = ioremap_nocache(pci_resource_start(pdev, 2),
9182 min_t(u64, BNX2X_DB_SIZE(bp),
9183 pci_resource_len(pdev, 2)));
9184 if (!bp->doorbells) {
9185 dev_err(&bp->pdev->dev,
9186 "Cannot map doorbell space, aborting\n");
9191 bnx2x_set_power_state(bp, PCI_D0);
9193 /* clean indirect addresses */
9194 pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
9195 PCICFG_VENDOR_ID_OFFSET);
9196 REG_WR(bp, PXP2_REG_PGL_ADDR_88_F0 + BP_PORT(bp)*16, 0);
9197 REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F0 + BP_PORT(bp)*16, 0);
9198 REG_WR(bp, PXP2_REG_PGL_ADDR_90_F0 + BP_PORT(bp)*16, 0);
9199 REG_WR(bp, PXP2_REG_PGL_ADDR_94_F0 + BP_PORT(bp)*16, 0);
9201 /* Reset the load counter */
9202 bnx2x_clear_load_cnt(bp);
9204 dev->watchdog_timeo = TX_TIMEOUT;
9206 dev->netdev_ops = &bnx2x_netdev_ops;
9207 bnx2x_set_ethtool_ops(dev);
9209 dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
9210 NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6 |
9211 NETIF_F_RXCSUM | NETIF_F_LRO | NETIF_F_HW_VLAN_TX;
9213 dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
9214 NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_HIGHDMA;
9216 dev->features |= dev->hw_features | NETIF_F_HW_VLAN_RX;
9217 if (bp->flags & USING_DAC_FLAG)
9218 dev->features |= NETIF_F_HIGHDMA;
9220 /* Add Loopback capability to the device */
9221 dev->hw_features |= NETIF_F_LOOPBACK;
9224 dev->dcbnl_ops = &bnx2x_dcbnl_ops;
9227 /* get_port_hwinfo() will set prtad and mmds properly */
9228 bp->mdio.prtad = MDIO_PRTAD_NONE;
9230 bp->mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
9232 bp->mdio.mdio_read = bnx2x_mdio_read;
9233 bp->mdio.mdio_write = bnx2x_mdio_write;
9239 iounmap(bp->regview);
9242 if (bp->doorbells) {
9243 iounmap(bp->doorbells);
9244 bp->doorbells = NULL;
9248 if (atomic_read(&pdev->enable_cnt) == 1)
9249 pci_release_regions(pdev);
9252 pci_disable_device(pdev);
9253 pci_set_drvdata(pdev, NULL);
9259 static void __devinit bnx2x_get_pcie_width_speed(struct bnx2x *bp,
9260 int *width, int *speed)
9262 u32 val = REG_RD(bp, PCICFG_OFFSET + PCICFG_LINK_CONTROL);
9264 *width = (val & PCICFG_LINK_WIDTH) >> PCICFG_LINK_WIDTH_SHIFT;
9266 /* return value of 1=2.5GHz 2=5GHz */
9267 *speed = (val & PCICFG_LINK_SPEED) >> PCICFG_LINK_SPEED_SHIFT;
9270 static int bnx2x_check_firmware(struct bnx2x *bp)
9272 const struct firmware *firmware = bp->firmware;
9273 struct bnx2x_fw_file_hdr *fw_hdr;
9274 struct bnx2x_fw_file_section *sections;
9275 u32 offset, len, num_ops;
9280 if (firmware->size < sizeof(struct bnx2x_fw_file_hdr))
9283 fw_hdr = (struct bnx2x_fw_file_hdr *)firmware->data;
9284 sections = (struct bnx2x_fw_file_section *)fw_hdr;
9286 /* Make sure none of the offsets and sizes make us read beyond
9287 * the end of the firmware data */
9288 for (i = 0; i < sizeof(*fw_hdr) / sizeof(*sections); i++) {
9289 offset = be32_to_cpu(sections[i].offset);
9290 len = be32_to_cpu(sections[i].len);
9291 if (offset + len > firmware->size) {
9292 dev_err(&bp->pdev->dev,
9293 "Section %d length is out of bounds\n", i);
9298 /* Likewise for the init_ops offsets */
9299 offset = be32_to_cpu(fw_hdr->init_ops_offsets.offset);
9300 ops_offsets = (u16 *)(firmware->data + offset);
9301 num_ops = be32_to_cpu(fw_hdr->init_ops.len) / sizeof(struct raw_op);
9303 for (i = 0; i < be32_to_cpu(fw_hdr->init_ops_offsets.len) / 2; i++) {
9304 if (be16_to_cpu(ops_offsets[i]) > num_ops) {
9305 dev_err(&bp->pdev->dev,
9306 "Section offset %d is out of bounds\n", i);
9311 /* Check FW version */
9312 offset = be32_to_cpu(fw_hdr->fw_version.offset);
9313 fw_ver = firmware->data + offset;
9314 if ((fw_ver[0] != BCM_5710_FW_MAJOR_VERSION) ||
9315 (fw_ver[1] != BCM_5710_FW_MINOR_VERSION) ||
9316 (fw_ver[2] != BCM_5710_FW_REVISION_VERSION) ||
9317 (fw_ver[3] != BCM_5710_FW_ENGINEERING_VERSION)) {
9318 dev_err(&bp->pdev->dev,
9319 "Bad FW version:%d.%d.%d.%d. Should be %d.%d.%d.%d\n",
9320 fw_ver[0], fw_ver[1], fw_ver[2],
9321 fw_ver[3], BCM_5710_FW_MAJOR_VERSION,
9322 BCM_5710_FW_MINOR_VERSION,
9323 BCM_5710_FW_REVISION_VERSION,
9324 BCM_5710_FW_ENGINEERING_VERSION);
9331 static inline void be32_to_cpu_n(const u8 *_source, u8 *_target, u32 n)
9333 const __be32 *source = (const __be32 *)_source;
9334 u32 *target = (u32 *)_target;
9337 for (i = 0; i < n/4; i++)
9338 target[i] = be32_to_cpu(source[i]);
9342 Ops array is stored in the following format:
9343 {op(8bit), offset(24bit, big endian), data(32bit, big endian)}
9345 static inline void bnx2x_prep_ops(const u8 *_source, u8 *_target, u32 n)
9347 const __be32 *source = (const __be32 *)_source;
9348 struct raw_op *target = (struct raw_op *)_target;
9351 for (i = 0, j = 0; i < n/8; i++, j += 2) {
9352 tmp = be32_to_cpu(source[j]);
9353 target[i].op = (tmp >> 24) & 0xff;
9354 target[i].offset = tmp & 0xffffff;
9355 target[i].raw_data = be32_to_cpu(source[j + 1]);
9360 * IRO array is stored in the following format:
9361 * {base(24bit), m1(16bit), m2(16bit), m3(16bit), size(16bit) }
9363 static inline void bnx2x_prep_iro(const u8 *_source, u8 *_target, u32 n)
9365 const __be32 *source = (const __be32 *)_source;
9366 struct iro *target = (struct iro *)_target;
9369 for (i = 0, j = 0; i < n/sizeof(struct iro); i++) {
9370 target[i].base = be32_to_cpu(source[j]);
9372 tmp = be32_to_cpu(source[j]);
9373 target[i].m1 = (tmp >> 16) & 0xffff;
9374 target[i].m2 = tmp & 0xffff;
9376 tmp = be32_to_cpu(source[j]);
9377 target[i].m3 = (tmp >> 16) & 0xffff;
9378 target[i].size = tmp & 0xffff;
9383 static inline void be16_to_cpu_n(const u8 *_source, u8 *_target, u32 n)
9385 const __be16 *source = (const __be16 *)_source;
9386 u16 *target = (u16 *)_target;
9389 for (i = 0; i < n/2; i++)
9390 target[i] = be16_to_cpu(source[i]);
9393 #define BNX2X_ALLOC_AND_SET(arr, lbl, func) \
9395 u32 len = be32_to_cpu(fw_hdr->arr.len); \
9396 bp->arr = kmalloc(len, GFP_KERNEL); \
9398 pr_err("Failed to allocate %d bytes for "#arr"\n", len); \
9401 func(bp->firmware->data + be32_to_cpu(fw_hdr->arr.offset), \
9402 (u8 *)bp->arr, len); \
9405 int bnx2x_init_firmware(struct bnx2x *bp)
9407 const char *fw_file_name;
9408 struct bnx2x_fw_file_hdr *fw_hdr;
9412 fw_file_name = FW_FILE_NAME_E1;
9413 else if (CHIP_IS_E1H(bp))
9414 fw_file_name = FW_FILE_NAME_E1H;
9415 else if (CHIP_IS_E2(bp))
9416 fw_file_name = FW_FILE_NAME_E2;
9418 BNX2X_ERR("Unsupported chip revision\n");
9422 BNX2X_DEV_INFO("Loading %s\n", fw_file_name);
9424 rc = request_firmware(&bp->firmware, fw_file_name, &bp->pdev->dev);
9426 BNX2X_ERR("Can't load firmware file %s\n", fw_file_name);
9427 goto request_firmware_exit;
9430 rc = bnx2x_check_firmware(bp);
9432 BNX2X_ERR("Corrupt firmware file %s\n", fw_file_name);
9433 goto request_firmware_exit;
9436 fw_hdr = (struct bnx2x_fw_file_hdr *)bp->firmware->data;
9438 /* Initialize the pointers to the init arrays */
9440 BNX2X_ALLOC_AND_SET(init_data, request_firmware_exit, be32_to_cpu_n);
9443 BNX2X_ALLOC_AND_SET(init_ops, init_ops_alloc_err, bnx2x_prep_ops);
9446 BNX2X_ALLOC_AND_SET(init_ops_offsets, init_offsets_alloc_err,
9449 /* STORMs firmware */
9450 INIT_TSEM_INT_TABLE_DATA(bp) = bp->firmware->data +
9451 be32_to_cpu(fw_hdr->tsem_int_table_data.offset);
9452 INIT_TSEM_PRAM_DATA(bp) = bp->firmware->data +
9453 be32_to_cpu(fw_hdr->tsem_pram_data.offset);
9454 INIT_USEM_INT_TABLE_DATA(bp) = bp->firmware->data +
9455 be32_to_cpu(fw_hdr->usem_int_table_data.offset);
9456 INIT_USEM_PRAM_DATA(bp) = bp->firmware->data +
9457 be32_to_cpu(fw_hdr->usem_pram_data.offset);
9458 INIT_XSEM_INT_TABLE_DATA(bp) = bp->firmware->data +
9459 be32_to_cpu(fw_hdr->xsem_int_table_data.offset);
9460 INIT_XSEM_PRAM_DATA(bp) = bp->firmware->data +
9461 be32_to_cpu(fw_hdr->xsem_pram_data.offset);
9462 INIT_CSEM_INT_TABLE_DATA(bp) = bp->firmware->data +
9463 be32_to_cpu(fw_hdr->csem_int_table_data.offset);
9464 INIT_CSEM_PRAM_DATA(bp) = bp->firmware->data +
9465 be32_to_cpu(fw_hdr->csem_pram_data.offset);
9467 BNX2X_ALLOC_AND_SET(iro_arr, iro_alloc_err, bnx2x_prep_iro);
9472 kfree(bp->init_ops_offsets);
9473 init_offsets_alloc_err:
9474 kfree(bp->init_ops);
9476 kfree(bp->init_data);
9477 request_firmware_exit:
9478 release_firmware(bp->firmware);
9483 static inline int bnx2x_set_qm_cid_count(struct bnx2x *bp, int l2_cid_count)
9485 int cid_count = L2_FP_COUNT(l2_cid_count);
9488 cid_count += CNIC_CID_MAX;
9490 return roundup(cid_count, QM_CID_ROUND);
9493 static int __devinit bnx2x_init_one(struct pci_dev *pdev,
9494 const struct pci_device_id *ent)
9496 struct net_device *dev = NULL;
9498 int pcie_width, pcie_speed;
9501 switch (ent->driver_data) {
9505 cid_count = FP_SB_MAX_E1x;
9510 cid_count = FP_SB_MAX_E2;
9514 pr_err("Unknown board_type (%ld), aborting\n",
9519 cid_count += NONE_ETH_CONTEXT_USE + CNIC_CONTEXT_USE;
9521 /* dev zeroed in init_etherdev */
9522 dev = alloc_etherdev_mq(sizeof(*bp), cid_count);
9524 dev_err(&pdev->dev, "Cannot allocate net device\n");
9528 bp = netdev_priv(dev);
9529 bp->msg_enable = debug;
9531 pci_set_drvdata(pdev, dev);
9533 bp->l2_cid_count = cid_count;
9535 rc = bnx2x_init_dev(pdev, dev);
9541 rc = bnx2x_init_bp(bp);
9545 /* calc qm_cid_count */
9546 bp->qm_cid_count = bnx2x_set_qm_cid_count(bp, cid_count);
9549 /* disable FCOE L2 queue for E1x*/
9550 if (CHIP_IS_E1x(bp))
9551 bp->flags |= NO_FCOE_FLAG;
9555 /* Configure interrupt mode: try to enable MSI-X/MSI if
9556 * needed, set bp->num_queues appropriately.
9558 bnx2x_set_int_mode(bp);
9560 /* Add all NAPI objects */
9561 bnx2x_add_all_napi(bp);
9563 rc = register_netdev(dev);
9565 dev_err(&pdev->dev, "Cannot register net device\n");
9571 /* Add storage MAC address */
9573 dev_addr_add(bp->dev, bp->fip_mac, NETDEV_HW_ADDR_T_SAN);
9578 bnx2x_get_pcie_width_speed(bp, &pcie_width, &pcie_speed);
9580 netdev_info(dev, "%s (%c%d) PCI-E x%d %s found at mem %lx,"
9581 " IRQ %d, ", board_info[ent->driver_data].name,
9582 (CHIP_REV(bp) >> 12) + 'A', (CHIP_METAL(bp) >> 4),
9584 ((!CHIP_IS_E2(bp) && pcie_speed == 2) ||
9585 (CHIP_IS_E2(bp) && pcie_speed == 1)) ?
9586 "5GHz (Gen2)" : "2.5GHz",
9587 dev->base_addr, bp->pdev->irq);
9588 pr_cont("node addr %pM\n", dev->dev_addr);
9594 iounmap(bp->regview);
9597 iounmap(bp->doorbells);
9601 if (atomic_read(&pdev->enable_cnt) == 1)
9602 pci_release_regions(pdev);
9604 pci_disable_device(pdev);
9605 pci_set_drvdata(pdev, NULL);
9610 static void __devexit bnx2x_remove_one(struct pci_dev *pdev)
9612 struct net_device *dev = pci_get_drvdata(pdev);
9616 dev_err(&pdev->dev, "BAD net device from bnx2x_init_one\n");
9619 bp = netdev_priv(dev);
9622 /* Delete storage MAC address */
9625 dev_addr_del(bp->dev, bp->fip_mac, NETDEV_HW_ADDR_T_SAN);
9631 /* Delete app tlvs from dcbnl */
9632 bnx2x_dcbnl_update_applist(bp, true);
9635 unregister_netdev(dev);
9637 /* Delete all NAPI objects */
9638 bnx2x_del_all_napi(bp);
9640 /* Power on: we can't let PCI layer write to us while we are in D3 */
9641 bnx2x_set_power_state(bp, PCI_D0);
9643 /* Disable MSI/MSI-X */
9644 bnx2x_disable_msi(bp);
9647 bnx2x_set_power_state(bp, PCI_D3hot);
9649 /* Make sure RESET task is not scheduled before continuing */
9650 cancel_delayed_work_sync(&bp->reset_task);
9653 iounmap(bp->regview);
9656 iounmap(bp->doorbells);
9658 bnx2x_free_mem_bp(bp);
9662 if (atomic_read(&pdev->enable_cnt) == 1)
9663 pci_release_regions(pdev);
9665 pci_disable_device(pdev);
9666 pci_set_drvdata(pdev, NULL);
9669 static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
9673 bp->state = BNX2X_STATE_ERROR;
9675 bp->rx_mode = BNX2X_RX_MODE_NONE;
9677 bnx2x_netif_stop(bp, 0);
9678 netif_carrier_off(bp->dev);
9680 del_timer_sync(&bp->timer);
9681 bp->stats_state = STATS_STATE_DISABLED;
9682 DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
9687 /* Free SKBs, SGEs, TPA pool and driver internals */
9688 bnx2x_free_skbs(bp);
9690 for_each_rx_queue(bp, i)
9691 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
9695 bp->state = BNX2X_STATE_CLOSED;
9700 static void bnx2x_eeh_recover(struct bnx2x *bp)
9704 mutex_init(&bp->port.phy_mutex);
9706 bp->common.shmem_base = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
9707 bp->link_params.shmem_base = bp->common.shmem_base;
9708 BNX2X_DEV_INFO("shmem offset is 0x%x\n", bp->common.shmem_base);
9710 if (!bp->common.shmem_base ||
9711 (bp->common.shmem_base < 0xA0000) ||
9712 (bp->common.shmem_base >= 0xC0000)) {
9713 BNX2X_DEV_INFO("MCP not active\n");
9714 bp->flags |= NO_MCP_FLAG;
9718 val = SHMEM_RD(bp, validity_map[BP_PORT(bp)]);
9719 if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
9720 != (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
9721 BNX2X_ERR("BAD MCP validity signature\n");
9723 if (!BP_NOMCP(bp)) {
9725 (SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
9726 DRV_MSG_SEQ_NUMBER_MASK);
9727 BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
9732 * bnx2x_io_error_detected - called when PCI error is detected
9733 * @pdev: Pointer to PCI device
9734 * @state: The current pci connection state
9736 * This function is called after a PCI bus error affecting
9737 * this device has been detected.
9739 static pci_ers_result_t bnx2x_io_error_detected(struct pci_dev *pdev,
9740 pci_channel_state_t state)
9742 struct net_device *dev = pci_get_drvdata(pdev);
9743 struct bnx2x *bp = netdev_priv(dev);
9747 netif_device_detach(dev);
9749 if (state == pci_channel_io_perm_failure) {
9751 return PCI_ERS_RESULT_DISCONNECT;
9754 if (netif_running(dev))
9755 bnx2x_eeh_nic_unload(bp);
9757 pci_disable_device(pdev);
9761 /* Request a slot reset */
9762 return PCI_ERS_RESULT_NEED_RESET;
9766 * bnx2x_io_slot_reset - called after the PCI bus has been reset
9767 * @pdev: Pointer to PCI device
9769 * Restart the card from scratch, as if from a cold-boot.
9771 static pci_ers_result_t bnx2x_io_slot_reset(struct pci_dev *pdev)
9773 struct net_device *dev = pci_get_drvdata(pdev);
9774 struct bnx2x *bp = netdev_priv(dev);
9778 if (pci_enable_device(pdev)) {
9780 "Cannot re-enable PCI device after reset\n");
9782 return PCI_ERS_RESULT_DISCONNECT;
9785 pci_set_master(pdev);
9786 pci_restore_state(pdev);
9788 if (netif_running(dev))
9789 bnx2x_set_power_state(bp, PCI_D0);
9793 return PCI_ERS_RESULT_RECOVERED;
9797 * bnx2x_io_resume - called when traffic can start flowing again
9798 * @pdev: Pointer to PCI device
9800 * This callback is called when the error recovery driver tells us that
9801 * its OK to resume normal operation.
9803 static void bnx2x_io_resume(struct pci_dev *pdev)
9805 struct net_device *dev = pci_get_drvdata(pdev);
9806 struct bnx2x *bp = netdev_priv(dev);
9808 if (bp->recovery_state != BNX2X_RECOVERY_DONE) {
9809 printk(KERN_ERR "Handling parity error recovery. "
9810 "Try again later\n");
9816 bnx2x_eeh_recover(bp);
9818 if (netif_running(dev))
9819 bnx2x_nic_load(bp, LOAD_NORMAL);
9821 netif_device_attach(dev);
9826 static struct pci_error_handlers bnx2x_err_handler = {
9827 .error_detected = bnx2x_io_error_detected,
9828 .slot_reset = bnx2x_io_slot_reset,
9829 .resume = bnx2x_io_resume,
9832 static struct pci_driver bnx2x_pci_driver = {
9833 .name = DRV_MODULE_NAME,
9834 .id_table = bnx2x_pci_tbl,
9835 .probe = bnx2x_init_one,
9836 .remove = __devexit_p(bnx2x_remove_one),
9837 .suspend = bnx2x_suspend,
9838 .resume = bnx2x_resume,
9839 .err_handler = &bnx2x_err_handler,
9842 static int __init bnx2x_init(void)
9846 pr_info("%s", version);
9848 bnx2x_wq = create_singlethread_workqueue("bnx2x");
9849 if (bnx2x_wq == NULL) {
9850 pr_err("Cannot create workqueue\n");
9854 ret = pci_register_driver(&bnx2x_pci_driver);
9856 pr_err("Cannot register driver\n");
9857 destroy_workqueue(bnx2x_wq);
9862 static void __exit bnx2x_cleanup(void)
9864 pci_unregister_driver(&bnx2x_pci_driver);
9866 destroy_workqueue(bnx2x_wq);
9869 module_init(bnx2x_init);
9870 module_exit(bnx2x_cleanup);
9874 /* count denotes the number of new completions we have seen */
9875 static void bnx2x_cnic_sp_post(struct bnx2x *bp, int count)
9877 struct eth_spe *spe;
9879 #ifdef BNX2X_STOP_ON_ERROR
9880 if (unlikely(bp->panic))
9884 spin_lock_bh(&bp->spq_lock);
9885 BUG_ON(bp->cnic_spq_pending < count);
9886 bp->cnic_spq_pending -= count;
9889 for (; bp->cnic_kwq_pending; bp->cnic_kwq_pending--) {
9890 u16 type = (le16_to_cpu(bp->cnic_kwq_cons->hdr.type)
9891 & SPE_HDR_CONN_TYPE) >>
9892 SPE_HDR_CONN_TYPE_SHIFT;
9894 /* Set validation for iSCSI L2 client before sending SETUP
9897 if (type == ETH_CONNECTION_TYPE) {
9898 u8 cmd = (le32_to_cpu(bp->cnic_kwq_cons->
9899 hdr.conn_and_cmd_data) >>
9900 SPE_HDR_CMD_ID_SHIFT) & 0xff;
9902 if (cmd == RAMROD_CMD_ID_ETH_CLIENT_SETUP)
9903 bnx2x_set_ctx_validation(&bp->context.
9904 vcxt[BNX2X_ISCSI_ETH_CID].eth,
9905 HW_CID(bp, BNX2X_ISCSI_ETH_CID));
9908 /* There may be not more than 8 L2 and not more than 8 L5 SPEs
9909 * We also check that the number of outstanding
9910 * COMMON ramrods is not more than the EQ and SPQ can
9913 if (type == ETH_CONNECTION_TYPE) {
9914 if (!atomic_read(&bp->cq_spq_left))
9917 atomic_dec(&bp->cq_spq_left);
9918 } else if (type == NONE_CONNECTION_TYPE) {
9919 if (!atomic_read(&bp->eq_spq_left))
9922 atomic_dec(&bp->eq_spq_left);
9923 } else if ((type == ISCSI_CONNECTION_TYPE) ||
9924 (type == FCOE_CONNECTION_TYPE)) {
9925 if (bp->cnic_spq_pending >=
9926 bp->cnic_eth_dev.max_kwqe_pending)
9929 bp->cnic_spq_pending++;
9931 BNX2X_ERR("Unknown SPE type: %d\n", type);
9936 spe = bnx2x_sp_get_next(bp);
9937 *spe = *bp->cnic_kwq_cons;
9939 DP(NETIF_MSG_TIMER, "pending on SPQ %d, on KWQ %d count %d\n",
9940 bp->cnic_spq_pending, bp->cnic_kwq_pending, count);
9942 if (bp->cnic_kwq_cons == bp->cnic_kwq_last)
9943 bp->cnic_kwq_cons = bp->cnic_kwq;
9945 bp->cnic_kwq_cons++;
9947 bnx2x_sp_prod_update(bp);
9948 spin_unlock_bh(&bp->spq_lock);
9951 static int bnx2x_cnic_sp_queue(struct net_device *dev,
9952 struct kwqe_16 *kwqes[], u32 count)
9954 struct bnx2x *bp = netdev_priv(dev);
9957 #ifdef BNX2X_STOP_ON_ERROR
9958 if (unlikely(bp->panic))
9962 spin_lock_bh(&bp->spq_lock);
9964 for (i = 0; i < count; i++) {
9965 struct eth_spe *spe = (struct eth_spe *)kwqes[i];
9967 if (bp->cnic_kwq_pending == MAX_SP_DESC_CNT)
9970 *bp->cnic_kwq_prod = *spe;
9972 bp->cnic_kwq_pending++;
9974 DP(NETIF_MSG_TIMER, "L5 SPQE %x %x %x:%x pos %d\n",
9975 spe->hdr.conn_and_cmd_data, spe->hdr.type,
9976 spe->data.update_data_addr.hi,
9977 spe->data.update_data_addr.lo,
9978 bp->cnic_kwq_pending);
9980 if (bp->cnic_kwq_prod == bp->cnic_kwq_last)
9981 bp->cnic_kwq_prod = bp->cnic_kwq;
9983 bp->cnic_kwq_prod++;
9986 spin_unlock_bh(&bp->spq_lock);
9988 if (bp->cnic_spq_pending < bp->cnic_eth_dev.max_kwqe_pending)
9989 bnx2x_cnic_sp_post(bp, 0);
9994 static int bnx2x_cnic_ctl_send(struct bnx2x *bp, struct cnic_ctl_info *ctl)
9996 struct cnic_ops *c_ops;
9999 mutex_lock(&bp->cnic_mutex);
10000 c_ops = rcu_dereference_protected(bp->cnic_ops,
10001 lockdep_is_held(&bp->cnic_mutex));
10003 rc = c_ops->cnic_ctl(bp->cnic_data, ctl);
10004 mutex_unlock(&bp->cnic_mutex);
10009 static int bnx2x_cnic_ctl_send_bh(struct bnx2x *bp, struct cnic_ctl_info *ctl)
10011 struct cnic_ops *c_ops;
10015 c_ops = rcu_dereference(bp->cnic_ops);
10017 rc = c_ops->cnic_ctl(bp->cnic_data, ctl);
10024 * for commands that have no data
10026 int bnx2x_cnic_notify(struct bnx2x *bp, int cmd)
10028 struct cnic_ctl_info ctl = {0};
10032 return bnx2x_cnic_ctl_send(bp, &ctl);
10035 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid)
10037 struct cnic_ctl_info ctl;
10039 /* first we tell CNIC and only then we count this as a completion */
10040 ctl.cmd = CNIC_CTL_COMPLETION_CMD;
10041 ctl.data.comp.cid = cid;
10043 bnx2x_cnic_ctl_send_bh(bp, &ctl);
10044 bnx2x_cnic_sp_post(bp, 0);
10047 static int bnx2x_drv_ctl(struct net_device *dev, struct drv_ctl_info *ctl)
10049 struct bnx2x *bp = netdev_priv(dev);
10052 switch (ctl->cmd) {
10053 case DRV_CTL_CTXTBL_WR_CMD: {
10054 u32 index = ctl->data.io.offset;
10055 dma_addr_t addr = ctl->data.io.dma_addr;
10057 bnx2x_ilt_wr(bp, index, addr);
10061 case DRV_CTL_RET_L5_SPQ_CREDIT_CMD: {
10062 int count = ctl->data.credit.credit_count;
10064 bnx2x_cnic_sp_post(bp, count);
10068 /* rtnl_lock is held. */
10069 case DRV_CTL_START_L2_CMD: {
10070 u32 cli = ctl->data.ring.client_id;
10072 /* Clear FCoE FIP and ALL ENODE MACs addresses first */
10073 bnx2x_del_fcoe_eth_macs(bp);
10075 /* Set iSCSI MAC address */
10076 bnx2x_set_iscsi_eth_mac_addr(bp, 1);
10081 /* Start accepting on iSCSI L2 ring. Accept all multicasts
10082 * because it's the only way for UIO Client to accept
10083 * multicasts (in non-promiscuous mode only one Client per
10084 * function will receive multicast packets (leading in our
10087 bnx2x_rxq_set_mac_filters(bp, cli,
10088 BNX2X_ACCEPT_UNICAST |
10089 BNX2X_ACCEPT_BROADCAST |
10090 BNX2X_ACCEPT_ALL_MULTICAST);
10091 storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
10096 /* rtnl_lock is held. */
10097 case DRV_CTL_STOP_L2_CMD: {
10098 u32 cli = ctl->data.ring.client_id;
10100 /* Stop accepting on iSCSI L2 ring */
10101 bnx2x_rxq_set_mac_filters(bp, cli, BNX2X_ACCEPT_NONE);
10102 storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
10107 /* Unset iSCSI L2 MAC */
10108 bnx2x_set_iscsi_eth_mac_addr(bp, 0);
10111 case DRV_CTL_RET_L2_SPQ_CREDIT_CMD: {
10112 int count = ctl->data.credit.credit_count;
10114 smp_mb__before_atomic_inc();
10115 atomic_add(count, &bp->cq_spq_left);
10116 smp_mb__after_atomic_inc();
10120 case DRV_CTL_ISCSI_STOPPED_CMD: {
10121 bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_ISCSI_STOPPED);
10126 BNX2X_ERR("unknown command %x\n", ctl->cmd);
10133 void bnx2x_setup_cnic_irq_info(struct bnx2x *bp)
10135 struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
10137 if (bp->flags & USING_MSIX_FLAG) {
10138 cp->drv_state |= CNIC_DRV_STATE_USING_MSIX;
10139 cp->irq_arr[0].irq_flags |= CNIC_IRQ_FL_MSIX;
10140 cp->irq_arr[0].vector = bp->msix_table[1].vector;
10142 cp->drv_state &= ~CNIC_DRV_STATE_USING_MSIX;
10143 cp->irq_arr[0].irq_flags &= ~CNIC_IRQ_FL_MSIX;
10145 if (CHIP_IS_E2(bp))
10146 cp->irq_arr[0].status_blk = (void *)bp->cnic_sb.e2_sb;
10148 cp->irq_arr[0].status_blk = (void *)bp->cnic_sb.e1x_sb;
10150 cp->irq_arr[0].status_blk_num = CNIC_SB_ID(bp);
10151 cp->irq_arr[0].status_blk_num2 = CNIC_IGU_SB_ID(bp);
10152 cp->irq_arr[1].status_blk = bp->def_status_blk;
10153 cp->irq_arr[1].status_blk_num = DEF_SB_ID;
10154 cp->irq_arr[1].status_blk_num2 = DEF_SB_IGU_ID;
10159 static int bnx2x_register_cnic(struct net_device *dev, struct cnic_ops *ops,
10162 struct bnx2x *bp = netdev_priv(dev);
10163 struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
10168 if (atomic_read(&bp->intr_sem) != 0)
10171 bp->cnic_kwq = kzalloc(PAGE_SIZE, GFP_KERNEL);
10175 bp->cnic_kwq_cons = bp->cnic_kwq;
10176 bp->cnic_kwq_prod = bp->cnic_kwq;
10177 bp->cnic_kwq_last = bp->cnic_kwq + MAX_SP_DESC_CNT;
10179 bp->cnic_spq_pending = 0;
10180 bp->cnic_kwq_pending = 0;
10182 bp->cnic_data = data;
10185 cp->drv_state = CNIC_DRV_STATE_REGD;
10186 cp->iro_arr = bp->iro_arr;
10188 bnx2x_setup_cnic_irq_info(bp);
10190 rcu_assign_pointer(bp->cnic_ops, ops);
10195 static int bnx2x_unregister_cnic(struct net_device *dev)
10197 struct bnx2x *bp = netdev_priv(dev);
10198 struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
10200 mutex_lock(&bp->cnic_mutex);
10202 rcu_assign_pointer(bp->cnic_ops, NULL);
10203 mutex_unlock(&bp->cnic_mutex);
10205 kfree(bp->cnic_kwq);
10206 bp->cnic_kwq = NULL;
10211 struct cnic_eth_dev *bnx2x_cnic_probe(struct net_device *dev)
10213 struct bnx2x *bp = netdev_priv(dev);
10214 struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
10216 /* If both iSCSI and FCoE are disabled - return NULL in
10217 * order to indicate CNIC that it should not try to work
10218 * with this device.
10220 if (NO_ISCSI(bp) && NO_FCOE(bp))
10223 cp->drv_owner = THIS_MODULE;
10224 cp->chip_id = CHIP_ID(bp);
10225 cp->pdev = bp->pdev;
10226 cp->io_base = bp->regview;
10227 cp->io_base2 = bp->doorbells;
10228 cp->max_kwqe_pending = 8;
10229 cp->ctx_blk_size = CDU_ILT_PAGE_SZ;
10230 cp->ctx_tbl_offset = FUNC_ILT_BASE(BP_FUNC(bp)) +
10231 bnx2x_cid_ilt_lines(bp);
10232 cp->ctx_tbl_len = CNIC_ILT_LINES;
10233 cp->starting_cid = bnx2x_cid_ilt_lines(bp) * ILT_PAGE_CIDS;
10234 cp->drv_submit_kwqes_16 = bnx2x_cnic_sp_queue;
10235 cp->drv_ctl = bnx2x_drv_ctl;
10236 cp->drv_register_cnic = bnx2x_register_cnic;
10237 cp->drv_unregister_cnic = bnx2x_unregister_cnic;
10238 cp->fcoe_init_cid = BNX2X_FCOE_ETH_CID;
10239 cp->iscsi_l2_client_id = BNX2X_ISCSI_ETH_CL_ID +
10240 BP_E1HVN(bp) * NONE_ETH_CONTEXT_USE;
10241 cp->iscsi_l2_cid = BNX2X_ISCSI_ETH_CID;
10243 if (NO_ISCSI_OOO(bp))
10244 cp->drv_state |= CNIC_DRV_STATE_NO_ISCSI_OOO;
10247 cp->drv_state |= CNIC_DRV_STATE_NO_ISCSI;
10250 cp->drv_state |= CNIC_DRV_STATE_NO_FCOE;
10252 DP(BNX2X_MSG_SP, "page_size %d, tbl_offset %d, tbl_lines %d, "
10253 "starting cid %d\n",
10255 cp->ctx_tbl_offset,
10260 EXPORT_SYMBOL(bnx2x_cnic_probe);
10262 #endif /* BCM_CNIC */