[linux-2.6-block.git] / drivers / bus / fsl-mc / dprc.c

// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
/*
 * Copyright 2013-2016 Freescale Semiconductor Inc.
 *
 */
#include <linux/kernel.h>
#include <linux/fsl/mc.h>

#include "fsl-mc-private.h"

/**
 * dprc_open() - Open DPRC object for use
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @container_id: Container ID to open
 * @token:	Returned token of DPRC object
 *
 * Return:	'0' on Success; Error code otherwise.
 *
 * @warning	Required before any operation on the object.
 */
int dprc_open(struct fsl_mc_io *mc_io,
	      u32 cmd_flags,
	      int container_id,
	      u16 *token)
{
	struct fsl_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 = (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);
	if (err)
		return err;

	/* retrieve response parameters */
	*token = mc_cmd_hdr_read_token(&cmd);

	return 0;
}
EXPORT_SYMBOL_GPL(dprc_open);

/**
 * dprc_close() - Close the control session of the object
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 *
 * After this function is called, no further operations are
 * allowed on the object without opening a new control session.
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_close(struct fsl_mc_io *mc_io,
	       u32 cmd_flags,
	       u16 token)
{
	struct fsl_mc_command cmd = { 0 };

	/* prepare command */
	cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags,
					  token);

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

/**
 * dprc_set_irq() - Set IRQ information for the DPRC to trigger an interrupt.
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @irq_index:	Identifies the interrupt index to configure
 * @irq_cfg:	IRQ configuration
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_set_irq(struct fsl_mc_io *mc_io,
		 u32 cmd_flags,
		 u16 token,
		 u8 irq_index,
		 struct dprc_irq_cfg *irq_cfg)
{
	struct fsl_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 = (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);
}

/**
 * dprc_set_irq_enable() - Set overall interrupt state.
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @irq_index:	The interrupt index to configure
 * @en:		Interrupt state - enable = 1, disable = 0
 *
 * 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 dprc_set_irq_enable(struct fsl_mc_io *mc_io,
			u32 cmd_flags,
			u16 token,
			u8 irq_index,
			u8 en)
{
	struct fsl_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 = (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);
}

/**
 * dprc_set_irq_mask() - Set interrupt mask.
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @irq_index:	The interrupt index to configure
 * @mask:	event mask to trigger interrupt;
 *			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 dprc_set_irq_mask(struct fsl_mc_io *mc_io,
		      u32 cmd_flags,
		      u16 token,
		      u8 irq_index,
		      u32 mask)
{
	struct fsl_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 = (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);
}

/**
 * dprc_get_irq_status() - Get the current status of any pending interrupts.
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @irq_index:	The interrupt index to configure
 * @status:	Returned interrupts status - one bit per cause:
 *			0 = no interrupt pending
 *			1 = interrupt pending
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_get_irq_status(struct fsl_mc_io *mc_io,
			u32 cmd_flags,
			u16 token,
			u8 irq_index,
			u32 *status)
{
	struct fsl_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 = (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);
	if (err)
		return err;

	/* retrieve response parameters */
	rsp_params = (struct dprc_rsp_get_irq_status *)cmd.params;
	*status = le32_to_cpu(rsp_params->status);

	return 0;
}

/**
 * dprc_clear_irq_status() - Clear a pending interrupt's status
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @irq_index:	The interrupt index to configure
 * @status:	bits to clear (W1C) - one bit per cause:
 *					0 = don't change
 *					1 = clear status bit
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_clear_irq_status(struct fsl_mc_io *mc_io,
			  u32 cmd_flags,
			  u16 token,
			  u8 irq_index,
			  u32 status)
{
	struct fsl_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 = (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);
}

/**
 * dprc_get_attributes() - Obtains container attributes
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @attributes	Returned container attributes
 *
 * Return:     '0' on Success; Error code otherwise.
 */
int dprc_get_attributes(struct fsl_mc_io *mc_io,
			u32 cmd_flags,
			u16 token,
			struct dprc_attributes *attr)
{
	struct fsl_mc_command cmd = { 0 };
	struct dprc_rsp_get_attributes *rsp_params;
	int err;

