[thirdparty/u-boot.git] / include / remoteproc.h

/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * (C) Copyright 2015
 * Texas Instruments Incorporated - http://www.ti.com/
 */

#ifndef _RPROC_H_
#define _RPROC_H_

/*
 * Note: The platform data support is not meant for use with newer
 * platforms. This is meant only for legacy devices. This mode of
 * initialization *will* be eventually removed once all necessary
 * platforms have moved to dm/fdt.
 */
#include <dm/platdata.h>	/* For platform data support - non dt world */

/**
 * enum rproc_mem_type - What type of memory model does the rproc use
 * @RPROC_INTERNAL_MEMORY_MAPPED: Remote processor uses own memory and is memory
 *	mapped to the host processor over an address range.
 *
 * Please note that this is an enumeration of memory model of different types
 * of remote processors. Few of the remote processors do have own internal
 * memories, while others use external memory for instruction and data.
 */
enum rproc_mem_type {
	RPROC_INTERNAL_MEMORY_MAPPED	= 0,
};

/**
 * struct dm_rproc_uclass_pdata - platform data for a CPU
 * @name: Platform-specific way of naming the Remote proc
 * @mem_type: one of 'enum rproc_mem_type'
 * @driver_plat_data: driver specific platform data that may be needed.
 *
 * This can be accessed with dev_get_uclass_platdata() for any UCLASS_REMOTEPROC
 * device.
 *
 */
struct dm_rproc_uclass_pdata {
	const char *name;
	enum rproc_mem_type mem_type;
	void *driver_plat_data;
};

/**
 * struct dm_rproc_ops - Driver model remote proc operations.
 *
 * This defines the operations provided by remote proc driver.
 */
struct dm_rproc_ops {
	/**
	 * init() - Initialize the remoteproc device (optional)
	 *
	 * This is called after the probe is completed allowing the remote
	 * processor drivers to split up the initializations between probe and
	 * init if needed.
	 *
	 * @dev:	Remote proc device
	 * @return 0 if all ok, else appropriate error value.
	 */
	int (*init)(struct udevice *dev);

	/**
	 * load() - Load the remoteproc device using data provided (mandatory)
	 *
	 * Load the remoteproc device with an image, do not start the device.
	 *
	 * @dev:	Remote proc device
	 * @addr:	Address of the image to be loaded
	 * @size:	Size of the image to be loaded
	 * @return 0 if all ok, else appropriate error value.
	 */
	int (*load)(struct udevice *dev, ulong addr, ulong size);

	/**
	 * start() - Start the remoteproc device (mandatory)
	 *
	 * @dev:	Remote proc device
	 * @return 0 if all ok, else appropriate error value.
	 */
	int (*start)(struct udevice *dev);

	/**
	 * stop() - Stop the remoteproc device (optional)
	 *
	 * @dev:	Remote proc device
	 * @return 0 if all ok, else appropriate error value.
	 */
	int (*stop)(struct udevice *dev);

	/**
	 * reset() - Reset the remoteproc device (optional)
	 *
	 * @dev:	Remote proc device
	 * @return 0 if all ok, else appropriate error value.
	 */
	int (*reset)(struct udevice *dev);

	/**
	 * is_running() - Check if the remote processor is running (optional)
	 *
	 * @dev:	Remote proc device
	 * @return 0 if running, 1 if not running, -ve on error.
	 */
	int (*is_running)(struct udevice *dev);

	/**
	 * ping() - Ping the remote device for basic communication (optional)
	 *
	 * @dev:	Remote proc device
	 * @return 0 on success, 1 if not responding, -ve on other errors.
	 */
	int (*ping)(struct udevice *dev);

	/**
	 * device_to_virt() - Return translated virtual address (optional)
	 *
	 * Translate a device address (remote processor view) to virtual
	 * address (main processor view).
	 *
	 * @dev:	Remote proc device
	 * @da:		Device address
	 * @size:	Size of the memory region @da is pointing to
	 * @return virtual address.
	 */
	void * (*device_to_virt)(struct udevice *dev, ulong da, ulong size);
};

/* Accessor */
#define rproc_get_ops(dev) ((struct dm_rproc_ops *)(dev)->driver->ops)

#if CONFIG_IS_ENABLED(REMOTEPROC)
/**
 * rproc_init() - Initialize all bound remote proc devices
 * @return 0 if all ok, else appropriate error value.
 */
int rproc_init(void);

