Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * ti-dac082s085.c - Texas Instruments 8/10/12-bit 2/4-channel DAC driver
0004  *
0005  * Copyright (C) 2017 KUNBUS GmbH
0006  *
0007  * https://www.ti.com/lit/ds/symlink/dac082s085.pdf
0008  * https://www.ti.com/lit/ds/symlink/dac102s085.pdf
0009  * https://www.ti.com/lit/ds/symlink/dac122s085.pdf
0010  * https://www.ti.com/lit/ds/symlink/dac084s085.pdf
0011  * https://www.ti.com/lit/ds/symlink/dac104s085.pdf
0012  * https://www.ti.com/lit/ds/symlink/dac124s085.pdf
0013  */
0014 
0015 #include <linux/iio/iio.h>
0016 #include <linux/module.h>
0017 #include <linux/mod_devicetable.h>
0018 #include <linux/regulator/consumer.h>
0019 #include <linux/spi/spi.h>
0020 
0021 enum { dual_8bit, dual_10bit, dual_12bit, quad_8bit, quad_10bit, quad_12bit };
0022 
0023 struct ti_dac_spec {
0024     u8 num_channels;
0025     u8 resolution;
0026 };
0027 
0028 static const struct ti_dac_spec ti_dac_spec[] = {
0029     [dual_8bit]  = { .num_channels = 2, .resolution = 8  },
0030     [dual_10bit] = { .num_channels = 2, .resolution = 10 },
0031     [dual_12bit] = { .num_channels = 2, .resolution = 12 },
0032     [quad_8bit]  = { .num_channels = 4, .resolution = 8  },
0033     [quad_10bit] = { .num_channels = 4, .resolution = 10 },
0034     [quad_12bit] = { .num_channels = 4, .resolution = 12 },
0035 };
0036 
0037 /**
0038  * struct ti_dac_chip - TI DAC chip
0039  * @lock: protects write sequences
0040  * @vref: regulator generating Vref
0041  * @mesg: SPI message to perform a write
0042  * @xfer: SPI transfer used by @mesg
0043  * @val: cached value of each output
0044  * @powerdown: whether the chip is powered down
0045  * @powerdown_mode: selected by the user
0046  * @resolution: resolution of the chip
0047  * @buf: buffer for @xfer
0048  */
0049 struct ti_dac_chip {
0050     struct mutex lock;
0051     struct regulator *vref;
0052     struct spi_message mesg;
0053     struct spi_transfer xfer;
0054     u16 val[4];
0055     bool powerdown;
0056     u8 powerdown_mode;
0057     u8 resolution;
0058     u8 buf[2] __aligned(IIO_DMA_MINALIGN);
0059 };
0060 
0061 #define WRITE_NOT_UPDATE(chan)  (0x00 | (chan) << 6)
0062 #define WRITE_AND_UPDATE(chan)  (0x10 | (chan) << 6)
0063 #define WRITE_ALL_UPDATE     0x20
0064 #define POWERDOWN(mode)     (0x30 | ((mode) + 1) << 6)
0065 
0066 static int ti_dac_cmd(struct ti_dac_chip *ti_dac, u8 cmd, u16 val)
0067 {
0068     u8 shift = 12 - ti_dac->resolution;
0069 
0070     ti_dac->buf[0] = cmd | (val >> (8 - shift));
0071     ti_dac->buf[1] = (val << shift) & 0xff;
0072     return spi_sync(ti_dac->mesg.spi, &ti_dac->mesg);
0073 }
0074 
0075 static const char * const ti_dac_powerdown_modes[] = {
0076     "2.5kohm_to_gnd", "100kohm_to_gnd", "three_state",
0077 };
0078 
0079 static int ti_dac_get_powerdown_mode(struct iio_dev *indio_dev,
0080                      const struct iio_chan_spec *chan)
0081 {
0082     struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
0083 
0084     return ti_dac->powerdown_mode;
0085 }
0086 
0087 static int ti_dac_set_powerdown_mode(struct iio_dev *indio_dev,
0088                      const struct iio_chan_spec *chan,
0089                      unsigned int mode)
0090 {
0091     struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
0092     int ret = 0;
0093 
0094     if (ti_dac->powerdown_mode == mode)
0095         return 0;
0096 
0097     mutex_lock(&ti_dac->lock);
0098     if (ti_dac->powerdown) {
0099         ret = ti_dac_cmd(ti_dac, POWERDOWN(mode), 0);
0100         if (ret)
0101             goto out;
0102     }
0103     ti_dac->powerdown_mode = mode;
0104 
0105 out:
0106     mutex_unlock(&ti_dac->lock);
0107     return ret;
0108 }
0109 
0110 static const struct iio_enum ti_dac_powerdown_mode = {
0111     .items = ti_dac_powerdown_modes,
0112     .num_items = ARRAY_SIZE(ti_dac_powerdown_modes),
0113     .get = ti_dac_get_powerdown_mode,
0114     .set = ti_dac_set_powerdown_mode,
0115 };
0116 
0117 static ssize_t ti_dac_read_powerdown(struct iio_dev *indio_dev,
0118                      uintptr_t private,
0119                      const struct iio_chan_spec *chan,
0120                      char *buf)
0121 {
0122     struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
0123 
0124     return sysfs_emit(buf, "%d\n", ti_dac->powerdown);
0125 }
0126 
0127 static ssize_t ti_dac_write_powerdown(struct iio_dev *indio_dev,
0128                       uintptr_t private,
0129                       const struct iio_chan_spec *chan,
0130                       const char *buf, size_t len)
0131 {
0132     struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
0133     bool powerdown;
0134     int ret;
0135 
0136     ret = kstrtobool(buf, &powerdown);
0137     if (ret)
0138         return ret;
0139 
0140     if (ti_dac->powerdown == powerdown)
0141         return len;
0142 
0143     mutex_lock(&ti_dac->lock);
0144     if (powerdown)
0145         ret = ti_dac_cmd(ti_dac, POWERDOWN(ti_dac->powerdown_mode), 0);
0146     else
0147         ret = ti_dac_cmd(ti_dac, WRITE_AND_UPDATE(0), ti_dac->val[0]);
0148     if (!ret)
0149         ti_dac->powerdown = powerdown;
0150     mutex_unlock(&ti_dac->lock);
0151 
0152     return ret ? ret : len;
0153 }
0154 
0155 static const struct iio_chan_spec_ext_info ti_dac_ext_info[] = {
0156     {
0157         .name      = "powerdown",
0158         .read      = ti_dac_read_powerdown,
0159         .write     = ti_dac_write_powerdown,
0160         .shared    = IIO_SHARED_BY_TYPE,
0161     },
0162     IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE, &ti_dac_powerdown_mode),
0163     IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &ti_dac_powerdown_mode),
0164     { },
0165 };
0166 
0167 #define TI_DAC_CHANNEL(chan) {                  \
0168     .type = IIO_VOLTAGE,                    \
0169     .channel = (chan),                  \
0170     .address = (chan),                  \
0171     .indexed = true,                    \
0172     .output = true,                     \
0173     .datasheet_name = (const char[]){ 'A' + (chan), 0 },    \
0174     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),       \
0175     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
0176     .ext_info = ti_dac_ext_info,                \
0177 }
0178 
0179 static const struct iio_chan_spec ti_dac_channels[] = {
0180     TI_DAC_CHANNEL(0),
0181     TI_DAC_CHANNEL(1),
0182     TI_DAC_CHANNEL(2),
0183     TI_DAC_CHANNEL(3),
0184 };
0185 
0186 static int ti_dac_read_raw(struct iio_dev *indio_dev,
0187                struct iio_chan_spec const *chan,
0188                int *val, int *val2, long mask)
0189 {
0190     struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
0191     int ret;
0192 
0193     switch (mask) {
0194     case IIO_CHAN_INFO_RAW:
0195         *val = ti_dac->val[chan->channel];
0196         ret = IIO_VAL_INT;
0197         break;
0198 
0199     case IIO_CHAN_INFO_SCALE:
0200         ret = regulator_get_voltage(ti_dac->vref);
0201         if (ret < 0)
0202             return ret;
0203 
0204         *val = ret / 1000;
0205         *val2 = ti_dac->resolution;
0206         ret = IIO_VAL_FRACTIONAL_LOG2;
0207         break;
0208 
0209     default:
0210         ret = -EINVAL;
0211     }
0212 
0213     return ret;
0214 }
0215 
0216 static int ti_dac_write_raw(struct iio_dev *indio_dev,
0217                 struct iio_chan_spec const *chan,
0218                 int val, int val2, long mask)
0219 {
0220     struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
0221     int ret;
0222 
0223     switch (mask) {
0224     case IIO_CHAN_INFO_RAW:
0225         if (ti_dac->val[chan->channel] == val)
0226             return 0;
0227 
0228         if (val >= (1 << ti_dac->resolution) || val < 0)
0229             return -EINVAL;
0230 
0231         if (ti_dac->powerdown)
0232             return -EBUSY;
0233 
0234         mutex_lock(&ti_dac->lock);
0235         ret = ti_dac_cmd(ti_dac, WRITE_AND_UPDATE(chan->channel), val);
0236         if (!ret)
0237             ti_dac->val[chan->channel] = val;
0238         mutex_unlock(&ti_dac->lock);
0239         break;
0240 
0241     default:
0242         ret = -EINVAL;
0243     }
0244 
0245     return ret;
0246 }
0247 
0248 static int ti_dac_write_raw_get_fmt(struct iio_dev *indio_dev,
0249                     struct iio_chan_spec const *chan, long mask)
0250 {
0251     return IIO_VAL_INT;
0252 }
0253 
0254 static const struct iio_info ti_dac_info = {
0255     .read_raw      = ti_dac_read_raw,
0256     .write_raw     = ti_dac_write_raw,
0257     .write_raw_get_fmt = ti_dac_write_raw_get_fmt,
0258 };
0259 
0260 static int ti_dac_probe(struct spi_device *spi)
0261 {
0262     struct device *dev = &spi->dev;
0263     const struct ti_dac_spec *spec;
0264     struct ti_dac_chip *ti_dac;
0265     struct iio_dev *indio_dev;
0266     int ret;
0267 
0268     indio_dev = devm_iio_device_alloc(dev, sizeof(*ti_dac));
0269     if (!indio_dev)
0270         return -ENOMEM;
0271 
0272     indio_dev->info = &ti_dac_info;
0273     indio_dev->name = spi->modalias;
0274     indio_dev->modes = INDIO_DIRECT_MODE;
0275     indio_dev->channels = ti_dac_channels;
0276     spi_set_drvdata(spi, indio_dev);
0277 
0278     ti_dac = iio_priv(indio_dev);
0279     ti_dac->xfer.tx_buf = &ti_dac->buf;
0280     ti_dac->xfer.len = sizeof(ti_dac->buf);
0281     spi_message_init_with_transfers(&ti_dac->mesg, &ti_dac->xfer, 1);
0282     ti_dac->mesg.spi = spi;
0283 
0284     spec = &ti_dac_spec[spi_get_device_id(spi)->driver_data];
0285     indio_dev->num_channels = spec->num_channels;
0286     ti_dac->resolution = spec->resolution;
0287 
0288     ti_dac->vref = devm_regulator_get(dev, "vref");
0289     if (IS_ERR(ti_dac->vref))
0290         return PTR_ERR(ti_dac->vref);
0291 
0292     ret = regulator_enable(ti_dac->vref);
0293     if (ret < 0)
0294         return ret;
0295 
0296     mutex_init(&ti_dac->lock);
0297 
0298     ret = ti_dac_cmd(ti_dac, WRITE_ALL_UPDATE, 0);
0299     if (ret) {
0300         dev_err(dev, "failed to initialize outputs to 0\n");
0301         goto err;
0302     }
0303 
0304     ret = iio_device_register(indio_dev);
0305     if (ret)
0306         goto err;
0307 
0308     return 0;
0309 
0310 err:
0311     mutex_destroy(&ti_dac->lock);
0312     regulator_disable(ti_dac->vref);
0313     return ret;
0314 }
0315 
0316 static void ti_dac_remove(struct spi_device *spi)
0317 {
0318     struct iio_dev *indio_dev = spi_get_drvdata(spi);
0319     struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
0320 
0321     iio_device_unregister(indio_dev);
0322     mutex_destroy(&ti_dac->lock);
0323     regulator_disable(ti_dac->vref);
0324 }
0325 
0326 static const struct of_device_id ti_dac_of_id[] = {
0327     { .compatible = "ti,dac082s085" },
0328     { .compatible = "ti,dac102s085" },
0329     { .compatible = "ti,dac122s085" },
0330     { .compatible = "ti,dac084s085" },
0331     { .compatible = "ti,dac104s085" },
0332     { .compatible = "ti,dac124s085" },
0333     { }
0334 };
0335 MODULE_DEVICE_TABLE(of, ti_dac_of_id);
0336 
0337 static const struct spi_device_id ti_dac_spi_id[] = {
0338     { "dac082s085", dual_8bit  },
0339     { "dac102s085", dual_10bit },
0340     { "dac122s085", dual_12bit },
0341     { "dac084s085", quad_8bit  },
0342     { "dac104s085", quad_10bit },
0343     { "dac124s085", quad_12bit },
0344     { }
0345 };
0346 MODULE_DEVICE_TABLE(spi, ti_dac_spi_id);
0347 
0348 static struct spi_driver ti_dac_driver = {
0349     .driver = {
0350         .name       = "ti-dac082s085",
0351         .of_match_table = ti_dac_of_id,
0352     },
0353     .probe    = ti_dac_probe,
0354     .remove   = ti_dac_remove,
0355     .id_table = ti_dac_spi_id,
0356 };
0357 module_spi_driver(ti_dac_driver);
0358 
0359 MODULE_AUTHOR("Lukas Wunner <lukas@wunner.de>");
0360 MODULE_DESCRIPTION("Texas Instruments 8/10/12-bit 2/4-channel DAC driver");
0361 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!