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; 27 u8 *tx; 28 29 /* All but the timestamp channel */ 30 burst_length = (indio_dev->num_channels - 1) * sizeof(u16); 31 burst_length += adis->burst->extra_len; 32 33 adis->xfer = kcalloc(2, sizeof(*adis->xfer), GFP_KERNEL); 34 if (!adis->xfer) 35 return -ENOMEM; 36 37 adis->buffer = kzalloc(burst_length + sizeof(u16), GFP_KERNEL); 38 if (!adis->buffer) { 39 kfree(adis->xfer); 40 adis->xfer = NULL; 41 return -ENOMEM; 42 } 43 44 tx = adis->buffer + burst_length; 45 tx[0] = ADIS_READ_REG(adis->burst->reg_cmd); 46 tx[1] = 0; 47 48 adis->xfer[0].tx_buf = tx; 49 adis->xfer[0].bits_per_word = 8; 50 adis->xfer[0].len = 2; 51 adis->xfer[1].rx_buf = adis->buffer; 52 adis->xfer[1].bits_per_word = 8; 53 adis->xfer[1].len = burst_length; 54 55 spi_message_init(&adis->msg); 56 spi_message_add_tail(&adis->xfer[0], &adis->msg); 57 spi_message_add_tail(&adis->xfer[1], &adis->msg); 58 59 return 0; 60 } 61 62 int adis_update_scan_mode(struct iio_dev *indio_dev, 63 const unsigned long *scan_mask) 64 { 65 struct adis *adis = iio_device_get_drvdata(indio_dev); 66 const struct iio_chan_spec *chan; 67 unsigned int scan_count; 68 unsigned int i, j; 69 __be16 *tx, *rx; 70 71 kfree(adis->xfer); 72 kfree(adis->buffer); 73 74 if (adis->burst && adis->burst->en) 75 return adis_update_scan_mode_burst(indio_dev, scan_mask); 76 77 scan_count = indio_dev->scan_bytes / 2; 78 79 adis->xfer = kcalloc(scan_count + 1, sizeof(*adis->xfer), GFP_KERNEL); 80 if (!adis->xfer) 81 return -ENOMEM; 82 83 adis->buffer = kcalloc(indio_dev->scan_bytes, 2, GFP_KERNEL); 84 if (!adis->buffer) { 85 kfree(adis->xfer); 86 adis->xfer = NULL; 87 return -ENOMEM; 88 } 89 90 rx = adis->buffer; 91 tx = rx + scan_count; 92 93 spi_message_init(&adis->msg); 94 95 for (j = 0; j <= scan_count; j++) { 96 adis->xfer[j].bits_per_word = 8; 97 if (j != scan_count) 98 adis->xfer[j].cs_change = 1; 99 adis->xfer[j].len = 2; 100 adis->xfer[j].delay.value = adis->data->read_delay; 101 adis->xfer[j].delay.unit = SPI_DELAY_UNIT_USECS; 102 if (j < scan_count) 103 adis->xfer[j].tx_buf = &tx[j]; 104 if (j >= 1) 105 adis->xfer[j].rx_buf = &rx[j - 1]; 106 spi_message_add_tail(&adis->xfer[j], &adis->msg); 107 } 108 109 chan = indio_dev->channels; 110 for (i = 0; i < indio_dev->num_channels; i++, chan++) { 111 if (!test_bit(chan->scan_index, scan_mask)) 112 continue; 113 if (chan->scan_type.storagebits == 32) 114 *tx++ = cpu_to_be16((chan->address + 2) << 8); 115 *tx++ = cpu_to_be16(chan->address << 8); 116 } 117 118 return 0; 119 } 120 EXPORT_SYMBOL_GPL(adis_update_scan_mode); 121 122 static irqreturn_t adis_trigger_handler(int irq, void *p) 123 { 124 struct iio_poll_func *pf = p; 125 struct iio_dev *indio_dev = pf->indio_dev; 126 struct adis *adis = iio_device_get_drvdata(indio_dev); 127 int ret; 128 129 if (!adis->buffer) 130 return -ENOMEM; 131 132 if (adis->data->has_paging) { 133 mutex_lock(&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 spi_write(adis->spi, adis->tx, 2); 138 } 139 } 140 141 ret = spi_sync(adis->spi, &adis->msg); 142 if (ret) 143 dev_err(&adis->spi->dev, "Failed to read data: %d", ret); 144 145 146 if (adis->data->has_paging) { 147 adis->current_page = 0; 148 mutex_unlock(&adis->state_lock); 149 } 150 151 iio_push_to_buffers_with_timestamp(indio_dev, adis->buffer, 152 pf->timestamp); 153 154 iio_trigger_notify_done(indio_dev->trig); 155 156 return IRQ_HANDLED; 157 } 158 159 /** 160 * adis_setup_buffer_and_trigger() - Sets up buffer and trigger for the adis device 161 * @adis: The adis device. 162 * @indio_dev: The IIO device. 163 * @trigger_handler: Optional trigger handler, may be NULL. 164 * 165 * Returns 0 on success, a negative error code otherwise. 166 * 167 * This function sets up the buffer and trigger for a adis devices. If 168 * 'trigger_handler' is NULL the default trigger handler will be used. The 169 * default trigger handler will simply read the registers assigned to the 170 * currently active channels. 171 * 172 * adis_cleanup_buffer_and_trigger() should be called to free the resources 173 * allocated by this function. 174 */ 175 int adis_setup_buffer_and_trigger(struct adis *adis, struct iio_dev *indio_dev, 176 irqreturn_t (*trigger_handler)(int, void *)) 177 { 178 int ret; 179 180 if (!trigger_handler) 181 trigger_handler = adis_trigger_handler; 182 183 ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time, 184 trigger_handler, NULL); 185 if (ret) 186 return ret; 187 188 if (adis->spi->irq) { 189 ret = adis_probe_trigger(adis, indio_dev); 190 if (ret) 191 goto error_buffer_cleanup; 192 } 193 return 0; 194 195 error_buffer_cleanup: 196 iio_triggered_buffer_cleanup(indio_dev); 197 return ret; 198 } 199 EXPORT_SYMBOL_GPL(adis_setup_buffer_and_trigger); 200 201 /** 202 * adis_cleanup_buffer_and_trigger() - Free buffer and trigger resources 203 * @adis: The adis device. 204 * @indio_dev: The IIO device. 205 * 206 * Frees resources allocated by adis_setup_buffer_and_trigger() 207 */ 208 void adis_cleanup_buffer_and_trigger(struct adis *adis, 209 struct iio_dev *indio_dev) 210 { 211 if (adis->spi->irq) 212 adis_remove_trigger(adis); 213 kfree(adis->buffer); 214 kfree(adis->xfer); 215 iio_triggered_buffer_cleanup(indio_dev); 216 } 217 EXPORT_SYMBOL_GPL(adis_cleanup_buffer_and_trigger); 218