drivers/net/qede/base/ecore.h

   1 /*
   2  * Copyright (c) 2016 QLogic Corporation.
   3  * All rights reserved.
   4  * www.qlogic.com
   5  *
   6  * See LICENSE.qede_pmd for copyright and licensing details.
   7  */
   8
   9 #ifndef __ECORE_H
  10 #define __ECORE_H
  11
  12 #include "ecore_hsi_common.h"
  13 #include "ecore_hsi_tools.h"
  14 #include "ecore_proto_if.h"
  15 #include "mcp_public.h"
  16
  17 #define MAX_HWFNS_PER_DEVICE    (4)
  18 #define NAME_SIZE 64            /* @DPDK */
  19 #define VER_SIZE 16
  20 /* @DPDK ARRAY_DECL */
  21 #define ECORE_WFQ_UNIT  100
  22 #include "../qede_logs.h"       /* @DPDK */
  23
  24 /* Constants */
  25 #define ECORE_WID_SIZE          (1024)
  26
  27 /* Configurable */
  28 #define ECORE_PF_DEMS_SIZE      (4)
  29
  30 /* cau states */
  31 enum ecore_coalescing_mode {
  32         ECORE_COAL_MODE_DISABLE,
  33         ECORE_COAL_MODE_ENABLE
  34 };
  35
  36 enum ecore_nvm_cmd {
  37         ECORE_PUT_FILE_BEGIN = DRV_MSG_CODE_NVM_PUT_FILE_BEGIN,
  38         ECORE_PUT_FILE_DATA = DRV_MSG_CODE_NVM_PUT_FILE_DATA,
  39         ECORE_NVM_READ_NVRAM = DRV_MSG_CODE_NVM_READ_NVRAM,
  40         ECORE_NVM_WRITE_NVRAM = DRV_MSG_CODE_NVM_WRITE_NVRAM,
  41         ECORE_NVM_DEL_FILE = DRV_MSG_CODE_NVM_DEL_FILE,
  42         ECORE_NVM_SET_SECURE_MODE = DRV_MSG_CODE_SET_SECURE_MODE,
  43         ECORE_PHY_RAW_READ = DRV_MSG_CODE_PHY_RAW_READ,
  44         ECORE_PHY_RAW_WRITE = DRV_MSG_CODE_PHY_RAW_WRITE,
  45         ECORE_PHY_CORE_READ = DRV_MSG_CODE_PHY_CORE_READ,
  46         ECORE_PHY_CORE_WRITE = DRV_MSG_CODE_PHY_CORE_WRITE,
  47         ECORE_GET_MCP_NVM_RESP = 0xFFFFFF00
  48 };
  49
  50 #ifndef LINUX_REMOVE
  51 #if !defined(CONFIG_ECORE_L2)
  52 #define CONFIG_ECORE_L2
  53 #define CONFIG_ECORE_SRIOV
  54 #endif
  55 #endif
  56
  57 /* helpers */
  58 #ifndef __EXTRACT__LINUX__
  59 #define MASK_FIELD(_name, _value)                                       \
  60                 ((_value) &= (_name##_MASK))
  61
  62 #define FIELD_VALUE(_name, _value)                                      \
  63                 ((_value & _name##_MASK) << _name##_SHIFT)
  64
  65 #define SET_FIELD(value, name, flag)                                    \
  66 do {                                                                    \
  67         (value) &= ~(name##_MASK << name##_SHIFT);                      \
  68         (value) |= (((u64)flag) << (name##_SHIFT));                     \
  69 } while (0)
  70
  71 #define GET_FIELD(value, name)                                          \
  72         (((value) >> (name##_SHIFT)) & name##_MASK)
  73 #endif
  74
  75 static OSAL_INLINE u32 DB_ADDR(u32 cid, u32 DEMS)
  76 {
  77         u32 db_addr = FIELD_VALUE(DB_LEGACY_ADDR_DEMS, DEMS) |
  78             (cid * ECORE_PF_DEMS_SIZE);
  79
  80         return db_addr;
  81 }
  82
  83 /* @DPDK: This is a backport from latest ecore for TSS fix */
  84 static OSAL_INLINE u32 DB_ADDR_VF(u32 cid, u32 DEMS)
  85 {
  86         u32 db_addr = FIELD_VALUE(DB_LEGACY_ADDR_DEMS, DEMS) |
  87                       FIELD_VALUE(DB_LEGACY_ADDR_ICID, cid);
  88
  89         return db_addr;
  90 }
  91
  92 #define ALIGNED_TYPE_SIZE(type_name, p_hwfn)                              \
  93         ((sizeof(type_name) + (u32)(1 << (p_hwfn->p_dev->cache_shift)) - 1) & \
  94          ~((1 << (p_hwfn->p_dev->cache_shift)) - 1))
  95
  96 #ifndef U64_HI
  97 #define U64_HI(val) ((u32)(((u64)(val))  >> 32))
  98 #endif
  99
 100 #ifndef U64_LO
 101 #define U64_LO(val) ((u32)(((u64)(val)) & 0xffffffff))
 102 #endif
 103
 104 #ifndef __EXTRACT__LINUX__
 105 enum DP_LEVEL {
 106         ECORE_LEVEL_VERBOSE = 0x0,
 107         ECORE_LEVEL_INFO = 0x1,
 108         ECORE_LEVEL_NOTICE = 0x2,
 109         ECORE_LEVEL_ERR = 0x3,
 110 };
 111
 112 #define ECORE_LOG_LEVEL_SHIFT   (30)
 113 #define ECORE_LOG_VERBOSE_MASK  (0x3fffffff)
 114 #define ECORE_LOG_INFO_MASK     (0x40000000)
 115 #define ECORE_LOG_NOTICE_MASK   (0x80000000)
 116
 117 enum DP_MODULE {
 118 #ifndef LINUX_REMOVE
 119         ECORE_MSG_DRV = 0x0001,
 120         ECORE_MSG_PROBE = 0x0002,
 121         ECORE_MSG_LINK = 0x0004,
 122         ECORE_MSG_TIMER = 0x0008,
 123         ECORE_MSG_IFDOWN = 0x0010,
 124         ECORE_MSG_IFUP = 0x0020,
 125         ECORE_MSG_RX_ERR = 0x0040,
 126         ECORE_MSG_TX_ERR = 0x0080,
 127         ECORE_MSG_TX_QUEUED = 0x0100,
 128         ECORE_MSG_INTR = 0x0200,
 129         ECORE_MSG_TX_DONE = 0x0400,
 130         ECORE_MSG_RX_STATUS = 0x0800,
 131         ECORE_MSG_PKTDATA = 0x1000,
 132         ECORE_MSG_HW = 0x2000,
 133         ECORE_MSG_WOL = 0x4000,
 134 #endif
 135         ECORE_MSG_SPQ = 0x10000,
 136         ECORE_MSG_STATS = 0x20000,
 137         ECORE_MSG_DCB = 0x40000,
 138         ECORE_MSG_IOV = 0x80000,
 139         ECORE_MSG_SP = 0x100000,
 140         ECORE_MSG_STORAGE = 0x200000,
 141         ECORE_MSG_CXT = 0x800000,
 142         ECORE_MSG_ILT = 0x2000000,
 143         ECORE_MSG_DEBUG = 0x8000000,
 144         /* to be added...up to 0x8000000 */
 145 };
 146 #endif
 147
 148 #define for_each_hwfn(p_dev, i) for (i = 0; i < p_dev->num_hwfns; i++)
 149
 150 #define D_TRINE(val, cond1, cond2, true1, true2, def) \
 151         (val == (cond1) ? true1 : \
 152          (val == (cond2) ? true2 : def))
 153
 154 /* forward */
 155 struct ecore_ptt_pool;
 156 struct ecore_spq;
 157 struct ecore_sb_info;
 158 struct ecore_sb_attn_info;
 159 struct ecore_cxt_mngr;
 160 struct ecore_dma_mem;
 161 struct ecore_sb_sp_info;
 162 struct ecore_igu_info;
 163 struct ecore_mcp_info;
 164 struct ecore_dcbx_info;
 165
 166 struct ecore_rt_data {
 167         u32 *init_val;
 168         bool *b_valid;
 169 };
 170
 171 enum ecore_tunn_mode {
 172         ECORE_MODE_L2GENEVE_TUNN,
 173         ECORE_MODE_IPGENEVE_TUNN,
 174         ECORE_MODE_L2GRE_TUNN,
 175         ECORE_MODE_IPGRE_TUNN,
 176         ECORE_MODE_VXLAN_TUNN,
 177 };
 178
 179 enum ecore_tunn_clss {
 180         ECORE_TUNN_CLSS_MAC_VLAN,
 181         ECORE_TUNN_CLSS_MAC_VNI,
 182         ECORE_TUNN_CLSS_INNER_MAC_VLAN,
 183         ECORE_TUNN_CLSS_INNER_MAC_VNI,
 184         MAX_ECORE_TUNN_CLSS,
 185 };
 186
 187 struct ecore_tunn_start_params {
 188         unsigned long tunn_mode;
 189         u16 vxlan_udp_port;
 190         u16 geneve_udp_port;
 191         u8 update_vxlan_udp_port;
 192         u8 update_geneve_udp_port;
 193         u8 tunn_clss_vxlan;
 194         u8 tunn_clss_l2geneve;
 195         u8 tunn_clss_ipgeneve;
 196         u8 tunn_clss_l2gre;
 197         u8 tunn_clss_ipgre;
 198 };
 199
 200 struct ecore_tunn_update_params {
 201         unsigned long tunn_mode_update_mask;
 202         unsigned long tunn_mode;
 203         u16 vxlan_udp_port;
 204         u16 geneve_udp_port;
 205         u8 update_rx_pf_clss;
 206         u8 update_tx_pf_clss;
 207         u8 update_vxlan_udp_port;
 208         u8 update_geneve_udp_port;
 209         u8 tunn_clss_vxlan;
 210         u8 tunn_clss_l2geneve;
 211         u8 tunn_clss_ipgeneve;
 212         u8 tunn_clss_l2gre;
 213         u8 tunn_clss_ipgre;
 214 };
 215
 216 struct ecore_hw_sriov_info {
 217         /* standard SRIOV capability fields, mostly for debugging */
 218         int pos;                /* capability position */
 219         int nres;               /* number of resources */
 220         u32 cap;                /* SR-IOV Capabilities */
 221         u16 ctrl;               /* SR-IOV Control */
 222         u16 total_vfs;          /* total VFs associated with the PF */
 223         u16 num_vfs;            /* number of vfs that have been started */
 224         u64 active_vfs[3];      /* bitfield of active vfs */
 225 #define ECORE_IS_VF_ACTIVE(_p_dev, _rel_vf_id)  \
 226                 (!!(_p_dev->sriov_info.active_vfs[_rel_vf_id / 64] & \
 227                     (1ULL << (_rel_vf_id % 64))))
 228         u16 initial_vfs;        /* initial VFs associated with the PF */
 229         u16 nr_virtfn;          /* number of VFs available */
 230         u16 offset;             /* first VF Routing ID offset */
 231         u16 stride;             /* following VF stride */
 232         u16 vf_device_id;       /* VF device id */
 233         u32 pgsz;               /* page size for BAR alignment */
 234         u8 link;                /* Function Dependency Link */
 235
 236         bool b_hw_channel;      /* Whether PF uses the HW-channel */
 237 };
 238
 239 /* The PCI personality is not quite synonymous to protocol ID:
 240  * 1. All personalities need CORE connections
 241  * 2. The Ethernet personality may support also the RoCE protocol
 242  */
 243 enum ecore_pci_personality {
 244         ECORE_PCI_ETH,
 245         ECORE_PCI_DEFAULT       /* default in shmem */
 246 };
 247
 248 /* All VFs are symmetric, all counters are PF + all VFs */
 249 struct ecore_qm_iids {
 250         u32 cids;
 251         u32 vf_cids;
 252         u32 tids;
 253 };
 254
 255 #define MAX_PF_PER_PORT 8
 256
 257 /*@@@TBD MK RESC: need to remove and use MCP interface instead */
 258 /* HW / FW resources, output of features supported below, most information
 259  * is received from MFW.
 260  */
 261 enum ECORE_RESOURCES {
 262         ECORE_SB,
 263         ECORE_L2_QUEUE,
 264         ECORE_VPORT,
 265         ECORE_RSS_ENG,
 266         ECORE_PQ,
 267         ECORE_RL,
 268         ECORE_MAC,
 269         ECORE_VLAN,
 270         ECORE_ILT,
 271         ECORE_CMDQS_CQS,
 272         ECORE_MAX_RESC,
 273 };
 274
 275 /* Features that require resources, given as input to the resource management
 276  * algorithm, the output are the resources above
 277  */
 278 enum ECORE_FEATURE {
 279         ECORE_PF_L2_QUE,
 280         ECORE_PF_TC,
 281         ECORE_VF,
 282         ECORE_EXTRA_VF_QUE,
 283         ECORE_VMQ,
 284         ECORE_MAX_FEATURES,
 285 };
 286
 287 enum ECORE_PORT_MODE {
 288         ECORE_PORT_MODE_DE_2X40G,
 289         ECORE_PORT_MODE_DE_2X50G,
 290         ECORE_PORT_MODE_DE_1X100G,
 291         ECORE_PORT_MODE_DE_4X10G_F,
 292         ECORE_PORT_MODE_DE_4X10G_E,
 293         ECORE_PORT_MODE_DE_4X20G,
 294         ECORE_PORT_MODE_DE_1X40G,
 295         ECORE_PORT_MODE_DE_2X25G,
 296         ECORE_PORT_MODE_DE_1X25G
 297 };
 298
 299 enum ecore_dev_cap {
 300         ECORE_DEV_CAP_ETH,
 301 };
 302
 303 #ifndef __EXTRACT__LINUX__
 304 enum ecore_hw_err_type {
 305         ECORE_HW_ERR_FAN_FAIL,
 306         ECORE_HW_ERR_MFW_RESP_FAIL,
 307         ECORE_HW_ERR_HW_ATTN,
 308         ECORE_HW_ERR_DMAE_FAIL,
 309         ECORE_HW_ERR_RAMROD_FAIL,
 310         ECORE_HW_ERR_FW_ASSERT,
 311 };
 312 #endif
 313
 314 struct ecore_hw_info {
 315         /* PCI personality */
 316         enum ecore_pci_personality personality;
 317
 318         /* Resource Allocation scheme results */
 319         u32 resc_start[ECORE_MAX_RESC];
 320         u32 resc_num[ECORE_MAX_RESC];
 321         u32 feat_num[ECORE_MAX_FEATURES];
 322
 323 #define RESC_START(_p_hwfn, resc) ((_p_hwfn)->hw_info.resc_start[resc])
 324 #define RESC_NUM(_p_hwfn, resc) ((_p_hwfn)->hw_info.resc_num[resc])
 325 #define RESC_END(_p_hwfn, resc) (RESC_START(_p_hwfn, resc) + \
 326                                          RESC_NUM(_p_hwfn, resc))
 327 #define FEAT_NUM(_p_hwfn, resc) ((_p_hwfn)->hw_info.feat_num[resc])
 328
 329         u8 num_tc;
 330         u8 ooo_tc;
 331         u8 offload_tc;
 332         u8 non_offload_tc;
 333
 334         u32 concrete_fid;
 335         u16 opaque_fid;
 336         u16 ovlan;
 337         u32 part_num[4];
 338
 339         unsigned char hw_mac_addr[ETH_ALEN];
 340
 341         struct ecore_igu_info *p_igu_info;
 342         /* Sriov */
 343         u32 first_vf_in_pf;
 344         u8 max_chains_per_vf;
 345
 346         u32 port_mode;
 347         u32 hw_mode;
 348         unsigned long device_capabilities;
 349 };
 350
 351 struct ecore_hw_cid_data {
 352         u32 cid;
 353         bool b_cid_allocated;
 354         u8 vfid;                /* 1-based; 0 signals this is for a PF */
 355
 356         /* Additional identifiers */
 357         u16 opaque_fid;
 358         u8 vport_id;
 359 };
 360
 361 /* maximun size of read/write commands (HW limit) */
 362 #define DMAE_MAX_RW_SIZE        0x2000
 363
 364 struct ecore_dmae_info {
 365         /* Mutex for synchronizing access to functions */
 366         osal_mutex_t mutex;
 367
 368         u8 channel;
 369
 370         dma_addr_t completion_word_phys_addr;
 371
 372         /* The memory location where the DMAE writes the completion
 373          * value when an operation is finished on this context.
 374          */
 375         u32 *p_completion_word;
 376
 377         dma_addr_t intermediate_buffer_phys_addr;
 378
 379         /* An intermediate buffer for DMAE operations that use virtual
 380          * addresses - data is DMA'd to/from this buffer and then
 381          * memcpy'd to/from the virtual address
 382          */
 383         u32 *p_intermediate_buffer;
 384
 385         dma_addr_t dmae_cmd_phys_addr;
 386         struct dmae_cmd *p_dmae_cmd;
 387 };
 388
 389 struct ecore_wfq_data {
 390         u32 default_min_speed;  /* When wfq feature is not configured */
 391         u32 min_speed;          /* when feature is configured for any 1 vport */
 392         bool configured;
 393 };
 394
 395 struct ecore_qm_info {
 396         struct init_qm_pq_params *qm_pq_params;
 397         struct init_qm_vport_params *qm_vport_params;
 398         struct init_qm_port_params *qm_port_params;
 399         u16 start_pq;
 400         u8 start_vport;
 401         u8 pure_lb_pq;
 402         u8 offload_pq;
 403         u8 pure_ack_pq;
 404         u8 ooo_pq;
 405         u8 vf_queues_offset;
 406         u16 num_pqs;
 407         u16 num_vf_pqs;
 408         u8 num_vports;
 409         u8 max_phys_tcs_per_port;
 410         bool pf_rl_en;
 411         bool pf_wfq_en;
 412         bool vport_rl_en;
 413         bool vport_wfq_en;
 414         u8 pf_wfq;
 415         u32 pf_rl;
 416         struct ecore_wfq_data *wfq_data;
 417 };
 418
 419 struct storm_stats {
 420         u32 address;
 421         u32 len;
 422 };
 423
 424 #define CONFIG_ECORE_BINARY_FW
 425 #define CONFIG_ECORE_ZIPPED_FW
 426
 427 struct ecore_fw_data {
 428 #ifdef CONFIG_ECORE_BINARY_FW
 429         struct fw_ver_info *fw_ver_info;
 430 #endif
 431         const u8 *modes_tree_buf;
 432         union init_op *init_ops;
 433         const u32 *arr_data;
 434         u32 init_ops_size;
 435 };
 436
 437 struct ecore_hwfn {
 438         struct ecore_dev *p_dev;
 439         u8 my_id;               /* ID inside the PF */
 440 #define IS_LEAD_HWFN(edev)              (!((edev)->my_id))
 441         u8 rel_pf_id;           /* Relative to engine */
 442         u8 abs_pf_id;
 443 #define ECORE_PATH_ID(_p_hwfn) \
 444                 (ECORE_IS_K2((_p_hwfn)->p_dev) ? 0 : ((_p_hwfn)->abs_pf_id & 1))
 445         u8 port_id;
 446         bool b_active;
 447
 448         u32 dp_module;
 449         u8 dp_level;
 450         char name[NAME_SIZE];
 451         void *dp_ctx;
 452
 453         bool first_on_engine;
 454         bool hw_init_done;
 455
 456         u8 num_funcs_on_engine;
 457
 458         /* BAR access */
 459         void OSAL_IOMEM *regview;
 460         void OSAL_IOMEM *doorbells;
 461         u64 db_phys_addr;
 462         unsigned long db_size;
 463
 464         /* PTT pool */
 465         struct ecore_ptt_pool *p_ptt_pool;
 466
 467         /* HW info */
 468         struct ecore_hw_info hw_info;
 469
 470         /* rt_array (for init-tool) */
 471         struct ecore_rt_data rt_data;
 472
 473         /* SPQ */
 474         struct ecore_spq *p_spq;
 475
 476         /* EQ */
 477         struct ecore_eq *p_eq;
 478
 479         /* Consolidate Q */
 480         struct ecore_consq *p_consq;
 481
 482         /* Slow-Path definitions */
 483         osal_dpc_t sp_dpc;
 484         bool b_sp_dpc_enabled;
 485
 486         struct ecore_ptt *p_main_ptt;
 487         struct ecore_ptt *p_dpc_ptt;
 488
 489         struct ecore_sb_sp_info *p_sp_sb;
 490         struct ecore_sb_attn_info *p_sb_attn;
 491
 492         /* Protocol related */
 493         struct ecore_ooo_info *p_ooo_info;
 494         struct ecore_pf_params pf_params;
 495
 496         /* Array of sb_info of all status blocks */
 497         struct ecore_sb_info *sbs_info[MAX_SB_PER_PF_MIMD];
 498         u16 num_sbs;
 499
 500         struct ecore_cxt_mngr *p_cxt_mngr;
 501
 502         /* Flag indicating whether interrupts are enabled or not */
 503         bool b_int_enabled;
 504         bool b_int_requested;
 505
 506         /* True if the driver requests for the link */
 507         bool b_drv_link_init;
 508
 509         struct ecore_vf_iov *vf_iov_info;
 510         struct ecore_pf_iov *pf_iov_info;
 511         struct ecore_mcp_info *mcp_info;
 512         struct ecore_dcbx_info *p_dcbx_info;
 513
 514         struct ecore_hw_cid_data *p_tx_cids;
 515         struct ecore_hw_cid_data *p_rx_cids;
 516
 517         struct ecore_dmae_info dmae_info;
 518
 519         /* QM init */
 520         struct ecore_qm_info qm_info;
 521
 522         /* Buffer for unzipping firmware data */
 523 #ifdef CONFIG_ECORE_ZIPPED_FW
 524         void *unzip_buf;
 525 #endif
 526
 527         struct dbg_tools_data dbg_info;
 528
 529         struct z_stream_s *stream;
 530
 531         /* PWM region specific data */
 532         u32 dpi_size;
 533         u32 dpi_count;
 534         u32 dpi_start_offset;   /* this is used to
 535                                  * calculate th
 536                                  * doorbell address
 537                                  */
 538 };
 539
 540 #ifndef __EXTRACT__LINUX__
 541 enum ecore_mf_mode {
 542         ECORE_MF_DEFAULT,
 543         ECORE_MF_OVLAN,
 544         ECORE_MF_NPAR,
 545 };
 546 #endif
 547
 548 struct ecore_dev {
 549         u32 dp_module;
 550         u8 dp_level;
 551         char name[NAME_SIZE];
 552         void *dp_ctx;
 553
 554         u8 type;
 555 #define ECORE_DEV_TYPE_BB       (0 << 0)
 556 #define ECORE_DEV_TYPE_AH       (1 << 0)
 557 /* Translate type/revision combo into the proper conditions */
 558 #define ECORE_IS_BB(dev)        ((dev)->type == ECORE_DEV_TYPE_BB)
 559 #define ECORE_IS_BB_A0(dev)     (ECORE_IS_BB(dev) && \
 560                                  CHIP_REV_IS_A0(dev))
 561 #define ECORE_IS_BB_B0(dev)     (ECORE_IS_BB(dev) && \
 562                                  CHIP_REV_IS_B0(dev))
 563 #define ECORE_IS_AH(dev)        ((dev)->type == ECORE_DEV_TYPE_AH)
 564 #define ECORE_IS_K2(dev)        ECORE_IS_AH(dev)
 565 #define ECORE_GET_TYPE(dev)     (ECORE_IS_BB_A0(dev) ? CHIP_BB_A0 : \
 566                                  ECORE_IS_BB_B0(dev) ? CHIP_BB_B0 : CHIP_K2)
 567
 568         u16 vendor_id;
 569         u16 device_id;
 570
 571         u16 chip_num;
 572 #define CHIP_NUM_MASK                   0xffff
 573 #define CHIP_NUM_SHIFT                  16
 574
 575         u16 chip_rev;
 576 #define CHIP_REV_MASK                   0xf
 577 #define CHIP_REV_SHIFT                  12
 578 #ifndef ASIC_ONLY
 579 #define CHIP_REV_IS_TEDIBEAR(_p_dev) ((_p_dev)->chip_rev == 0x5)
 580 #define CHIP_REV_IS_EMUL_A0(_p_dev) ((_p_dev)->chip_rev == 0xe)
 581 #define CHIP_REV_IS_EMUL_B0(_p_dev) ((_p_dev)->chip_rev == 0xc)
 582 #define CHIP_REV_IS_EMUL(_p_dev) (CHIP_REV_IS_EMUL_A0(_p_dev) || \
 583                                           CHIP_REV_IS_EMUL_B0(_p_dev))
 584 #define CHIP_REV_IS_FPGA_A0(_p_dev) ((_p_dev)->chip_rev == 0xf)
 585 #define CHIP_REV_IS_FPGA_B0(_p_dev) ((_p_dev)->chip_rev == 0xd)
 586 #define CHIP_REV_IS_FPGA(_p_dev) (CHIP_REV_IS_FPGA_A0(_p_dev) || \
 587                                           CHIP_REV_IS_FPGA_B0(_p_dev))
 588 #define CHIP_REV_IS_SLOW(_p_dev) \
 589                 (CHIP_REV_IS_EMUL(_p_dev) || CHIP_REV_IS_FPGA(_p_dev))
 590 #define CHIP_REV_IS_A0(_p_dev) \
 591                 (CHIP_REV_IS_EMUL_A0(_p_dev) || \
 592                  CHIP_REV_IS_FPGA_A0(_p_dev) || \
 593                  !(_p_dev)->chip_rev)
 594 #define CHIP_REV_IS_B0(_p_dev) \
 595                 (CHIP_REV_IS_EMUL_B0(_p_dev) || \
 596                  CHIP_REV_IS_FPGA_B0(_p_dev) || \
 597                  (_p_dev)->chip_rev == 1)
 598 #define CHIP_REV_IS_ASIC(_p_dev) (!CHIP_REV_IS_SLOW(_p_dev))
 599 #else
 600 #define CHIP_REV_IS_A0(_p_dev)  (!(_p_dev)->chip_rev)
 601 #define CHIP_REV_IS_B0(_p_dev)  ((_p_dev)->chip_rev == 1)
 602 #endif
 603
 604         u16 chip_metal;
 605 #define CHIP_METAL_MASK                 0xff
 606 #define CHIP_METAL_SHIFT                4
 607
 608         u16 chip_bond_id;
 609 #define CHIP_BOND_ID_MASK               0xf
 610 #define CHIP_BOND_ID_SHIFT              0
 611
 612         u8 num_engines;
 613         u8 num_ports_in_engines;
 614         u8 num_funcs_in_port;
 615
 616         u8 path_id;
 617         enum ecore_mf_mode mf_mode;
 618 #define IS_MF_DEFAULT(_p_hwfn) \
 619                 (((_p_hwfn)->p_dev)->mf_mode == ECORE_MF_DEFAULT)
 620 #define IS_MF_SI(_p_hwfn)       (((_p_hwfn)->p_dev)->mf_mode == ECORE_MF_NPAR)
 621 #define IS_MF_SD(_p_hwfn)       (((_p_hwfn)->p_dev)->mf_mode == ECORE_MF_OVLAN)
 622
 623         int pcie_width;
 624         int pcie_speed;
 625         u8 ver_str[VER_SIZE];
 626         /* Add MF related configuration */
 627         u8 mcp_rev;
 628         u8 boot_mode;
 629
 630         u8 wol;
 631
 632         u32 int_mode;
 633         enum ecore_coalescing_mode int_coalescing_mode;
 634         u8 rx_coalesce_usecs;
 635         u8 tx_coalesce_usecs;
 636
 637         /* Start Bar offset of first hwfn */
 638         void OSAL_IOMEM *regview;
 639         void OSAL_IOMEM *doorbells;
 640         u64 db_phys_addr;
 641         unsigned long db_size;
 642
 643         /* PCI */
 644         u8 cache_shift;
 645
 646         /* Init */
 647         const struct iro *iro_arr;
 648 #define IRO (p_hwfn->p_dev->iro_arr)
 649
 650         /* HW functions */
 651         u8 num_hwfns;
 652         struct ecore_hwfn hwfns[MAX_HWFNS_PER_DEVICE];
 653
 654         /* SRIOV */
 655         struct ecore_hw_sriov_info sriov_info;
 656         unsigned long tunn_mode;
 657 #define IS_ECORE_SRIOV(edev)            (!!((edev)->sriov_info.total_vfs))
 658         bool b_is_vf;
 659
 660         u32 drv_type;
 661
 662         struct ecore_eth_stats *reset_stats;
 663         struct ecore_fw_data *fw_data;
 664
 665         u32 mcp_nvm_resp;
 666
 667         /* Recovery */
 668         bool recov_in_prog;
 669
 670 #ifndef ASIC_ONLY
 671         bool b_is_emul_full;
 672 #endif
 673
 674         void *firmware;
 675
 676         u64 fw_len;
 677
 678 };
 679
 680 #define NUM_OF_VFS(dev)         (ECORE_IS_BB(dev) ? MAX_NUM_VFS_BB \
 681                                                   : MAX_NUM_VFS_K2)
 682 #define NUM_OF_L2_QUEUES(dev)   (ECORE_IS_BB(dev) ? MAX_NUM_L2_QUEUES_BB \
 683                                                   : MAX_NUM_L2_QUEUES_K2)
 684 #define NUM_OF_PORTS(dev)       (ECORE_IS_BB(dev) ? MAX_NUM_PORTS_BB \
 685                                                   : MAX_NUM_PORTS_K2)
 686 #define NUM_OF_SBS(dev)         (ECORE_IS_BB(dev) ? MAX_SB_PER_PATH_BB \
 687                                                   : MAX_SB_PER_PATH_K2)
 688 #define NUM_OF_ENG_PFS(dev)     (ECORE_IS_BB(dev) ? MAX_NUM_PFS_BB \
 689                                                   : MAX_NUM_PFS_K2)
 690
 691 #define ENABLE_EAGLE_ENG1_WORKAROUND(p_hwfn) ( \
 692         (ECORE_IS_BB_A0(p_hwfn->p_dev)) && \
 693         (ECORE_PATH_ID(p_hwfn) == 1) && \
 694         ((p_hwfn->hw_info.port_mode == ECORE_PORT_MODE_DE_2X40G) || \
 695          (p_hwfn->hw_info.port_mode == ECORE_PORT_MODE_DE_2X50G) || \
 696          (p_hwfn->hw_info.port_mode == ECORE_PORT_MODE_DE_2X25G)))
 697
 698 /**
 699  * @brief ecore_concrete_to_sw_fid - get the sw function id from
 700  *        the concrete value.
 701  *
 702  * @param concrete_fid
 703  *
 704  * @return OSAL_INLINE u8
 705  */
 706 static OSAL_INLINE u8 ecore_concrete_to_sw_fid(struct ecore_dev *p_dev,
 707                                                u32 concrete_fid)
 708 {
 709         u8 vfid = GET_FIELD(concrete_fid, PXP_CONCRETE_FID_VFID);
 710         u8 pfid = GET_FIELD(concrete_fid, PXP_CONCRETE_FID_PFID);
 711         u8 vf_valid = GET_FIELD(concrete_fid, PXP_CONCRETE_FID_VFVALID);
 712         u8 sw_fid;
 713
 714         if (vf_valid)
 715                 sw_fid = vfid + MAX_NUM_PFS;
 716         else
 717                 sw_fid = pfid;
 718
 719         return sw_fid;
 720 }
 721
 722 #define PURE_LB_TC 8
 723 #define OOO_LB_TC 9
 724
 725 static OSAL_INLINE u16 ecore_sriov_get_next_vf(struct ecore_hwfn *p_hwfn,
 726                                                u16 rel_vf_id)
 727 {
 728         u16 i;
 729
 730         for (i = rel_vf_id; i < p_hwfn->p_dev->sriov_info.total_vfs; i++)
 731                 if (ECORE_IS_VF_ACTIVE(p_hwfn->p_dev, i))
 732                         return i;
 733
 734         return p_hwfn->p_dev->sriov_info.total_vfs;
 735 }
 736
 737 int ecore_configure_vport_wfq(struct ecore_dev *p_dev, u16 vp_id, u32 rate);
 738 void ecore_configure_vp_wfq_on_link_change(struct ecore_dev *p_dev,
 739                                            u32 min_pf_rate);
 740
 741 int ecore_configure_pf_max_bandwidth(struct ecore_dev *p_dev, u8 max_bw);
 742 int ecore_configure_pf_min_bandwidth(struct ecore_dev *p_dev, u8 min_bw);
 743 void ecore_clean_wfq_db(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt);
 744 int ecore_device_num_engines(struct ecore_dev *p_dev);
 745 int ecore_device_num_ports(struct ecore_dev *p_dev);
 746
 747 #define ecore_for_each_vf(_p_hwfn, _i)                          \
 748         for (_i = ecore_sriov_get_next_vf(_p_hwfn, 0);          \
 749              _i < _p_hwfn->p_dev->sriov_info.total_vfs;         \
 750              _i = ecore_sriov_get_next_vf(_p_hwfn, _i + 1))
 751
 752 #define ECORE_LEADING_HWFN(dev) (&dev->hwfns[0])
 753
 754 #endif /* __ECORE_H */