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

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

  Lots of cleanups and updates for drivers all through the staging tree.
  We are pretty much "code neutral" here, adding just about as many
  lines as we removed.

  All of these have been in linux-next for a while."

* tag 'staging-3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (804 commits)
  staging: comedi: vmk80xx: wait for URBs to complete
  staging: comedi: drivers: addi-data: hwdrv_apci3200.c: Add a missing semicolon
  staging: et131x: Update TODO list
  staging: et131x: Remove assignment of skb->dev
  staging: wlan-ng: hfa384x.h: fix for error reported by smatch
  staging/zache checkpatch ERROR: spaces prohibited around that
  staging/ozwpan: Mark read only parameters and structs as const
  staging/ozwpan: Remove empty and unused function oz_cdev_heartbeat
  staging/ozwpan: Mark local functions as static (fix sparse warnings)
  staging/ozwpan: Add missing header includes
  staging/usbip: Mark local functions as static (fix sparse warnings)
  staging/xgifb: Remove duplicated code in loops.
  staging/xgifb: Consolidate return paths
  staging/xgifb: Remove code without effect
  staging/xgifb: Remove unnecessary casts
  staging/xgifb: Consolidate if/else if with identical code branches
  staging: vt6656: replaced custom TRUE definition with true
  staging: vt6656: replaced custom FALSE definition with false
  staging: vt6656: replace custom BOOL definition with bool
  staging/rtl8187se: Mark functions as static to silence sparse
  ...

1 files changed, 287 insertions, 0 deletions

