Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
Gerald Van Baren | c4a57ea | 2007-04-06 14:19:43 -0400 | [diff] [blame] | 2 | /* |
| 3 | * (C) Copyright 2007 |
| 4 | * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com |
Gerald Van Baren | c4a57ea | 2007-04-06 14:19:43 -0400 | [diff] [blame] | 5 | */ |
| 6 | |
| 7 | #ifndef __FDT_SUPPORT_H |
| 8 | #define __FDT_SUPPORT_H |
| 9 | |
Troy Kisky | ab2307b | 2023-03-13 14:31:35 -0700 | [diff] [blame] | 10 | #if (defined(CONFIG_OF_LIBFDT) || defined(CONFIG_OF_CONTROL)) && \ |
| 11 | !defined(USE_HOSTCC) |
Gerald Van Baren | c4a57ea | 2007-04-06 14:19:43 -0400 | [diff] [blame] | 12 | |
Sean Anderson | c29f5a5 | 2019-12-17 21:21:54 -0500 | [diff] [blame] | 13 | #include <asm/u-boot.h> |
Masahiro Yamada | 75f82d0 | 2018-03-05 01:20:11 +0900 | [diff] [blame] | 14 | #include <linux/libfdt.h> |
Rasmus Villemoes | bd2e353 | 2022-08-22 09:34:23 +0200 | [diff] [blame] | 15 | #include <abuf.h> |
Gerald Van Baren | c4a57ea | 2007-04-06 14:19:43 -0400 | [diff] [blame] | 16 | |
Simon Glass | 3bbe70c | 2019-12-28 10:44:54 -0700 | [diff] [blame] | 17 | /** |
| 18 | * arch_fixup_fdt() - Write arch-specific information to fdt |
| 19 | * |
| 20 | * Defined in arch/$(ARCH)/lib/bootm-fdt.c |
| 21 | * |
| 22 | * @blob: FDT blob to write to |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 23 | * Return: 0 if ok, or -ve FDT_ERR_... on failure |
Simon Glass | 3bbe70c | 2019-12-28 10:44:54 -0700 | [diff] [blame] | 24 | */ |
| 25 | int arch_fixup_fdt(void *blob); |
| 26 | |
Masahiro Yamada | f7ed78b | 2020-06-26 15:13:33 +0900 | [diff] [blame] | 27 | void ft_cpu_setup(void *blob, struct bd_info *bd); |
Simon Glass | 3bbe70c | 2019-12-28 10:44:54 -0700 | [diff] [blame] | 28 | |
Masahiro Yamada | f7ed78b | 2020-06-26 15:13:33 +0900 | [diff] [blame] | 29 | void ft_pci_setup(void *blob, struct bd_info *bd); |
Simon Glass | 3bbe70c | 2019-12-28 10:44:54 -0700 | [diff] [blame] | 30 | |
Alexander Graf | 7c8a6cf | 2014-04-11 17:09:40 +0200 | [diff] [blame] | 31 | u32 fdt_getprop_u32_default_node(const void *fdt, int off, int cell, |
| 32 | const char *prop, const u32 dflt); |
Gabe Black | cd37de7 | 2011-11-08 01:09:44 -0800 | [diff] [blame] | 33 | u32 fdt_getprop_u32_default(const void *fdt, const char *path, |
| 34 | const char *prop, const u32 dflt); |
Paul Kocialkowski | 4795337 | 2015-05-24 12:01:53 +0200 | [diff] [blame] | 35 | |
| 36 | /** |
| 37 | * Add data to the root of the FDT before booting the OS. |
| 38 | * |
| 39 | * See doc/device-tree-bindings/root.txt |
| 40 | * |
| 41 | * @param fdt FDT address in memory |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 42 | * Return: 0 if ok, or -FDT_ERR_... on error |
Paul Kocialkowski | 4795337 | 2015-05-24 12:01:53 +0200 | [diff] [blame] | 43 | */ |
Paul Kocialkowski | 2c0fbc7 | 2015-05-21 11:27:03 +0200 | [diff] [blame] | 44 | int fdt_root(void *fdt); |
Paul Kocialkowski | 4795337 | 2015-05-24 12:01:53 +0200 | [diff] [blame] | 45 | |
| 46 | /** |
| 47 | * Add chosen data the FDT before booting the OS. |
| 48 | * |
| 49 | * In particular, this adds the kernel command line (bootargs) to the FDT. |
| 50 | * |
| 51 | * @param fdt FDT address in memory |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 52 | * Return: 0 if ok, or -FDT_ERR_... on error |
Paul Kocialkowski | 4795337 | 2015-05-24 12:01:53 +0200 | [diff] [blame] | 53 | */ |
Masahiro Yamada | 451c204 | 2014-04-18 17:41:00 +0900 | [diff] [blame] | 54 | int fdt_chosen(void *fdt); |
Paul Kocialkowski | 4795337 | 2015-05-24 12:01:53 +0200 | [diff] [blame] | 55 | |
| 56 | /** |
| 57 | * Add initrd information to the FDT before booting the OS. |
| 58 | * |
| 59 | * @param fdt FDT address in memory |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 60 | * Return: 0 if ok, or -FDT_ERR_... on error |
Paul Kocialkowski | 4795337 | 2015-05-24 12:01:53 +0200 | [diff] [blame] | 61 | */ |
Masahiro Yamada | 5b11489 | 2014-04-18 17:40:59 +0900 | [diff] [blame] | 62 | int fdt_initrd(void *fdt, ulong initrd_start, ulong initrd_end); |
Paul Kocialkowski | 4795337 | 2015-05-24 12:01:53 +0200 | [diff] [blame] | 63 | |
Kumar Gala | 7e64cf8 | 2007-11-03 19:46:28 -0500 | [diff] [blame] | 64 | void do_fixup_by_path(void *fdt, const char *path, const char *prop, |
| 65 | const void *val, int len, int create); |
| 66 | void do_fixup_by_path_u32(void *fdt, const char *path, const char *prop, |
| 67 | u32 val, int create); |
Chunhe Lan | 566f833 | 2011-08-31 10:36:32 +0800 | [diff] [blame] | 68 | |
| 69 | static inline void do_fixup_by_path_string(void *fdt, const char *path, |
| 70 | const char *prop, const char *status) |
| 71 | { |
| 72 | do_fixup_by_path(fdt, path, prop, status, strlen(status) + 1, 1); |
| 73 | } |
| 74 | |
Kumar Gala | 7590a19 | 2007-11-21 13:30:15 -0600 | [diff] [blame] | 75 | void do_fixup_by_prop(void *fdt, |
| 76 | const char *pname, const void *pval, int plen, |
| 77 | const char *prop, const void *val, int len, |
| 78 | int create); |
| 79 | void do_fixup_by_prop_u32(void *fdt, |
| 80 | const char *pname, const void *pval, int plen, |
| 81 | const char *prop, u32 val, int create); |
| 82 | void do_fixup_by_compat(void *fdt, const char *compat, |
| 83 | const char *prop, const void *val, int len, int create); |
| 84 | void do_fixup_by_compat_u32(void *fdt, const char *compat, |
| 85 | const char *prop, u32 val, int create); |
Andre Przywara | 3d2d441 | 2015-06-21 00:29:54 +0100 | [diff] [blame] | 86 | /** |
| 87 | * Setup the memory node in the DT. Creates one if none was existing before. |
| 88 | * Calls fdt_fixup_memory_banks() to populate a single reg pair covering the |
| 89 | * whole memory. |
| 90 | * |
| 91 | * @param blob FDT blob to update |
| 92 | * @param start Begin of DRAM mapping in physical memory |
| 93 | * @param size Size of the single memory bank |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 94 | * Return: 0 if ok, or -1 or -FDT_ERR_... on error |
Andre Przywara | 3d2d441 | 2015-06-21 00:29:54 +0100 | [diff] [blame] | 95 | */ |
Kumar Gala | 0db72ed | 2007-11-26 14:57:45 -0600 | [diff] [blame] | 96 | int fdt_fixup_memory(void *blob, u64 start, u64 size); |
Andre Przywara | 3d2d441 | 2015-06-21 00:29:54 +0100 | [diff] [blame] | 97 | |
| 98 | /** |
| 99 | * Fill the DT memory node with multiple memory banks. |
| 100 | * Creates the node if none was existing before. |
| 101 | * If banks is 0, it will not touch the existing reg property. This allows |
| 102 | * boards to not mess with the existing DT setup, which may have been |
| 103 | * filled in properly before. |
| 104 | * |
| 105 | * @param blob FDT blob to update |
| 106 | * @param start Array of size <banks> to hold the start addresses. |
| 107 | * @param size Array of size <banks> to hold the size of each region. |
| 108 | * @param banks Number of memory banks to create. If 0, the reg |
| 109 | * property will be left untouched. |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 110 | * Return: 0 if ok, or -1 or -FDT_ERR_... on error |
Andre Przywara | 3d2d441 | 2015-06-21 00:29:54 +0100 | [diff] [blame] | 111 | */ |
Masahiro Yamada | f6aa39e | 2016-11-26 11:02:10 +0900 | [diff] [blame] | 112 | #ifdef CONFIG_ARCH_FIXUP_FDT_MEMORY |
John Rigby | b4ae942 | 2010-10-13 13:57:33 -0600 | [diff] [blame] | 113 | int fdt_fixup_memory_banks(void *blob, u64 start[], u64 size[], int banks); |
Igor Opaniuk | 80b9578 | 2019-12-03 14:04:46 +0200 | [diff] [blame] | 114 | int fdt_set_usable_memory(void *blob, u64 start[], u64 size[], int banks); |
Masahiro Yamada | f6aa39e | 2016-11-26 11:02:10 +0900 | [diff] [blame] | 115 | #else |
| 116 | static inline int fdt_fixup_memory_banks(void *blob, u64 start[], u64 size[], |
| 117 | int banks) |
| 118 | { |
| 119 | return 0; |
| 120 | } |
| 121 | #endif |
Andre Przywara | 3d2d441 | 2015-06-21 00:29:54 +0100 | [diff] [blame] | 122 | |
Kumar Gala | fabda92 | 2008-08-19 15:41:18 -0500 | [diff] [blame] | 123 | void fdt_fixup_ethernet(void *fdt); |
Matthias Fuchs | 21d2916 | 2007-12-28 11:56:30 +0100 | [diff] [blame] | 124 | int fdt_find_and_setprop(void *fdt, const char *node, const char *prop, |
| 125 | const void *val, int len, int create); |
Timur Tabi | 6d838da | 2008-01-07 13:31:19 -0600 | [diff] [blame] | 126 | void fdt_fixup_qe_firmware(void *fdt); |
Gerald Van Baren | c4a57ea | 2007-04-06 14:19:43 -0400 | [diff] [blame] | 127 | |
Tim Harvey | 5d7c6b5 | 2015-04-08 11:45:39 -0700 | [diff] [blame] | 128 | /** |
| 129 | * Update native-mode property of display-timings node to the phandle |
| 130 | * of the timings matching a display by name (case insensitive). |
| 131 | * |
| 132 | * see kernel Documentation/devicetree/bindings/video/display-timing.txt |
| 133 | * |
| 134 | * @param blob FDT blob to update |
| 135 | * @param path path within dt |
| 136 | * @param display name of display timing to match |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 137 | * Return: 0 if ok, or -FDT_ERR_... on error |
Tim Harvey | 5d7c6b5 | 2015-04-08 11:45:39 -0700 | [diff] [blame] | 138 | */ |
| 139 | int fdt_fixup_display(void *blob, const char *path, const char *display); |
| 140 | |
Sriram Dash | 2510ff5 | 2016-04-05 14:41:21 +0530 | [diff] [blame] | 141 | #if defined(CONFIG_USB_EHCI_FSL) || defined(CONFIG_USB_XHCI_FSL) |
Masahiro Yamada | f7ed78b | 2020-06-26 15:13:33 +0900 | [diff] [blame] | 142 | void fsl_fdt_fixup_dr_usb(void *blob, struct bd_info *bd); |
Anton Vorontsov | 07e6091 | 2008-03-14 23:20:18 +0300 | [diff] [blame] | 143 | #else |
Masahiro Yamada | f7ed78b | 2020-06-26 15:13:33 +0900 | [diff] [blame] | 144 | static inline void fsl_fdt_fixup_dr_usb(void *blob, struct bd_info *bd) {} |
Sriram Dash | 2510ff5 | 2016-04-05 14:41:21 +0530 | [diff] [blame] | 145 | #endif /* defined(CONFIG_USB_EHCI_FSL) || defined(CONFIG_USB_XHCI_FSL) */ |
Anton Vorontsov | 07e6091 | 2008-03-14 23:20:18 +0300 | [diff] [blame] | 146 | |
Kim Phillips | def125f | 2010-06-01 12:24:27 -0500 | [diff] [blame] | 147 | #if defined(CONFIG_SYS_FSL_SEC_COMPAT) |
Kim Phillips | 868e346 | 2008-06-16 15:55:53 -0500 | [diff] [blame] | 148 | void fdt_fixup_crypto_node(void *blob, int sec_rev); |
| 149 | #else |
| 150 | static inline void fdt_fixup_crypto_node(void *blob, int sec_rev) {} |
| 151 | #endif |
| 152 | |
Philipp Tomsich | a601818 | 2017-09-13 21:29:33 +0200 | [diff] [blame] | 153 | /** |
| 154 | * Record information about a processed loadable in /fit-images (creating |
| 155 | * /fit-images if necessary). |
| 156 | * |
| 157 | * @param blob FDT blob to update |
| 158 | * @param index index of this loadable |
| 159 | * @param name name of the loadable |
| 160 | * @param load_addr address the loadable was loaded to |
| 161 | * @param size number of bytes loaded |
| 162 | * @param entry_point entry point (if specified, otherwise pass -1) |
| 163 | * @param type type (if specified, otherwise pass NULL) |
| 164 | * @param os os-type (if specified, otherwise pass NULL) |
Michal Simek | 0e4f43d | 2021-05-27 11:40:09 +0200 | [diff] [blame] | 165 | * @param arch architecture (if specified, otherwise pass NULL) |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 166 | * Return: 0 if ok, or -1 or -FDT_ERR_... on error |
Philipp Tomsich | a601818 | 2017-09-13 21:29:33 +0200 | [diff] [blame] | 167 | */ |
| 168 | int fdt_record_loadable(void *blob, u32 index, const char *name, |
| 169 | uintptr_t load_addr, u32 size, uintptr_t entry_point, |
Michal Simek | 0e4f43d | 2021-05-27 11:40:09 +0200 | [diff] [blame] | 170 | const char *type, const char *os, const char *arch); |
Philipp Tomsich | a601818 | 2017-09-13 21:29:33 +0200 | [diff] [blame] | 171 | |
Kumar Gala | e0475cd | 2008-10-22 23:33:56 -0500 | [diff] [blame] | 172 | #ifdef CONFIG_PCI |
| 173 | #include <pci.h> |
| 174 | int fdt_pci_dma_ranges(void *blob, int phb_off, struct pci_controller *hose); |
| 175 | #endif |
| 176 | |
Simon Glass | 014aa05 | 2014-10-23 18:58:49 -0600 | [diff] [blame] | 177 | int fdt_find_or_add_subnode(void *fdt, int parentoffset, const char *name); |
| 178 | |
Simon Glass | 2aec3cc | 2014-10-23 18:58:47 -0600 | [diff] [blame] | 179 | /** |
| 180 | * Add board-specific data to the FDT before booting the OS. |
| 181 | * |
| 182 | * Use CONFIG_SYS_FDT_PAD to ensure there is sufficient space. |
Simon Glass | f3dd50b | 2014-10-23 18:58:53 -0600 | [diff] [blame] | 183 | * This function is called if CONFIG_OF_BOARD_SETUP is defined |
Simon Glass | 2aec3cc | 2014-10-23 18:58:47 -0600 | [diff] [blame] | 184 | * |
| 185 | * @param blob FDT blob to update |
Masahiro Yamada | 940a922 | 2020-06-26 15:13:34 +0900 | [diff] [blame] | 186 | * @param bd Pointer to board data |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 187 | * Return: 0 if ok, or -FDT_ERR_... on error |
Simon Glass | 2aec3cc | 2014-10-23 18:58:47 -0600 | [diff] [blame] | 188 | */ |
Masahiro Yamada | f7ed78b | 2020-06-26 15:13:33 +0900 | [diff] [blame] | 189 | int ft_board_setup(void *blob, struct bd_info *bd); |
Simon Glass | 2aec3cc | 2014-10-23 18:58:47 -0600 | [diff] [blame] | 190 | |
Niko Mauno | 673db43 | 2021-02-22 19:18:51 +0000 | [diff] [blame] | 191 | /** |
Rasmus Villemoes | bd2e353 | 2022-08-22 09:34:23 +0200 | [diff] [blame] | 192 | * board_rng_seed() - Provide a seed to be passed via /chosen/rng-seed |
| 193 | * |
| 194 | * This function is called if CONFIG_BOARD_RNG_SEED is set, and must |
| 195 | * be provided by the board. It should return, via @buf, some suitable |
| 196 | * seed value to pass to the kernel. |
| 197 | * |
| 198 | * @param buf A struct abuf for returning the seed and its size. |
| 199 | * @return 0 if ok, negative on error. |
| 200 | */ |
| 201 | int board_rng_seed(struct abuf *buf); |
| 202 | |
| 203 | /** |
Niko Mauno | 673db43 | 2021-02-22 19:18:51 +0000 | [diff] [blame] | 204 | * board_fdt_chosen_bootargs() - Arbitrarily amend fdt kernel command line |
| 205 | * |
| 206 | * This is used for late modification of kernel command line arguments just |
| 207 | * before they are added into the /chosen node in flat device tree. |
| 208 | * |
| 209 | * @return: pointer to kernel command line arguments in memory |
| 210 | */ |
| 211 | char *board_fdt_chosen_bootargs(void); |
| 212 | |
Vitaly Andrianov | a122cbb | 2014-04-04 13:16:47 -0400 | [diff] [blame] | 213 | /* |
| 214 | * The keystone2 SOC requires all 32 bit aliased addresses to be converted |
| 215 | * to their 36 physical format. This has to happen after all fdt nodes |
| 216 | * are added or modified by the image_setup_libfdt(). The ft_board_setup_ex() |
| 217 | * called at the end of the image_setup_libfdt() is to do that convertion. |
| 218 | */ |
Masahiro Yamada | f7ed78b | 2020-06-26 15:13:33 +0900 | [diff] [blame] | 219 | void ft_board_setup_ex(void *blob, struct bd_info *bd); |
Gerald Van Baren | 566fae3 | 2007-07-10 20:40:39 -0400 | [diff] [blame] | 220 | |
Simon Glass | 6c0be91 | 2014-10-23 18:58:54 -0600 | [diff] [blame] | 221 | /** |
| 222 | * Add system-specific data to the FDT before booting the OS. |
| 223 | * |
| 224 | * Use CONFIG_SYS_FDT_PAD to ensure there is sufficient space. |
| 225 | * This function is called if CONFIG_OF_SYSTEM_SETUP is defined |
| 226 | * |
| 227 | * @param blob FDT blob to update |
Masahiro Yamada | 940a922 | 2020-06-26 15:13:34 +0900 | [diff] [blame] | 228 | * @param bd Pointer to board data |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 229 | * Return: 0 if ok, or -FDT_ERR_... on error |
Simon Glass | 6c0be91 | 2014-10-23 18:58:54 -0600 | [diff] [blame] | 230 | */ |
Masahiro Yamada | f7ed78b | 2020-06-26 15:13:33 +0900 | [diff] [blame] | 231 | int ft_system_setup(void *blob, struct bd_info *bd); |
Simon Glass | 6c0be91 | 2014-10-23 18:58:54 -0600 | [diff] [blame] | 232 | |
Joe Hershberger | 3d4ea4c | 2015-02-04 21:56:53 -0600 | [diff] [blame] | 233 | void set_working_fdt_addr(ulong addr); |
Hannes Schmelzer | d3dbac8 | 2016-09-20 18:10:43 +0200 | [diff] [blame] | 234 | |
| 235 | /** |
| 236 | * shrink down the given blob to minimum size + some extrasize if required |
| 237 | * |
| 238 | * @param blob FDT blob to update |
| 239 | * @param extrasize additional bytes needed |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 240 | * Return: 0 if ok, or -FDT_ERR_... on error |
Hannes Schmelzer | d3dbac8 | 2016-09-20 18:10:43 +0200 | [diff] [blame] | 241 | */ |
| 242 | int fdt_shrink_to_minimum(void *blob, uint extrasize); |
Timur Tabi | cd7d8e8 | 2011-05-03 13:35:10 -0500 | [diff] [blame] | 243 | int fdt_increase_size(void *fdt, int add_len); |
Kumar Gala | 9f4e7e4 | 2008-08-15 08:24:39 -0500 | [diff] [blame] | 244 | |
Marek Behún | ac4d9ff | 2021-11-26 14:57:15 +0100 | [diff] [blame] | 245 | int fdt_delete_disabled_nodes(void *blob); |
| 246 | |
Masahiro Yamada | f3d4014 | 2018-07-19 16:28:22 +0900 | [diff] [blame] | 247 | struct node_info; |
Christopher Spinrath | e51b8a4 | 2016-07-12 23:37:35 +0200 | [diff] [blame] | 248 | #if defined(CONFIG_FDT_FIXUP_PARTITIONS) |
Masahiro Yamada | f3d4014 | 2018-07-19 16:28:22 +0900 | [diff] [blame] | 249 | void fdt_fixup_mtdparts(void *fdt, const struct node_info *node_info, |
| 250 | int node_info_size); |
Christopher Spinrath | e51b8a4 | 2016-07-12 23:37:35 +0200 | [diff] [blame] | 251 | #else |
Masahiro Yamada | f3d4014 | 2018-07-19 16:28:22 +0900 | [diff] [blame] | 252 | static inline void fdt_fixup_mtdparts(void *fdt, |
| 253 | const struct node_info *node_info, |
| 254 | int node_info_size) |
| 255 | { |
| 256 | } |
Christopher Spinrath | e51b8a4 | 2016-07-12 23:37:35 +0200 | [diff] [blame] | 257 | #endif |
| 258 | |
Kumar Gala | f4ad4fd | 2010-03-30 10:19:26 -0500 | [diff] [blame] | 259 | void fdt_del_node_and_alias(void *blob, const char *alias); |
Fabien Dessenne | 22236e0 | 2019-05-31 15:11:30 +0200 | [diff] [blame] | 260 | |
| 261 | /** |
| 262 | * Translate an address from the DT into a CPU physical address |
| 263 | * |
| 264 | * The translation relies on the "ranges" property. |
| 265 | * |
| 266 | * @param blob Pointer to device tree blob |
| 267 | * @param node_offset Node DT offset |
| 268 | * @param in_addr Pointer to the address to translate |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 269 | * Return: translated address or OF_BAD_ADDR on error |
Fabien Dessenne | 22236e0 | 2019-05-31 15:11:30 +0200 | [diff] [blame] | 270 | */ |
Stephen Warren | c99581b | 2016-08-05 09:47:50 -0600 | [diff] [blame] | 271 | u64 fdt_translate_address(const void *blob, int node_offset, |
| 272 | const __be32 *in_addr); |
Fabien Dessenne | 22236e0 | 2019-05-31 15:11:30 +0200 | [diff] [blame] | 273 | /** |
| 274 | * Translate a DMA address from the DT into a CPU physical address |
| 275 | * |
| 276 | * The translation relies on the "dma-ranges" property. |
| 277 | * |
| 278 | * @param blob Pointer to device tree blob |
| 279 | * @param node_offset Node DT offset |
| 280 | * @param in_addr Pointer to the DMA address to translate |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 281 | * Return: translated DMA address or OF_BAD_ADDR on error |
Fabien Dessenne | 22236e0 | 2019-05-31 15:11:30 +0200 | [diff] [blame] | 282 | */ |
| 283 | u64 fdt_translate_dma_address(const void *blob, int node_offset, |
| 284 | const __be32 *in_addr); |
| 285 | |
Nicolas Saenz Julienne | 50d2fa4 | 2021-01-12 13:55:22 +0100 | [diff] [blame] | 286 | /** |
| 287 | * Get DMA ranges for a specifc node, this is useful to perform bus->cpu and |
| 288 | * cpu->bus address translations |
| 289 | * |
| 290 | * @param blob Pointer to device tree blob |
| 291 | * @param node_offset Node DT offset |
| 292 | * @param cpu Pointer to variable storing the range's cpu address |
| 293 | * @param bus Pointer to variable storing the range's bus address |
| 294 | * @param size Pointer to variable storing the range's size |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 295 | * Return: translated DMA address or OF_BAD_ADDR on error |
Nicolas Saenz Julienne | 50d2fa4 | 2021-01-12 13:55:22 +0100 | [diff] [blame] | 296 | */ |
| 297 | int fdt_get_dma_range(const void *blob, int node_offset, phys_addr_t *cpu, |
| 298 | dma_addr_t *bus, u64 *size); |
| 299 | |
Kumar Gala | 800d1d1 | 2010-07-04 12:48:21 -0500 | [diff] [blame] | 300 | int fdt_node_offset_by_compat_reg(void *blob, const char *compat, |
| 301 | phys_addr_t compat_off); |
Marek Behún | 4ef5ca6 | 2021-11-26 14:57:10 +0100 | [diff] [blame] | 302 | int fdt_node_offset_by_pathf(void *blob, const char *fmt, ...) |
| 303 | __attribute__ ((format (printf, 2, 3))); |
Marek Behún | 5d6b448 | 2022-01-20 01:04:42 +0100 | [diff] [blame] | 304 | |
| 305 | #define fdt_for_each_node_by_compatible(node, fdt, start, compat) \ |
| 306 | for (node = fdt_node_offset_by_compatible(fdt, start, compat); \ |
| 307 | node >= 0; \ |
| 308 | node = fdt_node_offset_by_compatible(fdt, node, compat)) |
| 309 | |
Kumar Gala | f2f1c5a | 2011-08-01 00:23:23 -0500 | [diff] [blame] | 310 | int fdt_set_phandle(void *fdt, int nodeoffset, uint32_t phandle); |
Timur Tabi | 0f46c80 | 2011-09-20 18:24:34 -0500 | [diff] [blame] | 311 | unsigned int fdt_create_phandle(void *fdt, int nodeoffset); |
Marek Behún | 4ef5ca6 | 2021-11-26 14:57:10 +0100 | [diff] [blame] | 312 | unsigned int fdt_create_phandle_by_compatible(void *fdt, const char *compat); |
| 313 | unsigned int fdt_create_phandle_by_pathf(void *fdt, const char *fmt, ...) |
| 314 | __attribute__ ((format (printf, 2, 3))); |
Anatolij Gustschin | 3b857f1 | 2010-08-18 11:25:20 +0200 | [diff] [blame] | 315 | int fdt_add_edid(void *blob, const char *compat, unsigned char *buf); |
Anatolij Gustschin | 6c44c38 | 2010-03-16 17:10:05 +0100 | [diff] [blame] | 316 | |
Timur Tabi | 8ebaf20 | 2011-05-03 13:24:07 -0500 | [diff] [blame] | 317 | int fdt_verify_alias_address(void *fdt, int anode, const char *alias, |
| 318 | u64 addr); |
Simon Glass | 293340a | 2017-05-18 20:09:00 -0600 | [diff] [blame] | 319 | u64 fdt_get_base_address(const void *fdt, int node); |
Alexander Graf | 19555be | 2014-04-11 17:09:41 +0200 | [diff] [blame] | 320 | int fdt_read_range(void *fdt, int node, int n, uint64_t *child_addr, |
| 321 | uint64_t *addr, uint64_t *len); |
Timur Tabi | 8ebaf20 | 2011-05-03 13:24:07 -0500 | [diff] [blame] | 322 | |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 323 | enum fdt_status { |
| 324 | FDT_STATUS_OKAY, |
| 325 | FDT_STATUS_DISABLED, |
| 326 | FDT_STATUS_FAIL, |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 327 | }; |
Marek Behún | f872e83 | 2021-11-26 14:57:08 +0100 | [diff] [blame] | 328 | int fdt_set_node_status(void *fdt, int nodeoffset, enum fdt_status status); |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 329 | static inline int fdt_status_okay(void *fdt, int nodeoffset) |
| 330 | { |
Marek Behún | f872e83 | 2021-11-26 14:57:08 +0100 | [diff] [blame] | 331 | return fdt_set_node_status(fdt, nodeoffset, FDT_STATUS_OKAY); |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 332 | } |
| 333 | static inline int fdt_status_disabled(void *fdt, int nodeoffset) |
| 334 | { |
Marek Behún | f872e83 | 2021-11-26 14:57:08 +0100 | [diff] [blame] | 335 | return fdt_set_node_status(fdt, nodeoffset, FDT_STATUS_DISABLED); |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 336 | } |
J. German Rivera | 8ff14b7 | 2014-06-23 15:15:55 -0700 | [diff] [blame] | 337 | static inline int fdt_status_fail(void *fdt, int nodeoffset) |
| 338 | { |
Marek Behún | f872e83 | 2021-11-26 14:57:08 +0100 | [diff] [blame] | 339 | return fdt_set_node_status(fdt, nodeoffset, FDT_STATUS_FAIL); |
J. German Rivera | 8ff14b7 | 2014-06-23 15:15:55 -0700 | [diff] [blame] | 340 | } |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 341 | |
J. German Rivera | 8ff14b7 | 2014-06-23 15:15:55 -0700 | [diff] [blame] | 342 | int fdt_set_status_by_alias(void *fdt, const char *alias, |
Marek Behún | f872e83 | 2021-11-26 14:57:08 +0100 | [diff] [blame] | 343 | enum fdt_status status); |
J. German Rivera | 8ff14b7 | 2014-06-23 15:15:55 -0700 | [diff] [blame] | 344 | static inline int fdt_status_okay_by_alias(void *fdt, const char *alias) |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 345 | { |
Marek Behún | f872e83 | 2021-11-26 14:57:08 +0100 | [diff] [blame] | 346 | return fdt_set_status_by_alias(fdt, alias, FDT_STATUS_OKAY); |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 347 | } |
J. German Rivera | 8ff14b7 | 2014-06-23 15:15:55 -0700 | [diff] [blame] | 348 | static inline int fdt_status_disabled_by_alias(void *fdt, const char *alias) |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 349 | { |
Marek Behún | f872e83 | 2021-11-26 14:57:08 +0100 | [diff] [blame] | 350 | return fdt_set_status_by_alias(fdt, alias, FDT_STATUS_DISABLED); |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 351 | } |
J. German Rivera | 8ff14b7 | 2014-06-23 15:15:55 -0700 | [diff] [blame] | 352 | static inline int fdt_status_fail_by_alias(void *fdt, const char *alias) |
| 353 | { |
Marek Behún | f872e83 | 2021-11-26 14:57:08 +0100 | [diff] [blame] | 354 | return fdt_set_status_by_alias(fdt, alias, FDT_STATUS_FAIL); |
J. German Rivera | 8ff14b7 | 2014-06-23 15:15:55 -0700 | [diff] [blame] | 355 | } |
Shengzhou Liu | a7be802 | 2011-10-14 16:26:05 +0800 | [diff] [blame] | 356 | |
Marek Behún | 4ef5ca6 | 2021-11-26 14:57:10 +0100 | [diff] [blame] | 357 | int fdt_set_status_by_compatible(void *fdt, const char *compat, |
| 358 | enum fdt_status status); |
| 359 | static inline int fdt_status_okay_by_compatible(void *fdt, const char *compat) |
| 360 | { |
| 361 | return fdt_set_status_by_compatible(fdt, compat, FDT_STATUS_OKAY); |
| 362 | } |
| 363 | static inline int fdt_status_disabled_by_compatible(void *fdt, |
| 364 | const char *compat) |
| 365 | { |
| 366 | return fdt_set_status_by_compatible(fdt, compat, FDT_STATUS_DISABLED); |
| 367 | } |
| 368 | static inline int fdt_status_fail_by_compatible(void *fdt, const char *compat) |
| 369 | { |
| 370 | return fdt_set_status_by_compatible(fdt, compat, FDT_STATUS_FAIL); |
| 371 | } |
| 372 | |
| 373 | int fdt_set_status_by_pathf(void *fdt, enum fdt_status status, const char *fmt, |
| 374 | ...) __attribute__ ((format (printf, 3, 4))); |
| 375 | #define fdt_status_okay_by_pathf(fdt, fmt, ...) \ |
| 376 | fdt_set_status_by_pathf((fdt), FDT_STATUS_OKAY, (fmt), ##__VA_ARGS__) |
| 377 | #define fdt_status_disabled_by_pathf(fdt, fmt, ...) \ |
| 378 | fdt_set_status_by_pathf((fdt), FDT_STATUS_DISABLED, (fmt), ##__VA_ARGS__) |
| 379 | #define fdt_status_fail_by_pathf(fdt, fmt, ...) \ |
| 380 | fdt_set_status_by_pathf((fdt), FDT_STATUS_FAIL, (fmt), ##__VA_ARGS__) |
| 381 | |
Arnab Basu | ae16fc8 | 2014-09-08 12:19:58 -0700 | [diff] [blame] | 382 | /* Helper to read a big number; size is in cells (not bytes) */ |
Simon Glass | bb7c01e | 2017-05-18 20:09:26 -0600 | [diff] [blame] | 383 | static inline u64 fdt_read_number(const fdt32_t *cell, int size) |
Arnab Basu | ae16fc8 | 2014-09-08 12:19:58 -0700 | [diff] [blame] | 384 | { |
| 385 | u64 r = 0; |
| 386 | while (size--) |
| 387 | r = (r << 32) | fdt32_to_cpu(*(cell++)); |
| 388 | return r; |
| 389 | } |
| 390 | |
Simon Glass | bb7c01e | 2017-05-18 20:09:26 -0600 | [diff] [blame] | 391 | void fdt_support_default_count_cells(const void *blob, int parentoffset, |
Arnab Basu | 9f6a06a | 2014-09-08 12:19:59 -0700 | [diff] [blame] | 392 | int *addrc, int *sizec); |
Jeroen Hofstee | 0aa4b37 | 2014-10-08 22:58:02 +0200 | [diff] [blame] | 393 | int ft_verify_fdt(void *fdt); |
| 394 | int arch_fixup_memory_node(void *blob); |
Arnab Basu | 9f6a06a | 2014-09-08 12:19:59 -0700 | [diff] [blame] | 395 | |
Hans de Goede | ea87637 | 2014-11-17 15:29:11 +0100 | [diff] [blame] | 396 | int fdt_setup_simplefb_node(void *fdt, int node, u64 base_address, u32 width, |
| 397 | u32 height, u32 stride, const char *format); |
| 398 | |
Pantelis Antoniou | 592386d | 2017-09-04 23:12:11 +0300 | [diff] [blame] | 399 | int fdt_overlay_apply_verbose(void *fdt, void *fdto); |
| 400 | |
Kory Maincent | 623e1ac | 2021-05-04 19:31:21 +0200 | [diff] [blame] | 401 | int fdt_valid(struct fdt_header **blobp); |
| 402 | |
Michael Pratt | fa28d14 | 2018-06-11 13:07:09 -0600 | [diff] [blame] | 403 | /** |
| 404 | * fdt_get_cells_len() - Get the length of a type of cell in top-level nodes |
| 405 | * |
| 406 | * Returns the length of the cell type in bytes (4 or 8). |
| 407 | * |
| 408 | * @blob: Pointer to device tree blob |
| 409 | * @nr_cells_name: Name to lookup, e.g. "#address-cells" |
| 410 | */ |
| 411 | int fdt_get_cells_len(const void *blob, char *nr_cells_name); |
| 412 | |
Gerald Van Baren | c4a57ea | 2007-04-06 14:19:43 -0400 | [diff] [blame] | 413 | #endif /* ifdef CONFIG_OF_LIBFDT */ |
Heiko Schocher | d7b4232 | 2014-03-03 12:19:30 +0100 | [diff] [blame] | 414 | |
| 415 | #ifdef USE_HOSTCC |
| 416 | int fdtdec_get_int(const void *blob, int node, const char *prop_name, |
| 417 | int default_val); |
Kever Yang | 8010fa4 | 2020-03-30 11:56:23 +0800 | [diff] [blame] | 418 | |
| 419 | /* |
| 420 | * Count child nodes of one parent node. |
| 421 | * |
| 422 | * @param blob FDT blob |
| 423 | * @param node parent node |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 424 | * Return: number of child node; 0 if there is not child node |
Kever Yang | 8010fa4 | 2020-03-30 11:56:23 +0800 | [diff] [blame] | 425 | */ |
| 426 | int fdtdec_get_child_count(const void *blob, int node); |
Heiko Schocher | d7b4232 | 2014-03-03 12:19:30 +0100 | [diff] [blame] | 427 | #endif |
Prabhakar Kushwaha | c10b967 | 2017-11-23 16:51:41 +0530 | [diff] [blame] | 428 | #ifdef CONFIG_FMAN_ENET |
| 429 | int fdt_update_ethernet_dt(void *blob); |
| 430 | #endif |
Yogesh Gaur | 8dadfb4 | 2018-01-16 10:08:24 +0530 | [diff] [blame] | 431 | #ifdef CONFIG_FSL_MC_ENET |
| 432 | void fdt_fixup_board_enet(void *blob); |
| 433 | #endif |
Frédéric Danis | cdd6a6d | 2020-03-20 10:59:24 +0100 | [diff] [blame] | 434 | #ifdef CONFIG_CMD_PSTORE |
| 435 | void fdt_fixup_pstore(void *blob); |
| 436 | #endif |
Gerald Van Baren | c4a57ea | 2007-04-06 14:19:43 -0400 | [diff] [blame] | 437 | #endif /* ifndef __FDT_SUPPORT_H */ |