drivers/iio/dac/max5821.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2  /*
   3   * iio/dac/max5821.c
   4   * Copyright (C) 2014 Philippe Reynes
   5   */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/i2c.h>
  10 #include <linux/iio/iio.h>
  11 #include <linux/regulator/consumer.h>
  12
  13 #define MAX5821_MAX_DAC_CHANNELS                2
  14
  15 /* command bytes */
  16 #define MAX5821_LOAD_DAC_A_IN_REG_B             0x00
  17 #define MAX5821_LOAD_DAC_B_IN_REG_A             0x10
  18 #define MAX5821_EXTENDED_COMMAND_MODE           0xf0
  19 #define MAX5821_READ_DAC_A_COMMAND              0xf1
  20 #define MAX5821_READ_DAC_B_COMMAND              0xf2
  21
  22 #define MAX5821_EXTENDED_POWER_UP               0x00
  23 #define MAX5821_EXTENDED_POWER_DOWN_MODE0       0x01
  24 #define MAX5821_EXTENDED_POWER_DOWN_MODE1       0x02
  25 #define MAX5821_EXTENDED_POWER_DOWN_MODE2       0x03
  26 #define MAX5821_EXTENDED_DAC_A                  0x04
  27 #define MAX5821_EXTENDED_DAC_B                  0x08
  28
  29 enum max5821_device_ids {
  30         ID_MAX5821,
  31 };
  32
  33 struct max5821_data {
  34         struct i2c_client       *client;
  35         unsigned short          vref_mv;
  36         bool                    powerdown[MAX5821_MAX_DAC_CHANNELS];
  37         u8                      powerdown_mode[MAX5821_MAX_DAC_CHANNELS];
  38         struct mutex            lock;
  39 };
  40
  41 static const char * const max5821_powerdown_modes[] = {
  42         "three_state",
  43         "1kohm_to_gnd",
  44         "100kohm_to_gnd",
  45 };
  46
  47 enum {
  48         MAX5821_THREE_STATE,
  49         MAX5821_1KOHM_TO_GND,
  50         MAX5821_100KOHM_TO_GND
  51 };
  52
  53 static int max5821_get_powerdown_mode(struct iio_dev *indio_dev,
  54                                       const struct iio_chan_spec *chan)
  55 {
  56         struct max5821_data *st = iio_priv(indio_dev);
  57
  58         return st->powerdown_mode[chan->channel];
  59 }
  60
  61 static int max5821_set_powerdown_mode(struct iio_dev *indio_dev,
  62                                       const struct iio_chan_spec *chan,
  63                                       unsigned int mode)
  64 {
  65         struct max5821_data *st = iio_priv(indio_dev);
  66
  67         st->powerdown_mode[chan->channel] = mode;
  68
  69         return 0;
  70 }
  71
  72 static const struct iio_enum max5821_powerdown_mode_enum = {
  73         .items = max5821_powerdown_modes,
  74         .num_items = ARRAY_SIZE(max5821_powerdown_modes),
  75         .get = max5821_get_powerdown_mode,
  76         .set = max5821_set_powerdown_mode,
  77 };
  78
  79 static ssize_t max5821_read_dac_powerdown(struct iio_dev *indio_dev,
  80                                           uintptr_t private,
  81                                           const struct iio_chan_spec *chan,
  82                                           char *buf)
  83 {
  84         struct max5821_data *st = iio_priv(indio_dev);
  85
  86         return sysfs_emit(buf, "%d\n", st->powerdown[chan->channel]);
  87 }
  88
  89 static int max5821_sync_powerdown_mode(struct max5821_data *data,
  90                                        const struct iio_chan_spec *chan)
  91 {
  92         u8 outbuf[2];
  93
  94         outbuf[0] = MAX5821_EXTENDED_COMMAND_MODE;
  95
  96         if (chan->channel == 0)
  97                 outbuf[1] = MAX5821_EXTENDED_DAC_A;
  98         else
  99                 outbuf[1] = MAX5821_EXTENDED_DAC_B;
 100
 101         if (data->powerdown[chan->channel])
 102                 outbuf[1] |= data->powerdown_mode[chan->channel] + 1;
 103         else
 104                 outbuf[1] |= MAX5821_EXTENDED_POWER_UP;
 105
 106         return i2c_master_send(data->client, outbuf, 2);
 107 }
 108
 109 static ssize_t max5821_write_dac_powerdown(struct iio_dev *indio_dev,
 110                                            uintptr_t private,
 111                                            const struct iio_chan_spec *chan,
 112                                            const char *buf, size_t len)
 113 {
 114         struct max5821_data *data = iio_priv(indio_dev);
 115         bool powerdown;
 116         int ret;
 117
 118         ret = kstrtobool(buf, &powerdown);
 119         if (ret)
 120                 return ret;
 121
 122         data->powerdown[chan->channel] = powerdown;
 123
 124         ret = max5821_sync_powerdown_mode(data, chan);
 125         if (ret < 0)
 126                 return ret;
 127
 128         return len;
 129 }
 130
 131 static const struct iio_chan_spec_ext_info max5821_ext_info[] = {
 132         {
 133                 .name = "powerdown",
 134                 .read = max5821_read_dac_powerdown,
 135                 .write = max5821_write_dac_powerdown,
 136                 .shared = IIO_SEPARATE,
 137         },
 138         IIO_ENUM("powerdown_mode", IIO_SEPARATE, &max5821_powerdown_mode_enum),
 139         IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &max5821_powerdown_mode_enum),
 140         { },
 141 };
 142
 143 #define MAX5821_CHANNEL(chan) {                                 \
 144         .type = IIO_VOLTAGE,                                    \
 145         .indexed = 1,                                           \
 146         .output = 1,                                            \
 147         .channel = (chan),                                      \
 148         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 149         .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE),    \
 150         .ext_info = max5821_ext_info,                           \
 151 }
 152
 153 static const struct iio_chan_spec max5821_channels[] = {
 154         MAX5821_CHANNEL(0),
 155         MAX5821_CHANNEL(1)
 156 };
 157
 158 static const u8 max5821_read_dac_command[] = {
 159         MAX5821_READ_DAC_A_COMMAND,
 160         MAX5821_READ_DAC_B_COMMAND
 161 };
 162
 163 static const u8 max5821_load_dac_command[] = {
 164         MAX5821_LOAD_DAC_A_IN_REG_B,
 165         MAX5821_LOAD_DAC_B_IN_REG_A
 166 };
 167
 168 static int max5821_get_value(struct iio_dev *indio_dev,
 169                              int *val, int channel)
 170 {
 171         struct max5821_data *data = iio_priv(indio_dev);
 172         struct i2c_client *client = data->client;
 173         u8 outbuf[1];
 174         u8 inbuf[2];
 175         int ret;
 176
 177         if ((channel != 0) && (channel != 1))
 178                 return -EINVAL;
 179
 180         outbuf[0] = max5821_read_dac_command[channel];
 181
 182         mutex_lock(&data->lock);
 183
 184         ret = i2c_master_send(client, outbuf, 1);
 185         if (ret < 0) {
 186                 mutex_unlock(&data->lock);
 187                 return ret;
 188         } else if (ret != 1) {
 189                 mutex_unlock(&data->lock);
 190                 return -EIO;
 191         }
 192
 193         ret = i2c_master_recv(client, inbuf, 2);
 194         if (ret < 0) {
 195                 mutex_unlock(&data->lock);
 196                 return ret;
 197         } else if (ret != 2) {
 198                 mutex_unlock(&data->lock);
 199                 return -EIO;
 200         }
 201
 202         mutex_unlock(&data->lock);
 203
 204         *val = ((inbuf[0] & 0x0f) << 6) | (inbuf[1] >> 2);
 205
 206         return IIO_VAL_INT;
 207 }
 208
 209 static int max5821_set_value(struct iio_dev *indio_dev,
 210                              int val, int channel)
 211 {
 212         struct max5821_data *data = iio_priv(indio_dev);
 213         struct i2c_client *client = data->client;
 214         u8 outbuf[2];
 215         int ret;
 216
 217         if ((val < 0) || (val > 1023))
 218                 return -EINVAL;
 219
 220         if ((channel != 0) && (channel != 1))
 221                 return -EINVAL;
 222
 223         outbuf[0] = max5821_load_dac_command[channel];
 224         outbuf[0] |= val >> 6;
 225         outbuf[1] = (val & 0x3f) << 2;
 226
 227         ret = i2c_master_send(client, outbuf, 2);
 228         if (ret < 0)
 229                 return ret;
 230         else if (ret != 2)
 231                 return -EIO;
 232         else
 233                 return 0;
 234 }
 235
 236 static int max5821_read_raw(struct iio_dev *indio_dev,
 237                            struct iio_chan_spec const *chan,
 238                            int *val, int *val2, long mask)
 239 {
 240         struct max5821_data *data = iio_priv(indio_dev);
 241
 242         switch (mask) {
 243         case IIO_CHAN_INFO_RAW:
 244                 return max5821_get_value(indio_dev, val, chan->channel);
 245         case IIO_CHAN_INFO_SCALE:
 246                 *val = data->vref_mv;
 247                 *val2 = 10;
 248                 return IIO_VAL_FRACTIONAL_LOG2;
 249         default:
 250                 return -EINVAL;
 251         }
 252 }
 253
 254 static int max5821_write_raw(struct iio_dev *indio_dev,
 255                              struct iio_chan_spec const *chan,
 256                              int val, int val2, long mask)
 257 {
 258         if (val2 != 0)
 259                 return -EINVAL;
 260
 261         switch (mask) {
 262         case IIO_CHAN_INFO_RAW:
 263                 return max5821_set_value(indio_dev, val, chan->channel);
 264         default:
 265                 return -EINVAL;
 266         }
 267 }
 268
 269 static int max5821_suspend(struct device *dev)
 270 {
 271         u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
 272                          MAX5821_EXTENDED_DAC_A |
 273                          MAX5821_EXTENDED_DAC_B |
 274                          MAX5821_EXTENDED_POWER_DOWN_MODE2 };
 275
 276         return i2c_master_send(to_i2c_client(dev), outbuf, 2);
 277 }
 278
 279 static int max5821_resume(struct device *dev)
 280 {
 281         u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
 282                          MAX5821_EXTENDED_DAC_A |
 283                          MAX5821_EXTENDED_DAC_B |
 284                          MAX5821_EXTENDED_POWER_UP };
 285
 286         return i2c_master_send(to_i2c_client(dev), outbuf, 2);
 287 }
 288
 289 static DEFINE_SIMPLE_DEV_PM_OPS(max5821_pm_ops, max5821_suspend,
 290                                 max5821_resume);
 291
 292 static const struct iio_info max5821_info = {
 293         .read_raw = max5821_read_raw,
 294         .write_raw = max5821_write_raw,
 295 };
 296
 297 static int max5821_probe(struct i2c_client *client)
 298 {
 299         const struct i2c_device_id *id = i2c_client_get_device_id(client);
 300         struct max5821_data *data;
 301         struct iio_dev *indio_dev;
 302         u32 tmp;
 303         int ret;
 304
 305         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 306         if (!indio_dev)
 307                 return -ENOMEM;
 308         data = iio_priv(indio_dev);
 309         data->client = client;
 310         mutex_init(&data->lock);
 311
 312         /* max5821 start in powerdown mode 100Kohm to ground */
 313         for (tmp = 0; tmp < MAX5821_MAX_DAC_CHANNELS; tmp++) {
 314                 data->powerdown[tmp] = true;
 315                 data->powerdown_mode[tmp] = MAX5821_100KOHM_TO_GND;
 316         }
 317
 318         ret = devm_regulator_get_enable_read_voltage(&client->dev, "vref");
 319         if (ret)
 320                 return dev_err_probe(&client->dev, ret,
 321                                      "Failed to get vref regulator voltage\n");
 322
 323         data->vref_mv = ret / 1000;
 324
 325         indio_dev->name = id->name;
 326         indio_dev->num_channels = ARRAY_SIZE(max5821_channels);
 327         indio_dev->channels = max5821_channels;
 328         indio_dev->modes = INDIO_DIRECT_MODE;
 329         indio_dev->info = &max5821_info;
 330
 331         return devm_iio_device_register(&client->dev, indio_dev);
 332 }
 333
 334 static const struct i2c_device_id max5821_id[] = {
 335         { "max5821", ID_MAX5821 },
 336         { }
 337 };
 338 MODULE_DEVICE_TABLE(i2c, max5821_id);
 339
 340 static const struct of_device_id max5821_of_match[] = {
 341         { .compatible = "maxim,max5821" },
 342         { }
 343 };
 344 MODULE_DEVICE_TABLE(of, max5821_of_match);
 345
 346 static struct i2c_driver max5821_driver = {
 347         .driver = {
 348                 .name   = "max5821",
 349                 .of_match_table = max5821_of_match,
 350                 .pm     = pm_sleep_ptr(&max5821_pm_ops),
 351         },
 352         .probe          = max5821_probe,
 353         .id_table       = max5821_id,
 354 };
 355 module_i2c_driver(max5821_driver);
 356
 357 MODULE_AUTHOR("Philippe Reynes <[email protected]>");
 358 MODULE_DESCRIPTION("MAX5821 DAC");
 359 MODULE_LICENSE("GPL v2");