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_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  */
 236 int 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  */
 245 int rproc_elf64_load_image(struct udevice *dev, ulong addr, ulong size);
 246 #else
 247 static inline int rproc_init(void) { return -ENOSYS; }
 248 static inline int rproc_dev_init(int id) { return -ENOSYS; }
 249 static inline bool rproc_is_initialized(void) { return false; }
 250 static inline int rproc_load(int id, ulong addr, ulong size) { return -ENOSYS; }
 251 static inline int rproc_start(int id) { return -ENOSYS; }
 252 static inline int rproc_stop(int id) { return -ENOSYS; }
 253 static inline int rproc_reset(int id) { return -ENOSYS; }
 254 static inline int rproc_ping(int id) { return -ENOSYS; }
 255 static inline int rproc_is_running(int id) { return -ENOSYS; }
 256 static inline int rproc_elf32_sanity_check(ulong addr,
 257                                            ulong size) { return -ENOSYS; }
 258 static inline int rproc_elf64_sanity_check(ulong addr,
 259                                            ulong size) { return -ENOSYS; }
 260 static inline int rproc_elf32_load_image(struct udevice *dev,
 261                                          unsigned long addr, ulong size)
 262 { return -ENOSYS; }
 263 static inline int rproc_elf64_load_image(struct udevice *dev, ulong addr,
 264                                          ulong size)
 265 { return -ENOSYS; }
 266 #endif
 267
 268 #endif  /* _RPROC_H_ */