staging: fsl-mc: convert mc command build/parse to use C structs

The layer abstracting the building of commands and extracting
responses is currently based on macros that shift and mask the command
fields and requires exposing offset/size values as macro parameters
and makes the code harder to read.

For clarity and maintainability, instead use an implementation based on
mapping the MC command definitions to C structures. These structures
contain the hardware command fields (which are naturally-aligned)
and individual fields are little-endian ordering (the byte ordering
of the hardware).

As such, there is no need to perform the conversion between core and
hardware (LE) endianness in mc_send_command(), but instead each
individual field in a command will be converted separately if needed
by the function building the command or extracting the response.

This patch does not introduce functional changes, both the hardware
ABIs and the APIs exposed for the DPAA2 objects remain the same.

Signed-off-by: Ioana Radulescu <ruxandra.radulescu@nxp.com>
Signed-off-by: Stuart Yoder <stuart.yoder@nxp.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/fsl-mc/bus/dpbp.c b/drivers/staging/fsl-mc/bus/dpbp.c
index c31fe1bca19119d8b77a4df0ebbbeaa76c0d9ca3..fe271fbd629bd6189bc3854fce3e54ad98594903 100644 (file)
--- a/drivers/staging/fsl-mc/bus/dpbp.c
+++ b/drivers/staging/fsl-mc/bus/dpbp.c
@@ -1,4 +1,4 @@
-/* Copyright 2013-2014 Freescale Semiconductor Inc.
+/* Copyright 2013-2016 Freescale Semiconductor Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -57,12 +57,14 @@ int dpbp_open(struct fsl_mc_io *mc_io,
              u16 *token)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_open *cmd_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_OPEN,
                                          cmd_flags, 0);
-       cmd.params[0] |= mc_enc(0, 32, dpbp_id);
+       cmd_params = (struct dpbp_cmd_open *)cmd.params;
+       cmd_params->dpbp_id = cpu_to_le32(dpbp_id);
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -70,7 +72,7 @@ int dpbp_open(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
+       *token = mc_cmd_hdr_read_token(&cmd);
 
        return err;
 }
@@ -143,7 +145,7 @@ int dpbp_create(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
+       *token = mc_cmd_hdr_read_token(&cmd);
 
        return 0;
 }
@@ -231,6 +233,7 @@ int dpbp_is_enabled(struct fsl_mc_io *mc_io,
                    int *en)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_rsp_is_enabled *rsp_params;
        int err;
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_IS_ENABLED, cmd_flags,
@@ -242,7 +245,8 @@ int dpbp_is_enabled(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *en = (int)mc_dec(cmd.params[0], 0, 1);
+       rsp_params = (struct dpbp_rsp_is_enabled *)cmd.params;
+       *en = rsp_params->enabled & DPBP_ENABLE;
 
        return 0;
 }
@@ -286,14 +290,16 @@ int dpbp_set_irq(struct fsl_mc_io *mc_io,
                 struct dpbp_irq_cfg *irq_cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_set_irq *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_IRQ,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 8, irq_index);
-       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->irq_num);
+       cmd_params = (struct dpbp_cmd_set_irq *)cmd.params;
+       cmd_params->irq_index = irq_index;
+       cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
+       cmd_params->irq_addr = cpu_to_le64(irq_cfg->addr);
+       cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -319,12 +325,15 @@ int dpbp_get_irq(struct fsl_mc_io *mc_io,
                 struct dpbp_irq_cfg *irq_cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_get_irq *cmd_params;
+       struct dpbp_rsp_get_irq *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpbp_cmd_get_irq *)cmd.params;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -332,10 +341,12 @@ int dpbp_get_irq(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       irq_cfg->val = (u32)mc_dec(cmd.params[0], 0, 32);
-       irq_cfg->addr = (u64)mc_dec(cmd.params[1], 0, 64);
-       irq_cfg->irq_num = (int)mc_dec(cmd.params[2], 0, 32);
-       *type = (int)mc_dec(cmd.params[2], 32, 32);
+       rsp_params = (struct dpbp_rsp_get_irq *)cmd.params;
+       irq_cfg->val = le32_to_cpu(rsp_params->irq_val);
+       irq_cfg->addr = le64_to_cpu(rsp_params->irq_addr);
+       irq_cfg->irq_num = le32_to_cpu(rsp_params->irq_num);
+       *type = le32_to_cpu(rsp_params->type);
+
        return 0;
 }
 
@@ -361,12 +372,14 @@ int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
                        u8 en)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_set_irq_enable *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_IRQ_ENABLE,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 8, en);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpbp_cmd_set_irq_enable *)cmd.params;
+       cmd_params->enable = en & DPBP_ENABLE;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -389,12 +402,15 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
                        u8 *en)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_get_irq_enable *cmd_params;
+       struct dpbp_rsp_get_irq_enable *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ_ENABLE,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpbp_cmd_get_irq_enable *)cmd.params;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -402,7 +418,8 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *en = (u8)mc_dec(cmd.params[0], 0, 8);
+       rsp_params = (struct dpbp_rsp_get_irq_enable *)cmd.params;
+       *en = rsp_params->enabled & DPBP_ENABLE;
        return 0;
 }
 
@@ -429,12 +446,14 @@ int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
                      u32 mask)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_set_irq_mask *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_IRQ_MASK,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 32, mask);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpbp_cmd_set_irq_mask *)cmd.params;
+       cmd_params->mask = cpu_to_le32(mask);
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -460,12 +479,15 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
                      u32 *mask)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_get_irq_mask *cmd_params;
+       struct dpbp_rsp_get_irq_mask *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ_MASK,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpbp_cmd_get_irq_mask *)cmd.params;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -473,7 +495,9 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *mask = (u32)mc_dec(cmd.params[0], 0, 32);
+       rsp_params = (struct dpbp_rsp_get_irq_mask *)cmd.params;
+       *mask = le32_to_cpu(rsp_params->mask);
+
        return 0;
 }
 
@@ -497,13 +521,16 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
                        u32 *status)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_get_irq_status *cmd_params;
+       struct dpbp_rsp_get_irq_status *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ_STATUS,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 32, *status);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpbp_cmd_get_irq_status *)cmd.params;
+       cmd_params->status = cpu_to_le32(*status);
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -511,7 +538,9 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *status = (u32)mc_dec(cmd.params[0], 0, 32);
+       rsp_params = (struct dpbp_rsp_get_irq_status *)cmd.params;
+       *status = le32_to_cpu(rsp_params->status);
+
        return 0;
 }
 
@@ -535,12 +564,14 @@ int dpbp_clear_irq_status(struct fsl_mc_io *mc_io,
                          u32 status)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_clear_irq_status *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLEAR_IRQ_STATUS,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 32, status);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpbp_cmd_clear_irq_status *)cmd.params;
+       cmd_params->status = cpu_to_le32(status);
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -562,6 +593,7 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io,
                        struct dpbp_attr *attr)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_rsp_get_attributes *rsp_params;
        int err;
 
        /* prepare command */
@@ -574,10 +606,12 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       attr->bpid = (u16)mc_dec(cmd.params[0], 16, 16);
-       attr->id = (int)mc_dec(cmd.params[0], 32, 32);
-       attr->version.major = (u16)mc_dec(cmd.params[1], 0, 16);
-       attr->version.minor = (u16)mc_dec(cmd.params[1], 16, 16);
+       rsp_params = (struct dpbp_rsp_get_attributes *)cmd.params;
+       attr->bpid = le16_to_cpu(rsp_params->bpid);
+       attr->id = le32_to_cpu(rsp_params->id);
+       attr->version.major = le16_to_cpu(rsp_params->version_major);
+       attr->version.minor = le16_to_cpu(rsp_params->version_minor);
+
        return 0;
 }
 EXPORT_SYMBOL(dpbp_get_attributes);
@@ -597,19 +631,19 @@ int dpbp_set_notifications(struct fsl_mc_io *mc_io,
                           struct dpbp_notification_cfg *cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_cmd_set_notifications *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_NOTIFICATIONS,
-                                         cmd_flags,
-                                         token);
-
-       cmd.params[0] |= mc_enc(0, 32, cfg->depletion_entry);
-       cmd.params[0] |= mc_enc(32, 32, cfg->depletion_exit);
-       cmd.params[1] |= mc_enc(0, 32, cfg->surplus_entry);
-       cmd.params[1] |= mc_enc(32, 32, cfg->surplus_exit);
-       cmd.params[2] |= mc_enc(0, 16, cfg->options);
-       cmd.params[3] |= mc_enc(0, 64, cfg->message_ctx);
-       cmd.params[4] |= mc_enc(0, 64, cfg->message_iova);
+                                         cmd_flags, token);
+       cmd_params = (struct dpbp_cmd_set_notifications *)cmd.params;
+       cmd_params->depletion_entry = cpu_to_le32(cfg->depletion_entry);
+       cmd_params->depletion_exit = cpu_to_le32(cfg->depletion_exit);
+       cmd_params->surplus_entry = cpu_to_le32(cfg->surplus_entry);
+       cmd_params->surplus_exit = cpu_to_le32(cfg->surplus_exit);
+       cmd_params->options = cpu_to_le16(cfg->options);
+       cmd_params->message_ctx = cpu_to_le64(cfg->message_ctx);
+       cmd_params->message_iova = cpu_to_le64(cfg->message_iova);
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -630,6 +664,7 @@ int dpbp_get_notifications(struct fsl_mc_io *mc_io,
                           struct dpbp_notification_cfg *cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dpbp_rsp_get_notifications *rsp_params;
        int err;
 
        /* prepare command */
@@ -643,13 +678,14 @@ int dpbp_get_notifications(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       cfg->depletion_entry = (u32)mc_dec(cmd.params[0], 0, 32);
-       cfg->depletion_exit = (u32)mc_dec(cmd.params[0], 32, 32);
-       cfg->surplus_entry = (u32)mc_dec(cmd.params[1], 0, 32);
-       cfg->surplus_exit = (u32)mc_dec(cmd.params[1], 32, 32);
-       cfg->options = (u16)mc_dec(cmd.params[2], 0, 16);
-       cfg->message_ctx = (u64)mc_dec(cmd.params[3], 0, 64);
-       cfg->message_iova = (u64)mc_dec(cmd.params[4], 0, 64);
+       rsp_params = (struct dpbp_rsp_get_notifications *)cmd.params;
+       cfg->depletion_entry = le32_to_cpu(rsp_params->depletion_entry);
+       cfg->depletion_exit = le32_to_cpu(rsp_params->depletion_exit);
+       cfg->surplus_entry = le32_to_cpu(rsp_params->surplus_entry);
+       cfg->surplus_exit = le32_to_cpu(rsp_params->surplus_exit);
+       cfg->options = le16_to_cpu(rsp_params->options);
+       cfg->message_ctx = le64_to_cpu(rsp_params->message_ctx);
+       cfg->message_iova = le64_to_cpu(rsp_params->message_iova);
 
        return 0;
 }

diff --git a/drivers/staging/fsl-mc/bus/dpmcp-cmd.h b/drivers/staging/fsl-mc/bus/dpmcp-cmd.h
index c9b52dd7ba31dcc6a0f0d994b241fa91062b6c59..d098a6d8f6bced916d68ae010d67ce25adecd2eb 100644 (file)
--- a/drivers/staging/fsl-mc/bus/dpmcp-cmd.h
+++ b/drivers/staging/fsl-mc/bus/dpmcp-cmd.h
@@ -1,4 +1,4 @@
-/* Copyright 2013-2015 Freescale Semiconductor Inc.
+/* Copyright 2013-2016 Freescale Semiconductor Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -53,4 +53,88 @@
 #define DPMCP_CMDID_GET_IRQ_MASK                       0x015
 #define DPMCP_CMDID_GET_IRQ_STATUS                     0x016
 
+struct dpmcp_cmd_open {
+       __le32 dpmcp_id;
+};
+
+struct dpmcp_cmd_create {
+       __le32 portal_id;
+};
+
+struct dpmcp_cmd_set_irq {
+       /* cmd word 0 */
+       u8 irq_index;
+       u8 pad[3];
+       __le32 irq_val;
+       /* cmd word 1 */
+       __le64 irq_addr;
+       /* cmd word 2 */
+       __le32 irq_num;
+};
+
+struct dpmcp_cmd_get_irq {
+       __le32 pad;
+       u8 irq_index;
+};
+
+struct dpmcp_rsp_get_irq {
+       /* cmd word 0 */
+       __le32 irq_val;
+       __le32 pad;
+       /* cmd word 1 */
+       __le64 irq_paddr;
+       /* cmd word 2 */
+       __le32 irq_num;
+       __le32 type;
+};
+
+#define DPMCP_ENABLE           0x1
+
+struct dpmcp_cmd_set_irq_enable {
+       u8 enable;
+       u8 pad[3];
+       u8 irq_index;
+};
+
+struct dpmcp_cmd_get_irq_enable {
+       __le32 pad;
+       u8 irq_index;
+};
+
+struct dpmcp_rsp_get_irq_enable {
+       u8 enabled;
+};
+
+struct dpmcp_cmd_set_irq_mask {
+       __le32 mask;
+       u8 irq_index;
+};
+
+struct dpmcp_cmd_get_irq_mask {
+       __le32 pad;
+       u8 irq_index;
+};
+
+struct dpmcp_rsp_get_irq_mask {
+       __le32 mask;
+};
+
+struct dpmcp_cmd_get_irq_status {
+       __le32 status;
+       u8 irq_index;
+};
+
+struct dpmcp_rsp_get_irq_status {
+       __le32 status;
+};
+
+struct dpmcp_rsp_get_attributes {
+       /* response word 0 */
+       __le32 pad;
+       __le32 id;
+       /* response word 1 */
+       __le16 version_major;
+       __le16 version_minor;
+};
+
 #endif /* _FSL_DPMCP_CMD_H */

