2 * AD9523 SPI Low Jitter Clock Generator
4 * Copyright 2012 Analog Devices Inc.
6 * Licensed under the GPL-2.
9 #include <linux/device.h>
10 #include <linux/kernel.h>
11 #include <linux/slab.h>
12 #include <linux/sysfs.h>
13 #include <linux/spi/spi.h>
14 #include <linux/regulator/consumer.h>
15 #include <linux/err.h>
16 #include <linux/module.h>
17 #include <linux/delay.h>
19 #include <linux/iio/iio.h>
20 #include <linux/iio/sysfs.h>
21 #include <linux/iio/frequency/ad9523.h>
23 #define AD9523_READ (1 << 15)
24 #define AD9523_WRITE (0 << 15)
25 #define AD9523_CNT(x) (((x) - 1) << 13)
26 #define AD9523_ADDR(x) ((x) & 0xFFF)
28 #define AD9523_R1B (1 << 16)
29 #define AD9523_R2B (2 << 16)
30 #define AD9523_R3B (3 << 16)
31 #define AD9523_TRANSF_LEN(x) ((x) >> 16)
33 #define AD9523_SERIAL_PORT_CONFIG (AD9523_R1B | 0x0)
34 #define AD9523_VERSION_REGISTER (AD9523_R1B | 0x2)
35 #define AD9523_PART_REGISTER (AD9523_R1B | 0x3)
36 #define AD9523_READBACK_CTRL (AD9523_R1B | 0x4)
38 #define AD9523_EEPROM_CUSTOMER_VERSION_ID (AD9523_R2B | 0x6)
40 #define AD9523_PLL1_REF_A_DIVIDER (AD9523_R2B | 0x11)
41 #define AD9523_PLL1_REF_B_DIVIDER (AD9523_R2B | 0x13)
42 #define AD9523_PLL1_REF_TEST_DIVIDER (AD9523_R1B | 0x14)
43 #define AD9523_PLL1_FEEDBACK_DIVIDER (AD9523_R2B | 0x17)
44 #define AD9523_PLL1_CHARGE_PUMP_CTRL (AD9523_R2B | 0x19)
45 #define AD9523_PLL1_INPUT_RECEIVERS_CTRL (AD9523_R1B | 0x1A)
46 #define AD9523_PLL1_REF_CTRL (AD9523_R1B | 0x1B)
47 #define AD9523_PLL1_MISC_CTRL (AD9523_R1B | 0x1C)
48 #define AD9523_PLL1_LOOP_FILTER_CTRL (AD9523_R1B | 0x1D)
50 #define AD9523_PLL2_CHARGE_PUMP (AD9523_R1B | 0xF0)
51 #define AD9523_PLL2_FEEDBACK_DIVIDER_AB (AD9523_R1B | 0xF1)
52 #define AD9523_PLL2_CTRL (AD9523_R1B | 0xF2)
53 #define AD9523_PLL2_VCO_CTRL (AD9523_R1B | 0xF3)
54 #define AD9523_PLL2_VCO_DIVIDER (AD9523_R1B | 0xF4)
55 #define AD9523_PLL2_LOOP_FILTER_CTRL (AD9523_R2B | 0xF6)
56 #define AD9523_PLL2_R2_DIVIDER (AD9523_R1B | 0xF7)
58 #define AD9523_CHANNEL_CLOCK_DIST(ch) (AD9523_R3B | (0x192 + 3 * ch))
60 #define AD9523_PLL1_OUTPUT_CTRL (AD9523_R1B | 0x1BA)
61 #define AD9523_PLL1_OUTPUT_CHANNEL_CTRL (AD9523_R1B | 0x1BB)
63 #define AD9523_READBACK_0 (AD9523_R1B | 0x22C)
64 #define AD9523_READBACK_1 (AD9523_R1B | 0x22D)
66 #define AD9523_STATUS_SIGNALS (AD9523_R3B | 0x232)
67 #define AD9523_POWER_DOWN_CTRL (AD9523_R1B | 0x233)
68 #define AD9523_IO_UPDATE (AD9523_R1B | 0x234)
70 #define AD9523_EEPROM_DATA_XFER_STATUS (AD9523_R1B | 0xB00)
71 #define AD9523_EEPROM_ERROR_READBACK (AD9523_R1B | 0xB01)
72 #define AD9523_EEPROM_CTRL1 (AD9523_R1B | 0xB02)
73 #define AD9523_EEPROM_CTRL2 (AD9523_R1B | 0xB03)
75 /* AD9523_SERIAL_PORT_CONFIG */
77 #define AD9523_SER_CONF_SDO_ACTIVE (1 << 7)
78 #define AD9523_SER_CONF_SOFT_RESET (1 << 5)
80 /* AD9523_READBACK_CTRL */
81 #define AD9523_READBACK_CTRL_READ_BUFFERED (1 << 0)
83 /* AD9523_PLL1_CHARGE_PUMP_CTRL */
84 #define AD9523_PLL1_CHARGE_PUMP_CURRENT_nA(x) (((x) / 500) & 0x7F)
85 #define AD9523_PLL1_CHARGE_PUMP_TRISTATE (1 << 7)
86 #define AD9523_PLL1_CHARGE_PUMP_MODE_NORMAL (3 << 8)
87 #define AD9523_PLL1_CHARGE_PUMP_MODE_PUMP_DOWN (2 << 8)
88 #define AD9523_PLL1_CHARGE_PUMP_MODE_PUMP_UP (1 << 8)
89 #define AD9523_PLL1_CHARGE_PUMP_MODE_TRISTATE (0 << 8)
90 #define AD9523_PLL1_BACKLASH_PW_MIN (0 << 10)
91 #define AD9523_PLL1_BACKLASH_PW_LOW (1 << 10)
92 #define AD9523_PLL1_BACKLASH_PW_HIGH (2 << 10)
93 #define AD9523_PLL1_BACKLASH_PW_MAX (3 << 10)
95 /* AD9523_PLL1_INPUT_RECEIVERS_CTRL */
96 #define AD9523_PLL1_REF_TEST_RCV_EN (1 << 7)
97 #define AD9523_PLL1_REFB_DIFF_RCV_EN (1 << 6)
98 #define AD9523_PLL1_REFA_DIFF_RCV_EN (1 << 5)
99 #define AD9523_PLL1_REFB_RCV_EN (1 << 4)
100 #define AD9523_PLL1_REFA_RCV_EN (1 << 3)
101 #define AD9523_PLL1_REFA_REFB_PWR_CTRL_EN (1 << 2)
102 #define AD9523_PLL1_OSC_IN_CMOS_NEG_INP_EN (1 << 1)
103 #define AD9523_PLL1_OSC_IN_DIFF_EN (1 << 0)
105 /* AD9523_PLL1_REF_CTRL */
106 #define AD9523_PLL1_BYPASS_REF_TEST_DIV_EN (1 << 7)
107 #define AD9523_PLL1_BYPASS_FEEDBACK_DIV_EN (1 << 6)
108 #define AD9523_PLL1_ZERO_DELAY_MODE_INT (1 << 5)
109 #define AD9523_PLL1_ZERO_DELAY_MODE_EXT (0 << 5)
110 #define AD9523_PLL1_OSC_IN_PLL_FEEDBACK_EN (1 << 4)
111 #define AD9523_PLL1_ZD_IN_CMOS_NEG_INP_EN (1 << 3)
112 #define AD9523_PLL1_ZD_IN_DIFF_EN (1 << 2)
113 #define AD9523_PLL1_REFB_CMOS_NEG_INP_EN (1 << 1)
114 #define AD9523_PLL1_REFA_CMOS_NEG_INP_EN (1 << 0)
116 /* AD9523_PLL1_MISC_CTRL */
117 #define AD9523_PLL1_REFB_INDEP_DIV_CTRL_EN (1 << 7)
118 #define AD9523_PLL1_OSC_CTRL_FAIL_VCC_BY2_EN (1 << 6)
119 #define AD9523_PLL1_REF_MODE(x) ((x) << 2)
120 #define AD9523_PLL1_BYPASS_REFB_DIV (1 << 1)
121 #define AD9523_PLL1_BYPASS_REFA_DIV (1 << 0)
123 /* AD9523_PLL1_LOOP_FILTER_CTRL */
124 #define AD9523_PLL1_LOOP_FILTER_RZERO(x) ((x) & 0xF)
126 /* AD9523_PLL2_CHARGE_PUMP */
127 #define AD9523_PLL2_CHARGE_PUMP_CURRENT_nA(x) ((x) / 3500)
129 /* AD9523_PLL2_FEEDBACK_DIVIDER_AB */
130 #define AD9523_PLL2_FB_NDIV_A_CNT(x) (((x) & 0x3) << 6)
131 #define AD9523_PLL2_FB_NDIV_B_CNT(x) (((x) & 0x3F) << 0)
132 #define AD9523_PLL2_FB_NDIV(a, b) (4 * (b) + (a))
134 /* AD9523_PLL2_CTRL */
135 #define AD9523_PLL2_CHARGE_PUMP_MODE_NORMAL (3 << 0)
136 #define AD9523_PLL2_CHARGE_PUMP_MODE_PUMP_DOWN (2 << 0)
137 #define AD9523_PLL2_CHARGE_PUMP_MODE_PUMP_UP (1 << 0)
138 #define AD9523_PLL2_CHARGE_PUMP_MODE_TRISTATE (0 << 0)
139 #define AD9523_PLL2_BACKLASH_PW_MIN (0 << 2)
140 #define AD9523_PLL2_BACKLASH_PW_LOW (1 << 2)
141 #define AD9523_PLL2_BACKLASH_PW_HIGH (2 << 2)
142 #define AD9523_PLL2_BACKLASH_PW_MAX (3 << 1)
143 #define AD9523_PLL2_BACKLASH_CTRL_EN (1 << 4)
144 #define AD9523_PLL2_FREQ_DOUBLER_EN (1 << 5)
145 #define AD9523_PLL2_LOCK_DETECT_PWR_DOWN_EN (1 << 7)
147 /* AD9523_PLL2_VCO_CTRL */
148 #define AD9523_PLL2_VCO_CALIBRATE (1 << 1)
149 #define AD9523_PLL2_FORCE_VCO_MIDSCALE (1 << 2)
150 #define AD9523_PLL2_FORCE_REFERENCE_VALID (1 << 3)
151 #define AD9523_PLL2_FORCE_RELEASE_SYNC (1 << 4)
153 /* AD9523_PLL2_VCO_DIVIDER */
154 #define AD9523_PLL2_VCO_DIV_M1(x) ((((x) - 3) & 0x3) << 0)
155 #define AD9523_PLL2_VCO_DIV_M2(x) ((((x) - 3) & 0x3) << 4)
156 #define AD9523_PLL2_VCO_DIV_M1_PWR_DOWN_EN (1 << 2)
157 #define AD9523_PLL2_VCO_DIV_M2_PWR_DOWN_EN (1 << 6)
159 /* AD9523_PLL2_LOOP_FILTER_CTRL */
160 #define AD9523_PLL2_LOOP_FILTER_CPOLE1(x) (((x) & 0x7) << 0)
161 #define AD9523_PLL2_LOOP_FILTER_RZERO(x) (((x) & 0x7) << 3)
162 #define AD9523_PLL2_LOOP_FILTER_RPOLE2(x) (((x) & 0x7) << 6)
163 #define AD9523_PLL2_LOOP_FILTER_RZERO_BYPASS_EN (1 << 8)
165 /* AD9523_PLL2_R2_DIVIDER */
166 #define AD9523_PLL2_R2_DIVIDER_VAL(x) (((x) & 0x1F) << 0)
168 /* AD9523_CHANNEL_CLOCK_DIST */
169 #define AD9523_CLK_DIST_DIV_PHASE(x) (((x) & 0x3F) << 18)
170 #define AD9523_CLK_DIST_DIV_PHASE_REV(x) ((ret >> 18) & 0x3F)
171 #define AD9523_CLK_DIST_DIV(x) ((((x) - 1) & 0x3FF) << 8)
172 #define AD9523_CLK_DIST_DIV_REV(x) (((ret >> 8) & 0x3FF) + 1)
173 #define AD9523_CLK_DIST_INV_DIV_OUTPUT_EN (1 << 7)
174 #define AD9523_CLK_DIST_IGNORE_SYNC_EN (1 << 6)
175 #define AD9523_CLK_DIST_PWR_DOWN_EN (1 << 5)
176 #define AD9523_CLK_DIST_LOW_PWR_MODE_EN (1 << 4)
177 #define AD9523_CLK_DIST_DRIVER_MODE(x) (((x) & 0xF) << 0)
179 /* AD9523_PLL1_OUTPUT_CTRL */
180 #define AD9523_PLL1_OUTP_CTRL_VCO_DIV_SEL_CH6_M2 (1 << 7)
181 #define AD9523_PLL1_OUTP_CTRL_VCO_DIV_SEL_CH5_M2 (1 << 6)
182 #define AD9523_PLL1_OUTP_CTRL_VCO_DIV_SEL_CH4_M2 (1 << 5)
183 #define AD9523_PLL1_OUTP_CTRL_CMOS_DRV_WEAK (1 << 4)
184 #define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_1 (0 << 0)
185 #define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_2 (1 << 0)
186 #define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_4 (2 << 0)
187 #define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_8 (4 << 0)
188 #define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_16 (8 << 0)
190 /* AD9523_PLL1_OUTPUT_CHANNEL_CTRL */
191 #define AD9523_PLL1_OUTP_CH_CTRL_OUTPUT_PWR_DOWN_EN (1 << 7)
192 #define AD9523_PLL1_OUTP_CH_CTRL_VCO_DIV_SEL_CH9_M2 (1 << 6)
193 #define AD9523_PLL1_OUTP_CH_CTRL_VCO_DIV_SEL_CH8_M2 (1 << 5)
194 #define AD9523_PLL1_OUTP_CH_CTRL_VCO_DIV_SEL_CH7_M2 (1 << 4)
195 #define AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH3 (1 << 3)
196 #define AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH2 (1 << 2)
197 #define AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH1 (1 << 1)
198 #define AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH0 (1 << 0)
200 /* AD9523_READBACK_0 */
201 #define AD9523_READBACK_0_STAT_PLL2_REF_CLK (1 << 7)
202 #define AD9523_READBACK_0_STAT_PLL2_FB_CLK (1 << 6)
203 #define AD9523_READBACK_0_STAT_VCXO (1 << 5)
204 #define AD9523_READBACK_0_STAT_REF_TEST (1 << 4)
205 #define AD9523_READBACK_0_STAT_REFB (1 << 3)
206 #define AD9523_READBACK_0_STAT_REFA (1 << 2)
207 #define AD9523_READBACK_0_STAT_PLL2_LD (1 << 1)
208 #define AD9523_READBACK_0_STAT_PLL1_LD (1 << 0)
210 /* AD9523_READBACK_1 */
211 #define AD9523_READBACK_1_HOLDOVER_ACTIVE (1 << 3)
212 #define AD9523_READBACK_1_AUTOMODE_SEL_REFB (1 << 2)
213 #define AD9523_READBACK_1_VCO_CALIB_IN_PROGRESS (1 << 0)
215 /* AD9523_STATUS_SIGNALS */
216 #define AD9523_STATUS_SIGNALS_SYNC_MAN_CTRL (1 << 16)
217 #define AD9523_STATUS_MONITOR_01_PLL12_LOCKED (0x302)
218 /* AD9523_POWER_DOWN_CTRL */
219 #define AD9523_POWER_DOWN_CTRL_PLL1_PWR_DOWN (1 << 2)
220 #define AD9523_POWER_DOWN_CTRL_PLL2_PWR_DOWN (1 << 1)
221 #define AD9523_POWER_DOWN_CTRL_DIST_PWR_DOWN (1 << 0)
223 /* AD9523_IO_UPDATE */
224 #define AD9523_IO_UPDATE_EN (1 << 0)
226 /* AD9523_EEPROM_DATA_XFER_STATUS */
227 #define AD9523_EEPROM_DATA_XFER_IN_PROGRESS (1 << 0)
229 /* AD9523_EEPROM_ERROR_READBACK */
230 #define AD9523_EEPROM_ERROR_READBACK_FAIL (1 << 0)
232 /* AD9523_EEPROM_CTRL1 */
233 #define AD9523_EEPROM_CTRL1_SOFT_EEPROM (1 << 1)
234 #define AD9523_EEPROM_CTRL1_EEPROM_WRITE_PROT_DIS (1 << 0)
236 /* AD9523_EEPROM_CTRL2 */
237 #define AD9523_EEPROM_CTRL2_REG2EEPROM (1 << 0)
239 #define AD9523_NUM_CHAN 14
240 #define AD9523_NUM_CHAN_ALT_CLK_SRC 10
242 /* Helpers to avoid excess line breaks */
243 #define AD_IFE(_pde, _a, _b) ((pdata->_pde) ? _a : _b)
244 #define AD_IF(_pde, _a) AD_IFE(_pde, _a, 0)
251 AD9523_STAT_REF_TEST
,
253 AD9523_STAT_PLL2_FB_CLK
,
254 AD9523_STAT_PLL2_REF_CLK
,
266 struct ad9523_state
{
267 struct spi_device
*spi
;
268 struct regulator
*reg
;
269 struct ad9523_platform_data
*pdata
;
270 struct iio_chan_spec ad9523_channels
[AD9523_NUM_CHAN
];
272 unsigned long vcxo_freq
;
273 unsigned long vco_freq
;
274 unsigned long vco_out_freq
[AD9523_NUM_CLK_SRC
];
275 unsigned char vco_out_map
[AD9523_NUM_CHAN_ALT_CLK_SRC
];
278 * DMA (thus cache coherency maintenance) requires the
279 * transfer buffers to live in their own cache lines.
284 } data
[2] ____cacheline_aligned
;
287 static int ad9523_read(struct iio_dev
*indio_dev
, unsigned addr
)
289 struct ad9523_state
*st
= iio_priv(indio_dev
);
290 struct spi_message m
;
293 /* We encode the register size 1..3 bytes into the register address.
294 * On transfer we get the size from the register datum, and make sure
295 * the result is properly aligned.
298 struct spi_transfer t
[] = {
300 .tx_buf
= &st
->data
[0].d8
[2],
303 .rx_buf
= &st
->data
[1].d8
[4 - AD9523_TRANSF_LEN(addr
)],
304 .len
= AD9523_TRANSF_LEN(addr
),
308 spi_message_init(&m
);
309 spi_message_add_tail(&t
[0], &m
);
310 spi_message_add_tail(&t
[1], &m
);
312 st
->data
[0].d32
= cpu_to_be32(AD9523_READ
|
313 AD9523_CNT(AD9523_TRANSF_LEN(addr
)) |
316 ret
= spi_sync(st
->spi
, &m
);
318 dev_err(&indio_dev
->dev
, "read failed (%d)", ret
);
320 ret
= be32_to_cpu(st
->data
[1].d32
) & (0xFFFFFF >>
321 (8 * (3 - AD9523_TRANSF_LEN(addr
))));
326 static int ad9523_write(struct iio_dev
*indio_dev
, unsigned addr
, unsigned val
)
328 struct ad9523_state
*st
= iio_priv(indio_dev
);
329 struct spi_message m
;
331 struct spi_transfer t
[] = {
333 .tx_buf
= &st
->data
[0].d8
[2],
336 .tx_buf
= &st
->data
[1].d8
[4 - AD9523_TRANSF_LEN(addr
)],
337 .len
= AD9523_TRANSF_LEN(addr
),
341 spi_message_init(&m
);
342 spi_message_add_tail(&t
[0], &m
);
343 spi_message_add_tail(&t
[1], &m
);
345 st
->data
[0].d32
= cpu_to_be32(AD9523_WRITE
|
346 AD9523_CNT(AD9523_TRANSF_LEN(addr
)) |
348 st
->data
[1].d32
= cpu_to_be32(val
);
350 ret
= spi_sync(st
->spi
, &m
);
353 dev_err(&indio_dev
->dev
, "write failed (%d)", ret
);
358 static int ad9523_io_update(struct iio_dev
*indio_dev
)
360 return ad9523_write(indio_dev
, AD9523_IO_UPDATE
, AD9523_IO_UPDATE_EN
);
363 static int ad9523_vco_out_map(struct iio_dev
*indio_dev
,
364 unsigned ch
, unsigned out
)
366 struct ad9523_state
*st
= iio_priv(indio_dev
);
372 ret
= ad9523_read(indio_dev
, AD9523_PLL1_OUTPUT_CHANNEL_CTRL
);
375 mask
= AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH0
<< ch
;
382 ret
= ad9523_write(indio_dev
,
383 AD9523_PLL1_OUTPUT_CHANNEL_CTRL
, ret
);
386 ret
= ad9523_read(indio_dev
, AD9523_PLL1_OUTPUT_CTRL
);
389 mask
= AD9523_PLL1_OUTP_CTRL_VCO_DIV_SEL_CH4_M2
<< (ch
- 4);
394 ret
= ad9523_write(indio_dev
, AD9523_PLL1_OUTPUT_CTRL
, ret
);
397 ret
= ad9523_read(indio_dev
, AD9523_PLL1_OUTPUT_CHANNEL_CTRL
);
400 mask
= AD9523_PLL1_OUTP_CH_CTRL_VCO_DIV_SEL_CH7_M2
<< (ch
- 7);
405 ret
= ad9523_write(indio_dev
,
406 AD9523_PLL1_OUTPUT_CHANNEL_CTRL
, ret
);
412 st
->vco_out_map
[ch
] = out
;
417 static int ad9523_set_clock_provider(struct iio_dev
*indio_dev
,
418 unsigned ch
, unsigned long freq
)
420 struct ad9523_state
*st
= iio_priv(indio_dev
);
422 bool use_alt_clk_src
;
426 use_alt_clk_src
= (freq
== st
->vco_out_freq
[AD9523_VCXO
]);
429 tmp1
= st
->vco_out_freq
[AD9523_VCO1
] / freq
;
430 tmp2
= st
->vco_out_freq
[AD9523_VCO2
] / freq
;
433 use_alt_clk_src
= (abs(tmp1
- freq
) > abs(tmp2
- freq
));
436 /* Ch 10..14: No action required, return success */
440 return ad9523_vco_out_map(indio_dev
, ch
, use_alt_clk_src
);
443 static int ad9523_store_eeprom(struct iio_dev
*indio_dev
)
447 ret
= ad9523_write(indio_dev
, AD9523_EEPROM_CTRL1
,
448 AD9523_EEPROM_CTRL1_EEPROM_WRITE_PROT_DIS
);
451 ret
= ad9523_write(indio_dev
, AD9523_EEPROM_CTRL2
,
452 AD9523_EEPROM_CTRL2_REG2EEPROM
);
459 ret
= ad9523_read(indio_dev
,
460 AD9523_EEPROM_DATA_XFER_STATUS
);
463 } while ((ret
& AD9523_EEPROM_DATA_XFER_IN_PROGRESS
) && tmp
--);
465 ret
= ad9523_write(indio_dev
, AD9523_EEPROM_CTRL1
, 0);
469 ret
= ad9523_read(indio_dev
, AD9523_EEPROM_ERROR_READBACK
);
473 if (ret
& AD9523_EEPROM_ERROR_READBACK_FAIL
) {
474 dev_err(&indio_dev
->dev
, "Verify EEPROM failed");
481 static int ad9523_sync(struct iio_dev
*indio_dev
)
485 ret
= ad9523_read(indio_dev
, AD9523_STATUS_SIGNALS
);
490 tmp
|= AD9523_STATUS_SIGNALS_SYNC_MAN_CTRL
;
492 ret
= ad9523_write(indio_dev
, AD9523_STATUS_SIGNALS
, tmp
);
496 ad9523_io_update(indio_dev
);
497 tmp
&= ~AD9523_STATUS_SIGNALS_SYNC_MAN_CTRL
;
499 ret
= ad9523_write(indio_dev
, AD9523_STATUS_SIGNALS
, tmp
);
503 return ad9523_io_update(indio_dev
);
506 static ssize_t
ad9523_store(struct device
*dev
,
507 struct device_attribute
*attr
,
508 const char *buf
, size_t len
)
510 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
511 struct iio_dev_attr
*this_attr
= to_iio_dev_attr(attr
);
515 ret
= strtobool(buf
, &state
);
522 mutex_lock(&indio_dev
->mlock
);
523 switch ((u32
)this_attr
->address
) {
525 ret
= ad9523_sync(indio_dev
);
528 ret
= ad9523_store_eeprom(indio_dev
);
533 mutex_unlock(&indio_dev
->mlock
);
535 return ret
? ret
: len
;
538 static ssize_t
ad9523_show(struct device
*dev
,
539 struct device_attribute
*attr
,
542 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
543 struct iio_dev_attr
*this_attr
= to_iio_dev_attr(attr
);
546 mutex_lock(&indio_dev
->mlock
);
547 ret
= ad9523_read(indio_dev
, AD9523_READBACK_0
);
549 ret
= sprintf(buf
, "%d\n", !!(ret
& (1 <<
550 (u32
)this_attr
->address
)));
552 mutex_unlock(&indio_dev
->mlock
);
557 static IIO_DEVICE_ATTR(pll1_locked
, S_IRUGO
,
560 AD9523_STAT_PLL1_LD
);
562 static IIO_DEVICE_ATTR(pll2_locked
, S_IRUGO
,
565 AD9523_STAT_PLL2_LD
);
567 static IIO_DEVICE_ATTR(pll1_reference_clk_a_present
, S_IRUGO
,
572 static IIO_DEVICE_ATTR(pll1_reference_clk_b_present
, S_IRUGO
,
577 static IIO_DEVICE_ATTR(pll1_reference_clk_test_present
, S_IRUGO
,
580 AD9523_STAT_REF_TEST
);
582 static IIO_DEVICE_ATTR(vcxo_clk_present
, S_IRUGO
,
587 static IIO_DEVICE_ATTR(pll2_feedback_clk_present
, S_IRUGO
,
590 AD9523_STAT_PLL2_FB_CLK
);
592 static IIO_DEVICE_ATTR(pll2_reference_clk_present
, S_IRUGO
,
595 AD9523_STAT_PLL2_REF_CLK
);
597 static IIO_DEVICE_ATTR(sync_dividers
, S_IWUSR
,
602 static IIO_DEVICE_ATTR(store_eeprom
, S_IWUSR
,
607 static struct attribute
*ad9523_attributes
[] = {
608 &iio_dev_attr_sync_dividers
.dev_attr
.attr
,
609 &iio_dev_attr_store_eeprom
.dev_attr
.attr
,
610 &iio_dev_attr_pll2_feedback_clk_present
.dev_attr
.attr
,
611 &iio_dev_attr_pll2_reference_clk_present
.dev_attr
.attr
,
612 &iio_dev_attr_pll1_reference_clk_a_present
.dev_attr
.attr
,
613 &iio_dev_attr_pll1_reference_clk_b_present
.dev_attr
.attr
,
614 &iio_dev_attr_pll1_reference_clk_test_present
.dev_attr
.attr
,
615 &iio_dev_attr_vcxo_clk_present
.dev_attr
.attr
,
616 &iio_dev_attr_pll1_locked
.dev_attr
.attr
,
617 &iio_dev_attr_pll2_locked
.dev_attr
.attr
,
621 static const struct attribute_group ad9523_attribute_group
= {
622 .attrs
= ad9523_attributes
,
625 static int ad9523_read_raw(struct iio_dev
*indio_dev
,
626 struct iio_chan_spec
const *chan
,
631 struct ad9523_state
*st
= iio_priv(indio_dev
);
635 mutex_lock(&indio_dev
->mlock
);
636 ret
= ad9523_read(indio_dev
, AD9523_CHANNEL_CLOCK_DIST(chan
->channel
));
637 mutex_unlock(&indio_dev
->mlock
);
643 case IIO_CHAN_INFO_RAW
:
644 *val
= !(ret
& AD9523_CLK_DIST_PWR_DOWN_EN
);
646 case IIO_CHAN_INFO_FREQUENCY
:
647 *val
= st
->vco_out_freq
[st
->vco_out_map
[chan
->channel
]] /
648 AD9523_CLK_DIST_DIV_REV(ret
);
650 case IIO_CHAN_INFO_PHASE
:
651 code
= (AD9523_CLK_DIST_DIV_PHASE_REV(ret
) * 3141592) /
652 AD9523_CLK_DIST_DIV_REV(ret
);
653 *val
= code
/ 1000000;
654 *val2
= (code
% 1000000) * 10;
655 return IIO_VAL_INT_PLUS_MICRO
;
661 static int ad9523_write_raw(struct iio_dev
*indio_dev
,
662 struct iio_chan_spec
const *chan
,
667 struct ad9523_state
*st
= iio_priv(indio_dev
);
671 mutex_lock(&indio_dev
->mlock
);
672 ret
= ad9523_read(indio_dev
, AD9523_CHANNEL_CLOCK_DIST(chan
->channel
));
679 case IIO_CHAN_INFO_RAW
:
681 reg
&= ~AD9523_CLK_DIST_PWR_DOWN_EN
;
683 reg
|= AD9523_CLK_DIST_PWR_DOWN_EN
;
685 case IIO_CHAN_INFO_FREQUENCY
:
690 ret
= ad9523_set_clock_provider(indio_dev
, chan
->channel
, val
);
693 tmp
= st
->vco_out_freq
[st
->vco_out_map
[chan
->channel
]] / val
;
694 tmp
= clamp(tmp
, 1, 1024);
695 reg
&= ~(0x3FF << 8);
696 reg
|= AD9523_CLK_DIST_DIV(tmp
);
698 case IIO_CHAN_INFO_PHASE
:
699 code
= val
* 1000000 + val2
% 1000000;
700 tmp
= (code
* AD9523_CLK_DIST_DIV_REV(ret
)) / 3141592;
701 tmp
= clamp(tmp
, 0, 63);
702 reg
&= ~AD9523_CLK_DIST_DIV_PHASE(~0);
703 reg
|= AD9523_CLK_DIST_DIV_PHASE(tmp
);
710 ret
= ad9523_write(indio_dev
, AD9523_CHANNEL_CLOCK_DIST(chan
->channel
),
715 ad9523_io_update(indio_dev
);
717 mutex_unlock(&indio_dev
->mlock
);
721 static int ad9523_reg_access(struct iio_dev
*indio_dev
,
722 unsigned reg
, unsigned writeval
,
727 mutex_lock(&indio_dev
->mlock
);
728 if (readval
== NULL
) {
729 ret
= ad9523_write(indio_dev
, reg
| AD9523_R1B
, writeval
);
730 ad9523_io_update(indio_dev
);
732 ret
= ad9523_read(indio_dev
, reg
| AD9523_R1B
);
740 mutex_unlock(&indio_dev
->mlock
);
745 static const struct iio_info ad9523_info
= {
746 .read_raw
= &ad9523_read_raw
,
747 .write_raw
= &ad9523_write_raw
,
748 .debugfs_reg_access
= &ad9523_reg_access
,
749 .attrs
= &ad9523_attribute_group
,
750 .driver_module
= THIS_MODULE
,
753 static int ad9523_setup(struct iio_dev
*indio_dev
)
755 struct ad9523_state
*st
= iio_priv(indio_dev
);
756 struct ad9523_platform_data
*pdata
= st
->pdata
;
757 struct ad9523_channel_spec
*chan
;
758 unsigned long active_mask
= 0;
761 ret
= ad9523_write(indio_dev
, AD9523_SERIAL_PORT_CONFIG
,
762 AD9523_SER_CONF_SOFT_RESET
|
763 (st
->spi
->mode
& SPI_3WIRE
? 0 :
764 AD9523_SER_CONF_SDO_ACTIVE
));
768 ret
= ad9523_write(indio_dev
, AD9523_READBACK_CTRL
,
769 AD9523_READBACK_CTRL_READ_BUFFERED
);
773 ret
= ad9523_io_update(indio_dev
);
780 ret
= ad9523_write(indio_dev
, AD9523_PLL1_REF_A_DIVIDER
,
785 ret
= ad9523_write(indio_dev
, AD9523_PLL1_REF_B_DIVIDER
,
790 ret
= ad9523_write(indio_dev
, AD9523_PLL1_FEEDBACK_DIVIDER
,
791 pdata
->pll1_feedback_div
);
795 ret
= ad9523_write(indio_dev
, AD9523_PLL1_CHARGE_PUMP_CTRL
,
796 AD9523_PLL1_CHARGE_PUMP_CURRENT_nA(pdata
->
797 pll1_charge_pump_current_nA
) |
798 AD9523_PLL1_CHARGE_PUMP_MODE_NORMAL
|
799 AD9523_PLL1_BACKLASH_PW_MIN
);
803 ret
= ad9523_write(indio_dev
, AD9523_PLL1_INPUT_RECEIVERS_CTRL
,
804 AD_IF(refa_diff_rcv_en
, AD9523_PLL1_REFA_RCV_EN
) |
805 AD_IF(refb_diff_rcv_en
, AD9523_PLL1_REFB_RCV_EN
) |
806 AD_IF(osc_in_diff_en
, AD9523_PLL1_OSC_IN_DIFF_EN
) |
807 AD_IF(osc_in_cmos_neg_inp_en
,
808 AD9523_PLL1_OSC_IN_CMOS_NEG_INP_EN
) |
809 AD_IF(refa_diff_rcv_en
, AD9523_PLL1_REFA_DIFF_RCV_EN
) |
810 AD_IF(refb_diff_rcv_en
, AD9523_PLL1_REFB_DIFF_RCV_EN
));
814 ret
= ad9523_write(indio_dev
, AD9523_PLL1_REF_CTRL
,
815 AD_IF(zd_in_diff_en
, AD9523_PLL1_ZD_IN_DIFF_EN
) |
816 AD_IF(zd_in_cmos_neg_inp_en
,
817 AD9523_PLL1_ZD_IN_CMOS_NEG_INP_EN
) |
818 AD_IF(zero_delay_mode_internal_en
,
819 AD9523_PLL1_ZERO_DELAY_MODE_INT
) |
820 AD_IF(osc_in_feedback_en
, AD9523_PLL1_OSC_IN_PLL_FEEDBACK_EN
) |
821 AD_IF(refa_cmos_neg_inp_en
, AD9523_PLL1_REFA_CMOS_NEG_INP_EN
) |
822 AD_IF(refb_cmos_neg_inp_en
, AD9523_PLL1_REFB_CMOS_NEG_INP_EN
));
826 ret
= ad9523_write(indio_dev
, AD9523_PLL1_MISC_CTRL
,
827 AD9523_PLL1_REFB_INDEP_DIV_CTRL_EN
|
828 AD9523_PLL1_REF_MODE(pdata
->ref_mode
));
832 ret
= ad9523_write(indio_dev
, AD9523_PLL1_LOOP_FILTER_CTRL
,
833 AD9523_PLL1_LOOP_FILTER_RZERO(pdata
->pll1_loop_filter_rzero
));
840 ret
= ad9523_write(indio_dev
, AD9523_PLL2_CHARGE_PUMP
,
841 AD9523_PLL2_CHARGE_PUMP_CURRENT_nA(pdata
->
842 pll2_charge_pump_current_nA
));
846 ret
= ad9523_write(indio_dev
, AD9523_PLL2_FEEDBACK_DIVIDER_AB
,
847 AD9523_PLL2_FB_NDIV_A_CNT(pdata
->pll2_ndiv_a_cnt
) |
848 AD9523_PLL2_FB_NDIV_B_CNT(pdata
->pll2_ndiv_b_cnt
));
852 ret
= ad9523_write(indio_dev
, AD9523_PLL2_CTRL
,
853 AD9523_PLL2_CHARGE_PUMP_MODE_NORMAL
|
854 AD9523_PLL2_BACKLASH_CTRL_EN
|
855 AD_IF(pll2_freq_doubler_en
, AD9523_PLL2_FREQ_DOUBLER_EN
));
859 st
->vco_freq
= (pdata
->vcxo_freq
* (pdata
->pll2_freq_doubler_en
? 2 : 1)
860 / pdata
->pll2_r2_div
) * AD9523_PLL2_FB_NDIV(pdata
->
861 pll2_ndiv_a_cnt
, pdata
->pll2_ndiv_b_cnt
);
863 ret
= ad9523_write(indio_dev
, AD9523_PLL2_VCO_CTRL
,
864 AD9523_PLL2_VCO_CALIBRATE
);
868 ret
= ad9523_write(indio_dev
, AD9523_PLL2_VCO_DIVIDER
,
869 AD9523_PLL2_VCO_DIV_M1(pdata
->pll2_vco_diff_m1
) |
870 AD9523_PLL2_VCO_DIV_M2(pdata
->pll2_vco_diff_m2
) |
871 AD_IFE(pll2_vco_diff_m1
, 0,
872 AD9523_PLL2_VCO_DIV_M1_PWR_DOWN_EN
) |
873 AD_IFE(pll2_vco_diff_m2
, 0,
874 AD9523_PLL2_VCO_DIV_M2_PWR_DOWN_EN
));
878 if (pdata
->pll2_vco_diff_m1
)
879 st
->vco_out_freq
[AD9523_VCO1
] =
880 st
->vco_freq
/ pdata
->pll2_vco_diff_m1
;
882 if (pdata
->pll2_vco_diff_m2
)
883 st
->vco_out_freq
[AD9523_VCO2
] =
884 st
->vco_freq
/ pdata
->pll2_vco_diff_m2
;
886 st
->vco_out_freq
[AD9523_VCXO
] = pdata
->vcxo_freq
;
888 ret
= ad9523_write(indio_dev
, AD9523_PLL2_R2_DIVIDER
,
889 AD9523_PLL2_R2_DIVIDER_VAL(pdata
->pll2_r2_div
));
893 ret
= ad9523_write(indio_dev
, AD9523_PLL2_LOOP_FILTER_CTRL
,
894 AD9523_PLL2_LOOP_FILTER_CPOLE1(pdata
->cpole1
) |
895 AD9523_PLL2_LOOP_FILTER_RZERO(pdata
->rzero
) |
896 AD9523_PLL2_LOOP_FILTER_RPOLE2(pdata
->rpole2
) |
897 AD_IF(rzero_bypass_en
,
898 AD9523_PLL2_LOOP_FILTER_RZERO_BYPASS_EN
));
902 for (i
= 0; i
< pdata
->num_channels
; i
++) {
903 chan
= &pdata
->channels
[i
];
904 if (chan
->channel_num
< AD9523_NUM_CHAN
) {
905 __set_bit(chan
->channel_num
, &active_mask
);
906 ret
= ad9523_write(indio_dev
,
907 AD9523_CHANNEL_CLOCK_DIST(chan
->channel_num
),
908 AD9523_CLK_DIST_DRIVER_MODE(chan
->driver_mode
) |
909 AD9523_CLK_DIST_DIV(chan
->channel_divider
) |
910 AD9523_CLK_DIST_DIV_PHASE(chan
->divider_phase
) |
911 (chan
->sync_ignore_en
?
912 AD9523_CLK_DIST_IGNORE_SYNC_EN
: 0) |
913 (chan
->divider_output_invert_en
?
914 AD9523_CLK_DIST_INV_DIV_OUTPUT_EN
: 0) |
915 (chan
->low_power_mode_en
?
916 AD9523_CLK_DIST_LOW_PWR_MODE_EN
: 0) |
918 AD9523_CLK_DIST_PWR_DOWN_EN
: 0));
922 ret
= ad9523_vco_out_map(indio_dev
, chan
->channel_num
,
923 chan
->use_alt_clock_src
);
927 st
->ad9523_channels
[i
].type
= IIO_ALTVOLTAGE
;
928 st
->ad9523_channels
[i
].output
= 1;
929 st
->ad9523_channels
[i
].indexed
= 1;
930 st
->ad9523_channels
[i
].channel
= chan
->channel_num
;
931 st
->ad9523_channels
[i
].extend_name
=
933 st
->ad9523_channels
[i
].info_mask
=
934 IIO_CHAN_INFO_RAW_SEPARATE_BIT
|
935 IIO_CHAN_INFO_PHASE_SEPARATE_BIT
|
936 IIO_CHAN_INFO_FREQUENCY_SEPARATE_BIT
;
940 for_each_clear_bit(i
, &active_mask
, AD9523_NUM_CHAN
)
941 ad9523_write(indio_dev
,
942 AD9523_CHANNEL_CLOCK_DIST(i
),
943 AD9523_CLK_DIST_DRIVER_MODE(TRISTATE
) |
944 AD9523_CLK_DIST_PWR_DOWN_EN
);
946 ret
= ad9523_write(indio_dev
, AD9523_POWER_DOWN_CTRL
, 0);
950 ret
= ad9523_write(indio_dev
, AD9523_STATUS_SIGNALS
,
951 AD9523_STATUS_MONITOR_01_PLL12_LOCKED
);
955 ret
= ad9523_io_update(indio_dev
);
962 static int ad9523_probe(struct spi_device
*spi
)
964 struct ad9523_platform_data
*pdata
= spi
->dev
.platform_data
;
965 struct iio_dev
*indio_dev
;
966 struct ad9523_state
*st
;
970 dev_err(&spi
->dev
, "no platform data?\n");
974 indio_dev
= iio_device_alloc(sizeof(*st
));
975 if (indio_dev
== NULL
)
978 st
= iio_priv(indio_dev
);
980 st
->reg
= regulator_get(&spi
->dev
, "vcc");
981 if (!IS_ERR(st
->reg
)) {
982 ret
= regulator_enable(st
->reg
);
987 spi_set_drvdata(spi
, indio_dev
);
991 indio_dev
->dev
.parent
= &spi
->dev
;
992 indio_dev
->name
= (pdata
->name
[0] != 0) ? pdata
->name
:
993 spi_get_device_id(spi
)->name
;
994 indio_dev
->info
= &ad9523_info
;
995 indio_dev
->modes
= INDIO_DIRECT_MODE
;
996 indio_dev
->channels
= st
->ad9523_channels
;
997 indio_dev
->num_channels
= pdata
->num_channels
;
999 ret
= ad9523_setup(indio_dev
);
1001 goto error_disable_reg
;
1003 ret
= iio_device_register(indio_dev
);
1005 goto error_disable_reg
;
1007 dev_info(&spi
->dev
, "probed %s\n", indio_dev
->name
);
1012 if (!IS_ERR(st
->reg
))
1013 regulator_disable(st
->reg
);
1015 if (!IS_ERR(st
->reg
))
1016 regulator_put(st
->reg
);
1018 iio_device_free(indio_dev
);
1023 static int ad9523_remove(struct spi_device
*spi
)
1025 struct iio_dev
*indio_dev
= spi_get_drvdata(spi
);
1026 struct ad9523_state
*st
= iio_priv(indio_dev
);
1028 iio_device_unregister(indio_dev
);
1030 if (!IS_ERR(st
->reg
)) {
1031 regulator_disable(st
->reg
);
1032 regulator_put(st
->reg
);
1035 iio_device_free(indio_dev
);
1040 static const struct spi_device_id ad9523_id
[] = {
1044 MODULE_DEVICE_TABLE(spi
, ad9523_id
);
1046 static struct spi_driver ad9523_driver
= {
1049 .owner
= THIS_MODULE
,
1051 .probe
= ad9523_probe
,
1052 .remove
= ad9523_remove
,
1053 .id_table
= ad9523_id
,
1055 module_spi_driver(ad9523_driver
);
1057 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
1058 MODULE_DESCRIPTION("Analog Devices AD9523 CLOCKDIST/PLL");
1059 MODULE_LICENSE("GPL v2");