Re: [U-Boot] [u-boot][PATCH v2] drivers/fsl-mc: Support DPSPARSER object and apply spb command

-----Original Message----- From: U-Boot u-boot-bounces@lists.denx.de On Behalf Of Florinel Iordache Sent: Tuesday, November 19, 2019 3:58 PM To: u-boot@lists.denx.de Subject: [U-Boot] [u-boot][PATCH v2] drivers/fsl-mc: Support DPSPARSER object and apply spb command

Add support for DPSPARSER object (create/destroy, open/close, apply spb) required to configure Soft Parser by using MC. Also add uboot command to apply Soft Parser Blob with command: fsl_mc apply spb <spb_load_addr>

Signed-off-by: Florinel Iordache florinel.iordache@nxp.com

drivers/net/fsl-mc/Kconfig | 12 ++ drivers/net/fsl-mc/Makefile | 4 +- drivers/net/fsl-mc/dpsparser.c | 138 +++++++++++++++++++++ drivers/net/fsl-mc/mc.c | 264 ++++++++++++++++++++++++++++++++++++---- include/fsl-mc/fsl_dpsparser.h | 208 +++++++++++++++++++++++++++++++ include/fsl-mc/fsl_mc_private.h | 17 ++- 6 files changed, 620 insertions(+), 23 deletions(-) create mode 100644 drivers/net/fsl-mc/dpsparser.c create mode 100644 include/fsl- mc/fsl_dpsparser.h

diff --git a/drivers/net/fsl-mc/Kconfig b/drivers/net/fsl-mc/Kconfig index 25a2cb8..2cf651d 100644 --- a/drivers/net/fsl-mc/Kconfig +++ b/drivers/net/fsl-mc/Kconfig @@ -22,4 +22,16 @@ config SYS_MC_RSV_MEM_ALIGN Reserved memory needs to be aligned for MC to use. Default value is 512MB.

+config MC_DRAM_SPB_OFFSET

• hex "Soft Parser SPB DRAM offset"
• default 0x00F40000
• help

•  Set the DRAM offset for Soft Parser Blob.
  

+config MC_SPB_MAX_SIZE

• hex "Soft Parser SPB maximum size"
• default 0x00020000
• help

•  Set the maximum size for Soft Parser Blob.
  

endif # FSL_MC_ENET diff --git a/drivers/net/fsl-mc/Makefile b/drivers/net/fsl-mc/Makefile index 1b1b4a7..5a1acd5 100644 --- a/drivers/net/fsl-mc/Makefile +++ b/drivers/net/fsl-mc/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0+ # # Copyright 2014 Freescale Semiconductor, Inc. +# Copyright 2018 NXP

Since file is getting changed in 2019 as well. Please update to 2018-2019

# Layerscape MC driver obj-y += mc.o \ @@ -9,5 +10,6 @@ obj-y += mc.o \ dprc.o \ dpbp.o \ dpni.o \

• dpmac.o

• dpmac.o \
• dpsparser.o

obj-y += dpio/ diff --git a/drivers/net/fsl-mc/dpsparser.c b/drivers/net/fsl-mc/dpsparser.c new file mode 100644 index 0000000..cfd1ba6 --- /dev/null +++ b/drivers/net/fsl-mc/dpsparser.c @@ -0,0 +1,138 @@ +// SPDX-License-Identifier: GPL-2.0+ +/*

• • Data Path Soft Parser
• • Copyright 2018 NXP

Same as above

• */

+#include <fsl-mc/fsl_mc_sys.h> +#include <fsl-mc/fsl_mc_cmd.h> +#include <fsl-mc/fsl_dpsparser.h>

+int dpsparser_open(struct fsl_mc_io *mc_io,

•    u32 cmd_flags,
  

•    u16 *token)
  

+{

• struct mc_command cmd = { 0 };
• int err;
• /* prepare command */
• cmd.header = mc_encode_cmd_header(DPSPARSER_CMDID_OPEN,

• 			  cmd_flags,
  

• 			  0);
  

• /* send command to mc*/
• err = mc_send_command(mc_io, &cmd);
• if (err)

• return err;
  

• /* retrieve response parameters */
• *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
• return err;

+}

+int dpsparser_close(struct fsl_mc_io *mc_io,

•     u32 cmd_flags,
  

•     u16 token)
  

