691 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Support code for Analog Devices Sigma-Delta ADCs4 *5 * Copyright 2012 Analog Devices Inc.6 * Author: Lars-Peter Clausen <lars@metafoo.de>7 */8 9#include <linux/align.h>10#include <linux/interrupt.h>11#include <linux/device.h>12#include <linux/kernel.h>13#include <linux/slab.h>14#include <linux/spi/spi.h>15#include <linux/err.h>16#include <linux/module.h>17 18#include <linux/iio/iio.h>19#include <linux/iio/sysfs.h>20#include <linux/iio/buffer.h>21#include <linux/iio/trigger.h>22#include <linux/iio/trigger_consumer.h>23#include <linux/iio/triggered_buffer.h>24#include <linux/iio/adc/ad_sigma_delta.h>25 26#include <linux/unaligned.h>27 28 29#define AD_SD_COMM_CHAN_MASK 0x330 31#define AD_SD_REG_COMM 0x0032#define AD_SD_REG_DATA 0x0333 34/**35 * ad_sd_set_comm() - Set communications register36 *37 * @sigma_delta: The sigma delta device38 * @comm: New value for the communications register39 */40void ad_sd_set_comm(struct ad_sigma_delta *sigma_delta, uint8_t comm)41{42 /* Some variants use the lower two bits of the communications register43 * to select the channel */44 sigma_delta->comm = comm & AD_SD_COMM_CHAN_MASK;45}46EXPORT_SYMBOL_NS_GPL(ad_sd_set_comm, IIO_AD_SIGMA_DELTA);47 48/**49 * ad_sd_write_reg() - Write a register50 *51 * @sigma_delta: The sigma delta device52 * @reg: Address of the register53 * @size: Size of the register (0-3)54 * @val: Value to write to the register55 *56 * Returns 0 on success, an error code otherwise.57 **/58int ad_sd_write_reg(struct ad_sigma_delta *sigma_delta, unsigned int reg,59 unsigned int size, unsigned int val)60{61 uint8_t *data = sigma_delta->tx_buf;62 struct spi_transfer t = {63 .tx_buf = data,64 .len = size + 1,65 .cs_change = sigma_delta->keep_cs_asserted,66 };67 struct spi_message m;68 int ret;69 70 data[0] = (reg << sigma_delta->info->addr_shift) | sigma_delta->comm;71 72 switch (size) {73 case 3:74 put_unaligned_be24(val, &data[1]);75 break;76 case 2:77 put_unaligned_be16(val, &data[1]);78 break;79 case 1:80 data[1] = val;81 break;82 case 0:83 break;84 default:85 return -EINVAL;86 }87 88 spi_message_init(&m);89 spi_message_add_tail(&t, &m);90 91 if (sigma_delta->bus_locked)92 ret = spi_sync_locked(sigma_delta->spi, &m);93 else94 ret = spi_sync(sigma_delta->spi, &m);95 96 return ret;97}98EXPORT_SYMBOL_NS_GPL(ad_sd_write_reg, IIO_AD_SIGMA_DELTA);99 100static int ad_sd_read_reg_raw(struct ad_sigma_delta *sigma_delta,101 unsigned int reg, unsigned int size, uint8_t *val)102{103 uint8_t *data = sigma_delta->tx_buf;104 int ret;105 struct spi_transfer t[] = {106 {107 .tx_buf = data,108 .len = 1,109 }, {110 .rx_buf = val,111 .len = size,112 .cs_change = sigma_delta->bus_locked,113 },114 };115 struct spi_message m;116 117 spi_message_init(&m);118 119 if (sigma_delta->info->has_registers) {120 data[0] = reg << sigma_delta->info->addr_shift;121 data[0] |= sigma_delta->info->read_mask;122 data[0] |= sigma_delta->comm;123 spi_message_add_tail(&t[0], &m);124 }125 spi_message_add_tail(&t[1], &m);126 127 if (sigma_delta->bus_locked)128 ret = spi_sync_locked(sigma_delta->spi, &m);129 else130 ret = spi_sync(sigma_delta->spi, &m);131 132 return ret;133}134 135/**136 * ad_sd_read_reg() - Read a register137 *138 * @sigma_delta: The sigma delta device139 * @reg: Address of the register140 * @size: Size of the register (1-4)141 * @val: Read value142 *143 * Returns 0 on success, an error code otherwise.144 **/145int ad_sd_read_reg(struct ad_sigma_delta *sigma_delta,146 unsigned int reg, unsigned int size, unsigned int *val)147{148 int ret;149 150 ret = ad_sd_read_reg_raw(sigma_delta, reg, size, sigma_delta->rx_buf);151 if (ret < 0)152 goto out;153 154 switch (size) {155 case 4:156 *val = get_unaligned_be32(sigma_delta->rx_buf);157 break;158 case 3:159 *val = get_unaligned_be24(sigma_delta->rx_buf);160 break;161 case 2:162 *val = get_unaligned_be16(sigma_delta->rx_buf);163 break;164 case 1:165 *val = sigma_delta->rx_buf[0];166 break;167 default:168 ret = -EINVAL;169 break;170 }171 172out:173 return ret;174}175EXPORT_SYMBOL_NS_GPL(ad_sd_read_reg, IIO_AD_SIGMA_DELTA);176 177/**178 * ad_sd_reset() - Reset the serial interface179 *180 * @sigma_delta: The sigma delta device181 * @reset_length: Number of SCLKs with DIN = 1182 *183 * Returns 0 on success, an error code otherwise.184 **/185int ad_sd_reset(struct ad_sigma_delta *sigma_delta,186 unsigned int reset_length)187{188 uint8_t *buf;189 unsigned int size;190 int ret;191 192 size = DIV_ROUND_UP(reset_length, 8);193 buf = kcalloc(size, sizeof(*buf), GFP_KERNEL);194 if (!buf)195 return -ENOMEM;196 197 memset(buf, 0xff, size);198 ret = spi_write(sigma_delta->spi, buf, size);199 kfree(buf);200 201 return ret;202}203EXPORT_SYMBOL_NS_GPL(ad_sd_reset, IIO_AD_SIGMA_DELTA);204 205int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta,206 unsigned int mode, unsigned int channel)207{208 int ret;209 unsigned long time_left;210 211 ret = ad_sigma_delta_set_channel(sigma_delta, channel);212 if (ret)213 return ret;214 215 spi_bus_lock(sigma_delta->spi->controller);216 sigma_delta->bus_locked = true;217 sigma_delta->keep_cs_asserted = true;218 reinit_completion(&sigma_delta->completion);219 220 ret = ad_sigma_delta_set_mode(sigma_delta, mode);221 if (ret < 0)222 goto out;223 224 sigma_delta->irq_dis = false;225 enable_irq(sigma_delta->irq_line);226 time_left = wait_for_completion_timeout(&sigma_delta->completion, 2 * HZ);227 if (time_left == 0) {228 sigma_delta->irq_dis = true;229 disable_irq_nosync(sigma_delta->irq_line);230 ret = -EIO;231 } else {232 ret = 0;233 }234out:235 sigma_delta->keep_cs_asserted = false;236 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);237 sigma_delta->bus_locked = false;238 spi_bus_unlock(sigma_delta->spi->controller);239 240 return ret;241}242EXPORT_SYMBOL_NS_GPL(ad_sd_calibrate, IIO_AD_SIGMA_DELTA);243 244/**245 * ad_sd_calibrate_all() - Performs channel calibration246 * @sigma_delta: The sigma delta device247 * @cb: Array of channels and calibration type to perform248 * @n: Number of items in cb249 *250 * Returns 0 on success, an error code otherwise.251 **/252int ad_sd_calibrate_all(struct ad_sigma_delta *sigma_delta,253 const struct ad_sd_calib_data *cb, unsigned int n)254{255 unsigned int i;256 int ret;257 258 for (i = 0; i < n; i++) {259 ret = ad_sd_calibrate(sigma_delta, cb[i].mode, cb[i].channel);260 if (ret)261 return ret;262 }263 264 return 0;265}266EXPORT_SYMBOL_NS_GPL(ad_sd_calibrate_all, IIO_AD_SIGMA_DELTA);267 268/**269 * ad_sigma_delta_single_conversion() - Performs a single data conversion270 * @indio_dev: The IIO device271 * @chan: The conversion is done for this channel272 * @val: Pointer to the location where to store the read value273 *274 * Returns: 0 on success, an error value otherwise.275 */276int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,277 const struct iio_chan_spec *chan, int *val)278{279 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);280 unsigned int sample, raw_sample;281 unsigned int data_reg;282 int ret = 0;283 284 ret = iio_device_claim_direct_mode(indio_dev);285 if (ret)286 return ret;287 288 ad_sigma_delta_set_channel(sigma_delta, chan->address);289 290 spi_bus_lock(sigma_delta->spi->controller);291 sigma_delta->bus_locked = true;292 sigma_delta->keep_cs_asserted = true;293 reinit_completion(&sigma_delta->completion);294 295 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_SINGLE);296 297 sigma_delta->irq_dis = false;298 enable_irq(sigma_delta->irq_line);299 ret = wait_for_completion_interruptible_timeout(300 &sigma_delta->completion, HZ);301 302 if (ret == 0)303 ret = -EIO;304 if (ret < 0)305 goto out;306 307 if (sigma_delta->info->data_reg != 0)308 data_reg = sigma_delta->info->data_reg;309 else310 data_reg = AD_SD_REG_DATA;311 312 ret = ad_sd_read_reg(sigma_delta, data_reg,313 DIV_ROUND_UP(chan->scan_type.realbits + chan->scan_type.shift, 8),314 &raw_sample);315 316out:317 if (!sigma_delta->irq_dis) {318 disable_irq_nosync(sigma_delta->irq_line);319 sigma_delta->irq_dis = true;320 }321 322 sigma_delta->keep_cs_asserted = false;323 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);324 ad_sigma_delta_disable_one(sigma_delta, chan->address);325 sigma_delta->bus_locked = false;326 spi_bus_unlock(sigma_delta->spi->controller);327 iio_device_release_direct_mode(indio_dev);328 329 if (ret)330 return ret;331 332 sample = raw_sample >> chan->scan_type.shift;333 sample &= (1 << chan->scan_type.realbits) - 1;334 *val = sample;335 336 ret = ad_sigma_delta_postprocess_sample(sigma_delta, raw_sample);337 if (ret)338 return ret;339 340 return IIO_VAL_INT;341}342EXPORT_SYMBOL_NS_GPL(ad_sigma_delta_single_conversion, IIO_AD_SIGMA_DELTA);343 344static int ad_sd_buffer_postenable(struct iio_dev *indio_dev)345{346 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);347 unsigned int i, slot, samples_buf_size;348 unsigned int channel;349 uint8_t *samples_buf;350 int ret;351 352 if (sigma_delta->num_slots == 1) {353 channel = find_first_bit(indio_dev->active_scan_mask,354 iio_get_masklength(indio_dev));355 ret = ad_sigma_delta_set_channel(sigma_delta,356 indio_dev->channels[channel].address);357 if (ret)358 return ret;359 slot = 1;360 } else {361 /*362 * At this point update_scan_mode already enabled the required channels.363 * For sigma-delta sequencer drivers with multiple slots, an update_scan_mode364 * implementation is mandatory.365 */366 slot = 0;367 iio_for_each_active_channel(indio_dev, i) {368 sigma_delta->slots[slot] = indio_dev->channels[i].address;369 slot++;370 }371 }372 373 sigma_delta->active_slots = slot;374 sigma_delta->current_slot = 0;375 376 if (sigma_delta->active_slots > 1) {377 ret = ad_sigma_delta_append_status(sigma_delta, true);378 if (ret)379 return ret;380 }381 382 samples_buf_size = ALIGN(slot * indio_dev->channels[0].scan_type.storagebits, 8);383 samples_buf_size += sizeof(int64_t);384 samples_buf = devm_krealloc(&sigma_delta->spi->dev, sigma_delta->samples_buf,385 samples_buf_size, GFP_KERNEL);386 if (!samples_buf)387 return -ENOMEM;388 389 sigma_delta->samples_buf = samples_buf;390 391 spi_bus_lock(sigma_delta->spi->controller);392 sigma_delta->bus_locked = true;393 sigma_delta->keep_cs_asserted = true;394 395 ret = ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_CONTINUOUS);396 if (ret)397 goto err_unlock;398 399 sigma_delta->irq_dis = false;400 enable_irq(sigma_delta->irq_line);401 402 return 0;403 404err_unlock:405 spi_bus_unlock(sigma_delta->spi->controller);406 407 return ret;408}409 410static int ad_sd_buffer_postdisable(struct iio_dev *indio_dev)411{412 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);413 414 reinit_completion(&sigma_delta->completion);415 wait_for_completion_timeout(&sigma_delta->completion, HZ);416 417 if (!sigma_delta->irq_dis) {418 disable_irq_nosync(sigma_delta->irq_line);419 sigma_delta->irq_dis = true;420 }421 422 sigma_delta->keep_cs_asserted = false;423 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);424 425 if (sigma_delta->status_appended)426 ad_sigma_delta_append_status(sigma_delta, false);427 428 ad_sigma_delta_disable_all(sigma_delta);429 sigma_delta->bus_locked = false;430 return spi_bus_unlock(sigma_delta->spi->controller);431}432 433static irqreturn_t ad_sd_trigger_handler(int irq, void *p)434{435 struct iio_poll_func *pf = p;436 struct iio_dev *indio_dev = pf->indio_dev;437 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);438 uint8_t *data = sigma_delta->rx_buf;439 unsigned int transfer_size;440 unsigned int sample_size;441 unsigned int sample_pos;442 unsigned int status_pos;443 unsigned int reg_size;444 unsigned int data_reg;445 446 reg_size = indio_dev->channels[0].scan_type.realbits +447 indio_dev->channels[0].scan_type.shift;448 reg_size = DIV_ROUND_UP(reg_size, 8);449 450 if (sigma_delta->info->data_reg != 0)451 data_reg = sigma_delta->info->data_reg;452 else453 data_reg = AD_SD_REG_DATA;454 455 /* Status word will be appended to the sample during transfer */456 if (sigma_delta->status_appended)457 transfer_size = reg_size + 1;458 else459 transfer_size = reg_size;460 461 switch (reg_size) {462 case 4:463 case 2:464 case 1:465 status_pos = reg_size;466 ad_sd_read_reg_raw(sigma_delta, data_reg, transfer_size, &data[0]);467 break;468 case 3:469 /*470 * Data array after transfer will look like (if status is appended):471 * data[] = { [0][sample][sample][sample][status] }472 * Keeping the first byte 0 shifts the status postion by 1 byte to the right.473 */474 status_pos = reg_size + 1;475 476 /* We store 24 bit samples in a 32 bit word. Keep the upper477 * byte set to zero. */478 ad_sd_read_reg_raw(sigma_delta, data_reg, transfer_size, &data[1]);479 break;480 }481 482 /*483 * For devices sampling only one channel at484 * once, there is no need for sample number tracking.485 */486 if (sigma_delta->active_slots == 1) {487 iio_push_to_buffers_with_timestamp(indio_dev, data, pf->timestamp);488 goto irq_handled;489 }490 491 if (sigma_delta->status_appended) {492 u8 converted_channel;493 494 converted_channel = data[status_pos] & sigma_delta->info->status_ch_mask;495 if (converted_channel != sigma_delta->slots[sigma_delta->current_slot]) {496 /*497 * Desync occurred during continuous sampling of multiple channels.498 * Drop this incomplete sample and start from first channel again.499 */500 501 sigma_delta->current_slot = 0;502 goto irq_handled;503 }504 }505 506 sample_size = indio_dev->channels[0].scan_type.storagebits / 8;507 sample_pos = sample_size * sigma_delta->current_slot;508 memcpy(&sigma_delta->samples_buf[sample_pos], data, sample_size);509 sigma_delta->current_slot++;510 511 if (sigma_delta->current_slot == sigma_delta->active_slots) {512 sigma_delta->current_slot = 0;513 iio_push_to_buffers_with_timestamp(indio_dev, sigma_delta->samples_buf,514 pf->timestamp);515 }516 517irq_handled:518 iio_trigger_notify_done(indio_dev->trig);519 sigma_delta->irq_dis = false;520 enable_irq(sigma_delta->irq_line);521 522 return IRQ_HANDLED;523}524 525static bool ad_sd_validate_scan_mask(struct iio_dev *indio_dev, const unsigned long *mask)526{527 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);528 529 return bitmap_weight(mask, iio_get_masklength(indio_dev)) <= sigma_delta->num_slots;530}531 532static const struct iio_buffer_setup_ops ad_sd_buffer_setup_ops = {533 .postenable = &ad_sd_buffer_postenable,534 .postdisable = &ad_sd_buffer_postdisable,535 .validate_scan_mask = &ad_sd_validate_scan_mask,536};537 538static irqreturn_t ad_sd_data_rdy_trig_poll(int irq, void *private)539{540 struct ad_sigma_delta *sigma_delta = private;541 542 complete(&sigma_delta->completion);543 disable_irq_nosync(irq);544 sigma_delta->irq_dis = true;545 iio_trigger_poll(sigma_delta->trig);546 547 return IRQ_HANDLED;548}549 550/**551 * ad_sd_validate_trigger() - validate_trigger callback for ad_sigma_delta devices552 * @indio_dev: The IIO device553 * @trig: The new trigger554 *555 * Returns: 0 if the 'trig' matches the trigger registered by the ad_sigma_delta556 * device, -EINVAL otherwise.557 */558int ad_sd_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig)559{560 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);561 562 if (sigma_delta->trig != trig)563 return -EINVAL;564 565 return 0;566}567EXPORT_SYMBOL_NS_GPL(ad_sd_validate_trigger, IIO_AD_SIGMA_DELTA);568 569static int devm_ad_sd_probe_trigger(struct device *dev, struct iio_dev *indio_dev)570{571 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);572 unsigned long irq_flags = irq_get_trigger_type(sigma_delta->irq_line);573 int ret;574 575 if (dev != &sigma_delta->spi->dev) {576 dev_err(dev, "Trigger parent should be '%s', got '%s'\n",577 dev_name(dev), dev_name(&sigma_delta->spi->dev));578 return -EFAULT;579 }580 581 sigma_delta->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,582 iio_device_id(indio_dev));583 if (sigma_delta->trig == NULL)584 return -ENOMEM;585 586 init_completion(&sigma_delta->completion);587 588 sigma_delta->irq_dis = true;589 590 /* the IRQ core clears IRQ_DISABLE_UNLAZY flag when freeing an IRQ */591 irq_set_status_flags(sigma_delta->irq_line, IRQ_DISABLE_UNLAZY);592 593 /* Allow overwriting the flags from firmware */594 if (!irq_flags)595 irq_flags = sigma_delta->info->irq_flags;596 597 ret = devm_request_irq(dev, sigma_delta->irq_line,598 ad_sd_data_rdy_trig_poll,599 irq_flags | IRQF_NO_AUTOEN,600 indio_dev->name,601 sigma_delta);602 if (ret)603 return ret;604 605 iio_trigger_set_drvdata(sigma_delta->trig, sigma_delta);606 607 ret = devm_iio_trigger_register(dev, sigma_delta->trig);608 if (ret)609 return ret;610 611 /* select default trigger */612 indio_dev->trig = iio_trigger_get(sigma_delta->trig);613 614 return 0;615}616 617/**618 * devm_ad_sd_setup_buffer_and_trigger() - Device-managed buffer & trigger setup619 * @dev: Device object to which to bind the life-time of the resources attached620 * @indio_dev: The IIO device621 */622int devm_ad_sd_setup_buffer_and_trigger(struct device *dev, struct iio_dev *indio_dev)623{624 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);625 int ret;626 627 sigma_delta->slots = devm_kcalloc(dev, sigma_delta->num_slots,628 sizeof(*sigma_delta->slots), GFP_KERNEL);629 if (!sigma_delta->slots)630 return -ENOMEM;631 632 ret = devm_iio_triggered_buffer_setup(dev, indio_dev,633 &iio_pollfunc_store_time,634 &ad_sd_trigger_handler,635 &ad_sd_buffer_setup_ops);636 if (ret)637 return ret;638 639 return devm_ad_sd_probe_trigger(dev, indio_dev);640}641EXPORT_SYMBOL_NS_GPL(devm_ad_sd_setup_buffer_and_trigger, IIO_AD_SIGMA_DELTA);642 643/**644 * ad_sd_init() - Initializes a ad_sigma_delta struct645 * @sigma_delta: The ad_sigma_delta device646 * @indio_dev: The IIO device which the Sigma Delta device is used for647 * @spi: The SPI device for the ad_sigma_delta device648 * @info: Device specific callbacks and options649 *650 * This function needs to be called before any other operations are performed on651 * the ad_sigma_delta struct.652 */653int ad_sd_init(struct ad_sigma_delta *sigma_delta, struct iio_dev *indio_dev,654 struct spi_device *spi, const struct ad_sigma_delta_info *info)655{656 sigma_delta->spi = spi;657 sigma_delta->info = info;658 659 /* If the field is unset in ad_sigma_delta_info, asume there can only be 1 slot. */660 if (!info->num_slots)661 sigma_delta->num_slots = 1;662 else663 sigma_delta->num_slots = info->num_slots;664 665 if (sigma_delta->num_slots > 1) {666 if (!indio_dev->info->update_scan_mode) {667 dev_err(&spi->dev, "iio_dev lacks update_scan_mode().\n");668 return -EINVAL;669 }670 671 if (!info->disable_all) {672 dev_err(&spi->dev, "ad_sigma_delta_info lacks disable_all().\n");673 return -EINVAL;674 }675 }676 677 if (info->irq_line)678 sigma_delta->irq_line = info->irq_line;679 else680 sigma_delta->irq_line = spi->irq;681 682 iio_device_set_drvdata(indio_dev, sigma_delta);683 684 return 0;685}686EXPORT_SYMBOL_NS_GPL(ad_sd_init, IIO_AD_SIGMA_DELTA);687 688MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");689MODULE_DESCRIPTION("Analog Devices Sigma-Delta ADCs");690MODULE_LICENSE("GPL v2");691