1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * iio/adc/max1027.c 4 * Copyright (C) 2014 Philippe Reynes 5 * 6 * based on linux/drivers/iio/ad7923.c 7 * Copyright 2011 Analog Devices Inc (from AD7923 Driver) 8 * Copyright 2012 CS Systemes d'Information 9 * 10 * max1027.c 11 * 12 * Partial support for max1027 and similar chips. 13 */ 14 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/mod_devicetable.h> 18 #include <linux/spi/spi.h> 19 #include <linux/delay.h> 20 21 #include <linux/iio/iio.h> 22 #include <linux/iio/buffer.h> 23 #include <linux/iio/trigger.h> 24 #include <linux/iio/trigger_consumer.h> 25 #include <linux/iio/triggered_buffer.h> 26 27 #define MAX1027_CONV_REG BIT(7) 28 #define MAX1027_SETUP_REG BIT(6) 29 #define MAX1027_AVG_REG BIT(5) 30 #define MAX1027_RST_REG BIT(4) 31 32 /* conversion register */ 33 #define MAX1027_TEMP BIT(0) 34 #define MAX1027_SCAN_0_N (0x00 << 1) 35 #define MAX1027_SCAN_N_M (0x01 << 1) 36 #define MAX1027_SCAN_N (0x02 << 1) 37 #define MAX1027_NOSCAN (0x03 << 1) 38 #define MAX1027_CHAN(n) ((n) << 3) 39 40 /* setup register */ 41 #define MAX1027_UNIPOLAR 0x02 42 #define MAX1027_BIPOLAR 0x03 43 #define MAX1027_REF_MODE0 (0x00 << 2) 44 #define MAX1027_REF_MODE1 (0x01 << 2) 45 #define MAX1027_REF_MODE2 (0x02 << 2) 46 #define MAX1027_REF_MODE3 (0x03 << 2) 47 #define MAX1027_CKS_MODE0 (0x00 << 4) 48 #define MAX1027_CKS_MODE1 (0x01 << 4) 49 #define MAX1027_CKS_MODE2 (0x02 << 4) 50 #define MAX1027_CKS_MODE3 (0x03 << 4) 51 52 /* averaging register */ 53 #define MAX1027_NSCAN_4 0x00 54 #define MAX1027_NSCAN_8 0x01 55 #define MAX1027_NSCAN_12 0x02 56 #define MAX1027_NSCAN_16 0x03 57 #define MAX1027_NAVG_4 (0x00 << 2) 58 #define MAX1027_NAVG_8 (0x01 << 2) 59 #define MAX1027_NAVG_16 (0x02 << 2) 60 #define MAX1027_NAVG_32 (0x03 << 2) 61 #define MAX1027_AVG_EN BIT(4) 62 63 enum max1027_id { 64 max1027, 65 max1029, 66 max1031, 67 max1227, 68 max1229, 69 max1231, 70 }; 71 72 static const struct spi_device_id max1027_id[] = { 73 {"max1027", max1027}, 74 {"max1029", max1029}, 75 {"max1031", max1031}, 76 {"max1227", max1227}, 77 {"max1229", max1229}, 78 {"max1231", max1231}, 79 {} 80 }; 81 MODULE_DEVICE_TABLE(spi, max1027_id); 82 83 static const struct of_device_id max1027_adc_dt_ids[] = { 84 { .compatible = "maxim,max1027" }, 85 { .compatible = "maxim,max1029" }, 86 { .compatible = "maxim,max1031" }, 87 { .compatible = "maxim,max1227" }, 88 { .compatible = "maxim,max1229" }, 89 { .compatible = "maxim,max1231" }, 90 {}, 91 }; 92 MODULE_DEVICE_TABLE(of, max1027_adc_dt_ids); 93 94 #define MAX1027_V_CHAN(index, depth) \ 95 { \ 96 .type = IIO_VOLTAGE, \ 97 .indexed = 1, \ 98 .channel = index, \ 99 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 100 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 101 .scan_index = index + 1, \ 102 .scan_type = { \ 103 .sign = 'u', \ 104 .realbits = depth, \ 105 .storagebits = 16, \ 106 .shift = 2, \ 107 .endianness = IIO_BE, \ 108 }, \ 109 } 110 111 #define MAX1027_T_CHAN \ 112 { \ 113 .type = IIO_TEMP, \ 114 .channel = 0, \ 115 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 116 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 117 .scan_index = 0, \ 118 .scan_type = { \ 119 .sign = 'u', \ 120 .realbits = 12, \ 121 .storagebits = 16, \ 122 .endianness = IIO_BE, \ 123 }, \ 124 } 125 126 #define MAX1X27_CHANNELS(depth) \ 127 MAX1027_T_CHAN, \ 128 MAX1027_V_CHAN(0, depth), \ 129 MAX1027_V_CHAN(1, depth), \ 130 MAX1027_V_CHAN(2, depth), \ 131 MAX1027_V_CHAN(3, depth), \ 132 MAX1027_V_CHAN(4, depth), \ 133 MAX1027_V_CHAN(5, depth), \ 134 MAX1027_V_CHAN(6, depth), \ 135 MAX1027_V_CHAN(7, depth) 136 137 #define MAX1X29_CHANNELS(depth) \ 138 MAX1X27_CHANNELS(depth), \ 139 MAX1027_V_CHAN(8, depth), \ 140 MAX1027_V_CHAN(9, depth), \ 141 MAX1027_V_CHAN(10, depth), \ 142 MAX1027_V_CHAN(11, depth) 143 144 #define MAX1X31_CHANNELS(depth) \ 145 MAX1X27_CHANNELS(depth), \ 146 MAX1X29_CHANNELS(depth), \ 147 MAX1027_V_CHAN(12, depth), \ 148 MAX1027_V_CHAN(13, depth), \ 149 MAX1027_V_CHAN(14, depth), \ 150 MAX1027_V_CHAN(15, depth) 151 152 static const struct iio_chan_spec max1027_channels[] = { 153 MAX1X27_CHANNELS(10), 154 }; 155 156 static const struct iio_chan_spec max1029_channels[] = { 157 MAX1X29_CHANNELS(10), 158 }; 159 160 static const struct iio_chan_spec max1031_channels[] = { 161 MAX1X31_CHANNELS(10), 162 }; 163 164 static const struct iio_chan_spec max1227_channels[] = { 165 MAX1X27_CHANNELS(12), 166 }; 167 168 static const struct iio_chan_spec max1229_channels[] = { 169 MAX1X29_CHANNELS(12), 170 }; 171 172 static const struct iio_chan_spec max1231_channels[] = { 173 MAX1X31_CHANNELS(12), 174 }; 175 176 static const unsigned long max1027_available_scan_masks[] = { 177 0x000001ff, 178 0x00000000, 179 }; 180 181 static const unsigned long max1029_available_scan_masks[] = { 182 0x00001fff, 183 0x00000000, 184 }; 185 186 static const unsigned long max1031_available_scan_masks[] = { 187 0x0001ffff, 188 0x00000000, 189 }; 190 191 struct max1027_chip_info { 192 const struct iio_chan_spec *channels; 193 unsigned int num_channels; 194 const unsigned long *available_scan_masks; 195 }; 196 197 static const struct max1027_chip_info max1027_chip_info_tbl[] = { 198 [max1027] = { 199 .channels = max1027_channels, 200 .num_channels = ARRAY_SIZE(max1027_channels), 201 .available_scan_masks = max1027_available_scan_masks, 202 }, 203 [max1029] = { 204 .channels = max1029_channels, 205 .num_channels = ARRAY_SIZE(max1029_channels), 206 .available_scan_masks = max1029_available_scan_masks, 207 }, 208 [max1031] = { 209 .channels = max1031_channels, 210 .num_channels = ARRAY_SIZE(max1031_channels), 211 .available_scan_masks = max1031_available_scan_masks, 212 }, 213 [max1227] = { 214 .channels = max1227_channels, 215 .num_channels = ARRAY_SIZE(max1227_channels), 216 .available_scan_masks = max1027_available_scan_masks, 217 }, 218 [max1229] = { 219 .channels = max1229_channels, 220 .num_channels = ARRAY_SIZE(max1229_channels), 221 .available_scan_masks = max1029_available_scan_masks, 222 }, 223 [max1231] = { 224 .channels = max1231_channels, 225 .num_channels = ARRAY_SIZE(max1231_channels), 226 .available_scan_masks = max1031_available_scan_masks, 227 }, 228 }; 229 230 struct max1027_state { 231 const struct max1027_chip_info *info; 232 struct spi_device *spi; 233 struct iio_trigger *trig; 234 __be16 *buffer; 235 struct mutex lock; 236 237 u8 reg ____cacheline_aligned; 238 }; 239 240 static int max1027_read_single_value(struct iio_dev *indio_dev, 241 struct iio_chan_spec const *chan, 242 int *val) 243 { 244 int ret; 245 struct max1027_state *st = iio_priv(indio_dev); 246 247 if (iio_buffer_enabled(indio_dev)) { 248 dev_warn(&indio_dev->dev, "trigger mode already enabled"); 249 return -EBUSY; 250 } 251 252 /* Start acquisition on conversion register write */ 253 st->reg = MAX1027_SETUP_REG | MAX1027_REF_MODE2 | MAX1027_CKS_MODE2; 254 ret = spi_write(st->spi, &st->reg, 1); 255 if (ret < 0) { 256 dev_err(&indio_dev->dev, 257 "Failed to configure setup register\n"); 258 return ret; 259 } 260 261 /* Configure conversion register with the requested chan */ 262 st->reg = MAX1027_CONV_REG | MAX1027_CHAN(chan->channel) | 263 MAX1027_NOSCAN; 264 if (chan->type == IIO_TEMP) 265 st->reg |= MAX1027_TEMP; 266 ret = spi_write(st->spi, &st->reg, 1); 267 if (ret < 0) { 268 dev_err(&indio_dev->dev, 269 "Failed to configure conversion register\n"); 270 return ret; 271 } 272 273 /* 274 * For an unknown reason, when we use the mode "10" (write 275 * conversion register), the interrupt doesn't occur every time. 276 * So we just wait 1 ms. 277 */ 278 mdelay(1); 279 280 /* Read result */ 281 ret = spi_read(st->spi, st->buffer, (chan->type == IIO_TEMP) ? 4 : 2); 282 if (ret < 0) 283 return ret; 284 285 *val = be16_to_cpu(st->buffer[0]); 286 287 return IIO_VAL_INT; 288 } 289 290 static int max1027_read_raw(struct iio_dev *indio_dev, 291 struct iio_chan_spec const *chan, 292 int *val, int *val2, long mask) 293 { 294 int ret = 0; 295 struct max1027_state *st = iio_priv(indio_dev); 296 297 mutex_lock(&st->lock); 298 299 switch (mask) { 300 case IIO_CHAN_INFO_RAW: 301 ret = max1027_read_single_value(indio_dev, chan, val); 302 break; 303 case IIO_CHAN_INFO_SCALE: 304 switch (chan->type) { 305 case IIO_TEMP: 306 *val = 1; 307 *val2 = 8; 308 ret = IIO_VAL_FRACTIONAL; 309 break; 310 case IIO_VOLTAGE: 311 *val = 2500; 312 *val2 = chan->scan_type.realbits; 313 ret = IIO_VAL_FRACTIONAL_LOG2; 314 break; 315 default: 316 ret = -EINVAL; 317 break; 318 } 319 break; 320 default: 321 ret = -EINVAL; 322 break; 323 } 324 325 mutex_unlock(&st->lock); 326 327 return ret; 328 } 329 330 static int max1027_debugfs_reg_access(struct iio_dev *indio_dev, 331 unsigned reg, unsigned writeval, 332 unsigned *readval) 333 { 334 struct max1027_state *st = iio_priv(indio_dev); 335 u8 *val = (u8 *)st->buffer; 336 337 if (readval) { 338 int ret = spi_read(st->spi, val, 2); 339 *readval = be16_to_cpu(st->buffer[0]); 340 return ret; 341 } 342 343 *val = (u8)writeval; 344 return spi_write(st->spi, val, 1); 345 } 346 347 static int max1027_validate_trigger(struct iio_dev *indio_dev, 348 struct iio_trigger *trig) 349 { 350 struct max1027_state *st = iio_priv(indio_dev); 351 352 if (st->trig != trig) 353 return -EINVAL; 354 355 return 0; 356 } 357 358 static int max1027_set_trigger_state(struct iio_trigger *trig, bool state) 359 { 360 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 361 struct max1027_state *st = iio_priv(indio_dev); 362 int ret; 363 364 if (state) { 365 /* Start acquisition on cnvst */ 366 st->reg = MAX1027_SETUP_REG | MAX1027_CKS_MODE0 | 367 MAX1027_REF_MODE2; 368 ret = spi_write(st->spi, &st->reg, 1); 369 if (ret < 0) 370 return ret; 371 372 /* Scan from 0 to max */ 373 st->reg = MAX1027_CONV_REG | MAX1027_CHAN(0) | 374 MAX1027_SCAN_N_M | MAX1027_TEMP; 375 ret = spi_write(st->spi, &st->reg, 1); 376 if (ret < 0) 377 return ret; 378 } else { 379 /* Start acquisition on conversion register write */ 380 st->reg = MAX1027_SETUP_REG | MAX1027_CKS_MODE2 | 381 MAX1027_REF_MODE2; 382 ret = spi_write(st->spi, &st->reg, 1); 383 if (ret < 0) 384 return ret; 385 } 386 387 return 0; 388 } 389 390 static irqreturn_t max1027_trigger_handler(int irq, void *private) 391 { 392 struct iio_poll_func *pf = private; 393 struct iio_dev *indio_dev = pf->indio_dev; 394 struct max1027_state *st = iio_priv(indio_dev); 395 396 pr_debug("%s(irq=%d, private=0x%p)\n", __func__, irq, private); 397 398 /* fill buffer with all channel */ 399 spi_read(st->spi, st->buffer, indio_dev->masklength * 2); 400 401 iio_push_to_buffers(indio_dev, st->buffer); 402 403 iio_trigger_notify_done(indio_dev->trig); 404 405 return IRQ_HANDLED; 406 } 407 408 static const struct iio_trigger_ops max1027_trigger_ops = { 409 .validate_device = &iio_trigger_validate_own_device, 410 .set_trigger_state = &max1027_set_trigger_state, 411 }; 412 413 static const struct iio_info max1027_info = { 414 .read_raw = &max1027_read_raw, 415 .validate_trigger = &max1027_validate_trigger, 416 .debugfs_reg_access = &max1027_debugfs_reg_access, 417 }; 418 419 static int max1027_probe(struct spi_device *spi) 420 { 421 int ret; 422 struct iio_dev *indio_dev; 423 struct max1027_state *st; 424 425 pr_debug("%s: probe(spi = 0x%p)\n", __func__, spi); 426 427 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); 428 if (indio_dev == NULL) { 429 pr_err("Can't allocate iio device\n"); 430 return -ENOMEM; 431 } 432 433 st = iio_priv(indio_dev); 434 st->spi = spi; 435 st->info = &max1027_chip_info_tbl[spi_get_device_id(spi)->driver_data]; 436 437 mutex_init(&st->lock); 438 439 indio_dev->name = spi_get_device_id(spi)->name; 440 indio_dev->info = &max1027_info; 441 indio_dev->modes = INDIO_DIRECT_MODE; 442 indio_dev->channels = st->info->channels; 443 indio_dev->num_channels = st->info->num_channels; 444 indio_dev->available_scan_masks = st->info->available_scan_masks; 445 446 st->buffer = devm_kmalloc_array(&indio_dev->dev, 447 indio_dev->num_channels, 2, 448 GFP_KERNEL); 449 if (st->buffer == NULL) { 450 dev_err(&indio_dev->dev, "Can't allocate buffer\n"); 451 return -ENOMEM; 452 } 453 454 if (spi->irq) { 455 ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, 456 &iio_pollfunc_store_time, 457 &max1027_trigger_handler, 458 NULL); 459 if (ret < 0) { 460 dev_err(&indio_dev->dev, "Failed to setup buffer\n"); 461 return ret; 462 } 463 464 st->trig = devm_iio_trigger_alloc(&spi->dev, "%s-trigger", 465 indio_dev->name); 466 if (st->trig == NULL) { 467 ret = -ENOMEM; 468 dev_err(&indio_dev->dev, 469 "Failed to allocate iio trigger\n"); 470 return ret; 471 } 472 473 st->trig->ops = &max1027_trigger_ops; 474 iio_trigger_set_drvdata(st->trig, indio_dev); 475 ret = devm_iio_trigger_register(&indio_dev->dev, 476 st->trig); 477 if (ret < 0) { 478 dev_err(&indio_dev->dev, 479 "Failed to register iio trigger\n"); 480 return ret; 481 } 482 483 ret = devm_request_threaded_irq(&spi->dev, spi->irq, 484 iio_trigger_generic_data_rdy_poll, 485 NULL, 486 IRQF_TRIGGER_FALLING, 487 spi->dev.driver->name, 488 st->trig); 489 if (ret < 0) { 490 dev_err(&indio_dev->dev, "Failed to allocate IRQ.\n"); 491 return ret; 492 } 493 } 494 495 /* Internal reset */ 496 st->reg = MAX1027_RST_REG; 497 ret = spi_write(st->spi, &st->reg, 1); 498 if (ret < 0) { 499 dev_err(&indio_dev->dev, "Failed to reset the ADC\n"); 500 return ret; 501 } 502 503 /* Disable averaging */ 504 st->reg = MAX1027_AVG_REG; 505 ret = spi_write(st->spi, &st->reg, 1); 506 if (ret < 0) { 507 dev_err(&indio_dev->dev, "Failed to configure averaging register\n"); 508 return ret; 509 } 510 511 return devm_iio_device_register(&spi->dev, indio_dev); 512 } 513 514 static struct spi_driver max1027_driver = { 515 .driver = { 516 .name = "max1027", 517 .of_match_table = max1027_adc_dt_ids, 518 }, 519 .probe = max1027_probe, 520 .id_table = max1027_id, 521 }; 522 module_spi_driver(max1027_driver); 523 524 MODULE_AUTHOR("Philippe Reynes <tremyfr@yahoo.fr>"); 525 MODULE_DESCRIPTION("MAX1X27/MAX1X29/MAX1X31 ADC"); 526 MODULE_LICENSE("GPL v2"); 527