+{

• struct mc_command cmd = { 0 };
• /* prepare command */
• cmd.header = mc_encode_cmd_header(DPSPARSER_CMDID_CLOSE,

cmd_flags,

• 			  token);
  

• /* send command to mc*/
• return mc_send_command(mc_io, &cmd);

+}

+int dpsparser_create(struct fsl_mc_io *mc_io,

•      u16 token,
  

•      u32 cmd_flags,
  

•      u32 *obj_id)
  

+{

• struct mc_command cmd = { 0 };
• int err;
• /* prepare command */
• cmd.header = mc_encode_cmd_header(DPSPARSER_CMDID_CREATE,

• 			  cmd_flags,
  

• 			  token);
  

• /* send command to mc*/
• err = mc_send_command(mc_io, &cmd);
• if (err)

• return err;
  

• /* retrieve response parameters */
• MC_CMD_READ_OBJ_ID(cmd, *obj_id);
• return 0;

+}

+int dpsparser_destroy(struct fsl_mc_io *mc_io,

•       u16 token,
  

•       u32 cmd_flags,
  

•       u32 obj_id)
  

+{

• struct mc_command cmd = { 0 };
• /* prepare command */
• cmd.header = mc_encode_cmd_header(DPSPARSER_CMDID_DESTROY,

• 			  cmd_flags,
  

• 			  token);
  

• /* set object id to destroy */
• CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
• /* send command to mc*/
• return mc_send_command(mc_io, &cmd);

+}

+int dpsparser_apply_spb(struct fsl_mc_io *mc_io,

• 	u32 cmd_flags,
  

• 	u16 token,
  

• 	u64 blob_addr,
  

• 	u16 *error)
  

+{

• struct mc_command cmd = { 0 };
• int err;
• /* prepare command */
• cmd.header =

mc_encode_cmd_header(DPSPARSER_CMDID_APPLY_SPB,

• 			  cmd_flags,
  

• 			  token);
  

• DPSPARSER_CMD_BLOB_SET_ADDR(cmd, blob_addr);
• /* send command to mc*/
• err = mc_send_command(mc_io, &cmd);
• if (err)

• return err;
  

• /* retrieve response parameters: MC error code */
• DPSPARSER_CMD_BLOB_REPORT_ERROR(cmd, *error);
• return 0;

+}

+int dpsparser_get_api_version(struct fsl_mc_io *mc_io,

• 	      u32 cmd_flags,
  

• 	      u16 *major_ver,
  

• 	      u16 *minor_ver)
  

+{

• struct mc_command cmd = { 0 };
• int err;
• /* prepare command */
• cmd.header =

mc_encode_cmd_header(DPSPARSER_CMDID_GET_API_VERSION,

• 			  cmd_flags, 0);
  

• /* send command to mc */
• err = mc_send_command(mc_io, &cmd);
• if (err)

• return err;
  

• /* retrieve response parameters */
• mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
• return 0;

+} diff --git a/drivers/net/fsl-mc/mc.c b/drivers/net/fsl-mc/mc.c index c980ba4..f760249 100644 --- a/drivers/net/fsl-mc/mc.c +++ b/drivers/net/fsl-mc/mc.c @@ -1,7 +1,6 @@ // SPDX-License-Identifier: GPL-2.0+ /*

• Copyright 2014 Freescale Semiconductor, Inc.

• • Copyright 2017 NXP

• Copyright 2017-2018 NXP

Same as above

*/ #include <common.h> @@ -19,6 +18,7 @@ #include <fsl-mc/fsl_dprc.h> #include <fsl-mc/fsl_dpio.h> #include <fsl-mc/fsl_dpni.h> +#include <fsl-mc/fsl_dpsparser.h> #include <fsl-mc/fsl_qbman_portal.h> #include <fsl-mc/ldpaa_wriop.h>

@@ -33,6 +33,7 @@