diff --git a/drivers/staging/fsl-mc/bus/dpmcp.c b/drivers/staging/fsl-mc/bus/dpmcp.c
index fd6dd4e07b8724b26a60585ff6092a75ba8818f3..06440176243ac45165cf0635db9622cc98d7e759 100644 (file)
--- a/drivers/staging/fsl-mc/bus/dpmcp.c
+++ b/drivers/staging/fsl-mc/bus/dpmcp.c
@@ -1,4 +1,4 @@
-/* Copyright 2013-2015 Freescale Semiconductor Inc.
+/* Copyright 2013-2016 Freescale Semiconductor Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -57,12 +57,14 @@ int dpmcp_open(struct fsl_mc_io *mc_io,
               u16 *token)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_cmd_open *cmd_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPMCP_CMDID_OPEN,
                                          cmd_flags, 0);
-       cmd.params[0] |= mc_enc(0, 32, dpmcp_id);
+       cmd_params = (struct dpmcp_cmd_open *)cmd.params;
+       cmd_params->dpmcp_id = cpu_to_le32(dpmcp_id);
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -70,7 +72,7 @@ int dpmcp_open(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
+       *token = mc_cmd_hdr_read_token(&cmd);
 
        return err;
 }
@@ -127,12 +129,15 @@ int dpmcp_create(struct fsl_mc_io *mc_io,
                 u16 *token)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_cmd_create *cmd_params;
+
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CREATE,
                                          cmd_flags, 0);
-       cmd.params[0] |= mc_enc(0, 32, cfg->portal_id);
+       cmd_params = (struct dpmcp_cmd_create *)cmd.params;
+       cmd_params->portal_id = cpu_to_le32(cfg->portal_id);
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -140,7 +145,7 @@ int dpmcp_create(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
+       *token = mc_cmd_hdr_read_token(&cmd);
 
        return 0;
 }
@@ -206,14 +211,16 @@ int dpmcp_set_irq(struct fsl_mc_io *mc_io,
                  struct dpmcp_irq_cfg  *irq_cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_cmd_set_irq *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 8, irq_index);
-       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->irq_num);
+       cmd_params = (struct dpmcp_cmd_set_irq *)cmd.params;
+       cmd_params->irq_index = irq_index;
+       cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
+       cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
+       cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -239,12 +246,15 @@ int dpmcp_get_irq(struct fsl_mc_io *mc_io,
                  struct dpmcp_irq_cfg  *irq_cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_cmd_get_irq *cmd_params;
+       struct dpmcp_rsp_get_irq *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpmcp_cmd_get_irq *)cmd.params;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -252,10 +262,11 @@ int dpmcp_get_irq(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       irq_cfg->val = (u32)mc_dec(cmd.params[0], 0, 32);
-       irq_cfg->paddr = (u64)mc_dec(cmd.params[1], 0, 64);
-       irq_cfg->irq_num = (int)mc_dec(cmd.params[2], 0, 32);
-       *type = (int)mc_dec(cmd.params[2], 32, 32);
+       rsp_params = (struct dpmcp_rsp_get_irq *)cmd.params;
+       irq_cfg->val = le32_to_cpu(rsp_params->irq_val);
+       irq_cfg->paddr = le64_to_cpu(rsp_params->irq_paddr);
+       irq_cfg->irq_num = le32_to_cpu(rsp_params->irq_num);
+       *type = le32_to_cpu(rsp_params->type);
        return 0;
 }
 
@@ -281,12 +292,14 @@ int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io,
                         u8 en)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_cmd_set_irq_enable *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ_ENABLE,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 8, en);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpmcp_cmd_set_irq_enable *)cmd.params;
+       cmd_params->enable = en & DPMCP_ENABLE;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -309,12 +322,15 @@ int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io,
                         u8 *en)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_cmd_get_irq_enable *cmd_params;
+       struct dpmcp_rsp_get_irq_enable *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_ENABLE,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpmcp_cmd_get_irq_enable *)cmd.params;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -322,7 +338,8 @@ int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *en = (u8)mc_dec(cmd.params[0], 0, 8);
+       rsp_params = (struct dpmcp_rsp_get_irq_enable *)cmd.params;
+       *en = rsp_params->enabled & DPMCP_ENABLE;
        return 0;
 }
 
@@ -349,12 +366,15 @@ int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io,
                       u32 mask)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_cmd_set_irq_mask *cmd_params;
+
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ_MASK,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 32, mask);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpmcp_cmd_set_irq_mask *)cmd.params;
+       cmd_params->mask = cpu_to_le32(mask);
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -380,12 +400,16 @@ int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
                       u32 *mask)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_cmd_get_irq_mask *cmd_params;
+       struct dpmcp_rsp_get_irq_mask *rsp_params;
+
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_MASK,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpmcp_cmd_get_irq_mask *)cmd.params;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -393,7 +417,9 @@ int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *mask = (u32)mc_dec(cmd.params[0], 0, 32);
+       rsp_params = (struct dpmcp_rsp_get_irq_mask *)cmd.params;
+       *mask = le32_to_cpu(rsp_params->mask);
+
        return 0;
 }
 
@@ -417,12 +443,16 @@ int dpmcp_get_irq_status(struct fsl_mc_io *mc_io,
                         u32 *status)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_cmd_get_irq_status *cmd_params;
+       struct dpmcp_rsp_get_irq_status *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_STATUS,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dpmcp_cmd_get_irq_status *)cmd.params;
+       cmd_params->status = cpu_to_le32(*status);
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -430,7 +460,9 @@ int dpmcp_get_irq_status(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *status = (u32)mc_dec(cmd.params[0], 0, 32);
+       rsp_params = (struct dpmcp_rsp_get_irq_status *)cmd.params;
+       *status = le32_to_cpu(rsp_params->status);
+
        return 0;
 }
 
@@ -450,6 +482,7 @@ int dpmcp_get_attributes(struct fsl_mc_io *mc_io,
                         struct dpmcp_attr *attr)
 {
        struct mc_command cmd = { 0 };
+       struct dpmcp_rsp_get_attributes *rsp_params;
        int err;
 
        /* prepare command */
@@ -462,8 +495,10 @@ int dpmcp_get_attributes(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       attr->id = (int)mc_dec(cmd.params[0], 32, 32);
-       attr->version.major = (u16)mc_dec(cmd.params[1], 0, 16);
-       attr->version.minor = (u16)mc_dec(cmd.params[1], 16, 16);
+       rsp_params = (struct dpmcp_rsp_get_attributes *)cmd.params;
+       attr->id = le32_to_cpu(rsp_params->id);
+       attr->version.major = le16_to_cpu(rsp_params->version_major);
+       attr->version.minor = le16_to_cpu(rsp_params->version_minor);
+
        return 0;
 }

diff --git a/drivers/staging/fsl-mc/bus/dpmng-cmd.h b/drivers/staging/fsl-mc/bus/dpmng-cmd.h
index ba8cfa9635dd154dbf38b06c53a678fa22888aa7..779bf9c25bc01ebddefe43c73767267a5188a5a5 100644 (file)
--- a/drivers/staging/fsl-mc/bus/dpmng-cmd.h
+++ b/drivers/staging/fsl-mc/bus/dpmng-cmd.h
@@ -1,4 +1,4 @@
-/* Copyright 2013-2014 Freescale Semiconductor Inc.
+/* Copyright 2013-2016 Freescale Semiconductor Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -44,4 +44,14 @@
 #define DPMNG_CMDID_GET_CONT_ID                        0x830
 #define DPMNG_CMDID_GET_VERSION                        0x831
 
+struct dpmng_rsp_get_container_id {
+       __le32 container_id;
+};
+
+struct dpmng_rsp_get_version {
+       __le32 revision;
+       __le32 version_major;
+       __le32 version_minor;
+};
+
 #endif /* __FSL_DPMNG_CMD_H */

diff --git a/drivers/staging/fsl-mc/bus/dpmng.c b/drivers/staging/fsl-mc/bus/dpmng.c
index a31fa9b43768d86b25dfe2b5b82d992d836bf68b..660bbe7ea899b0c52572afc5e3bf342b25085d7d 100644 (file)
--- a/drivers/staging/fsl-mc/bus/dpmng.c
+++ b/drivers/staging/fsl-mc/bus/dpmng.c
@@ -1,4 +1,4 @@
-/* Copyright 2013-2014 Freescale Semiconductor Inc.
+/* Copyright 2013-2016 Freescale Semiconductor Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -48,6 +48,7 @@ int mc_get_version(struct fsl_mc_io *mc_io,
                   struct mc_version *mc_ver_info)
 {
        struct mc_command cmd = { 0 };
+       struct dpmng_rsp_get_version *rsp_params;
        int err;
 
        /* prepare command */
