drivers/core/device.c

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