	/* prepare command */
	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR,
					  cmd_flags,
					  token);

	/* send command to mc*/
	err = mc_send_command(mc_io, &cmd);
	if (err)
		return err;

	/* retrieve response parameters */
	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);

	return 0;
}

/**
 * dprc_get_obj_count() - Obtains the number of objects in the DPRC
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @obj_count:	Number of objects assigned to the DPRC
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_get_obj_count(struct fsl_mc_io *mc_io,
		       u32 cmd_flags,
		       u16 token,
		       int *obj_count)
{
	struct fsl_mc_command cmd = { 0 };
	struct dprc_rsp_get_obj_count *rsp_params;
	int err;

	/* prepare command */
	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT,
					  cmd_flags, token);

	/* send command to mc*/
	err = mc_send_command(mc_io, &cmd);
	if (err)
		return err;

	/* retrieve response parameters */
	rsp_params = (struct dprc_rsp_get_obj_count *)cmd.params;
	*obj_count = le32_to_cpu(rsp_params->obj_count);

	return 0;
}
EXPORT_SYMBOL_GPL(dprc_get_obj_count);

/**
 * dprc_get_obj() - Get general information on an object
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @obj_index:	Index of the object to be queried (< obj_count)
 * @obj_desc:	Returns the requested object descriptor
 *
 * The object descriptors are retrieved one by one by incrementing
 * obj_index up to (not including) the value of obj_count returned
 * from dprc_get_obj_count(). dprc_get_obj_count() must
 * be called prior to dprc_get_obj().
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_get_obj(struct fsl_mc_io *mc_io,
		 u32 cmd_flags,
		 u16 token,
		 int obj_index,
		 struct fsl_mc_obj_desc *obj_desc)
{
	struct fsl_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 = (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);
	if (err)
		return err;

	/* retrieve response parameters */
	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';
	strncpy(obj_desc->label, rsp_params->label, 16);
	obj_desc->label[15] = '\0';
	return 0;
}
EXPORT_SYMBOL_GPL(dprc_get_obj);

/**
 * dprc_set_obj_irq() - Set IRQ information for object to trigger an interrupt.
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @obj_type:	Type of the object to set its IRQ
 * @obj_id:	ID of the object to set its IRQ
 * @irq_index:	The interrupt index to configure
 * @irq_cfg:	IRQ configuration
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_set_obj_irq(struct fsl_mc_io *mc_io,
		     u32 cmd_flags,
		     u16 token,
		     char *obj_type,
		     int obj_id,
		     u8 irq_index,
		     struct dprc_irq_cfg *irq_cfg)
{
	struct fsl_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 = (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);
}
EXPORT_SYMBOL_GPL(dprc_set_obj_irq);

/**
 * dprc_get_obj_region() - Get region information for a specified object.
 * @mc_io:	Pointer to MC portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:	Token of DPRC object
 * @obj_type;	Object type as returned in dprc_get_obj()
 * @obj_id:	Unique object instance as returned in dprc_get_obj()
 * @region_index: The specific region to query
 * @region_desc:  Returns the requested region descriptor
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_get_obj_region(struct fsl_mc_io *mc_io,
			u32 cmd_flags,
			u16 token,
			char *obj_type,
			int obj_id,
			u8 region_index,
			struct dprc_region_desc *region_desc)
{
	struct fsl_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 = (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);
	if (err)
		return err;

	/* retrieve response parameters */
	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;
}
EXPORT_SYMBOL_GPL(dprc_get_obj_region);

/**
 * dprc_get_api_version - Get Data Path Resource Container API version
 * @mc_io:	Pointer to Mc portal's I/O object
 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 * @major_ver:	Major version of Data Path Resource Container API
 * @minor_ver:	Minor version of Data Path Resource Container API
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_get_api_version(struct fsl_mc_io *mc_io,
			 u32 cmd_flags,
			 u16 *major_ver,
			 u16 *minor_ver)
{
	struct fsl_mc_command cmd = { 0 };
	int err;

	/* prepare command */
	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_API_VERSION,
					  cmd_flags, 0);

	/* send command to mc */
	err = mc_send_command(mc_io, &cmd);
	if (err)
		return err;

	/* retrieve response parameters */
	mc_cmd_read_api_version(&cmd, major_ver, minor_ver);

	return 0;
}