/**
 * rproc_dev_init() - Initialize a remote proc device based on id
 * @id:		id of the remote processor
 * @return 0 if all ok, else appropriate error value.
 */
int rproc_dev_init(int id);

/**
 * rproc_is_initialized() - check to see if remoteproc devices are initialized
 * @return true if all devices are initialized, false otherwise.
 */
bool rproc_is_initialized(void);

/**
 * rproc_load() - load binary or elf to a remote processor
 * @id:		id of the remote processor
 * @addr:	address in memory where the image is located
 * @size:	size of the image
 * @return 0 if all ok, else appropriate error value.
 */
int rproc_load(int id, ulong addr, ulong size);

/**
 * rproc_start() - Start a remote processor
 * @id:		id of the remote processor
 * @return 0 if all ok, else appropriate error value.
 */
int rproc_start(int id);

/**
 * rproc_stop() - Stop a remote processor
 * @id:		id of the remote processor
 * @return 0 if all ok, else appropriate error value.
 */
int rproc_stop(int id);

/**
 * rproc_reset() - reset a remote processor
 * @id:		id of the remote processor
 * @return 0 if all ok, else appropriate error value.
 */
int rproc_reset(int id);

/**
 * rproc_ping() - ping a remote processor to check if it can communicate
 * @id:		id of the remote processor
 * @return 0 if all ok, else appropriate error value.
 *
 * NOTE: this might need communication path available, which is not implemented
 * as part of remoteproc framework - hook on to appropriate bus architecture to
 * do the same
 */
int rproc_ping(int id);

/**
 * rproc_is_running() - check to see if remote processor is running
 * @id:		id of the remote processor
 * @return 0 if running, 1 if not running, -ve on error.
 *
 * NOTE: this may not involve actual communication capability of the remote
 * processor, but just ensures that it is out of reset and executing code.
 */
int rproc_is_running(int id);

/**
 * rproc_elf32_sanity_check() - Verify if an image is a valid ELF32 one
 *
 * Check if a valid ELF32 image exists at the given memory location. Verify
 * basic ELF32 format requirements like magic number and sections size.
 *
 * @addr:	address of the image to verify
 * @size:	size of the image
 * @return 0 if the image looks good, else appropriate error value.
 */
int rproc_elf32_sanity_check(ulong addr, ulong size);

/**
 * rproc_elf64_sanity_check() - Verify if an image is a valid ELF32 one
 *
 * Check if a valid ELF64 image exists at the given memory location. Verify
 * basic ELF64 format requirements like magic number and sections size.
 *
 * @addr:	address of the image to verify
 * @size:	size of the image
 * @return 0 if the image looks good, else appropriate error value.
 */
int rproc_elf64_sanity_check(ulong addr, ulong size);

/**
 * rproc_elf_sanity_check() - Verify if an image is a valid ELF one
 *
 * Check if a valid ELF image exists at the given memory location. Auto
 * detects ELF32/ELF64 and verifies basic ELF64/ELF32 format requirements
 * like magic number and sections size.
 *
 * @addr:	address of the image to verify
 * @size:	size of the image
 * @return 0 if the image looks good, else appropriate error value.
 */
int rproc_elf_sanity_check(ulong addr, ulong size);

/**
 * rproc_elf32_load_image() - load an ELF32 image
 * @dev:	device loading the ELF32 image
 * @addr:	valid ELF32 image address
 * @size:	size of the image
 * @return 0 if the image is successfully loaded, else appropriate error value.
 */
int rproc_elf32_load_image(struct udevice *dev, unsigned long addr, ulong size);

/**
 * rproc_elf64_load_image() - load an ELF64 image
 * @dev:	device loading the ELF64 image
 * @addr:	valid ELF64 image address
 * @size:	size of the image
 * @return 0 if the image is successfully loaded, else appropriate error value.
 */
int rproc_elf64_load_image(struct udevice *dev, ulong addr, ulong size);

/**
 * rproc_elf_load_image() - load an ELF image
 * @dev:	device loading the ELF image
 * @addr:	valid ELF image address
 * @size:	size of the image
 *
 * Auto detects if the image is ELF32 or ELF64 image and load accordingly.
 * @return 0 if the image is successfully loaded, else appropriate error value.
 */
int rproc_elf_load_image(struct udevice *dev, unsigned long addr, ulong size);

