net/ice/base: add parser runtime skeleton

Add parser runtime data struct ice_parser_rt.

Add below APIs for parser runtime preparation:
ice_parser_rt_reset
ice_parser_rt_pkt_buf_set

Add below API skeleton for parser runtime execution:
ice_parser_rt_execute

Signed-off-by: Qi Zhang <qi.z.zhang@intel.com>
Acked-by: Junfeng Guo <junfeng.guo@intel.com>

diff --git a/drivers/net/ice/base/ice_parser.c b/drivers/net/ice/base/ice_parser.c
index 1bce75a..8f42371 100644 (file)
--- a/drivers/net/ice/base/ice_parser.c
+++ b/drivers/net/ice/base/ice_parser.c
@@ -167,6 +167,8 @@ enum ice_status ice_parser_create(struct ice_hw *hw, struct ice_parser **psr)
        struct ice_parser *p;
 
        p = (struct ice_parser *)ice_malloc(hw, sizeof(struct ice_parser));
+       p->hw = hw;
+       p->rt.psr = p;
 
        if (!p)
                return ICE_ERR_NO_MEMORY;
@@ -301,3 +303,40 @@ void ice_parser_destroy(struct ice_parser *psr)
 
        ice_free(psr->hw, psr);
 }
+
+/**
+ * ice_parser_run - parse on a packet in binary and return the result
+ * @psr: pointer to a parser instance
+ * @pkt_buf: packet data
+ * @pkt_len: packet length
+ * @rslt: input/output parameter to save parser result.
+ */
+enum ice_status ice_parser_run(struct ice_parser *psr, const u8 *pkt_buf,
+                              int pkt_len, struct ice_parser_result *rslt)
+{
+       ice_parser_rt_reset(&psr->rt);
+       ice_parser_rt_pktbuf_set(&psr->rt, pkt_buf, pkt_len);
+
+       return ice_parser_rt_execute(&psr->rt, rslt);
+}
+
+/**
+ * ice_parser_result_dump - dump a parser result info
+ * @hw: pointer to the hardware structure
+ * @rslt: parser result info to dump
+ */
+void ice_parser_result_dump(struct ice_hw *hw, struct ice_parser_result *rslt)
+{
+       int i;
+
+       ice_info(hw, "ptype = %d\n", rslt->ptype);
+       for (i = 0; i < rslt->po_num; i++)
+               ice_info(hw, "proto = %d, offset = %d\n",
+                        rslt->po[i].proto_id, rslt->po[i].offset);
+
+       ice_info(hw, "flags_psr = 0x%016" PRIx64 "\n", rslt->flags_psr);
+       ice_info(hw, "flags_pkt = 0x%016" PRIx64 "\n", rslt->flags_pkt);
+       ice_info(hw, "flags_sw = 0x%04x\n", rslt->flags_sw);
+       ice_info(hw, "flags_fd = 0x%04x\n", rslt->flags_fd);
+       ice_info(hw, "flags_rss = 0x%04x\n", rslt->flags_rss);
+}

diff --git a/drivers/net/ice/base/ice_parser.h b/drivers/net/ice/base/ice_parser.h
index ba3175e..f71a8d8 100644 (file)
--- a/drivers/net/ice/base/ice_parser.h
+++ b/drivers/net/ice/base/ice_parser.h
@@ -14,6 +14,7 @@
 #include "ice_proto_grp.h"
 #include "ice_flg_rd.h"
 #include "ice_xlt_kb.h"
