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