1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Texas Instruments ADS7950 SPI ADC driver 4 * 5 * Copyright 2016 David Lechner <david@lechnology.com> 6 * 7 * Based on iio/ad7923.c: 8 * Copyright 2011 Analog Devices Inc 9 * Copyright 2012 CS Systemes d'Information 10 * 11 * And also on hwmon/ads79xx.c 12 * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/ 13 * Nishanth Menon 14 */ 15 16 #include <linux/acpi.h> 17 #include <linux/bitops.h> 18 #include <linux/device.h> 19 #include <linux/err.h> 20 #include <linux/interrupt.h> 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/regulator/consumer.h> 24 #include <linux/slab.h> 25 #include <linux/spi/spi.h> 26 27 #include <linux/iio/buffer.h> 28 #include <linux/iio/iio.h> 29 #include <linux/iio/sysfs.h> 30 #include <linux/iio/trigger_consumer.h> 31 #include <linux/iio/triggered_buffer.h> 32 33 /* 34 * In case of ACPI, we use the 5000 mV as default for the reference pin. 35 * Device tree users encode that via the vref-supply regulator. 36 */ 37 #define TI_ADS7950_VA_MV_ACPI_DEFAULT 5000 38 39 #define TI_ADS7950_CR_MANUAL BIT(12) 40 #define TI_ADS7950_CR_WRITE BIT(11) 41 #define TI_ADS7950_CR_CHAN(ch) ((ch) << 7) 42 #define TI_ADS7950_CR_RANGE_5V BIT(6) 43 44 #define TI_ADS7950_MAX_CHAN 16 45 46 #define TI_ADS7950_TIMESTAMP_SIZE (sizeof(int64_t) / sizeof(__be16)) 47 48 /* val = value, dec = left shift, bits = number of bits of the mask */ 49 #define TI_ADS7950_EXTRACT(val, dec, bits) \ 50 (((val) >> (dec)) & ((1 << (bits)) - 1)) 51 52 struct ti_ads7950_state { 53 struct spi_device *spi; 54 struct spi_transfer ring_xfer; 55 struct spi_transfer scan_single_xfer[3]; 56 struct spi_message ring_msg; 57 struct spi_message scan_single_msg; 58 59 struct regulator *reg; 60 unsigned int vref_mv; 61 62 unsigned int settings; 63 64 /* 65 * DMA (thus cache coherency maintenance) requires the 66 * transfer buffers to live in their own cache lines. 67 */ 68 u16 rx_buf[TI_ADS7950_MAX_CHAN + 2 + TI_ADS7950_TIMESTAMP_SIZE] 69 ____cacheline_aligned; 70 u16 tx_buf[TI_ADS7950_MAX_CHAN + 2]; 71 u16 single_tx; 72 u16 single_rx; 73 74 }; 75 76 struct ti_ads7950_chip_info { 77 const struct iio_chan_spec *channels; 78 unsigned int num_channels; 79 }; 80 81 enum ti_ads7950_id { 82 TI_ADS7950, 83 TI_ADS7951, 84 TI_ADS7952, 85 TI_ADS7953, 86 TI_ADS7954, 87 TI_ADS7955, 88 TI_ADS7956, 89 TI_ADS7957, 90 TI_ADS7958, 91 TI_ADS7959, 92 TI_ADS7960, 93 TI_ADS7961, 94 }; 95 96 #define TI_ADS7950_V_CHAN(index, bits) \ 97 { \ 98 .type = IIO_VOLTAGE, \ 99 .indexed = 1, \ 100 .channel = index, \ 101 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 102 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 103 .address = index, \ 104 .datasheet_name = "CH##index", \ 105 .scan_index = index, \ 106 .scan_type = { \ 107 .sign = 'u', \ 108 .realbits = bits, \ 109 .storagebits = 16, \ 110 .shift = 12 - (bits), \ 111 .endianness = IIO_CPU, \ 112 }, \ 113 } 114 115 #define DECLARE_TI_ADS7950_4_CHANNELS(name, bits) \ 116 const struct iio_chan_spec name ## _channels[] = { \ 117 TI_ADS7950_V_CHAN(0, bits), \ 118 TI_ADS7950_V_CHAN(1, bits), \ 119 TI_ADS7950_V_CHAN(2, bits), \ 120 TI_ADS7950_V_CHAN(3, bits), \ 121 IIO_CHAN_SOFT_TIMESTAMP(4), \ 122 } 123 124 #define DECLARE_TI_ADS7950_8_CHANNELS(name, bits) \ 125 const struct iio_chan_spec name ## _channels[] = { \ 126 TI_ADS7950_V_CHAN(0, bits), \ 127 TI_ADS7950_V_CHAN(1, bits), \ 128 TI_ADS7950_V_CHAN(2, bits), \ 129 TI_ADS7950_V_CHAN(3, bits), \ 130 TI_ADS7950_V_CHAN(4, bits), \ 131 TI_ADS7950_V_CHAN(5, bits), \ 132 TI_ADS7950_V_CHAN(6, bits), \ 133 TI_ADS7950_V_CHAN(7, bits), \ 134 IIO_CHAN_SOFT_TIMESTAMP(8), \ 135 } 136 137 #define DECLARE_TI_ADS7950_12_CHANNELS(name, bits) \ 138 const struct iio_chan_spec name ## _channels[] = { \ 139 TI_ADS7950_V_CHAN(0, bits), \ 140 TI_ADS7950_V_CHAN(1, bits), \ 141 TI_ADS7950_V_CHAN(2, bits), \ 142 TI_ADS7950_V_CHAN(3, bits), \ 143 TI_ADS7950_V_CHAN(4, bits), \ 144 TI_ADS7950_V_CHAN(5, bits), \ 145 TI_ADS7950_V_CHAN(6, bits), \ 146 TI_ADS7950_V_CHAN(7, bits), \ 147 TI_ADS7950_V_CHAN(8, bits), \ 148 TI_ADS7950_V_CHAN(9, bits), \ 149 TI_ADS7950_V_CHAN(10, bits), \ 150 TI_ADS7950_V_CHAN(11, bits), \ 151 IIO_CHAN_SOFT_TIMESTAMP(12), \ 152 } 153 154 #define DECLARE_TI_ADS7950_16_CHANNELS(name, bits) \ 155 const struct iio_chan_spec name ## _channels[] = { \ 156 TI_ADS7950_V_CHAN(0, bits), \ 157 TI_ADS7950_V_CHAN(1, bits), \ 158 TI_ADS7950_V_CHAN(2, bits), \ 159 TI_ADS7950_V_CHAN(3, bits), \ 160 TI_ADS7950_V_CHAN(4, bits), \ 161 TI_ADS7950_V_CHAN(5, bits), \ 162 TI_ADS7950_V_CHAN(6, bits), \ 163 TI_ADS7950_V_CHAN(7, bits), \ 164 TI_ADS7950_V_CHAN(8, bits), \ 165 TI_ADS7950_V_CHAN(9, bits), \ 166 TI_ADS7950_V_CHAN(10, bits), \ 167 TI_ADS7950_V_CHAN(11, bits), \ 168 TI_ADS7950_V_CHAN(12, bits), \ 169 TI_ADS7950_V_CHAN(13, bits), \ 170 TI_ADS7950_V_CHAN(14, bits), \ 171 TI_ADS7950_V_CHAN(15, bits), \ 172 IIO_CHAN_SOFT_TIMESTAMP(16), \ 173 } 174 175 static DECLARE_TI_ADS7950_4_CHANNELS(ti_ads7950, 12); 176 static DECLARE_TI_ADS7950_8_CHANNELS(ti_ads7951, 12); 177 static DECLARE_TI_ADS7950_12_CHANNELS(ti_ads7952, 12); 178 static DECLARE_TI_ADS7950_16_CHANNELS(ti_ads7953, 12); 179 static DECLARE_TI_ADS7950_4_CHANNELS(ti_ads7954, 10); 180 static DECLARE_TI_ADS7950_8_CHANNELS(ti_ads7955, 10); 181 static DECLARE_TI_ADS7950_12_CHANNELS(ti_ads7956, 10); 182 static DECLARE_TI_ADS7950_16_CHANNELS(ti_ads7957, 10); 183 static DECLARE_TI_ADS7950_4_CHANNELS(ti_ads7958, 8); 184 static DECLARE_TI_ADS7950_8_CHANNELS(ti_ads7959, 8); 185 static DECLARE_TI_ADS7950_12_CHANNELS(ti_ads7960, 8); 186 static DECLARE_TI_ADS7950_16_CHANNELS(ti_ads7961, 8); 187 188 static const struct ti_ads7950_chip_info ti_ads7950_chip_info[] = { 189 [TI_ADS7950] = { 190 .channels = ti_ads7950_channels, 191 .num_channels = ARRAY_SIZE(ti_ads7950_channels), 192 }, 193 [TI_ADS7951] = { 194 .channels = ti_ads7951_channels, 195 .num_channels = ARRAY_SIZE(ti_ads7951_channels), 196 }, 197 [TI_ADS7952] = { 198 .channels = ti_ads7952_channels, 199 .num_channels = ARRAY_SIZE(ti_ads7952_channels), 200 }, 201 [TI_ADS7953] = { 202 .channels = ti_ads7953_channels, 203 .num_channels = ARRAY_SIZE(ti_ads7953_channels), 204 }, 205 [TI_ADS7954] = { 206 .channels = ti_ads7954_channels, 207 .num_channels = ARRAY_SIZE(ti_ads7954_channels), 208 }, 209 [TI_ADS7955] = { 210 .channels = ti_ads7955_channels, 211 .num_channels = ARRAY_SIZE(ti_ads7955_channels), 212 }, 213 [TI_ADS7956] = { 214 .channels = ti_ads7956_channels, 215 .num_channels = ARRAY_SIZE(ti_ads7956_channels), 216 }, 217 [TI_ADS7957] = { 218 .channels = ti_ads7957_channels, 219 .num_channels = ARRAY_SIZE(ti_ads7957_channels), 220 }, 221 [TI_ADS7958] = { 222 .channels = ti_ads7958_channels, 223 .num_channels = ARRAY_SIZE(ti_ads7958_channels), 224 }, 225 [TI_ADS7959] = { 226 .channels = ti_ads7959_channels, 227 .num_channels = ARRAY_SIZE(ti_ads7959_channels), 228 }, 229 [TI_ADS7960] = { 230 .channels = ti_ads7960_channels, 231 .num_channels = ARRAY_SIZE(ti_ads7960_channels), 232 }, 233 [TI_ADS7961] = { 234 .channels = ti_ads7961_channels, 235 .num_channels = ARRAY_SIZE(ti_ads7961_channels), 236 }, 237 }; 238 239 /* 240 * ti_ads7950_update_scan_mode() setup the spi transfer buffer for the new 241 * scan mask 242 */ 243 static int ti_ads7950_update_scan_mode(struct iio_dev *indio_dev, 244 const unsigned long *active_scan_mask) 245 { 246 struct ti_ads7950_state *st = iio_priv(indio_dev); 247 int i, cmd, len; 248 249 len = 0; 250 for_each_set_bit(i, active_scan_mask, indio_dev->num_channels) { 251 cmd = TI_ADS7950_CR_WRITE | TI_ADS7950_CR_CHAN(i) | st->settings; 252 st->tx_buf[len++] = cmd; 253 } 254 255 /* Data for the 1st channel is not returned until the 3rd transfer */ 256 st->tx_buf[len++] = 0; 257 st->tx_buf[len++] = 0; 258 259 st->ring_xfer.len = len * 2; 260 261 return 0; 262 } 263 264 static irqreturn_t ti_ads7950_trigger_handler(int irq, void *p) 265 { 266 struct iio_poll_func *pf = p; 267 struct iio_dev *indio_dev = pf->indio_dev; 268 struct ti_ads7950_state *st = iio_priv(indio_dev); 269 int ret; 270 271 ret = spi_sync(st->spi, &st->ring_msg); 272 if (ret < 0) 273 goto out; 274 275 iio_push_to_buffers_with_timestamp(indio_dev, &st->rx_buf[2], 276 iio_get_time_ns(indio_dev)); 277 278 out: 279 iio_trigger_notify_done(indio_dev->trig); 280 281 return IRQ_HANDLED; 282 } 283 284 static int ti_ads7950_scan_direct(struct iio_dev *indio_dev, unsigned int ch) 285 { 286 struct ti_ads7950_state *st = iio_priv(indio_dev); 287 int ret, cmd; 288 289 mutex_lock(&indio_dev->mlock); 290 291 cmd = TI_ADS7950_CR_WRITE | TI_ADS7950_CR_CHAN(ch) | st->settings; 292 st->single_tx = cmd; 293 294 ret = spi_sync(st->spi, &st->scan_single_msg); 295 if (ret) 296 goto out; 297 298 ret = st->single_rx; 299 300 out: 301 mutex_unlock(&indio_dev->mlock); 302 303 return ret; 304 } 305 306 static int ti_ads7950_get_range(struct ti_ads7950_state *st) 307 { 308 int vref; 309 310 if (st->vref_mv) { 311 vref = st->vref_mv; 312 } else { 313 vref = regulator_get_voltage(st->reg); 314 if (vref < 0) 315 return vref; 316 317 vref /= 1000; 318 } 319 320 if (st->settings & TI_ADS7950_CR_RANGE_5V) 321 vref *= 2; 322 323 return vref; 324 } 325 326 static int ti_ads7950_read_raw(struct iio_dev *indio_dev, 327 struct iio_chan_spec const *chan, 328 int *val, int *val2, long m) 329 { 330 struct ti_ads7950_state *st = iio_priv(indio_dev); 331 int ret; 332 333 switch (m) { 334 case IIO_CHAN_INFO_RAW: 335 ret = ti_ads7950_scan_direct(indio_dev, chan->address); 336 if (ret < 0) 337 return ret; 338 339 if (chan->address != TI_ADS7950_EXTRACT(ret, 12, 4)) 340 return -EIO; 341 342 *val = TI_ADS7950_EXTRACT(ret, chan->scan_type.shift, 343 chan->scan_type.realbits); 344 345 return IIO_VAL_INT; 346 case IIO_CHAN_INFO_SCALE: 347 ret = ti_ads7950_get_range(st); 348 if (ret < 0) 349 return ret; 350 351 *val = ret; 352 *val2 = (1 << chan->scan_type.realbits) - 1; 353 354 return IIO_VAL_FRACTIONAL; 355 } 356 357 return -EINVAL; 358 } 359 360 static const struct iio_info ti_ads7950_info = { 361 .read_raw = &ti_ads7950_read_raw, 362 .update_scan_mode = ti_ads7950_update_scan_mode, 363 }; 364 365 static int ti_ads7950_probe(struct spi_device *spi) 366 { 367 struct ti_ads7950_state *st; 368 struct iio_dev *indio_dev; 369 const struct ti_ads7950_chip_info *info; 370 int ret; 371 372 spi->bits_per_word = 16; 373 spi->mode |= SPI_CS_WORD; 374 ret = spi_setup(spi); 375 if (ret < 0) { 376 dev_err(&spi->dev, "Error in spi setup\n"); 377 return ret; 378 } 379 380 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); 381 if (!indio_dev) 382 return -ENOMEM; 383 384 st = iio_priv(indio_dev); 385 386 spi_set_drvdata(spi, indio_dev); 387 388 st->spi = spi; 389 st->settings = TI_ADS7950_CR_MANUAL | TI_ADS7950_CR_RANGE_5V; 390 391 info = &ti_ads7950_chip_info[spi_get_device_id(spi)->driver_data]; 392 393 indio_dev->name = spi_get_device_id(spi)->name; 394 indio_dev->dev.parent = &spi->dev; 395 indio_dev->modes = INDIO_DIRECT_MODE; 396 indio_dev->channels = info->channels; 397 indio_dev->num_channels = info->num_channels; 398 indio_dev->info = &ti_ads7950_info; 399 400 /* build spi ring message */ 401 spi_message_init(&st->ring_msg); 402 403 st->ring_xfer.tx_buf = &st->tx_buf[0]; 404 st->ring_xfer.rx_buf = &st->rx_buf[0]; 405 /* len will be set later */ 406 st->ring_xfer.cs_change = true; 407 408 spi_message_add_tail(&st->ring_xfer, &st->ring_msg); 409 410 /* 411 * Setup default message. The sample is read at the end of the first 412 * transfer, then it takes one full cycle to convert the sample and one 413 * more cycle to send the value. The conversion process is driven by 414 * the SPI clock, which is why we have 3 transfers. The middle one is 415 * just dummy data sent while the chip is converting the sample that 416 * was read at the end of the first transfer. 417 */ 418 419 st->scan_single_xfer[0].tx_buf = &st->single_tx; 420 st->scan_single_xfer[0].len = 2; 421 st->scan_single_xfer[0].cs_change = 1; 422 st->scan_single_xfer[1].tx_buf = &st->single_tx; 423 st->scan_single_xfer[1].len = 2; 424 st->scan_single_xfer[1].cs_change = 1; 425 st->scan_single_xfer[2].rx_buf = &st->single_rx; 426 st->scan_single_xfer[2].len = 2; 427 428 spi_message_init_with_transfers(&st->scan_single_msg, 429 st->scan_single_xfer, 3); 430 431 /* Use hard coded value for reference voltage in ACPI case */ 432 if (ACPI_COMPANION(&spi->dev)) 433 st->vref_mv = TI_ADS7950_VA_MV_ACPI_DEFAULT; 434 435 st->reg = devm_regulator_get(&spi->dev, "vref"); 436 if (IS_ERR(st->reg)) { 437 dev_err(&spi->dev, "Failed get get regulator \"vref\"\n"); 438 return PTR_ERR(st->reg); 439 } 440 441 ret = regulator_enable(st->reg); 442 if (ret) { 443 dev_err(&spi->dev, "Failed to enable regulator \"vref\"\n"); 444 return ret; 445 } 446 447 ret = iio_triggered_buffer_setup(indio_dev, NULL, 448 &ti_ads7950_trigger_handler, NULL); 449 if (ret) { 450 dev_err(&spi->dev, "Failed to setup triggered buffer\n"); 451 goto error_disable_reg; 452 } 453 454 ret = iio_device_register(indio_dev); 455 if (ret) { 456 dev_err(&spi->dev, "Failed to register iio device\n"); 457 goto error_cleanup_ring; 458 } 459 460 return 0; 461 462 error_cleanup_ring: 463 iio_triggered_buffer_cleanup(indio_dev); 464 error_disable_reg: 465 regulator_disable(st->reg); 466 467 return ret; 468 } 469 470 static int ti_ads7950_remove(struct spi_device *spi) 471 { 472 struct iio_dev *indio_dev = spi_get_drvdata(spi); 473 struct ti_ads7950_state *st = iio_priv(indio_dev); 474 475 iio_device_unregister(indio_dev); 476 iio_triggered_buffer_cleanup(indio_dev); 477 regulator_disable(st->reg); 478 479 return 0; 480 } 481 482 static const struct spi_device_id ti_ads7950_id[] = { 483 { "ads7950", TI_ADS7950 }, 484 { "ads7951", TI_ADS7951 }, 485 { "ads7952", TI_ADS7952 }, 486 { "ads7953", TI_ADS7953 }, 487 { "ads7954", TI_ADS7954 }, 488 { "ads7955", TI_ADS7955 }, 489 { "ads7956", TI_ADS7956 }, 490 { "ads7957", TI_ADS7957 }, 491 { "ads7958", TI_ADS7958 }, 492 { "ads7959", TI_ADS7959 }, 493 { "ads7960", TI_ADS7960 }, 494 { "ads7961", TI_ADS7961 }, 495 { } 496 }; 497 MODULE_DEVICE_TABLE(spi, ti_ads7950_id); 498 499 static const struct of_device_id ads7950_of_table[] = { 500 { .compatible = "ti,ads7950", .data = &ti_ads7950_chip_info[TI_ADS7950] }, 501 { .compatible = "ti,ads7951", .data = &ti_ads7950_chip_info[TI_ADS7951] }, 502 { .compatible = "ti,ads7952", .data = &ti_ads7950_chip_info[TI_ADS7952] }, 503 { .compatible = "ti,ads7953", .data = &ti_ads7950_chip_info[TI_ADS7953] }, 504 { .compatible = "ti,ads7954", .data = &ti_ads7950_chip_info[TI_ADS7954] }, 505 { .compatible = "ti,ads7955", .data = &ti_ads7950_chip_info[TI_ADS7955] }, 506 { .compatible = "ti,ads7956", .data = &ti_ads7950_chip_info[TI_ADS7956] }, 507 { .compatible = "ti,ads7957", .data = &ti_ads7950_chip_info[TI_ADS7957] }, 508 { .compatible = "ti,ads7958", .data = &ti_ads7950_chip_info[TI_ADS7958] }, 509 { .compatible = "ti,ads7959", .data = &ti_ads7950_chip_info[TI_ADS7959] }, 510 { .compatible = "ti,ads7960", .data = &ti_ads7950_chip_info[TI_ADS7960] }, 511 { .compatible = "ti,ads7961", .data = &ti_ads7950_chip_info[TI_ADS7961] }, 512 { }, 513 }; 514 MODULE_DEVICE_TABLE(of, ads7950_of_table); 515 516 static struct spi_driver ti_ads7950_driver = { 517 .driver = { 518 .name = "ads7950", 519 .of_match_table = ads7950_of_table, 520 }, 521 .probe = ti_ads7950_probe, 522 .remove = ti_ads7950_remove, 523 .id_table = ti_ads7950_id, 524 }; 525 module_spi_driver(ti_ads7950_driver); 526 527 MODULE_AUTHOR("David Lechner <david@lechnology.com>"); 528 MODULE_DESCRIPTION("TI TI_ADS7950 ADC"); 529 MODULE_LICENSE("GPL v2"); 530