[PATCH v5 12/39] ml/cnxk: enable validity checks for model metadata

[Srikanth Yalavarthi <syalavarthi@marvell.com>]

Added model metadata structure and enabled metadata check
during model load. Remap cnxk IO types with RTE IO types.
Store and update model metadata in model structure.

Signed-off-by: Srikanth Yalavarthi <syalavarthi@marvell.com>
---
 drivers/ml/cnxk/cn10k_ml_model.c | 211 +++++++++++++++++++++
 drivers/ml/cnxk/cn10k_ml_model.h | 312 +++++++++++++++++++++++++++++++
 drivers/ml/cnxk/cn10k_ml_ops.c   |  14 +-
 drivers/ml/cnxk/meson.build      |   2 +-
 4 files changed, 537 insertions(+), 2 deletions(-)

diff --git a/drivers/ml/cnxk/cn10k_ml_model.c b/drivers/ml/cnxk/cn10k_ml_model.c
index 39ed707396..dfa814bbe0 100644
--- a/drivers/ml/cnxk/cn10k_ml_model.c
+++ b/drivers/ml/cnxk/cn10k_ml_model.c
@@ -2,4 +2,215 @@
  * Copyright (c) 2022 Marvell.
  */
 
+#include <rte_hash_crc.h>
+
+#include <mldev_utils.h>
+
+#include "cn10k_ml_dev.h"
 #include "cn10k_ml_model.h"
