1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*
3 * Copyright (c) 2016-2021, Linaro Limited
4 */
5
6 #ifndef KERNEL_DT_H
7 #define KERNEL_DT_H
8
9 #include <compiler.h>
10 #include <kernel/interrupt.h>
11 #include <kernel/panic.h>
12 #include <scattered_array.h>
13 #include <stdint.h>
14 #include <tee_api_types.h>
15 #include <types_ext.h>
16 #include <util.h>
17
18 /*
19 * Bitfield to reflect status and secure-status values ("okay", "disabled"
20 * or not present)
21 */
22 #define DT_STATUS_DISABLED U(0)
23 #define DT_STATUS_OK_NSEC BIT(0)
24 #define DT_STATUS_OK_SEC BIT(1)
25
26 #define DT_INFO_INVALID_REG ((paddr_t)-1)
27 #define DT_INFO_INVALID_REG_SIZE ((size_t)-1)
28 #define DT_INFO_INVALID_CLOCK -1
29 #define DT_INFO_INVALID_RESET -1
30 #define DT_INFO_INVALID_INTERRUPT -1
31
32 /*
33 * @status: Bit mask for DT_STATUS_*
34 * @reg: Device register physical base address or DT_INFO_INVALID_REG
35 * @reg_size: Device register size or DT_INFO_INVALID_REG_SIZE
36 * @clock: Device identifier (positive value) or DT_INFO_INVALID_CLOCK
37 * @reset: Device reset identifier (positive value) or DT_INFO_INVALID_CLOCK
38 * @interrupt: Device interrupt identifier (positive value) or
39 * DT_INFO_INVALID_INTERRUPT
40 * @type: IRQ_TYPE_* value parsed from interrupts properties or IRQ_TYPE_NONE if
41 * not present
42 * @prio: interrupt priority parsed from interrupts properties or 0 if not
43 * present
44 */
45 struct dt_node_info {
46 unsigned int status;
47 paddr_t reg;
48 size_t reg_size;
49 int clock;
50 int reset;
51 int interrupt;
52 uint32_t type;
53 uint32_t prio;
54 };
55
56 /*
57 * DT-aware drivers
58 */
59
60 struct dt_device_match {
61 const char *compatible;
62 const void *compat_data;
63 };
64
65 enum dt_driver_type {
66 DT_DRIVER_NOTYPE,
67 DT_DRIVER_UART,
68 DT_DRIVER_CLK,
69 DT_DRIVER_RSTCTRL,
70 };
71
72 /*
73 * DT_MAP_AUTO: Uses status properties from device tree to determine mapping.
74 * DT_MAP_SECURE: Force mapping for device to be secure.
75 * DT_MAP_NON_SECURE: Force mapping for device to be non-secure.
76 */
77 enum dt_map_dev_directive {
78 DT_MAP_AUTO,
79 DT_MAP_SECURE,
80 DT_MAP_NON_SECURE
81 };
82
83 /*
84 * dt_driver_probe_func - Callback probe function for a driver.
85 *
86 * @fdt: FDT base address
87 * @nodeoffset: Offset of the node in the FDT
88 * @compat_data: Data registered for the compatible that probed the device
89 *
90 * Return TEE_SUCCESS on successful probe,
91 * TEE_ERROR_DEFER_DRIVER_INIT if probe must be deferred
92 * TEE_ERROR_ITEM_NOT_FOUND when no driver matched node's compatible string
93 * Any other TEE_ERROR_* compliant code.
94 */
95 typedef TEE_Result (*dt_driver_probe_func)(const void *fdt, int nodeoffset,
96 const void *compat_data);
97
98 #if defined(CFG_DT)
99 /*
100 * Driver instance registered to be probed on compatible node found in the DT.
101 *
102 * @name: Driver name
103 * @type: Drive type
104 * @match_table: Compatible matching identifiers, null terminated
105 * @driver: Driver private reference or NULL
106 * @probe: Probe callback (see dt_driver_probe_func) or NULL
107 */
108 struct dt_driver {
109 const char *name;
110 enum dt_driver_type type;
111 const struct dt_device_match *match_table; /* null-terminated */
112 const void *driver;
113 TEE_Result (*probe)(const void *fdt, int node, const void *compat_data);
114 };
115
116 #define DEFINE_DT_DRIVER(name) \
117 SCATTERED_ARRAY_DEFINE_PG_ITEM(dt_drivers, struct dt_driver)
118
119 /*
120 * Find a driver that is suitable for the given DT node, that is, with
121 * a matching "compatible" property.
122 *
123 * @fdt: pointer to the device tree
124 * @offs: node offset
125 */
126 const struct dt_driver *dt_find_compatible_driver(const void *fdt, int offs);
127
128 /*
129 * Map a device into secure or non-secure memory and return the base VA and
130 * the mapping size. The mapping is done with type MEM_AREA_IO_SEC or
131 * MEM_AREA_IO_NSEC, depending on the device status.
132 * If the mapping already exists, the function simply returns the @vbase and
133 * @size information.
134 *
135 * @offs is the offset of the node that describes the device in @fdt.
136 * @base receives the base virtual address corresponding to the base physical
137 * address of the "reg" property
138 * @size receives the size of the mapping
139 * @mapping what kind of mapping is done for memory.
140 *
141 * Returns 0 on success or -1 in case of error.
142 */
143 int dt_map_dev(const void *fdt, int offs, vaddr_t *base, size_t *size,
144 enum dt_map_dev_directive mapping);
145
146 /*
147 * Check whether the node at @offs contains the property with propname or not.
148 *
149 * @offs is the offset of the node that describes the device in @fdt.
150 * @propname is the property that need to check
151 *
152 * Returns true on success or false if no propname.
153 */
154 bool dt_have_prop(const void *fdt, int offs, const char *propname);
155
156 /*
157 * Modify or add "status" property to "disabled"
158 *
159 * @fdt reference to the Device Tree
160 * @node is the node offset to modify
161 *
162 * Returns 0 on success or -1 on failure
163 */
164 int dt_disable_status(void *fdt, int node);
165
166 /*
167 * Force secure-status = "okay" and status="disabled" for the target node.
168 *
169 * @fdt reference to the Device Tree
170 * @node is the node offset to modify
171 *
172 * Returns 0 on success or -1 on failure
173 */
174 int dt_enable_secure_status(void *fdt, int node);
175
176 /*
177 * FDT manipulation functions, not provided by <libfdt.h>
178 */
179
180 /*
181 * Return the base address for the "reg" property of the specified node or
182 * (paddr_t)-1 in case of error
183 */
184 paddr_t _fdt_reg_base_address(const void *fdt, int offs);
185
186 /*
187 * Return the reg size for the reg property of the specified node or -1 in case
188 * of error
189 */
190 size_t _fdt_reg_size(const void *fdt, int offs);
191
192 /*
193 * Read the status and secure-status properties into a bitfield.
194 * Return -1 on failure, DT_STATUS_DISABLED if the node is disabled,
195 * otherwise return a combination of DT_STATUS_OK_NSEC and DT_STATUS_OK_SEC.
196 */
197 int _fdt_get_status(const void *fdt, int offs);
198
199 /*
200 * fdt_fill_device_info - Get generic device info from a node
201 *
202 * This function fills the generic information from a given node.
203 * Currently supports a single base register, a single clock,
204 * a single reset ID line and a single interrupt ID.
205 * Default DT_INFO_* macros are used when the relate property is not found.
206 */
207 void _fdt_fill_device_info(const void *fdt, struct dt_node_info *info,
208 int node);
209 /*
210 * Read cells from a given property of the given node. Any number of 32-bit
211 * cells of the property can be read. Returns 0 on success, or a negative
212 * FDT error value otherwise.
213 */
214 int _fdt_read_uint32_array(const void *fdt, int node, const char *prop_name,
215 uint32_t *array, size_t count);
216
217 /*
218 * Read one cell from a given property of the given node.
219 * Returns 0 on success, or a negative FDT error value otherwise.
220 */
221 int _fdt_read_uint32(const void *fdt, int node, const char *prop_name,
222 uint32_t *value);
223
224 /*
225 * Read one cell from a property of a cell or default to a given value
226 * Returns the 32bit cell value or @dflt_value on failure.
227 */
228 uint32_t _fdt_read_uint32_default(const void *fdt, int node,
229 const char *prop_name, uint32_t dflt_value);
230
231 /*
232 * Check whether the node at @node has a reference name.
233 *
234 * @node is the offset of the node that describes the device in @fdt.
235 *
236 * Returns true on success or false if no property
237 */
238 bool _fdt_check_node(const void *fdt, int node);
239
240 #else /* !CFG_DT */
241
dt_find_compatible_driver(const void * fdt __unused,int offs __unused)242 static inline const struct dt_driver *dt_find_compatible_driver(
243 const void *fdt __unused,
244 int offs __unused)
245 {
246 return NULL;
247 }
248
dt_map_dev(const void * fdt __unused,int offs __unused,vaddr_t * vbase __unused,size_t * size __unused,enum dt_map_dev_directive mapping __unused)249 static inline int dt_map_dev(const void *fdt __unused, int offs __unused,
250 vaddr_t *vbase __unused, size_t *size __unused,
251 enum dt_map_dev_directive mapping __unused)
252 {
253 return -1;
254 }
255
_fdt_reg_base_address(const void * fdt __unused,int offs __unused)256 static inline paddr_t _fdt_reg_base_address(const void *fdt __unused,
257 int offs __unused)
258 {
259 return (paddr_t)-1;
260 }
261
_fdt_reg_size(const void * fdt __unused,int offs __unused)262 static inline size_t _fdt_reg_size(const void *fdt __unused,
263 int offs __unused)
264 {
265 return (size_t)-1;
266 }
267
_fdt_get_status(const void * fdt __unused,int offs __unused)268 static inline int _fdt_get_status(const void *fdt __unused, int offs __unused)
269 {
270 return -1;
271 }
272
273 __noreturn
_fdt_fill_device_info(const void * fdt __unused,struct dt_node_info * info __unused,int node __unused)274 static inline void _fdt_fill_device_info(const void *fdt __unused,
275 struct dt_node_info *info __unused,
276 int node __unused)
277 {
278 panic();
279 }
280
_fdt_read_uint32_array(const void * fdt __unused,int node __unused,const char * prop_name __unused,uint32_t * array __unused,size_t count __unused)281 static inline int _fdt_read_uint32_array(const void *fdt __unused,
282 int node __unused,
283 const char *prop_name __unused,
284 uint32_t *array __unused,
285 size_t count __unused)
286 {
287 return -1;
288 }
289
_fdt_read_uint32(const void * fdt __unused,int node __unused,const char * prop_name __unused,uint32_t * value __unused)290 static inline int _fdt_read_uint32(const void *fdt __unused,
291 int node __unused,
292 const char *prop_name __unused,
293 uint32_t *value __unused)
294 {
295 return -1;
296 }
297
_fdt_read_uint32_default(const void * fdt __unused,int node __unused,const char * prop_name __unused,uint32_t dflt_value __unused)298 static inline uint32_t _fdt_read_uint32_default(const void *fdt __unused,
299 int node __unused,
300 const char *prop_name __unused,
301 uint32_t dflt_value __unused)
302 {
303 return dflt_value;
304 }
305
306 #endif /* !CFG_DT */
307
308 #define for_each_dt_driver(drv) \
309 for (drv = SCATTERED_ARRAY_BEGIN(dt_drivers, struct dt_driver); \
310 drv < SCATTERED_ARRAY_END(dt_drivers, struct dt_driver); \
311 drv++)
312
313 #endif /* KERNEL_DT_H */
314