1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework 4 * for Non-CPU Devices. 5 * 6 * Copyright (C) 2011 Samsung Electronics 7 * MyungJoo Ham <myungjoo.ham@samsung.com> 8 */ 9 10#include <linux/kernel.h> 11#include <linux/kmod.h> 12#include <linux/sched.h> 13#include <linux/debugfs.h> 14#include <linux/devfreq_cooling.h> 15#include <linux/errno.h> 16#include <linux/err.h> 17#include <linux/init.h> 18#include <linux/export.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 <linux/of.h> 29#include <linux/pm_qos.h> 30#include <linux/units.h> 31#include "governor.h" 32 33#define CREATE_TRACE_POINTS 34#include <trace/events/devfreq.h> 35 36#define IS_SUPPORTED_FLAG(f, name) ((f & DEVFREQ_GOV_FLAG_##name) ? true : false) 37#define IS_SUPPORTED_ATTR(f, name) ((f & DEVFREQ_GOV_ATTR_##name) ? true : false) 38 39static struct class *devfreq_class; 40static struct dentry *devfreq_debugfs; 41 42/* 43 * devfreq core provides delayed work based load monitoring helper 44 * functions. Governors can use these or can implement their own 45 * monitoring mechanism. 46 */ 47static struct workqueue_struct *devfreq_wq; 48 49/* The list of all device-devfreq governors */ 50static LIST_HEAD(devfreq_governor_list); 51/* The list of all device-devfreq */ 52static LIST_HEAD(devfreq_list); 53static DEFINE_MUTEX(devfreq_list_lock); 54 55static const char timer_name[][DEVFREQ_NAME_LEN] = { 56 [DEVFREQ_TIMER_DEFERRABLE] = { "deferrable" }, 57 [DEVFREQ_TIMER_DELAYED] = { "delayed" }, 58}; 59 60/** 61 * find_device_devfreq() - find devfreq struct using device pointer 62 * @dev: device pointer used to lookup device devfreq. 63 * 64 * Search the list of device devfreqs and return the matched device's 65 * devfreq info. devfreq_list_lock should be held by the caller. 66 */ 67static struct devfreq *find_device_devfreq(struct device *dev) 68{ 69 struct devfreq *tmp_devfreq; 70 71 lockdep_assert_held(&devfreq_list_lock); 72 73 if (IS_ERR_OR_NULL(dev)) { 74 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__); 75 return ERR_PTR(-EINVAL); 76 } 77 78 list_for_each_entry(tmp_devfreq, &devfreq_list, node) { 79 if (tmp_devfreq->dev.parent == dev) 80 return tmp_devfreq; 81 } 82 83 return ERR_PTR(-ENODEV); 84} 85 86static unsigned long find_available_min_freq(struct devfreq *devfreq) 87{ 88 struct dev_pm_opp *opp; 89 unsigned long min_freq = 0; 90 91 opp = dev_pm_opp_find_freq_ceil_indexed(devfreq->dev.parent, &min_freq, 0); 92 if (IS_ERR(opp)) 93 min_freq = 0; 94 else 95 dev_pm_opp_put(opp); 96 97 return min_freq; 98} 99 100static unsigned long find_available_max_freq(struct devfreq *devfreq) 101{ 102 struct dev_pm_opp *opp; 103 unsigned long max_freq = ULONG_MAX; 104 105 opp = dev_pm_opp_find_freq_floor_indexed(devfreq->dev.parent, &max_freq, 0); 106 if (IS_ERR(opp)) 107 max_freq = 0; 108 else 109 dev_pm_opp_put(opp); 110 111 return max_freq; 112} 113 114/** 115 * devfreq_get_freq_range() - Get the current freq range 116 * @devfreq: the devfreq instance 117 * @min_freq: the min frequency 118 * @max_freq: the max frequency 119 * 120 * This takes into consideration all constraints. 121 */ 122void devfreq_get_freq_range(struct devfreq *devfreq, 123 unsigned long *min_freq, 124 unsigned long *max_freq) 125{ 126 unsigned long *freq_table = devfreq->freq_table; 127 s32 qos_min_freq, qos_max_freq; 128 129 lockdep_assert_held(&devfreq->lock); 130 131 /* 132 * Initialize minimum/maximum frequency from freq table. 133 * The devfreq drivers can initialize this in either ascending or 134 * descending order and devfreq core supports both. 135 */ 136 if (freq_table[0] < freq_table[devfreq->max_state - 1]) { 137 *min_freq = freq_table[0]; 138 *max_freq = freq_table[devfreq->max_state - 1]; 139 } else { 140 *min_freq = freq_table[devfreq->max_state - 1]; 141 *max_freq = freq_table[0]; 142 } 143 144 /* Apply constraints from PM QoS */ 145 qos_min_freq = dev_pm_qos_read_value(devfreq->dev.parent, 146 DEV_PM_QOS_MIN_FREQUENCY); 147 qos_max_freq = dev_pm_qos_read_value(devfreq->dev.parent, 148 DEV_PM_QOS_MAX_FREQUENCY); 149 *min_freq = max(*min_freq, (unsigned long)HZ_PER_KHZ * qos_min_freq); 150 if (qos_max_freq != PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE) 151 *max_freq = min(*max_freq, 152 (unsigned long)HZ_PER_KHZ * qos_max_freq); 153 154 /* Apply constraints from OPP interface */ 155 *min_freq = max(*min_freq, devfreq->scaling_min_freq); 156 *max_freq = min(*max_freq, devfreq->scaling_max_freq); 157 158 if (*min_freq > *max_freq) 159 *min_freq = *max_freq; 160} 161EXPORT_SYMBOL(devfreq_get_freq_range); 162 163/** 164 * devfreq_get_freq_level() - Lookup freq_table for the frequency 165 * @devfreq: the devfreq instance 166 * @freq: the target frequency 167 */ 168static int devfreq_get_freq_level(struct devfreq *devfreq, unsigned long freq) 169{ 170 int lev; 171 172 for (lev = 0; lev < devfreq->max_state; lev++) 173 if (freq == devfreq->freq_table[lev]) 174 return lev; 175 176 return -EINVAL; 177} 178 179static int set_freq_table(struct devfreq *devfreq) 180{ 181 struct dev_pm_opp *opp; 182 unsigned long freq; 183 int i, count; 184 185 /* Initialize the freq_table from OPP table */ 186 count = dev_pm_opp_get_opp_count(devfreq->dev.parent); 187 if (count <= 0) 188 return -EINVAL; 189 190 devfreq->max_state = count; 191 devfreq->freq_table = devm_kcalloc(devfreq->dev.parent, 192 devfreq->max_state, 193 sizeof(*devfreq->freq_table), 194 GFP_KERNEL); 195 if (!devfreq->freq_table) 196 return -ENOMEM; 197 198 for (i = 0, freq = 0; i < devfreq->max_state; i++, freq++) { 199 opp = dev_pm_opp_find_freq_ceil_indexed(devfreq->dev.parent, &freq, 0); 200 if (IS_ERR(opp)) { 201 devm_kfree(devfreq->dev.parent, devfreq->freq_table); 202 return PTR_ERR(opp); 203 } 204 dev_pm_opp_put(opp); 205 devfreq->freq_table[i] = freq; 206 } 207 208 return 0; 209} 210 211/** 212 * devfreq_update_status() - Update statistics of devfreq behavior 213 * @devfreq: the devfreq instance 214 * @freq: the update target frequency 215 */ 216int devfreq_update_status(struct devfreq *devfreq, unsigned long freq) 217{ 218 int lev, prev_lev, ret = 0; 219 u64 cur_time; 220 221 lockdep_assert_held(&devfreq->lock); 222 cur_time = get_jiffies_64(); 223 224 /* Immediately exit if previous_freq is not initialized yet. */ 225 if (!devfreq->previous_freq) 226 goto out; 227 228 prev_lev = devfreq_get_freq_level(devfreq, devfreq->previous_freq); 229 if (prev_lev < 0) { 230 ret = prev_lev; 231 goto out; 232 } 233 234 devfreq->stats.time_in_state[prev_lev] += 235 cur_time - devfreq->stats.last_update; 236 237 lev = devfreq_get_freq_level(devfreq, freq); 238 if (lev < 0) { 239 ret = lev; 240 goto out; 241 } 242 243 if (lev != prev_lev) { 244 devfreq->stats.trans_table[ 245 (prev_lev * devfreq->max_state) + lev]++; 246 devfreq->stats.total_trans++; 247 } 248 249out: 250 devfreq->stats.last_update = cur_time; 251 return ret; 252} 253EXPORT_SYMBOL(devfreq_update_status); 254 255/** 256 * find_devfreq_governor() - find devfreq governor from name 257 * @name: name of the governor 258 * 259 * Search the list of devfreq governors and return the matched 260 * governor's pointer. devfreq_list_lock should be held by the caller. 261 */ 262static struct devfreq_governor *find_devfreq_governor(const char *name) 263{ 264 struct devfreq_governor *tmp_governor; 265 266 lockdep_assert_held(&devfreq_list_lock); 267 268 if (IS_ERR_OR_NULL(name)) { 269 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__); 270 return ERR_PTR(-EINVAL); 271 } 272 273 list_for_each_entry(tmp_governor, &devfreq_governor_list, node) { 274 if (!strncmp(tmp_governor->name, name, DEVFREQ_NAME_LEN)) 275 return tmp_governor; 276 } 277 278 return ERR_PTR(-ENODEV); 279} 280 281/** 282 * try_then_request_governor() - Try to find the governor and request the 283 * module if is not found. 284 * @name: name of the governor 285 * 286 * Search the list of devfreq governors and request the module and try again 287 * if is not found. This can happen when both drivers (the governor driver 288 * and the driver that call devfreq_add_device) are built as modules. 289 * devfreq_list_lock should be held by the caller. Returns the matched 290 * governor's pointer or an error pointer. 291 */ 292static struct devfreq_governor *try_then_request_governor(const char *name) 293{ 294 struct devfreq_governor *governor; 295 int err = 0; 296 297 lockdep_assert_held(&devfreq_list_lock); 298 299 if (IS_ERR_OR_NULL(name)) { 300 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__); 301 return ERR_PTR(-EINVAL); 302 } 303 304 governor = find_devfreq_governor(name); 305 if (IS_ERR(governor)) { 306 mutex_unlock(&devfreq_list_lock); 307 308 if (!strncmp(name, DEVFREQ_GOV_SIMPLE_ONDEMAND, 309 DEVFREQ_NAME_LEN)) 310 err = request_module("governor_%s", "simpleondemand"); 311 else 312 err = request_module("governor_%s", name); 313 /* Restore previous state before return */ 314 mutex_lock(&devfreq_list_lock); 315 if (err) 316 return (err < 0) ? ERR_PTR(err) : ERR_PTR(-EINVAL); 317 318 governor = find_devfreq_governor(name); 319 } 320 321 return governor; 322} 323 324static int devfreq_notify_transition(struct devfreq *devfreq, 325 struct devfreq_freqs *freqs, unsigned int state) 326{ 327 if (!devfreq) 328 return -EINVAL; 329 330 switch (state) { 331 case DEVFREQ_PRECHANGE: 332 srcu_notifier_call_chain(&devfreq->transition_notifier_list, 333 DEVFREQ_PRECHANGE, freqs); 334 break; 335 336 case DEVFREQ_POSTCHANGE: 337 srcu_notifier_call_chain(&devfreq->transition_notifier_list, 338 DEVFREQ_POSTCHANGE, freqs); 339 break; 340 default: 341 return -EINVAL; 342 } 343 344 return 0; 345} 346 347static int devfreq_set_target(struct devfreq *devfreq, unsigned long new_freq, 348 u32 flags) 349{ 350 struct devfreq_freqs freqs; 351 unsigned long cur_freq; 352 int err = 0; 353 354 if (devfreq->profile->get_cur_freq) 355 devfreq->profile->get_cur_freq(devfreq->dev.parent, &cur_freq); 356 else 357 cur_freq = devfreq->previous_freq; 358 359 freqs.old = cur_freq; 360 freqs.new = new_freq; 361 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_PRECHANGE); 362 363 err = devfreq->profile->target(devfreq->dev.parent, &new_freq, flags); 364 if (err) { 365 freqs.new = cur_freq; 366 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE); 367 return err; 368 } 369 370 /* 371 * Print devfreq_frequency trace information between DEVFREQ_PRECHANGE 372 * and DEVFREQ_POSTCHANGE because for showing the correct frequency 373 * change order of between devfreq device and passive devfreq device. 374 */ 375 if (trace_devfreq_frequency_enabled() && new_freq != cur_freq) 376 trace_devfreq_frequency(devfreq, new_freq, cur_freq); 377 378 freqs.new = new_freq; 379 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE); 380 381 if (devfreq_update_status(devfreq, new_freq)) 382 dev_warn(&devfreq->dev, 383 "Couldn't update frequency transition information.\n"); 384 385 devfreq->previous_freq = new_freq; 386 387 if (devfreq->suspend_freq) 388 devfreq->resume_freq = new_freq; 389 390 return err; 391} 392 393/** 394 * devfreq_update_target() - Reevaluate the device and configure frequency 395 * on the final stage. 396 * @devfreq: the devfreq instance. 397 * @freq: the new frequency of parent device. This argument 398 * is only used for devfreq device using passive governor. 399 * 400 * Note: Lock devfreq->lock before calling devfreq_update_target. This function 401 * should be only used by both update_devfreq() and devfreq governors. 402 */ 403int devfreq_update_target(struct devfreq *devfreq, unsigned long freq) 404{ 405 unsigned long min_freq, max_freq; 406 int err = 0; 407 u32 flags = 0; 408 409 lockdep_assert_held(&devfreq->lock); 410 411 if (!devfreq->governor) 412 return -EINVAL; 413 414 /* Reevaluate the proper frequency */ 415 err = devfreq->governor->get_target_freq(devfreq, &freq); 416 if (err) 417 return err; 418 devfreq_get_freq_range(devfreq, &min_freq, &max_freq); 419 420 if (freq < min_freq) { 421 freq = min_freq; 422 flags &= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use GLB */ 423 } 424 if (freq > max_freq) { 425 freq = max_freq; 426 flags |= DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use LUB */ 427 } 428 429 return devfreq_set_target(devfreq, freq, flags); 430} 431EXPORT_SYMBOL(devfreq_update_target); 432 433/* Load monitoring helper functions for governors use */ 434 435/** 436 * update_devfreq() - Reevaluate the device and configure frequency. 437 * @devfreq: the devfreq instance. 438 * 439 * Note: Lock devfreq->lock before calling update_devfreq 440 * This function is exported for governors. 441 */ 442int update_devfreq(struct devfreq *devfreq) 443{ 444 return devfreq_update_target(devfreq, 0L); 445} 446EXPORT_SYMBOL(update_devfreq); 447 448/** 449 * devfreq_monitor() - Periodically poll devfreq objects. 450 * @work: the work struct used to run devfreq_monitor periodically. 451 * 452 */ 453static void devfreq_monitor(struct work_struct *work) 454{ 455 int err; 456 struct devfreq *devfreq = container_of(work, 457 struct devfreq, work.work); 458 459 mutex_lock(&devfreq->lock); 460 err = update_devfreq(devfreq); 461 if (err) 462 dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err); 463 464 if (devfreq->stop_polling) 465 goto out; 466 467 queue_delayed_work(devfreq_wq, &devfreq->work, 468 msecs_to_jiffies(devfreq->profile->polling_ms)); 469 470out: 471 mutex_unlock(&devfreq->lock); 472 trace_devfreq_monitor(devfreq); 473} 474 475/** 476 * devfreq_monitor_start() - Start load monitoring of devfreq instance 477 * @devfreq: the devfreq instance. 478 * 479 * Helper function for starting devfreq device load monitoring. By default, 480 * deferrable timer is used for load monitoring. But the users can change this 481 * behavior using the "timer" type in devfreq_dev_profile. This function will be 482 * called by devfreq governor in response to the DEVFREQ_GOV_START event 483 * generated while adding a device to the devfreq framework. 484 */ 485void devfreq_monitor_start(struct devfreq *devfreq) 486{ 487 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) 488 return; 489 490 mutex_lock(&devfreq->lock); 491 if (delayed_work_pending(&devfreq->work)) 492 goto out; 493 494 switch (devfreq->profile->timer) { 495 case DEVFREQ_TIMER_DEFERRABLE: 496 INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor); 497 break; 498 case DEVFREQ_TIMER_DELAYED: 499 INIT_DELAYED_WORK(&devfreq->work, devfreq_monitor); 500 break; 501 default: 502 goto out; 503 } 504 505 if (devfreq->profile->polling_ms) 506 queue_delayed_work(devfreq_wq, &devfreq->work, 507 msecs_to_jiffies(devfreq->profile->polling_ms)); 508 509out: 510 devfreq->stop_polling = false; 511 mutex_unlock(&devfreq->lock); 512} 513EXPORT_SYMBOL(devfreq_monitor_start); 514 515/** 516 * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance 517 * @devfreq: the devfreq instance. 518 * 519 * Helper function to stop devfreq device load monitoring. Function 520 * to be called from governor in response to DEVFREQ_GOV_STOP 521 * event when device is removed from devfreq framework. 522 */ 523void devfreq_monitor_stop(struct devfreq *devfreq) 524{ 525 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) 526 return; 527 528 mutex_lock(&devfreq->lock); 529 if (devfreq->stop_polling) { 530 mutex_unlock(&devfreq->lock); 531 return; 532 } 533 534 devfreq->stop_polling = true; 535 mutex_unlock(&devfreq->lock); 536 cancel_delayed_work_sync(&devfreq->work); 537} 538EXPORT_SYMBOL(devfreq_monitor_stop); 539 540/** 541 * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance 542 * @devfreq: the devfreq instance. 543 * 544 * Helper function to suspend devfreq device load monitoring. Function 545 * to be called from governor in response to DEVFREQ_GOV_SUSPEND 546 * event or when polling interval is set to zero. 547 * 548 * Note: Though this function is same as devfreq_monitor_stop(), 549 * intentionally kept separate to provide hooks for collecting 550 * transition statistics. 551 */ 552void devfreq_monitor_suspend(struct devfreq *devfreq) 553{ 554 mutex_lock(&devfreq->lock); 555 if (devfreq->stop_polling) { 556 mutex_unlock(&devfreq->lock); 557 return; 558 } 559 560 devfreq_update_status(devfreq, devfreq->previous_freq); 561 devfreq->stop_polling = true; 562 mutex_unlock(&devfreq->lock); 563 564 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) 565 return; 566 567 cancel_delayed_work_sync(&devfreq->work); 568} 569EXPORT_SYMBOL(devfreq_monitor_suspend); 570 571/** 572 * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance 573 * @devfreq: the devfreq instance. 574 * 575 * Helper function to resume devfreq device load monitoring. Function 576 * to be called from governor in response to DEVFREQ_GOV_RESUME 577 * event or when polling interval is set to non-zero. 578 */ 579void devfreq_monitor_resume(struct devfreq *devfreq) 580{ 581 unsigned long freq; 582 583 mutex_lock(&devfreq->lock); 584 585 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) 586 goto out_update; 587 588 if (!devfreq->stop_polling) 589 goto out; 590 591 if (!delayed_work_pending(&devfreq->work) && 592 devfreq->profile->polling_ms) 593 queue_delayed_work(devfreq_wq, &devfreq->work, 594 msecs_to_jiffies(devfreq->profile->polling_ms)); 595 596out_update: 597 devfreq->stats.last_update = get_jiffies_64(); 598 devfreq->stop_polling = false; 599 600 if (devfreq->profile->get_cur_freq && 601 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq)) 602 devfreq->previous_freq = freq; 603 604out: 605 mutex_unlock(&devfreq->lock); 606} 607EXPORT_SYMBOL(devfreq_monitor_resume); 608 609/** 610 * devfreq_update_interval() - Update device devfreq monitoring interval 611 * @devfreq: the devfreq instance. 612 * @delay: new polling interval to be set. 613 * 614 * Helper function to set new load monitoring polling interval. Function 615 * to be called from governor in response to DEVFREQ_GOV_UPDATE_INTERVAL event. 616 */ 617void devfreq_update_interval(struct devfreq *devfreq, unsigned int *delay) 618{ 619 unsigned int cur_delay = devfreq->profile->polling_ms; 620 unsigned int new_delay = *delay; 621 622 mutex_lock(&devfreq->lock); 623 devfreq->profile->polling_ms = new_delay; 624 625 if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) 626 goto out; 627 628 if (devfreq->stop_polling) 629 goto out; 630 631 /* if new delay is zero, stop polling */ 632 if (!new_delay) { 633 mutex_unlock(&devfreq->lock); 634 cancel_delayed_work_sync(&devfreq->work); 635 return; 636 } 637 638 /* if current delay is zero, start polling with new delay */ 639 if (!cur_delay) { 640 queue_delayed_work(devfreq_wq, &devfreq->work, 641 msecs_to_jiffies(devfreq->profile->polling_ms)); 642 goto out; 643 } 644 645 /* if current delay is greater than new delay, restart polling */ 646 if (cur_delay > new_delay) { 647 mutex_unlock(&devfreq->lock); 648 cancel_delayed_work_sync(&devfreq->work); 649 mutex_lock(&devfreq->lock); 650 if (!devfreq->stop_polling) 651 queue_delayed_work(devfreq_wq, &devfreq->work, 652 msecs_to_jiffies(devfreq->profile->polling_ms)); 653 } 654out: 655 mutex_unlock(&devfreq->lock); 656} 657EXPORT_SYMBOL(devfreq_update_interval); 658 659/** 660 * devfreq_notifier_call() - Notify that the device frequency requirements 661 * has been changed out of devfreq framework. 662 * @nb: the notifier_block (supposed to be devfreq->nb) 663 * @type: not used 664 * @devp: not used 665 * 666 * Called by a notifier that uses devfreq->nb. 667 */ 668static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type, 669 void *devp) 670{ 671 struct devfreq *devfreq = container_of(nb, struct devfreq, nb); 672 int err = -EINVAL; 673 674 mutex_lock(&devfreq->lock); 675 676 devfreq->scaling_min_freq = find_available_min_freq(devfreq); 677 if (!devfreq->scaling_min_freq) 678 goto out; 679 680 devfreq->scaling_max_freq = find_available_max_freq(devfreq); 681 if (!devfreq->scaling_max_freq) { 682 devfreq->scaling_max_freq = ULONG_MAX; 683 goto out; 684 } 685 686 err = update_devfreq(devfreq); 687 688out: 689 mutex_unlock(&devfreq->lock); 690 if (err) 691 dev_err(devfreq->dev.parent, 692 "failed to update frequency from OPP notifier (%d)\n", 693 err); 694 695 return NOTIFY_OK; 696} 697 698/** 699 * qos_notifier_call() - Common handler for QoS constraints. 700 * @devfreq: the devfreq instance. 701 */ 702static int qos_notifier_call(struct devfreq *devfreq) 703{ 704 int err; 705 706 mutex_lock(&devfreq->lock); 707 err = update_devfreq(devfreq); 708 mutex_unlock(&devfreq->lock); 709 if (err) 710 dev_err(devfreq->dev.parent, 711 "failed to update frequency from PM QoS (%d)\n", 712 err); 713 714 return NOTIFY_OK; 715} 716 717/** 718 * qos_min_notifier_call() - Callback for QoS min_freq changes. 719 * @nb: Should be devfreq->nb_min 720 * @val: not used 721 * @ptr: not used 722 */ 723static int qos_min_notifier_call(struct notifier_block *nb, 724 unsigned long val, void *ptr) 725{ 726 return qos_notifier_call(container_of(nb, struct devfreq, nb_min)); 727} 728 729/** 730 * qos_max_notifier_call() - Callback for QoS max_freq changes. 731 * @nb: Should be devfreq->nb_max 732 * @val: not used 733 * @ptr: not used 734 */ 735static int qos_max_notifier_call(struct notifier_block *nb, 736 unsigned long val, void *ptr) 737{ 738 return qos_notifier_call(container_of(nb, struct devfreq, nb_max)); 739} 740 741/** 742 * devfreq_dev_release() - Callback for struct device to release the device. 743 * @dev: the devfreq device 744 * 745 * Remove devfreq from the list and release its resources. 746 */ 747static void devfreq_dev_release(struct device *dev) 748{ 749 struct devfreq *devfreq = to_devfreq(dev); 750 int err; 751 752 mutex_lock(&devfreq_list_lock); 753 list_del(&devfreq->node); 754 mutex_unlock(&devfreq_list_lock); 755 756 err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_max, 757 DEV_PM_QOS_MAX_FREQUENCY); 758 if (err && err != -ENOENT) 759 dev_warn(dev->parent, 760 "Failed to remove max_freq notifier: %d\n", err); 761 err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_min, 762 DEV_PM_QOS_MIN_FREQUENCY); 763 if (err && err != -ENOENT) 764 dev_warn(dev->parent, 765 "Failed to remove min_freq notifier: %d\n", err); 766 767 if (dev_pm_qos_request_active(&devfreq->user_max_freq_req)) { 768 err = dev_pm_qos_remove_request(&devfreq->user_max_freq_req); 769 if (err < 0) 770 dev_warn(dev->parent, 771 "Failed to remove max_freq request: %d\n", err); 772 } 773 if (dev_pm_qos_request_active(&devfreq->user_min_freq_req)) { 774 err = dev_pm_qos_remove_request(&devfreq->user_min_freq_req); 775 if (err < 0) 776 dev_warn(dev->parent, 777 "Failed to remove min_freq request: %d\n", err); 778 } 779 780 if (devfreq->profile->exit) 781 devfreq->profile->exit(devfreq->dev.parent); 782 783 if (devfreq->opp_table) 784 dev_pm_opp_put_opp_table(devfreq->opp_table); 785 786 mutex_destroy(&devfreq->lock); 787 srcu_cleanup_notifier_head(&devfreq->transition_notifier_list); 788 kfree(devfreq); 789} 790 791static void create_sysfs_files(struct devfreq *devfreq, 792 const struct devfreq_governor *gov); 793static void remove_sysfs_files(struct devfreq *devfreq, 794 const struct devfreq_governor *gov); 795 796/** 797 * devfreq_add_device() - Add devfreq feature to the device 798 * @dev: the device to add devfreq feature. 799 * @profile: device-specific profile to run devfreq. 800 * @governor_name: name of the policy to choose frequency. 801 * @data: devfreq driver pass to governors, governor should not change it. 802 */ 803struct devfreq *devfreq_add_device(struct device *dev, 804 struct devfreq_dev_profile *profile, 805 const char *governor_name, 806 void *data) 807{ 808 struct devfreq *devfreq; 809 struct devfreq_governor *governor; 810 unsigned long min_freq, max_freq; 811 int err = 0; 812 813 if (!dev || !profile || !governor_name) { 814 dev_err(dev, "%s: Invalid parameters.\n", __func__); 815 return ERR_PTR(-EINVAL); 816 } 817 818 mutex_lock(&devfreq_list_lock); 819 devfreq = find_device_devfreq(dev); 820 mutex_unlock(&devfreq_list_lock); 821 if (!IS_ERR(devfreq)) { 822 dev_err(dev, "%s: devfreq device already exists!\n", 823 __func__); 824 err = -EINVAL; 825 goto err_out; 826 } 827 828 devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL); 829 if (!devfreq) { 830 err = -ENOMEM; 831 goto err_out; 832 } 833 834 mutex_init(&devfreq->lock); 835 mutex_lock(&devfreq->lock); 836 devfreq->dev.parent = dev; 837 devfreq->dev.class = devfreq_class; 838 devfreq->dev.release = devfreq_dev_release; 839 INIT_LIST_HEAD(&devfreq->node); 840 devfreq->profile = profile; 841 devfreq->previous_freq = profile->initial_freq; 842 devfreq->last_status.current_frequency = profile->initial_freq; 843 devfreq->data = data; 844 devfreq->nb.notifier_call = devfreq_notifier_call; 845 846 if (devfreq->profile->timer < 0 847 || devfreq->profile->timer >= DEVFREQ_TIMER_NUM) { 848 mutex_unlock(&devfreq->lock); 849 err = -EINVAL; 850 goto err_dev; 851 } 852 853 if (!devfreq->profile->max_state || !devfreq->profile->freq_table) { 854 mutex_unlock(&devfreq->lock); 855 err = set_freq_table(devfreq); 856 if (err < 0) 857 goto err_dev; 858 mutex_lock(&devfreq->lock); 859 } else { 860 devfreq->freq_table = devfreq->profile->freq_table; 861 devfreq->max_state = devfreq->profile->max_state; 862 } 863 864 devfreq->scaling_min_freq = find_available_min_freq(devfreq); 865 if (!devfreq->scaling_min_freq) { 866 mutex_unlock(&devfreq->lock); 867 err = -EINVAL; 868 goto err_dev; 869 } 870 871 devfreq->scaling_max_freq = find_available_max_freq(devfreq); 872 if (!devfreq->scaling_max_freq) { 873 mutex_unlock(&devfreq->lock); 874 err = -EINVAL; 875 goto err_dev; 876 } 877 878 devfreq_get_freq_range(devfreq, &min_freq, &max_freq); 879 880 devfreq->suspend_freq = dev_pm_opp_get_suspend_opp_freq(dev); 881 devfreq->opp_table = dev_pm_opp_get_opp_table(dev); 882 if (IS_ERR(devfreq->opp_table)) 883 devfreq->opp_table = NULL; 884 885 atomic_set(&devfreq->suspend_count, 0); 886 887 dev_set_name(&devfreq->dev, "%s", dev_name(dev)); 888 err = device_register(&devfreq->dev); 889 if (err) { 890 mutex_unlock(&devfreq->lock); 891 put_device(&devfreq->dev); 892 goto err_out; 893 } 894 895 devfreq->stats.trans_table = devm_kzalloc(&devfreq->dev, 896 array3_size(sizeof(unsigned int), 897 devfreq->max_state, 898 devfreq->max_state), 899 GFP_KERNEL); 900 if (!devfreq->stats.trans_table) { 901 mutex_unlock(&devfreq->lock); 902 err = -ENOMEM; 903 goto err_devfreq; 904 } 905 906 devfreq->stats.time_in_state = devm_kcalloc(&devfreq->dev, 907 devfreq->max_state, 908 sizeof(*devfreq->stats.time_in_state), 909 GFP_KERNEL); 910 if (!devfreq->stats.time_in_state) { 911 mutex_unlock(&devfreq->lock); 912 err = -ENOMEM; 913 goto err_devfreq; 914 } 915 916 devfreq->stats.total_trans = 0; 917 devfreq->stats.last_update = get_jiffies_64(); 918 919 srcu_init_notifier_head(&devfreq->transition_notifier_list); 920 921 mutex_unlock(&devfreq->lock); 922 923 err = dev_pm_qos_add_request(dev, &devfreq->user_min_freq_req, 924 DEV_PM_QOS_MIN_FREQUENCY, 0); 925 if (err < 0) 926 goto err_devfreq; 927 err = dev_pm_qos_add_request(dev, &devfreq->user_max_freq_req, 928 DEV_PM_QOS_MAX_FREQUENCY, 929 PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE); 930 if (err < 0) 931 goto err_devfreq; 932 933 devfreq->nb_min.notifier_call = qos_min_notifier_call; 934 err = dev_pm_qos_add_notifier(dev, &devfreq->nb_min, 935 DEV_PM_QOS_MIN_FREQUENCY); 936 if (err) 937 goto err_devfreq; 938 939 devfreq->nb_max.notifier_call = qos_max_notifier_call; 940 err = dev_pm_qos_add_notifier(dev, &devfreq->nb_max, 941 DEV_PM_QOS_MAX_FREQUENCY); 942 if (err) 943 goto err_devfreq; 944 945 mutex_lock(&devfreq_list_lock); 946 947 governor = try_then_request_governor(governor_name); 948 if (IS_ERR(governor)) { 949 dev_err(dev, "%s: Unable to find governor for the device\n", 950 __func__); 951 err = PTR_ERR(governor); 952 goto err_init; 953 } 954 955 devfreq->governor = governor; 956 err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START, 957 NULL); 958 if (err) { 959 dev_err_probe(dev, err, 960 "%s: Unable to start governor for the device\n", 961 __func__); 962 goto err_init; 963 } 964 create_sysfs_files(devfreq, devfreq->governor); 965 966 list_add(&devfreq->node, &devfreq_list); 967 968 mutex_unlock(&devfreq_list_lock); 969 970 if (devfreq->profile->is_cooling_device) { 971 devfreq->cdev = devfreq_cooling_em_register(devfreq, NULL); 972 if (IS_ERR(devfreq->cdev)) 973 devfreq->cdev = NULL; 974 } 975 976 return devfreq; 977 978err_init: 979 mutex_unlock(&devfreq_list_lock); 980err_devfreq: 981 devfreq_remove_device(devfreq); 982 devfreq = NULL; 983err_dev: 984 kfree(devfreq); 985err_out: 986 return ERR_PTR(err); 987} 988EXPORT_SYMBOL(devfreq_add_device); 989 990/** 991 * devfreq_remove_device() - Remove devfreq feature from a device. 992 * @devfreq: the devfreq instance to be removed 993 * 994 * The opposite of devfreq_add_device(). 995 */ 996int devfreq_remove_device(struct devfreq *devfreq) 997{ 998 if (!devfreq) 999 return -EINVAL; 1000 1001 devfreq_cooling_unregister(devfreq->cdev); 1002 1003 if (devfreq->governor) { 1004 devfreq->governor->event_handler(devfreq, 1005 DEVFREQ_GOV_STOP, NULL); 1006 remove_sysfs_files(devfreq, devfreq->governor); 1007 } 1008 1009 device_unregister(&devfreq->dev); 1010 1011 return 0; 1012} 1013EXPORT_SYMBOL(devfreq_remove_device); 1014 1015static int devm_devfreq_dev_match(struct device *dev, void *res, void *data) 1016{ 1017 struct devfreq **r = res; 1018 1019 if (WARN_ON(!r || !*r)) 1020 return 0; 1021 1022 return *r == data; 1023} 1024 1025static void devm_devfreq_dev_release(struct device *dev, void *res) 1026{ 1027 devfreq_remove_device(*(struct devfreq **)res); 1028} 1029 1030/** 1031 * devm_devfreq_add_device() - Resource-managed devfreq_add_device() 1032 * @dev: the device to add devfreq feature. 1033 * @profile: device-specific profile to run devfreq. 1034 * @governor_name: name of the policy to choose frequency. 1035 * @data: devfreq driver pass to governors, governor should not change it. 1036 * 1037 * This function manages automatically the memory of devfreq device using device 1038 * resource management and simplify the free operation for memory of devfreq 1039 * device. 1040 */ 1041struct devfreq *devm_devfreq_add_device(struct device *dev, 1042 struct devfreq_dev_profile *profile, 1043 const char *governor_name, 1044 void *data) 1045{ 1046 struct devfreq **ptr, *devfreq; 1047 1048 ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL); 1049 if (!ptr) 1050 return ERR_PTR(-ENOMEM); 1051 1052 devfreq = devfreq_add_device(dev, profile, governor_name, data); 1053 if (IS_ERR(devfreq)) { 1054 devres_free(ptr); 1055 return devfreq; 1056 } 1057 1058 *ptr = devfreq; 1059 devres_add(dev, ptr); 1060 1061 return devfreq; 1062} 1063EXPORT_SYMBOL(devm_devfreq_add_device); 1064 1065#ifdef CONFIG_OF 1066/* 1067 * devfreq_get_devfreq_by_node - Get the devfreq device from devicetree 1068 * @node - pointer to device_node 1069 * 1070 * return the instance of devfreq device 1071 */ 1072struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node) 1073{ 1074 struct devfreq *devfreq; 1075 1076 if (!node) 1077 return ERR_PTR(-EINVAL); 1078 1079 mutex_lock(&devfreq_list_lock); 1080 list_for_each_entry(devfreq, &devfreq_list, node) { 1081 if (devfreq->dev.parent 1082 && device_match_of_node(devfreq->dev.parent, node)) { 1083 mutex_unlock(&devfreq_list_lock); 1084 return devfreq; 1085 } 1086 } 1087 mutex_unlock(&devfreq_list_lock); 1088 1089 return ERR_PTR(-ENODEV); 1090} 1091 1092/* 1093 * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree 1094 * @dev - instance to the given device 1095 * @phandle_name - name of property holding a phandle value 1096 * @index - index into list of devfreq 1097 * 1098 * return the instance of devfreq device 1099 */ 1100struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, 1101 const char *phandle_name, int index) 1102{ 1103 struct device_node *node; 1104 struct devfreq *devfreq; 1105 1106 if (!dev || !phandle_name) 1107 return ERR_PTR(-EINVAL); 1108 1109 if (!dev->of_node) 1110 return ERR_PTR(-EINVAL); 1111 1112 node = of_parse_phandle(dev->of_node, phandle_name, index); 1113 if (!node) 1114 return ERR_PTR(-ENODEV); 1115 1116 devfreq = devfreq_get_devfreq_by_node(node); 1117 of_node_put(node); 1118 1119 return devfreq; 1120} 1121 1122#else 1123struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node) 1124{ 1125 return ERR_PTR(-ENODEV); 1126} 1127 1128struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, 1129 const char *phandle_name, int index) 1130{ 1131 return ERR_PTR(-ENODEV); 1132} 1133#endif /* CONFIG_OF */ 1134EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_node); 1135EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_phandle); 1136 1137/** 1138 * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device() 1139 * @dev: the device from which to remove devfreq feature. 1140 * @devfreq: the devfreq instance to be removed 1141 */ 1142void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq) 1143{ 1144 WARN_ON(devres_release(dev, devm_devfreq_dev_release, 1145 devm_devfreq_dev_match, devfreq)); 1146} 1147EXPORT_SYMBOL(devm_devfreq_remove_device); 1148 1149/** 1150 * devfreq_suspend_device() - Suspend devfreq of a device. 1151 * @devfreq: the devfreq instance to be suspended 1152 * 1153 * This function is intended to be called by the pm callbacks 1154 * (e.g., runtime_suspend, suspend) of the device driver that 1155 * holds the devfreq. 1156 */ 1157int devfreq_suspend_device(struct devfreq *devfreq) 1158{ 1159 int ret; 1160 1161 if (!devfreq) 1162 return -EINVAL; 1163 1164 if (atomic_inc_return(&devfreq->suspend_count) > 1) 1165 return 0; 1166 1167 if (devfreq->governor) { 1168 ret = devfreq->governor->event_handler(devfreq, 1169 DEVFREQ_GOV_SUSPEND, NULL); 1170 if (ret) 1171 return ret; 1172 } 1173 1174 if (devfreq->suspend_freq) { 1175 mutex_lock(&devfreq->lock); 1176 ret = devfreq_set_target(devfreq, devfreq->suspend_freq, 0); 1177 mutex_unlock(&devfreq->lock); 1178 if (ret) 1179 return ret; 1180 } 1181 1182 return 0; 1183} 1184EXPORT_SYMBOL(devfreq_suspend_device); 1185 1186/** 1187 * devfreq_resume_device() - Resume devfreq of a device. 1188 * @devfreq: the devfreq instance to be resumed 1189 * 1190 * This function is intended to be called by the pm callbacks 1191 * (e.g., runtime_resume, resume) of the device driver that 1192 * holds the devfreq. 1193 */ 1194int devfreq_resume_device(struct devfreq *devfreq) 1195{ 1196 int ret; 1197 1198 if (!devfreq) 1199 return -EINVAL; 1200 1201 if (atomic_dec_return(&devfreq->suspend_count) >= 1) 1202 return 0; 1203 1204 if (devfreq->resume_freq) { 1205 mutex_lock(&devfreq->lock); 1206 ret = devfreq_set_target(devfreq, devfreq->resume_freq, 0); 1207 mutex_unlock(&devfreq->lock); 1208 if (ret) 1209 return ret; 1210 } 1211 1212 if (devfreq->governor) { 1213 ret = devfreq->governor->event_handler(devfreq, 1214 DEVFREQ_GOV_RESUME, NULL); 1215 if (ret) 1216 return ret; 1217 } 1218 1219 return 0; 1220} 1221EXPORT_SYMBOL(devfreq_resume_device); 1222 1223/** 1224 * devfreq_suspend() - Suspend devfreq governors and devices 1225 * 1226 * Called during system wide Suspend/Hibernate cycles for suspending governors 1227 * and devices preserving the state for resume. On some platforms the devfreq 1228 * device must have precise state (frequency) after resume in order to provide 1229 * fully operating setup. 1230 */ 1231void devfreq_suspend(void) 1232{ 1233 struct devfreq *devfreq; 1234 int ret; 1235 1236 mutex_lock(&devfreq_list_lock); 1237 list_for_each_entry(devfreq, &devfreq_list, node) { 1238 ret = devfreq_suspend_device(devfreq); 1239 if (ret) 1240 dev_err(&devfreq->dev, 1241 "failed to suspend devfreq device\n"); 1242 } 1243 mutex_unlock(&devfreq_list_lock); 1244} 1245 1246/** 1247 * devfreq_resume() - Resume devfreq governors and devices 1248 * 1249 * Called during system wide Suspend/Hibernate cycle for resuming governors and 1250 * devices that are suspended with devfreq_suspend(). 1251 */ 1252void devfreq_resume(void) 1253{ 1254 struct devfreq *devfreq; 1255 int ret; 1256 1257 mutex_lock(&devfreq_list_lock); 1258 list_for_each_entry(devfreq, &devfreq_list, node) { 1259 ret = devfreq_resume_device(devfreq); 1260 if (ret) 1261 dev_warn(&devfreq->dev, 1262 "failed to resume devfreq device\n"); 1263 } 1264 mutex_unlock(&devfreq_list_lock); 1265} 1266 1267/** 1268 * devfreq_add_governor() - Add devfreq governor 1269 * @governor: the devfreq governor to be added 1270 */ 1271int devfreq_add_governor(struct devfreq_governor *governor) 1272{ 1273 struct devfreq_governor *g; 1274 struct devfreq *devfreq; 1275 int err = 0; 1276 1277 if (!governor) { 1278 pr_err("%s: Invalid parameters.\n", __func__); 1279 return -EINVAL; 1280 } 1281 1282 mutex_lock(&devfreq_list_lock); 1283 g = find_devfreq_governor(governor->name); 1284 if (!IS_ERR(g)) { 1285 pr_err("%s: governor %s already registered\n", __func__, 1286 g->name); 1287 err = -EINVAL; 1288 goto err_out; 1289 } 1290 1291 list_add(&governor->node, &devfreq_governor_list); 1292 1293 list_for_each_entry(devfreq, &devfreq_list, node) { 1294 int ret = 0; 1295 struct device *dev = devfreq->dev.parent; 1296 1297 if (!strncmp(devfreq->governor->name, governor->name, 1298 DEVFREQ_NAME_LEN)) { 1299 /* The following should never occur */ 1300 if (devfreq->governor) { 1301 dev_warn(dev, 1302 "%s: Governor %s already present\n", 1303 __func__, devfreq->governor->name); 1304 ret = devfreq->governor->event_handler(devfreq, 1305 DEVFREQ_GOV_STOP, NULL); 1306 if (ret) { 1307 dev_warn(dev, 1308 "%s: Governor %s stop = %d\n", 1309 __func__, 1310 devfreq->governor->name, ret); 1311 } 1312 /* Fall through */ 1313 } 1314 devfreq->governor = governor; 1315 ret = devfreq->governor->event_handler(devfreq, 1316 DEVFREQ_GOV_START, NULL); 1317 if (ret) { 1318 dev_warn(dev, "%s: Governor %s start=%d\n", 1319 __func__, devfreq->governor->name, 1320 ret); 1321 } 1322 } 1323 } 1324 1325err_out: 1326 mutex_unlock(&devfreq_list_lock); 1327 1328 return err; 1329} 1330EXPORT_SYMBOL(devfreq_add_governor); 1331 1332static void devm_devfreq_remove_governor(void *governor) 1333{ 1334 WARN_ON(devfreq_remove_governor(governor)); 1335} 1336 1337/** 1338 * devm_devfreq_add_governor() - Add devfreq governor 1339 * @dev: device which adds devfreq governor 1340 * @governor: the devfreq governor to be added 1341 * 1342 * This is a resource-managed variant of devfreq_add_governor(). 1343 */ 1344int devm_devfreq_add_governor(struct device *dev, 1345 struct devfreq_governor *governor) 1346{ 1347 int err; 1348 1349 err = devfreq_add_governor(governor); 1350 if (err) 1351 return err; 1352 1353 return devm_add_action_or_reset(dev, devm_devfreq_remove_governor, 1354 governor); 1355} 1356EXPORT_SYMBOL(devm_devfreq_add_governor); 1357 1358/** 1359 * devfreq_remove_governor() - Remove devfreq feature from a device. 1360 * @governor: the devfreq governor to be removed 1361 */ 1362int devfreq_remove_governor(struct devfreq_governor *governor) 1363{ 1364 struct devfreq_governor *g; 1365 struct devfreq *devfreq; 1366 int err = 0; 1367 1368 if (!governor) { 1369 pr_err("%s: Invalid parameters.\n", __func__); 1370 return -EINVAL; 1371 } 1372 1373 mutex_lock(&devfreq_list_lock); 1374 g = find_devfreq_governor(governor->name); 1375 if (IS_ERR(g)) { 1376 pr_err("%s: governor %s not registered\n", __func__, 1377 governor->name); 1378 err = PTR_ERR(g); 1379 goto err_out; 1380 } 1381 list_for_each_entry(devfreq, &devfreq_list, node) { 1382 int ret; 1383 struct device *dev = devfreq->dev.parent; 1384 1385 if (!strncmp(devfreq->governor->name, governor->name, 1386 DEVFREQ_NAME_LEN)) { 1387 /* we should have a devfreq governor! */ 1388 if (!devfreq->governor) { 1389 dev_warn(dev, "%s: Governor %s NOT present\n", 1390 __func__, governor->name); 1391 continue; 1392 /* Fall through */ 1393 } 1394 ret = devfreq->governor->event_handler(devfreq, 1395 DEVFREQ_GOV_STOP, NULL); 1396 if (ret) { 1397 dev_warn(dev, "%s: Governor %s stop=%d\n", 1398 __func__, devfreq->governor->name, 1399 ret); 1400 } 1401 devfreq->governor = NULL; 1402 } 1403 } 1404 1405 list_del(&governor->node); 1406err_out: 1407 mutex_unlock(&devfreq_list_lock); 1408 1409 return err; 1410} 1411EXPORT_SYMBOL(devfreq_remove_governor); 1412 1413static ssize_t name_show(struct device *dev, 1414 struct device_attribute *attr, char *buf) 1415{ 1416 struct devfreq *df = to_devfreq(dev); 1417 return sprintf(buf, "%s\n", dev_name(df->dev.parent)); 1418} 1419static DEVICE_ATTR_RO(name); 1420 1421static ssize_t governor_show(struct device *dev, 1422 struct device_attribute *attr, char *buf) 1423{ 1424 struct devfreq *df = to_devfreq(dev); 1425 1426 if (!df->governor) 1427 return -EINVAL; 1428 1429 return sprintf(buf, "%s\n", df->governor->name); 1430} 1431 1432static ssize_t governor_store(struct device *dev, struct device_attribute *attr, 1433 const char *buf, size_t count) 1434{ 1435 struct devfreq *df = to_devfreq(dev); 1436 int ret; 1437 char str_governor[DEVFREQ_NAME_LEN + 1]; 1438 const struct devfreq_governor *governor, *prev_governor; 1439 1440 if (!df->governor) 1441 return -EINVAL; 1442 1443 ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor); 1444 if (ret != 1) 1445 return -EINVAL; 1446 1447 mutex_lock(&devfreq_list_lock); 1448 governor = try_then_request_governor(str_governor); 1449 if (IS_ERR(governor)) { 1450 ret = PTR_ERR(governor); 1451 goto out; 1452 } 1453 if (df->governor == governor) { 1454 ret = 0; 1455 goto out; 1456 } else if (IS_SUPPORTED_FLAG(df->governor->flags, IMMUTABLE) 1457 || IS_SUPPORTED_FLAG(governor->flags, IMMUTABLE)) { 1458 ret = -EINVAL; 1459 goto out; 1460 } 1461 1462 /* 1463 * Stop the current governor and remove the specific sysfs files 1464 * which depend on current governor. 1465 */ 1466 ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL); 1467 if (ret) { 1468 dev_warn(dev, "%s: Governor %s not stopped(%d)\n", 1469 __func__, df->governor->name, ret); 1470 goto out; 1471 } 1472 remove_sysfs_files(df, df->governor); 1473 1474 /* 1475 * Start the new governor and create the specific sysfs files 1476 * which depend on the new governor. 1477 */ 1478 prev_governor = df->governor; 1479 df->governor = governor; 1480 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL); 1481 if (ret) { 1482 dev_warn(dev, "%s: Governor %s not started(%d)\n", 1483 __func__, df->governor->name, ret); 1484 1485 /* Restore previous governor */ 1486 df->governor = prev_governor; 1487 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL); 1488 if (ret) { 1489 dev_err(dev, 1490 "%s: reverting to Governor %s failed (%d)\n", 1491 __func__, prev_governor->name, ret); 1492 df->governor = NULL; 1493 goto out; 1494 } 1495 } 1496 1497 /* 1498 * Create the sysfs files for the new governor. But if failed to start 1499 * the new governor, restore the sysfs files of previous governor. 1500 */ 1501 create_sysfs_files(df, df->governor); 1502 1503out: 1504 mutex_unlock(&devfreq_list_lock); 1505 1506 if (!ret) 1507 ret = count; 1508 return ret; 1509} 1510static DEVICE_ATTR_RW(governor); 1511 1512static ssize_t available_governors_show(struct device *d, 1513 struct device_attribute *attr, 1514 char *buf) 1515{ 1516 struct devfreq *df = to_devfreq(d); 1517 ssize_t count = 0; 1518 1519 if (!df->governor) 1520 return -EINVAL; 1521 1522 mutex_lock(&devfreq_list_lock); 1523 1524 /* 1525 * The devfreq with immutable governor (e.g., passive) shows 1526 * only own governor. 1527 */ 1528 if (IS_SUPPORTED_FLAG(df->governor->flags, IMMUTABLE)) { 1529 count = scnprintf(&buf[count], DEVFREQ_NAME_LEN, 1530 "%s ", df->governor->name); 1531 /* 1532 * The devfreq device shows the registered governor except for 1533 * immutable governors such as passive governor . 1534 */ 1535 } else { 1536 struct devfreq_governor *governor; 1537 1538 list_for_each_entry(governor, &devfreq_governor_list, node) { 1539 if (IS_SUPPORTED_FLAG(governor->flags, IMMUTABLE)) 1540 continue; 1541 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2), 1542 "%s ", governor->name); 1543 } 1544 } 1545 1546 mutex_unlock(&devfreq_list_lock); 1547 1548 /* Truncate the trailing space */ 1549 if (count) 1550 count--; 1551 1552 count += sprintf(&buf[count], "\n"); 1553 1554 return count; 1555} 1556static DEVICE_ATTR_RO(available_governors); 1557 1558static ssize_t cur_freq_show(struct device *dev, struct device_attribute *attr, 1559 char *buf) 1560{ 1561 unsigned long freq; 1562 struct devfreq *df = to_devfreq(dev); 1563 1564 if (!df->profile) 1565 return -EINVAL; 1566 1567 if (df->profile->get_cur_freq && 1568 !df->profile->get_cur_freq(df->dev.parent, &freq)) 1569 return sprintf(buf, "%lu\n", freq); 1570 1571 return sprintf(buf, "%lu\n", df->previous_freq); 1572} 1573static DEVICE_ATTR_RO(cur_freq); 1574 1575static ssize_t target_freq_show(struct device *dev, 1576 struct device_attribute *attr, char *buf) 1577{ 1578 struct devfreq *df = to_devfreq(dev); 1579 1580 return sprintf(buf, "%lu\n", df->previous_freq); 1581} 1582static DEVICE_ATTR_RO(target_freq); 1583 1584static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr, 1585 const char *buf, size_t count) 1586{ 1587 struct devfreq *df = to_devfreq(dev); 1588 unsigned long value; 1589 int ret; 1590 1591 /* 1592 * Protect against theoretical sysfs writes between 1593 * device_add and dev_pm_qos_add_request 1594 */ 1595 if (!dev_pm_qos_request_active(&df->user_min_freq_req)) 1596 return -EAGAIN; 1597 1598 ret = sscanf(buf, "%lu", &value); 1599 if (ret != 1) 1600 return -EINVAL; 1601 1602 /* Round down to kHz for PM QoS */ 1603 ret = dev_pm_qos_update_request(&df->user_min_freq_req, 1604 value / HZ_PER_KHZ); 1605 if (ret < 0) 1606 return ret; 1607 1608 return count; 1609} 1610 1611static ssize_t min_freq_show(struct device *dev, struct device_attribute *attr, 1612 char *buf) 1613{ 1614 struct devfreq *df = to_devfreq(dev); 1615 unsigned long min_freq, max_freq; 1616 1617 mutex_lock(&df->lock); 1618 devfreq_get_freq_range(df, &min_freq, &max_freq); 1619 mutex_unlock(&df->lock); 1620 1621 return sprintf(buf, "%lu\n", min_freq); 1622} 1623static DEVICE_ATTR_RW(min_freq); 1624 1625static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr, 1626 const char *buf, size_t count) 1627{ 1628 struct devfreq *df = to_devfreq(dev); 1629 unsigned long value; 1630 int ret; 1631 1632 /* 1633 * Protect against theoretical sysfs writes between 1634 * device_add and dev_pm_qos_add_request 1635 */ 1636 if (!dev_pm_qos_request_active(&df->user_max_freq_req)) 1637 return -EINVAL; 1638 1639 ret = sscanf(buf, "%lu", &value); 1640 if (ret != 1) 1641 return -EINVAL; 1642 1643 /* 1644 * PM QoS frequencies are in kHz so we need to convert. Convert by 1645 * rounding upwards so that the acceptable interval never shrinks. 1646 * 1647 * For example if the user writes "666666666" to sysfs this value will 1648 * be converted to 666667 kHz and back to 666667000 Hz before an OPP 1649 * lookup, this ensures that an OPP of 666666666Hz is still accepted. 1650 * 1651 * A value of zero means "no limit". 1652 */ 1653 if (value) 1654 value = DIV_ROUND_UP(value, HZ_PER_KHZ); 1655 else 1656 value = PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE; 1657 1658 ret = dev_pm_qos_update_request(&df->user_max_freq_req, value); 1659 if (ret < 0) 1660 return ret; 1661 1662 return count; 1663} 1664 1665static ssize_t max_freq_show(struct device *dev, struct device_attribute *attr, 1666 char *buf) 1667{ 1668 struct devfreq *df = to_devfreq(dev); 1669 unsigned long min_freq, max_freq; 1670 1671 mutex_lock(&df->lock); 1672 devfreq_get_freq_range(df, &min_freq, &max_freq); 1673 mutex_unlock(&df->lock); 1674 1675 return sprintf(buf, "%lu\n", max_freq); 1676} 1677static DEVICE_ATTR_RW(max_freq); 1678 1679static ssize_t available_frequencies_show(struct device *d, 1680 struct device_attribute *attr, 1681 char *buf) 1682{ 1683 struct devfreq *df = to_devfreq(d); 1684 ssize_t count = 0; 1685 int i; 1686 1687 if (!df->profile) 1688 return -EINVAL; 1689 1690 mutex_lock(&df->lock); 1691 1692 for (i = 0; i < df->max_state; i++) 1693 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2), 1694 "%lu ", df->freq_table[i]); 1695 1696 mutex_unlock(&df->lock); 1697 /* Truncate the trailing space */ 1698 if (count) 1699 count--; 1700 1701 count += sprintf(&buf[count], "\n"); 1702 1703 return count; 1704} 1705static DEVICE_ATTR_RO(available_frequencies); 1706 1707static ssize_t trans_stat_show(struct device *dev, 1708 struct device_attribute *attr, char *buf) 1709{ 1710 struct devfreq *df = to_devfreq(dev); 1711 ssize_t len = 0; 1712 int i, j; 1713 unsigned int max_state; 1714 1715 if (!df->profile) 1716 return -EINVAL; 1717 max_state = df->max_state; 1718 1719 if (max_state == 0) 1720 return sysfs_emit(buf, "Not Supported.\n"); 1721 1722 mutex_lock(&df->lock); 1723 if (!df->stop_polling && 1724 devfreq_update_status(df, df->previous_freq)) { 1725 mutex_unlock(&df->lock); 1726 return 0; 1727 } 1728 mutex_unlock(&df->lock); 1729 1730 len += sysfs_emit_at(buf, len, " From : To\n"); 1731 len += sysfs_emit_at(buf, len, " :"); 1732 for (i = 0; i < max_state; i++) { 1733 if (len >= PAGE_SIZE - 1) 1734 break; 1735 len += sysfs_emit_at(buf, len, "%10lu", 1736 df->freq_table[i]); 1737 } 1738 1739 if (len >= PAGE_SIZE - 1) 1740 return PAGE_SIZE - 1; 1741 len += sysfs_emit_at(buf, len, " time(ms)\n"); 1742 1743 for (i = 0; i < max_state; i++) { 1744 if (len >= PAGE_SIZE - 1) 1745 break; 1746 if (df->freq_table[2] == df->previous_freq) 1747 len += sysfs_emit_at(buf, len, "*"); 1748 else 1749 len += sysfs_emit_at(buf, len, " "); 1750 if (len >= PAGE_SIZE - 1) 1751 break; 1752 len += sysfs_emit_at(buf, len, "%10lu:", df->freq_table[i]); 1753 for (j = 0; j < max_state; j++) { 1754 if (len >= PAGE_SIZE - 1) 1755 break; 1756 len += sysfs_emit_at(buf, len, "%10u", 1757 df->stats.trans_table[(i * max_state) + j]); 1758 } 1759 if (len >= PAGE_SIZE - 1) 1760 break; 1761 len += sysfs_emit_at(buf, len, "%10llu\n", (u64) 1762 jiffies64_to_msecs(df->stats.time_in_state[i])); 1763 } 1764 1765 if (len < PAGE_SIZE - 1) 1766 len += sysfs_emit_at(buf, len, "Total transition : %u\n", 1767 df->stats.total_trans); 1768 if (len >= PAGE_SIZE - 1) { 1769 pr_warn_once("devfreq transition table exceeds PAGE_SIZE. Disabling\n"); 1770 return -EFBIG; 1771 } 1772 1773 return len; 1774} 1775 1776static ssize_t trans_stat_store(struct device *dev, 1777 struct device_attribute *attr, 1778 const char *buf, size_t count) 1779{ 1780 struct devfreq *df = to_devfreq(dev); 1781 int err, value; 1782 1783 if (!df->profile) 1784 return -EINVAL; 1785 1786 if (df->max_state == 0) 1787 return count; 1788 1789 err = kstrtoint(buf, 10, &value); 1790 if (err || value != 0) 1791 return -EINVAL; 1792 1793 mutex_lock(&df->lock); 1794 memset(df->stats.time_in_state, 0, (df->max_state * 1795 sizeof(*df->stats.time_in_state))); 1796 memset(df->stats.trans_table, 0, array3_size(sizeof(unsigned int), 1797 df->max_state, 1798 df->max_state)); 1799 df->stats.total_trans = 0; 1800 df->stats.last_update = get_jiffies_64(); 1801 mutex_unlock(&df->lock); 1802 1803 return count; 1804} 1805static DEVICE_ATTR_RW(trans_stat); 1806 1807static struct attribute *devfreq_attrs[] = { 1808 &dev_attr_name.attr, 1809 &dev_attr_governor.attr, 1810 &dev_attr_available_governors.attr, 1811 &dev_attr_cur_freq.attr, 1812 &dev_attr_available_frequencies.attr, 1813 &dev_attr_target_freq.attr, 1814 &dev_attr_min_freq.attr, 1815 &dev_attr_max_freq.attr, 1816 &dev_attr_trans_stat.attr, 1817 NULL, 1818}; 1819ATTRIBUTE_GROUPS(devfreq); 1820 1821static ssize_t polling_interval_show(struct device *dev, 1822 struct device_attribute *attr, char *buf) 1823{ 1824 struct devfreq *df = to_devfreq(dev); 1825 1826 if (!df->profile) 1827 return -EINVAL; 1828 1829 return sprintf(buf, "%d\n", df->profile->polling_ms); 1830} 1831 1832static ssize_t polling_interval_store(struct device *dev, 1833 struct device_attribute *attr, 1834 const char *buf, size_t count) 1835{ 1836 struct devfreq *df = to_devfreq(dev); 1837 unsigned int value; 1838 int ret; 1839 1840 if (!df->governor) 1841 return -EINVAL; 1842 1843 ret = sscanf(buf, "%u", &value); 1844 if (ret != 1) 1845 return -EINVAL; 1846 1847 df->governor->event_handler(df, DEVFREQ_GOV_UPDATE_INTERVAL, &value); 1848 ret = count; 1849 1850 return ret; 1851} 1852static DEVICE_ATTR_RW(polling_interval); 1853 1854static ssize_t timer_show(struct device *dev, 1855 struct device_attribute *attr, char *buf) 1856{ 1857 struct devfreq *df = to_devfreq(dev); 1858 1859 if (!df->profile) 1860 return -EINVAL; 1861 1862 return sprintf(buf, "%s\n", timer_name[df->profile->timer]); 1863} 1864 1865static ssize_t timer_store(struct device *dev, struct device_attribute *attr, 1866 const char *buf, size_t count) 1867{ 1868 struct devfreq *df = to_devfreq(dev); 1869 char str_timer[DEVFREQ_NAME_LEN + 1]; 1870 int timer = -1; 1871 int ret = 0, i; 1872 1873 if (!df->governor || !df->profile) 1874 return -EINVAL; 1875 1876 ret = sscanf(buf, "%16s", str_timer); 1877 if (ret != 1) 1878 return -EINVAL; 1879 1880 for (i = 0; i < DEVFREQ_TIMER_NUM; i++) { 1881 if (!strncmp(timer_name[i], str_timer, DEVFREQ_NAME_LEN)) { 1882 timer = i; 1883 break; 1884 } 1885 } 1886 1887 if (timer < 0) { 1888 ret = -EINVAL; 1889 goto out; 1890 } 1891 1892 if (df->profile->timer == timer) { 1893 ret = 0; 1894 goto out; 1895 } 1896 1897 mutex_lock(&df->lock); 1898 df->profile->timer = timer; 1899 mutex_unlock(&df->lock); 1900 1901 ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL); 1902 if (ret) { 1903 dev_warn(dev, "%s: Governor %s not stopped(%d)\n", 1904 __func__, df->governor->name, ret); 1905 goto out; 1906 } 1907 1908 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL); 1909 if (ret) 1910 dev_warn(dev, "%s: Governor %s not started(%d)\n", 1911 __func__, df->governor->name, ret); 1912out: 1913 return ret ? ret : count; 1914} 1915static DEVICE_ATTR_RW(timer); 1916 1917#define CREATE_SYSFS_FILE(df, name) \ 1918{ \ 1919 int ret; \ 1920 ret = sysfs_create_file(&df->dev.kobj, &dev_attr_##name.attr); \ 1921 if (ret < 0) { \ 1922 dev_warn(&df->dev, \ 1923 "Unable to create attr(%s)\n", "##name"); \ 1924 } \ 1925} \ 1926 1927/* Create the specific sysfs files which depend on each governor. */ 1928static void create_sysfs_files(struct devfreq *devfreq, 1929 const struct devfreq_governor *gov) 1930{ 1931 if (IS_SUPPORTED_ATTR(gov->attrs, POLLING_INTERVAL)) 1932 CREATE_SYSFS_FILE(devfreq, polling_interval); 1933 if (IS_SUPPORTED_ATTR(gov->attrs, TIMER)) 1934 CREATE_SYSFS_FILE(devfreq, timer); 1935} 1936 1937/* Remove the specific sysfs files which depend on each governor. */ 1938static void remove_sysfs_files(struct devfreq *devfreq, 1939 const struct devfreq_governor *gov) 1940{ 1941 if (IS_SUPPORTED_ATTR(gov->attrs, POLLING_INTERVAL)) 1942 sysfs_remove_file(&devfreq->dev.kobj, 1943 &dev_attr_polling_interval.attr); 1944 if (IS_SUPPORTED_ATTR(gov->attrs, TIMER)) 1945 sysfs_remove_file(&devfreq->dev.kobj, &dev_attr_timer.attr); 1946} 1947 1948/** 1949 * devfreq_summary_show() - Show the summary of the devfreq devices 1950 * @s: seq_file instance to show the summary of devfreq devices 1951 * @data: not used 1952 * 1953 * Show the summary of the devfreq devices via 'devfreq_summary' debugfs file. 1954 * It helps that user can know the detailed information of the devfreq devices. 1955 * 1956 * Return 0 always because it shows the information without any data change. 1957 */ 1958static int devfreq_summary_show(struct seq_file *s, void *data) 1959{ 1960 struct devfreq *devfreq; 1961 struct devfreq *p_devfreq = NULL; 1962 unsigned long cur_freq, min_freq, max_freq; 1963 unsigned int polling_ms; 1964 unsigned int timer; 1965 1966 seq_printf(s, "%-30s %-30s %-15s %-10s %10s %12s %12s %12s\n", 1967 "dev", 1968 "parent_dev", 1969 "governor", 1970 "timer", 1971 "polling_ms", 1972 "cur_freq_Hz", 1973 "min_freq_Hz", 1974 "max_freq_Hz"); 1975 seq_printf(s, "%30s %30s %15s %10s %10s %12s %12s %12s\n", 1976 "------------------------------", 1977 "------------------------------", 1978 "---------------", 1979 "----------", 1980 "----------", 1981 "------------", 1982 "------------", 1983 "------------"); 1984 1985 mutex_lock(&devfreq_list_lock); 1986 1987 list_for_each_entry_reverse(devfreq, &devfreq_list, node) { 1988#if IS_ENABLED(CONFIG_DEVFREQ_GOV_PASSIVE) 1989 if (!strncmp(devfreq->governor->name, DEVFREQ_GOV_PASSIVE, 1990 DEVFREQ_NAME_LEN)) { 1991 struct devfreq_passive_data *data = devfreq->data; 1992 1993 if (data) 1994 p_devfreq = data->parent; 1995 } else { 1996 p_devfreq = NULL; 1997 } 1998#endif 1999 2000 mutex_lock(&devfreq->lock); 2001 cur_freq = devfreq->previous_freq; 2002 devfreq_get_freq_range(devfreq, &min_freq, &max_freq); 2003 timer = devfreq->profile->timer; 2004 2005 if (IS_SUPPORTED_ATTR(devfreq->governor->attrs, POLLING_INTERVAL)) 2006 polling_ms = devfreq->profile->polling_ms; 2007 else 2008 polling_ms = 0; 2009 mutex_unlock(&devfreq->lock); 2010 2011 seq_printf(s, 2012 "%-30s %-30s %-15s %-10s %10d %12ld %12ld %12ld\n", 2013 dev_name(&devfreq->dev), 2014 p_devfreq ? dev_name(&p_devfreq->dev) : "null", 2015 devfreq->governor->name, 2016 polling_ms ? timer_name[timer] : "null", 2017 polling_ms, 2018 cur_freq, 2019 min_freq, 2020 max_freq); 2021 } 2022 2023 mutex_unlock(&devfreq_list_lock); 2024 2025 return 0; 2026} 2027DEFINE_SHOW_ATTRIBUTE(devfreq_summary); 2028 2029static int __init devfreq_init(void) 2030{ 2031 devfreq_class = class_create("devfreq"); 2032 if (IS_ERR(devfreq_class)) { 2033 pr_err("%s: couldn't create class\n", __FILE__); 2034 return PTR_ERR(devfreq_class); 2035 } 2036 2037 devfreq_wq = create_freezable_workqueue("devfreq_wq"); 2038 if (!devfreq_wq) { 2039 class_destroy(devfreq_class); 2040 pr_err("%s: couldn't create workqueue\n", __FILE__); 2041 return -ENOMEM; 2042 } 2043 devfreq_class->dev_groups = devfreq_groups; 2044 2045 devfreq_debugfs = debugfs_create_dir("devfreq", NULL); 2046 debugfs_create_file("devfreq_summary", 0444, 2047 devfreq_debugfs, NULL, 2048 &devfreq_summary_fops); 2049 2050 return 0; 2051} 2052subsys_initcall(devfreq_init); 2053 2054/* 2055 * The following are helper functions for devfreq user device drivers with 2056 * OPP framework. 2057 */ 2058 2059/** 2060 * devfreq_recommended_opp() - Helper function to get proper OPP for the 2061 * freq value given to target callback. 2062 * @dev: The devfreq user device. (parent of devfreq) 2063 * @freq: The frequency given to target function 2064 * @flags: Flags handed from devfreq framework. 2065 * 2066 * The callers are required to call dev_pm_opp_put() for the returned OPP after 2067 * use. 2068 */ 2069struct dev_pm_opp *devfreq_recommended_opp(struct device *dev, 2070 unsigned long *freq, 2071 u32 flags) 2072{ 2073 struct dev_pm_opp *opp; 2074 2075 if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) { 2076 /* The freq is an upper bound. opp should be lower */ 2077 opp = dev_pm_opp_find_freq_floor_indexed(dev, freq, 0); 2078 2079 /* If not available, use the closest opp */ 2080 if (opp == ERR_PTR(-ERANGE)) 2081 opp = dev_pm_opp_find_freq_ceil_indexed(dev, freq, 0); 2082 } else { 2083 /* The freq is an lower bound. opp should be higher */ 2084 opp = dev_pm_opp_find_freq_ceil_indexed(dev, freq, 0); 2085 2086 /* If not available, use the closest opp */ 2087 if (opp == ERR_PTR(-ERANGE)) 2088 opp = dev_pm_opp_find_freq_floor_indexed(dev, freq, 0); 2089 } 2090 2091 return opp; 2092} 2093EXPORT_SYMBOL(devfreq_recommended_opp); 2094 2095/** 2096 * devfreq_register_opp_notifier() - Helper function to get devfreq notified 2097 * for any changes in the OPP availability 2098 * changes 2099 * @dev: The devfreq user device. (parent of devfreq) 2100 * @devfreq: The devfreq object. 2101 */ 2102int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq) 2103{ 2104 return dev_pm_opp_register_notifier(dev, &devfreq->nb); 2105} 2106EXPORT_SYMBOL(devfreq_register_opp_notifier); 2107 2108/** 2109 * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq 2110 * notified for any changes in the OPP 2111 * availability changes anymore. 2112 * @dev: The devfreq user device. (parent of devfreq) 2113 * @devfreq: The devfreq object. 2114 * 2115 * At exit() callback of devfreq_dev_profile, this must be included if 2116 * devfreq_recommended_opp is used. 2117 */ 2118int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq) 2119{ 2120 return dev_pm_opp_unregister_notifier(dev, &devfreq->nb); 2121} 2122EXPORT_SYMBOL(devfreq_unregister_opp_notifier); 2123 2124static void devm_devfreq_opp_release(struct device *dev, void *res) 2125{ 2126 devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res); 2127} 2128 2129/** 2130 * devm_devfreq_register_opp_notifier() - Resource-managed 2131 * devfreq_register_opp_notifier() 2132 * @dev: The devfreq user device. (parent of devfreq) 2133 * @devfreq: The devfreq object. 2134 */ 2135int devm_devfreq_register_opp_notifier(struct device *dev, 2136 struct devfreq *devfreq) 2137{ 2138 struct devfreq **ptr; 2139 int ret; 2140 2141 ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL); 2142 if (!ptr) 2143 return -ENOMEM; 2144 2145 ret = devfreq_register_opp_notifier(dev, devfreq); 2146 if (ret) { 2147 devres_free(ptr); 2148 return ret; 2149 } 2150 2151 *ptr = devfreq; 2152 devres_add(dev, ptr); 2153 2154 return 0; 2155} 2156EXPORT_SYMBOL(devm_devfreq_register_opp_notifier); 2157 2158/** 2159 * devm_devfreq_unregister_opp_notifier() - Resource-managed 2160 * devfreq_unregister_opp_notifier() 2161 * @dev: The devfreq user device. (parent of devfreq) 2162 * @devfreq: The devfreq object. 2163 */ 2164void devm_devfreq_unregister_opp_notifier(struct device *dev, 2165 struct devfreq *devfreq) 2166{ 2167 WARN_ON(devres_release(dev, devm_devfreq_opp_release, 2168 devm_devfreq_dev_match, devfreq)); 2169} 2170EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier); 2171 2172/** 2173 * devfreq_register_notifier() - Register a driver with devfreq 2174 * @devfreq: The devfreq object. 2175 * @nb: The notifier block to register. 2176 * @list: DEVFREQ_TRANSITION_NOTIFIER. 2177 */ 2178int devfreq_register_notifier(struct devfreq *devfreq, 2179 struct notifier_block *nb, 2180 unsigned int list) 2181{ 2182 int ret = 0; 2183 2184 if (!devfreq) 2185 return -EINVAL; 2186 2187 switch (list) { 2188 case DEVFREQ_TRANSITION_NOTIFIER: 2189 ret = srcu_notifier_chain_register( 2190 &devfreq->transition_notifier_list, nb); 2191 break; 2192 default: 2193 ret = -EINVAL; 2194 } 2195 2196 return ret; 2197} 2198EXPORT_SYMBOL(devfreq_register_notifier); 2199 2200/* 2201 * devfreq_unregister_notifier() - Unregister a driver with devfreq 2202 * @devfreq: The devfreq object. 2203 * @nb: The notifier block to be unregistered. 2204 * @list: DEVFREQ_TRANSITION_NOTIFIER. 2205 */ 2206int devfreq_unregister_notifier(struct devfreq *devfreq, 2207 struct notifier_block *nb, 2208 unsigned int list) 2209{ 2210 int ret = 0; 2211 2212 if (!devfreq) 2213 return -EINVAL; 2214 2215 switch (list) { 2216 case DEVFREQ_TRANSITION_NOTIFIER: 2217 ret = srcu_notifier_chain_unregister( 2218 &devfreq->transition_notifier_list, nb); 2219 break; 2220 default: 2221 ret = -EINVAL; 2222 } 2223 2224 return ret; 2225} 2226EXPORT_SYMBOL(devfreq_unregister_notifier); 2227 2228struct devfreq_notifier_devres { 2229 struct devfreq *devfreq; 2230 struct notifier_block *nb; 2231 unsigned int list; 2232}; 2233 2234static void devm_devfreq_notifier_release(struct device *dev, void *res) 2235{ 2236 struct devfreq_notifier_devres *this = res; 2237 2238 devfreq_unregister_notifier(this->devfreq, this->nb, this->list); 2239} 2240 2241/** 2242 * devm_devfreq_register_notifier() 2243 * - Resource-managed devfreq_register_notifier() 2244 * @dev: The devfreq user device. (parent of devfreq) 2245 * @devfreq: The devfreq object. 2246 * @nb: The notifier block to be unregistered. 2247 * @list: DEVFREQ_TRANSITION_NOTIFIER. 2248 */ 2249int devm_devfreq_register_notifier(struct device *dev, 2250 struct devfreq *devfreq, 2251 struct notifier_block *nb, 2252 unsigned int list) 2253{ 2254 struct devfreq_notifier_devres *ptr; 2255 int ret; 2256 2257 ptr = devres_alloc(devm_devfreq_notifier_release, sizeof(*ptr), 2258 GFP_KERNEL); 2259 if (!ptr) 2260 return -ENOMEM; 2261 2262 ret = devfreq_register_notifier(devfreq, nb, list); 2263 if (ret) { 2264 devres_free(ptr); 2265 return ret; 2266 } 2267 2268 ptr->devfreq = devfreq; 2269 ptr->nb = nb; 2270 ptr->list = list; 2271 devres_add(dev, ptr); 2272 2273 return 0; 2274} 2275EXPORT_SYMBOL(devm_devfreq_register_notifier); 2276 2277/** 2278 * devm_devfreq_unregister_notifier() 2279 * - Resource-managed devfreq_unregister_notifier() 2280 * @dev: The devfreq user device. (parent of devfreq) 2281 * @devfreq: The devfreq object. 2282 * @nb: The notifier block to be unregistered. 2283 * @list: DEVFREQ_TRANSITION_NOTIFIER. 2284 */ 2285void devm_devfreq_unregister_notifier(struct device *dev, 2286 struct devfreq *devfreq, 2287 struct notifier_block *nb, 2288 unsigned int list) 2289{ 2290 WARN_ON(devres_release(dev, devm_devfreq_notifier_release, 2291 devm_devfreq_dev_match, devfreq)); 2292} 2293EXPORT_SYMBOL(devm_devfreq_unregister_notifier); 2294