/**
 * rproc_elf_get_boot_addr() - Get rproc's boot address.
 * @dev:	device loading the ELF image
 * @addr:	valid ELF image address
 *
 * This function returns the entry point address of the ELF
 * image.
 */
ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr);

/**
 * rproc_elf32_load_rsc_table() - load the resource table from an ELF32 image
 *
 * Search for the resource table in an ELF32 image, and if found, copy it to
 * device memory.
 *
 * @dev:	device loading the resource table
 * @fw_addr:	ELF image address
 * @fw_size:	size of the ELF image
 * @rsc_addr:	pointer to the found resource table address. Updated on
 *		operation success
 * @rsc_size:	pointer to the found resource table size. Updated on operation
 *		success
 *
 * @return 0 if a valid resource table is successfully loaded, -ENODATA if there
 * is no resource table (which is optional), or another appropriate error value.
 */
int rproc_elf32_load_rsc_table(struct udevice *dev, ulong fw_addr,
			       ulong fw_size, ulong *rsc_addr, ulong *rsc_size);
/**
 * rproc_elf64_load_rsc_table() - load the resource table from an ELF64 image
 *
 * Search for the resource table in an ELF64 image, and if found, copy it to
 * device memory.
 *
 * @dev:	device loading the resource table
 * @fw_addr:	ELF image address
 * @fw_size:	size of the ELF image
 * @rsc_addr:	pointer to the found resource table address. Updated on
 *		operation success
 * @rsc_size:	pointer to the found resource table size. Updated on operation
 *		success
 *
 * @return 0 if a valid resource table is successfully loaded, -ENODATA if there
 * is no resource table (which is optional), or another appropriate error value.
 */
int rproc_elf64_load_rsc_table(struct udevice *dev, ulong fw_addr,
			       ulong fw_size, ulong *rsc_addr, ulong *rsc_size);
/**
 * rproc_elf_load_rsc_table() - load the resource table from an ELF image
 *
 * Auto detects if the image is ELF32 or ELF64 image and search accordingly for
 * the resource table, and if found, copy it to device memory.
 *
 * @dev:	device loading the resource table
 * @fw_addr:	ELF image address
 * @fw_size:	size of the ELF image
 * @rsc_addr:	pointer to the found resource table address. Updated on
 *		operation success
 * @rsc_size:	pointer to the found resource table size. Updated on operation
 *		success
 *
 * @return 0 if a valid resource table is successfully loaded, -ENODATA if there
 * is no resource table (which is optional), or another appropriate error value.
 */
int rproc_elf_load_rsc_table(struct udevice *dev, ulong fw_addr,
			     ulong fw_size, ulong *rsc_addr, ulong *rsc_size);
#else
static inline int rproc_init(void) { return -ENOSYS; }
static inline int rproc_dev_init(int id) { return -ENOSYS; }
static inline bool rproc_is_initialized(void) { return false; }
static inline int rproc_load(int id, ulong addr, ulong size) { return -ENOSYS; }
static inline int rproc_start(int id) { return -ENOSYS; }
static inline int rproc_stop(int id) { return -ENOSYS; }
static inline int rproc_reset(int id) { return -ENOSYS; }
static inline int rproc_ping(int id) { return -ENOSYS; }
static inline int rproc_is_running(int id) { return -ENOSYS; }
static inline int rproc_elf32_sanity_check(ulong addr,
					   ulong size) { return -ENOSYS; }
static inline int rproc_elf64_sanity_check(ulong addr,
					   ulong size) { return -ENOSYS; }
static inline int rproc_elf_sanity_check(ulong addr,
					 ulong size) { return -ENOSYS; }
static inline int rproc_elf32_load_image(struct udevice *dev,
					 unsigned long addr, ulong size)
{ return -ENOSYS; }
static inline int rproc_elf64_load_image(struct udevice *dev, ulong addr,
					 ulong size)
{ return -ENOSYS; }
static inline int rproc_elf_load_image(struct udevice *dev, ulong addr,
				       ulong size)
{ return -ENOSYS; }
static inline ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr)
{ return 0; }
static inline int rproc_elf32_load_rsc_table(struct udevice *dev, ulong fw_addr,
					     ulong fw_size, ulong *rsc_addr,
					     ulong *rsc_size)
{ return -ENOSYS; }
static inline int rproc_elf64_load_rsc_table(struct udevice *dev, ulong fw_addr,
					     ulong fw_size, ulong *rsc_addr,
					     ulong *rsc_size)
{ return -ENOSYS; }
static inline int rproc_elf_load_rsc_table(struct udevice *dev, ulong fw_addr,
					   ulong fw_size, ulong *rsc_addr,
					   ulong *rsc_size)
{ return -ENOSYS; }
#endif

