Commit 9989b599 authored by Ioana Radulescu's avatar Ioana Radulescu Committed by Greg Kroah-Hartman
Browse files

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: default avatarIoana Radulescu <ruxandra.radulescu@nxp.com>
Signed-off-by: default avatarStuart Yoder <stuart.yoder@nxp.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent adf72b5b
/* 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;
}
/* 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 */
/* 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;