/**
 * dprc_get_container_id - Get container ID associated with a given portal.
 * @mc_io:		Pointer to Mc portal's I/O object
 * @cmd_flags:		Command flags; one or more of 'MC_CMD_FLAG_'
 * @container_id:	Requested container id
 *
 * Return:	'0' on Success; Error code otherwise.
 */
int dprc_get_container_id(struct fsl_mc_io *mc_io,
			  u32 cmd_flags,
			  int *container_id)
{
	struct fsl_mc_command cmd = { 0 };
	int err;

	/* prepare command */
	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
					  cmd_flags,
					  0);

	/* send command to mc*/
	err = mc_send_command(mc_io, &cmd);
	if (err)
		return err;

	/* retrieve response parameters */
	*container_id = (int)mc_cmd_read_object_id(&cmd);

	return 0;
}
Commit	Line	Data
203e2de3	1	// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
363b0cbf SY	2	/*
363b0cbf SY	3	* Copyright 2013-2016 Freescale Semiconductor Inc.
f86a1808	4	*
f86a1808	5	*/
409acdd0	6	#include <linux/kernel.h>
6bd067c4 BP	7	#include <linux/fsl/mc.h>
6bd067c4 BP	8
39d14e4e	9	#include "fsl-mc-private.h"
31c88965	10
e9bf3f20 GR	11	/**
	12	* dprc_open() - Open DPRC object for use
	13	* @mc_io: Pointer to MC portal's I/O object
	14	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	15	* @container_id: Container ID to open
	16	* @token: Returned token of DPRC object
	17	*
	18	* Return: '0' on Success; Error code otherwise.
	19	*
	20	* @warning Required before any operation on the object.
	21	*/
1ee695fa	22	int dprc_open(struct fsl_mc_io *mc_io,
ba72f25b	23	u32 cmd_flags,
1ee695fa	24	int container_id,
ba72f25b	25	u16 *token)
31c88965	26	{
5b04cede	27	struct fsl_mc_command cmd = { 0 };
9989b599	28	struct dprc_cmd_open *cmd_params;
31c88965 GR	29	int err;
	30
	31	/* prepare command */
1ee695fa	32	cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, cmd_flags,
31c88965	33	0);
9989b599 IR	34	cmd_params = (struct dprc_cmd_open *)cmd.params;
9989b599 IR	35	cmd_params->container_id = cpu_to_le32(container_id);
31c88965 GR	36
	37	/* send command to mc*/
	38	err = mc_send_command(mc_io, &cmd);
	39	if (err)
	40	return err;
	41
	42	/* retrieve response parameters */
9989b599	43	*token = mc_cmd_hdr_read_token(&cmd);
31c88965 GR	44
	45	return 0;
	46	}
c9d57ea0	47	EXPORT_SYMBOL_GPL(dprc_open);
31c88965	48
e9bf3f20 GR	49	/**
	50	* dprc_close() - Close the control session of the object
	51	* @mc_io: Pointer to MC portal's I/O object
	52	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	53	* @token: Token of DPRC object
	54	*
	55	* After this function is called, no further operations are
	56	* allowed on the object without opening a new control session.
	57	*
	58	* Return: '0' on Success; Error code otherwise.
	59	*/
1ee695fa	60	int dprc_close(struct fsl_mc_io *mc_io,
ba72f25b GR	61	u32 cmd_flags,
ba72f25b GR	62	u16 token)
31c88965	63	{
5b04cede	64	struct fsl_mc_command cmd = { 0 };
31c88965 GR	65
31c88965 GR	66	/* prepare command */
1ee695fa	67	cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags,
31c88965 GR	68	token);
	69
	70	/* send command to mc*/
	71	return mc_send_command(mc_io, &cmd);
	72	}
