drivers/core/devres.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Masahiro Yamada <yamada.masahiro@socionext.com>
   4  *
   5  * Based on the original work in Linux by
   6  * Copyright (c) 2006  SUSE Linux Products GmbH
   7  * Copyright (c) 2006  Tejun Heo <teheo@suse.de>
   8  */
   9
  10 #define LOG_CATEGORY LOGC_DEVRES
  11
  12 #include <common.h>
  13 #include <linux/compat.h>
  14 #include <linux/kernel.h>
  15 #include <linux/list.h>
  16 #include <dm/device.h>
  17 #include <dm/devres.h>
  18 #include <dm/root.h>
  19 #include <dm/util.h>
  20
  21 /** enum devres_phase - Shows where resource was allocated
  22  *
  23  * DEVRES_PHASE_BIND: In the bind() method
  24  * DEVRES_PHASE_OFDATA: In the ofdata_to_platdata() method
  25  * DEVRES_PHASE_PROBE: In the probe() method
  26  */
  27 enum devres_phase {
  28         DEVRES_PHASE_BIND,
  29         DEVRES_PHASE_OFDATA,
  30         DEVRES_PHASE_PROBE,
  31 };
  32
  33 /**
  34  * struct devres - Bookkeeping info for managed device resource
  35  * @entry: List to associate this structure with a device
  36  * @release: Callback invoked when this resource is released
  37  * @probe: Show where this resource was allocated
  38  * @name: Name of release function
  39  * @size: Size of resource data
  40  * @data: Resource data
  41  */
  42 struct devres {
  43         struct list_head                entry;
  44         dr_release_t                    release;
  45         enum devres_phase               phase;
  46 #ifdef CONFIG_DEBUG_DEVRES
  47         const char                      *name;
  48         size_t                          size;
  49 #endif
  50         unsigned long long              data[];
  51 };
  52
  53 #ifdef CONFIG_DEBUG_DEVRES
  54 static void set_node_dbginfo(struct devres *dr, const char *name, size_t size)
  55 {
  56         dr->name = name;
  57         dr->size = size;
  58 }
  59
  60 static void devres_log(struct udevice *dev, struct devres *dr,
  61                        const char *op)
  62 {
  63         log_debug("%s: DEVRES %3s %p %s (%lu bytes)\n", dev->name, op, dr,
  64                   dr->name, (unsigned long)dr->size);
  65 }
  66 #else /* CONFIG_DEBUG_DEVRES */
  67 #define set_node_dbginfo(dr, n, s)      do {} while (0)
  68 #define devres_log(dev, dr, op)         do {} while (0)
  69 #endif
  70
  71 #if CONFIG_DEBUG_DEVRES
  72 void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
  73                      const char *name)
  74 #else
  75 void *_devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
  76 #endif
  77 {
  78         size_t tot_size = sizeof(struct devres) + size;
  79         struct devres *dr;
  80
  81         dr = kmalloc(tot_size, gfp);
  82         if (unlikely(!dr))
  83                 return NULL;
  84
  85         INIT_LIST_HEAD(&dr->entry);
  86         dr->release = release;
  87         set_node_dbginfo(dr, name, size);
  88
  89         return dr->data;
  90 }
  91
  92 void devres_free(void *res)
  93 {
  94         if (res) {
  95                 struct devres *dr = container_of(res, struct devres, data);
  96
  97                 assert_noisy(list_empty(&dr->entry));
  98                 kfree(dr);
  99         }
 100 }
 101
 102 void devres_add(struct udevice *dev, void *res)
 103 {
 104         struct devres *dr = container_of(res, struct devres, data);
 105
 106         devres_log(dev, dr, "ADD");
 107         assert_noisy(list_empty(&dr->entry));
 108         if (dev->flags & DM_FLAG_PLATDATA_VALID)
 109                 dr->phase = DEVRES_PHASE_PROBE;
 110         else if (dev->flags & DM_FLAG_BOUND)
 111                 dr->phase = DEVRES_PHASE_OFDATA;
 112         else
 113                 dr->phase = DEVRES_PHASE_BIND;
 114         list_add_tail(&dr->entry, &dev->devres_head);
 115 }
 116
 117 void *devres_find(struct udevice *dev, dr_release_t release,
 118                   dr_match_t match, void *match_data)
 119 {
 120         struct devres *dr;
 121
 122         list_for_each_entry_reverse(dr, &dev->devres_head, entry) {
 123                 if (dr->release != release)
 124                         continue;
 125                 if (match && !match(dev, dr->data, match_data))
 126                         continue;
 127                 return dr->data;
 128         }
 129
 130         return NULL;
 131 }
 132
 133 void *devres_get(struct udevice *dev, void *new_res,
 134                  dr_match_t match, void *match_data)
 135 {
 136         struct devres *new_dr = container_of(new_res, struct devres, data);
 137         void *res;
 138
 139         res = devres_find(dev, new_dr->release, match, match_data);
 140         if (!res) {
 141                 devres_add(dev, new_res);
 142                 res = new_res;
 143                 new_res = NULL;
 144         }
 145         devres_free(new_res);
 146
 147         return res;
 148 }
 149
 150 void *devres_remove(struct udevice *dev, dr_release_t release,
 151                     dr_match_t match, void *match_data)
 152 {
 153         void *res;
 154
 155         res = devres_find(dev, release, match, match_data);
 156         if (res) {
 157                 struct devres *dr = container_of(res, struct devres, data);
 158
 159                 list_del_init(&dr->entry);
 160                 devres_log(dev, dr, "REM");
 161         }
 162
 163         return res;
 164 }
 165
 166 int devres_destroy(struct udevice *dev, dr_release_t release,
 167                    dr_match_t match, void *match_data)
 168 {
 169         void *res;
 170
 171         res = devres_remove(dev, release, match, match_data);
 172         if (unlikely(!res))
 173                 return -ENOENT;
 174
 175         devres_free(res);
 176         return 0;
 177 }
 178
 179 int devres_release(struct udevice *dev, dr_release_t release,
 180                    dr_match_t match, void *match_data)
 181 {
 182         void *res;
 183
 184         res = devres_remove(dev, release, match, match_data);
 185         if (unlikely(!res))
 186                 return -ENOENT;
 187
 188         (*release)(dev, res);
 189         devres_free(res);
 190         return 0;
 191 }
 192
 193 static void release_nodes(struct udevice *dev, struct list_head *head,
 194                           bool probe_and_ofdata_only)
 195 {
 196         struct devres *dr, *tmp;
 197
 198         list_for_each_entry_safe_reverse(dr, tmp, head, entry)  {
 199                 if (probe_and_ofdata_only && dr->phase == DEVRES_PHASE_BIND)
 200                         break;
 201                 devres_log(dev, dr, "REL");
 202                 dr->release(dev, dr->data);
 203                 list_del(&dr->entry);
 204                 kfree(dr);
 205         }
 206 }
 207
 208 void devres_release_probe(struct udevice *dev)
 209 {
 210         release_nodes(dev, &dev->devres_head, true);
 211 }
 212
 213 void devres_release_all(struct udevice *dev)
 214 {
 215         release_nodes(dev, &dev->devres_head, false);
 216 }
 217
 218 #ifdef CONFIG_DEBUG_DEVRES
 219 static char *const devres_phase_name[] = {"BIND", "OFDATA", "PROBE"};
 220
 221 static void dump_resources(struct udevice *dev, int depth)
 222 {
 223         struct devres *dr;
 224         struct udevice *child;
 225
 226         printf("- %s\n", dev->name);
 227
 228         list_for_each_entry(dr, &dev->devres_head, entry)
 229                 printf("    %p (%lu byte) %s  %s\n", dr,
 230                        (unsigned long)dr->size, dr->name,
 231                        devres_phase_name[dr->phase]);
 232
 233         list_for_each_entry(child, &dev->child_head, sibling_node)
 234                 dump_resources(child, depth + 1);
 235 }
 236
 237 void dm_dump_devres(void)
 238 {
 239         struct udevice *root;
 240
 241         root = dm_root();
 242         if (root)
 243                 dump_resources(root, 0);
 244 }
 245
 246 void devres_get_stats(const struct udevice *dev, struct devres_stats *stats)
 247 {
 248         struct devres *dr;
 249
 250         stats->allocs = 0;
 251         stats->total_size = 0;
 252         list_for_each_entry(dr, &dev->devres_head, entry) {
 253                 stats->allocs++;
 254                 stats->total_size += dr->size;
 255         }
 256 }
 257
 258 #endif
 259
 260 /*
 261  * Managed kmalloc/kfree
 262  */
 263 static void devm_kmalloc_release(struct udevice *dev, void *res)
 264 {
 265         /* noop */
 266 }
 267
 268 static int devm_kmalloc_match(struct udevice *dev, void *res, void *data)
 269 {
 270         return res == data;
 271 }
 272
 273 void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp)
 274 {
 275         void *data;
 276
 277         data = _devres_alloc(devm_kmalloc_release, size, gfp);
 278         if (unlikely(!data))
 279                 return NULL;
 280
 281         devres_add(dev, data);
 282
 283         return data;
 284 }
 285
 286 void devm_kfree(struct udevice *dev, void *p)
 287 {
 288         int rc;
 289
 290         rc = devres_destroy(dev, devm_kmalloc_release, devm_kmalloc_match, p);
 291         assert_noisy(!rc);
 292 }