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/clkdev.h> 16 #include <linux/slab.h> 17 #include <linux/err.h> 18 #include <linux/pm_domain.h> 19 #include <linux/pm_runtime.h> 20 21 #ifdef CONFIG_PM_CLK 22 23 enum pce_status { 24 PCE_STATUS_NONE = 0, 25 PCE_STATUS_ACQUIRED, 26 PCE_STATUS_ENABLED, 27 PCE_STATUS_ERROR, 28 }; 29 30 struct pm_clock_entry { 31 struct list_head node; 32 char *con_id; 33 struct clk *clk; 34 enum pce_status status; 35 }; 36 37 /** 38 * pm_clk_enable - Enable a clock, reporting any errors 39 * @dev: The device for the given clock 40 * @ce: PM clock entry corresponding to the clock. 41 */ 42 static inline void __pm_clk_enable(struct device *dev, struct pm_clock_entry *ce) 43 { 44 int ret; 45 46 if (ce->status < PCE_STATUS_ERROR) { 47 ret = clk_enable(ce->clk); 48 if (!ret) 49 ce->status = PCE_STATUS_ENABLED; 50 else 51 dev_err(dev, "%s: failed to enable clk %p, error %d\n", 52 __func__, ce->clk, ret); 53 } 54 } 55 56 /** 57 * pm_clk_acquire - Acquire a device clock. 58 * @dev: Device whose clock is to be acquired. 59 * @ce: PM clock entry corresponding to the clock. 60 */ 61 static void pm_clk_acquire(struct device *dev, struct pm_clock_entry *ce) 62 { 63 if (!ce->clk) 64 ce->clk = clk_get(dev, ce->con_id); 65 if (IS_ERR(ce->clk)) { 66 ce->status = PCE_STATUS_ERROR; 67 } else { 68 clk_prepare(ce->clk); 69 ce->status = PCE_STATUS_ACQUIRED; 70 dev_dbg(dev, "Clock %pC con_id %s managed by runtime PM.\n", 71 ce->clk, ce->con_id); 72 } 73 } 74 75 static int __pm_clk_add(struct device *dev, const char *con_id, 76 struct clk *clk) 77 { 78 struct pm_subsys_data *psd = dev_to_psd(dev); 79 struct pm_clock_entry *ce; 80 81 if (!psd) 82 return -EINVAL; 83 84 ce = kzalloc(sizeof(*ce), GFP_KERNEL); 85 if (!ce) 86 return -ENOMEM; 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 } else { 97 if (IS_ERR(clk)) { 98 kfree(ce); 99 return -ENOENT; 100 } 101 ce->clk = clk; 102 } 103 104 pm_clk_acquire(dev, ce); 105 106 spin_lock_irq(&psd->lock); 107 list_add_tail(&ce->node, &psd->clock_list); 108 spin_unlock_irq(&psd->lock); 109 return 0; 110 } 111 112 /** 113 * pm_clk_add - Start using a device clock for power management. 114 * @dev: Device whose clock is going to be used for power management. 115 * @con_id: Connection ID of the clock. 116 * 117 * Add the clock represented by @con_id to the list of clocks used for 118 * the power management of @dev. 119 */ 120 int pm_clk_add(struct device *dev, const char *con_id) 121 { 122 return __pm_clk_add(dev, con_id, NULL); 123 } 124 125 /** 126 * pm_clk_add_clk - Start using a device clock for power management. 127 * @dev: Device whose clock is going to be used for power management. 128 * @clk: Clock pointer 129 * 130 * Add the clock to the list of clocks used for the power management of @dev. 131 * The power-management code will take control of the clock reference, so 132 * callers should not call clk_put() on @clk after this function sucessfully 133 * returned. 134 */ 135 int pm_clk_add_clk(struct device *dev, struct clk *clk) 136 { 137 return __pm_clk_add(dev, NULL, clk); 138 } 139 140 141 /** 142 * of_pm_clk_add_clks - Start using device clock(s) for power management. 143 * @dev: Device whose clock(s) is going to be used for power management. 144 * 145 * Add a series of clocks described in the 'clocks' device-tree node for 146 * a device to the list of clocks used for the power management of @dev. 147 * On success, returns the number of clocks added. Returns a negative 148 * error code if there are no clocks in the device node for the device 149 * or if adding a clock fails. 150 */ 151 int of_pm_clk_add_clks(struct device *dev) 152 { 153 struct clk **clks; 154 unsigned int i, count; 155 int ret; 156 157 if (!dev || !dev->of_node) 158 return -EINVAL; 159 160 count = of_count_phandle_with_args(dev->of_node, "clocks", 161 "#clock-cells"); 162 if (count <= 0) 163 return -ENODEV; 164 165 clks = kcalloc(count, sizeof(*clks), GFP_KERNEL); 166 if (!clks) 167 return -ENOMEM; 168 169 for (i = 0; i < count; i++) { 170 clks[i] = of_clk_get(dev->of_node, i); 171 if (IS_ERR(clks[i])) { 172 ret = PTR_ERR(clks[i]); 173 goto error; 174 } 175 176 ret = pm_clk_add_clk(dev, clks[i]); 177 if (ret) { 178 clk_put(clks[i]); 179 goto error; 180 } 181 } 182 183 kfree(clks); 184 185 return i; 186 187 error: 188 while (i--) 189 pm_clk_remove_clk(dev, clks[i]); 190 191 kfree(clks); 192 193 return ret; 194 } 195 196 /** 197 * __pm_clk_remove - Destroy PM clock entry. 198 * @ce: PM clock entry to destroy. 199 */ 200 static void __pm_clk_remove(struct pm_clock_entry *ce) 201 { 202 if (!ce) 203 return; 204 205 if (ce->status < PCE_STATUS_ERROR) { 206 if (ce->status == PCE_STATUS_ENABLED) 207 clk_disable(ce->clk); 208 209 if (ce->status >= PCE_STATUS_ACQUIRED) { 210 clk_unprepare(ce->clk); 211 clk_put(ce->clk); 212 } 213 } 214 215 kfree(ce->con_id); 216 kfree(ce); 217 } 218 219 /** 220 * pm_clk_remove - Stop using a device clock for power management. 221 * @dev: Device whose clock should not be used for PM any more. 222 * @con_id: Connection ID of the clock. 223 * 224 * Remove the clock represented by @con_id from the list of clocks used for 225 * the power management of @dev. 226 */ 227 void pm_clk_remove(struct device *dev, const char *con_id) 228 { 229 struct pm_subsys_data *psd = dev_to_psd(dev); 230 struct pm_clock_entry *ce; 231 232 if (!psd) 233 return; 234 235 spin_lock_irq(&psd->lock); 236 237 list_for_each_entry(ce, &psd->clock_list, node) { 238 if (!con_id && !ce->con_id) 239 goto remove; 240 else if (!con_id || !ce->con_id) 241 continue; 242 else if (!strcmp(con_id, ce->con_id)) 243 goto remove; 244 } 245 246 spin_unlock_irq(&psd->lock); 247 return; 248 249 remove: 250 list_del(&ce->node); 251 spin_unlock_irq(&psd->lock); 252 253 __pm_clk_remove(ce); 254 } 255 256 /** 257 * pm_clk_remove_clk - Stop using a device clock for power management. 258 * @dev: Device whose clock should not be used for PM any more. 259 * @clk: Clock pointer 260 * 261 * Remove the clock pointed to by @clk from the list of clocks used for 262 * the power management of @dev. 263 */ 264 void pm_clk_remove_clk(struct device *dev, struct clk *clk) 265 { 266 struct pm_subsys_data *psd = dev_to_psd(dev); 267 struct pm_clock_entry *ce; 268 269 if (!psd || !clk) 270 return; 271 272 spin_lock_irq(&psd->lock); 273 274 list_for_each_entry(ce, &psd->clock_list, node) { 275 if (clk == ce->clk) 276 goto remove; 277 } 278 279 spin_unlock_irq(&psd->lock); 280 return; 281 282 remove: 283 list_del(&ce->node); 284 spin_unlock_irq(&psd->lock); 285 286 __pm_clk_remove(ce); 287 } 288 289 /** 290 * pm_clk_init - Initialize a device's list of power management clocks. 291 * @dev: Device to initialize the list of PM clocks for. 292 * 293 * Initialize the lock and clock_list members of the device's pm_subsys_data 294 * object. 295 */ 296 void pm_clk_init(struct device *dev) 297 { 298 struct pm_subsys_data *psd = dev_to_psd(dev); 299 if (psd) 300 INIT_LIST_HEAD(&psd->clock_list); 301 } 302 303 /** 304 * pm_clk_create - Create and initialize a device's list of PM clocks. 305 * @dev: Device to create and initialize the list of PM clocks for. 306 * 307 * Allocate a struct pm_subsys_data object, initialize its lock and clock_list 308 * members and make the @dev's power.subsys_data field point to it. 309 */ 310 int pm_clk_create(struct device *dev) 311 { 312 return dev_pm_get_subsys_data(dev); 313 } 314 315 /** 316 * pm_clk_destroy - Destroy a device's list of power management clocks. 317 * @dev: Device to destroy the list of PM clocks for. 318 * 319 * Clear the @dev's power.subsys_data field, remove the list of clock entries 320 * from the struct pm_subsys_data object pointed to by it before and free 321 * that object. 322 */ 323 void pm_clk_destroy(struct device *dev) 324 { 325 struct pm_subsys_data *psd = dev_to_psd(dev); 326 struct pm_clock_entry *ce, *c; 327 struct list_head list; 328 329 if (!psd) 330 return; 331 332 INIT_LIST_HEAD(&list); 333 334 spin_lock_irq(&psd->lock); 335 336 list_for_each_entry_safe_reverse(ce, c, &psd->clock_list, node) 337 list_move(&ce->node, &list); 338 339 spin_unlock_irq(&psd->lock); 340 341 dev_pm_put_subsys_data(dev); 342 343 list_for_each_entry_safe_reverse(ce, c, &list, node) { 344 list_del(&ce->node); 345 __pm_clk_remove(ce); 346 } 347 } 348 349 /** 350 * pm_clk_suspend - Disable clocks in a device's PM clock list. 351 * @dev: Device to disable the clocks for. 352 */ 353 int pm_clk_suspend(struct device *dev) 354 { 355 struct pm_subsys_data *psd = dev_to_psd(dev); 356 struct pm_clock_entry *ce; 357 unsigned long flags; 358 359 dev_dbg(dev, "%s()\n", __func__); 360 361 if (!psd) 362 return 0; 363 364 spin_lock_irqsave(&psd->lock, flags); 365 366 list_for_each_entry_reverse(ce, &psd->clock_list, node) { 367 if (ce->status < PCE_STATUS_ERROR) { 368 if (ce->status == PCE_STATUS_ENABLED) 369 clk_disable(ce->clk); 370 ce->status = PCE_STATUS_ACQUIRED; 371 } 372 } 373 374 spin_unlock_irqrestore(&psd->lock, flags); 375 376 return 0; 377 } 378 379 /** 380 * pm_clk_resume - Enable clocks in a device's PM clock list. 381 * @dev: Device to enable the clocks for. 382 */ 383 int pm_clk_resume(struct device *dev) 384 { 385 struct pm_subsys_data *psd = dev_to_psd(dev); 386 struct pm_clock_entry *ce; 387 unsigned long flags; 388 389 dev_dbg(dev, "%s()\n", __func__); 390 391 if (!psd) 392 return 0; 393 394 spin_lock_irqsave(&psd->lock, flags); 395 396 list_for_each_entry(ce, &psd->clock_list, node) 397 __pm_clk_enable(dev, ce); 398 399 spin_unlock_irqrestore(&psd->lock, flags); 400 401 return 0; 402 } 403 404 /** 405 * pm_clk_notify - Notify routine for device addition and removal. 406 * @nb: Notifier block object this function is a member of. 407 * @action: Operation being carried out by the caller. 408 * @data: Device the routine is being run for. 409 * 410 * For this function to work, @nb must be a member of an object of type 411 * struct pm_clk_notifier_block containing all of the requisite data. 412 * Specifically, the pm_domain member of that object is copied to the device's 413 * pm_domain field and its con_ids member is used to populate the device's list 414 * of PM clocks, depending on @action. 415 * 416 * If the device's pm_domain field is already populated with a value different 417 * from the one stored in the struct pm_clk_notifier_block object, the function 418 * does nothing. 419 */ 420 static int pm_clk_notify(struct notifier_block *nb, 421 unsigned long action, void *data) 422 { 423 struct pm_clk_notifier_block *clknb; 424 struct device *dev = data; 425 char **con_id; 426 int error; 427 428 dev_dbg(dev, "%s() %ld\n", __func__, action); 429 430 clknb = container_of(nb, struct pm_clk_notifier_block, nb); 431 432 switch (action) { 433 case BUS_NOTIFY_ADD_DEVICE: 434 if (dev->pm_domain) 435 break; 436 437 error = pm_clk_create(dev); 438 if (error) 439 break; 440 441 dev_pm_domain_set(dev, clknb->pm_domain); 442 if (clknb->con_ids[0]) { 443 for (con_id = clknb->con_ids; *con_id; con_id++) 444 pm_clk_add(dev, *con_id); 445 } else { 446 pm_clk_add(dev, NULL); 447 } 448 449 break; 450 case BUS_NOTIFY_DEL_DEVICE: 451 if (dev->pm_domain != clknb->pm_domain) 452 break; 453 454 dev_pm_domain_set(dev, NULL); 455 pm_clk_destroy(dev); 456 break; 457 } 458 459 return 0; 460 } 461 462 int pm_clk_runtime_suspend(struct device *dev) 463 { 464 int ret; 465 466 dev_dbg(dev, "%s\n", __func__); 467 468 ret = pm_generic_runtime_suspend(dev); 469 if (ret) { 470 dev_err(dev, "failed to suspend device\n"); 471 return ret; 472 } 473 474 ret = pm_clk_suspend(dev); 475 if (ret) { 476 dev_err(dev, "failed to suspend clock\n"); 477 pm_generic_runtime_resume(dev); 478 return ret; 479 } 480 481 return 0; 482 } 483 484 int pm_clk_runtime_resume(struct device *dev) 485 { 486 int ret; 487 488 dev_dbg(dev, "%s\n", __func__); 489 490 ret = pm_clk_resume(dev); 491 if (ret) { 492 dev_err(dev, "failed to resume clock\n"); 493 return ret; 494 } 495 496 return pm_generic_runtime_resume(dev); 497 } 498 499 #else /* !CONFIG_PM_CLK */ 500 501 /** 502 * enable_clock - Enable a device clock. 503 * @dev: Device whose clock is to be enabled. 504 * @con_id: Connection ID of the clock. 505 */ 506 static void enable_clock(struct device *dev, const char *con_id) 507 { 508 struct clk *clk; 509 510 clk = clk_get(dev, con_id); 511 if (!IS_ERR(clk)) { 512 clk_prepare_enable(clk); 513 clk_put(clk); 514 dev_info(dev, "Runtime PM disabled, clock forced on.\n"); 515 } 516 } 517 518 /** 519 * disable_clock - Disable a device clock. 520 * @dev: Device whose clock is to be disabled. 521 * @con_id: Connection ID of the clock. 522 */ 523 static void disable_clock(struct device *dev, const char *con_id) 524 { 525 struct clk *clk; 526 527 clk = clk_get(dev, con_id); 528 if (!IS_ERR(clk)) { 529 clk_disable_unprepare(clk); 530 clk_put(clk); 531 dev_info(dev, "Runtime PM disabled, clock forced off.\n"); 532 } 533 } 534 535 /** 536 * pm_clk_notify - Notify routine for device addition and removal. 537 * @nb: Notifier block object this function is a member of. 538 * @action: Operation being carried out by the caller. 539 * @data: Device the routine is being run for. 540 * 541 * For this function to work, @nb must be a member of an object of type 542 * struct pm_clk_notifier_block containing all of the requisite data. 543 * Specifically, the con_ids member of that object is used to enable or disable 544 * the device's clocks, depending on @action. 545 */ 546 static int pm_clk_notify(struct notifier_block *nb, 547 unsigned long action, void *data) 548 { 549 struct pm_clk_notifier_block *clknb; 550 struct device *dev = data; 551 char **con_id; 552 553 dev_dbg(dev, "%s() %ld\n", __func__, action); 554 555 clknb = container_of(nb, struct pm_clk_notifier_block, nb); 556 557 switch (action) { 558 case BUS_NOTIFY_BIND_DRIVER: 559 if (clknb->con_ids[0]) { 560 for (con_id = clknb->con_ids; *con_id; con_id++) 561 enable_clock(dev, *con_id); 562 } else { 563 enable_clock(dev, NULL); 564 } 565 break; 566 case BUS_NOTIFY_DRIVER_NOT_BOUND: 567 case BUS_NOTIFY_UNBOUND_DRIVER: 568 if (clknb->con_ids[0]) { 569 for (con_id = clknb->con_ids; *con_id; con_id++) 570 disable_clock(dev, *con_id); 571 } else { 572 disable_clock(dev, NULL); 573 } 574 break; 575 } 576 577 return 0; 578 } 579 580 #endif /* !CONFIG_PM_CLK */ 581 582 /** 583 * pm_clk_add_notifier - Add bus type notifier for power management clocks. 584 * @bus: Bus type to add the notifier to. 585 * @clknb: Notifier to be added to the given bus type. 586 * 587 * The nb member of @clknb is not expected to be initialized and its 588 * notifier_call member will be replaced with pm_clk_notify(). However, 589 * the remaining members of @clknb should be populated prior to calling this 590 * routine. 591 */ 592 void pm_clk_add_notifier(struct bus_type *bus, 593 struct pm_clk_notifier_block *clknb) 594 { 595 if (!bus || !clknb) 596 return; 597 598 clknb->nb.notifier_call = pm_clk_notify; 599 bus_register_notifier(bus, &clknb->nb); 600 } 601