c9d57ea0	73	EXPORT_SYMBOL_GPL(dprc_close);
31c88965	74
e9bf3f20 GR	75	/**
	76	* dprc_set_irq() - Set IRQ information for the DPRC to trigger an interrupt.
	77	* @mc_io: Pointer to MC portal's I/O object
	78	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	79	* @token: Token of DPRC object
	80	* @irq_index: Identifies the interrupt index to configure
	81	* @irq_cfg: IRQ configuration
	82	*
	83	* Return: '0' on Success; Error code otherwise.
	84	*/
31c88965	85	int dprc_set_irq(struct fsl_mc_io *mc_io,
ba72f25b GR	86	u32 cmd_flags,
	87	u16 token,
	88	u8 irq_index,
1ee695fa	89	struct dprc_irq_cfg *irq_cfg)
31c88965	90	{
5b04cede	91	struct fsl_mc_command cmd = { 0 };
9989b599	92	struct dprc_cmd_set_irq *cmd_params;
31c88965 GR	93
	94	/* prepare command */
	95	cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ,
1ee695fa	96	cmd_flags,
31c88965	97	token);
9989b599 IR	98	cmd_params = (struct dprc_cmd_set_irq *)cmd.params;
	99	cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
	100	cmd_params->irq_index = irq_index;
	101	cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
	102	cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
31c88965 GR	103
	104	/* send command to mc*/
	105	return mc_send_command(mc_io, &cmd);
	106	}
	107
e9bf3f20 GR	108	/**
	109	* dprc_set_irq_enable() - Set overall interrupt state.
	110	* @mc_io: Pointer to MC portal's I/O object
	111	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	112	* @token: Token of DPRC object
	113	* @irq_index: The interrupt index to configure
	114	* @en: Interrupt state - enable = 1, disable = 0
	115	*
	116	* Allows GPP software to control when interrupts are generated.
	117	* Each interrupt can have up to 32 causes. The enable/disable control's the
	118	* overall interrupt state. if the interrupt is disabled no causes will cause
	119	* an interrupt.
	120	*
	121	* Return: '0' on Success; Error code otherwise.
	122	*/
31c88965	123	int dprc_set_irq_enable(struct fsl_mc_io *mc_io,
ba72f25b GR	124	u32 cmd_flags,
	125	u16 token,
	126	u8 irq_index,
	127	u8 en)
31c88965	128	{
5b04cede	129	struct fsl_mc_command cmd = { 0 };
9989b599	130	struct dprc_cmd_set_irq_enable *cmd_params;
31c88965 GR	131
	132	/* prepare command */
	133	cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_ENABLE,
1ee695fa	134	cmd_flags, token);
9989b599 IR	135	cmd_params = (struct dprc_cmd_set_irq_enable *)cmd.params;
	136	cmd_params->enable = en & DPRC_ENABLE;
	137	cmd_params->irq_index = irq_index;
31c88965 GR	138
	139	/* send command to mc*/
	140	return mc_send_command(mc_io, &cmd);
	141	}
	142
e9bf3f20 GR	143	/**
	144	* dprc_set_irq_mask() - Set interrupt mask.
	145	* @mc_io: Pointer to MC portal's I/O object
	146	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	147	* @token: Token of DPRC object
	148	* @irq_index: The interrupt index to configure
	149	* @mask: event mask to trigger interrupt;
	150	* each bit:
	151	* 0 = ignore event
	152	* 1 = consider event for asserting irq
	153	*
	154	* Every interrupt can have up to 32 causes and the interrupt model supports
	155	* masking/unmasking each cause independently
	156	*
	157	* Return: '0' on Success; Error code otherwise.
	158	*/
31c88965	159	int dprc_set_irq_mask(struct fsl_mc_io *mc_io,
ba72f25b GR	160	u32 cmd_flags,
	161	u16 token,
	162	u8 irq_index,
	163	u32 mask)
