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