SPDX: Convert all of our single license tags to Linux Kernel style

[u-boot] / drivers / net / fsl-mc / dprc.c

diff --git a/drivers/net/fsl-mc/dprc.c b/drivers/net/fsl-mc/dprc.c
index d481200243cac2ae02c037b2b8e62a343dfb3b08..38d19a4063e6d6cbdb812e092644aa31cf6b8a9e 100644 (file)
--- a/drivers/net/fsl-mc/dprc.c
+++ b/drivers/net/fsl-mc/dprc.c
@@ -1,24 +1,26 @@
+// SPDX-License-Identifier: GPL-2.0+
 /*
  * Freescale Layerscape MC I/O wrapper
  *
- * Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
- * Author: German Rivera <German.Rivera@freescale.com>
- *
- * SPDX-License-Identifier:    GPL-2.0+
+ * Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
  */
 
 #include <fsl-mc/fsl_mc_sys.h>
 #include <fsl-mc/fsl_mc_cmd.h>
 #include <fsl-mc/fsl_dprc.h>
 
-int dprc_get_container_id(struct fsl_mc_io *mc_io, int *container_id)
+int dprc_get_container_id(struct fsl_mc_io *mc_io,
+                         uint32_t cmd_flags,
+                         int *container_id)
 {
        struct mc_command cmd = { 0 };
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
-                                         MC_CMD_PRI_LOW, 0);
+                                         cmd_flags,
+                                         0);
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -31,13 +33,16 @@ int dprc_get_container_id(struct fsl_mc_io *mc_io, int *container_id)
        return 0;
 }
 
-int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token)
+int dprc_open(struct fsl_mc_io *mc_io,
+             uint32_t cmd_flags,
+             int container_id,
+             uint16_t *token)
 {
        struct mc_command cmd = { 0 };
        int err;
 
        /* prepare command */
-       cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, MC_CMD_PRI_LOW,
+       cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, cmd_flags,
                                          0);
        DPRC_CMD_OPEN(cmd, container_id);
 
@@ -52,19 +57,68 @@ int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token)
        return 0;
 }
 
-int dprc_close(struct fsl_mc_io *mc_io, uint16_t token)
+int dprc_close(struct fsl_mc_io *mc_io,
+              uint32_t cmd_flags,
+              uint16_t token)
 {
        struct mc_command cmd = { 0 };
 
        /* prepare command */
-       cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, MC_CMD_PRI_HIGH,
+       cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags,
                                          token);
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
 }
 
+int dprc_create_container(struct fsl_mc_io *mc_io,
+                         uint32_t cmd_flags,
+                         uint16_t token,
+                         struct dprc_cfg *cfg,
+                         int *child_container_id,
+                         uint64_t *child_portal_paddr)
+{
+       struct mc_command cmd = { 0 };
+       int err;
+
+       /* prepare command */
+       DPRC_CMD_CREATE_CONTAINER(cmd, cfg);
+
+       cmd.header = mc_encode_cmd_header(DPRC_CMDID_CREATE_CONT,
+                                         cmd_flags,
+                                         token);
+
+       /* send command to mc*/
+       err = mc_send_command(mc_io, &cmd);
+       if (err)
+               return err;
+
+       /* retrieve response parameters */
+       DPRC_RSP_CREATE_CONTAINER(cmd, *child_container_id,
+                                 *child_portal_paddr);
+
+       return 0;
+}
+
+int dprc_destroy_container(struct fsl_mc_io *mc_io,
+                          uint32_t cmd_flags,
+                          uint16_t token,
+                          int child_container_id)
+{
+       struct mc_command cmd = { 0 };
+
+       /* prepare command */
+       cmd.header = mc_encode_cmd_header(DPRC_CMDID_DESTROY_CONT,
+                                         cmd_flags,
+                                         token);
+       DPRC_CMD_DESTROY_CONTAINER(cmd, child_container_id);
+
+       /* send command to mc*/
+       return mc_send_command(mc_io, &cmd);
+}
+
 int dprc_reset_container(struct fsl_mc_io *mc_io,
+                        uint32_t cmd_flags,
                         uint16_t token,
                         int child_container_id)
 {
@@ -72,7 +126,8 @@ int dprc_reset_container(struct fsl_mc_io *mc_io,
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_RESET_CONT,
-                                         MC_CMD_PRI_LOW, token);
+                                         cmd_flags,
+                                         token);
        DPRC_CMD_RESET_CONTAINER(cmd, child_container_id);
 
        /* send command to mc*/
@@ -80,6 +135,7 @@ int dprc_reset_container(struct fsl_mc_io *mc_io,
 }
 
 int dprc_get_attributes(struct fsl_mc_io *mc_io,
+                       uint32_t cmd_flags,
                        uint16_t token,
                        struct dprc_attributes *attr)
 {
@@ -88,7 +144,7 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io,
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR,
-                                         MC_CMD_PRI_LOW,
+                                         cmd_flags,
                                          token);
 
        /* send command to mc*/
@@ -102,14 +158,18 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io,
        return 0;
 }
 
