blob: 391e5f0547e2d7b46cde5a09a186c801516d8882 [file] [log] [blame]
Yann Gautier9aea69e2018-07-24 17:13:36 +02001/*
Yann Gautier2260b842020-03-11 17:17:51 +01002 * Copyright (c) 2017-2020, ARM Limited and Contributors. All rights reserved.
Yann Gautier9aea69e2018-07-24 17:13:36 +02003 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7#include <assert.h>
Yann Gautier038bff22019-01-17 19:17:47 +01008#include <errno.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +00009
Yann Gautier9aea69e2018-07-24 17:13:36 +020010#include <libfdt.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000011
Yann Gautier9aea69e2018-07-24 17:13:36 +020012#include <platform_def.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000013
14#include <common/debug.h>
Andre Przywaracc99f3f2020-03-26 12:51:21 +000015#include <common/fdt_wrappers.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000016#include <drivers/st/stm32_gpio.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000017#include <drivers/st/stm32mp1_ddr.h>
18#include <drivers/st/stm32mp1_ram.h>
19
Yann Gautieree8f5422019-02-14 11:13:25 +010020#include <stm32mp_dt.h>
21
Yann Gautier9aea69e2018-07-24 17:13:36 +020022static int fdt_checked;
23
Yann Gautiera2e2a302019-02-14 11:13:39 +010024static void *fdt = (void *)(uintptr_t)STM32MP_DTB_BASE;
Yann Gautier9aea69e2018-07-24 17:13:36 +020025
26/*******************************************************************************
27 * This function checks device tree file with its header.
Yann Gautier038bff22019-01-17 19:17:47 +010028 * Returns 0 on success and a negative FDT error code on failure.
Yann Gautier9aea69e2018-07-24 17:13:36 +020029 ******************************************************************************/
30int dt_open_and_check(void)
31{
32 int ret = fdt_check_header(fdt);
33
34 if (ret == 0) {
35 fdt_checked = 1;
36 }
37
38 return ret;
39}
40
41/*******************************************************************************
42 * This function gets the address of the DT.
43 * If DT is OK, fdt_addr is filled with DT address.
44 * Returns 1 if success, 0 otherwise.
45 ******************************************************************************/
46int fdt_get_address(void **fdt_addr)
47{
48 if (fdt_checked == 1) {
49 *fdt_addr = fdt;
50 }
51
52 return fdt_checked;
53}
54
55/*******************************************************************************
56 * This function check the presence of a node (generic use of fdt library).
Yann Gautier038bff22019-01-17 19:17:47 +010057 * Returns true if present, else return false.
Yann Gautier9aea69e2018-07-24 17:13:36 +020058 ******************************************************************************/
59bool fdt_check_node(int node)
60{
61 int len;
62 const char *cchar;
63
64 cchar = fdt_get_name(fdt, node, &len);
65
66 return (cchar != NULL) && (len >= 0);
67}
68
69/*******************************************************************************
Yann Gautier038bff22019-01-17 19:17:47 +010070 * This function return global node status (generic use of fdt library).
Yann Gautier9aea69e2018-07-24 17:13:36 +020071 ******************************************************************************/
Yann Gautieree8f5422019-02-14 11:13:25 +010072uint8_t fdt_get_status(int node)
Yann Gautier9aea69e2018-07-24 17:13:36 +020073{
Yann Gautieree8f5422019-02-14 11:13:25 +010074 uint8_t status = DT_DISABLED;
Yann Gautier9aea69e2018-07-24 17:13:36 +020075 int len;
76 const char *cchar;
77
78 cchar = fdt_getprop(fdt, node, "status", &len);
Yann Gautier038bff22019-01-17 19:17:47 +010079 if ((cchar == NULL) ||
80 (strncmp(cchar, "okay", (size_t)len) == 0)) {
81 status |= DT_NON_SECURE;
Yann Gautier9aea69e2018-07-24 17:13:36 +020082 }
83
Yann Gautier9aea69e2018-07-24 17:13:36 +020084 cchar = fdt_getprop(fdt, node, "secure-status", &len);
85 if (cchar == NULL) {
Yann Gautier038bff22019-01-17 19:17:47 +010086 if (status == DT_NON_SECURE) {
87 status |= DT_SECURE;
88 }
89 } else if (strncmp(cchar, "okay", (size_t)len) == 0) {
90 status |= DT_SECURE;
Yann Gautier9aea69e2018-07-24 17:13:36 +020091 }
92
Yann Gautier038bff22019-01-17 19:17:47 +010093 return status;
Yann Gautier9aea69e2018-07-24 17:13:36 +020094}
95
Yann Gautier2260b842020-03-11 17:17:51 +010096#if ENABLE_ASSERTIONS
Yann Gautier9aea69e2018-07-24 17:13:36 +020097/*******************************************************************************
Lionel Debieveb0899eb2019-09-24 17:41:11 +020098 * 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 ******************************************************************************/
Yann Gautier2260b842020-03-11 17:17:51 +0100105static int fdt_get_node_parent_address_cells(int node)
Lionel Debieveb0899eb2019-09-24 17:41:11 +0200106{
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}
Yann Gautier2260b842020-03-11 17:17:51 +0100116#endif
Lionel Debieveb0899eb2019-09-24 17:41:11 +0200117
118/*******************************************************************************
Yann Gautier69035a82018-07-05 16:48:16 +0200119 * 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.
Yann Gautier038bff22019-01-17 19:17:47 +0100121 * Returns 0 on success and a negative FDT error code on failure.
Yann Gautier69035a82018-07-05 16:48:16 +0200122 ******************************************************************************/
123int dt_set_stdout_pinctrl(void)
124{
125 int node;
126
Andre Przywaraeec91922020-04-09 11:27:21 +0100127 node = fdt_get_stdout_node_offset(fdt);
Yann Gautier69035a82018-07-05 16:48:16 +0200128 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 ******************************************************************************/
138void dt_fill_device_info(struct dt_node_info *info, int node)
139{
140 const fdt32_t *cuint;
141
Lionel Debieveb0899eb2019-09-24 17:41:11 +0200142 assert(fdt_get_node_parent_address_cells(node) == 1);
143
Yann Gautier69035a82018-07-05 16:48:16 +0200144 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
Yann Gautier038bff22019-01-17 19:17:47 +0100167 info->status = fdt_get_status(node);
Yann Gautier69035a82018-07-05 16:48:16 +0200168}
169
170/*******************************************************************************
171 * This function retrieve the generic information from DT.
Yann Gautier038bff22019-01-17 19:17:47 +0100172 * Returns node on success and a negative FDT error code on failure.
Yann Gautier69035a82018-07-05 16:48:16 +0200173 ******************************************************************************/
174int 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.
Yann Gautier038bff22019-01-17 19:17:47 +0100190 * Returns node on success and a negative FDT error code on failure.
Yann Gautier69035a82018-07-05 16:48:16 +0200191 ******************************************************************************/
192int dt_get_stdout_uart_info(struct dt_node_info *info)
193{
194 int node;
195
Andre Przywaraeec91922020-04-09 11:27:21 +0100196 node = fdt_get_stdout_node_offset(fdt);
Yann Gautier69035a82018-07-05 16:48:16 +0200197 if (node < 0) {
198 return -FDT_ERR_NOTFOUND;
199 }
200
201 dt_fill_device_info(info, node);
202
203 return node;
204}
205
206/*******************************************************************************
Yann Gautiercaf575b2018-07-24 17:18:19 +0200207 * This function gets DDR size information from the DT.
Yann Gautier038bff22019-01-17 19:17:47 +0100208 * Returns value in bytes on success, and 0 on failure.
Yann Gautiercaf575b2018-07-24 17:18:19 +0200209 ******************************************************************************/
210uint32_t dt_get_ddr_size(void)
211{
212 int node;
213
214 node = fdt_node_offset_by_compatible(fdt, -1, DT_DDR_COMPAT);
215 if (node < 0) {
216 INFO("%s: Cannot read DDR node in DT\n", __func__);
Yann Gautier038bff22019-01-17 19:17:47 +0100217 return 0;
Yann Gautiercaf575b2018-07-24 17:18:19 +0200218 }
219
Andre Przywara2d5690c2020-03-26 11:50:33 +0000220 return fdt_read_uint32_default(fdt, node, "st,mem-size", 0);
Yann Gautiercaf575b2018-07-24 17:18:19 +0200221}
222
223/*******************************************************************************
Yann Gautier3edc7c32019-05-20 19:17:08 +0200224 * This function gets PWR VDD regulator voltage information from the DT.
225 * Returns value in microvolts on success, and 0 on failure.
226 ******************************************************************************/
227uint32_t dt_get_pwr_vdd_voltage(void)
228{
229 int node, pwr_regulators_node;
230 const fdt32_t *cuint;
231
232 node = fdt_node_offset_by_compatible(fdt, -1, DT_PWR_COMPAT);
233 if (node < 0) {
234 INFO("%s: Cannot read PWR node in DT\n", __func__);
235 return 0;
236 }
237
238 pwr_regulators_node = fdt_subnode_offset(fdt, node, "pwr-regulators");
Yann Gautierdf473922020-03-18 14:35:27 +0100239 if (pwr_regulators_node < 0) {
Yann Gautier3edc7c32019-05-20 19:17:08 +0200240 INFO("%s: Cannot read pwr-regulators node in DT\n", __func__);
241 return 0;
242 }
243
244 cuint = fdt_getprop(fdt, pwr_regulators_node, "vdd-supply", NULL);
245 if (cuint == NULL) {
246 return 0;
247 }
248
249 node = fdt_node_offset_by_phandle(fdt, fdt32_to_cpu(*cuint));
250 if (node < 0) {
251 return 0;
252 }
253
254 cuint = fdt_getprop(fdt, node, "regulator-min-microvolt", NULL);
255 if (cuint == NULL) {
256 return 0;
257 }
258
259 return fdt32_to_cpu(*cuint);
260}
261
262/*******************************************************************************
Yann Gautier69035a82018-07-05 16:48:16 +0200263 * This function retrieves board model from DT
264 * Returns string taken from model node, NULL otherwise
265 ******************************************************************************/
266const char *dt_get_board_model(void)
267{
268 int node = fdt_path_offset(fdt, "/");
269
270 if (node < 0) {
271 return NULL;
272 }
273
274 return (const char *)fdt_getprop(fdt, node, "model", NULL);
275}
Etienne Carriered81dadf2020-04-25 11:14:45 +0200276
277/*******************************************************************************
278 * This function gets the pin count for a GPIO bank based from the FDT.
279 * It also checks node consistency.
280 ******************************************************************************/
281int fdt_get_gpio_bank_pin_count(unsigned int bank)
282{
283 int pinctrl_node;
284 int node;
285 uint32_t bank_offset;
286
287 pinctrl_node = stm32_get_gpio_bank_pinctrl_node(fdt, bank);
288 if (pinctrl_node < 0) {
289 return -FDT_ERR_NOTFOUND;
290 }
291
292 bank_offset = stm32_get_gpio_bank_offset(bank);
293
294 fdt_for_each_subnode(node, fdt, pinctrl_node) {
295 const fdt32_t *cuint;
296
297 if (fdt_getprop(fdt, node, "gpio-controller", NULL) == NULL) {
298 continue;
299 }
300
301 cuint = fdt_getprop(fdt, node, "reg", NULL);
302 if (cuint == NULL) {
303 continue;
304 }
305
306 if (fdt32_to_cpu(*cuint) != bank_offset) {
307 continue;
308 }
309
310 if (fdt_get_status(node) == DT_DISABLED) {
311 return 0;
312 }
313
314 cuint = fdt_getprop(fdt, node, "ngpios", NULL);
315 if (cuint == NULL) {
316 return -FDT_ERR_NOTFOUND;
317 }
318
319 return (int)fdt32_to_cpu(*cuint);
320 }
321
322 return 0;
323}