Merge tag 'staging-3.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging

Pull staging driver tree merge from Greg Kroah-Hartman:
 "Here's the big staging tree merge for 3.8-rc1

  There's a lot of patches in here, the majority being the comedi
  rework/cleanup that has been ongoing and is causing a huge reduction
  in overall code size, which is amazing to watch.  We also removed some
  older drivers (telephony and rts_pstor), and added a new one (fwserial
  which also came in through the tty tree due to tty api changes, take
  that one if you get merge conflicts.)

  The iio and ipack drivers are moving out of the staging area into
  their own part of the kernel as they have been cleaned up sufficiently
  and are working well.

  Overall, again a reduction of code:
   768 files changed, 31887 insertions(+), 82166 deletions(-)

  All of this has been in the linux-next tree for a while.

  Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>"

* tag 'staging-3.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (1298 commits)
  iio: imu: adis16480: remove duplicated include from adis16480.c
  iio: gyro: adis16136: remove duplicated include from adis16136.c
  iio:imu: adis16480: show_firmware() buffer too small
  iio:gyro: adis16136: divide by zero in write_frequency()
  iio: adc: Add Texas Instruments ADC081C021/027 support
  iio:ad7793: Add support for the ad7796 and ad7797
  iio:ad7793: Add support for the ad7798 and ad7799
  staging:iio: Move ad7793 driver out of staging
  staging:iio:ad7793: Implement stricter id checking
  staging:iio:ad7793: Move register definitions from header to source
  staging:iio:ad7793: Rework regulator handling
  staging:iio:ad7793: Rework platform data
  staging:iio:ad7793: Use kstrtol instead of strict_strtol
  staging:iio:ad7793: Use usleep_range instead of msleep
  staging:iio:ad7793: Fix temperature scale
  staging:iio:ad7793: Fix VDD monitor scale
  staging: gdm72xx: unlock on error in init_usb()
  staging: panel: pass correct lengths to keypad_send_key()
  staging: comedi: addi_apci_2032: fix interrupt support
  staging: comedi: addi_apci_2032: move i_APCI2032_ConfigDigitalOutput()
  ...

1 files changed, 72 insertions, 424 deletions

diff --git a/drivers/staging/iio/accel/adis16209_core.c b/drivers/staging/iio/accel/adis16209_core.c
index 7ee974b45d7..69c50ee44ce 100644
--- a/drivers/staging/iio/accel/adis16209_core.c
+++ b/drivers/staging/iio/accel/adis16209_core.c
@@ -19,262 +19,19 @@
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
+#include <linux/iio/imu/adis.h>
 
 #include "adis16209.h"
 