@@ -61,9 +62,10 @@ int mc_get_version(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       mc_ver_info->revision = mc_dec(cmd.params[0], 0, 32);
-       mc_ver_info->major = mc_dec(cmd.params[0], 32, 32);
-       mc_ver_info->minor = mc_dec(cmd.params[1], 0, 32);
+       rsp_params = (struct dpmng_rsp_get_version *)cmd.params;
+       mc_ver_info->revision = le32_to_cpu(rsp_params->revision);
+       mc_ver_info->major = le32_to_cpu(rsp_params->version_major);
+       mc_ver_info->minor = le32_to_cpu(rsp_params->version_minor);
 
        return 0;
 }
@@ -82,6 +84,7 @@ int dpmng_get_container_id(struct fsl_mc_io *mc_io,
                           int *container_id)
 {
        struct mc_command cmd = { 0 };
+       struct dpmng_rsp_get_container_id *rsp_params;
        int err;
 
        /* prepare command */
@@ -95,7 +98,8 @@ int dpmng_get_container_id(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *container_id = mc_dec(cmd.params[0], 0, 32);
+       rsp_params = (struct dpmng_rsp_get_container_id *)cmd.params;
+       *container_id = le32_to_cpu(rsp_params->container_id);
 
        return 0;
 }

diff --git a/drivers/staging/fsl-mc/bus/dprc-cmd.h b/drivers/staging/fsl-mc/bus/dprc-cmd.h
index 9b854fa8e84d6f0665955cb53628a9a9e3a6b5ed..bb127f4a3ae7d0fdd3715aec2c08531d1048c3ec 100644 (file)
--- a/drivers/staging/fsl-mc/bus/dprc-cmd.h
+++ b/drivers/staging/fsl-mc/bus/dprc-cmd.h
@@ -1,4 +1,4 @@
-/* Copyright 2013-2014 Freescale Semiconductor Inc.
+/* Copyright 2013-2016 Freescale Semiconductor Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -84,4 +84,381 @@
 
 #define DPRC_CMDID_GET_CONNECTION              0x16C
 
+struct dprc_cmd_open {
+       __le32 container_id;
+};
+
+struct dprc_cmd_create_container {
+       /* cmd word 0 */
+       __le32 options;
+       __le16 icid;
+       __le16 pad0;
+       /* cmd word 1 */
+       __le32 pad1;
+       __le32 portal_id;
+       /* cmd words 2-3 */
+       u8 label[16];
+};
+
+struct dprc_rsp_create_container {
+       /* response word 0 */
+       __le64 pad0;
+       /* response word 1 */
+       __le32 child_container_id;
+       __le32 pad1;
+       /* response word 2 */
+       __le64 child_portal_addr;
+};
+
+struct dprc_cmd_destroy_container {
+       __le32 child_container_id;
+};
+
+struct dprc_cmd_reset_container {
+       __le32 child_container_id;
+};
+
+struct dprc_cmd_set_irq {
+       /* cmd word 0 */
+       __le32 irq_val;
+       u8 irq_index;
+       u8 pad[3];
+       /* cmd word 1 */
+       __le64 irq_addr;
+       /* cmd word 2 */
+       __le32 irq_num;
+};
+
+struct dprc_cmd_get_irq {
+       __le32 pad;
+       u8 irq_index;
+};
+
+struct dprc_rsp_get_irq {
+       /* response word 0 */
+       __le32 irq_val;
+       __le32 pad;
+       /* response word 1 */
+       __le64 irq_addr;
+       /* response word 2 */
+       __le32 irq_num;
+       __le32 type;
+};
+
+#define DPRC_ENABLE            0x1
+
+struct dprc_cmd_set_irq_enable {
+       u8 enable;
+       u8 pad[3];
+       u8 irq_index;
+};
+
+struct dprc_cmd_get_irq_enable {
+       __le32 pad;
+       u8 irq_index;
+};
+
+struct dprc_rsp_get_irq_enable {
+       u8 enabled;
+};
+
+struct dprc_cmd_set_irq_mask {
+       __le32 mask;
+       u8 irq_index;
+};
+
+struct dprc_cmd_get_irq_mask {
+       __le32 pad;
+       u8 irq_index;
+};
+
+struct dprc_rsp_get_irq_mask {
+       __le32 mask;
+};
+
+struct dprc_cmd_get_irq_status {
+       __le32 status;
+       u8 irq_index;
+};
+
+struct dprc_rsp_get_irq_status {
+       __le32 status;
+};
+
+struct dprc_cmd_clear_irq_status {
+       __le32 status;
+       u8 irq_index;
+};
+
+struct dprc_rsp_get_attributes {
+       /* response word 0 */
+       __le32 container_id;
+       __le16 icid;
+       __le16 pad;
+       /* response word 1 */
+       __le32 options;
+       __le32 portal_id;
+       /* response word 2 */
+       __le16 version_major;
+       __le16 version_minor;
+};
+
+struct dprc_cmd_set_res_quota {
+       /* cmd word 0 */
+       __le32 child_container_id;
+       __le16 quota;
+       __le16 pad;
+       /* cmd words 1-2 */
+       u8 type[16];
+};
+
+struct dprc_cmd_get_res_quota {
+       /* cmd word 0 */
+       __le32 child_container_id;
+       __le32 pad;
+       /* cmd word 1-2 */
+       u8 type[16];
+};
+
+struct dprc_rsp_get_res_quota {
+       __le32 pad;
+       __le16 quota;
+};
+
+struct dprc_cmd_assign {
+       /* cmd word 0 */
+       __le32 container_id;
+       __le32 options;
+       /* cmd word 1 */
+       __le32 num;
+       __le32 id_base_align;
+       /* cmd word 2-3 */
+       u8 type[16];
+};
+
+struct dprc_cmd_unassign {
+       /* cmd word 0 */
+       __le32 child_container_id;
+       __le32 options;
+       /* cmd word 1 */
+       __le32 num;
+       __le32 id_base_align;
+       /* cmd word 2-3 */
+       u8 type[16];
+};
+
+struct dprc_rsp_get_pool_count {
+       __le32 pool_count;
+};
+
+struct dprc_cmd_get_pool {
+       __le32 pool_index;
+};
+
+struct dprc_rsp_get_pool {
+       /* response word 0 */
+       __le64 pad;
+       /* response word 1-2 */
+       u8 type[16];
+};
+
+struct dprc_rsp_get_obj_count {
+       __le32 pad;
+       __le32 obj_count;
+};
+
+struct dprc_cmd_get_obj {
+       __le32 obj_index;
+};
+
+struct dprc_rsp_get_obj {
+       /* response word 0 */
+       __le32 pad0;
+       __le32 id;
+       /* response word 1 */
+       __le16 vendor;
+       u8 irq_count;
+       u8 region_count;
+       __le32 state;
+       /* response word 2 */
+       __le16 version_major;
+       __le16 version_minor;
+       __le16 flags;
+       __le16 pad1;
+       /* response word 3-4 */
+       u8 type[16];
+       /* response word 5-6 */
+       u8 label[16];
+};
+
+struct dprc_cmd_get_obj_desc {
+       /* cmd word 0 */
+       __le32 obj_id;
+       __le32 pad;
+       /* cmd word 1-2 */
+       u8 type[16];
+};
+
+struct dprc_rsp_get_obj_desc {
+       /* response word 0 */
+       __le32 pad0;
+       __le32 id;
+       /* response word 1 */
+       __le16 vendor;
+       u8 irq_count;
+       u8 region_count;
+       __le32 state;
+       /* response word 2 */
+       __le16 version_major;
+       __le16 version_minor;
+       __le16 flags;
+       __le16 pad1;
+       /* response word 3-4 */
+       u8 type[16];
+       /* response word 5-6 */
+       u8 label[16];
+};
+
+struct dprc_cmd_get_res_count {
+       /* cmd word 0 */
+       __le64 pad;
+       /* cmd word 1-2 */
+       u8 type[16];
+};
+
+struct dprc_rsp_get_res_count {
+       __le32 res_count;
+};
+
+struct dprc_cmd_get_res_ids {
+       /* cmd word 0 */
+       u8 pad0[5];
+       u8 iter_status;
+       __le16 pad1;
+       /* cmd word 1 */
+       __le32 base_id;
+       __le32 last_id;
+       /* cmd word 2-3 */
+       u8 type[16];
+};
+
+struct dprc_rsp_get_res_ids {
+       /* response word 0 */
+       u8 pad0[5];
+       u8 iter_status;
+       __le16 pad1;
+       /* response word 1 */
+       __le32 base_id;
+       __le32 last_id;
+};
+
+struct dprc_cmd_get_obj_region {
+       /* cmd word 0 */
+       __le32 obj_id;
+       __le16 pad0;
+       u8 region_index;
+       u8 pad1;
+       /* cmd word 1-2 */
+       __le64 pad2[2];
+       /* cmd word 3-4 */
+       u8 obj_type[16];
+};
+
+struct dprc_rsp_get_obj_region {
+       /* response word 0 */
+       __le64 pad;
+       /* response word 1 */
+       __le64 base_addr;
+       /* response word 2 */
+       __le32 size;
+};
+
+struct dprc_cmd_set_obj_label {
+       /* cmd word 0 */
+       __le32 obj_id;
+       __le32 pad;
+       /* cmd word 1-2 */
+       u8 label[16];
+       /* cmd word 3-4 */
+       u8 obj_type[16];
+};
+
+struct dprc_cmd_set_obj_irq {
+       /* cmd word 0 */
+       __le32 irq_val;
+       u8 irq_index;
+       u8 pad[3];
+       /* cmd word 1 */
+       __le64 irq_addr;
+       /* cmd word 2 */
+       __le32 irq_num;
+       __le32 obj_id;
+       /* cmd word 3-4 */
+       u8 obj_type[16];
+};
+
+struct dprc_cmd_get_obj_irq {
+       /* cmd word 0 */
+       __le32 obj_id;
+       u8 irq_index;
+       u8 pad[3];
+       /* cmd word 1-2 */
+       u8 obj_type[16];
+};
+
+struct dprc_rsp_get_obj_irq {
+       /* response word 0 */
+       __le32 irq_val;
+       __le32 pad;
+       /* response word 1 */
+       __le64 irq_addr;
+       /* response word 2 */
+       __le32 irq_num;
+       __le32 type;
+};
+
+struct dprc_cmd_connect {
+       /* cmd word 0 */
+       __le32 ep1_id;
+       __le32 ep1_interface_id;
+       /* cmd word 1 */
+       __le32 ep2_id;
+       __le32 ep2_interface_id;
+       /* cmd word 2-3 */
+       u8 ep1_type[16];
+       /* cmd word 4 */
+       __le32 max_rate;
+       __le32 committed_rate;
+       /* cmd word 5-6 */
+       u8 ep2_type[16];
+};
+
+struct dprc_cmd_disconnect {
+       /* cmd word 0 */
+       __le32 id;
+       __le32 interface_id;
+       /* cmd word 1-2 */
+       u8 type[16];
+};
+
+struct dprc_cmd_get_connection {
+       /* cmd word 0 */
+       __le32 ep1_id;
+       __le32 ep1_interface_id;
+       /* cmd word 1-2 */
+       u8 ep1_type[16];
+};
+
+struct dprc_rsp_get_connection {
+       /* response word 0-2 */
+       __le64 pad[3];
+       /* response word 3 */
+       __le32 ep2_id;
+       __le32 ep2_interface_id;
+       /* response word 4-5 */
+       u8 ep2_type[16];
+       /* response word 6 */
+       __le32 state;
+};
+
 #endif /* _FSL_DPRC_CMD_H */

