1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Device manager 4 * 5 * Copyright (c) 2013 Google, Inc 6 * 7 * (C) Copyright 2012 8 * Pavel Herrmann <morpheus.ibis@gmail.com> 9 */ 10 11#include <cpu_func.h> 12#include <errno.h> 13#include <event.h> 14#include <log.h> 15#include <asm/global_data.h> 16#include <asm/io.h> 17#include <clk.h> 18#include <fdtdec.h> 19#include <fdt_support.h> 20#include <malloc.h> 21#include <asm/cache.h> 22#include <dm/device.h> 23#include <dm/device-internal.h> 24#include <dm/lists.h> 25#include <dm/of_access.h> 26#include <dm/pinctrl.h> 27#include <dm/platdata.h> 28#include <dm/read.h> 29#include <dm/uclass.h> 30#include <dm/uclass-internal.h> 31#include <dm/util.h> 32#include <iommu.h> 33#include <linux/err.h> 34#include <linux/list.h> 35#include <power-domain.h> 36#include <linux/printk.h> 37 38DECLARE_GLOBAL_DATA_PTR; 39 40static int device_bind_common(struct udevice *parent, const struct driver *drv, 41 const char *name, void *plat, 42 ulong driver_data, ofnode node, 43 uint of_plat_size, struct udevice **devp) 44{ 45 struct udevice *dev; 46 struct uclass *uc; 47 int size, ret = 0; 48 bool auto_seq = true; 49 void *ptr; 50 51 if (CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND)) 52 return -ENOSYS; 53 54 if (devp) 55 *devp = NULL; 56 if (!name) 57 return -EINVAL; 58 59 ret = uclass_get(drv->id, &uc); 60 if (ret) { 61 debug("Missing uclass for driver %s\n", drv->name); 62 return ret; 63 } 64 65 dev = calloc(1, sizeof(struct udevice)); 66 if (!dev) 67 return -ENOMEM; 68 69 INIT_LIST_HEAD(&dev->sibling_node); 70 INIT_LIST_HEAD(&dev->child_head); 71 INIT_LIST_HEAD(&dev->uclass_node); 72#if CONFIG_IS_ENABLED(DEVRES) 73 INIT_LIST_HEAD(&dev->devres_head); 74#endif 75 dev_set_plat(dev, plat); 76 dev->driver_data = driver_data; 77 dev->name = name; 78 dev_set_ofnode(dev, node); 79 dev->parent = parent; 80 dev->driver = drv; 81 dev->uclass = uc; 82 83 dev->seq_ = -1; 84 if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) && 85 (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS)) { 86 /* 87 * Some devices, such as a SPI bus, I2C bus and serial ports 88 * are numbered using aliases. 89 */ 90 if (CONFIG_IS_ENABLED(OF_CONTROL) && 91 !CONFIG_IS_ENABLED(OF_PLATDATA)) { 92 if (uc->uc_drv->name && ofnode_valid(node)) { 93 if (!dev_read_alias_seq(dev, &dev->seq_)) { 94 auto_seq = false; 95 log_debug(" - seq=%d\n", dev->seq_); 96 } 97 } 98 } 99 } 100 if (auto_seq && !(uc->uc_drv->flags & DM_UC_FLAG_NO_AUTO_SEQ)) 101 dev->seq_ = uclass_find_next_free_seq(uc); 102 103 /* Check if we need to allocate plat */ 104 if (drv->plat_auto) { 105 bool alloc = !plat; 106 107 /* 108 * For of-platdata, we try use the existing data, but if 109 * plat_auto is larger, we must allocate a new space 110 */ 111 if (CONFIG_IS_ENABLED(OF_PLATDATA)) { 112 if (of_plat_size) 113 dev_or_flags(dev, DM_FLAG_OF_PLATDATA); 114 if (of_plat_size < drv->plat_auto) 115 alloc = true; 116 } 117 if (alloc) { 118 dev_or_flags(dev, DM_FLAG_ALLOC_PDATA); 119 ptr = calloc(1, drv->plat_auto); 120 if (!ptr) { 121 ret = -ENOMEM; 122 goto fail_alloc1; 123 } 124 125 /* 126 * For of-platdata, copy the old plat into the new 127 * space 128 */ 129 if (CONFIG_IS_ENABLED(OF_PLATDATA) && plat) 130 memcpy(ptr, plat, of_plat_size); 131 dev_set_plat(dev, ptr); 132 } 133 } 134 135 size = uc->uc_drv->per_device_plat_auto; 136 if (size) { 137 dev_or_flags(dev, DM_FLAG_ALLOC_UCLASS_PDATA); 138 ptr = calloc(1, size); 139 if (!ptr) { 140 ret = -ENOMEM; 141 goto fail_alloc2; 142 } 143 dev_set_uclass_plat(dev, ptr); 144 } 145 146 if (parent) { 147 size = parent->driver->per_child_plat_auto; 148 if (!size) 149 size = parent->uclass->uc_drv->per_child_plat_auto; 150 if (size) { 151 dev_or_flags(dev, DM_FLAG_ALLOC_PARENT_PDATA); 152 ptr = calloc(1, size); 153 if (!ptr) { 154 ret = -ENOMEM; 155 goto fail_alloc3; 156 } 157 dev_set_parent_plat(dev, ptr); 158 } 159 /* put dev into parent's successor list */ 160 list_add_tail(&dev->sibling_node, &parent->child_head); 161 } 162 163 ret = uclass_bind_device(dev); 164 if (ret) 165 goto fail_uclass_bind; 166 167 /* if we fail to bind we remove device from successors and free it */ 168 if (drv->bind) { 169 ret = drv->bind(dev); 170 if (ret) 171 goto fail_bind; 172 } 173 if (parent && parent->driver->child_post_bind) { 174 ret = parent->driver->child_post_bind(dev); 175 if (ret) 176 goto fail_child_post_bind; 177 } 178 if (uc->uc_drv->post_bind) { 179 ret = uc->uc_drv->post_bind(dev); 180 if (ret) 181 goto fail_uclass_post_bind; 182 } 183 184 if (parent) 185 pr_debug("Bound device %s to %s\n", dev->name, parent->name); 186 if (devp) 187 *devp = dev; 188 189 dev_or_flags(dev, DM_FLAG_BOUND); 190 191 return 0; 192 193fail_uclass_post_bind: 194 /* There is no child unbind() method, so no clean-up required */ 195fail_child_post_bind: 196 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 197 if (drv->unbind && drv->unbind(dev)) { 198 dm_warn("unbind() method failed on dev '%s' on error path\n", 199 dev->name); 200 } 201 } 202 203fail_bind: 204 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 205 if (uclass_unbind_device(dev)) { 206 dm_warn("Failed to unbind dev '%s' on error path\n", 207 dev->name); 208 } 209 } 210fail_uclass_bind: 211 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 212 list_del(&dev->sibling_node); 213 if (dev_get_flags(dev) & DM_FLAG_ALLOC_PARENT_PDATA) { 214 free(dev_get_parent_plat(dev)); 215 dev_set_parent_plat(dev, NULL); 216 } 217 } 218fail_alloc3: 219 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 220 if (dev_get_flags(dev) & DM_FLAG_ALLOC_UCLASS_PDATA) { 221 free(dev_get_uclass_plat(dev)); 222 dev_set_uclass_plat(dev, NULL); 223 } 224 } 225fail_alloc2: 226 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 227 if (dev_get_flags(dev) & DM_FLAG_ALLOC_PDATA) { 228 free(dev_get_plat(dev)); 229 dev_set_plat(dev, NULL); 230 } 231 } 232fail_alloc1: 233 devres_release_all(dev); 234 235 free(dev); 236 237 return ret; 238} 239 240int device_bind_with_driver_data(struct udevice *parent, 241 const struct driver *drv, const char *name, 242 ulong driver_data, ofnode node, 243 struct udevice **devp) 244{ 245 return device_bind_common(parent, drv, name, NULL, driver_data, node, 246 0, devp); 247} 248 249int device_bind(struct udevice *parent, const struct driver *drv, 250 const char *name, void *plat, ofnode node, 251 struct udevice **devp) 252{ 253 return device_bind_common(parent, drv, name, plat, 0, node, 0, 254 devp); 255} 256 257int device_bind_by_name(struct udevice *parent, bool pre_reloc_only, 258 const struct driver_info *info, struct udevice **devp) 259{ 260 struct driver *drv; 261 uint plat_size = 0; 262 int ret; 263 264 drv = lists_driver_lookup_name(info->name); 265 if (!drv) 266 return -ENOENT; 267 if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC)) 268 return -EPERM; 269 270#if CONFIG_IS_ENABLED(OF_PLATDATA) 271 plat_size = info->plat_size; 272#endif 273 ret = device_bind_common(parent, drv, info->name, (void *)info->plat, 0, 274 ofnode_null(), plat_size, devp); 275 if (ret) 276 return ret; 277 278 return ret; 279} 280 281int device_reparent(struct udevice *dev, struct udevice *new_parent) 282{ 283 struct udevice *pos, *n; 284 285 assert(dev); 286 assert(new_parent); 287 288 device_foreach_child_safe(pos, n, dev->parent) { 289 if (pos->driver != dev->driver) 290 continue; 291 292 list_del(&dev->sibling_node); 293 list_add_tail(&dev->sibling_node, &new_parent->child_head); 294 dev->parent = new_parent; 295 296 break; 297 } 298 299 return 0; 300} 301 302static void *alloc_priv(int size, uint flags) 303{ 304 void *priv; 305 306 if (flags & DM_FLAG_ALLOC_PRIV_DMA) { 307 size = ROUND(size, ARCH_DMA_MINALIGN); 308 priv = memalign(ARCH_DMA_MINALIGN, size); 309 if (priv) { 310 memset(priv, '\0', size); 311 312 /* 313 * Ensure that the zero bytes are flushed to memory. 314 * This prevents problems if the driver uses this as 315 * both an input and an output buffer: 316 * 317 * 1. Zeroes written to buffer (here) and sit in the 318 * cache 319 * 2. Driver issues a read command to DMA 320 * 3. CPU runs out of cache space and evicts some cache 321 * data in the buffer, writing zeroes to RAM from 322 * the memset() above 323 * 4. DMA completes 324 * 5. Buffer now has some DMA data and some zeroes 325 * 6. Data being read is now incorrect 326 * 327 * To prevent this, ensure that the cache is clean 328 * within this range at the start. The driver can then 329 * use normal flush-after-write, invalidate-before-read 330 * procedures. 331 */ 332 flush_dcache_range((ulong)priv, (ulong)priv + size); 333 } 334 } else { 335 priv = calloc(1, size); 336 } 337 338 return priv; 339} 340 341/** 342 * device_alloc_priv() - Allocate priv/plat data required by the device 343 * 344 * @dev: Device to process 345 * Return: 0 if OK, -ENOMEM if out of memory 346 */ 347static int device_alloc_priv(struct udevice *dev) 348{ 349 const struct driver *drv; 350 void *ptr; 351 int size; 352 353 drv = dev->driver; 354 assert(drv); 355 356 /* Allocate private data if requested and not reentered */ 357 if (drv->priv_auto && !dev_get_priv(dev)) { 358 ptr = alloc_priv(drv->priv_auto, drv->flags); 359 if (!ptr) 360 return -ENOMEM; 361 dev_set_priv(dev, ptr); 362 } 363 364 /* Allocate private data if requested and not reentered */ 365 size = dev->uclass->uc_drv->per_device_auto; 366 if (size && !dev_get_uclass_priv(dev)) { 367 ptr = alloc_priv(size, dev->uclass->uc_drv->flags); 368 if (!ptr) 369 return -ENOMEM; 370 dev_set_uclass_priv(dev, ptr); 371 } 372 373 /* Allocate parent data for this child */ 374 if (dev->parent) { 375 size = dev->parent->driver->per_child_auto; 376 if (!size) 377 size = dev->parent->uclass->uc_drv->per_child_auto; 378 if (size && !dev_get_parent_priv(dev)) { 379 ptr = alloc_priv(size, drv->flags); 380 if (!ptr) 381 return -ENOMEM; 382 dev_set_parent_priv(dev, ptr); 383 } 384 } 385 386 return 0; 387} 388 389int device_of_to_plat(struct udevice *dev) 390{ 391 const struct driver *drv; 392 int ret; 393 394 if (!dev) 395 return -EINVAL; 396 397 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID) 398 return 0; 399 400 /* 401 * This is not needed if binding is disabled, since data is allocated 402 * at build time. 403 */ 404 if (!CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND)) { 405 /* Ensure all parents have ofdata */ 406 if (dev->parent) { 407 ret = device_of_to_plat(dev->parent); 408 if (ret) 409 goto fail; 410 411 /* 412 * The device might have already been probed during 413 * the call to device_probe() on its parent device 414 * (e.g. PCI bridge devices). Test the flags again 415 * so that we don't mess up the device. 416 */ 417 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID) 418 return 0; 419 } 420 421 ret = device_alloc_priv(dev); 422 if (ret) 423 goto fail; 424 } 425 drv = dev->driver; 426 assert(drv); 427 428 if (drv->of_to_plat && 429 (CONFIG_IS_ENABLED(OF_PLATDATA) || dev_has_ofnode(dev))) { 430 ret = drv->of_to_plat(dev); 431 if (ret) 432 goto fail; 433 } 434 435 dev_or_flags(dev, DM_FLAG_PLATDATA_VALID); 436 437 return 0; 438fail: 439 device_free(dev); 440 441 return ret; 442} 443 444/** 445 * device_get_dma_constraints() - Populate device's DMA constraints 446 * 447 * Gets a device's DMA constraints from firmware. This information is later 448 * used by drivers to translate physcal addresses to the device's bus address 449 * space. For now only device-tree is supported. 450 * 451 * @dev: Pointer to target device 452 * Return: 0 if OK or if no DMA constraints were found, error otherwise 453 */ 454static int device_get_dma_constraints(struct udevice *dev) 455{ 456 struct udevice *parent = dev->parent; 457 phys_addr_t cpu = 0; 458 dma_addr_t bus = 0; 459 u64 size = 0; 460 int ret; 461 462 if (!CONFIG_IS_ENABLED(DM_DMA) || !parent || !dev_has_ofnode(parent)) 463 return 0; 464 465 /* 466 * We start parsing for dma-ranges from the device's bus node. This is 467 * specially important on nested buses. 468 */ 469 ret = dev_get_dma_range(parent, &cpu, &bus, &size); 470 /* Don't return an error if no 'dma-ranges' were found */ 471 if (ret && ret != -ENOENT) { 472 dm_warn("%s: failed to get DMA range, %d\n", dev->name, ret); 473 return ret; 474 } 475 476 dev_set_dma_offset(dev, cpu - bus); 477 478 return 0; 479} 480 481int device_probe(struct udevice *dev) 482{ 483 const struct driver *drv; 484 int ret; 485 486 if (!dev) 487 return -EINVAL; 488 489 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED) 490 return 0; 491 492 ret = device_notify(dev, EVT_DM_PRE_PROBE); 493 if (ret) 494 return ret; 495 496 drv = dev->driver; 497 assert(drv); 498 499 ret = device_of_to_plat(dev); 500 if (ret) 501 goto fail; 502 503 /* Ensure all parents are probed */ 504 if (dev->parent) { 505 ret = device_probe(dev->parent); 506 if (ret) 507 goto fail; 508 509 /* 510 * The device might have already been probed during 511 * the call to device_probe() on its parent device 512 * (e.g. PCI bridge devices). Test the flags again 513 * so that we don't mess up the device. 514 */ 515 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED) 516 return 0; 517 } 518 519 dev_or_flags(dev, DM_FLAG_ACTIVATED); 520 521 if (CONFIG_IS_ENABLED(POWER_DOMAIN) && dev->parent && 522 (device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) && 523 !(drv->flags & DM_FLAG_DEFAULT_PD_CTRL_OFF)) { 524 ret = dev_power_domain_on(dev); 525 if (ret) 526 goto fail; 527 } 528 529 /* 530 * Process pinctrl for everything except the root device, and 531 * continue regardless of the result of pinctrl. Don't process pinctrl 532 * settings for pinctrl devices since the device may not yet be 533 * probed. 534 * 535 * This call can produce some non-intuitive results. For example, on an 536 * x86 device where dev is the main PCI bus, the pinctrl device may be 537 * child or grandchild of that bus, meaning that the child will be 538 * probed here. If the child happens to be the P2SB and the pinctrl 539 * device is a child of that, then both the pinctrl and P2SB will be 540 * probed by this call. This works because the DM_FLAG_ACTIVATED flag 541 * is set just above. However, the PCI bus' probe() method and 542 * associated uclass methods have not yet been called. 543 */ 544 if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL) { 545 ret = pinctrl_select_state(dev, "default"); 546 if (ret && ret != -ENOSYS) 547 log_debug("Device '%s' failed to configure default pinctrl: %d (%s)\n", 548 dev->name, ret, errno_str(ret)); 549 } 550 551 if (CONFIG_IS_ENABLED(IOMMU) && dev->parent && 552 (device_get_uclass_id(dev) != UCLASS_IOMMU)) { 553 ret = dev_iommu_enable(dev); 554 if (ret) 555 goto fail; 556 } 557 558 ret = device_get_dma_constraints(dev); 559 if (ret) 560 goto fail; 561 562 ret = uclass_pre_probe_device(dev); 563 if (ret) 564 goto fail; 565 566 if (dev->parent && dev->parent->driver->child_pre_probe) { 567 ret = dev->parent->driver->child_pre_probe(dev); 568 if (ret) 569 goto fail; 570 } 571 572 /* Only handle devices that have a valid ofnode */ 573 if (dev_has_ofnode(dev)) { 574 /* 575 * Process 'assigned-{clocks/clock-parents/clock-rates}' 576 * properties 577 */ 578 ret = clk_set_defaults(dev, CLK_DEFAULTS_PRE); 579 if (ret) 580 goto fail; 581 } 582 583 if (drv->probe) { 584 ret = drv->probe(dev); 585 if (ret) 586 goto fail; 587 } 588 589 ret = uclass_post_probe_device(dev); 590 if (ret) 591 goto fail_uclass; 592 593 if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL) { 594 ret = pinctrl_select_state(dev, "default"); 595 if (ret && ret != -ENOSYS) 596 log_debug("Device '%s' failed to configure default pinctrl: %d (%s)\n", 597 dev->name, ret, errno_str(ret)); 598 } 599 600 ret = device_notify(dev, EVT_DM_POST_PROBE); 601 if (ret) 602 goto fail_event; 603 604 return 0; 605fail_event: 606fail_uclass: 607 if (device_remove(dev, DM_REMOVE_NORMAL)) { 608 dm_warn("%s: Device '%s' failed to remove on error path\n", 609 __func__, dev->name); 610 } 611fail: 612 dev_bic_flags(dev, DM_FLAG_ACTIVATED); 613 614 device_free(dev); 615 616 return ret; 617} 618 619void *dev_get_plat(const struct udevice *dev) 620{ 621 if (!dev) { 622 dm_warn("%s: null device\n", __func__); 623 return NULL; 624 } 625 626 return dm_priv_to_rw(dev->plat_); 627} 628 629void *dev_get_parent_plat(const struct udevice *dev) 630{ 631 if (!dev) { 632 dm_warn("%s: null device\n", __func__); 633 return NULL; 634 } 635 636 return dm_priv_to_rw(dev->parent_plat_); 637} 638 639void *dev_get_uclass_plat(const struct udevice *dev) 640{ 641 if (!dev) { 642 dm_warn("%s: null device\n", __func__); 643 return NULL; 644 } 645 646 return dm_priv_to_rw(dev->uclass_plat_); 647} 648 649void *dev_get_priv(const struct udevice *dev) 650{ 651 if (!dev) { 652 dm_warn("%s: null device\n", __func__); 653 return NULL; 654 } 655 656 return dm_priv_to_rw(dev->priv_); 657} 658 659/* notrace is needed as this is called by timer_get_rate() */ 660notrace void *dev_get_uclass_priv(const struct udevice *dev) 661{ 662 if (!dev) { 663 dm_warn("%s: null device\n", __func__); 664 return NULL; 665 } 666 667 return dm_priv_to_rw(dev->uclass_priv_); 668} 669 670void *dev_get_parent_priv(const struct udevice *dev) 671{ 672 if (!dev) { 673 dm_warn("%s: null device\n", __func__); 674 return NULL; 675 } 676 677 return dm_priv_to_rw(dev->parent_priv_); 678} 679 680void *dev_get_attach_ptr(const struct udevice *dev, enum dm_tag_t tag) 681{ 682 switch (tag) { 683 case DM_TAG_PLAT: 684 return dev_get_plat(dev); 685 case DM_TAG_PARENT_PLAT: 686 return dev_get_parent_plat(dev); 687 case DM_TAG_UC_PLAT: 688 return dev_get_uclass_plat(dev); 689 case DM_TAG_PRIV: 690 return dev_get_priv(dev); 691 case DM_TAG_PARENT_PRIV: 692 return dev_get_parent_priv(dev); 693 case DM_TAG_UC_PRIV: 694 return dev_get_uclass_priv(dev); 695 default: 696 return NULL; 697 } 698} 699 700int dev_get_attach_size(const struct udevice *dev, enum dm_tag_t tag) 701{ 702 const struct udevice *parent = dev_get_parent(dev); 703 const struct uclass *uc = dev->uclass; 704 const struct uclass_driver *uc_drv = uc->uc_drv; 705 const struct driver *parent_drv = NULL; 706 int size = 0; 707 708 if (parent) 709 parent_drv = parent->driver; 710 711 switch (tag) { 712 case DM_TAG_PLAT: 713 size = dev->driver->plat_auto; 714 break; 715 case DM_TAG_PARENT_PLAT: 716 if (parent) { 717 size = parent_drv->per_child_plat_auto; 718 if (!size) 719 size = parent->uclass->uc_drv->per_child_plat_auto; 720 } 721 break; 722 case DM_TAG_UC_PLAT: 723 size = uc_drv->per_device_plat_auto; 724 break; 725 case DM_TAG_PRIV: 726 size = dev->driver->priv_auto; 727 break; 728 case DM_TAG_PARENT_PRIV: 729 if (parent) { 730 size = parent_drv->per_child_auto; 731 if (!size) 732 size = parent->uclass->uc_drv->per_child_auto; 733 } 734 break; 735 case DM_TAG_UC_PRIV: 736 size = uc_drv->per_device_auto; 737 break; 738 default: 739 break; 740 } 741 742 return size; 743} 744 745static int device_get_device_tail(struct udevice *dev, int ret, 746 struct udevice **devp) 747{ 748 if (ret) 749 return ret; 750 751 ret = device_probe(dev); 752 if (ret) 753 return ret; 754 755 *devp = dev; 756 757 return 0; 758} 759 760#if CONFIG_IS_ENABLED(OF_REAL) 761/** 762 * device_find_by_ofnode() - Return device associated with given ofnode 763 * 764 * The returned device is *not* activated. 765 * 766 * @node: The ofnode for which a associated device should be looked up 767 * @devp: Pointer to structure to hold the found device 768 * Return: 0 if OK, -ve on error 769 */ 770static int device_find_by_ofnode(ofnode node, struct udevice **devp) 771{ 772 struct uclass *uc; 773 struct udevice *dev; 774 int ret; 775 776 list_for_each_entry(uc, gd->uclass_root, sibling_node) { 777 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node, 778 &dev); 779 if (!ret || dev) { 780 *devp = dev; 781 return 0; 782 } 783 } 784 785 return -ENODEV; 786} 787#endif 788 789int device_get_child(const struct udevice *parent, int index, 790 struct udevice **devp) 791{ 792 struct udevice *dev; 793 794 device_foreach_child(dev, parent) { 795 if (!index--) 796 return device_get_device_tail(dev, 0, devp); 797 } 798 799 return -ENODEV; 800} 801 802int device_get_child_count(const struct udevice *parent) 803{ 804 struct udevice *dev; 805 int count = 0; 806 807 device_foreach_child(dev, parent) 808 count++; 809 810 return count; 811} 812 813int device_get_decendent_count(const struct udevice *parent) 814{ 815 const struct udevice *dev; 816 int count = 1; 817 818 device_foreach_child(dev, parent) 819 count += device_get_decendent_count(dev); 820 821 return count; 822} 823 824int device_find_child_by_seq(const struct udevice *parent, int seq, 825 struct udevice **devp) 826{ 827 struct udevice *dev; 828 829 *devp = NULL; 830 831 device_foreach_child(dev, parent) { 832 if (dev->seq_ == seq) { 833 *devp = dev; 834 return 0; 835 } 836 } 837 838 return -ENODEV; 839} 840 841int device_get_child_by_seq(const struct udevice *parent, int seq, 842 struct udevice **devp) 843{ 844 struct udevice *dev; 845 int ret; 846 847 *devp = NULL; 848 ret = device_find_child_by_seq(parent, seq, &dev); 849 850 return device_get_device_tail(dev, ret, devp); 851} 852 853int device_find_child_by_of_offset(const struct udevice *parent, int of_offset, 854 struct udevice **devp) 855{ 856 struct udevice *dev; 857 858 *devp = NULL; 859 860 device_foreach_child(dev, parent) { 861 if (dev_of_offset(dev) == of_offset) { 862 *devp = dev; 863 return 0; 864 } 865 } 866 867 return -ENODEV; 868} 869 870int device_get_child_by_of_offset(const struct udevice *parent, int node, 871 struct udevice **devp) 872{ 873 struct udevice *dev; 874 int ret; 875 876 *devp = NULL; 877 ret = device_find_child_by_of_offset(parent, node, &dev); 878 return device_get_device_tail(dev, ret, devp); 879} 880 881static struct udevice *_device_find_global_by_ofnode(struct udevice *parent, 882 ofnode ofnode) 883{ 884 struct udevice *dev, *found; 885 886 if (ofnode_equal(dev_ofnode(parent), ofnode)) 887 return parent; 888 889 device_foreach_child(dev, parent) { 890 found = _device_find_global_by_ofnode(dev, ofnode); 891 if (found) 892 return found; 893 } 894 895 return NULL; 896} 897 898int device_find_global_by_ofnode(ofnode ofnode, struct udevice **devp) 899{ 900 *devp = _device_find_global_by_ofnode(gd->dm_root, ofnode); 901 902 return *devp ? 0 : -ENOENT; 903} 904 905int device_get_global_by_ofnode(ofnode ofnode, struct udevice **devp) 906{ 907 struct udevice *dev; 908 909 dev = _device_find_global_by_ofnode(gd->dm_root, ofnode); 910 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp); 911} 912 913#if CONFIG_IS_ENABLED(OF_PLATDATA) 914int device_get_by_ofplat_idx(uint idx, struct udevice **devp) 915{ 916 struct udevice *dev; 917 918 if (CONFIG_IS_ENABLED(OF_PLATDATA_INST)) { 919 struct udevice *base = ll_entry_start(struct udevice, udevice); 920 921 dev = base + idx; 922 } else { 923 struct driver_rt *drt = gd_dm_driver_rt() + idx; 924 925 dev = drt->dev; 926 } 927 *devp = NULL; 928 929 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp); 930} 931#endif 932 933int device_find_first_child(const struct udevice *parent, struct udevice **devp) 934{ 935 if (list_empty(&parent->child_head)) { 936 *devp = NULL; 937 } else { 938 *devp = list_first_entry(&parent->child_head, struct udevice, 939 sibling_node); 940 } 941 942 return 0; 943} 944 945int device_find_next_child(struct udevice **devp) 946{ 947 struct udevice *dev = *devp; 948 struct udevice *parent = dev->parent; 949 950 if (list_is_last(&dev->sibling_node, &parent->child_head)) { 951 *devp = NULL; 952 } else { 953 *devp = list_entry(dev->sibling_node.next, struct udevice, 954 sibling_node); 955 } 956 957 return 0; 958} 959 960int device_find_first_inactive_child(const struct udevice *parent, 961 enum uclass_id uclass_id, 962 struct udevice **devp) 963{ 964 struct udevice *dev; 965 966 *devp = NULL; 967 device_foreach_child(dev, parent) { 968 if (!device_active(dev) && 969 device_get_uclass_id(dev) == uclass_id) { 970 *devp = dev; 971 return 0; 972 } 973 } 974 975 return -ENODEV; 976} 977 978int device_find_first_child_by_uclass(const struct udevice *parent, 979 enum uclass_id uclass_id, 980 struct udevice **devp) 981{ 982 struct udevice *dev; 983 984 *devp = NULL; 985 device_foreach_child(dev, parent) { 986 if (device_get_uclass_id(dev) == uclass_id) { 987 *devp = dev; 988 return 0; 989 } 990 } 991 992 return -ENODEV; 993} 994 995int device_find_child_by_namelen(const struct udevice *parent, const char *name, 996 int len, struct udevice **devp) 997{ 998 struct udevice *dev; 999 1000 *devp = NULL; 1001 1002 device_foreach_child(dev, parent) { 1003 if (!strncmp(dev->name, name, len) && 1004 strlen(dev->name) == len) { 1005 *devp = dev; 1006 return 0; 1007 } 1008 } 1009 1010 return -ENODEV; 1011} 1012 1013int device_find_child_by_name(const struct udevice *parent, const char *name, 1014 struct udevice **devp) 1015{ 1016 return device_find_child_by_namelen(parent, name, strlen(name), devp); 1017} 1018 1019int device_first_child_err(struct udevice *parent, struct udevice **devp) 1020{ 1021 struct udevice *dev; 1022 1023 device_find_first_child(parent, &dev); 1024 if (!dev) 1025 return -ENODEV; 1026 1027 return device_get_device_tail(dev, 0, devp); 1028} 1029 1030int device_next_child_err(struct udevice **devp) 1031{ 1032 struct udevice *dev = *devp; 1033 1034 device_find_next_child(&dev); 1035 if (!dev) 1036 return -ENODEV; 1037 1038 return device_get_device_tail(dev, 0, devp); 1039} 1040 1041int device_first_child_ofdata_err(struct udevice *parent, struct udevice **devp) 1042{ 1043 struct udevice *dev; 1044 int ret; 1045 1046 device_find_first_child(parent, &dev); 1047 if (!dev) 1048 return -ENODEV; 1049 1050 ret = device_of_to_plat(dev); 1051 if (ret) 1052 return ret; 1053 1054 *devp = dev; 1055 1056 return 0; 1057} 1058 1059int device_next_child_ofdata_err(struct udevice **devp) 1060{ 1061 struct udevice *dev = *devp; 1062 int ret; 1063 1064 device_find_next_child(&dev); 1065 if (!dev) 1066 return -ENODEV; 1067 1068 ret = device_of_to_plat(dev); 1069 if (ret) 1070 return ret; 1071 1072 *devp = dev; 1073 1074 return 0; 1075} 1076 1077struct udevice *dev_get_parent(const struct udevice *child) 1078{ 1079 return child->parent; 1080} 1081 1082ulong dev_get_driver_data(const struct udevice *dev) 1083{ 1084 return dev->driver_data; 1085} 1086 1087const void *dev_get_driver_ops(const struct udevice *dev) 1088{ 1089 if (!dev || !dev->driver->ops) 1090 return NULL; 1091 1092 return dev->driver->ops; 1093} 1094 1095enum uclass_id device_get_uclass_id(const struct udevice *dev) 1096{ 1097 return dev->uclass->uc_drv->id; 1098} 1099 1100const char *dev_get_uclass_name(const struct udevice *dev) 1101{ 1102 if (!dev) 1103 return NULL; 1104 1105 return dev->uclass->uc_drv->name; 1106} 1107 1108bool device_has_children(const struct udevice *dev) 1109{ 1110 return !list_empty(&dev->child_head); 1111} 1112 1113bool device_has_active_children(const struct udevice *dev) 1114{ 1115 struct udevice *child; 1116 1117 for (device_find_first_child(dev, &child); 1118 child; 1119 device_find_next_child(&child)) { 1120 if (device_active(child)) 1121 return true; 1122 } 1123 1124 return false; 1125} 1126 1127bool device_is_last_sibling(const struct udevice *dev) 1128{ 1129 struct udevice *parent = dev->parent; 1130 1131 if (!parent) 1132 return false; 1133 return list_is_last(&dev->sibling_node, &parent->child_head); 1134} 1135 1136void device_set_name_alloced(struct udevice *dev) 1137{ 1138 dev_or_flags(dev, DM_FLAG_NAME_ALLOCED); 1139} 1140 1141int device_set_name(struct udevice *dev, const char *name) 1142{ 1143 name = strdup(name); 1144 if (!name) 1145 return -ENOMEM; 1146 dev->name = name; 1147 device_set_name_alloced(dev); 1148 1149 return 0; 1150} 1151 1152void dev_set_priv(struct udevice *dev, void *priv) 1153{ 1154 dev->priv_ = priv; 1155} 1156 1157void dev_set_parent_priv(struct udevice *dev, void *parent_priv) 1158{ 1159 dev->parent_priv_ = parent_priv; 1160} 1161 1162void dev_set_uclass_priv(struct udevice *dev, void *uclass_priv) 1163{ 1164 dev->uclass_priv_ = uclass_priv; 1165} 1166 1167void dev_set_plat(struct udevice *dev, void *plat) 1168{ 1169 dev->plat_ = plat; 1170} 1171 1172void dev_set_parent_plat(struct udevice *dev, void *parent_plat) 1173{ 1174 dev->parent_plat_ = parent_plat; 1175} 1176 1177void dev_set_uclass_plat(struct udevice *dev, void *uclass_plat) 1178{ 1179 dev->uclass_plat_ = uclass_plat; 1180} 1181 1182#if CONFIG_IS_ENABLED(OF_REAL) 1183bool device_is_compatible(const struct udevice *dev, const char *compat) 1184{ 1185 return ofnode_device_is_compatible(dev_ofnode(dev), compat); 1186} 1187 1188bool of_machine_is_compatible(const char *compat) 1189{ 1190 return ofnode_device_is_compatible(ofnode_root(), compat); 1191} 1192 1193int dev_disable_by_path(const char *path) 1194{ 1195 struct uclass *uc; 1196 ofnode node = ofnode_path(path); 1197 struct udevice *dev; 1198 int ret = 1; 1199 1200 if (!of_live_active()) 1201 return -ENOSYS; 1202 1203 list_for_each_entry(uc, gd->uclass_root, sibling_node) { 1204 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node, &dev); 1205 if (!ret) 1206 break; 1207 } 1208 1209 if (ret) 1210 return ret; 1211 1212 ret = device_remove(dev, DM_REMOVE_NORMAL); 1213 if (ret) 1214 return ret; 1215 1216 ret = device_unbind(dev); 1217 if (ret) 1218 return ret; 1219 1220 return ofnode_set_enabled(node, false); 1221} 1222 1223int dev_enable_by_path(const char *path) 1224{ 1225 ofnode node = ofnode_path(path); 1226 ofnode pnode = ofnode_get_parent(node); 1227 struct udevice *parent; 1228 int ret = 1; 1229 1230 if (!of_live_active()) 1231 return -ENOSYS; 1232 1233 ret = device_find_by_ofnode(pnode, &parent); 1234 if (ret) 1235 return ret; 1236 1237 ret = ofnode_set_enabled(node, true); 1238 if (ret) 1239 return ret; 1240 1241 return lists_bind_fdt(parent, node, NULL, NULL, false); 1242} 1243#endif 1244 1245#if CONFIG_IS_ENABLED(OF_PLATDATA_RT) 1246static struct udevice_rt *dev_get_rt(const struct udevice *dev) 1247{ 1248 struct udevice *base = ll_entry_start(struct udevice, udevice); 1249 uint each_size = dm_udevice_size(); 1250 int idx = ((void *)dev - (void *)base) / each_size; 1251 1252 struct udevice_rt *urt = gd_dm_udevice_rt() + idx; 1253 1254 return urt; 1255} 1256 1257u32 dev_get_flags(const struct udevice *dev) 1258{ 1259 const struct udevice_rt *urt = dev_get_rt(dev); 1260 1261 return urt->flags_; 1262} 1263 1264void dev_or_flags(const struct udevice *dev, u32 or) 1265{ 1266 struct udevice_rt *urt = dev_get_rt(dev); 1267 1268 urt->flags_ |= or; 1269} 1270 1271void dev_bic_flags(const struct udevice *dev, u32 bic) 1272{ 1273 struct udevice_rt *urt = dev_get_rt(dev); 1274 1275 urt->flags_ &= ~bic; 1276} 1277#endif /* OF_PLATDATA_RT */ 1278