iio: adc: ad4170-4: Add clock provider support

The AD4170-4 chip can use an externally supplied clock at the XTAL2 pin, or
an external crystal connected to the XTAL1 and XTAL2 pins. Alternatively,
the AD4170-4 can provide its 16 MHz internal clock at the XTAL2 pin. In
addition, the chip has a programmable clock divider that allows dividing
the external or internal clock frequency, however, control for that is not
provided in this patch. Extend the AD4170-4 driver so it effectively uses
the provided external clock, if any, or supplies its own clock as a clock
provider.

Reviewed-by: Nuno Sá <nuno.sa@analog.com>
Signed-off-by: Marcelo Schmitt <marcelo.schmitt@analog.com>
Link: https://patch.msgid.link/68697c7613b1a69d752e541caef28d08b3e59bc1.1751895245.git.marcelo.schmitt@analog.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index 538929b3df6e2a94c3df9996d4132eba6891055e..36e506e8d8f1c94929820de33a21a184a281405b 100644 (file)
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -91,6 +91,7 @@ config AD4170_4
        select REGMAP_SPI
        select IIO_BUFFER
        select IIO_TRIGGERED_BUFFER
+       depends on COMMON_CLK
        help
          Say yes here to build support for Analog Devices AD4170-4 SPI analog
          to digital converters (ADC).

diff --git a/drivers/iio/adc/ad4170-4.c b/drivers/iio/adc/ad4170-4.c
index 30ae667a252c924573df12bee6b3bd3e3c9ff509..32e52d24656a04426b0f123ce529460ae6a09840 100644 (file)
--- a/drivers/iio/adc/ad4170-4.c
+++ b/drivers/iio/adc/ad4170-4.c
@@ -13,6 +13,8 @@
 #include <linux/bitops.h>
 #include <linux/bits.h>
 #include <linux/cleanup.h>
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/err.h>
@@ -55,6 +57,7 @@
 #define AD4170_CONFIG_A_REG                            0x00
 #define AD4170_DATA_24B_REG                            0x1E
 #define AD4170_PIN_MUXING_REG                          0x69
+#define AD4170_CLOCK_CTRL_REG                          0x6B
 #define AD4170_ADC_CTRL_REG                            0x71
 #define AD4170_CHAN_EN_REG                             0x79
 #define AD4170_CHAN_SETUP_REG(x)                       (0x81 + 4 * (x))
@@ -75,6 +78,9 @@
 /* AD4170_PIN_MUXING_REG */
 #define AD4170_PIN_MUXING_DIG_AUX1_CTRL_MSK            GENMASK(5, 4)
 
+/* AD4170_CLOCK_CTRL_REG */
+#define AD4170_CLOCK_CTRL_CLOCKSEL_MSK                 GENMASK(1, 0)
+
 /* AD4170_ADC_CTRL_REG */
 #define AD4170_ADC_CTRL_MULTI_DATA_REG_SEL_MSK         BIT(7)
 #define AD4170_ADC_CTRL_CONT_READ_MSK                  GENMASK(5, 4)
@@ -102,6 +108,12 @@
 
 /* AD4170 register constants */
 
+/* AD4170_CLOCK_CTRL_REG constants */
+#define AD4170_CLOCK_CTRL_CLOCKSEL_INT                 0x0
+#define AD4170_CLOCK_CTRL_CLOCKSEL_INT_OUT             0x1
+#define AD4170_CLOCK_CTRL_CLOCKSEL_EXT                 0x2
+#define AD4170_CLOCK_CTRL_CLOCKSEL_EXT_XTAL            0x3
+
 /* AD4170_CHAN_MAP_REG constants */
 #define AD4170_CHAN_MAP_AIN(x)                 (x)
 #define AD4170_CHAN_MAP_TEMP_SENSOR            17
@@ -150,6 +162,8 @@
 
 /* Internal and external clock properties */
 #define AD4170_INT_CLOCK_16MHZ                         (16 * HZ_PER_MHZ)
