1/* SPDX-License-Identifier: GPL-2.0+ */ 2/* 3 * (C) Copyright 2015 4 * Texas Instruments Incorporated - http://www.ti.com/ 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 */ 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/** 48 * struct dm_rproc_ops - Driver model remote proc operations. 49 * 50 * This defines the operations provided by remote proc driver. 51 */ 52struct dm_rproc_ops { 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 */ 63 int (*init)(struct udevice *dev); 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 */ 75 int (*load)(struct udevice *dev, ulong addr, ulong size); 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 */ 83 int (*start)(struct udevice *dev); 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 */ 91 int (*stop)(struct udevice *dev); 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 */ 99 int (*reset)(struct udevice *dev); 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 */ 107 int (*is_running)(struct udevice *dev); 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 */ 115 int (*ping)(struct udevice *dev); 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 125 * @size: Size of the memory region @da is pointing to 126 * @return virtual address. 127 */ 128 void * (*device_to_virt)(struct udevice *dev, ulong da, ulong size); 129}; 130 131/* Accessor */ 132#define rproc_get_ops(dev) ((struct dm_rproc_ops *)(dev)->driver->ops) 133 134#if CONFIG_IS_ENABLED(REMOTEPROC) 135/** 136 * rproc_init() - Initialize all bound remote proc devices 137 * @return 0 if all ok, else appropriate error value. 138 */ 139int rproc_init(void); 140 141/** 142 * rproc_dev_init() - Initialize a remote proc device based on id 143 * @id: id of the remote processor 144 * @return 0 if all ok, else appropriate error value. 145 */ 146int rproc_dev_init(int id); 147 148/** 149 * rproc_is_initialized() - check to see if remoteproc devices are initialized 150 * @return true if all devices are initialized, false otherwise. 151 */ 152bool rproc_is_initialized(void); 153 154/** 155 * rproc_load() - load binary or elf to a remote processor 156 * @id: id of the remote processor 157 * @addr: address in memory where the image is located 158 * @size: size of the image 159 * @return 0 if all ok, else appropriate error value. 160 */ 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 166 * @return 0 if all ok, else appropriate error value. 167 */ 168int rproc_start(int id); 169 170/** 171 * rproc_stop() - Stop a remote processor 172 * @id: id of the remote processor 173 * @return 0 if all ok, else appropriate error value. 174 */ 175int rproc_stop(int id); 176 177/** 178 * rproc_reset() - reset a remote processor 179 * @id: id of the remote processor 180 * @return 0 if all ok, else appropriate error value. 181 */ 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 187 * @return 0 if all ok, else appropriate error value. 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 192 */ 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 198 * @return 0 if running, 1 if not running, -ve on error. 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. 202 */ 203int rproc_is_running(int id); 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 */ 215int rproc_elf32_sanity_check(ulong addr, ulong size); 216 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 */ 227int rproc_elf64_sanity_check(ulong addr, ulong size); 228 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 */ 240int rproc_elf_sanity_check(ulong addr, ulong size); 241 242/** 243 * rproc_elf32_load_image() - load an ELF32 image 244 * @dev: device loading the ELF32 image 245 * @addr: valid ELF32 image address 246 * @size: size of the image 247 * @return 0 if the image is successfully loaded, else appropriate error value. 248 */ 249int rproc_elf32_load_image(struct udevice *dev, unsigned long addr, ulong size); 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 */ 258int rproc_elf64_load_image(struct udevice *dev, ulong addr, ulong size); 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 */ 269int rproc_elf_load_image(struct udevice *dev, unsigned long addr, ulong size); 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 */ 279ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr); 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 */ 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); 338#else 339static inline int rproc_init(void) { return -ENOSYS; } 340static inline int rproc_dev_init(int id) { return -ENOSYS; } 341static 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; } 348static inline int rproc_elf32_sanity_check(ulong addr, 349 ulong size) { return -ENOSYS; } 350static inline int rproc_elf64_sanity_check(ulong addr, 351 ulong size) { return -ENOSYS; } 352static inline int rproc_elf_sanity_check(ulong addr, 353 ulong size) { return -ENOSYS; } 354static inline int rproc_elf32_load_image(struct udevice *dev, 355 unsigned long addr, ulong size) 356{ return -ENOSYS; } 357static inline int rproc_elf64_load_image(struct udevice *dev, ulong addr, 358 ulong size) 359{ return -ENOSYS; } 360static inline int rproc_elf_load_image(struct udevice *dev, ulong addr, 361 ulong size) 362{ return -ENOSYS; } 363static inline ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr) 364{ return 0; } 365static 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; } 377#endif 378 379#endif /* _RPROC_H_ */ 380