+
+static enum rte_ml_io_type
+cn10k_ml_io_type_map(uint8_t type)
+{
+	switch (type) {
+	case 1:
+		return RTE_ML_IO_TYPE_INT8;
+	case 2:
+		return RTE_ML_IO_TYPE_UINT8;
+	case 3:
+		return RTE_ML_IO_TYPE_INT16;
+	case 4:
+		return RTE_ML_IO_TYPE_UINT16;
+	case 5:
+		return RTE_ML_IO_TYPE_INT32;
+	case 6:
+		return RTE_ML_IO_TYPE_UINT32;
+	case 7:
+		return RTE_ML_IO_TYPE_FP16;
+	case 8:
+		return RTE_ML_IO_TYPE_FP32;
+	}
+
+	return RTE_ML_IO_TYPE_UNKNOWN;
+}
+
+int
+cn10k_ml_model_metadata_check(uint8_t *buffer, uint64_t size)
+{
+	struct cn10k_ml_model_metadata *metadata;
+	uint32_t payload_crc32c;
+	uint32_t header_crc32c;
+	uint8_t version[4];
+	uint8_t i;
+
+	metadata = (struct cn10k_ml_model_metadata *)buffer;
+
+	/* Header CRC check */
+	if (metadata->metadata_header.header_crc32c != 0) {
+		header_crc32c = rte_hash_crc(
+			buffer, sizeof(metadata->metadata_header) - sizeof(uint32_t), 0);
+
+		if (header_crc32c != metadata->metadata_header.header_crc32c) {
+			plt_err("Invalid model, Header CRC mismatch");
+			return -EINVAL;
+		}
+	}
+
+	/* Payload CRC check */
+	if (metadata->metadata_header.payload_crc32c != 0) {
+		payload_crc32c = rte_hash_crc(buffer + sizeof(metadata->metadata_header),
+					      size - sizeof(metadata->metadata_header), 0);
+
+		if (payload_crc32c != metadata->metadata_header.payload_crc32c) {
+			plt_err("Invalid model, Payload CRC mismatch");
+			return -EINVAL;
+		}
+	}
+
+	/* Model magic string */
+	if (strncmp((char *)metadata->metadata_header.magic, MRVL_ML_MODEL_MAGIC_STRING, 4) != 0) {
+		plt_err("Invalid model, magic = %s", metadata->metadata_header.magic);
+		return -EINVAL;
+	}
+
+	/* Target architecture */
+	if (metadata->metadata_header.target_architecture != MRVL_ML_MODEL_TARGET_ARCH) {
+		plt_err("Model target architecture (%u) not supported",
+			metadata->metadata_header.target_architecture);
+		return -ENOTSUP;
+	}
+
+	/* Header version */
+	rte_memcpy(version, metadata->metadata_header.version, 4 * sizeof(uint8_t));
+	if (version[0] * 1000 + version[1] * 100 < MRVL_ML_MODEL_VERSION) {
+		plt_err("Metadata version = %u.%u.%u.%u (< %u.%u.%u.%u) not supported", version[0],
+			version[1], version[2], version[3], (MRVL_ML_MODEL_VERSION / 1000) % 10,
+			(MRVL_ML_MODEL_VERSION / 100) % 10, (MRVL_ML_MODEL_VERSION / 10) % 10,
+			MRVL_ML_MODEL_VERSION % 10);
+		return -ENOTSUP;
+	}
+
+	/* Init section */
+	if (metadata->init_model.file_size == 0) {
+		plt_err("Invalid metadata, init_model.file_size = %u",
+			metadata->init_model.file_size);
+		return -EINVAL;
+	}
+
+	/* Main section */
+	if (metadata->main_model.file_size == 0) {
+		plt_err("Invalid metadata, main_model.file_size = %u",
+			metadata->main_model.file_size);
+		return -EINVAL;
+	}
+
+	/* Finish section */
+	if (metadata->finish_model.file_size == 0) {
+		plt_err("Invalid metadata, finish_model.file_size = %u",
+			metadata->finish_model.file_size);
+		return -EINVAL;
+	}
+
+	/* Weights and Bias */
+	if (metadata->weights_bias.file_size == 0) {
+		plt_err("Invalid metadata, weights_bias.file_size = %u",
+			metadata->weights_bias.file_size);
+		return -EINVAL;
+	}
+
+	if (metadata->weights_bias.relocatable != 1) {
+		plt_err("Model not supported, non-relocatable weights and bias");
+		return -ENOTSUP;
+	}
+
+	/* Check input count */
+	if (metadata->model.num_input > MRVL_ML_INPUT_OUTPUT_SIZE) {
+		plt_err("Invalid metadata, num_input  = %u (> %u)", metadata->model.num_input,
+			MRVL_ML_INPUT_OUTPUT_SIZE);
+		return -EINVAL;
+	}
+
+	/* Check output count */
+	if (metadata->model.num_output > MRVL_ML_INPUT_OUTPUT_SIZE) {
+		plt_err("Invalid metadata, num_output  = %u (> %u)", metadata->model.num_output,
+			MRVL_ML_INPUT_OUTPUT_SIZE);
+		return -EINVAL;
+	}
+
+	/* Inputs */
+	for (i = 0; i < metadata->model.num_input; i++) {
+		if (rte_ml_io_type_size_get(cn10k_ml_io_type_map(metadata->input[i].input_type)) <=
+		    0) {
+			plt_err("Invalid metadata, input[%u] : input_type = %u", i,
+				metadata->input[i].input_type);
+			return -EINVAL;
+		}
+
+		if (rte_ml_io_type_size_get(
+			    cn10k_ml_io_type_map(metadata->input[i].model_input_type)) <= 0) {
+			plt_err("Invalid metadata, input[%u] : model_input_type = %u", i,
+				metadata->input[i].model_input_type);
+			return -EINVAL;
+		}
+
+		if (metadata->input[i].relocatable != 1) {
+			plt_err("Model not supported, non-relocatable input: %u", i);
+			return -ENOTSUP;
+		}
+	}
+
+	/* Outputs */
+	for (i = 0; i < metadata->model.num_output; i++) {
+		if (rte_ml_io_type_size_get(
+			    cn10k_ml_io_type_map(metadata->output[i].output_type)) <= 0) {
+			plt_err("Invalid metadata, output[%u] : output_type = %u", i,
+				metadata->output[i].output_type);
+			return -EINVAL;
+		}
+
+		if (rte_ml_io_type_size_get(
+			    cn10k_ml_io_type_map(metadata->output[i].model_output_type)) <= 0) {
+			plt_err("Invalid metadata, output[%u] : model_output_type = %u", i,
+				metadata->output[i].model_output_type);
+			return -EINVAL;
+		}
+
+		if (metadata->output[i].relocatable != 1) {
+			plt_err("Model not supported, non-relocatable output: %u", i);
+			return -ENOTSUP;
+		}
+	}
+
+	return 0;
+}
+
+void
+cn10k_ml_model_metadata_update(struct cn10k_ml_model_metadata *metadata)
+{
+	uint8_t i;
+
+	for (i = 0; i < metadata->model.num_input; i++) {
+		metadata->input[i].input_type = cn10k_ml_io_type_map(metadata->input[i].input_type);
+		metadata->input[i].model_input_type =
+			cn10k_ml_io_type_map(metadata->input[i].model_input_type);
+
+		if (metadata->input[i].shape.w == 0)
+			metadata->input[i].shape.w = 1;
+
+		if (metadata->input[i].shape.x == 0)
+			metadata->input[i].shape.x = 1;
+
+		if (metadata->input[i].shape.y == 0)
+			metadata->input[i].shape.y = 1;
+
+		if (metadata->input[i].shape.z == 0)
+			metadata->input[i].shape.z = 1;
+	}
+
+	for (i = 0; i < metadata->model.num_output; i++) {
+		metadata->output[i].output_type =
+			cn10k_ml_io_type_map(metadata->output[i].output_type);
+		metadata->output[i].model_output_type =
+			cn10k_ml_io_type_map(metadata->output[i].model_output_type);
+	}
+}
diff --git a/drivers/ml/cnxk/cn10k_ml_model.h b/drivers/ml/cnxk/cn10k_ml_model.h
index a9f7b169de..dc30bc2aa7 100644
--- a/drivers/ml/cnxk/cn10k_ml_model.h
+++ b/drivers/ml/cnxk/cn10k_ml_model.h
@@ -19,6 +19,309 @@ enum cn10k_ml_model_state {
 	ML_CN10K_MODEL_STATE_UNKNOWN,
 };
 