diff --git a/drivers/staging/fsl-mc/bus/dprc.c b/drivers/staging/fsl-mc/bus/dprc.c
index a2c47377cc4e2d3bccd64510b4e543dbd823e293..c260549813335888c5f8005c5c3d5d3a6cc0ca0c 100644 (file)
--- a/drivers/staging/fsl-mc/bus/dprc.c
+++ b/drivers/staging/fsl-mc/bus/dprc.c
@@ -1,4 +1,4 @@
-/* Copyright 2013-2014 Freescale Semiconductor Inc.
+/* Copyright 2013-2016 Freescale Semiconductor Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -51,12 +51,14 @@ int dprc_open(struct fsl_mc_io *mc_io,
              u16 *token)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_open *cmd_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, cmd_flags,
                                          0);
-       cmd.params[0] |= mc_enc(0, 32, container_id);
+       cmd_params = (struct dprc_cmd_open *)cmd.params;
+       cmd_params->container_id = cpu_to_le32(container_id);
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -64,7 +66,7 @@ int dprc_open(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
+       *token = mc_cmd_hdr_read_token(&cmd);
 
        return 0;
 }
@@ -115,28 +117,17 @@ int dprc_create_container(struct fsl_mc_io *mc_io,
                          u64 *child_portal_offset)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_create_container *cmd_params;
+       struct dprc_rsp_create_container *rsp_params;
        int err;
 
        /* prepare command */
-       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_params = (struct dprc_cmd_create_container *)cmd.params;
+       cmd_params->options = cpu_to_le32(cfg->options);
+       cmd_params->icid = cpu_to_le16(cfg->icid);
+       cmd_params->portal_id = cpu_to_le32(cfg->portal_id);
+       strncpy(cmd_params->label, cfg->label, 16);
+       cmd_params->label[15] = '\0';
 
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_CREATE_CONT,
                                          cmd_flags, token);
@@ -147,8 +138,9 @@ int dprc_create_container(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *child_container_id = mc_dec(cmd.params[1], 0, 32);
-       *child_portal_offset = mc_dec(cmd.params[2], 0, 64);
+       rsp_params = (struct dprc_rsp_create_container *)cmd.params;
+       *child_container_id = le32_to_cpu(rsp_params->child_container_id);
+       *child_portal_offset = le64_to_cpu(rsp_params->child_portal_addr);
 
        return 0;
 }
@@ -181,11 +173,13 @@ int dprc_destroy_container(struct fsl_mc_io *mc_io,
                           int child_container_id)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_destroy_container *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_DESTROY_CONT,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 32, child_container_id);
+       cmd_params = (struct dprc_cmd_destroy_container *)cmd.params;
+       cmd_params->child_container_id = cpu_to_le32(child_container_id);
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -219,11 +213,13 @@ int dprc_reset_container(struct fsl_mc_io *mc_io,
                         int child_container_id)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_reset_container *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_RESET_CONT,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 32, child_container_id);
+       cmd_params = (struct dprc_cmd_reset_container *)cmd.params;
+       cmd_params->child_container_id = cpu_to_le32(child_container_id);
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -249,13 +245,16 @@ int dprc_get_irq(struct fsl_mc_io *mc_io,
                 struct dprc_irq_cfg *irq_cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_irq *cmd_params;
+       struct dprc_rsp_get_irq *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ,
                                          cmd_flags,
                                          token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dprc_cmd_get_irq *)cmd.params;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -263,10 +262,11 @@ int dprc_get_irq(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       irq_cfg->val = mc_dec(cmd.params[0], 0, 32);
-       irq_cfg->paddr = mc_dec(cmd.params[1], 0, 64);
-       irq_cfg->irq_num = mc_dec(cmd.params[2], 0, 32);
-       *type = mc_dec(cmd.params[2], 32, 32);
+       rsp_params = (struct dprc_rsp_get_irq *)cmd.params;
+       irq_cfg->val = le32_to_cpu(rsp_params->irq_val);
+       irq_cfg->paddr = le64_to_cpu(rsp_params->irq_addr);
+       irq_cfg->irq_num = le32_to_cpu(rsp_params->irq_num);
+       *type = le32_to_cpu(rsp_params->type);
 
        return 0;
 }
@@ -288,15 +288,17 @@ int dprc_set_irq(struct fsl_mc_io *mc_io,
                 struct dprc_irq_cfg *irq_cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_set_irq *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_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->irq_num);
+       cmd_params = (struct dprc_cmd_set_irq *)cmd.params;
+       cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
+       cmd_params->irq_index = irq_index;
+       cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
+       cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -319,12 +321,15 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io,
                        u8 *en)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_irq_enable *cmd_params;
+       struct dprc_rsp_get_irq_enable *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_ENABLE,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dprc_cmd_get_irq_enable *)cmd.params;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -332,7 +337,8 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *en = mc_dec(cmd.params[0], 0, 8);
+       rsp_params = (struct dprc_rsp_get_irq_enable *)cmd.params;
+       *en = rsp_params->enabled & DPRC_ENABLE;
 
        return 0;
 }
@@ -359,12 +365,14 @@ int dprc_set_irq_enable(struct fsl_mc_io *mc_io,
                        u8 en)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_set_irq_enable *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_ENABLE,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 8, en);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dprc_cmd_set_irq_enable *)cmd.params;
+       cmd_params->enable = en & DPRC_ENABLE;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -390,12 +398,15 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io,
                      u32 *mask)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_irq_mask *cmd_params;
+       struct dprc_rsp_get_irq_mask *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_MASK,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dprc_cmd_get_irq_mask *)cmd.params;
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -403,7 +414,8 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *mask = mc_dec(cmd.params[0], 0, 32);
+       rsp_params = (struct dprc_rsp_get_irq_mask *)cmd.params;
+       *mask = le32_to_cpu(rsp_params->mask);
 
        return 0;
 }
@@ -431,12 +443,14 @@ int dprc_set_irq_mask(struct fsl_mc_io *mc_io,
                      u32 mask)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_set_irq_mask *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_MASK,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 32, mask);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dprc_cmd_set_irq_mask *)cmd.params;
+       cmd_params->mask = cpu_to_le32(mask);
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -461,13 +475,16 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io,
                        u32 *status)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_irq_status *cmd_params;
+       struct dprc_rsp_get_irq_status *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_STATUS,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 32, *status);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dprc_cmd_get_irq_status *)cmd.params;
+       cmd_params->status = cpu_to_le32(*status);
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -475,7 +492,8 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *status = mc_dec(cmd.params[0], 0, 32);
+       rsp_params = (struct dprc_rsp_get_irq_status *)cmd.params;
+       *status = le32_to_cpu(rsp_params->status);
 
        return 0;
 }
@@ -499,12 +517,14 @@ int dprc_clear_irq_status(struct fsl_mc_io *mc_io,
                          u32 status)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_clear_irq_status *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLEAR_IRQ_STATUS,
                                          cmd_flags, token);
-       cmd.params[0] |= mc_enc(0, 32, status);
-       cmd.params[0] |= mc_enc(32, 8, irq_index);
+       cmd_params = (struct dprc_cmd_clear_irq_status *)cmd.params;
+       cmd_params->status = cpu_to_le32(status);
+       cmd_params->irq_index = irq_index;
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -525,6 +545,7 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io,
                        struct dprc_attributes *attr)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_rsp_get_attributes *rsp_params;
        int err;
 
        /* prepare command */
@@ -538,12 +559,13 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       attr->container_id = mc_dec(cmd.params[0], 0, 32);
-       attr->icid = mc_dec(cmd.params[0], 32, 16);
-       attr->options = mc_dec(cmd.params[1], 0, 32);
-       attr->portal_id = mc_dec(cmd.params[1], 32, 32);
-       attr->version.major = mc_dec(cmd.params[2], 0, 16);
-       attr->version.minor = mc_dec(cmd.params[2], 16, 16);
+       rsp_params = (struct dprc_rsp_get_attributes *)cmd.params;
+       attr->container_id = le32_to_cpu(rsp_params->container_id);
+       attr->icid = le16_to_cpu(rsp_params->icid);
+       attr->options = le32_to_cpu(rsp_params->options);
+       attr->portal_id = le32_to_cpu(rsp_params->portal_id);
+       attr->version.major = le16_to_cpu(rsp_params->version_major);
+       attr->version.minor = le16_to_cpu(rsp_params->version_minor);
 
        return 0;
 }
@@ -581,28 +603,16 @@ int dprc_set_res_quota(struct fsl_mc_io *mc_io,
                       u16 quota)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_set_res_quota *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_RES_QUOTA,
                                          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]);
-       cmd.params[1] |= mc_enc(8, 8, type[1]);
-       cmd.params[1] |= mc_enc(16, 8, type[2]);
-       cmd.params[1] |= mc_enc(24, 8, type[3]);
-       cmd.params[1] |= mc_enc(32, 8, type[4]);
-       cmd.params[1] |= mc_enc(40, 8, type[5]);
-       cmd.params[1] |= mc_enc(48, 8, type[6]);
-       cmd.params[1] |= mc_enc(56, 8, type[7]);
-       cmd.params[2] |= mc_enc(0, 8, type[8]);
-       cmd.params[2] |= mc_enc(8, 8, type[9]);
-       cmd.params[2] |= mc_enc(16, 8, type[10]);
-       cmd.params[2] |= mc_enc(24, 8, type[11]);
-       cmd.params[2] |= mc_enc(32, 8, type[12]);
-       cmd.params[2] |= mc_enc(40, 8, type[13]);
-       cmd.params[2] |= mc_enc(48, 8, type[14]);
-       cmd.params[2] |= mc_enc(56, 8, '\0');
+       cmd_params = (struct dprc_cmd_set_res_quota *)cmd.params;
+       cmd_params->child_container_id = cpu_to_le32(child_container_id);
+       cmd_params->quota = cpu_to_le16(quota);
+       strncpy(cmd_params->type, type, 16);
+       cmd_params->type[15] = '\0';
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -631,28 +641,17 @@ int dprc_get_res_quota(struct fsl_mc_io *mc_io,
                       u16 *quota)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_res_quota *cmd_params;
+       struct dprc_rsp_get_res_quota *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_QUOTA,
                                          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]);
