summaryrefslogtreecommitdiff
path: root/drivers/iio/dac
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/iio/dac')
-rw-r--r--drivers/iio/dac/Kconfig31
-rw-r--r--drivers/iio/dac/Makefile2
-rw-r--r--drivers/iio/dac/ad3530r.c3
-rw-r--r--drivers/iio/dac/ad5446-i2c.c102
-rw-r--r--drivers/iio/dac/ad5446-spi.c252
-rw-r--r--drivers/iio/dac/ad5446.c506
-rw-r--r--drivers/iio/dac/ad5446.h77
-rw-r--r--drivers/iio/dac/ltc2688.c32
8 files changed, 530 insertions, 475 deletions
diff --git a/drivers/iio/dac/Kconfig b/drivers/iio/dac/Kconfig
index e0996dc014a3..7cd3caec1262 100644
--- a/drivers/iio/dac/Kconfig
+++ b/drivers/iio/dac/Kconfig
@@ -97,17 +97,32 @@ config AD5421
ad5421.
config AD5446
- tristate "Analog Devices AD5446 and similar single channel DACs driver"
- depends on (SPI_MASTER && I2C!=m) || I2C
+ tristate
+
+config AD5446_SPI
+ tristate "Analog Devices AD5446 and similar single channel DACs driver (SPI)"
+ depends on SPI
+ select AD5446
+ help
+ Say yes here to build support for Analog Devices AD5300, AD5310,
+ AD5320, AD5444, AD5446, AD5450, AD5451, AD5452, AD5453, AD5512A,
+ AD5541A, AD5542A, AD5543, AD5553, AD5600, AD5601, AD5611, AD5620,
+ AD5621, AD5640, AD5641, AD5660, AD5662 DACs as well as
+ Texas Instruments DAC081S101, DAC101S101, DAC121S101.
+
+ To compile this driver as a module, choose M here: the
+ module will be called ad5446-spi.
+
+config AD5446_I2C
+ tristate "Analog Devices AD5446 and similar single channel DACs driver (I2C)"
+ depends on I2C
+ select AD5446
help
- Say yes here to build support for Analog Devices AD5300, AD5301, AD5310,
- AD5311, AD5320, AD5321, AD5444, AD5446, AD5450, AD5451, AD5452, AD5453,
- AD5512A, AD5541A, AD5542A, AD5543, AD5553, AD5600, AD5601, AD5602, AD5611,
- AD5612, AD5620, AD5621, AD5622, AD5640, AD5641, AD5660, AD5662 DACs
- as well as Texas Instruments DAC081S101, DAC101S101, DAC121S101.
+ Say yes here to build support for Analog Devices AD5301, AD5311, AD5321,
+ AD5602, AD5612, AD5622 DACs.
To compile this driver as a module, choose M here: the
- module will be called ad5446.
+ module will be called ad5446-i2c.
config AD5449
tristate "Analog Devices AD5449 and similar DACs driver"
diff --git a/drivers/iio/dac/Makefile b/drivers/iio/dac/Makefile
index 3684cd52b7fa..e6ac4c67e337 100644
--- a/drivers/iio/dac/Makefile
+++ b/drivers/iio/dac/Makefile
@@ -15,6 +15,8 @@ obj-$(CONFIG_AD5624R_SPI) += ad5624r_spi.o
obj-$(CONFIG_AD5064) += ad5064.o
obj-$(CONFIG_AD5504) += ad5504.o
obj-$(CONFIG_AD5446) += ad5446.o
+obj-$(CONFIG_AD5446_SPI) += ad5446-spi.o
+obj-$(CONFIG_AD5446_I2C) += ad5446-i2c.o
obj-$(CONFIG_AD5449) += ad5449.o
obj-$(CONFIG_AD5592R_BASE) += ad5592r-base.o
obj-$(CONFIG_AD5592R) += ad5592r.o
diff --git a/drivers/iio/dac/ad3530r.c b/drivers/iio/dac/ad3530r.c
index 6134613777b8..b97b46090d80 100644
--- a/drivers/iio/dac/ad3530r.c
+++ b/drivers/iio/dac/ad3530r.c
@@ -53,9 +53,6 @@
#define AD3530R_MAX_CHANNELS 8
#define AD3531R_MAX_CHANNELS 4
-/* Non-constant mask variant of FIELD_PREP() */
-#define field_prep(_mask, _val) (((_val) << (ffs(_mask) - 1)) & (_mask))
-
enum ad3530r_mode {
AD3530R_NORMAL_OP,
AD3530R_POWERDOWN_1K,
diff --git a/drivers/iio/dac/ad5446-i2c.c b/drivers/iio/dac/ad5446-i2c.c
new file mode 100644
index 000000000000..40fe7e17fce4
--- /dev/null
+++ b/drivers/iio/dac/ad5446-i2c.c
@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * AD5446 SPI I2C driver
+ *
+ * Copyright 2025 Analog Devices Inc.
+ */
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/mod_devicetable.h>
+#include <linux/i2c.h>
+
+#include <asm/byteorder.h>
+
+#include "ad5446.h"
+
+static int ad5622_write(struct ad5446_state *st, unsigned int val)
+{
+ struct i2c_client *client = to_i2c_client(st->dev);
+ int ret;
+
+ st->d16 = cpu_to_be16(val);
+
+ ret = i2c_master_send_dmasafe(client, (char *)&st->d16, sizeof(st->d16));
+ if (ret < 0)
+ return ret;
+ if (ret != sizeof(st->d16))
+ return -EIO;
+
+ return 0;
+}
+
+static int ad5446_i2c_probe(struct i2c_client *i2c)
+{
+ const struct i2c_device_id *id = i2c_client_get_device_id(i2c);
+ const struct ad5446_chip_info *chip_info;
+
+ chip_info = i2c_get_match_data(i2c);
+ if (!chip_info)
+ return -ENODEV;
+
+ return ad5446_probe(&i2c->dev, id->name, chip_info);
+}
+
+/*
+ * ad5446_supported_i2c_device_ids:
+ * The AD5620/40/60 parts are available in different fixed internal reference
+ * voltage options. The actual part numbers may look differently
+ * (and a bit cryptic), however this style is used to make clear which
+ * parts are supported here.
+ */
+
+static const struct ad5446_chip_info ad5602_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
+ .write = ad5622_write,
+};
+
+static const struct ad5446_chip_info ad5612_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
+ .write = ad5622_write,
+};
+
+static const struct ad5446_chip_info ad5622_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
+ .write = ad5622_write,
+};
+
+static const struct i2c_device_id ad5446_i2c_ids[] = {
+ {"ad5301", (kernel_ulong_t)&ad5602_chip_info},
+ {"ad5311", (kernel_ulong_t)&ad5612_chip_info},
+ {"ad5321", (kernel_ulong_t)&ad5622_chip_info},
+ {"ad5602", (kernel_ulong_t)&ad5602_chip_info},
+ {"ad5612", (kernel_ulong_t)&ad5612_chip_info},
+ {"ad5622", (kernel_ulong_t)&ad5622_chip_info},
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, ad5446_i2c_ids);
+
+static const struct of_device_id ad5446_i2c_of_ids[] = {
+ { .compatible = "adi,ad5301", .data = &ad5602_chip_info },
+ { .compatible = "adi,ad5311", .data = &ad5612_chip_info },
+ { .compatible = "adi,ad5321", .data = &ad5622_chip_info },
+ { .compatible = "adi,ad5602", .data = &ad5602_chip_info },
+ { .compatible = "adi,ad5612", .data = &ad5612_chip_info },
+ { .compatible = "adi,ad5622", .data = &ad5622_chip_info },
+ { }
+};
+MODULE_DEVICE_TABLE(OF, ad5446_i2c_of_ids);
+
+static struct i2c_driver ad5446_i2c_driver = {
+ .driver = {
+ .name = "ad5446",
+ .of_match_table = ad5446_i2c_of_ids,
+ },
+ .probe = ad5446_i2c_probe,
+ .id_table = ad5446_i2c_ids,
+};
+module_i2c_driver(ad5446_i2c_driver);
+
+MODULE_AUTHOR("Nuno Sá <nuno.sa@analog.com>");
+MODULE_DESCRIPTION("Analog Devices AD5622 and similar I2C DACs");
+MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS("IIO_AD5446");
diff --git a/drivers/iio/dac/ad5446-spi.c b/drivers/iio/dac/ad5446-spi.c
new file mode 100644
index 000000000000..e29d77f21482
--- /dev/null
+++ b/drivers/iio/dac/ad5446-spi.c
@@ -0,0 +1,252 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * AD5446 SPI DAC driver
+ *
+ * Copyright 2025 Analog Devices Inc.
+ */
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/mod_devicetable.h>
+#include <linux/spi/spi.h>
+#include <linux/unaligned.h>
+
+#include <asm/byteorder.h>
+
+#include "ad5446.h"
+
+static int ad5446_write(struct ad5446_state *st, unsigned int val)
+{
+ struct spi_device *spi = to_spi_device(st->dev);
+
+ st->d16 = cpu_to_be16(val);
+
+ return spi_write(spi, &st->d16, sizeof(st->d16));
+}
+
+static int ad5660_write(struct ad5446_state *st, unsigned int val)
+{
+ struct spi_device *spi = to_spi_device(st->dev);
+
+ put_unaligned_be24(val, st->d24);
+
+ return spi_write(spi, st->d24, sizeof(st->d24));
+}
+
+static int ad5446_spi_probe(struct spi_device *spi)
+{
+ const struct spi_device_id *id = spi_get_device_id(spi);
+ const struct ad5446_chip_info *chip_info;
+
+ chip_info = spi_get_device_match_data(spi);
+ if (!chip_info)
+ return -ENODEV;
+
+ return ad5446_probe(&spi->dev, id->name, chip_info);
+}
+
+/*
+ * ad5446_supported_spi_device_ids:
+ * The AD5620/40/60 parts are available in different fixed internal reference
+ * voltage options. The actual part numbers may look differently
+ * (and a bit cryptic), however this style is used to make clear which
+ * parts are supported here.
+ */
+
+static const struct ad5446_chip_info ad5300_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5310_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5320_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5444_chip_info = {
+ .channel = AD5446_CHANNEL(12, 16, 2),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5446_chip_info = {
+ .channel = AD5446_CHANNEL(14, 16, 0),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5450_chip_info = {
+ .channel = AD5446_CHANNEL(8, 16, 6),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5451_chip_info = {
+ .channel = AD5446_CHANNEL(10, 16, 4),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5541a_chip_info = {
+ .channel = AD5446_CHANNEL(16, 16, 0),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5512a_chip_info = {
+ .channel = AD5446_CHANNEL(12, 16, 4),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5553_chip_info = {
+ .channel = AD5446_CHANNEL(14, 16, 0),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5601_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5611_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5621_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5641_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5620_2500_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
+ .int_vref_mv = 2500,
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5620_1250_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
+ .int_vref_mv = 1250,
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5640_2500_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
+ .int_vref_mv = 2500,
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5640_1250_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
+ .int_vref_mv = 1250,
+ .write = ad5446_write,
+};
+
+static const struct ad5446_chip_info ad5660_2500_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
+ .int_vref_mv = 2500,
+ .write = ad5660_write,
+};
+
+static const struct ad5446_chip_info ad5660_1250_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
+ .int_vref_mv = 1250,
+ .write = ad5660_write,
+};
+
+static const struct ad5446_chip_info ad5662_chip_info = {
+ .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
+ .write = ad5660_write,
+};
+
+static const struct spi_device_id ad5446_spi_ids[] = {
+ {"ad5300", (kernel_ulong_t)&ad5300_chip_info},
+ {"ad5310", (kernel_ulong_t)&ad5310_chip_info},
+ {"ad5320", (kernel_ulong_t)&ad5320_chip_info},
+ {"ad5444", (kernel_ulong_t)&ad5444_chip_info},
+ {"ad5446", (kernel_ulong_t)&ad5446_chip_info},
+ {"ad5450", (kernel_ulong_t)&ad5450_chip_info},
+ {"ad5451", (kernel_ulong_t)&ad5451_chip_info},
+ {"ad5452", (kernel_ulong_t)&ad5444_chip_info}, /* ad5452 is compatible to the ad5444 */
+ {"ad5453", (kernel_ulong_t)&ad5446_chip_info}, /* ad5453 is compatible to the ad5446 */
+ {"ad5512a", (kernel_ulong_t)&ad5512a_chip_info},
+ {"ad5541a", (kernel_ulong_t)&ad5541a_chip_info},
+ {"ad5542", (kernel_ulong_t)&ad5541a_chip_info}, /* ad5541a and ad5542 are compatible */
+ {"ad5542a", (kernel_ulong_t)&ad5541a_chip_info}, /* ad5541a and ad5542a are compatible */
+ {"ad5543", (kernel_ulong_t)&ad5541a_chip_info}, /* ad5541a and ad5543 are compatible */
+ {"ad5553", (kernel_ulong_t)&ad5553_chip_info},
+ {"ad5600", (kernel_ulong_t)&ad5541a_chip_info}, /* ad5541a and ad5600 are compatible */
+ {"ad5601", (kernel_ulong_t)&ad5601_chip_info},
+ {"ad5611", (kernel_ulong_t)&ad5611_chip_info},
+ {"ad5621", (kernel_ulong_t)&ad5621_chip_info},
+ {"ad5641", (kernel_ulong_t)&ad5641_chip_info},
+ {"ad5620-2500", (kernel_ulong_t)&ad5620_2500_chip_info}, /* AD5620/40/60: */
+ /* part numbers may look differently */
+ {"ad5620-1250", (kernel_ulong_t)&ad5620_1250_chip_info},
+ {"ad5640-2500", (kernel_ulong_t)&ad5640_2500_chip_info},
+ {"ad5640-1250", (kernel_ulong_t)&ad5640_1250_chip_info},
+ {"ad5660-2500", (kernel_ulong_t)&ad5660_2500_chip_info},
+ {"ad5660-1250", (kernel_ulong_t)&ad5660_1250_chip_info},
+ {"ad5662", (kernel_ulong_t)&ad5662_chip_info},
+ {"dac081s101", (kernel_ulong_t)&ad5300_chip_info}, /* compatible Texas Instruments chips */
+ {"dac101s101", (kernel_ulong_t)&ad5310_chip_info},
+ {"dac121s101", (kernel_ulong_t)&ad5320_chip_info},
+ {"dac7512", (kernel_ulong_t)&ad5320_chip_info},
+ { }
+};
+MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);
+
+static const struct of_device_id ad5446_of_ids[] = {
+ { .compatible = "adi,ad5300", .data = &ad5300_chip_info },
+ { .compatible = "adi,ad5310", .data = &ad5310_chip_info },
+ { .compatible = "adi,ad5320", .data = &ad5320_chip_info },
+ { .compatible = "adi,ad5444", .data = &ad5444_chip_info },
+ { .compatible = "adi,ad5446", .data = &ad5446_chip_info },
+ { .compatible = "adi,ad5450", .data = &ad5450_chip_info },
+ { .compatible = "adi,ad5451", .data = &ad5451_chip_info },
+ { .compatible = "adi,ad5452", .data = &ad5444_chip_info },
+ { .compatible = "adi,ad5453", .data = &ad5446_chip_info },
+ { .compatible = "adi,ad5512a", .data = &ad5512a_chip_info },
+ { .compatible = "adi,ad5541a", .data = &ad5541a_chip_info },
+ { .compatible = "adi,ad5542", .data = &ad5541a_chip_info },
+ { .compatible = "adi,ad5542a", .data = &ad5541a_chip_info },
+ { .compatible = "adi,ad5543", .data = &ad5541a_chip_info },
+ { .compatible = "adi,ad5553", .data = &ad5553_chip_info },
+ { .compatible = "adi,ad5600", .data = &ad5541a_chip_info },
+ { .compatible = "adi,ad5601", .data = &ad5601_chip_info },
+ { .compatible = "adi,ad5611", .data = &ad5611_chip_info },
+ { .compatible = "adi,ad5621", .data = &ad5621_chip_info },
+ { .compatible = "adi,ad5641", .data = &ad5641_chip_info },
+ { .compatible = "adi,ad5620-2500", .data = &ad5620_2500_chip_info },
+ { .compatible = "adi,ad5620-1250", .data = &ad5620_1250_chip_info },
+ { .compatible = "adi,ad5640-2500", .data = &ad5640_2500_chip_info },
+ { .compatible = "adi,ad5640-1250", .data = &ad5640_1250_chip_info },
+ { .compatible = "adi,ad5660-2500", .data = &ad5660_2500_chip_info },
+ { .compatible = "adi,ad5660-1250", .data = &ad5660_1250_chip_info },
+ { .compatible = "adi,ad5662", .data = &ad5662_chip_info },
+ { .compatible = "ti,dac081s101", .data = &ad5300_chip_info },
+ { .compatible = "ti,dac101s101", .data = &ad5310_chip_info },
+ { .compatible = "ti,dac121s101", .data = &ad5320_chip_info },
+ { .compatible = "ti,dac7512", .data = &ad5320_chip_info },
+ { }
+};
+MODULE_DEVICE_TABLE(of, ad5446_of_ids);
+
+static struct spi_driver ad5446_spi_driver = {
+ .driver = {
+ .name = "ad5446",
+ .of_match_table = ad5446_of_ids,
+ },
+ .probe = ad5446_spi_probe,
+ .id_table = ad5446_spi_ids,
+};
+module_spi_driver(ad5446_spi_driver);
+
+MODULE_AUTHOR("Nuno Sá <nuno.sa@analog.com>");
+MODULE_DESCRIPTION("Analog Devices AD5446 and similar SPI DACs");
+MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS("IIO_AD5446");
diff --git a/drivers/iio/dac/ad5446.c b/drivers/iio/dac/ad5446.c
index ad304b0fec08..46a2eadb1d9b 100644
--- a/drivers/iio/dac/ad5446.c
+++ b/drivers/iio/dac/ad5446.c
@@ -1,73 +1,35 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
- * AD5446 SPI DAC driver
+ * AD5446 CORE DAC driver
*
* Copyright 2010 Analog Devices Inc.
*/
-#include <linux/interrupt.h>
-#include <linux/workqueue.h>
+#include <linux/array_size.h>
+#include <linux/cleanup.h>
#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/list.h>
-#include <linux/spi/spi.h>
-#include <linux/i2c.h>
-#include <linux/regulator/consumer.h>
#include <linux/err.h>
-#include <linux/module.h>
-#include <linux/mod_devicetable.h>
-
+#include <linux/export.h>
#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
+#include <linux/kstrtox.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/regulator/consumer.h>
+#include <linux/sysfs.h>
-#include <linux/unaligned.h>
+#include "ad5446.h"
#define MODE_PWRDWN_1k 0x1
#define MODE_PWRDWN_100k 0x2
#define MODE_PWRDWN_TRISTATE 0x3
-/**
- * struct ad5446_state - driver instance specific data
- * @dev: this device
- * @chip_info: chip model specific constants, available modes etc
- * @vref_mv: actual reference voltage used
- * @cached_val: store/retrieve values during power down
- * @pwr_down_mode: power down mode (1k, 100k or tristate)
- * @pwr_down: true if the device is in power down
- * @lock: lock to protect the data buffer during write ops
- */
-
-struct ad5446_state {
- struct device *dev;
- const struct ad5446_chip_info *chip_info;
- unsigned short vref_mv;
- unsigned cached_val;
- unsigned pwr_down_mode;
- unsigned pwr_down;
- struct mutex lock;
-};
-
-/**
- * struct ad5446_chip_info - chip specific information
- * @channel: channel spec for the DAC
- * @int_vref_mv: AD5620/40/60: the internal reference voltage
- * @write: chip specific helper function to write to the register
- */
-
-struct ad5446_chip_info {
- struct iio_chan_spec channel;
- u16 int_vref_mv;
- int (*write)(struct ad5446_state *st, unsigned val);
-};
-
static const char * const ad5446_powerdown_modes[] = {
"1kohm_to_gnd", "100kohm_to_gnd", "three_state"
};
static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
- const struct iio_chan_spec *chan, unsigned int mode)
+ const struct iio_chan_spec *chan,
+ unsigned int mode)
{
struct ad5446_state *st = iio_priv(indio_dev);
@@ -77,7 +39,7 @@ static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
}
static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev,
- const struct iio_chan_spec *chan)
+ const struct iio_chan_spec *chan)
{
struct ad5446_state *st = iio_priv(indio_dev);
@@ -92,9 +54,9 @@ static const struct iio_enum ad5446_powerdown_mode_enum = {
};
static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
- uintptr_t private,
- const struct iio_chan_spec *chan,
- char *buf)
+ uintptr_t private,
+ const struct iio_chan_spec *chan,
+ char *buf)
{
struct ad5446_state *st = iio_priv(indio_dev);
@@ -102,9 +64,9 @@ static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
}
static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
- uintptr_t private,
- const struct iio_chan_spec *chan,
- const char *buf, size_t len)
+ uintptr_t private,
+ const struct iio_chan_spec *chan,
+ const char *buf, size_t len)
{
struct ad5446_state *st = iio_priv(indio_dev);
unsigned int shift;
@@ -116,7 +78,7 @@ static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
if (ret)
return ret;
- mutex_lock(&st->lock);
+ guard(mutex)(&st->lock);
st->pwr_down = powerdown;
if (st->pwr_down) {
@@ -127,12 +89,13 @@ static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
}
ret = st->chip_info->write(st, val);
- mutex_unlock(&st->lock);
+ if (ret)
+ return ret;
- return ret ? ret : len;
+ return len;
}
-static const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[] = {
+const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[] = {
{
.name = "powerdown",
.read = ad5446_read_dac_powerdown,
@@ -143,28 +106,7 @@ static const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[] = {
IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &ad5446_powerdown_mode_enum),
{ }
};
-
-#define _AD5446_CHANNEL(bits, storage, _shift, ext) { \
- .type = IIO_VOLTAGE, \
- .indexed = 1, \
- .output = 1, \
- .channel = 0, \
- .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
- .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
- .scan_type = { \
- .sign = 'u', \
- .realbits = (bits), \
- .storagebits = (storage), \
- .shift = (_shift), \
- }, \
- .ext_info = (ext), \
-}
-
-#define AD5446_CHANNEL(bits, storage, shift) \
- _AD5446_CHANNEL(bits, storage, shift, NULL)
-
-#define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
- _AD5446_CHANNEL(bits, storage, shift, ad5446_ext_info_powerdown)
+EXPORT_SYMBOL_NS_GPL(ad5446_ext_info_powerdown, "IIO_AD5446");
static int ad5446_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
@@ -186,32 +128,35 @@ static int ad5446_read_raw(struct iio_dev *indio_dev,
return -EINVAL;
}
-static int ad5446_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int val,
- int val2,
- long mask)
+static int ad5446_write_dac_raw(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan,
+ int val)
{
struct ad5446_state *st = iio_priv(indio_dev);
- int ret = 0;
+ if (val >= (1 << chan->scan_type.realbits) || val < 0)
+ return -EINVAL;
+
+ val <<= chan->scan_type.shift;
+ guard(mutex)(&st->lock);
+
+ st->cached_val = val;
+ if (st->pwr_down)
+ return 0;
+
+ return st->chip_info->write(st, val);
+}
+
+static int ad5446_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan, int val,
+ int val2, long mask)
+{
switch (mask) {
case IIO_CHAN_INFO_RAW:
- if (val >= (1 << chan->scan_type.realbits) || val < 0)
- return -EINVAL;
-
- val <<= chan->scan_type.shift;
- mutex_lock(&st->lock);
- st->cached_val = val;
- if (!st->pwr_down)
- ret = st->chip_info->write(st, val);
- mutex_unlock(&st->lock);
- break;
+ return ad5446_write_dac_raw(indio_dev, chan, val);
default:
- ret = -EINVAL;
+ return -EINVAL;
}
-
- return ret;
}
static const struct iio_info ad5446_info = {
@@ -219,8 +164,8 @@ static const struct iio_info ad5446_info = {
.write_raw = ad5446_write_raw,
};
-static int ad5446_probe(struct device *dev, const char *name,
- const struct ad5446_chip_info *chip_info)
+int ad5446_probe(struct device *dev, const char *name,
+ const struct ad5446_chip_info *chip_info)
{
struct ad5446_state *st;
struct iio_dev *indio_dev;
@@ -241,7 +186,9 @@ static int ad5446_probe(struct device *dev, const char *name,
indio_dev->channels = &st->chip_info->channel;
indio_dev->num_channels = 1;
- mutex_init(&st->lock);
+ ret = devm_mutex_init(dev, &st->lock);
+ if (ret)
+ return ret;
st->pwr_down_mode = MODE_PWRDWN_1k;
@@ -249,354 +196,19 @@ static int ad5446_probe(struct device *dev, const char *name,
if (ret < 0 && ret != -ENODEV)
return ret;
if (ret == -ENODEV) {
- if (chip_info->int_vref_mv)
- st->vref_mv = chip_info->int_vref_mv;
- else
- dev_warn(dev, "reference voltage unspecified\n");
+ if (!chip_info->int_vref_mv)
+ return dev_err_probe(dev, ret,
+ "reference voltage unspecified\n");
+
+ st->vref_mv = chip_info->int_vref_mv;
} else {
st->vref_mv = ret / 1000;
}
return devm_iio_device_register(dev, indio_dev);
}
-
-#if IS_ENABLED(CONFIG_SPI_MASTER)
-
-static int ad5446_write(struct ad5446_state *st, unsigned val)
-{
- struct spi_device *spi = to_spi_device(st->dev);
- __be16 data = cpu_to_be16(val);
-
- return spi_write(spi, &data, sizeof(data));
-}
-
-static int ad5660_write(struct ad5446_state *st, unsigned val)
-{
- struct spi_device *spi = to_spi_device(st->dev);
- uint8_t data[3];
-
- put_unaligned_be24(val, &data[0]);
-
- return spi_write(spi, data, sizeof(data));
-}
-
-/*
- * ad5446_supported_spi_device_ids:
- * The AD5620/40/60 parts are available in different fixed internal reference
- * voltage options. The actual part numbers may look differently
- * (and a bit cryptic), however this style is used to make clear which
- * parts are supported here.
- */
-enum ad5446_supported_spi_device_ids {
- ID_AD5300,
- ID_AD5310,
- ID_AD5320,
- ID_AD5444,
- ID_AD5446,
- ID_AD5450,
- ID_AD5451,
- ID_AD5541A,
- ID_AD5512A,
- ID_AD5553,
- ID_AD5600,
- ID_AD5601,
- ID_AD5611,
- ID_AD5621,
- ID_AD5641,
- ID_AD5620_2500,
- ID_AD5620_1250,
- ID_AD5640_2500,
- ID_AD5640_1250,
- ID_AD5660_2500,
- ID_AD5660_1250,
- ID_AD5662,
-};
-
-static const struct ad5446_chip_info ad5446_spi_chip_info[] = {
- [ID_AD5300] = {
- .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
- .write = ad5446_write,
- },
- [ID_AD5310] = {
- .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
- .write = ad5446_write,
- },
- [ID_AD5320] = {
- .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
- .write = ad5446_write,
- },
- [ID_AD5444] = {
- .channel = AD5446_CHANNEL(12, 16, 2),
- .write = ad5446_write,
- },
- [ID_AD5446] = {
- .channel = AD5446_CHANNEL(14, 16, 0),
- .write = ad5446_write,
- },
- [ID_AD5450] = {
- .channel = AD5446_CHANNEL(8, 16, 6),
- .write = ad5446_write,
- },
- [ID_AD5451] = {
- .channel = AD5446_CHANNEL(10, 16, 4),
- .write = ad5446_write,
- },
- [ID_AD5541A] = {
- .channel = AD5446_CHANNEL(16, 16, 0),
- .write = ad5446_write,
- },
- [ID_AD5512A] = {
- .channel = AD5446_CHANNEL(12, 16, 4),
- .write = ad5446_write,
- },
- [ID_AD5553] = {
- .channel = AD5446_CHANNEL(14, 16, 0),
- .write = ad5446_write,
- },
- [ID_AD5600] = {
- .channel = AD5446_CHANNEL(16, 16, 0),
- .write = ad5446_write,
- },
- [ID_AD5601] = {
- .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
- .write = ad5446_write,
- },
- [ID_AD5611] = {
- .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
- .write = ad5446_write,
- },
- [ID_AD5621] = {
- .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
- .write = ad5446_write,
- },
- [ID_AD5641] = {
- .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
- .write = ad5446_write,
- },
- [ID_AD5620_2500] = {
- .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
- .int_vref_mv = 2500,
- .write = ad5446_write,
- },
- [ID_AD5620_1250] = {
- .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
- .int_vref_mv = 1250,
- .write = ad5446_write,
- },
- [ID_AD5640_2500] = {
- .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
- .int_vref_mv = 2500,
- .write = ad5446_write,
- },
- [ID_AD5640_1250] = {
- .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
- .int_vref_mv = 1250,
- .write = ad5446_write,
- },
- [ID_AD5660_2500] = {
- .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
- .int_vref_mv = 2500,
- .write = ad5660_write,
- },
- [ID_AD5660_1250] = {
- .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
- .int_vref_mv = 1250,
- .write = ad5660_write,
- },
- [ID_AD5662] = {
- .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
- .write = ad5660_write,
- },
-};
-
-static const struct spi_device_id ad5446_spi_ids[] = {
- {"ad5300", ID_AD5300},
- {"ad5310", ID_AD5310},
- {"ad5320", ID_AD5320},
- {"ad5444", ID_AD5444},
- {"ad5446", ID_AD5446},
- {"ad5450", ID_AD5450},
- {"ad5451", ID_AD5451},
- {"ad5452", ID_AD5444}, /* ad5452 is compatible to the ad5444 */
- {"ad5453", ID_AD5446}, /* ad5453 is compatible to the ad5446 */
- {"ad5512a", ID_AD5512A},
- {"ad5541a", ID_AD5541A},
- {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
- {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
- {"ad5553", ID_AD5553},
- {"ad5600", ID_AD5600},
- {"ad5601", ID_AD5601},
- {"ad5611", ID_AD5611},
- {"ad5621", ID_AD5621},
- {"ad5641", ID_AD5641},
- {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
- {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
- {"ad5640-2500", ID_AD5640_2500},
- {"ad5640-1250", ID_AD5640_1250},
- {"ad5660-2500", ID_AD5660_2500},
- {"ad5660-1250", ID_AD5660_1250},
- {"ad5662", ID_AD5662},
- {"dac081s101", ID_AD5300}, /* compatible Texas Instruments chips */
- {"dac101s101", ID_AD5310},
- {"dac121s101", ID_AD5320},
- {"dac7512", ID_AD5320},
- { }
-};
-MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);
-
-static const struct of_device_id ad5446_of_ids[] = {
- { .compatible = "ti,dac7512" },
- { }
-};
-MODULE_DEVICE_TABLE(of, ad5446_of_ids);
-
-static int ad5446_spi_probe(struct spi_device *spi)
-{
- const struct spi_device_id *id = spi_get_device_id(spi);
-
- return ad5446_probe(&spi->dev, id->name,
- &ad5446_spi_chip_info[id->driver_data]);
-}
-
-static struct spi_driver ad5446_spi_driver = {
- .driver = {
- .name = "ad5446",
- .of_match_table = ad5446_of_ids,
- },
- .probe = ad5446_spi_probe,
- .id_table = ad5446_spi_ids,
-};
-
-static int __init ad5446_spi_register_driver(void)
-{
- return spi_register_driver(&ad5446_spi_driver);
-}
-
-static void ad5446_spi_unregister_driver(void)
-{
- spi_unregister_driver(&ad5446_spi_driver);
-}
-
-#else
-
-static inline int ad5446_spi_register_driver(void) { return 0; }
-static inline void ad5446_spi_unregister_driver(void) { }
-
-#endif
-
-#if IS_ENABLED(CONFIG_I2C)
-
-static int ad5622_write(struct ad5446_state *st, unsigned val)
-{
- struct i2c_client *client = to_i2c_client(st->dev);
- __be16 data = cpu_to_be16(val);
- int ret;
-
- ret = i2c_master_send(client, (char *)&data, sizeof(data));
- if (ret < 0)
- return ret;
- if (ret != sizeof(data))
- return -EIO;
-
- return 0;
-}
-
-/*
- * ad5446_supported_i2c_device_ids:
- * The AD5620/40/60 parts are available in different fixed internal reference
- * voltage options. The actual part numbers may look differently
- * (and a bit cryptic), however this style is used to make clear which
- * parts are supported here.
- */
-enum ad5446_supported_i2c_device_ids {
- ID_AD5602,
- ID_AD5612,
- ID_AD5622,
-};
-
-static const struct ad5446_chip_info ad5446_i2c_chip_info[] = {
- [ID_AD5602] = {
- .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
- .write = ad5622_write,
- },
- [ID_AD5612] = {
- .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
- .write = ad5622_write,
- },
- [ID_AD5622] = {
- .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
- .write = ad5622_write,
- },
-};
-
-static int ad5446_i2c_probe(struct i2c_client *i2c)
-{
- const struct i2c_device_id *id = i2c_client_get_device_id(i2c);
- return ad5446_probe(&i2c->dev, id->name,
- &ad5446_i2c_chip_info[id->driver_data]);
-}
-
-static const struct i2c_device_id ad5446_i2c_ids[] = {
- {"ad5301", ID_AD5602},
- {"ad5311", ID_AD5612},
- {"ad5321", ID_AD5622},
- {"ad5602", ID_AD5602},
- {"ad5612", ID_AD5612},
- {"ad5622", ID_AD5622},
- { }
-};
-MODULE_DEVICE_TABLE(i2c, ad5446_i2c_ids);
-
-static struct i2c_driver ad5446_i2c_driver = {
- .driver = {
- .name = "ad5446",
- },
- .probe = ad5446_i2c_probe,
- .id_table = ad5446_i2c_ids,
-};
-
-static int __init ad5446_i2c_register_driver(void)
-{
- return i2c_add_driver(&ad5446_i2c_driver);
-}
-
-static void __exit ad5446_i2c_unregister_driver(void)
-{
- i2c_del_driver(&ad5446_i2c_driver);
-}
-
-#else
-
-static inline int ad5446_i2c_register_driver(void) { return 0; }
-static inline void ad5446_i2c_unregister_driver(void) { }
-
-#endif
-
-static int __init ad5446_init(void)
-{
- int ret;
-
- ret = ad5446_spi_register_driver();
- if (ret)
- return ret;
-
- ret = ad5446_i2c_register_driver();
- if (ret) {
- ad5446_spi_unregister_driver();
- return ret;
- }
-
- return 0;
-}
-module_init(ad5446_init);
-
-static void __exit ad5446_exit(void)
-{
- ad5446_i2c_unregister_driver();
- ad5446_spi_unregister_driver();
-}
-module_exit(ad5446_exit);
+EXPORT_SYMBOL_NS_GPL(ad5446_probe, "IIO_AD5446");
MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
-MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
+MODULE_DESCRIPTION("Analog Devices CORE AD5446 DAC and similar devices");
MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/dac/ad5446.h b/drivers/iio/dac/ad5446.h
new file mode 100644
index 000000000000..6ba31d98f415
--- /dev/null
+++ b/drivers/iio/dac/ad5446.h
@@ -0,0 +1,77 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_AD5446_H
+#define _LINUX_AD5446_H
+
+#include <linux/bits.h>
+#include <linux/compiler.h>
+#include <linux/iio/iio.h>
+#include <linux/mutex.h>
+#include <linux/types.h>
+
+struct device;
+
+extern const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[];
+
+#define _AD5446_CHANNEL(bits, storage, _shift, ext) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .channel = 0, \
+ .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+ .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
+ .scan_type = { \
+ .sign = 'u', \
+ .realbits = (bits), \
+ .storagebits = (storage), \
+ .shift = (_shift), \
+ }, \
+ .ext_info = (ext), \
+}
+
+#define AD5446_CHANNEL(bits, storage, shift) \
+ _AD5446_CHANNEL(bits, storage, shift, NULL)
+
+#define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
+ _AD5446_CHANNEL(bits, storage, shift, ad5446_ext_info_powerdown)
+
+/**
+ * struct ad5446_state - driver instance specific data
+ * @dev: this device
+ * @chip_info: chip model specific constants, available modes etc
+ * @vref_mv: actual reference voltage used
+ * @cached_val: store/retrieve values during power down
+ * @pwr_down_mode: power down mode (1k, 100k or tristate)
+ * @pwr_down: true if the device is in power down
+ * @lock: lock to protect the data buffer during write ops
+ */
+struct ad5446_state {
+ struct device *dev;
+ const struct ad5446_chip_info *chip_info;
+ unsigned short vref_mv;
+ unsigned int cached_val;
+ unsigned int pwr_down_mode;
+ unsigned int pwr_down;
+ /* mutex to protect device shared data */
+ struct mutex lock;
+ union {
+ __be16 d16;
+ u8 d24[3];
+ } __aligned(IIO_DMA_MINALIGN);
+};
+
+/**
+ * struct ad5446_chip_info - chip specific information
+ * @channel: channel spec for the DAC
+ * @int_vref_mv: AD5620/40/60: the internal reference voltage
+ * @write: chip specific helper function to write to the register
+ */
+struct ad5446_chip_info {
+ struct iio_chan_spec channel;
+ u16 int_vref_mv;
+ int (*write)(struct ad5446_state *st, unsigned int val);
+};
+
+int ad5446_probe(struct device *dev, const char *name,
+ const struct ad5446_chip_info *chip_info);
+
+#endif
diff --git a/drivers/iio/dac/ltc2688.c b/drivers/iio/dac/ltc2688.c
index 7a2ee26a7d68..02f408229681 100644
--- a/drivers/iio/dac/ltc2688.c
+++ b/drivers/iio/dac/ltc2688.c
@@ -6,6 +6,7 @@
*/
#include <linux/bitfield.h>
#include <linux/bits.h>
+#include <linux/cleanup.h>
#include <linux/clk.h>
#include <linux/device.h>
#include <linux/gpio/consumer.h>
@@ -208,12 +209,12 @@ static int ltc2688_dac_code_write(struct ltc2688_state *st, u32 chan, u32 input,
code = FIELD_PREP(LTC2688_DITHER_RAW_MASK, code);
}
- mutex_lock(&st->lock);
+ guard(mutex)(&st->lock);
/* select the correct input register to read from */
ret = regmap_update_bits(st->regmap, LTC2688_CMD_A_B_SELECT, BIT(chan),
input << chan);
if (ret)
- goto out_unlock;
+ return ret;
/*
* If in dither/toggle mode the dac should be updated by an
@@ -224,10 +225,7 @@ static int ltc2688_dac_code_write(struct ltc2688_state *st, u32 chan, u32 input,
else
reg = LTC2688_CMD_CH_CODE(chan);
- ret = regmap_write(st->regmap, reg, code);
-out_unlock:
- mutex_unlock(&st->lock);
- return ret;
+ return regmap_write(st->regmap, reg, code);
}
static int ltc2688_dac_code_read(struct ltc2688_state *st, u32 chan, u32 input,
@@ -236,20 +234,20 @@ static int ltc2688_dac_code_read(struct ltc2688_state *st, u32 chan, u32 input,
struct ltc2688_chan *c = &st->channels[chan];
int ret;
- mutex_lock(&st->lock);
+ guard(mutex)(&st->lock);
ret = regmap_update_bits(st->regmap, LTC2688_CMD_A_B_SELECT, BIT(chan),
input << chan);
if (ret)
- goto out_unlock;
+ return ret;
ret = regmap_read(st->regmap, LTC2688_CMD_CH_CODE(chan), code);
-out_unlock:
- mutex_unlock(&st->lock);
+ if (ret)
+ return ret;
if (!c->toggle_chan && input == LTC2688_INPUT_B)
*code = FIELD_GET(LTC2688_DITHER_RAW_MASK, *code);
- return ret;
+ return 0;
}
static const int ltc2688_raw_range[] = {0, 1, U16_MAX};
@@ -359,17 +357,15 @@ static ssize_t ltc2688_dither_toggle_set(struct iio_dev *indio_dev,
if (ret)
return ret;
- mutex_lock(&st->lock);
+ guard(mutex)(&st->lock);
ret = regmap_update_bits(st->regmap, LTC2688_CMD_TOGGLE_DITHER_EN,
BIT(chan->channel), en << chan->channel);
if (ret)
- goto out_unlock;
+ return ret;
c->mode = en ? LTC2688_MODE_DITHER_TOGGLE : LTC2688_MODE_DEFAULT;
-out_unlock:
- mutex_unlock(&st->lock);
- return ret ?: len;
+ return len;
}
static ssize_t ltc2688_reg_bool_get(struct iio_dev *indio_dev,
@@ -953,7 +949,9 @@ static int ltc2688_probe(struct spi_device *spi)
/* Just write this once. No need to do it in every regmap read. */
st->tx_data[3] = LTC2688_CMD_NOOP;
- mutex_init(&st->lock);
+ ret = devm_mutex_init(dev, &st->lock);
+ if (ret)
+ return ret;
st->regmap = devm_regmap_init(dev, &ltc2688_regmap_bus, st,
&ltc2688_regmap_config);
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-07 16:41:01 +0000