ARM: tegra11: dvfs: Update CL-DVFS clock management
[linux-2.6.git] / arch / arm / mach-tegra / tegra_cl_dvfs.c
1 /*
2  * arch/arm/mach-tegra/tegra_cl_dvfs.c
3  *
4  * Copyright (C) 2012 NVIDIA Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <linux/kernel.h>
20 #include <linux/spinlock.h>
21 #include <linux/delay.h>
22 #include <linux/err.h>
23 #include <linux/io.h>
24 #include <linux/clk.h>
25 #include <linux/interrupt.h>
26 #include <linux/suspend.h>
27 #include <linux/debugfs.h>
28 #include <linux/seq_file.h>
29 #include <linux/uaccess.h>
30 #include <linux/module.h>
31
32 #include <mach/iomap.h>
33 #include <mach/irqs.h>
34 #include <mach/hardware.h>
35
36 #include "tegra_cl_dvfs.h"
37 #include "clock.h"
38
39 #define OUT_MASK                        0x3f
40
41 #define CL_DVFS_CTRL                    0x00
42 #define CL_DVFS_CONFIG                  0x04
43 #define CL_DVFS_CONFIG_DIV_MASK         0xff
44
45 #define CL_DVFS_PARAMS                  0x08
46 #define CL_DVFS_PARAMS_CG_SCALE         (0x1 << 24)
47 #define CL_DVFS_PARAMS_FORCE_MODE_SHIFT 22
48 #define CL_DVFS_PARAMS_FORCE_MODE_MASK  (0x3 << CL_DVFS_PARAMS_FORCE_MODE_SHIFT)
49 #define CL_DVFS_PARAMS_CF_PARAM_SHIFT   16
50 #define CL_DVFS_PARAMS_CF_PARAM_MASK    (0x3f << CL_DVFS_PARAMS_CF_PARAM_SHIFT)
51 #define CL_DVFS_PARAMS_CI_PARAM_SHIFT   8
52 #define CL_DVFS_PARAMS_CI_PARAM_MASK    (0x7 << CL_DVFS_PARAMS_CI_PARAM_SHIFT)
53 #define CL_DVFS_PARAMS_CG_PARAM_SHIFT   0
54 #define CL_DVFS_PARAMS_CG_PARAM_MASK    (0xff << CL_DVFS_PARAMS_CG_PARAM_SHIFT)
55
56 #define CL_DVFS_TUNE0                   0x0c
57 #define CL_DVFS_TUNE1                   0x10
58
59 #define CL_DVFS_FREQ_REQ                0x14
60 #define CL_DVFS_FREQ_REQ_FORCE_ENABLE   (0x1 << 28)
61 #define CL_DVFS_FREQ_REQ_FORCE_SHIFT    16
62 #define CL_DVFS_FREQ_REQ_FORCE_MASK     (0xfff << CL_DVFS_FREQ_REQ_FORCE_SHIFT)
63 #define FORCE_MAX                       2047
64 #define FORCE_MIN                       -2048
65 #define CL_DVFS_FREQ_REQ_SCALE_SHIFT    8
66 #define CL_DVFS_FREQ_REQ_SCALE_MASK     (0xff << CL_DVFS_FREQ_REQ_SCALE_SHIFT)
67 #define SCALE_MAX                       256
68 #define CL_DVFS_FREQ_REQ_FREQ_VALID     (0x1 << 7)
69 #define CL_DVFS_FREQ_REQ_FREQ_SHIFT     0
70 #define CL_DVFS_FREQ_REQ_FREQ_MASK      (0x7f << CL_DVFS_FREQ_REQ_FREQ_SHIFT)
71 #define FREQ_MAX                        127
72
73 #define CL_DVFS_SCALE_RAMP              0x18
74
75 #define CL_DVFS_DROOP_CTRL              0x1c
76 #define CL_DVFS_DROOP_CTRL_MIN_FREQ_SHIFT 16
77 #define CL_DVFS_DROOP_CTRL_MIN_FREQ_MASK  \
78                 (0xff << CL_DVFS_DROOP_CTRL_MIN_FREQ_SHIFT)
79 #define CL_DVFS_DROOP_CTRL_CUT_SHIFT    8
80 #define CL_DVFS_DROOP_CTRL_CUT_MASK     (0xf << CL_DVFS_DROOP_CTRL_CUT_SHIFT)
81 #define CL_DVFS_DROOP_CTRL_RAMP_SHIFT   0
82 #define CL_DVFS_DROOP_CTRL_RAMP_MASK    (0xff << CL_DVFS_DROOP_CTRL_RAMP_SHIFT)
83
84 #define CL_DVFS_OUTPUT_CFG              0x20
85 #define CL_DVFS_OUTPUT_CFG_I2C_ENABLE   (0x1 << 30)
86 #define CL_DVFS_OUTPUT_CFG_SAFE_SHIFT   24
87 #define CL_DVFS_OUTPUT_CFG_SAFE_MASK    \
88                 (OUT_MASK << CL_DVFS_OUTPUT_CFG_SAFE_SHIFT)
89 #define CL_DVFS_OUTPUT_CFG_MAX_SHIFT    16
90 #define CL_DVFS_OUTPUT_CFG_MAX_MASK     \
91                 (OUT_MASK << CL_DVFS_OUTPUT_CFG_MAX_SHIFT)
92 #define CL_DVFS_OUTPUT_CFG_MIN_SHIFT    8
93 #define CL_DVFS_OUTPUT_CFG_MIN_MASK     \
94                 (OUT_MASK << CL_DVFS_OUTPUT_CFG_MIN_SHIFT)
95
96 #define CL_DVFS_OUTPUT_FORCE            0x24
97 #define CL_DVFS_MONITOR_CTRL            0x28
98 #define CL_DVFS_MONITOR_CTRL_DISABLE    0
99 #define CL_DVFS_MONITOR_DATA            0x2c
100
101 #define CL_DVFS_I2C_CFG                 0x40
102 #define CL_DVFS_I2C_CFG_ARB_ENABLE      (0x1 << 20)
103 #define CL_DVFS_I2C_CFG_HS_CODE_SHIFT   16
104 #define CL_DVFS_I2C_CFG_HS_CODE_MASK    (0x7 << CL_DVFS_I2C_CFG_HS_CODE_SHIFT)
105 #define CL_DVFS_I2C_CFG_PACKET_ENABLE   (0x1 << 15)
106 #define CL_DVFS_I2C_CFG_SIZE_SHIFT      12
107 #define CL_DVFS_I2C_CFG_SIZE_MASK       (0x7 << CL_DVFS_I2C_CFG_SIZE_SHIFT)
108 #define CL_DVFS_I2C_CFG_SLAVE_ADDR_10   (0x1 << 10)
109 #define CL_DVFS_I2C_CFG_SLAVE_ADDR_SHIFT 0
110 #define CL_DVFS_I2C_CFG_SLAVE_ADDR_MASK \
111                 (0x3ff << CL_DVFS_I2C_CFG_SLAVE_ADDR_SHIFT)
112
113 #define CL_DVFS_I2C_VDD_REG_ADDR        0x44
114 #define CL_DVFS_I2C_STS                 0x48
115 #define CL_DVFS_I2C_STS_I2C_REQ_PENDING 0x1
116
117 #define CL_DVFS_INTR_STS                0x5c
118 #define CL_DVFS_INTR_EN                 0x60
119 #define CL_DVFS_INTR_MIN_MASK           0x1
120 #define CL_DVFS_INTR_MAX_MASK           0x2
121
122 #define CL_DVFS_I2C_CLK_DIVISOR         0x16c
123 #define CL_DVFS_I2C_CLK_DIVISOR_MASK    0xffff
124 #define CL_DVFS_I2C_CLK_DIVISOR_FS_SHIFT 16
125 #define CL_DVFS_I2C_CLK_DIVISOR_HS_SHIFT 0
126
127 #define CL_DVFS_OUTPUT_LUT              0x200
128
129 #define CL_DVFS_OUTPUT_PENDING_TIMEOUT  1000
130
131 /* Conversion macros (different scales for frequency request, and monitored
132    rate is not a typo)*/
133 #define GET_REQUEST_FREQ(rate, ref_rate)        ((rate) / ((ref_rate) / 2))
134 #define GET_REQUEST_RATE(freq, ref_rate)        ((freq) * ((ref_rate) / 2))
135 #define GET_MONITORED_RATE(freq, ref_rate)      ((freq) * ((ref_rate) / 4))
136 #define GET_DROOP_FREQ(rate, ref_rate)          ((rate) / ((ref_rate) / 4))
137 #define ROUND_MIN_RATE(rate, ref_rate)          \
138                 (DIV_ROUND_UP(rate, (ref_rate) / 2) * ((ref_rate) / 2))
139 #define GET_DIV(ref_rate, out_rate, scale)      \
140                 DIV_ROUND_UP((ref_rate), (out_rate) * (scale))
141
142 static const char *mode_name[] = {
143         [TEGRA_CL_DVFS_UNINITIALIZED] = "uninitialized",
144         [TEGRA_CL_DVFS_DISABLED] = "disabled",
145         [TEGRA_CL_DVFS_OPEN_LOOP] = "open_loop",
146         [TEGRA_CL_DVFS_CLOSED_LOOP] = "closed_loop",
147 };
148
149 static inline u32 cl_dvfs_readl(struct tegra_cl_dvfs *cld, u32 offs)
150 {
151         return __raw_readl(cld->cl_base + offs);
152 }
153 static inline void cl_dvfs_writel(struct tegra_cl_dvfs *cld, u32 val, u32 offs)
154 {
155         __raw_writel(val, cld->cl_base + offs);
156 }
157 static inline void cl_dvfs_wmb(struct tegra_cl_dvfs *cld)
158 {
159         wmb();
160         cl_dvfs_readl(cld, CL_DVFS_CTRL);
161 }
162
163 static inline void output_enable(struct tegra_cl_dvfs *cld, bool enable)
164 {
165         u32 val = cl_dvfs_readl(cld, CL_DVFS_OUTPUT_CFG);
166
167         /* FIXME: PWM output control */
168         if (enable)
169                 val |= CL_DVFS_OUTPUT_CFG_I2C_ENABLE;
170         else
171                 val &= ~CL_DVFS_OUTPUT_CFG_I2C_ENABLE;
172
173         cl_dvfs_writel(cld, val, CL_DVFS_OUTPUT_CFG);
174         cl_dvfs_wmb(cld);
175
176         if (!enable) {
177                 int i;
178                 for (i = 0; i < CL_DVFS_OUTPUT_PENDING_TIMEOUT; i++) {
179                         udelay(1);
180                         val = cl_dvfs_readl(cld, CL_DVFS_I2C_STS);
181                         if (!(val & CL_DVFS_I2C_STS_I2C_REQ_PENDING))
182                                 return;
183                 }
184                 pr_err("%s: I2C pending transaction timeout\n", __func__);
185         }
186 }
187
188 static inline void set_mode(struct tegra_cl_dvfs *cld,
189                             enum tegra_cl_dvfs_ctrl_mode mode)
190 {
191         cld->mode = mode;
192         cl_dvfs_writel(cld, mode - 1, CL_DVFS_CTRL);
193         cl_dvfs_wmb(cld);
194 }
195
196 static int find_safe_output(
197         struct tegra_cl_dvfs *cld, unsigned long rate, u8 *safe_output)
198 {
199         int i;
200         int n = cld->safe_dvfs->num_freqs;
201         unsigned long *freqs = cld->safe_dvfs->freqs;
202
203         for (i = 0; i < n; i++) {
204                 if (freqs[i] >= rate) {
205                         *safe_output = cld->clk_dvfs_map[i];
206                         return 0;
207                 }
208         }
209         return -EINVAL;
210 }
211
212 static struct voltage_reg_map *find_vdd_map_entry(
213         struct tegra_cl_dvfs *cld, int mV, bool exact)
214 {
215         int i, reg_mV;
216
217         for (i = 0; i < cld->p_data->vdd_map_size; i++) {
218                 /* round down to 1mV */
219                 reg_mV = cld->p_data->vdd_map[i].reg_uV / 1000;
220                 if (mV <= reg_mV)
221                         break;
222         }
223
224         if (i < cld->p_data->vdd_map_size) {
225                 if (!exact || (mV == reg_mV))
226                         return &cld->p_data->vdd_map[i];
227         }
228         return NULL;
229 }
230
231 static void cl_dvfs_init_maps(struct tegra_cl_dvfs *cld)
232 {
233         int i, j, v, v_max;
234         const int *millivolts;
235         struct voltage_reg_map *m;
236
237         BUILD_BUG_ON(MAX_DVFS_FREQS >= MAX_CL_DVFS_VOLTAGES);
238         BUILD_BUG_ON(MAX_CL_DVFS_VOLTAGES > OUT_MASK + 1);
239         BUG_ON(!cld->safe_dvfs);
240
241         millivolts = cld->safe_dvfs->millivolts;
242         v_max = cld->safe_dvfs->max_millivolts;
243
244         v = cld->soc_data->dfll_millivolts_min;
245         BUG_ON(v > millivolts[0]);
246
247         cld->out_map[0] = find_vdd_map_entry(cld, v, true);
248         BUG_ON(!cld->out_map[0]);
249
250         for (i = 0, j = 1; i < MAX_DVFS_FREQS; i++) {
251                 for (;;) {
252                         v += (v_max - v) / (MAX_CL_DVFS_VOLTAGES - j);
253                         if (v >= millivolts[i])
254                                 break;
255
256                         m = find_vdd_map_entry(cld, v, false);
257                         BUG_ON(!m);
258                         if (m != cld->out_map[j - 1])
259                                 cld->out_map[j++] = m;
260                 }
261
262                 v = millivolts[i];
263                 m = find_vdd_map_entry(cld, v, true);
264                 BUG_ON(!m);
265                 if (m != cld->out_map[j - 1])
266                         cld->out_map[j++] = m;
267                 cld->clk_dvfs_map[i] = j - 1;
268
269                 if (v >= v_max)
270                         break;
271         }
272         BUG_ON(millivolts[i] != v_max);
273         BUG_ON(j > MAX_CL_DVFS_VOLTAGES);
274         cld->num_voltages = j;
275 }
276
277 static void cl_dvfs_init_pwm_if(struct tegra_cl_dvfs *cld)
278 {
279         /* FIXME: not supported */
280 }
281
282 static void cl_dvfs_init_i2c_if(struct tegra_cl_dvfs *cld)
283 {
284         u32 val, div;
285         struct tegra_cl_dvfs_platform_data *p_data = cld->p_data;
286         bool hs_mode = p_data->u.pmu_i2c.hs_rate;
287
288         /* PMU slave address, vdd register offset, and transfer mode */
289         val = p_data->u.pmu_i2c.slave_addr << CL_DVFS_I2C_CFG_SLAVE_ADDR_SHIFT;
290         if (p_data->u.pmu_i2c.addr_10)
291                 val |= CL_DVFS_I2C_CFG_SLAVE_ADDR_10;
292         if (hs_mode) {
293                 val |= p_data->u.pmu_i2c.hs_master_code <<
294                         CL_DVFS_I2C_CFG_HS_CODE_SHIFT;
295                 val |= CL_DVFS_I2C_CFG_PACKET_ENABLE;
296         }
297         val |= CL_DVFS_I2C_CFG_SIZE_MASK;
298         val |= CL_DVFS_I2C_CFG_ARB_ENABLE;
299         cl_dvfs_writel(cld, val, CL_DVFS_I2C_CFG);
300         cl_dvfs_writel(cld, p_data->u.pmu_i2c.reg, CL_DVFS_I2C_VDD_REG_ADDR);
301
302
303         val = GET_DIV(cld->i2c_rate, p_data->u.pmu_i2c.fs_rate, 8);
304         BUG_ON(!val || (val > CL_DVFS_I2C_CLK_DIVISOR_MASK));
305         val = (val - 1) << CL_DVFS_I2C_CLK_DIVISOR_FS_SHIFT;
306         if (hs_mode) {
307                 div = GET_DIV(cld->i2c_rate, p_data->u.pmu_i2c.hs_rate, 12);
308                 BUG_ON(!div || (div > CL_DVFS_I2C_CLK_DIVISOR_MASK));
309         } else {
310                 div = 2;        /* default hs divisor just in case */
311         }
312         val |= (div - 1) << CL_DVFS_I2C_CLK_DIVISOR_HS_SHIFT;
313         cl_dvfs_writel(cld, val, CL_DVFS_I2C_CLK_DIVISOR);
314         cl_dvfs_wmb(cld);
315 }
316
317 static void cl_dvfs_init_out_if(struct tegra_cl_dvfs *cld)
318 {
319         int i;
320         u32 val;
321
322         /* disable output, and set output limits, use medium volatge
323            level as safe; disable and clear limit interrupts */
324         cld->safe_ouput = cld->num_voltages / 2;
325         val = ((cld->num_voltages / 2) << CL_DVFS_OUTPUT_CFG_SAFE_SHIFT) |
326                 ((cld->num_voltages - 1) << CL_DVFS_OUTPUT_CFG_MAX_SHIFT);
327         cl_dvfs_writel(cld, val, CL_DVFS_OUTPUT_CFG);
328         cl_dvfs_wmb(cld);
329
330         cl_dvfs_writel(cld, 0, CL_DVFS_OUTPUT_FORCE);
331         cl_dvfs_writel(cld, 0, CL_DVFS_INTR_EN);
332         cl_dvfs_writel(cld, CL_DVFS_INTR_MAX_MASK | CL_DVFS_INTR_MIN_MASK,
333                        CL_DVFS_INTR_STS);
334
335         /* fill in LUT table */
336         for (i = 0; i < cld->num_voltages; i++) {
337                 val = cld->out_map[i]->reg_value;
338                 cl_dvfs_writel(cld, val, CL_DVFS_OUTPUT_LUT + i * 4);
339         }
340         cl_dvfs_wmb(cld);
341
342         /* configure transport */
343         if (cld->p_data->pmu_if == TEGRA_CL_DVFS_PMU_I2C)
344                 cl_dvfs_init_i2c_if(cld);
345         else
346                 cl_dvfs_init_pwm_if(cld);
347 }
348
349 static void cl_dvfs_init_cntrl_logic(struct tegra_cl_dvfs *cld)
350 {
351         u32 val;
352         struct tegra_cl_dvfs_cfg_param *param = cld->p_data->cfg_param;
353
354         /* configure mode, control loop parameters, DFLL tuning */
355         set_mode(cld, TEGRA_CL_DVFS_DISABLED);
356
357         val = GET_DIV(cld->ref_rate, param->sample_rate, 32);
358         BUG_ON(val > CL_DVFS_CONFIG_DIV_MASK);
359         cl_dvfs_writel(cld, val, CL_DVFS_CONFIG);
360
361         val = (param->force_mode << CL_DVFS_PARAMS_FORCE_MODE_SHIFT) |
362                 (param->cf << CL_DVFS_PARAMS_CF_PARAM_SHIFT) |
363                 (param->ci << CL_DVFS_PARAMS_CI_PARAM_SHIFT) |
364                 ((u8)param->cg << CL_DVFS_PARAMS_CG_PARAM_SHIFT) |
365                 (param->cg_scale ? CL_DVFS_PARAMS_CG_SCALE : 0);
366         cl_dvfs_writel(cld, val, CL_DVFS_PARAMS);
367
368         cl_dvfs_writel(cld, cld->soc_data->tune0, CL_DVFS_TUNE0);
369         cl_dvfs_writel(cld, cld->soc_data->tune1, CL_DVFS_TUNE1);
370
371         /* configure droop (skipper 1) and scale (skipper 2) */
372         val = GET_DROOP_FREQ(cld->soc_data->dfll_droop_rate_min, cld->ref_rate);
373         val <<= CL_DVFS_DROOP_CTRL_MIN_FREQ_SHIFT;
374         BUG_ON(val > CL_DVFS_DROOP_CTRL_MIN_FREQ_MASK);
375         val |= (param->droop_cut_value << CL_DVFS_DROOP_CTRL_CUT_SHIFT);
376         val |= (param->droop_restore_ramp << CL_DVFS_DROOP_CTRL_RAMP_SHIFT);
377         cl_dvfs_writel(cld, val, CL_DVFS_DROOP_CTRL);
378
379         /* round minimum rate to request unit (ref_rate/2) boundary */
380         cld->dfll_rate_min = cld->soc_data->dfll_out_rate_min;
381         cld->dfll_rate_min = ROUND_MIN_RATE(cld->dfll_rate_min, cld->ref_rate);
382
383         cld->last_req.freq = 0;
384         cld->last_req.output = 0;
385         cld->last_req.scale = SCALE_MAX - 1;
386         cl_dvfs_writel(cld, CL_DVFS_FREQ_REQ_SCALE_MASK, CL_DVFS_FREQ_REQ);
387         cl_dvfs_writel(cld, param->scale_out_ramp, CL_DVFS_SCALE_RAMP);
388
389         /* disable monitoring */
390         cl_dvfs_writel(cld, CL_DVFS_MONITOR_CTRL_DISABLE, CL_DVFS_MONITOR_CTRL);
391         cl_dvfs_wmb(cld);
392 }
393
394 static int cl_dvfs_enable_clocks(struct tegra_cl_dvfs *cld)
395 {
396         if (cld->p_data->pmu_if == TEGRA_CL_DVFS_PMU_I2C) {
397                 clk_enable(cld->i2c_clk);
398                 clk_enable(cld->i2c_fast);
399         }
400         clk_enable(cld->ref_clk);
401         clk_enable(cld->soc_clk);
402         return 0;
403 }
404
405 static void cl_dvfs_disable_clocks(struct tegra_cl_dvfs *cld)
406 {
407         if (cld->p_data->pmu_if == TEGRA_CL_DVFS_PMU_I2C) {
408                 clk_disable(cld->i2c_clk);
409                 clk_disable(cld->i2c_fast);
410         }
411         clk_disable(cld->ref_clk);
412         clk_disable(cld->soc_clk);
413 }
414
415 int __init tegra_init_cl_dvfs(struct tegra_cl_dvfs *cld)
416 {
417         int ret;
418
419         /* Check platform and SoC data, get i2c clock */
420         if (!cld->soc_data) {
421                 pr_err("%s: SoC tuning data is not available\n", __func__);
422                 return -EINVAL;
423         }
424         if (!cld->p_data || !cld->p_data->cfg_param) {
425                 pr_err("%s: Platform data is not available\n", __func__);
426                 return -EINVAL;
427         }
428         if (cld->p_data->pmu_if == TEGRA_CL_DVFS_PMU_I2C) {
429                 ret = clk_enable(cld->i2c_clk);
430                 if (ret) {
431                         pr_err("%s: Failed to enable %s\n",
432                                __func__, cld->i2c_clk->name);
433                         return ret;
434                 }
435                 ret = clk_enable(cld->i2c_fast);
436                 if (ret) {
437                         pr_err("%s: Failed to enable %s\n",
438                                __func__, cld->i2c_clk->name);
439                         return ret;
440                 }
441                 cld->i2c_rate = clk_get_rate(cld->i2c_clk);
442         } else {
443                 pr_err("%s: PMU interface is not I2C\n", __func__);
444                 return -EINVAL;
445         }
446
447         /* Enable clocks, release control logic reset */
448         ret = clk_enable(cld->ref_clk);
449         if (ret) {
450                 pr_err("%s: Failed to enable %s\n",
451                        __func__, cld->ref_clk->name);
452                 return ret;
453         }
454         ret = clk_enable(cld->soc_clk);
455         if (ret) {
456                 pr_err("%s: Failed to enable %s\n",
457                        __func__, cld->ref_clk->name);
458                 return ret;
459         }
460         cld->ref_rate = clk_get_rate(cld->ref_clk);
461         BUG_ON(!cld->ref_rate);
462
463         /* Get ready ouput voltage mapping*/
464         cl_dvfs_init_maps(cld);
465
466         /* Setup PMU interface */
467         cl_dvfs_init_out_if(cld);
468
469         /* Configure control registers in disabled mode and disable clocks */
470         cl_dvfs_init_cntrl_logic(cld);
471         cl_dvfs_disable_clocks(cld);
472
473         return 0;
474 }
475
476 void tegra_cl_dvfs_set_plarform_data(struct tegra_cl_dvfs_platform_data *data)
477 {
478         struct clk *c = tegra_get_clock_by_name(data->dfll_clk_name);
479         if (c && c->u.dfll.cl_dvfs)
480                 c->u.dfll.cl_dvfs->p_data = data;
481 }
482
483 void tegra_cl_dvfs_set_soc_data(struct tegra_cl_dvfs_soc_data *data)
484 {
485         struct clk *c = tegra_get_clock_by_name(data->dfll_clk_name);
486         if (c && c->u.dfll.cl_dvfs)
487                 c->u.dfll.cl_dvfs->soc_data = data;
488 }
489
490 /*
491  * CL_DVFS states:
492  *
493  * - DISABLED: control logic mode - DISABLED, output interface disabled,
494  *   dfll in reset
495  * - OPEN_LOOP: control logic mode - OPEN_LOOP, output interface disabled,
496  *   dfll is running "unlocked"
497  * - CLOSED_LOOP: control logic mode - CLOSED_LOOP, output interface enabled,
498  *   dfll is running "locked"
499  */
500
501 /* Switch from any other state to DISABLED state */
502 void tegra_cl_dvfs_disable(struct tegra_cl_dvfs *cld)
503 {
504         if ((cld->mode == TEGRA_CL_DVFS_UNINITIALIZED) ||
505             (cld->mode == TEGRA_CL_DVFS_DISABLED))
506                 return;
507
508         output_enable(cld, false);
509         set_mode(cld, TEGRA_CL_DVFS_DISABLED);
510         cl_dvfs_disable_clocks(cld);
511 }
512
513 /* Switch from DISABLE state to OPEN_LOOP state */
514 int tegra_cl_dvfs_enable(struct tegra_cl_dvfs *cld)
515 {
516         if (cld->mode == TEGRA_CL_DVFS_UNINITIALIZED) {
517                 pr_err("%s: Cannot enable DFLL in %s mode\n",
518                        __func__, mode_name[cld->mode]);
519                 return -EPERM;
520         }
521
522         if (cld->mode != TEGRA_CL_DVFS_DISABLED)
523                 return 0;
524
525         cl_dvfs_enable_clocks(cld);
526         set_mode(cld, TEGRA_CL_DVFS_OPEN_LOOP);
527         return 0;
528 }
529
530 /* Switch from OPEN_LOOP state to CLOSED_LOOP state */
531 int tegra_cl_dvfs_lock(struct tegra_cl_dvfs *cld)
532 {
533         u32 val;
534         struct dfll_rate_req *req = &cld->last_req;
535
536         switch (cld->mode) {
537         case TEGRA_CL_DVFS_CLOSED_LOOP:
538                 return 0;
539
540         case TEGRA_CL_DVFS_OPEN_LOOP:
541                 if (req->freq == 0) {
542                         pr_err("%s: Cannot lock DFLL at rate 0\n", __func__);
543                         return -EINVAL;
544                 }
545
546                 /* update control logic setting with last rate request;
547                    use request safe output to set safe volatge */
548                 val = cl_dvfs_readl(cld, CL_DVFS_OUTPUT_CFG);
549                 val &= ~CL_DVFS_OUTPUT_CFG_SAFE_MASK;
550                 val |= req->output << CL_DVFS_OUTPUT_CFG_SAFE_SHIFT;
551                 cl_dvfs_writel(cld, val, CL_DVFS_OUTPUT_CFG);
552                 cld->safe_ouput = req->output;
553
554                 val = req->freq << CL_DVFS_FREQ_REQ_FREQ_SHIFT;
555                 val |= req->scale << CL_DVFS_FREQ_REQ_SCALE_SHIFT;
556                 val |= CL_DVFS_FREQ_REQ_FREQ_VALID |
557                         CL_DVFS_FREQ_REQ_FORCE_ENABLE;
558                 cl_dvfs_writel(cld, val, CL_DVFS_FREQ_REQ);
559
560                 output_enable(cld, true);
561                 set_mode(cld, TEGRA_CL_DVFS_CLOSED_LOOP);
562                 return 0;
563
564         default:
565                 BUG_ON(cld->mode > TEGRA_CL_DVFS_CLOSED_LOOP);
566                 pr_err("%s: Cannot lock DFLL in %s mode\n",
567                        __func__, mode_name[cld->mode]);
568                 return -EPERM;
569         }
570 }
571
572 /* Switch from CLOSED_LOOP state to OPEN_LOOP state */
573 int tegra_cl_dvfs_unlock(struct tegra_cl_dvfs *cld)
574 {
575         switch (cld->mode) {
576         case TEGRA_CL_DVFS_CLOSED_LOOP:
577                 output_enable(cld, false);
578                 set_mode(cld, TEGRA_CL_DVFS_OPEN_LOOP);
579                 return 0;
580
581         case TEGRA_CL_DVFS_OPEN_LOOP:
582                 return 0;
583
584         default:
585                 BUG_ON(cld->mode > TEGRA_CL_DVFS_CLOSED_LOOP);
586                 pr_err("%s: Cannot unlock DFLL in %s mode\n",
587                        __func__, mode_name[cld->mode]);
588                 return -EPERM;
589         }
590 }
591 /*
592  * Convert requested rate into the control logic settings. In CLOSED_LOOP mode,
593  * update new settings immediately to adjust DFLL output rate accordingly.
594  * Otherwise, just save them until next switch to closed loop.
595  */
596 int tegra_cl_dvfs_request_rate(struct tegra_cl_dvfs *cld, unsigned long rate)
597 {
598         u32 val;
599         struct dfll_rate_req req;
600
601         if (cld->mode == TEGRA_CL_DVFS_UNINITIALIZED) {
602                 pr_err("%s: Cannot set DFLL rate in %s mode\n",
603                        __func__, mode_name[cld->mode]);
604                 return -EPERM;
605         }
606
607         /* Determine DFLL output scale */
608         req.scale = SCALE_MAX - 1;
609         if (rate < cld->dfll_rate_min) {
610                 req.scale = rate / 1000 * SCALE_MAX /
611                         (cld->dfll_rate_min / 1000);
612                 if (!req.scale) {
613                         pr_err("%s: Rate %lu is below scalable range\n",
614                                __func__, rate);
615                         return -EINVAL;
616                 }
617                 req.scale--;
618                 rate = cld->dfll_rate_min;
619         }
620
621         /* Convert requested rate into frequency request and scale settings */
622         val = GET_REQUEST_FREQ(rate, cld->ref_rate);
623         if (val > FREQ_MAX) {
624                 pr_err("%s: Rate %lu is above dfll range\n", __func__, rate);
625                 return -EINVAL;
626         }
627         req.freq = val;
628         rate = GET_REQUEST_RATE(val, cld->ref_rate);
629
630         /* Find safe voltage for requested rate */
631         if (find_safe_output(cld, rate, &req.output)) {
632                 pr_err("%s: Failed to find safe output for rate %lu\n",
633                        __func__, rate);
634                 return -EINVAL;
635         }
636
637         /* Save validated request, and in CLOSED_LOOP mode actually update
638            control logic settings; use request safe output to set forced
639            voltage */
640         cld->last_req = req;
641
642         if (cld->mode == TEGRA_CL_DVFS_CLOSED_LOOP) {
643                 int force_val = req.output - cld->safe_ouput;
644                 int coef = cld->p_data->cfg_param->cg_scale ? 128 : 16;
645                 force_val = force_val * coef / cld->p_data->cfg_param->cg;
646                 force_val = clamp(force_val, FORCE_MIN, FORCE_MAX);
647                 val |= ((u32)force_val << CL_DVFS_FREQ_REQ_FORCE_SHIFT) &
648                                         CL_DVFS_FREQ_REQ_FORCE_MASK;
649
650                 val |= req.scale << CL_DVFS_FREQ_REQ_SCALE_SHIFT;
651                 val |= CL_DVFS_FREQ_REQ_FREQ_VALID |
652                         CL_DVFS_FREQ_REQ_FORCE_ENABLE;
653                 cl_dvfs_writel(cld, val, CL_DVFS_FREQ_REQ);
654                 cl_dvfs_wmb(cld);
655         }
656         return 0;
657 }
658
659 unsigned long tegra_cl_dvfs_request_get(struct tegra_cl_dvfs *cld)
660 {
661         struct dfll_rate_req *req = &cld->last_req;
662         u32 rate = GET_REQUEST_RATE(req->freq, cld->ref_rate);
663         if ((req->scale + 1) < SCALE_MAX) {
664                 rate = DIV_ROUND_UP(rate / 1000 * (req->scale + 1), SCALE_MAX);
665                 rate *= 1000;
666         }
667         return rate;
668 }
669
670 #ifdef CONFIG_DEBUG_FS
671
672 static int lock_get(void *data, u64 *val)
673 {
674         struct clk *c = (struct clk *)data;
675         *val = c->u.dfll.cl_dvfs->mode == TEGRA_CL_DVFS_CLOSED_LOOP;
676         return 0;
677 }
678 static int lock_set(void *data, u64 val)
679 {
680         struct clk *c = (struct clk *)data;
681         return tegra_clk_cfg_ex(c, TEGRA_CLK_DFLL_LOCK, val);
682 }
683 DEFINE_SIMPLE_ATTRIBUTE(lock_fops, lock_get, lock_set, "%llu\n");
684
685 static int monitor_get(void *data, u64 *val)
686 {
687         struct tegra_cl_dvfs *cld = ((struct clk *)data)->u.dfll.cl_dvfs;
688         *val = cl_dvfs_readl(cld, CL_DVFS_MONITOR_DATA);
689         return 0;
690 }
691 DEFINE_SIMPLE_ATTRIBUTE(monitor_fops, monitor_get, NULL, "%llu\n");
692
693
694 static int cl_register_show(struct seq_file *s, void *data)
695 {
696         u32 offs;
697         struct clk *c = s->private;
698         struct tegra_cl_dvfs *cld = c->u.dfll.cl_dvfs;
699
700         seq_printf(s, "CONTROL REGISTERS:\n");
701         for (offs = 0; offs <= CL_DVFS_MONITOR_CTRL; offs += 4)
702                 seq_printf(s, "[0x%02x] = 0x%08x\n",
703                            offs, cl_dvfs_readl(cld, offs));
704
705         seq_printf(s, "\nI2C and INTR REGISTERS:\n");
706         for (offs = CL_DVFS_I2C_CFG; offs <= CL_DVFS_I2C_STS; offs += 4)
707                 seq_printf(s, "[0x%02x] = 0x%08x\n",
708                            offs, cl_dvfs_readl(cld, offs));
709
710         offs = CL_DVFS_INTR_STS;
711         seq_printf(s, "[0x%02x] = 0x%08x\n", offs, cl_dvfs_readl(cld, offs));
712         offs = CL_DVFS_INTR_EN;
713         seq_printf(s, "[0x%02x] = 0x%08x\n", offs, cl_dvfs_readl(cld, offs));
714         offs = CL_DVFS_I2C_CLK_DIVISOR;
715         seq_printf(s, "[0x%02x] = 0x%08x\n", offs, cl_dvfs_readl(cld, offs));
716
717         seq_printf(s, "\nLUT:\n");
718         for (offs = CL_DVFS_OUTPUT_LUT;
719              offs < CL_DVFS_OUTPUT_LUT + 4 * MAX_CL_DVFS_VOLTAGES;
720              offs += 4)
721                 seq_printf(s, "[0x%02x] = 0x%08x\n",
722                            offs, cl_dvfs_readl(cld, offs));
723
724         return 0;
725 }
726
727 static int cl_register_open(struct inode *inode, struct file *file)
728 {
729         return single_open(file, cl_register_show, inode->i_private);
730 }
731
732 static ssize_t cl_register_write(struct file *file,
733         const char __user *userbuf, size_t count, loff_t *ppos)
734 {
735         char buf[80];
736         u32 offs;
737         u32 val;
738         struct clk *c = file->f_path.dentry->d_inode->i_private;
739         struct tegra_cl_dvfs *cld = c->u.dfll.cl_dvfs;
740
741         if (sizeof(buf) <= count)
742                 return -EINVAL;
743
744         if (copy_from_user(buf, userbuf, count))
745                 return -EFAULT;
746
747         /* terminate buffer and trim - white spaces may be appended
748          *  at the end when invoked from shell command line */
749         buf[count] = '\0';
750         strim(buf);
751
752         if (sscanf(buf, "[0x%x] = 0x%x", &offs, &val) != 2)
753                 return -1;
754
755         cl_dvfs_writel(cld, val, offs & (~0x3));
756         return count;
757 }
758
759 static const struct file_operations cl_register_fops = {
760         .open           = cl_register_open,
761         .read           = seq_read,
762         .write          = cl_register_write,
763         .llseek         = seq_lseek,
764         .release        = single_release,
765 };
766
767 static int __init tegra_cl_dvfs_debug_init(void)
768 {
769         struct dentry *cpu_cl_dvfs_dentry;
770         struct clk *dfll_cpu = tegra_get_clock_by_name("dfll_cpu");
771
772         if (!dfll_cpu || !dfll_cpu->dent || (dfll_cpu->state == UNINITIALIZED))
773                 return 0;
774
775         if (!debugfs_create_file("lock", S_IRUGO | S_IWUSR,
776                 dfll_cpu->dent, dfll_cpu, &lock_fops))
777                 goto err_out;
778
779         cpu_cl_dvfs_dentry = debugfs_create_dir("cl_dvfs", dfll_cpu->dent);
780         if (!cpu_cl_dvfs_dentry)
781                 goto err_out;
782
783         if (!debugfs_create_file("monitor", S_IRUGO,
784                 cpu_cl_dvfs_dentry, dfll_cpu, &monitor_fops))
785                 goto err_out;
786
787         if (!debugfs_create_file("registers", S_IRUGO | S_IWUSR,
788                 cpu_cl_dvfs_dentry, dfll_cpu, &cl_register_fops))
789                 goto err_out;
790
791         return 0;
792
793 err_out:
794         debugfs_remove_recursive(dfll_cpu->dent);
795         return -ENOMEM;
796 }
797
798 late_initcall(tegra_cl_dvfs_debug_init);
799 #endif