31c88965	164	{
5b04cede	165	struct fsl_mc_command cmd = { 0 };
9989b599	166	struct dprc_cmd_set_irq_mask *cmd_params;
31c88965 GR	167
	168	/* prepare command */
	169	cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_MASK,
1ee695fa	170	cmd_flags, token);
9989b599 IR	171	cmd_params = (struct dprc_cmd_set_irq_mask *)cmd.params;
	172	cmd_params->mask = cpu_to_le32(mask);
	173	cmd_params->irq_index = irq_index;
31c88965 GR	174
	175	/* send command to mc*/
	176	return mc_send_command(mc_io, &cmd);
	177	}
	178
e9bf3f20 GR	179	/**
	180	* dprc_get_irq_status() - Get the current status of any pending interrupts.
	181	* @mc_io: Pointer to MC portal's I/O object
	182	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	183	* @token: Token of DPRC object
	184	* @irq_index: The interrupt index to configure
	185	* @status: Returned interrupts status - one bit per cause:
	186	* 0 = no interrupt pending
	187	* 1 = interrupt pending
	188	*
	189	* Return: '0' on Success; Error code otherwise.
	190	*/
31c88965	191	int dprc_get_irq_status(struct fsl_mc_io *mc_io,
ba72f25b GR	192	u32 cmd_flags,
	193	u16 token,
	194	u8 irq_index,
	195	u32 *status)
31c88965	196	{
5b04cede	197	struct fsl_mc_command cmd = { 0 };
9989b599 IR	198	struct dprc_cmd_get_irq_status *cmd_params;
9989b599 IR	199	struct dprc_rsp_get_irq_status *rsp_params;
31c88965 GR	200	int err;
	201
	202	/* prepare command */
	203	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_STATUS,
1ee695fa	204	cmd_flags, token);
9989b599 IR	205	cmd_params = (struct dprc_cmd_get_irq_status *)cmd.params;
	206	cmd_params->status = cpu_to_le32(*status);
	207	cmd_params->irq_index = irq_index;
31c88965 GR	208
	209	/* send command to mc*/
	210	err = mc_send_command(mc_io, &cmd);
	211	if (err)
	212	return err;
	213
	214	/* retrieve response parameters */
9989b599 IR	215	rsp_params = (struct dprc_rsp_get_irq_status *)cmd.params;
9989b599 IR	216	*status = le32_to_cpu(rsp_params->status);
31c88965 GR	217
	218	return 0;
	219	}
	220
e9bf3f20 GR	221	/**
	222	* dprc_clear_irq_status() - Clear a pending interrupt's status
	223	* @mc_io: Pointer to MC portal's I/O object
	224	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	225	* @token: Token of DPRC object
	226	* @irq_index: The interrupt index to configure
	227	* @status: bits to clear (W1C) - one bit per cause:
	228	* 0 = don't change
	229	* 1 = clear status bit
	230	*
	231	* Return: '0' on Success; Error code otherwise.
	232	*/
31c88965	233	int dprc_clear_irq_status(struct fsl_mc_io *mc_io,
ba72f25b GR	234	u32 cmd_flags,
	235	u16 token,
	236	u8 irq_index,
	237	u32 status)
31c88965	238	{
5b04cede	239	struct fsl_mc_command cmd = { 0 };
9989b599	240	struct dprc_cmd_clear_irq_status *cmd_params;
31c88965 GR	241
	242	/* prepare command */
	243	cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLEAR_IRQ_STATUS,
1ee695fa	244	cmd_flags, token);
9989b599 IR	245	cmd_params = (struct dprc_cmd_clear_irq_status *)cmd.params;
	246	cmd_params->status = cpu_to_le32(status);
	247	cmd_params->irq_index = irq_index;
31c88965 GR	248
	249	/* send command to mc*/
	250	return mc_send_command(mc_io, &cmd);
	251	}
	252
e9bf3f20 GR	253	/**
	254	* dprc_get_attributes() - Obtains container attributes
	255	* @mc_io: Pointer to MC portal's I/O object
	256	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	257	* @token: Token of DPRC object
	258	* @attributes Returned container attributes
	259	*
	260	* Return: '0' on Success; Error code otherwise.
	261	*/
