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_plat() 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_elf32_load_image() - load an ELF32 image 231 * @dev: device loading the ELF32 image 232 * @addr: valid ELF32 image address 233 * @size: size of the image 234 * @return 0 if the image is successfully loaded, else appropriate error value. 235 */ 236int rproc_elf32_load_image(struct udevice *dev, unsigned long addr, ulong size); 237 238/** 239 * rproc_elf64_load_image() - load an ELF64 image 240 * @dev: device loading the ELF64 image 241 * @addr: valid ELF64 image address 242 * @size: size of the image 243 * @return 0 if the image is successfully loaded, else appropriate error value. 244 */ 245int rproc_elf64_load_image(struct udevice *dev, ulong addr, ulong size); 246 247/** 248 * rproc_elf_load_image() - load an ELF image 249 * @dev: device loading the ELF image 250 * @addr: valid ELF image address 251 * @size: size of the image 252 * 253 * Auto detects if the image is ELF32 or ELF64 image and load accordingly. 254 * @return 0 if the image is successfully loaded, else appropriate error value. 255 */ 256int rproc_elf_load_image(struct udevice *dev, unsigned long addr, ulong size); 257 258/** 259 * rproc_elf_get_boot_addr() - Get rproc's boot address. 260 * @dev: device loading the ELF image 261 * @addr: valid ELF image address 262 * 263 * This function returns the entry point address of the ELF 264 * image. 265 */ 266ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr); 267 268/** 269 * rproc_elf32_load_rsc_table() - load the resource table from an ELF32 image 270 * 271 * Search for the resource table in an ELF32 image, and if found, copy it to 272 * device memory. 273 * 274 * @dev: device loading the resource table 275 * @fw_addr: ELF image address 276 * @fw_size: size of the ELF image 277 * @rsc_addr: pointer to the found resource table address. Updated on 278 * operation success 279 * @rsc_size: pointer to the found resource table size. Updated on operation 280 * success 281 * 282 * @return 0 if a valid resource table is successfully loaded, -ENODATA if there 283 * is no resource table (which is optional), or another appropriate error value. 284 */ 285int rproc_elf32_load_rsc_table(struct udevice *dev, ulong fw_addr, 286 ulong fw_size, ulong *rsc_addr, ulong *rsc_size); 287/** 288 * rproc_elf64_load_rsc_table() - load the resource table from an ELF64 image 289 * 290 * Search for the resource table in an ELF64 image, and if found, copy it to 291 * device memory. 292 * 293 * @dev: device loading the resource table 294 * @fw_addr: ELF image address 295 * @fw_size: size of the ELF image 296 * @rsc_addr: pointer to the found resource table address. Updated on 297 * operation success 298 * @rsc_size: pointer to the found resource table size. Updated on operation 299 * success 300 * 301 * @return 0 if a valid resource table is successfully loaded, -ENODATA if there 302 * is no resource table (which is optional), or another appropriate error value. 303 */ 304int rproc_elf64_load_rsc_table(struct udevice *dev, ulong fw_addr, 305 ulong fw_size, ulong *rsc_addr, ulong *rsc_size); 306/** 307 * rproc_elf_load_rsc_table() - load the resource table from an ELF image 308 * 309 * Auto detects if the image is ELF32 or ELF64 image and search accordingly for 310 * the resource table, and if found, copy it to device memory. 311 * 312 * @dev: device loading the resource table 313 * @fw_addr: ELF image address 314 * @fw_size: size of the ELF image 315 * @rsc_addr: pointer to the found resource table address. Updated on 316 * operation success 317 * @rsc_size: pointer to the found resource table size. Updated on operation 318 * success 319 * 320 * @return 0 if a valid resource table is successfully loaded, -ENODATA if there 321 * is no resource table (which is optional), or another appropriate error value. 322 */ 323int rproc_elf_load_rsc_table(struct udevice *dev, ulong fw_addr, 324 ulong fw_size, ulong *rsc_addr, ulong *rsc_size); 325#else 326static inline int rproc_init(void) { return -ENOSYS; } 327static inline int rproc_dev_init(int id) { return -ENOSYS; } 328static inline bool rproc_is_initialized(void) { return false; } 329static inline int rproc_load(int id, ulong addr, ulong size) { return -ENOSYS; } 330static inline int rproc_start(int id) { return -ENOSYS; } 331static inline int rproc_stop(int id) { return -ENOSYS; } 332static inline int rproc_reset(int id) { return -ENOSYS; } 333static inline int rproc_ping(int id) { return -ENOSYS; } 334static inline int rproc_is_running(int id) { return -ENOSYS; } 335static inline int rproc_elf32_sanity_check(ulong addr, 336 ulong size) { return -ENOSYS; } 337static inline int rproc_elf64_sanity_check(ulong addr, 338 ulong size) { return -ENOSYS; } 339static inline int rproc_elf_sanity_check(ulong addr, 340 ulong size) { return -ENOSYS; } 341static inline int rproc_elf32_load_image(struct udevice *dev, 342 unsigned long addr, ulong size) 343{ return -ENOSYS; } 344static inline int rproc_elf64_load_image(struct udevice *dev, ulong addr, 345 ulong size) 346{ return -ENOSYS; } 347static inline int rproc_elf_load_image(struct udevice *dev, ulong addr, 348 ulong size) 349{ return -ENOSYS; } 350static inline ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr) 351{ return 0; } 352static inline int rproc_elf32_load_rsc_table(struct udevice *dev, ulong fw_addr, 353 ulong fw_size, ulong *rsc_addr, 354 ulong *rsc_size) 355{ return -ENOSYS; } 356static inline int rproc_elf64_load_rsc_table(struct udevice *dev, ulong fw_addr, 357 ulong fw_size, ulong *rsc_addr, 358 ulong *rsc_size) 359{ return -ENOSYS; } 360static inline int rproc_elf_load_rsc_table(struct udevice *dev, ulong fw_addr, 361 ulong fw_size, ulong *rsc_addr, 362 ulong *rsc_size) 363{ return -ENOSYS; } 364#endif 365 366#endif /* _RPROC_H_ */ 367