Commit | Line | Data |
---|---|---|
99613311 CC |
1 | /* |
2 | * linux/drivers/devfreq/governor_passive.c | |
3 | * | |
4 | * Copyright (C) 2016 Samsung Electronics | |
5 | * Author: Chanwoo Choi <cw00.choi@samsung.com> | |
6 | * Author: MyungJoo Ham <myungjoo.ham@samsung.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | */ | |
12 | ||
13 | #include <linux/module.h> | |
14 | #include <linux/device.h> | |
15 | #include <linux/devfreq.h> | |
16 | #include "governor.h" | |
17 | ||
18 | static int devfreq_passive_get_target_freq(struct devfreq *devfreq, | |
19 | unsigned long *freq) | |
20 | { | |
21 | struct devfreq_passive_data *p_data | |
22 | = (struct devfreq_passive_data *)devfreq->data; | |
23 | struct devfreq *parent_devfreq = (struct devfreq *)p_data->parent; | |
24 | unsigned long child_freq = ULONG_MAX; | |
25 | struct dev_pm_opp *opp; | |
26 | int i, count, ret = 0; | |
27 | ||
28 | /* | |
29 | * If the devfreq device with passive governor has the specific method | |
30 | * to determine the next frequency, should use the get_target_freq() | |
31 | * of struct devfreq_passive_data. | |
32 | */ | |
33 | if (p_data->get_target_freq) { | |
34 | ret = p_data->get_target_freq(devfreq, freq); | |
35 | goto out; | |
36 | } | |
37 | ||
38 | /* | |
39 | * If the parent and passive devfreq device uses the OPP table, | |
40 | * get the next frequency by using the OPP table. | |
41 | */ | |
42 | ||
43 | /* | |
44 | * - parent devfreq device uses the governors except for passive. | |
45 | * - passive devfreq device uses the passive governor. | |
46 | * | |
47 | * Each devfreq has the OPP table. After deciding the new frequency | |
48 | * from the governor of parent devfreq device, the passive governor | |
49 | * need to get the index of new frequency on OPP table of parent | |
50 | * device. And then the index is used for getting the suitable | |
51 | * new frequency for passive devfreq device. | |
52 | */ | |
53 | if (!devfreq->profile || !devfreq->profile->freq_table | |
54 | || devfreq->profile->max_state <= 0) | |
55 | return -EINVAL; | |
56 | ||
57 | /* | |
58 | * The passive governor have to get the correct frequency from OPP | |
59 | * list of parent device. Because in this case, *freq is temporary | |
60 | * value which is decided by ondemand governor. | |
61 | */ | |
99613311 | 62 | opp = devfreq_recommended_opp(parent_devfreq->dev.parent, freq, 0); |
99613311 CC |
63 | if (IS_ERR(opp)) { |
64 | ret = PTR_ERR(opp); | |
65 | goto out; | |
66 | } | |
67 | ||
8a31d9d9 VK |
68 | dev_pm_opp_put(opp); |
69 | ||
99613311 CC |
70 | /* |
71 | * Get the OPP table's index of decided freqeuncy by governor | |
72 | * of parent device. | |
73 | */ | |
74 | for (i = 0; i < parent_devfreq->profile->max_state; i++) | |
75 | if (parent_devfreq->profile->freq_table[i] == *freq) | |
76 | break; | |
77 | ||
78 | if (i == parent_devfreq->profile->max_state) { | |
79 | ret = -EINVAL; | |
80 | goto out; | |
81 | } | |
82 | ||
83 | /* Get the suitable frequency by using index of parent device. */ | |
84 | if (i < devfreq->profile->max_state) { | |
85 | child_freq = devfreq->profile->freq_table[i]; | |
86 | } else { | |
87 | count = devfreq->profile->max_state; | |
88 | child_freq = devfreq->profile->freq_table[count - 1]; | |
89 | } | |
90 | ||
91 | /* Return the suitable frequency for passive device. */ | |
92 | *freq = child_freq; | |
93 | ||
94 | out: | |
95 | return ret; | |
96 | } | |
97 | ||
98 | static int update_devfreq_passive(struct devfreq *devfreq, unsigned long freq) | |
99 | { | |
100 | int ret; | |
101 | ||
102 | if (!devfreq->governor) | |
103 | return -EINVAL; | |
104 | ||
105 | mutex_lock_nested(&devfreq->lock, SINGLE_DEPTH_NESTING); | |
106 | ||
107 | ret = devfreq->governor->get_target_freq(devfreq, &freq); | |
108 | if (ret < 0) | |
109 | goto out; | |
110 | ||
111 | ret = devfreq->profile->target(devfreq->dev.parent, &freq, 0); | |
112 | if (ret < 0) | |
113 | goto out; | |
114 | ||
30582c25 CC |
115 | if (devfreq->profile->freq_table |
116 | && (devfreq_update_status(devfreq, freq))) | |
117 | dev_err(&devfreq->dev, | |
118 | "Couldn't update frequency transition information.\n"); | |
119 | ||
99613311 CC |
120 | devfreq->previous_freq = freq; |
121 | ||
122 | out: | |
123 | mutex_unlock(&devfreq->lock); | |
124 | ||
125 | return 0; | |
126 | } | |
127 | ||
128 | static int devfreq_passive_notifier_call(struct notifier_block *nb, | |
129 | unsigned long event, void *ptr) | |
130 | { | |
131 | struct devfreq_passive_data *data | |
132 | = container_of(nb, struct devfreq_passive_data, nb); | |
133 | struct devfreq *devfreq = (struct devfreq *)data->this; | |
134 | struct devfreq *parent = (struct devfreq *)data->parent; | |
135 | struct devfreq_freqs *freqs = (struct devfreq_freqs *)ptr; | |
136 | unsigned long freq = freqs->new; | |
137 | ||
138 | switch (event) { | |
139 | case DEVFREQ_PRECHANGE: | |
140 | if (parent->previous_freq > freq) | |
141 | update_devfreq_passive(devfreq, freq); | |
142 | break; | |
143 | case DEVFREQ_POSTCHANGE: | |
144 | if (parent->previous_freq < freq) | |
145 | update_devfreq_passive(devfreq, freq); | |
146 | break; | |
147 | } | |
148 | ||
149 | return NOTIFY_DONE; | |
150 | } | |
151 | ||
152 | static int devfreq_passive_event_handler(struct devfreq *devfreq, | |
153 | unsigned int event, void *data) | |
154 | { | |
155 | struct device *dev = devfreq->dev.parent; | |
156 | struct devfreq_passive_data *p_data | |
157 | = (struct devfreq_passive_data *)devfreq->data; | |
158 | struct devfreq *parent = (struct devfreq *)p_data->parent; | |
159 | struct notifier_block *nb = &p_data->nb; | |
160 | int ret = 0; | |
161 | ||
162 | if (!parent) | |
163 | return -EPROBE_DEFER; | |
164 | ||
165 | switch (event) { | |
166 | case DEVFREQ_GOV_START: | |
167 | if (!p_data->this) | |
168 | p_data->this = devfreq; | |
169 | ||
170 | nb->notifier_call = devfreq_passive_notifier_call; | |
171 | ret = devm_devfreq_register_notifier(dev, parent, nb, | |
172 | DEVFREQ_TRANSITION_NOTIFIER); | |
173 | break; | |
174 | case DEVFREQ_GOV_STOP: | |
175 | devm_devfreq_unregister_notifier(dev, parent, nb, | |
176 | DEVFREQ_TRANSITION_NOTIFIER); | |
177 | break; | |
178 | default: | |
179 | break; | |
180 | } | |
181 | ||
182 | return ret; | |
183 | } | |
184 | ||
185 | static struct devfreq_governor devfreq_passive = { | |
aa7c352f | 186 | .name = DEVFREQ_GOV_PASSIVE, |
bcf23c79 | 187 | .immutable = 1, |
99613311 CC |
188 | .get_target_freq = devfreq_passive_get_target_freq, |
189 | .event_handler = devfreq_passive_event_handler, | |
190 | }; | |
191 | ||
192 | static int __init devfreq_passive_init(void) | |
193 | { | |
194 | return devfreq_add_governor(&devfreq_passive); | |
195 | } | |
196 | subsys_initcall(devfreq_passive_init); | |
197 | ||
198 | static void __exit devfreq_passive_exit(void) | |
199 | { | |
200 | int ret; | |
201 | ||
202 | ret = devfreq_remove_governor(&devfreq_passive); | |
203 | if (ret) | |
204 | pr_err("%s: failed remove governor %d\n", __func__, ret); | |
99613311 CC |
205 | } |
206 | module_exit(devfreq_passive_exit); | |
207 | ||
208 | MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>"); | |
209 | MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>"); | |
210 | MODULE_DESCRIPTION("DEVFREQ Passive governor"); | |
211 | MODULE_LICENSE("GPL v2"); |