blob: a903acb9b24ffb9154758df2a480843082e30586 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001/* SPDX-License-Identifier: GPL-2.0+ */
Nishanth Menonddf56bc2015-09-17 15:42:39 -05002/*
3 * (C) Copyright 2015
4 * Texas Instruments Incorporated - http://www.ti.com/
Nishanth Menonddf56bc2015-09-17 15:42:39 -05005 */
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 */
27enum 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 */
41struct dm_rproc_uclass_pdata {
42 const char *name;
43 enum rproc_mem_type mem_type;
44 void *driver_plat_data;
45};
46
47/**
Fabien Dessenne31a839f2019-05-31 15:11:31 +020048 * struct dm_rproc_ops - Driver model remote proc operations.
49 *
50 * This defines the operations provided by remote proc driver.
Nishanth Menonddf56bc2015-09-17 15:42:39 -050051 */
52struct dm_rproc_ops {
Fabien Dessenne31a839f2019-05-31 15:11:31 +020053 /**
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 */
Nishanth Menonddf56bc2015-09-17 15:42:39 -050063 int (*init)(struct udevice *dev);
Fabien Dessenne31a839f2019-05-31 15:11:31 +020064
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 */
Nishanth Menonddf56bc2015-09-17 15:42:39 -050075 int (*load)(struct udevice *dev, ulong addr, ulong size);
Fabien Dessenne31a839f2019-05-31 15:11:31 +020076
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 */
Nishanth Menonddf56bc2015-09-17 15:42:39 -050083 int (*start)(struct udevice *dev);
Fabien Dessenne31a839f2019-05-31 15:11:31 +020084
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 */
Nishanth Menonddf56bc2015-09-17 15:42:39 -050091 int (*stop)(struct udevice *dev);
Fabien Dessenne31a839f2019-05-31 15:11:31 +020092
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 */
Nishanth Menonddf56bc2015-09-17 15:42:39 -050099 int (*reset)(struct udevice *dev);
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200100
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 */
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500107 int (*is_running)(struct udevice *dev);
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200108
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 */
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500115 int (*ping)(struct udevice *dev);
Fabien Dessenne163b7d72019-05-31 15:11:32 +0200116
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
Lokesh Vutlac08eb932019-09-04 16:01:27 +0530125 * @size: Size of the memory region @da is pointing to
Fabien Dessenne163b7d72019-05-31 15:11:32 +0200126 * @return virtual address.
127 */
Lokesh Vutlac08eb932019-09-04 16:01:27 +0530128 void * (*device_to_virt)(struct udevice *dev, ulong da, ulong size);
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500129};
130
131/* Accessor */
132#define rproc_get_ops(dev) ((struct dm_rproc_ops *)(dev)->driver->ops)
133
Suman Anna26557d12019-07-19 10:27:56 -0500134#if CONFIG_IS_ENABLED(REMOTEPROC)
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500135/**
136 * rproc_init() - Initialize all bound remote proc devices
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200137 * @return 0 if all ok, else appropriate error value.
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500138 */
139int rproc_init(void);
140
141/**
Lokesh Vutla81ae6e62018-08-27 15:57:50 +0530142 * rproc_dev_init() - Initialize a remote proc device based on id
143 * @id: id of the remote processor
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200144 * @return 0 if all ok, else appropriate error value.
Lokesh Vutla81ae6e62018-08-27 15:57:50 +0530145 */
146int rproc_dev_init(int id);
147
148/**
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500149 * rproc_is_initialized() - check to see if remoteproc devices are initialized
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200150 * @return true if all devices are initialized, false otherwise.
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500151 */
152bool rproc_is_initialized(void);
153
154/**
Fabien Dessenne7a7c4cb2019-05-31 15:11:33 +0200155 * rproc_load() - load binary or elf to a remote processor
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500156 * @id: id of the remote processor
Fabien Dessenne7a7c4cb2019-05-31 15:11:33 +0200157 * @addr: address in memory where the image is located
158 * @size: size of the image
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200159 * @return 0 if all ok, else appropriate error value.
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500160 */
161int rproc_load(int id, ulong addr, ulong size);
162
163/**
164 * rproc_start() - Start a remote processor
165 * @id: id of the remote processor
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200166 * @return 0 if all ok, else appropriate error value.
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500167 */
168int rproc_start(int id);
169
170/**
171 * rproc_stop() - Stop a remote processor
172 * @id: id of the remote processor
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200173 * @return 0 if all ok, else appropriate error value.
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500174 */
175int rproc_stop(int id);
176
177/**
178 * rproc_reset() - reset a remote processor
179 * @id: id of the remote processor
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200180 * @return 0 if all ok, else appropriate error value.
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500181 */
182int 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
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200187 * @return 0 if all ok, else appropriate error value.
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500188 *
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
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500192 */
193int 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
Fabien Dessenne31a839f2019-05-31 15:11:31 +0200198 * @return 0 if running, 1 if not running, -ve on error.
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500199 *
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.
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500202 */
203int rproc_is_running(int id);
Fabien Dessenne7a7c4cb2019-05-31 15:11:33 +0200204
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 */
215int rproc_elf32_sanity_check(ulong addr, ulong size);
216
217/**
Lokesh Vutlae3c4d6f2019-09-04 16:01:29 +0530218 * 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 */
227int rproc_elf64_sanity_check(ulong addr, ulong size);
228
229/**
Lokesh Vutla856c0ad2019-09-04 16:01:30 +0530230 * 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 */
240int rproc_elf_sanity_check(ulong addr, ulong size);
241
242/**
Fabien Dessenne7a7c4cb2019-05-31 15:11:33 +0200243 * rproc_elf32_load_image() - load an ELF32 image
244 * @dev: device loading the ELF32 image
245 * @addr: valid ELF32 image address
Lokesh Vutla14d963d2019-09-04 16:01:28 +0530246 * @size: size of the image
Fabien Dessenne7a7c4cb2019-05-31 15:11:33 +0200247 * @return 0 if the image is successfully loaded, else appropriate error value.
248 */
Lokesh Vutla14d963d2019-09-04 16:01:28 +0530249int rproc_elf32_load_image(struct udevice *dev, unsigned long addr, ulong size);
Lokesh Vutlae3c4d6f2019-09-04 16:01:29 +0530250
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 */
258int rproc_elf64_load_image(struct udevice *dev, ulong addr, ulong size);
Lokesh Vutla856c0ad2019-09-04 16:01:30 +0530259
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 */
269int rproc_elf_load_image(struct udevice *dev, unsigned long addr, ulong size);
Lokesh Vutla81e39fb2019-09-04 16:01:31 +0530270
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 */
279ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr);
Fabien Dessenneffcb8802019-10-30 14:38:28 +0100280
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 */
298int 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 */
317int 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 */
336int rproc_elf_load_rsc_table(struct udevice *dev, ulong fw_addr,
337 ulong fw_size, ulong *rsc_addr, ulong *rsc_size);
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500338#else
339static inline int rproc_init(void) { return -ENOSYS; }
Lokesh Vutla81ae6e62018-08-27 15:57:50 +0530340static inline int rproc_dev_init(int id) { return -ENOSYS; }
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500341static inline bool rproc_is_initialized(void) { return false; }
342static inline int rproc_load(int id, ulong addr, ulong size) { return -ENOSYS; }
343static inline int rproc_start(int id) { return -ENOSYS; }
344static inline int rproc_stop(int id) { return -ENOSYS; }
345static inline int rproc_reset(int id) { return -ENOSYS; }
346static inline int rproc_ping(int id) { return -ENOSYS; }
347static inline int rproc_is_running(int id) { return -ENOSYS; }
Fabien Dessenne7a7c4cb2019-05-31 15:11:33 +0200348static inline int rproc_elf32_sanity_check(ulong addr,
349 ulong size) { return -ENOSYS; }
Lokesh Vutlae3c4d6f2019-09-04 16:01:29 +0530350static inline int rproc_elf64_sanity_check(ulong addr,
351 ulong size) { return -ENOSYS; }
Lokesh Vutla856c0ad2019-09-04 16:01:30 +0530352static inline int rproc_elf_sanity_check(ulong addr,
353 ulong size) { return -ENOSYS; }
Fabien Dessenne7a7c4cb2019-05-31 15:11:33 +0200354static inline int rproc_elf32_load_image(struct udevice *dev,
Lokesh Vutla14d963d2019-09-04 16:01:28 +0530355 unsigned long addr, ulong size)
356{ return -ENOSYS; }
Lokesh Vutlae3c4d6f2019-09-04 16:01:29 +0530357static inline int rproc_elf64_load_image(struct udevice *dev, ulong addr,
358 ulong size)
359{ return -ENOSYS; }
Lokesh Vutla856c0ad2019-09-04 16:01:30 +0530360static inline int rproc_elf_load_image(struct udevice *dev, ulong addr,
361 ulong size)
362{ return -ENOSYS; }
Lokesh Vutla81e39fb2019-09-04 16:01:31 +0530363static inline ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr)
364{ return 0; }
Fabien Dessenneffcb8802019-10-30 14:38:28 +0100365static 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; }
369static 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; }
373static 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; }
Nishanth Menonddf56bc2015-09-17 15:42:39 -0500377#endif
378
379#endif /* _RPROC_H_ */