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 <asm/io.h> 13 #include <clk.h> 14 #include <fdtdec.h> 15 #include <fdt_support.h> 16 #include <malloc.h> 17 #include <dm/device.h> 18 #include <dm/device-internal.h> 19 #include <dm/lists.h> 20 #include <dm/of_access.h> 21 #include <dm/pinctrl.h> 22 #include <dm/platdata.h> 23 #include <dm/read.h> 24 #include <dm/uclass.h> 25 #include <dm/uclass-internal.h> 26 #include <dm/util.h> 27 #include <linux/err.h> 28 #include <linux/list.h> 29 #include <power-domain.h> 30 31 DECLARE_GLOBAL_DATA_PTR; 32 33 static int device_bind_common(struct udevice *parent, const struct driver *drv, 34 const char *name, void *platdata, 35 ulong driver_data, ofnode node, 36 uint of_platdata_size, struct udevice **devp) 37 { 38 struct udevice *dev; 39 struct uclass *uc; 40 int size, ret = 0; 41 42 if (devp) 43 *devp = NULL; 44 if (!name) 45 return -EINVAL; 46 47 ret = uclass_get(drv->id, &uc); 48 if (ret) { 49 debug("Missing uclass for driver %s\n", drv->name); 50 return ret; 51 } 52 53 dev = calloc(1, sizeof(struct udevice)); 54 if (!dev) 55 return -ENOMEM; 56 57 INIT_LIST_HEAD(&dev->sibling_node); 58 INIT_LIST_HEAD(&dev->child_head); 59 INIT_LIST_HEAD(&dev->uclass_node); 60 #ifdef CONFIG_DEVRES 61 INIT_LIST_HEAD(&dev->devres_head); 62 #endif 63 dev->platdata = platdata; 64 dev->driver_data = driver_data; 65 dev->name = name; 66 dev->node = node; 67 dev->parent = parent; 68 dev->driver = drv; 69 dev->uclass = uc; 70 71 dev->seq = -1; 72 dev->req_seq = -1; 73 if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) && 74 (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS)) { 75 /* 76 * Some devices, such as a SPI bus, I2C bus and serial ports 77 * are numbered using aliases. 78 * 79 * This is just a 'requested' sequence, and will be 80 * resolved (and ->seq updated) when the device is probed. 81 */ 82 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) { 83 if (uc->uc_drv->name && ofnode_valid(node)) 84 dev_read_alias_seq(dev, &dev->req_seq); 85 } else { 86 dev->req_seq = uclass_find_next_free_req_seq(drv->id); 87 } 88 } 89 90 if (drv->platdata_auto_alloc_size) { 91 bool alloc = !platdata; 92 93 if (CONFIG_IS_ENABLED(OF_PLATDATA)) { 94 if (of_platdata_size) { 95 dev->flags |= DM_FLAG_OF_PLATDATA; 96 if (of_platdata_size < 97 drv->platdata_auto_alloc_size) 98 alloc = true; 99 } 100 } 101 if (alloc) { 102 dev->flags |= DM_FLAG_ALLOC_PDATA; 103 dev->platdata = calloc(1, 104 drv->platdata_auto_alloc_size); 105 if (!dev->platdata) { 106 ret = -ENOMEM; 107 goto fail_alloc1; 108 } 109 if (CONFIG_IS_ENABLED(OF_PLATDATA) && platdata) { 110 memcpy(dev->platdata, platdata, 111 of_platdata_size); 112 } 113 } 114 } 115 116 size = uc->uc_drv->per_device_platdata_auto_alloc_size; 117 if (size) { 118 dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA; 119 dev->uclass_platdata = calloc(1, size); 120 if (!dev->uclass_platdata) { 121 ret = -ENOMEM; 122 goto fail_alloc2; 123 } 124 } 125 126 if (parent) { 127 size = parent->driver->per_child_platdata_auto_alloc_size; 128 if (!size) { 129 size = parent->uclass->uc_drv-> 130 per_child_platdata_auto_alloc_size; 131 } 132 if (size) { 133 dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA; 134 dev->parent_platdata = calloc(1, size); 135 if (!dev->parent_platdata) { 136 ret = -ENOMEM; 137 goto fail_alloc3; 138 } 139 } 140 } 141 142 /* put dev into parent's successor list */ 143 if (parent) 144 list_add_tail(&dev->sibling_node, &parent->child_head); 145 146 ret = uclass_bind_device(dev); 147 if (ret) 148 goto fail_uclass_bind; 149 150 /* if we fail to bind we remove device from successors and free it */ 151 if (drv->bind) { 152 ret = drv->bind(dev); 153 if (ret) 154 goto fail_bind; 155 } 156 if (parent && parent->driver->child_post_bind) { 157 ret = parent->driver->child_post_bind(dev); 158 if (ret) 159 goto fail_child_post_bind; 160 } 161 if (uc->uc_drv->post_bind) { 162 ret = uc->uc_drv->post_bind(dev); 163 if (ret) 164 goto fail_uclass_post_bind; 165 } 166 167 if (parent) 168 pr_debug("Bound device %s to %s\n", dev->name, parent->name); 169 if (devp) 170 *devp = dev; 171 172 dev->flags |= DM_FLAG_BOUND; 173 174 return 0; 175 176 fail_uclass_post_bind: 177 /* There is no child unbind() method, so no clean-up required */ 178 fail_child_post_bind: 179 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 180 if (drv->unbind && drv->unbind(dev)) { 181 dm_warn("unbind() method failed on dev '%s' on error path\n", 182 dev->name); 183 } 184 } 185 186 fail_bind: 187 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 188 if (uclass_unbind_device(dev)) { 189 dm_warn("Failed to unbind dev '%s' on error path\n", 190 dev->name); 191 } 192 } 193 fail_uclass_bind: 194 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 195 list_del(&dev->sibling_node); 196 if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) { 197 free(dev->parent_platdata); 198 dev->parent_platdata = NULL; 199 } 200 } 201 fail_alloc3: 202 if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) { 203 free(dev->uclass_platdata); 204 dev->uclass_platdata = NULL; 205 } 206 fail_alloc2: 207 if (dev->flags & DM_FLAG_ALLOC_PDATA) { 208 free(dev->platdata); 209 dev->platdata = NULL; 210 } 211 fail_alloc1: 212 devres_release_all(dev); 213 214 free(dev); 215 216 return ret; 217 } 218 219 int device_bind_with_driver_data(struct udevice *parent, 220 const struct driver *drv, const char *name, 221 ulong driver_data, ofnode node, 222 struct udevice **devp) 223 { 224 return device_bind_common(parent, drv, name, NULL, driver_data, node, 225 0, devp); 226 } 227 228 int device_bind(struct udevice *parent, const struct driver *drv, 229 const char *name, void *platdata, int of_offset, 230 struct udevice **devp) 231 { 232 return device_bind_common(parent, drv, name, platdata, 0, 233 offset_to_ofnode(of_offset), 0, devp); 234 } 235 236 int device_bind_ofnode(struct udevice *parent, const struct driver *drv, 237 const char *name, void *platdata, ofnode node, 238 struct udevice **devp) 239 { 240 return device_bind_common(parent, drv, name, platdata, 0, node, 0, 241 devp); 242 } 243 244 int device_bind_by_name(struct udevice *parent, bool pre_reloc_only, 245 const struct driver_info *info, struct udevice **devp) 246 { 247 struct driver *drv; 248 uint platdata_size = 0; 249 250 drv = lists_driver_lookup_name(info->name); 251 if (!drv) 252 return -ENOENT; 253 if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC)) 254 return -EPERM; 255 256 #if CONFIG_IS_ENABLED(OF_PLATDATA) 257 platdata_size = info->platdata_size; 258 #endif 259 return device_bind_common(parent, drv, info->name, 260 (void *)info->platdata, 0, ofnode_null(), platdata_size, 261 devp); 262 } 263 264 static void *alloc_priv(int size, uint flags) 265 { 266 void *priv; 267 268 if (flags & DM_FLAG_ALLOC_PRIV_DMA) { 269 size = ROUND(size, ARCH_DMA_MINALIGN); 270 priv = memalign(ARCH_DMA_MINALIGN, size); 271 if (priv) { 272 memset(priv, '\0', size); 273 274 /* 275 * Ensure that the zero bytes are flushed to memory. 276 * This prevents problems if the driver uses this as 277 * both an input and an output buffer: 278 * 279 * 1. Zeroes written to buffer (here) and sit in the 280 * cache 281 * 2. Driver issues a read command to DMA 282 * 3. CPU runs out of cache space and evicts some cache 283 * data in the buffer, writing zeroes to RAM from 284 * the memset() above 285 * 4. DMA completes 286 * 5. Buffer now has some DMA data and some zeroes 287 * 6. Data being read is now incorrect 288 * 289 * To prevent this, ensure that the cache is clean 290 * within this range at the start. The driver can then 291 * use normal flush-after-write, invalidate-before-read 292 * procedures. 293 * 294 * TODO(sjg@chromium.org): Drop this microblaze 295 * exception. 296 */ 297 #ifndef CONFIG_MICROBLAZE 298 flush_dcache_range((ulong)priv, (ulong)priv + size); 299 #endif 300 } 301 } else { 302 priv = calloc(1, size); 303 } 304 305 return priv; 306 } 307 308 int device_probe(struct udevice *dev) 309 { 310 struct power_domain pd; 311 const struct driver *drv; 312 int size = 0; 313 int ret; 314 int seq; 315 316 if (!dev) 317 return -EINVAL; 318 319 if (dev->flags & DM_FLAG_ACTIVATED) 320 return 0; 321 322 drv = dev->driver; 323 assert(drv); 324 325 /* Allocate private data if requested and not reentered */ 326 if (drv->priv_auto_alloc_size && !dev->priv) { 327 dev->priv = alloc_priv(drv->priv_auto_alloc_size, drv->flags); 328 if (!dev->priv) { 329 ret = -ENOMEM; 330 goto fail; 331 } 332 } 333 /* Allocate private data if requested and not reentered */ 334 size = dev->uclass->uc_drv->per_device_auto_alloc_size; 335 if (size && !dev->uclass_priv) { 336 dev->uclass_priv = alloc_priv(size, 337 dev->uclass->uc_drv->flags); 338 if (!dev->uclass_priv) { 339 ret = -ENOMEM; 340 goto fail; 341 } 342 } 343 344 /* Ensure all parents are probed */ 345 if (dev->parent) { 346 size = dev->parent->driver->per_child_auto_alloc_size; 347 if (!size) { 348 size = dev->parent->uclass->uc_drv-> 349 per_child_auto_alloc_size; 350 } 351 if (size && !dev->parent_priv) { 352 dev->parent_priv = alloc_priv(size, drv->flags); 353 if (!dev->parent_priv) { 354 ret = -ENOMEM; 355 goto fail; 356 } 357 } 358 359 ret = device_probe(dev->parent); 360 if (ret) 361 goto fail; 362 363 /* 364 * The device might have already been probed during 365 * the call to device_probe() on its parent device 366 * (e.g. PCI bridge devices). Test the flags again 367 * so that we don't mess up the device. 368 */ 369 if (dev->flags & DM_FLAG_ACTIVATED) 370 return 0; 371 } 372 373 seq = uclass_resolve_seq(dev); 374 if (seq < 0) { 375 ret = seq; 376 goto fail; 377 } 378 dev->seq = seq; 379 380 dev->flags |= DM_FLAG_ACTIVATED; 381 382 /* 383 * Process pinctrl for everything except the root device, and 384 * continue regardless of the result of pinctrl. Don't process pinctrl 385 * settings for pinctrl devices since the device may not yet be 386 * probed. 387 */ 388 if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL) 389 pinctrl_select_state(dev, "default"); 390 391 if (dev->parent && device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) { 392 if (!power_domain_get(dev, &pd)) 393 power_domain_on(&pd); 394 } 395 396 ret = uclass_pre_probe_device(dev); 397 if (ret) 398 goto fail; 399 400 if (dev->parent && dev->parent->driver->child_pre_probe) { 401 ret = dev->parent->driver->child_pre_probe(dev); 402 if (ret) 403 goto fail; 404 } 405 406 if (drv->ofdata_to_platdata && dev_has_of_node(dev)) { 407 ret = drv->ofdata_to_platdata(dev); 408 if (ret) 409 goto fail; 410 } 411 412 /* Process 'assigned-{clocks/clock-parents/clock-rates}' properties */ 413 ret = clk_set_defaults(dev); 414 if (ret) 415 goto fail; 416 417 if (drv->probe) { 418 ret = drv->probe(dev); 419 if (ret) { 420 dev->flags &= ~DM_FLAG_ACTIVATED; 421 goto fail; 422 } 423 } 424 425 ret = uclass_post_probe_device(dev); 426 if (ret) 427 goto fail_uclass; 428 429 if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL) 430 pinctrl_select_state(dev, "default"); 431 432 return 0; 433 fail_uclass: 434 if (device_remove(dev, DM_REMOVE_NORMAL)) { 435 dm_warn("%s: Device '%s' failed to remove on error path\n", 436 __func__, dev->name); 437 } 438 fail: 439 dev->flags &= ~DM_FLAG_ACTIVATED; 440 441 dev->seq = -1; 442 device_free(dev); 443 444 return ret; 445 } 446 447 void *dev_get_platdata(const struct udevice *dev) 448 { 449 if (!dev) { 450 dm_warn("%s: null device\n", __func__); 451 return NULL; 452 } 453 454 return dev->platdata; 455 } 456 457 void *dev_get_parent_platdata(const struct udevice *dev) 458 { 459 if (!dev) { 460 dm_warn("%s: null device\n", __func__); 461 return NULL; 462 } 463 464 return dev->parent_platdata; 465 } 466 467 void *dev_get_uclass_platdata(const struct udevice *dev) 468 { 469 if (!dev) { 470 dm_warn("%s: null device\n", __func__); 471 return NULL; 472 } 473 474 return dev->uclass_platdata; 475 } 476 477 void *dev_get_priv(const struct udevice *dev) 478 { 479 if (!dev) { 480 dm_warn("%s: null device\n", __func__); 481 return NULL; 482 } 483 484 return dev->priv; 485 } 486 487 void *dev_get_uclass_priv(const struct udevice *dev) 488 { 489 if (!dev) { 490 dm_warn("%s: null device\n", __func__); 491 return NULL; 492 } 493 494 return dev->uclass_priv; 495 } 496 497 void *dev_get_parent_priv(const struct udevice *dev) 498 { 499 if (!dev) { 500 dm_warn("%s: null device\n", __func__); 501 return NULL; 502 } 503 504 return dev->parent_priv; 505 } 506 507 static int device_get_device_tail(struct udevice *dev, int ret, 508 struct udevice **devp) 509 { 510 if (ret) 511 return ret; 512 513 ret = device_probe(dev); 514 if (ret) 515 return ret; 516 517 *devp = dev; 518 519 return 0; 520 } 521 522 /** 523 * device_find_by_ofnode() - Return device associated with given ofnode 524 * 525 * The returned device is *not* activated. 526 * 527 * @node: The ofnode for which a associated device should be looked up 528 * @devp: Pointer to structure to hold the found device 529 * Return: 0 if OK, -ve on error 530 */ 531 static int device_find_by_ofnode(ofnode node, struct udevice **devp) 532 { 533 struct uclass *uc; 534 struct udevice *dev; 535 int ret; 536 537 list_for_each_entry(uc, &gd->uclass_root, sibling_node) { 538 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node, 539 &dev); 540 if (!ret || dev) { 541 *devp = dev; 542 return 0; 543 } 544 } 545 546 return -ENODEV; 547 } 548 549 int device_get_child(struct udevice *parent, int index, struct udevice **devp) 550 { 551 struct udevice *dev; 552 553 list_for_each_entry(dev, &parent->child_head, sibling_node) { 554 if (!index--) 555 return device_get_device_tail(dev, 0, devp); 556 } 557 558 return -ENODEV; 559 } 560 561 int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq, 562 bool find_req_seq, struct udevice **devp) 563 { 564 struct udevice *dev; 565 566 *devp = NULL; 567 if (seq_or_req_seq == -1) 568 return -ENODEV; 569 570 list_for_each_entry(dev, &parent->child_head, sibling_node) { 571 if ((find_req_seq ? dev->req_seq : dev->seq) == 572 seq_or_req_seq) { 573 *devp = dev; 574 return 0; 575 } 576 } 577 578 return -ENODEV; 579 } 580 581 int device_get_child_by_seq(struct udevice *parent, int seq, 582 struct udevice **devp) 583 { 584 struct udevice *dev; 585 int ret; 586 587 *devp = NULL; 588 ret = device_find_child_by_seq(parent, seq, false, &dev); 589 if (ret == -ENODEV) { 590 /* 591 * We didn't find it in probed devices. See if there is one 592 * that will request this seq if probed. 593 */ 594 ret = device_find_child_by_seq(parent, seq, true, &dev); 595 } 596 return device_get_device_tail(dev, ret, devp); 597 } 598 599 int device_find_child_by_of_offset(struct udevice *parent, int of_offset, 600 struct udevice **devp) 601 { 602 struct udevice *dev; 603 604 *devp = NULL; 605 606 list_for_each_entry(dev, &parent->child_head, sibling_node) { 607 if (dev_of_offset(dev) == of_offset) { 608 *devp = dev; 609 return 0; 610 } 611 } 612 613 return -ENODEV; 614 } 615 616 int device_get_child_by_of_offset(struct udevice *parent, int node, 617 struct udevice **devp) 618 { 619 struct udevice *dev; 620 int ret; 621 622 *devp = NULL; 623 ret = device_find_child_by_of_offset(parent, node, &dev); 624 return device_get_device_tail(dev, ret, devp); 625 } 626 627 static struct udevice *_device_find_global_by_ofnode(struct udevice *parent, 628 ofnode ofnode) 629 { 630 struct udevice *dev, *found; 631 632 if (ofnode_equal(dev_ofnode(parent), ofnode)) 633 return parent; 634 635 list_for_each_entry(dev, &parent->child_head, sibling_node) { 636 found = _device_find_global_by_ofnode(dev, ofnode); 637 if (found) 638 return found; 639 } 640 641 return NULL; 642 } 643 644 int device_find_global_by_ofnode(ofnode ofnode, struct udevice **devp) 645 { 646 *devp = _device_find_global_by_ofnode(gd->dm_root, ofnode); 647 648 return *devp ? 0 : -ENOENT; 649 } 650 651 int device_get_global_by_ofnode(ofnode ofnode, struct udevice **devp) 652 { 653 struct udevice *dev; 654 655 dev = _device_find_global_by_ofnode(gd->dm_root, ofnode); 656 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp); 657 } 658 659 int device_find_first_child(struct udevice *parent, struct udevice **devp) 660 { 661 if (list_empty(&parent->child_head)) { 662 *devp = NULL; 663 } else { 664 *devp = list_first_entry(&parent->child_head, struct udevice, 665 sibling_node); 666 } 667 668 return 0; 669 } 670 671 int device_find_next_child(struct udevice **devp) 672 { 673 struct udevice *dev = *devp; 674 struct udevice *parent = dev->parent; 675 676 if (list_is_last(&dev->sibling_node, &parent->child_head)) { 677 *devp = NULL; 678 } else { 679 *devp = list_entry(dev->sibling_node.next, struct udevice, 680 sibling_node); 681 } 682 683 return 0; 684 } 685 686 int device_find_first_inactive_child(struct udevice *parent, 687 enum uclass_id uclass_id, 688 struct udevice **devp) 689 { 690 struct udevice *dev; 691 692 *devp = NULL; 693 list_for_each_entry(dev, &parent->child_head, sibling_node) { 694 if (!device_active(dev) && 695 device_get_uclass_id(dev) == uclass_id) { 696 *devp = dev; 697 return 0; 698 } 699 } 700 701 return -ENODEV; 702 } 703 704 int device_find_first_child_by_uclass(struct udevice *parent, 705 enum uclass_id uclass_id, 706 struct udevice **devp) 707 { 708 struct udevice *dev; 709 710 *devp = NULL; 711 list_for_each_entry(dev, &parent->child_head, sibling_node) { 712 if (device_get_uclass_id(dev) == uclass_id) { 713 *devp = dev; 714 return 0; 715 } 716 } 717 718 return -ENODEV; 719 } 720 721 int device_find_child_by_name(struct udevice *parent, const char *name, 722 struct udevice **devp) 723 { 724 struct udevice *dev; 725 726 *devp = NULL; 727 728 list_for_each_entry(dev, &parent->child_head, sibling_node) { 729 if (!strcmp(dev->name, name)) { 730 *devp = dev; 731 return 0; 732 } 733 } 734 735 return -ENODEV; 736 } 737 738 struct udevice *dev_get_parent(const struct udevice *child) 739 { 740 return child->parent; 741 } 742 743 ulong dev_get_driver_data(const struct udevice *dev) 744 { 745 return dev->driver_data; 746 } 747 748 const void *dev_get_driver_ops(const struct udevice *dev) 749 { 750 if (!dev || !dev->driver->ops) 751 return NULL; 752 753 return dev->driver->ops; 754 } 755 756 enum uclass_id device_get_uclass_id(const struct udevice *dev) 757 { 758 return dev->uclass->uc_drv->id; 759 } 760 761 const char *dev_get_uclass_name(const struct udevice *dev) 762 { 763 if (!dev) 764 return NULL; 765 766 return dev->uclass->uc_drv->name; 767 } 768 769 bool device_has_children(const struct udevice *dev) 770 { 771 return !list_empty(&dev->child_head); 772 } 773 774 bool device_has_active_children(struct udevice *dev) 775 { 776 struct udevice *child; 777 778 for (device_find_first_child(dev, &child); 779 child; 780 device_find_next_child(&child)) { 781 if (device_active(child)) 782 return true; 783 } 784 785 return false; 786 } 787 788 bool device_is_last_sibling(struct udevice *dev) 789 { 790 struct udevice *parent = dev->parent; 791 792 if (!parent) 793 return false; 794 return list_is_last(&dev->sibling_node, &parent->child_head); 795 } 796 797 void device_set_name_alloced(struct udevice *dev) 798 { 799 dev->flags |= DM_FLAG_NAME_ALLOCED; 800 } 801 802 int device_set_name(struct udevice *dev, const char *name) 803 { 804 name = strdup(name); 805 if (!name) 806 return -ENOMEM; 807 dev->name = name; 808 device_set_name_alloced(dev); 809 810 return 0; 811 } 812 813 bool device_is_compatible(struct udevice *dev, const char *compat) 814 { 815 return ofnode_device_is_compatible(dev_ofnode(dev), compat); 816 } 817 818 bool of_machine_is_compatible(const char *compat) 819 { 820 const void *fdt = gd->fdt_blob; 821 822 return !fdt_node_check_compatible(fdt, 0, compat); 823 } 824 825 int dev_disable_by_path(const char *path) 826 { 827 struct uclass *uc; 828 ofnode node = ofnode_path(path); 829 struct udevice *dev; 830 int ret = 1; 831 832 if (!of_live_active()) 833 return -ENOSYS; 834 835 list_for_each_entry(uc, &gd->uclass_root, sibling_node) { 836 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node, &dev); 837 if (!ret) 838 break; 839 } 840 841 if (ret) 842 return ret; 843 844 ret = device_remove(dev, DM_REMOVE_NORMAL); 845 if (ret) 846 return ret; 847 848 ret = device_unbind(dev); 849 if (ret) 850 return ret; 851 852 return ofnode_set_enabled(node, false); 853 } 854 855 int dev_enable_by_path(const char *path) 856 { 857 ofnode node = ofnode_path(path); 858 ofnode pnode = ofnode_get_parent(node); 859 struct udevice *parent; 860 int ret = 1; 861 862 if (!of_live_active()) 863 return -ENOSYS; 864 865 ret = device_find_by_ofnode(pnode, &parent); 866 if (ret) 867 return ret; 868 869 ret = ofnode_set_enabled(node, true); 870 if (ret) 871 return ret; 872 873 return lists_bind_fdt(parent, node, NULL, false); 874 } 875