iio/dac/max5821.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002  /*
0003   * iio/dac/max5821.c
0004   * Copyright (C) 2014 Philippe Reynes
0005   */
0006
0007 #include <linux/kernel.h>
0008 #include <linux/module.h>
0009 #include <linux/i2c.h>
0010 #include <linux/iio/iio.h>
0011 #include <linux/regulator/consumer.h>
0012
0013 #define MAX5821_MAX_DAC_CHANNELS        2
0014
0015 /* command bytes */
0016 #define MAX5821_LOAD_DAC_A_IN_REG_B     0x00
0017 #define MAX5821_LOAD_DAC_B_IN_REG_A     0x10
0018 #define MAX5821_EXTENDED_COMMAND_MODE       0xf0
0019 #define MAX5821_READ_DAC_A_COMMAND      0xf1
0020 #define MAX5821_READ_DAC_B_COMMAND      0xf2
0021
0022 #define MAX5821_EXTENDED_POWER_UP       0x00
0023 #define MAX5821_EXTENDED_POWER_DOWN_MODE0   0x01
0024 #define MAX5821_EXTENDED_POWER_DOWN_MODE1   0x02
0025 #define MAX5821_EXTENDED_POWER_DOWN_MODE2   0x03
0026 #define MAX5821_EXTENDED_DAC_A          0x04
0027 #define MAX5821_EXTENDED_DAC_B          0x08
0028
0029 enum max5821_device_ids {
0030     ID_MAX5821,
0031 };
0032
0033 struct max5821_data {
0034     struct i2c_client   *client;
0035     struct regulator    *vref_reg;
0036     unsigned short      vref_mv;
0037     bool            powerdown[MAX5821_MAX_DAC_CHANNELS];
0038     u8          powerdown_mode[MAX5821_MAX_DAC_CHANNELS];
0039     struct mutex        lock;
0040 };
0041
0042 static const char * const max5821_powerdown_modes[] = {
0043     "three_state",
0044     "1kohm_to_gnd",
0045     "100kohm_to_gnd",
0046 };
0047
0048 enum {
0049     MAX5821_THREE_STATE,
0050     MAX5821_1KOHM_TO_GND,
0051     MAX5821_100KOHM_TO_GND
0052 };
0053
0054 static int max5821_get_powerdown_mode(struct iio_dev *indio_dev,
0055                       const struct iio_chan_spec *chan)
0056 {
0057     struct max5821_data *st = iio_priv(indio_dev);
0058
0059     return st->powerdown_mode[chan->channel];
0060 }
0061
0062 static int max5821_set_powerdown_mode(struct iio_dev *indio_dev,
0063                       const struct iio_chan_spec *chan,
0064                       unsigned int mode)
0065 {
0066     struct max5821_data *st = iio_priv(indio_dev);
0067
0068     st->powerdown_mode[chan->channel] = mode;
0069
0070     return 0;
0071 }
0072
0073 static const struct iio_enum max5821_powerdown_mode_enum = {
0074     .items = max5821_powerdown_modes,
0075     .num_items = ARRAY_SIZE(max5821_powerdown_modes),
0076     .get = max5821_get_powerdown_mode,
0077     .set = max5821_set_powerdown_mode,
0078 };
0079
0080 static ssize_t max5821_read_dac_powerdown(struct iio_dev *indio_dev,
0081                       uintptr_t private,
0082                       const struct iio_chan_spec *chan,
0083                       char *buf)
0084 {
0085     struct max5821_data *st = iio_priv(indio_dev);
0086
0087     return sysfs_emit(buf, "%d\n", st->powerdown[chan->channel]);
0088 }
0089
0090 static int max5821_sync_powerdown_mode(struct max5821_data *data,
0091                        const struct iio_chan_spec *chan)
0092 {
0093     u8 outbuf[2];
0094
0095     outbuf[0] = MAX5821_EXTENDED_COMMAND_MODE;
0096
0097     if (chan->channel == 0)
0098         outbuf[1] = MAX5821_EXTENDED_DAC_A;
0099     else
0100         outbuf[1] = MAX5821_EXTENDED_DAC_B;
0101
0102     if (data->powerdown[chan->channel])
0103         outbuf[1] |= data->powerdown_mode[chan->channel] + 1;
0104     else
0105         outbuf[1] |= MAX5821_EXTENDED_POWER_UP;
0106
0107     return i2c_master_send(data->client, outbuf, 2);
0108 }
0109
0110 static ssize_t max5821_write_dac_powerdown(struct iio_dev *indio_dev,
0111                        uintptr_t private,
0112                        const struct iio_chan_spec *chan,
0113                        const char *buf, size_t len)
0114 {
0115     struct max5821_data *data = iio_priv(indio_dev);
0116     bool powerdown;
0117     int ret;
0118
0119     ret = kstrtobool(buf, &powerdown);
0120     if (ret)
0121         return ret;
0122
0123     data->powerdown[chan->channel] = powerdown;
0124
0125     ret = max5821_sync_powerdown_mode(data, chan);
0126     if (ret < 0)
0127         return ret;
0128
0129     return len;
0130 }
0131
0132 static const struct iio_chan_spec_ext_info max5821_ext_info[] = {
0133     {
0134         .name = "powerdown",
0135         .read = max5821_read_dac_powerdown,
0136         .write = max5821_write_dac_powerdown,
0137         .shared = IIO_SEPARATE,
0138     },
0139     IIO_ENUM("powerdown_mode", IIO_SEPARATE, &max5821_powerdown_mode_enum),
0140     IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &max5821_powerdown_mode_enum),
0141     { },
0142 };
0143
0144 #define MAX5821_CHANNEL(chan) {                 \
0145     .type = IIO_VOLTAGE,                    \
0146     .indexed = 1,                       \
0147     .output = 1,                        \
0148     .channel = (chan),                  \
0149     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),       \
0150     .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE),    \
0151     .ext_info = max5821_ext_info,               \
0152 }
0153
0154 static const struct iio_chan_spec max5821_channels[] = {
0155     MAX5821_CHANNEL(0),
0156     MAX5821_CHANNEL(1)
0157 };
0158
0159 static const u8 max5821_read_dac_command[] = {
0160     MAX5821_READ_DAC_A_COMMAND,
0161     MAX5821_READ_DAC_B_COMMAND
0162 };
0163
0164 static const u8 max5821_load_dac_command[] = {
0165     MAX5821_LOAD_DAC_A_IN_REG_B,
0166     MAX5821_LOAD_DAC_B_IN_REG_A
0167 };
0168
0169 static int max5821_get_value(struct iio_dev *indio_dev,
0170                  int *val, int channel)
0171 {
0172     struct max5821_data *data = iio_priv(indio_dev);
0173     struct i2c_client *client = data->client;
0174     u8 outbuf[1];
0175     u8 inbuf[2];
0176     int ret;
0177
0178     if ((channel != 0) && (channel != 1))
0179         return -EINVAL;
0180
0181     outbuf[0] = max5821_read_dac_command[channel];
0182
0183     mutex_lock(&data->lock);
0184
0185     ret = i2c_master_send(client, outbuf, 1);
0186     if (ret < 0) {
0187         mutex_unlock(&data->lock);
0188         return ret;
0189     } else if (ret != 1) {
0190         mutex_unlock(&data->lock);
0191         return -EIO;
0192     }
0193
0194     ret = i2c_master_recv(client, inbuf, 2);
0195     if (ret < 0) {
0196         mutex_unlock(&data->lock);
0197         return ret;
0198     } else if (ret != 2) {
0199         mutex_unlock(&data->lock);
0200         return -EIO;
0201     }
0202
0203     mutex_unlock(&data->lock);
0204
0205     *val = ((inbuf[0] & 0x0f) << 6) | (inbuf[1] >> 2);
0206
0207     return IIO_VAL_INT;
0208 }
0209
0210 static int max5821_set_value(struct iio_dev *indio_dev,
0211                  int val, int channel)
0212 {
0213     struct max5821_data *data = iio_priv(indio_dev);
0214     struct i2c_client *client = data->client;
0215     u8 outbuf[2];
0216     int ret;
0217
0218     if ((val < 0) || (val > 1023))
0219         return -EINVAL;
0220
0221     if ((channel != 0) && (channel != 1))
0222         return -EINVAL;
0223
0224     outbuf[0] = max5821_load_dac_command[channel];
0225     outbuf[0] |= val >> 6;
0226     outbuf[1] = (val & 0x3f) << 2;
0227
0228     ret = i2c_master_send(client, outbuf, 2);
0229     if (ret < 0)
0230         return ret;
0231     else if (ret != 2)
0232         return -EIO;
0233     else
0234         return 0;
0235 }
0236
0237 static int max5821_read_raw(struct iio_dev *indio_dev,
0238                struct iio_chan_spec const *chan,
0239                int *val, int *val2, long mask)
0240 {
0241     struct max5821_data *data = iio_priv(indio_dev);
0242
0243     switch (mask) {
0244     case IIO_CHAN_INFO_RAW:
0245         return max5821_get_value(indio_dev, val, chan->channel);
0246     case IIO_CHAN_INFO_SCALE:
0247         *val = data->vref_mv;
0248         *val2 = 10;
0249         return IIO_VAL_FRACTIONAL_LOG2;
0250     default:
0251         return -EINVAL;
0252     }
0253 }
0254
0255 static int max5821_write_raw(struct iio_dev *indio_dev,
0256                  struct iio_chan_spec const *chan,
0257                  int val, int val2, long mask)
0258 {
0259     if (val2 != 0)
0260         return -EINVAL;
0261
0262     switch (mask) {
0263     case IIO_CHAN_INFO_RAW:
0264         return max5821_set_value(indio_dev, val, chan->channel);
0265     default:
0266         return -EINVAL;
0267     }
0268 }
0269
0270 static int max5821_suspend(struct device *dev)
0271 {
0272     u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
0273              MAX5821_EXTENDED_DAC_A |
0274              MAX5821_EXTENDED_DAC_B |
0275              MAX5821_EXTENDED_POWER_DOWN_MODE2 };
0276
0277     return i2c_master_send(to_i2c_client(dev), outbuf, 2);
0278 }
0279
0280 static int max5821_resume(struct device *dev)
0281 {
0282     u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
0283              MAX5821_EXTENDED_DAC_A |
0284              MAX5821_EXTENDED_DAC_B |
0285              MAX5821_EXTENDED_POWER_UP };
0286
0287     return i2c_master_send(to_i2c_client(dev), outbuf, 2);
0288 }
0289
0290 static DEFINE_SIMPLE_DEV_PM_OPS(max5821_pm_ops, max5821_suspend,
0291                 max5821_resume);
0292
0293 static const struct iio_info max5821_info = {
0294     .read_raw = max5821_read_raw,
0295     .write_raw = max5821_write_raw,
0296 };
0297
0298 static void max5821_regulator_disable(void *reg)
0299 {
0300     regulator_disable(reg);
0301 }
0302
0303 static int max5821_probe(struct i2c_client *client,
0304             const struct i2c_device_id *id)
0305 {
0306     struct max5821_data *data;
0307     struct iio_dev *indio_dev;
0308     u32 tmp;
0309     int ret;
0310
0311     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
0312     if (!indio_dev)
0313         return -ENOMEM;
0314     data = iio_priv(indio_dev);
0315     data->client = client;
0316     mutex_init(&data->lock);
0317
0318     /* max5821 start in powerdown mode 100Kohm to ground */
0319     for (tmp = 0; tmp < MAX5821_MAX_DAC_CHANNELS; tmp++) {
0320         data->powerdown[tmp] = true;
0321         data->powerdown_mode[tmp] = MAX5821_100KOHM_TO_GND;
0322     }
0323
0324     data->vref_reg = devm_regulator_get(&client->dev, "vref");
0325     if (IS_ERR(data->vref_reg))
0326         return dev_err_probe(&client->dev, PTR_ERR(data->vref_reg),
0327                      "Failed to get vref regulator\n");
0328
0329     ret = regulator_enable(data->vref_reg);
0330     if (ret) {
0331         dev_err(&client->dev,
0332             "Failed to enable vref regulator: %d\n", ret);
0333         return ret;
0334     }
0335
0336     ret = devm_add_action_or_reset(&client->dev, max5821_regulator_disable,
0337                        data->vref_reg);
0338     if (ret) {
0339         dev_err(&client->dev,
0340             "Failed to add action to managed regulator: %d\n", ret);
0341         return ret;
0342     }
0343
0344     ret = regulator_get_voltage(data->vref_reg);
0345     if (ret < 0) {
0346         dev_err(&client->dev,
0347             "Failed to get voltage on regulator: %d\n", ret);
0348         return ret;
0349     }
0350
0351     data->vref_mv = ret / 1000;
0352
0353     indio_dev->name = id->name;
0354     indio_dev->num_channels = ARRAY_SIZE(max5821_channels);
0355     indio_dev->channels = max5821_channels;
0356     indio_dev->modes = INDIO_DIRECT_MODE;
0357     indio_dev->info = &max5821_info;
0358
0359     return devm_iio_device_register(&client->dev, indio_dev);
0360 }
0361
0362 static const struct i2c_device_id max5821_id[] = {
0363     { "max5821", ID_MAX5821 },
0364     { }
0365 };
0366 MODULE_DEVICE_TABLE(i2c, max5821_id);
0367
0368 static const struct of_device_id max5821_of_match[] = {
0369     { .compatible = "maxim,max5821" },
0370     { }
0371 };
0372 MODULE_DEVICE_TABLE(of, max5821_of_match);
0373
0374 static struct i2c_driver max5821_driver = {
0375     .driver = {
0376         .name   = "max5821",
0377         .of_match_table = max5821_of_match,
0378         .pm     = pm_sleep_ptr(&max5821_pm_ops),
0379     },
0380     .probe      = max5821_probe,
0381     .id_table   = max5821_id,
0382 };
0383 module_i2c_driver(max5821_driver);
0384
0385 MODULE_AUTHOR("Philippe Reynes <tremyfr@yahoo.fr>");
0386 MODULE_DESCRIPTION("MAX5821 DAC");
0387 MODULE_LICENSE("GPL v2");