redonkable
/
remarkable-linux
1
0
Fork 0
Code Releases Activity

staging: fsl-mc: dpbp: drop unused APIs 

Leave only APIs that will be used in upcomming drivers.
The patch is mostly mechanical, with a couple exceptions:
 - getters/setters were not removed even if only one of
   them is being used
 - versioning API was also left in place
They will be added back on an as-needed basis.

Signed-off-by: Laurentiu Tudor <laurentiu.tudor@nxp.com>
Acked-by: Stuart Yoder <stuart.yoder@nxp.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
zero-colors
Laurentiu Tudor 2017-02-07 09:43:51 -06:00 committed by Greg Kroah-Hartman
parent 58acb3875b
commit 7337013473
3 changed files with 0 additions and 694 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
drivers/staging/fsl-mc/bus/dpbp-cmd.h
View File

@ -45,8 +45,6 @@
/* Command IDs */
#define DPBP_CMDID_CLOSE DPBP_CMD(0x800)
#define DPBP_CMDID_OPEN DPBP_CMD(0x804)
#define DPBP_CMDID_CREATE DPBP_CMD(0x904)
#define DPBP_CMDID_DESTROY DPBP_CMD(0x984)
#define DPBP_CMDID_GET_API_VERSION DPBP_CMD(0xa04)
#define DPBP_CMDID_ENABLE DPBP_CMD(0x002)
@ -55,18 +53,6 @@
#define DPBP_CMDID_RESET DPBP_CMD(0x005)
#define DPBP_CMDID_IS_ENABLED DPBP_CMD(0x006)
#define DPBP_CMDID_SET_IRQ DPBP_CMD(0x010)
#define DPBP_CMDID_GET_IRQ DPBP_CMD(0x011)
#define DPBP_CMDID_SET_IRQ_ENABLE DPBP_CMD(0x012)
#define DPBP_CMDID_GET_IRQ_ENABLE DPBP_CMD(0x013)
#define DPBP_CMDID_SET_IRQ_MASK DPBP_CMD(0x014)
#define DPBP_CMDID_GET_IRQ_MASK DPBP_CMD(0x015)
#define DPBP_CMDID_GET_IRQ_STATUS DPBP_CMD(0x016)
#define DPBP_CMDID_CLEAR_IRQ_STATUS DPBP_CMD(0x017)
#define DPBP_CMDID_SET_NOTIFICATIONS DPBP_CMD(0x01b0)
#define DPBP_CMDID_GET_NOTIFICATIONS DPBP_CMD(0x01b1)
struct dpbp_cmd_open {
__le32 dpbp_id;
};
@ -81,76 +67,6 @@ 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;
@ -161,36 +77,4 @@ struct dpbp_rsp_get_attributes {
__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 */

449
drivers/staging/fsl-mc/bus/dpbp.c
View File

@ -105,77 +105,6 @@ int dpbp_close(struct fsl_mc_io *mc_io,
}
EXPORT_SYMBOL(dpbp_close);
/**
* dpbp_create() - Create the DPBP object.
* @mc_io: Pointer to MC portal's I/O object
* @dprc_token: Parent container token; '0' for default container
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @cfg: Configuration structure
* @obj_id: Returned object id; use in subsequent API calls
*
* Create the DPBP object, allocate required resources and
* perform required initialization.
*
* This function accepts an authentication token of a parent
* container that this object should be assigned to and returns
* an object id. This object_id will be used in all subsequent calls to
* this specific object.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_create(struct fsl_mc_io *mc_io,
u16 dprc_token,
u32 cmd_flags,
const struct dpbp_cfg *cfg,
u32 *obj_id)
{
struct mc_command cmd = { 0 };
int err;
(void)(cfg); /* unused */
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_CREATE,
cmd_flags, dprc_token);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*obj_id = mc_cmd_read_object_id(&cmd);
return 0;
}
/**
* dpbp_destroy() - Destroy the DPBP object and release all its resources.
* @mc_io: Pointer to MC portal's I/O object
* @dprc_token: Parent container token; '0' for default container
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @obj_id: ID of DPBP object
*
* Return: '0' on Success; error code otherwise.
*/
int dpbp_destroy(struct fsl_mc_io *mc_io,
u16 dprc_token,
u32 cmd_flags,
u32 obj_id)
{
struct dpbp_cmd_destroy *cmd_params;
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_DESTROY,
cmd_flags, dprc_token);
cmd_params = (struct dpbp_cmd_destroy *)cmd.params;
cmd_params->object_id = cpu_to_le32(obj_id);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
/**
* dpbp_enable() - Enable the DPBP.
* @mc_io: Pointer to MC portal's I/O object
@ -277,310 +206,6 @@ int dpbp_reset(struct fsl_mc_io *mc_io,
return mc_send_command(mc_io, &cmd);
}
/**
* dpbp_set_irq() - Set IRQ information for the DPBP to trigger an interrupt.
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: Identifies the interrupt index to configure
* @irq_cfg: IRQ configuration
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_irq(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
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 = (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);
}
/**
* dpbp_get_irq() - Get IRQ information from the DPBP.
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @type: Interrupt type: 0 represents message interrupt
* type (both irq_addr and irq_val are valid)
* @irq_cfg: IRQ attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
int *type,
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 = (struct dpbp_cmd_get_irq *)cmd.params;
cmd_params->irq_index = irq_index;
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
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;
}
/**
* dpbp_set_irq_enable() - Set overall interrupt state.
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @en: Interrupt state - enable = 1, disable = 0
*
* Allows GPP software to control when interrupts are generated.
* Each interrupt can have up to 32 causes. The enable/disable control's the
* overall interrupt state. if the interrupt is disabled no causes will cause
* an interrupt.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
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 = (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);
}
/**
* dpbp_get_irq_enable() - Get overall interrupt state
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @en: Returned interrupt state - enable = 1, disable = 0
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
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 = (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);
if (err)
return err;
/* retrieve response parameters */
rsp_params = (struct dpbp_rsp_get_irq_enable *)cmd.params;
*en = rsp_params->enabled & DPBP_ENABLE;
return 0;
}
/**
* dpbp_set_irq_mask() - Set interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @mask: Event mask to trigger interrupt;
* each bit:
* 0 = ignore event
* 1 = consider event for asserting IRQ
*
* Every interrupt can have up to 32 causes and the interrupt model supports
* masking/unmasking each cause independently
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
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 = (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);
}
/**
* dpbp_get_irq_mask() - Get interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @mask: Returned event mask to trigger interrupt
*
* Every interrupt can have up to 32 causes and the interrupt model supports
* masking/unmasking each cause independently
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
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 = (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);
if (err)
return err;
/* retrieve response parameters */
rsp_params = (struct dpbp_rsp_get_irq_mask *)cmd.params;
*mask = le32_to_cpu(rsp_params->mask);
return 0;
}
/**
* dpbp_get_irq_status() - Get the current status of any pending interrupts.
*
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @status: Returned interrupts status - one bit per cause:
* 0 = no interrupt pending
* 1 = interrupt pending
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
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 = (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);
if (err)
return err;
/* retrieve response parameters */
rsp_params = (struct dpbp_rsp_get_irq_status *)cmd.params;
*status = le32_to_cpu(rsp_params->status);
return 0;
}
/**
* dpbp_clear_irq_status() - Clear a pending interrupt's status
*
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @status: Bits to clear (W1C) - one bit per cause:
* 0 = don't change
* 1 = clear status bit
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_clear_irq_status(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
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 = (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);
}
/**
* dpbp_get_attributes - Retrieve DPBP attributes.
*
@ -618,80 +243,6 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io,
}
EXPORT_SYMBOL(dpbp_get_attributes);
/**
* dpbp_set_notifications() - Set notifications towards software
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @cfg: notifications configuration
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_notifications(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
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 = (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);
}
/**
* dpbp_get_notifications() - Get the notifications configuration
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPBP object
* @cfg: notifications configuration
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_notifications(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
struct dpbp_notification_cfg *cfg)
{
struct mc_command cmd = { 0 };
struct dpbp_rsp_get_notifications *rsp_params;
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_NOTIFICATIONS,
cmd_flags,
token);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
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;
}
/**
* dpbp_get_api_version - Get Data Path Buffer Pool API version
* @mc_io: Pointer to Mc portal's I/O object

129
drivers/staging/fsl-mc/include/dpbp.h
View File

@ -49,25 +49,6 @@ int dpbp_close(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token);
/**
* struct dpbp_cfg - Structure representing DPBP configuration
* @options: place holder
*/
struct dpbp_cfg {
u32 options;
};
int dpbp_create(struct fsl_mc_io *mc_io,
u16 dprc_token,
u32 cmd_flags,
const struct dpbp_cfg *cfg,
u32 *obj_id);
int dpbp_destroy(struct fsl_mc_io *mc_io,
u16 dprc_token,
u32 cmd_flags,
u32 obj_id);
int dpbp_enable(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token);
@ -85,67 +66,6 @@ int dpbp_reset(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token);
/**
* struct dpbp_irq_cfg - IRQ configuration
* @addr: Address that must be written to signal a message-based interrupt
* @val: Value to write into irq_addr address
* @irq_num: A user defined number associated with this IRQ
*/
struct dpbp_irq_cfg {
u64 addr;
u32 val;
int irq_num;
};
int dpbp_set_irq(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
struct dpbp_irq_cfg *irq_cfg);
int dpbp_get_irq(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
int *type,
struct dpbp_irq_cfg *irq_cfg);
int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u8 en);
int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u8 *en);
int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u32 mask);
int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u32 *mask);
int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u32 *status);
int dpbp_clear_irq_status(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u32 status);
/**
* struct dpbp_attr - Structure representing DPBP attributes
* @id: DPBP object ID
@ -162,58 +82,9 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io,
u16 token,
struct dpbp_attr *attr);
/**
* DPBP notifications options
*/
/**
* BPSCN write will attempt to allocate into a cache (coherent write)
*/
#define DPBP_NOTIF_OPT_COHERENT_WRITE 0x00000001
/**
* struct dpbp_notification_cfg - Structure representing DPBP notifications
* towards software
* @depletion_entry: below this threshold the pool is "depleted";
* set it to '0' to disable it
* @depletion_exit: greater than or equal to this threshold the pool exit its
* "depleted" state
* @surplus_entry: above this threshold the pool is in "surplus" state;
* set it to '0' to disable it
* @surplus_exit: less than or equal to this threshold the pool exit its
* "surplus" state
* @message_iova: MUST be given if either 'depletion_entry' or 'surplus_entry'
* is not '0' (enable); I/O virtual address (must be in DMA-able memory),
* must be 16B aligned.
* @message_ctx: The context that will be part of the BPSCN message and will
* be written to 'message_iova'
* @options: Mask of available options; use 'DPBP_NOTIF_OPT_<X>' values
*/
struct dpbp_notification_cfg {
u32 depletion_entry;
u32 depletion_exit;
u32 surplus_entry;
u32 surplus_exit;
u64 message_iova;
u64 message_ctx;
u16 options;
};
int dpbp_set_notifications(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
struct dpbp_notification_cfg *cfg);
int dpbp_get_notifications(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
struct dpbp_notification_cfg *cfg);
int dpbp_get_api_version(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 *major_ver,
u16 *minor_ver);
/** @} */
#endif /* __FSL_DPBP_H */