remoteproc: fix function headers
[platform/kernel/u-boot.git] / 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 /* Accessor */
119 #define rproc_get_ops(dev) ((struct dm_rproc_ops *)(dev)->driver->ops)
120
121 #ifdef CONFIG_REMOTEPROC
122 /**
123  * rproc_init() - Initialize all bound remote proc devices
124  * @return 0 if all ok, else appropriate error value.
125  */
126 int rproc_init(void);
127
128 /**
129  * rproc_dev_init() - Initialize a remote proc device based on id
130  * @id:         id of the remote processor
131  * @return 0 if all ok, else appropriate error value.
132  */
133 int rproc_dev_init(int id);
134
135 /**
136  * rproc_is_initialized() - check to see if remoteproc devices are initialized
137  * @return true if all devices are initialized, false otherwise.
138  */
139 bool rproc_is_initialized(void);
140
141 /**
142  * rproc_load() - load binary to a remote processor
143  * @id:         id of the remote processor
144  * @addr:       address in memory where the binary image is located
145  * @size:       size of the binary image
146  * @return 0 if all ok, else appropriate error value.
147  */
148 int rproc_load(int id, ulong addr, ulong size);
149
150 /**
151  * rproc_start() - Start a remote processor
152  * @id:         id of the remote processor
153  * @return 0 if all ok, else appropriate error value.
154  */
155 int rproc_start(int id);
156
157 /**
158  * rproc_stop() - Stop a remote processor
159  * @id:         id of the remote processor
160  * @return 0 if all ok, else appropriate error value.
161  */
162 int rproc_stop(int id);
163
164 /**
165  * rproc_reset() - reset a remote processor
166  * @id:         id of the remote processor
167  * @return 0 if all ok, else appropriate error value.
168  */
169 int rproc_reset(int id);
170
171 /**
172  * rproc_ping() - ping a remote processor to check if it can communicate
173  * @id:         id of the remote processor
174  * @return 0 if all ok, else appropriate error value.
175  *
176  * NOTE: this might need communication path available, which is not implemented
177  * as part of remoteproc framework - hook on to appropriate bus architecture to
178  * do the same
179  */
180 int rproc_ping(int id);
181
182 /**
183  * rproc_is_running() - check to see if remote processor is running
184  * @id:         id of the remote processor
185  * @return 0 if running, 1 if not running, -ve on error.
186  *
187  * NOTE: this may not involve actual communication capability of the remote
188  * processor, but just ensures that it is out of reset and executing code.
189  */
190 int rproc_is_running(int id);
191 #else
192 static inline int rproc_init(void) { return -ENOSYS; }
193 static inline int rproc_dev_init(int id) { return -ENOSYS; }
194 static inline bool rproc_is_initialized(void) { return false; }
195 static inline int rproc_load(int id, ulong addr, ulong size) { return -ENOSYS; }
196 static inline int rproc_start(int id) { return -ENOSYS; }
197 static inline int rproc_stop(int id) { return -ENOSYS; }
198 static inline int rproc_reset(int id) { return -ENOSYS; }
199 static inline int rproc_ping(int id) { return -ENOSYS; }
200 static inline int rproc_is_running(int id) { return -ENOSYS; }
201 #endif
202
203 #endif  /* _RPROC_H_ */