Commit | Line | Data |
---|---|---|
4097351a FL |
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, | |
e9bb8af9 | 257 | struct i40iw_dev_hw_stats *hw_stats) |
4097351a FL |
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; | |
e9bb8af9 | 267 | *((struct i40iw_dev_hw_stats *)vchnl_msg_resp->iw_chnl_buf) = *hw_stats; |
4097351a FL |
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 | } | |
f69c3331 | 440 | for (iw_vf_idx = 0; iw_vf_idx < I40IW_MAX_PE_ENABLED_VF_COUNT; iw_vf_idx++) { |
4097351a | 441 | if (!dev->vf_dev[iw_vf_idx]) { |
f69c3331 | 442 | if (first_avail_iw_vf == I40IW_MAX_PE_ENABLED_VF_COUNT) |
4097351a FL |
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--; | |
e9bb8af9 | 542 | vchnl_pf_send_get_pe_stats_resp(dev, vf_id, vchnl_msg, &devstat->hw_stats); |
4097351a FL |
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 | ||
f69c3331 IM |
597 | if (!i40iw_vf_clear_to_send(dev)) |
598 | return I40IW_ERR_TIMEOUT; | |
4097351a FL |
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; | |
f69c3331 | 604 | |
4097351a | 605 | ret_code = vchnl_vf_send_get_ver_req(dev, &vchnl_req); |
f69c3331 | 606 | if (ret_code) { |
4097351a FL |
607 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
608 | "%s Send message failed 0x%0x\n", __func__, ret_code); | |
f69c3331 | 609 | return ret_code; |
4097351a | 610 | } |
f69c3331 IM |
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; | |
4097351a FL |
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 | ||
f69c3331 IM |
629 | if (!i40iw_vf_clear_to_send(dev)) |
630 | return I40IW_ERR_TIMEOUT; | |
4097351a FL |
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; | |
f69c3331 | 636 | |
4097351a | 637 | ret_code = vchnl_vf_send_get_hmc_fcn_req(dev, &vchnl_req); |
f69c3331 | 638 | if (ret_code) { |
4097351a FL |
639 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
640 | "%s Send message failed 0x%0x\n", __func__, ret_code); | |
f69c3331 | 641 | return ret_code; |
4097351a | 642 | } |
f69c3331 IM |
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; | |
4097351a FL |
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 | ||
f69c3331 IM |
665 | if (!i40iw_vf_clear_to_send(dev)) |
666 | return I40IW_ERR_TIMEOUT; | |
4097351a FL |
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; | |
f69c3331 | 670 | |
4097351a FL |
671 | ret_code = vchnl_vf_send_add_hmc_objs_req(dev, |
672 | &vchnl_req, | |
673 | rsrc_type, | |
674 | start_index, | |
675 | rsrc_count); | |
f69c3331 | 676 | if (ret_code) { |
4097351a FL |
677 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
678 | "%s Send message failed 0x%0x\n", __func__, ret_code); | |
f69c3331 | 679 | return ret_code; |
4097351a | 680 | } |
f69c3331 IM |
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; | |
4097351a FL |
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 | ||
f69c3331 IM |
703 | if (!i40iw_vf_clear_to_send(dev)) |
704 | return I40IW_ERR_TIMEOUT; | |
4097351a FL |
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; | |
f69c3331 | 708 | |
4097351a FL |
709 | ret_code = vchnl_vf_send_del_hmc_objs_req(dev, |
710 | &vchnl_req, | |
711 | rsrc_type, | |
712 | start_index, | |
713 | rsrc_count); | |
f69c3331 | 714 | if (ret_code) { |
4097351a FL |
715 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
716 | "%s Send message failed 0x%0x\n", __func__, ret_code); | |
f69c3331 | 717 | return ret_code; |
4097351a | 718 | } |
f69c3331 IM |
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; | |
4097351a FL |
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 | ||
f69c3331 IM |
737 | if (!i40iw_vf_clear_to_send(dev)) |
738 | return I40IW_ERR_TIMEOUT; | |
4097351a FL |
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; | |
f69c3331 | 744 | |
4097351a | 745 | ret_code = vchnl_vf_send_get_pe_stats_req(dev, &vchnl_req); |
f69c3331 | 746 | if (ret_code) { |
4097351a FL |
747 | i40iw_debug(dev, I40IW_DEBUG_VIRT, |
748 | "%s Send message failed 0x%0x\n", __func__, ret_code); | |
f69c3331 | 749 | return ret_code; |
4097351a | 750 | } |
f69c3331 IM |
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; | |
4097351a | 756 | } |