drivers/net/ethernet/qlogic/qed/qed_mcp.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_MCP_H
  34 #define _QED_MCP_H
  35
  36 #include <linux/types.h>
  37 #include <linux/delay.h>
  38 #include <linux/slab.h>
  39 #include <linux/spinlock.h>
  40 #include "qed_hsi.h"
  41
  42 struct qed_mcp_link_speed_params {
  43         bool    autoneg;
  44         u32     advertised_speeds;      /* bitmask of DRV_SPEED_CAPABILITY */
  45         u32     forced_speed;      /* In Mb/s */
  46 };
  47
  48 struct qed_mcp_link_pause_params {
  49         bool    autoneg;
  50         bool    forced_rx;
  51         bool    forced_tx;
  52 };
  53
  54 struct qed_mcp_link_params {
  55         struct qed_mcp_link_speed_params        speed;
  56         struct qed_mcp_link_pause_params        pause;
  57         u32                                  loopback_mode;
  58 };
  59
  60 struct qed_mcp_link_capabilities {
  61         u32 speed_capabilities;
  62 };
  63
  64 struct qed_mcp_link_state {
  65         bool    link_up;
  66
  67         u32     min_pf_rate;
  68
  69         /* Actual link speed in Mb/s */
  70         u32     line_speed;
  71
  72         /* PF max speed in Mb/s, deduced from line_speed
  73          * according to PF max bandwidth configuration.
  74          */
  75         u32     speed;
  76         bool    full_duplex;
  77
  78         bool    an;
  79         bool    an_complete;
  80         bool    parallel_detection;
  81         bool    pfc_enabled;
  82
  83 #define QED_LINK_PARTNER_SPEED_1G_HD    BIT(0)
  84 #define QED_LINK_PARTNER_SPEED_1G_FD    BIT(1)
  85 #define QED_LINK_PARTNER_SPEED_10G      BIT(2)
  86 #define QED_LINK_PARTNER_SPEED_20G      BIT(3)
  87 #define QED_LINK_PARTNER_SPEED_25G      BIT(4)
  88 #define QED_LINK_PARTNER_SPEED_40G      BIT(5)
  89 #define QED_LINK_PARTNER_SPEED_50G      BIT(6)
  90 #define QED_LINK_PARTNER_SPEED_100G     BIT(7)
  91         u32     partner_adv_speed;
  92
  93         bool    partner_tx_flow_ctrl_en;
  94         bool    partner_rx_flow_ctrl_en;
  95
  96 #define QED_LINK_PARTNER_SYMMETRIC_PAUSE (1)
  97 #define QED_LINK_PARTNER_ASYMMETRIC_PAUSE (2)
  98 #define QED_LINK_PARTNER_BOTH_PAUSE (3)
  99         u8      partner_adv_pause;
 100
 101         bool    sfp_tx_fault;
 102 };
 103
 104 struct qed_mcp_function_info {
 105         u8                              pause_on_host;
 106
 107         enum qed_pci_personality        protocol;
 108
 109         u8                              bandwidth_min;
 110         u8                              bandwidth_max;
 111
 112         u8                              mac[ETH_ALEN];
 113
 114         u64                             wwn_port;
 115         u64                             wwn_node;
 116
 117 #define QED_MCP_VLAN_UNSET              (0xffff)
 118         u16                             ovlan;
 119
 120         u16                             mtu;
 121 };
 122
 123 struct qed_mcp_nvm_common {
 124         u32     offset;
 125         u32     param;
 126         u32     resp;
 127         u32     cmd;
 128 };
 129
 130 struct qed_mcp_drv_version {
 131         u32     version;
 132         u8      name[MCP_DRV_VER_STR_SIZE - 4];
 133 };
 134
 135 struct qed_mcp_lan_stats {
 136         u64 ucast_rx_pkts;
 137         u64 ucast_tx_pkts;
 138         u32 fcs_err;
 139 };
 140
 141 struct qed_mcp_fcoe_stats {
 142         u64 rx_pkts;
 143         u64 tx_pkts;
 144         u32 fcs_err;
 145         u32 login_failure;
 146 };
 147
 148 struct qed_mcp_iscsi_stats {
 149         u64 rx_pdus;
 150         u64 tx_pdus;
 151         u64 rx_bytes;
 152         u64 tx_bytes;
 153 };
 154
 155 struct qed_mcp_rdma_stats {
 156         u64 rx_pkts;
 157         u64 tx_pkts;
 158         u64 rx_bytes;
 159         u64 tx_byts;
 160 };
 161
 162 enum qed_mcp_protocol_type {
 163         QED_MCP_LAN_STATS,
 164         QED_MCP_FCOE_STATS,
 165         QED_MCP_ISCSI_STATS,
 166         QED_MCP_RDMA_STATS
 167 };
 168
 169 union qed_mcp_protocol_stats {
 170         struct qed_mcp_lan_stats lan_stats;
 171         struct qed_mcp_fcoe_stats fcoe_stats;
 172         struct qed_mcp_iscsi_stats iscsi_stats;
 173         struct qed_mcp_rdma_stats rdma_stats;
 174 };
 175
 176 enum qed_ov_eswitch {
 177         QED_OV_ESWITCH_NONE,
 178         QED_OV_ESWITCH_VEB,
 179         QED_OV_ESWITCH_VEPA
 180 };
 181
 182 enum qed_ov_client {
 183         QED_OV_CLIENT_DRV,
 184         QED_OV_CLIENT_USER,
 185         QED_OV_CLIENT_VENDOR_SPEC
 186 };
 187
 188 enum qed_ov_driver_state {
 189         QED_OV_DRIVER_STATE_NOT_LOADED,
 190         QED_OV_DRIVER_STATE_DISABLED,
 191         QED_OV_DRIVER_STATE_ACTIVE
 192 };
 193
 194 enum qed_ov_wol {
 195         QED_OV_WOL_DEFAULT,
 196         QED_OV_WOL_DISABLED,
 197         QED_OV_WOL_ENABLED
 198 };
 199
 200 /**
 201  * @brief - returns the link params of the hw function
 202  *
 203  * @param p_hwfn
 204  *
 205  * @returns pointer to link params
 206  */
 207 struct qed_mcp_link_params *qed_mcp_get_link_params(struct qed_hwfn *);
 208
 209 /**
 210  * @brief - return the link state of the hw function
 211  *
 212  * @param p_hwfn
 213  *
 214  * @returns pointer to link state
 215  */
 216 struct qed_mcp_link_state *qed_mcp_get_link_state(struct qed_hwfn *);
 217
 218 /**
 219  * @brief - return the link capabilities of the hw function
 220  *
 221  * @param p_hwfn
 222  *
 223  * @returns pointer to link capabilities
 224  */
 225 struct qed_mcp_link_capabilities
 226         *qed_mcp_get_link_capabilities(struct qed_hwfn *p_hwfn);
 227
 228 /**
 229  * @brief Request the MFW to set the the link according to 'link_input'.
 230  *
 231  * @param p_hwfn
 232  * @param p_ptt
 233  * @param b_up - raise link if `true'. Reset link if `false'.
 234  *
 235  * @return int
 236  */
 237 int qed_mcp_set_link(struct qed_hwfn   *p_hwfn,
 238                      struct qed_ptt     *p_ptt,
 239                      bool               b_up);
 240
 241 /**
 242  * @brief Get the management firmware version value
 243  *
 244  * @param p_hwfn
 245  * @param p_ptt
 246  * @param p_mfw_ver    - mfw version value
 247  * @param p_running_bundle_id   - image id in nvram; Optional.
 248  *
 249  * @return int - 0 - operation was successful.
 250  */
 251 int qed_mcp_get_mfw_ver(struct qed_hwfn *p_hwfn,
 252                         struct qed_ptt *p_ptt,
 253                         u32 *p_mfw_ver, u32 *p_running_bundle_id);
 254
 255 /**
 256  * @brief Get media type value of the port.
 257  *
 258  * @param cdev      - qed dev pointer
 259  * @param mfw_ver    - media type value
 260  *
 261  * @return int -
 262  *      0 - Operation was successul.
 263  *      -EBUSY - Operation failed
 264  */
 265 int qed_mcp_get_media_type(struct qed_dev      *cdev,
 266                            u32                  *media_type);
 267
 268 /**
 269  * @brief General function for sending commands to the MCP
 270  *        mailbox. It acquire mutex lock for the entire
 271  *        operation, from sending the request until the MCP
 272  *        response. Waiting for MCP response will be checked up
 273  *        to 5 seconds every 5ms.
 274  *
 275  * @param p_hwfn     - hw function
 276  * @param p_ptt      - PTT required for register access
 277  * @param cmd        - command to be sent to the MCP.
 278  * @param param      - Optional param
 279  * @param o_mcp_resp - The MCP response code (exclude sequence).
 280  * @param o_mcp_param- Optional parameter provided by the MCP
 281  *                     response
 282  * @return int - 0 - operation
 283  * was successul.
 284  */
 285 int qed_mcp_cmd(struct qed_hwfn *p_hwfn,
 286                 struct qed_ptt *p_ptt,
 287                 u32 cmd,
 288                 u32 param,
 289                 u32 *o_mcp_resp,
 290                 u32 *o_mcp_param);
 291
 292 /**
 293  * @brief - drains the nig, allowing completion to pass in case of pauses.
 294  *          (Should be called only from sleepable context)
 295  *
 296  * @param p_hwfn
 297  * @param p_ptt
 298  */
 299 int qed_mcp_drain(struct qed_hwfn *p_hwfn,
 300                   struct qed_ptt *p_ptt);
 301
 302 /**
 303  * @brief Get the flash size value
 304  *
 305  * @param p_hwfn
 306  * @param p_ptt
 307  * @param p_flash_size  - flash size in bytes to be filled.
 308  *
 309  * @return int - 0 - operation was successul.
 310  */
 311 int qed_mcp_get_flash_size(struct qed_hwfn     *p_hwfn,
 312                            struct qed_ptt       *p_ptt,
 313                            u32 *p_flash_size);
 314
 315 /**
 316  * @brief Send driver version to MFW
 317  *
 318  * @param p_hwfn
 319  * @param p_ptt
 320  * @param version - Version value
 321  * @param name - Protocol driver name
 322  *
 323  * @return int - 0 - operation was successul.
 324  */
 325 int
 326 qed_mcp_send_drv_version(struct qed_hwfn *p_hwfn,
 327                          struct qed_ptt *p_ptt,
 328                          struct qed_mcp_drv_version *p_ver);
 329
 330 /**
 331  * @brief Notify MFW about the change in base device properties
 332  *
 333  *  @param p_hwfn
 334  *  @param p_ptt
 335  *  @param client - qed client type
 336  *
 337  * @return int - 0 - operation was successful.
 338  */
 339 int qed_mcp_ov_update_current_config(struct qed_hwfn *p_hwfn,
 340                                      struct qed_ptt *p_ptt,
 341                                      enum qed_ov_client client);
 342
 343 /**
 344  * @brief Notify MFW about the driver state
 345  *
 346  *  @param p_hwfn
 347  *  @param p_ptt
 348  *  @param drv_state - Driver state
 349  *
 350  * @return int - 0 - operation was successful.
 351  */
 352 int qed_mcp_ov_update_driver_state(struct qed_hwfn *p_hwfn,
 353                                    struct qed_ptt *p_ptt,
 354                                    enum qed_ov_driver_state drv_state);
 355
 356 /**
 357  * @brief Send MTU size to MFW
 358  *
 359  *  @param p_hwfn
 360  *  @param p_ptt
 361  *  @param mtu - MTU size
 362  *
 363  * @return int - 0 - operation was successful.
 364  */
 365 int qed_mcp_ov_update_mtu(struct qed_hwfn *p_hwfn,
 366                           struct qed_ptt *p_ptt, u16 mtu);
 367
 368 /**
 369  * @brief Send MAC address to MFW
 370  *
 371  *  @param p_hwfn
 372  *  @param p_ptt
 373  *  @param mac - MAC address
 374  *
 375  * @return int - 0 - operation was successful.
 376  */
 377 int qed_mcp_ov_update_mac(struct qed_hwfn *p_hwfn,
 378                           struct qed_ptt *p_ptt, u8 *mac);
 379
 380 /**
 381  * @brief Send WOL mode to MFW
 382  *
 383  *  @param p_hwfn
 384  *  @param p_ptt
 385  *  @param wol - WOL mode
 386  *
 387  * @return int - 0 - operation was successful.
 388  */
 389 int qed_mcp_ov_update_wol(struct qed_hwfn *p_hwfn,
 390                           struct qed_ptt *p_ptt,
 391                           enum qed_ov_wol wol);
 392
 393 /**
 394  * @brief Set LED status
 395  *
 396  *  @param p_hwfn
 397  *  @param p_ptt
 398  *  @param mode - LED mode
 399  *
 400  * @return int - 0 - operation was successful.
 401  */
 402 int qed_mcp_set_led(struct qed_hwfn *p_hwfn,
 403                     struct qed_ptt *p_ptt,
 404                     enum qed_led_mode mode);
 405
 406 /**
 407  * @brief Read from nvm
 408  *
 409  *  @param cdev
 410  *  @param addr - nvm offset
 411  *  @param p_buf - nvm read buffer
 412  *  @param len - buffer len
 413  *
 414  * @return int - 0 - operation was successful.
 415  */
 416 int qed_mcp_nvm_read(struct qed_dev *cdev, u32 addr, u8 *p_buf, u32 len);
 417
 418 /**
 419  * @brief Bist register test
 420  *
 421  *  @param p_hwfn    - hw function
 422  *  @param p_ptt     - PTT required for register access
 423  *
 424  * @return int - 0 - operation was successful.
 425  */
 426 int qed_mcp_bist_register_test(struct qed_hwfn *p_hwfn,
 427                                struct qed_ptt *p_ptt);
 428
 429 /**
 430  * @brief Bist clock test
 431  *
 432  *  @param p_hwfn    - hw function
 433  *  @param p_ptt     - PTT required for register access
 434  *
 435  * @return int - 0 - operation was successful.
 436  */
 437 int qed_mcp_bist_clock_test(struct qed_hwfn *p_hwfn,
 438                             struct qed_ptt *p_ptt);
 439
 440 /**
 441  * @brief Bist nvm test - get number of images
 442  *
 443  *  @param p_hwfn       - hw function
 444  *  @param p_ptt        - PTT required for register access
 445  *  @param num_images   - number of images if operation was
 446  *                        successful. 0 if not.
 447  *
 448  * @return int - 0 - operation was successful.
 449  */
 450 int qed_mcp_bist_nvm_test_get_num_images(struct qed_hwfn *p_hwfn,
 451                                          struct qed_ptt *p_ptt,
 452                                          u32 *num_images);
 453
 454 /**
 455  * @brief Bist nvm test - get image attributes by index
 456  *
 457  *  @param p_hwfn      - hw function
 458  *  @param p_ptt       - PTT required for register access
 459  *  @param p_image_att - Attributes of image
 460  *  @param image_index - Index of image to get information for
 461  *
 462  * @return int - 0 - operation was successful.
 463  */
 464 int qed_mcp_bist_nvm_test_get_image_att(struct qed_hwfn *p_hwfn,
 465                                         struct qed_ptt *p_ptt,
 466                                         struct bist_nvm_image_att *p_image_att,
 467                                         u32 image_index);
 468
 469 /* Using hwfn number (and not pf_num) is required since in CMT mode,
 470  * same pf_num may be used by two different hwfn
 471  * TODO - this shouldn't really be in .h file, but until all fields
 472  * required during hw-init will be placed in their correct place in shmem
 473  * we need it in qed_dev.c [for readin the nvram reflection in shmem].
 474  */
 475 #define MCP_PF_ID_BY_REL(p_hwfn, rel_pfid) (QED_IS_BB((p_hwfn)->cdev) ?        \
 476                                             ((rel_pfid) |                      \
 477                                              ((p_hwfn)->abs_pf_id & 1) << 3) : \
 478                                             rel_pfid)
 479 #define MCP_PF_ID(p_hwfn) MCP_PF_ID_BY_REL(p_hwfn, (p_hwfn)->rel_pf_id)
 480
 481 /* TODO - this is only correct as long as only BB is supported, and
 482  * no port-swapping is implemented; Afterwards we'll need to fix it.
 483  */
 484 #define MFW_PORT(_p_hwfn)       ((_p_hwfn)->abs_pf_id % \
 485                                  ((_p_hwfn)->cdev->num_ports_in_engines * 2))
 486 struct qed_mcp_info {
 487         spinlock_t                              lock;
 488         bool                                    block_mb_sending;
 489         u32                                     public_base;
 490         u32                                     drv_mb_addr;
 491         u32                                     mfw_mb_addr;
 492         u32                                     port_addr;
 493         u16                                     drv_mb_seq;
 494         u16                                     drv_pulse_seq;
 495         struct qed_mcp_link_params              link_input;
 496         struct qed_mcp_link_state               link_output;
 497         struct qed_mcp_link_capabilities        link_capabilities;
 498         struct qed_mcp_function_info            func_info;
 499         u8                                      *mfw_mb_cur;
 500         u8                                      *mfw_mb_shadow;
 501         u16                                     mfw_mb_length;
 502         u16                                     mcp_hist;
 503 };
 504
 505 struct qed_mcp_mb_params {
 506         u32                     cmd;
 507         u32                     param;
 508         union drv_union_data    *p_data_src;
 509         union drv_union_data    *p_data_dst;
 510         u32                     mcp_resp;
 511         u32                     mcp_param;
 512 };
 513
 514 /**
 515  * @brief Initialize the interface with the MCP
 516  *
 517  * @param p_hwfn - HW func
 518  * @param p_ptt - PTT required for register access
 519  *
 520  * @return int
 521  */
 522 int qed_mcp_cmd_init(struct qed_hwfn *p_hwfn,
 523                      struct qed_ptt *p_ptt);
 524
 525 /**
 526  * @brief Initialize the port interface with the MCP
 527  *
 528  * @param p_hwfn
 529  * @param p_ptt
 530  * Can only be called after `num_ports_in_engines' is set
 531  */
 532 void qed_mcp_cmd_port_init(struct qed_hwfn *p_hwfn,
 533                            struct qed_ptt *p_ptt);
 534 /**
 535  * @brief Releases resources allocated during the init process.
 536  *
 537  * @param p_hwfn - HW func
 538  * @param p_ptt - PTT required for register access
 539  *
 540  * @return int
 541  */
 542
 543 int qed_mcp_free(struct qed_hwfn *p_hwfn);
 544
 545 /**
 546  * @brief This function is called from the DPC context. After
 547  * pointing PTT to the mfw mb, check for events sent by the MCP
 548  * to the driver and ack them. In case a critical event
 549  * detected, it will be handled here, otherwise the work will be
 550  * queued to a sleepable work-queue.
 551  *
 552  * @param p_hwfn - HW function
 553  * @param p_ptt - PTT required for register access
 554  * @return int - 0 - operation
 555  * was successul.
 556  */
 557 int qed_mcp_handle_events(struct qed_hwfn *p_hwfn,
 558                           struct qed_ptt *p_ptt);
 559
 560 /**
 561  * @brief Sends a LOAD_REQ to the MFW, and in case operation
 562  *        succeed, returns whether this PF is the first on the
 563  *        chip/engine/port or function. This function should be
 564  *        called when driver is ready to accept MFW events after
 565  *        Storms initializations are done.
 566  *
 567  * @param p_hwfn       - hw function
 568  * @param p_ptt        - PTT required for register access
 569  * @param p_load_code  - The MCP response param containing one
 570  *      of the following:
 571  *      FW_MSG_CODE_DRV_LOAD_ENGINE
 572  *      FW_MSG_CODE_DRV_LOAD_PORT
 573  *      FW_MSG_CODE_DRV_LOAD_FUNCTION
 574  * @return int -
 575  *      0 - Operation was successul.
 576  *      -EBUSY - Operation failed
 577  */
 578 int qed_mcp_load_req(struct qed_hwfn *p_hwfn,
 579                      struct qed_ptt *p_ptt,
 580                      u32 *p_load_code);
 581
 582 /**
 583  * @brief Read the MFW mailbox into Current buffer.
 584  *
 585  * @param p_hwfn
 586  * @param p_ptt
 587  */
 588 void qed_mcp_read_mb(struct qed_hwfn *p_hwfn,
 589                      struct qed_ptt *p_ptt);
 590
 591 /**
 592  * @brief Ack to mfw that driver finished FLR process for VFs
 593  *
 594  * @param p_hwfn
 595  * @param p_ptt
 596  * @param vfs_to_ack - bit mask of all engine VFs for which the PF acks.
 597  *
 598  * @param return int - 0 upon success.
 599  */
 600 int qed_mcp_ack_vf_flr(struct qed_hwfn *p_hwfn,
 601                        struct qed_ptt *p_ptt, u32 *vfs_to_ack);
 602
 603 /**
 604  * @brief - calls during init to read shmem of all function-related info.
 605  *
 606  * @param p_hwfn
 607  *
 608  * @param return 0 upon success.
 609  */
 610 int qed_mcp_fill_shmem_func_info(struct qed_hwfn *p_hwfn,
 611                                  struct qed_ptt *p_ptt);
 612
 613 /**
 614  * @brief - Reset the MCP using mailbox command.
 615  *
 616  * @param p_hwfn
 617  * @param p_ptt
 618  *
 619  * @param return 0 upon success.
 620  */
 621 int qed_mcp_reset(struct qed_hwfn *p_hwfn,
 622                   struct qed_ptt *p_ptt);
 623
 624 /**
 625  * @brief - Sends an NVM read command request to the MFW to get
 626  *        a buffer.
 627  *
 628  * @param p_hwfn
 629  * @param p_ptt
 630  * @param cmd - Command: DRV_MSG_CODE_NVM_GET_FILE_DATA or
 631  *            DRV_MSG_CODE_NVM_READ_NVRAM commands
 632  * @param param - [0:23] - Offset [24:31] - Size
 633  * @param o_mcp_resp - MCP response
 634  * @param o_mcp_param - MCP response param
 635  * @param o_txn_size -  Buffer size output
 636  * @param o_buf - Pointer to the buffer returned by the MFW.
 637  *
 638  * @param return 0 upon success.
 639  */
 640 int qed_mcp_nvm_rd_cmd(struct qed_hwfn *p_hwfn,
 641                        struct qed_ptt *p_ptt,
 642                        u32 cmd,
 643                        u32 param,
 644                        u32 *o_mcp_resp,
 645                        u32 *o_mcp_param, u32 *o_txn_size, u32 *o_buf);
 646
 647 /**
 648  * @brief indicates whether the MFW objects [under mcp_info] are accessible
 649  *
 650  * @param p_hwfn
 651  *
 652  * @return true iff MFW is running and mcp_info is initialized
 653  */
 654 bool qed_mcp_is_init(struct qed_hwfn *p_hwfn);
 655
 656 /**
 657  * @brief request MFW to configure MSI-X for a VF
 658  *
 659  * @param p_hwfn
 660  * @param p_ptt
 661  * @param vf_id - absolute inside engine
 662  * @param num_sbs - number of entries to request
 663  *
 664  * @return int
 665  */
 666 int qed_mcp_config_vf_msix(struct qed_hwfn *p_hwfn,
 667                            struct qed_ptt *p_ptt, u8 vf_id, u8 num);
 668
 669 /**
 670  * @brief - Halt the MCP.
 671  *
 672  * @param p_hwfn
 673  * @param p_ptt
 674  *
 675  * @param return 0 upon success.
 676  */
 677 int qed_mcp_halt(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
 678
 679 /**
 680  * @brief - Wake up the MCP.
 681  *
 682  * @param p_hwfn
 683  * @param p_ptt
 684  *
 685  * @param return 0 upon success.
 686  */
 687 int qed_mcp_resume(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
 688
 689 int qed_configure_pf_min_bandwidth(struct qed_dev *cdev, u8 min_bw);
 690 int qed_configure_pf_max_bandwidth(struct qed_dev *cdev, u8 max_bw);
 691 int __qed_configure_pf_max_bandwidth(struct qed_hwfn *p_hwfn,
 692                                      struct qed_ptt *p_ptt,
 693                                      struct qed_mcp_link_state *p_link,
 694                                      u8 max_bw);
 695 int __qed_configure_pf_min_bandwidth(struct qed_hwfn *p_hwfn,
 696                                      struct qed_ptt *p_ptt,
 697                                      struct qed_mcp_link_state *p_link,
 698                                      u8 min_bw);
 699
 700 int qed_mcp_mask_parities(struct qed_hwfn *p_hwfn,
 701                           struct qed_ptt *p_ptt, u32 mask_parities);
 702
 703 /**
 704  * @brief Send eswitch mode to MFW
 705  *
 706  *  @param p_hwfn
 707  *  @param p_ptt
 708  *  @param eswitch - eswitch mode
 709  *
 710  * @return int - 0 - operation was successful.
 711  */
 712 int qed_mcp_ov_update_eswitch(struct qed_hwfn *p_hwfn,
 713                               struct qed_ptt *p_ptt,
 714                               enum qed_ov_eswitch eswitch);
 715
 716 /**
 717  * @brief - Gets the MFW allocation info for the given resource
 718  *
 719  *  @param p_hwfn
 720  *  @param p_ptt
 721  *  @param p_resc_info - descriptor of requested resource
 722  *  @param p_mcp_resp
 723  *  @param p_mcp_param
 724  *
 725  * @return int - 0 - operation was successful.
 726  */
 727 int qed_mcp_get_resc_info(struct qed_hwfn *p_hwfn,
 728                           struct qed_ptt *p_ptt,
 729                           struct resource_info *p_resc_info,
 730                           u32 *p_mcp_resp, u32 *p_mcp_param);
 731 #endif