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