1/* 2 * drivers/base/power/clock_ops.c - Generic clock manipulation PM callbacks 3 * 4 * Copyright (c) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp. 5 * 6 * This file is released under the GPLv2. 7 */ 8 9#include <linux/kernel.h> 10#include <linux/device.h> 11#include <linux/io.h> 12#include <linux/pm.h> 13#include <linux/pm_clock.h> 14#include <linux/clk.h> 15#include <linux/slab.h> 16#include <linux/err.h> 17 18#ifdef CONFIG_PM 19 20enum pce_status { 21 PCE_STATUS_NONE = 0, 22 PCE_STATUS_ACQUIRED, 23 PCE_STATUS_ENABLED, 24 PCE_STATUS_ERROR, 25}; 26 27struct pm_clock_entry { 28 struct list_head node; 29 char *con_id; 30 struct clk *clk; 31 enum pce_status status; 32}; 33 34/** 35 * pm_clk_enable - Enable a clock, reporting any errors 36 * @dev: The device for the given clock 37 * @clk: The clock being enabled. 38 */ 39static inline int __pm_clk_enable(struct device *dev, struct clk *clk) 40{ 41 int ret = clk_enable(clk); 42 if (ret) 43 dev_err(dev, "%s: failed to enable clk %p, error %d\n", 44 __func__, clk, ret); 45 46 return ret; 47} 48 49/** 50 * pm_clk_acquire - Acquire a device clock. 51 * @dev: Device whose clock is to be acquired. 52 * @ce: PM clock entry corresponding to the clock. 53 */ 54static void pm_clk_acquire(struct device *dev, struct pm_clock_entry *ce) 55{ 56 ce->clk = clk_get(dev, ce->con_id); 57 if (IS_ERR(ce->clk)) { 58 ce->status = PCE_STATUS_ERROR; 59 } else { 60 clk_prepare(ce->clk); 61 ce->status = PCE_STATUS_ACQUIRED; 62 dev_dbg(dev, "Clock %s managed by runtime PM.\n", ce->con_id); 63 } 64} 65 66/** 67 * pm_clk_add - Start using a device clock for power management. 68 * @dev: Device whose clock is going to be used for power management. 69 * @con_id: Connection ID of the clock. 70 * 71 * Add the clock represented by @con_id to the list of clocks used for 72 * the power management of @dev. 73 */ 74int pm_clk_add(struct device *dev, const char *con_id) 75{ 76 struct pm_subsys_data *psd = dev_to_psd(dev); 77 struct pm_clock_entry *ce; 78 79 if (!psd) 80 return -EINVAL; 81 82 ce = kzalloc(sizeof(*ce), GFP_KERNEL); 83 if (!ce) { 84 dev_err(dev, "Not enough memory for clock entry.\n"); 85 return -ENOMEM; 86 } 87 88 if (con_id) { 89 ce->con_id = kstrdup(con_id, GFP_KERNEL); 90 if (!ce->con_id) { 91 dev_err(dev, 92 "Not enough memory for clock connection ID.\n"); 93 kfree(ce); 94 return -ENOMEM; 95 } 96 } 97 98 pm_clk_acquire(dev, ce); 99 100 spin_lock_irq(&psd->lock); 101 list_add_tail(&ce->node, &psd->clock_list); 102 spin_unlock_irq(&psd->lock); 103 return 0; 104} 105 106/** 107 * __pm_clk_remove - Destroy PM clock entry. 108 * @ce: PM clock entry to destroy. 109 */ 110static void __pm_clk_remove(struct pm_clock_entry *ce) 111{ 112 if (!ce) 113 return; 114 115 if (ce->status < PCE_STATUS_ERROR) { 116 if (ce->status == PCE_STATUS_ENABLED) 117 clk_disable(ce->clk); 118 119 if (ce->status >= PCE_STATUS_ACQUIRED) { 120 clk_unprepare(ce->clk); 121 clk_put(ce->clk); 122 } 123 } 124 125 kfree(ce->con_id); 126 kfree(ce); 127} 128 129/** 130 * pm_clk_remove - Stop using a device clock for power management. 131 * @dev: Device whose clock should not be used for PM any more. 132 * @con_id: Connection ID of the clock. 133 * 134 * Remove the clock represented by @con_id from the list of clocks used for 135 * the power management of @dev. 136 */ 137void pm_clk_remove(struct device *dev, const char *con_id) 138{ 139 struct pm_subsys_data *psd = dev_to_psd(dev); 140 struct pm_clock_entry *ce; 141 142 if (!psd) 143 return; 144 145 spin_lock_irq(&psd->lock); 146 147 list_for_each_entry(ce, &psd->clock_list, node) { 148 if (!con_id && !ce->con_id) 149 goto remove; 150 else if (!con_id || !ce->con_id) 151 continue; 152 else if (!strcmp(con_id, ce->con_id)) 153 goto remove; 154 } 155 156 spin_unlock_irq(&psd->lock); 157 return; 158 159 remove: 160 list_del(&ce->node); 161 spin_unlock_irq(&psd->lock); 162 163 __pm_clk_remove(ce); 164} 165 166/** 167 * pm_clk_init - Initialize a device's list of power management clocks. 168 * @dev: Device to initialize the list of PM clocks for. 169 * 170 * Initialize the lock and clock_list members of the device's pm_subsys_data 171 * object. 172 */ 173void pm_clk_init(struct device *dev) 174{ 175 struct pm_subsys_data *psd = dev_to_psd(dev); 176 if (psd) 177 INIT_LIST_HEAD(&psd->clock_list); 178} 179 180/** 181 * pm_clk_create - Create and initialize a device's list of PM clocks. 182 * @dev: Device to create and initialize the list of PM clocks for. 183 * 184 * Allocate a struct pm_subsys_data object, initialize its lock and clock_list 185 * members and make the @dev's power.subsys_data field point to it. 186 */ 187int pm_clk_create(struct device *dev) 188{ 189 return dev_pm_get_subsys_data(dev); 190} 191 192/** 193 * pm_clk_destroy - Destroy a device's list of power management clocks. 194 * @dev: Device to destroy the list of PM clocks for. 195 * 196 * Clear the @dev's power.subsys_data field, remove the list of clock entries 197 * from the struct pm_subsys_data object pointed to by it before and free 198 * that object. 199 */ 200void pm_clk_destroy(struct device *dev) 201{ 202 struct pm_subsys_data *psd = dev_to_psd(dev); 203 struct pm_clock_entry *ce, *c; 204 struct list_head list; 205 206 if (!psd) 207 return; 208 209 INIT_LIST_HEAD(&list); 210 211 spin_lock_irq(&psd->lock); 212 213 list_for_each_entry_safe_reverse(ce, c, &psd->clock_list, node) 214 list_move(&ce->node, &list); 215 216 spin_unlock_irq(&psd->lock); 217 218 dev_pm_put_subsys_data(dev); 219 220 list_for_each_entry_safe_reverse(ce, c, &list, node) { 221 list_del(&ce->node); 222 __pm_clk_remove(ce); 223 } 224} 225 226#endif /* CONFIG_PM */ 227 228#ifdef CONFIG_PM_RUNTIME 229 230/** 231 * pm_clk_suspend - Disable clocks in a device's PM clock list. 232 * @dev: Device to disable the clocks for. 233 */ 234int pm_clk_suspend(struct device *dev) 235{ 236 struct pm_subsys_data *psd = dev_to_psd(dev); 237 struct pm_clock_entry *ce; 238 unsigned long flags; 239 240 dev_dbg(dev, "%s()\n", __func__); 241 242 if (!psd) 243 return 0; 244 245 spin_lock_irqsave(&psd->lock, flags); 246 247 list_for_each_entry_reverse(ce, &psd->clock_list, node) { 248 if (ce->status < PCE_STATUS_ERROR) { 249 if (ce->status == PCE_STATUS_ENABLED) 250 clk_disable(ce->clk); 251 ce->status = PCE_STATUS_ACQUIRED; 252 } 253 } 254 255 spin_unlock_irqrestore(&psd->lock, flags); 256 257 return 0; 258} 259 260/** 261 * pm_clk_resume - Enable clocks in a device's PM clock list. 262 * @dev: Device to enable the clocks for. 263 */ 264int pm_clk_resume(struct device *dev) 265{ 266 struct pm_subsys_data *psd = dev_to_psd(dev); 267 struct pm_clock_entry *ce; 268 unsigned long flags; 269 int ret; 270 271 dev_dbg(dev, "%s()\n", __func__); 272 273 if (!psd) 274 return 0; 275 276 spin_lock_irqsave(&psd->lock, flags); 277 278 list_for_each_entry(ce, &psd->clock_list, node) { 279 if (ce->status < PCE_STATUS_ERROR) { 280 ret = __pm_clk_enable(dev, ce->clk); 281 if (!ret) 282 ce->status = PCE_STATUS_ENABLED; 283 } 284 } 285 286 spin_unlock_irqrestore(&psd->lock, flags); 287 288 return 0; 289} 290 291/** 292 * pm_clk_notify - Notify routine for device addition and removal. 293 * @nb: Notifier block object this function is a member of. 294 * @action: Operation being carried out by the caller. 295 * @data: Device the routine is being run for. 296 * 297 * For this function to work, @nb must be a member of an object of type 298 * struct pm_clk_notifier_block containing all of the requisite data. 299 * Specifically, the pm_domain member of that object is copied to the device's 300 * pm_domain field and its con_ids member is used to populate the device's list 301 * of PM clocks, depending on @action. 302 * 303 * If the device's pm_domain field is already populated with a value different 304 * from the one stored in the struct pm_clk_notifier_block object, the function 305 * does nothing. 306 */ 307static int pm_clk_notify(struct notifier_block *nb, 308 unsigned long action, void *data) 309{ 310 struct pm_clk_notifier_block *clknb; 311 struct device *dev = data; 312 char **con_id; 313 int error; 314 315 dev_dbg(dev, "%s() %ld\n", __func__, action); 316 317 clknb = container_of(nb, struct pm_clk_notifier_block, nb); 318 319 switch (action) { 320 case BUS_NOTIFY_ADD_DEVICE: 321 if (dev->pm_domain) 322 break; 323 324 error = pm_clk_create(dev); 325 if (error) 326 break; 327 328 dev->pm_domain = clknb->pm_domain; 329 if (clknb->con_ids[0]) { 330 for (con_id = clknb->con_ids; *con_id; con_id++) 331 pm_clk_add(dev, *con_id); 332 } else { 333 pm_clk_add(dev, NULL); 334 } 335 336 break; 337 case BUS_NOTIFY_DEL_DEVICE: 338 if (dev->pm_domain != clknb->pm_domain) 339 break; 340 341 dev->pm_domain = NULL; 342 pm_clk_destroy(dev); 343 break; 344 } 345 346 return 0; 347} 348 349#else /* !CONFIG_PM_RUNTIME */ 350 351#ifdef CONFIG_PM 352 353/** 354 * pm_clk_suspend - Disable clocks in a device's PM clock list. 355 * @dev: Device to disable the clocks for. 356 */ 357int pm_clk_suspend(struct device *dev) 358{ 359 struct pm_subsys_data *psd = dev_to_psd(dev); 360 struct pm_clock_entry *ce; 361 unsigned long flags; 362 363 dev_dbg(dev, "%s()\n", __func__); 364 365 /* If there is no driver, the clocks are already disabled. */ 366 if (!psd || !dev->driver) 367 return 0; 368 369 spin_lock_irqsave(&psd->lock, flags); 370 371 list_for_each_entry_reverse(ce, &psd->clock_list, node) { 372 if (ce->status < PCE_STATUS_ERROR) { 373 if (ce->status == PCE_STATUS_ENABLED) 374 clk_disable(ce->clk); 375 ce->status = PCE_STATUS_ACQUIRED; 376 } 377 } 378 379 spin_unlock_irqrestore(&psd->lock, flags); 380 381 return 0; 382} 383 384/** 385 * pm_clk_resume - Enable clocks in a device's PM clock list. 386 * @dev: Device to enable the clocks for. 387 */ 388int pm_clk_resume(struct device *dev) 389{ 390 struct pm_subsys_data *psd = dev_to_psd(dev); 391 struct pm_clock_entry *ce; 392 unsigned long flags; 393 int ret; 394 395 dev_dbg(dev, "%s()\n", __func__); 396 397 /* If there is no driver, the clocks should remain disabled. */ 398 if (!psd || !dev->driver) 399 return 0; 400 401 spin_lock_irqsave(&psd->lock, flags); 402 403 list_for_each_entry(ce, &psd->clock_list, node) { 404 if (ce->status < PCE_STATUS_ERROR) { 405 ret = __pm_clk_enable(dev, ce->clk); 406 if (!ret) 407 ce->status = PCE_STATUS_ENABLED; 408 } 409 } 410 411 spin_unlock_irqrestore(&psd->lock, flags); 412 413 return 0; 414} 415 416#endif /* CONFIG_PM */ 417 418/** 419 * enable_clock - Enable a device clock. 420 * @dev: Device whose clock is to be enabled. 421 * @con_id: Connection ID of the clock. 422 */ 423static void enable_clock(struct device *dev, const char *con_id) 424{ 425 struct clk *clk; 426 427 clk = clk_get(dev, con_id); 428 if (!IS_ERR(clk)) { 429 clk_prepare_enable(clk); 430 clk_put(clk); 431 dev_info(dev, "Runtime PM disabled, clock forced on.\n"); 432 } 433} 434 435/** 436 * disable_clock - Disable a device clock. 437 * @dev: Device whose clock is to be disabled. 438 * @con_id: Connection ID of the clock. 439 */ 440static void disable_clock(struct device *dev, const char *con_id) 441{ 442 struct clk *clk; 443 444 clk = clk_get(dev, con_id); 445 if (!IS_ERR(clk)) { 446 clk_disable_unprepare(clk); 447 clk_put(clk); 448 dev_info(dev, "Runtime PM disabled, clock forced off.\n"); 449 } 450} 451 452/** 453 * pm_clk_notify - Notify routine for device addition and removal. 454 * @nb: Notifier block object this function is a member of. 455 * @action: Operation being carried out by the caller. 456 * @data: Device the routine is being run for. 457 * 458 * For this function to work, @nb must be a member of an object of type 459 * struct pm_clk_notifier_block containing all of the requisite data. 460 * Specifically, the con_ids member of that object is used to enable or disable 461 * the device's clocks, depending on @action. 462 */ 463static int pm_clk_notify(struct notifier_block *nb, 464 unsigned long action, void *data) 465{ 466 struct pm_clk_notifier_block *clknb; 467 struct device *dev = data; 468 char **con_id; 469 470 dev_dbg(dev, "%s() %ld\n", __func__, action); 471 472 clknb = container_of(nb, struct pm_clk_notifier_block, nb); 473 474 switch (action) { 475 case BUS_NOTIFY_BIND_DRIVER: 476 if (clknb->con_ids[0]) { 477 for (con_id = clknb->con_ids; *con_id; con_id++) 478 enable_clock(dev, *con_id); 479 } else { 480 enable_clock(dev, NULL); 481 } 482 break; 483 case BUS_NOTIFY_UNBOUND_DRIVER: 484 if (clknb->con_ids[0]) { 485 for (con_id = clknb->con_ids; *con_id; con_id++) 486 disable_clock(dev, *con_id); 487 } else { 488 disable_clock(dev, NULL); 489 } 490 break; 491 } 492 493 return 0; 494} 495 496#endif /* !CONFIG_PM_RUNTIME */ 497 498/** 499 * pm_clk_add_notifier - Add bus type notifier for power management clocks. 500 * @bus: Bus type to add the notifier to. 501 * @clknb: Notifier to be added to the given bus type. 502 * 503 * The nb member of @clknb is not expected to be initialized and its 504 * notifier_call member will be replaced with pm_clk_notify(). However, 505 * the remaining members of @clknb should be populated prior to calling this 506 * routine. 507 */ 508void pm_clk_add_notifier(struct bus_type *bus, 509 struct pm_clk_notifier_block *clknb) 510{ 511 if (!bus || !clknb) 512 return; 513 514 clknb->nb.notifier_call = pm_clk_notify; 515 bus_register_notifier(bus, &clknb->nb); 516} 517