#endif	/* _RPROC_H_ */
Commit	Line	Data
83d290c5	1	/* SPDX-License-Identifier: GPL-2.0+ */
ddf56bc7 NM	2	/*
	3	* (C) Copyright 2015
	4	* Texas Instruments Incorporated - http://www.ti.com/
ddf56bc7 NM	5	*/
	6
	7	#ifndef _RPROC_H_
	8	#define _RPROC_H_
	9
	10	/*
	11	* Note: The platform data support is not meant for use with newer
	12	* platforms. This is meant only for legacy devices. This mode of
	13	* initialization will be eventually removed once all necessary
	14	* platforms have moved to dm/fdt.
	15	*/
	16	#include <dm/platdata.h> /* For platform data support - non dt world */
	17
	18	/**
	19	* enum rproc_mem_type - What type of memory model does the rproc use
	20	* @RPROC_INTERNAL_MEMORY_MAPPED: Remote processor uses own memory and is memory
	21	* mapped to the host processor over an address range.
	22	*
	23	* Please note that this is an enumeration of memory model of different types
	24	* of remote processors. Few of the remote processors do have own internal
	25	* memories, while others use external memory for instruction and data.
	26	*/
	27	enum rproc_mem_type {
	28	RPROC_INTERNAL_MEMORY_MAPPED = 0,
	29	};
	30
	31	/**
	32	* struct dm_rproc_uclass_pdata - platform data for a CPU
	33	* @name: Platform-specific way of naming the Remote proc
	34	* @mem_type: one of 'enum rproc_mem_type'
	35	* @driver_plat_data: driver specific platform data that may be needed.
	36	*
	37	* This can be accessed with dev_get_uclass_platdata() for any UCLASS_REMOTEPROC
	38	* device.
	39	*
	40	*/
	41	struct dm_rproc_uclass_pdata {
	42	const char *name;
	43	enum rproc_mem_type mem_type;
	44	void *driver_plat_data;
	45	};
	46
	47	/**
31a839f8 FD	48	* struct dm_rproc_ops - Driver model remote proc operations.
	49	*
	50	* This defines the operations provided by remote proc driver.
ddf56bc7 NM	51	*/
ddf56bc7 NM	52	struct dm_rproc_ops {
31a839f8 FD	53	/**
	54	* init() - Initialize the remoteproc device (optional)
	55	*
	56	* This is called after the probe is completed allowing the remote
	57	* processor drivers to split up the initializations between probe and
	58	* init if needed.
	59	*
	60	* @dev: Remote proc device
	61	* @return 0 if all ok, else appropriate error value.
	62	*/
ddf56bc7	63	int (init)(struct udevice dev);
31a839f8 FD	64
	65	/**
	66	* load() - Load the remoteproc device using data provided (mandatory)
	67	*
	68	* Load the remoteproc device with an image, do not start the device.
	69	*
	70	* @dev: Remote proc device
	71	* @addr: Address of the image to be loaded
	72	* @size: Size of the image to be loaded
	73	* @return 0 if all ok, else appropriate error value.
	74	*/
ddf56bc7	75	int (load)(struct udevice dev, ulong addr, ulong size);
31a839f8 FD	76
	77	/**
	78	* start() - Start the remoteproc device (mandatory)
	79	*
	80	* @dev: Remote proc device
	81	* @return 0 if all ok, else appropriate error value.
	82	*/
ddf56bc7	83	int (start)(struct udevice dev);
31a839f8 FD	84
	85	/**
	86	* stop() - Stop the remoteproc device (optional)
	87	*
	88	* @dev: Remote proc device
	89	* @return 0 if all ok, else appropriate error value.
	90	*/
ddf56bc7	91	int (stop)(struct udevice dev);
31a839f8 FD	92
	93	/**
	94	* reset() - Reset the remoteproc device (optional)
	95	*
	96	* @dev: Remote proc device
	97	* @return 0 if all ok, else appropriate error value.
	98	*/
ddf56bc7	99	int (reset)(struct udevice dev);
31a839f8 FD	100
	101	/**
	102	* is_running() - Check if the remote processor is running (optional)
	103	*
	104	* @dev: Remote proc device
	105	* @return 0 if running, 1 if not running, -ve on error.
	106	*/
ddf56bc7	107	int (is_running)(struct udevice dev);
31a839f8 FD	108
	109	/**
	110	* ping() - Ping the remote device for basic communication (optional)
	111	*
	112	* @dev: Remote proc device
	113	* @return 0 on success, 1 if not responding, -ve on other errors.
	114	*/
ddf56bc7	115	int (ping)(struct udevice dev);
163b7d77 FD	116
	117	/**
	118	* device_to_virt() - Return translated virtual address (optional)
	119	*
	120	* Translate a device address (remote processor view) to virtual
	121	* address (main processor view).
	122	*
	123	* @dev: Remote proc device
	124	* @da: Device address
c08eb936	125	* @size: Size of the memory region @da is pointing to
163b7d77 FD	126	* @return virtual address.
163b7d77 FD	127	*/
c08eb936	128	void * (device_to_virt)(struct udevice dev, ulong da, ulong size);
ddf56bc7 NM	129	};
	130
	131	/* Accessor */
	132	#define rproc_get_ops(dev) ((struct dm_rproc_ops *)(dev)->driver->ops)
	133
