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