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