LXR linux/drivers/infiniband/hw/i40iw/i40iw

   1/*******************************************************************************
   2*
   3* Copyright (c) 2015-2016 Intel Corporation.  All rights reserved.
   4*
   5* This software is available to you under a choice of one of two
   6* licenses.  You may choose to be licensed under the terms of the GNU
   7* General Public License (GPL) Version 2, available from the file
   8* COPYING in the main directory of this source tree, or the
   9* OpenFabrics.org BSD license below:
  10*
  11*   Redistribution and use in source and binary forms, with or
  12*   without modification, are permitted provided that the following
  13*   conditions are met:
  14*
  15*    - Redistributions of source code must retain the above
  16*       copyright notice, this list of conditions and the following
  17*       disclaimer.
  18*
  19*    - Redistributions in binary form must reproduce the above
  20*       copyright notice, this list of conditions and the following
  21*       disclaimer in the documentation and/or other materials
  22*       provided with the distribution.
  23*
  24* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31* SOFTWARE.
  32*
  33*******************************************************************************/
  34
  35#include "i40iw_osdep.h"
  36#include "i40iw_register.h"
  37#include "i40iw_status.h"
  38#include "i40iw_hmc.h"
  39#include "i40iw_d.h"
  40#include "i40iw_type.h"
  41#include "i40iw_p.h"
  42#include "i40iw_virtchnl.h"
  43
  44/**
  45 * vchnl_vf_send_get_ver_req - Request Channel version
  46 * @dev: IWARP device pointer
  47 * @vchnl_req: Virtual channel message request pointer
  48 */
  49static enum i40iw_status_code vchnl_vf_send_get_ver_req(struct i40iw_sc_dev *dev,
  50                                                        struct i40iw_virtchnl_req *vchnl_req)
  51{
  52        enum i40iw_status_code ret_code = I40IW_ERR_NOT_READY;
  53        struct i40iw_virtchnl_op_buf *vchnl_msg = vchnl_req->vchnl_msg;
  54
  55        if (!dev->vchnl_up)
  56                return ret_code;
  57
  58        memset(vchnl_msg, 0, sizeof(*vchnl_msg));
  59        vchnl_msg->iw_chnl_op_ctx = (uintptr_t)vchnl_req;
  60        vchnl_msg->iw_chnl_buf_len = sizeof(*vchnl_msg);
  61        vchnl_msg->iw_op_code = I40IW_VCHNL_OP_GET_VER;
  62        vchnl_msg->iw_op_ver = I40IW_VCHNL_OP_GET_VER_V0;
  63        ret_code = dev->vchnl_if.vchnl_send(dev, 0, (u8 *)vchnl_msg, vchnl_msg->iw_chnl_buf_len);
  64        if (ret_code)
  65                i40iw_debug(dev, I40IW_DEBUG_VIRT,
  66                            "%s: virt channel send failed 0x%x\n", __func__, ret_code);
  67        return ret_code;
  68}
  69
  70/**
  71 * vchnl_vf_send_get_hmc_fcn_req - Request HMC Function from VF
  72 * @dev: IWARP device pointer
  73 * @vchnl_req: Virtual channel message request pointer
  74 */
  75static enum i40iw_status_code vchnl_vf_send_get_hmc_fcn_req(struct i40iw_sc_dev *dev,
  76                                                            struct i40iw_virtchnl_req *vchnl_req)
  77{
  78        enum i40iw_status_code ret_code = I40IW_ERR_NOT_READY;
  79        struct i40iw_virtchnl_op_buf *vchnl_msg = vchnl_req->vchnl_msg;
  80
  81        if (!dev->vchnl_up)
  82                return ret_code;
  83
  84        memset(vchnl_msg, 0, sizeof(*vchnl_msg));
  85        vchnl_msg->iw_chnl_op_ctx = (uintptr_t)vchnl_req;
  86        vchnl_msg->iw_chnl_buf_len = sizeof(*vchnl_msg);
  87        vchnl_msg->iw_op_code = I40IW_VCHNL_OP_GET_HMC_FCN;
  88        vchnl_msg->iw_op_ver = I40IW_VCHNL_OP_GET_HMC_FCN_V0;
  89        ret_code = dev->vchnl_if.vchnl_send(dev, 0, (u8 *)vchnl_msg, vchnl_msg->iw_chnl_buf_len);
  90        if (ret_code)
  91                i40iw_debug(dev, I40IW_DEBUG_VIRT,
  92                            "%s: virt channel send failed 0x%x\n", __func__, ret_code);
  93        return ret_code;
  94}
  95
  96/**
  97 * vchnl_vf_send_get_pe_stats_req - Request PE stats from VF
  98 * @dev: IWARP device pointer
  99 * @vchnl_req: Virtual channel message request pointer
 100 */
 101static enum i40iw_status_code vchnl_vf_send_get_pe_stats_req(struct i40iw_sc_dev *dev,
 102                                                             struct i40iw_virtchnl_req  *vchnl_req)
 103{
 104        enum i40iw_status_code ret_code = I40IW_ERR_NOT_READY;
 105        struct i40iw_virtchnl_op_buf *vchnl_msg = vchnl_req->vchnl_msg;
 106
 107        if (!dev->vchnl_up)
 108                return ret_code;
 109
 110        memset(vchnl_msg, 0, sizeof(*vchnl_msg));
 111        vchnl_msg->iw_chnl_op_ctx = (uintptr_t)vchnl_req;
 112        vchnl_msg->iw_chnl_buf_len = sizeof(*vchnl_msg) + sizeof(struct i40iw_dev_hw_stats) - 1;
 113        vchnl_msg->iw_op_code = I40IW_VCHNL_OP_GET_STATS;
 114        vchnl_msg->iw_op_ver = I40IW_VCHNL_OP_GET_STATS_V0;
 115        ret_code = dev->vchnl_if.vchnl_send(dev, 0, (u8 *)vchnl_msg, vchnl_msg->iw_chnl_buf_len);
 116        if (ret_code)
 117                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 118                            "%s: virt channel send failed 0x%x\n", __func__, ret_code);
 119        return ret_code;
 120}
 121
 122/**
 123 * vchnl_vf_send_add_hmc_objs_req - Add HMC objects
 124 * @dev: IWARP device pointer
 125 * @vchnl_req: Virtual channel message request pointer
 126 */
 127static enum i40iw_status_code vchnl_vf_send_add_hmc_objs_req(struct i40iw_sc_dev *dev,
 128                                                             struct i40iw_virtchnl_req *vchnl_req,
 129                                                             enum i40iw_hmc_rsrc_type rsrc_type,
 130                                                             u32 start_index,
 131                                                             u32 rsrc_count)
 132{
 133        enum i40iw_status_code ret_code = I40IW_ERR_NOT_READY;
 134        struct i40iw_virtchnl_op_buf *vchnl_msg = vchnl_req->vchnl_msg;
 135        struct i40iw_virtchnl_hmc_obj_range *add_hmc_obj;
 136
 137        if (!dev->vchnl_up)
 138                return ret_code;
 139
 140        add_hmc_obj = (struct i40iw_virtchnl_hmc_obj_range *)vchnl_msg->iw_chnl_buf;
 141        memset(vchnl_msg, 0, sizeof(*vchnl_msg));
 142        memset(add_hmc_obj, 0, sizeof(*add_hmc_obj));
 143        vchnl_msg->iw_chnl_op_ctx = (uintptr_t)vchnl_req;
 144        vchnl_msg->iw_chnl_buf_len = sizeof(*vchnl_msg) + sizeof(struct i40iw_virtchnl_hmc_obj_range) - 1;
 145        vchnl_msg->iw_op_code = I40IW_VCHNL_OP_ADD_HMC_OBJ_RANGE;
 146        vchnl_msg->iw_op_ver = I40IW_VCHNL_OP_ADD_HMC_OBJ_RANGE_V0;
 147        add_hmc_obj->obj_type = (u16)rsrc_type;
 148        add_hmc_obj->start_index = start_index;
 149        add_hmc_obj->obj_count = rsrc_count;
 150        ret_code = dev->vchnl_if.vchnl_send(dev, 0, (u8 *)vchnl_msg, vchnl_msg->iw_chnl_buf_len);
 151        if (ret_code)
 152                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 153                            "%s: virt channel send failed 0x%x\n", __func__, ret_code);
 154        return ret_code;
 155}
 156
 157/**
 158 * vchnl_vf_send_del_hmc_objs_req - del HMC objects
 159 * @dev: IWARP device pointer
 160 * @vchnl_req: Virtual channel message request pointer
 161 * @ rsrc_type - resource type to delete
 162 * @ start_index - starting index for resource
 163 * @ rsrc_count - number of resource type to delete
 164 */
 165static enum i40iw_status_code vchnl_vf_send_del_hmc_objs_req(struct i40iw_sc_dev *dev,
 166                                                             struct i40iw_virtchnl_req *vchnl_req,
 167                                                             enum i40iw_hmc_rsrc_type rsrc_type,
 168                                                             u32 start_index,
 169                                                             u32 rsrc_count)
 170{
 171        enum i40iw_status_code ret_code = I40IW_ERR_NOT_READY;
 172        struct i40iw_virtchnl_op_buf *vchnl_msg = vchnl_req->vchnl_msg;
 173        struct i40iw_virtchnl_hmc_obj_range *add_hmc_obj;
 174
 175        if (!dev->vchnl_up)
 176                return ret_code;
 177
 178        add_hmc_obj = (struct i40iw_virtchnl_hmc_obj_range *)vchnl_msg->iw_chnl_buf;
 179        memset(vchnl_msg, 0, sizeof(*vchnl_msg));
 180        memset(add_hmc_obj, 0, sizeof(*add_hmc_obj));
 181        vchnl_msg->iw_chnl_op_ctx = (uintptr_t)vchnl_req;
 182        vchnl_msg->iw_chnl_buf_len = sizeof(*vchnl_msg) + sizeof(struct i40iw_virtchnl_hmc_obj_range) - 1;
 183        vchnl_msg->iw_op_code = I40IW_VCHNL_OP_DEL_HMC_OBJ_RANGE;
 184        vchnl_msg->iw_op_ver = I40IW_VCHNL_OP_DEL_HMC_OBJ_RANGE_V0;
 185        add_hmc_obj->obj_type = (u16)rsrc_type;
 186        add_hmc_obj->start_index = start_index;
 187        add_hmc_obj->obj_count = rsrc_count;
 188        ret_code = dev->vchnl_if.vchnl_send(dev, 0, (u8 *)vchnl_msg, vchnl_msg->iw_chnl_buf_len);
 189        if (ret_code)
 190                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 191                            "%s: virt channel send failed 0x%x\n", __func__, ret_code);
 192        return ret_code;
 193}
 194
 195/**
 196 * vchnl_pf_send_get_ver_resp - Send channel version to VF
 197 * @dev: IWARP device pointer
 198 * @vf_id: Virtual function ID associated with the message
 199 * @vchnl_msg: Virtual channel message buffer pointer
 200 */
 201static void vchnl_pf_send_get_ver_resp(struct i40iw_sc_dev *dev,
 202                                       u32 vf_id,
 203                                       struct i40iw_virtchnl_op_buf *vchnl_msg)
 204{
 205        enum i40iw_status_code ret_code;
 206        u8 resp_buffer[sizeof(struct i40iw_virtchnl_resp_buf) + sizeof(u32) - 1];
 207        struct i40iw_virtchnl_resp_buf *vchnl_msg_resp = (struct i40iw_virtchnl_resp_buf *)resp_buffer;
 208
 209        memset(resp_buffer, 0, sizeof(*resp_buffer));
 210        vchnl_msg_resp->iw_chnl_op_ctx = vchnl_msg->iw_chnl_op_ctx;
 211        vchnl_msg_resp->iw_chnl_buf_len = sizeof(resp_buffer);
 212        vchnl_msg_resp->iw_op_ret_code = I40IW_SUCCESS;
 213        *((u32 *)vchnl_msg_resp->iw_chnl_buf) = I40IW_VCHNL_CHNL_VER_V0;
 214        ret_code = dev->vchnl_if.vchnl_send(dev, vf_id, resp_buffer, sizeof(resp_buffer));
 215        if (ret_code)
 216                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 217                            "%s: virt channel send failed 0x%x\n", __func__, ret_code);
 218}
 219
 220/**
 221 * vchnl_pf_send_get_hmc_fcn_resp - Send HMC Function to VF
 222 * @dev: IWARP device pointer
 223 * @vf_id: Virtual function ID associated with the message
 224 * @vchnl_msg: Virtual channel message buffer pointer
 225 */
 226static void vchnl_pf_send_get_hmc_fcn_resp(struct i40iw_sc_dev *dev,
 227                                           u32 vf_id,
 228                                           struct i40iw_virtchnl_op_buf *vchnl_msg,
 229                                           u16 hmc_fcn)
 230{
 231        enum i40iw_status_code ret_code;
 232        u8 resp_buffer[sizeof(struct i40iw_virtchnl_resp_buf) + sizeof(u16) - 1];
 233        struct i40iw_virtchnl_resp_buf *vchnl_msg_resp = (struct i40iw_virtchnl_resp_buf *)resp_buffer;
 234
 235        memset(resp_buffer, 0, sizeof(*resp_buffer));
 236        vchnl_msg_resp->iw_chnl_op_ctx = vchnl_msg->iw_chnl_op_ctx;
 237        vchnl_msg_resp->iw_chnl_buf_len = sizeof(resp_buffer);
 238        vchnl_msg_resp->iw_op_ret_code = I40IW_SUCCESS;
 239        *((u16 *)vchnl_msg_resp->iw_chnl_buf) = hmc_fcn;
 240        ret_code = dev->vchnl_if.vchnl_send(dev, vf_id, resp_buffer, sizeof(resp_buffer));
 241        if (ret_code)
 242                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 243                            "%s: virt channel send failed 0x%x\n", __func__, ret_code);
 244}
 245
 246/**
 247 * vchnl_pf_send_get_pe_stats_resp - Send PE Stats to VF
 248 * @dev: IWARP device pointer
 249 * @vf_id: Virtual function ID associated with the message
 250 * @vchnl_msg: Virtual channel message buffer pointer
 251 * @hw_stats: HW Stats struct
 252 */
 253
 254static void vchnl_pf_send_get_pe_stats_resp(struct i40iw_sc_dev *dev,
 255                                            u32 vf_id,
 256                                            struct i40iw_virtchnl_op_buf *vchnl_msg,
 257                                            struct i40iw_dev_hw_stats *hw_stats)
 258{
 259        enum i40iw_status_code ret_code;
 260        u8 resp_buffer[sizeof(struct i40iw_virtchnl_resp_buf) + sizeof(struct i40iw_dev_hw_stats) - 1];
 261        struct i40iw_virtchnl_resp_buf *vchnl_msg_resp = (struct i40iw_virtchnl_resp_buf *)resp_buffer;
 262
 263        memset(resp_buffer, 0, sizeof(*resp_buffer));
 264        vchnl_msg_resp->iw_chnl_op_ctx = vchnl_msg->iw_chnl_op_ctx;
 265        vchnl_msg_resp->iw_chnl_buf_len = sizeof(resp_buffer);
 266        vchnl_msg_resp->iw_op_ret_code = I40IW_SUCCESS;
 267        *((struct i40iw_dev_hw_stats *)vchnl_msg_resp->iw_chnl_buf) = *hw_stats;
 268        ret_code = dev->vchnl_if.vchnl_send(dev, vf_id, resp_buffer, sizeof(resp_buffer));
 269        if (ret_code)
 270                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 271                            "%s: virt channel send failed 0x%x\n", __func__, ret_code);
 272}
 273
 274/**
 275 * vchnl_pf_send_error_resp - Send an error response to VF
 276 * @dev: IWARP device pointer
 277 * @vf_id: Virtual function ID associated with the message
 278 * @vchnl_msg: Virtual channel message buffer pointer
 279 */
 280static void vchnl_pf_send_error_resp(struct i40iw_sc_dev *dev, u32 vf_id,
 281                                     struct i40iw_virtchnl_op_buf *vchnl_msg,
 282                                     u16 op_ret_code)
 283{
 284        enum i40iw_status_code ret_code;
 285        u8 resp_buffer[sizeof(struct i40iw_virtchnl_resp_buf)];
 286        struct i40iw_virtchnl_resp_buf *vchnl_msg_resp = (struct i40iw_virtchnl_resp_buf *)resp_buffer;
 287
 288        memset(resp_buffer, 0, sizeof(resp_buffer));
 289        vchnl_msg_resp->iw_chnl_op_ctx = vchnl_msg->iw_chnl_op_ctx;
 290        vchnl_msg_resp->iw_chnl_buf_len = sizeof(resp_buffer);
 291        vchnl_msg_resp->iw_op_ret_code = (u16)op_ret_code;
 292        ret_code = dev->vchnl_if.vchnl_send(dev, vf_id, resp_buffer, sizeof(resp_buffer));
 293        if (ret_code)
 294                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 295                            "%s: virt channel send failed 0x%x\n", __func__, ret_code);
 296}
 297
 298/**
 299 * pf_cqp_get_hmc_fcn_callback - Callback for Get HMC Fcn
 300 * @cqp_req_param: CQP Request param value
 301 * @not_used: unused CQP callback parameter
 302 */
 303static void pf_cqp_get_hmc_fcn_callback(struct i40iw_sc_dev *dev, void *callback_param,
 304                                        struct i40iw_ccq_cqe_info *cqe_info)
 305{
 306        struct i40iw_vfdev *vf_dev = callback_param;
 307        struct i40iw_virt_mem vf_dev_mem;
 308
 309        if (cqe_info->error) {
 310                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 311                            "CQP Completion Error on Get HMC Function.  Maj = 0x%04x, Minor = 0x%04x\n",
 312                            cqe_info->maj_err_code, cqe_info->min_err_code);
 313                dev->vf_dev[vf_dev->iw_vf_idx] = NULL;
 314                vchnl_pf_send_error_resp(dev, vf_dev->vf_id, &vf_dev->vf_msg_buffer.vchnl_msg,
 315                                         (u16)I40IW_ERR_CQP_COMPL_ERROR);
 316                vf_dev_mem.va = vf_dev;
 317                vf_dev_mem.size = sizeof(*vf_dev);
 318                i40iw_free_virt_mem(dev->hw, &vf_dev_mem);
 319        } else {
 320                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 321                            "CQP Completion Operation Return information = 0x%08x\n",
 322                            cqe_info->op_ret_val);
 323                vf_dev->pmf_index = (u16)cqe_info->op_ret_val;
 324                vf_dev->msg_count--;
 325                vchnl_pf_send_get_hmc_fcn_resp(dev,
 326                                               vf_dev->vf_id,
 327                                               &vf_dev->vf_msg_buffer.vchnl_msg,
 328                                               vf_dev->pmf_index);
 329        }
 330}
 331
 332/**
 333 * pf_add_hmc_obj - Callback for Add HMC Object
 334 * @vf_dev: pointer to the VF Device
 335 */
 336static void pf_add_hmc_obj_callback(void *work_vf_dev)
 337{
 338        struct i40iw_vfdev *vf_dev = (struct i40iw_vfdev *)work_vf_dev;
 339        struct i40iw_hmc_info *hmc_info = &vf_dev->hmc_info;
 340        struct i40iw_virtchnl_op_buf *vchnl_msg = &vf_dev->vf_msg_buffer.vchnl_msg;
 341        struct i40iw_hmc_create_obj_info info;
 342        struct i40iw_virtchnl_hmc_obj_range *add_hmc_obj;
 343        enum i40iw_status_code ret_code;
 344
 345        if (!vf_dev->pf_hmc_initialized) {
 346                ret_code = i40iw_pf_init_vfhmc(vf_dev->pf_dev, (u8)vf_dev->pmf_index, NULL);
 347                if (ret_code)
 348                        goto add_out;
 349                vf_dev->pf_hmc_initialized = true;
 350        }
 351
 352        add_hmc_obj = (struct i40iw_virtchnl_hmc_obj_range *)vchnl_msg->iw_chnl_buf;
 353
 354        memset(&info, 0, sizeof(info));
 355        info.hmc_info = hmc_info;
 356        info.is_pf = false;
 357        info.rsrc_type = (u32)add_hmc_obj->obj_type;
 358        info.entry_type = (info.rsrc_type == I40IW_HMC_IW_PBLE) ? I40IW_SD_TYPE_PAGED : I40IW_SD_TYPE_DIRECT;
 359        info.start_idx = add_hmc_obj->start_index;
 360        info.count = add_hmc_obj->obj_count;
 361        i40iw_debug(vf_dev->pf_dev, I40IW_DEBUG_VIRT,
 362                    "I40IW_VCHNL_OP_ADD_HMC_OBJ_RANGE.  Add %u type %u objects\n",
 363                    info.count, info.rsrc_type);
 364        ret_code = i40iw_sc_create_hmc_obj(vf_dev->pf_dev, &info);
 365        if (!ret_code)
 366                vf_dev->hmc_info.hmc_obj[add_hmc_obj->obj_type].cnt = add_hmc_obj->obj_count;
 367add_out:
 368        vf_dev->msg_count--;
 369        vchnl_pf_send_error_resp(vf_dev->pf_dev, vf_dev->vf_id, vchnl_msg, (u16)ret_code);
 370}
 371
 372/**
 373 * pf_del_hmc_obj_callback - Callback for delete HMC Object
 374 * @work_vf_dev: pointer to the VF Device
 375 */
 376static void pf_del_hmc_obj_callback(void *work_vf_dev)
 377{
 378        struct i40iw_vfdev *vf_dev = (struct i40iw_vfdev *)work_vf_dev;
 379        struct i40iw_hmc_info *hmc_info = &vf_dev->hmc_info;
 380        struct i40iw_virtchnl_op_buf *vchnl_msg = &vf_dev->vf_msg_buffer.vchnl_msg;
 381        struct i40iw_hmc_del_obj_info info;
 382        struct i40iw_virtchnl_hmc_obj_range *del_hmc_obj;
 383        enum i40iw_status_code ret_code = I40IW_SUCCESS;
 384
 385        if (!vf_dev->pf_hmc_initialized)
 386                goto del_out;
 387
 388        del_hmc_obj = (struct i40iw_virtchnl_hmc_obj_range *)vchnl_msg->iw_chnl_buf;
 389
 390        memset(&info, 0, sizeof(info));
 391        info.hmc_info = hmc_info;
 392        info.is_pf = false;
 393        info.rsrc_type = (u32)del_hmc_obj->obj_type;
 394        info.start_idx = del_hmc_obj->start_index;
 395        info.count = del_hmc_obj->obj_count;
 396        i40iw_debug(vf_dev->pf_dev, I40IW_DEBUG_VIRT,
 397                    "I40IW_VCHNL_OP_DEL_HMC_OBJ_RANGE.  Delete %u type %u objects\n",
 398                    info.count, info.rsrc_type);
 399        ret_code = i40iw_sc_del_hmc_obj(vf_dev->pf_dev, &info, false);
 400del_out:
 401        vf_dev->msg_count--;
 402        vchnl_pf_send_error_resp(vf_dev->pf_dev, vf_dev->vf_id, vchnl_msg, (u16)ret_code);
 403}
 404
 405/**
 406 * i40iw_vchnl_recv_pf - Receive PF virtual channel messages
 407 * @dev: IWARP device pointer
 408 * @vf_id: Virtual function ID associated with the message
 409 * @msg: Virtual channel message buffer pointer
 410 * @len: Length of the virtual channels message
 411 */
 412enum i40iw_status_code i40iw_vchnl_recv_pf(struct i40iw_sc_dev *dev,
 413                                           u32 vf_id,
 414                                           u8 *msg,
 415                                           u16 len)
 416{
 417        struct i40iw_virtchnl_op_buf *vchnl_msg = (struct i40iw_virtchnl_op_buf *)msg;
 418        struct i40iw_vfdev *vf_dev = NULL;
 419        struct i40iw_hmc_fcn_info hmc_fcn_info;
 420        u16 iw_vf_idx;
 421        u16 first_avail_iw_vf = I40IW_MAX_PE_ENABLED_VF_COUNT;
 422        struct i40iw_virt_mem vf_dev_mem;
 423        struct i40iw_virtchnl_work_info work_info;
 424        struct i40iw_dev_pestat *devstat;
 425        enum i40iw_status_code ret_code;
 426        unsigned long flags;
 427
 428        if (!dev || !msg || !len)
 429                return I40IW_ERR_PARAM;
 430
 431        if (!dev->vchnl_up)
 432                return I40IW_ERR_NOT_READY;
 433        if (vchnl_msg->iw_op_code == I40IW_VCHNL_OP_GET_VER) {
 434                if (vchnl_msg->iw_op_ver != I40IW_VCHNL_OP_GET_VER_V0)
 435                        vchnl_pf_send_get_ver_resp(dev, vf_id, vchnl_msg);
 436                else
 437                        vchnl_pf_send_get_ver_resp(dev, vf_id, vchnl_msg);
 438                return I40IW_SUCCESS;
 439        }
 440        for (iw_vf_idx = 0; iw_vf_idx < I40IW_MAX_PE_ENABLED_VF_COUNT; iw_vf_idx++) {
 441                if (!dev->vf_dev[iw_vf_idx]) {
 442                        if (first_avail_iw_vf == I40IW_MAX_PE_ENABLED_VF_COUNT)
 443                                first_avail_iw_vf = iw_vf_idx;
 444                        continue;
 445                }
 446                if (dev->vf_dev[iw_vf_idx]->vf_id == vf_id) {
 447                        vf_dev = dev->vf_dev[iw_vf_idx];
 448                        break;
 449                }
 450        }
 451        if (vf_dev) {
 452                if (!vf_dev->msg_count) {
 453                        vf_dev->msg_count++;
 454                } else {
 455                        i40iw_debug(dev, I40IW_DEBUG_VIRT,
 456                                    "VF%u already has a channel message in progress.\n",
 457                                    vf_id);
 458                        return I40IW_SUCCESS;
 459                }
 460        }
 461        switch (vchnl_msg->iw_op_code) {
 462        case I40IW_VCHNL_OP_GET_HMC_FCN:
 463                if (!vf_dev &&
 464                    (first_avail_iw_vf != I40IW_MAX_PE_ENABLED_VF_COUNT)) {
 465                        ret_code = i40iw_allocate_virt_mem(dev->hw, &vf_dev_mem, sizeof(struct i40iw_vfdev) +
 466                                                           (sizeof(struct i40iw_hmc_obj_info) * I40IW_HMC_IW_MAX));
 467                        if (!ret_code) {
 468                                vf_dev = vf_dev_mem.va;
 469                                vf_dev->stats_initialized = false;
 470                                vf_dev->pf_dev = dev;
 471                                vf_dev->msg_count = 1;
 472                                vf_dev->vf_id = vf_id;
 473                                vf_dev->iw_vf_idx = first_avail_iw_vf;
 474                                vf_dev->pf_hmc_initialized = false;
 475                                vf_dev->hmc_info.hmc_obj = (struct i40iw_hmc_obj_info *)(&vf_dev[1]);
 476                                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 477                                            "vf_dev %p, hmc_info %p, hmc_obj %p\n",
 478                                            vf_dev, &vf_dev->hmc_info, vf_dev->hmc_info.hmc_obj);
 479                                dev->vf_dev[first_avail_iw_vf] = vf_dev;
 480                                iw_vf_idx = first_avail_iw_vf;
 481                        } else {
 482                                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 483                                            "VF%u Unable to allocate a VF device structure.\n",
 484                                            vf_id);
 485                                vchnl_pf_send_error_resp(dev, vf_id, vchnl_msg, (u16)I40IW_ERR_NO_MEMORY);
 486                                return I40IW_SUCCESS;
 487                        }
 488                        memcpy(&vf_dev->vf_msg_buffer.vchnl_msg, vchnl_msg, len);
 489                        hmc_fcn_info.callback_fcn = pf_cqp_get_hmc_fcn_callback;
 490                        hmc_fcn_info.vf_id = vf_id;
 491                        hmc_fcn_info.iw_vf_idx = vf_dev->iw_vf_idx;
 492                        hmc_fcn_info.cqp_callback_param = vf_dev;
 493                        hmc_fcn_info.free_fcn = false;
 494                        ret_code = i40iw_cqp_manage_hmc_fcn_cmd(dev, &hmc_fcn_info);
 495                        if (ret_code)
 496                                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 497                                            "VF%u error CQP HMC Function operation.\n",
 498                                            vf_id);
 499                        ret_code = i40iw_device_init_pestat(&vf_dev->dev_pestat);
 500                        if (ret_code)
 501                                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 502                                            "VF%u - i40iw_device_init_pestat failed\n",
 503                                            vf_id);
 504                        vf_dev->dev_pestat.ops.iw_hw_stat_init(&vf_dev->dev_pestat,
 505                                                              (u8)vf_dev->pmf_index,
 506                                                              dev->hw, false);
 507                        vf_dev->stats_initialized = true;
 508                } else {
 509                        if (vf_dev) {
 510                                vf_dev->msg_count--;
 511                                vchnl_pf_send_get_hmc_fcn_resp(dev, vf_id, vchnl_msg, vf_dev->pmf_index);
 512                        } else {
 513                                vchnl_pf_send_error_resp(dev, vf_id, vchnl_msg,
 514                                                         (u16)I40IW_ERR_NO_MEMORY);
 515                        }
 516                }
 517                break;
 518        case I40IW_VCHNL_OP_ADD_HMC_OBJ_RANGE:
 519                if (!vf_dev)
 520                        return I40IW_ERR_BAD_PTR;
 521                work_info.worker_vf_dev = vf_dev;
 522                work_info.callback_fcn = pf_add_hmc_obj_callback;
 523                memcpy(&vf_dev->vf_msg_buffer.vchnl_msg, vchnl_msg, len);
 524                i40iw_cqp_spawn_worker(dev, &work_info, vf_dev->iw_vf_idx);
 525                break;
 526        case I40IW_VCHNL_OP_DEL_HMC_OBJ_RANGE:
 527                if (!vf_dev)
 528                        return I40IW_ERR_BAD_PTR;
 529                work_info.worker_vf_dev = vf_dev;
 530                work_info.callback_fcn = pf_del_hmc_obj_callback;
 531                memcpy(&vf_dev->vf_msg_buffer.vchnl_msg, vchnl_msg, len);
 532                i40iw_cqp_spawn_worker(dev, &work_info, vf_dev->iw_vf_idx);
 533                break;
 534        case I40IW_VCHNL_OP_GET_STATS:
 535                if (!vf_dev)
 536                        return I40IW_ERR_BAD_PTR;
 537                devstat = &vf_dev->dev_pestat;
 538                spin_lock_irqsave(&dev->dev_pestat.stats_lock, flags);
 539                devstat->ops.iw_hw_stat_read_all(devstat, &devstat->hw_stats);
 540                spin_unlock_irqrestore(&dev->dev_pestat.stats_lock, flags);
 541                vf_dev->msg_count--;
 542                vchnl_pf_send_get_pe_stats_resp(dev, vf_id, vchnl_msg, &devstat->hw_stats);
 543                break;
 544        default:
 545                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 546                            "40iw_vchnl_recv_pf: Invalid OpCode 0x%x\n",
 547                            vchnl_msg->iw_op_code);
 548                vchnl_pf_send_error_resp(dev, vf_id,
 549                                         vchnl_msg, (u16)I40IW_ERR_NOT_IMPLEMENTED);
 550        }
 551        return I40IW_SUCCESS;
 552}
 553
 554/**
 555 * i40iw_vchnl_recv_vf - Receive VF virtual channel messages
 556 * @dev: IWARP device pointer
 557 * @vf_id: Virtual function ID associated with the message
 558 * @msg: Virtual channel message buffer pointer
 559 * @len: Length of the virtual channels message
 560 */
 561enum i40iw_status_code i40iw_vchnl_recv_vf(struct i40iw_sc_dev *dev,
 562                                           u32 vf_id,
 563                                           u8 *msg,
 564                                           u16 len)
 565{
 566        struct i40iw_virtchnl_resp_buf *vchnl_msg_resp = (struct i40iw_virtchnl_resp_buf *)msg;
 567        struct i40iw_virtchnl_req *vchnl_req;
 568
 569        vchnl_req = (struct i40iw_virtchnl_req *)(uintptr_t)vchnl_msg_resp->iw_chnl_op_ctx;
 570        vchnl_req->ret_code = (enum i40iw_status_code)vchnl_msg_resp->iw_op_ret_code;
 571        if (len == (sizeof(*vchnl_msg_resp) + vchnl_req->parm_len - 1)) {
 572                if (vchnl_req->parm_len && vchnl_req->parm)
 573                        memcpy(vchnl_req->parm, vchnl_msg_resp->iw_chnl_buf, vchnl_req->parm_len);
 574                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 575                            "%s: Got response, data size %u\n", __func__,
 576                            vchnl_req->parm_len);
 577        } else {
 578                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 579                            "%s: error length on response, Got %u, expected %u\n", __func__,
 580                            len, (u32)(sizeof(*vchnl_msg_resp) + vchnl_req->parm_len - 1));
 581        }
 582
 583        return I40IW_SUCCESS;
 584}
 585
 586/**
 587 * i40iw_vchnl_vf_get_ver - Request Channel version
 588 * @dev: IWARP device pointer
 589 * @vchnl_ver: Virtual channel message version pointer
 590 */
 591enum i40iw_status_code i40iw_vchnl_vf_get_ver(struct i40iw_sc_dev *dev,
 592                                              u32 *vchnl_ver)
 593{
 594        struct i40iw_virtchnl_req vchnl_req;
 595        enum i40iw_status_code ret_code;
 596
 597        if (!i40iw_vf_clear_to_send(dev))
 598                return I40IW_ERR_TIMEOUT;
 599        memset(&vchnl_req, 0, sizeof(vchnl_req));
 600        vchnl_req.dev = dev;
 601        vchnl_req.parm = vchnl_ver;
 602        vchnl_req.parm_len = sizeof(*vchnl_ver);
 603        vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 604
 605        ret_code = vchnl_vf_send_get_ver_req(dev, &vchnl_req);
 606        if (ret_code) {
 607                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 608                            "%s Send message failed 0x%0x\n", __func__, ret_code);
 609                return ret_code;
 610        }
 611        ret_code = i40iw_vf_wait_vchnl_resp(dev);
 612        if (ret_code)
 613                return ret_code;
 614        else
 615                return vchnl_req.ret_code;
 616}
 617
 618/**
 619 * i40iw_vchnl_vf_get_hmc_fcn - Request HMC Function
 620 * @dev: IWARP device pointer
 621 * @hmc_fcn: HMC function index pointer
 622 */
 623enum i40iw_status_code i40iw_vchnl_vf_get_hmc_fcn(struct i40iw_sc_dev *dev,
 624                                                  u16 *hmc_fcn)
 625{
 626        struct i40iw_virtchnl_req vchnl_req;
 627        enum i40iw_status_code ret_code;
 628
 629        if (!i40iw_vf_clear_to_send(dev))
 630                return I40IW_ERR_TIMEOUT;
 631        memset(&vchnl_req, 0, sizeof(vchnl_req));
 632        vchnl_req.dev = dev;
 633        vchnl_req.parm = hmc_fcn;
 634        vchnl_req.parm_len = sizeof(*hmc_fcn);
 635        vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 636
 637        ret_code = vchnl_vf_send_get_hmc_fcn_req(dev, &vchnl_req);
 638        if (ret_code) {
 639                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 640                            "%s Send message failed 0x%0x\n", __func__, ret_code);
 641                return ret_code;
 642        }
 643        ret_code = i40iw_vf_wait_vchnl_resp(dev);
 644        if (ret_code)
 645                return ret_code;
 646        else
 647                return vchnl_req.ret_code;
 648}
 649
 650/**
 651 * i40iw_vchnl_vf_add_hmc_objs - Add HMC Object
 652 * @dev: IWARP device pointer
 653 * @rsrc_type: HMC Resource type
 654 * @start_index: Starting index of the objects to be added
 655 * @rsrc_count: Number of resources to be added
 656 */
 657enum i40iw_status_code i40iw_vchnl_vf_add_hmc_objs(struct i40iw_sc_dev *dev,
 658                                                   enum i40iw_hmc_rsrc_type rsrc_type,
 659                                                   u32 start_index,
 660                                                   u32 rsrc_count)
 661{
 662        struct i40iw_virtchnl_req vchnl_req;
 663        enum i40iw_status_code ret_code;
 664
 665        if (!i40iw_vf_clear_to_send(dev))
 666                return I40IW_ERR_TIMEOUT;
 667        memset(&vchnl_req, 0, sizeof(vchnl_req));
 668        vchnl_req.dev = dev;
 669        vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 670
 671        ret_code = vchnl_vf_send_add_hmc_objs_req(dev,
 672                                                  &vchnl_req,
 673                                                  rsrc_type,
 674                                                  start_index,
 675                                                  rsrc_count);
 676        if (ret_code) {
 677                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 678                            "%s Send message failed 0x%0x\n", __func__, ret_code);
 679                return ret_code;
 680        }
 681        ret_code = i40iw_vf_wait_vchnl_resp(dev);
 682        if (ret_code)
 683                return ret_code;
 684        else
 685                return vchnl_req.ret_code;
 686}
 687
 688/**
 689 * i40iw_vchnl_vf_del_hmc_obj - del HMC obj
 690 * @dev: IWARP device pointer
 691 * @rsrc_type: HMC Resource type
 692 * @start_index: Starting index of the object to delete
 693 * @rsrc_count: Number of resources to be delete
 694 */
 695enum i40iw_status_code i40iw_vchnl_vf_del_hmc_obj(struct i40iw_sc_dev *dev,
 696                                                  enum i40iw_hmc_rsrc_type rsrc_type,
 697                                                  u32 start_index,
 698                                                  u32 rsrc_count)
 699{
 700        struct i40iw_virtchnl_req vchnl_req;
 701        enum i40iw_status_code ret_code;
 702
 703        if (!i40iw_vf_clear_to_send(dev))
 704                return I40IW_ERR_TIMEOUT;
 705        memset(&vchnl_req, 0, sizeof(vchnl_req));
 706        vchnl_req.dev = dev;
 707        vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 708
 709        ret_code = vchnl_vf_send_del_hmc_objs_req(dev,
 710                                                  &vchnl_req,
 711                                                  rsrc_type,
 712                                                  start_index,
 713                                                  rsrc_count);
 714        if (ret_code) {
 715                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 716                            "%s Send message failed 0x%0x\n", __func__, ret_code);
 717                return ret_code;
 718        }
 719        ret_code = i40iw_vf_wait_vchnl_resp(dev);
 720        if (ret_code)
 721                return ret_code;
 722        else
 723                return vchnl_req.ret_code;
 724}
 725
 726/**
 727 * i40iw_vchnl_vf_get_pe_stats - Get PE stats
 728 * @dev: IWARP device pointer
 729 * @hw_stats: HW stats struct
 730 */
 731enum i40iw_status_code i40iw_vchnl_vf_get_pe_stats(struct i40iw_sc_dev *dev,
 732                                                   struct i40iw_dev_hw_stats *hw_stats)
 733{
 734        struct i40iw_virtchnl_req  vchnl_req;
 735        enum i40iw_status_code ret_code;
 736
 737        if (!i40iw_vf_clear_to_send(dev))
 738                return I40IW_ERR_TIMEOUT;
 739        memset(&vchnl_req, 0, sizeof(vchnl_req));
 740        vchnl_req.dev = dev;
 741        vchnl_req.parm = hw_stats;
 742        vchnl_req.parm_len = sizeof(*hw_stats);
 743        vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 744
 745        ret_code = vchnl_vf_send_get_pe_stats_req(dev, &vchnl_req);
 746        if (ret_code) {
 747                i40iw_debug(dev, I40IW_DEBUG_VIRT,
 748                            "%s Send message failed 0x%0x\n", __func__, ret_code);
 749                return ret_code;
 750        }
 751        ret_code = i40iw_vf_wait_vchnl_resp(dev);
 752        if (ret_code)
 753                return ret_code;
 754        else
 755                return vchnl_req.ret_code;
 756}
 757