git.sur5r.net Git - u-boot/blob - drivers/core/uclass.c

   1 /*
   2  * Copyright (c) 2013 Google, Inc
   3  *
   4  * (C) Copyright 2012
   5  * Pavel Herrmann <morpheus.ibis@gmail.com>
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 #include <common.h>
  11 #include <errno.h>
  12 #include <malloc.h>
  13 #include <dm/device.h>
  14 #include <dm/device-internal.h>
  15 #include <dm/lists.h>
  16 #include <dm/uclass.h>
  17 #include <dm/uclass-internal.h>
  18 #include <dm/util.h>
  19
  20 DECLARE_GLOBAL_DATA_PTR;
  21
  22 struct uclass *uclass_find(enum uclass_id key)
  23 {
  24         struct uclass *uc;
  25
  26         if (!gd->dm_root)
  27                 return NULL;
  28         /*
  29          * TODO(sjg@chromium.org): Optimise this, perhaps moving the found
  30          * node to the start of the list, or creating a linear array mapping
  31          * id to node.
  32          */
  33         list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
  34                 if (uc->uc_drv->id == key)
  35                         return uc;
  36         }
  37
  38         return NULL;
  39 }
  40
  41 /**
  42  * uclass_add() - Create new uclass in list
  43  * @id: Id number to create
  44  * @ucp: Returns pointer to uclass, or NULL on error
  45  * @return 0 on success, -ve on error
  46  *
  47  * The new uclass is added to the list. There must be only one uclass for
  48  * each id.
  49  */
  50 static int uclass_add(enum uclass_id id, struct uclass **ucp)
  51 {
  52         struct uclass_driver *uc_drv;
  53         struct uclass *uc;
  54         int ret;
  55
  56         *ucp = NULL;
  57         uc_drv = lists_uclass_lookup(id);
  58         if (!uc_drv) {
  59                 debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
  60                       id);
  61                 return -ENOENT;
  62         }
  63         uc = calloc(1, sizeof(*uc));
  64         if (!uc)
  65                 return -ENOMEM;
  66         if (uc_drv->priv_auto_alloc_size) {
  67                 uc->priv = calloc(1, uc_drv->priv_auto_alloc_size);
  68                 if (!uc->priv) {
  69                         ret = -ENOMEM;
  70                         goto fail_mem;
  71                 }
  72         }
  73         uc->uc_drv = uc_drv;
  74         INIT_LIST_HEAD(&uc->sibling_node);
  75         INIT_LIST_HEAD(&uc->dev_head);
  76         list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);
  77
  78         if (uc_drv->init) {
  79                 ret = uc_drv->init(uc);
  80                 if (ret)
  81                         goto fail;
  82         }
  83
  84         *ucp = uc;
  85
  86         return 0;
  87 fail:
  88         if (uc_drv->priv_auto_alloc_size) {
  89                 free(uc->priv);
  90                 uc->priv = NULL;
  91         }
  92         list_del(&uc->sibling_node);
  93 fail_mem:
  94         free(uc);
  95
  96         return ret;
  97 }
  98
  99 int uclass_destroy(struct uclass *uc)
 100 {
 101         struct uclass_driver *uc_drv;
 102         struct udevice *dev;
 103         int ret;
 104
 105         /*
 106          * We cannot use list_for_each_entry_safe() here. If a device in this
 107          * uclass has a child device also in this uclass, it will be also be
 108          * unbound (by the recursion in the call to device_unbind() below).
 109          * We can loop until the list is empty.
 110          */
 111         while (!list_empty(&uc->dev_head)) {
 112                 dev = list_first_entry(&uc->dev_head, struct udevice,
 113                                        uclass_node);
 114                 ret = device_remove(dev);
 115                 if (ret)
 116                         return ret;
 117                 ret = device_unbind(dev);
 118                 if (ret)
 119                         return ret;
 120         }
 121
 122         uc_drv = uc->uc_drv;
 123         if (uc_drv->destroy)
 124                 uc_drv->destroy(uc);
 125         list_del(&uc->sibling_node);
 126         if (uc_drv->priv_auto_alloc_size)
 127                 free(uc->priv);
 128         free(uc);
 129
 130         return 0;
 131 }
 132
 133 int uclass_get(enum uclass_id id, struct uclass **ucp)
 134 {
 135         struct uclass *uc;
 136
 137         *ucp = NULL;
 138         uc = uclass_find(id);
 139         if (!uc)
 140                 return uclass_add(id, ucp);
 141         *ucp = uc;
 142
 143         return 0;
 144 }
 145
 146 int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
 147 {
 148         struct uclass *uc;
 149         struct udevice *dev;
 150         int ret;
 151
 152         *devp = NULL;
 153         ret = uclass_get(id, &uc);
 154         if (ret)
 155                 return ret;
 156         if (list_empty(&uc->dev_head))
 157                 return -ENODEV;
 158
 159         list_for_each_entry(dev, &uc->dev_head, uclass_node) {
 160                 if (!index--) {
 161                         *devp = dev;
 162                         return 0;
 163                 }
 164         }
 165
 166         return -ENODEV;
 167 }
 168
 169 int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
 170 {
 171         struct uclass *uc;
 172         int ret;
 173
 174         *devp = NULL;
 175         ret = uclass_get(id, &uc);
 176         if (ret)
 177                 return ret;
 178         if (list_empty(&uc->dev_head))
 179                 return 0;
 180
 181         *devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
 182
 183         return 0;
 184 }
 185
 186 int uclass_find_next_device(struct udevice **devp)
 187 {
 188         struct udevice *dev = *devp;
 189
 190         *devp = NULL;
 191         if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
 192                 return 0;
 193
 194         *devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
 195
 196         return 0;
 197 }
 198
 199 int uclass_find_device_by_name(enum uclass_id id, const char *name,
 200                                struct udevice **devp)
 201 {
 202         struct uclass *uc;
 203         struct udevice *dev;
 204         int ret;
 205
 206         *devp = NULL;
 207         if (!name)
 208                 return -EINVAL;
 209         ret = uclass_get(id, &uc);
 210         if (ret)
 211                 return ret;
 212
 213         list_for_each_entry(dev, &uc->dev_head, uclass_node) {
 214                 if (!strncmp(dev->name, name, strlen(name))) {
 215                         *devp = dev;
 216                         return 0;
 217                 }
 218         }
 219
 220         return -ENODEV;
 221 }
 222
 223 int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
 224                               bool find_req_seq, struct udevice **devp)
 225 {
 226         struct uclass *uc;
 227         struct udevice *dev;
 228         int ret;
 229
 230         *devp = NULL;
 231         debug("%s: %d %d\n", __func__, find_req_seq, seq_or_req_seq);
 232         if (seq_or_req_seq == -1)
 233                 return -ENODEV;
 234         ret = uclass_get(id, &uc);
 235         if (ret)
 236                 return ret;
 237
 238         list_for_each_entry(dev, &uc->dev_head, uclass_node) {
 239                 debug("   - %d %d\n", dev->req_seq, dev->seq);
 240                 if ((find_req_seq ? dev->req_seq : dev->seq) ==
 241                                 seq_or_req_seq) {
 242                         *devp = dev;
 243                         debug("   - found\n");
 244                         return 0;
 245                 }
 246         }
 247         debug("   - not found\n");
 248
 249         return -ENODEV;
 250 }
 251
 252 static int uclass_find_device_by_of_offset(enum uclass_id id, int node,
 253                                            struct udevice **devp)
 254 {
 255         struct uclass *uc;
 256         struct udevice *dev;
 257         int ret;
 258
 259         *devp = NULL;
 260         if (node < 0)
 261                 return -ENODEV;
 262         ret = uclass_get(id, &uc);
 263         if (ret)
 264                 return ret;
 265
 266         list_for_each_entry(dev, &uc->dev_head, uclass_node) {
 267                 if (dev->of_offset == node) {
 268                         *devp = dev;
 269                         return 0;
 270                 }
 271         }
 272
 273         return -ENODEV;
 274 }
 275
 276 int uclass_get_device_tail(struct udevice *dev, int ret,
 277                                   struct udevice **devp)
 278 {
 279         if (ret)
 280                 return ret;
 281
 282         assert(dev);
 283         ret = device_probe(dev);
 284         if (ret)
 285                 return ret;
 286
 287         *devp = dev;
 288
 289         return 0;
 290 }
 291
 292 int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
 293 {
 294         struct udevice *dev;
 295         int ret;
 296
 297         *devp = NULL;
 298         ret = uclass_find_device(id, index, &dev);
 299         return uclass_get_device_tail(dev, ret, devp);
 300 }
 301
 302 int uclass_get_device_by_name(enum uclass_id id, const char *name,
 303                               struct udevice **devp)
 304 {
 305         struct udevice *dev;
 306         int ret;
 307
 308         *devp = NULL;
 309         ret = uclass_find_device_by_name(id, name, &dev);
 310         return uclass_get_device_tail(dev, ret, devp);
 311 }
 312
 313 int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
 314 {
 315         struct udevice *dev;
 316         int ret;
 317
 318         *devp = NULL;
 319         ret = uclass_find_device_by_seq(id, seq, false, &dev);
 320         if (ret == -ENODEV) {
 321                 /*
 322                  * We didn't find it in probed devices. See if there is one
 323                  * that will request this seq if probed.
 324                  */
 325                 ret = uclass_find_device_by_seq(id, seq, true, &dev);
 326         }
 327         return uclass_get_device_tail(dev, ret, devp);
 328 }
 329
 330 int uclass_get_device_by_of_offset(enum uclass_id id, int node,
 331                                    struct udevice **devp)
 332 {
 333         struct udevice *dev;
 334         int ret;
 335
 336         *devp = NULL;
 337         ret = uclass_find_device_by_of_offset(id, node, &dev);
 338         return uclass_get_device_tail(dev, ret, devp);
 339 }
 340
 341 int uclass_first_device(enum uclass_id id, struct udevice **devp)
 342 {
 343         struct udevice *dev;
 344         int ret;
 345
 346         *devp = NULL;
 347         ret = uclass_find_first_device(id, &dev);
 348         if (!dev)
 349                 return 0;
 350         return uclass_get_device_tail(dev, ret, devp);
 351 }
 352
 353 int uclass_next_device(struct udevice **devp)
 354 {
 355         struct udevice *dev = *devp;
 356         int ret;
 357
 358         *devp = NULL;
 359         ret = uclass_find_next_device(&dev);
 360         if (!dev)
 361                 return 0;
 362         return uclass_get_device_tail(dev, ret, devp);
 363 }
 364
 365 int uclass_bind_device(struct udevice *dev)
 366 {
 367         struct uclass *uc;
 368         int ret;
 369
 370         uc = dev->uclass;
 371         list_add_tail(&dev->uclass_node, &uc->dev_head);
 372
 373         if (dev->parent) {
 374                 struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;
 375
 376                 if (uc_drv->child_post_bind) {
 377                         ret = uc_drv->child_post_bind(dev);
 378                         if (ret)
 379                                 goto err;
 380                 }
 381         }
 382         if (uc->uc_drv->post_bind) {
 383                 ret = uc->uc_drv->post_bind(dev);
 384                 if (ret)
 385                         goto err;
 386         }
 387
 388         return 0;
 389 err:
 390         /* There is no need to undo the parent's post_bind call */
 391         list_del(&dev->uclass_node);
 392
 393         return ret;
 394 }
 395
 396 #ifdef CONFIG_DM_DEVICE_REMOVE
 397 int uclass_unbind_device(struct udevice *dev)
 398 {
 399         struct uclass *uc;
 400         int ret;
 401
 402         uc = dev->uclass;
 403         if (uc->uc_drv->pre_unbind) {
 404                 ret = uc->uc_drv->pre_unbind(dev);
 405                 if (ret)
 406                         return ret;
 407         }
 408
 409         list_del(&dev->uclass_node);
 410         return 0;
 411 }
 412 #endif
 413
 414 int uclass_resolve_seq(struct udevice *dev)
 415 {
 416         struct udevice *dup;
 417         int seq;
 418         int ret;
 419
 420         assert(dev->seq == -1);
 421         ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, dev->req_seq,
 422                                         false, &dup);
 423         if (!ret) {
 424                 dm_warn("Device '%s': seq %d is in use by '%s'\n",
 425                         dev->name, dev->req_seq, dup->name);
 426         } else if (ret == -ENODEV) {
 427                 /* Our requested sequence number is available */
 428                 if (dev->req_seq != -1)
 429                         return dev->req_seq;
 430         } else {
 431                 return ret;
 432         }
 433
 434         for (seq = 0; seq < DM_MAX_SEQ; seq++) {
 435                 ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, seq,
 436                                                 false, &dup);
 437                 if (ret == -ENODEV)
 438                         break;
 439                 if (ret)
 440                         return ret;
 441         }
 442         return seq;
 443 }
 444
 445 int uclass_pre_probe_device(struct udevice *dev)
 446 {
 447         struct uclass_driver *uc_drv;
 448         int ret;
 449
 450         uc_drv = dev->uclass->uc_drv;
 451         if (uc_drv->pre_probe) {
 452                 ret = uc_drv->pre_probe(dev);
 453                 if (ret)
 454                         return ret;
 455         }
 456
 457         if (!dev->parent)
 458                 return 0;
 459         uc_drv = dev->parent->uclass->uc_drv;
 460         if (uc_drv->child_pre_probe)
 461                 return uc_drv->child_pre_probe(dev);
 462
 463         return 0;
 464 }
 465
 466 int uclass_post_probe_device(struct udevice *dev)
 467 {
 468         struct uclass_driver *uc_drv = dev->uclass->uc_drv;
 469
 470         if (uc_drv->post_probe)
 471                 return uc_drv->post_probe(dev);
 472
 473         return 0;
 474 }
 475
 476 #ifdef CONFIG_DM_DEVICE_REMOVE
 477 int uclass_pre_remove_device(struct udevice *dev)
 478 {
 479         struct uclass_driver *uc_drv;
 480         struct uclass *uc;
 481         int ret;
 482
 483         uc = dev->uclass;
 484         uc_drv = uc->uc_drv;
 485         if (uc->uc_drv->pre_remove) {
 486                 ret = uc->uc_drv->pre_remove(dev);
 487                 if (ret)
 488                         return ret;
 489         }
 490         if (uc_drv->per_device_auto_alloc_size) {
 491                 free(dev->uclass_priv);
 492                 dev->uclass_priv = NULL;
 493         }
 494         dev->seq = -1;
 495
 496         return 0;
 497 }
 498 #endif