1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (c) 2021, Linaro Limited 4 * Copyright (c) 2021, Bootlin 5 * Copyright (c) 2021, Linaro Limited 6 * Copyright (c) 2021, STMicroelectronics 7 */ 8 9 #include <assert.h> 10 #include <config.h> 11 #include <initcall.h> 12 #include <kernel/boot.h> 13 #include <kernel/dt.h> 14 #include <kernel/dt_driver.h> 15 #include <libfdt.h> 16 #include <malloc.h> 17 #include <sys/queue.h> 18 #include <tee_api_defines_extensions.h> 19 #include <tee_api_types.h> 20 21 /* 22 * struct dt_driver_probe - Node instance in secure FDT to probe a driver for 23 * 24 * @link: List hook 25 * @nodeoffset: Node offset of device referenced in the FDT 26 * @type: One of DT_DRIVER_* or DT_DRIVER_NOTYPE. 27 * @deferrals: Driver probe deferrals count 28 * @dt_drv: Matching driver to probe if found or NULL 29 * @dm: Matching reference if applicable or NULL 30 */ 31 struct dt_driver_probe { 32 int nodeoffset; 33 enum dt_driver_type type; 34 unsigned int deferrals; 35 const struct dt_driver *dt_drv; 36 const struct dt_device_match *dm; 37 TAILQ_ENTRY(dt_driver_probe) link; 38 }; 39 40 /* 41 * struct dt_driver_provider - DT related info on probed device 42 * 43 * Saves information on the probed device so that device 44 * drivers can get resources from DT phandle and related arguments. 45 * 46 * @nodeoffset: Node offset of device referenced in the FDT 47 * @type: One of DT_DRIVER_* or DT_DRIVER_NOTYPE. 48 * @provider_cells: Cells count in the FDT used by the driver's references 49 * @get_of_device: Function to get driver's device ref from phandle data 50 * @priv_data: Driver private data passed as @get_of_device argument 51 * @link: Reference in DT driver providers list 52 */ 53 struct dt_driver_provider { 54 int nodeoffset; 55 enum dt_driver_type type; 56 unsigned int provider_cells; 57 uint32_t phandle; 58 get_of_device_func get_of_device; 59 void *priv_data; 60 SLIST_ENTRY(dt_driver_provider) link; 61 }; 62 63 /* 64 * Device driver providers are able to provide a driver specific instance 65 * related to device phandle arguments found in the secure embedded FDT. 66 */ 67 static SLIST_HEAD(, dt_driver_provider) dt_driver_provider_list = 68 SLIST_HEAD_INITIALIZER(dt_driver_provider_list); 69 70 /* FDT nodes for which a matching driver is to be probed */ 71 static TAILQ_HEAD(dt_driver_probe_head, dt_driver_probe) dt_driver_probe_list = 72 TAILQ_HEAD_INITIALIZER(dt_driver_probe_list); 73 74 /* FDT nodes for which a matching driver has been successfully probed */ 75 static TAILQ_HEAD(, dt_driver_probe) dt_driver_ready_list = 76 TAILQ_HEAD_INITIALIZER(dt_driver_ready_list); 77 78 /* List of the nodes for which a compatible driver but reported a failure */ 79 static TAILQ_HEAD(, dt_driver_probe) dt_driver_failed_list = 80 TAILQ_HEAD_INITIALIZER(dt_driver_failed_list); 81 82 /* Flag enabled when a new node (possibly typed) is added in the probe list */ 83 static bool added_node; 84 85 /* Resolve drivers dependencies on core crypto layer */ 86 static bool tee_crypt_is_ready; 87 88 void dt_driver_crypt_init_complete(void) 89 { 90 assert(!tee_crypt_is_ready); 91 tee_crypt_is_ready = true; 92 } 93 94 TEE_Result dt_driver_get_crypto(void) 95 { 96 if (tee_crypt_is_ready) 97 return TEE_SUCCESS; 98 else 99 return TEE_ERROR_DEFER_DRIVER_INIT; 100 } 101 102 static void assert_type_is_valid(enum dt_driver_type type) 103 { 104 switch (type) { 105 case DT_DRIVER_NOTYPE: 106 case DT_DRIVER_CLK: 107 case DT_DRIVER_RSTCTRL: 108 case DT_DRIVER_UART: 109 case DT_DRIVER_GPIO: 110 case DT_DRIVER_I2C: 111 return; 112 default: 113 assert(0); 114 } 115 } 116 117 /* 118 * Driver provider registering API functions 119 */ 120 121 TEE_Result dt_driver_register_provider(const void *fdt, int nodeoffset, 122 get_of_device_func get_of_device, 123 void *priv, enum dt_driver_type type) 124 { 125 struct dt_driver_provider *prv = NULL; 126 int provider_cells = 0; 127 uint32_t phandle = 0; 128 129 assert_type_is_valid(type); 130 131 provider_cells = fdt_get_dt_driver_cells(fdt, nodeoffset, type); 132 if (provider_cells < 0) { 133 DMSG("Failed to find provider cells: %d", provider_cells); 134 return TEE_ERROR_GENERIC; 135 } 136 137 phandle = fdt_get_phandle(fdt, nodeoffset); 138 if (phandle == (uint32_t)-1) { 139 DMSG("Failed to find provide phandle"); 140 return TEE_ERROR_GENERIC; 141 } 142 143 prv = calloc(1, sizeof(*prv)); 144 if (!prv) 145 return TEE_ERROR_OUT_OF_MEMORY; 146 147 prv->nodeoffset = nodeoffset; 148 prv->type = type; 149 prv->provider_cells = provider_cells; 150 prv->phandle = phandle; 151 prv->get_of_device = get_of_device; 152 prv->priv_data = priv; 153 154 SLIST_INSERT_HEAD(&dt_driver_provider_list, prv, link); 155 156 return TEE_SUCCESS; 157 } 158 159 /* 160 * Helper functions for dt_drivers querying driver provider information 161 */ 162 163 int fdt_get_dt_driver_cells(const void *fdt, int nodeoffset, 164 enum dt_driver_type type) 165 { 166 const char *cells_name = NULL; 167 const fdt32_t *c = NULL; 168 int len = 0; 169 170 switch (type) { 171 case DT_DRIVER_CLK: 172 cells_name = "#clock-cells"; 173 break; 174 case DT_DRIVER_RSTCTRL: 175 cells_name = "#reset-cells"; 176 break; 177 case DT_DRIVER_GPIO: 178 cells_name = "#gpio-cells"; 179 break; 180 case DT_DRIVER_I2C: 181 return 0; 182 default: 183 panic(); 184 } 185 186 c = fdt_getprop(fdt, nodeoffset, cells_name, &len); 187 if (!c) 188 return len; 189 190 if (len != sizeof(*c)) 191 return -FDT_ERR_BADNCELLS; 192 193 return fdt32_to_cpu(*c); 194 } 195 196 unsigned int dt_driver_provider_cells(struct dt_driver_provider *prv) 197 { 198 return prv->provider_cells; 199 } 200 201 struct dt_driver_provider * 202 dt_driver_get_provider_by_node(int nodeoffset, enum dt_driver_type type) 203 { 204 struct dt_driver_provider *prv = NULL; 205 206 SLIST_FOREACH(prv, &dt_driver_provider_list, link) 207 if (prv->nodeoffset == nodeoffset && prv->type == type) 208 return prv; 209 210 return NULL; 211 } 212 213 struct dt_driver_provider * 214 dt_driver_get_provider_by_phandle(uint32_t phandle, enum dt_driver_type type) 215 { 216 struct dt_driver_provider *prv = NULL; 217 218 SLIST_FOREACH(prv, &dt_driver_provider_list, link) 219 if (prv->phandle == phandle && prv->type == type) 220 return prv; 221 222 return NULL; 223 } 224 225 static void *device_from_provider_prop(struct dt_driver_provider *prv, 226 const void *fdt, int phandle_node, 227 const uint32_t *prop, TEE_Result *res) 228 { 229 struct dt_driver_phandle_args *pargs = NULL; 230 unsigned int n = 0; 231 void *device = NULL; 232 233 pargs = calloc(1, prv->provider_cells * sizeof(uint32_t *) + 234 sizeof(*pargs)); 235 if (!pargs) { 236 *res = TEE_ERROR_OUT_OF_MEMORY; 237 return NULL; 238 } 239 240 pargs->fdt = fdt; 241 pargs->phandle_node = phandle_node; 242 pargs->args_count = prv->provider_cells; 243 for (n = 0; n < prv->provider_cells; n++) 244 pargs->args[n] = fdt32_to_cpu(prop[n + 1]); 245 246 device = prv->get_of_device(pargs, prv->priv_data, res); 247 248 free(pargs); 249 250 return device; 251 } 252 253 void *dt_driver_device_from_parent(const void *fdt, int nodeoffset, 254 enum dt_driver_type type, TEE_Result *res) 255 { 256 int parent = -1; 257 struct dt_driver_provider *prv = NULL; 258 259 assert(fdt == get_secure_dt()); 260 261 parent = fdt_parent_offset(fdt, nodeoffset); 262 if (parent < 0) { 263 *res = TEE_ERROR_GENERIC; 264 return NULL; 265 } 266 267 prv = dt_driver_get_provider_by_node(parent, type); 268 if (!prv) { 269 /* No provider registered yet */ 270 *res = TEE_ERROR_DEFER_DRIVER_INIT; 271 return NULL; 272 } 273 274 return device_from_provider_prop(prv, fdt, nodeoffset, NULL, res); 275 } 276 277 void *dt_driver_device_from_node_idx_prop(const char *prop_name, 278 const void *fdt, int nodeoffset, 279 unsigned int prop_idx, 280 enum dt_driver_type type, 281 TEE_Result *res) 282 { 283 int len = 0; 284 int idx = 0; 285 int idx32 = 0; 286 int prv_cells = 0; 287 int phandle_node = -1; 288 uint32_t phandle = 0; 289 const uint32_t *prop = NULL; 290 struct dt_driver_provider *prv = NULL; 291 292 prop = fdt_getprop(fdt, nodeoffset, prop_name, &len); 293 if (!prop) { 294 DMSG("Property %s missing in node %s", prop_name, 295 fdt_get_name(fdt, nodeoffset, NULL)); 296 *res = TEE_ERROR_ITEM_NOT_FOUND; 297 return NULL; 298 } 299 300 while (idx < len) { 301 idx32 = idx / sizeof(uint32_t); 302 phandle = fdt32_to_cpu(prop[idx32]); 303 if (!phandle) { 304 if (!prop_idx) 305 break; 306 idx += sizeof(phandle); 307 prop_idx--; 308 continue; 309 } 310 311 prv = dt_driver_get_provider_by_phandle(phandle, type); 312 if (!prv) { 313 /* No provider registered yet */ 314 *res = TEE_ERROR_DEFER_DRIVER_INIT; 315 return NULL; 316 } 317 318 prv_cells = dt_driver_provider_cells(prv); 319 if (prop_idx) { 320 prop_idx--; 321 idx += sizeof(phandle) + prv_cells * sizeof(uint32_t); 322 continue; 323 } 324 325 return device_from_provider_prop(prv, fdt, phandle_node, 326 prop + idx32, res); 327 } 328 329 *res = TEE_ERROR_ITEM_NOT_FOUND; 330 return NULL; 331 } 332 333 static void __maybe_unused print_probe_list(const void *fdt __maybe_unused) 334 { 335 struct dt_driver_probe *elt = NULL; 336 unsigned int count = 0; 337 338 TAILQ_FOREACH(elt, &dt_driver_probe_list, link) 339 count++; 340 341 DMSG("Probe list: %u elements", count); 342 TAILQ_FOREACH(elt, &dt_driver_probe_list, link) 343 DMSG("|- Driver %s probes on node %s", 344 elt->dt_drv->name, 345 fdt_get_name(fdt, elt->nodeoffset, NULL)); 346 347 DMSG("`- Probe list end"); 348 349 count = 0; 350 TAILQ_FOREACH(elt, &dt_driver_failed_list, link) 351 count++; 352 353 DMSG("Failed list: %u elements", count); 354 TAILQ_FOREACH(elt, &dt_driver_failed_list, link) 355 EMSG("|- Driver %s on node %s failed", elt->dt_drv->name, 356 fdt_get_name(fdt, elt->nodeoffset, NULL)); 357 358 DMSG("`- Failed list end"); 359 } 360 361 /* 362 * Probe element: push to ready list if succeeds, push to probe list if probe 363 * if deferred, panic with an error trace otherwise. 364 */ 365 static TEE_Result probe_driver_node(const void *fdt, 366 struct dt_driver_probe *elt) 367 { 368 TEE_Result res = TEE_ERROR_GENERIC; 369 const char __maybe_unused *drv_name = NULL; 370 const char __maybe_unused *node_name = NULL; 371 372 node_name = fdt_get_name(fdt, elt->nodeoffset, NULL); 373 drv_name = elt->dt_drv->name; 374 375 if (!elt->dt_drv->probe) { 376 DMSG("No probe operator for driver %s, skipped", drv_name); 377 return TEE_SUCCESS; 378 } 379 380 FMSG("Probing %s on node %s", drv_name, node_name); 381 382 res = elt->dt_drv->probe(fdt, elt->nodeoffset, elt->dm->compat_data); 383 switch (res) { 384 case TEE_SUCCESS: 385 TAILQ_INSERT_HEAD(&dt_driver_ready_list, elt, link); 386 387 DMSG("element: %s on node %s initialized", drv_name, node_name); 388 break; 389 case TEE_ERROR_DEFER_DRIVER_INIT: 390 elt->deferrals++; 391 TAILQ_INSERT_TAIL(&dt_driver_probe_list, elt, link); 392 393 DMSG("element: %s on node %s deferred %u time(s)", drv_name, 394 node_name, elt->deferrals); 395 break; 396 case TEE_ERROR_NODE_DISABLED: 397 DMSG("element: %s on node %s is disabled", drv_name, node_name); 398 break; 399 default: 400 TAILQ_INSERT_HEAD(&dt_driver_failed_list, elt, link); 401 402 EMSG("Failed to probe %s on node %s: %#"PRIx32, 403 drv_name, node_name, res); 404 break; 405 } 406 407 return res; 408 } 409 410 static TEE_Result alloc_elt_and_probe(const void *fdt, int node, 411 const struct dt_driver *dt_drv, 412 const struct dt_device_match *dm) 413 { 414 struct dt_driver_probe *elt = NULL; 415 416 /* Will be freed when lists are released */ 417 elt = calloc(1, sizeof(*elt)); 418 if (!elt) 419 return TEE_ERROR_OUT_OF_MEMORY; 420 421 elt->nodeoffset = node; 422 elt->dt_drv = dt_drv; 423 elt->dm = dm; 424 elt->type = dt_drv->type; 425 426 return probe_driver_node(fdt, elt); 427 } 428 429 /* Lookup a compatible driver, possibly of a specific @type, for the FDT node */ 430 static TEE_Result probe_device_by_compat(const void *fdt, int node, 431 const char *compat, 432 enum dt_driver_type type) 433 { 434 const struct dt_driver *drv = NULL; 435 const struct dt_device_match *dm = NULL; 436 437 for_each_dt_driver(drv) { 438 if (drv->type != type) 439 continue; 440 441 for (dm = drv->match_table; dm && dm->compatible; dm++) 442 if (strcmp(dm->compatible, compat) == 0) 443 return alloc_elt_and_probe(fdt, node, drv, dm); 444 } 445 446 return TEE_ERROR_ITEM_NOT_FOUND; 447 } 448 449 /* 450 * Lookup the best matching compatible driver, possibly of a specific @type, 451 * for the FDT node. 452 */ 453 TEE_Result dt_driver_probe_device_by_node(const void *fdt, int nodeoffset, 454 enum dt_driver_type type) 455 { 456 int idx = 0; 457 int len = 0; 458 int count = 0; 459 const char *compat = NULL; 460 TEE_Result res = TEE_ERROR_GENERIC; 461 462 assert_type_is_valid(type); 463 464 count = fdt_stringlist_count(fdt, nodeoffset, "compatible"); 465 if (count < 0) 466 return TEE_ERROR_ITEM_NOT_FOUND; 467 468 for (idx = 0; idx < count; idx++) { 469 compat = fdt_stringlist_get(fdt, nodeoffset, "compatible", 470 idx, &len); 471 if (!compat) 472 return TEE_ERROR_GENERIC; 473 474 res = probe_device_by_compat(fdt, nodeoffset, compat, type); 475 476 if (res != TEE_ERROR_ITEM_NOT_FOUND) 477 return res; 478 } 479 480 return TEE_ERROR_ITEM_NOT_FOUND; 481 } 482 483 static TEE_Result process_probe_list(const void *fdt) 484 { 485 struct dt_driver_probe *elt = NULL; 486 struct dt_driver_probe *prev = NULL; 487 static unsigned int __maybe_unused loop_count; 488 static unsigned int __maybe_unused deferral_loop_count; 489 bool __maybe_unused one_deferred = false; 490 bool one_probed_ok = false; 491 492 do { 493 loop_count++; 494 FMSG("Probe loop %u after %u for deferral(s)", loop_count, 495 deferral_loop_count); 496 497 /* Hack here for TRACE_DEBUG messages on probe list elements */ 498 if (TRACE_LEVEL >= TRACE_FLOW) 499 print_probe_list(fdt); 500 501 if (TAILQ_EMPTY(&dt_driver_probe_list)) 502 return TEE_SUCCESS; 503 504 /* 505 * Probe from current end to top. Deferred probed node are 506 * pushed back after current tail for the next probe round. 507 * Reset probe result flags and see status after probe round. 508 */ 509 one_deferred = false; 510 one_probed_ok = false; 511 added_node = false; 512 513 TAILQ_FOREACH_REVERSE_SAFE(elt, &dt_driver_probe_list, 514 dt_driver_probe_head, link, prev) { 515 TAILQ_REMOVE(&dt_driver_probe_list, elt, link); 516 517 switch (probe_driver_node(fdt, elt)) { 518 case TEE_SUCCESS: 519 one_probed_ok = true; 520 break; 521 case TEE_ERROR_DEFER_DRIVER_INIT: 522 one_deferred = true; 523 break; 524 default: 525 break; 526 } 527 } 528 529 if (one_deferred) 530 deferral_loop_count++; 531 532 } while (added_node || one_probed_ok); 533 534 DMSG("Unresolved dependencies after %u rounds, %u deferred", 535 loop_count, deferral_loop_count); 536 537 if (one_deferred) 538 return TEE_ERROR_DEFER_DRIVER_INIT; 539 else 540 return TEE_ERROR_GENERIC; 541 } 542 543 static int driver_probe_compare(struct dt_driver_probe *candidate, 544 struct dt_driver_probe *elt) 545 { 546 if (candidate->nodeoffset != elt->nodeoffset || 547 candidate->type != elt->type) 548 return 1; 549 550 assert(elt->dt_drv == candidate->dt_drv); 551 return 0; 552 } 553 554 /* 555 * Return TEE_SUCCESS if compatible found 556 * TEE_ERROR_OUT_OF_MEMORY if heap is exhausted 557 */ 558 static TEE_Result add_node_to_probe(const void *fdt, int node, 559 const struct dt_driver *dt_drv, 560 const struct dt_device_match *dm) 561 { 562 const char __maybe_unused *node_name = fdt_get_name(fdt, node, NULL); 563 const char __maybe_unused *drv_name = dt_drv->name; 564 struct dt_driver_probe *elt = NULL; 565 struct dt_driver_probe elt_new = { 566 .dm = dm, 567 .dt_drv = dt_drv, 568 .nodeoffset = node, 569 .type = dt_drv->type, 570 }; 571 572 /* If node/type found in probe list or ready list, nothing to do */ 573 TAILQ_FOREACH(elt, &dt_driver_probe_list, link) 574 if (!driver_probe_compare(&elt_new, elt)) 575 return TEE_SUCCESS; 576 577 TAILQ_FOREACH(elt, &dt_driver_ready_list, link) 578 if (!driver_probe_compare(&elt_new, elt)) 579 return TEE_SUCCESS; 580 581 elt = malloc(sizeof(*elt)); 582 if (!elt) 583 return TEE_ERROR_OUT_OF_MEMORY; 584 585 DMSG("element: %s on node %s", node_name, drv_name); 586 587 memcpy(elt, &elt_new, sizeof(*elt)); 588 589 added_node = true; 590 591 TAILQ_INSERT_TAIL(&dt_driver_probe_list, elt, link); 592 593 /* Hack here for TRACE_DEBUG messages on current probe list elements */ 594 if (TRACE_LEVEL >= TRACE_FLOW) 595 print_probe_list(fdt); 596 597 return TEE_SUCCESS; 598 } 599 600 /* 601 * Add a node to the probe list if a dt_driver matches target compatible. 602 * 603 * If @type is DT_DRIVER_ANY, probe list can hold only 1 driver to probe for 604 * the node. A node may probe several drivers if have a unique driver type. 605 * 606 * Return TEE_SUCCESS if compatible found 607 * TEE_ERROR_ITEM_NOT_FOUND if no matching driver 608 * TEE_ERROR_OUT_OF_MEMORY if heap is exhausted 609 */ 610 static TEE_Result add_probe_node_by_compat(const void *fdt, int node, 611 const char *compat) 612 { 613 TEE_Result res = TEE_ERROR_ITEM_NOT_FOUND; 614 const struct dt_driver *dt_drv = NULL; 615 const struct dt_device_match *dm = NULL; 616 uint32_t found_types = 0; 617 618 for_each_dt_driver(dt_drv) { 619 for (dm = dt_drv->match_table; dm && dm->compatible; dm++) { 620 if (strcmp(dm->compatible, compat) == 0) { 621 assert(dt_drv->type < 32); 622 623 res = add_node_to_probe(fdt, node, dt_drv, dm); 624 if (res) 625 return res; 626 627 if (found_types & BIT(dt_drv->type)) { 628 EMSG("Driver %s multi hit on type %u", 629 dt_drv->name, dt_drv->type); 630 panic(); 631 } 632 found_types |= BIT(dt_drv->type); 633 634 /* Matching found for this driver, try next */ 635 break; 636 } 637 } 638 } 639 640 return res; 641 } 642 643 /* 644 * Add the node to the probe list if matching compatible drivers are found. 645 * Follow node's compatible property list ordering to find matching driver. 646 */ 647 TEE_Result dt_driver_maybe_add_probe_node(const void *fdt, int node) 648 { 649 int idx = 0; 650 int len = 0; 651 int count = 0; 652 const char *compat = NULL; 653 TEE_Result res = TEE_ERROR_GENERIC; 654 655 if (fdt_get_status(fdt, node) == DT_STATUS_DISABLED) 656 return TEE_SUCCESS; 657 658 count = fdt_stringlist_count(fdt, node, "compatible"); 659 if (count < 0) 660 return TEE_SUCCESS; 661 662 for (idx = 0; idx < count; idx++) { 663 compat = fdt_stringlist_get(fdt, node, "compatible", idx, &len); 664 assert(compat && len > 0); 665 666 res = add_probe_node_by_compat(fdt, node, compat); 667 668 /* Stop lookup if something was found */ 669 if (res != TEE_ERROR_ITEM_NOT_FOUND) 670 return res; 671 } 672 673 return TEE_SUCCESS; 674 } 675 676 static void parse_node(const void *fdt, int node) 677 { 678 TEE_Result __maybe_unused res = TEE_ERROR_GENERIC; 679 int subnode = 0; 680 681 fdt_for_each_subnode(subnode, fdt, node) { 682 res = dt_driver_maybe_add_probe_node(fdt, subnode); 683 if (res) { 684 EMSG("Failed on node %s with %#"PRIx32, 685 fdt_get_name(fdt, subnode, NULL), res); 686 panic(); 687 } 688 689 /* 690 * Rescursively parse the FDT, skipping disabled nodes. 691 * FDT is expected reliable and core shall have sufficient 692 * stack depth to possibly parse all DT nodes. 693 */ 694 if (IS_ENABLED(CFG_DRIVERS_DT_RECURSIVE_PROBE)) { 695 if (fdt_get_status(fdt, subnode) == DT_STATUS_DISABLED) 696 continue; 697 698 parse_node(fdt, subnode); 699 } 700 } 701 } 702 703 /* 704 * Parse FDT for nodes and save in probe list the node for which a dt_driver 705 * matches node's compatible property. 706 */ 707 static TEE_Result probe_dt_drivers_early(void) 708 { 709 TEE_Result res = TEE_ERROR_GENERIC; 710 const void *fdt = NULL; 711 712 fdt = get_secure_dt(); 713 if (!fdt) 714 return TEE_SUCCESS; 715 716 parse_node(fdt, fdt_path_offset(fdt, "/")); 717 718 res = process_probe_list(fdt); 719 if (res == TEE_ERROR_DEFER_DRIVER_INIT) { 720 DMSG("Deferred drivers probing"); 721 print_probe_list(fdt); 722 res = TEE_SUCCESS; 723 } 724 725 return res; 726 } 727 728 static TEE_Result probe_dt_drivers(void) 729 { 730 TEE_Result res = TEE_ERROR_GENERIC; 731 const void *fdt = NULL; 732 733 fdt = get_secure_dt(); 734 if (!fdt) 735 return TEE_SUCCESS; 736 737 res = process_probe_list(fdt); 738 if (res || !TAILQ_EMPTY(&dt_driver_failed_list)) { 739 EMSG("Probe sequence result: %#"PRIx32, res); 740 print_probe_list(fdt); 741 } 742 if (res) 743 panic(); 744 745 return TEE_SUCCESS; 746 } 747 748 early_init_late(probe_dt_drivers_early); 749 driver_init(probe_dt_drivers); 750 751 static TEE_Result release_probe_lists(void) 752 { 753 struct dt_driver_probe *elt = NULL; 754 struct dt_driver_probe *next = NULL; 755 struct dt_driver_provider *prov = NULL; 756 struct dt_driver_provider *next_prov = NULL; 757 const void *fdt = NULL; 758 759 fdt = get_secure_dt(); 760 if (!fdt) 761 return TEE_SUCCESS; 762 763 assert(fdt && TAILQ_EMPTY(&dt_driver_probe_list)); 764 765 TAILQ_FOREACH_SAFE(elt, &dt_driver_ready_list, link, next) 766 free(elt); 767 768 TAILQ_FOREACH_SAFE(elt, &dt_driver_failed_list, link, next) 769 free(elt); 770 771 SLIST_FOREACH_SAFE(prov, &dt_driver_provider_list, link, next_prov) 772 free(prov); 773 774 return TEE_SUCCESS; 775 } 776 777 release_init_resource(release_probe_lists); 778 779 /* 780 * Simple bus support: handy to parse subnodes 781 */ 782 static TEE_Result simple_bus_probe(const void *fdt, int node, 783 const void *compat_data __unused) 784 { 785 TEE_Result res = TEE_ERROR_GENERIC; 786 int subnode = 0; 787 788 fdt_for_each_subnode(subnode, fdt, node) { 789 res = dt_driver_maybe_add_probe_node(fdt, subnode); 790 if (res) { 791 EMSG("Failed on node %s with %#"PRIx32, 792 fdt_get_name(fdt, subnode, NULL), res); 793 panic(); 794 } 795 } 796 797 return TEE_SUCCESS; 798 } 799 800 static const struct dt_device_match simple_bus_match_table[] = { 801 { .compatible = "simple-bus" }, 802 { } 803 }; 804 805 DEFINE_DT_DRIVER(simple_bus_dt_driver) = { 806 .name = "simple-bus", 807 .match_table = simple_bus_match_table, 808 .probe = simple_bus_probe, 809 }; 810