drivers/net/ethernet/qlogic/qed/qed_vf.h

   1 /* QLogic qed NIC Driver
   2  * Copyright (c) 2015-2017  QLogic Corporation
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and /or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #ifndef _QED_VF_H
  34 #define _QED_VF_H
  35
  36 #include "qed_l2.h"
  37 #include "qed_mcp.h"
  38
  39 #define T_ETH_INDIRECTION_TABLE_SIZE 128
  40 #define T_ETH_RSS_KEY_SIZE 10
  41
  42 struct vf_pf_resc_request {
  43         u8 num_rxqs;
  44         u8 num_txqs;
  45         u8 num_sbs;
  46         u8 num_mac_filters;
  47         u8 num_vlan_filters;
  48         u8 num_mc_filters;
  49         u16 padding;
  50 };
  51
  52 struct hw_sb_info {
  53         u16 hw_sb_id;
  54         u8 sb_qid;
  55         u8 padding[5];
  56 };
  57
  58 #define TLV_BUFFER_SIZE                 1024
  59
  60 enum {
  61         PFVF_STATUS_WAITING,
  62         PFVF_STATUS_SUCCESS,
  63         PFVF_STATUS_FAILURE,
  64         PFVF_STATUS_NOT_SUPPORTED,
  65         PFVF_STATUS_NO_RESOURCE,
  66         PFVF_STATUS_FORCED,
  67         PFVF_STATUS_MALICIOUS,
  68 };
  69
  70 /* vf pf channel tlvs */
  71 /* general tlv header (used for both vf->pf request and pf->vf response) */
  72 struct channel_tlv {
  73         u16 type;
  74         u16 length;
  75 };
  76
  77 /* header of first vf->pf tlv carries the offset used to calculate reponse
  78  * buffer address
  79  */
  80 struct vfpf_first_tlv {
  81         struct channel_tlv tl;
  82         u32 padding;
  83         u64 reply_address;
  84 };
  85
  86 /* header of pf->vf tlvs, carries the status of handling the request */
  87 struct pfvf_tlv {
  88         struct channel_tlv tl;
  89         u8 status;
  90         u8 padding[3];
  91 };
  92
  93 /* response tlv used for most tlvs */
  94 struct pfvf_def_resp_tlv {
  95         struct pfvf_tlv hdr;
  96 };
  97
  98 /* used to terminate and pad a tlv list */
  99 struct channel_list_end_tlv {
 100         struct channel_tlv tl;
 101         u8 padding[4];
 102 };
 103
 104 #define VFPF_ACQUIRE_OS_LINUX (0)
 105 #define VFPF_ACQUIRE_OS_WINDOWS (1)
 106 #define VFPF_ACQUIRE_OS_ESX (2)
 107 #define VFPF_ACQUIRE_OS_SOLARIS (3)
 108 #define VFPF_ACQUIRE_OS_LINUX_USERSPACE (4)
 109
 110 struct vfpf_acquire_tlv {
 111         struct vfpf_first_tlv first_tlv;
 112
 113         struct vf_pf_vfdev_info {
 114 #define VFPF_ACQUIRE_CAP_PRE_FP_HSI     (1 << 0) /* VF pre-FP hsi version */
 115 #define VFPF_ACQUIRE_CAP_100G           (1 << 1) /* VF can support 100g */
 116                 u64 capabilities;
 117                 u8 fw_major;
 118                 u8 fw_minor;
 119                 u8 fw_revision;
 120                 u8 fw_engineering;
 121                 u32 driver_version;
 122                 u16 opaque_fid; /* ME register value */
 123                 u8 os_type;     /* VFPF_ACQUIRE_OS_* value */
 124                 u8 eth_fp_hsi_major;
 125                 u8 eth_fp_hsi_minor;
 126                 u8 padding[3];
 127         } vfdev_info;
 128
 129         struct vf_pf_resc_request resc_request;
 130
 131         u64 bulletin_addr;
 132         u32 bulletin_size;
 133         u32 padding;
 134 };
 135
 136 /* receive side scaling tlv */
 137 struct vfpf_vport_update_rss_tlv {
 138         struct channel_tlv tl;
 139
 140         u8 update_rss_flags;
 141 #define VFPF_UPDATE_RSS_CONFIG_FLAG       BIT(0)
 142 #define VFPF_UPDATE_RSS_CAPS_FLAG         BIT(1)
 143 #define VFPF_UPDATE_RSS_IND_TABLE_FLAG    BIT(2)
 144 #define VFPF_UPDATE_RSS_KEY_FLAG          BIT(3)
 145
 146         u8 rss_enable;
 147         u8 rss_caps;
 148         u8 rss_table_size_log;  /* The table size is 2 ^ rss_table_size_log */
 149         u16 rss_ind_table[T_ETH_INDIRECTION_TABLE_SIZE];
 150         u32 rss_key[T_ETH_RSS_KEY_SIZE];
 151 };
 152
 153 struct pfvf_storm_stats {
 154         u32 address;
 155         u32 len;
 156 };
 157
 158 struct pfvf_stats_info {
 159         struct pfvf_storm_stats mstats;
 160         struct pfvf_storm_stats pstats;
 161         struct pfvf_storm_stats tstats;
 162         struct pfvf_storm_stats ustats;
 163 };
 164
 165 struct pfvf_acquire_resp_tlv {
 166         struct pfvf_tlv hdr;
 167
 168         struct pf_vf_pfdev_info {
 169                 u32 chip_num;
 170                 u32 mfw_ver;
 171
 172                 u16 fw_major;
 173                 u16 fw_minor;
 174                 u16 fw_rev;
 175                 u16 fw_eng;
 176
 177                 u64 capabilities;
 178 #define PFVF_ACQUIRE_CAP_DEFAULT_UNTAGGED       BIT(0)
 179 #define PFVF_ACQUIRE_CAP_100G                   BIT(1)  /* If set, 100g PF */
 180 /* There are old PF versions where the PF might mistakenly override the sanity
 181  * mechanism [version-based] and allow a VF that can't be supported to pass
 182  * the acquisition phase.
 183  * To overcome this, PFs now indicate that they're past that point and the new
 184  * VFs would fail probe on the older PFs that fail to do so.
 185  */
 186 #define PFVF_ACQUIRE_CAP_POST_FW_OVERRIDE       BIT(2)
 187
 188                 u16 db_size;
 189                 u8 indices_per_sb;
 190                 u8 os_type;
 191
 192                 /* These should match the PF's qed_dev values */
 193                 u16 chip_rev;
 194                 u8 dev_type;
 195
 196                 u8 padding;
 197
 198                 struct pfvf_stats_info stats_info;
 199
 200                 u8 port_mac[ETH_ALEN];
 201
 202                 /* It's possible PF had to configure an older fastpath HSI
 203                  * [in case VF is newer than PF]. This is communicated back
 204                  * to the VF. It can also be used in case of error due to
 205                  * non-matching versions to shed light in VF about failure.
 206                  */
 207                 u8 major_fp_hsi;
 208                 u8 minor_fp_hsi;
 209         } pfdev_info;
 210
 211         struct pf_vf_resc {
 212 #define PFVF_MAX_QUEUES_PER_VF          16
 213 #define PFVF_MAX_SBS_PER_VF             16
 214                 struct hw_sb_info hw_sbs[PFVF_MAX_SBS_PER_VF];
 215                 u8 hw_qid[PFVF_MAX_QUEUES_PER_VF];
 216                 u8 cid[PFVF_MAX_QUEUES_PER_VF];
 217
 218                 u8 num_rxqs;
 219                 u8 num_txqs;
 220                 u8 num_sbs;
 221                 u8 num_mac_filters;
 222                 u8 num_vlan_filters;
 223                 u8 num_mc_filters;
 224                 u8 padding[2];
 225         } resc;
 226
 227         u32 bulletin_size;
 228         u32 padding;
 229 };
 230
 231 struct pfvf_start_queue_resp_tlv {
 232         struct pfvf_tlv hdr;
 233         u32 offset;             /* offset to consumer/producer of queue */
 234         u8 padding[4];
 235 };
 236
 237 /* Setup Queue */
 238 struct vfpf_start_rxq_tlv {
 239         struct vfpf_first_tlv first_tlv;
 240
 241         /* physical addresses */
 242         u64 rxq_addr;
 243         u64 deprecated_sge_addr;
 244         u64 cqe_pbl_addr;
 245
 246         u16 cqe_pbl_size;
 247         u16 hw_sb;
 248         u16 rx_qid;
 249         u16 hc_rate;            /* desired interrupts per sec. */
 250
 251         u16 bd_max_bytes;
 252         u16 stat_id;
 253         u8 sb_index;
 254         u8 padding[3];
 255 };
 256
 257 struct vfpf_start_txq_tlv {
 258         struct vfpf_first_tlv first_tlv;
 259
 260         /* physical addresses */
 261         u64 pbl_addr;
 262         u16 pbl_size;
 263         u16 stat_id;
 264         u16 tx_qid;
 265         u16 hw_sb;
 266
 267         u32 flags;              /* VFPF_QUEUE_FLG_X flags */
 268         u16 hc_rate;            /* desired interrupts per sec. */
 269         u8 sb_index;
 270         u8 padding[3];
 271 };
 272
 273 /* Stop RX Queue */
 274 struct vfpf_stop_rxqs_tlv {
 275         struct vfpf_first_tlv first_tlv;
 276
 277         u16 rx_qid;
 278         u8 num_rxqs;
 279         u8 cqe_completion;
 280         u8 padding[4];
 281 };
 282
 283 /* Stop TX Queues */
 284 struct vfpf_stop_txqs_tlv {
 285         struct vfpf_first_tlv first_tlv;
 286
 287         u16 tx_qid;
 288         u8 num_txqs;
 289         u8 padding[5];
 290 };
 291
 292 struct vfpf_update_rxq_tlv {
 293         struct vfpf_first_tlv first_tlv;
 294
 295         u64 deprecated_sge_addr[PFVF_MAX_QUEUES_PER_VF];
 296
 297         u16 rx_qid;
 298         u8 num_rxqs;
 299         u8 flags;
 300 #define VFPF_RXQ_UPD_INIT_SGE_DEPRECATE_FLAG    BIT(0)
 301 #define VFPF_RXQ_UPD_COMPLETE_CQE_FLAG          BIT(1)
 302 #define VFPF_RXQ_UPD_COMPLETE_EVENT_FLAG        BIT(2)
 303
 304         u8 padding[4];
 305 };
 306
 307 /* Set Queue Filters */
 308 struct vfpf_q_mac_vlan_filter {
 309         u32 flags;
 310 #define VFPF_Q_FILTER_DEST_MAC_VALID    0x01
 311 #define VFPF_Q_FILTER_VLAN_TAG_VALID    0x02
 312 #define VFPF_Q_FILTER_SET_MAC           0x100   /* set/clear */
 313
 314         u8 mac[ETH_ALEN];
 315         u16 vlan_tag;
 316
 317         u8 padding[4];
 318 };
 319
 320 /* Start a vport */
 321 struct vfpf_vport_start_tlv {
 322         struct vfpf_first_tlv first_tlv;
 323
 324         u64 sb_addr[PFVF_MAX_SBS_PER_VF];
 325
 326         u32 tpa_mode;
 327         u16 dep1;
 328         u16 mtu;
 329
 330         u8 vport_id;
 331         u8 inner_vlan_removal;
 332
 333         u8 only_untagged;
 334         u8 max_buffers_per_cqe;
 335
 336         u8 padding[4];
 337 };
 338
 339 /* Extended tlvs - need to add rss, mcast, accept mode tlvs */
 340 struct vfpf_vport_update_activate_tlv {
 341         struct channel_tlv tl;
 342         u8 update_rx;
 343         u8 update_tx;
 344         u8 active_rx;
 345         u8 active_tx;
 346 };
 347
 348 struct vfpf_vport_update_tx_switch_tlv {
 349         struct channel_tlv tl;
 350         u8 tx_switching;
 351         u8 padding[3];
 352 };
 353
 354 struct vfpf_vport_update_vlan_strip_tlv {
 355         struct channel_tlv tl;
 356         u8 remove_vlan;
 357         u8 padding[3];
 358 };
 359
 360 struct vfpf_vport_update_mcast_bin_tlv {
 361         struct channel_tlv tl;
 362         u8 padding[4];
 363
 364         u64 bins[8];
 365 };
 366
 367 struct vfpf_vport_update_accept_param_tlv {
 368         struct channel_tlv tl;
 369         u8 update_rx_mode;
 370         u8 update_tx_mode;
 371         u8 rx_accept_filter;
 372         u8 tx_accept_filter;
 373 };
 374
 375 struct vfpf_vport_update_accept_any_vlan_tlv {
 376         struct channel_tlv tl;
 377         u8 update_accept_any_vlan_flg;
 378         u8 accept_any_vlan;
 379
 380         u8 padding[2];
 381 };
 382
 383 struct vfpf_vport_update_sge_tpa_tlv {
 384         struct channel_tlv tl;
 385
 386         u16 sge_tpa_flags;
 387 #define VFPF_TPA_IPV4_EN_FLAG           BIT(0)
 388 #define VFPF_TPA_IPV6_EN_FLAG           BIT(1)
 389 #define VFPF_TPA_PKT_SPLIT_FLAG         BIT(2)
 390 #define VFPF_TPA_HDR_DATA_SPLIT_FLAG    BIT(3)
 391 #define VFPF_TPA_GRO_CONSIST_FLAG       BIT(4)
 392
 393         u8 update_sge_tpa_flags;
 394 #define VFPF_UPDATE_SGE_DEPRECATED_FLAG BIT(0)
 395 #define VFPF_UPDATE_TPA_EN_FLAG         BIT(1)
 396 #define VFPF_UPDATE_TPA_PARAM_FLAG      BIT(2)
 397
 398         u8 max_buffers_per_cqe;
 399
 400         u16 deprecated_sge_buff_size;
 401         u16 tpa_max_size;
 402         u16 tpa_min_size_to_start;
 403         u16 tpa_min_size_to_cont;
 404
 405         u8 tpa_max_aggs_num;
 406         u8 padding[7];
 407 };
 408
 409 /* Primary tlv as a header for various extended tlvs for
 410  * various functionalities in vport update ramrod.
 411  */
 412 struct vfpf_vport_update_tlv {
 413         struct vfpf_first_tlv first_tlv;
 414 };
 415
 416 struct vfpf_ucast_filter_tlv {
 417         struct vfpf_first_tlv first_tlv;
 418
 419         u8 opcode;
 420         u8 type;
 421
 422         u8 mac[ETH_ALEN];
 423
 424         u16 vlan;
 425         u16 padding[3];
 426 };
 427
 428 struct tlv_buffer_size {
 429         u8 tlv_buffer[TLV_BUFFER_SIZE];
 430 };
 431
 432 union vfpf_tlvs {
 433         struct vfpf_first_tlv first_tlv;
 434         struct vfpf_acquire_tlv acquire;
 435         struct vfpf_start_rxq_tlv start_rxq;
 436         struct vfpf_start_txq_tlv start_txq;
 437         struct vfpf_stop_rxqs_tlv stop_rxqs;
 438         struct vfpf_stop_txqs_tlv stop_txqs;
 439         struct vfpf_update_rxq_tlv update_rxq;
 440         struct vfpf_vport_start_tlv start_vport;
 441         struct vfpf_vport_update_tlv vport_update;
 442         struct vfpf_ucast_filter_tlv ucast_filter;
 443         struct channel_list_end_tlv list_end;
 444         struct tlv_buffer_size tlv_buf_size;
 445 };
 446
 447 union pfvf_tlvs {
 448         struct pfvf_def_resp_tlv default_resp;
 449         struct pfvf_acquire_resp_tlv acquire_resp;
 450         struct tlv_buffer_size tlv_buf_size;
 451         struct pfvf_start_queue_resp_tlv queue_start;
 452 };
 453
 454 enum qed_bulletin_bit {
 455         /* Alert the VF that a forced MAC was set by the PF */
 456         MAC_ADDR_FORCED = 0,
 457         /* Alert the VF that a forced VLAN was set by the PF */
 458         VLAN_ADDR_FORCED = 2,
 459
 460         /* Indicate that `default_only_untagged' contains actual data */
 461         VFPF_BULLETIN_UNTAGGED_DEFAULT = 3,
 462         VFPF_BULLETIN_UNTAGGED_DEFAULT_FORCED = 4,
 463
 464         /* Alert the VF that suggested mac was sent by the PF.
 465          * MAC_ADDR will be disabled in case MAC_ADDR_FORCED is set.
 466          */
 467         VFPF_BULLETIN_MAC_ADDR = 5
 468 };
 469
 470 struct qed_bulletin_content {
 471         /* crc of structure to ensure is not in mid-update */
 472         u32 crc;
 473
 474         u32 version;
 475
 476         /* bitmap indicating which fields hold valid values */
 477         u64 valid_bitmap;
 478
 479         /* used for MAC_ADDR or MAC_ADDR_FORCED */
 480         u8 mac[ETH_ALEN];
 481
 482         /* If valid, 1 => only untagged Rx if no vlan is configured */
 483         u8 default_only_untagged;
 484         u8 padding;
 485
 486         /* The following is a 'copy' of qed_mcp_link_state,
 487          * qed_mcp_link_params and qed_mcp_link_capabilities. Since it's
 488          * possible the structs will increase further along the road we cannot
 489          * have it here; Instead we need to have all of its fields.
 490          */
 491         u8 req_autoneg;
 492         u8 req_autoneg_pause;
 493         u8 req_forced_rx;
 494         u8 req_forced_tx;
 495         u8 padding2[4];
 496
 497         u32 req_adv_speed;
 498         u32 req_forced_speed;
 499         u32 req_loopback;
 500         u32 padding3;
 501
 502         u8 link_up;
 503         u8 full_duplex;
 504         u8 autoneg;
 505         u8 autoneg_complete;
 506         u8 parallel_detection;
 507         u8 pfc_enabled;
 508         u8 partner_tx_flow_ctrl_en;
 509         u8 partner_rx_flow_ctrl_en;
 510         u8 partner_adv_pause;
 511         u8 sfp_tx_fault;
 512         u8 padding4[6];
 513
 514         u32 speed;
 515         u32 partner_adv_speed;
 516
 517         u32 capability_speed;
 518
 519         /* Forced vlan */
 520         u16 pvid;
 521         u16 padding5;
 522 };
 523
 524 struct qed_bulletin {
 525         dma_addr_t phys;
 526         struct qed_bulletin_content *p_virt;
 527         u32 size;
 528 };
 529
 530 enum {
 531         CHANNEL_TLV_NONE,       /* ends tlv sequence */
 532         CHANNEL_TLV_ACQUIRE,
 533         CHANNEL_TLV_VPORT_START,
 534         CHANNEL_TLV_VPORT_UPDATE,
 535         CHANNEL_TLV_VPORT_TEARDOWN,
 536         CHANNEL_TLV_START_RXQ,
 537         CHANNEL_TLV_START_TXQ,
 538         CHANNEL_TLV_STOP_RXQS,
 539         CHANNEL_TLV_STOP_TXQS,
 540         CHANNEL_TLV_UPDATE_RXQ,
 541         CHANNEL_TLV_INT_CLEANUP,
 542         CHANNEL_TLV_CLOSE,
 543         CHANNEL_TLV_RELEASE,
 544         CHANNEL_TLV_LIST_END,
 545         CHANNEL_TLV_UCAST_FILTER,
 546         CHANNEL_TLV_VPORT_UPDATE_ACTIVATE,
 547         CHANNEL_TLV_VPORT_UPDATE_TX_SWITCH,
 548         CHANNEL_TLV_VPORT_UPDATE_VLAN_STRIP,
 549         CHANNEL_TLV_VPORT_UPDATE_MCAST,
 550         CHANNEL_TLV_VPORT_UPDATE_ACCEPT_PARAM,
 551         CHANNEL_TLV_VPORT_UPDATE_RSS,
 552         CHANNEL_TLV_VPORT_UPDATE_ACCEPT_ANY_VLAN,
 553         CHANNEL_TLV_VPORT_UPDATE_SGE_TPA,
 554         CHANNEL_TLV_MAX,
 555
 556         /* Required for iterating over vport-update tlvs.
 557          * Will break in case non-sequential vport-update tlvs.
 558          */
 559         CHANNEL_TLV_VPORT_UPDATE_MAX = CHANNEL_TLV_VPORT_UPDATE_SGE_TPA + 1,
 560 };
 561
 562 /* This data is held in the qed_hwfn structure for VFs only. */
 563 struct qed_vf_iov {
 564         union vfpf_tlvs *vf2pf_request;
 565         dma_addr_t vf2pf_request_phys;
 566         union pfvf_tlvs *pf2vf_reply;
 567         dma_addr_t pf2vf_reply_phys;
 568
 569         /* Should be taken whenever the mailbox buffers are accessed */
 570         struct mutex mutex;
 571         u8 *offset;
 572
 573         /* Bulletin Board */
 574         struct qed_bulletin bulletin;
 575         struct qed_bulletin_content bulletin_shadow;
 576
 577         /* we set aside a copy of the acquire response */
 578         struct pfvf_acquire_resp_tlv acquire_resp;
 579
 580         /* In case PF originates prior to the fp-hsi version comparison,
 581          * this has to be propagated as it affects the fastpath.
 582          */
 583         bool b_pre_fp_hsi;
 584 };
 585
 586 #ifdef CONFIG_QED_SRIOV
 587 /**
 588  * @brief Read the VF bulletin and act on it if needed
 589  *
 590  * @param p_hwfn
 591  * @param p_change - qed fills 1 iff bulletin board has changed, 0 otherwise.
 592  *
 593  * @return enum _qed_status
 594  */
 595 int qed_vf_read_bulletin(struct qed_hwfn *p_hwfn, u8 *p_change);
 596
 597 /**
 598  * @brief Get link paramters for VF from qed
 599  *
 600  * @param p_hwfn
 601  * @param params - the link params structure to be filled for the VF
 602  */
 603 void qed_vf_get_link_params(struct qed_hwfn *p_hwfn,
 604                             struct qed_mcp_link_params *params);
 605
 606 /**
 607  * @brief Get link state for VF from qed
 608  *
 609  * @param p_hwfn
 610  * @param link - the link state structure to be filled for the VF
 611  */
 612 void qed_vf_get_link_state(struct qed_hwfn *p_hwfn,
 613                            struct qed_mcp_link_state *link);
 614
 615 /**
 616  * @brief Get link capabilities for VF from qed
 617  *
 618  * @param p_hwfn
 619  * @param p_link_caps - the link capabilities structure to be filled for the VF
 620  */
 621 void qed_vf_get_link_caps(struct qed_hwfn *p_hwfn,
 622                           struct qed_mcp_link_capabilities *p_link_caps);
 623
 624 /**
 625  * @brief Get number of Rx queues allocated for VF by qed
 626  *
 627  *  @param p_hwfn
 628  *  @param num_rxqs - allocated RX queues
 629  */
 630 void qed_vf_get_num_rxqs(struct qed_hwfn *p_hwfn, u8 *num_rxqs);
 631
 632 /**
 633  * @brief Get port mac address for VF
 634  *
 635  * @param p_hwfn
 636  * @param port_mac - destination location for port mac
 637  */
 638 void qed_vf_get_port_mac(struct qed_hwfn *p_hwfn, u8 *port_mac);
 639
 640 /**
 641  * @brief Get number of VLAN filters allocated for VF by qed
 642  *
 643  *  @param p_hwfn
 644  *  @param num_rxqs - allocated VLAN filters
 645  */
 646 void qed_vf_get_num_vlan_filters(struct qed_hwfn *p_hwfn,
 647                                  u8 *num_vlan_filters);
 648
 649 /**
 650  * @brief Get number of MAC filters allocated for VF by qed
 651  *
 652  *  @param p_hwfn
 653  *  @param num_rxqs - allocated MAC filters
 654  */
 655 void qed_vf_get_num_mac_filters(struct qed_hwfn *p_hwfn, u8 *num_mac_filters);
 656
 657 /**
 658  * @brief Check if VF can set a MAC address
 659  *
 660  * @param p_hwfn
 661  * @param mac
 662  *
 663  * @return bool
 664  */
 665 bool qed_vf_check_mac(struct qed_hwfn *p_hwfn, u8 *mac);
 666
 667 /**
 668  * @brief Set firmware version information in dev_info from VFs acquire response tlv
 669  *
 670  * @param p_hwfn
 671  * @param fw_major
 672  * @param fw_minor
 673  * @param fw_rev
 674  * @param fw_eng
 675  */
 676 void qed_vf_get_fw_version(struct qed_hwfn *p_hwfn,
 677                            u16 *fw_major, u16 *fw_minor,
 678                            u16 *fw_rev, u16 *fw_eng);
 679
 680 /**
 681  * @brief hw preparation for VF
 682  *      sends ACQUIRE message
 683  *
 684  * @param p_hwfn
 685  *
 686  * @return int
 687  */
 688 int qed_vf_hw_prepare(struct qed_hwfn *p_hwfn);
 689
 690 /**
 691  * @brief VF - start the RX Queue by sending a message to the PF
 692  * @param p_hwfn
 693  * @param p_cid                 - Only relative fields are relevant
 694  * @param bd_max_bytes          - maximum number of bytes per bd
 695  * @param bd_chain_phys_addr    - physical address of bd chain
 696  * @param cqe_pbl_addr          - physical address of pbl
 697  * @param cqe_pbl_size          - pbl size
 698  * @param pp_prod               - pointer to the producer to be
 699  *                                used in fastpath
 700  *
 701  * @return int
 702  */
 703 int qed_vf_pf_rxq_start(struct qed_hwfn *p_hwfn,
 704                         struct qed_queue_cid *p_cid,
 705                         u16 bd_max_bytes,
 706                         dma_addr_t bd_chain_phys_addr,
 707                         dma_addr_t cqe_pbl_addr,
 708                         u16 cqe_pbl_size, void __iomem **pp_prod);
 709
 710 /**
 711  * @brief VF - start the TX queue by sending a message to the
 712  *        PF.
 713  *
 714  * @param p_hwfn
 715  * @param tx_queue_id           - zero based within the VF
 716  * @param sb                    - status block for this queue
 717  * @param sb_index              - index within the status block
 718  * @param bd_chain_phys_addr    - physical address of tx chain
 719  * @param pp_doorbell           - pointer to address to which to
 720  *                      write the doorbell too..
 721  *
 722  * @return int
 723  */
 724 int
 725 qed_vf_pf_txq_start(struct qed_hwfn *p_hwfn,
 726                     struct qed_queue_cid *p_cid,
 727                     dma_addr_t pbl_addr,
 728                     u16 pbl_size, void __iomem **pp_doorbell);
 729
 730 /**
 731  * @brief VF - stop the RX queue by sending a message to the PF
 732  *
 733  * @param p_hwfn
 734  * @param p_cid
 735  * @param cqe_completion
 736  *
 737  * @return int
 738  */
 739 int qed_vf_pf_rxq_stop(struct qed_hwfn *p_hwfn,
 740                        struct qed_queue_cid *p_cid, bool cqe_completion);
 741
 742 /**
 743  * @brief VF - stop the TX queue by sending a message to the PF
 744  *
 745  * @param p_hwfn
 746  * @param tx_qid
 747  *
 748  * @return int
 749  */
 750 int qed_vf_pf_txq_stop(struct qed_hwfn *p_hwfn, struct qed_queue_cid *p_cid);
 751
 752 /**
 753  * @brief VF - send a vport update command
 754  *
 755  * @param p_hwfn
 756  * @param params
 757  *
 758  * @return int
 759  */
 760 int qed_vf_pf_vport_update(struct qed_hwfn *p_hwfn,
 761                            struct qed_sp_vport_update_params *p_params);
 762
 763 /**
 764  *
 765  * @brief VF - send a close message to PF
 766  *
 767  * @param p_hwfn
 768  *
 769  * @return enum _qed_status
 770  */
 771 int qed_vf_pf_reset(struct qed_hwfn *p_hwfn);
 772
 773 /**
 774  * @brief VF - free vf`s memories
 775  *
 776  * @param p_hwfn
 777  *
 778  * @return enum _qed_status
 779  */
 780 int qed_vf_pf_release(struct qed_hwfn *p_hwfn);
 781
 782 /**
 783  * @brief qed_vf_get_igu_sb_id - Get the IGU SB ID for a given
 784  *        sb_id. For VFs igu sbs don't have to be contiguous
 785  *
 786  * @param p_hwfn
 787  * @param sb_id
 788  *
 789  * @return INLINE u16
 790  */
 791 u16 qed_vf_get_igu_sb_id(struct qed_hwfn *p_hwfn, u16 sb_id);
 792
 793 /**
 794  * @brief qed_vf_pf_vport_start - perform vport start for VF.
 795  *
 796  * @param p_hwfn
 797  * @param vport_id
 798  * @param mtu
 799  * @param inner_vlan_removal
 800  * @param tpa_mode
 801  * @param max_buffers_per_cqe,
 802  * @param only_untagged - default behavior regarding vlan acceptance
 803  *
 804  * @return enum _qed_status
 805  */
 806 int qed_vf_pf_vport_start(struct qed_hwfn *p_hwfn,
 807                           u8 vport_id,
 808                           u16 mtu,
 809                           u8 inner_vlan_removal,
 810                           enum qed_tpa_mode tpa_mode,
 811                           u8 max_buffers_per_cqe, u8 only_untagged);
 812
 813 /**
 814  * @brief qed_vf_pf_vport_stop - stop the VF's vport
 815  *
 816  * @param p_hwfn
 817  *
 818  * @return enum _qed_status
 819  */
 820 int qed_vf_pf_vport_stop(struct qed_hwfn *p_hwfn);
 821
 822 int qed_vf_pf_filter_ucast(struct qed_hwfn *p_hwfn,
 823                            struct qed_filter_ucast *p_param);
 824
 825 void qed_vf_pf_filter_mcast(struct qed_hwfn *p_hwfn,
 826                             struct qed_filter_mcast *p_filter_cmd);
 827
 828 /**
 829  * @brief qed_vf_pf_int_cleanup - clean the SB of the VF
 830  *
 831  * @param p_hwfn
 832  *
 833  * @return enum _qed_status
 834  */
 835 int qed_vf_pf_int_cleanup(struct qed_hwfn *p_hwfn);
 836
 837 /**
 838  * @brief - return the link params in a given bulletin board
 839  *
 840  * @param p_hwfn
 841  * @param p_params - pointer to a struct to fill with link params
 842  * @param p_bulletin
 843  */
 844 void __qed_vf_get_link_params(struct qed_hwfn *p_hwfn,
 845                               struct qed_mcp_link_params *p_params,
 846                               struct qed_bulletin_content *p_bulletin);
 847
 848 /**
 849  * @brief - return the link state in a given bulletin board
 850  *
 851  * @param p_hwfn
 852  * @param p_link - pointer to a struct to fill with link state
 853  * @param p_bulletin
 854  */
 855 void __qed_vf_get_link_state(struct qed_hwfn *p_hwfn,
 856                              struct qed_mcp_link_state *p_link,
 857                              struct qed_bulletin_content *p_bulletin);
 858
 859 /**
 860  * @brief - return the link capabilities in a given bulletin board
 861  *
 862  * @param p_hwfn
 863  * @param p_link - pointer to a struct to fill with link capabilities
 864  * @param p_bulletin
 865  */
 866 void __qed_vf_get_link_caps(struct qed_hwfn *p_hwfn,
 867                             struct qed_mcp_link_capabilities *p_link_caps,
 868                             struct qed_bulletin_content *p_bulletin);
 869
 870 void qed_iov_vf_task(struct work_struct *work);
 871 #else
 872 static inline void qed_vf_get_link_params(struct qed_hwfn *p_hwfn,
 873                                           struct qed_mcp_link_params *params)
 874 {
 875 }
 876
 877 static inline void qed_vf_get_link_state(struct qed_hwfn *p_hwfn,
 878                                          struct qed_mcp_link_state *link)
 879 {
 880 }
 881
 882 static inline void
 883 qed_vf_get_link_caps(struct qed_hwfn *p_hwfn,
 884                      struct qed_mcp_link_capabilities *p_link_caps)
 885 {
 886 }
 887
 888 static inline void qed_vf_get_num_rxqs(struct qed_hwfn *p_hwfn, u8 *num_rxqs)
 889 {
 890 }
 891
 892 static inline void qed_vf_get_port_mac(struct qed_hwfn *p_hwfn, u8 *port_mac)
 893 {
 894 }
 895
 896 static inline void qed_vf_get_num_vlan_filters(struct qed_hwfn *p_hwfn,
 897                                                u8 *num_vlan_filters)
 898 {
 899 }
 900
 901 static inline void qed_vf_get_num_mac_filters(struct qed_hwfn *p_hwfn,
 902                                               u8 *num_mac_filters)
 903 {
 904 }
 905
 906 static inline bool qed_vf_check_mac(struct qed_hwfn *p_hwfn, u8 *mac)
 907 {
 908         return false;
 909 }
 910
 911 static inline void qed_vf_get_fw_version(struct qed_hwfn *p_hwfn,
 912                                          u16 *fw_major, u16 *fw_minor,
 913                                          u16 *fw_rev, u16 *fw_eng)
 914 {
 915 }
 916
 917 static inline int qed_vf_hw_prepare(struct qed_hwfn *p_hwfn)
 918 {
 919         return -EINVAL;
 920 }
 921
 922 static inline int qed_vf_pf_rxq_start(struct qed_hwfn *p_hwfn,
 923                                       struct qed_queue_cid *p_cid,
 924                                       u16 bd_max_bytes,
 925                                       dma_addr_t bd_chain_phys_adr,
 926                                       dma_addr_t cqe_pbl_addr,
 927                                       u16 cqe_pbl_size, void __iomem **pp_prod)
 928 {
 929         return -EINVAL;
 930 }
 931
 932 static inline int qed_vf_pf_txq_start(struct qed_hwfn *p_hwfn,
 933                                       struct qed_queue_cid *p_cid,
 934                                       dma_addr_t pbl_addr,
 935                                       u16 pbl_size, void __iomem **pp_doorbell)
 936 {
 937         return -EINVAL;
 938 }
 939
 940 static inline int qed_vf_pf_rxq_stop(struct qed_hwfn *p_hwfn,
 941                                      struct qed_queue_cid *p_cid,
 942                                      bool cqe_completion)
 943 {
 944         return -EINVAL;
 945 }
 946
 947 static inline int qed_vf_pf_txq_stop(struct qed_hwfn *p_hwfn,
 948                                      struct qed_queue_cid *p_cid)
 949 {
 950         return -EINVAL;
 951 }
 952
 953 static inline int
 954 qed_vf_pf_vport_update(struct qed_hwfn *p_hwfn,
 955                        struct qed_sp_vport_update_params *p_params)
 956 {
 957         return -EINVAL;
 958 }
 959
 960 static inline int qed_vf_pf_reset(struct qed_hwfn *p_hwfn)
 961 {
 962         return -EINVAL;
 963 }
 964
 965 static inline int qed_vf_pf_release(struct qed_hwfn *p_hwfn)
 966 {
 967         return -EINVAL;
 968 }
 969
 970 static inline u16 qed_vf_get_igu_sb_id(struct qed_hwfn *p_hwfn, u16 sb_id)
 971 {
 972         return 0;
 973 }
 974
 975 static inline int qed_vf_pf_vport_start(struct qed_hwfn *p_hwfn,
 976                                         u8 vport_id,
 977                                         u16 mtu,
 978                                         u8 inner_vlan_removal,
 979                                         enum qed_tpa_mode tpa_mode,
 980                                         u8 max_buffers_per_cqe,
 981                                         u8 only_untagged)
 982 {
 983         return -EINVAL;
 984 }
 985
 986 static inline int qed_vf_pf_vport_stop(struct qed_hwfn *p_hwfn)
 987 {
 988         return -EINVAL;
 989 }
 990
 991 static inline int qed_vf_pf_filter_ucast(struct qed_hwfn *p_hwfn,
 992                                          struct qed_filter_ucast *p_param)
 993 {
 994         return -EINVAL;
 995 }
 996
 997 static inline void qed_vf_pf_filter_mcast(struct qed_hwfn *p_hwfn,
 998                                           struct qed_filter_mcast *p_filter_cmd)
 999 {
1000 }
1001
1002 static inline int qed_vf_pf_int_cleanup(struct qed_hwfn *p_hwfn)
1003 {
1004         return -EINVAL;
1005 }
1006
1007 static inline void __qed_vf_get_link_params(struct qed_hwfn *p_hwfn,
1008                                             struct qed_mcp_link_params
1009                                             *p_params,
1010                                             struct qed_bulletin_content
1011                                             *p_bulletin)
1012 {
1013 }
1014
1015 static inline void __qed_vf_get_link_state(struct qed_hwfn *p_hwfn,
1016                                            struct qed_mcp_link_state *p_link,
1017                                            struct qed_bulletin_content
1018                                            *p_bulletin)
1019 {
1020 }
1021
1022 static inline void
1023 __qed_vf_get_link_caps(struct qed_hwfn *p_hwfn,
1024                        struct qed_mcp_link_capabilities *p_link_caps,
1025                        struct qed_bulletin_content *p_bulletin)
1026 {
1027 }
1028
1029 static inline void qed_iov_vf_task(struct work_struct *work)
1030 {
1031 }
1032 #endif
1033
1034 #endif