DECLARE_GLOBAL_DATA_PTR; static int mc_memset_resv_ram; +static struct mc_version mc_ver_info; static int mc_boot_status = -1; static int mc_dpl_applied = -1; #ifdef CONFIG_SYS_LS_MC_DRAM_AIOP_IMG_OFFSET @@ -47,6 +48,9 @@ struct fsl_dpbp_obj *dflt_dpbp = NULL; struct fsl_dpio_obj *dflt_dpio = NULL; struct fsl_dpni_obj *dflt_dpni = NULL; static u64 mc_lazy_dpl_addr; +static u32 dpsparser_obj_id; +static u16 dpsparser_handle; +static char *mc_err_msg_apply_spb[] = MC_ERROR_MSG_APPLY_SPB;

#ifdef DEBUG void dump_ram_words(const char *title, void *addr) @@ -90,7 +94,6 @@ void dump_mc_ccsr_regs(struct mc_ccsr_registers __iomem *mc_ccsr_regs)

#endif /* DEBUG */

-#ifndef CONFIG_SYS_LS_MC_FW_IN_DDR /**

• Copying MC firmware or DPL image to DDR

*/ @@ -103,6 +106,7 @@ static int mc_copy_image(const char *title, return 0; }

+#ifndef CONFIG_SYS_LS_MC_FW_IN_DDR /**

• MC firmware FIT image parser checks if the image is in FIT
• format, verifies integrity of the image and calculates @@ -689,7 +693,6 @@

int mc_init(u64 mc_fw_addr, u64 mc_dpc_addr) const void *raw_image_addr; size_t raw_image_size = 0; #endif

• struct mc_version mc_ver_info; u8 mc_ram_num_256mb_blocks; size_t mc_ram_size = mc_get_dram_block_size();

@@ -1445,6 +1448,170 @@ err: return err; }

+static bool is_dpsparser_supported(void) {

• /* dpsparser support was first introduced in MC version: 10.12.0 */
• if (mc_ver_info.major < 10)

• return false;
  

• if (mc_ver_info.major == 10)

• return (mc_ver_info.minor >= 12);
  

• return true;

+}

+static int dpsparser_version_check(struct fsl_mc_io *mc_io) {

• int error;
• u16 major_ver, minor_ver;
• if (!is_dpsparser_supported())

• return 0;
  

• error = dpsparser_get_api_version(mc_io, 0,

• 			  &major_ver,
  

• 			  &minor_ver);
  

• if (error < 0) {

• printf("dpsparser_get_api_version() failed: %d\n", error);
  

• return error;
  

• }
• if (major_ver < DPSPARSER_VER_MAJOR || (major_ver ==

•    DPSPARSER_VER_MAJOR && minor_ver < DPSPARSER_VER_MINOR))
  

{

• printf("DPSPARSER version mismatch found %u.%u,",
  

•        major_ver, minor_ver);
  

• printf("supported version is %u.%u\n",
  

•        DPSPARSER_VER_MAJOR, DPSPARSER_VER_MINOR);
  

• }
• return error;

+}

+static int dpsparser_init(void) +{

• int err = 0;
• if (!is_dpsparser_supported())

• return 0;
  

• err = dpsparser_create(dflt_mc_io,

• 	       dflt_dprc_handle,
  

• 	       MC_CMD_NO_FLAGS,
  

• 	       &dpsparser_obj_id);
  

• if (err)

• printf("dpsparser_create() failed\n");
  

• err = dpsparser_version_check(dflt_mc_io);
• if (err < 0) {

• printf("dpsparser_version_check() failed: %d\n", err);
  

• goto err_version_check;
  

• }
• err = dpsparser_open(dflt_mc_io,

• 	     MC_CMD_NO_FLAGS,
  

• 	     &dpsparser_handle);
  

• if (err < 0) {

• printf("dpsparser_open() failed: %d\n", err);
  

• goto err_open;
  

• }
• return err;

+err_open: +err_version_check:

• dpsparser_destroy(dflt_mc_io,

• 	  dflt_dprc_handle,
  

• 	  MC_CMD_NO_FLAGS, dpsparser_obj_id);
  

• return err;

+}

+#ifdef DPSPARSER_DESTROY +/* TODO: refactoring needed in the future to allow DPSPARSER object +destroy

• • Workaround: DO NOT destroy DPSPARSER object because it needs to be

+available

• • on Apply DPL
• */