+#define AD4170_EXT_CLOCK_MHZ_MIN                       (1 * HZ_PER_MHZ)
+#define AD4170_EXT_CLOCK_MHZ_MAX                       (17 * HZ_PER_MHZ)
 
 #define AD4170_NUM_PGA_OPTIONS                         10
 
@@ -167,6 +181,7 @@ static const unsigned int ad4170_reg_size[] = {
        [AD4170_CONFIG_A_REG] = 1,
        [AD4170_DATA_24B_REG] = 3,
        [AD4170_PIN_MUXING_REG] = 2,
+       [AD4170_CLOCK_CTRL_REG] = 2,
        [AD4170_ADC_CTRL_REG] = 2,
        [AD4170_CHAN_EN_REG] = 2,
        /*
@@ -239,6 +254,10 @@ enum ad4170_regulator {
        AD4170_MAX_SUP,
 };
 
+static const char *const ad4170_clk_sel[] = {
+       "ext-clk", "xtal",
+};
+
 enum ad4170_int_pin_sel {
        AD4170_INT_PIN_SDO,
        AD4170_INT_PIN_DIG_AUX1,
@@ -343,6 +362,8 @@ struct ad4170_state {
        struct spi_message msg;
        struct spi_transfer xfer;
        struct iio_trigger *trig;
+       struct clk_hw int_clk_hw;
+       unsigned int clock_ctrl;
        unsigned int pins_fn[AD4170_NUM_ANALOG_PINS];
        /*
         * DMA (thus cache coherency maintenance) requires the transfer buffers
@@ -1646,6 +1667,124 @@ static int ad4170_parse_channels(struct iio_dev *indio_dev)
        return 0;
 }
 
+static struct ad4170_state *clk_hw_to_ad4170(struct clk_hw *hw)
+{
+       return container_of(hw, struct ad4170_state, int_clk_hw);
+}
+
+static unsigned long ad4170_sel_clk(struct ad4170_state *st,
+                                   unsigned int clk_sel)
+{
+       st->clock_ctrl &= ~AD4170_CLOCK_CTRL_CLOCKSEL_MSK;
+       st->clock_ctrl |= FIELD_PREP(AD4170_CLOCK_CTRL_CLOCKSEL_MSK, clk_sel);
+       return regmap_write(st->regmap, AD4170_CLOCK_CTRL_REG, st->clock_ctrl);
+}
+
+static unsigned long ad4170_clk_recalc_rate(struct clk_hw *hw,
+                                           unsigned long parent_rate)
+{
+       return AD4170_INT_CLOCK_16MHZ;
+}
+
+static int ad4170_clk_output_is_enabled(struct clk_hw *hw)
+{
+       struct ad4170_state *st = clk_hw_to_ad4170(hw);
+       u32 clk_sel;
+
+       clk_sel = FIELD_GET(AD4170_CLOCK_CTRL_CLOCKSEL_MSK, st->clock_ctrl);
+       return clk_sel == AD4170_CLOCK_CTRL_CLOCKSEL_INT_OUT;
+}
+
+static int ad4170_clk_output_prepare(struct clk_hw *hw)
+{
+       struct ad4170_state *st = clk_hw_to_ad4170(hw);
+
+       return ad4170_sel_clk(st, AD4170_CLOCK_CTRL_CLOCKSEL_INT_OUT);
+}
+
+static void ad4170_clk_output_unprepare(struct clk_hw *hw)
+{
+       struct ad4170_state *st = clk_hw_to_ad4170(hw);
+
+       ad4170_sel_clk(st, AD4170_CLOCK_CTRL_CLOCKSEL_INT);
+}
+
+static const struct clk_ops ad4170_int_clk_ops = {
+       .recalc_rate = ad4170_clk_recalc_rate,
+       .is_enabled = ad4170_clk_output_is_enabled,
+       .prepare = ad4170_clk_output_prepare,
+       .unprepare = ad4170_clk_output_unprepare,
+};
+
+static int ad4170_register_clk_provider(struct iio_dev *indio_dev)
+{
+       struct ad4170_state *st = iio_priv(indio_dev);
+       struct device *dev = indio_dev->dev.parent;
+       struct clk_init_data init = {};
+       int ret;
+
+       if (device_property_read_string(dev, "clock-output-names", &init.name)) {
+               init.name = devm_kasprintf(dev, GFP_KERNEL, "%pfw",
+                                          dev_fwnode(dev));
+               if (!init.name)
+                       return -ENOMEM;
+       }
+
+       init.ops = &ad4170_int_clk_ops;
+
+       st->int_clk_hw.init = &init;
+       ret = devm_clk_hw_register(dev, &st->int_clk_hw);
+       if (ret)
+               return ret;
+
+       return devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get,
+                                          &st->int_clk_hw);
+}
+
+static int ad4170_clock_select(struct iio_dev *indio_dev)
+{
+       struct ad4170_state *st = iio_priv(indio_dev);
+       struct device *dev = &st->spi->dev;
+       struct clk *ext_clk;
+       int ret;
+
+       ext_clk = devm_clk_get_optional_enabled(dev, NULL);
+       if (IS_ERR(ext_clk))
+               return dev_err_probe(dev, PTR_ERR(ext_clk),
+                                    "Failed to get external clock\n");
+
+       if (!ext_clk) {
+               /* Use internal clock reference */
+               st->mclk_hz = AD4170_INT_CLOCK_16MHZ;
+               st->clock_ctrl |= FIELD_PREP(AD4170_CLOCK_CTRL_CLOCKSEL_MSK,
+                                            AD4170_CLOCK_CTRL_CLOCKSEL_INT_OUT);
+
+               if (!device_property_present(&st->spi->dev, "#clock-cells"))
+                       return 0;
+
+               return ad4170_register_clk_provider(indio_dev);
+       }
+
+       /* Read optional clock-names prop to specify the external clock type */
+       ret = device_property_match_property_string(dev, "clock-names",
+                                                   ad4170_clk_sel,
+                                                   ARRAY_SIZE(ad4170_clk_sel));
+
+       ret = ret < 0 ? 0 : ret; /* Default to external clock if no clock-names */
+       st->clock_ctrl |= FIELD_PREP(AD4170_CLOCK_CTRL_CLOCKSEL_MSK,
+                                    AD4170_CLOCK_CTRL_CLOCKSEL_EXT + ret);
+
+       st->mclk_hz = clk_get_rate(ext_clk);
+       if (st->mclk_hz < AD4170_EXT_CLOCK_MHZ_MIN ||
+           st->mclk_hz > AD4170_EXT_CLOCK_MHZ_MAX) {
+               return dev_err_probe(dev, -EINVAL,
+                                    "Invalid external clock frequency %u\n",
+                                    st->mclk_hz);
+       }
+
+       return 0;
+}
+
 static int ad4170_parse_firmware(struct iio_dev *indio_dev)
 {
        struct ad4170_state *st = iio_priv(indio_dev);
@@ -1653,7 +1792,13 @@ static int ad4170_parse_firmware(struct iio_dev *indio_dev)
        int reg_data, ret;
        u32 int_pin_sel;
 
-       st->mclk_hz = AD4170_INT_CLOCK_16MHZ;
+       ret = ad4170_clock_select(indio_dev);
+       if (ret)
+               return dev_err_probe(dev, ret, "Failed to setup device clock\n");
+
+       ret = regmap_write(st->regmap, AD4170_CLOCK_CTRL_REG, st->clock_ctrl);
+       if (ret)
+               return ret;
 
        /* On power on, device defaults to using SDO pin for data ready signal */
        int_pin_sel = AD4170_INT_PIN_SDO;