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