+static int dpsparser_exit(void) +{

• int err;
• if (!is_dpsparser_supported())

• return 0;
  

• dpsparser_close(dflt_mc_io, MC_CMD_NO_FLAGS, dpsparser_handle);
• if (err < 0) {

• printf("dpsparser_close() failed: %d\n", err);
  

• goto err;
  

• }
• err = dpsparser_destroy(dflt_mc_io, dflt_dprc_handle,

• 		MC_CMD_NO_FLAGS, dpsparser_obj_id);
  

• if (err < 0) {

• printf("dpsparser_destroy() failed: %d\n", err);
  

• goto err;
  

• }
• return 0;

+err:

• return err;

+} +#endif

+int mc_apply_spb(u64 mc_spb_addr) +{

• int err = 0;
• u16 error, err_arr_size;
• u64 mc_spb_offset;
• u32 spb_size;
• struct sp_blob_header *sp_blob;
• u64 mc_ram_addr = mc_get_dram_addr();
• if (!is_dpsparser_supported())

• return 0;
  

• if (!mc_spb_addr) {

• printf("fsl-mc: Invalid Blob address\n");
  

• return -1;
  

• }

+#ifdef CONFIG_MC_DRAM_SPB_OFFSET

• mc_spb_offset = CONFIG_MC_DRAM_SPB_OFFSET; #else #error

+"CONFIG_MC_DRAM_SPB_OFFSET not defined" +#endif

• // Read blob header and get size of SPB blob
• sp_blob = (struct sp_blob_header *)mc_spb_addr;
• spb_size = le32_to_cpu(sp_blob->length);
• if (spb_size > CONFIG_MC_SPB_MAX_SIZE) {

• printf("\nfsl-mc: ERROR: Bad SPB image (too large: %d)\n",
  

•        spb_size);
  

• return -EINVAL;
  

• }
• mc_copy_image("MC SP Blob", mc_spb_addr, spb_size,

•       mc_ram_addr + mc_spb_offset);
  

• //Invoke MC command to apply SPB blob
• printf("fsl-mc: Applying soft parser blob... ");
• err = dpsparser_apply_spb(dflt_mc_io, MC_CMD_NO_FLAGS,

dpsparser_handle,

• 		  mc_spb_offset, &error);
  

• if (err)

• return err;
  

• if (error == 0) {

• printf("SUCCESS\n");
  

• } else {

• printf("FAILED with error code = %d:\n", error);
  

• err_arr_size = (u16)ARRAY_SIZE(mc_err_msg_apply_spb);
  

• if (error > 0 && error < err_arr_size)
  

• 	printf(mc_err_msg_apply_spb[error]);
  

• else
  

• 	printf(MC_ERROR_MSG_SPB_UNKNOWN);
  

• }
• return err;

+}

static int mc_init_object(void) { int err = 0; @@ -1473,6 +1640,12 @@ static int mc_init_object(void) goto err; }

• err = dpsparser_init();
• if (err < 0) {

• printf("dpsparser_init() failed: %d\n", err);
  

• goto err;
  

• }
• return 0;

err: return err; @@ -1606,39 +1779,87 @@ static int do_fsl_mc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) } break;

• case 'l':

• case 'l': {

• /* lazyapply */
  

• u64 mc_dpl_addr;
  

• if (argc < 4)
  

• 	goto usage;
  

• if (get_dpl_apply_status() == 0) {
  

• 	printf("fsl-mc: DPL already applied\n");
  

• 	return err;
  

• }
  

• mc_dpl_addr = simple_strtoull(argv[3], NULL, 16);
  

• if (get_mc_boot_status() != 0) {
  

• 	printf("fsl-mc: Deploying data path layout ..");
  

• 	printf("ERROR (MC is not booted)\n");
  

• 	return -ENODEV;
  

• }
  

• /*
  

•  * We will do the actual dpaa exit and dpl apply
  

•  * later from announce_and_cleanup().
  

•  */
  

• mc_lazy_dpl_addr = mc_dpl_addr;
  

• break;
  

• }
  

