dvfs: tegra21: Rename thermal safe maximum frequency
[linux-3.10.git] / include / linux / platform / 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-2014 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 <linux/tegra_throttle.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         bool solved_at_suspend;
52 };
53
54 struct rail_stats {
55         ktime_t time_at_mv[DVFS_RAIL_STATS_TOP_BIN + 1];
56         ktime_t last_update;
57         int last_index;
58         bool off;
59         int bin_uV;
60 };
61
62 struct rail_alignment {
63         int offset_uv;
64         int step_uv; /* Step voltage */
65 };
66
67 struct dvfs_rail {
68         const char *reg_id;
69         int min_millivolts;
70         int max_millivolts;
71         int reg_max_millivolts;
72         int nominal_millivolts; /* Max DVFS voltage */
73         int fixed_millivolts;
74         int override_millivolts;
75         int min_override_millivolts;
76         int override_unresolved;
77         int (*resolve_override)(int mv);
78
79         const int *therm_mv_floors;
80         const int *therm_mv_dfll_floors;
81         int therm_mv_floors_num;
82         const int *therm_mv_caps;
83         int therm_mv_caps_num;
84         const int *simon_vmin_offsets;
85         int simon_vmin_offs_num;
86         int simon_domain;
87
88         int step;
89         int step_up;
90         bool jmp_to_zero;
91         bool in_band_pm;
92         bool disabled;
93         bool updating;
94         bool resolving_to;
95         bool rate_set;
96         bool dt_reg_fixed;
97         bool dt_reg_pwm;
98
99         struct device_node *dt_node; /* device tree rail node */
100         struct list_head node;  /* node in dvfs_rail_list */
101         struct list_head dvfs;  /* list head of attached dvfs clocks */
102         struct list_head relationships_to;
103         struct list_head relationships_from;
104         struct regulator *reg;
105         int millivolts;
106         int new_millivolts;
107         int dbg_mv_offs;
108         int boot_millivolts;
109         int disable_millivolts;
110         int suspend_millivolts; /* voltage setting set during suspend */
111
112         bool suspended;
113         bool dfll_mode; /* DFLL mode ON/OFF */
114         bool dfll_mode_updating;
115
116         int therm_floor_idx;    /* index of vmin thermal range */
117         int therm_cap_idx;      /* index of vmax thermal range */
118         int therm_scale_idx;    /* index of thermal DVFS or clk source range */
119
120         /* Trips for vmin cooling device */
121         struct tegra_cooling_device *vmin_cdev;
122
123         /* Trips for vmax cooling device */
124         struct tegra_cooling_device *vmax_cdev;
125
126         /* Trips for thermal DVFS cooling device */
127         struct tegra_cooling_device *vts_cdev;
128
129         /* Trips for clock source switch cooling device */
130         struct tegra_cooling_device *clk_switch_cdev;
131
132         struct rail_alignment alignment;
133         struct rail_stats stats;
134         const char *version;
135 };
136
137 /*
138  * dfll_range -
139  *      DFLL_RANGE_NONE       : DFLL is not used
140  *      DFLL_RANGE_ALL_RATES  : DFLL is is used for all CPU rates
141  *      DFLL_RANGE_HIGH_RATES : DFLL is used only for high rates
142  *                              above crossover with PLL dvfs curve
143  */
144 enum dfll_range {
145         DFLL_RANGE_NONE = 0,
146         DFLL_RANGE_ALL_RATES,
147         DFLL_RANGE_HIGH_RATES,
148 };
149
150 /* DFLL usage is under thermal cooling device control */
151 #define TEGRA_USE_DFLL_CDEV_CNTRL 3
152
153 /* DVFS settings specific for DFLL clock source */
154 struct dvfs_dfll_data {
155         u32             tune0;
156         u32             tune0_high_mv;
157         u32             tune0_simon_mask;
158         u32             tune1;
159         bool            tune0_low_at_cold;
160         unsigned long   droop_rate_min;
161         unsigned long   use_dfll_rate_min;
162         unsigned long   out_rate_min;
163         unsigned long   max_rate_boost;
164         int tune_high_min_millivolts;
165         int tune_high_margin_mv;
166         int min_millivolts;
167         enum dfll_range range;
168         void (*tune_trimmers)(bool trim_high);
169         unsigned int (*is_bypass_down)(void);
170 };
171
172 /* DVFS settings specific for PLL clock source */
173 struct dvfs_pll_data {
174         int min_millivolts;
175 };
176
177 struct dvfs {
178         const char *clk_name;
179         int speedo_id;
180         int process_id;
181
182         /* Must be initialized before tegra_dvfs_init */
183         int freqs_mult;
184         unsigned long freqs[MAX_DVFS_FREQS];
185         const int *millivolts;
186         const int *peak_millivolts;
187         /* voltage settings as per DFLL clock source */
188         const int *dfll_millivolts;
189         struct dvfs_rail *dvfs_rail;
190         bool auto_dvfs;
191         bool can_override;
192         bool defer_override;
193
194         /* Filled in by tegra_dvfs_init */
195         int max_millivolts;
196         int num_freqs;
197         struct dvfs_dfll_data dfll_data;
198
199         /* Inidcates thermal DVFS on/off */
200         bool therm_dvfs;
201         /* Maximum rate safe at minimum voltage across all thermal ranges */
202         unsigned long fmax_at_vmin_safe_t;
203
204         int cur_millivolts;
205         unsigned long cur_rate;
206         unsigned long *alt_freqs;
207         bool use_alt_freqs;
208         long dbg_hz_offs;
209         struct list_head node;
210         struct list_head debug_node;
211         struct list_head reg_node;
212         struct mutex *lock;
213 };
214
215 /* CVB coefficients */
216 struct cvb_dvfs_parameters {
217         int     c0;
218         int     c1;
219         int     c2;
220         int     c3;
221         int     c4;
222         int     c5;
223 };
224
225 struct cvb_dvfs_table {
226         unsigned long freq;
227
228         /* Coeffs for voltage calculation, when dfll clock source is selected */
229         struct cvb_dvfs_parameters cvb_dfll_param;
230
231         /* Coeffs for voltage calculation, when pll clock source is selected */
232         struct cvb_dvfs_parameters cvb_pll_param;
233 };
234
235 struct cvb_dvfs {
236         int speedo_id;
237         int process_id;
238
239         /* Tuning parameters for dfll */
240         struct dvfs_dfll_data dfll_tune_data;
241
242         /* tuning parameters for pll clock */
243         struct dvfs_pll_data pll_tune_data;
244
245         /* dvfs Max voltage */
246         int max_mv;
247         int freqs_mult;
248
249         /* scaling values for voltage calculation */
250         int speedo_scale;
251         int voltage_scale;
252         int thermal_scale;
253
254         struct cvb_dvfs_table cvb_vmin;
255
256         /* CVB table for various frequencies */
257         struct cvb_dvfs_table cvb_table[MAX_DVFS_FREQS];
258
259         /* Trips for minimal voltage settings per thermal ranges */
260         int vmin_trips_table[MAX_THERMAL_LIMITS];
261         int therm_floors_table[MAX_THERMAL_LIMITS];
262
263         /* Trips for thermal DVFS per thermal ranges */
264         int vts_trips_table[MAX_THERMAL_LIMITS];
265
266         /* Trips for clock source change per thermal ranges */
267         int clk_switch_trips[MAX_THERMAL_LIMITS];
268 };
269
270 #define cpu_cvb_dvfs    cvb_dvfs
271 #define gpu_cvb_dvfs    cvb_dvfs
272 #define core_cvb_dvfs   cvb_dvfs
273
274 extern struct dvfs_rail *tegra_cpu_rail;
275 extern struct dvfs_rail *tegra_gpu_rail;
276 extern struct dvfs_rail *tegra_core_rail;
277
278 struct dvfs_data {
279         struct dvfs_rail *rail;
280         struct dvfs *tables;
281         int *millivolts;
282         unsigned int num_tables;
283         unsigned int num_voltages;
284 };
285
286 #ifdef CONFIG_OF
287 typedef int (*of_tegra_dvfs_init_cb_t)(struct device_node *);
288 int of_tegra_dvfs_init(const struct of_device_id *matches);
289 int of_tegra_dvfs_rail_node_parse(struct device_node *rail_dn,
290                                   struct dvfs_rail *rail);
291 #else
292 static inline int of_tegra_dvfs_init(const struct of_device_id *matches)
293 { return -ENODATA; }
294 static inline int of_tegra_dvfs_rail_node_parse(struct device_node *rail_dn,
295                                                 struct dvfs_rail *rail)
296 { return -ENODEV; }
297 #endif
298
299 void tegra11x_init_dvfs(void);
300 void tegra12x_init_dvfs(void);
301 void tegra13x_init_dvfs(void);
302 void tegra14x_init_dvfs(void);
303 void tegra21x_init_dvfs(void);
304 void tegra12x_vdd_cpu_align(int step_uv, int offset_uv);
305 void tegra13x_vdd_cpu_align(int step_uv, int offset_uv);
306 void tegra21x_vdd_cpu_align(int step_uv, int offset_uv);
307 void tegra_init_dvfs_one(struct dvfs *d, int max_freq_index);
308 int dvfs_debugfs_init(struct dentry *clk_debugfs_root);
309 int tegra_dvfs_rail_connect_regulators(void);
310 int tegra_dvfs_rail_register_notifiers(void);
311 int tegra_dvfs_init_rails(struct dvfs_rail *dvfs_rails[], int n);
312 void tegra_dvfs_add_relationships(struct dvfs_relationship *rels, int n);
313
314 void tegra_dvfs_rail_enable(struct dvfs_rail *rail);
315 void tegra_dvfs_rail_disable(struct dvfs_rail *rail);
316 int tegra_dvfs_rail_power_up(struct dvfs_rail *rail);
317 int tegra_dvfs_rail_power_down(struct dvfs_rail *rail);
318 bool tegra_dvfs_is_rail_up(struct dvfs_rail *rail);
319 bool tegra_dvfs_rail_updating(struct clk *clk);
320 void tegra_dvfs_rail_off(struct dvfs_rail *rail, ktime_t now);
321 void tegra_dvfs_rail_on(struct dvfs_rail *rail, ktime_t now);
322 void tegra_dvfs_rail_pause(struct dvfs_rail *rail, ktime_t delta, bool on);
323 int tegra_dvfs_rail_set_mode(struct dvfs_rail *rail, unsigned int mode);
324 int tegra_dvfs_rail_register_notifier(struct dvfs_rail *rail,
325                                       struct notifier_block *nb);
326 int tegra_dvfs_rail_unregister_notifier(struct dvfs_rail *rail,
327                                         struct notifier_block *nb);
328 struct dvfs_rail *tegra_dvfs_get_rail_by_name(const char *reg_id);
329
330 int tegra_dvfs_predict_peak_millivolts(struct clk *c, unsigned long rate);
331
332 int tegra_dvfs_override_core_cap_apply(int level);
333 int tegra_dvfs_therm_vmax_core_cap_apply(int *cap_idx, int new_idx, int level);
334
335 int tegra_dvfs_alt_freqs_install(struct dvfs *d, unsigned long *alt_freqs);
336 int tegra_dvfs_alt_freqs_set(struct dvfs *d, unsigned long *alt_freqs);
337 int tegra_dvfs_replace_voltage_table(struct dvfs *d, const int *new_millivolts);
338
339 int tegra_dvfs_dfll_mode_set(struct dvfs *d, unsigned long rate);
340 int tegra_dvfs_dfll_mode_clear(struct dvfs *d, unsigned long rate);
341 int tegra_clk_dfll_range_control(enum dfll_range use_dfll);
342
343 struct tegra_cooling_device *tegra_dvfs_get_cpu_vmax_cdev(void);
344 struct tegra_cooling_device *tegra_dvfs_get_cpu_vmin_cdev(void);
345 struct tegra_cooling_device *tegra_dvfs_get_core_vmax_cdev(void);
346 struct tegra_cooling_device *tegra_dvfs_get_core_vmin_cdev(void);
347 struct tegra_cooling_device *tegra_dvfs_get_gpu_vmin_cdev(void);
348 struct tegra_cooling_device *tegra_dvfs_get_gpu_vts_cdev(void);
349 struct tegra_cooling_device *tegra_dvfs_get_cpu_clk_switch_cdev(void);
350 #ifdef CONFIG_TEGRA_USE_SIMON
351 void tegra_dvfs_rail_init_simon_vmin_offsets(
352         int *offsets, int offs_num, struct dvfs_rail *rail);
353 #else
354 static inline void tegra_dvfs_rail_init_simon_vmin_offsets(
355         int *offsets, int offs_num, struct dvfs_rail *rail)
356 { }
357 #endif
358 void tegra_dvfs_rail_init_vmin_thermal_profile(
359         int *therm_trips_table, int *therm_floors_table,
360         struct dvfs_rail *rail, struct dvfs_dfll_data *d);
361 void tegra_dvfs_rail_init_vmax_thermal_profile(
362         int *therm_trips_table, int *therm_caps_table,
363         struct dvfs_rail *rail, struct dvfs_dfll_data *d);
364 int __init tegra_dvfs_rail_init_clk_switch_thermal_profile(
365         int *clk_switch_trips, struct dvfs_rail *rail);
366 int tegra_dvfs_rail_init_thermal_dvfs_trips(
367         int *therm_trips_table, struct dvfs_rail *rail);
368 int tegra_dvfs_init_thermal_dvfs_voltages(int *millivolts,
369         int *peak_millivolts, int freqs_num, int ranges_num, struct dvfs *d);
370 int tegra_dvfs_rail_dfll_mode_set_cold(struct dvfs_rail *rail,
371                                        struct clk *dfll_clk);
372 int tegra_dvfs_rail_get_thermal_floor(struct dvfs_rail *rail);
373 void tegra_dvfs_rail_register_vmax_cdev(struct dvfs_rail *rail);
374
375 #ifdef CONFIG_TEGRA_VDD_CORE_OVERRIDE
376 int tegra_dvfs_resolve_override(struct clk *c, unsigned long max_rate);
377 int tegra_dvfs_rail_get_override_floor(struct dvfs_rail *rail);
378 #else
379 static inline int tegra_dvfs_resolve_override(struct clk *c, unsigned long rate)
380 { return 0; }
381 static inline int tegra_dvfs_rail_get_override_floor(struct dvfs_rail *rail)
382 { return 0; }
383 #endif
384
385 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
386 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail);
387 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail);
388 #else
389 static inline int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
390 { return 0; }
391 static inline int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
392 { return 0; }
393 #endif
394
395 bool tegra_dvfs_is_dfll_bypass(void);
396
397 static inline bool tegra_dvfs_rail_is_dfll_mode(struct dvfs_rail *rail)
398 {
399         return rail ? rail->dfll_mode : false;
400 }
401 static inline bool tegra_dvfs_is_dfll_range_entry(struct dvfs *d,
402                                                   unsigned long rate)
403 {
404         /* make exception for cluster switch (cur_rate = 0) */
405         return  d->cur_rate && d->dvfs_rail && (!d->dvfs_rail->dfll_mode) &&
406                 (d->dfll_data.range == DFLL_RANGE_HIGH_RATES) &&
407                 (rate >= d->dfll_data.use_dfll_rate_min) &&
408                 (d->cur_rate < d->dfll_data.use_dfll_rate_min);
409 }
410
411 static inline bool tegra_dvfs_is_dfll_scale(struct dvfs *d, unsigned long rate)
412 {
413         return d->dfll_millivolts &&
414                 (tegra_dvfs_rail_is_dfll_mode(d->dvfs_rail) ||
415                 tegra_dvfs_is_dfll_range_entry(d, rate));
416 }
417
418 static inline bool tegra_dvfs_is_dfll_range(struct dvfs *d, unsigned long rate)
419 {
420         return (d->dfll_data.range == DFLL_RANGE_ALL_RATES) ||
421                 ((d->dfll_data.range == DFLL_RANGE_HIGH_RATES) &&
422                 (rate >= d->dfll_data.use_dfll_rate_min));
423 }
424
425 static inline int tegra_dvfs_get_dfll_range(struct dvfs *d)
426 {
427         if (d)
428                 return d->dfll_data.range;
429         return -ENOENT;
430 }
431
432 static inline int tegra_dvfs_set_dfll_range(struct dvfs *d, int range)
433 {
434         if (!d->dfll_millivolts)
435                 return -ENOSYS;
436
437         if ((range < DFLL_RANGE_NONE) || (range > DFLL_RANGE_HIGH_RATES))
438                 return -EINVAL;
439
440         d->dfll_data.range = range;
441         return 0;
442 }
443
444 static inline void tegra_dvfs_rail_mode_updating(struct dvfs_rail *rail,
445                                                  bool updating)
446 {
447         if (rail)
448                 rail->dfll_mode_updating = updating;
449 }
450
451 static inline void tegra_dvfs_set_dfll_tune_trimmers(
452         struct dvfs *d, void (*tune_trimmers)(bool trim_high))
453 {
454         d->dfll_data.tune_trimmers = tune_trimmers;
455 }
456
457 static inline int tegra_dvfs_rail_get_nominal_millivolts(struct dvfs_rail *rail)
458 {
459         if (rail)
460                 return rail->nominal_millivolts;
461         return -ENOENT;
462 }
463
464 static inline int tegra_dvfs_rail_get_boot_level(struct dvfs_rail *rail)
465 {
466         if (rail)
467                 return rail->boot_millivolts ? : rail->nominal_millivolts;
468         return -ENOENT;
469 }
470
471 #endif