Home | History | Annotate | Download | only in core 
      1 // SPDX-License-Identifier: GPL-2.0+
      2 /*
      3  * Copyright (c) 2017 Google, Inc
      4  * Written by Simon Glass <sjg (at) chromium.org>
      5  */
      6 
      7 #include <asm/types.h>
      8 #include <asm/io.h>
      9 #include <common.h>
     10 #include <dm.h>
     11 #include <mapmem.h>
     12 #include <dm/of_access.h>
     13 
     14 int dev_read_u32(struct udevice *dev, const char *propname, u32 *outp)
     15 {
     16 	return ofnode_read_u32(dev_ofnode(dev), propname, outp);
     17 }
     18 
     19 int dev_read_u32_default(struct udevice *dev, const char *propname, int def)
     20 {
     21 	return ofnode_read_u32_default(dev_ofnode(dev), propname, def);
     22 }
     23 
     24 const char *dev_read_string(struct udevice *dev, const char *propname)
     25 {
     26 	return ofnode_read_string(dev_ofnode(dev), propname);
     27 }
     28 
     29 bool dev_read_bool(struct udevice *dev, const char *propname)
     30 {
     31 	return ofnode_read_bool(dev_ofnode(dev), propname);
     32 }
     33 
     34 ofnode dev_read_subnode(struct udevice *dev, const char *subnode_name)
     35 {
     36 	return ofnode_find_subnode(dev_ofnode(dev), subnode_name);
     37 }
     38 
     39 ofnode dev_read_first_subnode(struct udevice *dev)
     40 {
     41 	return ofnode_first_subnode(dev_ofnode(dev));
     42 }
     43 
     44 ofnode dev_read_next_subnode(ofnode node)
     45 {
     46 	return ofnode_next_subnode(node);
     47 }
     48 
     49 int dev_read_size(struct udevice *dev, const char *propname)
     50 {
     51 	return ofnode_read_size(dev_ofnode(dev), propname);
     52 }
     53 
     54 fdt_addr_t dev_read_addr_index(struct udevice *dev, int index)
     55 {
     56 	if (ofnode_is_np(dev_ofnode(dev)))
     57 		return ofnode_get_addr_index(dev_ofnode(dev), index);
     58 	else
     59 		return devfdt_get_addr_index(dev, index);
     60 }
     61 
     62 void *dev_remap_addr_index(struct udevice *dev, int index)
     63 {
     64 	fdt_addr_t addr = dev_read_addr_index(dev, index);
     65 
     66 	if (addr == FDT_ADDR_T_NONE)
     67 		return NULL;
     68 
     69 	return map_physmem(addr, 0, MAP_NOCACHE);
     70 }
     71 
     72 fdt_addr_t dev_read_addr(struct udevice *dev)
     73 {
     74 	return dev_read_addr_index(dev, 0);
     75 }
     76 
     77 void *dev_read_addr_ptr(struct udevice *dev)
     78 {
     79 	fdt_addr_t addr = dev_read_addr(dev);
     80 
     81 	return (addr == FDT_ADDR_T_NONE) ? NULL : map_sysmem(addr, 0);
     82 }
     83 
     84 void *dev_remap_addr(struct udevice *dev)
     85 {
     86 	return dev_remap_addr_index(dev, 0);
     87 }
     88 
     89 fdt_addr_t dev_read_addr_size(struct udevice *dev, const char *property,
     90 			      fdt_size_t *sizep)
     91 {
     92 	return ofnode_get_addr_size(dev_ofnode(dev), property, sizep);
     93 }
     94 
     95 const char *dev_read_name(struct udevice *dev)
     96 {
     97 	return ofnode_get_name(dev_ofnode(dev));
     98 }
     99 
    100 int dev_read_stringlist_search(struct udevice *dev, const char *property,
    101 			       const char *string)
    102 {
    103 	return ofnode_stringlist_search(dev_ofnode(dev), property, string);
    104 }
    105 
    106 int dev_read_string_index(struct udevice *dev, const char *propname, int index,
    107 			  const char **outp)
    108 {
    109 	return ofnode_read_string_index(dev_ofnode(dev), propname, index, outp);
    110 }
    111 
    112 int dev_read_string_count(struct udevice *dev, const char *propname)
    113 {
    114 	return ofnode_read_string_count(dev_ofnode(dev), propname);
    115 }
    116 
    117 int dev_read_phandle_with_args(struct udevice *dev, const char *list_name,
    118 			       const char *cells_name, int cell_count,
    119 			       int index, struct ofnode_phandle_args *out_args)
    120 {
    121 	return ofnode_parse_phandle_with_args(dev_ofnode(dev), list_name,
    122 					      cells_name, cell_count, index,
    123 					      out_args);
    124 }
    125 
    126 int dev_count_phandle_with_args(struct udevice *dev, const char *list_name,
    127 				const char *cells_name)
    128 {
    129 	return ofnode_count_phandle_with_args(dev_ofnode(dev), list_name,
    130 					      cells_name);
    131 }
    132 
    133 int dev_read_addr_cells(struct udevice *dev)
    134 {
    135 	return ofnode_read_addr_cells(dev_ofnode(dev));
    136 }
    137 
    138 int dev_read_size_cells(struct udevice *dev)
    139 {
    140 	return ofnode_read_size_cells(dev_ofnode(dev));
    141 }
    142 
    143 int dev_read_simple_addr_cells(struct udevice *dev)
    144 {
    145 	return ofnode_read_simple_addr_cells(dev_ofnode(dev));
    146 }
    147 
    148 int dev_read_simple_size_cells(struct udevice *dev)
    149 {
    150 	return ofnode_read_simple_size_cells(dev_ofnode(dev));
    151 }
    152 
    153 int dev_read_phandle(struct udevice *dev)
    154 {
    155 	ofnode node = dev_ofnode(dev);
    156 
    157 	if (ofnode_is_np(node))
    158 		return ofnode_to_np(node)->phandle;
    159 	else
    160 		return fdt_get_phandle(gd->fdt_blob, ofnode_to_offset(node));
    161 }
    162 
    163 const void *dev_read_prop(struct udevice *dev, const char *propname, int *lenp)
    164 {
    165 	return ofnode_get_property(dev_ofnode(dev), propname, lenp);
    166 }
    167 
    168 int dev_read_alias_seq(struct udevice *dev, int *devnump)
    169 {
    170 	ofnode node = dev_ofnode(dev);
    171 	const char *uc_name = dev->uclass->uc_drv->name;
    172 	int ret;
    173 
    174 	if (ofnode_is_np(node)) {
    175 		ret = of_alias_get_id(ofnode_to_np(node), uc_name);
    176 		if (ret >= 0)
    177 			*devnump = ret;
    178 	} else {
    179 		ret = fdtdec_get_alias_seq(gd->fdt_blob, uc_name,
    180 					   ofnode_to_offset(node), devnump);
    181 	}
    182 
    183 	return ret;
    184 }
    185 
    186 int dev_read_u32_array(struct udevice *dev, const char *propname,
    187 		       u32 *out_values, size_t sz)
    188 {
    189 	return ofnode_read_u32_array(dev_ofnode(dev), propname, out_values, sz);
    190 }
    191 
    192 const uint8_t *dev_read_u8_array_ptr(struct udevice *dev, const char *propname,
    193 				     size_t sz)
    194 {
    195 	return ofnode_read_u8_array_ptr(dev_ofnode(dev), propname, sz);
    196 }
    197 
    198 int dev_read_enabled(struct udevice *dev)
    199 {
    200 	ofnode node = dev_ofnode(dev);
    201 
    202 	if (ofnode_is_np(node))
    203 		return of_device_is_available(ofnode_to_np(node));
    204 	else
    205 		return fdtdec_get_is_enabled(gd->fdt_blob,
    206 					     ofnode_to_offset(node));
    207 }
    208 
    209 int dev_read_resource(struct udevice *dev, uint index, struct resource *res)
    210 {
    211 	return ofnode_read_resource(dev_ofnode(dev), index, res);
    212 }
    213 
    214 int dev_read_resource_byname(struct udevice *dev, const char *name,
    215 			     struct resource *res)
    216 {
    217 	return ofnode_read_resource_byname(dev_ofnode(dev), name, res);
    218 }
    219 
    220 u64 dev_translate_address(struct udevice *dev, const fdt32_t *in_addr)
    221 {
    222 	return ofnode_translate_address(dev_ofnode(dev), in_addr);
    223 }
    224