drivers/iio/imu/adis_buffer.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Common library for ADIS16XXX devices
   4  *
   5  * Copyright 2012 Analog Devices Inc.
   6  *   Author: Lars-Peter Clausen <lars@metafoo.de>
   7  */
   8
   9 #include <linux/export.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/mutex.h>
  12 #include <linux/kernel.h>
  13 #include <linux/spi/spi.h>
  14 #include <linux/slab.h>
  15
  16 #include <linux/iio/iio.h>
  17 #include <linux/iio/buffer.h>
  18 #include <linux/iio/trigger_consumer.h>
  19 #include <linux/iio/triggered_buffer.h>
  20 #include <linux/iio/imu/adis.h>
  21
  22 static int adis_update_scan_mode_burst(struct iio_dev *indio_dev,
  23                                        const unsigned long *scan_mask)
  24 {
  25         struct adis *adis = iio_device_get_drvdata(indio_dev);
  26         unsigned int burst_length, burst_max_length;
  27         u8 *tx;
  28
  29         burst_length = adis->data->burst_len + adis->burst_extra_len;
  30
  31         if (adis->data->burst_max_len)
  32                 burst_max_length = adis->data->burst_max_len;
  33         else
  34                 burst_max_length = burst_length;
  35
  36         adis->xfer = kcalloc(2, sizeof(*adis->xfer), GFP_KERNEL);
  37         if (!adis->xfer)
  38                 return -ENOMEM;
  39
  40         adis->buffer = kzalloc(burst_max_length + sizeof(u16), GFP_KERNEL);
  41         if (!adis->buffer) {
  42                 kfree(adis->xfer);
  43                 adis->xfer = NULL;
  44                 return -ENOMEM;
  45         }
  46
  47         tx = adis->buffer + burst_max_length;
  48         tx[0] = ADIS_READ_REG(adis->data->burst_reg_cmd);
  49         tx[1] = 0;
  50
  51         adis->xfer[0].tx_buf = tx;
  52         adis->xfer[0].bits_per_word = 8;
  53         adis->xfer[0].len = 2;
  54         if (adis->data->burst_max_speed_hz)
  55                 adis->xfer[0].speed_hz = adis->data->burst_max_speed_hz;
  56         adis->xfer[1].rx_buf = adis->buffer;
  57         adis->xfer[1].bits_per_word = 8;
  58         adis->xfer[1].len = burst_length;
  59         if (adis->data->burst_max_speed_hz)
  60                 adis->xfer[1].speed_hz = adis->data->burst_max_speed_hz;
  61
  62         spi_message_init(&adis->msg);
  63         spi_message_add_tail(&adis->xfer[0], &adis->msg);
  64         spi_message_add_tail(&adis->xfer[1], &adis->msg);
  65
  66         return 0;
  67 }
  68
  69 int adis_update_scan_mode(struct iio_dev *indio_dev,
  70                           const unsigned long *scan_mask)
  71 {
  72         struct adis *adis = iio_device_get_drvdata(indio_dev);
  73         const struct iio_chan_spec *chan;
  74         unsigned int scan_count;
  75         unsigned int i, j;
  76         __be16 *tx, *rx;
  77
  78         kfree(adis->xfer);
  79         kfree(adis->buffer);
  80
  81         if (adis->data->burst_len)
  82                 return adis_update_scan_mode_burst(indio_dev, scan_mask);
  83
  84         scan_count = indio_dev->scan_bytes / 2;
  85
  86         adis->xfer = kcalloc(scan_count + 1, sizeof(*adis->xfer), GFP_KERNEL);
  87         if (!adis->xfer)
  88                 return -ENOMEM;
  89
  90         adis->buffer = kcalloc(indio_dev->scan_bytes, 2, GFP_KERNEL);
  91         if (!adis->buffer) {
  92                 kfree(adis->xfer);
  93                 adis->xfer = NULL;
  94                 return -ENOMEM;
  95         }
  96
  97         rx = adis->buffer;
  98         tx = rx + scan_count;
  99
 100         spi_message_init(&adis->msg);
 101
 102         for (j = 0; j <= scan_count; j++) {
 103                 adis->xfer[j].bits_per_word = 8;
 104                 if (j != scan_count)
 105                         adis->xfer[j].cs_change = 1;
 106                 adis->xfer[j].len = 2;
 107                 adis->xfer[j].delay.value = adis->data->read_delay;
 108                 adis->xfer[j].delay.unit = SPI_DELAY_UNIT_USECS;
 109                 if (j < scan_count)
 110                         adis->xfer[j].tx_buf = &tx[j];
 111                 if (j >= 1)
 112                         adis->xfer[j].rx_buf = &rx[j - 1];
 113                 spi_message_add_tail(&adis->xfer[j], &adis->msg);
 114         }
 115
 116         chan = indio_dev->channels;
 117         for (i = 0; i < indio_dev->num_channels; i++, chan++) {
 118                 if (!test_bit(chan->scan_index, scan_mask))
 119                         continue;
 120                 if (chan->scan_type.storagebits == 32)
 121                         *tx++ = cpu_to_be16((chan->address + 2) << 8);
 122                 *tx++ = cpu_to_be16(chan->address << 8);
 123         }
 124
 125         return 0;
 126 }
 127 EXPORT_SYMBOL_NS_GPL(adis_update_scan_mode, "IIO_ADISLIB");
 128
 129 static int adis_paging_trigger_handler(struct adis *adis)
 130 {
 131         int ret;
 132
 133         guard(mutex)(&adis->state_lock);
 134         if (adis->current_page != 0) {
 135                 adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID);
 136                 adis->tx[1] = 0;
 137                 ret = spi_write(adis->spi, adis->tx, 2);
 138                 if (ret) {
 139                         dev_err(&adis->spi->dev, "Failed to change device page: %d\n", ret);
 140                         return ret;
 141                 }
 142
 143                 adis->current_page = 0;
 144         }
 145
 146         return spi_sync(adis->spi, &adis->msg);
 147 }
 148
 149 static irqreturn_t adis_trigger_handler(int irq, void *p)
 150 {
 151         struct iio_poll_func *pf = p;
 152         struct iio_dev *indio_dev = pf->indio_dev;
 153         struct adis *adis = iio_device_get_drvdata(indio_dev);
 154         int ret;
 155
 156         if (adis->data->has_paging)
 157                 ret = adis_paging_trigger_handler(adis);
 158         else
 159                 ret = spi_sync(adis->spi, &adis->msg);
 160         if (ret) {
 161                 dev_err(&adis->spi->dev, "Failed to read data: %d", ret);
 162                 goto irq_done;
 163         }
 164
 165         iio_push_to_buffers_with_timestamp(indio_dev, adis->buffer,
 166                                            pf->timestamp);
 167
 168 irq_done:
 169         iio_trigger_notify_done(indio_dev->trig);
 170
 171         return IRQ_HANDLED;
 172 }
 173
 174 static void adis_buffer_cleanup(void *arg)
 175 {
 176         struct adis *adis = arg;
 177
 178         kfree(adis->buffer);
 179         kfree(adis->xfer);
 180 }
 181
 182 /**
 183  * devm_adis_setup_buffer_and_trigger_with_attrs() - Sets up buffer and trigger
 184  * for the managed adis device with buffer attributes.
 185  * @adis: The adis device
 186  * @indio_dev: The IIO device
 187  * @trigger_handler: Trigger handler: should handle the buffer readings.
 188  * @ops: Optional buffer setup functions, may be NULL.
 189  * @buffer_attrs: Extra buffer attributes.
 190  *
 191  * Returns 0 on success, a negative error code otherwise.
 192  *
 193  * This function sets up the buffer (with buffer setup functions and extra
 194  * buffer attributes) and trigger for a adis devices with buffer attributes.
 195  */
 196 int
 197 devm_adis_setup_buffer_and_trigger_with_attrs(struct adis *adis, struct iio_dev *indio_dev,
 198                                               irq_handler_t trigger_handler,
 199                                               const struct iio_buffer_setup_ops *ops,
 200                                               const struct iio_dev_attr **buffer_attrs)
 201 {
 202         int ret;
 203
 204         if (!trigger_handler)
 205                 trigger_handler = adis_trigger_handler;
 206
 207         ret = devm_iio_triggered_buffer_setup_ext(&adis->spi->dev, indio_dev,
 208                                                   &iio_pollfunc_store_time,
 209                                                   trigger_handler,
 210                                                   IIO_BUFFER_DIRECTION_IN,
 211                                                   ops,
 212                                                   buffer_attrs);
 213         if (ret)
 214                 return ret;
 215
 216         if (adis->spi->irq) {
 217                 ret = devm_adis_probe_trigger(adis, indio_dev);
 218                 if (ret)
 219                         return ret;
 220         }
 221
 222         return devm_add_action_or_reset(&adis->spi->dev, adis_buffer_cleanup,
 223                                         adis);
 224 }
 225 EXPORT_SYMBOL_NS_GPL(devm_adis_setup_buffer_and_trigger_with_attrs, "IIO_ADISLIB");