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 <malloc.h> 15 #include <dm/device.h> 16 #include <dm/device-internal.h> 17 #include <dm/lists.h> 18 #include <dm/pinctrl.h> 19 #include <dm/platdata.h> 20 #include <dm/uclass.h> 21 #include <dm/uclass-internal.h> 22 #include <dm/util.h> 23 #include <linux/err.h> 24 #include <linux/list.h> 25 26 DECLARE_GLOBAL_DATA_PTR; 27 28 int device_bind(struct udevice *parent, const struct driver *drv, 29 const char *name, void *platdata, int of_offset, 30 struct udevice **devp) 31 { 32 struct udevice *dev; 33 struct uclass *uc; 34 int size, ret = 0; 35 36 if (devp) 37 *devp = NULL; 38 if (!name) 39 return -EINVAL; 40 41 ret = uclass_get(drv->id, &uc); 42 if (ret) 43 return ret; 44 45 dev = calloc(1, sizeof(struct udevice)); 46 if (!dev) 47 return -ENOMEM; 48 49 INIT_LIST_HEAD(&dev->sibling_node); 50 INIT_LIST_HEAD(&dev->child_head); 51 INIT_LIST_HEAD(&dev->uclass_node); 52 #ifdef CONFIG_DEVRES 53 INIT_LIST_HEAD(&dev->devres_head); 54 #endif 55 dev->platdata = platdata; 56 dev->name = name; 57 dev->of_offset = of_offset; 58 dev->parent = parent; 59 dev->driver = drv; 60 dev->uclass = uc; 61 62 dev->seq = -1; 63 dev->req_seq = -1; 64 if (CONFIG_IS_ENABLED(OF_CONTROL) && IS_ENABLED(CONFIG_DM_SEQ_ALIAS)) { 65 /* 66 * Some devices, such as a SPI bus, I2C bus and serial ports 67 * are numbered using aliases. 68 * 69 * This is just a 'requested' sequence, and will be 70 * resolved (and ->seq updated) when the device is probed. 71 */ 72 if (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS) { 73 if (uc->uc_drv->name && of_offset != -1) { 74 fdtdec_get_alias_seq(gd->fdt_blob, 75 uc->uc_drv->name, of_offset, 76 &dev->req_seq); 77 } 78 } 79 } 80 81 if (!dev->platdata && drv->platdata_auto_alloc_size) { 82 dev->flags |= DM_FLAG_ALLOC_PDATA; 83 dev->platdata = calloc(1, drv->platdata_auto_alloc_size); 84 if (!dev->platdata) { 85 ret = -ENOMEM; 86 goto fail_alloc1; 87 } 88 } 89 90 size = uc->uc_drv->per_device_platdata_auto_alloc_size; 91 if (size) { 92 dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA; 93 dev->uclass_platdata = calloc(1, size); 94 if (!dev->uclass_platdata) { 95 ret = -ENOMEM; 96 goto fail_alloc2; 97 } 98 } 99 100 if (parent) { 101 size = parent->driver->per_child_platdata_auto_alloc_size; 102 if (!size) { 103 size = parent->uclass->uc_drv-> 104 per_child_platdata_auto_alloc_size; 105 } 106 if (size) { 107 dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA; 108 dev->parent_platdata = calloc(1, size); 109 if (!dev->parent_platdata) { 110 ret = -ENOMEM; 111 goto fail_alloc3; 112 } 113 } 114 } 115 116 /* put dev into parent's successor list */ 117 if (parent) 118 list_add_tail(&dev->sibling_node, &parent->child_head); 119 120 ret = uclass_bind_device(dev); 121 if (ret) 122 goto fail_uclass_bind; 123 124 /* if we fail to bind we remove device from successors and free it */ 125 if (drv->bind) { 126 ret = drv->bind(dev); 127 if (ret) 128 goto fail_bind; 129 } 130 if (parent && parent->driver->child_post_bind) { 131 ret = parent->driver->child_post_bind(dev); 132 if (ret) 133 goto fail_child_post_bind; 134 } 135 136 if (parent) 137 dm_dbg("Bound device %s to %s\n", dev->name, parent->name); 138 if (devp) 139 *devp = dev; 140 141 dev->flags |= DM_FLAG_BOUND; 142 143 return 0; 144 145 fail_child_post_bind: 146 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 147 if (drv->unbind && drv->unbind(dev)) { 148 dm_warn("unbind() method failed on dev '%s' on error path\n", 149 dev->name); 150 } 151 } 152 153 fail_bind: 154 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 155 if (uclass_unbind_device(dev)) { 156 dm_warn("Failed to unbind dev '%s' on error path\n", 157 dev->name); 158 } 159 } 160 fail_uclass_bind: 161 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) { 162 list_del(&dev->sibling_node); 163 if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) { 164 free(dev->parent_platdata); 165 dev->parent_platdata = NULL; 166 } 167 } 168 fail_alloc3: 169 if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) { 170 free(dev->uclass_platdata); 171 dev->uclass_platdata = NULL; 172 } 173 fail_alloc2: 174 if (dev->flags & DM_FLAG_ALLOC_PDATA) { 175 free(dev->platdata); 176 dev->platdata = NULL; 177 } 178 fail_alloc1: 179 devres_release_all(dev); 180 181 free(dev); 182 183 return ret; 184 } 185 186 int device_bind_by_name(struct udevice *parent, bool pre_reloc_only, 187 const struct driver_info *info, struct udevice **devp) 188 { 189 struct driver *drv; 190 191 drv = lists_driver_lookup_name(info->name); 192 if (!drv) 193 return -ENOENT; 194 if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC)) 195 return -EPERM; 196 197 return device_bind(parent, drv, info->name, (void *)info->platdata, 198 -1, devp); 199 } 200 201 static void *alloc_priv(int size, uint flags) 202 { 203 void *priv; 204 205 if (flags & DM_FLAG_ALLOC_PRIV_DMA) { 206 priv = memalign(ARCH_DMA_MINALIGN, size); 207 if (priv) 208 memset(priv, '\0', size); 209 } else { 210 priv = calloc(1, size); 211 } 212 213 return priv; 214 } 215 216 int device_probe_child(struct udevice *dev, void *parent_priv) 217 { 218 const struct driver *drv; 219 int size = 0; 220 int ret; 221 int seq; 222 223 if (!dev) 224 return -EINVAL; 225 226 if (dev->flags & DM_FLAG_ACTIVATED) 227 return 0; 228 229 drv = dev->driver; 230 assert(drv); 231 232 /* Allocate private data if requested and not reentered */ 233 if (drv->priv_auto_alloc_size && !dev->priv) { 234 dev->priv = alloc_priv(drv->priv_auto_alloc_size, drv->flags); 235 if (!dev->priv) { 236 ret = -ENOMEM; 237 goto fail; 238 } 239 } 240 /* Allocate private data if requested and not reentered */ 241 size = dev->uclass->uc_drv->per_device_auto_alloc_size; 242 if (size && !dev->uclass_priv) { 243 dev->uclass_priv = calloc(1, size); 244 if (!dev->uclass_priv) { 245 ret = -ENOMEM; 246 goto fail; 247 } 248 } 249 250 /* Ensure all parents are probed */ 251 if (dev->parent) { 252 size = dev->parent->driver->per_child_auto_alloc_size; 253 if (!size) { 254 size = dev->parent->uclass->uc_drv-> 255 per_child_auto_alloc_size; 256 } 257 if (size && !dev->parent_priv) { 258 dev->parent_priv = alloc_priv(size, drv->flags); 259 if (!dev->parent_priv) { 260 ret = -ENOMEM; 261 goto fail; 262 } 263 if (parent_priv) 264 memcpy(dev->parent_priv, parent_priv, size); 265 } 266 267 ret = device_probe(dev->parent); 268 if (ret) 269 goto fail; 270 271 /* 272 * The device might have already been probed during 273 * the call to device_probe() on its parent device 274 * (e.g. PCI bridge devices). Test the flags again 275 * so that we don't mess up the device. 276 */ 277 if (dev->flags & DM_FLAG_ACTIVATED) 278 return 0; 279 } 280 281 seq = uclass_resolve_seq(dev); 282 if (seq < 0) { 283 ret = seq; 284 goto fail; 285 } 286 dev->seq = seq; 287 288 dev->flags |= DM_FLAG_ACTIVATED; 289 290 /* continue regardless of the result of pinctrl */ 291 pinctrl_select_state(dev, "default"); 292 293 ret = uclass_pre_probe_device(dev); 294 if (ret) 295 goto fail; 296 297 if (dev->parent && dev->parent->driver->child_pre_probe) { 298 ret = dev->parent->driver->child_pre_probe(dev); 299 if (ret) 300 goto fail; 301 } 302 303 if (drv->ofdata_to_platdata && dev->of_offset >= 0) { 304 ret = drv->ofdata_to_platdata(dev); 305 if (ret) 306 goto fail; 307 } 308 309 if (drv->probe) { 310 ret = drv->probe(dev); 311 if (ret) { 312 dev->flags &= ~DM_FLAG_ACTIVATED; 313 goto fail; 314 } 315 } 316 317 ret = uclass_post_probe_device(dev); 318 if (ret) 319 goto fail_uclass; 320 321 return 0; 322 fail_uclass: 323 if (device_remove(dev)) { 324 dm_warn("%s: Device '%s' failed to remove on error path\n", 325 __func__, dev->name); 326 } 327 fail: 328 dev->flags &= ~DM_FLAG_ACTIVATED; 329 330 dev->seq = -1; 331 device_free(dev); 332 333 return ret; 334 } 335 336 int device_probe(struct udevice *dev) 337 { 338 return device_probe_child(dev, NULL); 339 } 340 341 void *dev_get_platdata(struct udevice *dev) 342 { 343 if (!dev) { 344 dm_warn("%s: null device\n", __func__); 345 return NULL; 346 } 347 348 return dev->platdata; 349 } 350 351 void *dev_get_parent_platdata(struct udevice *dev) 352 { 353 if (!dev) { 354 dm_warn("%s: null device\n", __func__); 355 return NULL; 356 } 357 358 return dev->parent_platdata; 359 } 360 361 void *dev_get_uclass_platdata(struct udevice *dev) 362 { 363 if (!dev) { 364 dm_warn("%s: null device\n", __func__); 365 return NULL; 366 } 367 368 return dev->uclass_platdata; 369 } 370 371 void *dev_get_priv(struct udevice *dev) 372 { 373 if (!dev) { 374 dm_warn("%s: null device\n", __func__); 375 return NULL; 376 } 377 378 return dev->priv; 379 } 380 381 void *dev_get_uclass_priv(struct udevice *dev) 382 { 383 if (!dev) { 384 dm_warn("%s: null device\n", __func__); 385 return NULL; 386 } 387 388 return dev->uclass_priv; 389 } 390 391 void *dev_get_parentdata(struct udevice *dev) 392 { 393 if (!dev) { 394 dm_warn("%s: null device\n", __func__); 395 return NULL; 396 } 397 398 return dev->parent_priv; 399 } 400 401 static int device_get_device_tail(struct udevice *dev, int ret, 402 struct udevice **devp) 403 { 404 if (ret) 405 return ret; 406 407 ret = device_probe(dev); 408 if (ret) 409 return ret; 410 411 *devp = dev; 412 413 return 0; 414 } 415 416 int device_get_child(struct udevice *parent, int index, struct udevice **devp) 417 { 418 struct udevice *dev; 419 420 list_for_each_entry(dev, &parent->child_head, sibling_node) { 421 if (!index--) 422 return device_get_device_tail(dev, 0, devp); 423 } 424 425 return -ENODEV; 426 } 427 428 int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq, 429 bool find_req_seq, struct udevice **devp) 430 { 431 struct udevice *dev; 432 433 *devp = NULL; 434 if (seq_or_req_seq == -1) 435 return -ENODEV; 436 437 list_for_each_entry(dev, &parent->child_head, sibling_node) { 438 if ((find_req_seq ? dev->req_seq : dev->seq) == 439 seq_or_req_seq) { 440 *devp = dev; 441 return 0; 442 } 443 } 444 445 return -ENODEV; 446 } 447 448 int device_get_child_by_seq(struct udevice *parent, int seq, 449 struct udevice **devp) 450 { 451 struct udevice *dev; 452 int ret; 453 454 *devp = NULL; 455 ret = device_find_child_by_seq(parent, seq, false, &dev); 456 if (ret == -ENODEV) { 457 /* 458 * We didn't find it in probed devices. See if there is one 459 * that will request this seq if probed. 460 */ 461 ret = device_find_child_by_seq(parent, seq, true, &dev); 462 } 463 return device_get_device_tail(dev, ret, devp); 464 } 465 466 int device_find_child_by_of_offset(struct udevice *parent, int of_offset, 467 struct udevice **devp) 468 { 469 struct udevice *dev; 470 471 *devp = NULL; 472 473 list_for_each_entry(dev, &parent->child_head, sibling_node) { 474 if (dev->of_offset == of_offset) { 475 *devp = dev; 476 return 0; 477 } 478 } 479 480 return -ENODEV; 481 } 482 483 int device_get_child_by_of_offset(struct udevice *parent, int node, 484 struct udevice **devp) 485 { 486 struct udevice *dev; 487 int ret; 488 489 *devp = NULL; 490 ret = device_find_child_by_of_offset(parent, node, &dev); 491 return device_get_device_tail(dev, ret, devp); 492 } 493 494 static struct udevice *_device_find_global_by_of_offset(struct udevice *parent, 495 int of_offset) 496 { 497 struct udevice *dev, *found; 498 499 if (parent->of_offset == of_offset) 500 return parent; 501 502 list_for_each_entry(dev, &parent->child_head, sibling_node) { 503 found = _device_find_global_by_of_offset(dev, of_offset); 504 if (found) 505 return found; 506 } 507 508 return NULL; 509 } 510 511 int device_get_global_by_of_offset(int of_offset, struct udevice **devp) 512 { 513 struct udevice *dev; 514 515 dev = _device_find_global_by_of_offset(gd->dm_root, of_offset); 516 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp); 517 } 518 519 int device_find_first_child(struct udevice *parent, struct udevice **devp) 520 { 521 if (list_empty(&parent->child_head)) { 522 *devp = NULL; 523 } else { 524 *devp = list_first_entry(&parent->child_head, struct udevice, 525 sibling_node); 526 } 527 528 return 0; 529 } 530 531 int device_find_next_child(struct udevice **devp) 532 { 533 struct udevice *dev = *devp; 534 struct udevice *parent = dev->parent; 535 536 if (list_is_last(&dev->sibling_node, &parent->child_head)) { 537 *devp = NULL; 538 } else { 539 *devp = list_entry(dev->sibling_node.next, struct udevice, 540 sibling_node); 541 } 542 543 return 0; 544 } 545 546 struct udevice *dev_get_parent(struct udevice *child) 547 { 548 return child->parent; 549 } 550 551 ulong dev_get_driver_data(struct udevice *dev) 552 { 553 return dev->driver_data; 554 } 555 556 const void *dev_get_driver_ops(struct udevice *dev) 557 { 558 if (!dev || !dev->driver->ops) 559 return NULL; 560 561 return dev->driver->ops; 562 } 563 564 enum uclass_id device_get_uclass_id(struct udevice *dev) 565 { 566 return dev->uclass->uc_drv->id; 567 } 568 569 const char *dev_get_uclass_name(struct udevice *dev) 570 { 571 if (!dev) 572 return NULL; 573 574 return dev->uclass->uc_drv->name; 575 } 576 577 fdt_addr_t dev_get_addr(struct udevice *dev) 578 { 579 #if CONFIG_IS_ENABLED(OF_CONTROL) 580 fdt_addr_t addr; 581 582 addr = fdtdec_get_addr(gd->fdt_blob, dev->of_offset, "reg"); 583 if (CONFIG_IS_ENABLED(SIMPLE_BUS) && addr != FDT_ADDR_T_NONE) { 584 if (device_get_uclass_id(dev->parent) == UCLASS_SIMPLE_BUS) 585 addr = simple_bus_translate(dev->parent, addr); 586 } 587 588 return addr; 589 #else 590 return FDT_ADDR_T_NONE; 591 #endif 592 } 593 594 bool device_has_children(struct udevice *dev) 595 { 596 return !list_empty(&dev->child_head); 597 } 598 599 bool device_has_active_children(struct udevice *dev) 600 { 601 struct udevice *child; 602 603 for (device_find_first_child(dev, &child); 604 child; 605 device_find_next_child(&child)) { 606 if (device_active(child)) 607 return true; 608 } 609 610 return false; 611 } 612 613 bool device_is_last_sibling(struct udevice *dev) 614 { 615 struct udevice *parent = dev->parent; 616 617 if (!parent) 618 return false; 619 return list_is_last(&dev->sibling_node, &parent->child_head); 620 } 621 622 int device_set_name(struct udevice *dev, const char *name) 623 { 624 name = strdup(name); 625 if (!name) 626 return -ENOMEM; 627 dev->name = name; 628 629 return 0; 630 } 631