[PATCH] staging: fsl-mc: up-rev version of MC interface code

From: J. German Rivera
Date: Tue Sep 15 2015 - 17:09:38 EST

Next message: Christian Borntraeger: "Re: [4.2] commit d59cfc09c32 (sched, cgroup: replace signal_struct->group_rwsem with a global percpu_rwsem) causes regression for libvirt/kvm"
Previous message: Jens Wiklander: "Re: [PATCH v5 1/5] arm/arm64: add smccc ARCH32"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

The DPAA2 management complex has a versioned binary interface
that has to be kept in sync with the DPAA2 drivers. This patch
uprevs the APIs that build MC commands and parse results.
This uprev is needed to support object interrupts.

MC binary interface changes
-overall version from 6.0 to 8.0
-dprc version from 3.0 to 4.0
-dpbp and dpmcp versions from 2.0 to 2.1
-new dprc commands -- set/get obj irq, set obj label,
get obj descriptor
-removed commands -- get portal paddr
-object regions are reported as region offsets not physical
addresses

build/parse API changes
-flags arg is added to all APIs for future extensibility,
hardcoded priority bit is now a flag
-IRQ-related args are consolidated into an irq_cfg struct

Signed-off-by: J. German Rivera <German.Rivera@xxxxxxxxxxxxx>
---
drivers/staging/fsl-mc/bus/dpbp.c | 141 ++++++---
drivers/staging/fsl-mc/bus/dpmcp-cmd.h | 2 +-
drivers/staging/fsl-mc/bus/dpmcp.c | 123 +++++---
drivers/staging/fsl-mc/bus/dpmcp.h | 123 +++++---
drivers/staging/fsl-mc/bus/dpmng.c | 14 +-
drivers/staging/fsl-mc/bus/dprc-cmd.h | 7 +-
drivers/staging/fsl-mc/bus/dprc-driver.c | 8 +-
drivers/staging/fsl-mc/bus/dprc.c | 464 +++++++++++++++++++++++-----
drivers/staging/fsl-mc/bus/mc-allocator.c | 6 +-
drivers/staging/fsl-mc/bus/mc-bus.c | 54 +++-
drivers/staging/fsl-mc/include/dpbp-cmd.h | 2 +-
drivers/staging/fsl-mc/include/dpbp.h | 91 ++++--
drivers/staging/fsl-mc/include/dpcon-cmd.h | 2 +-
drivers/staging/fsl-mc/include/dpmng.h | 14 +-
drivers/staging/fsl-mc/include/dprc.h | 313 +++++++++++++++----
drivers/staging/fsl-mc/include/mc-cmd.h | 28 +-
drivers/staging/fsl-mc/include/mc-private.h | 15 +-
17 files changed, 1052 insertions(+), 355 deletions(-)

diff --git a/drivers/staging/fsl-mc/bus/dpbp.c b/drivers/staging/fsl-mc/bus/dpbp.c
index d99ab6d..04775db8 100644
--- a/drivers/staging/fsl-mc/bus/dpbp.c
+++ b/drivers/staging/fsl-mc/bus/dpbp.c
@@ -34,14 +34,19 @@
#include "../include/dpbp.h"
#include "../include/dpbp-cmd.h"

-int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token)
+int dpbp_open(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ int dpbp_id,
+ uint16_t *token)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_OPEN,
- MC_CMD_PRI_LOW, 0);
+ cmd_flags,
+ 0);
+
cmd.params[0] |= mc_enc(0, 32, dpbp_id);

/* send command to mc*/
@@ -54,22 +59,23 @@ int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token)

return err;
}
-EXPORT_SYMBOL(dpbp_open);

-int dpbp_close(struct fsl_mc_io *mc_io, uint16_t token)
+int dpbp_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(DPBP_CMDID_CLOSE, MC_CMD_PRI_HIGH,
+ cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLOSE, cmd_flags,
token);

/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
-EXPORT_SYMBOL(dpbp_close);

int dpbp_create(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
const struct dpbp_cfg *cfg,
uint16_t *token)
{
@@ -80,7 +86,8 @@ int dpbp_create(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_CREATE,
- MC_CMD_PRI_LOW, 0);
+ cmd_flags,
+ 0);

/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
@@ -93,50 +100,59 @@ int dpbp_create(struct fsl_mc_io *mc_io,
return 0;
}

-int dpbp_destroy(struct fsl_mc_io *mc_io, uint16_t token)
+int dpbp_destroy(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(DPBP_CMDID_DESTROY,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);

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

-int dpbp_enable(struct fsl_mc_io *mc_io, uint16_t token)
+int dpbp_enable(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(DPBP_CMDID_ENABLE, MC_CMD_PRI_LOW,
+ cmd.header = mc_encode_cmd_header(DPBP_CMDID_ENABLE, cmd_flags,
token);

/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
-EXPORT_SYMBOL(dpbp_enable);

-int dpbp_disable(struct fsl_mc_io *mc_io, uint16_t token)
+int dpbp_disable(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(DPBP_CMDID_DISABLE,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);

/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
-EXPORT_SYMBOL(dpbp_disable);

-int dpbp_is_enabled(struct fsl_mc_io *mc_io, uint16_t token, int *en)
+int dpbp_is_enabled(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ int *en)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
- cmd.header = mc_encode_cmd_header(DPBP_CMDID_IS_ENABLED, MC_CMD_PRI_LOW,
+ cmd.header = mc_encode_cmd_header(DPBP_CMDID_IS_ENABLED, cmd_flags,
token);

/* send command to mc*/
@@ -150,53 +166,58 @@ int dpbp_is_enabled(struct fsl_mc_io *mc_io, uint16_t token, int *en)
return 0;
}

-int dpbp_reset(struct fsl_mc_io *mc_io, uint16_t token)
+int dpbp_reset(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(DPBP_CMDID_RESET,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);

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

-int dpbp_set_irq(struct fsl_mc_io *mc_io,
- uint16_t token,
- uint8_t irq_index,
- uint64_t irq_paddr,
- uint32_t irq_val,
- int user_irq_id)
+int dpbp_set_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ uint8_t irq_index,
+ struct dpbp_irq_cfg *irq_cfg)
{
struct mc_command cmd = { 0 };

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_IRQ,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
+
cmd.params[0] |= mc_enc(0, 8, irq_index);
- cmd.params[0] |= mc_enc(32, 32, irq_val);
- cmd.params[1] |= mc_enc(0, 64, irq_paddr);
- cmd.params[2] |= mc_enc(0, 32, user_irq_id);
+ cmd.params[0] |= mc_enc(32, 32, irq_cfg->val);
+ cmd.params[1] |= mc_enc(0, 64, irq_cfg->addr);
+ cmd.params[2] |= mc_enc(0, 32, irq_cfg->user_irq_id);

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

-int dpbp_get_irq(struct fsl_mc_io *mc_io,
- uint16_t token,
- uint8_t irq_index,
- int *type,
- uint64_t *irq_paddr,
- uint32_t *irq_val,
- int *user_irq_id)
+int dpbp_get_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ uint8_t irq_index,
+ int *type,
+ struct dpbp_irq_cfg *irq_cfg)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
+
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -205,14 +226,16 @@ int dpbp_get_irq(struct fsl_mc_io *mc_io,
return err;

/* retrieve response parameters */
- *irq_val = (uint32_t)mc_dec(cmd.params[0], 0, 32);
- *irq_paddr = (uint64_t)mc_dec(cmd.params[1], 0, 64);
- *user_irq_id = (int)mc_dec(cmd.params[2], 0, 32);
+ irq_cfg->val = (uint32_t)mc_dec(cmd.params[0], 0, 32);
+ irq_cfg->addr = (uint64_t)mc_dec(cmd.params[1], 0, 64);
+ irq_cfg->user_irq_id = (int)mc_dec(cmd.params[2], 0, 32);
*type = (int)mc_dec(cmd.params[2], 32, 32);
+
return 0;
}

int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint8_t en)
@@ -221,7 +244,9 @@ int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_IRQ_ENABLE,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
+
cmd.params[0] |= mc_enc(0, 8, en);
cmd.params[0] |= mc_enc(32, 8, irq_index);

@@ -230,6 +255,7 @@ int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
}

int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint8_t *en)
@@ -239,7 +265,9 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ_ENABLE,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
+
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -249,10 +277,12 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,

/* retrieve response parameters */
*en = (uint8_t)mc_dec(cmd.params[0], 0, 8);
+
return 0;
}

int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t mask)
@@ -261,7 +291,9 @@ int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_IRQ_MASK,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
+
cmd.params[0] |= mc_enc(0, 32, mask);
cmd.params[0] |= mc_enc(32, 8, irq_index);

@@ -270,6 +302,7 @@ int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
}

int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t *mask)
@@ -279,7 +312,9 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ_MASK,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
+
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -289,10 +324,12 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,

/* retrieve response parameters */
*mask = (uint32_t)mc_dec(cmd.params[0], 0, 32);
+
return 0;
}

int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t *status)
@@ -302,7 +339,9 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ_STATUS,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
+
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -312,10 +351,12 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io,

/* retrieve response parameters */
*status = (uint32_t)mc_dec(cmd.params[0], 0, 32);
+
return 0;
}

int dpbp_clear_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t status)
@@ -324,7 +365,9 @@ int dpbp_clear_irq_status(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLEAR_IRQ_STATUS,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
+
cmd.params[0] |= mc_enc(0, 32, status);
cmd.params[0] |= mc_enc(32, 8, irq_index);

@@ -333,6 +376,7 @@ int dpbp_clear_irq_status(struct fsl_mc_io *mc_io,
}

int dpbp_get_attributes(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
struct dpbp_attr *attr)
{
@@ -341,7 +385,8 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_ATTR,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);

/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
@@ -353,6 +398,6 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io,
attr->id = (int)mc_dec(cmd.params[0], 32, 32);
attr->version.major = (uint16_t)mc_dec(cmd.params[1], 0, 16);
attr->version.minor = (uint16_t)mc_dec(cmd.params[1], 16, 16);
+
return 0;
}
-EXPORT_SYMBOL(dpbp_get_attributes);
diff --git a/drivers/staging/fsl-mc/bus/dpmcp-cmd.h b/drivers/staging/fsl-mc/bus/dpmcp-cmd.h
index 57f326b..6cc0fed 100644
--- a/drivers/staging/fsl-mc/bus/dpmcp-cmd.h
+++ b/drivers/staging/fsl-mc/bus/dpmcp-cmd.h
@@ -34,7 +34,7 @@

/* DPMCP Version */
#define DPMCP_VER_MAJOR 2
-#define DPMCP_VER_MINOR 0
+#define DPMCP_VER_MINOR 1

/* Command IDs */
#define DPMCP_CMDID_CLOSE 0x800
diff --git a/drivers/staging/fsl-mc/bus/dpmcp.c b/drivers/staging/fsl-mc/bus/dpmcp.c
index 6b9da5b..ee63380 100644
--- a/drivers/staging/fsl-mc/bus/dpmcp.c
+++ b/drivers/staging/fsl-mc/bus/dpmcp.c
@@ -34,14 +34,18 @@
#include "dpmcp.h"
#include "dpmcp-cmd.h"

-int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token)
+int dpmcp_open(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ int dpmcp_id,
+ uint16_t *token)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_OPEN,
- MC_CMD_PRI_LOW, 0);
+ cmd_flags,
+ 0);
cmd.params[0] |= mc_enc(0, 32, dpmcp_id);

/* send command to mc*/
@@ -55,12 +59,15 @@ int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token)
return err;
}

-int dpmcp_close(struct fsl_mc_io *mc_io, uint16_t token)
+int dpmcp_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(DPMCP_CMDID_CLOSE, MC_CMD_PRI_HIGH,
+ cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CLOSE,
+ cmd_flags,
token);

/* send command to mc*/
@@ -68,15 +75,17 @@ int dpmcp_close(struct fsl_mc_io *mc_io, uint16_t token)
}

int dpmcp_create(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
const struct dpmcp_cfg *cfg,
- uint16_t *token)
+ uint16_t *token)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CREATE,
- MC_CMD_PRI_LOW, 0);
+ cmd_flags,
+ 0);
cmd.params[0] |= mc_enc(0, 32, cfg->portal_id);

/* send command to mc*/
@@ -90,65 +99,71 @@ int dpmcp_create(struct fsl_mc_io *mc_io,
return 0;
}

