ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[linux-3.10.git] / arch / arm / mach-tegra / dvfs.h
1 /*
2  *
3  * Copyright (C) 2010 Google, Inc.
4  *
5  * Author:
6  *      Colin Cross <ccross@google.com>
7  *
8  * Copyright (c) 2010-2013 NVIDIA CORPORATION. All rights reserved.
9  *
10  * This software is licensed under the terms of the GNU General Public
11  * License version 2, as published by the Free Software Foundation, and
12  * may be copied, distributed, and modified under those terms.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  */
20
21 #ifndef _TEGRA_DVFS_H_
22 #define _TEGRA_DVFS_H_
23
24 #include <linux/of.h>
25 #include <mach/thermal.h>
26
27 #define MAX_DVFS_FREQS  40
28 #define MAX_DVFS_TABLES 80
29 #define DVFS_RAIL_STATS_TOP_BIN 100
30 #define MAX_THERMAL_LIMITS      8
31 #define MAX_THERMAL_RANGES      (MAX_THERMAL_LIMITS + 1)
32
33 struct clk;
34 struct dvfs_rail;
35
36 /*
37  * dvfs_relationship between to rails, "from" and "to"
38  * when the rail changes, it will call dvfs_rail_update on the rails
39  * in the relationship_to list.
40  * when determining the voltage to set a rail to, it will consider each
41  * rail in the relationship_from list.
42  */
43 struct dvfs_relationship {
44         struct dvfs_rail *to;
45         struct dvfs_rail *from;
46         int (*solve)(struct dvfs_rail *, struct dvfs_rail *);
47
48         struct list_head to_node; /* node in relationship_to list */
49         struct list_head from_node; /* node in relationship_from list */
50         bool solved_at_nominal;
51 };
52
53 struct rail_stats {
54         ktime_t time_at_mv[DVFS_RAIL_STATS_TOP_BIN + 1];
55         ktime_t last_update;
56         int last_index;
57         bool off;
58         int bin_uV;
59 };
60
61 struct rail_alignment {
62         int offset_uv;
63         int step_uv;
64 };
65
66 struct dvfs_rail {
67         const char *reg_id;
68         int min_millivolts;
69         int max_millivolts;
70         int reg_max_millivolts;
71         int nominal_millivolts;
72         int fixed_millivolts;
73         int override_millivolts;
74         int min_override_millivolts;
75         int override_unresolved;
76         int (*resolve_override)(int mv);
77
78         const int *therm_mv_floors;
79         int therm_mv_floors_num;
80         const int *therm_mv_caps;
81         int therm_mv_caps_num;
82         const int *simon_vmin_offsets;
83         int simon_vmin_offs_num;
84         int simon_domain;
85
86         int step;
87         int step_up;
88         bool jmp_to_zero;
89         bool in_band_pm;
90         bool disabled;
91         bool updating;
92         bool resolving_to;
93         bool rate_set;
94
95         struct list_head node;  /* node in dvfs_rail_list */
96         struct list_head dvfs;  /* list head of attached dvfs clocks */
97         struct list_head relationships_to;
98         struct list_head relationships_from;
99         struct regulator *reg;
100         int millivolts;
101         int new_millivolts;
102         int dbg_mv_offs;
103         int boot_millivolts;
104         int disable_millivolts;
105         int suspend_millivolts;
106
107         bool suspended;
108         bool dfll_mode;
109         bool dfll_mode_updating;
110         int therm_floor_idx;
111         int therm_cap_idx;
112         int therm_scale_idx;
113         struct tegra_cooling_device *vmin_cdev;
114         struct tegra_cooling_device *vmax_cdev;
115         struct tegra_cooling_device *vts_cdev;
116         struct rail_alignment alignment;
117         struct rail_stats stats;
118 };
119
120 enum dfll_range {
121         DFLL_RANGE_NONE = 0,
122         DFLL_RANGE_ALL_RATES,
123         DFLL_RANGE_HIGH_RATES,
124 };
125
126 struct dvfs_dfll_data {
127         u32             tune0;
128         u32             tune0_high_mv;
129         u32             tune1;
130         unsigned long   droop_rate_min;
131         unsigned long   use_dfll_rate_min;
132         unsigned long   out_rate_min;
133         unsigned long   max_rate_boost;
134         int tune_high_min_millivolts;
135         int tune_high_margin_mv;
136         int min_millivolts;
137         enum dfll_range range;
138         void (*tune_trimmers)(bool trim_high);
139         unsigned int (*is_bypass_down)(void);
140 };
141
142 struct dvfs {
143         /* Used only by tegra2_clock.c */
144         const char *clk_name;
145         int speedo_id;
146         int process_id;
147
148         /* Must be initialized before tegra_dvfs_init */
149         int freqs_mult;
150         unsigned long freqs[MAX_DVFS_FREQS];
151         const int *millivolts;
152         const int *peak_millivolts;
153         const int *dfll_millivolts;
154         struct dvfs_rail *dvfs_rail;
155         bool auto_dvfs;
156         bool can_override;
157         bool defer_override;
158
159         /* Filled in by tegra_dvfs_init */
160         int max_millivolts;
161         int num_freqs;
162         struct dvfs_dfll_data dfll_data;
163         bool therm_dvfs;
164
165         int cur_millivolts;
166         unsigned long cur_rate;
167         unsigned long *alt_freqs;
168         bool use_alt_freqs;
169         struct list_head node;
170         struct list_head debug_node;
171         struct list_head reg_node;
172 };
173
174 struct cvb_dvfs_parameters {
175         int     c0;
176         int     c1;
177         int     c2;
178         int     c3;
179         int     c4;
180         int     c5;
181 };
182
183 struct cvb_dvfs_table {
184         unsigned long freq;
185         struct cvb_dvfs_parameters cvb_dfll_param;
186         struct cvb_dvfs_parameters cvb_pll_param;
187 };
188
189 struct cvb_dvfs {
190         int speedo_id;
191         int process_id;
192
193         struct dvfs_dfll_data dfll_tune_data;
194         int max_mv;
195         int freqs_mult;
196         int speedo_scale;
197         int voltage_scale;
198         int thermal_scale;
199         struct cvb_dvfs_table cvb_vmin;
200         struct cvb_dvfs_table cvb_table[MAX_DVFS_FREQS];
201         int vmin_trips_table[MAX_THERMAL_LIMITS];
202         int therm_floors_table[MAX_THERMAL_LIMITS];
203         int vts_trips_table[MAX_THERMAL_LIMITS];
204 };
205
206 #define cpu_cvb_dvfs    cvb_dvfs
207 #define gpu_cvb_dvfs    cvb_dvfs
208 #define core_cvb_dvfs   cvb_dvfs
209
210 extern struct dvfs_rail *tegra_cpu_rail;
211 extern struct dvfs_rail *tegra_gpu_rail;
212 extern struct dvfs_rail *tegra_core_rail;
213
214 struct dvfs_data {
215         struct dvfs_rail *rail;
216         struct dvfs *tables;
217         int *millivolts;
218         unsigned int num_tables;
219         unsigned int num_voltages;
220 };
221
222 #ifdef CONFIG_OF
223 typedef int (*of_tegra_dvfs_init_cb_t)(struct device_node *);
224 int of_tegra_dvfs_init(const struct of_device_id *matches);
225 #else
226 static inline int of_tegra_dvfs_init(const struct of_device_id *matches)
227 { return -ENODATA; }
228 #endif
229
230 void tegra11x_init_dvfs(void);
231 void tegra12x_init_dvfs(void);
232 void tegra14x_init_dvfs(void);
233 void tegra12x_vdd_cpu_align(int step_uv, int offset_uv);
234 int tegra_enable_dvfs_on_clk(struct clk *c, struct dvfs *d);
235 int dvfs_debugfs_init(struct dentry *clk_debugfs_root);
236 int tegra_dvfs_rail_connect_regulators(void);
237 int tegra_dvfs_rail_register_notifiers(void);
238 int tegra_dvfs_init_rails(struct dvfs_rail *dvfs_rails[], int n);
239 void tegra_dvfs_add_relationships(struct dvfs_relationship *rels, int n);
240
241 void tegra_dvfs_rail_enable(struct dvfs_rail *rail);
242 void tegra_dvfs_rail_disable(struct dvfs_rail *rail);
243 int tegra_dvfs_rail_power_up(struct dvfs_rail *rail);
244 int tegra_dvfs_rail_power_down(struct dvfs_rail *rail);
245 bool tegra_dvfs_is_rail_up(struct dvfs_rail *rail);
246 bool tegra_dvfs_rail_updating(struct clk *clk);
247 void tegra_dvfs_rail_off(struct dvfs_rail *rail, ktime_t now);
248 void tegra_dvfs_rail_on(struct dvfs_rail *rail, ktime_t now);
249 void tegra_dvfs_rail_pause(struct dvfs_rail *rail, ktime_t delta, bool on);
250 int tegra_dvfs_rail_set_mode(struct dvfs_rail *rail, unsigned int mode);
251 struct dvfs_rail *tegra_dvfs_get_rail_by_name(const char *reg_id);
252
253 int tegra_dvfs_predict_peak_millivolts(struct clk *c, unsigned long rate);
254 const int *tegra_dvfs_get_millivolts_pll(struct dvfs *d);
255
256 int tegra_dvfs_override_core_cap_apply(int level);
257 int tegra_dvfs_therm_vmax_core_cap_apply(int *cap_idx, int new_idx, int level);
258
259 int tegra_dvfs_alt_freqs_install(struct dvfs *d, unsigned long *alt_freqs);
260 int tegra_dvfs_alt_freqs_set(struct dvfs *d, unsigned long *alt_freqs);
261 int tegra_cpu_dvfs_alter(int edp_thermal_index, const cpumask_t *cpus,
262                          bool before_clk_update, int cpu_event);
263 int tegra_dvfs_replace_voltage_table(struct dvfs *d, const int *new_millivolts);
264
265 int tegra_dvfs_dfll_mode_set(struct dvfs *d, unsigned long rate);
266 int tegra_dvfs_dfll_mode_clear(struct dvfs *d, unsigned long rate);
267
268 struct tegra_cooling_device *tegra_dvfs_get_cpu_vmax_cdev(void);
269 struct tegra_cooling_device *tegra_dvfs_get_cpu_vmin_cdev(void);
270 struct tegra_cooling_device *tegra_dvfs_get_core_vmax_cdev(void);
271 struct tegra_cooling_device *tegra_dvfs_get_core_vmin_cdev(void);
272 struct tegra_cooling_device *tegra_dvfs_get_gpu_vmin_cdev(void);
273 struct tegra_cooling_device *tegra_dvfs_get_gpu_vts_cdev(void);
274 void tegra_dvfs_rail_init_simon_vmin_offsets(
275         int *offsets, int offs_num, struct dvfs_rail *rail);
276 void tegra_dvfs_rail_init_vmin_thermal_profile(
277         int *therm_trips_table, int *therm_floors_table,
278         struct dvfs_rail *rail, struct dvfs_dfll_data *d);
279 void tegra_dvfs_rail_init_vmax_thermal_profile(
280         int *therm_trips_table, int *therm_caps_table,
281         struct dvfs_rail *rail, struct dvfs_dfll_data *d);
282 int tegra_dvfs_rail_init_thermal_dvfs_trips(
283         int *therm_trips_table, struct dvfs_rail *rail);
284 int tegra_dvfs_init_thermal_dvfs_voltages(int *millivolts,
285         int *peak_millivolts, int freqs_num, int ranges_num, struct dvfs *d);
286 int tegra_dvfs_rail_dfll_mode_set_cold(struct dvfs_rail *rail);
287 void tegra_dvfs_rail_register_vmax_cdev(struct dvfs_rail *rail);
288
289 #ifdef CONFIG_TEGRA_VDD_CORE_OVERRIDE
290 int tegra_dvfs_resolve_override(struct clk *c, unsigned long max_rate);
291 int tegra_dvfs_rail_get_override_floor(struct dvfs_rail *rail);
292 #else
293 static inline int tegra_dvfs_resolve_override(struct clk *c, unsigned long rate)
294 { return 0; }
295 static inline int tegra_dvfs_rail_get_override_floor(struct dvfs_rail *rail)
296 { return 0; }
297 #endif
298
299 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
300 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail);
301 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail);
302 #else
303 static inline int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
304 { return 0; }
305 static inline int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
306 { return 0; }
307 #endif
308
309 bool tegra_dvfs_is_dfll_bypass(void);
310
311 static inline bool tegra_dvfs_rail_is_dfll_mode(struct dvfs_rail *rail)
312 {
313         return rail ? rail->dfll_mode : false;
314 }
315 static inline bool tegra_dvfs_is_dfll_range_entry(struct dvfs *d,
316                                                   unsigned long rate)
317 {
318         /* make exception for cluster switch (cur_rate = 0) */
319         return  d->cur_rate && d->dvfs_rail && (!d->dvfs_rail->dfll_mode) &&
320                 (d->dfll_data.range == DFLL_RANGE_HIGH_RATES) &&
321                 (rate >= d->dfll_data.use_dfll_rate_min) &&
322                 (d->cur_rate < d->dfll_data.use_dfll_rate_min);
323 }
324
325 static inline bool tegra_dvfs_is_dfll_scale(struct dvfs *d, unsigned long rate)
326 {
327         return tegra_dvfs_rail_is_dfll_mode(d->dvfs_rail) ||
328                 tegra_dvfs_is_dfll_range_entry(d, rate);
329 }
330
331 static inline bool tegra_dvfs_is_dfll_range(struct dvfs *d, unsigned long rate)
332 {
333         return (d->dfll_data.range == DFLL_RANGE_ALL_RATES) ||
334                 ((d->dfll_data.range == DFLL_RANGE_HIGH_RATES) &&
335                 (rate >= d->dfll_data.use_dfll_rate_min));
336 }
337 static inline int tegra_dvfs_set_dfll_range(struct dvfs *d, int range)
338 {
339         if (!d->dfll_millivolts)
340                 return -ENOSYS;
341
342         if ((range < DFLL_RANGE_NONE) || (range > DFLL_RANGE_HIGH_RATES))
343                 return -EINVAL;
344
345         d->dfll_data.range = range;
346         return 0;
347 }
348 static inline void tegra_dvfs_rail_mode_updating(struct dvfs_rail *rail,
349                                                  bool updating)
350 {
351         if (rail)
352                 rail->dfll_mode_updating = updating;
353 }
354
355 static inline void tegra_dvfs_set_dfll_tune_trimmers(
356         struct dvfs *d, void (*tune_trimmers)(bool trim_high))
357 {
358         d->dfll_data.tune_trimmers = tune_trimmers;
359 }
360
361 static inline int tegra_dvfs_rail_get_nominal_millivolts(struct dvfs_rail *rail)
362 {
363         if (rail)
364                 return rail->nominal_millivolts;
365         return -ENOENT;
366 }
367
368 static inline int tegra_dvfs_rail_get_boot_level(struct dvfs_rail *rail)
369 {
370         if (rail)
371                 return rail->boot_millivolts ? : rail->nominal_millivolts;
372         return -ENOENT;
373 }
374
375 static inline int tegra_dvfs_rail_get_thermal_floor(struct dvfs_rail *rail)
376 {
377         if (rail && rail->therm_mv_floors &&
378             (rail->therm_floor_idx < rail->therm_mv_floors_num))
379                 return rail->therm_mv_floors[rail->therm_floor_idx];
380         return 0;
381 }
382
383 #endif