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 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
  31 static struct clk *__of_clk_get(struct device_node *np, int index,
  32                                const char *dev_id, const char *con_id)
  33 {
  34         struct of_phandle_args clkspec;
  35         struct clk *clk;
  36         int rc;
  37
  38         rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
  39                                         &clkspec);
  40         if (rc)
  41                 return ERR_PTR(rc);
  42
  43         clk = __of_clk_get_from_provider(&clkspec, dev_id, con_id);
  44         of_node_put(clkspec.np);
  45
  46         return clk;
  47 }
  48
  49 struct clk *of_clk_get(struct device_node *np, int index)
  50 {
  51         return __of_clk_get(np, index, np->full_name, NULL);
  52 }
  53 EXPORT_SYMBOL(of_clk_get);
  54
  55 static struct clk *__of_clk_get_by_name(struct device_node *np,
  56                                         const char *dev_id,
  57                                         const char *name)
  58 {
  59         struct clk *clk = ERR_PTR(-ENOENT);
  60
  61         /* Walk up the tree of devices looking for a clock that matches */
  62         while (np) {
  63                 int index = 0;
  64
  65                 /*
  66                  * For named clocks, first look up the name in the
  67                  * "clock-names" property.  If it cannot be found, then
  68                  * index will be an error code, and of_clk_get() will fail.
  69                  */
  70                 if (name)
  71                         index = of_property_match_string(np, "clock-names", name);
  72                 clk = __of_clk_get(np, index, dev_id, name);
  73                 if (!IS_ERR(clk)) {
  74                         break;
  75                 } else if (name && index >= 0) {
  76                         if (PTR_ERR(clk) != -EPROBE_DEFER)
  77                                 pr_err("ERROR: could not get clock %pOF:%s(%i)\n",
  78                                         np, name ? name : "", index);
  79                         return clk;
  80                 }
  81
  82                 /*
  83                  * No matching clock found on this node.  If the parent node
  84                  * has a "clock-ranges" property, then we can try one of its
  85                  * clocks.
  86                  */
  87                 np = np->parent;
  88                 if (np && !of_get_property(np, "clock-ranges", NULL))
  89                         break;
  90         }
  91
  92         return clk;
  93 }
  94
  95 /**
  96  * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
  97  * @np: pointer to clock consumer node
  98  * @name: name of consumer's clock input, or NULL for the first clock reference
  99  *
 100  * This function parses the clocks and clock-names properties,
 101  * and uses them to look up the struct clk from the registered list of clock
 102  * providers.
 103  */
 104 struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
 105 {
 106         if (!np)
 107                 return ERR_PTR(-ENOENT);
 108
 109         return __of_clk_get_by_name(np, np->full_name, name);
 110 }
 111 EXPORT_SYMBOL(of_clk_get_by_name);
 112
 113 #else /* defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK) */
 114
 115 static struct clk *__of_clk_get_by_name(struct device_node *np,
 116                                         const char *dev_id,
 117                                         const char *name)
 118 {
 119         return ERR_PTR(-ENOENT);
 120 }
 121 #endif
 122
 123 /*
 124  * Find the correct struct clk for the device and connection ID.
 125  * We do slightly fuzzy matching here:
 126  *  An entry with a NULL ID is assumed to be a wildcard.
 127  *  If an entry has a device ID, it must match
 128  *  If an entry has a connection ID, it must match
 129  * Then we take the most specific entry - with the following
 130  * order of precedence: dev+con > dev only > con only.
 131  */
 132 static struct clk_lookup *clk_find(const char *dev_id, const char *con_id)
 133 {
 134         struct clk_lookup *p, *cl = NULL;
 135         int match, best_found = 0, best_possible = 0;
 136
 137         if (dev_id)
 138                 best_possible += 2;
 139         if (con_id)
 140                 best_possible += 1;
 141
 142         list_for_each_entry(p, &clocks, node) {
 143                 match = 0;
 144                 if (p->dev_id) {
 145                         if (!dev_id || strcmp(p->dev_id, dev_id))
 146                                 continue;
 147                         match += 2;
 148                 }
 149                 if (p->con_id) {
 150                         if (!con_id || strcmp(p->con_id, con_id))
 151                                 continue;
 152                         match += 1;
 153                 }
 154
 155                 if (match > best_found) {
 156                         cl = p;
 157                         if (match != best_possible)
 158                                 best_found = match;
 159                         else
 160                                 break;
 161                 }
 162         }
 163         return cl;
 164 }
 165
 166 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
 167 {
 168         struct clk_lookup *cl;
 169         struct clk *clk = NULL;
 170
 171         mutex_lock(&clocks_mutex);
 172
 173         cl = clk_find(dev_id, con_id);
 174         if (!cl)
 175                 goto out;
 176
 177         clk = __clk_create_clk(cl->clk_hw, dev_id, con_id);
 178         if (IS_ERR(clk))
 179                 goto out;
 180
 181         if (!__clk_get(clk)) {
 182                 __clk_free_clk(clk);
 183                 cl = NULL;
 184                 goto out;
 185         }
 186
 187 out:
 188         mutex_unlock(&clocks_mutex);
 189
 190         return cl ? clk : ERR_PTR(-ENOENT);
 191 }
 192 EXPORT_SYMBOL(clk_get_sys);
 193
 194 struct clk *clk_get(struct device *dev, const char *con_id)
 195 {
 196         const char *dev_id = dev ? dev_name(dev) : NULL;
 197         struct clk *clk;
 198
 199         if (dev && dev->of_node) {
 200                 clk = __of_clk_get_by_name(dev->of_node, dev_id, con_id);
 201                 if (!IS_ERR(clk) || PTR_ERR(clk) == -EPROBE_DEFER)
 202                         return clk;
 203         }
 204
 205         return clk_get_sys(dev_id, con_id);
 206 }
 207 EXPORT_SYMBOL(clk_get);
 208
 209 void clk_put(struct clk *clk)
 210 {
 211         __clk_put(clk);
 212 }
 213 EXPORT_SYMBOL(clk_put);
 214
 215 static void __clkdev_add(struct clk_lookup *cl)
 216 {
 217         mutex_lock(&clocks_mutex);
 218         list_add_tail(&cl->node, &clocks);
 219         mutex_unlock(&clocks_mutex);
 220 }
 221
 222 void clkdev_add(struct clk_lookup *cl)
 223 {
 224         if (!cl->clk_hw)
 225                 cl->clk_hw = __clk_get_hw(cl->clk);
 226         __clkdev_add(cl);
 227 }
 228 EXPORT_SYMBOL(clkdev_add);
 229
 230 void clkdev_add_table(struct clk_lookup *cl, size_t num)
 231 {
 232         mutex_lock(&clocks_mutex);
 233         while (num--) {
 234                 cl->clk_hw = __clk_get_hw(cl->clk);
 235                 list_add_tail(&cl->node, &clocks);
 236                 cl++;
 237         }
 238         mutex_unlock(&clocks_mutex);
 239 }
 240
 241 #define MAX_DEV_ID      20
 242 #define MAX_CON_ID      16
 243
 244 struct clk_lookup_alloc {
 245         struct clk_lookup cl;
 246         char    dev_id[MAX_DEV_ID];
 247         char    con_id[MAX_CON_ID];
 248 };
 249
 250 static struct clk_lookup * __ref
 251 vclkdev_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
 252         va_list ap)
 253 {
 254         struct clk_lookup_alloc *cla;
 255
 256         cla = kzalloc(sizeof(*cla), GFP_KERNEL);
 257         if (!cla)
 258                 return NULL;
 259
 260         cla->cl.clk_hw = hw;
 261         if (con_id) {
 262                 strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
 263                 cla->cl.con_id = cla->con_id;
 264         }
 265
 266         if (dev_fmt) {
 267                 vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
 268                 cla->cl.dev_id = cla->dev_id;
 269         }
 270
 271         return &cla->cl;
 272 }
 273
 274 static struct clk_lookup *
 275 vclkdev_create(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
 276         va_list ap)
 277 {
 278         struct clk_lookup *cl;
 279
 280         cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
 281         if (cl)
 282                 __clkdev_add(cl);
 283
 284         return cl;
 285 }
 286
 287 struct clk_lookup * __ref
 288 clkdev_alloc(struct clk *clk, const char *con_id, const char *dev_fmt, ...)
 289 {
 290         struct clk_lookup *cl;
 291         va_list ap;
 292
 293         va_start(ap, dev_fmt);
 294         cl = vclkdev_alloc(__clk_get_hw(clk), con_id, dev_fmt, ap);
 295         va_end(ap);
 296
 297         return cl;
 298 }
 299 EXPORT_SYMBOL(clkdev_alloc);
 300
 301 struct clk_lookup *
 302 clkdev_hw_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt, ...)
 303 {
 304         struct clk_lookup *cl;
 305         va_list ap;
 306
 307         va_start(ap, dev_fmt);
 308         cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
 309         va_end(ap);
 310
 311         return cl;
 312 }
 313 EXPORT_SYMBOL(clkdev_hw_alloc);
 314
 315 /**
 316  * clkdev_create - allocate and add a clkdev lookup structure
 317  * @clk: struct clk to associate with all clk_lookups
 318  * @con_id: connection ID string on device
 319  * @dev_fmt: format string describing device name
 320  *
 321  * Returns a clk_lookup structure, which can be later unregistered and
 322  * freed.
 323  */
 324 struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
 325         const char *dev_fmt, ...)
 326 {
 327         struct clk_lookup *cl;
 328         va_list ap;
 329
 330         va_start(ap, dev_fmt);
 331         cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);
 332         va_end(ap);
 333
 334         return cl;
 335 }
 336 EXPORT_SYMBOL_GPL(clkdev_create);
 337
 338 /**
 339  * clkdev_hw_create - allocate and add a clkdev lookup structure
 340  * @hw: struct clk_hw to associate with all clk_lookups
 341  * @con_id: connection ID string on device
 342  * @dev_fmt: format string describing device name
 343  *
 344  * Returns a clk_lookup structure, which can be later unregistered and
 345  * freed.
 346  */
 347 struct clk_lookup *clkdev_hw_create(struct clk_hw *hw, const char *con_id,
 348         const char *dev_fmt, ...)
 349 {
 350         struct clk_lookup *cl;
 351         va_list ap;
 352
 353         va_start(ap, dev_fmt);
 354         cl = vclkdev_create(hw, con_id, dev_fmt, ap);
 355         va_end(ap);
 356
 357         return cl;
 358 }
 359 EXPORT_SYMBOL_GPL(clkdev_hw_create);
 360
 361 int clk_add_alias(const char *alias, const char *alias_dev_name,
 362         const char *con_id, struct device *dev)
 363 {
 364         struct clk *r = clk_get(dev, con_id);
 365         struct clk_lookup *l;
 366
 367         if (IS_ERR(r))
 368                 return PTR_ERR(r);
 369
 370         l = clkdev_create(r, alias, alias_dev_name ? "%s" : NULL,
 371                           alias_dev_name);
 372         clk_put(r);
 373
 374         return l ? 0 : -ENODEV;
 375 }
 376 EXPORT_SYMBOL(clk_add_alias);
 377
 378 /*
 379  * clkdev_drop - remove a clock dynamically allocated
 380  */
 381 void clkdev_drop(struct clk_lookup *cl)
 382 {
 383         mutex_lock(&clocks_mutex);
 384         list_del(&cl->node);
 385         mutex_unlock(&clocks_mutex);
 386         kfree(cl);
 387 }
 388 EXPORT_SYMBOL(clkdev_drop);
 389
 390 static struct clk_lookup *__clk_register_clkdev(struct clk_hw *hw,
 391                                                 const char *con_id,
 392                                                 const char *dev_id, ...)
 393 {
 394         struct clk_lookup *cl;
 395         va_list ap;
 396
 397         va_start(ap, dev_id);
 398         cl = vclkdev_create(hw, con_id, dev_id, ap);
 399         va_end(ap);
 400
 401         return cl;
 402 }
 403
 404 /**
 405  * clk_register_clkdev - register one clock lookup for a struct clk
 406  * @clk: struct clk to associate with all clk_lookups
 407  * @con_id: connection ID string on device
 408  * @dev_id: string describing device name
 409  *
 410  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 411  * clkdev.
 412  *
 413  * To make things easier for mass registration, we detect error clks
 414  * from a previous clk_register() call, and return the error code for
 415  * those.  This is to permit this function to be called immediately
 416  * after clk_register().
 417  */
 418 int clk_register_clkdev(struct clk *clk, const char *con_id,
 419         const char *dev_id)
 420 {
 421         struct clk_lookup *cl;
 422
 423         if (IS_ERR(clk))
 424                 return PTR_ERR(clk);
 425
 426         /*
 427          * Since dev_id can be NULL, and NULL is handled specially, we must
 428          * pass it as either a NULL format string, or with "%s".
 429          */
 430         if (dev_id)
 431                 cl = __clk_register_clkdev(__clk_get_hw(clk), con_id, "%s",
 432                                            dev_id);
 433         else
 434                 cl = __clk_register_clkdev(__clk_get_hw(clk), con_id, NULL);
 435
 436         return cl ? 0 : -ENOMEM;
 437 }
 438 EXPORT_SYMBOL(clk_register_clkdev);
 439
 440 /**
 441  * clk_hw_register_clkdev - register one clock lookup for a struct clk_hw
 442  * @hw: struct clk_hw to associate with all clk_lookups
 443  * @con_id: connection ID string on device
 444  * @dev_id: format string describing device name
 445  *
 446  * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 447  * clkdev.
 448  *
 449  * To make things easier for mass registration, we detect error clk_hws
 450  * from a previous clk_hw_register_*() call, and return the error code for
 451  * those.  This is to permit this function to be called immediately
 452  * after clk_hw_register_*().
 453  */
 454 int clk_hw_register_clkdev(struct clk_hw *hw, const char *con_id,
 455         const char *dev_id)
 456 {
 457         struct clk_lookup *cl;
 458
 459         if (IS_ERR(hw))
 460                 return PTR_ERR(hw);
 461
 462         /*
 463          * Since dev_id can be NULL, and NULL is handled specially, we must
 464          * pass it as either a NULL format string, or with "%s".
 465          */
 466         if (dev_id)
 467                 cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);
 468         else
 469                 cl = __clk_register_clkdev(hw, con_id, NULL);
 470
 471         return cl ? 0 : -ENOMEM;
 472 }
 473 EXPORT_SYMBOL(clk_hw_register_clkdev);