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); 451