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
  36static struct class *devfreq_class;
  37static 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 */
 
  44static struct workqueue_struct *devfreq_wq;
 
 
 
 
  45
  46/* The list of all device-devfreq governors */
  47static LIST_HEAD(devfreq_governor_list);
  48/* The list of all device-devfreq */
  49static LIST_HEAD(devfreq_list);
  50static DEFINE_MUTEX(devfreq_list_lock);
  51
  52static 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 */
  64static 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
  83static 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
  97static 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 */
 119static 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 */
 164static 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
 175static 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 */
 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->profile->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	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 */
 394int 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}
 423EXPORT_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 */
 430static 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 */
 457void 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}
 477EXPORT_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 */
 487void devfreq_monitor_stop(struct devfreq *devfreq)
 488{
 489	if (devfreq->governor->interrupt_driven)
 490		return;
 491
 492	cancel_delayed_work_sync(&devfreq->work);
 493}
 494EXPORT_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 */
 508void 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}
 525EXPORT_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 */
 535void 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
 551out_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
 559out:
 560	mutex_unlock(&devfreq->lock);
 
 
 
 561}
 562EXPORT_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 */
 572void 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	}
 609out:
 610	mutex_unlock(&devfreq->lock);
 611}
 612EXPORT_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 */
 623static 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
 643out:
 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 */
 657static 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 */
 676static 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 */
 686static 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 */
 698static 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 */
 746struct 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
 902err_init:
 903	mutex_unlock(&devfreq_list_lock);
 904err_devfreq:
 905	devfreq_remove_device(devfreq);
 906	devfreq = NULL;
 907err_dev:
 
 908	kfree(devfreq);
 909err_out:
 910	return ERR_PTR(err);
 911}
 912EXPORT_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 */
 920int 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}
 932EXPORT_SYMBOL(devfreq_remove_device);
 933
 934static 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
 944static 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 */
 961struct 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}
 983EXPORT_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 */
 993struct 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
