1 /* 2 * AD5421 Digital to analog converters driver 3 * 4 * Copyright 2011 Analog Devices Inc. 5 * 6 * Licensed under the GPL-2. 7 */ 8 9 #include <linux/device.h> 10 #include <linux/delay.h> 11 #include <linux/err.h> 12 #include <linux/module.h> 13 #include <linux/interrupt.h> 14 #include <linux/kernel.h> 15 #include <linux/spi/spi.h> 16 #include <linux/slab.h> 17 #include <linux/sysfs.h> 18 19 #include <linux/iio/iio.h> 20 #include <linux/iio/sysfs.h> 21 #include <linux/iio/events.h> 22 #include <linux/iio/dac/ad5421.h> 23 24 25 #define AD5421_REG_DAC_DATA 0x1 26 #define AD5421_REG_CTRL 0x2 27 #define AD5421_REG_OFFSET 0x3 28 #define AD5421_REG_GAIN 0x4 29 /* load dac and fault shared the same register number. Writing to it will cause 30 * a dac load command, reading from it will return the fault status register */ 31 #define AD5421_REG_LOAD_DAC 0x5 32 #define AD5421_REG_FAULT 0x5 33 #define AD5421_REG_FORCE_ALARM_CURRENT 0x6 34 #define AD5421_REG_RESET 0x7 35 #define AD5421_REG_START_CONVERSION 0x8 36 #define AD5421_REG_NOOP 0x9 37 38 #define AD5421_CTRL_WATCHDOG_DISABLE BIT(12) 39 #define AD5421_CTRL_AUTO_FAULT_READBACK BIT(11) 40 #define AD5421_CTRL_MIN_CURRENT BIT(9) 41 #define AD5421_CTRL_ADC_SOURCE_TEMP BIT(8) 42 #define AD5421_CTRL_ADC_ENABLE BIT(7) 43 #define AD5421_CTRL_PWR_DOWN_INT_VREF BIT(6) 44 45 #define AD5421_FAULT_SPI BIT(15) 46 #define AD5421_FAULT_PEC BIT(14) 47 #define AD5421_FAULT_OVER_CURRENT BIT(13) 48 #define AD5421_FAULT_UNDER_CURRENT BIT(12) 49 #define AD5421_FAULT_TEMP_OVER_140 BIT(11) 50 #define AD5421_FAULT_TEMP_OVER_100 BIT(10) 51 #define AD5421_FAULT_UNDER_VOLTAGE_6V BIT(9) 52 #define AD5421_FAULT_UNDER_VOLTAGE_12V BIT(8) 53 54 /* These bits will cause the fault pin to go high */ 55 #define AD5421_FAULT_TRIGGER_IRQ \ 56 (AD5421_FAULT_SPI | AD5421_FAULT_PEC | AD5421_FAULT_OVER_CURRENT | \ 57 AD5421_FAULT_UNDER_CURRENT | AD5421_FAULT_TEMP_OVER_140) 58 59 /** 60 * struct ad5421_state - driver instance specific data 61 * @spi: spi_device 62 * @ctrl: control register cache 63 * @current_range: current range which the device is configured for 64 * @data: spi transfer buffers 65 * @fault_mask: software masking of events 66 */ 67 struct ad5421_state { 68 struct spi_device *spi; 69 unsigned int ctrl; 70 enum ad5421_current_range current_range; 71 unsigned int fault_mask; 72 73 /* 74 * DMA (thus cache coherency maintenance) requires the 75 * transfer buffers to live in their own cache lines. 76 */ 77 union { 78 __be32 d32; 79 u8 d8[4]; 80 } data[2] ____cacheline_aligned; 81 }; 82 83 static const struct iio_event_spec ad5421_current_event[] = { 84 { 85 .type = IIO_EV_TYPE_THRESH, 86 .dir = IIO_EV_DIR_RISING, 87 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 88 BIT(IIO_EV_INFO_ENABLE), 89 }, { 90 .type = IIO_EV_TYPE_THRESH, 91 .dir = IIO_EV_DIR_FALLING, 92 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 93 BIT(IIO_EV_INFO_ENABLE), 94 }, 95 }; 96 97 static const struct iio_event_spec ad5421_temp_event[] = { 98 { 99 .type = IIO_EV_TYPE_THRESH, 100 .dir = IIO_EV_DIR_RISING, 101 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 102 BIT(IIO_EV_INFO_ENABLE), 103 }, 104 }; 105 106 static const struct iio_chan_spec ad5421_channels[] = { 107 { 108 .type = IIO_CURRENT, 109 .indexed = 1, 110 .output = 1, 111 .channel = 0, 112 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 113 BIT(IIO_CHAN_INFO_CALIBSCALE) | 114 BIT(IIO_CHAN_INFO_CALIBBIAS), 115 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | 116 BIT(IIO_CHAN_INFO_OFFSET), 117 .scan_type = { 118 .sign = 'u', 119 .realbits = 16, 120 .storagebits = 16, 121 }, 122 .event_spec = ad5421_current_event, 123 .num_event_specs = ARRAY_SIZE(ad5421_current_event), 124 }, 125 { 126 .type = IIO_TEMP, 127 .channel = -1, 128 .event_spec = ad5421_temp_event, 129 .num_event_specs = ARRAY_SIZE(ad5421_temp_event), 130 }, 131 }; 132 133 static int ad5421_write_unlocked(struct iio_dev *indio_dev, 134 unsigned int reg, unsigned int val) 135 { 136 struct ad5421_state *st = iio_priv(indio_dev); 137 138 st->data[0].d32 = cpu_to_be32((reg << 16) | val); 139 140 return spi_write(st->spi, &st->data[0].d8[1], 3); 141 } 142 143 static int ad5421_write(struct iio_dev *indio_dev, unsigned int reg, 144 unsigned int val) 145 { 146 int ret; 147 148 mutex_lock(&indio_dev->mlock); 149 ret = ad5421_write_unlocked(indio_dev, reg, val); 150 mutex_unlock(&indio_dev->mlock); 151 152 return ret; 153 } 154 155 static int ad5421_read(struct iio_dev *indio_dev, unsigned int reg) 156 { 157 struct ad5421_state *st = iio_priv(indio_dev); 158 int ret; 159 struct spi_transfer t[] = { 160 { 161 .tx_buf = &st->data[0].d8[1], 162 .len = 3, 163 .cs_change = 1, 164 }, { 165 .rx_buf = &st->data[1].d8[1], 166 .len = 3, 167 }, 168 }; 169 170 mutex_lock(&indio_dev->mlock); 171 172 st->data[0].d32 = cpu_to_be32((1 << 23) | (reg << 16)); 173 174 ret = spi_sync_transfer(st->spi, t, ARRAY_SIZE(t)); 175 if (ret >= 0) 176 ret = be32_to_cpu(st->data[1].d32) & 0xffff; 177 178 mutex_unlock(&indio_dev->mlock); 179 180 return ret; 181 } 182 183 static int ad5421_update_ctrl(struct iio_dev *indio_dev, unsigned int set, 184 unsigned int clr) 185 { 186 struct ad5421_state *st = iio_priv(indio_dev); 187 unsigned int ret; 188 189 mutex_lock(&indio_dev->mlock); 190 191 st->ctrl &= ~clr; 192 st->ctrl |= set; 193 194 ret = ad5421_write_unlocked(indio_dev, AD5421_REG_CTRL, st->ctrl); 195 196 mutex_unlock(&indio_dev->mlock); 197 198 return ret; 199 } 200 201 static irqreturn_t ad5421_fault_handler(int irq, void *data) 202 { 203 struct iio_dev *indio_dev = data; 204 struct ad5421_state *st = iio_priv(indio_dev); 205 unsigned int fault; 206 unsigned int old_fault = 0; 207 unsigned int events; 208 209 fault = ad5421_read(indio_dev, AD5421_REG_FAULT); 210 if (!fault) 211 return IRQ_NONE; 212 213 /* If we had a fault, this might mean that the DAC has lost its state 214 * and has been reset. Make sure that the control register actually 215 * contains what we expect it to contain. Otherwise the watchdog might 216 * be enabled and we get watchdog timeout faults, which will render the 217 * DAC unusable. */ 218 ad5421_update_ctrl(indio_dev, 0, 0); 219 220 221 /* The fault pin stays high as long as a fault condition is present and 222 * it is not possible to mask fault conditions. For certain fault 223 * conditions for example like over-temperature it takes some time 224 * until the fault condition disappears. If we would exit the interrupt 225 * handler immediately after handling the event it would be entered 226 * again instantly. Thus we fall back to polling in case we detect that 227 * a interrupt condition is still present. 228 */ 229 do { 230 /* 0xffff is a invalid value for the register and will only be 231 * read if there has been a communication error */ 232 if (fault == 0xffff) 233 fault = 0; 234 235 /* we are only interested in new events */ 236 events = (old_fault ^ fault) & fault; 237 events &= st->fault_mask; 238 239 if (events & AD5421_FAULT_OVER_CURRENT) { 240 iio_push_event(indio_dev, 241 IIO_UNMOD_EVENT_CODE(IIO_CURRENT, 242 0, 243 IIO_EV_TYPE_THRESH, 244 IIO_EV_DIR_RISING), 245 iio_get_time_ns(indio_dev)); 246 } 247 248 if (events & AD5421_FAULT_UNDER_CURRENT) { 249 iio_push_event(indio_dev, 250 IIO_UNMOD_EVENT_CODE(IIO_CURRENT, 251 0, 252 IIO_EV_TYPE_THRESH, 253 IIO_EV_DIR_FALLING), 254 iio_get_time_ns(indio_dev)); 255 } 256 257 if (events & AD5421_FAULT_TEMP_OVER_140) { 258 iio_push_event(indio_dev, 259 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 260 0, 261 IIO_EV_TYPE_MAG, 262 IIO_EV_DIR_RISING), 263 iio_get_time_ns(indio_dev)); 264 } 265 266 old_fault = fault; 267 fault = ad5421_read(indio_dev, AD5421_REG_FAULT); 268 269 /* still active? go to sleep for some time */ 270 if (fault & AD5421_FAULT_TRIGGER_IRQ) 271 msleep(1000); 272 273 } while (fault & AD5421_FAULT_TRIGGER_IRQ); 274 275 276 return IRQ_HANDLED; 277 } 278 279 static void ad5421_get_current_min_max(struct ad5421_state *st, 280 unsigned int *min, unsigned int *max) 281 { 282 /* The current range is configured using external pins, which are 283 * usually hard-wired and not run-time switchable. */ 284 switch (st->current_range) { 285 case AD5421_CURRENT_RANGE_4mA_20mA: 286 *min = 4000; 287 *max = 20000; 288 break; 289 case AD5421_CURRENT_RANGE_3mA8_21mA: 290 *min = 3800; 291 *max = 21000; 292 break; 293 case AD5421_CURRENT_RANGE_3mA2_24mA: 294 *min = 3200; 295 *max = 24000; 296 break; 297 default: 298 *min = 0; 299 *max = 1; 300 break; 301 } 302 } 303 304 static inline unsigned int ad5421_get_offset(struct ad5421_state *st) 305 { 306 unsigned int min, max; 307 308 ad5421_get_current_min_max(st, &min, &max); 309 return (min * (1 << 16)) / (max - min); 310 } 311 312 static int ad5421_read_raw(struct iio_dev *indio_dev, 313 struct iio_chan_spec const *chan, int *val, int *val2, long m) 314 { 315 struct ad5421_state *st = iio_priv(indio_dev); 316 unsigned int min, max; 317 int ret; 318 319 if (chan->type != IIO_CURRENT) 320 return -EINVAL; 321 322 switch (m) { 323 case IIO_CHAN_INFO_RAW: 324 ret = ad5421_read(indio_dev, AD5421_REG_DAC_DATA); 325 if (ret < 0) 326 return ret; 327 *val = ret; 328 return IIO_VAL_INT; 329 case IIO_CHAN_INFO_SCALE: 330 ad5421_get_current_min_max(st, &min, &max); 331 *val = max - min; 332 *val2 = (1 << 16) * 1000; 333 return IIO_VAL_FRACTIONAL; 334 case IIO_CHAN_INFO_OFFSET: 335 *val = ad5421_get_offset(st); 336 return IIO_VAL_INT; 337 case IIO_CHAN_INFO_CALIBBIAS: 338 ret = ad5421_read(indio_dev, AD5421_REG_OFFSET); 339 if (ret < 0) 340 return ret; 341 *val = ret - 32768; 342 return IIO_VAL_INT; 343 case IIO_CHAN_INFO_CALIBSCALE: 344 ret = ad5421_read(indio_dev, AD5421_REG_GAIN); 345 if (ret < 0) 346 return ret; 347 *val = ret; 348 return IIO_VAL_INT; 349 } 350 351 return -EINVAL; 352 } 353 354 static int ad5421_write_raw(struct iio_dev *indio_dev, 355 struct iio_chan_spec const *chan, int val, int val2, long mask) 356 { 357 const unsigned int max_val = 1 << 16; 358 359 switch (mask) { 360 case IIO_CHAN_INFO_RAW: 361 if (val >= max_val || val < 0) 362 return -EINVAL; 363 364 return ad5421_write(indio_dev, AD5421_REG_DAC_DATA, val); 365 case IIO_CHAN_INFO_CALIBBIAS: 366 val += 32768; 367 if (val >= max_val || val < 0) 368 return -EINVAL; 369 370 return ad5421_write(indio_dev, AD5421_REG_OFFSET, val); 371 case IIO_CHAN_INFO_CALIBSCALE: 372 if (val >= max_val || val < 0) 373 return -EINVAL; 374 375 return ad5421_write(indio_dev, AD5421_REG_GAIN, val); 376 default: 377 break; 378 } 379 380 return -EINVAL; 381 } 382 383 static int ad5421_write_event_config(struct iio_dev *indio_dev, 384 const struct iio_chan_spec *chan, enum iio_event_type type, 385 enum iio_event_direction dir, int state) 386 { 387 struct ad5421_state *st = iio_priv(indio_dev); 388 unsigned int mask; 389 390 switch (chan->type) { 391 case IIO_CURRENT: 392 if (dir == IIO_EV_DIR_RISING) 393 mask = AD5421_FAULT_OVER_CURRENT; 394 else 395 mask = AD5421_FAULT_UNDER_CURRENT; 396 break; 397 case IIO_TEMP: 398 mask = AD5421_FAULT_TEMP_OVER_140; 399 break; 400 default: 401 return -EINVAL; 402 } 403 404 mutex_lock(&indio_dev->mlock); 405 if (state) 406 st->fault_mask |= mask; 407 else 408 st->fault_mask &= ~mask; 409 mutex_unlock(&indio_dev->mlock); 410 411 return 0; 412 } 413 414 static int ad5421_read_event_config(struct iio_dev *indio_dev, 415 const struct iio_chan_spec *chan, enum iio_event_type type, 416 enum iio_event_direction dir) 417 { 418 struct ad5421_state *st = iio_priv(indio_dev); 419 unsigned int mask; 420 421 switch (chan->type) { 422 case IIO_CURRENT: 423 if (dir == IIO_EV_DIR_RISING) 424 mask = AD5421_FAULT_OVER_CURRENT; 425 else 426 mask = AD5421_FAULT_UNDER_CURRENT; 427 break; 428 case IIO_TEMP: 429 mask = AD5421_FAULT_TEMP_OVER_140; 430 break; 431 default: 432 return -EINVAL; 433 } 434 435 return (bool)(st->fault_mask & mask); 436 } 437 438 static int ad5421_read_event_value(struct iio_dev *indio_dev, 439 const struct iio_chan_spec *chan, enum iio_event_type type, 440 enum iio_event_direction dir, enum iio_event_info info, int *val, 441 int *val2) 442 { 443 int ret; 444 445 switch (chan->type) { 446 case IIO_CURRENT: 447 ret = ad5421_read(indio_dev, AD5421_REG_DAC_DATA); 448 if (ret < 0) 449 return ret; 450 *val = ret; 451 break; 452 case IIO_TEMP: 453 *val = 140000; 454 break; 455 default: 456 return -EINVAL; 457 } 458 459 return IIO_VAL_INT; 460 } 461 462 static const struct iio_info ad5421_info = { 463 .read_raw = ad5421_read_raw, 464 .write_raw = ad5421_write_raw, 465 .read_event_config = ad5421_read_event_config, 466 .write_event_config = ad5421_write_event_config, 467 .read_event_value = ad5421_read_event_value, 468 .driver_module = THIS_MODULE, 469 }; 470 471 static int ad5421_probe(struct spi_device *spi) 472 { 473 struct ad5421_platform_data *pdata = dev_get_platdata(&spi->dev); 474 struct iio_dev *indio_dev; 475 struct ad5421_state *st; 476 int ret; 477 478 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); 479 if (indio_dev == NULL) { 480 dev_err(&spi->dev, "Failed to allocate iio device\n"); 481 return -ENOMEM; 482 } 483 484 st = iio_priv(indio_dev); 485 spi_set_drvdata(spi, indio_dev); 486 487 st->spi = spi; 488 489 indio_dev->dev.parent = &spi->dev; 490 indio_dev->name = "ad5421"; 491 indio_dev->info = &ad5421_info; 492 indio_dev->modes = INDIO_DIRECT_MODE; 493 indio_dev->channels = ad5421_channels; 494 indio_dev->num_channels = ARRAY_SIZE(ad5421_channels); 495 496 st->ctrl = AD5421_CTRL_WATCHDOG_DISABLE | 497 AD5421_CTRL_AUTO_FAULT_READBACK; 498 499 if (pdata) { 500 st->current_range = pdata->current_range; 501 if (pdata->external_vref) 502 st->ctrl |= AD5421_CTRL_PWR_DOWN_INT_VREF; 503 } else { 504 st->current_range = AD5421_CURRENT_RANGE_4mA_20mA; 505 } 506 507 /* write initial ctrl register value */ 508 ad5421_update_ctrl(indio_dev, 0, 0); 509 510 if (spi->irq) { 511 ret = devm_request_threaded_irq(&spi->dev, spi->irq, 512 NULL, 513 ad5421_fault_handler, 514 IRQF_TRIGGER_HIGH | IRQF_ONESHOT, 515 "ad5421 fault", 516 indio_dev); 517 if (ret) 518 return ret; 519 } 520 521 return devm_iio_device_register(&spi->dev, indio_dev); 522 } 523 524 static struct spi_driver ad5421_driver = { 525 .driver = { 526 .name = "ad5421", 527 }, 528 .probe = ad5421_probe, 529 }; 530 module_spi_driver(ad5421_driver); 531 532 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 533 MODULE_DESCRIPTION("Analog Devices AD5421 DAC"); 534 MODULE_LICENSE("GPL v2"); 535 MODULE_ALIAS("spi:ad5421"); 536