Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (c) 2022 NVIDIA Corporation & Affiliates
3 : : */
4 : :
5 : : #include "mlx5dr_internal.h"
6 : :
7 : : static uint32_t mlx5dr_cmd_get_syndrome(uint32_t *out)
8 : : {
9 : : /* Assumption: syndrome is always the second u32 */
10 : 0 : return be32toh(out[1]);
11 : : }
12 : :
13 : 0 : int mlx5dr_cmd_destroy_obj(struct mlx5dr_devx_obj *devx_obj)
14 : : {
15 : : int ret;
16 : :
17 : 0 : ret = mlx5_glue->devx_obj_destroy(devx_obj->obj);
18 : : simple_free(devx_obj);
19 : :
20 : 0 : return ret;
21 : : }
22 : :
23 : : struct mlx5dr_devx_obj *
24 : 0 : mlx5dr_cmd_flow_table_create(struct ibv_context *ctx,
25 : : struct mlx5dr_cmd_ft_create_attr *ft_attr)
26 : : {
27 : 0 : uint32_t out[MLX5_ST_SZ_DW(create_flow_table_out)] = {0};
28 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_flow_table_in)] = {0};
29 : : struct mlx5dr_devx_obj *devx_obj;
30 : : void *ft_ctx;
31 : :
32 : : devx_obj = simple_malloc(sizeof(*devx_obj));
33 [ # # ]: 0 : if (!devx_obj) {
34 : 0 : DR_LOG(ERR, "Failed to allocate memory for flow table object");
35 : 0 : rte_errno = ENOMEM;
36 : 0 : return NULL;
37 : : }
38 : :
39 [ # # ]: 0 : MLX5_SET(create_flow_table_in, in, opcode, MLX5_CMD_OP_CREATE_FLOW_TABLE);
40 [ # # ]: 0 : MLX5_SET(create_flow_table_in, in, table_type, ft_attr->type);
41 : :
42 : : ft_ctx = MLX5_ADDR_OF(create_flow_table_in, in, flow_table_context);
43 [ # # ]: 0 : MLX5_SET(flow_table_context, ft_ctx, level, ft_attr->level);
44 [ # # ]: 0 : MLX5_SET(flow_table_context, ft_ctx, rtc_valid, ft_attr->rtc_valid);
45 [ # # ]: 0 : MLX5_SET(flow_table_context, ft_ctx, reformat_en, ft_attr->reformat_en);
46 : :
47 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
48 [ # # ]: 0 : if (!devx_obj->obj) {
49 : 0 : DR_LOG(ERR, "Failed to create FT (syndrome: %#x)",
50 : : mlx5dr_cmd_get_syndrome(out));
51 : : simple_free(devx_obj);
52 : 0 : rte_errno = errno;
53 : 0 : return NULL;
54 : : }
55 : :
56 [ # # ]: 0 : devx_obj->id = MLX5_GET(create_flow_table_out, out, table_id);
57 : :
58 : 0 : return devx_obj;
59 : : }
60 : :
61 : : int
62 : 0 : mlx5dr_cmd_flow_table_modify(struct mlx5dr_devx_obj *devx_obj,
63 : : struct mlx5dr_cmd_ft_modify_attr *ft_attr)
64 : : {
65 : 0 : uint32_t out[MLX5_ST_SZ_DW(modify_flow_table_out)] = {0};
66 : 0 : uint32_t in[MLX5_ST_SZ_DW(modify_flow_table_in)] = {0};
67 : : void *ft_ctx;
68 : : int ret;
69 : :
70 : 0 : MLX5_SET(modify_flow_table_in, in, opcode, MLX5_CMD_OP_MODIFY_FLOW_TABLE);
71 : 0 : MLX5_SET(modify_flow_table_in, in, table_type, ft_attr->type);
72 : 0 : MLX5_SET(modify_flow_table_in, in, modify_field_select, ft_attr->modify_fs);
73 : 0 : MLX5_SET(modify_flow_table_in, in, table_id, devx_obj->id);
74 : :
75 : : ft_ctx = MLX5_ADDR_OF(modify_flow_table_in, in, flow_table_context);
76 : :
77 : 0 : MLX5_SET(flow_table_context, ft_ctx, table_miss_action, ft_attr->table_miss_action);
78 : 0 : MLX5_SET(flow_table_context, ft_ctx, table_miss_id, ft_attr->table_miss_id);
79 : 0 : MLX5_SET(flow_table_context, ft_ctx, rtc_id_0, ft_attr->rtc_id_0);
80 : 0 : MLX5_SET(flow_table_context, ft_ctx, rtc_id_1, ft_attr->rtc_id_1);
81 : :
82 : 0 : ret = mlx5_glue->devx_obj_modify(devx_obj->obj, in, sizeof(in), out, sizeof(out));
83 [ # # ]: 0 : if (ret) {
84 : 0 : DR_LOG(ERR, "Failed to modify FT (syndrome: %#x)",
85 : : mlx5dr_cmd_get_syndrome(out));
86 : 0 : rte_errno = errno;
87 : : }
88 : :
89 : 0 : return ret;
90 : : }
91 : :
92 : : int
93 : 0 : mlx5dr_cmd_flow_table_query(struct mlx5dr_devx_obj *devx_obj,
94 : : struct mlx5dr_cmd_ft_query_attr *ft_attr,
95 : : uint64_t *icm_addr_0, uint64_t *icm_addr_1)
96 : : {
97 : 0 : uint32_t out[MLX5_ST_SZ_DW(query_flow_table_out)] = {0};
98 : 0 : uint32_t in[MLX5_ST_SZ_DW(query_flow_table_in)] = {0};
99 : : void *ft_ctx;
100 : : int ret;
101 : :
102 : 0 : MLX5_SET(query_flow_table_in, in, opcode, MLX5_CMD_OP_QUERY_FLOW_TABLE);
103 : 0 : MLX5_SET(query_flow_table_in, in, table_type, ft_attr->type);
104 : 0 : MLX5_SET(query_flow_table_in, in, table_id, devx_obj->id);
105 : :
106 : 0 : ret = mlx5_glue->devx_obj_query(devx_obj->obj, in, sizeof(in), out, sizeof(out));
107 [ # # ]: 0 : if (ret) {
108 : 0 : DR_LOG(ERR, "Failed to query FT (syndrome: %#x)",
109 : : mlx5dr_cmd_get_syndrome(out));
110 : 0 : rte_errno = errno;
111 : 0 : return ret;
112 : : }
113 : :
114 : : ft_ctx = MLX5_ADDR_OF(query_flow_table_out, out, flow_table_context);
115 [ # # ]: 0 : *icm_addr_0 = MLX5_GET64(flow_table_context, ft_ctx, sw_owner_icm_root_0);
116 [ # # ]: 0 : *icm_addr_1 = MLX5_GET64(flow_table_context, ft_ctx, sw_owner_icm_root_1);
117 : :
118 : 0 : return ret;
119 : : }
120 : :
121 : : static struct mlx5dr_devx_obj *
122 : 0 : mlx5dr_cmd_flow_group_create(struct ibv_context *ctx,
123 : : struct mlx5dr_cmd_fg_attr *fg_attr)
124 : : {
125 : 0 : uint32_t out[MLX5_ST_SZ_DW(create_flow_group_out)] = {0};
126 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_flow_group_in)] = {0};
127 : : struct mlx5dr_devx_obj *devx_obj;
128 : :
129 : : devx_obj = simple_malloc(sizeof(*devx_obj));
130 [ # # ]: 0 : if (!devx_obj) {
131 : 0 : DR_LOG(ERR, "Failed to allocate memory for flow group object");
132 : 0 : rte_errno = ENOMEM;
133 : 0 : return NULL;
134 : : }
135 : :
136 [ # # ]: 0 : MLX5_SET(create_flow_group_in, in, opcode, MLX5_CMD_OP_CREATE_FLOW_GROUP);
137 [ # # ]: 0 : MLX5_SET(create_flow_group_in, in, table_type, fg_attr->table_type);
138 [ # # ]: 0 : MLX5_SET(create_flow_group_in, in, table_id, fg_attr->table_id);
139 : :
140 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
141 [ # # ]: 0 : if (!devx_obj->obj) {
142 : 0 : DR_LOG(ERR, "Failed to create Flow group(syndrome: %#x)",
143 : : mlx5dr_cmd_get_syndrome(out));
144 : : simple_free(devx_obj);
145 : 0 : rte_errno = errno;
146 : 0 : return NULL;
147 : : }
148 : :
149 [ # # ]: 0 : devx_obj->id = MLX5_GET(create_flow_group_out, out, group_id);
150 : :
151 : 0 : return devx_obj;
152 : : }
153 : :
154 : : struct mlx5dr_devx_obj *
155 : 0 : mlx5dr_cmd_set_fte(struct ibv_context *ctx,
156 : : uint32_t table_type,
157 : : uint32_t table_id,
158 : : uint32_t group_id,
159 : : struct mlx5dr_cmd_set_fte_attr *fte_attr)
160 : : {
161 : 0 : uint32_t out[MLX5_ST_SZ_DW(set_fte_out)] = {0};
162 : : struct mlx5dr_devx_obj *devx_obj;
163 : : uint32_t dest_entry_sz;
164 : : uint32_t total_dest_sz;
165 : : void *in_flow_context;
166 : : uint32_t action_flags;
167 : : uint8_t *in_dests;
168 : : uint32_t inlen;
169 : : uint32_t *in;
170 : : uint32_t i;
171 : :
172 [ # # ]: 0 : dest_entry_sz = fte_attr->extended_dest ?
173 : : MLX5_ST_SZ_BYTES(extended_dest_format) :
174 : : MLX5_ST_SZ_BYTES(dest_format);
175 : 0 : total_dest_sz = dest_entry_sz * fte_attr->dests_num;
176 : 0 : inlen = align((MLX5_ST_SZ_BYTES(set_fte_in) + total_dest_sz), DW_SIZE);
177 : : in = simple_calloc(1, inlen);
178 [ # # ]: 0 : if (!in) {
179 : 0 : rte_errno = ENOMEM;
180 : 0 : return NULL;
181 : : }
182 : :
183 : : devx_obj = simple_malloc(sizeof(*devx_obj));
184 [ # # ]: 0 : if (!devx_obj) {
185 : 0 : DR_LOG(ERR, "Failed to allocate memory for fte object");
186 : 0 : rte_errno = ENOMEM;
187 : 0 : goto free_in;
188 : : }
189 : :
190 [ # # ]: 0 : MLX5_SET(set_fte_in, in, opcode, MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY);
191 [ # # ]: 0 : MLX5_SET(set_fte_in, in, table_type, table_type);
192 [ # # ]: 0 : MLX5_SET(set_fte_in, in, table_id, table_id);
193 : :
194 : : in_flow_context = MLX5_ADDR_OF(set_fte_in, in, flow_context);
195 [ # # ]: 0 : MLX5_SET(flow_context, in_flow_context, group_id, group_id);
196 [ # # ]: 0 : MLX5_SET(flow_context, in_flow_context, flow_source, fte_attr->flow_source);
197 [ # # ]: 0 : MLX5_SET(flow_context, in_flow_context, extended_destination, fte_attr->extended_dest);
198 [ # # ]: 0 : MLX5_SET(set_fte_in, in, ignore_flow_level, fte_attr->ignore_flow_level);
199 : :
200 : 0 : action_flags = fte_attr->action_flags;
201 [ # # ]: 0 : MLX5_SET(flow_context, in_flow_context, action, action_flags);
202 : :
203 [ # # ]: 0 : if (action_flags & MLX5_FLOW_CONTEXT_ACTION_REFORMAT)
204 [ # # ]: 0 : MLX5_SET(flow_context, in_flow_context,
205 : : packet_reformat_id, fte_attr->packet_reformat_id);
206 : :
207 [ # # ]: 0 : if (action_flags & (MLX5_FLOW_CONTEXT_ACTION_DECRYPT | MLX5_FLOW_CONTEXT_ACTION_ENCRYPT)) {
208 [ # # ]: 0 : MLX5_SET(flow_context, in_flow_context,
209 : : encrypt_decrypt_type, fte_attr->encrypt_decrypt_type);
210 [ # # ]: 0 : MLX5_SET(flow_context, in_flow_context,
211 : : encrypt_decrypt_obj_id, fte_attr->encrypt_decrypt_obj_id);
212 : : }
213 : :
214 [ # # ]: 0 : if (action_flags & MLX5_FLOW_CONTEXT_ACTION_FWD_DEST) {
215 : 0 : in_dests = (uint8_t *)MLX5_ADDR_OF(flow_context, in_flow_context, destination);
216 : :
217 [ # # ]: 0 : for (i = 0; i < fte_attr->dests_num; i++) {
218 : 0 : struct mlx5dr_cmd_set_fte_dest *dest = &fte_attr->dests[i];
219 : :
220 [ # # # ]: 0 : switch (dest->destination_type) {
221 : 0 : case MLX5_FLOW_DESTINATION_TYPE_VPORT:
222 [ # # ]: 0 : if (dest->ext_flags & MLX5DR_CMD_EXT_DEST_ESW_OWNER_VHCA_ID) {
223 [ # # ]: 0 : MLX5_SET(dest_format, in_dests,
224 : : destination_eswitch_owner_vhca_id_valid, 1);
225 [ # # ]: 0 : MLX5_SET(dest_format, in_dests,
226 : : destination_eswitch_owner_vhca_id,
227 : : dest->esw_owner_vhca_id);
228 : : }
229 : : /* Fall through */
230 : : case MLX5_FLOW_DESTINATION_TYPE_TIR:
231 : : case MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE:
232 [ # # ]: 0 : MLX5_SET(dest_format, in_dests, destination_type,
233 : : dest->destination_type);
234 [ # # ]: 0 : MLX5_SET(dest_format, in_dests, destination_id,
235 : : dest->destination_id);
236 [ # # ]: 0 : if (dest->ext_flags & MLX5DR_CMD_EXT_DEST_REFORMAT) {
237 [ # # ]: 0 : MLX5_SET(dest_format, in_dests, packet_reformat, 1);
238 [ # # ]: 0 : MLX5_SET(extended_dest_format, in_dests, packet_reformat_id,
239 : : dest->ext_reformat->id);
240 : : }
241 : : break;
242 : 0 : default:
243 : 0 : rte_errno = EOPNOTSUPP;
244 : 0 : goto free_devx;
245 : : }
246 : :
247 : 0 : in_dests = in_dests + dest_entry_sz;
248 : : }
249 [ # # ]: 0 : MLX5_SET(flow_context, in_flow_context, destination_list_size, fte_attr->dests_num);
250 : : }
251 : :
252 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, inlen, out, sizeof(out));
253 [ # # ]: 0 : if (!devx_obj->obj) {
254 : 0 : DR_LOG(ERR, "Failed to create FTE (syndrome: %#x)",
255 : : mlx5dr_cmd_get_syndrome(out));
256 : 0 : rte_errno = errno;
257 : 0 : goto free_devx;
258 : : }
259 : :
260 : : simple_free(in);
261 : 0 : return devx_obj;
262 : :
263 : 0 : free_devx:
264 : : simple_free(devx_obj);
265 : 0 : free_in:
266 : : simple_free(in);
267 : 0 : return NULL;
268 : : }
269 : :
270 : : struct mlx5dr_cmd_forward_tbl *
271 : 0 : mlx5dr_cmd_forward_tbl_create(struct ibv_context *ctx,
272 : : struct mlx5dr_cmd_ft_create_attr *ft_attr,
273 : : struct mlx5dr_cmd_set_fte_attr *fte_attr)
274 : : {
275 : 0 : struct mlx5dr_cmd_fg_attr fg_attr = {0};
276 : : struct mlx5dr_cmd_forward_tbl *tbl;
277 : :
278 : : tbl = simple_calloc(1, sizeof(*tbl));
279 [ # # ]: 0 : if (!tbl) {
280 : 0 : DR_LOG(ERR, "Failed to allocate memory");
281 : 0 : rte_errno = ENOMEM;
282 : 0 : return NULL;
283 : : }
284 : :
285 : 0 : tbl->ft = mlx5dr_cmd_flow_table_create(ctx, ft_attr);
286 [ # # ]: 0 : if (!tbl->ft) {
287 : 0 : DR_LOG(ERR, "Failed to create FT");
288 : 0 : goto free_tbl;
289 : : }
290 : :
291 : 0 : fg_attr.table_id = tbl->ft->id;
292 : 0 : fg_attr.table_type = ft_attr->type;
293 : :
294 : 0 : tbl->fg = mlx5dr_cmd_flow_group_create(ctx, &fg_attr);
295 [ # # ]: 0 : if (!tbl->fg) {
296 : 0 : DR_LOG(ERR, "Failed to create FG");
297 : 0 : goto free_ft;
298 : : }
299 : :
300 : 0 : tbl->fte = mlx5dr_cmd_set_fte(ctx, ft_attr->type, tbl->ft->id, tbl->fg->id, fte_attr);
301 [ # # ]: 0 : if (!tbl->fte) {
302 : 0 : DR_LOG(ERR, "Failed to create FTE");
303 : 0 : goto free_fg;
304 : : }
305 : : return tbl;
306 : :
307 : : free_fg:
308 : 0 : mlx5dr_cmd_destroy_obj(tbl->fg);
309 : 0 : free_ft:
310 : 0 : mlx5dr_cmd_destroy_obj(tbl->ft);
311 : 0 : free_tbl:
312 : : simple_free(tbl);
313 : 0 : return NULL;
314 : : }
315 : :
316 : 0 : void mlx5dr_cmd_forward_tbl_destroy(struct mlx5dr_cmd_forward_tbl *tbl)
317 : : {
318 : 0 : mlx5dr_cmd_destroy_obj(tbl->fte);
319 : 0 : mlx5dr_cmd_destroy_obj(tbl->fg);
320 : 0 : mlx5dr_cmd_destroy_obj(tbl->ft);
321 : : simple_free(tbl);
322 : 0 : }
323 : :
324 : 0 : void mlx5dr_cmd_set_attr_connect_miss_tbl(struct mlx5dr_context *ctx,
325 : : uint32_t fw_ft_type,
326 : : enum mlx5dr_table_type type,
327 : : struct mlx5dr_cmd_ft_modify_attr *ft_attr)
328 : : {
329 : : struct mlx5dr_devx_obj *default_miss_tbl;
330 : :
331 [ # # # # ]: 0 : if (type != MLX5DR_TABLE_TYPE_FDB && !mlx5dr_context_shared_gvmi_used(ctx))
332 : : return;
333 : :
334 : 0 : ft_attr->modify_fs = MLX5_IFC_MODIFY_FLOW_TABLE_MISS_ACTION;
335 : 0 : ft_attr->type = fw_ft_type;
336 : 0 : ft_attr->table_miss_action = MLX5_IFC_MODIFY_FLOW_TABLE_MISS_ACTION_GOTO_TBL;
337 : :
338 [ # # ]: 0 : if (type == MLX5DR_TABLE_TYPE_FDB) {
339 : 0 : default_miss_tbl = ctx->common_res[type].default_miss->ft;
340 [ # # ]: 0 : if (!default_miss_tbl) {
341 : 0 : assert(false);
342 : : return;
343 : : }
344 : 0 : ft_attr->table_miss_id = default_miss_tbl->id;
345 : : } else {
346 : 0 : ft_attr->table_miss_id = ctx->gvmi_res[type].aliased_end_ft->id;
347 : : }
348 : : }
349 : :
350 : : struct mlx5dr_devx_obj *
351 : 0 : mlx5dr_cmd_rtc_create(struct ibv_context *ctx,
352 : : struct mlx5dr_cmd_rtc_create_attr *rtc_attr)
353 : : {
354 : 0 : uint32_t out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)] = {0};
355 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_rtc_in)] = {0};
356 : : struct mlx5dr_devx_obj *devx_obj;
357 : : void *attr;
358 : :
359 : : devx_obj = simple_malloc(sizeof(*devx_obj));
360 [ # # ]: 0 : if (!devx_obj) {
361 : 0 : DR_LOG(ERR, "Failed to allocate memory for RTC object");
362 : 0 : rte_errno = ENOMEM;
363 : 0 : return NULL;
364 : : }
365 : :
366 : : attr = MLX5_ADDR_OF(create_rtc_in, in, hdr);
367 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
368 : : attr, opcode, MLX5_CMD_OP_CREATE_GENERAL_OBJECT);
369 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
370 : : attr, obj_type, MLX5_GENERAL_OBJ_TYPE_RTC);
371 : :
372 : : attr = MLX5_ADDR_OF(create_rtc_in, in, rtc);
373 [ # # # # ]: 0 : MLX5_SET(rtc, attr, ste_format_0, rtc_attr->is_frst_jumbo ?
374 : : MLX5_IFC_RTC_STE_FORMAT_11DW :
375 : : MLX5_IFC_RTC_STE_FORMAT_8DW);
376 : :
377 [ # # ]: 0 : if (rtc_attr->is_scnd_range) {
378 [ # # ]: 0 : MLX5_SET(rtc, attr, ste_format_1, MLX5_IFC_RTC_STE_FORMAT_RANGE);
379 [ # # ]: 0 : MLX5_SET(rtc, attr, num_match_ste, 2);
380 : : }
381 : :
382 [ # # ]: 0 : MLX5_SET(rtc, attr, pd, rtc_attr->pd);
383 [ # # ]: 0 : MLX5_SET(rtc, attr, update_method, rtc_attr->fw_gen_wqe);
384 [ # # ]: 0 : MLX5_SET(rtc, attr, update_index_mode, rtc_attr->update_index_mode);
385 [ # # ]: 0 : MLX5_SET(rtc, attr, access_index_mode, rtc_attr->access_index_mode);
386 [ # # ]: 0 : MLX5_SET(rtc, attr, num_hash_definer, rtc_attr->num_hash_definer);
387 [ # # ]: 0 : MLX5_SET(rtc, attr, log_depth, rtc_attr->log_depth);
388 [ # # ]: 0 : MLX5_SET(rtc, attr, log_hash_size, rtc_attr->log_size);
389 [ # # ]: 0 : MLX5_SET(rtc, attr, table_type, rtc_attr->table_type);
390 [ # # ]: 0 : MLX5_SET(rtc, attr, num_hash_definer, rtc_attr->num_hash_definer);
391 [ # # ]: 0 : MLX5_SET(rtc, attr, match_definer_0, rtc_attr->match_definer_0);
392 [ # # ]: 0 : MLX5_SET(rtc, attr, match_definer_1, rtc_attr->match_definer_1);
393 [ # # ]: 0 : MLX5_SET(rtc, attr, stc_id, rtc_attr->stc_base);
394 [ # # ]: 0 : MLX5_SET(rtc, attr, ste_table_base_id, rtc_attr->ste_base);
395 [ # # ]: 0 : MLX5_SET(rtc, attr, ste_table_offset, rtc_attr->ste_offset);
396 [ # # ]: 0 : MLX5_SET(rtc, attr, miss_flow_table_id, rtc_attr->miss_ft_id);
397 [ # # ]: 0 : MLX5_SET(rtc, attr, reparse_mode, rtc_attr->reparse_mode);
398 : :
399 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
400 [ # # ]: 0 : if (!devx_obj->obj) {
401 : 0 : DR_LOG(ERR, "Failed to create RTC (syndrome: %#x)",
402 : : mlx5dr_cmd_get_syndrome(out));
403 : : simple_free(devx_obj);
404 : 0 : rte_errno = errno;
405 : 0 : return NULL;
406 : : }
407 : :
408 [ # # ]: 0 : devx_obj->id = MLX5_GET(general_obj_out_cmd_hdr, out, obj_id);
409 : :
410 : 0 : return devx_obj;
411 : : }
412 : :
413 : : struct mlx5dr_devx_obj *
414 : 0 : mlx5dr_cmd_stc_create(struct ibv_context *ctx,
415 : : struct mlx5dr_cmd_stc_create_attr *stc_attr)
416 : : {
417 : 0 : uint32_t out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)] = {0};
418 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_stc_in)] = {0};
419 : : struct mlx5dr_devx_obj *devx_obj;
420 : : void *attr;
421 : :
422 : : devx_obj = simple_malloc(sizeof(*devx_obj));
423 [ # # ]: 0 : if (!devx_obj) {
424 : 0 : DR_LOG(ERR, "Failed to allocate memory for STC object");
425 : 0 : rte_errno = ENOMEM;
426 : 0 : return NULL;
427 : : }
428 : :
429 : : attr = MLX5_ADDR_OF(create_stc_in, in, hdr);
430 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
431 : : attr, opcode, MLX5_CMD_OP_CREATE_GENERAL_OBJECT);
432 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
433 : : attr, obj_type, MLX5_GENERAL_OBJ_TYPE_STC);
434 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
435 : : attr, log_obj_range, stc_attr->log_obj_range);
436 : :
437 : : attr = MLX5_ADDR_OF(create_stc_in, in, stc);
438 [ # # ]: 0 : MLX5_SET(stc, attr, table_type, stc_attr->table_type);
439 : :
440 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
441 [ # # ]: 0 : if (!devx_obj->obj) {
442 : 0 : DR_LOG(ERR, "Failed to create STC (syndrome: %#x)",
443 : : mlx5dr_cmd_get_syndrome(out));
444 : : simple_free(devx_obj);
445 : 0 : rte_errno = errno;
446 : 0 : return NULL;
447 : : }
448 : :
449 [ # # ]: 0 : devx_obj->id = MLX5_GET(general_obj_out_cmd_hdr, out, obj_id);
450 : :
451 : 0 : return devx_obj;
452 : : }
453 : :
454 : : static int
455 : 0 : mlx5dr_cmd_stc_modify_set_stc_param(struct mlx5dr_cmd_stc_modify_attr *stc_attr,
456 : : void *stc_parm)
457 : : {
458 [ # # # # : 0 : switch (stc_attr->action_type) {
# # # # #
# # # # ]
459 : 0 : case MLX5_IFC_STC_ACTION_TYPE_COUNTER:
460 [ # # ]: 0 : MLX5_SET(stc_ste_param_flow_counter, stc_parm, flow_counter_id, stc_attr->id);
461 : 0 : break;
462 : 0 : case MLX5_IFC_STC_ACTION_TYPE_JUMP_TO_TIR:
463 [ # # ]: 0 : MLX5_SET(stc_ste_param_tir, stc_parm, tirn, stc_attr->dest_tir_num);
464 : 0 : break;
465 : 0 : case MLX5_IFC_STC_ACTION_TYPE_JUMP_TO_FT:
466 [ # # ]: 0 : MLX5_SET(stc_ste_param_table, stc_parm, table_id, stc_attr->dest_table_id);
467 : 0 : break;
468 : 0 : case MLX5_IFC_STC_ACTION_TYPE_ACC_MODIFY_LIST:
469 [ # # ]: 0 : MLX5_SET(stc_ste_param_header_modify_list, stc_parm,
470 : : header_modify_pattern_id, stc_attr->modify_header.pattern_id);
471 [ # # ]: 0 : MLX5_SET(stc_ste_param_header_modify_list, stc_parm,
472 : : header_modify_argument_id, stc_attr->modify_header.arg_id);
473 : 0 : break;
474 : 0 : case MLX5_IFC_STC_ACTION_TYPE_HEADER_REMOVE:
475 [ # # ]: 0 : MLX5_SET(stc_ste_param_remove, stc_parm, action_type,
476 : : MLX5_MODIFICATION_TYPE_REMOVE);
477 [ # # ]: 0 : MLX5_SET(stc_ste_param_remove, stc_parm, decap,
478 : : stc_attr->remove_header.decap);
479 [ # # ]: 0 : MLX5_SET(stc_ste_param_remove, stc_parm, remove_start_anchor,
480 : : stc_attr->remove_header.start_anchor);
481 [ # # ]: 0 : MLX5_SET(stc_ste_param_remove, stc_parm, remove_end_anchor,
482 : : stc_attr->remove_header.end_anchor);
483 : 0 : break;
484 : 0 : case MLX5_IFC_STC_ACTION_TYPE_HEADER_INSERT:
485 [ # # ]: 0 : MLX5_SET(stc_ste_param_insert, stc_parm, action_type,
486 : : MLX5_MODIFICATION_TYPE_INSERT);
487 [ # # ]: 0 : MLX5_SET(stc_ste_param_insert, stc_parm, encap,
488 : : stc_attr->insert_header.encap);
489 [ # # ]: 0 : MLX5_SET(stc_ste_param_insert, stc_parm, inline_data,
490 : : stc_attr->insert_header.is_inline);
491 [ # # ]: 0 : MLX5_SET(stc_ste_param_insert, stc_parm, insert_anchor,
492 : : stc_attr->insert_header.insert_anchor);
493 : : /* HW gets the next 2 sizes in words */
494 [ # # ]: 0 : MLX5_SET(stc_ste_param_insert, stc_parm, insert_size,
495 : : stc_attr->insert_header.header_size / W_SIZE);
496 [ # # ]: 0 : MLX5_SET(stc_ste_param_insert, stc_parm, insert_offset,
497 : : stc_attr->insert_header.insert_offset / W_SIZE);
498 [ # # ]: 0 : MLX5_SET(stc_ste_param_insert, stc_parm, insert_argument,
499 : : stc_attr->insert_header.arg_id);
500 : 0 : break;
501 : 0 : case MLX5_IFC_STC_ACTION_TYPE_COPY:
502 : : case MLX5_IFC_STC_ACTION_TYPE_SET:
503 : : case MLX5_IFC_STC_ACTION_TYPE_ADD:
504 : : case MLX5_IFC_STC_ACTION_TYPE_ADD_FIELD:
505 : 0 : *(__be64 *)stc_parm = stc_attr->modify_action.data;
506 : 0 : break;
507 : 0 : case MLX5_IFC_STC_ACTION_TYPE_JUMP_TO_VPORT:
508 : : case MLX5_IFC_STC_ACTION_TYPE_JUMP_TO_UPLINK:
509 [ # # ]: 0 : MLX5_SET(stc_ste_param_vport, stc_parm, vport_number,
510 : : stc_attr->vport.vport_num);
511 [ # # ]: 0 : MLX5_SET(stc_ste_param_vport, stc_parm, eswitch_owner_vhca_id,
512 : : stc_attr->vport.esw_owner_vhca_id);
513 [ # # ]: 0 : MLX5_SET(stc_ste_param_vport, stc_parm, eswitch_owner_vhca_id_valid, 1);
514 : 0 : break;
515 : : case MLX5_IFC_STC_ACTION_TYPE_DROP:
516 : : case MLX5_IFC_STC_ACTION_TYPE_NOP:
517 : : case MLX5_IFC_STC_ACTION_TYPE_TAG:
518 : : case MLX5_IFC_STC_ACTION_TYPE_ALLOW:
519 : : break;
520 : 0 : case MLX5_IFC_STC_ACTION_TYPE_ASO:
521 [ # # ]: 0 : MLX5_SET(stc_ste_param_execute_aso, stc_parm, aso_object_id,
522 : : stc_attr->aso.devx_obj_id);
523 [ # # ]: 0 : MLX5_SET(stc_ste_param_execute_aso, stc_parm, return_reg_id,
524 : : stc_attr->aso.return_reg_id);
525 [ # # ]: 0 : MLX5_SET(stc_ste_param_execute_aso, stc_parm, aso_type,
526 : : stc_attr->aso.aso_type);
527 : 0 : break;
528 : 0 : case MLX5_IFC_STC_ACTION_TYPE_JUMP_TO_STE_TABLE:
529 [ # # ]: 0 : MLX5_SET(stc_ste_param_ste_table, stc_parm, ste_obj_id,
530 : : stc_attr->ste_table.ste_obj_id);
531 [ # # ]: 0 : MLX5_SET(stc_ste_param_ste_table, stc_parm, match_definer_id,
532 : : stc_attr->ste_table.match_definer_id);
533 [ # # ]: 0 : MLX5_SET(stc_ste_param_ste_table, stc_parm, log_hash_size,
534 : : stc_attr->ste_table.log_hash_size);
535 : 0 : break;
536 : 0 : case MLX5_IFC_STC_ACTION_TYPE_REMOVE_WORDS:
537 [ # # ]: 0 : MLX5_SET(stc_ste_param_remove_words, stc_parm, action_type,
538 : : MLX5_MODIFICATION_TYPE_REMOVE_WORDS);
539 [ # # ]: 0 : MLX5_SET(stc_ste_param_remove_words, stc_parm, remove_start_anchor,
540 : : stc_attr->remove_words.start_anchor);
541 [ # # ]: 0 : MLX5_SET(stc_ste_param_remove_words, stc_parm,
542 : : remove_size, stc_attr->remove_words.num_of_words);
543 : 0 : break;
544 : 0 : default:
545 : 0 : DR_LOG(ERR, "Not supported type %d", stc_attr->action_type);
546 : 0 : rte_errno = EINVAL;
547 : 0 : return rte_errno;
548 : : }
549 : : return 0;
550 : : }
551 : :
552 : : int
553 : 0 : mlx5dr_cmd_stc_modify(struct mlx5dr_devx_obj *devx_obj,
554 : : struct mlx5dr_cmd_stc_modify_attr *stc_attr)
555 : : {
556 : 0 : uint32_t out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)] = {0};
557 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_stc_in)] = {0};
558 : : void *stc_parm;
559 : : void *attr;
560 : : int ret;
561 : :
562 : : attr = MLX5_ADDR_OF(create_stc_in, in, hdr);
563 : 0 : MLX5_SET(general_obj_in_cmd_hdr,
564 : : attr, opcode, MLX5_CMD_OP_MODIFY_GENERAL_OBJECT);
565 : 0 : MLX5_SET(general_obj_in_cmd_hdr,
566 : : attr, obj_type, MLX5_GENERAL_OBJ_TYPE_STC);
567 : 0 : MLX5_SET(general_obj_in_cmd_hdr, in, obj_id, devx_obj->id);
568 : 0 : MLX5_SET(general_obj_in_cmd_hdr, in, obj_offset, stc_attr->stc_offset);
569 : :
570 : : attr = MLX5_ADDR_OF(create_stc_in, in, stc);
571 : 0 : MLX5_SET(stc, attr, ste_action_offset, stc_attr->action_offset);
572 [ # # ]: 0 : MLX5_SET(stc, attr, action_type, stc_attr->action_type);
573 [ # # ]: 0 : MLX5_SET(stc, attr, reparse_mode, stc_attr->reparse_mode);
574 : 0 : MLX5_SET64(stc, attr, modify_field_select,
575 : : MLX5_IFC_MODIFY_STC_FIELD_SELECT_NEW_STC);
576 : :
577 : : /* Set destination TIRN, TAG, FT ID, STE ID */
578 : : stc_parm = MLX5_ADDR_OF(stc, attr, stc_param);
579 : 0 : ret = mlx5dr_cmd_stc_modify_set_stc_param(stc_attr, stc_parm);
580 [ # # ]: 0 : if (ret)
581 : : return ret;
582 : :
583 : 0 : ret = mlx5_glue->devx_obj_modify(devx_obj->obj, in, sizeof(in), out, sizeof(out));
584 [ # # ]: 0 : if (ret) {
585 : 0 : DR_LOG(ERR, "Failed to modify STC FW action_type %d (syndrome: %#x)",
586 : : stc_attr->action_type, mlx5dr_cmd_get_syndrome(out));
587 : 0 : rte_errno = errno;
588 : : }
589 : :
590 : : return ret;
591 : : }
592 : :
593 : : struct mlx5dr_devx_obj *
594 : 0 : mlx5dr_cmd_arg_create(struct ibv_context *ctx,
595 : : uint16_t log_obj_range,
596 : : uint32_t pd)
597 : : {
598 : 0 : uint32_t out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)] = {0};
599 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_arg_in)] = {0};
600 : : struct mlx5dr_devx_obj *devx_obj;
601 : : void *attr;
602 : :
603 : : devx_obj = simple_malloc(sizeof(*devx_obj));
604 [ # # ]: 0 : if (!devx_obj) {
605 : 0 : DR_LOG(ERR, "Failed to allocate memory for ARG object");
606 : 0 : rte_errno = ENOMEM;
607 : 0 : return NULL;
608 : : }
609 : :
610 : : attr = MLX5_ADDR_OF(create_arg_in, in, hdr);
611 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
612 : : attr, opcode, MLX5_CMD_OP_CREATE_GENERAL_OBJECT);
613 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
614 : : attr, obj_type, MLX5_GENERAL_OBJ_TYPE_ARG);
615 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
616 : : attr, log_obj_range, log_obj_range);
617 : :
618 : : attr = MLX5_ADDR_OF(create_arg_in, in, arg);
619 [ # # ]: 0 : MLX5_SET(arg, attr, access_pd, pd);
620 : :
621 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
622 [ # # ]: 0 : if (!devx_obj->obj) {
623 : 0 : DR_LOG(ERR, "Failed to create ARG (syndrome: %#x)",
624 : : mlx5dr_cmd_get_syndrome(out));
625 : : simple_free(devx_obj);
626 : 0 : rte_errno = errno;
627 : 0 : return NULL;
628 : : }
629 : :
630 [ # # ]: 0 : devx_obj->id = MLX5_GET(general_obj_out_cmd_hdr, out, obj_id);
631 : :
632 : 0 : return devx_obj;
633 : : }
634 : :
635 : : struct mlx5dr_devx_obj *
636 : 0 : mlx5dr_cmd_header_modify_pattern_create(struct ibv_context *ctx,
637 : : uint32_t pattern_length,
638 : : uint8_t *actions)
639 : : {
640 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_header_modify_pattern_in)] = {0};
641 : 0 : uint32_t out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)] = {0};
642 : : struct mlx5dr_devx_obj *devx_obj;
643 : : uint64_t *pattern_data;
644 : : int num_of_actions;
645 : : void *pattern;
646 : : void *attr;
647 : : int i;
648 : :
649 [ # # ]: 0 : if (pattern_length > MAX_ACTIONS_DATA_IN_HEADER_MODIFY) {
650 : 0 : DR_LOG(ERR, "Pattern length %d exceeds limit %d",
651 : : pattern_length, MAX_ACTIONS_DATA_IN_HEADER_MODIFY);
652 : 0 : rte_errno = EINVAL;
653 : 0 : return NULL;
654 : : }
655 : :
656 : : devx_obj = simple_malloc(sizeof(*devx_obj));
657 [ # # ]: 0 : if (!devx_obj) {
658 : 0 : DR_LOG(ERR, "Failed to allocate memory for header_modify_pattern object");
659 : 0 : rte_errno = ENOMEM;
660 : 0 : return NULL;
661 : : }
662 : : attr = MLX5_ADDR_OF(create_header_modify_pattern_in, in, hdr);
663 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
664 : : attr, opcode, MLX5_CMD_OP_CREATE_GENERAL_OBJECT);
665 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
666 : : attr, obj_type, MLX5_GENERAL_OBJ_TYPE_MODIFY_HEADER_PATTERN);
667 : :
668 : : pattern = MLX5_ADDR_OF(create_header_modify_pattern_in, in, pattern);
669 : : /* Pattern_length is in ddwords */
670 [ # # ]: 0 : MLX5_SET(header_modify_pattern_in, pattern, pattern_length, pattern_length / (2 * DW_SIZE));
671 : :
672 : : pattern_data = (uint64_t *)MLX5_ADDR_OF(header_modify_pattern_in, pattern, pattern_data);
673 : 0 : memcpy(pattern_data, actions, pattern_length);
674 : :
675 : 0 : num_of_actions = pattern_length / MLX5DR_MODIFY_ACTION_SIZE;
676 [ # # ]: 0 : for (i = 0; i < num_of_actions; i++) {
677 : : int type;
678 : :
679 [ # # ]: 0 : type = MLX5_GET(set_action_in, &pattern_data[i], action_type);
680 : 0 : if (type != MLX5_MODIFICATION_TYPE_COPY &&
681 [ # # ]: 0 : type != MLX5_MODIFICATION_TYPE_ADD_FIELD)
682 : : /* Action typ-copy use all bytes for control */
683 [ # # ]: 0 : MLX5_SET(set_action_in, &pattern_data[i], data, 0);
684 : : }
685 : :
686 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
687 [ # # ]: 0 : if (!devx_obj->obj) {
688 : 0 : DR_LOG(ERR, "Failed to create header_modify_pattern (syndrome: %#x)",
689 : : mlx5dr_cmd_get_syndrome(out));
690 : 0 : rte_errno = errno;
691 : 0 : goto free_obj;
692 : : }
693 : :
694 [ # # ]: 0 : devx_obj->id = MLX5_GET(general_obj_out_cmd_hdr, out, obj_id);
695 : :
696 : 0 : return devx_obj;
697 : :
698 : : free_obj:
699 : : simple_free(devx_obj);
700 : 0 : return NULL;
701 : : }
702 : :
703 : : struct mlx5dr_devx_obj *
704 : 0 : mlx5dr_cmd_ste_create(struct ibv_context *ctx,
705 : : struct mlx5dr_cmd_ste_create_attr *ste_attr)
706 : : {
707 : 0 : uint32_t out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)] = {0};
708 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_ste_in)] = {0};
709 : : struct mlx5dr_devx_obj *devx_obj;
710 : : void *attr;
711 : :
712 : : devx_obj = simple_malloc(sizeof(*devx_obj));
713 [ # # ]: 0 : if (!devx_obj) {
714 : 0 : DR_LOG(ERR, "Failed to allocate memory for STE object");
715 : 0 : rte_errno = ENOMEM;
716 : 0 : return NULL;
717 : : }
718 : :
719 : : attr = MLX5_ADDR_OF(create_ste_in, in, hdr);
720 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
721 : : attr, opcode, MLX5_CMD_OP_CREATE_GENERAL_OBJECT);
722 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
723 : : attr, obj_type, MLX5_GENERAL_OBJ_TYPE_STE);
724 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
725 : : attr, log_obj_range, ste_attr->log_obj_range);
726 : :
727 : : attr = MLX5_ADDR_OF(create_ste_in, in, ste);
728 [ # # ]: 0 : MLX5_SET(ste, attr, table_type, ste_attr->table_type);
729 : :
730 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
731 [ # # ]: 0 : if (!devx_obj->obj) {
732 : 0 : DR_LOG(ERR, "Failed to create STE (syndrome: %#x)",
733 : : mlx5dr_cmd_get_syndrome(out));
734 : : simple_free(devx_obj);
735 : 0 : rte_errno = errno;
736 : 0 : return NULL;
737 : : }
738 : :
739 [ # # ]: 0 : devx_obj->id = MLX5_GET(general_obj_out_cmd_hdr, out, obj_id);
740 : :
741 : 0 : return devx_obj;
742 : : }
743 : :
744 : : struct mlx5dr_devx_obj *
745 : 0 : mlx5dr_cmd_definer_create(struct ibv_context *ctx,
746 : : struct mlx5dr_cmd_definer_create_attr *def_attr)
747 : : {
748 : 0 : uint32_t out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)] = {0};
749 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_definer_in)] = {0};
750 : : struct mlx5dr_devx_obj *devx_obj;
751 : : void *ptr;
752 : :
753 : : devx_obj = simple_malloc(sizeof(*devx_obj));
754 [ # # ]: 0 : if (!devx_obj) {
755 : 0 : DR_LOG(ERR, "Failed to allocate memory for definer object");
756 : 0 : rte_errno = ENOMEM;
757 : 0 : return NULL;
758 : : }
759 : :
760 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
761 : : in, opcode, MLX5_CMD_OP_CREATE_GENERAL_OBJECT);
762 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
763 : : in, obj_type, MLX5_GENERAL_OBJ_TYPE_DEFINER);
764 : :
765 : : ptr = MLX5_ADDR_OF(create_definer_in, in, definer);
766 [ # # ]: 0 : MLX5_SET(definer, ptr, format_id, MLX5_IFC_DEFINER_FORMAT_ID_SELECT);
767 : :
768 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_dw0, def_attr->dw_selector[0]);
769 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_dw1, def_attr->dw_selector[1]);
770 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_dw2, def_attr->dw_selector[2]);
771 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_dw3, def_attr->dw_selector[3]);
772 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_dw4, def_attr->dw_selector[4]);
773 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_dw5, def_attr->dw_selector[5]);
774 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_dw6, def_attr->dw_selector[6]);
775 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_dw7, def_attr->dw_selector[7]);
776 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_dw8, def_attr->dw_selector[8]);
777 : :
778 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_byte0, def_attr->byte_selector[0]);
779 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_byte1, def_attr->byte_selector[1]);
780 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_byte2, def_attr->byte_selector[2]);
781 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_byte3, def_attr->byte_selector[3]);
782 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_byte4, def_attr->byte_selector[4]);
783 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_byte5, def_attr->byte_selector[5]);
784 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_byte6, def_attr->byte_selector[6]);
785 [ # # ]: 0 : MLX5_SET(definer, ptr, format_select_byte7, def_attr->byte_selector[7]);
786 : :
787 : : ptr = MLX5_ADDR_OF(definer, ptr, match_mask);
788 : 0 : memcpy(ptr, def_attr->match_mask, MLX5_FLD_SZ_BYTES(definer, match_mask));
789 : :
790 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
791 [ # # ]: 0 : if (!devx_obj->obj) {
792 : 0 : DR_LOG(ERR, "Failed to create Definer (syndrome: %#x)",
793 : : mlx5dr_cmd_get_syndrome(out));
794 : : simple_free(devx_obj);
795 : 0 : rte_errno = errno;
796 : 0 : return NULL;
797 : : }
798 : :
799 [ # # ]: 0 : devx_obj->id = MLX5_GET(general_obj_out_cmd_hdr, out, obj_id);
800 : :
801 : 0 : return devx_obj;
802 : : }
803 : :
804 : : struct mlx5dr_devx_obj *
805 : 0 : mlx5dr_cmd_sq_create(struct ibv_context *ctx,
806 : : struct mlx5dr_cmd_sq_create_attr *attr)
807 : : {
808 : 0 : uint32_t out[MLX5_ST_SZ_DW(create_sq_out)] = {0};
809 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_sq_in)] = {0};
810 : : void *sqc = MLX5_ADDR_OF(create_sq_in, in, ctx);
811 : : void *wqc = MLX5_ADDR_OF(sqc, sqc, wq);
812 : : struct mlx5dr_devx_obj *devx_obj;
813 : :
814 : : devx_obj = simple_malloc(sizeof(*devx_obj));
815 [ # # ]: 0 : if (!devx_obj) {
816 : 0 : DR_LOG(ERR, "Failed to create SQ");
817 : 0 : rte_errno = ENOMEM;
818 : 0 : return NULL;
819 : : }
820 : :
821 [ # # ]: 0 : MLX5_SET(create_sq_in, in, opcode, MLX5_CMD_OP_CREATE_SQ);
822 [ # # ]: 0 : MLX5_SET(sqc, sqc, cqn, attr->cqn);
823 [ # # ]: 0 : MLX5_SET(sqc, sqc, flush_in_error_en, 1);
824 [ # # ]: 0 : MLX5_SET(sqc, sqc, non_wire, 1);
825 [ # # ]: 0 : MLX5_SET(sqc, sqc, ts_format, attr->ts_format);
826 [ # # ]: 0 : MLX5_SET(wq, wqc, wq_type, MLX5_WQ_TYPE_CYCLIC);
827 [ # # ]: 0 : MLX5_SET(wq, wqc, pd, attr->pdn);
828 [ # # ]: 0 : MLX5_SET(wq, wqc, uar_page, attr->page_id);
829 [ # # ]: 0 : MLX5_SET(wq, wqc, log_wq_stride, log2above(MLX5_SEND_WQE_BB));
830 [ # # ]: 0 : MLX5_SET(wq, wqc, log_wq_sz, attr->log_wq_sz);
831 [ # # ]: 0 : MLX5_SET(wq, wqc, dbr_umem_id, attr->dbr_id);
832 [ # # ]: 0 : MLX5_SET(wq, wqc, wq_umem_id, attr->wq_id);
833 : :
834 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
835 [ # # ]: 0 : if (!devx_obj->obj) {
836 : : simple_free(devx_obj);
837 : 0 : rte_errno = errno;
838 : 0 : return NULL;
839 : : }
840 : :
841 [ # # ]: 0 : devx_obj->id = MLX5_GET(create_sq_out, out, sqn);
842 : :
843 : 0 : return devx_obj;
844 : : }
845 : :
846 : : struct mlx5dr_devx_obj *
847 : 0 : mlx5dr_cmd_packet_reformat_create(struct ibv_context *ctx,
848 : : struct mlx5dr_cmd_packet_reformat_create_attr *attr)
849 : : {
850 : 0 : uint32_t out[MLX5_ST_SZ_DW(alloc_packet_reformat_out)] = {0};
851 : : size_t insz, cmd_data_sz, cmd_total_sz;
852 : : struct mlx5dr_devx_obj *devx_obj;
853 : : void *prctx;
854 : : void *pdata;
855 : : void *in;
856 : :
857 : : cmd_total_sz = MLX5_ST_SZ_BYTES(alloc_packet_reformat_context_in);
858 : : cmd_total_sz += MLX5_ST_SZ_BYTES(packet_reformat_context_in);
859 : : cmd_data_sz = MLX5_FLD_SZ_BYTES(packet_reformat_context_in, reformat_data);
860 : 0 : insz = align(cmd_total_sz + attr->data_sz - cmd_data_sz, DW_SIZE);
861 : : in = simple_calloc(1, insz);
862 [ # # ]: 0 : if (!in) {
863 : 0 : rte_errno = ENOMEM;
864 : 0 : return NULL;
865 : : }
866 : :
867 [ # # ]: 0 : MLX5_SET(alloc_packet_reformat_context_in, in, opcode,
868 : : MLX5_CMD_OP_ALLOC_PACKET_REFORMAT_CONTEXT);
869 : :
870 : : prctx = MLX5_ADDR_OF(alloc_packet_reformat_context_in, in,
871 : : packet_reformat_context);
872 : 0 : pdata = MLX5_ADDR_OF(packet_reformat_context_in, prctx, reformat_data);
873 : :
874 [ # # ]: 0 : MLX5_SET(packet_reformat_context_in, prctx, reformat_type, attr->type);
875 [ # # ]: 0 : MLX5_SET(packet_reformat_context_in, prctx, reformat_param_0, attr->reformat_param_0);
876 [ # # ]: 0 : MLX5_SET(packet_reformat_context_in, prctx, reformat_data_size, attr->data_sz);
877 : 0 : memcpy(pdata, attr->data, attr->data_sz);
878 : :
879 : : devx_obj = simple_malloc(sizeof(*devx_obj));
880 [ # # ]: 0 : if (!devx_obj) {
881 : 0 : DR_LOG(ERR, "Failed to allocate memory for packet reformat object");
882 : 0 : rte_errno = ENOMEM;
883 : 0 : goto out_free_in;
884 : : }
885 : :
886 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, insz, out, sizeof(out));
887 [ # # ]: 0 : if (!devx_obj->obj) {
888 : 0 : DR_LOG(ERR, "Failed to create packet reformat");
889 : 0 : rte_errno = errno;
890 : 0 : goto out_free_devx;
891 : : }
892 : :
893 [ # # ]: 0 : devx_obj->id = MLX5_GET(alloc_packet_reformat_out, out, packet_reformat_id);
894 : :
895 : : simple_free(in);
896 : :
897 : 0 : return devx_obj;
898 : :
899 : : out_free_devx:
900 : : simple_free(devx_obj);
901 : 0 : out_free_in:
902 : : simple_free(in);
903 : 0 : return NULL;
904 : : }
905 : :
906 : 0 : int mlx5dr_cmd_sq_modify_rdy(struct mlx5dr_devx_obj *devx_obj)
907 : : {
908 : 0 : uint32_t out[MLX5_ST_SZ_DW(modify_sq_out)] = {0};
909 : 0 : uint32_t in[MLX5_ST_SZ_DW(modify_sq_in)] = {0};
910 : : void *sqc = MLX5_ADDR_OF(modify_sq_in, in, ctx);
911 : : int ret;
912 : :
913 : 0 : MLX5_SET(modify_sq_in, in, opcode, MLX5_CMD_OP_MODIFY_SQ);
914 : 0 : MLX5_SET(modify_sq_in, in, sqn, devx_obj->id);
915 [ # # ]: 0 : MLX5_SET(modify_sq_in, in, sq_state, MLX5_SQC_STATE_RST);
916 : 0 : MLX5_SET(sqc, sqc, state, MLX5_SQC_STATE_RDY);
917 : :
918 : 0 : ret = mlx5_glue->devx_obj_modify(devx_obj->obj, in, sizeof(in), out, sizeof(out));
919 [ # # ]: 0 : if (ret) {
920 : 0 : DR_LOG(ERR, "Failed to modify SQ (syndrome: %#x)",
921 : : mlx5dr_cmd_get_syndrome(out));
922 : 0 : rte_errno = errno;
923 : : }
924 : :
925 : 0 : return ret;
926 : : }
927 : :
928 : 0 : int mlx5dr_cmd_allow_other_vhca_access(struct ibv_context *ctx,
929 : : struct mlx5dr_cmd_allow_other_vhca_access_attr *attr)
930 : : {
931 : 0 : uint32_t out[MLX5_ST_SZ_DW(allow_other_vhca_access_out)] = {0};
932 : 0 : uint32_t in[MLX5_ST_SZ_DW(allow_other_vhca_access_in)] = {0};
933 : : void *key;
934 : : int ret;
935 : :
936 : 0 : MLX5_SET(allow_other_vhca_access_in,
937 : : in, opcode, MLX5_CMD_OP_ALLOW_OTHER_VHCA_ACCESS);
938 : 0 : MLX5_SET(allow_other_vhca_access_in,
939 : : in, object_type_to_be_accessed, attr->obj_type);
940 : 0 : MLX5_SET(allow_other_vhca_access_in,
941 : : in, object_id_to_be_accessed, attr->obj_id);
942 : :
943 : : key = MLX5_ADDR_OF(allow_other_vhca_access_in, in, access_key);
944 : 0 : memcpy(key, attr->access_key, sizeof(attr->access_key));
945 : :
946 : 0 : ret = mlx5_glue->devx_general_cmd(ctx, in, sizeof(in), out, sizeof(out));
947 [ # # ]: 0 : if (ret) {
948 : 0 : DR_LOG(ERR, "Failed to execute ALLOW_OTHER_VHCA_ACCESS command");
949 : 0 : rte_errno = errno;
950 : 0 : return rte_errno;
951 : : }
952 : :
953 : : return 0;
954 : : }
955 : :
956 : : struct mlx5dr_devx_obj *
957 : 0 : mlx5dr_cmd_alias_obj_create(struct ibv_context *ctx,
958 : : struct mlx5dr_cmd_alias_obj_create_attr *alias_attr)
959 : : {
960 : 0 : uint32_t out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)] = {0};
961 : 0 : uint32_t in[MLX5_ST_SZ_DW(create_alias_obj_in)] = {0};
962 : : struct mlx5dr_devx_obj *devx_obj;
963 : : void *attr;
964 : : void *key;
965 : :
966 : : devx_obj = simple_malloc(sizeof(*devx_obj));
967 [ # # ]: 0 : if (!devx_obj) {
968 : 0 : DR_LOG(ERR, "Failed to allocate memory for ALIAS general object");
969 : 0 : rte_errno = ENOMEM;
970 : 0 : return NULL;
971 : : }
972 : :
973 : : attr = MLX5_ADDR_OF(create_alias_obj_in, in, hdr);
974 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
975 : : attr, opcode, MLX5_CMD_OP_CREATE_GENERAL_OBJECT);
976 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr,
977 : : attr, obj_type, alias_attr->obj_type);
978 [ # # ]: 0 : MLX5_SET(general_obj_in_cmd_hdr, attr, alias_object, 1);
979 : :
980 : : attr = MLX5_ADDR_OF(create_alias_obj_in, in, alias_ctx);
981 [ # # ]: 0 : MLX5_SET(alias_context, attr, vhca_id_to_be_accessed, alias_attr->vhca_id);
982 [ # # ]: 0 : MLX5_SET(alias_context, attr, object_id_to_be_accessed, alias_attr->obj_id);
983 : :
984 : : key = MLX5_ADDR_OF(alias_context, attr, access_key);
985 : 0 : memcpy(key, alias_attr->access_key, sizeof(alias_attr->access_key));
986 : :
987 : 0 : devx_obj->obj = mlx5_glue->devx_obj_create(ctx, in, sizeof(in), out, sizeof(out));
988 [ # # ]: 0 : if (!devx_obj->obj) {
989 : 0 : DR_LOG(ERR, "Failed to create ALIAS OBJ (syndrome: %#x)",
990 : : mlx5dr_cmd_get_syndrome(out));
991 : : simple_free(devx_obj);
992 : 0 : rte_errno = errno;
993 : 0 : return NULL;
994 : : }
995 : :
996 [ # # ]: 0 : devx_obj->id = MLX5_GET(general_obj_out_cmd_hdr, out, obj_id);
997 : :
998 : 0 : return devx_obj;
999 : : }
1000 : :
1001 : 0 : int mlx5dr_cmd_generate_wqe(struct ibv_context *ctx,
1002 : : struct mlx5dr_cmd_generate_wqe_attr *attr,
1003 : : struct mlx5_cqe64 *ret_cqe)
1004 : : {
1005 : 0 : uint32_t out[MLX5_ST_SZ_DW(generate_wqe_out)] = {0};
1006 : 0 : uint32_t in[MLX5_ST_SZ_DW(generate_wqe_in)] = {0};
1007 : : uint8_t status;
1008 : : void *ptr;
1009 : : int ret;
1010 : :
1011 : 0 : MLX5_SET(generate_wqe_in, in, opcode, MLX5_CMD_OP_GENERATE_WQE);
1012 : 0 : MLX5_SET(generate_wqe_in, in, pdn, attr->pdn);
1013 : :
1014 : : ptr = MLX5_ADDR_OF(generate_wqe_in, in, wqe_ctrl);
1015 : 0 : memcpy(ptr, attr->wqe_ctrl, MLX5_FLD_SZ_BYTES(generate_wqe_in, wqe_ctrl));
1016 : :
1017 : : ptr = MLX5_ADDR_OF(generate_wqe_in, in, wqe_gta_ctrl);
1018 [ # # ]: 0 : memcpy(ptr, attr->gta_ctrl, MLX5_FLD_SZ_BYTES(generate_wqe_in, wqe_gta_ctrl));
1019 : :
1020 : : ptr = MLX5_ADDR_OF(generate_wqe_in, in, wqe_gta_data_0);
1021 : 0 : memcpy(ptr, attr->gta_data_0, MLX5_FLD_SZ_BYTES(generate_wqe_in, wqe_gta_data_0));
1022 : :
1023 [ # # ]: 0 : if (attr->gta_data_1) {
1024 : : ptr = MLX5_ADDR_OF(generate_wqe_in, in, wqe_gta_data_1);
1025 : : memcpy(ptr, attr->gta_data_1, MLX5_FLD_SZ_BYTES(generate_wqe_in, wqe_gta_data_1));
1026 : : }
1027 : :
1028 : 0 : ret = mlx5_glue->devx_general_cmd(ctx, in, sizeof(in), out, sizeof(out));
1029 [ # # ]: 0 : if (ret) {
1030 : 0 : DR_LOG(ERR, "Failed to write GTA WQE using FW");
1031 : 0 : rte_errno = errno;
1032 : 0 : return rte_errno;
1033 : : }
1034 : :
1035 [ # # ]: 0 : status = MLX5_GET(generate_wqe_out, out, status);
1036 [ # # ]: 0 : if (status) {
1037 : 0 : DR_LOG(ERR, "Invalid FW CQE status %d", status);
1038 : 0 : rte_errno = EINVAL;
1039 : 0 : return rte_errno;
1040 : : }
1041 : :
1042 : : ptr = MLX5_ADDR_OF(generate_wqe_out, out, cqe_data);
1043 : : memcpy(ret_cqe, ptr, sizeof(*ret_cqe));
1044 : :
1045 : 0 : return 0;
1046 : : }
1047 : :
1048 : 0 : int mlx5dr_cmd_query_caps(struct ibv_context *ctx,
1049 : : struct mlx5dr_cmd_query_caps *caps)
1050 : : {
1051 : 0 : uint32_t out[MLX5_ST_SZ_DW(query_hca_cap_out)] = {0};
1052 : 0 : uint32_t in[MLX5_ST_SZ_DW(query_hca_cap_in)] = {0};
1053 : : const struct flow_hw_port_info *port_info;
1054 : : struct ibv_device_attr_ex attr_ex;
1055 : : u32 res;
1056 : : int ret;
1057 : :
1058 : 0 : MLX5_SET(query_hca_cap_in, in, opcode, MLX5_CMD_OP_QUERY_HCA_CAP);
1059 : 0 : MLX5_SET(query_hca_cap_in, in, op_mod,
1060 : : MLX5_GET_HCA_CAP_OP_MOD_GENERAL_DEVICE |
1061 : : MLX5_HCA_CAP_OPMOD_GET_CUR);
1062 : :
1063 : 0 : ret = mlx5_glue->devx_general_cmd(ctx, in, sizeof(in), out, sizeof(out));
1064 [ # # ]: 0 : if (ret) {
1065 : 0 : DR_LOG(ERR, "Failed to query device caps");
1066 : 0 : rte_errno = errno;
1067 : 0 : return rte_errno;
1068 : : }
1069 : :
1070 : 0 : caps->wqe_based_update =
1071 [ # # ]: 0 : MLX5_GET(query_hca_cap_out, out,
1072 : : capability.cmd_hca_cap.wqe_based_flow_table_update_cap);
1073 : :
1074 [ # # ]: 0 : caps->eswitch_manager = MLX5_GET(query_hca_cap_out, out,
1075 : : capability.cmd_hca_cap.eswitch_manager);
1076 : :
1077 [ # # ]: 0 : caps->flex_protocols = MLX5_GET(query_hca_cap_out, out,
1078 : : capability.cmd_hca_cap.flex_parser_protocols);
1079 : :
1080 : 0 : caps->log_header_modify_argument_granularity =
1081 [ # # ]: 0 : MLX5_GET(query_hca_cap_out, out,
1082 : : capability.cmd_hca_cap.log_header_modify_argument_granularity);
1083 : :
1084 : 0 : caps->log_header_modify_argument_granularity -=
1085 [ # # ]: 0 : MLX5_GET(query_hca_cap_out, out,
1086 : : capability.cmd_hca_cap.
1087 : : log_header_modify_argument_granularity_offset);
1088 : :
1089 [ # # ]: 0 : caps->log_header_modify_argument_max_alloc =
1090 : 0 : MLX5_GET(query_hca_cap_out, out,
1091 : : capability.cmd_hca_cap.log_header_modify_argument_max_alloc);
1092 : :
1093 : 0 : caps->definer_format_sup =
1094 [ # # ]: 0 : MLX5_GET64(query_hca_cap_out, out,
1095 : : capability.cmd_hca_cap.match_definer_format_supported);
1096 : :
1097 [ # # ]: 0 : caps->vhca_id = MLX5_GET(query_hca_cap_out, out,
1098 : : capability.cmd_hca_cap.vhca_id);
1099 : :
1100 [ # # ]: 0 : caps->sq_ts_format = MLX5_GET(query_hca_cap_out, out,
1101 : : capability.cmd_hca_cap.sq_ts_format);
1102 : :
1103 [ # # ]: 0 : caps->ipsec_offload = MLX5_GET(query_hca_cap_out, out,
1104 : : capability.cmd_hca_cap.ipsec_offload);
1105 : :
1106 [ # # ]: 0 : MLX5_SET(query_hca_cap_in, in, op_mod,
1107 : : MLX5_GET_HCA_CAP_OP_MOD_GENERAL_DEVICE_2 |
1108 : : MLX5_HCA_CAP_OPMOD_GET_CUR);
1109 : :
1110 : 0 : ret = mlx5_glue->devx_general_cmd(ctx, in, sizeof(in), out, sizeof(out));
1111 [ # # ]: 0 : if (ret) {
1112 : 0 : DR_LOG(ERR, "Failed to query device caps");
1113 : 0 : rte_errno = errno;
1114 : 0 : return rte_errno;
1115 : : }
1116 : :
1117 [ # # ]: 0 : caps->full_dw_jumbo_support = MLX5_GET(query_hca_cap_out, out,
1118 : : capability.cmd_hca_cap_2.
1119 : : format_select_dw_8_6_ext);
1120 : :
1121 [ # # ]: 0 : caps->format_select_gtpu_dw_0 = MLX5_GET(query_hca_cap_out, out,
1122 : : capability.cmd_hca_cap_2.
1123 : : format_select_dw_gtpu_dw_0);
1124 : :
1125 [ # # ]: 0 : caps->format_select_gtpu_dw_1 = MLX5_GET(query_hca_cap_out, out,
1126 : : capability.cmd_hca_cap_2.
1127 : : format_select_dw_gtpu_dw_1);
1128 : :
1129 [ # # ]: 0 : caps->format_select_gtpu_dw_2 = MLX5_GET(query_hca_cap_out, out,
1130 : : capability.cmd_hca_cap_2.
1131 : : format_select_dw_gtpu_dw_2);
1132 : :
1133 [ # # ]: 0 : caps->format_select_gtpu_ext_dw_0 = MLX5_GET(query_hca_cap_out, out,
1134 : : capability.cmd_hca_cap_2.
1135 : : format_select_dw_gtpu_first_ext_dw_0);
1136 : :
1137 [ # # ]: 0 : caps->supp_type_gen_wqe = MLX5_GET(query_hca_cap_out, out,
1138 : : capability.cmd_hca_cap_2.
1139 : : generate_wqe_type);
1140 : :
1141 : : /* check cross-VHCA support in cap2 */
1142 : : res =
1143 [ # # ]: 0 : MLX5_GET(query_hca_cap_out, out,
1144 : : capability.cmd_hca_cap_2.cross_vhca_object_to_object_supported);
1145 : :
1146 : : caps->cross_vhca_resources = (res & MLX5_CROSS_VHCA_OBJ_TO_OBJ_TYPE_STC_TO_TIR) &&
1147 : 0 : (res & MLX5_CROSS_VHCA_OBJ_TO_OBJ_TYPE_STC_TO_FT) &&
1148 : : (res & MLX5_CROSS_VHCA_OBJ_TO_OBJ_TYPE_FT_TO_RTC);
1149 : :
1150 : : res =
1151 [ # # ]: 0 : MLX5_GET(query_hca_cap_out, out,
1152 : : capability.cmd_hca_cap_2.allowed_object_for_other_vhca_access);
1153 : :
1154 : 0 : caps->cross_vhca_resources &= (res & MLX5_CROSS_VHCA_ALLOWED_OBJS_TIR) &&
1155 : 0 : (res & MLX5_CROSS_VHCA_ALLOWED_OBJS_FT) &&
1156 : : (res & MLX5_CROSS_VHCA_ALLOWED_OBJS_RTC);
1157 : :
1158 [ # # ]: 0 : caps->flow_table_hash_type = MLX5_GET(query_hca_cap_out, out,
1159 : : capability.cmd_hca_cap_2.flow_table_hash_type);
1160 : :
1161 [ # # ]: 0 : MLX5_SET(query_hca_cap_in, in, op_mod,
1162 : : MLX5_GET_HCA_CAP_OP_MOD_NIC_FLOW_TABLE |
1163 : : MLX5_HCA_CAP_OPMOD_GET_CUR);
1164 : :
1165 : 0 : ret = mlx5_glue->devx_general_cmd(ctx, in, sizeof(in), out, sizeof(out));
1166 [ # # ]: 0 : if (ret) {
1167 : 0 : DR_LOG(ERR, "Failed to query flow table caps");
1168 : 0 : rte_errno = errno;
1169 : 0 : return rte_errno;
1170 : : }
1171 : :
1172 [ # # ]: 0 : caps->nic_ft.max_level = MLX5_GET(query_hca_cap_out, out,
1173 : : capability.flow_table_nic_cap.
1174 : : flow_table_properties_nic_receive.max_ft_level);
1175 : :
1176 [ # # ]: 0 : caps->nic_ft.reparse = MLX5_GET(query_hca_cap_out, out,
1177 : : capability.flow_table_nic_cap.
1178 : : flow_table_properties_nic_receive.reparse);
1179 : :
1180 [ # # ]: 0 : caps->nic_ft.ignore_flow_level_rtc_valid =
1181 : 0 : MLX5_GET(query_hca_cap_out,
1182 : : out,
1183 : : capability.flow_table_nic_cap.
1184 : : flow_table_properties_nic_receive.ignore_flow_level_rtc_valid);
1185 : :
1186 : : /* check cross-VHCA support in flow table properties */
1187 : : res =
1188 [ # # ]: 0 : MLX5_GET(query_hca_cap_out, out,
1189 : : capability.flow_table_nic_cap.flow_table_properties_nic_receive.cross_vhca_object);
1190 : 0 : caps->cross_vhca_resources &= res;
1191 : :
1192 [ # # ]: 0 : if (caps->wqe_based_update) {
1193 [ # # ]: 0 : MLX5_SET(query_hca_cap_in, in, op_mod,
1194 : : MLX5_GET_HCA_CAP_OP_MOD_WQE_BASED_FLOW_TABLE |
1195 : : MLX5_HCA_CAP_OPMOD_GET_CUR);
1196 : :
1197 : 0 : ret = mlx5_glue->devx_general_cmd(ctx, in, sizeof(in), out, sizeof(out));
1198 [ # # ]: 0 : if (ret) {
1199 : 0 : DR_LOG(ERR, "Failed to query WQE based FT caps");
1200 : 0 : rte_errno = errno;
1201 : 0 : return rte_errno;
1202 : : }
1203 : :
1204 [ # # ]: 0 : caps->rtc_reparse_mode = MLX5_GET(query_hca_cap_out, out,
1205 : : capability.wqe_based_flow_table_cap.
1206 : : rtc_reparse_mode);
1207 : :
1208 [ # # ]: 0 : caps->ste_format = MLX5_GET(query_hca_cap_out, out,
1209 : : capability.wqe_based_flow_table_cap.
1210 : : ste_format);
1211 : :
1212 [ # # ]: 0 : caps->rtc_index_mode = MLX5_GET(query_hca_cap_out, out,
1213 : : capability.wqe_based_flow_table_cap.
1214 : : rtc_index_mode);
1215 : :
1216 [ # # ]: 0 : caps->rtc_log_depth_max = MLX5_GET(query_hca_cap_out, out,
1217 : : capability.wqe_based_flow_table_cap.
1218 : : rtc_log_depth_max);
1219 : :
1220 [ # # ]: 0 : caps->ste_alloc_log_max = MLX5_GET(query_hca_cap_out, out,
1221 : : capability.wqe_based_flow_table_cap.
1222 : : ste_alloc_log_max);
1223 : :
1224 [ # # ]: 0 : caps->ste_alloc_log_gran = MLX5_GET(query_hca_cap_out, out,
1225 : : capability.wqe_based_flow_table_cap.
1226 : : ste_alloc_log_granularity);
1227 : :
1228 [ # # ]: 0 : caps->trivial_match_definer = MLX5_GET(query_hca_cap_out, out,
1229 : : capability.wqe_based_flow_table_cap.
1230 : : trivial_match_definer);
1231 : :
1232 [ # # ]: 0 : caps->stc_alloc_log_max = MLX5_GET(query_hca_cap_out, out,
1233 : : capability.wqe_based_flow_table_cap.
1234 : : stc_alloc_log_max);
1235 : :
1236 [ # # ]: 0 : caps->stc_alloc_log_gran = MLX5_GET(query_hca_cap_out, out,
1237 : : capability.wqe_based_flow_table_cap.
1238 : : stc_alloc_log_granularity);
1239 : :
1240 [ # # ]: 0 : caps->rtc_hash_split_table = MLX5_GET(query_hca_cap_out, out,
1241 : : capability.wqe_based_flow_table_cap.
1242 : : rtc_hash_split_table);
1243 : :
1244 [ # # ]: 0 : caps->rtc_linear_lookup_table = MLX5_GET(query_hca_cap_out, out,
1245 : : capability.wqe_based_flow_table_cap.
1246 : : rtc_linear_lookup_table);
1247 : :
1248 [ # # ]: 0 : caps->access_index_mode = MLX5_GET(query_hca_cap_out, out,
1249 : : capability.wqe_based_flow_table_cap.
1250 : : access_index_mode);
1251 : :
1252 [ # # ]: 0 : caps->linear_match_definer = MLX5_GET(query_hca_cap_out, out,
1253 : : capability.wqe_based_flow_table_cap.
1254 : : linear_match_definer_reg_c3);
1255 : :
1256 [ # # ]: 0 : caps->rtc_max_hash_def_gen_wqe = MLX5_GET(query_hca_cap_out, out,
1257 : : capability.wqe_based_flow_table_cap.
1258 : : rtc_max_num_hash_definer_gen_wqe);
1259 : :
1260 [ # # ]: 0 : caps->supp_ste_format_gen_wqe = MLX5_GET(query_hca_cap_out, out,
1261 : : capability.wqe_based_flow_table_cap.
1262 : : ste_format_gen_wqe);
1263 : :
1264 [ # # ]: 0 : caps->fdb_tir_stc = MLX5_GET(query_hca_cap_out, out,
1265 : : capability.wqe_based_flow_table_cap.
1266 : : fdb_jump_to_tir_stc);
1267 : : }
1268 : :
1269 [ # # ]: 0 : if (caps->eswitch_manager) {
1270 [ # # ]: 0 : MLX5_SET(query_hca_cap_in, in, op_mod,
1271 : : MLX5_GET_HCA_CAP_OP_MOD_ESW_FLOW_TABLE |
1272 : : MLX5_HCA_CAP_OPMOD_GET_CUR);
1273 : :
1274 : 0 : ret = mlx5_glue->devx_general_cmd(ctx, in, sizeof(in), out, sizeof(out));
1275 [ # # ]: 0 : if (ret) {
1276 : 0 : DR_LOG(ERR, "Failed to query flow table esw caps");
1277 : 0 : rte_errno = errno;
1278 : 0 : return rte_errno;
1279 : : }
1280 : :
1281 [ # # ]: 0 : caps->fdb_ft.max_level = MLX5_GET(query_hca_cap_out, out,
1282 : : capability.flow_table_nic_cap.
1283 : : flow_table_properties_nic_receive.max_ft_level);
1284 : :
1285 [ # # ]: 0 : caps->fdb_ft.reparse = MLX5_GET(query_hca_cap_out, out,
1286 : : capability.flow_table_nic_cap.
1287 : : flow_table_properties_nic_receive.reparse);
1288 : :
1289 [ # # ]: 0 : MLX5_SET(query_hca_cap_in, in, op_mod,
1290 : : MLX5_SET_HCA_CAP_OP_MOD_ESW | MLX5_HCA_CAP_OPMOD_GET_CUR);
1291 : :
1292 : 0 : ret = mlx5_glue->devx_general_cmd(ctx, in, sizeof(in), out, sizeof(out));
1293 [ # # ]: 0 : if (ret) {
1294 : 0 : DR_LOG(ERR, "Query eswitch capabilities failed %d", ret);
1295 : 0 : rte_errno = errno;
1296 : 0 : return rte_errno;
1297 : : }
1298 : :
1299 [ # # # # ]: 0 : if (MLX5_GET(query_hca_cap_out, out,
1300 : : capability.esw_cap.esw_manager_vport_number_valid))
1301 : 0 : caps->eswitch_manager_vport_number =
1302 [ # # ]: 0 : MLX5_GET(query_hca_cap_out, out,
1303 : : capability.esw_cap.esw_manager_vport_number);
1304 : :
1305 [ # # ]: 0 : caps->merged_eswitch = MLX5_GET(query_hca_cap_out, out,
1306 : : capability.esw_cap.merged_eswitch);
1307 : : }
1308 : :
1309 : 0 : ret = mlx5_glue->query_device_ex(ctx, NULL, &attr_ex);
1310 [ # # ]: 0 : if (ret) {
1311 : 0 : DR_LOG(ERR, "Failed to query device attributes");
1312 : 0 : rte_errno = ret;
1313 : 0 : return rte_errno;
1314 : : }
1315 : :
1316 : 0 : strlcpy(caps->fw_ver, attr_ex.orig_attr.fw_ver, sizeof(caps->fw_ver));
1317 : :
1318 : : port_info = flow_hw_get_wire_port(ctx);
1319 [ # # ]: 0 : if (port_info) {
1320 : 0 : caps->wire_regc = port_info->regc_value;
1321 : 0 : caps->wire_regc_mask = port_info->regc_mask;
1322 : : } else {
1323 : 0 : DR_LOG(INFO, "Failed to query wire port regc value");
1324 : : }
1325 : :
1326 : : return ret;
1327 : : }
1328 : :
1329 : 0 : int mlx5dr_cmd_query_ib_port(struct ibv_context *ctx,
1330 : : struct mlx5dr_cmd_query_vport_caps *vport_caps,
1331 : : uint32_t port_num)
1332 : : {
1333 : 0 : struct mlx5_port_info port_info = {0};
1334 : : uint32_t flags;
1335 : : int ret;
1336 : :
1337 : : flags = MLX5_PORT_QUERY_VPORT | MLX5_PORT_QUERY_ESW_OWNER_VHCA_ID;
1338 : :
1339 : 0 : ret = mlx5_glue->devx_port_query(ctx, port_num, &port_info);
1340 : : /* Check if query succeed and vport is enabled */
1341 [ # # # # ]: 0 : if (ret || (port_info.query_flags & flags) != flags) {
1342 : 0 : rte_errno = ENOTSUP;
1343 : 0 : return rte_errno;
1344 : : }
1345 : :
1346 : 0 : vport_caps->vport_num = port_info.vport_id;
1347 : 0 : vport_caps->esw_owner_vhca_id = port_info.esw_owner_vhca_id;
1348 : :
1349 [ # # ]: 0 : if (port_info.query_flags & MLX5_PORT_QUERY_REG_C0) {
1350 : 0 : vport_caps->metadata_c = port_info.vport_meta_tag;
1351 : 0 : vport_caps->metadata_c_mask = port_info.vport_meta_mask;
1352 : : }
1353 : :
1354 : : return 0;
1355 : : }
|