drivers/net/bnx2x/bnx2x_main.c

   1 /* bnx2x_main.c: Broadcom Everest network driver.
   2  *
   3  * Copyright (c) 2007-2011 Broadcom Corporation
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation.
   8  *
   9  * Maintained by: Eilon Greenstein <eilong@broadcom.com>
  10  * Written by: Eliezer Tamir
  11  * Based on code from Michael Chan's bnx2 driver
  12  * UDP CSUM errata workaround by Arik Gendelman
  13  * Slowpath and fastpath rework by Vladislav Zolotarov
  14  * Statistics and Link management by Yitchak Gertner
  15  *
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/moduleparam.h>
  20 #include <linux/kernel.h>
  21 #include <linux/device.h>  /* for dev_info() */
  22 #include <linux/timer.h>
  23 #include <linux/errno.h>
  24 #include <linux/ioport.h>
  25 #include <linux/slab.h>
  26 #include <linux/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>
  41 #include <net/ip.h>
  42 #include <net/tcp.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>
  50 #include <linux/io.h>
  51 #include <linux/stringify.h>
  52
  53 #define BNX2X_MAIN
  54 #include "bnx2x.h"
  55 #include "bnx2x_init.h"
  56 #include "bnx2x_init_ops.h"
  57 #include "bnx2x_cmn.h"
  58 #include "bnx2x_dcb.h"
  59
  60 #include <linux/firmware.h>
  61 #include "bnx2x_fw_file_hdr.h"
  62 /* FW files */
  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"
  71
  72 /* Time in jiffies before concluding the transmitter is hung */
  73 #define TX_TIMEOUT              (5*HZ)
  74
  75 static char version[] __devinitdata =
  76         "Broadcom NetXtreme II 5771x 10Gigabit Ethernet Driver "
  77         DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
  78
  79 MODULE_AUTHOR("Eliezer Tamir");
  80 MODULE_DESCRIPTION("Broadcom NetXtreme II "
  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);
  87
  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))");
  92
  93 int num_queues;
  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)");
  97
  98 static int disable_tpa;
  99 module_param(disable_tpa, int, 0);
 100 MODULE_PARM_DESC(disable_tpa, " Disable the TPA (LRO) feature");
 101
 102 static int int_mode;
 103 module_param(int_mode, int, 0);
 104 MODULE_PARM_DESC(int_mode, " Force interrupt mode other then MSI-X "
 105                                 "(1 INT#x; 2 MSI)");
 106
 107 static int dropless_fc;
 108 module_param(dropless_fc, int, 0);
 109 MODULE_PARM_DESC(dropless_fc, " Pause on exhausted host ring");
 110
 111 static int poll;
 112 module_param(poll, int, 0);
 113 MODULE_PARM_DESC(poll, " Use polling (for debug)");
 114
 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)");
 118
 119 static int debug;
 120 module_param(debug, int, 0);
 121 MODULE_PARM_DESC(debug, " Default debug msglevel");
 122
 123 static struct workqueue_struct *bnx2x_wq;
 124
 125 #ifdef BCM_CNIC
 126 static u8 ALL_ENODE_MACS[] = {0x01, 0x10, 0x18, 0x01, 0x00, 0x01};
 127 #endif
 128
 129 enum bnx2x_board_type {
 130         BCM57710 = 0,
 131         BCM57711 = 1,
 132         BCM57711E = 2,
 133         BCM57712 = 3,
 134         BCM57712E = 4
 135 };
 136
 137 /* indexed by board_type, above */
 138 static struct {
 139         char *name;
 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" }
 146 };
 147
 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 },
 154         { 0 }
 155 };
 156
 157 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
 158
 159 /****************************************************************************
 160 * General service functions
 161 ****************************************************************************/
 162
 163 static inline void __storm_memset_dma_mapping(struct bnx2x *bp,
 164                                        u32 addr, dma_addr_t mapping)
 165 {
 166         REG_WR(bp,  addr, U64_LO(mapping));
 167         REG_WR(bp,  addr + 4, U64_HI(mapping));
 168 }
 169
 170 static inline void __storm_memset_fill(struct bnx2x *bp,
 171                                        u32 addr, size_t size, u32 val)
 172 {
 173         int i;
 174         for (i = 0; i < size/4; i++)
 175                 REG_WR(bp,  addr + (i * 4), val);
 176 }
 177
 178 static inline void storm_memset_ustats_zero(struct bnx2x *bp,
 179                                             u8 port, u16 stat_id)
 180 {
 181         size_t size = sizeof(struct ustorm_per_client_stats);
 182
 183         u32 addr = BAR_USTRORM_INTMEM +
 184                         USTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
 185
 186         __storm_memset_fill(bp, addr, size, 0);
 187 }
 188
 189 static inline void storm_memset_tstats_zero(struct bnx2x *bp,
 190                                             u8 port, u16 stat_id)
 191 {
 192         size_t size = sizeof(struct tstorm_per_client_stats);
 193
 194         u32 addr = BAR_TSTRORM_INTMEM +
 195                         TSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
 196
 197         __storm_memset_fill(bp, addr, size, 0);
 198 }
 199
 200 static inline void storm_memset_xstats_zero(struct bnx2x *bp,
 201                                             u8 port, u16 stat_id)
 202 {
 203         size_t size = sizeof(struct xstorm_per_client_stats);
 204
 205         u32 addr = BAR_XSTRORM_INTMEM +
 206                         XSTORM_PER_COUNTER_ID_STATS_OFFSET(port, stat_id);
 207
 208         __storm_memset_fill(bp, addr, size, 0);
 209 }
 210
 211
 212 static inline void storm_memset_spq_addr(struct bnx2x *bp,
 213                                          dma_addr_t mapping, u16 abs_fid)
 214 {
 215         u32 addr = XSEM_REG_FAST_MEMORY +
 216                         XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid);
 217
 218         __storm_memset_dma_mapping(bp, addr, mapping);
 219 }
 220
 221 static inline void storm_memset_ov(struct bnx2x *bp, u16 ov, u16 abs_fid)
 222 {
 223         REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_E1HOV_OFFSET(abs_fid), ov);
 224 }
 225
 226 static inline void storm_memset_func_cfg(struct bnx2x *bp,
 227                                 struct tstorm_eth_function_common_config *tcfg,
 228                                 u16 abs_fid)
 229 {
 230         size_t size = sizeof(struct tstorm_eth_function_common_config);
 231
 232         u32 addr = BAR_TSTRORM_INTMEM +
 233                         TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid);
 234
 235         __storm_memset_struct(bp, addr, size, (u32 *)tcfg);
 236 }
 237
 238 static inline void storm_memset_xstats_flags(struct bnx2x *bp,
 239                                 struct stats_indication_flags *flags,
 240                                 u16 abs_fid)
 241 {
 242         size_t size = sizeof(struct stats_indication_flags);
 243
 244         u32 addr = BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(abs_fid);
 245
 246         __storm_memset_struct(bp, addr, size, (u32 *)flags);
 247 }
 248
 249 static inline void storm_memset_tstats_flags(struct bnx2x *bp,
 250                                 struct stats_indication_flags *flags,
 251                                 u16 abs_fid)
 252 {
 253         size_t size = sizeof(struct stats_indication_flags);
 254
 255         u32 addr = BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(abs_fid);
 256
 257         __storm_memset_struct(bp, addr, size, (u32 *)flags);
 258 }
 259
 260 static inline void storm_memset_ustats_flags(struct bnx2x *bp,
 261                                 struct stats_indication_flags *flags,
 262                                 u16 abs_fid)
 263 {
 264         size_t size = sizeof(struct stats_indication_flags);
 265
 266         u32 addr = BAR_USTRORM_INTMEM + USTORM_STATS_FLAGS_OFFSET(abs_fid);
 267
 268         __storm_memset_struct(bp, addr, size, (u32 *)flags);
 269 }
 270
 271 static inline void storm_memset_cstats_flags(struct bnx2x *bp,
 272                                 struct stats_indication_flags *flags,
 273                                 u16 abs_fid)
 274 {
 275         size_t size = sizeof(struct stats_indication_flags);
 276
 277         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(abs_fid);
 278
 279         __storm_memset_struct(bp, addr, size, (u32 *)flags);
 280 }
 281
 282 static inline void storm_memset_xstats_addr(struct bnx2x *bp,
 283                                            dma_addr_t mapping, u16 abs_fid)
 284 {
 285         u32 addr = BAR_XSTRORM_INTMEM +
 286                 XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
 287
 288         __storm_memset_dma_mapping(bp, addr, mapping);
 289 }
 290
 291 static inline void storm_memset_tstats_addr(struct bnx2x *bp,
 292                                            dma_addr_t mapping, u16 abs_fid)
 293 {
 294         u32 addr = BAR_TSTRORM_INTMEM +
 295                 TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
 296
 297         __storm_memset_dma_mapping(bp, addr, mapping);
 298 }
 299
 300 static inline void storm_memset_ustats_addr(struct bnx2x *bp,
 301                                            dma_addr_t mapping, u16 abs_fid)
 302 {
 303         u32 addr = BAR_USTRORM_INTMEM +
 304                 USTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
 305
 306         __storm_memset_dma_mapping(bp, addr, mapping);
 307 }
 308
 309 static inline void storm_memset_cstats_addr(struct bnx2x *bp,
 310                                            dma_addr_t mapping, u16 abs_fid)
 311 {
 312         u32 addr = BAR_CSTRORM_INTMEM +
 313                 CSTORM_ETH_STATS_QUERY_ADDR_OFFSET(abs_fid);
 314
 315         __storm_memset_dma_mapping(bp, addr, mapping);
 316 }
 317
 318 static inline void storm_memset_vf_to_pf(struct bnx2x *bp, u16 abs_fid,
 319                                          u16 pf_id)
 320 {
 321         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid),
 322                 pf_id);
 323         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid),
 324                 pf_id);
 325         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid),
 326                 pf_id);
 327         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid),
 328                 pf_id);
 329 }
 330
 331 static inline void storm_memset_func_en(struct bnx2x *bp, u16 abs_fid,
 332                                         u8 enable)
 333 {
 334         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid),
 335                 enable);
 336         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid),
 337                 enable);
 338         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid),
 339                 enable);
 340         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid),
 341                 enable);
 342 }
 343
 344 static inline void storm_memset_eq_data(struct bnx2x *bp,
 345                                 struct event_ring_data *eq_data,
 346                                 u16 pfid)
 347 {
 348         size_t size = sizeof(struct event_ring_data);
 349
 350         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_DATA_OFFSET(pfid);
 351
 352         __storm_memset_struct(bp, addr, size, (u32 *)eq_data);
 353 }
 354
 355 static inline void storm_memset_eq_prod(struct bnx2x *bp, u16 eq_prod,
 356                                         u16 pfid)
 357 {
 358         u32 addr = BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_PROD_OFFSET(pfid);
 359         REG_WR16(bp, addr, eq_prod);
 360 }
 361
 362 static inline void storm_memset_hc_timeout(struct bnx2x *bp, u8 port,
 363                                              u16 fw_sb_id, u8 sb_index,
 364                                              u8 ticks)
 365 {
 366
 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) +
 372                         index_offset +
 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);
 378 }
 379 static inline void storm_memset_hc_disable(struct bnx2x *bp, u8 port,
 380                                              u16 fw_sb_id, u8 sb_index,
 381                                              u8 disable)
 382 {
 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) +
 389                         index_offset +
 390                         sizeof(struct hc_index_data)*sb_index +
 391                         offsetof(struct hc_index_data, flags);
 392         u16 flags = REG_RD16(bp, addr);
 393         /* clear and set */
 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);
 399 }
 400
 401 /* used only at init
 402  * locking is done by mcp
 403  */
 404 static void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
 405 {
 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);
 410 }
 411
 412 static u32 bnx2x_reg_rd_ind(struct bnx2x *bp, u32 addr)
 413 {
 414         u32 val;
 415
 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);
 420
 421         return val;
 422 }
 423
 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]"
 429
 430 static void bnx2x_dp_dmae(struct bnx2x *bp, struct dmae_command *dmae,
 431                           int msglvl)
 432 {
 433         u32 src_type = dmae->opcode & DMAE_COMMAND_SRC;
 434
 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,
 444                            dmae->comp_val);
 445                 else
 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,
 452                            dmae->comp_val);
 453                 break;
 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,
 462                            dmae->comp_val);
 463                 else
 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,
 470                            dmae->comp_val);
 471                 break;
 472         default:
 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]  "
 476                                     "dst_addr [none]\n"
 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,
 480                            dmae->comp_val);
 481                 else
 482                         DP(msglvl, "DMAE: opcode 0x%08x\n"
 483                            DP_LEVEL "src_addr [%08x]  len [%d * 4]  "
 484                                     "dst_addr [none]\n"
 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,
 488                            dmae->comp_val);
 489                 break;
 490         }
 491
 492 }
 493
 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
 499 };
 500
 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)
 503 {
 504         u32 cmd_offset;
 505         int i;
 506
 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));
 510
 511                 DP(BNX2X_MSG_OFF, "DMAE cmd[%d].%d (0x%08x) : 0x%08x\n",
 512                    idx, i, cmd_offset + i*4, *(((u32 *)dmae) + i));
 513         }
 514         REG_WR(bp, dmae_reg_go_c[idx], 1);
 515 }
 516
 517 u32 bnx2x_dmae_opcode_add_comp(u32 opcode, u8 comp_type)
 518 {
 519         return opcode | ((comp_type << DMAE_COMMAND_C_DST_SHIFT) |
 520                            DMAE_CMD_C_ENABLE);
 521 }
 522
 523 u32 bnx2x_dmae_opcode_clr_src_reset(u32 opcode)
 524 {
 525         return opcode & ~DMAE_CMD_SRC_RESET;
 526 }
 527
 528 u32 bnx2x_dmae_opcode(struct bnx2x *bp, u8 src_type, u8 dst_type,
 529                              bool with_comp, u8 comp_type)
 530 {
 531         u32 opcode = 0;
 532
 533         opcode |= ((src_type << DMAE_COMMAND_SRC_SHIFT) |
 534                    (dst_type << DMAE_COMMAND_DST_SHIFT));
 535
 536         opcode |= (DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET);
 537
 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);
 542
 543 #ifdef __BIG_ENDIAN
 544         opcode |= DMAE_CMD_ENDIANITY_B_DW_SWAP;
 545 #else
 546         opcode |= DMAE_CMD_ENDIANITY_DW_SWAP;
 547 #endif
 548         if (with_comp)
 549                 opcode = bnx2x_dmae_opcode_add_comp(opcode, comp_type);
 550         return opcode;
 551 }
 552
 553 static void bnx2x_prep_dmae_with_comp(struct bnx2x *bp,
 554                                       struct dmae_command *dmae,
 555                                       u8 src_type, u8 dst_type)
 556 {
 557         memset(dmae, 0, sizeof(struct dmae_command));
 558
 559         /* set the opcode */
 560         dmae->opcode = bnx2x_dmae_opcode(bp, src_type, dst_type,
 561                                          true, DMAE_COMP_PCI);
 562
 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;
 567 }
 568
 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)
 572 {
 573         u32 *wb_comp = bnx2x_sp(bp, wb_comp);
 574         int cnt = CHIP_REV_IS_SLOW(bp) ? (400000) : 4000;
 575         int rc = 0;
 576
 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]);
 580
 581         /* lock the dmae channel */
 582         spin_lock_bh(&bp->dmae_lock);
 583
 584         /* reset completion */
 585         *wb_comp = 0;
 586
 587         /* post the command on the channel used for initializations */
 588         bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
 589
 590         /* wait for completion */
 591         udelay(5);
 592         while ((*wb_comp & ~DMAE_PCI_ERR_FLAG) != DMAE_COMP_VAL) {
 593                 DP(BNX2X_MSG_OFF, "wb_comp 0x%08x\n", *wb_comp);
 594
 595                 if (!cnt) {
 596                         BNX2X_ERR("DMAE timeout!\n");
 597                         rc = DMAE_TIMEOUT;
 598                         goto unlock;
 599                 }
 600                 cnt--;
 601                 udelay(50);
 602         }
 603         if (*wb_comp & DMAE_PCI_ERR_FLAG) {
 604                 BNX2X_ERR("DMAE PCI error!\n");
 605                 rc = DMAE_PCI_ERROR;
 606         }
 607
 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]);
 611
 612 unlock:
 613         spin_unlock_bh(&bp->dmae_lock);
 614         return rc;
 615 }
 616
 617 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr, u32 dst_addr,
 618                       u32 len32)
 619 {
 620         struct dmae_command dmae;
 621
 622         if (!bp->dmae_ready) {
 623                 u32 *data = bnx2x_sp(bp, wb_data[0]);
 624
 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);
 628                 return;
 629         }
 630
 631         /* set opcode and fixed command fields */
 632         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_GRC);
 633
 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;
 639         dmae.len = len32;
 640
 641         bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_OFF);
 642
 643         /* issue the command and wait for completion */
 644         bnx2x_issue_dmae_with_comp(bp, &dmae);
 645 }
 646
 647 void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32)
 648 {
 649         struct dmae_command dmae;
 650
 651         if (!bp->dmae_ready) {
 652                 u32 *data = bnx2x_sp(bp, wb_data[0]);
 653                 int i;
 654
 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);
 659                 return;
 660         }
 661
 662         /* set opcode and fixed command fields */
 663         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_GRC, DMAE_DST_PCI);
 664
 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));
 670         dmae.len = len32;
 671
 672         bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_OFF);
 673
 674         /* issue the command and wait for completion */
 675         bnx2x_issue_dmae_with_comp(bp, &dmae);
 676 }
 677
 678 static void bnx2x_write_dmae_phys_len(struct bnx2x *bp, dma_addr_t phys_addr,
 679                                       u32 addr, u32 len)
 680 {
 681         int dmae_wr_max = DMAE_LEN32_WR_MAX(bp);
 682         int offset = 0;
 683
 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;
 688                 len -= dmae_wr_max;
 689         }
 690
 691         bnx2x_write_dmae(bp, phys_addr + offset, addr + offset, len);
 692 }
 693
 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)
 696 {
 697         u32 wb_write[2];
 698
 699         wb_write[0] = val_hi;
 700         wb_write[1] = val_lo;
 701         REG_WR_DMAE(bp, reg, wb_write, 2);
 702 }
 703
 704 #ifdef USE_WB_RD
 705 static u64 bnx2x_wb_rd(struct bnx2x *bp, int reg)
 706 {
 707         u32 wb_data[2];
 708
 709         REG_RD_DMAE(bp, reg, wb_data, 2);
 710
 711         return HILO_U64(wb_data[0], wb_data[1]);
 712 }
 713 #endif
 714
 715 static int bnx2x_mc_assert(struct bnx2x *bp)
 716 {
 717         char last_idx;
 718         int i, rc = 0;
 719         u32 row0, row1, row2, row3;
 720
 721         /* XSTORM */
 722         last_idx = REG_RD8(bp, BAR_XSTRORM_INTMEM +
 723                            XSTORM_ASSERT_LIST_INDEX_OFFSET);
 724         if (last_idx)
 725                 BNX2X_ERR("XSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
 726
 727         /* print the asserts */
 728         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
 729
 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);
 738
 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);
 743                         rc++;
 744                 } else {
 745                         break;
 746                 }
 747         }
 748
 749         /* TSTORM */
 750         last_idx = REG_RD8(bp, BAR_TSTRORM_INTMEM +
 751                            TSTORM_ASSERT_LIST_INDEX_OFFSET);
 752         if (last_idx)
 753                 BNX2X_ERR("TSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
 754
 755         /* print the asserts */
 756         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
 757
 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);
 766
 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);
 771                         rc++;
 772                 } else {
 773                         break;
 774                 }
 775         }
 776
 777         /* CSTORM */
 778         last_idx = REG_RD8(bp, BAR_CSTRORM_INTMEM +
 779                            CSTORM_ASSERT_LIST_INDEX_OFFSET);
 780         if (last_idx)
 781                 BNX2X_ERR("CSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
 782
 783         /* print the asserts */
 784         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
 785
 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);
 794
 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);
 799                         rc++;
 800                 } else {
 801                         break;
 802                 }
 803         }
 804
 805         /* USTORM */
 806         last_idx = REG_RD8(bp, BAR_USTRORM_INTMEM +
 807                            USTORM_ASSERT_LIST_INDEX_OFFSET);
 808         if (last_idx)
 809                 BNX2X_ERR("USTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
 810
 811         /* print the asserts */
 812         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
 813
 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);
 822
 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);
 827                         rc++;
 828                 } else {
 829                         break;
 830                 }
 831         }
 832
 833         return rc;
 834 }
 835
 836 static void bnx2x_fw_dump(struct bnx2x *bp)
 837 {
 838         u32 addr;
 839         u32 mark, offset;
 840         __be32 data[9];
 841         int word;
 842         u32 trace_shmem_base;
 843         if (BP_NOMCP(bp)) {
 844                 BNX2X_ERR("NO MCP - can not dump\n");
 845                 return;
 846         }
 847
 848         if (BP_PATH(bp) == 0)
 849                 trace_shmem_base = bp->common.shmem_base;
 850         else
 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);
 857
 858         pr_err("");
 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));
 862                 data[8] = 0x0;
 863                 pr_cont("%s", (char *)data);
 864         }
 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));
 868                 data[8] = 0x0;
 869                 pr_cont("%s", (char *)data);
 870         }
 871         pr_err("end of fw dump\n");
 872 }
 873
 874 void bnx2x_panic_dump(struct bnx2x *bp)
 875 {
 876         int i;
 877         u16 j;
 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;
 882 #endif
 883
 884         bp->stats_state = STATS_STATE_DISABLED;
 885         DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
 886
 887         BNX2X_ERR("begin crash dump -----------------\n");
 888
 889         /* Indices */
 890         /* Common */
 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);
 900         BNX2X_ERR("     def (");
 901         for (i = 0; i < HC_SP_SB_MAX_INDICES; i++)
 902                 pr_cont("0x%x%s",
 903                        bp->def_status_blk->sp_sb.index_values[i],
 904                        (i == HC_SP_SB_MAX_INDICES - 1) ? ")  " : " ");
 905
 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) +
 909                         i*sizeof(u32));
 910
 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);
 920
 921
 922         for_each_eth_queue(bp, i) {
 923                 struct bnx2x_fastpath *fp = &bp->fp[i];
 924                 int loop;
 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 =
 928                         CHIP_IS_E2(bp) ?
 929                         sb_data_e2.common.state_machine :
 930                         sb_data_e1x.common.state_machine;
 931                 struct hc_index_data *hc_index_p =
 932                         CHIP_IS_E2(bp) ?
 933                         sb_data_e2.index_data :
 934                         sb_data_e1x.index_data;
 935                 int data_size;
 936                 u32 *sb_data_p;
 937
 938                 /* Rx */
 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,
 943                           fp->rx_comp_prod,
 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));
 949
 950                 /* Tx */
 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));
 956
 957                 loop = CHIP_IS_E2(bp) ?
 958                         HC_SB_MAX_INDICES_E2 : HC_SB_MAX_INDICES_E1X;
 959
 960                 /* host sb data */
 961
 962 #ifdef BCM_CNIC
 963                 if (IS_FCOE_FP(fp))
 964                         continue;
 965 #endif
 966                 BNX2X_ERR("     run indexes (");
 967                 for (j = 0; j < HC_SB_MAX_SM; j++)
 968                         pr_cont("0x%x%s",
 969                                fp->sb_running_index[j],
 970                                (j == HC_SB_MAX_SM - 1) ? ")" : " ");
 971
 972                 BNX2X_ERR("     indexes (");
 973                 for (j = 0; j < loop; j++)
 974                         pr_cont("0x%x%s",
 975                                fp->sb_index_values[j],
 976                                (j == loop - 1) ? ")" : " ");
 977                 /* fw sb data */
 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) ?
 983                         (u32 *)&sb_data_e2 :
 984                         (u32 *)&sb_data_e1x;
 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) +
 989                                 j * sizeof(u32));
 990
 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);
 999                 } else {
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);
1007                 }
1008
1009                 /* SB_SMs data */
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,
1015                                hc_sm_p[j].__flags,
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);
1020                 }
1021
1022                 /* Indecies data */
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);
1028                 }
1029         }
1030
1031 #ifdef BNX2X_STOP_ON_ERROR
1032         /* Rings */
1033         /* Rx */
1034         for_each_rx_queue(bp, i) {
1035                 struct bnx2x_fastpath *fp = &bp->fp[i];
1036
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];
1042
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);
1045                 }
1046
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];
1052
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);
1055                 }
1056
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];
1061
1062                         BNX2X_ERR("fp%d: cqe[%x]=[%x:%x:%x:%x]\n",
1063                                   i, j, cqe[0], cqe[1], cqe[2], cqe[3]);
1064                 }
1065         }
1066
1067         /* Tx */
1068         for_each_tx_queue(bp, i) {
1069                 struct bnx2x_fastpath *fp = &bp->fp[i];
1070
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];
1075
1076                         BNX2X_ERR("fp%d: packet[%x]=[%p,%x]\n",
1077                                   i, j, sw_bd->skb, sw_bd->first_bd);
1078                 }
1079
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];
1084
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]);
1087                 }
1088         }
1089 #endif
1090         bnx2x_fw_dump(bp);
1091         bnx2x_mc_assert(bp);
1092         BNX2X_ERR("end crash dump -----------------\n");
1093 }
1094
1095 static void bnx2x_hc_int_enable(struct bnx2x *bp)
1096 {
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;
1102
1103         if (msix) {
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);
1108         } else if (msi) {
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);
1113         } else {
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);
1118
1119                 if (!CHIP_IS_E1(bp)) {
1120                         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
1121                            val, port, addr);
1122
1123                         REG_WR(bp, addr, val);
1124
1125                         val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
1126                 }
1127         }
1128
1129         if (CHIP_IS_E1(bp))
1130                 REG_WR(bp, HC_REG_INT_MASK + port*4, 0x1FFFF);
1131
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")));
1134
1135         REG_WR(bp, addr, val);
1136         /*
1137          * Ensure that HC_CONFIG is written before leading/trailing edge config
1138          */
1139         mmiowb();
1140         barrier();
1141
1142         if (!CHIP_IS_E1(bp)) {
1143                 /* init leading/trailing edge */
1144                 if (IS_MF(bp)) {
1145                         val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
1146                         if (bp->port.pmf)
1147                                 /* enable nig and gpio3 attention */
1148                                 val |= 0x1100;
1149                 } else
1150                         val = 0xffff;
1151
1152                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
1153                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
1154         }
1155
1156         /* Make sure that interrupts are indeed enabled from here on */
1157         mmiowb();
1158 }
1159
1160 static void bnx2x_igu_int_enable(struct bnx2x *bp)
1161 {
1162         u32 val;
1163         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1164         int msi = (bp->flags & USING_MSI_FLAG) ? 1 : 0;
1165
1166         val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1167
1168         if (msix) {
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);
1174         } else if (msi) {
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);
1180         } else {
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);
1186         }
1187
1188         DP(NETIF_MSG_INTR, "write 0x%x to IGU  mode %s\n",
1189            val, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
1190
1191         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
1192
1193         barrier();
1194
1195         /* init leading/trailing edge */
1196         if (IS_MF(bp)) {
1197                 val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
1198                 if (bp->port.pmf)
1199                         /* enable nig and gpio3 attention */
1200                         val |= 0x1100;
1201         } else
1202                 val = 0xffff;
1203
1204         REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
1205         REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
1206
1207         /* Make sure that interrupts are indeed enabled from here on */
1208         mmiowb();
1209 }
1210
1211 void bnx2x_int_enable(struct bnx2x *bp)
1212 {
1213         if (bp->common.int_block == INT_BLOCK_HC)
1214                 bnx2x_hc_int_enable(bp);
1215         else
1216                 bnx2x_igu_int_enable(bp);
1217 }
1218
1219 static void bnx2x_hc_int_disable(struct bnx2x *bp)
1220 {
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);
1224
1225         /*
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
1229          */
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
1234                  */
1235                 REG_WR(bp, HC_REG_INT_MASK + port*4, 0);
1236
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);
1240         } else
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);
1245
1246         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
1247            val, port, addr);
1248
1249         /* flush all outstanding writes */
1250         mmiowb();
1251
1252         REG_WR(bp, addr, val);
1253         if (REG_RD(bp, addr) != val)
1254                 BNX2X_ERR("BUG! proper val not read from IGU!\n");
1255 }
1256
1257 static void bnx2x_igu_int_disable(struct bnx2x *bp)
1258 {
1259         u32 val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
1260
1261         val &= ~(IGU_PF_CONF_MSI_MSIX_EN |
1262                  IGU_PF_CONF_INT_LINE_EN |
1263                  IGU_PF_CONF_ATTN_BIT_EN);
1264
1265         DP(NETIF_MSG_INTR, "write %x to IGU\n", val);
1266
1267         /* flush all outstanding writes */
1268         mmiowb();
1269
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");
1273 }
1274
1275 static void bnx2x_int_disable(struct bnx2x *bp)
1276 {
1277         if (bp->common.int_block == INT_BLOCK_HC)
1278                 bnx2x_hc_int_disable(bp);
1279         else
1280                 bnx2x_igu_int_disable(bp);
1281 }
1282
1283 void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
1284 {
1285         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
1286         int i, offset;
1287
1288         /* disable interrupt handling */
1289         atomic_inc(&bp->intr_sem);
1290         smp_wmb(); /* Ensure that bp->intr_sem update is SMP-safe */
1291
1292         if (disable_hw)
1293                 /* prevent the HW from sending interrupts */
1294                 bnx2x_int_disable(bp);
1295
1296         /* make sure all ISRs are done */
1297         if (msix) {
1298                 synchronize_irq(bp->msix_table[0].vector);
1299                 offset = 1;
1300 #ifdef BCM_CNIC
1301                 offset++;
1302 #endif
1303                 for_each_eth_queue(bp, i)
1304                         synchronize_irq(bp->msix_table[i + offset].vector);
1305         } else
1306                 synchronize_irq(bp->pdev->irq);
1307
1308         /* make sure sp_task is not running */
1309         cancel_delayed_work(&bp->sp_task);
1310         flush_workqueue(bnx2x_wq);
1311 }
1312
1313 /* fast path */
1314
1315 /*
1316  * General service functions
1317  */
1318
1319 /* Return true if succeeded to acquire the lock */
1320 static bool bnx2x_trylock_hw_lock(struct bnx2x *bp, u32 resource)
1321 {
1322         u32 lock_status;
1323         u32 resource_bit = (1 << resource);
1324         int func = BP_FUNC(bp);
1325         u32 hw_lock_control_reg;
1326
1327         DP(NETIF_MSG_HW, "Trying to take a lock on resource %d\n", resource);
1328
1329         /* Validating that the resource is within range */
1330         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1331                 DP(NETIF_MSG_HW,
1332                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1333                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1334                 return false;
1335         }
1336
1337         if (func <= 5)
1338                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1339         else
1340                 hw_lock_control_reg =
1341                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1342
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)
1347                 return true;
1348
1349         DP(NETIF_MSG_HW, "Failed to get a lock on resource %d\n", resource);
1350         return false;
1351 }
1352
1353 #ifdef BCM_CNIC
1354 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid);
1355 #endif
1356
1357 void bnx2x_sp_event(struct bnx2x_fastpath *fp,
1358                            union eth_rx_cqe *rr_cqe)
1359 {
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);
1363
1364         DP(BNX2X_MSG_SP,
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);
1368
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;
1373                 break;
1374
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;
1378                 break;
1379
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;
1383                 break;
1384
1385         default:
1386                 BNX2X_ERR("unexpected MC reply (%d)  "
1387                           "fp[%d] state is %x\n",
1388                           command, fp->index, fp->state);
1389                 break;
1390         }
1391
1392         smp_mb__before_atomic_inc();
1393         atomic_inc(&bp->cq_spq_left);
1394         /* push the change in fp->state and towards the memory */
1395         smp_wmb();
1396
1397         return;
1398 }
1399
1400 irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
1401 {
1402         struct bnx2x *bp = netdev_priv(dev_instance);
1403         u16 status = bnx2x_ack_int(bp);
1404         u16 mask;
1405         int i;
1406
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");
1410                 return IRQ_NONE;
1411         }
1412         DP(NETIF_MSG_INTR, "got an interrupt  status 0x%x\n", status);
1413
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");
1417                 return IRQ_HANDLED;
1418         }
1419
1420 #ifdef BNX2X_STOP_ON_ERROR
1421         if (unlikely(bp->panic))
1422                 return IRQ_HANDLED;
1423 #endif
1424
1425         for_each_eth_queue(bp, i) {
1426                 struct bnx2x_fastpath *fp = &bp->fp[i];
1427
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));
1435                         status &= ~mask;
1436                 }
1437         }
1438
1439 #ifdef BCM_CNIC
1440         mask = 0x2;
1441         if (status & (mask | 0x1)) {
1442                 struct cnic_ops *c_ops = NULL;
1443
1444                 rcu_read_lock();
1445                 c_ops = rcu_dereference(bp->cnic_ops);
1446                 if (c_ops)
1447                         c_ops->cnic_handler(bp->cnic_data, NULL);
1448                 rcu_read_unlock();
1449
1450                 status &= ~mask;
1451         }
1452 #endif
1453
1454         if (unlikely(status & 0x1)) {
1455                 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
1456
1457                 status &= ~0x1;
1458                 if (!status)
1459                         return IRQ_HANDLED;
1460         }
1461
1462         if (unlikely(status))
1463                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
1464                    status);
1465
1466         return IRQ_HANDLED;
1467 }
1468
1469 /* end of fast path */
1470
1471
1472 /* Link */
1473
1474 /*
1475  * General service functions
1476  */
1477
1478 int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource)
1479 {
1480         u32 lock_status;
1481         u32 resource_bit = (1 << resource);
1482         int func = BP_FUNC(bp);
1483         u32 hw_lock_control_reg;
1484         int cnt;
1485
1486         /* Validating that the resource is within range */
1487         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1488                 DP(NETIF_MSG_HW,
1489                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1490                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1491                 return -EINVAL;
1492         }
1493
1494         if (func <= 5) {
1495                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1496         } else {
1497                 hw_lock_control_reg =
1498                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1499         }
1500
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);
1506                 return -EEXIST;
1507         }
1508
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)
1515                         return 0;
1516
1517                 msleep(5);
1518         }
1519         DP(NETIF_MSG_HW, "Timeout\n");
1520         return -EAGAIN;
1521 }
1522
1523 int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource)
1524 {
1525         u32 lock_status;
1526         u32 resource_bit = (1 << resource);
1527         int func = BP_FUNC(bp);
1528         u32 hw_lock_control_reg;
1529
1530         DP(NETIF_MSG_HW, "Releasing a lock on resource %d\n", resource);
1531
1532         /* Validating that the resource is within range */
1533         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1534                 DP(NETIF_MSG_HW,
1535                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1536                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1537                 return -EINVAL;
1538         }
1539
1540         if (func <= 5) {
1541                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1542         } else {
1543                 hw_lock_control_reg =
1544                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1545         }
1546
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);
1552                 return -EFAULT;
1553         }
1554
1555         REG_WR(bp, hw_lock_control_reg, resource_bit);
1556         return 0;
1557 }
1558
1559
1560 int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, u8 port)
1561 {
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);
1568         u32 gpio_reg;
1569         int value;
1570
1571         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1572                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1573                 return -EINVAL;
1574         }
1575
1576         /* read GPIO value */
1577         gpio_reg = REG_RD(bp, MISC_REG_GPIO);
1578
1579         /* get the requested pin value */
1580         if ((gpio_reg & gpio_mask) == gpio_mask)
1581                 value = 1;
1582         else
1583                 value = 0;
1584
1585         DP(NETIF_MSG_LINK, "pin %d  value 0x%x\n", gpio_num, value);
1586
1587         return value;
1588 }
1589
1590 int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1591 {
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);
1598         u32 gpio_reg;
1599
1600         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1601                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1602                 return -EINVAL;
1603         }
1604
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);
1608
1609         switch (mode) {
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);
1616                 break;
1617
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);
1624                 break;
1625
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);
1629                 /* set FLOAT */
1630                 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1631                 break;
1632
1633         default:
1634                 break;
1635         }
1636
1637         REG_WR(bp, MISC_REG_GPIO, gpio_reg);
1638         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1639
1640         return 0;
1641 }
1642
1643 int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1644 {
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);
1651         u32 gpio_reg;
1652
1653         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1654                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1655                 return -EINVAL;
1656         }
1657
1658         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1659         /* read GPIO int */
1660         gpio_reg = REG_RD(bp, MISC_REG_GPIO_INT);
1661
1662         switch (mode) {
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);
1669                 break;
1670
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);
1677                 break;
1678
1679         default:
1680                 break;
1681         }
1682
1683         REG_WR(bp, MISC_REG_GPIO_INT, gpio_reg);
1684         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1685
1686         return 0;
1687 }
1688
1689 static int bnx2x_set_spio(struct bnx2x *bp, int spio_num, u32 mode)
1690 {
1691         u32 spio_mask = (1 << spio_num);
1692         u32 spio_reg;
1693
1694         if ((spio_num < MISC_REGISTERS_SPIO_4) ||
1695             (spio_num > MISC_REGISTERS_SPIO_7)) {
1696                 BNX2X_ERR("Invalid SPIO %d\n", spio_num);
1697                 return -EINVAL;
1698         }
1699
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);
1703
1704         switch (mode) {
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);
1710                 break;
1711
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);
1717                 break;
1718
1719         case MISC_REGISTERS_SPIO_INPUT_HI_Z:
1720                 DP(NETIF_MSG_LINK, "Set SPIO %d -> input\n", spio_num);
1721                 /* set FLOAT */
1722                 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
1723                 break;
1724
1725         default:
1726                 break;
1727         }
1728
1729         REG_WR(bp, MISC_REG_SPIO, spio_reg);
1730         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1731
1732         return 0;
1733 }
1734
1735 int bnx2x_get_link_cfg_idx(struct bnx2x *bp)
1736 {
1737         u32 sel_phy_idx = 0;
1738         if (bp->link_vars.link_up) {
1739                 sel_phy_idx = EXT_PHY1;
1740                 /* In case link is SERDES, check if the EXT_PHY2 is the one */
1741                 if ((bp->link_vars.link_status & LINK_STATUS_SERDES_LINK) &&
1742                     (bp->link_params.phy[EXT_PHY2].supported & SUPPORTED_FIBRE))
1743                         sel_phy_idx = EXT_PHY2;
1744         } else {
1745
1746                 switch (bnx2x_phy_selection(&bp->link_params)) {
1747                 case PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT:
1748                 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY:
1749                 case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY:
1750                        sel_phy_idx = EXT_PHY1;
1751                        break;
1752                 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY:
1753                 case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY:
1754                        sel_phy_idx = EXT_PHY2;
1755                        break;
1756                 }
1757         }
1758         /*
1759         * The selected actived PHY is always after swapping (in case PHY
1760         * swapping is enabled). So when swapping is enabled, we need to reverse
1761         * the configuration
1762         */
1763
1764         if (bp->link_params.multi_phy_config &
1765             PORT_HW_CFG_PHY_SWAPPED_ENABLED) {
1766                 if (sel_phy_idx == EXT_PHY1)
1767                         sel_phy_idx = EXT_PHY2;
1768                 else if (sel_phy_idx == EXT_PHY2)
1769                         sel_phy_idx = EXT_PHY1;
1770         }
1771         return LINK_CONFIG_IDX(sel_phy_idx);
1772 }
1773
1774 void bnx2x_calc_fc_adv(struct bnx2x *bp)
1775 {
1776         u8 cfg_idx = bnx2x_get_link_cfg_idx(bp);
1777         switch (bp->link_vars.ieee_fc &
1778                 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
1779         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
1780                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1781                                                    ADVERTISED_Pause);
1782                 break;
1783
1784         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
1785                 bp->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
1786                                                   ADVERTISED_Pause);
1787                 break;
1788
1789         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
1790                 bp->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
1791                 break;
1792
1793         default:
1794                 bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
1795                                                    ADVERTISED_Pause);
1796                 break;
1797         }
1798 }
1799
1800 u8 bnx2x_initial_phy_init(struct bnx2x *bp, int load_mode)
1801 {
1802         if (!BP_NOMCP(bp)) {
1803                 u8 rc;
1804                 int cfx_idx = bnx2x_get_link_cfg_idx(bp);
1805                 u16 req_line_speed = bp->link_params.req_line_speed[cfx_idx];
1806                 /* Initialize link parameters structure variables */
1807                 /* It is recommended to turn off RX FC for jumbo frames
1808                    for better performance */
1809                 if ((CHIP_IS_E1x(bp)) && (bp->dev->mtu > 5000))
1810                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_TX;
1811                 else
1812                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
1813
1814                 bnx2x_acquire_phy_lock(bp);
1815
1816                 if (load_mode == LOAD_DIAG) {
1817                         bp->link_params.loopback_mode = LOOPBACK_XGXS;
1818                         bp->link_params.req_line_speed[cfx_idx] = SPEED_10000;
1819                 }
1820
1821                 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1822
1823                 bnx2x_release_phy_lock(bp);
1824
1825                 bnx2x_calc_fc_adv(bp);
1826
1827                 if (CHIP_REV_IS_SLOW(bp) && bp->link_vars.link_up) {
1828                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
1829                         bnx2x_link_report(bp);
1830                 }
1831                 bp->link_params.req_line_speed[cfx_idx] = req_line_speed;
1832                 return rc;
1833         }
1834         BNX2X_ERR("Bootcode is missing - can not initialize link\n");
1835         return -EINVAL;
1836 }
1837
1838 void bnx2x_link_set(struct bnx2x *bp)
1839 {
1840         if (!BP_NOMCP(bp)) {
1841                 bnx2x_acquire_phy_lock(bp);
1842                 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1843                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
1844                 bnx2x_release_phy_lock(bp);
1845
1846                 bnx2x_calc_fc_adv(bp);
1847         } else
1848                 BNX2X_ERR("Bootcode is missing - can not set link\n");
1849 }
1850
1851 static void bnx2x__link_reset(struct bnx2x *bp)
1852 {
1853         if (!BP_NOMCP(bp)) {
1854                 bnx2x_acquire_phy_lock(bp);
1855                 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
1856                 bnx2x_release_phy_lock(bp);
1857         } else
1858                 BNX2X_ERR("Bootcode is missing - can not reset link\n");
1859 }
1860
1861 u8 bnx2x_link_test(struct bnx2x *bp, u8 is_serdes)
1862 {
1863         u8 rc = 0;
1864
1865         if (!BP_NOMCP(bp)) {
1866                 bnx2x_acquire_phy_lock(bp);
1867                 rc = bnx2x_test_link(&bp->link_params, &bp->link_vars,
1868                                      is_serdes);
1869                 bnx2x_release_phy_lock(bp);
1870         } else
1871                 BNX2X_ERR("Bootcode is missing - can not test link\n");
1872
1873         return rc;
1874 }
1875
1876 static void bnx2x_init_port_minmax(struct bnx2x *bp)
1877 {
1878         u32 r_param = bp->link_vars.line_speed / 8;
1879         u32 fair_periodic_timeout_usec;
1880         u32 t_fair;
1881
1882         memset(&(bp->cmng.rs_vars), 0,
1883                sizeof(struct rate_shaping_vars_per_port));
1884         memset(&(bp->cmng.fair_vars), 0, sizeof(struct fairness_vars_per_port));
1885
1886         /* 100 usec in SDM ticks = 25 since each tick is 4 usec */
1887         bp->cmng.rs_vars.rs_periodic_timeout = RS_PERIODIC_TIMEOUT_USEC / 4;
1888
1889         /* this is the threshold below which no timer arming will occur
1890            1.25 coefficient is for the threshold to be a little bigger
1891            than the real time, to compensate for timer in-accuracy */
1892         bp->cmng.rs_vars.rs_threshold =
1893                                 (RS_PERIODIC_TIMEOUT_USEC * r_param * 5) / 4;
1894
1895         /* resolution of fairness timer */
1896         fair_periodic_timeout_usec = QM_ARB_BYTES / r_param;
1897         /* for 10G it is 1000usec. for 1G it is 10000usec. */
1898         t_fair = T_FAIR_COEF / bp->link_vars.line_speed;
1899
1900         /* this is the threshold below which we won't arm the timer anymore */
1901         bp->cmng.fair_vars.fair_threshold = QM_ARB_BYTES;
1902
1903         /* we multiply by 1e3/8 to get bytes/msec.
1904            We don't want the credits to pass a credit
1905            of the t_fair*FAIR_MEM (algorithm resolution) */
1906         bp->cmng.fair_vars.upper_bound = r_param * t_fair * FAIR_MEM;
1907         /* since each tick is 4 usec */
1908         bp->cmng.fair_vars.fairness_timeout = fair_periodic_timeout_usec / 4;
1909 }
1910
1911 /* Calculates the sum of vn_min_rates.
1912    It's needed for further normalizing of the min_rates.
1913    Returns:
1914      sum of vn_min_rates.
1915        or
1916      0 - if all the min_rates are 0.
1917      In the later case fainess algorithm should be deactivated.
1918      If not all min_rates are zero then those that are zeroes will be set to 1.
1919  */
1920 static void bnx2x_calc_vn_weight_sum(struct bnx2x *bp)
1921 {
1922         int all_zero = 1;
1923         int vn;
1924
1925         bp->vn_weight_sum = 0;
1926         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
1927                 u32 vn_cfg = bp->mf_config[vn];
1928                 u32 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1929                                    FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1930
1931                 /* Skip hidden vns */
1932                 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
1933                         continue;
1934
1935                 /* If min rate is zero - set it to 1 */
1936                 if (!vn_min_rate)
1937                         vn_min_rate = DEF_MIN_RATE;
1938                 else
1939                         all_zero = 0;
1940
1941                 bp->vn_weight_sum += vn_min_rate;
1942         }
1943
1944         /* ... only if all min rates are zeros - disable fairness */
1945         if (all_zero) {
1946                 bp->cmng.flags.cmng_enables &=
1947                                         ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1948                 DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
1949                    "  fairness will be disabled\n");
1950         } else
1951                 bp->cmng.flags.cmng_enables |=
1952                                         CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
1953 }
1954
1955 static void bnx2x_init_vn_minmax(struct bnx2x *bp, int vn)
1956 {
1957         struct rate_shaping_vars_per_vn m_rs_vn;
1958         struct fairness_vars_per_vn m_fair_vn;
1959         u32 vn_cfg = bp->mf_config[vn];
1960         int func = 2*vn + BP_PORT(bp);
1961         u16 vn_min_rate, vn_max_rate;
1962         int i;
1963
1964         /* If function is hidden - set min and max to zeroes */
1965         if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE) {
1966                 vn_min_rate = 0;
1967                 vn_max_rate = 0;
1968
1969         } else {
1970                 u32 maxCfg = bnx2x_extract_max_cfg(bp, vn_cfg);
1971
1972                 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
1973                                 FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
1974                 /* If fairness is enabled (not all min rates are zeroes) and
1975                    if current min rate is zero - set it to 1.
1976                    This is a requirement of the algorithm. */
1977                 if (bp->vn_weight_sum && (vn_min_rate == 0))
1978                         vn_min_rate = DEF_MIN_RATE;
1979
1980                 if (IS_MF_SI(bp))
1981                         /* maxCfg in percents of linkspeed */
1982                         vn_max_rate = (bp->link_vars.line_speed * maxCfg) / 100;
1983                 else
1984                         /* maxCfg is absolute in 100Mb units */
1985                         vn_max_rate = maxCfg * 100;
1986         }
1987
1988         DP(NETIF_MSG_IFUP,
1989            "func %d: vn_min_rate %d  vn_max_rate %d  vn_weight_sum %d\n",
1990            func, vn_min_rate, vn_max_rate, bp->vn_weight_sum);
1991
1992         memset(&m_rs_vn, 0, sizeof(struct rate_shaping_vars_per_vn));
1993         memset(&m_fair_vn, 0, sizeof(struct fairness_vars_per_vn));
1994
1995         /* global vn counter - maximal Mbps for this vn */
1996         m_rs_vn.vn_counter.rate = vn_max_rate;
1997
1998         /* quota - number of bytes transmitted in this period */
1999         m_rs_vn.vn_counter.quota =
2000                                 (vn_max_rate * RS_PERIODIC_TIMEOUT_USEC) / 8;
2001
2002         if (bp->vn_weight_sum) {
2003                 /* credit for each period of the fairness algorithm:
2004                    number of bytes in T_FAIR (the vn share the port rate).
2005                    vn_weight_sum should not be larger than 10000, thus
2006                    T_FAIR_COEF / (8 * vn_weight_sum) will always be greater
2007                    than zero */
2008                 m_fair_vn.vn_credit_delta =
2009                         max_t(u32, (vn_min_rate * (T_FAIR_COEF /
2010                                                    (8 * bp->vn_weight_sum))),
2011                               (bp->cmng.fair_vars.fair_threshold +
2012                                                         MIN_ABOVE_THRESH));
2013                 DP(NETIF_MSG_IFUP, "m_fair_vn.vn_credit_delta %d\n",
2014                    m_fair_vn.vn_credit_delta);
2015         }
2016
2017         /* Store it to internal memory */
2018         for (i = 0; i < sizeof(struct rate_shaping_vars_per_vn)/4; i++)
2019                 REG_WR(bp, BAR_XSTRORM_INTMEM +
2020                        XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func) + i * 4,
2021                        ((u32 *)(&m_rs_vn))[i]);
2022
2023         for (i = 0; i < sizeof(struct fairness_vars_per_vn)/4; i++)
2024                 REG_WR(bp, BAR_XSTRORM_INTMEM +
2025                        XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func) + i * 4,
2026                        ((u32 *)(&m_fair_vn))[i]);
2027 }
2028
2029 static int bnx2x_get_cmng_fns_mode(struct bnx2x *bp)
2030 {
2031         if (CHIP_REV_IS_SLOW(bp))
2032                 return CMNG_FNS_NONE;
2033         if (IS_MF(bp))
2034                 return CMNG_FNS_MINMAX;
2035
2036         return CMNG_FNS_NONE;
2037 }
2038
2039 void bnx2x_read_mf_cfg(struct bnx2x *bp)
2040 {
2041         int vn, n = (CHIP_MODE_IS_4_PORT(bp) ? 2 : 1);
2042
2043         if (BP_NOMCP(bp))
2044                 return; /* what should be the default bvalue in this case */
2045
2046         /* For 2 port configuration the absolute function number formula
2047          * is:
2048          *      abs_func = 2 * vn + BP_PORT + BP_PATH
2049          *
2050          *      and there are 4 functions per port
2051          *
2052          * For 4 port configuration it is
2053          *      abs_func = 4 * vn + 2 * BP_PORT + BP_PATH
2054          *
2055          *      and there are 2 functions per port
2056          */
2057         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2058                 int /*abs*/func = n * (2 * vn + BP_PORT(bp)) + BP_PATH(bp);
2059
2060                 if (func >= E1H_FUNC_MAX)
2061                         break;
2062
2063                 bp->mf_config[vn] =
2064                         MF_CFG_RD(bp, func_mf_config[func].config);
2065         }
2066 }
2067
2068 static void bnx2x_cmng_fns_init(struct bnx2x *bp, u8 read_cfg, u8 cmng_type)
2069 {
2070
2071         if (cmng_type == CMNG_FNS_MINMAX) {
2072                 int vn;
2073
2074                 /* clear cmng_enables */
2075                 bp->cmng.flags.cmng_enables = 0;
2076
2077                 /* read mf conf from shmem */
2078                 if (read_cfg)
2079                         bnx2x_read_mf_cfg(bp);
2080
2081                 /* Init rate shaping and fairness contexts */
2082                 bnx2x_init_port_minmax(bp);
2083
2084                 /* vn_weight_sum and enable fairness if not 0 */
2085                 bnx2x_calc_vn_weight_sum(bp);
2086
2087                 /* calculate and set min-max rate for each vn */
2088                 if (bp->port.pmf)
2089                         for (vn = VN_0; vn < E1HVN_MAX; vn++)
2090                                 bnx2x_init_vn_minmax(bp, vn);
2091
2092                 /* always enable rate shaping and fairness */
2093                 bp->cmng.flags.cmng_enables |=
2094                                         CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN;
2095                 if (!bp->vn_weight_sum)
2096                         DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
2097                                    "  fairness will be disabled\n");
2098                 return;
2099         }
2100
2101         /* rate shaping and fairness are disabled */
2102         DP(NETIF_MSG_IFUP,
2103            "rate shaping and fairness are disabled\n");
2104 }
2105
2106 static inline void bnx2x_link_sync_notify(struct bnx2x *bp)
2107 {
2108         int port = BP_PORT(bp);
2109         int func;
2110         int vn;
2111
2112         /* Set the attention towards other drivers on the same port */
2113         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2114                 if (vn == BP_E1HVN(bp))
2115                         continue;
2116
2117                 func = ((vn << 1) | port);
2118                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_0 +
2119                        (LINK_SYNC_ATTENTION_BIT_FUNC_0 + func)*4, 1);
2120         }
2121 }
2122
2123 /* This function is called upon link interrupt */
2124 static void bnx2x_link_attn(struct bnx2x *bp)
2125 {
2126         /* Make sure that we are synced with the current statistics */
2127         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2128
2129         bnx2x_link_update(&bp->link_params, &bp->link_vars);
2130
2131         if (bp->link_vars.link_up) {
2132
2133                 /* dropless flow control */
2134                 if (!CHIP_IS_E1(bp) && bp->dropless_fc) {
2135                         int port = BP_PORT(bp);
2136                         u32 pause_enabled = 0;
2137
2138                         if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
2139                                 pause_enabled = 1;
2140
2141                         REG_WR(bp, BAR_USTRORM_INTMEM +
2142                                USTORM_ETH_PAUSE_ENABLED_OFFSET(port),
2143                                pause_enabled);
2144                 }
2145
2146                 if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
2147                         struct host_port_stats *pstats;
2148
2149                         pstats = bnx2x_sp(bp, port_stats);
2150                         /* reset old bmac stats */
2151                         memset(&(pstats->mac_stx[0]), 0,
2152                                sizeof(struct mac_stx));
2153                 }
2154                 if (bp->state == BNX2X_STATE_OPEN)
2155                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2156         }
2157
2158         if (bp->link_vars.link_up && bp->link_vars.line_speed) {
2159                 int cmng_fns = bnx2x_get_cmng_fns_mode(bp);
2160
2161                 if (cmng_fns != CMNG_FNS_NONE) {
2162                         bnx2x_cmng_fns_init(bp, false, cmng_fns);
2163                         storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2164                 } else
2165                         /* rate shaping and fairness are disabled */
2166                         DP(NETIF_MSG_IFUP,
2167                            "single function mode without fairness\n");
2168         }
2169
2170         __bnx2x_link_report(bp);
2171
2172         if (IS_MF(bp))
2173                 bnx2x_link_sync_notify(bp);
2174 }
2175
2176 void bnx2x__link_status_update(struct bnx2x *bp)
2177 {
2178         if (bp->state != BNX2X_STATE_OPEN)
2179                 return;
2180
2181         bnx2x_link_status_update(&bp->link_params, &bp->link_vars);
2182
2183         if (bp->link_vars.link_up)
2184                 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2185         else
2186                 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2187
2188         /* indicate link status */
2189         bnx2x_link_report(bp);
2190 }
2191
2192 static void bnx2x_pmf_update(struct bnx2x *bp)
2193 {
2194         int port = BP_PORT(bp);
2195         u32 val;
2196
2197         bp->port.pmf = 1;
2198         DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
2199
2200         /* enable nig attention */
2201         val = (0xff0f | (1 << (BP_E1HVN(bp) + 4)));
2202         if (bp->common.int_block == INT_BLOCK_HC) {
2203                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
2204                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
2205         } else if (CHIP_IS_E2(bp)) {
2206                 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, val);
2207                 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, val);
2208         }
2209
2210         bnx2x_stats_handle(bp, STATS_EVENT_PMF);
2211 }
2212
2213 /* end of Link */
2214
2215 /* slow path */
2216
2217 /*
2218  * General service functions
2219  */
2220
2221 /* send the MCP a request, block until there is a reply */
2222 u32 bnx2x_fw_command(struct bnx2x *bp, u32 command, u32 param)
2223 {
2224         int mb_idx = BP_FW_MB_IDX(bp);
2225         u32 seq = ++bp->fw_seq;
2226         u32 rc = 0;
2227         u32 cnt = 1;
2228         u8 delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
2229
2230         mutex_lock(&bp->fw_mb_mutex);
2231         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_param, param);
2232         SHMEM_WR(bp, func_mb[mb_idx].drv_mb_header, (command | seq));
2233
2234         DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB\n", (command | seq));
2235
2236         do {
2237                 /* let the FW do it's magic ... */
2238                 msleep(delay);
2239
2240                 rc = SHMEM_RD(bp, func_mb[mb_idx].fw_mb_header);
2241
2242                 /* Give the FW up to 5 second (500*10ms) */
2243         } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
2244
2245         DP(BNX2X_MSG_MCP, "[after %d ms] read (%x) seq is (%x) from FW MB\n",
2246            cnt*delay, rc, seq);
2247
2248         /* is this a reply to our command? */
2249         if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK))
2250                 rc &= FW_MSG_CODE_MASK;
2251         else {
2252                 /* FW BUG! */
2253                 BNX2X_ERR("FW failed to respond!\n");
2254                 bnx2x_fw_dump(bp);
2255                 rc = 0;
2256         }
2257         mutex_unlock(&bp->fw_mb_mutex);
2258
2259         return rc;
2260 }
2261
2262 static u8 stat_counter_valid(struct bnx2x *bp, struct bnx2x_fastpath *fp)
2263 {
2264 #ifdef BCM_CNIC
2265         if (IS_FCOE_FP(fp) && IS_MF(bp))
2266                 return false;
2267 #endif
2268         return true;
2269 }
2270
2271 /* must be called under rtnl_lock */
2272 static void bnx2x_rxq_set_mac_filters(struct bnx2x *bp, u16 cl_id, u32 filters)
2273 {
2274         u32 mask = (1 << cl_id);
2275
2276         /* initial seeting is BNX2X_ACCEPT_NONE */
2277         u8 drop_all_ucast = 1, drop_all_bcast = 1, drop_all_mcast = 1;
2278         u8 accp_all_ucast = 0, accp_all_bcast = 0, accp_all_mcast = 0;
2279         u8 unmatched_unicast = 0;
2280
2281         if (filters & BNX2X_ACCEPT_UNMATCHED_UCAST)
2282                 unmatched_unicast = 1;
2283
2284         if (filters & BNX2X_PROMISCUOUS_MODE) {
2285                 /* promiscious - accept all, drop none */
2286                 drop_all_ucast = drop_all_bcast = drop_all_mcast = 0;
2287                 accp_all_ucast = accp_all_bcast = accp_all_mcast = 1;
2288                 if (IS_MF_SI(bp)) {
2289                         /*
2290                          * SI mode defines to accept in promiscuos mode
2291                          * only unmatched packets
2292                          */
2293                         unmatched_unicast = 1;
2294                         accp_all_ucast = 0;
2295                 }
2296         }
2297         if (filters & BNX2X_ACCEPT_UNICAST) {
2298                 /* accept matched ucast */
2299                 drop_all_ucast = 0;
2300         }
2301         if (filters & BNX2X_ACCEPT_MULTICAST)
2302                 /* accept matched mcast */
2303                 drop_all_mcast = 0;
2304
2305         if (filters & BNX2X_ACCEPT_ALL_UNICAST) {
2306                 /* accept all mcast */
2307                 drop_all_ucast = 0;
2308                 accp_all_ucast = 1;
2309         }
2310         if (filters & BNX2X_ACCEPT_ALL_MULTICAST) {
2311                 /* accept all mcast */
2312                 drop_all_mcast = 0;
2313                 accp_all_mcast = 1;
2314         }
2315         if (filters & BNX2X_ACCEPT_BROADCAST) {
2316                 /* accept (all) bcast */
2317                 drop_all_bcast = 0;
2318                 accp_all_bcast = 1;
2319         }
2320
2321         bp->mac_filters.ucast_drop_all = drop_all_ucast ?
2322                 bp->mac_filters.ucast_drop_all | mask :
2323                 bp->mac_filters.ucast_drop_all & ~mask;
2324
2325         bp->mac_filters.mcast_drop_all = drop_all_mcast ?
2326                 bp->mac_filters.mcast_drop_all | mask :
2327                 bp->mac_filters.mcast_drop_all & ~mask;
2328
2329         bp->mac_filters.bcast_drop_all = drop_all_bcast ?
2330                 bp->mac_filters.bcast_drop_all | mask :
2331                 bp->mac_filters.bcast_drop_all & ~mask;
2332
2333         bp->mac_filters.ucast_accept_all = accp_all_ucast ?
2334                 bp->mac_filters.ucast_accept_all | mask :
2335                 bp->mac_filters.ucast_accept_all & ~mask;
2336
2337         bp->mac_filters.mcast_accept_all = accp_all_mcast ?
2338                 bp->mac_filters.mcast_accept_all | mask :
2339                 bp->mac_filters.mcast_accept_all & ~mask;
2340
2341         bp->mac_filters.bcast_accept_all = accp_all_bcast ?
2342                 bp->mac_filters.bcast_accept_all | mask :
2343                 bp->mac_filters.bcast_accept_all & ~mask;
2344
2345         bp->mac_filters.unmatched_unicast = unmatched_unicast ?
2346                 bp->mac_filters.unmatched_unicast | mask :
2347                 bp->mac_filters.unmatched_unicast & ~mask;
2348 }
2349
2350 static void bnx2x_func_init(struct bnx2x *bp, struct bnx2x_func_init_params *p)
2351 {
2352         struct tstorm_eth_function_common_config tcfg = {0};
2353         u16 rss_flgs;
2354
2355         /* tpa */
2356         if (p->func_flgs & FUNC_FLG_TPA)
2357                 tcfg.config_flags |=
2358                 TSTORM_ETH_FUNCTION_COMMON_CONFIG_ENABLE_TPA;
2359
2360         /* set rss flags */
2361         rss_flgs = (p->rss->mode <<
2362                 TSTORM_ETH_FUNCTION_COMMON_CONFIG_RSS_MODE_SHIFT);
2363
2364         if (p->rss->cap & RSS_IPV4_CAP)
2365                 rss_flgs |= RSS_IPV4_CAP_MASK;
2366         if (p->rss->cap & RSS_IPV4_TCP_CAP)
2367                 rss_flgs |= RSS_IPV4_TCP_CAP_MASK;
2368         if (p->rss->cap & RSS_IPV6_CAP)
2369                 rss_flgs |= RSS_IPV6_CAP_MASK;
2370         if (p->rss->cap & RSS_IPV6_TCP_CAP)
2371                 rss_flgs |= RSS_IPV6_TCP_CAP_MASK;
2372
2373         tcfg.config_flags |= rss_flgs;
2374         tcfg.rss_result_mask = p->rss->result_mask;
2375
2376         storm_memset_func_cfg(bp, &tcfg, p->func_id);
2377
2378         /* Enable the function in the FW */
2379         storm_memset_vf_to_pf(bp, p->func_id, p->pf_id);
2380         storm_memset_func_en(bp, p->func_id, 1);
2381
2382         /* statistics */
2383         if (p->func_flgs & FUNC_FLG_STATS) {
2384                 struct stats_indication_flags stats_flags = {0};
2385                 stats_flags.collect_eth = 1;
2386
2387                 storm_memset_xstats_flags(bp, &stats_flags, p->func_id);
2388                 storm_memset_xstats_addr(bp, p->fw_stat_map, p->func_id);
2389
2390                 storm_memset_tstats_flags(bp, &stats_flags, p->func_id);
2391                 storm_memset_tstats_addr(bp, p->fw_stat_map, p->func_id);
2392
2393                 storm_memset_ustats_flags(bp, &stats_flags, p->func_id);
2394                 storm_memset_ustats_addr(bp, p->fw_stat_map, p->func_id);
2395
2396                 storm_memset_cstats_flags(bp, &stats_flags, p->func_id);
2397                 storm_memset_cstats_addr(bp, p->fw_stat_map, p->func_id);
2398         }
2399
2400         /* spq */
2401         if (p->func_flgs & FUNC_FLG_SPQ) {
2402                 storm_memset_spq_addr(bp, p->spq_map, p->func_id);
2403                 REG_WR(bp, XSEM_REG_FAST_MEMORY +
2404                        XSTORM_SPQ_PROD_OFFSET(p->func_id), p->spq_prod);
2405         }
2406 }
2407
2408 static inline u16 bnx2x_get_cl_flags(struct bnx2x *bp,
2409                                      struct bnx2x_fastpath *fp)
2410 {
2411         u16 flags = 0;
2412
2413         /* calculate queue flags */
2414         flags |= QUEUE_FLG_CACHE_ALIGN;
2415         flags |= QUEUE_FLG_HC;
2416         flags |= IS_MF_SD(bp) ? QUEUE_FLG_OV : 0;
2417
2418         flags |= QUEUE_FLG_VLAN;
2419         DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
2420
2421         if (!fp->disable_tpa)
2422                 flags |= QUEUE_FLG_TPA;
2423
2424         flags = stat_counter_valid(bp, fp) ?
2425                         (flags | QUEUE_FLG_STATS) : (flags & ~QUEUE_FLG_STATS);
2426
2427         return flags;
2428 }
2429
2430 static void bnx2x_pf_rx_cl_prep(struct bnx2x *bp,
2431         struct bnx2x_fastpath *fp, struct rxq_pause_params *pause,
2432         struct bnx2x_rxq_init_params *rxq_init)
2433 {
2434         u16 max_sge = 0;
2435         u16 sge_sz = 0;
2436         u16 tpa_agg_size = 0;
2437
2438         /* calculate queue flags */
2439         u16 flags = bnx2x_get_cl_flags(bp, fp);
2440
2441         if (!fp->disable_tpa) {
2442                 pause->sge_th_hi = 250;
2443                 pause->sge_th_lo = 150;
2444                 tpa_agg_size = min_t(u32,
2445                         (min_t(u32, 8, MAX_SKB_FRAGS) *
2446                         SGE_PAGE_SIZE * PAGES_PER_SGE), 0xffff);
2447                 max_sge = SGE_PAGE_ALIGN(bp->dev->mtu) >>
2448                         SGE_PAGE_SHIFT;
2449                 max_sge = ((max_sge + PAGES_PER_SGE - 1) &
2450                           (~(PAGES_PER_SGE-1))) >> PAGES_PER_SGE_SHIFT;
2451                 sge_sz = (u16)min_t(u32, SGE_PAGE_SIZE * PAGES_PER_SGE,
2452                                     0xffff);
2453         }
2454
2455         /* pause - not for e1 */
2456         if (!CHIP_IS_E1(bp)) {
2457                 pause->bd_th_hi = 350;
2458                 pause->bd_th_lo = 250;
2459                 pause->rcq_th_hi = 350;
2460                 pause->rcq_th_lo = 250;
2461                 pause->sge_th_hi = 0;
2462                 pause->sge_th_lo = 0;
2463                 pause->pri_map = 1;
2464         }
2465
2466         /* rxq setup */
2467         rxq_init->flags = flags;
2468         rxq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2469         rxq_init->dscr_map = fp->rx_desc_mapping;
2470         rxq_init->sge_map = fp->rx_sge_mapping;
2471         rxq_init->rcq_map = fp->rx_comp_mapping;
2472         rxq_init->rcq_np_map = fp->rx_comp_mapping + BCM_PAGE_SIZE;
2473
2474         /* Always use mini-jumbo MTU for FCoE L2 ring */
2475         if (IS_FCOE_FP(fp))
2476                 rxq_init->mtu = BNX2X_FCOE_MINI_JUMBO_MTU;
2477         else
2478                 rxq_init->mtu = bp->dev->mtu;
2479
2480         rxq_init->buf_sz = fp->rx_buf_size;
2481         rxq_init->cl_qzone_id = fp->cl_qzone_id;
2482         rxq_init->cl_id = fp->cl_id;
2483         rxq_init->spcl_id = fp->cl_id;
2484         rxq_init->stat_id = fp->cl_id;
2485         rxq_init->tpa_agg_sz = tpa_agg_size;
2486         rxq_init->sge_buf_sz = sge_sz;
2487         rxq_init->max_sges_pkt = max_sge;
2488         rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
2489         rxq_init->fw_sb_id = fp->fw_sb_id;
2490
2491         if (IS_FCOE_FP(fp))
2492                 rxq_init->sb_cq_index = HC_SP_INDEX_ETH_FCOE_RX_CQ_CONS;
2493         else
2494                 rxq_init->sb_cq_index = U_SB_ETH_RX_CQ_INDEX;
2495
2496         rxq_init->cid = HW_CID(bp, fp->cid);
2497
2498         rxq_init->hc_rate = bp->rx_ticks ? (1000000 / bp->rx_ticks) : 0;
2499 }
2500
2501 static void bnx2x_pf_tx_cl_prep(struct bnx2x *bp,
2502         struct bnx2x_fastpath *fp, struct bnx2x_txq_init_params *txq_init)
2503 {
2504         u16 flags = bnx2x_get_cl_flags(bp, fp);
2505
2506         txq_init->flags = flags;
2507         txq_init->cxt = &bp->context.vcxt[fp->cid].eth;
2508         txq_init->dscr_map = fp->tx_desc_mapping;
2509         txq_init->stat_id = fp->cl_id;
2510         txq_init->cid = HW_CID(bp, fp->cid);
2511         txq_init->sb_cq_index = C_SB_ETH_TX_CQ_INDEX;
2512         txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
2513         txq_init->fw_sb_id = fp->fw_sb_id;
2514
2515         if (IS_FCOE_FP(fp)) {
2516                 txq_init->sb_cq_index = HC_SP_INDEX_ETH_FCOE_TX_CQ_CONS;
2517                 txq_init->traffic_type = LLFC_TRAFFIC_TYPE_FCOE;
2518         }
2519
2520         txq_init->hc_rate = bp->tx_ticks ? (1000000 / bp->tx_ticks) : 0;
2521 }
2522
2523 static void bnx2x_pf_init(struct bnx2x *bp)
2524 {
2525         struct bnx2x_func_init_params func_init = {0};
2526         struct bnx2x_rss_params rss = {0};
2527         struct event_ring_data eq_data = { {0} };
2528         u16 flags;
2529
2530         /* pf specific setups */
2531         if (!CHIP_IS_E1(bp))
2532                 storm_memset_ov(bp, bp->mf_ov, BP_FUNC(bp));
2533
2534         if (CHIP_IS_E2(bp)) {
2535                 /* reset IGU PF statistics: MSIX + ATTN */
2536                 /* PF */
2537                 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
2538                            BNX2X_IGU_STAS_MSG_VF_CNT*4 +
2539                            (CHIP_MODE_IS_4_PORT(bp) ?
2540                                 BP_FUNC(bp) : BP_VN(bp))*4, 0);
2541                 /* ATTN */
2542                 REG_WR(bp, IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
2543                            BNX2X_IGU_STAS_MSG_VF_CNT*4 +
2544                            BNX2X_IGU_STAS_MSG_PF_CNT*4 +
2545                            (CHIP_MODE_IS_4_PORT(bp) ?
2546                                 BP_FUNC(bp) : BP_VN(bp))*4, 0);
2547         }
2548
2549         /* function setup flags */
2550         flags = (FUNC_FLG_STATS | FUNC_FLG_LEADING | FUNC_FLG_SPQ);
2551
2552         if (CHIP_IS_E1x(bp))
2553                 flags |= (bp->flags & TPA_ENABLE_FLAG) ? FUNC_FLG_TPA : 0;
2554         else
2555                 flags |= FUNC_FLG_TPA;
2556
2557         /* function setup */
2558
2559         /**
2560          * Although RSS is meaningless when there is a single HW queue we
2561          * still need it enabled in order to have HW Rx hash generated.
2562          */
2563         rss.cap = (RSS_IPV4_CAP | RSS_IPV4_TCP_CAP |
2564                    RSS_IPV6_CAP | RSS_IPV6_TCP_CAP);
2565         rss.mode = bp->multi_mode;
2566         rss.result_mask = MULTI_MASK;
2567         func_init.rss = &rss;
2568
2569         func_init.func_flgs = flags;
2570         func_init.pf_id = BP_FUNC(bp);
2571         func_init.func_id = BP_FUNC(bp);
2572         func_init.fw_stat_map = bnx2x_sp_mapping(bp, fw_stats);
2573         func_init.spq_map = bp->spq_mapping;
2574         func_init.spq_prod = bp->spq_prod_idx;
2575
2576         bnx2x_func_init(bp, &func_init);
2577
2578         memset(&(bp->cmng), 0, sizeof(struct cmng_struct_per_port));
2579
2580         /*
2581         Congestion management values depend on the link rate
2582         There is no active link so initial link rate is set to 10 Gbps.
2583         When the link comes up The congestion management values are
2584         re-calculated according to the actual link rate.
2585         */
2586         bp->link_vars.line_speed = SPEED_10000;
2587         bnx2x_cmng_fns_init(bp, true, bnx2x_get_cmng_fns_mode(bp));
2588
2589         /* Only the PMF sets the HW */
2590         if (bp->port.pmf)
2591                 storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2592
2593         /* no rx until link is up */
2594         bp->rx_mode = BNX2X_RX_MODE_NONE;
2595         bnx2x_set_storm_rx_mode(bp);
2596
2597         /* init Event Queue */
2598         eq_data.base_addr.hi = U64_HI(bp->eq_mapping);
2599         eq_data.base_addr.lo = U64_LO(bp->eq_mapping);
2600         eq_data.producer = bp->eq_prod;
2601         eq_data.index_id = HC_SP_INDEX_EQ_CONS;
2602         eq_data.sb_id = DEF_SB_ID;
2603         storm_memset_eq_data(bp, &eq_data, BP_FUNC(bp));
2604 }
2605
2606
2607 static void bnx2x_e1h_disable(struct bnx2x *bp)
2608 {
2609         int port = BP_PORT(bp);
2610
2611         netif_tx_disable(bp->dev);
2612
2613         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
2614
2615         netif_carrier_off(bp->dev);
2616 }
2617
2618 static void bnx2x_e1h_enable(struct bnx2x *bp)
2619 {
2620         int port = BP_PORT(bp);
2621
2622         REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
2623
2624         /* Tx queue should be only reenabled */
2625         netif_tx_wake_all_queues(bp->dev);
2626
2627         /*
2628          * Should not call netif_carrier_on since it will be called if the link
2629          * is up when checking for link state
2630          */
2631 }
2632
2633 /* called due to MCP event (on pmf):
2634  *      reread new bandwidth configuration
2635  *      configure FW
2636  *      notify others function about the change
2637  */
2638 static inline void bnx2x_config_mf_bw(struct bnx2x *bp)
2639 {
2640         if (bp->link_vars.link_up) {
2641                 bnx2x_cmng_fns_init(bp, true, CMNG_FNS_MINMAX);
2642                 bnx2x_link_sync_notify(bp);
2643         }
2644         storm_memset_cmng(bp, &bp->cmng, BP_PORT(bp));
2645 }
2646
2647 static inline void bnx2x_set_mf_bw(struct bnx2x *bp)
2648 {
2649         bnx2x_config_mf_bw(bp);
2650         bnx2x_fw_command(bp, DRV_MSG_CODE_SET_MF_BW_ACK, 0);
2651 }
2652
2653 static void bnx2x_dcc_event(struct bnx2x *bp, u32 dcc_event)
2654 {
2655         DP(BNX2X_MSG_MCP, "dcc_event 0x%x\n", dcc_event);
2656
2657         if (dcc_event & DRV_STATUS_DCC_DISABLE_ENABLE_PF) {
2658
2659                 /*
2660                  * This is the only place besides the function initialization
2661                  * where the bp->flags can change so it is done without any
2662                  * locks
2663                  */
2664                 if (bp->mf_config[BP_VN(bp)] & FUNC_MF_CFG_FUNC_DISABLED) {
2665                         DP(NETIF_MSG_IFDOWN, "mf_cfg function disabled\n");
2666                         bp->flags |= MF_FUNC_DIS;
2667
2668                         bnx2x_e1h_disable(bp);
2669                 } else {
2670                         DP(NETIF_MSG_IFUP, "mf_cfg function enabled\n");
2671                         bp->flags &= ~MF_FUNC_DIS;
2672
2673                         bnx2x_e1h_enable(bp);
2674                 }
2675                 dcc_event &= ~DRV_STATUS_DCC_DISABLE_ENABLE_PF;
2676         }
2677         if (dcc_event & DRV_STATUS_DCC_BANDWIDTH_ALLOCATION) {
2678                 bnx2x_config_mf_bw(bp);
2679                 dcc_event &= ~DRV_STATUS_DCC_BANDWIDTH_ALLOCATION;
2680         }
2681
2682         /* Report results to MCP */
2683         if (dcc_event)
2684                 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_FAILURE, 0);
2685         else
2686                 bnx2x_fw_command(bp, DRV_MSG_CODE_DCC_OK, 0);
2687 }
2688
2689 /* must be called under the spq lock */
2690 static inline struct eth_spe *bnx2x_sp_get_next(struct bnx2x *bp)
2691 {
2692         struct eth_spe *next_spe = bp->spq_prod_bd;
2693
2694         if (bp->spq_prod_bd == bp->spq_last_bd) {
2695                 bp->spq_prod_bd = bp->spq;
2696                 bp->spq_prod_idx = 0;
2697                 DP(NETIF_MSG_TIMER, "end of spq\n");
2698         } else {
2699                 bp->spq_prod_bd++;
2700                 bp->spq_prod_idx++;
2701         }
2702         return next_spe;
2703 }
2704
2705 /* must be called under the spq lock */
2706 static inline void bnx2x_sp_prod_update(struct bnx2x *bp)
2707 {
2708         int func = BP_FUNC(bp);
2709
2710         /* Make sure that BD data is updated before writing the producer */
2711         wmb();
2712
2713         REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func),
2714                  bp->spq_prod_idx);
2715         mmiowb();
2716 }
2717
2718 /* the slow path queue is odd since completions arrive on the fastpath ring */
2719 int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
2720                   u32 data_hi, u32 data_lo, int common)
2721 {
2722         struct eth_spe *spe;
2723         u16 type;
2724
2725 #ifdef BNX2X_STOP_ON_ERROR
2726         if (unlikely(bp->panic))
2727                 return -EIO;
2728 #endif
2729
2730         spin_lock_bh(&bp->spq_lock);
2731
2732         if (common) {
2733                 if (!atomic_read(&bp->eq_spq_left)) {
2734                         BNX2X_ERR("BUG! EQ ring full!\n");
2735                         spin_unlock_bh(&bp->spq_lock);
2736                         bnx2x_panic();
2737                         return -EBUSY;
2738                 }
2739         } else if (!atomic_read(&bp->cq_spq_left)) {
2740                         BNX2X_ERR("BUG! SPQ ring full!\n");
2741                         spin_unlock_bh(&bp->spq_lock);
2742                         bnx2x_panic();
2743                         return -EBUSY;
2744         }
2745
2746         spe = bnx2x_sp_get_next(bp);
2747
2748         /* CID needs port number to be encoded int it */
2749         spe->hdr.conn_and_cmd_data =
2750                         cpu_to_le32((command << SPE_HDR_CMD_ID_SHIFT) |
2751                                     HW_CID(bp, cid));
2752
2753         if (common)
2754                 /* Common ramrods:
2755                  *      FUNC_START, FUNC_STOP, CFC_DEL, STATS, SET_MAC
2756                  *      TRAFFIC_STOP, TRAFFIC_START
2757                  */
2758                 type = (NONE_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2759                         & SPE_HDR_CONN_TYPE;
2760         else
2761                 /* ETH ramrods: SETUP, HALT */
2762                 type = (ETH_CONNECTION_TYPE << SPE_HDR_CONN_TYPE_SHIFT)
2763                         & SPE_HDR_CONN_TYPE;
2764
2765         type |= ((BP_FUNC(bp) << SPE_HDR_FUNCTION_ID_SHIFT) &
2766                  SPE_HDR_FUNCTION_ID);
2767
2768         spe->hdr.type = cpu_to_le16(type);
2769
2770         spe->data.update_data_addr.hi = cpu_to_le32(data_hi);
2771         spe->data.update_data_addr.lo = cpu_to_le32(data_lo);
2772
2773         /* stats ramrod has it's own slot on the spq */
2774         if (command != RAMROD_CMD_ID_COMMON_STAT_QUERY) {
2775                 /* It's ok if the actual decrement is issued towards the memory
2776                  * somewhere between the spin_lock and spin_unlock. Thus no
2777                  * more explict memory barrier is needed.
2778                  */
2779                 if (common)
2780                         atomic_dec(&bp->eq_spq_left);
2781                 else
2782                         atomic_dec(&bp->cq_spq_left);
2783         }
2784
2785
2786         DP(BNX2X_MSG_SP/*NETIF_MSG_TIMER*/,
2787            "SPQE[%x] (%x:%x)  command %d  hw_cid %x  data (%x:%x) "
2788            "type(0x%x) left (ETH, COMMON) (%x,%x)\n",
2789            bp->spq_prod_idx, (u32)U64_HI(bp->spq_mapping),
2790            (u32)(U64_LO(bp->spq_mapping) +
2791            (void *)bp->spq_prod_bd - (void *)bp->spq), command,
2792            HW_CID(bp, cid), data_hi, data_lo, type,
2793            atomic_read(&bp->cq_spq_left), atomic_read(&bp->eq_spq_left));
2794
2795         bnx2x_sp_prod_update(bp);
2796         spin_unlock_bh(&bp->spq_lock);
2797         return 0;
2798 }
2799
2800 /* acquire split MCP access lock register */
2801 static int bnx2x_acquire_alr(struct bnx2x *bp)
2802 {
2803         u32 j, val;
2804         int rc = 0;
2805
2806         might_sleep();
2807         for (j = 0; j < 1000; j++) {
2808                 val = (1UL << 31);
2809                 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
2810                 val = REG_RD(bp, GRCBASE_MCP + 0x9c);
2811                 if (val & (1L << 31))
2812                         break;
2813
2814                 msleep(5);
2815         }
2816         if (!(val & (1L << 31))) {
2817                 BNX2X_ERR("Cannot acquire MCP access lock register\n");
2818                 rc = -EBUSY;
2819         }
2820
2821         return rc;
2822 }
2823
2824 /* release split MCP access lock register */
2825 static void bnx2x_release_alr(struct bnx2x *bp)
2826 {
2827         REG_WR(bp, GRCBASE_MCP + 0x9c, 0);
2828 }
2829
2830 #define BNX2X_DEF_SB_ATT_IDX    0x0001
2831 #define BNX2X_DEF_SB_IDX        0x0002
2832
2833 static inline u16 bnx2x_update_dsb_idx(struct bnx2x *bp)
2834 {
2835         struct host_sp_status_block *def_sb = bp->def_status_blk;
2836         u16 rc = 0;
2837
2838         barrier(); /* status block is written to by the chip */
2839         if (bp->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
2840                 bp->def_att_idx = def_sb->atten_status_block.attn_bits_index;
2841                 rc |= BNX2X_DEF_SB_ATT_IDX;
2842         }
2843
2844         if (bp->def_idx != def_sb->sp_sb.running_index) {
2845                 bp->def_idx = def_sb->sp_sb.running_index;
2846                 rc |= BNX2X_DEF_SB_IDX;
2847         }
2848
2849         /* Do not reorder: indecies reading should complete before handling */
2850         barrier();
2851         return rc;
2852 }
2853
2854 /*
2855  * slow path service functions
2856  */
2857
2858 static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
2859 {
2860         int port = BP_PORT(bp);
2861         u32 aeu_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
2862                               MISC_REG_AEU_MASK_ATTN_FUNC_0;
2863         u32 nig_int_mask_addr = port ? NIG_REG_MASK_INTERRUPT_PORT1 :
2864                                        NIG_REG_MASK_INTERRUPT_PORT0;
2865         u32 aeu_mask;
2866         u32 nig_mask = 0;
2867         u32 reg_addr;
2868
2869         if (bp->attn_state & asserted)
2870                 BNX2X_ERR("IGU ERROR\n");
2871
2872         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2873         aeu_mask = REG_RD(bp, aeu_addr);
2874
2875         DP(NETIF_MSG_HW, "aeu_mask %x  newly asserted %x\n",
2876            aeu_mask, asserted);
2877         aeu_mask &= ~(asserted & 0x3ff);
2878         DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
2879
2880         REG_WR(bp, aeu_addr, aeu_mask);
2881         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2882
2883         DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
2884         bp->attn_state |= asserted;
2885         DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
2886
2887         if (asserted & ATTN_HARD_WIRED_MASK) {
2888                 if (asserted & ATTN_NIG_FOR_FUNC) {
2889
2890                         bnx2x_acquire_phy_lock(bp);
2891
2892                         /* save nig interrupt mask */
2893                         nig_mask = REG_RD(bp, nig_int_mask_addr);
2894                         REG_WR(bp, nig_int_mask_addr, 0);
2895
2896                         bnx2x_link_attn(bp);
2897
2898                         /* handle unicore attn? */
2899                 }
2900                 if (asserted & ATTN_SW_TIMER_4_FUNC)
2901                         DP(NETIF_MSG_HW, "ATTN_SW_TIMER_4_FUNC!\n");
2902
2903                 if (asserted & GPIO_2_FUNC)
2904                         DP(NETIF_MSG_HW, "GPIO_2_FUNC!\n");
2905
2906                 if (asserted & GPIO_3_FUNC)
2907                         DP(NETIF_MSG_HW, "GPIO_3_FUNC!\n");
2908
2909                 if (asserted & GPIO_4_FUNC)
2910                         DP(NETIF_MSG_HW, "GPIO_4_FUNC!\n");
2911
2912                 if (port == 0) {
2913                         if (asserted & ATTN_GENERAL_ATTN_1) {
2914                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_1!\n");
2915                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
2916                         }
2917                         if (asserted & ATTN_GENERAL_ATTN_2) {
2918                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_2!\n");
2919                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
2920                         }
2921                         if (asserted & ATTN_GENERAL_ATTN_3) {
2922                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_3!\n");
2923                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
2924                         }
2925                 } else {
2926                         if (asserted & ATTN_GENERAL_ATTN_4) {
2927                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_4!\n");
2928                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
2929                         }
2930                         if (asserted & ATTN_GENERAL_ATTN_5) {
2931                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_5!\n");
2932                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
2933                         }
2934                         if (asserted & ATTN_GENERAL_ATTN_6) {
2935                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_6!\n");
2936                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
2937                         }
2938                 }
2939
2940         } /* if hardwired */
2941
2942         if (bp->common.int_block == INT_BLOCK_HC)
2943                 reg_addr = (HC_REG_COMMAND_REG + port*32 +
2944                             COMMAND_REG_ATTN_BITS_SET);
2945         else
2946                 reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_SET_UPPER*8);
2947
2948         DP(NETIF_MSG_HW, "about to mask 0x%08x at %s addr 0x%x\n", asserted,
2949            (bp->common.int_block == INT_BLOCK_HC) ? "HC" : "IGU", reg_addr);
2950         REG_WR(bp, reg_addr, asserted);
2951
2952         /* now set back the mask */
2953         if (asserted & ATTN_NIG_FOR_FUNC) {
2954                 REG_WR(bp, nig_int_mask_addr, nig_mask);
2955                 bnx2x_release_phy_lock(bp);
2956         }
2957 }
2958
2959 static inline void bnx2x_fan_failure(struct bnx2x *bp)
2960 {
2961         int port = BP_PORT(bp);
2962         u32 ext_phy_config;
2963         /* mark the failure */
2964         ext_phy_config =
2965                 SHMEM_RD(bp,
2966                          dev_info.port_hw_config[port].external_phy_config);
2967
2968         ext_phy_config &= ~PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK;
2969         ext_phy_config |= PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE;
2970         SHMEM_WR(bp, dev_info.port_hw_config[port].external_phy_config,
2971                  ext_phy_config);
2972
2973         /* log the failure */
2974         netdev_err(bp->dev, "Fan Failure on Network Controller has caused"
2975                " the driver to shutdown the card to prevent permanent"
2976                " damage.  Please contact OEM Support for assistance\n");
2977 }
2978
2979 static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
2980 {
2981         int port = BP_PORT(bp);
2982         int reg_offset;
2983         u32 val;
2984
2985         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
2986                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
2987
2988         if (attn & AEU_INPUTS_ATTN_BITS_SPIO5) {
2989
2990                 val = REG_RD(bp, reg_offset);
2991                 val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
2992                 REG_WR(bp, reg_offset, val);
2993
2994                 BNX2X_ERR("SPIO5 hw attention\n");
2995
2996                 /* Fan failure attention */
2997                 bnx2x_hw_reset_phy(&bp->link_params);
2998                 bnx2x_fan_failure(bp);
2999         }
3000
3001         if (attn & (AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0 |
3002                     AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1)) {
3003                 bnx2x_acquire_phy_lock(bp);
3004                 bnx2x_handle_module_detect_int(&bp->link_params);
3005                 bnx2x_release_phy_lock(bp);
3006         }
3007
3008         if (attn & HW_INTERRUT_ASSERT_SET_0) {
3009
3010                 val = REG_RD(bp, reg_offset);
3011                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_0);
3012                 REG_WR(bp, reg_offset, val);
3013
3014                 BNX2X_ERR("FATAL HW block attention set0 0x%x\n",
3015                           (u32)(attn & HW_INTERRUT_ASSERT_SET_0));
3016                 bnx2x_panic();
3017         }
3018 }
3019
3020 static inline void bnx2x_attn_int_deasserted1(struct bnx2x *bp, u32 attn)
3021 {
3022         u32 val;
3023
3024         if (attn & AEU_INPUTS_ATTN_BITS_DOORBELLQ_HW_INTERRUPT) {
3025
3026                 val = REG_RD(bp, DORQ_REG_DORQ_INT_STS_CLR);
3027                 BNX2X_ERR("DB hw attention 0x%x\n", val);
3028                 /* DORQ discard attention */
3029                 if (val & 0x2)
3030                         BNX2X_ERR("FATAL error from DORQ\n");
3031         }
3032
3033         if (attn & HW_INTERRUT_ASSERT_SET_1) {
3034
3035                 int port = BP_PORT(bp);
3036                 int reg_offset;
3037
3038                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_1 :
3039                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_1);
3040
3041                 val = REG_RD(bp, reg_offset);
3042                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
3043                 REG_WR(bp, reg_offset, val);
3044
3045                 BNX2X_ERR("FATAL HW block attention set1 0x%x\n",
3046                           (u32)(attn & HW_INTERRUT_ASSERT_SET_1));
3047                 bnx2x_panic();
3048         }
3049 }
3050
3051 static inline void bnx2x_attn_int_deasserted2(struct bnx2x *bp, u32 attn)
3052 {
3053         u32 val;
3054
3055         if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
3056
3057                 val = REG_RD(bp, CFC_REG_CFC_INT_STS_CLR);
3058                 BNX2X_ERR("CFC hw attention 0x%x\n", val);
3059                 /* CFC error attention */
3060                 if (val & 0x2)
3061                         BNX2X_ERR("FATAL error from CFC\n");
3062         }
3063
3064         if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
3065
3066                 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_0);
3067                 BNX2X_ERR("PXP hw attention 0x%x\n", val);
3068                 /* RQ_USDMDP_FIFO_OVERFLOW */
3069                 if (val & 0x18000)
3070                         BNX2X_ERR("FATAL error from PXP\n");
3071                 if (CHIP_IS_E2(bp)) {
3072                         val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_1);
3073                         BNX2X_ERR("PXP hw attention-1 0x%x\n", val);
3074                 }
3075         }
3076
3077         if (attn & HW_INTERRUT_ASSERT_SET_2) {
3078
3079                 int port = BP_PORT(bp);
3080                 int reg_offset;
3081
3082                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_2 :
3083                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_2);
3084
3085                 val = REG_RD(bp, reg_offset);
3086                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
3087                 REG_WR(bp, reg_offset, val);
3088
3089                 BNX2X_ERR("FATAL HW block attention set2 0x%x\n",
3090                           (u32)(attn & HW_INTERRUT_ASSERT_SET_2));
3091                 bnx2x_panic();
3092         }
3093 }
3094
3095 static inline void bnx2x_attn_int_deasserted3(struct bnx2x *bp, u32 attn)
3096 {
3097         u32 val;
3098
3099         if (attn & EVEREST_GEN_ATTN_IN_USE_MASK) {
3100
3101                 if (attn & BNX2X_PMF_LINK_ASSERT) {
3102                         int func = BP_FUNC(bp);
3103
3104                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
3105                         bp->mf_config[BP_VN(bp)] = MF_CFG_RD(bp,
3106                                         func_mf_config[BP_ABS_FUNC(bp)].config);
3107                         val = SHMEM_RD(bp,
3108                                        func_mb[BP_FW_MB_IDX(bp)].drv_status);
3109                         if (val & DRV_STATUS_DCC_EVENT_MASK)
3110                                 bnx2x_dcc_event(bp,
3111                                             (val & DRV_STATUS_DCC_EVENT_MASK));
3112
3113                         if (val & DRV_STATUS_SET_MF_BW)
3114                                 bnx2x_set_mf_bw(bp);
3115
3116                         if ((bp->port.pmf == 0) && (val & DRV_STATUS_PMF))
3117                                 bnx2x_pmf_update(bp);
3118
3119                         /* Always call it here: bnx2x_link_report() will
3120                          * prevent the link indication duplication.
3121                          */
3122                         bnx2x__link_status_update(bp);
3123
3124                         if (bp->port.pmf &&
3125                             (val & DRV_STATUS_DCBX_NEGOTIATION_RESULTS) &&
3126                                 bp->dcbx_enabled > 0)
3127                                 /* start dcbx state machine */
3128                                 bnx2x_dcbx_set_params(bp,
3129                                         BNX2X_DCBX_STATE_NEG_RECEIVED);
3130                 } else if (attn & BNX2X_MC_ASSERT_BITS) {
3131
3132                         BNX2X_ERR("MC assert!\n");
3133                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_10, 0);
3134                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_9, 0);
3135                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_8, 0);
3136                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_7, 0);
3137                         bnx2x_panic();
3138
3139                 } else if (attn & BNX2X_MCP_ASSERT) {
3140
3141                         BNX2X_ERR("MCP assert!\n");
3142                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_11, 0);
3143                         bnx2x_fw_dump(bp);
3144
3145                 } else
3146                         BNX2X_ERR("Unknown HW assert! (attn 0x%x)\n", attn);
3147         }
3148
3149         if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
3150                 BNX2X_ERR("LATCHED attention 0x%08x (masked)\n", attn);
3151                 if (attn & BNX2X_GRC_TIMEOUT) {
3152                         val = CHIP_IS_E1(bp) ? 0 :
3153                                         REG_RD(bp, MISC_REG_GRC_TIMEOUT_ATTN);
3154                         BNX2X_ERR("GRC time-out 0x%08x\n", val);
3155                 }
3156                 if (attn & BNX2X_GRC_RSV) {
3157                         val = CHIP_IS_E1(bp) ? 0 :
3158                                         REG_RD(bp, MISC_REG_GRC_RSV_ATTN);
3159                         BNX2X_ERR("GRC reserved 0x%08x\n", val);
3160                 }
3161                 REG_WR(bp, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
3162         }
3163 }
3164
3165 #define BNX2X_MISC_GEN_REG      MISC_REG_GENERIC_POR_1
3166 #define LOAD_COUNTER_BITS       16 /* Number of bits for load counter */
3167 #define LOAD_COUNTER_MASK       (((u32)0x1 << LOAD_COUNTER_BITS) - 1)
3168 #define RESET_DONE_FLAG_MASK    (~LOAD_COUNTER_MASK)
3169 #define RESET_DONE_FLAG_SHIFT   LOAD_COUNTER_BITS
3170
3171 /*
3172  * should be run under rtnl lock
3173  */
3174 static inline void bnx2x_set_reset_done(struct bnx2x *bp)
3175 {
3176         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3177         val &= ~(1 << RESET_DONE_FLAG_SHIFT);
3178         REG_WR(bp, BNX2X_MISC_GEN_REG, val);
3179         barrier();
3180         mmiowb();
3181 }
3182
3183 /*
3184  * should be run under rtnl lock
3185  */
3186 static inline void bnx2x_set_reset_in_progress(struct bnx2x *bp)
3187 {
3188         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3189         val |= (1 << 16);
3190         REG_WR(bp, BNX2X_MISC_GEN_REG, val);
3191         barrier();
3192         mmiowb();
3193 }
3194
3195 /*
3196  * should be run under rtnl lock
3197  */
3198 bool bnx2x_reset_is_done(struct bnx2x *bp)
3199 {
3200         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3201         DP(NETIF_MSG_HW, "GEN_REG_VAL=0x%08x\n", val);
3202         return (val & RESET_DONE_FLAG_MASK) ? false : true;
3203 }
3204
3205 /*
3206  * should be run under rtnl lock
3207  */
3208 inline void bnx2x_inc_load_cnt(struct bnx2x *bp)
3209 {
3210         u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3211
3212         DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
3213
3214         val1 = ((val & LOAD_COUNTER_MASK) + 1) & LOAD_COUNTER_MASK;
3215         REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
3216         barrier();
3217         mmiowb();
3218 }
3219
3220 /*
3221  * should be run under rtnl lock
3222  */
3223 u32 bnx2x_dec_load_cnt(struct bnx2x *bp)
3224 {
3225         u32 val1, val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3226
3227         DP(NETIF_MSG_HW, "Old GEN_REG_VAL=0x%08x\n", val);
3228
3229         val1 = ((val & LOAD_COUNTER_MASK) - 1) & LOAD_COUNTER_MASK;
3230         REG_WR(bp, BNX2X_MISC_GEN_REG, (val & RESET_DONE_FLAG_MASK) | val1);
3231         barrier();
3232         mmiowb();
3233
3234         return val1;
3235 }
3236
3237 /*
3238  * should be run under rtnl lock
3239  */
3240 static inline u32 bnx2x_get_load_cnt(struct bnx2x *bp)
3241 {
3242         return REG_RD(bp, BNX2X_MISC_GEN_REG) & LOAD_COUNTER_MASK;
3243 }
3244
3245 static inline void bnx2x_clear_load_cnt(struct bnx2x *bp)
3246 {
3247         u32 val = REG_RD(bp, BNX2X_MISC_GEN_REG);
3248         REG_WR(bp, BNX2X_MISC_GEN_REG, val & (~LOAD_COUNTER_MASK));
3249 }
3250
3251 static inline void _print_next_block(int idx, const char *blk)
3252 {
3253         if (idx)
3254                 pr_cont(", ");
3255         pr_cont("%s", blk);
3256 }
3257
3258 static inline int bnx2x_print_blocks_with_parity0(u32 sig, int par_num)
3259 {
3260         int i = 0;
3261         u32 cur_bit = 0;
3262         for (i = 0; sig; i++) {
3263                 cur_bit = ((u32)0x1 << i);
3264                 if (sig & cur_bit) {
3265                         switch (cur_bit) {
3266                         case AEU_INPUTS_ATTN_BITS_BRB_PARITY_ERROR:
3267                                 _print_next_block(par_num++, "BRB");
3268                                 break;
3269                         case AEU_INPUTS_ATTN_BITS_PARSER_PARITY_ERROR:
3270                                 _print_next_block(par_num++, "PARSER");
3271                                 break;
3272                         case AEU_INPUTS_ATTN_BITS_TSDM_PARITY_ERROR:
3273                                 _print_next_block(par_num++, "TSDM");
3274                                 break;
3275                         case AEU_INPUTS_ATTN_BITS_SEARCHER_PARITY_ERROR:
3276                                 _print_next_block(par_num++, "SEARCHER");
3277                                 break;
3278                         case AEU_INPUTS_ATTN_BITS_TSEMI_PARITY_ERROR:
3279                                 _print_next_block(par_num++, "TSEMI");
3280                                 break;
3281                         }
3282
3283                         /* Clear the bit */
3284                         sig &= ~cur_bit;
3285                 }
3286         }
3287
3288         return par_num;
3289 }
3290
3291 static inline int bnx2x_print_blocks_with_parity1(u32 sig, int par_num)
3292 {
3293         int i = 0;
3294         u32 cur_bit = 0;
3295         for (i = 0; sig; i++) {
3296                 cur_bit = ((u32)0x1 << i);
3297                 if (sig & cur_bit) {
3298                         switch (cur_bit) {
3299                         case AEU_INPUTS_ATTN_BITS_PBCLIENT_PARITY_ERROR:
3300                                 _print_next_block(par_num++, "PBCLIENT");
3301                                 break;
3302                         case AEU_INPUTS_ATTN_BITS_QM_PARITY_ERROR:
3303                                 _print_next_block(par_num++, "QM");
3304                                 break;
3305                         case AEU_INPUTS_ATTN_BITS_XSDM_PARITY_ERROR:
3306                                 _print_next_block(par_num++, "XSDM");
3307                                 break;
3308                         case AEU_INPUTS_ATTN_BITS_XSEMI_PARITY_ERROR:
3309                                 _print_next_block(par_num++, "XSEMI");
3310                                 break;
3311                         case AEU_INPUTS_ATTN_BITS_DOORBELLQ_PARITY_ERROR:
3312                                 _print_next_block(par_num++, "DOORBELLQ");
3313                                 break;
3314                         case AEU_INPUTS_ATTN_BITS_VAUX_PCI_CORE_PARITY_ERROR:
3315                                 _print_next_block(par_num++, "VAUX PCI CORE");
3316                                 break;
3317                         case AEU_INPUTS_ATTN_BITS_DEBUG_PARITY_ERROR:
3318                                 _print_next_block(par_num++, "DEBUG");
3319                                 break;
3320                         case AEU_INPUTS_ATTN_BITS_USDM_PARITY_ERROR:
3321                                 _print_next_block(par_num++, "USDM");
3322                                 break;
3323                         case AEU_INPUTS_ATTN_BITS_USEMI_PARITY_ERROR:
3324                                 _print_next_block(par_num++, "USEMI");
3325                                 break;
3326                         case AEU_INPUTS_ATTN_BITS_UPB_PARITY_ERROR:
3327                                 _print_next_block(par_num++, "UPB");
3328                                 break;
3329                         case AEU_INPUTS_ATTN_BITS_CSDM_PARITY_ERROR:
3330                                 _print_next_block(par_num++, "CSDM");
3331                                 break;
3332                         }
3333
3334                         /* Clear the bit */
3335                         sig &= ~cur_bit;
3336                 }
3337         }
3338
3339         return par_num;
3340 }
3341
3342 static inline int bnx2x_print_blocks_with_parity2(u32 sig, int par_num)
3343 {
3344         int i = 0;
3345         u32 cur_bit = 0;
3346         for (i = 0; sig; i++) {
3347                 cur_bit = ((u32)0x1 << i);
3348                 if (sig & cur_bit) {
3349                         switch (cur_bit) {
3350                         case AEU_INPUTS_ATTN_BITS_CSEMI_PARITY_ERROR:
3351                                 _print_next_block(par_num++, "CSEMI");
3352                                 break;
3353                         case AEU_INPUTS_ATTN_BITS_PXP_PARITY_ERROR:
3354                                 _print_next_block(par_num++, "PXP");
3355                                 break;
3356                         case AEU_IN_ATTN_BITS_PXPPCICLOCKCLIENT_PARITY_ERROR:
3357                                 _print_next_block(par_num++,
3358                                         "PXPPCICLOCKCLIENT");
3359                                 break;
3360                         case AEU_INPUTS_ATTN_BITS_CFC_PARITY_ERROR:
3361                                 _print_next_block(par_num++, "CFC");
3362                                 break;
3363                         case AEU_INPUTS_ATTN_BITS_CDU_PARITY_ERROR:
3364                                 _print_next_block(par_num++, "CDU");
3365                                 break;
3366                         case AEU_INPUTS_ATTN_BITS_IGU_PARITY_ERROR:
3367                                 _print_next_block(par_num++, "IGU");
3368                                 break;
3369                         case AEU_INPUTS_ATTN_BITS_MISC_PARITY_ERROR:
3370                                 _print_next_block(par_num++, "MISC");
3371                                 break;
3372                         }
3373
3374                         /* Clear the bit */
3375                         sig &= ~cur_bit;
3376                 }
3377         }
3378
3379         return par_num;
3380 }
3381
3382 static inline int bnx2x_print_blocks_with_parity3(u32 sig, int par_num)
3383 {
3384         int i = 0;
3385         u32 cur_bit = 0;
3386         for (i = 0; sig; i++) {
3387                 cur_bit = ((u32)0x1 << i);
3388                 if (sig & cur_bit) {
3389                         switch (cur_bit) {
3390                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_ROM_PARITY:
3391                                 _print_next_block(par_num++, "MCP ROM");
3392                                 break;
3393                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_RX_PARITY:
3394                                 _print_next_block(par_num++, "MCP UMP RX");
3395                                 break;
3396                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_TX_PARITY:
3397                                 _print_next_block(par_num++, "MCP UMP TX");
3398                                 break;
3399                         case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_SCPAD_PARITY:
3400                                 _print_next_block(par_num++, "MCP SCPAD");
3401                                 break;
3402                         }
3403
3404                         /* Clear the bit */
3405                         sig &= ~cur_bit;
3406                 }
3407         }
3408
3409         return par_num;
3410 }
3411
3412 static inline bool bnx2x_parity_attn(struct bnx2x *bp, u32 sig0, u32 sig1,
3413                                      u32 sig2, u32 sig3)
3414 {
3415         if ((sig0 & HW_PRTY_ASSERT_SET_0) || (sig1 & HW_PRTY_ASSERT_SET_1) ||
3416             (sig2 & HW_PRTY_ASSERT_SET_2) || (sig3 & HW_PRTY_ASSERT_SET_3)) {
3417                 int par_num = 0;
3418                 DP(NETIF_MSG_HW, "Was parity error: HW block parity attention: "
3419                         "[0]:0x%08x [1]:0x%08x "
3420                         "[2]:0x%08x [3]:0x%08x\n",
3421                           sig0 & HW_PRTY_ASSERT_SET_0,
3422                           sig1 & HW_PRTY_ASSERT_SET_1,
3423                           sig2 & HW_PRTY_ASSERT_SET_2,
3424                           sig3 & HW_PRTY_ASSERT_SET_3);
3425                 printk(KERN_ERR"%s: Parity errors detected in blocks: ",
3426                        bp->dev->name);
3427                 par_num = bnx2x_print_blocks_with_parity0(
3428                         sig0 & HW_PRTY_ASSERT_SET_0, par_num);
3429                 par_num = bnx2x_print_blocks_with_parity1(
3430                         sig1 & HW_PRTY_ASSERT_SET_1, par_num);
3431                 par_num = bnx2x_print_blocks_with_parity2(
3432                         sig2 & HW_PRTY_ASSERT_SET_2, par_num);
3433                 par_num = bnx2x_print_blocks_with_parity3(
3434                         sig3 & HW_PRTY_ASSERT_SET_3, par_num);
3435                 printk("\n");
3436                 return true;
3437         } else
3438                 return false;
3439 }
3440
3441 bool bnx2x_chk_parity_attn(struct bnx2x *bp)
3442 {
3443         struct attn_route attn;
3444         int port = BP_PORT(bp);
3445
3446         attn.sig[0] = REG_RD(bp,
3447                 MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 +
3448                              port*4);
3449         attn.sig[1] = REG_RD(bp,
3450                 MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 +
3451                              port*4);
3452         attn.sig[2] = REG_RD(bp,
3453                 MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 +
3454                              port*4);
3455         attn.sig[3] = REG_RD(bp,
3456                 MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 +
3457                              port*4);
3458
3459         return bnx2x_parity_attn(bp, attn.sig[0], attn.sig[1], attn.sig[2],
3460                                         attn.sig[3]);
3461 }
3462
3463
3464 static inline void bnx2x_attn_int_deasserted4(struct bnx2x *bp, u32 attn)
3465 {
3466         u32 val;
3467         if (attn & AEU_INPUTS_ATTN_BITS_PGLUE_HW_INTERRUPT) {
3468
3469                 val = REG_RD(bp, PGLUE_B_REG_PGLUE_B_INT_STS_CLR);
3470                 BNX2X_ERR("PGLUE hw attention 0x%x\n", val);
3471                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_ADDRESS_ERROR)
3472                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3473                                   "ADDRESS_ERROR\n");
3474                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_INCORRECT_RCV_BEHAVIOR)
3475                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3476                                   "INCORRECT_RCV_BEHAVIOR\n");
3477                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN)
3478                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3479                                   "WAS_ERROR_ATTN\n");
3480                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_VF_LENGTH_VIOLATION_ATTN)
3481                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3482                                   "VF_LENGTH_VIOLATION_ATTN\n");
3483                 if (val &
3484                     PGLUE_B_PGLUE_B_INT_STS_REG_VF_GRC_SPACE_VIOLATION_ATTN)
3485                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3486                                   "VF_GRC_SPACE_VIOLATION_ATTN\n");
3487                 if (val &
3488                     PGLUE_B_PGLUE_B_INT_STS_REG_VF_MSIX_BAR_VIOLATION_ATTN)
3489                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3490                                   "VF_MSIX_BAR_VIOLATION_ATTN\n");
3491                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_ERROR_ATTN)
3492                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3493                                   "TCPL_ERROR_ATTN\n");
3494                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_IN_TWO_RCBS_ATTN)
3495                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3496                                   "TCPL_IN_TWO_RCBS_ATTN\n");
3497                 if (val & PGLUE_B_PGLUE_B_INT_STS_REG_CSSNOOP_FIFO_OVERFLOW)
3498                         BNX2X_ERR("PGLUE_B_PGLUE_B_INT_STS_REG_"
3499                                   "CSSNOOP_FIFO_OVERFLOW\n");
3500         }
3501         if (attn & AEU_INPUTS_ATTN_BITS_ATC_HW_INTERRUPT) {
3502                 val = REG_RD(bp, ATC_REG_ATC_INT_STS_CLR);
3503                 BNX2X_ERR("ATC hw attention 0x%x\n", val);
3504                 if (val & ATC_ATC_INT_STS_REG_ADDRESS_ERROR)
3505                         BNX2X_ERR("ATC_ATC_INT_STS_REG_ADDRESS_ERROR\n");
3506                 if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_TO_NOT_PEND)
3507                         BNX2X_ERR("ATC_ATC_INT_STS_REG"
3508                                   "_ATC_TCPL_TO_NOT_PEND\n");
3509                 if (val & ATC_ATC_INT_STS_REG_ATC_GPA_MULTIPLE_HITS)
3510                         BNX2X_ERR("ATC_ATC_INT_STS_REG_"
3511                                   "ATC_GPA_MULTIPLE_HITS\n");
3512                 if (val & ATC_ATC_INT_STS_REG_ATC_RCPL_TO_EMPTY_CNT)
3513                         BNX2X_ERR("ATC_ATC_INT_STS_REG_"
3514                                   "ATC_RCPL_TO_EMPTY_CNT\n");
3515                 if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR)
3516                         BNX2X_ERR("ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR\n");
3517                 if (val & ATC_ATC_INT_STS_REG_ATC_IREQ_LESS_THAN_STU)
3518                         BNX2X_ERR("ATC_ATC_INT_STS_REG_"
3519                                   "ATC_IREQ_LESS_THAN_STU\n");
3520         }
3521
3522         if (attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
3523                     AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)) {
3524                 BNX2X_ERR("FATAL parity attention set4 0x%x\n",
3525                 (u32)(attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
3526                     AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)));
3527         }
3528
3529 }
3530
3531 static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
3532 {
3533         struct attn_route attn, *group_mask;
3534         int port = BP_PORT(bp);
3535         int index;
3536         u32 reg_addr;
3537         u32 val;
3538         u32 aeu_mask;
3539
3540         /* need to take HW lock because MCP or other port might also
3541            try to handle this event */
3542         bnx2x_acquire_alr(bp);
3543
3544         if (CHIP_PARITY_ENABLED(bp) && bnx2x_chk_parity_attn(bp)) {
3545                 bp->recovery_state = BNX2X_RECOVERY_INIT;
3546                 bnx2x_set_reset_in_progress(bp);
3547                 schedule_delayed_work(&bp->reset_task, 0);
3548                 /* Disable HW interrupts */
3549                 bnx2x_int_disable(bp);
3550                 bnx2x_release_alr(bp);
3551                 /* In case of parity errors don't handle attentions so that
3552                  * other function would "see" parity errors.
3553                  */
3554                 return;
3555         }
3556
3557         attn.sig[0] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + port*4);
3558         attn.sig[1] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
3559         attn.sig[2] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
3560         attn.sig[3] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
3561         if (CHIP_IS_E2(bp))
3562                 attn.sig[4] =
3563                       REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_5_FUNC_0 + port*4);
3564         else
3565                 attn.sig[4] = 0;
3566
3567         DP(NETIF_MSG_HW, "attn: %08x %08x %08x %08x %08x\n",
3568            attn.sig[0], attn.sig[1], attn.sig[2], attn.sig[3], attn.sig[4]);
3569
3570         for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
3571                 if (deasserted & (1 << index)) {
3572                         group_mask = &bp->attn_group[index];
3573
3574                         DP(NETIF_MSG_HW, "group[%d]: %08x %08x "
3575                                          "%08x %08x %08x\n",
3576                            index,
3577                            group_mask->sig[0], group_mask->sig[1],
3578                            group_mask->sig[2], group_mask->sig[3],
3579                            group_mask->sig[4]);
3580
3581                         bnx2x_attn_int_deasserted4(bp,
3582                                         attn.sig[4] & group_mask->sig[4]);
3583                         bnx2x_attn_int_deasserted3(bp,
3584                                         attn.sig[3] & group_mask->sig[3]);
3585                         bnx2x_attn_int_deasserted1(bp,
3586                                         attn.sig[1] & group_mask->sig[1]);
3587                         bnx2x_attn_int_deasserted2(bp,
3588                                         attn.sig[2] & group_mask->sig[2]);
3589                         bnx2x_attn_int_deasserted0(bp,
3590                                         attn.sig[0] & group_mask->sig[0]);
3591                 }
3592         }
3593
3594         bnx2x_release_alr(bp);
3595
3596         if (bp->common.int_block == INT_BLOCK_HC)
3597                 reg_addr = (HC_REG_COMMAND_REG + port*32 +
3598                             COMMAND_REG_ATTN_BITS_CLR);
3599         else
3600                 reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_CLR_UPPER*8);
3601
3602         val = ~deasserted;
3603         DP(NETIF_MSG_HW, "about to mask 0x%08x at %s addr 0x%x\n", val,
3604            (bp->common.int_block == INT_BLOCK_HC) ? "HC" : "IGU", reg_addr);
3605         REG_WR(bp, reg_addr, val);
3606
3607         if (~bp->attn_state & deasserted)
3608                 BNX2X_ERR("IGU ERROR\n");
3609
3610         reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
3611                           MISC_REG_AEU_MASK_ATTN_FUNC_0;
3612
3613         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
3614         aeu_mask = REG_RD(bp, reg_addr);
3615
3616         DP(NETIF_MSG_HW, "aeu_mask %x  newly deasserted %x\n",
3617            aeu_mask, deasserted);
3618         aeu_mask |= (deasserted & 0x3ff);
3619         DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
3620
3621         REG_WR(bp, reg_addr, aeu_mask);
3622         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
3623
3624         DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
3625         bp->attn_state &= ~deasserted;
3626         DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
3627 }
3628
3629 static void bnx2x_attn_int(struct bnx2x *bp)
3630 {
3631         /* read local copy of bits */
3632         u32 attn_bits = le32_to_cpu(bp->def_status_blk->atten_status_block.
3633                                                                 attn_bits);
3634         u32 attn_ack = le32_to_cpu(bp->def_status_blk->atten_status_block.
3635                                                                 attn_bits_ack);
3636         u32 attn_state = bp->attn_state;
3637
3638         /* look for changed bits */
3639         u32 asserted   =  attn_bits & ~attn_ack & ~attn_state;
3640         u32 deasserted = ~attn_bits &  attn_ack &  attn_state;
3641
3642         DP(NETIF_MSG_HW,
3643            "attn_bits %x  attn_ack %x  asserted %x  deasserted %x\n",
3644            attn_bits, attn_ack, asserted, deasserted);
3645
3646         if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state))
3647                 BNX2X_ERR("BAD attention state\n");
3648
3649         /* handle bits that were raised */
3650         if (asserted)
3651                 bnx2x_attn_int_asserted(bp, asserted);
3652
3653         if (deasserted)
3654                 bnx2x_attn_int_deasserted(bp, deasserted);
3655 }
3656
3657 static inline void bnx2x_update_eq_prod(struct bnx2x *bp, u16 prod)
3658 {
3659         /* No memory barriers */
3660         storm_memset_eq_prod(bp, prod, BP_FUNC(bp));
3661         mmiowb(); /* keep prod updates ordered */
3662 }
3663
3664 #ifdef BCM_CNIC
3665 static int  bnx2x_cnic_handle_cfc_del(struct bnx2x *bp, u32 cid,
3666                                       union event_ring_elem *elem)
3667 {
3668         if (!bp->cnic_eth_dev.starting_cid  ||
3669             (cid < bp->cnic_eth_dev.starting_cid &&
3670             cid != bp->cnic_eth_dev.iscsi_l2_cid))
3671                 return 1;
3672
3673         DP(BNX2X_MSG_SP, "got delete ramrod for CNIC CID %d\n", cid);
3674
3675         if (unlikely(elem->message.data.cfc_del_event.error)) {
3676                 BNX2X_ERR("got delete ramrod for CNIC CID %d with error!\n",
3677                           cid);
3678                 bnx2x_panic_dump(bp);
3679         }
3680         bnx2x_cnic_cfc_comp(bp, cid);
3681         return 0;
3682 }
3683 #endif
3684
3685 static void bnx2x_eq_int(struct bnx2x *bp)
3686 {
3687         u16 hw_cons, sw_cons, sw_prod;
3688         union event_ring_elem *elem;
3689         u32 cid;
3690         u8 opcode;
3691         int spqe_cnt = 0;
3692
3693         hw_cons = le16_to_cpu(*bp->eq_cons_sb);
3694
3695         /* The hw_cos range is 1-255, 257 - the sw_cons range is 0-254, 256.
3696          * when we get the the next-page we nned to adjust so the loop
3697          * condition below will be met. The next element is the size of a
3698          * regular element and hence incrementing by 1
3699          */
3700         if ((hw_cons & EQ_DESC_MAX_PAGE) == EQ_DESC_MAX_PAGE)
3701                 hw_cons++;
3702
3703         /* This function may never run in parallel with itself for a
3704          * specific bp, thus there is no need in "paired" read memory
3705          * barrier here.
3706          */
3707         sw_cons = bp->eq_cons;
3708         sw_prod = bp->eq_prod;
3709
3710         DP(BNX2X_MSG_SP, "EQ:  hw_cons %u  sw_cons %u bp->cq_spq_left %u\n",
3711                         hw_cons, sw_cons, atomic_read(&bp->eq_spq_left));
3712
3713         for (; sw_cons != hw_cons;
3714               sw_prod = NEXT_EQ_IDX(sw_prod), sw_cons = NEXT_EQ_IDX(sw_cons)) {
3715
3716
3717                 elem = &bp->eq_ring[EQ_DESC(sw_cons)];
3718
3719                 cid = SW_CID(elem->message.data.cfc_del_event.cid);
3720                 opcode = elem->message.opcode;
3721
3722
3723                 /* handle eq element */
3724                 switch (opcode) {
3725                 case EVENT_RING_OPCODE_STAT_QUERY:
3726                         DP(NETIF_MSG_TIMER, "got statistics comp event\n");
3727                         /* nothing to do with stats comp */
3728                         continue;
3729
3730                 case EVENT_RING_OPCODE_CFC_DEL:
3731                         /* handle according to cid range */
3732                         /*
3733                          * we may want to verify here that the bp state is
3734                          * HALTING
3735                          */
3736                         DP(NETIF_MSG_IFDOWN,
3737                            "got delete ramrod for MULTI[%d]\n", cid);
3738 #ifdef BCM_CNIC
3739                         if (!bnx2x_cnic_handle_cfc_del(bp, cid, elem))
3740                                 goto next_spqe;
3741                         if (cid == BNX2X_FCOE_ETH_CID)
3742                                 bnx2x_fcoe(bp, state) = BNX2X_FP_STATE_CLOSED;
3743                         else
3744 #endif
3745                                 bnx2x_fp(bp, cid, state) =
3746                                                 BNX2X_FP_STATE_CLOSED;
3747
3748                         goto next_spqe;
3749
3750                 case EVENT_RING_OPCODE_STOP_TRAFFIC:
3751                         DP(NETIF_MSG_IFUP, "got STOP TRAFFIC\n");
3752                         bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_TX_PAUSED);
3753                         goto next_spqe;
3754                 case EVENT_RING_OPCODE_START_TRAFFIC:
3755                         DP(NETIF_MSG_IFUP, "got START TRAFFIC\n");
3756                         bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_TX_RELEASED);
3757                         goto next_spqe;
3758                 }
3759
3760                 switch (opcode | bp->state) {
3761                 case (EVENT_RING_OPCODE_FUNCTION_START |
3762                       BNX2X_STATE_OPENING_WAIT4_PORT):
3763                         DP(NETIF_MSG_IFUP, "got setup ramrod\n");
3764                         bp->state = BNX2X_STATE_FUNC_STARTED;
3765                         break;
3766
3767                 case (EVENT_RING_OPCODE_FUNCTION_STOP |
3768                       BNX2X_STATE_CLOSING_WAIT4_HALT):
3769                         DP(NETIF_MSG_IFDOWN, "got halt ramrod\n");
3770                         bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
3771                         break;
3772
3773                 case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_OPEN):
3774                 case (EVENT_RING_OPCODE_SET_MAC | BNX2X_STATE_DIAG):
3775                         DP(NETIF_MSG_IFUP, "got set mac ramrod\n");
3776                         if (elem->message.data.set_mac_event.echo)
3777                                 bp->set_mac_pending = 0;
3778                         break;
3779
3780                 case (EVENT_RING_OPCODE_SET_MAC |
3781                       BNX2X_STATE_CLOSING_WAIT4_HALT):
3782                         DP(NETIF_MSG_IFDOWN, "got (un)set mac ramrod\n");
3783                         if (elem->message.data.set_mac_event.echo)
3784                                 bp->set_mac_pending = 0;
3785                         break;
3786                 default:
3787                         /* unknown event log error and continue */
3788                         BNX2X_ERR("Unknown EQ event %d\n",
3789                                   elem->message.opcode);
3790                 }
3791 next_spqe:
3792                 spqe_cnt++;
3793         } /* for */
3794
3795         smp_mb__before_atomic_inc();
3796         atomic_add(spqe_cnt, &bp->eq_spq_left);
3797
3798         bp->eq_cons = sw_cons;
3799         bp->eq_prod = sw_prod;
3800         /* Make sure that above mem writes were issued towards the memory */
3801         smp_wmb();
3802
3803         /* update producer */
3804         bnx2x_update_eq_prod(bp, bp->eq_prod);
3805 }
3806
3807 static void bnx2x_sp_task(struct work_struct *work)
3808 {
3809         struct bnx2x *bp = container_of(work, struct bnx2x, sp_task.work);
3810         u16 status;
3811
3812         /* Return here if interrupt is disabled */
3813         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3814                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3815                 return;
3816         }
3817
3818         status = bnx2x_update_dsb_idx(bp);
3819 /*      if (status == 0)                                     */
3820 /*              BNX2X_ERR("spurious slowpath interrupt!\n"); */
3821
3822         DP(NETIF_MSG_INTR, "got a slowpath interrupt (status 0x%x)\n", status);
3823
3824         /* HW attentions */
3825         if (status & BNX2X_DEF_SB_ATT_IDX) {
3826                 bnx2x_attn_int(bp);
3827                 status &= ~BNX2X_DEF_SB_ATT_IDX;
3828         }
3829
3830         /* SP events: STAT_QUERY and others */
3831         if (status & BNX2X_DEF_SB_IDX) {
3832 #ifdef BCM_CNIC
3833                 struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);
3834
3835                 if ((!NO_FCOE(bp)) &&
3836                         (bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp)))
3837                         napi_schedule(&bnx2x_fcoe(bp, napi));
3838 #endif
3839                 /* Handle EQ completions */
3840                 bnx2x_eq_int(bp);
3841
3842                 bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID,
3843                         le16_to_cpu(bp->def_idx), IGU_INT_NOP, 1);
3844
3845                 status &= ~BNX2X_DEF_SB_IDX;
3846         }
3847
3848         if (unlikely(status))
3849                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status 0x%x)\n",
3850                    status);
3851
3852         bnx2x_ack_sb(bp, bp->igu_dsb_id, ATTENTION_ID,
3853              le16_to_cpu(bp->def_att_idx), IGU_INT_ENABLE, 1);
3854 }
3855
3856 irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
3857 {
3858         struct net_device *dev = dev_instance;
3859         struct bnx2x *bp = netdev_priv(dev);
3860
3861         /* Return here if interrupt is disabled */
3862         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
3863                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
3864                 return IRQ_HANDLED;
3865         }
3866
3867         bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID, 0,
3868                      IGU_INT_DISABLE, 0);
3869
3870 #ifdef BNX2X_STOP_ON_ERROR
3871         if (unlikely(bp->panic))
3872                 return IRQ_HANDLED;
3873 #endif
3874
3875 #ifdef BCM_CNIC
3876         {
3877                 struct cnic_ops *c_ops;
3878
3879                 rcu_read_lock();
3880                 c_ops = rcu_dereference(bp->cnic_ops);
3881                 if (c_ops)
3882                         c_ops->cnic_handler(bp->cnic_data, NULL);
3883                 rcu_read_unlock();
3884         }
3885 #endif
3886         queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
3887
3888         return IRQ_HANDLED;
3889 }
3890
3891 /* end of slow path */
3892
3893 static void bnx2x_timer(unsigned long data)
3894 {
3895         struct bnx2x *bp = (struct bnx2x *) data;
3896
3897         if (!netif_running(bp->dev))
3898                 return;
3899
3900         if (atomic_read(&bp->intr_sem) != 0)
3901                 goto timer_restart;
3902
3903         if (poll) {
3904                 struct bnx2x_fastpath *fp = &bp->fp[0];
3905
3906                 bnx2x_tx_int(fp);
3907                 bnx2x_rx_int(fp, 1000);
3908         }
3909
3910         if (!BP_NOMCP(bp)) {
3911                 int mb_idx = BP_FW_MB_IDX(bp);
3912                 u32 drv_pulse;
3913                 u32 mcp_pulse;
3914
3915                 ++bp->fw_drv_pulse_wr_seq;
3916                 bp->fw_drv_pulse_wr_seq &= DRV_PULSE_SEQ_MASK;
3917                 /* TBD - add SYSTEM_TIME */
3918                 drv_pulse = bp->fw_drv_pulse_wr_seq;
3919                 SHMEM_WR(bp, func_mb[mb_idx].drv_pulse_mb, drv_pulse);
3920
3921                 mcp_pulse = (SHMEM_RD(bp, func_mb[mb_idx].mcp_pulse_mb) &
3922                              MCP_PULSE_SEQ_MASK);
3923                 /* The delta between driver pulse and mcp response
3924                  * should be 1 (before mcp response) or 0 (after mcp response)
3925                  */
3926                 if ((drv_pulse != mcp_pulse) &&
3927                     (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
3928                         /* someone lost a heartbeat... */
3929                         BNX2X_ERR("drv_pulse (0x%x) != mcp_pulse (0x%x)\n",
3930                                   drv_pulse, mcp_pulse);
3931                 }
3932         }
3933
3934         if (bp->state == BNX2X_STATE_OPEN)
3935                 bnx2x_stats_handle(bp, STATS_EVENT_UPDATE);
3936
3937 timer_restart:
3938         mod_timer(&bp->timer, jiffies + bp->current_interval);
3939 }
3940
3941 /* end of Statistics */
3942
3943 /* nic init */
3944
3945 /*
3946  * nic init service functions
3947  */
3948
3949 static inline void bnx2x_fill(struct bnx2x *bp, u32 addr, int fill, u32 len)
3950 {
3951         u32 i;
3952         if (!(len%4) && !(addr%4))
3953                 for (i = 0; i < len; i += 4)
3954                         REG_WR(bp, addr + i, fill);
3955         else
3956                 for (i = 0; i < len; i++)
3957                         REG_WR8(bp, addr + i, fill);
3958
3959 }
3960
3961 /* helper: writes FP SP data to FW - data_size in dwords */
3962 static inline void bnx2x_wr_fp_sb_data(struct bnx2x *bp,
3963                                        int fw_sb_id,
3964                                        u32 *sb_data_p,
3965                                        u32 data_size)
3966 {
3967         int index;
3968         for (index = 0; index < data_size; index++)
3969                 REG_WR(bp, BAR_CSTRORM_INTMEM +
3970                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
3971                         sizeof(u32)*index,
3972                         *(sb_data_p + index));
3973 }
3974
3975 static inline void bnx2x_zero_fp_sb(struct bnx2x *bp, int fw_sb_id)
3976 {
3977         u32 *sb_data_p;
3978         u32 data_size = 0;
3979         struct hc_status_block_data_e2 sb_data_e2;
3980         struct hc_status_block_data_e1x sb_data_e1x;
3981
3982         /* disable the function first */
3983         if (CHIP_IS_E2(bp)) {
3984                 memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
3985                 sb_data_e2.common.p_func.pf_id = HC_FUNCTION_DISABLED;
3986                 sb_data_e2.common.p_func.vf_id = HC_FUNCTION_DISABLED;
3987                 sb_data_e2.common.p_func.vf_valid = false;
3988                 sb_data_p = (u32 *)&sb_data_e2;
3989                 data_size = sizeof(struct hc_status_block_data_e2)/sizeof(u32);
3990         } else {
3991                 memset(&sb_data_e1x, 0,
3992                        sizeof(struct hc_status_block_data_e1x));
3993                 sb_data_e1x.common.p_func.pf_id = HC_FUNCTION_DISABLED;
3994                 sb_data_e1x.common.p_func.vf_id = HC_FUNCTION_DISABLED;
3995                 sb_data_e1x.common.p_func.vf_valid = false;
3996                 sb_data_p = (u32 *)&sb_data_e1x;
3997                 data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
3998         }
3999         bnx2x_wr_fp_sb_data(bp, fw_sb_id, sb_data_p, data_size);
4000
4001         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
4002                         CSTORM_STATUS_BLOCK_OFFSET(fw_sb_id), 0,
4003                         CSTORM_STATUS_BLOCK_SIZE);
4004         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
4005                         CSTORM_SYNC_BLOCK_OFFSET(fw_sb_id), 0,
4006                         CSTORM_SYNC_BLOCK_SIZE);
4007 }
4008
4009 /* helper:  writes SP SB data to FW */
4010 static inline void bnx2x_wr_sp_sb_data(struct bnx2x *bp,
4011                 struct hc_sp_status_block_data *sp_sb_data)
4012 {
4013         int func = BP_FUNC(bp);
4014         int i;
4015         for (i = 0; i < sizeof(struct hc_sp_status_block_data)/sizeof(u32); i++)
4016                 REG_WR(bp, BAR_CSTRORM_INTMEM +
4017                         CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
4018                         i*sizeof(u32),
4019                         *((u32 *)sp_sb_data + i));
4020 }
4021
4022 static inline void bnx2x_zero_sp_sb(struct bnx2x *bp)
4023 {
4024         int func = BP_FUNC(bp);
4025         struct hc_sp_status_block_data sp_sb_data;
4026         memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
4027
4028         sp_sb_data.p_func.pf_id = HC_FUNCTION_DISABLED;
4029         sp_sb_data.p_func.vf_id = HC_FUNCTION_DISABLED;
4030         sp_sb_data.p_func.vf_valid = false;
4031
4032         bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
4033
4034         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
4035                         CSTORM_SP_STATUS_BLOCK_OFFSET(func), 0,
4036                         CSTORM_SP_STATUS_BLOCK_SIZE);
4037         bnx2x_fill(bp, BAR_CSTRORM_INTMEM +
4038                         CSTORM_SP_SYNC_BLOCK_OFFSET(func), 0,
4039                         CSTORM_SP_SYNC_BLOCK_SIZE);
4040
4041 }
4042
4043
4044 static inline
4045 void bnx2x_setup_ndsb_state_machine(struct hc_status_block_sm *hc_sm,
4046                                            int igu_sb_id, int igu_seg_id)
4047 {
4048         hc_sm->igu_sb_id = igu_sb_id;
4049         hc_sm->igu_seg_id = igu_seg_id;
4050         hc_sm->timer_value = 0xFF;
4051         hc_sm->time_to_expire = 0xFFFFFFFF;
4052 }
4053
4054 static void bnx2x_init_sb(struct bnx2x *bp, dma_addr_t mapping, int vfid,
4055                           u8 vf_valid, int fw_sb_id, int igu_sb_id)
4056 {
4057         int igu_seg_id;
4058
4059         struct hc_status_block_data_e2 sb_data_e2;
4060         struct hc_status_block_data_e1x sb_data_e1x;
4061         struct hc_status_block_sm  *hc_sm_p;
4062         int data_size;
4063         u32 *sb_data_p;
4064
4065         if (CHIP_INT_MODE_IS_BC(bp))
4066                 igu_seg_id = HC_SEG_ACCESS_NORM;
4067         else
4068                 igu_seg_id = IGU_SEG_ACCESS_NORM;
4069
4070         bnx2x_zero_fp_sb(bp, fw_sb_id);
4071
4072         if (CHIP_IS_E2(bp)) {
4073                 memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
4074                 sb_data_e2.common.p_func.pf_id = BP_FUNC(bp);
4075                 sb_data_e2.common.p_func.vf_id = vfid;
4076                 sb_data_e2.common.p_func.vf_valid = vf_valid;
4077                 sb_data_e2.common.p_func.vnic_id = BP_VN(bp);
4078                 sb_data_e2.common.same_igu_sb_1b = true;
4079                 sb_data_e2.common.host_sb_addr.hi = U64_HI(mapping);
4080                 sb_data_e2.common.host_sb_addr.lo = U64_LO(mapping);
4081                 hc_sm_p = sb_data_e2.common.state_machine;
4082                 sb_data_p = (u32 *)&sb_data_e2;
4083                 data_size = sizeof(struct hc_status_block_data_e2)/sizeof(u32);
4084         } else {
4085                 memset(&sb_data_e1x, 0,
4086                        sizeof(struct hc_status_block_data_e1x));
4087                 sb_data_e1x.common.p_func.pf_id = BP_FUNC(bp);
4088                 sb_data_e1x.common.p_func.vf_id = 0xff;
4089                 sb_data_e1x.common.p_func.vf_valid = false;
4090                 sb_data_e1x.common.p_func.vnic_id = BP_VN(bp);
4091                 sb_data_e1x.common.same_igu_sb_1b = true;
4092                 sb_data_e1x.common.host_sb_addr.hi = U64_HI(mapping);
4093                 sb_data_e1x.common.host_sb_addr.lo = U64_LO(mapping);
4094                 hc_sm_p = sb_data_e1x.common.state_machine;
4095                 sb_data_p = (u32 *)&sb_data_e1x;
4096                 data_size = sizeof(struct hc_status_block_data_e1x)/sizeof(u32);
4097         }
4098
4099         bnx2x_setup_ndsb_state_machine(&hc_sm_p[SM_RX_ID],
4100                                        igu_sb_id, igu_seg_id);
4101         bnx2x_setup_ndsb_state_machine(&hc_sm_p[SM_TX_ID],
4102                                        igu_sb_id, igu_seg_id);
4103
4104         DP(NETIF_MSG_HW, "Init FW SB %d\n", fw_sb_id);
4105
4106         /* write indecies to HW */
4107         bnx2x_wr_fp_sb_data(bp, fw_sb_id, sb_data_p, data_size);
4108 }
4109
4110 static void bnx2x_update_coalesce_sb_index(struct bnx2x *bp, u16 fw_sb_id,
4111                                         u8 sb_index, u8 disable, u16 usec)
4112 {
4113         int port = BP_PORT(bp);
4114         u8 ticks = usec / BNX2X_BTR;
4115
4116         storm_memset_hc_timeout(bp, port, fw_sb_id, sb_index, ticks);
4117
4118         disable = disable ? 1 : (usec ? 0 : 1);
4119         storm_memset_hc_disable(bp, port, fw_sb_id, sb_index, disable);
4120 }
4121
4122 static void bnx2x_update_coalesce_sb(struct bnx2x *bp, u16 fw_sb_id,
4123                                      u16 tx_usec, u16 rx_usec)
4124 {
4125         bnx2x_update_coalesce_sb_index(bp, fw_sb_id, U_SB_ETH_RX_CQ_INDEX,
4126                                     false, rx_usec);
4127         bnx2x_update_coalesce_sb_index(bp, fw_sb_id, C_SB_ETH_TX_CQ_INDEX,
4128                                     false, tx_usec);
4129 }
4130
4131 static void bnx2x_init_def_sb(struct bnx2x *bp)
4132 {
4133         struct host_sp_status_block *def_sb = bp->def_status_blk;
4134         dma_addr_t mapping = bp->def_status_blk_mapping;
4135         int igu_sp_sb_index;
4136         int igu_seg_id;
4137         int port = BP_PORT(bp);
4138         int func = BP_FUNC(bp);
4139         int reg_offset;
4140         u64 section;
4141         int index;
4142         struct hc_sp_status_block_data sp_sb_data;
4143         memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
4144
4145         if (CHIP_INT_MODE_IS_BC(bp)) {
4146                 igu_sp_sb_index = DEF_SB_IGU_ID;
4147                 igu_seg_id = HC_SEG_ACCESS_DEF;
4148         } else {
4149                 igu_sp_sb_index = bp->igu_dsb_id;
4150                 igu_seg_id = IGU_SEG_ACCESS_DEF;
4151         }
4152
4153         /* ATTN */
4154         section = ((u64)mapping) + offsetof(struct host_sp_status_block,
4155                                             atten_status_block);
4156         def_sb->atten_status_block.status_block_id = igu_sp_sb_index;
4157
4158         bp->attn_state = 0;
4159
4160         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
4161                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
4162         for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
4163                 int sindex;
4164                 /* take care of sig[0]..sig[4] */
4165                 for (sindex = 0; sindex < 4; sindex++)
4166                         bp->attn_group[index].sig[sindex] =
4167                            REG_RD(bp, reg_offset + sindex*0x4 + 0x10*index);
4168
4169                 if (CHIP_IS_E2(bp))
4170                         /*
4171                          * enable5 is separate from the rest of the registers,
4172                          * and therefore the address skip is 4
4173                          * and not 16 between the different groups
4174                          */
4175                         bp->attn_group[index].sig[4] = REG_RD(bp,
4176                                         reg_offset + 0x10 + 0x4*index);
4177                 else
4178                         bp->attn_group[index].sig[4] = 0;
4179         }
4180
4181         if (bp->common.int_block == INT_BLOCK_HC) {
4182                 reg_offset = (port ? HC_REG_ATTN_MSG1_ADDR_L :
4183                                      HC_REG_ATTN_MSG0_ADDR_L);
4184
4185                 REG_WR(bp, reg_offset, U64_LO(section));
4186                 REG_WR(bp, reg_offset + 4, U64_HI(section));
4187         } else if (CHIP_IS_E2(bp)) {
4188                 REG_WR(bp, IGU_REG_ATTN_MSG_ADDR_L, U64_LO(section));
4189                 REG_WR(bp, IGU_REG_ATTN_MSG_ADDR_H, U64_HI(section));
4190         }
4191
4192         section = ((u64)mapping) + offsetof(struct host_sp_status_block,
4193                                             sp_sb);
4194
4195         bnx2x_zero_sp_sb(bp);
4196
4197         sp_sb_data.host_sb_addr.lo      = U64_LO(section);
4198         sp_sb_data.host_sb_addr.hi      = U64_HI(section);
4199         sp_sb_data.igu_sb_id            = igu_sp_sb_index;
4200         sp_sb_data.igu_seg_id           = igu_seg_id;
4201         sp_sb_data.p_func.pf_id         = func;
4202         sp_sb_data.p_func.vnic_id       = BP_VN(bp);
4203         sp_sb_data.p_func.vf_id         = 0xff;
4204
4205         bnx2x_wr_sp_sb_data(bp, &sp_sb_data);
4206
4207         bp->stats_pending = 0;
4208         bp->set_mac_pending = 0;
4209
4210         bnx2x_ack_sb(bp, bp->igu_dsb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
4211 }
4212
4213 void bnx2x_update_coalesce(struct bnx2x *bp)
4214 {
4215         int i;
4216
4217         for_each_eth_queue(bp, i)
4218                 bnx2x_update_coalesce_sb(bp, bp->fp[i].fw_sb_id,
4219                                          bp->tx_ticks, bp->rx_ticks);
4220 }
4221
4222 static void bnx2x_init_sp_ring(struct bnx2x *bp)
4223 {
4224         spin_lock_init(&bp->spq_lock);
4225         atomic_set(&bp->cq_spq_left, MAX_SPQ_PENDING);
4226
4227         bp->spq_prod_idx = 0;
4228         bp->dsb_sp_prod = BNX2X_SP_DSB_INDEX;
4229         bp->spq_prod_bd = bp->spq;
4230         bp->spq_last_bd = bp->spq_prod_bd + MAX_SP_DESC_CNT;
4231 }
4232
4233 static void bnx2x_init_eq_ring(struct bnx2x *bp)
4234 {
4235         int i;
4236         for (i = 1; i <= NUM_EQ_PAGES; i++) {
4237                 union event_ring_elem *elem =
4238                         &bp->eq_ring[EQ_DESC_CNT_PAGE * i - 1];
4239
4240                 elem->next_page.addr.hi =
4241                         cpu_to_le32(U64_HI(bp->eq_mapping +
4242                                    BCM_PAGE_SIZE * (i % NUM_EQ_PAGES)));
4243                 elem->next_page.addr.lo =
4244                         cpu_to_le32(U64_LO(bp->eq_mapping +
4245                                    BCM_PAGE_SIZE*(i % NUM_EQ_PAGES)));
4246         }
4247         bp->eq_cons = 0;
4248         bp->eq_prod = NUM_EQ_DESC;
4249         bp->eq_cons_sb = BNX2X_EQ_INDEX;
4250         /* we want a warning message before it gets rought... */
4251         atomic_set(&bp->eq_spq_left,
4252                 min_t(int, MAX_SP_DESC_CNT - MAX_SPQ_PENDING, NUM_EQ_DESC) - 1);
4253 }
4254
4255 void bnx2x_push_indir_table(struct bnx2x *bp)
4256 {
4257         int func = BP_FUNC(bp);
4258         int i;
4259
4260         if (bp->multi_mode == ETH_RSS_MODE_DISABLED)
4261                 return;
4262
4263         for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
4264                 REG_WR8(bp, BAR_TSTRORM_INTMEM +
4265                         TSTORM_INDIRECTION_TABLE_OFFSET(func) + i,
4266                         bp->fp->cl_id + bp->rx_indir_table[i]);
4267 }
4268
4269 static void bnx2x_init_ind_table(struct bnx2x *bp)
4270 {
4271         int i;
4272
4273         for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
4274                 bp->rx_indir_table[i] = i % BNX2X_NUM_ETH_QUEUES(bp);
4275
4276         bnx2x_push_indir_table(bp);
4277 }
4278
4279 void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
4280 {
4281         int mode = bp->rx_mode;
4282         int port = BP_PORT(bp);
4283         u16 cl_id;
4284         u32 def_q_filters = 0;
4285
4286         /* All but management unicast packets should pass to the host as well */
4287         u32 llh_mask =
4288                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_BRCST |
4289                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_MLCST |
4290                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_VLAN |
4291                 NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_NO_VLAN;
4292
4293         switch (mode) {
4294         case BNX2X_RX_MODE_NONE: /* no Rx */
4295                 def_q_filters = BNX2X_ACCEPT_NONE;
4296 #ifdef BCM_CNIC
4297                 if (!NO_FCOE(bp)) {
4298                         cl_id = bnx2x_fcoe(bp, cl_id);
4299                         bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_NONE);
4300                 }
4301 #endif
4302                 break;
4303
4304         case BNX2X_RX_MODE_NORMAL:
4305                 def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST |
4306                                 BNX2X_ACCEPT_MULTICAST;
4307 #ifdef BCM_CNIC
4308                 if (!NO_FCOE(bp)) {
4309                         cl_id = bnx2x_fcoe(bp, cl_id);
4310                         bnx2x_rxq_set_mac_filters(bp, cl_id,
4311                                                   BNX2X_ACCEPT_UNICAST |
4312                                                   BNX2X_ACCEPT_MULTICAST);
4313                 }
4314 #endif
4315                 break;
4316
4317         case BNX2X_RX_MODE_ALLMULTI:
4318                 def_q_filters |= BNX2X_ACCEPT_UNICAST | BNX2X_ACCEPT_BROADCAST |
4319                                 BNX2X_ACCEPT_ALL_MULTICAST;
4320 #ifdef BCM_CNIC
4321                 /*
4322                  *  Prevent duplication of multicast packets by configuring FCoE
4323                  *  L2 Client to receive only matched unicast frames.
4324                  */
4325                 if (!NO_FCOE(bp)) {
4326                         cl_id = bnx2x_fcoe(bp, cl_id);
4327                         bnx2x_rxq_set_mac_filters(bp, cl_id,
4328                                                   BNX2X_ACCEPT_UNICAST);
4329                 }
4330 #endif
4331                 break;
4332
4333         case BNX2X_RX_MODE_PROMISC:
4334                 def_q_filters |= BNX2X_PROMISCUOUS_MODE;
4335 #ifdef BCM_CNIC
4336                 /*
4337                  *  Prevent packets duplication by configuring DROP_ALL for FCoE
4338                  *  L2 Client.
4339                  */
4340                 if (!NO_FCOE(bp)) {
4341                         cl_id = bnx2x_fcoe(bp, cl_id);
4342                         bnx2x_rxq_set_mac_filters(bp, cl_id, BNX2X_ACCEPT_NONE);
4343                 }
4344 #endif
4345                 /* pass management unicast packets as well */
4346                 llh_mask |= NIG_LLH0_BRB1_DRV_MASK_REG_LLH0_BRB1_DRV_MASK_UNCST;
4347                 break;
4348
4349         default:
4350                 BNX2X_ERR("BAD rx mode (%d)\n", mode);
4351                 break;
4352         }
4353
4354         cl_id = BP_L_ID(bp);
4355         bnx2x_rxq_set_mac_filters(bp, cl_id, def_q_filters);
4356
4357         REG_WR(bp,
4358                (port ? NIG_REG_LLH1_BRB1_DRV_MASK :
4359                        NIG_REG_LLH0_BRB1_DRV_MASK), llh_mask);
4360
4361         DP(NETIF_MSG_IFUP, "rx mode %d\n"
4362                 "drop_ucast 0x%x\ndrop_mcast 0x%x\ndrop_bcast 0x%x\n"
4363                 "accp_ucast 0x%x\naccp_mcast 0x%x\naccp_bcast 0x%x\n"
4364                 "unmatched_ucast 0x%x\n", mode,
4365                 bp->mac_filters.ucast_drop_all,
4366                 bp->mac_filters.mcast_drop_all,
4367                 bp->mac_filters.bcast_drop_all,
4368                 bp->mac_filters.ucast_accept_all,
4369                 bp->mac_filters.mcast_accept_all,
4370                 bp->mac_filters.bcast_accept_all,
4371                 bp->mac_filters.unmatched_unicast
4372         );
4373
4374         storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
4375 }
4376
4377 static void bnx2x_init_internal_common(struct bnx2x *bp)
4378 {
4379         int i;
4380
4381         if (!CHIP_IS_E1(bp)) {
4382
4383                 /* xstorm needs to know whether to add  ovlan to packets or not,
4384                  * in switch-independent we'll write 0 to here... */
4385                 REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNCTION_MODE_OFFSET,
4386                         bp->mf_mode);
4387                 REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNCTION_MODE_OFFSET,
4388                         bp->mf_mode);
4389                 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNCTION_MODE_OFFSET,
4390                         bp->mf_mode);
4391                 REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNCTION_MODE_OFFSET,
4392                         bp->mf_mode);
4393         }
4394
4395         if (IS_MF_SI(bp))
4396                 /*
4397                  * In switch independent mode, the TSTORM needs to accept
4398                  * packets that failed classification, since approximate match
4399                  * mac addresses aren't written to NIG LLH
4400                  */
4401                 REG_WR8(bp, BAR_TSTRORM_INTMEM +
4402                             TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET, 2);
4403
4404         /* Zero this manually as its initialization is
4405            currently missing in the initTool */
4406         for (i = 0; i < (USTORM_AGG_DATA_SIZE >> 2); i++)
4407                 REG_WR(bp, BAR_USTRORM_INTMEM +
4408                        USTORM_AGG_DATA_OFFSET + i * 4, 0);
4409         if (CHIP_IS_E2(bp)) {
4410                 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_IGU_MODE_OFFSET,
4411                         CHIP_INT_MODE_IS_BC(bp) ?
4412                         HC_IGU_BC_MODE : HC_IGU_NBC_MODE);
4413         }
4414 }
4415
4416 static void bnx2x_init_internal_port(struct bnx2x *bp)
4417 {
4418         /* port */
4419         bnx2x_dcb_init_intmem_pfc(bp);
4420 }
4421
4422 static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
4423 {
4424         switch (load_code) {
4425         case FW_MSG_CODE_DRV_LOAD_COMMON:
4426         case FW_MSG_CODE_DRV_LOAD_COMMON_CHIP:
4427                 bnx2x_init_internal_common(bp);
4428                 /* no break */
4429
4430         case FW_MSG_CODE_DRV_LOAD_PORT:
4431                 bnx2x_init_internal_port(bp);
4432                 /* no break */
4433
4434         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
4435                 /* internal memory per function is
4436                    initialized inside bnx2x_pf_init */
4437                 break;
4438
4439         default:
4440                 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
4441                 break;
4442         }
4443 }
4444
4445 static void bnx2x_init_fp_sb(struct bnx2x *bp, int fp_idx)
4446 {
4447         struct bnx2x_fastpath *fp = &bp->fp[fp_idx];
4448
4449         fp->state = BNX2X_FP_STATE_CLOSED;
4450
4451         fp->cid = fp_idx;
4452         fp->cl_id = BP_L_ID(bp) + fp_idx;
4453         fp->fw_sb_id = bp->base_fw_ndsb + fp->cl_id + CNIC_CONTEXT_USE;
4454         fp->igu_sb_id = bp->igu_base_sb + fp_idx + CNIC_CONTEXT_USE;
4455         /* qZone id equals to FW (per path) client id */
4456         fp->cl_qzone_id  = fp->cl_id +
4457                            BP_PORT(bp)*(CHIP_IS_E2(bp) ? ETH_MAX_RX_CLIENTS_E2 :
4458                                 ETH_MAX_RX_CLIENTS_E1H);
4459         /* init shortcut */
4460         fp->ustorm_rx_prods_offset = CHIP_IS_E2(bp) ?
4461                             USTORM_RX_PRODS_E2_OFFSET(fp->cl_qzone_id) :
4462                             USTORM_RX_PRODS_E1X_OFFSET(BP_PORT(bp), fp->cl_id);
4463         /* Setup SB indicies */
4464         fp->rx_cons_sb = BNX2X_RX_SB_INDEX;
4465         fp->tx_cons_sb = BNX2X_TX_SB_INDEX;
4466
4467         DP(NETIF_MSG_IFUP, "queue[%d]:  bnx2x_init_sb(%p,%p)  "
4468                                    "cl_id %d  fw_sb %d  igu_sb %d\n",
4469                    fp_idx, bp, fp->status_blk.e1x_sb, fp->cl_id, fp->fw_sb_id,
4470                    fp->igu_sb_id);
4471         bnx2x_init_sb(bp, fp->status_blk_mapping, BNX2X_VF_ID_INVALID, false,
4472                       fp->fw_sb_id, fp->igu_sb_id);
4473
4474         bnx2x_update_fpsb_idx(fp);
4475 }
4476
4477 void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
4478 {
4479         int i;
4480
4481         for_each_eth_queue(bp, i)
4482                 bnx2x_init_fp_sb(bp, i);
4483 #ifdef BCM_CNIC
4484         if (!NO_FCOE(bp))
4485                 bnx2x_init_fcoe_fp(bp);
4486
4487         bnx2x_init_sb(bp, bp->cnic_sb_mapping,
4488                       BNX2X_VF_ID_INVALID, false,
4489                       CNIC_SB_ID(bp), CNIC_IGU_SB_ID(bp));
4490
4491 #endif
4492
4493         /* ensure status block indices were read */
4494         rmb();
4495
4496         bnx2x_init_def_sb(bp);
4497         bnx2x_update_dsb_idx(bp);
4498         bnx2x_init_rx_rings(bp);
4499         bnx2x_init_tx_rings(bp);
4500         bnx2x_init_sp_ring(bp);
4501         bnx2x_init_eq_ring(bp);
4502         bnx2x_init_internal(bp, load_code);
4503         bnx2x_pf_init(bp);
4504         bnx2x_init_ind_table(bp);
4505         bnx2x_stats_init(bp);
4506
4507         /* At this point, we are ready for interrupts */
4508         atomic_set(&bp->intr_sem, 0);
4509
4510         /* flush all before enabling interrupts */
4511         mb();
4512         mmiowb();
4513
4514         bnx2x_int_enable(bp);
4515
4516         /* Check for SPIO5 */
4517         bnx2x_attn_int_deasserted0(bp,
4518                 REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + BP_PORT(bp)*4) &
4519                                    AEU_INPUTS_ATTN_BITS_SPIO5);
4520 }
4521
4522 /* end of nic init */
4523
4524 /*
4525  * gzip service functions
4526  */
4527
4528 static int bnx2x_gunzip_init(struct bnx2x *bp)
4529 {
4530         bp->gunzip_buf = dma_alloc_coherent(&bp->pdev->dev, FW_BUF_SIZE,
4531                                             &bp->gunzip_mapping, GFP_KERNEL);
4532         if (bp->gunzip_buf  == NULL)
4533                 goto gunzip_nomem1;
4534
4535         bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL);
4536         if (bp->strm  == NULL)
4537                 goto gunzip_nomem2;
4538
4539         bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(),
4540                                       GFP_KERNEL);
4541         if (bp->strm->workspace == NULL)
4542                 goto gunzip_nomem3;
4543
4544         return 0;
4545
4546 gunzip_nomem3:
4547         kfree(bp->strm);
4548         bp->strm = NULL;
4549
4550 gunzip_nomem2:
4551         dma_free_coherent(&bp->pdev->dev, FW_BUF_SIZE, bp->gunzip_buf,
4552                           bp->gunzip_mapping);
4553         bp->gunzip_buf = NULL;
4554
4555 gunzip_nomem1:
4556         netdev_err(bp->dev, "Cannot allocate firmware buffer for"
4557                " un-compression\n");
4558         return -ENOMEM;
4559 }
4560
4561 static void bnx2x_gunzip_end(struct bnx2x *bp)
4562 {
4563         if (bp->strm) {
4564                 kfree(bp->strm->workspace);
4565                 kfree(bp->strm);
4566                 bp->strm = NULL;
4567         }
4568
4569         if (bp->gunzip_buf) {
4570                 dma_free_coherent(&bp->pdev->dev, FW_BUF_SIZE, bp->gunzip_buf,
4571                                   bp->gunzip_mapping);
4572                 bp->gunzip_buf = NULL;
4573         }
4574 }
4575
4576 static int bnx2x_gunzip(struct bnx2x *bp, const u8 *zbuf, int len)
4577 {
4578         int n, rc;
4579
4580         /* check gzip header */
4581         if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED)) {
4582                 BNX2X_ERR("Bad gzip header\n");
4583                 return -EINVAL;
4584         }
4585
4586         n = 10;
4587
4588 #define FNAME                           0x8
4589
4590         if (zbuf[3] & FNAME)
4591                 while ((zbuf[n++] != 0) && (n < len));
4592
4593         bp->strm->next_in = (typeof(bp->strm->next_in))zbuf + n;
4594         bp->strm->avail_in = len - n;
4595         bp->strm->next_out = bp->gunzip_buf;
4596         bp->strm->avail_out = FW_BUF_SIZE;
4597
4598         rc = zlib_inflateInit2(bp->strm, -MAX_WBITS);
4599         if (rc != Z_OK)
4600                 return rc;
4601
4602         rc = zlib_inflate(bp->strm, Z_FINISH);
4603         if ((rc != Z_OK) && (rc != Z_STREAM_END))
4604                 netdev_err(bp->dev, "Firmware decompression error: %s\n",
4605                            bp->strm->msg);
4606
4607         bp->gunzip_outlen = (FW_BUF_SIZE - bp->strm->avail_out);
4608         if (bp->gunzip_outlen & 0x3)
4609                 netdev_err(bp->dev, "Firmware decompression error:"
4610                                     " gunzip_outlen (%d) not aligned\n",
4611                                 bp->gunzip_outlen);
4612         bp->gunzip_outlen >>= 2;
4613
4614         zlib_inflateEnd(bp->strm);
4615
4616         if (rc == Z_STREAM_END)
4617                 return 0;
4618
4619         return rc;
4620 }
4621
4622 /* nic load/unload */
4623
4624 /*
4625  * General service functions
4626  */
4627
4628 /* send a NIG loopback debug packet */
4629 static void bnx2x_lb_pckt(struct bnx2x *bp)
4630 {
4631         u32 wb_write[3];
4632
4633         /* Ethernet source and destination addresses */
4634         wb_write[0] = 0x55555555;
4635         wb_write[1] = 0x55555555;
4636         wb_write[2] = 0x20;             /* SOP */
4637         REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4638
4639         /* NON-IP protocol */
4640         wb_write[0] = 0x09000000;
4641         wb_write[1] = 0x55555555;
4642         wb_write[2] = 0x10;             /* EOP, eop_bvalid = 0 */
4643         REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
4644 }
4645
4646 /* some of the internal memories
4647  * are not directly readable from the driver
4648  * to test them we send debug packets
4649  */
4650 static int bnx2x_int_mem_test(struct bnx2x *bp)
4651 {
4652         int factor;
4653         int count, i;
4654         u32 val = 0;
4655
4656         if (CHIP_REV_IS_FPGA(bp))
4657                 factor = 120;
4658         else if (CHIP_REV_IS_EMUL(bp))
4659                 factor = 200;
4660         else
4661                 factor = 1;
4662
4663         /* Disable inputs of parser neighbor blocks */
4664         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
4665         REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
4666         REG_WR(bp, CFC_REG_DEBUG0, 0x1);
4667         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
4668
4669         /*  Write 0 to parser credits for CFC search request */
4670         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
4671
4672         /* send Ethernet packet */
4673         bnx2x_lb_pckt(bp);
4674
4675         /* TODO do i reset NIG statistic? */
4676         /* Wait until NIG register shows 1 packet of size 0x10 */
4677         count = 1000 * factor;
4678         while (count) {
4679
4680                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
4681                 val = *bnx2x_sp(bp, wb_data[0]);
4682                 if (val == 0x10)
4683                         break;
4684
4685                 msleep(10);
4686                 count--;
4687         }
4688         if (val != 0x10) {
4689                 BNX2X_ERR("NIG timeout  val = 0x%x\n", val);
4690                 return -1;
4691         }
4692
4693         /* Wait until PRS register shows 1 packet */
4694         count = 1000 * factor;
4695         while (count) {
4696                 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4697                 if (val == 1)
4698                         break;
4699
4700                 msleep(10);
4701                 count--;
4702         }
4703         if (val != 0x1) {
4704                 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
4705                 return -2;
4706         }
4707
4708         /* Reset and init BRB, PRS */
4709         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
4710         msleep(50);
4711         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
4712         msleep(50);
4713         bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
4714         bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
4715
4716         DP(NETIF_MSG_HW, "part2\n");
4717
4718         /* Disable inputs of parser neighbor blocks */
4719         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
4720         REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
4721         REG_WR(bp, CFC_REG_DEBUG0, 0x1);
4722         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
4723
4724         /* Write 0 to parser credits for CFC search request */
4725         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
4726
4727         /* send 10 Ethernet packets */
4728         for (i = 0; i < 10; i++)
4729                 bnx2x_lb_pckt(bp);
4730
4731         /* Wait until NIG register shows 10 + 1
4732            packets of size 11*0x10 = 0xb0 */
4733         count = 1000 * factor;
4734         while (count) {
4735
4736                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
4737                 val = *bnx2x_sp(bp, wb_data[0]);
4738                 if (val == 0xb0)
4739                         break;
4740
4741                 msleep(10);
4742                 count--;
4743         }
4744         if (val != 0xb0) {
4745                 BNX2X_ERR("NIG timeout  val = 0x%x\n", val);
4746                 return -3;
4747         }
4748
4749         /* Wait until PRS register shows 2 packets */
4750         val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4751         if (val != 2)
4752                 BNX2X_ERR("PRS timeout  val = 0x%x\n", val);
4753
4754         /* Write 1 to parser credits for CFC search request */
4755         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x1);
4756
4757         /* Wait until PRS register shows 3 packets */
4758         msleep(10 * factor);
4759         /* Wait until NIG register shows 1 packet of size 0x10 */
4760         val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
4761         if (val != 3)
4762                 BNX2X_ERR("PRS timeout  val = 0x%x\n", val);
4763
4764         /* clear NIG EOP FIFO */
4765         for (i = 0; i < 11; i++)
4766                 REG_RD(bp, NIG_REG_INGRESS_EOP_LB_FIFO);
4767         val = REG_RD(bp, NIG_REG_INGRESS_EOP_LB_EMPTY);
4768         if (val != 1) {
4769                 BNX2X_ERR("clear of NIG failed\n");
4770                 return -4;
4771         }
4772
4773         /* Reset and init BRB, PRS, NIG */
4774         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
4775         msleep(50);
4776         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
4777         msleep(50);
4778         bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
4779         bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
4780 #ifndef BCM_CNIC
4781         /* set NIC mode */
4782         REG_WR(bp, PRS_REG_NIC_MODE, 1);
4783 #endif
4784
4785         /* Enable inputs of parser neighbor blocks */
4786         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x7fffffff);
4787         REG_WR(bp, TCM_REG_PRS_IFEN, 0x1);
4788         REG_WR(bp, CFC_REG_DEBUG0, 0x0);
4789         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x1);
4790
4791         DP(NETIF_MSG_HW, "done\n");
4792
4793         return 0; /* OK */
4794 }
4795
4796 static void bnx2x_enable_blocks_attention(struct bnx2x *bp)
4797 {
4798         REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
4799         if (CHIP_IS_E2(bp))
4800                 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0x40);
4801         else
4802                 REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0);
4803         REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
4804         REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
4805         /*
4806          * mask read length error interrupts in brb for parser
4807          * (parsing unit and 'checksum and crc' unit)
4808          * these errors are legal (PU reads fixed length and CAC can cause
4809          * read length error on truncated packets)
4810          */
4811         REG_WR(bp, BRB1_REG_BRB1_INT_MASK, 0xFC00);
4812         REG_WR(bp, QM_REG_QM_INT_MASK, 0);
4813         REG_WR(bp, TM_REG_TM_INT_MASK, 0);
4814         REG_WR(bp, XSDM_REG_XSDM_INT_MASK_0, 0);
4815         REG_WR(bp, XSDM_REG_XSDM_INT_MASK_1, 0);
4816         REG_WR(bp, XCM_REG_XCM_INT_MASK, 0);
4817 /*      REG_WR(bp, XSEM_REG_XSEM_INT_MASK_0, 0); */
4818 /*      REG_WR(bp, XSEM_REG_XSEM_INT_MASK_1, 0); */
4819         REG_WR(bp, USDM_REG_USDM_INT_MASK_0, 0);
4820         REG_WR(bp, USDM_REG_USDM_INT_MASK_1, 0);
4821         REG_WR(bp, UCM_REG_UCM_INT_MASK, 0);
4822 /*      REG_WR(bp, USEM_REG_USEM_INT_MASK_0, 0); */
4823 /*      REG_WR(bp, USEM_REG_USEM_INT_MASK_1, 0); */
4824         REG_WR(bp, GRCBASE_UPB + PB_REG_PB_INT_MASK, 0);
4825         REG_WR(bp, CSDM_REG_CSDM_INT_MASK_0, 0);
4826         REG_WR(bp, CSDM_REG_CSDM_INT_MASK_1, 0);
4827         REG_WR(bp, CCM_REG_CCM_INT_MASK, 0);
4828 /*      REG_WR(bp, CSEM_REG_CSEM_INT_MASK_0, 0); */
4829 /*      REG_WR(bp, CSEM_REG_CSEM_INT_MASK_1, 0); */
4830
4831         if (CHIP_REV_IS_FPGA(bp))
4832                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x580000);
4833         else if (CHIP_IS_E2(bp))
4834                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0,
4835                            (PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_OF
4836                                 | PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_AFT
4837                                 | PXP2_PXP2_INT_MASK_0_REG_PGL_PCIE_ATTN
4838                                 | PXP2_PXP2_INT_MASK_0_REG_PGL_READ_BLOCKED
4839                                 | PXP2_PXP2_INT_MASK_0_REG_PGL_WRITE_BLOCKED));
4840         else
4841                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x480000);
4842         REG_WR(bp, TSDM_REG_TSDM_INT_MASK_0, 0);
4843         REG_WR(bp, TSDM_REG_TSDM_INT_MASK_1, 0);
4844         REG_WR(bp, TCM_REG_TCM_INT_MASK, 0);
4845 /*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_0, 0); */
4846 /*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_1, 0); */
4847         REG_WR(bp, CDU_REG_CDU_INT_MASK, 0);
4848         REG_WR(bp, DMAE_REG_DMAE_INT_MASK, 0);
4849 /*      REG_WR(bp, MISC_REG_MISC_INT_MASK, 0); */
4850         REG_WR(bp, PBF_REG_PBF_INT_MASK, 0x18);         /* bit 3,4 masked */
4851 }
4852
4853 static void bnx2x_reset_common(struct bnx2x *bp)
4854 {
4855         /* reset_common */
4856         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
4857                0xd3ffff7f);
4858         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
4859 }
4860
4861 static void bnx2x_init_pxp(struct bnx2x *bp)
4862 {
4863         u16 devctl;
4864         int r_order, w_order;
4865
4866         pci_read_config_word(bp->pdev,
4867                              bp->pcie_cap + PCI_EXP_DEVCTL, &devctl);
4868         DP(NETIF_MSG_HW, "read 0x%x from devctl\n", devctl);
4869         w_order = ((devctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
4870         if (bp->mrrs == -1)
4871                 r_order = ((devctl & PCI_EXP_DEVCTL_READRQ) >> 12);
4872         else {
4873                 DP(NETIF_MSG_HW, "force read order to %d\n", bp->mrrs);
4874                 r_order = bp->mrrs;
4875         }
4876
4877         bnx2x_init_pxp_arb(bp, r_order, w_order);
4878 }
4879
4880 static void bnx2x_setup_fan_failure_detection(struct bnx2x *bp)
4881 {
4882         int is_required;
4883         u32 val;
4884         int port;
4885
4886         if (BP_NOMCP(bp))
4887                 return;
4888
4889         is_required = 0;
4890         val = SHMEM_RD(bp, dev_info.shared_hw_config.config2) &
4891               SHARED_HW_CFG_FAN_FAILURE_MASK;
4892
4893         if (val == SHARED_HW_CFG_FAN_FAILURE_ENABLED)
4894                 is_required = 1;
4895
4896         /*
4897          * The fan failure mechanism is usually related to the PHY type since
4898          * the power consumption of the board is affected by the PHY. Currently,
4899          * fan is required for most designs with SFX7101, BCM8727 and BCM8481.
4900          */
4901         else if (val == SHARED_HW_CFG_FAN_FAILURE_PHY_TYPE)
4902                 for (port = PORT_0; port < PORT_MAX; port++) {
4903                         is_required |=
4904                                 bnx2x_fan_failure_det_req(
4905                                         bp,
4906                                         bp->common.shmem_base,
4907                                         bp->common.shmem2_base,
4908                                         port);
4909                 }
4910
4911         DP(NETIF_MSG_HW, "fan detection setting: %d\n", is_required);
4912
4913         if (is_required == 0)
4914                 return;
4915
4916         /* Fan failure is indicated by SPIO 5 */
4917         bnx2x_set_spio(bp, MISC_REGISTERS_SPIO_5,
4918                        MISC_REGISTERS_SPIO_INPUT_HI_Z);
4919
4920         /* set to active low mode */
4921         val = REG_RD(bp, MISC_REG_SPIO_INT);
4922         val |= ((1 << MISC_REGISTERS_SPIO_5) <<
4923                                         MISC_REGISTERS_SPIO_INT_OLD_SET_POS);
4924         REG_WR(bp, MISC_REG_SPIO_INT, val);
4925
4926         /* enable interrupt to signal the IGU */
4927         val = REG_RD(bp, MISC_REG_SPIO_EVENT_EN);
4928         val |= (1 << MISC_REGISTERS_SPIO_5);
4929         REG_WR(bp, MISC_REG_SPIO_EVENT_EN, val);
4930 }
4931
4932 static void bnx2x_pretend_func(struct bnx2x *bp, u8 pretend_func_num)
4933 {
4934         u32 offset = 0;
4935
4936         if (CHIP_IS_E1(bp))
4937                 return;
4938         if (CHIP_IS_E1H(bp) && (pretend_func_num >= E1H_FUNC_MAX))
4939                 return;
4940
4941         switch (BP_ABS_FUNC(bp)) {
4942         case 0:
4943                 offset = PXP2_REG_PGL_PRETEND_FUNC_F0;
4944                 break;
4945         case 1:
4946                 offset = PXP2_REG_PGL_PRETEND_FUNC_F1;
4947                 break;
4948         case 2:
4949                 offset = PXP2_REG_PGL_PRETEND_FUNC_F2;
4950                 break;
4951         case 3:
4952                 offset = PXP2_REG_PGL_PRETEND_FUNC_F3;
4953                 break;
4954         case 4:
4955                 offset = PXP2_REG_PGL_PRETEND_FUNC_F4;
4956                 break;
4957         case 5:
4958                 offset = PXP2_REG_PGL_PRETEND_FUNC_F5;
4959                 break;
4960         case 6:
4961                 offset = PXP2_REG_PGL_PRETEND_FUNC_F6;
4962                 break;
4963         case 7:
4964                 offset = PXP2_REG_PGL_PRETEND_FUNC_F7;
4965                 break;
4966         default:
4967                 return;
4968         }
4969
4970         REG_WR(bp, offset, pretend_func_num);
4971         REG_RD(bp, offset);
4972         DP(NETIF_MSG_HW, "Pretending to func %d\n", pretend_func_num);
4973 }
4974
4975 static void bnx2x_pf_disable(struct bnx2x *bp)
4976 {
4977         u32 val = REG_RD(bp, IGU_REG_PF_CONFIGURATION);
4978         val &= ~IGU_PF_CONF_FUNC_EN;
4979
4980         REG_WR(bp, IGU_REG_PF_CONFIGURATION, val);
4981         REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 0);
4982         REG_WR(bp, CFC_REG_WEAK_ENABLE_PF, 0);
4983 }
4984
4985 static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
4986 {
4987         u32 val, i;
4988
4989         DP(BNX2X_MSG_MCP, "starting common init  func %d\n", BP_ABS_FUNC(bp));
4990
4991         bnx2x_reset_common(bp);
4992         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
4993         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, 0xfffc);
4994
4995         bnx2x_init_block(bp, MISC_BLOCK, COMMON_STAGE);
4996         if (!CHIP_IS_E1(bp))
4997                 REG_WR(bp, MISC_REG_E1HMF_MODE, IS_MF(bp));
4998
4999         if (CHIP_IS_E2(bp)) {
5000                 u8 fid;
5001
5002                 /**
5003                  * 4-port mode or 2-port mode we need to turn of master-enable
5004                  * for everyone, after that, turn it back on for self.
5005                  * so, we disregard multi-function or not, and always disable
5006                  * for all functions on the given path, this means 0,2,4,6 for
5007                  * path 0 and 1,3,5,7 for path 1
5008                  */
5009                 for (fid = BP_PATH(bp); fid  < E2_FUNC_MAX*2; fid += 2) {
5010                         if (fid == BP_ABS_FUNC(bp)) {
5011                                 REG_WR(bp,
5012                                     PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER,
5013                                     1);
5014                                 continue;
5015                         }
5016
5017                         bnx2x_pretend_func(bp, fid);
5018                         /* clear pf enable */
5019                         bnx2x_pf_disable(bp);
5020                         bnx2x_pretend_func(bp, BP_ABS_FUNC(bp));
5021                 }
5022         }
5023
5024         bnx2x_init_block(bp, PXP_BLOCK, COMMON_STAGE);
5025         if (CHIP_IS_E1(bp)) {
5026                 /* enable HW interrupt from PXP on USDM overflow
5027                    bit 16 on INT_MASK_0 */
5028                 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
5029         }
5030
5031         bnx2x_init_block(bp, PXP2_BLOCK, COMMON_STAGE);
5032         bnx2x_init_pxp(bp);
5033
5034 #ifdef __BIG_ENDIAN
5035         REG_WR(bp, PXP2_REG_RQ_QM_ENDIAN_M, 1);
5036         REG_WR(bp, PXP2_REG_RQ_TM_ENDIAN_M, 1);
5037         REG_WR(bp, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
5038         REG_WR(bp, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
5039         REG_WR(bp, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
5040         /* make sure this value is 0 */
5041         REG_WR(bp, PXP2_REG_RQ_HC_ENDIAN_M, 0);
5042
5043 /*      REG_WR(bp, PXP2_REG_RD_PBF_SWAP_MODE, 1); */
5044         REG_WR(bp, PXP2_REG_RD_QM_SWAP_MODE, 1);
5045         REG_WR(bp, PXP2_REG_RD_TM_SWAP_MODE, 1);
5046         REG_WR(bp, PXP2_REG_RD_SRC_SWAP_MODE, 1);
5047         REG_WR(bp, PXP2_REG_RD_CDURD_SWAP_MODE, 1);
5048 #endif
5049
5050         bnx2x_ilt_init_page_size(bp, INITOP_SET);
5051
5052         if (CHIP_REV_IS_FPGA(bp) && CHIP_IS_E1H(bp))
5053                 REG_WR(bp, PXP2_REG_PGL_TAGS_LIMIT, 0x1);
5054
5055         /* let the HW do it's magic ... */
5056         msleep(100);
5057         /* finish PXP init */
5058         val = REG_RD(bp, PXP2_REG_RQ_CFG_DONE);
5059         if (val != 1) {
5060                 BNX2X_ERR("PXP2 CFG failed\n");
5061                 return -EBUSY;
5062         }
5063         val = REG_RD(bp, PXP2_REG_RD_INIT_DONE);
5064         if (val != 1) {
5065                 BNX2X_ERR("PXP2 RD_INIT failed\n");
5066                 return -EBUSY;
5067         }
5068
5069         /* Timers bug workaround E2 only. We need to set the entire ILT to
5070          * have entries with value "0" and valid bit on.
5071          * This needs to be done by the first PF that is loaded in a path
5072          * (i.e. common phase)
5073          */
5074         if (CHIP_IS_E2(bp)) {
5075                 struct ilt_client_info ilt_cli;
5076                 struct bnx2x_ilt ilt;
5077                 memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
5078                 memset(&ilt, 0, sizeof(struct bnx2x_ilt));
5079
5080                 /* initialize dummy TM client */
5081                 ilt_cli.start = 0;
5082                 ilt_cli.end = ILT_NUM_PAGE_ENTRIES - 1;
5083                 ilt_cli.client_num = ILT_CLIENT_TM;
5084
5085                 /* Step 1: set zeroes to all ilt page entries with valid bit on
5086                  * Step 2: set the timers first/last ilt entry to point
5087                  * to the entire range to prevent ILT range error for 3rd/4th
5088                  * vnic (this code assumes existence of the vnic)
5089                  *
5090                  * both steps performed by call to bnx2x_ilt_client_init_op()
5091                  * with dummy TM client
5092                  *
5093                  * we must use pretend since PXP2_REG_RQ_##blk##_FIRST_ILT
5094                  * and his brother are split registers
5095                  */
5096                 bnx2x_pretend_func(bp, (BP_PATH(bp) + 6));
5097                 bnx2x_ilt_client_init_op_ilt(bp, &ilt, &ilt_cli, INITOP_CLEAR);
5098                 bnx2x_pretend_func(bp, BP_ABS_FUNC(bp));
5099
5100                 REG_WR(bp, PXP2_REG_RQ_DRAM_ALIGN, BNX2X_PXP_DRAM_ALIGN);
5101                 REG_WR(bp, PXP2_REG_RQ_DRAM_ALIGN_RD, BNX2X_PXP_DRAM_ALIGN);
5102                 REG_WR(bp, PXP2_REG_RQ_DRAM_ALIGN_SEL, 1);
5103         }
5104
5105
5106         REG_WR(bp, PXP2_REG_RQ_DISABLE_INPUTS, 0);
5107         REG_WR(bp, PXP2_REG_RD_DISABLE_INPUTS, 0);
5108
5109         if (CHIP_IS_E2(bp)) {
5110                 int factor = CHIP_REV_IS_EMUL(bp) ? 1000 :
5111                                 (CHIP_REV_IS_FPGA(bp) ? 400 : 0);
5112                 bnx2x_init_block(bp, PGLUE_B_BLOCK, COMMON_STAGE);
5113
5114                 bnx2x_init_block(bp, ATC_BLOCK, COMMON_STAGE);
5115
5116                 /* let the HW do it's magic ... */
5117                 do {
5118                         msleep(200);
5119                         val = REG_RD(bp, ATC_REG_ATC_INIT_DONE);
5120                 } while (factor-- && (val != 1));
5121
5122                 if (val != 1) {
5123                         BNX2X_ERR("ATC_INIT failed\n");
5124                         return -EBUSY;
5125                 }
5126         }
5127
5128         bnx2x_init_block(bp, DMAE_BLOCK, COMMON_STAGE);
5129
5130         /* clean the DMAE memory */
5131         bp->dmae_ready = 1;
5132         bnx2x_init_fill(bp, TSEM_REG_PRAM, 0, 8);
5133
5134         bnx2x_init_block(bp, TCM_BLOCK, COMMON_STAGE);
5135         bnx2x_init_block(bp, UCM_BLOCK, COMMON_STAGE);
5136         bnx2x_init_block(bp, CCM_BLOCK, COMMON_STAGE);
5137         bnx2x_init_block(bp, XCM_BLOCK, COMMON_STAGE);
5138
5139         bnx2x_read_dmae(bp, XSEM_REG_PASSIVE_BUFFER, 3);
5140         bnx2x_read_dmae(bp, CSEM_REG_PASSIVE_BUFFER, 3);
5141         bnx2x_read_dmae(bp, TSEM_REG_PASSIVE_BUFFER, 3);
5142         bnx2x_read_dmae(bp, USEM_REG_PASSIVE_BUFFER, 3);
5143
5144         bnx2x_init_block(bp, QM_BLOCK, COMMON_STAGE);
5145
5146         if (CHIP_MODE_IS_4_PORT(bp))
5147                 bnx2x_init_block(bp, QM_4PORT_BLOCK, COMMON_STAGE);
5148
5149         /* QM queues pointers table */
5150         bnx2x_qm_init_ptr_table(bp, bp->qm_cid_count, INITOP_SET);
5151
5152         /* soft reset pulse */
5153         REG_WR(bp, QM_REG_SOFT_RESET, 1);
5154         REG_WR(bp, QM_REG_SOFT_RESET, 0);
5155
5156 #ifdef BCM_CNIC
5157         bnx2x_init_block(bp, TIMERS_BLOCK, COMMON_STAGE);
5158 #endif
5159
5160         bnx2x_init_block(bp, DQ_BLOCK, COMMON_STAGE);
5161         REG_WR(bp, DORQ_REG_DPM_CID_OFST, BNX2X_DB_SHIFT);
5162
5163         if (!CHIP_REV_IS_SLOW(bp)) {
5164                 /* enable hw interrupt from doorbell Q */
5165                 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
5166         }
5167
5168         bnx2x_init_block(bp, BRB1_BLOCK, COMMON_STAGE);
5169         if (CHIP_MODE_IS_4_PORT(bp)) {
5170                 REG_WR(bp, BRB1_REG_FULL_LB_XOFF_THRESHOLD, 248);
5171                 REG_WR(bp, BRB1_REG_FULL_LB_XON_THRESHOLD, 328);
5172         }
5173
5174         bnx2x_init_block(bp, PRS_BLOCK, COMMON_STAGE);
5175         REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
5176 #ifndef BCM_CNIC
5177         /* set NIC mode */
5178         REG_WR(bp, PRS_REG_NIC_MODE, 1);
5179 #endif
5180         if (!CHIP_IS_E1(bp))
5181                 REG_WR(bp, PRS_REG_E1HOV_MODE, IS_MF_SD(bp));
5182
5183         if (CHIP_IS_E2(bp)) {
5184                 /* Bit-map indicating which L2 hdrs may appear after the
5185                    basic Ethernet header */
5186                 int has_ovlan = IS_MF_SD(bp);
5187                 REG_WR(bp, PRS_REG_HDRS_AFTER_BASIC, (has_ovlan ? 7 : 6));
5188                 REG_WR(bp, PRS_REG_MUST_HAVE_HDRS, (has_ovlan ? 1 : 0));
5189         }
5190
5191         bnx2x_init_block(bp, TSDM_BLOCK, COMMON_STAGE);
5192         bnx2x_init_block(bp, CSDM_BLOCK, COMMON_STAGE);
5193         bnx2x_init_block(bp, USDM_BLOCK, COMMON_STAGE);
5194         bnx2x_init_block(bp, XSDM_BLOCK, COMMON_STAGE);
5195
5196         bnx2x_init_fill(bp, TSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5197         bnx2x_init_fill(bp, USEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5198         bnx2x_init_fill(bp, CSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5199         bnx2x_init_fill(bp, XSEM_REG_FAST_MEMORY, 0, STORM_INTMEM_SIZE(bp));
5200
5201         bnx2x_init_block(bp, TSEM_BLOCK, COMMON_STAGE);
5202         bnx2x_init_block(bp, USEM_BLOCK, COMMON_STAGE);
5203         bnx2x_init_block(bp, CSEM_BLOCK, COMMON_STAGE);
5204         bnx2x_init_block(bp, XSEM_BLOCK, COMMON_STAGE);
5205
5206         if (CHIP_MODE_IS_4_PORT(bp))
5207                 bnx2x_init_block(bp, XSEM_4PORT_BLOCK, COMMON_STAGE);
5208
5209         /* sync semi rtc */
5210         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
5211                0x80000000);
5212         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
5213                0x80000000);
5214
5215         bnx2x_init_block(bp, UPB_BLOCK, COMMON_STAGE);
5216         bnx2x_init_block(bp, XPB_BLOCK, COMMON_STAGE);
5217         bnx2x_init_block(bp, PBF_BLOCK, COMMON_STAGE);
5218
5219         if (CHIP_IS_E2(bp)) {
5220                 int has_ovlan = IS_MF_SD(bp);
5221                 REG_WR(bp, PBF_REG_HDRS_AFTER_BASIC, (has_ovlan ? 7 : 6));
5222                 REG_WR(bp, PBF_REG_MUST_HAVE_HDRS, (has_ovlan ? 1 : 0));
5223         }
5224
5225         REG_WR(bp, SRC_REG_SOFT_RST, 1);
5226         for (i = SRC_REG_KEYRSS0_0; i <= SRC_REG_KEYRSS1_9; i += 4)
5227                 REG_WR(bp, i, random32());
5228
5229         bnx2x_init_block(bp, SRCH_BLOCK, COMMON_STAGE);
5230 #ifdef BCM_CNIC
5231         REG_WR(bp, SRC_REG_KEYSEARCH_0, 0x63285672);
5232         REG_WR(bp, SRC_REG_KEYSEARCH_1, 0x24b8f2cc);
5233         REG_WR(bp, SRC_REG_KEYSEARCH_2, 0x223aef9b);
5234         REG_WR(bp, SRC_REG_KEYSEARCH_3, 0x26001e3a);
5235         REG_WR(bp, SRC_REG_KEYSEARCH_4, 0x7ae91116);
5236         REG_WR(bp, SRC_REG_KEYSEARCH_5, 0x5ce5230b);
5237         REG_WR(bp, SRC_REG_KEYSEARCH_6, 0x298d8adf);
5238         REG_WR(bp, SRC_REG_KEYSEARCH_7, 0x6eb0ff09);
5239         REG_WR(bp, SRC_REG_KEYSEARCH_8, 0x1830f82f);
5240         REG_WR(bp, SRC_REG_KEYSEARCH_9, 0x01e46be7);
5241 #endif
5242         REG_WR(bp, SRC_REG_SOFT_RST, 0);
5243
5244         if (sizeof(union cdu_context) != 1024)
5245                 /* we currently assume that a context is 1024 bytes */
5246                 dev_alert(&bp->pdev->dev, "please adjust the size "
5247                                           "of cdu_context(%ld)\n",
5248                          (long)sizeof(union cdu_context));
5249
5250         bnx2x_init_block(bp, CDU_BLOCK, COMMON_STAGE);
5251         val = (4 << 24) + (0 << 12) + 1024;
5252         REG_WR(bp, CDU_REG_CDU_GLOBAL_PARAMS, val);
5253
5254         bnx2x_init_block(bp, CFC_BLOCK, COMMON_STAGE);
5255         REG_WR(bp, CFC_REG_INIT_REG, 0x7FF);
5256         /* enable context validation interrupt from CFC */
5257         REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
5258
5259         /* set the thresholds to prevent CFC/CDU race */
5260         REG_WR(bp, CFC_REG_DEBUG0, 0x20020000);
5261
5262         bnx2x_init_block(bp, HC_BLOCK, COMMON_STAGE);
5263
5264         if (CHIP_IS_E2(bp) && BP_NOMCP(bp))
5265                 REG_WR(bp, IGU_REG_RESET_MEMORIES, 0x36);
5266
5267         bnx2x_init_block(bp, IGU_BLOCK, COMMON_STAGE);
5268         bnx2x_init_block(bp, MISC_AEU_BLOCK, COMMON_STAGE);
5269
5270         bnx2x_init_block(bp, PXPCS_BLOCK, COMMON_STAGE);
5271         /* Reset PCIE errors for debug */
5272         REG_WR(bp, 0x2814, 0xffffffff);
5273         REG_WR(bp, 0x3820, 0xffffffff);
5274
5275         if (CHIP_IS_E2(bp)) {
5276                 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_CONTROL_5,
5277                            (PXPCS_TL_CONTROL_5_ERR_UNSPPORT1 |
5278                                 PXPCS_TL_CONTROL_5_ERR_UNSPPORT));
5279                 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_FUNC345_STAT,
5280                            (PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT4 |
5281                                 PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT3 |
5282                                 PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT2));
5283                 REG_WR(bp, PCICFG_OFFSET + PXPCS_TL_FUNC678_STAT,
5284                            (PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT7 |
5285                                 PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT6 |
5286                                 PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT5));
5287         }
5288
5289         bnx2x_init_block(bp, EMAC0_BLOCK, COMMON_STAGE);
5290         bnx2x_init_block(bp, EMAC1_BLOCK, COMMON_STAGE);
5291         bnx2x_init_block(bp, DBU_BLOCK, COMMON_STAGE);
5292         bnx2x_init_block(bp, DBG_BLOCK, COMMON_STAGE);
5293
5294         bnx2x_init_block(bp, NIG_BLOCK, COMMON_STAGE);
5295         if (!CHIP_IS_E1(bp)) {
5296                 REG_WR(bp, NIG_REG_LLH_MF_MODE, IS_MF(bp));
5297                 REG_WR(bp, NIG_REG_LLH_E1HOV_MODE, IS_MF_SD(bp));
5298         }
5299         if (CHIP_IS_E2(bp)) {
5300                 /* Bit-map indicating which L2 hdrs may appear after the
5301                    basic Ethernet header */
5302                 REG_WR(bp, NIG_REG_P0_HDRS_AFTER_BASIC, (IS_MF_SD(bp) ? 7 : 6));
5303         }
5304
5305         if (CHIP_REV_IS_SLOW(bp))
5306                 msleep(200);
5307
5308         /* finish CFC init */
5309         val = reg_poll(bp, CFC_REG_LL_INIT_DONE, 1, 100, 10);
5310         if (val != 1) {
5311                 BNX2X_ERR("CFC LL_INIT failed\n");
5312                 return -EBUSY;
5313         }
5314         val = reg_poll(bp, CFC_REG_AC_INIT_DONE, 1, 100, 10);
5315         if (val != 1) {
5316                 BNX2X_ERR("CFC AC_INIT failed\n");
5317                 return -EBUSY;
5318         }
5319         val = reg_poll(bp, CFC_REG_CAM_INIT_DONE, 1, 100, 10);
5320         if (val != 1) {
5321                 BNX2X_ERR("CFC CAM_INIT failed\n");
5322                 return -EBUSY;
5323         }
5324         REG_WR(bp, CFC_REG_DEBUG0, 0);
5325
5326         if (CHIP_IS_E1(bp)) {
5327                 /* read NIG statistic
5328                    to see if this is our first up since powerup */
5329                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5330                 val = *bnx2x_sp(bp, wb_data[0]);
5331
5332                 /* do internal memory self test */
5333                 if ((val == 0) && bnx2x_int_mem_test(bp)) {
5334                         BNX2X_ERR("internal mem self test failed\n");
5335                         return -EBUSY;
5336                 }
5337         }
5338
5339         bnx2x_setup_fan_failure_detection(bp);
5340
5341         /* clear PXP2 attentions */
5342         REG_RD(bp, PXP2_REG_PXP2_INT_STS_CLR_0);
5343
5344         bnx2x_enable_blocks_attention(bp);
5345         if (CHIP_PARITY_ENABLED(bp))
5346                 bnx2x_enable_blocks_parity(bp);
5347
5348         if (!BP_NOMCP(bp)) {
5349                 /* In E2 2-PORT mode, same ext phy is used for the two paths */
5350                 if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) ||
5351                     CHIP_IS_E1x(bp)) {
5352                         u32 shmem_base[2], shmem2_base[2];
5353                         shmem_base[0] =  bp->common.shmem_base;
5354                         shmem2_base[0] = bp->common.shmem2_base;
5355                         if (CHIP_IS_E2(bp)) {
5356                                 shmem_base[1] =
5357                                         SHMEM2_RD(bp, other_shmem_base_addr);
5358                                 shmem2_base[1] =
5359                                         SHMEM2_RD(bp, other_shmem2_base_addr);
5360                         }
5361                         bnx2x_acquire_phy_lock(bp);
5362                         bnx2x_common_init_phy(bp, shmem_base, shmem2_base,
5363                                               bp->common.chip_id);
5364                         bnx2x_release_phy_lock(bp);
5365                 }
5366         } else
5367                 BNX2X_ERR("Bootcode is missing - can not initialize link\n");
5368
5369         return 0;
5370 }
5371
5372 static int bnx2x_init_hw_port(struct bnx2x *bp)
5373 {
5374         int port = BP_PORT(bp);
5375         int init_stage = port ? PORT1_STAGE : PORT0_STAGE;
5376         u32 low, high;
5377         u32 val;
5378
5379         DP(BNX2X_MSG_MCP, "starting port init  port %d\n", port);
5380
5381         REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
5382
5383         bnx2x_init_block(bp, PXP_BLOCK, init_stage);
5384         bnx2x_init_block(bp, PXP2_BLOCK, init_stage);
5385
5386         /* Timers bug workaround: disables the pf_master bit in pglue at
5387          * common phase, we need to enable it here before any dmae access are
5388          * attempted. Therefore we manually added the enable-master to the
5389          * port phase (it also happens in the function phase)
5390          */
5391         if (CHIP_IS_E2(bp))
5392                 REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
5393
5394         bnx2x_init_block(bp, TCM_BLOCK, init_stage);
5395         bnx2x_init_block(bp, UCM_BLOCK, init_stage);
5396         bnx2x_init_block(bp, CCM_BLOCK, init_stage);
5397         bnx2x_init_block(bp, XCM_BLOCK, init_stage);
5398
5399         /* QM cid (connection) count */
5400         bnx2x_qm_init_cid_count(bp, bp->qm_cid_count, INITOP_SET);
5401
5402 #ifdef BCM_CNIC
5403         bnx2x_init_block(bp, TIMERS_BLOCK, init_stage);
5404         REG_WR(bp, TM_REG_LIN0_SCAN_TIME + port*4, 20);
5405         REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + port*4, 31);
5406 #endif
5407
5408         bnx2x_init_block(bp, DQ_BLOCK, init_stage);
5409
5410         if (CHIP_MODE_IS_4_PORT(bp))
5411                 bnx2x_init_block(bp, QM_4PORT_BLOCK, init_stage);
5412
5413         if (CHIP_IS_E1(bp) || CHIP_IS_E1H(bp)) {
5414                 bnx2x_init_block(bp, BRB1_BLOCK, init_stage);
5415                 if (CHIP_REV_IS_SLOW(bp) && CHIP_IS_E1(bp)) {
5416                         /* no pause for emulation and FPGA */
5417                         low = 0;
5418                         high = 513;
5419                 } else {
5420                         if (IS_MF(bp))
5421                                 low = ((bp->flags & ONE_PORT_FLAG) ? 160 : 246);
5422                         else if (bp->dev->mtu > 4096) {
5423                                 if (bp->flags & ONE_PORT_FLAG)
5424                                         low = 160;
5425                                 else {
5426                                         val = bp->dev->mtu;
5427                                         /* (24*1024 + val*4)/256 */
5428                                         low = 96 + (val/64) +
5429                                                         ((val % 64) ? 1 : 0);
5430                                 }
5431                         } else
5432                                 low = ((bp->flags & ONE_PORT_FLAG) ? 80 : 160);
5433                         high = low + 56;        /* 14*1024/256 */
5434                 }
5435                 REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_0 + port*4, low);
5436                 REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_0 + port*4, high);
5437         }
5438
5439         if (CHIP_MODE_IS_4_PORT(bp)) {
5440                 REG_WR(bp, BRB1_REG_PAUSE_0_XOFF_THRESHOLD_0 + port*8, 248);
5441                 REG_WR(bp, BRB1_REG_PAUSE_0_XON_THRESHOLD_0 + port*8, 328);
5442                 REG_WR(bp, (BP_PORT(bp) ? BRB1_REG_MAC_GUARANTIED_1 :
5443                                           BRB1_REG_MAC_GUARANTIED_0), 40);
5444         }
5445
5446         bnx2x_init_block(bp, PRS_BLOCK, init_stage);
5447
5448         bnx2x_init_block(bp, TSDM_BLOCK, init_stage);
5449         bnx2x_init_block(bp, CSDM_BLOCK, init_stage);
5450         bnx2x_init_block(bp, USDM_BLOCK, init_stage);
5451         bnx2x_init_block(bp, XSDM_BLOCK, init_stage);
5452
5453         bnx2x_init_block(bp, TSEM_BLOCK, init_stage);
5454         bnx2x_init_block(bp, USEM_BLOCK, init_stage);
5455         bnx2x_init_block(bp, CSEM_BLOCK, init_stage);
5456         bnx2x_init_block(bp, XSEM_BLOCK, init_stage);
5457         if (CHIP_MODE_IS_4_PORT(bp))
5458                 bnx2x_init_block(bp, XSEM_4PORT_BLOCK, init_stage);
5459
5460         bnx2x_init_block(bp, UPB_BLOCK, init_stage);
5461         bnx2x_init_block(bp, XPB_BLOCK, init_stage);
5462
5463         bnx2x_init_block(bp, PBF_BLOCK, init_stage);
5464
5465         if (!CHIP_IS_E2(bp)) {
5466                 /* configure PBF to work without PAUSE mtu 9000 */
5467                 REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
5468
5469                 /* update threshold */
5470                 REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, (9040/16));
5471                 /* update init credit */
5472                 REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, (9040/16) + 553 - 22);
5473
5474                 /* probe changes */
5475                 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 1);
5476                 udelay(50);
5477                 REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0);
5478         }
5479
5480 #ifdef BCM_CNIC
5481         bnx2x_init_block(bp, SRCH_BLOCK, init_stage);
5482 #endif
5483         bnx2x_init_block(bp, CDU_BLOCK, init_stage);
5484         bnx2x_init_block(bp, CFC_BLOCK, init_stage);
5485
5486         if (CHIP_IS_E1(bp)) {
5487                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5488                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5489         }
5490         bnx2x_init_block(bp, HC_BLOCK, init_stage);
5491
5492         bnx2x_init_block(bp, IGU_BLOCK, init_stage);
5493
5494         bnx2x_init_block(bp, MISC_AEU_BLOCK, init_stage);
5495         /* init aeu_mask_attn_func_0/1:
5496          *  - SF mode: bits 3-7 are masked. only bits 0-2 are in use
5497          *  - MF mode: bit 3 is masked. bits 0-2 are in use as in SF
5498          *             bits 4-7 are used for "per vn group attention" */
5499         val = IS_MF(bp) ? 0xF7 : 0x7;
5500         /* Enable DCBX attention for all but E1 */
5501         val |= CHIP_IS_E1(bp) ? 0 : 0x10;
5502         REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, val);
5503
5504         bnx2x_init_block(bp, PXPCS_BLOCK, init_stage);
5505         bnx2x_init_block(bp, EMAC0_BLOCK, init_stage);
5506         bnx2x_init_block(bp, EMAC1_BLOCK, init_stage);
5507         bnx2x_init_block(bp, DBU_BLOCK, init_stage);
5508         bnx2x_init_block(bp, DBG_BLOCK, init_stage);
5509
5510         bnx2x_init_block(bp, NIG_BLOCK, init_stage);
5511
5512         REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
5513
5514         if (!CHIP_IS_E1(bp)) {
5515                 /* 0x2 disable mf_ov, 0x1 enable */
5516                 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK_MF + port*4,
5517                        (IS_MF_SD(bp) ? 0x1 : 0x2));
5518
5519                 if (CHIP_IS_E2(bp)) {
5520                         val = 0;
5521                         switch (bp->mf_mode) {
5522                         case MULTI_FUNCTION_SD:
5523                                 val = 1;
5524                                 break;
5525                         case MULTI_FUNCTION_SI:
5526                                 val = 2;
5527                                 break;
5528                         }
5529
5530                         REG_WR(bp, (BP_PORT(bp) ? NIG_REG_LLH1_CLS_TYPE :
5531                                                   NIG_REG_LLH0_CLS_TYPE), val);
5532                 }
5533                 {
5534                         REG_WR(bp, NIG_REG_LLFC_ENABLE_0 + port*4, 0);
5535                         REG_WR(bp, NIG_REG_LLFC_OUT_EN_0 + port*4, 0);
5536                         REG_WR(bp, NIG_REG_PAUSE_ENABLE_0 + port*4, 1);
5537                 }
5538         }
5539
5540         bnx2x_init_block(bp, MCP_BLOCK, init_stage);
5541         bnx2x_init_block(bp, DMAE_BLOCK, init_stage);
5542         if (bnx2x_fan_failure_det_req(bp, bp->common.shmem_base,
5543                                       bp->common.shmem2_base, port)) {
5544                 u32 reg_addr = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
5545                                        MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
5546                 val = REG_RD(bp, reg_addr);
5547                 val |= AEU_INPUTS_ATTN_BITS_SPIO5;
5548                 REG_WR(bp, reg_addr, val);
5549         }
5550         bnx2x__link_reset(bp);
5551
5552         return 0;
5553 }
5554
5555 static void bnx2x_ilt_wr(struct bnx2x *bp, u32 index, dma_addr_t addr)
5556 {
5557         int reg;
5558
5559         if (CHIP_IS_E1(bp))
5560                 reg = PXP2_REG_RQ_ONCHIP_AT + index*8;
5561         else
5562                 reg = PXP2_REG_RQ_ONCHIP_AT_B0 + index*8;
5563
5564         bnx2x_wb_wr(bp, reg, ONCHIP_ADDR1(addr), ONCHIP_ADDR2(addr));
5565 }
5566
5567 static inline void bnx2x_igu_clear_sb(struct bnx2x *bp, u8 idu_sb_id)
5568 {
5569         bnx2x_igu_clear_sb_gen(bp, idu_sb_id, true /*PF*/);
5570 }
5571
5572 static inline void bnx2x_clear_func_ilt(struct bnx2x *bp, u32 func)
5573 {
5574         u32 i, base = FUNC_ILT_BASE(func);
5575         for (i = base; i < base + ILT_PER_FUNC; i++)
5576                 bnx2x_ilt_wr(bp, i, 0);
5577 }
5578
5579 static int bnx2x_init_hw_func(struct bnx2x *bp)
5580 {
5581         int port = BP_PORT(bp);
5582         int func = BP_FUNC(bp);
5583         struct bnx2x_ilt *ilt = BP_ILT(bp);
5584         u16 cdu_ilt_start;
5585         u32 addr, val;
5586         u32 main_mem_base, main_mem_size, main_mem_prty_clr;
5587         int i, main_mem_width;
5588
5589         DP(BNX2X_MSG_MCP, "starting func init  func %d\n", func);
5590
5591         /* set MSI reconfigure capability */
5592         if (bp->common.int_block == INT_BLOCK_HC) {
5593                 addr = (port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0);
5594                 val = REG_RD(bp, addr);
5595                 val |= HC_CONFIG_0_REG_MSI_ATTN_EN_0;
5596                 REG_WR(bp, addr, val);
5597         }
5598
5599         ilt = BP_ILT(bp);
5600         cdu_ilt_start = ilt->clients[ILT_CLIENT_CDU].start;
5601
5602         for (i = 0; i < L2_ILT_LINES(bp); i++) {
5603                 ilt->lines[cdu_ilt_start + i].page =
5604                         bp->context.vcxt + (ILT_PAGE_CIDS * i);
5605                 ilt->lines[cdu_ilt_start + i].page_mapping =
5606                         bp->context.cxt_mapping + (CDU_ILT_PAGE_SZ * i);
5607                 /* cdu ilt pages are allocated manually so there's no need to
5608                 set the size */
5609         }
5610         bnx2x_ilt_init_op(bp, INITOP_SET);
5611
5612 #ifdef BCM_CNIC
5613         bnx2x_src_init_t2(bp, bp->t2, bp->t2_mapping, SRC_CONN_NUM);
5614
5615         /* T1 hash bits value determines the T1 number of entries */
5616         REG_WR(bp, SRC_REG_NUMBER_HASH_BITS0 + port*4, SRC_HASH_BITS);
5617 #endif
5618
5619 #ifndef BCM_CNIC
5620         /* set NIC mode */
5621         REG_WR(bp, PRS_REG_NIC_MODE, 1);
5622 #endif  /* BCM_CNIC */
5623
5624         if (CHIP_IS_E2(bp)) {
5625                 u32 pf_conf = IGU_PF_CONF_FUNC_EN;
5626
5627                 /* Turn on a single ISR mode in IGU if driver is going to use
5628                  * INT#x or MSI
5629                  */
5630                 if (!(bp->flags & USING_MSIX_FLAG))
5631                         pf_conf |= IGU_PF_CONF_SINGLE_ISR_EN;
5632                 /*
5633                  * Timers workaround bug: function init part.
5634                  * Need to wait 20msec after initializing ILT,
5635                  * needed to make sure there are no requests in
5636                  * one of the PXP internal queues with "old" ILT addresses
5637                  */
5638                 msleep(20);
5639                 /*
5640                  * Master enable - Due to WB DMAE writes performed before this
5641                  * register is re-initialized as part of the regular function
5642                  * init
5643                  */
5644                 REG_WR(bp, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
5645                 /* Enable the function in IGU */
5646                 REG_WR(bp, IGU_REG_PF_CONFIGURATION, pf_conf);
5647         }
5648
5649         bp->dmae_ready = 1;
5650
5651         bnx2x_init_block(bp, PGLUE_B_BLOCK, FUNC0_STAGE + func);
5652
5653         if (CHIP_IS_E2(bp))
5654                 REG_WR(bp, PGLUE_B_REG_WAS_ERROR_PF_7_0_CLR, func);
5655
5656         bnx2x_init_block(bp, MISC_BLOCK, FUNC0_STAGE + func);
5657         bnx2x_init_block(bp, TCM_BLOCK, FUNC0_STAGE + func);
5658         bnx2x_init_block(bp, UCM_BLOCK, FUNC0_STAGE + func);
5659         bnx2x_init_block(bp, CCM_BLOCK, FUNC0_STAGE + func);
5660         bnx2x_init_block(bp, XCM_BLOCK, FUNC0_STAGE + func);
5661         bnx2x_init_block(bp, TSEM_BLOCK, FUNC0_STAGE + func);
5662         bnx2x_init_block(bp, USEM_BLOCK, FUNC0_STAGE + func);
5663         bnx2x_init_block(bp, CSEM_BLOCK, FUNC0_STAGE + func);
5664         bnx2x_init_block(bp, XSEM_BLOCK, FUNC0_STAGE + func);
5665
5666         if (CHIP_IS_E2(bp)) {
5667                 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_PATH_ID_OFFSET,
5668                                                                 BP_PATH(bp));
5669                 REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_PATH_ID_OFFSET,
5670                                                                 BP_PATH(bp));
5671         }
5672
5673         if (CHIP_MODE_IS_4_PORT(bp))
5674                 bnx2x_init_block(bp, XSEM_4PORT_BLOCK, FUNC0_STAGE + func);
5675
5676         if (CHIP_IS_E2(bp))
5677                 REG_WR(bp, QM_REG_PF_EN, 1);
5678
5679         bnx2x_init_block(bp, QM_BLOCK, FUNC0_STAGE + func);
5680
5681         if (CHIP_MODE_IS_4_PORT(bp))
5682                 bnx2x_init_block(bp, QM_4PORT_BLOCK, FUNC0_STAGE + func);
5683
5684         bnx2x_init_block(bp, TIMERS_BLOCK, FUNC0_STAGE + func);
5685         bnx2x_init_block(bp, DQ_BLOCK, FUNC0_STAGE + func);
5686         bnx2x_init_block(bp, BRB1_BLOCK, FUNC0_STAGE + func);
5687         bnx2x_init_block(bp, PRS_BLOCK, FUNC0_STAGE + func);
5688         bnx2x_init_block(bp, TSDM_BLOCK, FUNC0_STAGE + func);
5689         bnx2x_init_block(bp, CSDM_BLOCK, FUNC0_STAGE + func);
5690         bnx2x_init_block(bp, USDM_BLOCK, FUNC0_STAGE + func);
5691         bnx2x_init_block(bp, XSDM_BLOCK, FUNC0_STAGE + func);
5692         bnx2x_init_block(bp, UPB_BLOCK, FUNC0_STAGE + func);
5693         bnx2x_init_block(bp, XPB_BLOCK, FUNC0_STAGE + func);
5694         bnx2x_init_block(bp, PBF_BLOCK, FUNC0_STAGE + func);
5695         if (CHIP_IS_E2(bp))
5696                 REG_WR(bp, PBF_REG_DISABLE_PF, 0);
5697
5698         bnx2x_init_block(bp, CDU_BLOCK, FUNC0_STAGE + func);
5699
5700         bnx2x_init_block(bp, CFC_BLOCK, FUNC0_STAGE + func);
5701
5702         if (CHIP_IS_E2(bp))
5703                 REG_WR(bp, CFC_REG_WEAK_ENABLE_PF, 1);
5704
5705         if (IS_MF(bp)) {
5706                 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
5707                 REG_WR(bp, NIG_REG_LLH0_FUNC_VLAN_ID + port*8, bp->mf_ov);
5708         }
5709
5710         bnx2x_init_block(bp, MISC_AEU_BLOCK, FUNC0_STAGE + func);
5711
5712         /* HC init per function */
5713         if (bp->common.int_block == INT_BLOCK_HC) {
5714                 if (CHIP_IS_E1H(bp)) {
5715                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
5716
5717                         REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5718                         REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5719                 }
5720                 bnx2x_init_block(bp, HC_BLOCK, FUNC0_STAGE + func);
5721
5722         } else {
5723                 int num_segs, sb_idx, prod_offset;
5724
5725                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
5726
5727                 if (CHIP_IS_E2(bp)) {
5728                         REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, 0);
5729                         REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, 0);
5730                 }
5731
5732                 bnx2x_init_block(bp, IGU_BLOCK, FUNC0_STAGE + func);
5733
5734                 if (CHIP_IS_E2(bp)) {
5735                         int dsb_idx = 0;
5736                         /**
5737                          * Producer memory:
5738                          * E2 mode: address 0-135 match to the mapping memory;
5739                          * 136 - PF0 default prod; 137 - PF1 default prod;
5740                          * 138 - PF2 default prod; 139 - PF3 default prod;
5741                          * 140 - PF0 attn prod;    141 - PF1 attn prod;
5742                          * 142 - PF2 attn prod;    143 - PF3 attn prod;
5743                          * 144-147 reserved.
5744                          *
5745                          * E1.5 mode - In backward compatible mode;
5746                          * for non default SB; each even line in the memory
5747                          * holds the U producer and each odd line hold
5748                          * the C producer. The first 128 producers are for
5749                          * NDSB (PF0 - 0-31; PF1 - 32-63 and so on). The last 20
5750                          * producers are for the DSB for each PF.
5751                          * Each PF has five segments: (the order inside each
5752                          * segment is PF0; PF1; PF2; PF3) - 128-131 U prods;
5753                          * 132-135 C prods; 136-139 X prods; 140-143 T prods;
5754                          * 144-147 attn prods;
5755                          */
5756                         /* non-default-status-blocks */
5757                         num_segs = CHIP_INT_MODE_IS_BC(bp) ?
5758                                 IGU_BC_NDSB_NUM_SEGS : IGU_NORM_NDSB_NUM_SEGS;
5759                         for (sb_idx = 0; sb_idx < bp->igu_sb_cnt; sb_idx++) {
5760                                 prod_offset = (bp->igu_base_sb + sb_idx) *
5761                                         num_segs;
5762
5763                                 for (i = 0; i < num_segs; i++) {
5764                                         addr = IGU_REG_PROD_CONS_MEMORY +
5765                                                         (prod_offset + i) * 4;
5766                                         REG_WR(bp, addr, 0);
5767                                 }
5768                                 /* send consumer update with value 0 */
5769                                 bnx2x_ack_sb(bp, bp->igu_base_sb + sb_idx,
5770                                              USTORM_ID, 0, IGU_INT_NOP, 1);
5771                                 bnx2x_igu_clear_sb(bp,
5772                                                    bp->igu_base_sb + sb_idx);
5773                         }
5774
5775                         /* default-status-blocks */
5776                         num_segs = CHIP_INT_MODE_IS_BC(bp) ?
5777                                 IGU_BC_DSB_NUM_SEGS : IGU_NORM_DSB_NUM_SEGS;
5778
5779                         if (CHIP_MODE_IS_4_PORT(bp))
5780                                 dsb_idx = BP_FUNC(bp);
5781                         else
5782                                 dsb_idx = BP_E1HVN(bp);
5783
5784                         prod_offset = (CHIP_INT_MODE_IS_BC(bp) ?
5785                                        IGU_BC_BASE_DSB_PROD + dsb_idx :
5786                                        IGU_NORM_BASE_DSB_PROD + dsb_idx);
5787
5788                         for (i = 0; i < (num_segs * E1HVN_MAX);
5789                              i += E1HVN_MAX) {
5790                                 addr = IGU_REG_PROD_CONS_MEMORY +
5791                                                         (prod_offset + i)*4;
5792                                 REG_WR(bp, addr, 0);
5793                         }
5794                         /* send consumer update with 0 */
5795                         if (CHIP_INT_MODE_IS_BC(bp)) {
5796                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5797                                              USTORM_ID, 0, IGU_INT_NOP, 1);
5798                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5799                                              CSTORM_ID, 0, IGU_INT_NOP, 1);
5800                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5801                                              XSTORM_ID, 0, IGU_INT_NOP, 1);
5802                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5803                                              TSTORM_ID, 0, IGU_INT_NOP, 1);
5804                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5805                                              ATTENTION_ID, 0, IGU_INT_NOP, 1);
5806                         } else {
5807                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5808                                              USTORM_ID, 0, IGU_INT_NOP, 1);
5809                                 bnx2x_ack_sb(bp, bp->igu_dsb_id,
5810                                              ATTENTION_ID, 0, IGU_INT_NOP, 1);
5811                         }
5812                         bnx2x_igu_clear_sb(bp, bp->igu_dsb_id);
5813
5814                         /* !!! these should become driver const once
5815                            rf-tool supports split-68 const */
5816                         REG_WR(bp, IGU_REG_SB_INT_BEFORE_MASK_LSB, 0);
5817                         REG_WR(bp, IGU_REG_SB_INT_BEFORE_MASK_MSB, 0);
5818                         REG_WR(bp, IGU_REG_SB_MASK_LSB, 0);
5819                         REG_WR(bp, IGU_REG_SB_MASK_MSB, 0);
5820                         REG_WR(bp, IGU_REG_PBA_STATUS_LSB, 0);
5821                         REG_WR(bp, IGU_REG_PBA_STATUS_MSB, 0);
5822                 }
5823         }
5824
5825         /* Reset PCIE errors for debug */
5826         REG_WR(bp, 0x2114, 0xffffffff);
5827         REG_WR(bp, 0x2120, 0xffffffff);
5828
5829         bnx2x_init_block(bp, EMAC0_BLOCK, FUNC0_STAGE + func);
5830         bnx2x_init_block(bp, EMAC1_BLOCK, FUNC0_STAGE + func);
5831         bnx2x_init_block(bp, DBU_BLOCK, FUNC0_STAGE + func);
5832         bnx2x_init_block(bp, DBG_BLOCK, FUNC0_STAGE + func);
5833         bnx2x_init_block(bp, MCP_BLOCK, FUNC0_STAGE + func);
5834         bnx2x_init_block(bp, DMAE_BLOCK, FUNC0_STAGE + func);
5835
5836         if (CHIP_IS_E1x(bp)) {
5837                 main_mem_size = HC_REG_MAIN_MEMORY_SIZE / 2; /*dwords*/
5838                 main_mem_base = HC_REG_MAIN_MEMORY +
5839                                 BP_PORT(bp) * (main_mem_size * 4);
5840                 main_mem_prty_clr = HC_REG_HC_PRTY_STS_CLR;
5841                 main_mem_width = 8;
5842
5843                 val = REG_RD(bp, main_mem_prty_clr);
5844                 if (val)
5845                         DP(BNX2X_MSG_MCP, "Hmmm... Parity errors in HC "
5846                                           "block during "
5847                                           "function init (0x%x)!\n", val);
5848
5849                 /* Clear "false" parity errors in MSI-X table */
5850                 for (i = main_mem_base;
5851                      i < main_mem_base + main_mem_size * 4;
5852                      i += main_mem_width) {
5853                         bnx2x_read_dmae(bp, i, main_mem_width / 4);
5854                         bnx2x_write_dmae(bp, bnx2x_sp_mapping(bp, wb_data),
5855                                          i, main_mem_width / 4);
5856                 }
5857                 /* Clear HC parity attention */
5858                 REG_RD(bp, main_mem_prty_clr);
5859         }
5860
5861         bnx2x_phy_probe(&bp->link_params);
5862
5863         return 0;
5864 }
5865
5866 int bnx2x_init_hw(struct bnx2x *bp, u32 load_code)
5867 {
5868         int rc = 0;
5869
5870         DP(BNX2X_MSG_MCP, "function %d  load_code %x\n",
5871            BP_ABS_FUNC(bp), load_code);
5872
5873         bp->dmae_ready = 0;
5874         spin_lock_init(&bp->dmae_lock);
5875
5876         switch (load_code) {
5877         case FW_MSG_CODE_DRV_LOAD_COMMON:
5878         case FW_MSG_CODE_DRV_LOAD_COMMON_CHIP:
5879                 rc = bnx2x_init_hw_common(bp, load_code);
5880                 if (rc)
5881                         goto init_hw_err;
5882                 /* no break */
5883
5884         case FW_MSG_CODE_DRV_LOAD_PORT:
5885                 rc = bnx2x_init_hw_port(bp);
5886                 if (rc)
5887                         goto init_hw_err;
5888                 /* no break */
5889
5890         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
5891                 rc = bnx2x_init_hw_func(bp);
5892                 if (rc)
5893                         goto init_hw_err;
5894                 break;
5895
5896         default:
5897                 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
5898                 break;
5899         }
5900
5901         if (!BP_NOMCP(bp)) {
5902                 int mb_idx = BP_FW_MB_IDX(bp);
5903
5904                 bp->fw_drv_pulse_wr_seq =
5905                                 (SHMEM_RD(bp, func_mb[mb_idx].drv_pulse_mb) &
5906                                  DRV_PULSE_SEQ_MASK);
5907                 DP(BNX2X_MSG_MCP, "drv_pulse 0x%x\n", bp->fw_drv_pulse_wr_seq);
5908         }
5909
5910 init_hw_err:
5911         bnx2x_gunzip_end(bp);
5912
5913         return rc;
5914 }
5915
5916 void bnx2x_free_mem(struct bnx2x *bp)
5917 {
5918         bnx2x_gunzip_end(bp);
5919
5920         /* fastpath */
5921         bnx2x_free_fp_mem(bp);
5922         /* end of fastpath */
5923
5924         BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
5925                        sizeof(struct host_sp_status_block));
5926
5927         BNX2X_PCI_FREE(bp->slowpath, bp->slowpath_mapping,
5928                        sizeof(struct bnx2x_slowpath));
5929
5930         BNX2X_PCI_FREE(bp->context.vcxt, bp->context.cxt_mapping,
5931                        bp->context.size);
5932
5933         bnx2x_ilt_mem_op(bp, ILT_MEMOP_FREE);
5934
5935         BNX2X_FREE(bp->ilt->lines);
5936
5937 #ifdef BCM_CNIC
5938         if (CHIP_IS_E2(bp))
5939                 BNX2X_PCI_FREE(bp->cnic_sb.e2_sb, bp->cnic_sb_mapping,
5940                                sizeof(struct host_hc_status_block_e2));
5941         else
5942                 BNX2X_PCI_FREE(bp->cnic_sb.e1x_sb, bp->cnic_sb_mapping,
5943                                sizeof(struct host_hc_status_block_e1x));
5944
5945         BNX2X_PCI_FREE(bp->t2, bp->t2_mapping, SRC_T2_SZ);
5946 #endif
5947
5948         BNX2X_PCI_FREE(bp->spq, bp->spq_mapping, BCM_PAGE_SIZE);
5949
5950         BNX2X_PCI_FREE(bp->eq_ring, bp->eq_mapping,
5951                        BCM_PAGE_SIZE * NUM_EQ_PAGES);
5952
5953         BNX2X_FREE(bp->rx_indir_table);
5954 }
5955
5956
5957 int bnx2x_alloc_mem(struct bnx2x *bp)
5958 {
5959         if (bnx2x_gunzip_init(bp))
5960                 return -ENOMEM;
5961
5962 #ifdef BCM_CNIC
5963         if (CHIP_IS_E2(bp))
5964                 BNX2X_PCI_ALLOC(bp->cnic_sb.e2_sb, &bp->cnic_sb_mapping,
5965                                 sizeof(struct host_hc_status_block_e2));
5966         else
5967                 BNX2X_PCI_ALLOC(bp->cnic_sb.e1x_sb, &bp->cnic_sb_mapping,
5968                                 sizeof(struct host_hc_status_block_e1x));
5969
5970         /* allocate searcher T2 table */
5971         BNX2X_PCI_ALLOC(bp->t2, &bp->t2_mapping, SRC_T2_SZ);
5972 #endif
5973
5974
5975         BNX2X_PCI_ALLOC(bp->def_status_blk, &bp->def_status_blk_mapping,
5976                         sizeof(struct host_sp_status_block));
5977
5978         BNX2X_PCI_ALLOC(bp->slowpath, &bp->slowpath_mapping,
5979                         sizeof(struct bnx2x_slowpath));
5980
5981         bp->context.size = sizeof(union cdu_context) * bp->l2_cid_count;
5982
5983         BNX2X_PCI_ALLOC(bp->context.vcxt, &bp->context.cxt_mapping,
5984                         bp->context.size);
5985
5986         BNX2X_ALLOC(bp->ilt->lines, sizeof(struct ilt_line) * ILT_MAX_LINES);
5987
5988         if (bnx2x_ilt_mem_op(bp, ILT_MEMOP_ALLOC))
5989                 goto alloc_mem_err;
5990
5991         /* Slow path ring */
5992         BNX2X_PCI_ALLOC(bp->spq, &bp->spq_mapping, BCM_PAGE_SIZE);
5993
5994         /* EQ */
5995         BNX2X_PCI_ALLOC(bp->eq_ring, &bp->eq_mapping,
5996                         BCM_PAGE_SIZE * NUM_EQ_PAGES);
5997
5998         BNX2X_ALLOC(bp->rx_indir_table, sizeof(bp->rx_indir_table[0]) *
5999                     TSTORM_INDIRECTION_TABLE_SIZE);
6000
6001         /* fastpath */
6002         /* need to be done at the end, since it's self adjusting to amount
6003          * of memory available for RSS queues
6004          */
6005         if (bnx2x_alloc_fp_mem(bp))
6006                 goto alloc_mem_err;
6007         return 0;
6008
6009 alloc_mem_err:
6010         bnx2x_free_mem(bp);
6011         return -ENOMEM;
6012 }
6013
6014 /*
6015  * Init service functions
6016  */
6017 static int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
6018                              int *state_p, int flags);
6019
6020 int bnx2x_func_start(struct bnx2x *bp)
6021 {
6022         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_START, 0, 0, 0, 1);
6023
6024         /* Wait for completion */
6025         return bnx2x_wait_ramrod(bp, BNX2X_STATE_FUNC_STARTED, 0, &(bp->state),
6026                                  WAIT_RAMROD_COMMON);
6027 }
6028
6029 static int bnx2x_func_stop(struct bnx2x *bp)
6030 {
6031         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_FUNCTION_STOP, 0, 0, 0, 1);
6032
6033         /* Wait for completion */
6034         return bnx2x_wait_ramrod(bp, BNX2X_STATE_CLOSING_WAIT4_UNLOAD,
6035                                       0, &(bp->state), WAIT_RAMROD_COMMON);
6036 }
6037
6038 /**
6039  * bnx2x_set_mac_addr_gen - set a MAC in a CAM for a few L2 Clients for E1x chips
6040  *
6041  * @bp:         driver handle
6042  * @set:        set or clear an entry (1 or 0)
6043  * @mac:        pointer to a buffer containing a MAC
6044  * @cl_bit_vec: bit vector of clients to register a MAC for
6045  * @cam_offset: offset in a CAM to use
6046  * @is_bcast:   is the set MAC a broadcast address (for E1 only)
6047  */
6048 static void bnx2x_set_mac_addr_gen(struct bnx2x *bp, int set, const u8 *mac,
6049                                    u32 cl_bit_vec, u8 cam_offset,
6050                                    u8 is_bcast)
6051 {
6052         struct mac_configuration_cmd *config =
6053                 (struct mac_configuration_cmd *)bnx2x_sp(bp, mac_config);
6054         int ramrod_flags = WAIT_RAMROD_COMMON;
6055
6056         bp->set_mac_pending = 1;
6057
6058         config->hdr.length = 1;
6059         config->hdr.offset = cam_offset;
6060         config->hdr.client_id = 0xff;
6061         /* Mark the single MAC configuration ramrod as opposed to a
6062          * UC/MC list configuration).
6063          */
6064         config->hdr.echo = 1;
6065
6066         /* primary MAC */
6067         config->config_table[0].msb_mac_addr =
6068                                         swab16(*(u16 *)&mac[0]);
6069         config->config_table[0].middle_mac_addr =
6070                                         swab16(*(u16 *)&mac[2]);
6071         config->config_table[0].lsb_mac_addr =
6072                                         swab16(*(u16 *)&mac[4]);
6073         config->config_table[0].clients_bit_vector =
6074                                         cpu_to_le32(cl_bit_vec);
6075         config->config_table[0].vlan_id = 0;
6076         config->config_table[0].pf_id = BP_FUNC(bp);
6077         if (set)
6078                 SET_FLAG(config->config_table[0].flags,
6079                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6080                         T_ETH_MAC_COMMAND_SET);
6081         else
6082                 SET_FLAG(config->config_table[0].flags,
6083                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6084                         T_ETH_MAC_COMMAND_INVALIDATE);
6085
6086         if (is_bcast)
6087                 SET_FLAG(config->config_table[0].flags,
6088                         MAC_CONFIGURATION_ENTRY_BROADCAST, 1);
6089
6090         DP(NETIF_MSG_IFUP, "%s MAC (%04x:%04x:%04x)  PF_ID %d  CLID mask %d\n",
6091            (set ? "setting" : "clearing"),
6092            config->config_table[0].msb_mac_addr,
6093            config->config_table[0].middle_mac_addr,
6094            config->config_table[0].lsb_mac_addr, BP_FUNC(bp), cl_bit_vec);
6095
6096         mb();
6097
6098         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
6099                       U64_HI(bnx2x_sp_mapping(bp, mac_config)),
6100                       U64_LO(bnx2x_sp_mapping(bp, mac_config)), 1);
6101
6102         /* Wait for a completion */
6103         bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending, ramrod_flags);
6104 }
6105
6106 static int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
6107                              int *state_p, int flags)
6108 {
6109         /* can take a while if any port is running */
6110         int cnt = 5000;
6111         u8 poll = flags & WAIT_RAMROD_POLL;
6112         u8 common = flags & WAIT_RAMROD_COMMON;
6113
6114         DP(NETIF_MSG_IFUP, "%s for state to become %x on IDX [%d]\n",
6115            poll ? "polling" : "waiting", state, idx);
6116
6117         might_sleep();
6118         while (cnt--) {
6119                 if (poll) {
6120                         if (common)
6121                                 bnx2x_eq_int(bp);
6122                         else {
6123                                 bnx2x_rx_int(bp->fp, 10);
6124                                 /* if index is different from 0
6125                                  * the reply for some commands will
6126                                  * be on the non default queue
6127                                  */
6128                                 if (idx)
6129                                         bnx2x_rx_int(&bp->fp[idx], 10);
6130                         }
6131                 }
6132
6133                 mb(); /* state is changed by bnx2x_sp_event() */
6134                 if (*state_p == state) {
6135 #ifdef BNX2X_STOP_ON_ERROR
6136                         DP(NETIF_MSG_IFUP, "exit  (cnt %d)\n", 5000 - cnt);
6137 #endif
6138                         return 0;
6139                 }
6140
6141                 msleep(1);
6142
6143                 if (bp->panic)
6144                         return -EIO;
6145         }
6146
6147         /* timeout! */
6148         BNX2X_ERR("timeout %s for state %x on IDX [%d]\n",
6149                   poll ? "polling" : "waiting", state, idx);
6150 #ifdef BNX2X_STOP_ON_ERROR
6151         bnx2x_panic();
6152 #endif
6153
6154         return -EBUSY;
6155 }
6156
6157 static u8 bnx2x_e1h_cam_offset(struct bnx2x *bp, u8 rel_offset)
6158 {
6159         if (CHIP_IS_E1H(bp))
6160                 return E1H_FUNC_MAX * rel_offset + BP_FUNC(bp);
6161         else if (CHIP_MODE_IS_4_PORT(bp))
6162                 return E2_FUNC_MAX * rel_offset + BP_FUNC(bp);
6163         else
6164                 return E2_FUNC_MAX * rel_offset + BP_VN(bp);
6165 }
6166
6167 /**
6168  *  LLH CAM line allocations: currently only iSCSI and ETH macs are
6169  *  relevant. In addition, current implementation is tuned for a
6170  *  single ETH MAC.
6171  */
6172 enum {
6173         LLH_CAM_ISCSI_ETH_LINE = 0,
6174         LLH_CAM_ETH_LINE,
6175         LLH_CAM_MAX_PF_LINE = NIG_REG_LLH1_FUNC_MEM_SIZE
6176 };
6177
6178 static void bnx2x_set_mac_in_nig(struct bnx2x *bp,
6179                           int set,
6180                           unsigned char *dev_addr,
6181                           int index)
6182 {
6183         u32 wb_data[2];
6184         u32 mem_offset, ena_offset, mem_index;
6185         /**
6186          * indexes mapping:
6187          * 0..7 - goes to MEM
6188          * 8..15 - goes to MEM2
6189          */
6190
6191         if (!IS_MF_SI(bp) || index > LLH_CAM_MAX_PF_LINE)
6192                 return;
6193
6194         /* calculate memory start offset according to the mapping
6195          * and index in the memory */
6196         if (index < NIG_LLH_FUNC_MEM_MAX_OFFSET) {
6197                 mem_offset = BP_PORT(bp) ? NIG_REG_LLH1_FUNC_MEM :
6198                                            NIG_REG_LLH0_FUNC_MEM;
6199                 ena_offset = BP_PORT(bp) ? NIG_REG_LLH1_FUNC_MEM_ENABLE :
6200                                            NIG_REG_LLH0_FUNC_MEM_ENABLE;
6201                 mem_index = index;
6202         } else {
6203                 mem_offset = BP_PORT(bp) ? NIG_REG_P1_LLH_FUNC_MEM2 :
6204                                            NIG_REG_P0_LLH_FUNC_MEM2;
6205                 ena_offset = BP_PORT(bp) ? NIG_REG_P1_LLH_FUNC_MEM2_ENABLE :
6206                                            NIG_REG_P0_LLH_FUNC_MEM2_ENABLE;
6207                 mem_index = index - NIG_LLH_FUNC_MEM_MAX_OFFSET;
6208         }
6209
6210         if (set) {
6211                 /* LLH_FUNC_MEM is a u64 WB register */
6212                 mem_offset += 8*mem_index;
6213
6214                 wb_data[0] = ((dev_addr[2] << 24) | (dev_addr[3] << 16) |
6215                               (dev_addr[4] <<  8) |  dev_addr[5]);
6216                 wb_data[1] = ((dev_addr[0] <<  8) |  dev_addr[1]);
6217
6218                 REG_WR_DMAE(bp, mem_offset, wb_data, 2);
6219         }
6220
6221         /* enable/disable the entry */
6222         REG_WR(bp, ena_offset + 4*mem_index, set);
6223
6224 }
6225
6226 void bnx2x_set_eth_mac(struct bnx2x *bp, int set)
6227 {
6228         u8 cam_offset = (CHIP_IS_E1(bp) ? (BP_PORT(bp) ? 32 : 0) :
6229                          bnx2x_e1h_cam_offset(bp, CAM_ETH_LINE));
6230
6231         /* networking  MAC */
6232         bnx2x_set_mac_addr_gen(bp, set, bp->dev->dev_addr,
6233                                (1 << bp->fp->cl_id), cam_offset , 0);
6234
6235         bnx2x_set_mac_in_nig(bp, set, bp->dev->dev_addr, LLH_CAM_ETH_LINE);
6236
6237         if (CHIP_IS_E1(bp)) {
6238                 /* broadcast MAC */
6239                 static const u8 bcast[ETH_ALEN] = {
6240                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
6241                 };
6242                 bnx2x_set_mac_addr_gen(bp, set, bcast, 0, cam_offset + 1, 1);
6243         }
6244 }
6245
6246 static inline u8 bnx2x_e1_cam_mc_offset(struct bnx2x *bp)
6247 {
6248         return CHIP_REV_IS_SLOW(bp) ?
6249                 (BNX2X_MAX_EMUL_MULTI * (1 + BP_PORT(bp))) :
6250                 (BNX2X_MAX_MULTICAST * (1 + BP_PORT(bp)));
6251 }
6252
6253 /* set mc list, do not wait as wait implies sleep and
6254  * set_rx_mode can be invoked from non-sleepable context.
6255  *
6256  * Instead we use the same ramrod data buffer each time we need
6257  * to configure a list of addresses, and use the fact that the
6258  * list of MACs is changed in an incremental way and that the
6259  * function is called under the netif_addr_lock. A temporary
6260  * inconsistent CAM configuration (possible in case of a very fast
6261  * sequence of add/del/add on the host side) will shortly be
6262  * restored by the handler of the last ramrod.
6263  */
6264 static int bnx2x_set_e1_mc_list(struct bnx2x *bp)
6265 {
6266         int i = 0, old;
6267         struct net_device *dev = bp->dev;
6268         u8 offset = bnx2x_e1_cam_mc_offset(bp);
6269         struct netdev_hw_addr *ha;
6270         struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, mcast_config);
6271         dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, mcast_config);
6272
6273         if (netdev_mc_count(dev) > BNX2X_MAX_MULTICAST)
6274                 return -EINVAL;
6275
6276         netdev_for_each_mc_addr(ha, dev) {
6277                 /* copy mac */
6278                 config_cmd->config_table[i].msb_mac_addr =
6279                         swab16(*(u16 *)&bnx2x_mc_addr(ha)[0]);
6280                 config_cmd->config_table[i].middle_mac_addr =
6281                         swab16(*(u16 *)&bnx2x_mc_addr(ha)[2]);
6282                 config_cmd->config_table[i].lsb_mac_addr =
6283                         swab16(*(u16 *)&bnx2x_mc_addr(ha)[4]);
6284
6285                 config_cmd->config_table[i].vlan_id = 0;
6286                 config_cmd->config_table[i].pf_id = BP_FUNC(bp);
6287                 config_cmd->config_table[i].clients_bit_vector =
6288                         cpu_to_le32(1 << BP_L_ID(bp));
6289
6290                 SET_FLAG(config_cmd->config_table[i].flags,
6291                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6292                         T_ETH_MAC_COMMAND_SET);
6293
6294                 DP(NETIF_MSG_IFUP,
6295                    "setting MCAST[%d] (%04x:%04x:%04x)\n", i,
6296                    config_cmd->config_table[i].msb_mac_addr,
6297                    config_cmd->config_table[i].middle_mac_addr,
6298                    config_cmd->config_table[i].lsb_mac_addr);
6299                 i++;
6300         }
6301         old = config_cmd->hdr.length;
6302         if (old > i) {
6303                 for (; i < old; i++) {
6304                         if (CAM_IS_INVALID(config_cmd->
6305                                            config_table[i])) {
6306                                 /* already invalidated */
6307                                 break;
6308                         }
6309                         /* invalidate */
6310                         SET_FLAG(config_cmd->config_table[i].flags,
6311                                 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6312                                 T_ETH_MAC_COMMAND_INVALIDATE);
6313                 }
6314         }
6315
6316         wmb();
6317
6318         config_cmd->hdr.length = i;
6319         config_cmd->hdr.offset = offset;
6320         config_cmd->hdr.client_id = 0xff;
6321         /* Mark that this ramrod doesn't use bp->set_mac_pending for
6322          * synchronization.
6323          */
6324         config_cmd->hdr.echo = 0;
6325
6326         mb();
6327
6328         return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
6329                    U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
6330 }
6331
6332 void bnx2x_invalidate_e1_mc_list(struct bnx2x *bp)
6333 {
6334         int i;
6335         struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, mcast_config);
6336         dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, mcast_config);
6337         int ramrod_flags = WAIT_RAMROD_COMMON;
6338         u8 offset = bnx2x_e1_cam_mc_offset(bp);
6339
6340         for (i = 0; i < BNX2X_MAX_MULTICAST; i++)
6341                 SET_FLAG(config_cmd->config_table[i].flags,
6342                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
6343                         T_ETH_MAC_COMMAND_INVALIDATE);
6344
6345         wmb();
6346
6347         config_cmd->hdr.length = BNX2X_MAX_MULTICAST;
6348         config_cmd->hdr.offset = offset;
6349         config_cmd->hdr.client_id = 0xff;
6350         /* We'll wait for a completion this time... */
6351         config_cmd->hdr.echo = 1;
6352
6353         bp->set_mac_pending = 1;
6354
6355         mb();
6356
6357         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
6358                       U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
6359
6360         /* Wait for a completion */
6361         bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending,
6362                                 ramrod_flags);
6363
6364 }
6365
6366 /* Accept one or more multicasts */
6367 static int bnx2x_set_e1h_mc_list(struct bnx2x *bp)
6368 {
6369         struct net_device *dev = bp->dev;
6370         struct netdev_hw_addr *ha;
6371         u32 mc_filter[MC_HASH_SIZE];
6372         u32 crc, bit, regidx;
6373         int i;
6374
6375         memset(mc_filter, 0, 4 * MC_HASH_SIZE);
6376
6377         netdev_for_each_mc_addr(ha, dev) {
6378                 DP(NETIF_MSG_IFUP, "Adding mcast MAC: %pM\n",
6379                    bnx2x_mc_addr(ha));
6380
6381                 crc = crc32c_le(0, bnx2x_mc_addr(ha),
6382                                 ETH_ALEN);
6383                 bit = (crc >> 24) & 0xff;
6384                 regidx = bit >> 5;
6385                 bit &= 0x1f;
6386                 mc_filter[regidx] |= (1 << bit);
6387         }
6388
6389         for (i = 0; i < MC_HASH_SIZE; i++)
6390                 REG_WR(bp, MC_HASH_OFFSET(bp, i),
6391                        mc_filter[i]);
6392
6393         return 0;
6394 }
6395
6396 void bnx2x_invalidate_e1h_mc_list(struct bnx2x *bp)
6397 {
6398         int i;
6399
6400         for (i = 0; i < MC_HASH_SIZE; i++)
6401                 REG_WR(bp, MC_HASH_OFFSET(bp, i), 0);
6402 }
6403
6404 #ifdef BCM_CNIC
6405 /**
6406  * bnx2x_set_iscsi_eth_mac_addr - set iSCSI MAC(s).
6407  *
6408  * @bp:         driver handle
6409  * @set:        set or clear the CAM entry
6410  *
6411  * This function will wait until the ramdord completion returns.
6412  * Return 0 if success, -ENODEV if ramrod doesn't return.
6413  */
6414 static int bnx2x_set_iscsi_eth_mac_addr(struct bnx2x *bp, int set)
6415 {
6416         u8 cam_offset = (CHIP_IS_E1(bp) ? ((BP_PORT(bp) ? 32 : 0) + 2) :
6417                          bnx2x_e1h_cam_offset(bp, CAM_ISCSI_ETH_LINE));
6418         u32 iscsi_l2_cl_id = BNX2X_ISCSI_ETH_CL_ID +
6419                 BP_E1HVN(bp) * NONE_ETH_CONTEXT_USE;
6420         u32 cl_bit_vec = (1 << iscsi_l2_cl_id);
6421         u8 *iscsi_mac = bp->cnic_eth_dev.iscsi_mac;
6422
6423         /* Send a SET_MAC ramrod */
6424         bnx2x_set_mac_addr_gen(bp, set, iscsi_mac, cl_bit_vec,
6425                                cam_offset, 0);
6426
6427         bnx2x_set_mac_in_nig(bp, set, iscsi_mac, LLH_CAM_ISCSI_ETH_LINE);
6428
6429         return 0;
6430 }
6431
6432 /**
6433  * bnx2x_set_fip_eth_mac_addr - set FCoE L2 MAC(s)
6434  *
6435  * @bp:         driver handle
6436  * @set:        set or clear the CAM entry
6437  *
6438  * This function will wait until the ramrod completion returns.
6439  * Returns 0 if success, -ENODEV if ramrod doesn't return.
6440  */
6441 int bnx2x_set_fip_eth_mac_addr(struct bnx2x *bp, int set)
6442 {
6443         u32 cl_bit_vec = (1 << bnx2x_fcoe(bp, cl_id));
6444         /**
6445          * CAM allocation for E1H
6446          * eth unicasts: by func number
6447          * iscsi: by func number
6448          * fip unicast: by func number
6449          * fip multicast: by func number
6450          */
6451         bnx2x_set_mac_addr_gen(bp, set, bp->fip_mac,
6452                 cl_bit_vec, bnx2x_e1h_cam_offset(bp, CAM_FIP_ETH_LINE), 0);
6453
6454         return 0;
6455 }
6456
6457 int bnx2x_set_all_enode_macs(struct bnx2x *bp, int set)
6458 {
6459         u32 cl_bit_vec = (1 << bnx2x_fcoe(bp, cl_id));
6460
6461         /**
6462          * CAM allocation for E1H
6463          * eth unicasts: by func number
6464          * iscsi: by func number
6465          * fip unicast: by func number
6466          * fip multicast: by func number
6467          */
6468         bnx2x_set_mac_addr_gen(bp, set, ALL_ENODE_MACS, cl_bit_vec,
6469                 bnx2x_e1h_cam_offset(bp, CAM_FIP_MCAST_LINE), 0);
6470
6471         return 0;
6472 }
6473 #endif
6474
6475 static void bnx2x_fill_cl_init_data(struct bnx2x *bp,
6476                                     struct bnx2x_client_init_params *params,
6477                                     u8 activate,
6478                                     struct client_init_ramrod_data *data)
6479 {
6480         /* Clear the buffer */
6481         memset(data, 0, sizeof(*data));
6482
6483         /* general */
6484         data->general.client_id = params->rxq_params.cl_id;
6485         data->general.statistics_counter_id = params->rxq_params.stat_id;
6486         data->general.statistics_en_flg =
6487                 (params->rxq_params.flags & QUEUE_FLG_STATS) ? 1 : 0;
6488         data->general.is_fcoe_flg =
6489                 (params->ramrod_params.flags & CLIENT_IS_FCOE) ? 1 : 0;
6490         data->general.activate_flg = activate;
6491         data->general.sp_client_id = params->rxq_params.spcl_id;
6492
6493         /* Rx data */
6494         data->rx.tpa_en_flg =
6495                 (params->rxq_params.flags & QUEUE_FLG_TPA) ? 1 : 0;
6496         data->rx.vmqueue_mode_en_flg = 0;
6497         data->rx.cache_line_alignment_log_size =
6498                 params->rxq_params.cache_line_log;
6499         data->rx.enable_dynamic_hc =
6500                 (params->rxq_params.flags & QUEUE_FLG_DHC) ? 1 : 0;
6501         data->rx.max_sges_for_packet = params->rxq_params.max_sges_pkt;
6502         data->rx.client_qzone_id = params->rxq_params.cl_qzone_id;
6503         data->rx.max_agg_size = params->rxq_params.tpa_agg_sz;
6504
6505         /* We don't set drop flags */
6506         data->rx.drop_ip_cs_err_flg = 0;
6507         data->rx.drop_tcp_cs_err_flg = 0;
6508         data->rx.drop_ttl0_flg = 0;
6509         data->rx.drop_udp_cs_err_flg = 0;
6510
6511         data->rx.inner_vlan_removal_enable_flg =
6512                 (params->rxq_params.flags & QUEUE_FLG_VLAN) ? 1 : 0;
6513         data->rx.outer_vlan_removal_enable_flg =
6514                 (params->rxq_params.flags & QUEUE_FLG_OV) ? 1 : 0;
6515         data->rx.status_block_id = params->rxq_params.fw_sb_id;
6516         data->rx.rx_sb_index_number = params->rxq_params.sb_cq_index;
6517         data->rx.bd_buff_size = cpu_to_le16(params->rxq_params.buf_sz);
6518         data->rx.sge_buff_size = cpu_to_le16(params->rxq_params.sge_buf_sz);
6519         data->rx.mtu = cpu_to_le16(params->rxq_params.mtu);
6520         data->rx.bd_page_base.lo =
6521                 cpu_to_le32(U64_LO(params->rxq_params.dscr_map));
6522         data->rx.bd_page_base.hi =
6523                 cpu_to_le32(U64_HI(params->rxq_params.dscr_map));
6524         data->rx.sge_page_base.lo =
6525                 cpu_to_le32(U64_LO(params->rxq_params.sge_map));
6526         data->rx.sge_page_base.hi =
6527                 cpu_to_le32(U64_HI(params->rxq_params.sge_map));
6528         data->rx.cqe_page_base.lo =
6529                 cpu_to_le32(U64_LO(params->rxq_params.rcq_map));
6530         data->rx.cqe_page_base.hi =
6531                 cpu_to_le32(U64_HI(params->rxq_params.rcq_map));
6532         data->rx.is_leading_rss =
6533                 (params->ramrod_params.flags & CLIENT_IS_LEADING_RSS) ? 1 : 0;
6534         data->rx.is_approx_mcast = data->rx.is_leading_rss;
6535
6536         /* Tx data */
6537         data->tx.enforce_security_flg = 0; /* VF specific */
6538         data->tx.tx_status_block_id = params->txq_params.fw_sb_id;
6539         data->tx.tx_sb_index_number = params->txq_params.sb_cq_index;
6540         data->tx.mtu = 0; /* VF specific */
6541         data->tx.tx_bd_page_base.lo =
6542                 cpu_to_le32(U64_LO(params->txq_params.dscr_map));
6543         data->tx.tx_bd_page_base.hi =
6544                 cpu_to_le32(U64_HI(params->txq_params.dscr_map));
6545
6546         /* flow control data */
6547         data->fc.cqe_pause_thr_low = cpu_to_le16(params->pause.rcq_th_lo);
6548         data->fc.cqe_pause_thr_high = cpu_to_le16(params->pause.rcq_th_hi);
6549         data->fc.bd_pause_thr_low = cpu_to_le16(params->pause.bd_th_lo);
6550         data->fc.bd_pause_thr_high = cpu_to_le16(params->pause.bd_th_hi);
6551         data->fc.sge_pause_thr_low = cpu_to_le16(params->pause.sge_th_lo);
6552         data->fc.sge_pause_thr_high = cpu_to_le16(params->pause.sge_th_hi);
6553         data->fc.rx_cos_mask = cpu_to_le16(params->pause.pri_map);
6554
6555         data->fc.safc_group_num = params->txq_params.cos;
6556         data->fc.safc_group_en_flg =
6557                 (params->txq_params.flags & QUEUE_FLG_COS) ? 1 : 0;
6558         data->fc.traffic_type =
6559                 (params->ramrod_params.flags & CLIENT_IS_FCOE) ?
6560                 LLFC_TRAFFIC_TYPE_FCOE : LLFC_TRAFFIC_TYPE_NW;
6561 }
6562
6563 static inline void bnx2x_set_ctx_validation(struct eth_context *cxt, u32 cid)
6564 {
6565         /* ustorm cxt validation */
6566         cxt->ustorm_ag_context.cdu_usage =
6567                 CDU_RSRVD_VALUE_TYPE_A(cid, CDU_REGION_NUMBER_UCM_AG,
6568                                        ETH_CONNECTION_TYPE);
6569         /* xcontext validation */
6570         cxt->xstorm_ag_context.cdu_reserved =
6571                 CDU_RSRVD_VALUE_TYPE_A(cid, CDU_REGION_NUMBER_XCM_AG,
6572                                        ETH_CONNECTION_TYPE);
6573 }
6574
6575 static int bnx2x_setup_fw_client(struct bnx2x *bp,
6576                                  struct bnx2x_client_init_params *params,
6577                                  u8 activate,
6578                                  struct client_init_ramrod_data *data,
6579                                  dma_addr_t data_mapping)
6580 {
6581         u16 hc_usec;
6582         int ramrod = RAMROD_CMD_ID_ETH_CLIENT_SETUP;
6583         int ramrod_flags = 0, rc;
6584
6585         /* HC and context validation values */
6586         hc_usec = params->txq_params.hc_rate ?
6587                 1000000 / params->txq_params.hc_rate : 0;
6588         bnx2x_update_coalesce_sb_index(bp,
6589                         params->txq_params.fw_sb_id,
6590                         params->txq_params.sb_cq_index,
6591                         !(params->txq_params.flags & QUEUE_FLG_HC),
6592                         hc_usec);
6593
6594         *(params->ramrod_params.pstate) = BNX2X_FP_STATE_OPENING;
6595
6596         hc_usec = params->rxq_params.hc_rate ?
6597                 1000000 / params->rxq_params.hc_rate : 0;
6598         bnx2x_update_coalesce_sb_index(bp,
6599                         params->rxq_params.fw_sb_id,
6600                         params->rxq_params.sb_cq_index,
6601                         !(params->rxq_params.flags & QUEUE_FLG_HC),
6602                         hc_usec);
6603
6604         bnx2x_set_ctx_validation(params->rxq_params.cxt,
6605                                  params->rxq_params.cid);
6606
6607         /* zero stats */
6608         if (params->txq_params.flags & QUEUE_FLG_STATS)
6609                 storm_memset_xstats_zero(bp, BP_PORT(bp),
6610                                          params->txq_params.stat_id);
6611
6612         if (params->rxq_params.flags & QUEUE_FLG_STATS) {
6613                 storm_memset_ustats_zero(bp, BP_PORT(bp),
6614                                          params->rxq_params.stat_id);
6615                 storm_memset_tstats_zero(bp, BP_PORT(bp),
6616                                          params->rxq_params.stat_id);
6617         }
6618
6619         /* Fill the ramrod data */
6620         bnx2x_fill_cl_init_data(bp, params, activate, data);
6621
6622         /* SETUP ramrod.
6623          *
6624          * bnx2x_sp_post() takes a spin_lock thus no other explict memory
6625          * barrier except from mmiowb() is needed to impose a
6626          * proper ordering of memory operations.
6627          */
6628         mmiowb();
6629
6630
6631         bnx2x_sp_post(bp, ramrod, params->ramrod_params.cid,
6632                       U64_HI(data_mapping), U64_LO(data_mapping), 0);
6633
6634         /* Wait for completion */
6635         rc = bnx2x_wait_ramrod(bp, params->ramrod_params.state,
6636                                  params->ramrod_params.index,
6637                                  params->ramrod_params.pstate,
6638                                  ramrod_flags);
6639         return rc;
6640 }
6641
6642 /**
6643  * bnx2x_set_int_mode - configure interrupt mode
6644  *
6645  * @bp:         driver handle
6646  *
6647  * In case of MSI-X it will also try to enable MSI-X.
6648  */
6649 static int __devinit bnx2x_set_int_mode(struct bnx2x *bp)
6650 {
6651         int rc = 0;
6652
6653         switch (bp->int_mode) {
6654         case INT_MODE_MSI:
6655                 bnx2x_enable_msi(bp);
6656                 /* falling through... */
6657         case INT_MODE_INTx:
6658                 bp->num_queues = 1 + NONE_ETH_CONTEXT_USE;
6659                 DP(NETIF_MSG_IFUP, "set number of queues to 1\n");
6660                 break;
6661         default:
6662                 /* Set number of queues according to bp->multi_mode value */
6663                 bnx2x_set_num_queues(bp);
6664
6665                 DP(NETIF_MSG_IFUP, "set number of queues to %d\n",
6666                    bp->num_queues);
6667
6668                 /* if we can't use MSI-X we only need one fp,
6669                  * so try to enable MSI-X with the requested number of fp's
6670                  * and fallback to MSI or legacy INTx with one fp
6671                  */
6672                 rc = bnx2x_enable_msix(bp);
6673                 if (rc) {
6674                         /* failed to enable MSI-X */
6675                         if (bp->multi_mode)
6676                                 DP(NETIF_MSG_IFUP,
6677                                           "Multi requested but failed to "
6678                                           "enable MSI-X (%d), "
6679                                           "set number of queues to %d\n",
6680                                    bp->num_queues,
6681                                    1 + NONE_ETH_CONTEXT_USE);
6682                         bp->num_queues = 1 + NONE_ETH_CONTEXT_USE;
6683
6684                         if (!(bp->flags & DISABLE_MSI_FLAG))
6685                                 bnx2x_enable_msi(bp);
6686                 }
6687
6688                 break;
6689         }
6690
6691         return rc;
6692 }
6693
6694 /* must be called prioir to any HW initializations */
6695 static inline u16 bnx2x_cid_ilt_lines(struct bnx2x *bp)
6696 {
6697         return L2_ILT_LINES(bp);
6698 }
6699
6700 void bnx2x_ilt_set_info(struct bnx2x *bp)
6701 {
6702         struct ilt_client_info *ilt_client;
6703         struct bnx2x_ilt *ilt = BP_ILT(bp);
6704         u16 line = 0;
6705
6706         ilt->start_line = FUNC_ILT_BASE(BP_FUNC(bp));
6707         DP(BNX2X_MSG_SP, "ilt starts at line %d\n", ilt->start_line);
6708
6709         /* CDU */
6710         ilt_client = &ilt->clients[ILT_CLIENT_CDU];
6711         ilt_client->client_num = ILT_CLIENT_CDU;
6712         ilt_client->page_size = CDU_ILT_PAGE_SZ;
6713         ilt_client->flags = ILT_CLIENT_SKIP_MEM;
6714         ilt_client->start = line;
6715         line += L2_ILT_LINES(bp);
6716 #ifdef BCM_CNIC
6717         line += CNIC_ILT_LINES;
6718 #endif
6719         ilt_client->end = line - 1;
6720
6721         DP(BNX2X_MSG_SP, "ilt client[CDU]: start %d, end %d, psz 0x%x, "
6722                                          "flags 0x%x, hw psz %d\n",
6723            ilt_client->start,
6724            ilt_client->end,
6725            ilt_client->page_size,
6726            ilt_client->flags,
6727            ilog2(ilt_client->page_size >> 12));
6728
6729         /* QM */
6730         if (QM_INIT(bp->qm_cid_count)) {
6731                 ilt_client = &ilt->clients[ILT_CLIENT_QM];
6732                 ilt_client->client_num = ILT_CLIENT_QM;
6733                 ilt_client->page_size = QM_ILT_PAGE_SZ;
6734                 ilt_client->flags = 0;
6735                 ilt_client->start = line;
6736
6737                 /* 4 bytes for each cid */
6738                 line += DIV_ROUND_UP(bp->qm_cid_count * QM_QUEUES_PER_FUNC * 4,
6739                                                          QM_ILT_PAGE_SZ);
6740
6741                 ilt_client->end = line - 1;
6742
6743                 DP(BNX2X_MSG_SP, "ilt client[QM]: start %d, end %d, psz 0x%x, "
6744                                                  "flags 0x%x, hw psz %d\n",
6745                    ilt_client->start,
6746                    ilt_client->end,
6747                    ilt_client->page_size,
6748                    ilt_client->flags,
6749                    ilog2(ilt_client->page_size >> 12));
6750
6751         }
6752         /* SRC */
6753         ilt_client = &ilt->clients[ILT_CLIENT_SRC];
6754 #ifdef BCM_CNIC
6755         ilt_client->client_num = ILT_CLIENT_SRC;
6756         ilt_client->page_size = SRC_ILT_PAGE_SZ;
6757         ilt_client->flags = 0;
6758         ilt_client->start = line;
6759         line += SRC_ILT_LINES;
6760         ilt_client->end = line - 1;
6761
6762         DP(BNX2X_MSG_SP, "ilt client[SRC]: start %d, end %d, psz 0x%x, "
6763                                          "flags 0x%x, hw psz %d\n",
6764            ilt_client->start,
6765            ilt_client->end,
6766            ilt_client->page_size,
6767            ilt_client->flags,
6768            ilog2(ilt_client->page_size >> 12));
6769
6770 #else
6771         ilt_client->flags = (ILT_CLIENT_SKIP_INIT | ILT_CLIENT_SKIP_MEM);
6772 #endif
6773
6774         /* TM */
6775         ilt_client = &ilt->clients[ILT_CLIENT_TM];
6776 #ifdef BCM_CNIC
6777         ilt_client->client_num = ILT_CLIENT_TM;
6778         ilt_client->page_size = TM_ILT_PAGE_SZ;
6779         ilt_client->flags = 0;
6780         ilt_client->start = line;
6781         line += TM_ILT_LINES;
6782         ilt_client->end = line - 1;
6783
6784         DP(BNX2X_MSG_SP, "ilt client[TM]: start %d, end %d, psz 0x%x, "
6785                                          "flags 0x%x, hw psz %d\n",
6786            ilt_client->start,
6787            ilt_client->end,
6788            ilt_client->page_size,
6789            ilt_client->flags,
6790            ilog2(ilt_client->page_size >> 12));
6791
6792 #else
6793         ilt_client->flags = (ILT_CLIENT_SKIP_INIT | ILT_CLIENT_SKIP_MEM);
6794 #endif
6795 }
6796
6797 int bnx2x_setup_client(struct bnx2x *bp, struct bnx2x_fastpath *fp,
6798                        int is_leading)
6799 {
6800         struct bnx2x_client_init_params params = { {0} };
6801         int rc;
6802
6803         /* reset IGU state skip FCoE L2 queue */
6804         if (!IS_FCOE_FP(fp))
6805                 bnx2x_ack_sb(bp, fp->igu_sb_id, USTORM_ID, 0,
6806                              IGU_INT_ENABLE, 0);
6807
6808         params.ramrod_params.pstate = &fp->state;
6809         params.ramrod_params.state = BNX2X_FP_STATE_OPEN;
6810         params.ramrod_params.index = fp->index;
6811         params.ramrod_params.cid = fp->cid;
6812
6813 #ifdef BCM_CNIC
6814         if (IS_FCOE_FP(fp))
6815                 params.ramrod_params.flags |= CLIENT_IS_FCOE;
6816
6817 #endif
6818
6819         if (is_leading)
6820                 params.ramrod_params.flags |= CLIENT_IS_LEADING_RSS;
6821
6822         bnx2x_pf_rx_cl_prep(bp, fp, &params.pause, &params.rxq_params);
6823
6824         bnx2x_pf_tx_cl_prep(bp, fp, &params.txq_params);
6825
6826         rc = bnx2x_setup_fw_client(bp, &params, 1,
6827                                      bnx2x_sp(bp, client_init_data),
6828                                      bnx2x_sp_mapping(bp, client_init_data));
6829         return rc;
6830 }
6831
6832 static int bnx2x_stop_fw_client(struct bnx2x *bp,
6833                                 struct bnx2x_client_ramrod_params *p)
6834 {
6835         int rc;
6836
6837         int poll_flag = p->poll ? WAIT_RAMROD_POLL : 0;
6838
6839         /* halt the connection */
6840         *p->pstate = BNX2X_FP_STATE_HALTING;
6841         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, p->cid, 0,
6842                                                   p->cl_id, 0);
6843
6844         /* Wait for completion */
6845         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, p->index,
6846                                p->pstate, poll_flag);
6847         if (rc) /* timeout */
6848                 return rc;
6849
6850         *p->pstate = BNX2X_FP_STATE_TERMINATING;
6851         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_TERMINATE, p->cid, 0,
6852                                                        p->cl_id, 0);
6853         /* Wait for completion */
6854         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_TERMINATED, p->index,
6855                                p->pstate, poll_flag);
6856         if (rc) /* timeout */
6857                 return rc;
6858
6859
6860         /* delete cfc entry */
6861         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_CFC_DEL, p->cid, 0, 0, 1);
6862
6863         /* Wait for completion */
6864         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_CLOSED, p->index,
6865                                p->pstate, WAIT_RAMROD_COMMON);
6866         return rc;
6867 }
6868
6869 static int bnx2x_stop_client(struct bnx2x *bp, int index)
6870 {
6871         struct bnx2x_client_ramrod_params client_stop = {0};
6872         struct bnx2x_fastpath *fp = &bp->fp[index];
6873
6874         client_stop.index = index;
6875         client_stop.cid = fp->cid;
6876         client_stop.cl_id = fp->cl_id;
6877         client_stop.pstate = &(fp->state);
6878         client_stop.poll = 0;
6879
6880         return bnx2x_stop_fw_client(bp, &client_stop);
6881 }
6882
6883
6884 static void bnx2x_reset_func(struct bnx2x *bp)
6885 {
6886         int port = BP_PORT(bp);
6887         int func = BP_FUNC(bp);
6888         int i;
6889         int pfunc_offset_fp = offsetof(struct hc_sb_data, p_func) +
6890                         (CHIP_IS_E2(bp) ?
6891                          offsetof(struct hc_status_block_data_e2, common) :
6892                          offsetof(struct hc_status_block_data_e1x, common));
6893         int pfunc_offset_sp = offsetof(struct hc_sp_status_block_data, p_func);
6894         int pfid_offset = offsetof(struct pci_entity, pf_id);
6895
6896         /* Disable the function in the FW */
6897         REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(func), 0);
6898         REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(func), 0);
6899         REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(func), 0);
6900         REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(func), 0);
6901
6902         /* FP SBs */
6903         for_each_eth_queue(bp, i) {
6904                 struct bnx2x_fastpath *fp = &bp->fp[i];
6905                 REG_WR8(bp,
6906                         BAR_CSTRORM_INTMEM +
6907                         CSTORM_STATUS_BLOCK_DATA_OFFSET(fp->fw_sb_id)
6908                         + pfunc_offset_fp + pfid_offset,
6909                         HC_FUNCTION_DISABLED);
6910         }
6911
6912         /* SP SB */
6913         REG_WR8(bp,
6914                 BAR_CSTRORM_INTMEM +
6915                 CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(func) +
6916                 pfunc_offset_sp + pfid_offset,
6917                 HC_FUNCTION_DISABLED);
6918
6919
6920         for (i = 0; i < XSTORM_SPQ_DATA_SIZE / 4; i++)
6921                 REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_DATA_OFFSET(func),
6922                        0);
6923
6924         /* Configure IGU */
6925         if (bp->common.int_block == INT_BLOCK_HC) {
6926                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
6927                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
6928         } else {
6929                 REG_WR(bp, IGU_REG_LEADING_EDGE_LATCH, 0);
6930                 REG_WR(bp, IGU_REG_TRAILING_EDGE_LATCH, 0);
6931         }
6932
6933 #ifdef BCM_CNIC
6934         /* Disable Timer scan */
6935         REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + port*4, 0);
6936         /*
6937          * Wait for at least 10ms and up to 2 second for the timers scan to
6938          * complete
6939          */
6940         for (i = 0; i < 200; i++) {
6941                 msleep(10);
6942                 if (!REG_RD(bp, TM_REG_LIN0_SCAN_ON + port*4))
6943                         break;
6944         }
6945 #endif
6946         /* Clear ILT */
6947         bnx2x_clear_func_ilt(bp, func);
6948
6949         /* Timers workaround bug for E2: if this is vnic-3,
6950          * we need to set the entire ilt range for this timers.
6951          */
6952         if (CHIP_IS_E2(bp) && BP_VN(bp) == 3) {
6953                 struct ilt_client_info ilt_cli;
6954                 /* use dummy TM client */
6955                 memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
6956                 ilt_cli.start = 0;
6957                 ilt_cli.end = ILT_NUM_PAGE_ENTRIES - 1;
6958                 ilt_cli.client_num = ILT_CLIENT_TM;
6959
6960                 bnx2x_ilt_boundry_init_op(bp, &ilt_cli, 0, INITOP_CLEAR);
6961         }
6962
6963         /* this assumes that reset_port() called before reset_func()*/
6964         if (CHIP_IS_E2(bp))
6965                 bnx2x_pf_disable(bp);
6966
6967         bp->dmae_ready = 0;
6968 }
6969
6970 static void bnx2x_reset_port(struct bnx2x *bp)
6971 {
6972         int port = BP_PORT(bp);
6973         u32 val;
6974
6975         REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
6976
6977         /* Do not rcv packets to BRB */
6978         REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK + port*4, 0x0);
6979         /* Do not direct rcv packets that are not for MCP to the BRB */
6980         REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_NOT_MCP :
6981                            NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
6982
6983         /* Configure AEU */
6984         REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, 0);
6985
6986         msleep(100);
6987         /* Check for BRB port occupancy */
6988         val = REG_RD(bp, BRB1_REG_PORT_NUM_OCC_BLOCKS_0 + port*4);
6989         if (val)
6990                 DP(NETIF_MSG_IFDOWN,
6991                    "BRB1 is not empty  %d blocks are occupied\n", val);
6992
6993         /* TODO: Close Doorbell port? */
6994 }
6995
6996 static void bnx2x_reset_chip(struct bnx2x *bp, u32 reset_code)
6997 {
6998         DP(BNX2X_MSG_MCP, "function %d  reset_code %x\n",
6999            BP_ABS_FUNC(bp), reset_code);
7000
7001         switch (reset_code) {
7002         case FW_MSG_CODE_DRV_UNLOAD_COMMON:
7003                 bnx2x_reset_port(bp);
7004                 bnx2x_reset_func(bp);
7005                 bnx2x_reset_common(bp);
7006                 break;
7007
7008         case FW_MSG_CODE_DRV_UNLOAD_PORT:
7009                 bnx2x_reset_port(bp);
7010                 bnx2x_reset_func(bp);
7011                 break;
7012
7013         case FW_MSG_CODE_DRV_UNLOAD_FUNCTION:
7014                 bnx2x_reset_func(bp);
7015                 break;
7016
7017         default:
7018                 BNX2X_ERR("Unknown reset_code (0x%x) from MCP\n", reset_code);
7019                 break;
7020         }
7021 }
7022
7023 #ifdef BCM_CNIC
7024 static inline void bnx2x_del_fcoe_eth_macs(struct bnx2x *bp)
7025 {
7026         if (bp->flags & FCOE_MACS_SET) {
7027                 if (!IS_MF_SD(bp))
7028                         bnx2x_set_fip_eth_mac_addr(bp, 0);
7029
7030                 bnx2x_set_all_enode_macs(bp, 0);
7031
7032                 bp->flags &= ~FCOE_MACS_SET;
7033         }
7034 }
7035 #endif
7036
7037 void bnx2x_chip_cleanup(struct bnx2x *bp, int unload_mode)
7038 {
7039         int port = BP_PORT(bp);
7040         u32 reset_code = 0;
7041         int i, cnt, rc;
7042
7043         /* Wait until tx fastpath tasks complete */
7044         for_each_tx_queue(bp, i) {
7045                 struct bnx2x_fastpath *fp = &bp->fp[i];
7046
7047                 cnt = 1000;
7048                 while (bnx2x_has_tx_work_unload(fp)) {
7049
7050                         if (!cnt) {
7051                                 BNX2X_ERR("timeout waiting for queue[%d]\n",
7052                                           i);
7053 #ifdef BNX2X_STOP_ON_ERROR
7054                                 bnx2x_panic();
7055                                 return -EBUSY;
7056 #else
7057                                 break;
7058 #endif
7059                         }
7060                         cnt--;
7061                         msleep(1);
7062                 }
7063         }
7064         /* Give HW time to discard old tx messages */
7065         msleep(1);
7066
7067         bnx2x_set_eth_mac(bp, 0);
7068
7069         bnx2x_invalidate_uc_list(bp);
7070
7071         if (CHIP_IS_E1(bp))
7072                 bnx2x_invalidate_e1_mc_list(bp);
7073         else {
7074                 bnx2x_invalidate_e1h_mc_list(bp);
7075                 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
7076         }
7077
7078 #ifdef BCM_CNIC
7079         bnx2x_del_fcoe_eth_macs(bp);
7080 #endif
7081
7082         if (unload_mode == UNLOAD_NORMAL)
7083                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7084
7085         else if (bp->flags & NO_WOL_FLAG)
7086                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
7087
7088         else if (bp->wol) {
7089                 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
7090                 u8 *mac_addr = bp->dev->dev_addr;
7091                 u32 val;
7092                 /* The mac address is written to entries 1-4 to
7093                    preserve entry 0 which is used by the PMF */
7094                 u8 entry = (BP_E1HVN(bp) + 1)*8;
7095
7096                 val = (mac_addr[0] << 8) | mac_addr[1];
7097                 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry, val);
7098
7099                 val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
7100                       (mac_addr[4] << 8) | mac_addr[5];
7101                 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
7102
7103                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
7104
7105         } else
7106                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7107
7108         /* Close multi and leading connections
7109            Completions for ramrods are collected in a synchronous way */
7110         for_each_queue(bp, i)
7111
7112                 if (bnx2x_stop_client(bp, i))
7113 #ifdef BNX2X_STOP_ON_ERROR
7114                         return;
7115 #else
7116                         goto unload_error;
7117 #endif
7118
7119         rc = bnx2x_func_stop(bp);
7120         if (rc) {
7121                 BNX2X_ERR("Function stop failed!\n");
7122 #ifdef BNX2X_STOP_ON_ERROR
7123                 return;
7124 #else
7125                 goto unload_error;
7126 #endif
7127         }
7128 #ifndef BNX2X_STOP_ON_ERROR
7129 unload_error:
7130 #endif
7131         if (!BP_NOMCP(bp))
7132                 reset_code = bnx2x_fw_command(bp, reset_code, 0);
7133         else {
7134                 DP(NETIF_MSG_IFDOWN, "NO MCP - load counts[%d]      "
7135                                      "%d, %d, %d\n", BP_PATH(bp),
7136                    load_count[BP_PATH(bp)][0],
7137                    load_count[BP_PATH(bp)][1],
7138                    load_count[BP_PATH(bp)][2]);
7139                 load_count[BP_PATH(bp)][0]--;
7140                 load_count[BP_PATH(bp)][1 + port]--;
7141                 DP(NETIF_MSG_IFDOWN, "NO MCP - new load counts[%d]  "
7142                                      "%d, %d, %d\n", BP_PATH(bp),
7143                    load_count[BP_PATH(bp)][0], load_count[BP_PATH(bp)][1],
7144                    load_count[BP_PATH(bp)][2]);
7145                 if (load_count[BP_PATH(bp)][0] == 0)
7146                         reset_code = FW_MSG_CODE_DRV_UNLOAD_COMMON;
7147                 else if (load_count[BP_PATH(bp)][1 + port] == 0)
7148                         reset_code = FW_MSG_CODE_DRV_UNLOAD_PORT;
7149                 else
7150                         reset_code = FW_MSG_CODE_DRV_UNLOAD_FUNCTION;
7151         }
7152
7153         if ((reset_code == FW_MSG_CODE_DRV_UNLOAD_COMMON) ||
7154             (reset_code == FW_MSG_CODE_DRV_UNLOAD_PORT))
7155                 bnx2x__link_reset(bp);
7156
7157         /* Disable HW interrupts, NAPI */
7158         bnx2x_netif_stop(bp, 1);
7159
7160         /* Release IRQs */
7161         bnx2x_free_irq(bp);
7162
7163         /* Reset the chip */
7164         bnx2x_reset_chip(bp, reset_code);
7165
7166         /* Report UNLOAD_DONE to MCP */
7167         if (!BP_NOMCP(bp))
7168                 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
7169
7170 }
7171
7172 void bnx2x_disable_close_the_gate(struct bnx2x *bp)
7173 {
7174         u32 val;
7175
7176         DP(NETIF_MSG_HW, "Disabling \"close the gates\"\n");
7177
7178         if (CHIP_IS_E1(bp)) {
7179                 int port = BP_PORT(bp);
7180                 u32 addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
7181                         MISC_REG_AEU_MASK_ATTN_FUNC_0;
7182
7183                 val = REG_RD(bp, addr);
7184                 val &= ~(0x300);
7185                 REG_WR(bp, addr, val);
7186         } else if (CHIP_IS_E1H(bp)) {
7187                 val = REG_RD(bp, MISC_REG_AEU_GENERAL_MASK);
7188                 val &= ~(MISC_AEU_GENERAL_MASK_REG_AEU_PXP_CLOSE_MASK |
7189                          MISC_AEU_GENERAL_MASK_REG_AEU_NIG_CLOSE_MASK);
7190                 REG_WR(bp, MISC_REG_AEU_GENERAL_MASK, val);
7191         }
7192 }
7193
7194 /* Close gates #2, #3 and #4: */
7195 static void bnx2x_set_234_gates(struct bnx2x *bp, bool close)
7196 {
7197         u32 val, addr;
7198
7199         /* Gates #2 and #4a are closed/opened for "not E1" only */
7200         if (!CHIP_IS_E1(bp)) {
7201                 /* #4 */
7202                 val = REG_RD(bp, PXP_REG_HST_DISCARD_DOORBELLS);
7203                 REG_WR(bp, PXP_REG_HST_DISCARD_DOORBELLS,
7204                        close ? (val | 0x1) : (val & (~(u32)1)));
7205                 /* #2 */
7206                 val = REG_RD(bp, PXP_REG_HST_DISCARD_INTERNAL_WRITES);
7207                 REG_WR(bp, PXP_REG_HST_DISCARD_INTERNAL_WRITES,
7208                        close ? (val | 0x1) : (val & (~(u32)1)));
7209         }
7210
7211         /* #3 */
7212         addr = BP_PORT(bp) ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
7213         val = REG_RD(bp, addr);
7214         REG_WR(bp, addr, (!close) ? (val | 0x1) : (val & (~(u32)1)));
7215
7216         DP(NETIF_MSG_HW, "%s gates #2, #3 and #4\n",
7217                 close ? "closing" : "opening");
7218         mmiowb();
7219 }
7220
7221 #define SHARED_MF_CLP_MAGIC  0x80000000 /* `magic' bit */
7222
7223 static void bnx2x_clp_reset_prep(struct bnx2x *bp, u32 *magic_val)
7224 {
7225         /* Do some magic... */
7226         u32 val = MF_CFG_RD(bp, shared_mf_config.clp_mb);
7227         *magic_val = val & SHARED_MF_CLP_MAGIC;
7228         MF_CFG_WR(bp, shared_mf_config.clp_mb, val | SHARED_MF_CLP_MAGIC);
7229 }
7230
7231 /**
7232  * bnx2x_clp_reset_done - restore the value of the `magic' bit.
7233  *
7234  * @bp:         driver handle
7235  * @magic_val:  old value of the `magic' bit.
7236  */
7237 static void bnx2x_clp_reset_done(struct bnx2x *bp, u32 magic_val)
7238 {
7239         /* Restore the `magic' bit value... */
7240         u32 val = MF_CFG_RD(bp, shared_mf_config.clp_mb);
7241         MF_CFG_WR(bp, shared_mf_config.clp_mb,
7242                 (val & (~SHARED_MF_CLP_MAGIC)) | magic_val);
7243 }
7244
7245 /**
7246  * bnx2x_reset_mcp_prep - prepare for MCP reset.
7247  *
7248  * @bp:         driver handle
7249  * @magic_val:  old value of 'magic' bit.
7250  *
7251  * Takes care of CLP configurations.
7252  */
7253 static void bnx2x_reset_mcp_prep(struct bnx2x *bp, u32 *magic_val)
7254 {
7255         u32 shmem;
7256         u32 validity_offset;
7257
7258         DP(NETIF_MSG_HW, "Starting\n");
7259
7260         /* Set `magic' bit in order to save MF config */
7261         if (!CHIP_IS_E1(bp))
7262                 bnx2x_clp_reset_prep(bp, magic_val);
7263
7264         /* Get shmem offset */
7265         shmem = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
7266         validity_offset = offsetof(struct shmem_region, validity_map[0]);
7267
7268         /* Clear validity map flags */
7269         if (shmem > 0)
7270                 REG_WR(bp, shmem + validity_offset, 0);
7271 }
7272
7273 #define MCP_TIMEOUT      5000   /* 5 seconds (in ms) */
7274 #define MCP_ONE_TIMEOUT  100    /* 100 ms */
7275
7276 /**
7277  * bnx2x_mcp_wait_one - wait for MCP_ONE_TIMEOUT
7278  *
7279  * @bp: driver handle
7280  */
7281 static inline void bnx2x_mcp_wait_one(struct bnx2x *bp)
7282 {
7283         /* special handling for emulation and FPGA,
7284            wait 10 times longer */
7285         if (CHIP_REV_IS_SLOW(bp))
7286                 msleep(MCP_ONE_TIMEOUT*10);
7287         else
7288                 msleep(MCP_ONE_TIMEOUT);
7289 }
7290
7291 /*
7292  * initializes bp->common.shmem_base and waits for validity signature to appear
7293  */
7294 static int bnx2x_init_shmem(struct bnx2x *bp)
7295 {
7296         int cnt = 0;
7297         u32 val = 0;
7298
7299         do {
7300                 bp->common.shmem_base = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
7301                 if (bp->common.shmem_base) {
7302                         val = SHMEM_RD(bp, validity_map[BP_PORT(bp)]);
7303                         if (val & SHR_MEM_VALIDITY_MB)
7304                                 return 0;
7305                 }
7306
7307                 bnx2x_mcp_wait_one(bp);
7308
7309         } while (cnt++ < (MCP_TIMEOUT / MCP_ONE_TIMEOUT));
7310
7311         BNX2X_ERR("BAD MCP validity signature\n");
7312
7313         return -ENODEV;
7314 }
7315
7316 static int bnx2x_reset_mcp_comp(struct bnx2x *bp, u32 magic_val)
7317 {
7318         int rc = bnx2x_init_shmem(bp);
7319
7320         /* Restore the `magic' bit value */
7321         if (!CHIP_IS_E1(bp))
7322                 bnx2x_clp_reset_done(bp, magic_val);
7323
7324         return rc;
7325 }
7326
7327 static void bnx2x_pxp_prep(struct bnx2x *bp)
7328 {
7329         if (!CHIP_IS_E1(bp)) {
7330                 REG_WR(bp, PXP2_REG_RD_START_INIT, 0);
7331                 REG_WR(bp, PXP2_REG_RQ_RBC_DONE, 0);
7332                 REG_WR(bp, PXP2_REG_RQ_CFG_DONE, 0);
7333                 mmiowb();
7334         }
7335 }
7336
7337 /*
7338  * Reset the whole chip except for:
7339  *      - PCIE core
7340  *      - PCI Glue, PSWHST, PXP/PXP2 RF (all controlled by
7341  *              one reset bit)
7342  *      - IGU
7343  *      - MISC (including AEU)
7344  *      - GRC
7345  *      - RBCN, RBCP
7346  */
7347 static void bnx2x_process_kill_chip_reset(struct bnx2x *bp)
7348 {
7349         u32 not_reset_mask1, reset_mask1, not_reset_mask2, reset_mask2;
7350
7351         not_reset_mask1 =
7352                 MISC_REGISTERS_RESET_REG_1_RST_HC |
7353                 MISC_REGISTERS_RESET_REG_1_RST_PXPV |
7354                 MISC_REGISTERS_RESET_REG_1_RST_PXP;
7355
7356         not_reset_mask2 =
7357                 MISC_REGISTERS_RESET_REG_2_RST_MDIO |
7358                 MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE |
7359                 MISC_REGISTERS_RESET_REG_2_RST_EMAC1_HARD_CORE |
7360                 MISC_REGISTERS_RESET_REG_2_RST_MISC_CORE |
7361                 MISC_REGISTERS_RESET_REG_2_RST_RBCN |
7362                 MISC_REGISTERS_RESET_REG_2_RST_GRC  |
7363                 MISC_REGISTERS_RESET_REG_2_RST_MCP_N_RESET_REG_HARD_CORE |
7364                 MISC_REGISTERS_RESET_REG_2_RST_MCP_N_HARD_CORE_RST_B;
7365
7366         reset_mask1 = 0xffffffff;
7367
7368         if (CHIP_IS_E1(bp))
7369                 reset_mask2 = 0xffff;
7370         else
7371                 reset_mask2 = 0x1ffff;
7372
7373         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
7374                reset_mask1 & (~not_reset_mask1));
7375         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
7376                reset_mask2 & (~not_reset_mask2));
7377
7378         barrier();
7379         mmiowb();
7380
7381         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, reset_mask1);
7382         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, reset_mask2);
7383         mmiowb();
7384 }
7385
7386 static int bnx2x_process_kill(struct bnx2x *bp)
7387 {
7388         int cnt = 1000;
7389         u32 val = 0;
7390         u32 sr_cnt, blk_cnt, port_is_idle_0, port_is_idle_1, pgl_exp_rom2;
7391
7392
7393         /* Empty the Tetris buffer, wait for 1s */
7394         do {
7395                 sr_cnt  = REG_RD(bp, PXP2_REG_RD_SR_CNT);
7396                 blk_cnt = REG_RD(bp, PXP2_REG_RD_BLK_CNT);
7397                 port_is_idle_0 = REG_RD(bp, PXP2_REG_RD_PORT_IS_IDLE_0);
7398                 port_is_idle_1 = REG_RD(bp, PXP2_REG_RD_PORT_IS_IDLE_1);
7399                 pgl_exp_rom2 = REG_RD(bp, PXP2_REG_PGL_EXP_ROM2);
7400                 if ((sr_cnt == 0x7e) && (blk_cnt == 0xa0) &&
7401                     ((port_is_idle_0 & 0x1) == 0x1) &&
7402                     ((port_is_idle_1 & 0x1) == 0x1) &&
7403                     (pgl_exp_rom2 == 0xffffffff))
7404                         break;
7405                 msleep(1);
7406         } while (cnt-- > 0);
7407
7408         if (cnt <= 0) {
7409                 DP(NETIF_MSG_HW, "Tetris buffer didn't get empty or there"
7410                           " are still"
7411                           " outstanding read requests after 1s!\n");
7412                 DP(NETIF_MSG_HW, "sr_cnt=0x%08x, blk_cnt=0x%08x,"
7413                           " port_is_idle_0=0x%08x,"
7414                           " port_is_idle_1=0x%08x, pgl_exp_rom2=0x%08x\n",
7415                           sr_cnt, blk_cnt, port_is_idle_0, port_is_idle_1,
7416                           pgl_exp_rom2);
7417                 return -EAGAIN;
7418         }
7419
7420         barrier();
7421
7422         /* Close gates #2, #3 and #4 */
7423         bnx2x_set_234_gates(bp, true);
7424
7425         /* TBD: Indicate that "process kill" is in progress to MCP */
7426
7427         /* Clear "unprepared" bit */
7428         REG_WR(bp, MISC_REG_UNPREPARED, 0);
7429         barrier();
7430
7431         /* Make sure all is written to the chip before the reset */
7432         mmiowb();
7433
7434         /* Wait for 1ms to empty GLUE and PCI-E core queues,
7435          * PSWHST, GRC and PSWRD Tetris buffer.
7436          */
7437         msleep(1);
7438
7439         /* Prepare to chip reset: */
7440         /* MCP */
7441         bnx2x_reset_mcp_prep(bp, &val);
7442
7443         /* PXP */
7444         bnx2x_pxp_prep(bp);
7445         barrier();
7446
7447         /* reset the chip */
7448         bnx2x_process_kill_chip_reset(bp);
7449         barrier();
7450
7451         /* Recover after reset: */
7452         /* MCP */
7453         if (bnx2x_reset_mcp_comp(bp, val))
7454                 return -EAGAIN;
7455
7456         /* PXP */
7457         bnx2x_pxp_prep(bp);
7458
7459         /* Open the gates #2, #3 and #4 */
7460         bnx2x_set_234_gates(bp, false);
7461
7462         /* TBD: IGU/AEU preparation bring back the AEU/IGU to a
7463          * reset state, re-enable attentions. */
7464
7465         return 0;
7466 }
7467
7468 static int bnx2x_leader_reset(struct bnx2x *bp)
7469 {
7470         int rc = 0;
7471         /* Try to recover after the failure */
7472         if (bnx2x_process_kill(bp)) {
7473                 printk(KERN_ERR "%s: Something bad had happen! Aii!\n",
7474                        bp->dev->name);
7475                 rc = -EAGAIN;
7476                 goto exit_leader_reset;
7477         }
7478
7479         /* Clear "reset is in progress" bit and update the driver state */
7480         bnx2x_set_reset_done(bp);
7481         bp->recovery_state = BNX2X_RECOVERY_DONE;
7482
7483 exit_leader_reset:
7484         bp->is_leader = 0;
7485         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_RESERVED_08);
7486         smp_wmb();
7487         return rc;
7488 }
7489
7490 /* Assumption: runs under rtnl lock. This together with the fact
7491  * that it's called only from bnx2x_reset_task() ensure that it
7492  * will never be called when netif_running(bp->dev) is false.
7493  */
7494 static void bnx2x_parity_recover(struct bnx2x *bp)
7495 {
7496         DP(NETIF_MSG_HW, "Handling parity\n");
7497         while (1) {
7498                 switch (bp->recovery_state) {
7499                 case BNX2X_RECOVERY_INIT:
7500                         DP(NETIF_MSG_HW, "State is BNX2X_RECOVERY_INIT\n");
7501                         /* Try to get a LEADER_LOCK HW lock */
7502                         if (bnx2x_trylock_hw_lock(bp,
7503                                 HW_LOCK_RESOURCE_RESERVED_08))
7504                                 bp->is_leader = 1;
7505
7506                         /* Stop the driver */
7507                         /* If interface has been removed - break */
7508                         if (bnx2x_nic_unload(bp, UNLOAD_RECOVERY))
7509                                 return;
7510
7511                         bp->recovery_state = BNX2X_RECOVERY_WAIT;
7512                         /* Ensure "is_leader" and "recovery_state"
7513                          *  update values are seen on other CPUs
7514                          */
7515                         smp_wmb();
7516                         break;
7517
7518                 case BNX2X_RECOVERY_WAIT:
7519                         DP(NETIF_MSG_HW, "State is BNX2X_RECOVERY_WAIT\n");
7520                         if (bp->is_leader) {
7521                                 u32 load_counter = bnx2x_get_load_cnt(bp);
7522                                 if (load_counter) {
7523                                         /* Wait until all other functions get
7524                                          * down.
7525                                          */
7526                                         schedule_delayed_work(&bp->reset_task,
7527                                                                 HZ/10);
7528                                         return;
7529                                 } else {
7530                                         /* If all other functions got down -
7531                                          * try to bring the chip back to
7532                                          * normal. In any case it's an exit
7533                                          * point for a leader.
7534                                          */
7535                                         if (bnx2x_leader_reset(bp) ||
7536                                         bnx2x_nic_load(bp, LOAD_NORMAL)) {
7537                                                 printk(KERN_ERR"%s: Recovery "
7538                                                 "has failed. Power cycle is "
7539                                                 "needed.\n", bp->dev->name);
7540                                                 /* Disconnect this device */
7541                                                 netif_device_detach(bp->dev);
7542                                                 /* Block ifup for all function
7543                                                  * of this ASIC until
7544                                                  * "process kill" or power
7545                                                  * cycle.
7546                                                  */
7547                                                 bnx2x_set_reset_in_progress(bp);
7548                                                 /* Shut down the power */
7549                                                 bnx2x_set_power_state(bp,
7550                                                                 PCI_D3hot);
7551                                                 return;
7552                                         }
7553
7554                                         return;
7555                                 }
7556                         } else { /* non-leader */
7557                                 if (!bnx2x_reset_is_done(bp)) {
7558                                         /* Try to get a LEADER_LOCK HW lock as
7559                                          * long as a former leader may have
7560                                          * been unloaded by the user or
7561                                          * released a leadership by another
7562                                          * reason.
7563                                          */
7564                                         if (bnx2x_trylock_hw_lock(bp,
7565                                             HW_LOCK_RESOURCE_RESERVED_08)) {
7566                                                 /* I'm a leader now! Restart a
7567                                                  * switch case.
7568                                                  */
7569                                                 bp->is_leader = 1;
7570                                                 break;
7571                                         }
7572
7573                                         schedule_delayed_work(&bp->reset_task,
7574                                                                 HZ/10);
7575                                         return;
7576
7577                                 } else { /* A leader has completed
7578                                           * the "process kill". It's an exit
7579                                           * point for a non-leader.
7580                                           */
7581                                         bnx2x_nic_load(bp, LOAD_NORMAL);
7582                                         bp->recovery_state =
7583                                                 BNX2X_RECOVERY_DONE;
7584                                         smp_wmb();
7585                                         return;
7586                                 }
7587                         }
7588                 default:
7589                         return;
7590                 }
7591         }
7592 }
7593
7594 /* bnx2x_nic_unload() flushes the bnx2x_wq, thus reset task is
7595  * scheduled on a general queue in order to prevent a dead lock.
7596  */
7597 static void bnx2x_reset_task(struct work_struct *work)
7598 {
7599         struct bnx2x *bp = container_of(work, struct bnx2x, reset_task.work);
7600
7601 #ifdef BNX2X_STOP_ON_ERROR
7602         BNX2X_ERR("reset task called but STOP_ON_ERROR defined"
7603                   " so reset not done to allow debug dump,\n"
7604          KERN_ERR " you will need to reboot when done\n");
7605         return;
7606 #endif
7607
7608         rtnl_lock();
7609
7610         if (!netif_running(bp->dev))
7611                 goto reset_task_exit;
7612
7613         if (unlikely(bp->recovery_state != BNX2X_RECOVERY_DONE))
7614                 bnx2x_parity_recover(bp);
7615         else {
7616                 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
7617                 bnx2x_nic_load(bp, LOAD_NORMAL);
7618         }
7619
7620 reset_task_exit:
7621         rtnl_unlock();
7622 }
7623
7624 /* end of nic load/unload */
7625
7626 /*
7627  * Init service functions
7628  */
7629
7630 static u32 bnx2x_get_pretend_reg(struct bnx2x *bp)
7631 {
7632         u32 base = PXP2_REG_PGL_PRETEND_FUNC_F0;
7633         u32 stride = PXP2_REG_PGL_PRETEND_FUNC_F1 - base;
7634         return base + (BP_ABS_FUNC(bp)) * stride;
7635 }
7636
7637 static void bnx2x_undi_int_disable_e1h(struct bnx2x *bp)
7638 {
7639         u32 reg = bnx2x_get_pretend_reg(bp);
7640
7641         /* Flush all outstanding writes */
7642         mmiowb();
7643
7644         /* Pretend to be function 0 */
7645         REG_WR(bp, reg, 0);
7646         REG_RD(bp, reg);        /* Flush the GRC transaction (in the chip) */
7647
7648         /* From now we are in the "like-E1" mode */
7649         bnx2x_int_disable(bp);
7650
7651         /* Flush all outstanding writes */
7652         mmiowb();
7653
7654         /* Restore the original function */
7655         REG_WR(bp, reg, BP_ABS_FUNC(bp));
7656         REG_RD(bp, reg);
7657 }
7658
7659 static inline void bnx2x_undi_int_disable(struct bnx2x *bp)
7660 {
7661         if (CHIP_IS_E1(bp))
7662                 bnx2x_int_disable(bp);
7663         else
7664                 bnx2x_undi_int_disable_e1h(bp);
7665 }
7666
7667 static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
7668 {
7669         u32 val;
7670
7671         /* Check if there is any driver already loaded */
7672         val = REG_RD(bp, MISC_REG_UNPREPARED);
7673         if (val == 0x1) {
7674                 /* Check if it is the UNDI driver
7675                  * UNDI driver initializes CID offset for normal bell to 0x7
7676                  */
7677                 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7678                 val = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
7679                 if (val == 0x7) {
7680                         u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7681                         /* save our pf_num */
7682                         int orig_pf_num = bp->pf_num;
7683                         u32 swap_en;
7684                         u32 swap_val;
7685
7686                         /* clear the UNDI indication */
7687                         REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
7688
7689                         BNX2X_DEV_INFO("UNDI is active! reset device\n");
7690
7691                         /* try unload UNDI on port 0 */
7692                         bp->pf_num = 0;
7693                         bp->fw_seq =
7694                               (SHMEM_RD(bp, func_mb[bp->pf_num].drv_mb_header) &
7695                                 DRV_MSG_SEQ_NUMBER_MASK);
7696                         reset_code = bnx2x_fw_command(bp, reset_code, 0);
7697
7698                         /* if UNDI is loaded on the other port */
7699                         if (reset_code != FW_MSG_CODE_DRV_UNLOAD_COMMON) {
7700
7701                                 /* send "DONE" for previous unload */
7702                                 bnx2x_fw_command(bp,
7703                                                  DRV_MSG_CODE_UNLOAD_DONE, 0);
7704
7705                                 /* unload UNDI on port 1 */
7706                                 bp->pf_num = 1;
7707                                 bp->fw_seq =
7708                               (SHMEM_RD(bp, func_mb[bp->pf_num].drv_mb_header) &
7709                                         DRV_MSG_SEQ_NUMBER_MASK);
7710                                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7711
7712                                 bnx2x_fw_command(bp, reset_code, 0);
7713                         }
7714
7715                         /* now it's safe to release the lock */
7716                         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7717
7718                         bnx2x_undi_int_disable(bp);
7719
7720                         /* close input traffic and wait for it */
7721                         /* Do not rcv packets to BRB */
7722                         REG_WR(bp,
7723                               (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_DRV_MASK :
7724                                              NIG_REG_LLH0_BRB1_DRV_MASK), 0x0);
7725                         /* Do not direct rcv packets that are not for MCP to
7726                          * the BRB */
7727                         REG_WR(bp,
7728                                (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_NOT_MCP :
7729                                               NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
7730                         /* clear AEU */
7731                         REG_WR(bp,
7732                              (BP_PORT(bp) ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
7733                                             MISC_REG_AEU_MASK_ATTN_FUNC_0), 0);
7734                         msleep(10);
7735
7736                         /* save NIG port swap info */
7737                         swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
7738                         swap_en = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
7739                         /* reset device */
7740                         REG_WR(bp,
7741                                GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
7742                                0xd3ffffff);
7743                         REG_WR(bp,
7744                                GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
7745                                0x1403);
7746                         /* take the NIG out of reset and restore swap values */
7747                         REG_WR(bp,
7748                                GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
7749                                MISC_REGISTERS_RESET_REG_1_RST_NIG);
7750                         REG_WR(bp, NIG_REG_PORT_SWAP, swap_val);
7751                         REG_WR(bp, NIG_REG_STRAP_OVERRIDE, swap_en);
7752
7753                         /* send unload done to the MCP */
7754                         bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
7755
7756                         /* restore our func and fw_seq */
7757                         bp->pf_num = orig_pf_num;
7758                         bp->fw_seq =
7759                               (SHMEM_RD(bp, func_mb[bp->pf_num].drv_mb_header) &
7760                                 DRV_MSG_SEQ_NUMBER_MASK);
7761                 } else
7762                         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7763         }
7764 }
7765
7766 static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
7767 {
7768         u32 val, val2, val3, val4, id;
7769         u16 pmc;
7770
7771         /* Get the chip revision id and number. */
7772         /* chip num:16-31, rev:12-15, metal:4-11, bond_id:0-3 */
7773         val = REG_RD(bp, MISC_REG_CHIP_NUM);
7774         id = ((val & 0xffff) << 16);
7775         val = REG_RD(bp, MISC_REG_CHIP_REV);
7776         id |= ((val & 0xf) << 12);
7777         val = REG_RD(bp, MISC_REG_CHIP_METAL);
7778         id |= ((val & 0xff) << 4);
7779         val = REG_RD(bp, MISC_REG_BOND_ID);
7780         id |= (val & 0xf);
7781         bp->common.chip_id = id;
7782
7783         /* Set doorbell size */
7784         bp->db_size = (1 << BNX2X_DB_SHIFT);
7785
7786         if (CHIP_IS_E2(bp)) {
7787                 val = REG_RD(bp, MISC_REG_PORT4MODE_EN_OVWR);
7788                 if ((val & 1) == 0)
7789                         val = REG_RD(bp, MISC_REG_PORT4MODE_EN);
7790                 else
7791                         val = (val >> 1) & 1;
7792                 BNX2X_DEV_INFO("chip is in %s\n", val ? "4_PORT_MODE" :
7793                                                        "2_PORT_MODE");
7794                 bp->common.chip_port_mode = val ? CHIP_4_PORT_MODE :
7795                                                  CHIP_2_PORT_MODE;
7796
7797                 if (CHIP_MODE_IS_4_PORT(bp))
7798                         bp->pfid = (bp->pf_num >> 1);   /* 0..3 */
7799                 else
7800                         bp->pfid = (bp->pf_num & 0x6);  /* 0, 2, 4, 6 */
7801         } else {
7802                 bp->common.chip_port_mode = CHIP_PORT_MODE_NONE; /* N/A */
7803                 bp->pfid = bp->pf_num;                  /* 0..7 */
7804         }
7805
7806         /*
7807          * set base FW non-default (fast path) status block id, this value is
7808          * used to initialize the fw_sb_id saved on the fp/queue structure to
7809          * determine the id used by the FW.
7810          */
7811         if (CHIP_IS_E1x(bp))
7812                 bp->base_fw_ndsb = BP_PORT(bp) * FP_SB_MAX_E1x;
7813         else /* E2 */
7814                 bp->base_fw_ndsb = BP_PORT(bp) * FP_SB_MAX_E2;
7815
7816         bp->link_params.chip_id = bp->common.chip_id;
7817         BNX2X_DEV_INFO("chip ID is 0x%x\n", id);
7818
7819         val = (REG_RD(bp, 0x2874) & 0x55);
7820         if ((bp->common.chip_id & 0x1) ||
7821             (CHIP_IS_E1(bp) && val) || (CHIP_IS_E1H(bp) && (val == 0x55))) {
7822                 bp->flags |= ONE_PORT_FLAG;
7823                 BNX2X_DEV_INFO("single port device\n");
7824         }
7825
7826         val = REG_RD(bp, MCP_REG_MCPR_NVM_CFG4);
7827         bp->common.flash_size = (NVRAM_1MB_SIZE <<
7828                                  (val & MCPR_NVM_CFG4_FLASH_SIZE));
7829         BNX2X_DEV_INFO("flash_size 0x%x (%d)\n",
7830                        bp->common.flash_size, bp->common.flash_size);
7831
7832         bnx2x_init_shmem(bp);
7833
7834         bp->common.shmem2_base = REG_RD(bp, (BP_PATH(bp) ?
7835                                         MISC_REG_GENERIC_CR_1 :
7836                                         MISC_REG_GENERIC_CR_0));
7837
7838         bp->link_params.shmem_base = bp->common.shmem_base;
7839         bp->link_params.shmem2_base = bp->common.shmem2_base;
7840         BNX2X_DEV_INFO("shmem offset 0x%x  shmem2 offset 0x%x\n",
7841                        bp->common.shmem_base, bp->common.shmem2_base);
7842
7843         if (!bp->common.shmem_base) {
7844                 BNX2X_DEV_INFO("MCP not active\n");
7845                 bp->flags |= NO_MCP_FLAG;
7846                 return;
7847         }
7848
7849         bp->common.hw_config = SHMEM_RD(bp, dev_info.shared_hw_config.config);
7850         BNX2X_DEV_INFO("hw_config 0x%08x\n", bp->common.hw_config);
7851
7852         bp->link_params.hw_led_mode = ((bp->common.hw_config &
7853                                         SHARED_HW_CFG_LED_MODE_MASK) >>
7854                                        SHARED_HW_CFG_LED_MODE_SHIFT);
7855
7856         bp->link_params.feature_config_flags = 0;
7857         val = SHMEM_RD(bp, dev_info.shared_feature_config.config);
7858         if (val & SHARED_FEAT_CFG_OVERRIDE_PREEMPHASIS_CFG_ENABLED)
7859                 bp->link_params.feature_config_flags |=
7860                                 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED;
7861         else
7862                 bp->link_params.feature_config_flags &=
7863                                 ~FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED;
7864
7865         val = SHMEM_RD(bp, dev_info.bc_rev) >> 8;
7866         bp->common.bc_ver = val;
7867         BNX2X_DEV_INFO("bc_ver %X\n", val);
7868         if (val < BNX2X_BC_VER) {
7869                 /* for now only warn
7870                  * later we might need to enforce this */
7871                 BNX2X_ERR("This driver needs bc_ver %X but found %X, "
7872                           "please upgrade BC\n", BNX2X_BC_VER, val);
7873         }
7874         bp->link_params.feature_config_flags |=
7875                                 (val >= REQ_BC_VER_4_VRFY_FIRST_PHY_OPT_MDL) ?
7876                                 FEATURE_CONFIG_BC_SUPPORTS_OPT_MDL_VRFY : 0;
7877
7878         bp->link_params.feature_config_flags |=
7879                 (val >= REQ_BC_VER_4_VRFY_SPECIFIC_PHY_OPT_MDL) ?
7880                 FEATURE_CONFIG_BC_SUPPORTS_DUAL_PHY_OPT_MDL_VRFY : 0;
7881
7882         pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_PMC, &pmc);
7883         bp->flags |= (pmc & PCI_PM_CAP_PME_D3cold) ? 0 : NO_WOL_FLAG;
7884
7885         BNX2X_DEV_INFO("%sWoL capable\n",
7886                        (bp->flags & NO_WOL_FLAG) ? "not " : "");
7887
7888         val = SHMEM_RD(bp, dev_info.shared_hw_config.part_num);
7889         val2 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[4]);
7890         val3 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[8]);
7891         val4 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[12]);
7892
7893         dev_info(&bp->pdev->dev, "part number %X-%X-%X-%X\n",
7894                  val, val2, val3, val4);
7895 }
7896
7897 #define IGU_FID(val)    GET_FIELD((val), IGU_REG_MAPPING_MEMORY_FID)
7898 #define IGU_VEC(val)    GET_FIELD((val), IGU_REG_MAPPING_MEMORY_VECTOR)
7899
7900 static void __devinit bnx2x_get_igu_cam_info(struct bnx2x *bp)
7901 {
7902         int pfid = BP_FUNC(bp);
7903         int vn = BP_E1HVN(bp);
7904         int igu_sb_id;
7905         u32 val;
7906         u8 fid;
7907
7908         bp->igu_base_sb = 0xff;
7909         bp->igu_sb_cnt = 0;
7910         if (CHIP_INT_MODE_IS_BC(bp)) {
7911                 bp->igu_sb_cnt = min_t(u8, FP_SB_MAX_E1x,
7912                                        NUM_IGU_SB_REQUIRED(bp->l2_cid_count));
7913
7914                 bp->igu_base_sb = (CHIP_MODE_IS_4_PORT(bp) ? pfid : vn) *
7915                         FP_SB_MAX_E1x;
7916
7917                 bp->igu_dsb_id =  E1HVN_MAX * FP_SB_MAX_E1x +
7918                         (CHIP_MODE_IS_4_PORT(bp) ? pfid : vn);
7919
7920                 return;
7921         }
7922
7923         /* IGU in normal mode - read CAM */
7924         for (igu_sb_id = 0; igu_sb_id < IGU_REG_MAPPING_MEMORY_SIZE;
7925              igu_sb_id++) {
7926                 val = REG_RD(bp, IGU_REG_MAPPING_MEMORY + igu_sb_id * 4);
7927                 if (!(val & IGU_REG_MAPPING_MEMORY_VALID))
7928                         continue;
7929                 fid = IGU_FID(val);
7930                 if ((fid & IGU_FID_ENCODE_IS_PF)) {
7931                         if ((fid & IGU_FID_PF_NUM_MASK) != pfid)
7932                                 continue;
7933                         if (IGU_VEC(val) == 0)
7934                                 /* default status block */
7935                                 bp->igu_dsb_id = igu_sb_id;
7936                         else {
7937                                 if (bp->igu_base_sb == 0xff)
7938                                         bp->igu_base_sb = igu_sb_id;
7939                                 bp->igu_sb_cnt++;
7940                         }
7941                 }
7942         }
7943         bp->igu_sb_cnt = min_t(u8, bp->igu_sb_cnt,
7944                                    NUM_IGU_SB_REQUIRED(bp->l2_cid_count));
7945         if (bp->igu_sb_cnt == 0)
7946                 BNX2X_ERR("CAM configuration error\n");
7947 }
7948
7949 static void __devinit bnx2x_link_settings_supported(struct bnx2x *bp,
7950                                                     u32 switch_cfg)
7951 {
7952         int cfg_size = 0, idx, port = BP_PORT(bp);
7953
7954         /* Aggregation of supported attributes of all external phys */
7955         bp->port.supported[0] = 0;
7956         bp->port.supported[1] = 0;
7957         switch (bp->link_params.num_phys) {
7958         case 1:
7959                 bp->port.supported[0] = bp->link_params.phy[INT_PHY].supported;
7960                 cfg_size = 1;
7961                 break;
7962         case 2:
7963                 bp->port.supported[0] = bp->link_params.phy[EXT_PHY1].supported;
7964                 cfg_size = 1;
7965                 break;
7966         case 3:
7967                 if (bp->link_params.multi_phy_config &
7968                     PORT_HW_CFG_PHY_SWAPPED_ENABLED) {
7969                         bp->port.supported[1] =
7970                                 bp->link_params.phy[EXT_PHY1].supported;
7971                         bp->port.supported[0] =
7972                                 bp->link_params.phy[EXT_PHY2].supported;
7973                 } else {
7974                         bp->port.supported[0] =
7975                                 bp->link_params.phy[EXT_PHY1].supported;
7976                         bp->port.supported[1] =
7977                                 bp->link_params.phy[EXT_PHY2].supported;
7978                 }
7979                 cfg_size = 2;
7980                 break;
7981         }
7982
7983         if (!(bp->port.supported[0] || bp->port.supported[1])) {
7984                 BNX2X_ERR("NVRAM config error. BAD phy config."
7985                           "PHY1 config 0x%x, PHY2 config 0x%x\n",
7986                            SHMEM_RD(bp,
7987                            dev_info.port_hw_config[port].external_phy_config),
7988                            SHMEM_RD(bp,
7989                            dev_info.port_hw_config[port].external_phy_config2));
7990                         return;
7991         }
7992
7993         switch (switch_cfg) {
7994         case SWITCH_CFG_1G:
7995                 bp->port.phy_addr = REG_RD(bp, NIG_REG_SERDES0_CTRL_PHY_ADDR +
7996                                            port*0x10);
7997                 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
7998                 break;
7999
8000         case SWITCH_CFG_10G:
8001                 bp->port.phy_addr = REG_RD(bp, NIG_REG_XGXS0_CTRL_PHY_ADDR +
8002                                            port*0x18);
8003                 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
8004                 break;
8005
8006         default:
8007                 BNX2X_ERR("BAD switch_cfg link_config 0x%x\n",
8008                           bp->port.link_config[0]);
8009                 return;
8010         }
8011         /* mask what we support according to speed_cap_mask per configuration */
8012         for (idx = 0; idx < cfg_size; idx++) {
8013                 if (!(bp->link_params.speed_cap_mask[idx] &
8014                                 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF))
8015                         bp->port.supported[idx] &= ~SUPPORTED_10baseT_Half;
8016
8017                 if (!(bp->link_params.speed_cap_mask[idx] &
8018                                 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL))
8019                         bp->port.supported[idx] &= ~SUPPORTED_10baseT_Full;
8020
8021                 if (!(bp->link_params.speed_cap_mask[idx] &
8022                                 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF))
8023                         bp->port.supported[idx] &= ~SUPPORTED_100baseT_Half;
8024
8025                 if (!(bp->link_params.speed_cap_mask[idx] &
8026                                 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL))
8027                         bp->port.supported[idx] &= ~SUPPORTED_100baseT_Full;
8028
8029                 if (!(bp->link_params.speed_cap_mask[idx] &
8030                                         PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))
8031                         bp->port.supported[idx] &= ~(SUPPORTED_1000baseT_Half |
8032                                                      SUPPORTED_1000baseT_Full);
8033
8034                 if (!(bp->link_params.speed_cap_mask[idx] &
8035                                         PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
8036                         bp->port.supported[idx] &= ~SUPPORTED_2500baseX_Full;
8037
8038                 if (!(bp->link_params.speed_cap_mask[idx] &
8039                                         PORT_HW_CFG_SPEED_CAPABILITY_D0_10G))
8040                         bp->port.supported[idx] &= ~SUPPORTED_10000baseT_Full;
8041
8042         }
8043
8044         BNX2X_DEV_INFO("supported 0x%x 0x%x\n", bp->port.supported[0],
8045                        bp->port.supported[1]);
8046 }
8047
8048 static void __devinit bnx2x_link_settings_requested(struct bnx2x *bp)
8049 {
8050         u32 link_config, idx, cfg_size = 0;
8051         bp->port.advertising[0] = 0;
8052         bp->port.advertising[1] = 0;
8053         switch (bp->link_params.num_phys) {
8054         case 1:
8055         case 2:
8056                 cfg_size = 1;
8057                 break;
8058         case 3:
8059                 cfg_size = 2;
8060                 break;
8061         }
8062         for (idx = 0; idx < cfg_size; idx++) {
8063                 bp->link_params.req_duplex[idx] = DUPLEX_FULL;
8064                 link_config = bp->port.link_config[idx];
8065                 switch (link_config & PORT_FEATURE_LINK_SPEED_MASK) {
8066                 case PORT_FEATURE_LINK_SPEED_AUTO:
8067                         if (bp->port.supported[idx] & SUPPORTED_Autoneg) {
8068                                 bp->link_params.req_line_speed[idx] =
8069                                         SPEED_AUTO_NEG;
8070                                 bp->port.advertising[idx] |=
8071                                         bp->port.supported[idx];
8072                         } else {
8073                                 /* force 10G, no AN */
8074                                 bp->link_params.req_line_speed[idx] =
8075                                         SPEED_10000;
8076                                 bp->port.advertising[idx] |=
8077                                         (ADVERTISED_10000baseT_Full |
8078                                          ADVERTISED_FIBRE);
8079                                 continue;
8080                         }
8081                         break;
8082
8083                 case PORT_FEATURE_LINK_SPEED_10M_FULL:
8084                         if (bp->port.supported[idx] & SUPPORTED_10baseT_Full) {
8085                                 bp->link_params.req_line_speed[idx] =
8086                                         SPEED_10;
8087                                 bp->port.advertising[idx] |=
8088                                         (ADVERTISED_10baseT_Full |
8089                                          ADVERTISED_TP);
8090                         } else {
8091                                 BNX2X_ERROR("NVRAM config error. "
8092                                             "Invalid link_config 0x%x"
8093                                             "  speed_cap_mask 0x%x\n",
8094                                             link_config,
8095                                     bp->link_params.speed_cap_mask[idx]);
8096                                 return;
8097                         }
8098                         break;
8099
8100                 case PORT_FEATURE_LINK_SPEED_10M_HALF:
8101                         if (bp->port.supported[idx] & SUPPORTED_10baseT_Half) {
8102                                 bp->link_params.req_line_speed[idx] =
8103                                         SPEED_10;
8104                                 bp->link_params.req_duplex[idx] =
8105                                         DUPLEX_HALF;
8106                                 bp->port.advertising[idx] |=
8107                                         (ADVERTISED_10baseT_Half |
8108                                          ADVERTISED_TP);
8109                         } else {
8110                                 BNX2X_ERROR("NVRAM config error. "
8111                                             "Invalid link_config 0x%x"
8112                                             "  speed_cap_mask 0x%x\n",
8113                                             link_config,
8114                                           bp->link_params.speed_cap_mask[idx]);
8115                                 return;
8116                         }
8117                         break;
8118
8119                 case PORT_FEATURE_LINK_SPEED_100M_FULL:
8120                         if (bp->port.supported[idx] &
8121                             SUPPORTED_100baseT_Full) {
8122                                 bp->link_params.req_line_speed[idx] =
8123                                         SPEED_100;
8124                                 bp->port.advertising[idx] |=
8125                                         (ADVERTISED_100baseT_Full |
8126                                          ADVERTISED_TP);
8127                         } else {
8128                                 BNX2X_ERROR("NVRAM config error. "
8129                                             "Invalid link_config 0x%x"
8130                                             "  speed_cap_mask 0x%x\n",
8131                                             link_config,
8132                                           bp->link_params.speed_cap_mask[idx]);
8133                                 return;
8134                         }
8135                         break;
8136
8137                 case PORT_FEATURE_LINK_SPEED_100M_HALF:
8138                         if (bp->port.supported[idx] &
8139                             SUPPORTED_100baseT_Half) {
8140                                 bp->link_params.req_line_speed[idx] =
8141                                                                 SPEED_100;
8142                                 bp->link_params.req_duplex[idx] =
8143                                                                 DUPLEX_HALF;
8144                                 bp->port.advertising[idx] |=
8145                                         (ADVERTISED_100baseT_Half |
8146                                          ADVERTISED_TP);
8147                         } else {
8148                                 BNX2X_ERROR("NVRAM config error. "
8149                                     "Invalid link_config 0x%x"
8150                                     "  speed_cap_mask 0x%x\n",
8151                                     link_config,
8152                                     bp->link_params.speed_cap_mask[idx]);
8153                                 return;
8154                         }
8155                         break;
8156
8157                 case PORT_FEATURE_LINK_SPEED_1G:
8158                         if (bp->port.supported[idx] &
8159                             SUPPORTED_1000baseT_Full) {
8160                                 bp->link_params.req_line_speed[idx] =
8161                                         SPEED_1000;
8162                                 bp->port.advertising[idx] |=
8163                                         (ADVERTISED_1000baseT_Full |
8164                                          ADVERTISED_TP);
8165                         } else {
8166                                 BNX2X_ERROR("NVRAM config error. "
8167                                     "Invalid link_config 0x%x"
8168                                     "  speed_cap_mask 0x%x\n",
8169                                     link_config,
8170                                     bp->link_params.speed_cap_mask[idx]);
8171                                 return;
8172                         }
8173                         break;
8174
8175                 case PORT_FEATURE_LINK_SPEED_2_5G:
8176                         if (bp->port.supported[idx] &
8177                             SUPPORTED_2500baseX_Full) {
8178                                 bp->link_params.req_line_speed[idx] =
8179                                         SPEED_2500;
8180                                 bp->port.advertising[idx] |=
8181                                         (ADVERTISED_2500baseX_Full |
8182                                                 ADVERTISED_TP);
8183                         } else {
8184                                 BNX2X_ERROR("NVRAM config error. "
8185                                     "Invalid link_config 0x%x"
8186                                     "  speed_cap_mask 0x%x\n",
8187                                     link_config,
8188                                     bp->link_params.speed_cap_mask[idx]);
8189                                 return;
8190                         }
8191                         break;
8192
8193                 case PORT_FEATURE_LINK_SPEED_10G_CX4:
8194                 case PORT_FEATURE_LINK_SPEED_10G_KX4:
8195                 case PORT_FEATURE_LINK_SPEED_10G_KR:
8196                         if (bp->port.supported[idx] &
8197                             SUPPORTED_10000baseT_Full) {
8198                                 bp->link_params.req_line_speed[idx] =
8199                                         SPEED_10000;
8200                                 bp->port.advertising[idx] |=
8201                                         (ADVERTISED_10000baseT_Full |
8202                                                 ADVERTISED_FIBRE);
8203                         } else {
8204                                 BNX2X_ERROR("NVRAM config error. "
8205                                     "Invalid link_config 0x%x"
8206                                     "  speed_cap_mask 0x%x\n",
8207                                     link_config,
8208                                     bp->link_params.speed_cap_mask[idx]);
8209                                 return;
8210                         }
8211                         break;
8212
8213                 default:
8214                         BNX2X_ERROR("NVRAM config error. "
8215                                     "BAD link speed link_config 0x%x\n",
8216                                           link_config);
8217                                 bp->link_params.req_line_speed[idx] =
8218                                                         SPEED_AUTO_NEG;
8219                                 bp->port.advertising[idx] =
8220                                                 bp->port.supported[idx];
8221                         break;
8222                 }
8223
8224                 bp->link_params.req_flow_ctrl[idx] = (link_config &
8225                                          PORT_FEATURE_FLOW_CONTROL_MASK);
8226                 if ((bp->link_params.req_flow_ctrl[idx] ==
8227                      BNX2X_FLOW_CTRL_AUTO) &&
8228                     !(bp->port.supported[idx] & SUPPORTED_Autoneg)) {
8229                         bp->link_params.req_flow_ctrl[idx] =
8230                                 BNX2X_FLOW_CTRL_NONE;
8231                 }
8232
8233                 BNX2X_DEV_INFO("req_line_speed %d  req_duplex %d req_flow_ctrl"
8234                                " 0x%x advertising 0x%x\n",
8235                                bp->link_params.req_line_speed[idx],
8236                                bp->link_params.req_duplex[idx],
8237                                bp->link_params.req_flow_ctrl[idx],
8238                                bp->port.advertising[idx]);
8239         }
8240 }
8241
8242 static void __devinit bnx2x_set_mac_buf(u8 *mac_buf, u32 mac_lo, u16 mac_hi)
8243 {
8244         mac_hi = cpu_to_be16(mac_hi);
8245         mac_lo = cpu_to_be32(mac_lo);
8246         memcpy(mac_buf, &mac_hi, sizeof(mac_hi));
8247         memcpy(mac_buf + sizeof(mac_hi), &mac_lo, sizeof(mac_lo));
8248 }
8249
8250 static void __devinit bnx2x_get_port_hwinfo(struct bnx2x *bp)
8251 {
8252         int port = BP_PORT(bp);
8253         u32 config;
8254         u32 ext_phy_type, ext_phy_config;
8255
8256         bp->link_params.bp = bp;
8257         bp->link_params.port = port;
8258
8259         bp->link_params.lane_config =
8260                 SHMEM_RD(bp, dev_info.port_hw_config[port].lane_config);
8261
8262         bp->link_params.speed_cap_mask[0] =
8263                 SHMEM_RD(bp,
8264                          dev_info.port_hw_config[port].speed_capability_mask);
8265         bp->link_params.speed_cap_mask[1] =
8266                 SHMEM_RD(bp,
8267                          dev_info.port_hw_config[port].speed_capability_mask2);
8268         bp->port.link_config[0] =
8269                 SHMEM_RD(bp, dev_info.port_feature_config[port].link_config);
8270
8271         bp->port.link_config[1] =
8272                 SHMEM_RD(bp, dev_info.port_feature_config[port].link_config2);
8273
8274         bp->link_params.multi_phy_config =
8275                 SHMEM_RD(bp, dev_info.port_hw_config[port].multi_phy_config);
8276         /* If the device is capable of WoL, set the default state according
8277          * to the HW
8278          */
8279         config = SHMEM_RD(bp, dev_info.port_feature_config[port].config);
8280         bp->wol = (!(bp->flags & NO_WOL_FLAG) &&
8281                    (config & PORT_FEATURE_WOL_ENABLED));
8282
8283         BNX2X_DEV_INFO("lane_config 0x%08x  "
8284                        "speed_cap_mask0 0x%08x  link_config0 0x%08x\n",
8285                        bp->link_params.lane_config,
8286                        bp->link_params.speed_cap_mask[0],
8287                        bp->port.link_config[0]);
8288
8289         bp->link_params.switch_cfg = (bp->port.link_config[0] &
8290                                       PORT_FEATURE_CONNECTED_SWITCH_MASK);
8291         bnx2x_phy_probe(&bp->link_params);
8292         bnx2x_link_settings_supported(bp, bp->link_params.switch_cfg);
8293
8294         bnx2x_link_settings_requested(bp);
8295
8296         /*
8297          * If connected directly, work with the internal PHY, otherwise, work
8298          * with the external PHY
8299          */
8300         ext_phy_config =
8301                 SHMEM_RD(bp,
8302                          dev_info.port_hw_config[port].external_phy_config);
8303         ext_phy_type = XGXS_EXT_PHY_TYPE(ext_phy_config);
8304         if (ext_phy_type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT)
8305                 bp->mdio.prtad = bp->port.phy_addr;
8306
8307         else if ((ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) &&
8308                  (ext_phy_type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_NOT_CONN))
8309                 bp->mdio.prtad =
8310                         XGXS_EXT_PHY_ADDR(ext_phy_config);
8311
8312         /*
8313          * Check if hw lock is required to access MDC/MDIO bus to the PHY(s)
8314          * In MF mode, it is set to cover self test cases
8315          */
8316         if (IS_MF(bp))
8317                 bp->port.need_hw_lock = 1;
8318         else
8319                 bp->port.need_hw_lock = bnx2x_hw_lock_required(bp,
8320                                                         bp->common.shmem_base,
8321                                                         bp->common.shmem2_base);
8322 }
8323
8324 #ifdef BCM_CNIC
8325 static void __devinit bnx2x_get_cnic_info(struct bnx2x *bp)
8326 {
8327         u32 max_iscsi_conn = FW_ENCODE_32BIT_PATTERN ^ SHMEM_RD(bp,
8328                                 drv_lic_key[BP_PORT(bp)].max_iscsi_conn);
8329         u32 max_fcoe_conn = FW_ENCODE_32BIT_PATTERN ^ SHMEM_RD(bp,
8330                                 drv_lic_key[BP_PORT(bp)].max_fcoe_conn);
8331
8332         /* Get the number of maximum allowed iSCSI and FCoE connections */
8333         bp->cnic_eth_dev.max_iscsi_conn =
8334                 (max_iscsi_conn & BNX2X_MAX_ISCSI_INIT_CONN_MASK) >>
8335                 BNX2X_MAX_ISCSI_INIT_CONN_SHIFT;
8336
8337         bp->cnic_eth_dev.max_fcoe_conn =
8338                 (max_fcoe_conn & BNX2X_MAX_FCOE_INIT_CONN_MASK) >>
8339                 BNX2X_MAX_FCOE_INIT_CONN_SHIFT;
8340
8341         BNX2X_DEV_INFO("max_iscsi_conn 0x%x max_fcoe_conn 0x%x\n",
8342                        bp->cnic_eth_dev.max_iscsi_conn,
8343                        bp->cnic_eth_dev.max_fcoe_conn);
8344
8345         /* If mamimum allowed number of connections is zero -
8346          * disable the feature.
8347          */
8348         if (!bp->cnic_eth_dev.max_iscsi_conn)
8349                 bp->flags |= NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG;
8350
8351         if (!bp->cnic_eth_dev.max_fcoe_conn)
8352                 bp->flags |= NO_FCOE_FLAG;
8353 }
8354 #endif
8355
8356 static void __devinit bnx2x_get_mac_hwinfo(struct bnx2x *bp)
8357 {
8358         u32 val, val2;
8359         int func = BP_ABS_FUNC(bp);
8360         int port = BP_PORT(bp);
8361 #ifdef BCM_CNIC
8362         u8 *iscsi_mac = bp->cnic_eth_dev.iscsi_mac;
8363         u8 *fip_mac = bp->fip_mac;
8364 #endif
8365
8366         if (BP_NOMCP(bp)) {
8367                 BNX2X_ERROR("warning: random MAC workaround active\n");
8368                 random_ether_addr(bp->dev->dev_addr);
8369         } else if (IS_MF(bp)) {
8370                 val2 = MF_CFG_RD(bp, func_mf_config[func].mac_upper);
8371                 val = MF_CFG_RD(bp, func_mf_config[func].mac_lower);
8372                 if ((val2 != FUNC_MF_CFG_UPPERMAC_DEFAULT) &&
8373                     (val != FUNC_MF_CFG_LOWERMAC_DEFAULT))
8374                         bnx2x_set_mac_buf(bp->dev->dev_addr, val, val2);
8375
8376 #ifdef BCM_CNIC
8377                 /* iSCSI and FCoE NPAR MACs: if there is no either iSCSI or
8378                  * FCoE MAC then the appropriate feature should be disabled.
8379                  */
8380                 if (IS_MF_SI(bp)) {
8381                         u32 cfg = MF_CFG_RD(bp, func_ext_config[func].func_cfg);
8382                         if (cfg & MACP_FUNC_CFG_FLAGS_ISCSI_OFFLOAD) {
8383                                 val2 = MF_CFG_RD(bp, func_ext_config[func].
8384                                                      iscsi_mac_addr_upper);
8385                                 val = MF_CFG_RD(bp, func_ext_config[func].
8386                                                     iscsi_mac_addr_lower);
8387                                 BNX2X_DEV_INFO("Read iSCSI MAC: "
8388                                                "0x%x:0x%04x\n", val2, val);
8389                                 bnx2x_set_mac_buf(iscsi_mac, val, val2);
8390                         } else
8391                                 bp->flags |= NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG;
8392
8393                         if (cfg & MACP_FUNC_CFG_FLAGS_FCOE_OFFLOAD) {
8394                                 val2 = MF_CFG_RD(bp, func_ext_config[func].
8395                                                      fcoe_mac_addr_upper);
8396                                 val = MF_CFG_RD(bp, func_ext_config[func].
8397                                                     fcoe_mac_addr_lower);
8398                                 BNX2X_DEV_INFO("Read FCoE MAC to "
8399                                                "0x%x:0x%04x\n", val2, val);
8400                                 bnx2x_set_mac_buf(fip_mac, val, val2);
8401
8402                         } else
8403                                 bp->flags |= NO_FCOE_FLAG;
8404                 }
8405 #endif
8406         } else {
8407                 /* in SF read MACs from port configuration */
8408                 val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_upper);
8409                 val = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_lower);
8410                 bnx2x_set_mac_buf(bp->dev->dev_addr, val, val2);
8411
8412 #ifdef BCM_CNIC
8413                 val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].
8414                                     iscsi_mac_upper);
8415                 val = SHMEM_RD(bp, dev_info.port_hw_config[port].
8416                                    iscsi_mac_lower);
8417                 bnx2x_set_mac_buf(iscsi_mac, val, val2);
8418 #endif
8419         }
8420
8421         memcpy(bp->link_params.mac_addr, bp->dev->dev_addr, ETH_ALEN);
8422         memcpy(bp->dev->perm_addr, bp->dev->dev_addr, ETH_ALEN);
8423
8424 #ifdef BCM_CNIC
8425         /* Set the FCoE MAC in modes other then MF_SI */
8426         if (!CHIP_IS_E1x(bp)) {
8427                 if (IS_MF_SD(bp))
8428                         memcpy(fip_mac, bp->dev->dev_addr, ETH_ALEN);
8429                 else if (!IS_MF(bp))
8430                         memcpy(fip_mac, iscsi_mac, ETH_ALEN);
8431         }
8432
8433         /* Disable iSCSI if MAC configuration is
8434          * invalid.
8435          */
8436         if (!is_valid_ether_addr(iscsi_mac)) {
8437                 bp->flags |= NO_ISCSI_FLAG;
8438                 memset(iscsi_mac, 0, ETH_ALEN);
8439         }
8440
8441         /* Disable FCoE if MAC configuration is
8442          * invalid.
8443          */
8444         if (!is_valid_ether_addr(fip_mac)) {
8445                 bp->flags |= NO_FCOE_FLAG;
8446                 memset(bp->fip_mac, 0, ETH_ALEN);
8447         }
8448 #endif
8449 }
8450
8451 static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
8452 {
8453         int /*abs*/func = BP_ABS_FUNC(bp);
8454         int vn;
8455         u32 val = 0;
8456         int rc = 0;
8457
8458         bnx2x_get_common_hwinfo(bp);
8459
8460         if (CHIP_IS_E1x(bp)) {
8461                 bp->common.int_block = INT_BLOCK_HC;
8462
8463                 bp->igu_dsb_id = DEF_SB_IGU_ID;
8464                 bp->igu_base_sb = 0;
8465                 bp->igu_sb_cnt = min_t(u8, FP_SB_MAX_E1x,
8466                                        NUM_IGU_SB_REQUIRED(bp->l2_cid_count));
8467         } else {
8468                 bp->common.int_block = INT_BLOCK_IGU;
8469                 val = REG_RD(bp, IGU_REG_BLOCK_CONFIGURATION);
8470                 if (val & IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN) {
8471                         DP(NETIF_MSG_PROBE, "IGU Backward Compatible Mode\n");
8472                         bp->common.int_block |= INT_BLOCK_MODE_BW_COMP;
8473                 } else
8474                         DP(NETIF_MSG_PROBE, "IGU Normal Mode\n");
8475
8476                 bnx2x_get_igu_cam_info(bp);
8477
8478         }
8479         DP(NETIF_MSG_PROBE, "igu_dsb_id %d  igu_base_sb %d  igu_sb_cnt %d\n",
8480                              bp->igu_dsb_id, bp->igu_base_sb, bp->igu_sb_cnt);
8481
8482         /*
8483          * Initialize MF configuration
8484          */
8485
8486         bp->mf_ov = 0;
8487         bp->mf_mode = 0;
8488         vn = BP_E1HVN(bp);
8489
8490         if (!CHIP_IS_E1(bp) && !BP_NOMCP(bp)) {
8491                 DP(NETIF_MSG_PROBE,
8492                             "shmem2base 0x%x, size %d, mfcfg offset %d\n",
8493                             bp->common.shmem2_base, SHMEM2_RD(bp, size),
8494                             (u32)offsetof(struct shmem2_region, mf_cfg_addr));
8495                 if (SHMEM2_HAS(bp, mf_cfg_addr))
8496                         bp->common.mf_cfg_base = SHMEM2_RD(bp, mf_cfg_addr);
8497                 else
8498                         bp->common.mf_cfg_base = bp->common.shmem_base +
8499                                 offsetof(struct shmem_region, func_mb) +
8500                                 E1H_FUNC_MAX * sizeof(struct drv_func_mb);
8501                 /*
8502                  * get mf configuration:
8503                  * 1. existence of MF configuration
8504                  * 2. MAC address must be legal (check only upper bytes)
8505                  *    for  Switch-Independent mode;
8506                  *    OVLAN must be legal for Switch-Dependent mode
8507                  * 3. SF_MODE configures specific MF mode
8508                  */
8509                 if (bp->common.mf_cfg_base != SHMEM_MF_CFG_ADDR_NONE) {
8510                         /* get mf configuration */
8511                         val = SHMEM_RD(bp,
8512                                        dev_info.shared_feature_config.config);
8513                         val &= SHARED_FEAT_CFG_FORCE_SF_MODE_MASK;
8514
8515                         switch (val) {
8516                         case SHARED_FEAT_CFG_FORCE_SF_MODE_SWITCH_INDEPT:
8517                                 val = MF_CFG_RD(bp, func_mf_config[func].
8518                                                 mac_upper);
8519                                 /* check for legal mac (upper bytes)*/
8520                                 if (val != 0xffff) {
8521                                         bp->mf_mode = MULTI_FUNCTION_SI;
8522                                         bp->mf_config[vn] = MF_CFG_RD(bp,
8523                                                    func_mf_config[func].config);
8524                                 } else
8525                                         DP(NETIF_MSG_PROBE, "illegal MAC "
8526                                                             "address for SI\n");
8527                                 break;
8528                         case SHARED_FEAT_CFG_FORCE_SF_MODE_MF_ALLOWED:
8529                                 /* get OV configuration */
8530                                 val = MF_CFG_RD(bp,
8531                                         func_mf_config[FUNC_0].e1hov_tag);
8532                                 val &= FUNC_MF_CFG_E1HOV_TAG_MASK;
8533
8534                                 if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
8535                                         bp->mf_mode = MULTI_FUNCTION_SD;
8536                                         bp->mf_config[vn] = MF_CFG_RD(bp,
8537                                                 func_mf_config[func].config);
8538                                 } else
8539                                         DP(NETIF_MSG_PROBE, "illegal OV for "
8540                                                             "SD\n");
8541                                 break;
8542                         default:
8543                                 /* Unknown configuration: reset mf_config */
8544                                 bp->mf_config[vn] = 0;
8545                                 DP(NETIF_MSG_PROBE, "Unknown MF mode 0x%x\n",
8546                                    val);
8547                         }
8548                 }
8549
8550                 BNX2X_DEV_INFO("%s function mode\n",
8551                                IS_MF(bp) ? "multi" : "single");
8552
8553                 switch (bp->mf_mode) {
8554                 case MULTI_FUNCTION_SD:
8555                         val = MF_CFG_RD(bp, func_mf_config[func].e1hov_tag) &
8556                               FUNC_MF_CFG_E1HOV_TAG_MASK;
8557                         if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
8558                                 bp->mf_ov = val;
8559                                 BNX2X_DEV_INFO("MF OV for func %d is %d"
8560                                                " (0x%04x)\n", func,
8561                                                bp->mf_ov, bp->mf_ov);
8562                         } else {
8563                                 BNX2X_ERR("No valid MF OV for func %d,"
8564                                           "  aborting\n", func);
8565                                 rc = -EPERM;
8566                         }
8567                         break;
8568                 case MULTI_FUNCTION_SI:
8569                         BNX2X_DEV_INFO("func %d is in MF "
8570                                        "switch-independent mode\n", func);
8571                         break;
8572                 default:
8573                         if (vn) {
8574                                 BNX2X_ERR("VN %d in single function mode,"
8575                                           "  aborting\n", vn);
8576                                 rc = -EPERM;
8577                         }
8578                         break;
8579                 }
8580
8581         }
8582
8583         /* adjust igu_sb_cnt to MF for E1x */
8584         if (CHIP_IS_E1x(bp) && IS_MF(bp))
8585                 bp->igu_sb_cnt /= E1HVN_MAX;
8586
8587         /*
8588          * adjust E2 sb count: to be removed when FW will support
8589          * more then 16 L2 clients
8590          */
8591 #define MAX_L2_CLIENTS                          16
8592         if (CHIP_IS_E2(bp))
8593                 bp->igu_sb_cnt = min_t(u8, bp->igu_sb_cnt,
8594                                        MAX_L2_CLIENTS / (IS_MF(bp) ? 4 : 1));
8595
8596         if (!BP_NOMCP(bp)) {
8597                 bnx2x_get_port_hwinfo(bp);
8598
8599                 bp->fw_seq =
8600                         (SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
8601                          DRV_MSG_SEQ_NUMBER_MASK);
8602                 BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
8603         }
8604
8605         /* Get MAC addresses */
8606         bnx2x_get_mac_hwinfo(bp);
8607
8608 #ifdef BCM_CNIC
8609         bnx2x_get_cnic_info(bp);
8610 #endif
8611
8612         return rc;
8613 }
8614
8615 static void __devinit bnx2x_read_fwinfo(struct bnx2x *bp)
8616 {
8617         int cnt, i, block_end, rodi;
8618         char vpd_data[BNX2X_VPD_LEN+1];
8619         char str_id_reg[VENDOR_ID_LEN+1];
8620         char str_id_cap[VENDOR_ID_LEN+1];
8621         u8 len;
8622
8623         cnt = pci_read_vpd(bp->pdev, 0, BNX2X_VPD_LEN, vpd_data);
8624         memset(bp->fw_ver, 0, sizeof(bp->fw_ver));
8625
8626         if (cnt < BNX2X_VPD_LEN)
8627                 goto out_not_found;
8628
8629         i = pci_vpd_find_tag(vpd_data, 0, BNX2X_VPD_LEN,
8630                              PCI_VPD_LRDT_RO_DATA);
8631         if (i < 0)
8632                 goto out_not_found;
8633
8634
8635         block_end = i + PCI_VPD_LRDT_TAG_SIZE +
8636                     pci_vpd_lrdt_size(&vpd_data[i]);
8637
8638         i += PCI_VPD_LRDT_TAG_SIZE;
8639
8640         if (block_end > BNX2X_VPD_LEN)
8641                 goto out_not_found;
8642
8643         rodi = pci_vpd_find_info_keyword(vpd_data, i, block_end,
8644                                    PCI_VPD_RO_KEYWORD_MFR_ID);
8645         if (rodi < 0)
8646                 goto out_not_found;
8647
8648         len = pci_vpd_info_field_size(&vpd_data[rodi]);
8649
8650         if (len != VENDOR_ID_LEN)
8651                 goto out_not_found;
8652
8653         rodi += PCI_VPD_INFO_FLD_HDR_SIZE;
8654
8655         /* vendor specific info */
8656         snprintf(str_id_reg, VENDOR_ID_LEN + 1, "%04x", PCI_VENDOR_ID_DELL);
8657         snprintf(str_id_cap, VENDOR_ID_LEN + 1, "%04X", PCI_VENDOR_ID_DELL);
8658         if (!strncmp(str_id_reg, &vpd_data[rodi], VENDOR_ID_LEN) ||
8659             !strncmp(str_id_cap, &vpd_data[rodi], VENDOR_ID_LEN)) {
8660
8661                 rodi = pci_vpd_find_info_keyword(vpd_data, i, block_end,
8662                                                 PCI_VPD_RO_KEYWORD_VENDOR0);
8663                 if (rodi >= 0) {
8664                         len = pci_vpd_info_field_size(&vpd_data[rodi]);
8665
8666                         rodi += PCI_VPD_INFO_FLD_HDR_SIZE;
8667
8668                         if (len < 32 && (len + rodi) <= BNX2X_VPD_LEN) {
8669                                 memcpy(bp->fw_ver, &vpd_data[rodi], len);
8670                                 bp->fw_ver[len] = ' ';
8671                         }
8672                 }
8673                 return;
8674         }
8675 out_not_found:
8676         return;
8677 }
8678
8679 static int __devinit bnx2x_init_bp(struct bnx2x *bp)
8680 {
8681         int func;
8682         int timer_interval;
8683         int rc;
8684
8685         /* Disable interrupt handling until HW is initialized */
8686         atomic_set(&bp->intr_sem, 1);
8687         smp_wmb(); /* Ensure that bp->intr_sem update is SMP-safe */
8688
8689         mutex_init(&bp->port.phy_mutex);
8690         mutex_init(&bp->fw_mb_mutex);
8691         spin_lock_init(&bp->stats_lock);
8692 #ifdef BCM_CNIC
8693         mutex_init(&bp->cnic_mutex);
8694 #endif
8695
8696         INIT_DELAYED_WORK(&bp->sp_task, bnx2x_sp_task);
8697         INIT_DELAYED_WORK(&bp->reset_task, bnx2x_reset_task);
8698
8699         rc = bnx2x_get_hwinfo(bp);
8700
8701         if (!rc)
8702                 rc = bnx2x_alloc_mem_bp(bp);
8703
8704         bnx2x_read_fwinfo(bp);
8705
8706         func = BP_FUNC(bp);
8707
8708         /* need to reset chip if undi was active */
8709         if (!BP_NOMCP(bp))
8710                 bnx2x_undi_unload(bp);
8711
8712         if (CHIP_REV_IS_FPGA(bp))
8713                 dev_err(&bp->pdev->dev, "FPGA detected\n");
8714
8715         if (BP_NOMCP(bp) && (func == 0))
8716                 dev_err(&bp->pdev->dev, "MCP disabled, "
8717                                         "must load devices in order!\n");
8718
8719         bp->multi_mode = multi_mode;
8720         bp->int_mode = int_mode;
8721
8722         /* Set TPA flags */
8723         if (disable_tpa) {
8724                 bp->flags &= ~TPA_ENABLE_FLAG;
8725                 bp->dev->features &= ~NETIF_F_LRO;
8726         } else {
8727                 bp->flags |= TPA_ENABLE_FLAG;
8728                 bp->dev->features |= NETIF_F_LRO;
8729         }
8730         bp->disable_tpa = disable_tpa;
8731
8732         if (CHIP_IS_E1(bp))
8733                 bp->dropless_fc = 0;
8734         else
8735                 bp->dropless_fc = dropless_fc;
8736
8737         bp->mrrs = mrrs;
8738
8739         bp->tx_ring_size = MAX_TX_AVAIL;
8740
8741         /* make sure that the numbers are in the right granularity */
8742         bp->tx_ticks = (50 / BNX2X_BTR) * BNX2X_BTR;
8743         bp->rx_ticks = (25 / BNX2X_BTR) * BNX2X_BTR;
8744
8745         timer_interval = (CHIP_REV_IS_SLOW(bp) ? 5*HZ : HZ);
8746         bp->current_interval = (poll ? poll : timer_interval);
8747
8748         init_timer(&bp->timer);
8749         bp->timer.expires = jiffies + bp->current_interval;
8750         bp->timer.data = (unsigned long) bp;
8751         bp->timer.function = bnx2x_timer;
8752
8753         bnx2x_dcbx_set_state(bp, true, BNX2X_DCBX_ENABLED_ON_NEG_ON);
8754         bnx2x_dcbx_init_params(bp);
8755
8756         return rc;
8757 }
8758
8759
8760 /****************************************************************************
8761 * General service functions
8762 ****************************************************************************/
8763
8764 /* called with rtnl_lock */
8765 static int bnx2x_open(struct net_device *dev)
8766 {
8767         struct bnx2x *bp = netdev_priv(dev);
8768
8769         netif_carrier_off(dev);
8770
8771         bnx2x_set_power_state(bp, PCI_D0);
8772
8773         if (!bnx2x_reset_is_done(bp)) {
8774                 do {
8775                         /* Reset MCP mail box sequence if there is on going
8776                          * recovery
8777                          */
8778                         bp->fw_seq = 0;
8779
8780                         /* If it's the first function to load and reset done
8781                          * is still not cleared it may mean that. We don't
8782                          * check the attention state here because it may have
8783                          * already been cleared by a "common" reset but we
8784                          * shell proceed with "process kill" anyway.
8785                          */
8786                         if ((bnx2x_get_load_cnt(bp) == 0) &&
8787                                 bnx2x_trylock_hw_lock(bp,
8788                                 HW_LOCK_RESOURCE_RESERVED_08) &&
8789                                 (!bnx2x_leader_reset(bp))) {
8790                                 DP(NETIF_MSG_HW, "Recovered in open\n");
8791                                 break;
8792                         }
8793
8794                         bnx2x_set_power_state(bp, PCI_D3hot);
8795
8796                         printk(KERN_ERR"%s: Recovery flow hasn't been properly"
8797                         " completed yet. Try again later. If u still see this"
8798                         " message after a few retries then power cycle is"
8799                         " required.\n", bp->dev->name);
8800
8801                         return -EAGAIN;
8802                 } while (0);
8803         }
8804
8805         bp->recovery_state = BNX2X_RECOVERY_DONE;
8806
8807         return bnx2x_nic_load(bp, LOAD_OPEN);
8808 }
8809
8810 /* called with rtnl_lock */
8811 static int bnx2x_close(struct net_device *dev)
8812 {
8813         struct bnx2x *bp = netdev_priv(dev);
8814
8815         /* Unload the driver, release IRQs */
8816         bnx2x_nic_unload(bp, UNLOAD_CLOSE);
8817         bnx2x_set_power_state(bp, PCI_D3hot);
8818
8819         return 0;
8820 }
8821
8822 #define E1_MAX_UC_LIST  29
8823 #define E1H_MAX_UC_LIST 30
8824 #define E2_MAX_UC_LIST  14
8825 static inline u8 bnx2x_max_uc_list(struct bnx2x *bp)
8826 {
8827         if (CHIP_IS_E1(bp))
8828                 return E1_MAX_UC_LIST;
8829         else if (CHIP_IS_E1H(bp))
8830                 return E1H_MAX_UC_LIST;
8831         else
8832                 return E2_MAX_UC_LIST;
8833 }
8834
8835
8836 static inline u8 bnx2x_uc_list_cam_offset(struct bnx2x *bp)
8837 {
8838         if (CHIP_IS_E1(bp))
8839                 /* CAM Entries for Port0:
8840                  *      0 - prim ETH MAC
8841                  *      1 - BCAST MAC
8842                  *      2 - iSCSI L2 ring ETH MAC
8843                  *      3-31 - UC MACs
8844                  *
8845                  * Port1 entries are allocated the same way starting from
8846                  * entry 32.
8847                  */
8848                 return 3 + 32 * BP_PORT(bp);
8849         else if (CHIP_IS_E1H(bp)) {
8850                 /* CAM Entries:
8851                  *      0-7  - prim ETH MAC for each function
8852                  *      8-15 - iSCSI L2 ring ETH MAC for each function
8853                  *      16 till 255 UC MAC lists for each function
8854                  *
8855                  * Remark: There is no FCoE support for E1H, thus FCoE related
8856                  *         MACs are not considered.
8857                  */
8858                 return E1H_FUNC_MAX * (CAM_ISCSI_ETH_LINE + 1) +
8859                         bnx2x_max_uc_list(bp) * BP_FUNC(bp);
8860         } else {
8861                 /* CAM Entries (there is a separate CAM per engine):
8862                  *      0-4  - prim ETH MAC for each function
8863                  *      4-7 - iSCSI L2 ring ETH MAC for each function
8864                  *      8-11 - FIP ucast L2 MAC for each function
8865                  *      12-15 - ALL_ENODE_MACS mcast MAC for each function
8866                  *      16 till 71 UC MAC lists for each function
8867                  */
8868                 u8 func_idx =
8869                         (CHIP_MODE_IS_4_PORT(bp) ? BP_FUNC(bp) : BP_VN(bp));
8870
8871                 return E2_FUNC_MAX * (CAM_MAX_PF_LINE + 1) +
8872                         bnx2x_max_uc_list(bp) * func_idx;
8873         }
8874 }
8875
8876 /* set uc list, do not wait as wait implies sleep and
8877  * set_rx_mode can be invoked from non-sleepable context.
8878  *
8879  * Instead we use the same ramrod data buffer each time we need
8880  * to configure a list of addresses, and use the fact that the
8881  * list of MACs is changed in an incremental way and that the
8882  * function is called under the netif_addr_lock. A temporary
8883  * inconsistent CAM configuration (possible in case of very fast
8884  * sequence of add/del/add on the host side) will shortly be
8885  * restored by the handler of the last ramrod.
8886  */
8887 static int bnx2x_set_uc_list(struct bnx2x *bp)
8888 {
8889         int i = 0, old;
8890         struct net_device *dev = bp->dev;
8891         u8 offset = bnx2x_uc_list_cam_offset(bp);
8892         struct netdev_hw_addr *ha;
8893         struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, uc_mac_config);
8894         dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, uc_mac_config);
8895
8896         if (netdev_uc_count(dev) > bnx2x_max_uc_list(bp))
8897                 return -EINVAL;
8898
8899         netdev_for_each_uc_addr(ha, dev) {
8900                 /* copy mac */
8901                 config_cmd->config_table[i].msb_mac_addr =
8902                         swab16(*(u16 *)&bnx2x_uc_addr(ha)[0]);
8903                 config_cmd->config_table[i].middle_mac_addr =
8904                         swab16(*(u16 *)&bnx2x_uc_addr(ha)[2]);
8905                 config_cmd->config_table[i].lsb_mac_addr =
8906                         swab16(*(u16 *)&bnx2x_uc_addr(ha)[4]);
8907
8908                 config_cmd->config_table[i].vlan_id = 0;
8909                 config_cmd->config_table[i].pf_id = BP_FUNC(bp);
8910                 config_cmd->config_table[i].clients_bit_vector =
8911                         cpu_to_le32(1 << BP_L_ID(bp));
8912
8913                 SET_FLAG(config_cmd->config_table[i].flags,
8914                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
8915                         T_ETH_MAC_COMMAND_SET);
8916
8917                 DP(NETIF_MSG_IFUP,
8918                    "setting UCAST[%d] (%04x:%04x:%04x)\n", i,
8919                    config_cmd->config_table[i].msb_mac_addr,
8920                    config_cmd->config_table[i].middle_mac_addr,
8921                    config_cmd->config_table[i].lsb_mac_addr);
8922
8923                 i++;
8924
8925                 /* Set uc MAC in NIG */
8926                 bnx2x_set_mac_in_nig(bp, 1, bnx2x_uc_addr(ha),
8927                                      LLH_CAM_ETH_LINE + i);
8928         }
8929         old = config_cmd->hdr.length;
8930         if (old > i) {
8931                 for (; i < old; i++) {
8932                         if (CAM_IS_INVALID(config_cmd->
8933                                            config_table[i])) {
8934                                 /* already invalidated */
8935                                 break;
8936                         }
8937                         /* invalidate */
8938                         SET_FLAG(config_cmd->config_table[i].flags,
8939                                 MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
8940                                 T_ETH_MAC_COMMAND_INVALIDATE);
8941                 }
8942         }
8943
8944         wmb();
8945
8946         config_cmd->hdr.length = i;
8947         config_cmd->hdr.offset = offset;
8948         config_cmd->hdr.client_id = 0xff;
8949         /* Mark that this ramrod doesn't use bp->set_mac_pending for
8950          * synchronization.
8951          */
8952         config_cmd->hdr.echo = 0;
8953
8954         mb();
8955
8956         return bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
8957                    U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
8958
8959 }
8960
8961 void bnx2x_invalidate_uc_list(struct bnx2x *bp)
8962 {
8963         int i;
8964         struct mac_configuration_cmd *config_cmd = bnx2x_sp(bp, uc_mac_config);
8965         dma_addr_t config_cmd_map = bnx2x_sp_mapping(bp, uc_mac_config);
8966         int ramrod_flags = WAIT_RAMROD_COMMON;
8967         u8 offset = bnx2x_uc_list_cam_offset(bp);
8968         u8 max_list_size = bnx2x_max_uc_list(bp);
8969
8970         for (i = 0; i < max_list_size; i++) {
8971                 SET_FLAG(config_cmd->config_table[i].flags,
8972                         MAC_CONFIGURATION_ENTRY_ACTION_TYPE,
8973                         T_ETH_MAC_COMMAND_INVALIDATE);
8974                 bnx2x_set_mac_in_nig(bp, 0, NULL, LLH_CAM_ETH_LINE + 1 + i);
8975         }
8976
8977         wmb();
8978
8979         config_cmd->hdr.length = max_list_size;
8980         config_cmd->hdr.offset = offset;
8981         config_cmd->hdr.client_id = 0xff;
8982         /* We'll wait for a completion this time... */
8983         config_cmd->hdr.echo = 1;
8984
8985         bp->set_mac_pending = 1;
8986
8987         mb();
8988
8989         bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_SET_MAC, 0,
8990                       U64_HI(config_cmd_map), U64_LO(config_cmd_map), 1);
8991
8992         /* Wait for a completion */
8993         bnx2x_wait_ramrod(bp, 0, 0, &bp->set_mac_pending,
8994                                 ramrod_flags);
8995
8996 }
8997
8998 static inline int bnx2x_set_mc_list(struct bnx2x *bp)
8999 {
9000         /* some multicasts */
9001         if (CHIP_IS_E1(bp)) {
9002                 return bnx2x_set_e1_mc_list(bp);
9003         } else { /* E1H and newer */
9004                 return bnx2x_set_e1h_mc_list(bp);
9005         }
9006 }
9007
9008 /* called with netif_tx_lock from dev_mcast.c */
9009 void bnx2x_set_rx_mode(struct net_device *dev)
9010 {
9011         struct bnx2x *bp = netdev_priv(dev);
9012         u32 rx_mode = BNX2X_RX_MODE_NORMAL;
9013
9014         if (bp->state != BNX2X_STATE_OPEN) {
9015                 DP(NETIF_MSG_IFUP, "state is %x, returning\n", bp->state);
9016                 return;
9017         }
9018
9019         DP(NETIF_MSG_IFUP, "dev->flags = %x\n", dev->flags);
9020
9021         if (dev->flags & IFF_PROMISC)
9022                 rx_mode = BNX2X_RX_MODE_PROMISC;
9023         else if (dev->flags & IFF_ALLMULTI)
9024                 rx_mode = BNX2X_RX_MODE_ALLMULTI;
9025         else {
9026                 /* some multicasts */
9027                 if (bnx2x_set_mc_list(bp))
9028                         rx_mode = BNX2X_RX_MODE_ALLMULTI;
9029
9030                 /* some unicasts */
9031                 if (bnx2x_set_uc_list(bp))
9032                         rx_mode = BNX2X_RX_MODE_PROMISC;
9033         }
9034
9035         bp->rx_mode = rx_mode;
9036         bnx2x_set_storm_rx_mode(bp);
9037 }
9038
9039 /* called with rtnl_lock */
9040 static int bnx2x_mdio_read(struct net_device *netdev, int prtad,
9041                            int devad, u16 addr)
9042 {
9043         struct bnx2x *bp = netdev_priv(netdev);
9044         u16 value;
9045         int rc;
9046
9047         DP(NETIF_MSG_LINK, "mdio_read: prtad 0x%x, devad 0x%x, addr 0x%x\n",
9048            prtad, devad, addr);
9049
9050         /* The HW expects different devad if CL22 is used */
9051         devad = (devad == MDIO_DEVAD_NONE) ? DEFAULT_PHY_DEV_ADDR : devad;
9052
9053         bnx2x_acquire_phy_lock(bp);
9054         rc = bnx2x_phy_read(&bp->link_params, prtad, devad, addr, &value);
9055         bnx2x_release_phy_lock(bp);
9056         DP(NETIF_MSG_LINK, "mdio_read_val 0x%x rc = 0x%x\n", value, rc);
9057
9058         if (!rc)
9059                 rc = value;
9060         return rc;
9061 }
9062
9063 /* called with rtnl_lock */
9064 static int bnx2x_mdio_write(struct net_device *netdev, int prtad, int devad,
9065                             u16 addr, u16 value)
9066 {
9067         struct bnx2x *bp = netdev_priv(netdev);
9068         int rc;
9069
9070         DP(NETIF_MSG_LINK, "mdio_write: prtad 0x%x, devad 0x%x, addr 0x%x,"
9071                            " value 0x%x\n", prtad, devad, addr, value);
9072
9073         /* The HW expects different devad if CL22 is used */
9074         devad = (devad == MDIO_DEVAD_NONE) ? DEFAULT_PHY_DEV_ADDR : devad;
9075
9076         bnx2x_acquire_phy_lock(bp);
9077         rc = bnx2x_phy_write(&bp->link_params, prtad, devad, addr, value);
9078         bnx2x_release_phy_lock(bp);
9079         return rc;
9080 }
9081
9082 /* called with rtnl_lock */
9083 static int bnx2x_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
9084 {
9085         struct bnx2x *bp = netdev_priv(dev);
9086         struct mii_ioctl_data *mdio = if_mii(ifr);
9087
9088         DP(NETIF_MSG_LINK, "ioctl: phy id 0x%x, reg 0x%x, val_in 0x%x\n",
9089            mdio->phy_id, mdio->reg_num, mdio->val_in);
9090
9091         if (!netif_running(dev))
9092                 return -EAGAIN;
9093
9094         return mdio_mii_ioctl(&bp->mdio, mdio, cmd);
9095 }
9096
9097 #ifdef CONFIG_NET_POLL_CONTROLLER
9098 static void poll_bnx2x(struct net_device *dev)
9099 {
9100         struct bnx2x *bp = netdev_priv(dev);
9101
9102         disable_irq(bp->pdev->irq);
9103         bnx2x_interrupt(bp->pdev->irq, dev);
9104         enable_irq(bp->pdev->irq);
9105 }
9106 #endif
9107
9108 static const struct net_device_ops bnx2x_netdev_ops = {
9109         .ndo_open               = bnx2x_open,
9110         .ndo_stop               = bnx2x_close,
9111         .ndo_start_xmit         = bnx2x_start_xmit,
9112         .ndo_select_queue       = bnx2x_select_queue,
9113         .ndo_set_rx_mode        = bnx2x_set_rx_mode,
9114         .ndo_set_mac_address    = bnx2x_change_mac_addr,
9115         .ndo_validate_addr      = eth_validate_addr,
9116         .ndo_do_ioctl           = bnx2x_ioctl,
9117         .ndo_change_mtu         = bnx2x_change_mtu,
9118         .ndo_fix_features       = bnx2x_fix_features,
9119         .ndo_set_features       = bnx2x_set_features,
9120         .ndo_tx_timeout         = bnx2x_tx_timeout,
9121 #ifdef CONFIG_NET_POLL_CONTROLLER
9122         .ndo_poll_controller    = poll_bnx2x,
9123 #endif
9124 };
9125
9126 static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
9127                                     struct net_device *dev)
9128 {
9129         struct bnx2x *bp;
9130         int rc;
9131
9132         SET_NETDEV_DEV(dev, &pdev->dev);
9133         bp = netdev_priv(dev);
9134
9135         bp->dev = dev;
9136         bp->pdev = pdev;
9137         bp->flags = 0;
9138         bp->pf_num = PCI_FUNC(pdev->devfn);
9139
9140         rc = pci_enable_device(pdev);
9141         if (rc) {
9142                 dev_err(&bp->pdev->dev,
9143                         "Cannot enable PCI device, aborting\n");
9144                 goto err_out;
9145         }
9146
9147         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
9148                 dev_err(&bp->pdev->dev,
9149                         "Cannot find PCI device base address, aborting\n");
9150                 rc = -ENODEV;
9151                 goto err_out_disable;
9152         }
9153
9154         if (!(pci_resource_flags(pdev, 2) & IORESOURCE_MEM)) {
9155                 dev_err(&bp->pdev->dev, "Cannot find second PCI device"
9156                        " base address, aborting\n");
9157                 rc = -ENODEV;
9158                 goto err_out_disable;
9159         }
9160
9161         if (atomic_read(&pdev->enable_cnt) == 1) {
9162                 rc = pci_request_regions(pdev, DRV_MODULE_NAME);
9163                 if (rc) {
9164                         dev_err(&bp->pdev->dev,
9165                                 "Cannot obtain PCI resources, aborting\n");
9166                         goto err_out_disable;
9167                 }
9168
9169                 pci_set_master(pdev);
9170                 pci_save_state(pdev);
9171         }
9172
9173         bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
9174         if (bp->pm_cap == 0) {
9175                 dev_err(&bp->pdev->dev,
9176                         "Cannot find power management capability, aborting\n");
9177                 rc = -EIO;
9178                 goto err_out_release;
9179         }
9180
9181         bp->pcie_cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
9182         if (bp->pcie_cap == 0) {
9183                 dev_err(&bp->pdev->dev,
9184                         "Cannot find PCI Express capability, aborting\n");
9185                 rc = -EIO;
9186                 goto err_out_release;
9187         }
9188
9189         if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)) == 0) {
9190                 bp->flags |= USING_DAC_FLAG;
9191                 if (dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64)) != 0) {
9192                         dev_err(&bp->pdev->dev, "dma_set_coherent_mask"
9193                                " failed, aborting\n");
9194                         rc = -EIO;
9195                         goto err_out_release;
9196                 }
9197
9198         } else if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)) != 0) {
9199                 dev_err(&bp->pdev->dev,
9200                         "System does not support DMA, aborting\n");
9201                 rc = -EIO;
9202                 goto err_out_release;
9203         }
9204
9205         dev->mem_start = pci_resource_start(pdev, 0);
9206         dev->base_addr = dev->mem_start;
9207         dev->mem_end = pci_resource_end(pdev, 0);
9208
9209         dev->irq = pdev->irq;
9210
9211         bp->regview = pci_ioremap_bar(pdev, 0);
9212         if (!bp->regview) {
9213                 dev_err(&bp->pdev->dev,
9214                         "Cannot map register space, aborting\n");
9215                 rc = -ENOMEM;
9216                 goto err_out_release;
9217         }
9218
9219         bp->doorbells = ioremap_nocache(pci_resource_start(pdev, 2),
9220                                         min_t(u64, BNX2X_DB_SIZE(bp),
9221                                               pci_resource_len(pdev, 2)));
9222         if (!bp->doorbells) {
9223                 dev_err(&bp->pdev->dev,
9224                         "Cannot map doorbell space, aborting\n");
9225                 rc = -ENOMEM;
9226                 goto err_out_unmap;
9227         }
9228
9229         bnx2x_set_power_state(bp, PCI_D0);
9230
9231         /* clean indirect addresses */
9232         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
9233                                PCICFG_VENDOR_ID_OFFSET);
9234         REG_WR(bp, PXP2_REG_PGL_ADDR_88_F0 + BP_PORT(bp)*16, 0);
9235         REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F0 + BP_PORT(bp)*16, 0);
9236         REG_WR(bp, PXP2_REG_PGL_ADDR_90_F0 + BP_PORT(bp)*16, 0);
9237         REG_WR(bp, PXP2_REG_PGL_ADDR_94_F0 + BP_PORT(bp)*16, 0);
9238
9239         /* Reset the load counter */
9240         bnx2x_clear_load_cnt(bp);
9241
9242         dev->watchdog_timeo = TX_TIMEOUT;
9243
9244         dev->netdev_ops = &bnx2x_netdev_ops;
9245         bnx2x_set_ethtool_ops(dev);
9246
9247         dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
9248                 NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6 |
9249                 NETIF_F_RXCSUM | NETIF_F_LRO | NETIF_F_HW_VLAN_TX;
9250
9251         dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
9252                 NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_HIGHDMA;
9253
9254         dev->features |= dev->hw_features | NETIF_F_HW_VLAN_RX;
9255         if (bp->flags & USING_DAC_FLAG)
9256                 dev->features |= NETIF_F_HIGHDMA;
9257
9258         /* Add Loopback capability to the device */
9259         dev->hw_features |= NETIF_F_LOOPBACK;
9260
9261 #ifdef BCM_DCBNL
9262         dev->dcbnl_ops = &bnx2x_dcbnl_ops;
9263 #endif
9264
9265         /* get_port_hwinfo() will set prtad and mmds properly */
9266         bp->mdio.prtad = MDIO_PRTAD_NONE;
9267         bp->mdio.mmds = 0;
9268         bp->mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22;
9269         bp->mdio.dev = dev;
9270         bp->mdio.mdio_read = bnx2x_mdio_read;
9271         bp->mdio.mdio_write = bnx2x_mdio_write;
9272
9273         return 0;
9274
9275 err_out_unmap:
9276         if (bp->regview) {
9277                 iounmap(bp->regview);
9278                 bp->regview = NULL;
9279         }
9280         if (bp->doorbells) {
9281                 iounmap(bp->doorbells);
9282                 bp->doorbells = NULL;
9283         }
9284
9285 err_out_release:
9286         if (atomic_read(&pdev->enable_cnt) == 1)
9287                 pci_release_regions(pdev);
9288
9289 err_out_disable:
9290         pci_disable_device(pdev);
9291         pci_set_drvdata(pdev, NULL);
9292
9293 err_out:
9294         return rc;
9295 }
9296
9297 static void __devinit bnx2x_get_pcie_width_speed(struct bnx2x *bp,
9298                                                  int *width, int *speed)
9299 {
9300         u32 val = REG_RD(bp, PCICFG_OFFSET + PCICFG_LINK_CONTROL);
9301
9302         *width = (val & PCICFG_LINK_WIDTH) >> PCICFG_LINK_WIDTH_SHIFT;
9303
9304         /* return value of 1=2.5GHz 2=5GHz */
9305         *speed = (val & PCICFG_LINK_SPEED) >> PCICFG_LINK_SPEED_SHIFT;
9306 }
9307
9308 static int bnx2x_check_firmware(struct bnx2x *bp)
9309 {
9310         const struct firmware *firmware = bp->firmware;
9311         struct bnx2x_fw_file_hdr *fw_hdr;
9312         struct bnx2x_fw_file_section *sections;
9313         u32 offset, len, num_ops;
9314         u16 *ops_offsets;
9315         int i;
9316         const u8 *fw_ver;
9317
9318         if (firmware->size < sizeof(struct bnx2x_fw_file_hdr))
9319                 return -EINVAL;
9320
9321         fw_hdr = (struct bnx2x_fw_file_hdr *)firmware->data;
9322         sections = (struct bnx2x_fw_file_section *)fw_hdr;
9323
9324         /* Make sure none of the offsets and sizes make us read beyond
9325          * the end of the firmware data */
9326         for (i = 0; i < sizeof(*fw_hdr) / sizeof(*sections); i++) {
9327                 offset = be32_to_cpu(sections[i].offset);
9328                 len = be32_to_cpu(sections[i].len);
9329                 if (offset + len > firmware->size) {
9330                         dev_err(&bp->pdev->dev,
9331                                 "Section %d length is out of bounds\n", i);
9332                         return -EINVAL;
9333                 }
9334         }
9335
9336         /* Likewise for the init_ops offsets */
9337         offset = be32_to_cpu(fw_hdr->init_ops_offsets.offset);
9338         ops_offsets = (u16 *)(firmware->data + offset);
9339         num_ops = be32_to_cpu(fw_hdr->init_ops.len) / sizeof(struct raw_op);
9340
9341         for (i = 0; i < be32_to_cpu(fw_hdr->init_ops_offsets.len) / 2; i++) {
9342                 if (be16_to_cpu(ops_offsets[i]) > num_ops) {
9343                         dev_err(&bp->pdev->dev,
9344                                 "Section offset %d is out of bounds\n", i);
9345                         return -EINVAL;
9346                 }
9347         }
9348
9349         /* Check FW version */
9350         offset = be32_to_cpu(fw_hdr->fw_version.offset);
9351         fw_ver = firmware->data + offset;
9352         if ((fw_ver[0] != BCM_5710_FW_MAJOR_VERSION) ||
9353             (fw_ver[1] != BCM_5710_FW_MINOR_VERSION) ||
9354             (fw_ver[2] != BCM_5710_FW_REVISION_VERSION) ||
9355             (fw_ver[3] != BCM_5710_FW_ENGINEERING_VERSION)) {
9356                 dev_err(&bp->pdev->dev,
9357                         "Bad FW version:%d.%d.%d.%d. Should be %d.%d.%d.%d\n",
9358                        fw_ver[0], fw_ver[1], fw_ver[2],
9359                        fw_ver[3], BCM_5710_FW_MAJOR_VERSION,
9360                        BCM_5710_FW_MINOR_VERSION,
9361                        BCM_5710_FW_REVISION_VERSION,
9362                        BCM_5710_FW_ENGINEERING_VERSION);
9363                 return -EINVAL;
9364         }
9365
9366         return 0;
9367 }
9368
9369 static inline void be32_to_cpu_n(const u8 *_source, u8 *_target, u32 n)
9370 {
9371         const __be32 *source = (const __be32 *)_source;
9372         u32 *target = (u32 *)_target;
9373         u32 i;
9374
9375         for (i = 0; i < n/4; i++)
9376                 target[i] = be32_to_cpu(source[i]);
9377 }
9378
9379 /*
9380    Ops array is stored in the following format:
9381    {op(8bit), offset(24bit, big endian), data(32bit, big endian)}
9382  */
9383 static inline void bnx2x_prep_ops(const u8 *_source, u8 *_target, u32 n)
9384 {
9385         const __be32 *source = (const __be32 *)_source;
9386         struct raw_op *target = (struct raw_op *)_target;
9387         u32 i, j, tmp;
9388
9389         for (i = 0, j = 0; i < n/8; i++, j += 2) {
9390                 tmp = be32_to_cpu(source[j]);
9391                 target[i].op = (tmp >> 24) & 0xff;
9392                 target[i].offset = tmp & 0xffffff;
9393                 target[i].raw_data = be32_to_cpu(source[j + 1]);
9394         }
9395 }
9396
9397 /**
9398  * IRO array is stored in the following format:
9399  * {base(24bit), m1(16bit), m2(16bit), m3(16bit), size(16bit) }
9400  */
9401 static inline void bnx2x_prep_iro(const u8 *_source, u8 *_target, u32 n)
9402 {
9403         const __be32 *source = (const __be32 *)_source;
9404         struct iro *target = (struct iro *)_target;
9405         u32 i, j, tmp;
9406
9407         for (i = 0, j = 0; i < n/sizeof(struct iro); i++) {
9408                 target[i].base = be32_to_cpu(source[j]);
9409                 j++;
9410                 tmp = be32_to_cpu(source[j]);
9411                 target[i].m1 = (tmp >> 16) & 0xffff;
9412                 target[i].m2 = tmp & 0xffff;
9413                 j++;
9414                 tmp = be32_to_cpu(source[j]);
9415                 target[i].m3 = (tmp >> 16) & 0xffff;
9416                 target[i].size = tmp & 0xffff;
9417                 j++;
9418         }
9419 }
9420
9421 static inline void be16_to_cpu_n(const u8 *_source, u8 *_target, u32 n)
9422 {
9423         const __be16 *source = (const __be16 *)_source;
9424         u16 *target = (u16 *)_target;
9425         u32 i;
9426
9427         for (i = 0; i < n/2; i++)
9428                 target[i] = be16_to_cpu(source[i]);
9429 }
9430
9431 #define BNX2X_ALLOC_AND_SET(arr, lbl, func)                             \
9432 do {                                                                    \
9433         u32 len = be32_to_cpu(fw_hdr->arr.len);                         \
9434         bp->arr = kmalloc(len, GFP_KERNEL);                             \
9435         if (!bp->arr) {                                                 \
9436                 pr_err("Failed to allocate %d bytes for "#arr"\n", len); \
9437                 goto lbl;                                               \
9438         }                                                               \
9439         func(bp->firmware->data + be32_to_cpu(fw_hdr->arr.offset),      \
9440              (u8 *)bp->arr, len);                                       \
9441 } while (0)
9442
9443 int bnx2x_init_firmware(struct bnx2x *bp)
9444 {
9445         const char *fw_file_name;
9446         struct bnx2x_fw_file_hdr *fw_hdr;
9447         int rc;
9448
9449         if (CHIP_IS_E1(bp))
9450                 fw_file_name = FW_FILE_NAME_E1;
9451         else if (CHIP_IS_E1H(bp))
9452                 fw_file_name = FW_FILE_NAME_E1H;
9453         else if (CHIP_IS_E2(bp))
9454                 fw_file_name = FW_FILE_NAME_E2;
9455         else {
9456                 BNX2X_ERR("Unsupported chip revision\n");
9457                 return -EINVAL;
9458         }
9459
9460         BNX2X_DEV_INFO("Loading %s\n", fw_file_name);
9461
9462         rc = request_firmware(&bp->firmware, fw_file_name, &bp->pdev->dev);
9463         if (rc) {
9464                 BNX2X_ERR("Can't load firmware file %s\n", fw_file_name);
9465                 goto request_firmware_exit;
9466         }
9467
9468         rc = bnx2x_check_firmware(bp);
9469         if (rc) {
9470                 BNX2X_ERR("Corrupt firmware file %s\n", fw_file_name);
9471                 goto request_firmware_exit;
9472         }
9473
9474         fw_hdr = (struct bnx2x_fw_file_hdr *)bp->firmware->data;
9475
9476         /* Initialize the pointers to the init arrays */
9477         /* Blob */
9478         BNX2X_ALLOC_AND_SET(init_data, request_firmware_exit, be32_to_cpu_n);
9479
9480         /* Opcodes */
9481         BNX2X_ALLOC_AND_SET(init_ops, init_ops_alloc_err, bnx2x_prep_ops);
9482
9483         /* Offsets */
9484         BNX2X_ALLOC_AND_SET(init_ops_offsets, init_offsets_alloc_err,
9485                             be16_to_cpu_n);
9486
9487         /* STORMs firmware */
9488         INIT_TSEM_INT_TABLE_DATA(bp) = bp->firmware->data +
9489                         be32_to_cpu(fw_hdr->tsem_int_table_data.offset);
9490         INIT_TSEM_PRAM_DATA(bp)      = bp->firmware->data +
9491                         be32_to_cpu(fw_hdr->tsem_pram_data.offset);
9492         INIT_USEM_INT_TABLE_DATA(bp) = bp->firmware->data +
9493                         be32_to_cpu(fw_hdr->usem_int_table_data.offset);
9494         INIT_USEM_PRAM_DATA(bp)      = bp->firmware->data +
9495                         be32_to_cpu(fw_hdr->usem_pram_data.offset);
9496         INIT_XSEM_INT_TABLE_DATA(bp) = bp->firmware->data +
9497                         be32_to_cpu(fw_hdr->xsem_int_table_data.offset);
9498         INIT_XSEM_PRAM_DATA(bp)      = bp->firmware->data +
9499                         be32_to_cpu(fw_hdr->xsem_pram_data.offset);
9500         INIT_CSEM_INT_TABLE_DATA(bp) = bp->firmware->data +
9501                         be32_to_cpu(fw_hdr->csem_int_table_data.offset);
9502         INIT_CSEM_PRAM_DATA(bp)      = bp->firmware->data +
9503                         be32_to_cpu(fw_hdr->csem_pram_data.offset);
9504         /* IRO */
9505         BNX2X_ALLOC_AND_SET(iro_arr, iro_alloc_err, bnx2x_prep_iro);
9506
9507         return 0;
9508
9509 iro_alloc_err:
9510         kfree(bp->init_ops_offsets);
9511 init_offsets_alloc_err:
9512         kfree(bp->init_ops);
9513 init_ops_alloc_err:
9514         kfree(bp->init_data);
9515 request_firmware_exit:
9516         release_firmware(bp->firmware);
9517
9518         return rc;
9519 }
9520
9521 static inline int bnx2x_set_qm_cid_count(struct bnx2x *bp, int l2_cid_count)
9522 {
9523         int cid_count = L2_FP_COUNT(l2_cid_count);
9524
9525 #ifdef BCM_CNIC
9526         cid_count += CNIC_CID_MAX;
9527 #endif
9528         return roundup(cid_count, QM_CID_ROUND);
9529 }
9530
9531 static int __devinit bnx2x_init_one(struct pci_dev *pdev,
9532                                     const struct pci_device_id *ent)
9533 {
9534         struct net_device *dev = NULL;
9535         struct bnx2x *bp;
9536         int pcie_width, pcie_speed;
9537         int rc, cid_count;
9538
9539         switch (ent->driver_data) {
9540         case BCM57710:
9541         case BCM57711:
9542         case BCM57711E:
9543                 cid_count = FP_SB_MAX_E1x;
9544                 break;
9545
9546         case BCM57712:
9547         case BCM57712E:
9548                 cid_count = FP_SB_MAX_E2;
9549                 break;
9550
9551         default:
9552                 pr_err("Unknown board_type (%ld), aborting\n",
9553                            ent->driver_data);
9554                 return -ENODEV;
9555         }
9556
9557         cid_count += NONE_ETH_CONTEXT_USE + CNIC_CONTEXT_USE;
9558
9559         /* dev zeroed in init_etherdev */
9560         dev = alloc_etherdev_mq(sizeof(*bp), cid_count);
9561         if (!dev) {
9562                 dev_err(&pdev->dev, "Cannot allocate net device\n");
9563                 return -ENOMEM;
9564         }
9565
9566         bp = netdev_priv(dev);
9567         bp->msg_enable = debug;
9568
9569         pci_set_drvdata(pdev, dev);
9570
9571         bp->l2_cid_count = cid_count;
9572
9573         rc = bnx2x_init_dev(pdev, dev);
9574         if (rc < 0) {
9575                 free_netdev(dev);
9576                 return rc;
9577         }
9578
9579         rc = bnx2x_init_bp(bp);
9580         if (rc)
9581                 goto init_one_exit;
9582
9583         /* calc qm_cid_count */
9584         bp->qm_cid_count = bnx2x_set_qm_cid_count(bp, cid_count);
9585
9586 #ifdef BCM_CNIC
9587         /* disable FCOE L2 queue for E1x*/
9588         if (CHIP_IS_E1x(bp))
9589                 bp->flags |= NO_FCOE_FLAG;
9590
9591 #endif
9592
9593         /* Configure interrupt mode: try to enable MSI-X/MSI if
9594          * needed, set bp->num_queues appropriately.
9595          */
9596         bnx2x_set_int_mode(bp);
9597
9598         /* Add all NAPI objects */
9599         bnx2x_add_all_napi(bp);
9600
9601         rc = register_netdev(dev);
9602         if (rc) {
9603                 dev_err(&pdev->dev, "Cannot register net device\n");
9604                 goto init_one_exit;
9605         }
9606
9607 #ifdef BCM_CNIC
9608         if (!NO_FCOE(bp)) {
9609                 /* Add storage MAC address */
9610                 rtnl_lock();
9611                 dev_addr_add(bp->dev, bp->fip_mac, NETDEV_HW_ADDR_T_SAN);
9612                 rtnl_unlock();
9613         }
9614 #endif
9615
9616         bnx2x_get_pcie_width_speed(bp, &pcie_width, &pcie_speed);
9617
9618         netdev_info(dev, "%s (%c%d) PCI-E x%d %s found at mem %lx,"
9619                " IRQ %d, ", board_info[ent->driver_data].name,
9620                (CHIP_REV(bp) >> 12) + 'A', (CHIP_METAL(bp) >> 4),
9621                pcie_width,
9622                ((!CHIP_IS_E2(bp) && pcie_speed == 2) ||
9623                  (CHIP_IS_E2(bp) && pcie_speed == 1)) ?
9624                                                 "5GHz (Gen2)" : "2.5GHz",
9625                dev->base_addr, bp->pdev->irq);
9626         pr_cont("node addr %pM\n", dev->dev_addr);
9627
9628         return 0;
9629
9630 init_one_exit:
9631         if (bp->regview)
9632                 iounmap(bp->regview);
9633
9634         if (bp->doorbells)
9635                 iounmap(bp->doorbells);
9636
9637         free_netdev(dev);
9638
9639         if (atomic_read(&pdev->enable_cnt) == 1)
9640                 pci_release_regions(pdev);
9641
9642         pci_disable_device(pdev);
9643         pci_set_drvdata(pdev, NULL);
9644
9645         return rc;
9646 }
9647
9648 static void __devexit bnx2x_remove_one(struct pci_dev *pdev)
9649 {
9650         struct net_device *dev = pci_get_drvdata(pdev);
9651         struct bnx2x *bp;
9652
9653         if (!dev) {
9654                 dev_err(&pdev->dev, "BAD net device from bnx2x_init_one\n");
9655                 return;
9656         }
9657         bp = netdev_priv(dev);
9658
9659 #ifdef BCM_CNIC
9660         /* Delete storage MAC address */
9661         if (!NO_FCOE(bp)) {
9662                 rtnl_lock();
9663                 dev_addr_del(bp->dev, bp->fip_mac, NETDEV_HW_ADDR_T_SAN);
9664                 rtnl_unlock();
9665         }
9666 #endif
9667
9668 #ifdef BCM_DCBNL
9669         /* Delete app tlvs from dcbnl */
9670         bnx2x_dcbnl_update_applist(bp, true);
9671 #endif
9672
9673         unregister_netdev(dev);
9674
9675         /* Delete all NAPI objects */
9676         bnx2x_del_all_napi(bp);
9677
9678         /* Power on: we can't let PCI layer write to us while we are in D3 */
9679         bnx2x_set_power_state(bp, PCI_D0);
9680
9681         /* Disable MSI/MSI-X */
9682         bnx2x_disable_msi(bp);
9683
9684         /* Power off */
9685         bnx2x_set_power_state(bp, PCI_D3hot);
9686
9687         /* Make sure RESET task is not scheduled before continuing */
9688         cancel_delayed_work_sync(&bp->reset_task);
9689
9690         if (bp->regview)
9691                 iounmap(bp->regview);
9692
9693         if (bp->doorbells)
9694                 iounmap(bp->doorbells);
9695
9696         bnx2x_free_mem_bp(bp);
9697
9698         free_netdev(dev);
9699
9700         if (atomic_read(&pdev->enable_cnt) == 1)
9701                 pci_release_regions(pdev);
9702
9703         pci_disable_device(pdev);
9704         pci_set_drvdata(pdev, NULL);
9705 }
9706
9707 static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
9708 {
9709         int i;
9710
9711         bp->state = BNX2X_STATE_ERROR;
9712
9713         bp->rx_mode = BNX2X_RX_MODE_NONE;
9714
9715         bnx2x_netif_stop(bp, 0);
9716         netif_carrier_off(bp->dev);
9717
9718         del_timer_sync(&bp->timer);
9719         bp->stats_state = STATS_STATE_DISABLED;
9720         DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
9721
9722         /* Release IRQs */
9723         bnx2x_free_irq(bp);
9724
9725         /* Free SKBs, SGEs, TPA pool and driver internals */
9726         bnx2x_free_skbs(bp);
9727
9728         for_each_rx_queue(bp, i)
9729                 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
9730
9731         bnx2x_free_mem(bp);
9732
9733         bp->state = BNX2X_STATE_CLOSED;
9734
9735         return 0;
9736 }
9737
9738 static void bnx2x_eeh_recover(struct bnx2x *bp)
9739 {
9740         u32 val;
9741
9742         mutex_init(&bp->port.phy_mutex);
9743
9744         bp->common.shmem_base = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
9745         bp->link_params.shmem_base = bp->common.shmem_base;
9746         BNX2X_DEV_INFO("shmem offset is 0x%x\n", bp->common.shmem_base);
9747
9748         if (!bp->common.shmem_base ||
9749             (bp->common.shmem_base < 0xA0000) ||
9750             (bp->common.shmem_base >= 0xC0000)) {
9751                 BNX2X_DEV_INFO("MCP not active\n");
9752                 bp->flags |= NO_MCP_FLAG;
9753                 return;
9754         }
9755
9756         val = SHMEM_RD(bp, validity_map[BP_PORT(bp)]);
9757         if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
9758                 != (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
9759                 BNX2X_ERR("BAD MCP validity signature\n");
9760
9761         if (!BP_NOMCP(bp)) {
9762                 bp->fw_seq =
9763                     (SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
9764                     DRV_MSG_SEQ_NUMBER_MASK);
9765                 BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
9766         }
9767 }
9768
9769 /**
9770  * bnx2x_io_error_detected - called when PCI error is detected
9771  * @pdev: Pointer to PCI device
9772  * @state: The current pci connection state
9773  *
9774  * This function is called after a PCI bus error affecting
9775  * this device has been detected.
9776  */
9777 static pci_ers_result_t bnx2x_io_error_detected(struct pci_dev *pdev,
9778                                                 pci_channel_state_t state)
9779 {
9780         struct net_device *dev = pci_get_drvdata(pdev);
9781         struct bnx2x *bp = netdev_priv(dev);
9782
9783         rtnl_lock();
9784
9785         netif_device_detach(dev);
9786
9787         if (state == pci_channel_io_perm_failure) {
9788                 rtnl_unlock();
9789                 return PCI_ERS_RESULT_DISCONNECT;
9790         }
9791
9792         if (netif_running(dev))
9793                 bnx2x_eeh_nic_unload(bp);
9794
9795         pci_disable_device(pdev);
9796
9797         rtnl_unlock();
9798
9799         /* Request a slot reset */
9800         return PCI_ERS_RESULT_NEED_RESET;
9801 }
9802
9803 /**
9804  * bnx2x_io_slot_reset - called after the PCI bus has been reset
9805  * @pdev: Pointer to PCI device
9806  *
9807  * Restart the card from scratch, as if from a cold-boot.
9808  */
9809 static pci_ers_result_t bnx2x_io_slot_reset(struct pci_dev *pdev)
9810 {
9811         struct net_device *dev = pci_get_drvdata(pdev);
9812         struct bnx2x *bp = netdev_priv(dev);
9813
9814         rtnl_lock();
9815
9816         if (pci_enable_device(pdev)) {
9817                 dev_err(&pdev->dev,
9818                         "Cannot re-enable PCI device after reset\n");
9819                 rtnl_unlock();
9820                 return PCI_ERS_RESULT_DISCONNECT;
9821         }
9822
9823         pci_set_master(pdev);
9824         pci_restore_state(pdev);
9825
9826         if (netif_running(dev))
9827                 bnx2x_set_power_state(bp, PCI_D0);
9828
9829         rtnl_unlock();
9830
9831         return PCI_ERS_RESULT_RECOVERED;
9832 }
9833
9834 /**
9835  * bnx2x_io_resume - called when traffic can start flowing again
9836  * @pdev: Pointer to PCI device
9837  *
9838  * This callback is called when the error recovery driver tells us that
9839  * its OK to resume normal operation.
9840  */
9841 static void bnx2x_io_resume(struct pci_dev *pdev)
9842 {
9843         struct net_device *dev = pci_get_drvdata(pdev);
9844         struct bnx2x *bp = netdev_priv(dev);
9845
9846         if (bp->recovery_state != BNX2X_RECOVERY_DONE) {
9847                 printk(KERN_ERR "Handling parity error recovery. "
9848                                 "Try again later\n");
9849                 return;
9850         }
9851
9852         rtnl_lock();
9853
9854         bnx2x_eeh_recover(bp);
9855
9856         if (netif_running(dev))
9857                 bnx2x_nic_load(bp, LOAD_NORMAL);
9858
9859         netif_device_attach(dev);
9860
9861         rtnl_unlock();
9862 }
9863
9864 static struct pci_error_handlers bnx2x_err_handler = {
9865         .error_detected = bnx2x_io_error_detected,
9866         .slot_reset     = bnx2x_io_slot_reset,
9867         .resume         = bnx2x_io_resume,
9868 };
9869
9870 static struct pci_driver bnx2x_pci_driver = {
9871         .name        = DRV_MODULE_NAME,
9872         .id_table    = bnx2x_pci_tbl,
9873         .probe       = bnx2x_init_one,
9874         .remove      = __devexit_p(bnx2x_remove_one),
9875         .suspend     = bnx2x_suspend,
9876         .resume      = bnx2x_resume,
9877         .err_handler = &bnx2x_err_handler,
9878 };
9879
9880 static int __init bnx2x_init(void)
9881 {
9882         int ret;
9883
9884         pr_info("%s", version);
9885
9886         bnx2x_wq = create_singlethread_workqueue("bnx2x");
9887         if (bnx2x_wq == NULL) {
9888                 pr_err("Cannot create workqueue\n");
9889                 return -ENOMEM;
9890         }
9891
9892         ret = pci_register_driver(&bnx2x_pci_driver);
9893         if (ret) {
9894                 pr_err("Cannot register driver\n");
9895                 destroy_workqueue(bnx2x_wq);
9896         }
9897         return ret;
9898 }
9899
9900 static void __exit bnx2x_cleanup(void)
9901 {
9902         pci_unregister_driver(&bnx2x_pci_driver);
9903
9904         destroy_workqueue(bnx2x_wq);
9905 }
9906
9907 module_init(bnx2x_init);
9908 module_exit(bnx2x_cleanup);
9909
9910 #ifdef BCM_CNIC
9911
9912 /* count denotes the number of new completions we have seen */
9913 static void bnx2x_cnic_sp_post(struct bnx2x *bp, int count)
9914 {
9915         struct eth_spe *spe;
9916
9917 #ifdef BNX2X_STOP_ON_ERROR
9918         if (unlikely(bp->panic))
9919                 return;
9920 #endif
9921
9922         spin_lock_bh(&bp->spq_lock);
9923         BUG_ON(bp->cnic_spq_pending < count);
9924         bp->cnic_spq_pending -= count;
9925
9926
9927         for (; bp->cnic_kwq_pending; bp->cnic_kwq_pending--) {
9928                 u16 type =  (le16_to_cpu(bp->cnic_kwq_cons->hdr.type)
9929                                 & SPE_HDR_CONN_TYPE) >>
9930                                 SPE_HDR_CONN_TYPE_SHIFT;
9931
9932                 /* Set validation for iSCSI L2 client before sending SETUP
9933                  *  ramrod
9934                  */
9935                 if (type == ETH_CONNECTION_TYPE) {
9936                         u8 cmd = (le32_to_cpu(bp->cnic_kwq_cons->
9937                                              hdr.conn_and_cmd_data) >>
9938                                 SPE_HDR_CMD_ID_SHIFT) & 0xff;
9939
9940                         if (cmd == RAMROD_CMD_ID_ETH_CLIENT_SETUP)
9941                                 bnx2x_set_ctx_validation(&bp->context.
9942                                                 vcxt[BNX2X_ISCSI_ETH_CID].eth,
9943                                         HW_CID(bp, BNX2X_ISCSI_ETH_CID));
9944                 }
9945
9946                 /* There may be not more than 8 L2 and not more than 8 L5 SPEs
9947                  * We also check that the number of outstanding
9948                  * COMMON ramrods is not more than the EQ and SPQ can
9949                  * accommodate.
9950                  */
9951                 if (type == ETH_CONNECTION_TYPE) {
9952                         if (!atomic_read(&bp->cq_spq_left))
9953                                 break;
9954                         else
9955                                 atomic_dec(&bp->cq_spq_left);
9956                 } else if (type == NONE_CONNECTION_TYPE) {
9957                         if (!atomic_read(&bp->eq_spq_left))
9958                                 break;
9959                         else
9960                                 atomic_dec(&bp->eq_spq_left);
9961                 } else if ((type == ISCSI_CONNECTION_TYPE) ||
9962                            (type == FCOE_CONNECTION_TYPE)) {
9963                         if (bp->cnic_spq_pending >=
9964                             bp->cnic_eth_dev.max_kwqe_pending)
9965                                 break;
9966                         else
9967                                 bp->cnic_spq_pending++;
9968                 } else {
9969                         BNX2X_ERR("Unknown SPE type: %d\n", type);
9970                         bnx2x_panic();
9971                         break;
9972                 }
9973
9974                 spe = bnx2x_sp_get_next(bp);
9975                 *spe = *bp->cnic_kwq_cons;
9976
9977                 DP(NETIF_MSG_TIMER, "pending on SPQ %d, on KWQ %d count %d\n",
9978                    bp->cnic_spq_pending, bp->cnic_kwq_pending, count);
9979
9980                 if (bp->cnic_kwq_cons == bp->cnic_kwq_last)
9981                         bp->cnic_kwq_cons = bp->cnic_kwq;
9982                 else
9983                         bp->cnic_kwq_cons++;
9984         }
9985         bnx2x_sp_prod_update(bp);
9986         spin_unlock_bh(&bp->spq_lock);
9987 }
9988
9989 static int bnx2x_cnic_sp_queue(struct net_device *dev,
9990                                struct kwqe_16 *kwqes[], u32 count)
9991 {
9992         struct bnx2x *bp = netdev_priv(dev);
9993         int i;
9994
9995 #ifdef BNX2X_STOP_ON_ERROR
9996         if (unlikely(bp->panic))
9997                 return -EIO;
9998 #endif
9999
10000         spin_lock_bh(&bp->spq_lock);
10001
10002         for (i = 0; i < count; i++) {
10003                 struct eth_spe *spe = (struct eth_spe *)kwqes[i];
10004
10005                 if (bp->cnic_kwq_pending == MAX_SP_DESC_CNT)
10006                         break;
10007
10008                 *bp->cnic_kwq_prod = *spe;
10009
10010                 bp->cnic_kwq_pending++;
10011
10012                 DP(NETIF_MSG_TIMER, "L5 SPQE %x %x %x:%x pos %d\n",
10013                    spe->hdr.conn_and_cmd_data, spe->hdr.type,
10014                    spe->data.update_data_addr.hi,
10015                    spe->data.update_data_addr.lo,
10016                    bp->cnic_kwq_pending);
10017
10018                 if (bp->cnic_kwq_prod == bp->cnic_kwq_last)
10019                         bp->cnic_kwq_prod = bp->cnic_kwq;
10020                 else
10021                         bp->cnic_kwq_prod++;
10022         }
10023
10024         spin_unlock_bh(&bp->spq_lock);
10025
10026         if (bp->cnic_spq_pending < bp->cnic_eth_dev.max_kwqe_pending)
10027                 bnx2x_cnic_sp_post(bp, 0);
10028
10029         return i;
10030 }
10031
10032 static int bnx2x_cnic_ctl_send(struct bnx2x *bp, struct cnic_ctl_info *ctl)
10033 {
10034         struct cnic_ops *c_ops;
10035         int rc = 0;
10036
10037         mutex_lock(&bp->cnic_mutex);
10038         c_ops = rcu_dereference_protected(bp->cnic_ops,
10039                                           lockdep_is_held(&bp->cnic_mutex));
10040         if (c_ops)
10041                 rc = c_ops->cnic_ctl(bp->cnic_data, ctl);
10042         mutex_unlock(&bp->cnic_mutex);
10043
10044         return rc;
10045 }
10046
10047 static int bnx2x_cnic_ctl_send_bh(struct bnx2x *bp, struct cnic_ctl_info *ctl)
10048 {
10049         struct cnic_ops *c_ops;
10050         int rc = 0;
10051
10052         rcu_read_lock();
10053         c_ops = rcu_dereference(bp->cnic_ops);
10054         if (c_ops)
10055                 rc = c_ops->cnic_ctl(bp->cnic_data, ctl);
10056         rcu_read_unlock();
10057
10058         return rc;
10059 }
10060
10061 /*
10062  * for commands that have no data
10063  */
10064 int bnx2x_cnic_notify(struct bnx2x *bp, int cmd)
10065 {
10066         struct cnic_ctl_info ctl = {0};
10067
10068         ctl.cmd = cmd;
10069
10070         return bnx2x_cnic_ctl_send(bp, &ctl);
10071 }
10072
10073 static void bnx2x_cnic_cfc_comp(struct bnx2x *bp, int cid)
10074 {
10075         struct cnic_ctl_info ctl;
10076
10077         /* first we tell CNIC and only then we count this as a completion */
10078         ctl.cmd = CNIC_CTL_COMPLETION_CMD;
10079         ctl.data.comp.cid = cid;
10080
10081         bnx2x_cnic_ctl_send_bh(bp, &ctl);
10082         bnx2x_cnic_sp_post(bp, 0);
10083 }
10084
10085 static int bnx2x_drv_ctl(struct net_device *dev, struct drv_ctl_info *ctl)
10086 {
10087         struct bnx2x *bp = netdev_priv(dev);
10088         int rc = 0;
10089
10090         switch (ctl->cmd) {
10091         case DRV_CTL_CTXTBL_WR_CMD: {
10092                 u32 index = ctl->data.io.offset;
10093                 dma_addr_t addr = ctl->data.io.dma_addr;
10094
10095                 bnx2x_ilt_wr(bp, index, addr);
10096                 break;
10097         }
10098
10099         case DRV_CTL_RET_L5_SPQ_CREDIT_CMD: {
10100                 int count = ctl->data.credit.credit_count;
10101
10102                 bnx2x_cnic_sp_post(bp, count);
10103                 break;
10104         }
10105
10106         /* rtnl_lock is held.  */
10107         case DRV_CTL_START_L2_CMD: {
10108                 u32 cli = ctl->data.ring.client_id;
10109
10110                 /* Clear FCoE FIP and ALL ENODE MACs addresses first */
10111                 bnx2x_del_fcoe_eth_macs(bp);
10112
10113                 /* Set iSCSI MAC address */
10114                 bnx2x_set_iscsi_eth_mac_addr(bp, 1);
10115
10116                 mmiowb();
10117                 barrier();
10118
10119                 /* Start accepting on iSCSI L2 ring. Accept all multicasts
10120                  * because it's the only way for UIO Client to accept
10121                  * multicasts (in non-promiscuous mode only one Client per
10122                  * function will receive multicast packets (leading in our
10123                  * case).
10124                  */
10125                 bnx2x_rxq_set_mac_filters(bp, cli,
10126                         BNX2X_ACCEPT_UNICAST |
10127                         BNX2X_ACCEPT_BROADCAST |
10128                         BNX2X_ACCEPT_ALL_MULTICAST);
10129                 storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
10130
10131                 break;
10132         }
10133
10134         /* rtnl_lock is held.  */
10135         case DRV_CTL_STOP_L2_CMD: {
10136                 u32 cli = ctl->data.ring.client_id;
10137
10138                 /* Stop accepting on iSCSI L2 ring */
10139                 bnx2x_rxq_set_mac_filters(bp, cli, BNX2X_ACCEPT_NONE);
10140                 storm_memset_mac_filters(bp, &bp->mac_filters, BP_FUNC(bp));
10141
10142                 mmiowb();
10143                 barrier();
10144
10145                 /* Unset iSCSI L2 MAC */
10146                 bnx2x_set_iscsi_eth_mac_addr(bp, 0);
10147                 break;
10148         }
10149         case DRV_CTL_RET_L2_SPQ_CREDIT_CMD: {
10150                 int count = ctl->data.credit.credit_count;
10151
10152                 smp_mb__before_atomic_inc();
10153                 atomic_add(count, &bp->cq_spq_left);
10154                 smp_mb__after_atomic_inc();
10155                 break;
10156         }
10157
10158         case DRV_CTL_ISCSI_STOPPED_CMD: {
10159                 bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_ISCSI_STOPPED);
10160                 break;
10161         }
10162
10163         default:
10164                 BNX2X_ERR("unknown command %x\n", ctl->cmd);
10165                 rc = -EINVAL;
10166         }
10167
10168         return rc;
10169 }
10170
10171 void bnx2x_setup_cnic_irq_info(struct bnx2x *bp)
10172 {
10173         struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
10174
10175         if (bp->flags & USING_MSIX_FLAG) {
10176                 cp->drv_state |= CNIC_DRV_STATE_USING_MSIX;
10177                 cp->irq_arr[0].irq_flags |= CNIC_IRQ_FL_MSIX;
10178                 cp->irq_arr[0].vector = bp->msix_table[1].vector;
10179         } else {
10180                 cp->drv_state &= ~CNIC_DRV_STATE_USING_MSIX;
10181                 cp->irq_arr[0].irq_flags &= ~CNIC_IRQ_FL_MSIX;
10182         }
10183         if (CHIP_IS_E2(bp))
10184                 cp->irq_arr[0].status_blk = (void *)bp->cnic_sb.e2_sb;
10185         else
10186                 cp->irq_arr[0].status_blk = (void *)bp->cnic_sb.e1x_sb;
10187
10188         cp->irq_arr[0].status_blk_num = CNIC_SB_ID(bp);
10189         cp->irq_arr[0].status_blk_num2 = CNIC_IGU_SB_ID(bp);
10190         cp->irq_arr[1].status_blk = bp->def_status_blk;
10191         cp->irq_arr[1].status_blk_num = DEF_SB_ID;
10192         cp->irq_arr[1].status_blk_num2 = DEF_SB_IGU_ID;
10193
10194         cp->num_irq = 2;
10195 }
10196
10197 static int bnx2x_register_cnic(struct net_device *dev, struct cnic_ops *ops,
10198                                void *data)
10199 {
10200         struct bnx2x *bp = netdev_priv(dev);
10201         struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
10202
10203         if (ops == NULL)
10204                 return -EINVAL;
10205
10206         if (atomic_read(&bp->intr_sem) != 0)
10207                 return -EBUSY;
10208
10209         bp->cnic_kwq = kzalloc(PAGE_SIZE, GFP_KERNEL);
10210         if (!bp->cnic_kwq)
10211                 return -ENOMEM;
10212
10213         bp->cnic_kwq_cons = bp->cnic_kwq;
10214         bp->cnic_kwq_prod = bp->cnic_kwq;
10215         bp->cnic_kwq_last = bp->cnic_kwq + MAX_SP_DESC_CNT;
10216
10217         bp->cnic_spq_pending = 0;
10218         bp->cnic_kwq_pending = 0;
10219
10220         bp->cnic_data = data;
10221
10222         cp->num_irq = 0;
10223         cp->drv_state = CNIC_DRV_STATE_REGD;
10224         cp->iro_arr = bp->iro_arr;
10225
10226         bnx2x_setup_cnic_irq_info(bp);
10227
10228         rcu_assign_pointer(bp->cnic_ops, ops);
10229
10230         return 0;
10231 }
10232
10233 static int bnx2x_unregister_cnic(struct net_device *dev)
10234 {
10235         struct bnx2x *bp = netdev_priv(dev);
10236         struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
10237
10238         mutex_lock(&bp->cnic_mutex);
10239         cp->drv_state = 0;
10240         rcu_assign_pointer(bp->cnic_ops, NULL);
10241         mutex_unlock(&bp->cnic_mutex);
10242         synchronize_rcu();
10243         kfree(bp->cnic_kwq);
10244         bp->cnic_kwq = NULL;
10245
10246         return 0;
10247 }
10248
10249 struct cnic_eth_dev *bnx2x_cnic_probe(struct net_device *dev)
10250 {
10251         struct bnx2x *bp = netdev_priv(dev);
10252         struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
10253
10254         /* If both iSCSI and FCoE are disabled - return NULL in
10255          * order to indicate CNIC that it should not try to work
10256          * with this device.
10257          */
10258         if (NO_ISCSI(bp) && NO_FCOE(bp))
10259                 return NULL;
10260
10261         cp->drv_owner = THIS_MODULE;
10262         cp->chip_id = CHIP_ID(bp);
10263         cp->pdev = bp->pdev;
10264         cp->io_base = bp->regview;
10265         cp->io_base2 = bp->doorbells;
10266         cp->max_kwqe_pending = 8;
10267         cp->ctx_blk_size = CDU_ILT_PAGE_SZ;
10268         cp->ctx_tbl_offset = FUNC_ILT_BASE(BP_FUNC(bp)) +
10269                              bnx2x_cid_ilt_lines(bp);
10270         cp->ctx_tbl_len = CNIC_ILT_LINES;
10271         cp->starting_cid = bnx2x_cid_ilt_lines(bp) * ILT_PAGE_CIDS;
10272         cp->drv_submit_kwqes_16 = bnx2x_cnic_sp_queue;
10273         cp->drv_ctl = bnx2x_drv_ctl;
10274         cp->drv_register_cnic = bnx2x_register_cnic;
10275         cp->drv_unregister_cnic = bnx2x_unregister_cnic;
10276         cp->fcoe_init_cid = BNX2X_FCOE_ETH_CID;
10277         cp->iscsi_l2_client_id = BNX2X_ISCSI_ETH_CL_ID +
10278                 BP_E1HVN(bp) * NONE_ETH_CONTEXT_USE;
10279         cp->iscsi_l2_cid = BNX2X_ISCSI_ETH_CID;
10280
10281         if (NO_ISCSI_OOO(bp))
10282                 cp->drv_state |= CNIC_DRV_STATE_NO_ISCSI_OOO;
10283
10284         if (NO_ISCSI(bp))
10285                 cp->drv_state |= CNIC_DRV_STATE_NO_ISCSI;
10286
10287         if (NO_FCOE(bp))
10288                 cp->drv_state |= CNIC_DRV_STATE_NO_FCOE;
10289
10290         DP(BNX2X_MSG_SP, "page_size %d, tbl_offset %d, tbl_lines %d, "
10291                          "starting cid %d\n",
10292            cp->ctx_blk_size,
10293            cp->ctx_tbl_offset,
10294            cp->ctx_tbl_len,
10295            cp->starting_cid);
10296         return cp;
10297 }
10298 EXPORT_SYMBOL(bnx2x_cnic_probe);
10299
10300 #endif /* BCM_CNIC */
10301