-       cmd.params[1] |= mc_enc(16, 8, type[2]);
-       cmd.params[1] |= mc_enc(24, 8, type[3]);
-       cmd.params[1] |= mc_enc(32, 8, type[4]);
-       cmd.params[1] |= mc_enc(40, 8, type[5]);
-       cmd.params[1] |= mc_enc(48, 8, type[6]);
-       cmd.params[1] |= mc_enc(56, 8, type[7]);
-       cmd.params[2] |= mc_enc(0, 8, type[8]);
-       cmd.params[2] |= mc_enc(8, 8, type[9]);
-       cmd.params[2] |= mc_enc(16, 8, type[10]);
-       cmd.params[2] |= mc_enc(24, 8, type[11]);
-       cmd.params[2] |= mc_enc(32, 8, type[12]);
-       cmd.params[2] |= mc_enc(40, 8, type[13]);
-       cmd.params[2] |= mc_enc(48, 8, type[14]);
-       cmd.params[2] |= mc_enc(56, 8, '\0');
+       cmd_params = (struct dprc_cmd_get_res_quota *)cmd.params;
+       cmd_params->child_container_id = cpu_to_le32(child_container_id);
+       strncpy(cmd_params->type, type, 16);
+       cmd_params->type[15] = '\0';
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -660,7 +659,8 @@ int dprc_get_res_quota(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *quota = mc_dec(cmd.params[0], 32, 16);
+       rsp_params = (struct dprc_rsp_get_res_quota *)cmd.params;
+       *quota = le16_to_cpu(rsp_params->quota);
 
        return 0;
 }
@@ -704,30 +704,18 @@ int dprc_assign(struct fsl_mc_io *mc_io,
                struct dprc_res_req *res_req)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_assign *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_ASSIGN,
                                          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);
-       cmd.params[1] |= mc_enc(32, 32, res_req->id_base_align);
-       cmd.params[2] |= mc_enc(0, 8, res_req->type[0]);
-       cmd.params[2] |= mc_enc(8, 8, res_req->type[1]);
-       cmd.params[2] |= mc_enc(16, 8, res_req->type[2]);
-       cmd.params[2] |= mc_enc(24, 8, res_req->type[3]);
-       cmd.params[2] |= mc_enc(32, 8, res_req->type[4]);
-       cmd.params[2] |= mc_enc(40, 8, res_req->type[5]);
-       cmd.params[2] |= mc_enc(48, 8, res_req->type[6]);
-       cmd.params[2] |= mc_enc(56, 8, res_req->type[7]);
-       cmd.params[3] |= mc_enc(0, 8, res_req->type[8]);
-       cmd.params[3] |= mc_enc(8, 8, res_req->type[9]);
-       cmd.params[3] |= mc_enc(16, 8, res_req->type[10]);
-       cmd.params[3] |= mc_enc(24, 8, res_req->type[11]);
-       cmd.params[3] |= mc_enc(32, 8, res_req->type[12]);
-       cmd.params[3] |= mc_enc(40, 8, res_req->type[13]);
-       cmd.params[3] |= mc_enc(48, 8, res_req->type[14]);
-       cmd.params[3] |= mc_enc(56, 8, res_req->type[15]);
+       cmd_params = (struct dprc_cmd_assign *)cmd.params;
+       cmd_params->container_id = cpu_to_le32(container_id);
+       cmd_params->options = cpu_to_le32(res_req->options);
+       cmd_params->num = cpu_to_le32(res_req->num);
+       cmd_params->id_base_align = cpu_to_le32(res_req->id_base_align);
+       strncpy(cmd_params->type, res_req->type, 16);
+       cmd_params->type[15] = '\0';
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -755,31 +743,19 @@ int dprc_unassign(struct fsl_mc_io *mc_io,
                  struct dprc_res_req *res_req)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_unassign *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_UNASSIGN,
                                          cmd_flags,
                                          token);
-       cmd.params[0] |= mc_enc(0, 32, child_container_id);
-       cmd.params[0] |= mc_enc(32, 32, res_req->options);
-       cmd.params[1] |= mc_enc(0, 32, res_req->num);
-       cmd.params[1] |= mc_enc(32, 32, res_req->id_base_align);
-       cmd.params[2] |= mc_enc(0, 8, res_req->type[0]);
-       cmd.params[2] |= mc_enc(8, 8, res_req->type[1]);
-       cmd.params[2] |= mc_enc(16, 8, res_req->type[2]);
-       cmd.params[2] |= mc_enc(24, 8, res_req->type[3]);
-       cmd.params[2] |= mc_enc(32, 8, res_req->type[4]);
-       cmd.params[2] |= mc_enc(40, 8, res_req->type[5]);
-       cmd.params[2] |= mc_enc(48, 8, res_req->type[6]);
-       cmd.params[2] |= mc_enc(56, 8, res_req->type[7]);
-       cmd.params[3] |= mc_enc(0, 8, res_req->type[8]);
-       cmd.params[3] |= mc_enc(8, 8, res_req->type[9]);
-       cmd.params[3] |= mc_enc(16, 8, res_req->type[10]);
-       cmd.params[3] |= mc_enc(24, 8, res_req->type[11]);
-       cmd.params[3] |= mc_enc(32, 8, res_req->type[12]);
-       cmd.params[3] |= mc_enc(40, 8, res_req->type[13]);
-       cmd.params[3] |= mc_enc(48, 8, res_req->type[14]);
-       cmd.params[3] |= mc_enc(56, 8, res_req->type[15]);
+       cmd_params = (struct dprc_cmd_unassign *)cmd.params;
+       cmd_params->child_container_id = cpu_to_le32(child_container_id);
+       cmd_params->options = cpu_to_le32(res_req->options);
+       cmd_params->num = cpu_to_le32(res_req->num);
+       cmd_params->id_base_align = cpu_to_le32(res_req->id_base_align);
+       strncpy(cmd_params->type, res_req->type, 16);
+       cmd_params->type[15] = '\0';
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -800,6 +776,7 @@ int dprc_get_pool_count(struct fsl_mc_io *mc_io,
                        int *pool_count)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_rsp_get_pool_count *rsp_params;
        int err;
 
        /* prepare command */
@@ -812,7 +789,8 @@ int dprc_get_pool_count(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *pool_count = mc_dec(cmd.params[0], 0, 32);
+       rsp_params = (struct dprc_rsp_get_pool_count *)cmd.params;
+       *pool_count = le32_to_cpu(rsp_params->pool_count);
 
        return 0;
 }
@@ -839,13 +817,16 @@ int dprc_get_pool(struct fsl_mc_io *mc_io,
                  char *type)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_pool *cmd_params;
+       struct dprc_rsp_get_pool *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_POOL,
                                          cmd_flags,
                                          token);
-       cmd.params[0] |= mc_enc(0, 32, pool_index);
+       cmd_params = (struct dprc_cmd_get_pool *)cmd.params;
+       cmd_params->pool_index = cpu_to_le32(pool_index);
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -853,21 +834,8 @@ int dprc_get_pool(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       type[0] = mc_dec(cmd.params[1], 0, 8);
-       type[1] = mc_dec(cmd.params[1], 8, 8);
-       type[2] = mc_dec(cmd.params[1], 16, 8);
-       type[3] = mc_dec(cmd.params[1], 24, 8);
-       type[4] = mc_dec(cmd.params[1], 32, 8);
-       type[5] = mc_dec(cmd.params[1], 40, 8);
-       type[6] = mc_dec(cmd.params[1], 48, 8);
-       type[7] = mc_dec(cmd.params[1], 56, 8);
-       type[8] = mc_dec(cmd.params[2], 0, 8);
-       type[9] = mc_dec(cmd.params[2], 8, 8);
-       type[10] = mc_dec(cmd.params[2], 16, 8);
-       type[11] = mc_dec(cmd.params[2], 24, 8);
-       type[12] = mc_dec(cmd.params[2], 32, 8);
-       type[13] = mc_dec(cmd.params[2], 40, 8);
-       type[14] = mc_dec(cmd.params[2], 48, 8);
+       rsp_params = (struct dprc_rsp_get_pool *)cmd.params;
+       strncpy(type, rsp_params->type, 16);
        type[15] = '\0';
 
        return 0;
@@ -888,6 +856,7 @@ int dprc_get_obj_count(struct fsl_mc_io *mc_io,
                       int *obj_count)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_rsp_get_obj_count *rsp_params;
        int err;
 
        /* prepare command */
@@ -900,7 +869,8 @@ int dprc_get_obj_count(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *obj_count = mc_dec(cmd.params[0], 32, 32);
+       rsp_params = (struct dprc_rsp_get_obj_count *)cmd.params;
+       *obj_count = le32_to_cpu(rsp_params->obj_count);
 
        return 0;
 }
@@ -928,13 +898,16 @@ int dprc_get_obj(struct fsl_mc_io *mc_io,
                 struct dprc_obj_desc *obj_desc)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_obj *cmd_params;
+       struct dprc_rsp_get_obj *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ,
                                          cmd_flags,
                                          token);
-       cmd.params[0] |= mc_enc(0, 32, obj_index);
+       cmd_params = (struct dprc_cmd_get_obj *)cmd.params;
+       cmd_params->obj_index = cpu_to_le32(obj_index);
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -942,45 +915,18 @@ int dprc_get_obj(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       obj_desc->id = mc_dec(cmd.params[0], 32, 32);
-       obj_desc->vendor = mc_dec(cmd.params[1], 0, 16);
-       obj_desc->irq_count = mc_dec(cmd.params[1], 16, 8);
-       obj_desc->region_count = mc_dec(cmd.params[1], 24, 8);
-       obj_desc->state = mc_dec(cmd.params[1], 32, 32);
-       obj_desc->ver_major = mc_dec(cmd.params[2], 0, 16);
-       obj_desc->ver_minor = mc_dec(cmd.params[2], 16, 16);
-       obj_desc->flags = mc_dec(cmd.params[2], 32, 16);
-       obj_desc->type[0] = mc_dec(cmd.params[3], 0, 8);
-       obj_desc->type[1] = mc_dec(cmd.params[3], 8, 8);
-       obj_desc->type[2] = mc_dec(cmd.params[3], 16, 8);
-       obj_desc->type[3] = mc_dec(cmd.params[3], 24, 8);
-       obj_desc->type[4] = mc_dec(cmd.params[3], 32, 8);
-       obj_desc->type[5] = mc_dec(cmd.params[3], 40, 8);
-       obj_desc->type[6] = mc_dec(cmd.params[3], 48, 8);
-       obj_desc->type[7] = mc_dec(cmd.params[3], 56, 8);
-       obj_desc->type[8] = mc_dec(cmd.params[4], 0, 8);
-       obj_desc->type[9] = mc_dec(cmd.params[4], 8, 8);
-       obj_desc->type[10] = mc_dec(cmd.params[4], 16, 8);
-       obj_desc->type[11] = mc_dec(cmd.params[4], 24, 8);
-       obj_desc->type[12] = mc_dec(cmd.params[4], 32, 8);
-       obj_desc->type[13] = mc_dec(cmd.params[4], 40, 8);
-       obj_desc->type[14] = mc_dec(cmd.params[4], 48, 8);
+       rsp_params = (struct dprc_rsp_get_obj *)cmd.params;
+       obj_desc->id = le32_to_cpu(rsp_params->id);
+       obj_desc->vendor = le16_to_cpu(rsp_params->vendor);
+       obj_desc->irq_count = rsp_params->irq_count;
+       obj_desc->region_count = rsp_params->region_count;
+       obj_desc->state = le32_to_cpu(rsp_params->state);
+       obj_desc->ver_major = le16_to_cpu(rsp_params->version_major);
+       obj_desc->ver_minor = le16_to_cpu(rsp_params->version_minor);
+       obj_desc->flags = le16_to_cpu(rsp_params->flags);
+       strncpy(obj_desc->type, rsp_params->type, 16);
        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);