26557d10	134	#if CONFIG_IS_ENABLED(REMOTEPROC)
ddf56bc7 NM	135	/**
ddf56bc7 NM	136	* rproc_init() - Initialize all bound remote proc devices
31a839f8	137	* @return 0 if all ok, else appropriate error value.
ddf56bc7 NM	138	*/
	139	int rproc_init(void);
	140
81ae6e6d LV	141	/**
	142	* rproc_dev_init() - Initialize a remote proc device based on id
	143	* @id: id of the remote processor
31a839f8	144	* @return 0 if all ok, else appropriate error value.
81ae6e6d LV	145	*/
	146	int rproc_dev_init(int id);
	147
ddf56bc7 NM	148	/**
ddf56bc7 NM	149	* rproc_is_initialized() - check to see if remoteproc devices are initialized
31a839f8	150	* @return true if all devices are initialized, false otherwise.
ddf56bc7 NM	151	*/
	152	bool rproc_is_initialized(void);
	153
	154	/**
7a7c4cb0	155	* rproc_load() - load binary or elf to a remote processor
ddf56bc7	156	* @id: id of the remote processor
7a7c4cb0 FD	157	* @addr: address in memory where the image is located
7a7c4cb0 FD	158	* @size: size of the image
31a839f8	159	* @return 0 if all ok, else appropriate error value.
ddf56bc7 NM	160	*/
	161	int rproc_load(int id, ulong addr, ulong size);
	162
	163	/**
	164	* rproc_start() - Start a remote processor
	165	* @id: id of the remote processor
31a839f8	166	* @return 0 if all ok, else appropriate error value.
ddf56bc7 NM	167	*/
	168	int rproc_start(int id);
	169
	170	/**
	171	* rproc_stop() - Stop a remote processor
	172	* @id: id of the remote processor
31a839f8	173	* @return 0 if all ok, else appropriate error value.
ddf56bc7 NM	174	*/
	175	int rproc_stop(int id);
	176
	177	/**
	178	* rproc_reset() - reset a remote processor
	179	* @id: id of the remote processor
31a839f8	180	* @return 0 if all ok, else appropriate error value.
ddf56bc7 NM	181	*/
	182	int rproc_reset(int id);
	183
	184	/**
	185	* rproc_ping() - ping a remote processor to check if it can communicate
	186	* @id: id of the remote processor
31a839f8	187	* @return 0 if all ok, else appropriate error value.
ddf56bc7 NM	188	*
	189	* NOTE: this might need communication path available, which is not implemented
	190	* as part of remoteproc framework - hook on to appropriate bus architecture to
	191	* do the same
ddf56bc7 NM	192	*/
	193	int rproc_ping(int id);
	194
	195	/**
	196	* rproc_is_running() - check to see if remote processor is running
	197	* @id: id of the remote processor
31a839f8	198	* @return 0 if running, 1 if not running, -ve on error.
ddf56bc7 NM	199	*
	200	* NOTE: this may not involve actual communication capability of the remote
	201	* processor, but just ensures that it is out of reset and executing code.
ddf56bc7 NM	202	*/
ddf56bc7 NM	203	int rproc_is_running(int id);
7a7c4cb0 FD	204
	205	/**
	206	* rproc_elf32_sanity_check() - Verify if an image is a valid ELF32 one
	207	*
	208	* Check if a valid ELF32 image exists at the given memory location. Verify
	209	* basic ELF32 format requirements like magic number and sections size.
	210	*
	211	* @addr: address of the image to verify
	212	* @size: size of the image
	213	* @return 0 if the image looks good, else appropriate error value.
	214	*/
	215	int rproc_elf32_sanity_check(ulong addr, ulong size);
	216