-#define DRIVER_NAME             "adis16209"
-
-/**
- * adis16209_spi_write_reg_8() - write single byte to a register
- * @indio_dev: iio device associated with actual device
- * @reg_address: the address of the register to be written
- * @val: the value to write
- **/
-static int adis16209_spi_write_reg_8(struct iio_dev *indio_dev,
-                                     u8 reg_address,
-                                     u8 val)
-{
-        int ret;
-        struct adis16209_state *st = iio_priv(indio_dev);
-
-        mutex_lock(&st->buf_lock);
-        st->tx[0] = ADIS16209_WRITE_REG(reg_address);
-        st->tx[1] = val;
-
-        ret = spi_write(st->us, st->tx, 2);
-        mutex_unlock(&st->buf_lock);
-
-        return ret;
-}
-
-/**
- * adis16209_spi_write_reg_16() - write 2 bytes to a pair of registers
- * @indio_dev: iio device associated actual device
- * @reg_address: the address of the lower of the two registers. Second register
- *               is assumed to have address one greater.
- * @val: value to be written
- **/
-static int adis16209_spi_write_reg_16(struct iio_dev *indio_dev,
-                                      u8 lower_reg_address,
-                                      u16 value)
-{
-        int ret;
-        struct spi_message msg;
-        struct adis16209_state *st = iio_priv(indio_dev);
-        struct spi_transfer xfers[] = {
-                {
-                        .tx_buf = st->tx,
-                        .bits_per_word = 8,
-                        .len = 2,
-                        .cs_change = 1,
-                        .delay_usecs = 30,
-                }, {
-                        .tx_buf = st->tx + 2,
-                        .bits_per_word = 8,
-                        .len = 2,
-                        .delay_usecs = 30,
-                },
-        };
-
-        mutex_lock(&st->buf_lock);
-        st->tx[0] = ADIS16209_WRITE_REG(lower_reg_address);
-        st->tx[1] = value & 0xFF;
-        st->tx[2] = ADIS16209_WRITE_REG(lower_reg_address + 1);
-        st->tx[3] = (value >> 8) & 0xFF;
-
-        spi_message_init(&msg);
-        spi_message_add_tail(&xfers[0], &msg);
-        spi_message_add_tail(&xfers[1], &msg);
-        ret = spi_sync(st->us, &msg);
-        mutex_unlock(&st->buf_lock);
-
-        return ret;
-}
-
-/**
- * adis16209_spi_read_reg_16() - read 2 bytes from a 16-bit register
- * @indio_dev: iio device associated with device
- * @reg_address: the address of the lower of the two registers. Second register
- *               is assumed to have address one greater.
- * @val: somewhere to pass back the value read
- **/
-static int adis16209_spi_read_reg_16(struct iio_dev *indio_dev,
-                                     u8 lower_reg_address,
-                                     u16 *val)
-{
-        struct spi_message msg;
-        struct adis16209_state *st = iio_priv(indio_dev);
-        int ret;
-        struct spi_transfer xfers[] = {
-                {
-                        .tx_buf = st->tx,
-                        .bits_per_word = 8,
-                        .len = 2,
-                        .cs_change = 1,
-                        .delay_usecs = 30,
-                }, {
-                        .rx_buf = st->rx,
-                        .bits_per_word = 8,
-                        .len = 2,
-                        .delay_usecs = 30,
-                },
-        };
-
-        mutex_lock(&st->buf_lock);
-        st->tx[0] = ADIS16209_READ_REG(lower_reg_address);
-        st->tx[1] = 0;
-
-        spi_message_init(&msg);
-        spi_message_add_tail(&xfers[0], &msg);
-        spi_message_add_tail(&xfers[1], &msg);
-        ret = spi_sync(st->us, &msg);
-        if (ret) {
-                dev_err(&st->us->dev,
-                        "problem when reading 16 bit register 0x%02X",
-                        lower_reg_address);
-                goto error_ret;
-        }
-        *val = (st->rx[0] << 8) | st->rx[1];
-
-error_ret:
-        mutex_unlock(&st->buf_lock);
-        return ret;
-}
-
-static int adis16209_reset(struct iio_dev *indio_dev)
-{
-        int ret;
-        ret = adis16209_spi_write_reg_8(indio_dev,
-                        ADIS16209_GLOB_CMD,
-                        ADIS16209_GLOB_CMD_SW_RESET);
-        if (ret)
-                dev_err(&indio_dev->dev, "problem resetting device");
-
-        return ret;
-}
-
-int adis16209_set_irq(struct iio_dev *indio_dev, bool enable)
-{
-        int ret = 0;
-        u16 msc;
-
-        ret = adis16209_spi_read_reg_16(indio_dev, ADIS16209_MSC_CTRL, &msc);
-        if (ret)
-                goto error_ret;
-
-        msc |= ADIS16209_MSC_CTRL_ACTIVE_HIGH;
-        msc &= ~ADIS16209_MSC_CTRL_DATA_RDY_DIO2;
-        if (enable)
-                msc |= ADIS16209_MSC_CTRL_DATA_RDY_EN;
-        else
-                msc &= ~ADIS16209_MSC_CTRL_DATA_RDY_EN;
-
-        ret = adis16209_spi_write_reg_16(indio_dev, ADIS16209_MSC_CTRL, msc);
-
-error_ret:
-        return ret;
-}
-
-static int adis16209_check_status(struct iio_dev *indio_dev)
-{
-        u16 status;
-        int ret;
-
-        ret = adis16209_spi_read_reg_16(indio_dev,
-                                        ADIS16209_DIAG_STAT, &status);
-        if (ret < 0) {
-                dev_err(&indio_dev->dev, "Reading status failed\n");
-                goto error_ret;
-        }
-        ret = status & 0x1F;
-
-        if (status & ADIS16209_DIAG_STAT_SELFTEST_FAIL)
-                dev_err(&indio_dev->dev, "Self test failure\n");
-        if (status & ADIS16209_DIAG_STAT_SPI_FAIL)
-                dev_err(&indio_dev->dev, "SPI failure\n");
-        if (status & ADIS16209_DIAG_STAT_FLASH_UPT)
-                dev_err(&indio_dev->dev, "Flash update failed\n");
-        if (status & ADIS16209_DIAG_STAT_POWER_HIGH)
-                dev_err(&indio_dev->dev, "Power supply above 3.625V\n");
-        if (status & ADIS16209_DIAG_STAT_POWER_LOW)
-                dev_err(&indio_dev->dev, "Power supply below 3.15V\n");
-
-error_ret:
-        return ret;
-}
-
-static int adis16209_self_test(struct iio_dev *indio_dev)
-{
-        int ret;
-        ret = adis16209_spi_write_reg_16(indio_dev,
-                        ADIS16209_MSC_CTRL,
-                        ADIS16209_MSC_CTRL_SELF_TEST_EN);
-        if (ret) {
-                dev_err(&indio_dev->dev, "problem starting self test");
-                goto err_ret;
-        }
-
-        adis16209_check_status(indio_dev);
-
-err_ret:
-        return ret;
-}
-
-static int adis16209_initial_setup(struct iio_dev *indio_dev)
-{
-        int ret;
-
-        /* Disable IRQ */
-        ret = adis16209_set_irq(indio_dev, false);
-        if (ret) {
-                dev_err(&indio_dev->dev, "disable irq failed");
-                goto err_ret;
-        }
-
-        /* Do self test */
-        ret = adis16209_self_test(indio_dev);
-        if (ret) {
-                dev_err(&indio_dev->dev, "self test failure");
-                goto err_ret;
-        }
-
-        /* Read status register to check the result */
-        ret = adis16209_check_status(indio_dev);
-        if (ret) {
-                adis16209_reset(indio_dev);
-                dev_err(&indio_dev->dev, "device not playing ball -> reset");
-                msleep(ADIS16209_STARTUP_DELAY);
-                ret = adis16209_check_status(indio_dev);
-                if (ret) {
-                        dev_err(&indio_dev->dev, "giving up");
-                        goto err_ret;
-                }
-        }
-
-err_ret:
-        return ret;
-}
-
-enum adis16209_chan {
-        in_supply,
-        temp,
-        accel_x,
-        accel_y,
-        incli_x,
-        incli_y,
-        in_aux,
-        rot,
-};
-
-static const u8 adis16209_addresses[8][2] = {
-        [in_supply] = { ADIS16209_SUPPLY_OUT },
-        [in_aux] = { ADIS16209_AUX_ADC },
-        [accel_x] = { ADIS16209_XACCL_OUT, ADIS16209_XACCL_NULL },
-        [accel_y] = { ADIS16209_YACCL_OUT, ADIS16209_YACCL_NULL },
-        [incli_x] = { ADIS16209_XINCL_OUT, ADIS16209_XINCL_NULL },
-        [incli_y] = { ADIS16209_YINCL_OUT, ADIS16209_YINCL_NULL },
-        [rot] = { ADIS16209_ROT_OUT },
-        [temp] = { ADIS16209_TEMP_OUT },
+static const u8 adis16209_addresses[8][1] = {
+        [ADIS16209_SCAN_SUPPLY] = { },
+        [ADIS16209_SCAN_AUX_ADC] = { },
+        [ADIS16209_SCAN_ACC_X] = { ADIS16209_XACCL_NULL },
+        [ADIS16209_SCAN_ACC_Y] = { ADIS16209_YACCL_NULL },
+        [ADIS16209_SCAN_INCLI_X] = { ADIS16209_XINCL_NULL },
+        [ADIS16209_SCAN_INCLI_Y] = { ADIS16209_YINCL_NULL },
+        [ADIS16209_SCAN_ROT] = { },
+        [ADIS16209_SCAN_TEMP] = { },
 };
 
 static int adis16209_write_raw(struct iio_dev *indio_dev,
@@ -283,6 +40,7 @@ static int adis16209_write_raw(struct iio_dev *indio_dev,
                                int val2,
                                long mask)
 {
+        struct adis *st = iio_priv(indio_dev);
         int bits;
         s16 val16;
         u8 addr;
@@ -295,10 +53,10 @@ static int adis16209_write_raw(struct iio_dev *indio_dev,
                         break;
                 default:
                         return -EINVAL;
-                };
+                }
                 val16 = val & ((1 << bits) - 1);
-                addr = adis16209_addresses[chan->address][1];
-                return adis16209_spi_write_reg_16(indio_dev, addr, val16);
+                addr = adis16209_addresses[chan->scan_index][0];
+                return adis_write_reg_16(st, addr, val16);
         }
         return -EINVAL;
 }
