1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * ti-adc161s626.c - Texas Instruments ADC161S626 1-channel differential ADC 4 * 5 * ADC Devices Supported: 6 * adc141s626 - 14-bit ADC 7 * adc161s626 - 16-bit ADC 8 * 9 * Copyright (C) 2016-2018 10 * Author: Matt Ranostay <matt.ranostay@konsulko.com> 11 */ 12 13 #include <linux/module.h> 14 #include <linux/mod_devicetable.h> 15 #include <linux/init.h> 16 #include <linux/err.h> 17 #include <linux/spi/spi.h> 18 #include <linux/iio/iio.h> 19 #include <linux/iio/trigger.h> 20 #include <linux/iio/buffer.h> 21 #include <linux/iio/trigger_consumer.h> 22 #include <linux/iio/triggered_buffer.h> 23 #include <linux/regulator/consumer.h> 24 25 #define TI_ADC_DRV_NAME "ti-adc161s626" 26 27 enum { 28 TI_ADC141S626, 29 TI_ADC161S626, 30 }; 31 32 static const struct iio_chan_spec ti_adc141s626_channels[] = { 33 { 34 .type = IIO_VOLTAGE, 35 .channel = 0, 36 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 37 BIT(IIO_CHAN_INFO_SCALE) | 38 BIT(IIO_CHAN_INFO_OFFSET), 39 .scan_index = 0, 40 .scan_type = { 41 .sign = 's', 42 .realbits = 14, 43 .storagebits = 16, 44 }, 45 }, 46 IIO_CHAN_SOFT_TIMESTAMP(1), 47 }; 48 49 static const struct iio_chan_spec ti_adc161s626_channels[] = { 50 { 51 .type = IIO_VOLTAGE, 52 .channel = 0, 53 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 54 BIT(IIO_CHAN_INFO_SCALE) | 55 BIT(IIO_CHAN_INFO_OFFSET), 56 .scan_index = 0, 57 .scan_type = { 58 .sign = 's', 59 .realbits = 16, 60 .storagebits = 16, 61 }, 62 }, 63 IIO_CHAN_SOFT_TIMESTAMP(1), 64 }; 65 66 struct ti_adc_data { 67 struct iio_dev *indio_dev; 68 struct spi_device *spi; 69 struct regulator *ref; 70 71 u8 read_size; 72 u8 shift; 73 74 u8 buffer[16] __aligned(IIO_DMA_MINALIGN); 75 }; 76 77 static int ti_adc_read_measurement(struct ti_adc_data *data, 78 struct iio_chan_spec const *chan, int *val) 79 { 80 int ret; 81 82 switch (data->read_size) { 83 case 2: { 84 __be16 buf; 85 86 ret = spi_read(data->spi, (void *) &buf, 2); 87 if (ret) 88 return ret; 89 90 *val = be16_to_cpu(buf); 91 break; 92 } 93 case 3: { 94 __be32 buf; 95 96 ret = spi_read(data->spi, (void *) &buf, 3); 97 if (ret) 98 return ret; 99 100 *val = be32_to_cpu(buf) >> 8; 101 break; 102 } 103 default: 104 return -EINVAL; 105 } 106 107 *val = sign_extend32(*val >> data->shift, chan->scan_type.realbits - 1); 108 109 return 0; 110 } 111 112 static irqreturn_t ti_adc_trigger_handler(int irq, void *private) 113 { 114 struct iio_poll_func *pf = private; 115 struct iio_dev *indio_dev = pf->indio_dev; 116 struct ti_adc_data *data = iio_priv(indio_dev); 117 int ret; 118 119 ret = ti_adc_read_measurement(data, &indio_dev->channels[0], 120 (int *) &data->buffer); 121 if (!ret) 122 iio_push_to_buffers_with_timestamp(indio_dev, 123 data->buffer, 124 iio_get_time_ns(indio_dev)); 125 126 iio_trigger_notify_done(indio_dev->trig); 127 128 return IRQ_HANDLED; 129 } 130 131 static int ti_adc_read_raw(struct iio_dev *indio_dev, 132 struct iio_chan_spec const *chan, 133 int *val, int *val2, long mask) 134 { 135 struct ti_adc_data *data = iio_priv(indio_dev); 136 int ret; 137 138 switch (mask) { 139 case IIO_CHAN_INFO_RAW: 140 iio_device_claim_direct_scoped(return -EBUSY, indio_dev) { 141 ret = ti_adc_read_measurement(data, chan, val); 142 if (ret) 143 return ret; 144 return IIO_VAL_INT; 145 } 146 unreachable(); 147 case IIO_CHAN_INFO_SCALE: 148 ret = regulator_get_voltage(data->ref); 149 if (ret < 0) 150 return ret; 151 152 *val = ret / 1000; 153 *val2 = chan->scan_type.realbits; 154 155 return IIO_VAL_FRACTIONAL_LOG2; 156 case IIO_CHAN_INFO_OFFSET: 157 *val = 1 << (chan->scan_type.realbits - 1); 158 return IIO_VAL_INT; 159 } 160 161 return 0; 162 } 163 164 static const struct iio_info ti_adc_info = { 165 .read_raw = ti_adc_read_raw, 166 }; 167 168 static void ti_adc_reg_disable(void *reg) 169 { 170 regulator_disable(reg); 171 } 172 173 static int ti_adc_probe(struct spi_device *spi) 174 { 175 struct iio_dev *indio_dev; 176 struct ti_adc_data *data; 177 int ret; 178 179 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data)); 180 if (!indio_dev) 181 return -ENOMEM; 182 183 indio_dev->info = &ti_adc_info; 184 indio_dev->name = TI_ADC_DRV_NAME; 185 indio_dev->modes = INDIO_DIRECT_MODE; 186 187 data = iio_priv(indio_dev); 188 data->spi = spi; 189 190 switch (spi_get_device_id(spi)->driver_data) { 191 case TI_ADC141S626: 192 indio_dev->channels = ti_adc141s626_channels; 193 indio_dev->num_channels = ARRAY_SIZE(ti_adc141s626_channels); 194 data->shift = 0; 195 data->read_size = 2; 196 break; 197 case TI_ADC161S626: 198 indio_dev->channels = ti_adc161s626_channels; 199 indio_dev->num_channels = ARRAY_SIZE(ti_adc161s626_channels); 200 data->shift = 6; 201 data->read_size = 3; 202 break; 203 } 204 205 data->ref = devm_regulator_get(&spi->dev, "vdda"); 206 if (IS_ERR(data->ref)) 207 return PTR_ERR(data->ref); 208 209 ret = regulator_enable(data->ref); 210 if (ret < 0) 211 return ret; 212 213 ret = devm_add_action_or_reset(&spi->dev, ti_adc_reg_disable, 214 data->ref); 215 if (ret) 216 return ret; 217 218 ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL, 219 ti_adc_trigger_handler, NULL); 220 if (ret) 221 return ret; 222 223 return devm_iio_device_register(&spi->dev, indio_dev); 224 } 225 226 static const struct of_device_id ti_adc_dt_ids[] = { 227 { .compatible = "ti,adc141s626", }, 228 { .compatible = "ti,adc161s626", }, 229 {} 230 }; 231 MODULE_DEVICE_TABLE(of, ti_adc_dt_ids); 232 233 static const struct spi_device_id ti_adc_id[] = { 234 {"adc141s626", TI_ADC141S626}, 235 {"adc161s626", TI_ADC161S626}, 236 {}, 237 }; 238 MODULE_DEVICE_TABLE(spi, ti_adc_id); 239 240 static struct spi_driver ti_adc_driver = { 241 .driver = { 242 .name = TI_ADC_DRV_NAME, 243 .of_match_table = ti_adc_dt_ids, 244 }, 245 .probe = ti_adc_probe, 246 .id_table = ti_adc_id, 247 }; 248 module_spi_driver(ti_adc_driver); 249 250 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>"); 251 MODULE_DESCRIPTION("Texas Instruments ADC1x1S 1-channel differential ADC"); 252 MODULE_LICENSE("GPL"); 253