31c88965	262	int dprc_get_attributes(struct fsl_mc_io *mc_io,
ba72f25b GR	263	u32 cmd_flags,
ba72f25b GR	264	u16 token,
31c88965 GR	265	struct dprc_attributes *attr)
31c88965 GR	266	{
5b04cede	267	struct fsl_mc_command cmd = { 0 };
9989b599	268	struct dprc_rsp_get_attributes *rsp_params;
31c88965 GR	269	int err;
	270
	271	/* prepare command */
	272	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR,
1ee695fa	273	cmd_flags,
31c88965 GR	274	token);
	275
	276	/* send command to mc*/
	277	err = mc_send_command(mc_io, &cmd);
	278	if (err)
	279	return err;
	280
	281	/* retrieve response parameters */
9989b599 IR	282	rsp_params = (struct dprc_rsp_get_attributes *)cmd.params;
	283	attr->container_id = le32_to_cpu(rsp_params->container_id);
	284	attr->icid = le16_to_cpu(rsp_params->icid);
	285	attr->options = le32_to_cpu(rsp_params->options);
	286	attr->portal_id = le32_to_cpu(rsp_params->portal_id);
31c88965 GR	287
	288	return 0;
	289	}
	290
e9bf3f20 GR	291	/**
	292	* dprc_get_obj_count() - Obtains the number of objects in the DPRC
	293	* @mc_io: Pointer to MC portal's I/O object
	294	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	295	* @token: Token of DPRC object
	296	* @obj_count: Number of objects assigned to the DPRC
	297	*
	298	* Return: '0' on Success; Error code otherwise.
	299	*/
1ee695fa	300	int dprc_get_obj_count(struct fsl_mc_io *mc_io,
ba72f25b GR	301	u32 cmd_flags,
ba72f25b GR	302	u16 token,
1ee695fa	303	int *obj_count)
31c88965	304	{
5b04cede	305	struct fsl_mc_command cmd = { 0 };
9989b599	306	struct dprc_rsp_get_obj_count *rsp_params;
31c88965 GR	307	int err;
	308
	309	/* prepare command */
	310	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT,
1ee695fa	311	cmd_flags, token);
31c88965 GR	312
	313	/* send command to mc*/
	314	err = mc_send_command(mc_io, &cmd);
	315	if (err)
	316	return err;
	317
	318	/* retrieve response parameters */
9989b599 IR	319	rsp_params = (struct dprc_rsp_get_obj_count *)cmd.params;
9989b599 IR	320	*obj_count = le32_to_cpu(rsp_params->obj_count);
31c88965 GR	321
	322	return 0;
	323	}
c9d57ea0	324	EXPORT_SYMBOL_GPL(dprc_get_obj_count);
31c88965	325
e9bf3f20 GR	326	/**
	327	* dprc_get_obj() - Get general information on an object
	328	* @mc_io: Pointer to MC portal's I/O object
	329	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	330	* @token: Token of DPRC object
	331	* @obj_index: Index of the object to be queried (< obj_count)
	332	* @obj_desc: Returns the requested object descriptor
	333	*
	334	* The object descriptors are retrieved one by one by incrementing
	335	* obj_index up to (not including) the value of obj_count returned
	336	* from dprc_get_obj_count(). dprc_get_obj_count() must
	337	* be called prior to dprc_get_obj().
	338	*
	339	* Return: '0' on Success; Error code otherwise.
	340	*/