e3c4d6f0 LV	217	/**
	218	* rproc_elf64_sanity_check() - Verify if an image is a valid ELF32 one
	219	*
	220	* Check if a valid ELF64 image exists at the given memory location. Verify
	221	* basic ELF64 format requirements like magic number and sections size.
	222	*
	223	* @addr: address of the image to verify
	224	* @size: size of the image
	225	* @return 0 if the image looks good, else appropriate error value.
	226	*/
	227	int rproc_elf64_sanity_check(ulong addr, ulong size);
	228
856c0ad4 LV	229	/**
	230	* rproc_elf_sanity_check() - Verify if an image is a valid ELF one
	231	*
	232	* Check if a valid ELF image exists at the given memory location. Auto
	233	* detects ELF32/ELF64 and verifies basic ELF64/ELF32 format requirements
	234	* like magic number and sections size.
	235	*
	236	* @addr: address of the image to verify
	237	* @size: size of the image
	238	* @return 0 if the image looks good, else appropriate error value.
	239	*/
	240	int rproc_elf_sanity_check(ulong addr, ulong size);
	241
7a7c4cb0 FD	242	/**
	243	* rproc_elf32_load_image() - load an ELF32 image
	244	* @dev: device loading the ELF32 image
	245	* @addr: valid ELF32 image address
14d963d1	246	* @size: size of the image
7a7c4cb0 FD	247	* @return 0 if the image is successfully loaded, else appropriate error value.
7a7c4cb0 FD	248	*/
14d963d1	249	int rproc_elf32_load_image(struct udevice *dev, unsigned long addr, ulong size);
e3c4d6f0 LV	250
	251	/**
	252	* rproc_elf64_load_image() - load an ELF64 image
	253	* @dev: device loading the ELF64 image
	254	* @addr: valid ELF64 image address
	255	* @size: size of the image
	256	* @return 0 if the image is successfully loaded, else appropriate error value.
	257	*/
	258	int rproc_elf64_load_image(struct udevice *dev, ulong addr, ulong size);
856c0ad4 LV	259
	260	/**
	261	* rproc_elf_load_image() - load an ELF image
	262	* @dev: device loading the ELF image
	263	* @addr: valid ELF image address
	264	* @size: size of the image
	265	*
	266	* Auto detects if the image is ELF32 or ELF64 image and load accordingly.
	267	* @return 0 if the image is successfully loaded, else appropriate error value.
	268	*/
	269	int rproc_elf_load_image(struct udevice *dev, unsigned long addr, ulong size);
81e39fbd LV	270
	271	/**
	272	* rproc_elf_get_boot_addr() - Get rproc's boot address.
	273	* @dev: device loading the ELF image
	274	* @addr: valid ELF image address
	275	*
	276	* This function returns the entry point address of the ELF
	277	* image.
	278	*/
	279	ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr);
