1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * MAX1117/MAX1118/MAX1119 8-bit, dual-channel ADCs driver 4 * 5 * Copyright (c) 2017 Akinobu Mita <akinobu.mita@gmail.com> 6 * 7 * Datasheet: https://datasheets.maximintegrated.com/en/ds/MAX1117-MAX1119.pdf 8 * 9 * SPI interface connections 10 * 11 * SPI MAXIM 12 * Master Direction MAX1117/8/9 13 * ------ --------- ----------- 14 * nCS --> CNVST 15 * SCK --> SCLK 16 * MISO <-- DOUT 17 * ------ --------- ----------- 18 */ 19 20 #include <linux/module.h> 21 #include <linux/mod_devicetable.h> 22 #include <linux/spi/spi.h> 23 #include <linux/iio/iio.h> 24 #include <linux/iio/buffer.h> 25 #include <linux/iio/triggered_buffer.h> 26 #include <linux/iio/trigger_consumer.h> 27 #include <linux/regulator/consumer.h> 28 29 enum max1118_id { 30 max1117, 31 max1118, 32 max1119, 33 }; 34 35 struct max1118 { 36 struct spi_device *spi; 37 struct mutex lock; 38 struct regulator *reg; 39 /* Ensure natural alignment of buffer elements */ 40 struct { 41 u8 channels[2]; 42 s64 ts __aligned(8); 43 } scan; 44 45 u8 data ____cacheline_aligned; 46 }; 47 48 #define MAX1118_CHANNEL(ch) \ 49 { \ 50 .type = IIO_VOLTAGE, \ 51 .indexed = 1, \ 52 .channel = (ch), \ 53 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 54 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 55 .scan_index = ch, \ 56 .scan_type = { \ 57 .sign = 'u', \ 58 .realbits = 8, \ 59 .storagebits = 8, \ 60 }, \ 61 } 62 63 static const struct iio_chan_spec max1118_channels[] = { 64 MAX1118_CHANNEL(0), 65 MAX1118_CHANNEL(1), 66 IIO_CHAN_SOFT_TIMESTAMP(2), 67 }; 68 69 static int max1118_read(struct spi_device *spi, int channel) 70 { 71 struct iio_dev *indio_dev = spi_get_drvdata(spi); 72 struct max1118 *adc = iio_priv(indio_dev); 73 struct spi_transfer xfers[] = { 74 /* 75 * To select CH1 for conversion, CNVST pin must be brought high 76 * and low for a second time. 77 */ 78 { 79 .len = 0, 80 .delay = { /* > CNVST Low Time 100 ns */ 81 .value = 1, 82 .unit = SPI_DELAY_UNIT_USECS 83 }, 84 .cs_change = 1, 85 }, 86 /* 87 * The acquisition interval begins with the falling edge of 88 * CNVST. The total acquisition and conversion process takes 89 * <7.5us. 90 */ 91 { 92 .len = 0, 93 .delay = { 94 .value = 8, 95 .unit = SPI_DELAY_UNIT_USECS 96 }, 97 }, 98 { 99 .rx_buf = &adc->data, 100 .len = 1, 101 }, 102 }; 103 int ret; 104 105 if (channel == 0) 106 ret = spi_sync_transfer(spi, xfers + 1, 2); 107 else 108 ret = spi_sync_transfer(spi, xfers, 3); 109 110 if (ret) 111 return ret; 112 113 return adc->data; 114 } 115 116 static int max1118_get_vref_mV(struct spi_device *spi) 117 { 118 struct iio_dev *indio_dev = spi_get_drvdata(spi); 119 struct max1118 *adc = iio_priv(indio_dev); 120 const struct spi_device_id *id = spi_get_device_id(spi); 121 int vref_uV; 122 123 switch (id->driver_data) { 124 case max1117: 125 return 2048; 126 case max1119: 127 return 4096; 128 case max1118: 129 vref_uV = regulator_get_voltage(adc->reg); 130 if (vref_uV < 0) 131 return vref_uV; 132 return vref_uV / 1000; 133 } 134 135 return -ENODEV; 136 } 137 138 static int max1118_read_raw(struct iio_dev *indio_dev, 139 struct iio_chan_spec const *chan, 140 int *val, int *val2, long mask) 141 { 142 struct max1118 *adc = iio_priv(indio_dev); 143 144 switch (mask) { 145 case IIO_CHAN_INFO_RAW: 146 mutex_lock(&adc->lock); 147 *val = max1118_read(adc->spi, chan->channel); 148 mutex_unlock(&adc->lock); 149 if (*val < 0) 150 return *val; 151 152 return IIO_VAL_INT; 153 case IIO_CHAN_INFO_SCALE: 154 *val = max1118_get_vref_mV(adc->spi); 155 if (*val < 0) 156 return *val; 157 *val2 = 8; 158 159 return IIO_VAL_FRACTIONAL_LOG2; 160 } 161 162 return -EINVAL; 163 } 164 165 static const struct iio_info max1118_info = { 166 .read_raw = max1118_read_raw, 167 }; 168 169 static irqreturn_t max1118_trigger_handler(int irq, void *p) 170 { 171 struct iio_poll_func *pf = p; 172 struct iio_dev *indio_dev = pf->indio_dev; 173 struct max1118 *adc = iio_priv(indio_dev); 174 int scan_index; 175 int i = 0; 176 177 mutex_lock(&adc->lock); 178 179 for_each_set_bit(scan_index, indio_dev->active_scan_mask, 180 indio_dev->masklength) { 181 const struct iio_chan_spec *scan_chan = 182 &indio_dev->channels[scan_index]; 183 int ret = max1118_read(adc->spi, scan_chan->channel); 184 185 if (ret < 0) { 186 dev_warn(&adc->spi->dev, 187 "failed to get conversion data\n"); 188 goto out; 189 } 190 191 adc->scan.channels[i] = ret; 192 i++; 193 } 194 iio_push_to_buffers_with_timestamp(indio_dev, &adc->scan, 195 iio_get_time_ns(indio_dev)); 196 out: 197 mutex_unlock(&adc->lock); 198 199 iio_trigger_notify_done(indio_dev->trig); 200 201 return IRQ_HANDLED; 202 } 203 204 static int max1118_probe(struct spi_device *spi) 205 { 206 struct iio_dev *indio_dev; 207 struct max1118 *adc; 208 const struct spi_device_id *id = spi_get_device_id(spi); 209 int ret; 210 211 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adc)); 212 if (!indio_dev) 213 return -ENOMEM; 214 215 adc = iio_priv(indio_dev); 216 adc->spi = spi; 217 mutex_init(&adc->lock); 218 219 if (id->driver_data == max1118) { 220 adc->reg = devm_regulator_get(&spi->dev, "vref"); 221 if (IS_ERR(adc->reg)) { 222 dev_err(&spi->dev, "failed to get vref regulator\n"); 223 return PTR_ERR(adc->reg); 224 } 225 ret = regulator_enable(adc->reg); 226 if (ret) 227 return ret; 228 } 229 230 spi_set_drvdata(spi, indio_dev); 231 232 indio_dev->name = spi_get_device_id(spi)->name; 233 indio_dev->info = &max1118_info; 234 indio_dev->modes = INDIO_DIRECT_MODE; 235 indio_dev->channels = max1118_channels; 236 indio_dev->num_channels = ARRAY_SIZE(max1118_channels); 237 238 /* 239 * To reinitiate a conversion on CH0, it is necessary to allow for a 240 * conversion to be complete and all of the data to be read out. Once 241 * a conversion has been completed, the MAX1117/MAX1118/MAX1119 will go 242 * into AutoShutdown mode until the next conversion is initiated. 243 */ 244 max1118_read(spi, 0); 245 246 ret = iio_triggered_buffer_setup(indio_dev, NULL, 247 max1118_trigger_handler, NULL); 248 if (ret) 249 goto err_reg_disable; 250 251 ret = iio_device_register(indio_dev); 252 if (ret) 253 goto err_buffer_cleanup; 254 255 return 0; 256 257 err_buffer_cleanup: 258 iio_triggered_buffer_cleanup(indio_dev); 259 err_reg_disable: 260 if (id->driver_data == max1118) 261 regulator_disable(adc->reg); 262 263 return ret; 264 } 265 266 static int max1118_remove(struct spi_device *spi) 267 { 268 struct iio_dev *indio_dev = spi_get_drvdata(spi); 269 struct max1118 *adc = iio_priv(indio_dev); 270 const struct spi_device_id *id = spi_get_device_id(spi); 271 272 iio_device_unregister(indio_dev); 273 iio_triggered_buffer_cleanup(indio_dev); 274 if (id->driver_data == max1118) 275 return regulator_disable(adc->reg); 276 277 return 0; 278 } 279 280 static const struct spi_device_id max1118_id[] = { 281 { "max1117", max1117 }, 282 { "max1118", max1118 }, 283 { "max1119", max1119 }, 284 {} 285 }; 286 MODULE_DEVICE_TABLE(spi, max1118_id); 287 288 static const struct of_device_id max1118_dt_ids[] = { 289 { .compatible = "maxim,max1117" }, 290 { .compatible = "maxim,max1118" }, 291 { .compatible = "maxim,max1119" }, 292 {}, 293 }; 294 MODULE_DEVICE_TABLE(of, max1118_dt_ids); 295 296 static struct spi_driver max1118_spi_driver = { 297 .driver = { 298 .name = "max1118", 299 .of_match_table = max1118_dt_ids, 300 }, 301 .probe = max1118_probe, 302 .remove = max1118_remove, 303 .id_table = max1118_id, 304 }; 305 module_spi_driver(max1118_spi_driver); 306 307 MODULE_AUTHOR("Akinobu Mita <akinobu.mita@gmail.com>"); 308 MODULE_DESCRIPTION("MAXIM MAX1117/MAX1118/MAX1119 ADCs driver"); 309 MODULE_LICENSE("GPL v2"); 310