Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 73370134 authored by Laurentiu Tudor's avatar Laurentiu Tudor Committed by Greg Kroah-Hartman
Browse files

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: default avatarLaurentiu Tudor <laurentiu.tudor@nxp.com>
Acked-by: default avatarStuart Yoder <stuart.yoder@nxp.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 58acb387

drivers/staging/fsl-mc/bus/dpbp-cmd.h

+0 −116
Original line number Diff line number Diff line
@@ -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 */

drivers/staging/fsl-mc/bus/dpbp.c

+0 −449
Original line number Diff line number Diff line
@@ -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

drivers/staging/fsl-mc/include/dpbp.h

+0 −129
Original line number Diff line number Diff line
@@ -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 */