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