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 <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 15int 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 20u8 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 25int 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 30u16 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 36int 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 41int 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 47int 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 53u32 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 60int 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 65int 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 71int 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 84int 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 89u64 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 95const char *dev_read_string(const struct udevice *dev, const char *propname) 96{ 97 return ofnode_read_string(dev_ofnode(dev), propname); 98} 99 100bool dev_read_bool(const struct udevice *dev, const char *propname) 101{ 102 return ofnode_read_bool(dev_ofnode(dev), propname); 103} 104 105ofnode dev_read_subnode(const struct udevice *dev, const char *subnode_name) 106{ 107 return ofnode_find_subnode(dev_ofnode(dev), subnode_name); 108} 109 110ofnode dev_read_first_subnode(const struct udevice *dev) 111{ 112 return ofnode_first_subnode(dev_ofnode(dev)); 113} 114 115ofnode dev_read_next_subnode(ofnode node) 116{ 117 return ofnode_next_subnode(node); 118} 119 120int dev_read_size(const struct udevice *dev, const char *propname) 121{ 122 return ofnode_read_size(dev_ofnode(dev), propname); 123} 124 125fdt_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 133void *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 143fdt_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 152void *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 163void *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 173fdt_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 183void *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 193fdt_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 204void *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 215void *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 225fdt_addr_t dev_read_addr(const struct udevice *dev) 226{ 227 return dev_read_addr_index(dev, 0); 228} 229 230void *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 240void *dev_remap_addr(const struct udevice *dev) 241{ 242 return dev_remap_addr_index(dev, 0); 243} 244 245fdt_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 250const char *dev_read_name(const struct udevice *dev) 251{ 252 return ofnode_get_name(dev_ofnode(dev)); 253} 254 255int 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 261int 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 267int dev_read_string_count(const struct udevice *dev, const char *propname) 268{ 269 return ofnode_read_string_count(dev_ofnode(dev), propname); 270} 271 272int 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 278int 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 287int 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 295int dev_read_addr_cells(const struct udevice *dev) 296{ 297 return ofnode_read_addr_cells(dev_ofnode(dev)); 298} 299 300int dev_read_size_cells(const struct udevice *dev) 301{ 302 return ofnode_read_size_cells(dev_ofnode(dev)); 303} 304 305int dev_read_simple_addr_cells(const struct udevice *dev) 306{ 307 return ofnode_read_simple_addr_cells(dev_ofnode(dev)); 308} 309 310int dev_read_simple_size_cells(const struct udevice *dev) 311{ 312 return ofnode_read_simple_size_cells(dev_ofnode(dev)); 313} 314 315int 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 325const 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 331int dev_read_first_prop(const struct udevice *dev, struct ofprop *prop) 332{ 333 return ofnode_first_property(dev_ofnode(dev), prop); 334} 335 336int dev_read_next_prop(struct ofprop *prop) 337{ 338 return ofnode_next_property(prop); 339} 340 341const 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 347int 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 369int 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 375const 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 381int 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 392int 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 398int 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 404u64 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 409u64 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 414int 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 420int 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 428fdt_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 441int dev_get_child_count(const struct udevice *dev) 442{ 443 return ofnode_get_child_count(dev_ofnode(dev)); 444} 445 446int 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 462int 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 468int 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 474ofnode dev_get_phy_node(const struct udevice *dev) 475{ 476 return ofnode_get_phy_node(dev_ofnode(dev)); 477} 478 479phy_interface_t dev_read_phy_mode(const struct udevice *dev) 480{ 481 return ofnode_read_phy_mode(dev_ofnode(dev)); 482} 483