1 /* 2 * Device manager 3 * 4 * Copyright (c) 2013 Google, Inc 5 * 6 * (C) Copyright 2012 7 * Pavel Herrmann <morpheus.ibis@gmail.com> 8 * 9 * SPDX-License-Identifier: GPL-2.0+ 10 */ 11 12 #include <common.h> 13 #include <fdtdec.h> 14 #include <fdt_support.h> 15 #include <malloc.h> 16 #include <dm/device.h> 17 #include <dm/device-internal.h> 18 #include <dm/lists.h> 19 #include <dm/pinctrl.h> 20 #include <dm/platdata.h> 21 #include <dm/uclass.h> 22 #include <dm/uclass-internal.h> 23 #include <dm/util.h> 24 #include <linux/err.h> 25 #include <linux/list.h> 26 27 DECLARE_GLOBAL_DATA_PTR; 28 29 static int device_bind_common(struct udevice *parent, const struct driver *drv, 30 const char *name, void *platdata, 31 ulong driver_data, int of_offset, 32 struct udevice **devp) 33 { 34 struct udevice *dev; 35 struct uclass *uc; 36 int size, ret = 0; 37 38 if (devp) 39 *devp = NULL; 40 if (!name) 41 return -EINVAL; 42 43 ret = uclass_get(drv->id, &uc); 44 if (ret) { 45 debug("Missing uclass for driver %s\n", drv->name); 46 return ret; 47 } 48 49 dev = calloc(1, sizeof(struct udevice)); 50 if (!dev) 51 return -ENOMEM; 52 53 INIT_LIST_HEAD(&dev->sibling_node); 54 INIT_LIST_HEAD(&dev->child_head); 55 INIT_LIST_HEAD(&dev->uclass_node); 56 #ifdef CONFIG_DEVRES 57 INIT_LIST_HEAD(&dev->devres_head); 58 #endif 59 dev->platdata = platdata; 60 dev->driver_data = driver_data; 61 dev->name = name; 62 dev->of_offset = of_offset; 63 dev->parent = parent; 64 dev->driver = drv; 65 dev->uclass = uc; 66 67 dev->seq = -1; 68 dev->req_seq = -1; 69 if (CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(DM_SEQ_ALIAS)) { 70 /* 71 * Some devices, such as a SPI bus, I2C bus and serial ports 72 * are numbered using aliases. 73 * 74 * This is just a 'requested' sequence, and will be 75 * resolved (and ->seq updated) when the device is probed. 76 */ 77 if (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS) { 78 if (uc->uc_drv->name && of_offset != -1) { 79 fdtdec_get_alias_seq(gd->fdt_blob, 80 uc->uc_drv->name, of_offset, 81 &dev->req_seq); 82 } 83 } 84 } 85 86 if (!dev->platdata && drv->platdata_auto_alloc_size) { 87 dev->flags |= DM_FLAG_ALLOC_PDATA; 88 dev->platdata = calloc(1, drv->platdata_auto_alloc_size); 89 if (!dev->platdata) { 90 ret = -ENOMEM; 91 goto fail_alloc1; 92 } 93 } 94 95 size = uc->uc_drv->per_device_platdata_auto_alloc_size; 96 if (size) { 97 dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA; 98 dev->uclass_platdata = calloc(1, size); 99 if (!dev->uclass_platdata) { 100 ret = -ENOMEM; 101 goto fail_alloc2; 102 } 103 } 104 105 if (parent) { 106 size = parent->driver->per_child_platdata_auto_alloc_size; 107 if (!size) { 108 size = parent->uclass->uc_drv-> 109 per_child_platdata_auto_alloc_size; 110 } 111 if (size) { 112 dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA; 113 dev->parent_platdata = calloc(1, size); 114 if (!dev->parent_platdata) { 115 ret = -ENOMEM; 116 goto fail_alloc3; 117 } 118 } 119 } 120 121 /* put dev into parent's successor list */ 122 if (parent) 123 list_add_tail(&dev->sibling_node, &parent->child_head); 124 125 ret = uclass_bind_device(dev); 126 if (ret) 127 goto fail_uclass_bind; 128 129 /* if we fail to bind we remove device from successors and free it */ 130 if (drv->bind) { 131 ret = drv->bind(dev); 132 if (ret) 133 goto fail_bind; 134 } 135 if (parent && parent->driver->child_post_bind) { 136 ret = parent->driver->child_post_bind(dev); 137 if (ret) 138 goto fail_child_post_bind; 139 } 140 if (uc->uc_drv->post_bind) { 141 ret = uc->uc_drv->post_bind(dev); 142 if (ret) 143 goto fail_uclass_post_bind; 144 } 145 146 if (parent) 147 dm_dbg("Bound device %s to %s\n", dev->name, parent->name); 148 if (devp) 149 *devp = dev; 150 151 dev->flags |= DM_FLAG_BOUND; 152 153 return 0; 154 155 fail_uclass_post_bind: 156 /* There is no child unbind() method, so no clean-up required */ 157 fail_child_post_bind: 158 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 159 if (drv->unbind && drv->unbind(dev)) { 160 dm_warn("unbind() method failed on dev '%s' on error path\n", 161 dev->name); 162 } 163 } 164 165 fail_bind: 166 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 167 if (uclass_unbind_device(dev)) { 168 dm_warn("Failed to unbind dev '%s' on error path\n", 169 dev->name); 170 } 171 } 172 fail_uclass_bind: 173 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 174 list_del(&dev->sibling_node); 175 if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) { 176 free(dev->parent_platdata); 177 dev->parent_platdata = NULL; 178 } 179 } 180 fail_alloc3: 181 if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) { 182 free(dev->uclass_platdata); 183 dev->uclass_platdata = NULL; 184 } 185 fail_alloc2: 186 if (dev->flags & DM_FLAG_ALLOC_PDATA) { 187 free(dev->platdata); 188 dev->platdata = NULL; 189 } 190 fail_alloc1: 191 devres_release_all(dev); 192 193 free(dev); 194 195 return ret; 196 } 197 198 int device_bind_with_driver_data(struct udevice *parent, 199 const struct driver *drv, const char *name, 200 ulong driver_data, int of_offset, 201 struct udevice **devp) 202 { 203 return device_bind_common(parent, drv, name, NULL, driver_data, 204 of_offset, devp); 205 } 206 207 int device_bind(struct udevice *parent, const struct driver *drv, 208 const char *name, void *platdata, int of_offset, 209 struct udevice **devp) 210 { 211 return device_bind_common(parent, drv, name, platdata, 0, of_offset, 212 devp); 213 } 214 215 int device_bind_by_name(struct udevice *parent, bool pre_reloc_only, 216 const struct driver_info *info, struct udevice **devp) 217 { 218 struct driver *drv; 219 220 drv = lists_driver_lookup_name(info->name); 221 if (!drv) 222 return -ENOENT; 223 if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC)) 224 return -EPERM; 225 226 return device_bind(parent, drv, info->name, (void *)info->platdata, 227 -1, devp); 228 } 229 230 static void *alloc_priv(int size, uint flags) 231 { 232 void *priv; 233 234 if (flags & DM_FLAG_ALLOC_PRIV_DMA) { 235 priv = memalign(ARCH_DMA_MINALIGN, size); 236 if (priv) 237 memset(priv, '\0', size); 238 } else { 239 priv = calloc(1, size); 240 } 241 242 return priv; 243 } 244 245 int device_probe(struct udevice *dev) 246 { 247 const struct driver *drv; 248 int size = 0; 249 int ret; 250 int seq; 251 252 if (!dev) 253 return -EINVAL; 254 255 if (dev->flags & DM_FLAG_ACTIVATED) 256 return 0; 257 258 drv = dev->driver; 259 assert(drv); 260 261 /* Allocate private data if requested and not reentered */ 262 if (drv->priv_auto_alloc_size && !dev->priv) { 263 dev->priv = alloc_priv(drv->priv_auto_alloc_size, drv->flags); 264 if (!dev->priv) { 265 ret = -ENOMEM; 266 goto fail; 267 } 268 } 269 /* Allocate private data if requested and not reentered */ 270 size = dev->uclass->uc_drv->per_device_auto_alloc_size; 271 if (size && !dev->uclass_priv) { 272 dev->uclass_priv = calloc(1, size); 273 if (!dev->uclass_priv) { 274 ret = -ENOMEM; 275 goto fail; 276 } 277 } 278 279 /* Ensure all parents are probed */ 280 if (dev->parent) { 281 size = dev->parent->driver->per_child_auto_alloc_size; 282 if (!size) { 283 size = dev->parent->uclass->uc_drv-> 284 per_child_auto_alloc_size; 285 } 286 if (size && !dev->parent_priv) { 287 dev->parent_priv = alloc_priv(size, drv->flags); 288 if (!dev->parent_priv) { 289 ret = -ENOMEM; 290 goto fail; 291 } 292 } 293 294 ret = device_probe(dev->parent); 295 if (ret) 296 goto fail; 297 298 /* 299 * The device might have already been probed during 300 * the call to device_probe() on its parent device 301 * (e.g. PCI bridge devices). Test the flags again 302 * so that we don't mess up the device. 303 */ 304 if (dev->flags & DM_FLAG_ACTIVATED) 305 return 0; 306 } 307 308 seq = uclass_resolve_seq(dev); 309 if (seq < 0) { 310 ret = seq; 311 goto fail; 312 } 313 dev->seq = seq; 314 315 dev->flags |= DM_FLAG_ACTIVATED; 316 317 /* 318 * Process pinctrl for everything except the root device, and 319 * continue regardless of the result of pinctrl. Don't process pinctrl 320 * settings for pinctrl devices since the device may not yet be 321 * probed. 322 */ 323 if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL) 324 pinctrl_select_state(dev, "default"); 325 326 ret = uclass_pre_probe_device(dev); 327 if (ret) 328 goto fail; 329 330 if (dev->parent && dev->parent->driver->child_pre_probe) { 331 ret = dev->parent->driver->child_pre_probe(dev); 332 if (ret) 333 goto fail; 334 } 335 336 if (drv->ofdata_to_platdata && dev->of_offset >= 0) { 337 ret = drv->ofdata_to_platdata(dev); 338 if (ret) 339 goto fail; 340 } 341 342 if (drv->probe) { 343 ret = drv->probe(dev); 344 if (ret) { 345 dev->flags &= ~DM_FLAG_ACTIVATED; 346 goto fail; 347 } 348 } 349 350 ret = uclass_post_probe_device(dev); 351 if (ret) 352 goto fail_uclass; 353 354 if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL) 355 pinctrl_select_state(dev, "default"); 356 357 return 0; 358 fail_uclass: 359 if (device_remove(dev)) { 360 dm_warn("%s: Device '%s' failed to remove on error path\n", 361 __func__, dev->name); 362 } 363 fail: 364 dev->flags &= ~DM_FLAG_ACTIVATED; 365 366 dev->seq = -1; 367 device_free(dev); 368 369 return ret; 370 } 371 372 void *dev_get_platdata(struct udevice *dev) 373 { 374 if (!dev) { 375 dm_warn("%s: null device\n", __func__); 376 return NULL; 377 } 378 379 return dev->platdata; 380 } 381 382 void *dev_get_parent_platdata(struct udevice *dev) 383 { 384 if (!dev) { 385 dm_warn("%s: null device\n", __func__); 386 return NULL; 387 } 388 389 return dev->parent_platdata; 390 } 391 392 void *dev_get_uclass_platdata(struct udevice *dev) 393 { 394 if (!dev) { 395 dm_warn("%s: null device\n", __func__); 396 return NULL; 397 } 398 399 return dev->uclass_platdata; 400 } 401 402 void *dev_get_priv(struct udevice *dev) 403 { 404 if (!dev) { 405 dm_warn("%s: null device\n", __func__); 406 return NULL; 407 } 408 409 return dev->priv; 410 } 411 412 void *dev_get_uclass_priv(struct udevice *dev) 413 { 414 if (!dev) { 415 dm_warn("%s: null device\n", __func__); 416 return NULL; 417 } 418 419 return dev->uclass_priv; 420 } 421 422 void *dev_get_parent_priv(struct udevice *dev) 423 { 424 if (!dev) { 425 dm_warn("%s: null device\n", __func__); 426 return NULL; 427 } 428 429 return dev->parent_priv; 430 } 431 432 static int device_get_device_tail(struct udevice *dev, int ret, 433 struct udevice **devp) 434 { 435 if (ret) 436 return ret; 437 438 ret = device_probe(dev); 439 if (ret) 440 return ret; 441 442 *devp = dev; 443 444 return 0; 445 } 446 447 int device_get_child(struct udevice *parent, int index, struct udevice **devp) 448 { 449 struct udevice *dev; 450 451 list_for_each_entry(dev, &parent->child_head, sibling_node) { 452 if (!index--) 453 return device_get_device_tail(dev, 0, devp); 454 } 455 456 return -ENODEV; 457 } 458 459 int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq, 460 bool find_req_seq, struct udevice **devp) 461 { 462 struct udevice *dev; 463 464 *devp = NULL; 465 if (seq_or_req_seq == -1) 466 return -ENODEV; 467 468 list_for_each_entry(dev, &parent->child_head, sibling_node) { 469 if ((find_req_seq ? dev->req_seq : dev->seq) == 470 seq_or_req_seq) { 471 *devp = dev; 472 return 0; 473 } 474 } 475 476 return -ENODEV; 477 } 478 479 int device_get_child_by_seq(struct udevice *parent, int seq, 480 struct udevice **devp) 481 { 482 struct udevice *dev; 483 int ret; 484 485 *devp = NULL; 486 ret = device_find_child_by_seq(parent, seq, false, &dev); 487 if (ret == -ENODEV) { 488 /* 489 * We didn't find it in probed devices. See if there is one 490 * that will request this seq if probed. 491 */ 492 ret = device_find_child_by_seq(parent, seq, true, &dev); 493 } 494 return device_get_device_tail(dev, ret, devp); 495 } 496 497 int device_find_child_by_of_offset(struct udevice *parent, int of_offset, 498 struct udevice **devp) 499 { 500 struct udevice *dev; 501 502 *devp = NULL; 503 504 list_for_each_entry(dev, &parent->child_head, sibling_node) { 505 if (dev->of_offset == of_offset) { 506 *devp = dev; 507 return 0; 508 } 509 } 510 511 return -ENODEV; 512 } 513 514 int device_get_child_by_of_offset(struct udevice *parent, int node, 515 struct udevice **devp) 516 { 517 struct udevice *dev; 518 int ret; 519 520 *devp = NULL; 521 ret = device_find_child_by_of_offset(parent, node, &dev); 522 return device_get_device_tail(dev, ret, devp); 523 } 524 525 static struct udevice *_device_find_global_by_of_offset(struct udevice *parent, 526 int of_offset) 527 { 528 struct udevice *dev, *found; 529 530 if (parent->of_offset == of_offset) 531 return parent; 532 533 list_for_each_entry(dev, &parent->child_head, sibling_node) { 534 found = _device_find_global_by_of_offset(dev, of_offset); 535 if (found) 536 return found; 537 } 538 539 return NULL; 540 } 541 542 int device_get_global_by_of_offset(int of_offset, struct udevice **devp) 543 { 544 struct udevice *dev; 545 546 dev = _device_find_global_by_of_offset(gd->dm_root, of_offset); 547 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp); 548 } 549 550 int device_find_first_child(struct udevice *parent, struct udevice **devp) 551 { 552 if (list_empty(&parent->child_head)) { 553 *devp = NULL; 554 } else { 555 *devp = list_first_entry(&parent->child_head, struct udevice, 556 sibling_node); 557 } 558 559 return 0; 560 } 561 562 int device_find_next_child(struct udevice **devp) 563 { 564 struct udevice *dev = *devp; 565 struct udevice *parent = dev->parent; 566 567 if (list_is_last(&dev->sibling_node, &parent->child_head)) { 568 *devp = NULL; 569 } else { 570 *devp = list_entry(dev->sibling_node.next, struct udevice, 571 sibling_node); 572 } 573 574 return 0; 575 } 576 577 struct udevice *dev_get_parent(struct udevice *child) 578 { 579 return child->parent; 580 } 581 582 ulong dev_get_driver_data(struct udevice *dev) 583 { 584 return dev->driver_data; 585 } 586 587 const void *dev_get_driver_ops(struct udevice *dev) 588 { 589 if (!dev || !dev->driver->ops) 590 return NULL; 591 592 return dev->driver->ops; 593 } 594 595 enum uclass_id device_get_uclass_id(struct udevice *dev) 596 { 597 return dev->uclass->uc_drv->id; 598 } 599 600 const char *dev_get_uclass_name(struct udevice *dev) 601 { 602 if (!dev) 603 return NULL; 604 605 return dev->uclass->uc_drv->name; 606 } 607 608 fdt_addr_t dev_get_addr_index(struct udevice *dev, int index) 609 { 610 #if CONFIG_IS_ENABLED(OF_CONTROL) 611 fdt_addr_t addr; 612 613 if (CONFIG_IS_ENABLED(OF_TRANSLATE)) { 614 const fdt32_t *reg; 615 int len = 0; 616 int na, ns; 617 618 na = fdt_address_cells(gd->fdt_blob, dev->parent->of_offset); 619 if (na < 1) { 620 debug("bad #address-cells\n"); 621 return FDT_ADDR_T_NONE; 622 } 623 624 ns = fdt_size_cells(gd->fdt_blob, dev->parent->of_offset); 625 if (ns < 0) { 626 debug("bad #size-cells\n"); 627 return FDT_ADDR_T_NONE; 628 } 629 630 reg = fdt_getprop(gd->fdt_blob, dev->of_offset, "reg", &len); 631 if (!reg || (len <= (index * sizeof(fdt32_t) * (na + ns)))) { 632 debug("Req index out of range\n"); 633 return FDT_ADDR_T_NONE; 634 } 635 636 reg += index * (na + ns); 637 638 /* 639 * Use the full-fledged translate function for complex 640 * bus setups. 641 */ 642 addr = fdt_translate_address((void *)gd->fdt_blob, 643 dev->of_offset, reg); 644 } else { 645 /* 646 * Use the "simple" translate function for less complex 647 * bus setups. 648 */ 649 addr = fdtdec_get_addr_size_auto_parent(gd->fdt_blob, 650 dev->parent->of_offset, 651 dev->of_offset, "reg", 652 index, NULL); 653 if (CONFIG_IS_ENABLED(SIMPLE_BUS) && addr != FDT_ADDR_T_NONE) { 654 if (device_get_uclass_id(dev->parent) == 655 UCLASS_SIMPLE_BUS) 656 addr = simple_bus_translate(dev->parent, addr); 657 } 658 } 659 660 /* 661 * Some platforms need a special address translation. Those 662 * platforms (e.g. mvebu in SPL) can configure a translation 663 * offset in the DM by calling dm_set_translation_offset() that 664 * will get added to all addresses returned by dev_get_addr(). 665 */ 666 addr += dm_get_translation_offset(); 667 668 return addr; 669 #else 670 return FDT_ADDR_T_NONE; 671 #endif 672 } 673 674 fdt_addr_t dev_get_addr_name(struct udevice *dev, const char *name) 675 { 676 #if CONFIG_IS_ENABLED(OF_CONTROL) 677 int index; 678 679 index = fdt_find_string(gd->fdt_blob, dev->of_offset, "reg-names", 680 name); 681 if (index < 0) 682 return index; 683 684 return dev_get_addr_index(dev, index); 685 #else 686 return FDT_ADDR_T_NONE; 687 #endif 688 } 689 690 fdt_addr_t dev_get_addr(struct udevice *dev) 691 { 692 return dev_get_addr_index(dev, 0); 693 } 694 695 void *dev_get_addr_ptr(struct udevice *dev) 696 { 697 return (void *)(uintptr_t)dev_get_addr_index(dev, 0); 698 } 699 700 bool device_has_children(struct udevice *dev) 701 { 702 return !list_empty(&dev->child_head); 703 } 704 705 bool device_has_active_children(struct udevice *dev) 706 { 707 struct udevice *child; 708 709 for (device_find_first_child(dev, &child); 710 child; 711 device_find_next_child(&child)) { 712 if (device_active(child)) 713 return true; 714 } 715 716 return false; 717 } 718 719 bool device_is_last_sibling(struct udevice *dev) 720 { 721 struct udevice *parent = dev->parent; 722 723 if (!parent) 724 return false; 725 return list_is_last(&dev->sibling_node, &parent->child_head); 726 } 727 728 void device_set_name_alloced(struct udevice *dev) 729 { 730 dev->flags |= DM_NAME_ALLOCED; 731 } 732 733 int device_set_name(struct udevice *dev, const char *name) 734 { 735 name = strdup(name); 736 if (!name) 737 return -ENOMEM; 738 dev->name = name; 739 device_set_name_alloced(dev); 740 741 return 0; 742 } 743 744 bool of_device_is_compatible(struct udevice *dev, const char *compat) 745 { 746 const void *fdt = gd->fdt_blob; 747 748 return !fdt_node_check_compatible(fdt, dev->of_offset, compat); 749 } 750 751 bool of_machine_is_compatible(const char *compat) 752 { 753 const void *fdt = gd->fdt_blob; 754 755 return !fdt_node_check_compatible(fdt, 0, compat); 756 } 757