ffcb880d FD	280
	281	/**
	282	* rproc_elf32_load_rsc_table() - load the resource table from an ELF32 image
	283	*
	284	* Search for the resource table in an ELF32 image, and if found, copy it to
	285	* device memory.
	286	*
	287	* @dev: device loading the resource table
	288	* @fw_addr: ELF image address
	289	* @fw_size: size of the ELF image
	290	* @rsc_addr: pointer to the found resource table address. Updated on
	291	* operation success
	292	* @rsc_size: pointer to the found resource table size. Updated on operation
	293	* success
	294	*
	295	* @return 0 if a valid resource table is successfully loaded, -ENODATA if there
	296	* is no resource table (which is optional), or another appropriate error value.
	297	*/
	298	int rproc_elf32_load_rsc_table(struct udevice *dev, ulong fw_addr,
	299	ulong fw_size, ulong rsc_addr, ulong rsc_size);
	300	/**
	301	* rproc_elf64_load_rsc_table() - load the resource table from an ELF64 image
	302	*
	303	* Search for the resource table in an ELF64 image, and if found, copy it to
	304	* device memory.
	305	*
	306	* @dev: device loading the resource table
	307	* @fw_addr: ELF image address
	308	* @fw_size: size of the ELF image
	309	* @rsc_addr: pointer to the found resource table address. Updated on
	310	* operation success
	311	* @rsc_size: pointer to the found resource table size. Updated on operation
	312	* success
	313	*
	314	* @return 0 if a valid resource table is successfully loaded, -ENODATA if there
	315	* is no resource table (which is optional), or another appropriate error value.
	316	*/
	317	int rproc_elf64_load_rsc_table(struct udevice *dev, ulong fw_addr,
	318	ulong fw_size, ulong rsc_addr, ulong rsc_size);
	319	/**
	320	* rproc_elf_load_rsc_table() - load the resource table from an ELF image
	321	*
	322	* Auto detects if the image is ELF32 or ELF64 image and search accordingly for
	323	* the resource table, and if found, copy it to device memory.
	324	*
	325	* @dev: device loading the resource table
	326	* @fw_addr: ELF image address
	327	* @fw_size: size of the ELF image
	328	* @rsc_addr: pointer to the found resource table address. Updated on
	329	* operation success
	330	* @rsc_size: pointer to the found resource table size. Updated on operation
	331	* success
	332	*
	333	* @return 0 if a valid resource table is successfully loaded, -ENODATA if there
	334	* is no resource table (which is optional), or another appropriate error value.
	335	*/
	336	int rproc_elf_load_rsc_table(struct udevice *dev, ulong fw_addr,
	337	ulong fw_size, ulong rsc_addr, ulong rsc_size);
ddf56bc7 NM	338	#else
ddf56bc7 NM	339	static inline int rproc_init(void) { return -ENOSYS; }
81ae6e6d	340	static inline int rproc_dev_init(int id) { return -ENOSYS; }
ddf56bc7 NM	341	static inline bool rproc_is_initialized(void) { return false; }
	342	static inline int rproc_load(int id, ulong addr, ulong size) { return -ENOSYS; }
	343	static inline int rproc_start(int id) { return -ENOSYS; }
	344	static inline int rproc_stop(int id) { return -ENOSYS; }
	345	static inline int rproc_reset(int id) { return -ENOSYS; }
	346	static inline int rproc_ping(int id) { return -ENOSYS; }
	347	static inline int rproc_is_running(int id) { return -ENOSYS; }
7a7c4cb0 FD	348	static inline int rproc_elf32_sanity_check(ulong addr,
7a7c4cb0 FD	349	ulong size) { return -ENOSYS; }
e3c4d6f0 LV	350	static inline int rproc_elf64_sanity_check(ulong addr,
e3c4d6f0 LV	351	ulong size) { return -ENOSYS; }
856c0ad4 LV	352	static inline int rproc_elf_sanity_check(ulong addr,
856c0ad4 LV	353	ulong size) { return -ENOSYS; }
7a7c4cb0	354	static inline int rproc_elf32_load_image(struct udevice *dev,
14d963d1 LV	355	unsigned long addr, ulong size)
14d963d1 LV	356	{ return -ENOSYS; }
e3c4d6f0 LV	357	static inline int rproc_elf64_load_image(struct udevice *dev, ulong addr,
	358	ulong size)
	359	{ return -ENOSYS; }
856c0ad4 LV	360	static inline int rproc_elf_load_image(struct udevice *dev, ulong addr,
	361	ulong size)
	362	{ return -ENOSYS; }
81e39fbd LV	363	static inline ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr)
81e39fbd LV	364	{ return 0; }
ffcb880d FD	365	static inline int rproc_elf32_load_rsc_table(struct udevice *dev, ulong fw_addr,
	366	ulong fw_size, ulong *rsc_addr,
	367	ulong *rsc_size)
	368	{ return -ENOSYS; }
	369	static inline int rproc_elf64_load_rsc_table(struct udevice *dev, ulong fw_addr,
	370	ulong fw_size, ulong *rsc_addr,
	371	ulong *rsc_size)
	372	{ return -ENOSYS; }
	373	static inline int rproc_elf_load_rsc_table(struct udevice *dev, ulong fw_addr,
	374	ulong fw_size, ulong *rsc_addr,
	375	ulong *rsc_size)
	376	{ return -ENOSYS; }
ddf56bc7 NM	377	#endif
	378
	379	#endif /* _RPROC_H_ */