@@ -3463,6 +3463,7 @@ enum mlx5_ifc_rtc_ste_format {
MLX5_IFC_RTC_STE_FORMAT_8DW = 0x4,
MLX5_IFC_RTC_STE_FORMAT_11DW = 0x5,
MLX5_IFC_RTC_STE_FORMAT_RANGE = 0x7,
+ MLX5_IFC_RTC_STE_FORMAT_4DW_RANGE = 0x8,
};
enum mlx5_ifc_rtc_reparse_mode {
@@ -3501,6 +3502,21 @@ struct mlx5_ifc_rtc_bits {
u8 reserved_at_1a0[0x260];
};
+struct mlx5_ifc_ste_match_4dw_range_ctrl_dw_bits {
+ u8 match[0x1];
+ u8 reserved_at_1[0x2];
+ u8 base1[0x1];
+ u8 inverse1[0x1];
+ u8 reserved_at_5[0x1];
+ u8 operator1[0x2];
+ u8 reserved_at_8[0x3];
+ u8 base0[0x1];
+ u8 inverse0[0x1];
+ u8 reserved_at_a[0x1];
+ u8 operator0[0x2];
+ u8 compare_delta[0x10];
+};
+
struct mlx5_ifc_alias_context_bits {
u8 vhca_id_to_be_accessed[0x10];
u8 reserved_at_10[0xd];
@@ -370,9 +370,12 @@ mlx5dr_cmd_rtc_create(struct ibv_context *ctx,
attr, obj_type, MLX5_GENERAL_OBJ_TYPE_RTC);
attr = MLX5_ADDR_OF(create_rtc_in, in, rtc);
- MLX5_SET(rtc, attr, ste_format_0, rtc_attr->is_frst_jumbo ?
- MLX5_IFC_RTC_STE_FORMAT_11DW :
- MLX5_IFC_RTC_STE_FORMAT_8DW);
+ if (rtc_attr->is_compare) {
+ MLX5_SET(rtc, attr, ste_format_0, MLX5_IFC_RTC_STE_FORMAT_4DW_RANGE);
+ } else {
+ MLX5_SET(rtc, attr, ste_format_0, rtc_attr->is_frst_jumbo ?
+ MLX5_IFC_RTC_STE_FORMAT_11DW : MLX5_IFC_RTC_STE_FORMAT_8DW);
+ }
if (rtc_attr->is_scnd_range) {
MLX5_SET(rtc, attr, ste_format_1, MLX5_IFC_RTC_STE_FORMAT_RANGE);
@@ -82,6 +82,7 @@ struct mlx5dr_cmd_rtc_create_attr {
uint8_t reparse_mode;
bool is_frst_jumbo;
bool is_scnd_range;
+ bool is_compare;
};
struct mlx5dr_cmd_alias_obj_create_attr {
@@ -99,6 +99,7 @@ static int
mlx5dr_debug_dump_matcher_match_template(FILE *f, struct mlx5dr_matcher *matcher)
{
bool is_root = matcher->tbl->level == MLX5DR_ROOT_LEVEL;
+ bool is_compare = mlx5dr_matcher_is_compare(matcher);
enum mlx5dr_debug_res_type type;
int i, ret;
@@ -117,7 +118,8 @@ mlx5dr_debug_dump_matcher_match_template(FILE *f, struct mlx5dr_matcher *matcher
return rte_errno;
}
- type = MLX5DR_DEBUG_RES_TYPE_MATCHER_TEMPLATE_MATCH_DEFINER;
+ type = is_compare ? MLX5DR_DEBUG_RES_TYPE_MATCHER_TEMPLATE_COMPARE_MATCH_DEFINER :
+ MLX5DR_DEBUG_RES_TYPE_MATCHER_TEMPLATE_MATCH_DEFINER;
ret = mlx5dr_debug_dump_matcher_template_definer(f, mt, mt->definer, type);
if (ret)
return ret;
@@ -24,6 +24,7 @@ enum mlx5dr_debug_res_type {
MLX5DR_DEBUG_RES_TYPE_MATCHER_ACTION_TEMPLATE = 4204,
MLX5DR_DEBUG_RES_TYPE_MATCHER_TEMPLATE_HASH_DEFINER = 4205,
MLX5DR_DEBUG_RES_TYPE_MATCHER_TEMPLATE_RANGE_DEFINER = 4206,
+ MLX5DR_DEBUG_RES_TYPE_MATCHER_TEMPLATE_COMPARE_MATCH_DEFINER = 4207,
};
static inline uint64_t
@@ -411,6 +411,86 @@ mlx5dr_definer_ptype_frag_set(struct mlx5dr_definer_fc *fc,
DR_SET(tag, !!packet_type, fc->byte_off, fc->bit_off, fc->bit_mask);
}
+static void
+mlx5dr_definer_compare_base_value_set(const void *item_spec,
+ uint8_t *tag)
+{
+ uint32_t *ctrl = &(((uint32_t *)tag)[MLX5DR_DEFINER_COMPARE_STE_ARGUMENT_1]);
+ uint32_t *base = &(((uint32_t *)tag)[MLX5DR_DEFINER_COMPARE_STE_BASE_0]);
+ const struct rte_flow_item_compare *v = item_spec;
+ const struct rte_flow_field_data *a = &v->a;
+ const struct rte_flow_field_data *b = &v->b;
+ const uint32_t *value;
+
+ value = (const uint32_t *)&b->value[0];
+
+ if (a->field == RTE_FLOW_FIELD_RANDOM)
+ *base = htobe32(*value << 16);
+ else
+ *base = htobe32(*value);
+
+ MLX5_SET(ste_match_4dw_range_ctrl_dw, ctrl, base0, 1);
+}
+
+static void
+mlx5dr_definer_compare_op_translate(enum rte_flow_item_compare_op op,
+ uint8_t *tag)
+{
+ uint32_t *ctrl = &(((uint32_t *)tag)[MLX5DR_DEFINER_COMPARE_STE_ARGUMENT_1]);
+ uint8_t operator = 0;
+ uint8_t inverse = 0;
+
+ switch (op) {
+ case RTE_FLOW_ITEM_COMPARE_EQ:
+ operator = 2;
+ break;
+ case RTE_FLOW_ITEM_COMPARE_NE:
+ operator = 2;
+ inverse = 1;
+ break;
+ case RTE_FLOW_ITEM_COMPARE_LT:
+ inverse = 1;
+ break;
+ case RTE_FLOW_ITEM_COMPARE_LE:
+ operator = 1;
+ break;
+ case RTE_FLOW_ITEM_COMPARE_GT:
+ operator = 1;
+ inverse = 1;
+ break;
+ case RTE_FLOW_ITEM_COMPARE_GE:
+ break;
+ default:
+ DR_LOG(ERR, "Invalid operation type %d", op);
+ assert(false);
+ }
+
+ MLX5_SET(ste_match_4dw_range_ctrl_dw, ctrl, inverse0, inverse);
+ MLX5_SET(ste_match_4dw_range_ctrl_dw, ctrl, operator0, operator);
+}
+
+static void
+mlx5dr_definer_compare_arg_set(const void *item_spec,
+ uint8_t *tag)
+{
+ const struct rte_flow_item_compare *v = item_spec;
+ enum rte_flow_item_compare_op op = v->operation;
+
+ mlx5dr_definer_compare_op_translate(op, tag);
+}
+
+static void
+mlx5dr_definer_compare_set(struct mlx5dr_definer_fc *fc,
+ const void *item_spec,
+ uint8_t *tag)
+{
+ if (fc->compare_idx == MLX5DR_DEFINER_COMPARE_ARGUMENT_0) {
+ mlx5dr_definer_compare_arg_set(item_spec, tag);
+ if (fc->compare_set_base)
+ mlx5dr_definer_compare_base_value_set(item_spec, tag);
+ }
+}
+
static void
mlx5dr_definer_integrity_set(struct mlx5dr_definer_fc *fc,
const void *item_spec,
@@ -2782,10 +2862,124 @@ mlx5dr_definer_conv_item_vxlan_gpe(struct mlx5dr_definer_conv_data *cd,
return 0;
}
+static int
+mlx5dr_definer_conv_item_compare_field(const struct rte_flow_field_data *f,
+ const struct rte_flow_field_data *other_f,
+ struct mlx5dr_definer_conv_data *cd,
+ int item_idx,
+ enum mlx5dr_definer_compare_dw_selectors dw_offset)
+{
+ struct mlx5dr_definer_fc *fc = NULL;
+ int reg;
+
+ if (f->offset) {
+ DR_LOG(ERR, "field offset %u is not supported, only offset zero supported",
+ f->offset);
+ goto err_notsup;
+ }
+
+ switch (f->field) {
+ case RTE_FLOW_FIELD_META:
+ reg = flow_hw_get_reg_id_from_ctx(cd->ctx,
+ RTE_FLOW_ITEM_TYPE_META, -1);
+ if (reg <= 0) {
+ DR_LOG(ERR, "Invalid register for compare metadata field");
+ rte_errno = EINVAL;
+ return rte_errno;
+ }
+
+ fc = mlx5dr_definer_get_register_fc(cd, reg);
+ if (!fc)
+ return rte_errno;
+
+ fc->item_idx = item_idx;
+ fc->tag_set = &mlx5dr_definer_compare_set;
+ fc->tag_mask_set = &mlx5dr_definer_ones_set;
+ fc->compare_idx = dw_offset;
+ break;
+ case RTE_FLOW_FIELD_TAG:
+ reg = flow_hw_get_reg_id_from_ctx(cd->ctx,
+ RTE_FLOW_ITEM_TYPE_TAG,
+ f->tag_index);
+ if (reg <= 0) {
+ DR_LOG(ERR, "Invalid register for compare tag field");
+ rte_errno = EINVAL;
+ return rte_errno;
+ }
+
+ fc = mlx5dr_definer_get_register_fc(cd, reg);
+ if (!fc)
+ return rte_errno;
+
+ fc->item_idx = item_idx;
+ fc->tag_set = &mlx5dr_definer_compare_set;
+ fc->tag_mask_set = &mlx5dr_definer_ones_set;
+ fc->compare_idx = dw_offset;
+ break;
+ case RTE_FLOW_FIELD_VALUE:
+ if (dw_offset == MLX5DR_DEFINER_COMPARE_ARGUMENT_0) {
+ DR_LOG(ERR, "Argument field does not support immediate value");
+ goto err_notsup;
+ }
+ break;
+ case RTE_FLOW_FIELD_RANDOM:
+ fc = &cd->fc[MLX5DR_DEFINER_FNAME_RANDOM_NUM];
+ fc->item_idx = item_idx;
+ fc->tag_set = &mlx5dr_definer_compare_set;
+ fc->tag_mask_set = &mlx5dr_definer_ones_set;
+ fc->compare_idx = dw_offset;
+ DR_CALC_SET_HDR(fc, random_number, random_number);
+ break;
+ default:
+ DR_LOG(ERR, "%u field is not supported", f->field);
+ goto err_notsup;
+ }
+
+ if (fc && other_f && other_f->field == RTE_FLOW_FIELD_VALUE)
+ fc->compare_set_base = true;
+
+ return 0;
+
+err_notsup:
+ rte_errno = ENOTSUP;
+ return rte_errno;
+}
+
+static int
+mlx5dr_definer_conv_item_compare(struct mlx5dr_definer_conv_data *cd,
+ struct rte_flow_item *item,
+ int item_idx)
+{
+ const struct rte_flow_item_compare *m = item->mask;
+ const struct rte_flow_field_data *a = &m->a;
+ const struct rte_flow_field_data *b = &m->b;
+ int ret;
+
+ if (m->width != 0xffffffff) {
+ DR_LOG(ERR, "compare item width of 0x%x is not supported, only full DW supported",
+ m->width);
+ rte_errno = ENOTSUP;
+ return rte_errno;
+ }
+
+ ret = mlx5dr_definer_conv_item_compare_field(a, b, cd, item_idx,
+ MLX5DR_DEFINER_COMPARE_ARGUMENT_0);
+ if (ret)
+ return ret;
+
+ ret = mlx5dr_definer_conv_item_compare_field(b, NULL, cd, item_idx,
+ MLX5DR_DEFINER_COMPARE_BASE_0);
+ if (ret)
+ return ret;
+
+ return 0;
+}
+
static int
mlx5dr_definer_conv_items_to_hl(struct mlx5dr_context *ctx,
struct mlx5dr_match_template *mt,
- uint8_t *hl)
+ uint8_t *hl,
+ struct mlx5dr_matcher *matcher)
{
struct mlx5dr_definer_fc fc[MLX5DR_DEFINER_FNAME_MAX] = {{0}};
struct mlx5dr_definer_conv_data cd = {0};
@@ -2805,6 +2999,11 @@ mlx5dr_definer_conv_items_to_hl(struct mlx5dr_context *ctx,
if (ret)
return ret;
+ if (mlx5dr_matcher_is_compare(matcher)) {
+ DR_LOG(ERR, "Compare matcher not supported for more than one item");
+ goto not_supp;
+ }
+
switch ((int)items->type) {
case RTE_FLOW_ITEM_TYPE_ETH:
ret = mlx5dr_definer_conv_item_eth(&cd, items, i);
@@ -2950,10 +3149,18 @@ mlx5dr_definer_conv_items_to_hl(struct mlx5dr_context *ctx,
ret = mlx5dr_definer_conv_item_vxlan_gpe(&cd, items, i);
item_flags |= MLX5_FLOW_LAYER_VXLAN_GPE;
break;
+ case RTE_FLOW_ITEM_TYPE_COMPARE:
+ if (i) {
+ DR_LOG(ERR, "Compare matcher not supported for more than one item");
+ goto not_supp;
+ }
+ ret = mlx5dr_definer_conv_item_compare(&cd, items, i);
+ item_flags |= MLX5_FLOW_ITEM_COMPARE;
+ matcher->flags |= MLX5DR_MATCHER_FLAGS_COMPARE;
+ break;
default:
DR_LOG(ERR, "Unsupported item type %d", items->type);
- rte_errno = ENOTSUP;
- return rte_errno;
+ goto not_supp;
}
cd.last_item = items->type;
@@ -2974,6 +3181,10 @@ mlx5dr_definer_conv_items_to_hl(struct mlx5dr_context *ctx,
}
return 0;
+
+not_supp:
+ rte_errno = ENOTSUP;
+ return rte_errno;
}
static int
@@ -3391,6 +3602,7 @@ mlx5dr_definer_calc_layout(struct mlx5dr_matcher *matcher,
{
struct mlx5dr_context *ctx = matcher->tbl->ctx;
struct mlx5dr_match_template *mt = matcher->mt;
+ struct mlx5dr_definer_fc *fc;
uint8_t *match_hl;
int i, ret;
@@ -3408,13 +3620,35 @@ mlx5dr_definer_calc_layout(struct mlx5dr_matcher *matcher,
* and allocate the match and range field copy array (fc & fcr).
*/
for (i = 0; i < matcher->num_of_mt; i++) {
- ret = mlx5dr_definer_conv_items_to_hl(ctx, &mt[i], match_hl);
+ ret = mlx5dr_definer_conv_items_to_hl(ctx, &mt[i], match_hl, matcher);
if (ret) {
DR_LOG(ERR, "Failed to convert items to header layout");
goto free_fc;
}
}
+ if (mlx5dr_matcher_is_compare(matcher)) {
+ ret = mlx5dr_matcher_validate_compare_attr(matcher);
+ if (ret)
+ goto free_fc;
+
+ /* Due some HW limitation need to fill unused
+ * DW's 0-5 and byte selectors with 0xff.
+ */
+ for (i = 0; i < DW_SELECTORS_MATCH; i++)
+ match_definer->dw_selector[i] = 0xff;
+
+ for (i = 0; i < BYTE_SELECTORS; i++)
+ match_definer->byte_selector[i] = 0xff;
+
+ for (i = 0; i < mt[0].fc_sz; i++) {
+ fc = &mt[0].fc[i];
+ match_definer->dw_selector[fc->compare_idx] = fc->byte_off / DW_SIZE;
+ }
+
+ goto out;
+ }
+
/* Find the match definer layout for header layout match union */
ret = mlx5dr_definer_find_best_match_fit(ctx, match_definer, match_hl);
if (ret) {
@@ -3435,6 +3669,7 @@ mlx5dr_definer_calc_layout(struct mlx5dr_matcher *matcher,
goto free_fc;
}
+out:
simple_free(match_hl);
return 0;
@@ -17,6 +17,37 @@
#define DW_SELECTORS_RANGE 2
#define BYTE_SELECTORS_RANGE 8
+enum mlx5dr_definer_compare_ste_dw_offset {
+ /* In compare STE the matching DW's starts after the 3 actions */
+ MLX5DR_DEFINER_COMPARE_STE_ARGUMENT_1 = 3,
+ MLX5DR_DEFINER_COMPARE_STE_ARGUMENT_0,
+ MLX5DR_DEFINER_COMPARE_STE_BASE_1,
+ MLX5DR_DEFINER_COMPARE_STE_BASE_0,
+ MLX5DR_DEFINER_COMPARE_STE_TAG_DW_3,
+ MLX5DR_DEFINER_COMPARE_STE_TAG_DW_2,
+ MLX5DR_DEFINER_COMPARE_STE_TAG_DW_1,
+ MLX5DR_DEFINER_COMPARE_STE_TAG_DW_0,
+};
+
+enum mlx5dr_definer_dw_selectors {
+ MLX5DR_DEFINER_SELECTOR_DW0,
+ MLX5DR_DEFINER_SELECTOR_DW1,
+ MLX5DR_DEFINER_SELECTOR_DW2,
+ MLX5DR_DEFINER_SELECTOR_DW3,
+ MLX5DR_DEFINER_SELECTOR_DW4,
+ MLX5DR_DEFINER_SELECTOR_DW5,
+ MLX5DR_DEFINER_SELECTOR_DW6,
+ MLX5DR_DEFINER_SELECTOR_DW7,
+ MLX5DR_DEFINER_SELECTOR_DW8,
+};
+
+enum mlx5dr_definer_compare_dw_selectors {
+ MLX5DR_DEFINER_COMPARE_ARGUMENT_0 = MLX5DR_DEFINER_SELECTOR_DW4,
+ MLX5DR_DEFINER_COMPARE_ARGUMENT_1 = MLX5DR_DEFINER_SELECTOR_DW5,
+ MLX5DR_DEFINER_COMPARE_BASE_0 = MLX5DR_DEFINER_SELECTOR_DW2,
+ MLX5DR_DEFINER_COMPARE_BASE_1 = MLX5DR_DEFINER_SELECTOR_DW3,
+};
+
enum mlx5dr_definer_fname {
MLX5DR_DEFINER_FNAME_ETH_SMAC_48_16_O,
MLX5DR_DEFINER_FNAME_ETH_SMAC_48_16_I,
@@ -188,6 +219,8 @@ struct mlx5dr_definer_fc {
uint8_t item_idx;
uint8_t is_range;
uint16_t extra_data;
+ uint8_t compare_idx;
+ bool compare_set_base;
uint32_t byte_off;
int bit_off;
uint32_t bit_mask;
@@ -485,6 +485,7 @@ static int mlx5dr_matcher_create_rtc(struct mlx5dr_matcher *matcher,
rtc_attr.log_depth = attr->table.sz_col_log;
rtc_attr.is_frst_jumbo = mlx5dr_matcher_mt_is_jumbo(mt);
rtc_attr.is_scnd_range = mlx5dr_matcher_mt_is_range(mt);
+ rtc_attr.is_compare = mlx5dr_matcher_is_compare(matcher);
rtc_attr.miss_ft_id = matcher->end_ft->id;
if (attr->insert_mode == MLX5DR_MATCHER_INSERT_BY_HASH) {
@@ -497,6 +498,10 @@ static int mlx5dr_matcher_create_rtc(struct mlx5dr_matcher *matcher,
rtc_attr.num_hash_definer = 1;
rtc_attr.match_definer_0 =
mlx5dr_definer_get_id(matcher->hash_definer);
+ } else if (mlx5dr_matcher_is_compare(matcher)) {
+ rtc_attr.match_definer_0 = ctx->caps->trivial_match_definer;
+ rtc_attr.fw_gen_wqe = true;
+ rtc_attr.num_hash_definer = 1;
} else {
/* The first mt is used since all share the same definer */
rtc_attr.match_definer_0 = mlx5dr_definer_get_id(mt->definer);
@@ -1635,3 +1640,51 @@ int mlx5dr_matcher_resize_rule_move(struct mlx5dr_matcher *src_matcher,
rte_errno = EINVAL;
return -rte_errno;
}
+
+int mlx5dr_matcher_validate_compare_attr(struct mlx5dr_matcher *matcher)
+{
+ struct mlx5dr_cmd_query_caps *caps = matcher->tbl->ctx->caps;
+ struct mlx5dr_matcher_attr *attr = &matcher->attr;
+
+ if (mlx5dr_table_is_root(matcher->tbl)) {
+ DR_LOG(ERR, "Compare matcher is not supported for root tables");
+ goto err;
+ }
+
+ if (attr->mode != MLX5DR_MATCHER_RESOURCE_MODE_HTABLE) {
+ DR_LOG(ERR, "Compare matcher is only supported with pre-defined table size");
+ goto err;
+ }
+
+ if (attr->insert_mode != MLX5DR_MATCHER_INSERT_BY_HASH ||
+ attr->distribute_mode != MLX5DR_MATCHER_DISTRIBUTE_BY_HASH) {
+ DR_LOG(ERR, "Gen WQE for compare matcher must be inserted and distribute by hash");
+ goto err;
+ }
+
+ if (matcher->num_of_mt != 1 || matcher->num_of_at != 1) {
+ DR_LOG(ERR, "Compare matcher match templates and action templates must be 1 for each");
+ goto err;
+ }
+
+ if (attr->table.sz_col_log || attr->table.sz_row_log) {
+ DR_LOG(ERR, "Compare matcher supports only 1x1 table size");
+ goto err;
+ }
+
+ if (attr->resizable) {
+ DR_LOG(ERR, "Compare matcher does not support resizeing");
+ goto err;
+ }
+
+ if (!IS_BIT_SET(caps->supp_ste_format_gen_wqe, MLX5_IFC_RTC_STE_FORMAT_4DW_RANGE)) {
+ DR_LOG(ERR, "Gen WQE Compare match format not supported");
+ goto err;
+ }
+
+ return 0;
+
+err:
+ rte_errno = ENOTSUP;
+ return rte_errno;
+}
@@ -27,6 +27,7 @@ enum mlx5dr_matcher_flags {
MLX5DR_MATCHER_FLAGS_HASH_DEFINER = 1 << 1,
MLX5DR_MATCHER_FLAGS_COLLISION = 1 << 2,
MLX5DR_MATCHER_FLAGS_RESIZABLE = 1 << 3,
+ MLX5DR_MATCHER_FLAGS_COMPARE = 1 << 4,
};
struct mlx5dr_match_template {
@@ -110,12 +111,19 @@ static inline bool mlx5dr_matcher_is_in_resize(struct mlx5dr_matcher *matcher)
return !!matcher->resize_dst;
}
+static inline bool
+mlx5dr_matcher_is_compare(struct mlx5dr_matcher *matcher)
+{
+ return !!(matcher->flags & MLX5DR_MATCHER_FLAGS_COMPARE);
+}
+
static inline bool mlx5dr_matcher_req_fw_wqe(struct mlx5dr_matcher *matcher)
{
/* Currently HWS doesn't support hash different from match or range */
return unlikely(matcher->flags &
(MLX5DR_MATCHER_FLAGS_HASH_DEFINER |
- MLX5DR_MATCHER_FLAGS_RANGE_DEFINER));
+ MLX5DR_MATCHER_FLAGS_RANGE_DEFINER |
+ MLX5DR_MATCHER_FLAGS_COMPARE));
}
int mlx5dr_matcher_conv_items_to_prm(uint64_t *match_buf,
@@ -141,4 +149,6 @@ int mlx5dr_matcher_free_rtc_pointing(struct mlx5dr_context *ctx,
enum mlx5dr_table_type type,
struct mlx5dr_devx_obj *devx_obj);
+int mlx5dr_matcher_validate_compare_attr(struct mlx5dr_matcher *matcher);
+
#endif /* MLX5DR_MATCHER_H_ */