Lines Matching refs:devfreq
3 * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
21 #include <linux/devfreq.h>
32 #include <trace/events/devfreq.h>
40 * devfreq core provides delayed work based load monitoring helper
46 /* The list of all device-devfreq governors */
48 /* The list of all device-devfreq */
58 * find_device_devfreq() - find devfreq struct using device pointer
59 * @dev: device pointer used to lookup device devfreq.
62 * devfreq info. devfreq_list_lock should be held by the caller.
64 static struct devfreq *find_device_devfreq(struct device *dev)
66 struct devfreq *tmp_devfreq;
85 static unsigned long find_available_min_freq(struct devfreq *devfreq)
90 opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &min_freq);
100 static unsigned long find_available_max_freq(struct devfreq *devfreq)
105 opp = dev_pm_opp_find_freq_floor(devfreq->dev.parent, &max_freq);
117 * @devfreq: the devfreq instance
123 static void get_freq_range(struct devfreq *devfreq, unsigned long *min_freq, unsigned long *max_freq)
125 unsigned long *freq_table = devfreq->profile->freq_table;
128 lockdep_assert_held(&devfreq->lock);
132 * The devfreq drivers can initialize this in either ascending or
133 * descending order and devfreq core supports both.
135 if (freq_table[0] < freq_table[devfreq->profile->max_state - 1]) {
137 *max_freq = freq_table[devfreq->profile->max_state - 1];
139 *min_freq = freq_table[devfreq->profile->max_state - 1];
144 qos_min_freq = dev_pm_qos_read_value(devfreq->dev.parent, DEV_PM_QOS_MIN_FREQUENCY);
145 qos_max_freq = dev_pm_qos_read_value(devfreq->dev.parent, DEV_PM_QOS_MAX_FREQUENCY);
152 *min_freq = max(*min_freq, devfreq->scaling_min_freq);
153 *max_freq = min(*max_freq, devfreq->scaling_max_freq);
162 * @devfreq: the devfreq instance
165 static int devfreq_get_freq_level(struct devfreq *devfreq, unsigned long freq)
169 for (lev = 0; lev < devfreq->profile->max_state; lev++) {
170 if (freq == devfreq->profile->freq_table[lev]) {
178 static int set_freq_table(struct devfreq *devfreq)
180 struct devfreq_dev_profile *profile = devfreq->profile;
186 count = dev_pm_opp_get_opp_count(devfreq->dev.parent);
193 devm_kcalloc(devfreq->dev.parent, profile->max_state, sizeof(*profile->freq_table), GFP_KERNEL);
200 opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &freq);
202 devm_kfree(devfreq->dev.parent, profile->freq_table);
214 * devfreq_update_status() - Update statistics of devfreq behavior
215 * @devfreq: the devfreq instance
218 int devfreq_update_status(struct devfreq *devfreq, unsigned long freq)
223 lockdep_assert_held(&devfreq->lock);
227 if (!devfreq->previous_freq) {
231 prev_lev = devfreq_get_freq_level(devfreq, devfreq->previous_freq);
237 devfreq->stats.time_in_state[prev_lev] += cur_time - devfreq->stats.last_update;
239 lev = devfreq_get_freq_level(devfreq, freq);
246 devfreq->stats.trans_table[(prev_lev * devfreq->profile->max_state) + lev]++;
247 devfreq->stats.total_trans++;
251 devfreq->stats.last_update = cur_time;
257 * find_devfreq_governor() - find devfreq governor from name
260 * Search the list of devfreq governors and return the matched
289 * Search the list of devfreq governors and request the module and try again
328 static int devfreq_notify_transition(struct devfreq *devfreq, struct devfreq_freqs *freqs, unsigned int state)
330 if (!devfreq) {
336 srcu_notifier_call_chain(&devfreq->transition_notifier_list, DEVFREQ_PRECHANGE, freqs);
340 srcu_notifier_call_chain(&devfreq->transition_notifier_list, DEVFREQ_POSTCHANGE, freqs);
349 static int devfreq_set_target(struct devfreq *devfreq, unsigned long new_freq, u32 flags)
355 if (devfreq->profile->get_cur_freq) {
356 devfreq->profile->get_cur_freq(devfreq->dev.parent, &cur_freq);
358 cur_freq = devfreq->previous_freq;
363 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_PRECHANGE);
365 err = devfreq->profile->target(devfreq->dev.parent, &new_freq, flags);
368 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
373 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
375 if (devfreq_update_status(devfreq, new_freq)) {
376 dev_err(&devfreq->dev, "Couldn't update frequency transition information.\n");
379 devfreq->previous_freq = new_freq;
381 if (devfreq->suspend_freq) {
382 devfreq->resume_freq = new_freq;
392 * @devfreq: the devfreq instance.
394 * Note: Lock devfreq->lock before calling update_devfreq
397 int update_devfreq(struct devfreq *devfreq)
403 lockdep_assert_held(&devfreq->lock);
405 if (!devfreq->governor) {
410 err = devfreq->governor->get_target_freq(devfreq, &freq);
414 get_freq_range(devfreq, &min_freq, &max_freq);
425 return devfreq_set_target(devfreq, freq, flags);
430 * devfreq_monitor() - Periodically poll devfreq objects.
437 struct devfreq *devfreq = container_of(work, struct devfreq, work.work);
439 mutex_lock(&devfreq->lock);
440 err = update_devfreq(devfreq);
442 dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err);
445 queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms));
446 mutex_unlock(&devfreq->lock);
448 trace_devfreq_monitor(devfreq);
452 * devfreq_monitor_start() - Start load monitoring of devfreq instance
453 * @devfreq: the devfreq instance.
455 * Helper function for starting devfreq device load monitoring. By
458 * event when device is added to devfreq framework.
460 void devfreq_monitor_start(struct devfreq *devfreq)
462 if (devfreq->governor->interrupt_driven) {
466 switch (devfreq->profile->timer) {
468 INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor);
471 INIT_DELAYED_WORK(&devfreq->work, devfreq_monitor);
477 if (devfreq->profile->polling_ms) {
478 queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms));
484 * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance
485 * @devfreq: the devfreq instance.
487 * Helper function to stop devfreq device load monitoring. Function
489 * event when device is removed from devfreq framework.
491 void devfreq_monitor_stop(struct devfreq *devfreq)
493 if (devfreq->governor->interrupt_driven) {
497 cancel_delayed_work_sync(&devfreq->work);
502 * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance
503 * @devfreq: the devfreq instance.
505 * Helper function to suspend devfreq device load monitoring. Function
513 void devfreq_monitor_suspend(struct devfreq *devfreq)
515 mutex_lock(&devfreq->lock);
516 if (devfreq->stop_polling) {
517 mutex_unlock(&devfreq->lock);
521 devfreq_update_status(devfreq, devfreq->previous_freq);
522 devfreq->stop_polling = true;
523 mutex_unlock(&devfreq->lock);
525 if (devfreq->governor->interrupt_driven) {
529 cancel_delayed_work_sync(&devfreq->work);
534 * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance
535 * @devfreq: the devfreq instance.
537 * Helper function to resume devfreq device load monitoring. Function
541 void devfreq_monitor_resume(struct devfreq *devfreq)
545 mutex_lock(&devfreq->lock);
546 if (!devfreq->stop_polling) {
550 if (devfreq->governor->interrupt_driven) {
554 if (!delayed_work_pending(&devfreq->work) && devfreq->profile->polling_ms) {
555 queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms));
559 devfreq->stats.last_update = get_jiffies_64();
560 devfreq->stop_polling = false;
562 if (devfreq->profile->get_cur_freq && !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq)) {
563 devfreq->previous_freq = freq;
567 mutex_unlock(&devfreq->lock);
572 * devfreq_update_interval() - Update device devfreq monitoring interval
573 * @devfreq: the devfreq instance.
579 void devfreq_update_interval(struct devfreq *devfreq, unsigned int *delay)
581 unsigned int cur_delay = devfreq->profile->polling_ms;
584 mutex_lock(&devfreq->lock);
585 devfreq->profile->polling_ms = new_delay;
587 if (devfreq->stop_polling) {
591 if (devfreq->governor->interrupt_driven) {
597 mutex_unlock(&devfreq->lock);
598 cancel_delayed_work_sync(&devfreq->work);
604 queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms));
610 mutex_unlock(&devfreq->lock);
611 cancel_delayed_work_sync(&devfreq->work);
612 mutex_lock(&devfreq->lock);
613 if (!devfreq->stop_polling) {
614 queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms));
618 mutex_unlock(&devfreq->lock);
624 * has been changed out of devfreq framework.
625 * @nb: the notifier_block (supposed to be devfreq->nb)
629 * Called by a notifier that uses devfreq->nb.
633 struct devfreq *devfreq = container_of(nb, struct devfreq, nb);
636 mutex_lock(&devfreq->lock);
638 devfreq->scaling_min_freq = find_available_min_freq(devfreq);
639 if (!devfreq->scaling_min_freq) {
643 devfreq->scaling_max_freq = find_available_max_freq(devfreq);
644 if (!devfreq->scaling_max_freq) {
645 devfreq->scaling_max_freq = ULONG_MAX;
649 err = update_devfreq(devfreq);
652 mutex_unlock(&devfreq->lock);
654 dev_err(devfreq->dev.parent, "failed to update frequency from OPP notifier (%d)\n", err);
662 * @devfreq: the devfreq instance.
664 static int qos_notifier_call(struct devfreq *devfreq)
668 mutex_lock(&devfreq->lock);
669 err = update_devfreq(devfreq);
670 mutex_unlock(&devfreq->lock);
672 dev_err(devfreq->dev.parent, "failed to update frequency from PM QoS (%d)\n", err);
680 * @nb: Should be devfreq->nb_min
684 return qos_notifier_call(container_of(nb, struct devfreq, nb_min));
689 * @nb: Should be devfreq->nb_max
693 return qos_notifier_call(container_of(nb, struct devfreq, nb_max));
698 * @dev: the devfreq device
700 * Remove devfreq from the list and release its resources.
704 struct devfreq *devfreq = to_devfreq(dev);
708 list_del(&devfreq->node);
711 err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_max, DEV_PM_QOS_MAX_FREQUENCY);
715 err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_min, DEV_PM_QOS_MIN_FREQUENCY);
720 if (dev_pm_qos_request_active(&devfreq->user_max_freq_req)) {
721 err = dev_pm_qos_remove_request(&devfreq->user_max_freq_req);
726 if (dev_pm_qos_request_active(&devfreq->user_min_freq_req)) {
727 err = dev_pm_qos_remove_request(&devfreq->user_min_freq_req);
733 if (devfreq->profile->exit) {
734 devfreq->profile->exit(devfreq->dev.parent);
737 mutex_destroy(&devfreq->lock);
738 kfree(devfreq);
742 * devfreq_remove_device() - Remove devfreq feature from a device.
743 * @devfreq: the devfreq instance to be removed
747 int devfreq_remove_device(struct devfreq *devfreq)
749 if (!devfreq) {
753 if (devfreq->governor) {
754 devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_STOP, NULL);
756 device_unregister(&devfreq->dev);
763 * devfreq_add_device() - Add devfreq feature to the device
764 * @dev: the device to add devfreq feature.
765 * @profile: device-specific profile to run devfreq.
767 * @data: private data for the governor. The devfreq framework does not
770 struct devfreq *devfreq_add_device(struct device *dev, struct devfreq_dev_profile *profile, const char *governor_name,
773 struct devfreq *devfreq;
783 devfreq = find_device_devfreq(dev);
785 if (!IS_ERR(devfreq)) {
786 dev_err(dev, "%s: devfreq device already exists!\n", __func__);
791 devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL);
792 if (!devfreq) {
797 mutex_init(&devfreq->lock);
798 mutex_lock(&devfreq->lock);
799 devfreq->dev.parent = dev;
800 devfreq->dev.class = devfreq_class;
801 devfreq->dev.release = devfreq_dev_release;
802 INIT_LIST_HEAD(&devfreq->node);
803 devfreq->profile = profile;
804 strscpy(devfreq->governor_name, governor_name, DEVFREQ_NAME_LEN);
805 devfreq->previous_freq = profile->initial_freq;
806 devfreq->last_status.current_frequency = profile->initial_freq;
807 devfreq->data = data;
808 devfreq->nb.notifier_call = devfreq_notifier_call;
810 if (devfreq->profile->timer < 0 || devfreq->profile->timer >= DEVFREQ_TIMER_NUM) {
811 mutex_unlock(&devfreq->lock);
816 if (!devfreq->profile->max_state && !devfreq->profile->freq_table) {
817 mutex_unlock(&devfreq->lock);
818 err = set_freq_table(devfreq);
822 mutex_lock(&devfreq->lock);
825 devfreq->scaling_min_freq = find_available_min_freq(devfreq);
826 if (!devfreq->scaling_min_freq) {
827 mutex_unlock(&devfreq->lock);
832 devfreq->scaling_max_freq = find_available_max_freq(devfreq);
833 if (!devfreq->scaling_max_freq) {
834 mutex_unlock(&devfreq->lock);
839 devfreq->suspend_freq = dev_pm_opp_get_suspend_opp_freq(dev);
840 atomic_set(&devfreq->suspend_count, 0);
842 dev_set_name(&devfreq->dev, "%s", dev_name(dev));
843 err = device_register(&devfreq->dev);
845 mutex_unlock(&devfreq->lock);
846 put_device(&devfreq->dev);
850 devfreq->stats.trans_table = devm_kzalloc(
851 &devfreq->dev, array3_size(sizeof(unsigned int), devfreq->profile->max_state, devfreq->profile->max_state),
853 if (!devfreq->stats.trans_table) {
854 mutex_unlock(&devfreq->lock);
859 devfreq->stats.time_in_state =
860 devm_kcalloc(&devfreq->dev, devfreq->profile->max_state, sizeof(*devfreq->stats.time_in_state), GFP_KERNEL);
861 if (!devfreq->stats.time_in_state) {
862 mutex_unlock(&devfreq->lock);
867 devfreq->stats.total_trans = 0;
868 devfreq->stats.last_update = get_jiffies_64();
870 srcu_init_notifier_head(&devfreq->transition_notifier_list);
872 mutex_unlock(&devfreq->lock);
874 err = dev_pm_qos_add_request(dev, &devfreq->user_min_freq_req, DEV_PM_QOS_MIN_FREQUENCY, 0);
878 err = dev_pm_qos_add_request(dev, &devfreq->user_max_freq_req, DEV_PM_QOS_MAX_FREQUENCY,
884 devfreq->nb_min.notifier_call = qos_min_notifier_call;
885 err = dev_pm_qos_add_notifier(devfreq->dev.parent, &devfreq->nb_min, DEV_PM_QOS_MIN_FREQUENCY);
890 devfreq->nb_max.notifier_call = qos_max_notifier_call;
891 err = dev_pm_qos_add_notifier(devfreq->dev.parent, &devfreq->nb_max, DEV_PM_QOS_MAX_FREQUENCY);
898 governor = try_then_request_governor(devfreq->governor_name);
905 devfreq->governor = governor;
906 err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START, NULL);
912 list_add(&devfreq->node, &devfreq_list);
916 return devfreq;
921 devfreq_remove_device(devfreq);
922 devfreq = NULL;
924 kfree(devfreq);
932 struct devfreq **r = res;
943 devfreq_remove_device(*(struct devfreq **)res);
948 * @dev: the device to add devfreq feature.
949 * @profile: device-specific profile to run devfreq.
951 * @data: private data for the governor. The devfreq framework does not
954 * This function manages automatically the memory of devfreq device using device
955 * resource management and simplify the free operation for memory of devfreq
958 struct devfreq *devm_devfreq_add_device(struct device *dev, struct devfreq_dev_profile *profile,
961 struct devfreq **ptr, *devfreq;
968 devfreq = devfreq_add_device(dev, profile, governor_name, data);
969 if (IS_ERR(devfreq)) {
971 return devfreq;
974 *ptr = devfreq;
977 return devfreq;
983 * devfreq_get_devfreq_by_node - Get the devfreq device from devicetree
986 * return the instance of devfreq device
988 struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node)
990 struct devfreq *devfreq;
997 list_for_each_entry(devfreq, &devfreq_list, node)
999 if (devfreq->dev.parent && devfreq->dev.parent->of_node == node) {
1001 return devfreq;
1010 * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree
1013 * @index - index into list of devfreq
1015 * return the instance of devfreq device
1017 struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, const char *phandle_name, int index)
1020 struct devfreq *devfreq;
1035 devfreq = devfreq_get_devfreq_by_node(node);
1038 return devfreq;
1042 struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node)
1047 struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, const char *phandle_name, int index)
1057 * @dev: the device from which to remove devfreq feature.
1058 * @devfreq: the devfreq instance to be removed
1060 void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq)
1062 WARN_ON(devres_release(dev, devm_devfreq_dev_release, devm_devfreq_dev_match, devfreq));
1067 * devfreq_suspend_device() - Suspend devfreq of a device.
1068 * @devfreq: the devfreq instance to be suspended
1072 * holds the devfreq.
1074 int devfreq_suspend_device(struct devfreq *devfreq)
1078 if (!devfreq) {
1082 if (atomic_inc_return(&devfreq->suspend_count) > 1) {
1086 if (devfreq->governor) {
1087 ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_SUSPEND, NULL);
1093 if (devfreq->suspend_freq) {
1094 mutex_lock(&devfreq->lock);
1095 ret = devfreq_set_target(devfreq, devfreq->suspend_freq, 0);
1096 mutex_unlock(&devfreq->lock);
1107 * devfreq_resume_device() - Resume devfreq of a device.
1108 * @devfreq: the devfreq instance to be resumed
1112 * holds the devfreq.
1114 int devfreq_resume_device(struct devfreq *devfreq)
1118 if (!devfreq) {
1122 if (atomic_dec_return(&devfreq->suspend_count) >= 1) {
1126 if (devfreq->resume_freq) {
1127 mutex_lock(&devfreq->lock);
1128 ret = devfreq_set_target(devfreq, devfreq->resume_freq, 0);
1129 mutex_unlock(&devfreq->lock);
1135 if (devfreq->governor) {
1136 ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_RESUME, NULL);
1147 * devfreq_suspend() - Suspend devfreq governors and devices
1150 * and devices preserving the state for resume. On some platforms the devfreq
1156 struct devfreq *devfreq;
1160 list_for_each_entry(devfreq, &devfreq_list, node)
1162 ret = devfreq_suspend_device(devfreq);
1164 dev_err(&devfreq->dev, "failed to suspend devfreq device\n");
1171 * devfreq_resume() - Resume devfreq governors and devices
1178 struct devfreq *devfreq;
1182 list_for_each_entry(devfreq, &devfreq_list, node)
1184 ret = devfreq_resume_device(devfreq);
1186 dev_warn(&devfreq->dev, "failed to resume devfreq device\n");
1193 * devfreq_add_governor() - Add devfreq governor
1194 * @governor: the devfreq governor to be added
1199 struct devfreq *devfreq;
1217 list_for_each_entry(devfreq, &devfreq_list, node)
1220 struct device *dev = devfreq->dev.parent;
1222 if (!strncmp(devfreq->governor_name, governor->name, DEVFREQ_NAME_LEN)) {
1224 if (devfreq->governor) {
1225 dev_warn(dev, "%s: Governor %s already present\n", __func__, devfreq->governor->name);
1226 ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_STOP, NULL);
1228 dev_warn(dev, "%s: Governor %s stop = %d\n", __func__, devfreq->governor->name, ret);
1232 devfreq->governor = governor;
1233 ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START, NULL);
1235 dev_warn(dev, "%s: Governor %s start=%d\n", __func__, devfreq->governor->name, ret);
1248 * devfreq_remove_governor() - Remove devfreq feature from a device.
1249 * @governor: the devfreq governor to be removed
1254 struct devfreq *devfreq;
1269 list_for_each_entry(devfreq, &devfreq_list, node)
1272 struct device *dev = devfreq->dev.parent;
1274 if (!strncmp(devfreq->governor_name, governor->name, DEVFREQ_NAME_LEN)) {
1275 /* we should have a devfreq governor! */
1276 if (!devfreq->governor) {
1281 ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_STOP, NULL);
1283 dev_warn(dev, "%s: Governor %s stop=%d\n", __func__, devfreq->governor->name, ret);
1285 devfreq->governor = NULL;
1299 struct devfreq *df = to_devfreq(dev);
1306 struct devfreq *df = to_devfreq(dev);
1317 struct devfreq *df = to_devfreq(dev);
1377 struct devfreq *df = to_devfreq(d);
1387 * The devfreq with immutable governor (e.g., passive) shows
1393 * The devfreq device shows the registered governor except for
1424 struct devfreq *df = to_devfreq(dev);
1440 struct devfreq *df = to_devfreq(dev);
1448 struct devfreq *df = to_devfreq(dev);
1459 struct devfreq *df = to_devfreq(dev);
1481 struct devfreq *df = to_devfreq(dev);
1509 struct devfreq *df = to_devfreq(dev);
1522 struct devfreq *df = to_devfreq(dev);
1565 struct devfreq *df = to_devfreq(dev);
1578 struct devfreq *df = to_devfreq(d);
1606 struct devfreq *df = to_devfreq(dev);
1655 struct devfreq *df = to_devfreq(dev);
1684 struct devfreq *df = to_devfreq(dev);
1695 struct devfreq *df = to_devfreq(dev);
1748 struct devfreq *devfreq = to_devfreq(dev);
1749 struct devfreq_dev_status stat = devfreq->last_status;
1753 err = devfreq_update_stats(devfreq);
1759 err = devfreq_update_stats(devfreq);
1771 if (devfreq->profile->get_cur_freq && !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq)) {
1774 len += sprintf(buf + len, "@%luHz\n", devfreq->previous_freq);
1796 ATTRIBUTE_GROUPS(devfreq);
1799 * devfreq_summary_show() - Show the summary of the devfreq devices
1800 * @s: seq_file instance to show the summary of devfreq devices
1803 * Show the summary of the devfreq devices via 'devfreq_summary' debugfs file.
1804 * It helps that user can know the detailed information of the devfreq devices.
1810 struct devfreq *devfreq;
1811 struct devfreq *p_devfreq = NULL;
1824 list_for_each_entry_reverse(devfreq, &devfreq_list, node)
1827 if (!strncmp(devfreq->governor_name, DEVFREQ_GOV_PASSIVE, DEVFREQ_NAME_LEN)) {
1828 struct devfreq_passive_data *data = devfreq->data;
1838 mutex_lock(&devfreq->lock);
1839 cur_freq = devfreq->previous_freq;
1840 get_freq_range(devfreq, &min_freq, &max_freq);
1841 polling_ms = devfreq->profile->polling_ms;
1842 timer = devfreq->profile->timer;
1843 mutex_unlock(&devfreq->lock);
1845 seq_printf(s, "%-30s %-30s %-15s %-10s %10d %12ld %12ld %12ld\n", dev_name(&devfreq->dev),
1846 p_devfreq ? dev_name(&p_devfreq->dev) : "null", devfreq->governor_name,
1858 devfreq_class = class_create(THIS_MODULE, "devfreq");
1872 devfreq_debugfs = debugfs_create_dir("devfreq", NULL);
1880 * The following are helper functions for devfreq user device drivers with
1887 * @dev: The devfreq user device. (parent of devfreq)
1889 * @flags: Flags handed from devfreq framework.
1919 * devfreq_register_opp_notifier() - Helper function to get devfreq notified
1922 * @dev: The devfreq user device. (parent of devfreq)
1923 * @devfreq: The devfreq object.
1925 int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
1927 return dev_pm_opp_register_notifier(dev, &devfreq->nb);
1932 * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
1935 * @dev: The devfreq user device. (parent of devfreq)
1936 * @devfreq: The devfreq object.
1941 int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
1943 return dev_pm_opp_unregister_notifier(dev, &devfreq->nb);
1949 devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);
1955 * @dev: The devfreq user device. (parent of devfreq)
1956 * @devfreq: The devfreq object.
1958 int devm_devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
1960 struct devfreq **ptr;
1968 ret = devfreq_register_opp_notifier(dev, devfreq);
1974 *ptr = devfreq;
1984 * @dev: The devfreq user device. (parent of devfreq)
1985 * @devfreq: The devfreq object.
1987 void devm_devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
1989 WARN_ON(devres_release(dev, devm_devfreq_opp_release, devm_devfreq_dev_match, devfreq));
1994 * devfreq_register_notifier() - Register a driver with devfreq
1995 * @devfreq: The devfreq object.
1999 int devfreq_register_notifier(struct devfreq *devfreq, struct notifier_block *nb, unsigned int list)
2003 if (!devfreq) {
2009 ret = srcu_notifier_chain_register(&devfreq->transition_notifier_list, nb);
2020 * devfreq_unregister_notifier() - Unregister a driver with devfreq
2021 * @devfreq: The devfreq object.
2025 int devfreq_unregister_notifier(struct devfreq *devfreq, struct notifier_block *nb, unsigned int list)
2029 if (!devfreq) {
2035 ret = srcu_notifier_chain_unregister(&devfreq->transition_notifier_list, nb);
2046 struct devfreq *devfreq;
2055 devfreq_unregister_notifier(this->devfreq, this->nb, this->list);
2061 * @dev: The devfreq user device. (parent of devfreq)
2062 * @devfreq: The devfreq object.
2066 int devm_devfreq_register_notifier(struct device *dev, struct devfreq *devfreq, struct notifier_block *nb,
2077 ret = devfreq_register_notifier(devfreq, nb, list);
2083 ptr->devfreq = devfreq;
2095 * @dev: The devfreq user device. (parent of devfreq)
2096 * @devfreq: The devfreq object.
2100 void devm_devfreq_unregister_notifier(struct device *dev, struct devfreq *devfreq, struct notifier_block *nb,
2103 WARN_ON(devres_release(dev, devm_devfreq_notifier_release, devm_devfreq_dev_match, devfreq));