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
39	static struct class *devfreq_class;
40	static 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	*/
47	static struct workqueue_struct *devfreq_wq;
48
49	/* The list of all device-devfreq governors */
50	static LIST_HEAD(devfreq_governor_list);
51	/* The list of all device-devfreq */
52	static LIST_HEAD(devfreq_list);
53	static DEFINE_MUTEX(devfreq_list_lock);
54
55	static 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	*/
67	static 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(ptr: dev)) {
74	pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
75	return ERR_PTR(error: -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(error: -ENODEV);
84	}
85
86	static 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(dev: devfreq->dev.parent, freq: &min_freq, index: 0);
92	if (IS_ERR(ptr: opp))
93	min_freq = 0;
94	else
95	dev_pm_opp_put(opp);
96
97	return min_freq;
98	}
99
100	static 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(dev: devfreq->dev.parent, freq: &max_freq, index: 0);
106	if (IS_ERR(ptr: 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	*/
122	void 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(dev: devfreq->dev.parent,
146	type: DEV_PM_QOS_MIN_FREQUENCY);
147	qos_max_freq = dev_pm_qos_read_value(dev: devfreq->dev.parent,
148	type: 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	}
161	EXPORT_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	*/
168	static 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
179	static 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(dev: devfreq->dev.parent);
187	if (count <= 0)
188	return -EINVAL;
189
190	devfreq->max_state = count;
191	devfreq->freq_table = devm_kcalloc(dev: devfreq->dev.parent,
192	n: devfreq->max_state,
193	size: 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(dev: devfreq->dev.parent, freq: &freq, index: 0);
200	if (IS_ERR(ptr: opp)) {
201	devm_kfree(dev: devfreq->dev.parent, p: devfreq->freq_table);
202	return PTR_ERR(ptr: 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	*/
216	int devfreq_update_status(struct devfreq *devfreq, unsigned long freq)
217	{
218	int lev, prev_lev, ret = 0;
219	u64 cur_time;
220
221	lockdep_assert_held(&devfreq->lock);
222	cur_time = get_jiffies_64();
223
224	/* Immediately exit if previous_freq is not initialized yet. */
225	if (!devfreq->previous_freq)
226	goto out;
227
228	prev_lev = devfreq_get_freq_level(devfreq, freq: 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
249	out:
250	devfreq->stats.last_update = cur_time;
251	return ret;
252	}
253	EXPORT_SYMBOL(devfreq_update_status);
254
255	/**
256	* find_devfreq_governor() - find devfreq governor from name
257	* @name: name of the governor
258	*
259	* Search the list of devfreq governors and return the matched
260	* governor's pointer. devfreq_list_lock should be held by the caller.
261	*/
262	static struct devfreq_governor *find_devfreq_governor(const char *name)
263	{
264	struct devfreq_governor *tmp_governor;
265
266	lockdep_assert_held(&devfreq_list_lock);
267
268	if (IS_ERR_OR_NULL(ptr: name)) {
269	pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
270	return ERR_PTR(error: -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(error: -ENODEV);
279	}
280
281	/**
282	* try_then_request_governor() - Try to find the governor and request the
283	* module if is not found.
284	* @name: name of the governor
285	*
286	* Search the list of devfreq governors and request the module and try again
287	* if is not found. This can happen when both drivers (the governor driver
288	* and the driver that call devfreq_add_device) are built as modules.
289	* devfreq_list_lock should be held by the caller. Returns the matched
290	* governor's pointer or an error pointer.
291	*/
292	static struct devfreq_governor *try_then_request_governor(const char *name)
293	{
294	struct devfreq_governor *governor;
295	int err = 0;
296
297	lockdep_assert_held(&devfreq_list_lock);
298
299	if (IS_ERR_OR_NULL(ptr: name)) {
300	pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
301	return ERR_PTR(error: -EINVAL);
302	}
303
304	governor = find_devfreq_governor(name);
305	if (IS_ERR(ptr: governor)) {
306	mutex_unlock(lock: &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(error: err) : ERR_PTR(error: -EINVAL);
317
318	governor = find_devfreq_governor(name);
319	}
320
321	return governor;
322	}
323
324	static int devfreq_notify_transition(struct devfreq *devfreq,
325	struct devfreq_freqs *freqs, unsigned int state)
326	{
327	if (!devfreq)
328	return -EINVAL;
329
330	switch (state) {
331	case DEVFREQ_PRECHANGE:
332	srcu_notifier_call_chain(nh: &devfreq->transition_notifier_list,
333	DEVFREQ_PRECHANGE, v: freqs);
334	break;
335
336	case DEVFREQ_POSTCHANGE:
337	srcu_notifier_call_chain(nh: &devfreq->transition_notifier_list,
338	DEVFREQ_POSTCHANGE, v: freqs);
339	break;
340	default:
341	return -EINVAL;
342	}
343
344	return 0;
345	}
346
347	static int devfreq_set_target(struct devfreq *devfreq, unsigned long new_freq,
348	u32 flags)
349	{
350	struct devfreq_freqs freqs;
351	unsigned long cur_freq;
352	int err = 0;
353
354	if (devfreq->profile->get_cur_freq)
355	devfreq->profile->get_cur_freq(devfreq->dev.parent, &cur_freq);
356	else
357	cur_freq = devfreq->previous_freq;
358
359	freqs.old = cur_freq;
360	freqs.new = new_freq;
361	devfreq_notify_transition(devfreq, freqs: &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: &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, freq: new_freq, prev_freq: cur_freq);
377
378	freqs.new = new_freq;
379	devfreq_notify_transition(devfreq, freqs: &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	*/
403	int 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, new_freq: freq, flags);
430	}
431	EXPORT_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	*/
442	int update_devfreq(struct devfreq *devfreq)
443	{
444	return devfreq_update_target(devfreq, 0L);
445	}
446	EXPORT_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	*/
453	static 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(wq: devfreq_wq, dwork: &devfreq->work,
468	delay: msecs_to_jiffies(m: devfreq->profile->polling_ms));
469
470	out:
471	mutex_unlock(lock: &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	*/
485	void 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(wq: devfreq_wq, dwork: &devfreq->work,
507	delay: msecs_to_jiffies(m: devfreq->profile->polling_ms));
508
509	out:
510	devfreq->stop_polling = false;
511	mutex_unlock(lock: &devfreq->lock);
512	}
513	EXPORT_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	*/
523	void 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(lock: &devfreq->lock);
531	return;
532	}
533
534	devfreq->stop_polling = true;
535	mutex_unlock(lock: &devfreq->lock);
536	cancel_delayed_work_sync(dwork: &devfreq->work);
537	}
538	EXPORT_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	*/
552	void devfreq_monitor_suspend(struct devfreq *devfreq)
553	{
554	mutex_lock(&devfreq->lock);
555	if (devfreq->stop_polling) {
556	mutex_unlock(lock: &devfreq->lock);
557	return;
558	}
559
560	devfreq_update_status(devfreq, devfreq->previous_freq);
561	devfreq->stop_polling = true;
562	mutex_unlock(lock: &devfreq->lock);
563
564	if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN))
565	return;
566
567	cancel_delayed_work_sync(dwork: &devfreq->work);
568	}
569	EXPORT_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	*/
579	void 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(wq: devfreq_wq, dwork: &devfreq->work,
594	delay: msecs_to_jiffies(m: devfreq->profile->polling_ms));
595
596	out_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
604	out:
605	mutex_unlock(lock: &devfreq->lock);
606	}
607	EXPORT_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	*/
617	void 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(lock: &devfreq->lock);
634	cancel_delayed_work_sync(dwork: &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(wq: devfreq_wq, dwork: &devfreq->work,
641	delay: msecs_to_jiffies(m: 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(lock: &devfreq->lock);
648	cancel_delayed_work_sync(dwork: &devfreq->work);
649	mutex_lock(&devfreq->lock);
650	if (!devfreq->stop_polling)
651	queue_delayed_work(wq: devfreq_wq, dwork: &devfreq->work,
652	delay: msecs_to_jiffies(m: devfreq->profile->polling_ms));
653	}
654	out:
655	mutex_unlock(lock: &devfreq->lock);
656	}
657	EXPORT_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	*/
668	static 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
688	out:
689	mutex_unlock(lock: &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	*/
702	static 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(lock: &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	*/
723	static 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	*/
735	static 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	*/
747	static 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(entry: &devfreq->node);
754	mutex_unlock(lock: &devfreq_list_lock);
755
756	err = dev_pm_qos_remove_notifier(dev: devfreq->dev.parent, notifier: &devfreq->nb_max,
757	type: 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(dev: devfreq->dev.parent, notifier: &devfreq->nb_min,
762	type: 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(req: &devfreq->user_max_freq_req)) {
768	err = dev_pm_qos_remove_request(req: &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(req: &devfreq->user_min_freq_req)) {
774	err = dev_pm_qos_remove_request(req: &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(opp_table: devfreq->opp_table);
785
786	mutex_destroy(lock: &devfreq->lock);
787	srcu_cleanup_notifier_head(&devfreq->transition_notifier_list);
788	kfree(objp: devfreq);
789	}
790
791	static void create_sysfs_files(struct devfreq *devfreq,
792	const struct devfreq_governor *gov);
793	static 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	*/
803	struct 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(error: -EINVAL);
816	}
817
818	mutex_lock(&devfreq_list_lock);
819	devfreq = find_device_devfreq(dev);
820	mutex_unlock(lock: &devfreq_list_lock);
821	if (!IS_ERR(ptr: 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(size: 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(list: &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(lock: &devfreq->lock);
849	err = -EINVAL;
850	goto err_dev;
851	}
852
853	if (!devfreq->profile->max_state || !devfreq->profile->freq_table) {
854	mutex_unlock(lock: &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(lock: &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(lock: &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(ptr: devfreq->opp_table))
883	devfreq->opp_table = NULL;
884
885	atomic_set(v: &devfreq->suspend_count, i: 0);
886
887	dev_set_name(dev: &devfreq->dev, name: "%s", dev_name(dev));
888	err = device_register(dev: &devfreq->dev);
889	if (err) {
890	mutex_unlock(lock: &devfreq->lock);
891	put_device(dev: &devfreq->dev);
892	goto err_out;
893	}
894
895	devfreq->stats.trans_table = devm_kzalloc(dev: &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(lock: &devfreq->lock);
902	err = -ENOMEM;
903	goto err_devfreq;
904	}
905
906	devfreq->stats.time_in_state = devm_kcalloc(dev: &devfreq->dev,
907	n: devfreq->max_state,
908	size: sizeof(*devfreq->stats.time_in_state),
909	GFP_KERNEL);
910	if (!devfreq->stats.time_in_state) {
911	mutex_unlock(lock: &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(nh: &devfreq->transition_notifier_list);
920
921	mutex_unlock(lock: &devfreq->lock);
922
923	err = dev_pm_qos_add_request(dev, req: &devfreq->user_min_freq_req,
924	type: DEV_PM_QOS_MIN_FREQUENCY, value: 0);
925	if (err < 0)
926	goto err_devfreq;
927	err = dev_pm_qos_add_request(dev, req: &devfreq->user_max_freq_req,
928	type: 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, notifier: &devfreq->nb_min,
935	type: 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, notifier: &devfreq->nb_max,
941	type: 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(name: governor_name);
948	if (IS_ERR(ptr: governor)) {
949	dev_err(dev, "%s: Unable to find governor for the device\n",
950	__func__);
951	err = PTR_ERR(ptr: 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	fmt: "%s: Unable to start governor for the device\n",
961	__func__);
962	goto err_init;
963	}
964	create_sysfs_files(devfreq, gov: devfreq->governor);
965
966	list_add(new: &devfreq->node, head: &devfreq_list);
967
968	mutex_unlock(lock: &devfreq_list_lock);
969
970	if (devfreq->profile->is_cooling_device) {
971	devfreq->cdev = devfreq_cooling_em_register(df: devfreq, NULL);
972	if (IS_ERR(ptr: devfreq->cdev))
973	devfreq->cdev = NULL;
974	}
975
976	return devfreq;
977
978	err_init:
979	mutex_unlock(lock: &devfreq_list_lock);
980	err_devfreq:
981	devfreq_remove_device(devfreq);
982	devfreq = NULL;
983	err_dev:
984	kfree(objp: devfreq);
985	err_out:
986	return ERR_PTR(error: err);
987	}
988	EXPORT_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	*/
996	int devfreq_remove_device(struct devfreq *devfreq)
997	{
998	if (!devfreq)
999	return -EINVAL;
1000
1001	devfreq_cooling_unregister(dfc: devfreq->cdev);
1002
1003	if (devfreq->governor) {
1004	devfreq->governor->event_handler(devfreq,
1005	DEVFREQ_GOV_STOP, NULL);
1006	remove_sysfs_files(devfreq, gov: devfreq->governor);
1007	}
1008
1009	device_unregister(dev: &devfreq->dev);
1010
1011	return 0;
1012	}
1013	EXPORT_SYMBOL(devfreq_remove_device);
1014
1015	static 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
1025	static 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	*/
1041	struct 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(error: -ENOMEM);
1051
1052	devfreq = devfreq_add_device(dev, profile, governor_name, data);
1053	if (IS_ERR(ptr: devfreq)) {
1054	devres_free(res: ptr);
1055	return devfreq;
1056	}
1057
1058	*ptr = devfreq;
1059	devres_add(dev, res: ptr);
1060
1061	return devfreq;
1062	}
1063	EXPORT_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	*/
1072	struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node)
1073	{
1074	struct devfreq *devfreq;
1075
1076	if (!node)
1077	return ERR_PTR(error: -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(dev: devfreq->dev.parent, np: node)) {
1083	mutex_unlock(lock: &devfreq_list_lock);
1084	return devfreq;
1085	}
1086	}
1087	mutex_unlock(lock: &devfreq_list_lock);
1088
1089	return ERR_PTR(error: -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	*/
1100	struct 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(error: -EINVAL);
1108
1109	if (!dev->of_node)
1110	return ERR_PTR(error: -EINVAL);
1111
1112	node = of_parse_phandle(np: dev->of_node, phandle_name, index);
1113	if (!node)
1114	return ERR_PTR(error: -ENODEV);
1115
1116	devfreq = devfreq_get_devfreq_by_node(node);
1117	of_node_put(node);
1118
1119	return devfreq;
1120	}
1121
1122	#else
1123	struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node)
1124	{
1125	return ERR_PTR(-ENODEV);
1126	}
1127
1128	struct 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 */
1134	EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_node);
1135	EXPORT_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	*/
1142	void 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	}
1147	EXPORT_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	*/
1157	int devfreq_suspend_device(struct devfreq *devfreq)
1158	{
1159	int ret;
1160
1161	if (!devfreq)
1162	return -EINVAL;
1163
1164	if (atomic_inc_return(v: &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, new_freq: devfreq->suspend_freq, flags: 0);
1177	mutex_unlock(lock: &devfreq->lock);
1178	if (ret)
1179	return ret;
1180	}
1181
1182	return 0;
1183	}
1184	EXPORT_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	*/
1194	int devfreq_resume_device(struct devfreq *devfreq)
1195	{
1196	int ret;
1197
1198	if (!devfreq)
1199	return -EINVAL;
1200
1201	if (atomic_dec_return(v: &devfreq->suspend_count) >= 1)
1202	return 0;
1203
1204	if (devfreq->resume_freq) {
1205	mutex_lock(&devfreq->lock);
1206	ret = devfreq_set_target(devfreq, new_freq: devfreq->resume_freq, flags: 0);
1207	mutex_unlock(lock: &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	}
1221	EXPORT_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	*/
1231	void 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(lock: &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	*/
1252	void 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(lock: &devfreq_list_lock);
1265	}
1266
1267	/**
1268	* devfreq_add_governor() - Add devfreq governor
1269	* @governor: the devfreq governor to be added
1270	*/
1271	int 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(name: governor->name);
1284	if (!IS_ERR(ptr: 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(new: &governor->node, head: &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
1325	err_out:
1326	mutex_unlock(lock: &devfreq_list_lock);
1327
1328	return err;
1329	}
1330	EXPORT_SYMBOL(devfreq_add_governor);
1331
1332	static 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	*/
1344	int 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	}
1356	EXPORT_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	*/
1362	int 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(name: governor->name);
1375	if (IS_ERR(ptr: g)) {
1376	pr_err("%s: governor %s not registered\n", __func__,
1377	governor->name);
1378	err = PTR_ERR(ptr: 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(entry: &governor->node);
1406	err_out:
1407	mutex_unlock(lock: &devfreq_list_lock);
1408
1409	return err;
1410	}
1411	EXPORT_SYMBOL(devfreq_remove_governor);
1412
1413	static 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, fmt: "%s\n", dev_name(dev: df->dev.parent));
1418	}
1419	static DEVICE_ATTR_RO(name);
1420
1421	static 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, fmt: "%s\n", df->governor->name);
1430	}
1431
1432	static 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(name: str_governor);
1449	if (IS_ERR(ptr: governor)) {
1450	ret = PTR_ERR(ptr: 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(devfreq: df, gov: 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(devfreq: df, gov: df->governor);
1502
1503	out:
1504	mutex_unlock(lock: &devfreq_list_lock);
1505
1506	if (!ret)
1507	ret = count;
1508	return ret;
1509	}
1510	static DEVICE_ATTR_RW(governor);
1511
1512	static 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: &buf[count], DEVFREQ_NAME_LEN,
1530	fmt: "%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: &buf[count], size: (PAGE_SIZE - count - 2),
1542	fmt: "%s ", governor->name);
1543	}
1544	}
1545
1546	mutex_unlock(lock: &devfreq_list_lock);
1547
1548	/* Truncate the trailing space */
1549	if (count)
1550	count--;
1551
1552	count += sprintf(buf: &buf[count], fmt: "\n");
1553
1554	return count;
1555	}
1556	static DEVICE_ATTR_RO(available_governors);
1557
1558	static 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, fmt: "%lu\n", freq);
1570
1571	return sprintf(buf, fmt: "%lu\n", df->previous_freq);
1572	}
1573	static DEVICE_ATTR_RO(cur_freq);
1574
1575	static 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, fmt: "%lu\n", df->previous_freq);
1581	}
1582	static DEVICE_ATTR_RO(target_freq);
1583
1584	static 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(req: &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(req: &df->user_min_freq_req,
1604	new_value: value / HZ_PER_KHZ);
1605	if (ret < 0)
1606	return ret;
1607
1608	return count;
1609	}
1610
1611	static 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(lock: &df->lock);
1620
1621	return sprintf(buf, fmt: "%lu\n", min_freq);
1622	}
1623	static DEVICE_ATTR_RW(min_freq);
1624
1625	static 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(req: &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(req: &df->user_max_freq_req, new_value: value);
1659	if (ret < 0)
1660	return ret;
1661
1662	return count;
1663	}
1664
1665	static 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(lock: &df->lock);
1674
1675	return sprintf(buf, fmt: "%lu\n", max_freq);
1676	}
1677	static DEVICE_ATTR_RW(max_freq);
1678
1679	static 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: &buf[count], size: (PAGE_SIZE - count - 2),
1694	fmt: "%lu ", df->freq_table[i]);
1695
1696	mutex_unlock(lock: &df->lock);
1697	/* Truncate the trailing space */
1698	if (count)
1699	count--;
1700
1701	count += sprintf(buf: &buf[count], fmt: "\n");
1702
1703	return count;
1704	}
1705	static DEVICE_ATTR_RO(available_frequencies);
1706
1707	static 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, fmt: "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(lock: &df->lock);
1726	return 0;
1727	}
1728	mutex_unlock(lock: &df->lock);
1729
1730	len += sysfs_emit_at(buf, at: len, fmt: " From : To\n");
1731	len += sysfs_emit_at(buf, at: len, fmt: " :");
1732	for (i = 0; i < max_state; i++) {
1733	if (len >= PAGE_SIZE - 1)
1734	break;
1735	len += sysfs_emit_at(buf, at: len, fmt: "%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, at: len, fmt: " 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, at: len, fmt: "*");
1748	else
1749	len += sysfs_emit_at(buf, at: len, fmt: " ");
1750	if (len >= PAGE_SIZE - 1)
1751	break;
1752	len += sysfs_emit_at(buf, at: len, fmt: "%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, at: len, fmt: "%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, at: len, fmt: "%10llu\n", (u64)
1762	jiffies64_to_msecs(j: df->stats.time_in_state[i]));
1763	}
1764
1765	if (len < PAGE_SIZE - 1)
1766	len += sysfs_emit_at(buf, at: len, fmt: "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
1776	static 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(s: buf, base: 10, res: &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(lock: &df->lock);
1802
1803	return count;
1804	}
1805	static DEVICE_ATTR_RW(trans_stat);
1806
1807	static 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	};
1819	ATTRIBUTE_GROUPS(devfreq);
1820
1821	static 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, fmt: "%d\n", df->profile->polling_ms);
1830	}
1831
1832	static 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	}
1852	static DEVICE_ATTR_RW(polling_interval);
1853
1854	static 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, fmt: "%s\n", timer_name[df->profile->timer]);
1863	}
1864
1865	static 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(lock: &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);
1912	out:
1913	return ret ? ret : count;
1914	}
1915	static 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. */
1928	static 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. */
1938	static 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(kobj: &devfreq->dev.kobj,
1943	attr: &dev_attr_polling_interval.attr);
1944	if (IS_SUPPORTED_ATTR(gov->attrs, TIMER))
1945	sysfs_remove_file(kobj: &devfreq->dev.kobj, attr: &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	*/
1958	static 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(m: s, fmt: "%-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(m: s, fmt: "%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(lock: &devfreq->lock);
2010
2011	seq_printf(m: s,
2012	fmt: "%-30s %-30s %-15s %-10s %10d %12ld %12ld %12ld\n",
2013	dev_name(dev: &devfreq->dev),
2014	p_devfreq ? dev_name(dev: &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(lock: &devfreq_list_lock);
2024
2025	return 0;
2026	}
2027	DEFINE_SHOW_ATTRIBUTE(devfreq_summary);
2028
2029	static int __init devfreq_init(void)
2030	{
2031	devfreq_class = class_create(name: "devfreq");
2032	if (IS_ERR(ptr: devfreq_class)) {
2033	pr_err("%s: couldn't create class\n", __FILE__);
2034	return PTR_ERR(ptr: devfreq_class);
2035	}
2036
2037	devfreq_wq = create_freezable_workqueue("devfreq_wq");
2038	if (!devfreq_wq) {
2039	class_destroy(cls: 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(name: "devfreq", NULL);
2046	debugfs_create_file(name: "devfreq_summary", mode: 0444,
2047	parent: devfreq_debugfs, NULL,
2048	fops: &devfreq_summary_fops);
2049
2050	return 0;
2051	}
2052	subsys_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	*/
2069	struct 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, index: 0);
2078
2079	/* If not available, use the closest opp */
2080	if (opp == ERR_PTR(error: -ERANGE))
2081	opp = dev_pm_opp_find_freq_ceil_indexed(dev, freq, index: 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, index: 0);
2085
2086	/* If not available, use the closest opp */
2087	if (opp == ERR_PTR(error: -ERANGE))
2088	opp = dev_pm_opp_find_freq_floor_indexed(dev, freq, index: 0);
2089	}
2090
2091	return opp;
2092	}
2093	EXPORT_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	*/
2102	int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
2103	{
2104	return dev_pm_opp_register_notifier(dev, nb: &devfreq->nb);
2105	}
2106	EXPORT_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	*/
2118	int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
2119	{
2120	return dev_pm_opp_unregister_notifier(dev, nb: &devfreq->nb);
2121	}
2122	EXPORT_SYMBOL(devfreq_unregister_opp_notifier);
2123
2124	static 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	*/
2135	int 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(res: ptr);
2148	return ret;
2149	}
2150
2151	*ptr = devfreq;
2152	devres_add(dev, res: ptr);
2153
2154	return 0;
2155	}
2156	EXPORT_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	*/
2164	void 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	}
2170	EXPORT_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	*/
2178	int 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	nh: &devfreq->transition_notifier_list, nb);
2191	break;
2192	default:
2193	ret = -EINVAL;
2194	}
2195
2196	return ret;
2197	}
2198	EXPORT_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	*/
2206	int 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	nh: &devfreq->transition_notifier_list, nb);
2219	break;
2220	default:
2221	ret = -EINVAL;
2222	}
2223
2224	return ret;
2225	}
2226	EXPORT_SYMBOL(devfreq_unregister_notifier);
2227
2228	struct devfreq_notifier_devres {
2229	struct devfreq *devfreq;
2230	struct notifier_block *nb;
2231	unsigned int list;
2232	};
2233
2234	static 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	*/
2249	int 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(res: ptr);
2265	return ret;
2266	}
2267
2268	ptr->devfreq = devfreq;
2269	ptr->nb = nb;
2270	ptr->list = list;
2271	devres_add(dev, res: ptr);
2272
2273	return 0;
2274	}
2275	EXPORT_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	*/
2285	void 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	}
2293	EXPORT_SYMBOL(devm_devfreq_unregister_notifier);
2294