drivers/iio/dac/ds4424.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Maxim Integrated
   4  * 7-bit, Multi-Channel Sink/Source Current DAC Driver
   5  * Copyright (C) 2017 Maxim Integrated
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/module.h>
  10 #include <linux/i2c.h>
  11 #include <linux/regulator/consumer.h>
  12 #include <linux/err.h>
  13 #include <linux/delay.h>
  14 #include <linux/iio/iio.h>
  15 #include <linux/iio/driver.h>
  16 #include <linux/iio/machine.h>
  17 #include <linux/iio/consumer.h>
  18
  19 #define DS4422_MAX_DAC_CHANNELS         2
  20 #define DS4424_MAX_DAC_CHANNELS         4
  21
  22 #define DS4424_DAC_ADDR(chan)   ((chan) + 0xf8)
  23 #define DS4424_SOURCE_I         1
  24 #define DS4424_SINK_I           0
  25
  26 #define DS4424_CHANNEL(chan) { \
  27         .type = IIO_CURRENT, \
  28         .indexed = 1, \
  29         .output = 1, \
  30         .channel = chan, \
  31         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  32 }
  33
  34 /*
  35  * DS4424 DAC control register 8 bits
  36  * [7]          0: to sink; 1: to source
  37  * [6:0]        steps to sink/source
  38  * bit[7] looks like a sign bit, but the value of the register is
  39  * not a two's complement code considering the bit[6:0] is a absolute
  40  * distance from the zero point.
  41  */
  42 union ds4424_raw_data {
  43         struct {
  44                 u8 dx:7;
  45                 u8 source_bit:1;
  46         };
  47         u8 bits;
  48 };
  49
  50 enum ds4424_device_ids {
  51         ID_DS4422,
  52         ID_DS4424,
  53 };
  54
  55 struct ds4424_data {
  56         struct i2c_client *client;
  57         struct mutex lock;
  58         uint8_t save[DS4424_MAX_DAC_CHANNELS];
  59         struct regulator *vcc_reg;
  60         uint8_t raw[DS4424_MAX_DAC_CHANNELS];
  61 };
  62
  63 static const struct iio_chan_spec ds4424_channels[] = {
  64         DS4424_CHANNEL(0),
  65         DS4424_CHANNEL(1),
  66         DS4424_CHANNEL(2),
  67         DS4424_CHANNEL(3),
  68 };
  69
  70 static int ds4424_get_value(struct iio_dev *indio_dev,
  71                              int *val, int channel)
  72 {
  73         struct ds4424_data *data = iio_priv(indio_dev);
  74         int ret;
  75
  76         mutex_lock(&data->lock);
  77         ret = i2c_smbus_read_byte_data(data->client, DS4424_DAC_ADDR(channel));
  78         if (ret < 0)
  79                 goto fail;
  80
  81         *val = ret;
  82
  83 fail:
  84         mutex_unlock(&data->lock);
  85         return ret;
  86 }
  87
  88 static int ds4424_set_value(struct iio_dev *indio_dev,
  89                              int val, struct iio_chan_spec const *chan)
  90 {
  91         struct ds4424_data *data = iio_priv(indio_dev);
  92         int ret;
  93
  94         mutex_lock(&data->lock);
  95         ret = i2c_smbus_write_byte_data(data->client,
  96                         DS4424_DAC_ADDR(chan->channel), val);
  97         if (ret < 0)
  98                 goto fail;
  99
 100         data->raw[chan->channel] = val;
 101
 102 fail:
 103         mutex_unlock(&data->lock);
 104         return ret;
 105 }
 106
 107 static int ds4424_read_raw(struct iio_dev *indio_dev,
 108                            struct iio_chan_spec const *chan,
 109                            int *val, int *val2, long mask)
 110 {
 111         union ds4424_raw_data raw;
 112         int ret;
 113
 114         switch (mask) {
 115         case IIO_CHAN_INFO_RAW:
 116                 ret = ds4424_get_value(indio_dev, val, chan->channel);
 117                 if (ret < 0) {
 118                         pr_err("%s : ds4424_get_value returned %d\n",
 119                                                         __func__, ret);
 120                         return ret;
 121                 }
 122                 raw.bits = *val;
 123                 *val = raw.dx;
 124                 if (raw.source_bit == DS4424_SINK_I)
 125                         *val = -*val;
 126                 return IIO_VAL_INT;
 127
 128         default:
 129                 return -EINVAL;
 130         }
 131 }
 132
 133 static int ds4424_write_raw(struct iio_dev *indio_dev,
 134                              struct iio_chan_spec const *chan,
 135                              int val, int val2, long mask)
 136 {
 137         union ds4424_raw_data raw;
 138
 139         if (val2 != 0)
 140                 return -EINVAL;
 141
 142         switch (mask) {
 143         case IIO_CHAN_INFO_RAW:
 144                 if (val < S8_MIN || val > S8_MAX)
 145                         return -EINVAL;
 146
 147                 if (val > 0) {
 148                         raw.source_bit = DS4424_SOURCE_I;
 149                         raw.dx = val;
 150                 } else {
 151                         raw.source_bit = DS4424_SINK_I;
 152                         raw.dx = -val;
 153                 }
 154
 155                 return ds4424_set_value(indio_dev, raw.bits, chan);
 156
 157         default:
 158                 return -EINVAL;
 159         }
 160 }
 161
 162 static int ds4424_verify_chip(struct iio_dev *indio_dev)
 163 {
 164         int ret, val;
 165
 166         ret = ds4424_get_value(indio_dev, &val, 0);
 167         if (ret < 0)
 168                 dev_err(&indio_dev->dev,
 169                                 "%s failed. ret: %d\n", __func__, ret);
 170
 171         return ret;
 172 }
 173
 174 static int __maybe_unused ds4424_suspend(struct device *dev)
 175 {
 176         struct i2c_client *client = to_i2c_client(dev);
 177         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 178         struct ds4424_data *data = iio_priv(indio_dev);
 179         int ret = 0;
 180         int i;
 181
 182         for (i = 0; i < indio_dev->num_channels; i++) {
 183                 data->save[i] = data->raw[i];
 184                 ret = ds4424_set_value(indio_dev, 0,
 185                                 &indio_dev->channels[i]);
 186                 if (ret < 0)
 187                         return ret;
 188         }
 189         return ret;
 190 }
 191
 192 static int __maybe_unused ds4424_resume(struct device *dev)
 193 {
 194         struct i2c_client *client = to_i2c_client(dev);
 195         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 196         struct ds4424_data *data = iio_priv(indio_dev);
 197         int ret = 0;
 198         int i;
 199
 200         for (i = 0; i < indio_dev->num_channels; i++) {
 201                 ret = ds4424_set_value(indio_dev, data->save[i],
 202                                 &indio_dev->channels[i]);
 203                 if (ret < 0)
 204                         return ret;
 205         }
 206         return ret;
 207 }
 208
 209 static SIMPLE_DEV_PM_OPS(ds4424_pm_ops, ds4424_suspend, ds4424_resume);
 210
 211 static const struct iio_info ds4424_info = {
 212         .read_raw = ds4424_read_raw,
 213         .write_raw = ds4424_write_raw,
 214 };
 215
 216 static int ds4424_probe(struct i2c_client *client,
 217                         const struct i2c_device_id *id)
 218 {
 219         struct ds4424_data *data;
 220         struct iio_dev *indio_dev;
 221         int ret;
 222
 223         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 224         if (!indio_dev) {
 225                 dev_err(&client->dev, "iio dev alloc failed.\n");
 226                 return -ENOMEM;
 227         }
 228
 229         data = iio_priv(indio_dev);
 230         i2c_set_clientdata(client, indio_dev);
 231         data->client = client;
 232         indio_dev->name = id->name;
 233         indio_dev->dev.of_node = client->dev.of_node;
 234         indio_dev->dev.parent = &client->dev;
 235
 236         if (!client->dev.of_node) {
 237                 dev_err(&client->dev,
 238                                 "Not found DT.\n");
 239                 return -ENODEV;
 240         }
 241
 242         data->vcc_reg = devm_regulator_get(&client->dev, "vcc");
 243         if (IS_ERR(data->vcc_reg)) {
 244                 dev_err(&client->dev,
 245                         "Failed to get vcc-supply regulator. err: %ld\n",
 246                                 PTR_ERR(data->vcc_reg));
 247                 return PTR_ERR(data->vcc_reg);
 248         }
 249
 250         mutex_init(&data->lock);
 251         ret = regulator_enable(data->vcc_reg);
 252         if (ret < 0) {
 253                 dev_err(&client->dev,
 254                                 "Unable to enable the regulator.\n");
 255                 return ret;
 256         }
 257
 258         usleep_range(1000, 1200);
 259         ret = ds4424_verify_chip(indio_dev);
 260         if (ret < 0)
 261                 goto fail;
 262
 263         switch (id->driver_data) {
 264         case ID_DS4422:
 265                 indio_dev->num_channels = DS4422_MAX_DAC_CHANNELS;
 266                 break;
 267         case ID_DS4424:
 268                 indio_dev->num_channels = DS4424_MAX_DAC_CHANNELS;
 269                 break;
 270         default:
 271                 dev_err(&client->dev,
 272                                 "ds4424: Invalid chip id.\n");
 273                 ret = -ENXIO;
 274                 goto fail;
 275         }
 276
 277         indio_dev->channels = ds4424_channels;
 278         indio_dev->modes = INDIO_DIRECT_MODE;
 279         indio_dev->info = &ds4424_info;
 280
 281         ret = iio_device_register(indio_dev);
 282         if (ret < 0) {
 283                 dev_err(&client->dev,
 284                                 "iio_device_register failed. ret: %d\n", ret);
 285                 goto fail;
 286         }
 287
 288         return ret;
 289
 290 fail:
 291         regulator_disable(data->vcc_reg);
 292         return ret;
 293 }
 294
 295 static int ds4424_remove(struct i2c_client *client)
 296 {
 297         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 298         struct ds4424_data *data = iio_priv(indio_dev);
 299
 300         iio_device_unregister(indio_dev);
 301         regulator_disable(data->vcc_reg);
 302
 303         return 0;
 304 }
 305
 306 static const struct i2c_device_id ds4424_id[] = {
 307         { "ds4422", ID_DS4422 },
 308         { "ds4424", ID_DS4424 },
 309         { }
 310 };
 311
 312 MODULE_DEVICE_TABLE(i2c, ds4424_id);
 313
 314 static const struct of_device_id ds4424_of_match[] = {
 315         { .compatible = "maxim,ds4422" },
 316         { .compatible = "maxim,ds4424" },
 317         { },
 318 };
 319
 320 MODULE_DEVICE_TABLE(of, ds4424_of_match);
 321
 322 static struct i2c_driver ds4424_driver = {
 323         .driver = {
 324                 .name   = "ds4424",
 325                 .of_match_table = ds4424_of_match,
 326                 .pm     = &ds4424_pm_ops,
 327         },
 328         .probe          = ds4424_probe,
 329         .remove         = ds4424_remove,
 330         .id_table       = ds4424_id,
 331 };
 332 module_i2c_driver(ds4424_driver);
 333
 334 MODULE_DESCRIPTION("Maxim DS4424 DAC Driver");
 335 MODULE_AUTHOR("Ismail H. Kose <ismail.kose@maximintegrated.com>");
 336 MODULE_AUTHOR("Vishal Sood <vishal.sood@maximintegrated.com>");
 337 MODULE_AUTHOR("David Jung <david.jung@maximintegrated.com>");
 338 MODULE_LICENSE("GPL v2");