Commit | Line | Data |
---|---|---|
d8d7a08f TT |
1 | /* |
2 | * clk-dfll.c - Tegra DFLL clock source common code | |
3 | * | |
4 | * Copyright (C) 2012-2014 NVIDIA Corporation. All rights reserved. | |
5 | * | |
6 | * Aleksandr Frid <afrid@nvidia.com> | |
7 | * Paul Walmsley <pwalmsley@nvidia.com> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License version 2 as | |
11 | * published by the Free Software Foundation. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, but WITHOUT | |
14 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
16 | * more details. | |
17 | * | |
18 | * This library is for the DVCO and DFLL IP blocks on the Tegra124 | |
19 | * SoC. These IP blocks together are also known at NVIDIA as | |
20 | * "CL-DVFS". To try to avoid confusion, this code refers to them | |
21 | * collectively as the "DFLL." | |
22 | * | |
23 | * The DFLL is a root clocksource which tolerates some amount of | |
24 | * supply voltage noise. Tegra124 uses it to clock the fast CPU | |
25 | * complex when the target CPU speed is above a particular rate. The | |
26 | * DFLL can be operated in either open-loop mode or closed-loop mode. | |
27 | * In open-loop mode, the DFLL generates an output clock appropriate | |
28 | * to the supply voltage. In closed-loop mode, when configured with a | |
29 | * target frequency, the DFLL minimizes supply voltage while | |
30 | * delivering an average frequency equal to the target. | |
31 | * | |
32 | * Devices clocked by the DFLL must be able to tolerate frequency | |
33 | * variation. In the case of the CPU, it's important to note that the | |
34 | * CPU cycle time will vary. This has implications for | |
35 | * performance-measurement code and any code that relies on the CPU | |
36 | * cycle time to delay for a certain length of time. | |
37 | * | |
38 | */ | |
39 | ||
40 | #include <linux/clk.h> | |
41 | #include <linux/clk-provider.h> | |
42 | #include <linux/debugfs.h> | |
43 | #include <linux/device.h> | |
44 | #include <linux/err.h> | |
45 | #include <linux/i2c.h> | |
46 | #include <linux/io.h> | |
47 | #include <linux/kernel.h> | |
48 | #include <linux/module.h> | |
49 | #include <linux/of.h> | |
50 | #include <linux/pm_opp.h> | |
51 | #include <linux/pm_runtime.h> | |
52 | #include <linux/regmap.h> | |
53 | #include <linux/regulator/consumer.h> | |
54 | #include <linux/reset.h> | |
55 | #include <linux/seq_file.h> | |
56 | ||
57 | #include "clk-dfll.h" | |
58 | ||
59 | /* | |
60 | * DFLL control registers - access via dfll_{readl,writel} | |
61 | */ | |
62 | ||
63 | /* DFLL_CTRL: DFLL control register */ | |
64 | #define DFLL_CTRL 0x00 | |
65 | #define DFLL_CTRL_MODE_MASK 0x03 | |
66 | ||
67 | /* DFLL_CONFIG: DFLL sample rate control */ | |
68 | #define DFLL_CONFIG 0x04 | |
69 | #define DFLL_CONFIG_DIV_MASK 0xff | |
70 | #define DFLL_CONFIG_DIV_PRESCALE 32 | |
71 | ||
72 | /* DFLL_PARAMS: tuning coefficients for closed loop integrator */ | |
73 | #define DFLL_PARAMS 0x08 | |
74 | #define DFLL_PARAMS_CG_SCALE (0x1 << 24) | |
75 | #define DFLL_PARAMS_FORCE_MODE_SHIFT 22 | |
76 | #define DFLL_PARAMS_FORCE_MODE_MASK (0x3 << DFLL_PARAMS_FORCE_MODE_SHIFT) | |
77 | #define DFLL_PARAMS_CF_PARAM_SHIFT 16 | |
78 | #define DFLL_PARAMS_CF_PARAM_MASK (0x3f << DFLL_PARAMS_CF_PARAM_SHIFT) | |
79 | #define DFLL_PARAMS_CI_PARAM_SHIFT 8 | |
80 | #define DFLL_PARAMS_CI_PARAM_MASK (0x7 << DFLL_PARAMS_CI_PARAM_SHIFT) | |
81 | #define DFLL_PARAMS_CG_PARAM_SHIFT 0 | |
82 | #define DFLL_PARAMS_CG_PARAM_MASK (0xff << DFLL_PARAMS_CG_PARAM_SHIFT) | |
83 | ||
84 | /* DFLL_TUNE0: delay line configuration register 0 */ | |
85 | #define DFLL_TUNE0 0x0c | |
86 | ||
87 | /* DFLL_TUNE1: delay line configuration register 1 */ | |
88 | #define DFLL_TUNE1 0x10 | |
89 | ||
90 | /* DFLL_FREQ_REQ: target DFLL frequency control */ | |
91 | #define DFLL_FREQ_REQ 0x14 | |
92 | #define DFLL_FREQ_REQ_FORCE_ENABLE (0x1 << 28) | |
93 | #define DFLL_FREQ_REQ_FORCE_SHIFT 16 | |
94 | #define DFLL_FREQ_REQ_FORCE_MASK (0xfff << DFLL_FREQ_REQ_FORCE_SHIFT) | |
95 | #define FORCE_MAX 2047 | |
96 | #define FORCE_MIN -2048 | |
97 | #define DFLL_FREQ_REQ_SCALE_SHIFT 8 | |
98 | #define DFLL_FREQ_REQ_SCALE_MASK (0xff << DFLL_FREQ_REQ_SCALE_SHIFT) | |
99 | #define DFLL_FREQ_REQ_SCALE_MAX 256 | |
100 | #define DFLL_FREQ_REQ_FREQ_VALID (0x1 << 7) | |
101 | #define DFLL_FREQ_REQ_MULT_SHIFT 0 | |
102 | #define DFLL_FREQ_REG_MULT_MASK (0x7f << DFLL_FREQ_REQ_MULT_SHIFT) | |
103 | #define FREQ_MAX 127 | |
104 | ||
105 | /* DFLL_DROOP_CTRL: droop prevention control */ | |
106 | #define DFLL_DROOP_CTRL 0x1c | |
107 | ||
108 | /* DFLL_OUTPUT_CFG: closed loop mode control registers */ | |
109 | /* NOTE: access via dfll_i2c_{readl,writel} */ | |
110 | #define DFLL_OUTPUT_CFG 0x20 | |
111 | #define DFLL_OUTPUT_CFG_I2C_ENABLE (0x1 << 30) | |
112 | #define OUT_MASK 0x3f | |
113 | #define DFLL_OUTPUT_CFG_SAFE_SHIFT 24 | |
114 | #define DFLL_OUTPUT_CFG_SAFE_MASK \ | |
115 | (OUT_MASK << DFLL_OUTPUT_CFG_SAFE_SHIFT) | |
116 | #define DFLL_OUTPUT_CFG_MAX_SHIFT 16 | |
117 | #define DFLL_OUTPUT_CFG_MAX_MASK \ | |
118 | (OUT_MASK << DFLL_OUTPUT_CFG_MAX_SHIFT) | |
119 | #define DFLL_OUTPUT_CFG_MIN_SHIFT 8 | |
120 | #define DFLL_OUTPUT_CFG_MIN_MASK \ | |
121 | (OUT_MASK << DFLL_OUTPUT_CFG_MIN_SHIFT) | |
122 | #define DFLL_OUTPUT_CFG_PWM_DELTA (0x1 << 7) | |
123 | #define DFLL_OUTPUT_CFG_PWM_ENABLE (0x1 << 6) | |
124 | #define DFLL_OUTPUT_CFG_PWM_DIV_SHIFT 0 | |
125 | #define DFLL_OUTPUT_CFG_PWM_DIV_MASK \ | |
126 | (OUT_MASK << DFLL_OUTPUT_CFG_PWM_DIV_SHIFT) | |
127 | ||
128 | /* DFLL_OUTPUT_FORCE: closed loop mode voltage forcing control */ | |
129 | #define DFLL_OUTPUT_FORCE 0x24 | |
130 | #define DFLL_OUTPUT_FORCE_ENABLE (0x1 << 6) | |
131 | #define DFLL_OUTPUT_FORCE_VALUE_SHIFT 0 | |
132 | #define DFLL_OUTPUT_FORCE_VALUE_MASK \ | |
133 | (OUT_MASK << DFLL_OUTPUT_FORCE_VALUE_SHIFT) | |
134 | ||
135 | /* DFLL_MONITOR_CTRL: internal monitor data source control */ | |
136 | #define DFLL_MONITOR_CTRL 0x28 | |
137 | #define DFLL_MONITOR_CTRL_FREQ 6 | |
138 | ||
139 | /* DFLL_MONITOR_DATA: internal monitor data output */ | |
140 | #define DFLL_MONITOR_DATA 0x2c | |
141 | #define DFLL_MONITOR_DATA_NEW_MASK (0x1 << 16) | |
142 | #define DFLL_MONITOR_DATA_VAL_SHIFT 0 | |
143 | #define DFLL_MONITOR_DATA_VAL_MASK (0xFFFF << DFLL_MONITOR_DATA_VAL_SHIFT) | |
144 | ||
145 | /* | |
146 | * I2C output control registers - access via dfll_i2c_{readl,writel} | |
147 | */ | |
148 | ||
149 | /* DFLL_I2C_CFG: I2C controller configuration register */ | |
150 | #define DFLL_I2C_CFG 0x40 | |
151 | #define DFLL_I2C_CFG_ARB_ENABLE (0x1 << 20) | |
152 | #define DFLL_I2C_CFG_HS_CODE_SHIFT 16 | |
153 | #define DFLL_I2C_CFG_HS_CODE_MASK (0x7 << DFLL_I2C_CFG_HS_CODE_SHIFT) | |
154 | #define DFLL_I2C_CFG_PACKET_ENABLE (0x1 << 15) | |
155 | #define DFLL_I2C_CFG_SIZE_SHIFT 12 | |
156 | #define DFLL_I2C_CFG_SIZE_MASK (0x7 << DFLL_I2C_CFG_SIZE_SHIFT) | |
157 | #define DFLL_I2C_CFG_SLAVE_ADDR_10 (0x1 << 10) | |
158 | #define DFLL_I2C_CFG_SLAVE_ADDR_SHIFT_7BIT 1 | |
159 | #define DFLL_I2C_CFG_SLAVE_ADDR_SHIFT_10BIT 0 | |
160 | ||
161 | /* DFLL_I2C_VDD_REG_ADDR: PMIC I2C address for closed loop mode */ | |
162 | #define DFLL_I2C_VDD_REG_ADDR 0x44 | |
163 | ||
164 | /* DFLL_I2C_STS: I2C controller status */ | |
165 | #define DFLL_I2C_STS 0x48 | |
166 | #define DFLL_I2C_STS_I2C_LAST_SHIFT 1 | |
167 | #define DFLL_I2C_STS_I2C_REQ_PENDING 0x1 | |
168 | ||
169 | /* DFLL_INTR_STS: DFLL interrupt status register */ | |
170 | #define DFLL_INTR_STS 0x5c | |
171 | ||
172 | /* DFLL_INTR_EN: DFLL interrupt enable register */ | |
173 | #define DFLL_INTR_EN 0x60 | |
174 | #define DFLL_INTR_MIN_MASK 0x1 | |
175 | #define DFLL_INTR_MAX_MASK 0x2 | |
176 | ||
177 | /* | |
178 | * Integrated I2C controller registers - relative to td->i2c_controller_base | |
179 | */ | |
180 | ||
181 | /* DFLL_I2C_CLK_DIVISOR: I2C controller clock divisor */ | |
182 | #define DFLL_I2C_CLK_DIVISOR 0x6c | |
183 | #define DFLL_I2C_CLK_DIVISOR_MASK 0xffff | |
184 | #define DFLL_I2C_CLK_DIVISOR_FS_SHIFT 16 | |
185 | #define DFLL_I2C_CLK_DIVISOR_HS_SHIFT 0 | |
186 | #define DFLL_I2C_CLK_DIVISOR_PREDIV 8 | |
187 | #define DFLL_I2C_CLK_DIVISOR_HSMODE_PREDIV 12 | |
188 | ||
189 | /* | |
190 | * Other constants | |
191 | */ | |
192 | ||
193 | /* MAX_DFLL_VOLTAGES: number of LUT entries in the DFLL IP block */ | |
194 | #define MAX_DFLL_VOLTAGES 33 | |
195 | ||
196 | /* | |
197 | * REF_CLK_CYC_PER_DVCO_SAMPLE: the number of ref_clk cycles that the hardware | |
198 | * integrates the DVCO counter over - used for debug rate monitoring and | |
199 | * droop control | |
200 | */ | |
201 | #define REF_CLK_CYC_PER_DVCO_SAMPLE 4 | |
202 | ||
203 | /* | |
204 | * REF_CLOCK_RATE: the DFLL reference clock rate currently supported by this | |
205 | * driver, in Hz | |
206 | */ | |
207 | #define REF_CLOCK_RATE 51000000UL | |
208 | ||
c4fe70ad TT |
209 | #define DVCO_RATE_TO_MULT(rate, ref_rate) ((rate) / ((ref_rate) / 2)) |
210 | #define MULT_TO_DVCO_RATE(mult, ref_rate) ((mult) * ((ref_rate) / 2)) | |
d8d7a08f TT |
211 | |
212 | /** | |
213 | * enum dfll_ctrl_mode - DFLL hardware operating mode | |
214 | * @DFLL_UNINITIALIZED: (uninitialized state - not in hardware bitfield) | |
215 | * @DFLL_DISABLED: DFLL not generating an output clock | |
216 | * @DFLL_OPEN_LOOP: DVCO running, but DFLL not adjusting voltage | |
c4fe70ad TT |
217 | * @DFLL_CLOSED_LOOP: DVCO running, and DFLL adjusting voltage to match |
218 | * the requested rate | |
d8d7a08f TT |
219 | * |
220 | * The integer corresponding to the last two states, minus one, is | |
221 | * written to the DFLL hardware to change operating modes. | |
222 | */ | |
223 | enum dfll_ctrl_mode { | |
224 | DFLL_UNINITIALIZED = 0, | |
225 | DFLL_DISABLED = 1, | |
226 | DFLL_OPEN_LOOP = 2, | |
c4fe70ad | 227 | DFLL_CLOSED_LOOP = 3, |
d8d7a08f TT |
228 | }; |
229 | ||
230 | /** | |
231 | * enum dfll_tune_range - voltage range that the driver believes it's in | |
232 | * @DFLL_TUNE_UNINITIALIZED: DFLL tuning not yet programmed | |
233 | * @DFLL_TUNE_LOW: DFLL in the low-voltage range (or open-loop mode) | |
234 | * | |
235 | * Some DFLL tuning parameters may need to change depending on the | |
236 | * DVCO's voltage; these states represent the ranges that the driver | |
237 | * supports. These are software states; these values are never | |
238 | * written into registers. | |
239 | */ | |
240 | enum dfll_tune_range { | |
241 | DFLL_TUNE_UNINITIALIZED = 0, | |
242 | DFLL_TUNE_LOW = 1, | |
243 | }; | |
244 | ||
c4fe70ad TT |
245 | /** |
246 | * struct dfll_rate_req - target DFLL rate request data | |
247 | * @rate: target frequency, after the postscaling | |
248 | * @dvco_target_rate: target frequency, after the postscaling | |
249 | * @lut_index: LUT index at which voltage the dvco_target_rate will be reached | |
250 | * @mult_bits: value to program to the MULT bits of the DFLL_FREQ_REQ register | |
251 | * @scale_bits: value to program to the SCALE bits of the DFLL_FREQ_REQ register | |
252 | */ | |
253 | struct dfll_rate_req { | |
254 | unsigned long rate; | |
255 | unsigned long dvco_target_rate; | |
256 | int lut_index; | |
257 | u8 mult_bits; | |
258 | u8 scale_bits; | |
259 | }; | |
260 | ||
d8d7a08f TT |
261 | struct tegra_dfll { |
262 | struct device *dev; | |
263 | struct tegra_dfll_soc_data *soc; | |
264 | ||
265 | void __iomem *base; | |
266 | void __iomem *i2c_base; | |
267 | void __iomem *i2c_controller_base; | |
268 | void __iomem *lut_base; | |
269 | ||
270 | struct regulator *vdd_reg; | |
271 | struct clk *soc_clk; | |
272 | struct clk *ref_clk; | |
273 | struct clk *i2c_clk; | |
274 | struct clk *dfll_clk; | |
275 | struct reset_control *dvco_rst; | |
276 | unsigned long ref_rate; | |
277 | unsigned long i2c_clk_rate; | |
278 | unsigned long dvco_rate_min; | |
279 | ||
280 | enum dfll_ctrl_mode mode; | |
281 | enum dfll_tune_range tune_range; | |
282 | struct dentry *debugfs_dir; | |
283 | struct clk_hw dfll_clk_hw; | |
284 | const char *output_clock_name; | |
c4fe70ad TT |
285 | struct dfll_rate_req last_req; |
286 | unsigned long last_unrounded_rate; | |
d8d7a08f TT |
287 | |
288 | /* Parameters from DT */ | |
289 | u32 droop_ctrl; | |
c4fe70ad TT |
290 | u32 sample_rate; |
291 | u32 force_mode; | |
292 | u32 cf; | |
293 | u32 ci; | |
294 | u32 cg; | |
295 | bool cg_scale; | |
296 | ||
297 | /* I2C interface parameters */ | |
298 | u32 i2c_fs_rate; | |
299 | u32 i2c_reg; | |
300 | u32 i2c_slave_addr; | |
301 | ||
302 | /* i2c_lut array entries are regulator framework selectors */ | |
303 | unsigned i2c_lut[MAX_DFLL_VOLTAGES]; | |
304 | int i2c_lut_size; | |
305 | u8 lut_min, lut_max, lut_safe; | |
d8d7a08f TT |
306 | }; |
307 | ||
308 | #define clk_hw_to_dfll(_hw) container_of(_hw, struct tegra_dfll, dfll_clk_hw) | |
309 | ||
310 | /* mode_name: map numeric DFLL modes to names for friendly console messages */ | |
311 | static const char * const mode_name[] = { | |
312 | [DFLL_UNINITIALIZED] = "uninitialized", | |
313 | [DFLL_DISABLED] = "disabled", | |
314 | [DFLL_OPEN_LOOP] = "open_loop", | |
c4fe70ad | 315 | [DFLL_CLOSED_LOOP] = "closed_loop", |
d8d7a08f TT |
316 | }; |
317 | ||
318 | /* | |
319 | * Register accessors | |
320 | */ | |
321 | ||
322 | static inline u32 dfll_readl(struct tegra_dfll *td, u32 offs) | |
323 | { | |
324 | return __raw_readl(td->base + offs); | |
325 | } | |
326 | ||
327 | static inline void dfll_writel(struct tegra_dfll *td, u32 val, u32 offs) | |
328 | { | |
329 | WARN_ON(offs >= DFLL_I2C_CFG); | |
330 | __raw_writel(val, td->base + offs); | |
331 | } | |
332 | ||
333 | static inline void dfll_wmb(struct tegra_dfll *td) | |
334 | { | |
335 | dfll_readl(td, DFLL_CTRL); | |
336 | } | |
337 | ||
338 | /* I2C output control registers - for addresses above DFLL_I2C_CFG */ | |
339 | ||
340 | static inline u32 dfll_i2c_readl(struct tegra_dfll *td, u32 offs) | |
341 | { | |
342 | return __raw_readl(td->i2c_base + offs); | |
343 | } | |
344 | ||
345 | static inline void dfll_i2c_writel(struct tegra_dfll *td, u32 val, u32 offs) | |
346 | { | |
347 | __raw_writel(val, td->i2c_base + offs); | |
348 | } | |
349 | ||
350 | static inline void dfll_i2c_wmb(struct tegra_dfll *td) | |
351 | { | |
352 | dfll_i2c_readl(td, DFLL_I2C_CFG); | |
353 | } | |
354 | ||
355 | /** | |
356 | * dfll_is_running - is the DFLL currently generating a clock? | |
357 | * @td: DFLL instance | |
358 | * | |
359 | * If the DFLL is currently generating an output clock signal, return | |
360 | * true; otherwise return false. | |
361 | */ | |
362 | static bool dfll_is_running(struct tegra_dfll *td) | |
363 | { | |
364 | return td->mode >= DFLL_OPEN_LOOP; | |
365 | } | |
366 | ||
367 | /* | |
368 | * Runtime PM suspend/resume callbacks | |
369 | */ | |
370 | ||
371 | /** | |
372 | * tegra_dfll_runtime_resume - enable all clocks needed by the DFLL | |
373 | * @dev: DFLL device * | |
374 | * | |
375 | * Enable all clocks needed by the DFLL. Assumes that clk_prepare() | |
376 | * has already been called on all the clocks. | |
377 | * | |
378 | * XXX Should also handle context restore when returning from off. | |
379 | */ | |
380 | int tegra_dfll_runtime_resume(struct device *dev) | |
381 | { | |
382 | struct tegra_dfll *td = dev_get_drvdata(dev); | |
383 | int ret; | |
384 | ||
385 | ret = clk_enable(td->ref_clk); | |
386 | if (ret) { | |
387 | dev_err(dev, "could not enable ref clock: %d\n", ret); | |
388 | return ret; | |
389 | } | |
390 | ||
391 | ret = clk_enable(td->soc_clk); | |
392 | if (ret) { | |
393 | dev_err(dev, "could not enable register clock: %d\n", ret); | |
394 | clk_disable(td->ref_clk); | |
395 | return ret; | |
396 | } | |
397 | ||
398 | ret = clk_enable(td->i2c_clk); | |
399 | if (ret) { | |
400 | dev_err(dev, "could not enable i2c clock: %d\n", ret); | |
401 | clk_disable(td->soc_clk); | |
402 | clk_disable(td->ref_clk); | |
403 | return ret; | |
404 | } | |
405 | ||
406 | return 0; | |
407 | } | |
408 | EXPORT_SYMBOL(tegra_dfll_runtime_resume); | |
409 | ||
410 | /** | |
411 | * tegra_dfll_runtime_suspend - disable all clocks needed by the DFLL | |
412 | * @dev: DFLL device * | |
413 | * | |
414 | * Disable all clocks needed by the DFLL. Assumes that other code | |
415 | * will later call clk_unprepare(). | |
416 | */ | |
417 | int tegra_dfll_runtime_suspend(struct device *dev) | |
418 | { | |
419 | struct tegra_dfll *td = dev_get_drvdata(dev); | |
420 | ||
421 | clk_disable(td->ref_clk); | |
422 | clk_disable(td->soc_clk); | |
423 | clk_disable(td->i2c_clk); | |
424 | ||
425 | return 0; | |
426 | } | |
427 | EXPORT_SYMBOL(tegra_dfll_runtime_suspend); | |
428 | ||
429 | /* | |
430 | * DFLL tuning operations (per-voltage-range tuning settings) | |
431 | */ | |
432 | ||
433 | /** | |
434 | * dfll_tune_low - tune to DFLL and CPU settings valid for any voltage | |
435 | * @td: DFLL instance | |
436 | * | |
437 | * Tune the DFLL oscillator parameters and the CPU clock shaper for | |
438 | * the low-voltage range. These settings are valid for any voltage, | |
439 | * but may not be optimal. | |
440 | */ | |
441 | static void dfll_tune_low(struct tegra_dfll *td) | |
442 | { | |
443 | td->tune_range = DFLL_TUNE_LOW; | |
444 | ||
445 | dfll_writel(td, td->soc->tune0_low, DFLL_TUNE0); | |
446 | dfll_writel(td, td->soc->tune1, DFLL_TUNE1); | |
447 | dfll_wmb(td); | |
448 | ||
449 | if (td->soc->set_clock_trimmers_low) | |
450 | td->soc->set_clock_trimmers_low(); | |
451 | } | |
452 | ||
453 | /* | |
454 | * Output clock scaler helpers | |
455 | */ | |
456 | ||
457 | /** | |
458 | * dfll_scale_dvco_rate - calculate scaled rate from the DVCO rate | |
459 | * @scale_bits: clock scaler value (bits in the DFLL_FREQ_REQ_SCALE field) | |
460 | * @dvco_rate: the DVCO rate | |
461 | * | |
462 | * Apply the same scaling formula that the DFLL hardware uses to scale | |
463 | * the DVCO rate. | |
464 | */ | |
465 | static unsigned long dfll_scale_dvco_rate(int scale_bits, | |
466 | unsigned long dvco_rate) | |
467 | { | |
468 | return (u64)dvco_rate * (scale_bits + 1) / DFLL_FREQ_REQ_SCALE_MAX; | |
469 | } | |
470 | ||
d8d7a08f TT |
471 | /* |
472 | * DFLL mode switching | |
473 | */ | |
474 | ||
475 | /** | |
476 | * dfll_set_mode - change the DFLL control mode | |
477 | * @td: DFLL instance | |
478 | * @mode: DFLL control mode (see enum dfll_ctrl_mode) | |
479 | * | |
480 | * Change the DFLL's operating mode between disabled, open-loop mode, | |
481 | * and closed-loop mode, or vice versa. | |
482 | */ | |
483 | static void dfll_set_mode(struct tegra_dfll *td, | |
484 | enum dfll_ctrl_mode mode) | |
485 | { | |
486 | td->mode = mode; | |
487 | dfll_writel(td, mode - 1, DFLL_CTRL); | |
488 | dfll_wmb(td); | |
489 | } | |
490 | ||
c4fe70ad TT |
491 | /* |
492 | * DFLL-to-I2C controller interface | |
493 | */ | |
494 | ||
495 | /** | |
496 | * dfll_i2c_set_output_enabled - enable/disable I2C PMIC voltage requests | |
497 | * @td: DFLL instance | |
498 | * @enable: whether to enable or disable the I2C voltage requests | |
499 | * | |
500 | * Set the master enable control for I2C control value updates. If disabled, | |
501 | * then I2C control messages are inhibited, regardless of the DFLL mode. | |
502 | */ | |
503 | static int dfll_i2c_set_output_enabled(struct tegra_dfll *td, bool enable) | |
504 | { | |
505 | u32 val; | |
506 | ||
507 | val = dfll_i2c_readl(td, DFLL_OUTPUT_CFG); | |
508 | ||
509 | if (enable) | |
510 | val |= DFLL_OUTPUT_CFG_I2C_ENABLE; | |
511 | else | |
512 | val &= ~DFLL_OUTPUT_CFG_I2C_ENABLE; | |
513 | ||
514 | dfll_i2c_writel(td, val, DFLL_OUTPUT_CFG); | |
515 | dfll_i2c_wmb(td); | |
516 | ||
517 | return 0; | |
518 | } | |
519 | ||
520 | /** | |
521 | * dfll_load_lut - load the voltage lookup table | |
522 | * @td: struct tegra_dfll * | |
523 | * | |
524 | * Load the voltage-to-PMIC register value lookup table into the DFLL | |
525 | * IP block memory. Look-up tables can be loaded at any time. | |
526 | */ | |
527 | static void dfll_load_i2c_lut(struct tegra_dfll *td) | |
528 | { | |
529 | int i, lut_index; | |
530 | u32 val; | |
531 | ||
532 | for (i = 0; i < MAX_DFLL_VOLTAGES; i++) { | |
533 | if (i < td->lut_min) | |
534 | lut_index = td->lut_min; | |
535 | else if (i > td->lut_max) | |
536 | lut_index = td->lut_max; | |
537 | else | |
538 | lut_index = i; | |
539 | ||
c5a132a8 | 540 | val = regulator_list_hardware_vsel(td->vdd_reg, |
c4fe70ad TT |
541 | td->i2c_lut[lut_index]); |
542 | __raw_writel(val, td->lut_base + i * 4); | |
543 | } | |
544 | ||
545 | dfll_i2c_wmb(td); | |
546 | } | |
547 | ||
548 | /** | |
549 | * dfll_init_i2c_if - set up the DFLL's DFLL-I2C interface | |
550 | * @td: DFLL instance | |
551 | * | |
552 | * During DFLL driver initialization, program the DFLL-I2C interface | |
553 | * with the PMU slave address, vdd register offset, and transfer mode. | |
554 | * This data is used by the DFLL to automatically construct I2C | |
555 | * voltage-set commands, which are then passed to the DFLL's internal | |
556 | * I2C controller. | |
557 | */ | |
558 | static void dfll_init_i2c_if(struct tegra_dfll *td) | |
559 | { | |
560 | u32 val; | |
561 | ||
562 | if (td->i2c_slave_addr > 0x7f) { | |
563 | val = td->i2c_slave_addr << DFLL_I2C_CFG_SLAVE_ADDR_SHIFT_10BIT; | |
564 | val |= DFLL_I2C_CFG_SLAVE_ADDR_10; | |
565 | } else { | |
566 | val = td->i2c_slave_addr << DFLL_I2C_CFG_SLAVE_ADDR_SHIFT_7BIT; | |
567 | } | |
568 | val |= DFLL_I2C_CFG_SIZE_MASK; | |
569 | val |= DFLL_I2C_CFG_ARB_ENABLE; | |
570 | dfll_i2c_writel(td, val, DFLL_I2C_CFG); | |
571 | ||
572 | dfll_i2c_writel(td, td->i2c_reg, DFLL_I2C_VDD_REG_ADDR); | |
573 | ||
574 | val = DIV_ROUND_UP(td->i2c_clk_rate, td->i2c_fs_rate * 8); | |
575 | BUG_ON(!val || (val > DFLL_I2C_CLK_DIVISOR_MASK)); | |
576 | val = (val - 1) << DFLL_I2C_CLK_DIVISOR_FS_SHIFT; | |
577 | ||
578 | /* default hs divisor just in case */ | |
579 | val |= 1 << DFLL_I2C_CLK_DIVISOR_HS_SHIFT; | |
580 | __raw_writel(val, td->i2c_controller_base + DFLL_I2C_CLK_DIVISOR); | |
581 | dfll_i2c_wmb(td); | |
582 | } | |
583 | ||
584 | /** | |
585 | * dfll_init_out_if - prepare DFLL-to-PMIC interface | |
586 | * @td: DFLL instance | |
587 | * | |
588 | * During DFLL driver initialization or resume from context loss, | |
589 | * disable the I2C command output to the PMIC, set safe voltage and | |
590 | * output limits, and disable and clear limit interrupts. | |
591 | */ | |
592 | static void dfll_init_out_if(struct tegra_dfll *td) | |
593 | { | |
594 | u32 val; | |
595 | ||
596 | td->lut_min = 0; | |
597 | td->lut_max = td->i2c_lut_size - 1; | |
598 | td->lut_safe = td->lut_min + 1; | |
599 | ||
600 | dfll_i2c_writel(td, 0, DFLL_OUTPUT_CFG); | |
601 | val = (td->lut_safe << DFLL_OUTPUT_CFG_SAFE_SHIFT) | | |
602 | (td->lut_max << DFLL_OUTPUT_CFG_MAX_SHIFT) | | |
603 | (td->lut_min << DFLL_OUTPUT_CFG_MIN_SHIFT); | |
604 | dfll_i2c_writel(td, val, DFLL_OUTPUT_CFG); | |
605 | dfll_i2c_wmb(td); | |
606 | ||
607 | dfll_writel(td, 0, DFLL_OUTPUT_FORCE); | |
608 | dfll_i2c_writel(td, 0, DFLL_INTR_EN); | |
609 | dfll_i2c_writel(td, DFLL_INTR_MAX_MASK | DFLL_INTR_MIN_MASK, | |
610 | DFLL_INTR_STS); | |
611 | ||
612 | dfll_load_i2c_lut(td); | |
613 | dfll_init_i2c_if(td); | |
614 | } | |
615 | ||
616 | /* | |
617 | * Set/get the DFLL's targeted output clock rate | |
618 | */ | |
619 | ||
620 | /** | |
621 | * find_lut_index_for_rate - determine I2C LUT index for given DFLL rate | |
622 | * @td: DFLL instance | |
623 | * @rate: clock rate | |
624 | * | |
625 | * Determines the index of a I2C LUT entry for a voltage that approximately | |
626 | * produces the given DFLL clock rate. This is used when forcing a value | |
627 | * to the integrator during rate changes. Returns -ENOENT if a suitable | |
628 | * LUT index is not found. | |
629 | */ | |
630 | static int find_lut_index_for_rate(struct tegra_dfll *td, unsigned long rate) | |
631 | { | |
632 | struct dev_pm_opp *opp; | |
633 | int i, uv; | |
634 | ||
e1595d89 TR |
635 | rcu_read_lock(); |
636 | ||
62a8a094 | 637 | opp = dev_pm_opp_find_freq_ceil(td->soc->dev, &rate); |
e1595d89 TR |
638 | if (IS_ERR(opp)) { |
639 | rcu_read_unlock(); | |
c4fe70ad | 640 | return PTR_ERR(opp); |
e1595d89 | 641 | } |
c4fe70ad TT |
642 | uv = dev_pm_opp_get_voltage(opp); |
643 | ||
e1595d89 TR |
644 | rcu_read_unlock(); |
645 | ||
c4fe70ad TT |
646 | for (i = 0; i < td->i2c_lut_size; i++) { |
647 | if (regulator_list_voltage(td->vdd_reg, td->i2c_lut[i]) == uv) | |
648 | return i; | |
649 | } | |
650 | ||
651 | return -ENOENT; | |
652 | } | |
653 | ||
654 | /** | |
655 | * dfll_calculate_rate_request - calculate DFLL parameters for a given rate | |
656 | * @td: DFLL instance | |
657 | * @req: DFLL-rate-request structure | |
658 | * @rate: the desired DFLL rate | |
659 | * | |
660 | * Populate the DFLL-rate-request record @req fields with the scale_bits | |
661 | * and mult_bits fields, based on the target input rate. Returns 0 upon | |
662 | * success, or -EINVAL if the requested rate in req->rate is too high | |
663 | * or low for the DFLL to generate. | |
664 | */ | |
665 | static int dfll_calculate_rate_request(struct tegra_dfll *td, | |
666 | struct dfll_rate_req *req, | |
667 | unsigned long rate) | |
668 | { | |
669 | u32 val; | |
670 | ||
671 | /* | |
672 | * If requested rate is below the minimum DVCO rate, active the scaler. | |
673 | * In the future the DVCO minimum voltage should be selected based on | |
674 | * chip temperature and the actual minimum rate should be calibrated | |
675 | * at runtime. | |
676 | */ | |
677 | req->scale_bits = DFLL_FREQ_REQ_SCALE_MAX - 1; | |
678 | if (rate < td->dvco_rate_min) { | |
679 | int scale; | |
680 | ||
681 | scale = DIV_ROUND_CLOSEST(rate / 1000 * DFLL_FREQ_REQ_SCALE_MAX, | |
682 | td->dvco_rate_min / 1000); | |
683 | if (!scale) { | |
684 | dev_err(td->dev, "%s: Rate %lu is too low\n", | |
685 | __func__, rate); | |
686 | return -EINVAL; | |
687 | } | |
688 | req->scale_bits = scale - 1; | |
689 | rate = td->dvco_rate_min; | |
690 | } | |
691 | ||
692 | /* Convert requested rate into frequency request and scale settings */ | |
693 | val = DVCO_RATE_TO_MULT(rate, td->ref_rate); | |
694 | if (val > FREQ_MAX) { | |
695 | dev_err(td->dev, "%s: Rate %lu is above dfll range\n", | |
696 | __func__, rate); | |
697 | return -EINVAL; | |
698 | } | |
699 | req->mult_bits = val; | |
700 | req->dvco_target_rate = MULT_TO_DVCO_RATE(req->mult_bits, td->ref_rate); | |
701 | req->rate = dfll_scale_dvco_rate(req->scale_bits, | |
702 | req->dvco_target_rate); | |
703 | req->lut_index = find_lut_index_for_rate(td, req->dvco_target_rate); | |
704 | if (req->lut_index < 0) | |
705 | return req->lut_index; | |
706 | ||
707 | return 0; | |
708 | } | |
709 | ||
710 | /** | |
711 | * dfll_set_frequency_request - start the frequency change operation | |
712 | * @td: DFLL instance | |
713 | * @req: rate request structure | |
714 | * | |
715 | * Tell the DFLL to try to change its output frequency to the | |
716 | * frequency represented by @req. DFLL must be in closed-loop mode. | |
717 | */ | |
718 | static void dfll_set_frequency_request(struct tegra_dfll *td, | |
719 | struct dfll_rate_req *req) | |
720 | { | |
721 | u32 val = 0; | |
722 | int force_val; | |
723 | int coef = 128; /* FIXME: td->cg_scale? */; | |
724 | ||
725 | force_val = (req->lut_index - td->lut_safe) * coef / td->cg; | |
726 | force_val = clamp(force_val, FORCE_MIN, FORCE_MAX); | |
727 | ||
728 | val |= req->mult_bits << DFLL_FREQ_REQ_MULT_SHIFT; | |
729 | val |= req->scale_bits << DFLL_FREQ_REQ_SCALE_SHIFT; | |
730 | val |= ((u32)force_val << DFLL_FREQ_REQ_FORCE_SHIFT) & | |
731 | DFLL_FREQ_REQ_FORCE_MASK; | |
732 | val |= DFLL_FREQ_REQ_FREQ_VALID | DFLL_FREQ_REQ_FORCE_ENABLE; | |
733 | ||
734 | dfll_writel(td, val, DFLL_FREQ_REQ); | |
735 | dfll_wmb(td); | |
736 | } | |
737 | ||
738 | /** | |
739 | * tegra_dfll_request_rate - set the next rate for the DFLL to tune to | |
740 | * @td: DFLL instance | |
741 | * @rate: clock rate to target | |
742 | * | |
743 | * Convert the requested clock rate @rate into the DFLL control logic | |
744 | * settings. In closed-loop mode, update new settings immediately to | |
745 | * adjust DFLL output rate accordingly. Otherwise, just save them | |
746 | * until the next switch to closed loop. Returns 0 upon success, | |
747 | * -EPERM if the DFLL driver has not yet been initialized, or -EINVAL | |
748 | * if @rate is outside the DFLL's tunable range. | |
749 | */ | |
750 | static int dfll_request_rate(struct tegra_dfll *td, unsigned long rate) | |
751 | { | |
752 | int ret; | |
753 | struct dfll_rate_req req; | |
754 | ||
755 | if (td->mode == DFLL_UNINITIALIZED) { | |
756 | dev_err(td->dev, "%s: Cannot set DFLL rate in %s mode\n", | |
757 | __func__, mode_name[td->mode]); | |
758 | return -EPERM; | |
759 | } | |
760 | ||
761 | ret = dfll_calculate_rate_request(td, &req, rate); | |
762 | if (ret) | |
763 | return ret; | |
764 | ||
765 | td->last_unrounded_rate = rate; | |
766 | td->last_req = req; | |
767 | ||
768 | if (td->mode == DFLL_CLOSED_LOOP) | |
769 | dfll_set_frequency_request(td, &td->last_req); | |
770 | ||
771 | return 0; | |
772 | } | |
773 | ||
d8d7a08f TT |
774 | /* |
775 | * DFLL enable/disable & open-loop <-> closed-loop transitions | |
776 | */ | |
777 | ||
778 | /** | |
779 | * dfll_disable - switch from open-loop mode to disabled mode | |
780 | * @td: DFLL instance | |
781 | * | |
782 | * Switch from OPEN_LOOP state to DISABLED state. Returns 0 upon success | |
783 | * or -EPERM if the DFLL is not currently in open-loop mode. | |
784 | */ | |
785 | static int dfll_disable(struct tegra_dfll *td) | |
786 | { | |
787 | if (td->mode != DFLL_OPEN_LOOP) { | |
788 | dev_err(td->dev, "cannot disable DFLL in %s mode\n", | |
789 | mode_name[td->mode]); | |
790 | return -EINVAL; | |
791 | } | |
792 | ||
793 | dfll_set_mode(td, DFLL_DISABLED); | |
794 | pm_runtime_put_sync(td->dev); | |
795 | ||
796 | return 0; | |
797 | } | |
798 | ||
799 | /** | |
800 | * dfll_enable - switch a disabled DFLL to open-loop mode | |
801 | * @td: DFLL instance | |
802 | * | |
803 | * Switch from DISABLED state to OPEN_LOOP state. Returns 0 upon success | |
804 | * or -EPERM if the DFLL is not currently disabled. | |
805 | */ | |
806 | static int dfll_enable(struct tegra_dfll *td) | |
807 | { | |
808 | if (td->mode != DFLL_DISABLED) { | |
809 | dev_err(td->dev, "cannot enable DFLL in %s mode\n", | |
810 | mode_name[td->mode]); | |
811 | return -EPERM; | |
812 | } | |
813 | ||
814 | pm_runtime_get_sync(td->dev); | |
815 | dfll_set_mode(td, DFLL_OPEN_LOOP); | |
816 | ||
817 | return 0; | |
818 | } | |
819 | ||
820 | /** | |
821 | * dfll_set_open_loop_config - prepare to switch to open-loop mode | |
822 | * @td: DFLL instance | |
823 | * | |
824 | * Prepare to switch the DFLL to open-loop mode. This switches the | |
825 | * DFLL to the low-voltage tuning range, ensures that I2C output | |
826 | * forcing is disabled, and disables the output clock rate scaler. | |
827 | * The DFLL's low-voltage tuning range parameters must be | |
828 | * characterized to keep the downstream device stable at any DVCO | |
829 | * input voltage. No return value. | |
830 | */ | |
831 | static void dfll_set_open_loop_config(struct tegra_dfll *td) | |
832 | { | |
833 | u32 val; | |
834 | ||
835 | /* always tune low (safe) in open loop */ | |
836 | if (td->tune_range != DFLL_TUNE_LOW) | |
837 | dfll_tune_low(td); | |
838 | ||
839 | val = dfll_readl(td, DFLL_FREQ_REQ); | |
840 | val |= DFLL_FREQ_REQ_SCALE_MASK; | |
841 | val &= ~DFLL_FREQ_REQ_FORCE_ENABLE; | |
842 | dfll_writel(td, val, DFLL_FREQ_REQ); | |
843 | dfll_wmb(td); | |
844 | } | |
845 | ||
c4fe70ad TT |
846 | /** |
847 | * tegra_dfll_lock - switch from open-loop to closed-loop mode | |
848 | * @td: DFLL instance | |
849 | * | |
850 | * Switch from OPEN_LOOP state to CLOSED_LOOP state. Returns 0 upon success, | |
851 | * -EINVAL if the DFLL's target rate hasn't been set yet, or -EPERM if the | |
852 | * DFLL is not currently in open-loop mode. | |
853 | */ | |
854 | static int dfll_lock(struct tegra_dfll *td) | |
855 | { | |
856 | struct dfll_rate_req *req = &td->last_req; | |
857 | ||
858 | switch (td->mode) { | |
859 | case DFLL_CLOSED_LOOP: | |
860 | return 0; | |
861 | ||
862 | case DFLL_OPEN_LOOP: | |
863 | if (req->rate == 0) { | |
864 | dev_err(td->dev, "%s: Cannot lock DFLL at rate 0\n", | |
865 | __func__); | |
866 | return -EINVAL; | |
867 | } | |
868 | ||
869 | dfll_i2c_set_output_enabled(td, true); | |
870 | dfll_set_mode(td, DFLL_CLOSED_LOOP); | |
871 | dfll_set_frequency_request(td, req); | |
872 | return 0; | |
873 | ||
874 | default: | |
875 | BUG_ON(td->mode > DFLL_CLOSED_LOOP); | |
876 | dev_err(td->dev, "%s: Cannot lock DFLL in %s mode\n", | |
877 | __func__, mode_name[td->mode]); | |
878 | return -EPERM; | |
879 | } | |
880 | } | |
881 | ||
882 | /** | |
883 | * tegra_dfll_unlock - switch from closed-loop to open-loop mode | |
884 | * @td: DFLL instance | |
885 | * | |
886 | * Switch from CLOSED_LOOP state to OPEN_LOOP state. Returns 0 upon success, | |
887 | * or -EPERM if the DFLL is not currently in open-loop mode. | |
888 | */ | |
889 | static int dfll_unlock(struct tegra_dfll *td) | |
890 | { | |
891 | switch (td->mode) { | |
892 | case DFLL_CLOSED_LOOP: | |
893 | dfll_set_open_loop_config(td); | |
894 | dfll_set_mode(td, DFLL_OPEN_LOOP); | |
895 | dfll_i2c_set_output_enabled(td, false); | |
896 | return 0; | |
897 | ||
898 | case DFLL_OPEN_LOOP: | |
899 | return 0; | |
900 | ||
901 | default: | |
902 | BUG_ON(td->mode > DFLL_CLOSED_LOOP); | |
903 | dev_err(td->dev, "%s: Cannot unlock DFLL in %s mode\n", | |
904 | __func__, mode_name[td->mode]); | |
905 | return -EPERM; | |
906 | } | |
907 | } | |
908 | ||
d8d7a08f TT |
909 | /* |
910 | * Clock framework integration | |
c4fe70ad TT |
911 | * |
912 | * When the DFLL is being controlled by the CCF, always enter closed loop | |
913 | * mode when the clk is enabled. This requires that a DFLL rate request | |
914 | * has been set beforehand, which implies that a clk_set_rate() call is | |
915 | * always required before a clk_enable(). | |
d8d7a08f TT |
916 | */ |
917 | ||
918 | static int dfll_clk_is_enabled(struct clk_hw *hw) | |
919 | { | |
920 | struct tegra_dfll *td = clk_hw_to_dfll(hw); | |
921 | ||
922 | return dfll_is_running(td); | |
923 | } | |
924 | ||
925 | static int dfll_clk_enable(struct clk_hw *hw) | |
926 | { | |
927 | struct tegra_dfll *td = clk_hw_to_dfll(hw); | |
c4fe70ad TT |
928 | int ret; |
929 | ||
930 | ret = dfll_enable(td); | |
931 | if (ret) | |
932 | return ret; | |
d8d7a08f | 933 | |
c4fe70ad TT |
934 | ret = dfll_lock(td); |
935 | if (ret) | |
936 | dfll_disable(td); | |
937 | ||
938 | return ret; | |
d8d7a08f TT |
939 | } |
940 | ||
941 | static void dfll_clk_disable(struct clk_hw *hw) | |
c4fe70ad TT |
942 | { |
943 | struct tegra_dfll *td = clk_hw_to_dfll(hw); | |
944 | int ret; | |
945 | ||
946 | ret = dfll_unlock(td); | |
947 | if (!ret) | |
948 | dfll_disable(td); | |
949 | } | |
950 | ||
951 | static unsigned long dfll_clk_recalc_rate(struct clk_hw *hw, | |
952 | unsigned long parent_rate) | |
953 | { | |
954 | struct tegra_dfll *td = clk_hw_to_dfll(hw); | |
955 | ||
956 | return td->last_unrounded_rate; | |
957 | } | |
958 | ||
10d9be6e MP |
959 | /* Must use determine_rate since it allows for rates exceeding 2^31-1 */ |
960 | static int dfll_clk_determine_rate(struct clk_hw *hw, | |
961 | struct clk_rate_request *clk_req) | |
c4fe70ad TT |
962 | { |
963 | struct tegra_dfll *td = clk_hw_to_dfll(hw); | |
964 | struct dfll_rate_req req; | |
965 | int ret; | |
966 | ||
10d9be6e | 967 | ret = dfll_calculate_rate_request(td, &req, clk_req->rate); |
c4fe70ad TT |
968 | if (ret) |
969 | return ret; | |
970 | ||
971 | /* | |
10d9be6e | 972 | * Don't set the rounded rate, since it doesn't really matter as |
c4fe70ad TT |
973 | * the output rate will be voltage controlled anyway, and cpufreq |
974 | * freaks out if any rounding happens. | |
975 | */ | |
10d9be6e MP |
976 | |
977 | return 0; | |
c4fe70ad TT |
978 | } |
979 | ||
980 | static int dfll_clk_set_rate(struct clk_hw *hw, unsigned long rate, | |
981 | unsigned long parent_rate) | |
d8d7a08f TT |
982 | { |
983 | struct tegra_dfll *td = clk_hw_to_dfll(hw); | |
984 | ||
c4fe70ad | 985 | return dfll_request_rate(td, rate); |
d8d7a08f TT |
986 | } |
987 | ||
988 | static const struct clk_ops dfll_clk_ops = { | |
989 | .is_enabled = dfll_clk_is_enabled, | |
990 | .enable = dfll_clk_enable, | |
991 | .disable = dfll_clk_disable, | |
c4fe70ad | 992 | .recalc_rate = dfll_clk_recalc_rate, |
10d9be6e | 993 | .determine_rate = dfll_clk_determine_rate, |
c4fe70ad | 994 | .set_rate = dfll_clk_set_rate, |
d8d7a08f TT |
995 | }; |
996 | ||
997 | static struct clk_init_data dfll_clk_init_data = { | |
998 | .flags = CLK_IS_ROOT, | |
999 | .ops = &dfll_clk_ops, | |
1000 | .num_parents = 0, | |
1001 | }; | |
1002 | ||
1003 | /** | |
1004 | * dfll_register_clk - register the DFLL output clock with the clock framework | |
1005 | * @td: DFLL instance | |
1006 | * | |
1007 | * Register the DFLL's output clock with the Linux clock framework and register | |
1008 | * the DFLL driver as an OF clock provider. Returns 0 upon success or -EINVAL | |
1009 | * or -ENOMEM upon failure. | |
1010 | */ | |
1011 | static int dfll_register_clk(struct tegra_dfll *td) | |
1012 | { | |
1013 | int ret; | |
1014 | ||
1015 | dfll_clk_init_data.name = td->output_clock_name; | |
1016 | td->dfll_clk_hw.init = &dfll_clk_init_data; | |
1017 | ||
1018 | td->dfll_clk = clk_register(td->dev, &td->dfll_clk_hw); | |
1019 | if (IS_ERR(td->dfll_clk)) { | |
1020 | dev_err(td->dev, "DFLL clock registration error\n"); | |
1021 | return -EINVAL; | |
1022 | } | |
1023 | ||
1024 | ret = of_clk_add_provider(td->dev->of_node, of_clk_src_simple_get, | |
1025 | td->dfll_clk); | |
1026 | if (ret) { | |
1027 | dev_err(td->dev, "of_clk_add_provider() failed\n"); | |
1028 | ||
1029 | clk_unregister(td->dfll_clk); | |
1030 | return ret; | |
1031 | } | |
1032 | ||
1033 | return 0; | |
1034 | } | |
1035 | ||
1036 | /** | |
1037 | * dfll_unregister_clk - unregister the DFLL output clock | |
1038 | * @td: DFLL instance | |
1039 | * | |
1040 | * Unregister the DFLL's output clock from the Linux clock framework | |
1041 | * and from clkdev. No return value. | |
1042 | */ | |
1043 | static void dfll_unregister_clk(struct tegra_dfll *td) | |
1044 | { | |
1045 | of_clk_del_provider(td->dev->of_node); | |
1046 | clk_unregister(td->dfll_clk); | |
1047 | td->dfll_clk = NULL; | |
1048 | } | |
1049 | ||
1050 | /* | |
1051 | * Debugfs interface | |
1052 | */ | |
1053 | ||
1054 | #ifdef CONFIG_DEBUG_FS | |
4182b8d4 TR |
1055 | /* |
1056 | * Monitor control | |
1057 | */ | |
1058 | ||
1059 | /** | |
1060 | * dfll_calc_monitored_rate - convert DFLL_MONITOR_DATA_VAL rate into real freq | |
1061 | * @monitor_data: value read from the DFLL_MONITOR_DATA_VAL bitfield | |
1062 | * @ref_rate: DFLL reference clock rate | |
1063 | * | |
1064 | * Convert @monitor_data from DFLL_MONITOR_DATA_VAL units into cycles | |
1065 | * per second. Returns the converted value. | |
1066 | */ | |
1067 | static u64 dfll_calc_monitored_rate(u32 monitor_data, | |
1068 | unsigned long ref_rate) | |
1069 | { | |
1070 | return monitor_data * (ref_rate / REF_CLK_CYC_PER_DVCO_SAMPLE); | |
1071 | } | |
1072 | ||
1073 | /** | |
1074 | * dfll_read_monitor_rate - return the DFLL's output rate from internal monitor | |
1075 | * @td: DFLL instance | |
1076 | * | |
1077 | * If the DFLL is enabled, return the last rate reported by the DFLL's | |
1078 | * internal monitoring hardware. This works in both open-loop and | |
1079 | * closed-loop mode, and takes the output scaler setting into account. | |
1080 | * Assumes that the monitor was programmed to monitor frequency before | |
1081 | * the sample period started. If the driver believes that the DFLL is | |
1082 | * currently uninitialized or disabled, it will return 0, since | |
1083 | * otherwise the DFLL monitor data register will return the last | |
1084 | * measured rate from when the DFLL was active. | |
1085 | */ | |
1086 | static u64 dfll_read_monitor_rate(struct tegra_dfll *td) | |
1087 | { | |
1088 | u32 v, s; | |
1089 | u64 pre_scaler_rate, post_scaler_rate; | |
1090 | ||
1091 | if (!dfll_is_running(td)) | |
1092 | return 0; | |
1093 | ||
1094 | v = dfll_readl(td, DFLL_MONITOR_DATA); | |
1095 | v = (v & DFLL_MONITOR_DATA_VAL_MASK) >> DFLL_MONITOR_DATA_VAL_SHIFT; | |
1096 | pre_scaler_rate = dfll_calc_monitored_rate(v, td->ref_rate); | |
1097 | ||
1098 | s = dfll_readl(td, DFLL_FREQ_REQ); | |
1099 | s = (s & DFLL_FREQ_REQ_SCALE_MASK) >> DFLL_FREQ_REQ_SCALE_SHIFT; | |
1100 | post_scaler_rate = dfll_scale_dvco_rate(s, pre_scaler_rate); | |
1101 | ||
1102 | return post_scaler_rate; | |
1103 | } | |
d8d7a08f TT |
1104 | |
1105 | static int attr_enable_get(void *data, u64 *val) | |
1106 | { | |
1107 | struct tegra_dfll *td = data; | |
1108 | ||
1109 | *val = dfll_is_running(td); | |
1110 | ||
1111 | return 0; | |
1112 | } | |
1113 | static int attr_enable_set(void *data, u64 val) | |
1114 | { | |
1115 | struct tegra_dfll *td = data; | |
1116 | ||
1117 | return val ? dfll_enable(td) : dfll_disable(td); | |
1118 | } | |
1119 | DEFINE_SIMPLE_ATTRIBUTE(enable_fops, attr_enable_get, attr_enable_set, | |
1120 | "%llu\n"); | |
1121 | ||
c4fe70ad TT |
1122 | static int attr_lock_get(void *data, u64 *val) |
1123 | { | |
1124 | struct tegra_dfll *td = data; | |
1125 | ||
1126 | *val = (td->mode == DFLL_CLOSED_LOOP); | |
1127 | ||
1128 | return 0; | |
1129 | } | |
1130 | static int attr_lock_set(void *data, u64 val) | |
1131 | { | |
1132 | struct tegra_dfll *td = data; | |
1133 | ||
1134 | return val ? dfll_lock(td) : dfll_unlock(td); | |
1135 | } | |
1136 | DEFINE_SIMPLE_ATTRIBUTE(lock_fops, attr_lock_get, attr_lock_set, | |
1137 | "%llu\n"); | |
1138 | ||
d8d7a08f TT |
1139 | static int attr_rate_get(void *data, u64 *val) |
1140 | { | |
1141 | struct tegra_dfll *td = data; | |
1142 | ||
1143 | *val = dfll_read_monitor_rate(td); | |
1144 | ||
1145 | return 0; | |
1146 | } | |
c4fe70ad TT |
1147 | |
1148 | static int attr_rate_set(void *data, u64 val) | |
1149 | { | |
1150 | struct tegra_dfll *td = data; | |
1151 | ||
1152 | return dfll_request_rate(td, val); | |
1153 | } | |
1154 | DEFINE_SIMPLE_ATTRIBUTE(rate_fops, attr_rate_get, attr_rate_set, "%llu\n"); | |
d8d7a08f TT |
1155 | |
1156 | static int attr_registers_show(struct seq_file *s, void *data) | |
1157 | { | |
1158 | u32 val, offs; | |
1159 | struct tegra_dfll *td = s->private; | |
1160 | ||
1161 | seq_puts(s, "CONTROL REGISTERS:\n"); | |
1162 | for (offs = 0; offs <= DFLL_MONITOR_DATA; offs += 4) { | |
1163 | if (offs == DFLL_OUTPUT_CFG) | |
1164 | val = dfll_i2c_readl(td, offs); | |
1165 | else | |
1166 | val = dfll_readl(td, offs); | |
1167 | seq_printf(s, "[0x%02x] = 0x%08x\n", offs, val); | |
1168 | } | |
1169 | ||
1170 | seq_puts(s, "\nI2C and INTR REGISTERS:\n"); | |
1171 | for (offs = DFLL_I2C_CFG; offs <= DFLL_I2C_STS; offs += 4) | |
1172 | seq_printf(s, "[0x%02x] = 0x%08x\n", offs, | |
1173 | dfll_i2c_readl(td, offs)); | |
1174 | for (offs = DFLL_INTR_STS; offs <= DFLL_INTR_EN; offs += 4) | |
1175 | seq_printf(s, "[0x%02x] = 0x%08x\n", offs, | |
1176 | dfll_i2c_readl(td, offs)); | |
1177 | ||
1178 | seq_puts(s, "\nINTEGRATED I2C CONTROLLER REGISTERS:\n"); | |
1179 | offs = DFLL_I2C_CLK_DIVISOR; | |
1180 | seq_printf(s, "[0x%02x] = 0x%08x\n", offs, | |
1181 | __raw_readl(td->i2c_controller_base + offs)); | |
1182 | ||
1183 | seq_puts(s, "\nLUT:\n"); | |
1184 | for (offs = 0; offs < 4 * MAX_DFLL_VOLTAGES; offs += 4) | |
1185 | seq_printf(s, "[0x%02x] = 0x%08x\n", offs, | |
1186 | __raw_readl(td->lut_base + offs)); | |
1187 | ||
1188 | return 0; | |
1189 | } | |
1190 | ||
1191 | static int attr_registers_open(struct inode *inode, struct file *file) | |
1192 | { | |
1193 | return single_open(file, attr_registers_show, inode->i_private); | |
1194 | } | |
1195 | ||
1196 | static const struct file_operations attr_registers_fops = { | |
1197 | .open = attr_registers_open, | |
1198 | .read = seq_read, | |
1199 | .llseek = seq_lseek, | |
1200 | .release = single_release, | |
1201 | }; | |
1202 | ||
1203 | static int dfll_debug_init(struct tegra_dfll *td) | |
1204 | { | |
1205 | int ret; | |
1206 | ||
1207 | if (!td || (td->mode == DFLL_UNINITIALIZED)) | |
1208 | return 0; | |
1209 | ||
1210 | td->debugfs_dir = debugfs_create_dir("tegra_dfll_fcpu", NULL); | |
1211 | if (!td->debugfs_dir) | |
1212 | return -ENOMEM; | |
1213 | ||
1214 | ret = -ENOMEM; | |
1215 | ||
1216 | if (!debugfs_create_file("enable", S_IRUGO | S_IWUSR, | |
1217 | td->debugfs_dir, td, &enable_fops)) | |
1218 | goto err_out; | |
1219 | ||
c4fe70ad TT |
1220 | if (!debugfs_create_file("lock", S_IRUGO, |
1221 | td->debugfs_dir, td, &lock_fops)) | |
1222 | goto err_out; | |
1223 | ||
d8d7a08f TT |
1224 | if (!debugfs_create_file("rate", S_IRUGO, |
1225 | td->debugfs_dir, td, &rate_fops)) | |
1226 | goto err_out; | |
1227 | ||
1228 | if (!debugfs_create_file("registers", S_IRUGO, | |
1229 | td->debugfs_dir, td, &attr_registers_fops)) | |
1230 | goto err_out; | |
1231 | ||
1232 | return 0; | |
1233 | ||
1234 | err_out: | |
1235 | debugfs_remove_recursive(td->debugfs_dir); | |
1236 | return ret; | |
1237 | } | |
1238 | ||
1239 | #endif /* CONFIG_DEBUG_FS */ | |
1240 | ||
1241 | /* | |
1242 | * DFLL initialization | |
1243 | */ | |
1244 | ||
1245 | /** | |
1246 | * dfll_set_default_params - program non-output related DFLL parameters | |
1247 | * @td: DFLL instance | |
1248 | * | |
1249 | * During DFLL driver initialization or resume from context loss, | |
1250 | * program parameters for the closed loop integrator, DVCO tuning, | |
1251 | * voltage droop control and monitor control. | |
1252 | */ | |
1253 | static void dfll_set_default_params(struct tegra_dfll *td) | |
1254 | { | |
c4fe70ad TT |
1255 | u32 val; |
1256 | ||
1257 | val = DIV_ROUND_UP(td->ref_rate, td->sample_rate * 32); | |
1258 | BUG_ON(val > DFLL_CONFIG_DIV_MASK); | |
1259 | dfll_writel(td, val, DFLL_CONFIG); | |
1260 | ||
1261 | val = (td->force_mode << DFLL_PARAMS_FORCE_MODE_SHIFT) | | |
1262 | (td->cf << DFLL_PARAMS_CF_PARAM_SHIFT) | | |
1263 | (td->ci << DFLL_PARAMS_CI_PARAM_SHIFT) | | |
1264 | (td->cg << DFLL_PARAMS_CG_PARAM_SHIFT) | | |
1265 | (td->cg_scale ? DFLL_PARAMS_CG_SCALE : 0); | |
1266 | dfll_writel(td, val, DFLL_PARAMS); | |
1267 | ||
d8d7a08f TT |
1268 | dfll_tune_low(td); |
1269 | dfll_writel(td, td->droop_ctrl, DFLL_DROOP_CTRL); | |
1270 | dfll_writel(td, DFLL_MONITOR_CTRL_FREQ, DFLL_MONITOR_CTRL); | |
1271 | } | |
1272 | ||
1273 | /** | |
1274 | * dfll_init_clks - clk_get() the DFLL source clocks | |
1275 | * @td: DFLL instance | |
1276 | * | |
1277 | * Call clk_get() on the DFLL source clocks and save the pointers for later | |
1278 | * use. Returns 0 upon success or error (see devm_clk_get) if one or more | |
1279 | * of the clocks couldn't be looked up. | |
1280 | */ | |
1281 | static int dfll_init_clks(struct tegra_dfll *td) | |
1282 | { | |
1283 | td->ref_clk = devm_clk_get(td->dev, "ref"); | |
1284 | if (IS_ERR(td->ref_clk)) { | |
1285 | dev_err(td->dev, "missing ref clock\n"); | |
1286 | return PTR_ERR(td->ref_clk); | |
1287 | } | |
1288 | ||
1289 | td->soc_clk = devm_clk_get(td->dev, "soc"); | |
1290 | if (IS_ERR(td->soc_clk)) { | |
1291 | dev_err(td->dev, "missing soc clock\n"); | |
1292 | return PTR_ERR(td->soc_clk); | |
1293 | } | |
1294 | ||
1295 | td->i2c_clk = devm_clk_get(td->dev, "i2c"); | |
1296 | if (IS_ERR(td->i2c_clk)) { | |
1297 | dev_err(td->dev, "missing i2c clock\n"); | |
1298 | return PTR_ERR(td->i2c_clk); | |
1299 | } | |
1300 | td->i2c_clk_rate = clk_get_rate(td->i2c_clk); | |
1301 | ||
1302 | return 0; | |
1303 | } | |
1304 | ||
1305 | /** | |
1306 | * dfll_init - Prepare the DFLL IP block for use | |
1307 | * @td: DFLL instance | |
1308 | * | |
1309 | * Do everything necessary to prepare the DFLL IP block for use. The | |
1310 | * DFLL will be left in DISABLED state. Called by dfll_probe(). | |
1311 | * Returns 0 upon success, or passes along the error from whatever | |
1312 | * function returned it. | |
1313 | */ | |
1314 | static int dfll_init(struct tegra_dfll *td) | |
1315 | { | |
1316 | int ret; | |
1317 | ||
1318 | td->ref_rate = clk_get_rate(td->ref_clk); | |
1319 | if (td->ref_rate != REF_CLOCK_RATE) { | |
1320 | dev_err(td->dev, "unexpected ref clk rate %lu, expecting %lu", | |
1321 | td->ref_rate, REF_CLOCK_RATE); | |
1322 | return -EINVAL; | |
1323 | } | |
1324 | ||
1325 | reset_control_deassert(td->dvco_rst); | |
1326 | ||
1327 | ret = clk_prepare(td->ref_clk); | |
1328 | if (ret) { | |
1329 | dev_err(td->dev, "failed to prepare ref_clk\n"); | |
1330 | return ret; | |
1331 | } | |
1332 | ||
1333 | ret = clk_prepare(td->soc_clk); | |
1334 | if (ret) { | |
1335 | dev_err(td->dev, "failed to prepare soc_clk\n"); | |
1336 | goto di_err1; | |
1337 | } | |
1338 | ||
1339 | ret = clk_prepare(td->i2c_clk); | |
1340 | if (ret) { | |
1341 | dev_err(td->dev, "failed to prepare i2c_clk\n"); | |
1342 | goto di_err2; | |
1343 | } | |
1344 | ||
c4fe70ad TT |
1345 | td->last_unrounded_rate = 0; |
1346 | ||
d8d7a08f TT |
1347 | pm_runtime_enable(td->dev); |
1348 | pm_runtime_get_sync(td->dev); | |
1349 | ||
1350 | dfll_set_mode(td, DFLL_DISABLED); | |
1351 | dfll_set_default_params(td); | |
1352 | ||
1353 | if (td->soc->init_clock_trimmers) | |
1354 | td->soc->init_clock_trimmers(); | |
1355 | ||
1356 | dfll_set_open_loop_config(td); | |
1357 | ||
c4fe70ad TT |
1358 | dfll_init_out_if(td); |
1359 | ||
d8d7a08f TT |
1360 | pm_runtime_put_sync(td->dev); |
1361 | ||
1362 | return 0; | |
1363 | ||
1364 | di_err2: | |
1365 | clk_unprepare(td->soc_clk); | |
1366 | di_err1: | |
1367 | clk_unprepare(td->ref_clk); | |
1368 | ||
1369 | reset_control_assert(td->dvco_rst); | |
1370 | ||
1371 | return ret; | |
1372 | } | |
1373 | ||
1374 | /* | |
1375 | * DT data fetch | |
1376 | */ | |
1377 | ||
c4fe70ad TT |
1378 | /* |
1379 | * Find a PMIC voltage register-to-voltage mapping for the given voltage. | |
1380 | * An exact voltage match is required. | |
1381 | */ | |
1382 | static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV) | |
1383 | { | |
1384 | int i, n_voltages, reg_uV; | |
1385 | ||
1386 | n_voltages = regulator_count_voltages(td->vdd_reg); | |
1387 | for (i = 0; i < n_voltages; i++) { | |
1388 | reg_uV = regulator_list_voltage(td->vdd_reg, i); | |
1389 | if (reg_uV < 0) | |
1390 | break; | |
1391 | ||
1392 | if (uV == reg_uV) | |
1393 | return i; | |
1394 | } | |
1395 | ||
1396 | dev_err(td->dev, "no voltage map entry for %d uV\n", uV); | |
1397 | return -EINVAL; | |
1398 | } | |
1399 | ||
1400 | /* | |
1401 | * Find a PMIC voltage register-to-voltage mapping for the given voltage, | |
1402 | * rounding up to the closest supported voltage. | |
1403 | * */ | |
1404 | static int find_vdd_map_entry_min(struct tegra_dfll *td, int uV) | |
1405 | { | |
1406 | int i, n_voltages, reg_uV; | |
1407 | ||
1408 | n_voltages = regulator_count_voltages(td->vdd_reg); | |
1409 | for (i = 0; i < n_voltages; i++) { | |
1410 | reg_uV = regulator_list_voltage(td->vdd_reg, i); | |
1411 | if (reg_uV < 0) | |
1412 | break; | |
1413 | ||
1414 | if (uV <= reg_uV) | |
1415 | return i; | |
1416 | } | |
1417 | ||
1418 | dev_err(td->dev, "no voltage map entry rounding to %d uV\n", uV); | |
1419 | return -EINVAL; | |
1420 | } | |
1421 | ||
1422 | /** | |
1423 | * dfll_build_i2c_lut - build the I2C voltage register lookup table | |
1424 | * @td: DFLL instance | |
1425 | * | |
1426 | * The DFLL hardware has 33 bytes of look-up table RAM that must be filled with | |
1427 | * PMIC voltage register values that span the entire DFLL operating range. | |
1428 | * This function builds the look-up table based on the OPP table provided by | |
1429 | * the soc-specific platform driver (td->soc->opp_dev) and the PMIC | |
1430 | * register-to-voltage mapping queried from the regulator framework. | |
1431 | * | |
1432 | * On success, fills in td->i2c_lut and returns 0, or -err on failure. | |
1433 | */ | |
1434 | static int dfll_build_i2c_lut(struct tegra_dfll *td) | |
1435 | { | |
1436 | int ret = -EINVAL; | |
1437 | int j, v, v_max, v_opp; | |
1438 | int selector; | |
1439 | unsigned long rate; | |
1440 | struct dev_pm_opp *opp; | |
c5a132a8 | 1441 | int lut; |
c4fe70ad TT |
1442 | |
1443 | rcu_read_lock(); | |
1444 | ||
1445 | rate = ULONG_MAX; | |
62a8a094 | 1446 | opp = dev_pm_opp_find_freq_floor(td->soc->dev, &rate); |
c4fe70ad TT |
1447 | if (IS_ERR(opp)) { |
1448 | dev_err(td->dev, "couldn't get vmax opp, empty opp table?\n"); | |
1449 | goto out; | |
1450 | } | |
1451 | v_max = dev_pm_opp_get_voltage(opp); | |
1452 | ||
1453 | v = td->soc->min_millivolts * 1000; | |
c5a132a8 SB |
1454 | lut = find_vdd_map_entry_exact(td, v); |
1455 | if (lut < 0) | |
c4fe70ad | 1456 | goto out; |
c5a132a8 | 1457 | td->i2c_lut[0] = lut; |
c4fe70ad TT |
1458 | |
1459 | for (j = 1, rate = 0; ; rate++) { | |
62a8a094 | 1460 | opp = dev_pm_opp_find_freq_ceil(td->soc->dev, &rate); |
c4fe70ad TT |
1461 | if (IS_ERR(opp)) |
1462 | break; | |
1463 | v_opp = dev_pm_opp_get_voltage(opp); | |
1464 | ||
1465 | if (v_opp <= td->soc->min_millivolts * 1000) | |
1466 | td->dvco_rate_min = dev_pm_opp_get_freq(opp); | |
1467 | ||
1468 | for (;;) { | |
1469 | v += max(1, (v_max - v) / (MAX_DFLL_VOLTAGES - j)); | |
1470 | if (v >= v_opp) | |
1471 | break; | |
1472 | ||
1473 | selector = find_vdd_map_entry_min(td, v); | |
1474 | if (selector < 0) | |
1475 | goto out; | |
1476 | if (selector != td->i2c_lut[j - 1]) | |
1477 | td->i2c_lut[j++] = selector; | |
1478 | } | |
1479 | ||
1480 | v = (j == MAX_DFLL_VOLTAGES - 1) ? v_max : v_opp; | |
1481 | selector = find_vdd_map_entry_exact(td, v); | |
1482 | if (selector < 0) | |
1483 | goto out; | |
1484 | if (selector != td->i2c_lut[j - 1]) | |
1485 | td->i2c_lut[j++] = selector; | |
1486 | ||
1487 | if (v >= v_max) | |
1488 | break; | |
1489 | } | |
1490 | td->i2c_lut_size = j; | |
1491 | ||
1492 | if (!td->dvco_rate_min) | |
1493 | dev_err(td->dev, "no opp above DFLL minimum voltage %d mV\n", | |
1494 | td->soc->min_millivolts); | |
1495 | else | |
1496 | ret = 0; | |
1497 | ||
1498 | out: | |
1499 | rcu_read_unlock(); | |
1500 | ||
1501 | return ret; | |
1502 | } | |
1503 | ||
d8d7a08f TT |
1504 | /** |
1505 | * read_dt_param - helper function for reading required parameters from the DT | |
1506 | * @td: DFLL instance | |
1507 | * @param: DT property name | |
1508 | * @dest: output pointer for the value read | |
1509 | * | |
1510 | * Read a required numeric parameter from the DFLL device node, or complain | |
1511 | * if the property doesn't exist. Returns a boolean indicating success for | |
1512 | * easy chaining of multiple calls to this function. | |
1513 | */ | |
1514 | static bool read_dt_param(struct tegra_dfll *td, const char *param, u32 *dest) | |
1515 | { | |
1516 | int err = of_property_read_u32(td->dev->of_node, param, dest); | |
1517 | ||
1518 | if (err < 0) { | |
1519 | dev_err(td->dev, "failed to read DT parameter %s: %d\n", | |
1520 | param, err); | |
1521 | return false; | |
1522 | } | |
1523 | ||
1524 | return true; | |
1525 | } | |
1526 | ||
c4fe70ad TT |
1527 | /** |
1528 | * dfll_fetch_i2c_params - query PMIC I2C params from DT & regulator subsystem | |
1529 | * @td: DFLL instance | |
1530 | * | |
1531 | * Read all the parameters required for operation in I2C mode. The parameters | |
1532 | * can originate from the device tree or the regulator subsystem. | |
1533 | * Returns 0 on success or -err on failure. | |
1534 | */ | |
1535 | static int dfll_fetch_i2c_params(struct tegra_dfll *td) | |
1536 | { | |
1537 | struct regmap *regmap; | |
1538 | struct device *i2c_dev; | |
1539 | struct i2c_client *i2c_client; | |
1540 | int vsel_reg, vsel_mask; | |
1541 | int ret; | |
1542 | ||
1543 | if (!read_dt_param(td, "nvidia,i2c-fs-rate", &td->i2c_fs_rate)) | |
1544 | return -EINVAL; | |
1545 | ||
1546 | regmap = regulator_get_regmap(td->vdd_reg); | |
1547 | i2c_dev = regmap_get_device(regmap); | |
1548 | i2c_client = to_i2c_client(i2c_dev); | |
1549 | ||
1550 | td->i2c_slave_addr = i2c_client->addr; | |
1551 | ||
1552 | ret = regulator_get_hardware_vsel_register(td->vdd_reg, | |
1553 | &vsel_reg, | |
1554 | &vsel_mask); | |
1555 | if (ret < 0) { | |
1556 | dev_err(td->dev, | |
1557 | "regulator unsuitable for DFLL I2C operation\n"); | |
1558 | return -EINVAL; | |
1559 | } | |
1560 | td->i2c_reg = vsel_reg; | |
1561 | ||
1562 | ret = dfll_build_i2c_lut(td); | |
1563 | if (ret) { | |
1564 | dev_err(td->dev, "couldn't build I2C LUT\n"); | |
1565 | return ret; | |
1566 | } | |
1567 | ||
1568 | return 0; | |
1569 | } | |
1570 | ||
d8d7a08f TT |
1571 | /** |
1572 | * dfll_fetch_common_params - read DFLL parameters from the device tree | |
1573 | * @td: DFLL instance | |
1574 | * | |
1575 | * Read all the DT parameters that are common to both I2C and PWM operation. | |
1576 | * Returns 0 on success or -EINVAL on any failure. | |
1577 | */ | |
1578 | static int dfll_fetch_common_params(struct tegra_dfll *td) | |
1579 | { | |
1580 | bool ok = true; | |
1581 | ||
1582 | ok &= read_dt_param(td, "nvidia,droop-ctrl", &td->droop_ctrl); | |
c4fe70ad TT |
1583 | ok &= read_dt_param(td, "nvidia,sample-rate", &td->sample_rate); |
1584 | ok &= read_dt_param(td, "nvidia,force-mode", &td->force_mode); | |
1585 | ok &= read_dt_param(td, "nvidia,cf", &td->cf); | |
1586 | ok &= read_dt_param(td, "nvidia,ci", &td->ci); | |
1587 | ok &= read_dt_param(td, "nvidia,cg", &td->cg); | |
1588 | td->cg_scale = of_property_read_bool(td->dev->of_node, | |
1589 | "nvidia,cg-scale"); | |
d8d7a08f TT |
1590 | |
1591 | if (of_property_read_string(td->dev->of_node, "clock-output-names", | |
1592 | &td->output_clock_name)) { | |
1593 | dev_err(td->dev, "missing clock-output-names property\n"); | |
1594 | ok = false; | |
1595 | } | |
1596 | ||
1597 | return ok ? 0 : -EINVAL; | |
1598 | } | |
1599 | ||
1600 | /* | |
1601 | * API exported to per-SoC platform drivers | |
1602 | */ | |
1603 | ||
1604 | /** | |
1605 | * tegra_dfll_register - probe a Tegra DFLL device | |
1606 | * @pdev: DFLL platform_device * | |
1607 | * @soc: Per-SoC integration and characterization data for this DFLL instance | |
1608 | * | |
1609 | * Probe and initialize a DFLL device instance. Intended to be called | |
1610 | * by a SoC-specific shim driver that passes in per-SoC integration | |
1611 | * and configuration data via @soc. Returns 0 on success or -err on failure. | |
1612 | */ | |
1613 | int tegra_dfll_register(struct platform_device *pdev, | |
1614 | struct tegra_dfll_soc_data *soc) | |
1615 | { | |
1616 | struct resource *mem; | |
1617 | struct tegra_dfll *td; | |
1618 | int ret; | |
1619 | ||
1620 | if (!soc) { | |
1621 | dev_err(&pdev->dev, "no tegra_dfll_soc_data provided\n"); | |
1622 | return -EINVAL; | |
1623 | } | |
1624 | ||
1625 | td = devm_kzalloc(&pdev->dev, sizeof(*td), GFP_KERNEL); | |
1626 | if (!td) | |
1627 | return -ENOMEM; | |
1628 | td->dev = &pdev->dev; | |
1629 | platform_set_drvdata(pdev, td); | |
1630 | ||
1631 | td->soc = soc; | |
1632 | ||
1633 | td->vdd_reg = devm_regulator_get(td->dev, "vdd-cpu"); | |
1634 | if (IS_ERR(td->vdd_reg)) { | |
1635 | dev_err(td->dev, "couldn't get vdd_cpu regulator\n"); | |
1636 | return PTR_ERR(td->vdd_reg); | |
1637 | } | |
1638 | ||
1639 | td->dvco_rst = devm_reset_control_get(td->dev, "dvco"); | |
1640 | if (IS_ERR(td->dvco_rst)) { | |
1641 | dev_err(td->dev, "couldn't get dvco reset\n"); | |
1642 | return PTR_ERR(td->dvco_rst); | |
1643 | } | |
1644 | ||
1645 | ret = dfll_fetch_common_params(td); | |
1646 | if (ret) { | |
1647 | dev_err(td->dev, "couldn't parse device tree parameters\n"); | |
1648 | return ret; | |
1649 | } | |
1650 | ||
c4fe70ad TT |
1651 | ret = dfll_fetch_i2c_params(td); |
1652 | if (ret) | |
1653 | return ret; | |
1654 | ||
d8d7a08f TT |
1655 | mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
1656 | if (!mem) { | |
1657 | dev_err(td->dev, "no control register resource\n"); | |
1658 | return -ENODEV; | |
1659 | } | |
1660 | ||
1661 | td->base = devm_ioremap(td->dev, mem->start, resource_size(mem)); | |
1662 | if (!td->base) { | |
1663 | dev_err(td->dev, "couldn't ioremap DFLL control registers\n"); | |
1664 | return -ENODEV; | |
1665 | } | |
1666 | ||
1667 | mem = platform_get_resource(pdev, IORESOURCE_MEM, 1); | |
1668 | if (!mem) { | |
1669 | dev_err(td->dev, "no i2c_base resource\n"); | |
1670 | return -ENODEV; | |
1671 | } | |
1672 | ||
1673 | td->i2c_base = devm_ioremap(td->dev, mem->start, resource_size(mem)); | |
1674 | if (!td->i2c_base) { | |
1675 | dev_err(td->dev, "couldn't ioremap i2c_base resource\n"); | |
1676 | return -ENODEV; | |
1677 | } | |
1678 | ||
1679 | mem = platform_get_resource(pdev, IORESOURCE_MEM, 2); | |
1680 | if (!mem) { | |
1681 | dev_err(td->dev, "no i2c_controller_base resource\n"); | |
1682 | return -ENODEV; | |
1683 | } | |
1684 | ||
1685 | td->i2c_controller_base = devm_ioremap(td->dev, mem->start, | |
1686 | resource_size(mem)); | |
1687 | if (!td->i2c_controller_base) { | |
1688 | dev_err(td->dev, | |
1689 | "couldn't ioremap i2c_controller_base resource\n"); | |
1690 | return -ENODEV; | |
1691 | } | |
1692 | ||
1693 | mem = platform_get_resource(pdev, IORESOURCE_MEM, 3); | |
1694 | if (!mem) { | |
1695 | dev_err(td->dev, "no lut_base resource\n"); | |
1696 | return -ENODEV; | |
1697 | } | |
1698 | ||
1699 | td->lut_base = devm_ioremap(td->dev, mem->start, resource_size(mem)); | |
1700 | if (!td->lut_base) { | |
1701 | dev_err(td->dev, | |
1702 | "couldn't ioremap lut_base resource\n"); | |
1703 | return -ENODEV; | |
1704 | } | |
1705 | ||
1706 | ret = dfll_init_clks(td); | |
1707 | if (ret) { | |
1708 | dev_err(&pdev->dev, "DFLL clock init error\n"); | |
1709 | return ret; | |
1710 | } | |
1711 | ||
1712 | /* Enable the clocks and set the device up */ | |
1713 | ret = dfll_init(td); | |
1714 | if (ret) | |
1715 | return ret; | |
1716 | ||
1717 | ret = dfll_register_clk(td); | |
1718 | if (ret) { | |
1719 | dev_err(&pdev->dev, "DFLL clk registration failed\n"); | |
1720 | return ret; | |
1721 | } | |
1722 | ||
1723 | #ifdef CONFIG_DEBUG_FS | |
1724 | dfll_debug_init(td); | |
1725 | #endif | |
1726 | ||
1727 | return 0; | |
1728 | } | |
1729 | EXPORT_SYMBOL(tegra_dfll_register); | |
1730 | ||
1731 | /** | |
1732 | * tegra_dfll_unregister - release all of the DFLL driver resources for a device | |
1733 | * @pdev: DFLL platform_device * | |
1734 | * | |
1735 | * Unbind this driver from the DFLL hardware device represented by | |
1736 | * @pdev. The DFLL must be disabled for this to succeed. Returns 0 | |
1737 | * upon success or -EBUSY if the DFLL is still active. | |
1738 | */ | |
1739 | int tegra_dfll_unregister(struct platform_device *pdev) | |
1740 | { | |
1741 | struct tegra_dfll *td = platform_get_drvdata(pdev); | |
1742 | ||
1743 | /* Try to prevent removal while the DFLL is active */ | |
1744 | if (td->mode != DFLL_DISABLED) { | |
1745 | dev_err(&pdev->dev, | |
1746 | "must disable DFLL before removing driver\n"); | |
1747 | return -EBUSY; | |
1748 | } | |
1749 | ||
1750 | debugfs_remove_recursive(td->debugfs_dir); | |
1751 | ||
1752 | dfll_unregister_clk(td); | |
1753 | pm_runtime_disable(&pdev->dev); | |
1754 | ||
1755 | clk_unprepare(td->ref_clk); | |
1756 | clk_unprepare(td->soc_clk); | |
1757 | clk_unprepare(td->i2c_clk); | |
1758 | ||
1759 | reset_control_assert(td->dvco_rst); | |
1760 | ||
1761 | return 0; | |
1762 | } | |
1763 | EXPORT_SYMBOL(tegra_dfll_unregister); |