iio/dac/m62332.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  m62332.c - Support for Mitsubishi m62332 DAC
0004  *
0005  *  Copyright (c) 2014 Dmitry Eremin-Solenikov
0006  *
0007  *  Based on max517 driver:
0008  *  Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
0009  */
0010
0011 #include <linux/module.h>
0012 #include <linux/slab.h>
0013 #include <linux/i2c.h>
0014 #include <linux/err.h>
0015
0016 #include <linux/iio/iio.h>
0017 #include <linux/iio/driver.h>
0018
0019 #include <linux/regulator/consumer.h>
0020
0021 #define M62332_CHANNELS 2
0022
0023 struct m62332_data {
0024     struct i2c_client   *client;
0025     struct regulator    *vcc;
0026     struct mutex        mutex;
0027     u8          raw[M62332_CHANNELS];
0028     u8          save[M62332_CHANNELS];
0029 };
0030
0031 static int m62332_set_value(struct iio_dev *indio_dev, u8 val, int channel)
0032 {
0033     struct m62332_data *data = iio_priv(indio_dev);
0034     struct i2c_client *client = data->client;
0035     u8 outbuf[2];
0036     int res;
0037
0038     if (val == data->raw[channel])
0039         return 0;
0040
0041     outbuf[0] = channel;
0042     outbuf[1] = val;
0043
0044     mutex_lock(&data->mutex);
0045
0046     if (val) {
0047         res = regulator_enable(data->vcc);
0048         if (res)
0049             goto out;
0050     }
0051
0052     res = i2c_master_send(client, outbuf, ARRAY_SIZE(outbuf));
0053     if (res >= 0 && res != ARRAY_SIZE(outbuf))
0054         res = -EIO;
0055     if (res < 0)
0056         goto out;
0057
0058     data->raw[channel] = val;
0059
0060     if (!val)
0061         regulator_disable(data->vcc);
0062
0063     mutex_unlock(&data->mutex);
0064
0065     return 0;
0066
0067 out:
0068     mutex_unlock(&data->mutex);
0069
0070     return res;
0071 }
0072
0073 static int m62332_read_raw(struct iio_dev *indio_dev,
0074                struct iio_chan_spec const *chan,
0075                int *val,
0076                int *val2,
0077                long mask)
0078 {
0079     struct m62332_data *data = iio_priv(indio_dev);
0080     int ret;
0081
0082     switch (mask) {
0083     case IIO_CHAN_INFO_SCALE:
0084         /* Corresponds to Vref / 2^(bits) */
0085         ret = regulator_get_voltage(data->vcc);
0086         if (ret < 0)
0087             return ret;
0088
0089         *val = ret / 1000; /* mV */
0090         *val2 = 8;
0091
0092         return IIO_VAL_FRACTIONAL_LOG2;
0093     case IIO_CHAN_INFO_RAW:
0094         *val = data->raw[chan->channel];
0095
0096         return IIO_VAL_INT;
0097     case IIO_CHAN_INFO_OFFSET:
0098         *val = 1;
0099
0100         return IIO_VAL_INT;
0101     default:
0102         break;
0103     }
0104
0105     return -EINVAL;
0106 }
0107
0108 static int m62332_write_raw(struct iio_dev *indio_dev,
0109                 struct iio_chan_spec const *chan, int val, int val2,
0110                 long mask)
0111 {
0112     switch (mask) {
0113     case IIO_CHAN_INFO_RAW:
0114         if (val < 0 || val > 255)
0115             return -EINVAL;
0116
0117         return m62332_set_value(indio_dev, val, chan->channel);
0118     default:
0119         break;
0120     }
0121
0122     return -EINVAL;
0123 }
0124
0125 static int m62332_suspend(struct device *dev)
0126 {
0127     struct i2c_client *client = to_i2c_client(dev);
0128     struct iio_dev *indio_dev = i2c_get_clientdata(client);
0129     struct m62332_data *data = iio_priv(indio_dev);
0130     int ret;
0131
0132     data->save[0] = data->raw[0];
0133     data->save[1] = data->raw[1];
0134
0135     ret = m62332_set_value(indio_dev, 0, 0);
0136     if (ret < 0)
0137         return ret;
0138
0139     return m62332_set_value(indio_dev, 0, 1);
0140 }
0141
0142 static int m62332_resume(struct device *dev)
0143 {
0144     struct i2c_client *client = to_i2c_client(dev);
0145     struct iio_dev *indio_dev = i2c_get_clientdata(client);
0146     struct m62332_data *data = iio_priv(indio_dev);
0147     int ret;
0148
0149     ret = m62332_set_value(indio_dev, data->save[0], 0);
0150     if (ret < 0)
0151         return ret;
0152
0153     return m62332_set_value(indio_dev, data->save[1], 1);
0154 }
0155
0156 static DEFINE_SIMPLE_DEV_PM_OPS(m62332_pm_ops, m62332_suspend, m62332_resume);
0157
0158 static const struct iio_info m62332_info = {
0159     .read_raw = m62332_read_raw,
0160     .write_raw = m62332_write_raw,
0161 };
0162
0163 #define M62332_CHANNEL(chan) {                  \
0164     .type = IIO_VOLTAGE,                    \
0165     .indexed = 1,                       \
0166     .output = 1,                        \
0167     .channel = (chan),                  \
0168     .datasheet_name = "CH" #chan,               \
0169     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),       \
0170     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
0171                     BIT(IIO_CHAN_INFO_OFFSET),  \
0172 }
0173
0174 static const struct iio_chan_spec m62332_channels[M62332_CHANNELS] = {
0175     M62332_CHANNEL(0),
0176     M62332_CHANNEL(1)
0177 };
0178
0179 static int m62332_probe(struct i2c_client *client,
0180             const struct i2c_device_id *id)
0181 {
0182     struct m62332_data *data;
0183     struct iio_dev *indio_dev;
0184     int ret;
0185
0186     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
0187     if (!indio_dev)
0188         return -ENOMEM;
0189
0190     data = iio_priv(indio_dev);
0191     i2c_set_clientdata(client, indio_dev);
0192     data->client = client;
0193
0194     mutex_init(&data->mutex);
0195
0196     data->vcc = devm_regulator_get(&client->dev, "VCC");
0197     if (IS_ERR(data->vcc))
0198         return PTR_ERR(data->vcc);
0199
0200     indio_dev->num_channels = ARRAY_SIZE(m62332_channels);
0201     indio_dev->channels = m62332_channels;
0202     indio_dev->modes = INDIO_DIRECT_MODE;
0203     indio_dev->info = &m62332_info;
0204
0205     ret = iio_map_array_register(indio_dev, client->dev.platform_data);
0206     if (ret < 0)
0207         return ret;
0208
0209     ret = iio_device_register(indio_dev);
0210     if (ret < 0)
0211         goto err;
0212
0213     return 0;
0214
0215 err:
0216     iio_map_array_unregister(indio_dev);
0217
0218     return ret;
0219 }
0220
0221 static int m62332_remove(struct i2c_client *client)
0222 {
0223     struct iio_dev *indio_dev = i2c_get_clientdata(client);
0224
0225     iio_device_unregister(indio_dev);
0226     iio_map_array_unregister(indio_dev);
0227     m62332_set_value(indio_dev, 0, 0);
0228     m62332_set_value(indio_dev, 0, 1);
0229
0230     return 0;
0231 }
0232
0233 static const struct i2c_device_id m62332_id[] = {
0234     { "m62332", },
0235     { }
0236 };
0237 MODULE_DEVICE_TABLE(i2c, m62332_id);
0238
0239 static struct i2c_driver m62332_driver = {
0240     .driver = {
0241         .name   = "m62332",
0242         .pm = pm_sleep_ptr(&m62332_pm_ops),
0243     },
0244     .probe      = m62332_probe,
0245     .remove     = m62332_remove,
0246     .id_table   = m62332_id,
0247 };
0248 module_i2c_driver(m62332_driver);
0249
0250 MODULE_AUTHOR("Dmitry Eremin-Solenikov");
0251 MODULE_DESCRIPTION("M62332 8-bit DAC");
0252 MODULE_LICENSE("GPL v2");