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