drivers/core/read.c

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