+       strncpy(obj_desc->label, rsp_params->label, 16);
        obj_desc->label[15] = '\0';
        return 0;
 }
@@ -1007,29 +953,18 @@ int dprc_get_obj_desc(struct fsl_mc_io *mc_io,
                      struct dprc_obj_desc *obj_desc)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_obj_desc *cmd_params;
+       struct dprc_rsp_get_obj_desc *rsp_params;
        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]);
+       cmd_params = (struct dprc_cmd_get_obj_desc *)cmd.params;
+       cmd_params->obj_id = cpu_to_le32(obj_id);
+       strncpy(cmd_params->type, obj_type, 16);
+       cmd_params->type[15] = '\0';
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -1037,46 +972,19 @@ int dprc_get_obj_desc(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       obj_desc->id = (int)mc_dec(cmd.params[0], 32, 32);
-       obj_desc->vendor = (u16)mc_dec(cmd.params[1], 0, 16);
-       obj_desc->vendor = (u8)mc_dec(cmd.params[1], 16, 8);
-       obj_desc->region_count = (u8)mc_dec(cmd.params[1], 24, 8);
-       obj_desc->state = (u32)mc_dec(cmd.params[1], 32, 32);
-       obj_desc->ver_major = (u16)mc_dec(cmd.params[2], 0, 16);
-       obj_desc->ver_minor = (u16)mc_dec(cmd.params[2], 16, 16);
-       obj_desc->flags = mc_dec(cmd.params[2], 32, 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);
+       rsp_params = (struct dprc_rsp_get_obj_desc *)cmd.params;
+       obj_desc->id = le32_to_cpu(rsp_params->id);
+       obj_desc->vendor = le16_to_cpu(rsp_params->vendor);
+       obj_desc->irq_count = rsp_params->irq_count;
+       obj_desc->region_count = rsp_params->region_count;
+       obj_desc->state = le32_to_cpu(rsp_params->state);
+       obj_desc->ver_major = le16_to_cpu(rsp_params->version_major);
+       obj_desc->ver_minor = le16_to_cpu(rsp_params->version_minor);
+       obj_desc->flags = le16_to_cpu(rsp_params->flags);
+       strncpy(obj_desc->type, rsp_params->type, 16);
+       obj_desc->type[15] = '\0';
+       strncpy(obj_desc->label, rsp_params->label, 16);
+       obj_desc->label[15] = '\0';
 
        return 0;
 }
@@ -1103,32 +1011,20 @@ int dprc_set_obj_irq(struct fsl_mc_io *mc_io,
                     struct dprc_irq_cfg *irq_cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_set_obj_irq *cmd_params;
 
        /* 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->irq_num);
-       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]);
+       cmd_params = (struct dprc_cmd_set_obj_irq *)cmd.params;
+       cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
+       cmd_params->irq_index = irq_index;
+       cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
+       cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
+       cmd_params->obj_id = cpu_to_le32(obj_id);
+       strncpy(cmd_params->obj_type, obj_type, 16);
+       cmd_params->obj_type[15] = '\0';
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -1159,30 +1055,19 @@ int dprc_get_obj_irq(struct fsl_mc_io *mc_io,
                     struct dprc_irq_cfg *irq_cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_obj_irq *cmd_params;
+       struct dprc_rsp_get_obj_irq *rsp_params;
        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]);
+       cmd_params = (struct dprc_cmd_get_obj_irq *)cmd.params;
+       cmd_params->obj_id = cpu_to_le32(obj_id);
+       cmd_params->irq_index = irq_index;
+       strncpy(cmd_params->obj_type, obj_type, 16);
+       cmd_params->obj_type[15] = '\0';
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -1190,10 +1075,11 @@ int dprc_get_obj_irq(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       irq_cfg->val = (u32)mc_dec(cmd.params[0], 0, 32);
-       irq_cfg->paddr = (u64)mc_dec(cmd.params[1], 0, 64);
-       irq_cfg->irq_num = (int)mc_dec(cmd.params[2], 0, 32);
-       *type = (int)mc_dec(cmd.params[2], 32, 32);
+       rsp_params = (struct dprc_rsp_get_obj_irq *)cmd.params;
+       irq_cfg->val = le32_to_cpu(rsp_params->irq_val);
+       irq_cfg->paddr = le64_to_cpu(rsp_params->irq_addr);
+       irq_cfg->irq_num = le32_to_cpu(rsp_params->irq_num);
+       *type = le32_to_cpu(rsp_params->type);
 
        return 0;
 }
@@ -1218,29 +1104,16 @@ int dprc_get_res_count(struct fsl_mc_io *mc_io,
                       int *res_count)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_res_count *cmd_params;
+       struct dprc_rsp_get_res_count *rsp_params;
        int err;
 
-       *res_count = 0;
-
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_COUNT,
                                          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]);
-       cmd.params[1] |= mc_enc(24, 8, type[3]);
-       cmd.params[1] |= mc_enc(32, 8, type[4]);
-       cmd.params[1] |= mc_enc(40, 8, type[5]);
-       cmd.params[1] |= mc_enc(48, 8, type[6]);
-       cmd.params[1] |= mc_enc(56, 8, type[7]);
-       cmd.params[2] |= mc_enc(0, 8, type[8]);
-       cmd.params[2] |= mc_enc(8, 8, type[9]);
-       cmd.params[2] |= mc_enc(16, 8, type[10]);
-       cmd.params[2] |= mc_enc(24, 8, type[11]);
-       cmd.params[2] |= mc_enc(32, 8, type[12]);
-       cmd.params[2] |= mc_enc(40, 8, type[13]);
-       cmd.params[2] |= mc_enc(48, 8, type[14]);
-       cmd.params[2] |= mc_enc(56, 8, '\0');
+       cmd_params = (struct dprc_cmd_get_res_count *)cmd.params;
+       strncpy(cmd_params->type, type, 16);
+       cmd_params->type[15] = '\0';
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -1248,7 +1121,8 @@ int dprc_get_res_count(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       *res_count = mc_dec(cmd.params[0], 0, 32);
+       rsp_params = (struct dprc_rsp_get_res_count *)cmd.params;
+       *res_count = le32_to_cpu(rsp_params->res_count);
 
        return 0;
 }
@@ -1271,30 +1145,19 @@ int dprc_get_res_ids(struct fsl_mc_io *mc_io,
                     struct dprc_res_ids_range_desc *range_desc)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_res_ids *cmd_params;
+       struct dprc_rsp_get_res_ids *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_IDS,
                                          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);
-       cmd.params[2] |= mc_enc(0, 8, type[0]);
-       cmd.params[2] |= mc_enc(8, 8, type[1]);
-       cmd.params[2] |= mc_enc(16, 8, type[2]);
-       cmd.params[2] |= mc_enc(24, 8, type[3]);
-       cmd.params[2] |= mc_enc(32, 8, type[4]);
-       cmd.params[2] |= mc_enc(40, 8, type[5]);
-       cmd.params[2] |= mc_enc(48, 8, type[6]);
-       cmd.params[2] |= mc_enc(56, 8, type[7]);
-       cmd.params[3] |= mc_enc(0, 8, type[8]);
-       cmd.params[3] |= mc_enc(8, 8, type[9]);
-       cmd.params[3] |= mc_enc(16, 8, type[10]);
-       cmd.params[3] |= mc_enc(24, 8, type[11]);
-       cmd.params[3] |= mc_enc(32, 8, type[12]);
-       cmd.params[3] |= mc_enc(40, 8, type[13]);
-       cmd.params[3] |= mc_enc(48, 8, type[14]);
-       cmd.params[3] |= mc_enc(56, 8, '\0');
+       cmd_params = (struct dprc_cmd_get_res_ids *)cmd.params;
+       cmd_params->iter_status = range_desc->iter_status;
+       cmd_params->base_id = cpu_to_le32(range_desc->base_id);
+       cmd_params->last_id = cpu_to_le32(range_desc->last_id);
+       strncpy(cmd_params->type, type, 16);
+       cmd_params->type[15] = '\0';
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -1302,9 +1165,10 @@ int dprc_get_res_ids(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       range_desc->iter_status = mc_dec(cmd.params[0], 42, 7);
-       range_desc->base_id = mc_dec(cmd.params[1], 0, 32);
-       range_desc->last_id = mc_dec(cmd.params[1], 32, 32);
+       rsp_params = (struct dprc_rsp_get_res_ids *)cmd.params;
+       range_desc->iter_status = rsp_params->iter_status;
+       range_desc->base_id = le32_to_cpu(rsp_params->base_id);
+       range_desc->last_id = le32_to_cpu(rsp_params->last_id);
 
        return 0;
 }
@@ -1331,29 +1195,18 @@ int dprc_get_obj_region(struct fsl_mc_io *mc_io,
                        struct dprc_region_desc *region_desc)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_obj_region *cmd_params;
+       struct dprc_rsp_get_obj_region *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
                                          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]);
-       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, '\0');
+       cmd_params = (struct dprc_cmd_get_obj_region *)cmd.params;
+       cmd_params->obj_id = cpu_to_le32(obj_id);
+       cmd_params->region_index = region_index;
+       strncpy(cmd_params->obj_type, obj_type, 16);
+       cmd_params->obj_type[15] = '\0';
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -1361,8 +1214,9 @@ int dprc_get_obj_region(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       region_desc->base_offset = mc_dec(cmd.params[1], 0, 64);
-       region_desc->size = mc_dec(cmd.params[2], 0, 32);
+       rsp_params = (struct dprc_rsp_get_obj_region *)cmd.params;
+       region_desc->base_offset = le64_to_cpu(rsp_params->base_addr);
+       region_desc->size = le32_to_cpu(rsp_params->size);
 
        return 0;
 }
@@ -1387,45 +1241,18 @@ int dprc_set_obj_label(struct fsl_mc_io *mc_io,
                       char *label)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_set_obj_label *cmd_params;
 
        /* 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]);
+       cmd_params = (struct dprc_cmd_set_obj_label *)cmd.params;
+       cmd_params->obj_id = cpu_to_le32(obj_id);
+       strncpy(cmd_params->label, label, 16);
+       cmd_params->label[15] = '\0';
+       strncpy(cmd_params->obj_type, obj_type, 16);
+       cmd_params->obj_type[15] = '\0';
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -1453,49 +1280,23 @@ int dprc_connect(struct fsl_mc_io *mc_io,
                 const struct dprc_connection_cfg *cfg)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_connect *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_CONNECT,
                                          cmd_flags,
                                          token);
-       cmd.params[0] |= mc_enc(0, 32, endpoint1->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->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]);
-       cmd.params[2] |= mc_enc(24, 8, endpoint1->type[3]);
-       cmd.params[2] |= mc_enc(32, 8, endpoint1->type[4]);
-       cmd.params[2] |= mc_enc(40, 8, endpoint1->type[5]);
-       cmd.params[2] |= mc_enc(48, 8, endpoint1->type[6]);
-       cmd.params[2] |= mc_enc(56, 8, endpoint1->type[7]);
-       cmd.params[3] |= mc_enc(0, 8, endpoint1->type[8]);
-       cmd.params[3] |= mc_enc(8, 8, endpoint1->type[9]);
-       cmd.params[3] |= mc_enc(16, 8, endpoint1->type[10]);
-       cmd.params[3] |= mc_enc(24, 8, endpoint1->type[11]);
-       cmd.params[3] |= mc_enc(32, 8, endpoint1->type[12]);
-       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]);
-       cmd.params[5] |= mc_enc(24, 8, endpoint2->type[3]);
-       cmd.params[5] |= mc_enc(32, 8, endpoint2->type[4]);
-       cmd.params[5] |= mc_enc(40, 8, endpoint2->type[5]);
-       cmd.params[5] |= mc_enc(48, 8, endpoint2->type[6]);
-       cmd.params[5] |= mc_enc(56, 8, endpoint2->type[7]);
-       cmd.params[6] |= mc_enc(0, 8, endpoint2->type[8]);
-       cmd.params[6] |= mc_enc(8, 8, endpoint2->type[9]);
-       cmd.params[6] |= mc_enc(16, 8, endpoint2->type[10]);
-       cmd.params[6] |= mc_enc(24, 8, endpoint2->type[11]);
-       cmd.params[6] |= mc_enc(32, 8, endpoint2->type[12]);
-       cmd.params[6] |= mc_enc(40, 8, endpoint2->type[13]);
-       cmd.params[6] |= mc_enc(48, 8, endpoint2->type[14]);
-       cmd.params[6] |= mc_enc(56, 8, endpoint2->type[15]);
+       cmd_params = (struct dprc_cmd_connect *)cmd.params;
+       cmd_params->ep1_id = cpu_to_le32(endpoint1->id);
+       cmd_params->ep1_interface_id = cpu_to_le32(endpoint1->if_id);
+       cmd_params->ep2_id = cpu_to_le32(endpoint2->id);
+       cmd_params->ep2_interface_id = cpu_to_le32(endpoint2->if_id);
+       strncpy(cmd_params->ep1_type, endpoint1->type, 16);
+       cmd_params->ep1_type[15] = '\0';
+       cmd_params->max_rate = cpu_to_le32(cfg->max_rate);
+       cmd_params->committed_rate = cpu_to_le32(cfg->committed_rate);
+       strncpy(cmd_params->ep2_type, endpoint2->type, 16);
+       cmd_params->ep2_type[15] = '\0';
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -1516,29 +1317,17 @@ int dprc_disconnect(struct fsl_mc_io *mc_io,
                    const struct dprc_endpoint *endpoint)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_disconnect *cmd_params;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_DISCONNECT,
                                          cmd_flags,
                                          token);
-       cmd.params[0] |= mc_enc(0, 32, endpoint->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]);
-       cmd.params[1] |= mc_enc(24, 8, endpoint->type[3]);
-       cmd.params[1] |= mc_enc(32, 8, endpoint->type[4]);
-       cmd.params[1] |= mc_enc(40, 8, endpoint->type[5]);
-       cmd.params[1] |= mc_enc(48, 8, endpoint->type[6]);
-       cmd.params[1] |= mc_enc(56, 8, endpoint->type[7]);
-       cmd.params[2] |= mc_enc(0, 8, endpoint->type[8]);
-       cmd.params[2] |= mc_enc(8, 8, endpoint->type[9]);
-       cmd.params[2] |= mc_enc(16, 8, endpoint->type[10]);
-       cmd.params[2] |= mc_enc(24, 8, endpoint->type[11]);
-       cmd.params[2] |= mc_enc(32, 8, endpoint->type[12]);
-       cmd.params[2] |= mc_enc(40, 8, endpoint->type[13]);
-       cmd.params[2] |= mc_enc(48, 8, endpoint->type[14]);
-       cmd.params[2] |= mc_enc(56, 8, endpoint->type[15]);
+       cmd_params = (struct dprc_cmd_disconnect *)cmd.params;
+       cmd_params->id = cpu_to_le32(endpoint->id);
+       cmd_params->interface_id = cpu_to_le32(endpoint->if_id);
+       strncpy(cmd_params->type, endpoint->type, 16);
+       cmd_params->type[15] = '\0';
 
        /* send command to mc*/
        return mc_send_command(mc_io, &cmd);
@@ -1567,30 +1356,19 @@ int dprc_get_connection(struct fsl_mc_io *mc_io,
                        int *state)
 {
        struct mc_command cmd = { 0 };
+       struct dprc_cmd_get_connection *cmd_params;
+       struct dprc_rsp_get_connection *rsp_params;
        int err;
 
        /* prepare command */
        cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION,
                                          cmd_flags,
                                          token);
-       cmd.params[0] |= mc_enc(0, 32, endpoint1->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]);
-       cmd.params[1] |= mc_enc(24, 8, endpoint1->type[3]);
-       cmd.params[1] |= mc_enc(32, 8, endpoint1->type[4]);
-       cmd.params[1] |= mc_enc(40, 8, endpoint1->type[5]);
-       cmd.params[1] |= mc_enc(48, 8, endpoint1->type[6]);
-       cmd.params[1] |= mc_enc(56, 8, endpoint1->type[7]);
-       cmd.params[2] |= mc_enc(0, 8, endpoint1->type[8]);
-       cmd.params[2] |= mc_enc(8, 8, endpoint1->type[9]);
-       cmd.params[2] |= mc_enc(16, 8, endpoint1->type[10]);
-       cmd.params[2] |= mc_enc(24, 8, endpoint1->type[11]);
-       cmd.params[2] |= mc_enc(32, 8, endpoint1->type[12]);
-       cmd.params[2] |= mc_enc(40, 8, endpoint1->type[13]);
-       cmd.params[2] |= mc_enc(48, 8, endpoint1->type[14]);
-       cmd.params[2] |= mc_enc(56, 8, endpoint1->type[15]);
+       cmd_params = (struct dprc_cmd_get_connection *)cmd.params;
+       cmd_params->ep1_id = cpu_to_le32(endpoint1->id);
+       cmd_params->ep1_interface_id = cpu_to_le32(endpoint1->if_id);
+       strncpy(cmd_params->ep1_type, endpoint1->type, 16);
+       cmd_params->ep1_type[15] = '\0';
 
        /* send command to mc*/
        err = mc_send_command(mc_io, &cmd);