• case 'a': {

• 	u64 mc_dpl_addr;
  

• /* apply */
  

• char sub_cmd;
  

• u64 mc_apply_addr;
  
  

• 	if (argc < 4)
  

• 		goto usage;
  

• if (argc < 4)
  

• 	goto usage;
  

• sub_cmd = argv[2][0];
  
  

• switch (sub_cmd) {
  

• case 'd':
  

• case 'D':
  if (get_dpl_apply_status() == 0) {
  	printf("fsl-mc: DPL already applied\n");
  	return err;
  }
  

• 	mc_dpl_addr = simple_strtoull(argv[3], NULL,
  

• 					      16);
  

• if (get_mc_boot_status() != 0) {
  	printf("fsl-mc: Deploying data path layout ..");
  	printf("ERROR (MC is not booted)\n");
  	return -ENODEV;
  }
  
  

• 	if (argv[1][0] == 'l') {
  

• 		/*
  

• 		 * We will do the actual dpaa exit and dpl apply
  

• 		 * later from announce_and_cleanup().
  

• 		 */
  

• 		mc_lazy_dpl_addr = mc_dpl_addr;
  

• 	} else {
  

• 		/* The user wants it applied now */
  

• 		if (!fsl_mc_ldpaa_exit(NULL))
  

• 			err = mc_apply_dpl(mc_dpl_addr);
  

• 	mc_apply_addr = simple_strtoull(argv[3], NULL, 16);
  

• 	/* The user wants DPL applied now */
  

• 	if (!fsl_mc_ldpaa_exit(NULL))
  

• 		err = mc_apply_dpl(mc_apply_addr);
  

• 	break;
  

• case 's':
  

• 	if (!is_dpsparser_supported()) {
  

• 		printf("fsl-mc: apply spb command .. ");
  

• 		printf("ERROR: requires at least MC
  

10.12.0\n");

• 		return err;
  }
  

• 	if (get_mc_boot_status() != 0) {
  

• 		printf("fsl-mc: Deploying Soft Parser Blob...");
  

• 		printf("ERROR (MC is not booted)\n");
  

• 		return err;
  

• 	}
  

• 	mc_apply_addr = simple_strtoull(argv[3], NULL, 16);
  

• 	/* Apply spb (Soft Parser Blob) */
  

• 	err = mc_apply_spb(mc_apply_addr);
  break;
  

• default:
  

• 	printf("Invalid option: %s\n", argv[2]);
  

• 	goto usage;
  

• }
  

• break;
  

  } default: printf("Invalid option: %s\n", argv[1]); @@ -1656,6 +1877,7 @@

U_BOOT_CMD( "start mc [FW_addr] [DPC_addr] - Start Management Complex\n" "fsl_mc apply DPL [DPL_addr] - Apply DPL file\n" "fsl_mc lazyapply DPL [DPL_addr] - Apply DPL file on exit\n"

• "fsl_mc apply spb [spb_addr] - Apply SPB Soft Parser Blob\n" "fsl_mc start aiop [FW_addr] - Start AIOP\n"

);

diff --git a/include/fsl-mc/fsl_dpsparser.h b/include/fsl-mc/fsl_dpsparser.h new file mode 100644 index 0000000..48fb495 --- /dev/null +++ b/include/fsl-mc/fsl_dpsparser.h @@ -0,0 +1,208 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/*

• • Data Path Soft Parser API
• • Copyright 2018 NXP

Same as above

• */

+#ifndef _FSL_DPSPARSER_H +#define _FSL_DPSPARSER_H

+/* DPSPARSER last supported API version */ +#define DPSPARSER_VER_MAJOR 1 +#define DPSPARSER_VER_MINOR 0

+/* Command IDs */ +#define DPSPARSER_CMDID_CLOSE 0x8001 +#define DPSPARSER_CMDID_OPEN 0x8111 +#define DPSPARSER_CMDID_CREATE 0x9111 +#define DPSPARSER_CMDID_DESTROY 0x9911 +#define DPSPARSER_CMDID_GET_API_VERSION 0xa111

+#define DPSPARSER_CMDID_APPLY_SPB 0x1181

+/* cmd, param, offset, width, type, arg_name */ +#define DPSPARSER_CMD_BLOB_SET_ADDR(cmd, addr) \

• MC_CMD_OP(cmd, 0, 0, 64, u64, addr)

+/* cmd, param, offset, width, type, arg_name */ +#define DPSPARSER_CMD_BLOB_REPORT_ERROR(cmd, err) \

• MC_RSP_OP(cmd, 0, 0, 16, u16, err)

+/* Data Path Soft Parser API

• • Contains initialization APIs and runtime control APIs for DPSPARSER

+*/

+struct fsl_mc_io;

+/* MC Unknown error: */ +#define MC_ERROR_MSG_SPB_UNKNOWN "Unknown MC error\n"

+/* MC Error messages (in order for each error code defined above): */ +#define MC_ERROR_MSG_APPLY_SPB \ { \

• "OK\n", \
• "BLOB : Magic number does not match\n", \
• "BLOB : Version does not match MC API version\n", \
• "BLOB : IP revision does not match HW revision\n", \
• "BLOB : Blob length is not a multiple of 4\n", \
• "BLOB : Invalid length detected\n", \
• "BLOB : Name length < 0 in 'blob-name'\n", \
• "BLOB : Name length not a 4 multiple in 'blob-name'\n", \
• "BLOB : No target HW parser selected\n", \
• "BLOB : SP size is negative\n", \
• "BLOB : Size is zero\n", \
• "BLOB : Number of protocols is negative\n", \
• "BLOB : Zero protocols\n", \
• "BLOB : Protocol name is null\n", \
• "BLOB : SP 'seq-start' is not in [0x40, 0xffc0) range\n", \
• "BLOB : Invalid base protocol\n", \
• "BLOB : Invalid parameters section\n", \
• "BLOB : Invalid parameter\n", \
• "BLOB : Invalid parameter configuration\n", \
• "BLOB : Not aligned value\n", \
• "BLOB : Invalid section TAG detected\n", \
• "BLOB : Section size is zero\n", \
• "BLOB : Section size not a 4 multiple\n", \
• "BLOB : Section size is too big\n", \
• "BLOB : No 'bytecode' section before\n", \
• "BLOB : No 'sp-protocols' section before\n", \
• "BLOB : No 'bytecode' section defined\n", \
• "BLOB : No 'sp-protocols' section defined\n", \
• "BLOB : Soft Parser BLOB parsing : Error detected\n", \
• "apply spb : Soft Parser BLOB is already applied\n", \
• "apply spb : BLOB address is not set\n", \
• "BLOB : SP parameter offset is not a 4 multiple\n", \
• "BLOB : SP parameter offset can't be less than 0x40\n", \
• "BLOB : Bytecode size is not a 4 multiple\n", \
• "BLOB : Bytecode size cannot be zero\n", \
• "BLOB : Bytecode can't overwrite the 0xFFE address\n", \
• "BLOB : No hardware parser selected as target\n", \
• "BLOB : Bytecode overlap detected\n", \
• "BLOB : No parser support\n", \
• "BLOB : Too many bytecode sections on WRIOP ingress\n", \
• "BLOB : Too many bytecode sections on WRIOP egress\n", \
• "BLOB : Too many bytecode sections on AIOP\n", \
• "BLOB : Duplicated protocol is already registered\n", \
• "BLOB : Maximum number of allowed protocols was exceeded\n", \
• "BLOB : Protocols limit exceeded\n", \
• "BLOB : Protocol is linked twice\n", \
• "BLOB : Soft parser is linked twice\n", \
• "BLOB : Parameter offset exceeds the maximum parameters limit\n", \
• "BLOB : Parameter size can't be 0 or greater than 64\n", \
• "BLOB : Parameter offset plus size exceeds the maximum limit\n", \
• "BLOB : Parameters number exceeds the maximum limit\n", \
• "BLOB : Duplicated parameter name\n", \
• "BLOB : Parameters overlapped detected\n", \
• "apply spb : No dpsparser handle.\n", \
• \
• MC_ERROR_MSG_SPB_UNKNOWN, \
• NULL, \

+}

+/**

• • dpsparser_open() - Open a control session for the specified object.
• • @mc_io: Pointer to MC portal's I/O object
• • @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
• • @token: Returned token; use in subsequent API calls
• • This function can be used to open a control session for an
• • already created object; an object may have been declared in
• • the DPL or by calling the dpsparser_create function.
• • This function returns a unique authentication token,
• • associated with the specific object ID and the specific MC
• • portal; this token must be used in all subsequent commands for
• • this specific object
• • Return: '0' on Success; Error code otherwise.
• */

+int dpsparser_open(struct fsl_mc_io *mc_io,

•    u32 cmd_flags,
  

•    u16 *token);
  

+/**

• • dpsparser_close() - Close the control session of the object
• • @mc_io: Pointer to MC portal's I/O object
• • @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
• • @token: Token of DPSPARSER object
• • After this function is called, no further operations are
• • allowed on the object without opening a new control session.
• • Return: '0' on Success; Error code otherwise.
• */

+int dpsparser_close(struct fsl_mc_io *mc_io,

•     u32 cmd_flags,
  

•     u16	token);
  

+/**

• • dpsparser_create() - Create the DPSPARSER object.
• • @mc_io: Pointer to MC portal's I/O object
• • @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
• • @token: Returned token; use in subsequent API calls
• • Create the DPSPARSER object, allocate required resources and
• • perform required initialization.
• • The object can be created either by declaring it in the
• • DPL file, or by calling this function.
• • This function returns a unique authentication token,
• • associated with the specific object ID and the specific MC
• • portal; this token must be used in all subsequent calls to
• • this specific object. For objects that are created using the
• • DPL file, call dpsparser_open function to get an authentication
• • token first.
• • Return: '0' on Success; Error code otherwise.
• */

+int dpsparser_create(struct fsl_mc_io *mc_io,

•      u16 token,
  

•      u32 cmd_flags,
  

•      u32 *obj_id);
  

+/**

• • dpsparser_destroy() - Destroy the DPSPARSER object and release all

+its

• • resources.
• • @mc_io: Pointer to MC portal's I/O object
• • @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
• • @token: Token of DPSPARSER object
• • Return: '0' on Success; error code otherwise.
• */

+int dpsparser_destroy(struct fsl_mc_io *mc_io,

•       u16 token,
  

•       u32 cmd_flags,
  

•       u32 obj_id);
  

+/**

• • dpsparser_apply_spb() - Applies the Soft Parser Blob loaded at

+specified

• • address.
• • @mc_io: Pointer to MC portal's I/O object
• • @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
• • @token: Token of DPSPARSER object
• • @blob_addr: Blob loading address
• • @error: Error reported by MC related to SP Blob parsing and apply
• • Return: '0' on Success; error code otherwise.
• */

+int dpsparser_apply_spb(struct fsl_mc_io *mc_io,

• 	u32 cmd_flags,
  

• 	u16 token,
  

• 	u64 blob_addr,
  

• 	u16 *error);
  

+/**

• • dpsparser_get_api_version - Retrieve DPSPARSER Major and Minor version

info.

• • @mc_io: Pointer to MC portal's I/O object
• • @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
• • @major_ver: DPSPARSER major version
• • @minor_ver: DPSPARSER minor version
• • Return: '0' on Success; Error code otherwise.
• */

+int dpsparser_get_api_version(struct fsl_mc_io *mc_io,

• 	      u32 cmd_flags,
  

• 	      u16 *major_ver,
  

• 	      u16 *minor_ver);
  

+#endif /* _FSL_DPSPARSER_H */ diff --git a/include/fsl-mc/fsl_mc_private.h b/include/fsl-mc/fsl_mc_private.h index ba0bc37..28b6d45 100644 --- a/include/fsl-mc/fsl_mc_private.h +++ b/include/fsl-mc/fsl_mc_private.h @@ -1,7 +1,7 @@ /* SPDX-License-Identifier: GPL-2.0+ */ /*

• Copyright 2014-2016 Freescale Semiconductor, Inc.

• • Copyright 2017 NXP

• • Copyright 2017-2018 NXP

Same as above

*/

#ifndef _FSL_MC_PRIVATE_H_ @@ -65,7 +65,22 @@ struct fsl_dpni_obj {

extern struct fsl_dpni_obj *dflt_dpni;

+/**

• • struct sp_blob_header - SP Blob header structure
• • @magic: SP Blob magic number
• • @blob_ver: SP Blob version
• • @ip_rev: SP IP revision
• • @length: Length of the SP Blob
• */

+struct sp_blob_header {

• u32 magic;
• u32 blob_ver;
• u32 ip_rev;
• u32 length;

+};

int mc_init(u64 mc_fw_addr, u64 mc_dpc_addr); int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if); int mc_apply_dpl(u64 mc_dpl_addr); +int mc_apply_spb(u64 mc_spb_addr);

#endif /* _FSL_MC_PRIVATE_H_ */

1.9.1

-priyankajain