ARM: tegra: loki: fix build error due to warning
[linux-3.10.git] / arch / arm / mach-tegra / tegra_core_volt_cap.c
1 /*
2  * arch/arm/mach-tegra/tegra_core_volt_cap.c
3  *
4  * Copyright (c), 2013 NVIDIA CORPORATION. All rights reserved.
5  *
6  * This software is licensed under the terms of the GNU General Public
7  * License version 2, as published by the Free Software Foundation, and
8  * may be copied, distributed, and modified under those terms.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  */
16
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/clk.h>
21 #include <linux/kobject.h>
22 #include <linux/err.h>
23 #include <linux/pm_qos.h>
24
25 #include "clock.h"
26 #include "dvfs.h"
27 #include "tegra_core_sysfs_limits.h"
28
29 /*
30  * sysfs and kernel interfaces to limit tegra core shared bus frequencies based
31  * on the required core voltage (cap level)
32  *
33  * Cap level is specified in millivolts, and rate limits from the respective
34  * dvfs tables are applied to all bus clocks. Note that cap level affects only
35  * scalable bus frequencies (graphics bus, emc, system clock). Core voltage is
36  * not necessarily set at the cap level, since CPU and/or fixed peripheral
37  * clocks outside the buses may require higher voltage level.
38  */
39 static DEFINE_MUTEX(core_cap_lock);
40
41 struct core_cap {
42         int refcnt;
43         int level;
44 };
45
46 static struct core_cap core_buses_cap;
47 static struct core_cap kdvfs_core_cap;
48 static struct core_cap user_core_cap;
49
50 static struct core_dvfs_cap_table *core_cap_table;
51 static int core_cap_table_size;
52
53 static const int *cap_millivolts;
54 static int cap_millivolts_num;
55
56 static int core_cap_level_set(int level, int core_nominal_mv)
57 {
58         int i, j;
59         int ret = 0;
60
61         if (!core_cap_table) {
62                 int mv = tegra_dvfs_rail_get_boot_level(tegra_core_rail);
63                 if (level == mv) {
64                         core_buses_cap.level = level;
65                         return 0;
66                 }
67                 return -ENOENT;
68         }
69
70         for (j = 0; j < cap_millivolts_num; j++) {
71                 int v = cap_millivolts[j];
72                 if ((v == 0) || (level < v))
73                         break;
74         }
75         j = (j == 0) ? 0 : j - 1;
76         level = cap_millivolts[j];
77
78         if (level < core_buses_cap.level) {
79                 for (i = 0; i < core_cap_table_size; i++)
80                         if (core_cap_table[i].cap_clk)
81                                 ret |= clk_set_rate(core_cap_table[i].cap_clk,
82                                              core_cap_table[i].freqs[j]);
83         } else if (level > core_buses_cap.level) {
84                 for (i = core_cap_table_size - 1; i >= 0; i--)
85                         if (core_cap_table[i].cap_clk)
86                                 ret |= clk_set_rate(core_cap_table[i].cap_clk,
87                                              core_cap_table[i].freqs[j]);
88         }
89         core_buses_cap.level = level;
90         if (ret)
91                 ret = -EAGAIN;
92         return ret;
93 }
94
95 static int core_cap_update(void)
96 {
97         int new_level;
98         int core_nominal_mv =
99                 tegra_dvfs_rail_get_nominal_millivolts(tegra_core_rail);
100         if (core_nominal_mv <= 0)
101                 return -ENOENT;
102
103         new_level = core_nominal_mv;
104         if (kdvfs_core_cap.refcnt)
105                 new_level = min(new_level, kdvfs_core_cap.level);
106         if (user_core_cap.refcnt)
107                 new_level = min(new_level, user_core_cap.level);
108
109         if (core_buses_cap.level != new_level)
110                 return core_cap_level_set(new_level, core_nominal_mv);
111         return 0;
112 }
113
114 static int core_cap_enable(bool enable)
115 {
116         if (enable)
117                 core_buses_cap.refcnt++;
118         else if (core_buses_cap.refcnt)
119                 core_buses_cap.refcnt--;
120
121         return core_cap_update();
122 }
123
124 static ssize_t
125 core_cap_state_show(struct kobject *kobj, struct kobj_attribute *attr,
126                     char *buf)
127 {
128         return sprintf(buf, "%d (%d)\n", core_buses_cap.refcnt ? 1 : 0,
129                         user_core_cap.refcnt ? 1 : 0);
130 }
131 static ssize_t
132 core_cap_state_store(struct kobject *kobj, struct kobj_attribute *attr,
133                      const char *buf, size_t count)
134 {
135         int state;
136
137         if (sscanf(buf, "%d", &state) != 1)
138                 return -1;
139
140         mutex_lock(&core_cap_lock);
141
142         if (state) {
143                 user_core_cap.refcnt++;
144                 if (user_core_cap.refcnt == 1)
145                         core_cap_enable(true);
146         } else if (user_core_cap.refcnt) {
147                 user_core_cap.refcnt--;
148                 if (user_core_cap.refcnt == 0)
149                         core_cap_enable(false);
150         }
151
152         mutex_unlock(&core_cap_lock);
153         return count;
154 }
155
156 static ssize_t
157 core_cap_level_show(struct kobject *kobj, struct kobj_attribute *attr,
158                     char *buf)
159 {
160         return sprintf(buf, "%d (%d)\n", core_buses_cap.level,
161                         user_core_cap.level);
162 }
163 static ssize_t
164 core_cap_level_store(struct kobject *kobj, struct kobj_attribute *attr,
165                      const char *buf, size_t count)
166 {
167         int level;
168
169         if (sscanf(buf, "%d", &level) != 1)
170                 return -1;
171
172         mutex_lock(&core_cap_lock);
173         user_core_cap.level = level;
174         core_cap_update();
175         mutex_unlock(&core_cap_lock);
176         return count;
177 }
178
179 static struct kobj_attribute cap_state_attribute =
180         __ATTR(core_cap_state, 0644, core_cap_state_show, core_cap_state_store);
181 static struct kobj_attribute cap_level_attribute =
182         __ATTR(core_cap_level, 0644, core_cap_level_show, core_cap_level_store);
183
184 const struct attribute *cap_attributes[] = {
185         &cap_state_attribute.attr,
186         &cap_level_attribute.attr,
187         NULL,
188 };
189
190 int tegra_dvfs_core_cap_level_apply(int level)
191 {
192         int ret = 0;
193
194         mutex_lock(&core_cap_lock);
195
196         if (level) {
197                 if (kdvfs_core_cap.refcnt) {
198                         pr_err("%s: core cap is already set\n", __func__);
199                         ret = -EPERM;
200                 } else {
201                         kdvfs_core_cap.level = level;
202                         kdvfs_core_cap.refcnt = 1;
203                         ret = core_cap_enable(true);
204                         if (ret) {
205                                 kdvfs_core_cap.refcnt = 0;
206                                 core_cap_enable(false);
207                         }
208                 }
209         } else if (kdvfs_core_cap.refcnt) {
210                 kdvfs_core_cap.refcnt = 0;
211                 core_cap_enable(false);
212         }
213
214         mutex_unlock(&core_cap_lock);
215         return ret;
216 }
217
218 static int __init init_core_cap_one(struct clk *c, unsigned long *freqs)
219 {
220         int i, v, next_v = 0;
221         unsigned long rate, next_rate = 0;
222
223         for (i = 0; i < cap_millivolts_num; i++) {
224                 v = cap_millivolts[i];
225                 if (v == 0)
226                         break;
227
228                 for (;;) {
229                         rate = next_rate;
230                         next_rate = clk_round_rate(c->parent, rate + 1000);
231                         if (IS_ERR_VALUE(next_rate)) {
232                                 pr_debug("tegra11_dvfs: failed to round %s rate %lu\n",
233                                          c->name, rate);
234                                 return -EINVAL;
235                         }
236                         if (rate == next_rate)
237                                 break;
238
239                         next_v = tegra_dvfs_predict_millivolts(
240                                 c->parent, next_rate);
241                         if (IS_ERR_VALUE(next_v)) {
242                                 pr_debug("tegra11_dvfs: failed to predict %s mV for rate %lu\n",
243                                          c->name, next_rate);
244                                 return -EINVAL;
245                         }
246                         if (next_v > v)
247                                 break;
248                 }
249
250                 if (rate == 0) {
251                         rate = next_rate;
252                         pr_warn("tegra11_dvfs: minimum %s rate %lu requires %d mV\n",
253                                 c->name, rate, next_v);
254                 }
255                 freqs[i] = rate;
256                 next_rate = rate;
257         }
258         return 0;
259 }
260
261 int __init tegra_init_core_cap(
262         struct core_dvfs_cap_table *table, int table_size,
263         const int *millivolts, int millivolts_num,
264         struct kobject *cap_kobj)
265 {
266         int i;
267         struct clk *c = NULL;
268
269         if (!table || !table_size || !millivolts || !millivolts_num)
270                 return -EINVAL;
271
272         user_core_cap.level =
273                 tegra_dvfs_rail_get_nominal_millivolts(tegra_core_rail);
274         if (user_core_cap.level <= 0)
275                 return -ENOENT;
276
277         cap_millivolts = millivolts;
278         cap_millivolts_num = millivolts_num;
279
280         for (i = 0; i < table_size; i++) {
281                 c = tegra_get_clock_by_name(table[i].cap_name);
282                 if (!c || !c->parent ||
283                     init_core_cap_one(c, table[i].freqs)) {
284                         pr_err("%s: failed to initialize %s table\n",
285                                __func__, table[i].cap_name);
286                         continue;
287                 }
288                 table[i].cap_clk = c;
289         }
290
291         if (!cap_kobj || sysfs_create_files(cap_kobj, cap_attributes))
292                 return -ENOMEM;
293
294         core_cap_table = table;
295         core_cap_table_size = table_size;
296         return 0;
297 }
298
299
300 /*
301  * sysfs interfaces to profile tegra core shared bus frequencies by directly
302  * specifying limit level in Hz for each bus independently
303  */
304
305 #define refcnt_to_bus(attr) \
306         container_of(attr, struct core_bus_limit_table, refcnt_attr)
307 #define level_to_bus(attr) \
308         container_of(attr, struct core_bus_limit_table, level_attr)
309 #define nb_to_bus(nb) \
310         container_of(nb, struct core_bus_limit_table, qos_nb)
311
312 #define MAX_BUS_NUM     8
313
314 static DEFINE_MUTEX(bus_limit_lock);
315 static const struct attribute *bus_attributes[2 * MAX_BUS_NUM + 1];
316
317 static int _floor_update(struct core_bus_limit_table *bus_limit,
318                          unsigned long qos_limit_level)
319 {
320         int ret = 0;
321         unsigned long level, max_level;
322         struct clk *c = bus_limit->limit_clk;
323
324         BUG_ON(!c);
325         max_level = clk_get_max_rate(c);
326
327         if (!bus_limit->refcnt && !qos_limit_level) {
328                 if (bus_limit->applied) {
329                         tegra_clk_disable_unprepare(c);
330                         bus_limit->applied = false;
331                 }
332                 return 0;
333         }
334
335         level = bus_limit->refcnt ? bus_limit->level : 0;
336
337         /* qos level is in kHz, bus floor level is in Hz */
338         if (qos_limit_level < max_level / 1000)
339                 qos_limit_level *= 1000;
340         else
341                 qos_limit_level = max_level;
342
343         level = max(level, qos_limit_level);
344
345
346         ret = clk_set_rate(c, level);
347         if (!bus_limit->applied)
348                 ret = tegra_clk_prepare_enable(c);
349
350         if (ret) {
351                 pr_err("%s: Failed to floor %s at level %lu\n",
352                        __func__, bus_limit->limit_clk_name, level);
353                 return ret;
354         }
355         bus_limit->applied = true;
356
357         return 0;
358 }
359
360 static int _cap_update(struct core_bus_limit_table *bus_limit,
361                        unsigned long qos_limit_level)
362 {
363         int ret = 0;
364         unsigned long level, max_level;
365         struct clk *c = bus_limit->limit_clk;
366
367         BUG_ON(!c);
368         max_level = clk_get_max_rate(c);
369         level = bus_limit->refcnt ? bus_limit->level : max_level;
370
371         /* qos level is in kHz, bus cap level is in Hz */
372         if (qos_limit_level < max_level / 1000)
373                 qos_limit_level *= 1000;
374         else
375                 qos_limit_level = max_level;
376
377         level = min(level, qos_limit_level);
378
379         ret = clk_set_rate(c, level);
380         if (ret)
381                 pr_err("%s: Failed to cap %s at level %lu\n",
382                        __func__, bus_limit->limit_clk_name, level);
383         return ret;
384 }
385
386 static int bus_limit_update(struct core_bus_limit_table *bus_limit)
387 {
388         unsigned long qos_limit_level;
389
390         if (bus_limit->pm_qos_class)
391                 qos_limit_level = pm_qos_request(bus_limit->pm_qos_class);
392         else
393                 qos_limit_level = bus_limit->update == _cap_update ?
394                                                         ULONG_MAX : 0;
395         return bus_limit->update(bus_limit, qos_limit_level);
396 }
397
398 static ssize_t
399 bus_limit_state_show(struct kobject *kobj, struct kobj_attribute *attr,
400                     char *buf)
401 {
402         struct core_bus_limit_table *bus_limit = refcnt_to_bus(attr);
403         return sprintf(buf, "%d\n", bus_limit->refcnt ? 1 : 0);
404 }
405 static ssize_t
406 bus_limit_state_store(struct kobject *kobj, struct kobj_attribute *attr,
407                      const char *buf, size_t count)
408 {
409         int state;
410         struct core_bus_limit_table *bus_limit = refcnt_to_bus(attr);
411
412         if (sscanf(buf, "%d", &state) != 1)
413                 return -1;
414
415         mutex_lock(&bus_limit_lock);
416
417         if (state) {
418                 bus_limit->refcnt++;
419                 if (bus_limit->refcnt == 1)
420                         bus_limit_update(bus_limit);
421         } else if (bus_limit->refcnt) {
422                 bus_limit->refcnt--;
423                 if (bus_limit->refcnt == 0)
424                         bus_limit_update(bus_limit);
425         }
426
427         mutex_unlock(&bus_limit_lock);
428         return count;
429 }
430
431 static ssize_t
432 bus_limit_level_show(struct kobject *kobj, struct kobj_attribute *attr,
433                     char *buf)
434 {
435         struct core_bus_limit_table *bus_limit = level_to_bus(attr);
436         return sprintf(buf, "%lu\n", bus_limit->level);
437 }
438 static ssize_t
439 bus_limit_level_store(struct kobject *kobj, struct kobj_attribute *attr,
440                      const char *buf, size_t count)
441 {
442         int level;
443         struct core_bus_limit_table *bus_limit = level_to_bus(attr);
444
445         if (sscanf(buf, "%d", &level) != 1)
446                 return -1;
447
448         mutex_lock(&bus_limit_lock);
449         if (bus_limit->level != level) {
450                 bus_limit->level = level;
451                 bus_limit_update(bus_limit);
452         }
453         mutex_unlock(&bus_limit_lock);
454         return count;
455 }
456
457 static int qos_limit_notify(struct notifier_block *nb,
458                           unsigned long qos_limit_level, void *p)
459 {
460         struct core_bus_limit_table *bus_limit = nb_to_bus(nb);
461
462         mutex_lock(&bus_limit_lock);
463         bus_limit->update(bus_limit, qos_limit_level);
464         mutex_unlock(&bus_limit_lock);
465         return NOTIFY_OK;
466 }
467
468 int __init tegra_init_shared_bus_cap(
469         struct core_bus_limit_table *table, int table_size,
470         struct kobject *cap_kobj)
471 {
472         int i, j;
473         struct clk *c = NULL;
474
475         if (!table || !table_size || (table_size > MAX_BUS_NUM))
476                 return -EINVAL;
477
478         for (i = 0, j = 0; i < table_size; i++) {
479                 c = tegra_get_clock_by_name(table[i].limit_clk_name);
480                 if (!c) {
481                         pr_err("%s: failed to initialize %s table\n",
482                                __func__, table[i].limit_clk_name);
483                         continue;
484                 }
485                 table[i].limit_clk = c;
486                 table[i].level = clk_get_max_rate(c);
487                 table[i].refcnt = 0;
488                 table[i].refcnt_attr.show = bus_limit_state_show;
489                 table[i].refcnt_attr.store = bus_limit_state_store;
490                 table[i].level_attr.show = bus_limit_level_show;
491                 table[i].level_attr.store = bus_limit_level_store;
492                 table[i].update = _cap_update;
493                 bus_attributes[j++] = &table[i].refcnt_attr.attr;
494                 bus_attributes[j++] = &table[i].level_attr.attr;
495                 if (table[i].pm_qos_class) {
496                         table[i].qos_nb.notifier_call = qos_limit_notify;
497                         if (pm_qos_add_notifier(
498                                 table[i].pm_qos_class, &table[i].qos_nb)) {
499                                 pr_err("%s: Failed register %s with PM QoS\n",
500                                         __func__, table[i].limit_clk_name);
501                                 table[i].pm_qos_class = 0;
502                         }
503                 }
504         }
505         bus_attributes[j] = NULL;
506
507         if (!cap_kobj || sysfs_create_files(cap_kobj, bus_attributes))
508                 return -ENOMEM;
509         return 0;
510 }
511
512 int __init tegra_init_shared_bus_floor(
513         struct core_bus_limit_table *table, int table_size,
514         struct kobject *floor_kobj)
515 {
516         int i, j;
517         struct clk *c = NULL;
518
519         if (!table || !table_size || (table_size > MAX_BUS_NUM))
520                 return -EINVAL;
521
522         for (i = 0, j = 0; i < table_size; i++) {
523                 c = tegra_get_clock_by_name(table[i].limit_clk_name);
524                 if (!c) {
525                         pr_err("%s: failed to initialize %s table\n",
526                                __func__, table[i].limit_clk_name);
527                         continue;
528                 }
529                 table[i].limit_clk = c;
530                 table[i].level = clk_get_max_rate(c);
531                 table[i].refcnt_attr.show = bus_limit_state_show;
532                 table[i].refcnt_attr.store = bus_limit_state_store;
533                 table[i].level_attr.show = bus_limit_level_show;
534                 table[i].level_attr.store = bus_limit_level_store;
535                 table[i].update = _floor_update;
536                 bus_attributes[j++] = &table[i].refcnt_attr.attr;
537                 bus_attributes[j++] = &table[i].level_attr.attr;
538                 if (table[i].pm_qos_class) {
539                         table[i].qos_nb.notifier_call = qos_limit_notify;
540                         if (pm_qos_add_notifier(
541                                 table[i].pm_qos_class, &table[i].qos_nb)) {
542                                 pr_err("%s: Failed register %s with PM QoS\n",
543                                         __func__, table[i].limit_clk_name);
544                                 table[i].pm_qos_class = 0;
545                         }
546                 }
547         }
548         bus_attributes[j] = NULL;
549
550         if (!floor_kobj || sysfs_create_files(floor_kobj, bus_attributes))
551                 return -ENOMEM;
552         return 0;
553 }
554
555 /* sysfs interfaces to read tegra core shared bus current / available rates */
556 #define rate_to_bus(attr) \
557         container_of(attr, struct core_bus_rates_table, rate_attr)
558 #define available_rates_to_bus(attr) \
559         container_of(attr, struct core_bus_rates_table, available_rates_attr)
560
561
562 static ssize_t
563 bus_rate_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
564 {
565         struct core_bus_rates_table *bus = rate_to_bus(attr);
566         struct clk *c = bus->bus_clk;
567         return sprintf(buf, "%lu\n", clk_get_rate(c));
568 }
569
570 static ssize_t
571 bus_available_rates_show(struct kobject *kobj, struct kobj_attribute *attr,
572                          char *buf)
573 {
574         int i;
575         ssize_t n = 0;
576         struct core_bus_rates_table *bus = available_rates_to_bus(attr);
577
578         for (i = 0; i < MAX_DVFS_FREQS; i++) {
579                 unsigned long rate = bus->available_rates[i];
580                 if (!rate || ((n + 10) > PAGE_SIZE))
581                         break;
582
583                 n += sprintf(&buf[n], "%lu ", rate);
584         }
585         n = n ? n-1 : 0;
586         n += sprintf(&buf[n], "\n");
587         return n;
588 }
589
590 static int get_available_rates(struct clk *c, struct core_bus_rates_table *t)
591 {
592         int i = 0;
593         unsigned long rate = 0;
594         unsigned long max_rate = clk_get_max_rate(c);
595
596         /* available rates search below applied to shared bus only */
597         if (!c->ops || !c->ops->round_rate || !c->ops->shared_bus_update) {
598                 pr_err("%s: cannot find %s rates ladder\n", __func__, c->name);
599                 return -ENOSYS;
600         }
601
602         /* shared bus clock must round up, unless top of range reached */
603         while ((rate <= max_rate) && (i <= MAX_DVFS_FREQS)) {
604                 unsigned long rounded_rate = clk_round_rate(c, rate);
605                 if (IS_ERR_VALUE(rounded_rate) || (rounded_rate <= rate))
606                         break;
607
608                 rate = rounded_rate + 2000;     /* 2kHz resolution */
609                 t->available_rates[i++] = rounded_rate;
610         }
611         return 0;
612 }
613
614 int __init tegra_init_sysfs_shared_bus_rate(
615         struct core_bus_rates_table *table, int table_size,
616         struct kobject *floor_kobj)
617 {
618         int i, j;
619         struct clk *c = NULL;
620
621         if (!table || !table_size || (table_size > MAX_BUS_NUM))
622                 return -EINVAL;
623
624         for (i = 0, j = 0; i < table_size; i++) {
625                 c = tegra_get_clock_by_name(table[i].bus_clk_name);
626                 if (!c || get_available_rates(c, &table[i])) {
627                         pr_err("%s: failed to initialize %s table\n",
628                                __func__, table[i].bus_clk_name);
629                         continue;
630                 }
631                 table[i].bus_clk = c;
632                 table[i].rate_attr.show = bus_rate_show;
633                 table[i].available_rates_attr.show = bus_available_rates_show;
634                 bus_attributes[j++] = &table[i].rate_attr.attr;
635                 bus_attributes[j++] = &table[i].available_rates_attr.attr;
636         }
637         bus_attributes[j] = NULL;
638
639         if (!floor_kobj || sysfs_create_files(floor_kobj, bus_attributes))
640                 return -ENOMEM;
641         return 0;
642 }