LCOV - code coverage report
Current view: top level - drivers/net/mlx5/hws - mlx5dr_cmd.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 625 0.0 %
Date: 2024-01-22 16:13:49 Functions: 0 25 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 554 0.0 %

           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                 :            : }

Generated by: LCOV version 1.14