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 /* @DPDK */
  13 #include <sys/stat.h>
  14 #include <fcntl.h>
  15 #include <unistd.h>
  16
  17 #define CONFIG_ECORE_BINARY_FW
  18 #undef CONFIG_ECORE_ZIPPED_FW
  19
  20 #ifdef CONFIG_ECORE_ZIPPED_FW
  21 #include <zlib.h>
  22 #endif
  23
  24 #include "ecore_hsi_common.h"
  25 #include "ecore_hsi_debug_tools.h"
  26 #include "ecore_hsi_init_func.h"
  27 #include "ecore_hsi_init_tool.h"
  28 #include "ecore_proto_if.h"
  29 #include "mcp_public.h"
  30
  31 #define ECORE_MAJOR_VERSION             8
  32 #define ECORE_MINOR_VERSION             18
  33 #define ECORE_REVISION_VERSION          7
  34 #define ECORE_ENGINEERING_VERSION       1
  35
  36 #define ECORE_VERSION                                                   \
  37         ((ECORE_MAJOR_VERSION << 24) | (ECORE_MINOR_VERSION << 16) |    \
  38          (ECORE_REVISION_VERSION << 8) | ECORE_ENGINEERING_VERSION)
  39
  40 #define STORM_FW_VERSION                                                \
  41         ((FW_MAJOR_VERSION << 24) | (FW_MINOR_VERSION << 16) |  \
  42          (FW_REVISION_VERSION << 8) | FW_ENGINEERING_VERSION)
  43
  44 #define MAX_HWFNS_PER_DEVICE    2
  45 #define NAME_SIZE 128 /* @DPDK */
  46 #define ECORE_WFQ_UNIT  100
  47 #include "../qede_logs.h" /* @DPDK */
  48
  49 #define ISCSI_BDQ_ID(_port_id) (_port_id)
  50 #define FCOE_BDQ_ID(_port_id) (_port_id + 2)
  51 /* Constants */
  52 #define ECORE_WID_SIZE          (1024)
  53
  54 /* Configurable */
  55 #define ECORE_PF_DEMS_SIZE      (4)
  56
  57 /* cau states */
  58 enum ecore_coalescing_mode {
  59         ECORE_COAL_MODE_DISABLE,
  60         ECORE_COAL_MODE_ENABLE
  61 };
  62
  63 enum ecore_nvm_cmd {
  64         ECORE_PUT_FILE_BEGIN = DRV_MSG_CODE_NVM_PUT_FILE_BEGIN,
  65         ECORE_PUT_FILE_DATA = DRV_MSG_CODE_NVM_PUT_FILE_DATA,
  66         ECORE_NVM_READ_NVRAM = DRV_MSG_CODE_NVM_READ_NVRAM,
  67         ECORE_NVM_WRITE_NVRAM = DRV_MSG_CODE_NVM_WRITE_NVRAM,
  68         ECORE_NVM_DEL_FILE = DRV_MSG_CODE_NVM_DEL_FILE,
  69         ECORE_EXT_PHY_FW_UPGRADE = DRV_MSG_CODE_EXT_PHY_FW_UPGRADE,
  70         ECORE_NVM_SET_SECURE_MODE = DRV_MSG_CODE_SET_SECURE_MODE,
  71         ECORE_PHY_RAW_READ = DRV_MSG_CODE_PHY_RAW_READ,
  72         ECORE_PHY_RAW_WRITE = DRV_MSG_CODE_PHY_RAW_WRITE,
  73         ECORE_PHY_CORE_READ = DRV_MSG_CODE_PHY_CORE_READ,
  74         ECORE_PHY_CORE_WRITE = DRV_MSG_CODE_PHY_CORE_WRITE,
  75         ECORE_GET_MCP_NVM_RESP = 0xFFFFFF00
  76 };
  77
  78 #ifndef LINUX_REMOVE
  79 #if !defined(CONFIG_ECORE_L2)
  80 #define CONFIG_ECORE_L2
  81 #define CONFIG_ECORE_SRIOV
  82 #endif
  83 #endif
  84
  85 /* helpers */
  86 #ifndef __EXTRACT__LINUX__
  87 #define MASK_FIELD(_name, _value)                                       \
  88                 ((_value) &= (_name##_MASK))
  89
  90 #define FIELD_VALUE(_name, _value)                                      \
  91                 ((_value & _name##_MASK) << _name##_SHIFT)
  92
  93 #define SET_FIELD(value, name, flag)                                    \
  94 do {                                                                    \
  95         (value) &= ~(name##_MASK << name##_SHIFT);                      \
  96         (value) |= ((((u64)flag) & (u64)name##_MASK) << (name##_SHIFT));\
  97 } while (0)
  98
  99 #define GET_FIELD(value, name)                                          \
 100         (((value) >> (name##_SHIFT)) & name##_MASK)
 101
 102 #define GET_MFW_FIELD(name, field)                              \
 103         (((name) & (field ## _MASK)) >> (field ## _OFFSET))
 104
 105 #define SET_MFW_FIELD(name, field, value)                               \
 106 do {                                                                    \
 107         (name) &= ~((field ## _MASK));          \
 108         (name) |= (((value) << (field ## _OFFSET)) & (field ## _MASK)); \
 109 } while (0)
 110 #endif
 111
 112 static OSAL_INLINE u32 DB_ADDR(u32 cid, u32 DEMS)
 113 {
 114         u32 db_addr = FIELD_VALUE(DB_LEGACY_ADDR_DEMS, DEMS) |
 115                       (cid * ECORE_PF_DEMS_SIZE);
 116
 117         return db_addr;
 118 }
 119
 120 static OSAL_INLINE u32 DB_ADDR_VF(u32 cid, u32 DEMS)
 121 {
 122         u32 db_addr = FIELD_VALUE(DB_LEGACY_ADDR_DEMS, DEMS) |
 123                       FIELD_VALUE(DB_LEGACY_ADDR_ICID, cid);
 124
 125         return db_addr;
 126 }
 127
 128 #define ALIGNED_TYPE_SIZE(type_name, p_hwfn)                              \
 129         ((sizeof(type_name) + (u32)(1 << (p_hwfn->p_dev->cache_shift)) - 1) & \
 130          ~((1 << (p_hwfn->p_dev->cache_shift)) - 1))
 131
 132 #ifndef LINUX_REMOVE
 133 #ifndef U64_HI
 134 #define U64_HI(val) ((u32)(((u64)(val))  >> 32))
 135 #endif
 136
 137 #ifndef U64_LO
 138 #define U64_LO(val) ((u32)(((u64)(val)) & 0xffffffff))
 139 #endif
 140 #endif
 141
 142 #ifndef __EXTRACT__LINUX__
 143 enum DP_LEVEL {
 144         ECORE_LEVEL_VERBOSE     = 0x0,
 145         ECORE_LEVEL_INFO        = 0x1,
 146         ECORE_LEVEL_NOTICE      = 0x2,
 147         ECORE_LEVEL_ERR         = 0x3,
 148 };
 149
 150 #define ECORE_LOG_LEVEL_SHIFT   (30)
 151 #define ECORE_LOG_VERBOSE_MASK  (0x3fffffff)
 152 #define ECORE_LOG_INFO_MASK     (0x40000000)
 153 #define ECORE_LOG_NOTICE_MASK   (0x80000000)
 154
 155 enum DP_MODULE {
 156 #ifndef LINUX_REMOVE
 157         ECORE_MSG_DRV           = 0x0001,
 158         ECORE_MSG_PROBE         = 0x0002,
 159         ECORE_MSG_LINK          = 0x0004,
 160         ECORE_MSG_TIMER         = 0x0008,
 161         ECORE_MSG_IFDOWN        = 0x0010,
 162         ECORE_MSG_IFUP          = 0x0020,
 163         ECORE_MSG_RX_ERR        = 0x0040,
 164         ECORE_MSG_TX_ERR        = 0x0080,
 165         ECORE_MSG_TX_QUEUED     = 0x0100,
 166         ECORE_MSG_INTR          = 0x0200,
 167         ECORE_MSG_TX_DONE       = 0x0400,
 168         ECORE_MSG_RX_STATUS     = 0x0800,
 169         ECORE_MSG_PKTDATA       = 0x1000,
 170         ECORE_MSG_HW            = 0x2000,
 171         ECORE_MSG_WOL           = 0x4000,
 172 #endif
 173         ECORE_MSG_SPQ           = 0x10000,
 174         ECORE_MSG_STATS         = 0x20000,
 175         ECORE_MSG_DCB           = 0x40000,
 176         ECORE_MSG_IOV           = 0x80000,
 177         ECORE_MSG_SP            = 0x100000,
 178         ECORE_MSG_STORAGE       = 0x200000,
 179         ECORE_MSG_OOO           = 0x200000,
 180         ECORE_MSG_CXT           = 0x800000,
 181         ECORE_MSG_LL2           = 0x1000000,
 182         ECORE_MSG_ILT           = 0x2000000,
 183         ECORE_MSG_RDMA          = 0x4000000,
 184         ECORE_MSG_DEBUG         = 0x8000000,
 185         /* to be added...up to 0x8000000 */
 186 };
 187 #endif
 188
 189 #define for_each_hwfn(p_dev, i) for (i = 0; i < p_dev->num_hwfns; i++)
 190
 191 #define D_TRINE(val, cond1, cond2, true1, true2, def) \
 192         (val == (cond1) ? true1 : \
 193          (val == (cond2) ? true2 : def))
 194
 195 /* forward */
 196 struct ecore_ptt_pool;
 197 struct ecore_spq;
 198 struct ecore_sb_info;
 199 struct ecore_sb_attn_info;
 200 struct ecore_cxt_mngr;
 201 struct ecore_dma_mem;
 202 struct ecore_sb_sp_info;
 203 struct ecore_ll2_info;
 204 struct ecore_l2_info;
 205 struct ecore_igu_info;
 206 struct ecore_mcp_info;
 207 struct ecore_dcbx_info;
 208
 209 struct ecore_rt_data {
 210         u32     *init_val;
 211         bool    *b_valid;
 212 };
 213
 214 enum ecore_tunn_mode {
 215         ECORE_MODE_L2GENEVE_TUNN,
 216         ECORE_MODE_IPGENEVE_TUNN,
 217         ECORE_MODE_L2GRE_TUNN,
 218         ECORE_MODE_IPGRE_TUNN,
 219         ECORE_MODE_VXLAN_TUNN,
 220 };
 221
 222 enum ecore_tunn_clss {
 223         ECORE_TUNN_CLSS_MAC_VLAN,
 224         ECORE_TUNN_CLSS_MAC_VNI,
 225         ECORE_TUNN_CLSS_INNER_MAC_VLAN,
 226         ECORE_TUNN_CLSS_INNER_MAC_VNI,
 227         ECORE_TUNN_CLSS_MAC_VLAN_DUAL_STAGE,
 228         MAX_ECORE_TUNN_CLSS,
 229 };
 230
 231 struct ecore_tunn_update_type {
 232         bool b_update_mode;
 233         bool b_mode_enabled;
 234         enum ecore_tunn_clss tun_cls;
 235 };
 236
 237 struct ecore_tunn_update_udp_port {
 238         bool b_update_port;
 239         u16 port;
 240 };
 241
 242 struct ecore_tunnel_info {
 243         struct ecore_tunn_update_type vxlan;
 244         struct ecore_tunn_update_type l2_geneve;
 245         struct ecore_tunn_update_type ip_geneve;
 246         struct ecore_tunn_update_type l2_gre;
 247         struct ecore_tunn_update_type ip_gre;
 248
 249         struct ecore_tunn_update_udp_port vxlan_port;
 250         struct ecore_tunn_update_udp_port geneve_port;
 251
 252         bool b_update_rx_cls;
 253         bool b_update_tx_cls;
 254 };
 255
 256 /* The PCI personality is not quite synonymous to protocol ID:
 257  * 1. All personalities need CORE connections
 258  * 2. The Ethernet personality may support also the RoCE/iWARP protocol
 259  */
 260 enum ecore_pci_personality {
 261         ECORE_PCI_ETH,
 262         ECORE_PCI_FCOE,
 263         ECORE_PCI_ISCSI,
 264         ECORE_PCI_ETH_ROCE,
 265         ECORE_PCI_ETH_IWARP,
 266         ECORE_PCI_ETH_RDMA,
 267         ECORE_PCI_DEFAULT /* default in shmem */
 268 };
 269
 270 /* All VFs are symmetric, all counters are PF + all VFs */
 271 struct ecore_qm_iids {
 272         u32 cids;
 273         u32 vf_cids;
 274         u32 tids;
 275 };
 276
 277 #define MAX_PF_PER_PORT 8
 278
 279 /* HW / FW resources, output of features supported below, most information
 280  * is received from MFW.
 281  */
 282 enum ecore_resources {
 283         ECORE_L2_QUEUE,
 284         ECORE_VPORT,
 285         ECORE_RSS_ENG,
 286         ECORE_PQ,
 287         ECORE_RL,
 288         ECORE_MAC,
 289         ECORE_VLAN,
 290         ECORE_RDMA_CNQ_RAM,
 291         ECORE_ILT,
 292         ECORE_LL2_QUEUE,
 293         ECORE_CMDQS_CQS,
 294         ECORE_RDMA_STATS_QUEUE,
 295         ECORE_BDQ,
 296
 297         /* This is needed only internally for matching against the IGU.
 298          * In case of legacy MFW, would be set to `0'.
 299          */
 300         ECORE_SB,
 301
 302         ECORE_MAX_RESC,
 303 };
 304
 305 /* Features that require resources, given as input to the resource management
 306  * algorithm, the output are the resources above
 307  */
 308 enum ecore_feature {
 309         ECORE_PF_L2_QUE,
 310         ECORE_PF_TC,
 311         ECORE_VF,
 312         ECORE_EXTRA_VF_QUE,
 313         ECORE_VMQ,
 314         ECORE_RDMA_CNQ,
 315         ECORE_ISCSI_CQ,
 316         ECORE_FCOE_CQ,
 317         ECORE_VF_L2_QUE,
 318         ECORE_MAX_FEATURES,
 319 };
 320
 321 enum ecore_port_mode {
 322         ECORE_PORT_MODE_DE_2X40G,
 323         ECORE_PORT_MODE_DE_2X50G,
 324         ECORE_PORT_MODE_DE_1X100G,
 325         ECORE_PORT_MODE_DE_4X10G_F,
 326         ECORE_PORT_MODE_DE_4X10G_E,
 327         ECORE_PORT_MODE_DE_4X20G,
 328         ECORE_PORT_MODE_DE_1X40G,
 329         ECORE_PORT_MODE_DE_2X25G,
 330         ECORE_PORT_MODE_DE_1X25G,
 331         ECORE_PORT_MODE_DE_4X25G,
 332         ECORE_PORT_MODE_DE_2X10G,
 333 };
 334
 335 enum ecore_dev_cap {
 336         ECORE_DEV_CAP_ETH,
 337         ECORE_DEV_CAP_FCOE,
 338         ECORE_DEV_CAP_ISCSI,
 339         ECORE_DEV_CAP_ROCE,
 340         ECORE_DEV_CAP_IWARP
 341 };
 342
 343 #ifndef __EXTRACT__LINUX__
 344 enum ecore_hw_err_type {
 345         ECORE_HW_ERR_FAN_FAIL,
 346         ECORE_HW_ERR_MFW_RESP_FAIL,
 347         ECORE_HW_ERR_HW_ATTN,
 348         ECORE_HW_ERR_DMAE_FAIL,
 349         ECORE_HW_ERR_RAMROD_FAIL,
 350         ECORE_HW_ERR_FW_ASSERT,
 351 };
 352 #endif
 353
 354 enum ecore_db_rec_exec {
 355         DB_REC_DRY_RUN,
 356         DB_REC_REAL_DEAL,
 357         DB_REC_ONCE,
 358 };
 359
 360 struct ecore_hw_info {
 361         /* PCI personality */
 362         enum ecore_pci_personality personality;
 363 #define ECORE_IS_RDMA_PERSONALITY(dev)                      \
 364         ((dev)->hw_info.personality == ECORE_PCI_ETH_ROCE ||  \
 365          (dev)->hw_info.personality == ECORE_PCI_ETH_IWARP || \
 366          (dev)->hw_info.personality == ECORE_PCI_ETH_RDMA)
 367 #define ECORE_IS_ROCE_PERSONALITY(dev)                     \
 368         ((dev)->hw_info.personality == ECORE_PCI_ETH_ROCE || \
 369          (dev)->hw_info.personality == ECORE_PCI_ETH_RDMA)
 370 #define ECORE_IS_IWARP_PERSONALITY(dev)                     \
 371         ((dev)->hw_info.personality == ECORE_PCI_ETH_IWARP || \
 372          (dev)->hw_info.personality == ECORE_PCI_ETH_RDMA)
 373 #define ECORE_IS_L2_PERSONALITY(dev)                  \
 374         ((dev)->hw_info.personality == ECORE_PCI_ETH || \
 375          ECORE_IS_RDMA_PERSONALITY(dev))
 376
 377         /* Resource Allocation scheme results */
 378         u32 resc_start[ECORE_MAX_RESC];
 379         u32 resc_num[ECORE_MAX_RESC];
 380         u32 feat_num[ECORE_MAX_FEATURES];
 381
 382         #define RESC_START(_p_hwfn, resc) ((_p_hwfn)->hw_info.resc_start[resc])
 383         #define RESC_NUM(_p_hwfn, resc) ((_p_hwfn)->hw_info.resc_num[resc])
 384         #define RESC_END(_p_hwfn, resc) (RESC_START(_p_hwfn, resc) + \
 385                                          RESC_NUM(_p_hwfn, resc))
 386         #define FEAT_NUM(_p_hwfn, resc) ((_p_hwfn)->hw_info.feat_num[resc])
 387
 388         /* Amount of traffic classes HW supports */
 389         u8 num_hw_tc;
 390
 391 /* Amount of TCs which should be active according to DCBx or upper layer driver
 392  * configuration
 393  */
 394
 395         u8 num_active_tc;
 396
 397         /* The traffic class used by PF for it's offloaded protocol */
 398         u8 offload_tc;
 399
 400         u32 concrete_fid;
 401         u16 opaque_fid;
 402         u16 ovlan;
 403         u32 part_num[4];
 404
 405         unsigned char hw_mac_addr[ETH_ALEN];
 406         u64 node_wwn; /* For FCoE only */
 407         u64 port_wwn; /* For FCoE only */
 408
 409         u16 num_iscsi_conns;
 410         u16 num_fcoe_conns;
 411
 412         struct ecore_igu_info *p_igu_info;
 413         /* Sriov */
 414         u8 max_chains_per_vf;
 415
 416         u32 port_mode;
 417         u32     hw_mode;
 418         unsigned long device_capabilities;
 419
 420         /* Default DCBX mode */
 421         u8 dcbx_mode;
 422
 423         u16 mtu;
 424 };
 425
 426 /* maximun size of read/write commands (HW limit) */
 427 #define DMAE_MAX_RW_SIZE        0x2000
 428
 429 struct ecore_dmae_info {
 430         /* Mutex for synchronizing access to functions */
 431         osal_mutex_t    mutex;
 432
 433         u8 channel;
 434
 435         dma_addr_t completion_word_phys_addr;
 436
 437         /* The memory location where the DMAE writes the completion
 438          * value when an operation is finished on this context.
 439          */
 440         u32 *p_completion_word;
 441
 442         dma_addr_t intermediate_buffer_phys_addr;
 443
 444         /* An intermediate buffer for DMAE operations that use virtual
 445          * addresses - data is DMA'd to/from this buffer and then
 446          * memcpy'd to/from the virtual address
 447          */
 448         u32 *p_intermediate_buffer;
 449
 450         dma_addr_t dmae_cmd_phys_addr;
 451         struct dmae_cmd *p_dmae_cmd;
 452 };
 453
 454 struct ecore_wfq_data {
 455         u32 default_min_speed; /* When wfq feature is not configured */
 456         u32 min_speed; /* when feature is configured for any 1 vport */
 457         bool configured;
 458 };
 459
 460 struct ecore_qm_info {
 461         struct init_qm_pq_params    *qm_pq_params;
 462         struct init_qm_vport_params *qm_vport_params;
 463         struct init_qm_port_params  *qm_port_params;
 464         u16                     start_pq;
 465         u8                      start_vport;
 466         u16                     pure_lb_pq;
 467         u16                     offload_pq;
 468         u16                     pure_ack_pq;
 469         u16                     ooo_pq;
 470         u16                     first_vf_pq;
 471         u16                     first_mcos_pq;
 472         u16                     first_rl_pq;
 473         u16                     num_pqs;
 474         u16                     num_vf_pqs;
 475         u8                      num_vports;
 476         u8                      max_phys_tcs_per_port;
 477         u8                      ooo_tc;
 478         bool                    pf_rl_en;
 479         bool                    pf_wfq_en;
 480         bool                    vport_rl_en;
 481         bool                    vport_wfq_en;
 482         u8                      pf_wfq;
 483         u32                     pf_rl;
 484         struct ecore_wfq_data   *wfq_data;
 485         u8                      num_pf_rls;
 486 };
 487
 488 struct ecore_db_recovery_info {
 489         osal_list_t list;
 490         osal_spinlock_t lock;
 491         u32 db_recovery_counter;
 492 };
 493
 494 struct storm_stats {
 495         u32 address;
 496         u32 len;
 497 };
 498
 499 struct ecore_fw_data {
 500 #ifdef CONFIG_ECORE_BINARY_FW
 501         struct fw_ver_info *fw_ver_info;
 502 #endif
 503         const u8 *modes_tree_buf;
 504         union init_op *init_ops;
 505         const u32 *arr_data;
 506         u32 init_ops_size;
 507 };
 508
 509 struct ecore_hwfn {
 510         struct ecore_dev                *p_dev;
 511         u8                              my_id;          /* ID inside the PF */
 512 #define IS_LEAD_HWFN(edev)              (!((edev)->my_id))
 513         u8                              rel_pf_id;      /* Relative to engine*/
 514         u8                              abs_pf_id;
 515         #define ECORE_PATH_ID(_p_hwfn) \
 516                 (ECORE_IS_K2((_p_hwfn)->p_dev) ? 0 : ((_p_hwfn)->abs_pf_id & 1))
 517         u8                              port_id;
 518         bool                            b_active;
 519
 520         u32                             dp_module;
 521         u8                              dp_level;
 522         char                            name[NAME_SIZE];
 523         void                            *dp_ctx;
 524
 525         bool                            first_on_engine;
 526         bool                            hw_init_done;
 527
 528         u8                              num_funcs_on_engine;
 529         u8                              enabled_func_idx;
 530
 531         /* BAR access */
 532         void OSAL_IOMEM                 *regview;
 533         void OSAL_IOMEM                 *doorbells;
 534         u64                             db_phys_addr;
 535         unsigned long                   db_size;
 536
 537         /* PTT pool */
 538         struct ecore_ptt_pool           *p_ptt_pool;
 539
 540         /* HW info */
 541         struct ecore_hw_info            hw_info;
 542
 543         /* rt_array (for init-tool) */
 544         struct ecore_rt_data            rt_data;
 545
 546         /* SPQ */
 547         struct ecore_spq                *p_spq;
 548
 549         /* EQ */
 550         struct ecore_eq                 *p_eq;
 551
 552         /* Consolidate Q*/
 553         struct ecore_consq              *p_consq;
 554
 555         /* Slow-Path definitions */
 556         osal_dpc_t                      sp_dpc;
 557         bool                            b_sp_dpc_enabled;
 558
 559         struct ecore_ptt                *p_main_ptt;
 560         struct ecore_ptt                *p_dpc_ptt;
 561
 562         struct ecore_sb_sp_info         *p_sp_sb;
 563         struct ecore_sb_attn_info       *p_sb_attn;
 564
 565         /* Protocol related */
 566         bool                            using_ll2;
 567         struct ecore_ll2_info           *p_ll2_info;
 568         struct ecore_ooo_info           *p_ooo_info;
 569         struct ecore_iscsi_info         *p_iscsi_info;
 570         struct ecore_fcoe_info          *p_fcoe_info;
 571         struct ecore_rdma_info          *p_rdma_info;
 572         struct ecore_pf_params          pf_params;
 573
 574         bool                            b_rdma_enabled_in_prs;
 575         u32                             rdma_prs_search_reg;
 576
 577         struct ecore_cxt_mngr           *p_cxt_mngr;
 578
 579         /* Flag indicating whether interrupts are enabled or not*/
 580         bool                            b_int_enabled;
 581         bool                            b_int_requested;
 582
 583         /* True if the driver requests for the link */
 584         bool                            b_drv_link_init;
 585
 586         struct ecore_vf_iov             *vf_iov_info;
 587         struct ecore_pf_iov             *pf_iov_info;
 588         struct ecore_mcp_info           *mcp_info;
 589         struct ecore_dcbx_info          *p_dcbx_info;
 590
 591         struct ecore_dmae_info          dmae_info;
 592
 593         /* QM init */
 594         struct ecore_qm_info            qm_info;
 595
 596 #ifdef CONFIG_ECORE_ZIPPED_FW
 597         /* Buffer for unzipping firmware data */
 598         void *unzip_buf;
 599 #endif
 600
 601         struct dbg_tools_data           dbg_info;
 602
 603         struct z_stream_s               *stream;
 604
 605         /* PWM region specific data */
 606         u32                             dpi_size;
 607         u32                             dpi_count;
 608         u32                             dpi_start_offset; /* this is used to
 609                                                            * calculate th
 610                                                            * doorbell address
 611                                                            */
 612
 613         /* If one of the following is set then EDPM shouldn't be used */
 614         u8                              dcbx_no_edpm;
 615         u8                              db_bar_no_edpm;
 616
 617         /* L2-related */
 618         struct ecore_l2_info            *p_l2_info;
 619
 620         /* Mechanism for recovering from doorbell drop */
 621         struct ecore_db_recovery_info   db_recovery_info;
 622
 623         /* @DPDK */
 624         struct ecore_ptt                *p_arfs_ptt;
 625 };
 626
 627 #ifndef __EXTRACT__LINUX__
 628 enum ecore_mf_mode {
 629         ECORE_MF_DEFAULT,
 630         ECORE_MF_OVLAN,
 631         ECORE_MF_NPAR,
 632 };
 633 #endif
 634
 635 /* @DPDK */
 636 struct ecore_dbg_feature {
 637         u8                              *dump_buf;
 638         u32                             buf_size;
 639         u32                             dumped_dwords;
 640 };
 641
 642 enum qed_dbg_features {
 643         DBG_FEATURE_BUS,
 644         DBG_FEATURE_GRC,
 645         DBG_FEATURE_IDLE_CHK,
 646         DBG_FEATURE_MCP_TRACE,
 647         DBG_FEATURE_REG_FIFO,
 648         DBG_FEATURE_PROTECTION_OVERRIDE,
 649         DBG_FEATURE_NUM
 650 };
 651
 652 enum ecore_dev_type {
 653         ECORE_DEV_TYPE_BB,
 654         ECORE_DEV_TYPE_AH,
 655 };
 656
 657 struct ecore_dev {
 658         u32                             dp_module;
 659         u8                              dp_level;
 660         char                            name[NAME_SIZE];
 661         void                            *dp_ctx;
 662
 663         enum ecore_dev_type             type;
 664 /* Translate type/revision combo into the proper conditions */
 665 #define ECORE_IS_BB(dev)        ((dev)->type == ECORE_DEV_TYPE_BB)
 666 #define ECORE_IS_BB_A0(dev)     (ECORE_IS_BB(dev) && CHIP_REV_IS_A0(dev))
 667 #ifndef ASIC_ONLY
 668 #define ECORE_IS_BB_B0(dev)     ((ECORE_IS_BB(dev) && CHIP_REV_IS_B0(dev)) || \
 669                                  (CHIP_REV_IS_TEDIBEAR(dev)))
 670 #else
 671 #define ECORE_IS_BB_B0(dev)     (ECORE_IS_BB(dev) && CHIP_REV_IS_B0(dev))
 672 #endif
 673 #define ECORE_IS_AH(dev)        ((dev)->type == ECORE_DEV_TYPE_AH)
 674 #define ECORE_IS_K2(dev)        ECORE_IS_AH(dev)
 675
 676         u16 vendor_id;
 677         u16 device_id;
 678 #define ECORE_DEV_ID_MASK       0xff00
 679 #define ECORE_DEV_ID_MASK_BB    0x1600
 680 #define ECORE_DEV_ID_MASK_AH    0x8000
 681
 682         u16                             chip_num;
 683         #define CHIP_NUM_MASK                   0xffff
 684         #define CHIP_NUM_SHIFT                  16
 685
 686         u16                             chip_rev;
 687         #define CHIP_REV_MASK                   0xf
 688         #define CHIP_REV_SHIFT                  12
 689 #ifndef ASIC_ONLY
 690         #define CHIP_REV_IS_TEDIBEAR(_p_dev) ((_p_dev)->chip_rev == 0x5)
 691         #define CHIP_REV_IS_EMUL_A0(_p_dev) ((_p_dev)->chip_rev == 0xe)
 692         #define CHIP_REV_IS_EMUL_B0(_p_dev) ((_p_dev)->chip_rev == 0xc)
 693         #define CHIP_REV_IS_EMUL(_p_dev) (CHIP_REV_IS_EMUL_A0(_p_dev) || \
 694                                           CHIP_REV_IS_EMUL_B0(_p_dev))
 695         #define CHIP_REV_IS_FPGA_A0(_p_dev) ((_p_dev)->chip_rev == 0xf)
 696         #define CHIP_REV_IS_FPGA_B0(_p_dev) ((_p_dev)->chip_rev == 0xd)
 697         #define CHIP_REV_IS_FPGA(_p_dev) (CHIP_REV_IS_FPGA_A0(_p_dev) || \
 698                                           CHIP_REV_IS_FPGA_B0(_p_dev))
 699         #define CHIP_REV_IS_SLOW(_p_dev) \
 700                 (CHIP_REV_IS_EMUL(_p_dev) || CHIP_REV_IS_FPGA(_p_dev))
 701         #define CHIP_REV_IS_A0(_p_dev) \
 702                 (CHIP_REV_IS_EMUL_A0(_p_dev) || \
 703                  CHIP_REV_IS_FPGA_A0(_p_dev) || \
 704                  !(_p_dev)->chip_rev)
 705         #define CHIP_REV_IS_B0(_p_dev) \
 706                 (CHIP_REV_IS_EMUL_B0(_p_dev) || \
 707                  CHIP_REV_IS_FPGA_B0(_p_dev) || \
 708                  (_p_dev)->chip_rev == 1)
 709         #define CHIP_REV_IS_ASIC(_p_dev) !CHIP_REV_IS_SLOW(_p_dev)
 710 #else
 711         #define CHIP_REV_IS_A0(_p_dev)  (!(_p_dev)->chip_rev)
 712         #define CHIP_REV_IS_B0(_p_dev)  ((_p_dev)->chip_rev == 1)
 713 #endif
 714
 715         u16                             chip_metal;
 716         #define CHIP_METAL_MASK                 0xff
 717         #define CHIP_METAL_SHIFT                4
 718
 719         u16                             chip_bond_id;
 720         #define CHIP_BOND_ID_MASK               0xf
 721         #define CHIP_BOND_ID_SHIFT              0
 722
 723         u8                              num_engines;
 724         u8                              num_ports_in_engines;
 725         u8                              num_funcs_in_port;
 726
 727         u8                              path_id;
 728         enum ecore_mf_mode              mf_mode;
 729         #define IS_MF_DEFAULT(_p_hwfn)  \
 730                         (((_p_hwfn)->p_dev)->mf_mode == ECORE_MF_DEFAULT)
 731         #define IS_MF_SI(_p_hwfn)       \
 732                         (((_p_hwfn)->p_dev)->mf_mode == ECORE_MF_NPAR)
 733         #define IS_MF_SD(_p_hwfn)       \
 734                         (((_p_hwfn)->p_dev)->mf_mode == ECORE_MF_OVLAN)
 735
 736         int                             pcie_width;
 737         int                             pcie_speed;
 738
 739         /* Add MF related configuration */
 740         u8                              mcp_rev;
 741         u8                              boot_mode;
 742
 743         u8                              wol;
 744
 745         u32                             int_mode;
 746         enum ecore_coalescing_mode      int_coalescing_mode;
 747         u16                             rx_coalesce_usecs;
 748         u16                             tx_coalesce_usecs;
 749
 750         /* Start Bar offset of first hwfn */
 751         void OSAL_IOMEM                 *regview;
 752         void OSAL_IOMEM                 *doorbells;
 753         u64                             db_phys_addr;
 754         unsigned long                   db_size;
 755
 756         /* PCI */
 757         u8                              cache_shift;
 758
 759         /* Init */
 760         const struct iro                *iro_arr;
 761         #define IRO (p_hwfn->p_dev->iro_arr)
 762
 763         /* HW functions */
 764         u8                              num_hwfns;
 765         struct ecore_hwfn               hwfns[MAX_HWFNS_PER_DEVICE];
 766
 767         /* SRIOV */
 768         struct ecore_hw_sriov_info      *p_iov_info;
 769 #define IS_ECORE_SRIOV(p_dev)           (!!(p_dev)->p_iov_info)
 770         struct ecore_tunnel_info        tunnel;
 771         bool                            b_is_vf;
 772         bool                            b_dont_override_vf_msix;
 773
 774         u32                             drv_type;
 775
 776         u32                             rdma_max_sge;
 777         u32                             rdma_max_inline;
 778         u32                             rdma_max_srq_sge;
 779
 780         struct ecore_eth_stats          *reset_stats;
 781         struct ecore_fw_data            *fw_data;
 782
 783         u32                             mcp_nvm_resp;
 784
 785         /* Recovery */
 786         bool                            recov_in_prog;
 787
 788 /* Indicates whether should prevent attentions from being reasserted */
 789
 790         bool                            attn_clr_en;
 791
 792         /* Indicates whether allowing the MFW to collect a crash dump */
 793         bool                            allow_mdump;
 794
 795         /* Indicates if the reg_fifo is checked after any register access */
 796         bool                            chk_reg_fifo;
 797
 798 #ifndef ASIC_ONLY
 799         bool                            b_is_emul_full;
 800 #endif
 801
 802 #ifdef CONFIG_ECORE_BINARY_FW /* @DPDK */
 803         void                            *firmware;
 804         u64                             fw_len;
 805 #endif
 806
 807         /* @DPDK */
 808         struct ecore_dbg_feature        dbg_features[DBG_FEATURE_NUM];
 809         u8                              engine_for_debug;
 810 };
 811
 812 #define NUM_OF_VFS(dev)         (ECORE_IS_BB(dev) ? MAX_NUM_VFS_BB \
 813                                                   : MAX_NUM_VFS_K2)
 814 #define NUM_OF_L2_QUEUES(dev)   (ECORE_IS_BB(dev) ? MAX_NUM_L2_QUEUES_BB \
 815                                                   : MAX_NUM_L2_QUEUES_K2)
 816 #define NUM_OF_PORTS(dev)       (ECORE_IS_BB(dev) ? MAX_NUM_PORTS_BB \
 817                                                   : MAX_NUM_PORTS_K2)
 818 #define NUM_OF_SBS(dev)         (ECORE_IS_BB(dev) ? MAX_SB_PER_PATH_BB \
 819                                                   : MAX_SB_PER_PATH_K2)
 820 #define NUM_OF_ENG_PFS(dev)     (ECORE_IS_BB(dev) ? MAX_NUM_PFS_BB \
 821                                                   : MAX_NUM_PFS_K2)
 822
 823 /**
 824  * @brief ecore_concrete_to_sw_fid - get the sw function id from
 825  *        the concrete value.
 826  *
 827  * @param concrete_fid
 828  *
 829  * @return OSAL_INLINE u8
 830  */
 831 static OSAL_INLINE u8
 832 ecore_concrete_to_sw_fid(__rte_unused struct ecore_dev *p_dev, u32 concrete_fid)
 833 {
 834         u8 vfid     = GET_FIELD(concrete_fid, PXP_CONCRETE_FID_VFID);
 835         u8 pfid     = GET_FIELD(concrete_fid, PXP_CONCRETE_FID_PFID);
 836         u8 vf_valid = GET_FIELD(concrete_fid, PXP_CONCRETE_FID_VFVALID);
 837         u8 sw_fid;
 838
 839         if (vf_valid)
 840                 sw_fid = vfid + MAX_NUM_PFS;
 841         else
 842                 sw_fid = pfid;
 843
 844         return sw_fid;
 845 }
 846
 847 #define PURE_LB_TC 8
 848 #define PKT_LB_TC 9
 849
 850 int ecore_configure_vport_wfq(struct ecore_dev *p_dev, u16 vp_id, u32 rate);
 851 void ecore_configure_vp_wfq_on_link_change(struct ecore_dev *p_dev,
 852                                            struct ecore_ptt *p_ptt,
 853                                            u32 min_pf_rate);
 854
 855 int ecore_configure_pf_max_bandwidth(struct ecore_dev *p_dev, u8 max_bw);
 856 int ecore_configure_pf_min_bandwidth(struct ecore_dev *p_dev, u8 min_bw);
 857 void ecore_clean_wfq_db(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt);
 858 int ecore_device_num_engines(struct ecore_dev *p_dev);
 859 int ecore_device_num_ports(struct ecore_dev *p_dev);
 860 void ecore_set_fw_mac_addr(__le16 *fw_msb, __le16 *fw_mid, __le16 *fw_lsb,
 861                            u8 *mac);
 862
 863 /* Flags for indication of required queues */
 864 #define PQ_FLAGS_RLS    (1 << 0)
 865 #define PQ_FLAGS_MCOS   (1 << 1)
 866 #define PQ_FLAGS_LB     (1 << 2)
 867 #define PQ_FLAGS_OOO    (1 << 3)
 868 #define PQ_FLAGS_ACK    (1 << 4)
 869 #define PQ_FLAGS_OFLD   (1 << 5)
 870 #define PQ_FLAGS_VFS    (1 << 6)
 871
 872 /* physical queue index for cm context intialization */
 873 u16 ecore_get_cm_pq_idx(struct ecore_hwfn *p_hwfn, u32 pq_flags);
 874 u16 ecore_get_cm_pq_idx_mcos(struct ecore_hwfn *p_hwfn, u8 tc);
 875 u16 ecore_get_cm_pq_idx_vf(struct ecore_hwfn *p_hwfn, u16 vf);
 876 u16 ecore_get_cm_pq_idx_rl(struct ecore_hwfn *p_hwfn, u8 qpid);
 877
 878 const char *ecore_hw_get_resc_name(enum ecore_resources res_id);
 879
 880 /* doorbell recovery mechanism */
 881 void ecore_db_recovery_dp(struct ecore_hwfn *p_hwfn);
 882 void ecore_db_recovery_execute(struct ecore_hwfn *p_hwfn,
 883                                enum ecore_db_rec_exec);
 884
 885 /* amount of resources used in qm init */
 886 u8 ecore_init_qm_get_num_tcs(struct ecore_hwfn *p_hwfn);
 887 u16 ecore_init_qm_get_num_vfs(struct ecore_hwfn *p_hwfn);
 888 u16 ecore_init_qm_get_num_pf_rls(struct ecore_hwfn *p_hwfn);
 889 u16 ecore_init_qm_get_num_vports(struct ecore_hwfn *p_hwfn);
 890 u16 ecore_init_qm_get_num_pqs(struct ecore_hwfn *p_hwfn);
 891
 892 #define ECORE_LEADING_HWFN(dev) (&dev->hwfns[0])
 893
 894 #endif /* __ECORE_H */