include/remoteproc.h

   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  */
  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 /**
  48  * struct dm_rproc_ops - Driver model remote proc operations.
  49  *
  50  * This defines the operations provided by remote proc driver.
  51  */
  52 struct 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  */
 139 int 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  */
 146 int 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  */
 152 bool 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  */
 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
 166  * @return 0 if all ok, else appropriate error value.
 167  */
 168 int 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  */
 175 int 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  */
 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
 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  */
 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
 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  */
 203 int 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  */
 215 int 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  */
 227 int 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  */
 240 int 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  */
 249 int 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  */
 258 int 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  */
 269 int 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  */
 279 ulong 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  */
 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);
 338 #else
 339 static inline int rproc_init(void) { return -ENOSYS; }
 340 static inline int rproc_dev_init(int id) { return -ENOSYS; }
 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; }
 348 static inline int rproc_elf32_sanity_check(ulong addr,
 349                                            ulong size) { return -ENOSYS; }
 350 static inline int rproc_elf64_sanity_check(ulong addr,
 351                                            ulong size) { return -ENOSYS; }
 352 static inline int rproc_elf_sanity_check(ulong addr,
 353                                          ulong size) { return -ENOSYS; }
 354 static inline int rproc_elf32_load_image(struct udevice *dev,
 355                                          unsigned long addr, ulong size)
 356 { return -ENOSYS; }
 357 static inline int rproc_elf64_load_image(struct udevice *dev, ulong addr,
 358                                          ulong size)
 359 { return -ENOSYS; }
 360 static inline int rproc_elf_load_image(struct udevice *dev, ulong addr,
 361                                        ulong size)
 362 { return -ENOSYS; }
 363 static inline ulong rproc_elf_get_boot_addr(struct udevice *dev, ulong addr)
 364 { return 0; }
 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; }
 377 #endif
 378
 379 #endif  /* _RPROC_H_ */