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         /*
  27          * TODO(sjg@chromium.org): Optimise this, perhaps moving the found
  28          * node to the start of the list, or creating a linear array mapping
  29          * id to node.
  30          */
  31         list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
  32                 if (uc->uc_drv->id == key)
  33                         return uc;
  34         }
  35
  36         return NULL;
  37 }
  38
  39 /**
  40  * uclass_add() - Create new uclass in list
  41  * @id: Id number to create
  42  * @ucp: Returns pointer to uclass, or NULL on error
  43  * @return 0 on success, -ve on error
  44  *
  45  * The new uclass is added to the list. There must be only one uclass for
  46  * each id.
  47  */
  48 static int uclass_add(enum uclass_id id, struct uclass **ucp)
  49 {
  50         struct uclass_driver *uc_drv;
  51         struct uclass *uc;
  52         int ret;
  53
  54         *ucp = NULL;
  55         uc_drv = lists_uclass_lookup(id);
  56         if (!uc_drv) {
  57                 dm_warn("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
  58                         id);
  59                 return -ENOENT;
  60         }
  61         if (uc_drv->ops) {
  62                 dm_warn("No ops for uclass id %d\n", id);
  63                 return -EINVAL;
  64         }
  65         uc = calloc(1, sizeof(*uc));
  66         if (!uc)
  67                 return -ENOMEM;
  68         if (uc_drv->priv_auto_alloc_size) {
  69                 uc->priv = calloc(1, uc_drv->priv_auto_alloc_size);
  70                 if (!uc->priv) {
  71                         ret = -ENOMEM;
  72                         goto fail_mem;
  73                 }
  74         }
  75         uc->uc_drv = uc_drv;
  76         INIT_LIST_HEAD(&uc->sibling_node);
  77         INIT_LIST_HEAD(&uc->dev_head);
  78         list_add(&uc->sibling_node, &gd->uclass_root);
  79
  80         if (uc_drv->init) {
  81                 ret = uc_drv->init(uc);
  82                 if (ret)
  83                         goto fail;
  84         }
  85
  86         *ucp = uc;
  87
  88         return 0;
  89 fail:
  90         if (uc_drv->priv_auto_alloc_size) {
  91                 free(uc->priv);
  92                 uc->priv = NULL;
  93         }
  94         list_del(&uc->sibling_node);
  95 fail_mem:
  96         free(uc);
  97
  98         return ret;
  99 }
 100
 101 int uclass_destroy(struct uclass *uc)
 102 {
 103         struct uclass_driver *uc_drv;
 104         struct udevice *dev, *tmp;
 105         int ret;
 106
 107         list_for_each_entry_safe(dev, tmp, &uc->dev_head, uclass_node) {
 108                 ret = device_remove(dev);
 109                 if (ret)
 110                         return ret;
 111                 ret = device_unbind(dev);
 112                 if (ret)
 113                         return ret;
 114         }
 115
 116         uc_drv = uc->uc_drv;
 117         if (uc_drv->destroy)
 118                 uc_drv->destroy(uc);
 119         list_del(&uc->sibling_node);
 120         if (uc_drv->priv_auto_alloc_size)
 121                 free(uc->priv);
 122         free(uc);
 123
 124         return 0;
 125 }
 126
 127 int uclass_get(enum uclass_id id, struct uclass **ucp)
 128 {
 129         struct uclass *uc;
 130
 131         *ucp = NULL;
 132         uc = uclass_find(id);
 133         if (!uc)
 134                 return uclass_add(id, ucp);
 135         *ucp = uc;
 136
 137         return 0;
 138 }
 139
 140 int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
 141 {
 142         struct uclass *uc;
 143         struct udevice *dev;
 144         int ret;
 145
 146         *devp = NULL;
 147         ret = uclass_get(id, &uc);
 148         if (ret)
 149                 return ret;
 150
 151         list_for_each_entry(dev, &uc->dev_head, uclass_node) {
 152                 if (!index--) {
 153                         *devp = dev;
 154                         return 0;
 155                 }
 156         }
 157
 158         return -ENODEV;
 159 }
 160
 161 int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
 162 {
 163         struct udevice *dev;
 164         int ret;
 165
 166         *devp = NULL;
 167         ret = uclass_find_device(id, index, &dev);
 168         if (ret)
 169                 return ret;
 170
 171         ret = device_probe(dev);
 172         if (ret)
 173                 return ret;
 174
 175         *devp = dev;
 176
 177         return 0;
 178 }
 179
 180 int uclass_first_device(enum uclass_id id, struct udevice **devp)
 181 {
 182         struct uclass *uc;
 183         struct udevice *dev;
 184         int ret;
 185
 186         *devp = NULL;
 187         ret = uclass_get(id, &uc);
 188         if (ret)
 189                 return ret;
 190         if (list_empty(&uc->dev_head))
 191                 return 0;
 192
 193         dev = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
 194         ret = device_probe(dev);
 195         if (ret)
 196                 return ret;
 197         *devp = dev;
 198
 199         return 0;
 200 }
 201
 202 int uclass_next_device(struct udevice **devp)
 203 {
 204         struct udevice *dev = *devp;
 205         int ret;
 206
 207         *devp = NULL;
 208         if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
 209                 return 0;
 210
 211         dev = list_entry(dev->uclass_node.next, struct udevice,
 212                          uclass_node);
 213         ret = device_probe(dev);
 214         if (ret)
 215                 return ret;
 216         *devp = dev;
 217
 218         return 0;
 219 }
 220
 221 int uclass_bind_device(struct udevice *dev)
 222 {
 223         struct uclass *uc;
 224         int ret;
 225
 226         uc = dev->uclass;
 227
 228         list_add_tail(&dev->uclass_node, &uc->dev_head);
 229
 230         if (uc->uc_drv->post_bind) {
 231                 ret = uc->uc_drv->post_bind(dev);
 232                 if (ret) {
 233                         list_del(&dev->uclass_node);
 234                         return ret;
 235                 }
 236         }
 237
 238         return 0;
 239 }
 240
 241 int uclass_unbind_device(struct udevice *dev)
 242 {
 243         struct uclass *uc;
 244         int ret;
 245
 246         uc = dev->uclass;
 247         if (uc->uc_drv->pre_unbind) {
 248                 ret = uc->uc_drv->pre_unbind(dev);
 249                 if (ret)
 250                         return ret;
 251         }
 252
 253         list_del(&dev->uclass_node);
 254         return 0;
 255 }
 256
 257 int uclass_post_probe_device(struct udevice *dev)
 258 {
 259         struct uclass_driver *uc_drv = dev->uclass->uc_drv;
 260
 261         if (uc_drv->post_probe)
 262                 return uc_drv->post_probe(dev);
 263
 264         return 0;
 265 }
 266
 267 int uclass_pre_remove_device(struct udevice *dev)
 268 {
 269         struct uclass_driver *uc_drv;
 270         struct uclass *uc;
 271         int ret;
 272
 273         uc = dev->uclass;
 274         uc_drv = uc->uc_drv;
 275         if (uc->uc_drv->pre_remove) {
 276                 ret = uc->uc_drv->pre_remove(dev);
 277                 if (ret)
 278                         return ret;
 279         }
 280         if (uc_drv->per_device_auto_alloc_size) {
 281                 free(dev->uclass_priv);
 282                 dev->uclass_priv = NULL;
 283         }
 284
 285         return 0;
 286 }