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