Commit | Line | Data |
---|---|---|
3bc61cfd LB |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * LMK04832 Ultra Low-Noise JESD204B Compliant Clock Jitter Cleaner | |
4 | * Pin compatible with the LMK0482x family | |
5 | * | |
6 | * Datasheet: https://www.ti.com/lit/ds/symlink/lmk04832.pdf | |
7 | * | |
8 | * Copyright (c) 2020, Xiphos Systems Corp. | |
9 | * | |
10 | */ | |
11 | ||
12 | #include <linux/bitfield.h> | |
13 | #include <linux/clk.h> | |
14 | #include <linux/clk-provider.h> | |
3bc61cfd LB |
15 | #include <linux/device.h> |
16 | #include <linux/gcd.h> | |
17 | #include <linux/gpio/consumer.h> | |
18 | #include <linux/module.h> | |
3bc61cfd LB |
19 | #include <linux/regmap.h> |
20 | #include <linux/spi/spi.h> | |
21 | ||
22 | /* 0x000 - 0x00d System Functions */ | |
23 | #define LMK04832_REG_RST3W 0x000 | |
24 | #define LMK04832_BIT_RESET BIT(7) | |
25 | #define LMK04832_BIT_SPI_3WIRE_DIS BIT(4) | |
26 | #define LMK04832_REG_POWERDOWN 0x002 | |
27 | #define LMK04832_REG_ID_DEV_TYPE 0x003 | |
28 | #define LMK04832_REG_ID_PROD_MSB 0x004 | |
29 | #define LMK04832_REG_ID_PROD_LSB 0x005 | |
30 | #define LMK04832_REG_ID_MASKREV 0x006 | |
31 | #define LMK04832_REG_ID_VNDR_MSB 0x00c | |
32 | #define LMK04832_REG_ID_VNDR_LSB 0x00d | |
33 | ||
34 | /* 0x100 - 0x137 Device Clock and SYSREF Clock Output Control */ | |
35 | #define LMK04832_REG_CLKOUT_CTRL0(ch) (0x100 + (ch >> 1) * 8) | |
36 | #define LMK04832_BIT_DCLK_DIV_LSB GENMASK(7, 0) | |
37 | #define LMK04832_REG_CLKOUT_CTRL1(ch) (0x101 + (ch >> 1) * 8) | |
6181baa1 | 38 | #define LMK04832_BIT_DCLKX_Y_DDLY_LSB GENMASK(7, 0) |
3bc61cfd LB |
39 | #define LMK04832_REG_CLKOUT_CTRL2(ch) (0x102 + (ch >> 1) * 8) |
40 | #define LMK04832_BIT_CLKOUTX_Y_PD BIT(7) | |
6181baa1 LB |
41 | #define LMK04832_BIT_DCLKX_Y_DDLY_PD BIT(4) |
42 | #define LMK04832_BIT_DCLKX_Y_DDLY_MSB GENMASK(3, 2) | |
3bc61cfd LB |
43 | #define LMK04832_BIT_DCLK_DIV_MSB GENMASK(1, 0) |
44 | #define LMK04832_REG_CLKOUT_SRC_MUX(ch) (0x103 + (ch % 2) + (ch >> 1) * 8) | |
45 | #define LMK04832_BIT_CLKOUT_SRC_MUX BIT(5) | |
46 | #define LMK04832_REG_CLKOUT_CTRL3(ch) (0x103 + (ch >> 1) * 8) | |
47 | #define LMK04832_BIT_DCLKX_Y_PD BIT(4) | |
48 | #define LMK04832_BIT_DCLKX_Y_DCC BIT(2) | |
6181baa1 | 49 | #define LMK04832_BIT_DCLKX_Y_HS BIT(0) |
3bc61cfd LB |
50 | #define LMK04832_REG_CLKOUT_CTRL4(ch) (0x104 + (ch >> 1) * 8) |
51 | #define LMK04832_BIT_SCLK_PD BIT(4) | |
6181baa1 LB |
52 | #define LMK04832_BIT_SCLKX_Y_DIS_MODE GENMASK(3, 2) |
53 | #define LMK04832_REG_SCLKX_Y_ADLY(ch) (0x105 + (ch >> 1) * 8) | |
54 | #define LMK04832_REG_SCLKX_Y_DDLY(ch) (0x106 + (ch >> 1) * 8) | |
55 | #define LMK04832_BIT_SCLKX_Y_DDLY GENMASK(3, 0) | |
3bc61cfd LB |
56 | #define LMK04832_REG_CLKOUT_FMT(ch) (0x107 + (ch >> 1) * 8) |
57 | #define LMK04832_BIT_CLKOUT_FMT(ch) (ch % 2 ? 0xf0 : 0x0f) | |
58 | #define LMK04832_VAL_CLKOUT_FMT_POWERDOWN 0x00 | |
59 | #define LMK04832_VAL_CLKOUT_FMT_LVDS 0x01 | |
60 | #define LMK04832_VAL_CLKOUT_FMT_HSDS6 0x02 | |
61 | #define LMK04832_VAL_CLKOUT_FMT_HSDS8 0x03 | |
62 | #define LMK04832_VAL_CLKOUT_FMT_LVPECL1600 0x04 | |
63 | #define LMK04832_VAL_CLKOUT_FMT_LVPECL2000 0x05 | |
64 | #define LMK04832_VAL_CLKOUT_FMT_LCPECL 0x06 | |
65 | #define LMK04832_VAL_CLKOUT_FMT_CML16 0x07 | |
66 | #define LMK04832_VAL_CLKOUT_FMT_CML24 0x08 | |
67 | #define LMK04832_VAL_CLKOUT_FMT_CML32 0x09 | |
68 | #define LMK04832_VAL_CLKOUT_FMT_CMOS_OFF_INV 0x0a | |
69 | #define LMK04832_VAL_CLKOUT_FMT_CMOS_NOR_OFF 0x0b | |
70 | #define LMK04832_VAL_CLKOUT_FMT_CMOS_INV_INV 0x0c | |
71 | #define LMK04832_VAL_CLKOUT_FMT_CMOS_INV_NOR 0x0d | |
72 | #define LMK04832_VAL_CLKOUT_FMT_CMOS_NOR_INV 0x0e | |
73 | #define LMK04832_VAL_CLKOUT_FMT_CMOS_NOR_NOR 0x0f | |
74 | ||
75 | /* 0x138 - 0x145 SYSREF, SYNC, and Device Config */ | |
76 | #define LMK04832_REG_VCO_OSCOUT 0x138 | |
77 | #define LMK04832_BIT_VCO_MUX GENMASK(6, 5) | |
78 | #define LMK04832_VAL_VCO_MUX_VCO0 0x00 | |
79 | #define LMK04832_VAL_VCO_MUX_VCO1 0x01 | |
80 | #define LMK04832_VAL_VCO_MUX_EXT 0x02 | |
81 | #define LMK04832_REG_SYSREF_OUT 0x139 | |
6181baa1 | 82 | #define LMK04832_BIT_SYSREF_REQ_EN BIT(6) |
3bc61cfd | 83 | #define LMK04832_BIT_SYSREF_MUX GENMASK(1, 0) |
6181baa1 LB |
84 | #define LMK04832_VAL_SYSREF_MUX_NORMAL_SYNC 0x00 |
85 | #define LMK04832_VAL_SYSREF_MUX_RECLK 0x01 | |
86 | #define LMK04832_VAL_SYSREF_MUX_PULSER 0x02 | |
3bc61cfd LB |
87 | #define LMK04832_VAL_SYSREF_MUX_CONTINUOUS 0x03 |
88 | #define LMK04832_REG_SYSREF_DIV_MSB 0x13a | |
89 | #define LMK04832_BIT_SYSREF_DIV_MSB GENMASK(4, 0) | |
90 | #define LMK04832_REG_SYSREF_DIV_LSB 0x13b | |
6181baa1 LB |
91 | #define LMK04832_REG_SYSREF_DDLY_MSB 0x13c |
92 | #define LMK04832_BIT_SYSREF_DDLY_MSB GENMASK(4, 0) | |
93 | #define LMK04832_REG_SYSREF_DDLY_LSB 0x13d | |
94 | #define LMK04832_REG_SYSREF_PULSE_CNT 0x13e | |
3bc61cfd LB |
95 | #define LMK04832_REG_FB_CTRL 0x13f |
96 | #define LMK04832_BIT_PLL2_RCLK_MUX BIT(7) | |
97 | #define LMK04832_VAL_PLL2_RCLK_MUX_OSCIN 0x00 | |
98 | #define LMK04832_VAL_PLL2_RCLK_MUX_CLKIN 0x01 | |
99 | #define LMK04832_BIT_PLL2_NCLK_MUX BIT(5) | |
100 | #define LMK04832_VAL_PLL2_NCLK_MUX_PLL2_P 0x00 | |
101 | #define LMK04832_VAL_PLL2_NCLK_MUX_FB_MUX 0x01 | |
102 | #define LMK04832_BIT_FB_MUX_EN BIT(0) | |
103 | #define LMK04832_REG_MAIN_PD 0x140 | |
104 | #define LMK04832_BIT_PLL1_PD BIT(7) | |
105 | #define LMK04832_BIT_VCO_LDO_PD BIT(6) | |
106 | #define LMK04832_BIT_VCO_PD BIT(5) | |
107 | #define LMK04832_BIT_OSCIN_PD BIT(4) | |
108 | #define LMK04832_BIT_SYSREF_GBL_PD BIT(3) | |
109 | #define LMK04832_BIT_SYSREF_PD BIT(2) | |
110 | #define LMK04832_BIT_SYSREF_DDLY_PD BIT(1) | |
111 | #define LMK04832_BIT_SYSREF_PLSR_PD BIT(0) | |
112 | #define LMK04832_REG_SYNC 0x143 | |
6181baa1 LB |
113 | #define LMK04832_BIT_SYNC_CLR BIT(7) |
114 | #define LMK04832_BIT_SYNC_1SHOT_EN BIT(6) | |
115 | #define LMK04832_BIT_SYNC_POL BIT(5) | |
3bc61cfd | 116 | #define LMK04832_BIT_SYNC_EN BIT(4) |
6181baa1 LB |
117 | #define LMK04832_BIT_SYNC_MODE GENMASK(1, 0) |
118 | #define LMK04832_VAL_SYNC_MODE_OFF 0x00 | |
119 | #define LMK04832_VAL_SYNC_MODE_ON 0x01 | |
120 | #define LMK04832_VAL_SYNC_MODE_PULSER_PIN 0x02 | |
121 | #define LMK04832_VAL_SYNC_MODE_PULSER_SPI 0x03 | |
3bc61cfd LB |
122 | #define LMK04832_REG_SYNC_DIS 0x144 |
123 | ||
124 | /* 0x146 - 0x14a CLKin Control */ | |
125 | #define LMK04832_REG_CLKIN_SEL0 0x148 | |
126 | #define LMK04832_REG_CLKIN_SEL1 0x149 | |
127 | #define LMK04832_REG_CLKIN_RST 0x14a | |
128 | #define LMK04832_BIT_SDIO_RDBK_TYPE BIT(6) | |
129 | #define LMK04832_BIT_CLKIN_SEL_MUX GENMASK(5, 3) | |
130 | #define LMK04832_VAL_CLKIN_SEL_MUX_SPI_RDBK 0x06 | |
131 | #define LMK04832_BIT_CLKIN_SEL_TYPE GENMASK(2, 0) | |
132 | #define LMK04832_VAL_CLKIN_SEL_TYPE_OUT 0x03 | |
133 | ||
134 | /* 0x14b - 0x152 Holdover */ | |
135 | ||
136 | /* 0x153 - 0x15f PLL1 Configuration */ | |
6aa8dc69 ML |
137 | #define LMK04832_REG_PLL1_LD 0x15f |
138 | #define LMK04832_BIT_PLL1_LD_MUX GENMASK(7, 3) | |
139 | #define LMK04832_VAL_PLL1_LD_MUX_SPI_RDBK 0x07 | |
140 | #define LMK04832_BIT_PLL1_LD_TYPE GENMASK(2, 0) | |
141 | #define LMK04832_VAL_PLL1_LD_TYPE_OUT_PP 0x03 | |
3bc61cfd LB |
142 | |
143 | /* 0x160 - 0x16e PLL2 Configuration */ | |
144 | #define LMK04832_REG_PLL2_R_MSB 0x160 | |
145 | #define LMK04832_BIT_PLL2_R_MSB GENMASK(3, 0) | |
146 | #define LMK04832_REG_PLL2_R_LSB 0x161 | |
147 | #define LMK04832_REG_PLL2_MISC 0x162 | |
148 | #define LMK04832_BIT_PLL2_MISC_P GENMASK(7, 5) | |
149 | #define LMK04832_BIT_PLL2_MISC_REF_2X_EN BIT(0) | |
150 | #define LMK04832_REG_PLL2_N_CAL_0 0x163 | |
151 | #define LMK04832_BIT_PLL2_N_CAL_0 GENMASK(1, 0) | |
152 | #define LMK04832_REG_PLL2_N_CAL_1 0x164 | |
153 | #define LMK04832_REG_PLL2_N_CAL_2 0x165 | |
154 | #define LMK04832_REG_PLL2_N_0 0x166 | |
155 | #define LMK04832_BIT_PLL2_N_0 GENMASK(1, 0) | |
156 | #define LMK04832_REG_PLL2_N_1 0x167 | |
157 | #define LMK04832_REG_PLL2_N_2 0x168 | |
6181baa1 | 158 | #define LMK04832_REG_PLL2_DLD_CNT_MSB 0x16a |
3bc61cfd LB |
159 | #define LMK04832_REG_PLL2_DLD_CNT_LSB 0x16b |
160 | #define LMK04832_REG_PLL2_LD 0x16e | |
161 | #define LMK04832_BIT_PLL2_LD_MUX GENMASK(7, 3) | |
162 | #define LMK04832_VAL_PLL2_LD_MUX_PLL2_DLD 0x02 | |
163 | #define LMK04832_BIT_PLL2_LD_TYPE GENMASK(2, 0) | |
164 | #define LMK04832_VAL_PLL2_LD_TYPE_OUT_PP 0x03 | |
165 | ||
166 | /* 0x16F - 0x555 Misc Registers */ | |
167 | #define LMK04832_REG_PLL2_PD 0x173 | |
168 | #define LMK04832_BIT_PLL2_PRE_PD BIT(6) | |
169 | #define LMK04832_BIT_PLL2_PD BIT(5) | |
170 | #define LMK04832_REG_PLL1R_RST 0x177 | |
171 | #define LMK04832_REG_CLR_PLL_LOST 0x182 | |
172 | #define LMK04832_REG_RB_PLL_LD 0x183 | |
173 | #define LMK04832_REG_RB_CLK_DAC_VAL_MSB 0x184 | |
174 | #define LMK04832_REG_RB_DAC_VAL_LSB 0x185 | |
175 | #define LMK04832_REG_RB_HOLDOVER 0x188 | |
176 | #define LMK04832_REG_SPI_LOCK 0x555 | |
177 | ||
178 | enum lmk04832_device_types { | |
179 | LMK04832, | |
180 | }; | |
181 | ||
182 | /** | |
40b85eec LB |
183 | * struct lmk04832_device_info - Holds static device information that is |
184 | * specific to the chip revision | |
3bc61cfd | 185 | * |
40b85eec LB |
186 | * @pid: Product Identifier |
187 | * @maskrev: IC version identifier | |
188 | * @num_channels: Number of available output channels (clkout count) | |
189 | * @vco0_range: {min, max} of the VCO0 operating range (in MHz) | |
190 | * @vco1_range: {min, max} of the VCO1 operating range (in MHz) | |
3bc61cfd LB |
191 | */ |
192 | struct lmk04832_device_info { | |
193 | u16 pid; | |
194 | u8 maskrev; | |
195 | size_t num_channels; | |
196 | unsigned int vco0_range[2]; | |
197 | unsigned int vco1_range[2]; | |
198 | }; | |
199 | ||
200 | static const struct lmk04832_device_info lmk04832_device_info[] = { | |
201 | [LMK04832] = { | |
202 | .pid = 0x63d1, /* WARNING PROD_ID is inverted in the datasheet */ | |
203 | .maskrev = 0x70, | |
204 | .num_channels = 14, | |
205 | .vco0_range = { 2440, 2580 }, | |
206 | .vco1_range = { 2945, 3255 }, | |
207 | }, | |
208 | }; | |
209 | ||
210 | enum lmk04832_rdbk_type { | |
211 | RDBK_CLKIN_SEL0, | |
212 | RDBK_CLKIN_SEL1, | |
213 | RDBK_RESET, | |
6aa8dc69 | 214 | RDBK_PLL1_LD, |
3bc61cfd LB |
215 | }; |
216 | ||
217 | struct lmk_dclk { | |
218 | struct lmk04832 *lmk; | |
219 | struct clk_hw hw; | |
220 | u8 id; | |
221 | }; | |
222 | ||
223 | struct lmk_clkout { | |
224 | struct lmk04832 *lmk; | |
225 | struct clk_hw hw; | |
226 | bool sysref; | |
227 | u32 format; | |
228 | u8 id; | |
229 | }; | |
230 | ||
231 | /** | |
232 | * struct lmk04832 - The LMK04832 device structure | |
233 | * | |
234 | * @dev: reference to a struct device, linked to the spi_device | |
235 | * @regmap: struct regmap instance use to access the chip | |
6181baa1 LB |
236 | * @sync_mode: operational mode for SYNC signal |
237 | * @sysref_mux: select SYSREF source | |
238 | * @sysref_pulse_cnt: number of SYSREF pulses generated while not in continuous | |
239 | * mode. | |
240 | * @sysref_ddly: SYSREF digital delay value | |
3bc61cfd LB |
241 | * @oscin: PLL2 input clock |
242 | * @vco: reference to the internal VCO clock | |
243 | * @sclk: reference to the internal sysref clock (SCLK) | |
244 | * @vco_rate: user provided VCO rate | |
245 | * @reset_gpio: reference to the reset GPIO | |
246 | * @dclk: list of internal device clock references. | |
247 | * Each pair of clkout clocks share a single device clock (DCLKX_Y) | |
248 | * @clkout: list of output clock references | |
249 | * @clk_data: holds clkout related data like clk_hw* and number of clocks | |
250 | */ | |
251 | struct lmk04832 { | |
252 | struct device *dev; | |
253 | struct regmap *regmap; | |
254 | ||
6181baa1 LB |
255 | unsigned int sync_mode; |
256 | unsigned int sysref_mux; | |
257 | unsigned int sysref_pulse_cnt; | |
258 | unsigned int sysref_ddly; | |
259 | ||
3bc61cfd LB |
260 | struct clk *oscin; |
261 | struct clk_hw vco; | |
262 | struct clk_hw sclk; | |
263 | unsigned int vco_rate; | |
264 | ||
265 | struct gpio_desc *reset_gpio; | |
266 | ||
267 | struct lmk_dclk *dclk; | |
268 | struct lmk_clkout *clkout; | |
269 | struct clk_hw_onecell_data *clk_data; | |
270 | }; | |
271 | ||
272 | static bool lmk04832_regmap_rd_regs(struct device *dev, unsigned int reg) | |
273 | { | |
274 | switch (reg) { | |
275 | case LMK04832_REG_RST3W ... LMK04832_REG_ID_MASKREV: | |
3bc61cfd | 276 | case LMK04832_REG_ID_VNDR_MSB: |
3bc61cfd | 277 | case LMK04832_REG_ID_VNDR_LSB: |
3bc61cfd | 278 | case LMK04832_REG_CLKOUT_CTRL0(0) ... LMK04832_REG_PLL2_DLD_CNT_LSB: |
3bc61cfd | 279 | case LMK04832_REG_PLL2_LD: |
3bc61cfd | 280 | case LMK04832_REG_PLL2_PD: |
3bc61cfd | 281 | case LMK04832_REG_PLL1R_RST: |
3bc61cfd | 282 | case LMK04832_REG_CLR_PLL_LOST ... LMK04832_REG_RB_DAC_VAL_LSB: |
3bc61cfd | 283 | case LMK04832_REG_RB_HOLDOVER: |
3bc61cfd LB |
284 | case LMK04832_REG_SPI_LOCK: |
285 | return true; | |
286 | default: | |
287 | return false; | |
288 | }; | |
992a3552 | 289 | } |
3bc61cfd LB |
290 | |
291 | static bool lmk04832_regmap_wr_regs(struct device *dev, unsigned int reg) | |
292 | { | |
293 | switch (reg) { | |
294 | case LMK04832_REG_RST3W: | |
3bc61cfd LB |
295 | case LMK04832_REG_POWERDOWN: |
296 | return true; | |
297 | case LMK04832_REG_ID_DEV_TYPE ... LMK04832_REG_ID_MASKREV: | |
3bc61cfd | 298 | case LMK04832_REG_ID_VNDR_MSB: |
3bc61cfd LB |
299 | case LMK04832_REG_ID_VNDR_LSB: |
300 | return false; | |
301 | case LMK04832_REG_CLKOUT_CTRL0(0) ... LMK04832_REG_PLL2_DLD_CNT_LSB: | |
3bc61cfd | 302 | case LMK04832_REG_PLL2_LD: |
3bc61cfd | 303 | case LMK04832_REG_PLL2_PD: |
3bc61cfd | 304 | case LMK04832_REG_PLL1R_RST: |
3bc61cfd | 305 | case LMK04832_REG_CLR_PLL_LOST ... LMK04832_REG_RB_DAC_VAL_LSB: |
3bc61cfd | 306 | case LMK04832_REG_RB_HOLDOVER: |
3bc61cfd LB |
307 | case LMK04832_REG_SPI_LOCK: |
308 | return true; | |
309 | default: | |
310 | return false; | |
311 | }; | |
992a3552 | 312 | } |
3bc61cfd LB |
313 | |
314 | static const struct regmap_config regmap_config = { | |
315 | .name = "lmk04832", | |
316 | .reg_bits = 16, | |
317 | .val_bits = 8, | |
318 | .use_single_read = 1, | |
319 | .use_single_write = 1, | |
320 | .read_flag_mask = 0x80, | |
321 | .write_flag_mask = 0x00, | |
322 | .readable_reg = lmk04832_regmap_rd_regs, | |
323 | .writeable_reg = lmk04832_regmap_wr_regs, | |
324 | .cache_type = REGCACHE_NONE, | |
325 | .max_register = LMK04832_REG_SPI_LOCK, | |
326 | }; | |
327 | ||
328 | static int lmk04832_vco_is_enabled(struct clk_hw *hw) | |
329 | { | |
330 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, vco); | |
331 | unsigned int tmp; | |
332 | int ret; | |
333 | ||
334 | ret = regmap_read(lmk->regmap, LMK04832_REG_MAIN_PD, &tmp); | |
335 | if (ret) | |
336 | return ret; | |
337 | ||
338 | return !(FIELD_GET(LMK04832_BIT_OSCIN_PD, tmp) | | |
339 | FIELD_GET(LMK04832_BIT_VCO_PD, tmp) | | |
340 | FIELD_GET(LMK04832_BIT_VCO_LDO_PD, tmp)); | |
341 | } | |
342 | ||
343 | static int lmk04832_vco_prepare(struct clk_hw *hw) | |
344 | { | |
345 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, vco); | |
346 | int ret; | |
347 | ||
348 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_PLL2_PD, | |
349 | LMK04832_BIT_PLL2_PRE_PD | | |
350 | LMK04832_BIT_PLL2_PD, | |
351 | 0x00); | |
352 | if (ret) | |
353 | return ret; | |
354 | ||
355 | return regmap_update_bits(lmk->regmap, LMK04832_REG_MAIN_PD, | |
356 | LMK04832_BIT_VCO_LDO_PD | | |
357 | LMK04832_BIT_VCO_PD | | |
358 | LMK04832_BIT_OSCIN_PD, 0x00); | |
359 | } | |
360 | ||
361 | static void lmk04832_vco_unprepare(struct clk_hw *hw) | |
362 | { | |
363 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, vco); | |
364 | ||
365 | regmap_update_bits(lmk->regmap, LMK04832_REG_PLL2_PD, | |
366 | LMK04832_BIT_PLL2_PRE_PD | LMK04832_BIT_PLL2_PD, | |
367 | 0xff); | |
368 | ||
369 | /* Don't set LMK04832_BIT_OSCIN_PD since other clocks depend on it */ | |
370 | regmap_update_bits(lmk->regmap, LMK04832_REG_MAIN_PD, | |
371 | LMK04832_BIT_VCO_LDO_PD | LMK04832_BIT_VCO_PD, 0xff); | |
372 | } | |
373 | ||
374 | static unsigned long lmk04832_vco_recalc_rate(struct clk_hw *hw, | |
375 | unsigned long prate) | |
376 | { | |
377 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, vco); | |
6c634446 | 378 | const unsigned int pll2_p[] = {8, 2, 2, 3, 4, 5, 6, 7}; |
3bc61cfd LB |
379 | unsigned int pll2_n, p, pll2_r; |
380 | unsigned int pll2_misc; | |
381 | unsigned long vco_rate; | |
382 | u8 tmp[3]; | |
383 | int ret; | |
384 | ||
385 | ret = regmap_read(lmk->regmap, LMK04832_REG_PLL2_MISC, &pll2_misc); | |
386 | if (ret) | |
387 | return ret; | |
388 | ||
389 | p = FIELD_GET(LMK04832_BIT_PLL2_MISC_P, pll2_misc); | |
390 | ||
391 | ret = regmap_bulk_read(lmk->regmap, LMK04832_REG_PLL2_N_0, &tmp, 3); | |
392 | if (ret) | |
393 | return ret; | |
394 | ||
395 | pll2_n = FIELD_PREP(0x030000, tmp[0]) | | |
396 | FIELD_PREP(0x00ff00, tmp[1]) | | |
397 | FIELD_PREP(0x0000ff, tmp[2]); | |
398 | ||
399 | ret = regmap_bulk_read(lmk->regmap, LMK04832_REG_PLL2_R_MSB, &tmp, 2); | |
400 | if (ret) | |
401 | return ret; | |
402 | ||
403 | pll2_r = FIELD_PREP(0x0f00, tmp[0]) | | |
404 | FIELD_PREP(0x00ff, tmp[1]); | |
405 | ||
406 | vco_rate = (prate << FIELD_GET(LMK04832_BIT_PLL2_MISC_REF_2X_EN, | |
407 | pll2_misc)) * pll2_n * pll2_p[p] / pll2_r; | |
408 | ||
409 | return vco_rate; | |
992a3552 | 410 | } |
3bc61cfd LB |
411 | |
412 | /** | |
413 | * lmk04832_check_vco_ranges - Check requested VCO frequency against VCO ranges | |
414 | * | |
415 | * @lmk: Reference to the lmk device | |
416 | * @rate: Desired output rate for the VCO | |
417 | * | |
418 | * The LMK04832 has 2 internal VCO, each with independent operating ranges. | |
419 | * Use the device_info structure to determine which VCO to use based on rate. | |
420 | * | |
40b85eec | 421 | * Returns: VCO_MUX value or negative errno. |
3bc61cfd LB |
422 | */ |
423 | static int lmk04832_check_vco_ranges(struct lmk04832 *lmk, unsigned long rate) | |
424 | { | |
425 | struct spi_device *spi = to_spi_device(lmk->dev); | |
426 | const struct lmk04832_device_info *info; | |
427 | unsigned long mhz = rate / 1000000; | |
428 | ||
429 | info = &lmk04832_device_info[spi_get_device_id(spi)->driver_data]; | |
430 | ||
431 | if (mhz >= info->vco0_range[0] && mhz <= info->vco0_range[1]) | |
432 | return LMK04832_VAL_VCO_MUX_VCO0; | |
433 | ||
434 | if (mhz >= info->vco1_range[0] && mhz <= info->vco1_range[1]) | |
435 | return LMK04832_VAL_VCO_MUX_VCO1; | |
436 | ||
437 | dev_err(lmk->dev, "%lu Hz is out of VCO ranges\n", rate); | |
438 | return -ERANGE; | |
439 | } | |
440 | ||
441 | /** | |
442 | * lmk04832_calc_pll2_params - Get PLL2 parameters used to set the VCO frequency | |
443 | * | |
444 | * @prate: parent rate to the PLL2, usually OSCin | |
445 | * @rate: Desired output rate for the VCO | |
446 | * @n: reference to PLL2_N | |
447 | * @p: reference to PLL2_P | |
448 | * @r: reference to PLL2_R | |
449 | * | |
450 | * This functions assumes LMK04832_BIT_PLL2_MISC_REF_2X_EN is set since it is | |
451 | * recommended in the datasheet because a higher phase detector frequencies | |
452 | * makes the design of wider loop bandwidth filters possible. | |
453 | * | |
454 | * the VCO rate can be calculated using the following expression: | |
455 | * | |
456 | * VCO = OSCin * 2 * PLL2_N * PLL2_P / PLL2_R | |
457 | * | |
40b85eec | 458 | * Returns: vco rate or negative errno. |
3bc61cfd LB |
459 | */ |
460 | static long lmk04832_calc_pll2_params(unsigned long prate, unsigned long rate, | |
461 | unsigned int *n, unsigned int *p, | |
462 | unsigned int *r) | |
463 | { | |
464 | unsigned int pll2_n, pll2_p, pll2_r; | |
465 | unsigned long num, div; | |
466 | ||
467 | /* Set PLL2_P to a fixed value to simplify optimizations */ | |
468 | pll2_p = 2; | |
469 | ||
470 | div = gcd(rate, prate); | |
471 | ||
472 | num = DIV_ROUND_CLOSEST(rate, div); | |
473 | pll2_r = DIV_ROUND_CLOSEST(prate, div); | |
474 | ||
475 | if (num > 4) { | |
476 | pll2_n = num >> 2; | |
477 | } else { | |
478 | pll2_r = pll2_r << 2; | |
479 | pll2_n = num; | |
480 | } | |
481 | ||
482 | if (pll2_n < 1 || pll2_n > 0x03ffff) | |
483 | return -EINVAL; | |
484 | if (pll2_r < 1 || pll2_r > 0xfff) | |
485 | return -EINVAL; | |
486 | ||
487 | *n = pll2_n; | |
488 | *p = pll2_p; | |
489 | *r = pll2_r; | |
490 | ||
491 | return DIV_ROUND_CLOSEST(prate * 2 * pll2_p * pll2_n, pll2_r); | |
492 | } | |
493 | ||
494 | static long lmk04832_vco_round_rate(struct clk_hw *hw, unsigned long rate, | |
495 | unsigned long *prate) | |
496 | { | |
497 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, vco); | |
498 | unsigned int n, p, r; | |
499 | long vco_rate; | |
500 | int ret; | |
501 | ||
502 | ret = lmk04832_check_vco_ranges(lmk, rate); | |
503 | if (ret < 0) | |
504 | return ret; | |
505 | ||
506 | vco_rate = lmk04832_calc_pll2_params(*prate, rate, &n, &p, &r); | |
507 | if (vco_rate < 0) { | |
2cdee50e | 508 | dev_err(lmk->dev, "PLL2 parameters out of range\n"); |
3bc61cfd LB |
509 | return vco_rate; |
510 | } | |
511 | ||
512 | if (rate != vco_rate) | |
513 | return -EINVAL; | |
514 | ||
515 | return vco_rate; | |
992a3552 | 516 | } |
3bc61cfd LB |
517 | |
518 | static int lmk04832_vco_set_rate(struct clk_hw *hw, unsigned long rate, | |
519 | unsigned long prate) | |
520 | { | |
521 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, vco); | |
522 | unsigned int n, p, r; | |
523 | long vco_rate; | |
524 | int vco_mux; | |
525 | int ret; | |
526 | ||
527 | vco_mux = lmk04832_check_vco_ranges(lmk, rate); | |
528 | if (vco_mux < 0) | |
529 | return vco_mux; | |
530 | ||
531 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_VCO_OSCOUT, | |
532 | LMK04832_BIT_VCO_MUX, | |
533 | FIELD_PREP(LMK04832_BIT_VCO_MUX, vco_mux)); | |
534 | if (ret) | |
535 | return ret; | |
536 | ||
537 | vco_rate = lmk04832_calc_pll2_params(prate, rate, &n, &p, &r); | |
538 | if (vco_rate < 0) { | |
2cdee50e | 539 | dev_err(lmk->dev, "failed to determine PLL2 parameters\n"); |
3bc61cfd LB |
540 | return vco_rate; |
541 | } | |
542 | ||
543 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_PLL2_R_MSB, | |
544 | LMK04832_BIT_PLL2_R_MSB, | |
545 | FIELD_GET(0x000700, r)); | |
546 | if (ret) | |
547 | return ret; | |
548 | ||
549 | ret = regmap_write(lmk->regmap, LMK04832_REG_PLL2_R_LSB, | |
550 | FIELD_GET(0x0000ff, r)); | |
551 | if (ret) | |
552 | return ret; | |
553 | ||
554 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_PLL2_MISC, | |
555 | LMK04832_BIT_PLL2_MISC_P, | |
556 | FIELD_PREP(LMK04832_BIT_PLL2_MISC_P, p)); | |
557 | if (ret) | |
558 | return ret; | |
559 | ||
560 | /* | |
561 | * PLL2_N registers must be programmed after other PLL2 dividers are | |
2cdee50e | 562 | * programmed to ensure proper VCO frequency calibration |
3bc61cfd LB |
563 | */ |
564 | ret = regmap_write(lmk->regmap, LMK04832_REG_PLL2_N_0, | |
565 | FIELD_GET(0x030000, n)); | |
566 | if (ret) | |
567 | return ret; | |
568 | ret = regmap_write(lmk->regmap, LMK04832_REG_PLL2_N_1, | |
569 | FIELD_GET(0x00ff00, n)); | |
570 | if (ret) | |
571 | return ret; | |
572 | ||
573 | return regmap_write(lmk->regmap, LMK04832_REG_PLL2_N_2, | |
574 | FIELD_GET(0x0000ff, n)); | |
992a3552 | 575 | } |
3bc61cfd LB |
576 | |
577 | static const struct clk_ops lmk04832_vco_ops = { | |
578 | .is_enabled = lmk04832_vco_is_enabled, | |
579 | .prepare = lmk04832_vco_prepare, | |
580 | .unprepare = lmk04832_vco_unprepare, | |
581 | .recalc_rate = lmk04832_vco_recalc_rate, | |
582 | .round_rate = lmk04832_vco_round_rate, | |
583 | .set_rate = lmk04832_vco_set_rate, | |
584 | }; | |
585 | ||
586 | /* | |
587 | * lmk04832_register_vco - Initialize the internal VCO and clock distribution | |
588 | * path in PLL2 single loop mode. | |
589 | */ | |
590 | static int lmk04832_register_vco(struct lmk04832 *lmk) | |
591 | { | |
592 | const char *parent_names[1]; | |
593 | struct clk_init_data init; | |
594 | int ret; | |
595 | ||
596 | init.name = "lmk-vco"; | |
597 | parent_names[0] = __clk_get_name(lmk->oscin); | |
598 | init.parent_names = parent_names; | |
599 | ||
600 | init.ops = &lmk04832_vco_ops; | |
601 | init.num_parents = 1; | |
602 | ||
603 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_VCO_OSCOUT, | |
604 | LMK04832_BIT_VCO_MUX, | |
605 | FIELD_PREP(LMK04832_BIT_VCO_MUX, | |
606 | LMK04832_VAL_VCO_MUX_VCO1)); | |
607 | if (ret) | |
608 | return ret; | |
609 | ||
610 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_FB_CTRL, | |
611 | LMK04832_BIT_PLL2_RCLK_MUX | | |
612 | LMK04832_BIT_PLL2_NCLK_MUX, | |
613 | FIELD_PREP(LMK04832_BIT_PLL2_RCLK_MUX, | |
614 | LMK04832_VAL_PLL2_RCLK_MUX_OSCIN)| | |
615 | FIELD_PREP(LMK04832_BIT_PLL2_NCLK_MUX, | |
616 | LMK04832_VAL_PLL2_NCLK_MUX_PLL2_P)); | |
617 | if (ret) | |
618 | return ret; | |
619 | ||
620 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_PLL2_MISC, | |
621 | LMK04832_BIT_PLL2_MISC_REF_2X_EN, | |
622 | LMK04832_BIT_PLL2_MISC_REF_2X_EN); | |
623 | if (ret) | |
624 | return ret; | |
625 | ||
626 | ret = regmap_write(lmk->regmap, LMK04832_REG_PLL2_LD, | |
627 | FIELD_PREP(LMK04832_BIT_PLL2_LD_MUX, | |
628 | LMK04832_VAL_PLL2_LD_MUX_PLL2_DLD) | | |
629 | FIELD_PREP(LMK04832_BIT_PLL2_LD_TYPE, | |
630 | LMK04832_VAL_PLL2_LD_TYPE_OUT_PP)); | |
631 | if (ret) | |
632 | return ret; | |
633 | ||
634 | lmk->vco.init = &init; | |
635 | return devm_clk_hw_register(lmk->dev, &lmk->vco); | |
636 | } | |
637 | ||
6181baa1 LB |
638 | static int lmk04832_clkout_set_ddly(struct lmk04832 *lmk, int id) |
639 | { | |
6c634446 | 640 | const int dclk_div_adj[] = {0, 0, -2, -2, 0, 3, -1, 0}; |
6181baa1 LB |
641 | unsigned int sclkx_y_ddly = 10; |
642 | unsigned int dclkx_y_ddly; | |
643 | unsigned int dclkx_y_div; | |
644 | unsigned int sysref_ddly; | |
645 | unsigned int dclkx_y_hs; | |
646 | unsigned int lsb, msb; | |
647 | int ret; | |
648 | ||
649 | ret = regmap_update_bits(lmk->regmap, | |
650 | LMK04832_REG_CLKOUT_CTRL2(id), | |
651 | LMK04832_BIT_DCLKX_Y_DDLY_PD, | |
652 | FIELD_PREP(LMK04832_BIT_DCLKX_Y_DDLY_PD, 0)); | |
653 | if (ret) | |
654 | return ret; | |
655 | ||
656 | ret = regmap_read(lmk->regmap, LMK04832_REG_SYSREF_DDLY_LSB, &lsb); | |
657 | if (ret) | |
658 | return ret; | |
659 | ||
660 | ret = regmap_read(lmk->regmap, LMK04832_REG_SYSREF_DDLY_MSB, &msb); | |
661 | if (ret) | |
662 | return ret; | |
663 | ||
664 | sysref_ddly = FIELD_GET(LMK04832_BIT_SYSREF_DDLY_MSB, msb) << 8 | lsb; | |
665 | ||
666 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_CTRL0(id), &lsb); | |
667 | if (ret) | |
668 | return ret; | |
669 | ||
670 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_CTRL2(id), &msb); | |
671 | if (ret) | |
672 | return ret; | |
673 | ||
674 | dclkx_y_div = FIELD_GET(LMK04832_BIT_DCLK_DIV_MSB, msb) << 8 | lsb; | |
675 | ||
676 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_CTRL3(id), &lsb); | |
677 | if (ret) | |
678 | return ret; | |
679 | ||
680 | dclkx_y_hs = FIELD_GET(LMK04832_BIT_DCLKX_Y_HS, lsb); | |
681 | ||
682 | dclkx_y_ddly = sysref_ddly + 1 - | |
683 | dclk_div_adj[dclkx_y_div < 6 ? dclkx_y_div : 7] - | |
684 | dclkx_y_hs + sclkx_y_ddly; | |
685 | ||
686 | if (dclkx_y_ddly < 7 || dclkx_y_ddly > 0x3fff) { | |
687 | dev_err(lmk->dev, "DCLKX_Y_DDLY out of range (%d)\n", | |
688 | dclkx_y_ddly); | |
689 | return -EINVAL; | |
690 | } | |
691 | ||
692 | ret = regmap_write(lmk->regmap, | |
693 | LMK04832_REG_SCLKX_Y_DDLY(id), | |
694 | FIELD_GET(LMK04832_BIT_SCLKX_Y_DDLY, sclkx_y_ddly)); | |
695 | if (ret) | |
696 | return ret; | |
697 | ||
698 | ret = regmap_write(lmk->regmap, LMK04832_REG_CLKOUT_CTRL1(id), | |
699 | FIELD_GET(0x00ff, dclkx_y_ddly)); | |
700 | if (ret) | |
701 | return ret; | |
702 | ||
703 | dev_dbg(lmk->dev, "clkout%02u: sysref_ddly=%u, dclkx_y_ddly=%u, " | |
704 | "dclk_div_adj=%+d, dclkx_y_hs=%u, sclkx_y_ddly=%u\n", | |
705 | id, sysref_ddly, dclkx_y_ddly, | |
706 | dclk_div_adj[dclkx_y_div < 6 ? dclkx_y_div : 7], | |
707 | dclkx_y_hs, sclkx_y_ddly); | |
708 | ||
709 | return regmap_update_bits(lmk->regmap, LMK04832_REG_CLKOUT_CTRL2(id), | |
710 | LMK04832_BIT_DCLKX_Y_DDLY_MSB, | |
711 | FIELD_GET(0x0300, dclkx_y_ddly)); | |
712 | } | |
713 | ||
714 | /** lmk04832_sclk_sync - Establish deterministic phase relationship between sclk | |
715 | * and dclk | |
716 | * | |
717 | * @lmk: Reference to the lmk device | |
718 | * | |
719 | * The synchronization sequence: | |
720 | * - in the datasheet https://www.ti.com/lit/ds/symlink/lmk04832.pdf, p.31 | |
721 | * (8.3.3.1 How to enable SYSREF) | |
722 | * - Ti forum: https://e2e.ti.com/support/clock-and-timing/f/48/t/970972 | |
723 | * | |
724 | * Returns 0 or negative errno. | |
725 | */ | |
726 | static int lmk04832_sclk_sync_sequence(struct lmk04832 *lmk) | |
727 | { | |
728 | int ret; | |
729 | int i; | |
730 | ||
731 | /* 1. (optional) mute all sysref_outputs during synchronization */ | |
732 | /* 2. Enable and write device clock digital delay to applicable clocks */ | |
733 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_MAIN_PD, | |
734 | LMK04832_BIT_SYSREF_DDLY_PD, | |
735 | FIELD_PREP(LMK04832_BIT_SYSREF_DDLY_PD, 0)); | |
736 | if (ret) | |
737 | return ret; | |
738 | ||
739 | for (i = 0; i < lmk->clk_data->num; i += 2) { | |
740 | ret = lmk04832_clkout_set_ddly(lmk, i); | |
741 | if (ret) | |
742 | return ret; | |
743 | } | |
744 | ||
745 | /* | |
746 | * 3. Configure SYNC_MODE to SYNC_PIN and SYSREF_MUX to Normal SYNC, | |
747 | * and clear SYSREF_REQ_EN (see 6.) | |
748 | */ | |
749 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_SYSREF_OUT, | |
750 | LMK04832_BIT_SYSREF_REQ_EN | | |
751 | LMK04832_BIT_SYSREF_MUX, | |
752 | FIELD_PREP(LMK04832_BIT_SYSREF_REQ_EN, 0) | | |
753 | FIELD_PREP(LMK04832_BIT_SYSREF_MUX, | |
754 | LMK04832_VAL_SYSREF_MUX_NORMAL_SYNC)); | |
755 | if (ret) | |
756 | return ret; | |
757 | ||
758 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_SYNC, | |
759 | LMK04832_BIT_SYNC_MODE, | |
760 | FIELD_PREP(LMK04832_BIT_SYNC_MODE, | |
761 | LMK04832_VAL_SYNC_MODE_ON)); | |
762 | if (ret) | |
763 | return ret; | |
764 | ||
765 | /* 4. Clear SYNXC_DISx or applicable clocks and clear SYNC_DISSYSREF */ | |
766 | ret = regmap_write(lmk->regmap, LMK04832_REG_SYNC_DIS, 0x00); | |
767 | if (ret) | |
768 | return ret; | |
769 | ||
770 | /* | |
771 | * 5. If SCLKX_Y_DDLY != 0, Set SYSREF_CLR=1 for at least 15 clock | |
772 | * distribution path cycles (VCO cycles), then back to 0. In | |
773 | * PLL2-only use case, this will be complete in less than one SPI | |
774 | * transaction. If SYSREF local digital delay is not used, this step | |
775 | * can be skipped. | |
776 | */ | |
777 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_SYNC, | |
778 | LMK04832_BIT_SYNC_CLR, | |
779 | FIELD_PREP(LMK04832_BIT_SYNC_CLR, 0x01)); | |
780 | if (ret) | |
781 | return ret; | |
782 | ||
783 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_SYNC, | |
784 | LMK04832_BIT_SYNC_CLR, | |
785 | FIELD_PREP(LMK04832_BIT_SYNC_CLR, 0x00)); | |
786 | if (ret) | |
787 | return ret; | |
788 | ||
789 | /* | |
790 | * 6. Toggle SYNC_POL state between inverted and not inverted. | |
791 | * If you use an external signal on the SYNC pin instead of toggling | |
792 | * SYNC_POL, make sure that SYSREF_REQ_EN=0 so that the SYSREF_MUX | |
793 | * does not shift into continuous SYSREF mode. | |
794 | */ | |
795 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_SYNC, | |
796 | LMK04832_BIT_SYNC_POL, | |
797 | FIELD_PREP(LMK04832_BIT_SYNC_POL, 0x01)); | |
798 | if (ret) | |
799 | return ret; | |
800 | ||
801 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_SYNC, | |
802 | LMK04832_BIT_SYNC_POL, | |
803 | FIELD_PREP(LMK04832_BIT_SYNC_POL, 0x00)); | |
804 | if (ret) | |
805 | return ret; | |
806 | ||
807 | /* 7. Set all SYNC_DISx=1, including SYNC_DISSYSREF */ | |
808 | ret = regmap_write(lmk->regmap, LMK04832_REG_SYNC_DIS, 0xff); | |
809 | if (ret) | |
810 | return ret; | |
811 | ||
812 | /* 8. Restore state of SYNC_MODE and SYSREF_MUX to desired values */ | |
813 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_SYSREF_OUT, | |
814 | LMK04832_BIT_SYSREF_MUX, | |
815 | FIELD_PREP(LMK04832_BIT_SYSREF_MUX, | |
816 | lmk->sysref_mux)); | |
817 | if (ret) | |
818 | return ret; | |
819 | ||
820 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_SYNC, | |
821 | LMK04832_BIT_SYNC_MODE, | |
822 | FIELD_PREP(LMK04832_BIT_SYNC_MODE, | |
823 | lmk->sync_mode)); | |
824 | if (ret) | |
825 | return ret; | |
826 | ||
827 | /* | |
828 | * 9. (optional) if SCLKx_y_DIS_MODE was used to mute SYSREF outputs | |
829 | * during the SYNC event, restore SCLKx_y_DIS_MODE=0 for active state, | |
830 | * or set SYSREF_GBL_PD=0 if SCLKx_y_DIS_MODE is set to a conditional | |
831 | * option. | |
832 | */ | |
833 | ||
834 | /* | |
835 | * 10. (optional) To reduce power consumption, after the synchronization | |
836 | * event is complete, DCLKx_y_DDLY_PD=1 and SYSREF_DDLY_PD=1 disable the | |
837 | * digital delay counters (which are only used immediately after the | |
838 | * SYNC pulse to delay the output by some number of VCO counts). | |
839 | */ | |
840 | ||
841 | return ret; | |
842 | } | |
843 | ||
3bc61cfd LB |
844 | static int lmk04832_sclk_is_enabled(struct clk_hw *hw) |
845 | { | |
846 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, sclk); | |
847 | unsigned int tmp; | |
848 | int ret; | |
849 | ||
850 | ret = regmap_read(lmk->regmap, LMK04832_REG_MAIN_PD, &tmp); | |
851 | if (ret) | |
852 | return ret; | |
853 | ||
854 | return FIELD_GET(LMK04832_BIT_SYSREF_PD, tmp); | |
855 | } | |
856 | ||
857 | static int lmk04832_sclk_prepare(struct clk_hw *hw) | |
858 | { | |
859 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, sclk); | |
860 | ||
861 | return regmap_update_bits(lmk->regmap, LMK04832_REG_MAIN_PD, | |
862 | LMK04832_BIT_SYSREF_PD, 0x00); | |
863 | } | |
864 | ||
865 | static void lmk04832_sclk_unprepare(struct clk_hw *hw) | |
866 | { | |
867 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, sclk); | |
868 | ||
869 | regmap_update_bits(lmk->regmap, LMK04832_REG_MAIN_PD, | |
870 | LMK04832_BIT_SYSREF_PD, LMK04832_BIT_SYSREF_PD); | |
871 | } | |
872 | ||
873 | static unsigned long lmk04832_sclk_recalc_rate(struct clk_hw *hw, | |
874 | unsigned long prate) | |
875 | { | |
876 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, sclk); | |
877 | unsigned int sysref_div; | |
878 | u8 tmp[2]; | |
879 | int ret; | |
880 | ||
881 | ret = regmap_bulk_read(lmk->regmap, LMK04832_REG_SYSREF_DIV_MSB, &tmp, 2); | |
882 | if (ret) | |
883 | return ret; | |
884 | ||
885 | sysref_div = FIELD_GET(LMK04832_BIT_SYSREF_DIV_MSB, tmp[0]) << 8 | | |
886 | tmp[1]; | |
887 | ||
888 | return DIV_ROUND_CLOSEST(prate, sysref_div); | |
889 | } | |
890 | ||
891 | static long lmk04832_sclk_round_rate(struct clk_hw *hw, unsigned long rate, | |
892 | unsigned long *prate) | |
893 | { | |
894 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, sclk); | |
895 | unsigned long sclk_rate; | |
896 | unsigned int sysref_div; | |
897 | ||
898 | sysref_div = DIV_ROUND_CLOSEST(*prate, rate); | |
899 | sclk_rate = DIV_ROUND_CLOSEST(*prate, sysref_div); | |
900 | ||
901 | if (sysref_div < 0x07 || sysref_div > 0x1fff) { | |
902 | dev_err(lmk->dev, "SYSREF divider out of range\n"); | |
903 | return -EINVAL; | |
904 | } | |
905 | ||
906 | if (rate != sclk_rate) | |
907 | return -EINVAL; | |
908 | ||
909 | return sclk_rate; | |
910 | } | |
911 | ||
912 | static int lmk04832_sclk_set_rate(struct clk_hw *hw, unsigned long rate, | |
913 | unsigned long prate) | |
914 | { | |
915 | struct lmk04832 *lmk = container_of(hw, struct lmk04832, sclk); | |
916 | unsigned int sysref_div; | |
917 | int ret; | |
918 | ||
919 | sysref_div = DIV_ROUND_CLOSEST(prate, rate); | |
920 | ||
921 | if (sysref_div < 0x07 || sysref_div > 0x1fff) { | |
922 | dev_err(lmk->dev, "SYSREF divider out of range\n"); | |
923 | return -EINVAL; | |
924 | } | |
925 | ||
926 | ret = regmap_write(lmk->regmap, LMK04832_REG_SYSREF_DIV_MSB, | |
927 | FIELD_GET(0x1f00, sysref_div)); | |
928 | if (ret) | |
929 | return ret; | |
930 | ||
6181baa1 | 931 | ret = regmap_write(lmk->regmap, LMK04832_REG_SYSREF_DIV_LSB, |
3bc61cfd | 932 | FIELD_GET(0x00ff, sysref_div)); |
6181baa1 LB |
933 | if (ret) |
934 | return ret; | |
935 | ||
936 | ret = lmk04832_sclk_sync_sequence(lmk); | |
937 | if (ret) | |
938 | dev_err(lmk->dev, "SYNC sequence failed\n"); | |
939 | ||
940 | return ret; | |
3bc61cfd LB |
941 | } |
942 | ||
943 | static const struct clk_ops lmk04832_sclk_ops = { | |
944 | .is_enabled = lmk04832_sclk_is_enabled, | |
945 | .prepare = lmk04832_sclk_prepare, | |
946 | .unprepare = lmk04832_sclk_unprepare, | |
947 | .recalc_rate = lmk04832_sclk_recalc_rate, | |
948 | .round_rate = lmk04832_sclk_round_rate, | |
949 | .set_rate = lmk04832_sclk_set_rate, | |
950 | }; | |
951 | ||
952 | static int lmk04832_register_sclk(struct lmk04832 *lmk) | |
953 | { | |
954 | const char *parent_names[1]; | |
955 | struct clk_init_data init; | |
956 | int ret; | |
957 | ||
958 | init.name = "lmk-sclk"; | |
959 | parent_names[0] = clk_hw_get_name(&lmk->vco); | |
960 | init.parent_names = parent_names; | |
961 | ||
962 | init.ops = &lmk04832_sclk_ops; | |
963 | init.flags = CLK_SET_RATE_PARENT; | |
964 | init.num_parents = 1; | |
965 | ||
966 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_SYSREF_OUT, | |
967 | LMK04832_BIT_SYSREF_MUX, | |
968 | FIELD_PREP(LMK04832_BIT_SYSREF_MUX, | |
6181baa1 LB |
969 | lmk->sysref_mux)); |
970 | if (ret) | |
971 | return ret; | |
972 | ||
973 | ret = regmap_write(lmk->regmap, LMK04832_REG_SYSREF_DDLY_LSB, | |
974 | FIELD_GET(0x00ff, lmk->sysref_ddly)); | |
975 | if (ret) | |
976 | return ret; | |
977 | ||
978 | ret = regmap_write(lmk->regmap, LMK04832_REG_SYSREF_DDLY_MSB, | |
979 | FIELD_GET(0x1f00, lmk->sysref_ddly)); | |
980 | if (ret) | |
981 | return ret; | |
982 | ||
983 | ret = regmap_write(lmk->regmap, LMK04832_REG_SYSREF_PULSE_CNT, | |
984 | ilog2(lmk->sysref_pulse_cnt)); | |
3bc61cfd LB |
985 | if (ret) |
986 | return ret; | |
987 | ||
988 | ret = regmap_update_bits(lmk->regmap, LMK04832_REG_MAIN_PD, | |
6181baa1 | 989 | LMK04832_BIT_SYSREF_DDLY_PD | |
3bc61cfd | 990 | LMK04832_BIT_SYSREF_PLSR_PD, |
6181baa1 LB |
991 | FIELD_PREP(LMK04832_BIT_SYSREF_DDLY_PD, 0) | |
992 | FIELD_PREP(LMK04832_BIT_SYSREF_PLSR_PD, 0)); | |
3bc61cfd LB |
993 | if (ret) |
994 | return ret; | |
995 | ||
6181baa1 LB |
996 | ret = regmap_write(lmk->regmap, LMK04832_REG_SYNC, |
997 | FIELD_PREP(LMK04832_BIT_SYNC_POL, 0) | | |
998 | FIELD_PREP(LMK04832_BIT_SYNC_EN, 1) | | |
999 | FIELD_PREP(LMK04832_BIT_SYNC_MODE, lmk->sync_mode)); | |
3bc61cfd LB |
1000 | if (ret) |
1001 | return ret; | |
1002 | ||
1003 | ret = regmap_write(lmk->regmap, LMK04832_REG_SYNC_DIS, 0xff); | |
1004 | if (ret) | |
1005 | return ret; | |
1006 | ||
1007 | lmk->sclk.init = &init; | |
1008 | return devm_clk_hw_register(lmk->dev, &lmk->sclk); | |
1009 | } | |
1010 | ||
1011 | static int lmk04832_dclk_is_enabled(struct clk_hw *hw) | |
1012 | { | |
1013 | struct lmk_dclk *dclk = container_of(hw, struct lmk_dclk, hw); | |
1014 | struct lmk04832 *lmk = dclk->lmk; | |
1015 | unsigned int tmp; | |
1016 | int ret; | |
1017 | ||
1018 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_CTRL3(dclk->id), | |
1019 | &tmp); | |
1020 | if (ret) | |
1021 | return ret; | |
1022 | ||
1023 | return !FIELD_GET(LMK04832_BIT_DCLKX_Y_PD, tmp); | |
1024 | } | |
1025 | ||
1026 | static int lmk04832_dclk_prepare(struct clk_hw *hw) | |
1027 | { | |
1028 | struct lmk_dclk *dclk = container_of(hw, struct lmk_dclk, hw); | |
1029 | struct lmk04832 *lmk = dclk->lmk; | |
1030 | ||
1031 | return regmap_update_bits(lmk->regmap, | |
1032 | LMK04832_REG_CLKOUT_CTRL3(dclk->id), | |
1033 | LMK04832_BIT_DCLKX_Y_PD, 0x00); | |
1034 | } | |
1035 | ||
1036 | static void lmk04832_dclk_unprepare(struct clk_hw *hw) | |
1037 | { | |
1038 | struct lmk_dclk *dclk = container_of(hw, struct lmk_dclk, hw); | |
1039 | struct lmk04832 *lmk = dclk->lmk; | |
1040 | ||
1041 | regmap_update_bits(lmk->regmap, | |
1042 | LMK04832_REG_CLKOUT_CTRL3(dclk->id), | |
1043 | LMK04832_BIT_DCLKX_Y_PD, 0xff); | |
1044 | } | |
1045 | ||
1046 | static unsigned long lmk04832_dclk_recalc_rate(struct clk_hw *hw, | |
1047 | unsigned long prate) | |
1048 | { | |
1049 | struct lmk_dclk *dclk = container_of(hw, struct lmk_dclk, hw); | |
1050 | struct lmk04832 *lmk = dclk->lmk; | |
1051 | unsigned int dclk_div; | |
1052 | unsigned int lsb, msb; | |
1053 | unsigned long rate; | |
1054 | int ret; | |
1055 | ||
1056 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_CTRL0(dclk->id), | |
1057 | &lsb); | |
1058 | if (ret) | |
1059 | return ret; | |
1060 | ||
1061 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_CTRL2(dclk->id), | |
1062 | &msb); | |
1063 | if (ret) | |
1064 | return ret; | |
1065 | ||
1066 | dclk_div = FIELD_GET(LMK04832_BIT_DCLK_DIV_MSB, msb) << 8 | lsb; | |
1067 | rate = DIV_ROUND_CLOSEST(prate, dclk_div); | |
1068 | ||
1069 | return rate; | |
992a3552 | 1070 | } |
3bc61cfd LB |
1071 | |
1072 | static long lmk04832_dclk_round_rate(struct clk_hw *hw, unsigned long rate, | |
1073 | unsigned long *prate) | |
1074 | { | |
1075 | struct lmk_dclk *dclk = container_of(hw, struct lmk_dclk, hw); | |
1076 | struct lmk04832 *lmk = dclk->lmk; | |
1077 | unsigned long dclk_rate; | |
1078 | unsigned int dclk_div; | |
1079 | ||
1080 | dclk_div = DIV_ROUND_CLOSEST(*prate, rate); | |
1081 | dclk_rate = DIV_ROUND_CLOSEST(*prate, dclk_div); | |
1082 | ||
1083 | if (dclk_div < 1 || dclk_div > 0x3ff) { | |
1084 | dev_err(lmk->dev, "%s_div out of range\n", clk_hw_get_name(hw)); | |
1085 | return -EINVAL; | |
1086 | } | |
1087 | ||
1088 | if (rate != dclk_rate) | |
1089 | return -EINVAL; | |
1090 | ||
1091 | return dclk_rate; | |
992a3552 | 1092 | } |
3bc61cfd LB |
1093 | |
1094 | static int lmk04832_dclk_set_rate(struct clk_hw *hw, unsigned long rate, | |
1095 | unsigned long prate) | |
1096 | { | |
1097 | struct lmk_dclk *dclk = container_of(hw, struct lmk_dclk, hw); | |
1098 | struct lmk04832 *lmk = dclk->lmk; | |
1099 | unsigned int dclk_div; | |
1100 | int ret; | |
1101 | ||
1102 | dclk_div = DIV_ROUND_CLOSEST(prate, rate); | |
1103 | ||
1104 | if (dclk_div > 0x3ff) { | |
1105 | dev_err(lmk->dev, "%s_div out of range\n", clk_hw_get_name(hw)); | |
1106 | return -EINVAL; | |
1107 | } | |
1108 | ||
2cdee50e | 1109 | /* Enable Duty Cycle Correction */ |
3bc61cfd LB |
1110 | if (dclk_div == 1) { |
1111 | ret = regmap_update_bits(lmk->regmap, | |
1112 | LMK04832_REG_CLKOUT_CTRL3(dclk->id), | |
1113 | LMK04832_BIT_DCLKX_Y_DCC, | |
1114 | FIELD_PREP(LMK04832_BIT_DCLKX_Y_DCC, 1)); | |
1115 | if (ret) | |
1116 | return ret; | |
1117 | } | |
1118 | ||
6181baa1 LB |
1119 | /* |
1120 | * While using Divide-by-2 or Divide-by-3 for DCLK_X_Y_DIV, SYNC | |
1121 | * procedure requires to first program Divide-by-4 and then back to | |
1122 | * Divide-by-2 or Divide-by-3 before doing SYNC. | |
1123 | */ | |
1124 | if (dclk_div == 2 || dclk_div == 3) { | |
1125 | ret = regmap_update_bits(lmk->regmap, | |
1126 | LMK04832_REG_CLKOUT_CTRL2(dclk->id), | |
1127 | LMK04832_BIT_DCLK_DIV_MSB, 0x00); | |
1128 | if (ret) | |
1129 | return ret; | |
1130 | ||
1131 | ret = regmap_write(lmk->regmap, | |
1132 | LMK04832_REG_CLKOUT_CTRL0(dclk->id), 0x04); | |
1133 | if (ret) | |
1134 | return ret; | |
1135 | } | |
1136 | ||
3bc61cfd LB |
1137 | ret = regmap_write(lmk->regmap, LMK04832_REG_CLKOUT_CTRL0(dclk->id), |
1138 | FIELD_GET(0x0ff, dclk_div)); | |
1139 | if (ret) | |
1140 | return ret; | |
1141 | ||
6181baa1 | 1142 | ret = regmap_update_bits(lmk->regmap, |
3bc61cfd LB |
1143 | LMK04832_REG_CLKOUT_CTRL2(dclk->id), |
1144 | LMK04832_BIT_DCLK_DIV_MSB, | |
1145 | FIELD_GET(0x300, dclk_div)); | |
6181baa1 LB |
1146 | if (ret) |
1147 | return ret; | |
1148 | ||
1149 | ret = lmk04832_sclk_sync_sequence(lmk); | |
1150 | if (ret) | |
1151 | dev_err(lmk->dev, "SYNC sequence failed\n"); | |
1152 | ||
1153 | return ret; | |
992a3552 | 1154 | } |
3bc61cfd LB |
1155 | |
1156 | static const struct clk_ops lmk04832_dclk_ops = { | |
1157 | .is_enabled = lmk04832_dclk_is_enabled, | |
1158 | .prepare = lmk04832_dclk_prepare, | |
1159 | .unprepare = lmk04832_dclk_unprepare, | |
1160 | .recalc_rate = lmk04832_dclk_recalc_rate, | |
1161 | .round_rate = lmk04832_dclk_round_rate, | |
1162 | .set_rate = lmk04832_dclk_set_rate, | |
1163 | }; | |
1164 | ||
1165 | static int lmk04832_clkout_is_enabled(struct clk_hw *hw) | |
1166 | { | |
1167 | struct lmk_clkout *clkout = container_of(hw, struct lmk_clkout, hw); | |
1168 | struct lmk04832 *lmk = clkout->lmk; | |
1169 | unsigned int clkoutx_y_pd; | |
1170 | unsigned int sclkx_y_pd; | |
1171 | unsigned int tmp; | |
1172 | u32 enabled; | |
1173 | int ret; | |
1174 | u8 fmt; | |
1175 | ||
1176 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_CTRL2(clkout->id), | |
1177 | &clkoutx_y_pd); | |
1178 | if (ret) | |
1179 | return ret; | |
1180 | ||
1181 | enabled = !FIELD_GET(LMK04832_BIT_CLKOUTX_Y_PD, clkoutx_y_pd); | |
1182 | ||
1183 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_SRC_MUX(clkout->id), | |
1184 | &tmp); | |
1185 | if (ret) | |
1186 | return ret; | |
1187 | ||
1188 | if (FIELD_GET(LMK04832_BIT_CLKOUT_SRC_MUX, tmp)) { | |
1189 | ret = regmap_read(lmk->regmap, | |
1190 | LMK04832_REG_CLKOUT_CTRL4(clkout->id), | |
1191 | &sclkx_y_pd); | |
1192 | if (ret) | |
1193 | return ret; | |
1194 | ||
1195 | enabled = enabled && !FIELD_GET(LMK04832_BIT_SCLK_PD, sclkx_y_pd); | |
1196 | } | |
1197 | ||
1198 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_FMT(clkout->id), | |
1199 | &tmp); | |
1200 | if (ret) | |
1201 | return ret; | |
1202 | ||
1203 | if (clkout->id % 2) | |
1204 | fmt = FIELD_GET(0xf0, tmp); | |
1205 | else | |
1206 | fmt = FIELD_GET(0x0f, tmp); | |
1207 | ||
1208 | return enabled && !fmt; | |
1209 | } | |
1210 | ||
1211 | static int lmk04832_clkout_prepare(struct clk_hw *hw) | |
1212 | { | |
1213 | struct lmk_clkout *clkout = container_of(hw, struct lmk_clkout, hw); | |
1214 | struct lmk04832 *lmk = clkout->lmk; | |
1215 | unsigned int tmp; | |
1216 | int ret; | |
1217 | ||
1218 | if (clkout->format == LMK04832_VAL_CLKOUT_FMT_POWERDOWN) | |
1219 | dev_err(lmk->dev, "prepared %s but format is powerdown\n", | |
1220 | clk_hw_get_name(hw)); | |
1221 | ||
1222 | ret = regmap_update_bits(lmk->regmap, | |
1223 | LMK04832_REG_CLKOUT_CTRL2(clkout->id), | |
1224 | LMK04832_BIT_CLKOUTX_Y_PD, 0x00); | |
1225 | if (ret) | |
1226 | return ret; | |
1227 | ||
1228 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_SRC_MUX(clkout->id), | |
1229 | &tmp); | |
1230 | if (ret) | |
1231 | return ret; | |
1232 | ||
1233 | if (FIELD_GET(LMK04832_BIT_CLKOUT_SRC_MUX, tmp)) { | |
1234 | ret = regmap_update_bits(lmk->regmap, | |
1235 | LMK04832_REG_CLKOUT_CTRL4(clkout->id), | |
1236 | LMK04832_BIT_SCLK_PD, 0x00); | |
1237 | if (ret) | |
1238 | return ret; | |
1239 | } | |
1240 | ||
1241 | return regmap_update_bits(lmk->regmap, | |
1242 | LMK04832_REG_CLKOUT_FMT(clkout->id), | |
1243 | LMK04832_BIT_CLKOUT_FMT(clkout->id), | |
1244 | clkout->format << 4 * (clkout->id % 2)); | |
1245 | } | |
1246 | ||
1247 | static void lmk04832_clkout_unprepare(struct clk_hw *hw) | |
1248 | { | |
1249 | struct lmk_clkout *clkout = container_of(hw, struct lmk_clkout, hw); | |
1250 | struct lmk04832 *lmk = clkout->lmk; | |
1251 | ||
1252 | regmap_update_bits(lmk->regmap, LMK04832_REG_CLKOUT_FMT(clkout->id), | |
1253 | LMK04832_BIT_CLKOUT_FMT(clkout->id), | |
1254 | 0x00); | |
1255 | } | |
1256 | ||
1257 | static int lmk04832_clkout_set_parent(struct clk_hw *hw, uint8_t index) | |
1258 | { | |
1259 | struct lmk_clkout *clkout = container_of(hw, struct lmk_clkout, hw); | |
1260 | struct lmk04832 *lmk = clkout->lmk; | |
1261 | ||
1262 | return regmap_update_bits(lmk->regmap, | |
1263 | LMK04832_REG_CLKOUT_SRC_MUX(clkout->id), | |
1264 | LMK04832_BIT_CLKOUT_SRC_MUX, | |
1265 | FIELD_PREP(LMK04832_BIT_CLKOUT_SRC_MUX, | |
1266 | index)); | |
1267 | } | |
1268 | ||
1269 | static uint8_t lmk04832_clkout_get_parent(struct clk_hw *hw) | |
1270 | { | |
1271 | struct lmk_clkout *clkout = container_of(hw, struct lmk_clkout, hw); | |
1272 | struct lmk04832 *lmk = clkout->lmk; | |
1273 | unsigned int tmp; | |
1274 | int ret; | |
1275 | ||
1276 | ret = regmap_read(lmk->regmap, LMK04832_REG_CLKOUT_SRC_MUX(clkout->id), | |
1277 | &tmp); | |
1278 | if (ret) | |
1279 | return ret; | |
1280 | ||
1281 | return FIELD_GET(LMK04832_BIT_CLKOUT_SRC_MUX, tmp); | |
1282 | } | |
1283 | ||
1284 | static const struct clk_ops lmk04832_clkout_ops = { | |
1285 | .is_enabled = lmk04832_clkout_is_enabled, | |
1286 | .prepare = lmk04832_clkout_prepare, | |
1287 | .unprepare = lmk04832_clkout_unprepare, | |
38bdfb21 | 1288 | .determine_rate = __clk_mux_determine_rate, |
3bc61cfd LB |
1289 | .set_parent = lmk04832_clkout_set_parent, |
1290 | .get_parent = lmk04832_clkout_get_parent, | |
1291 | }; | |
1292 | ||
1293 | static int lmk04832_register_clkout(struct lmk04832 *lmk, const int num) | |
1294 | { | |
1295 | char name[] = "lmk-clkoutXX"; | |
1296 | char dclk_name[] = "lmk-dclkXX_YY"; | |
1297 | const char *parent_names[2]; | |
1298 | struct clk_init_data init; | |
1299 | int dclk_num = num / 2; | |
1300 | int ret; | |
1301 | ||
1302 | if (num % 2 == 0) { | |
1303 | sprintf(dclk_name, "lmk-dclk%02d_%02d", num, num + 1); | |
1304 | init.name = dclk_name; | |
1305 | parent_names[0] = clk_hw_get_name(&lmk->vco); | |
f6d6c11f | 1306 | init.parent_names = parent_names; |
3bc61cfd LB |
1307 | init.ops = &lmk04832_dclk_ops; |
1308 | init.flags = CLK_SET_RATE_PARENT; | |
1309 | init.num_parents = 1; | |
1310 | ||
1311 | lmk->dclk[dclk_num].id = num; | |
1312 | lmk->dclk[dclk_num].lmk = lmk; | |
1313 | lmk->dclk[dclk_num].hw.init = &init; | |
1314 | ||
1315 | ret = devm_clk_hw_register(lmk->dev, &lmk->dclk[dclk_num].hw); | |
1316 | if (ret) | |
1317 | return ret; | |
1318 | } else { | |
1319 | sprintf(dclk_name, "lmk-dclk%02d_%02d", num - 1, num); | |
1320 | } | |
1321 | ||
1322 | if (of_property_read_string_index(lmk->dev->of_node, | |
1323 | "clock-output-names", | |
1324 | num, &init.name)) { | |
1325 | sprintf(name, "lmk-clkout%02d", num); | |
1326 | init.name = name; | |
1327 | } | |
1328 | ||
1329 | parent_names[0] = dclk_name; | |
1330 | parent_names[1] = clk_hw_get_name(&lmk->sclk); | |
1331 | init.parent_names = parent_names; | |
1332 | init.ops = &lmk04832_clkout_ops; | |
1333 | init.flags = CLK_SET_RATE_PARENT | CLK_SET_RATE_NO_REPARENT; | |
1334 | init.num_parents = ARRAY_SIZE(parent_names); | |
1335 | ||
1336 | lmk->clkout[num].id = num; | |
1337 | lmk->clkout[num].lmk = lmk; | |
1338 | lmk->clkout[num].hw.init = &init; | |
1339 | lmk->clk_data->hws[num] = &lmk->clkout[num].hw; | |
1340 | ||
1341 | /* Set initial parent */ | |
1342 | regmap_update_bits(lmk->regmap, | |
1343 | LMK04832_REG_CLKOUT_SRC_MUX(num), | |
1344 | LMK04832_BIT_CLKOUT_SRC_MUX, | |
1345 | FIELD_PREP(LMK04832_BIT_CLKOUT_SRC_MUX, | |
1346 | lmk->clkout[num].sysref)); | |
1347 | ||
1348 | return devm_clk_hw_register(lmk->dev, &lmk->clkout[num].hw); | |
1349 | } | |
1350 | ||
1351 | static int lmk04832_set_spi_rdbk(const struct lmk04832 *lmk, const int rdbk_pin) | |
1352 | { | |
1353 | int reg; | |
1354 | int ret; | |
6aa8dc69 ML |
1355 | int val = FIELD_PREP(LMK04832_BIT_CLKIN_SEL_MUX, |
1356 | LMK04832_VAL_CLKIN_SEL_MUX_SPI_RDBK) | | |
1357 | FIELD_PREP(LMK04832_BIT_CLKIN_SEL_TYPE, | |
1358 | LMK04832_VAL_CLKIN_SEL_TYPE_OUT); | |
3bc61cfd LB |
1359 | |
1360 | dev_info(lmk->dev, "setting up 4-wire mode\n"); | |
1361 | ret = regmap_write(lmk->regmap, LMK04832_REG_RST3W, | |
1362 | LMK04832_BIT_SPI_3WIRE_DIS); | |
1363 | if (ret) | |
1364 | return ret; | |
1365 | ||
1366 | switch (rdbk_pin) { | |
1367 | case RDBK_CLKIN_SEL0: | |
1368 | reg = LMK04832_REG_CLKIN_SEL0; | |
1369 | break; | |
1370 | case RDBK_CLKIN_SEL1: | |
1371 | reg = LMK04832_REG_CLKIN_SEL1; | |
1372 | break; | |
1373 | case RDBK_RESET: | |
1374 | reg = LMK04832_REG_CLKIN_RST; | |
1375 | break; | |
6aa8dc69 ML |
1376 | case RDBK_PLL1_LD: |
1377 | reg = LMK04832_REG_PLL1_LD; | |
1378 | val = FIELD_PREP(LMK04832_BIT_PLL1_LD_MUX, | |
1379 | LMK04832_VAL_PLL1_LD_MUX_SPI_RDBK) | | |
1380 | FIELD_PREP(LMK04832_BIT_PLL1_LD_TYPE, | |
1381 | LMK04832_VAL_PLL1_LD_TYPE_OUT_PP); | |
1382 | break; | |
3bc61cfd LB |
1383 | default: |
1384 | return -EINVAL; | |
1385 | } | |
1386 | ||
6aa8dc69 | 1387 | return regmap_write(lmk->regmap, reg, val); |
3bc61cfd LB |
1388 | } |
1389 | ||
1390 | static int lmk04832_probe(struct spi_device *spi) | |
1391 | { | |
1392 | const struct lmk04832_device_info *info; | |
1393 | int rdbk_pin = RDBK_CLKIN_SEL1; | |
1394 | struct device_node *child; | |
1395 | struct lmk04832 *lmk; | |
1396 | u8 tmp[3]; | |
1397 | int ret; | |
1398 | int i; | |
1399 | ||
1400 | info = &lmk04832_device_info[spi_get_device_id(spi)->driver_data]; | |
1401 | ||
1402 | lmk = devm_kzalloc(&spi->dev, sizeof(struct lmk04832), GFP_KERNEL); | |
1403 | if (!lmk) | |
1404 | return -ENOMEM; | |
1405 | ||
1406 | lmk->dev = &spi->dev; | |
1407 | ||
1408 | lmk->oscin = devm_clk_get(lmk->dev, "oscin"); | |
1409 | if (IS_ERR(lmk->oscin)) { | |
1410 | dev_err(lmk->dev, "failed to get oscin clock\n"); | |
1411 | return PTR_ERR(lmk->oscin); | |
1412 | } | |
1413 | ||
1414 | ret = clk_prepare_enable(lmk->oscin); | |
1415 | if (ret) | |
1416 | return ret; | |
1417 | ||
1418 | lmk->reset_gpio = devm_gpiod_get_optional(&spi->dev, "reset", | |
1419 | GPIOD_OUT_LOW); | |
1420 | ||
1421 | lmk->dclk = devm_kcalloc(lmk->dev, info->num_channels >> 1, | |
1422 | sizeof(struct lmk_dclk), GFP_KERNEL); | |
b424f73b WH |
1423 | if (!lmk->dclk) { |
1424 | ret = -ENOMEM; | |
3bc61cfd LB |
1425 | goto err_disable_oscin; |
1426 | } | |
1427 | ||
1428 | lmk->clkout = devm_kcalloc(lmk->dev, info->num_channels, | |
1429 | sizeof(*lmk->clkout), GFP_KERNEL); | |
b424f73b WH |
1430 | if (!lmk->clkout) { |
1431 | ret = -ENOMEM; | |
3bc61cfd LB |
1432 | goto err_disable_oscin; |
1433 | } | |
1434 | ||
1435 | lmk->clk_data = devm_kzalloc(lmk->dev, struct_size(lmk->clk_data, hws, | |
1436 | info->num_channels), | |
1437 | GFP_KERNEL); | |
b424f73b WH |
1438 | if (!lmk->clk_data) { |
1439 | ret = -ENOMEM; | |
3bc61cfd LB |
1440 | goto err_disable_oscin; |
1441 | } | |
1442 | ||
1443 | device_property_read_u32(lmk->dev, "ti,vco-hz", &lmk->vco_rate); | |
1444 | ||
6181baa1 LB |
1445 | lmk->sysref_ddly = 8; |
1446 | device_property_read_u32(lmk->dev, "ti,sysref-ddly", &lmk->sysref_ddly); | |
1447 | ||
1448 | lmk->sysref_mux = LMK04832_VAL_SYSREF_MUX_CONTINUOUS; | |
1449 | device_property_read_u32(lmk->dev, "ti,sysref-mux", | |
1450 | &lmk->sysref_mux); | |
1451 | ||
1452 | lmk->sync_mode = LMK04832_VAL_SYNC_MODE_OFF; | |
1453 | device_property_read_u32(lmk->dev, "ti,sync-mode", | |
1454 | &lmk->sync_mode); | |
1455 | ||
1456 | lmk->sysref_pulse_cnt = 4; | |
1457 | device_property_read_u32(lmk->dev, "ti,sysref-pulse-count", | |
1458 | &lmk->sysref_pulse_cnt); | |
1459 | ||
3bc61cfd LB |
1460 | for_each_child_of_node(lmk->dev->of_node, child) { |
1461 | int reg; | |
1462 | ||
1463 | ret = of_property_read_u32(child, "reg", ®); | |
1464 | if (ret) { | |
1465 | dev_err(lmk->dev, "missing reg property in child: %s\n", | |
1466 | child->full_name); | |
1467 | of_node_put(child); | |
1468 | goto err_disable_oscin; | |
1469 | } | |
1470 | ||
1471 | of_property_read_u32(child, "ti,clkout-fmt", | |
1472 | &lmk->clkout[reg].format); | |
1473 | ||
1474 | if (lmk->clkout[reg].format >= 0x0a && reg % 2 == 0 | |
1475 | && reg != 8 && reg != 10) | |
1476 | dev_err(lmk->dev, "invalid format for clkout%02d\n", | |
1477 | reg); | |
1478 | ||
1479 | lmk->clkout[reg].sysref = | |
1480 | of_property_read_bool(child, "ti,clkout-sysref"); | |
1481 | } | |
1482 | ||
1483 | lmk->regmap = devm_regmap_init_spi(spi, ®map_config); | |
1484 | if (IS_ERR(lmk->regmap)) { | |
1485 | dev_err(lmk->dev, "%s: regmap allocation failed: %ld\n", | |
1486 | ||
1487 | __func__, PTR_ERR(lmk->regmap)); | |
1488 | ret = PTR_ERR(lmk->regmap); | |
1489 | goto err_disable_oscin; | |
1490 | } | |
1491 | ||
1492 | regmap_write(lmk->regmap, LMK04832_REG_RST3W, LMK04832_BIT_RESET); | |
1493 | ||
1494 | if (!(spi->mode & SPI_3WIRE)) { | |
1495 | device_property_read_u32(lmk->dev, "ti,spi-4wire-rdbk", | |
1496 | &rdbk_pin); | |
1497 | ret = lmk04832_set_spi_rdbk(lmk, rdbk_pin); | |
1498 | if (ret) | |
1499 | goto err_disable_oscin; | |
1500 | } | |
1501 | ||
1502 | regmap_bulk_read(lmk->regmap, LMK04832_REG_ID_PROD_MSB, &tmp, 3); | |
1503 | if ((tmp[0] << 8 | tmp[1]) != info->pid || tmp[2] != info->maskrev) { | |
1504 | dev_err(lmk->dev, "unsupported device type: pid 0x%04x, maskrev 0x%02x\n", | |
1505 | tmp[0] << 8 | tmp[1], tmp[2]); | |
1506 | ret = -EINVAL; | |
1507 | goto err_disable_oscin; | |
1508 | } | |
1509 | ||
1510 | ret = lmk04832_register_vco(lmk); | |
1511 | if (ret) { | |
1512 | dev_err(lmk->dev, "failed to init device clock path\n"); | |
1513 | goto err_disable_oscin; | |
1514 | } | |
1515 | ||
1516 | if (lmk->vco_rate) { | |
1517 | dev_info(lmk->dev, "setting VCO rate to %u Hz\n", lmk->vco_rate); | |
1518 | ret = clk_set_rate(lmk->vco.clk, lmk->vco_rate); | |
1519 | if (ret) { | |
1520 | dev_err(lmk->dev, "failed to set VCO rate\n"); | |
e63227c8 | 1521 | goto err_disable_oscin; |
3bc61cfd LB |
1522 | } |
1523 | } | |
1524 | ||
1525 | ret = lmk04832_register_sclk(lmk); | |
1526 | if (ret) { | |
1527 | dev_err(lmk->dev, "failed to init SYNC/SYSREF clock path\n"); | |
e63227c8 | 1528 | goto err_disable_oscin; |
3bc61cfd LB |
1529 | } |
1530 | ||
1531 | for (i = 0; i < info->num_channels; i++) { | |
1532 | ret = lmk04832_register_clkout(lmk, i); | |
1533 | if (ret) { | |
1534 | dev_err(lmk->dev, "failed to register clk %d\n", i); | |
e63227c8 | 1535 | goto err_disable_oscin; |
3bc61cfd LB |
1536 | } |
1537 | } | |
1538 | ||
1539 | lmk->clk_data->num = info->num_channels; | |
56fc9a34 LPC |
1540 | ret = devm_of_clk_add_hw_provider(lmk->dev, of_clk_hw_onecell_get, |
1541 | lmk->clk_data); | |
3bc61cfd LB |
1542 | if (ret) { |
1543 | dev_err(lmk->dev, "failed to add provider (%d)\n", ret); | |
e63227c8 | 1544 | goto err_disable_oscin; |
3bc61cfd LB |
1545 | } |
1546 | ||
1547 | spi_set_drvdata(spi, lmk); | |
1548 | ||
1549 | return 0; | |
1550 | ||
3bc61cfd LB |
1551 | err_disable_oscin: |
1552 | clk_disable_unprepare(lmk->oscin); | |
1553 | ||
1554 | return ret; | |
1555 | } | |
1556 | ||
a0386bba | 1557 | static void lmk04832_remove(struct spi_device *spi) |
3bc61cfd LB |
1558 | { |
1559 | struct lmk04832 *lmk = spi_get_drvdata(spi); | |
1560 | ||
1561 | clk_disable_unprepare(lmk->oscin); | |
3bc61cfd | 1562 | } |
992a3552 | 1563 | |
3bc61cfd LB |
1564 | static const struct spi_device_id lmk04832_id[] = { |
1565 | { "lmk04832", LMK04832 }, | |
bf68fdfd | 1566 | {} |
3bc61cfd LB |
1567 | }; |
1568 | MODULE_DEVICE_TABLE(spi, lmk04832_id); | |
1569 | ||
1570 | static const struct of_device_id lmk04832_of_id[] = { | |
1571 | { .compatible = "ti,lmk04832" }, | |
bf68fdfd | 1572 | {} |
3bc61cfd | 1573 | }; |
bf68fdfd | 1574 | MODULE_DEVICE_TABLE(of, lmk04832_of_id); |
3bc61cfd LB |
1575 | |
1576 | static struct spi_driver lmk04832_driver = { | |
1577 | .driver = { | |
1578 | .name = "lmk04832", | |
bf68fdfd | 1579 | .of_match_table = lmk04832_of_id, |
3bc61cfd LB |
1580 | }, |
1581 | .probe = lmk04832_probe, | |
1582 | .remove = lmk04832_remove, | |
1583 | .id_table = lmk04832_id, | |
1584 | }; | |
1585 | module_spi_driver(lmk04832_driver); | |
1586 | ||
1587 | MODULE_AUTHOR("Liam Beguin <lvb@xiphos.com>"); | |
1588 | MODULE_DESCRIPTION("Texas Instruments LMK04832"); | |
1589 | MODULE_LICENSE("GPL v2"); |