+#include "ice_parser_rt.h"
 
 struct ice_parser {
        struct ice_hw *hw; /* pointer to the hardware structure */
@@ -50,8 +51,31 @@ struct ice_parser {
        struct ice_xlt_kb *xlt_kb_fd;
        /* load data from section ICE_SID_XLT_KEY_BUILDER_RSS */
        struct ice_xlt_kb *xlt_kb_rss;
+       struct ice_parser_rt rt; /* parser runtime */
 };
 
 enum ice_status ice_parser_create(struct ice_hw *hw, struct ice_parser **psr);
 void ice_parser_destroy(struct ice_parser *psr);
+
+struct ice_parser_proto_off {
+       u8 proto_id; /* hardware protocol ID */
+       u16 offset;  /* offset where the  protocol header start */
+};
+
+struct ice_parser_result {
+       u16 ptype; /* 16 bits hardware PTYPE */
+       /* protocol and header offset pairs */
+       struct ice_parser_proto_off po[16];
+       int po_num; /* number of pairs must <= 16 */
+       u64 flags_psr; /* 64 bits parser flags */
+       u64 flags_pkt; /* 64 bits packet flags */
+       u16 flags_sw; /* 16 bits key builder flag for SW */
+       u16 flags_acl; /* 16 bits key builder flag for ACL */
+       u16 flags_fd; /* 16 bits key builder flag for FD */
+       u16 flags_rss; /* 16 bits key builder flag for RSS */
+};
+
+enum ice_status ice_parser_run(struct ice_parser *psr, const u8 *pkt_buf,
+                              int pkt_len, struct ice_parser_result *rslt);
+void ice_parser_result_dump(struct ice_hw *hw, struct ice_parser_result *rslt);
 #endif /* _ICE_PARSER_H_ */

diff --git a/drivers/net/ice/base/ice_parser_rt.c b/drivers/net/ice/base/ice_parser_rt.c
new file mode 100644 (file)
index 0000000..d62d017
--- /dev/null
+++ b/drivers/net/ice/base/ice_parser_rt.c
@@ -0,0 +1,98 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2001-2021 Intel Corporation
+ */
+
+#include "ice_common.h"
+
+#define GPR_HB_IDX     64
+#define GPR_ERR_IDX    84
+#define GPR_FLG_IDX    104
+#define GPR_TSR_IDX    108
+#define GPR_NN_IDX     109
+#define GPR_HO_IDX     110
+#define GPR_NP_IDX     111
+
+static void _rt_tsr_set(struct ice_parser_rt *rt, u16 tsr)
+{
+       rt->gpr[GPR_TSR_IDX] = tsr;
+}
+
+static void _rt_ho_set(struct ice_parser_rt *rt, u16 ho)
+{
+       rt->gpr[GPR_HO_IDX] = ho;
+       ice_memcpy(&rt->gpr[GPR_HB_IDX], &rt->pkt_buf[ho], 32,
+                  ICE_NONDMA_TO_NONDMA);
+}
+
+static void _rt_np_set(struct ice_parser_rt *rt, u16 pc)
+{
+       rt->gpr[GPR_NP_IDX] = pc;
+}
+
+static void _rt_nn_set(struct ice_parser_rt *rt, u16 node)
+{
+       rt->gpr[GPR_NN_IDX] = node;
+}
+
+static void _rt_flag_set(struct ice_parser_rt *rt, int idx)
+{
+       int y = idx / 16;
+       int x = idx % 16;
+
+       rt->gpr[GPR_FLG_IDX + y] |= (u16)(1 << x);
+}
+
+/**
+ * ice_parser_rt_reset - reset the parser runtime
+ * @rt: pointer to the parser runtime
+ */
+void ice_parser_rt_reset(struct ice_parser_rt *rt)
+{
+       struct ice_parser *psr = rt->psr;
+       struct ice_metainit_item *mi = &psr->mi_table[0];
+       int i;
+
+       ice_memset(rt, 0, sizeof(*rt), ICE_NONDMA_MEM);
+
+       _rt_tsr_set(rt, mi->tsr);
+       _rt_ho_set(rt, mi->ho);
+       _rt_np_set(rt, mi->pc);
+       _rt_nn_set(rt, mi->pg_rn);
+
+       for (i = 0; i < 64; i++) {
+               if ((mi->flags & (1ul << i)) != 0ul)
+                       _rt_flag_set(rt, i);
+       }
+
+       rt->psr = psr;
+}
+
+/**
+ * ice_parser_rt_pktbuf_set - set a packet into parser runtime
+ * @rt: pointer to the parser runtime
+ * @pkt_buf: buffer with packet data
+ * @pkt_len: packet buffer length
+ */
+void ice_parser_rt_pktbuf_set(struct ice_parser_rt *rt, const u8 *pkt_buf,
+                             int pkt_len)
+{
+       int len = min(ICE_PARSER_MAX_PKT_LEN, pkt_len);
+       u16 ho = rt->gpr[GPR_HO_IDX];
+
+       ice_memcpy(rt->pkt_buf, pkt_buf, len, ICE_NONDMA_TO_NONDMA);
+       rt->pkt_len = pkt_len;
+
+       ice_memcpy(&rt->gpr[GPR_HB_IDX], &rt->pkt_buf[ho], 32,
+                  ICE_NONDMA_TO_NONDMA);
+}
+
+/**
+ * ice_parser_rt_execute - parser execution routine
+ * @rt: pointer to the parser runtime
+ * @rslt: input/output parameter to save parser result
+ */
+enum ice_status ice_parser_rt_execute(struct ice_parser_rt *rt,
+                                     struct ice_parser_result *rslt)
+{
+       return ICE_ERR_NOT_IMPL;
+}

diff --git a/drivers/net/ice/base/ice_parser_rt.h b/drivers/net/ice/base/ice_parser_rt.h
new file mode 100644 (file)
index 0000000..32fa7f6
--- /dev/null
+++ b/drivers/net/ice/base/ice_parser_rt.h
@@ -0,0 +1,28 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2001-2021 Intel Corporation
+ */
+
+#ifndef _ICE_PARSER_RT_H_
+#define _ICE_PARSER_RT_H_
+
+struct ice_parser_ctx;
+
+#define ICE_PARSER_MAX_PKT_LEN 504
+#define ICE_PARSER_GPR_NUM 128
+
+struct ice_parser_rt {
+       struct ice_parser *psr;
+       u16 gpr[ICE_PARSER_GPR_NUM];
+       u8 pkt_buf[ICE_PARSER_MAX_PKT_LEN + 32];
+       u16 pkt_len;
+       u16 po;
+};
+
+void ice_parser_rt_reset(struct ice_parser_rt *rt);
+void ice_parser_rt_pktbuf_set(struct ice_parser_rt *rt, const u8 *pkt_buf,
+                             int pkt_len);
+
+struct ice_parser_result;
+enum ice_status ice_parser_rt_execute(struct ice_parser_rt *rt,
+                                     struct ice_parser_result *rslt);
+#endif /* _ICE_PARSER_RT_H_ */

diff --git a/drivers/net/ice/base/meson.build b/drivers/net/ice/base/meson.build
index 37191b2..3cf4ce0 100644 (file)
--- a/drivers/net/ice/base/meson.build
+++ b/drivers/net/ice/base/meson.build
@@ -25,6 +25,7 @@ sources = [
         'ice_proto_grp.c',
         'ice_flg_rd.c',
         'ice_xlt_kb.c',
+        'ice_parser_rt.c',
 ]
 
 error_cflags = [