drivers/infiniband/hw/i40iw/i40iw_virtchnl.c

   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  */
  49 static 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  */
  75 static 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  */
 101 static 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  */
 127 static 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  */
 165 static 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  */
 201 static 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  */
 226 static 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
 254 static 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  */
 280 static 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  */
 303 static 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  */
 336 static 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;
 367 add_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  */
 376 static 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);
 400 del_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_vf_init_pestat - Initialize stats for VF
 407  * @devL pointer to the VF Device
 408  * @stats: Statistics structure pointer
 409  * @index: Stats index
 410  */
 411 static void i40iw_vf_init_pestat(struct i40iw_sc_dev *dev, struct i40iw_vsi_pestat *stats, u16 index)
 412 {
 413         stats->hw = dev->hw;
 414         i40iw_hw_stats_init(stats, (u8)index, false);
 415         spin_lock_init(&stats->lock);
 416 }
 417
 418 /**
 419  * i40iw_vchnl_recv_pf - Receive PF virtual channel messages
 420  * @dev: IWARP device pointer
 421  * @vf_id: Virtual function ID associated with the message
 422  * @msg: Virtual channel message buffer pointer
 423  * @len: Length of the virtual channels message
 424  */
 425 enum i40iw_status_code i40iw_vchnl_recv_pf(struct i40iw_sc_dev *dev,
 426                                            u32 vf_id,
 427                                            u8 *msg,
 428                                            u16 len)
 429 {
 430         struct i40iw_virtchnl_op_buf *vchnl_msg = (struct i40iw_virtchnl_op_buf *)msg;
 431         struct i40iw_vfdev *vf_dev = NULL;
 432         struct i40iw_hmc_fcn_info hmc_fcn_info;
 433         u16 iw_vf_idx;
 434         u16 first_avail_iw_vf = I40IW_MAX_PE_ENABLED_VF_COUNT;
 435         struct i40iw_virt_mem vf_dev_mem;
 436         struct i40iw_virtchnl_work_info work_info;
 437         struct i40iw_vsi_pestat *stats;
 438         enum i40iw_status_code ret_code;
 439
 440         if (!dev || !msg || !len)
 441                 return I40IW_ERR_PARAM;
 442
 443         if (!dev->vchnl_up)
 444                 return I40IW_ERR_NOT_READY;
 445         if (vchnl_msg->iw_op_code == I40IW_VCHNL_OP_GET_VER) {
 446                 if (vchnl_msg->iw_op_ver != I40IW_VCHNL_OP_GET_VER_V0)
 447                         vchnl_pf_send_get_ver_resp(dev, vf_id, vchnl_msg);
 448                 else
 449                         vchnl_pf_send_get_ver_resp(dev, vf_id, vchnl_msg);
 450                 return I40IW_SUCCESS;
 451         }
 452         for (iw_vf_idx = 0; iw_vf_idx < I40IW_MAX_PE_ENABLED_VF_COUNT; iw_vf_idx++) {
 453                 if (!dev->vf_dev[iw_vf_idx]) {
 454                         if (first_avail_iw_vf == I40IW_MAX_PE_ENABLED_VF_COUNT)
 455                                 first_avail_iw_vf = iw_vf_idx;
 456                         continue;
 457                 }
 458                 if (dev->vf_dev[iw_vf_idx]->vf_id == vf_id) {
 459                         vf_dev = dev->vf_dev[iw_vf_idx];
 460                         break;
 461                 }
 462         }
 463         if (vf_dev) {
 464                 if (!vf_dev->msg_count) {
 465                         vf_dev->msg_count++;
 466                 } else {
 467                         i40iw_debug(dev, I40IW_DEBUG_VIRT,
 468                                     "VF%u already has a channel message in progress.\n",
 469                                     vf_id);
 470                         return I40IW_SUCCESS;
 471                 }
 472         }
 473         switch (vchnl_msg->iw_op_code) {
 474         case I40IW_VCHNL_OP_GET_HMC_FCN:
 475                 if (!vf_dev &&
 476                     (first_avail_iw_vf != I40IW_MAX_PE_ENABLED_VF_COUNT)) {
 477                         ret_code = i40iw_allocate_virt_mem(dev->hw, &vf_dev_mem, sizeof(struct i40iw_vfdev) +
 478                                                            (sizeof(struct i40iw_hmc_obj_info) * I40IW_HMC_IW_MAX));
 479                         if (!ret_code) {
 480                                 vf_dev = vf_dev_mem.va;
 481                                 vf_dev->stats_initialized = false;
 482                                 vf_dev->pf_dev = dev;
 483                                 vf_dev->msg_count = 1;
 484                                 vf_dev->vf_id = vf_id;
 485                                 vf_dev->iw_vf_idx = first_avail_iw_vf;
 486                                 vf_dev->pf_hmc_initialized = false;
 487                                 vf_dev->hmc_info.hmc_obj = (struct i40iw_hmc_obj_info *)(&vf_dev[1]);
 488                                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 489                                             "vf_dev %p, hmc_info %p, hmc_obj %p\n",
 490                                             vf_dev, &vf_dev->hmc_info, vf_dev->hmc_info.hmc_obj);
 491                                 dev->vf_dev[first_avail_iw_vf] = vf_dev;
 492                                 iw_vf_idx = first_avail_iw_vf;
 493                         } else {
 494                                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 495                                             "VF%u Unable to allocate a VF device structure.\n",
 496                                             vf_id);
 497                                 vchnl_pf_send_error_resp(dev, vf_id, vchnl_msg, (u16)I40IW_ERR_NO_MEMORY);
 498                                 return I40IW_SUCCESS;
 499                         }
 500                         memcpy(&vf_dev->vf_msg_buffer.vchnl_msg, vchnl_msg, len);
 501                         hmc_fcn_info.callback_fcn = pf_cqp_get_hmc_fcn_callback;
 502                         hmc_fcn_info.vf_id = vf_id;
 503                         hmc_fcn_info.iw_vf_idx = vf_dev->iw_vf_idx;
 504                         hmc_fcn_info.cqp_callback_param = vf_dev;
 505                         hmc_fcn_info.free_fcn = false;
 506                         ret_code = i40iw_cqp_manage_hmc_fcn_cmd(dev, &hmc_fcn_info);
 507                         if (ret_code)
 508                                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 509                                             "VF%u error CQP HMC Function operation.\n",
 510                                             vf_id);
 511                         i40iw_vf_init_pestat(dev, &vf_dev->pestat, vf_dev->pmf_index);
 512                         vf_dev->stats_initialized = true;
 513                 } else {
 514                         if (vf_dev) {
 515                                 vf_dev->msg_count--;
 516                                 vchnl_pf_send_get_hmc_fcn_resp(dev, vf_id, vchnl_msg, vf_dev->pmf_index);
 517                         } else {
 518                                 vchnl_pf_send_error_resp(dev, vf_id, vchnl_msg,
 519                                                          (u16)I40IW_ERR_NO_MEMORY);
 520                         }
 521                 }
 522                 break;
 523         case I40IW_VCHNL_OP_ADD_HMC_OBJ_RANGE:
 524                 if (!vf_dev)
 525                         return I40IW_ERR_BAD_PTR;
 526                 work_info.worker_vf_dev = vf_dev;
 527                 work_info.callback_fcn = pf_add_hmc_obj_callback;
 528                 memcpy(&vf_dev->vf_msg_buffer.vchnl_msg, vchnl_msg, len);
 529                 i40iw_cqp_spawn_worker(dev, &work_info, vf_dev->iw_vf_idx);
 530                 break;
 531         case I40IW_VCHNL_OP_DEL_HMC_OBJ_RANGE:
 532                 if (!vf_dev)
 533                         return I40IW_ERR_BAD_PTR;
 534                 work_info.worker_vf_dev = vf_dev;
 535                 work_info.callback_fcn = pf_del_hmc_obj_callback;
 536                 memcpy(&vf_dev->vf_msg_buffer.vchnl_msg, vchnl_msg, len);
 537                 i40iw_cqp_spawn_worker(dev, &work_info, vf_dev->iw_vf_idx);
 538                 break;
 539         case I40IW_VCHNL_OP_GET_STATS:
 540                 if (!vf_dev)
 541                         return I40IW_ERR_BAD_PTR;
 542                 stats = &vf_dev->pestat;
 543                 i40iw_hw_stats_read_all(stats, &stats->hw_stats);
 544                 vf_dev->msg_count--;
 545                 vchnl_pf_send_get_pe_stats_resp(dev, vf_id, vchnl_msg, &stats->hw_stats);
 546                 break;
 547         default:
 548                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 549                             "40iw_vchnl_recv_pf: Invalid OpCode 0x%x\n",
 550                             vchnl_msg->iw_op_code);
 551                 vchnl_pf_send_error_resp(dev, vf_id,
 552                                          vchnl_msg, (u16)I40IW_ERR_NOT_IMPLEMENTED);
 553         }
 554         return I40IW_SUCCESS;
 555 }
 556
 557 /**
 558  * i40iw_vchnl_recv_vf - Receive VF virtual channel messages
 559  * @dev: IWARP device pointer
 560  * @vf_id: Virtual function ID associated with the message
 561  * @msg: Virtual channel message buffer pointer
 562  * @len: Length of the virtual channels message
 563  */
 564 enum i40iw_status_code i40iw_vchnl_recv_vf(struct i40iw_sc_dev *dev,
 565                                            u32 vf_id,
 566                                            u8 *msg,
 567                                            u16 len)
 568 {
 569         struct i40iw_virtchnl_resp_buf *vchnl_msg_resp = (struct i40iw_virtchnl_resp_buf *)msg;
 570         struct i40iw_virtchnl_req *vchnl_req;
 571
 572         vchnl_req = (struct i40iw_virtchnl_req *)(uintptr_t)vchnl_msg_resp->iw_chnl_op_ctx;
 573         vchnl_req->ret_code = (enum i40iw_status_code)vchnl_msg_resp->iw_op_ret_code;
 574         if (len == (sizeof(*vchnl_msg_resp) + vchnl_req->parm_len - 1)) {
 575                 if (vchnl_req->parm_len && vchnl_req->parm)
 576                         memcpy(vchnl_req->parm, vchnl_msg_resp->iw_chnl_buf, vchnl_req->parm_len);
 577                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 578                             "%s: Got response, data size %u\n", __func__,
 579                             vchnl_req->parm_len);
 580         } else {
 581                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 582                             "%s: error length on response, Got %u, expected %u\n", __func__,
 583                             len, (u32)(sizeof(*vchnl_msg_resp) + vchnl_req->parm_len - 1));
 584         }
 585
 586         return I40IW_SUCCESS;
 587 }
 588
 589 /**
 590  * i40iw_vchnl_vf_get_ver - Request Channel version
 591  * @dev: IWARP device pointer
 592  * @vchnl_ver: Virtual channel message version pointer
 593  */
 594 enum i40iw_status_code i40iw_vchnl_vf_get_ver(struct i40iw_sc_dev *dev,
 595                                               u32 *vchnl_ver)
 596 {
 597         struct i40iw_virtchnl_req vchnl_req;
 598         enum i40iw_status_code ret_code;
 599
 600         if (!i40iw_vf_clear_to_send(dev))
 601                 return I40IW_ERR_TIMEOUT;
 602         memset(&vchnl_req, 0, sizeof(vchnl_req));
 603         vchnl_req.dev = dev;
 604         vchnl_req.parm = vchnl_ver;
 605         vchnl_req.parm_len = sizeof(*vchnl_ver);
 606         vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 607
 608         ret_code = vchnl_vf_send_get_ver_req(dev, &vchnl_req);
 609         if (ret_code) {
 610                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 611                             "%s Send message failed 0x%0x\n", __func__, ret_code);
 612                 return ret_code;
 613         }
 614         ret_code = i40iw_vf_wait_vchnl_resp(dev);
 615         if (ret_code)
 616                 return ret_code;
 617         else
 618                 return vchnl_req.ret_code;
 619 }
 620
 621 /**
 622  * i40iw_vchnl_vf_get_hmc_fcn - Request HMC Function
 623  * @dev: IWARP device pointer
 624  * @hmc_fcn: HMC function index pointer
 625  */
 626 enum i40iw_status_code i40iw_vchnl_vf_get_hmc_fcn(struct i40iw_sc_dev *dev,
 627                                                   u16 *hmc_fcn)
 628 {
 629         struct i40iw_virtchnl_req vchnl_req;
 630         enum i40iw_status_code ret_code;
 631
 632         if (!i40iw_vf_clear_to_send(dev))
 633                 return I40IW_ERR_TIMEOUT;
 634         memset(&vchnl_req, 0, sizeof(vchnl_req));
 635         vchnl_req.dev = dev;
 636         vchnl_req.parm = hmc_fcn;
 637         vchnl_req.parm_len = sizeof(*hmc_fcn);
 638         vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 639
 640         ret_code = vchnl_vf_send_get_hmc_fcn_req(dev, &vchnl_req);
 641         if (ret_code) {
 642                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 643                             "%s Send message failed 0x%0x\n", __func__, ret_code);
 644                 return ret_code;
 645         }
 646         ret_code = i40iw_vf_wait_vchnl_resp(dev);
 647         if (ret_code)
 648                 return ret_code;
 649         else
 650                 return vchnl_req.ret_code;
 651 }
 652
 653 /**
 654  * i40iw_vchnl_vf_add_hmc_objs - Add HMC Object
 655  * @dev: IWARP device pointer
 656  * @rsrc_type: HMC Resource type
 657  * @start_index: Starting index of the objects to be added
 658  * @rsrc_count: Number of resources to be added
 659  */
 660 enum i40iw_status_code i40iw_vchnl_vf_add_hmc_objs(struct i40iw_sc_dev *dev,
 661                                                    enum i40iw_hmc_rsrc_type rsrc_type,
 662                                                    u32 start_index,
 663                                                    u32 rsrc_count)
 664 {
 665         struct i40iw_virtchnl_req vchnl_req;
 666         enum i40iw_status_code ret_code;
 667
 668         if (!i40iw_vf_clear_to_send(dev))
 669                 return I40IW_ERR_TIMEOUT;
 670         memset(&vchnl_req, 0, sizeof(vchnl_req));
 671         vchnl_req.dev = dev;
 672         vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 673
 674         ret_code = vchnl_vf_send_add_hmc_objs_req(dev,
 675                                                   &vchnl_req,
 676                                                   rsrc_type,
 677                                                   start_index,
 678                                                   rsrc_count);
 679         if (ret_code) {
 680                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 681                             "%s Send message failed 0x%0x\n", __func__, ret_code);
 682                 return ret_code;
 683         }
 684         ret_code = i40iw_vf_wait_vchnl_resp(dev);
 685         if (ret_code)
 686                 return ret_code;
 687         else
 688                 return vchnl_req.ret_code;
 689 }
 690
 691 /**
 692  * i40iw_vchnl_vf_del_hmc_obj - del HMC obj
 693  * @dev: IWARP device pointer
 694  * @rsrc_type: HMC Resource type
 695  * @start_index: Starting index of the object to delete
 696  * @rsrc_count: Number of resources to be delete
 697  */
 698 enum i40iw_status_code i40iw_vchnl_vf_del_hmc_obj(struct i40iw_sc_dev *dev,
 699                                                   enum i40iw_hmc_rsrc_type rsrc_type,
 700                                                   u32 start_index,
 701                                                   u32 rsrc_count)
 702 {
 703         struct i40iw_virtchnl_req vchnl_req;
 704         enum i40iw_status_code ret_code;
 705
 706         if (!i40iw_vf_clear_to_send(dev))
 707                 return I40IW_ERR_TIMEOUT;
 708         memset(&vchnl_req, 0, sizeof(vchnl_req));
 709         vchnl_req.dev = dev;
 710         vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 711
 712         ret_code = vchnl_vf_send_del_hmc_objs_req(dev,
 713                                                   &vchnl_req,
 714                                                   rsrc_type,
 715                                                   start_index,
 716                                                   rsrc_count);
 717         if (ret_code) {
 718                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 719                             "%s Send message failed 0x%0x\n", __func__, ret_code);
 720                 return ret_code;
 721         }
 722         ret_code = i40iw_vf_wait_vchnl_resp(dev);
 723         if (ret_code)
 724                 return ret_code;
 725         else
 726                 return vchnl_req.ret_code;
 727 }
 728
 729 /**
 730  * i40iw_vchnl_vf_get_pe_stats - Get PE stats
 731  * @dev: IWARP device pointer
 732  * @hw_stats: HW stats struct
 733  */
 734 enum i40iw_status_code i40iw_vchnl_vf_get_pe_stats(struct i40iw_sc_dev *dev,
 735                                                    struct i40iw_dev_hw_stats *hw_stats)
 736 {
 737         struct i40iw_virtchnl_req  vchnl_req;
 738         enum i40iw_status_code ret_code;
 739
 740         if (!i40iw_vf_clear_to_send(dev))
 741                 return I40IW_ERR_TIMEOUT;
 742         memset(&vchnl_req, 0, sizeof(vchnl_req));
 743         vchnl_req.dev = dev;
 744         vchnl_req.parm = hw_stats;
 745         vchnl_req.parm_len = sizeof(*hw_stats);
 746         vchnl_req.vchnl_msg = &dev->vchnl_vf_msg_buf.vchnl_msg;
 747
 748         ret_code = vchnl_vf_send_get_pe_stats_req(dev, &vchnl_req);
 749         if (ret_code) {
 750                 i40iw_debug(dev, I40IW_DEBUG_VIRT,
 751                             "%s Send message failed 0x%0x\n", __func__, ret_code);
 752                 return ret_code;
 753         }
 754         ret_code = i40iw_vf_wait_vchnl_resp(dev);
 755         if (ret_code)
 756                 return ret_code;
 757         else
 758                 return vchnl_req.ret_code;
 759 }