Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 2 | /* |
| 3 | * Device addresses |
| 4 | * |
| 5 | * Copyright (c) 2017 Google, Inc |
| 6 | * |
| 7 | * (C) Copyright 2012 |
| 8 | * Pavel Herrmann <morpheus.ibis@gmail.com> |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 9 | */ |
| 10 | |
Tom Rini | abb9a04 | 2024-05-18 20:20:43 -0600 | [diff] [blame] | 11 | #include <common.h> |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 12 | #include <dm.h> |
| 13 | #include <fdt_support.h> |
Simon Glass | 0f2af88 | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 14 | #include <log.h> |
Johan Jonker | 8664860 | 2023-04-23 11:19:41 +0200 | [diff] [blame] | 15 | #include <mapmem.h> |
Simon Glass | 3ba929a | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 16 | #include <asm/global_data.h> |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 17 | #include <asm/io.h> |
| 18 | #include <dm/device-internal.h> |
| 19 | |
| 20 | DECLARE_GLOBAL_DATA_PTR; |
| 21 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 22 | fdt_addr_t devfdt_get_addr_index(const struct udevice *dev, int index) |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 23 | { |
Simon Glass | 3580f6d | 2021-08-07 07:24:03 -0600 | [diff] [blame] | 24 | #if CONFIG_IS_ENABLED(OF_REAL) |
Simon Glass | cb12c9f | 2022-09-06 20:27:12 -0600 | [diff] [blame] | 25 | int offset = dev_of_offset(dev); |
Jonas Karlman | 4dd834a | 2024-02-17 13:19:41 +0000 | [diff] [blame] | 26 | int parent = fdt_parent_offset(gd->fdt_blob, offset); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 27 | fdt_addr_t addr; |
| 28 | |
| 29 | if (CONFIG_IS_ENABLED(OF_TRANSLATE)) { |
| 30 | const fdt32_t *reg; |
| 31 | int len = 0; |
| 32 | int na, ns; |
| 33 | |
Simon Glass | cb12c9f | 2022-09-06 20:27:12 -0600 | [diff] [blame] | 34 | na = fdt_address_cells(gd->fdt_blob, parent); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 35 | if (na < 1) { |
| 36 | debug("bad #address-cells\n"); |
| 37 | return FDT_ADDR_T_NONE; |
| 38 | } |
| 39 | |
Simon Glass | cb12c9f | 2022-09-06 20:27:12 -0600 | [diff] [blame] | 40 | ns = fdt_size_cells(gd->fdt_blob, parent); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 41 | if (ns < 0) { |
| 42 | debug("bad #size-cells\n"); |
| 43 | return FDT_ADDR_T_NONE; |
| 44 | } |
| 45 | |
Simon Glass | cb12c9f | 2022-09-06 20:27:12 -0600 | [diff] [blame] | 46 | reg = fdt_getprop(gd->fdt_blob, offset, "reg", &len); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 47 | if (!reg || (len <= (index * sizeof(fdt32_t) * (na + ns)))) { |
| 48 | debug("Req index out of range\n"); |
| 49 | return FDT_ADDR_T_NONE; |
| 50 | } |
| 51 | |
| 52 | reg += index * (na + ns); |
| 53 | |
Dario Binacchi | f8fc703 | 2021-05-01 17:05:26 +0200 | [diff] [blame] | 54 | if (ns) { |
Mario Six | 35616ef | 2018-03-12 14:53:33 +0100 | [diff] [blame] | 55 | /* |
| 56 | * Use the full-fledged translate function for complex |
| 57 | * bus setups. |
| 58 | */ |
| 59 | addr = fdt_translate_address((void *)gd->fdt_blob, |
Simon Glass | cb12c9f | 2022-09-06 20:27:12 -0600 | [diff] [blame] | 60 | offset, reg); |
Mario Six | 35616ef | 2018-03-12 14:53:33 +0100 | [diff] [blame] | 61 | } else { |
| 62 | /* Non translatable if #size-cells == 0 */ |
| 63 | addr = fdt_read_number(reg, na); |
| 64 | } |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 65 | } else { |
| 66 | /* |
| 67 | * Use the "simple" translate function for less complex |
| 68 | * bus setups. |
| 69 | */ |
Simon Glass | cb12c9f | 2022-09-06 20:27:12 -0600 | [diff] [blame] | 70 | addr = fdtdec_get_addr_size_auto_parent(gd->fdt_blob, parent, |
| 71 | offset, "reg", index, |
| 72 | NULL, false); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 73 | if (CONFIG_IS_ENABLED(SIMPLE_BUS) && addr != FDT_ADDR_T_NONE) { |
| 74 | if (device_get_uclass_id(dev->parent) == |
| 75 | UCLASS_SIMPLE_BUS) |
| 76 | addr = simple_bus_translate(dev->parent, addr); |
| 77 | } |
| 78 | } |
| 79 | |
Stefan Roese | 85bddff | 2019-04-12 16:42:28 +0200 | [diff] [blame] | 80 | #if defined(CONFIG_TRANSLATION_OFFSET) |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 81 | /* |
| 82 | * Some platforms need a special address translation. Those |
| 83 | * platforms (e.g. mvebu in SPL) can configure a translation |
Stefan Roese | 85bddff | 2019-04-12 16:42:28 +0200 | [diff] [blame] | 84 | * offset by setting this value in the GD and enaling this |
| 85 | * feature via CONFIG_TRANSLATION_OFFSET. This value will |
| 86 | * get added to all addresses returned by devfdt_get_addr(). |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 87 | */ |
Stefan Roese | 85bddff | 2019-04-12 16:42:28 +0200 | [diff] [blame] | 88 | addr += gd->translation_offset; |
| 89 | #endif |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 90 | |
| 91 | return addr; |
| 92 | #else |
| 93 | return FDT_ADDR_T_NONE; |
| 94 | #endif |
| 95 | } |
| 96 | |
Bin Meng | a44397f | 2021-09-12 11:15:12 +0800 | [diff] [blame] | 97 | void *devfdt_get_addr_index_ptr(const struct udevice *dev, int index) |
| 98 | { |
| 99 | fdt_addr_t addr = devfdt_get_addr_index(dev, index); |
| 100 | |
Johan Jonker | 8664860 | 2023-04-23 11:19:41 +0200 | [diff] [blame] | 101 | if (addr == FDT_ADDR_T_NONE) |
| 102 | return NULL; |
| 103 | |
| 104 | return map_sysmem(addr, 0); |
Bin Meng | a44397f | 2021-09-12 11:15:12 +0800 | [diff] [blame] | 105 | } |
| 106 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 107 | fdt_addr_t devfdt_get_addr_size_index(const struct udevice *dev, int index, |
| 108 | fdt_size_t *size) |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 109 | { |
| 110 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
| 111 | /* |
| 112 | * Only get the size in this first call. We'll get the addr in the |
| 113 | * next call to the exisiting dev_get_xxx function which handles |
| 114 | * all config options. |
| 115 | */ |
| 116 | fdtdec_get_addr_size_auto_noparent(gd->fdt_blob, dev_of_offset(dev), |
| 117 | "reg", index, size, false); |
| 118 | |
| 119 | /* |
| 120 | * Get the base address via the existing function which handles |
| 121 | * all Kconfig cases |
| 122 | */ |
Simon Glass | ba1dea4 | 2017-05-17 17:18:05 -0600 | [diff] [blame] | 123 | return devfdt_get_addr_index(dev, index); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 124 | #else |
| 125 | return FDT_ADDR_T_NONE; |
| 126 | #endif |
| 127 | } |
| 128 | |
Johan Jonker | ef6769f | 2023-04-21 17:33:58 +0200 | [diff] [blame] | 129 | void *devfdt_get_addr_size_index_ptr(const struct udevice *dev, int index, |
| 130 | fdt_size_t *size) |
| 131 | { |
| 132 | fdt_addr_t addr = devfdt_get_addr_size_index(dev, index, size); |
| 133 | |
Johan Jonker | 4d3bce4 | 2023-05-10 23:48:44 +0200 | [diff] [blame] | 134 | if (addr == FDT_ADDR_T_NONE) |
| 135 | return NULL; |
| 136 | |
| 137 | return map_sysmem(addr, 0); |
Johan Jonker | ef6769f | 2023-04-21 17:33:58 +0200 | [diff] [blame] | 138 | } |
| 139 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 140 | fdt_addr_t devfdt_get_addr_name(const struct udevice *dev, const char *name) |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 141 | { |
| 142 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
| 143 | int index; |
| 144 | |
| 145 | index = fdt_stringlist_search(gd->fdt_blob, dev_of_offset(dev), |
| 146 | "reg-names", name); |
| 147 | if (index < 0) |
Matthias Schiffer | bc2b85d | 2023-09-27 15:33:31 +0200 | [diff] [blame] | 148 | return FDT_ADDR_T_NONE; |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 149 | |
Simon Glass | ba1dea4 | 2017-05-17 17:18:05 -0600 | [diff] [blame] | 150 | return devfdt_get_addr_index(dev, index); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 151 | #else |
| 152 | return FDT_ADDR_T_NONE; |
| 153 | #endif |
| 154 | } |
| 155 | |
Matthias Schiffer | 5e90d4e | 2023-09-27 15:33:32 +0200 | [diff] [blame] | 156 | void *devfdt_get_addr_name_ptr(const struct udevice *dev, const char *name) |
| 157 | { |
| 158 | fdt_addr_t addr = devfdt_get_addr_name(dev, name); |
| 159 | |
| 160 | if (addr == FDT_ADDR_T_NONE) |
| 161 | return NULL; |
| 162 | |
| 163 | return map_sysmem(addr, 0); |
| 164 | } |
| 165 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 166 | fdt_addr_t devfdt_get_addr_size_name(const struct udevice *dev, |
| 167 | const char *name, fdt_size_t *size) |
Sekhar Nori | f677c6f | 2019-08-01 19:12:56 +0530 | [diff] [blame] | 168 | { |
| 169 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
| 170 | int index; |
| 171 | |
| 172 | index = fdt_stringlist_search(gd->fdt_blob, dev_of_offset(dev), |
| 173 | "reg-names", name); |
| 174 | if (index < 0) |
Matthias Schiffer | bc2b85d | 2023-09-27 15:33:31 +0200 | [diff] [blame] | 175 | return FDT_ADDR_T_NONE; |
Sekhar Nori | f677c6f | 2019-08-01 19:12:56 +0530 | [diff] [blame] | 176 | |
| 177 | return devfdt_get_addr_size_index(dev, index, size); |
| 178 | #else |
| 179 | return FDT_ADDR_T_NONE; |
| 180 | #endif |
| 181 | } |
| 182 | |
Matthias Schiffer | 5e90d4e | 2023-09-27 15:33:32 +0200 | [diff] [blame] | 183 | void *devfdt_get_addr_size_name_ptr(const struct udevice *dev, |
| 184 | const char *name, fdt_size_t *size) |
| 185 | { |
| 186 | fdt_addr_t addr = devfdt_get_addr_size_name(dev, name, size); |
| 187 | |
| 188 | if (addr == FDT_ADDR_T_NONE) |
| 189 | return NULL; |
| 190 | |
| 191 | return map_sysmem(addr, 0); |
| 192 | } |
| 193 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 194 | fdt_addr_t devfdt_get_addr(const struct udevice *dev) |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 195 | { |
Simon Glass | ba1dea4 | 2017-05-17 17:18:05 -0600 | [diff] [blame] | 196 | return devfdt_get_addr_index(dev, 0); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 197 | } |
| 198 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 199 | void *devfdt_get_addr_ptr(const struct udevice *dev) |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 200 | { |
Bin Meng | a44397f | 2021-09-12 11:15:12 +0800 | [diff] [blame] | 201 | return devfdt_get_addr_index_ptr(dev, 0); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 202 | } |
| 203 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 204 | void *devfdt_remap_addr_index(const struct udevice *dev, int index) |
Álvaro Fernández Rojas | 67036129 | 2018-04-29 21:56:54 +0200 | [diff] [blame] | 205 | { |
Cédric Le Goater | c0fb7e6 | 2018-08-14 12:48:11 +0200 | [diff] [blame] | 206 | fdt_addr_t addr = devfdt_get_addr_index(dev, index); |
Álvaro Fernández Rojas | 67036129 | 2018-04-29 21:56:54 +0200 | [diff] [blame] | 207 | |
| 208 | if (addr == FDT_ADDR_T_NONE) |
| 209 | return NULL; |
| 210 | |
| 211 | return map_physmem(addr, 0, MAP_NOCACHE); |
| 212 | } |
| 213 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 214 | void *devfdt_remap_addr_name(const struct udevice *dev, const char *name) |
Álvaro Fernández Rojas | a318115 | 2018-12-03 19:37:09 +0100 | [diff] [blame] | 215 | { |
| 216 | fdt_addr_t addr = devfdt_get_addr_name(dev, name); |
| 217 | |
| 218 | if (addr == FDT_ADDR_T_NONE) |
| 219 | return NULL; |
| 220 | |
| 221 | return map_physmem(addr, 0, MAP_NOCACHE); |
| 222 | } |
| 223 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 224 | void *devfdt_remap_addr(const struct udevice *dev) |
Álvaro Fernández Rojas | 67036129 | 2018-04-29 21:56:54 +0200 | [diff] [blame] | 225 | { |
| 226 | return devfdt_remap_addr_index(dev, 0); |
| 227 | } |
| 228 | |
Simon Glass | c6548b8 | 2020-01-27 08:49:39 -0700 | [diff] [blame] | 229 | void *devfdt_map_physmem(const struct udevice *dev, unsigned long size) |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 230 | { |
Simon Glass | ba1dea4 | 2017-05-17 17:18:05 -0600 | [diff] [blame] | 231 | fdt_addr_t addr = devfdt_get_addr(dev); |
Simon Glass | aadfaf0 | 2017-05-17 17:18:04 -0600 | [diff] [blame] | 232 | |
| 233 | if (addr == FDT_ADDR_T_NONE) |
| 234 | return NULL; |
| 235 | |
| 236 | return map_physmem(addr, size, MAP_NOCACHE); |
| 237 | } |
Simon Glass | 23b2759 | 2019-09-15 12:08:58 -0600 | [diff] [blame] | 238 | |
Simon Glass | 4289c26 | 2023-09-26 08:14:58 -0600 | [diff] [blame] | 239 | fdt_addr_t devfdt_get_addr_pci(const struct udevice *dev, fdt_size_t *sizep) |
Simon Glass | 23b2759 | 2019-09-15 12:08:58 -0600 | [diff] [blame] | 240 | { |
| 241 | ulong addr; |
| 242 | |
| 243 | addr = devfdt_get_addr(dev); |
Simon Glass | 82278e3 | 2021-08-01 18:54:23 -0600 | [diff] [blame] | 244 | if (CONFIG_IS_ENABLED(PCI) && addr == FDT_ADDR_T_NONE) { |
Simon Glass | 23b2759 | 2019-09-15 12:08:58 -0600 | [diff] [blame] | 245 | struct fdt_pci_addr pci_addr; |
| 246 | u32 bar; |
| 247 | int ret; |
| 248 | |
Simon Glass | 04ec59c | 2019-09-25 08:56:41 -0600 | [diff] [blame] | 249 | ret = ofnode_read_pci_addr(dev_ofnode(dev), FDT_PCI_SPACE_MEM32, |
Simon Glass | 4289c26 | 2023-09-26 08:14:58 -0600 | [diff] [blame] | 250 | "reg", &pci_addr, sizep); |
Simon Glass | 23b2759 | 2019-09-15 12:08:58 -0600 | [diff] [blame] | 251 | if (ret) { |
| 252 | /* try if there is any i/o-mapped register */ |
Simon Glass | 04ec59c | 2019-09-25 08:56:41 -0600 | [diff] [blame] | 253 | ret = ofnode_read_pci_addr(dev_ofnode(dev), |
| 254 | FDT_PCI_SPACE_IO, "reg", |
Simon Glass | 4289c26 | 2023-09-26 08:14:58 -0600 | [diff] [blame] | 255 | &pci_addr, sizep); |
Simon Glass | 23b2759 | 2019-09-15 12:08:58 -0600 | [diff] [blame] | 256 | if (ret) |
| 257 | return FDT_ADDR_T_NONE; |
| 258 | } |
| 259 | ret = fdtdec_get_pci_bar32(dev, &pci_addr, &bar); |
| 260 | if (ret) |
| 261 | return FDT_ADDR_T_NONE; |
| 262 | addr = bar; |
| 263 | } |
| 264 | |
| 265 | return addr; |
| 266 | } |