-int dpmcp_destroy(struct fsl_mc_io *mc_io, uint16_t token)
+int dpmcp_destroy(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(DPMCP_CMDID_DESTROY,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);

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

-int dpmcp_reset(struct fsl_mc_io *mc_io, uint16_t token)
+int dpmcp_reset(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(DPMCP_CMDID_RESET,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);

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

int dpmcp_set_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint64_t irq_addr,
- uint32_t irq_val,
- int user_irq_id)
+ uint8_t irq_index,
+ struct dpmcp_irq_cfg *irq_cfg)
{
struct mc_command cmd = { 0 };

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 8, irq_index);
- cmd.params[0] |= mc_enc(32, 32, irq_val);
- cmd.params[1] |= mc_enc(0, 64, irq_addr);
- cmd.params[2] |= mc_enc(0, 32, user_irq_id);
+ cmd.params[0] |= mc_enc(32, 32, irq_cfg->val);
+ cmd.params[1] |= mc_enc(0, 64, irq_cfg->paddr);
+ cmd.params[2] |= mc_enc(0, 32, irq_cfg->user_irq_id);

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

int dpmcp_get_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- int *type,
- uint64_t *irq_addr,
- uint32_t *irq_val,
- int *user_irq_id)
+ uint8_t irq_index,
+ int *type,
+ struct dpmcp_irq_cfg *irq_cfg)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -157,23 +172,25 @@ int dpmcp_get_irq(struct fsl_mc_io *mc_io,
return err;

/* retrieve response parameters */
- *irq_val = (uint32_t)mc_dec(cmd.params[0], 0, 32);
- *irq_addr = (uint64_t)mc_dec(cmd.params[1], 0, 64);
- *user_irq_id = (int)mc_dec(cmd.params[2], 0, 32);
+ irq_cfg->val = (uint32_t)mc_dec(cmd.params[0], 0, 32);
+ irq_cfg->paddr = (uint64_t)mc_dec(cmd.params[1], 0, 64);
+ irq_cfg->user_irq_id = (int)mc_dec(cmd.params[2], 0, 32);
*type = (int)mc_dec(cmd.params[2], 32, 32);
return 0;
}

int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint8_t en)
+ uint8_t irq_index,
+ uint8_t en)
{
struct mc_command cmd = { 0 };

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ_ENABLE,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 8, en);
cmd.params[0] |= mc_enc(32, 8, irq_index);

@@ -182,16 +199,18 @@ int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io,
}

int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint8_t *en)
+ uint8_t irq_index,
+ uint8_t *en)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_ENABLE,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -205,15 +224,17 @@ int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io,
}

int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint32_t mask)
+ uint8_t irq_index,
+ uint32_t mask)
{
struct mc_command cmd = { 0 };

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ_MASK,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 32, mask);
cmd.params[0] |= mc_enc(32, 8, irq_index);

@@ -222,16 +243,18 @@ int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io,
}

int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint32_t *mask)
+ uint8_t irq_index,
+ uint32_t *mask)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_MASK,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -245,16 +268,18 @@ int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
}

int dpmcp_get_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint32_t *status)
+ uint8_t irq_index,
+ uint32_t *status)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_STATUS,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -268,15 +293,17 @@ int dpmcp_get_irq_status(struct fsl_mc_io *mc_io,
}

int dpmcp_clear_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint32_t status)
+ uint8_t irq_index,
+ uint32_t status)
{
struct mc_command cmd = { 0 };

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CLEAR_IRQ_STATUS,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 32, status);
cmd.params[0] |= mc_enc(32, 8, irq_index);

@@ -285,15 +312,17 @@ int dpmcp_clear_irq_status(struct fsl_mc_io *mc_io,
}

int dpmcp_get_attributes(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- struct dpmcp_attr *attr)
+ struct dpmcp_attr *attr)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_ATTR,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);

/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
diff --git a/drivers/staging/fsl-mc/bus/dpmcp.h b/drivers/staging/fsl-mc/bus/dpmcp.h
index 5e7c219..164684f 100644
--- a/drivers/staging/fsl-mc/bus/dpmcp.h
+++ b/drivers/staging/fsl-mc/bus/dpmcp.h
@@ -41,6 +41,7 @@ struct fsl_mc_io;
/**
* dpmcp_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_'
* @dpmcp_id: DPMCP unique ID
* @token: Returned token; use in subsequent API calls
*
@@ -54,7 +55,10 @@ struct fsl_mc_io;
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token);
+int dpmcp_open(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ int dpmcp_id,
+ uint16_t *token);

/* Get portal ID from pool */
#define DPMCP_GET_PORTAL_ID_FROM_POOL (-1)
@@ -62,6 +66,7 @@ int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token);
/**
* dpmcp_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 DPMCP object
*
* After this function is called, no further operations are
@@ -69,12 +74,14 @@ int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token);
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpmcp_close(struct fsl_mc_io *mc_io, uint16_t token);
+int dpmcp_close(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token);

/**
- * struct dpmcp_cfg() - Structure representing DPMCP configuration
+ * struct dpmcp_cfg - Structure representing DPMCP configuration
* @portal_id: Portal ID; 'DPMCP_GET_PORTAL_ID_FROM_POOL' to get the portal ID
- * from pool
+ * from pool
*/
struct dpmcp_cfg {
int portal_id;
@@ -83,6 +90,7 @@ struct dpmcp_cfg {
/**
* dpmcp_create() - Create the DPMCP object.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @cfg: Configuration structure
* @token: Returned token; use in subsequent API calls
*
@@ -101,81 +109,91 @@ struct dpmcp_cfg {
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_create(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
const struct dpmcp_cfg *cfg,
- uint16_t *token);
+ uint16_t *token);

/**
* dpmcp_destroy() - Destroy the DPMCP 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 DPMCP object
*
* Return: '0' on Success; error code otherwise.
*/
-int dpmcp_destroy(struct fsl_mc_io *mc_io, uint16_t token);
+int dpmcp_destroy(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token);

/**
* dpmcp_reset() - Reset the DPMCP, returns the object to initial state.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpmcp_reset(struct fsl_mc_io *mc_io, uint16_t token);
+int dpmcp_reset(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token);

/* IRQ */
-/*!
- * @name dpmcp IRQ Index and Events
- */
+/* IRQ Index */
#define DPMCP_IRQ_INDEX 0
-/*!< Irq index */
+/* irq event - Indicates that the link state changed */
#define DPMCP_IRQ_EVENT_CMD_DONE 0x00000001
-/*!< irq event - Indicates that the link state changed */
-/* @} */
+
+/**
+ * struct dpmcp_irq_cfg - IRQ configuration
+ * @paddr: Address that must be written to signal a message-based interrupt
+ * @val: Value to write into irq_addr address
+ * @user_irq_id: A user defined number associated with this IRQ
+ */
+struct dpmcp_irq_cfg {
+ uint64_t paddr;
+ uint32_t val;
+ int user_irq_id;
+};

/**
* dpmcp_set_irq() - Set IRQ information for the DPMCP to trigger an interrupt.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
* @irq_index: Identifies the interrupt index to configure
- * @irq_addr: Address that must be written to
- * signal a message-based interrupt
- * @irq_val: Value to write into irq_addr address
- * @user_irq_id: A user defined number associated with this IRQ
+ * @irq_cfg: IRQ configuration
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_set_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint64_t irq_addr,
- uint32_t irq_val,
- int user_irq_id);
+ uint8_t irq_index,
+ struct dpmcp_irq_cfg *irq_cfg);

/**
* dpmcp_get_irq() - Get IRQ information from the DPMCP.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @type: Interrupt type: 0 represents message interrupt
- * type (both irq_addr and irq_val are valid)
- * @irq_addr: Returned address that must be written to
- * signal the message-based interrupt
- * @irq_val: Value to write into irq_addr address
- * @user_irq_id: A user defined number associated with this IRQ
+ * type (both irq_addr and irq_val are valid)
+ * @irq_cfg: IRQ attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_get_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- int *type,
- uint64_t *irq_addr,
- uint32_t *irq_val,
- int *user_irq_id);
+ uint8_t irq_index,
+ int *type,
+ struct dpmcp_irq_cfg *irq_cfg);

/**
* dpmcp_set_irq_enable() - Set overall interrupt state.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @en: Interrupt state - enable = 1, disable = 0
@@ -188,13 +206,15 @@ int dpmcp_get_irq(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint8_t en);
+ uint8_t irq_index,
+ uint8_t en);

/**
* dpmcp_get_irq_enable() - Get overall interrupt state
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @en: Returned interrupt state - enable = 1, disable = 0
@@ -202,13 +222,15 @@ int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint8_t *en);
+ uint8_t irq_index,
+ uint8_t *en);

/**
* dpmcp_set_irq_mask() - Set interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @mask: Event mask to trigger interrupt;
@@ -221,14 +243,16 @@ int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io,
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io,
+int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint32_t mask);
+ uint8_t irq_index,
+ uint32_t mask);

/**
* dpmcp_get_irq_mask() - Get interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @mask: Returned event mask to trigger interrupt
@@ -238,15 +262,17 @@ int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io,
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
+int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint32_t *mask);
+ uint8_t irq_index,
+ uint32_t *mask);

/**
* dpmcp_get_irq_status() - Get the current status of any pending interrupts.
*
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @status: Returned interrupts status - one bit per cause:
@@ -256,14 +282,16 @@ int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_get_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint32_t *status);
+ uint8_t irq_index,
+ uint32_t *status);

/**
* dpmcp_clear_irq_status() - Clear a pending interrupt's status
*
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @status: Bits to clear (W1C) - one bit per cause:
@@ -273,9 +301,10 @@ int dpmcp_get_irq_status(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_clear_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- uint8_t irq_index,
- uint32_t status);
+ uint8_t irq_index,
+ uint32_t status);

/**
* struct dpmcp_attr - Structure representing DPMCP attributes
@@ -299,13 +328,15 @@ struct dpmcp_attr {
* dpmcp_get_attributes - Retrieve DPMCP attributes.
*
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMCP object
* @attr: Returned object's attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_get_attributes(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
- struct dpmcp_attr *attr);
+ struct dpmcp_attr *attr);

#endif /* __FSL_DPMCP_H */
diff --git a/drivers/staging/fsl-mc/bus/dpmng.c b/drivers/staging/fsl-mc/bus/dpmng.c
index 58328e8..1aeca05 100644
--- a/drivers/staging/fsl-mc/bus/dpmng.c
+++ b/drivers/staging/fsl-mc/bus/dpmng.c
@@ -34,14 +34,17 @@
#include "../include/dpmng.h"
#include "dpmng-cmd.h"

-int mc_get_version(struct fsl_mc_io *mc_io, struct mc_version *mc_ver_info)
+int mc_get_version(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ struct mc_version *mc_ver_info)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPMNG_CMDID_GET_VERSION,
- MC_CMD_PRI_LOW, 0);
+ cmd_flags,
+ 0);

/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
@@ -56,14 +59,17 @@ int mc_get_version(struct fsl_mc_io *mc_io, struct mc_version *mc_ver_info)
return 0;
}

-int dpmng_get_container_id(struct fsl_mc_io *mc_io, int *container_id)
+int dpmng_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(DPMNG_CMDID_GET_CONT_ID,
- MC_CMD_PRI_LOW, 0);
+ cmd_flags,
+ 0);

/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
diff --git a/drivers/staging/fsl-mc/bus/dprc-cmd.h b/drivers/staging/fsl-mc/bus/dprc-cmd.h
index 0920248..6552c20 100644
--- a/drivers/staging/fsl-mc/bus/dprc-cmd.h
+++ b/drivers/staging/fsl-mc/bus/dprc-cmd.h
@@ -41,7 +41,7 @@
#define _FSL_DPRC_CMD_H

/* DPRC Version */
-#define DPRC_VER_MAJOR 3
+#define DPRC_VER_MAJOR 4
#define DPRC_VER_MINOR 0

/* Command IDs */
@@ -72,12 +72,15 @@
#define DPRC_CMDID_GET_RES_COUNT 0x15B
#define DPRC_CMDID_GET_RES_IDS 0x15C
#define DPRC_CMDID_GET_OBJ_REG 0x15E
+#define DPRC_CMDID_SET_OBJ_IRQ 0x15F
+#define DPRC_CMDID_GET_OBJ_IRQ 0x160
+#define DPRC_CMDID_SET_OBJ_LABEL 0x161
+#define DPRC_CMDID_GET_OBJ_DESC 0x162

#define DPRC_CMDID_CONNECT 0x167
#define DPRC_CMDID_DISCONNECT 0x168
#define DPRC_CMDID_GET_POOL 0x169
#define DPRC_CMDID_GET_POOL_COUNT 0x16A
-#define DPRC_CMDID_GET_PORTAL_PADDR 0x16B

