Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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, |
Colin Ian King | e9bb8af | 2016-03-28 12:14:46 +0100 | [diff] [blame] | 257 | struct i40iw_dev_hw_stats *hw_stats) |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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; |
Colin Ian King | e9bb8af | 2016-03-28 12:14:46 +0100 | [diff] [blame] | 267 | *((struct i40iw_dev_hw_stats *)vchnl_msg_resp->iw_chnl_buf) = *hw_stats; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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_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 | */ |
| 412 | enum 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 | } |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 440 | for (iw_vf_idx = 0; iw_vf_idx < I40IW_MAX_PE_ENABLED_VF_COUNT; iw_vf_idx++) { |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 441 | if (!dev->vf_dev[iw_vf_idx]) { |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 442 | if (first_avail_iw_vf == I40IW_MAX_PE_ENABLED_VF_COUNT) |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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--; |
Colin Ian King | e9bb8af | 2016-03-28 12:14:46 +0100 | [diff] [blame] | 542 | vchnl_pf_send_get_pe_stats_resp(dev, vf_id, vchnl_msg, &devstat->hw_stats); |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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 | */ |
| 561 | enum 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 | */ |
| 591 | enum 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 | |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 597 | if (!i40iw_vf_clear_to_send(dev)) |
| 598 | return I40IW_ERR_TIMEOUT; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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; |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 604 | |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 605 | ret_code = vchnl_vf_send_get_ver_req(dev, &vchnl_req); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 606 | if (ret_code) { |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 607 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
| 608 | "%s Send message failed 0x%0x\n", __func__, ret_code); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 609 | return ret_code; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 610 | } |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 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; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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 | */ |
| 623 | enum 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 | |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 629 | if (!i40iw_vf_clear_to_send(dev)) |
| 630 | return I40IW_ERR_TIMEOUT; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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; |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 636 | |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 637 | ret_code = vchnl_vf_send_get_hmc_fcn_req(dev, &vchnl_req); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 638 | if (ret_code) { |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 639 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
| 640 | "%s Send message failed 0x%0x\n", __func__, ret_code); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 641 | return ret_code; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 642 | } |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 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; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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 | */ |
| 657 | enum 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 | |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 665 | if (!i40iw_vf_clear_to_send(dev)) |
| 666 | return I40IW_ERR_TIMEOUT; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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; |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 670 | |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 671 | ret_code = vchnl_vf_send_add_hmc_objs_req(dev, |
| 672 | &vchnl_req, |
| 673 | rsrc_type, |
| 674 | start_index, |
| 675 | rsrc_count); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 676 | if (ret_code) { |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 677 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
| 678 | "%s Send message failed 0x%0x\n", __func__, ret_code); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 679 | return ret_code; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 680 | } |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 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; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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 | */ |
| 695 | enum 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 | |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 703 | if (!i40iw_vf_clear_to_send(dev)) |
| 704 | return I40IW_ERR_TIMEOUT; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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; |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 708 | |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 709 | ret_code = vchnl_vf_send_del_hmc_objs_req(dev, |
| 710 | &vchnl_req, |
| 711 | rsrc_type, |
| 712 | start_index, |
| 713 | rsrc_count); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 714 | if (ret_code) { |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 715 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
| 716 | "%s Send message failed 0x%0x\n", __func__, ret_code); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 717 | return ret_code; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 718 | } |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 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; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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 | */ |
| 731 | enum 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 | |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 737 | if (!i40iw_vf_clear_to_send(dev)) |
| 738 | return I40IW_ERR_TIMEOUT; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 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; |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 744 | |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 745 | ret_code = vchnl_vf_send_get_pe_stats_req(dev, &vchnl_req); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 746 | if (ret_code) { |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 747 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
| 748 | "%s Send message failed 0x%0x\n", __func__, ret_code); |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 749 | return ret_code; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 750 | } |
Ismail, Mustafa | f69c333 | 2016-04-18 10:33:03 -0500 | [diff] [blame] | 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; |
Faisal Latif | 4097351 | 2016-01-20 13:40:14 -0600 | [diff] [blame] | 756 | } |