@@ -1598,25 +1376,12 @@ int dprc_get_connection(struct fsl_mc_io *mc_io,
                return err;
 
        /* retrieve response parameters */
-       endpoint2->id = mc_dec(cmd.params[3], 0, 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);
-       endpoint2->type[3] = mc_dec(cmd.params[4], 24, 8);
-       endpoint2->type[4] = mc_dec(cmd.params[4], 32, 8);
-       endpoint2->type[5] = mc_dec(cmd.params[4], 40, 8);
-       endpoint2->type[6] = mc_dec(cmd.params[4], 48, 8);
-       endpoint2->type[7] = mc_dec(cmd.params[4], 56, 8);
-       endpoint2->type[8] = mc_dec(cmd.params[5], 0, 8);
-       endpoint2->type[9] = mc_dec(cmd.params[5], 8, 8);
-       endpoint2->type[10] = mc_dec(cmd.params[5], 16, 8);
-       endpoint2->type[11] = mc_dec(cmd.params[5], 24, 8);
-       endpoint2->type[12] = mc_dec(cmd.params[5], 32, 8);
-       endpoint2->type[13] = mc_dec(cmd.params[5], 40, 8);
-       endpoint2->type[14] = mc_dec(cmd.params[5], 48, 8);
-       endpoint2->type[15] = mc_dec(cmd.params[5], 56, 8);
-       *state = mc_dec(cmd.params[6], 0, 32);
+       rsp_params = (struct dprc_rsp_get_connection *)cmd.params;
+       endpoint2->id = le32_to_cpu(rsp_params->ep2_id);
+       endpoint2->if_id = le32_to_cpu(rsp_params->ep2_interface_id);
+       strncpy(endpoint2->type, rsp_params->ep2_type, 16);
+       endpoint2->type[15] = '\0';
+       *state = le32_to_cpu(rsp_params->state);
 
        return 0;
 }

diff --git a/drivers/staging/fsl-mc/bus/mc-sys.c b/drivers/staging/fsl-mc/bus/mc-sys.c
index 810a611c1cb042f3ae4ff80f957b368f8b124218..0c185abe665e5f4bf0e0280229dd21bb812c919e 100644 (file)
--- a/drivers/staging/fsl-mc/bus/mc-sys.c
+++ b/drivers/staging/fsl-mc/bus/mc-sys.c
@@ -53,8 +53,20 @@
 #define MC_CMD_COMPLETION_POLLING_MIN_SLEEP_USECS    10
 #define MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS    500
 
-#define MC_CMD_HDR_READ_CMDID(_hdr) \
-       ((u16)mc_dec((_hdr), MC_CMD_HDR_CMDID_O, MC_CMD_HDR_CMDID_S))
+static enum mc_cmd_status mc_cmd_hdr_read_status(struct mc_command *cmd)
+{
+       struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header;
+
+       return (enum mc_cmd_status)hdr->status;
+}
+
+static u16 mc_cmd_hdr_read_cmdid(struct mc_command *cmd)
+{
+       struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header;
+       u16 cmd_id = le16_to_cpu(hdr->cmd_id);
+
+       return (cmd_id & MC_CMD_HDR_CMDID_MASK) >> MC_CMD_HDR_CMDID_SHIFT;
+}
 
 /**
  * Creates an MC I/O object
@@ -261,10 +273,11 @@ static inline void mc_write_command(struct mc_command __iomem *portal,
 
        /* copy command parameters into the portal */
        for (i = 0; i < MC_CMD_NUM_OF_PARAMS; i++)
-               writeq(cmd->params[i], &portal->params[i]);
+               __raw_writeq(cmd->params[i], &portal->params[i]);
+       __iowmb();
 
        /* submit the command by writing the header */
-       writeq(cmd->header, &portal->header);
+       __raw_writeq(cmd->header, &portal->header);
 }
 
 /**
@@ -284,14 +297,17 @@ static inline enum mc_cmd_status mc_read_response(struct mc_command __iomem *
        enum mc_cmd_status status;
 
        /* Copy command response header from MC portal: */