-int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count)
+int dprc_get_obj_count(struct fsl_mc_io *mc_io,
+                      uint32_t cmd_flags,
+                      uint16_t token,
+                      int *obj_count)
 {
        struct mc_command cmd = { 0 };
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT,
-                                         MC_CMD_PRI_LOW, token);
+                                         cmd_flags,
+                                         token);
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -123,6 +183,7 @@ int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count)
 }
 
 int dprc_get_obj(struct fsl_mc_io *mc_io,
+                uint32_t cmd_flags,
                 uint16_t token,
                 int obj_index,
                 struct dprc_obj_desc *obj_desc)
@@ -132,7 +193,7 @@ int dprc_get_obj(struct fsl_mc_io *mc_io,
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ,
-                                         MC_CMD_PRI_LOW,
+                                         cmd_flags,
                                          token);
        DPRC_CMD_GET_OBJ(cmd, obj_index);
 
@@ -148,6 +209,7 @@ int dprc_get_obj(struct fsl_mc_io *mc_io,
 }
 
 int dprc_get_res_count(struct fsl_mc_io *mc_io,
+                      uint32_t cmd_flags,
                       uint16_t token,
                       char *type,
                       int *res_count)
@@ -159,7 +221,8 @@ int dprc_get_res_count(struct fsl_mc_io *mc_io,
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_COUNT,
-                                         MC_CMD_PRI_LOW, token);
+                                         cmd_flags,
+                                         token);
        DPRC_CMD_GET_RES_COUNT(cmd, type);
 
        /* send command to mc*/
@@ -174,6 +237,7 @@ int dprc_get_res_count(struct fsl_mc_io *mc_io,
 }
 
 int dprc_get_res_ids(struct fsl_mc_io *mc_io,
+                    uint32_t cmd_flags,
                     uint16_t token,
                     char *type,
                     struct dprc_res_ids_range_desc *range_desc)
@@ -183,7 +247,8 @@ int dprc_get_res_ids(struct fsl_mc_io *mc_io,
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_IDS,
-                                         MC_CMD_PRI_LOW, token);
+                                         cmd_flags,
+                                         token);
        DPRC_CMD_GET_RES_IDS(cmd, range_desc, type);
 
        /* send command to mc*/
@@ -198,6 +263,7 @@ int dprc_get_res_ids(struct fsl_mc_io *mc_io,
 }
 
 int dprc_get_obj_region(struct fsl_mc_io *mc_io,
+                       uint32_t cmd_flags,
                        uint16_t token,
                        char *obj_type,
                        int obj_id,
@@ -209,7 +275,8 @@ int dprc_get_obj_region(struct fsl_mc_io *mc_io,
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
-                                         MC_CMD_PRI_LOW, token);
+                                         cmd_flags,
+                                         token);
        DPRC_CMD_GET_OBJ_REGION(cmd, obj_type, obj_id, region_index);
 
        /* send command to mc*/
@@ -224,23 +291,26 @@ int dprc_get_obj_region(struct fsl_mc_io *mc_io,
 }
 
 int dprc_connect(struct fsl_mc_io *mc_io,
+                uint32_t cmd_flags,
                 uint16_t token,
                 const struct dprc_endpoint *endpoint1,
-                const struct dprc_endpoint *endpoint2)
+                const struct dprc_endpoint *endpoint2,
+                const struct dprc_connection_cfg *cfg)
 {
        struct mc_command cmd = { 0 };
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_CONNECT,
-                                         MC_CMD_PRI_LOW,
+                                         cmd_flags,
                                          token);
-       DPRC_CMD_CONNECT(cmd, endpoint1, endpoint2);
+       DPRC_CMD_CONNECT(cmd, endpoint1, endpoint2, cfg);
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
 }
 
 int dprc_disconnect(struct fsl_mc_io *mc_io,
+                   uint32_t cmd_flags,
                    uint16_t token,
                    const struct dprc_endpoint *endpoint)
 {
@@ -248,7 +318,7 @@ int dprc_disconnect(struct fsl_mc_io *mc_io,
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_DISCONNECT,
-                                         MC_CMD_PRI_LOW,
+                                         cmd_flags,
                                          token);
        DPRC_CMD_DISCONNECT(cmd, endpoint);
 
@@ -257,17 +327,18 @@ int dprc_disconnect(struct fsl_mc_io *mc_io,
 }
 
 int dprc_get_connection(struct fsl_mc_io *mc_io,
+                       uint32_t cmd_flags,
                        uint16_t token,
-                                       const struct dprc_endpoint *endpoint1,
-                                       struct dprc_endpoint *endpoint2,
-                                       int *state)
+                       const struct dprc_endpoint *endpoint1,
+                       struct dprc_endpoint *endpoint2,
+                       int *state)
 {
        struct mc_command cmd = { 0 };
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION,
-                                         MC_CMD_PRI_LOW,
+                                         cmd_flags,
                                          token);
        DPRC_CMD_GET_CONNECTION(cmd, endpoint1);
 
@@ -281,3 +352,26 @@ int dprc_get_connection(struct fsl_mc_io *mc_io,
 
        return 0;
 }
+
+int dprc_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(DPRC_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;
+}