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/of.h>
  23
  24 #include "clk.h"
  25
  26 static LIST_HEAD(clocks);
  27 static DEFINE_MUTEX(clocks_mutex);
  28
  29 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
  30
  31 /**
  32  * of_clk_get_by_clkspec() - Lookup a clock form a clock provider
  33  * @clkspec: pointer to a clock specifier data structure
  34  *
  35  * This function looks up a struct clk from the registered list of clock
  36  * providers, an input is a clock specifier data structure as returned
  37  * from the of_parse_phandle_with_args() function call.
  38  */
  39 struct clk *of_clk_get_by_clkspec(struct of_phandle_args *clkspec)
  40 {
  41         struct clk *clk;
  42
  43         if (!clkspec)
  44                 return ERR_PTR(-EINVAL);
  45
  46         of_clk_lock();
  47         clk = __of_clk_get_from_provider(clkspec);
  48
  49         if (!IS_ERR(clk) && !__clk_get(clk))
  50                 clk = ERR_PTR(-ENOENT);
  51
  52         of_clk_unlock();
  53         return clk;
  54 }
  55
  56 struct clk *of_clk_get(struct device_node *np, int index)
  57 {
  58         struct of_phandle_args clkspec;
  59         struct clk *clk;
  60         int rc;
  61
  62         if (index < 0)
  63                 return ERR_PTR(-EINVAL);
  64
  65         rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
  66                                         &clkspec);
  67         if (rc)
  68                 return ERR_PTR(rc);
  69
  70         clk = of_clk_get_by_clkspec(&clkspec);
  71         of_node_put(clkspec.np);
  72         return clk;
  73 }
  74 EXPORT_SYMBOL(of_clk_get);
  75
  76 /**
  77  * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
  78  * @np: pointer to clock consumer node
  79  * @name: name of consumer's clock input, or NULL for the first clock reference
  80  *
  81  * This function parses the clocks and clock-names properties,
  82  * and uses them to look up the struct clk from the registered list of clock
  83  * providers.
  84  */
  85 struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
  86 {
  87         struct clk *clk = ERR_PTR(-ENOENT);
  88
  89         /* Walk up the tree of devices looking for a clock that matches */
  90         while (np) {
  91                 int index = 0;
  92
  93                 /*
  94                  * For named clocks, first look up the name in the
  95                  * "clock-names" property.  If it cannot be found, then
  96                  * index will be an error code, and of_clk_get() will fail.
  97                  */
  98                 if (name)
  99                         index = of_property_match_string(np, "clock-names", name);
 100                 clk = of_clk_get(np, index);
 101                 if (!IS_ERR(clk))
 102                         break;
 103                 else if (name && index >= 0) {
 104                         pr_err("ERROR: could not get clock %s:%s(%i)\n",
 105                                 np->full_name, name ? name : "", index);
 106                         return clk;
 107                 }
 108
 109                 /*
 110                  * No matching clock found on this node.  If the parent node
 111                  * has a "clock-ranges" property, then we can try one of its
 112                  * clocks.
 113                  */
 114                 np = np->parent;
 115                 if (np && !of_get_property(np, "clock-ranges", NULL))
 116                         break;
 117         }
 118
 119         return clk;
 120 }
 121 EXPORT_SYMBOL(of_clk_get_by_name);
 122 #endif
 123
 124 /*
 125  * Find the correct struct clk for the device and connection ID.
 126  * We do slightly fuzzy matching here:
 127  *  An entry with a NULL ID is assumed to be a wildcard.
 128  *  If an entry has a device ID, it must match
 129  *  If an entry has a connection ID, it must match
 130  * Then we take the most specific entry - with the following
 131  * order of precedence: dev+con > dev only > con only.
 132  */
 133 static struct clk_lookup *clk_find(const char *dev_id, const char *con_id)
 134 {
 135         struct clk_lookup *p, *cl = NULL;
 136         int match, best_found = 0, best_possible = 0;
 137
 138         if (dev_id)
 139                 best_possible += 2;
 140         if (con_id)
 141                 best_possible += 1;
 142
 143         list_for_each_entry(p, &clocks, node) {
 144                 match = 0;
 145                 if (p->dev_id) {
 146                         if (!dev_id || strcmp(p->dev_id, dev_id))
 147                                 continue;
 148                         match += 2;
 149                 }
 150                 if (p->con_id) {
 151                         if (!con_id || strcmp(p->con_id, con_id))
 152                                 continue;
 153                         match += 1;
 154                 }
 155
 156                 if (match > best_found) {
 157                         cl = p;
 158                         if (match != best_possible)
 159                                 best_found = match;
 160                         else
 161                                 break;
 162                 }
 163         }
 164         return cl;
 165 }
 166
 167 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
 168 {
 169         struct clk_lookup *cl;
 170
 171         mutex_lock(&clocks_mutex);
 172         cl = clk_find(dev_id, con_id);
 173         if (cl && !__clk_get(cl->clk))
 174                 cl = NULL;
 175         mutex_unlock(&clocks_mutex);
 176
 177         return cl ? cl->clk : ERR_PTR(-ENOENT);
 178 }
 179 EXPORT_SYMBOL(clk_get_sys);
 180
 181 struct clk *clk_get(struct device *dev, const char *con_id)
 182 {
 183         const char *dev_id = dev ? dev_name(dev) : NULL;
 184         struct clk *clk;
 185
 186         if (dev) {
 187                 clk = of_clk_get_by_name(dev->of_node, con_id);
 188                 if (!IS_ERR(clk))
 189                         return clk;
 190                 if (PTR_ERR(clk) == -EPROBE_DEFER)
 191                         return clk;
 192         }
 193
 194         return clk_get_sys(dev_id, con_id);
 195 }
 196 EXPORT_SYMBOL(clk_get);
 197
 198 void clk_put(struct clk *clk)
 199 {
 200         __clk_put(clk);
 201 }
 202 EXPORT_SYMBOL(clk_put);
 203
 204 void clkdev_add(struct clk_lookup *cl)
 205 {
 206         mutex_lock(&clocks_mutex);
 207         list_add_tail(&cl->node, &clocks);
 208         mutex_unlock(&clocks_mutex);
 209 }
 210 EXPORT_SYMBOL(clkdev_add);
 211
 212 void __init clkdev_add_table(struct clk_lookup *cl, size_t num)
 213 {
 214         mutex_lock(&clocks_mutex);
 215         while (num--) {
 216                 list_add_tail(&cl->node, &clocks);
 217                 cl++;
 218         }
 219         mutex_unlock(&clocks_mutex);
 220 }
 221
 222 #define MAX_DEV_ID      20
 223 #define MAX_CON_ID      16
 224
 225 struct clk_lookup_alloc {
 226         struct clk_lookup cl;
 227         char    dev_id[MAX_DEV_ID];
 228         char    con_id[MAX_CON_ID];
 229 };
 230
 231 static struct clk_lookup * __init_refok
 232 vclkdev_alloc(struct clk *clk, const char *con_id, const char *dev_fmt,
 233         va_list ap)
 234 {
 235         struct clk_lookup_alloc *cla;
 236
 237         cla = __clkdev_alloc(sizeof(*cla));
 238         if (!cla)
 239                 return NULL;
 240
 241         cla->cl.clk = clk;
 242         if (con_id) {
 243                 strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
 244                 cla->cl.con_id = cla->con_id;
 245         }
 246
 247         if (dev_fmt) {
 248                 vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
 249                 cla->cl.dev_id = cla->dev_id;
 250         }
 251
 252         return &cla->cl;
 253 }
 254
 255 struct clk_lookup * __init_refok
 256 clkdev_alloc(struct clk *clk, const char *con_id, const char *dev_fmt, ...)
 257 {
 258         struct clk_lookup *cl;
 259         va_list ap;
 260
 261         va_start(ap, dev_fmt);
 262         cl = vclkdev_alloc(clk, con_id, dev_fmt, ap);
 263         va_end(ap);
 264
 265         return cl;
 266 }
 267 EXPORT_SYMBOL(clkdev_alloc);
 268
 269 int clk_add_alias(const char *alias, const char *alias_dev_name, char *id,
 270         struct device *dev)
 271 {
 272         struct clk *r = clk_get(dev, id);
 273         struct clk_lookup *l;
 274
 275         if (IS_ERR(r))
 276                 return PTR_ERR(r);
 277
 278         l = clkdev_alloc(r, alias, alias_dev_name);
 279         clk_put(r);
 280         if (!l)
 281                 return -ENODEV;
 282         clkdev_add(l);
 283         return 0;
 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 /**
 300  * clk_register_clkdev - register one clock lookup for a struct clk
 301  * @clk: struct clk to associate with all clk_lookups
 302  * @con_id: connection ID string on device
 303  * @dev_id: format string describing device name
 304  *
 305  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 306  * clkdev.
 307  *
 308  * To make things easier for mass registration, we detect error clks
 309  * from a previous clk_register() call, and return the error code for
 310  * those.  This is to permit this function to be called immediately
 311  * after clk_register().
 312  */
 313 int clk_register_clkdev(struct clk *clk, const char *con_id,
 314         const char *dev_fmt, ...)
 315 {
 316         struct clk_lookup *cl;
 317         va_list ap;
 318
 319         if (IS_ERR(clk))
 320                 return PTR_ERR(clk);
 321
 322         va_start(ap, dev_fmt);
 323         cl = vclkdev_alloc(clk, con_id, dev_fmt, ap);
 324         va_end(ap);
 325
 326         if (!cl)
 327                 return -ENOMEM;
 328
 329         clkdev_add(cl);
 330
 331         return 0;
 332 }
 333
 334 /**
 335  * clk_register_clkdevs - register a set of clk_lookup for a struct clk
 336  * @clk: struct clk to associate with all clk_lookups
 337  * @cl: array of clk_lookup structures with con_id and dev_id pre-initialized
 338  * @num: number of clk_lookup structures to register
 339  *
 340  * To make things easier for mass registration, we detect error clks
 341  * from a previous clk_register() call, and return the error code for
 342  * those.  This is to permit this function to be called immediately
 343  * after clk_register().
 344  */
 345 int clk_register_clkdevs(struct clk *clk, struct clk_lookup *cl, size_t num)
 346 {
 347         unsigned i;
 348
 349         if (IS_ERR(clk))
 350                 return PTR_ERR(clk);
 351
 352         for (i = 0; i < num; i++, cl++) {
 353                 cl->clk = clk;
 354                 clkdev_add(cl);
 355         }
 356
 357         return 0;
 358 }
 359 EXPORT_SYMBOL(clk_register_clkdevs);