#define DPRC_CMDID_GET_CONNECTION 0x16C

diff --git a/drivers/staging/fsl-mc/bus/dprc-driver.c b/drivers/staging/fsl-mc/bus/dprc-driver.c
index 35c06cf..7faf23b4 100644
--- a/drivers/staging/fsl-mc/bus/dprc-driver.c
+++ b/drivers/staging/fsl-mc/bus/dprc-driver.c
@@ -262,6 +262,7 @@ int dprc_scan_objects(struct fsl_mc_device *mc_bus_dev)
struct dprc_obj_desc *child_obj_desc_array = NULL;

error = dprc_get_obj_count(mc_bus_dev->mc_io,
+ 0,
mc_bus_dev->mc_handle,
&num_child_objects);
if (error < 0) {
@@ -289,6 +290,7 @@ int dprc_scan_objects(struct fsl_mc_device *mc_bus_dev)
&child_obj_desc_array[i];

error = dprc_get_obj(mc_bus_dev->mc_io,
+ 0,
mc_bus_dev->mc_handle,
i, obj_desc);
if (error < 0) {
@@ -399,7 +401,7 @@ static int dprc_probe(struct fsl_mc_device *mc_dev)
return error;
}

- error = dprc_open(mc_dev->mc_io, mc_dev->obj_desc.id,
+ error = dprc_open(mc_dev->mc_io, 0, mc_dev->obj_desc.id,
&mc_dev->mc_handle);
if (error < 0) {
dev_err(&mc_dev->dev, "dprc_open() failed: %d\n", error);
@@ -419,7 +421,7 @@ static int dprc_probe(struct fsl_mc_device *mc_dev)
return 0;

error_cleanup_open:
- (void)dprc_close(mc_dev->mc_io, mc_dev->mc_handle);
+ (void)dprc_close(mc_dev->mc_io, 0, mc_dev->mc_handle);

error_cleanup_mc_io:
fsl_destroy_mc_io(mc_dev->mc_io);
@@ -447,7 +449,7 @@ static int dprc_remove(struct fsl_mc_device *mc_dev)

device_for_each_child(&mc_dev->dev, NULL, __fsl_mc_device_remove);
dprc_cleanup_all_resource_pools(mc_dev);
- error = dprc_close(mc_dev->mc_io, mc_dev->mc_handle);
+ error = dprc_close(mc_dev->mc_io, 0, mc_dev->mc_handle);
if (error < 0)
dev_err(&mc_dev->dev, "dprc_close() failed: %d\n", error);

diff --git a/drivers/staging/fsl-mc/bus/dprc.c b/drivers/staging/fsl-mc/bus/dprc.c
index 19b26e6..a1cdafd 100644
--- a/drivers/staging/fsl-mc/bus/dprc.c
+++ b/drivers/staging/fsl-mc/bus/dprc.c
@@ -34,13 +34,16 @@
#include "../include/dprc.h"
#include "dprc-cmd.h"

-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);
cmd.params[0] |= mc_enc(0, 32, container_id);

@@ -56,12 +59,14 @@ int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token)
}
EXPORT_SYMBOL(dprc_open);

-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*/
@@ -70,10 +75,11 @@ int dprc_close(struct fsl_mc_io *mc_io, uint16_t token)
EXPORT_SYMBOL(dprc_close);

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)
+ uint64_t *child_portal_offset)
{
struct mc_command cmd = { 0 };
int err;
@@ -82,9 +88,26 @@ int dprc_create_container(struct fsl_mc_io *mc_io,
cmd.params[0] |= mc_enc(32, 16, cfg->icid);
cmd.params[0] |= mc_enc(0, 32, cfg->options);
cmd.params[1] |= mc_enc(32, 32, cfg->portal_id);
+ cmd.params[2] |= mc_enc(0, 8, cfg->label[0]);
+ cmd.params[2] |= mc_enc(8, 8, cfg->label[1]);
+ cmd.params[2] |= mc_enc(16, 8, cfg->label[2]);
+ cmd.params[2] |= mc_enc(24, 8, cfg->label[3]);
+ cmd.params[2] |= mc_enc(32, 8, cfg->label[4]);
+ cmd.params[2] |= mc_enc(40, 8, cfg->label[5]);
+ cmd.params[2] |= mc_enc(48, 8, cfg->label[6]);
+ cmd.params[2] |= mc_enc(56, 8, cfg->label[7]);
+ cmd.params[3] |= mc_enc(0, 8, cfg->label[8]);
+ cmd.params[3] |= mc_enc(8, 8, cfg->label[9]);
+ cmd.params[3] |= mc_enc(16, 8, cfg->label[10]);
+ cmd.params[3] |= mc_enc(24, 8, cfg->label[11]);
+ cmd.params[3] |= mc_enc(32, 8, cfg->label[12]);
+ cmd.params[3] |= mc_enc(40, 8, cfg->label[13]);
+ cmd.params[3] |= mc_enc(48, 8, cfg->label[14]);
+ cmd.params[3] |= mc_enc(56, 8, cfg->label[15]);

cmd.header = mc_encode_cmd_header(DPRC_CMDID_CREATE_CONT,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);

/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
@@ -93,12 +116,14 @@ int dprc_create_container(struct fsl_mc_io *mc_io,

/* retrieve response parameters */
*child_container_id = mc_dec(cmd.params[1], 0, 32);
- *child_portal_paddr = mc_dec(cmd.params[2], 0, 64);
+ *child_portal_offset = mc_dec(cmd.params[2], 0, 64);

return 0;
}
+EXPORT_SYMBOL(dprc_create_container);

int dprc_destroy_container(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int child_container_id)
{
@@ -106,14 +131,17 @@ int dprc_destroy_container(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_DESTROY_CONT,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 32, child_container_id);

/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_destroy_container);

int dprc_reset_container(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int child_container_id)
{
@@ -121,27 +149,28 @@ 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);
cmd.params[0] |= mc_enc(0, 32, child_container_id);

/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_reset_container);

int dprc_get_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
int *type,
- uint64_t *irq_paddr,
- uint32_t *irq_val,
- int *user_irq_id)
+ struct dprc_irq_cfg *irq_cfg)
{
struct mc_command cmd = { 0 };
int err;

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ,
- MC_CMD_PRI_LOW,
+ cmd_flags,
token);
cmd.params[0] |= mc_enc(32, 8, irq_index);

@@ -151,37 +180,39 @@ int dprc_get_irq(struct fsl_mc_io *mc_io,
return err;

/* retrieve response parameters */
- *irq_val = mc_dec(cmd.params[0], 0, 32);
- *irq_paddr = mc_dec(cmd.params[1], 0, 64);
- *user_irq_id = mc_dec(cmd.params[2], 0, 32);
+ irq_cfg->val = mc_dec(cmd.params[0], 0, 32);
+ irq_cfg->paddr = mc_dec(cmd.params[1], 0, 64);
+ irq_cfg->user_irq_id = mc_dec(cmd.params[2], 0, 32);
*type = mc_dec(cmd.params[2], 32, 32);

return 0;
}
+EXPORT_SYMBOL(dprc_get_irq);

int dprc_set_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
- uint64_t irq_paddr,
- uint32_t irq_val,
- int user_irq_id)
+ struct dprc_irq_cfg *irq_cfg)
{
struct mc_command cmd = { 0 };

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ,
- MC_CMD_PRI_LOW,
+ cmd_flags,
token);
cmd.params[0] |= mc_enc(32, 8, irq_index);
- cmd.params[0] |= mc_enc(0, 32, irq_val);
- cmd.params[1] |= mc_enc(0, 64, irq_paddr);
- cmd.params[2] |= mc_enc(0, 32, user_irq_id);
+ cmd.params[0] |= mc_enc(0, 32, irq_cfg->val);
+ cmd.params[1] |= mc_enc(0, 64, irq_cfg->paddr);
+ cmd.params[2] |= mc_enc(0, 32, irq_cfg->user_irq_id);

/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_set_irq);

int dprc_get_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint8_t *en)
@@ -191,7 +222,8 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_ENABLE,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -204,8 +236,10 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io,

return 0;
}
+EXPORT_SYMBOL(dprc_get_irq_enable);

int dprc_set_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint8_t en)
@@ -214,15 +248,18 @@ int dprc_set_irq_enable(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_ENABLE,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 8, en);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_set_irq_enable);

int dprc_get_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t *mask)
@@ -232,7 +269,8 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_MASK,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -245,8 +283,10 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io,

return 0;
}
+EXPORT_SYMBOL(dprc_get_irq_mask);

int dprc_set_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t mask)
@@ -255,15 +295,18 @@ int dprc_set_irq_mask(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_MASK,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 32, mask);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_set_irq_mask);

int dprc_get_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t *status)
@@ -273,7 +316,8 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_STATUS,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
@@ -286,8 +330,10 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io,

return 0;
}
+EXPORT_SYMBOL(dprc_get_irq_status);

int dprc_clear_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t status)
@@ -296,15 +342,18 @@ int dprc_clear_irq_status(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLEAR_IRQ_STATUS,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 32, status);
cmd.params[0] |= mc_enc(32, 8, irq_index);

/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_clear_irq_status);

int dprc_get_attributes(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
struct dprc_attributes *attr)
{
@@ -313,7 +362,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*/
@@ -331,8 +380,10 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io,

return 0;
}
+EXPORT_SYMBOL(dprc_get_attributes);

int dprc_set_res_quota(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int child_container_id,
char *type,
@@ -342,7 +393,8 @@ int dprc_set_res_quota(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_RES_QUOTA,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 32, child_container_id);
cmd.params[0] |= mc_enc(32, 16, quota);
cmd.params[1] |= mc_enc(0, 8, type[0]);
@@ -365,8 +417,10 @@ int dprc_set_res_quota(struct fsl_mc_io *mc_io,
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_set_res_quota);

int dprc_get_res_quota(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int child_container_id,
char *type,
@@ -377,7 +431,8 @@ int dprc_get_res_quota(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_QUOTA,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 32, child_container_id);
cmd.params[1] |= mc_enc(0, 8, type[0]);
cmd.params[1] |= mc_enc(8, 8, type[1]);
@@ -406,8 +461,10 @@ int dprc_get_res_quota(struct fsl_mc_io *mc_io,

return 0;
}
+EXPORT_SYMBOL(dprc_get_res_quota);

int dprc_assign(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int container_id,
struct dprc_res_req *res_req)
@@ -416,7 +473,8 @@ int dprc_assign(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_ASSIGN,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);
cmd.params[0] |= mc_enc(0, 32, container_id);
cmd.params[0] |= mc_enc(32, 32, res_req->options);
cmd.params[1] |= mc_enc(0, 32, res_req->num);
@@ -441,8 +499,10 @@ int dprc_assign(struct fsl_mc_io *mc_io,
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_assign);

int dprc_unassign(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int child_container_id,
struct dprc_res_req *res_req)
@@ -451,7 +511,7 @@ int dprc_unassign(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_UNASSIGN,
- MC_CMD_PRI_LOW,
+ cmd_flags,
token);
cmd.params[0] |= mc_enc(0, 32, child_container_id);
cmd.params[0] |= mc_enc(32, 32, res_req->options);
@@ -477,8 +537,10 @@ int dprc_unassign(struct fsl_mc_io *mc_io,
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_unassign);

int dprc_get_pool_count(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int *pool_count)
{
@@ -487,7 +549,8 @@ int dprc_get_pool_count(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_POOL_COUNT,
- MC_CMD_PRI_LOW, token);
+ cmd_flags,
+ token);

/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
@@ -499,8 +562,10 @@ int dprc_get_pool_count(struct fsl_mc_io *mc_io,

return 0;
}
+EXPORT_SYMBOL(dprc_get_pool_count);

int dprc_get_pool(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int pool_index,
char *type)
@@ -510,7 +575,7 @@ int dprc_get_pool(struct fsl_mc_io *mc_io,

/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_POOL,
- MC_CMD_PRI_LOW,
+ cmd_flags,
token);
cmd.params[0] |= mc_enc(0, 32, pool_index);

@@ -539,15 +604,20 @@ int dprc_get_pool(struct fsl_mc_io *mc_io,

return 0;
}
+EXPORT_SYMBOL(dprc_get_pool);

-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);
@@ -562,6 +632,7 @@ int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count)
EXPORT_SYMBOL(dprc_get_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)
@@ -571,7 +642,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);
cmd.params[0] |= mc_enc(0, 32, obj_index);