1023struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, int index)
1024{
1025	return ERR_PTR(-ENODEV);
1026}
1027#endif /* CONFIG_OF */
1028EXPORT_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 */
1035void 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}
1040EXPORT_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 */
1050int 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}
1077EXPORT_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 */
1087int 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}
1114EXPORT_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 */
1124void 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 */
1145void 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 */
1164int 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
1218err_out:
1219	mutex_unlock(&devfreq_list_lock);
1220
1221	return err;
1222}
1223EXPORT_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 */
1229int 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);
1273err_out:
1274	mutex_unlock(&devfreq_list_lock);
1275
1276	return err;
1277}
1278EXPORT_SYMBOL(devfreq_remove_governor);
1279
1280static 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}
1286static DEVICE_ATTR_RO(name);
1287
1288static 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
1299static 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	}
1353out:
1354	mutex_unlock(&devfreq_list_lock);
1355
1356	if (!ret)
1357		ret = count;
1358	return ret;
1359}
1360static DEVICE_ATTR_RW(governor);
1361
1362static 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}
1406static DEVICE_ATTR_RO(available_governors);
1407
1408static 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}
1423static DEVICE_ATTR_RO(cur_freq);
1424
1425static 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}
1432static DEVICE_ATTR_RO(target_freq);
1433
1434static 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
1445static 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}
1465static DEVICE_ATTR_RW(polling_interval);
1466
1467static 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
1494static 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}
1506static DEVICE_ATTR_RW(min_freq);
1507
1508static 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
1548static 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}
1560static DEVICE_ATTR_RW(max_freq);
1561
1562static 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}
1588static DEVICE_ATTR_RO(available_frequencies);
1589
1590static 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
1643static 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}
1672static DEVICE_ATTR_RW(trans_stat);
1673
1674static 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
1685static 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);
1732out:
1733	return ret ? ret : count;
1734}
1735static DEVICE_ATTR_RW(timer);
1736
1737static 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};
1751ATTRIBUTE_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 */
1763static 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	unsigned int timer;
1770
1771	seq_printf(s, "%-30s %-30s %-15s %-10s %10s %12s %12s %12s\n",
1772			"dev",
1773			"parent_dev",
1774			"governor",
1775			"timer",
1776			"polling_ms",
1777			"cur_freq_Hz",
1778			"min_freq_Hz",
1779			"max_freq_Hz");
1780	seq_printf(s, "%30s %30s %15s %10s %10s %12s %12s %12s\n",
1781			"------------------------------",
1782			"------------------------------",
1783			"---------------",
1784			"----------",
1785			"----------",
1786			"------------",
1787			"------------",
1788			"------------");
1789
1790	mutex_lock(&devfreq_list_lock);
1791
1792	list_for_each_entry_reverse(devfreq, &devfreq_list, node) {
1793#if IS_ENABLED(CONFIG_DEVFREQ_GOV_PASSIVE)
1794		if (!strncmp(devfreq->governor_name, DEVFREQ_GOV_PASSIVE,
1795							DEVFREQ_NAME_LEN)) {
1796			struct devfreq_passive_data *data = devfreq->data;
1797
1798			if (data)
1799				p_devfreq = data->parent;
1800		} else {
1801			p_devfreq = NULL;
1802		}
1803#endif
1804
1805		mutex_lock(&devfreq->lock);
1806		cur_freq = devfreq->previous_freq;
1807		get_freq_range(devfreq, &min_freq, &max_freq);
1808		polling_ms = devfreq->profile->polling_ms;
1809		timer = devfreq->profile->timer;
1810		mutex_unlock(&devfreq->lock);
1811
1812		seq_printf(s,
1813			"%-30s %-30s %-15s %-10s %10d %12ld %12ld %12ld\n",
1814			dev_name(&devfreq->dev),
1815			p_devfreq ? dev_name(&p_devfreq->dev) : "null",
1816			devfreq->governor_name,
1817			polling_ms ? timer_name[timer] : "null",
1818			polling_ms,
1819			cur_freq,
1820			min_freq,
1821			max_freq);
1822	}
1823
1824	mutex_unlock(&devfreq_list_lock);
1825
 