@@ -308,6 +66,7 @@ static int adis16209_read_raw(struct iio_dev *indio_dev,
                               int *val, int *val2,
                               long mask)
 {
+        struct adis *st = iio_priv(indio_dev);
         int ret;
         int bits;
         u8 addr;
@@ -315,29 +74,8 @@ static int adis16209_read_raw(struct iio_dev *indio_dev,
 
         switch (mask) {
         case IIO_CHAN_INFO_RAW:
-                mutex_lock(&indio_dev->mlock);
-                addr = adis16209_addresses[chan->address][0];
-                ret = adis16209_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret) {
-                        mutex_unlock(&indio_dev->mlock);
-                        return ret;
-                }
-
-                if (val16 & ADIS16209_ERROR_ACTIVE) {
-                        ret = adis16209_check_status(indio_dev);
-                        if (ret) {
-                                mutex_unlock(&indio_dev->mlock);
-                                return ret;
-                        }
-                }
-                val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
-                if (chan->scan_type.sign == 's')
-                        val16 = (s16)(val16 <<
-                                      (16 - chan->scan_type.realbits)) >>
-                                (16 - chan->scan_type.realbits);
-                *val = val16;
-                mutex_unlock(&indio_dev->mlock);
-                return IIO_VAL_INT;
+                return adis_single_conversion(indio_dev, chan,
+                        ADIS16209_ERROR_ACTIVE, val);
         case IIO_CHAN_INFO_SCALE:
                 switch (chan->type) {
                 case IIO_VOLTAGE:
@@ -374,10 +112,10 @@ static int adis16209_read_raw(struct iio_dev *indio_dev,
                         break;
                 default:
                         return -EINVAL;
-                };
+                }
                 mutex_lock(&indio_dev->mlock);
-                addr = adis16209_addresses[chan->address][1];
-                ret = adis16209_spi_read_reg_16(indio_dev, addr, &val16);
+                addr = adis16209_addresses[chan->scan_index][0];
+                ret = adis_read_reg_16(st, addr, &val16);
                 if (ret) {
                         mutex_unlock(&indio_dev->mlock);
                         return ret;
@@ -392,128 +130,56 @@ static int adis16209_read_raw(struct iio_dev *indio_dev,
 }
 
 static const struct iio_chan_spec adis16209_channels[] = {
-        {
-                .type = IIO_VOLTAGE,
-                .indexed = 1,
-                .channel = 0,
-                .extend_name = "supply",
-                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
-                IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
-                .address = in_supply,
-                .scan_index = ADIS16209_SCAN_SUPPLY,
-                .scan_type = {
-                        .sign = 'u',
-                        .realbits = 14,
-                        .storagebits = 16,
-                },
-        }, {
-                .type = IIO_TEMP,
-                .indexed = 0,
-                .channel = 0,
-                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
-                IIO_CHAN_INFO_SCALE_SEPARATE_BIT |
-                IIO_CHAN_INFO_OFFSET_SEPARATE_BIT,
-                .address = temp,
-                .scan_index = ADIS16209_SCAN_TEMP,
-                .scan_type = {
-                        .sign = 'u',
-                        .realbits = 12,
-                        .storagebits = 16,
-                },
-        }, {
-                .type = IIO_ACCEL,
-                .modified = 1,
-                .channel2 = IIO_MOD_X,
-                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
-                IIO_CHAN_INFO_SCALE_SHARED_BIT |
-                IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT,
-                .address = accel_x,
-                .scan_index = ADIS16209_SCAN_ACC_X,
-                .scan_type = {
-                        .sign = 's',
-                        .realbits = 14,
-                        .storagebits = 16,
-                },
-        }, {
-                .type = IIO_ACCEL,
-                .modified = 1,
-                .channel2 = IIO_MOD_Y,
-                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
-                IIO_CHAN_INFO_SCALE_SHARED_BIT |
-                IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT,
-                .address = accel_y,
-                .scan_index = ADIS16209_SCAN_ACC_Y,
-                .scan_type = {
-                        .sign = 's',
-                        .realbits = 14,
-                        .storagebits = 16,
-                },
-        }, {
-                .type = IIO_VOLTAGE,
-                .indexed = 1,
-                .channel = 1,
-                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
-                IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
-                .address = in_aux,
-                .scan_index = ADIS16209_SCAN_AUX_ADC,
-                .scan_type = {
-                        .sign = 'u',
-                        .realbits = 12,
-                        .storagebits = 16,
-                },
-        }, {
-                .type = IIO_INCLI,
-                .modified = 1,
-                .channel2 = IIO_MOD_X,
-                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
-                IIO_CHAN_INFO_SCALE_SHARED_BIT,
-                .address = incli_x,
-                .scan_index = ADIS16209_SCAN_INCLI_X,
-                .scan_type = {
-                        .sign = 's',
-                        .realbits = 14,
-                        .storagebits = 16,
-                },
-        }, {
-                .type = IIO_INCLI,
-                .modified = 1,
-                .channel2 = IIO_MOD_Y,
-                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
-                IIO_CHAN_INFO_SCALE_SHARED_BIT,
-                .address = incli_y,
-                .scan_index = ADIS16209_SCAN_INCLI_Y,
-                .scan_type = {
-                        .sign = 's',
-                        .realbits = 14,
-                        .storagebits = 16,
-                },
-        }, {
-                .type = IIO_ROT,
-                .modified = 1,
-                .channel2 = IIO_MOD_X,
-                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT,
-                IIO_CHAN_INFO_SCALE_SHARED_BIT,
-                .address = rot,
-                .scan_index = ADIS16209_SCAN_ROT,
-                .scan_type = {
-                        .sign = 's',
-                        .realbits = 14,
-                        .storagebits = 16,
-                },
-        },
+        ADIS_SUPPLY_CHAN(ADIS16209_SUPPLY_OUT, ADIS16209_SCAN_SUPPLY, 14),
+        ADIS_TEMP_CHAN(ADIS16209_TEMP_OUT, ADIS16209_SCAN_TEMP, 12),
+        ADIS_ACCEL_CHAN(X, ADIS16209_XACCL_OUT, ADIS16209_SCAN_ACC_X,
+                IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, 14),
+        ADIS_ACCEL_CHAN(Y, ADIS16209_YACCL_OUT, ADIS16209_SCAN_ACC_Y,
+                IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, 14),
+        ADIS_AUX_ADC_CHAN(ADIS16209_AUX_ADC, ADIS16209_SCAN_AUX_ADC, 12),
+        ADIS_INCLI_CHAN(X, ADIS16209_XINCL_OUT, ADIS16209_SCAN_INCLI_X, 0, 14),
+        ADIS_INCLI_CHAN(Y, ADIS16209_YINCL_OUT, ADIS16209_SCAN_INCLI_Y, 0, 14),
+        ADIS_ROT_CHAN(X, ADIS16209_ROT_OUT, ADIS16209_SCAN_ROT, 0, 14),
         IIO_CHAN_SOFT_TIMESTAMP(8)
 };
 
 static const struct iio_info adis16209_info = {
         .read_raw = &adis16209_read_raw,
         .write_raw = &adis16209_write_raw,
+        .update_scan_mode = adis_update_scan_mode,
         .driver_module = THIS_MODULE,
 };
 
-static int __devinit adis16209_probe(struct spi_device *spi)
+static const char * const adis16209_status_error_msgs[] = {
+        [ADIS16209_DIAG_STAT_SELFTEST_FAIL_BIT] = "Self test failure",
+        [ADIS16209_DIAG_STAT_SPI_FAIL_BIT] = "SPI failure",
+        [ADIS16209_DIAG_STAT_FLASH_UPT_BIT] = "Flash update failed",
+        [ADIS16209_DIAG_STAT_POWER_HIGH_BIT] = "Power supply above 3.625V",
+        [ADIS16209_DIAG_STAT_POWER_LOW_BIT] = "Power supply below 3.15V",
+};
+
+static const struct adis_data adis16209_data = {
+        .read_delay = 30,
+        .msc_ctrl_reg = ADIS16209_MSC_CTRL,
+        .glob_cmd_reg = ADIS16209_GLOB_CMD,
+        .diag_stat_reg = ADIS16209_DIAG_STAT,
+
+        .self_test_mask = ADIS16209_MSC_CTRL_SELF_TEST_EN,
+        .startup_delay = ADIS16209_STARTUP_DELAY,
+
+        .status_error_msgs = adis16209_status_error_msgs,
+        .status_error_mask = BIT(ADIS16209_DIAG_STAT_SELFTEST_FAIL_BIT) |
+                BIT(ADIS16209_DIAG_STAT_SPI_FAIL_BIT) |
+                BIT(ADIS16209_DIAG_STAT_FLASH_UPT_BIT) |
+                BIT(ADIS16209_DIAG_STAT_POWER_HIGH_BIT) |
+                BIT(ADIS16209_DIAG_STAT_POWER_LOW_BIT),
+};
+
+
+static int adis16209_probe(struct spi_device *spi)
 {
         int ret;
-        struct adis16209_state *st;
+        struct adis *st;
         struct iio_dev *indio_dev;
 
         /* setup the industrialio driver allocated elements */
@@ -525,8 +191,6 @@ static int __devinit adis16209_probe(struct spi_device *spi)
         st = iio_priv(indio_dev);
         /* this is only used for removal purposes */
         spi_set_drvdata(spi, indio_dev);
-        st->us = spi;
-        mutex_init(&st->buf_lock);
 
         indio_dev->name = spi->dev.driver->name;
         indio_dev->dev.parent = &spi->dev;
@@ -535,54 +199,38 @@ static int __devinit adis16209_probe(struct spi_device *spi)
         indio_dev->num_channels = ARRAY_SIZE(adis16209_channels);
         indio_dev->modes = INDIO_DIRECT_MODE;
 
-        ret = adis16209_configure_ring(indio_dev);
+        ret = adis_init(st, indio_dev, spi, &adis16209_data);
+        if (ret)
+                goto error_free_dev;
+        ret = adis_setup_buffer_and_trigger(st, indio_dev, NULL);
         if (ret)
                 goto error_free_dev;
-
-        ret = iio_buffer_register(indio_dev,
-                                  adis16209_channels,
-                                  ARRAY_SIZE(adis16209_channels));
-        if (ret) {
-                printk(KERN_ERR "failed to initialize the ring\n");
-                goto error_unreg_ring_funcs;
-        }
-
-        if (spi->irq) {
-                ret = adis16209_probe_trigger(indio_dev);
-                if (ret)
-                        goto error_uninitialize_ring;
-        }
 
         /* Get the device into a sane initial state */
-        ret = adis16209_initial_setup(indio_dev);
+        ret = adis_initial_startup(st);
         if (ret)
-                goto error_remove_trigger;
+                goto error_cleanup_buffer_trigger;
         ret = iio_device_register(indio_dev);
         if (ret)
-                goto error_remove_trigger;
+                goto error_cleanup_buffer_trigger;
 
         return 0;
 
-error_remove_trigger:
-        adis16209_remove_trigger(indio_dev);
-error_uninitialize_ring:
-        iio_buffer_unregister(indio_dev);
-error_unreg_ring_funcs:
-        adis16209_unconfigure_ring(indio_dev);
+error_cleanup_buffer_trigger:
+        adis_cleanup_buffer_and_trigger(st, indio_dev);
 error_free_dev:
         iio_device_free(indio_dev);
 error_ret:
         return ret;
 }
 
-static int __devexit adis16209_remove(struct spi_device *spi)
+static int adis16209_remove(struct spi_device *spi)
 {
         struct iio_dev *indio_dev = spi_get_drvdata(spi);
+        struct adis *st = iio_priv(indio_dev);
 
         iio_device_unregister(indio_dev);
-        adis16209_remove_trigger(indio_dev);
-        iio_buffer_unregister(indio_dev);
-        adis16209_unconfigure_ring(indio_dev);
+        adis_cleanup_buffer_and_trigger(st, indio_dev);
         iio_device_free(indio_dev);
 
         return 0;
@@ -594,7 +242,7 @@ static struct spi_driver adis16209_driver = {
                 .owner = THIS_MODULE,
         },
         .probe = adis16209_probe,
-        .remove = __devexit_p(adis16209_remove),
+        .remove = adis16209_remove,
 };
 module_spi_driver(adis16209_driver);