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 static struct clk *__clk_get_sys(struct device *dev, const char *dev_id,
  76                                  const char *con_id)
  77 {
  78         struct clk_lookup *cl;
  79         struct clk *clk = NULL;
  80
  81         mutex_lock(&clocks_mutex);
  82
  83         cl = clk_find(dev_id, con_id);
  84         if (!cl)
  85                 goto out;
  86
  87         clk = clk_hw_create_clk(dev, cl->clk_hw, dev_id, con_id);
  88         if (IS_ERR(clk))
  89                 cl = NULL;
  90 out:
  91         mutex_unlock(&clocks_mutex);
  92
  93         return cl ? clk : ERR_PTR(-ENOENT);
  94 }
  95
  96 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
  97 {
  98         return __clk_get_sys(NULL, dev_id, con_id);
  99 }
 100 EXPORT_SYMBOL(clk_get_sys);
 101
 102 struct clk *clk_get(struct device *dev, const char *con_id)
 103 {
 104         const char *dev_id = dev ? dev_name(dev) : NULL;
 105         struct clk_hw *hw;
 106
 107         if (dev && dev->of_node) {
 108                 hw = of_clk_get_hw(dev->of_node, 0, con_id);
 109                 if (!IS_ERR(hw) || PTR_ERR(hw) == -EPROBE_DEFER)
 110                         return clk_hw_create_clk(dev, hw, dev_id, con_id);
 111         }
 112
 113         return __clk_get_sys(dev, dev_id, con_id);
 114 }
 115 EXPORT_SYMBOL(clk_get);
 116
 117 void clk_put(struct clk *clk)
 118 {
 119         __clk_put(clk);
 120 }
 121 EXPORT_SYMBOL(clk_put);
 122
 123 static void __clkdev_add(struct clk_lookup *cl)
 124 {
 125         mutex_lock(&clocks_mutex);
 126         list_add_tail(&cl->node, &clocks);
 127         mutex_unlock(&clocks_mutex);
 128 }
 129
 130 void clkdev_add(struct clk_lookup *cl)
 131 {
 132         if (!cl->clk_hw)
 133                 cl->clk_hw = __clk_get_hw(cl->clk);
 134         __clkdev_add(cl);
 135 }
 136 EXPORT_SYMBOL(clkdev_add);
 137
 138 void clkdev_add_table(struct clk_lookup *cl, size_t num)
 139 {
 140         mutex_lock(&clocks_mutex);
 141         while (num--) {
 142                 cl->clk_hw = __clk_get_hw(cl->clk);
 143                 list_add_tail(&cl->node, &clocks);
 144                 cl++;
 145         }
 146         mutex_unlock(&clocks_mutex);
 147 }
 148
 149 #define MAX_DEV_ID      20
 150 #define MAX_CON_ID      16
 151
 152 struct clk_lookup_alloc {
 153         struct clk_lookup cl;
 154         char    dev_id[MAX_DEV_ID];
 155         char    con_id[MAX_CON_ID];
 156 };
 157
 158 static struct clk_lookup * __ref
 159 vclkdev_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
 160         va_list ap)
 161 {
 162         struct clk_lookup_alloc *cla;
 163
 164         cla = kzalloc(sizeof(*cla), GFP_KERNEL);
 165         if (!cla)
 166                 return NULL;
 167
 168         cla->cl.clk_hw = hw;
 169         if (con_id) {
 170                 strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
 171                 cla->cl.con_id = cla->con_id;
 172         }
 173
 174         if (dev_fmt) {
 175                 vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
 176                 cla->cl.dev_id = cla->dev_id;
 177         }
 178
 179         return &cla->cl;
 180 }
 181
 182 static struct clk_lookup *
 183 vclkdev_create(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
 184         va_list ap)
 185 {
 186         struct clk_lookup *cl;
 187
 188         cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
 189         if (cl)
 190                 __clkdev_add(cl);
 191
 192         return cl;
 193 }
 194
 195 struct clk_lookup * __ref
 196 clkdev_alloc(struct clk *clk, const char *con_id, const char *dev_fmt, ...)
 197 {
 198         struct clk_lookup *cl;
 199         va_list ap;
 200
 201         va_start(ap, dev_fmt);
 202         cl = vclkdev_alloc(__clk_get_hw(clk), con_id, dev_fmt, ap);
 203         va_end(ap);
 204
 205         return cl;
 206 }
 207 EXPORT_SYMBOL(clkdev_alloc);
 208
 209 struct clk_lookup *
 210 clkdev_hw_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt, ...)
 211 {
 212         struct clk_lookup *cl;
 213         va_list ap;
 214
 215         va_start(ap, dev_fmt);
 216         cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
 217         va_end(ap);
 218
 219         return cl;
 220 }
 221 EXPORT_SYMBOL(clkdev_hw_alloc);
 222
 223 /**
 224  * clkdev_create - allocate and add a clkdev lookup structure
 225  * @clk: struct clk to associate with all clk_lookups
 226  * @con_id: connection ID string on device
 227  * @dev_fmt: format string describing device name
 228  *
 229  * Returns a clk_lookup structure, which can be later unregistered and
 230  * freed.
 231  */
 232 struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
 233         const char *dev_fmt, ...)
 234 {
 235         struct clk_lookup *cl;
 236         va_list ap;
 237
 238         va_start(ap, dev_fmt);
 239         cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);
 240         va_end(ap);
 241
 242         return cl;
 243 }
 244 EXPORT_SYMBOL_GPL(clkdev_create);
 245
 246 /**
 247  * clkdev_hw_create - allocate and add a clkdev lookup structure
 248  * @hw: struct clk_hw to associate with all clk_lookups
 249  * @con_id: connection ID string on device
 250  * @dev_fmt: format string describing device name
 251  *
 252  * Returns a clk_lookup structure, which can be later unregistered and
 253  * freed.
 254  */
 255 struct clk_lookup *clkdev_hw_create(struct clk_hw *hw, const char *con_id,
 256         const char *dev_fmt, ...)
 257 {
 258         struct clk_lookup *cl;
 259         va_list ap;
 260
 261         va_start(ap, dev_fmt);
 262         cl = vclkdev_create(hw, con_id, dev_fmt, ap);
 263         va_end(ap);
 264
 265         return cl;
 266 }
 267 EXPORT_SYMBOL_GPL(clkdev_hw_create);
 268
 269 int clk_add_alias(const char *alias, const char *alias_dev_name,
 270         const char *con_id, struct device *dev)
 271 {
 272         struct clk *r = clk_get(dev, con_id);
 273         struct clk_lookup *l;
 274
 275         if (IS_ERR(r))
 276                 return PTR_ERR(r);
 277
 278         l = clkdev_create(r, alias, alias_dev_name ? "%s" : NULL,
 279                           alias_dev_name);
 280         clk_put(r);
 281
 282         return l ? 0 : -ENODEV;
 283 }
 284 EXPORT_SYMBOL(clk_add_alias);
 285
 286 /*
 287  * clkdev_drop - remove a clock dynamically allocated
 288  */
 289 void clkdev_drop(struct clk_lookup *cl)
 290 {
 291         mutex_lock(&clocks_mutex);
 292         list_del(&cl->node);
 293         mutex_unlock(&clocks_mutex);
 294         kfree(cl);
 295 }
 296 EXPORT_SYMBOL(clkdev_drop);
 297
 298 static struct clk_lookup *__clk_register_clkdev(struct clk_hw *hw,
 299                                                 const char *con_id,
 300                                                 const char *dev_id, ...)
 301 {
 302         struct clk_lookup *cl;
 303         va_list ap;
 304
 305         va_start(ap, dev_id);
 306         cl = vclkdev_create(hw, con_id, dev_id, ap);
 307         va_end(ap);
 308
 309         return cl;
 310 }
 311
 312 static int do_clk_register_clkdev(struct clk_hw *hw,
 313         struct clk_lookup **cl, const char *con_id, const char *dev_id)
 314 {
 315         if (IS_ERR(hw))
 316                 return PTR_ERR(hw);
 317         /*
 318          * Since dev_id can be NULL, and NULL is handled specially, we must
 319          * pass it as either a NULL format string, or with "%s".
 320          */
 321         if (dev_id)
 322                 *cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);
 323         else
 324                 *cl = __clk_register_clkdev(hw, con_id, NULL);
 325
 326         return *cl ? 0 : -ENOMEM;
 327 }
 328
 329 /**
 330  * clk_register_clkdev - register one clock lookup for a struct clk
 331  * @clk: struct clk to associate with all clk_lookups
 332  * @con_id: connection ID string on device
 333  * @dev_id: string describing device name
 334  *
 335  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 336  * clkdev.
 337  *
 338  * To make things easier for mass registration, we detect error clks
 339  * from a previous clk_register() call, and return the error code for
 340  * those.  This is to permit this function to be called immediately
 341  * after clk_register().
 342  */
 343 int clk_register_clkdev(struct clk *clk, const char *con_id,
 344         const char *dev_id)
 345 {
 346         struct clk_lookup *cl;
 347
 348         if (IS_ERR(clk))
 349                 return PTR_ERR(clk);
 350
 351         return do_clk_register_clkdev(__clk_get_hw(clk), &cl, con_id,
 352                                               dev_id);
 353 }
 354 EXPORT_SYMBOL(clk_register_clkdev);
 355
 356 /**
 357  * clk_hw_register_clkdev - register one clock lookup for a struct clk_hw
 358  * @hw: struct clk_hw to associate with all clk_lookups
 359  * @con_id: connection ID string on device
 360  * @dev_id: format string describing device name
 361  *
 362  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 363  * clkdev.
 364  *
 365  * To make things easier for mass registration, we detect error clk_hws
 366  * from a previous clk_hw_register_*() call, and return the error code for
 367  * those.  This is to permit this function to be called immediately
 368  * after clk_hw_register_*().
 369  */
 370 int clk_hw_register_clkdev(struct clk_hw *hw, const char *con_id,
 371         const char *dev_id)
 372 {
 373         struct clk_lookup *cl;
 374
 375         return do_clk_register_clkdev(hw, &cl, con_id, dev_id);
 376 }
 377 EXPORT_SYMBOL(clk_hw_register_clkdev);
 378
 379 static void devm_clkdev_release(struct device *dev, void *res)
 380 {
 381         clkdev_drop(*(struct clk_lookup **)res);
 382 }
 383
 384 static int devm_clk_match_clkdev(struct device *dev, void *res, void *data)
 385 {
 386         struct clk_lookup **l = res;
 387
 388         return *l == data;
 389 }
 390
 391 /**
 392  * devm_clk_release_clkdev - Resource managed clkdev lookup release
 393  * @dev: device this lookup is bound
 394  * @con_id: connection ID string on device
 395  * @dev_id: format string describing device name
 396  *
 397  * Drop the clkdev lookup created with devm_clk_hw_register_clkdev.
 398  * Normally this function will not need to be called and the resource
 399  * management code will ensure that the resource is freed.
 400  */
 401 void devm_clk_release_clkdev(struct device *dev, const char *con_id,
 402                              const char *dev_id)
 403 {
 404         struct clk_lookup *cl;
 405         int rval;
 406
 407         mutex_lock(&clocks_mutex);
 408         cl = clk_find(dev_id, con_id);
 409         mutex_unlock(&clocks_mutex);
 410
 411         WARN_ON(!cl);
 412         rval = devres_release(dev, devm_clkdev_release,
 413                               devm_clk_match_clkdev, cl);
 414         WARN_ON(rval);
 415 }
 416 EXPORT_SYMBOL(devm_clk_release_clkdev);
 417
 418 /**
 419  * devm_clk_hw_register_clkdev - managed clk lookup registration for clk_hw
 420  * @dev: device this lookup is bound
 421  * @hw: struct clk_hw to associate with all clk_lookups
 422  * @con_id: connection ID string on device
 423  * @dev_id: format string describing device name
 424  *
 425  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 426  * clkdev.
 427  *
 428  * To make things easier for mass registration, we detect error clk_hws
 429  * from a previous clk_hw_register_*() call, and return the error code for
 430  * those.  This is to permit this function to be called immediately
 431  * after clk_hw_register_*().
 432  */
 433 int devm_clk_hw_register_clkdev(struct device *dev, struct clk_hw *hw,
 434                                 const char *con_id, const char *dev_id)
 435 {
 436         int rval = -ENOMEM;
 437         struct clk_lookup **cl;
 438
 439         cl = devres_alloc(devm_clkdev_release, sizeof(*cl), GFP_KERNEL);
 440         if (cl) {
 441                 rval = do_clk_register_clkdev(hw, cl, con_id, dev_id);
 442                 if (!rval)
 443                         devres_add(dev, cl);
 444                 else
 445                         devres_free(cl);
 446         }
 447         return rval;
 448 }
 449 EXPORT_SYMBOL(devm_clk_hw_register_clkdev);