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