drivers/core/read.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2017 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <dm/of_access.h>
  10 #include <mapmem.h>
  11 #include <asm/global_data.h>
  12 #include <asm/types.h>
  13 #include <asm/io.h>
  14 #include <linux/ioport.h>
  15
  16 int dev_read_u32(const struct udevice *dev, const char *propname, u32 *outp)
  17 {
  18         return ofnode_read_u32(dev_ofnode(dev), propname, outp);
  19 }
  20
  21 int dev_read_u32_default(const struct udevice *dev, const char *propname,
  22                          int def)
  23 {
  24         return ofnode_read_u32_default(dev_ofnode(dev), propname, def);
  25 }
  26
  27 int dev_read_u32_index(struct udevice *dev, const char *propname, int index,
  28                        u32 *outp)
  29 {
  30         return ofnode_read_u32_index(dev_ofnode(dev), propname, index, outp);
  31 }
  32
  33 u32 dev_read_u32_index_default(struct udevice *dev, const char *propname,
  34                                int index, u32 def)
  35 {
  36         return ofnode_read_u32_index_default(dev_ofnode(dev), propname, index,
  37                                              def);
  38 }
  39
  40 int dev_read_s32(const struct udevice *dev, const char *propname, s32 *outp)
  41 {
  42         return ofnode_read_u32(dev_ofnode(dev), propname, (u32 *)outp);
  43 }
  44
  45 int dev_read_s32_default(const struct udevice *dev, const char *propname,
  46                          int def)
  47 {
  48         return ofnode_read_u32_default(dev_ofnode(dev), propname, def);
  49 }
  50
  51 int dev_read_u32u(const struct udevice *dev, const char *propname, uint *outp)
  52 {
  53         u32 val;
  54         int ret;
  55
  56         ret = ofnode_read_u32(dev_ofnode(dev), propname, &val);
  57         if (ret)
  58                 return ret;
  59         *outp = val;
  60
  61         return 0;
  62 }
  63
  64 int dev_read_u64(const struct udevice *dev, const char *propname, u64 *outp)
  65 {
  66         return ofnode_read_u64(dev_ofnode(dev), propname, outp);
  67 }
  68
  69 u64 dev_read_u64_default(const struct udevice *dev, const char *propname,
  70                          u64 def)
  71 {
  72         return ofnode_read_u64_default(dev_ofnode(dev), propname, def);
  73 }
  74
  75 const char *dev_read_string(const struct udevice *dev, const char *propname)
  76 {
  77         return ofnode_read_string(dev_ofnode(dev), propname);
  78 }
  79
  80 bool dev_read_bool(const struct udevice *dev, const char *propname)
  81 {
  82         return ofnode_read_bool(dev_ofnode(dev), propname);
  83 }
  84
  85 ofnode dev_read_subnode(const struct udevice *dev, const char *subnode_name)
  86 {
  87         return ofnode_find_subnode(dev_ofnode(dev), subnode_name);
  88 }
  89
  90 ofnode dev_read_first_subnode(const struct udevice *dev)
  91 {
  92         return ofnode_first_subnode(dev_ofnode(dev));
  93 }
  94
  95 ofnode dev_read_next_subnode(ofnode node)
  96 {
  97         return ofnode_next_subnode(node);
  98 }
  99
 100 int dev_read_size(const struct udevice *dev, const char *propname)
 101 {
 102         return ofnode_read_size(dev_ofnode(dev), propname);
 103 }
 104
 105 fdt_addr_t dev_read_addr_index(const struct udevice *dev, int index)
 106 {
 107         if (ofnode_is_np(dev_ofnode(dev)))
 108                 return ofnode_get_addr_index(dev_ofnode(dev), index);
 109         else
 110                 return devfdt_get_addr_index(dev, index);
 111 }
 112
 113 fdt_addr_t dev_read_addr_size_index(const struct udevice *dev, int index,
 114                                     fdt_size_t *size)
 115 {
 116         if (ofnode_is_np(dev_ofnode(dev)))
 117                 return ofnode_get_addr_size_index(dev_ofnode(dev), index, size);
 118         else
 119                 return devfdt_get_addr_size_index(dev, index, size);
 120 }
 121
 122 void *dev_remap_addr_index(const struct udevice *dev, int index)
 123 {
 124         fdt_addr_t addr = dev_read_addr_index(dev, index);
 125
 126         if (addr == FDT_ADDR_T_NONE)
 127                 return NULL;
 128
 129         return map_physmem(addr, 0, MAP_NOCACHE);
 130 }
 131
 132 fdt_addr_t dev_read_addr_name(const struct udevice *dev, const char *name)
 133 {
 134         int index = dev_read_stringlist_search(dev, "reg-names", name);
 135
 136         if (index < 0)
 137                 return FDT_ADDR_T_NONE;
 138         else
 139                 return dev_read_addr_index(dev, index);
 140 }
 141
 142 fdt_addr_t dev_read_addr_size_name(const struct udevice *dev, const char *name,
 143                                    fdt_size_t *size)
 144 {
 145         int index = dev_read_stringlist_search(dev, "reg-names", name);
 146
 147         if (index < 0)
 148                 return FDT_ADDR_T_NONE;
 149         else
 150                 return dev_read_addr_size_index(dev, index, size);
 151 }
 152
 153 void *dev_remap_addr_name(const struct udevice *dev, const char *name)
 154 {
 155         fdt_addr_t addr = dev_read_addr_name(dev, name);
 156
 157         if (addr == FDT_ADDR_T_NONE)
 158                 return NULL;
 159
 160         return map_physmem(addr, 0, MAP_NOCACHE);
 161 }
 162
 163 fdt_addr_t dev_read_addr(const struct udevice *dev)
 164 {
 165         return dev_read_addr_index(dev, 0);
 166 }
 167
 168 void *dev_read_addr_ptr(const struct udevice *dev)
 169 {
 170         fdt_addr_t addr = dev_read_addr(dev);
 171
 172         return (addr == FDT_ADDR_T_NONE) ? NULL : (void *)(uintptr_t)addr;
 173 }
 174
 175 void *dev_remap_addr(const struct udevice *dev)
 176 {
 177         return dev_remap_addr_index(dev, 0);
 178 }
 179
 180 fdt_addr_t dev_read_addr_size(const struct udevice *dev, const char *property,
 181                               fdt_size_t *sizep)
 182 {
 183         return ofnode_get_addr_size(dev_ofnode(dev), property, sizep);
 184 }
 185
 186 const char *dev_read_name(const struct udevice *dev)
 187 {
 188         return ofnode_get_name(dev_ofnode(dev));
 189 }
 190
 191 int dev_read_stringlist_search(const struct udevice *dev, const char *property,
 192                                const char *string)
 193 {
 194         return ofnode_stringlist_search(dev_ofnode(dev), property, string);
 195 }
 196
 197 int dev_read_string_index(const struct udevice *dev, const char *propname,
 198                           int index, const char **outp)
 199 {
 200         return ofnode_read_string_index(dev_ofnode(dev), propname, index, outp);
 201 }
 202
 203 int dev_read_string_count(const struct udevice *dev, const char *propname)
 204 {
 205         return ofnode_read_string_count(dev_ofnode(dev), propname);
 206 }
 207
 208 int dev_read_string_list(const struct udevice *dev, const char *propname,
 209                          const char ***listp)
 210 {
 211         return ofnode_read_string_list(dev_ofnode(dev), propname, listp);
 212 }
 213
 214 int dev_read_phandle_with_args(const struct udevice *dev, const char *list_name,
 215                                const char *cells_name, int cell_count,
 216                                int index, struct ofnode_phandle_args *out_args)
 217 {
 218         return ofnode_parse_phandle_with_args(dev_ofnode(dev), list_name,
 219                                               cells_name, cell_count, index,
 220                                               out_args);
 221 }
 222
 223 int dev_count_phandle_with_args(const struct udevice *dev,
 224                                 const char *list_name, const char *cells_name,
 225                                 int cell_count)
 226 {
 227         return ofnode_count_phandle_with_args(dev_ofnode(dev), list_name,
 228                                               cells_name, cell_count);
 229 }
 230
 231 int dev_read_addr_cells(const struct udevice *dev)
 232 {
 233         return ofnode_read_addr_cells(dev_ofnode(dev));
 234 }
 235
 236 int dev_read_size_cells(const struct udevice *dev)
 237 {
 238         return ofnode_read_size_cells(dev_ofnode(dev));
 239 }
 240
 241 int dev_read_simple_addr_cells(const struct udevice *dev)
 242 {
 243         return ofnode_read_simple_addr_cells(dev_ofnode(dev));
 244 }
 245
 246 int dev_read_simple_size_cells(const struct udevice *dev)
 247 {
 248         return ofnode_read_simple_size_cells(dev_ofnode(dev));
 249 }
 250
 251 int dev_read_phandle(const struct udevice *dev)
 252 {
 253         ofnode node = dev_ofnode(dev);
 254
 255         if (ofnode_is_np(node))
 256                 return ofnode_to_np(node)->phandle;
 257         else
 258                 return fdt_get_phandle(gd->fdt_blob, ofnode_to_offset(node));
 259 }
 260
 261 const void *dev_read_prop(const struct udevice *dev, const char *propname,
 262                           int *lenp)
 263 {
 264         return ofnode_get_property(dev_ofnode(dev), propname, lenp);
 265 }
 266
 267 int dev_read_first_prop(const struct udevice *dev, struct ofprop *prop)
 268 {
 269         return ofnode_get_first_property(dev_ofnode(dev), prop);
 270 }
 271
 272 int dev_read_next_prop(struct ofprop *prop)
 273 {
 274         return ofnode_get_next_property(prop);
 275 }
 276
 277 const void *dev_read_prop_by_prop(struct ofprop *prop,
 278                                   const char **propname, int *lenp)
 279 {
 280         return ofnode_get_property_by_prop(prop, propname, lenp);
 281 }
 282
 283 int dev_read_alias_seq(const struct udevice *dev, int *devnump)
 284 {
 285         ofnode node = dev_ofnode(dev);
 286         const char *uc_name = dev->uclass->uc_drv->name;
 287         int ret = -ENOTSUPP;
 288
 289         if (ofnode_is_np(node)) {
 290                 ret = of_alias_get_id(ofnode_to_np(node), uc_name);
 291                 if (ret >= 0) {
 292                         *devnump = ret;
 293                         ret = 0;
 294                 }
 295         } else {
 296 #if CONFIG_IS_ENABLED(OF_CONTROL)
 297                 ret = fdtdec_get_alias_seq(gd->fdt_blob, uc_name,
 298                                            ofnode_to_offset(node), devnump);
 299 #endif
 300         }
 301
 302         return ret;
 303 }
 304
 305 int dev_read_u32_array(const struct udevice *dev, const char *propname,
 306                        u32 *out_values, size_t sz)
 307 {
 308         return ofnode_read_u32_array(dev_ofnode(dev), propname, out_values, sz);
 309 }
 310
 311 const uint8_t *dev_read_u8_array_ptr(const struct udevice *dev,
 312                                      const char *propname, size_t sz)
 313 {
 314         return ofnode_read_u8_array_ptr(dev_ofnode(dev), propname, sz);
 315 }
 316
 317 int dev_read_enabled(const struct udevice *dev)
 318 {
 319         ofnode node = dev_ofnode(dev);
 320
 321         if (ofnode_is_np(node))
 322                 return of_device_is_available(ofnode_to_np(node));
 323         else
 324                 return fdtdec_get_is_enabled(gd->fdt_blob,
 325                                              ofnode_to_offset(node));
 326 }
 327
 328 int dev_read_resource(const struct udevice *dev, uint index,
 329                       struct resource *res)
 330 {
 331         return ofnode_read_resource(dev_ofnode(dev), index, res);
 332 }
 333
 334 int dev_read_resource_byname(const struct udevice *dev, const char *name,
 335                              struct resource *res)
 336 {
 337         return ofnode_read_resource_byname(dev_ofnode(dev), name, res);
 338 }
 339
 340 u64 dev_translate_address(const struct udevice *dev, const fdt32_t *in_addr)
 341 {
 342         return ofnode_translate_address(dev_ofnode(dev), in_addr);
 343 }
 344
 345 u64 dev_translate_dma_address(const struct udevice *dev, const fdt32_t *in_addr)
 346 {
 347         return ofnode_translate_dma_address(dev_ofnode(dev), in_addr);
 348 }
 349
 350 int dev_get_dma_range(const struct udevice *dev, phys_addr_t *cpu,
 351                       dma_addr_t *bus, u64 *size)
 352 {
 353         return ofnode_get_dma_range(dev_ofnode(dev), cpu, bus, size);
 354 }
 355
 356 int dev_read_alias_highest_id(const char *stem)
 357 {
 358         if (of_live_active())
 359                 return of_alias_get_highest_id(stem);
 360
 361         return fdtdec_get_alias_highest_id(gd->fdt_blob, stem);
 362 }
 363
 364 fdt_addr_t dev_read_addr_pci(const struct udevice *dev)
 365 {
 366         ulong addr;
 367
 368         addr = dev_read_addr(dev);
 369         if (addr == FDT_ADDR_T_NONE && !of_live_active())
 370                 addr = devfdt_get_addr_pci(dev);
 371
 372         return addr;
 373 }
 374
 375 int dev_get_child_count(const struct udevice *dev)
 376 {
 377         return ofnode_get_child_count(dev_ofnode(dev));
 378 }
 379
 380 int dev_read_pci_bus_range(const struct udevice *dev,
 381                            struct resource *res)
 382 {
 383         const u32 *values;
 384         int len;
 385
 386         values = dev_read_prop(dev, "bus-range", &len);
 387         if (!values || len < sizeof(*values) * 2)
 388                 return -EINVAL;
 389
 390         res->start = *values++;
 391         res->end = *values;
 392
 393         return 0;
 394 }
 395
 396 int dev_decode_display_timing(const struct udevice *dev, int index,
 397                               struct display_timing *config)
 398 {
 399         return ofnode_decode_display_timing(dev_ofnode(dev), index, config);
 400 }
 401
 402 ofnode dev_get_phy_node(const struct udevice *dev)
 403 {
 404         return ofnode_get_phy_node(dev_ofnode(dev));
 405 }
 406
 407 phy_interface_t dev_read_phy_mode(const struct udevice *dev)
 408 {
 409         return ofnode_read_phy_mode(dev_ofnode(dev));
 410 }