diff --git a/drivers/iio/accel/kxsd9.c b/drivers/iio/accel/kxsd9.c
new file mode 100644
index 000000000000..c2229a521ab9
--- /dev/null
+++ b/drivers/iio/accel/kxsd9.c
@@ -0,0 +1,287 @@
+/*
+ * kxsd9.c      simple support for the Kionix KXSD9 3D
+ *              accelerometer.
+ *
+ * Copyright (c) 2008-2009 Jonathan Cameron <jic23@kernel.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * The i2c interface is very similar, so shouldn't be a problem once
+ * I have a suitable wire made up.
+ *
+ * TODO:        Support the motion detector
+ *              Uses register address incrementing so could have a
+ *              heavily optimized ring buffer access function.
+ */
+
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/sysfs.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define KXSD9_REG_X             0x00
+#define KXSD9_REG_Y             0x02
+#define KXSD9_REG_Z             0x04
+#define KXSD9_REG_AUX           0x06
+#define KXSD9_REG_RESET         0x0a
+#define KXSD9_REG_CTRL_C        0x0c
+
+#define KXSD9_FS_MASK           0x03
+
+#define KXSD9_REG_CTRL_B        0x0d
+#define KXSD9_REG_CTRL_A        0x0e
+
+#define KXSD9_READ(a) (0x80 | (a))
+#define KXSD9_WRITE(a) (a)
+
+#define KXSD9_STATE_RX_SIZE 2
+#define KXSD9_STATE_TX_SIZE 2
+/**
+ * struct kxsd9_state - device related storage
+ * @buf_lock:   protect the rx and tx buffers.
+ * @us:         spi device
+ * @rx:         single rx buffer storage
+ * @tx:         single tx buffer storage
+ **/
+struct kxsd9_state {
+        struct mutex buf_lock;
+        struct spi_device *us;
+        u8 rx[KXSD9_STATE_RX_SIZE] ____cacheline_aligned;
+        u8 tx[KXSD9_STATE_TX_SIZE];
+};
+
+#define KXSD9_SCALE_2G "0.011978"
+#define KXSD9_SCALE_4G "0.023927"
+#define KXSD9_SCALE_6G "0.035934"
+#define KXSD9_SCALE_8G "0.047853"
+
+/* reverse order */
+static const int kxsd9_micro_scales[4] = { 47853, 35934, 23927, 11978 };
+
+static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro)
+{
+        int ret, i;
+        struct kxsd9_state *st = iio_priv(indio_dev);
+        bool foundit = false;
+
+        for (i = 0; i < 4; i++)
+                if (micro == kxsd9_micro_scales[i]) {
+                        foundit = true;
+                        break;
+                }
+        if (!foundit)
+                return -EINVAL;
+
+        mutex_lock(&st->buf_lock);
+        ret = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
+        if (ret)
+                goto error_ret;
+        st->tx[0] = KXSD9_WRITE(KXSD9_REG_CTRL_C);
+        st->tx[1] = (ret & ~KXSD9_FS_MASK) | i;
+
+        ret = spi_write(st->us, st->tx, 2);
+error_ret:
+        mutex_unlock(&st->buf_lock);
+        return ret;
+}
+
+static int kxsd9_read(struct iio_dev *indio_dev, u8 address)
+{
+        int ret;
+        struct kxsd9_state *st = iio_priv(indio_dev);
+        struct spi_transfer xfers[] = {
+                {
+                        .bits_per_word = 8,
+                        .len = 1,
+                        .delay_usecs = 200,
+                        .tx_buf = st->tx,
+                }, {
+                        .bits_per_word = 8,
+                        .len = 2,
+                        .rx_buf = st->rx,
+                },
+        };
+
+        mutex_lock(&st->buf_lock);
+        st->tx[0] = KXSD9_READ(address);
+        ret = spi_sync_transfer(st->us, xfers, ARRAY_SIZE(xfers));
+        if (ret)
+                return ret;
+        return (((u16)(st->rx[0])) << 8) | (st->rx[1] & 0xF0);
+}
+
+static IIO_CONST_ATTR(accel_scale_available,
+                KXSD9_SCALE_2G " "
+                KXSD9_SCALE_4G " "
+                KXSD9_SCALE_6G " "
+                KXSD9_SCALE_8G);
+
+static struct attribute *kxsd9_attributes[] = {
+        &iio_const_attr_accel_scale_available.dev_attr.attr,
+        NULL,
+};
+
+static int kxsd9_write_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan,
+                           int val,
+                           int val2,
+                           long mask)
+{
+        int ret = -EINVAL;
+
+        if (mask == IIO_CHAN_INFO_SCALE) {
+                /* Check no integer component */
+                if (val)
+                        return -EINVAL;
+                ret = kxsd9_write_scale(indio_dev, val2);
+        }
+
+        return ret;
+}
+
+static int kxsd9_read_raw(struct iio_dev *indio_dev,
+                          struct iio_chan_spec const *chan,
+                          int *val, int *val2, long mask)
+{
+        int ret = -EINVAL;
+        struct kxsd9_state *st = iio_priv(indio_dev);
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                ret = kxsd9_read(indio_dev, chan->address);
+                if (ret < 0)
+                        goto error_ret;
+                *val = ret;
+                break;
+        case IIO_CHAN_INFO_SCALE:
+                ret = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
+                if (ret)
+                        goto error_ret;
+                *val2 = kxsd9_micro_scales[ret & KXSD9_FS_MASK];
+                ret = IIO_VAL_INT_PLUS_MICRO;
+                break;
+        }
+
+error_ret:
+        return ret;
+};
+#define KXSD9_ACCEL_CHAN(axis)                                          \
+        {                                                               \
+                .type = IIO_ACCEL,                                      \
+                .modified = 1,                                          \
+                .channel2 = IIO_MOD_##axis,                             \
+                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |           \
+                        IIO_CHAN_INFO_SCALE_SHARED_BIT,                 \
+                .address = KXSD9_REG_##axis,                            \
+        }
+
+static const struct iio_chan_spec kxsd9_channels[] = {
+        KXSD9_ACCEL_CHAN(X), KXSD9_ACCEL_CHAN(Y), KXSD9_ACCEL_CHAN(Z),
+        {
+                .type = IIO_VOLTAGE,
+                .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT,
+                .indexed = 1,
+                .address = KXSD9_REG_AUX,
+        }
+};
+
+static const struct attribute_group kxsd9_attribute_group = {
+        .attrs = kxsd9_attributes,
+};
+
+static int kxsd9_power_up(struct kxsd9_state *st)
+{
+        int ret;
+
+        st->tx[0] = 0x0d;
+        st->tx[1] = 0x40;
+        ret = spi_write(st->us, st->tx, 2);
+        if (ret)
+                return ret;
+
+        st->tx[0] = 0x0c;
+        st->tx[1] = 0x9b;
+        return spi_write(st->us, st->tx, 2);
+};
+
+static const struct iio_info kxsd9_info = {
+        .read_raw = &kxsd9_read_raw,
+        .write_raw = &kxsd9_write_raw,
+        .attrs = &kxsd9_attribute_group,
+        .driver_module = THIS_MODULE,
+};
+
+static int kxsd9_probe(struct spi_device *spi)
+{
+        struct iio_dev *indio_dev;
+        struct kxsd9_state *st;
+        int ret;
+
+        indio_dev = iio_device_alloc(sizeof(*st));
+        if (indio_dev == NULL) {
+                ret = -ENOMEM;
+                goto error_ret;
+        }
+        st = iio_priv(indio_dev);
+        spi_set_drvdata(spi, indio_dev);
+
+        st->us = spi;
+        mutex_init(&st->buf_lock);
+        indio_dev->channels = kxsd9_channels;
+        indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels);
+        indio_dev->name = spi_get_device_id(spi)->name;
+        indio_dev->dev.parent = &spi->dev;
+        indio_dev->info = &kxsd9_info;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+
+        spi->mode = SPI_MODE_0;
+        spi_setup(spi);
+        kxsd9_power_up(st);
+
+        ret = iio_device_register(indio_dev);
+        if (ret)
+                goto error_free_dev;
+
+        return 0;
+
+error_free_dev:
+        iio_device_free(indio_dev);
+error_ret:
+        return ret;
+}
+
+static int kxsd9_remove(struct spi_device *spi)
+{
+        iio_device_unregister(spi_get_drvdata(spi));
+        iio_device_free(spi_get_drvdata(spi));
+
+        return 0;
+}
+
+static const struct spi_device_id kxsd9_id[] = {
+        {"kxsd9", 0},
+        { },
+};
+MODULE_DEVICE_TABLE(spi, kxsd9_id);
+
+static struct spi_driver kxsd9_driver = {
+        .driver = {
+                .name = "kxsd9",
+                .owner = THIS_MODULE,
+        },
+        .probe = kxsd9_probe,
+        .remove = kxsd9_remove,
+        .id_table = kxsd9_id,
+};
+module_spi_driver(kxsd9_driver);
+
+MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
+MODULE_DESCRIPTION("Kionix KXSD9 SPI driver");
+MODULE_LICENSE("GPL v2");