+/* Model Metadata : v 2.1.0.2 */
+#define MRVL_ML_MODEL_MAGIC_STRING "MRVL"
+#define MRVL_ML_MODEL_TARGET_ARCH  128
+#define MRVL_ML_MODEL_VERSION	   2100
+#define MRVL_ML_MODEL_NAME_LEN	   64
+#define MRVL_ML_INPUT_NAME_LEN	   16
+#define MRVL_ML_OUTPUT_NAME_LEN	   16
+#define MRVL_ML_INPUT_OUTPUT_SIZE  8
+
+/* Model file metadata structure */
+struct cn10k_ml_model_metadata {
+	/* Header (256-byte) */
+	struct {
+		/* Magic string ('M', 'R', 'V', 'L') */
+		uint8_t magic[4];
+
+		/* Metadata version */
+		uint8_t version[4];
+
+		/* Metadata size */
+		uint32_t metadata_size;
+
+		/* Unique ID */
+		uint8_t uuid[128];
+
+		/* Model target architecture
+		 * 0 = Undefined
+		 * 1 = M1K
+		 * 128 = MLIP
+		 * 256 = Experimental
+		 */
+		uint32_t target_architecture;
+		uint8_t reserved[104];
+
+		/* CRC of data after metadata_header (i.e. after first 256 bytes) */
+		uint32_t payload_crc32c;
+
+		/* CRC of first 252 bytes of metadata_header, after payload_crc calculation */
+		uint32_t header_crc32c;
+	} metadata_header;
+
+	/* Model information (256-byte) */
+	struct {
+		/* Model name string */
+		uint8_t name[MRVL_ML_MODEL_NAME_LEN];
+
+		/* Model version info (xx.xx.xx.xx) */
+		uint8_t version[4];
+
+		/* Model code size (Init + Main + Finish) */
+		uint32_t code_size;
+
+		/* Model data size (Weights and Bias) */
+		uint32_t data_size;
+
+		/* OCM start offset, set to ocm_wb_range_start */
+		uint32_t ocm_start;
+
+		/* OCM start offset, set to max OCM size */
+		uint32_t ocm_end;
+
+		/* Relocatable flag (always yes)
+		 * 0 = Not relocatable
+		 * 1 = Relocatable
+		 */
+		uint8_t ocm_relocatable;
+
+		/* Tile relocatable flag (always yes)
+		 * 0 = Not relocatable
+		 * 1 = Relocatable
+		 */
+		uint8_t tile_relocatable;
+
+		/* Start tile (Always 0) */
+		uint8_t tile_start;
+
+		/* End tile (num_tiles - 1) */
+		uint8_t tile_end;
+
+		/* Inference batch size */
+		uint8_t batch_size;
+
+		/* Number of input tensors (Max 8) */
+		uint8_t num_input;
+
+		/* Number of output tensors (Max 8) */
+		uint8_t num_output;
+		uint8_t reserved1;
+
+		/* Total input size in bytes */
+		uint32_t input_size;
+
+		/* Total output size in bytes */
+		uint32_t output_size;
+
+		/* Table size in bytes */
+		uint32_t table_size;
+
+		/* Number of layers in the network */
+		uint32_t num_layers;
+		uint32_t reserved2;
+
+		/* Floor of absolute OCM region */
+		uint64_t ocm_tmp_range_floor;
+
+		/* Relative OCM start address of WB data block */
+		uint64_t ocm_wb_range_start;
+
+		/* Relative OCM end address of WB data block */
+		uint64_t ocm_wb_range_end;
+
+		/* Relative DDR start address of WB data block */
+		uint64_t ddr_wb_range_start;
+
+		/* Relative DDR end address of all outputs */
+		uint64_t ddr_wb_range_end;
+
+		/* Relative DDR start address of all inputs */
+		uint64_t ddr_input_range_start;
+
+		/* Relative DDR end address of all inputs */
+		uint64_t ddr_input_range_end;
+
+		/* Relative DDR start address of all outputs */
+		uint64_t ddr_output_range_start;
+
+		/* Relative DDR end address of all outputs */
+		uint64_t ddr_output_range_end;
+
+		/* Compiler version */
+		uint8_t compiler_version[8];
+
+		/* CDK version */
+		uint8_t cdk_version[4];
+
+		/* Lower batch optimization support
+		 * 0 - No,
+		 * 1 - Yes
+		 */
+		uint8_t supports_lower_batch_size_optimization;
+		uint8_t reserved3[59];
+	} model;
+
+	/* Init section (64-byte) */
+	struct {
+		uint32_t file_offset;
+		uint32_t file_size;
+		uint8_t reserved[56];
+	} init_model;
+
+	/* Main section (64-byte) */
+	struct {
+		uint32_t file_offset;
+		uint32_t file_size;
+		uint8_t reserved[56];
+	} main_model;
+
+	/* Finish section (64-byte) */
+	struct {
+		uint32_t file_offset;
+		uint32_t file_size;
+		uint8_t reserved[56];
+	} finish_model;
+
+	uint8_t reserved1[512]; /* End of 2k bytes */
+
+	/* Weights and Bias (64-byte) */
+	struct {
+		/* Memory offset, set to ddr_wb_range_start */
+		uint64_t mem_offset;
+		uint32_t file_offset;
+		uint32_t file_size;
+
+		/* Relocatable flag for WB
+		 * 1 = Relocatable
+		 * 2 = Not relocatable
+		 */
+		uint8_t relocatable;
+		uint8_t reserved[47];
+	} weights_bias;
+
+	/* Input (512-byte, 64-byte per input) provisioned for 8 inputs */
+	struct {
+		/* DDR offset (in OCM absolute addresses for input) */
+		uint64_t mem_offset;
+
+		/* Relocatable flag
+		 * 1 = Relocatable
+		 * 2 = Not relocatable
+		 */
+		uint8_t relocatable;
+
+		/* Input quantization
+		 * 1 = Requires quantization
+		 * 2 = Pre-quantized
+		 */
+		uint8_t quantize;
+
+		/* Type of incoming input
+		 * 1 = INT8, 2 = UINT8, 3 = INT16, 4 = UINT16,
+		 * 5 = INT32, 6 = UINT32, 7 = FP16, 8 = FP32
+		 */
+		uint8_t input_type;
+
+		/* Type of input required by model
+		 * 1 = INT8, 2 = UINT8, 3 = INT16, 4 = UINT16,
+		 * 5 = INT32, 6 = UINT32, 7 = FP16, 8 = FP32
+		 */
+		uint8_t model_input_type;
+
+		/* float_32 qscale value
+		 * quantized = non-quantized * qscale
+		 */
+		float qscale;
+
+		/* Input shape */
+		struct {
+			/* Input format
+			 * 1 = NCHW
+			 * 2 = NHWC
+			 */
+			uint8_t format;
+			uint8_t reserved[3];
+			uint32_t w;
+			uint32_t x;
+			uint32_t y;
+			uint32_t z;
+		} shape;
+		uint8_t reserved[4];
+
+		/* Name of input */
+		uint8_t input_name[MRVL_ML_INPUT_NAME_LEN];
+
+		/* DDR range end
+		 * new = mem_offset + size_bytes - 1
+		 */
+		uint64_t ddr_range_end;
+	} input[MRVL_ML_INPUT_OUTPUT_SIZE];
+
+	/* Output (512 byte, 64-byte per input) provisioned for 8 outputs */
+	struct {
+		/* DDR offset in OCM absolute addresses for output */
+		uint64_t mem_offset;
+
+		/* Relocatable flag
+		 * 1 = Relocatable
+		 * 2 = Not relocatable
+		 */
+		uint8_t relocatable;
+
+		/* Output dequantization
+		 * 1 = De-quantization required
+		 * 2 = De-quantization not required
+		 */
+		uint8_t dequantize;
+
+		/* Type of outgoing output
+		 * 1 = INT8, 2 = UINT8, 3 = INT16, 4 = UINT16
+		 * 5 = INT32, 6 = UINT32, 7 = FP16, 8 = FP32
+		 */
+		uint8_t output_type;
+
+		/* Type of output produced by model
+		 * 1 = INT8, 2 = UINT8, 3 = INT16, 4 = UINT16
+		 * 5 = INT32, 6 = UINT32, 7 = FP16, 8 = FP32
+		 */
+		uint8_t model_output_type;
+
+		/* float_32 dscale value
+		 * dequantized = quantized * dscale
+		 */
+		float dscale;
+
+		/* Number of items in the output */
+		uint32_t size;
+		uint8_t reserved[20];
+
+		/* DDR range end
+		 * new = mem_offset + size_bytes - 1
+		 */
+		uint64_t ddr_range_end;
+		uint8_t output_name[MRVL_ML_OUTPUT_NAME_LEN];
+	} output[MRVL_ML_INPUT_OUTPUT_SIZE];
+
+	uint8_t reserved2[1792];
+
+	/* Model data */
+	struct {
+		uint8_t reserved1[4068];
+
+		/* Beta: xx.xx.xx.xx,
+		 * Later: YYYYMM.xx.xx
+		 */
+		uint8_t compiler_version[8];
+
+		/* M1K CDK version (xx.xx.xx.xx) */
+		uint8_t m1k_cdk_version[4];
+	} data;
+
+	/* Hidden 16 bytes of magic code */
+	uint8_t reserved3[16];
+};
+
 /* Model Object */
 struct cn10k_ml_model {
 	/* Device reference */
@@ -30,6 +333,12 @@ struct cn10k_ml_model {
 	/* ID */
 	uint16_t model_id;
 
+	/* Batch size */
+	uint32_t batch_size;
+
+	/* Metadata */
+	struct cn10k_ml_model_metadata metadata;
+
 	/* Spinlock, used to update model state */
 	plt_spinlock_t lock;
 
@@ -37,4 +346,7 @@ struct cn10k_ml_model {
 	enum cn10k_ml_model_state state;
 };
 
+int cn10k_ml_model_metadata_check(uint8_t *buffer, uint64_t size);
+void cn10k_ml_model_metadata_update(struct cn10k_ml_model_metadata *metadata);
+
 #endif /* _CN10K_ML_MODEL_H_ */
diff --git a/drivers/ml/cnxk/cn10k_ml_ops.c b/drivers/ml/cnxk/cn10k_ml_ops.c
index 0955fa0d76..2cde795903 100644
--- a/drivers/ml/cnxk/cn10k_ml_ops.c
+++ b/drivers/ml/cnxk/cn10k_ml_ops.c
@@ -416,8 +416,11 @@ cn10k_ml_model_load(struct rte_ml_dev *dev, struct rte_ml_model_params *params,
 	uint64_t mz_size;
 	uint16_t idx;
 	bool found;
+	int ret;
 
-	PLT_SET_USED(params);
+	ret = cn10k_ml_model_metadata_check(params->addr, params->size);
+	if (ret != 0)
+		return ret;
 
 	mldev = dev->data->dev_private;
 
@@ -450,6 +453,15 @@ cn10k_ml_model_load(struct rte_ml_dev *dev, struct rte_ml_model_params *params,
 	model->mldev = mldev;
 	model->model_id = idx;
 
+	rte_memcpy(&model->metadata, params->addr, sizeof(struct cn10k_ml_model_metadata));
+	cn10k_ml_model_metadata_update(&model->metadata);
+
+	/* Enable support for batch_size of 256 */
+	if (model->metadata.model.batch_size == 0)
+		model->batch_size = 256;
+	else
+		model->batch_size = model->metadata.model.batch_size;
+
 	plt_spinlock_init(&model->lock);
 	model->state = ML_CN10K_MODEL_STATE_LOADED;
 	dev->data->models[idx] = model;
diff --git a/drivers/ml/cnxk/meson.build b/drivers/ml/cnxk/meson.build
index bf7a9c0225..799e8f2470 100644
--- a/drivers/ml/cnxk/meson.build
+++ b/drivers/ml/cnxk/meson.build
@@ -19,7 +19,7 @@ sources = files(
         'cn10k_ml_model.c',
 )
 
-deps += ['mldev', 'common_cnxk', 'kvargs']
+deps += ['mldev', 'common_cnxk', 'kvargs', 'hash']
 
 if get_option('buildtype').contains('debug')
         cflags += [ '-DCNXK_ML_DEV_DEBUG' ]
-- 
2.17.1