include/linux/devfreq.h - LeafOS-Devices/android_kernel_samsung_universal7904 - Gitiles

 /*
  * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
  *	    for Non-CPU Devices.
  *
  * Copyright (C) 2011 Samsung Electronics
  *	MyungJoo Ham <myungjoo.ham@samsung.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */

 #ifndef __LINUX_DEVFREQ_H__
 #define __LINUX_DEVFREQ_H__

 #include <linux/device.h>
 #include <linux/notifier.h>
 #include <linux/pm_opp.h>
 #include <linux/kthread.h>
 #include <linux/timer.h>

 #define DEVFREQ_NAME_LEN 16

 struct devfreq;

 /**
  * struct devfreq_dev_status - Data given from devfreq user device to
  *			     governors. Represents the performance
  *			     statistics.
  * @total_time:		The total time represented by this instance of
  *			devfreq_dev_status
  * @busy_time:		The time that the device was working among the
  *			total_time.
  * @current_frequency:	The operating frequency.
  * @private_data:	An entry not specified by the devfreq framework.
  *			A device and a specific governor may have their
  *			own protocol with private_data. However, because
  *			this is governor-specific, a governor using this
  *			will be only compatible with devices aware of it.
  */
 struct devfreq_dev_status {
 	/* both since the last measure */
 	unsigned long long total_time;
 	unsigned long long busy_time;
 	unsigned long long delta_time;
 	unsigned long current_frequency;
 	void *private_data;
 };

 /*
  * The resulting frequency should be at most this. (this bound is the
  * least upper bound; thus, the resulting freq should be lower or same)
  * If the flag is not set, the resulting frequency should be at most the
  * bound (greatest lower bound)
  */
 #define DEVFREQ_FLAG_LEAST_UPPER_BOUND		0x1

 /**
  * struct devfreq_dev_profile - Devfreq's user device profile
  * @initial_freq:	The operating frequency when devfreq_add_device() is
  *			called.
  * @polling_ms:		The polling interval in ms. 0 disables polling.
  * @target:		The device should set its operating frequency at
  *			freq or lowest-upper-than-freq value. If freq is
  *			higher than any operable frequency, set maximum.
  *			Before returning, target function should set
  *			freq at the current frequency.
  *			The "flags" parameter's possible values are
  *			explained above with "DEVFREQ_FLAG_*" macros.
  * @get_dev_status:	The device should provide the current performance
  *			status to devfreq. Governors are recommended not to
  *			use this directly. Instead, governors are recommended
  *			to use devfreq_update_stats() along with
  *			devfreq.last_status.
  * @get_cur_freq:	The device should provide the current frequency
  *			at which it is operating.
  * @exit:		An optional callback that is called when devfreq
  *			is removing the devfreq object due to error or
  *			from devfreq_remove_device() call. If the user
  *			has registered devfreq->nb at a notifier-head,
  *			this is the time to unregister it.
  * @freq_table:	Optional list of frequencies to support statistics.
  * @max_state:	The size of freq_table.
  */
 struct devfreq_dev_profile {
 	unsigned long initial_freq;
 	unsigned long suspend_freq;
 	unsigned int polling_ms;

 	int (*target)(struct device *dev, unsigned long *freq, u32 flags);
 	int (*get_dev_status)(struct device *dev,
 			      struct devfreq_dev_status *stat);
 	int (*get_cur_freq)(struct device *dev, unsigned long *freq);
 	void (*exit)(struct device *dev);

 	unsigned int *freq_table;
 	unsigned int max_state;
 };

 /**
  * struct devfreq_governor - Devfreq policy governor
  * @node:		list node - contains registered devfreq governors
  * @name:		Governor's name
  * @get_target_freq:	Returns desired operating frequency for the device.
  *			Basically, get_target_freq will run
  *			devfreq_dev_profile.get_dev_status() to get the
  *			status of the device (load = busy_time / total_time).
  *			If no_central_polling is set, this callback is called
  *			only with update_devfreq() notified by OPP.
  * @event_handler:      Callback for devfreq core framework to notify events
  *                      to governors. Events include per device governor
  *                      init and exit, opp changes out of devfreq, suspend
  *                      and resume of per device devfreq during device idle.
  *
  * Note that the callbacks are called with devfreq->lock locked by devfreq.
  */
 struct devfreq_governor {
 	struct list_head node;

 	const char name[DEVFREQ_NAME_LEN];
 	int (*get_target_freq)(struct devfreq *this, unsigned long *freq);
 	int (*event_handler)(struct devfreq *devfreq,
 				unsigned int event, void *data);
 };

 /**
  * struct devfreq - Device devfreq structure
  * @node:	list node - contains the devices with devfreq that have been
  *		registered.
  * @lock:	a mutex to protect accessing devfreq.
  * @dev:	device registered by devfreq class. dev.parent is the device
  *		using devfreq.
  * @profile:	device-specific devfreq profile
  * @governor:	method how to choose frequency based on the usage.
  * @governor_name:	devfreq governor name for use with this devfreq
  * @nb:		notifier block used to notify devfreq object that it should
  *		reevaluate operable frequencies. Devfreq users may use
  *		devfreq.nb to the corresponding register notifier call chain.
  * @work:	delayed work for load monitoring.
  * @previous_freq:	previously configured frequency value.
  * @data:	Private data of the governor. The devfreq framework does not
  *		touch this.
  * @min_freq:	Limit minimum frequency requested by user (0: none)
  * @max_freq:	Limit maximum frequency requested by user (0: none)
  * @stop_polling:	 devfreq polling status of a device.
  * @total_trans:	Number of devfreq transitions
  * @trans_table:	Statistics of devfreq transitions
  * @time_in_state:	Statistics of devfreq states
  * @last_stat_updated:	The last time stat updated
  *
  * This structure stores the devfreq information for a give device.
  *
  * Note that when a governor accesses entries in struct devfreq in its
  * functions except for the context of callbacks defined in struct
  * devfreq_governor, the governor should protect its access with the
  * struct mutex lock in struct devfreq. A governor may use this mutex
  * to protect its own private data in void *data as well.
  */
 struct devfreq {
 	struct list_head node;

 	struct mutex lock;
 	struct device dev;
 	struct devfreq_dev_profile *profile;
 	const struct devfreq_governor *governor;
 	char governor_name[DEVFREQ_NAME_LEN];
 	struct notifier_block nb;
 	struct delayed_work work;

 	unsigned long previous_freq;
 	struct devfreq_dev_status last_status;

 	void *data; /* private data for governors */

 	unsigned long min_freq;
 	unsigned long max_freq;
 	unsigned long str_freq;
 	bool stop_polling;

 	/* information for device frequency transition */
 	unsigned int total_trans;
 	unsigned int *trans_table;
 	unsigned long *time_in_state;
 	unsigned long last_stat_updated;

 	bool disabled_pm_qos;
 };

 #if defined(CONFIG_PM_DEVFREQ)
 extern struct devfreq *devfreq_add_device(struct device *dev,
 				  struct devfreq_dev_profile *profile,
 				  const char *governor_name,
 				  void *data);
 extern int devfreq_remove_device(struct devfreq *devfreq);
 extern struct devfreq *devm_devfreq_add_device(struct device *dev,
 				  struct devfreq_dev_profile *profile,
 				  const char *governor_name,
 				  void *data);
 extern void devm_devfreq_remove_device(struct device *dev,
 				  struct devfreq *devfreq);

 /* Supposed to be called by PM callbacks */
 extern int devfreq_suspend_device(struct devfreq *devfreq);
 extern int devfreq_resume_device(struct devfreq *devfreq);

 /* Helper functions for devfreq user device driver with OPP. */
 extern struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
 					   unsigned long *freq, u32 flags);
 extern int devfreq_register_opp_notifier(struct device *dev,
 					 struct devfreq *devfreq);
 extern int devfreq_unregister_opp_notifier(struct device *dev,
 					   struct devfreq *devfreq);
 extern int devm_devfreq_register_opp_notifier(struct device *dev,
 					      struct devfreq *devfreq);
 extern void devm_devfreq_unregister_opp_notifier(struct device *dev,
 						struct devfreq *devfreq);

 /**
  * devfreq_update_stats() - update the last_status pointer in struct devfreq
  * @df:		the devfreq instance whose status needs updating
  *
  *  Governors are recommended to use this function along with last_status,
  * which allows other entities to reuse the last_status without affecting
  * the values fetched later by governors.
  */
 static inline int devfreq_update_stats(struct devfreq *df)
 {
 	return df->profile->get_dev_status(df->dev.parent, &df->last_status);
 }
 #if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND) || IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_USAGE)\
 	|| IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_INTERACTIVE)
 struct devfreq_notifier_block {
 	struct notifier_block nb;
 	struct devfreq *df;
 };
 #endif

 #if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND)
 /**
  * struct devfreq_simple_ondemand_data - void *data fed to struct devfreq
  *	and devfreq_add_device
  * @upthreshold:	If the load is over this value, the frequency jumps.
  *			Specify 0 to use the default. Valid value = 0 to 100.
  * @downdifferential:	If the load is under upthreshold - downdifferential,
  *			the governor may consider slowing the frequency down.
  *			Specify 0 to use the default. Valid value = 0 to 100.
  *			downdifferential < upthreshold must hold.
  *
  * If the fed devfreq_simple_ondemand_data pointer is NULL to the governor,
  * the governor uses the default values.
  */
 struct devfreq_simple_ondemand_data {
 	unsigned int multiplication_weight;
 	unsigned int upthreshold;
 	unsigned int downdifferential;
 	unsigned long cal_qos_max;
 	int pm_qos_class;
 	struct devfreq_notifier_block nb;
 };
 #endif

 #if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_USAGE)
 struct devfreq_simple_usage_data {
 	unsigned int multiplication_weight;
 	unsigned int proportional;
 	unsigned int upthreshold;
 	unsigned int target_percentage;
 	int pm_qos_class;
 	unsigned long cal_qos_max;
 	bool en_monitoring;
 	struct devfreq_notifier_block nb;
 };
 #endif

 #if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_EXYNOS)
 struct devfreq_simple_exynos_data {
 	unsigned int urgentthreshold;
 	unsigned int upthreshold;
 	unsigned int downthreshold;
 	unsigned int idlethreshold;
 	unsigned long above_freq;
 	unsigned long below_freq;
 	int pm_qos_class;
 	int pm_qos_class_max;
 	unsigned long cal_qos_max;
 	bool en_monitoring;
 	struct devfreq_notifier_block nb;
 	struct devfreq_notifier_block nb_max;
 };
 #endif

 #if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_INTERACTIVE)
 #define DEFAULT_DELAY_TIME		10 /* msec */
 #define DEFAULT_NDELAY_TIME		1
 #define DELAY_TIME_RANGE		10
 #define BOUND_CPU_NUM			0

 #ifdef CONFIG_EXYNOS_WD_DVFS
 #define SIMPLE_LOAD_MAX				10
 struct devfreq_simple_load {
 	unsigned long long delta;
 	unsigned int load;
 };
 #endif
 struct devfreq_simple_interactive_data {
 #ifdef CONFIG_EXYNOS_WD_DVFS
 	struct devfreq_simple_load buffer[SIMPLE_LOAD_MAX];
 	struct devfreq_simple_load *front;
 	struct devfreq_simple_load *rear;
 	unsigned long long busy;
 	unsigned long long total;
 	unsigned int min_load;
 	unsigned int max_load;
 	unsigned long long max_spent;
 	/* governor parameter */
 #define INTERACTIVE_MIN_SAMPLE_TIME	15
 	unsigned int min_sample_time;
 #define INTERACTIVE_HOLD_SAMPLE_TIME	100
 	unsigned int hold_sample_time;
 #define INTERACTIVE_TARGET_LOAD		75
 #define INTERACTIVE_NTARGET_LOAD	1
 	unsigned int *target_load;
 	unsigned int ntarget_load;
 #define INTERACTIVE_GO_HISPEED_LOAD	99
 	unsigned int go_hispeed_load;
 #define INTERACTIVE_HISPEED_FREQ	1000000
 	unsigned int hispeed_freq;
 #define INTERACTIVE_TOLERANCE		1
 	unsigned int tolerance;
 	/* governor end */
 #endif
 	bool use_delay_time;
 	int *delay_time;
 	int ndelay_time;
 	unsigned long prev_freq;
 	u64 changed_time;
 	struct timer_list freq_timer;
 	struct timer_list freq_slack_timer;
 	struct task_struct *change_freq_task;
 	int pm_qos_class;
 	int pm_qos_class_max;
 	struct devfreq_notifier_block nb;
 	struct devfreq_notifier_block nb_max;
 };
 #endif

 #else /* !CONFIG_PM_DEVFREQ */
 static inline struct devfreq *devfreq_add_device(struct device *dev,
 					  struct devfreq_dev_profile *profile,
 					  const char *governor_name,
 					  void *data)
 {
 	return ERR_PTR(-ENOSYS);
 }

 static inline int devfreq_remove_device(struct devfreq *devfreq)
 {
 	return 0;
 }

 static inline struct devfreq *devm_devfreq_add_device(struct device *dev,
 					struct devfreq_dev_profile *profile,
 					const char *governor_name,
 					void *data)
 {
 	return ERR_PTR(-ENOSYS);
 }

 static inline void devm_devfreq_remove_device(struct device *dev,
 					struct devfreq *devfreq)
 {
 }

 static inline int devfreq_suspend_device(struct devfreq *devfreq)
 {
 	return 0;
 }

 static inline int devfreq_resume_device(struct devfreq *devfreq)
 {
 	return 0;
 }

 static inline struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
 					   unsigned long *freq, u32 flags)
 {
 	return ERR_PTR(-EINVAL);
 }

 static inline int devfreq_register_opp_notifier(struct device *dev,
 					 struct devfreq *devfreq)
 {
 	return -EINVAL;
 }

 static inline int devfreq_unregister_opp_notifier(struct device *dev,
 					   struct devfreq *devfreq)
 {
 	return -EINVAL;
 }

 static inline int devm_devfreq_register_opp_notifier(struct device *dev,
 						     struct devfreq *devfreq)
 {
 	return -EINVAL;
 }

 static inline void devm_devfreq_unregister_opp_notifier(struct device *dev,
 							struct devfreq *devfreq)
 {
 }

 static inline int devfreq_update_stats(struct devfreq *df)
 {
 	return -EINVAL;
 }
 #endif /* CONFIG_PM_DEVFREQ */

 #endif /* __LINUX_DEVFREQ_H__ */
	/*
	* devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
	* for Non-CPU Devices.
	*
	* Copyright (C) 2011 Samsung Electronics
	* MyungJoo Ham <myungjoo.ham@samsung.com>
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*/

	#ifndef __LINUX_DEVFREQ_H__
	#define __LINUX_DEVFREQ_H__

	#include <linux/device.h>
	#include <linux/notifier.h>
	#include <linux/pm_opp.h>
	#include <linux/kthread.h>
	#include <linux/timer.h>

	#define DEVFREQ_NAME_LEN 16

	struct devfreq;

	/**
	* struct devfreq_dev_status - Data given from devfreq user device to
	* governors. Represents the performance
	* statistics.
	* @total_time: The total time represented by this instance of
	* devfreq_dev_status
	* @busy_time: The time that the device was working among the
	* total_time.
	* @current_frequency: The operating frequency.
	* @private_data: An entry not specified by the devfreq framework.
	* A device and a specific governor may have their
	* own protocol with private_data. However, because
	* this is governor-specific, a governor using this
	* will be only compatible with devices aware of it.
	*/
	struct devfreq_dev_status {
	/* both since the last measure */
	unsigned long long total_time;
	unsigned long long busy_time;
	unsigned long long delta_time;
	unsigned long current_frequency;
	void *private_data;
	};

	/*
	* The resulting frequency should be at most this. (this bound is the
	* least upper bound; thus, the resulting freq should be lower or same)
	* If the flag is not set, the resulting frequency should be at most the
	* bound (greatest lower bound)
	*/
	#define DEVFREQ_FLAG_LEAST_UPPER_BOUND 0x1

	/**
	* struct devfreq_dev_profile - Devfreq's user device profile
	* @initial_freq: The operating frequency when devfreq_add_device() is
	* called.
	* @polling_ms: The polling interval in ms. 0 disables polling.
	* @target: The device should set its operating frequency at
	* freq or lowest-upper-than-freq value. If freq is
	* higher than any operable frequency, set maximum.
	* Before returning, target function should set
	* freq at the current frequency.
	* The "flags" parameter's possible values are
	* explained above with "DEVFREQ_FLAG_*" macros.
	* @get_dev_status: The device should provide the current performance
	* status to devfreq. Governors are recommended not to
	* use this directly. Instead, governors are recommended
	* to use devfreq_update_stats() along with
	* devfreq.last_status.
	* @get_cur_freq: The device should provide the current frequency
	* at which it is operating.
	* @exit: An optional callback that is called when devfreq
	* is removing the devfreq object due to error or
	* from devfreq_remove_device() call. If the user
	* has registered devfreq->nb at a notifier-head,
	* this is the time to unregister it.
	* @freq_table: Optional list of frequencies to support statistics.
	* @max_state: The size of freq_table.
	*/
	struct devfreq_dev_profile {
	unsigned long initial_freq;
	unsigned long suspend_freq;
	unsigned int polling_ms;

	int (target)(struct device dev, unsigned long *freq, u32 flags);
	int (get_dev_status)(struct device dev,
	struct devfreq_dev_status *stat);
	int (get_cur_freq)(struct device dev, unsigned long *freq);
	void (exit)(struct device dev);

	unsigned int *freq_table;
	unsigned int max_state;
	};

	/**
	* struct devfreq_governor - Devfreq policy governor
	* @node: list node - contains registered devfreq governors
	* @name: Governor's name
	* @get_target_freq: Returns desired operating frequency for the device.
	* Basically, get_target_freq will run
	* devfreq_dev_profile.get_dev_status() to get the
	* status of the device (load = busy_time / total_time).
	* If no_central_polling is set, this callback is called
	* only with update_devfreq() notified by OPP.
	* @event_handler: Callback for devfreq core framework to notify events
	* to governors. Events include per device governor
	* init and exit, opp changes out of devfreq, suspend
	* and resume of per device devfreq during device idle.
	*
	* Note that the callbacks are called with devfreq->lock locked by devfreq.
	*/
	struct devfreq_governor {
	struct list_head node;

	const char name[DEVFREQ_NAME_LEN];
	int (get_target_freq)(struct devfreq this, unsigned long *freq);
	int (event_handler)(struct devfreq devfreq,
	unsigned int event, void *data);
	};

	/**
	* struct devfreq - Device devfreq structure
	* @node: list node - contains the devices with devfreq that have been
	* registered.
	* @lock: a mutex to protect accessing devfreq.
	* @dev: device registered by devfreq class. dev.parent is the device
	* using devfreq.
	* @profile: device-specific devfreq profile
	* @governor: method how to choose frequency based on the usage.
	* @governor_name: devfreq governor name for use with this devfreq
	* @nb: notifier block used to notify devfreq object that it should
	* reevaluate operable frequencies. Devfreq users may use
	* devfreq.nb to the corresponding register notifier call chain.
	* @work: delayed work for load monitoring.
	* @previous_freq: previously configured frequency value.
	* @data: Private data of the governor. The devfreq framework does not
	* touch this.
	* @min_freq: Limit minimum frequency requested by user (0: none)
	* @max_freq: Limit maximum frequency requested by user (0: none)
	* @stop_polling: devfreq polling status of a device.
	* @total_trans: Number of devfreq transitions
	* @trans_table: Statistics of devfreq transitions
	* @time_in_state: Statistics of devfreq states
	* @last_stat_updated: The last time stat updated
	*
	* This structure stores the devfreq information for a give device.
	*
	* Note that when a governor accesses entries in struct devfreq in its
	* functions except for the context of callbacks defined in struct
	* devfreq_governor, the governor should protect its access with the
	* struct mutex lock in struct devfreq. A governor may use this mutex
	* to protect its own private data in void *data as well.
	*/
	struct devfreq {
	struct list_head node;

	struct mutex lock;
	struct device dev;
	struct devfreq_dev_profile *profile;
	const struct devfreq_governor *governor;
	char governor_name[DEVFREQ_NAME_LEN];
	struct notifier_block nb;
	struct delayed_work work;

	unsigned long previous_freq;
	struct devfreq_dev_status last_status;

	void data; / private data for governors */

	unsigned long min_freq;
	unsigned long max_freq;
	unsigned long str_freq;
	bool stop_polling;

	/* information for device frequency transition */
	unsigned int total_trans;
	unsigned int *trans_table;
	unsigned long *time_in_state;
	unsigned long last_stat_updated;

	bool disabled_pm_qos;
	};

	#if defined(CONFIG_PM_DEVFREQ)
	extern struct devfreq devfreq_add_device(struct device dev,
	struct devfreq_dev_profile *profile,
	const char *governor_name,
	void *data);
	extern int devfreq_remove_device(struct devfreq *devfreq);
	extern struct devfreq devm_devfreq_add_device(struct device dev,
	struct devfreq_dev_profile *profile,
	const char *governor_name,
	void *data);
	extern void devm_devfreq_remove_device(struct device *dev,
	struct devfreq *devfreq);

	/* Supposed to be called by PM callbacks */
	extern int devfreq_suspend_device(struct devfreq *devfreq);
	extern int devfreq_resume_device(struct devfreq *devfreq);

	/* Helper functions for devfreq user device driver with OPP. */
	extern struct dev_pm_opp devfreq_recommended_opp(struct device dev,
	unsigned long *freq, u32 flags);
	extern int devfreq_register_opp_notifier(struct device *dev,
	struct devfreq *devfreq);
	extern int devfreq_unregister_opp_notifier(struct device *dev,
	struct devfreq *devfreq);
	extern int devm_devfreq_register_opp_notifier(struct device *dev,
	struct devfreq *devfreq);
	extern void devm_devfreq_unregister_opp_notifier(struct device *dev,
	struct devfreq *devfreq);

	/**
	* devfreq_update_stats() - update the last_status pointer in struct devfreq
	* @df: the devfreq instance whose status needs updating
	*
	* Governors are recommended to use this function along with last_status,
	* which allows other entities to reuse the last_status without affecting
	* the values fetched later by governors.
	*/
	static inline int devfreq_update_stats(struct devfreq *df)
	{
	return df->profile->get_dev_status(df->dev.parent, &df->last_status);
	}
	#if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND) \|\| IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_USAGE)\
	\|\| IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_INTERACTIVE)
	struct devfreq_notifier_block {
	struct notifier_block nb;
	struct devfreq *df;
	};
	#endif

	#if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND)
	/**
	* struct devfreq_simple_ondemand_data - void *data fed to struct devfreq
	* and devfreq_add_device
	* @upthreshold: If the load is over this value, the frequency jumps.
	* Specify 0 to use the default. Valid value = 0 to 100.
	* @downdifferential: If the load is under upthreshold - downdifferential,
	* the governor may consider slowing the frequency down.
	* Specify 0 to use the default. Valid value = 0 to 100.
	* downdifferential < upthreshold must hold.
	*
	* If the fed devfreq_simple_ondemand_data pointer is NULL to the governor,
	* the governor uses the default values.
	*/
	struct devfreq_simple_ondemand_data {
	unsigned int multiplication_weight;
	unsigned int upthreshold;
	unsigned int downdifferential;
	unsigned long cal_qos_max;
	int pm_qos_class;
	struct devfreq_notifier_block nb;
	};
	#endif

	#if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_USAGE)
	struct devfreq_simple_usage_data {
	unsigned int multiplication_weight;
	unsigned int proportional;
	unsigned int upthreshold;
	unsigned int target_percentage;
	int pm_qos_class;
	unsigned long cal_qos_max;
	bool en_monitoring;
	struct devfreq_notifier_block nb;
	};
	#endif

	#if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_EXYNOS)
	struct devfreq_simple_exynos_data {
	unsigned int urgentthreshold;
	unsigned int upthreshold;
	unsigned int downthreshold;
	unsigned int idlethreshold;
	unsigned long above_freq;
	unsigned long below_freq;
	int pm_qos_class;
	int pm_qos_class_max;
	unsigned long cal_qos_max;
	bool en_monitoring;
	struct devfreq_notifier_block nb;
	struct devfreq_notifier_block nb_max;
	};
	#endif

	#if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_INTERACTIVE)
	#define DEFAULT_DELAY_TIME 10 /* msec */
	#define DEFAULT_NDELAY_TIME 1
	#define DELAY_TIME_RANGE 10
	#define BOUND_CPU_NUM 0

	#ifdef CONFIG_EXYNOS_WD_DVFS
	#define SIMPLE_LOAD_MAX 10
	struct devfreq_simple_load {
	unsigned long long delta;
	unsigned int load;
	};
	#endif
	struct devfreq_simple_interactive_data {
	#ifdef CONFIG_EXYNOS_WD_DVFS
	struct devfreq_simple_load buffer[SIMPLE_LOAD_MAX];
	struct devfreq_simple_load *front;
	struct devfreq_simple_load *rear;
	unsigned long long busy;
	unsigned long long total;
	unsigned int min_load;
	unsigned int max_load;
	unsigned long long max_spent;
	/* governor parameter */
	#define INTERACTIVE_MIN_SAMPLE_TIME 15
	unsigned int min_sample_time;
	#define INTERACTIVE_HOLD_SAMPLE_TIME 100
	unsigned int hold_sample_time;
	#define INTERACTIVE_TARGET_LOAD 75
	#define INTERACTIVE_NTARGET_LOAD 1
	unsigned int *target_load;
	unsigned int ntarget_load;
	#define INTERACTIVE_GO_HISPEED_LOAD 99
	unsigned int go_hispeed_load;
	#define INTERACTIVE_HISPEED_FREQ 1000000
	unsigned int hispeed_freq;
	#define INTERACTIVE_TOLERANCE 1
	unsigned int tolerance;
	/* governor end */
	#endif
	bool use_delay_time;
	int *delay_time;
	int ndelay_time;
	unsigned long prev_freq;
	u64 changed_time;
	struct timer_list freq_timer;
	struct timer_list freq_slack_timer;
	struct task_struct *change_freq_task;
	int pm_qos_class;
	int pm_qos_class_max;
	struct devfreq_notifier_block nb;
	struct devfreq_notifier_block nb_max;
	};
	#endif

	#else /* !CONFIG_PM_DEVFREQ */
	static inline struct devfreq devfreq_add_device(struct device dev,
	struct devfreq_dev_profile *profile,
	const char *governor_name,
	void *data)
	{
	return ERR_PTR(-ENOSYS);
	}

	static inline int devfreq_remove_device(struct devfreq *devfreq)
	{
	return 0;
	}

	static inline struct devfreq devm_devfreq_add_device(struct device dev,
	struct devfreq_dev_profile *profile,
	const char *governor_name,
	void *data)
	{
	return ERR_PTR(-ENOSYS);
	}

	static inline void devm_devfreq_remove_device(struct device *dev,
	struct devfreq *devfreq)
	{
	}

	static inline int devfreq_suspend_device(struct devfreq *devfreq)
	{
	return 0;
	}

	static inline int devfreq_resume_device(struct devfreq *devfreq)
	{
	return 0;
	}

	static inline struct dev_pm_opp devfreq_recommended_opp(struct device dev,
	unsigned long *freq, u32 flags)
	{
	return ERR_PTR(-EINVAL);
	}

	static inline int devfreq_register_opp_notifier(struct device *dev,
	struct devfreq *devfreq)
	{
	return -EINVAL;
	}

	static inline int devfreq_unregister_opp_notifier(struct device *dev,
	struct devfreq *devfreq)
	{
	return -EINVAL;
	}

	static inline int devm_devfreq_register_opp_notifier(struct device *dev,
	struct devfreq *devfreq)
	{
	return -EINVAL;
	}

	static inline void devm_devfreq_unregister_opp_notifier(struct device *dev,
	struct devfreq *devfreq)
	{
	}

	static inline int devfreq_update_stats(struct devfreq *df)
	{
	return -EINVAL;
	}
	#endif /* CONFIG_PM_DEVFREQ */

	#endif /* __LINUX_DEVFREQ_H__ */