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