root/drivers/iio/dac/max517.c

DEFINITIONS

1. max517_set_value
2. max517_read_raw
3. max517_write_raw
4. max517_suspend
5. max517_resume
6. max517_probe
7. max517_remove

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  max517.c - Support for Maxim MAX517, MAX518 and MAX519
   4  *
   5  *  Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
   6  */
   7 
   8 #include <linux/module.h>
   9 #include <linux/slab.h>
  10 #include <linux/jiffies.h>
  11 #include <linux/i2c.h>
  12 #include <linux/err.h>
  13 
  14 #include <linux/iio/iio.h>
  15 #include <linux/iio/sysfs.h>
  16 #include <linux/iio/dac/max517.h>
  17 
  18 #define MAX517_DRV_NAME "max517"
  19 
  20 /* Commands */
  21 #define COMMAND_CHANNEL0        0x00
  22 #define COMMAND_CHANNEL1        0x01 /* for MAX518 and MAX519 */
  23 #define COMMAND_PD              0x08 /* Power Down */
  24 
  25 enum max517_device_ids {
  26         ID_MAX517,
  27         ID_MAX518,
  28         ID_MAX519,
  29         ID_MAX520,
  30         ID_MAX521,
  31 };
  32 
  33 struct max517_data {
  34         struct i2c_client       *client;
  35         unsigned short          vref_mv[8];
  36 };
  37 
  38 /*
  39  * channel: bit 0: channel 1
  40  *          bit 1: channel 2
  41  * (this way, it's possible to set both channels at once)
  42  */
  43 static int max517_set_value(struct iio_dev *indio_dev,
  44         long val, int channel)
  45 {
  46         struct max517_data *data = iio_priv(indio_dev);
  47         struct i2c_client *client = data->client;
  48         u8 outbuf[2];
  49         int res;
  50 
  51         if (val < 0 || val > 255)
  52                 return -EINVAL;
  53 
  54         outbuf[0] = channel;
  55         outbuf[1] = val;
  56 
  57         res = i2c_master_send(client, outbuf, 2);
  58         if (res < 0)
  59                 return res;
  60         else if (res != 2)
  61                 return -EIO;
  62         else
  63                 return 0;
  64 }
  65 
  66 static int max517_read_raw(struct iio_dev *indio_dev,
  67                            struct iio_chan_spec const *chan,
  68                            int *val,
  69                            int *val2,
  70                            long m)
  71 {
  72         struct max517_data *data = iio_priv(indio_dev);
  73 
  74         switch (m) {
  75         case IIO_CHAN_INFO_SCALE:
  76                 /* Corresponds to Vref / 2^(bits) */
  77                 *val = data->vref_mv[chan->channel];
  78                 *val2 = 8;
  79                 return IIO_VAL_FRACTIONAL_LOG2;
  80         default:
  81                 break;
  82         }
  83         return -EINVAL;
  84 }
  85 
  86 static int max517_write_raw(struct iio_dev *indio_dev,
  87         struct iio_chan_spec const *chan, int val, int val2, long mask)
  88 {
  89         int ret;
  90 
  91         switch (mask) {
  92         case IIO_CHAN_INFO_RAW:
  93                 ret = max517_set_value(indio_dev, val, chan->channel);
  94                 break;
  95         default:
  96                 ret = -EINVAL;
  97                 break;
  98         }
  99 
 100         return ret;
 101 }
 102 
 103 static int __maybe_unused max517_suspend(struct device *dev)
 104 {
 105         u8 outbuf = COMMAND_PD;
 106 
 107         return i2c_master_send(to_i2c_client(dev), &outbuf, 1);
 108 }
 109 
 110 static int __maybe_unused max517_resume(struct device *dev)
 111 {
 112         u8 outbuf = 0;
 113 
 114         return i2c_master_send(to_i2c_client(dev), &outbuf, 1);
 115 }
 116 
 117 static SIMPLE_DEV_PM_OPS(max517_pm_ops, max517_suspend, max517_resume);
 118 
 119 static const struct iio_info max517_info = {
 120         .read_raw = max517_read_raw,
 121         .write_raw = max517_write_raw,
 122 };
 123 
 124 #define MAX517_CHANNEL(chan) {                          \
 125         .type = IIO_VOLTAGE,                            \
 126         .indexed = 1,                                   \
 127         .output = 1,                                    \
 128         .channel = (chan),                              \
 129         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |  \
 130         BIT(IIO_CHAN_INFO_SCALE),                       \
 131 }
 132 
 133 static const struct iio_chan_spec max517_channels[] = {
 134         MAX517_CHANNEL(0),
 135         MAX517_CHANNEL(1),
 136         MAX517_CHANNEL(2),
 137         MAX517_CHANNEL(3),
 138         MAX517_CHANNEL(4),
 139         MAX517_CHANNEL(5),
 140         MAX517_CHANNEL(6),
 141         MAX517_CHANNEL(7),
 142 };
 143 
 144 static int max517_probe(struct i2c_client *client,
 145                         const struct i2c_device_id *id)
 146 {
 147         struct max517_data *data;
 148         struct iio_dev *indio_dev;
 149         struct max517_platform_data *platform_data = client->dev.platform_data;
 150         int chan;
 151 
 152         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 153         if (!indio_dev)
 154                 return -ENOMEM;
 155         data = iio_priv(indio_dev);
 156         i2c_set_clientdata(client, indio_dev);
 157         data->client = client;
 158 
 159         /* establish that the iio_dev is a child of the i2c device */
 160         indio_dev->dev.parent = &client->dev;
 161 
 162         switch (id->driver_data) {
 163         case ID_MAX521:
 164                 indio_dev->num_channels = 8;
 165                 break;
 166         case ID_MAX520:
 167                 indio_dev->num_channels = 4;
 168                 break;
 169         case ID_MAX519:
 170         case ID_MAX518:
 171                 indio_dev->num_channels = 2;
 172                 break;
 173         default:  /* single channel for MAX517 */
 174                 indio_dev->num_channels = 1;
 175                 break;
 176         }
 177         indio_dev->channels = max517_channels;
 178         indio_dev->modes = INDIO_DIRECT_MODE;
 179         indio_dev->info = &max517_info;
 180 
 181         /*
 182          * Reference voltage on MAX518 and default is 5V, else take vref_mv
 183          * from platform_data
 184          */
 185         for (chan = 0; chan < indio_dev->num_channels; chan++) {
 186                 if (id->driver_data == ID_MAX518 || !platform_data)
 187                         data->vref_mv[chan] = 5000; /* mV */
 188                 else
 189                         data->vref_mv[chan] = platform_data->vref_mv[chan];
 190         }
 191 
 192         return iio_device_register(indio_dev);
 193 }
 194 
 195 static int max517_remove(struct i2c_client *client)
 196 {
 197         iio_device_unregister(i2c_get_clientdata(client));
 198         return 0;
 199 }
 200 
 201 static const struct i2c_device_id max517_id[] = {
 202         { "max517", ID_MAX517 },
 203         { "max518", ID_MAX518 },
 204         { "max519", ID_MAX519 },
 205         { "max520", ID_MAX520 },
 206         { "max521", ID_MAX521 },
 207         { }
 208 };
 209 MODULE_DEVICE_TABLE(i2c, max517_id);
 210 
 211 static struct i2c_driver max517_driver = {
 212         .driver = {
 213                 .name   = MAX517_DRV_NAME,
 214                 .pm     = &max517_pm_ops,
 215         },
 216         .probe          = max517_probe,
 217         .remove         = max517_remove,
 218         .id_table       = max517_id,
 219 };
 220 module_i2c_driver(max517_driver);
 221 
 222 MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
 223 MODULE_DESCRIPTION("MAX517/518/519/520/521 8-bit DAC");
 224 MODULE_LICENSE("GPL");