-       resp->header = readq(&portal->header);
-       status = MC_CMD_HDR_READ_STATUS(resp->header);
+       __iormb();
+       resp->header = __raw_readq(&portal->header);
+       __iormb();
+       status = mc_cmd_hdr_read_status(resp);
        if (status != MC_CMD_STATUS_OK)
                return status;
 
        /* Copy command response data from MC portal: */
        for (i = 0; i < MC_CMD_NUM_OF_PARAMS; i++)
-               resp->params[i] = readq(&portal->params[i]);
+               resp->params[i] = __raw_readq(&portal->params[i]);
+       __iormb();
 
        return status;
 }
@@ -331,10 +347,8 @@ static int mc_polling_wait_preemptible(struct fsl_mc_io *mc_io,
                        dev_dbg(mc_io->dev,
                                "MC command timed out (portal: %#llx, obj handle: %#x, command: %#x)\n",
                                 mc_io->portal_phys_addr,
-                                (unsigned int)
-                                       MC_CMD_HDR_READ_TOKEN(cmd->header),
-                                (unsigned int)
-                                       MC_CMD_HDR_READ_CMDID(cmd->header));
+                                (unsigned int)mc_cmd_hdr_read_token(cmd),
+                                (unsigned int)mc_cmd_hdr_read_cmdid(cmd));
 
                        return -ETIMEDOUT;
                }
@@ -373,10 +387,8 @@ static int mc_polling_wait_atomic(struct fsl_mc_io *mc_io,
                        dev_dbg(mc_io->dev,
                                "MC command timed out (portal: %#llx, obj handle: %#x, command: %#x)\n",
                                 mc_io->portal_phys_addr,
-                                (unsigned int)
-                                       MC_CMD_HDR_READ_TOKEN(cmd->header),
-                                (unsigned int)
-                                       MC_CMD_HDR_READ_CMDID(cmd->header));
+                                (unsigned int)mc_cmd_hdr_read_token(cmd),
+                                (unsigned int)mc_cmd_hdr_read_cmdid(cmd));
 
                        return -ETIMEDOUT;
                }
@@ -429,8 +441,8 @@ int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd)
                dev_dbg(mc_io->dev,
                        "MC command failed: portal: %#llx, obj handle: %#x, command: %#x, status: %s (%#x)\n",
                         mc_io->portal_phys_addr,
-                        (unsigned int)MC_CMD_HDR_READ_TOKEN(cmd->header),
-                        (unsigned int)MC_CMD_HDR_READ_CMDID(cmd->header),
+                        (unsigned int)mc_cmd_hdr_read_token(cmd),
+                        (unsigned int)mc_cmd_hdr_read_cmdid(cmd),
                         mc_status_to_string(status),
                         (unsigned int)status);
 

diff --git a/drivers/staging/fsl-mc/include/dpbp-cmd.h b/drivers/staging/fsl-mc/include/dpbp-cmd.h
index c57b454a291216e65bfff0e780c8ee3a308a87ae..4828ccd0cffd0716aaac39fc98e0025adaa7febb 100644 (file)
--- a/drivers/staging/fsl-mc/include/dpbp-cmd.h
+++ b/drivers/staging/fsl-mc/include/dpbp-cmd.h
@@ -1,4 +1,4 @@
-/* Copyright 2013-2014 Freescale Semiconductor Inc.
+/* Copyright 2013-2016 Freescale Semiconductor Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
@@ -59,4 +59,127 @@
 
 #define DPBP_CMDID_SET_NOTIFICATIONS           0x01b0
 #define DPBP_CMDID_GET_NOTIFICATIONS           0x01b1
+
+struct dpbp_cmd_open {
+       __le32 dpbp_id;
+};
+
+#define DPBP_ENABLE                    0x1
+
+struct dpbp_rsp_is_enabled {
+       u8 enabled;
+};
+
+struct dpbp_cmd_set_irq {
+       /* cmd word 0 */
+       u8 irq_index;
+       u8 pad[3];
+       __le32 irq_val;
+       /* cmd word 1 */
+       __le64 irq_addr;
+       /* cmd word 2 */
+       __le32 irq_num;
+};
+
+struct dpbp_cmd_get_irq {
+       __le32 pad;
+       u8 irq_index;
+};
+
+struct dpbp_rsp_get_irq {
+       /* response word 0 */
+       __le32 irq_val;
+       __le32 pad;
+       /* response word 1 */
+       __le64 irq_addr;
+       /* response word 2 */
+       __le32 irq_num;
+       __le32 type;
+};
+
+struct dpbp_cmd_set_irq_enable {
+       u8 enable;
+       u8 pad[3];
+       u8 irq_index;
+};
+
+struct dpbp_cmd_get_irq_enable {
+       __le32 pad;
+       u8 irq_index;
+};
+
+struct dpbp_rsp_get_irq_enable {
+       u8 enabled;
+};
+
+struct dpbp_cmd_set_irq_mask {
+       __le32 mask;
+       u8 irq_index;
+};
+
+struct dpbp_cmd_get_irq_mask {
+       __le32 pad;
+       u8 irq_index;
+};
+
+struct dpbp_rsp_get_irq_mask {
+       __le32 mask;
+};
+
+struct dpbp_cmd_get_irq_status {
+       __le32 status;
+       u8 irq_index;
+};
+
+struct dpbp_rsp_get_irq_status {
+       __le32 status;
+};
+
+struct dpbp_cmd_clear_irq_status {
+       __le32 status;
+       u8 irq_index;
+};
+
+struct dpbp_rsp_get_attributes {
+       /* response word 0 */
+       __le16 pad;
+       __le16 bpid;
+       __le32 id;
+       /* response word 1 */
+       __le16 version_major;
+       __le16 version_minor;
+};
+
+struct dpbp_cmd_set_notifications {
+       /* cmd word 0 */
+       __le32 depletion_entry;
+       __le32 depletion_exit;
+       /* cmd word 1 */
+       __le32 surplus_entry;
+       __le32 surplus_exit;
+       /* cmd word 2 */
+       __le16 options;
+       __le16 pad[3];
+       /* cmd word 3 */
+       __le64 message_ctx;
+       /* cmd word 4 */
+       __le64 message_iova;
+};
+
+struct dpbp_rsp_get_notifications {
+       /* response word 0 */
+       __le32 depletion_entry;
+       __le32 depletion_exit;
+       /* response word 1 */
+       __le32 surplus_entry;
+       __le32 surplus_exit;
+       /* response word 2 */
+       __le16 options;
+       __le16 pad[3];
+       /* response word 3 */
+       __le64 message_ctx;
+       /* response word 4 */
+       __le64 message_iova;
+};
+
 #endif /* _FSL_DPBP_CMD_H */

diff --git a/drivers/staging/fsl-mc/include/mc-cmd.h b/drivers/staging/fsl-mc/include/mc-cmd.h
index 65277e3de44d537ca51df63f98768374f7884847..5decb9890c31d727f968818f1175934e2fde91dc 100644 (file)
--- a/drivers/staging/fsl-mc/include/mc-cmd.h
+++ b/drivers/staging/fsl-mc/include/mc-cmd.h
@@ -34,18 +34,14 @@
 
 #define MC_CMD_NUM_OF_PARAMS   7
 
-#define MAKE_UMASK64(_width) \
-       ((u64)((_width) < 64 ? ((u64)1 << (_width)) - 1 : -1))
-
-static inline u64 mc_enc(int lsoffset, int width, u64 val)
-{
-       return (u64)(((u64)val & MAKE_UMASK64(width)) << lsoffset);
-}
-
-static inline u64 mc_dec(u64 val, int lsoffset, int width)
-{
-       return (u64)((val >> lsoffset) & MAKE_UMASK64(width));
-}
+struct mc_cmd_header {
+       u8 src_id;
+       u8 flags_hw;
+       u8 status;
+       u8 flags_sw;
+       __le16 token;
+       __le16 cmd_id;
+};
 
 struct mc_command {
        u64 header;
@@ -72,60 +68,41 @@ enum mc_cmd_status {
  */
 
 /* High priority flag */
-#define MC_CMD_FLAG_PRI                0x00008000
+#define MC_CMD_FLAG_PRI                0x80
 /* 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_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), \
-               MC_CMD_HDR_STATUS_O, MC_CMD_HDR_STATUS_S))
-
-#define MC_CMD_HDR_READ_TOKEN(_hdr) \
-       ((u16)mc_dec((_hdr), MC_CMD_HDR_TOKEN_O, MC_CMD_HDR_TOKEN_S))
-
-#define MC_CMD_HDR_READ_FLAGS(_hdr) \
-       ((u32)mc_dec((_hdr), MC_CMD_HDR_FLAGS_O, MC_CMD_HDR_FLAGS_S))
+#define MC_CMD_FLAG_INTR_DIS   0x01
 
-#define MC_EXT_OP(_ext, _param, _offset, _width, _type, _arg) \
-       ((_ext)[_param] |= mc_enc((_offset), (_width), _arg))
-
-#define MC_CMD_OP(_cmd, _param, _offset, _width, _type, _arg) \
-       ((_cmd).params[_param] |= mc_enc((_offset), (_width), _arg))
-
-#define MC_RSP_OP(_cmd, _param, _offset, _width, _type, _arg) \
-       (_arg = (_type)mc_dec(_cmd.params[_param], (_offset), (_width)))
+#define MC_CMD_HDR_CMDID_MASK          0xFFF0
+#define MC_CMD_HDR_CMDID_SHIFT         4
+#define MC_CMD_HDR_TOKEN_MASK          0xFFC0
+#define MC_CMD_HDR_TOKEN_SHIFT         6
 
 static inline u64 mc_encode_cmd_header(u16 cmd_id,
                                       u32 cmd_flags,
                                       u16 token)
 {
-       u64 hdr;
+       u64 header = 0;
+       struct mc_cmd_header *hdr = (struct mc_cmd_header *)&header;
+
+       hdr->cmd_id = cpu_to_le16((cmd_id << MC_CMD_HDR_CMDID_SHIFT) &
+                                 MC_CMD_HDR_CMDID_MASK);
+       hdr->token = cpu_to_le16((token << MC_CMD_HDR_TOKEN_SHIFT) &
+                                MC_CMD_HDR_TOKEN_MASK);
+       hdr->status = MC_CMD_STATUS_READY;
+       if (cmd_flags & MC_CMD_FLAG_PRI)
+               hdr->flags_hw = MC_CMD_FLAG_PRI;
+       if (cmd_flags & MC_CMD_FLAG_INTR_DIS)
+               hdr->flags_sw = MC_CMD_FLAG_INTR_DIS;
+
+       return header;
+}
 
-       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_STATUS_O, MC_CMD_HDR_STATUS_S,
-                      MC_CMD_STATUS_READY);
+static inline u16 mc_cmd_hdr_read_token(struct mc_command *cmd)
+{
+       struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header;
+       u16 token = le16_to_cpu(hdr->token);
 
-       return hdr;
+       return (token & MC_CMD_HDR_TOKEN_MASK) >> MC_CMD_HDR_TOKEN_SHIFT;
 }
 
 #endif /* __FSL_MC_CMD_H */