drivers/clk/clkdev.c

   1 /*
   2  * drivers/clk/clkdev.c
   3  *
   4  *  Copyright (C) 2008 Russell King.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * Helper for the clk API to assist looking up a struct clk.
  11  */
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/device.h>
  15 #include <linux/list.h>
  16 #include <linux/errno.h>
  17 #include <linux/err.h>
  18 #include <linux/string.h>
  19 #include <linux/mutex.h>
  20 #include <linux/clk.h>
  21 #include <linux/clkdev.h>
  22 #include <linux/clk-provider.h>
  23 #include <linux/of.h>
  24
  25 #include "clk.h"
  26
  27 static LIST_HEAD(clocks);
  28 static DEFINE_MUTEX(clocks_mutex);
  29
  30 /*
  31  * Find the correct struct clk for the device and connection ID.
  32  * We do slightly fuzzy matching here:
  33  *  An entry with a NULL ID is assumed to be a wildcard.
  34  *  If an entry has a device ID, it must match
  35  *  If an entry has a connection ID, it must match
  36  * Then we take the most specific entry - with the following
  37  * order of precedence: dev+con > dev only > con only.
  38  */
  39 static struct clk_lookup *clk_find(const char *dev_id, const char *con_id)
  40 {
  41         struct clk_lookup *p, *cl = NULL;
  42         int match, best_found = 0, best_possible = 0;
  43
  44         if (dev_id)
  45                 best_possible += 2;
  46         if (con_id)
  47                 best_possible += 1;
  48
  49         lockdep_assert_held(&clocks_mutex);
  50
  51         list_for_each_entry(p, &clocks, node) {
  52                 match = 0;
  53                 if (p->dev_id) {
  54                         if (!dev_id || strcmp(p->dev_id, dev_id))
  55                                 continue;
  56                         match += 2;
  57                 }
  58                 if (p->con_id) {
  59                         if (!con_id || strcmp(p->con_id, con_id))
  60                                 continue;
  61                         match += 1;
  62                 }
  63
  64                 if (match > best_found) {
  65                         cl = p;
  66                         if (match != best_possible)
  67                                 best_found = match;
  68                         else
  69                                 break;
  70                 }
  71         }
  72         return cl;
  73 }
  74
  75 struct clk_hw *clk_find_hw(const char *dev_id, const char *con_id)
  76 {
  77         struct clk_lookup *cl;
  78         struct clk_hw *hw = ERR_PTR(-ENOENT);
  79
  80         mutex_lock(&clocks_mutex);
  81         cl = clk_find(dev_id, con_id);
  82         if (cl)
  83                 hw = cl->clk_hw;
  84         mutex_unlock(&clocks_mutex);
  85
  86         return hw;
  87 }
  88
  89 static struct clk *__clk_get_sys(struct device *dev, const char *dev_id,
  90                                  const char *con_id)
  91 {
  92         struct clk_hw *hw = clk_find_hw(dev_id, con_id);
  93
  94         return clk_hw_create_clk(dev, hw, dev_id, con_id);
  95 }
  96
  97 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
  98 {
  99         return __clk_get_sys(NULL, dev_id, con_id);
 100 }
 101 EXPORT_SYMBOL(clk_get_sys);
 102
 103 struct clk *clk_get(struct device *dev, const char *con_id)
 104 {
 105         const char *dev_id = dev ? dev_name(dev) : NULL;
 106         struct clk_hw *hw;
 107
 108         if (dev && dev->of_node) {
 109                 hw = of_clk_get_hw(dev->of_node, 0, con_id);
 110                 if (!IS_ERR(hw) || PTR_ERR(hw) == -EPROBE_DEFER)
 111                         return clk_hw_create_clk(dev, hw, dev_id, con_id);
 112         }
 113
 114         return __clk_get_sys(dev, dev_id, con_id);
 115 }
 116 EXPORT_SYMBOL(clk_get);
 117
 118 void clk_put(struct clk *clk)
 119 {
 120         __clk_put(clk);
 121 }
 122 EXPORT_SYMBOL(clk_put);
 123
 124 static void __clkdev_add(struct clk_lookup *cl)
 125 {
 126         mutex_lock(&clocks_mutex);
 127         list_add_tail(&cl->node, &clocks);
 128         mutex_unlock(&clocks_mutex);
 129 }
 130
 131 void clkdev_add(struct clk_lookup *cl)
 132 {
 133         if (!cl->clk_hw)
 134                 cl->clk_hw = __clk_get_hw(cl->clk);
 135         __clkdev_add(cl);
 136 }
 137 EXPORT_SYMBOL(clkdev_add);
 138
 139 void clkdev_add_table(struct clk_lookup *cl, size_t num)
 140 {
 141         mutex_lock(&clocks_mutex);
 142         while (num--) {
 143                 cl->clk_hw = __clk_get_hw(cl->clk);
 144                 list_add_tail(&cl->node, &clocks);
 145                 cl++;
 146         }
 147         mutex_unlock(&clocks_mutex);
 148 }
 149
 150 #define MAX_DEV_ID      20
 151 #define MAX_CON_ID      16
 152
 153 struct clk_lookup_alloc {
 154         struct clk_lookup cl;
 155         char    dev_id[MAX_DEV_ID];
 156         char    con_id[MAX_CON_ID];
 157 };
 158
 159 static struct clk_lookup * __ref
 160 vclkdev_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
 161         va_list ap)
 162 {
 163         struct clk_lookup_alloc *cla;
 164
 165         cla = kzalloc(sizeof(*cla), GFP_KERNEL);
 166         if (!cla)
 167                 return NULL;
 168
 169         cla->cl.clk_hw = hw;
 170         if (con_id) {
 171                 strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
 172                 cla->cl.con_id = cla->con_id;
 173         }
 174
 175         if (dev_fmt) {
 176                 vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
 177                 cla->cl.dev_id = cla->dev_id;
 178         }
 179
 180         return &cla->cl;
 181 }
 182
 183 static struct clk_lookup *
 184 vclkdev_create(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
 185         va_list ap)
 186 {
 187         struct clk_lookup *cl;
 188
 189         cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
 190         if (cl)
 191                 __clkdev_add(cl);
 192
 193         return cl;
 194 }
 195
 196 struct clk_lookup * __ref
 197 clkdev_alloc(struct clk *clk, const char *con_id, const char *dev_fmt, ...)
 198 {
 199         struct clk_lookup *cl;
 200         va_list ap;
 201
 202         va_start(ap, dev_fmt);
 203         cl = vclkdev_alloc(__clk_get_hw(clk), con_id, dev_fmt, ap);
 204         va_end(ap);
 205
 206         return cl;
 207 }
 208 EXPORT_SYMBOL(clkdev_alloc);
 209
 210 struct clk_lookup *
 211 clkdev_hw_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt, ...)
 212 {
 213         struct clk_lookup *cl;
 214         va_list ap;
 215
 216         va_start(ap, dev_fmt);
 217         cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
 218         va_end(ap);
 219
 220         return cl;
 221 }
 222 EXPORT_SYMBOL(clkdev_hw_alloc);
 223
 224 /**
 225  * clkdev_create - allocate and add a clkdev lookup structure
 226  * @clk: struct clk to associate with all clk_lookups
 227  * @con_id: connection ID string on device
 228  * @dev_fmt: format string describing device name
 229  *
 230  * Returns a clk_lookup structure, which can be later unregistered and
 231  * freed.
 232  */
 233 struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
 234         const char *dev_fmt, ...)
 235 {
 236         struct clk_lookup *cl;
 237         va_list ap;
 238
 239         va_start(ap, dev_fmt);
 240         cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);
 241         va_end(ap);
 242
 243         return cl;
 244 }
 245 EXPORT_SYMBOL_GPL(clkdev_create);
 246
 247 /**
 248  * clkdev_hw_create - allocate and add a clkdev lookup structure
 249  * @hw: struct clk_hw to associate with all clk_lookups
 250  * @con_id: connection ID string on device
 251  * @dev_fmt: format string describing device name
 252  *
 253  * Returns a clk_lookup structure, which can be later unregistered and
 254  * freed.
 255  */
 256 struct clk_lookup *clkdev_hw_create(struct clk_hw *hw, const char *con_id,
 257         const char *dev_fmt, ...)
 258 {
 259         struct clk_lookup *cl;
 260         va_list ap;
 261
 262         va_start(ap, dev_fmt);
 263         cl = vclkdev_create(hw, con_id, dev_fmt, ap);
 264         va_end(ap);
 265
 266         return cl;
 267 }
 268 EXPORT_SYMBOL_GPL(clkdev_hw_create);
 269
 270 int clk_add_alias(const char *alias, const char *alias_dev_name,
 271         const char *con_id, struct device *dev)
 272 {
 273         struct clk *r = clk_get(dev, con_id);
 274         struct clk_lookup *l;
 275
 276         if (IS_ERR(r))
 277                 return PTR_ERR(r);
 278
 279         l = clkdev_create(r, alias, alias_dev_name ? "%s" : NULL,
 280                           alias_dev_name);
 281         clk_put(r);
 282
 283         return l ? 0 : -ENODEV;
 284 }
 285 EXPORT_SYMBOL(clk_add_alias);
 286
 287 /*
 288  * clkdev_drop - remove a clock dynamically allocated
 289  */
 290 void clkdev_drop(struct clk_lookup *cl)
 291 {
 292         mutex_lock(&clocks_mutex);
 293         list_del(&cl->node);
 294         mutex_unlock(&clocks_mutex);
 295         kfree(cl);
 296 }
 297 EXPORT_SYMBOL(clkdev_drop);
 298
 299 static struct clk_lookup *__clk_register_clkdev(struct clk_hw *hw,
 300                                                 const char *con_id,
 301                                                 const char *dev_id, ...)
 302 {
 303         struct clk_lookup *cl;
 304         va_list ap;
 305
 306         va_start(ap, dev_id);
 307         cl = vclkdev_create(hw, con_id, dev_id, ap);
 308         va_end(ap);
 309
 310         return cl;
 311 }
 312
 313 static int do_clk_register_clkdev(struct clk_hw *hw,
 314         struct clk_lookup **cl, const char *con_id, const char *dev_id)
 315 {
 316         if (IS_ERR(hw))
 317                 return PTR_ERR(hw);
 318         /*
 319          * Since dev_id can be NULL, and NULL is handled specially, we must
 320          * pass it as either a NULL format string, or with "%s".
 321          */
 322         if (dev_id)
 323                 *cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);
 324         else
 325                 *cl = __clk_register_clkdev(hw, con_id, NULL);
 326
 327         return *cl ? 0 : -ENOMEM;
 328 }
 329
 330 /**
 331  * clk_register_clkdev - register one clock lookup for a struct clk
 332  * @clk: struct clk to associate with all clk_lookups
 333  * @con_id: connection ID string on device
 334  * @dev_id: string describing device name
 335  *
 336  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 337  * clkdev.
 338  *
 339  * To make things easier for mass registration, we detect error clks
 340  * from a previous clk_register() call, and return the error code for
 341  * those.  This is to permit this function to be called immediately
 342  * after clk_register().
 343  */
 344 int clk_register_clkdev(struct clk *clk, const char *con_id,
 345         const char *dev_id)
 346 {
 347         struct clk_lookup *cl;
 348
 349         if (IS_ERR(clk))
 350                 return PTR_ERR(clk);
 351
 352         return do_clk_register_clkdev(__clk_get_hw(clk), &cl, con_id,
 353                                               dev_id);
 354 }
 355 EXPORT_SYMBOL(clk_register_clkdev);
 356
 357 /**
 358  * clk_hw_register_clkdev - register one clock lookup for a struct clk_hw
 359  * @hw: struct clk_hw to associate with all clk_lookups
 360  * @con_id: connection ID string on device
 361  * @dev_id: format string describing device name
 362  *
 363  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 364  * clkdev.
 365  *
 366  * To make things easier for mass registration, we detect error clk_hws
 367  * from a previous clk_hw_register_*() call, and return the error code for
 368  * those.  This is to permit this function to be called immediately
 369  * after clk_hw_register_*().
 370  */
 371 int clk_hw_register_clkdev(struct clk_hw *hw, const char *con_id,
 372         const char *dev_id)
 373 {
 374         struct clk_lookup *cl;
 375
 376         return do_clk_register_clkdev(hw, &cl, con_id, dev_id);
 377 }
 378 EXPORT_SYMBOL(clk_hw_register_clkdev);
 379
 380 static void devm_clkdev_release(struct device *dev, void *res)
 381 {
 382         clkdev_drop(*(struct clk_lookup **)res);
 383 }
 384
 385 static int devm_clk_match_clkdev(struct device *dev, void *res, void *data)
 386 {
 387         struct clk_lookup **l = res;
 388
 389         return *l == data;
 390 }
 391
 392 /**
 393  * devm_clk_release_clkdev - Resource managed clkdev lookup release
 394  * @dev: device this lookup is bound
 395  * @con_id: connection ID string on device
 396  * @dev_id: format string describing device name
 397  *
 398  * Drop the clkdev lookup created with devm_clk_hw_register_clkdev.
 399  * Normally this function will not need to be called and the resource
 400  * management code will ensure that the resource is freed.
 401  */
 402 void devm_clk_release_clkdev(struct device *dev, const char *con_id,
 403                              const char *dev_id)
 404 {
 405         struct clk_lookup *cl;
 406         int rval;
 407
 408         mutex_lock(&clocks_mutex);
 409         cl = clk_find(dev_id, con_id);
 410         mutex_unlock(&clocks_mutex);
 411
 412         WARN_ON(!cl);
 413         rval = devres_release(dev, devm_clkdev_release,
 414                               devm_clk_match_clkdev, cl);
 415         WARN_ON(rval);
 416 }
 417 EXPORT_SYMBOL(devm_clk_release_clkdev);
 418
 419 /**
 420  * devm_clk_hw_register_clkdev - managed clk lookup registration for clk_hw
 421  * @dev: device this lookup is bound
 422  * @hw: struct clk_hw to associate with all clk_lookups
 423  * @con_id: connection ID string on device
 424  * @dev_id: format string describing device name
 425  *
 426  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 427  * clkdev.
 428  *
 429  * To make things easier for mass registration, we detect error clk_hws
 430  * from a previous clk_hw_register_*() call, and return the error code for
 431  * those.  This is to permit this function to be called immediately
 432  * after clk_hw_register_*().
 433  */
 434 int devm_clk_hw_register_clkdev(struct device *dev, struct clk_hw *hw,
 435                                 const char *con_id, const char *dev_id)
 436 {
 437         int rval = -ENOMEM;
 438         struct clk_lookup **cl;
 439
 440         cl = devres_alloc(devm_clkdev_release, sizeof(*cl), GFP_KERNEL);
 441         if (cl) {
 442                 rval = do_clk_register_clkdev(hw, cl, con_id, dev_id);
 443                 if (!rval)
 444                         devres_add(dev, cl);
 445                 else
 446                         devres_free(cl);
 447         }
 448         return rval;
 449 }
 450 EXPORT_SYMBOL(devm_clk_hw_register_clkdev);