31c88965	341	int dprc_get_obj(struct fsl_mc_io *mc_io,
ba72f25b GR	342	u32 cmd_flags,
ba72f25b GR	343	u16 token,
31c88965	344	int obj_index,
0cf9f509	345	struct fsl_mc_obj_desc *obj_desc)
31c88965	346	{
5b04cede	347	struct fsl_mc_command cmd = { 0 };
9989b599 IR	348	struct dprc_cmd_get_obj *cmd_params;
9989b599 IR	349	struct dprc_rsp_get_obj *rsp_params;
31c88965 GR	350	int err;
	351
	352	/* prepare command */
	353	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ,
1ee695fa	354	cmd_flags,
31c88965	355	token);
9989b599 IR	356	cmd_params = (struct dprc_cmd_get_obj *)cmd.params;
9989b599 IR	357	cmd_params->obj_index = cpu_to_le32(obj_index);
31c88965 GR	358
	359	/* send command to mc*/
	360	err = mc_send_command(mc_io, &cmd);
	361	if (err)
	362	return err;
	363
	364	/* retrieve response parameters */
9989b599 IR	365	rsp_params = (struct dprc_rsp_get_obj *)cmd.params;
	366	obj_desc->id = le32_to_cpu(rsp_params->id);
	367	obj_desc->vendor = le16_to_cpu(rsp_params->vendor);
	368	obj_desc->irq_count = rsp_params->irq_count;
	369	obj_desc->region_count = rsp_params->region_count;
	370	obj_desc->state = le32_to_cpu(rsp_params->state);
	371	obj_desc->ver_major = le16_to_cpu(rsp_params->version_major);
	372	obj_desc->ver_minor = le16_to_cpu(rsp_params->version_minor);
	373	obj_desc->flags = le16_to_cpu(rsp_params->flags);
	374	strncpy(obj_desc->type, rsp_params->type, 16);
31c88965	375	obj_desc->type[15] = '\0';
9989b599	376	strncpy(obj_desc->label, rsp_params->label, 16);
1ee695fa	377	obj_desc->label[15] = '\0';
31c88965 GR	378	return 0;
31c88965 GR	379	}
c9d57ea0	380	EXPORT_SYMBOL_GPL(dprc_get_obj);
31c88965	381
e9bf3f20 GR	382	/**
	383	* dprc_set_obj_irq() - Set IRQ information for object to trigger an interrupt.
	384	* @mc_io: Pointer to MC portal's I/O object
	385	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	386	* @token: Token of DPRC object
	387	* @obj_type: Type of the object to set its IRQ
	388	* @obj_id: ID of the object to set its IRQ
	389	* @irq_index: The interrupt index to configure
	390	* @irq_cfg: IRQ configuration
	391	*
	392	* Return: '0' on Success; Error code otherwise.
	393	*/
1ee695fa	394	int dprc_set_obj_irq(struct fsl_mc_io *mc_io,
ba72f25b GR	395	u32 cmd_flags,
ba72f25b GR	396	u16 token,
1ee695fa GR	397	char *obj_type,
1ee695fa GR	398	int obj_id,
ba72f25b	399	u8 irq_index,
1ee695fa GR	400	struct dprc_irq_cfg *irq_cfg)
1ee695fa GR	401	{
5b04cede	402	struct fsl_mc_command cmd = { 0 };
9989b599	403	struct dprc_cmd_set_obj_irq *cmd_params;
1ee695fa GR	404
	405	/* prepare command */
	406	cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_OBJ_IRQ,
	407	cmd_flags,
	408	token);
9989b599 IR	409	cmd_params = (struct dprc_cmd_set_obj_irq *)cmd.params;
	410	cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
	411	cmd_params->irq_index = irq_index;
	412	cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
	413	cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
	414	cmd_params->obj_id = cpu_to_le32(obj_id);
	415	strncpy(cmd_params->obj_type, obj_type, 16);
	416	cmd_params->obj_type[15] = '\0';
1ee695fa GR	417
	418	/* send command to mc*/
	419	return mc_send_command(mc_io, &cmd);
	420	}
c9d57ea0	421	EXPORT_SYMBOL_GPL(dprc_set_obj_irq);
1ee695fa	422
e9bf3f20 GR	423	/**
	424	* dprc_get_obj_region() - Get region information for a specified object.
	425	* @mc_io: Pointer to MC portal's I/O object
	426	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	427	* @token: Token of DPRC object
	428	* @obj_type; Object type as returned in dprc_get_obj()
	429	* @obj_id: Unique object instance as returned in dprc_get_obj()
	430	* @region_index: The specific region to query
	431	* @region_desc: Returns the requested region descriptor
	432	*
	433	* Return: '0' on Success; Error code otherwise.
	434	*/