@@ -604,12 +675,201 @@ int dprc_get_obj(struct fsl_mc_io *mc_io,
obj_desc->type[13] = mc_dec(cmd.params[4], 40, 8);
obj_desc->type[14] = mc_dec(cmd.params[4], 48, 8);
obj_desc->type[15] = '\0';
-
+ obj_desc->label[0] = mc_dec(cmd.params[5], 0, 8);
+ obj_desc->label[1] = mc_dec(cmd.params[5], 8, 8);
+ obj_desc->label[2] = mc_dec(cmd.params[5], 16, 8);
+ obj_desc->label[3] = mc_dec(cmd.params[5], 24, 8);
+ obj_desc->label[4] = mc_dec(cmd.params[5], 32, 8);
+ obj_desc->label[5] = mc_dec(cmd.params[5], 40, 8);
+ obj_desc->label[6] = mc_dec(cmd.params[5], 48, 8);
+ obj_desc->label[7] = mc_dec(cmd.params[5], 56, 8);
+ obj_desc->label[8] = mc_dec(cmd.params[6], 0, 8);
+ obj_desc->label[9] = mc_dec(cmd.params[6], 8, 8);
+ obj_desc->label[10] = mc_dec(cmd.params[6], 16, 8);
+ obj_desc->label[11] = mc_dec(cmd.params[6], 24, 8);
+ obj_desc->label[12] = mc_dec(cmd.params[6], 32, 8);
+ obj_desc->label[13] = mc_dec(cmd.params[6], 40, 8);
+ obj_desc->label[14] = mc_dec(cmd.params[6], 48, 8);
+ obj_desc->label[15] = '\0';
return 0;
}
EXPORT_SYMBOL(dprc_get_obj);

+int dprc_get_obj_desc(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ char *obj_type,
+ int obj_id,
+ struct dprc_obj_desc *obj_desc)
+{
+ struct mc_command cmd = { 0 };
+ int err;
+
+ /* prepare command */
+ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_DESC,
+ cmd_flags,
+ token);
+ cmd.params[0] |= mc_enc(0, 32, obj_id);
+ cmd.params[1] |= mc_enc(0, 8, obj_type[0]);
+ cmd.params[1] |= mc_enc(8, 8, obj_type[1]);
+ cmd.params[1] |= mc_enc(16, 8, obj_type[2]);
+ cmd.params[1] |= mc_enc(24, 8, obj_type[3]);
+ cmd.params[1] |= mc_enc(32, 8, obj_type[4]);
+ cmd.params[1] |= mc_enc(40, 8, obj_type[5]);
+ cmd.params[1] |= mc_enc(48, 8, obj_type[6]);
+ cmd.params[1] |= mc_enc(56, 8, obj_type[7]);
+ cmd.params[2] |= mc_enc(0, 8, obj_type[8]);
+ cmd.params[2] |= mc_enc(8, 8, obj_type[9]);
+ cmd.params[2] |= mc_enc(16, 8, obj_type[10]);
+ cmd.params[2] |= mc_enc(24, 8, obj_type[11]);
+ cmd.params[2] |= mc_enc(32, 8, obj_type[12]);
+ cmd.params[2] |= mc_enc(40, 8, obj_type[13]);
+ cmd.params[2] |= mc_enc(48, 8, obj_type[14]);
+ cmd.params[2] |= mc_enc(56, 8, obj_type[15]);
+
+ /* send command to mc*/
+ err = mc_send_command(mc_io, &cmd);
+ if (err)
+ return err;
+
+ /* retrieve response parameters */
+ obj_desc->id = (int)mc_dec(cmd.params[0], 32, 32);
+ obj_desc->vendor = (uint16_t)mc_dec(cmd.params[1], 0, 16);
+ obj_desc->vendor = (uint8_t)mc_dec(cmd.params[1], 16, 8);
+ obj_desc->region_count = (uint8_t)mc_dec(cmd.params[1], 24, 8);
+ obj_desc->state = (uint32_t)mc_dec(cmd.params[1], 32, 32);
+ obj_desc->ver_major = (uint16_t)mc_dec(cmd.params[2], 0, 16);
+ obj_desc->ver_minor = (uint16_t)mc_dec(cmd.params[2], 16, 16);
+ obj_desc->type[0] = (char)mc_dec(cmd.params[3], 0, 8);
+ obj_desc->type[1] = (char)mc_dec(cmd.params[3], 8, 8);
+ obj_desc->type[2] = (char)mc_dec(cmd.params[3], 16, 8);
+ obj_desc->type[3] = (char)mc_dec(cmd.params[3], 24, 8);
+ obj_desc->type[4] = (char)mc_dec(cmd.params[3], 32, 8);
+ obj_desc->type[5] = (char)mc_dec(cmd.params[3], 40, 8);
+ obj_desc->type[6] = (char)mc_dec(cmd.params[3], 48, 8);
+ obj_desc->type[7] = (char)mc_dec(cmd.params[3], 56, 8);
+ obj_desc->type[8] = (char)mc_dec(cmd.params[4], 0, 8);
+ obj_desc->type[9] = (char)mc_dec(cmd.params[4], 8, 8);
+ obj_desc->type[10] = (char)mc_dec(cmd.params[4], 16, 8);
+ obj_desc->type[11] = (char)mc_dec(cmd.params[4], 24, 8);
+ obj_desc->type[12] = (char)mc_dec(cmd.params[4], 32, 8);
+ obj_desc->type[13] = (char)mc_dec(cmd.params[4], 40, 8);
+ obj_desc->type[14] = (char)mc_dec(cmd.params[4], 48, 8);
+ obj_desc->type[15] = (char)mc_dec(cmd.params[4], 56, 8);
+ obj_desc->label[0] = (char)mc_dec(cmd.params[5], 0, 8);
+ obj_desc->label[1] = (char)mc_dec(cmd.params[5], 8, 8);
+ obj_desc->label[2] = (char)mc_dec(cmd.params[5], 16, 8);
+ obj_desc->label[3] = (char)mc_dec(cmd.params[5], 24, 8);
+ obj_desc->label[4] = (char)mc_dec(cmd.params[5], 32, 8);
+ obj_desc->label[5] = (char)mc_dec(cmd.params[5], 40, 8);
+ obj_desc->label[6] = (char)mc_dec(cmd.params[5], 48, 8);
+ obj_desc->label[7] = (char)mc_dec(cmd.params[5], 56, 8);
+ obj_desc->label[8] = (char)mc_dec(cmd.params[6], 0, 8);
+ obj_desc->label[9] = (char)mc_dec(cmd.params[6], 8, 8);
+ obj_desc->label[10] = (char)mc_dec(cmd.params[6], 16, 8);
+ obj_desc->label[11] = (char)mc_dec(cmd.params[6], 24, 8);
+ obj_desc->label[12] = (char)mc_dec(cmd.params[6], 32, 8);
+ obj_desc->label[13] = (char)mc_dec(cmd.params[6], 40, 8);
+ obj_desc->label[14] = (char)mc_dec(cmd.params[6], 48, 8);
+ obj_desc->label[15] = (char)mc_dec(cmd.params[6], 56, 8);
+
+ return 0;
+}
+EXPORT_SYMBOL(dprc_get_obj_desc);
+
+int dprc_set_obj_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ char *obj_type,
+ int obj_id,
+ uint8_t irq_index,
+ struct dprc_irq_cfg *irq_cfg)
+{
+ struct mc_command cmd = { 0 };
+
+ /* prepare command */
+ cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_OBJ_IRQ,
+ cmd_flags,
+ token);
+ cmd.params[0] |= mc_enc(32, 8, irq_index);
+ cmd.params[0] |= mc_enc(0, 32, irq_cfg->val);
+ cmd.params[1] |= mc_enc(0, 64, irq_cfg->paddr);
+ cmd.params[2] |= mc_enc(0, 32, irq_cfg->user_irq_id);
+ cmd.params[2] |= mc_enc(32, 32, obj_id);
+ cmd.params[3] |= mc_enc(0, 8, obj_type[0]);
+ cmd.params[3] |= mc_enc(8, 8, obj_type[1]);
+ cmd.params[3] |= mc_enc(16, 8, obj_type[2]);
+ cmd.params[3] |= mc_enc(24, 8, obj_type[3]);
+ cmd.params[3] |= mc_enc(32, 8, obj_type[4]);
+ cmd.params[3] |= mc_enc(40, 8, obj_type[5]);
+ cmd.params[3] |= mc_enc(48, 8, obj_type[6]);
+ cmd.params[3] |= mc_enc(56, 8, obj_type[7]);
+ cmd.params[4] |= mc_enc(0, 8, obj_type[8]);
+ cmd.params[4] |= mc_enc(8, 8, obj_type[9]);
+ cmd.params[4] |= mc_enc(16, 8, obj_type[10]);
+ cmd.params[4] |= mc_enc(24, 8, obj_type[11]);
+ cmd.params[4] |= mc_enc(32, 8, obj_type[12]);
+ cmd.params[4] |= mc_enc(40, 8, obj_type[13]);
+ cmd.params[4] |= mc_enc(48, 8, obj_type[14]);
+ cmd.params[4] |= mc_enc(56, 8, obj_type[15]);
+
+ /* send command to mc*/
+ return mc_send_command(mc_io, &cmd);
+}
+EXPORT_SYMBOL(dprc_set_obj_irq);
+
+int dprc_get_obj_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ char *obj_type,
+ int obj_id,
+ uint8_t irq_index,
+ int *type,
+ struct dprc_irq_cfg *irq_cfg)
+{
+ struct mc_command cmd = { 0 };
+ int err;
+
+ /* prepare command */
+ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_IRQ,
+ cmd_flags,
+ token);
+ cmd.params[0] |= mc_enc(0, 32, obj_id);
+ cmd.params[0] |= mc_enc(32, 8, irq_index);
+ cmd.params[1] |= mc_enc(0, 8, obj_type[0]);
+ cmd.params[1] |= mc_enc(8, 8, obj_type[1]);
+ cmd.params[1] |= mc_enc(16, 8, obj_type[2]);
+ cmd.params[1] |= mc_enc(24, 8, obj_type[3]);
+ cmd.params[1] |= mc_enc(32, 8, obj_type[4]);
+ cmd.params[1] |= mc_enc(40, 8, obj_type[5]);
+ cmd.params[1] |= mc_enc(48, 8, obj_type[6]);
+ cmd.params[1] |= mc_enc(56, 8, obj_type[7]);
+ cmd.params[2] |= mc_enc(0, 8, obj_type[8]);
+ cmd.params[2] |= mc_enc(8, 8, obj_type[9]);
+ cmd.params[2] |= mc_enc(16, 8, obj_type[10]);
+ cmd.params[2] |= mc_enc(24, 8, obj_type[11]);
+ cmd.params[2] |= mc_enc(32, 8, obj_type[12]);
+ cmd.params[2] |= mc_enc(40, 8, obj_type[13]);
+ cmd.params[2] |= mc_enc(48, 8, obj_type[14]);
+ cmd.params[2] |= mc_enc(56, 8, obj_type[15]);
+
+ /* send command to mc*/
+ err = mc_send_command(mc_io, &cmd);
+ if (err)
+ return err;
+
+ /* retrieve response parameters */
+ irq_cfg->val = (uint32_t)mc_dec(cmd.params[0], 0, 32);
+ irq_cfg->paddr = (uint64_t)mc_dec(cmd.params[1], 0, 64);
+ irq_cfg->user_irq_id = (int)mc_dec(cmd.params[2], 0, 32);
+ *type = (int)mc_dec(cmd.params[2], 32, 32);
+
+ return 0;
+}
+EXPORT_SYMBOL(dprc_get_obj_irq);
+
int dprc_get_res_count(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
char *type,
int *res_count)
@@ -621,7 +881,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);
cmd.params[1] |= mc_enc(0, 8, type[0]);
cmd.params[1] |= mc_enc(8, 8, type[1]);
cmd.params[1] |= mc_enc(16, 8, type[2]);
@@ -652,6 +913,7 @@ int dprc_get_res_count(struct fsl_mc_io *mc_io,
EXPORT_SYMBOL(dprc_get_res_count);

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)
@@ -661,7 +923,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);
cmd.params[0] |= mc_enc(42, 7, range_desc->iter_status);
cmd.params[1] |= mc_enc(0, 32, range_desc->base_id);
cmd.params[1] |= mc_enc(32, 32, range_desc->last_id);
@@ -696,32 +959,8 @@ int dprc_get_res_ids(struct fsl_mc_io *mc_io,
}
EXPORT_SYMBOL(dprc_get_res_ids);

