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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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 ******************************************************************************/ 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