1/* 2 * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework 3 * for Non-CPU Devices. 4 * 5 * Copyright (C) 2011 Samsung Electronics 6 * MyungJoo Ham <myungjoo.ham@samsung.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13#include <linux/kernel.h> 14#include <linux/sched.h> 15#include <linux/errno.h> 16#include <linux/err.h> 17#include <linux/init.h> 18#include <linux/module.h> 19#include <linux/slab.h> 20#include <linux/stat.h> 21#include <linux/pm_opp.h> 22#include <linux/devfreq.h> 23#include <linux/workqueue.h> 24#include <linux/platform_device.h> 25#include <linux/list.h> 26#include <linux/printk.h> 27#include <linux/hrtimer.h> 28#include "governor.h" 29 30static struct class *devfreq_class; 31 32/* 33 * devfreq core provides delayed work based load monitoring helper 34 * functions. Governors can use these or can implement their own 35 * monitoring mechanism. 36 */ 37static struct workqueue_struct *devfreq_wq; 38 39/* The list of all device-devfreq governors */ 40static LIST_HEAD(devfreq_governor_list); 41/* The list of all device-devfreq */ 42static LIST_HEAD(devfreq_list); 43static DEFINE_MUTEX(devfreq_list_lock); 44 45/** 46 * find_device_devfreq() - find devfreq struct using device pointer 47 * @dev: device pointer used to lookup device devfreq. 48 * 49 * Search the list of device devfreqs and return the matched device's 50 * devfreq info. devfreq_list_lock should be held by the caller. 51 */ 52static struct devfreq *find_device_devfreq(struct device *dev) 53{ 54 struct devfreq *tmp_devfreq; 55 56 if (unlikely(IS_ERR_OR_NULL(dev))) { 57 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__); 58 return ERR_PTR(-EINVAL); 59 } 60 WARN(!mutex_is_locked(&devfreq_list_lock), 61 "devfreq_list_lock must be locked."); 62 63 list_for_each_entry(tmp_devfreq, &devfreq_list, node) { 64 if (tmp_devfreq->dev.parent == dev) 65 return tmp_devfreq; 66 } 67 68 return ERR_PTR(-ENODEV); 69} 70 71/** 72 * devfreq_get_freq_level() - Lookup freq_table for the frequency 73 * @devfreq: the devfreq instance 74 * @freq: the target frequency 75 */ 76static int devfreq_get_freq_level(struct devfreq *devfreq, unsigned long freq) 77{ 78 int lev; 79 80 for (lev = 0; lev < devfreq->profile->max_state; lev++) 81 if (freq == devfreq->profile->freq_table[lev]) 82 return lev; 83 84 return -EINVAL; 85} 86 87/** 88 * devfreq_update_status() - Update statistics of devfreq behavior 89 * @devfreq: the devfreq instance 90 * @freq: the update target frequency 91 */ 92static int devfreq_update_status(struct devfreq *devfreq, unsigned long freq) 93{ 94 int lev, prev_lev, ret = 0; 95 unsigned long cur_time; 96 97 cur_time = jiffies; 98 99 prev_lev = devfreq_get_freq_level(devfreq, devfreq->previous_freq); 100 if (prev_lev < 0) { 101 ret = prev_lev; 102 goto out; 103 } 104 105 devfreq->time_in_state[prev_lev] += 106 cur_time - devfreq->last_stat_updated; 107 108 lev = devfreq_get_freq_level(devfreq, freq); 109 if (lev < 0) { 110 ret = lev; 111 goto out; 112 } 113 114 if (lev != prev_lev) { 115 devfreq->trans_table[(prev_lev * 116 devfreq->profile->max_state) + lev]++; 117 devfreq->total_trans++; 118 } 119 120out: 121 devfreq->last_stat_updated = cur_time; 122 return ret; 123} 124 125/** 126 * find_devfreq_governor() - find devfreq governor from name 127 * @name: name of the governor 128 * 129 * Search the list of devfreq governors and return the matched 130 * governor's pointer. devfreq_list_lock should be held by the caller. 131 */ 132static struct devfreq_governor *find_devfreq_governor(const char *name) 133{ 134 struct devfreq_governor *tmp_governor; 135 136 if (unlikely(IS_ERR_OR_NULL(name))) { 137 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__); 138 return ERR_PTR(-EINVAL); 139 } 140 WARN(!mutex_is_locked(&devfreq_list_lock), 141 "devfreq_list_lock must be locked."); 142 143 list_for_each_entry(tmp_governor, &devfreq_governor_list, node) { 144 if (!strncmp(tmp_governor->name, name, DEVFREQ_NAME_LEN)) 145 return tmp_governor; 146 } 147 148 return ERR_PTR(-ENODEV); 149} 150 151/* Load monitoring helper functions for governors use */ 152 153/** 154 * update_devfreq() - Reevaluate the device and configure frequency. 155 * @devfreq: the devfreq instance. 156 * 157 * Note: Lock devfreq->lock before calling update_devfreq 158 * This function is exported for governors. 159 */ 160int update_devfreq(struct devfreq *devfreq) 161{ 162 unsigned long freq; 163 int err = 0; 164 u32 flags = 0; 165 166 if (!mutex_is_locked(&devfreq->lock)) { 167 WARN(true, "devfreq->lock must be locked by the caller.\n"); 168 return -EINVAL; 169 } 170 171 if (!devfreq->governor) 172 return -EINVAL; 173 174 /* Reevaluate the proper frequency */ 175 err = devfreq->governor->get_target_freq(devfreq, &freq); 176 if (err) 177 return err; 178 179 /* 180 * Adjust the freuqency with user freq and QoS. 181 * 182 * List from the highest proiority 183 * max_freq (probably called by thermal when it's too hot) 184 * min_freq 185 */ 186 187 if (devfreq->min_freq && freq < devfreq->min_freq) { 188 freq = devfreq->min_freq; 189 flags &= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use GLB */ 190 } 191 if (devfreq->max_freq && freq > devfreq->max_freq) { 192 freq = devfreq->max_freq; 193 flags |= DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use LUB */ 194 } 195 196 err = devfreq->profile->target(devfreq->dev.parent, &freq, flags); 197 if (err) 198 return err; 199 200 if (devfreq->profile->freq_table) 201 if (devfreq_update_status(devfreq, freq)) 202 dev_err(&devfreq->dev, 203 "Couldn't update frequency transition information.\n"); 204 205 devfreq->previous_freq = freq; 206 return err; 207} 208EXPORT_SYMBOL(update_devfreq); 209 210/** 211 * devfreq_monitor() - Periodically poll devfreq objects. 212 * @work: the work struct used to run devfreq_monitor periodically. 213 * 214 */ 215static void devfreq_monitor(struct work_struct *work) 216{ 217 int err; 218 struct devfreq *devfreq = container_of(work, 219 struct devfreq, work.work); 220 221 mutex_lock(&devfreq->lock); 222 err = update_devfreq(devfreq); 223 if (err) 224 dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err); 225 226 queue_delayed_work(devfreq_wq, &devfreq->work, 227 msecs_to_jiffies(devfreq->profile->polling_ms)); 228 mutex_unlock(&devfreq->lock); 229} 230 231/** 232 * devfreq_monitor_start() - Start load monitoring of devfreq instance 233 * @devfreq: the devfreq instance. 234 * 235 * Helper function for starting devfreq device load monitoing. By 236 * default delayed work based monitoring is supported. Function 237 * to be called from governor in response to DEVFREQ_GOV_START 238 * event when device is added to devfreq framework. 239 */ 240void devfreq_monitor_start(struct devfreq *devfreq) 241{ 242 INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor); 243 if (devfreq->profile->polling_ms) 244 queue_delayed_work(devfreq_wq, &devfreq->work, 245 msecs_to_jiffies(devfreq->profile->polling_ms)); 246} 247EXPORT_SYMBOL(devfreq_monitor_start); 248 249/** 250 * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance 251 * @devfreq: the devfreq instance. 252 * 253 * Helper function to stop devfreq device load monitoing. Function 254 * to be called from governor in response to DEVFREQ_GOV_STOP 255 * event when device is removed from devfreq framework. 256 */ 257void devfreq_monitor_stop(struct devfreq *devfreq) 258{ 259 cancel_delayed_work_sync(&devfreq->work); 260} 261EXPORT_SYMBOL(devfreq_monitor_stop); 262 263/** 264 * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance 265 * @devfreq: the devfreq instance. 266 * 267 * Helper function to suspend devfreq device load monitoing. Function 268 * to be called from governor in response to DEVFREQ_GOV_SUSPEND 269 * event or when polling interval is set to zero. 270 * 271 * Note: Though this function is same as devfreq_monitor_stop(), 272 * intentionally kept separate to provide hooks for collecting 273 * transition statistics. 274 */ 275void devfreq_monitor_suspend(struct devfreq *devfreq) 276{ 277 mutex_lock(&devfreq->lock); 278 if (devfreq->stop_polling) { 279 mutex_unlock(&devfreq->lock); 280 return; 281 } 282 283 devfreq_update_status(devfreq, devfreq->previous_freq); 284 devfreq->stop_polling = true; 285 mutex_unlock(&devfreq->lock); 286 cancel_delayed_work_sync(&devfreq->work); 287} 288EXPORT_SYMBOL(devfreq_monitor_suspend); 289 290/** 291 * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance 292 * @devfreq: the devfreq instance. 293 * 294 * Helper function to resume devfreq device load monitoing. Function 295 * to be called from governor in response to DEVFREQ_GOV_RESUME 296 * event or when polling interval is set to non-zero. 297 */ 298void devfreq_monitor_resume(struct devfreq *devfreq) 299{ 300 unsigned long freq; 301 302 mutex_lock(&devfreq->lock); 303 if (!devfreq->stop_polling) 304 goto out; 305 306 if (!delayed_work_pending(&devfreq->work) && 307 devfreq->profile->polling_ms) 308 queue_delayed_work(devfreq_wq, &devfreq->work, 309 msecs_to_jiffies(devfreq->profile->polling_ms)); 310 311 devfreq->last_stat_updated = jiffies; 312 devfreq->stop_polling = false; 313 314 if (devfreq->profile->get_cur_freq && 315 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq)) 316 devfreq->previous_freq = freq; 317 318out: 319 mutex_unlock(&devfreq->lock); 320} 321EXPORT_SYMBOL(devfreq_monitor_resume); 322 323/** 324 * devfreq_interval_update() - Update device devfreq monitoring interval 325 * @devfreq: the devfreq instance. 326 * @delay: new polling interval to be set. 327 * 328 * Helper function to set new load monitoring polling interval. Function 329 * to be called from governor in response to DEVFREQ_GOV_INTERVAL event. 330 */ 331void devfreq_interval_update(struct devfreq *devfreq, unsigned int *delay) 332{ 333 unsigned int cur_delay = devfreq->profile->polling_ms; 334 unsigned int new_delay = *delay; 335 336 mutex_lock(&devfreq->lock); 337 devfreq->profile->polling_ms = new_delay; 338 339 if (devfreq->stop_polling) 340 goto out; 341 342 /* if new delay is zero, stop polling */ 343 if (!new_delay) { 344 mutex_unlock(&devfreq->lock); 345 cancel_delayed_work_sync(&devfreq->work); 346 return; 347 } 348 349 /* if current delay is zero, start polling with new delay */ 350 if (!cur_delay) { 351 queue_delayed_work(devfreq_wq, &devfreq->work, 352 msecs_to_jiffies(devfreq->profile->polling_ms)); 353 goto out; 354 } 355 356 /* if current delay is greater than new delay, restart polling */ 357 if (cur_delay > new_delay) { 358 mutex_unlock(&devfreq->lock); 359 cancel_delayed_work_sync(&devfreq->work); 360 mutex_lock(&devfreq->lock); 361 if (!devfreq->stop_polling) 362 queue_delayed_work(devfreq_wq, &devfreq->work, 363 msecs_to_jiffies(devfreq->profile->polling_ms)); 364 } 365out: 366 mutex_unlock(&devfreq->lock); 367} 368EXPORT_SYMBOL(devfreq_interval_update); 369 370/** 371 * devfreq_notifier_call() - Notify that the device frequency requirements 372 * has been changed out of devfreq framework. 373 * @nb: the notifier_block (supposed to be devfreq->nb) 374 * @type: not used 375 * @devp: not used 376 * 377 * Called by a notifier that uses devfreq->nb. 378 */ 379static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type, 380 void *devp) 381{ 382 struct devfreq *devfreq = container_of(nb, struct devfreq, nb); 383 int ret; 384 385 mutex_lock(&devfreq->lock); 386 ret = update_devfreq(devfreq); 387 mutex_unlock(&devfreq->lock); 388 389 return ret; 390} 391 392/** 393 * _remove_devfreq() - Remove devfreq from the list and release its resources. 394 * @devfreq: the devfreq struct 395 */ 396static void _remove_devfreq(struct devfreq *devfreq) 397{ 398 mutex_lock(&devfreq_list_lock); 399 if (IS_ERR(find_device_devfreq(devfreq->dev.parent))) { 400 mutex_unlock(&devfreq_list_lock); 401 dev_warn(&devfreq->dev, "releasing devfreq which doesn't exist\n"); 402 return; 403 } 404 list_del(&devfreq->node); 405 mutex_unlock(&devfreq_list_lock); 406 407 if (devfreq->governor) 408 devfreq->governor->event_handler(devfreq, 409 DEVFREQ_GOV_STOP, NULL); 410 411 if (devfreq->profile->exit) 412 devfreq->profile->exit(devfreq->dev.parent); 413 414 mutex_destroy(&devfreq->lock); 415 kfree(devfreq); 416} 417 418/** 419 * devfreq_dev_release() - Callback for struct device to release the device. 420 * @dev: the devfreq device 421 * 422 * This calls _remove_devfreq() if _remove_devfreq() is not called. 423 */ 424static void devfreq_dev_release(struct device *dev) 425{ 426 struct devfreq *devfreq = to_devfreq(dev); 427 428 _remove_devfreq(devfreq); 429} 430 431/** 432 * devfreq_add_device() - Add devfreq feature to the device 433 * @dev: the device to add devfreq feature. 434 * @profile: device-specific profile to run devfreq. 435 * @governor_name: name of the policy to choose frequency. 436 * @data: private data for the governor. The devfreq framework does not 437 * touch this value. 438 */ 439struct devfreq *devfreq_add_device(struct device *dev, 440 struct devfreq_dev_profile *profile, 441 const char *governor_name, 442 void *data) 443{ 444 struct devfreq *devfreq; 445 struct devfreq_governor *governor; 446 int err = 0; 447 448 if (!dev || !profile || !governor_name) { 449 dev_err(dev, "%s: Invalid parameters.\n", __func__); 450 return ERR_PTR(-EINVAL); 451 } 452 453 mutex_lock(&devfreq_list_lock); 454 devfreq = find_device_devfreq(dev); 455 mutex_unlock(&devfreq_list_lock); 456 if (!IS_ERR(devfreq)) { 457 dev_err(dev, "%s: Unable to create devfreq for the device. It already has one.\n", __func__); 458 err = -EINVAL; 459 goto err_out; 460 } 461 462 devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL); 463 if (!devfreq) { 464 dev_err(dev, "%s: Unable to create devfreq for the device\n", 465 __func__); 466 err = -ENOMEM; 467 goto err_out; 468 } 469 470 mutex_init(&devfreq->lock); 471 mutex_lock(&devfreq->lock); 472 devfreq->dev.parent = dev; 473 devfreq->dev.class = devfreq_class; 474 devfreq->dev.release = devfreq_dev_release; 475 devfreq->profile = profile; 476 strncpy(devfreq->governor_name, governor_name, DEVFREQ_NAME_LEN); 477 devfreq->previous_freq = profile->initial_freq; 478 devfreq->data = data; 479 devfreq->nb.notifier_call = devfreq_notifier_call; 480 481 devfreq->trans_table = devm_kzalloc(dev, sizeof(unsigned int) * 482 devfreq->profile->max_state * 483 devfreq->profile->max_state, 484 GFP_KERNEL); 485 devfreq->time_in_state = devm_kzalloc(dev, sizeof(unsigned int) * 486 devfreq->profile->max_state, 487 GFP_KERNEL); 488 devfreq->last_stat_updated = jiffies; 489 490 dev_set_name(&devfreq->dev, "%s", dev_name(dev)); 491 err = device_register(&devfreq->dev); 492 if (err) { 493 put_device(&devfreq->dev); 494 mutex_unlock(&devfreq->lock); 495 goto err_dev; 496 } 497 498 mutex_unlock(&devfreq->lock); 499 500 mutex_lock(&devfreq_list_lock); 501 list_add(&devfreq->node, &devfreq_list); 502 503 governor = find_devfreq_governor(devfreq->governor_name); 504 if (!IS_ERR(governor)) 505 devfreq->governor = governor; 506 if (devfreq->governor) 507 err = devfreq->governor->event_handler(devfreq, 508 DEVFREQ_GOV_START, NULL); 509 mutex_unlock(&devfreq_list_lock); 510 if (err) { 511 dev_err(dev, "%s: Unable to start governor for the device\n", 512 __func__); 513 goto err_init; 514 } 515 516 return devfreq; 517 518err_init: 519 list_del(&devfreq->node); 520 device_unregister(&devfreq->dev); 521err_dev: 522 kfree(devfreq); 523err_out: 524 return ERR_PTR(err); 525} 526EXPORT_SYMBOL(devfreq_add_device); 527 528/** 529 * devfreq_remove_device() - Remove devfreq feature from a device. 530 * @devfreq: the devfreq instance to be removed 531 * 532 * The opposite of devfreq_add_device(). 533 */ 534int devfreq_remove_device(struct devfreq *devfreq) 535{ 536 if (!devfreq) 537 return -EINVAL; 538 539 device_unregister(&devfreq->dev); 540 put_device(&devfreq->dev); 541 542 return 0; 543} 544EXPORT_SYMBOL(devfreq_remove_device); 545 546static int devm_devfreq_dev_match(struct device *dev, void *res, void *data) 547{ 548 struct devfreq **r = res; 549 550 if (WARN_ON(!r || !*r)) 551 return 0; 552 553 return *r == data; 554} 555 556static void devm_devfreq_dev_release(struct device *dev, void *res) 557{ 558 devfreq_remove_device(*(struct devfreq **)res); 559} 560 561/** 562 * devm_devfreq_add_device() - Resource-managed devfreq_add_device() 563 * @dev: the device to add devfreq feature. 564 * @profile: device-specific profile to run devfreq. 565 * @governor_name: name of the policy to choose frequency. 566 * @data: private data for the governor. The devfreq framework does not 567 * touch this value. 568 * 569 * This function manages automatically the memory of devfreq device using device 570 * resource management and simplify the free operation for memory of devfreq 571 * device. 572 */ 573struct devfreq *devm_devfreq_add_device(struct device *dev, 574 struct devfreq_dev_profile *profile, 575 const char *governor_name, 576 void *data) 577{ 578 struct devfreq **ptr, *devfreq; 579 580 ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL); 581 if (!ptr) 582 return ERR_PTR(-ENOMEM); 583 584 devfreq = devfreq_add_device(dev, profile, governor_name, data); 585 if (IS_ERR(devfreq)) { 586 devres_free(ptr); 587 return ERR_PTR(-ENOMEM); 588 } 589 590 *ptr = devfreq; 591 devres_add(dev, ptr); 592 593 return devfreq; 594} 595EXPORT_SYMBOL(devm_devfreq_add_device); 596 597/** 598 * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device() 599 * @dev: the device to add devfreq feature. 600 * @devfreq: the devfreq instance to be removed 601 */ 602void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq) 603{ 604 WARN_ON(devres_release(dev, devm_devfreq_dev_release, 605 devm_devfreq_dev_match, devfreq)); 606} 607EXPORT_SYMBOL(devm_devfreq_remove_device); 608 609/** 610 * devfreq_suspend_device() - Suspend devfreq of a device. 611 * @devfreq: the devfreq instance to be suspended 612 * 613 * This function is intended to be called by the pm callbacks 614 * (e.g., runtime_suspend, suspend) of the device driver that 615 * holds the devfreq. 616 */ 617int devfreq_suspend_device(struct devfreq *devfreq) 618{ 619 if (!devfreq) 620 return -EINVAL; 621 622 if (!devfreq->governor) 623 return 0; 624 625 return devfreq->governor->event_handler(devfreq, 626 DEVFREQ_GOV_SUSPEND, NULL); 627} 628EXPORT_SYMBOL(devfreq_suspend_device); 629 630/** 631 * devfreq_resume_device() - Resume devfreq of a device. 632 * @devfreq: the devfreq instance to be resumed 633 * 634 * This function is intended to be called by the pm callbacks 635 * (e.g., runtime_resume, resume) of the device driver that 636 * holds the devfreq. 637 */ 638int devfreq_resume_device(struct devfreq *devfreq) 639{ 640 if (!devfreq) 641 return -EINVAL; 642 643 if (!devfreq->governor) 644 return 0; 645 646 return devfreq->governor->event_handler(devfreq, 647 DEVFREQ_GOV_RESUME, NULL); 648} 649EXPORT_SYMBOL(devfreq_resume_device); 650 651/** 652 * devfreq_add_governor() - Add devfreq governor 653 * @governor: the devfreq governor to be added 654 */ 655int devfreq_add_governor(struct devfreq_governor *governor) 656{ 657 struct devfreq_governor *g; 658 struct devfreq *devfreq; 659 int err = 0; 660 661 if (!governor) { 662 pr_err("%s: Invalid parameters.\n", __func__); 663 return -EINVAL; 664 } 665 666 mutex_lock(&devfreq_list_lock); 667 g = find_devfreq_governor(governor->name); 668 if (!IS_ERR(g)) { 669 pr_err("%s: governor %s already registered\n", __func__, 670 g->name); 671 err = -EINVAL; 672 goto err_out; 673 } 674 675 list_add(&governor->node, &devfreq_governor_list); 676 677 list_for_each_entry(devfreq, &devfreq_list, node) { 678 int ret = 0; 679 struct device *dev = devfreq->dev.parent; 680 681 if (!strncmp(devfreq->governor_name, governor->name, 682 DEVFREQ_NAME_LEN)) { 683 /* The following should never occur */ 684 if (devfreq->governor) { 685 dev_warn(dev, 686 "%s: Governor %s already present\n", 687 __func__, devfreq->governor->name); 688 ret = devfreq->governor->event_handler(devfreq, 689 DEVFREQ_GOV_STOP, NULL); 690 if (ret) { 691 dev_warn(dev, 692 "%s: Governor %s stop = %d\n", 693 __func__, 694 devfreq->governor->name, ret); 695 } 696 /* Fall through */ 697 } 698 devfreq->governor = governor; 699 ret = devfreq->governor->event_handler(devfreq, 700 DEVFREQ_GOV_START, NULL); 701 if (ret) { 702 dev_warn(dev, "%s: Governor %s start=%d\n", 703 __func__, devfreq->governor->name, 704 ret); 705 } 706 } 707 } 708 709err_out: 710 mutex_unlock(&devfreq_list_lock); 711 712 return err; 713} 714EXPORT_SYMBOL(devfreq_add_governor); 715 716/** 717 * devfreq_remove_device() - Remove devfreq feature from a device. 718 * @governor: the devfreq governor to be removed 719 */ 720int devfreq_remove_governor(struct devfreq_governor *governor) 721{ 722 struct devfreq_governor *g; 723 struct devfreq *devfreq; 724 int err = 0; 725 726 if (!governor) { 727 pr_err("%s: Invalid parameters.\n", __func__); 728 return -EINVAL; 729 } 730 731 mutex_lock(&devfreq_list_lock); 732 g = find_devfreq_governor(governor->name); 733 if (IS_ERR(g)) { 734 pr_err("%s: governor %s not registered\n", __func__, 735 governor->name); 736 err = PTR_ERR(g); 737 goto err_out; 738 } 739 list_for_each_entry(devfreq, &devfreq_list, node) { 740 int ret; 741 struct device *dev = devfreq->dev.parent; 742 743 if (!strncmp(devfreq->governor_name, governor->name, 744 DEVFREQ_NAME_LEN)) { 745 /* we should have a devfreq governor! */ 746 if (!devfreq->governor) { 747 dev_warn(dev, "%s: Governor %s NOT present\n", 748 __func__, governor->name); 749 continue; 750 /* Fall through */ 751 } 752 ret = devfreq->governor->event_handler(devfreq, 753 DEVFREQ_GOV_STOP, NULL); 754 if (ret) { 755 dev_warn(dev, "%s: Governor %s stop=%d\n", 756 __func__, devfreq->governor->name, 757 ret); 758 } 759 devfreq->governor = NULL; 760 } 761 } 762 763 list_del(&governor->node); 764err_out: 765 mutex_unlock(&devfreq_list_lock); 766 767 return err; 768} 769EXPORT_SYMBOL(devfreq_remove_governor); 770 771static ssize_t governor_show(struct device *dev, 772 struct device_attribute *attr, char *buf) 773{ 774 if (!to_devfreq(dev)->governor) 775 return -EINVAL; 776 777 return sprintf(buf, "%s\n", to_devfreq(dev)->governor->name); 778} 779 780static ssize_t governor_store(struct device *dev, struct device_attribute *attr, 781 const char *buf, size_t count) 782{ 783 struct devfreq *df = to_devfreq(dev); 784 int ret; 785 char str_governor[DEVFREQ_NAME_LEN + 1]; 786 struct devfreq_governor *governor; 787 788 ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor); 789 if (ret != 1) 790 return -EINVAL; 791 792 mutex_lock(&devfreq_list_lock); 793 governor = find_devfreq_governor(str_governor); 794 if (IS_ERR(governor)) { 795 ret = PTR_ERR(governor); 796 goto out; 797 } 798 if (df->governor == governor) 799 goto out; 800 801 if (df->governor) { 802 ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL); 803 if (ret) { 804 dev_warn(dev, "%s: Governor %s not stopped(%d)\n", 805 __func__, df->governor->name, ret); 806 goto out; 807 } 808 } 809 df->governor = governor; 810 strncpy(df->governor_name, governor->name, DEVFREQ_NAME_LEN); 811 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL); 812 if (ret) 813 dev_warn(dev, "%s: Governor %s not started(%d)\n", 814 __func__, df->governor->name, ret); 815out: 816 mutex_unlock(&devfreq_list_lock); 817 818 if (!ret) 819 ret = count; 820 return ret; 821} 822static DEVICE_ATTR_RW(governor); 823 824static ssize_t available_governors_show(struct device *d, 825 struct device_attribute *attr, 826 char *buf) 827{ 828 struct devfreq_governor *tmp_governor; 829 ssize_t count = 0; 830 831 mutex_lock(&devfreq_list_lock); 832 list_for_each_entry(tmp_governor, &devfreq_governor_list, node) 833 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2), 834 "%s ", tmp_governor->name); 835 mutex_unlock(&devfreq_list_lock); 836 837 /* Truncate the trailing space */ 838 if (count) 839 count--; 840 841 count += sprintf(&buf[count], "\n"); 842 843 return count; 844} 845static DEVICE_ATTR_RO(available_governors); 846 847static ssize_t cur_freq_show(struct device *dev, struct device_attribute *attr, 848 char *buf) 849{ 850 unsigned long freq; 851 struct devfreq *devfreq = to_devfreq(dev); 852 853 if (devfreq->profile->get_cur_freq && 854 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq)) 855 return sprintf(buf, "%lu\n", freq); 856 857 return sprintf(buf, "%lu\n", devfreq->previous_freq); 858} 859static DEVICE_ATTR_RO(cur_freq); 860 861static ssize_t target_freq_show(struct device *dev, 862 struct device_attribute *attr, char *buf) 863{ 864 return sprintf(buf, "%lu\n", to_devfreq(dev)->previous_freq); 865} 866static DEVICE_ATTR_RO(target_freq); 867 868static ssize_t polling_interval_show(struct device *dev, 869 struct device_attribute *attr, char *buf) 870{ 871 return sprintf(buf, "%d\n", to_devfreq(dev)->profile->polling_ms); 872} 873 874static ssize_t polling_interval_store(struct device *dev, 875 struct device_attribute *attr, 876 const char *buf, size_t count) 877{ 878 struct devfreq *df = to_devfreq(dev); 879 unsigned int value; 880 int ret; 881 882 if (!df->governor) 883 return -EINVAL; 884 885 ret = sscanf(buf, "%u", &value); 886 if (ret != 1) 887 return -EINVAL; 888 889 df->governor->event_handler(df, DEVFREQ_GOV_INTERVAL, &value); 890 ret = count; 891 892 return ret; 893} 894static DEVICE_ATTR_RW(polling_interval); 895 896static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr, 897 const char *buf, size_t count) 898{ 899 struct devfreq *df = to_devfreq(dev); 900 unsigned long value; 901 int ret; 902 unsigned long max; 903 904 ret = sscanf(buf, "%lu", &value); 905 if (ret != 1) 906 return -EINVAL; 907 908 mutex_lock(&df->lock); 909 max = df->max_freq; 910 if (value && max && value > max) { 911 ret = -EINVAL; 912 goto unlock; 913 } 914 915 df->min_freq = value; 916 update_devfreq(df); 917 ret = count; 918unlock: 919 mutex_unlock(&df->lock); 920 return ret; 921} 922 923static ssize_t min_freq_show(struct device *dev, struct device_attribute *attr, 924 char *buf) 925{ 926 return sprintf(buf, "%lu\n", to_devfreq(dev)->min_freq); 927} 928 929static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr, 930 const char *buf, size_t count) 931{ 932 struct devfreq *df = to_devfreq(dev); 933 unsigned long value; 934 int ret; 935 unsigned long min; 936 937 ret = sscanf(buf, "%lu", &value); 938 if (ret != 1) 939 return -EINVAL; 940 941 mutex_lock(&df->lock); 942 min = df->min_freq; 943 if (value && min && value < min) { 944 ret = -EINVAL; 945 goto unlock; 946 } 947 948 df->max_freq = value; 949 update_devfreq(df); 950 ret = count; 951unlock: 952 mutex_unlock(&df->lock); 953 return ret; 954} 955static DEVICE_ATTR_RW(min_freq); 956 957static ssize_t max_freq_show(struct device *dev, struct device_attribute *attr, 958 char *buf) 959{ 960 return sprintf(buf, "%lu\n", to_devfreq(dev)->max_freq); 961} 962static DEVICE_ATTR_RW(max_freq); 963 964static ssize_t available_frequencies_show(struct device *d, 965 struct device_attribute *attr, 966 char *buf) 967{ 968 struct devfreq *df = to_devfreq(d); 969 struct device *dev = df->dev.parent; 970 struct dev_pm_opp *opp; 971 ssize_t count = 0; 972 unsigned long freq = 0; 973 974 rcu_read_lock(); 975 do { 976 opp = dev_pm_opp_find_freq_ceil(dev, &freq); 977 if (IS_ERR(opp)) 978 break; 979 980 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2), 981 "%lu ", freq); 982 freq++; 983 } while (1); 984 rcu_read_unlock(); 985 986 /* Truncate the trailing space */ 987 if (count) 988 count--; 989 990 count += sprintf(&buf[count], "\n"); 991 992 return count; 993} 994static DEVICE_ATTR_RO(available_frequencies); 995 996static ssize_t trans_stat_show(struct device *dev, 997 struct device_attribute *attr, char *buf) 998{ 999 struct devfreq *devfreq = to_devfreq(dev); 1000 ssize_t len; 1001 int i, j; 1002 unsigned int max_state = devfreq->profile->max_state; 1003 1004 if (!devfreq->stop_polling && 1005 devfreq_update_status(devfreq, devfreq->previous_freq)) 1006 return 0; 1007 1008 len = sprintf(buf, " From : To\n"); 1009 len += sprintf(buf + len, " :"); 1010 for (i = 0; i < max_state; i++) 1011 len += sprintf(buf + len, "%8u", 1012 devfreq->profile->freq_table[i]); 1013 1014 len += sprintf(buf + len, " time(ms)\n"); 1015 1016 for (i = 0; i < max_state; i++) { 1017 if (devfreq->profile->freq_table[i] 1018 == devfreq->previous_freq) { 1019 len += sprintf(buf + len, "*"); 1020 } else { 1021 len += sprintf(buf + len, " "); 1022 } 1023 len += sprintf(buf + len, "%8u:", 1024 devfreq->profile->freq_table[i]); 1025 for (j = 0; j < max_state; j++) 1026 len += sprintf(buf + len, "%8u", 1027 devfreq->trans_table[(i * max_state) + j]); 1028 len += sprintf(buf + len, "%10u\n", 1029 jiffies_to_msecs(devfreq->time_in_state[i])); 1030 } 1031 1032 len += sprintf(buf + len, "Total transition : %u\n", 1033 devfreq->total_trans); 1034 return len; 1035} 1036static DEVICE_ATTR_RO(trans_stat); 1037 1038static struct attribute *devfreq_attrs[] = { 1039 &dev_attr_governor.attr, 1040 &dev_attr_available_governors.attr, 1041 &dev_attr_cur_freq.attr, 1042 &dev_attr_available_frequencies.attr, 1043 &dev_attr_target_freq.attr, 1044 &dev_attr_polling_interval.attr, 1045 &dev_attr_min_freq.attr, 1046 &dev_attr_max_freq.attr, 1047 &dev_attr_trans_stat.attr, 1048 NULL, 1049}; 1050ATTRIBUTE_GROUPS(devfreq); 1051 1052static int __init devfreq_init(void) 1053{ 1054 devfreq_class = class_create(THIS_MODULE, "devfreq"); 1055 if (IS_ERR(devfreq_class)) { 1056 pr_err("%s: couldn't create class\n", __FILE__); 1057 return PTR_ERR(devfreq_class); 1058 } 1059 1060 devfreq_wq = create_freezable_workqueue("devfreq_wq"); 1061 if (!devfreq_wq) { 1062 class_destroy(devfreq_class); 1063 pr_err("%s: couldn't create workqueue\n", __FILE__); 1064 return -ENOMEM; 1065 } 1066 devfreq_class->dev_groups = devfreq_groups; 1067 1068 return 0; 1069} 1070subsys_initcall(devfreq_init); 1071 1072static void __exit devfreq_exit(void) 1073{ 1074 class_destroy(devfreq_class); 1075 destroy_workqueue(devfreq_wq); 1076} 1077module_exit(devfreq_exit); 1078 1079/* 1080 * The followings are helper functions for devfreq user device drivers with 1081 * OPP framework. 1082 */ 1083 1084/** 1085 * devfreq_recommended_opp() - Helper function to get proper OPP for the 1086 * freq value given to target callback. 1087 * @dev: The devfreq user device. (parent of devfreq) 1088 * @freq: The frequency given to target function 1089 * @flags: Flags handed from devfreq framework. 1090 * 1091 * Locking: This function must be called under rcu_read_lock(). opp is a rcu 1092 * protected pointer. The reason for the same is that the opp pointer which is 1093 * returned will remain valid for use with opp_get_{voltage, freq} only while 1094 * under the locked area. The pointer returned must be used prior to unlocking 1095 * with rcu_read_unlock() to maintain the integrity of the pointer. 1096 */ 1097struct dev_pm_opp *devfreq_recommended_opp(struct device *dev, 1098 unsigned long *freq, 1099 u32 flags) 1100{ 1101 struct dev_pm_opp *opp; 1102 1103 if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) { 1104 /* The freq is an upper bound. opp should be lower */ 1105 opp = dev_pm_opp_find_freq_floor(dev, freq); 1106 1107 /* If not available, use the closest opp */ 1108 if (opp == ERR_PTR(-ERANGE)) 1109 opp = dev_pm_opp_find_freq_ceil(dev, freq); 1110 } else { 1111 /* The freq is an lower bound. opp should be higher */ 1112 opp = dev_pm_opp_find_freq_ceil(dev, freq); 1113 1114 /* If not available, use the closest opp */ 1115 if (opp == ERR_PTR(-ERANGE)) 1116 opp = dev_pm_opp_find_freq_floor(dev, freq); 1117 } 1118 1119 return opp; 1120} 1121EXPORT_SYMBOL(devfreq_recommended_opp); 1122 1123/** 1124 * devfreq_register_opp_notifier() - Helper function to get devfreq notified 1125 * for any changes in the OPP availability 1126 * changes 1127 * @dev: The devfreq user device. (parent of devfreq) 1128 * @devfreq: The devfreq object. 1129 */ 1130int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq) 1131{ 1132 struct srcu_notifier_head *nh; 1133 int ret = 0; 1134 1135 rcu_read_lock(); 1136 nh = dev_pm_opp_get_notifier(dev); 1137 if (IS_ERR(nh)) 1138 ret = PTR_ERR(nh); 1139 rcu_read_unlock(); 1140 if (!ret) 1141 ret = srcu_notifier_chain_register(nh, &devfreq->nb); 1142 1143 return ret; 1144} 1145EXPORT_SYMBOL(devfreq_register_opp_notifier); 1146 1147/** 1148 * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq 1149 * notified for any changes in the OPP 1150 * availability changes anymore. 1151 * @dev: The devfreq user device. (parent of devfreq) 1152 * @devfreq: The devfreq object. 1153 * 1154 * At exit() callback of devfreq_dev_profile, this must be included if 1155 * devfreq_recommended_opp is used. 1156 */ 1157int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq) 1158{ 1159 struct srcu_notifier_head *nh; 1160 int ret = 0; 1161 1162 rcu_read_lock(); 1163 nh = dev_pm_opp_get_notifier(dev); 1164 if (IS_ERR(nh)) 1165 ret = PTR_ERR(nh); 1166 rcu_read_unlock(); 1167 if (!ret) 1168 ret = srcu_notifier_chain_unregister(nh, &devfreq->nb); 1169 1170 return ret; 1171} 1172EXPORT_SYMBOL(devfreq_unregister_opp_notifier); 1173 1174static void devm_devfreq_opp_release(struct device *dev, void *res) 1175{ 1176 devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res); 1177} 1178 1179/** 1180 * devm_ devfreq_register_opp_notifier() 1181 * - Resource-managed devfreq_register_opp_notifier() 1182 * @dev: The devfreq user device. (parent of devfreq) 1183 * @devfreq: The devfreq object. 1184 */ 1185int devm_devfreq_register_opp_notifier(struct device *dev, 1186 struct devfreq *devfreq) 1187{ 1188 struct devfreq **ptr; 1189 int ret; 1190 1191 ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL); 1192 if (!ptr) 1193 return -ENOMEM; 1194 1195 ret = devfreq_register_opp_notifier(dev, devfreq); 1196 if (ret) { 1197 devres_free(ptr); 1198 return ret; 1199 } 1200 1201 *ptr = devfreq; 1202 devres_add(dev, ptr); 1203 1204 return 0; 1205} 1206EXPORT_SYMBOL(devm_devfreq_register_opp_notifier); 1207 1208/** 1209 * devm_devfreq_unregister_opp_notifier() 1210 * - Resource-managed devfreq_unregister_opp_notifier() 1211 * @dev: The devfreq user device. (parent of devfreq) 1212 * @devfreq: The devfreq object. 1213 */ 1214void devm_devfreq_unregister_opp_notifier(struct device *dev, 1215 struct devfreq *devfreq) 1216{ 1217 WARN_ON(devres_release(dev, devm_devfreq_opp_release, 1218 devm_devfreq_dev_match, devfreq)); 1219} 1220EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier); 1221 1222MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>"); 1223MODULE_DESCRIPTION("devfreq class support"); 1224MODULE_LICENSE("GPL"); 1225