drivers/core/uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2013 Google, Inc
   4  *
   5  * (C) Copyright 2012
   6  * Pavel Herrmann <morpheus.ibis@gmail.com>
   7  */
   8
   9 #define LOG_CATEGORY LOGC_DM
  10
  11 #include <common.h>
  12 #include <dm.h>
  13 #include <errno.h>
  14 #include <log.h>
  15 #include <malloc.h>
  16 #include <dm/device.h>
  17 #include <dm/device-internal.h>
  18 #include <dm/lists.h>
  19 #include <dm/uclass.h>
  20 #include <dm/uclass-internal.h>
  21 #include <dm/util.h>
  22
  23 DECLARE_GLOBAL_DATA_PTR;
  24
  25 struct uclass *uclass_find(enum uclass_id key)
  26 {
  27         struct uclass *uc;
  28
  29         if (!gd->dm_root)
  30                 return NULL;
  31         /*
  32          * TODO(sjg@chromium.org): Optimise this, perhaps moving the found
  33          * node to the start of the list, or creating a linear array mapping
  34          * id to node.
  35          */
  36         list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
  37                 if (uc->uc_drv->id == key)
  38                         return uc;
  39         }
  40
  41         return NULL;
  42 }
  43
  44 /**
  45  * uclass_add() - Create new uclass in list
  46  * @id: Id number to create
  47  * @ucp: Returns pointer to uclass, or NULL on error
  48  * @return 0 on success, -ve on error
  49  *
  50  * The new uclass is added to the list. There must be only one uclass for
  51  * each id.
  52  */
  53 static int uclass_add(enum uclass_id id, struct uclass **ucp)
  54 {
  55         struct uclass_driver *uc_drv;
  56         struct uclass *uc;
  57         int ret;
  58
  59         *ucp = NULL;
  60         uc_drv = lists_uclass_lookup(id);
  61         if (!uc_drv) {
  62                 debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
  63                       id);
  64                 /*
  65                  * Use a strange error to make this case easier to find. When
  66                  * a uclass is not available it can prevent driver model from
  67                  * starting up and this failure is otherwise hard to debug.
  68                  */
  69                 return -EPFNOSUPPORT;
  70         }
  71         uc = calloc(1, sizeof(*uc));
  72         if (!uc)
  73                 return -ENOMEM;
  74         if (uc_drv->priv_auto) {
  75                 uc->priv = calloc(1, uc_drv->priv_auto);
  76                 if (!uc->priv) {
  77                         ret = -ENOMEM;
  78                         goto fail_mem;
  79                 }
  80         }
  81         uc->uc_drv = uc_drv;
  82         INIT_LIST_HEAD(&uc->sibling_node);
  83         INIT_LIST_HEAD(&uc->dev_head);
  84         list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);
  85
  86         if (uc_drv->init) {
  87                 ret = uc_drv->init(uc);
  88                 if (ret)
  89                         goto fail;
  90         }
  91
  92         *ucp = uc;
  93
  94         return 0;
  95 fail:
  96         if (uc_drv->priv_auto) {
  97                 free(uc->priv);
  98                 uc->priv = NULL;
  99         }
 100         list_del(&uc->sibling_node);
 101 fail_mem:
 102         free(uc);
 103
 104         return ret;
 105 }
 106
 107 int uclass_destroy(struct uclass *uc)
 108 {
 109         struct uclass_driver *uc_drv;
 110         struct udevice *dev;
 111         int ret;
 112
 113         /*
 114          * We cannot use list_for_each_entry_safe() here. If a device in this
 115          * uclass has a child device also in this uclass, it will be also be
 116          * unbound (by the recursion in the call to device_unbind() below).
 117          * We can loop until the list is empty.
 118          */
 119         while (!list_empty(&uc->dev_head)) {
 120                 dev = list_first_entry(&uc->dev_head, struct udevice,
 121                                        uclass_node);
 122                 ret = device_remove(dev, DM_REMOVE_NORMAL | DM_REMOVE_NO_PD);
 123                 if (ret)
 124                         return log_msg_ret("remove", ret);
 125                 ret = device_unbind(dev);
 126                 if (ret)
 127                         return log_msg_ret("unbind", ret);
 128         }
 129
 130         uc_drv = uc->uc_drv;
 131         if (uc_drv->destroy)
 132                 uc_drv->destroy(uc);
 133         list_del(&uc->sibling_node);
 134         if (uc_drv->priv_auto)
 135                 free(uc->priv);
 136         free(uc);
 137
 138         return 0;
 139 }
 140
 141 int uclass_get(enum uclass_id id, struct uclass **ucp)
 142 {
 143         struct uclass *uc;
 144
 145         *ucp = NULL;
 146         uc = uclass_find(id);
 147         if (!uc)
 148                 return uclass_add(id, ucp);
 149         *ucp = uc;
 150
 151         return 0;
 152 }
 153
 154 const char *uclass_get_name(enum uclass_id id)
 155 {
 156         struct uclass *uc;
 157
 158         if (uclass_get(id, &uc))
 159                 return NULL;
 160         return uc->uc_drv->name;
 161 }
 162
 163 enum uclass_id uclass_get_by_name(const char *name)
 164 {
 165         int i;
 166
 167         for (i = 0; i < UCLASS_COUNT; i++) {
 168                 struct uclass_driver *uc_drv = lists_uclass_lookup(i);
 169
 170                 if (uc_drv && !strcmp(uc_drv->name, name))
 171                         return i;
 172         }
 173
 174         return UCLASS_INVALID;
 175 }
 176
 177 int dev_get_uclass_index(struct udevice *dev, struct uclass **ucp)
 178 {
 179         struct udevice *iter;
 180         struct uclass *uc = dev->uclass;
 181         int i = 0;
 182
 183         if (list_empty(&uc->dev_head))
 184                 return -ENODEV;
 185
 186         uclass_foreach_dev(iter, uc) {
 187                 if (iter == dev) {
 188                         if (ucp)
 189                                 *ucp = uc;
 190                         return i;
 191                 }
 192                 i++;
 193         }
 194
 195         return -ENODEV;
 196 }
 197
 198 int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
 199 {
 200         struct uclass *uc;
 201         struct udevice *dev;
 202         int ret;
 203
 204         *devp = NULL;
 205         ret = uclass_get(id, &uc);
 206         if (ret)
 207                 return ret;
 208         if (list_empty(&uc->dev_head))
 209                 return -ENODEV;
 210
 211         uclass_foreach_dev(dev, uc) {
 212                 if (!index--) {
 213                         *devp = dev;
 214                         return 0;
 215                 }
 216         }
 217
 218         return -ENODEV;
 219 }
 220
 221 int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
 222 {
 223         struct uclass *uc;
 224         int ret;
 225
 226         *devp = NULL;
 227         ret = uclass_get(id, &uc);
 228         if (ret)
 229                 return ret;
 230         if (list_empty(&uc->dev_head))
 231                 return 0;
 232
 233         *devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
 234
 235         return 0;
 236 }
 237
 238 int uclass_find_next_device(struct udevice **devp)
 239 {
 240         struct udevice *dev = *devp;
 241
 242         *devp = NULL;
 243         if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
 244                 return 0;
 245
 246         *devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
 247
 248         return 0;
 249 }
 250
 251 int uclass_find_device_by_name(enum uclass_id id, const char *name,
 252                                struct udevice **devp)
 253 {
 254         struct uclass *uc;
 255         struct udevice *dev;
 256         int ret;
 257
 258         *devp = NULL;
 259         if (!name)
 260                 return -EINVAL;
 261         ret = uclass_get(id, &uc);
 262         if (ret)
 263                 return ret;
 264
 265         uclass_foreach_dev(dev, uc) {
 266                 if (!strcmp(dev->name, name)) {
 267                         *devp = dev;
 268                         return 0;
 269                 }
 270         }
 271
 272         return -ENODEV;
 273 }
 274
 275 int uclass_find_next_free_req_seq(struct uclass *uc)
 276 {
 277         struct udevice *dev;
 278         int max = -1;
 279
 280         list_for_each_entry(dev, &uc->dev_head, uclass_node) {
 281                 if ((dev->req_seq != -1) && (dev->req_seq > max))
 282                         max = dev->req_seq;
 283         }
 284
 285         if (max == -1)
 286                 return 0;
 287
 288         return max + 1;
 289 }
 290
 291 int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
 292                               bool find_req_seq, struct udevice **devp)
 293 {
 294         struct uclass *uc;
 295         struct udevice *dev;
 296         int ret;
 297
 298         *devp = NULL;
 299         log_debug("%d %d\n", find_req_seq, seq_or_req_seq);
 300         if (seq_or_req_seq == -1)
 301                 return -ENODEV;
 302         ret = uclass_get(id, &uc);
 303         if (ret)
 304                 return ret;
 305
 306         uclass_foreach_dev(dev, uc) {
 307                 log_debug("   - %d %d '%s'\n",
 308                           dev->req_seq, dev_seq(dev), dev->name);
 309                 if (dev_seq(dev) == seq_or_req_seq) {
 310                         *devp = dev;
 311                         log_debug("   - found\n");
 312                         return 0;
 313                 }
 314         }
 315         log_debug("   - not found\n");
 316
 317         return -ENODEV;
 318 }
 319
 320 int uclass_find_device_by_of_offset(enum uclass_id id, int node,
 321                                     struct udevice **devp)
 322 {
 323         struct uclass *uc;
 324         struct udevice *dev;
 325         int ret;
 326
 327         *devp = NULL;
 328         if (node < 0)
 329                 return -ENODEV;
 330         ret = uclass_get(id, &uc);
 331         if (ret)
 332                 return ret;
 333
 334         uclass_foreach_dev(dev, uc) {
 335                 if (dev_of_offset(dev) == node) {
 336                         *devp = dev;
 337                         return 0;
 338                 }
 339         }
 340
 341         return -ENODEV;
 342 }
 343
 344 int uclass_find_device_by_ofnode(enum uclass_id id, ofnode node,
 345                                  struct udevice **devp)
 346 {
 347         struct uclass *uc;
 348         struct udevice *dev;
 349         int ret;
 350
 351         log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
 352         *devp = NULL;
 353         if (!ofnode_valid(node))
 354                 return -ENODEV;
 355         ret = uclass_get(id, &uc);
 356         if (ret)
 357                 return ret;
 358
 359         uclass_foreach_dev(dev, uc) {
 360                 log(LOGC_DM, LOGL_DEBUG_CONTENT, "      - checking %s\n",
 361                     dev->name);
 362                 if (ofnode_equal(dev_ofnode(dev), node)) {
 363                         *devp = dev;
 364                         goto done;
 365                 }
 366         }
 367         ret = -ENODEV;
 368
 369 done:
 370         log(LOGC_DM, LOGL_DEBUG, "   - result for %s: %s (ret=%d)\n",
 371             ofnode_get_name(node), *devp ? (*devp)->name : "(none)", ret);
 372         return ret;
 373 }
 374
 375 #if CONFIG_IS_ENABLED(OF_CONTROL)
 376 int uclass_find_device_by_phandle(enum uclass_id id, struct udevice *parent,
 377                                   const char *name, struct udevice **devp)
 378 {
 379         struct udevice *dev;
 380         struct uclass *uc;
 381         int find_phandle;
 382         int ret;
 383
 384         *devp = NULL;
 385         find_phandle = dev_read_u32_default(parent, name, -1);
 386         if (find_phandle <= 0)
 387                 return -ENOENT;
 388         ret = uclass_get(id, &uc);
 389         if (ret)
 390                 return ret;
 391
 392         uclass_foreach_dev(dev, uc) {
 393                 uint phandle;
 394
 395                 phandle = dev_read_phandle(dev);
 396
 397                 if (phandle == find_phandle) {
 398                         *devp = dev;
 399                         return 0;
 400                 }
 401         }
 402
 403         return -ENODEV;
 404 }
 405 #endif
 406
 407 int uclass_get_device_by_driver(enum uclass_id id,
 408                                 const struct driver *find_drv,
 409                                 struct udevice **devp)
 410 {
 411         struct udevice *dev;
 412         struct uclass *uc;
 413         int ret;
 414
 415         ret = uclass_get(id, &uc);
 416         if (ret)
 417                 return ret;
 418
 419         uclass_foreach_dev(dev, uc) {
 420                 if (dev->driver == find_drv)
 421                         return uclass_get_device_tail(dev, 0, devp);
 422         }
 423
 424         return -ENODEV;
 425 }
 426
 427 int uclass_get_device_tail(struct udevice *dev, int ret, struct udevice **devp)
 428 {
 429         if (ret)
 430                 return ret;
 431
 432         assert(dev);
 433         ret = device_probe(dev);
 434         if (ret)
 435                 return ret;
 436
 437         *devp = dev;
 438
 439         return 0;
 440 }
 441
 442 int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
 443 {
 444         struct udevice *dev;
 445         int ret;
 446
 447         *devp = NULL;
 448         ret = uclass_find_device(id, index, &dev);
 449         return uclass_get_device_tail(dev, ret, devp);
 450 }
 451
 452 int uclass_get_device_by_name(enum uclass_id id, const char *name,
 453                               struct udevice **devp)
 454 {
 455         struct udevice *dev;
 456         int ret;
 457
 458         *devp = NULL;
 459         ret = uclass_find_device_by_name(id, name, &dev);
 460         return uclass_get_device_tail(dev, ret, devp);
 461 }
 462
 463 int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
 464 {
 465         struct udevice *dev;
 466         int ret;
 467
 468         *devp = NULL;
 469         ret = uclass_find_device_by_seq(id, seq, false, &dev);
 470         if (ret == -ENODEV) {
 471                 /*
 472                  * We didn't find it in probed devices. See if there is one
 473                  * that will request this seq if probed.
 474                  */
 475                 ret = uclass_find_device_by_seq(id, seq, true, &dev);
 476         }
 477         return uclass_get_device_tail(dev, ret, devp);
 478 }
 479
 480 int uclass_get_device_by_of_offset(enum uclass_id id, int node,
 481                                    struct udevice **devp)
 482 {
 483         struct udevice *dev;
 484         int ret;
 485
 486         *devp = NULL;
 487         ret = uclass_find_device_by_of_offset(id, node, &dev);
 488         return uclass_get_device_tail(dev, ret, devp);
 489 }
 490
 491 int uclass_get_device_by_ofnode(enum uclass_id id, ofnode node,
 492                                 struct udevice **devp)
 493 {
 494         struct udevice *dev;
 495         int ret;
 496
 497         log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
 498         *devp = NULL;
 499         ret = uclass_find_device_by_ofnode(id, node, &dev);
 500         log(LOGC_DM, LOGL_DEBUG, "   - result for %s: %s (ret=%d)\n",
 501             ofnode_get_name(node), dev ? dev->name : "(none)", ret);
 502
 503         return uclass_get_device_tail(dev, ret, devp);
 504 }
 505
 506 #if CONFIG_IS_ENABLED(OF_CONTROL)
 507 int uclass_get_device_by_phandle_id(enum uclass_id id, uint phandle_id,
 508                                     struct udevice **devp)
 509 {
 510         struct udevice *dev;
 511         struct uclass *uc;
 512         int ret;
 513
 514         *devp = NULL;
 515         ret = uclass_get(id, &uc);
 516         if (ret)
 517                 return ret;
 518
 519         uclass_foreach_dev(dev, uc) {
 520                 uint phandle;
 521
 522                 phandle = dev_read_phandle(dev);
 523
 524                 if (phandle == phandle_id) {
 525                         *devp = dev;
 526                         return uclass_get_device_tail(dev, ret, devp);
 527                 }
 528         }
 529
 530         return -ENODEV;
 531 }
 532
 533 int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
 534                                  const char *name, struct udevice **devp)
 535 {
 536         struct udevice *dev;
 537         int ret;
 538
 539         *devp = NULL;
 540         ret = uclass_find_device_by_phandle(id, parent, name, &dev);
 541         return uclass_get_device_tail(dev, ret, devp);
 542 }
 543 #endif
 544
 545 int uclass_first_device(enum uclass_id id, struct udevice **devp)
 546 {
 547         struct udevice *dev;
 548         int ret;
 549
 550         *devp = NULL;
 551         ret = uclass_find_first_device(id, &dev);
 552         if (!dev)
 553                 return 0;
 554         return uclass_get_device_tail(dev, ret, devp);
 555 }
 556
 557 int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
 558 {
 559         int ret;
 560
 561         ret = uclass_first_device(id, devp);
 562         if (ret)
 563                 return ret;
 564         else if (!*devp)
 565                 return -ENODEV;
 566
 567         return 0;
 568 }
 569
 570 int uclass_next_device(struct udevice **devp)
 571 {
 572         struct udevice *dev = *devp;
 573         int ret;
 574
 575         *devp = NULL;
 576         ret = uclass_find_next_device(&dev);
 577         if (!dev)
 578                 return 0;
 579         return uclass_get_device_tail(dev, ret, devp);
 580 }
 581
 582 int uclass_next_device_err(struct udevice **devp)
 583 {
 584         int ret;
 585
 586         ret = uclass_next_device(devp);
 587         if (ret)
 588                 return ret;
 589         else if (!*devp)
 590                 return -ENODEV;
 591
 592         return 0;
 593 }
 594
 595 int uclass_first_device_check(enum uclass_id id, struct udevice **devp)
 596 {
 597         int ret;
 598
 599         *devp = NULL;
 600         ret = uclass_find_first_device(id, devp);
 601         if (ret)
 602                 return ret;
 603         if (!*devp)
 604                 return 0;
 605
 606         return device_probe(*devp);
 607 }
 608
 609 int uclass_next_device_check(struct udevice **devp)
 610 {
 611         int ret;
 612
 613         ret = uclass_find_next_device(devp);
 614         if (ret)
 615                 return ret;
 616         if (!*devp)
 617                 return 0;
 618
 619         return device_probe(*devp);
 620 }
 621
 622 int uclass_first_device_drvdata(enum uclass_id id, ulong driver_data,
 623                                 struct udevice **devp)
 624 {
 625         struct udevice *dev;
 626         struct uclass *uc;
 627
 628         uclass_id_foreach_dev(id, dev, uc) {
 629                 if (dev_get_driver_data(dev) == driver_data) {
 630                         *devp = dev;
 631
 632                         return device_probe(dev);
 633                 }
 634         }
 635
 636         return -ENODEV;
 637 }
 638
 639 int uclass_bind_device(struct udevice *dev)
 640 {
 641         struct uclass *uc;
 642         int ret;
 643
 644         uc = dev->uclass;
 645         list_add_tail(&dev->uclass_node, &uc->dev_head);
 646
 647         if (dev->parent) {
 648                 struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;
 649
 650                 if (uc_drv->child_post_bind) {
 651                         ret = uc_drv->child_post_bind(dev);
 652                         if (ret)
 653                                 goto err;
 654                 }
 655         }
 656
 657         return 0;
 658 err:
 659         /* There is no need to undo the parent's post_bind call */
 660         list_del(&dev->uclass_node);
 661
 662         return ret;
 663 }
 664
 665 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
 666 int uclass_unbind_device(struct udevice *dev)
 667 {
 668         struct uclass *uc;
 669         int ret;
 670
 671         uc = dev->uclass;
 672         if (uc->uc_drv->pre_unbind) {
 673                 ret = uc->uc_drv->pre_unbind(dev);
 674                 if (ret)
 675                         return ret;
 676         }
 677
 678         list_del(&dev->uclass_node);
 679         return 0;
 680 }
 681 #endif
 682
 683 int uclass_resolve_seq(struct udevice *dev)
 684 {
 685         struct uclass *uc = dev->uclass;
 686         struct uclass_driver *uc_drv = uc->uc_drv;
 687         struct udevice *dup;
 688         int seq = 0;
 689         int ret;
 690
 691         assert(dev_seq(dev) == -1);
 692         ret = uclass_find_device_by_seq(uc_drv->id, dev->req_seq, false, &dup);
 693         if (!ret) {
 694                 /* Do nothing here for now */
 695         } else if (ret == -ENODEV) {
 696                 /* Our requested sequence number is available */
 697                 if (dev->req_seq != -1)
 698                         return dev->req_seq;
 699         } else {
 700                 return ret;
 701         }
 702
 703         if (CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(DM_SEQ_ALIAS) &&
 704             (uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS)) {
 705                 /*
 706                  * dev_read_alias_highest_id() will return -1 if there no
 707                  * alias. Thus we can always add one.
 708                  */
 709                 seq = dev_read_alias_highest_id(uc_drv->name) + 1;
 710         }
 711
 712         for (; seq < DM_MAX_SEQ; seq++) {
 713                 ret = uclass_find_device_by_seq(uc_drv->id, seq, false, &dup);
 714                 if (ret == -ENODEV)
 715                         break;
 716                 if (ret)
 717                         return ret;
 718         }
 719         return seq;
 720 }
 721
 722 int uclass_pre_probe_device(struct udevice *dev)
 723 {
 724         struct uclass_driver *uc_drv;
 725         int ret;
 726
 727         uc_drv = dev->uclass->uc_drv;
 728         if (uc_drv->pre_probe) {
 729                 ret = uc_drv->pre_probe(dev);
 730                 if (ret)
 731                         return ret;
 732         }
 733
 734         if (!dev->parent)
 735                 return 0;
 736         uc_drv = dev->parent->uclass->uc_drv;
 737         if (uc_drv->child_pre_probe) {
 738                 ret = uc_drv->child_pre_probe(dev);
 739                 if (ret)
 740                         return ret;
 741         }
 742
 743         return 0;
 744 }
 745
 746 int uclass_post_probe_device(struct udevice *dev)
 747 {
 748         struct uclass_driver *uc_drv;
 749         int ret;
 750
 751         if (dev->parent) {
 752                 uc_drv = dev->parent->uclass->uc_drv;
 753                 if (uc_drv->child_post_probe) {
 754                         ret = uc_drv->child_post_probe(dev);
 755                         if (ret)
 756                                 return ret;
 757                 }
 758         }
 759
 760         uc_drv = dev->uclass->uc_drv;
 761         if (uc_drv->post_probe) {
 762                 ret = uc_drv->post_probe(dev);
 763                 if (ret)
 764                         return ret;
 765         }
 766
 767         return 0;
 768 }
 769
 770 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
 771 int uclass_pre_remove_device(struct udevice *dev)
 772 {
 773         struct uclass *uc;
 774         int ret;
 775
 776         uc = dev->uclass;
 777         if (uc->uc_drv->pre_remove) {
 778                 ret = uc->uc_drv->pre_remove(dev);
 779                 if (ret)
 780                         return ret;
 781         }
 782
 783         return 0;
 784 }
 785 #endif
 786
 787 UCLASS_DRIVER(nop) = {
 788         .id             = UCLASS_NOP,
 789         .name           = "nop",
 790 };