1826	return 0;
1827}
1828DEFINE_SHOW_ATTRIBUTE(devfreq_summary);
1829
1830static int __init devfreq_init(void)
1831{
1832	devfreq_class = class_create(THIS_MODULE, "devfreq");
1833	if (IS_ERR(devfreq_class)) {
1834		pr_err("%s: couldn't create class\n", __FILE__);
1835		return PTR_ERR(devfreq_class);
1836	}
1837
1838	devfreq_wq = create_freezable_workqueue("devfreq_wq");
1839	if (!devfreq_wq) {
1840		class_destroy(devfreq_class);
1841		pr_err("%s: couldn't create workqueue\n", __FILE__);
1842		return -ENOMEM;
1843	}
1844	devfreq_class->dev_groups = devfreq_groups;
1845
1846	devfreq_debugfs = debugfs_create_dir("devfreq", NULL);
1847	debugfs_create_file("devfreq_summary", 0444,
1848				devfreq_debugfs, NULL,
1849				&devfreq_summary_fops);
1850
1851	return 0;
1852}
1853subsys_initcall(devfreq_init);
1854
 
 
 
 
 
 
1855/*
1856 * The following are helper functions for devfreq user device drivers with
1857 * OPP framework.
1858 */
1859
1860/**
1861 * devfreq_recommended_opp() - Helper function to get proper OPP for the
1862 *			     freq value given to target callback.
1863 * @dev:	The devfreq user device. (parent of devfreq)
1864 * @freq:	The frequency given to target function
1865 * @flags:	Flags handed from devfreq framework.
1866 *
1867 * The callers are required to call dev_pm_opp_put() for the returned OPP after
1868 * use.
1869 */
1870struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
1871					   unsigned long *freq,
1872					   u32 flags)
1873{
1874	struct dev_pm_opp *opp;
1875
1876	if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) {
1877		/* The freq is an upper bound. opp should be lower */
1878		opp = dev_pm_opp_find_freq_floor(dev, freq);
1879
1880		/* If not available, use the closest opp */
1881		if (opp == ERR_PTR(-ERANGE))
1882			opp = dev_pm_opp_find_freq_ceil(dev, freq);
1883	} else {
1884		/* The freq is an lower bound. opp should be higher */
1885		opp = dev_pm_opp_find_freq_ceil(dev, freq);
1886
1887		/* If not available, use the closest opp */
1888		if (opp == ERR_PTR(-ERANGE))
1889			opp = dev_pm_opp_find_freq_floor(dev, freq);
1890	}
1891
1892	return opp;
1893}
1894EXPORT_SYMBOL(devfreq_recommended_opp);
1895
1896/**
1897 * devfreq_register_opp_notifier() - Helper function to get devfreq notified
1898 *				     for any changes in the OPP availability
1899 *				     changes
1900 * @dev:	The devfreq user device. (parent of devfreq)
1901 * @devfreq:	The devfreq object.
1902 */
1903int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
1904{
1905	return dev_pm_opp_register_notifier(dev, &devfreq->nb);
 
 
 
 
1906}
1907EXPORT_SYMBOL(devfreq_register_opp_notifier);
1908
1909/**
1910 * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
1911 *				       notified for any changes in the OPP
1912 *				       availability changes anymore.
1913 * @dev:	The devfreq user device. (parent of devfreq)
1914 * @devfreq:	The devfreq object.
1915 *
1916 * At exit() callback of devfreq_dev_profile, this must be included if
1917 * devfreq_recommended_opp is used.
1918 */
1919int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
1920{
1921	return dev_pm_opp_unregister_notifier(dev, &devfreq->nb);
1922}
1923EXPORT_SYMBOL(devfreq_unregister_opp_notifier);
1924
1925static void devm_devfreq_opp_release(struct device *dev, void *res)
1926{
1927	devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);
1928}
1929
1930/**
1931 * devm_devfreq_register_opp_notifier() - Resource-managed
1932 *					  devfreq_register_opp_notifier()
1933 * @dev:	The devfreq user device. (parent of devfreq)
1934 * @devfreq:	The devfreq object.
1935 */
1936int devm_devfreq_register_opp_notifier(struct device *dev,
1937				       struct devfreq *devfreq)
1938{
1939	struct devfreq **ptr;
1940	int ret;
1941
1942	ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL);
1943	if (!ptr)
1944		return -ENOMEM;
1945
1946	ret = devfreq_register_opp_notifier(dev, devfreq);
1947	if (ret) {
1948		devres_free(ptr);
1949		return ret;
1950	}
1951
1952	*ptr = devfreq;
1953	devres_add(dev, ptr);
1954
1955	return 0;
1956}
1957EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
1958
1959/**
1960 * devm_devfreq_unregister_opp_notifier() - Resource-managed
1961 *					    devfreq_unregister_opp_notifier()
1962 * @dev:	The devfreq user device. (parent of devfreq)
1963 * @devfreq:	The devfreq object.
1964 */
1965void devm_devfreq_unregister_opp_notifier(struct device *dev,
1966					 struct devfreq *devfreq)
1967{
1968	WARN_ON(devres_release(dev, devm_devfreq_opp_release,
1969			       devm_devfreq_dev_match, devfreq));
1970}
1971EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
1972
1973/**
1974 * devfreq_register_notifier() - Register a driver with devfreq
1975 * @devfreq:	The devfreq object.
1976 * @nb:		The notifier block to register.
1977 * @list:	DEVFREQ_TRANSITION_NOTIFIER.
1978 */
1979int devfreq_register_notifier(struct devfreq *devfreq,
1980			      struct notifier_block *nb,
1981			      unsigned int list)
1982{
1983	int ret = 0;
1984
1985	if (!devfreq)
1986		return -EINVAL;
1987
1988	switch (list) {
1989	case DEVFREQ_TRANSITION_NOTIFIER:
1990		ret = srcu_notifier_chain_register(
1991				&devfreq->transition_notifier_list, nb);
1992		break;
1993	default:
1994		ret = -EINVAL;
1995	}
1996
1997	return ret;
 
 
1998}
1999EXPORT_SYMBOL(devfreq_register_notifier);
2000
2001/*
2002 * devfreq_unregister_notifier() - Unregister a driver with devfreq
2003 * @devfreq:	The devfreq object.
2004 * @nb:		The notifier block to be unregistered.
2005 * @list:	DEVFREQ_TRANSITION_NOTIFIER.
2006 */
2007int devfreq_unregister_notifier(struct devfreq *devfreq,
2008				struct notifier_block *nb,
2009				unsigned int list)
2010{
2011	int ret = 0;
2012
2013	if (!devfreq)
2014		return -EINVAL;
2015
2016	switch (list) {
2017	case DEVFREQ_TRANSITION_NOTIFIER:
2018		ret = srcu_notifier_chain_unregister(
2019				&devfreq->transition_notifier_list, nb);
2020		break;
2021	default:
2022		ret = -EINVAL;
2023	}
2024
2025	return ret;
2026}
2027EXPORT_SYMBOL(devfreq_unregister_notifier);
2028
2029struct devfreq_notifier_devres {
2030	struct devfreq *devfreq;
2031	struct notifier_block *nb;
2032	unsigned int list;
2033};
2034
2035static void devm_devfreq_notifier_release(struct device *dev, void *res)
2036{
2037	struct devfreq_notifier_devres *this = res;
2038
2039	devfreq_unregister_notifier(this->devfreq, this->nb, this->list);
2040}
2041
2042/**
2043 * devm_devfreq_register_notifier()
2044 *	- Resource-managed devfreq_register_notifier()
2045 * @dev:	The devfreq user device. (parent of devfreq)
2046 * @devfreq:	The devfreq object.
2047 * @nb:		The notifier block to be unregistered.
2048 * @list:	DEVFREQ_TRANSITION_NOTIFIER.
2049 */
2050int devm_devfreq_register_notifier(struct device *dev,
2051				struct devfreq *devfreq,
2052				struct notifier_block *nb,
2053				unsigned int list)
2054{
2055	struct devfreq_notifier_devres *ptr;
2056	int ret;
2057
2058	ptr = devres_alloc(devm_devfreq_notifier_release, sizeof(*ptr),
2059				GFP_KERNEL);
2060	if (!ptr)
2061		return -ENOMEM;
2062
2063	ret = devfreq_register_notifier(devfreq, nb, list);
2064	if (ret) {
2065		devres_free(ptr);
2066		return ret;
2067	}
2068
2069	ptr->devfreq = devfreq;
2070	ptr->nb = nb;
2071	ptr->list = list;
2072	devres_add(dev, ptr);
2073
2074	return 0;
2075}
2076EXPORT_SYMBOL(devm_devfreq_register_notifier);
2077
2078/**
2079 * devm_devfreq_unregister_notifier()
2080 *	- Resource-managed devfreq_unregister_notifier()
2081 * @dev:	The devfreq user device. (parent of devfreq)
2082 * @devfreq:	The devfreq object.
2083 * @nb:		The notifier block to be unregistered.
2084 * @list:	DEVFREQ_TRANSITION_NOTIFIER.
2085 */
2086void devm_devfreq_unregister_notifier(struct device *dev,
2087				      struct devfreq *devfreq,
2088				      struct notifier_block *nb,
2089				      unsigned int list)
2090{
2091	WARN_ON(devres_release(dev, devm_devfreq_notifier_release,
2092			       devm_devfreq_dev_match, devfreq));
2093}
2094EXPORT_SYMBOL(devm_devfreq_unregister_notifier);