-int dprc_get_portal_paddr(struct fsl_mc_io *mc_io,
- uint16_t token,
- int portal_id,
- uint64_t *portal_addr)
-{
- struct mc_command cmd = { 0 };
- int err;
-
- /* prepare command */
- cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_PORTAL_PADDR,
- MC_CMD_PRI_LOW, token);
- cmd.params[0] |= mc_enc(0, 32, portal_id);
-
- /* send command to mc*/
- err = mc_send_command(mc_io, &cmd);
- if (err)
- return err;
-
- /* retrieve response parameters */
- *portal_addr = mc_dec(cmd.params[1], 0, 64);
-
- return 0;
-}
-EXPORT_SYMBOL(dprc_get_portal_paddr);
-
int dprc_get_obj_region(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
char *obj_type,
int obj_id,
@@ -733,7 +972,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);
cmd.params[0] |= mc_enc(0, 32, obj_id);
cmd.params[0] |= mc_enc(48, 8, region_index);
cmd.params[3] |= mc_enc(0, 8, obj_type[0]);
@@ -759,28 +999,83 @@ int dprc_get_obj_region(struct fsl_mc_io *mc_io,
return err;

/* retrieve response parameters */
- region_desc->base_paddr = mc_dec(cmd.params[1], 0, 64);
+ region_desc->base_offset = mc_dec(cmd.params[1], 0, 64);
region_desc->size = mc_dec(cmd.params[2], 0, 32);

return 0;
}
EXPORT_SYMBOL(dprc_get_obj_region);

