1 /*
2 * Copyright (c) 2017-2021, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <errno.h>
9
10 #include <libfdt.h>
11
12 #include <platform_def.h>
13
14 #include <common/debug.h>
15 #include <common/fdt_wrappers.h>
16 #include <drivers/st/stm32_gpio.h>
17 #include <drivers/st/stm32mp1_ddr.h>
18 #include <drivers/st/stm32mp1_ram.h>
19
20 #include <stm32mp_dt.h>
21
22 static void *fdt;
23
24 /*******************************************************************************
25 * This function checks device tree file with its header.
26 * Returns 0 on success and a negative FDT error code on failure.
27 ******************************************************************************/
dt_open_and_check(uintptr_t dt_addr)28 int dt_open_and_check(uintptr_t dt_addr)
29 {
30 int ret;
31
32 ret = fdt_check_header((void *)dt_addr);
33 if (ret == 0) {
34 fdt = (void *)dt_addr;
35 }
36
37 return ret;
38 }
39
40 /*******************************************************************************
41 * This function gets the address of the DT.
42 * If DT is OK, fdt_addr is filled with DT address.
43 * Returns 1 if success, 0 otherwise.
44 ******************************************************************************/
fdt_get_address(void ** fdt_addr)45 int fdt_get_address(void **fdt_addr)
46 {
47 if (fdt == NULL) {
48 return 0;
49 }
50
51 *fdt_addr = fdt;
52
53 return 1;
54 }
55
56 /*******************************************************************************
57 * This function check the presence of a node (generic use of fdt library).
58 * Returns true if present, else return false.
59 ******************************************************************************/
fdt_check_node(int node)60 bool fdt_check_node(int node)
61 {
62 int len;
63 const char *cchar;
64
65 cchar = fdt_get_name(fdt, node, &len);
66
67 return (cchar != NULL) && (len >= 0);
68 }
69
70 /*******************************************************************************
71 * This function return global node status (generic use of fdt library).
72 ******************************************************************************/
fdt_get_status(int node)73 uint8_t fdt_get_status(int node)
74 {
75 uint8_t status = DT_DISABLED;
76 const char *cchar;
77
78 cchar = fdt_getprop(fdt, node, "status", NULL);
79 if ((cchar == NULL) ||
80 (strncmp(cchar, "okay", strlen("okay")) == 0)) {
81 status |= DT_NON_SECURE;
82 }
83
84 cchar = fdt_getprop(fdt, node, "secure-status", NULL);
85 if (cchar == NULL) {
86 if (status == DT_NON_SECURE) {
87 status |= DT_SECURE;
88 }
89 } else if (strncmp(cchar, "okay", strlen("okay")) == 0) {
90 status |= DT_SECURE;
91 }
92
93 return status;
94 }
95
96 #if ENABLE_ASSERTIONS
97 /*******************************************************************************
98 * This function returns the address cells from the node parent.
99 * Returns:
100 * - #address-cells value if success.
101 * - invalid value if error.
102 * - a default value if undefined #address-cells property as per libfdt
103 * implementation.
104 ******************************************************************************/
fdt_get_node_parent_address_cells(int node)105 static int fdt_get_node_parent_address_cells(int node)
106 {
107 int parent;
108
109 parent = fdt_parent_offset(fdt, node);
110 if (parent < 0) {
111 return -FDT_ERR_NOTFOUND;
112 }
113
114 return fdt_address_cells(fdt, parent);
115 }
116 #endif
117
118 /*******************************************************************************
119 * This function gets the stdout pin configuration information from the DT.
120 * And then calls the sub-function to treat it and set GPIO registers.
121 * Returns 0 on success and a negative FDT error code on failure.
122 ******************************************************************************/
dt_set_stdout_pinctrl(void)123 int dt_set_stdout_pinctrl(void)
124 {
125 int node;
126
127 node = fdt_get_stdout_node_offset(fdt);
128 if (node < 0) {
129 return -FDT_ERR_NOTFOUND;
130 }
131
132 return dt_set_pinctrl_config(node);
133 }
134
135 /*******************************************************************************
136 * This function fills the generic information from a given node.
137 ******************************************************************************/
dt_fill_device_info(struct dt_node_info * info,int node)138 void dt_fill_device_info(struct dt_node_info *info, int node)
139 {
140 const fdt32_t *cuint;
141
142 assert(fdt_get_node_parent_address_cells(node) == 1);
143
144 cuint = fdt_getprop(fdt, node, "reg", NULL);
145 if (cuint != NULL) {
146 info->base = fdt32_to_cpu(*cuint);
147 } else {
148 info->base = 0;
149 }
150
151 cuint = fdt_getprop(fdt, node, "clocks", NULL);
152 if (cuint != NULL) {
153 cuint++;
154 info->clock = (int)fdt32_to_cpu(*cuint);
155 } else {
156 info->clock = -1;
157 }
158
159 cuint = fdt_getprop(fdt, node, "resets", NULL);
160 if (cuint != NULL) {
161 cuint++;
162 info->reset = (int)fdt32_to_cpu(*cuint);
163 } else {
164 info->reset = -1;
165 }
166
167 info->status = fdt_get_status(node);
168 }
169
170 /*******************************************************************************
171 * This function retrieve the generic information from DT.
172 * Returns node on success and a negative FDT error code on failure.
173 ******************************************************************************/
dt_get_node(struct dt_node_info * info,int offset,const char * compat)174 int dt_get_node(struct dt_node_info *info, int offset, const char *compat)
175 {
176 int node;
177
178 node = fdt_node_offset_by_compatible(fdt, offset, compat);
179 if (node < 0) {
180 return -FDT_ERR_NOTFOUND;
181 }
182
183 dt_fill_device_info(info, node);
184
185 return node;
186 }
187
188 /*******************************************************************************
189 * This function gets the UART instance info of stdout from the DT.
190 * Returns node on success and a negative FDT error code on failure.
191 ******************************************************************************/
dt_get_stdout_uart_info(struct dt_node_info * info)192 int dt_get_stdout_uart_info(struct dt_node_info *info)
193 {
194 int node;
195
196 node = fdt_get_stdout_node_offset(fdt);
197 if (node < 0) {
198 return -FDT_ERR_NOTFOUND;
199 }
200
201 dt_fill_device_info(info, node);
202
203 return node;
204 }
205
206 /*******************************************************************************
207 * This function returns the node offset matching compatible string in the DT,
208 * and also matching the reg property with the given address.
209 * Returns value on success, and error value on failure.
210 ******************************************************************************/
dt_match_instance_by_compatible(const char * compatible,uintptr_t address)211 int dt_match_instance_by_compatible(const char *compatible, uintptr_t address)
212 {
213 int node;
214
215 fdt_for_each_compatible_node(fdt, node, compatible) {
216 const fdt32_t *cuint;
217
218 assert(fdt_get_node_parent_address_cells(node) == 1);
219
220 cuint = fdt_getprop(fdt, node, "reg", NULL);
221 if (cuint == NULL) {
222 continue;
223 }
224
225 if ((uintptr_t)fdt32_to_cpu(*cuint) == address) {
226 return node;
227 }
228 }
229
230 return -FDT_ERR_NOTFOUND;
231 }
232
233 /*******************************************************************************
234 * This function gets DDR size information from the DT.
235 * Returns value in bytes on success, and 0 on failure.
236 ******************************************************************************/
dt_get_ddr_size(void)237 uint32_t dt_get_ddr_size(void)
238 {
239 static uint32_t size;
240 int node;
241
242 if (size != 0U) {
243 return size;
244 }
245
246 node = fdt_node_offset_by_compatible(fdt, -1, DT_DDR_COMPAT);
247 if (node < 0) {
248 INFO("%s: Cannot read DDR node in DT\n", __func__);
249 return 0;
250 }
251
252 size = fdt_read_uint32_default(fdt, node, "st,mem-size", 0U);
253
254 flush_dcache_range((uintptr_t)&size, sizeof(uint32_t));
255
256 return size;
257 }
258
259 /*******************************************************************************
260 * This function gets PWR VDD regulator voltage information from the DT.
261 * Returns value in microvolts on success, and 0 on failure.
262 ******************************************************************************/
dt_get_pwr_vdd_voltage(void)263 uint32_t dt_get_pwr_vdd_voltage(void)
264 {
265 int node, pwr_regulators_node;
266 const fdt32_t *cuint;
267
268 node = fdt_node_offset_by_compatible(fdt, -1, DT_PWR_COMPAT);
269 if (node < 0) {
270 INFO("%s: Cannot read PWR node in DT\n", __func__);
271 return 0;
272 }
273
274 pwr_regulators_node = fdt_subnode_offset(fdt, node, "pwr-regulators");
275 if (pwr_regulators_node < 0) {
276 INFO("%s: Cannot read pwr-regulators node in DT\n", __func__);
277 return 0;
278 }
279
280 cuint = fdt_getprop(fdt, pwr_regulators_node, "vdd-supply", NULL);
281 if (cuint == NULL) {
282 return 0;
283 }
284
285 node = fdt_node_offset_by_phandle(fdt, fdt32_to_cpu(*cuint));
286 if (node < 0) {
287 return 0;
288 }
289
290 cuint = fdt_getprop(fdt, node, "regulator-min-microvolt", NULL);
291 if (cuint == NULL) {
292 return 0;
293 }
294
295 return fdt32_to_cpu(*cuint);
296 }
297
298 /*******************************************************************************
299 * This function retrieves board model from DT
300 * Returns string taken from model node, NULL otherwise
301 ******************************************************************************/
dt_get_board_model(void)302 const char *dt_get_board_model(void)
303 {
304 int node = fdt_path_offset(fdt, "/");
305
306 if (node < 0) {
307 return NULL;
308 }
309
310 return (const char *)fdt_getprop(fdt, node, "model", NULL);
311 }
312
313 /*******************************************************************************
314 * This function gets the pin count for a GPIO bank based from the FDT.
315 * It also checks node consistency.
316 ******************************************************************************/
fdt_get_gpio_bank_pin_count(unsigned int bank)317 int fdt_get_gpio_bank_pin_count(unsigned int bank)
318 {
319 int pinctrl_node;
320 int node;
321 uint32_t bank_offset;
322
323 pinctrl_node = stm32_get_gpio_bank_pinctrl_node(fdt, bank);
324 if (pinctrl_node < 0) {
325 return -FDT_ERR_NOTFOUND;
326 }
327
328 bank_offset = stm32_get_gpio_bank_offset(bank);
329
330 fdt_for_each_subnode(node, fdt, pinctrl_node) {
331 const fdt32_t *cuint;
332
333 if (fdt_getprop(fdt, node, "gpio-controller", NULL) == NULL) {
334 continue;
335 }
336
337 cuint = fdt_getprop(fdt, node, "reg", NULL);
338 if (cuint == NULL) {
339 continue;
340 }
341
342 if (fdt32_to_cpu(*cuint) != bank_offset) {
343 continue;
344 }
345
346 if (fdt_get_status(node) == DT_DISABLED) {
347 return 0;
348 }
349
350 cuint = fdt_getprop(fdt, node, "ngpios", NULL);
351 if (cuint == NULL) {
352 return -FDT_ERR_NOTFOUND;
353 }
354
355 return (int)fdt32_to_cpu(*cuint);
356 }
357
358 return 0;
359 }
360