31c88965	435	int dprc_get_obj_region(struct fsl_mc_io *mc_io,
ba72f25b GR	436	u32 cmd_flags,
ba72f25b GR	437	u16 token,
31c88965 GR	438	char *obj_type,
31c88965 GR	439	int obj_id,
ba72f25b	440	u8 region_index,
31c88965 GR	441	struct dprc_region_desc *region_desc)
31c88965 GR	442	{
5b04cede	443	struct fsl_mc_command cmd = { 0 };
9989b599 IR	444	struct dprc_cmd_get_obj_region *cmd_params;
9989b599 IR	445	struct dprc_rsp_get_obj_region *rsp_params;
31c88965 GR	446	int err;
	447
	448	/* prepare command */
	449	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
1ee695fa	450	cmd_flags, token);
9989b599 IR	451	cmd_params = (struct dprc_cmd_get_obj_region *)cmd.params;
	452	cmd_params->obj_id = cpu_to_le32(obj_id);
	453	cmd_params->region_index = region_index;
	454	strncpy(cmd_params->obj_type, obj_type, 16);
	455	cmd_params->obj_type[15] = '\0';
31c88965 GR	456
	457	/* send command to mc*/
	458	err = mc_send_command(mc_io, &cmd);
	459	if (err)
	460	return err;
	461
	462	/* retrieve response parameters */
9989b599 IR	463	rsp_params = (struct dprc_rsp_get_obj_region *)cmd.params;
	464	region_desc->base_offset = le64_to_cpu(rsp_params->base_addr);
	465	region_desc->size = le32_to_cpu(rsp_params->size);
31c88965 GR	466
	467	return 0;
	468	}
c9d57ea0	469	EXPORT_SYMBOL_GPL(dprc_get_obj_region);
31c88965	470
decd3d0c IC	471	/**
	472	* dprc_get_api_version - Get Data Path Resource Container API version
	473	* @mc_io: Pointer to Mc portal's I/O object
	474	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	475	* @major_ver: Major version of Data Path Resource Container API
	476	* @minor_ver: Minor version of Data Path Resource Container API
	477	*
	478	* Return: '0' on Success; Error code otherwise.
	479	*/
	480	int dprc_get_api_version(struct fsl_mc_io *mc_io,
	481	u32 cmd_flags,
	482	u16 *major_ver,
	483	u16 *minor_ver)
	484	{
5b04cede	485	struct fsl_mc_command cmd = { 0 };
decd3d0c IC	486	int err;
	487
	488	/* prepare command */
	489	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_API_VERSION,
	490	cmd_flags, 0);
	491
	492	/* send command to mc */
	493	err = mc_send_command(mc_io, &cmd);
	494	if (err)
	495	return err;
	496
	497	/* retrieve response parameters */
	498	mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
	499
	500	return 0;
	501	}
	502
	503	/**
	504	* dprc_get_container_id - Get container ID associated with a given portal.
	505	* @mc_io: Pointer to Mc portal's I/O object
	506	* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
	507	* @container_id: Requested container id
	508	*
	509	* Return: '0' on Success; Error code otherwise.
	510	*/
	511	int dprc_get_container_id(struct fsl_mc_io *mc_io,
	512	u32 cmd_flags,
	513	int *container_id)
	514	{
5b04cede	515	struct fsl_mc_command cmd = { 0 };
decd3d0c IC	516	int err;
	517
	518	/* prepare command */
	519	cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
	520	cmd_flags,
	521	0);
	522
	523	/* send command to mc*/
	524	err = mc_send_command(mc_io, &cmd);
	525	if (err)
	526	return err;
	527
	528	/* retrieve response parameters */
	529	*container_id = (int)mc_cmd_read_object_id(&cmd);
	530
	531	return 0;
	532	}