+int dprc_set_obj_label(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ char *obj_type,
+ int obj_id,
+ char *label)
+{
+ struct mc_command cmd = { 0 };
+
+ /* prepare command */
+ cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_OBJ_LABEL,
+ cmd_flags,
+ token);
+
+ cmd.params[0] |= mc_enc(0, 32, obj_id);
+ cmd.params[1] |= mc_enc(0, 8, label[0]);
+ cmd.params[1] |= mc_enc(8, 8, label[1]);
+ cmd.params[1] |= mc_enc(16, 8, label[2]);
+ cmd.params[1] |= mc_enc(24, 8, label[3]);
+ cmd.params[1] |= mc_enc(32, 8, label[4]);
+ cmd.params[1] |= mc_enc(40, 8, label[5]);
+ cmd.params[1] |= mc_enc(48, 8, label[6]);
+ cmd.params[1] |= mc_enc(56, 8, label[7]);
+ cmd.params[2] |= mc_enc(0, 8, label[8]);
+ cmd.params[2] |= mc_enc(8, 8, label[9]);
+ cmd.params[2] |= mc_enc(16, 8, label[10]);
+ cmd.params[2] |= mc_enc(24, 8, label[11]);
+ cmd.params[2] |= mc_enc(32, 8, label[12]);
+ cmd.params[2] |= mc_enc(40, 8, label[13]);
+ cmd.params[2] |= mc_enc(48, 8, label[14]);
+ cmd.params[2] |= mc_enc(56, 8, label[15]);
+ cmd.params[3] |= mc_enc(0, 8, obj_type[0]);
+ cmd.params[3] |= mc_enc(8, 8, obj_type[1]);
+ cmd.params[3] |= mc_enc(16, 8, obj_type[2]);
+ cmd.params[3] |= mc_enc(24, 8, obj_type[3]);
+ cmd.params[3] |= mc_enc(32, 8, obj_type[4]);
+ cmd.params[3] |= mc_enc(40, 8, obj_type[5]);
+ cmd.params[3] |= mc_enc(48, 8, obj_type[6]);
+ cmd.params[3] |= mc_enc(56, 8, obj_type[7]);
+ cmd.params[4] |= mc_enc(0, 8, obj_type[8]);
+ cmd.params[4] |= mc_enc(8, 8, obj_type[9]);
+ cmd.params[4] |= mc_enc(16, 8, obj_type[10]);
+ cmd.params[4] |= mc_enc(24, 8, obj_type[11]);
+ cmd.params[4] |= mc_enc(32, 8, obj_type[12]);
+ cmd.params[4] |= mc_enc(40, 8, obj_type[13]);
+ cmd.params[4] |= mc_enc(48, 8, obj_type[14]);
+ cmd.params[4] |= mc_enc(56, 8, obj_type[15]);
+
+ /* send command to mc*/
+ return mc_send_command(mc_io, &cmd);
+}
+EXPORT_SYMBOL(dprc_set_obj_label);
+
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);
cmd.params[0] |= mc_enc(0, 32, endpoint1->id);
- cmd.params[0] |= mc_enc(32, 32, endpoint1->interface_id);
+ cmd.params[0] |= mc_enc(32, 32, endpoint1->if_id);
cmd.params[1] |= mc_enc(0, 32, endpoint2->id);
- cmd.params[1] |= mc_enc(32, 32, endpoint2->interface_id);
+ cmd.params[1] |= mc_enc(32, 32, endpoint2->if_id);
cmd.params[2] |= mc_enc(0, 8, endpoint1->type[0]);
cmd.params[2] |= mc_enc(8, 8, endpoint1->type[1]);
cmd.params[2] |= mc_enc(16, 8, endpoint1->type[2]);
@@ -797,6 +1092,8 @@ int dprc_connect(struct fsl_mc_io *mc_io,
cmd.params[3] |= mc_enc(40, 8, endpoint1->type[13]);
cmd.params[3] |= mc_enc(48, 8, endpoint1->type[14]);
cmd.params[3] |= mc_enc(56, 8, endpoint1->type[15]);
+ cmd.params[4] |= mc_enc(0, 32, cfg->max_rate);
+ cmd.params[4] |= mc_enc(32, 32, cfg->committed_rate);
cmd.params[5] |= mc_enc(0, 8, endpoint2->type[0]);
cmd.params[5] |= mc_enc(8, 8, endpoint2->type[1]);
cmd.params[5] |= mc_enc(16, 8, endpoint2->type[2]);
@@ -817,8 +1114,10 @@ int dprc_connect(struct fsl_mc_io *mc_io,
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_connect);

int dprc_disconnect(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
const struct dprc_endpoint *endpoint)
{
@@ -826,10 +1125,10 @@ 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);
cmd.params[0] |= mc_enc(0, 32, endpoint->id);
- cmd.params[0] |= mc_enc(32, 32, endpoint->interface_id);
+ cmd.params[0] |= mc_enc(32, 32, endpoint->if_id);
cmd.params[1] |= mc_enc(0, 8, endpoint->type[0]);
cmd.params[1] |= mc_enc(8, 8, endpoint->type[1]);
cmd.params[1] |= mc_enc(16, 8, endpoint->type[2]);
@@ -850,22 +1149,24 @@ int dprc_disconnect(struct fsl_mc_io *mc_io,
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
+EXPORT_SYMBOL(dprc_disconnect);

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);
cmd.params[0] |= mc_enc(0, 32, endpoint1->id);
- cmd.params[0] |= mc_enc(32, 32, endpoint1->interface_id);
+ cmd.params[0] |= mc_enc(32, 32, endpoint1->if_id);
cmd.params[1] |= mc_enc(0, 8, endpoint1->type[0]);
cmd.params[1] |= mc_enc(8, 8, endpoint1->type[1]);
cmd.params[1] |= mc_enc(16, 8, endpoint1->type[2]);
@@ -890,7 +1191,7 @@ int dprc_get_connection(struct fsl_mc_io *mc_io,

/* retrieve response parameters */
endpoint2->id = mc_dec(cmd.params[3], 0, 32);
- endpoint2->interface_id = mc_dec(cmd.params[3], 32, 32);
+ endpoint2->if_id = mc_dec(cmd.params[3], 32, 32);
endpoint2->type[0] = mc_dec(cmd.params[4], 0, 8);
endpoint2->type[1] = mc_dec(cmd.params[4], 8, 8);
endpoint2->type[2] = mc_dec(cmd.params[4], 16, 8);
@@ -911,3 +1212,4 @@ int dprc_get_connection(struct fsl_mc_io *mc_io,

return 0;
}
+EXPORT_SYMBOL(dprc_get_connection);
diff --git a/drivers/staging/fsl-mc/bus/mc-allocator.c b/drivers/staging/fsl-mc/bus/mc-allocator.c
index e36235d..376ce80 100644
--- a/drivers/staging/fsl-mc/bus/mc-allocator.c
+++ b/drivers/staging/fsl-mc/bus/mc-allocator.c
@@ -373,19 +373,19 @@ int fsl_mc_portal_reset(struct fsl_mc_io *mc_io)
if (WARN_ON(!mc_dev))
return -EINVAL;

- error = dpmcp_open(mc_io, mc_dev->obj_desc.id, &token);
+ error = dpmcp_open(mc_io, 0, mc_dev->obj_desc.id, &token);
if (error < 0) {
dev_err(&mc_dev->dev, "dpmcp_open() failed: %d\n", error);
return error;
}

- error = dpmcp_reset(mc_io, token);
+ error = dpmcp_reset(mc_io, 0, token);
if (error < 0) {
dev_err(&mc_dev->dev, "dpmcp_reset() failed: %d\n", error);
return error;
}

- error = dpmcp_close(mc_io, token);
+ error = dpmcp_close(mc_io, 0, token);
if (error < 0) {
dev_err(&mc_dev->dev, "dpmcp_close() failed: %d\n", error);
return error;
diff --git a/drivers/staging/fsl-mc/bus/mc-bus.c b/drivers/staging/fsl-mc/bus/mc-bus.c
index 766a659..795814c 100644
--- a/drivers/staging/fsl-mc/bus/mc-bus.c
+++ b/drivers/staging/fsl-mc/bus/mc-bus.c
@@ -213,14 +213,14 @@ static int get_dprc_icid(struct fsl_mc_io *mc_io,
struct dprc_attributes attr;
int error;

- error = dprc_open(mc_io, container_id, &dprc_handle);
+ error = dprc_open(mc_io, 0, container_id, &dprc_handle);
if (error < 0) {
pr_err("dprc_open() failed: %d\n", error);
return error;
}

memset(&attr, 0, sizeof(attr));
- error = dprc_get_attributes(mc_io, dprc_handle, &attr);
+ error = dprc_get_attributes(mc_io, 0, dprc_handle, &attr);
if (error < 0) {
pr_err("dprc_get_attributes() failed: %d\n", error);
goto common_cleanup;
@@ -230,11 +230,12 @@ static int get_dprc_icid(struct fsl_mc_io *mc_io,
error = 0;

common_cleanup:
- (void)dprc_close(mc_io, dprc_handle);
+ (void)dprc_close(mc_io, 0, dprc_handle);
return error;
}

-static int translate_mc_addr(uint64_t mc_addr, phys_addr_t *phys_addr)
+static int translate_mc_addr(enum dprc_region_type mc_region_type,
+ uint64_t mc_offset, phys_addr_t *phys_addr)
{
int i;
struct fsl_mc *mc = dev_get_drvdata(fsl_mc_bus_type.dev_root->parent);
@@ -243,7 +244,7 @@ static int translate_mc_addr(uint64_t mc_addr, phys_addr_t *phys_addr)
/*
* Do identity mapping:
*/
- *phys_addr = mc_addr;
+ *phys_addr = mc_offset;
return 0;
}

@@ -251,10 +252,11 @@ static int translate_mc_addr(uint64_t mc_addr, phys_addr_t *phys_addr)
struct fsl_mc_addr_translation_range *range =
&mc->translation_ranges[i];

- if (mc_addr >= range->start_mc_addr &&
- mc_addr < range->end_mc_addr) {
+ if (mc_region_type == range->mc_region_type &&
+ mc_offset >= range->start_mc_offset &&
+ mc_offset < range->end_mc_offset) {
*phys_addr = range->start_phys_addr +
- (mc_addr - range->start_mc_addr);
+ (mc_offset - range->start_mc_offset);
return 0;
}
}
@@ -270,6 +272,22 @@ static int fsl_mc_device_get_mmio_regions(struct fsl_mc_device *mc_dev,
struct resource *regions;
struct dprc_obj_desc *obj_desc = &mc_dev->obj_desc;
struct device *parent_dev = mc_dev->dev.parent;
+ enum dprc_region_type mc_region_type;
+
+ if (strcmp(obj_desc->type, "dprc") == 0 ||
+ strcmp(obj_desc->type, "dpmcp") == 0) {
+ mc_region_type = DPRC_REGION_TYPE_MC_PORTAL;
+ } else if (strcmp(obj_desc->type, "dpio") == 0) {
+ mc_region_type = DPRC_REGION_TYPE_QBMAN_PORTAL;
+ } else {
+ /*
+ * This function should not have been called for this MC object
+ * type, as this object type is not supposed to have MMIO
+ * regions
+ */
+ WARN_ON(true);
+ return -EINVAL;
+ }

regions = kmalloc_array(obj_desc->region_count,
sizeof(regions[0]), GFP_KERNEL);
@@ -280,6 +298,7 @@ static int fsl_mc_device_get_mmio_regions(struct fsl_mc_device *mc_dev,
struct dprc_region_desc region_desc;

error = dprc_get_obj_region(mc_bus_dev->mc_io,
+ 0,
mc_bus_dev->mc_handle,
obj_desc->type,
obj_desc->id, i, &region_desc);
@@ -289,14 +308,15 @@ static int fsl_mc_device_get_mmio_regions(struct fsl_mc_device *mc_dev,
goto error_cleanup_regions;
}

- WARN_ON(region_desc.base_paddr == 0x0);
WARN_ON(region_desc.size == 0);
- error = translate_mc_addr(region_desc.base_paddr,
+ error = translate_mc_addr(mc_region_type,
+ region_desc.base_offset,
&regions[i].start);
if (error < 0) {
dev_err(parent_dev,
- "Invalid MC address: %#llx\n",
- region_desc.base_paddr);
+ "Invalid MC offset: %#x (for %s.%d\'s region %d)\n",
+ region_desc.base_offset,
+ obj_desc->type, obj_desc->id, i);
goto error_cleanup_regions;
}

@@ -574,11 +594,13 @@ static int get_mc_addr_translation_ranges(struct device *dev,
for (i = 0; i < *num_ranges; ++i) {
struct fsl_mc_addr_translation_range *range = &(*ranges)[i];

- range->start_mc_addr = of_read_number(cell, mc_addr_cells);
+ range->mc_region_type = of_read_number(cell, 1);
+ range->start_mc_offset = of_read_number(cell + 1,
+ mc_addr_cells - 1);
cell += mc_addr_cells;
range->start_phys_addr = of_read_number(cell, paddr_cells);
cell += paddr_cells;
- range->end_mc_addr = range->start_mc_addr +
+ range->end_mc_offset = range->start_mc_offset +
of_read_number(cell, mc_size_cells);

cell += mc_size_cells;
@@ -630,7 +652,7 @@ static int fsl_mc_bus_probe(struct platform_device *pdev)
if (error < 0)
return error;

- error = mc_get_version(mc_io, &mc_version);
+ error = mc_get_version(mc_io, 0, &mc_version);
if (error != 0) {
dev_err(&pdev->dev,
"mc_get_version() failed with error %d\n", error);
@@ -661,7 +683,7 @@ static int fsl_mc_bus_probe(struct platform_device *pdev)
if (error < 0)
goto error_cleanup_mc_io;

- error = dpmng_get_container_id(mc_io, &container_id);
+ error = dpmng_get_container_id(mc_io, 0, &container_id);
if (error < 0) {
dev_err(&pdev->dev,
"dpmng_get_container_id() failed: %d\n", error);
diff --git a/drivers/staging/fsl-mc/include/dpbp-cmd.h b/drivers/staging/fsl-mc/include/dpbp-cmd.h
index 1fd70a21..efa9bf3 100644
--- a/drivers/staging/fsl-mc/include/dpbp-cmd.h
+++ b/drivers/staging/fsl-mc/include/dpbp-cmd.h
@@ -34,7 +34,7 @@

/* DPBP Version */
#define DPBP_VER_MAJOR 2
-#define DPBP_VER_MINOR 0
+#define DPBP_VER_MINOR 1

/* Command IDs */
#define DPBP_CMDID_CLOSE 0x800
diff --git a/drivers/staging/fsl-mc/include/dpbp.h b/drivers/staging/fsl-mc/include/dpbp.h
index 5f3c8e7..5d16bb1 100644
--- a/drivers/staging/fsl-mc/include/dpbp.h
+++ b/drivers/staging/fsl-mc/include/dpbp.h
@@ -41,6 +41,7 @@ struct fsl_mc_io;
/**
* dpbp_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_'
* @dpbp_id: DPBP unique ID
* @token: Returned token; use in subsequent API calls
*
@@ -54,11 +55,15 @@ struct fsl_mc_io;
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token);
+int dpbp_open(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ int dpbp_id,
+ uint16_t *token);

/**
* dpbp_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 DPBP object
*
* After this function is called, no further operations are
@@ -66,10 +71,12 @@ int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token);
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpbp_close(struct fsl_mc_io *mc_io, uint16_t token);
+int dpbp_close(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token);

/**
- * struct dpbp_cfg() - Structure representing DPBP configuration
+ * struct dpbp_cfg - Structure representing DPBP configuration
* @options: place holder
*/
struct dpbp_cfg {
@@ -79,6 +86,7 @@ struct dpbp_cfg {
/**
* dpbp_create() - Create the DPBP object.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @cfg: Configuration structure
* @token: Returned token; use in subsequent API calls
*
@@ -97,99 +105,123 @@ struct dpbp_cfg {
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_create(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
const struct dpbp_cfg *cfg,
uint16_t *token);

/**
* dpbp_destroy() - Destroy the DPBP 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 DPBP object
*
* Return: '0' on Success; error code otherwise.
*/
-int dpbp_destroy(struct fsl_mc_io *mc_io, uint16_t token);
+int dpbp_destroy(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token);

/**
* dpbp_enable() - Enable the DPBP.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpbp_enable(struct fsl_mc_io *mc_io, uint16_t token);
+int dpbp_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token);

/**
* dpbp_disable() - Disable the DPBP.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpbp_disable(struct fsl_mc_io *mc_io, uint16_t token);
+int dpbp_disable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token);

/**
* dpbp_is_enabled() - Check if the DPBP is enabled.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @en: Returns '1' if object is enabled; '0' otherwise
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpbp_is_enabled(struct fsl_mc_io *mc_io, uint16_t token, int *en);
+int dpbp_is_enabled(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ int *en);

/**
* dpbp_reset() - Reset the DPBP, returns the object to initial state.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpbp_reset(struct fsl_mc_io *mc_io, uint16_t token);
+int dpbp_reset(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token);
+
+/**
+ * struct dpbp_irq_cfg - IRQ configuration
+ * @addr: Address that must be written to signal a message-based interrupt
+ * @val: Value to write into irq_addr address
+ * @user_irq_id: A user defined number associated with this IRQ
+ */
+struct dpbp_irq_cfg {
+ uint64_t addr;
+ uint32_t val;
+ int user_irq_id;
+};

/**
* dpbp_set_irq() - Set IRQ information for the DPBP to trigger an interrupt.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: Identifies the interrupt index to configure
- * @irq_addr: Address that must be written to
- * signal a message-based interrupt
- * @irq_val: Value to write into irq_addr address
- * @user_irq_id: A user defined number associated with this IRQ
+ * @irq_cfg: IRQ configuration
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
- uint64_t irq_addr,
- uint32_t irq_val,
- int user_irq_id);
+ struct dpbp_irq_cfg *irq_cfg);

/**
* dpbp_get_irq() - Get IRQ information from the DPBP.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @type: Interrupt type: 0 represents message interrupt
- * type (both irq_addr and irq_val are valid)
- * @irq_addr: Returned address that must be written to
- * signal the message-based interrupt
- * @irq_val: Value to write into irq_addr address
- * @user_irq_id: A user defined number associated with this IRQ
+ * type (both irq_addr and irq_val are valid)
+ * @irq_cfg: IRQ attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
int *type,
- uint64_t *irq_addr,
- uint32_t *irq_val,
- int *user_irq_id);
+ struct dpbp_irq_cfg *irq_cfg);

/**
* dpbp_set_irq_enable() - Set overall interrupt state.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @en: Interrupt state - enable = 1, disable = 0
@@ -202,6 +234,7 @@ int dpbp_get_irq(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint8_t en);
@@ -209,6 +242,7 @@ int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
/**
* dpbp_get_irq_enable() - Get overall interrupt state
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @en: Returned interrupt state - enable = 1, disable = 0
@@ -216,6 +250,7 @@ int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint8_t *en);
@@ -223,6 +258,7 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
/**
* dpbp_set_irq_mask() - Set interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @mask: Event mask to trigger interrupt;
@@ -236,6 +272,7 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t mask);
@@ -243,6 +280,7 @@ int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
/**
* dpbp_get_irq_mask() - Get interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @mask: Returned event mask to trigger interrupt
@@ -253,6 +291,7 @@ int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t *mask);
@@ -261,6 +300,7 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
* dpbp_get_irq_status() - Get the current status of any pending interrupts.
*
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @status: Returned interrupts status - one bit per cause:
@@ -270,6 +310,7 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t *status);
@@ -278,6 +319,7 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
* dpbp_clear_irq_status() - Clear a pending interrupt's status
*
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @status: Bits to clear (W1C) - one bit per cause:
@@ -287,6 +329,7 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_clear_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t status);
@@ -316,12 +359,14 @@ struct dpbp_attr {
* dpbp_get_attributes - Retrieve DPBP attributes.
*
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @attr: Returned object's attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_attributes(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
struct dpbp_attr *attr);

diff --git a/drivers/staging/fsl-mc/include/dpcon-cmd.h b/drivers/staging/fsl-mc/include/dpcon-cmd.h
index c878d33..2617024 100644
--- a/drivers/staging/fsl-mc/include/dpcon-cmd.h
+++ b/drivers/staging/fsl-mc/include/dpcon-cmd.h
@@ -34,7 +34,7 @@

/* DPCON Version */
#define DPCON_VER_MAJOR 2
-#define DPCON_VER_MINOR 0
+#define DPCON_VER_MINOR 1

/* Command IDs */
#define DPCON_CMDID_CLOSE 0x800
diff --git a/drivers/staging/fsl-mc/include/dpmng.h b/drivers/staging/fsl-mc/include/dpmng.h
index 1b052b8..4a0996c 100644
--- a/drivers/staging/fsl-mc/include/dpmng.h
+++ b/drivers/staging/fsl-mc/include/dpmng.h
@@ -41,11 +41,11 @@ struct fsl_mc_io;
/**
* Management Complex firmware version information
*/
-#define MC_VER_MAJOR 6
+#define MC_VER_MAJOR 8
#define MC_VER_MINOR 0

/**
- * struct mc_versoin
+ * struct mc_version
* @major: Major version number: incremented on API compatibility changes
* @minor: Minor version number: incremented on API additions (that are
* backward compatible); reset when major version is incremented
@@ -62,19 +62,25 @@ struct mc_version {
* mc_get_version() - Retrieves the Management Complex firmware
* version information
* @mc_io: Pointer to opaque I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @mc_ver_info: Returned version information structure
*
* Return: '0' on Success; Error code otherwise.
*/
-int mc_get_version(struct fsl_mc_io *mc_io, struct mc_version *mc_ver_info);
+int mc_get_version(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ struct mc_version *mc_ver_info);

/**
* dpmng_get_container_id() - Get container ID associated with a given portal.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @container_id: Requested container ID
*
* Return: '0' on Success; Error code otherwise.
*/
-int dpmng_get_container_id(struct fsl_mc_io *mc_io, int *container_id);
+int dpmng_get_container_id(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ int *container_id);

#endif /* __FSL_DPMNG_H */
diff --git a/drivers/staging/fsl-mc/include/dprc.h b/drivers/staging/fsl-mc/include/dprc.h
index f1862a7..253ef7d 100644
--- a/drivers/staging/fsl-mc/include/dprc.h
+++ b/drivers/staging/fsl-mc/include/dprc.h
@@ -32,6 +32,8 @@
#ifndef _FSL_DPRC_H
#define _FSL_DPRC_H

+#include "mc-cmd.h"
+
/* Data Path Resource Container API
* Contains DPRC API for managing and querying DPAA resources
*/
@@ -55,6 +57,7 @@ struct fsl_mc_io;
/**
* dprc_open() - Open DPRC object for use
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @container_id: Container ID to open
* @token: Returned token of DPRC object
*
@@ -62,11 +65,15 @@ struct fsl_mc_io;
*
* @warning Required before any operation on the object.
*/
-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);

/**
* dprc_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 DPRC object
*
* After this function is called, no further operations are
@@ -74,7 +81,9 @@ int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token);
*
* Return: '0' on Success; Error code otherwise.
*/
-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);

/**
* Container general options
@@ -99,7 +108,7 @@ int dprc_close(struct fsl_mc_io *mc_io, uint16_t token);
/* Object initialization allowed - software context associated with this
* container is allowed to invoke object initialization operations.
*/
-#define DPRC_CFG_OPT_OBJ_CREATE_ALLOWED 0x00000004
+#define DPRC_CFG_OPT_OBJ_CREATE_ALLOWED 0x00000004

/* Topology change allowed - software context associated with this
* container is allowed to invoke topology operations, such as attach/detach
@@ -115,6 +124,9 @@ int dprc_close(struct fsl_mc_io *mc_io, uint16_t token);
/* AIOP - Indicates that container belongs to AIOP. */
#define DPRC_CFG_OPT_AIOP 0x00000020

+/* IRQ Config - Indicates that the container allowed to configure its IRQs. */
+#define DPRC_CFG_OPT_IRQ_CFG_ALLOWED 0x00000040
+
/**
* struct dprc_cfg - Container configuration options
* @icid: Container's ICID; if set to 'DPRC_GET_ICID_FROM_POOL', a free
@@ -122,33 +134,37 @@ int dprc_close(struct fsl_mc_io *mc_io, uint16_t token);
* @portal_id: Portal ID; if set to 'DPRC_GET_PORTAL_ID_FROM_POOL', a free
* portal ID is allocated by the DPRC
* @options: Combination of 'DPRC_CFG_OPT_<X>' options
+ * @label: Object's label
*/
struct dprc_cfg {
- uint16_t icid;
- int portal_id;
- uint64_t options;
+ uint16_t icid;
+ int portal_id;
+ uint64_t options;
+ char label[16];
};

/**
* dprc_create_container() - Create child container
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @cfg: Child container configuration
* @child_container_id: Returned child container ID
- * @child_portal_paddr: Returned base physical address of the
- * child portal
+ * @child_portal_offset: Returned child portal offset from MC portal base
*
* Return: '0' on Success; Error code otherwise.
*/
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);
+ uint64_t *child_portal_offset);

/**
* dprc_destroy_container() - Destroy child container.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @child_container_id: ID of the container to destroy
*
@@ -168,12 +184,14 @@ int dprc_create_container(struct fsl_mc_io *mc_io,
*
*/
int dprc_destroy_container(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int child_container_id);

/**
* dprc_reset_container - Reset child container.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @child_container_id: ID of the container to reset
*
@@ -192,25 +210,33 @@ int dprc_destroy_container(struct fsl_mc_io *mc_io,
*
* Return: '0' on Success; Error code otherwise.
*/
-int dprc_reset_container(struct fsl_mc_io *mc_io,
- uint16_t token,
- int child_container_id);
+int dprc_reset_container(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ int child_container_id);

/* IRQ */

+/* IRQ index */
+#define DPRC_IRQ_INDEX 0
+
/* Number of dprc's IRQs */
#define DPRC_NUM_OF_IRQS 1

-/* Object irq events */
+/* DPRC IRQ events */

-/* IRQ event - Indicates that a new object assigned to the container */
+/* IRQ event - Indicates that a new object added to the container */
#define DPRC_IRQ_EVENT_OBJ_ADDED 0x00000001
-/* IRQ event - Indicates that an object was unassigned from the container */
+
+/* IRQ event - Indicates that an object was removed from the container */
#define DPRC_IRQ_EVENT_OBJ_REMOVED 0x00000002
-/* IRQ event - Indicates that resources assigned to the container */
+
+/* IRQ event - Indicates that resources added to the container */
#define DPRC_IRQ_EVENT_RES_ADDED 0x00000004
-/* IRQ event - Indicates that resources unassigned from the container */
+
+/* IRQ event - Indicates that resources removed from the container */
#define DPRC_IRQ_EVENT_RES_REMOVED 0x00000008
+
/* IRQ event - Indicates that one of the descendant containers that opened by
* this container is destroyed
*/
@@ -225,49 +251,56 @@ int dprc_reset_container(struct fsl_mc_io *mc_io,
#define DPRC_IRQ_EVENT_OBJ_CREATED 0x00000040

/**
+ * struct dprc_irq_cfg - IRQ configuration
+ * @paddr: Address that must be written to signal a message-based interrupt
+ * @val: Value to write into irq_addr address
+ * @user_irq_id: A user defined number associated with this IRQ
+ */
+struct dprc_irq_cfg {
+ uint64_t paddr;
+ uint32_t val;
+ int user_irq_id;
+};
+
+/**
* dprc_set_irq() - Set IRQ information for the DPRC to trigger an interrupt.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @irq_index: Identifies the interrupt index to configure
- * @irq_addr: Address that must be written to
- * signal a message-based interrupt
- * @irq_val: Value to write into irq_addr address
- * @user_irq_id: Returned a user defined number associated with this IRQ
+ * @irq_cfg: IRQ configuration
*
* Return: '0' on Success; Error code otherwise.
*/
int dprc_set_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
- uint64_t irq_addr,
- uint32_t irq_val,
- int user_irq_id);
+ struct dprc_irq_cfg *irq_cfg);

/**
* dprc_get_irq() - Get IRQ information from the DPRC.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @irq_index: The interrupt index to configure
- * @type: Returned interrupt type: 0 represents message interrupt
- * type (both irq_addr and irq_val are valid)
- * @irq_addr: Returned address that must be written to
- * signal the message-based interrupt
- * @irq_val: Value to write into irq_addr address
- * @user_irq_id: A user defined number associated with this IRQ
+ * @type: Interrupt type: 0 represents message interrupt
+ * type (both irq_addr and irq_val are valid)
+ * @irq_cfg: IRQ attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
int *type,
- uint64_t *irq_addr,
- uint32_t *irq_val,
- int *user_irq_id);
+ struct dprc_irq_cfg *irq_cfg);

/**
* dprc_set_irq_enable() - Set overall interrupt state.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @irq_index: The interrupt index to configure
* @en: Interrupt state - enable = 1, disable = 0
@@ -280,6 +313,7 @@ int dprc_get_irq(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_set_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint8_t en);
@@ -287,6 +321,7 @@ int dprc_set_irq_enable(struct fsl_mc_io *mc_io,
/**
* dprc_get_irq_enable() - Get overall interrupt state.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @irq_index: The interrupt index to configure
* @en: Returned interrupt state - enable = 1, disable = 0
@@ -294,6 +329,7 @@ int dprc_set_irq_enable(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_irq_enable(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint8_t *en);
@@ -301,6 +337,7 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io,
/**
* dprc_set_irq_mask() - Set interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @irq_index: The interrupt index to configure
* @mask: event mask to trigger interrupt;
@@ -314,6 +351,7 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_set_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t mask);
@@ -321,6 +359,7 @@ int dprc_set_irq_mask(struct fsl_mc_io *mc_io,
/**
* dprc_get_irq_mask() - Get interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @irq_index: The interrupt index to configure
* @mask: Returned event mask to trigger interrupt
@@ -331,6 +370,7 @@ int dprc_set_irq_mask(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_irq_mask(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t *mask);
@@ -338,6 +378,7 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io,
/**
* dprc_get_irq_status() - Get the current status of any pending interrupts.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @irq_index: The interrupt index to configure
* @status: Returned interrupts status - one bit per cause:
@@ -347,6 +388,7 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t *status);
@@ -354,6 +396,7 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io,
/**
* dprc_clear_irq_status() - Clear a pending interrupt's status
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @irq_index: The interrupt index to configure
* @status: bits to clear (W1C) - one bit per cause:
@@ -363,6 +406,7 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_clear_irq_status(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
uint8_t irq_index,
uint32_t status);
@@ -394,12 +438,14 @@ struct dprc_attributes {
/**
* dprc_get_attributes() - Obtains container attributes
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
- * @attributes Returned container attributes
+ * @attributes: Returned container attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_attributes(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
struct dprc_attributes *attributes);

@@ -407,6 +453,7 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io,
* dprc_set_res_quota() - Set allocation policy for a specific resource/object
* type in a child container
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @child_container_id: ID of the child container
* @type: Resource/object type
@@ -428,6 +475,7 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io,
* @warning Only the parent container is allowed to change a child policy.
*/
int dprc_set_res_quota(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int child_container_id,
char *type,
@@ -437,8 +485,9 @@ int dprc_set_res_quota(struct fsl_mc_io *mc_io,
* dprc_get_res_quota() - Gets the allocation policy of a specific
* resource/object type in a child container
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
- * @child_container_id; ID of the child container
+ * @child_container_id: ID of the child container
* @type: resource/object type
* @quota: Returnes the maximum number of resources of the selected type
* that the child container is allowed to allocate from the parent;
@@ -448,6 +497,7 @@ int dprc_set_res_quota(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_res_quota(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int child_container_id,
char *type,
@@ -500,6 +550,7 @@ struct dprc_res_req {
/**
* dprc_assign() - Assigns objects or resource to a child container.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @container_id: ID of the child container
* @res_req: Describes the type and amount of resources to
@@ -529,6 +580,7 @@ struct dprc_res_req {
* Return: '0' on Success; Error code otherwise.
*/
int dprc_assign(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int container_id,
struct dprc_res_req *res_req);
@@ -537,6 +589,7 @@ int dprc_assign(struct fsl_mc_io *mc_io,
* dprc_unassign() - Un-assigns objects or resources from a child container
* and moves them into this (parent) DPRC.
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @child_container_id: ID of the child container
* @res_req: Describes the type and amount of resources to un-assign from
@@ -548,12 +601,14 @@ int dprc_assign(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_unassign(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int child_container_id,
struct dprc_res_req *res_req);

/**
* dprc_get_pool_count() - Get the number of dprc's pools
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPRC object
* @pool_count: Returned number of resource pools in the dprc
@@ -561,14 +616,16 @@ int dprc_unassign(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_pool_count(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int *pool_count);

/**
* dprc_get_pool() - Get the type (string) of a certain dprc's pool
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
- * @pool_index; Index of the pool to be queried (< pool_count)
+ * @pool_index: Index of the pool to be queried (< pool_count)
* @type: The type of the pool
*
* The pool types retrieved one by one by incrementing
@@ -579,6 +636,7 @@ int dprc_get_pool_count(struct fsl_mc_io *mc_io,
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_pool(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
int pool_index,
char *type);
@@ -586,12 +644,16 @@ int dprc_get_pool(struct fsl_mc_io *mc_io,
/**
* dprc_get_obj_count() - Obtains the number of objects in the DPRC
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @obj_count: Number of objects assigned to the DPRC
*
* Return: '0' on Success; Error code otherwise.
*/
-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);

/* Objects Attributes Flags */

@@ -610,6 +672,7 @@ int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count);
* @irq_count: Number of interrupts supported by the object
* @region_count: Number of mappable regions supported by the object
* @state: Object state: combination of DPRC_OBJ_STATE_ states
+ * @label: Object label
*/
struct dprc_obj_desc {
char type[16];
@@ -620,11 +683,13 @@ struct dprc_obj_desc {
uint8_t irq_count;
uint8_t region_count;
uint32_t state;
+ char label[16];
};

/**
* dprc_get_obj() - Get general information on an 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 DPRC object
* @obj_index: Index of the object to be queried (< obj_count)
* @obj_desc: Returns the requested object descriptor
@@ -637,14 +702,79 @@ struct dprc_obj_desc {
* Return: '0' on Success; Error code otherwise.
*/
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);

/**
+ * dprc_get_obj_desc() - Get object descriptor.
+ *
+ * @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
+ * @token: Token of DPRC object
+ * @obj_type: The type of the object to get its descriptor.
+ * @obj_id: The id of the object to get its descriptor
+ * @obj_desc: The returned descriptor to fill and return to the user
+ *
+ * Return: '0' on Success; Error code otherwise.
+ *
+ */
+int dprc_get_obj_desc(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ char *obj_type,
+ int obj_id,
+ struct dprc_obj_desc *obj_desc);
+
+/**
+ * dprc_set_obj_irq() - Set IRQ information for object to trigger an interrupt.
+ * @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
+ * @token: Token of DPRC object
+ * @obj_type: Type of the object to set its IRQ
+ * @obj_id: ID of the object to set its IRQ
+ * @irq_index: The interrupt index to configure
+ * @irq_cfg: IRQ configuration
+ *
+ * Return: '0' on Success; Error code otherwise.
+ */
+int dprc_set_obj_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ char *obj_type,
+ int obj_id,
+ uint8_t irq_index,
+ struct dprc_irq_cfg *irq_cfg);
+
+/**
+ * dprc_get_obj_irq() - Get IRQ information from 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 DPRC object
+ * @obj_type: Type od the object to get its IRQ
+ * @obj_id: ID of the object to get its IRQ
+ * @irq_index: The interrupt index to configure
+ * @type: Interrupt type: 0 represents message interrupt
+ * type (both irq_addr and irq_val are valid)
+ * @irq_cfg: The returned IRQ attributes
+ *
+ * Return: '0' on Success; Error code otherwise.
+ */
+int dprc_get_obj_irq(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ char *obj_type,
+ int obj_id,
+ uint8_t irq_index,
+ int *type,
+ struct dprc_irq_cfg *irq_cfg);
+
+/**
* dprc_get_res_count() - Obtains the number of free resources that are assigned
* to this container, by pool type
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @type: pool type
* @res_count: Returned number of free resources of the given
@@ -652,7 +782,8 @@ int dprc_get_obj(struct fsl_mc_io *mc_io,
*
* Return: '0' on Success; Error code otherwise.
*/
-int dprc_get_res_count(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);
@@ -687,6 +818,7 @@ struct dprc_res_ids_range_desc {
/**
* dprc_get_res_ids() - Obtains IDs of free resources in the container
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @type: pool type
* @range_desc: range descriptor
@@ -694,39 +826,48 @@ struct dprc_res_ids_range_desc {
* Return: '0' on Success; Error code otherwise.
*/
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);

+/* Region flags */
+/* Cacheable - Indicates that region should be mapped as cacheable */
+#define DPRC_REGION_CACHEABLE 0x00000001
+
/**
- * dprc_get_portal_paddr() - Get the physical address of MC portals
- * @mc_io: Pointer to MC portal's I/O object
- * @token: Token of DPRC object
- * @portal_id: MC portal ID
- * @portal_addr: The physical address of the MC portal ID
- *
- * Return: '0' on Success; Error code otherwise.
+ * enum dprc_region_type - Region type
+ * @DPRC_REGION_TYPE_MC_PORTAL: MC portal region
+ * @DPRC_REGION_TYPE_QBMAN_PORTAL: Qbman portal region
*/
-int dprc_get_portal_paddr(struct fsl_mc_io *mc_io,
- uint16_t token,
- int portal_id,
- uint64_t *portal_addr);
+enum dprc_region_type {
+ DPRC_REGION_TYPE_MC_PORTAL,
+ DPRC_REGION_TYPE_QBMAN_PORTAL
+};

/**
* struct dprc_region_desc - Mappable region descriptor
- * @base_paddr: Region base physical address
+ * @base_offset: Region offset from region's base address.
+ * For DPMCP and DPRC objects, region base is offset from SoC MC portals
+ * base address; For DPIO, region base is offset from SoC QMan portals
+ * base address
* @size: Region size (in bytes)
+ * @flags: Region attributes
+ * @type: Portal region type
*/
struct dprc_region_desc {
- uint64_t base_paddr;
- uint32_t size;
+ uint32_t base_offset;
+ uint32_t size;
+ uint32_t flags;
+ enum dprc_region_type type;
};

/**
* dprc_get_obj_region() - Get region information for a specified 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 DPRC object
- * @obj_type; Object type as returned in dprc_get_obj()
+ * @obj_type: Object type as returned in dprc_get_obj()
* @obj_id: Unique object instance as returned in dprc_get_obj()
* @region_index: The specific region to query
* @region_desc: Returns the requested region descriptor
@@ -734,6 +875,7 @@ struct dprc_region_desc {
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_obj_region(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
char *obj_type,
int obj_id,
@@ -741,57 +883,102 @@ int dprc_get_obj_region(struct fsl_mc_io *mc_io,
struct dprc_region_desc *region_desc);

/**
+ * dprc_set_obj_label() - Set object label.
+ * @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
+ * @token: Token of DPRC object
+ * @obj_type: Object's type
+ * @obj_id: Object's ID
+ * @label: The required label. The maximum length is 16 chars.
+ *
+ * Return: '0' on Success; Error code otherwise.
+ */
+int dprc_set_obj_label(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
+ uint16_t token,
+ char *obj_type,
+ int obj_id,
+ char *label);
+
+/**
* struct dprc_endpoint - Endpoint description for link connect/disconnect
* operations
* @type: Endpoint object type: NULL terminated string
* @id: Endpoint object ID
- * @interface_id: Interface ID; should be set for endpoints with multiple
+ * @if_id: Interface ID; should be set for endpoints with multiple
* interfaces ("dpsw", "dpdmux"); for others, always set to 0
*/
struct dprc_endpoint {
char type[16];
int id;
- int interface_id;
+ int if_id;
+};
+
+/**
+ * struct dprc_connection_cfg - Connection configuration.
+ * Used for virtual connections only
+ * @committed_rate: Committed rate (Mbits/s)
+ * @max_rate: Maximum rate (Mbits/s)
+ */
+struct dprc_connection_cfg {
+ uint32_t committed_rate;
+ uint32_t max_rate;
};

/**
* dprc_connect() - Connect two endpoints to create a network link between them
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @endpoint1: Endpoint 1 configuration parameters
* @endpoint2: Endpoint 2 configuration parameters
+ * @cfg: Connection configuration. The connection configuration is ignored for
+ * connections made to DPMAC objects, where rate is set according to
+ * MAC configuration.
+ * The committed rate is the guaranteed rate for the connection.
+ * The maximum rate is an upper limit allowed for the connection; it is
+ * expected to be equal or higher than the committed rate.
+ * When committed and maximum rates are both zero, the connection is set
+ * to "best effort" mode, having lower priority compared to connections
+ * with committed or maximum rates.
*
* Return: '0' on Success; Error code otherwise.
*/
-int dprc_connect(struct fsl_mc_io *mc_io,
- uint16_t token,
- const struct dprc_endpoint *endpoint1,
- const struct dprc_endpoint *endpoint2);
+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_connection_cfg *cfg);

/**
* dprc_disconnect() - Disconnect one endpoint to remove its network connection
* @mc_io: Pointer to MC portal's I/O object
+ * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPRC object
* @endpoint: Endpoint configuration parameters
*
* Return: '0' on Success; Error code otherwise.
*/
int dprc_disconnect(struct fsl_mc_io *mc_io,
+ uint32_t cmd_flags,
uint16_t token,
const struct dprc_endpoint *endpoint);

/**
* dprc_get_connection() - Get connected endpoint and link status if connection
* exists.
-* @mc_io Pointer to MC portal's I/O object
-* @token Token of DPRC object
-* @endpoint1 Endpoint 1 configuration parameters
-* @endpoint2 Returned endpoint 2 configuration parameters
+* @mc_io: Pointer to MC portal's I/O object
+* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
+* @token: Token of DPRC object
+* @endpoint1: Endpoint 1 configuration parameters
+* @endpoint2: Returned endpoint 2 configuration parameters
* @state: Returned link state: 1 - link is up, 0 - link is down
*
* Return: '0' on Success; -ENAVAIL if connection does not exist.
*/
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,
diff --git a/drivers/staging/fsl-mc/include/mc-cmd.h b/drivers/staging/fsl-mc/include/mc-cmd.h
index 32501e0..57fefd2 100644
--- a/drivers/staging/fsl-mc/include/mc-cmd.h
+++ b/drivers/staging/fsl-mc/include/mc-cmd.h
@@ -67,14 +67,29 @@ enum mc_cmd_status {
MC_CMD_STATUS_INVALID_STATE = 0xC /* Invalid state */
};

+/*
+ * MC command flags
+ */
+
+/* High priority flag */
+#define MC_CMD_FLAG_PRI 0x00008000
+/* Command completion flag */
+#define MC_CMD_FLAG_INTR_DIS 0x01000000
+
+/* TODO Remove following two defines after completion of flib 8.0.0
+integration */
+#define MC_CMD_PRI_LOW 0 /*!< Low Priority command indication */
+#define MC_CMD_PRI_HIGH 1 /*!< High Priority command indication */
+
#define MC_CMD_HDR_CMDID_O 52 /* Command ID field offset */
#define MC_CMD_HDR_CMDID_S 12 /* Command ID field size */
#define MC_CMD_HDR_TOKEN_O 38 /* Token field offset */
#define MC_CMD_HDR_TOKEN_S 10 /* Token field size */
#define MC_CMD_HDR_STATUS_O 16 /* Status field offset */
#define MC_CMD_HDR_STATUS_S 8 /* Status field size*/
-#define MC_CMD_HDR_PRI_O 15 /* Priority field offset */
-#define MC_CMD_HDR_PRI_S 1 /* Priority field size */
+#define MC_CMD_HDR_FLAGS_O 0 /* Flags field offset */
+#define MC_CMD_HDR_FLAGS_S 32 /* Flags field size*/
+#define MC_CMD_HDR_FLAGS_MASK 0xFF00FF00 /* Command flags mask */

#define MC_CMD_HDR_READ_STATUS(_hdr) \
((enum mc_cmd_status)mc_dec((_hdr), \
@@ -83,8 +98,8 @@ enum mc_cmd_status {
#define MC_CMD_HDR_READ_TOKEN(_hdr) \
((uint16_t)mc_dec((_hdr), MC_CMD_HDR_TOKEN_O, MC_CMD_HDR_TOKEN_S))

-#define MC_CMD_PRI_LOW 0 /* Low Priority command indication */
-#define MC_CMD_PRI_HIGH 1 /* High Priority command indication */
+#define MC_CMD_HDR_READ_FLAGS(_hdr) \
+ ((uint32_t)mc_dec((_hdr), MC_CMD_HDR_FLAGS_O, MC_CMD_HDR_FLAGS_S))

#define MC_EXT_OP(_ext, _param, _offset, _width, _type, _arg) \
((_ext)[_param] |= mc_enc((_offset), (_width), _arg))
@@ -96,14 +111,15 @@ enum mc_cmd_status {
(_arg = (_type)mc_dec(_cmd.params[_param], (_offset), (_width)))

static inline uint64_t mc_encode_cmd_header(uint16_t cmd_id,
- uint8_t priority,
+ uint32_t cmd_flags,
uint16_t token)
{
uint64_t hdr;

hdr = mc_enc(MC_CMD_HDR_CMDID_O, MC_CMD_HDR_CMDID_S, cmd_id);
+ hdr |= mc_enc(MC_CMD_HDR_FLAGS_O, MC_CMD_HDR_FLAGS_S,
+ (cmd_flags & MC_CMD_HDR_FLAGS_MASK));
hdr |= mc_enc(MC_CMD_HDR_TOKEN_O, MC_CMD_HDR_TOKEN_S, token);
- hdr |= mc_enc(MC_CMD_HDR_PRI_O, MC_CMD_HDR_PRI_S, priority);
hdr |= mc_enc(MC_CMD_HDR_STATUS_O, MC_CMD_HDR_STATUS_S,
MC_CMD_STATUS_READY);

diff --git a/drivers/staging/fsl-mc/include/mc-private.h b/drivers/staging/fsl-mc/include/mc-private.h
index c045f49..8aef55c 100644
--- a/drivers/staging/fsl-mc/include/mc-private.h
+++ b/drivers/staging/fsl-mc/include/mc-private.h
@@ -29,7 +29,8 @@
/**
* struct fsl_mc - Private data of a "fsl,qoriq-mc" platform device
* @root_mc_bus_dev: MC object device representing the root DPRC
- * @addr_translation_ranges: array of bus to system address translation ranges
+ * @num_translation_ranges: number of entries in addr_translation_ranges
+ * @translation_ranges: array of bus to system address translation ranges
*/
struct fsl_mc {
struct fsl_mc_device *root_mc_bus_dev;
@@ -40,14 +41,16 @@ struct fsl_mc {
/**
* struct fsl_mc_addr_translation_range - bus to system address translation
* range
- * @start_mc_addr: Start MC address of the range being translated
- * @end_mc_addr: MC address of the first byte after the range (last MC
- * address of the range is end_mc_addr - 1)
+ * @mc_region_type: Type of MC region for the range being translated
+ * @start_mc_offset: Start MC offset of the range being translated
+ * @end_mc_offset: MC offset of the first byte after the range (last MC
+ * offset of the range is end_mc_offset - 1)
* @start_phys_addr: system physical address corresponding to start_mc_addr
*/
struct fsl_mc_addr_translation_range {
- uint64_t start_mc_addr;
- uint64_t end_mc_addr;
+ enum dprc_region_type mc_region_type;
+ uint64_t start_mc_offset;
+ uint64_t end_mc_offset;
phys_addr_t start_phys_addr;
};

--
2.3.3

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

Next message: Christian Borntraeger: "Re: [4.2] commit d59cfc09c32 (sched, cgroup: replace signal_struct->group_rwsem with a global percpu_rwsem) causes regression for libvirt/kvm"
Previous message: Jens Wiklander: "Re: [PATCH v5 1/5] arm/arm64: add smccc ARCH32"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]