402 files changed, 16906 insertions, 7314 deletions

diff --git a/Documentation/ABI/testing/configfs-iio b/Documentation/ABI/testing/configfs-iio
index 2483756fccf5..aebda53ec0f7 100644
--- a/Documentation/ABI/testing/configfs-iio
+++ b/Documentation/ABI/testing/configfs-iio
@@ -19,3 +19,16 @@ KernelVersion:	4.4
 Description:
                 High resolution timers directory. Creating a directory here
                 will result in creating a hrtimer trigger in the IIO subsystem.
+
+What:           /config/iio/devices
+Date:           April 2016
+KernelVersion:  4.7
+Description:
+                Industrial IO software devices directory.
+
+What:           /config/iio/devices/dummy
+Date:           April 2016
+KernelVersion:  4.7
+Description:
+                Dummy IIO devices directory. Creating a directory here will result
+                in creating a dummy IIO device in the IIO subystem.
diff --git a/Documentation/ABI/testing/sysfs-bus-iio b/Documentation/ABI/testing/sysfs-bus-iio
index df44998e7506..e7f590c6ef8e 100644
--- a/Documentation/ABI/testing/sysfs-bus-iio
+++ b/Documentation/ABI/testing/sysfs-bus-iio
@@ -1565,3 +1565,10 @@ Description:
                 * X is in the plane of the propellers, perpendicular to Y axis,
                   and positive towards the starboard side of the UAV ;
                 * Z is perpendicular to propellers plane and positive upwards.
+
+What:           /sys/bus/iio/devices/iio:deviceX/in_electricalconductivity_raw
+KernelVersion:  4.8
+Contact:        linux-iio@vger.kernel.org
+Description:
+                Raw (unscaled no offset etc.) electric conductivity reading that
+                can be processed to siemens per meter.
diff --git a/Documentation/ABI/testing/sysfs-bus-iio-health-afe440x b/Documentation/ABI/testing/sysfs-bus-iio-health-afe440x
index 3740f253d406..6adba9058b22 100644
--- a/Documentation/ABI/testing/sysfs-bus-iio-health-afe440x
+++ b/Documentation/ABI/testing/sysfs-bus-iio-health-afe440x
@@ -1,54 +1,41 @@
-What:           /sys/bus/iio/devices/iio:deviceX/tia_resistanceY
-                /sys/bus/iio/devices/iio:deviceX/tia_capacitanceY
-Date:           December 2015
-KernelVersion:
-Contact:        Andrew F. Davis <afd@ti.com>
-Description:
-                Get and set the resistance and the capacitance settings for the
-                Transimpedance Amplifier. Y is 1 for Rf1 and Cf1, Y is 2 for
-                Rf2 and Cf2 values.
-
-What:           /sys/bus/iio/devices/iio:deviceX/tia_separate_en
-Date:           December 2015
-KernelVersion:
-Contact:        Andrew F. Davis <afd@ti.com>
-Description:
-                Enable or disable separate settings for the TransImpedance
-                Amplifier above, when disabled both values are set by the
-                first channel.
-
-What:           /sys/bus/iio/devices/iio:deviceX/in_intensity_ledY_raw
-                /sys/bus/iio/devices/iio:deviceX/in_intensity_ledY_ambient_raw
-Date:           December 2015
+What:           /sys/bus/iio/devices/iio:deviceX/in_intensityY_raw
+Date:           May 2016
 KernelVersion:
 Contact:        Andrew F. Davis <afd@ti.com>
 Description:
                 Get measured values from the ADC for these stages. Y is the
-                specific LED number. The values are expressed in 24-bit twos
-                complement.
+                specific stage number corresponding to datasheet stage names
+                as follows:
+                1 -> LED2
+                2 -> ALED2/LED3
+                3 -> LED1
+                4 -> ALED1/LED4
+                Note that channels 5 and 6 represent LED2-ALED2 and LED1-ALED1
+                respectively which simply helper channels containing the
+                calculated difference in the value of stage 1 - 2 and 3 - 4.
+                The values are expressed in 24-bit twos complement.
 
-What:           /sys/bus/iio/devices/iio:deviceX/in_intensity_ledY-ledY_ambient_raw
-Date:           December 2015
+What:           /sys/bus/iio/devices/iio:deviceX/in_intensityY_offset
+Date:           May 2016
 KernelVersion:
 Contact:        Andrew F. Davis <afd@ti.com>
 Description:
-                Get differential values from the ADC for these stages. Y is the
-                specific LED number. The values are expressed in 24-bit twos
-                complement for the specified LEDs.
+                Get and set the offset cancellation DAC setting for these
+                stages. The values are expressed in 5-bit sign-magnitude.
 
-What:           /sys/bus/iio/devices/iio:deviceX/out_current_ledY_offset
-                /sys/bus/iio/devices/iio:deviceX/out_current_ledY_ambient_offset
-Date:           December 2015
+What:           /sys/bus/iio/devices/iio:deviceX/in_intensityY_resistance
+What:           /sys/bus/iio/devices/iio:deviceX/in_intensityY_capacitance
+Date:           May 2016
 KernelVersion:
 Contact:        Andrew F. Davis <afd@ti.com>
 Description:
-                Get and set the offset cancellation DAC setting for these
-                stages. The values are expressed in 5-bit sign-magnitude.
+                Get and set the resistance and the capacitance settings for the
+                Transimpedance Amplifier during the associated stage.
 
-What:           /sys/bus/iio/devices/iio:deviceX/out_current_ledY_raw
-Date:           December 2015
+What:           /sys/bus/iio/devices/iio:deviceX/out_currentY_raw
+Date:           May 2016
 KernelVersion:
 Contact:        Andrew F. Davis <afd@ti.com>
 Description:
-                Get and set the LED current for the specified LED. Y is the
-                specific LED number.
+                Get and set the LED current for the specified LED active during
+                this stage. Y is the specific stage number.
diff --git a/Documentation/devicetree/bindings/iio/chemical/atlas,ec-sm.txt b/Documentation/devicetree/bindings/iio/chemical/atlas,ec-sm.txt
new file mode 100644
index 000000000000..2962bd9a2b3d
--- /dev/null
+++ b/Documentation/devicetree/bindings/iio/chemical/atlas,ec-sm.txt
@@ -0,0 +1,22 @@
+* Atlas Scientific EC-SM OEM sensor
+
+http://www.atlas-scientific.com/_files/_datasheets/_oem/EC_oem_datasheet.pdf
+
+Required properties:
+
+  - compatible: must be "atlas,ec-sm"
+  - reg: the I2C address of the sensor
+  - interrupt-parent: should be the phandle for the interrupt controller
+  - interrupts: the sole interrupt generated by the device
+
+  Refer to interrupt-controller/interrupts.txt for generic interrupt client
+  node bindings.
+
+Example:
+
+atlas@64 {
+        compatible = "atlas,ec-sm";
+        reg = <0x64>;
+        interrupt-parent = <&gpio1>;
+        interrupts = <16 2>;
+};
diff --git a/Documentation/devicetree/bindings/iio/st-sensors.txt b/Documentation/devicetree/bindings/iio/st-sensors.txt
index 5844cf72862d..e41fe340162b 100644
--- a/Documentation/devicetree/bindings/iio/st-sensors.txt
+++ b/Documentation/devicetree/bindings/iio/st-sensors.txt
@@ -64,3 +64,4 @@ Pressure sensors:
 - st,lps001wp-press
 - st,lps25h-press
 - st,lps331ap-press
+- st,lps22hb-press
diff --git a/MAINTAINERS b/MAINTAINERS
index e1b090f86e0d..c1e4bf3ea8ec 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -5786,6 +5786,7 @@ R:	Lars-Peter Clausen <lars@metafoo.de>
 R:      Peter Meerwald-Stadler <pmeerw@pmeerw.net>
 L:      linux-iio@vger.kernel.org
 S:      Maintained
+F:      Documentation/devicetree/bindings/iio/
 F:      drivers/iio/
 F:      drivers/staging/iio/
 F:      include/linux/iio/
@@ -10856,6 +10857,7 @@ STAGING - INDUSTRIAL IO
 M:      Jonathan Cameron <jic23@kernel.org>
 L:      linux-iio@vger.kernel.org
 S:      Odd Fixes
+F:      Documentation/devicetree/bindings/staging/iio/
 F:      drivers/staging/iio/
 
 STAGING - LIRC (LINUX INFRARED REMOTE CONTROL) DRIVERS
diff --git a/drivers/iio/Kconfig b/drivers/iio/Kconfig
index 505e921f0b19..6743b18194fb 100644
--- a/drivers/iio/Kconfig
+++ b/drivers/iio/Kconfig
@@ -46,6 +46,14 @@ config IIO_CONSUMERS_PER_TRIGGER
         This value controls the maximum number of consumers that a
         given trigger may handle. Default is 2.
 
+config IIO_SW_DEVICE
+        tristate "Enable software IIO device support"
+        select IIO_CONFIGFS
+        help
+         Provides IIO core support for software devices. A software
+         device can be created via configfs or directly by a driver
+         using the API provided.
+
 config IIO_SW_TRIGGER
         tristate "Enable software triggers support"
         select IIO_CONFIGFS
diff --git a/drivers/iio/Makefile b/drivers/iio/Makefile
index 20f649073462..87e4c4369e2f 100644
--- a/drivers/iio/Makefile
+++ b/drivers/iio/Makefile
@@ -8,6 +8,7 @@ industrialio-$(CONFIG_IIO_BUFFER) += industrialio-buffer.o
 industrialio-$(CONFIG_IIO_TRIGGER) += industrialio-trigger.o
 
 obj-$(CONFIG_IIO_CONFIGFS) += industrialio-configfs.o
+obj-$(CONFIG_IIO_SW_DEVICE) += industrialio-sw-device.o
 obj-$(CONFIG_IIO_SW_TRIGGER) += industrialio-sw-trigger.o
 obj-$(CONFIG_IIO_TRIGGERED_EVENT) += industrialio-triggered-event.o
 
diff --git a/drivers/iio/accel/Kconfig b/drivers/iio/accel/Kconfig
index e4a758cd7d35..31325870a9ef 100644
--- a/drivers/iio/accel/Kconfig
+++ b/drivers/iio/accel/Kconfig
@@ -17,6 +17,16 @@ config BMA180
           To compile this driver as a module, choose M here: the
           module will be called bma180.
 
+config BMA220
+    tristate "Bosch BMA220 3-Axis Accelerometer Driver"
+        depends on SPI
+    help
+      Say yes here to add support for the Bosch BMA220 triaxial
+      acceleration sensor.
+
+      To compile this driver as a module, choose M here: the
+      module will be called bma220_spi.
+
 config BMC150_ACCEL
         tristate "Bosch BMC150 Accelerometer Driver"
         select IIO_BUFFER
@@ -136,6 +146,16 @@ config MMA7455_SPI
           To compile this driver as a module, choose M here: the module
           will be called mma7455_spi.
 
+config MMA7660
+        tristate "Freescale MMA7660FC 3-Axis Accelerometer Driver"
+        depends on I2C
+        help
+          Say yes here to get support for the Freescale MMA7660FC 3-Axis
+          accelerometer.
+
+          Choosing M will build the driver as a module. If so, the module
+          will be called mma7660.
+
 config MMA8452
         tristate "Freescale MMA8452Q and similar Accelerometers Driver"
         depends on I2C
diff --git a/drivers/iio/accel/Makefile b/drivers/iio/accel/Makefile
index 71b6794de885..6cedbecca2ee 100644
--- a/drivers/iio/accel/Makefile
+++ b/drivers/iio/accel/Makefile
@@ -4,6 +4,7 @@
 
 # When adding new entries keep the list in alphabetical order
 obj-$(CONFIG_BMA180) += bma180.o
+obj-$(CONFIG_BMA220) += bma220_spi.o
 obj-$(CONFIG_BMC150_ACCEL) += bmc150-accel-core.o
 obj-$(CONFIG_BMC150_ACCEL_I2C) += bmc150-accel-i2c.o
 obj-$(CONFIG_BMC150_ACCEL_SPI) += bmc150-accel-spi.o
@@ -15,6 +16,8 @@ obj-$(CONFIG_MMA7455)		+= mma7455_core.o
 obj-$(CONFIG_MMA7455_I2C)       += mma7455_i2c.o
 obj-$(CONFIG_MMA7455_SPI)       += mma7455_spi.o
 
+obj-$(CONFIG_MMA7660)   += mma7660.o
+
 obj-$(CONFIG_MMA8452)   += mma8452.o
 
 obj-$(CONFIG_MMA9551_CORE)      += mma9551_core.o
diff --git a/drivers/iio/accel/bma220_spi.c b/drivers/iio/accel/bma220_spi.c
new file mode 100644
index 000000000000..1098d10df8e8
--- /dev/null
+++ b/drivers/iio/accel/bma220_spi.c
@@ -0,0 +1,338 @@
+/**
+ * BMA220 Digital triaxial acceleration sensor driver
+ *
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License. See the file COPYING in the main
+ * directory of this archive for more details.
+ */
+
+#include <linux/acpi.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/spi/spi.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
+
+#define BMA220_REG_ID                           0x00
+#define BMA220_REG_ACCEL_X                      0x02
+#define BMA220_REG_ACCEL_Y                      0x03
+#define BMA220_REG_ACCEL_Z                      0x04
+#define BMA220_REG_RANGE                        0x11
+#define BMA220_REG_SUSPEND                      0x18
+
+#define BMA220_CHIP_ID                          0xDD
+#define BMA220_READ_MASK                        0x80
+#define BMA220_RANGE_MASK                       0x03
+#define BMA220_DATA_SHIFT                       2
+#define BMA220_SUSPEND_SLEEP                    0xFF
+#define BMA220_SUSPEND_WAKE                     0x00
+
+#define BMA220_DEVICE_NAME                      "bma220"
+#define BMA220_SCALE_AVAILABLE                  "0.623 1.248 2.491 4.983"
+
+#define BMA220_ACCEL_CHANNEL(index, reg, axis) {                        \
+        .type = IIO_ACCEL,                                              \
+        .address = reg,                                                 \
+        .modified = 1,                                                  \
+        .channel2 = IIO_MOD_##axis,                                     \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
+        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),           \
+        .scan_index = index,                                            \
+        .scan_type = {                                                  \
+                .sign = 's',                                            \
+                .realbits = 6,                                          \
+                .storagebits = 8,                                       \
+                .shift = BMA220_DATA_SHIFT,                             \
+                .endianness = IIO_CPU,                                  \
+        },                                                              \
+}
+
+enum bma220_axis {
+        AXIS_X,
+        AXIS_Y,
+        AXIS_Z,
+};
+
+static IIO_CONST_ATTR(in_accel_scale_available, BMA220_SCALE_AVAILABLE);
+
+static struct attribute *bma220_attributes[] = {
+        &iio_const_attr_in_accel_scale_available.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group bma220_attribute_group = {
+        .attrs = bma220_attributes,
+};
+
+static const int bma220_scale_table[][4] = {
+        {0, 623000}, {1, 248000}, {2, 491000}, {4, 983000}
+};
+
+struct bma220_data {
+        struct spi_device *spi_device;
+        struct mutex lock;
+        s8 buffer[16]; /* 3x8-bit channels + 5x8 padding + 8x8 timestamp */
+        u8 tx_buf[2] ____cacheline_aligned;
+};
+
+static const struct iio_chan_spec bma220_channels[] = {
+        BMA220_ACCEL_CHANNEL(0, BMA220_REG_ACCEL_X, X),
+        BMA220_ACCEL_CHANNEL(1, BMA220_REG_ACCEL_Y, Y),
+        BMA220_ACCEL_CHANNEL(2, BMA220_REG_ACCEL_Z, Z),
+        IIO_CHAN_SOFT_TIMESTAMP(3),
+};
+
+static inline int bma220_read_reg(struct spi_device *spi, u8 reg)
+{
+        return spi_w8r8(spi, reg | BMA220_READ_MASK);
+}
+
+static const unsigned long bma220_accel_scan_masks[] = {
+        BIT(AXIS_X) | BIT(AXIS_Y) | BIT(AXIS_Z),
+        0
+};
+
+static irqreturn_t bma220_trigger_handler(int irq, void *p)
+{
+        int ret;
+        struct iio_poll_func *pf = p;
+        struct iio_dev *indio_dev = pf->indio_dev;
+        struct bma220_data *data = iio_priv(indio_dev);
+        struct spi_device *spi = data->spi_device;
+
+        mutex_lock(&data->lock);
+        data->tx_buf[0] = BMA220_REG_ACCEL_X | BMA220_READ_MASK;
+        ret = spi_write_then_read(spi, data->tx_buf, 1, data->buffer,
+                                  ARRAY_SIZE(bma220_channels) - 1);
+        if (ret < 0)
+                goto err;
+
+        iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+                                           pf->timestamp);
+err:
+        mutex_unlock(&data->lock);
+        iio_trigger_notify_done(indio_dev->trig);
+
+        return IRQ_HANDLED;
+}
+
+static int bma220_read_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan,
+                           int *val, int *val2, long mask)
+{
+        int ret;
+        u8 range_idx;
+        struct bma220_data *data = iio_priv(indio_dev);
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                ret = bma220_read_reg(data->spi_device, chan->address);
+                if (ret < 0)
+                        return -EINVAL;
+                *val = sign_extend32(ret >> BMA220_DATA_SHIFT, 5);
+                return IIO_VAL_INT;
+        case IIO_CHAN_INFO_SCALE:
+                ret = bma220_read_reg(data->spi_device, BMA220_REG_RANGE);
+                if (ret < 0)
+                        return ret;
+                range_idx = ret & BMA220_RANGE_MASK;
+                *val = bma220_scale_table[range_idx][0];
+                *val2 = bma220_scale_table[range_idx][1];
+                return IIO_VAL_INT_PLUS_MICRO;
+        }
+
+        return -EINVAL;
+}
+
+static int bma220_write_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan,
+                            int val, int val2, long mask)
+{
+        int i;
+        int ret;
+        int index = -1;
+        struct bma220_data *data = iio_priv(indio_dev);
+
+        switch (mask) {
+        case IIO_CHAN_INFO_SCALE:
+                for (i = 0; i < ARRAY_SIZE(bma220_scale_table); i++)
+                        if (val == bma220_scale_table[i][0] &&
+                            val2 == bma220_scale_table[i][1]) {
+                                index = i;
+                                break;
+                        }
+                if (index < 0)
+                        return -EINVAL;
+
+                mutex_lock(&data->lock);
+                data->tx_buf[0] = BMA220_REG_RANGE;
+                data->tx_buf[1] = index;
+                ret = spi_write(data->spi_device, data->tx_buf,
+                                sizeof(data->tx_buf));
+                if (ret < 0)
+                        dev_err(&data->spi_device->dev,
+                                "failed to set measurement range\n");
+                mutex_unlock(&data->lock);
+
+                return 0;
+        }
+
+        return -EINVAL;
+}
+
+static const struct iio_info bma220_info = {
+        .driver_module          = THIS_MODULE,
+        .read_raw               = bma220_read_raw,
+        .write_raw              = bma220_write_raw,
+        .attrs                  = &bma220_attribute_group,
+};
+
+static int bma220_init(struct spi_device *spi)
+{
+        int ret;
+
+        ret = bma220_read_reg(spi, BMA220_REG_ID);
+        if (ret != BMA220_CHIP_ID)
+                return -ENODEV;
+
+        /* Make sure the chip is powered on */
+        ret = bma220_read_reg(spi, BMA220_REG_SUSPEND);
+        if (ret < 0)
+                return ret;
+        else if (ret == BMA220_SUSPEND_WAKE)
+                return bma220_read_reg(spi, BMA220_REG_SUSPEND);
+
+        return 0;
+}
+
+static int bma220_deinit(struct spi_device *spi)
+{
+        int ret;
+
+        /* Make sure the chip is powered off */
+        ret = bma220_read_reg(spi, BMA220_REG_SUSPEND);
+        if (ret < 0)
+                return ret;
+        else if (ret == BMA220_SUSPEND_SLEEP)
+                return bma220_read_reg(spi, BMA220_REG_SUSPEND);
+
+        return 0;
+}
+
+static int bma220_probe(struct spi_device *spi)
+{
+        int ret;
+        struct iio_dev *indio_dev;
+        struct bma220_data *data;
+
+        indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
+        if (!indio_dev) {
+                dev_err(&spi->dev, "iio allocation failed!\n");
+                return -ENOMEM;
+        }
+
+        data = iio_priv(indio_dev);
+        data->spi_device = spi;
+        spi_set_drvdata(spi, indio_dev);
+        mutex_init(&data->lock);
+
+        indio_dev->dev.parent = &spi->dev;
+        indio_dev->info = &bma220_info;
+        indio_dev->name = BMA220_DEVICE_NAME;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        indio_dev->channels = bma220_channels;
+        indio_dev->num_channels = ARRAY_SIZE(bma220_channels);
+        indio_dev->available_scan_masks = bma220_accel_scan_masks;
+
+        ret = bma220_init(data->spi_device);
+        if (ret < 0)
+                return ret;
+
+        ret = iio_triggered_buffer_setup(indio_dev, NULL,
+                                         bma220_trigger_handler, NULL);
+        if (ret < 0) {
+                dev_err(&spi->dev, "iio triggered buffer setup failed\n");
+                goto err_suspend;
+        }
+
+        ret = iio_device_register(indio_dev);
+        if (ret < 0) {
+                dev_err(&spi->dev, "iio_device_register failed\n");
+                iio_triggered_buffer_cleanup(indio_dev);
+                goto err_suspend;
+        }
+
+        return 0;
+
+err_suspend:
+        return bma220_deinit(spi);
+}
+
+static int bma220_remove(struct spi_device *spi)
+{
+        struct iio_dev *indio_dev = spi_get_drvdata(spi);
+
+        iio_device_unregister(indio_dev);
+        iio_triggered_buffer_cleanup(indio_dev);
+
+        return bma220_deinit(spi);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int bma220_suspend(struct device *dev)
+{
+        struct bma220_data *data =
+                        iio_priv(spi_get_drvdata(to_spi_device(dev)));
+
+        /* The chip can be suspended/woken up by a simple register read. */
+        return bma220_read_reg(data->spi_device, BMA220_REG_SUSPEND);
+}
+
+static int bma220_resume(struct device *dev)
+{
+        struct bma220_data *data =
+                        iio_priv(spi_get_drvdata(to_spi_device(dev)));
+
+        return bma220_read_reg(data->spi_device, BMA220_REG_SUSPEND);
+}
+
+static SIMPLE_DEV_PM_OPS(bma220_pm_ops, bma220_suspend, bma220_resume);
+
+#define BMA220_PM_OPS (&bma220_pm_ops)
+#else
+#define BMA220_PM_OPS NULL
+#endif
+
+static const struct spi_device_id bma220_spi_id[] = {
+        {"bma220", 0},
+        {}
+};
+
+static const struct acpi_device_id bma220_acpi_id[] = {
+        {"BMA0220", 0},
+        {}
+};
+
+MODULE_DEVICE_TABLE(spi, bma220_spi_id);
+
+static struct spi_driver bma220_driver = {
+        .driver = {
+                .name = "bma220_spi",
+                .pm = BMA220_PM_OPS,
+                .acpi_match_table = ACPI_PTR(bma220_acpi_id),
+        },
+        .probe =            bma220_probe,
+        .remove =           bma220_remove,
+        .id_table =         bma220_spi_id,
+};
+
+module_spi_driver(bma220_driver);
+
+MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
+MODULE_DESCRIPTION("BMA220 acceleration sensor driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/accel/mma7660.c b/drivers/iio/accel/mma7660.c
new file mode 100644
index 000000000000..0acdee516973
--- /dev/null
+++ b/drivers/iio/accel/mma7660.c
@@ -0,0 +1,277 @@
+/**
+ * Freescale MMA7660FC 3-Axis Accelerometer
+ *
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License. See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * IIO driver for Freescale MMA7660FC; 7-bit I2C address: 0x4c.
+ */
+
+#include <linux/acpi.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define MMA7660_DRIVER_NAME     "mma7660"
+
+#define MMA7660_REG_XOUT        0x00
+#define MMA7660_REG_YOUT        0x01
+#define MMA7660_REG_ZOUT        0x02
+#define MMA7660_REG_OUT_BIT_ALERT       BIT(6)
+
+#define MMA7660_REG_MODE        0x07
+#define MMA7660_REG_MODE_BIT_MODE       BIT(0)
+#define MMA7660_REG_MODE_BIT_TON        BIT(2)
+
+#define MMA7660_I2C_READ_RETRIES        5
+
+/*
+ * The accelerometer has one measurement range:
+ *
+ * -1.5g - +1.5g (6-bit, signed)
+ *
+ * scale = (1.5 + 1.5) * 9.81 / (2^6 - 1)       = 0.467142857
+ */
+
+#define MMA7660_SCALE_AVAIL     "0.467142857"
+
+const int mma7660_nscale = 467142857;
+
+#define MMA7660_CHANNEL(reg, axis) {    \
+        .type = IIO_ACCEL,      \
+        .address = reg, \
+        .modified = 1,  \
+        .channel2 = IIO_MOD_##axis,     \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
+        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
+}
+
+static const struct iio_chan_spec mma7660_channels[] = {
+        MMA7660_CHANNEL(MMA7660_REG_XOUT, X),
+        MMA7660_CHANNEL(MMA7660_REG_YOUT, Y),
+        MMA7660_CHANNEL(MMA7660_REG_ZOUT, Z),
+};
+
+enum mma7660_mode {
+        MMA7660_MODE_STANDBY,
+        MMA7660_MODE_ACTIVE
+};
+
+struct mma7660_data {
+        struct i2c_client *client;
+        struct mutex lock;
+        enum mma7660_mode mode;
+};
+
+static IIO_CONST_ATTR(in_accel_scale_available, MMA7660_SCALE_AVAIL);
+
+static struct attribute *mma7660_attributes[] = {
+        &iio_const_attr_in_accel_scale_available.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group mma7660_attribute_group = {
+        .attrs = mma7660_attributes
+};
+
+static int mma7660_set_mode(struct mma7660_data *data,
+                                enum mma7660_mode mode)
+{
+        int ret;
+        struct i2c_client *client = data->client;
+
+        if (mode == data->mode)
+                return 0;
+
+        ret = i2c_smbus_read_byte_data(client, MMA7660_REG_MODE);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed to read sensor mode\n");
+                return ret;
+        }
+
+        if (mode == MMA7660_MODE_ACTIVE) {
+                ret &= ~MMA7660_REG_MODE_BIT_TON;
+                ret |= MMA7660_REG_MODE_BIT_MODE;
+        } else {
+                ret &= ~MMA7660_REG_MODE_BIT_TON;
+                ret &= ~MMA7660_REG_MODE_BIT_MODE;
+        }
+
+        ret = i2c_smbus_write_byte_data(client, MMA7660_REG_MODE, ret);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed to change sensor mode\n");
+                return ret;
+        }
+
+        data->mode = mode;
+
+        return ret;
+}
+
+static int mma7660_read_accel(struct mma7660_data *data, u8 address)
+{
+        int ret, retries = MMA7660_I2C_READ_RETRIES;
+        struct i2c_client *client = data->client;
+
+        /*
+         * Read data. If the Alert bit is set, the register was read at
+         * the same time as the device was attempting to update the content.
+         * The solution is to read the register again. Do this only
+         * MMA7660_I2C_READ_RETRIES times to avoid spending too much time
+         * in the kernel.
+         */
+        do {
+                ret = i2c_smbus_read_byte_data(client, address);
+                if (ret < 0) {
+                        dev_err(&client->dev, "register read failed\n");
+                        return ret;
+                }
+        } while (retries-- > 0 && ret & MMA7660_REG_OUT_BIT_ALERT);
+
+        if (ret & MMA7660_REG_OUT_BIT_ALERT) {
+                dev_err(&client->dev, "all register read retries failed\n");
+                return -ETIMEDOUT;
+        }
+
+        return ret;
+}
+
+static int mma7660_read_raw(struct iio_dev *indio_dev,
+                                struct iio_chan_spec const *chan,
+                                int *val, int *val2, long mask)
+{
+        struct mma7660_data *data = iio_priv(indio_dev);
+        int ret;
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                mutex_lock(&data->lock);
+                ret = mma7660_read_accel(data, chan->address);
+                mutex_unlock(&data->lock);
+                if (ret < 0)
+                        return ret;
+                *val = sign_extend32(ret, 5);
+                return IIO_VAL_INT;
+        case IIO_CHAN_INFO_SCALE:
+                *val = 0;
+                *val2 = mma7660_nscale;
+                return IIO_VAL_INT_PLUS_NANO;
+        default:
+                return -EINVAL;
+        }
+
+        return -EINVAL;
+}
+
+static const struct iio_info mma7660_info = {
+        .driver_module  = THIS_MODULE,
+        .read_raw               = mma7660_read_raw,
+        .attrs                  = &mma7660_attribute_group,
+};
+
+static int mma7660_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        int ret;
+        struct iio_dev *indio_dev;
+        struct mma7660_data *data;
+
+        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+        if (!indio_dev) {
+                dev_err(&client->dev, "iio allocation failed!\n");
+                return -ENOMEM;
+        }
+
+        data = iio_priv(indio_dev);
+        data->client = client;
+        i2c_set_clientdata(client, indio_dev);
+        mutex_init(&data->lock);
+        data->mode = MMA7660_MODE_STANDBY;
+
+        indio_dev->dev.parent = &client->dev;
+        indio_dev->info = &mma7660_info;
+        indio_dev->name = MMA7660_DRIVER_NAME;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        indio_dev->channels = mma7660_channels;
+        indio_dev->num_channels = ARRAY_SIZE(mma7660_channels);
+
+        ret = mma7660_set_mode(data, MMA7660_MODE_ACTIVE);
+        if (ret < 0)
+                return ret;
+
+        ret = iio_device_register(indio_dev);
+        if (ret < 0) {
+                dev_err(&client->dev, "device_register failed\n");
+                mma7660_set_mode(data, MMA7660_MODE_STANDBY);
+        }
+
+        return ret;
+}
+
+static int mma7660_remove(struct i2c_client *client)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(client);
+
+        iio_device_unregister(indio_dev);
+
+        return mma7660_set_mode(iio_priv(indio_dev), MMA7660_MODE_STANDBY);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int mma7660_suspend(struct device *dev)
+{
+        struct mma7660_data *data;
+
+        data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
+
+        return mma7660_set_mode(data, MMA7660_MODE_STANDBY);
+}
+
+static int mma7660_resume(struct device *dev)
+{
+        struct mma7660_data *data;
+
+        data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
+
+        return mma7660_set_mode(data, MMA7660_MODE_ACTIVE);
+}
+
+static SIMPLE_DEV_PM_OPS(mma7660_pm_ops, mma7660_suspend, mma7660_resume);
+
+#define MMA7660_PM_OPS (&mma7660_pm_ops)
+#else
+#define MMA7660_PM_OPS NULL
+#endif
+
+static const struct i2c_device_id mma7660_i2c_id[] = {
+        {"mma7660", 0},
+        {}
+};
+
+static const struct acpi_device_id mma7660_acpi_id[] = {
+        {"MMA7660", 0},
+        {}
+};
+
+MODULE_DEVICE_TABLE(acpi, mma7660_acpi_id);
+
+static struct i2c_driver mma7660_driver = {
+        .driver = {
+                .name = "mma7660",
+                .pm = MMA7660_PM_OPS,
+                .acpi_match_table = ACPI_PTR(mma7660_acpi_id),
+        },
+        .probe          = mma7660_probe,
+        .remove         = mma7660_remove,
+        .id_table       = mma7660_i2c_id,
+};
+
+module_i2c_driver(mma7660_driver);
+
+MODULE_AUTHOR("Constantin Musca <constantin.musca@intel.com>");
+MODULE_DESCRIPTION("Freescale MMA7660FC 3-Axis Accelerometer driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/accel/mma8452.c b/drivers/iio/accel/mma8452.c
index e225d3c53bd5..458c82715427 100644
--- a/drivers/iio/accel/mma8452.c
+++ b/drivers/iio/accel/mma8452.c
@@ -76,6 +76,8 @@
 #define  MMA8452_CTRL_DR_DEFAULT                0x4 /* 50 Hz sample frequency */
 #define MMA8452_CTRL_REG2                       0x2b
 #define  MMA8452_CTRL_REG2_RST                  BIT(6)
+#define  MMA8452_CTRL_REG2_MODS_SHIFT           3
+#define  MMA8452_CTRL_REG2_MODS_MASK            0x1b
 #define MMA8452_CTRL_REG4                       0x2d
 #define MMA8452_CTRL_REG5                       0x2e
 #define MMA8452_OFF_X                           0x2f
@@ -257,20 +259,17 @@ static const int mma8452_samp_freq[8][2] = {
         {6, 250000}, {1, 560000}
 };
 
-/* Datasheet table 35  (step time vs sample frequency) */
-static const int mma8452_transient_time_step_us[8] = {
-        1250,
-        2500,
-        5000,
-        10000,
-        20000,
-        20000,
-        20000,
-        20000
+/* Datasheet table: step time "Relationship with the ODR" (sample frequency) */
+static const int mma8452_transient_time_step_us[4][8] = {
+        { 1250, 2500, 5000, 10000, 20000, 20000, 20000, 20000 },  /* normal */
+        { 1250, 2500, 5000, 10000, 20000, 80000, 80000, 80000 },  /* l p l n */
+        { 1250, 2500, 2500, 2500, 2500, 2500, 2500, 2500 },       /* high res*/
+        { 1250, 2500, 5000, 10000, 20000, 80000, 160000, 160000 } /* l p */
 };
 
-/* Datasheet table 18 (normal mode) */
-static const int mma8452_hp_filter_cutoff[8][4][2] = {
+/* Datasheet table "High-Pass Filter Cutoff Options" */
+static const int mma8452_hp_filter_cutoff[4][8][4][2] = {
+        { /* normal */
         { {16, 0}, {8, 0}, {4, 0}, {2, 0} },            /* 800 Hz sample */
         { {16, 0}, {8, 0}, {4, 0}, {2, 0} },            /* 400 Hz sample */
         { {8, 0}, {4, 0}, {2, 0}, {1, 0} },             /* 200 Hz sample */
@@ -279,8 +278,61 @@ static const int mma8452_hp_filter_cutoff[8][4][2] = {
         { {2, 0}, {1, 0}, {0, 500000}, {0, 250000} },   /* 12.5 Hz sample */
         { {2, 0}, {1, 0}, {0, 500000}, {0, 250000} },   /* 6.25 Hz sample */
         { {2, 0}, {1, 0}, {0, 500000}, {0, 250000} }    /* 1.56 Hz sample */
+        },
+        { /* low noise low power */
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {8, 0}, {4, 0}, {2, 0}, {1, 0} },
+        { {4, 0}, {2, 0}, {1, 0}, {0, 500000} },
+        { {2, 0}, {1, 0}, {0, 500000}, {0, 250000} },
+        { {0, 500000}, {0, 250000}, {0, 125000}, {0, 063000} },
+        { {0, 500000}, {0, 250000}, {0, 125000}, {0, 063000} },
+        { {0, 500000}, {0, 250000}, {0, 125000}, {0, 063000} }
+        },
+        { /* high resolution */
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} }
+        },
+        { /* low power */
+        { {16, 0}, {8, 0}, {4, 0}, {2, 0} },
+        { {8, 0}, {4, 0}, {2, 0}, {1, 0} },
+        { {4, 0}, {2, 0}, {1, 0}, {0, 500000} },
+        { {2, 0}, {1, 0}, {0, 500000}, {0, 250000} },
+        { {1, 0}, {0, 500000}, {0, 250000}, {0, 125000} },
+        { {0, 250000}, {0, 125000}, {0, 063000}, {0, 031000} },
+        { {0, 250000}, {0, 125000}, {0, 063000}, {0, 031000} },
+        { {0, 250000}, {0, 125000}, {0, 063000}, {0, 031000} }
+        }
 };
 
+/* Datasheet table "MODS Oversampling modes averaging values at each ODR" */
+static const u16 mma8452_os_ratio[4][8] = {
+        /* 800 Hz, 400 Hz, ... , 1.56 Hz */
+        { 2, 4, 4, 4, 4, 16, 32, 128 },         /* normal */
+        { 2, 4, 4, 4, 4, 4, 8, 32 },            /* low power low noise */
+        { 2, 4, 8, 16, 32, 128, 256, 1024 },    /* high resolution */
+        { 2, 2, 2, 2, 2, 2, 4, 16 }             /* low power */
+};
+
+static int mma8452_get_power_mode(struct mma8452_data *data)
+{
+        int reg;
+
+        reg = i2c_smbus_read_byte_data(data->client,
+                                       MMA8452_CTRL_REG2);
+        if (reg < 0)
+                return reg;
+
+        return ((reg & MMA8452_CTRL_REG2_MODS_MASK) >>
+                MMA8452_CTRL_REG2_MODS_SHIFT);
+}
+
 static ssize_t mma8452_show_samp_freq_avail(struct device *dev,
                                             struct device_attribute *attr,
                                             char *buf)
@@ -306,10 +358,39 @@ static ssize_t mma8452_show_hp_cutoff_avail(struct device *dev,
 {
         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
         struct mma8452_data *data = iio_priv(indio_dev);
+        int i, j;
+
+        i = mma8452_get_odr_index(data);
+        j = mma8452_get_power_mode(data);
+        if (j < 0)
+                return j;
+
+        return mma8452_show_int_plus_micros(buf, mma8452_hp_filter_cutoff[j][i],
+                ARRAY_SIZE(mma8452_hp_filter_cutoff[0][0]));
+}
+
+static ssize_t mma8452_show_os_ratio_avail(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
+{
+        struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+        struct mma8452_data *data = iio_priv(indio_dev);
         int i = mma8452_get_odr_index(data);
+        int j;
+        u16 val = 0;
+        size_t len = 0;
+
+        for (j = 0; j < ARRAY_SIZE(mma8452_os_ratio); j++) {
+                if (val == mma8452_os_ratio[j][i])
+                        continue;
+
+                val = mma8452_os_ratio[j][i];
+
+                len += scnprintf(buf + len, PAGE_SIZE - len, "%d ", val);
+        }
+        buf[len - 1] = '\n';
 
-        return mma8452_show_int_plus_micros(buf, mma8452_hp_filter_cutoff[i],
-                ARRAY_SIZE(mma8452_hp_filter_cutoff[0]));
+        return len;
 }
 
 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(mma8452_show_samp_freq_avail);
@@ -317,6 +398,8 @@ static IIO_DEVICE_ATTR(in_accel_scale_available, S_IRUGO,
                        mma8452_show_scale_avail, NULL, 0);
 static IIO_DEVICE_ATTR(in_accel_filter_high_pass_3db_frequency_available,
                        S_IRUGO, mma8452_show_hp_cutoff_avail, NULL, 0);
+static IIO_DEVICE_ATTR(in_accel_oversampling_ratio_available, S_IRUGO,
+                       mma8452_show_os_ratio_avail, NULL, 0);
 
 static int mma8452_get_samp_freq_index(struct mma8452_data *data,
                                        int val, int val2)
@@ -335,24 +418,33 @@ static int mma8452_get_scale_index(struct mma8452_data *data, int val, int val2)
 static int mma8452_get_hp_filter_index(struct mma8452_data *data,
                                        int val, int val2)
 {
-        int i = mma8452_get_odr_index(data);
+        int i, j;
+
+        i = mma8452_get_odr_index(data);
+        j = mma8452_get_power_mode(data);
+        if (j < 0)
+                return j;
 
-        return mma8452_get_int_plus_micros_index(mma8452_hp_filter_cutoff[i],
-                ARRAY_SIZE(mma8452_hp_filter_cutoff[0]), val, val2);
+        return mma8452_get_int_plus_micros_index(mma8452_hp_filter_cutoff[j][i],
+                ARRAY_SIZE(mma8452_hp_filter_cutoff[0][0]), val, val2);
 }
 
 static int mma8452_read_hp_filter(struct mma8452_data *data, int *hz, int *uHz)
 {
-        int i, ret;
+        int j, i, ret;
 
         ret = i2c_smbus_read_byte_data(data->client, MMA8452_HP_FILTER_CUTOFF);
         if (ret < 0)
                 return ret;
 
         i = mma8452_get_odr_index(data);
+        j = mma8452_get_power_mode(data);
+        if (j < 0)
+                return j;
+
         ret &= MMA8452_HP_FILTER_CUTOFF_SEL_MASK;
-        *hz = mma8452_hp_filter_cutoff[i][ret][0];
-        *uHz = mma8452_hp_filter_cutoff[i][ret][1];
+        *hz = mma8452_hp_filter_cutoff[j][i][ret][0];
+        *uHz = mma8452_hp_filter_cutoff[j][i][ret][1];
 
         return 0;
 }
@@ -414,6 +506,15 @@ static int mma8452_read_raw(struct iio_dev *indio_dev,
                 }
 
                 return IIO_VAL_INT_PLUS_MICRO;
+        case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
+                ret = mma8452_get_power_mode(data);
+                if (ret < 0)
+                        return ret;
+
+                i = mma8452_get_odr_index(data);
+
+                *val = mma8452_os_ratio[ret][i];
+                return IIO_VAL_INT;
         }
 
         return -EINVAL;
@@ -480,6 +581,21 @@ fail:
         return ret;
 }
 
+static int mma8452_set_power_mode(struct mma8452_data *data, u8 mode)
+{
+        int reg;
+
+        reg = i2c_smbus_read_byte_data(data->client,
+                                       MMA8452_CTRL_REG2);
+        if (reg < 0)
+                return reg;
+
+        reg &= ~MMA8452_CTRL_REG2_MODS_MASK;
+        reg |= mode << MMA8452_CTRL_REG2_MODS_SHIFT;
+
+        return mma8452_change_config(data, MMA8452_CTRL_REG2, reg);
+}
+
 /* returns >0 if in freefall mode, 0 if not or <0 if an error occurred */
 static int mma8452_freefall_mode_enabled(struct mma8452_data *data)
 {
@@ -597,6 +713,14 @@ static int mma8452_write_raw(struct iio_dev *indio_dev,
                 return mma8452_change_config(data, MMA8452_DATA_CFG,
                                              data->data_cfg);
 
+        case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
+                ret = mma8452_get_odr_index(data);
+
+                for (i = 0; i < ARRAY_SIZE(mma8452_os_ratio); i++) {
+                        if (mma8452_os_ratio[i][ret] == val)
+                                return mma8452_set_power_mode(data, i);
+                }
+
         default:
                 return -EINVAL;
         }
@@ -610,7 +734,7 @@ static int mma8452_read_thresh(struct iio_dev *indio_dev,
                                int *val, int *val2)
 {
         struct mma8452_data *data = iio_priv(indio_dev);
-        int ret, us;
+        int ret, us, power_mode;
 
         switch (info) {
         case IIO_EV_INFO_VALUE:
@@ -629,7 +753,11 @@ static int mma8452_read_thresh(struct iio_dev *indio_dev,
                 if (ret < 0)
                         return ret;
 
-                us = ret * mma8452_transient_time_step_us[
+                power_mode = mma8452_get_power_mode(data);
+                if (power_mode < 0)
+                        return power_mode;
+
+                us = ret * mma8452_transient_time_step_us[power_mode][
                                 mma8452_get_odr_index(data)];
                 *val = us / USEC_PER_SEC;
                 *val2 = us % USEC_PER_SEC;
@@ -677,8 +805,12 @@ static int mma8452_write_thresh(struct iio_dev *indio_dev,
                                              val);
 
         case IIO_EV_INFO_PERIOD:
+                ret = mma8452_get_power_mode(data);
+                if (ret < 0)
+                        return ret;
+
                 steps = (val * USEC_PER_SEC + val2) /
-                                mma8452_transient_time_step_us[
+                                mma8452_transient_time_step_us[ret][
                                         mma8452_get_odr_index(data)];
 
                 if (steps < 0 || steps > 0xff)
@@ -978,7 +1110,8 @@ static struct attribute_group mma8452_event_attribute_group = {
                               BIT(IIO_CHAN_INFO_CALIBBIAS), \
         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
                         BIT(IIO_CHAN_INFO_SCALE) | \
-                        BIT(IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY), \
+                        BIT(IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY) | \
+                        BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
         .scan_index = idx, \
         .scan_type = { \
                 .sign = 's', \
@@ -998,7 +1131,8 @@ static struct attribute_group mma8452_event_attribute_group = {
         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
                 BIT(IIO_CHAN_INFO_CALIBBIAS), \
         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
-                BIT(IIO_CHAN_INFO_SCALE), \
+                BIT(IIO_CHAN_INFO_SCALE) | \
+                BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
         .scan_index = idx, \
         .scan_type = { \
                 .sign = 's', \
@@ -1171,6 +1305,7 @@ static struct attribute *mma8452_attributes[] = {
         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
         &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
         &iio_dev_attr_in_accel_filter_high_pass_3db_frequency_available.dev_attr.attr,
+        &iio_dev_attr_in_accel_oversampling_ratio_available.dev_attr.attr,
         NULL
 };
 
diff --git a/drivers/iio/accel/st_accel_core.c b/drivers/iio/accel/st_accel_core.c
index 4d95bfc4786c..dce289aa40f2 100644
--- a/drivers/iio/accel/st_accel_core.c
+++ b/drivers/iio/accel/st_accel_core.c
@@ -758,13 +758,15 @@ int st_accel_common_probe(struct iio_dev *indio_dev)
         indio_dev->info = &accel_info;
         mutex_init(&adata->tb.buf_lock);
 
-        st_sensors_power_enable(indio_dev);
+        err = st_sensors_power_enable(indio_dev);
+        if (err)
+                return err;
 
         err = st_sensors_check_device_support(indio_dev,
                                         ARRAY_SIZE(st_accel_sensors_settings),
                                         st_accel_sensors_settings);
         if (err < 0)
-                return err;
+                goto st_accel_power_off;
 
         adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS;
         adata->multiread_bit = adata->sensor_settings->multi_read_bit;
@@ -781,11 +783,11 @@ int st_accel_common_probe(struct iio_dev *indio_dev)
 
         err = st_sensors_init_sensor(indio_dev, adata->dev->platform_data);
         if (err < 0)
-                return err;
+                goto st_accel_power_off;
 
         err = st_accel_allocate_ring(indio_dev);
         if (err < 0)
-                return err;
+                goto st_accel_power_off;
 
         if (irq > 0) {
                 err = st_sensors_allocate_trigger(indio_dev,
@@ -808,6 +810,8 @@ st_accel_device_register_error:
                 st_sensors_deallocate_trigger(indio_dev);
 st_accel_probe_trigger_error:
         st_accel_deallocate_ring(indio_dev);
+st_accel_power_off:
+        st_sensors_power_disable(indio_dev);
 
         return err;
 }
diff --git a/drivers/iio/adc/ad7266.c b/drivers/iio/adc/ad7266.c
index 21e19b60e2b9..01240aeeeab0 100644
--- a/drivers/iio/adc/ad7266.c
+++ b/drivers/iio/adc/ad7266.c
@@ -154,12 +154,11 @@ static int ad7266_read_raw(struct iio_dev *indio_dev,
 
         switch (m) {
         case IIO_CHAN_INFO_RAW:
-                if (iio_buffer_enabled(indio_dev))
-                        return -EBUSY;
-
-                ret = ad7266_read_single(st, val, chan->address);
+                ret = iio_device_claim_direct_mode(indio_dev);
                 if (ret)
                         return ret;
+                ret = ad7266_read_single(st, val, chan->address);
+                iio_device_release_direct_mode(indio_dev);
 
                 *val = (*val >> 2) & 0xfff;
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/iio/adc/ad7476.c b/drivers/iio/adc/ad7476.c
index be85c2a0ad97..810c9a9fa62f 100644
--- a/drivers/iio/adc/ad7476.c
+++ b/drivers/iio/adc/ad7476.c
@@ -106,12 +106,11 @@ static int ad7476_read_raw(struct iio_dev *indio_dev,
 
         switch (m) {
         case IIO_CHAN_INFO_RAW:
-                mutex_lock(&indio_dev->mlock);
-                if (iio_buffer_enabled(indio_dev))
-                        ret = -EBUSY;
-                else
-                        ret = ad7476_scan_direct(st);
-                mutex_unlock(&indio_dev->mlock);
+                ret = iio_device_claim_direct_mode(indio_dev);
+                if (ret)
+                        return ret;
+                ret = ad7476_scan_direct(st);
+                iio_device_release_direct_mode(indio_dev);
 
                 if (ret < 0)
                         return ret;
diff --git a/drivers/iio/adc/ad7791.c b/drivers/iio/adc/ad7791.c
index cf172d58cd44..1dfe6410c64c 100644
--- a/drivers/iio/adc/ad7791.c
+++ b/drivers/iio/adc/ad7791.c
@@ -272,30 +272,22 @@ static ssize_t ad7791_write_frequency(struct device *dev,
         struct ad7791_state *st = iio_priv(indio_dev);
         int i, ret;
 
-        mutex_lock(&indio_dev->mlock);
-        if (iio_buffer_enabled(indio_dev)) {
-                mutex_unlock(&indio_dev->mlock);
-                return -EBUSY;
-        }
-        mutex_unlock(&indio_dev->mlock);
-
-        ret = -EINVAL;
-
-        for (i = 0; i < ARRAY_SIZE(ad7791_sample_freq_avail); i++) {
-                if (sysfs_streq(ad7791_sample_freq_avail[i], buf)) {
-
-                        mutex_lock(&indio_dev->mlock);
-                        st->filter &= ~AD7791_FILTER_RATE_MASK;
-                        st->filter |= i;
-                        ad_sd_write_reg(&st->sd, AD7791_REG_FILTER,
-                                         sizeof(st->filter), st->filter);
-                        mutex_unlock(&indio_dev->mlock);
-                        ret = 0;
+        for (i = 0; i < ARRAY_SIZE(ad7791_sample_freq_avail); i++)
+                if (sysfs_streq(ad7791_sample_freq_avail[i], buf))
                         break;
-                }
-        }
+        if (i == ARRAY_SIZE(ad7791_sample_freq_avail))
+                return -EINVAL;
+
+        ret = iio_device_claim_direct_mode(indio_dev);
+        if (ret)
+                return ret;
+        st->filter &= ~AD7791_FILTER_RATE_MASK;
+        st->filter |= i;
+        ad_sd_write_reg(&st->sd, AD7791_REG_FILTER, sizeof(st->filter),
+                        st->filter);
+        iio_device_release_direct_mode(indio_dev);
 
-        return ret ? ret : len;
+        return len;
 }
 
 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
diff --git a/drivers/iio/adc/ad7793.c b/drivers/iio/adc/ad7793.c
index 7b07bb651671..a43722fbf03a 100644
--- a/drivers/iio/adc/ad7793.c
+++ b/drivers/iio/adc/ad7793.c
@@ -369,13 +369,6 @@ static ssize_t ad7793_write_frequency(struct device *dev,
         long lval;
         int i, ret;
 
-        mutex_lock(&indio_dev->mlock);
-        if (iio_buffer_enabled(indio_dev)) {
-                mutex_unlock(&indio_dev->mlock);
-                return -EBUSY;
-        }
-        mutex_unlock(&indio_dev->mlock);
-
         ret = kstrtol(buf, 10, &lval);
         if (ret)
                 return ret;
@@ -383,20 +376,21 @@ static ssize_t ad7793_write_frequency(struct device *dev,
         if (lval == 0)
                 return -EINVAL;
 
-        ret = -EINVAL;
-
         for (i = 0; i < 16; i++)
-                if (lval == st->chip_info->sample_freq_avail[i]) {
-                        mutex_lock(&indio_dev->mlock);
-                        st->mode &= ~AD7793_MODE_RATE(-1);
-                        st->mode |= AD7793_MODE_RATE(i);
-                        ad_sd_write_reg(&st->sd, AD7793_REG_MODE,
-                                         sizeof(st->mode), st->mode);
-                        mutex_unlock(&indio_dev->mlock);
-                        ret = 0;
-                }
+                if (lval == st->chip_info->sample_freq_avail[i])
+                        break;
+        if (i == 16)
+                return -EINVAL;
 
-        return ret ? ret : len;
+        ret = iio_device_claim_direct_mode(indio_dev);
+        if (ret)
+                return ret;
+        st->mode &= ~AD7793_MODE_RATE(-1);
+        st->mode |= AD7793_MODE_RATE(i);
+        ad_sd_write_reg(&st->sd, AD7793_REG_MODE, sizeof(st->mode), st->mode);
+        iio_device_release_direct_mode(indio_dev);
+
+        return len;
 }
 
 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
diff --git a/drivers/iio/adc/ad7887.c b/drivers/iio/adc/ad7887.c
index 2d3c397e66ad..ee2ccc19fab6 100644
--- a/drivers/iio/adc/ad7887.c
+++ b/drivers/iio/adc/ad7887.c
@@ -156,12 +156,11 @@ static int ad7887_read_raw(struct iio_dev *indio_dev,
 
         switch (m) {
         case IIO_CHAN_INFO_RAW:
-                mutex_lock(&indio_dev->mlock);
-                if (iio_buffer_enabled(indio_dev))
-                        ret = -EBUSY;
-                else
-                        ret = ad7887_scan_direct(st, chan->address);
-                mutex_unlock(&indio_dev->mlock);
+                ret = iio_device_claim_direct_mode(indio_dev);
+                if (ret)
+                        return ret;
+                ret = ad7887_scan_direct(st, chan->address);
+                iio_device_release_direct_mode(indio_dev);
 
                 if (ret < 0)
                         return ret;
diff --git a/drivers/iio/adc/ad7923.c b/drivers/iio/adc/ad7923.c
index 45e29ccd824f..ff444c19d749 100644
--- a/drivers/iio/adc/ad7923.c
+++ b/drivers/iio/adc/ad7923.c
@@ -233,12 +233,11 @@ static int ad7923_read_raw(struct iio_dev *indio_dev,
 
         switch (m) {
         case IIO_CHAN_INFO_RAW:
-                mutex_lock(&indio_dev->mlock);
-                if (iio_buffer_enabled(indio_dev))
-                        ret = -EBUSY;
-                else
-                        ret = ad7923_scan_direct(st, chan->address);
-                mutex_unlock(&indio_dev->mlock);
+                ret = iio_device_claim_direct_mode(indio_dev);
+                if (ret)
+                        return ret;
+                ret = ad7923_scan_direct(st, chan->address);
+                iio_device_release_direct_mode(indio_dev);
 
                 if (ret < 0)
                         return ret;
diff --git a/drivers/iio/adc/ad799x.c b/drivers/iio/adc/ad799x.c
index a3f5254f4e51..ec0200dd52cb 100644
--- a/drivers/iio/adc/ad799x.c
+++ b/drivers/iio/adc/ad799x.c
@@ -282,12 +282,11 @@ static int ad799x_read_raw(struct iio_dev *indio_dev,
 
         switch (m) {
         case IIO_CHAN_INFO_RAW:
-                mutex_lock(&indio_dev->mlock);
-                if (iio_buffer_enabled(indio_dev))
-                        ret = -EBUSY;
-                else
-                        ret = ad799x_scan_direct(st, chan->scan_index);
-                mutex_unlock(&indio_dev->mlock);
+                ret = iio_device_claim_direct_mode(indio_dev);
+                if (ret)
+                        return ret;
+                ret = ad799x_scan_direct(st, chan->scan_index);
+                iio_device_release_direct_mode(indio_dev);
 
                 if (ret < 0)
                         return ret;
@@ -395,11 +394,9 @@ static int ad799x_write_event_config(struct iio_dev *indio_dev,
         struct ad799x_state *st = iio_priv(indio_dev);
         int ret;
 
-        mutex_lock(&indio_dev->mlock);
-        if (iio_buffer_enabled(indio_dev)) {
-                ret = -EBUSY;
-                goto done;
-        }
+        ret = iio_device_claim_direct_mode(indio_dev);
+        if (ret)
+                return ret;
 
         if (state)
                 st->config |= BIT(chan->scan_index) << AD799X_CHANNEL_SHIFT;
@@ -412,10 +409,7 @@ static int ad799x_write_event_config(struct iio_dev *indio_dev,
                 st->config &= ~AD7998_ALERT_EN;
 
         ret = ad799x_write_config(st, st->config);
-
-done:
-        mutex_unlock(&indio_dev->mlock);
-
+        iio_device_release_direct_mode(indio_dev);
         return ret;
 }
 
diff --git a/drivers/iio/adc/mxs-lradc.c b/drivers/iio/adc/mxs-lradc.c
index ad26da1edbee..b84d37c80a94 100644
--- a/drivers/iio/adc/mxs-lradc.c
+++ b/drivers/iio/adc/mxs-lradc.c
@@ -373,13 +373,6 @@ static u32 mxs_lradc_plate_mask(struct mxs_lradc *lradc)
         return LRADC_CTRL0_MX28_PLATE_MASK;
 }
 
-static u32 mxs_lradc_irq_en_mask(struct mxs_lradc *lradc)
-{
-        if (lradc->soc == IMX23_LRADC)
-                return LRADC_CTRL1_MX23_LRADC_IRQ_EN_MASK;
-        return LRADC_CTRL1_MX28_LRADC_IRQ_EN_MASK;
-}
-
 static u32 mxs_lradc_irq_mask(struct mxs_lradc *lradc)
 {
         if (lradc->soc == IMX23_LRADC)
@@ -1120,18 +1113,16 @@ static int mxs_lradc_ts_register(struct mxs_lradc *lradc)
 {
         struct input_dev *input;
         struct device *dev = lradc->dev;
-        int ret;
 
         if (!lradc->use_touchscreen)
                 return 0;
 
-        input = input_allocate_device();
+        input = devm_input_allocate_device(dev);
         if (!input)
                 return -ENOMEM;
 
         input->name = DRIVER_NAME;
         input->id.bustype = BUS_HOST;
-        input->dev.parent = dev;
         input->open = mxs_lradc_ts_open;
         input->close = mxs_lradc_ts_close;
 
@@ -1146,20 +1137,8 @@ static int mxs_lradc_ts_register(struct mxs_lradc *lradc)
 
         lradc->ts_input = input;
         input_set_drvdata(input, lradc);
-        ret = input_register_device(input);
-        if (ret)
-                input_free_device(lradc->ts_input);
-
-        return ret;
-}
-
-static void mxs_lradc_ts_unregister(struct mxs_lradc *lradc)
-{
-        if (!lradc->use_touchscreen)
-                return;
 
-        mxs_lradc_disable_ts(lradc);
-        input_unregister_device(lradc->ts_input);
+        return input_register_device(input);
 }
 
 /*
@@ -1510,7 +1489,9 @@ static void mxs_lradc_hw_stop(struct mxs_lradc *lradc)
 {
         int i;
 
-        mxs_lradc_reg_clear(lradc, mxs_lradc_irq_en_mask(lradc), LRADC_CTRL1);
+        mxs_lradc_reg_clear(lradc,
+                lradc->buffer_vchans << LRADC_CTRL1_LRADC_IRQ_EN_OFFSET,
+                LRADC_CTRL1);
 
         for (i = 0; i < LRADC_MAX_DELAY_CHANS; i++)
                 mxs_lradc_reg_wrt(lradc, 0, LRADC_DELAY(i));
@@ -1721,13 +1702,11 @@ static int mxs_lradc_probe(struct platform_device *pdev)
         ret = iio_device_register(iio);
         if (ret) {
                 dev_err(dev, "Failed to register IIO device\n");
-                goto err_ts;
+                return ret;
         }
 
         return 0;
 
-err_ts:
-        mxs_lradc_ts_unregister(lradc);
 err_ts_register:
         mxs_lradc_hw_stop(lradc);
 err_dev:
@@ -1745,7 +1724,6 @@ static int mxs_lradc_remove(struct platform_device *pdev)
         struct mxs_lradc *lradc = iio_priv(iio);
 
         iio_device_unregister(iio);
-        mxs_lradc_ts_unregister(lradc);
         mxs_lradc_hw_stop(lradc);
         mxs_lradc_trigger_remove(iio);
         iio_triggered_buffer_cleanup(iio);
diff --git a/drivers/iio/adc/nau7802.c b/drivers/iio/adc/nau7802.c
index e525aa6475c4..57365c504093 100644
--- a/drivers/iio/adc/nau7802.c
+++ b/drivers/iio/adc/nau7802.c
@@ -79,10 +79,29 @@ static const struct iio_chan_spec nau7802_chan_array[] = {
 static const u16 nau7802_sample_freq_avail[] = {10, 20, 40, 80,
                                                 10, 10, 10, 320};
 
+static ssize_t nau7802_show_scales(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        struct nau7802_state *st = iio_priv(dev_to_iio_dev(dev));
+        int i, len = 0;
+
+        for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++)
+                len += scnprintf(buf + len, PAGE_SIZE - len, "0.%09d ",
+                                 st->scale_avail[i]);
+
+        buf[len-1] = '\n';
+
+        return len;
+}
+
 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("10 40 80 320");
 
+static IIO_DEVICE_ATTR(in_voltage_scale_available, S_IRUGO, nau7802_show_scales,
+                       NULL, 0);
+
 static struct attribute *nau7802_attributes[] = {
         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
+        &iio_dev_attr_in_voltage_scale_available.dev_attr.attr,
         NULL
 };
 
diff --git a/drivers/iio/adc/ti-ads1015.c b/drivers/iio/adc/ti-ads1015.c
index 73cbf0b54e54..8be192a84893 100644
--- a/drivers/iio/adc/ti-ads1015.c
+++ b/drivers/iio/adc/ti-ads1015.c
@@ -55,6 +55,11 @@
 #define ADS1015_DEFAULT_DATA_RATE       4
 #define ADS1015_DEFAULT_CHAN            0
 
+enum {
+        ADS1015,
+        ADS1115,
+};
+
 enum ads1015_channels {
         ADS1015_AIN0_AIN1 = 0,
         ADS1015_AIN0_AIN3,
@@ -71,6 +76,10 @@ static const unsigned int ads1015_data_rate[] = {
         128, 250, 490, 920, 1600, 2400, 3300, 3300
 };
 
+static const unsigned int ads1115_data_rate[] = {
+        8, 16, 32, 64, 128, 250, 475, 860
+};
+
 static const struct {
         int scale;
         int uscale;
@@ -101,6 +110,7 @@ static const struct {
                 .shift = 4,                                     \
                 .endianness = IIO_CPU,                          \
         },                                                      \
+        .datasheet_name = "AIN"#_chan,                          \
 }
 
 #define ADS1015_V_DIFF_CHAN(_chan, _chan2, _addr) {             \
@@ -121,6 +131,45 @@ static const struct {
                 .shift = 4,                                     \
                 .endianness = IIO_CPU,                          \
         },                                                      \
+        .datasheet_name = "AIN"#_chan"-AIN"#_chan2,             \
+}
+
+#define ADS1115_V_CHAN(_chan, _addr) {                          \
+        .type = IIO_VOLTAGE,                                    \
+        .indexed = 1,                                           \
+        .address = _addr,                                       \
+        .channel = _chan,                                       \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |          \
+                                BIT(IIO_CHAN_INFO_SCALE) |      \
+                                BIT(IIO_CHAN_INFO_SAMP_FREQ),   \
+        .scan_index = _addr,                                    \
+        .scan_type = {                                          \
+                .sign = 's',                                    \
+                .realbits = 16,                                 \
+                .storagebits = 16,                              \
+                .endianness = IIO_CPU,                          \
+        },                                                      \
+        .datasheet_name = "AIN"#_chan,                          \
+}
+
+#define ADS1115_V_DIFF_CHAN(_chan, _chan2, _addr) {             \
+        .type = IIO_VOLTAGE,                                    \
+        .differential = 1,                                      \
+        .indexed = 1,                                           \
+        .address = _addr,                                       \
+        .channel = _chan,                                       \
+        .channel2 = _chan2,                                     \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |          \
+                                BIT(IIO_CHAN_INFO_SCALE) |      \
+                                BIT(IIO_CHAN_INFO_SAMP_FREQ),   \
+        .scan_index = _addr,                                    \
+        .scan_type = {                                          \
+                .sign = 's',                                    \
+                .realbits = 16,                                 \
+                .storagebits = 16,                              \
+                .endianness = IIO_CPU,                          \
+        },                                                      \
+        .datasheet_name = "AIN"#_chan"-AIN"#_chan2,             \
 }
 
 struct ads1015_data {
@@ -131,6 +180,8 @@ struct ads1015_data {
          */
         struct mutex lock;
         struct ads1015_channel_data channel_data[ADS1015_CHANNELS];
+
+        unsigned int *data_rate;
 };
 
 static bool ads1015_is_writeable_reg(struct device *dev, unsigned int reg)
@@ -157,6 +208,18 @@ static const struct iio_chan_spec ads1015_channels[] = {
         IIO_CHAN_SOFT_TIMESTAMP(ADS1015_TIMESTAMP),
 };
 
+static const struct iio_chan_spec ads1115_channels[] = {
+        ADS1115_V_DIFF_CHAN(0, 1, ADS1015_AIN0_AIN1),
+        ADS1115_V_DIFF_CHAN(0, 3, ADS1015_AIN0_AIN3),
+        ADS1115_V_DIFF_CHAN(1, 3, ADS1015_AIN1_AIN3),
+        ADS1115_V_DIFF_CHAN(2, 3, ADS1015_AIN2_AIN3),
+        ADS1115_V_CHAN(0, ADS1015_AIN0),
+        ADS1115_V_CHAN(1, ADS1015_AIN1),
+        ADS1115_V_CHAN(2, ADS1015_AIN2),
+        ADS1115_V_CHAN(3, ADS1015_AIN3),
+        IIO_CHAN_SOFT_TIMESTAMP(ADS1015_TIMESTAMP),
+};
+
 static int ads1015_set_power_state(struct ads1015_data *data, bool on)
 {
         int ret;
@@ -196,7 +259,7 @@ int ads1015_get_adc_result(struct ads1015_data *data, int chan, int *val)
                 return ret;
 
         if (change) {
-                conv_time = DIV_ROUND_UP(USEC_PER_SEC, ads1015_data_rate[dr]);
+                conv_time = DIV_ROUND_UP(USEC_PER_SEC, data->data_rate[dr]);
                 usleep_range(conv_time, conv_time + 1);
         }
 
@@ -263,7 +326,7 @@ static int ads1015_set_data_rate(struct ads1015_data *data, int chan, int rate)
         int i, ret, rindex = -1;
 
         for (i = 0; i < ARRAY_SIZE(ads1015_data_rate); i++)
-                if (ads1015_data_rate[i] == rate) {
+                if (data->data_rate[i] == rate) {
                         rindex = i;
                         break;
                 }
@@ -291,7 +354,9 @@ static int ads1015_read_raw(struct iio_dev *indio_dev,
         mutex_lock(&indio_dev->mlock);
         mutex_lock(&data->lock);
         switch (mask) {
-        case IIO_CHAN_INFO_RAW:
+        case IIO_CHAN_INFO_RAW: {
+                int shift = chan->scan_type.shift;
+
                 if (iio_buffer_enabled(indio_dev)) {
                         ret = -EBUSY;
                         break;
@@ -307,8 +372,7 @@ static int ads1015_read_raw(struct iio_dev *indio_dev,
                         break;
                 }
 
-                /* 12 bit res, D0 is bit 4 in conversion register */
-                *val = sign_extend32(*val >> 4, 11);
+                *val = sign_extend32(*val >> shift, 15 - shift);
 
                 ret = ads1015_set_power_state(data, false);
                 if (ret < 0)
@@ -316,6 +380,7 @@ static int ads1015_read_raw(struct iio_dev *indio_dev,
 
                 ret = IIO_VAL_INT;
                 break;
+        }
         case IIO_CHAN_INFO_SCALE:
                 idx = data->channel_data[chan->address].pga;
                 *val = ads1015_scale[idx].scale;
@@ -324,7 +389,7 @@ static int ads1015_read_raw(struct iio_dev *indio_dev,
                 break;
         case IIO_CHAN_INFO_SAMP_FREQ:
                 idx = data->channel_data[chan->address].data_rate;
-                *val = ads1015_data_rate[idx];
+                *val = data->data_rate[idx];
                 ret = IIO_VAL_INT;
                 break;
         default:
@@ -380,12 +445,15 @@ static const struct iio_buffer_setup_ops ads1015_buffer_setup_ops = {
 };
 
 static IIO_CONST_ATTR(scale_available, "3 2 1 0.5 0.25 0.125");
-static IIO_CONST_ATTR(sampling_frequency_available,
-                      "128 250 490 920 1600 2400 3300");
+
+static IIO_CONST_ATTR_NAMED(ads1015_sampling_frequency_available,
+        sampling_frequency_available, "128 250 490 920 1600 2400 3300");
+static IIO_CONST_ATTR_NAMED(ads1115_sampling_frequency_available,
+        sampling_frequency_available, "8 16 32 64 128 250 475 860");
 
 static struct attribute *ads1015_attributes[] = {
         &iio_const_attr_scale_available.dev_attr.attr,
-        &iio_const_attr_sampling_frequency_available.dev_attr.attr,
+        &iio_const_attr_ads1015_sampling_frequency_available.dev_attr.attr,
         NULL,
 };
 
@@ -393,11 +461,28 @@ static const struct attribute_group ads1015_attribute_group = {
         .attrs = ads1015_attributes,
 };
 
-static const struct iio_info ads1015_info = {
+static struct attribute *ads1115_attributes[] = {
+        &iio_const_attr_scale_available.dev_attr.attr,
+        &iio_const_attr_ads1115_sampling_frequency_available.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group ads1115_attribute_group = {
+        .attrs = ads1115_attributes,
+};
+
+static struct iio_info ads1015_info = {
+        .driver_module  = THIS_MODULE,
+        .read_raw       = ads1015_read_raw,
+        .write_raw      = ads1015_write_raw,
+        .attrs          = &ads1015_attribute_group,
+};
+
+static struct iio_info ads1115_info = {
         .driver_module  = THIS_MODULE,
         .read_raw       = ads1015_read_raw,
         .write_raw      = ads1015_write_raw,
-        .attrs          = &ads1015_attribute_group,
+        .attrs          = &ads1115_attribute_group,
 };
 
 #ifdef CONFIG_OF
@@ -500,12 +585,24 @@ static int ads1015_probe(struct i2c_client *client,
         mutex_init(&data->lock);
 
         indio_dev->dev.parent = &client->dev;
-        indio_dev->info = &ads1015_info;
         indio_dev->name = ADS1015_DRV_NAME;
-        indio_dev->channels = ads1015_channels;
-        indio_dev->num_channels = ARRAY_SIZE(ads1015_channels);
         indio_dev->modes = INDIO_DIRECT_MODE;
 
+        switch (id->driver_data) {
+        case ADS1015:
+                indio_dev->channels = ads1015_channels;
+                indio_dev->num_channels = ARRAY_SIZE(ads1015_channels);
+                indio_dev->info = &ads1015_info;
+                data->data_rate = (unsigned int *) &ads1015_data_rate;
+                break;
+        case ADS1115:
+                indio_dev->channels = ads1115_channels;
+                indio_dev->num_channels = ARRAY_SIZE(ads1115_channels);
+                indio_dev->info = &ads1115_info;
+                data->data_rate = (unsigned int *) &ads1115_data_rate;
+                break;
+        }
+
         /* we need to keep this ABI the same as used by hwmon ADS1015 driver */
         ads1015_get_channels_config(client);
 
@@ -590,7 +687,8 @@ static const struct dev_pm_ops ads1015_pm_ops = {
 };
 
 static const struct i2c_device_id ads1015_id[] = {
-        {"ads1015", 0},
+        {"ads1015", ADS1015},
+        {"ads1115", ADS1115},
         {}
 };
 MODULE_DEVICE_TABLE(i2c, ads1015_id);
diff --git a/drivers/iio/adc/ti_am335x_adc.c b/drivers/iio/adc/ti_am335x_adc.c
index c1e05532d437..8a368756881b 100644
--- a/drivers/iio/adc/ti_am335x_adc.c
+++ b/drivers/iio/adc/ti_am335x_adc.c
@@ -326,8 +326,7 @@ static int tiadc_channel_init(struct iio_dev *indio_dev, int channels)
         int i;
 
         indio_dev->num_channels = channels;
-        chan_array = kcalloc(channels,
-                        sizeof(struct iio_chan_spec), GFP_KERNEL);
+        chan_array = kcalloc(channels, sizeof(*chan_array), GFP_KERNEL);
         if (chan_array == NULL)
                 return -ENOMEM;
 
@@ -467,8 +466,7 @@ static int tiadc_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        indio_dev = devm_iio_device_alloc(&pdev->dev,
-                                          sizeof(struct tiadc_device));
+        indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*indio_dev));
         if (indio_dev == NULL) {
                 dev_err(&pdev->dev, "failed to allocate iio device\n");
                 return -ENOMEM;
@@ -531,8 +529,7 @@ static int tiadc_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int tiadc_suspend(struct device *dev)
+static int __maybe_unused tiadc_suspend(struct device *dev)
 {
         struct iio_dev *indio_dev = dev_get_drvdata(dev);
         struct tiadc_device *adc_dev = iio_priv(indio_dev);
@@ -550,7 +547,7 @@ static int tiadc_suspend(struct device *dev)
         return 0;
 }
 
-static int tiadc_resume(struct device *dev)
+static int __maybe_unused tiadc_resume(struct device *dev)
 {
         struct iio_dev *indio_dev = dev_get_drvdata(dev);
         struct tiadc_device *adc_dev = iio_priv(indio_dev);
@@ -567,14 +564,7 @@ static int tiadc_resume(struct device *dev)
         return 0;
 }
 
-static const struct dev_pm_ops tiadc_pm_ops = {
-        .suspend = tiadc_suspend,
-        .resume = tiadc_resume,
-};
-#define TIADC_PM_OPS (&tiadc_pm_ops)
-#else
-#define TIADC_PM_OPS NULL
-#endif
+static SIMPLE_DEV_PM_OPS(tiadc_pm_ops, tiadc_suspend, tiadc_resume);
 
 static const struct of_device_id ti_adc_dt_ids[] = {
         { .compatible = "ti,am3359-adc", },
@@ -585,7 +575,7 @@ MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
 static struct platform_driver tiadc_driver = {
         .driver = {
                 .name   = "TI-am335x-adc",
-                .pm     = TIADC_PM_OPS,
+                .pm     = &tiadc_pm_ops,
                 .of_match_table = ti_adc_dt_ids,
         },
         .probe  = tiadc_probe,
diff --git a/drivers/iio/chemical/Kconfig b/drivers/iio/chemical/Kconfig
index f73290f84c90..4bcc025e8c8a 100644
--- a/drivers/iio/chemical/Kconfig
+++ b/drivers/iio/chemical/Kconfig
@@ -5,15 +5,17 @@
 menu "Chemical Sensors"
 
 config ATLAS_PH_SENSOR
-        tristate "Atlas Scientific OEM pH-SM sensor"
+        tristate "Atlas Scientific OEM SM sensors"
         depends on I2C
         select REGMAP_I2C
         select IIO_BUFFER
         select IIO_TRIGGERED_BUFFER
         select IRQ_WORK
         help
-         Say Y here to build I2C interface support for the Atlas
-         Scientific OEM pH-SM sensor.
+         Say Y here to build I2C interface support for the following
+         Atlas Scientific OEM SM sensors:
+            * pH SM sensor
+            * EC SM sensor
 
          To compile this driver as module, choose M here: the
          module will be called atlas-ph-sensor.
diff --git a/drivers/iio/chemical/atlas-ph-sensor.c b/drivers/iio/chemical/atlas-ph-sensor.c
index 62b37cd8fb56..02e85db5d31f 100644
--- a/drivers/iio/chemical/atlas-ph-sensor.c
+++ b/drivers/iio/chemical/atlas-ph-sensor.c
@@ -24,6 +24,7 @@
 #include <linux/irq_work.h>
 #include <linux/gpio.h>
 #include <linux/i2c.h>
+#include <linux/of_device.h>
 #include <linux/regmap.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/buffer.h>
@@ -43,29 +44,50 @@
 
 #define ATLAS_REG_PWR_CONTROL           0x06
 
-#define ATLAS_REG_CALIB_STATUS          0x0d
-#define ATLAS_REG_CALIB_STATUS_MASK     0x07
-#define ATLAS_REG_CALIB_STATUS_LOW      BIT(0)
-#define ATLAS_REG_CALIB_STATUS_MID      BIT(1)
-#define ATLAS_REG_CALIB_STATUS_HIGH     BIT(2)
+#define ATLAS_REG_PH_CALIB_STATUS       0x0d
+#define ATLAS_REG_PH_CALIB_STATUS_MASK  0x07
+#define ATLAS_REG_PH_CALIB_STATUS_LOW   BIT(0)
+#define ATLAS_REG_PH_CALIB_STATUS_MID   BIT(1)
+#define ATLAS_REG_PH_CALIB_STATUS_HIGH  BIT(2)
 
-#define ATLAS_REG_TEMP_DATA             0x0e
+#define ATLAS_REG_EC_CALIB_STATUS               0x0f
+#define ATLAS_REG_EC_CALIB_STATUS_MASK          0x0f
+#define ATLAS_REG_EC_CALIB_STATUS_DRY           BIT(0)
+#define ATLAS_REG_EC_CALIB_STATUS_SINGLE        BIT(1)
+#define ATLAS_REG_EC_CALIB_STATUS_LOW           BIT(2)
+#define ATLAS_REG_EC_CALIB_STATUS_HIGH          BIT(3)
+
+#define ATLAS_REG_PH_TEMP_DATA          0x0e
 #define ATLAS_REG_PH_DATA               0x16
 
+#define ATLAS_REG_EC_PROBE              0x08
+#define ATLAS_REG_EC_TEMP_DATA          0x10
+#define ATLAS_REG_EC_DATA               0x18
+#define ATLAS_REG_TDS_DATA              0x1c
+#define ATLAS_REG_PSS_DATA              0x20
+
 #define ATLAS_PH_INT_TIME_IN_US         450000
+#define ATLAS_EC_INT_TIME_IN_US         650000
+
+enum {
+        ATLAS_PH_SM,
+        ATLAS_EC_SM,
+};
 
 struct atlas_data {
         struct i2c_client *client;
         struct iio_trigger *trig;
+        struct atlas_device *chip;
         struct regmap *regmap;
         struct irq_work work;
 
-        __be32 buffer[4]; /* 32-bit pH data + 32-bit pad + 64-bit timestamp */
+        __be32 buffer[6]; /* 96-bit data + 32-bit pad + 64-bit timestamp */
 };
 
 static const struct regmap_range atlas_volatile_ranges[] = {
         regmap_reg_range(ATLAS_REG_INT_CONTROL, ATLAS_REG_INT_CONTROL),
         regmap_reg_range(ATLAS_REG_PH_DATA, ATLAS_REG_PH_DATA + 4),
+        regmap_reg_range(ATLAS_REG_EC_DATA, ATLAS_REG_PSS_DATA + 4),
 };
 
 static const struct regmap_access_table atlas_volatile_table = {
@@ -80,13 +102,14 @@ static const struct regmap_config atlas_regmap_config = {
         .val_bits = 8,
 
         .volatile_table = &atlas_volatile_table,
-        .max_register = ATLAS_REG_PH_DATA + 4,
+        .max_register = ATLAS_REG_PSS_DATA + 4,
         .cache_type = REGCACHE_RBTREE,
 };
 
-static const struct iio_chan_spec atlas_channels[] = {
+static const struct iio_chan_spec atlas_ph_channels[] = {
         {
                 .type = IIO_PH,
+                .address = ATLAS_REG_PH_DATA,
                 .info_mask_separate =
                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
                 .scan_index = 0,
@@ -100,7 +123,7 @@ static const struct iio_chan_spec atlas_channels[] = {
         IIO_CHAN_SOFT_TIMESTAMP(1),
         {
                 .type = IIO_TEMP,
-                .address = ATLAS_REG_TEMP_DATA,
+                .address = ATLAS_REG_PH_TEMP_DATA,
                 .info_mask_separate =
                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
                 .output = 1,
@@ -108,6 +131,142 @@ static const struct iio_chan_spec atlas_channels[] = {
         },
 };
 
+#define ATLAS_EC_CHANNEL(_idx, _addr) \
+        {\
+                .type = IIO_CONCENTRATION, \
+                .indexed = 1, \
+                .channel = _idx, \
+                .address = _addr, \
+                .info_mask_separate = \
+                        BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \
+                .scan_index = _idx + 1, \
+                .scan_type = { \
+                        .sign = 'u', \
+                        .realbits = 32, \
+                        .storagebits = 32, \
+                        .endianness = IIO_BE, \
+                }, \
+        }
+
+static const struct iio_chan_spec atlas_ec_channels[] = {
+        {
+                .type = IIO_ELECTRICALCONDUCTIVITY,
+                .address = ATLAS_REG_EC_DATA,
+                .info_mask_separate =
+                        BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
+                .scan_index = 0,
+                .scan_type = {
+                        .sign = 'u',
+                        .realbits = 32,
+                        .storagebits = 32,
+                        .endianness = IIO_BE,
+                },
+        },
+        ATLAS_EC_CHANNEL(0, ATLAS_REG_TDS_DATA),
+        ATLAS_EC_CHANNEL(1, ATLAS_REG_PSS_DATA),
+        IIO_CHAN_SOFT_TIMESTAMP(3),
+        {
+                .type = IIO_TEMP,
+                .address = ATLAS_REG_EC_TEMP_DATA,
+                .info_mask_separate =
+                        BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
+                .output = 1,
+                .scan_index = -1
+        },
+};
+
+static int atlas_check_ph_calibration(struct atlas_data *data)
+{
+        struct device *dev = &data->client->dev;
+        int ret;
+        unsigned int val;
+
+        ret = regmap_read(data->regmap, ATLAS_REG_PH_CALIB_STATUS, &val);
+        if (ret)
+                return ret;
+
+        if (!(val & ATLAS_REG_PH_CALIB_STATUS_MASK)) {
+                dev_warn(dev, "device has not been calibrated\n");
+                return 0;
+        }
+
+        if (!(val & ATLAS_REG_PH_CALIB_STATUS_LOW))
+                dev_warn(dev, "device missing low point calibration\n");
+
+        if (!(val & ATLAS_REG_PH_CALIB_STATUS_MID))
+                dev_warn(dev, "device missing mid point calibration\n");
+
+        if (!(val & ATLAS_REG_PH_CALIB_STATUS_HIGH))
+                dev_warn(dev, "device missing high point calibration\n");
+
+        return 0;
+}
+
+static int atlas_check_ec_calibration(struct atlas_data *data)
+{
+        struct device *dev = &data->client->dev;
+        int ret;
+        unsigned int val;
+
+        ret = regmap_bulk_read(data->regmap, ATLAS_REG_EC_PROBE, &val, 2);
+        if (ret)
+                return ret;
+
+        dev_info(dev, "probe set to K = %d.%.2d", be16_to_cpu(val) / 100,
+                                                 be16_to_cpu(val) % 100);
+
+        ret = regmap_read(data->regmap, ATLAS_REG_EC_CALIB_STATUS, &val);
+        if (ret)
+                return ret;
+
+        if (!(val & ATLAS_REG_EC_CALIB_STATUS_MASK)) {
+                dev_warn(dev, "device has not been calibrated\n");
+                return 0;
+        }
+
+        if (!(val & ATLAS_REG_EC_CALIB_STATUS_DRY))
+                dev_warn(dev, "device missing dry point calibration\n");
+
+        if (val & ATLAS_REG_EC_CALIB_STATUS_SINGLE) {
+                dev_warn(dev, "device using single point calibration\n");
+        } else {
+                if (!(val & ATLAS_REG_EC_CALIB_STATUS_LOW))
+                        dev_warn(dev, "device missing low point calibration\n");
+
+                if (!(val & ATLAS_REG_EC_CALIB_STATUS_HIGH))
+                        dev_warn(dev, "device missing high point calibration\n");
+        }
+
+        return 0;
+}
+
+struct atlas_device {
+        const struct iio_chan_spec *channels;
+        int num_channels;
+        int data_reg;
+
+        int (*calibration)(struct atlas_data *data);
+        int delay;
+};
+
+static struct atlas_device atlas_devices[] = {
+        [ATLAS_PH_SM] = {
+                                .channels = atlas_ph_channels,
+                                .num_channels = 3,
+                                .data_reg = ATLAS_REG_PH_DATA,
+                                .calibration = &atlas_check_ph_calibration,
+                                .delay = ATLAS_PH_INT_TIME_IN_US,
+        },
+        [ATLAS_EC_SM] = {
+                                .channels = atlas_ec_channels,
+                                .num_channels = 5,
+                                .data_reg = ATLAS_REG_EC_DATA,
+                                .calibration = &atlas_check_ec_calibration,
+                                .delay = ATLAS_EC_INT_TIME_IN_US,
+        },
+
+};
+
 static int atlas_set_powermode(struct atlas_data *data, int on)
 {
         return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on);
@@ -178,8 +337,9 @@ static irqreturn_t atlas_trigger_handler(int irq, void *private)
         struct atlas_data *data = iio_priv(indio_dev);
         int ret;
 
-        ret = regmap_bulk_read(data->regmap, ATLAS_REG_PH_DATA,
-                              (u8 *) &data->buffer, sizeof(data->buffer[0]));
+        ret = regmap_bulk_read(data->regmap, data->chip->data_reg,
+                              (u8 *) &data->buffer,
+                              sizeof(__be32) * (data->chip->num_channels - 2));
 
         if (!ret)
                 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
@@ -200,7 +360,7 @@ static irqreturn_t atlas_interrupt_handler(int irq, void *private)
         return IRQ_HANDLED;
 }
 
-static int atlas_read_ph_measurement(struct atlas_data *data, __be32 *val)
+static int atlas_read_measurement(struct atlas_data *data, int reg, __be32 *val)
 {
         struct device *dev = &data->client->dev;
         int suspended = pm_runtime_suspended(dev);
@@ -213,11 +373,9 @@ static int atlas_read_ph_measurement(struct atlas_data *data, __be32 *val)
         }
 
         if (suspended)
-                usleep_range(ATLAS_PH_INT_TIME_IN_US,
-                             ATLAS_PH_INT_TIME_IN_US + 100000);
+                usleep_range(data->chip->delay, data->chip->delay + 100000);
 
-        ret = regmap_bulk_read(data->regmap, ATLAS_REG_PH_DATA,
-                              (u8 *) val, sizeof(*val));
+        ret = regmap_bulk_read(data->regmap, reg, (u8 *) val, sizeof(*val));
 
         pm_runtime_mark_last_busy(dev);
         pm_runtime_put_autosuspend(dev);
@@ -242,12 +400,15 @@ static int atlas_read_raw(struct iio_dev *indio_dev,
                                               (u8 *) &reg, sizeof(reg));
                         break;
                 case IIO_PH:
+                case IIO_CONCENTRATION:
+                case IIO_ELECTRICALCONDUCTIVITY:
                         mutex_lock(&indio_dev->mlock);
 
                         if (iio_buffer_enabled(indio_dev))
                                 ret = -EBUSY;
                         else
-                                ret = atlas_read_ph_measurement(data, &reg);
+                                ret = atlas_read_measurement(data,
+                                                        chan->address, &reg);
 
                         mutex_unlock(&indio_dev->mlock);
                         break;
@@ -271,6 +432,14 @@ static int atlas_read_raw(struct iio_dev *indio_dev,
                         *val = 1; /* 0.001 */
                         *val2 = 1000;
                         break;
+                case IIO_ELECTRICALCONDUCTIVITY:
+                        *val = 1; /* 0.00001 */
+                        *val = 100000;
+                        break;
+                case IIO_CONCENTRATION:
+                        *val = 0; /* 0.000000001 */
+                        *val2 = 1000;
+                        return IIO_VAL_INT_PLUS_NANO;
                 default:
                         return -EINVAL;
                 }
@@ -303,37 +472,26 @@ static const struct iio_info atlas_info = {
         .write_raw = atlas_write_raw,
 };
 
-static int atlas_check_calibration(struct atlas_data *data)
-{
-        struct device *dev = &data->client->dev;
-        int ret;
-        unsigned int val;
-
-        ret = regmap_read(data->regmap, ATLAS_REG_CALIB_STATUS, &val);
-        if (ret)
-                return ret;
-
-        if (!(val & ATLAS_REG_CALIB_STATUS_MASK)) {
-                dev_warn(dev, "device has not been calibrated\n");
-                return 0;
-        }
-
-        if (!(val & ATLAS_REG_CALIB_STATUS_LOW))
-                dev_warn(dev, "device missing low point calibration\n");
-
-        if (!(val & ATLAS_REG_CALIB_STATUS_MID))
-                dev_warn(dev, "device missing mid point calibration\n");
-
-        if (!(val & ATLAS_REG_CALIB_STATUS_HIGH))
-                dev_warn(dev, "device missing high point calibration\n");
+static const struct i2c_device_id atlas_id[] = {
+        { "atlas-ph-sm", ATLAS_PH_SM},
+        { "atlas-ec-sm", ATLAS_EC_SM},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, atlas_id);
 
-        return 0;
+static const struct of_device_id atlas_dt_ids[] = {
+        { .compatible = "atlas,ph-sm", .data = (void *)ATLAS_PH_SM, },
+        { .compatible = "atlas,ec-sm", .data = (void *)ATLAS_EC_SM, },
+        { }
 };
+MODULE_DEVICE_TABLE(of, atlas_dt_ids);
 
 static int atlas_probe(struct i2c_client *client,
                        const struct i2c_device_id *id)
 {
         struct atlas_data *data;
+        struct atlas_device *chip;
+        const struct of_device_id *of_id;
         struct iio_trigger *trig;
         struct iio_dev *indio_dev;
         int ret;
@@ -342,10 +500,16 @@ static int atlas_probe(struct i2c_client *client,
         if (!indio_dev)
                 return -ENOMEM;
 
+        of_id = of_match_device(atlas_dt_ids, &client->dev);
+        if (!of_id)
+                chip = &atlas_devices[id->driver_data];
+        else
+                chip = &atlas_devices[(unsigned long)of_id->data];
+
         indio_dev->info = &atlas_info;
         indio_dev->name = ATLAS_DRV_NAME;
-        indio_dev->channels = atlas_channels;
-        indio_dev->num_channels = ARRAY_SIZE(atlas_channels);
+        indio_dev->channels = chip->channels;
+        indio_dev->num_channels = chip->num_channels;
         indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;
         indio_dev->dev.parent = &client->dev;
 
@@ -358,6 +522,7 @@ static int atlas_probe(struct i2c_client *client,
         data = iio_priv(indio_dev);
         data->client = client;
         data->trig = trig;
+        data->chip = chip;
         trig->dev.parent = indio_dev->dev.parent;
         trig->ops = &atlas_interrupt_trigger_ops;
         iio_trigger_set_drvdata(trig, indio_dev);
@@ -379,7 +544,7 @@ static int atlas_probe(struct i2c_client *client,
                 return -EINVAL;
         }
 
-        ret = atlas_check_calibration(data);
+        ret = chip->calibration(data);
         if (ret)
                 return ret;
 
@@ -480,18 +645,6 @@ static const struct dev_pm_ops atlas_pm_ops = {
                            atlas_runtime_resume, NULL)
 };
 
-static const struct i2c_device_id atlas_id[] = {
-        { "atlas-ph-sm", 0 },
-        {}
-};
-MODULE_DEVICE_TABLE(i2c, atlas_id);
-
-static const struct of_device_id atlas_dt_ids[] = {
-        { .compatible = "atlas,ph-sm" },
-        { }
-};
-MODULE_DEVICE_TABLE(of, atlas_dt_ids);
-
 static struct i2c_driver atlas_driver = {
         .driver = {
                 .name   = ATLAS_DRV_NAME,
diff --git a/drivers/iio/common/st_sensors/st_sensors_buffer.c b/drivers/iio/common/st_sensors/st_sensors_buffer.c
index f1693dbebb8a..50afc0f8f16b 100644
--- a/drivers/iio/common/st_sensors/st_sensors_buffer.c
+++ b/drivers/iio/common/st_sensors/st_sensors_buffer.c
@@ -22,7 +22,7 @@
 #include <linux/iio/common/st_sensors.h>
 
 
-int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf)
+static int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf)
 {
         int i, len;
         int total = 0;
@@ -49,7 +49,6 @@ int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf)
 
         return total;
 }
-EXPORT_SYMBOL(st_sensors_get_buffer_element);
 
 irqreturn_t st_sensors_trigger_handler(int irq, void *p)
 {
diff --git a/drivers/iio/common/st_sensors/st_sensors_core.c b/drivers/iio/common/st_sensors/st_sensors_core.c
index 9e59c90f6a8d..6db12ea034d3 100644
--- a/drivers/iio/common/st_sensors/st_sensors_core.c
+++ b/drivers/iio/common/st_sensors/st_sensors_core.c
@@ -228,7 +228,7 @@ int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable)
 }
 EXPORT_SYMBOL(st_sensors_set_axis_enable);
 
-void st_sensors_power_enable(struct iio_dev *indio_dev)
+int st_sensors_power_enable(struct iio_dev *indio_dev)
 {
         struct st_sensor_data *pdata = iio_priv(indio_dev);
         int err;
@@ -237,18 +237,37 @@ void st_sensors_power_enable(struct iio_dev *indio_dev)
         pdata->vdd = devm_regulator_get_optional(indio_dev->dev.parent, "vdd");
         if (!IS_ERR(pdata->vdd)) {
                 err = regulator_enable(pdata->vdd);
-                if (err != 0)
+                if (err != 0) {
                         dev_warn(&indio_dev->dev,
                                  "Failed to enable specified Vdd supply\n");
+                        return err;
+                }
+        } else {
+                err = PTR_ERR(pdata->vdd);
+                if (err != -ENODEV)
+                        return err;
         }
 
         pdata->vdd_io = devm_regulator_get_optional(indio_dev->dev.parent, "vddio");
         if (!IS_ERR(pdata->vdd_io)) {
                 err = regulator_enable(pdata->vdd_io);
-                if (err != 0)
+                if (err != 0) {
                         dev_warn(&indio_dev->dev,
                                  "Failed to enable specified Vdd_IO supply\n");
+                        goto st_sensors_disable_vdd;
+                }
+        } else {
+                err = PTR_ERR(pdata->vdd_io);
+                if (err != -ENODEV)
+                        goto st_sensors_disable_vdd;
         }
+
+        return 0;
+
+st_sensors_disable_vdd:
+        if (!IS_ERR_OR_NULL(pdata->vdd))
+                regulator_disable(pdata->vdd);
+        return err;
 }
 EXPORT_SYMBOL(st_sensors_power_enable);
 
@@ -256,10 +275,10 @@ void st_sensors_power_disable(struct iio_dev *indio_dev)
 {
         struct st_sensor_data *pdata = iio_priv(indio_dev);
 
-        if (!IS_ERR(pdata->vdd))
+        if (!IS_ERR_OR_NULL(pdata->vdd))
                 regulator_disable(pdata->vdd);
 
-        if (!IS_ERR(pdata->vdd_io))
+        if (!IS_ERR_OR_NULL(pdata->vdd_io))
                 regulator_disable(pdata->vdd_io);
 }
 EXPORT_SYMBOL(st_sensors_power_disable);
diff --git a/drivers/iio/common/st_sensors/st_sensors_i2c.c b/drivers/iio/common/st_sensors/st_sensors_i2c.c
index 98cfee296d46..b43aa36031f8 100644
--- a/drivers/iio/common/st_sensors/st_sensors_i2c.c
+++ b/drivers/iio/common/st_sensors/st_sensors_i2c.c
@@ -48,8 +48,8 @@ static int st_sensors_i2c_read_multiple_byte(
         if (multiread_bit)
                 reg_addr |= ST_SENSORS_I2C_MULTIREAD;
 
-        return i2c_smbus_read_i2c_block_data(to_i2c_client(dev),
-                                                        reg_addr, len, data);
+        return i2c_smbus_read_i2c_block_data_or_emulated(to_i2c_client(dev),
+                                                         reg_addr, len, data);
 }
 
 static int st_sensors_i2c_write_byte(struct st_sensor_transfer_buffer *tb,
diff --git a/drivers/iio/dummy/Kconfig b/drivers/iio/dummy/Kconfig
index 71805ced1aae..aa5824d96a43 100644
--- a/drivers/iio/dummy/Kconfig
+++ b/drivers/iio/dummy/Kconfig
@@ -10,6 +10,7 @@ config IIO_DUMMY_EVGEN
 
 config IIO_SIMPLE_DUMMY
        tristate "An example driver with no hardware requirements"
+       depends on IIO_SW_DEVICE
        help
          Driver intended mainly as documentation for how to write
          a driver. May also be useful for testing userspace code
diff --git a/drivers/iio/dummy/iio_simple_dummy.c b/drivers/iio/dummy/iio_simple_dummy.c
index 43fe4ba7d0dc..ad3410e528b6 100644
--- a/drivers/iio/dummy/iio_simple_dummy.c
+++ b/drivers/iio/dummy/iio_simple_dummy.c
@@ -17,26 +17,18 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/module.h>
+#include <linux/string.h>
 
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
 #include <linux/iio/events.h>
 #include <linux/iio/buffer.h>
+#include <linux/iio/sw_device.h>
 #include "iio_simple_dummy.h"
 
-/*
- * A few elements needed to fake a bus for this driver
- * Note instances parameter controls how many of these
- * dummy devices are registered.
- */
-static unsigned instances = 1;
-module_param(instances, uint, 0);
-
-/* Pointer array used to fake bus elements */
-static struct iio_dev **iio_dummy_devs;
-
-/* Fake a name for the part number, usually obtained from the id table */
-static const char *iio_dummy_part_number = "iio_dummy_part_no";
+static struct config_item_type iio_dummy_type = {
+        .ct_owner = THIS_MODULE,
+};
 
 /**
  * struct iio_dummy_accel_calibscale - realworld to register mapping
@@ -572,12 +564,18 @@ static int iio_dummy_init_device(struct iio_dev *indio_dev)
  *                      const struct i2c_device_id *id)
  * SPI: iio_dummy_probe(struct spi_device *spi)
  */
-static int iio_dummy_probe(int index)
+static struct iio_sw_device *iio_dummy_probe(const char *name)
 {
         int ret;
         struct iio_dev *indio_dev;
         struct iio_dummy_state *st;
+        struct iio_sw_device *swd;
 
+        swd = kzalloc(sizeof(*swd), GFP_KERNEL);
+        if (!swd) {
+                ret = -ENOMEM;
+                goto error_kzalloc;
+        }
         /*
          * Allocate an IIO device.
          *
@@ -608,7 +606,7 @@ static int iio_dummy_probe(int index)
          * i2c_set_clientdata(client, indio_dev);
          * spi_set_drvdata(spi, indio_dev);
          */
-        iio_dummy_devs[index] = indio_dev;
+        swd->device = indio_dev;
 
         /*
          * Set the device name.
@@ -619,7 +617,7 @@ static int iio_dummy_probe(int index)
          *    indio_dev->name = id->name;
          *    indio_dev->name = spi_get_device_id(spi)->name;
          */
-        indio_dev->name = iio_dummy_part_number;
+        indio_dev->name = kstrdup(name, GFP_KERNEL);
 
         /* Provide description of available channels */
         indio_dev->channels = iio_dummy_channels;
@@ -646,7 +644,9 @@ static int iio_dummy_probe(int index)
         if (ret < 0)
                 goto error_unconfigure_buffer;
 
-        return 0;
+        iio_swd_group_init_type_name(swd, name, &iio_dummy_type);
+
+        return swd;
 error_unconfigure_buffer:
         iio_simple_dummy_unconfigure_buffer(indio_dev);
 error_unregister_events:
@@ -654,16 +654,18 @@ error_unregister_events:
 error_free_device:
         iio_device_free(indio_dev);
 error_ret:
-        return ret;
+        kfree(swd);
+error_kzalloc:
+        return ERR_PTR(ret);
 }
 
 /**
  * iio_dummy_remove() - device instance removal function
- * @index: device index.
+ * @swd: pointer to software IIO device abstraction
  *
  * Parameters follow those of iio_dummy_probe for buses.
  */
-static void iio_dummy_remove(int index)
+static int iio_dummy_remove(struct iio_sw_device *swd)
 {
         /*
          * Get a pointer to the device instance iio_dev structure
@@ -671,7 +673,7 @@ static void iio_dummy_remove(int index)
          * struct iio_dev *indio_dev = i2c_get_clientdata(client);
          * struct iio_dev *indio_dev = spi_get_drvdata(spi);
          */
-        struct iio_dev *indio_dev = iio_dummy_devs[index];
+        struct iio_dev *indio_dev = swd->device;
 
         /* Unregister the device */
         iio_device_unregister(indio_dev);
@@ -684,11 +686,13 @@ static void iio_dummy_remove(int index)
         iio_simple_dummy_events_unregister(indio_dev);
 
         /* Free all structures */
+        kfree(indio_dev->name);
         iio_device_free(indio_dev);
-}
 
+        return 0;
+}
 /**
- * iio_dummy_init() -  device driver registration
+ * module_iio_sw_device_driver() -  device driver registration
  *
  * Varies depending on bus type of the device. As there is no device
  * here, call probe directly. For information on device registration
@@ -697,50 +701,18 @@ static void iio_dummy_remove(int index)
  * spi:
  * Documentation/spi/spi-summary
  */
-static __init int iio_dummy_init(void)
-{
-        int i, ret;
-
-        if (instances > 10) {
-                instances = 1;
-                return -EINVAL;
-        }
-
-        /* Fake a bus */
-        iio_dummy_devs = kcalloc(instances, sizeof(*iio_dummy_devs),
-                                 GFP_KERNEL);
-        /* Here we have no actual device so call probe */
-        for (i = 0; i < instances; i++) {
-                ret = iio_dummy_probe(i);
-                if (ret < 0)
-                        goto error_remove_devs;
-        }
-        return 0;
-
-error_remove_devs:
-        while (i--)
-                iio_dummy_remove(i);
-
-        kfree(iio_dummy_devs);
-        return ret;
-}
-module_init(iio_dummy_init);
+static const struct iio_sw_device_ops iio_dummy_device_ops = {
+        .probe = iio_dummy_probe,
+        .remove = iio_dummy_remove,
+};
 
-/**
- * iio_dummy_exit() - device driver removal
- *
- * Varies depending on bus type of the device.
- * As there is no device here, call remove directly.
- */
-static __exit void iio_dummy_exit(void)
-{
-        int i;
+static struct iio_sw_device_type iio_dummy_device = {
+        .name = "dummy",
+        .owner = THIS_MODULE,
+        .ops = &iio_dummy_device_ops,
+};
 
-        for (i = 0; i < instances; i++)
-                iio_dummy_remove(i);
-        kfree(iio_dummy_devs);
-}
-module_exit(iio_dummy_exit);
+module_iio_sw_device_driver(iio_dummy_device);
 
 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
 MODULE_DESCRIPTION("IIO dummy driver");
diff --git a/drivers/iio/gyro/st_gyro_core.c b/drivers/iio/gyro/st_gyro_core.c
index a8012955a1f6..aea034d8fe0f 100644
--- a/drivers/iio/gyro/st_gyro_core.c
+++ b/drivers/iio/gyro/st_gyro_core.c
@@ -426,13 +426,15 @@ int st_gyro_common_probe(struct iio_dev *indio_dev)
         indio_dev->info = &gyro_info;
         mutex_init(&gdata->tb.buf_lock);
 
-        st_sensors_power_enable(indio_dev);
+        err = st_sensors_power_enable(indio_dev);
+        if (err)
+                return err;
 
         err = st_sensors_check_device_support(indio_dev,
                                         ARRAY_SIZE(st_gyro_sensors_settings),
                                         st_gyro_sensors_settings);
         if (err < 0)
-                return err;
+                goto st_gyro_power_off;
 
         gdata->num_data_channels = ST_GYRO_NUMBER_DATA_CHANNELS;
         gdata->multiread_bit = gdata->sensor_settings->multi_read_bit;
@@ -446,11 +448,11 @@ int st_gyro_common_probe(struct iio_dev *indio_dev)
         err = st_sensors_init_sensor(indio_dev,
                                 (struct st_sensors_platform_data *)&gyro_pdata);
         if (err < 0)
-                return err;
+                goto st_gyro_power_off;
 
         err = st_gyro_allocate_ring(indio_dev);
         if (err < 0)
-                return err;
+                goto st_gyro_power_off;
 
         if (irq > 0) {
                 err = st_sensors_allocate_trigger(indio_dev,
@@ -473,6 +475,8 @@ st_gyro_device_register_error:
                 st_sensors_deallocate_trigger(indio_dev);
 st_gyro_probe_trigger_error:
         st_gyro_deallocate_ring(indio_dev);
+st_gyro_power_off:
+        st_sensors_power_disable(indio_dev);
 
         return err;
 }
diff --git a/drivers/iio/health/afe4403.c b/drivers/iio/health/afe4403.c
index 88e43f87b926..9a081465c42f 100644
--- a/drivers/iio/health/afe4403.c
+++ b/drivers/iio/health/afe4403.c
@@ -1,7 +1,7 @@
 /*
  * AFE4403 Heart Rate Monitors and Low-Cost Pulse Oximeters
  *
- * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/
+ * Copyright (C) 2015-2016 Texas Instruments Incorporated - http://www.ti.com/
  *      Andrew F. Davis <afd@ti.com>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -39,127 +39,90 @@
 #define AFE4403_TIAGAIN                 0x20
 #define AFE4403_TIA_AMB_GAIN            0x21
 
-/* AFE4403 GAIN register fields */
-#define AFE4403_TIAGAIN_RES_MASK        GENMASK(2, 0)
-#define AFE4403_TIAGAIN_RES_SHIFT       0
-#define AFE4403_TIAGAIN_CAP_MASK        GENMASK(7, 3)
-#define AFE4403_TIAGAIN_CAP_SHIFT       3
-
-/* AFE4403 LEDCNTRL register fields */
-#define AFE440X_LEDCNTRL_LED1_MASK              GENMASK(15, 8)
-#define AFE440X_LEDCNTRL_LED1_SHIFT             8
-#define AFE440X_LEDCNTRL_LED2_MASK              GENMASK(7, 0)
-#define AFE440X_LEDCNTRL_LED2_SHIFT             0
-#define AFE440X_LEDCNTRL_LED_RANGE_MASK         GENMASK(17, 16)
-#define AFE440X_LEDCNTRL_LED_RANGE_SHIFT        16
-
-/* AFE4403 CONTROL2 register fields */
-#define AFE440X_CONTROL2_PWR_DWN_TX     BIT(2)
-#define AFE440X_CONTROL2_EN_SLOW_DIAG   BIT(8)
-#define AFE440X_CONTROL2_DIAG_OUT_TRI   BIT(10)
-#define AFE440X_CONTROL2_TX_BRDG_MOD    BIT(11)
-#define AFE440X_CONTROL2_TX_REF_MASK    GENMASK(18, 17)
-#define AFE440X_CONTROL2_TX_REF_SHIFT   17
-
-/* AFE4404 NULL fields */
-#define NULL_MASK       0
-#define NULL_SHIFT      0
-
-/* AFE4403 LEDCNTRL values */
-#define AFE440X_LEDCNTRL_RANGE_TX_HALF  0x1
-#define AFE440X_LEDCNTRL_RANGE_TX_FULL  0x2
-#define AFE440X_LEDCNTRL_RANGE_TX_OFF   0x3
-
-/* AFE4403 CONTROL2 values */
-#define AFE440X_CONTROL2_TX_REF_025     0x0
-#define AFE440X_CONTROL2_TX_REF_050     0x1
-#define AFE440X_CONTROL2_TX_REF_100     0x2
-#define AFE440X_CONTROL2_TX_REF_075     0x3
-
-/* AFE4403 CONTROL3 values */
-#define AFE440X_CONTROL3_CLK_DIV_2      0x0
-#define AFE440X_CONTROL3_CLK_DIV_4      0x2
-#define AFE440X_CONTROL3_CLK_DIV_6      0x3
-#define AFE440X_CONTROL3_CLK_DIV_8      0x4
-#define AFE440X_CONTROL3_CLK_DIV_12     0x5
-#define AFE440X_CONTROL3_CLK_DIV_1      0x7
-
-/* AFE4403 TIAGAIN_CAP values */
-#define AFE4403_TIAGAIN_CAP_5_P         0x0
-#define AFE4403_TIAGAIN_CAP_10_P        0x1
-#define AFE4403_TIAGAIN_CAP_20_P        0x2
-#define AFE4403_TIAGAIN_CAP_30_P        0x3
-#define AFE4403_TIAGAIN_CAP_55_P        0x8
-#define AFE4403_TIAGAIN_CAP_155_P       0x10
-
-/* AFE4403 TIAGAIN_RES values */
-#define AFE4403_TIAGAIN_RES_500_K       0x0
-#define AFE4403_TIAGAIN_RES_250_K       0x1
-#define AFE4403_TIAGAIN_RES_100_K       0x2
-#define AFE4403_TIAGAIN_RES_50_K        0x3
-#define AFE4403_TIAGAIN_RES_25_K        0x4
-#define AFE4403_TIAGAIN_RES_10_K        0x5
-#define AFE4403_TIAGAIN_RES_1_M         0x6
-#define AFE4403_TIAGAIN_RES_NONE        0x7
+enum afe4403_fields {
+        /* Gains */
+        F_RF_LED1, F_CF_LED1,
+        F_RF_LED, F_CF_LED,
+
+        /* LED Current */
+        F_ILED1, F_ILED2,
+
+        /* sentinel */
+        F_MAX_FIELDS
+};
+
+static const struct reg_field afe4403_reg_fields[] = {
+        /* Gains */
+        [F_RF_LED1]     = REG_FIELD(AFE4403_TIAGAIN, 0, 2),
+        [F_CF_LED1]     = REG_FIELD(AFE4403_TIAGAIN, 3, 7),
+        [F_RF_LED]      = REG_FIELD(AFE4403_TIA_AMB_GAIN, 0, 2),
+        [F_CF_LED]      = REG_FIELD(AFE4403_TIA_AMB_GAIN, 3, 7),
+        /* LED Current */
+        [F_ILED1]       = REG_FIELD(AFE440X_LEDCNTRL, 0, 7),
+        [F_ILED2]       = REG_FIELD(AFE440X_LEDCNTRL, 8, 15),
+};
 
 /**
- * struct afe4403_data
- * @dev - Device structure
- * @spi - SPI device handle
- * @regmap - Register map of the device
- * @regulator - Pointer to the regulator for the IC
- * @trig - IIO trigger for this device
- * @irq - ADC_RDY line interrupt number
+ * struct afe4403_data - AFE4403 device instance data
+ * @dev: Device structure
+ * @spi: SPI device handle
+ * @regmap: Register map of the device
+ * @fields: Register fields of the device
+ * @regulator: Pointer to the regulator for the IC
+ * @trig: IIO trigger for this device
+ * @irq: ADC_RDY line interrupt number
  */
 struct afe4403_data {
         struct device *dev;
         struct spi_device *spi;
         struct regmap *regmap;
+        struct regmap_field *fields[F_MAX_FIELDS];
         struct regulator *regulator;
         struct iio_trigger *trig;
         int irq;
 };
 
 enum afe4403_chan_id {
+        LED2 = 1,
+        ALED2,
         LED1,
         ALED1,
-        LED2,
-        ALED2,
-        LED1_ALED1,
         LED2_ALED2,
-        ILED1,
-        ILED2,
+        LED1_ALED1,
 };
 
-static const struct afe440x_reg_info afe4403_reg_info[] = {
-        [LED1] = AFE440X_REG_INFO(AFE440X_LED1VAL, 0, NULL),
-        [ALED1] = AFE440X_REG_INFO(AFE440X_ALED1VAL, 0, NULL),
-        [LED2] = AFE440X_REG_INFO(AFE440X_LED2VAL, 0, NULL),
-        [ALED2] = AFE440X_REG_INFO(AFE440X_ALED2VAL, 0, NULL),
-        [LED1_ALED1] = AFE440X_REG_INFO(AFE440X_LED1_ALED1VAL, 0, NULL),
-        [LED2_ALED2] = AFE440X_REG_INFO(AFE440X_LED2_ALED2VAL, 0, NULL),
-        [ILED1] = AFE440X_REG_INFO(AFE440X_LEDCNTRL, 0, AFE440X_LEDCNTRL_LED1),
-        [ILED2] = AFE440X_REG_INFO(AFE440X_LEDCNTRL, 0, AFE440X_LEDCNTRL_LED2),
+static const unsigned int afe4403_channel_values[] = {
+        [LED2] = AFE440X_LED2VAL,
+        [ALED2] = AFE440X_ALED2VAL,
+        [LED1] = AFE440X_LED1VAL,
+        [ALED1] = AFE440X_ALED1VAL,
+        [LED2_ALED2] = AFE440X_LED2_ALED2VAL,
+        [LED1_ALED1] = AFE440X_LED1_ALED1VAL,
+};
+
+static const unsigned int afe4403_channel_leds[] = {
+        [LED2] = F_ILED2,
+        [LED1] = F_ILED1,
 };
 
 static const struct iio_chan_spec afe4403_channels[] = {
         /* ADC values */
-        AFE440X_INTENSITY_CHAN(LED1, "led1", 0),
-        AFE440X_INTENSITY_CHAN(ALED1, "led1_ambient", 0),
-        AFE440X_INTENSITY_CHAN(LED2, "led2", 0),
-        AFE440X_INTENSITY_CHAN(ALED2, "led2_ambient", 0),
-        AFE440X_INTENSITY_CHAN(LED1_ALED1, "led1-led1_ambient", 0),
-        AFE440X_INTENSITY_CHAN(LED2_ALED2, "led2-led2_ambient", 0),
+        AFE440X_INTENSITY_CHAN(LED2, 0),
+        AFE440X_INTENSITY_CHAN(ALED2, 0),
+        AFE440X_INTENSITY_CHAN(LED1, 0),
+        AFE440X_INTENSITY_CHAN(ALED1, 0),
+        AFE440X_INTENSITY_CHAN(LED2_ALED2, 0),
+        AFE440X_INTENSITY_CHAN(LED1_ALED1, 0),
         /* LED current */
-        AFE440X_CURRENT_CHAN(ILED1, "led1"),
-        AFE440X_CURRENT_CHAN(ILED2, "led2"),
+        AFE440X_CURRENT_CHAN(LED2),
+        AFE440X_CURRENT_CHAN(LED1),
 };
 
 static const struct afe440x_val_table afe4403_res_table[] = {
         { 500000 }, { 250000 }, { 100000 }, { 50000 },
         { 25000 }, { 10000 }, { 1000000 }, { 0 },
 };
-AFE440X_TABLE_ATTR(tia_resistance_available, afe4403_res_table);
+AFE440X_TABLE_ATTR(in_intensity_resistance_available, afe4403_res_table);
 
 static const struct afe440x_val_table afe4403_cap_table[] = {
         { 0, 5000 }, { 0, 10000 }, { 0, 20000 }, { 0, 25000 },
@@ -171,7 +134,7 @@ static const struct afe440x_val_table afe4403_cap_table[] = {
         { 0, 205000 }, { 0, 210000 }, { 0, 220000 }, { 0, 225000 },
         { 0, 230000 }, { 0, 235000 }, { 0, 245000 }, { 0, 250000 },
 };
-AFE440X_TABLE_ATTR(tia_capacitance_available, afe4403_cap_table);
+AFE440X_TABLE_ATTR(in_intensity_capacitance_available, afe4403_cap_table);
 
 static ssize_t afe440x_show_register(struct device *dev,
                                      struct device_attribute *attr,
@@ -180,38 +143,21 @@ static ssize_t afe440x_show_register(struct device *dev,
         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
         struct afe4403_data *afe = iio_priv(indio_dev);
         struct afe440x_attr *afe440x_attr = to_afe440x_attr(attr);
-        unsigned int reg_val, type;
+        unsigned int reg_val;
         int vals[2];
-        int ret, val_len;
+        int ret;
 
-        ret = regmap_read(afe->regmap, afe440x_attr->reg, &reg_val);
+        ret = regmap_field_read(afe->fields[afe440x_attr->field], &reg_val);
         if (ret)
                 return ret;
 
-        reg_val &= afe440x_attr->mask;
-        reg_val >>= afe440x_attr->shift;
-
-        switch (afe440x_attr->type) {
-        case SIMPLE:
-                type = IIO_VAL_INT;
-                val_len = 1;
-                vals[0] = reg_val;
-                break;
-        case RESISTANCE:
-        case CAPACITANCE:
-                type = IIO_VAL_INT_PLUS_MICRO;
-                val_len = 2;
-                if (reg_val < afe440x_attr->table_size) {
-                        vals[0] = afe440x_attr->val_table[reg_val].integer;
-                        vals[1] = afe440x_attr->val_table[reg_val].fract;
-                        break;
-                }
-                return -EINVAL;
-        default:
+        if (reg_val >= afe440x_attr->table_size)
                 return -EINVAL;
-        }
 
-        return iio_format_value(buf, type, val_len, vals);
+        vals[0] = afe440x_attr->val_table[reg_val].integer;
+        vals[1] = afe440x_attr->val_table[reg_val].fract;
+
+        return iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, 2, vals);
 }
 
 static ssize_t afe440x_store_register(struct device *dev,
@@ -227,48 +173,43 @@ static ssize_t afe440x_store_register(struct device *dev,
         if (ret)
                 return ret;
 
-        switch (afe440x_attr->type) {
-        case SIMPLE:
-                val = integer;
-                break;
-        case RESISTANCE:
-        case CAPACITANCE:
-                for (val = 0; val < afe440x_attr->table_size; val++)
-                        if (afe440x_attr->val_table[val].integer == integer &&
-                            afe440x_attr->val_table[val].fract == fract)
-                                break;
-                if (val == afe440x_attr->table_size)
-                        return -EINVAL;
-                break;
-        default:
+        for (val = 0; val < afe440x_attr->table_size; val++)
+                if (afe440x_attr->val_table[val].integer == integer &&
+                    afe440x_attr->val_table[val].fract == fract)
+                        break;
+        if (val == afe440x_attr->table_size)
                 return -EINVAL;
-        }
 
-        ret = regmap_update_bits(afe->regmap, afe440x_attr->reg,
-                                 afe440x_attr->mask,
-                                 (val << afe440x_attr->shift));
+        ret = regmap_field_write(afe->fields[afe440x_attr->field], val);
         if (ret)
                 return ret;
 
         return count;
 }
 
-static AFE440X_ATTR(tia_separate_en, AFE4403_TIAGAIN, AFE440X_TIAGAIN_ENSEPGAIN, SIMPLE, NULL, 0);
+static AFE440X_ATTR(in_intensity1_resistance, F_RF_LED, afe4403_res_table);
+static AFE440X_ATTR(in_intensity1_capacitance, F_CF_LED, afe4403_cap_table);
+
+static AFE440X_ATTR(in_intensity2_resistance, F_RF_LED, afe4403_res_table);
+static AFE440X_ATTR(in_intensity2_capacitance, F_CF_LED, afe4403_cap_table);
 
-static AFE440X_ATTR(tia_resistance1, AFE4403_TIAGAIN, AFE4403_TIAGAIN_RES, RESISTANCE, afe4403_res_table, ARRAY_SIZE(afe4403_res_table));
-static AFE440X_ATTR(tia_capacitance1, AFE4403_TIAGAIN, AFE4403_TIAGAIN_CAP, CAPACITANCE, afe4403_cap_table, ARRAY_SIZE(afe4403_cap_table));
+static AFE440X_ATTR(in_intensity3_resistance, F_RF_LED1, afe4403_res_table);
+static AFE440X_ATTR(in_intensity3_capacitance, F_CF_LED1, afe4403_cap_table);
 
-static AFE440X_ATTR(tia_resistance2, AFE4403_TIA_AMB_GAIN, AFE4403_TIAGAIN_RES, RESISTANCE, afe4403_res_table, ARRAY_SIZE(afe4403_res_table));
-static AFE440X_ATTR(tia_capacitance2, AFE4403_TIA_AMB_GAIN, AFE4403_TIAGAIN_RES, CAPACITANCE, afe4403_cap_table, ARRAY_SIZE(afe4403_cap_table));
+static AFE440X_ATTR(in_intensity4_resistance, F_RF_LED1, afe4403_res_table);
+static AFE440X_ATTR(in_intensity4_capacitance, F_CF_LED1, afe4403_cap_table);
 
 static struct attribute *afe440x_attributes[] = {
-        &afe440x_attr_tia_separate_en.dev_attr.attr,
-        &afe440x_attr_tia_resistance1.dev_attr.attr,
-        &afe440x_attr_tia_capacitance1.dev_attr.attr,
-        &afe440x_attr_tia_resistance2.dev_attr.attr,
-        &afe440x_attr_tia_capacitance2.dev_attr.attr,
-        &dev_attr_tia_resistance_available.attr,
-        &dev_attr_tia_capacitance_available.attr,
+        &dev_attr_in_intensity_resistance_available.attr,
+        &dev_attr_in_intensity_capacitance_available.attr,
+        &afe440x_attr_in_intensity1_resistance.dev_attr.attr,
+        &afe440x_attr_in_intensity1_capacitance.dev_attr.attr,
+        &afe440x_attr_in_intensity2_resistance.dev_attr.attr,
+        &afe440x_attr_in_intensity2_capacitance.dev_attr.attr,
+        &afe440x_attr_in_intensity3_resistance.dev_attr.attr,
+        &afe440x_attr_in_intensity3_capacitance.dev_attr.attr,
+        &afe440x_attr_in_intensity4_resistance.dev_attr.attr,
+        &afe440x_attr_in_intensity4_capacitance.dev_attr.attr,
         NULL
 };
 
@@ -309,35 +250,26 @@ static int afe4403_read_raw(struct iio_dev *indio_dev,
                             int *val, int *val2, long mask)
 {
         struct afe4403_data *afe = iio_priv(indio_dev);
-        const struct afe440x_reg_info reg_info = afe4403_reg_info[chan->address];
+        unsigned int reg = afe4403_channel_values[chan->address];
+        unsigned int field = afe4403_channel_leds[chan->address];
         int ret;
 
         switch (chan->type) {
         case IIO_INTENSITY:
                 switch (mask) {
                 case IIO_CHAN_INFO_RAW:
-                        ret = afe4403_read(afe, reg_info.reg, val);
-                        if (ret)
-                                return ret;
-                        return IIO_VAL_INT;
-                case IIO_CHAN_INFO_OFFSET:
-                        ret = regmap_read(afe->regmap, reg_info.offreg,
-                                          val);
+                        ret = afe4403_read(afe, reg, val);
                         if (ret)
                                 return ret;
-                        *val &= reg_info.mask;
-                        *val >>= reg_info.shift;
                         return IIO_VAL_INT;
                 }
                 break;
         case IIO_CURRENT:
                 switch (mask) {
                 case IIO_CHAN_INFO_RAW:
-                        ret = regmap_read(afe->regmap, reg_info.reg, val);
+                        ret = regmap_field_read(afe->fields[field], val);
                         if (ret)
                                 return ret;
-                        *val &= reg_info.mask;
-                        *val >>= reg_info.shift;
                         return IIO_VAL_INT;
                 case IIO_CHAN_INFO_SCALE:
                         *val = 0;
@@ -357,25 +289,13 @@ static int afe4403_write_raw(struct iio_dev *indio_dev,
                              int val, int val2, long mask)
 {
         struct afe4403_data *afe = iio_priv(indio_dev);
-        const struct afe440x_reg_info reg_info = afe4403_reg_info[chan->address];
+        unsigned int field = afe4403_channel_leds[chan->address];
 
         switch (chan->type) {
-        case IIO_INTENSITY:
-                switch (mask) {
-                case IIO_CHAN_INFO_OFFSET:
-                        return regmap_update_bits(afe->regmap,
-                                reg_info.offreg,
-                                reg_info.mask,
-                                (val << reg_info.shift));
-                }
-                break;
         case IIO_CURRENT:
                 switch (mask) {
                 case IIO_CHAN_INFO_RAW:
-                        return regmap_update_bits(afe->regmap,
-                                reg_info.reg,
-                                reg_info.mask,
-                                (val << reg_info.shift));
+                        return regmap_field_write(afe->fields[field], val);
                 }
                 break;
         default:
@@ -410,7 +330,7 @@ static irqreturn_t afe4403_trigger_handler(int irq, void *private)
         for_each_set_bit(bit, indio_dev->active_scan_mask,
                          indio_dev->masklength) {
                 ret = spi_write_then_read(afe->spi,
-                                          &afe4403_reg_info[bit].reg, 1,
+                                          &afe4403_channel_values[bit], 1,
                                           rx, 3);
                 if (ret)
                         goto err;
@@ -472,12 +392,8 @@ static const struct iio_trigger_ops afe4403_trigger_ops = {
 
 static const struct reg_sequence afe4403_reg_sequences[] = {
         AFE4403_TIMING_PAIRS,
-        { AFE440X_CONTROL1, AFE440X_CONTROL1_TIMEREN | 0x000007},
-        { AFE4403_TIA_AMB_GAIN, AFE4403_TIAGAIN_RES_1_M },
-        { AFE440X_LEDCNTRL, (0x14 << AFE440X_LEDCNTRL_LED1_SHIFT) |
-                            (0x14 << AFE440X_LEDCNTRL_LED2_SHIFT) },
-        { AFE440X_CONTROL2, AFE440X_CONTROL2_TX_REF_050 <<
-                            AFE440X_CONTROL2_TX_REF_SHIFT },
+        { AFE440X_CONTROL1, AFE440X_CONTROL1_TIMEREN },
+        { AFE4403_TIAGAIN, AFE440X_TIAGAIN_ENSEPGAIN },
 };
 
 static const struct regmap_range afe4403_yes_ranges[] = {
@@ -498,13 +414,11 @@ static const struct regmap_config afe4403_regmap_config = {
         .volatile_table = &afe4403_volatile_table,
 };
 
-#ifdef CONFIG_OF
 static const struct of_device_id afe4403_of_match[] = {
         { .compatible = "ti,afe4403", },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, afe4403_of_match);
-#endif
 
 static int __maybe_unused afe4403_suspend(struct device *dev)
 {
@@ -553,7 +467,7 @@ static int afe4403_probe(struct spi_device *spi)
 {
         struct iio_dev *indio_dev;
         struct afe4403_data *afe;
-        int ret;
+        int i, ret;
 
         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*afe));
         if (!indio_dev)
@@ -572,6 +486,15 @@ static int afe4403_probe(struct spi_device *spi)
                 return PTR_ERR(afe->regmap);
         }
 
+        for (i = 0; i < F_MAX_FIELDS; i++) {
+                afe->fields[i] = devm_regmap_field_alloc(afe->dev, afe->regmap,
+                                                         afe4403_reg_fields[i]);
+                if (IS_ERR(afe->fields[i])) {
+                        dev_err(afe->dev, "Unable to allocate regmap fields\n");
+                        return PTR_ERR(afe->fields[i]);
+                }
+        }
+
         afe->regulator = devm_regulator_get(afe->dev, "tx_sup");
         if (IS_ERR(afe->regulator)) {
                 dev_err(afe->dev, "Unable to get regulator\n");
@@ -694,7 +617,7 @@ MODULE_DEVICE_TABLE(spi, afe4403_ids);
 static struct spi_driver afe4403_spi_driver = {
         .driver = {
                 .name = AFE4403_DRIVER_NAME,
-                .of_match_table = of_match_ptr(afe4403_of_match),
+                .of_match_table = afe4403_of_match,
                 .pm = &afe4403_pm_ops,
         },
         .probe = afe4403_probe,
@@ -704,5 +627,5 @@ static struct spi_driver afe4403_spi_driver = {
 module_spi_driver(afe4403_spi_driver);
 
 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
-MODULE_DESCRIPTION("TI AFE4403 Heart Rate and Pulse Oximeter");
+MODULE_DESCRIPTION("TI AFE4403 Heart Rate Monitor and Pulse Oximeter AFE");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/health/afe4404.c b/drivers/iio/health/afe4404.c
index 5096a4643784..45266404f7e3 100644
--- a/drivers/iio/health/afe4404.c
+++ b/drivers/iio/health/afe4404.c
@@ -1,7 +1,7 @@
 /*
  * AFE4404 Heart Rate Monitors and Low-Cost Pulse Oximeters
  *
- * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/
+ * Copyright (C) 2015-2016 Texas Instruments Incorporated - http://www.ti.com/
  *      Andrew F. Davis <afd@ti.com>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -48,118 +48,102 @@
 #define AFE4404_AVG_LED2_ALED2VAL       0x3f
 #define AFE4404_AVG_LED1_ALED1VAL       0x40
 
-/* AFE4404 GAIN register fields */
-#define AFE4404_TIA_GAIN_RES_MASK       GENMASK(2, 0)
-#define AFE4404_TIA_GAIN_RES_SHIFT      0
-#define AFE4404_TIA_GAIN_CAP_MASK       GENMASK(5, 3)
-#define AFE4404_TIA_GAIN_CAP_SHIFT      3
+/* AFE4404 CONTROL2 register fields */
+#define AFE440X_CONTROL2_OSC_ENABLE     BIT(9)
 
-/* AFE4404 LEDCNTRL register fields */
-#define AFE4404_LEDCNTRL_ILED1_MASK     GENMASK(5, 0)
-#define AFE4404_LEDCNTRL_ILED1_SHIFT    0
-#define AFE4404_LEDCNTRL_ILED2_MASK     GENMASK(11, 6)
-#define AFE4404_LEDCNTRL_ILED2_SHIFT    6
-#define AFE4404_LEDCNTRL_ILED3_MASK     GENMASK(17, 12)
-#define AFE4404_LEDCNTRL_ILED3_SHIFT    12
+enum afe4404_fields {
+        /* Gains */
+        F_TIA_GAIN_SEP, F_TIA_CF_SEP,
+        F_TIA_GAIN, TIA_CF,
 
-/* AFE4404 CONTROL2 register fields */
-#define AFE440X_CONTROL2_ILED_2X_MASK   BIT(17)
-#define AFE440X_CONTROL2_ILED_2X_SHIFT  17
-
-/* AFE4404 CONTROL3 register fields */
-#define AFE440X_CONTROL3_OSC_ENABLE     BIT(9)
-
-/* AFE4404 OFFDAC register current fields */
-#define AFE4404_OFFDAC_CURR_LED1_MASK   GENMASK(9, 5)
-#define AFE4404_OFFDAC_CURR_LED1_SHIFT  5
-#define AFE4404_OFFDAC_CURR_LED2_MASK   GENMASK(19, 15)
-#define AFE4404_OFFDAC_CURR_LED2_SHIFT  15
-#define AFE4404_OFFDAC_CURR_LED3_MASK   GENMASK(4, 0)
-#define AFE4404_OFFDAC_CURR_LED3_SHIFT  0
-#define AFE4404_OFFDAC_CURR_ALED1_MASK  GENMASK(14, 10)
-#define AFE4404_OFFDAC_CURR_ALED1_SHIFT 10
-#define AFE4404_OFFDAC_CURR_ALED2_MASK  GENMASK(4, 0)
-#define AFE4404_OFFDAC_CURR_ALED2_SHIFT 0
-
-/* AFE4404 NULL fields */
-#define NULL_MASK       0
-#define NULL_SHIFT      0
-
-/* AFE4404 TIA_GAIN_CAP values */
-#define AFE4404_TIA_GAIN_CAP_5_P        0x0
-#define AFE4404_TIA_GAIN_CAP_2_5_P      0x1
-#define AFE4404_TIA_GAIN_CAP_10_P       0x2
-#define AFE4404_TIA_GAIN_CAP_7_5_P      0x3
-#define AFE4404_TIA_GAIN_CAP_20_P       0x4
-#define AFE4404_TIA_GAIN_CAP_17_5_P     0x5
-#define AFE4404_TIA_GAIN_CAP_25_P       0x6
-#define AFE4404_TIA_GAIN_CAP_22_5_P     0x7
-
-/* AFE4404 TIA_GAIN_RES values */
-#define AFE4404_TIA_GAIN_RES_500_K      0x0
-#define AFE4404_TIA_GAIN_RES_250_K      0x1
-#define AFE4404_TIA_GAIN_RES_100_K      0x2
-#define AFE4404_TIA_GAIN_RES_50_K       0x3
-#define AFE4404_TIA_GAIN_RES_25_K       0x4
-#define AFE4404_TIA_GAIN_RES_10_K       0x5
-#define AFE4404_TIA_GAIN_RES_1_M        0x6
-#define AFE4404_TIA_GAIN_RES_2_M        0x7
+        /* LED Current */
+        F_ILED1, F_ILED2, F_ILED3,
+
+        /* Offset DAC */
+        F_OFFDAC_AMB2, F_OFFDAC_LED1, F_OFFDAC_AMB1, F_OFFDAC_LED2,
+
+        /* sentinel */
+        F_MAX_FIELDS
+};
+
+static const struct reg_field afe4404_reg_fields[] = {
+        /* Gains */
+        [F_TIA_GAIN_SEP]        = REG_FIELD(AFE4404_TIA_GAIN_SEP, 0, 2),
+        [F_TIA_CF_SEP]          = REG_FIELD(AFE4404_TIA_GAIN_SEP, 3, 5),
+        [F_TIA_GAIN]            = REG_FIELD(AFE4404_TIA_GAIN, 0, 2),
+        [TIA_CF]                = REG_FIELD(AFE4404_TIA_GAIN, 3, 5),
+        /* LED Current */
+        [F_ILED1]               = REG_FIELD(AFE440X_LEDCNTRL, 0, 5),
+        [F_ILED2]               = REG_FIELD(AFE440X_LEDCNTRL, 6, 11),
+        [F_ILED3]               = REG_FIELD(AFE440X_LEDCNTRL, 12, 17),
+        /* Offset DAC */
+        [F_OFFDAC_AMB2]         = REG_FIELD(AFE4404_OFFDAC, 0, 4),
+        [F_OFFDAC_LED1]         = REG_FIELD(AFE4404_OFFDAC, 5, 9),
+        [F_OFFDAC_AMB1]         = REG_FIELD(AFE4404_OFFDAC, 10, 14),
+        [F_OFFDAC_LED2]         = REG_FIELD(AFE4404_OFFDAC, 15, 19),
+};
 
 /**
- * struct afe4404_data
- * @dev - Device structure
- * @regmap - Register map of the device
- * @regulator - Pointer to the regulator for the IC
- * @trig - IIO trigger for this device
- * @irq - ADC_RDY line interrupt number
+ * struct afe4404_data - AFE4404 device instance data
+ * @dev: Device structure
+ * @regmap: Register map of the device
+ * @fields: Register fields of the device
+ * @regulator: Pointer to the regulator for the IC
+ * @trig: IIO trigger for this device
+ * @irq: ADC_RDY line interrupt number
  */
 struct afe4404_data {
         struct device *dev;
         struct regmap *regmap;
+        struct regmap_field *fields[F_MAX_FIELDS];
         struct regulator *regulator;
         struct iio_trigger *trig;
         int irq;
 };
 
 enum afe4404_chan_id {
+        LED2 = 1,
+        ALED2,
         LED1,
         ALED1,
-        LED2,
-        ALED2,
-        LED3,
-        LED1_ALED1,
         LED2_ALED2,
-        ILED1,
-        ILED2,
-        ILED3,
+        LED1_ALED1,
+};
+
+static const unsigned int afe4404_channel_values[] = {
+        [LED2] = AFE440X_LED2VAL,
+        [ALED2] = AFE440X_ALED2VAL,
+        [LED1] = AFE440X_LED1VAL,
+        [ALED1] = AFE440X_ALED1VAL,
+        [LED2_ALED2] = AFE440X_LED2_ALED2VAL,
+        [LED1_ALED1] = AFE440X_LED1_ALED1VAL,
 };
 
-static const struct afe440x_reg_info afe4404_reg_info[] = {
-        [LED1] = AFE440X_REG_INFO(AFE440X_LED1VAL, AFE4404_OFFDAC, AFE4404_OFFDAC_CURR_LED1),
-        [ALED1] = AFE440X_REG_INFO(AFE440X_ALED1VAL, AFE4404_OFFDAC, AFE4404_OFFDAC_CURR_ALED1),
-        [LED2] = AFE440X_REG_INFO(AFE440X_LED2VAL, AFE4404_OFFDAC, AFE4404_OFFDAC_CURR_LED2),
-        [ALED2] = AFE440X_REG_INFO(AFE440X_ALED2VAL, AFE4404_OFFDAC, AFE4404_OFFDAC_CURR_ALED2),
-        [LED3] = AFE440X_REG_INFO(AFE440X_ALED2VAL, 0, NULL),
-        [LED1_ALED1] = AFE440X_REG_INFO(AFE440X_LED1_ALED1VAL, 0, NULL),
-        [LED2_ALED2] = AFE440X_REG_INFO(AFE440X_LED2_ALED2VAL, 0, NULL),
-        [ILED1] = AFE440X_REG_INFO(AFE440X_LEDCNTRL, 0, AFE4404_LEDCNTRL_ILED1),
-        [ILED2] = AFE440X_REG_INFO(AFE440X_LEDCNTRL, 0, AFE4404_LEDCNTRL_ILED2),
-        [ILED3] = AFE440X_REG_INFO(AFE440X_LEDCNTRL, 0, AFE4404_LEDCNTRL_ILED3),
+static const unsigned int afe4404_channel_leds[] = {
+        [LED2] = F_ILED2,
+        [ALED2] = F_ILED3,
+        [LED1] = F_ILED1,
+};
+
+static const unsigned int afe4404_channel_offdacs[] = {
+        [LED2] = F_OFFDAC_LED2,
+        [ALED2] = F_OFFDAC_AMB2,
+        [LED1] = F_OFFDAC_LED1,
+        [ALED1] = F_OFFDAC_AMB1,
 };
 
 static const struct iio_chan_spec afe4404_channels[] = {
         /* ADC values */
-        AFE440X_INTENSITY_CHAN(LED1, "led1", BIT(IIO_CHAN_INFO_OFFSET)),
-        AFE440X_INTENSITY_CHAN(ALED1, "led1_ambient", BIT(IIO_CHAN_INFO_OFFSET)),
-        AFE440X_INTENSITY_CHAN(LED2, "led2", BIT(IIO_CHAN_INFO_OFFSET)),
-        AFE440X_INTENSITY_CHAN(ALED2, "led2_ambient", BIT(IIO_CHAN_INFO_OFFSET)),
-        AFE440X_INTENSITY_CHAN(LED3, "led3", BIT(IIO_CHAN_INFO_OFFSET)),
-        AFE440X_INTENSITY_CHAN(LED1_ALED1, "led1-led1_ambient", 0),
-        AFE440X_INTENSITY_CHAN(LED2_ALED2, "led2-led2_ambient", 0),
+        AFE440X_INTENSITY_CHAN(LED2, BIT(IIO_CHAN_INFO_OFFSET)),
+        AFE440X_INTENSITY_CHAN(ALED2, BIT(IIO_CHAN_INFO_OFFSET)),
+        AFE440X_INTENSITY_CHAN(LED1, BIT(IIO_CHAN_INFO_OFFSET)),
+        AFE440X_INTENSITY_CHAN(ALED1, BIT(IIO_CHAN_INFO_OFFSET)),
+        AFE440X_INTENSITY_CHAN(LED2_ALED2, 0),
+        AFE440X_INTENSITY_CHAN(LED1_ALED1, 0),
         /* LED current */
-        AFE440X_CURRENT_CHAN(ILED1, "led1"),
-        AFE440X_CURRENT_CHAN(ILED2, "led2"),
-        AFE440X_CURRENT_CHAN(ILED3, "led3"),
+        AFE440X_CURRENT_CHAN(LED2),
+        AFE440X_CURRENT_CHAN(ALED2),
+        AFE440X_CURRENT_CHAN(LED1),
 };
 
 static const struct afe440x_val_table afe4404_res_table[] = {
@@ -172,7 +156,7 @@ static const struct afe440x_val_table afe4404_res_table[] = {
         { .integer = 1000000, .fract = 0 },
         { .integer = 2000000, .fract = 0 },
 };
-AFE440X_TABLE_ATTR(tia_resistance_available, afe4404_res_table);
+AFE440X_TABLE_ATTR(in_intensity_resistance_available, afe4404_res_table);
 
 static const struct afe440x_val_table afe4404_cap_table[] = {
         { .integer = 0, .fract = 5000 },
@@ -184,7 +168,7 @@ static const struct afe440x_val_table afe4404_cap_table[] = {
         { .integer = 0, .fract = 25000 },
         { .integer = 0, .fract = 22500 },
 };
-AFE440X_TABLE_ATTR(tia_capacitance_available, afe4404_cap_table);
+AFE440X_TABLE_ATTR(in_intensity_capacitance_available, afe4404_cap_table);
 
 static ssize_t afe440x_show_register(struct device *dev,
                                      struct device_attribute *attr,
@@ -193,38 +177,21 @@ static ssize_t afe440x_show_register(struct device *dev,
         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
         struct afe4404_data *afe = iio_priv(indio_dev);
         struct afe440x_attr *afe440x_attr = to_afe440x_attr(attr);
-        unsigned int reg_val, type;
+        unsigned int reg_val;
         int vals[2];
-        int ret, val_len;
+        int ret;
 
-        ret = regmap_read(afe->regmap, afe440x_attr->reg, &reg_val);
+        ret = regmap_field_read(afe->fields[afe440x_attr->field], &reg_val);
         if (ret)
                 return ret;
 
-        reg_val &= afe440x_attr->mask;
-        reg_val >>= afe440x_attr->shift;
-
-        switch (afe440x_attr->type) {
-        case SIMPLE:
-                type = IIO_VAL_INT;
-                val_len = 1;
-                vals[0] = reg_val;
-                break;
-        case RESISTANCE:
-        case CAPACITANCE:
-                type = IIO_VAL_INT_PLUS_MICRO;
-                val_len = 2;
-                if (reg_val < afe440x_attr->table_size) {
-                        vals[0] = afe440x_attr->val_table[reg_val].integer;
-                        vals[1] = afe440x_attr->val_table[reg_val].fract;
-                        break;
-                }
-                return -EINVAL;
-        default:
+        if (reg_val >= afe440x_attr->table_size)
                 return -EINVAL;
-        }
 
-        return iio_format_value(buf, type, val_len, vals);
+        vals[0] = afe440x_attr->val_table[reg_val].integer;
+        vals[1] = afe440x_attr->val_table[reg_val].fract;
+
+        return iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, 2, vals);
 }
 
 static ssize_t afe440x_store_register(struct device *dev,
@@ -240,48 +207,43 @@ static ssize_t afe440x_store_register(struct device *dev,
         if (ret)
                 return ret;
 
-        switch (afe440x_attr->type) {
-        case SIMPLE:
-                val = integer;
-                break;
-        case RESISTANCE:
-        case CAPACITANCE:
-                for (val = 0; val < afe440x_attr->table_size; val++)
-                        if (afe440x_attr->val_table[val].integer == integer &&
-                            afe440x_attr->val_table[val].fract == fract)
-                                break;
-                if (val == afe440x_attr->table_size)
-                        return -EINVAL;
-                break;
-        default:
+        for (val = 0; val < afe440x_attr->table_size; val++)
+                if (afe440x_attr->val_table[val].integer == integer &&
+                    afe440x_attr->val_table[val].fract == fract)
+                        break;
+        if (val == afe440x_attr->table_size)
                 return -EINVAL;
-        }
 
-        ret = regmap_update_bits(afe->regmap, afe440x_attr->reg,
-                                 afe440x_attr->mask,
-                                 (val << afe440x_attr->shift));
+        ret = regmap_field_write(afe->fields[afe440x_attr->field], val);
         if (ret)
                 return ret;
 
         return count;
 }
 
-static AFE440X_ATTR(tia_separate_en, AFE4404_TIA_GAIN_SEP, AFE440X_TIAGAIN_ENSEPGAIN, SIMPLE, NULL, 0);
+static AFE440X_ATTR(in_intensity1_resistance, F_TIA_GAIN_SEP, afe4404_res_table);
+static AFE440X_ATTR(in_intensity1_capacitance, F_TIA_CF_SEP, afe4404_cap_table);
+
+static AFE440X_ATTR(in_intensity2_resistance, F_TIA_GAIN_SEP, afe4404_res_table);
+static AFE440X_ATTR(in_intensity2_capacitance, F_TIA_CF_SEP, afe4404_cap_table);
 
-static AFE440X_ATTR(tia_resistance1, AFE4404_TIA_GAIN, AFE4404_TIA_GAIN_RES, RESISTANCE, afe4404_res_table, ARRAY_SIZE(afe4404_res_table));
-static AFE440X_ATTR(tia_capacitance1, AFE4404_TIA_GAIN, AFE4404_TIA_GAIN_CAP, CAPACITANCE, afe4404_cap_table, ARRAY_SIZE(afe4404_cap_table));
+static AFE440X_ATTR(in_intensity3_resistance, F_TIA_GAIN, afe4404_res_table);
+static AFE440X_ATTR(in_intensity3_capacitance, TIA_CF, afe4404_cap_table);
 
-static AFE440X_ATTR(tia_resistance2, AFE4404_TIA_GAIN_SEP, AFE4404_TIA_GAIN_RES, RESISTANCE, afe4404_res_table, ARRAY_SIZE(afe4404_res_table));
-static AFE440X_ATTR(tia_capacitance2, AFE4404_TIA_GAIN_SEP, AFE4404_TIA_GAIN_CAP, CAPACITANCE, afe4404_cap_table, ARRAY_SIZE(afe4404_cap_table));
+static AFE440X_ATTR(in_intensity4_resistance, F_TIA_GAIN, afe4404_res_table);
+static AFE440X_ATTR(in_intensity4_capacitance, TIA_CF, afe4404_cap_table);
 
 static struct attribute *afe440x_attributes[] = {
-        &afe440x_attr_tia_separate_en.dev_attr.attr,
-        &afe440x_attr_tia_resistance1.dev_attr.attr,
-        &afe440x_attr_tia_capacitance1.dev_attr.attr,
-        &afe440x_attr_tia_resistance2.dev_attr.attr,
-        &afe440x_attr_tia_capacitance2.dev_attr.attr,
-        &dev_attr_tia_resistance_available.attr,
-        &dev_attr_tia_capacitance_available.attr,
+        &dev_attr_in_intensity_resistance_available.attr,
+        &dev_attr_in_intensity_capacitance_available.attr,
+        &afe440x_attr_in_intensity1_resistance.dev_attr.attr,
+        &afe440x_attr_in_intensity1_capacitance.dev_attr.attr,
+        &afe440x_attr_in_intensity2_resistance.dev_attr.attr,
+        &afe440x_attr_in_intensity2_capacitance.dev_attr.attr,
+        &afe440x_attr_in_intensity3_resistance.dev_attr.attr,
+        &afe440x_attr_in_intensity3_capacitance.dev_attr.attr,
+        &afe440x_attr_in_intensity4_resistance.dev_attr.attr,
+        &afe440x_attr_in_intensity4_capacitance.dev_attr.attr,
         NULL
 };
 
@@ -294,35 +256,32 @@ static int afe4404_read_raw(struct iio_dev *indio_dev,
                             int *val, int *val2, long mask)
 {
         struct afe4404_data *afe = iio_priv(indio_dev);
-        const struct afe440x_reg_info reg_info = afe4404_reg_info[chan->address];
+        unsigned int value_reg = afe4404_channel_values[chan->address];
+        unsigned int led_field = afe4404_channel_leds[chan->address];
+        unsigned int offdac_field = afe4404_channel_offdacs[chan->address];
         int ret;
 
         switch (chan->type) {
         case IIO_INTENSITY:
                 switch (mask) {
                 case IIO_CHAN_INFO_RAW:
-                        ret = regmap_read(afe->regmap, reg_info.reg, val);
+                        ret = regmap_read(afe->regmap, value_reg, val);
                         if (ret)
                                 return ret;
                         return IIO_VAL_INT;
                 case IIO_CHAN_INFO_OFFSET:
-                        ret = regmap_read(afe->regmap, reg_info.offreg,
-                                          val);
+                        ret = regmap_field_read(afe->fields[offdac_field], val);
                         if (ret)
                                 return ret;
-                        *val &= reg_info.mask;
-                        *val >>= reg_info.shift;
                         return IIO_VAL_INT;
                 }
                 break;
         case IIO_CURRENT:
                 switch (mask) {
                 case IIO_CHAN_INFO_RAW:
-                        ret = regmap_read(afe->regmap, reg_info.reg, val);
+                        ret = regmap_field_read(afe->fields[led_field], val);
                         if (ret)
                                 return ret;
-                        *val &= reg_info.mask;
-                        *val >>= reg_info.shift;
                         return IIO_VAL_INT;
                 case IIO_CHAN_INFO_SCALE:
                         *val = 0;
@@ -342,25 +301,20 @@ static int afe4404_write_raw(struct iio_dev *indio_dev,
                              int val, int val2, long mask)
 {
         struct afe4404_data *afe = iio_priv(indio_dev);
-        const struct afe440x_reg_info reg_info = afe4404_reg_info[chan->address];
+        unsigned int led_field = afe4404_channel_leds[chan->address];
+        unsigned int offdac_field = afe4404_channel_offdacs[chan->address];
 
         switch (chan->type) {
         case IIO_INTENSITY:
                 switch (mask) {
                 case IIO_CHAN_INFO_OFFSET:
-                        return regmap_update_bits(afe->regmap,
-                                reg_info.offreg,
-                                reg_info.mask,
-                                (val << reg_info.shift));
+                        return regmap_field_write(afe->fields[offdac_field], val);
                 }
                 break;
         case IIO_CURRENT:
                 switch (mask) {
                 case IIO_CHAN_INFO_RAW:
-                        return regmap_update_bits(afe->regmap,
-                                reg_info.reg,
-                                reg_info.mask,
-                                (val << reg_info.shift));
+                        return regmap_field_write(afe->fields[led_field], val);
                 }
                 break;
         default:
@@ -387,7 +341,7 @@ static irqreturn_t afe4404_trigger_handler(int irq, void *private)
 
         for_each_set_bit(bit, indio_dev->active_scan_mask,
                          indio_dev->masklength) {
-                ret = regmap_read(afe->regmap, afe4404_reg_info[bit].reg,
+                ret = regmap_read(afe->regmap, afe4404_channel_values[bit],
                                   &buffer[i++]);
                 if (ret)
                         goto err;
@@ -443,11 +397,8 @@ static const struct iio_trigger_ops afe4404_trigger_ops = {
 static const struct reg_sequence afe4404_reg_sequences[] = {
         AFE4404_TIMING_PAIRS,
         { AFE440X_CONTROL1, AFE440X_CONTROL1_TIMEREN },
-        { AFE4404_TIA_GAIN, AFE4404_TIA_GAIN_RES_50_K },
-        { AFE440X_LEDCNTRL, (0xf << AFE4404_LEDCNTRL_ILED1_SHIFT) |
-                            (0x3 << AFE4404_LEDCNTRL_ILED2_SHIFT) |
-                            (0x3 << AFE4404_LEDCNTRL_ILED3_SHIFT) },
-        { AFE440X_CONTROL2, AFE440X_CONTROL3_OSC_ENABLE },
+        { AFE4404_TIA_GAIN_SEP, AFE440X_TIAGAIN_ENSEPGAIN },
+        { AFE440X_CONTROL2, AFE440X_CONTROL2_OSC_ENABLE },
 };
 
 static const struct regmap_range afe4404_yes_ranges[] = {
@@ -469,13 +420,11 @@ static const struct regmap_config afe4404_regmap_config = {
         .volatile_table = &afe4404_volatile_table,
 };
 
-#ifdef CONFIG_OF
 static const struct of_device_id afe4404_of_match[] = {
         { .compatible = "ti,afe4404", },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, afe4404_of_match);
-#endif
 
 static int __maybe_unused afe4404_suspend(struct device *dev)
 {
@@ -525,7 +474,7 @@ static int afe4404_probe(struct i2c_client *client,
 {
         struct iio_dev *indio_dev;
         struct afe4404_data *afe;
-        int ret;
+        int i, ret;
 
         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*afe));
         if (!indio_dev)
@@ -543,6 +492,15 @@ static int afe4404_probe(struct i2c_client *client,
                 return PTR_ERR(afe->regmap);
         }
 
+        for (i = 0; i < F_MAX_FIELDS; i++) {
+                afe->fields[i] = devm_regmap_field_alloc(afe->dev, afe->regmap,
+                                                         afe4404_reg_fields[i]);
+                if (IS_ERR(afe->fields[i])) {
+                        dev_err(afe->dev, "Unable to allocate regmap fields\n");
+                        return PTR_ERR(afe->fields[i]);
+                }
+        }
+
         afe->regulator = devm_regulator_get(afe->dev, "tx_sup");
         if (IS_ERR(afe->regulator)) {
                 dev_err(afe->dev, "Unable to get regulator\n");
@@ -665,7 +623,7 @@ MODULE_DEVICE_TABLE(i2c, afe4404_ids);
 static struct i2c_driver afe4404_i2c_driver = {
         .driver = {
                 .name = AFE4404_DRIVER_NAME,
-                .of_match_table = of_match_ptr(afe4404_of_match),
+                .of_match_table = afe4404_of_match,
                 .pm = &afe4404_pm_ops,
         },
         .probe = afe4404_probe,
@@ -675,5 +633,5 @@ static struct i2c_driver afe4404_i2c_driver = {
 module_i2c_driver(afe4404_i2c_driver);
 
 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
-MODULE_DESCRIPTION("TI AFE4404 Heart Rate and Pulse Oximeter");
+MODULE_DESCRIPTION("TI AFE4404 Heart Rate Monitor and Pulse Oximeter AFE");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/health/afe440x.h b/drivers/iio/health/afe440x.h
index c671ab78a23a..1a0f247043ca 100644
--- a/drivers/iio/health/afe440x.h
+++ b/drivers/iio/health/afe440x.h
@@ -71,8 +71,7 @@
 #define AFE440X_CONTROL1_TIMEREN        BIT(8)
 
 /* TIAGAIN register fields */
-#define AFE440X_TIAGAIN_ENSEPGAIN_MASK  BIT(15)
-#define AFE440X_TIAGAIN_ENSEPGAIN_SHIFT 15
+#define AFE440X_TIAGAIN_ENSEPGAIN       BIT(15)
 
 /* CONTROL2 register fields */
 #define AFE440X_CONTROL2_PDN_AFE        BIT(0)
@@ -89,22 +88,7 @@
 #define AFE440X_CONTROL0_WRITE          0x0
 #define AFE440X_CONTROL0_READ           0x1
 
-struct afe440x_reg_info {
-        unsigned int reg;
-        unsigned int offreg;
-        unsigned int shift;
-        unsigned int mask;
-};
-
-#define AFE440X_REG_INFO(_reg, _offreg, _sm)                    \
-        {                                                       \
-                .reg = _reg,                                    \
-                .offreg = _offreg,                              \
-                .shift = _sm ## _SHIFT,                         \
-                .mask = _sm ## _MASK,                           \
-        }
-
-#define AFE440X_INTENSITY_CHAN(_index, _name, _mask)            \
+#define AFE440X_INTENSITY_CHAN(_index, _mask)                   \
         {                                                       \
                 .type = IIO_INTENSITY,                          \
                 .channel = _index,                              \
@@ -116,29 +100,23 @@ struct afe440x_reg_info {
                                 .storagebits = 32,              \
                                 .endianness = IIO_CPU,          \
                 },                                              \
-                .extend_name = _name,                           \
                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |  \
                         _mask,                                  \
+                .indexed = true,                                \
         }
 
-#define AFE440X_CURRENT_CHAN(_index, _name)                     \
+#define AFE440X_CURRENT_CHAN(_index)                            \
         {                                                       \
                 .type = IIO_CURRENT,                            \
                 .channel = _index,                              \
                 .address = _index,                              \
-                .scan_index = _index,                           \
-                .extend_name = _name,                           \
+                .scan_index = -1,                               \
                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |  \
                         BIT(IIO_CHAN_INFO_SCALE),               \
+                .indexed = true,                                \
                 .output = true,                                 \
         }
 
-enum afe440x_reg_type {
-        SIMPLE,
-        RESISTANCE,
-        CAPACITANCE,
-};
-
 struct afe440x_val_table {
         int integer;
         int fract;
@@ -164,10 +142,7 @@ static DEVICE_ATTR_RO(_name)
 
 struct afe440x_attr {
         struct device_attribute dev_attr;
-        unsigned int reg;
-        unsigned int shift;
-        unsigned int mask;
-        enum afe440x_reg_type type;
+        unsigned int field;
         const struct afe440x_val_table *val_table;
         unsigned int table_size;
 };
@@ -175,17 +150,14 @@ struct afe440x_attr {
 #define to_afe440x_attr(_dev_attr)                              \
         container_of(_dev_attr, struct afe440x_attr, dev_attr)
 
-#define AFE440X_ATTR(_name, _reg, _field, _type, _table, _size) \
+#define AFE440X_ATTR(_name, _field, _table)                     \
         struct afe440x_attr afe440x_attr_##_name = {            \
                 .dev_attr = __ATTR(_name, (S_IRUGO | S_IWUSR),  \
                                    afe440x_show_register,       \
                                    afe440x_store_register),     \
-                .reg = _reg,                                    \
-                .shift = _field ## _SHIFT,                      \
-                .mask = _field ## _MASK,                        \
-                .type = _type,                                  \
+                .field = _field,                                \
                 .val_table = _table,                            \
-                .table_size = _size,                            \
+                .table_size = ARRAY_SIZE(_table),               \
         }
 
 #endif /* _AFE440X_H */
diff --git a/drivers/iio/humidity/am2315.c b/drivers/iio/humidity/am2315.c
index 11535911a5c6..3e200f69e886 100644
--- a/drivers/iio/humidity/am2315.c
+++ b/drivers/iio/humidity/am2315.c
@@ -276,6 +276,7 @@ static const struct i2c_device_id am2315_i2c_id[] = {
         {"am2315", 0},
         {}
 };
+MODULE_DEVICE_TABLE(i2c, am2315_i2c_id);
 
 static const struct acpi_device_id am2315_acpi_id[] = {
         {"AOS2315", 0},
diff --git a/drivers/iio/humidity/htu21.c b/drivers/iio/humidity/htu21.c
index 11cbc38b450f..0fbbd8c40894 100644
--- a/drivers/iio/humidity/htu21.c
+++ b/drivers/iio/humidity/htu21.c
@@ -236,6 +236,7 @@ static const struct i2c_device_id htu21_id[] = {
         {"ms8607-humidity", MS8607},
         {}
 };
+MODULE_DEVICE_TABLE(i2c, htu21_id);
 
 static struct i2c_driver htu21_driver = {
         .probe = htu21_probe,
diff --git a/drivers/iio/imu/bmi160/bmi160_core.c b/drivers/iio/imu/bmi160/bmi160_core.c
index b8a290ec984e..97928d558a15 100644
--- a/drivers/iio/imu/bmi160/bmi160_core.c
+++ b/drivers/iio/imu/bmi160/bmi160_core.c
@@ -20,6 +20,7 @@
 #include <linux/iio/triggered_buffer.h>
 #include <linux/iio/trigger_consumer.h>
 #include <linux/iio/buffer.h>
+#include <linux/iio/sysfs.h>
 
 #include "bmi160.h"
 
@@ -466,10 +467,36 @@ static int bmi160_write_raw(struct iio_dev *indio_dev,
         return 0;
 }
 
+static
+IIO_CONST_ATTR(in_accel_sampling_frequency_available,
+               "0.78125 1.5625 3.125 6.25 12.5 25 50 100 200 400 800 1600");
+static
+IIO_CONST_ATTR(in_anglvel_sampling_frequency_available,
+               "25 50 100 200 400 800 1600 3200");
+static
+IIO_CONST_ATTR(in_accel_scale_available,
+               "0.000598 0.001197 0.002394 0.004788");
+static
+IIO_CONST_ATTR(in_anglvel_scale_available,
+               "0.001065 0.000532 0.000266 0.000133 0.000066");
+
+static struct attribute *bmi160_attrs[] = {
+        &iio_const_attr_in_accel_sampling_frequency_available.dev_attr.attr,
+        &iio_const_attr_in_anglvel_sampling_frequency_available.dev_attr.attr,
+        &iio_const_attr_in_accel_scale_available.dev_attr.attr,
+        &iio_const_attr_in_anglvel_scale_available.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group bmi160_attrs_group = {
+        .attrs = bmi160_attrs,
+};
+
 static const struct iio_info bmi160_info = {
         .driver_module = THIS_MODULE,
         .read_raw = bmi160_read_raw,
         .write_raw = bmi160_write_raw,
+        .attrs = &bmi160_attrs_group,
 };
 
 static const char *bmi160_match_acpi_device(struct device *dev)
diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-core.c
index e6319a9346b2..2a85bd888619 100644
--- a/drivers/iio/industrialio-core.c
+++ b/drivers/iio/industrialio-core.c
@@ -80,6 +80,7 @@ static const char * const iio_chan_type_name_spec[] = {
         [IIO_RESISTANCE] = "resistance",
         [IIO_PH] = "ph",
         [IIO_UVINDEX] = "uvindex",
+        [IIO_ELECTRICALCONDUCTIVITY] = "electricalconductivity",
 };
 
 static const char * const iio_modifier_names[] = {
diff --git a/drivers/iio/industrialio-sw-device.c b/drivers/iio/industrialio-sw-device.c
new file mode 100644
index 000000000000..81b49cfca452
--- /dev/null
+++ b/drivers/iio/industrialio-sw-device.c
@@ -0,0 +1,182 @@
+/*
+ * The Industrial I/O core, software IIO devices functions
+ *
+ * Copyright (c) 2016 Intel Corporation
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kmod.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+
+#include <linux/iio/sw_device.h>
+#include <linux/iio/configfs.h>
+#include <linux/configfs.h>
+
+static struct config_group *iio_devices_group;
+static struct config_item_type iio_device_type_group_type;
+
+static struct config_item_type iio_devices_group_type = {
+        .ct_owner = THIS_MODULE,
+};
+
+static LIST_HEAD(iio_device_types_list);
+static DEFINE_MUTEX(iio_device_types_lock);
+
+static
+struct iio_sw_device_type *__iio_find_sw_device_type(const char *name,
+                                                     unsigned len)
+{
+        struct iio_sw_device_type *d = NULL, *iter;
+
+        list_for_each_entry(iter, &iio_device_types_list, list)
+                if (!strcmp(iter->name, name)) {
+                        d = iter;
+                        break;
+                }
+
+        return d;
+}
+
+int iio_register_sw_device_type(struct iio_sw_device_type *d)
+{
+        struct iio_sw_device_type *iter;
+        int ret = 0;
+
+        mutex_lock(&iio_device_types_lock);
+        iter = __iio_find_sw_device_type(d->name, strlen(d->name));
+        if (iter)
+                ret = -EBUSY;
+        else
+                list_add_tail(&d->list, &iio_device_types_list);
+        mutex_unlock(&iio_device_types_lock);
+
+        if (ret)
+                return ret;
+
+        d->group = configfs_register_default_group(iio_devices_group, d->name,
+                                                &iio_device_type_group_type);
+        if (IS_ERR(d->group))
+                ret = PTR_ERR(d->group);
+
+        return ret;
+}
+EXPORT_SYMBOL(iio_register_sw_device_type);
+
+void iio_unregister_sw_device_type(struct iio_sw_device_type *dt)
+{
+        struct iio_sw_device_type *iter;
+
+        mutex_lock(&iio_device_types_lock);
+        iter = __iio_find_sw_device_type(dt->name, strlen(dt->name));
+        if (iter)
+                list_del(&dt->list);
+        mutex_unlock(&iio_device_types_lock);
+
+        configfs_unregister_default_group(dt->group);
+}
+EXPORT_SYMBOL(iio_unregister_sw_device_type);
+
+static
+struct iio_sw_device_type *iio_get_sw_device_type(const char *name)
+{
+        struct iio_sw_device_type *dt;
+
+        mutex_lock(&iio_device_types_lock);
+        dt = __iio_find_sw_device_type(name, strlen(name));
+        if (dt && !try_module_get(dt->owner))
+                dt = NULL;
+        mutex_unlock(&iio_device_types_lock);
+
+        return dt;
+}
+
+struct iio_sw_device *iio_sw_device_create(const char *type, const char *name)
+{
+        struct iio_sw_device *d;
+        struct iio_sw_device_type *dt;
+
+        dt = iio_get_sw_device_type(type);
+        if (!dt) {
+                pr_err("Invalid device type: %s\n", type);
+                return ERR_PTR(-EINVAL);
+        }
+        d = dt->ops->probe(name);
+        if (IS_ERR(d))
+                goto out_module_put;
+
+        d->device_type = dt;
+
+        return d;
+out_module_put:
+        module_put(dt->owner);
+        return d;
+}
+EXPORT_SYMBOL(iio_sw_device_create);
+
+void iio_sw_device_destroy(struct iio_sw_device *d)
+{
+        struct iio_sw_device_type *dt = d->device_type;
+
+        dt->ops->remove(d);
+        module_put(dt->owner);
+}
+EXPORT_SYMBOL(iio_sw_device_destroy);
+
+static struct config_group *device_make_group(struct config_group *group,
+                                              const char *name)
+{
+        struct iio_sw_device *d;
+
+        d = iio_sw_device_create(group->cg_item.ci_name, name);
+        if (IS_ERR(d))
+                return ERR_CAST(d);
+
+        config_item_set_name(&d->group.cg_item, "%s", name);
+
+        return &d->group;
+}
+
+static void device_drop_group(struct config_group *group,
+                              struct config_item *item)
+{
+        struct iio_sw_device *d = to_iio_sw_device(item);
+
+        iio_sw_device_destroy(d);
+        config_item_put(item);
+}
+
+static struct configfs_group_operations device_ops = {
+        .make_group     = &device_make_group,
+        .drop_item      = &device_drop_group,
+};
+
+static struct config_item_type iio_device_type_group_type = {
+        .ct_group_ops = &device_ops,
+        .ct_owner       = THIS_MODULE,
+};
+
+static int __init iio_sw_device_init(void)
+{
+        iio_devices_group =
+                configfs_register_default_group(&iio_configfs_subsys.su_group,
+                                                "devices",
+                                                &iio_devices_group_type);
+        return PTR_ERR_OR_ZERO(iio_devices_group);
+}
+module_init(iio_sw_device_init);
+
+static void __exit iio_sw_device_exit(void)
+{
+        configfs_unregister_default_group(iio_devices_group);
+}
+module_exit(iio_sw_device_exit);
+
+MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
+MODULE_DESCRIPTION("Industrial I/O software devices support");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/industrialio-trigger.c b/drivers/iio/industrialio-trigger.c
index 0c52dfe64977..7c15c3092d5d 100644
--- a/drivers/iio/industrialio-trigger.c
+++ b/drivers/iio/industrialio-trigger.c
@@ -68,6 +68,10 @@ int iio_trigger_register(struct iio_trigger *trig_info)
 {
         int ret;
 
+        /* trig_info->ops is required for the module member */
+        if (!trig_info->ops)
+                return -EINVAL;
+
         trig_info->id = ida_simple_get(&iio_trigger_ida, 0, 0, GFP_KERNEL);
         if (trig_info->id < 0)
                 return trig_info->id;
@@ -164,8 +168,7 @@ EXPORT_SYMBOL(iio_trigger_poll_chained);
 
 void iio_trigger_notify_done(struct iio_trigger *trig)
 {
-        if (atomic_dec_and_test(&trig->use_count) && trig->ops &&
-                trig->ops->try_reenable)
+        if (atomic_dec_and_test(&trig->use_count) && trig->ops->try_reenable)
                 if (trig->ops->try_reenable(trig))
                         /* Missed an interrupt so launch new poll now */
                         iio_trigger_poll(trig);
@@ -224,7 +227,7 @@ static int iio_trigger_attach_poll_func(struct iio_trigger *trig,
                 goto out_put_irq;
 
         /* Enable trigger in driver */
-        if (trig->ops && trig->ops->set_trigger_state && notinuse) {
+        if (trig->ops->set_trigger_state && notinuse) {
                 ret = trig->ops->set_trigger_state(trig, true);
                 if (ret < 0)
                         goto out_free_irq;
@@ -249,7 +252,7 @@ static int iio_trigger_detach_poll_func(struct iio_trigger *trig,
                 = (bitmap_weight(trig->pool,
                                  CONFIG_IIO_CONSUMERS_PER_TRIGGER)
                    == 1);
-        if (trig->ops && trig->ops->set_trigger_state && no_other_users) {
+        if (trig->ops->set_trigger_state && no_other_users) {
                 ret = trig->ops->set_trigger_state(trig, false);
                 if (ret)
                         return ret;
@@ -371,7 +374,7 @@ static ssize_t iio_trigger_write_current(struct device *dev,
                         return ret;
         }
 
-        if (trig && trig->ops && trig->ops->validate_device) {
+        if (trig && trig->ops->validate_device) {
                 ret = trig->ops->validate_device(trig, indio_dev);
                 if (ret)
                         return ret;
diff --git a/drivers/iio/light/jsa1212.c b/drivers/iio/light/jsa1212.c
index 99a62816c3b4..e8a8931b4f50 100644
--- a/drivers/iio/light/jsa1212.c
+++ b/drivers/iio/light/jsa1212.c
@@ -325,9 +325,6 @@ static int jsa1212_probe(struct i2c_client *client,
         struct regmap *regmap;
         int ret;
 
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
-                return -EOPNOTSUPP;
-
         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
         if (!indio_dev)
                 return -ENOMEM;
diff --git a/drivers/iio/magnetometer/Kconfig b/drivers/iio/magnetometer/Kconfig
index 84e6559ccc65..1f842abcb4a4 100644
--- a/drivers/iio/magnetometer/Kconfig
+++ b/drivers/iio/magnetometer/Kconfig
@@ -44,6 +44,7 @@ config BMC150_MAGN_I2C
           This driver is only implementing magnetometer part, which has
           its own address and register map.
 
+          This driver also supports I2C Bosch BMC156 and BMM150 chips.
           To compile this driver as a module, choose M here: the module will be
           called bmc150_magn_i2c.
 
@@ -60,6 +61,7 @@ config BMC150_MAGN_SPI
           This driver is only implementing magnetometer part, which has
           its own address and register map.
 
+          This driver also supports SPI Bosch BMC156 and BMM150 chips.
           To compile this driver as a module, choose M here: the module will be
           called bmc150_magn_spi.
 
diff --git a/drivers/iio/magnetometer/ak8975.c b/drivers/iio/magnetometer/ak8975.c
index 609a2c401b5d..57d3654d7caf 100644
--- a/drivers/iio/magnetometer/ak8975.c
+++ b/drivers/iio/magnetometer/ak8975.c
@@ -430,8 +430,8 @@ static int ak8975_who_i_am(struct i2c_client *client,
          * AK8975   |  DEVICE_ID |  NA
          * AK8963   |  DEVICE_ID |  NA
          */
-        ret = i2c_smbus_read_i2c_block_data(client, AK09912_REG_WIA1,
-                                            2, wia_val);
+        ret = i2c_smbus_read_i2c_block_data_or_emulated(
+                        client, AK09912_REG_WIA1, 2, wia_val);
         if (ret < 0) {
                 dev_err(&client->dev, "Error reading WIA\n");
                 return ret;
@@ -543,9 +543,9 @@ static int ak8975_setup(struct i2c_client *client)
         }
 
         /* Get asa data and store in the device data. */
-        ret = i2c_smbus_read_i2c_block_data(client,
-                                            data->def->ctrl_regs[ASA_BASE],
-                                            3, data->asa);
+        ret = i2c_smbus_read_i2c_block_data_or_emulated(
+                        client, data->def->ctrl_regs[ASA_BASE],
+                        3, data->asa);
         if (ret < 0) {
                 dev_err(&client->dev, "Not able to read asa data\n");
                 return ret;
@@ -686,6 +686,7 @@ static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
         struct ak8975_data *data = iio_priv(indio_dev);
         const struct i2c_client *client = data->client;
         const struct ak_def *def = data->def;
+        u16 buff;
         int ret;
 
         mutex_lock(&data->lock);
@@ -694,14 +695,17 @@ static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
         if (ret)
                 goto exit;
 
-        ret = i2c_smbus_read_word_data(client, def->data_regs[index]);
+        ret = i2c_smbus_read_i2c_block_data_or_emulated(
+                        client, def->data_regs[index],
+                        sizeof(buff), (u8*)&buff);
         if (ret < 0)
                 goto exit;
 
         mutex_unlock(&data->lock);
 
-        /* Clamp to valid range. */
-        *val = clamp_t(s16, ret, -def->range, def->range);
+        /* Swap bytes and convert to valid range. */
+        buff = le16_to_cpu(buff);
+        *val = clamp_t(s16, buff, -def->range, def->range);
         return IIO_VAL_INT;
 
 exit:
diff --git a/drivers/iio/magnetometer/bmc150_magn_i2c.c b/drivers/iio/magnetometer/bmc150_magn_i2c.c
index eddc7f0d0096..ee05722587aa 100644
--- a/drivers/iio/magnetometer/bmc150_magn_i2c.c
+++ b/drivers/iio/magnetometer/bmc150_magn_i2c.c
@@ -2,6 +2,7 @@
  * 3-axis magnetometer driver supporting following I2C Bosch-Sensortec chips:
  *  - BMC150
  *  - BMC156
+ *  - BMM150
  *
  * Copyright (c) 2016, Intel Corporation.
  *
@@ -49,6 +50,7 @@ static int bmc150_magn_i2c_remove(struct i2c_client *client)
 static const struct acpi_device_id bmc150_magn_acpi_match[] = {
         {"BMC150B", 0},
         {"BMC156B", 0},
+        {"BMM150B", 0},
         {},
 };
 MODULE_DEVICE_TABLE(acpi, bmc150_magn_acpi_match);
@@ -56,6 +58,7 @@ MODULE_DEVICE_TABLE(acpi, bmc150_magn_acpi_match);
 static const struct i2c_device_id bmc150_magn_i2c_id[] = {
         {"bmc150_magn", 0},
         {"bmc156_magn", 0},
+        {"bmm150_magn", 0},
         {}
 };
 MODULE_DEVICE_TABLE(i2c, bmc150_magn_i2c_id);
diff --git a/drivers/iio/magnetometer/bmc150_magn_spi.c b/drivers/iio/magnetometer/bmc150_magn_spi.c
index c4c738a07695..7d4152d4d01e 100644
--- a/drivers/iio/magnetometer/bmc150_magn_spi.c
+++ b/drivers/iio/magnetometer/bmc150_magn_spi.c
@@ -2,6 +2,7 @@
  * 3-axis magnetometer driver support following SPI Bosch-Sensortec chips:
  *  - BMC150
  *  - BMC156
+ *  - BMM150
  *
  * Copyright (c) 2016, Intel Corporation.
  *
@@ -41,6 +42,7 @@ static int bmc150_magn_spi_remove(struct spi_device *spi)
 static const struct spi_device_id bmc150_magn_spi_id[] = {
         {"bmc150_magn", 0},
         {"bmc156_magn", 0},
+        {"bmm150_magn", 0},
         {}
 };
 MODULE_DEVICE_TABLE(spi, bmc150_magn_spi_id);
@@ -48,6 +50,7 @@ MODULE_DEVICE_TABLE(spi, bmc150_magn_spi_id);
 static const struct acpi_device_id bmc150_magn_acpi_match[] = {
         {"BMC150B", 0},
         {"BMC156B", 0},
+        {"BMM150B", 0},
         {},
 };
 MODULE_DEVICE_TABLE(acpi, bmc150_magn_acpi_match);
diff --git a/drivers/iio/magnetometer/st_magn_core.c b/drivers/iio/magnetometer/st_magn_core.c
index 8250fc322c56..3e1f06b2224c 100644
--- a/drivers/iio/magnetometer/st_magn_core.c
+++ b/drivers/iio/magnetometer/st_magn_core.c
@@ -589,13 +589,15 @@ int st_magn_common_probe(struct iio_dev *indio_dev)
         indio_dev->info = &magn_info;
         mutex_init(&mdata->tb.buf_lock);
 
-        st_sensors_power_enable(indio_dev);
+        err = st_sensors_power_enable(indio_dev);
+        if (err)
+                return err;
 
         err = st_sensors_check_device_support(indio_dev,
                                         ARRAY_SIZE(st_magn_sensors_settings),
                                         st_magn_sensors_settings);
         if (err < 0)
-                return err;
+                goto st_magn_power_off;
 
         mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS;
         mdata->multiread_bit = mdata->sensor_settings->multi_read_bit;
@@ -608,11 +610,11 @@ int st_magn_common_probe(struct iio_dev *indio_dev)
 
         err = st_sensors_init_sensor(indio_dev, NULL);
         if (err < 0)
-                return err;
+                goto st_magn_power_off;
 
         err = st_magn_allocate_ring(indio_dev);
         if (err < 0)
-                return err;
+                goto st_magn_power_off;
 
         if (irq > 0) {
                 err = st_sensors_allocate_trigger(indio_dev,
@@ -635,6 +637,8 @@ st_magn_device_register_error:
                 st_sensors_deallocate_trigger(indio_dev);
 st_magn_probe_trigger_error:
         st_magn_deallocate_ring(indio_dev);
+st_magn_power_off:
+        st_sensors_power_disable(indio_dev);
 
         return err;
 }
diff --git a/drivers/iio/potentiometer/Kconfig b/drivers/iio/potentiometer/Kconfig
index 6acb23810bb4..0941c8d490a0 100644
--- a/drivers/iio/potentiometer/Kconfig
+++ b/drivers/iio/potentiometer/Kconfig
@@ -15,6 +15,17 @@ config DS1803
           To compile this driver as a module, choose M here: the
           module will be called ds1803.
 
+config MAX5487
+        tristate "Maxim MAX5487/MAX5488/MAX5489 Digital Potentiometer driver"
+        depends on SPI
+        help
+          Say yes here to build support for the Maxim
+          MAX5487, MAX5488, MAX5489 digital potentiometer
+          chips.
+
+          To compile this driver as a module, choose M here: the
+          module will be called max5487.
+
 config MCP4131
         tristate "Microchip MCP413X/414X/415X/416X/423X/424X/425X/426X Digital Potentiometer driver"
         depends on SPI
diff --git a/drivers/iio/potentiometer/Makefile b/drivers/iio/potentiometer/Makefile
index 6007faa2fb02..8adb58f38c0b 100644
--- a/drivers/iio/potentiometer/Makefile
+++ b/drivers/iio/potentiometer/Makefile
@@ -4,6 +4,7 @@
 
 # When adding new entries keep the list in alphabetical order
 obj-$(CONFIG_DS1803) += ds1803.o
+obj-$(CONFIG_MAX5487) += max5487.o
 obj-$(CONFIG_MCP4131) += mcp4131.o
 obj-$(CONFIG_MCP4531) += mcp4531.o
 obj-$(CONFIG_TPL0102) += tpl0102.o
diff --git a/drivers/iio/potentiometer/max5487.c b/drivers/iio/potentiometer/max5487.c
new file mode 100644
index 000000000000..6c50939a2e83
--- /dev/null
+++ b/drivers/iio/potentiometer/max5487.c
@@ -0,0 +1,161 @@
+/*
+ * max5487.c - Support for MAX5487, MAX5488, MAX5489 digital potentiometers
+ *
+ * Copyright (C) 2016 Cristina-Gabriela Moraru <cristina.moraru09@gmail.com>
+ *
+ * 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.
+ *
+ */
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/acpi.h>
+
+#include <linux/iio/sysfs.h>
+#include <linux/iio/iio.h>
+
+#define MAX5487_WRITE_WIPER_A   (0x01 << 8)
+#define MAX5487_WRITE_WIPER_B   (0x02 << 8)
+
+/* copy both wiper regs to NV regs */
+#define MAX5487_COPY_AB_TO_NV   (0x23 << 8)
+/* copy both NV regs to wiper regs */
+#define MAX5487_COPY_NV_TO_AB   (0x33 << 8)
+
+#define MAX5487_MAX_POS         255
+
+struct max5487_data {
+        struct spi_device *spi;
+        int kohms;
+};
+
+#define MAX5487_CHANNEL(ch, addr) {                             \
+        .type = IIO_RESISTANCE,                                 \
+        .indexed = 1,                                           \
+        .output = 1,                                            \
+        .channel = ch,                                          \
+        .address = addr,                                        \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
+        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
+}
+
+static const struct iio_chan_spec max5487_channels[] = {
+        MAX5487_CHANNEL(0, MAX5487_WRITE_WIPER_A),
+        MAX5487_CHANNEL(1, MAX5487_WRITE_WIPER_B),
+};
+
+static int max5487_write_cmd(struct spi_device *spi, u16 cmd)
+{
+        return spi_write(spi, (const void *) &cmd, sizeof(u16));
+}
+
+static int max5487_read_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan,
+                            int *val, int *val2, long mask)
+{
+        struct max5487_data *data = iio_priv(indio_dev);
+
+        if (mask != IIO_CHAN_INFO_SCALE)
+                return -EINVAL;
+
+        *val = 1000 * data->kohms;
+        *val2 = MAX5487_MAX_POS;
+
+        return IIO_VAL_FRACTIONAL;
+}
+
+static int max5487_write_raw(struct iio_dev *indio_dev,
+                             struct iio_chan_spec const *chan,
+                             int val, int val2, long mask)
+{
+        struct max5487_data *data = iio_priv(indio_dev);
+
+        if (mask != IIO_CHAN_INFO_RAW)
+                return -EINVAL;
+
+        if (val < 0 || val > MAX5487_MAX_POS)
+                return -EINVAL;
+
+        return max5487_write_cmd(data->spi, chan->address | val);
+}
+
+static const struct iio_info max5487_info = {
+        .read_raw = max5487_read_raw,
+        .write_raw = max5487_write_raw,
+        .driver_module = THIS_MODULE,
+};
+
+static int max5487_spi_probe(struct spi_device *spi)
+{
+        struct iio_dev *indio_dev;
+        struct max5487_data *data;
+        const struct spi_device_id *id = spi_get_device_id(spi);
+        int ret;
+
+        indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
+        if (!indio_dev)
+                return -ENOMEM;
+
+        dev_set_drvdata(&spi->dev, indio_dev);
+        data = iio_priv(indio_dev);
+
+        data->spi = spi;
+        data->kohms = id->driver_data;
+
+        indio_dev->info = &max5487_info;
+        indio_dev->name = id->name;
+        indio_dev->dev.parent = &spi->dev;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        indio_dev->channels = max5487_channels;
+        indio_dev->num_channels = ARRAY_SIZE(max5487_channels);
+
+        /* restore both wiper regs from NV regs */
+        ret = max5487_write_cmd(data->spi, MAX5487_COPY_NV_TO_AB);
+        if (ret < 0)
+                return ret;
+
+        return iio_device_register(indio_dev);
+}
+
+static int max5487_spi_remove(struct spi_device *spi)
+{
+        struct iio_dev *indio_dev = dev_get_drvdata(&spi->dev);
+
+        iio_device_unregister(indio_dev);
+
+        /* save both wiper regs to NV regs */
+        return max5487_write_cmd(spi, MAX5487_COPY_AB_TO_NV);
+}
+
+static const struct spi_device_id max5487_id[] = {
+        { "MAX5487", 10 },
+        { "MAX5488", 50 },
+        { "MAX5489", 100 },
+        { }
+};
+MODULE_DEVICE_TABLE(spi, max5487_id);
+
+static const struct acpi_device_id max5487_acpi_match[] = {
+        { "MAX5487", 10 },
+        { "MAX5488", 50 },
+        { "MAX5489", 100 },
+        { },
+};
+MODULE_DEVICE_TABLE(acpi, max5487_acpi_match);
+
+static struct spi_driver max5487_driver = {
+        .driver = {
+                .name = "max5487",
+                .owner = THIS_MODULE,
+                .acpi_match_table = ACPI_PTR(max5487_acpi_match),
+        },
+        .id_table = max5487_id,
+        .probe = max5487_spi_probe,
+        .remove = max5487_spi_remove
+};
+module_spi_driver(max5487_driver);
+
+MODULE_AUTHOR("Cristina-Gabriela Moraru <cristina.moraru09@gmail.com>");
+MODULE_DESCRIPTION("max5487 SPI driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/potentiometer/tpl0102.c b/drivers/iio/potentiometer/tpl0102.c
index 5c304d42d713..7b6b54531ea2 100644
--- a/drivers/iio/potentiometer/tpl0102.c
+++ b/drivers/iio/potentiometer/tpl0102.c
@@ -116,10 +116,6 @@ static int tpl0102_probe(struct i2c_client *client,
         struct tpl0102_data *data;
         struct iio_dev *indio_dev;
 
-        if (!i2c_check_functionality(client->adapter,
-                                     I2C_FUNC_SMBUS_WORD_DATA))
-                return -EOPNOTSUPP;
-
         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
         if (!indio_dev)
                 return -ENOMEM;
diff --git a/drivers/iio/pressure/Kconfig b/drivers/iio/pressure/Kconfig
index cda9f128f3a4..8d654f671b6b 100644
--- a/drivers/iio/pressure/Kconfig
+++ b/drivers/iio/pressure/Kconfig
@@ -12,7 +12,8 @@ config BMP280
         select REGMAP_I2C
         help
           Say yes here to build support for Bosch Sensortec BMP180 and BMP280
-          pressure and temperature sensors.
+          pressure and temperature sensors. Also supports the BE280 with
+          an additional humidty sensor channel.
 
           To compile this driver as a module, choose M here: the module
           will be called bmp280.
@@ -130,7 +131,7 @@ config IIO_ST_PRESS
         select IIO_TRIGGERED_BUFFER if (IIO_BUFFER)
         help
           Say yes here to build support for STMicroelectronics pressure
-          sensors: LPS001WP, LPS25H, LPS331AP.
+          sensors: LPS001WP, LPS25H, LPS331AP, LPS22HB.
 
           This driver can also be built as a module. If so, these modules
           will be created:
diff --git a/drivers/iio/pressure/bmp280.c b/drivers/iio/pressure/bmp280.c
index 724452d61846..dbbcd6d83e3b 100644
--- a/drivers/iio/pressure/bmp280.c
+++ b/drivers/iio/pressure/bmp280.c
@@ -10,6 +10,7 @@
  * Datasheet:
  * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP180-DS000-121.pdf
  * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP280-DS001-12.pdf
+ * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BME280_DS001-11.pdf
  */
 
 #define pr_fmt(fmt) "bmp280: " fmt
@@ -23,6 +24,8 @@
 #include <linux/iio/sysfs.h>
 
 /* BMP280 specific registers */
+#define BMP280_REG_HUMIDITY_LSB         0xFE
+#define BMP280_REG_HUMIDITY_MSB         0xFD
 #define BMP280_REG_TEMP_XLSB            0xFC
 #define BMP280_REG_TEMP_LSB             0xFB
 #define BMP280_REG_TEMP_MSB             0xFA
@@ -31,7 +34,17 @@
 #define BMP280_REG_PRESS_MSB            0xF7
 
 #define BMP280_REG_CONFIG               0xF5
+#define BMP280_REG_CTRL_MEAS            0xF4
 #define BMP280_REG_STATUS               0xF3
+#define BMP280_REG_CTRL_HUMIDITY        0xF2
+
+/* Due to non linear mapping, and data sizes we can't do a bulk read */
+#define BMP280_REG_COMP_H1              0xA1
+#define BMP280_REG_COMP_H2              0xE1
+#define BMP280_REG_COMP_H3              0xE3
+#define BMP280_REG_COMP_H4              0xE4
+#define BMP280_REG_COMP_H5              0xE5
+#define BMP280_REG_COMP_H6              0xE7
 
 #define BMP280_REG_COMP_TEMP_START      0x88
 #define BMP280_COMP_TEMP_REG_COUNT      6
@@ -46,6 +59,15 @@
 #define BMP280_FILTER_8X                (BIT(3) | BIT(2))
 #define BMP280_FILTER_16X               BIT(4)
 
+#define BMP280_OSRS_HUMIDITY_MASK       (BIT(2) | BIT(1) | BIT(0))
+#define BMP280_OSRS_HUMIDITIY_X(osrs_h) ((osrs_h) << 0)
+#define BMP280_OSRS_HUMIDITY_SKIP       0
+#define BMP280_OSRS_HUMIDITY_1X         BMP280_OSRS_HUMIDITIY_X(1)
+#define BMP280_OSRS_HUMIDITY_2X         BMP280_OSRS_HUMIDITIY_X(2)
+#define BMP280_OSRS_HUMIDITY_4X         BMP280_OSRS_HUMIDITIY_X(3)
+#define BMP280_OSRS_HUMIDITY_8X         BMP280_OSRS_HUMIDITIY_X(4)
+#define BMP280_OSRS_HUMIDITY_16X        BMP280_OSRS_HUMIDITIY_X(5)
+
 #define BMP280_OSRS_TEMP_MASK           (BIT(7) | BIT(6) | BIT(5))
 #define BMP280_OSRS_TEMP_SKIP           0
 #define BMP280_OSRS_TEMP_X(osrs_t)      ((osrs_t) << 5)
@@ -92,6 +114,7 @@
 
 #define BMP180_CHIP_ID                  0x55
 #define BMP280_CHIP_ID                  0x58
+#define BME280_CHIP_ID                  0x60
 #define BMP280_SOFT_RESET_VAL           0xB6
 
 struct bmp280_data {
@@ -103,6 +126,7 @@ struct bmp280_data {
         /* log of base 2 of oversampling rate */
         u8 oversampling_press;
         u8 oversampling_temp;
+        u8 oversampling_humid;
 
         /*
          * Carryover value from temperature conversion, used in pressure
@@ -120,9 +144,13 @@ struct bmp280_chip_info {
         const int *oversampling_press_avail;
         int num_oversampling_press_avail;
 
+        const int *oversampling_humid_avail;
+        int num_oversampling_humid_avail;
+
         int (*chip_config)(struct bmp280_data *);
         int (*read_temp)(struct bmp280_data *, int *);
         int (*read_press)(struct bmp280_data *, int *, int *);
+        int (*read_humid)(struct bmp280_data *, int *, int *);
 };
 
 /*
@@ -143,12 +171,18 @@ static const struct iio_chan_spec bmp280_channels[] = {
                 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
                                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
         },
+        {
+                .type = IIO_HUMIDITYRELATIVE,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
+                                      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
+        },
 };
 
 static bool bmp280_is_writeable_reg(struct device *dev, unsigned int reg)
 {
         switch (reg) {
         case BMP280_REG_CONFIG:
+        case BMP280_REG_CTRL_HUMIDITY:
         case BMP280_REG_CTRL_MEAS:
         case BMP280_REG_RESET:
                 return true;
@@ -160,6 +194,8 @@ static bool bmp280_is_writeable_reg(struct device *dev, unsigned int reg)
 static bool bmp280_is_volatile_reg(struct device *dev, unsigned int reg)
 {
         switch (reg) {
+        case BMP280_REG_HUMIDITY_LSB:
+        case BMP280_REG_HUMIDITY_MSB:
         case BMP280_REG_TEMP_XLSB:
         case BMP280_REG_TEMP_LSB:
         case BMP280_REG_TEMP_MSB:
@@ -177,7 +213,7 @@ static const struct regmap_config bmp280_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
 
-        .max_register = BMP280_REG_TEMP_XLSB,
+        .max_register = BMP280_REG_HUMIDITY_LSB,
         .cache_type = REGCACHE_RBTREE,
 
         .writeable_reg = bmp280_is_writeable_reg,
@@ -185,6 +221,70 @@ static const struct regmap_config bmp280_regmap_config = {
 };
 
 /*
+ * Returns humidity in percent, resolution is 0.01 percent. Output value of
+ * "47445" represents 47445/1024 = 46.333 %RH.
+ *
+ * Taken from BME280 datasheet, Section 4.2.3, "Compensation formula".
+ */
+
+static u32 bmp280_compensate_humidity(struct bmp280_data *data,
+                                      s32 adc_humidity)
+{
+        struct device *dev = &data->client->dev;
+        unsigned int H1, H3, tmp;
+        int H2, H4, H5, H6, ret, var;
+
+        ret = regmap_read(data->regmap, BMP280_REG_COMP_H1, &H1);
+        if (ret < 0) {
+                dev_err(dev, "failed to read H1 comp value\n");
+                return ret;
+        }
+
+        ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_H2, &tmp, 2);
+        if (ret < 0) {
+                dev_err(dev, "failed to read H2 comp value\n");
+                return ret;
+        }
+        H2 = sign_extend32(le16_to_cpu(tmp), 15);
+
+        ret = regmap_read(data->regmap, BMP280_REG_COMP_H3, &H3);
+        if (ret < 0) {
+                dev_err(dev, "failed to read H3 comp value\n");
+                return ret;
+        }
+
+        ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_H4, &tmp, 2);
+        if (ret < 0) {
+                dev_err(dev, "failed to read H4 comp value\n");
+                return ret;
+        }
+        H4 = sign_extend32(((be16_to_cpu(tmp) >> 4) & 0xff0) |
+                          (be16_to_cpu(tmp) & 0xf), 11);
+
+        ret = regmap_bulk_read(data->regmap, BMP280_REG_COMP_H5, &tmp, 2);
+        if (ret < 0) {
+                dev_err(dev, "failed to read H5 comp value\n");
+                return ret;
+        }
+        H5 = sign_extend32(((le16_to_cpu(tmp) >> 4) & 0xfff), 11);
+
+        ret = regmap_read(data->regmap, BMP280_REG_COMP_H6, &tmp);
+        if (ret < 0) {
+                dev_err(dev, "failed to read H6 comp value\n");
+                return ret;
+        }
+        H6 = sign_extend32(tmp, 7);
+
+        var = ((s32)data->t_fine) - 76800;
+        var = ((((adc_humidity << 14) - (H4 << 20) - (H5 * var)) + 16384) >> 15)
+                * (((((((var * H6) >> 10) * (((var * H3) >> 11) + 32768)) >> 10)
+                + 2097152) * H2 + 8192) >> 14);
+        var -= ((((var >> 15) * (var >> 15)) >> 7) * H1) >> 4;
+
+        return var >> 12;
+};
+
+/*
  * Returns temperature in DegC, resolution is 0.01 DegC.  Output value of
  * "5123" equals 51.23 DegC.  t_fine carries fine temperature as global
  * value.
@@ -324,6 +424,34 @@ static int bmp280_read_press(struct bmp280_data *data,
         return IIO_VAL_FRACTIONAL;
 }
 
+static int bmp280_read_humid(struct bmp280_data *data, int *val, int *val2)
+{
+        int ret;
+        __be16 tmp = 0;
+        s32 adc_humidity;
+        u32 comp_humidity;
+
+        /* Read and compensate temperature so we get a reading of t_fine. */
+        ret = bmp280_read_temp(data, NULL);
+        if (ret < 0)
+                return ret;
+
+        ret = regmap_bulk_read(data->regmap, BMP280_REG_HUMIDITY_MSB,
+                               (u8 *) &tmp, 2);
+        if (ret < 0) {
+                dev_err(&data->client->dev, "failed to read humidity\n");
+                return ret;
+        }
+
+        adc_humidity = be16_to_cpu(tmp);
+        comp_humidity = bmp280_compensate_humidity(data, adc_humidity);
+
+        *val = comp_humidity;
+        *val2 = 1024;
+
+        return IIO_VAL_FRACTIONAL;
+}
+
 static int bmp280_read_raw(struct iio_dev *indio_dev,
                            struct iio_chan_spec const *chan,
                            int *val, int *val2, long mask)
@@ -336,6 +464,9 @@ static int bmp280_read_raw(struct iio_dev *indio_dev,
         switch (mask) {
         case IIO_CHAN_INFO_PROCESSED:
                 switch (chan->type) {
+                case IIO_HUMIDITYRELATIVE:
+                        ret = data->chip_info->read_humid(data, val, val2);
+                        break;
                 case IIO_PRESSURE:
                         ret = data->chip_info->read_press(data, val, val2);
                         break;
@@ -349,6 +480,10 @@ static int bmp280_read_raw(struct iio_dev *indio_dev,
                 break;
         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
                 switch (chan->type) {
+                case IIO_HUMIDITYRELATIVE:
+                        *val = 1 << data->oversampling_humid;
+                        ret = IIO_VAL_INT;
+                        break;
                 case IIO_PRESSURE:
                         *val = 1 << data->oversampling_press;
                         ret = IIO_VAL_INT;
@@ -372,6 +507,23 @@ static int bmp280_read_raw(struct iio_dev *indio_dev,
         return ret;
 }
 
+static int bmp280_write_oversampling_ratio_humid(struct bmp280_data *data,
+                                               int val)
+{
+        int i;
+        const int *avail = data->chip_info->oversampling_humid_avail;
+        const int n = data->chip_info->num_oversampling_humid_avail;
+
+        for (i = 0; i < n; i++) {
+                if (avail[i] == val) {
+                        data->oversampling_humid = ilog2(val);
+
+                        return data->chip_info->chip_config(data);
+                }
+        }
+        return -EINVAL;
+}
+
 static int bmp280_write_oversampling_ratio_temp(struct bmp280_data *data,
                                                int val)
 {
@@ -417,6 +569,9 @@ static int bmp280_write_raw(struct iio_dev *indio_dev,
         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
                 mutex_lock(&data->lock);
                 switch (chan->type) {
+                case IIO_HUMIDITYRELATIVE:
+                        ret = bmp280_write_oversampling_ratio_humid(data, val);
+                        break;
                 case IIO_PRESSURE:
                         ret = bmp280_write_oversampling_ratio_press(data, val);
                         break;
@@ -535,6 +690,37 @@ static const struct bmp280_chip_info bmp280_chip_info = {
         .read_press = bmp280_read_press,
 };
 
+static int bme280_chip_config(struct bmp280_data *data)
+{
+        int ret = bmp280_chip_config(data);
+        u8 osrs = BMP280_OSRS_HUMIDITIY_X(data->oversampling_humid + 1);
+
+        if (ret < 0)
+                return ret;
+
+        return regmap_update_bits(data->regmap, BMP280_REG_CTRL_HUMIDITY,
+                                  BMP280_OSRS_HUMIDITY_MASK, osrs);
+}
+
+static const struct bmp280_chip_info bme280_chip_info = {
+        .regmap_config = &bmp280_regmap_config,
+
+        .oversampling_temp_avail = bmp280_oversampling_avail,
+        .num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail),
+
+        .oversampling_press_avail = bmp280_oversampling_avail,
+        .num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail),
+
+        .oversampling_humid_avail = bmp280_oversampling_avail,
+        .num_oversampling_humid_avail = ARRAY_SIZE(bmp280_oversampling_avail),
+
+        .chip_config = bme280_chip_config,
+        .read_temp = bmp280_read_temp,
+        .read_press = bmp280_read_press,
+        .read_humid = bmp280_read_humid,
+};
+
+
 static bool bmp180_is_writeable_reg(struct device *dev, unsigned int reg)
 {
         switch (reg) {
@@ -849,21 +1035,29 @@ static int bmp280_probe(struct i2c_client *client,
         indio_dev->dev.parent = &client->dev;
         indio_dev->name = id->name;
         indio_dev->channels = bmp280_channels;
-        indio_dev->num_channels = ARRAY_SIZE(bmp280_channels);
         indio_dev->info = &bmp280_info;
         indio_dev->modes = INDIO_DIRECT_MODE;
 
         switch (id->driver_data) {
         case BMP180_CHIP_ID:
+                indio_dev->num_channels = 2;
                 data->chip_info = &bmp180_chip_info;
                 data->oversampling_press = ilog2(8);
                 data->oversampling_temp = ilog2(1);
                 break;
         case BMP280_CHIP_ID:
+                indio_dev->num_channels = 2;
                 data->chip_info = &bmp280_chip_info;
                 data->oversampling_press = ilog2(16);
                 data->oversampling_temp = ilog2(2);
                 break;
+        case BME280_CHIP_ID:
+                indio_dev->num_channels = 3;
+                data->chip_info = &bme280_chip_info;
+                data->oversampling_press = ilog2(16);
+                data->oversampling_humid = ilog2(16);
+                data->oversampling_temp = ilog2(2);
+                break;
         default:
                 return -EINVAL;
         }
@@ -895,6 +1089,7 @@ static const struct acpi_device_id bmp280_acpi_match[] = {
         {"BMP0280", BMP280_CHIP_ID },
         {"BMP0180", BMP180_CHIP_ID },
         {"BMP0085", BMP180_CHIP_ID },
+        {"BME0280", BME280_CHIP_ID },
         { },
 };
 MODULE_DEVICE_TABLE(acpi, bmp280_acpi_match);
@@ -903,6 +1098,7 @@ static const struct i2c_device_id bmp280_id[] = {
         {"bmp280", BMP280_CHIP_ID },
         {"bmp180", BMP180_CHIP_ID },
         {"bmp085", BMP180_CHIP_ID },
+        {"bme280", BME280_CHIP_ID },
         { },
 };
 MODULE_DEVICE_TABLE(i2c, bmp280_id);
diff --git a/drivers/iio/pressure/hp206c.c b/drivers/iio/pressure/hp206c.c
index 90f2b6e4a920..12f769e86355 100644
--- a/drivers/iio/pressure/hp206c.c
+++ b/drivers/iio/pressure/hp206c.c
@@ -401,6 +401,7 @@ static const struct i2c_device_id hp206c_id[] = {
         {"hp206c"},
         {}
 };
+MODULE_DEVICE_TABLE(i2c, hp206c_id);
 
 #ifdef CONFIG_ACPI
 static const struct acpi_device_id hp206c_acpi_match[] = {
diff --git a/drivers/iio/pressure/ms5637.c b/drivers/iio/pressure/ms5637.c
index e68052c118e6..8fb6f7ab97e4 100644
--- a/drivers/iio/pressure/ms5637.c
+++ b/drivers/iio/pressure/ms5637.c
@@ -173,6 +173,7 @@ static const struct i2c_device_id ms5637_id[] = {
         {"ms8607-temppressure", 1},
         {}
 };
+MODULE_DEVICE_TABLE(i2c, ms5637_id);
 
 static struct i2c_driver ms5637_driver = {
         .probe = ms5637_probe,
diff --git a/drivers/iio/pressure/st_pressure.h b/drivers/iio/pressure/st_pressure.h
index f5f41490060b..903a21e46874 100644
--- a/drivers/iio/pressure/st_pressure.h
+++ b/drivers/iio/pressure/st_pressure.h
@@ -17,6 +17,7 @@
 #define LPS001WP_PRESS_DEV_NAME         "lps001wp"
 #define LPS25H_PRESS_DEV_NAME           "lps25h"
 #define LPS331AP_PRESS_DEV_NAME         "lps331ap"
+#define LPS22HB_PRESS_DEV_NAME          "lps22hb"
 
 /**
  * struct st_sensors_platform_data - default press platform data
diff --git a/drivers/iio/pressure/st_pressure_core.c b/drivers/iio/pressure/st_pressure_core.c
index 92a118c3c4ac..56d8f5eb9239 100644
--- a/drivers/iio/pressure/st_pressure_core.c
+++ b/drivers/iio/pressure/st_pressure_core.c
@@ -117,6 +117,26 @@
 #define ST_PRESS_LPS25H_OUT_XL_ADDR             0x28
 #define ST_TEMP_LPS25H_OUT_L_ADDR               0x2b
 
+/* CUSTOM VALUES FOR LPS22HB SENSOR */
+#define ST_PRESS_LPS22HB_WAI_EXP                0xb1
+#define ST_PRESS_LPS22HB_ODR_ADDR               0x10
+#define ST_PRESS_LPS22HB_ODR_MASK               0x70
+#define ST_PRESS_LPS22HB_ODR_AVL_1HZ_VAL        0x01
+#define ST_PRESS_LPS22HB_ODR_AVL_10HZ_VAL       0x02
+#define ST_PRESS_LPS22HB_ODR_AVL_25HZ_VAL       0x03
+#define ST_PRESS_LPS22HB_ODR_AVL_50HZ_VAL       0x04
+#define ST_PRESS_LPS22HB_ODR_AVL_75HZ_VAL       0x05
+#define ST_PRESS_LPS22HB_PW_ADDR                0x10
+#define ST_PRESS_LPS22HB_PW_MASK                0x70
+#define ST_PRESS_LPS22HB_BDU_ADDR               0x10
+#define ST_PRESS_LPS22HB_BDU_MASK               0x02
+#define ST_PRESS_LPS22HB_DRDY_IRQ_ADDR          0x12
+#define ST_PRESS_LPS22HB_DRDY_IRQ_INT1_MASK     0x04
+#define ST_PRESS_LPS22HB_DRDY_IRQ_INT2_MASK     0x08
+#define ST_PRESS_LPS22HB_IHL_IRQ_ADDR           0x12
+#define ST_PRESS_LPS22HB_IHL_IRQ_MASK           0x80
+#define ST_PRESS_LPS22HB_MULTIREAD_BIT          true
+
 static const struct iio_chan_spec st_press_1_channels[] = {
         {
                 .type = IIO_PRESSURE,
@@ -189,6 +209,27 @@ static const struct iio_chan_spec st_press_lps001wp_channels[] = {
         IIO_CHAN_SOFT_TIMESTAMP(1)
 };
 
+static const struct iio_chan_spec st_press_lps22hb_channels[] = {
+        {
+                .type = IIO_PRESSURE,
+                .channel2 = IIO_NO_MOD,
+                .address = ST_PRESS_1_OUT_XL_ADDR,
+                .scan_index = 0,
+                .scan_type = {
+                        .sign = 'u',
+                        .realbits = 24,
+                        .storagebits = 24,
+                        .endianness = IIO_LE,
+                },
+                .info_mask_separate =
+                        BIT(IIO_CHAN_INFO_RAW) |
+                        BIT(IIO_CHAN_INFO_SCALE),
+                .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
+                .modified = 0,
+        },
+        IIO_CHAN_SOFT_TIMESTAMP(1)
+};
+
 static const struct st_sensor_settings st_press_sensors_settings[] = {
         {
                 .wai = ST_PRESS_LPS331AP_WAI_EXP,
@@ -346,6 +387,51 @@ static const struct st_sensor_settings st_press_sensors_settings[] = {
                 .multi_read_bit = ST_PRESS_LPS25H_MULTIREAD_BIT,
                 .bootime = 2,
         },
+        {
+                .wai = ST_PRESS_LPS22HB_WAI_EXP,
+                .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
+                .sensors_supported = {
+                        [0] = LPS22HB_PRESS_DEV_NAME,
+                },
+                .ch = (struct iio_chan_spec *)st_press_lps22hb_channels,
+                .num_ch = ARRAY_SIZE(st_press_lps22hb_channels),
+                .odr = {
+                        .addr = ST_PRESS_LPS22HB_ODR_ADDR,
+                        .mask = ST_PRESS_LPS22HB_ODR_MASK,
+                        .odr_avl = {
+                                { 1, ST_PRESS_LPS22HB_ODR_AVL_1HZ_VAL, },
+                                { 10, ST_PRESS_LPS22HB_ODR_AVL_10HZ_VAL, },
+                                { 25, ST_PRESS_LPS22HB_ODR_AVL_25HZ_VAL, },
+                                { 50, ST_PRESS_LPS22HB_ODR_AVL_50HZ_VAL, },
+                                { 75, ST_PRESS_LPS22HB_ODR_AVL_75HZ_VAL, },
+                        },
+                },
+                .pw = {
+                        .addr = ST_PRESS_LPS22HB_PW_ADDR,
+                        .mask = ST_PRESS_LPS22HB_PW_MASK,
+                        .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
+                },
+                .fs = {
+                        .fs_avl = {
+                                [0] = {
+                                        .num = ST_PRESS_FS_AVL_1260MB,
+                                        .gain = ST_PRESS_KPASCAL_NANO_SCALE,
+                                },
+                        },
+                },
+                .bdu = {
+                        .addr = ST_PRESS_LPS22HB_BDU_ADDR,
+                        .mask = ST_PRESS_LPS22HB_BDU_MASK,
+                },
+                .drdy_irq = {
+                        .addr = ST_PRESS_LPS22HB_DRDY_IRQ_ADDR,
+                        .mask_int1 = ST_PRESS_LPS22HB_DRDY_IRQ_INT1_MASK,
+                        .mask_int2 = ST_PRESS_LPS22HB_DRDY_IRQ_INT2_MASK,
+                        .addr_ihl = ST_PRESS_LPS22HB_IHL_IRQ_ADDR,
+                        .mask_ihl = ST_PRESS_LPS22HB_IHL_IRQ_MASK,
+                },
+                .multi_read_bit = ST_PRESS_LPS22HB_MULTIREAD_BIT,
+        },
 };
 
 static int st_press_write_raw(struct iio_dev *indio_dev,
@@ -462,23 +548,24 @@ int st_press_common_probe(struct iio_dev *indio_dev)
         indio_dev->info = &press_info;
         mutex_init(&press_data->tb.buf_lock);
 
-        st_sensors_power_enable(indio_dev);
+        err = st_sensors_power_enable(indio_dev);
+        if (err)
+                return err;
 
         err = st_sensors_check_device_support(indio_dev,
                                         ARRAY_SIZE(st_press_sensors_settings),
                                         st_press_sensors_settings);
         if (err < 0)
-                return err;
+                goto st_press_power_off;
 
         press_data->num_data_channels = ST_PRESS_NUMBER_DATA_CHANNELS;
         press_data->multiread_bit = press_data->sensor_settings->multi_read_bit;
         indio_dev->channels = press_data->sensor_settings->ch;
         indio_dev->num_channels = press_data->sensor_settings->num_ch;
 
-        if (press_data->sensor_settings->fs.addr != 0)
-                press_data->current_fullscale =
-                        (struct st_sensor_fullscale_avl *)
-                                &press_data->sensor_settings->fs.fs_avl[0];
+        press_data->current_fullscale =
+                (struct st_sensor_fullscale_avl *)
+                        &press_data->sensor_settings->fs.fs_avl[0];
 
         press_data->odr = press_data->sensor_settings->odr.odr_avl[0].hz;
 
@@ -490,11 +577,11 @@ int st_press_common_probe(struct iio_dev *indio_dev)
 
         err = st_sensors_init_sensor(indio_dev, press_data->dev->platform_data);
         if (err < 0)
-                return err;
+                goto st_press_power_off;
 
         err = st_press_allocate_ring(indio_dev);
         if (err < 0)
-                return err;
+                goto st_press_power_off;
 
         if (irq > 0) {
                 err = st_sensors_allocate_trigger(indio_dev,
@@ -517,6 +604,8 @@ st_press_device_register_error:
                 st_sensors_deallocate_trigger(indio_dev);
 st_press_probe_trigger_error:
         st_press_deallocate_ring(indio_dev);
+st_press_power_off:
+        st_sensors_power_disable(indio_dev);
 
         return err;
 }
diff --git a/drivers/iio/pressure/st_pressure_i2c.c b/drivers/iio/pressure/st_pressure_i2c.c
index 8fcf9766eaec..ed18701c68c9 100644
--- a/drivers/iio/pressure/st_pressure_i2c.c
+++ b/drivers/iio/pressure/st_pressure_i2c.c
@@ -32,6 +32,10 @@ static const struct of_device_id st_press_of_match[] = {
                 .compatible = "st,lps331ap-press",
                 .data = LPS331AP_PRESS_DEV_NAME,
         },
+        {
+                .compatible = "st,lps22hb-press",
+                .data = LPS22HB_PRESS_DEV_NAME,
+        },
         {},
 };
 MODULE_DEVICE_TABLE(of, st_press_of_match);
diff --git a/drivers/iio/pressure/st_pressure_spi.c b/drivers/iio/pressure/st_pressure_spi.c
index 40c0692ff1de..550508025af1 100644
--- a/drivers/iio/pressure/st_pressure_spi.c
+++ b/drivers/iio/pressure/st_pressure_spi.c
@@ -50,6 +50,7 @@ static const struct spi_device_id st_press_id_table[] = {
         { LPS001WP_PRESS_DEV_NAME },
         { LPS25H_PRESS_DEV_NAME },
         { LPS331AP_PRESS_DEV_NAME },
+        { LPS22HB_PRESS_DEV_NAME },
         {},
 };
 MODULE_DEVICE_TABLE(spi, st_press_id_table);
diff --git a/drivers/iio/proximity/as3935.c b/drivers/iio/proximity/as3935.c
index e2f926cdcad2..9aa2ce551ba8 100644
--- a/drivers/iio/proximity/as3935.c
+++ b/drivers/iio/proximity/as3935.c
@@ -468,4 +468,3 @@ module_spi_driver(as3935_driver);
 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
 MODULE_DESCRIPTION("AS3935 lightning sensor");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("spi:as3935");
diff --git a/drivers/iio/temperature/tsys02d.c b/drivers/iio/temperature/tsys02d.c
index ab6fe8f6f2d1..c0a19a000387 100644
--- a/drivers/iio/temperature/tsys02d.c
+++ b/drivers/iio/temperature/tsys02d.c
@@ -174,6 +174,7 @@ static const struct i2c_device_id tsys02d_id[] = {
         {"tsys02d", 0},
         {}
 };
+MODULE_DEVICE_TABLE(i2c, tsys02d_id);
 
 static struct i2c_driver tsys02d_driver = {
         .probe = tsys02d_probe,
diff --git a/drivers/iio/trigger/Kconfig b/drivers/iio/trigger/Kconfig
index 519e6772f6f5..809b2e7d58fa 100644
--- a/drivers/iio/trigger/Kconfig
+++ b/drivers/iio/trigger/Kconfig
@@ -24,6 +24,18 @@ config IIO_INTERRUPT_TRIGGER
           To compile this driver as a module, choose M here: the
           module will be called iio-trig-interrupt.
 
+config IIO_TIGHTLOOP_TRIGGER
+        tristate "A kthread based hammering loop trigger"
+        depends on IIO_SW_TRIGGER
+        help
+          An experimental trigger, used to allow sensors to be sampled as fast
+          as possible under the limitations of whatever else is going on.
+          Uses a tight loop in a kthread.  Will only work with lower half only
+          trigger consumers.
+
+          To compile this driver as a module, choose M here: the
+          module will be called iio-trig-loop.
+
 config IIO_SYSFS_TRIGGER
         tristate "SYSFS trigger"
         depends on SYSFS
diff --git a/drivers/iio/trigger/Makefile b/drivers/iio/trigger/Makefile
index fe06eb564367..aab4dc23303d 100644
--- a/drivers/iio/trigger/Makefile
+++ b/drivers/iio/trigger/Makefile
@@ -7,3 +7,4 @@
 obj-$(CONFIG_IIO_HRTIMER_TRIGGER) += iio-trig-hrtimer.o
 obj-$(CONFIG_IIO_INTERRUPT_TRIGGER) += iio-trig-interrupt.o
 obj-$(CONFIG_IIO_SYSFS_TRIGGER) += iio-trig-sysfs.o
+obj-$(CONFIG_IIO_TIGHTLOOP_TRIGGER) += iio-trig-loop.o
diff --git a/drivers/iio/trigger/iio-trig-loop.c b/drivers/iio/trigger/iio-trig-loop.c
new file mode 100644
index 000000000000..dc6be28f96fe
--- /dev/null
+++ b/drivers/iio/trigger/iio-trig-loop.c
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2016 Jonathan Cameron <jic23@kernel.org>
+ *
+ * Licensed under the GPL-2.
+ *
+ * Based on a mashup of the hrtimer trigger and continuous sampling proposal of
+ * Gregor Boirie <gregor.boirie@parrot.com>
+ *
+ * Note this is still rather experimental and may eat babies.
+ *
+ * Todo
+ * * Protect against connection of devices that 'need' the top half
+ *   handler.
+ * * Work out how to run top half handlers in this context if it is
+ *   safe to do so (timestamp grabbing for example)
+ *
+ * Tested against a max1363. Used about 33% cpu for the thread and 20%
+ * for generic_buffer piping to /dev/null. Watermark set at 64 on a 128
+ * element kfifo buffer.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/irq_work.h>
+#include <linux/kthread.h>
+#include <linux/freezer.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/trigger.h>
+#include <linux/iio/sw_trigger.h>
+
+struct iio_loop_info {
+        struct iio_sw_trigger swt;
+        struct task_struct *task;
+};
+
+static struct config_item_type iio_loop_type = {
+        .ct_owner = THIS_MODULE,
+};
+
+static int iio_loop_thread(void *data)
+{
+        struct iio_trigger *trig = data;
+
+        set_freezable();
+
+        do {
+                iio_trigger_poll_chained(trig);
+        } while (likely(!kthread_freezable_should_stop(NULL)));
+
+        return 0;
+}
+
+static int iio_loop_trigger_set_state(struct iio_trigger *trig, bool state)
+{
+        struct iio_loop_info *loop_trig = iio_trigger_get_drvdata(trig);
+
+        if (state) {
+                loop_trig->task = kthread_run(iio_loop_thread,
+                                              trig, trig->name);
+                if (unlikely(IS_ERR(loop_trig->task))) {
+                        dev_err(&trig->dev,
+                                "failed to create trigger loop thread\n");
+                        return PTR_ERR(loop_trig->task);
+                }
+        } else {
+                kthread_stop(loop_trig->task);
+        }
+
+        return 0;
+}
+
+static const struct iio_trigger_ops iio_loop_trigger_ops = {
+        .set_trigger_state = iio_loop_trigger_set_state,
+        .owner = THIS_MODULE,
+};
+
+static struct iio_sw_trigger *iio_trig_loop_probe(const char *name)
+{
+        struct iio_loop_info *trig_info;
+        int ret;
+
+        trig_info = kzalloc(sizeof(*trig_info), GFP_KERNEL);
+        if (!trig_info)
+                return ERR_PTR(-ENOMEM);
+
+        trig_info->swt.trigger = iio_trigger_alloc("%s", name);
+        if (!trig_info->swt.trigger) {
+                ret = -ENOMEM;
+                goto err_free_trig_info;
+        }
+
+        iio_trigger_set_drvdata(trig_info->swt.trigger, trig_info);
+        trig_info->swt.trigger->ops = &iio_loop_trigger_ops;
+
+        ret = iio_trigger_register(trig_info->swt.trigger);
+        if (ret)
+                goto err_free_trigger;
+
+        iio_swt_group_init_type_name(&trig_info->swt, name, &iio_loop_type);
+
+        return &trig_info->swt;
+
+err_free_trigger:
+        iio_trigger_free(trig_info->swt.trigger);
+err_free_trig_info:
+        kfree(trig_info);
+
+        return ERR_PTR(ret);
+}
+
+static int iio_trig_loop_remove(struct iio_sw_trigger *swt)
+{
+        struct iio_loop_info *trig_info;
+
+        trig_info = iio_trigger_get_drvdata(swt->trigger);
+
+        iio_trigger_unregister(swt->trigger);
+        iio_trigger_free(swt->trigger);
+        kfree(trig_info);
+
+        return 0;
+}
+
+static const struct iio_sw_trigger_ops iio_trig_loop_ops = {
+        .probe = iio_trig_loop_probe,
+        .remove = iio_trig_loop_remove,
+};
+
+static struct iio_sw_trigger_type iio_trig_loop = {
+        .name = "loop",
+        .owner = THIS_MODULE,
+        .ops = &iio_trig_loop_ops,
+};
+
+module_iio_sw_trigger_driver(iio_trig_loop);
+
+MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
+MODULE_DESCRIPTION("Loop based trigger for the iio subsystem");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:iio-trig-loop");
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig
index 7c197d1a1231..af9476460023 100644
--- a/drivers/staging/Kconfig
+++ b/drivers/staging/Kconfig
@@ -102,4 +102,6 @@ source "drivers/staging/most/Kconfig"
 
 source "drivers/staging/i4l/Kconfig"
 
+source "drivers/staging/ks7010/Kconfig"
+
 endif # STAGING
diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile
index a470c7276142..9f6009dcafa8 100644
--- a/drivers/staging/Makefile
+++ b/drivers/staging/Makefile
@@ -40,3 +40,4 @@ obj-$(CONFIG_FSL_MC_BUS)	+= fsl-mc/
 obj-$(CONFIG_WILC1000)          += wilc1000/
 obj-$(CONFIG_MOST)              += most/
 obj-$(CONFIG_ISDN_I4L)          += i4l/
+obj-$(CONFIG_KS7010)            += ks7010/
diff --git a/drivers/staging/android/Kconfig b/drivers/staging/android/Kconfig
index 6480f60ebf6c..06e41d24ec62 100644
--- a/drivers/staging/android/Kconfig
+++ b/drivers/staging/android/Kconfig
@@ -24,26 +24,19 @@ config ANDROID_LOW_MEMORY_KILLER
           scripts (/init.rc), and it defines priority values with minimum free memory size
           for each priority.
 
-config SYNC
-        bool "Synchronization framework"
-        default n
-        select ANON_INODES
-        select DMA_SHARED_BUFFER
-        ---help---
-          This option enables the framework for synchronization between multiple
-          drivers.  Sync implementations can take advantage of hardware
-          synchronization built into devices like GPUs.
-
 config SW_SYNC
-        bool "Software synchronization objects"
+        bool "Software synchronization framework"
         default n
-        depends on SYNC
         depends on SYNC_FILE
+        depends on DEBUG_FS
         ---help---
           A sync object driver that uses a 32bit counter to coordinate
           synchronization.  Useful when there is no hardware primitive backing
           the synchronization.
 
+          WARNING: improper use of this can result in deadlocking kernel
+          drivers from userspace. Intended for test and debug only.
+
 source "drivers/staging/android/ion/Kconfig"
 
 endif # if ANDROID
diff --git a/drivers/staging/android/Makefile b/drivers/staging/android/Makefile
index 980d6dc4b265..7ca61b77a8d4 100644
--- a/drivers/staging/android/Makefile
+++ b/drivers/staging/android/Makefile
@@ -4,5 +4,4 @@ obj-y					+= ion/
 
 obj-$(CONFIG_ASHMEM)                    += ashmem.o
 obj-$(CONFIG_ANDROID_LOW_MEMORY_KILLER) += lowmemorykiller.o
-obj-$(CONFIG_SYNC)                      += sync.o sync_debug.o
-obj-$(CONFIG_SW_SYNC)                   += sw_sync.o
+obj-$(CONFIG_SW_SYNC)                   += sw_sync.o sync_debug.o
diff --git a/drivers/staging/android/sw_sync.c b/drivers/staging/android/sw_sync.c
index af39ff58fa33..115c9174705f 100644
--- a/drivers/staging/android/sw_sync.c
+++ b/drivers/staging/android/sw_sync.c
@@ -1,5 +1,5 @@
 /*
- * drivers/base/sw_sync.c
+ * drivers/dma-buf/sw_sync.c
  *
  * Copyright (C) 2012 Google, Inc.
  *
@@ -14,76 +14,331 @@
  *
  */
 
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/export.h>
 #include <linux/file.h>
 #include <linux/fs.h>
-#include <linux/miscdevice.h>
-#include <linux/syscalls.h>
 #include <linux/uaccess.h>
+#include <linux/slab.h>
+#include <linux/sync_file.h>
 
-#include "sw_sync.h"
+#include "sync_debug.h"
 
-struct fence *sw_sync_pt_create(struct sw_sync_timeline *obj, u32 value)
+#define CREATE_TRACE_POINTS
+#include "trace/sync.h"
+
+struct sw_sync_create_fence_data {
+        __u32   value;
+        char    name[32];
+        __s32   fence; /* fd of new fence */
+};
+
+#define SW_SYNC_IOC_MAGIC       'W'
+
+#define SW_SYNC_IOC_CREATE_FENCE        _IOWR(SW_SYNC_IOC_MAGIC, 0,\
+                struct sw_sync_create_fence_data)
+#define SW_SYNC_IOC_INC                 _IOW(SW_SYNC_IOC_MAGIC, 1, __u32)
+
+static const struct fence_ops timeline_fence_ops;
+
+static inline struct sync_pt *fence_to_sync_pt(struct fence *fence)
+{
+        if (fence->ops != &timeline_fence_ops)
+                return NULL;
+        return container_of(fence, struct sync_pt, base);
+}
+
+/**
+ * sync_timeline_create() - creates a sync object
+ * @name:       sync_timeline name
+ *
+ * Creates a new sync_timeline. Returns the sync_timeline object or NULL in
+ * case of error.
+ */
+struct sync_timeline *sync_timeline_create(const char *name)
+{
+        struct sync_timeline *obj;
+
+        obj = kzalloc(sizeof(*obj), GFP_KERNEL);
+        if (!obj)
+                return NULL;
+
+        kref_init(&obj->kref);
+        obj->context = fence_context_alloc(1);
+        strlcpy(obj->name, name, sizeof(obj->name));
+
+        INIT_LIST_HEAD(&obj->child_list_head);
+        INIT_LIST_HEAD(&obj->active_list_head);
+        spin_lock_init(&obj->child_list_lock);
+
+        sync_timeline_debug_add(obj);
+
+        return obj;
+}
+
+static void sync_timeline_free(struct kref *kref)
+{
+        struct sync_timeline *obj =
+                container_of(kref, struct sync_timeline, kref);
+
+        sync_timeline_debug_remove(obj);
+
+        kfree(obj);
+}
+
+static void sync_timeline_get(struct sync_timeline *obj)
+{
+        kref_get(&obj->kref);
+}
+
+static void sync_timeline_put(struct sync_timeline *obj)
+{
+        kref_put(&obj->kref, sync_timeline_free);
+}
+
+/**
+ * sync_timeline_signal() - signal a status change on a sync_timeline
+ * @obj:        sync_timeline to signal
+ * @inc:        num to increment on timeline->value
+ *
+ * A sync implementation should call this any time one of it's fences
+ * has signaled or has an error condition.
+ */
+static void sync_timeline_signal(struct sync_timeline *obj, unsigned int inc)
+{
+        unsigned long flags;
+        struct sync_pt *pt, *next;
+
+        trace_sync_timeline(obj);
+
+        spin_lock_irqsave(&obj->child_list_lock, flags);
+
+        obj->value += inc;
+
+        list_for_each_entry_safe(pt, next, &obj->active_list_head,
+                                 active_list) {
+                if (fence_is_signaled_locked(&pt->base))
+                        list_del_init(&pt->active_list);
+        }
+
+        spin_unlock_irqrestore(&obj->child_list_lock, flags);
+}
+
+/**
+ * sync_pt_create() - creates a sync pt
+ * @parent:     fence's parent sync_timeline
+ * @size:       size to allocate for this pt
+ * @inc:        value of the fence
+ *
+ * Creates a new sync_pt as a child of @parent.  @size bytes will be
+ * allocated allowing for implementation specific data to be kept after
+ * the generic sync_timeline struct. Returns the sync_pt object or
+ * NULL in case of error.
+ */
+static struct sync_pt *sync_pt_create(struct sync_timeline *obj, int size,
+                             unsigned int value)
+{
+        unsigned long flags;
+        struct sync_pt *pt;
+
+        if (size < sizeof(*pt))
+                return NULL;
+
+        pt = kzalloc(size, GFP_KERNEL);
+        if (!pt)
+                return NULL;
+
+        spin_lock_irqsave(&obj->child_list_lock, flags);
+        sync_timeline_get(obj);
+        fence_init(&pt->base, &timeline_fence_ops, &obj->child_list_lock,
+                   obj->context, value);
+        list_add_tail(&pt->child_list, &obj->child_list_head);
+        INIT_LIST_HEAD(&pt->active_list);
+        spin_unlock_irqrestore(&obj->child_list_lock, flags);
+        return pt;
+}
+
+static const char *timeline_fence_get_driver_name(struct fence *fence)
+{
+        return "sw_sync";
+}
+
+static const char *timeline_fence_get_timeline_name(struct fence *fence)
+{
+        struct sync_timeline *parent = fence_parent(fence);
+
+        return parent->name;
+}
+
+static void timeline_fence_release(struct fence *fence)
 {
-        struct sw_sync_pt *pt;
+        struct sync_pt *pt = fence_to_sync_pt(fence);
+        struct sync_timeline *parent = fence_parent(fence);
+        unsigned long flags;
 
-        pt = (struct sw_sync_pt *)
-                sync_pt_create(&obj->obj, sizeof(struct sw_sync_pt));
+        spin_lock_irqsave(fence->lock, flags);
+        list_del(&pt->child_list);
+        if (WARN_ON_ONCE(!list_empty(&pt->active_list)))
+                list_del(&pt->active_list);
+        spin_unlock_irqrestore(fence->lock, flags);
 
-        pt->value = value;
+        sync_timeline_put(parent);
+        fence_free(fence);
+}
+
+static bool timeline_fence_signaled(struct fence *fence)
+{
+        struct sync_timeline *parent = fence_parent(fence);
 
-        return (struct fence *)pt;
+        return (fence->seqno > parent->value) ? false : true;
 }
-EXPORT_SYMBOL(sw_sync_pt_create);
 
-static int sw_sync_fence_has_signaled(struct fence *fence)
+static bool timeline_fence_enable_signaling(struct fence *fence)
 {
-        struct sw_sync_pt *pt = (struct sw_sync_pt *)fence;
-        struct sw_sync_timeline *obj =
-                (struct sw_sync_timeline *)fence_parent(fence);
+        struct sync_pt *pt = fence_to_sync_pt(fence);
+        struct sync_timeline *parent = fence_parent(fence);
 
-        return (pt->value > obj->value) ? 0 : 1;
+        if (timeline_fence_signaled(fence))
+                return false;
+
+        list_add_tail(&pt->active_list, &parent->active_list_head);
+        return true;
 }
 
-static void sw_sync_timeline_value_str(struct sync_timeline *sync_timeline,
-                                       char *str, int size)
+static void timeline_fence_value_str(struct fence *fence,
+                                    char *str, int size)
 {
-        struct sw_sync_timeline *timeline =
-                (struct sw_sync_timeline *)sync_timeline;
-        snprintf(str, size, "%d", timeline->value);
+        snprintf(str, size, "%d", fence->seqno);
 }
 
-static void sw_sync_fence_value_str(struct fence *fence, char *str, int size)
+static void timeline_fence_timeline_value_str(struct fence *fence,
+                                             char *str, int size)
 {
-        struct sw_sync_pt *pt = (struct sw_sync_pt *)fence;
+        struct sync_timeline *parent = fence_parent(fence);
 
-        snprintf(str, size, "%d", pt->value);
+        snprintf(str, size, "%d", parent->value);
 }
 
-static struct sync_timeline_ops sw_sync_timeline_ops = {
-        .driver_name = "sw_sync",
-        .has_signaled = sw_sync_fence_has_signaled,
-        .timeline_value_str = sw_sync_timeline_value_str,
-        .fence_value_str = sw_sync_fence_value_str,
+static const struct fence_ops timeline_fence_ops = {
+        .get_driver_name = timeline_fence_get_driver_name,
+        .get_timeline_name = timeline_fence_get_timeline_name,
+        .enable_signaling = timeline_fence_enable_signaling,
+        .signaled = timeline_fence_signaled,
+        .wait = fence_default_wait,
+        .release = timeline_fence_release,
+        .fence_value_str = timeline_fence_value_str,
+        .timeline_value_str = timeline_fence_timeline_value_str,
 };
 
-struct sw_sync_timeline *sw_sync_timeline_create(const char *name)
+/*
+ * *WARNING*
+ *
+ * improper use of this can result in deadlocking kernel drivers from userspace.
+ */
+
+/* opening sw_sync create a new sync obj */
+static int sw_sync_debugfs_open(struct inode *inode, struct file *file)
 {
-        struct sw_sync_timeline *obj = (struct sw_sync_timeline *)
-                sync_timeline_create(&sw_sync_timeline_ops,
-                                     sizeof(struct sw_sync_timeline),
-                                     name);
+        struct sync_timeline *obj;
+        char task_comm[TASK_COMM_LEN];
 
-        return obj;
+        get_task_comm(task_comm, current);
+
+        obj = sync_timeline_create(task_comm);
+        if (!obj)
+                return -ENOMEM;
+
+        file->private_data = obj;
+
+        return 0;
 }
-EXPORT_SYMBOL(sw_sync_timeline_create);
 
-void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc)
+static int sw_sync_debugfs_release(struct inode *inode, struct file *file)
 {
-        obj->value += inc;
+        struct sync_timeline *obj = file->private_data;
+
+        smp_wmb();
+
+        sync_timeline_put(obj);
+        return 0;
+}
+
+static long sw_sync_ioctl_create_fence(struct sync_timeline *obj,
+                                       unsigned long arg)
+{
+        int fd = get_unused_fd_flags(O_CLOEXEC);
+        int err;
+        struct sync_pt *pt;
+        struct sync_file *sync_file;
+        struct sw_sync_create_fence_data data;
+
+        if (fd < 0)
+                return fd;
+
+        if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
+                err = -EFAULT;
+                goto err;
+        }
+
+        pt = sync_pt_create(obj, sizeof(*pt), data.value);
+        if (!pt) {
+                err = -ENOMEM;
+                goto err;
+        }
+
+        sync_file = sync_file_create(&pt->base);
+        if (!sync_file) {
+                fence_put(&pt->base);
+                err = -ENOMEM;
+                goto err;
+        }
+
+        data.fence = fd;
+        if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
+                fput(sync_file->file);
+                err = -EFAULT;
+                goto err;
+        }
+
+        fd_install(fd, sync_file->file);
+
+        return 0;
+
+err:
+        put_unused_fd(fd);
+        return err;
+}
 
-        sync_timeline_signal(&obj->obj);
+static long sw_sync_ioctl_inc(struct sync_timeline *obj, unsigned long arg)
+{
+        u32 value;
+
+        if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
+                return -EFAULT;
+
+        sync_timeline_signal(obj, value);
+
+        return 0;
+}
+
+static long sw_sync_ioctl(struct file *file, unsigned int cmd,
+                          unsigned long arg)
+{
+        struct sync_timeline *obj = file->private_data;
+
+        switch (cmd) {
+        case SW_SYNC_IOC_CREATE_FENCE:
+                return sw_sync_ioctl_create_fence(obj, arg);
+
+        case SW_SYNC_IOC_INC:
+                return sw_sync_ioctl_inc(obj, arg);
+
+        default:
+                return -ENOTTY;
+        }
 }
-EXPORT_SYMBOL(sw_sync_timeline_inc);
+
+const struct file_operations sw_sync_debugfs_fops = {
+        .open           = sw_sync_debugfs_open,
+        .release        = sw_sync_debugfs_release,
+        .unlocked_ioctl = sw_sync_ioctl,
+        .compat_ioctl   = sw_sync_ioctl,
+};
diff --git a/drivers/staging/android/sw_sync.h b/drivers/staging/android/sw_sync.h
deleted file mode 100644
index e18667bfb0ca..000000000000
--- a/drivers/staging/android/sw_sync.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * include/linux/sw_sync.h
- *
- * Copyright (C) 2012 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- */
-
-#ifndef _LINUX_SW_SYNC_H
-#define _LINUX_SW_SYNC_H
-
-#include <linux/types.h>
-#include <linux/kconfig.h>
-#include "sync.h"
-#include "uapi/sw_sync.h"
-
-struct sw_sync_timeline {
-        struct  sync_timeline   obj;
-
-        u32                     value;
-};
-
-struct sw_sync_pt {
-        struct fence            pt;
-
-        u32                     value;
-};
-
-#if IS_ENABLED(CONFIG_SW_SYNC)
-struct sw_sync_timeline *sw_sync_timeline_create(const char *name);
-void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc);
-
-struct fence *sw_sync_pt_create(struct sw_sync_timeline *obj, u32 value);
-#else
-static inline struct sw_sync_timeline *sw_sync_timeline_create(const char *name)
-{
-        return NULL;
-}
-
-static inline void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc)
-{
-}
-
-static inline struct fence *sw_sync_pt_create(struct sw_sync_timeline *obj,
-                                              u32 value)
-{
-        return NULL;
-}
-#endif /* IS_ENABLED(CONFIG_SW_SYNC) */
-
-#endif /* _LINUX_SW_SYNC_H */
diff --git a/drivers/staging/android/sync.c b/drivers/staging/android/sync.c
deleted file mode 100644
index 1d14c83c7f7c..000000000000
--- a/drivers/staging/android/sync.c
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * drivers/base/sync.c
- *
- * Copyright (C) 2012 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- */
-
-#include <linux/debugfs.h>
-#include <linux/export.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/seq_file.h>
-#include <linux/slab.h>
-#include <linux/uaccess.h>
-#include <linux/anon_inodes.h>
-
-#include "sync.h"
-
-#define CREATE_TRACE_POINTS
-#include "trace/sync.h"
-
-static const struct fence_ops android_fence_ops;
-
-struct sync_timeline *sync_timeline_create(const struct sync_timeline_ops *ops,
-                                           int size, const char *name)
-{
-        struct sync_timeline *obj;
-
-        if (size < sizeof(struct sync_timeline))
-                return NULL;
-
-        obj = kzalloc(size, GFP_KERNEL);
-        if (!obj)
-                return NULL;
-
-        kref_init(&obj->kref);
-        obj->ops = ops;
-        obj->context = fence_context_alloc(1);
-        strlcpy(obj->name, name, sizeof(obj->name));
-
-        INIT_LIST_HEAD(&obj->child_list_head);
-        INIT_LIST_HEAD(&obj->active_list_head);
-        spin_lock_init(&obj->child_list_lock);
-
-        sync_timeline_debug_add(obj);
-
-        return obj;
-}
-EXPORT_SYMBOL(sync_timeline_create);
-
-static void sync_timeline_free(struct kref *kref)
-{
-        struct sync_timeline *obj =
-                container_of(kref, struct sync_timeline, kref);
-
-        sync_timeline_debug_remove(obj);
-
-        kfree(obj);
-}
-
-static void sync_timeline_get(struct sync_timeline *obj)
-{
-        kref_get(&obj->kref);
-}
-
-static void sync_timeline_put(struct sync_timeline *obj)
-{
-        kref_put(&obj->kref, sync_timeline_free);
-}
-
-void sync_timeline_destroy(struct sync_timeline *obj)
-{
-        obj->destroyed = true;
-        /*
-         * Ensure timeline is marked as destroyed before
-         * changing timeline's fences status.
-         */
-        smp_wmb();
-
-        sync_timeline_put(obj);
-}
-EXPORT_SYMBOL(sync_timeline_destroy);
-
-void sync_timeline_signal(struct sync_timeline *obj)
-{
-        unsigned long flags;
-        struct fence *fence, *next;
-
-        trace_sync_timeline(obj);
-
-        spin_lock_irqsave(&obj->child_list_lock, flags);
-
-        list_for_each_entry_safe(fence, next, &obj->active_list_head,
-                                 active_list) {
-                if (fence_is_signaled_locked(fence))
-                        list_del_init(&fence->active_list);
-        }
-
-        spin_unlock_irqrestore(&obj->child_list_lock, flags);
-}
-EXPORT_SYMBOL(sync_timeline_signal);
-
-struct fence *sync_pt_create(struct sync_timeline *obj, int size)
-{
-        unsigned long flags;
-        struct fence *fence;
-
-        if (size < sizeof(*fence))
-                return NULL;
-
-        fence = kzalloc(size, GFP_KERNEL);
-        if (!fence)
-                return NULL;
-
-        spin_lock_irqsave(&obj->child_list_lock, flags);
-        sync_timeline_get(obj);
-        fence_init(fence, &android_fence_ops, &obj->child_list_lock,
-                   obj->context, ++obj->value);
-        list_add_tail(&fence->child_list, &obj->child_list_head);
-        INIT_LIST_HEAD(&fence->active_list);
-        spin_unlock_irqrestore(&obj->child_list_lock, flags);
-        return fence;
-}
-EXPORT_SYMBOL(sync_pt_create);
-
-static const char *android_fence_get_driver_name(struct fence *fence)
-{
-        struct sync_timeline *parent = fence_parent(fence);
-
-        return parent->ops->driver_name;
-}
-
-static const char *android_fence_get_timeline_name(struct fence *fence)
-{
-        struct sync_timeline *parent = fence_parent(fence);
-
-        return parent->name;
-}
-
-static void android_fence_release(struct fence *fence)
-{
-        struct sync_timeline *parent = fence_parent(fence);
-        unsigned long flags;
-
-        spin_lock_irqsave(fence->lock, flags);
-        list_del(&fence->child_list);
-        if (WARN_ON_ONCE(!list_empty(&fence->active_list)))
-                list_del(&fence->active_list);
-        spin_unlock_irqrestore(fence->lock, flags);
-
-        sync_timeline_put(parent);
-        fence_free(fence);
-}
-
-static bool android_fence_signaled(struct fence *fence)
-{
-        struct sync_timeline *parent = fence_parent(fence);
-        int ret;
-
-        ret = parent->ops->has_signaled(fence);
-        if (ret < 0)
-                fence->status = ret;
-        return ret;
-}
-
-static bool android_fence_enable_signaling(struct fence *fence)
-{
-        struct sync_timeline *parent = fence_parent(fence);
-
-        if (android_fence_signaled(fence))
-                return false;
-
-        list_add_tail(&fence->active_list, &parent->active_list_head);
-        return true;
-}
-
-static void android_fence_value_str(struct fence *fence,
-                                    char *str, int size)
-{
-        struct sync_timeline *parent = fence_parent(fence);
-
-        if (!parent->ops->fence_value_str) {
-                if (size)
-                        *str = 0;
-                return;
-        }
-        parent->ops->fence_value_str(fence, str, size);
-}
-
-static void android_fence_timeline_value_str(struct fence *fence,
-                                             char *str, int size)
-{
-        struct sync_timeline *parent = fence_parent(fence);
-
-        if (!parent->ops->timeline_value_str) {
-                if (size)
-                        *str = 0;
-                return;
-        }
-        parent->ops->timeline_value_str(parent, str, size);
-}
-
-static const struct fence_ops android_fence_ops = {
-        .get_driver_name = android_fence_get_driver_name,
-        .get_timeline_name = android_fence_get_timeline_name,
-        .enable_signaling = android_fence_enable_signaling,
-        .signaled = android_fence_signaled,
-        .wait = fence_default_wait,
-        .release = android_fence_release,
-        .fence_value_str = android_fence_value_str,
-        .timeline_value_str = android_fence_timeline_value_str,
-};
diff --git a/drivers/staging/android/sync.h b/drivers/staging/android/sync.h
deleted file mode 100644
index b56885c14839..000000000000
--- a/drivers/staging/android/sync.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * include/linux/sync.h
- *
- * Copyright (C) 2012 Google, Inc.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- */
-
-#ifndef _LINUX_SYNC_H
-#define _LINUX_SYNC_H
-
-#include <linux/types.h>
-#include <linux/kref.h>
-#include <linux/ktime.h>
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include <linux/fence.h>
-
-#include <linux/sync_file.h>
-#include <uapi/linux/sync_file.h>
-
-struct sync_timeline;
-
-/**
- * struct sync_timeline_ops - sync object implementation ops
- * @driver_name:        name of the implementation
- * @has_signaled:       returns:
- *                        1 if pt has signaled
- *                        0 if pt has not signaled
- *                       <0 on error
- * @timeline_value_str: fill str with the value of the sync_timeline's counter
- * @fence_value_str:    fill str with the value of the fence
- */
-struct sync_timeline_ops {
-        const char *driver_name;
-
-        /* required */
-        int (*has_signaled)(struct fence *fence);
-
-        /* optional */
-        void (*timeline_value_str)(struct sync_timeline *timeline, char *str,
-                                   int size);
-
-        /* optional */
-        void (*fence_value_str)(struct fence *fence, char *str, int size);
-};
-
-/**
- * struct sync_timeline - sync object
- * @kref:               reference count on fence.
- * @ops:                ops that define the implementation of the sync_timeline
- * @name:               name of the sync_timeline. Useful for debugging
- * @destroyed:          set when sync_timeline is destroyed
- * @child_list_head:    list of children sync_pts for this sync_timeline
- * @child_list_lock:    lock protecting @child_list_head, destroyed, and
- *                      fence.status
- * @active_list_head:   list of active (unsignaled/errored) sync_pts
- * @sync_timeline_list: membership in global sync_timeline_list
- */
-struct sync_timeline {
-        struct kref             kref;
-        const struct sync_timeline_ops  *ops;
-        char                    name[32];
-
-        /* protected by child_list_lock */
-        bool                    destroyed;
-        int                     context, value;
-
-        struct list_head        child_list_head;
-        spinlock_t              child_list_lock;
-
-        struct list_head        active_list_head;
-
-#ifdef CONFIG_DEBUG_FS
-        struct list_head        sync_timeline_list;
-#endif
-};
-
-static inline struct sync_timeline *fence_parent(struct fence *fence)
-{
-        return container_of(fence->lock, struct sync_timeline,
-                            child_list_lock);
-}
-
-/*
- * API for sync_timeline implementers
- */
-
-/**
- * sync_timeline_create() - creates a sync object
- * @ops:        specifies the implementation ops for the object
- * @size:       size to allocate for this obj
- * @name:       sync_timeline name
- *
- * Creates a new sync_timeline which will use the implementation specified by
- * @ops.  @size bytes will be allocated allowing for implementation specific
- * data to be kept after the generic sync_timeline struct. Returns the
- * sync_timeline object or NULL in case of error.
- */
-struct sync_timeline *sync_timeline_create(const struct sync_timeline_ops *ops,
-                                           int size, const char *name);
-
-/**
- * sync_timeline_destroy() - destroys a sync object
- * @obj:        sync_timeline to destroy
- *
- * A sync implementation should call this when the @obj is going away
- * (i.e. module unload.)  @obj won't actually be freed until all its children
- * fences are freed.
- */
-void sync_timeline_destroy(struct sync_timeline *obj);
-
-/**
- * sync_timeline_signal() - signal a status change on a sync_timeline
- * @obj:        sync_timeline to signal
- *
- * A sync implementation should call this any time one of it's fences
- * has signaled or has an error condition.
- */
-void sync_timeline_signal(struct sync_timeline *obj);
-
-/**
- * sync_pt_create() - creates a sync pt
- * @parent:     fence's parent sync_timeline
- * @size:       size to allocate for this pt
- *
- * Creates a new fence as a child of @parent.  @size bytes will be
- * allocated allowing for implementation specific data to be kept after
- * the generic sync_timeline struct. Returns the fence object or
- * NULL in case of error.
- */
-struct fence *sync_pt_create(struct sync_timeline *parent, int size);
-
-#ifdef CONFIG_DEBUG_FS
-
-void sync_timeline_debug_add(struct sync_timeline *obj);
-void sync_timeline_debug_remove(struct sync_timeline *obj);
-void sync_file_debug_add(struct sync_file *fence);
-void sync_file_debug_remove(struct sync_file *fence);
-void sync_dump(void);
-
-#else
-# define sync_timeline_debug_add(obj)
-# define sync_timeline_debug_remove(obj)
-# define sync_file_debug_add(fence)
-# define sync_file_debug_remove(fence)
-# define sync_dump()
-#endif
-
-#endif /* _LINUX_SYNC_H */
diff --git a/drivers/staging/android/sync_debug.c b/drivers/staging/android/sync_debug.c
index 5f57499c98bf..4c5a85595a85 100644
--- a/drivers/staging/android/sync_debug.c
+++ b/drivers/staging/android/sync_debug.c
@@ -15,21 +15,7 @@
  */
 
 #include <linux/debugfs.h>
-#include <linux/export.h>
-#include <linux/file.h>
-#include <linux/fs.h>
-#include <linux/kernel.h>
-#include <linux/poll.h>
-#include <linux/sched.h>
-#include <linux/seq_file.h>
-#include <linux/slab.h>
-#include <linux/uaccess.h>
-#include <linux/anon_inodes.h>
-#include <linux/time64.h>
-#include <linux/sync_file.h>
-#include "sw_sync.h"
-
-#ifdef CONFIG_DEBUG_FS
+#include "sync_debug.h"
 
 static struct dentry *dbgfs;
 
@@ -105,7 +91,7 @@ static void sync_print_fence(struct seq_file *s, struct fence *fence, bool show)
                 seq_printf(s, "@%lld.%09ld", (s64)ts64.tv_sec, ts64.tv_nsec);
         }
 
-        if ((!fence || fence->ops->timeline_value_str) &&
+        if (fence->ops->timeline_value_str &&
                 fence->ops->fence_value_str) {
                 char value[64];
                 bool success;
@@ -113,10 +99,9 @@ static void sync_print_fence(struct seq_file *s, struct fence *fence, bool show)
                 fence->ops->fence_value_str(fence, value, sizeof(value));
                 success = strlen(value);
 
-                if (success)
+                if (success) {
                         seq_printf(s, ": %s", value);
 
-                if (success && fence) {
                         fence->ops->timeline_value_str(fence, value,
                                                        sizeof(value));
 
@@ -133,22 +118,13 @@ static void sync_print_obj(struct seq_file *s, struct sync_timeline *obj)
         struct list_head *pos;
         unsigned long flags;
 
-        seq_printf(s, "%s %s", obj->name, obj->ops->driver_name);
-
-        if (obj->ops->timeline_value_str) {
-                char value[64];
-
-                obj->ops->timeline_value_str(obj, value, sizeof(value));
-                seq_printf(s, ": %s", value);
-        }
-
-        seq_puts(s, "\n");
+        seq_printf(s, "%s: %d\n", obj->name, obj->value);
 
         spin_lock_irqsave(&obj->child_list_lock, flags);
         list_for_each(pos, &obj->child_list_head) {
-                struct fence *fence =
-                        container_of(pos, struct fence, child_list);
-                sync_print_fence(s, fence, false);
+                struct sync_pt *pt =
+                        container_of(pos, struct sync_pt, child_list);
+                sync_print_fence(s, &pt->base, false);
         }
         spin_unlock_irqrestore(&obj->child_list_lock, flags);
 }
@@ -209,126 +185,19 @@ static const struct file_operations sync_info_debugfs_fops = {
         .release        = single_release,
 };
 
-/*
- * *WARNING*
- *
- * improper use of this can result in deadlocking kernel drivers from userspace.
- */
-
-/* opening sw_sync create a new sync obj */
-static int sw_sync_debugfs_open(struct inode *inode, struct file *file)
-{
-        struct sw_sync_timeline *obj;
-        char task_comm[TASK_COMM_LEN];
-
-        get_task_comm(task_comm, current);
-
-        obj = sw_sync_timeline_create(task_comm);
-        if (!obj)
-                return -ENOMEM;
-
-        file->private_data = obj;
-
-        return 0;
-}
-
-static int sw_sync_debugfs_release(struct inode *inode, struct file *file)
-{
-        struct sw_sync_timeline *obj = file->private_data;
-
-        sync_timeline_destroy(&obj->obj);
-        return 0;
-}
-
-static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj,
-                                       unsigned long arg)
-{
-        int fd = get_unused_fd_flags(O_CLOEXEC);
-        int err;
-        struct fence *fence;
-        struct sync_file *sync_file;
-        struct sw_sync_create_fence_data data;
-
-        if (fd < 0)
-                return fd;
-
-        if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
-                err = -EFAULT;
-                goto err;
-        }
-
-        fence = sw_sync_pt_create(obj, data.value);
-        if (!fence) {
-                err = -ENOMEM;
-                goto err;
-        }
-
-        sync_file = sync_file_create(fence);
-        if (!sync_file) {
-                fence_put(fence);
-                err = -ENOMEM;
-                goto err;
-        }
-
-        data.fence = fd;
-        if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
-                fput(sync_file->file);
-                err = -EFAULT;
-                goto err;
-        }
-
-        fd_install(fd, sync_file->file);
-
-        return 0;
-
-err:
-        put_unused_fd(fd);
-        return err;
-}
-
-static long sw_sync_ioctl_inc(struct sw_sync_timeline *obj, unsigned long arg)
-{
-        u32 value;
-
-        if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
-                return -EFAULT;
-
-        sw_sync_timeline_inc(obj, value);
-
-        return 0;
-}
-
-static long sw_sync_ioctl(struct file *file, unsigned int cmd,
-                          unsigned long arg)
-{
-        struct sw_sync_timeline *obj = file->private_data;
-
-        switch (cmd) {
-        case SW_SYNC_IOC_CREATE_FENCE:
-                return sw_sync_ioctl_create_fence(obj, arg);
-
-        case SW_SYNC_IOC_INC:
-                return sw_sync_ioctl_inc(obj, arg);
-
-        default:
-                return -ENOTTY;
-        }
-}
-
-static const struct file_operations sw_sync_debugfs_fops = {
-        .open           = sw_sync_debugfs_open,
-        .release        = sw_sync_debugfs_release,
-        .unlocked_ioctl = sw_sync_ioctl,
-        .compat_ioctl = sw_sync_ioctl,
-};
-
 static __init int sync_debugfs_init(void)
 {
         dbgfs = debugfs_create_dir("sync", NULL);
 
-        debugfs_create_file("info", 0444, dbgfs, NULL, &sync_info_debugfs_fops);
-        debugfs_create_file("sw_sync", 0644, dbgfs, NULL,
-                            &sw_sync_debugfs_fops);
+        /*
+         * The debugfs files won't ever get removed and thus, there is
+         * no need to protect it against removal races. The use of
+         * debugfs_create_file_unsafe() is actually safe here.
+         */
+        debugfs_create_file_unsafe("info", 0444, dbgfs, NULL,
+                                   &sync_info_debugfs_fops);
+        debugfs_create_file_unsafe("sw_sync", 0644, dbgfs, NULL,
+                                   &sw_sync_debugfs_fops);
 
         return 0;
 }
@@ -359,5 +228,3 @@ void sync_dump(void)
                 }
         }
 }
-
-#endif
diff --git a/drivers/staging/android/sync_debug.h b/drivers/staging/android/sync_debug.h
new file mode 100644
index 000000000000..425ebc5c32aa
--- /dev/null
+++ b/drivers/staging/android/sync_debug.h
@@ -0,0 +1,83 @@
+/*
+ * include/linux/sync.h
+ *
+ * Copyright (C) 2012 Google, Inc.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_SYNC_H
+#define _LINUX_SYNC_H
+
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/fence.h>
+
+#include <linux/sync_file.h>
+#include <uapi/linux/sync_file.h>
+
+/**
+ * struct sync_timeline - sync object
+ * @kref:               reference count on fence.
+ * @name:               name of the sync_timeline. Useful for debugging
+ * @child_list_head:    list of children sync_pts for this sync_timeline
+ * @child_list_lock:    lock protecting @child_list_head and fence.status
+ * @active_list_head:   list of active (unsignaled/errored) sync_pts
+ * @sync_timeline_list: membership in global sync_timeline_list
+ */
+struct sync_timeline {
+        struct kref             kref;
+        char                    name[32];
+
+        /* protected by child_list_lock */
+        int                     context, value;
+
+        struct list_head        child_list_head;
+        spinlock_t              child_list_lock;
+
+        struct list_head        active_list_head;
+
+        struct list_head        sync_timeline_list;
+};
+
+static inline struct sync_timeline *fence_parent(struct fence *fence)
+{
+        return container_of(fence->lock, struct sync_timeline,
+                            child_list_lock);
+}
+
+/**
+ * struct sync_pt - sync_pt object
+ * @base: base fence object
+ * @child_list: sync timeline child's list
+ * @active_list: sync timeline active child's list
+ */
+struct sync_pt {
+        struct fence base;
+        struct list_head child_list;
+        struct list_head active_list;
+};
+
+#ifdef CONFIG_SW_SYNC
+
+extern const struct file_operations sw_sync_debugfs_fops;
+
+void sync_timeline_debug_add(struct sync_timeline *obj);
+void sync_timeline_debug_remove(struct sync_timeline *obj);
+void sync_file_debug_add(struct sync_file *fence);
+void sync_file_debug_remove(struct sync_file *fence);
+void sync_dump(void);
+
+#else
+# define sync_timeline_debug_add(obj)
+# define sync_timeline_debug_remove(obj)
+# define sync_file_debug_add(fence)
+# define sync_file_debug_remove(fence)
+# define sync_dump()
+#endif
+
+#endif /* _LINUX_SYNC_H */
diff --git a/drivers/staging/android/trace/sync.h b/drivers/staging/android/trace/sync.h
index a0f80f41677e..6b5ce9640ddd 100644
--- a/drivers/staging/android/trace/sync.h
+++ b/drivers/staging/android/trace/sync.h
@@ -5,7 +5,7 @@
 #if !defined(_TRACE_SYNC_H) || defined(TRACE_HEADER_MULTI_READ)
 #define _TRACE_SYNC_H
 
-#include "../sync.h"
+#include "../sync_debug.h"
 #include <linux/tracepoint.h>
 
 TRACE_EVENT(sync_timeline,
@@ -15,21 +15,15 @@ TRACE_EVENT(sync_timeline,
 
         TP_STRUCT__entry(
                         __string(name, timeline->name)
-                        __array(char, value, 32)
+                        __field(u32, value)
         ),
 
         TP_fast_assign(
                         __assign_str(name, timeline->name);
-                        if (timeline->ops->timeline_value_str) {
-                                timeline->ops->timeline_value_str(timeline,
-                                                        __entry->value,
-                                                        sizeof(__entry->value));
-                        } else {
-                                __entry->value[0] = '\0';
-                        }
+                        __entry->value = timeline->value;
         ),
 
-        TP_printk("name=%s value=%s", __get_str(name), __entry->value)
+        TP_printk("name=%s value=%d", __get_str(name), __entry->value)
 );
 
 #endif /* if !defined(_TRACE_SYNC_H) || defined(TRACE_HEADER_MULTI_READ) */
diff --git a/drivers/staging/android/uapi/sw_sync.h b/drivers/staging/android/uapi/sw_sync.h
deleted file mode 100644
index 9b5d4869505c..000000000000
--- a/drivers/staging/android/uapi/sw_sync.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2012 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- */
-
-#ifndef _UAPI_LINUX_SW_SYNC_H
-#define _UAPI_LINUX_SW_SYNC_H
-
-#include <linux/types.h>
-
-struct sw_sync_create_fence_data {
-        __u32   value;
-        char    name[32];
-        __s32   fence; /* fd of new fence */
-};
-
-#define SW_SYNC_IOC_MAGIC       'W'
-
-#define SW_SYNC_IOC_CREATE_FENCE        _IOWR(SW_SYNC_IOC_MAGIC, 0,\
-                struct sw_sync_create_fence_data)
-#define SW_SYNC_IOC_INC                 _IOW(SW_SYNC_IOC_MAGIC, 1, __u32)
-
-#endif /* _UAPI_LINUX_SW_SYNC_H */
diff --git a/drivers/staging/comedi/comedi.h b/drivers/staging/comedi/comedi.h
index ad5297f6d418..08fb26b51a5f 100644
--- a/drivers/staging/comedi/comedi.h
+++ b/drivers/staging/comedi/comedi.h
@@ -779,7 +779,7 @@ struct comedi_subdinfo {
         unsigned int flags;
         unsigned int range_type;
         unsigned int settling_time_0;
-        unsigned insn_bits_support;
+        unsigned int insn_bits_support;
         unsigned int unused[8];
 };
 
diff --git a/drivers/staging/comedi/comedi_fops.c b/drivers/staging/comedi/comedi_fops.c
index 629080f39db0..1999eed4f4c5 100644
--- a/drivers/staging/comedi/comedi_fops.c
+++ b/drivers/staging/comedi/comedi_fops.c
@@ -312,8 +312,8 @@ static void comedi_file_reset(struct file *file)
         }
         cfp->last_attached = dev->attached;
         cfp->last_detach_count = dev->detach_count;
-        ACCESS_ONCE(cfp->read_subdev) = read_s;
-        ACCESS_ONCE(cfp->write_subdev) = write_s;
+        WRITE_ONCE(cfp->read_subdev, read_s);
+        WRITE_ONCE(cfp->write_subdev, write_s);
 }
 
 static void comedi_file_check(struct file *file)
@@ -331,7 +331,7 @@ static struct comedi_subdevice *comedi_file_read_subdevice(struct file *file)
         struct comedi_file *cfp = file->private_data;
 
         comedi_file_check(file);
-        return ACCESS_ONCE(cfp->read_subdev);
+        return READ_ONCE(cfp->read_subdev);
 }
 
 static struct comedi_subdevice *comedi_file_write_subdevice(struct file *file)
@@ -339,7 +339,7 @@ static struct comedi_subdevice *comedi_file_write_subdevice(struct file *file)
         struct comedi_file *cfp = file->private_data;
 
         comedi_file_check(file);
-        return ACCESS_ONCE(cfp->write_subdev);
+        return READ_ONCE(cfp->write_subdev);
 }
 
 static int resize_async_buffer(struct comedi_device *dev,
@@ -1256,16 +1256,17 @@ static int parse_insn(struct comedi_device *dev, struct comedi_insn *insn,
                 switch (insn->insn) {
                 case INSN_GTOD:
                         {
-                                struct timeval tv;
+                                struct timespec64 tv;
 
                                 if (insn->n != 2) {
                                         ret = -EINVAL;
                                         break;
                                 }
 
-                                do_gettimeofday(&tv);
-                                data[0] = tv.tv_sec;
-                                data[1] = tv.tv_usec;
+                                ktime_get_real_ts64(&tv);
+                                /* unsigned data safe until 2106 */
+                                data[0] = (unsigned int)tv.tv_sec;
+                                data[1] = tv.tv_nsec / NSEC_PER_USEC;
                                 ret = 2;
 
                                 break;
@@ -1992,7 +1993,7 @@ static int do_setrsubd_ioctl(struct comedi_device *dev, unsigned long arg,
             !(s_old->async->cmd.flags & CMDF_WRITE))
                 return -EBUSY;
 
-        ACCESS_ONCE(cfp->read_subdev) = s_new;
+        WRITE_ONCE(cfp->read_subdev, s_new);
         return 0;
 }
 
@@ -2034,7 +2035,7 @@ static int do_setwsubd_ioctl(struct comedi_device *dev, unsigned long arg,
             (s_old->async->cmd.flags & CMDF_WRITE))
                 return -EBUSY;
 
-        ACCESS_ONCE(cfp->write_subdev) = s_new;
+        WRITE_ONCE(cfp->write_subdev, s_new);
         return 0;
 }
 
diff --git a/drivers/staging/comedi/drivers/addi-data/hwdrv_apci1564.c b/drivers/staging/comedi/drivers/addi-data/hwdrv_apci1564.c
deleted file mode 100644
index f0c0d58383ca..000000000000
--- a/drivers/staging/comedi/drivers/addi-data/hwdrv_apci1564.c
+++ /dev/null
@@ -1,187 +0,0 @@
-static int apci1564_timer_insn_config(struct comedi_device *dev,
-                                      struct comedi_subdevice *s,
-                                      struct comedi_insn *insn,
-                                      unsigned int *data)
-{
-        struct apci1564_private *devpriv = dev->private;
-        unsigned int ctrl;
-
-        devpriv->tsk_current = current;
-
-        /* Stop the timer */
-        ctrl = inl(devpriv->timer + ADDI_TCW_CTRL_REG);
-        ctrl &= ~(ADDI_TCW_CTRL_GATE | ADDI_TCW_CTRL_TRIG |
-                  ADDI_TCW_CTRL_ENA);
-        outl(ctrl, devpriv->timer + ADDI_TCW_CTRL_REG);
-
-        if (data[1] == 1) {
-                /* Enable timer int & disable all the other int sources */
-                outl(ADDI_TCW_CTRL_IRQ_ENA,
-                     devpriv->timer + ADDI_TCW_CTRL_REG);
-                outl(0x0, dev->iobase + APCI1564_DI_IRQ_REG);
-                outl(0x0, dev->iobase + APCI1564_DO_IRQ_REG);
-                outl(0x0, dev->iobase + APCI1564_WDOG_IRQ_REG);
-                if (devpriv->counters) {
-                        unsigned long iobase;
-
-                        iobase = devpriv->counters + ADDI_TCW_IRQ_REG;
-                        outl(0x0, iobase + APCI1564_COUNTER(0));
-                        outl(0x0, iobase + APCI1564_COUNTER(1));
-                        outl(0x0, iobase + APCI1564_COUNTER(2));
-                }
-        } else {
-                /* disable Timer interrupt */
-                outl(0x0, devpriv->timer + ADDI_TCW_CTRL_REG);
-        }
-
-        /* Loading Timebase */
-        outl(data[2], devpriv->timer + ADDI_TCW_TIMEBASE_REG);
-
-        /* Loading the Reload value */
-        outl(data[3], devpriv->timer + ADDI_TCW_RELOAD_REG);
-
-        ctrl = inl(devpriv->timer + ADDI_TCW_CTRL_REG);
-        ctrl &= ~(ADDI_TCW_CTRL_CNTR_ENA | ADDI_TCW_CTRL_MODE_MASK |
-                  ADDI_TCW_CTRL_GATE | ADDI_TCW_CTRL_TRIG |
-                  ADDI_TCW_CTRL_TIMER_ENA | ADDI_TCW_CTRL_RESET_ENA |
-                  ADDI_TCW_CTRL_WARN_ENA | ADDI_TCW_CTRL_ENA);
-        ctrl |= ADDI_TCW_CTRL_MODE(2) | ADDI_TCW_CTRL_TIMER_ENA;
-        outl(ctrl, devpriv->timer + ADDI_TCW_CTRL_REG);
-
-        return insn->n;
-}
-
-static int apci1564_timer_insn_write(struct comedi_device *dev,
-                                     struct comedi_subdevice *s,
-                                     struct comedi_insn *insn,
-                                     unsigned int *data)
-{
-        struct apci1564_private *devpriv = dev->private;
-        unsigned int ctrl;
-
-        ctrl = inl(devpriv->timer + ADDI_TCW_CTRL_REG);
-        ctrl &= ~(ADDI_TCW_CTRL_GATE | ADDI_TCW_CTRL_TRIG);
-        switch (data[1]) {
-        case 0: /* Stop The Timer */
-                ctrl &= ~ADDI_TCW_CTRL_ENA;
-                break;
-        case 1: /* Enable the Timer */
-                ctrl |= ADDI_TCW_CTRL_ENA;
-                break;
-        }
-        outl(ctrl, devpriv->timer + ADDI_TCW_CTRL_REG);
-
-        return insn->n;
-}
-
-static int apci1564_timer_insn_read(struct comedi_device *dev,
-                                    struct comedi_subdevice *s,
-                                    struct comedi_insn *insn,
-                                    unsigned int *data)
-{
-        struct apci1564_private *devpriv = dev->private;
-
-        /* Stores the status of the Timer */
-        data[0] = inl(devpriv->timer + ADDI_TCW_STATUS_REG) &
-                  ADDI_TCW_STATUS_OVERFLOW;
-
-        /* Stores the Actual value of the Timer */
-        data[1] = inl(devpriv->timer + ADDI_TCW_VAL_REG);
-
-        return insn->n;
-}
-
-static int apci1564_counter_insn_config(struct comedi_device *dev,
-                                        struct comedi_subdevice *s,
-                                        struct comedi_insn *insn,
-                                        unsigned int *data)
-{
-        struct apci1564_private *devpriv = dev->private;
-        unsigned int chan = CR_CHAN(insn->chanspec);
-        unsigned long iobase = devpriv->counters + APCI1564_COUNTER(chan);
-        unsigned int ctrl;
-
-        devpriv->tsk_current = current;
-
-        /* Stop The Timer */
-        ctrl = inl(iobase + ADDI_TCW_CTRL_REG);
-        ctrl &= ~(ADDI_TCW_CTRL_GATE | ADDI_TCW_CTRL_TRIG |
-                  ADDI_TCW_CTRL_ENA);
-        outl(ctrl, iobase + ADDI_TCW_CTRL_REG);
-
-        /* Set the reload value */
-        outl(data[3], iobase + ADDI_TCW_RELOAD_REG);
-
-        /* Set the mode */
-        ctrl &= ~(ADDI_TCW_CTRL_EXT_CLK_MASK | ADDI_TCW_CTRL_MODE_MASK |
-                  ADDI_TCW_CTRL_TIMER_ENA | ADDI_TCW_CTRL_RESET_ENA |
-                  ADDI_TCW_CTRL_WARN_ENA);
-        ctrl |= ADDI_TCW_CTRL_CNTR_ENA | ADDI_TCW_CTRL_MODE(data[4]);
-        outl(ctrl, iobase + ADDI_TCW_CTRL_REG);
-
-        /* Enable or Disable Interrupt */
-        if (data[1])
-                ctrl |= ADDI_TCW_CTRL_IRQ_ENA;
-        else
-                ctrl &= ~ADDI_TCW_CTRL_IRQ_ENA;
-        outl(ctrl, iobase + ADDI_TCW_CTRL_REG);
-
-        /* Set the Up/Down selection */
-        if (data[6])
-                ctrl |= ADDI_TCW_CTRL_CNT_UP;
-        else
-                ctrl &= ~ADDI_TCW_CTRL_CNT_UP;
-        outl(ctrl, iobase + ADDI_TCW_CTRL_REG);
-
-        return insn->n;
-}
-
-static int apci1564_counter_insn_write(struct comedi_device *dev,
-                                       struct comedi_subdevice *s,
-                                       struct comedi_insn *insn,
-                                       unsigned int *data)
-{
-        struct apci1564_private *devpriv = dev->private;
-        unsigned int chan = CR_CHAN(insn->chanspec);
-        unsigned long iobase = devpriv->counters + APCI1564_COUNTER(chan);
-        unsigned int ctrl;
-
-        ctrl = inl(iobase + ADDI_TCW_CTRL_REG);
-        ctrl &= ~(ADDI_TCW_CTRL_GATE | ADDI_TCW_CTRL_TRIG);
-        switch (data[1]) {
-        case 0: /* Stops the Counter subdevice */
-                ctrl = 0;
-                break;
-        case 1: /* Start the Counter subdevice */
-                ctrl |= ADDI_TCW_CTRL_ENA;
-                break;
-        case 2: /* Clears the Counter subdevice */
-                ctrl |= ADDI_TCW_CTRL_GATE;
-                break;
-        }
-        outl(ctrl, iobase + ADDI_TCW_CTRL_REG);
-
-        return insn->n;
-}
-
-static int apci1564_counter_insn_read(struct comedi_device *dev,
-                                      struct comedi_subdevice *s,
-                                      struct comedi_insn *insn,
-                                      unsigned int *data)
-{
-        struct apci1564_private *devpriv = dev->private;
-        unsigned int chan = CR_CHAN(insn->chanspec);
-        unsigned long iobase = devpriv->counters + APCI1564_COUNTER(chan);
-        unsigned int status;
-
-        /* Read the Counter Actual Value. */
-        data[0] = inl(iobase + ADDI_TCW_VAL_REG);
-
-        status = inl(iobase + ADDI_TCW_STATUS_REG);
-        data[1] = (status & ADDI_TCW_STATUS_SOFT_TRIG) ? 1 : 0;
-        data[2] = (status & ADDI_TCW_STATUS_HARDWARE_TRIG) ? 1 : 0;
-        data[3] = (status & ADDI_TCW_STATUS_SOFT_CLR) ? 1 : 0;
-        data[4] = (status & ADDI_TCW_STATUS_OVERFLOW) ? 1 : 0;
-
-        return insn->n;
-}
diff --git a/drivers/staging/comedi/drivers/addi_apci_1564.c b/drivers/staging/comedi/drivers/addi_apci_1564.c
index f1ccfbd4c578..9bfb79c2e5c8 100644
--- a/drivers/staging/comedi/drivers/addi_apci_1564.c
+++ b/drivers/staging/comedi/drivers/addi_apci_1564.c
@@ -21,9 +21,62 @@
  * details.
  */
 
+/*
+ * Driver: addi_apci_1564
+ * Description: ADDI-DATA APCI-1564 Digital I/O board
+ * Devices: [ADDI-DATA] APCI-1564 (addi_apci_1564)
+ * Author: H Hartley Sweeten <hsweeten@visionengravers.com>
+ * Updated: Thu, 02 Jun 2016 13:12:46 -0700
+ * Status: untested
+ *
+ * Configuration Options: not applicable, uses comedi PCI auto config
+ *
+ * This board has the following features:
+ *   - 32 optically isolated digital inputs (24V), 16 of which can
+ *     generate change-of-state (COS) interrupts (channels 4 to 19)
+ *   - 32 optically isolated digital outputs (10V to 36V)
+ *   - 1 8-bit watchdog for resetting the outputs
+ *   - 1 12-bit timer
+ *   - 3 32-bit counters
+ *   - 2 diagnostic inputs
+ *
+ * The COS, timer, and counter subdevices all use the dev->read_subdev to
+ * return the interrupt status. The sample data is updated and returned when
+ * any of these subdevices generate an interrupt. The sample data format is:
+ *
+ *    Bit   Description
+ *   -----  ------------------------------------------
+ *    31    COS interrupt
+ *    30    timer interrupt
+ *    29    counter 2 interrupt
+ *    28    counter 1 interrupt
+ *    27    counter 0 interrupt
+ *   26:20  not used
+ *   19:4   COS digital input state (channels 19 to 4)
+ *    3:0   not used
+ *
+ * The COS interrupts must be configured using an INSN_CONFIG_DIGITAL_TRIG
+ * instruction before they can be enabled by an async command. The COS
+ * interrupts will stay active until canceled.
+ *
+ * The timer subdevice does not use an async command. All control is handled
+ * by the (*insn_config).
+ *
+ * FIXME: The format of the ADDI_TCW_TIMEBASE_REG is not descibed in the
+ * datasheet I have. The INSN_CONFIG_SET_CLOCK_SRC currently just writes
+ * the raw data[1] to this register along with the raw data[2] value to the
+ * ADDI_TCW_RELOAD_REG. If anyone tests this and can determine the actual
+ * timebase/reload operation please let me know.
+ *
+ * The counter subdevice also does not use an async command. All control is
+ * handled by the (*insn_config).
+ *
+ * FIXME: The operation of the counters is not really described in the
+ * datasheet I have. The (*insn_config) needs more work.
+ */
+
 #include <linux/module.h>
 #include <linux/interrupt.h>
-#include <linux/sched.h>
 
 #include "../comedi_pci.h"
 #include "addi_tcw.h"
@@ -77,6 +130,7 @@
 #define APCI1564_DI_REG                         0x00
 #define APCI1564_DI_INT_MODE1_REG               0x04
 #define APCI1564_DI_INT_MODE2_REG               0x08
+#define APCI1564_DI_INT_MODE_MASK               0x000ffff0 /* chans [19:4] */
 #define APCI1564_DI_INT_STATUS_REG              0x0c
 #define APCI1564_DI_IRQ_REG                     0x10
 #define APCI1564_DI_IRQ_ENA                     BIT(2)
@@ -90,14 +144,7 @@
 #define APCI1564_DO_INT_STATUS_VCC              BIT(0)
 #define APCI1564_DO_IRQ_REG                     0x20
 #define APCI1564_DO_IRQ_INTR                    BIT(0)
-#define APCI1564_WDOG_REG                       0x24
-#define APCI1564_WDOG_RELOAD_REG                0x28
-#define APCI1564_WDOG_TIMEBASE_REG              0x2c
-#define APCI1564_WDOG_CTRL_REG                  0x30
-#define APCI1564_WDOG_STATUS_REG                0x34
-#define APCI1564_WDOG_IRQ_REG                   0x38
-#define APCI1564_WDOG_WARN_TIMEVAL_REG          0x3c
-#define APCI1564_WDOG_WARN_TIMEBASE_REG         0x40
+#define APCI1564_WDOG_IOBASE                    0x24
 
 /*
  * devpriv->timer Register Map (see addi_tcw.h for register/bit defines)
@@ -111,18 +158,24 @@
  */
 #define APCI1564_COUNTER(x)                     ((x) * 0x20)
 
+/*
+ * The dev->read_subdev is used to return the interrupt events along with
+ * the state of the interrupt capable inputs.
+ */
+#define APCI1564_EVENT_COS                      BIT(31)
+#define APCI1564_EVENT_TIMER                    BIT(30)
+#define APCI1564_EVENT_COUNTER(x)               BIT(27 + (x)) /* counter 0-2 */
+#define APCI1564_EVENT_MASK                     0xfff0000f /* all but [19:4] */
+
 struct apci1564_private {
         unsigned long eeprom;   /* base address of EEPROM register */
         unsigned long timer;    /* base address of 12-bit timer */
         unsigned long counters; /* base address of 32-bit counters */
-        unsigned int mode1;     /* riding-edge/high level channels */
+        unsigned int mode1;     /* rising-edge/high level channels */
         unsigned int mode2;     /* falling-edge/low level channels */
         unsigned int ctrl;      /* interrupt mode OR (edge) . AND (level) */
-        struct task_struct *tsk_current;
 };
 
-#include "addi-data/hwdrv_apci1564.c"
-
 static int apci1564_reset(struct comedi_device *dev)
 {
         struct apci1564_private *devpriv = dev->private;
@@ -138,7 +191,7 @@ static int apci1564_reset(struct comedi_device *dev)
         outl(0x0, dev->iobase + APCI1564_DO_INT_CTRL_REG);
 
         /* Reset the watchdog registers */
-        addi_watchdog_reset(dev->iobase + APCI1564_WDOG_REG);
+        addi_watchdog_reset(dev->iobase + APCI1564_WDOG_IOBASE);
 
         /* Reset the timer registers */
         outl(0x0, devpriv->timer + ADDI_TCW_CTRL_REG);
@@ -165,55 +218,54 @@ static irqreturn_t apci1564_interrupt(int irq, void *d)
         unsigned int ctrl;
         unsigned int chan;
 
+        s->state &= ~APCI1564_EVENT_MASK;
+
         status = inl(dev->iobase + APCI1564_DI_IRQ_REG);
         if (status & APCI1564_DI_IRQ_ENA) {
-                /* disable the interrupt */
+                /* get the COS interrupt state and set the event flag */
+                s->state = inl(dev->iobase + APCI1564_DI_INT_STATUS_REG);
+                s->state &= APCI1564_DI_INT_MODE_MASK;
+                s->state |= APCI1564_EVENT_COS;
+
+                /* clear the interrupt */
                 outl(status & ~APCI1564_DI_IRQ_ENA,
                      dev->iobase + APCI1564_DI_IRQ_REG);
-
-                s->state = inl(dev->iobase + APCI1564_DI_INT_STATUS_REG) &
-                           0xffff;
-                comedi_buf_write_samples(s, &s->state, 1);
-                comedi_handle_events(dev, s);
-
-                /* enable the interrupt */
                 outl(status, dev->iobase + APCI1564_DI_IRQ_REG);
         }
 
         status = inl(devpriv->timer + ADDI_TCW_IRQ_REG);
-        if (status & 0x01) {
-                /*  Disable Timer Interrupt */
+        if (status & ADDI_TCW_IRQ) {
+                s->state |= APCI1564_EVENT_TIMER;
+
+                /* clear the interrupt */
                 ctrl = inl(devpriv->timer + ADDI_TCW_CTRL_REG);
                 outl(0x0, devpriv->timer + ADDI_TCW_CTRL_REG);
-
-                /* Send a signal to from kernel to user space */
-                send_sig(SIGIO, devpriv->tsk_current, 0);
-
-                /*  Enable Timer Interrupt */
                 outl(ctrl, devpriv->timer + ADDI_TCW_CTRL_REG);
         }
 
         if (devpriv->counters) {
-                for (chan = 0; chan < 4; chan++) {
+                for (chan = 0; chan < 3; chan++) {
                         unsigned long iobase;
 
                         iobase = devpriv->counters + APCI1564_COUNTER(chan);
 
                         status = inl(iobase + ADDI_TCW_IRQ_REG);
-                        if (status & 0x01) {
-                                /*  Disable Counter Interrupt */
+                        if (status & ADDI_TCW_IRQ) {
+                                s->state |= APCI1564_EVENT_COUNTER(chan);
+
+                                /* clear the interrupt */
                                 ctrl = inl(iobase + ADDI_TCW_CTRL_REG);
                                 outl(0x0, iobase + ADDI_TCW_CTRL_REG);
-
-                                /* Send a signal to from kernel to user space */
-                                send_sig(SIGIO, devpriv->tsk_current, 0);
-
-                                /*  Enable Counter Interrupt */
                                 outl(ctrl, iobase + ADDI_TCW_CTRL_REG);
                         }
                 }
         }
 
+        if (s->state & APCI1564_EVENT_MASK) {
+                comedi_buf_write_samples(s, &s->state, 1);
+                comedi_handle_events(dev, s);
+        }
+
         return IRQ_HANDLED;
 }
 
@@ -255,7 +307,7 @@ static int apci1564_diag_insn_bits(struct comedi_device *dev,
 /*
  * Change-Of-State (COS) interrupt configuration
  *
- * Channels 0 to 15 are interruptible. These channels can be configured
+ * Channels 4 to 19 are interruptible. These channels can be configured
  * to generate interrupts based on AND/OR logic for the desired channels.
  *
  *      OR logic
@@ -343,6 +395,10 @@ static int apci1564_cos_insn_config(struct comedi_device *dev,
                 default:
                         return -EINVAL;
                 }
+
+                /* ensure the mode bits are in-range for channels [19:4] */
+                devpriv->mode1 &= APCI1564_DI_INT_MODE_MASK;
+                devpriv->mode2 &= APCI1564_DI_INT_MODE_MASK;
                 break;
         default:
                 return -EINVAL;
@@ -409,7 +465,7 @@ static int apci1564_cos_cmd(struct comedi_device *dev,
 {
         struct apci1564_private *devpriv = dev->private;
 
-        if (!devpriv->ctrl) {
+        if (!devpriv->ctrl && !(devpriv->mode1 || devpriv->mode2)) {
                 dev_warn(dev->class_dev,
                          "Interrupts disabled due to mode configuration!\n");
                 return -EINVAL;
@@ -433,6 +489,173 @@ static int apci1564_cos_cancel(struct comedi_device *dev,
         return 0;
 }
 
+static int apci1564_timer_insn_config(struct comedi_device *dev,
+                                      struct comedi_subdevice *s,
+                                      struct comedi_insn *insn,
+                                      unsigned int *data)
+{
+        struct apci1564_private *devpriv = dev->private;
+        unsigned int val;
+
+        switch (data[0]) {
+        case INSN_CONFIG_ARM:
+                if (data[1] > s->maxdata)
+                        return -EINVAL;
+                outl(data[1], devpriv->timer + ADDI_TCW_RELOAD_REG);
+                outl(ADDI_TCW_CTRL_IRQ_ENA | ADDI_TCW_CTRL_TIMER_ENA,
+                     devpriv->timer + ADDI_TCW_CTRL_REG);
+                break;
+        case INSN_CONFIG_DISARM:
+                outl(0x0, devpriv->timer + ADDI_TCW_CTRL_REG);
+                break;
+        case INSN_CONFIG_GET_COUNTER_STATUS:
+                data[1] = 0;
+                val = inl(devpriv->timer + ADDI_TCW_CTRL_REG);
+                if (val & ADDI_TCW_CTRL_IRQ_ENA)
+                        data[1] |= COMEDI_COUNTER_ARMED;
+                if (val & ADDI_TCW_CTRL_TIMER_ENA)
+                        data[1] |= COMEDI_COUNTER_COUNTING;
+                val = inl(devpriv->timer + ADDI_TCW_STATUS_REG);
+                if (val & ADDI_TCW_STATUS_OVERFLOW)
+                        data[1] |= COMEDI_COUNTER_TERMINAL_COUNT;
+                data[2] = COMEDI_COUNTER_ARMED | COMEDI_COUNTER_COUNTING |
+                          COMEDI_COUNTER_TERMINAL_COUNT;
+                break;
+        case INSN_CONFIG_SET_CLOCK_SRC:
+                if (data[2] > s->maxdata)
+                        return -EINVAL;
+                outl(data[1], devpriv->timer + ADDI_TCW_TIMEBASE_REG);
+                outl(data[2], devpriv->timer + ADDI_TCW_RELOAD_REG);
+                break;
+        case INSN_CONFIG_GET_CLOCK_SRC:
+                data[1] = inl(devpriv->timer + ADDI_TCW_TIMEBASE_REG);
+                data[2] = inl(devpriv->timer + ADDI_TCW_RELOAD_REG);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return insn->n;
+}
+
+static int apci1564_timer_insn_write(struct comedi_device *dev,
+                                     struct comedi_subdevice *s,
+                                     struct comedi_insn *insn,
+                                     unsigned int *data)
+{
+        struct apci1564_private *devpriv = dev->private;
+
+        /* just write the last last to the reload register */
+        if (insn->n) {
+                unsigned int val = data[insn->n - 1];
+
+                outl(val, devpriv->timer + ADDI_TCW_RELOAD_REG);
+        }
+
+        return insn->n;
+}
+
+static int apci1564_timer_insn_read(struct comedi_device *dev,
+                                    struct comedi_subdevice *s,
+                                    struct comedi_insn *insn,
+                                    unsigned int *data)
+{
+        struct apci1564_private *devpriv = dev->private;
+        int i;
+
+        /* return the actual value of the timer */
+        for (i = 0; i < insn->n; i++)
+                data[i] = inl(devpriv->timer + ADDI_TCW_VAL_REG);
+
+        return insn->n;
+}
+
+static int apci1564_counter_insn_config(struct comedi_device *dev,
+                                        struct comedi_subdevice *s,
+                                        struct comedi_insn *insn,
+                                        unsigned int *data)
+{
+        struct apci1564_private *devpriv = dev->private;
+        unsigned int chan = CR_CHAN(insn->chanspec);
+        unsigned long iobase = devpriv->counters + APCI1564_COUNTER(chan);
+        unsigned int val;
+
+        switch (data[0]) {
+        case INSN_CONFIG_ARM:
+                val = inl(iobase + ADDI_TCW_CTRL_REG);
+                val |= ADDI_TCW_CTRL_IRQ_ENA | ADDI_TCW_CTRL_CNTR_ENA;
+                outl(data[1], iobase + ADDI_TCW_RELOAD_REG);
+                outl(val, iobase + ADDI_TCW_CTRL_REG);
+                break;
+        case INSN_CONFIG_DISARM:
+                val = inl(iobase + ADDI_TCW_CTRL_REG);
+                val &= ~(ADDI_TCW_CTRL_IRQ_ENA | ADDI_TCW_CTRL_CNTR_ENA);
+                outl(val, iobase + ADDI_TCW_CTRL_REG);
+                break;
+        case INSN_CONFIG_SET_COUNTER_MODE:
+                /*
+                 * FIXME: The counter operation is not described in the
+                 * datasheet. For now just write the raw data[1] value to
+                 * the control register.
+                 */
+                outl(data[1], iobase + ADDI_TCW_CTRL_REG);
+                break;
+        case INSN_CONFIG_GET_COUNTER_STATUS:
+                data[1] = 0;
+                val = inl(iobase + ADDI_TCW_CTRL_REG);
+                if (val & ADDI_TCW_CTRL_IRQ_ENA)
+                        data[1] |= COMEDI_COUNTER_ARMED;
+                if (val & ADDI_TCW_CTRL_CNTR_ENA)
+                        data[1] |= COMEDI_COUNTER_COUNTING;
+                val = inl(iobase + ADDI_TCW_STATUS_REG);
+                if (val & ADDI_TCW_STATUS_OVERFLOW)
+                        data[1] |= COMEDI_COUNTER_TERMINAL_COUNT;
+                data[2] = COMEDI_COUNTER_ARMED | COMEDI_COUNTER_COUNTING |
+                          COMEDI_COUNTER_TERMINAL_COUNT;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return insn->n;
+}
+
+static int apci1564_counter_insn_write(struct comedi_device *dev,
+                                       struct comedi_subdevice *s,
+                                       struct comedi_insn *insn,
+                                       unsigned int *data)
+{
+        struct apci1564_private *devpriv = dev->private;
+        unsigned int chan = CR_CHAN(insn->chanspec);
+        unsigned long iobase = devpriv->counters + APCI1564_COUNTER(chan);
+
+        /* just write the last last to the reload register */
+        if (insn->n) {
+                unsigned int val = data[insn->n - 1];
+
+                outl(val, iobase + ADDI_TCW_RELOAD_REG);
+        }
+
+        return insn->n;
+}
+
+static int apci1564_counter_insn_read(struct comedi_device *dev,
+                                      struct comedi_subdevice *s,
+                                      struct comedi_insn *insn,
+                                      unsigned int *data)
+{
+        struct apci1564_private *devpriv = dev->private;
+        unsigned int chan = CR_CHAN(insn->chanspec);
+        unsigned long iobase = devpriv->counters + APCI1564_COUNTER(chan);
+        int i;
+
+        /* return the actual value of the counter */
+        for (i = 0; i < insn->n; i++)
+                data[i] = inl(iobase + ADDI_TCW_VAL_REG);
+
+        return insn->n;
+}
+
 static int apci1564_auto_attach(struct comedi_device *dev,
                                 unsigned long context_unused)
 {
@@ -501,7 +724,7 @@ static int apci1564_auto_attach(struct comedi_device *dev,
         if (dev->irq) {
                 dev->read_subdev = s;
                 s->type         = COMEDI_SUBD_DI;
-                s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
+                s->subdev_flags = SDF_READABLE | SDF_CMD_READ | SDF_LSAMPL;
                 s->n_chan       = 1;
                 s->maxdata      = 1;
                 s->range_table  = &range_digital;
@@ -543,7 +766,7 @@ static int apci1564_auto_attach(struct comedi_device *dev,
 
         /* Initialize the watchdog subdevice */
         s = &dev->subdevices[5];
-        ret = addi_watchdog_init(s, dev->iobase + APCI1564_WDOG_REG);
+        ret = addi_watchdog_init(s, dev->iobase + APCI1564_WDOG_IOBASE);
         if (ret)
                 return ret;
 
diff --git a/drivers/staging/comedi/drivers/adl_pci9118.c b/drivers/staging/comedi/drivers/adl_pci9118.c
index 4437ea3abe8d..be70bd333807 100644
--- a/drivers/staging/comedi/drivers/adl_pci9118.c
+++ b/drivers/staging/comedi/drivers/adl_pci9118.c
@@ -570,7 +570,7 @@ static int pci9118_ai_cancel(struct comedi_device *dev,
         /* set default config (disable burst and triggers) */
         devpriv->ai_cfg = PCI9118_AI_CFG_PDTRG | PCI9118_AI_CFG_PETRG;
         outl(devpriv->ai_cfg, dev->iobase + PCI9118_AI_CFG_REG);
-        /* reset acqusition control */
+        /* reset acquisition control */
         devpriv->ai_ctrl = 0;
         outl(devpriv->ai_ctrl, dev->iobase + PCI9118_AI_CTRL_REG);
         outl(0, dev->iobase + PCI9118_AI_BURST_NUM_REG);
@@ -1022,12 +1022,12 @@ static int pci9118_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 
         /*
          * Configure analog input and load the chanlist.
-         * The acqusition control bits are enabled later.
+         * The acquisition control bits are enabled later.
          */
         pci9118_set_chanlist(dev, s, cmd->chanlist_len, cmd->chanlist,
                              devpriv->ai_add_front, devpriv->ai_add_back);
 
-        /* Determine acqusition mode and calculate timing */
+        /* Determine acquisition mode and calculate timing */
         devpriv->ai_do = 0;
         if (cmd->scan_begin_src != TRIG_TIMER &&
             cmd->convert_src == TRIG_TIMER) {
@@ -1097,7 +1097,7 @@ static int pci9118_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 
         if (devpriv->ai_do == 0) {
                 dev_err(dev->class_dev,
-                        "Unable to determine acqusition mode! BUG in (*do_cmdtest)?\n");
+                        "Unable to determine acquisition mode! BUG in (*do_cmdtest)?\n");
                 return -EINVAL;
         }
 
diff --git a/drivers/staging/comedi/drivers/cb_pcidas64.c b/drivers/staging/comedi/drivers/cb_pcidas64.c
index c773b8ca6599..1f9c08a845b6 100644
--- a/drivers/staging/comedi/drivers/cb_pcidas64.c
+++ b/drivers/staging/comedi/drivers/cb_pcidas64.c
@@ -1238,7 +1238,7 @@ static void disable_plx_interrupts(struct comedi_device *dev)
 
         devpriv->plx_intcsr_bits = 0;
         writel(devpriv->plx_intcsr_bits,
-               devpriv->plx9080_iobase + PLX_INTRCS_REG);
+               devpriv->plx9080_iobase + PLX_REG_INTCSR);
 }
 
 static void disable_ai_interrupts(struct comedi_device *dev)
@@ -1291,14 +1291,14 @@ static void init_plx9080(struct comedi_device *dev)
         void __iomem *plx_iobase = devpriv->plx9080_iobase;
 
         devpriv->plx_control_bits =
-                readl(devpriv->plx9080_iobase + PLX_CONTROL_REG);
+                readl(devpriv->plx9080_iobase + PLX_REG_CNTRL);
 
 #ifdef __BIG_ENDIAN
-        bits = BIGEND_DMA0 | BIGEND_DMA1;
+        bits = PLX_BIGEND_DMA0 | PLX_BIGEND_DMA1;
 #else
         bits = 0;
 #endif
-        writel(bits, devpriv->plx9080_iobase + PLX_BIGEND_REG);
+        writel(bits, devpriv->plx9080_iobase + PLX_REG_BIGEND);
 
         disable_plx_interrupts(dev);
 
@@ -1308,38 +1308,39 @@ static void init_plx9080(struct comedi_device *dev)
         /*  configure dma0 mode */
         bits = 0;
         /*  enable ready input, not sure if this is necessary */
-        bits |= PLX_DMA_EN_READYIN_BIT;
+        bits |= PLX_DMAMODE_READYIEN;
         /*  enable bterm, not sure if this is necessary */
-        bits |= PLX_EN_BTERM_BIT;
+        bits |= PLX_DMAMODE_BTERMIEN;
         /*  enable dma chaining */
-        bits |= PLX_EN_CHAIN_BIT;
+        bits |= PLX_DMAMODE_CHAINEN;
         /*  enable interrupt on dma done
          *  (probably don't need this, since chain never finishes) */
-        bits |= PLX_EN_DMA_DONE_INTR_BIT;
+        bits |= PLX_DMAMODE_DONEIEN;
         /*  don't increment local address during transfers
          *  (we are transferring from a fixed fifo register) */
-        bits |= PLX_LOCAL_ADDR_CONST_BIT;
+        bits |= PLX_DMAMODE_LACONST;
         /*  route dma interrupt to pci bus */
-        bits |= PLX_DMA_INTR_PCI_BIT;
+        bits |= PLX_DMAMODE_INTRPCI;
         /*  enable demand mode */
-        bits |= PLX_DEMAND_MODE_BIT;
+        bits |= PLX_DMAMODE_DEMAND;
         /*  enable local burst mode */
-        bits |= PLX_DMA_LOCAL_BURST_EN_BIT;
+        bits |= PLX_DMAMODE_BURSTEN;
         /*  4020 uses 32 bit dma */
         if (board->layout == LAYOUT_4020)
-                bits |= PLX_LOCAL_BUS_32_WIDE_BITS;
+                bits |= PLX_DMAMODE_WIDTH32;
         else            /*  localspace0 bus is 16 bits wide */
-                bits |= PLX_LOCAL_BUS_16_WIDE_BITS;
-        writel(bits, plx_iobase + PLX_DMA1_MODE_REG);
+                bits |= PLX_DMAMODE_WIDTH16;
+        writel(bits, plx_iobase + PLX_REG_DMAMODE1);
         if (ao_cmd_is_supported(board))
-                writel(bits, plx_iobase + PLX_DMA0_MODE_REG);
+                writel(bits, plx_iobase + PLX_REG_DMAMODE0);
 
         /*  enable interrupts on plx 9080 */
         devpriv->plx_intcsr_bits |=
-            ICS_AERR | ICS_PERR | ICS_PIE | ICS_PLIE | ICS_PAIE | ICS_LIE |
-            ICS_DMA0_E | ICS_DMA1_E;
+            PLX_INTCSR_LSEABORTEN | PLX_INTCSR_LSEPARITYEN | PLX_INTCSR_PIEN |
+            PLX_INTCSR_PLIEN | PLX_INTCSR_PABORTIEN | PLX_INTCSR_LIOEN |
+            PLX_INTCSR_DMA0IEN | PLX_INTCSR_DMA1IEN;
         writel(devpriv->plx_intcsr_bits,
-               devpriv->plx9080_iobase + PLX_INTRCS_REG);
+               devpriv->plx9080_iobase + PLX_REG_INTCSR);
 }
 
 static void disable_ai_pacing(struct comedi_device *dev)
@@ -1533,8 +1534,8 @@ static int alloc_and_init_dma_members(struct comedi_device *dev)
                         cpu_to_le32((devpriv->ai_dma_desc_bus_addr +
                                      ((i + 1) % ai_dma_ring_count(board)) *
                                      sizeof(devpriv->ai_dma_desc[0])) |
-                                    PLX_DESC_IN_PCI_BIT | PLX_INTR_TERM_COUNT |
-                                    PLX_XFER_LOCAL_TO_PCI);
+                                    PLX_DMADPR_DESCPCI | PLX_DMADPR_TCINTR |
+                                    PLX_DMADPR_XFERL2P);
         }
         if (ao_cmd_is_supported(board)) {
                 for (i = 0; i < AO_DMA_RING_COUNT; i++) {
@@ -1548,8 +1549,8 @@ static int alloc_and_init_dma_members(struct comedi_device *dev)
                                 cpu_to_le32((devpriv->ao_dma_desc_bus_addr +
                                              ((i + 1) % (AO_DMA_RING_COUNT)) *
                                              sizeof(devpriv->ao_dma_desc[0])) |
-                                            PLX_DESC_IN_PCI_BIT |
-                                            PLX_INTR_TERM_COUNT);
+                                            PLX_DMADPR_DESCPCI |
+                                            PLX_DMADPR_TCINTR);
                 }
         }
         return 0;
@@ -1613,9 +1614,9 @@ static const int i2c_low_udelay = 10;
 static void i2c_set_sda(struct comedi_device *dev, int state)
 {
         struct pcidas64_private *devpriv = dev->private;
-        static const int data_bit = CTL_EE_W;
+        static const int data_bit = PLX_CNTRL_EEWB;
         void __iomem *plx_control_addr = devpriv->plx9080_iobase +
-                                         PLX_CONTROL_REG;
+                                         PLX_REG_CNTRL;
 
         if (state) {
                 /*  set data line high */
@@ -1634,9 +1635,9 @@ static void i2c_set_sda(struct comedi_device *dev, int state)
 static void i2c_set_scl(struct comedi_device *dev, int state)
 {
         struct pcidas64_private *devpriv = dev->private;
-        static const int clock_bit = CTL_USERO;
+        static const int clock_bit = PLX_CNTRL_USERO;
         void __iomem *plx_control_addr = devpriv->plx9080_iobase +
-                                         PLX_CONTROL_REG;
+                                         PLX_REG_CNTRL;
 
         if (state) {
                 /*  set clock line high */
@@ -1707,7 +1708,7 @@ static void i2c_write(struct comedi_device *dev, unsigned int address,
          */
 
         /*  make sure we dont send anything to eeprom */
-        devpriv->plx_control_bits &= ~CTL_EE_CS;
+        devpriv->plx_control_bits &= ~PLX_CNTRL_EECS;
 
         i2c_stop(dev);
         i2c_start(dev);
@@ -2367,14 +2368,8 @@ static inline void dma_start_sync(struct comedi_device *dev,
 
         /*  spinlock for plx dma control/status reg */
         spin_lock_irqsave(&dev->spinlock, flags);
-        if (channel)
-                writeb(PLX_DMA_EN_BIT | PLX_DMA_START_BIT |
-                       PLX_CLEAR_DMA_INTR_BIT,
-                       devpriv->plx9080_iobase + PLX_DMA1_CS_REG);
-        else
-                writeb(PLX_DMA_EN_BIT | PLX_DMA_START_BIT |
-                       PLX_CLEAR_DMA_INTR_BIT,
-                       devpriv->plx9080_iobase + PLX_DMA0_CS_REG);
+        writeb(PLX_DMACSR_ENABLE | PLX_DMACSR_START | PLX_DMACSR_CLEARINTR,
+               devpriv->plx9080_iobase + PLX_REG_DMACSR(channel));
         spin_unlock_irqrestore(&dev->spinlock, flags);
 }
 
@@ -2552,21 +2547,17 @@ static inline void load_first_dma_descriptor(struct comedi_device *dev,
          * block.  Initializing them to zero seems to fix the problem.
          */
         if (dma_channel) {
-                writel(0,
-                       devpriv->plx9080_iobase + PLX_DMA1_TRANSFER_SIZE_REG);
-                writel(0, devpriv->plx9080_iobase + PLX_DMA1_PCI_ADDRESS_REG);
-                writel(0,
-                       devpriv->plx9080_iobase + PLX_DMA1_LOCAL_ADDRESS_REG);
+                writel(0, devpriv->plx9080_iobase + PLX_REG_DMASIZ1);
+                writel(0, devpriv->plx9080_iobase + PLX_REG_DMAPADR1);
+                writel(0, devpriv->plx9080_iobase + PLX_REG_DMALADR1);
                 writel(descriptor_bits,
-                       devpriv->plx9080_iobase + PLX_DMA1_DESCRIPTOR_REG);
+                       devpriv->plx9080_iobase + PLX_REG_DMADPR1);
         } else {
-                writel(0,
-                       devpriv->plx9080_iobase + PLX_DMA0_TRANSFER_SIZE_REG);
-                writel(0, devpriv->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG);
-                writel(0,
-                       devpriv->plx9080_iobase + PLX_DMA0_LOCAL_ADDRESS_REG);
+                writel(0, devpriv->plx9080_iobase + PLX_REG_DMASIZ0);
+                writel(0, devpriv->plx9080_iobase + PLX_REG_DMAPADR0);
+                writel(0, devpriv->plx9080_iobase + PLX_REG_DMALADR0);
                 writel(descriptor_bits,
-                       devpriv->plx9080_iobase + PLX_DMA0_DESCRIPTOR_REG);
+                       devpriv->plx9080_iobase + PLX_REG_DMADPR0);
         }
 }
 
@@ -2643,9 +2634,9 @@ static int ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
                 /*  give location of first dma descriptor */
                 load_first_dma_descriptor(dev, 1,
                                           devpriv->ai_dma_desc_bus_addr |
-                                          PLX_DESC_IN_PCI_BIT |
-                                          PLX_INTR_TERM_COUNT |
-                                          PLX_XFER_LOCAL_TO_PCI);
+                                          PLX_DMADPR_DESCPCI |
+                                          PLX_DMADPR_TCINTR |
+                                          PLX_DMADPR_XFERL2P);
 
                 dma_start_sync(dev, 1);
         }
@@ -2803,12 +2794,7 @@ static void drain_dma_buffers(struct comedi_device *dev, unsigned int channel)
         int num_samples = 0;
         void __iomem *pci_addr_reg;
 
-        if (channel)
-                pci_addr_reg =
-                    devpriv->plx9080_iobase + PLX_DMA1_PCI_ADDRESS_REG;
-        else
-                pci_addr_reg =
-                    devpriv->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG;
+        pci_addr_reg = devpriv->plx9080_iobase + PLX_REG_DMAPADR(channel);
 
         /*  loop until we have read all the full buffers */
         for (j = 0, next_transfer_addr = readl(pci_addr_reg);
@@ -2850,12 +2836,12 @@ static void handle_ai_interrupt(struct comedi_device *dev,
         }
         /*  spin lock makes sure no one else changes plx dma control reg */
         spin_lock_irqsave(&dev->spinlock, flags);
-        dma1_status = readb(devpriv->plx9080_iobase + PLX_DMA1_CS_REG);
-        if (plx_status & ICS_DMA1_A) {  /*  dma chan 1 interrupt */
-                writeb((dma1_status & PLX_DMA_EN_BIT) | PLX_CLEAR_DMA_INTR_BIT,
-                       devpriv->plx9080_iobase + PLX_DMA1_CS_REG);
+        dma1_status = readb(devpriv->plx9080_iobase + PLX_REG_DMACSR1);
+        if (plx_status & PLX_INTCSR_DMA1IA) {   /*  dma chan 1 interrupt */
+                writeb((dma1_status & PLX_DMACSR_ENABLE) | PLX_DMACSR_CLEARINTR,
+                       devpriv->plx9080_iobase + PLX_REG_DMACSR1);
 
-                if (dma1_status & PLX_DMA_EN_BIT)
+                if (dma1_status & PLX_DMACSR_ENABLE)
                         drain_dma_buffers(dev, 1);
         }
         spin_unlock_irqrestore(&dev->spinlock, flags);
@@ -2902,12 +2888,12 @@ static int last_ao_dma_load_completed(struct comedi_device *dev)
         unsigned short dma_status;
 
         buffer_index = prev_ao_dma_index(dev);
-        dma_status = readb(devpriv->plx9080_iobase + PLX_DMA0_CS_REG);
-        if ((dma_status & PLX_DMA_DONE_BIT) == 0)
+        dma_status = readb(devpriv->plx9080_iobase + PLX_REG_DMACSR0);
+        if ((dma_status & PLX_DMACSR_DONE) == 0)
                 return 0;
 
         transfer_address =
-                readl(devpriv->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG);
+                readl(devpriv->plx9080_iobase + PLX_REG_DMAPADR0);
         if (transfer_address != devpriv->ao_buffer_bus_addr[buffer_index])
                 return 0;
 
@@ -2917,8 +2903,8 @@ static int last_ao_dma_load_completed(struct comedi_device *dev)
 static inline int ao_dma_needs_restart(struct comedi_device *dev,
                                        unsigned short dma_status)
 {
-        if ((dma_status & PLX_DMA_DONE_BIT) == 0 ||
-            (dma_status & PLX_DMA_EN_BIT) == 0)
+        if ((dma_status & PLX_DMACSR_DONE) == 0 ||
+            (dma_status & PLX_DMACSR_ENABLE) == 0)
                 return 0;
         if (last_ao_dma_load_completed(dev))
                 return 0;
@@ -2931,9 +2917,8 @@ static void restart_ao_dma(struct comedi_device *dev)
         struct pcidas64_private *devpriv = dev->private;
         unsigned int dma_desc_bits;
 
-        dma_desc_bits =
-                readl(devpriv->plx9080_iobase + PLX_DMA0_DESCRIPTOR_REG);
-        dma_desc_bits &= ~PLX_END_OF_CHAIN_BIT;
+        dma_desc_bits = readl(devpriv->plx9080_iobase + PLX_REG_DMADPR0);
+        dma_desc_bits &= ~PLX_DMADPR_CHAINEND;
         load_first_dma_descriptor(dev, 0, dma_desc_bits);
 
         dma_start_sync(dev, 0);
@@ -2974,14 +2959,14 @@ static unsigned int load_ao_dma_buffer(struct comedi_device *dev,
         devpriv->ao_dma_desc[buffer_index].transfer_size = cpu_to_le32(nbytes);
         /* set end of chain bit so we catch underruns */
         next_bits = le32_to_cpu(devpriv->ao_dma_desc[buffer_index].next);
-        next_bits |= PLX_END_OF_CHAIN_BIT;
+        next_bits |= PLX_DMADPR_CHAINEND;
         devpriv->ao_dma_desc[buffer_index].next = cpu_to_le32(next_bits);
         /*
          * clear end of chain bit on previous buffer now that we have set it
          * for the last buffer
          */
         next_bits = le32_to_cpu(devpriv->ao_dma_desc[prev_buffer_index].next);
-        next_bits &= ~PLX_END_OF_CHAIN_BIT;
+        next_bits &= ~PLX_DMADPR_CHAINEND;
         devpriv->ao_dma_desc[prev_buffer_index].next = cpu_to_le32(next_bits);
 
         devpriv->ao_dma_index = (buffer_index + 1) % AO_DMA_RING_COUNT;
@@ -2994,8 +2979,7 @@ static void load_ao_dma(struct comedi_device *dev, const struct comedi_cmd *cmd)
         struct pcidas64_private *devpriv = dev->private;
         unsigned int num_bytes;
         unsigned int next_transfer_addr;
-        void __iomem *pci_addr_reg =
-                devpriv->plx9080_iobase + PLX_DMA0_PCI_ADDRESS_REG;
+        void __iomem *pci_addr_reg = devpriv->plx9080_iobase + PLX_REG_DMAPADR0;
         unsigned int buffer_index;
 
         do {
@@ -3030,17 +3014,18 @@ static void handle_ao_interrupt(struct comedi_device *dev,
 
         /*  spin lock makes sure no one else changes plx dma control reg */
         spin_lock_irqsave(&dev->spinlock, flags);
-        dma0_status = readb(devpriv->plx9080_iobase + PLX_DMA0_CS_REG);
-        if (plx_status & ICS_DMA0_A) {  /*  dma chan 0 interrupt */
-                if ((dma0_status & PLX_DMA_EN_BIT) &&
-                    !(dma0_status & PLX_DMA_DONE_BIT))
-                        writeb(PLX_DMA_EN_BIT | PLX_CLEAR_DMA_INTR_BIT,
-                               devpriv->plx9080_iobase + PLX_DMA0_CS_REG);
-                else
-                        writeb(PLX_CLEAR_DMA_INTR_BIT,
-                               devpriv->plx9080_iobase + PLX_DMA0_CS_REG);
+        dma0_status = readb(devpriv->plx9080_iobase + PLX_REG_DMACSR0);
+        if (plx_status & PLX_INTCSR_DMA0IA) {   /*  dma chan 0 interrupt */
+                if ((dma0_status & PLX_DMACSR_ENABLE) &&
+                    !(dma0_status & PLX_DMACSR_DONE)) {
+                        writeb(PLX_DMACSR_ENABLE | PLX_DMACSR_CLEARINTR,
+                               devpriv->plx9080_iobase + PLX_REG_DMACSR0);
+                } else {
+                        writeb(PLX_DMACSR_CLEARINTR,
+                               devpriv->plx9080_iobase + PLX_REG_DMACSR0);
+                }
                 spin_unlock_irqrestore(&dev->spinlock, flags);
-                if (dma0_status & PLX_DMA_EN_BIT) {
+                if (dma0_status & PLX_DMACSR_ENABLE) {
                         load_ao_dma(dev, cmd);
                         /* try to recover from dma end-of-chain event */
                         if (ao_dma_needs_restart(dev, dma0_status))
@@ -3069,7 +3054,7 @@ static irqreturn_t handle_interrupt(int irq, void *d)
         uint32_t plx_status;
         uint32_t plx_bits;
 
-        plx_status = readl(devpriv->plx9080_iobase + PLX_INTRCS_REG);
+        plx_status = readl(devpriv->plx9080_iobase + PLX_REG_INTCSR);
         status = readw(devpriv->main_iobase + HW_STATUS_REG);
 
         /*
@@ -3083,10 +3068,11 @@ static irqreturn_t handle_interrupt(int irq, void *d)
         handle_ai_interrupt(dev, status, plx_status);
         handle_ao_interrupt(dev, status, plx_status);
 
-        /*  clear possible plx9080 interrupt sources */
-        if (plx_status & ICS_LDIA) {    /*  clear local doorbell interrupt */
-                plx_bits = readl(devpriv->plx9080_iobase + PLX_DBR_OUT_REG);
-                writel(plx_bits, devpriv->plx9080_iobase + PLX_DBR_OUT_REG);
+        /* clear possible plx9080 interrupt sources */
+        if (plx_status & PLX_INTCSR_LDBIA) {
+                /* clear local doorbell interrupt */
+                plx_bits = readl(devpriv->plx9080_iobase + PLX_REG_L2PDBELL);
+                writel(plx_bits, devpriv->plx9080_iobase + PLX_REG_L2PDBELL);
         }
 
         return IRQ_HANDLED;
@@ -3324,7 +3310,7 @@ static int ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
         set_dac_select_reg(dev, cmd);
         set_dac_interval_regs(dev, cmd);
         load_first_dma_descriptor(dev, 0, devpriv->ao_dma_desc_bus_addr |
-                                  PLX_DESC_IN_PCI_BIT | PLX_INTR_TERM_COUNT);
+                                  PLX_DMADPR_DESCPCI | PLX_DMADPR_TCINTR);
 
         set_dac_control1_reg(dev, cmd);
         s->async->inttrig = ao_inttrig;
@@ -3725,19 +3711,19 @@ static uint16_t read_eeprom(struct comedi_device *dev, uint8_t address)
         unsigned int bitstream = (read_command << 8) | address;
         unsigned int bit;
         void __iomem * const plx_control_addr =
-                devpriv->plx9080_iobase + PLX_CONTROL_REG;
+                devpriv->plx9080_iobase + PLX_REG_CNTRL;
         uint16_t value;
         static const int value_length = 16;
         static const int eeprom_udelay = 1;
 
         udelay(eeprom_udelay);
-        devpriv->plx_control_bits &= ~CTL_EE_CLK & ~CTL_EE_CS;
+        devpriv->plx_control_bits &= ~PLX_CNTRL_EESK & ~PLX_CNTRL_EECS;
         /*  make sure we don't send anything to the i2c bus on 4020 */
-        devpriv->plx_control_bits |= CTL_USERO;
+        devpriv->plx_control_bits |= PLX_CNTRL_USERO;
         writel(devpriv->plx_control_bits, plx_control_addr);
         /*  activate serial eeprom */
         udelay(eeprom_udelay);
-        devpriv->plx_control_bits |= CTL_EE_CS;
+        devpriv->plx_control_bits |= PLX_CNTRL_EECS;
         writel(devpriv->plx_control_bits, plx_control_addr);
 
         /*  write read command and desired memory address */
@@ -3745,16 +3731,16 @@ static uint16_t read_eeprom(struct comedi_device *dev, uint8_t address)
                 /*  set bit to be written */
                 udelay(eeprom_udelay);
                 if (bitstream & bit)
-                        devpriv->plx_control_bits |= CTL_EE_W;
+                        devpriv->plx_control_bits |= PLX_CNTRL_EEWB;
                 else
-                        devpriv->plx_control_bits &= ~CTL_EE_W;
+                        devpriv->plx_control_bits &= ~PLX_CNTRL_EEWB;
                 writel(devpriv->plx_control_bits, plx_control_addr);
                 /*  clock in bit */
                 udelay(eeprom_udelay);
-                devpriv->plx_control_bits |= CTL_EE_CLK;
+                devpriv->plx_control_bits |= PLX_CNTRL_EESK;
                 writel(devpriv->plx_control_bits, plx_control_addr);
                 udelay(eeprom_udelay);
-                devpriv->plx_control_bits &= ~CTL_EE_CLK;
+                devpriv->plx_control_bits &= ~PLX_CNTRL_EESK;
                 writel(devpriv->plx_control_bits, plx_control_addr);
         }
         /*  read back value from eeprom memory location */
@@ -3762,19 +3748,19 @@ static uint16_t read_eeprom(struct comedi_device *dev, uint8_t address)
         for (bit = 1 << (value_length - 1); bit; bit >>= 1) {
                 /*  clock out bit */
                 udelay(eeprom_udelay);
-                devpriv->plx_control_bits |= CTL_EE_CLK;
+                devpriv->plx_control_bits |= PLX_CNTRL_EESK;
                 writel(devpriv->plx_control_bits, plx_control_addr);
                 udelay(eeprom_udelay);
-                devpriv->plx_control_bits &= ~CTL_EE_CLK;
+                devpriv->plx_control_bits &= ~PLX_CNTRL_EESK;
                 writel(devpriv->plx_control_bits, plx_control_addr);
                 udelay(eeprom_udelay);
-                if (readl(plx_control_addr) & CTL_EE_R)
+                if (readl(plx_control_addr) & PLX_CNTRL_EERB)
                         value |= bit;
         }
 
         /*  deactivate eeprom serial input */
         udelay(eeprom_udelay);
-        devpriv->plx_control_bits &= ~CTL_EE_CS;
+        devpriv->plx_control_bits &= ~PLX_CNTRL_EECS;
         writel(devpriv->plx_control_bits, plx_control_addr);
 
         return value;
@@ -3962,7 +3948,8 @@ static int setup_subdevices(struct comedi_device *dev)
 
         /* serial EEPROM, if present */
         s = &dev->subdevices[8];
-        if (readl(devpriv->plx9080_iobase + PLX_CONTROL_REG) & CTL_EECHK) {
+        if (readl(devpriv->plx9080_iobase + PLX_REG_CNTRL) &
+            PLX_CNTRL_EEPRESENT) {
                 s->type = COMEDI_SUBD_MEMORY;
                 s->subdev_flags = SDF_READABLE | SDF_INTERNAL;
                 s->n_chan = 128;
@@ -4019,16 +4006,16 @@ static int auto_attach(struct comedi_device *dev,
         }
 
         /*  figure out what local addresses are */
-        local_range = readl(devpriv->plx9080_iobase + PLX_LAS0RNG_REG) &
-                      LRNG_MEM_MASK;
-        local_decode = readl(devpriv->plx9080_iobase + PLX_LAS0MAP_REG) &
-                       local_range & LMAP_MEM_MASK;
+        local_range = readl(devpriv->plx9080_iobase + PLX_REG_LAS0RR) &
+                      PLX_LASRR_MEM_MASK;
+        local_decode = readl(devpriv->plx9080_iobase + PLX_REG_LAS0BA) &
+                       local_range & PLX_LASBA_MEM_MASK;
         devpriv->local0_iobase = ((uint32_t)devpriv->main_phys_iobase &
                                   ~local_range) | local_decode;
-        local_range = readl(devpriv->plx9080_iobase + PLX_LAS1RNG_REG) &
-                      LRNG_MEM_MASK;
-        local_decode = readl(devpriv->plx9080_iobase + PLX_LAS1MAP_REG) &
-                       local_range & LMAP_MEM_MASK;
+        local_range = readl(devpriv->plx9080_iobase + PLX_REG_LAS1RR) &
+                      PLX_LASRR_MEM_MASK;
+        local_decode = readl(devpriv->plx9080_iobase + PLX_REG_LAS1BA) &
+                       local_range & PLX_LASBA_MEM_MASK;
         devpriv->local1_iobase = ((uint32_t)devpriv->dio_counter_phys_iobase &
                                   ~local_range) | local_decode;
 
diff --git a/drivers/staging/comedi/drivers/comedi_bond.c b/drivers/staging/comedi/drivers/comedi_bond.c
index 50b76eccb7d7..64a5ea3810d4 100644
--- a/drivers/staging/comedi/drivers/comedi_bond.c
+++ b/drivers/staging/comedi/drivers/comedi_bond.c
@@ -55,16 +55,16 @@
 
 struct bonded_device {
         struct comedi_device *dev;
-        unsigned minor;
-        unsigned subdev;
-        unsigned nchans;
+        unsigned int minor;
+        unsigned int subdev;
+        unsigned int nchans;
 };
 
 struct comedi_bond_private {
         char name[256];
         struct bonded_device **devs;
-        unsigned ndevs;
-        unsigned nchans;
+        unsigned int ndevs;
+        unsigned int nchans;
 };
 
 static int bonding_dio_insn_bits(struct comedi_device *dev,
diff --git a/drivers/staging/comedi/drivers/daqboard2000.c b/drivers/staging/comedi/drivers/daqboard2000.c
index a536a15c1d30..65daef0c00d5 100644
--- a/drivers/staging/comedi/drivers/daqboard2000.c
+++ b/drivers/staging/comedi/drivers/daqboard2000.c
@@ -116,12 +116,12 @@
 #define DAQBOARD2000_SUBSYSTEM_IDS4     0x0004  /* Daqboard/2000 - 4 Dacs */
 
 /* Initialization bits for the Serial EEPROM Control Register */
-#define DAQBOARD2000_SECRProgPinHi      0x8001767e
-#define DAQBOARD2000_SECRProgPinLo      0x8000767e
-#define DAQBOARD2000_SECRLocalBusHi     0xc000767e
-#define DAQBOARD2000_SECRLocalBusLo     0x8000767e
-#define DAQBOARD2000_SECRReloadHi       0xa000767e
-#define DAQBOARD2000_SECRReloadLo       0x8000767e
+#define DB2K_SECR_PROG_PIN_HI           0x8001767e
+#define DB2K_SECR_PROG_PIN_LO           0x8000767e
+#define DB2K_SECR_LOCAL_BUS_HI          0xc000767e
+#define DB2K_SECR_LOCAL_BUS_LO          0x8000767e
+#define DB2K_SECR_RELOAD_HI             0xa000767e
+#define DB2K_SECR_RELOAD_LO             0x8000767e
 
 /* SECR status bits */
 #define DAQBOARD2000_EEPROM_PRESENT     0x10000000
@@ -151,119 +151,108 @@ static const struct comedi_lrange range_daqboard2000_ai = {
 /*
  * Register Memory Map
  */
-#define acqControl                      0x00            /* u16 */
-#define acqScanListFIFO                 0x02            /* u16 */
-#define acqPacerClockDivLow             0x04            /* u32 */
-#define acqScanCounter                  0x08            /* u16 */
-#define acqPacerClockDivHigh            0x0a            /* u16 */
-#define acqTriggerCount                 0x0c            /* u16 */
-#define acqResultsFIFO                  0x10            /* u16 */
-#define acqResultsShadow                0x14            /* u16 */
-#define acqAdcResult                    0x18            /* u16 */
-#define dacScanCounter                  0x1c            /* u16 */
-#define dacControl                      0x20            /* u16 */
-#define dacFIFO                         0x24            /* s16 */
-#define dacPacerClockDiv                0x2a            /* u16 */
-#define refDacs                         0x2c            /* u16 */
-#define dioControl                      0x30            /* u16 */
-#define dioP3hsioData                   0x32            /* s16 */
-#define dioP3Control                    0x34            /* u16 */
-#define calEepromControl                0x36            /* u16 */
-#define dacSetting(x)                   (0x38 + (x)*2)  /* s16 */
-#define dioP2ExpansionIO8Bit            0x40            /* s16 */
-#define ctrTmrControl                   0x80            /* u16 */
-#define ctrInput(x)                     (0x88 + (x)*2)  /* s16 */
-#define timerDivisor(x)                 (0xa0 + (x)*2)  /* u16 */
-#define dmaControl                      0xb0            /* u16 */
-#define trigControl                     0xb2            /* u16 */
-#define calEeprom                       0xb8            /* u16 */
-#define acqDigitalMark                  0xba            /* u16 */
-#define trigDacs                        0xbc            /* u16 */
-#define dioP2ExpansionIO16Bit(x)        (0xc0 + (x)*2)  /* s16 */
+#define DB2K_REG_ACQ_CONTROL                    0x00            /* u16 (w) */
+#define DB2K_REG_ACQ_STATUS                     0x00            /* u16 (r) */
+#define DB2K_REG_ACQ_SCAN_LIST_FIFO             0x02            /* u16 */
+#define DB2K_REG_ACQ_PACER_CLOCK_DIV_LOW        0x04            /* u32 */
+#define DB2K_REG_ACQ_SCAN_COUNTER               0x08            /* u16 */
+#define DB2K_REG_ACQ_PACER_CLOCK_DIV_HIGH       0x0a            /* u16 */
+#define DB2K_REG_ACQ_TRIGGER_COUNT              0x0c            /* u16 */
+#define DB2K_REG_ACQ_RESULTS_FIFO               0x10            /* u16 */
+#define DB2K_REG_ACQ_RESULTS_SHADOW             0x14            /* u16 */
+#define DB2K_REG_ACQ_ADC_RESULT                 0x18            /* u16 */
+#define DB2K_REG_DAC_SCAN_COUNTER               0x1c            /* u16 */
+#define DB2K_REG_DAC_CONTROL                    0x20            /* u16 (w) */
+#define DB2K_REG_DAC_STATUS                     0x20            /* u16 (r) */
+#define DB2K_REG_DAC_FIFO                       0x24            /* s16 */
+#define DB2K_REG_DAC_PACER_CLOCK_DIV            0x2a            /* u16 */
+#define DB2K_REG_REF_DACS                       0x2c            /* u16 */
+#define DB2K_REG_DIO_CONTROL                    0x30            /* u16 */
+#define DB2K_REG_P3_HSIO_DATA                   0x32            /* s16 */
+#define DB2K_REG_P3_CONTROL                     0x34            /* u16 */
+#define DB2K_REG_CAL_EEPROM_CONTROL             0x36            /* u16 */
+#define DB2K_REG_DAC_SETTING(x)                 (0x38 + (x) * 2) /* s16 */
+#define DB2K_REG_DIO_P2_EXP_IO_8_BIT            0x40            /* s16 */
+#define DB2K_REG_COUNTER_TIMER_CONTROL          0x80            /* u16 */
+#define DB2K_REG_COUNTER_INPUT(x)               (0x88 + (x) * 2) /* s16 */
+#define DB2K_REG_TIMER_DIV(x)                   (0xa0 + (x) * 2) /* u16 */
+#define DB2K_REG_DMA_CONTROL                    0xb0            /* u16 */
+#define DB2K_REG_TRIG_CONTROL                   0xb2            /* u16 */
+#define DB2K_REG_CAL_EEPROM                     0xb8            /* u16 */
+#define DB2K_REG_ACQ_DIGITAL_MARK               0xba            /* u16 */
+#define DB2K_REG_TRIG_DACS                      0xbc            /* u16 */
+#define DB2K_REG_DIO_P2_EXP_IO_16_BIT(x)        (0xc0 + (x) * 2) /* s16 */
 
 /* Scan Sequencer programming */
-#define DAQBOARD2000_SeqStartScanList            0x0011
-#define DAQBOARD2000_SeqStopScanList             0x0010
+#define DB2K_ACQ_CONTROL_SEQ_START_SCAN_LIST            0x0011
+#define DB2K_ACQ_CONTROL_SEQ_STOP_SCAN_LIST             0x0010
 
 /* Prepare for acquisition */
-#define DAQBOARD2000_AcqResetScanListFifo        0x0004
-#define DAQBOARD2000_AcqResetResultsFifo         0x0002
-#define DAQBOARD2000_AcqResetConfigPipe          0x0001
-
-/* Acqusition status bits */
-#define DAQBOARD2000_AcqResultsFIFOMore1Sample   0x0001
-#define DAQBOARD2000_AcqResultsFIFOHasValidData  0x0002
-#define DAQBOARD2000_AcqResultsFIFOOverrun       0x0004
-#define DAQBOARD2000_AcqLogicScanning            0x0008
-#define DAQBOARD2000_AcqConfigPipeFull           0x0010
-#define DAQBOARD2000_AcqScanListFIFOEmpty        0x0020
-#define DAQBOARD2000_AcqAdcNotReady              0x0040
-#define DAQBOARD2000_ArbitrationFailure          0x0080
-#define DAQBOARD2000_AcqPacerOverrun             0x0100
-#define DAQBOARD2000_DacPacerOverrun             0x0200
-#define DAQBOARD2000_AcqHardwareError            0x01c0
-
-/* Scan Sequencer programming */
-#define DAQBOARD2000_SeqStartScanList            0x0011
-#define DAQBOARD2000_SeqStopScanList             0x0010
+#define DB2K_ACQ_CONTROL_RESET_SCAN_LIST_FIFO           0x0004
+#define DB2K_ACQ_CONTROL_RESET_RESULTS_FIFO             0x0002
+#define DB2K_ACQ_CONTROL_RESET_CONFIG_PIPE              0x0001
 
 /* Pacer Clock Control */
-#define DAQBOARD2000_AdcPacerInternal            0x0030
-#define DAQBOARD2000_AdcPacerExternal            0x0032
-#define DAQBOARD2000_AdcPacerEnable              0x0031
-#define DAQBOARD2000_AdcPacerEnableDacPacer      0x0034
-#define DAQBOARD2000_AdcPacerDisable             0x0030
-#define DAQBOARD2000_AdcPacerNormalMode          0x0060
-#define DAQBOARD2000_AdcPacerCompatibilityMode   0x0061
-#define DAQBOARD2000_AdcPacerInternalOutEnable   0x0008
-#define DAQBOARD2000_AdcPacerExternalRising      0x0100
+#define DB2K_ACQ_CONTROL_ADC_PACER_INTERNAL             0x0030
+#define DB2K_ACQ_CONTROL_ADC_PACER_EXTERNAL             0x0032
+#define DB2K_ACQ_CONTROL_ADC_PACER_ENABLE               0x0031
+#define DB2K_ACQ_CONTROL_ADC_PACER_ENABLE_DAC_PACER     0x0034
+#define DB2K_ACQ_CONTROL_ADC_PACER_DISABLE              0x0030
+#define DB2K_ACQ_CONTROL_ADC_PACER_NORMAL_MODE          0x0060
+#define DB2K_ACQ_CONTROL_ADC_PACER_COMPATIBILITY_MODE   0x0061
+#define DB2K_ACQ_CONTROL_ADC_PACER_INTERNAL_OUT_ENABLE  0x0008
+#define DB2K_ACQ_CONTROL_ADC_PACER_EXTERNAL_RISING      0x0100
+
+/* Acquisition status bits */
+#define DB2K_ACQ_STATUS_RESULTS_FIFO_MORE_1_SAMPLE      0x0001
+#define DB2K_ACQ_STATUS_RESULTS_FIFO_HAS_DATA           0x0002
+#define DB2K_ACQ_STATUS_RESULTS_FIFO_OVERRUN            0x0004
+#define DB2K_ACQ_STATUS_LOGIC_SCANNING                  0x0008
+#define DB2K_ACQ_STATUS_CONFIG_PIPE_FULL                0x0010
+#define DB2K_ACQ_STATUS_SCAN_LIST_FIFO_EMPTY            0x0020
+#define DB2K_ACQ_STATUS_ADC_NOT_READY                   0x0040
+#define DB2K_ACQ_STATUS_ARBITRATION_FAILURE             0x0080
+#define DB2K_ACQ_STATUS_ADC_PACER_OVERRUN               0x0100
+#define DB2K_ACQ_STATUS_DAC_PACER_OVERRUN               0x0200
 
 /* DAC status */
-#define DAQBOARD2000_DacFull                     0x0001
-#define DAQBOARD2000_RefBusy                     0x0002
-#define DAQBOARD2000_TrgBusy                     0x0004
-#define DAQBOARD2000_CalBusy                     0x0008
-#define DAQBOARD2000_Dac0Busy                    0x0010
-#define DAQBOARD2000_Dac1Busy                    0x0020
-#define DAQBOARD2000_Dac2Busy                    0x0040
-#define DAQBOARD2000_Dac3Busy                    0x0080
+#define DB2K_DAC_STATUS_DAC_FULL                        0x0001
+#define DB2K_DAC_STATUS_REF_BUSY                        0x0002
+#define DB2K_DAC_STATUS_TRIG_BUSY                       0x0004
+#define DB2K_DAC_STATUS_CAL_BUSY                        0x0008
+#define DB2K_DAC_STATUS_DAC_BUSY(x)                     (0x0010 << (x))
 
 /* DAC control */
-#define DAQBOARD2000_Dac0Enable                  0x0021
-#define DAQBOARD2000_Dac1Enable                  0x0031
-#define DAQBOARD2000_Dac2Enable                  0x0041
-#define DAQBOARD2000_Dac3Enable                  0x0051
-#define DAQBOARD2000_DacEnableBit                0x0001
-#define DAQBOARD2000_Dac0Disable                 0x0020
-#define DAQBOARD2000_Dac1Disable                 0x0030
-#define DAQBOARD2000_Dac2Disable                 0x0040
-#define DAQBOARD2000_Dac3Disable                 0x0050
-#define DAQBOARD2000_DacResetFifo                0x0004
-#define DAQBOARD2000_DacPatternDisable           0x0060
-#define DAQBOARD2000_DacPatternEnable            0x0061
-#define DAQBOARD2000_DacSelectSignedData         0x0002
-#define DAQBOARD2000_DacSelectUnsignedData       0x0000
+#define DB2K_DAC_CONTROL_ENABLE_BIT                     0x0001
+#define DB2K_DAC_CONTROL_DATA_IS_SIGNED                 0x0002
+#define DB2K_DAC_CONTROL_RESET_FIFO                     0x0004
+#define DB2K_DAC_CONTROL_DAC_DISABLE(x)                 (0x0020 + ((x) << 4))
+#define DB2K_DAC_CONTROL_DAC_ENABLE(x)                  (0x0021 + ((x) << 4))
+#define DB2K_DAC_CONTROL_PATTERN_DISABLE                0x0060
+#define DB2K_DAC_CONTROL_PATTERN_ENABLE                 0x0061
 
 /* Trigger Control */
-#define DAQBOARD2000_TrigAnalog                  0x0000
-#define DAQBOARD2000_TrigTTL                     0x0010
-#define DAQBOARD2000_TrigTransHiLo               0x0004
-#define DAQBOARD2000_TrigTransLoHi               0x0000
-#define DAQBOARD2000_TrigAbove                   0x0000
-#define DAQBOARD2000_TrigBelow                   0x0004
-#define DAQBOARD2000_TrigLevelSense              0x0002
-#define DAQBOARD2000_TrigEdgeSense               0x0000
-#define DAQBOARD2000_TrigEnable                  0x0001
-#define DAQBOARD2000_TrigDisable                 0x0000
+#define DB2K_TRIG_CONTROL_TYPE_ANALOG                   0x0000
+#define DB2K_TRIG_CONTROL_TYPE_TTL                      0x0010
+#define DB2K_TRIG_CONTROL_EDGE_HI_LO                    0x0004
+#define DB2K_TRIG_CONTROL_EDGE_LO_HI                    0x0000
+#define DB2K_TRIG_CONTROL_LEVEL_ABOVE                   0x0000
+#define DB2K_TRIG_CONTROL_LEVEL_BELOW                   0x0004
+#define DB2K_TRIG_CONTROL_SENSE_LEVEL                   0x0002
+#define DB2K_TRIG_CONTROL_SENSE_EDGE                    0x0000
+#define DB2K_TRIG_CONTROL_ENABLE                        0x0001
+#define DB2K_TRIG_CONTROL_DISABLE                       0x0000
 
 /* Reference Dac Selection */
-#define DAQBOARD2000_PosRefDacSelect             0x0100
-#define DAQBOARD2000_NegRefDacSelect             0x0000
+#define DB2K_REF_DACS_SET                               0x0080
+#define DB2K_REF_DACS_SELECT_POS_REF                    0x0100
+#define DB2K_REF_DACS_SELECT_NEG_REF                    0x0000
 
 struct daq200_boardtype {
         const char *name;
         int id;
 };
+
 static const struct daq200_boardtype boardtypes[] = {
         {"ids2", DAQBOARD2000_SUBSYSTEM_IDS2},
         {"ids4", DAQBOARD2000_SUBSYSTEM_IDS4},
@@ -276,15 +265,16 @@ struct daqboard2000_private {
         void __iomem *plx;
 };
 
-static void writeAcqScanListEntry(struct comedi_device *dev, u16 entry)
+static void daqboard2000_write_acq_scan_list_entry(struct comedi_device *dev,
+                                                   u16 entry)
 {
-        /* udelay(4); */
-        writew(entry & 0x00ff, dev->mmio + acqScanListFIFO);
-        /* udelay(4); */
-        writew((entry >> 8) & 0x00ff, dev->mmio + acqScanListFIFO);
+        writew(entry & 0x00ff, dev->mmio + DB2K_REG_ACQ_SCAN_LIST_FIFO);
+        writew((entry >> 8) & 0x00ff,
+               dev->mmio + DB2K_REG_ACQ_SCAN_LIST_FIFO);
 }
 
-static void setup_sampling(struct comedi_device *dev, int chan, int gain)
+static void daqboard2000_setup_sampling(struct comedi_device *dev, int chan,
+                                        int gain)
 {
         u16 word0, word1, word2, word3;
 
@@ -315,17 +305,13 @@ static void setup_sampling(struct comedi_device *dev, int chan, int gain)
                 word3 = 0;
                 break;
         }
-/*
-  dev->eeprom.correctionDACSE[i][j][k].offset = 0x800;
-  dev->eeprom.correctionDACSE[i][j][k].gain = 0xc00;
-*/
         /* These should be read from EEPROM */
-        word2 |= 0x0800;
-        word3 |= 0xc000;
-        writeAcqScanListEntry(dev, word0);
-        writeAcqScanListEntry(dev, word1);
-        writeAcqScanListEntry(dev, word2);
-        writeAcqScanListEntry(dev, word3);
+        word2 |= 0x0800;        /* offset */
+        word3 |= 0xc000;        /* gain */
+        daqboard2000_write_acq_scan_list_entry(dev, word0);
+        daqboard2000_write_acq_scan_list_entry(dev, word1);
+        daqboard2000_write_acq_scan_list_entry(dev, word2);
+        daqboard2000_write_acq_scan_list_entry(dev, word3);
 }
 
 static int daqboard2000_ai_status(struct comedi_device *dev,
@@ -335,7 +321,7 @@ static int daqboard2000_ai_status(struct comedi_device *dev,
 {
         unsigned int status;
 
-        status = readw(dev->mmio + acqControl);
+        status = readw(dev->mmio + DB2K_REG_ACQ_STATUS);
         if (status & context)
                 return 0;
         return -EBUSY;
@@ -350,50 +336,58 @@ static int daqboard2000_ai_insn_read(struct comedi_device *dev,
         int ret;
         int i;
 
-        writew(DAQBOARD2000_AcqResetScanListFifo |
-               DAQBOARD2000_AcqResetResultsFifo |
-               DAQBOARD2000_AcqResetConfigPipe, dev->mmio + acqControl);
+        writew(DB2K_ACQ_CONTROL_RESET_SCAN_LIST_FIFO |
+               DB2K_ACQ_CONTROL_RESET_RESULTS_FIFO |
+               DB2K_ACQ_CONTROL_RESET_CONFIG_PIPE,
+               dev->mmio + DB2K_REG_ACQ_CONTROL);
 
         /*
          * If pacer clock is not set to some high value (> 10 us), we
          * risk multiple samples to be put into the result FIFO.
          */
         /* 1 second, should be long enough */
-        writel(1000000, dev->mmio + acqPacerClockDivLow);
-        writew(0, dev->mmio + acqPacerClockDivHigh);
+        writel(1000000, dev->mmio + DB2K_REG_ACQ_PACER_CLOCK_DIV_LOW);
+        writew(0, dev->mmio + DB2K_REG_ACQ_PACER_CLOCK_DIV_HIGH);
 
         gain = CR_RANGE(insn->chanspec);
         chan = CR_CHAN(insn->chanspec);
 
-        /* This doesn't look efficient.  I decided to take the conservative
+        /*
+         * This doesn't look efficient.  I decided to take the conservative
          * approach when I did the insn conversion.  Perhaps it would be
          * better to have broken it completely, then someone would have been
-         * forced to fix it.  --ds */
+         * forced to fix it.  --ds
+         */
         for (i = 0; i < insn->n; i++) {
-                setup_sampling(dev, chan, gain);
+                daqboard2000_setup_sampling(dev, chan, gain);
                 /* Enable reading from the scanlist FIFO */
-                writew(DAQBOARD2000_SeqStartScanList, dev->mmio + acqControl);
+                writew(DB2K_ACQ_CONTROL_SEQ_START_SCAN_LIST,
+                       dev->mmio + DB2K_REG_ACQ_CONTROL);
 
                 ret = comedi_timeout(dev, s, insn, daqboard2000_ai_status,
-                                     DAQBOARD2000_AcqConfigPipeFull);
+                                     DB2K_ACQ_STATUS_CONFIG_PIPE_FULL);
                 if (ret)
                         return ret;
 
-                writew(DAQBOARD2000_AdcPacerEnable, dev->mmio + acqControl);
+                writew(DB2K_ACQ_CONTROL_ADC_PACER_ENABLE,
+                       dev->mmio + DB2K_REG_ACQ_CONTROL);
 
                 ret = comedi_timeout(dev, s, insn, daqboard2000_ai_status,
-                                     DAQBOARD2000_AcqLogicScanning);
+                                     DB2K_ACQ_STATUS_LOGIC_SCANNING);
                 if (ret)
                         return ret;
 
-                ret = comedi_timeout(dev, s, insn, daqboard2000_ai_status,
-                                     DAQBOARD2000_AcqResultsFIFOHasValidData);
+                ret =
+                comedi_timeout(dev, s, insn, daqboard2000_ai_status,
+                               DB2K_ACQ_STATUS_RESULTS_FIFO_HAS_DATA);
                 if (ret)
                         return ret;
 
-                data[i] = readw(dev->mmio + acqResultsFIFO);
-                writew(DAQBOARD2000_AdcPacerDisable, dev->mmio + acqControl);
-                writew(DAQBOARD2000_SeqStopScanList, dev->mmio + acqControl);
+                data[i] = readw(dev->mmio + DB2K_REG_ACQ_RESULTS_FIFO);
+                writew(DB2K_ACQ_CONTROL_ADC_PACER_DISABLE,
+                       dev->mmio + DB2K_REG_ACQ_CONTROL);
+                writew(DB2K_ACQ_CONTROL_SEQ_STOP_SCAN_LIST,
+                       dev->mmio + DB2K_REG_ACQ_CONTROL);
         }
 
         return i;
@@ -407,8 +401,8 @@ static int daqboard2000_ao_eoc(struct comedi_device *dev,
         unsigned int chan = CR_CHAN(insn->chanspec);
         unsigned int status;
 
-        status = readw(dev->mmio + dacControl);
-        if ((status & ((chan + 1) * 0x0010)) == 0)
+        status = readw(dev->mmio + DB2K_REG_DAC_STATUS);
+        if ((status & DB2K_DAC_STATUS_DAC_BUSY(chan)) == 0)
                 return 0;
         return -EBUSY;
 }
@@ -425,7 +419,7 @@ static int daqboard2000_ao_insn_write(struct comedi_device *dev,
                 unsigned int val = data[i];
                 int ret;
 
-                writew(val, dev->mmio + dacSetting(chan));
+                writew(val, dev->mmio + DB2K_REG_DAC_SETTING(chan));
 
                 ret = comedi_timeout(dev, s, insn, daqboard2000_ao_eoc, 0);
                 if (ret)
@@ -437,39 +431,39 @@ static int daqboard2000_ao_insn_write(struct comedi_device *dev,
         return insn->n;
 }
 
-static void daqboard2000_resetLocalBus(struct comedi_device *dev)
+static void daqboard2000_reset_local_bus(struct comedi_device *dev)
 {
         struct daqboard2000_private *devpriv = dev->private;
 
-        writel(DAQBOARD2000_SECRLocalBusHi, devpriv->plx + 0x6c);
+        writel(DB2K_SECR_LOCAL_BUS_HI, devpriv->plx + 0x6c);
         mdelay(10);
-        writel(DAQBOARD2000_SECRLocalBusLo, devpriv->plx + 0x6c);
+        writel(DB2K_SECR_LOCAL_BUS_LO, devpriv->plx + 0x6c);
         mdelay(10);
 }
 
-static void daqboard2000_reloadPLX(struct comedi_device *dev)
+static void daqboard2000_reload_plx(struct comedi_device *dev)
 {
         struct daqboard2000_private *devpriv = dev->private;
 
-        writel(DAQBOARD2000_SECRReloadLo, devpriv->plx + 0x6c);
+        writel(DB2K_SECR_RELOAD_LO, devpriv->plx + 0x6c);
         mdelay(10);
-        writel(DAQBOARD2000_SECRReloadHi, devpriv->plx + 0x6c);
+        writel(DB2K_SECR_RELOAD_HI, devpriv->plx + 0x6c);
         mdelay(10);
-        writel(DAQBOARD2000_SECRReloadLo, devpriv->plx + 0x6c);
+        writel(DB2K_SECR_RELOAD_LO, devpriv->plx + 0x6c);
         mdelay(10);
 }
 
-static void daqboard2000_pulseProgPin(struct comedi_device *dev)
+static void daqboard2000_pulse_prog_pin(struct comedi_device *dev)
 {
         struct daqboard2000_private *devpriv = dev->private;
 
-        writel(DAQBOARD2000_SECRProgPinHi, devpriv->plx + 0x6c);
+        writel(DB2K_SECR_PROG_PIN_HI, devpriv->plx + 0x6c);
         mdelay(10);
-        writel(DAQBOARD2000_SECRProgPinLo, devpriv->plx + 0x6c);
+        writel(DB2K_SECR_PROG_PIN_LO, devpriv->plx + 0x6c);
         mdelay(10);     /* Not in the original code, but I like symmetry... */
 }
 
-static int daqboard2000_pollCPLD(struct comedi_device *dev, int mask)
+static int daqboard2000_poll_cpld(struct comedi_device *dev, int mask)
 {
         int result = 0;
         int i;
@@ -482,17 +476,17 @@ static int daqboard2000_pollCPLD(struct comedi_device *dev, int mask)
                         result = 1;
                         break;
                 }
-                udelay(100);
+                usleep_range(100, 1000);
         }
         udelay(5);
         return result;
 }
 
-static int daqboard2000_writeCPLD(struct comedi_device *dev, int data)
+static int daqboard2000_write_cpld(struct comedi_device *dev, int data)
 {
         int result = 0;
 
-        udelay(10);
+        usleep_range(10, 20);
         writew(data, dev->mmio + 0x1000);
         if ((readw(dev->mmio + 0x1000) & DAQBOARD2000_CPLD_INIT) ==
             DAQBOARD2000_CPLD_INIT) {
@@ -501,9 +495,9 @@ static int daqboard2000_writeCPLD(struct comedi_device *dev, int data)
         return result;
 }
 
-static int initialize_daqboard2000(struct comedi_device *dev,
-                                   const u8 *cpld_array, size_t len,
-                                   unsigned long context)
+static int daqboard2000_load_firmware(struct comedi_device *dev,
+                                      const u8 *cpld_array, size_t len,
+                                      unsigned long context)
 {
         struct daqboard2000_private *devpriv = dev->private;
         int result = -EIO;
@@ -518,10 +512,10 @@ static int initialize_daqboard2000(struct comedi_device *dev,
                 return -EIO;
 
         for (retry = 0; retry < 3; retry++) {
-                daqboard2000_resetLocalBus(dev);
-                daqboard2000_reloadPLX(dev);
-                daqboard2000_pulseProgPin(dev);
-                if (daqboard2000_pollCPLD(dev, DAQBOARD2000_CPLD_INIT)) {
+                daqboard2000_reset_local_bus(dev);
+                daqboard2000_reload_plx(dev);
+                daqboard2000_pulse_prog_pin(dev);
+                if (daqboard2000_poll_cpld(dev, DAQBOARD2000_CPLD_INIT)) {
                         for (i = 0; i < len; i++) {
                                 if (cpld_array[i] == 0xff &&
                                     cpld_array[i + 1] == 0x20)
@@ -530,12 +524,12 @@ static int initialize_daqboard2000(struct comedi_device *dev,
                         for (; i < len; i += 2) {
                                 int data =
                                     (cpld_array[i] << 8) + cpld_array[i + 1];
-                                if (!daqboard2000_writeCPLD(dev, data))
+                                if (!daqboard2000_write_cpld(dev, data))
                                         break;
                         }
                         if (i >= len) {
-                                daqboard2000_resetLocalBus(dev);
-                                daqboard2000_reloadPLX(dev);
+                                daqboard2000_reset_local_bus(dev);
+                                daqboard2000_reload_plx(dev);
                                 result = 0;
                                 break;
                         }
@@ -544,79 +538,83 @@ static int initialize_daqboard2000(struct comedi_device *dev,
         return result;
 }
 
-static void daqboard2000_adcStopDmaTransfer(struct comedi_device *dev)
+static void daqboard2000_adc_stop_dma_transfer(struct comedi_device *dev)
 {
 }
 
-static void daqboard2000_adcDisarm(struct comedi_device *dev)
+static void daqboard2000_adc_disarm(struct comedi_device *dev)
 {
         /* Disable hardware triggers */
         udelay(2);
-        writew(DAQBOARD2000_TrigAnalog | DAQBOARD2000_TrigDisable,
-               dev->mmio + trigControl);
+        writew(DB2K_TRIG_CONTROL_TYPE_ANALOG | DB2K_TRIG_CONTROL_DISABLE,
+               dev->mmio + DB2K_REG_TRIG_CONTROL);
         udelay(2);
-        writew(DAQBOARD2000_TrigTTL | DAQBOARD2000_TrigDisable,
-               dev->mmio + trigControl);
+        writew(DB2K_TRIG_CONTROL_TYPE_TTL | DB2K_TRIG_CONTROL_DISABLE,
+               dev->mmio + DB2K_REG_TRIG_CONTROL);
 
         /* Stop the scan list FIFO from loading the configuration pipe */
         udelay(2);
-        writew(DAQBOARD2000_SeqStopScanList, dev->mmio + acqControl);
+        writew(DB2K_ACQ_CONTROL_SEQ_STOP_SCAN_LIST,
+               dev->mmio + DB2K_REG_ACQ_CONTROL);
 
         /* Stop the pacer clock */
         udelay(2);
-        writew(DAQBOARD2000_AdcPacerDisable, dev->mmio + acqControl);
+        writew(DB2K_ACQ_CONTROL_ADC_PACER_DISABLE,
+               dev->mmio + DB2K_REG_ACQ_CONTROL);
 
         /* Stop the input dma (abort channel 1) */
-        daqboard2000_adcStopDmaTransfer(dev);
+        daqboard2000_adc_stop_dma_transfer(dev);
 }
 
-static void daqboard2000_activateReferenceDacs(struct comedi_device *dev)
+static void daqboard2000_activate_reference_dacs(struct comedi_device *dev)
 {
         unsigned int val;
         int timeout;
 
         /*  Set the + reference dac value in the FPGA */
-        writew(0x80 | DAQBOARD2000_PosRefDacSelect, dev->mmio + refDacs);
+        writew(DB2K_REF_DACS_SET | DB2K_REF_DACS_SELECT_POS_REF,
+               dev->mmio + DB2K_REG_REF_DACS);
         for (timeout = 0; timeout < 20; timeout++) {
-                val = readw(dev->mmio + dacControl);
-                if ((val & DAQBOARD2000_RefBusy) == 0)
+                val = readw(dev->mmio + DB2K_REG_DAC_STATUS);
+                if ((val & DB2K_DAC_STATUS_REF_BUSY) == 0)
                         break;
                 udelay(2);
         }
 
         /*  Set the - reference dac value in the FPGA */
-        writew(0x80 | DAQBOARD2000_NegRefDacSelect, dev->mmio + refDacs);
+        writew(DB2K_REF_DACS_SET | DB2K_REF_DACS_SELECT_NEG_REF,
+               dev->mmio + DB2K_REG_REF_DACS);
         for (timeout = 0; timeout < 20; timeout++) {
-                val = readw(dev->mmio + dacControl);
-                if ((val & DAQBOARD2000_RefBusy) == 0)
+                val = readw(dev->mmio + DB2K_REG_DAC_STATUS);
+                if ((val & DB2K_DAC_STATUS_REF_BUSY) == 0)
                         break;
                 udelay(2);
         }
 }
 
-static void daqboard2000_initializeCtrs(struct comedi_device *dev)
+static void daqboard2000_initialize_ctrs(struct comedi_device *dev)
 {
 }
 
-static void daqboard2000_initializeTmrs(struct comedi_device *dev)
+static void daqboard2000_initialize_tmrs(struct comedi_device *dev)
 {
 }
 
-static void daqboard2000_dacDisarm(struct comedi_device *dev)
+static void daqboard2000_dac_disarm(struct comedi_device *dev)
 {
 }
 
-static void daqboard2000_initializeAdc(struct comedi_device *dev)
+static void daqboard2000_initialize_adc(struct comedi_device *dev)
 {
-        daqboard2000_adcDisarm(dev);
-        daqboard2000_activateReferenceDacs(dev);
-        daqboard2000_initializeCtrs(dev);
-        daqboard2000_initializeTmrs(dev);
+        daqboard2000_adc_disarm(dev);
+        daqboard2000_activate_reference_dacs(dev);
+        daqboard2000_initialize_ctrs(dev);
+        daqboard2000_initialize_tmrs(dev);
 }
 
-static void daqboard2000_initializeDac(struct comedi_device *dev)
+static void daqboard2000_initialize_dac(struct comedi_device *dev)
 {
-        daqboard2000_dacDisarm(dev);
+        daqboard2000_dac_disarm(dev);
 }
 
 static int daqboard2000_8255_cb(struct comedi_device *dev,
@@ -683,12 +681,12 @@ static int daqboard2000_auto_attach(struct comedi_device *dev,
 
         result = comedi_load_firmware(dev, &comedi_to_pci_dev(dev)->dev,
                                       DAQBOARD2000_FIRMWARE,
-                                      initialize_daqboard2000, 0);
+                                      daqboard2000_load_firmware, 0);
         if (result < 0)
                 return result;
 
-        daqboard2000_initializeAdc(dev);
-        daqboard2000_initializeDac(dev);
+        daqboard2000_initialize_adc(dev);
+        daqboard2000_initialize_dac(dev);
 
         s = &dev->subdevices[0];
         /* ai subdevice */
@@ -714,7 +712,7 @@ static int daqboard2000_auto_attach(struct comedi_device *dev,
 
         s = &dev->subdevices[2];
         return subdev_8255_init(dev, s, daqboard2000_8255_cb,
-                                dioP2ExpansionIO8Bit);
+                                DB2K_REG_DIO_P2_EXP_IO_8_BIT);
 }
 
 static void daqboard2000_detach(struct comedi_device *dev)
diff --git a/drivers/staging/comedi/drivers/das16.c b/drivers/staging/comedi/drivers/das16.c
index fd8e0b76f764..5d157951f63f 100644
--- a/drivers/staging/comedi/drivers/das16.c
+++ b/drivers/staging/comedi/drivers/das16.c
@@ -92,37 +92,37 @@
 #define DAS16_AO_LSB_REG(x)             ((x) ? 0x06 : 0x04)
 #define DAS16_AO_MSB_REG(x)             ((x) ? 0x07 : 0x05)
 #define DAS16_STATUS_REG                0x08
-#define DAS16_STATUS_BUSY               (1 << 7)
-#define DAS16_STATUS_UNIPOLAR           (1 << 6)
-#define DAS16_STATUS_MUXBIT             (1 << 5)
-#define DAS16_STATUS_INT                (1 << 4)
+#define DAS16_STATUS_BUSY               BIT(7)
+#define DAS16_STATUS_UNIPOLAR           BIT(6)
+#define DAS16_STATUS_MUXBIT             BIT(5)
+#define DAS16_STATUS_INT                BIT(4)
 #define DAS16_CTRL_REG                  0x09
-#define DAS16_CTRL_INTE                 (1 << 7)
+#define DAS16_CTRL_INTE                 BIT(7)
 #define DAS16_CTRL_IRQ(x)               (((x) & 0x7) << 4)
-#define DAS16_CTRL_DMAE                 (1 << 2)
+#define DAS16_CTRL_DMAE                 BIT(2)
 #define DAS16_CTRL_PACING_MASK          (3 << 0)
 #define DAS16_CTRL_INT_PACER            (3 << 0)
 #define DAS16_CTRL_EXT_PACER            (2 << 0)
 #define DAS16_CTRL_SOFT_PACER           (0 << 0)
 #define DAS16_PACER_REG                 0x0a
 #define DAS16_PACER_BURST_LEN(x)        (((x) & 0xf) << 4)
-#define DAS16_PACER_CTR0                (1 << 1)
-#define DAS16_PACER_TRIG0               (1 << 0)
+#define DAS16_PACER_CTR0                BIT(1)
+#define DAS16_PACER_TRIG0               BIT(0)
 #define DAS16_GAIN_REG                  0x0b
 #define DAS16_TIMER_BASE_REG            0x0c    /* to 0x0f */
 
 #define DAS1600_CONV_REG                0x404
-#define DAS1600_CONV_DISABLE            (1 << 6)
+#define DAS1600_CONV_DISABLE            BIT(6)
 #define DAS1600_BURST_REG               0x405
-#define DAS1600_BURST_VAL               (1 << 6)
+#define DAS1600_BURST_VAL               BIT(6)
 #define DAS1600_ENABLE_REG              0x406
-#define DAS1600_ENABLE_VAL              (1 << 6)
+#define DAS1600_ENABLE_VAL              BIT(6)
 #define DAS1600_STATUS_REG              0x407
-#define DAS1600_STATUS_BME              (1 << 6)
-#define DAS1600_STATUS_ME               (1 << 5)
-#define DAS1600_STATUS_CD               (1 << 4)
-#define DAS1600_STATUS_WS               (1 << 1)
-#define DAS1600_STATUS_CLK_10MHZ        (1 << 0)
+#define DAS1600_STATUS_BME              BIT(6)
+#define DAS1600_STATUS_ME               BIT(5)
+#define DAS1600_STATUS_CD               BIT(4)
+#define DAS1600_STATUS_WS               BIT(1)
+#define DAS1600_STATUS_CLK_10MHZ        BIT(0)
 
 static const struct comedi_lrange range_das1x01_bip = {
         4, {
@@ -198,6 +198,7 @@ enum {
         das16_pg_1601,
         das16_pg_1602,
 };
+
 static const int *const das16_gainlists[] = {
         NULL,
         das16jr_gainlist,
@@ -428,8 +429,10 @@ static const struct das16_board das16_boards[] = {
         },
 };
 
-/* Period for timer interrupt in jiffies.  It's a function
- * to deal with possibility of dynamic HZ patches  */
+/*
+ * Period for timer interrupt in jiffies.  It's a function
+ * to deal with possibility of dynamic HZ patches
+ */
 static inline int timer_period(void)
 {
         return HZ / 20;
diff --git a/drivers/staging/comedi/drivers/das16m1.c b/drivers/staging/comedi/drivers/das16m1.c
index 3a37373fbb6f..bb8d6ec0632e 100644
--- a/drivers/staging/comedi/drivers/das16m1.c
+++ b/drivers/staging/comedi/drivers/das16m1.c
@@ -1,56 +1,52 @@
 /*
-    comedi/drivers/das16m1.c
-    CIO-DAS16/M1 driver
-    Author: Frank Mori Hess, based on code from the das16
-      driver.
-    Copyright (C) 2001 Frank Mori Hess <fmhess@users.sourceforge.net>
-
-    COMEDI - Linux Control and Measurement Device Interface
-    Copyright (C) 2000 David A. Schleef <ds@schleef.org>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-*/
+ * Comedi driver for CIO-DAS16/M1
+ * Author: Frank Mori Hess, based on code from the das16 driver.
+ * Copyright (C) 2001 Frank Mori Hess <fmhess@users.sourceforge.net>
+ *
+ * COMEDI - Linux Control and Measurement Device Interface
+ * Copyright (C) 2000 David A. Schleef <ds@schleef.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
 /*
-Driver: das16m1
-Description: CIO-DAS16/M1
-Author: Frank Mori Hess <fmhess@users.sourceforge.net>
-Devices: [Measurement Computing] CIO-DAS16/M1 (das16m1)
-Status: works
-
-This driver supports a single board - the CIO-DAS16/M1.
-As far as I know, there are no other boards that have
-the same register layout.  Even the CIO-DAS16/M1/16 is
-significantly different.
-
-I was _barely_ able to reach the full 1 MHz capability
-of this board, using a hard real-time interrupt
-(set the TRIG_RT flag in your struct comedi_cmd and use
-rtlinux or RTAI).  The board can't do dma, so the bottleneck is
-pulling the data across the ISA bus.  I timed the interrupt
-handler, and it took my computer ~470 microseconds to pull 512
-samples from the board.  So at 1 Mhz sampling rate,
-expect your CPU to be spending almost all of its
-time in the interrupt handler.
-
-This board has some unusual restrictions for its channel/gain list.  If the
-list has 2 or more channels in it, then two conditions must be satisfied:
-(1) - even/odd channels must appear at even/odd indices in the list
-(2) - the list must have an even number of entries.
-
-Options:
-        [0] - base io address
-        [1] - irq (optional, but you probably want it)
-
-irq can be omitted, although the cmd interface will not work without it.
-*/
+ * Driver: das16m1
+ * Description: CIO-DAS16/M1
+ * Author: Frank Mori Hess <fmhess@users.sourceforge.net>
+ * Devices: [Measurement Computing] CIO-DAS16/M1 (das16m1)
+ * Status: works
+ *
+ * This driver supports a single board - the CIO-DAS16/M1. As far as I know,
+ * there are no other boards that have the same register layout. Even the
+ * CIO-DAS16/M1/16 is significantly different.
+ *
+ * I was _barely_ able to reach the full 1 MHz capability of this board, using
+ * a hard real-time interrupt (set the TRIG_RT flag in your struct comedi_cmd
+ * and use rtlinux or RTAI). The board can't do dma, so the bottleneck is
+ * pulling the data across the ISA bus. I timed the interrupt handler, and it
+ * took my computer ~470 microseconds to pull 512 samples from the board. So
+ * at 1 Mhz sampling rate, expect your CPU to be spending almost all of its
+ * time in the interrupt handler.
+ *
+ * This board has some unusual restrictions for its channel/gain list.  If the
+ * list has 2 or more channels in it, then two conditions must be satisfied:
+ * (1) - even/odd channels must appear at even/odd indices in the list
+ * (2) - the list must have an even number of entries.
+ *
+ * Configuration options:
+ *   [0] - base io address
+ *   [1] - irq (optional, but you probably want it)
+ *
+ * irq can be omitted, although the cmd interface will not work without it.
+ */
 
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -60,52 +56,38 @@ irq can be omitted, although the cmd interface will not work without it.
 #include "8255.h"
 #include "comedi_8254.h"
 
-#define DAS16M1_SIZE2 8
-
-#define FIFO_SIZE 1024          /*  1024 sample fifo */
-
 /*
-    CIO-DAS16_M1.pdf
-
-    "cio-das16/m1"
-
-  0             a/d bits 0-3, mux               start 12 bit
-  1             a/d bits 4-11           unused
-  2             status          control
-  3             di 4 bit                do 4 bit
-  4             unused                  clear interrupt
-  5             interrupt, pacer
-  6             channel/gain queue address
-  7             channel/gain queue data
-  89ab          8254
-  cdef          8254
-  400           8255
-  404-407       8254
-
-*/
-
-#define DAS16M1_AI             0        /*  16-bit wide register */
-#define   AI_CHAN(x)             ((x) & 0xf)
-#define DAS16M1_CS             2
-#define   EXT_TRIG_BIT           0x1
-#define   OVRUN                  0x20
-#define   IRQDATA                0x80
-#define DAS16M1_DIO            3
-#define DAS16M1_CLEAR_INTR     4
-#define DAS16M1_INTR_CONTROL   5
-#define   EXT_PACER              0x2
-#define   INT_PACER              0x3
-#define   PACER_MASK             0x3
-#define   INTE                   0x80
-#define DAS16M1_QUEUE_ADDR     6
-#define DAS16M1_QUEUE_DATA     7
-#define   Q_CHAN(x)              ((x) & 0x7)
-#define   Q_RANGE(x)             (((x) & 0xf) << 4)
-#define   UNIPOLAR               0x40
-#define DAS16M1_8254_FIRST             0x8
-#define DAS16M1_8254_SECOND            0xc
-#define DAS16M1_82C55                  0x400
-#define DAS16M1_8254_THIRD             0x404
+ * Register map (dev->iobase)
+ */
+#define DAS16M1_AI_REG                  0x00    /* 16-bit register */
+#define DAS16M1_AI_TO_CHAN(x)           (((x) >> 0) & 0xf)
+#define DAS16M1_AI_TO_SAMPLE(x)         (((x) >> 4) & 0xfff)
+#define DAS16M1_CS_REG                  0x02
+#define DAS16M1_CS_EXT_TRIG             BIT(0)
+#define DAS16M1_CS_OVRUN                BIT(5)
+#define DAS16M1_CS_IRQDATA              BIT(7)
+#define DAS16M1_DI_REG                  0x03
+#define DAS16M1_DO_REG                  0x03
+#define DAS16M1_CLR_INTR_REG            0x04
+#define DAS16M1_INTR_CTRL_REG           0x05
+#define DAS16M1_INTR_CTRL_PACER(x)      (((x) & 0x3) << 0)
+#define DAS16M1_INTR_CTRL_PACER_EXT     DAS16M1_INTR_CTRL_PACER(2)
+#define DAS16M1_INTR_CTRL_PACER_INT     DAS16M1_INTR_CTRL_PACER(3)
+#define DAS16M1_INTR_CTRL_PACER_MASK    DAS16M1_INTR_CTRL_PACER(3)
+#define DAS16M1_INTR_CTRL_IRQ(x)        (((x) & 0x7) << 4)
+#define DAS16M1_INTR_CTRL_INTE          BIT(7)
+#define DAS16M1_Q_ADDR_REG              0x06
+#define DAS16M1_Q_REG                   0x07
+#define DAS16M1_Q_CHAN(x)              (((x) & 0x7) << 0)
+#define DAS16M1_Q_RANGE(x)             (((x) & 0xf) << 4)
+#define DAS16M1_8254_IOBASE1            0x08
+#define DAS16M1_8254_IOBASE2            0x0c
+#define DAS16M1_8255_IOBASE             0x400
+#define DAS16M1_8254_IOBASE3            0x404
+
+#define DAS16M1_SIZE2                   0x08
+
+#define DAS16M1_AI_FIFO_SZ              1024    /* # samples */
 
 static const struct comedi_lrange range_das16m1 = {
         9, {
@@ -121,29 +103,46 @@ static const struct comedi_lrange range_das16m1 = {
         }
 };
 
-struct das16m1_private_struct {
+struct das16m1_private {
         struct comedi_8254 *counter;
-        unsigned int control_state;
-        unsigned int adc_count; /*  number of samples completed */
-        /* initial value in lower half of hardware conversion counter,
-         * needed to keep track of whether new count has been loaded into
-         * counter yet (loaded by first sample conversion) */
+        unsigned int intr_ctrl;
+        unsigned int adc_count;
         u16 initial_hw_count;
-        unsigned short ai_buffer[FIFO_SIZE];
+        unsigned short ai_buffer[DAS16M1_AI_FIFO_SZ];
         unsigned long extra_iobase;
 };
 
-static inline unsigned short munge_sample(unsigned short data)
+static void das16m1_ai_set_queue(struct comedi_device *dev,
+                                 unsigned int *chanspec, unsigned int len)
 {
-        return (data >> 4) & 0xfff;
+        unsigned int i;
+
+        for (i = 0; i < len; i++) {
+                unsigned int chan = CR_CHAN(chanspec[i]);
+                unsigned int range = CR_RANGE(chanspec[i]);
+
+                outb(i, dev->iobase + DAS16M1_Q_ADDR_REG);
+                outb(DAS16M1_Q_CHAN(chan) | DAS16M1_Q_RANGE(range),
+                     dev->iobase + DAS16M1_Q_REG);
+        }
 }
 
-static void munge_sample_array(unsigned short *array, unsigned int num_elements)
+static void das16m1_ai_munge(struct comedi_device *dev,
+                             struct comedi_subdevice *s,
+                             void *data, unsigned int num_bytes,
+                             unsigned int start_chan_index)
 {
+        unsigned short *array = data;
+        unsigned int nsamples = comedi_bytes_to_samples(s, num_bytes);
         unsigned int i;
 
-        for (i = 0; i < num_elements; i++)
-                array[i] = munge_sample(array[i]);
+        /*
+         * The fifo values have the channel number in the lower 4-bits and
+         * the sample in the upper 12-bits. This just shifts the values
+         * to remove the channel numbers.
+         */
+        for (i = 0; i < nsamples; i++)
+                array[i] = DAS16M1_AI_TO_SAMPLE(array[i]);
 }
 
 static int das16m1_ai_check_chanlist(struct comedi_device *dev,
@@ -174,8 +173,9 @@ static int das16m1_ai_check_chanlist(struct comedi_device *dev,
         return 0;
 }
 
-static int das16m1_cmd_test(struct comedi_device *dev,
-                            struct comedi_subdevice *s, struct comedi_cmd *cmd)
+static int das16m1_ai_cmdtest(struct comedi_device *dev,
+                              struct comedi_subdevice *s,
+                              struct comedi_cmd *cmd)
 {
         int err = 0;
 
@@ -245,17 +245,13 @@ static int das16m1_cmd_test(struct comedi_device *dev,
         return 0;
 }
 
-static int das16m1_cmd_exec(struct comedi_device *dev,
-                            struct comedi_subdevice *s)
+static int das16m1_ai_cmd(struct comedi_device *dev,
+                          struct comedi_subdevice *s)
 {
-        struct das16m1_private_struct *devpriv = dev->private;
+        struct das16m1_private *devpriv = dev->private;
         struct comedi_async *async = s->async;
         struct comedi_cmd *cmd = &async->cmd;
-        unsigned int byte, i;
-
-        /* disable interrupts and internal pacer */
-        devpriv->control_state &= ~INTE & ~PACER_MASK;
-        outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
+        unsigned int byte;
 
         /*  set software count */
         devpriv->adc_count = 0;
@@ -274,48 +270,47 @@ static int das16m1_cmd_exec(struct comedi_device *dev,
          */
         devpriv->initial_hw_count = comedi_8254_read(devpriv->counter, 1);
 
-        /* setup channel/gain queue */
-        for (i = 0; i < cmd->chanlist_len; i++) {
-                outb(i, dev->iobase + DAS16M1_QUEUE_ADDR);
-                byte =
-                    Q_CHAN(CR_CHAN(cmd->chanlist[i])) |
-                    Q_RANGE(CR_RANGE(cmd->chanlist[i]));
-                outb(byte, dev->iobase + DAS16M1_QUEUE_DATA);
-        }
+        das16m1_ai_set_queue(dev, cmd->chanlist, cmd->chanlist_len);
 
         /* enable interrupts and set internal pacer counter mode and counts */
-        devpriv->control_state &= ~PACER_MASK;
+        devpriv->intr_ctrl &= ~DAS16M1_INTR_CTRL_PACER_MASK;
         if (cmd->convert_src == TRIG_TIMER) {
                 comedi_8254_update_divisors(dev->pacer);
                 comedi_8254_pacer_enable(dev->pacer, 1, 2, true);
-                devpriv->control_state |= INT_PACER;
+                devpriv->intr_ctrl |= DAS16M1_INTR_CTRL_PACER_INT;
         } else {        /* TRIG_EXT */
-                devpriv->control_state |= EXT_PACER;
+                devpriv->intr_ctrl |= DAS16M1_INTR_CTRL_PACER_EXT;
         }
 
         /*  set control & status register */
         byte = 0;
-        /* if we are using external start trigger (also board dislikes having
-         * both start and conversion triggers external simultaneously) */
+        /*
+         * If we are using external start trigger (also board dislikes having
+         * both start and conversion triggers external simultaneously).
+         */
         if (cmd->start_src == TRIG_EXT && cmd->convert_src != TRIG_EXT)
-                byte |= EXT_TRIG_BIT;
+                byte |= DAS16M1_CS_EXT_TRIG;
 
-        outb(byte, dev->iobase + DAS16M1_CS);
-        /* clear interrupt bit */
-        outb(0, dev->iobase + DAS16M1_CLEAR_INTR);
+        outb(byte, dev->iobase + DAS16M1_CS_REG);
+
+        /* clear interrupt */
+        outb(0, dev->iobase + DAS16M1_CLR_INTR_REG);
 
-        devpriv->control_state |= INTE;
-        outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
+        devpriv->intr_ctrl |= DAS16M1_INTR_CTRL_INTE;
+        outb(devpriv->intr_ctrl, dev->iobase + DAS16M1_INTR_CTRL_REG);
 
         return 0;
 }
 
-static int das16m1_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
+static int das16m1_ai_cancel(struct comedi_device *dev,
+                             struct comedi_subdevice *s)
 {
-        struct das16m1_private_struct *devpriv = dev->private;
+        struct das16m1_private *devpriv = dev->private;
 
-        devpriv->control_state &= ~INTE & ~PACER_MASK;
-        outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
+        /* disable interrupts and pacer */
+        devpriv->intr_ctrl &= ~(DAS16M1_INTR_CTRL_INTE |
+                                DAS16M1_INTR_CTRL_PACER_MASK);
+        outb(devpriv->intr_ctrl, dev->iobase + DAS16M1_INTR_CTRL_REG);
 
         return 0;
 }
@@ -327,67 +322,58 @@ static int das16m1_ai_eoc(struct comedi_device *dev,
 {
         unsigned int status;
 
-        status = inb(dev->iobase + DAS16M1_CS);
-        if (status & IRQDATA)
+        status = inb(dev->iobase + DAS16M1_CS_REG);
+        if (status & DAS16M1_CS_IRQDATA)
                 return 0;
         return -EBUSY;
 }
 
-static int das16m1_ai_rinsn(struct comedi_device *dev,
-                            struct comedi_subdevice *s,
-                            struct comedi_insn *insn, unsigned int *data)
+static int das16m1_ai_insn_read(struct comedi_device *dev,
+                                struct comedi_subdevice *s,
+                                struct comedi_insn *insn,
+                                unsigned int *data)
 {
-        struct das16m1_private_struct *devpriv = dev->private;
         int ret;
-        int n;
-        int byte;
-
-        /* disable interrupts and internal pacer */
-        devpriv->control_state &= ~INTE & ~PACER_MASK;
-        outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
-
-        /* setup channel/gain queue */
-        outb(0, dev->iobase + DAS16M1_QUEUE_ADDR);
-        byte =
-            Q_CHAN(CR_CHAN(insn->chanspec)) | Q_RANGE(CR_RANGE(insn->chanspec));
-        outb(byte, dev->iobase + DAS16M1_QUEUE_DATA);
-
-        for (n = 0; n < insn->n; n++) {
-                /* clear IRQDATA bit */
-                outb(0, dev->iobase + DAS16M1_CLEAR_INTR);
+        int i;
+
+        das16m1_ai_set_queue(dev, &insn->chanspec, 1);
+
+        for (i = 0; i < insn->n; i++) {
+                unsigned short val;
+
+                /* clear interrupt */
+                outb(0, dev->iobase + DAS16M1_CLR_INTR_REG);
                 /* trigger conversion */
-                outb(0, dev->iobase);
+                outb(0, dev->iobase + DAS16M1_AI_REG);
 
                 ret = comedi_timeout(dev, s, insn, das16m1_ai_eoc, 0);
                 if (ret)
                         return ret;
 
-                data[n] = munge_sample(inw(dev->iobase));
+                val = inw(dev->iobase + DAS16M1_AI_REG);
+                data[i] = DAS16M1_AI_TO_SAMPLE(val);
         }
 
-        return n;
+        return insn->n;
 }
 
-static int das16m1_di_rbits(struct comedi_device *dev,
-                            struct comedi_subdevice *s,
-                            struct comedi_insn *insn, unsigned int *data)
+static int das16m1_di_insn_bits(struct comedi_device *dev,
+                                struct comedi_subdevice *s,
+                                struct comedi_insn *insn,
+                                unsigned int *data)
 {
-        unsigned int bits;
-
-        bits = inb(dev->iobase + DAS16M1_DIO) & 0xf;
-        data[1] = bits;
-        data[0] = 0;
+        data[1] = inb(dev->iobase + DAS16M1_DI_REG) & 0xf;
 
         return insn->n;
 }
 
-static int das16m1_do_wbits(struct comedi_device *dev,
-                            struct comedi_subdevice *s,
-                            struct comedi_insn *insn,
-                            unsigned int *data)
+static int das16m1_do_insn_bits(struct comedi_device *dev,
+                                struct comedi_subdevice *s,
+                                struct comedi_insn *insn,
+                                unsigned int *data)
 {
         if (comedi_dio_update_state(s, data))
-                outb(s->state, dev->iobase + DAS16M1_DIO);
+                outb(s->state, dev->iobase + DAS16M1_DO_REG);
 
         data[1] = s->state;
 
@@ -396,33 +382,33 @@ static int das16m1_do_wbits(struct comedi_device *dev,
 
 static void das16m1_handler(struct comedi_device *dev, unsigned int status)
 {
-        struct das16m1_private_struct *devpriv = dev->private;
-        struct comedi_subdevice *s;
-        struct comedi_async *async;
-        struct comedi_cmd *cmd;
+        struct das16m1_private *devpriv = dev->private;
+        struct comedi_subdevice *s = dev->read_subdev;
+        struct comedi_async *async = s->async;
+        struct comedi_cmd *cmd = &async->cmd;
         u16 num_samples;
         u16 hw_counter;
 
-        s = dev->read_subdev;
-        async = s->async;
-        cmd = &async->cmd;
-
         /* figure out how many samples are in fifo */
         hw_counter = comedi_8254_read(devpriv->counter, 1);
-        /* make sure hardware counter reading is not bogus due to initial value
-         * not having been loaded yet */
+        /*
+         * Make sure hardware counter reading is not bogus due to initial
+         * value not having been loaded yet.
+         */
         if (devpriv->adc_count == 0 &&
             hw_counter == devpriv->initial_hw_count) {
                 num_samples = 0;
         } else {
-                /* The calculation of num_samples looks odd, but it uses the
+                /*
+                 * The calculation of num_samples looks odd, but it uses the
                  * following facts. 16 bit hardware counter is initialized with
                  * value of zero (which really means 0x1000).  The counter
                  * decrements by one on each conversion (when the counter
                  * decrements from zero it goes to 0xffff).  num_samples is a
                  * 16 bit variable, so it will roll over in a similar fashion
                  * to the hardware counter.  Work it out, and this is what you
-                 * get. */
+                 * get.
+                 */
                 num_samples = -hw_counter - devpriv->adc_count;
         }
         /*  check if we only need some of the points */
@@ -431,10 +417,9 @@ static void das16m1_handler(struct comedi_device *dev, unsigned int status)
                         num_samples = cmd->stop_arg * cmd->chanlist_len;
         }
         /*  make sure we dont try to get too many points if fifo has overrun */
-        if (num_samples > FIFO_SIZE)
-                num_samples = FIFO_SIZE;
+        if (num_samples > DAS16M1_AI_FIFO_SZ)
+                num_samples = DAS16M1_AI_FIFO_SZ;
         insw(dev->iobase, devpriv->ai_buffer, num_samples);
-        munge_sample_array(devpriv->ai_buffer, num_samples);
         comedi_buf_write_samples(s, devpriv->ai_buffer, num_samples);
         devpriv->adc_count += num_samples;
 
@@ -445,9 +430,11 @@ static void das16m1_handler(struct comedi_device *dev, unsigned int status)
                 }
         }
 
-        /* this probably won't catch overruns since the card doesn't generate
-         * overrun interrupts, but we might as well try */
-        if (status & OVRUN) {
+        /*
+         * This probably won't catch overruns since the card doesn't generate
+         * overrun interrupts, but we might as well try.
+         */
+        if (status & DAS16M1_CS_OVRUN) {
                 async->events |= COMEDI_CB_ERROR;
                 dev_err(dev->class_dev, "fifo overflow\n");
         }
@@ -455,14 +442,15 @@ static void das16m1_handler(struct comedi_device *dev, unsigned int status)
         comedi_handle_events(dev, s);
 }
 
-static int das16m1_poll(struct comedi_device *dev, struct comedi_subdevice *s)
+static int das16m1_ai_poll(struct comedi_device *dev,
+                           struct comedi_subdevice *s)
 {
         unsigned long flags;
         unsigned int status;
 
         /*  prevent race with interrupt handler */
         spin_lock_irqsave(&dev->spinlock, flags);
-        status = inb(dev->iobase + DAS16M1_CS);
+        status = inb(dev->iobase + DAS16M1_CS_REG);
         das16m1_handler(dev, status);
         spin_unlock_irqrestore(&dev->spinlock, flags);
 
@@ -481,9 +469,9 @@ static irqreturn_t das16m1_interrupt(int irq, void *d)
         /*  prevent race with comedi_poll() */
         spin_lock(&dev->spinlock);
 
-        status = inb(dev->iobase + DAS16M1_CS);
+        status = inb(dev->iobase + DAS16M1_CS_REG);
 
-        if ((status & (IRQDATA | OVRUN)) == 0) {
+        if ((status & (DAS16M1_CS_IRQDATA | DAS16M1_CS_OVRUN)) == 0) {
                 dev_err(dev->class_dev, "spurious interrupt\n");
                 spin_unlock(&dev->spinlock);
                 return IRQ_NONE;
@@ -492,7 +480,7 @@ static irqreturn_t das16m1_interrupt(int irq, void *d)
         das16m1_handler(dev, status);
 
         /* clear interrupt */
-        outb(0, dev->iobase + DAS16M1_CLEAR_INTR);
+        outb(0, dev->iobase + DAS16M1_CLR_INTR_REG);
 
         spin_unlock(&dev->spinlock);
         return IRQ_HANDLED;
@@ -522,15 +510,10 @@ static int das16m1_irq_bits(unsigned int irq)
         }
 }
 
-/*
- * Options list:
- *   0  I/O base
- *   1  IRQ
- */
 static int das16m1_attach(struct comedi_device *dev,
                           struct comedi_devconfig *it)
 {
-        struct das16m1_private_struct *devpriv;
+        struct das16m1_private *devpriv;
         struct comedi_subdevice *s;
         int ret;
 
@@ -541,12 +524,12 @@ static int das16m1_attach(struct comedi_device *dev,
         ret = comedi_request_region(dev, it->options[0], 0x10);
         if (ret)
                 return ret;
-        /* Request an additional region for the 8255 */
-        ret = __comedi_request_region(dev, dev->iobase + DAS16M1_82C55,
+        /* Request an additional region for the 8255 and 3rd 8254 */
+        ret = __comedi_request_region(dev, dev->iobase + DAS16M1_8255_IOBASE,
                                       DAS16M1_SIZE2);
         if (ret)
                 return ret;
-        devpriv->extra_iobase = dev->iobase + DAS16M1_82C55;
+        devpriv->extra_iobase = dev->iobase + DAS16M1_8255_IOBASE;
 
         /* only irqs 2, 3, 4, 5, 6, 7, 10, 11, 12, 14, and 15 are valid */
         if ((1 << it->options[1]) & 0xdcfc) {
@@ -556,12 +539,12 @@ static int das16m1_attach(struct comedi_device *dev,
                         dev->irq = it->options[1];
         }
 
-        dev->pacer = comedi_8254_init(dev->iobase + DAS16M1_8254_SECOND,
+        dev->pacer = comedi_8254_init(dev->iobase + DAS16M1_8254_IOBASE2,
                                       I8254_OSC_BASE_10MHZ, I8254_IO8, 0);
         if (!dev->pacer)
                 return -ENOMEM;
 
-        devpriv->counter = comedi_8254_init(dev->iobase + DAS16M1_8254_FIRST,
+        devpriv->counter = comedi_8254_init(dev->iobase + DAS16M1_8254_IOBASE1,
                                             0, I8254_IO8, 0);
         if (!devpriv->counter)
                 return -ENOMEM;
@@ -570,61 +553,62 @@ static int das16m1_attach(struct comedi_device *dev,
         if (ret)
                 return ret;
 
+        /* Analog Input subdevice */
         s = &dev->subdevices[0];
-        /* ai */
-        s->type = COMEDI_SUBD_AI;
-        s->subdev_flags = SDF_READABLE | SDF_DIFF;
-        s->n_chan = 8;
-        s->maxdata = (1 << 12) - 1;
-        s->range_table = &range_das16m1;
-        s->insn_read = das16m1_ai_rinsn;
+        s->type         = COMEDI_SUBD_AI;
+        s->subdev_flags = SDF_READABLE | SDF_DIFF;
+        s->n_chan       = 8;
+        s->maxdata      = 0x0fff;
+        s->range_table  = &range_das16m1;
+        s->insn_read    = das16m1_ai_insn_read;
         if (dev->irq) {
                 dev->read_subdev = s;
-                s->subdev_flags |= SDF_CMD_READ;
-                s->len_chanlist = 256;
-                s->do_cmdtest = das16m1_cmd_test;
-                s->do_cmd = das16m1_cmd_exec;
-                s->cancel = das16m1_cancel;
-                s->poll = das16m1_poll;
+                s->subdev_flags |= SDF_CMD_READ;
+                s->len_chanlist = 256;
+                s->do_cmdtest   = das16m1_ai_cmdtest;
+                s->do_cmd       = das16m1_ai_cmd;
+                s->cancel       = das16m1_ai_cancel;
+                s->poll         = das16m1_ai_poll;
+                s->munge        = das16m1_ai_munge;
         }
 
+        /* Digital Input subdevice */
         s = &dev->subdevices[1];
-        /* di */
-        s->type = COMEDI_SUBD_DI;
-        s->subdev_flags = SDF_READABLE;
-        s->n_chan = 4;
-        s->maxdata = 1;
-        s->range_table = &range_digital;
-        s->insn_bits = das16m1_di_rbits;
-
+        s->type         = COMEDI_SUBD_DI;
+        s->subdev_flags = SDF_READABLE;
+        s->n_chan       = 4;
+        s->maxdata      = 1;
+        s->range_table  = &range_digital;
+        s->insn_bits    = das16m1_di_insn_bits;
+
+        /* Digital Output subdevice */
         s = &dev->subdevices[2];
-        /* do */
-        s->type = COMEDI_SUBD_DO;
-        s->subdev_flags = SDF_WRITABLE;
-        s->n_chan = 4;
-        s->maxdata = 1;
-        s->range_table = &range_digital;
-        s->insn_bits = das16m1_do_wbits;
-
+        s->type         = COMEDI_SUBD_DO;
+        s->subdev_flags = SDF_WRITABLE;
+        s->n_chan       = 4;
+        s->maxdata      = 1;
+        s->range_table  = &range_digital;
+        s->insn_bits    = das16m1_do_insn_bits;
+
+        /* Digital I/O subdevice (8255) */
         s = &dev->subdevices[3];
-        /* 8255 */
-        ret = subdev_8255_init(dev, s, NULL, DAS16M1_82C55);
+        ret = subdev_8255_init(dev, s, NULL, DAS16M1_8255_IOBASE);
         if (ret)
                 return ret;
 
         /*  initialize digital output lines */
-        outb(0, dev->iobase + DAS16M1_DIO);
+        outb(0, dev->iobase + DAS16M1_DO_REG);
 
         /* set the interrupt level */
-        devpriv->control_state = das16m1_irq_bits(dev->irq) << 4;
-        outb(devpriv->control_state, dev->iobase + DAS16M1_INTR_CONTROL);
+        devpriv->intr_ctrl = DAS16M1_INTR_CTRL_IRQ(das16m1_irq_bits(dev->irq));
+        outb(devpriv->intr_ctrl, dev->iobase + DAS16M1_INTR_CTRL_REG);
 
         return 0;
 }
 
 static void das16m1_detach(struct comedi_device *dev)
 {
-        struct das16m1_private_struct *devpriv = dev->private;
+        struct das16m1_private *devpriv = dev->private;
 
         if (devpriv) {
                 if (devpriv->extra_iobase)
@@ -643,5 +627,5 @@ static struct comedi_driver das16m1_driver = {
 module_comedi_driver(das16m1_driver);
 
 MODULE_AUTHOR("Comedi http://www.comedi.org");
-MODULE_DESCRIPTION("Comedi low-level driver");
+MODULE_DESCRIPTION("Comedi driver for CIO-DAS16/M1 ISA cards");
 MODULE_LICENSE("GPL");
diff --git a/drivers/staging/comedi/drivers/das6402.c b/drivers/staging/comedi/drivers/das6402.c
index 1701294b79cd..0fdf5e02182f 100644
--- a/drivers/staging/comedi/drivers/das6402.c
+++ b/drivers/staging/comedi/drivers/das6402.c
@@ -50,48 +50,50 @@
 #define DAS6402_AO_LSB_REG(x)           (0x04 + ((x) * 2))
 #define DAS6402_AO_MSB_REG(x)           (0x05 + ((x) * 2))
 #define DAS6402_STATUS_REG              0x08
-#define DAS6402_STATUS_FFNE             (1 << 0)
-#define DAS6402_STATUS_FHALF            (1 << 1)
-#define DAS6402_STATUS_FFULL            (1 << 2)
-#define DAS6402_STATUS_XINT             (1 << 3)
-#define DAS6402_STATUS_INT              (1 << 4)
-#define DAS6402_STATUS_XTRIG            (1 << 5)
-#define DAS6402_STATUS_INDGT            (1 << 6)
-#define DAS6402_STATUS_10MHZ            (1 << 7)
-#define DAS6402_STATUS_W_CLRINT         (1 << 0)
-#define DAS6402_STATUS_W_CLRXTR         (1 << 1)
-#define DAS6402_STATUS_W_CLRXIN         (1 << 2)
-#define DAS6402_STATUS_W_EXTEND         (1 << 4)
-#define DAS6402_STATUS_W_ARMED          (1 << 5)
-#define DAS6402_STATUS_W_POSTMODE       (1 << 6)
-#define DAS6402_STATUS_W_10MHZ          (1 << 7)
+#define DAS6402_STATUS_FFNE             BIT(0)
+#define DAS6402_STATUS_FHALF            BIT(1)
+#define DAS6402_STATUS_FFULL            BIT(2)
+#define DAS6402_STATUS_XINT             BIT(3)
+#define DAS6402_STATUS_INT              BIT(4)
+#define DAS6402_STATUS_XTRIG            BIT(5)
+#define DAS6402_STATUS_INDGT            BIT(6)
+#define DAS6402_STATUS_10MHZ            BIT(7)
+#define DAS6402_STATUS_W_CLRINT         BIT(0)
+#define DAS6402_STATUS_W_CLRXTR         BIT(1)
+#define DAS6402_STATUS_W_CLRXIN         BIT(2)
+#define DAS6402_STATUS_W_EXTEND         BIT(4)
+#define DAS6402_STATUS_W_ARMED          BIT(5)
+#define DAS6402_STATUS_W_POSTMODE       BIT(6)
+#define DAS6402_STATUS_W_10MHZ          BIT(7)
 #define DAS6402_CTRL_REG                0x09
-#define DAS6402_CTRL_SOFT_TRIG          (0 << 0)
-#define DAS6402_CTRL_EXT_FALL_TRIG      (1 << 0)
-#define DAS6402_CTRL_EXT_RISE_TRIG      (2 << 0)
-#define DAS6402_CTRL_PACER_TRIG         (3 << 0)
-#define DAS6402_CTRL_BURSTEN            (1 << 2)
-#define DAS6402_CTRL_XINTE              (1 << 3)
+#define DAS6402_CTRL_TRIG(x)            ((x) << 0)
+#define DAS6402_CTRL_SOFT_TRIG          DAS6402_CTRL_TRIG(0)
+#define DAS6402_CTRL_EXT_FALL_TRIG      DAS6402_CTRL_TRIG(1)
+#define DAS6402_CTRL_EXT_RISE_TRIG      DAS6402_CTRL_TRIG(2)
+#define DAS6402_CTRL_PACER_TRIG         DAS6402_CTRL_TRIG(3)
+#define DAS6402_CTRL_BURSTEN            BIT(2)
+#define DAS6402_CTRL_XINTE              BIT(3)
 #define DAS6402_CTRL_IRQ(x)             ((x) << 4)
-#define DAS6402_CTRL_INTE               (1 << 7)
+#define DAS6402_CTRL_INTE               BIT(7)
 #define DAS6402_TRIG_REG                0x0a
-#define DAS6402_TRIG_TGEN               (1 << 0)
-#define DAS6402_TRIG_TGSEL              (1 << 1)
-#define DAS6402_TRIG_TGPOL              (1 << 2)
-#define DAS6402_TRIG_PRETRIG            (1 << 3)
+#define DAS6402_TRIG_TGEN               BIT(0)
+#define DAS6402_TRIG_TGSEL              BIT(1)
+#define DAS6402_TRIG_TGPOL              BIT(2)
+#define DAS6402_TRIG_PRETRIG            BIT(3)
 #define DAS6402_AO_RANGE(_chan, _range) ((_range) << ((_chan) ? 6 : 4))
 #define DAS6402_AO_RANGE_MASK(_chan)    (3 << ((_chan) ? 6 : 4))
 #define DAS6402_MODE_REG                0x0b
-#define DAS6402_MODE_RANGE(x)           ((x) << 0)
-#define DAS6402_MODE_POLLED             (0 << 2)
-#define DAS6402_MODE_FIFONEPTY          (1 << 2)
-#define DAS6402_MODE_FIFOHFULL          (2 << 2)
-#define DAS6402_MODE_EOB                (3 << 2)
-#define DAS6402_MODE_ENHANCED           (1 << 4)
-#define DAS6402_MODE_SE                 (1 << 5)
-#define DAS6402_MODE_UNI                (1 << 6)
-#define DAS6402_MODE_DMA1               (0 << 7)
-#define DAS6402_MODE_DMA3               (1 << 7)
+#define DAS6402_MODE_RANGE(x)           ((x) << 2)
+#define DAS6402_MODE_POLLED             DAS6402_MODE_RANGE(0)
+#define DAS6402_MODE_FIFONEPTY          DAS6402_MODE_RANGE(1)
+#define DAS6402_MODE_FIFOHFULL          DAS6402_MODE_RANGE(2)
+#define DAS6402_MODE_EOB                DAS6402_MODE_RANGE(3)
+#define DAS6402_MODE_ENHANCED           BIT(4)
+#define DAS6402_MODE_SE                 BIT(5)
+#define DAS6402_MODE_UNI                BIT(6)
+#define DAS6402_MODE_DMA(x)             ((x) << 7)
+#define DAS6402_MODE_DMA1               DAS6402_MODE_DMA(0)
+#define DAS6402_MODE_DMA3               DAS6402_MODE_DMA(1)
 #define DAS6402_TIMER_BASE              0x0c
 
 static const struct comedi_lrange das6402_ai_ranges = {
diff --git a/drivers/staging/comedi/drivers/das800.c b/drivers/staging/comedi/drivers/das800.c
index b02f12201cf7..fd4cb4911671 100644
--- a/drivers/staging/comedi/drivers/das800.c
+++ b/drivers/staging/comedi/drivers/das800.c
@@ -1,56 +1,56 @@
 /*
-    comedi/drivers/das800.c
-    Driver for Keitley das800 series boards and compatibles
-    Copyright (C) 2000 Frank Mori Hess <fmhess@users.sourceforge.net>
-
-    COMEDI - Linux Control and Measurement Device Interface
-    Copyright (C) 2000 David A. Schleef <ds@schleef.org>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-*/
+ * comedi/drivers/das800.c
+ * Driver for Keitley das800 series boards and compatibles
+ * Copyright (C) 2000 Frank Mori Hess <fmhess@users.sourceforge.net>
+ *
+ * COMEDI - Linux Control and Measurement Device Interface
+ * Copyright (C) 2000 David A. Schleef <ds@schleef.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
 /*
-Driver: das800
-Description: Keithley Metrabyte DAS800 (& compatibles)
-Author: Frank Mori Hess <fmhess@users.sourceforge.net>
-Devices: [Keithley Metrabyte] DAS-800 (das-800), DAS-801 (das-801),
-  DAS-802 (das-802),
-  [Measurement Computing] CIO-DAS800 (cio-das800),
-  CIO-DAS801 (cio-das801), CIO-DAS802 (cio-das802),
-  CIO-DAS802/16 (cio-das802/16)
-Status: works, cio-das802/16 untested - email me if you have tested it
-
-Configuration options:
-  [0] - I/O port base address
-  [1] - IRQ (optional, required for timed or externally triggered conversions)
-
-Notes:
-        IRQ can be omitted, although the cmd interface will not work without it.
-
-        All entries in the channel/gain list must use the same gain and be
-        consecutive channels counting upwards in channel number (these are
-        hardware limitations.)
-
-        I've never tested the gain setting stuff since I only have a
-        DAS-800 board with fixed gain.
-
-        The cio-das802/16 does not have a fifo-empty status bit!  Therefore
-        only fifo-half-full transfers are possible with this card.
-
-cmd triggers supported:
-        start_src:      TRIG_NOW | TRIG_EXT
-        scan_begin_src: TRIG_FOLLOW
-        scan_end_src:   TRIG_COUNT
-        convert_src:    TRIG_TIMER | TRIG_EXT
-        stop_src:       TRIG_NONE | TRIG_COUNT
-*/
+ * Driver: das800
+ * Description: Keithley Metrabyte DAS800 (& compatibles)
+ * Author: Frank Mori Hess <fmhess@users.sourceforge.net>
+ * Devices: [Keithley Metrabyte] DAS-800 (das-800), DAS-801 (das-801),
+ * DAS-802 (das-802),
+ * [Measurement Computing] CIO-DAS800 (cio-das800),
+ * CIO-DAS801 (cio-das801), CIO-DAS802 (cio-das802),
+ * CIO-DAS802/16 (cio-das802/16)
+ * Status: works, cio-das802/16 untested - email me if you have tested it
+ *
+ * Configuration options:
+ * [0] - I/O port base address
+ * [1] - IRQ (optional, required for timed or externally triggered conversions)
+ *
+ * Notes:
+ *      IRQ can be omitted, although the cmd interface will not work without it.
+ *
+ *      All entries in the channel/gain list must use the same gain and be
+ *      consecutive channels counting upwards in channel number (these are
+ *      hardware limitations.)
+ *
+ *      I've never tested the gain setting stuff since I only have a
+ *      DAS-800 board with fixed gain.
+ *
+ *      The cio-das802/16 does not have a fifo-empty status bit!  Therefore
+ *      only fifo-half-full transfers are possible with this card.
+ *
+ * cmd triggers supported:
+ *      start_src:      TRIG_NOW | TRIG_EXT
+ *      scan_begin_src: TRIG_FOLLOW
+ *      scan_end_src:   TRIG_COUNT
+ *      convert_src:    TRIG_TIMER | TRIG_EXT
+ *      stop_src:       TRIG_NONE | TRIG_COUNT
+ */
 
 #include <linux/module.h>
 #include <linux/interrupt.h>
@@ -218,7 +218,7 @@ struct das800_private {
 };
 
 static void das800_ind_write(struct comedi_device *dev,
-                             unsigned val, unsigned reg)
+                             unsigned int val, unsigned int reg)
 {
         /*
          * Select dev->iobase + 2 to be desired register
@@ -228,7 +228,7 @@ static void das800_ind_write(struct comedi_device *dev,
         outb(val, dev->iobase + 2);
 }
 
-static unsigned das800_ind_read(struct comedi_device *dev, unsigned reg)
+static unsigned int das800_ind_read(struct comedi_device *dev, unsigned int reg)
 {
         /*
          * Select dev->iobase + 7 to be desired register
diff --git a/drivers/staging/comedi/drivers/dmm32at.c b/drivers/staging/comedi/drivers/dmm32at.c
index 958c0d4aae5c..b8606ded0623 100644
--- a/drivers/staging/comedi/drivers/dmm32at.c
+++ b/drivers/staging/comedi/drivers/dmm32at.c
@@ -46,73 +46,75 @@
 #define DMM32AT_AI_START_CONV_REG       0x00
 #define DMM32AT_AI_LSB_REG              0x00
 #define DMM32AT_AUX_DOUT_REG            0x01
-#define DMM32AT_AUX_DOUT2               (1 << 2)  /* J3.42 - OUT2 (OUT2EN) */
-#define DMM32AT_AUX_DOUT1               (1 << 1)  /* J3.43 */
-#define DMM32AT_AUX_DOUT0               (1 << 0)  /* J3.44 - OUT0 (OUT0EN) */
+#define DMM32AT_AUX_DOUT2               BIT(2)  /* J3.42 - OUT2 (OUT2EN) */
+#define DMM32AT_AUX_DOUT1               BIT(1)  /* J3.43 */
+#define DMM32AT_AUX_DOUT0               BIT(0)  /* J3.44 - OUT0 (OUT0EN) */
 #define DMM32AT_AI_MSB_REG              0x01
 #define DMM32AT_AI_LO_CHAN_REG          0x02
 #define DMM32AT_AI_HI_CHAN_REG          0x03
 #define DMM32AT_AUX_DI_REG              0x04
-#define DMM32AT_AUX_DI_DACBUSY          (1 << 7)
-#define DMM32AT_AUX_DI_CALBUSY          (1 << 6)
-#define DMM32AT_AUX_DI3                 (1 << 3)  /* J3.45 - ADCLK (CLKSEL) */
-#define DMM32AT_AUX_DI2                 (1 << 2)  /* J3.46 - GATE12 (GT12EN) */
-#define DMM32AT_AUX_DI1                 (1 << 1)  /* J3.47 - GATE0 (GT0EN) */
-#define DMM32AT_AUX_DI0                 (1 << 0)  /* J3.48 - CLK0 (SRC0) */
+#define DMM32AT_AUX_DI_DACBUSY          BIT(7)
+#define DMM32AT_AUX_DI_CALBUSY          BIT(6)
+#define DMM32AT_AUX_DI3                 BIT(3)  /* J3.45 - ADCLK (CLKSEL) */
+#define DMM32AT_AUX_DI2                 BIT(2)  /* J3.46 - GATE12 (GT12EN) */
+#define DMM32AT_AUX_DI1                 BIT(1)  /* J3.47 - GATE0 (GT0EN) */
+#define DMM32AT_AUX_DI0                 BIT(0)  /* J3.48 - CLK0 (SRC0) */
 #define DMM32AT_AO_LSB_REG              0x04
 #define DMM32AT_AO_MSB_REG              0x05
 #define DMM32AT_AO_MSB_DACH(x)          ((x) << 6)
 #define DMM32AT_FIFO_DEPTH_REG          0x06
 #define DMM32AT_FIFO_CTRL_REG           0x07
-#define DMM32AT_FIFO_CTRL_FIFOEN        (1 << 3)
-#define DMM32AT_FIFO_CTRL_SCANEN        (1 << 2)
-#define DMM32AT_FIFO_CTRL_FIFORST       (1 << 1)
+#define DMM32AT_FIFO_CTRL_FIFOEN        BIT(3)
+#define DMM32AT_FIFO_CTRL_SCANEN        BIT(2)
+#define DMM32AT_FIFO_CTRL_FIFORST       BIT(1)
 #define DMM32AT_FIFO_STATUS_REG         0x07
-#define DMM32AT_FIFO_STATUS_EF          (1 << 7)
-#define DMM32AT_FIFO_STATUS_HF          (1 << 6)
-#define DMM32AT_FIFO_STATUS_FF          (1 << 5)
-#define DMM32AT_FIFO_STATUS_OVF         (1 << 4)
-#define DMM32AT_FIFO_STATUS_FIFOEN      (1 << 3)
-#define DMM32AT_FIFO_STATUS_SCANEN      (1 << 2)
+#define DMM32AT_FIFO_STATUS_EF          BIT(7)
+#define DMM32AT_FIFO_STATUS_HF          BIT(6)
+#define DMM32AT_FIFO_STATUS_FF          BIT(5)
+#define DMM32AT_FIFO_STATUS_OVF         BIT(4)
+#define DMM32AT_FIFO_STATUS_FIFOEN      BIT(3)
+#define DMM32AT_FIFO_STATUS_SCANEN      BIT(2)
 #define DMM32AT_FIFO_STATUS_PAGE_MASK   (3 << 0)
 #define DMM32AT_CTRL_REG                0x08
-#define DMM32AT_CTRL_RESETA             (1 << 5)
-#define DMM32AT_CTRL_RESETD             (1 << 4)
-#define DMM32AT_CTRL_INTRST             (1 << 3)
-#define DMM32AT_CTRL_PAGE_8254          (0 << 0)
-#define DMM32AT_CTRL_PAGE_8255          (1 << 0)
-#define DMM32AT_CTRL_PAGE_CALIB         (3 << 0)
+#define DMM32AT_CTRL_RESETA             BIT(5)
+#define DMM32AT_CTRL_RESETD             BIT(4)
+#define DMM32AT_CTRL_INTRST             BIT(3)
+#define DMM32AT_CTRL_PAGE(x)            ((x) << 0)
+#define DMM32AT_CTRL_PAGE_8254          DMM32AT_CTRL_PAGE(0)
+#define DMM32AT_CTRL_PAGE_8255          DMM32AT_CTRL_PAGE(1)
+#define DMM32AT_CTRL_PAGE_CALIB         DMM32AT_CTRL_PAGE(3)
 #define DMM32AT_AI_STATUS_REG           0x08
-#define DMM32AT_AI_STATUS_STS           (1 << 7)
-#define DMM32AT_AI_STATUS_SD1           (1 << 6)
-#define DMM32AT_AI_STATUS_SD0           (1 << 5)
+#define DMM32AT_AI_STATUS_STS           BIT(7)
+#define DMM32AT_AI_STATUS_SD1           BIT(6)
+#define DMM32AT_AI_STATUS_SD0           BIT(5)
 #define DMM32AT_AI_STATUS_ADCH_MASK     (0x1f << 0)
 #define DMM32AT_INTCLK_REG              0x09
-#define DMM32AT_INTCLK_ADINT            (1 << 7)
-#define DMM32AT_INTCLK_DINT             (1 << 6)
-#define DMM32AT_INTCLK_TINT             (1 << 5)
-#define DMM32AT_INTCLK_CLKEN            (1 << 1)  /* 1=see below  0=software */
-#define DMM32AT_INTCLK_CLKSEL           (1 << 0)  /* 1=OUT2  0=EXTCLK */
+#define DMM32AT_INTCLK_ADINT            BIT(7)
+#define DMM32AT_INTCLK_DINT             BIT(6)
+#define DMM32AT_INTCLK_TINT             BIT(5)
+#define DMM32AT_INTCLK_CLKEN            BIT(1)  /* 1=see below  0=software */
+#define DMM32AT_INTCLK_CLKSEL           BIT(0)  /* 1=OUT2  0=EXTCLK */
 #define DMM32AT_CTRDIO_CFG_REG          0x0a
-#define DMM32AT_CTRDIO_CFG_FREQ12       (1 << 7)  /* CLK12 1=100KHz 0=10MHz */
-#define DMM32AT_CTRDIO_CFG_FREQ0        (1 << 6)  /* CLK0  1=10KHz  0=10MHz */
-#define DMM32AT_CTRDIO_CFG_OUT2EN       (1 << 5)  /* J3.42 1=OUT2 is DOUT2 */
-#define DMM32AT_CTRDIO_CFG_OUT0EN       (1 << 4)  /* J3,44 1=OUT0 is DOUT0 */
-#define DMM32AT_CTRDIO_CFG_GT0EN        (1 << 2)  /* J3.47 1=DIN1 is GATE0 */
-#define DMM32AT_CTRDIO_CFG_SRC0         (1 << 1)  /* CLK0 is 0=FREQ0 1=J3.48 */
-#define DMM32AT_CTRDIO_CFG_GT12EN       (1 << 0)  /* J3.46 1=DIN2 is GATE12 */
+#define DMM32AT_CTRDIO_CFG_FREQ12       BIT(7)  /* CLK12 1=100KHz 0=10MHz */
+#define DMM32AT_CTRDIO_CFG_FREQ0        BIT(6)  /* CLK0  1=10KHz  0=10MHz */
+#define DMM32AT_CTRDIO_CFG_OUT2EN       BIT(5)  /* J3.42 1=OUT2 is DOUT2 */
+#define DMM32AT_CTRDIO_CFG_OUT0EN       BIT(4)  /* J3,44 1=OUT0 is DOUT0 */
+#define DMM32AT_CTRDIO_CFG_GT0EN        BIT(2)  /* J3.47 1=DIN1 is GATE0 */
+#define DMM32AT_CTRDIO_CFG_SRC0         BIT(1)  /* CLK0 is 0=FREQ0 1=J3.48 */
+#define DMM32AT_CTRDIO_CFG_GT12EN       BIT(0)  /* J3.46 1=DIN2 is GATE12 */
 #define DMM32AT_AI_CFG_REG              0x0b
-#define DMM32AT_AI_CFG_SCINT_20US       (0 << 4)
-#define DMM32AT_AI_CFG_SCINT_15US       (1 << 4)
-#define DMM32AT_AI_CFG_SCINT_10US       (2 << 4)
-#define DMM32AT_AI_CFG_SCINT_5US        (3 << 4)
-#define DMM32AT_AI_CFG_RANGE            (1 << 3)  /* 0=5V  1=10V */
-#define DMM32AT_AI_CFG_ADBU             (1 << 2)  /* 0=bipolar  1=unipolar */
+#define DMM32AT_AI_CFG_SCINT(x)         ((x) << 4)
+#define DMM32AT_AI_CFG_SCINT_20US       DMM32AT_AI_CFG_SCINT(0)
+#define DMM32AT_AI_CFG_SCINT_15US       DMM32AT_AI_CFG_SCINT(1)
+#define DMM32AT_AI_CFG_SCINT_10US       DMM32AT_AI_CFG_SCINT(2)
+#define DMM32AT_AI_CFG_SCINT_5US        DMM32AT_AI_CFG_SCINT(3)
+#define DMM32AT_AI_CFG_RANGE            BIT(3)  /* 0=5V  1=10V */
+#define DMM32AT_AI_CFG_ADBU             BIT(2)  /* 0=bipolar  1=unipolar */
 #define DMM32AT_AI_CFG_GAIN(x)          ((x) << 0)
 #define DMM32AT_AI_READBACK_REG         0x0b
-#define DMM32AT_AI_READBACK_WAIT        (1 << 7)  /* DMM32AT_AI_STATUS_STS */
-#define DMM32AT_AI_READBACK_RANGE       (1 << 3)
-#define DMM32AT_AI_READBACK_ADBU        (1 << 2)
+#define DMM32AT_AI_READBACK_WAIT        BIT(7)  /* DMM32AT_AI_STATUS_STS */
+#define DMM32AT_AI_READBACK_RANGE       BIT(3)
+#define DMM32AT_AI_READBACK_ADBU        BIT(2)
 #define DMM32AT_AI_READBACK_GAIN_MASK   (3 << 0)
 
 #define DMM32AT_CLK1 0x0d
diff --git a/drivers/staging/comedi/drivers/dt2801.c b/drivers/staging/comedi/drivers/dt2801.c
index 6c7b4d27c27c..c2ce1eb87385 100644
--- a/drivers/staging/comedi/drivers/dt2801.c
+++ b/drivers/staging/comedi/drivers/dt2801.c
@@ -4,30 +4,30 @@
  *
  */
 /*
-Driver: dt2801
-Description: Data Translation DT2801 series and DT01-EZ
-Author: ds
-Status: works
-Devices: [Data Translation] DT2801 (dt2801), DT2801-A, DT2801/5716A,
-  DT2805, DT2805/5716A, DT2808, DT2818, DT2809, DT01-EZ
-
-This driver can autoprobe the type of board.
-
-Configuration options:
-  [0] - I/O port base address
-  [1] - unused
-  [2] - A/D reference 0=differential, 1=single-ended
-  [3] - A/D range
-          0 = [-10, 10]
-          1 = [0,10]
-  [4] - D/A 0 range
-          0 = [-10, 10]
-          1 = [-5,5]
-          2 = [-2.5,2.5]
-          3 = [0,10]
-          4 = [0,5]
-  [5] - D/A 1 range (same choices)
-*/
+ * Driver: dt2801
+ * Description: Data Translation DT2801 series and DT01-EZ
+ * Author: ds
+ * Status: works
+ * Devices: [Data Translation] DT2801 (dt2801), DT2801-A, DT2801/5716A,
+ * DT2805, DT2805/5716A, DT2808, DT2818, DT2809, DT01-EZ
+ *
+ * This driver can autoprobe the type of board.
+ *
+ * Configuration options:
+ * [0] - I/O port base address
+ * [1] - unused
+ * [2] - A/D reference 0=differential, 1=single-ended
+ * [3] - A/D range
+ *        0 = [-10, 10]
+ *        1 = [0,10]
+ * [4] - D/A 0 range
+ *        0 = [-10, 10]
+ *        1 = [-5,5]
+ *        2 = [-2.5,2.5]
+ *        3 = [0,10]
+ *        4 = [0,5]
+ * [5] - D/A 1 range (same choices)
+ */
 
 #include <linux/module.h>
 #include "../comedidev.h"
@@ -65,9 +65,10 @@ Configuration options:
 #define DT_C_SET_AD      0xd
 #define DT_C_READ_AD     0xe
 
-/* Command modifiers (only used with read/write), EXTTRIG can be
-   used with some other commands.
-*/
+/*
+ * Command modifiers (only used with read/write), EXTTRIG can be
+ * used with some other commands.
+ */
 #define DT_MOD_DMA     BIT(4)
 #define DT_MOD_CONT    BIT(5)
 #define DT_MOD_EXTCLK  BIT(6)
@@ -135,9 +136,10 @@ struct dt2801_board {
         int dabits;
 };
 
-/* Typeid's for the different boards of the DT2801-series
-   (taken from the test-software, that comes with the board)
-   */
+/*
+ * Typeid's for the different boards of the DT2801-series
+ * (taken from the test-software, that comes with the board)
+ */
 static const struct dt2801_board boardtypes[] = {
         {
          .name = "dt2801",
@@ -209,15 +211,18 @@ struct dt2801_private {
         const struct comedi_lrange *dac_range_types[2];
 };
 
-/* These are the low-level routines:
-   writecommand: write a command to the board
-   writedata: write data byte
-   readdata: read data byte
+/*
+ * These are the low-level routines:
+ * writecommand: write a command to the board
+ * writedata: write data byte
+ * readdata: read data byte
  */
 
-/* Only checks DataOutReady-flag, not the Ready-flag as it is done
-   in the examples of the manual. I don't see why this should be
-   necessary. */
+/*
+ * Only checks DataOutReady-flag, not the Ready-flag as it is done
+ *  in the examples of the manual. I don't see why this should be
+ *  necessary.
+ */
 static int dt2801_readdata(struct comedi_device *dev, int *data)
 {
         int stat = 0;
@@ -517,14 +522,14 @@ static int dt2801_dio_insn_config(struct comedi_device *dev,
 }
 
 /*
-   options:
-        [0] - i/o base
-        [1] - unused
-        [2] - a/d 0=differential, 1=single-ended
-        [3] - a/d range 0=[-10,10], 1=[0,10]
-        [4] - dac0 range 0=[-10,10], 1=[-5,5], 2=[-2.5,2.5] 3=[0,10], 4=[0,5]
-        [5] - dac1 range 0=[-10,10], 1=[-5,5], 2=[-2.5,2.5] 3=[0,10], 4=[0,5]
-*/
+ * options:
+ *      [0] - i/o base
+ *      [1] - unused
+ *      [2] - a/d 0=differential, 1=single-ended
+ *      [3] - a/d range 0=[-10,10], 1=[0,10]
+ *      [4] - dac0 range 0=[-10,10], 1=[-5,5], 2=[-2.5,2.5] 3=[0,10], 4=[0,5]
+ *      [5] - dac1 range 0=[-10,10], 1=[-5,5], 2=[-2.5,2.5] 3=[0,10], 4=[0,5]
+ */
 static int dt2801_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 {
         const struct dt2801_board *board;
diff --git a/drivers/staging/comedi/drivers/dt2811.c b/drivers/staging/comedi/drivers/dt2811.c
index a80773291fdc..904f637797b6 100644
--- a/drivers/staging/comedi/drivers/dt2811.c
+++ b/drivers/staging/comedi/drivers/dt2811.c
@@ -1,224 +1,469 @@
 /*
-   comedi/drivers/dt2811.c
-   Hardware driver for Data Translation DT2811
-
-   COMEDI - Linux Control and Measurement Device Interface
-   History:
-   Base Version  - David A. Schleef <ds@schleef.org>
-   December 1998 - Updated to work.  David does not have a DT2811
-   board any longer so this was suffering from bitrot.
-   Updated performed by ...
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
+ * Comedi driver for Data Translation DT2811
+ *
+ * COMEDI - Linux Control and Measurement Device Interface
+ * Copyright (C) David A. Schleef <ds@schleef.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  */
+
 /*
-Driver: dt2811
-Description: Data Translation DT2811
-Author: ds
-Devices: [Data Translation] DT2811-PGL (dt2811-pgl), DT2811-PGH (dt2811-pgh)
-Status: works
-
-Configuration options:
-  [0] - I/O port base address
-  [1] - IRQ, although this is currently unused
-  [2] - A/D reference
-          0 = signle-ended
-          1 = differential
-          2 = pseudo-differential (common reference)
-  [3] - A/D range
-          0 = [-5, 5]
-          1 = [-2.5, 2.5]
-          2 = [0, 5]
-  [4] - D/A 0 range (same choices)
-  [4] - D/A 1 range (same choices)
-*/
+ * Driver: dt2811
+ * Description: Data Translation DT2811
+ * Author: ds
+ * Devices: [Data Translation] DT2811-PGL (dt2811-pgl), DT2811-PGH (dt2811-pgh)
+ * Status: works
+ *
+ * Configuration options:
+ *   [0] - I/O port base address
+ *   [1] - IRQ (optional, needed for async command support)
+ *   [2] - A/D reference (# of analog inputs)
+ *         0 = single-ended (16 channels)
+ *         1 = differential (8 channels)
+ *         2 = pseudo-differential (16 channels)
+ *   [3] - A/D range (deprecated, see below)
+ *   [4] - D/A 0 range (deprecated, see below)
+ *   [5] - D/A 1 range (deprecated, see below)
+ *
+ * Notes:
+ *   - A/D ranges are not programmable but the gain is. The AI subdevice has
+ *     a range_table containing all the possible analog input range/gain
+ *     options for the dt2811-pgh or dt2811-pgl. Use the range that matches
+ *     your board configuration and the desired gain to correctly convert
+ *     between data values and physical units and to set the correct output
+ *     gain.
+ *   - D/A ranges are not programmable. The AO subdevice has a range_table
+ *     containing all the possible analog output ranges. Use the range
+ *     that matches your board configuration to convert between data
+ *     values and physical units.
+ */
 
 #include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+
 #include "../comedidev.h"
 
-static const struct comedi_lrange range_dt2811_pgh_ai_5_unipolar = {
-        4, {
-                UNI_RANGE(5),
-                UNI_RANGE(2.5),
-                UNI_RANGE(1.25),
-                UNI_RANGE(0.625)
-        }
+/*
+ * Register I/O map
+ */
+#define DT2811_ADCSR_REG                0x00    /* r/w  A/D Control/Status */
+#define DT2811_ADCSR_ADDONE             BIT(7)  /* r      1=A/D conv done */
+#define DT2811_ADCSR_ADERROR            BIT(6)  /* r      1=A/D error */
+#define DT2811_ADCSR_ADBUSY             BIT(5)  /* r      1=A/D busy */
+#define DT2811_ADCSR_CLRERROR           BIT(4)
+#define DT2811_ADCSR_DMAENB             BIT(3)  /* r/w    1=dma ena */
+#define DT2811_ADCSR_INTENB             BIT(2)  /* r/w    1=interupts ena */
+#define DT2811_ADCSR_ADMODE(x)          (((x) & 0x3) << 0)
+
+#define DT2811_ADGCR_REG                0x01    /* r/w  A/D Gain/Channel */
+#define DT2811_ADGCR_GAIN(x)            (((x) & 0x3) << 6)
+#define DT2811_ADGCR_CHAN(x)            (((x) & 0xf) << 0)
+
+#define DT2811_ADDATA_LO_REG            0x02    /* r   A/D Data low byte */
+#define DT2811_ADDATA_HI_REG            0x03    /* r   A/D Data high byte */
+
+#define DT2811_DADATA_LO_REG(x)         (0x02 + ((x) * 2)) /* w D/A Data low */
+#define DT2811_DADATA_HI_REG(x)         (0x03 + ((x) * 2)) /* w D/A Data high */
+
+#define DT2811_DI_REG                   0x06    /* r   Digital Input Port 0 */
+#define DT2811_DO_REG                   0x06    /* w   Digital Output Port 1 */
+
+#define DT2811_TMRCTR_REG               0x07    /* r/w  Timer/Counter */
+#define DT2811_TMRCTR_MANTISSA(x)       (((x) & 0x7) << 3)
+#define DT2811_TMRCTR_EXPONENT(x)       (((x) & 0x7) << 0)
+
+#define DT2811_OSC_BASE                 1666    /* 600 kHz = 1666.6667ns */
+
+/*
+ * Timer frequency control:
+ *   DT2811_TMRCTR_MANTISSA     DT2811_TMRCTR_EXPONENT
+ *   val  divisor  frequency    val  multiply divisor/divide frequency by
+ *    0      1      600 kHz      0   1
+ *    1     10       60 kHz      1   10
+ *    2      2      300 kHz      2   100
+ *    3      3      200 kHz      3   1000
+ *    4      4      150 kHz      4   10000
+ *    5      5      120 kHz      5   100000
+ *    6      6      100 kHz      6   1000000
+ *    7     12       50 kHz      7   10000000
+ */
+const unsigned int dt2811_clk_dividers[] = {
+        1, 10, 2, 3, 4, 5, 6, 12
 };
 
-static const struct comedi_lrange range_dt2811_pgh_ai_2_5_bipolar = {
-        4, {
-                BIP_RANGE(2.5),
-                BIP_RANGE(1.25),
-                BIP_RANGE(0.625),
-                BIP_RANGE(0.3125)
-        }
+const unsigned int dt2811_clk_multipliers[] = {
+        1, 10, 100, 1000, 10000, 100000, 1000000, 10000000
 };
 
-static const struct comedi_lrange range_dt2811_pgh_ai_5_bipolar = {
-        4, {
-                BIP_RANGE(5),
-                BIP_RANGE(2.5),
-                BIP_RANGE(1.25),
-                BIP_RANGE(0.625)
+/*
+ * The Analog Input range is set using jumpers on the board.
+ *
+ * Input Range          W9  W10
+ * -5V to +5V           In  Out
+ * -2.5V to +2.5V       In  In
+ * 0V to +5V            Out In
+ *
+ * The gain may be set to 1, 2, 4, or 8 (on the dt2811-pgh) or to
+ * 1, 10, 100, 500 (on the dt2811-pgl).
+ */
+static const struct comedi_lrange dt2811_pgh_ai_ranges = {
+        12, {
+                BIP_RANGE(5),           /* range 0: gain=1 */
+                BIP_RANGE(2.5),         /* range 1: gain=2 */
+                BIP_RANGE(1.25),        /* range 2: gain=4 */
+                BIP_RANGE(0.625),       /* range 3: gain=8 */
+
+                BIP_RANGE(2.5),         /* range 0+4: gain=1 */
+                BIP_RANGE(1.25),        /* range 1+4: gain=2 */
+                BIP_RANGE(0.625),       /* range 2+4: gain=4 */
+                BIP_RANGE(0.3125),      /* range 3+4: gain=8 */
+
+                UNI_RANGE(5),           /* range 0+8: gain=1 */
+                UNI_RANGE(2.5),         /* range 1+8: gain=2 */
+                UNI_RANGE(1.25),        /* range 2+8: gain=4 */
+                UNI_RANGE(0.625)        /* range 3+8: gain=8 */
         }
 };
 
-static const struct comedi_lrange range_dt2811_pgl_ai_5_unipolar = {
-        4, {
-                UNI_RANGE(5),
-                UNI_RANGE(0.5),
-                UNI_RANGE(0.05),
-                UNI_RANGE(0.01)
+static const struct comedi_lrange dt2811_pgl_ai_ranges = {
+        12, {
+                BIP_RANGE(5),           /* range 0: gain=1 */
+                BIP_RANGE(0.5),         /* range 1: gain=10 */
+                BIP_RANGE(0.05),        /* range 2: gain=100 */
+                BIP_RANGE(0.01),        /* range 3: gain=500 */
+
+                BIP_RANGE(2.5),         /* range 0+4: gain=1 */
+                BIP_RANGE(0.25),        /* range 1+4: gain=10 */
+                BIP_RANGE(0.025),       /* range 2+4: gain=100 */
+                BIP_RANGE(0.005),       /* range 3+4: gain=500 */
+
+                UNI_RANGE(5),           /* range 0+8: gain=1 */
+                UNI_RANGE(0.5),         /* range 1+8: gain=10 */
+                UNI_RANGE(0.05),        /* range 2+8: gain=100 */
+                UNI_RANGE(0.01)         /* range 3+8: gain=500 */
         }
 };
 
-static const struct comedi_lrange range_dt2811_pgl_ai_2_5_bipolar = {
-        4, {
+/*
+ * The Analog Output range is set per-channel using jumpers on the board.
+ *
+ *                      DAC0 Jumpers            DAC1 Jumpers
+ * Output Range         W5  W6  W7  W8          W1  W2  W3  W4
+ * -5V to +5V           In  Out In  Out         In  Out In  Out
+ * -2.5V to +2.5V       In  Out Out In          In  Out Out In
+ * 0 to +5V             Out In  Out In          Out In  Out In
+ */
+static const struct comedi_lrange dt2811_ao_ranges = {
+        3, {
+                BIP_RANGE(5),   /* default setting from factory */
                 BIP_RANGE(2.5),
-                BIP_RANGE(0.25),
-                BIP_RANGE(0.025),
-                BIP_RANGE(0.005)
+                UNI_RANGE(5)
         }
 };
 
-static const struct comedi_lrange range_dt2811_pgl_ai_5_bipolar = {
-        4, {
-                BIP_RANGE(5),
-                BIP_RANGE(0.5),
-                BIP_RANGE(0.05),
-                BIP_RANGE(0.01)
-        }
+struct dt2811_board {
+        const char *name;
+        unsigned int is_pgh:1;
 };
 
-/*
+static const struct dt2811_board dt2811_boards[] = {
+        {
+                .name           = "dt2811-pgh",
+                .is_pgh         = 1,
+        }, {
+                .name           = "dt2811-pgl",
+        },
+};
 
-   0x00    ADCSR R/W  A/D Control/Status Register
-   bit 7 - (R) 1 indicates A/D conversion done
-   reading ADDAT clears bit
-   (W) ignored
-   bit 6 - (R) 1 indicates A/D error
-   (W) ignored
-   bit 5 - (R) 1 indicates A/D busy, cleared at end
-   of conversion
-   (W) ignored
-   bit 4 - (R) 0
-   (W)
-   bit 3 - (R) 0
-   bit 2 - (R/W) 1 indicates interrupts enabled
-   bits 1,0 - (R/W) mode bits
-   00  single conversion on ADGCR load
-   01  continuous conversion, internal clock,
-   (clock enabled on ADGCR load)
-   10  continuous conversion, internal clock,
-   external trigger
-   11  continuous conversion, external clock,
-   external trigger
-
-   0x01    ADGCR R/W A/D Gain/Channel Register
-   bit 6,7 - (R/W) gain select
-   00  gain=1, both PGH, PGL models
-   01  gain=2 PGH, 10 PGL
-   10  gain=4 PGH, 100 PGL
-   11  gain=8 PGH, 500 PGL
-   bit 4,5 - reserved
-   bit 3-0 - (R/W) channel select
-   channel number from 0-15
-
-   0x02,0x03 (R) ADDAT A/D Data Register
-   (W) DADAT0 D/A Data Register 0
-   0x02 low byte
-   0x03 high byte
-
-   0x04,0x05 (W) DADAT0 D/A Data Register 1
-
-   0x06 (R) DIO0 Digital Input Port 0
-   (W) DIO1 Digital Output Port 1
-
-   0x07 TMRCTR (R/W) Timer/Counter Register
-   bits 6,7 - reserved
-   bits 5-3 - Timer frequency control (mantissa)
-   543  divisor  freqency (kHz)
-   000  1        600
-   001  10       60
-   010  2        300
-   011  3        200
-   100  4        150
-   101  5        120
-   110  6        100
-   111  12       50
-   bits 2-0 - Timer frequency control (exponent)
-   210  multiply divisor/divide frequency by
-   000  1
-   001  10
-   010  100
-   011  1000
-   100  10000
-   101  100000
-   110  1000000
-   111  10000000
+struct dt2811_private {
+        unsigned int ai_divisor;
+};
 
- */
+static unsigned int dt2811_ai_read_sample(struct comedi_device *dev,
+                                          struct comedi_subdevice *s)
+{
+        unsigned int val;
 
-#define TIMEOUT 10000
+        val = inb(dev->iobase + DT2811_ADDATA_LO_REG) |
+              (inb(dev->iobase + DT2811_ADDATA_HI_REG) << 8);
 
-#define DT2811_ADCSR 0
-#define DT2811_ADGCR 1
-#define DT2811_ADDATLO 2
-#define DT2811_ADDATHI 3
-#define DT2811_DADAT0LO 2
-#define DT2811_DADAT0HI 3
-#define DT2811_DADAT1LO 4
-#define DT2811_DADAT1HI 5
-#define DT2811_DIO 6
-#define DT2811_TMRCTR 7
+        return val & s->maxdata;
+}
 
-/*
- * flags
- */
+static irqreturn_t dt2811_interrupt(int irq, void *d)
+{
+        struct comedi_device *dev = d;
+        struct comedi_subdevice *s = dev->read_subdev;
+        struct comedi_async *async = s->async;
+        struct comedi_cmd *cmd = &async->cmd;
+        unsigned int status;
 
-/* ADCSR */
+        if (!dev->attached)
+                return IRQ_NONE;
 
-#define DT2811_ADDONE   0x80
-#define DT2811_ADERROR  0x40
-#define DT2811_ADBUSY   0x20
-#define DT2811_CLRERROR 0x10
-#define DT2811_INTENB   0x04
-#define DT2811_ADMODE   0x03
+        status = inb(dev->iobase + DT2811_ADCSR_REG);
 
-struct dt2811_board {
-        const char *name;
-        const struct comedi_lrange *bip_5;
-        const struct comedi_lrange *bip_2_5;
-        const struct comedi_lrange *unip_5;
-};
+        if (status & DT2811_ADCSR_ADERROR) {
+                async->events |= COMEDI_CB_OVERFLOW;
 
-enum { card_2811_pgh, card_2811_pgl };
+                outb(status | DT2811_ADCSR_CLRERROR,
+                     dev->iobase + DT2811_ADCSR_REG);
+        }
 
-struct dt2811_private {
-        int ntrig;
-        int curadchan;
-        enum {
-                adc_singleended, adc_diff, adc_pseudo_diff
-        } adc_mux;
-        enum {
-                dac_bipolar_5, dac_bipolar_2_5, dac_unipolar_5
-        } dac_range[2];
-        const struct comedi_lrange *range_type_list[2];
-};
+        if (status & DT2811_ADCSR_ADDONE) {
+                unsigned short val;
 
-static const struct comedi_lrange *dac_range_types[] = {
-        &range_bipolar5,
-        &range_bipolar2_5,
-        &range_unipolar5
-};
+                val = dt2811_ai_read_sample(dev, s);
+                comedi_buf_write_samples(s, &val, 1);
+        }
+
+        if (cmd->stop_src == TRIG_COUNT && async->scans_done >= cmd->stop_arg)
+                async->events |= COMEDI_CB_EOA;
+
+        comedi_handle_events(dev, s);
+
+        return IRQ_HANDLED;
+}
+
+static int dt2811_ai_cancel(struct comedi_device *dev,
+                            struct comedi_subdevice *s)
+{
+        /*
+         * Mode 0
+         * Single conversion
+         *
+         * Loading a chanspec will trigger a conversion.
+         */
+        outb(DT2811_ADCSR_ADMODE(0), dev->iobase + DT2811_ADCSR_REG);
+
+        return 0;
+}
+
+static void dt2811_ai_set_chanspec(struct comedi_device *dev,
+                                   unsigned int chanspec)
+{
+        unsigned int chan = CR_CHAN(chanspec);
+        unsigned int range = CR_RANGE(chanspec);
+
+        outb(DT2811_ADGCR_CHAN(chan) | DT2811_ADGCR_GAIN(range),
+             dev->iobase + DT2811_ADGCR_REG);
+}
+
+static int dt2811_ai_cmd(struct comedi_device *dev,
+                         struct comedi_subdevice *s)
+{
+        struct dt2811_private *devpriv = dev->private;
+        struct comedi_cmd *cmd = &s->async->cmd;
+        unsigned int mode;
+
+        if (cmd->start_src == TRIG_NOW) {
+                /*
+                 * Mode 1
+                 * Continuous conversion, internal trigger and clock
+                 *
+                 * This resets the trigger flip-flop, disabling A/D strobes.
+                 * The timer/counter register is loaded with the division
+                 * ratio which will give the required sample rate.
+                 *
+                 * Loading the first chanspec sets the trigger flip-flop,
+                 * enabling the timer/counter. A/D strobes are then generated
+                 * at the rate set by the internal clock/divider.
+                 */
+                mode = DT2811_ADCSR_ADMODE(1);
+        } else { /* TRIG_EXT */
+                if (cmd->convert_src == TRIG_TIMER) {
+                        /*
+                         * Mode 2
+                         * Continuous conversion, external trigger
+                         *
+                         * Similar to Mode 1, with the exception that the
+                         * trigger flip-flop must be set by a negative edge
+                         * on the external trigger input.
+                         */
+                        mode = DT2811_ADCSR_ADMODE(2);
+                } else { /* TRIG_EXT */
+                        /*
+                         * Mode 3
+                         * Continuous conversion, external trigger, clock
+                         *
+                         * Similar to Mode 2, with the exception that the
+                         * conversion rate is set by the frequency on the
+                         * external clock/divider.
+                         */
+                        mode = DT2811_ADCSR_ADMODE(3);
+                }
+        }
+        outb(mode | DT2811_ADCSR_INTENB, dev->iobase + DT2811_ADCSR_REG);
+
+        /* load timer */
+        outb(devpriv->ai_divisor, dev->iobase + DT2811_TMRCTR_REG);
+
+        /* load chanspec - enables timer */
+        dt2811_ai_set_chanspec(dev, cmd->chanlist[0]);
+
+        return 0;
+}
+
+static unsigned int dt2811_ns_to_timer(unsigned int *nanosec,
+                                       unsigned int flags)
+{
+        unsigned long long ns = *nanosec;
+        unsigned int ns_lo = COMEDI_MIN_SPEED;
+        unsigned int ns_hi = 0;
+        unsigned int divisor_hi = 0;
+        unsigned int divisor_lo = 0;
+        unsigned int _div;
+        unsigned int _mult;
+
+        /*
+         * Work through all the divider/multiplier values to find the two
+         * closest divisors to generate the requested nanosecond timing.
+         */
+        for (_div = 0; _div <= 7; _div++) {
+                for (_mult = 0; _mult <= 7; _mult++) {
+                        unsigned int div = dt2811_clk_dividers[_div];
+                        unsigned int mult = dt2811_clk_multipliers[_mult];
+                        unsigned long long divider = div * mult;
+                        unsigned int divisor = DT2811_TMRCTR_MANTISSA(_div) |
+                                               DT2811_TMRCTR_EXPONENT(_mult);
+
+                        /*
+                         * The timer can be configured to run at a slowest
+                         * speed of 0.005hz (600 Khz/120000000), which requires
+                         * 37-bits to represent the nanosecond value. Limit the
+                         * slowest timing to what comedi handles (32-bits).
+                         */
+                        ns = divider * DT2811_OSC_BASE;
+                        if (ns > COMEDI_MIN_SPEED)
+                                continue;
+
+                        /* Check for fastest found timing */
+                        if (ns <= *nanosec && ns > ns_hi) {
+                                ns_hi = ns;
+                                divisor_hi = divisor;
+                        }
+                        /* Check for slowest found timing */
+                        if (ns >= *nanosec && ns < ns_lo) {
+                                ns_lo = ns;
+                                divisor_lo = divisor;
+                        }
+                }
+        }
+
+        /*
+         * The slowest found timing will be invalid if the requested timing
+         * is faster than what can be generated by the timer. Fix it so that
+         * CMDF_ROUND_UP returns valid timing.
+         */
+        if (ns_lo == COMEDI_MIN_SPEED) {
+                ns_lo = ns_hi;
+                divisor_lo = divisor_hi;
+        }
+        /*
+         * The fastest found timing will be invalid if the requested timing
+         * is less than what can be generated by the timer. Fix it so that
+         * CMDF_ROUND_NEAREST and CMDF_ROUND_DOWN return valid timing.
+         */
+        if (ns_hi == 0) {
+                ns_hi = ns_lo;
+                divisor_hi = divisor_lo;
+        }
+
+        switch (flags & CMDF_ROUND_MASK) {
+        case CMDF_ROUND_NEAREST:
+        default:
+                if (ns_hi - *nanosec < *nanosec - ns_lo) {
+                        *nanosec = ns_lo;
+                        return divisor_lo;
+                }
+                *nanosec = ns_hi;
+                return divisor_hi;
+        case CMDF_ROUND_UP:
+                *nanosec = ns_lo;
+                return divisor_lo;
+        case CMDF_ROUND_DOWN:
+                *nanosec = ns_hi;
+                return divisor_hi;
+        }
+}
+
+static int dt2811_ai_cmdtest(struct comedi_device *dev,
+                             struct comedi_subdevice *s,
+                             struct comedi_cmd *cmd)
+{
+        struct dt2811_private *devpriv = dev->private;
+        unsigned int arg;
+        int err = 0;
+
+        /* Step 1 : check if triggers are trivially valid */
+
+        err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
+        err |= comedi_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
+        err |= comedi_check_trigger_src(&cmd->convert_src,
+                                        TRIG_TIMER | TRIG_EXT);
+        err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
+        err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
+
+        if (err)
+                return 1;
+
+        /* Step 2a : make sure trigger sources are unique */
+
+        err |= comedi_check_trigger_is_unique(cmd->start_src);
+        err |= comedi_check_trigger_is_unique(cmd->convert_src);
+        err |= comedi_check_trigger_is_unique(cmd->stop_src);
+
+        /* Step 2b : and mutually compatible */
+
+        if (cmd->convert_src == TRIG_EXT && cmd->start_src != TRIG_EXT)
+                err |= -EINVAL;
+
+        if (err)
+                return 2;
+
+        /* Step 3: check if arguments are trivially valid */
+
+        err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
+        err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
+        if (cmd->convert_src == TRIG_TIMER)
+                err |= comedi_check_trigger_arg_min(&cmd->convert_arg, 12500);
+        err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
+                                           cmd->chanlist_len);
+        if (cmd->stop_src == TRIG_COUNT)
+                err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
+        else    /* TRIG_NONE */
+                err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
+
+        if (err)
+                return 3;
+
+        /* Step 4: fix up any arguments */
+
+        if (cmd->convert_src == TRIG_TIMER) {
+                arg = cmd->convert_arg;
+                devpriv->ai_divisor = dt2811_ns_to_timer(&arg, cmd->flags);
+                err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
+        } else { /* TRIG_EXT */
+                /* The convert_arg is used to set the divisor. */
+                devpriv->ai_divisor = cmd->convert_arg;
+        }
+
+        if (err)
+                return 4;
+
+        /* Step 5: check channel list if it exists */
+
+        return 0;
+}
 
 static int dt2811_ai_eoc(struct comedi_device *dev,
                          struct comedi_subdevice *s,
@@ -227,32 +472,33 @@ static int dt2811_ai_eoc(struct comedi_device *dev,
 {
         unsigned int status;
 
-        status = inb(dev->iobase + DT2811_ADCSR);
-        if ((status & DT2811_ADBUSY) == 0)
+        status = inb(dev->iobase + DT2811_ADCSR_REG);
+        if ((status & DT2811_ADCSR_ADBUSY) == 0)
                 return 0;
         return -EBUSY;
 }
 
-static int dt2811_ai_insn(struct comedi_device *dev, struct comedi_subdevice *s,
-                          struct comedi_insn *insn, unsigned int *data)
+static int dt2811_ai_insn_read(struct comedi_device *dev,
+                               struct comedi_subdevice *s,
+                               struct comedi_insn *insn,
+                               unsigned int *data)
 {
-        int chan = CR_CHAN(insn->chanspec);
         int ret;
         int i;
 
+        /* We will already be in Mode 0 */
         for (i = 0; i < insn->n; i++) {
-                outb(chan, dev->iobase + DT2811_ADGCR);
+                /* load chanspec and trigger conversion */
+                dt2811_ai_set_chanspec(dev, insn->chanspec);
 
                 ret = comedi_timeout(dev, s, insn, dt2811_ai_eoc, 0);
                 if (ret)
                         return ret;
 
-                data[i] = inb(dev->iobase + DT2811_ADDATLO);
-                data[i] |= inb(dev->iobase + DT2811_ADDATHI) << 8;
-                data[i] &= 0xfff;
+                data[i] = dt2811_ai_read_sample(dev, s);
         }
 
-        return i;
+        return insn->n;
 }
 
 static int dt2811_ao_insn_write(struct comedi_device *dev,
@@ -266,9 +512,9 @@ static int dt2811_ao_insn_write(struct comedi_device *dev,
 
         for (i = 0; i < insn->n; i++) {
                 val = data[i];
-                outb(val & 0xff, dev->iobase + DT2811_DADAT0LO + 2 * chan);
+                outb(val & 0xff, dev->iobase + DT2811_DADATA_LO_REG(chan));
                 outb((val >> 8) & 0xff,
-                     dev->iobase + DT2811_DADAT0HI + 2 * chan);
+                     dev->iobase + DT2811_DADATA_HI_REG(chan));
         }
         s->readback[chan] = val;
 
@@ -277,9 +523,10 @@ static int dt2811_ao_insn_write(struct comedi_device *dev,
 
 static int dt2811_di_insn_bits(struct comedi_device *dev,
                                struct comedi_subdevice *s,
-                               struct comedi_insn *insn, unsigned int *data)
+                               struct comedi_insn *insn,
+                               unsigned int *data)
 {
-        data[1] = inb(dev->iobase + DT2811_DIO);
+        data[1] = inb(dev->iobase + DT2811_DI_REG);
 
         return insn->n;
 }
@@ -290,185 +537,118 @@ static int dt2811_do_insn_bits(struct comedi_device *dev,
                                unsigned int *data)
 {
         if (comedi_dio_update_state(s, data))
-                outb(s->state, dev->iobase + DT2811_DIO);
+                outb(s->state, dev->iobase + DT2811_DO_REG);
 
         data[1] = s->state;
 
         return insn->n;
 }
 
-/*
-  options[0]   Board base address
-  options[1]   IRQ
-  options[2]   Input configuration
-                 0 == single-ended
-                 1 == differential
-                 2 == pseudo-differential
-  options[3]   Analog input range configuration
-                 0 == bipolar 5  (-5V -- +5V)
-                 1 == bipolar 2.5V  (-2.5V -- +2.5V)
-                 2 == unipolar 5V  (0V -- +5V)
-  options[4]   Analog output 0 range configuration
-                 0 == bipolar 5  (-5V -- +5V)
-                 1 == bipolar 2.5V  (-2.5V -- +2.5V)
-                 2 == unipolar 5V  (0V -- +5V)
-  options[5]   Analog output 1 range configuration
-                 0 == bipolar 5  (-5V -- +5V)
-                 1 == bipolar 2.5V  (-2.5V -- +2.5V)
-                 2 == unipolar 5V  (0V -- +5V)
-*/
+static void dt2811_reset(struct comedi_device *dev)
+{
+        /* This is the initialization sequence from the users manual */
+        outb(DT2811_ADCSR_ADMODE(0), dev->iobase + DT2811_ADCSR_REG);
+        usleep_range(100, 1000);
+        inb(dev->iobase + DT2811_ADDATA_LO_REG);
+        inb(dev->iobase + DT2811_ADDATA_HI_REG);
+        outb(DT2811_ADCSR_ADMODE(0) | DT2811_ADCSR_CLRERROR,
+             dev->iobase + DT2811_ADCSR_REG);
+}
+
 static int dt2811_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 {
-        /* int i; */
         const struct dt2811_board *board = dev->board_ptr;
         struct dt2811_private *devpriv;
-        int ret;
         struct comedi_subdevice *s;
+        int ret;
+
+        devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
+        if (!devpriv)
+                return -ENOMEM;
 
         ret = comedi_request_region(dev, it->options[0], 0x8);
         if (ret)
                 return ret;
 
-#if 0
-        outb(0, dev->iobase + DT2811_ADCSR);
-        udelay(100);
-        i = inb(dev->iobase + DT2811_ADDATLO);
-        i = inb(dev->iobase + DT2811_ADDATHI);
-#endif
+        dt2811_reset(dev);
+
+        /* IRQ's 2,3,5,7 are valid for async command support */
+        if (it->options[1] <= 7  && (BIT(it->options[1]) & 0xac)) {
+                ret = request_irq(it->options[1], dt2811_interrupt, 0,
+                                  dev->board_name, dev);
+                if (ret == 0)
+                        dev->irq = it->options[1];
+        }
 
         ret = comedi_alloc_subdevices(dev, 4);
         if (ret)
                 return ret;
 
-        devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
-        if (!devpriv)
-                return -ENOMEM;
-
-        switch (it->options[2]) {
-        case 0:
-                devpriv->adc_mux = adc_singleended;
-                break;
-        case 1:
-                devpriv->adc_mux = adc_diff;
-                break;
-        case 2:
-                devpriv->adc_mux = adc_pseudo_diff;
-                break;
-        default:
-                devpriv->adc_mux = adc_singleended;
-                break;
-        }
-        switch (it->options[4]) {
-        case 0:
-                devpriv->dac_range[0] = dac_bipolar_5;
-                break;
-        case 1:
-                devpriv->dac_range[0] = dac_bipolar_2_5;
-                break;
-        case 2:
-                devpriv->dac_range[0] = dac_unipolar_5;
-                break;
-        default:
-                devpriv->dac_range[0] = dac_bipolar_5;
-                break;
-        }
-        switch (it->options[5]) {
-        case 0:
-                devpriv->dac_range[1] = dac_bipolar_5;
-                break;
-        case 1:
-                devpriv->dac_range[1] = dac_bipolar_2_5;
-                break;
-        case 2:
-                devpriv->dac_range[1] = dac_unipolar_5;
-                break;
-        default:
-                devpriv->dac_range[1] = dac_bipolar_5;
-                break;
-        }
-
+        /* Analog Input subdevice */
         s = &dev->subdevices[0];
-        /* initialize the ADC subdevice */
-        s->type = COMEDI_SUBD_AI;
-        s->subdev_flags = SDF_READABLE | SDF_GROUND;
-        s->n_chan = devpriv->adc_mux == adc_diff ? 8 : 16;
-        s->insn_read = dt2811_ai_insn;
-        s->maxdata = 0xfff;
-        switch (it->options[3]) {
-        case 0:
-        default:
-                s->range_table = board->bip_5;
-                break;
-        case 1:
-                s->range_table = board->bip_2_5;
-                break;
-        case 2:
-                s->range_table = board->unip_5;
-                break;
+        s->type         = COMEDI_SUBD_AI;
+        s->subdev_flags = SDF_READABLE |
+                          (it->options[2] == 1) ? SDF_DIFF :
+                          (it->options[2] == 2) ? SDF_COMMON : SDF_GROUND;
+        s->n_chan       = (it->options[2] == 1) ? 8 : 16;
+        s->maxdata      = 0x0fff;
+        s->range_table  = board->is_pgh ? &dt2811_pgh_ai_ranges
+                                        : &dt2811_pgl_ai_ranges;
+        s->insn_read    = dt2811_ai_insn_read;
+        if (dev->irq) {
+                dev->read_subdev = s;
+                s->subdev_flags |= SDF_CMD_READ;
+                s->len_chanlist = 1;
+                s->do_cmdtest   = dt2811_ai_cmdtest;
+                s->do_cmd       = dt2811_ai_cmd;
+                s->cancel       = dt2811_ai_cancel;
         }
 
+        /* Analog Output subdevice */
         s = &dev->subdevices[1];
-        /* ao subdevice */
-        s->type = COMEDI_SUBD_AO;
-        s->subdev_flags = SDF_WRITABLE;
-        s->n_chan = 2;
-        s->maxdata = 0xfff;
-        s->range_table_list = devpriv->range_type_list;
-        devpriv->range_type_list[0] = dac_range_types[devpriv->dac_range[0]];
-        devpriv->range_type_list[1] = dac_range_types[devpriv->dac_range[1]];
-        s->insn_write = dt2811_ao_insn_write;
+        s->type         = COMEDI_SUBD_AO;
+        s->subdev_flags = SDF_WRITABLE;
+        s->n_chan       = 2;
+        s->maxdata      = 0x0fff;
+        s->range_table  = &dt2811_ao_ranges;
+        s->insn_write   = dt2811_ao_insn_write;
 
         ret = comedi_alloc_subdev_readback(s);
         if (ret)
                 return ret;
 
+        /* Digital Input subdevice */
         s = &dev->subdevices[2];
-        /* di subdevice */
-        s->type = COMEDI_SUBD_DI;
-        s->subdev_flags = SDF_READABLE;
-        s->n_chan = 8;
-        s->insn_bits = dt2811_di_insn_bits;
-        s->maxdata = 1;
-        s->range_table = &range_digital;
-
+        s->type         = COMEDI_SUBD_DI;
+        s->subdev_flags = SDF_READABLE;
+        s->n_chan       = 8;
+        s->maxdata      = 1;
+        s->range_table  = &range_digital;
+        s->insn_bits    = dt2811_di_insn_bits;
+
+        /* Digital Output subdevice */
         s = &dev->subdevices[3];
-        /* do subdevice */
-        s->type = COMEDI_SUBD_DO;
-        s->subdev_flags = SDF_WRITABLE;
-        s->n_chan = 8;
-        s->insn_bits = dt2811_do_insn_bits;
-        s->maxdata = 1;
-        s->state = 0;
-        s->range_table = &range_digital;
+        s->type         = COMEDI_SUBD_DO;
+        s->subdev_flags = SDF_WRITABLE;
+        s->n_chan       = 8;
+        s->maxdata      = 1;
+        s->range_table  = &range_digital;
+        s->insn_bits    = dt2811_do_insn_bits;
 
         return 0;
 }
 
-static const struct dt2811_board boardtypes[] = {
-        {
-                .name           = "dt2811-pgh",
-                .bip_5          = &range_dt2811_pgh_ai_5_bipolar,
-                .bip_2_5        = &range_dt2811_pgh_ai_2_5_bipolar,
-                .unip_5         = &range_dt2811_pgh_ai_5_unipolar,
-        }, {
-                .name           = "dt2811-pgl",
-                .bip_5          = &range_dt2811_pgl_ai_5_bipolar,
-                .bip_2_5        = &range_dt2811_pgl_ai_2_5_bipolar,
-                .unip_5         = &range_dt2811_pgl_ai_5_unipolar,
-        },
-};
-
 static struct comedi_driver dt2811_driver = {
         .driver_name    = "dt2811",
         .module         = THIS_MODULE,
         .attach         = dt2811_attach,
         .detach         = comedi_legacy_detach,
-        .board_name     = &boardtypes[0].name,
-        .num_names      = ARRAY_SIZE(boardtypes),
+        .board_name     = &dt2811_boards[0].name,
+        .num_names      = ARRAY_SIZE(dt2811_boards),
         .offset         = sizeof(struct dt2811_board),
 };
 module_comedi_driver(dt2811_driver);
 
 MODULE_AUTHOR("Comedi http://www.comedi.org");
-MODULE_DESCRIPTION("Comedi low-level driver");
+MODULE_DESCRIPTION("Comedi driver for Data Translation DT2811 series boards");
 MODULE_LICENSE("GPL");
diff --git a/drivers/staging/comedi/drivers/dt2814.c b/drivers/staging/comedi/drivers/dt2814.c
index 66705f9a0621..2f903bedcefa 100644
--- a/drivers/staging/comedi/drivers/dt2814.c
+++ b/drivers/staging/comedi/drivers/dt2814.c
@@ -1,38 +1,38 @@
 /*
-    comedi/drivers/dt2814.c
-    Hardware driver for Data Translation DT2814
-
-    COMEDI - Linux Control and Measurement Device Interface
-    Copyright (C) 1998 David A. Schleef <ds@schleef.org>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-*/
+ * comedi/drivers/dt2814.c
+ * Hardware driver for Data Translation DT2814
+ *
+ * COMEDI - Linux Control and Measurement Device Interface
+ * Copyright (C) 1998 David A. Schleef <ds@schleef.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
 /*
-Driver: dt2814
-Description: Data Translation DT2814
-Author: ds
-Status: complete
-Devices: [Data Translation] DT2814 (dt2814)
-
-Configuration options:
-  [0] - I/O port base address
-  [1] - IRQ
-
-This card has 16 analog inputs multiplexed onto a 12 bit ADC.  There
-is a minimally useful onboard clock.  The base frequency for the
-clock is selected by jumpers, and the clock divider can be selected
-via programmed I/O.  Unfortunately, the clock divider can only be
-a power of 10, from 1 to 10^7, of which only 3 or 4 are useful.  In
-addition, the clock does not seem to be very accurate.
-*/
+ * Driver: dt2814
+ * Description: Data Translation DT2814
+ * Author: ds
+ * Status: complete
+ * Devices: [Data Translation] DT2814 (dt2814)
+ *
+ * Configuration options:
+ * [0] - I/O port base address
+ * [1] - IRQ
+ *
+ * This card has 16 analog inputs multiplexed onto a 12 bit ADC.  There
+ * is a minimally useful onboard clock.  The base frequency for the
+ * clock is selected by jumpers, and the clock divider can be selected
+ * via programmed I/O.  Unfortunately, the clock divider can only be
+ * a power of 10, from 1 to 10^7, of which only 3 or 4 are useful.  In
+ * addition, the clock does not seem to be very accurate.
+ */
 
 #include <linux/module.h>
 #include <linux/interrupt.h>
@@ -215,8 +215,10 @@ static irqreturn_t dt2814_interrupt(int irq, void *d)
                 int i;
 
                 outb(0, dev->iobase + DT2814_CSR);
-                /* note: turning off timed mode triggers another
-                   sample. */
+                /*
+                 * note: turning off timed mode triggers another
+                 * sample.
+                 */
 
                 for (i = 0; i < DT2814_TIMEOUT; i++) {
                         if (inb(dev->iobase + DT2814_CSR) & DT2814_FINISH)
diff --git a/drivers/staging/comedi/drivers/dt2815.c b/drivers/staging/comedi/drivers/dt2815.c
index fb08569c1ac1..0be77cc40a79 100644
--- a/drivers/staging/comedi/drivers/dt2815.c
+++ b/drivers/staging/comedi/drivers/dt2815.c
@@ -1,55 +1,55 @@
 /*
-   comedi/drivers/dt2815.c
-   Hardware driver for Data Translation DT2815
-
-   COMEDI - Linux Control and Measurement Device Interface
-   Copyright (C) 1999 Anders Blomdell <anders.blomdell@control.lth.se>
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
+ * comedi/drivers/dt2815.c
+ * Hardware driver for Data Translation DT2815
+ *
+ * COMEDI - Linux Control and Measurement Device Interface
+ * Copyright (C) 1999 Anders Blomdell <anders.blomdell@control.lth.se>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  */
 /*
-Driver: dt2815
-Description: Data Translation DT2815
-Author: ds
-Status: mostly complete, untested
-Devices: [Data Translation] DT2815 (dt2815)
-
-I'm not sure anyone has ever tested this board.  If you have information
-contrary, please update.
-
-Configuration options:
-  [0] - I/O port base base address
-  [1] - IRQ (unused)
-  [2] - Voltage unipolar/bipolar configuration
-        0 == unipolar 5V  (0V -- +5V)
-        1 == bipolar 5V  (-5V -- +5V)
-  [3] - Current offset configuration
-        0 == disabled  (0mA -- +32mAV)
-        1 == enabled  (+4mA -- +20mAV)
-  [4] - Firmware program configuration
-        0 == program 1 (see manual table 5-4)
-        1 == program 2 (see manual table 5-4)
-        2 == program 3 (see manual table 5-4)
-        3 == program 4 (see manual table 5-4)
-  [5] - Analog output 0 range configuration
-        0 == voltage
-        1 == current
-  [6] - Analog output 1 range configuration (same options)
-  [7] - Analog output 2 range configuration (same options)
-  [8] - Analog output 3 range configuration (same options)
-  [9] - Analog output 4 range configuration (same options)
-  [10] - Analog output 5 range configuration (same options)
-  [11] - Analog output 6 range configuration (same options)
-  [12] - Analog output 7 range configuration (same options)
-*/
+ * Driver: dt2815
+ * Description: Data Translation DT2815
+ * Author: ds
+ * Status: mostly complete, untested
+ * Devices: [Data Translation] DT2815 (dt2815)
+ *
+ * I'm not sure anyone has ever tested this board.  If you have information
+ * contrary, please update.
+ *
+ * Configuration options:
+ * [0] - I/O port base base address
+ * [1] - IRQ (unused)
+ * [2] - Voltage unipolar/bipolar configuration
+ *      0 == unipolar 5V  (0V -- +5V)
+ *      1 == bipolar 5V  (-5V -- +5V)
+ * [3] - Current offset configuration
+ *      0 == disabled  (0mA -- +32mAV)
+ *      1 == enabled  (+4mA -- +20mAV)
+ * [4] - Firmware program configuration
+ *      0 == program 1 (see manual table 5-4)
+ *      1 == program 2 (see manual table 5-4)
+ *      2 == program 3 (see manual table 5-4)
+ *      3 == program 4 (see manual table 5-4)
+ * [5] - Analog output 0 range configuration
+ *      0 == voltage
+ *      1 == current
+ * [6] - Analog output 1 range configuration (same options)
+ * [7] - Analog output 2 range configuration (same options)
+ * [8] - Analog output 3 range configuration (same options)
+ * [9] - Analog output 4 range configuration (same options)
+ * [10] - Analog output 5 range configuration (same options)
+ * [11] - Analog output 6 range configuration (same options)
+ * [12] - Analog output 7 range configuration (same options)
+ */
 
 #include <linux/module.h>
 #include "../comedidev.h"
@@ -120,27 +120,27 @@ static int dt2815_ao_insn(struct comedi_device *dev, struct comedi_subdevice *s,
 }
 
 /*
-  options[0]   Board base address
-  options[1]   IRQ (not applicable)
-  options[2]   Voltage unipolar/bipolar configuration
-                0 == unipolar 5V  (0V -- +5V)
-                1 == bipolar 5V  (-5V -- +5V)
-  options[3]   Current offset configuration
-                0 == disabled  (0mA -- +32mAV)
-                1 == enabled  (+4mA -- +20mAV)
-  options[4]   Firmware program configuration
-                0 == program 1 (see manual table 5-4)
-                1 == program 2 (see manual table 5-4)
-                2 == program 3 (see manual table 5-4)
-                3 == program 4 (see manual table 5-4)
-  options[5]   Analog output 0 range configuration
-                0 == voltage
-                1 == current
-  options[6]   Analog output 1 range configuration
-  ...
-  options[12]   Analog output 7 range configuration
-                0 == voltage
-                1 == current
+ * options[0]   Board base address
+ * options[1]   IRQ (not applicable)
+ * options[2]   Voltage unipolar/bipolar configuration
+ *              0 == unipolar 5V  (0V -- +5V)
+ *              1 == bipolar 5V  (-5V -- +5V)
+ * options[3]   Current offset configuration
+ *              0 == disabled  (0mA -- +32mAV)
+ *              1 == enabled  (+4mA -- +20mAV)
+ * options[4]   Firmware program configuration
+ *              0 == program 1 (see manual table 5-4)
+ *              1 == program 2 (see manual table 5-4)
+ *              2 == program 3 (see manual table 5-4)
+ *              3 == program 4 (see manual table 5-4)
+ * options[5]   Analog output 0 range configuration
+ *              0 == voltage
+ *              1 == current
+ * options[6]   Analog output 1 range configuration
+ * ...
+ * options[12]   Analog output 7 range configuration
+ *              0 == voltage
+ *              1 == current
  */
 
 static int dt2815_attach(struct comedi_device *dev, struct comedi_devconfig *it)
diff --git a/drivers/staging/comedi/drivers/dt2817.c b/drivers/staging/comedi/drivers/dt2817.c
index 5131deebf66f..39d2566e49bf 100644
--- a/drivers/staging/comedi/drivers/dt2817.c
+++ b/drivers/staging/comedi/drivers/dt2817.c
@@ -1,37 +1,37 @@
 /*
-    comedi/drivers/dt2817.c
-    Hardware driver for Data Translation DT2817
-
-    COMEDI - Linux Control and Measurement Device Interface
-    Copyright (C) 1998 David A. Schleef <ds@schleef.org>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-*/
+ * comedi/drivers/dt2817.c
+ * Hardware driver for Data Translation DT2817
+ *
+ * COMEDI - Linux Control and Measurement Device Interface
+ * Copyright (C) 1998 David A. Schleef <ds@schleef.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
 /*
-Driver: dt2817
-Description: Data Translation DT2817
-Author: ds
-Status: complete
-Devices: [Data Translation] DT2817 (dt2817)
-
-A very simple digital I/O card.  Four banks of 8 lines, each bank
-is configurable for input or output.  One wonders why it takes a
-50 page manual to describe this thing.
-
-The driver (which, btw, is much less than 50 pages) has 1 subdevice
-with 32 channels, configurable in groups of 8.
-
-Configuration options:
-  [0] - I/O port base base address
-*/
+ * Driver: dt2817
+ * Description: Data Translation DT2817
+ * Author: ds
+ * Status: complete
+ * Devices: [Data Translation] DT2817 (dt2817)
+ *
+ * A very simple digital I/O card.  Four banks of 8 lines, each bank
+ * is configurable for input or output.  One wonders why it takes a
+ * 50 page manual to describe this thing.
+ *
+ * The driver (which, btw, is much less than 50 pages) has 1 subdevice
+ * with 32 channels, configurable in groups of 8.
+ *
+ * Configuration options:
+ * [0] - I/O port base base address
+ */
 
 #include <linux/module.h>
 #include "../comedidev.h"
diff --git a/drivers/staging/comedi/drivers/gsc_hpdi.c b/drivers/staging/comedi/drivers/gsc_hpdi.c
index 63b5cbc44bda..af4b4175af4d 100644
--- a/drivers/staging/comedi/drivers/gsc_hpdi.c
+++ b/drivers/staging/comedi/drivers/gsc_hpdi.c
@@ -158,10 +158,7 @@ static void gsc_hpdi_drain_dma(struct comedi_device *dev, unsigned int channel)
         unsigned int size;
         unsigned int next;
 
-        if (channel)
-                next = readl(devpriv->plx9080_mmio + PLX_DMA1_PCI_ADDRESS_REG);
-        else
-                next = readl(devpriv->plx9080_mmio + PLX_DMA0_PCI_ADDRESS_REG);
+        next = readl(devpriv->plx9080_mmio + PLX_REG_DMAPADR(channel));
 
         idx = devpriv->dma_desc_index;
         start = le32_to_cpu(devpriv->dma_desc[idx].pci_start_addr);
@@ -201,8 +198,9 @@ static irqreturn_t gsc_hpdi_interrupt(int irq, void *d)
         if (!dev->attached)
                 return IRQ_NONE;
 
-        plx_status = readl(devpriv->plx9080_mmio + PLX_INTRCS_REG);
-        if ((plx_status & (ICS_DMA0_A | ICS_DMA1_A | ICS_LIA)) == 0)
+        plx_status = readl(devpriv->plx9080_mmio + PLX_REG_INTCSR);
+        if ((plx_status &
+             (PLX_INTCSR_DMA0IA | PLX_INTCSR_DMA1IA | PLX_INTCSR_PLIA)) == 0)
                 return IRQ_NONE;
 
         hpdi_intr_status = readl(dev->mmio + INTERRUPT_STATUS_REG);
@@ -213,32 +211,32 @@ static irqreturn_t gsc_hpdi_interrupt(int irq, void *d)
 
         /* spin lock makes sure no one else changes plx dma control reg */
         spin_lock_irqsave(&dev->spinlock, flags);
-        dma0_status = readb(devpriv->plx9080_mmio + PLX_DMA0_CS_REG);
-        if (plx_status & ICS_DMA0_A) {
+        dma0_status = readb(devpriv->plx9080_mmio + PLX_REG_DMACSR0);
+        if (plx_status & PLX_INTCSR_DMA0IA) {
                 /* dma chan 0 interrupt */
-                writeb((dma0_status & PLX_DMA_EN_BIT) | PLX_CLEAR_DMA_INTR_BIT,
-                       devpriv->plx9080_mmio + PLX_DMA0_CS_REG);
+                writeb((dma0_status & PLX_DMACSR_ENABLE) | PLX_DMACSR_CLEARINTR,
+                       devpriv->plx9080_mmio + PLX_REG_DMACSR0);
 
-                if (dma0_status & PLX_DMA_EN_BIT)
+                if (dma0_status & PLX_DMACSR_ENABLE)
                         gsc_hpdi_drain_dma(dev, 0);
         }
         spin_unlock_irqrestore(&dev->spinlock, flags);
 
         /* spin lock makes sure no one else changes plx dma control reg */
         spin_lock_irqsave(&dev->spinlock, flags);
-        dma1_status = readb(devpriv->plx9080_mmio + PLX_DMA1_CS_REG);
-        if (plx_status & ICS_DMA1_A) {
+        dma1_status = readb(devpriv->plx9080_mmio + PLX_REG_DMACSR1);
+        if (plx_status & PLX_INTCSR_DMA1IA) {
                 /* XXX */ /* dma chan 1 interrupt */
-                writeb((dma1_status & PLX_DMA_EN_BIT) | PLX_CLEAR_DMA_INTR_BIT,
-                       devpriv->plx9080_mmio + PLX_DMA1_CS_REG);
+                writeb((dma1_status & PLX_DMACSR_ENABLE) | PLX_DMACSR_CLEARINTR,
+                       devpriv->plx9080_mmio + PLX_REG_DMACSR1);
         }
         spin_unlock_irqrestore(&dev->spinlock, flags);
 
         /* clear possible plx9080 interrupt sources */
-        if (plx_status & ICS_LDIA) {
+        if (plx_status & PLX_INTCSR_LDBIA) {
                 /* clear local doorbell interrupt */
-                plx_bits = readl(devpriv->plx9080_mmio + PLX_DBR_OUT_REG);
-                writel(plx_bits, devpriv->plx9080_mmio + PLX_DBR_OUT_REG);
+                plx_bits = readl(devpriv->plx9080_mmio + PLX_REG_L2PDBELL);
+                writel(plx_bits, devpriv->plx9080_mmio + PLX_REG_L2PDBELL);
         }
 
         if (hpdi_board_status & RX_OVERRUN_BIT) {
@@ -307,19 +305,19 @@ static int gsc_hpdi_cmd(struct comedi_device *dev,
          * occasionally cause problems with transfer of first dma
          * block.  Initializing them to zero seems to fix the problem.
          */
-        writel(0, devpriv->plx9080_mmio + PLX_DMA0_TRANSFER_SIZE_REG);
-        writel(0, devpriv->plx9080_mmio + PLX_DMA0_PCI_ADDRESS_REG);
-        writel(0, devpriv->plx9080_mmio + PLX_DMA0_LOCAL_ADDRESS_REG);
+        writel(0, devpriv->plx9080_mmio + PLX_REG_DMASIZ0);
+        writel(0, devpriv->plx9080_mmio + PLX_REG_DMAPADR0);
+        writel(0, devpriv->plx9080_mmio + PLX_REG_DMALADR0);
 
         /* give location of first dma descriptor */
-        bits = devpriv->dma_desc_phys_addr | PLX_DESC_IN_PCI_BIT |
-               PLX_INTR_TERM_COUNT | PLX_XFER_LOCAL_TO_PCI;
-        writel(bits, devpriv->plx9080_mmio + PLX_DMA0_DESCRIPTOR_REG);
+        bits = devpriv->dma_desc_phys_addr | PLX_DMADPR_DESCPCI |
+               PLX_DMADPR_TCINTR | PLX_DMADPR_XFERL2P;
+        writel(bits, devpriv->plx9080_mmio + PLX_REG_DMADPR0);
 
         /* enable dma transfer */
         spin_lock_irqsave(&dev->spinlock, flags);
-        writeb(PLX_DMA_EN_BIT | PLX_DMA_START_BIT | PLX_CLEAR_DMA_INTR_BIT,
-               devpriv->plx9080_mmio + PLX_DMA0_CS_REG);
+        writeb(PLX_DMACSR_ENABLE | PLX_DMACSR_START | PLX_DMACSR_CLEARINTR,
+               devpriv->plx9080_mmio + PLX_REG_DMACSR0);
         spin_unlock_irqrestore(&dev->spinlock, flags);
 
         if (cmd->stop_src == TRIG_COUNT)
@@ -424,8 +422,8 @@ static int gsc_hpdi_setup_dma_descriptors(struct comedi_device *dev,
 {
         struct hpdi_private *devpriv = dev->private;
         dma_addr_t phys_addr = devpriv->dma_desc_phys_addr;
-        u32 next_bits = PLX_DESC_IN_PCI_BIT | PLX_INTR_TERM_COUNT |
-                        PLX_XFER_LOCAL_TO_PCI;
+        u32 next_bits = PLX_DMADPR_DESCPCI | PLX_DMADPR_TCINTR |
+                        PLX_DMADPR_XFERL2P;
         unsigned int offset = 0;
         unsigned int idx = 0;
         unsigned int i;
@@ -536,9 +534,10 @@ static int gsc_hpdi_init(struct comedi_device *dev)
 
         /* enable interrupts */
         plx_intcsr_bits =
-            ICS_AERR | ICS_PERR | ICS_PIE | ICS_PLIE | ICS_PAIE | ICS_LIE |
-            ICS_DMA0_E;
-        writel(plx_intcsr_bits, devpriv->plx9080_mmio + PLX_INTRCS_REG);
+            PLX_INTCSR_LSEABORTEN | PLX_INTCSR_LSEPARITYEN | PLX_INTCSR_PIEN |
+            PLX_INTCSR_PLIEN | PLX_INTCSR_PABORTIEN | PLX_INTCSR_LIOEN |
+            PLX_INTCSR_DMA0IEN;
+        writel(plx_intcsr_bits, devpriv->plx9080_mmio + PLX_REG_INTCSR);
 
         return 0;
 }
@@ -550,13 +549,13 @@ static void gsc_hpdi_init_plx9080(struct comedi_device *dev)
         void __iomem *plx_iobase = devpriv->plx9080_mmio;
 
 #ifdef __BIG_ENDIAN
-        bits = BIGEND_DMA0 | BIGEND_DMA1;
+        bits = PLX_BIGEND_DMA0 | PLX_BIGEND_DMA1;
 #else
         bits = 0;
 #endif
-        writel(bits, devpriv->plx9080_mmio + PLX_BIGEND_REG);
+        writel(bits, devpriv->plx9080_mmio + PLX_REG_BIGEND);
 
-        writel(0, devpriv->plx9080_mmio + PLX_INTRCS_REG);
+        writel(0, devpriv->plx9080_mmio + PLX_REG_INTCSR);
 
         gsc_hpdi_abort_dma(dev, 0);
         gsc_hpdi_abort_dma(dev, 1);
@@ -564,27 +563,27 @@ static void gsc_hpdi_init_plx9080(struct comedi_device *dev)
         /* configure dma0 mode */
         bits = 0;
         /* enable ready input */
-        bits |= PLX_DMA_EN_READYIN_BIT;
+        bits |= PLX_DMAMODE_READYIEN;
         /* enable dma chaining */
-        bits |= PLX_EN_CHAIN_BIT;
+        bits |= PLX_DMAMODE_CHAINEN;
         /*
          * enable interrupt on dma done
          * (probably don't need this, since chain never finishes)
          */
-        bits |= PLX_EN_DMA_DONE_INTR_BIT;
+        bits |= PLX_DMAMODE_DONEIEN;
         /*
          * don't increment local address during transfers
          * (we are transferring from a fixed fifo register)
          */
-        bits |= PLX_LOCAL_ADDR_CONST_BIT;
+        bits |= PLX_DMAMODE_LACONST;
         /* route dma interrupt to pci bus */
-        bits |= PLX_DMA_INTR_PCI_BIT;
+        bits |= PLX_DMAMODE_INTRPCI;
         /* enable demand mode */
-        bits |= PLX_DEMAND_MODE_BIT;
+        bits |= PLX_DMAMODE_DEMAND;
         /* enable local burst mode */
-        bits |= PLX_DMA_LOCAL_BURST_EN_BIT;
-        bits |= PLX_LOCAL_BUS_32_WIDE_BITS;
-        writel(bits, plx_iobase + PLX_DMA0_MODE_REG);
+        bits |= PLX_DMAMODE_BURSTEN;
+        bits |= PLX_DMAMODE_WIDTH32;
+        writel(bits, plx_iobase + PLX_REG_DMAMODE0);
 }
 
 static int gsc_hpdi_auto_attach(struct comedi_device *dev,
@@ -680,7 +679,7 @@ static void gsc_hpdi_detach(struct comedi_device *dev)
                 free_irq(dev->irq, dev);
         if (devpriv) {
                 if (devpriv->plx9080_mmio) {
-                        writel(0, devpriv->plx9080_mmio + PLX_INTRCS_REG);
+                        writel(0, devpriv->plx9080_mmio + PLX_REG_INTCSR);
                         iounmap(devpriv->plx9080_mmio);
                 }
                 if (dev->mmio)
diff --git a/drivers/staging/comedi/drivers/jr3_pci.c b/drivers/staging/comedi/drivers/jr3_pci.c
index b87192e0f9aa..6c4ff023717f 100644
--- a/drivers/staging/comedi/drivers/jr3_pci.c
+++ b/drivers/staging/comedi/drivers/jr3_pci.c
@@ -1,20 +1,20 @@
 /*
-  comedi/drivers/jr3_pci.c
-  hardware driver for JR3/PCI force sensor board
-
-  COMEDI - Linux Control and Measurement Device Interface
-  Copyright (C) 2007 Anders Blomdell <anders.blomdell@control.lth.se>
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-*/
+ * comedi/drivers/jr3_pci.c
+ * hardware driver for JR3/PCI force sensor board
+ *
+ * COMEDI - Linux Control and Measurement Device Interface
+ * Copyright (C) 2007 Anders Blomdell <anders.blomdell@control.lth.se>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
 /*
  * Driver: jr3_pci
  * Description: JR3/PCI force sensor board
@@ -231,7 +231,7 @@ static unsigned int jr3_pci_ai_read_chan(struct comedi_device *dev,
 
         if (chan < 56) {
                 unsigned int axis = chan % 8;
-                unsigned filter = chan / 8;
+                unsigned int filter = chan / 8;
 
                 switch (axis) {
                 case 0:
@@ -690,7 +690,7 @@ static int jr3_pci_auto_attach(struct comedi_device *dev,
         if (sizeof(struct jr3_channel) != 0xc00) {
                 dev_err(dev->class_dev,
                         "sizeof(struct jr3_channel) = %x [expected %x]\n",
-                        (unsigned)sizeof(struct jr3_channel), 0xc00);
+                        (unsigned int)sizeof(struct jr3_channel), 0xc00);
                 return -EINVAL;
         }
 
diff --git a/drivers/staging/comedi/drivers/me_daq.c b/drivers/staging/comedi/drivers/me_daq.c
index 3bf0caa18ab0..c0b7a300e428 100644
--- a/drivers/staging/comedi/drivers/me_daq.c
+++ b/drivers/staging/comedi/drivers/me_daq.c
@@ -150,7 +150,7 @@ struct me_private_data {
         unsigned short dac_ctrl;        /* Mirror of the DAC_CONTROL register */
 };
 
-static inline void sleep(unsigned sec)
+static inline void sleep(unsigned int sec)
 {
         schedule_timeout_interruptible(sec * HZ);
 }
diff --git a/drivers/staging/comedi/drivers/mpc624.c b/drivers/staging/comedi/drivers/mpc624.c
index 826e4399c87e..9bda761433c2 100644
--- a/drivers/staging/comedi/drivers/mpc624.c
+++ b/drivers/staging/comedi/drivers/mpc624.c
@@ -103,7 +103,7 @@ static const struct comedi_lrange range_mpc624_bipolar1 = {
 /* BIP_RANGE(1.01)  this is correct, */
          /*  but my MPC-624 actually seems to have a range of 2.02 */
          BIP_RANGE(2.02)
-         }
+        }
 };
 
 static const struct comedi_lrange range_mpc624_bipolar10 = {
@@ -112,7 +112,7 @@ static const struct comedi_lrange range_mpc624_bipolar10 = {
 /* BIP_RANGE(10.1)   this is correct, */
          /*  but my MPC-624 actually seems to have a range of 20.2 */
          BIP_RANGE(20.2)
-         }
+        }
 };
 
 static unsigned int mpc624_ai_get_sample(struct comedi_device *dev,
diff --git a/drivers/staging/comedi/drivers/ni_65xx.c b/drivers/staging/comedi/drivers/ni_65xx.c
index 251117be1205..07f38e385469 100644
--- a/drivers/staging/comedi/drivers/ni_65xx.c
+++ b/drivers/staging/comedi/drivers/ni_65xx.c
@@ -151,10 +151,10 @@ enum ni_65xx_boardid {
 
 struct ni_65xx_board {
         const char *name;
-        unsigned num_dio_ports;
-        unsigned num_di_ports;
-        unsigned num_do_ports;
-        unsigned legacy_invert:1;
+        unsigned int num_dio_ports;
+        unsigned int num_di_ports;
+        unsigned int num_do_ports;
+        unsigned int legacy_invert:1;
 };
 
 static const struct ni_65xx_board ni_65xx_boards[] = {
@@ -360,7 +360,7 @@ static int ni_65xx_dio_insn_config(struct comedi_device *dev,
         unsigned long base_port = (unsigned long)s->private;
         unsigned int chan = CR_CHAN(insn->chanspec);
         unsigned int chan_mask = NI_65XX_CHAN_TO_MASK(chan);
-        unsigned port = base_port + NI_65XX_CHAN_TO_PORT(chan);
+        unsigned int port = base_port + NI_65XX_CHAN_TO_PORT(chan);
         unsigned int interval;
         unsigned int val;
 
@@ -428,14 +428,14 @@ static int ni_65xx_dio_insn_bits(struct comedi_device *dev,
         unsigned long base_port = (unsigned long)s->private;
         unsigned int base_chan = CR_CHAN(insn->chanspec);
         int last_port_offset = NI_65XX_CHAN_TO_PORT(s->n_chan - 1);
-        unsigned read_bits = 0;
+        unsigned int read_bits = 0;
         int port_offset;
 
         for (port_offset = NI_65XX_CHAN_TO_PORT(base_chan);
              port_offset <= last_port_offset; port_offset++) {
-                unsigned port = base_port + port_offset;
+                unsigned int port = base_port + port_offset;
                 int base_port_channel = NI_65XX_PORT_TO_CHAN(port_offset);
-                unsigned port_mask, port_data, bits;
+                unsigned int port_mask, port_data, bits;
                 int bitshift = base_port_channel - base_chan;
 
                 if (bitshift >= 32)
@@ -640,7 +640,7 @@ static int ni_65xx_auto_attach(struct comedi_device *dev,
         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
         const struct ni_65xx_board *board = NULL;
         struct comedi_subdevice *s;
-        unsigned i;
+        unsigned int i;
         int ret;
 
         if (context < ARRAY_SIZE(ni_65xx_boards))
diff --git a/drivers/staging/comedi/drivers/ni_pcidio.c b/drivers/staging/comedi/drivers/ni_pcidio.c
index 02a532990979..35ef1925703f 100644
--- a/drivers/staging/comedi/drivers/ni_pcidio.c
+++ b/drivers/staging/comedi/drivers/ni_pcidio.c
@@ -170,12 +170,12 @@ comedi_nonfree_firmware tarball available from http://www.comedi.org
 #define DMA_Line_Control_Group1         76
 #define DMA_Line_Control_Group2         108
 /* channel zero is none */
-static inline unsigned primary_DMAChannel_bits(unsigned channel)
+static inline unsigned int primary_DMAChannel_bits(unsigned int channel)
 {
         return channel & 0x3;
 }
 
-static inline unsigned secondary_DMAChannel_bits(unsigned channel)
+static inline unsigned int secondary_DMAChannel_bits(unsigned int channel)
 {
         return (channel << 2) & 0xc;
 }
diff --git a/drivers/staging/comedi/drivers/ni_pcimio.c b/drivers/staging/comedi/drivers/ni_pcimio.c
index 344aa343e5e1..d8917392b9f9 100644
--- a/drivers/staging/comedi/drivers/ni_pcimio.c
+++ b/drivers/staging/comedi/drivers/ni_pcimio.c
@@ -1064,12 +1064,12 @@ static void m_series_init_eeprom_buffer(struct comedi_device *dev)
         struct mite *mite = devpriv->mite;
         resource_size_t daq_phys_addr;
         static const int Start_Cal_EEPROM = 0x400;
-        static const unsigned window_size = 10;
+        static const unsigned int window_size = 10;
         static const int serial_number_eeprom_offset = 0x4;
         static const int serial_number_eeprom_length = 0x4;
-        unsigned old_iodwbsr_bits;
-        unsigned old_iodwbsr1_bits;
-        unsigned old_iodwcr1_bits;
+        unsigned int old_iodwbsr_bits;
+        unsigned int old_iodwbsr1_bits;
+        unsigned int old_iodwcr1_bits;
         int i;
 
         /* IO Window 1 needs to be temporarily mapped to read the eeprom */
diff --git a/drivers/staging/comedi/drivers/pcmmio.c b/drivers/staging/comedi/drivers/pcmmio.c
index 10472e6dd002..70ad497dd20b 100644
--- a/drivers/staging/comedi/drivers/pcmmio.c
+++ b/drivers/staging/comedi/drivers/pcmmio.c
@@ -84,25 +84,25 @@
 #define PCMMIO_AI_LSB_REG                       0x00
 #define PCMMIO_AI_MSB_REG                       0x01
 #define PCMMIO_AI_CMD_REG                       0x02
-#define PCMMIO_AI_CMD_SE                        (1 << 7)
-#define PCMMIO_AI_CMD_ODD_CHAN                  (1 << 6)
+#define PCMMIO_AI_CMD_SE                        BIT(7)
+#define PCMMIO_AI_CMD_ODD_CHAN                  BIT(6)
 #define PCMMIO_AI_CMD_CHAN_SEL(x)               (((x) & 0x3) << 4)
 #define PCMMIO_AI_CMD_RANGE(x)                  (((x) & 0x3) << 2)
 #define PCMMIO_RESOURCE_REG                     0x02
 #define PCMMIO_RESOURCE_IRQ(x)                  (((x) & 0xf) << 0)
 #define PCMMIO_AI_STATUS_REG                    0x03
-#define PCMMIO_AI_STATUS_DATA_READY             (1 << 7)
-#define PCMMIO_AI_STATUS_DATA_DMA_PEND          (1 << 6)
-#define PCMMIO_AI_STATUS_CMD_DMA_PEND           (1 << 5)
-#define PCMMIO_AI_STATUS_IRQ_PEND               (1 << 4)
-#define PCMMIO_AI_STATUS_DATA_DRQ_ENA           (1 << 2)
-#define PCMMIO_AI_STATUS_REG_SEL                (1 << 3)
-#define PCMMIO_AI_STATUS_CMD_DRQ_ENA            (1 << 1)
-#define PCMMIO_AI_STATUS_IRQ_ENA                (1 << 0)
+#define PCMMIO_AI_STATUS_DATA_READY             BIT(7)
+#define PCMMIO_AI_STATUS_DATA_DMA_PEND          BIT(6)
+#define PCMMIO_AI_STATUS_CMD_DMA_PEND           BIT(5)
+#define PCMMIO_AI_STATUS_IRQ_PEND               BIT(4)
+#define PCMMIO_AI_STATUS_DATA_DRQ_ENA           BIT(2)
+#define PCMMIO_AI_STATUS_REG_SEL                BIT(3)
+#define PCMMIO_AI_STATUS_CMD_DRQ_ENA            BIT(1)
+#define PCMMIO_AI_STATUS_IRQ_ENA                BIT(0)
 #define PCMMIO_AI_RES_ENA_REG                   0x03
 #define PCMMIO_AI_RES_ENA_CMD_REG_ACCESS        (0 << 3)
-#define PCMMIO_AI_RES_ENA_AI_RES_ACCESS         (1 << 3)
-#define PCMMIO_AI_RES_ENA_DIO_RES_ACCESS        (1 << 4)
+#define PCMMIO_AI_RES_ENA_AI_RES_ACCESS         BIT(3)
+#define PCMMIO_AI_RES_ENA_DIO_RES_ACCESS        BIT(4)
 #define PCMMIO_AI_2ND_ADC_OFFSET                0x04
 
 #define PCMMIO_AO_LSB_REG                       0x08
@@ -125,14 +125,14 @@
 #define PCMMIO_AO_CMD_CHAN_SEL(x)               (((x) & 0x03) << 1)
 #define PCMMIO_AO_CMD_CHAN_SEL_ALL              (0x0f << 0)
 #define PCMMIO_AO_STATUS_REG                    0x0b
-#define PCMMIO_AO_STATUS_DATA_READY             (1 << 7)
-#define PCMMIO_AO_STATUS_DATA_DMA_PEND          (1 << 6)
-#define PCMMIO_AO_STATUS_CMD_DMA_PEND           (1 << 5)
-#define PCMMIO_AO_STATUS_IRQ_PEND               (1 << 4)
-#define PCMMIO_AO_STATUS_DATA_DRQ_ENA           (1 << 2)
-#define PCMMIO_AO_STATUS_REG_SEL                (1 << 3)
-#define PCMMIO_AO_STATUS_CMD_DRQ_ENA            (1 << 1)
-#define PCMMIO_AO_STATUS_IRQ_ENA                (1 << 0)
+#define PCMMIO_AO_STATUS_DATA_READY             BIT(7)
+#define PCMMIO_AO_STATUS_DATA_DMA_PEND          BIT(6)
+#define PCMMIO_AO_STATUS_CMD_DMA_PEND           BIT(5)
+#define PCMMIO_AO_STATUS_IRQ_PEND               BIT(4)
+#define PCMMIO_AO_STATUS_DATA_DRQ_ENA           BIT(2)
+#define PCMMIO_AO_STATUS_REG_SEL                BIT(3)
+#define PCMMIO_AO_STATUS_CMD_DRQ_ENA            BIT(1)
+#define PCMMIO_AO_STATUS_IRQ_ENA                BIT(0)
 #define PCMMIO_AO_RESOURCE_ENA_REG              0x0b
 #define PCMMIO_AO_2ND_DAC_OFFSET                0x04
 
diff --git a/drivers/staging/comedi/drivers/pcmuio.c b/drivers/staging/comedi/drivers/pcmuio.c
index 7ea813022ff6..8ad64f2625fe 100644
--- a/drivers/staging/comedi/drivers/pcmuio.c
+++ b/drivers/staging/comedi/drivers/pcmuio.c
@@ -307,7 +307,7 @@ static void pcmuio_stop_intr(struct comedi_device *dev,
 
 static void pcmuio_handle_intr_subdev(struct comedi_device *dev,
                                       struct comedi_subdevice *s,
-                                      unsigned triggered)
+                                      unsigned int triggered)
 {
         struct pcmuio_private *devpriv = dev->private;
         int asic = pcmuio_subdevice_to_asic(s);
diff --git a/drivers/staging/comedi/drivers/plx9080.h b/drivers/staging/comedi/drivers/plx9080.h
index 8d1aee00b19f..0e20cc5c9a69 100644
--- a/drivers/staging/comedi/drivers/plx9080.h
+++ b/drivers/staging/comedi/drivers/plx9080.h
@@ -3,15 +3,6 @@
  *
  * Copyright (C) 2002,2003 Frank Mori Hess <fmhess@users.sourceforge.net>
  *
- * I modified this file from the plx9060.h header for the
- * wanXL device driver in the linux kernel,
- * for the register offsets and bit definitions.  Made minor modifications,
- * added plx9080 registers and
- * stripped out stuff that was specifically for the wanXL driver.
- * Note: I've only made sure the definitions are correct as far
- * as I make use of them.  There are still various plx9060-isms
- * left in this header file.
- *
  ********************************************************************
  *
  * Copyright (C) 1999 RG Studio s.c.
@@ -28,392 +19,611 @@
 #ifndef __COMEDI_PLX9080_H
 #define __COMEDI_PLX9080_H
 
-/*  descriptor block used for chained dma transfers */
+#include <linux/compiler.h>
+#include <linux/types.h>
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/io.h>
+
+/**
+ * struct plx_dma_desc - DMA descriptor format for PLX PCI 9080
+ * @pci_start_addr:     PCI Bus address for transfer (DMAPADR).
+ * @local_start_addr:   Local Bus address for transfer (DMALADR).
+ * @transfer_size:      Transfer size in bytes (max 8 MiB) (DMASIZ).
+ * @next:               Address of next descriptor + flags (DMADPR).
+ *
+ * Describes the format of a scatter-gather DMA descriptor for the PLX
+ * PCI 9080.  All members are raw, little-endian register values that
+ * will be transferred by the DMA engine from local or PCI memory into
+ * corresponding registers for the DMA channel.
+ *
+ * The DMA descriptors must be aligned on a 16-byte boundary.  Bits 3:0
+ * of @next contain flags describing the address space of the next
+ * descriptor (local or PCI), an "end of chain" marker, an "interrupt on
+ * terminal count" bit, and a data transfer direction.
+ */
 struct plx_dma_desc {
         __le32 pci_start_addr;
         __le32 local_start_addr;
-        /* transfer_size is in bytes, only first 23 bits of register are used */
         __le32 transfer_size;
-        /*
-         * address of next descriptor (quad word aligned), plus some
-         * additional bits (see PLX_DMA0_DESCRIPTOR_REG)
-         */
         __le32 next;
 };
 
-/**********************************************************************
-**            Register Offsets and Bit Definitions
-**
-** Note: All offsets zero relative.  IE. Some standard base address
-** must be added to the Register Number to properly access the register.
-**
-**********************************************************************/
-
-/* L, Local Addr Space 0 Range Register */
-#define PLX_LAS0RNG_REG         0x0000
-/* L, Local Addr Space 1 Range Register */
-#define PLX_LAS1RNG_REG         0x00f0
-#define  LRNG_IO           0x00000001   /* Map to: 1=I/O, 0=Mem */
-#define  LRNG_ANY32        0x00000000   /* Locate anywhere in 32 bit */
-#define  LRNG_LT1MB        0x00000002   /* Locate in 1st meg */
-#define  LRNG_ANY64        0x00000004   /* Locate anywhere in 64 bit */
-/*  bits that specify range for memory io */
-#define  LRNG_MEM_MASK     0xfffffff0
-/*  bits that specify range for normal io */
-#define  LRNG_IO_MASK     0xfffffffa
-/* L, Local Addr Space 0 Remap Register */
-#define PLX_LAS0MAP_REG         0x0004
-/* L, Local Addr Space 1 Remap Register */
-#define PLX_LAS1MAP_REG         0x00f4
-#define  LMAP_EN           0x00000001   /* Enable slave decode */
-/*  bits that specify decode for memory io */
-#define  LMAP_MEM_MASK     0xfffffff0
-/*  bits that specify decode bits for normal io */
-#define  LMAP_IO_MASK     0xfffffffa
-
 /*
- * Mode/Arbitration Register.
+ * Register Offsets and Bit Definitions
  */
-#define PLX_MARB_REG         0x8        /* L, Local Arbitration Register */
-#define PLX_DMAARB_REG      0xac
-enum marb_bits {
-        MARB_LLT_MASK = 0x000000ff,     /* Local Bus Latency Timer */
-        MARB_LPT_MASK = 0x0000ff00,     /* Local Bus Pause Timer */
-        MARB_LTEN = 0x00010000, /* Latency Timer Enable */
-        MARB_LPEN = 0x00020000, /* Pause Timer Enable */
-        MARB_BREQ = 0x00040000, /* Local Bus BREQ Enable */
-        MARB_DMA_PRIORITY_MASK = 0x00180000,
-        /* local bus direct slave give up bus mode */
-        MARB_LBDS_GIVE_UP_BUS_MODE = 0x00200000,
-        /* direct slave LLOCKo# enable */
-        MARB_DS_LLOCK_ENABLE = 0x00400000,
-        MARB_PCI_REQUEST_MODE = 0x00800000,
-        MARB_PCIV21_MODE = 0x01000000,  /* pci specification v2.1 mode */
-        MARB_PCI_READ_NO_WRITE_MODE = 0x02000000,
-        MARB_PCI_READ_WITH_WRITE_FLUSH_MODE = 0x04000000,
-        /* gate local bus latency timer with BREQ */
-        MARB_GATE_TIMER_WITH_BREQ = 0x08000000,
-        MARB_PCI_READ_NO_FLUSH_MODE = 0x10000000,
-        MARB_USE_SUBSYSTEM_IDS = 0x20000000,
-};
-
-#define PLX_BIGEND_REG 0xc
-enum bigend_bits {
-        /* use big endian ordering for configuration register accesses */
-        BIGEND_CONFIG = 0x1,
-        BIGEND_DIRECT_MASTER = 0x2,
-        BIGEND_DIRECT_SLAVE_LOCAL0 = 0x4,
-        BIGEND_ROM = 0x8,
-        /*
-         * use byte lane consisting of most significant bits instead of
-         * least significant
-         */
-        BIGEND_BYTE_LANE = 0x10,
-        BIGEND_DIRECT_SLAVE_LOCAL1 = 0x20,
-        BIGEND_DMA1 = 0x40,
-        BIGEND_DMA0 = 0x80,
-};
 
+/* Local Address Space 0 Range Register */
+#define PLX_REG_LAS0RR          0x0000
+/* Local Address Space 1 Range Register */
+#define PLX_REG_LAS1RR          0x00f0
+
+#define PLX_LASRR_IO            BIT(0)          /* Map to: 1=I/O, 0=Mem */
+#define PLX_LASRR_ANY32         (BIT(1) * 0)    /* Locate anywhere in 32 bit */
+#define PLX_LASRR_LT1MB         (BIT(1) * 1)    /* Locate in 1st meg */
+#define PLX_LASRR_ANY64         (BIT(1) * 2)    /* Locate anywhere in 64 bit */
+#define PLX_LASRR_MLOC_MASK     GENMASK(2, 1)   /* Memory location bits */
+#define PLX_LASRR_PREFETCH      BIT(3)          /* Memory is prefetchable */
+/* bits that specify range for memory space decode bits */
+#define PLX_LASRR_MEM_MASK      GENMASK(31, 4)
+/* bits that specify range for i/o space decode bits */
+#define PLX_LASRR_IO_MASK       GENMASK(31, 2)
+
+/* Local Address Space 0 Local Base Address (Remap) Register */
+#define PLX_REG_LAS0BA          0x0004
+/* Local Address Space 1 Local Base Address (Remap) Register */
+#define PLX_REG_LAS1BA          0x00f4
+
+#define PLX_LASBA_EN            BIT(0)          /* Enable slave decode */
+/* bits that specify local base address for memory space */
+#define PLX_LASBA_MEM_MASK      GENMASK(31, 4)
+/* bits that specify local base address for i/o space */
+#define PLX_LASBA_IO_MASK       GENMASK(31, 2)
+
+/* Mode/Arbitration Register */
+#define PLX_REG_MARBR           0x0008
+/* DMA Arbitration Register (alias of MARBR). */
+#define PLX_REG_DMAARB          0x00ac
+
+/* Local Bus Latency Timer */
+#define PLX_MARBR_LT(x)         (BIT(0) * ((x) & 0xff))
+#define PLX_MARBR_LT_MASK       GENMASK(7, 0)
+#define PLX_MARBR_LT_SHIFT      0
+/* Local Bus Pause Timer */
+#define PLX_MARBR_PT(x)         (BIT(8) * ((x) & 0xff))
+#define PLX_MARBR_PT_MASK       GENMASK(15, 8)
+#define PLX_MARBR_PT_SHIFT      8
+/* Local Bus Latency Timer Enable */
+#define PLX_MARBR_LTEN          BIT(16)
+/* Local Bus Pause Timer Enable */
+#define PLX_MARBR_PTEN          BIT(17)
+/* Local Bus BREQ Enable */
+#define PLX_MARBR_BREQEN        BIT(18)
+/* DMA Channel Priority */
+#define PLX_MARBR_PRIO_ROT      (BIT(19) * 0)   /* Rotational priority */
+#define PLX_MARBR_PRIO_DMA0     (BIT(19) * 1)   /* DMA channel 0 has priority */
+#define PLX_MARBR_PRIO_DMA1     (BIT(19) * 2)   /* DMA channel 1 has priority */
+#define PLX_MARBR_PRIO_MASK     GENMASK(20, 19)
+/* Local Bus Direct Slave Give Up Bus Mode */
+#define PLX_MARBR_DSGUBM        BIT(21)
+/* Direct Slace LLOCKo# Enable */
+#define PLX_MARBR_DSLLOCKOEN    BIT(22)
+/* PCI Request Mode */
+#define PLX_MARBR_PCIREQM       BIT(23)
+/* PCI Specification v2.1 Mode */
+#define PLX_MARBR_PCIV21M       BIT(24)
+/* PCI Read No Write Mode */
+#define PLX_MARBR_PCIRNWM       BIT(25)
+/* PCI Read with Write Flush Mode */
+#define PLX_MARBR_PCIRWFM       BIT(26)
+/* Gate Local Bus Latency Timer with BREQ */
+#define PLX_MARBR_GLTBREQ       BIT(27)
+/* PCI Read No Flush Mode */
+#define PLX_MARBR_PCIRNFM       BIT(28)
 /*
-** Note: The Expansion ROM  stuff is only relevant to the PC environment.
-**       This expansion ROM code is executed by the host CPU at boot time.
-**       For this reason no bit definitions are provided here.
+ * Make reads from PCI Configuration register 0 return Subsystem ID and
+ * Subsystem Vendor ID instead of Device ID and Vendor ID
  */
-#define PLX_ROMRNG_REG         0x0010   /* L, Expn ROM Space Range Register */
-/* L, Local Addr Space Range Register */
-#define PLX_ROMMAP_REG         0x0014
-
-#define PLX_REGION0_REG         0x0018  /* L, Local Bus Region 0 Descriptor */
-#define  RGN_WIDTH         0x00000002   /* Local bus width bits */
-#define  RGN_8BITS         0x00000000   /* 08 bit Local Bus */
-#define  RGN_16BITS        0x00000001   /* 16 bit Local Bus */
-#define  RGN_32BITS        0x00000002   /* 32 bit Local Bus */
-#define  RGN_MWS           0x0000003C   /* Memory Access Wait States */
-#define  RGN_0MWS          0x00000000
-#define  RGN_1MWS          0x00000004
-#define  RGN_2MWS          0x00000008
-#define  RGN_3MWS          0x0000000C
-#define  RGN_4MWS          0x00000010
-#define  RGN_6MWS          0x00000018
-#define  RGN_8MWS          0x00000020
-#define  RGN_MRE           0x00000040   /* Memory Space Ready Input Enable */
-#define  RGN_MBE           0x00000080   /* Memory Space Bterm Input Enable */
-#define  RGN_READ_PREFETCH_DISABLE 0x00000100
-#define  RGN_ROM_PREFETCH_DISABLE 0x00000200
-#define  RGN_READ_PREFETCH_COUNT_ENABLE 0x00000400
-#define  RGN_RWS           0x003C0000   /* Expn ROM Wait States */
-#define  RGN_RRE           0x00400000   /* ROM Space Ready Input Enable */
-#define  RGN_RBE           0x00800000   /* ROM Space Bterm Input Enable */
-#define  RGN_MBEN          0x01000000   /* Memory Space Burst Enable */
-#define  RGN_RBEN          0x04000000   /* ROM Space Burst Enable */
-#define  RGN_THROT         0x08000000   /* De-assert TRDY when FIFO full */
-#define  RGN_TRD           0xF0000000   /* Target Ready Delay /8 */
-
-#define PLX_REGION1_REG         0x00f8  /* L, Local Bus Region 1 Descriptor */
-
-#define PLX_DMRNG_REG          0x001C   /* L, Direct Master Range Register */
-
-#define PLX_LBAPMEM_REG        0x0020   /* L, Lcl Base Addr for PCI mem space */
-
-#define PLX_LBAPIO_REG         0x0024   /* L, Lcl Base Addr for PCI I/O space */
-
-#define PLX_DMMAP_REG          0x0028   /* L, Direct Master Remap Register */
-#define  DMM_MAE           0x00000001   /* Direct Mstr Memory Acc Enable */
-#define  DMM_IAE           0x00000002   /* Direct Mstr I/O Acc Enable */
-#define  DMM_LCK           0x00000004   /* LOCK Input Enable */
-#define  DMM_PF4           0x00000008   /* Prefetch 4 Mode Enable */
-#define  DMM_THROT         0x00000010   /* Assert IRDY when read FIFO full */
-#define  DMM_PAF0          0x00000000   /* Programmable Almost fill level */
-#define  DMM_PAF1          0x00000020   /* Programmable Almost fill level */
-#define  DMM_PAF2          0x00000040   /* Programmable Almost fill level */
-#define  DMM_PAF3          0x00000060   /* Programmable Almost fill level */
-#define  DMM_PAF4          0x00000080   /* Programmable Almost fill level */
-#define  DMM_PAF5          0x000000A0   /* Programmable Almost fill level */
-#define  DMM_PAF6          0x000000C0   /* Programmable Almost fill level */
-#define  DMM_PAF7          0x000000D0   /* Programmable Almost fill level */
-#define  DMM_MAP           0xFFFF0000   /* Remap Address Bits */
-
-#define PLX_CAR_REG            0x002C   /* L, Configuration Address Register */
-#define  CAR_CT0           0x00000000   /* Config Type 0 */
-#define  CAR_CT1           0x00000001   /* Config Type 1 */
-#define  CAR_REG           0x000000FC   /* Register Number Bits */
-#define  CAR_FUN           0x00000700   /* Function Number Bits */
-#define  CAR_DEV           0x0000F800   /* Device Number Bits */
-#define  CAR_BUS           0x00FF0000   /* Bus Number Bits */
-#define  CAR_CFG           0x80000000   /* Config Spc Access Enable */
-
-#define PLX_DBR_IN_REG         0x0060   /* L, PCI to Local Doorbell Register */
-
-#define PLX_DBR_OUT_REG        0x0064   /* L, Local to PCI Doorbell Register */
-
-#define PLX_INTRCS_REG         0x0068   /* L, Interrupt Control/Status Reg */
-#define  ICS_AERR          0x00000001   /* Assert LSERR on ABORT */
-#define  ICS_PERR          0x00000002   /* Assert LSERR on Parity Error */
-#define  ICS_SERR          0x00000004   /* Generate PCI SERR# */
-#define  ICS_MBIE          0x00000008   /*  mailbox interrupt enable */
-#define  ICS_PIE           0x00000100   /* PCI Interrupt Enable */
-#define  ICS_PDIE          0x00000200   /* PCI Doorbell Interrupt Enable */
-#define  ICS_PAIE          0x00000400   /* PCI Abort Interrupt Enable */
-#define  ICS_PLIE          0x00000800   /* PCI Local Int Enable */
-#define  ICS_RAE           0x00001000   /* Retry Abort Enable */
-#define  ICS_PDIA          0x00002000   /* PCI Doorbell Interrupt Active */
-#define  ICS_PAIA          0x00004000   /* PCI Abort Interrupt Active */
-#define  ICS_LIA           0x00008000   /* Local Interrupt Active */
-#define  ICS_LIE           0x00010000   /* Local Interrupt Enable */
-#define  ICS_LDIE          0x00020000   /* Local Doorbell Int Enable */
-#define  ICS_DMA0_E        0x00040000   /* DMA #0 Interrupt Enable */
-#define  ICS_DMA1_E        0x00080000   /* DMA #1 Interrupt Enable */
-#define  ICS_LDIA          0x00100000   /* Local Doorbell Int Active */
-#define  ICS_DMA0_A        0x00200000   /* DMA #0 Interrupt Active */
-#define  ICS_DMA1_A        0x00400000   /* DMA #1 Interrupt Active */
-#define  ICS_BIA           0x00800000   /* BIST Interrupt Active */
-#define  ICS_TA_DM         0x01000000   /* Target Abort - Direct Master */
-#define  ICS_TA_DMA0       0x02000000   /* Target Abort - DMA #0 */
-#define  ICS_TA_DMA1       0x04000000   /* Target Abort - DMA #1 */
-#define  ICS_TA_RA         0x08000000   /* Target Abort - Retry Timeout */
-/*  mailbox x is active */
-#define  ICS_MBIA(x)       (0x10000000 << ((x) & 0x3))
-
-#define PLX_CONTROL_REG        0x006C   /* L, EEPROM Cntl & PCI Cmd Codes */
-#define  CTL_RDMA          0x0000000E   /* DMA Read Command */
-#define  CTL_WDMA          0x00000070   /* DMA Write Command */
-#define  CTL_RMEM          0x00000600   /* Memory Read Command */
-#define  CTL_WMEM          0x00007000   /* Memory Write Command */
-#define  CTL_USERO         0x00010000   /* USERO output pin control bit */
-#define  CTL_USERI         0x00020000   /* USERI input pin bit */
-#define  CTL_EE_CLK        0x01000000   /* EEPROM Clock line */
-#define  CTL_EE_CS         0x02000000   /* EEPROM Chip Select */
-#define  CTL_EE_W          0x04000000   /* EEPROM Write bit */
-#define  CTL_EE_R          0x08000000   /* EEPROM Read bit */
-#define  CTL_EECHK         0x10000000   /* EEPROM Present bit */
-#define  CTL_EERLD         0x20000000   /* EEPROM Reload Register */
-#define  CTL_RESET         0x40000000   /* !! Adapter Reset !! */
-#define  CTL_READY         0x80000000   /* Local Init Done */
-
-#define PLX_ID_REG      0x70    /*  hard-coded plx vendor and device ids */
-
-#define PLX_REVISION_REG        0x74    /*  silicon revision */
-
-#define PLX_DMA0_MODE_REG       0x80    /*  dma channel 0 mode register */
-#define PLX_DMA1_MODE_REG       0x94    /*  dma channel 0 mode register */
-#define  PLX_LOCAL_BUS_16_WIDE_BITS     0x1
-#define  PLX_LOCAL_BUS_32_WIDE_BITS     0x3
-#define  PLX_LOCAL_BUS_WIDTH_MASK       0x3
-#define  PLX_DMA_EN_READYIN_BIT 0x40    /*  enable ready in input */
-#define  PLX_EN_BTERM_BIT       0x80    /*  enable BTERM# input */
-#define  PLX_DMA_LOCAL_BURST_EN_BIT     0x100   /*  enable local burst mode */
-#define  PLX_EN_CHAIN_BIT       0x200   /*  enables chaining */
-/*  enables interrupt on dma done */
-#define  PLX_EN_DMA_DONE_INTR_BIT       0x400
-/*  hold local address constant (don't increment) */
-#define  PLX_LOCAL_ADDR_CONST_BIT       0x800
-/*  enables demand-mode for dma transfer */
-#define  PLX_DEMAND_MODE_BIT    0x1000
-#define  PLX_EOT_ENABLE_BIT     0x4000
-#define  PLX_STOP_MODE_BIT 0x8000
-/*  routes dma interrupt to pci bus (instead of local bus) */
-#define  PLX_DMA_INTR_PCI_BIT   0x20000
-
-/*  pci address that dma transfers start at */
-#define PLX_DMA0_PCI_ADDRESS_REG        0x84
-#define PLX_DMA1_PCI_ADDRESS_REG        0x98
-
-/*  local address that dma transfers start at */
-#define PLX_DMA0_LOCAL_ADDRESS_REG      0x88
-#define PLX_DMA1_LOCAL_ADDRESS_REG      0x9c
-
-/*  number of bytes to transfer (first 23 bits) */
-#define PLX_DMA0_TRANSFER_SIZE_REG      0x8c
-#define PLX_DMA1_TRANSFER_SIZE_REG      0xa0
-
-#define PLX_DMA0_DESCRIPTOR_REG 0x90    /*  descriptor pointer register */
-#define PLX_DMA1_DESCRIPTOR_REG 0xa4
-/*  descriptor is located in pci space (not local space) */
-#define  PLX_DESC_IN_PCI_BIT    0x1
-#define  PLX_END_OF_CHAIN_BIT   0x2     /*  end of chain bit */
-/*  interrupt when this descriptor's transfer is finished */
-#define  PLX_INTR_TERM_COUNT    0x4
-/*  transfer from local to pci bus (not pci to local) */
-#define  PLX_XFER_LOCAL_TO_PCI 0x8
-
-#define PLX_DMA0_CS_REG 0xa8    /*  command status register */
-#define PLX_DMA1_CS_REG 0xa9
-#define  PLX_DMA_EN_BIT 0x1     /*  enable dma channel */
-#define  PLX_DMA_START_BIT      0x2     /*  start dma transfer */
-#define  PLX_DMA_ABORT_BIT      0x4     /*  abort dma transfer */
-#define  PLX_CLEAR_DMA_INTR_BIT 0x8     /*  clear dma interrupt */
-#define  PLX_DMA_DONE_BIT       0x10    /*  transfer done status bit */
-
-#define PLX_DMA0_THRESHOLD_REG  0xb0    /*  command status register */
+#define PLX_MARBR_SUBSYSIDS     BIT(29)
+
+/* Big/Little Endian Descriptor Register */
+#define PLX_REG_BIGEND          0x000c
+
+/* Configuration Register Big Endian Mode */
+#define PLX_BIGEND_CONFIG       BIT(0)
+/* Direct Master Big Endian Mode */
+#define PLX_BIGEND_DM           BIT(1)
+/* Direct Slave Address Space 0 Big Endian Mode */
+#define PLX_BIGEND_DSAS0        BIT(2)
+/* Direct Slave Expansion ROM Big Endian Mode */
+#define PLX_BIGEND_EROM         BIT(3)
+/* Big Endian Byte Lane Mode - use most significant byte lanes */
+#define PLX_BIGEND_BEBLM        BIT(4)
+/* Direct Slave Address Space 1 Big Endian Mode */
+#define PLX_BIGEND_DSAS1        BIT(5)
+/* DMA Channel 1 Big Endian Mode */
+#define PLX_BIGEND_DMA1         BIT(6)
+/* DMA Channel 0 Big Endian Mode */
+#define PLX_BIGEND_DMA0         BIT(7)
+/* DMA Channel N Big Endian Mode (N <= 1) */
+#define PLX_BIGEND_DMA(n)       ((n) ? PLX_BIGEND_DMA1 : PLX_BIGEND_DMA0)
 
 /*
- * Accesses near the end of memory can cause the PLX chip
- * to pre-fetch data off of end-of-ram.  Limit the size of
- * memory so host-side accesses cannot occur.
+ * Note: The Expansion ROM  stuff is only relevant to the PC environment.
+ *       This expansion ROM code is executed by the host CPU at boot time.
+ *       For this reason no bit definitions are provided here.
  */
 
-#define PLX_PREFETCH   32
+/* Expansion ROM Range Register */
+#define PLX_REG_EROMRR          0x0010
+/* Expansion ROM Local Base Address (Remap) Register */
+#define PLX_REG_EROMBA          0x0014
+
+/* Local Address Space 0/Expansion ROM Bus Region Descriptor Register */
+#define PLX_REG_LBRD0           0x0018
+/* Local Address Space 1 Bus Region Descriptor Register */
+#define PLX_REG_LBRD1           0x00f8
+
+/* Memory Space Local Bus Width */
+#define PLX_LBRD_MSWIDTH8       (BIT(0) * 0)    /* 8 bits wide */
+#define PLX_LBRD_MSWIDTH16      (BIT(0) * 1)    /* 16 bits wide */
+#define PLX_LBRD_MSWIDTH32      (BIT(0) * 2)    /* 32 bits wide */
+#define PLX_LBRD_MSWIDTH32A     (BIT(0) * 3)    /* 32 bits wide */
+#define PLX_LBRD_MSWIDTH_MASK   GENMASK(1, 0)
+#define PLX_LBRD_MSWIDTH_SHIFT  0
+/* Memory Space Internal Wait States */
+#define PLX_LBRD_MSIWS(x)       (BIT(2) * ((x) & 0xf))
+#define PLX_LBRD_MSIWS_MASK     GENMASK(5, 2)
+#define PLX_LBRD_MSIWS_SHIFT    2
+/* Memory Space Ready Input Enable */
+#define PLX_LBRD_MSREADYIEN     BIT(6)
+/* Memory Space BTERM# Input Enable */
+#define PLX_LBRD_MSBTERMIEN     BIT(7)
+/* Memory Space 0 Prefetch Disable (LBRD0 only) */
+#define PLX_LBRD0_MSPREDIS      BIT(8)
+/* Memory Space 1 Burst Enable (LBRD1 only) */
+#define PLX_LBRD1_MSBURSTEN     BIT(8)
+/* Expansion ROM Space Prefetch Disable (LBRD0 only) */
+#define PLX_LBRD0_EROMPREDIS    BIT(9)
+/* Memory Space 1 Prefetch Disable (LBRD1 only) */
+#define PLX_LBRD1_MSPREDIS      BIT(9)
+/* Read Prefetch Count Enable */
+#define PLX_LBRD_RPFCOUNTEN     BIT(10)
+/* Prefetch Counter */
+#define PLX_LBRD_PFCOUNT(x)     (BIT(11) * ((x) & 0xf))
+#define PLX_LBRD_PFCOUNT_MASK   GENMASK(14, 11)
+#define PLX_LBRD_PFCOUNT_SHIFT  11
+/* Expansion ROM Space Local Bus Width (LBRD0 only) */
+#define PLX_LBRD0_EROMWIDTH8    (BIT(16) * 0)   /* 8 bits wide */
+#define PLX_LBRD0_EROMWIDTH16   (BIT(16) * 1)   /* 16 bits wide */
+#define PLX_LBRD0_EROMWIDTH32   (BIT(16) * 2)   /* 32 bits wide */
+#define PLX_LBRD0_EROMWIDTH32A  (BIT(16) * 3)   /* 32 bits wide */
+#define PLX_LBRD0_EROMWIDTH_MASK        GENMASK(17, 16)
+#define PLX_LBRD0_EROMWIDTH_SHIFT       16
+/* Expansion ROM Space Internal Wait States (LBRD0 only) */
+#define PLX_LBRD0_EROMIWS(x)    (BIT(18) * ((x) & 0xf))
+#define PLX_LBRD0_EROMIWS_MASK  GENMASK(21, 18)
+#define PLX_LBRD0_EROMIWS_SHIFT 18
+/* Expansion ROM Space Ready Input Enable (LBDR0 only) */
+#define PLX_LBRD0_EROMREADYIEN  BIT(22)
+/* Expansion ROM Space BTERM# Input Enable (LBRD0 only) */
+#define PLX_LBRD0_EROMBTERMIEN  BIT(23)
+/* Memory Space 0 Burst Enable (LBRD0 only) */
+#define PLX_LBRD0_MSBURSTEN     BIT(24)
+/* Extra Long Load From Serial EEPROM  (LBRD0 only) */
+#define PLX_LBRD0_EELONGLOAD    BIT(25)
+/* Expansion ROM Space Burst Enable (LBRD0 only) */
+#define PLX_LBRD0_EROMBURSTEN   BIT(26)
+/* Direct Slave PCI Write Mode - assert TRDY# when FIFO full (LBRD0 only) */
+#define PLX_LBRD0_DSWMTRDY      BIT(27)
+/* PCI Target Retry Delay Clocks / 8 (LBRD0 only) */
+#define PLX_LBRD0_TRDELAY(x)    (BIT(28) * ((x) & 0xF))
+#define PLX_LBRD0_TRDELAY_MASK  GENMASK(31, 28)
+#define PLX_LBRD0_TRDELAY_SHIFT 28
+
+/* Local Range Register for Direct Master to PCI */
+#define PLX_REG_DMRR            0x001c
+
+/* Local Bus Base Address Register for Direct Master to PCI Memory */
+#define PLX_REG_DMLBAM          0x0020
+
+/* Local Base Address Register for Direct Master to PCI IO/CFG */
+#define PLX_REG_DMLBAI          0x0024
+
+/* PCI Base Address (Remap) Register for Direct Master to PCI Memory */
+#define PLX_REG_DMPBAM          0x0028
+
+/* Direct Master Memory Access Enable */
+#define PLX_DMPBAM_MEMACCEN     BIT(0)
+/* Direct Master I/O Access Enable */
+#define PLX_DMPBAM_IOACCEN      BIT(1)
+/* LLOCK# Input Enable */
+#define PLX_DMPBAM_LLOCKIEN     BIT(2)
+/* Direct Master Read Prefetch Size Control (bits 12, 3) */
+#define PLX_DMPBAM_RPSIZECONT   ((BIT(12) * 0) | (BIT(3) * 0))
+#define PLX_DMPBAM_RPSIZE4      ((BIT(12) * 0) | (BIT(3) * 1))
+#define PLX_DMPBAM_RPSIZE8      ((BIT(12) * 1) | (BIT(3) * 0))
+#define PLX_DMPBAM_RPSIZE16     ((BIT(12) * 1) | (BIT(3) * 1))
+#define PLX_DMPBAM_RPSIZE_MASK  (BIT(12) | BIT(3))
+/* Direct Master PCI Read Mode - deassert IRDY when FIFO full */
+#define PLX_DMPBAM_RMIRDY       BIT(4)
+/* Programmable Almost Full Level (bits 10, 8:5) */
+#define PLX_DMPBAM_PAFL(x)      ((BIT(10) * !!((x) & 0x10)) | \
+                                 (BIT(5) * ((x) & 0xf)))
+#define PLX_DMPBAM_TO_PAFL(v)   ((((BIT(10) & (v)) >> 1) | \
+                                  (GENMASK(8, 5) & (v))) >> 5)
+#define PLX_DMPBAM_PAFL_MASK    (BIT(10) | GENMASK(8, 5))
+/* Write And Invalidate Mode */
+#define PLX_DMPBAM_WIM          BIT(9)
+/* Direct Master Prefetch Limit */
+#define PLX_DBPBAM_PFLIMIT      BIT(11)
+/* I/O Remap Select */
+#define PLX_DMPBAM_IOREMAPSEL   BIT(13)
+/* Direct Master Write Delay */
+#define PLX_DMPBAM_WDELAYNONE   (BIT(14) * 0)
+#define PLX_DMPBAM_WDELAY4      (BIT(14) * 1)
+#define PLX_DMPBAM_WDELAY8      (BIT(14) * 2)
+#define PLX_DMPBAM_WDELAY16     (BIT(14) * 3)
+#define PLX_DMPBAM_WDELAY_MASK  GENMASK(15, 14)
+/* Remap of Local-to-PCI Space Into PCI Address Space */
+#define PLX_DMPBAM_REMAP_MASK   GENMASK(31, 16)
+
+/* PCI Configuration Address Register for Direct Master to PCI IO/CFG */
+#define PLX_REG_DMCFGA          0x002c
+
+/* Congiguration Type */
+#define PLX_DMCFGA_TYPE0        (BIT(0) * 0)
+#define PLX_DMCFGA_TYPE1        (BIT(0) * 1)
+#define PLX_DMCFGA_TYPE_MASK    GENMASK(1, 0)
+/* Register Number */
+#define PLX_DMCFGA_REGNUM(x)    (BIT(2) * ((x) & 0x3f))
+#define PLX_DMCFGA_REGNUM_MASK  GENMASK(7, 2)
+#define PLX_DMCFGA_REGNUM_SHIFT 2
+/* Function Number */
+#define PLX_DMCFGA_FUNCNUM(x)   (BIT(8) * ((x) & 0x7))
+#define PLX_DMCFGA_FUNCNUM_MASK GENMASK(10, 8)
+#define PLX_DMCFGA_FUNCNUM_SHIFT 8
+/* Device Number */
+#define PLX_DMCFGA_DEVNUM(x)    (BIT(11) * ((x) & 0x1f))
+#define PLX_DMCFGA_DEVNUM_MASK  GENMASK(15, 11)
+#define PLX_DMCFGA_DEVNUM_SHIFT 11
+/* Bus Number */
+#define PLX_DMCFGA_BUSNUM(x)    (BIT(16) * ((x) & 0xff))
+#define PLX_DMCFGA_BUSNUM_MASK  GENMASK(23, 16)
+#define PLX_DMCFGA_BUSNUM_SHIFT 16
+/* Configuration Enable */
+#define PLX_DMCFGA_CONFIGEN     BIT(31)
 
 /*
- * The PCI Interface, via the PCI-9060 Chip, has up to eight (8) Mailbox
- * Registers.  The PUTS (Power-Up Test Suite) handles the board-side
- * interface/interaction using the first 4 registers.  Specifications for
- * the use of the full PUTS' command and status interface is contained
- * within a separate SBE PUTS Manual.  The Host-Side Device Driver only
- * uses a subset of the full PUTS interface.
+ * Mailbox Register N (N <= 7)
+ *
+ * Note that if the I2O feature is enabled (QSR[0] is set), Mailbox Register 0
+ * is replaced by the Inbound Queue Port, and Mailbox Register 1 is replaced
+ * by the Outbound Queue Port.  However, Mailbox Register 0 and 1 are always
+ * accessible at alternative offsets if the I2O feature is enabled.
  */
+#define PLX_REG_MBOX(n)         (0x0040 + (n) * 4)
+#define PLX_REG_MBOX0           PLX_REG_MBOX(0)
+#define PLX_REG_MBOX1           PLX_REG_MBOX(1)
+#define PLX_REG_MBOX2           PLX_REG_MBOX(2)
+#define PLX_REG_MBOX3           PLX_REG_MBOX(3)
+#define PLX_REG_MBOX4           PLX_REG_MBOX(4)
+#define PLX_REG_MBOX5           PLX_REG_MBOX(5)
+#define PLX_REG_MBOX6           PLX_REG_MBOX(6)
+#define PLX_REG_MBOX7           PLX_REG_MBOX(7)
+
+/* Alternative offsets for Mailbox Registers 0 and 1 (in case I2O is enabled) */
+#define PLX_REG_ALT_MBOX(n)     ((n) < 2 ? 0x0078 + (n) * 4 : PLX_REG_MBOX(n))
+#define PLX_REG_ALT_MBOX0       PLX_REG_ALT_MBOX(0)
+#define PLX_REG_ALT_MBOX1       PLX_REG_ALT_MBOX(1)
+
+/* PCI-to-Local Doorbell Register */
+#define PLX_REG_P2LDBELL        0x0060
+
+/* Local-to-PCI Doorbell Register */
+#define PLX_REG_L2PDBELL        0x0064
+
+/* Interrupt Control/Status Register */
+#define PLX_REG_INTCSR          0x0068
+
+/* Enable Local Bus LSERR# when PCI Bus Target Abort or Master Abort occurs */
+#define PLX_INTCSR_LSEABORTEN   BIT(0)
+/* Enable Local Bus LSERR# when PCI parity error occurs */
+#define PLX_INTCSR_LSEPARITYEN  BIT(1)
+/* Generate PCI Bus SERR# when set to 1 */
+#define PLX_INTCSR_GENSERR      BIT(2)
+/* Mailbox Interrupt Enable (local bus interrupts on PCI write to MBOX0-3) */
+#define PLX_INTCSR_MBIEN        BIT(3)
+/* PCI Interrupt Enable */
+#define PLX_INTCSR_PIEN         BIT(8)
+/* PCI Doorbell Interrupt Enable */
+#define PLX_INTCSR_PDBIEN       BIT(9)
+/* PCI Abort Interrupt Enable */
+#define PLX_INTCSR_PABORTIEN    BIT(10)
+/* PCI Local Interrupt Enable */
+#define PLX_INTCSR_PLIEN        BIT(11)
+/* Retry Abort Enable (for diagnostic purposes only) */
+#define PLX_INTCSR_RAEN         BIT(12)
+/* PCI Doorbell Interrupt Active (read-only) */
+#define PLX_INTCSR_PDBIA        BIT(13)
+/* PCI Abort Interrupt Active (read-only) */
+#define PLX_INTCSR_PABORTIA     BIT(14)
+/* Local Interrupt (LINTi#) Active (read-only) */
+#define PLX_INTCSR_PLIA         BIT(15)
+/* Local Interrupt Output (LINTo#) Enable */
+#define PLX_INTCSR_LIOEN        BIT(16)
+/* Local Doorbell Interrupt Enable */
+#define PLX_INTCSR_LDBIEN       BIT(17)
+/* DMA Channel 0 Interrupt Enable */
+#define PLX_INTCSR_DMA0IEN      BIT(18)
+/* DMA Channel 1 Interrupt Enable */
+#define PLX_INTCSR_DMA1IEN      BIT(19)
+/* DMA Channel N Interrupt Enable (N <= 1) */
+#define PLX_INTCSR_DMAIEN(n)    ((n) ? PLX_INTCSR_DMA1IEN : PLX_INTCSR_DMA0IEN)
+/* Local Doorbell Interrupt Active (read-only) */
+#define PLX_INTCSR_LDBIA        BIT(20)
+/* DMA Channel 0 Interrupt Active (read-only) */
+#define PLX_INTCSR_DMA0IA       BIT(21)
+/* DMA Channel 1 Interrupt Active (read-only) */
+#define PLX_INTCSR_DMA1IA       BIT(22)
+/* DMA Channel N Interrupt Active (N <= 1) (read-only) */
+#define PLX_INTCSR_DMAIA(n)     ((n) ? PLX_INTCSR_DMA1IA : PLX_INTCSR_DMA0IA)
+/* BIST Interrupt Active (read-only) */
+#define PLX_INTCSR_BISTIA       BIT(23)
+/* Direct Master Not Bus Master During Master Or Target Abort (read-only) */
+#define PLX_INTCSR_ABNOTDM      BIT(24)
+/* DMA Channel 0 Not Bus Master During Master Or Target Abort (read-only) */
+#define PLX_INTCSR_ABNOTDMA0    BIT(25)
+/* DMA Channel 1 Not Bus Master During Master Or Target Abort (read-only) */
+#define PLX_INTCSR_ABNOTDMA1    BIT(26)
+/* DMA Channel N Not Bus Master During Master Or Target Abort (read-only) */
+#define PLX_INTCSR_ABNOTDMA(n)  ((n) ? PLX_INTCSR_ABNOTDMA1 \
+                                     : PLX_INTCSR_ABNOTDMA0)
+/* Target Abort Not Generated After 256 Master Retries (read-only) */
+#define PLX_INTCSR_ABNOTRETRY   BIT(27)
+/* PCI Wrote Mailbox 0 (enabled if bit 3 set) (read-only) */
+#define PLX_INTCSR_MB0IA        BIT(28)
+/* PCI Wrote Mailbox 1 (enabled if bit 3 set) (read-only) */
+#define PLX_INTCSR_MB1IA        BIT(29)
+/* PCI Wrote Mailbox 2 (enabled if bit 3 set) (read-only) */
+#define PLX_INTCSR_MB2IA        BIT(30)
+/* PCI Wrote Mailbox 3 (enabled if bit 3 set) (read-only) */
+#define PLX_INTCSR_MB3IA        BIT(31)
+/* PCI Wrote Mailbox N (N <= 3) (enabled if bit 3 set) (read-only) */
+#define PLX_INTCSR_MBIA(n)      BIT(28 + (n))
 
-/*****************************************/
-/***    MAILBOX #(-1) - MEM ACCESS STS ***/
-/*****************************************/
-
-#define MBX_STS_VALID      0x57584744   /* 'WXGD' */
-#define MBX_STS_DILAV      0x44475857   /* swapped = 'DGXW' */
-
-/*****************************************/
-/***    MAILBOX #0  -  PUTS STATUS     ***/
-/*****************************************/
-
-#define MBX_STS_MASK       0x000000ff   /* PUTS Status Register bits */
-#define MBX_STS_TMASK      0x0000000f   /* register bits for TEST number */
-
-#define MBX_STS_PCIRESET   0x00000100   /* Host issued PCI reset request */
-#define MBX_STS_BUSY       0x00000080   /* PUTS is in progress */
-#define MBX_STS_ERROR      0x00000040   /* PUTS has failed */
 /*
- * Undefined -> status in transition. We are in process of changing bits;
- * we SET Error bit before RESET of Busy bit
+ * Serial EEPROM Control, PCI Command Codes, User I/O Control,
+ * Init Control Register
  */
-#define MBX_STS_RESERVED   0x000000c0
-
-#define MBX_RESERVED_5     0x00000020   /* FYI: reserved/unused bit */
-#define MBX_RESERVED_4     0x00000010   /* FYI: reserved/unused bit */
-
-/******************************************/
-/***    MAILBOX #1  -  PUTS COMMANDS    ***/
-/******************************************/
-
+#define PLX_REG_CNTRL           0x006c
+
+/* PCI Read Command Code For DMA */
+#define PLX_CNTRL_CCRDMA(x)     (BIT(0) * ((x) & 0xf))
+#define PLX_CNTRL_CCRDMA_MASK   GENMASK(3, 0)
+#define PLX_CNTRL_CCRDMA_SHIFT  0
+#define PLX_CNTRL_CCRDMA_NORMAL PLX_CNTRL_CCRDMA(14)    /* value after reset */
+/* PCI Write Command Code For DMA 0 */
+#define PLX_CNTRL_CCWDMA(x)     (BIT(4) * ((x) & 0xf))
+#define PLX_CNTRL_CCWDMA_MASK   GENMASK(7, 4)
+#define PLX_CNTRL_CCWDMA_SHIFT  4
+#define PLX_CNTRL_CCWDMA_NORMAL PLX_CNTRL_CCWDMA(7)     /* value after reset */
+/* PCI Memory Read Command Code For Direct Master */
+#define PLX_CNTRL_CCRDM(x)      (BIT(8) * ((x) & 0xf))
+#define PLX_CNTRL_CCRDM_MASK    GENMASK(11, 8)
+#define PLX_CNTRL_CCRDM_SHIFT   8
+#define PLX_CNTRL_CCRDM_NORMAL  PLX_CNTRL_CCRDM(6)      /* value after reset */
+/* PCI Memory Write Command Code For Direct Master */
+#define PLX_CNTRL_CCWDM(x)      (BIT(12) * ((x) & 0xf))
+#define PLX_CNTRL_CCWDM_MASK    GENMASK(15, 12)
+#define PLX_CNTRL_CCWDM_SHIFT   12
+#define PLX_CNTRL_CCWDM_NORMAL  PLX_CNTRL_CCWDM(7)      /* value after reset */
+/* General Purpose Output (USERO) */
+#define PLX_CNTRL_USERO         BIT(16)
+/* General Purpose Input (USERI) (read-only) */
+#define PLX_CNTRL_USERI         BIT(17)
+/* Serial EEPROM Clock Output (EESK) */
+#define PLX_CNTRL_EESK          BIT(24)
+/* Serial EEPROM Chip Select Output (EECS) */
+#define PLX_CNTRL_EECS          BIT(25)
+/* Serial EEPROM Data Write Bit (EEDI (sic)) */
+#define PLX_CNTRL_EEWB          BIT(26)
+/* Serial EEPROM Data Read Bit (EEDO (sic)) (read-only) */
+#define PLX_CNTRL_EERB          BIT(27)
+/* Serial EEPROM Present (read-only) */
+#define PLX_CNTRL_EEPRESENT     BIT(28)
+/* Reload Configuration Registers from EEPROM */
+#define PLX_CNTRL_EERELOAD      BIT(29)
+/* PCI Adapter Software Reset (asserts LRESETo#) */
+#define PLX_CNTRL_RESET         BIT(30)
+/* Local Init Status (read-only) */
+#define PLX_CNTRL_INITDONE      BIT(31)
 /*
- * Any attempt to execute an unimplement command results in the PUTS
- * interface executing a NOOP and continuing as if the offending command
- * completed normally.  Note: this supplies a simple method to interrogate
- * mailbox command processing functionality.
+ * Combined command code stuff for convenience.
  */
+#define PLX_CNTRL_CC_MASK       \
+        (PLX_CNTRL_CCRDMA_MASK | PLX_CNTRL_CCWDMA_MASK | \
+         PLX_CNTRL_CCRDM_MASK | PLX_CNTRL_CCWDM_MASK)
+#define PLX_CNTRL_CC_NORMAL     \
+        (PLX_CNTRL_CCRDMA_NORMAL | PLX_CNTRL_CCWDMA_NORMAL | \
+         PLX_CNTRL_CCRDM_NORMAL | PLX_CNTRL_CCWDM_NORMAL) /* val after reset */
+
+/* PCI Permanent Configuration ID Register (hard-coded PLX vendor and device) */
+#define PLX_REG_PCIHIDR         0x0070
+
+/* Hard-coded ID for PLX PCI 9080 */
+#define PLX_PCIHIDR_9080        0x908010b5
+
+/* PCI Permanent Revision ID Register (hard-coded silicon revision) (8-bit). */
+#define PLX_REG_PCIHREV         0x0074
+
+/* DMA Channel N Mode Register (N <= 1) */
+#define PLX_REG_DMAMODE(n)      ((n) ? PLX_REG_DMAMODE1 : PLX_REG_DMAMODE0)
+#define PLX_REG_DMAMODE0        0x0080
+#define PLX_REG_DMAMODE1        0x0094
+
+/* Local Bus Width */
+#define PLX_DMAMODE_WIDTH8      (BIT(0) * 0)    /* 8 bits wide */
+#define PLX_DMAMODE_WIDTH16     (BIT(0) * 1)    /* 16 bits wide */
+#define PLX_DMAMODE_WIDTH32     (BIT(0) * 2)    /* 32 bits wide */
+#define PLX_DMAMODE_WIDTH32A    (BIT(0) * 3)    /* 32 bits wide */
+#define PLX_DMAMODE_WIDTH_MASK  GENMASK(1, 0)
+#define PLX_DMAMODE_WIDTH_SHIFT 0
+/* Internal Wait States */
+#define PLX_DMAMODE_IWS(x)      (BIT(2) * ((x) & 0xf))
+#define PLX_DMAMODE_IWS_MASK    GENMASK(5, 2)
+#define PLX_DMAMODE_SHIFT       2
+/* Ready Input Enable */
+#define PLX_DMAMODE_READYIEN    BIT(6)
+/* BTERM# Input Enable */
+#define PLX_DMAMODE_BTERMIEN    BIT(7)
+/* Local Burst Enable */
+#define PLX_DMAMODE_BURSTEN     BIT(8)
+/* Chaining Enable */
+#define PLX_DMAMODE_CHAINEN     BIT(9)
+/* Done Interrupt Enable */
+#define PLX_DMAMODE_DONEIEN     BIT(10)
+/* Hold Local Address Constant */
+#define PLX_DMAMODE_LACONST     BIT(11)
+/* Demand Mode */
+#define PLX_DMAMODE_DEMAND      BIT(12)
+/* Write And Invalidate Mode */
+#define PLX_DMAMODE_WINVALIDATE BIT(13)
+/* DMA EOT Enable - enables EOT0# or EOT1# input pin */
+#define PLX_DMAMODE_EOTEN       BIT(14)
+/* DMA Stop Data Transfer Mode - 0:BLAST; 1:EOT asserted or DREQ deasserted */
+#define PLX_DMAMODE_STOP        BIT(15)
+/* DMA Clear Count Mode - count in descriptor cleared on completion */
+#define PLX_DMAMODE_CLRCOUNT    BIT(16)
+/* DMA Channel Interrupt Select - 0:local bus interrupt; 1:PCI interrupt */
+#define PLX_DMAMODE_INTRPCI     BIT(17)
+
+/* DMA Channel N PCI Address Register (N <= 1) */
+#define PLX_REG_DMAPADR(n)      ((n) ? PLX_REG_DMAPADR1 : PLX_REG_DMAPADR0)
+#define PLX_REG_DMAPADR0        0x0084
+#define PLX_REG_DMAPADR1        0x0098
+
+/* DMA Channel N Local Address Register (N <= 1) */
+#define PLX_REG_DMALADR(n)      ((n) ? PLX_REG_DMALADR1 : PLX_REG_DMALADR0)
+#define PLX_REG_DMALADR0        0x0088
+#define PLX_REG_DMALADR1        0x009c
+
+/* DMA Channel N Transfer Size (Bytes) Register (N <= 1) (first 23 bits) */
+#define PLX_REG_DMASIZ(n)       ((n) ? PLX_REG_DMASIZ1 : PLX_REG_DMASIZ0)
+#define PLX_REG_DMASIZ0         0x008c
+#define PLX_REG_DMASIZ1         0x00a0
+
+/* DMA Channel N Descriptor Pointer Register (N <= 1) */
+#define PLX_REG_DMADPR(n)       ((n) ? PLX_REG_DMADPR1 : PLX_REG_DMADPR0)
+#define PLX_REG_DMADPR0         0x0090
+#define PLX_REG_DMADPR1         0x00a4
+
+/* Descriptor Located In PCI Address Space (not local address space) */
+#define PLX_DMADPR_DESCPCI      BIT(0)
+/* End Of Chain */
+#define PLX_DMADPR_CHAINEND     BIT(1)
+/* Interrupt After Terminal Count */
+#define PLX_DMADPR_TCINTR       BIT(2)
+/* Direction Of Transfer Local Bus To PCI (not PCI to local) */
+#define PLX_DMADPR_XFERL2P      BIT(3)
+/* Next Descriptor Address Bits 31:4 (16 byte boundary) */
+#define PLX_DMADPR_NEXT_MASK    GENMASK(31, 4)
+
+/* DMA Channel N Command/Status Register (N <= 1) (8-bit) */
+#define PLX_REG_DMACSR(n)       ((n) ? PLX_REG_DMACSR1 : PLX_REG_DMACSR0)
+#define PLX_REG_DMACSR0         0x00a8
+#define PLX_REG_DMACSR1         0x00a9
+
+/* Channel Enable */
+#define PLX_DMACSR_ENABLE       BIT(0)
+/* Channel Start - write 1 to start transfer (write-only) */
+#define PLX_DMACSR_START        BIT(1)
+/* Channel Abort - write 1 to abort transfer (write-only) */
+#define PLX_DMACSR_ABORT        BIT(2)
+/* Clear Interrupt - write 1 to clear DMA Channel Interrupt (write-only) */
+#define PLX_DMACSR_CLEARINTR    BIT(3)
+/* Channel Done - transfer complete/inactive (read-only) */
+#define PLX_DMACSR_DONE         BIT(4)
+
+/* DMA Threshold Register */
+#define PLX_REG_DMATHR          0x00b0
 
-#define MBX_CMD_MASK       0xffff0000   /* PUTS Command Register bits */
-
-#define MBX_CMD_ABORTJ     0x85000000   /* abort and jump */
-#define MBX_CMD_RESETP     0x86000000   /* reset and pause at start */
-#define MBX_CMD_PAUSE      0x87000000   /* pause immediately */
-#define MBX_CMD_PAUSEC     0x88000000   /* pause on completion */
-#define MBX_CMD_RESUME     0x89000000   /* resume operation */
-#define MBX_CMD_STEP       0x8a000000   /* single step tests */
-
-#define MBX_CMD_BSWAP      0x8c000000   /* identify byte swap scheme */
-#define MBX_CMD_BSWAP_0    0x8c000000   /* use scheme 0 */
-#define MBX_CMD_BSWAP_1    0x8c000001   /* use scheme 1 */
-
-/* setup host memory access window size */
-#define MBX_CMD_SETHMS     0x8d000000
-/* setup host memory access base address */
-#define MBX_CMD_SETHBA     0x8e000000
-/* perform memory setup and continue (IE. Done) */
-#define MBX_CMD_MGO        0x8f000000
-#define MBX_CMD_NOOP       0xFF000000   /* dummy, illegal command */
-
-/*****************************************/
-/***    MAILBOX #2  -  MEMORY SIZE     ***/
-/*****************************************/
-
-#define MBX_MEMSZ_MASK     0xffff0000   /* PUTS Memory Size Register bits */
-
-#define MBX_MEMSZ_128KB    0x00020000   /* 128 kilobyte board */
-#define MBX_MEMSZ_256KB    0x00040000   /* 256 kilobyte board */
-#define MBX_MEMSZ_512KB    0x00080000   /* 512 kilobyte board */
-#define MBX_MEMSZ_1MB      0x00100000   /* 1 megabyte board */
-#define MBX_MEMSZ_2MB      0x00200000   /* 2 megabyte board */
-#define MBX_MEMSZ_4MB      0x00400000   /* 4 megabyte board */
-#define MBX_MEMSZ_8MB      0x00800000   /* 8 megabyte board */
-#define MBX_MEMSZ_16MB     0x01000000   /* 16 megabyte board */
-
-/***************************************/
-/***    MAILBOX #2  -  BOARD TYPE    ***/
-/***************************************/
-
-#define MBX_BTYPE_MASK          0x0000ffff      /* PUTS Board Type Register */
-/* PUTS Board Family Register */
-#define MBX_BTYPE_FAMILY_MASK   0x0000ff00
-#define MBX_BTYPE_SUBTYPE_MASK  0x000000ff      /* PUTS Board Subtype */
-
-#define MBX_BTYPE_PLX9060       0x00000100      /* PLX family type */
-#define MBX_BTYPE_PLX9080       0x00000300      /* PLX wanXL100s family type */
-
-#define MBX_BTYPE_WANXL_4       0x00000104      /* wanXL400, 4-port */
-#define MBX_BTYPE_WANXL_2       0x00000102      /* wanXL200, 2-port */
-#define MBX_BTYPE_WANXL_1s      0x00000301      /* wanXL100s, 1-port */
-#define MBX_BTYPE_WANXL_1t      0x00000401      /* wanXL100T1, 1-port */
+/*
+ * DMA Threshold constraints:
+ * (C0PLAF + 1) + (C0PLAE + 1) <= 32
+ * (C0LPAF + 1) + (C0LPAE + 1) <= 32
+ * (C1PLAF + 1) + (C1PLAE + 1) <= 16
+ * (C1LPAF + 1) + (C1LPAE + 1) <= 16
+ */
 
-/*****************************************/
-/***    MAILBOX #3  -  SHMQ MAILBOX    ***/
-/*****************************************/
+/* DMA Channel 0 PCI-to-Local Almost Full (divided by 2, minus 1) */
+#define PLX_DMATHR_C0PLAF(x)    (BIT(0) * ((x) & 0xf))
+#define PLX_DMATHR_C0PLAF_MASK  GENMASK(3, 0)
+#define PLX_DMATHR_C0PLAF_SHIFT 0
+/* DMA Channel 0 Local-to-PCI Almost Empty (divided by 2, minus 1) */
+#define PLX_DMATHR_C0LPAE(x)    (BIT(4) * ((x) & 0xf))
+#define PLX_DMATHR_C0LPAE_MASK  GENMASK(7, 4)
+#define PLX_DMATHR_C0LPAE_SHIFT 4
+/* DMA Channel 0 Local-to-PCI Almost Full (divided by 2, minus 1) */
+#define PLX_DMATHR_C0LPAF(x)    (BIT(8) * ((x) & 0xf))
+#define PLX_DMATHR_C0LPAF_MASK  GENMASK(11, 8)
+#define PLX_DMATHR_C0LPAF_SHIFT 8
+/* DMA Channel 0 PCI-to-Local Almost Empty (divided by 2, minus 1) */
+#define PLX_DMATHR_C0PLAE(x)    (BIT(12) * ((x) & 0xf))
+#define PLX_DMATHR_C0PLAE_MASK  GENMASK(15, 12)
+#define PLX_DMATHR_C0PLAE_SHIFT 12
+/* DMA Channel 1 PCI-to-Local Almost Full (divided by 2, minus 1) */
+#define PLX_DMATHR_C1PLAF(x)    (BIT(16) * ((x) & 0xf))
+#define PLX_DMATHR_C1PLAF_MASK  GENMASK(19, 16)
+#define PLX_DMATHR_C1PLAF_SHIFT 16
+/* DMA Channel 1 Local-to-PCI Almost Empty (divided by 2, minus 1) */
+#define PLX_DMATHR_C1LPAE(x)    (BIT(20) * ((x) & 0xf))
+#define PLX_DMATHR_C1LPAE_MASK  GENMASK(23, 20)
+#define PLX_DMATHR_C1LPAE_SHIFT 20
+/* DMA Channel 1 Local-to-PCI Almost Full (divided by 2, minus 1) */
+#define PLX_DMATHR_C1LPAF(x)    (BIT(24) * ((x) & 0xf))
+#define PLX_DMATHR_C1LPAF_MASK  GENMASK(27, 24)
+#define PLX_DMATHR_C1LPAF_SHIFT 24
+/* DMA Channel 1 PCI-to-Local Almost Empty (divided by 2, minus 1) */
+#define PLX_DMATHR_C1PLAE(x)    (BIT(28) * ((x) & 0xf))
+#define PLX_DMATHR_C1PLAE_MASK  GENMASK(31, 28)
+#define PLX_DMATHR_C1PLAE_SHIFT 28
 
-#define MBX_SMBX_MASK           0x000000ff      /* PUTS SHMQ Mailbox bits */
+/*
+ * Messaging Queue Registers OPLFIS, OPLFIM, IQP, OQP, MQCR, QBAR, IFHPR,
+ * IFTPR, IPHPR, IPTPR, OFHPR, OFTPR, OPHPR, OPTPR, and QSR have been omitted.
+ * They are used by the I2O feature.  (IQP and OQP occupy the usual offsets of
+ * the MBOX0 and MBOX1 registers if the I2O feature is enabled, but MBOX0 and
+ * MBOX1 are accessible via alternative offsets.
+ */
 
-/***************************************/
-/***    GENERIC HOST-SIDE DRIVER     ***/
-/***************************************/
+/* Queue Status/Control Register */
+#define PLX_REG_QSR             0x00e8
 
-#define MBX_ERR    0
-#define MBX_OK     1
+/* Value of QSR after reset - disables I2O feature completely. */
+#define PLX_QSR_VALUE_AFTER_RESET       0x00000050
 
-/* mailbox check routine - type of testing */
-#define MBXCHK_STS      0x00    /* check for PUTS status */
-#define MBXCHK_NOWAIT   0x01    /* dont care about PUTS status */
+/*
+ * Accesses near the end of memory can cause the PLX chip
+ * to pre-fetch data off of end-of-ram.  Limit the size of
+ * memory so host-side accesses cannot occur.
+ */
 
-/* system allocates this many bytes for address mapping mailbox space */
-#define MBX_ADDR_SPACE_360 0x80 /* wanXL100s/200/400 */
-#define MBX_ADDR_MASK_360 (MBX_ADDR_SPACE_360 - 1)
+#define PLX_PREFETCH   32
 
+/**
+ * plx9080_abort_dma - Abort a PLX PCI 9080 DMA transfer
+ * @iobase:     Remapped base address of configuration registers.
+ * @channel:    DMA channel number (0 or 1).
+ *
+ * Aborts the DMA transfer on the channel, which must have been enabled
+ * and started beforehand.
+ *
+ * Return:
+ *      %0 on success.
+ *      -%ETIMEDOUT if timed out waiting for abort to complete.
+ */
 static inline int plx9080_abort_dma(void __iomem *iobase, unsigned int channel)
 {
         void __iomem *dma_cs_addr;
@@ -421,29 +631,26 @@ static inline int plx9080_abort_dma(void __iomem *iobase, unsigned int channel)
         const int timeout = 10000;
         unsigned int i;
 
-        if (channel)
-                dma_cs_addr = iobase + PLX_DMA1_CS_REG;
-        else
-                dma_cs_addr = iobase + PLX_DMA0_CS_REG;
+        dma_cs_addr = iobase + PLX_REG_DMACSR(channel);
 
-        /*  abort dma transfer if necessary */
+        /* abort dma transfer if necessary */
         dma_status = readb(dma_cs_addr);
-        if ((dma_status & PLX_DMA_EN_BIT) == 0)
+        if ((dma_status & PLX_DMACSR_ENABLE) == 0)
                 return 0;
 
-        /*  wait to make sure done bit is zero */
-        for (i = 0; (dma_status & PLX_DMA_DONE_BIT) && i < timeout; i++) {
+        /* wait to make sure done bit is zero */
+        for (i = 0; (dma_status & PLX_DMACSR_DONE) && i < timeout; i++) {
                 udelay(1);
                 dma_status = readb(dma_cs_addr);
         }
         if (i == timeout)
                 return -ETIMEDOUT;
 
-        /*  disable and abort channel */
-        writeb(PLX_DMA_ABORT_BIT, dma_cs_addr);
-        /*  wait for dma done bit */
+        /* disable and abort channel */
+        writeb(PLX_DMACSR_ABORT, dma_cs_addr);
+        /* wait for dma done bit */
         dma_status = readb(dma_cs_addr);
-        for (i = 0; (dma_status & PLX_DMA_DONE_BIT) == 0 && i < timeout; i++) {
+        for (i = 0; (dma_status & PLX_DMACSR_DONE) == 0 && i < timeout; i++) {
                 udelay(1);
                 dma_status = readb(dma_cs_addr);
         }
diff --git a/drivers/staging/comedi/drivers/quatech_daqp_cs.c b/drivers/staging/comedi/drivers/quatech_daqp_cs.c
index e9e43139157d..802f51e46405 100644
--- a/drivers/staging/comedi/drivers/quatech_daqp_cs.c
+++ b/drivers/staging/comedi/drivers/quatech_daqp_cs.c
@@ -643,7 +643,7 @@ static int daqp_ao_insn_write(struct comedi_device *dev,
         outb(0, dev->iobase + DAQP_AUX_REG);
 
         for (i = 0; i > insn->n; i++) {
-                unsigned val = data[i];
+                unsigned int val = data[i];
                 int ret;
 
                 /* D/A transfer rate is about 8ms */
diff --git a/drivers/staging/comedi/drivers/rtd520.c b/drivers/staging/comedi/drivers/rtd520.c
index 9b6c56773247..e00e9c6268ae 100644
--- a/drivers/staging/comedi/drivers/rtd520.c
+++ b/drivers/staging/comedi/drivers/rtd520.c
@@ -362,7 +362,7 @@ struct rtd_private {
         long ai_count;          /* total transfer size (samples) */
         int xfer_count;         /* # to transfer data. 0->1/2FIFO */
         int flags;              /* flag event modes */
-        unsigned fifosz;
+        unsigned int fifosz;
 
         /* 8254 Timer/Counter gate and clock sources */
         unsigned char timer_gate_src[3];
@@ -491,9 +491,9 @@ static void rtd_load_channelgain_list(struct comedi_device *dev,
 static int rtd520_probe_fifo_depth(struct comedi_device *dev)
 {
         unsigned int chanspec = CR_PACK(0, 0, AREF_GROUND);
-        unsigned i;
-        static const unsigned limit = 0x2000;
-        unsigned fifo_size = 0;
+        unsigned int i;
+        static const unsigned int limit = 0x2000;
+        unsigned int fifo_size = 0;
 
         writel(0, dev->mmio + LAS0_ADC_FIFO_CLEAR);
         rtd_load_channelgain_list(dev, 1, &chanspec);
@@ -501,7 +501,7 @@ static int rtd520_probe_fifo_depth(struct comedi_device *dev)
         writel(0, dev->mmio + LAS0_ADC_CONVERSION);
         /* convert  samples */
         for (i = 0; i < limit; ++i) {
-                unsigned fifo_status;
+                unsigned int fifo_status;
                 /* trigger conversion */
                 writew(0, dev->mmio + LAS0_ADC);
                 usleep_range(1, 1000);
@@ -1175,7 +1175,7 @@ static void rtd_reset(struct comedi_device *dev)
 
         writel(0, dev->mmio + LAS0_BOARD_RESET);
         usleep_range(100, 1000);        /* needed? */
-        writel(0, devpriv->lcfg + PLX_INTRCS_REG);
+        writel(0, devpriv->lcfg + PLX_REG_INTCSR);
         writew(0, dev->mmio + LAS0_IT);
         writew(~0, dev->mmio + LAS0_CLEAR);
         readw(dev->mmio + LAS0_CLEAR);
@@ -1316,7 +1316,8 @@ static int rtd_auto_attach(struct comedi_device *dev,
         devpriv->fifosz = ret;
 
         if (dev->irq)
-                writel(ICS_PIE | ICS_PLIE, devpriv->lcfg + PLX_INTRCS_REG);
+                writel(PLX_INTCSR_PIEN | PLX_INTCSR_PLIEN,
+                       devpriv->lcfg + PLX_REG_INTCSR);
 
         return 0;
 }
diff --git a/drivers/staging/comedi/drivers/s626.c b/drivers/staging/comedi/drivers/s626.c
index c5e08635e01e..4a87b4b52400 100644
--- a/drivers/staging/comedi/drivers/s626.c
+++ b/drivers/staging/comedi/drivers/s626.c
@@ -708,7 +708,7 @@ static uint16_t s626_get_mode_a(struct comedi_device *dev,
         uint16_t cra;
         uint16_t crb;
         uint16_t setup;
-        unsigned cntsrc, clkmult, clkpol, encmode;
+        unsigned int cntsrc, clkmult, clkpol, encmode;
 
         /* Fetch CRA and CRB register images. */
         cra = s626_debi_read(dev, S626_LP_CRA(chan));
@@ -763,7 +763,7 @@ static uint16_t s626_get_mode_b(struct comedi_device *dev,
         uint16_t cra;
         uint16_t crb;
         uint16_t setup;
-        unsigned cntsrc, clkmult, clkpol, encmode;
+        unsigned int cntsrc, clkmult, clkpol, encmode;
 
         /* Fetch CRA and CRB register images. */
         cra = s626_debi_read(dev, S626_LP_CRA(chan));
@@ -838,7 +838,7 @@ static void s626_set_mode_a(struct comedi_device *dev,
         struct s626_private *devpriv = dev->private;
         uint16_t cra;
         uint16_t crb;
-        unsigned cntsrc, clkmult, clkpol;
+        unsigned int cntsrc, clkmult, clkpol;
 
         /* Initialize CRA and CRB images. */
         /* Preload trigger is passed through. */
@@ -916,7 +916,7 @@ static void s626_set_mode_b(struct comedi_device *dev,
         struct s626_private *devpriv = dev->private;
         uint16_t cra;
         uint16_t crb;
-        unsigned cntsrc, clkmult, clkpol;
+        unsigned int cntsrc, clkmult, clkpol;
 
         /* Initialize CRA and CRB images. */
         /* IndexSrc is passed through. */
diff --git a/drivers/staging/comedi/drivers/s626.h b/drivers/staging/comedi/drivers/s626.h
index b83424e7507b..6a00a64c6f3a 100644
--- a/drivers/staging/comedi/drivers/s626.h
+++ b/drivers/staging/comedi/drivers/s626.h
@@ -29,8 +29,10 @@
 #define S626_ENCODER_CHANNELS   6
 #define S626_DIO_CHANNELS       48
 #define S626_DIO_BANKS          3       /* Number of DIO groups. */
-#define S626_DIO_EXTCHANS       40      /* Number of extended-capability
-                                         * DIO channels. */
+#define S626_DIO_EXTCHANS       40      /*
+                                         * Number of extended-capability
+                                         * DIO channels.
+                                         */
 
 #define S626_NUM_TRIMDACS       12      /* Number of valid TrimDAC channels. */
 
@@ -48,21 +50,29 @@
 #define S626_GSEL_BIPOLAR10V    0x00A0  /* S626_LP_GSEL setting 10V bipolar. */
 
 /* Error codes that must be visible to this base class. */
-#define S626_ERR_ILLEGAL_PARM   0x00010000      /* Illegal function parameter
-                                                 * value was specified. */
+#define S626_ERR_ILLEGAL_PARM   0x00010000      /*
+                                                 * Illegal function parameter
+                                                 * value was specified.
+                                                 */
 #define S626_ERR_I2C            0x00020000      /* I2C error. */
-#define S626_ERR_COUNTERSETUP   0x00200000      /* Illegal setup specified for
-                                                 * counter channel. */
+#define S626_ERR_COUNTERSETUP   0x00200000      /*
+                                                 * Illegal setup specified for
+                                                 * counter channel.
+                                                 */
 #define S626_ERR_DEBI_TIMEOUT   0x00400000      /* DEBI transfer timed out. */
 
 /*
  * Organization (physical order) and size (in DWORDs) of logical DMA buffers
  * contained by ANA_DMABUF.
  */
-#define S626_ADC_DMABUF_DWORDS  40      /* ADC DMA buffer must hold 16 samples,
-                                         * plus pre/post garbage samples. */
-#define S626_DAC_WDMABUF_DWORDS 1       /* DAC output DMA buffer holds a single
-                                         * sample. */
+#define S626_ADC_DMABUF_DWORDS  40      /*
+                                         * ADC DMA buffer must hold 16 samples,
+                                         * plus pre/post garbage samples.
+                                         */
+#define S626_DAC_WDMABUF_DWORDS 1       /*
+                                         * DAC output DMA buffer holds a single
+                                         * sample.
+                                         */
 
 /* All remaining space in 4KB DMA buffer is available for the RPS1 program. */
 
@@ -95,60 +105,90 @@
 #define S626_RPS_IRQ            0x60000000      /* IRQ */
 
 #define S626_RPS_LOGICAL_OR     0x08000000      /* Logical OR conditionals. */
-#define S626_RPS_INVERT         0x04000000      /* Test for negated
-                                                 * semaphores. */
+#define S626_RPS_INVERT         0x04000000      /*
+                                                 * Test for negated
+                                                 * semaphores.
+                                                 */
 #define S626_RPS_DEBI           0x00000002      /* DEBI done */
 
-#define S626_RPS_SIG0           0x00200000      /* RPS semaphore 0
-                                                 * (used by ADC). */
-#define S626_RPS_SIG1           0x00400000      /* RPS semaphore 1
-                                                 * (used by DAC). */
-#define S626_RPS_SIG2           0x00800000      /* RPS semaphore 2
-                                                 * (not used). */
+#define S626_RPS_SIG0           0x00200000      /*
+                                                 * RPS semaphore 0
+                                                 * (used by ADC).
+                                                 */
+#define S626_RPS_SIG1           0x00400000      /*
+                                                 * RPS semaphore 1
+                                                 * (used by DAC).
+                                                 */
+#define S626_RPS_SIG2           0x00800000      /*
+                                                 * RPS semaphore 2
+                                                 * (not used).
+                                                 */
 #define S626_RPS_GPIO2          0x00080000      /* RPS GPIO2 */
 #define S626_RPS_GPIO3          0x00100000      /* RPS GPIO3 */
 
-#define S626_RPS_SIGADC         S626_RPS_SIG0   /* Trigger/status for
-                                                 * ADC's RPS program. */
-#define S626_RPS_SIGDAC         S626_RPS_SIG1   /* Trigger/status for
-                                                 * DAC's RPS program. */
+#define S626_RPS_SIGADC         S626_RPS_SIG0   /*
+                                                 * Trigger/status for
+                                                 * ADC's RPS program.
+                                                 */
+#define S626_RPS_SIGDAC         S626_RPS_SIG1   /*
+                                                 * Trigger/status for
+                                                 * DAC's RPS program.
+                                                 */
 
 /* RPS clock parameters. */
-#define S626_RPSCLK_SCALAR      8       /* This is apparent ratio of
-                                         * PCI/RPS clks (undocumented!!). */
+#define S626_RPSCLK_SCALAR      8       /*
+                                         * This is apparent ratio of
+                                         * PCI/RPS clks (undocumented!!).
+                                         */
 #define S626_RPSCLK_PER_US      (33 / S626_RPSCLK_SCALAR)
-                                        /* Number of RPS clocks in one
-                                         * microsecond. */
+                                        /*
+                                         * Number of RPS clocks in one
+                                         * microsecond.
+                                         */
 
 /* Event counter source addresses. */
 #define S626_SBA_RPS_A0         0x27    /* Time of RPS0 busy, in PCI clocks. */
 
 /* GPIO constants. */
-#define S626_GPIO_BASE          0x10004000      /* GPIO 0,2,3 = inputs,
-                                                 * GPIO3 = IRQ; GPIO1 = out. */
+#define S626_GPIO_BASE          0x10004000      /*
+                                                 * GPIO 0,2,3 = inputs,
+                                                 * GPIO3 = IRQ; GPIO1 = out.
+                                                 */
 #define S626_GPIO1_LO           0x00000000      /* GPIO1 set to LOW. */
 #define S626_GPIO1_HI           0x00001000      /* GPIO1 set to HIGH. */
 
 /* Primary Status Register (PSR) constants. */
 #define S626_PSR_DEBI_E         0x00040000      /* DEBI event flag. */
 #define S626_PSR_DEBI_S         0x00080000      /* DEBI status flag. */
-#define S626_PSR_A2_IN          0x00008000      /* Audio output DMA2 protection
-                                                 * address reached. */
-#define S626_PSR_AFOU           0x00000800      /* Audio FIFO under/overflow
-                                                 * detected. */
-#define S626_PSR_GPIO2          0x00000020      /* GPIO2 input pin: 0=AdcBusy,
-                                                 * 1=AdcIdle. */
-#define S626_PSR_EC0S           0x00000001      /* Event counter 0 threshold
-                                                 * reached. */
+#define S626_PSR_A2_IN          0x00008000      /*
+                                                 * Audio output DMA2 protection
+                                                 * address reached.
+                                                 */
+#define S626_PSR_AFOU           0x00000800      /*
+                                                 * Audio FIFO under/overflow
+                                                 * detected.
+                                                 */
+#define S626_PSR_GPIO2          0x00000020      /*
+                                                 * GPIO2 input pin: 0=AdcBusy,
+                                                 * 1=AdcIdle.
+                                                 */
+#define S626_PSR_EC0S           0x00000001      /*
+                                                 * Event counter 0 threshold
+                                                 * reached.
+                                                 */
 
 /* Secondary Status Register (SSR) constants. */
-#define S626_SSR_AF2_OUT        0x00000200      /* Audio 2 output FIFO
-                                                 * under/overflow detected. */
+#define S626_SSR_AF2_OUT        0x00000200      /*
+                                                 * Audio 2 output FIFO
+                                                 * under/overflow detected.
+                                                 */
 
 /* Master Control Register 1 (MC1) constants. */
 #define S626_MC1_SOFT_RESET     0x80000000      /* Invoke 7146 soft reset. */
-#define S626_MC1_SHUTDOWN       0x3FFF0000      /* Shut down all MC1-controlled
-                                                 * enables. */
+#define S626_MC1_SHUTDOWN       0x3FFF0000      /*
+                                                 * Shut down all MC1-controlled
+                                                 * enables.
+                                                 */
 
 #define S626_MC1_ERPS1          0x2000  /* Enab/disable RPS task 1. */
 #define S626_MC1_ERPS0          0x1000  /* Enab/disable RPS task 0. */
@@ -177,15 +217,23 @@
 #define S626_P_DEBIAD           0x0088  /* DEBI target address. */
 #define S626_P_I2CCTRL          0x008C  /* I2C control. */
 #define S626_P_I2CSTAT          0x0090  /* I2C status. */
-#define S626_P_BASEA2_IN        0x00AC  /* Audio input 2 base physical DMAbuf
-                                         * address. */
-#define S626_P_PROTA2_IN        0x00B0  /* Audio input 2 physical DMAbuf
-                                         * protection address. */
+#define S626_P_BASEA2_IN        0x00AC  /*
+                                         * Audio input 2 base physical DMAbuf
+                                         * address.
+                                         */
+#define S626_P_PROTA2_IN        0x00B0  /*
+                                         * Audio input 2 physical DMAbuf
+                                         * protection address.
+                                         */
 #define S626_P_PAGEA2_IN        0x00B4  /* Audio input 2 paging attributes. */
-#define S626_P_BASEA2_OUT       0x00B8  /* Audio output 2 base physical DMAbuf
-                                         * address. */
-#define S626_P_PROTA2_OUT       0x00BC  /* Audio output 2 physical DMAbuf
-                                         * protection address. */
+#define S626_P_BASEA2_OUT       0x00B8  /*
+                                         * Audio output 2 base physical DMAbuf
+                                         * address.
+                                         */
+#define S626_P_PROTA2_OUT       0x00BC  /*
+                                         * Audio output 2 physical DMAbuf
+                                         * protection address.
+                                         */
 #define S626_P_PAGEA2_OUT       0x00C0  /* Audio output 2 paging attributes. */
 #define S626_P_RPSPAGE0         0x00C4  /* RPS0 page. */
 #define S626_P_RPSPAGE1         0x00C8  /* RPS1 page. */
@@ -205,8 +253,10 @@
 #define S626_P_PSR              0x0110  /* Primary status. */
 #define S626_P_SSR              0x0114  /* Secondary status. */
 #define S626_P_EC1R             0x0118  /* Event counter set 1. */
-#define S626_P_ADP4             0x0138  /* Logical audio DMA pointer of audio
-                                         * input FIFO A2_IN. */
+#define S626_P_ADP4             0x0138  /*
+                                         * Logical audio DMA pointer of audio
+                                         * input FIFO A2_IN.
+                                         */
 #define S626_P_FB_BUFFER1       0x0144  /* Audio feedback buffer 1. */
 #define S626_P_FB_BUFFER2       0x0148  /* Audio feedback buffer 2. */
 #define S626_P_TSL1             0x0180  /* Audio time slot list 1. */
@@ -243,13 +293,19 @@
 #define S626_LP_RDMISC2         0x0082  /* Read Misc2. */
 
 /* Bit masks for MISC1 register that are the same for reads and writes. */
-#define S626_MISC1_WENABLE      0x8000  /* enab writes to MISC2 (except Clear
-                                         * Watchdog bit). */
+#define S626_MISC1_WENABLE      0x8000  /*
+                                         * enab writes to MISC2 (except Clear
+                                         * Watchdog bit).
+                                         */
 #define S626_MISC1_WDISABLE     0x0000  /* Disable writes to MISC2. */
-#define S626_MISC1_EDCAP        0x1000  /* Enable edge capture on DIO chans
-                                         * specified by S626_LP_WRCAPSELx. */
-#define S626_MISC1_NOEDCAP      0x0000  /* Disable edge capture on specified
-                                         * DIO chans. */
+#define S626_MISC1_EDCAP        0x1000  /*
+                                         * Enable edge capture on DIO chans
+                                         * specified by S626_LP_WRCAPSELx.
+                                         */
+#define S626_MISC1_NOEDCAP      0x0000  /*
+                                         * Disable edge capture on specified
+                                         * DIO chans.
+                                         */
 
 /* Bit masks for MISC1 register reads. */
 #define S626_RDMISC1_WDTIMEOUT  0x4000  /* Watchdog timer timed out. */
@@ -268,35 +324,49 @@
 #define S626_A1_RUN             0x20000000      /* Run A1 based on TSL1. */
 #define S626_A1_SWAP            0x00200000      /* Use big-endian for A1. */
 #define S626_A2_SWAP            0x00100000      /* Use big-endian for A2. */
-#define S626_WS_MODES           0x00019999      /* WS0 = TSL1 trigger input,
-                                                 * WS1-WS4 = CS* outputs. */
-
-#if S626_PLATFORM == S626_INTEL         /* Base ACON1 config: always run
-                                         * A1 based on TSL1. */
+#define S626_WS_MODES           0x00019999      /*
+                                                 * WS0 = TSL1 trigger input,
+                                                 * WS1-WS4 = CS* outputs.
+                                                 */
+
+#if S626_PLATFORM == S626_INTEL         /*
+                                         * Base ACON1 config: always run
+                                         * A1 based on TSL1.
+                                         */
 #define S626_ACON1_BASE         (S626_WS_MODES | S626_A1_RUN)
 #elif S626_PLATFORM == S626_MOTOROLA
 #define S626_ACON1_BASE         \
         (S626_WS_MODES | S626_A1_RUN | S626_A1_SWAP | S626_A2_SWAP)
 #endif
 
-#define S626_ACON1_ADCSTART     S626_ACON1_BASE /* Start ADC: run A1
-                                                 * based on TSL1. */
+#define S626_ACON1_ADCSTART     S626_ACON1_BASE /*
+                                                 * Start ADC: run A1
+                                                 * based on TSL1.
+                                                 */
 #define S626_ACON1_DACSTART     (S626_ACON1_BASE | S626_A2_RUN)
 /* Start transmit to DAC: run A2 based on TSL2. */
 #define S626_ACON1_DACSTOP      S626_ACON1_BASE /* Halt A2. */
 
 /* Bit masks for ACON2 register. */
 #define S626_A1_CLKSRC_BCLK1    0x00000000      /* A1 bit rate = BCLK1 (ADC). */
-#define S626_A2_CLKSRC_X1       0x00800000      /* A2 bit rate = ACLK/1
-                                                 * (DACs). */
-#define S626_A2_CLKSRC_X2       0x00C00000      /* A2 bit rate = ACLK/2
-                                                 * (DACs). */
-#define S626_A2_CLKSRC_X4       0x01400000      /* A2 bit rate = ACLK/4
-                                                 * (DACs). */
+#define S626_A2_CLKSRC_X1       0x00800000      /*
+                                                 * A2 bit rate = ACLK/1
+                                                 * (DACs).
+                                                 */
+#define S626_A2_CLKSRC_X2       0x00C00000      /*
+                                                 * A2 bit rate = ACLK/2
+                                                 * (DACs).
+                                                 */
+#define S626_A2_CLKSRC_X4       0x01400000      /*
+                                                 * A2 bit rate = ACLK/4
+                                                 * (DACs).
+                                                 */
 #define S626_INVERT_BCLK2       0x00100000      /* Invert BCLK2 (DACs). */
 #define S626_BCLK2_OE           0x00040000      /* Enable BCLK2 (DACs). */
-#define S626_ACON2_XORMASK      0x000C0000      /* XOR mask for ACON2
-                                                 * active-low bits. */
+#define S626_ACON2_XORMASK      0x000C0000      /*
+                                                 * XOR mask for ACON2
+                                                 * active-low bits.
+                                                 */
 
 #define S626_ACON2_INIT         (S626_ACON2_XORMASK ^ \
                                  (S626_A1_CLKSRC_BCLK1 | S626_A2_CLKSRC_X2 | \
@@ -308,12 +378,18 @@
 #define S626_WS3                0x10000000
 #define S626_WS4                0x08000000
 #define S626_RSD1               0x01000000      /* Shift A1 data in on SD1. */
-#define S626_SDW_A1             0x00800000      /* Store rcv'd char at next char
-                                                 * slot of DWORD1 buffer. */
-#define S626_SIB_A1             0x00400000      /* Store rcv'd char at next
-                                                 * char slot of FB1 buffer. */
-#define S626_SF_A1              0x00200000      /* Write unsigned long
-                                                 * buffer to input FIFO. */
+#define S626_SDW_A1             0x00800000      /*
+                                                 * Store rcv'd char at next char
+                                                 * slot of DWORD1 buffer.
+                                                 */
+#define S626_SIB_A1             0x00400000      /*
+                                                 * Store rcv'd char at next
+                                                 * char slot of FB1 buffer.
+                                                 */
+#define S626_SF_A1              0x00200000      /*
+                                                 * Write unsigned long
+                                                 * buffer to input FIFO.
+                                                 */
 
 /* Select parallel-to-serial converter's data source: */
 #define S626_XFIFO_0            0x00000000      /* Data fifo byte 0. */
@@ -324,31 +400,45 @@
 #define S626_XFB1               0x00000050      /* FB_BUFFER byte 1. */
 #define S626_XFB2               0x00000060      /* FB_BUFFER byte 2. */
 #define S626_XFB3               0x00000070      /* FB_BUFFER byte 3. */
-#define S626_SIB_A2             0x00000200      /* Store next dword from A2's
+#define S626_SIB_A2             0x00000200      /*
+                                                 * Store next dword from A2's
                                                  * input shifter to FB2
-                                                 * buffer. */
-#define S626_SF_A2              0x00000100      /* Store next dword from A2's
+                                                 * buffer.
+                                                 */
+#define S626_SF_A2              0x00000100      /*
+                                                 * Store next dword from A2's
                                                  * input shifter to its input
-                                                 * fifo. */
-#define S626_LF_A2              0x00000080      /* Load next dword from A2's
+                                                 * fifo.
+                                                 */
+#define S626_LF_A2              0x00000080      /*
+                                                 * Load next dword from A2's
                                                  * output fifo into its
-                                                 * output dword buffer. */
+                                                 * output dword buffer.
+                                                 */
 #define S626_XSD2               0x00000008      /* Shift data out on SD2. */
 #define S626_RSD3               0x00001800      /* Shift data in on SD3. */
 #define S626_RSD2               0x00001000      /* Shift data in on SD2. */
-#define S626_LOW_A2             0x00000002      /* Drive last SD low for 7 clks,
-                                                 * then tri-state. */
+#define S626_LOW_A2             0x00000002      /*
+                                                 * Drive last SD low for 7 clks,
+                                                 * then tri-state.
+                                                 */
 #define S626_EOS                0x00000001      /* End of superframe. */
 
 /* I2C configuration constants. */
-#define S626_I2C_CLKSEL         0x0400          /* I2C bit rate =
-                                                 * PCIclk/480 = 68.75 KHz. */
-#define S626_I2C_BITRATE        68.75           /* I2C bus data bit rate
+#define S626_I2C_CLKSEL         0x0400          /*
+                                                 * I2C bit rate =
+                                                 * PCIclk/480 = 68.75 KHz.
+                                                 */
+#define S626_I2C_BITRATE        68.75           /*
+                                                 * I2C bus data bit rate
                                                  * (determined by
-                                                 * S626_I2C_CLKSEL) in KHz. */
-#define S626_I2C_WRTIME         15.0            /* Worst case time, in msec,
+                                                 * S626_I2C_CLKSEL) in KHz.
+                                                 */
+#define S626_I2C_WRTIME         15.0            /*
+                                                 * Worst case time, in msec,
                                                  * for EEPROM internal write
-                                                 * op. */
+                                                 * op.
+                                                 */
 
 /* I2C manifest constants. */
 
@@ -368,8 +458,10 @@
 #define S626_I2C_B0(ATTR, VAL)  (((ATTR) << 2) | ((VAL) <<  8))
 
 /* DEBI command constants. */
-#define S626_DEBI_CMD_SIZE16    (2 << 17)       /* Transfer size is always
-                                                 * 2 bytes. */
+#define S626_DEBI_CMD_SIZE16    (2 << 17)       /*
+                                                 * Transfer size is always
+                                                 * 2 bytes.
+                                                 */
 #define S626_DEBI_CMD_READ      0x00010000      /* Read operation. */
 #define S626_DEBI_CMD_WRITE     0x00000000      /* Write operation. */
 
@@ -380,42 +472,58 @@
 #define S626_DEBI_CMD_WRWORD    (S626_DEBI_CMD_WRITE | S626_DEBI_CMD_SIZE16)
 
 /* DEBI configuration constants. */
-#define S626_DEBI_CFG_XIRQ_EN   0x80000000      /* Enable external interrupt
-                                                 * on GPIO3. */
+#define S626_DEBI_CFG_XIRQ_EN   0x80000000      /*
+                                                 * Enable external interrupt
+                                                 * on GPIO3.
+                                                 */
 #define S626_DEBI_CFG_XRESUME   0x40000000      /* Resume block */
-                                                /* Transfer when XIRQ
-                                                 * deasserted. */
+                                                /*
+                                                 * Transfer when XIRQ
+                                                 * deasserted.
+                                                 */
 #define S626_DEBI_CFG_TOQ       0x03C00000      /* Timeout (15 PCI cycles). */
 #define S626_DEBI_CFG_FAST      0x10000000      /* Fast mode enable. */
 
 /* 4-bit field that specifies DEBI timeout value in PCI clock cycles: */
-#define S626_DEBI_CFG_TOUT_BIT  22      /* Finish DEBI cycle after this many
-                                         * clocks. */
+#define S626_DEBI_CFG_TOUT_BIT  22      /*
+                                         * Finish DEBI cycle after this many
+                                         * clocks.
+                                         */
 
 /* 2-bit field that specifies Endian byte lane steering: */
-#define S626_DEBI_CFG_SWAP_NONE 0x00000000      /* Straight - don't swap any
-                                                 * bytes (Intel). */
+#define S626_DEBI_CFG_SWAP_NONE 0x00000000      /*
+                                                 * Straight - don't swap any
+                                                 * bytes (Intel).
+                                                 */
 #define S626_DEBI_CFG_SWAP_2    0x00100000      /* 2-byte swap (Motorola). */
 #define S626_DEBI_CFG_SWAP_4    0x00200000      /* 4-byte swap. */
-#define S626_DEBI_CFG_SLAVE16   0x00080000      /* Slave is able to serve
-                                                 * 16-bit cycles. */
-#define S626_DEBI_CFG_INC       0x00040000      /* Enable address increment
-                                                 * for block transfers. */
+#define S626_DEBI_CFG_SLAVE16   0x00080000      /*
+                                                 * Slave is able to serve
+                                                 * 16-bit cycles.
+                                                 */
+#define S626_DEBI_CFG_INC       0x00040000      /*
+                                                 * Enable address increment
+                                                 * for block transfers.
+                                                 */
 #define S626_DEBI_CFG_INTEL     0x00020000      /* Intel style local bus. */
 #define S626_DEBI_CFG_TIMEROFF  0x00010000      /* Disable timer. */
 
 #if S626_PLATFORM == S626_INTEL
 
-#define S626_DEBI_TOUT          7       /* Wait 7 PCI clocks (212 ns) before
-                                         * polling RDY. */
+#define S626_DEBI_TOUT          7       /*
+                                         * Wait 7 PCI clocks (212 ns) before
+                                         * polling RDY.
+                                         */
 
 /* Intel byte lane steering (pass through all byte lanes). */
 #define S626_DEBI_SWAP          S626_DEBI_CFG_SWAP_NONE
 
 #elif S626_PLATFORM == S626_MOTOROLA
 
-#define S626_DEBI_TOUT          15      /* Wait 15 PCI clocks (454 ns) maximum
-                                         * before timing out. */
+#define S626_DEBI_TOUT          15      /*
+                                         * Wait 15 PCI clocks (454 ns) maximum
+                                         * before timing out.
+                                         */
 
 /* Motorola byte lane steering. */
 #define S626_DEBI_SWAP          S626_DEBI_CFG_SWAP_2
@@ -429,10 +537,14 @@
 
 /* LoadSrc values: */
 #define S626_LOADSRC_INDX       0       /* Preload core in response to Index. */
-#define S626_LOADSRC_OVER       1       /* Preload core in response to
-                                         * Overflow. */
-#define S626_LOADSRCB_OVERA     2       /* Preload B core in response to
-                                         * A Overflow. */
+#define S626_LOADSRC_OVER       1       /*
+                                         * Preload core in response to
+                                         * Overflow.
+                                         */
+#define S626_LOADSRCB_OVERA     2       /*
+                                         * Preload B core in response to
+                                         * A Overflow.
+                                         */
 #define S626_LOADSRC_NONE       3       /* Never preload core. */
 
 /* IntSrc values: */
@@ -469,10 +581,14 @@
 #define S626_CNTSRC_SYSCLK_DOWN 3       /* System clock down */
 
 /* ClkPol values: */
-#define S626_CLKPOL_POS         0       /* Counter/Extender clock is
-                                         * active high. */
-#define S626_CLKPOL_NEG         1       /* Counter/Extender clock is
-                                         * active low. */
+#define S626_CLKPOL_POS         0       /*
+                                         * Counter/Extender clock is
+                                         * active high.
+                                         */
+#define S626_CLKPOL_NEG         1       /*
+                                         * Counter/Extender clock is
+                                         * active low.
+                                         */
 #define S626_CNTDIR_UP          0       /* Timer counts up. */
 #define S626_CNTDIR_DOWN        1       /* Timer counts down. */
 
@@ -488,8 +604,10 @@
 
 /* Sanity-check limits for parameters. */
 
-#define S626_NUM_COUNTERS       6       /* Maximum valid counter
-                                         * logical channel number. */
+#define S626_NUM_COUNTERS       6       /*
+                                         * Maximum valid counter
+                                         * logical channel number.
+                                         */
 #define S626_NUM_INTSOURCES     4
 #define S626_NUM_LATCHSOURCES   4
 #define S626_NUM_CLKMULTS       4
diff --git a/drivers/staging/comedi/drivers/serial2002.c b/drivers/staging/comedi/drivers/serial2002.c
index 7a1defcf2102..0d33e520f635 100644
--- a/drivers/staging/comedi/drivers/serial2002.c
+++ b/drivers/staging/comedi/drivers/serial2002.c
@@ -95,7 +95,7 @@ struct serial_data {
 #define S2002_CFG_SIGN(x)               (((x) >> 13) & 0x1)
 #define S2002_CFG_BASE(x)               (((x) >> 14) & 0xfffff)
 
-static long serial2002_tty_ioctl(struct file *f, unsigned op,
+static long serial2002_tty_ioctl(struct file *f, unsigned int op,
                                  unsigned long param)
 {
         if (f->f_op->unlocked_ioctl)
@@ -379,7 +379,10 @@ static int serial2002_setup_subdevice(struct comedi_subdevice *s,
                                 range_table_list[chan] =
                                     (const struct comedi_lrange *)&range[j];
                         }
-                        maxdata_list[chan] = ((long long)1 << cfg[j].bits) - 1;
+                        if (cfg[j].bits < 32)
+                                maxdata_list[chan] = (1u << cfg[j].bits) - 1;
+                        else
+                                maxdata_list[chan] = 0xffffffff;
                         chan++;
                 }
         }
diff --git a/drivers/staging/ks7010/Kconfig b/drivers/staging/ks7010/Kconfig
new file mode 100644
index 000000000000..0b9217674d5b
--- /dev/null
+++ b/drivers/staging/ks7010/Kconfig
@@ -0,0 +1,10 @@
+config KS7010
+        tristate "KeyStream KS7010 SDIO support"
+        depends on MMC && WIRELESS
+        select WIRELESS_EXT
+        select WEXT_PRIV
+        select FW_LOADER
+        help
+          This is a driver for KeyStream KS7010 based SDIO WIFI cards. It is
+          found on at least later Spectec SDW-821 (FCC-ID "S2Y-WLAN-11G-K" only,
+          sadly not FCC-ID "S2Y-WLAN-11B-G") and Spectec SDW-823 microSD cards.
diff --git a/drivers/staging/ks7010/Makefile b/drivers/staging/ks7010/Makefile
new file mode 100644
index 000000000000..69fcf8d655c7
--- /dev/null
+++ b/drivers/staging/ks7010/Makefile
@@ -0,0 +1,4 @@
+obj-$(CONFIG_KS7010) += ks7010.o
+
+ccflags-y            += -DKS_WLAN_DEBUG=0
+ks7010-y             := michael_mic.o ks_hostif.o ks_wlan_net.o ks7010_sdio.o
diff --git a/drivers/staging/ks7010/TODO b/drivers/staging/ks7010/TODO
new file mode 100644
index 000000000000..2938d35be5bb
--- /dev/null
+++ b/drivers/staging/ks7010/TODO
@@ -0,0 +1,36 @@
+KS7010 Linux driver
+===================
+
+This driver is based on source code from the Ben Nanonote extra repository [1]
+which is based on the original v007 release from Renesas [2]. Some more
+background info about the chipset can be found here [3] and here [4]. Thank
+you to all which already participated in cleaning up the driver so far!
+
+[1] http://projects.qi-hardware.com/index.php/p/openwrt-packages/source/tree/master/ks7010/src
+[2] http://downloads.qi-hardware.com/software/ks7010_sdio_v007.tar.bz2
+[3] http://en.qi-hardware.com/wiki/Ben_NanoNote_Wi-Fi
+[4] https://wikidevi.com/wiki/Renesas
+
+TODO
+----
+
+First a few words what not to do (at least not blindly):
+
+- don't be overly strict with the 80 char limit. Only if it REALLY makes the
+  code more readable
+- No '#if 0/1' removal unless the surrounding code is understood and removal is
+  really OK. There might be some hints hidden there.
+
+Now the TODOs:
+
+- fix codechecker warnings (checkpatch, sparse, smatch). But PLEASE make sure
+  that you are not only silencing the warning but really fixing code. You
+  should understand the change you submit.
+- fix the 'card removal' event when card is inserted when booting
+- check what other upstream wireless mechanisms can be used instead of the
+  custom ones here
+
+Please send any patches to:
+Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+Wolfram Sang <wsa@the-dreams.de>
+Linux Driver Project Developer List <driverdev-devel@linuxdriverproject.org>
diff --git a/drivers/staging/ks7010/eap_packet.h b/drivers/staging/ks7010/eap_packet.h
new file mode 100644
index 000000000000..16a392abdaec
--- /dev/null
+++ b/drivers/staging/ks7010/eap_packet.h
@@ -0,0 +1,129 @@
+#ifndef EAP_PACKET_H
+#define EAP_PACKET_H
+
+#define WBIT(n) (1 << (n))
+
+#ifndef ETH_ALEN
+#define ETH_ALEN 6
+#endif
+
+struct ether_hdr {
+        unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
+        unsigned char h_source[ETH_ALEN];       /* source ether addr    */
+        unsigned char h_dest_snap;
+        unsigned char h_source_snap;
+        unsigned char h_command;
+        unsigned char h_vendor_id[3];
+        unsigned short h_proto; /* packet type ID field */
+#define ETHER_PROTOCOL_TYPE_EAP         0x888e
+#define ETHER_PROTOCOL_TYPE_IP          0x0800
+#define ETHER_PROTOCOL_TYPE_ARP         0x0806
+        /* followed by length octets of data */
+} __attribute__ ((packed));
+
+struct ieee802_1x_hdr {
+        unsigned char version;
+        unsigned char type;
+        unsigned short length;
+        /* followed by length octets of data */
+} __attribute__ ((packed));
+
+#define EAPOL_VERSION 2
+
+enum { IEEE802_1X_TYPE_EAP_PACKET = 0,
+        IEEE802_1X_TYPE_EAPOL_START = 1,
+        IEEE802_1X_TYPE_EAPOL_LOGOFF = 2,
+        IEEE802_1X_TYPE_EAPOL_KEY = 3,
+        IEEE802_1X_TYPE_EAPOL_ENCAPSULATED_ASF_ALERT = 4
+};
+
+enum { EAPOL_KEY_TYPE_RC4 = 1, EAPOL_KEY_TYPE_RSN = 2,
+        EAPOL_KEY_TYPE_WPA = 254
+};
+
+#define IEEE8021X_REPLAY_COUNTER_LEN 8
+#define IEEE8021X_KEY_SIGN_LEN 16
+#define IEEE8021X_KEY_IV_LEN 16
+
+#define IEEE8021X_KEY_INDEX_FLAG 0x80
+#define IEEE8021X_KEY_INDEX_MASK 0x03
+
+struct ieee802_1x_eapol_key {
+        unsigned char type;
+        unsigned short key_length;
+        /* does not repeat within the life of the keying material used to
+         * encrypt the Key field; 64-bit NTP timestamp MAY be used here */
+        unsigned char replay_counter[IEEE8021X_REPLAY_COUNTER_LEN];
+        unsigned char key_iv[IEEE8021X_KEY_IV_LEN];     /* cryptographically random number */
+        unsigned char key_index;        /* key flag in the most significant bit:
+                                         * 0 = broadcast (default key),
+                                         * 1 = unicast (key mapping key); key index is in the
+                                         * 7 least significant bits */
+        /* HMAC-MD5 message integrity check computed with MS-MPPE-Send-Key as
+         * the key */
+        unsigned char key_signature[IEEE8021X_KEY_SIGN_LEN];
+
+        /* followed by key: if packet body length = 44 + key length, then the
+         * key field (of key_length bytes) contains the key in encrypted form;
+         * if packet body length = 44, key field is absent and key_length
+         * represents the number of least significant octets from
+         * MS-MPPE-Send-Key attribute to be used as the keying material;
+         * RC4 key used in encryption = Key-IV + MS-MPPE-Recv-Key */
+} __attribute__ ((packed));
+
+#define WPA_NONCE_LEN 32
+#define WPA_REPLAY_COUNTER_LEN 8
+
+struct wpa_eapol_key {
+        unsigned char type;
+        unsigned short key_info;
+        unsigned short key_length;
+        unsigned char replay_counter[WPA_REPLAY_COUNTER_LEN];
+        unsigned char key_nonce[WPA_NONCE_LEN];
+        unsigned char key_iv[16];
+        unsigned char key_rsc[8];
+        unsigned char key_id[8];        /* Reserved in IEEE 802.11i/RSN */
+        unsigned char key_mic[16];
+        unsigned short key_data_length;
+        /* followed by key_data_length bytes of key_data */
+} __attribute__ ((packed));
+
+#define WPA_KEY_INFO_TYPE_MASK (WBIT(0) | WBIT(1) | WBIT(2))
+#define WPA_KEY_INFO_TYPE_HMAC_MD5_RC4 WBIT(0)
+#define WPA_KEY_INFO_TYPE_HMAC_SHA1_AES WBIT(1)
+#define WPA_KEY_INFO_KEY_TYPE WBIT(3)   /* 1 = Pairwise, 0 = Group key */
+/* bit4..5 is used in WPA, but is reserved in IEEE 802.11i/RSN */
+#define WPA_KEY_INFO_KEY_INDEX_MASK (WBIT(4) | WBIT(5))
+#define WPA_KEY_INFO_KEY_INDEX_SHIFT 4
+#define WPA_KEY_INFO_INSTALL WBIT(6)    /* pairwise */
+#define WPA_KEY_INFO_TXRX WBIT(6)       /* group */
+#define WPA_KEY_INFO_ACK WBIT(7)
+#define WPA_KEY_INFO_MIC WBIT(8)
+#define WPA_KEY_INFO_SECURE WBIT(9)
+#define WPA_KEY_INFO_ERROR WBIT(10)
+#define WPA_KEY_INFO_REQUEST WBIT(11)
+#define WPA_KEY_INFO_ENCR_KEY_DATA WBIT(12)     /* IEEE 802.11i/RSN only */
+
+#define WPA_CAPABILITY_PREAUTH WBIT(0)
+
+#define GENERIC_INFO_ELEM 0xdd
+#define RSN_INFO_ELEM 0x30
+
+enum {
+        REASON_UNSPECIFIED = 1,
+        REASON_DEAUTH_LEAVING = 3,
+        REASON_INVALID_IE = 13,
+        REASON_MICHAEL_MIC_FAILURE = 14,
+        REASON_4WAY_HANDSHAKE_TIMEOUT = 15,
+        REASON_GROUP_KEY_UPDATE_TIMEOUT = 16,
+        REASON_IE_IN_4WAY_DIFFERS = 17,
+        REASON_GROUP_CIPHER_NOT_VALID = 18,
+        REASON_PAIRWISE_CIPHER_NOT_VALID = 19,
+        REASON_AKMP_NOT_VALID = 20,
+        REASON_UNSUPPORTED_RSN_IE_VERSION = 21,
+        REASON_INVALID_RSN_IE_CAPAB = 22,
+        REASON_IEEE_802_1X_AUTH_FAILED = 23,
+        REASON_CIPHER_SUITE_REJECTED = 24
+};
+
+#endif /* EAP_PACKET_H */
diff --git a/drivers/staging/ks7010/ks7010_sdio.c b/drivers/staging/ks7010/ks7010_sdio.c
new file mode 100644
index 000000000000..b7337fd813d5
--- /dev/null
+++ b/drivers/staging/ks7010/ks7010_sdio.c
@@ -0,0 +1,1236 @@
+/*
+ *   Driver for KeyStream, KS7010 based SDIO cards.
+ *
+ *   Copyright (C) 2006-2008 KeyStream Corp.
+ *   Copyright (C) 2009 Renesas Technology Corp.
+ *   Copyright (C) 2016 Sang Engineering, Wolfram Sang
+ *
+ *   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.
+ */
+
+#include <linux/firmware.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio_func.h>
+#include <linux/workqueue.h>
+#include <asm/atomic.h>
+
+#include "ks_wlan.h"
+#include "ks_wlan_ioctl.h"
+#include "ks_hostif.h"
+#include "ks7010_sdio.h"
+
+#define KS7010_FUNC_NUM 1
+#define KS7010_IO_BLOCK_SIZE 512
+#define KS7010_MAX_CLOCK 25000000
+
+static const struct sdio_device_id ks7010_sdio_ids[] = {
+        {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010)},
+        {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010)},
+        { /* all zero */ }
+};
+MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids);
+
+/* macro */
+
+#define inc_txqhead(priv) \
+        ( priv->tx_dev.qhead = (priv->tx_dev.qhead + 1) % TX_DEVICE_BUFF_SIZE )
+#define inc_txqtail(priv) \
+        ( priv->tx_dev.qtail = (priv->tx_dev.qtail + 1) % TX_DEVICE_BUFF_SIZE )
+#define cnt_txqbody(priv) \
+        (((priv->tx_dev.qtail + TX_DEVICE_BUFF_SIZE) - (priv->tx_dev.qhead)) % TX_DEVICE_BUFF_SIZE )
+
+#define inc_rxqhead(priv) \
+        ( priv->rx_dev.qhead = (priv->rx_dev.qhead + 1) % RX_DEVICE_BUFF_SIZE )
+#define inc_rxqtail(priv) \
+        ( priv->rx_dev.qtail = (priv->rx_dev.qtail + 1) % RX_DEVICE_BUFF_SIZE )
+#define cnt_rxqbody(priv) \
+        (((priv->rx_dev.qtail + RX_DEVICE_BUFF_SIZE) - (priv->rx_dev.qhead)) % RX_DEVICE_BUFF_SIZE )
+
+static int ks7010_sdio_read(struct ks_wlan_private *priv, unsigned int address,
+                            unsigned char *buffer, int length)
+{
+        struct ks_sdio_card *card;
+        int rc;
+
+        card = priv->ks_wlan_hw.sdio_card;
+
+        if (length == 1)        /* CMD52 */
+                *buffer = sdio_readb(card->func, address, &rc);
+        else    /* CMD53 multi-block transfer */
+                rc = sdio_memcpy_fromio(card->func, buffer, address, length);
+
+        if (rc != 0)
+                DPRINTK(1, "sdio error=%d size=%d\n", rc, length);
+
+        return rc;
+}
+
+static int ks7010_sdio_write(struct ks_wlan_private *priv, unsigned int address,
+                             unsigned char *buffer, int length)
+{
+        struct ks_sdio_card *card;
+        int rc;
+
+        card = priv->ks_wlan_hw.sdio_card;
+
+        if (length == 1)        /* CMD52 */
+                sdio_writeb(card->func, *buffer, (unsigned int)address, &rc);
+        else    /* CMD53 */
+                rc = sdio_memcpy_toio(card->func, (unsigned int)address, buffer,
+                                      length);
+
+        if (rc != 0)
+                DPRINTK(1, "sdio error=%d size=%d\n", rc, length);
+
+        return rc;
+}
+
+void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv)
+{
+        unsigned char rw_data;
+        int retval;
+
+        DPRINTK(4, "\n");
+
+        /* clear request */
+        atomic_set(&priv->sleepstatus.doze_request, 0);
+
+        if (atomic_read(&priv->sleepstatus.status) == 0) {
+                rw_data = GCR_B_DOZE;
+                retval =
+                    ks7010_sdio_write(priv, GCR_B, &rw_data, sizeof(rw_data));
+                if (retval) {
+                        DPRINTK(1, " error : GCR_B=%02X\n", rw_data);
+                        goto out;
+                }
+                DPRINTK(4, "PMG SET!! : GCR_B=%02X\n", rw_data);
+                DPRINTK(3, "sleep_mode=SLP_SLEEP\n");
+                atomic_set(&priv->sleepstatus.status, 1);
+                priv->last_doze = jiffies;
+        } else {
+                DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode);
+        }
+
+ out:
+        priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
+        return;
+}
+
+void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv)
+{
+        unsigned char rw_data;
+        int retval;
+
+        DPRINTK(4, "\n");
+
+        /* clear request */
+        atomic_set(&priv->sleepstatus.wakeup_request, 0);
+
+        if (atomic_read(&priv->sleepstatus.status) == 1) {
+                rw_data = WAKEUP_REQ;
+                retval =
+                    ks7010_sdio_write(priv, WAKEUP, &rw_data, sizeof(rw_data));
+                if (retval) {
+                        DPRINTK(1, " error : WAKEUP=%02X\n", rw_data);
+                        goto out;
+                }
+                DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data);
+                atomic_set(&priv->sleepstatus.status, 0);
+                priv->last_wakeup = jiffies;
+                ++priv->wakeup_count;
+        } else {
+                DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode);
+        }
+
+ out:
+        priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
+        return;
+}
+
+void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv)
+{
+        unsigned char rw_data;
+        int retval;
+
+        DPRINTK(4, "\n");
+        if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
+                rw_data = WAKEUP_REQ;
+                retval =
+                    ks7010_sdio_write(priv, WAKEUP, &rw_data, sizeof(rw_data));
+                if (retval) {
+                        DPRINTK(1, " error : WAKEUP=%02X\n", rw_data);
+                }
+                DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data);
+                priv->last_wakeup = jiffies;
+                ++priv->wakeup_count;
+        } else {
+                DPRINTK(1, "psstatus=%d\n",
+                        atomic_read(&priv->psstatus.status));
+        }
+}
+
+int _ks_wlan_hw_power_save(struct ks_wlan_private *priv)
+{
+        int rc = 0;
+        unsigned char rw_data;
+        int retval;
+
+        if (priv->reg.powermgt == POWMGT_ACTIVE_MODE)
+                return rc;
+
+        if (priv->reg.operation_mode == MODE_INFRASTRUCTURE &&
+            (priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+
+                //DPRINTK(1,"psstatus.status=%d\n",atomic_read(&priv->psstatus.status));
+                if (priv->dev_state == DEVICE_STATE_SLEEP) {
+                        switch (atomic_read(&priv->psstatus.status)) {
+                        case PS_SNOOZE: /* 4 */
+                                break;
+                        default:
+                                DPRINTK(5, "\npsstatus.status=%d\npsstatus.confirm_wait=%d\npsstatus.snooze_guard=%d\ncnt_txqbody=%d\n",
+                                        atomic_read(&priv->psstatus.status),
+                                        atomic_read(&priv->psstatus.confirm_wait),
+                                        atomic_read(&priv->psstatus.snooze_guard),
+                                        cnt_txqbody(priv));
+
+                                if (!atomic_read(&priv->psstatus.confirm_wait)
+                                    && !atomic_read(&priv->psstatus.snooze_guard)
+                                    && !cnt_txqbody(priv)) {
+                                        retval =
+                                            ks7010_sdio_read(priv, INT_PENDING,
+                                                             &rw_data,
+                                                             sizeof(rw_data));
+                                        if (retval) {
+                                                DPRINTK(1,
+                                                        " error : INT_PENDING=%02X\n",
+                                                        rw_data);
+                                                queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                                                                   &priv->ks_wlan_hw.rw_wq, 1);
+                                                break;
+                                        }
+                                        if (!rw_data) {
+                                                rw_data = GCR_B_DOZE;
+                                                retval =
+                                                    ks7010_sdio_write(priv,
+                                                                      GCR_B,
+                                                                      &rw_data,
+                                                                      sizeof(rw_data));
+                                                if (retval) {
+                                                        DPRINTK(1,
+                                                                " error : GCR_B=%02X\n",
+                                                                rw_data);
+                                                        queue_delayed_work
+                                                            (priv->ks_wlan_hw.ks7010sdio_wq,
+                                                             &priv->ks_wlan_hw.rw_wq, 1);
+                                                        break;
+                                                }
+                                                DPRINTK(4,
+                                                        "PMG SET!! : GCR_B=%02X\n",
+                                                        rw_data);
+                                                atomic_set(&priv->psstatus.
+                                                           status, PS_SNOOZE);
+                                                DPRINTK(3,
+                                                        "psstatus.status=PS_SNOOZE\n");
+                                        } else {
+                                                queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                                                                   &priv->ks_wlan_hw.rw_wq, 1);
+                                        }
+                                } else {
+                                        queue_delayed_work(priv->ks_wlan_hw.
+                                                           ks7010sdio_wq,
+                                                           &priv->ks_wlan_hw.rw_wq,
+                                                           0);
+                                }
+                                break;
+                        }
+                }
+
+        }
+
+        return rc;
+}
+
+int ks_wlan_hw_power_save(struct ks_wlan_private *priv)
+{
+        queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                           &priv->ks_wlan_hw.rw_wq, 1);
+        return 0;
+}
+
+static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p,
+                         unsigned long size,
+                         void (*complete_handler) (void *arg1, void *arg2),
+                         void *arg1, void *arg2)
+{
+        struct tx_device_buffer *sp;
+
+        if (priv->dev_state < DEVICE_STATE_BOOT) {
+                kfree(p);
+                if (complete_handler != NULL)
+                        (*complete_handler) (arg1, arg2);
+                return 1;
+        }
+
+        if ((TX_DEVICE_BUFF_SIZE - 1) <= cnt_txqbody(priv)) {
+                /* in case of buffer overflow */
+                DPRINTK(1, "tx buffer overflow\n");
+                kfree(p);
+                if (complete_handler != NULL)
+                        (*complete_handler) (arg1, arg2);
+                return 1;
+        }
+
+        sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail];
+        sp->sendp = p;
+        sp->size = size;
+        sp->complete_handler = complete_handler;
+        sp->arg1 = arg1;
+        sp->arg2 = arg2;
+        inc_txqtail(priv);
+
+        return 0;
+}
+
+/* write data */
+static int write_to_device(struct ks_wlan_private *priv, unsigned char *buffer,
+                           unsigned long size)
+{
+        int rc, retval;
+        unsigned char rw_data;
+        struct hostif_hdr *hdr;
+        hdr = (struct hostif_hdr *)buffer;
+        rc = 0;
+
+        DPRINTK(4, "size=%d\n", hdr->size);
+        if (hdr->event < HIF_DATA_REQ || HIF_REQ_MAX < hdr->event) {
+                DPRINTK(1, "unknown event=%04X\n", hdr->event);
+                return 0;
+        }
+
+        retval = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size);
+        if (retval) {
+                DPRINTK(1, " write error : retval=%d\n", retval);
+                return -4;
+        }
+
+        rw_data = WRITE_STATUS_BUSY;
+        retval =
+            ks7010_sdio_write(priv, WRITE_STATUS, &rw_data, sizeof(rw_data));
+        if (retval) {
+                DPRINTK(1, " error : WRITE_STATUS=%02X\n", rw_data);
+                return -3;
+        }
+
+        return 0;
+}
+
+static void tx_device_task(void *dev)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
+        struct tx_device_buffer *sp;
+        int rc = 0;
+
+        DPRINTK(4, "\n");
+        if (cnt_txqbody(priv) > 0
+            && atomic_read(&priv->psstatus.status) != PS_SNOOZE) {
+                sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
+                if (priv->dev_state >= DEVICE_STATE_BOOT) {
+                        rc = write_to_device(priv, sp->sendp, sp->size);
+                        if (rc) {
+                                DPRINTK(1, "write_to_device error !!(%d)\n",
+                                        rc);
+                                queue_delayed_work(priv->ks_wlan_hw.
+                                                   ks7010sdio_wq,
+                                                   &priv->ks_wlan_hw.rw_wq, 1);
+                                return;
+                        }
+
+                }
+                kfree(sp->sendp);       /* allocated memory free */
+                if (sp->complete_handler != NULL)       /* TX Complete */
+                        (*sp->complete_handler) (sp->arg1, sp->arg2);
+                inc_txqhead(priv);
+
+                if (cnt_txqbody(priv) > 0) {
+                        queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                                           &priv->ks_wlan_hw.rw_wq, 0);
+                }
+        }
+        return;
+}
+
+int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size,
+                  void (*complete_handler) (void *arg1, void *arg2),
+                  void *arg1, void *arg2)
+{
+        int result = 0;
+        struct hostif_hdr *hdr;
+        hdr = (struct hostif_hdr *)p;
+
+        if (hdr->event < HIF_DATA_REQ || HIF_REQ_MAX < hdr->event) {
+                DPRINTK(1, "unknown event=%04X\n", hdr->event);
+                return 0;
+        }
+
+        /* add event to hostt buffer */
+        priv->hostt.buff[priv->hostt.qtail] = hdr->event;
+        priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE;
+
+        DPRINTK(4, "event=%04X\n", hdr->event);
+        spin_lock(&priv->tx_dev.tx_dev_lock);
+        result = enqueue_txdev(priv, p, size, complete_handler, arg1, arg2);
+        spin_unlock(&priv->tx_dev.tx_dev_lock);
+
+        if (cnt_txqbody(priv) > 0) {
+                queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                                   &priv->ks_wlan_hw.rw_wq, 0);
+        }
+        return result;
+}
+
+static void rx_event_task(unsigned long dev)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
+        struct rx_device_buffer *rp;
+
+        DPRINTK(4, "\n");
+
+        if (cnt_rxqbody(priv) > 0 && priv->dev_state >= DEVICE_STATE_BOOT) {
+                rp = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qhead];
+                hostif_receive(priv, rp->data, rp->size);
+                inc_rxqhead(priv);
+
+                if (cnt_rxqbody(priv) > 0) {
+                        tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task);
+                }
+        }
+
+        return;
+}
+
+static void ks_wlan_hw_rx(void *dev, uint16_t size)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
+        int retval;
+        struct rx_device_buffer *rx_buffer;
+        struct hostif_hdr *hdr;
+        unsigned char read_status;
+        unsigned short event = 0;
+
+        DPRINTK(4, "\n");
+
+        /* receive data */
+        if (cnt_rxqbody(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) {
+                /* in case of buffer overflow */
+                DPRINTK(1, "rx buffer overflow \n");
+                goto error_out;
+        }
+        rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail];
+
+        retval =
+            ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0],
+                             hif_align_size(size));
+        if (retval) {
+                goto error_out;
+        }
+
+        /* length check */
+        if (size > 2046 || size == 0) {
+#ifdef KS_WLAN_DEBUG
+                if (KS_WLAN_DEBUG > 5)
+                        print_hex_dump_bytes("INVALID DATA dump: ",
+                                             DUMP_PREFIX_OFFSET,
+                                             rx_buffer->data, 32);
+#endif
+                /* rx_status update */
+                read_status = READ_STATUS_IDLE;
+                retval =
+                    ks7010_sdio_write(priv, READ_STATUS, &read_status,
+                                      sizeof(read_status));
+                if (retval) {
+                        DPRINTK(1, " error : READ_STATUS=%02X\n", read_status);
+                }
+                goto error_out;
+        }
+
+        hdr = (struct hostif_hdr *)&rx_buffer->data[0];
+        rx_buffer->size = le16_to_cpu(hdr->size) + sizeof(hdr->size);
+        event = hdr->event;
+        inc_rxqtail(priv);
+
+        /* read status update */
+        read_status = READ_STATUS_IDLE;
+        retval =
+            ks7010_sdio_write(priv, READ_STATUS, &read_status,
+                              sizeof(read_status));
+        if (retval) {
+                DPRINTK(1, " error : READ_STATUS=%02X\n", read_status);
+        }
+        DPRINTK(4, "READ_STATUS=%02X\n", read_status);
+
+        if (atomic_read(&priv->psstatus.confirm_wait)) {
+                if (IS_HIF_CONF(event)) {
+                        DPRINTK(4, "IS_HIF_CONF true !!\n");
+                        atomic_dec(&priv->psstatus.confirm_wait);
+                }
+        }
+
+        /* rx_event_task((void *)priv); */
+        tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task);
+
+ error_out:
+        return;
+}
+
+static void ks7010_rw_function(struct work_struct *work)
+{
+        struct hw_info_t *hw;
+        struct ks_wlan_private *priv;
+        unsigned char rw_data;
+        int retval;
+
+        hw = container_of(work, struct hw_info_t, rw_wq.work);
+        priv = container_of(hw, struct ks_wlan_private, ks_wlan_hw);
+
+        DPRINTK(4, "\n");
+
+        /* wiat after DOZE */
+        if (time_after(priv->last_doze + ((30 * HZ) / 1000), jiffies)) {
+                DPRINTK(4, "wait after DOZE \n");
+                queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                                   &priv->ks_wlan_hw.rw_wq, 1);
+                return;
+        }
+
+        /* wiat after WAKEUP */
+        while (time_after(priv->last_wakeup + ((30 * HZ) / 1000), jiffies)) {
+                DPRINTK(4, "wait after WAKEUP \n");
+/*              queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq,
+                (priv->last_wakeup + ((30*HZ)/1000) - jiffies));*/
+                printk("wake: %lu %lu\n", priv->last_wakeup + (30 * HZ) / 1000,
+                       jiffies);
+                msleep(30);
+        }
+
+        sdio_claim_host(priv->ks_wlan_hw.sdio_card->func);
+
+        /* power save wakeup */
+        if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
+                if (cnt_txqbody(priv) > 0) {
+                        ks_wlan_hw_wakeup_request(priv);
+                        queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                                           &priv->ks_wlan_hw.rw_wq, 1);
+                }
+                goto err_out;
+        }
+
+        /* sleep mode doze */
+        if (atomic_read(&priv->sleepstatus.doze_request) == 1) {
+                ks_wlan_hw_sleep_doze_request(priv);
+                goto err_out;
+        }
+        /* sleep mode wakeup */
+        if (atomic_read(&priv->sleepstatus.wakeup_request) == 1) {
+                ks_wlan_hw_sleep_wakeup_request(priv);
+                goto err_out;
+        }
+
+        /* read (WriteStatus/ReadDataSize FN1:00_0014) */
+        retval =
+            ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data, sizeof(rw_data));
+        if (retval) {
+                DPRINTK(1, " error : WSTATUS_RSIZE=%02X psstatus=%d\n", rw_data,
+                        atomic_read(&priv->psstatus.status));
+                goto err_out;
+        }
+        DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data);
+
+        if (rw_data & RSIZE_MASK) {     /* Read schedule */
+                ks_wlan_hw_rx((void *)priv,
+                              (uint16_t) (((rw_data & RSIZE_MASK) << 4)));
+        }
+        if ((rw_data & WSTATUS_MASK)) {
+                tx_device_task((void *)priv);
+        }
+        _ks_wlan_hw_power_save(priv);
+
+ err_out:
+        sdio_release_host(priv->ks_wlan_hw.sdio_card->func);
+
+        return;
+}
+
+static void ks_sdio_interrupt(struct sdio_func *func)
+{
+        int retval;
+        struct ks_sdio_card *card;
+        struct ks_wlan_private *priv;
+        unsigned char status, rsize, rw_data;
+
+        card = sdio_get_drvdata(func);
+        priv = card->priv;
+        DPRINTK(4, "\n");
+
+        if (priv->dev_state >= DEVICE_STATE_BOOT) {
+                retval =
+                    ks7010_sdio_read(priv, INT_PENDING, &status,
+                                     sizeof(status));
+                if (retval) {
+                        DPRINTK(1, "read INT_PENDING Failed!!(%d)\n", retval);
+                        goto intr_out;
+                }
+                DPRINTK(4, "INT_PENDING=%02X\n", rw_data);
+
+                /* schedule task for interrupt status */
+                /* bit7 -> Write General Communication B register */
+                /* read (General Communication B register) */
+                /* bit5 -> Write Status Idle */
+                /* bit2 -> Read Status Busy  */
+                if (status & INT_GCR_B
+                    || atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
+                        retval =
+                            ks7010_sdio_read(priv, GCR_B, &rw_data,
+                                             sizeof(rw_data));
+                        if (retval) {
+                                DPRINTK(1, " error : GCR_B=%02X\n", rw_data);
+                                goto intr_out;
+                        }
+                        /* DPRINTK(1, "GCR_B=%02X\n", rw_data); */
+                        if (rw_data == GCR_B_ACTIVE) {
+                                if (atomic_read(&priv->psstatus.status) ==
+                                    PS_SNOOZE) {
+                                        atomic_set(&priv->psstatus.status,
+                                                   PS_WAKEUP);
+                                        priv->wakeup_count = 0;
+                                }
+                                complete(&priv->psstatus.wakeup_wait);
+                        }
+
+                }
+
+                do {
+                        /* read (WriteStatus/ReadDataSize FN1:00_0014) */
+                        retval =
+                            ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data,
+                                             sizeof(rw_data));
+                        if (retval) {
+                                DPRINTK(1, " error : WSTATUS_RSIZE=%02X\n",
+                                        rw_data);
+                                goto intr_out;
+                        }
+                        DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data);
+                        rsize = rw_data & RSIZE_MASK;
+                        if (rsize) {    /* Read schedule */
+                                ks_wlan_hw_rx((void *)priv,
+                                              (uint16_t) (((rsize) << 4)));
+                        }
+                        if (rw_data & WSTATUS_MASK) {
+#if 0
+                                if (status & INT_WRITE_STATUS
+                                    && !cnt_txqbody(priv)) {
+                                        /* dummy write for interrupt clear */
+                                        rw_data = 0;
+                                        retval =
+                                            ks7010_sdio_write(priv, DATA_WINDOW,
+                                                              &rw_data,
+                                                              sizeof(rw_data));
+                                        if (retval) {
+                                                DPRINTK(1,
+                                                        "write DATA_WINDOW Failed!!(%d)\n",
+                                                        retval);
+                                        }
+                                        status &= ~INT_WRITE_STATUS;
+                                } else {
+#endif
+                                        if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
+                                                if (cnt_txqbody(priv)) {
+                                                        ks_wlan_hw_wakeup_request(priv);
+                                                        queue_delayed_work
+                                                            (priv->ks_wlan_hw.
+                                                             ks7010sdio_wq,
+                                                             &priv->ks_wlan_hw.
+                                                             rw_wq, 1);
+                                                        return;
+                                                }
+                                        } else {
+                                                tx_device_task((void *)priv);
+                                        }
+#if 0
+                                }
+#endif
+                        }
+                } while (rsize);
+        }
+
+ intr_out:
+        queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                           &priv->ks_wlan_hw.rw_wq, 0);
+        return;
+}
+
+static int trx_device_init(struct ks_wlan_private *priv)
+{
+        /* initialize values (tx) */
+        priv->tx_dev.qtail = priv->tx_dev.qhead = 0;
+
+        /* initialize values (rx) */
+        priv->rx_dev.qtail = priv->rx_dev.qhead = 0;
+
+        /* initialize spinLock (tx,rx) */
+        spin_lock_init(&priv->tx_dev.tx_dev_lock);
+        spin_lock_init(&priv->rx_dev.rx_dev_lock);
+
+        tasklet_init(&priv->ks_wlan_hw.rx_bh_task, rx_event_task,
+                     (unsigned long)priv);
+
+        return 0;
+}
+
+static void trx_device_exit(struct ks_wlan_private *priv)
+{
+        struct tx_device_buffer *sp;
+
+        /* tx buffer clear */
+        while (cnt_txqbody(priv) > 0) {
+                sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
+                kfree(sp->sendp);       /* allocated memory free */
+                if (sp->complete_handler != NULL)       /* TX Complete */
+                        (*sp->complete_handler) (sp->arg1, sp->arg2);
+                inc_txqhead(priv);
+        }
+
+        tasklet_kill(&priv->ks_wlan_hw.rx_bh_task);
+
+        return;
+}
+
+static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index)
+{
+        int rc = 0;
+        int retval;
+        unsigned char *data_buf;
+        data_buf = NULL;
+
+        data_buf = kmalloc(sizeof(u32), GFP_KERNEL);
+        if (!data_buf) {
+                rc = 1;
+                goto error_out;
+        }
+
+        memcpy(data_buf, &index, sizeof(index));
+        retval = ks7010_sdio_write(priv, WRITE_INDEX, data_buf, sizeof(index));
+        if (retval) {
+                rc = 2;
+                goto error_out;
+        }
+
+        retval = ks7010_sdio_write(priv, READ_INDEX, data_buf, sizeof(index));
+        if (retval) {
+                rc = 3;
+                goto error_out;
+        }
+ error_out:
+        if (data_buf)
+                kfree(data_buf);
+        return rc;
+}
+
+#define ROM_BUFF_SIZE (64*1024)
+static int ks7010_sdio_data_compare(struct ks_wlan_private *priv, u32 address,
+                                    unsigned char *data, unsigned int size)
+{
+        int rc = 0;
+        int retval;
+        unsigned char *read_buf;
+        read_buf = NULL;
+        read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
+        if (!read_buf) {
+                rc = 1;
+                goto error_out;
+        }
+        retval = ks7010_sdio_read(priv, address, read_buf, size);
+        if (retval) {
+                rc = 2;
+                goto error_out;
+        }
+        retval = memcmp(data, read_buf, size);
+
+        if (retval) {
+                DPRINTK(0, "data compare error (%d) \n", retval);
+                rc = 3;
+                goto error_out;
+        }
+ error_out:
+        if (read_buf)
+                kfree(read_buf);
+        return rc;
+}
+
+static int ks7010_upload_firmware(struct ks_wlan_private *priv,
+                                  struct ks_sdio_card *card)
+{
+        unsigned int size, offset, n = 0;
+        unsigned char *rom_buf;
+        unsigned char rw_data = 0;
+        int retval, rc = 0;
+        int length;
+        const struct firmware *fw_entry = NULL;
+
+        rom_buf = NULL;
+
+        /* buffer allocate */
+        rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
+        if (!rom_buf) {
+                rc = 3;
+                goto error_out0;
+        }
+
+        sdio_claim_host(card->func);
+
+        /* Firmware running ? */
+        retval = ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data));
+        if (rw_data == GCR_A_RUN) {
+                DPRINTK(0, "MAC firmware running ...\n");
+                rc = 0;
+                goto error_out0;
+        }
+
+        retval = request_firmware(&fw_entry, ROM_FILE, &priv->ks_wlan_hw.sdio_card->func->dev);
+        if (retval)
+                return retval;
+
+        length = fw_entry->size;
+
+        /* Load Program */
+        n = 0;
+        do {
+                if (length >= ROM_BUFF_SIZE) {
+                        size = ROM_BUFF_SIZE;
+                        length = length - ROM_BUFF_SIZE;
+                } else {
+                        size = length;
+                        length = 0;
+                }
+                DPRINTK(4, "size = %d\n", size);
+                if (size == 0)
+                        break;
+                memcpy(rom_buf, fw_entry->data + n, size);
+                /* Update write index */
+                offset = n;
+                retval =
+                    ks7010_sdio_update_index(priv,
+                                             KS7010_IRAM_ADDRESS + offset);
+                if (retval) {
+                        rc = 6;
+                        goto error_out1;
+                }
+
+                /* Write data */
+                retval = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size);
+                if (retval) {
+                        rc = 8;
+                        goto error_out1;
+                }
+
+                /* compare */
+                retval =
+                    ks7010_sdio_data_compare(priv, DATA_WINDOW, rom_buf, size);
+                if (retval) {
+                        rc = 9;
+                        goto error_out1;
+                }
+                n += size;
+
+        } while (size);
+
+        /* Remap request */
+        rw_data = GCR_A_REMAP;
+        retval = ks7010_sdio_write(priv, GCR_A, &rw_data, sizeof(rw_data));
+        if (retval) {
+                rc = 11;
+                goto error_out1;
+        }
+        DPRINTK(4, " REMAP Request : GCR_A=%02X\n", rw_data);
+
+        /* Firmware running check */
+        for (n = 0; n < 50; ++n) {
+                mdelay(10);     /* wait_ms(10); */
+                retval =
+                    ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data));
+                if (retval) {
+                        rc = 11;
+                        goto error_out1;
+                }
+                if (rw_data == GCR_A_RUN)
+                        break;
+        }
+        DPRINTK(4, "firmware wakeup (%d)!!!!\n", n);
+        if ((50) <= n) {
+                DPRINTK(1, "firmware can't start\n");
+                rc = 12;
+                goto error_out1;
+        }
+
+        rc = 0;
+
+ error_out1:
+        release_firmware(fw_entry);
+ error_out0:
+        sdio_release_host(card->func);
+        if (rom_buf)
+                kfree(rom_buf);
+        return rc;
+}
+
+static void ks7010_card_init(struct ks_wlan_private *priv)
+{
+        DPRINTK(5, "\ncard_init_task()\n");
+
+        /* init_waitqueue_head(&priv->confirm_wait); */
+        init_completion(&priv->confirm_wait);
+
+        DPRINTK(5, "init_completion()\n");
+
+        /* get mac address & firmware version */
+        hostif_sme_enqueue(priv, SME_START);
+
+        DPRINTK(5, "hostif_sme_enqueu()\n");
+
+        if (!wait_for_completion_interruptible_timeout
+            (&priv->confirm_wait, 5 * HZ)) {
+                DPRINTK(1, "wait time out!! SME_START\n");
+        }
+
+        if (priv->mac_address_valid && priv->version_size) {
+                priv->dev_state = DEVICE_STATE_PREINIT;
+        }
+
+        hostif_sme_enqueue(priv, SME_GET_EEPROM_CKSUM);
+
+        /* load initial wireless parameter */
+        hostif_sme_enqueue(priv, SME_STOP_REQUEST);
+
+        hostif_sme_enqueue(priv, SME_RTS_THRESHOLD_REQUEST);
+        hostif_sme_enqueue(priv, SME_FRAGMENTATION_THRESHOLD_REQUEST);
+
+        hostif_sme_enqueue(priv, SME_WEP_INDEX_REQUEST);
+        hostif_sme_enqueue(priv, SME_WEP_KEY1_REQUEST);
+        hostif_sme_enqueue(priv, SME_WEP_KEY2_REQUEST);
+        hostif_sme_enqueue(priv, SME_WEP_KEY3_REQUEST);
+        hostif_sme_enqueue(priv, SME_WEP_KEY4_REQUEST);
+
+        hostif_sme_enqueue(priv, SME_WEP_FLAG_REQUEST);
+        hostif_sme_enqueue(priv, SME_RSN_ENABLED_REQUEST);
+        hostif_sme_enqueue(priv, SME_MODE_SET_REQUEST);
+        hostif_sme_enqueue(priv, SME_START_REQUEST);
+
+        if (!wait_for_completion_interruptible_timeout
+            (&priv->confirm_wait, 5 * HZ)) {
+                DPRINTK(1, "wait time out!! wireless parameter set\n");
+        }
+
+        if (priv->dev_state >= DEVICE_STATE_PREINIT) {
+                DPRINTK(1, "DEVICE READY!!\n");
+                priv->dev_state = DEVICE_STATE_READY;
+        } else {
+                DPRINTK(1, "dev_state=%d\n", priv->dev_state);
+        }
+}
+
+static void ks7010_init_defaults(struct ks_wlan_private *priv)
+{
+        priv->reg.tx_rate = TX_RATE_AUTO;
+        priv->reg.preamble = LONG_PREAMBLE;
+        priv->reg.powermgt = POWMGT_ACTIVE_MODE;
+        priv->reg.scan_type = ACTIVE_SCAN;
+        priv->reg.beacon_lost_count = 20;
+        priv->reg.rts = 2347UL;
+        priv->reg.fragment = 2346UL;
+        priv->reg.phy_type = D_11BG_COMPATIBLE_MODE;
+        priv->reg.cts_mode = CTS_MODE_FALSE;
+        priv->reg.rate_set.body[11] = TX_RATE_54M;
+        priv->reg.rate_set.body[10] = TX_RATE_48M;
+        priv->reg.rate_set.body[9] = TX_RATE_36M;
+        priv->reg.rate_set.body[8] = TX_RATE_18M;
+        priv->reg.rate_set.body[7] = TX_RATE_9M;
+        priv->reg.rate_set.body[6] = TX_RATE_24M | BASIC_RATE;
+        priv->reg.rate_set.body[5] = TX_RATE_12M | BASIC_RATE;
+        priv->reg.rate_set.body[4] = TX_RATE_6M | BASIC_RATE;
+        priv->reg.rate_set.body[3] = TX_RATE_11M | BASIC_RATE;
+        priv->reg.rate_set.body[2] = TX_RATE_5M | BASIC_RATE;
+        priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
+        priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
+        priv->reg.tx_rate = TX_RATE_FULL_AUTO;
+        priv->reg.rate_set.size = 12;
+}
+
+static int ks7010_sdio_probe(struct sdio_func *func,
+                             const struct sdio_device_id *device)
+{
+        struct ks_wlan_private *priv;
+        struct ks_sdio_card *card;
+        struct net_device *netdev;
+        unsigned char rw_data;
+        int ret;
+
+        DPRINTK(5, "ks7010_sdio_probe()\n");
+
+        priv = NULL;
+        netdev = NULL;
+
+        /* initilize ks_sdio_card */
+        card = kzalloc(sizeof(struct ks_sdio_card), GFP_KERNEL);
+        if (!card)
+                return -ENOMEM;
+
+        card->func = func;
+        spin_lock_init(&card->lock);
+
+        /*** Initialize  SDIO ***/
+        sdio_claim_host(func);
+
+        /* bus setting  */
+        /* Issue config request to override clock rate */
+
+        /* function blocksize set */
+        ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
+        DPRINTK(5, "multi_block=%d sdio_set_block_size()=%d %d\n",
+                func->card->cccr.multi_block, func->cur_blksize, ret);
+
+        /* Allocate the slot current */
+
+        /* function enable */
+        ret = sdio_enable_func(func);
+        DPRINTK(5, "sdio_enable_func() %d\n", ret);
+        if (ret)
+                goto error_free_card;
+
+        /* interrupt disable */
+        sdio_writeb(func, 0, INT_ENABLE, &ret);
+        if (ret)
+                goto error_free_card;
+        sdio_writeb(func, 0xff, INT_PENDING, &ret);
+        if (ret)
+                goto error_disable_func;
+
+        /* setup interrupt handler */
+        ret = sdio_claim_irq(func, ks_sdio_interrupt);
+        if (ret)
+                goto error_disable_func;
+
+        sdio_release_host(func);
+
+        sdio_set_drvdata(func, card);
+
+        DPRINTK(5, "class = 0x%X, vendor = 0x%X, "
+                "device = 0x%X\n", func->class, func->vendor, func->device);
+
+        /* private memory allocate */
+        netdev = alloc_etherdev(sizeof(*priv));
+        if (netdev == NULL) {
+                printk(KERN_ERR "ks7010 : Unable to alloc new net device\n");
+                goto error_release_irq;
+        }
+        if (dev_alloc_name(netdev, "wlan%d") < 0) {
+                printk(KERN_ERR "ks7010 :  Couldn't get name!\n");
+                goto error_free_netdev;
+        }
+
+        priv = netdev_priv(netdev);
+
+        card->priv = priv;
+        SET_NETDEV_DEV(netdev, &card->func->dev);       /* for create sysfs symlinks */
+
+        /* private memory initialize */
+        priv->ks_wlan_hw.sdio_card = card;
+        init_completion(&priv->ks_wlan_hw.ks7010_sdio_wait);
+        priv->ks_wlan_hw.read_buf = NULL;
+        priv->ks_wlan_hw.read_buf = kmalloc(RX_DATA_SIZE, GFP_KERNEL);
+        if (!priv->ks_wlan_hw.read_buf) {
+                goto error_free_netdev;
+        }
+        priv->dev_state = DEVICE_STATE_PREBOOT;
+        priv->net_dev = netdev;
+        priv->firmware_version[0] = '\0';
+        priv->version_size = 0;
+        priv->last_doze = jiffies;      /* set current jiffies */
+        priv->last_wakeup = jiffies;
+        memset(&priv->nstats, 0, sizeof(priv->nstats));
+        memset(&priv->wstats, 0, sizeof(priv->wstats));
+
+        /* sleep mode */
+        atomic_set(&priv->sleepstatus.doze_request, 0);
+        atomic_set(&priv->sleepstatus.wakeup_request, 0);
+        atomic_set(&priv->sleepstatus.wakeup_request, 0);
+
+        trx_device_init(priv);
+        hostif_init(priv);
+        ks_wlan_net_start(netdev);
+
+        ks7010_init_defaults(priv);
+
+        /* Upload firmware */
+        ret = ks7010_upload_firmware(priv, card);       /* firmware load */
+        if (ret) {
+                printk(KERN_ERR
+                       "ks7010: firmware load failed !! retern code = %d\n",
+                       ret);
+                goto error_free_read_buf;
+        }
+
+        /* interrupt setting */
+        /* clear Interrupt status write (ARMtoSD_InterruptPending FN1:00_0024) */
+        rw_data = 0xff;
+        sdio_claim_host(func);
+        ret = ks7010_sdio_write(priv, INT_PENDING, &rw_data, sizeof(rw_data));
+        sdio_release_host(func);
+        if (ret) {
+                DPRINTK(1, " error : INT_PENDING=%02X\n", rw_data);
+        }
+        DPRINTK(4, " clear Interrupt : INT_PENDING=%02X\n", rw_data);
+
+        /* enable ks7010sdio interrupt (INT_GCR_B|INT_READ_STATUS|INT_WRITE_STATUS) */
+        rw_data = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
+        sdio_claim_host(func);
+        ret = ks7010_sdio_write(priv, INT_ENABLE, &rw_data, sizeof(rw_data));
+        sdio_release_host(func);
+        if (ret) {
+                DPRINTK(1, " error : INT_ENABLE=%02X\n", rw_data);
+        }
+        DPRINTK(4, " enable Interrupt : INT_ENABLE=%02X\n", rw_data);
+        priv->dev_state = DEVICE_STATE_BOOT;
+
+        priv->ks_wlan_hw.ks7010sdio_wq = create_workqueue("ks7010sdio_wq");
+        if (!priv->ks_wlan_hw.ks7010sdio_wq) {
+                DPRINTK(1, "create_workqueue failed !!\n");
+                goto error_free_read_buf;
+        }
+
+        INIT_DELAYED_WORK(&priv->ks_wlan_hw.rw_wq, ks7010_rw_function);
+        ks7010_card_init(priv);
+
+        ret = register_netdev(priv->net_dev);
+        if (ret)
+                goto error_free_read_buf;
+
+        return 0;
+
+ error_free_read_buf:
+        kfree(priv->ks_wlan_hw.read_buf);
+        priv->ks_wlan_hw.read_buf = NULL;
+ error_free_netdev:
+        free_netdev(priv->net_dev);
+        card->priv = NULL;
+ error_release_irq:
+        sdio_claim_host(func);
+        sdio_release_irq(func);
+ error_disable_func:
+        sdio_disable_func(func);
+ error_free_card:
+        sdio_release_host(func);
+        sdio_set_drvdata(func, NULL);
+        kfree(card);
+
+        return -ENODEV;
+}
+
+static void ks7010_sdio_remove(struct sdio_func *func)
+{
+        int ret;
+        struct ks_sdio_card *card;
+        struct ks_wlan_private *priv;
+        struct net_device *netdev;
+        DPRINTK(1, "ks7010_sdio_remove()\n");
+
+        card = sdio_get_drvdata(func);
+
+        if (card == NULL)
+                return;
+
+        DPRINTK(1, "priv = card->priv\n");
+        priv = card->priv;
+        netdev = priv->net_dev;
+        if (priv) {
+                ks_wlan_net_stop(netdev);
+                DPRINTK(1, "ks_wlan_net_stop\n");
+
+                /* interrupt disable */
+                sdio_claim_host(func);
+                sdio_writeb(func, 0, INT_ENABLE, &ret);
+                sdio_writeb(func, 0xff, INT_PENDING, &ret);
+                sdio_release_host(func);
+                DPRINTK(1, "interrupt disable\n");
+
+                /* send stop request to MAC */
+                {
+                        struct hostif_stop_request_t *pp;
+                        pp = (struct hostif_stop_request_t *)
+                            kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL);
+                        if (pp == NULL) {
+                                DPRINTK(3, "allocate memory failed..\n");
+                                return; /* to do goto ni suru */
+                        }
+                        pp->header.size =
+                            cpu_to_le16((uint16_t)
+                                        (sizeof(*pp) -
+                                         sizeof(pp->header.size)));
+                        pp->header.event = cpu_to_le16((uint16_t) HIF_STOP_REQ);
+
+                        sdio_claim_host(func);
+                        write_to_device(priv, (unsigned char *)pp,
+                                        hif_align_size(sizeof(*pp)));
+                        sdio_release_host(func);
+                        kfree(pp);
+                }
+                DPRINTK(1, "STOP Req\n");
+
+                if (priv->ks_wlan_hw.ks7010sdio_wq) {
+                        flush_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
+                        destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
+                }
+                DPRINTK(1,
+                        "destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);\n");
+
+                hostif_exit(priv);
+                DPRINTK(1, "hostif_exit\n");
+
+                unregister_netdev(netdev);
+
+                trx_device_exit(priv);
+                if (priv->ks_wlan_hw.read_buf) {
+                        kfree(priv->ks_wlan_hw.read_buf);
+                }
+                free_netdev(priv->net_dev);
+                card->priv = NULL;
+        }
+
+        sdio_claim_host(func);
+        sdio_release_irq(func);
+        DPRINTK(1, "sdio_release_irq()\n");
+        sdio_disable_func(func);
+        DPRINTK(1, "sdio_disable_func()\n");
+        sdio_release_host(func);
+
+        sdio_set_drvdata(func, NULL);
+
+        kfree(card);
+        DPRINTK(1, "kfree()\n");
+
+        DPRINTK(5, " Bye !!\n");
+        return;
+}
+
+static struct sdio_driver ks7010_sdio_driver = {
+        .name = "ks7010_sdio",
+        .id_table = ks7010_sdio_ids,
+        .probe = ks7010_sdio_probe,
+        .remove = ks7010_sdio_remove,
+};
+
+module_driver(ks7010_sdio_driver, sdio_register_driver, sdio_unregister_driver);
+MODULE_AUTHOR("Sang Engineering, Qi-Hardware, KeyStream");
+MODULE_DESCRIPTION("Driver for KeyStream KS7010 based SDIO cards");
+MODULE_LICENSE("GPL v2");
+MODULE_FIRMWARE(ROM_FILE);
diff --git a/drivers/staging/ks7010/ks7010_sdio.h b/drivers/staging/ks7010/ks7010_sdio.h
new file mode 100644
index 000000000000..c72064b48bd8
--- /dev/null
+++ b/drivers/staging/ks7010/ks7010_sdio.h
@@ -0,0 +1,147 @@
+/*
+ *   Driver for KeyStream, KS7010 based SDIO cards. 
+ *
+ *   Copyright (C) 2006-2008 KeyStream Corp.
+ *   Copyright (C) 2009 Renesas Technology Corp.
+ *
+ *   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.
+ */
+#ifndef _KS7010_SDIO_H
+#define _KS7010_SDIO_H
+
+#ifdef  DEVICE_ALIGNMENT
+#undef  DEVICE_ALIGNMENT
+#endif
+#define DEVICE_ALIGNMENT 32
+
+/*  SDIO KeyStream vendor and device */
+#define SDIO_VENDOR_ID_KS_CODE_A        0x005b
+#define SDIO_VENDOR_ID_KS_CODE_B        0x0023
+/* Older sources suggest earlier versions were named 7910 or 79xx */
+#define SDIO_DEVICE_ID_KS_7010          0x7910
+
+/* Read Status Register */
+#define READ_STATUS             0x000000
+#define READ_STATUS_BUSY        0
+#define READ_STATUS_IDLE        1
+
+/* Read Index Register */
+#define READ_INDEX              0x000004
+
+/* Read Data Size Register */
+#define READ_DATA_SIZE          0x000008
+
+/* Write Status Register */
+#define WRITE_STATUS            0x00000C
+#define WRITE_STATUS_BUSY       0
+#define WRITE_STATUS_IDLE       1
+
+/* Write Index Register */
+#define WRITE_INDEX             0x000010
+
+/* Write Status/Read Data Size Register 
+ * for network packet (less than 2048 bytes data)
+ */
+#define WSTATUS_RSIZE           0x000014
+#define WSTATUS_MASK            0x80    /* Write Status Register value */
+#define RSIZE_MASK              0x7F    /* Read Data Size Register value [10:4] */
+
+/* ARM to SD interrupt Enable */
+#define INT_ENABLE              0x000020
+/* ARM to SD interrupt Pending */
+#define INT_PENDING             0x000024
+
+#define INT_GCR_B               (1<<7)
+#define INT_GCR_A               (1<<6)
+#define INT_WRITE_STATUS        (1<<5)
+#define INT_WRITE_INDEX         (1<<4)
+#define INT_WRITE_SIZE          (1<<3)
+#define INT_READ_STATUS         (1<<2)
+#define INT_READ_INDEX          (1<<1)
+#define INT_READ_SIZE           (1<<0)
+
+/* General Communication Register A */
+#define GCR_A                   0x000028
+#define GCR_A_INIT              0
+#define GCR_A_REMAP             1
+#define GCR_A_RUN               2
+
+/* General Communication Register B */
+#define GCR_B                   0x00002C
+#define GCR_B_ACTIVE            0
+#define GCR_B_DOZE              1
+
+/* Wakeup Register */
+/* #define WAKEUP                       0x008104 */
+/* #define WAKEUP_REQ           0x00 */
+#define WAKEUP                  0x008018
+#define WAKEUP_REQ              0x5a
+
+/* AHB Data Window  0x010000-0x01FFFF */
+#define DATA_WINDOW             0x010000
+#define WINDOW_SIZE             64*1024
+
+#define KS7010_IRAM_ADDRESS     0x06000000
+
+/* 
+ * struct define
+ */
+struct hw_info_t {
+        struct ks_sdio_card *sdio_card;
+        struct completion ks7010_sdio_wait;
+        struct workqueue_struct *ks7010sdio_wq;
+        struct delayed_work rw_wq;
+        unsigned char *read_buf;
+        struct tasklet_struct rx_bh_task;
+};
+
+struct ks_sdio_packet {
+        struct ks_sdio_packet *next;
+        u16 nb;
+        u8 buffer[0] __attribute__ ((aligned(4)));
+};
+
+struct ks_sdio_card {
+        struct sdio_func *func;
+        struct ks_wlan_private *priv;
+        spinlock_t lock;
+};
+
+/* Tx Device struct */
+#define TX_DEVICE_BUFF_SIZE     1024
+
+struct tx_device_buffer {
+        unsigned char *sendp;   /* pointer of send req data */
+        unsigned int size;
+        void (*complete_handler) (void *arg1, void *arg2);
+        void *arg1;
+        void *arg2;
+};
+
+struct tx_device {
+        struct tx_device_buffer tx_dev_buff[TX_DEVICE_BUFF_SIZE];
+        unsigned int qhead;     /* tx buffer queue first pointer */
+        unsigned int qtail;     /* tx buffer queue last pointer */
+        spinlock_t tx_dev_lock;
+};
+
+/* Rx Device struct */
+#define RX_DATA_SIZE    (2 + 2 + 2347 + 1)
+#define RX_DEVICE_BUFF_SIZE     32
+
+struct rx_device_buffer {
+        unsigned char data[RX_DATA_SIZE];
+        unsigned int size;
+};
+
+struct rx_device {
+        struct rx_device_buffer rx_dev_buff[RX_DEVICE_BUFF_SIZE];
+        unsigned int qhead;     /* rx buffer queue first pointer */
+        unsigned int qtail;     /* rx buffer queue last pointer */
+        spinlock_t rx_dev_lock;
+};
+#define ROM_FILE "ks7010sd.rom"
+
+#endif /* _KS7010_SDIO_H */
diff --git a/drivers/staging/ks7010/ks_hostif.c b/drivers/staging/ks7010/ks_hostif.c
new file mode 100644
index 000000000000..a8822fe2bd60
--- /dev/null
+++ b/drivers/staging/ks7010/ks_hostif.c
@@ -0,0 +1,2760 @@
+/*
+ *   Driver for KeyStream wireless LAN cards.
+ *
+ *   Copyright (C) 2005-2008 KeyStream Corp.
+ *   Copyright (C) 2009 Renesas Technology Corp.
+ *
+ *   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.
+ */
+
+#include "ks_wlan.h"
+#include "ks_hostif.h"
+#include "eap_packet.h"
+#include "michael_mic.h"
+
+#include <linux/if_ether.h>
+#include <linux/if_arp.h>
+
+/* Include Wireless Extension definition and check version */
+#include <net/iw_handler.h>     /* New driver API */
+
+extern int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p,
+                         unsigned long size,
+                         void (*complete_handler) (void *arg1, void *arg2),
+                         void *arg1, void *arg2);
+extern void send_packet_complete(void *, void *);
+
+extern void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv);
+extern int ks_wlan_hw_power_save(struct ks_wlan_private *priv);
+
+/* macro */
+#define inc_smeqhead(priv) \
+        ( priv->sme_i.qhead = (priv->sme_i.qhead + 1) % SME_EVENT_BUFF_SIZE )
+#define inc_smeqtail(priv) \
+        ( priv->sme_i.qtail = (priv->sme_i.qtail + 1) % SME_EVENT_BUFF_SIZE )
+#define cnt_smeqbody(priv) \
+        (((priv->sme_i.qtail + SME_EVENT_BUFF_SIZE) - (priv->sme_i.qhead)) % SME_EVENT_BUFF_SIZE )
+
+#define KS_WLAN_MEM_FLAG (GFP_ATOMIC)
+
+static
+inline u8 get_BYTE(struct ks_wlan_private *priv)
+{
+        u8 data;
+        data = *(priv->rxp)++;
+        /* length check in advance ! */
+        --(priv->rx_size);
+        return data;
+}
+
+static
+inline u16 get_WORD(struct ks_wlan_private *priv)
+{
+        u16 data;
+        data = (get_BYTE(priv) & 0xff);
+        data |= ((get_BYTE(priv) << 8) & 0xff00);
+        return data;
+}
+
+static
+inline u32 get_DWORD(struct ks_wlan_private *priv)
+{
+        u32 data;
+        data = (get_BYTE(priv) & 0xff);
+        data |= ((get_BYTE(priv) << 8) & 0x0000ff00);
+        data |= ((get_BYTE(priv) << 16) & 0x00ff0000);
+        data |= ((get_BYTE(priv) << 24) & 0xff000000);
+        return data;
+}
+
+void ks_wlan_hw_wakeup_task(struct work_struct *work)
+{
+        struct ks_wlan_private *priv =
+            container_of(work, struct ks_wlan_private, ks_wlan_wakeup_task);
+        int ps_status = atomic_read(&priv->psstatus.status);
+
+        if (ps_status == PS_SNOOZE) {
+                ks_wlan_hw_wakeup_request(priv);
+                if (!wait_for_completion_interruptible_timeout(&priv->psstatus.wakeup_wait, HZ / 50)) { /* 20ms timeout */
+                        DPRINTK(1, "wake up timeout !!!\n");
+                        schedule_work(&priv->ks_wlan_wakeup_task);
+                        return;
+                }
+        } else {
+                DPRINTK(1, "ps_status=%d\n", ps_status);
+        }
+
+        /* power save */
+        if (atomic_read(&priv->sme_task.count) > 0) {
+                DPRINTK(4, "sme task enable.\n");
+                tasklet_enable(&priv->sme_task);
+        }
+}
+
+static
+int ks_wlan_do_power_save(struct ks_wlan_private *priv)
+{
+        int rc = 0;
+
+        DPRINTK(4, "psstatus.status=%d\n", atomic_read(&priv->psstatus.status));
+
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+                hostif_sme_enqueue(priv, SME_POW_MNGMT_REQUEST);
+        } else {
+                priv->dev_state = DEVICE_STATE_READY;
+        }
+        return rc;
+}
+
+static
+int get_current_ap(struct ks_wlan_private *priv, struct link_ap_info_t *ap_info)
+{
+        struct local_ap_t *ap;
+        union iwreq_data wrqu;
+        struct net_device *netdev = priv->net_dev;
+        int rc = 0;
+
+        DPRINTK(3, "\n");
+        ap = &(priv->current_ap);
+
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == DISCONNECT_STATUS) {
+                memset(ap, 0, sizeof(struct local_ap_t));
+                return 1;
+        }
+
+        /* bssid */
+        memcpy(&(ap->bssid[0]), &(ap_info->bssid[0]), ETH_ALEN);
+        /* essid */
+        memcpy(&(ap->ssid.body[0]), &(priv->reg.ssid.body[0]),
+               priv->reg.ssid.size);
+        ap->ssid.size = priv->reg.ssid.size;
+        /* rate_set */
+        memcpy(&(ap->rate_set.body[0]), &(ap_info->rate_set.body[0]),
+               ap_info->rate_set.size);
+        ap->rate_set.size = ap_info->rate_set.size;
+        if (ap_info->ext_rate_set.size) {
+                /* rate_set */
+                memcpy(&(ap->rate_set.body[ap->rate_set.size]),
+                       &(ap_info->ext_rate_set.body[0]),
+                       ap_info->ext_rate_set.size);
+                ap->rate_set.size += ap_info->ext_rate_set.size;
+        }
+        /* channel */
+        ap->channel = ap_info->ds_parameter.channel;
+        /* rssi */
+        ap->rssi = ap_info->rssi;
+        /* sq */
+        ap->sq = ap_info->sq;
+        /* noise */
+        ap->noise = ap_info->noise;
+        /* capability */
+        ap->capability = ap_info->capability;
+        /* rsn */
+        if ((ap_info->rsn_mode & RSN_MODE_WPA2)
+            && (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)) {
+                ap->rsn_ie.id = 0x30;
+                if (ap_info->rsn.size <= RSN_IE_BODY_MAX) {
+                        ap->rsn_ie.size = ap_info->rsn.size;
+                        memcpy(&(ap->rsn_ie.body[0]), &(ap_info->rsn.body[0]),
+                               ap_info->rsn.size);
+                } else {
+                        ap->rsn_ie.size = RSN_IE_BODY_MAX;
+                        memcpy(&(ap->rsn_ie.body[0]), &(ap_info->rsn.body[0]),
+                               RSN_IE_BODY_MAX);
+                }
+        } else if ((ap_info->rsn_mode & RSN_MODE_WPA)
+                   && (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA)) {
+                ap->wpa_ie.id = 0xdd;
+                if (ap_info->rsn.size <= RSN_IE_BODY_MAX) {
+                        ap->wpa_ie.size = ap_info->rsn.size;
+                        memcpy(&(ap->wpa_ie.body[0]), &(ap_info->rsn.body[0]),
+                               ap_info->rsn.size);
+                } else {
+                        ap->wpa_ie.size = RSN_IE_BODY_MAX;
+                        memcpy(&(ap->wpa_ie.body[0]), &(ap_info->rsn.body[0]),
+                               RSN_IE_BODY_MAX);
+                }
+        } else {
+                ap->rsn_ie.id = 0;
+                ap->rsn_ie.size = 0;
+                ap->wpa_ie.id = 0;
+                ap->wpa_ie.size = 0;
+        }
+
+        wrqu.data.length = 0;
+        wrqu.data.flags = 0;
+        wrqu.ap_addr.sa_family = ARPHRD_ETHER;
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+                memcpy(wrqu.ap_addr.sa_data,
+                       &(priv->current_ap.bssid[0]), ETH_ALEN);
+                DPRINTK(3,
+                        "IWEVENT: connect bssid=%02x:%02x:%02x:%02x:%02x:%02x\n",
+                        (unsigned char)wrqu.ap_addr.sa_data[0],
+                        (unsigned char)wrqu.ap_addr.sa_data[1],
+                        (unsigned char)wrqu.ap_addr.sa_data[2],
+                        (unsigned char)wrqu.ap_addr.sa_data[3],
+                        (unsigned char)wrqu.ap_addr.sa_data[4],
+                        (unsigned char)wrqu.ap_addr.sa_data[5]);
+                wireless_send_event(netdev, SIOCGIWAP, &wrqu, NULL);
+        }
+        DPRINTK(4, "\n    Link AP\n");
+        DPRINTK(4, "    bssid=%02X:%02X:%02X:%02X:%02X:%02X\n \
+   essid=%s\n    rate_set=%02X,%02X,%02X,%02X,%02X,%02X,%02X,%02X\n    channel=%d\n \
+   rssi=%d\n    sq=%d\n    capability=%04X\n", ap->bssid[0], ap->bssid[1], ap->bssid[2], ap->bssid[3], ap->bssid[4], ap->bssid[5], &(ap->ssid.body[0]), ap->rate_set.body[0], ap->rate_set.body[1], ap->rate_set.body[2], ap->rate_set.body[3], ap->rate_set.body[4], ap->rate_set.body[5], ap->rate_set.body[6], ap->rate_set.body[7], ap->channel, ap->rssi, ap->sq, ap->capability);
+        DPRINTK(4, "\n    Link AP\n    rsn.mode=%d\n    rsn.size=%d\n",
+                ap_info->rsn_mode, ap_info->rsn.size);
+        DPRINTK(4, "\n    ext_rate_set_size=%d\n    rate_set_size=%d\n",
+                ap_info->ext_rate_set.size, ap_info->rate_set.size);
+
+        return rc;
+}
+
+static
+int get_ap_information(struct ks_wlan_private *priv, struct ap_info_t *ap_info,
+                       struct local_ap_t *ap)
+{
+        unsigned char *bp;
+        int bsize, offset;
+        int rc = 0;
+
+        DPRINTK(3, "\n");
+        memset(ap, 0, sizeof(struct local_ap_t));
+
+        /* bssid */
+        memcpy(&(ap->bssid[0]), &(ap_info->bssid[0]), ETH_ALEN);
+        /* rssi */
+        ap->rssi = ap_info->rssi;
+        /* sq */
+        ap->sq = ap_info->sq;
+        /* noise */
+        ap->noise = ap_info->noise;
+        /* capability */
+        ap->capability = ap_info->capability;
+        /* channel */
+        ap->channel = ap_info->ch_info;
+
+        bp = &(ap_info->body[0]);
+        bsize = ap_info->body_size;
+        offset = 0;
+
+        while (bsize > offset) {
+                /* DPRINTK(4, "Element ID=%d \n",*bp); */
+                switch (*bp) {
+                case 0: /* ssid */
+                        if (*(bp + 1) <= SSID_MAX_SIZE) {
+                                ap->ssid.size = *(bp + 1);
+                        } else {
+                                DPRINTK(1, "size over :: ssid size=%d \n",
+                                        *(bp + 1));
+                                ap->ssid.size = SSID_MAX_SIZE;
+                        }
+                        memcpy(&(ap->ssid.body[0]), bp + 2, ap->ssid.size);
+                        break;
+                case 1: /* rate */
+                case 50:        /* ext rate */
+                        if ((*(bp + 1) + ap->rate_set.size) <=
+                            RATE_SET_MAX_SIZE) {
+                                memcpy(&(ap->rate_set.body[ap->rate_set.size]),
+                                       bp + 2, *(bp + 1));
+                                ap->rate_set.size += *(bp + 1);
+                        } else {
+                                DPRINTK(1, "size over :: rate size=%d \n",
+                                        (*(bp + 1) + ap->rate_set.size));
+                                memcpy(&(ap->rate_set.body[ap->rate_set.size]),
+                                       bp + 2,
+                                       RATE_SET_MAX_SIZE - ap->rate_set.size);
+                                ap->rate_set.size +=
+                                    (RATE_SET_MAX_SIZE - ap->rate_set.size);
+                        }
+                        break;
+                case 3: /* DS parameter */
+                        break;
+                case 48:        /* RSN(WPA2) */
+                        ap->rsn_ie.id = *bp;
+                        if (*(bp + 1) <= RSN_IE_BODY_MAX) {
+                                ap->rsn_ie.size = *(bp + 1);
+                        } else {
+                                DPRINTK(1, "size over :: rsn size=%d \n",
+                                        *(bp + 1));
+                                ap->rsn_ie.size = RSN_IE_BODY_MAX;
+                        }
+                        memcpy(&(ap->rsn_ie.body[0]), bp + 2, ap->rsn_ie.size);
+                        break;
+                case 221:       /* WPA */
+                        if (!memcmp(bp + 2, "\x00\x50\xf2\x01", 4)) {   /* WPA OUI check */
+                                ap->wpa_ie.id = *bp;
+                                if (*(bp + 1) <= RSN_IE_BODY_MAX) {
+                                        ap->wpa_ie.size = *(bp + 1);
+                                } else {
+                                        DPRINTK(1,
+                                                "size over :: wpa size=%d \n",
+                                                *(bp + 1));
+                                        ap->wpa_ie.size = RSN_IE_BODY_MAX;
+                                }
+                                memcpy(&(ap->wpa_ie.body[0]), bp + 2,
+                                       ap->wpa_ie.size);
+                        }
+                        break;
+
+                case 2: /* FH parameter */
+                case 4: /* CF parameter */
+                case 5: /* TIM */
+                case 6: /* IBSS parameter */
+                case 7: /* Country */
+                case 42:        /* ERP information */
+                case 47:        /* Reserve ID 47 Broadcom AP */
+                        break;
+                default:
+                        DPRINTK(4, "unknown Element ID=%d \n", *bp);
+                        break;
+                }
+                offset += 2;    /* id & size field */
+                offset += *(bp + 1);    /* +size offset */
+                bp += (*(bp + 1) + 2);  /* pointer update */
+        }
+
+        return rc;
+}
+
+static
+void hostif_data_indication(struct ks_wlan_private *priv)
+{
+        unsigned int rx_ind_size;       /* indicate data size */
+        struct sk_buff *skb;
+        unsigned short auth_type;
+        unsigned char temp[256];
+
+        unsigned char RecvMIC[8];
+        char buf[128];
+        struct ether_hdr *eth_hdr;
+        unsigned short eth_proto;
+        unsigned long now;
+        struct mic_failure_t *mic_failure;
+        struct ieee802_1x_hdr *aa1x_hdr;
+        struct wpa_eapol_key *eap_key;
+        struct michel_mic_t michel_mic;
+        union iwreq_data wrqu;
+
+        DPRINTK(3, "\n");
+
+        /* min length check */
+        if (priv->rx_size <= ETH_HLEN) {
+                DPRINTK(3, "rx_size = %d\n", priv->rx_size);
+                priv->nstats.rx_errors++;
+                return;
+        }
+
+        auth_type = get_WORD(priv);     /* AuthType */
+        get_WORD(priv); /* Reserve Area */
+
+        eth_hdr = (struct ether_hdr *)(priv->rxp);
+        eth_proto = ntohs(eth_hdr->h_proto);
+        DPRINTK(3, "ether protocol = %04X\n", eth_proto);
+
+        /* source address check */
+        if (!memcmp(&priv->eth_addr[0], eth_hdr->h_source, ETH_ALEN)) {
+                DPRINTK(1, "invalid : source is own mac address !!\n");
+                DPRINTK(1,
+                        "eth_hdrernet->h_dest=%02X:%02X:%02X:%02X:%02X:%02X\n",
+                        eth_hdr->h_source[0], eth_hdr->h_source[1],
+                        eth_hdr->h_source[2], eth_hdr->h_source[3],
+                        eth_hdr->h_source[4], eth_hdr->h_source[5]);
+                priv->nstats.rx_errors++;
+                return;
+        }
+
+        /*  for WPA */
+        if (auth_type != TYPE_DATA && priv->wpa.rsn_enabled) {
+                if (memcmp(&eth_hdr->h_source[0], &priv->eth_addr[0], ETH_ALEN)) {      /* source address check */
+                        if (eth_hdr->h_dest_snap != eth_hdr->h_source_snap) {
+                                DPRINTK(1, "invalid data format\n");
+                                priv->nstats.rx_errors++;
+                                return;
+                        }
+                        if (((auth_type == TYPE_PMK1
+                              && priv->wpa.pairwise_suite ==
+                              IW_AUTH_CIPHER_TKIP) || (auth_type == TYPE_GMK1
+                                                       && priv->wpa.
+                                                       group_suite ==
+                                                       IW_AUTH_CIPHER_TKIP)
+                             || (auth_type == TYPE_GMK2
+                                 && priv->wpa.group_suite ==
+                                 IW_AUTH_CIPHER_TKIP))
+                            && priv->wpa.key[auth_type - 1].key_len) {
+                                DPRINTK(4, "TKIP: protocol=%04X: size=%u\n",
+                                        eth_proto, priv->rx_size);
+                                /* MIC save */
+                                memcpy(&RecvMIC[0],
+                                       (priv->rxp) + ((priv->rx_size) - 8), 8);
+                                priv->rx_size = priv->rx_size - 8;
+                                if (auth_type > 0 && auth_type < 4) {   /* auth_type check */
+                                        MichaelMICFunction(&michel_mic, (uint8_t *) priv->wpa.key[auth_type - 1].rx_mic_key, (uint8_t *) priv->rxp, (int)priv->rx_size, (uint8_t) 0,    /* priority */
+                                                           (uint8_t *)
+                                                           michel_mic.Result);
+                                }
+                                if (memcmp(michel_mic.Result, RecvMIC, 8)) {
+                                        now = jiffies;
+                                        mic_failure = &priv->wpa.mic_failure;
+                                        /* MIC FAILURE */
+                                        if (mic_failure->last_failure_time &&
+                                            (now -
+                                             mic_failure->last_failure_time) /
+                                            HZ >= 60) {
+                                                mic_failure->failure = 0;
+                                        }
+                                        DPRINTK(4, "MIC FAILURE \n");
+                                        if (mic_failure->failure == 0) {
+                                                mic_failure->failure = 1;
+                                                mic_failure->counter = 0;
+                                        } else if (mic_failure->failure == 1) {
+                                                mic_failure->failure = 2;
+                                                mic_failure->counter =
+                                                    (uint16_t) ((now -
+                                                                 mic_failure->
+                                                                 last_failure_time)
+                                                                / HZ);
+                                                if (!mic_failure->counter)      /* mic_failure counter value range 1-60 */
+                                                        mic_failure->counter =
+                                                            1;
+                                        }
+                                        priv->wpa.mic_failure.
+                                            last_failure_time = now;
+                                        /*  needed parameters: count, keyid, key type, TSC */
+                                        sprintf(buf,
+                                                "MLME-MICHAELMICFAILURE.indication(keyid=%d %scast addr="
+                                                "%02x:%02x:%02x:%02x:%02x:%02x)",
+                                                auth_type - 1,
+                                                eth_hdr->
+                                                h_dest[0] & 0x01 ? "broad" :
+                                                "uni", eth_hdr->h_source[0],
+                                                eth_hdr->h_source[1],
+                                                eth_hdr->h_source[2],
+                                                eth_hdr->h_source[3],
+                                                eth_hdr->h_source[4],
+                                                eth_hdr->h_source[5]);
+                                        memset(&wrqu, 0, sizeof(wrqu));
+                                        wrqu.data.length = strlen(buf);
+                                        DPRINTK(4,
+                                                "IWEVENT:MICHAELMICFAILURE\n");
+                                        wireless_send_event(priv->net_dev,
+                                                            IWEVCUSTOM, &wrqu,
+                                                            buf);
+                                        return;
+                                }
+                        }
+                }
+        }
+
+        if ((priv->connect_status & FORCE_DISCONNECT) ||
+            priv->wpa.mic_failure.failure == 2) {
+                return;
+        }
+
+        /* check 13th byte at rx data */
+        switch (*(priv->rxp + 12)) {
+        case 0xAA:      /* SNAP */
+                rx_ind_size = priv->rx_size - 6;
+                skb = dev_alloc_skb(rx_ind_size);
+                DPRINTK(4, "SNAP, rx_ind_size = %d\n", rx_ind_size);
+
+                if (skb) {
+                        memcpy(skb_put(skb, 12), priv->rxp, 12);        /* 8802/FDDI MAC copy */
+                        /* (SNAP+UI..) skip */
+                        memcpy(skb_put(skb, rx_ind_size - 12), priv->rxp + 18, rx_ind_size - 12);       /* copy after Type */
+
+                        aa1x_hdr = (struct ieee802_1x_hdr *)(priv->rxp + 20);
+                        if (aa1x_hdr->type == IEEE802_1X_TYPE_EAPOL_KEY
+                            && priv->wpa.rsn_enabled) {
+                                eap_key =
+                                    (struct wpa_eapol_key *)(aa1x_hdr + 1);
+                                atomic_set(&priv->psstatus.snooze_guard, 1);
+                        }
+
+                        /* rx indication */
+                        skb->dev = priv->net_dev;
+                        skb->protocol = eth_type_trans(skb, skb->dev);
+                        priv->nstats.rx_packets++;
+                        priv->nstats.rx_bytes += rx_ind_size;
+                        skb->dev->last_rx = jiffies;
+                        netif_rx(skb);
+                } else {
+                        printk(KERN_WARNING
+                               "%s: Memory squeeze, dropping packet.\n",
+                               skb->dev->name);
+                        priv->nstats.rx_dropped++;
+                }
+                break;
+        case 0xF0:      /* NETBEUI/NetBIOS */
+                rx_ind_size = (priv->rx_size + 2);
+                skb = dev_alloc_skb(rx_ind_size);
+                DPRINTK(3, "NETBEUI/NetBIOS rx_ind_size=%d\n", rx_ind_size);
+
+                if (skb) {
+                        memcpy(skb_put(skb, 12), priv->rxp, 12);        /* 8802/FDDI MAC copy */
+
+                        temp[0] = (((rx_ind_size - 12) >> 8) & 0xff);   /* NETBEUI size add */
+                        temp[1] = ((rx_ind_size - 12) & 0xff);
+                        memcpy(skb_put(skb, 2), temp, 2);
+
+                        memcpy(skb_put(skb, rx_ind_size - 14), priv->rxp + 12, rx_ind_size - 14);       /* copy after Type */
+
+                        aa1x_hdr = (struct ieee802_1x_hdr *)(priv->rxp + 14);
+                        if (aa1x_hdr->type == IEEE802_1X_TYPE_EAPOL_KEY
+                            && priv->wpa.rsn_enabled) {
+                                eap_key =
+                                    (struct wpa_eapol_key *)(aa1x_hdr + 1);
+                                atomic_set(&priv->psstatus.snooze_guard, 1);
+                        }
+
+                        /* rx indication */
+                        skb->dev = priv->net_dev;
+                        skb->protocol = eth_type_trans(skb, skb->dev);
+                        priv->nstats.rx_packets++;
+                        priv->nstats.rx_bytes += rx_ind_size;
+                        skb->dev->last_rx = jiffies;
+                        netif_rx(skb);
+                } else {
+                        printk(KERN_WARNING
+                               "%s: Memory squeeze, dropping packet.\n",
+                               skb->dev->name);
+                        priv->nstats.rx_dropped++;
+                }
+                break;
+        default:        /* other rx data */
+                DPRINTK(2, "invalid data format\n");
+                priv->nstats.rx_errors++;
+        }
+}
+
+static
+void hostif_mib_get_confirm(struct ks_wlan_private *priv)
+{
+        struct net_device *dev = priv->net_dev;
+        uint32_t mib_status;
+        uint32_t mib_attribute;
+        uint16_t mib_val_size;
+        uint16_t mib_val_type;
+
+        DPRINTK(3, "\n");
+
+        mib_status = get_DWORD(priv);   /* MIB status */
+        mib_attribute = get_DWORD(priv);        /* MIB atttibute */
+        mib_val_size = get_WORD(priv);  /* MIB value size */
+        mib_val_type = get_WORD(priv);  /* MIB value type */
+
+        if (mib_status != 0) {
+                /* in case of error */
+                DPRINTK(1, "attribute=%08X, status=%08X\n", mib_attribute,
+                        mib_status);
+                return;
+        }
+
+        switch (mib_attribute) {
+        case DOT11_MAC_ADDRESS:
+                /* MAC address */
+                DPRINTK(3, " mib_attribute=DOT11_MAC_ADDRESS\n");
+                hostif_sme_enqueue(priv, SME_GET_MAC_ADDRESS);
+                memcpy(priv->eth_addr, priv->rxp, ETH_ALEN);
+                priv->mac_address_valid = 1;
+                dev->dev_addr[0] = priv->eth_addr[0];
+                dev->dev_addr[1] = priv->eth_addr[1];
+                dev->dev_addr[2] = priv->eth_addr[2];
+                dev->dev_addr[3] = priv->eth_addr[3];
+                dev->dev_addr[4] = priv->eth_addr[4];
+                dev->dev_addr[5] = priv->eth_addr[5];
+                dev->dev_addr[6] = 0x00;
+                dev->dev_addr[7] = 0x00;
+                printk(KERN_INFO
+                       "ks_wlan: MAC ADDRESS = %02x:%02x:%02x:%02x:%02x:%02x\n",
+                       priv->eth_addr[0], priv->eth_addr[1], priv->eth_addr[2],
+                       priv->eth_addr[3], priv->eth_addr[4], priv->eth_addr[5]);
+                break;
+        case DOT11_PRODUCT_VERSION:
+                /* firmware version */
+                DPRINTK(3, " mib_attribute=DOT11_PRODUCT_VERSION\n");
+                priv->version_size = priv->rx_size;
+                memcpy(priv->firmware_version, priv->rxp, priv->rx_size);
+                priv->firmware_version[priv->rx_size] = '\0';
+                printk(KERN_INFO "ks_wlan: firmware ver. = %s\n",
+                       priv->firmware_version);
+                hostif_sme_enqueue(priv, SME_GET_PRODUCT_VERSION);
+                /* wake_up_interruptible_all(&priv->confirm_wait); */
+                complete(&priv->confirm_wait);
+                break;
+        case LOCAL_GAIN:
+                memcpy(&priv->gain, priv->rxp, sizeof(priv->gain));
+                DPRINTK(3, "TxMode=%d, RxMode=%d, TxGain=%d, RxGain=%d\n",
+                        priv->gain.TxMode, priv->gain.RxMode, priv->gain.TxGain,
+                        priv->gain.RxGain);
+                break;
+        case LOCAL_EEPROM_SUM:
+                memcpy(&priv->eeprom_sum, priv->rxp, sizeof(priv->eeprom_sum));
+                DPRINTK(1, "eeprom_sum.type=%x, eeprom_sum.result=%x\n",
+                        priv->eeprom_sum.type, priv->eeprom_sum.result);
+                if (priv->eeprom_sum.type == 0) {
+                        priv->eeprom_checksum = EEPROM_CHECKSUM_NONE;
+                } else if (priv->eeprom_sum.type == 1) {
+                        if (priv->eeprom_sum.result == 0) {
+                                priv->eeprom_checksum = EEPROM_NG;
+                                printk("LOCAL_EEPROM_SUM NG\n");
+                        } else if (priv->eeprom_sum.result == 1) {
+                                priv->eeprom_checksum = EEPROM_OK;
+                        }
+                } else {
+                        printk("LOCAL_EEPROM_SUM error!\n");
+                }
+                break;
+        default:
+                DPRINTK(1, "mib_attribute=%08x\n", (unsigned int)mib_attribute);
+                break;
+        }
+}
+
+static
+void hostif_mib_set_confirm(struct ks_wlan_private *priv)
+{
+        uint32_t mib_status;    /* +04 MIB Status */
+        uint32_t mib_attribute; /* +08 MIB attribute */
+
+        DPRINTK(3, "\n");
+
+        mib_status = get_DWORD(priv);   /* MIB Status */
+        mib_attribute = get_DWORD(priv);        /* MIB attribute */
+
+        if (mib_status != 0) {
+                /* in case of error */
+                DPRINTK(1, "error :: attribute=%08X, status=%08X\n",
+                        mib_attribute, mib_status);
+        }
+
+        switch (mib_attribute) {
+        case DOT11_RTS_THRESHOLD:
+                hostif_sme_enqueue(priv, SME_RTS_THRESHOLD_CONFIRM);
+                break;
+        case DOT11_FRAGMENTATION_THRESHOLD:
+                hostif_sme_enqueue(priv, SME_FRAGMENTATION_THRESHOLD_CONFIRM);
+                break;
+        case DOT11_WEP_DEFAULT_KEY_ID:
+                if (!priv->wpa.wpa_enabled)
+                        hostif_sme_enqueue(priv, SME_WEP_INDEX_CONFIRM);
+                break;
+        case DOT11_WEP_DEFAULT_KEY_VALUE1:
+                DPRINTK(2, "DOT11_WEP_DEFAULT_KEY_VALUE1:mib_status=%d\n",
+                        (int)mib_status);
+                if (priv->wpa.rsn_enabled)
+                        hostif_sme_enqueue(priv, SME_SET_PMK_TSC);
+                else
+                        hostif_sme_enqueue(priv, SME_WEP_KEY1_CONFIRM);
+                break;
+        case DOT11_WEP_DEFAULT_KEY_VALUE2:
+                DPRINTK(2, "DOT11_WEP_DEFAULT_KEY_VALUE2:mib_status=%d\n",
+                        (int)mib_status);
+                if (priv->wpa.rsn_enabled)
+                        hostif_sme_enqueue(priv, SME_SET_GMK1_TSC);
+                else
+                        hostif_sme_enqueue(priv, SME_WEP_KEY2_CONFIRM);
+                break;
+        case DOT11_WEP_DEFAULT_KEY_VALUE3:
+                DPRINTK(2, "DOT11_WEP_DEFAULT_KEY_VALUE3:mib_status=%d\n",
+                        (int)mib_status);
+                if (priv->wpa.rsn_enabled)
+                        hostif_sme_enqueue(priv, SME_SET_GMK2_TSC);
+                else
+                        hostif_sme_enqueue(priv, SME_WEP_KEY3_CONFIRM);
+                break;
+        case DOT11_WEP_DEFAULT_KEY_VALUE4:
+                DPRINTK(2, "DOT11_WEP_DEFAULT_KEY_VALUE4:mib_status=%d\n",
+                        (int)mib_status);
+                if (!priv->wpa.rsn_enabled)
+                        hostif_sme_enqueue(priv, SME_WEP_KEY4_CONFIRM);
+                break;
+        case DOT11_PRIVACY_INVOKED:
+                if (!priv->wpa.rsn_enabled)
+                        hostif_sme_enqueue(priv, SME_WEP_FLAG_CONFIRM);
+                break;
+        case DOT11_RSN_ENABLED:
+                DPRINTK(2, "DOT11_RSN_ENABLED:mib_status=%d\n",
+                        (int)mib_status);
+                hostif_sme_enqueue(priv, SME_RSN_ENABLED_CONFIRM);
+                break;
+        case LOCAL_RSN_MODE:
+                hostif_sme_enqueue(priv, SME_RSN_MODE_CONFIRM);
+                break;
+        case LOCAL_MULTICAST_ADDRESS:
+                hostif_sme_enqueue(priv, SME_MULTICAST_REQUEST);
+                break;
+        case LOCAL_MULTICAST_FILTER:
+                hostif_sme_enqueue(priv, SME_MULTICAST_CONFIRM);
+                break;
+        case LOCAL_CURRENTADDRESS:
+                priv->mac_address_valid = 1;
+                break;
+        case DOT11_RSN_CONFIG_MULTICAST_CIPHER:
+                DPRINTK(2, "DOT11_RSN_CONFIG_MULTICAST_CIPHER:mib_status=%d\n",
+                        (int)mib_status);
+                hostif_sme_enqueue(priv, SME_RSN_MCAST_CONFIRM);
+                break;
+        case DOT11_RSN_CONFIG_UNICAST_CIPHER:
+                DPRINTK(2, "DOT11_RSN_CONFIG_UNICAST_CIPHER:mib_status=%d\n",
+                        (int)mib_status);
+                hostif_sme_enqueue(priv, SME_RSN_UCAST_CONFIRM);
+                break;
+        case DOT11_RSN_CONFIG_AUTH_SUITE:
+                DPRINTK(2, "DOT11_RSN_CONFIG_AUTH_SUITE:mib_status=%d\n",
+                        (int)mib_status);
+                hostif_sme_enqueue(priv, SME_RSN_AUTH_CONFIRM);
+                break;
+        case DOT11_PMK_TSC:
+                DPRINTK(2, "DOT11_PMK_TSC:mib_status=%d\n", (int)mib_status);
+                break;
+        case DOT11_GMK1_TSC:
+                DPRINTK(2, "DOT11_GMK1_TSC:mib_status=%d\n", (int)mib_status);
+                if (atomic_read(&priv->psstatus.snooze_guard)) {
+                        atomic_set(&priv->psstatus.snooze_guard, 0);
+                }
+                break;
+        case DOT11_GMK2_TSC:
+                DPRINTK(2, "DOT11_GMK2_TSC:mib_status=%d\n", (int)mib_status);
+                if (atomic_read(&priv->psstatus.snooze_guard)) {
+                        atomic_set(&priv->psstatus.snooze_guard, 0);
+                }
+                break;
+        case LOCAL_PMK:
+                DPRINTK(2, "LOCAL_PMK:mib_status=%d\n", (int)mib_status);
+                break;
+        case LOCAL_GAIN:
+                DPRINTK(2, "LOCAL_GAIN:mib_status=%d\n", (int)mib_status);
+                break;
+#ifdef WPS
+        case LOCAL_WPS_ENABLE:
+                DPRINTK(2, "LOCAL_WPS_ENABLE:mib_status=%d\n", (int)mib_status);
+                break;
+        case LOCAL_WPS_PROBE_REQ:
+                DPRINTK(2, "LOCAL_WPS_PROBE_REQ:mib_status=%d\n",
+                        (int)mib_status);
+                break;
+#endif /* WPS */
+        case LOCAL_REGION:
+                DPRINTK(2, "LOCAL_REGION:mib_status=%d\n", (int)mib_status);
+        default:
+                break;
+        }
+}
+
+static
+void hostif_power_mngmt_confirm(struct ks_wlan_private *priv)
+{
+        DPRINTK(3, "\n");
+
+        if (priv->reg.powermgt > POWMGT_ACTIVE_MODE &&
+            priv->reg.operation_mode == MODE_INFRASTRUCTURE) {
+                atomic_set(&priv->psstatus.confirm_wait, 0);
+                priv->dev_state = DEVICE_STATE_SLEEP;
+                ks_wlan_hw_power_save(priv);
+        } else {
+                priv->dev_state = DEVICE_STATE_READY;
+        }
+
+}
+
+static
+void hostif_sleep_confirm(struct ks_wlan_private *priv)
+{
+        DPRINTK(3, "\n");
+
+        atomic_set(&priv->sleepstatus.doze_request, 1);
+        queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                           &priv->ks_wlan_hw.rw_wq, 1);
+}
+
+static
+void hostif_start_confirm(struct ks_wlan_private *priv)
+{
+#ifdef  WPS
+        union iwreq_data wrqu;
+        wrqu.data.length = 0;
+        wrqu.data.flags = 0;
+        wrqu.ap_addr.sa_family = ARPHRD_ETHER;
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+                memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
+                DPRINTK(3, "IWEVENT: disconnect\n");
+                wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
+        }
+#endif
+        DPRINTK(3, " scan_ind_count=%d\n", priv->scan_ind_count);
+        hostif_sme_enqueue(priv, SME_START_CONFIRM);
+}
+
+static
+void hostif_connect_indication(struct ks_wlan_private *priv)
+{
+        unsigned short connect_code;
+        unsigned int tmp = 0;
+        unsigned int old_status = priv->connect_status;
+        struct net_device *netdev = priv->net_dev;
+        union iwreq_data wrqu0;
+        connect_code = get_WORD(priv);
+
+        switch (connect_code) {
+        case RESULT_CONNECT:    /* connect */
+                DPRINTK(3, "connect :: scan_ind_count=%d\n",
+                        priv->scan_ind_count);
+                if (!(priv->connect_status & FORCE_DISCONNECT))
+                        netif_carrier_on(netdev);
+                tmp = FORCE_DISCONNECT & priv->connect_status;
+                priv->connect_status = tmp + CONNECT_STATUS;
+                break;
+        case RESULT_DISCONNECT: /* disconnect */
+                DPRINTK(3, "disconnect :: scan_ind_count=%d\n",
+                        priv->scan_ind_count);
+                netif_carrier_off(netdev);
+                tmp = FORCE_DISCONNECT & priv->connect_status;
+                priv->connect_status = tmp + DISCONNECT_STATUS;
+                break;
+        default:
+                DPRINTK(1, "unknown connect_code=%d :: scan_ind_count=%d\n",
+                        connect_code, priv->scan_ind_count);
+                netif_carrier_off(netdev);
+                tmp = FORCE_DISCONNECT & priv->connect_status;
+                priv->connect_status = tmp + DISCONNECT_STATUS;
+                break;
+        }
+
+        get_current_ap(priv, (struct link_ap_info_t *)priv->rxp);
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS &&
+            (old_status & CONNECT_STATUS_MASK) == DISCONNECT_STATUS) {
+                /* for power save */
+                atomic_set(&priv->psstatus.snooze_guard, 0);
+                atomic_set(&priv->psstatus.confirm_wait, 0);
+        }
+        ks_wlan_do_power_save(priv);
+
+        wrqu0.data.length = 0;
+        wrqu0.data.flags = 0;
+        wrqu0.ap_addr.sa_family = ARPHRD_ETHER;
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == DISCONNECT_STATUS &&
+            (old_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+                memset(wrqu0.ap_addr.sa_data, '\0', ETH_ALEN);
+                DPRINTK(3, "IWEVENT: disconnect\n");
+                DPRINTK(3, "disconnect :: scan_ind_count=%d\n",
+                        priv->scan_ind_count);
+                wireless_send_event(netdev, SIOCGIWAP, &wrqu0, NULL);
+        }
+        priv->scan_ind_count = 0;
+}
+
+static
+void hostif_scan_indication(struct ks_wlan_private *priv)
+{
+        int i;
+        struct ap_info_t *ap_info;
+
+        DPRINTK(3, "scan_ind_count = %d\n", priv->scan_ind_count);
+        ap_info = (struct ap_info_t *)(priv->rxp);
+
+        if (priv->scan_ind_count != 0) {
+                for (i = 0; i < priv->aplist.size; i++) {       /* bssid check */
+                        if (!memcmp
+                            (&(ap_info->bssid[0]),
+                             &(priv->aplist.ap[i].bssid[0]), ETH_ALEN)) {
+                                if (ap_info->frame_type ==
+                                    FRAME_TYPE_PROBE_RESP)
+                                        get_ap_information(priv, ap_info,
+                                                           &(priv->aplist.
+                                                             ap[i]));
+                                return;
+                        }
+                }
+        }
+        priv->scan_ind_count++;
+        if (priv->scan_ind_count < LOCAL_APLIST_MAX + 1) {
+                DPRINTK(4, " scan_ind_count=%d :: aplist.size=%d\n",
+                        priv->scan_ind_count, priv->aplist.size);
+                get_ap_information(priv, (struct ap_info_t *)(priv->rxp),
+                                   &(priv->aplist.
+                                     ap[priv->scan_ind_count - 1]));
+                priv->aplist.size = priv->scan_ind_count;
+        } else {
+                DPRINTK(4, " count over :: scan_ind_count=%d\n",
+                        priv->scan_ind_count);
+        }
+
+}
+
+static
+void hostif_stop_confirm(struct ks_wlan_private *priv)
+{
+        unsigned int tmp = 0;
+        unsigned int old_status = priv->connect_status;
+        struct net_device *netdev = priv->net_dev;
+        union iwreq_data wrqu0;
+
+        DPRINTK(3, "\n");
+        if (priv->dev_state == DEVICE_STATE_SLEEP)
+                priv->dev_state = DEVICE_STATE_READY;
+
+        /* disconnect indication */
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+                netif_carrier_off(netdev);
+                tmp = FORCE_DISCONNECT & priv->connect_status;
+                priv->connect_status = tmp | DISCONNECT_STATUS;
+                printk("IWEVENT: disconnect\n");
+
+                wrqu0.data.length = 0;
+                wrqu0.data.flags = 0;
+                wrqu0.ap_addr.sa_family = ARPHRD_ETHER;
+                if ((priv->connect_status & CONNECT_STATUS_MASK) ==
+                    DISCONNECT_STATUS
+                    && (old_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+                        memset(wrqu0.ap_addr.sa_data, '\0', ETH_ALEN);
+                        DPRINTK(3, "IWEVENT: disconnect\n");
+                        printk("IWEVENT: disconnect\n");
+                        DPRINTK(3, "disconnect :: scan_ind_count=%d\n",
+                                priv->scan_ind_count);
+                        wireless_send_event(netdev, SIOCGIWAP, &wrqu0, NULL);
+                }
+                priv->scan_ind_count = 0;
+        }
+
+        hostif_sme_enqueue(priv, SME_STOP_CONFIRM);
+}
+
+static
+void hostif_ps_adhoc_set_confirm(struct ks_wlan_private *priv)
+{
+        DPRINTK(3, "\n");
+        priv->infra_status = 0; /* infrastructure mode cancel */
+        hostif_sme_enqueue(priv, SME_MODE_SET_CONFIRM);
+
+}
+
+static
+void hostif_infrastructure_set_confirm(struct ks_wlan_private *priv)
+{
+        uint16_t result_code;
+        DPRINTK(3, "\n");
+        result_code = get_WORD(priv);
+        DPRINTK(3, "result code = %d\n", result_code);
+        priv->infra_status = 1; /* infrastructure mode set */
+        hostif_sme_enqueue(priv, SME_MODE_SET_CONFIRM);
+}
+
+static
+void hostif_adhoc_set_confirm(struct ks_wlan_private *priv)
+{
+        DPRINTK(3, "\n");
+        priv->infra_status = 1; /* infrastructure mode set */
+        hostif_sme_enqueue(priv, SME_MODE_SET_CONFIRM);
+}
+
+static
+void hostif_associate_indication(struct ks_wlan_private *priv)
+{
+        struct association_request_t *assoc_req;
+        struct association_response_t *assoc_resp;
+        unsigned char *pb;
+        union iwreq_data wrqu;
+        char buf[IW_CUSTOM_MAX];
+        char *pbuf = &buf[0];
+        int i;
+
+        static const char associnfo_leader0[] = "ASSOCINFO(ReqIEs=";
+        static const char associnfo_leader1[] = " RespIEs=";
+
+        DPRINTK(3, "\n");
+        assoc_req = (struct association_request_t *)(priv->rxp);
+        assoc_resp = (struct association_response_t *)(assoc_req + 1);
+        pb = (unsigned char *)(assoc_resp + 1);
+
+        memset(&wrqu, 0, sizeof(wrqu));
+        memcpy(pbuf, associnfo_leader0, sizeof(associnfo_leader0) - 1);
+        wrqu.data.length += sizeof(associnfo_leader0) - 1;
+        pbuf += sizeof(associnfo_leader0) - 1;
+
+        for (i = 0; i < assoc_req->reqIEs_size; i++)
+                pbuf += sprintf(pbuf, "%02x", *(pb + i));
+        wrqu.data.length += (assoc_req->reqIEs_size) * 2;
+
+        memcpy(pbuf, associnfo_leader1, sizeof(associnfo_leader1) - 1);
+        wrqu.data.length += sizeof(associnfo_leader1) - 1;
+        pbuf += sizeof(associnfo_leader1) - 1;
+
+        pb += assoc_req->reqIEs_size;
+        for (i = 0; i < assoc_resp->respIEs_size; i++)
+                pbuf += sprintf(pbuf, "%02x", *(pb + i));
+        wrqu.data.length += (assoc_resp->respIEs_size) * 2;
+
+        pbuf += sprintf(pbuf, ")");
+        wrqu.data.length += 1;
+
+        DPRINTK(3, "IWEVENT:ASSOCINFO\n");
+        wireless_send_event(priv->net_dev, IWEVCUSTOM, &wrqu, buf);
+}
+
+static
+void hostif_bss_scan_confirm(struct ks_wlan_private *priv)
+{
+        unsigned int result_code;
+        struct net_device *dev = priv->net_dev;
+        union iwreq_data wrqu;
+        result_code = get_DWORD(priv);
+        DPRINTK(2, "result=%d :: scan_ind_count=%d\n", result_code,
+                priv->scan_ind_count);
+
+        priv->sme_i.sme_flag &= ~SME_AP_SCAN;
+        hostif_sme_enqueue(priv, SME_BSS_SCAN_CONFIRM);
+
+        wrqu.data.length = 0;
+        wrqu.data.flags = 0;
+        DPRINTK(3, "IWEVENT: SCAN CONFIRM\n");
+        wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
+        priv->scan_ind_count = 0;
+}
+
+static
+void hostif_phy_information_confirm(struct ks_wlan_private *priv)
+{
+        struct iw_statistics *wstats = &priv->wstats;
+        unsigned char rssi, signal, noise;
+        unsigned char LinkSpeed;
+        unsigned int TransmittedFrameCount, ReceivedFragmentCount;
+        unsigned int FailedCount, FCSErrorCount;
+
+        DPRINTK(3, "\n");
+        rssi = get_BYTE(priv);
+        signal = get_BYTE(priv);
+        noise = get_BYTE(priv);
+        LinkSpeed = get_BYTE(priv);
+        TransmittedFrameCount = get_DWORD(priv);
+        ReceivedFragmentCount = get_DWORD(priv);
+        FailedCount = get_DWORD(priv);
+        FCSErrorCount = get_DWORD(priv);
+
+        DPRINTK(4, "phyinfo confirm rssi=%d signal=%d\n", rssi, signal);
+        priv->current_rate = (LinkSpeed & RATE_MASK);
+        wstats->qual.qual = signal;
+        wstats->qual.level = 256 - rssi;
+        wstats->qual.noise = 0; /* invalid noise value */
+        wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
+
+        DPRINTK(3, "\n    rssi=%u\n    signal=%u\n    LinkSpeed=%ux500Kbps\n \
+   TransmittedFrameCount=%u\n    ReceivedFragmentCount=%u\n    FailedCount=%u\n \
+   FCSErrorCount=%u\n", rssi, signal, LinkSpeed, TransmittedFrameCount, ReceivedFragmentCount, FailedCount, FCSErrorCount);
+
+        /* wake_up_interruptible_all(&priv->confirm_wait); */
+        complete(&priv->confirm_wait);
+}
+
+static
+void hostif_mic_failure_confirm(struct ks_wlan_private *priv)
+{
+        DPRINTK(3, "mic_failure=%u\n", priv->wpa.mic_failure.failure);
+        hostif_sme_enqueue(priv, SME_MIC_FAILURE_CONFIRM);
+}
+
+static
+void hostif_event_check(struct ks_wlan_private *priv)
+{
+        unsigned short event;
+
+        DPRINTK(4, "\n");
+        event = get_WORD(priv); /* get event */
+        switch (event) {
+        case HIF_DATA_IND:
+                hostif_data_indication(priv);
+                break;
+        case HIF_MIB_GET_CONF:
+                hostif_mib_get_confirm(priv);
+                break;
+        case HIF_MIB_SET_CONF:
+                hostif_mib_set_confirm(priv);
+                break;
+        case HIF_POWERMGT_CONF:
+                hostif_power_mngmt_confirm(priv);
+                break;
+        case HIF_SLEEP_CONF:
+                hostif_sleep_confirm(priv);
+                break;
+        case HIF_START_CONF:
+                hostif_start_confirm(priv);
+                break;
+        case HIF_CONNECT_IND:
+                hostif_connect_indication(priv);
+                break;
+        case HIF_STOP_CONF:
+                hostif_stop_confirm(priv);
+                break;
+        case HIF_PS_ADH_SET_CONF:
+                hostif_ps_adhoc_set_confirm(priv);
+                break;
+        case HIF_INFRA_SET_CONF:
+        case HIF_INFRA_SET2_CONF:
+                hostif_infrastructure_set_confirm(priv);
+                break;
+        case HIF_ADH_SET_CONF:
+        case HIF_ADH_SET2_CONF:
+                hostif_adhoc_set_confirm(priv);
+                break;
+        case HIF_ASSOC_INFO_IND:
+                hostif_associate_indication(priv);
+                break;
+        case HIF_MIC_FAILURE_CONF:
+                hostif_mic_failure_confirm(priv);
+                break;
+        case HIF_SCAN_CONF:
+                hostif_bss_scan_confirm(priv);
+                break;
+        case HIF_PHY_INFO_CONF:
+        case HIF_PHY_INFO_IND:
+                hostif_phy_information_confirm(priv);
+                break;
+        case HIF_SCAN_IND:
+                hostif_scan_indication(priv);
+                break;
+        case HIF_AP_SET_CONF:
+        default:
+                //DPRINTK(1, "undefined event[%04X]\n", event);
+                printk("undefined event[%04X]\n", event);
+                /* wake_up_all(&priv->confirm_wait); */
+                complete(&priv->confirm_wait);
+                break;
+        }
+
+        /* add event to hostt buffer */
+        priv->hostt.buff[priv->hostt.qtail] = event;
+        priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE;
+}
+
+#define CHECK_ALINE(size) (size%4 ? (size+(4-(size%4))):size)
+
+int hostif_data_request(struct ks_wlan_private *priv, struct sk_buff *packet)
+{
+        unsigned int packet_len = 0;
+
+        unsigned char *buffer = NULL;
+        unsigned int length = 0;
+        struct hostif_data_request_t *pp;
+        unsigned char *p;
+        int result = 0;
+        unsigned short eth_proto;
+        struct ether_hdr *eth_hdr;
+        struct michel_mic_t michel_mic;
+        unsigned short keyinfo = 0;
+        struct ieee802_1x_hdr *aa1x_hdr;
+        struct wpa_eapol_key *eap_key;
+        struct ethhdr *eth;
+
+        packet_len = packet->len;
+        if (packet_len > ETH_FRAME_LEN) {
+                DPRINTK(1, "bad length packet_len=%d \n", packet_len);
+                dev_kfree_skb(packet);
+                return -1;
+        }
+
+        if (((priv->connect_status & CONNECT_STATUS_MASK) == DISCONNECT_STATUS)
+            || (priv->connect_status & FORCE_DISCONNECT)
+            || priv->wpa.mic_failure.stop) {
+                DPRINTK(3, " DISCONNECT\n");
+                if (netif_queue_stopped(priv->net_dev))
+                        netif_wake_queue(priv->net_dev);
+                if (packet)
+                        dev_kfree_skb(packet);
+
+                return 0;
+        }
+
+        /* for PowerSave */
+        if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { /* power save wakeup */
+                if (!netif_queue_stopped(priv->net_dev))
+                        netif_stop_queue(priv->net_dev);
+        }
+
+        DPRINTK(4, "skb_buff length=%d\n", packet_len);
+        pp = (struct hostif_data_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp) + 6 + packet_len + 8),
+                    KS_WLAN_MEM_FLAG);
+
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                dev_kfree_skb(packet);
+                return -2;
+        }
+
+        p = (unsigned char *)pp->data;
+
+        buffer = packet->data;
+        length = packet->len;
+
+        /* packet check */
+        eth = (struct ethhdr *)packet->data;
+        if (memcmp(&priv->eth_addr[0], eth->h_source, ETH_ALEN)) {
+                DPRINTK(1, "invalid mac address !!\n");
+                DPRINTK(1, "ethernet->h_source=%02X:%02X:%02X:%02X:%02X:%02X\n",
+                        eth->h_source[0], eth->h_source[1], eth->h_source[2],
+                        eth->h_source[3], eth->h_source[4], eth->h_source[5]);
+                return -3;
+        }
+
+        /* MAC address copy */
+        memcpy(p, buffer, 12);  /* DST/SRC MAC address */
+        p += 12;
+        buffer += 12;
+        length -= 12;
+        /* EtherType/Length check */
+        if (*(buffer + 1) + (*buffer << 8) > 1500) {
+                /* ProtocolEAP = *(buffer+1) + (*buffer << 8); */
+                /* DPRINTK(2, "Send [SNAP]Type %x\n",ProtocolEAP); */
+                /* SAP/CTL/OUI(6 byte) add */
+                *p++ = 0xAA;    /* DSAP */
+                *p++ = 0xAA;    /* SSAP */
+                *p++ = 0x03;    /* CTL */
+                *p++ = 0x00;    /* OUI ("000000") */
+                *p++ = 0x00;    /* OUI ("000000") */
+                *p++ = 0x00;    /* OUI ("000000") */
+                packet_len += 6;
+        } else {
+                DPRINTK(4, "DIX\n");
+                /* Length(2 byte) delete */
+                buffer += 2;
+                length -= 2;
+                packet_len -= 2;
+        }
+
+        /* pp->data copy */
+        memcpy(p, buffer, length);
+
+        p += length;
+
+        /* for WPA */
+        eth_hdr = (struct ether_hdr *)&pp->data[0];
+        eth_proto = ntohs(eth_hdr->h_proto);
+
+        /* for MIC FAILUER REPORT check */
+        if (eth_proto == ETHER_PROTOCOL_TYPE_EAP
+            && priv->wpa.mic_failure.failure > 0) {
+                aa1x_hdr = (struct ieee802_1x_hdr *)(eth_hdr + 1);
+                if (aa1x_hdr->type == IEEE802_1X_TYPE_EAPOL_KEY) {
+                        eap_key = (struct wpa_eapol_key *)(aa1x_hdr + 1);
+                        keyinfo = ntohs(eap_key->key_info);
+                }
+        }
+
+        if (priv->wpa.rsn_enabled && priv->wpa.key[0].key_len) {
+                if (eth_proto == ETHER_PROTOCOL_TYPE_EAP
+                    && !(priv->wpa.key[1].key_len)
+                    && !(priv->wpa.key[2].key_len)
+                    && !(priv->wpa.key[3].key_len)) {
+                        pp->auth_type = cpu_to_le16((uint16_t) TYPE_AUTH);      /* no encryption */
+                } else {
+                        if (priv->wpa.pairwise_suite == IW_AUTH_CIPHER_TKIP) {
+                                MichaelMICFunction(&michel_mic, (uint8_t *) priv->wpa.key[0].tx_mic_key, (uint8_t *) & pp->data[0], (int)packet_len, (uint8_t) 0,       /* priority */
+                                                   (uint8_t *) michel_mic.
+                                                   Result);
+                                memcpy(p, michel_mic.Result, 8);
+                                length += 8;
+                                packet_len += 8;
+                                p += 8;
+                                pp->auth_type =
+                                    cpu_to_le16((uint16_t) TYPE_DATA);
+
+                        } else if (priv->wpa.pairwise_suite ==
+                                   IW_AUTH_CIPHER_CCMP) {
+                                pp->auth_type =
+                                    cpu_to_le16((uint16_t) TYPE_DATA);
+                        }
+                }
+        } else {
+                if (eth_proto == ETHER_PROTOCOL_TYPE_EAP)
+                        pp->auth_type = cpu_to_le16((uint16_t) TYPE_AUTH);
+                else
+                        pp->auth_type = cpu_to_le16((uint16_t) TYPE_DATA);
+        }
+
+        /* header value set */
+        pp->header.size =
+            cpu_to_le16((uint16_t)
+                        (sizeof(*pp) - sizeof(pp->header.size) + packet_len));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_DATA_REQ);
+
+        /* tx request */
+        result =
+            ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp) + packet_len),
+                          (void *)send_packet_complete, (void *)priv,
+                          (void *)packet);
+
+        /* MIC FAILUER REPORT check */
+        if (eth_proto == ETHER_PROTOCOL_TYPE_EAP
+            && priv->wpa.mic_failure.failure > 0) {
+                if (keyinfo & WPA_KEY_INFO_ERROR
+                    && keyinfo & WPA_KEY_INFO_REQUEST) {
+                        DPRINTK(3, " MIC ERROR Report SET : %04X\n", keyinfo);
+                        hostif_sme_enqueue(priv, SME_MIC_FAILURE_REQUEST);
+                }
+                if (priv->wpa.mic_failure.failure == 2)
+                        priv->wpa.mic_failure.stop = 1;
+        }
+
+        return result;
+}
+
+#define ps_confirm_wait_inc(priv)  do{if(atomic_read(&priv->psstatus.status) > PS_ACTIVE_SET){ \
+                                                  atomic_inc(&priv->psstatus.confirm_wait); \
+                                                  /* atomic_set(&priv->psstatus.status, PS_CONF_WAIT);*/ \
+                                      } }while(0)
+
+static
+void hostif_mib_get_request(struct ks_wlan_private *priv,
+                            unsigned long mib_attribute)
+{
+        struct hostif_mib_get_request_t *pp;
+
+        DPRINTK(3, "\n");
+
+        /* make primitive */
+        pp = (struct hostif_mib_get_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_MIB_GET_REQ);
+        pp->mib_attribute = cpu_to_le32((uint32_t) mib_attribute);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+static
+void hostif_mib_set_request(struct ks_wlan_private *priv,
+                            unsigned long mib_attribute, unsigned short size,
+                            unsigned short type, void *vp)
+{
+        struct hostif_mib_set_request_t *pp;
+
+        DPRINTK(3, "\n");
+
+        if (priv->dev_state < DEVICE_STATE_BOOT) {
+                DPRINTK(3, "DeviceRemove\n");
+                return;
+        }
+
+        /* make primitive */
+        pp = (struct hostif_mib_set_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp) + size), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+
+        pp->header.size =
+            cpu_to_le16((uint16_t)
+                        (sizeof(*pp) - sizeof(pp->header.size) + size));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_MIB_SET_REQ);
+        pp->mib_attribute = cpu_to_le32((uint32_t) mib_attribute);
+        pp->mib_value.size = cpu_to_le16((uint16_t) size);
+        pp->mib_value.type = cpu_to_le16((uint16_t) type);
+        memcpy(&pp->mib_value.body, vp, size);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp) + size), NULL, NULL,
+                      NULL);
+}
+
+static
+void hostif_start_request(struct ks_wlan_private *priv, unsigned char mode)
+{
+        struct hostif_start_request_t *pp;
+
+        DPRINTK(3, "\n");
+
+        /* make primitive */
+        pp = (struct hostif_start_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_START_REQ);
+        pp->mode = cpu_to_le16((uint16_t) mode);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+
+        priv->aplist.size = 0;
+        priv->scan_ind_count = 0;
+}
+
+static
+void hostif_ps_adhoc_set_request(struct ks_wlan_private *priv)
+{
+        struct hostif_ps_adhoc_set_request_t *pp;
+        uint16_t capability;
+
+        DPRINTK(3, "\n");
+
+        /* make primitive */
+        pp = (struct hostif_ps_adhoc_set_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        memset(pp, 0, sizeof(*pp));
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_PS_ADH_SET_REQ);
+        pp->phy_type = cpu_to_le16((uint16_t) (priv->reg.phy_type));
+        pp->cts_mode = cpu_to_le16((uint16_t) (priv->reg.cts_mode));
+        pp->scan_type = cpu_to_le16((uint16_t) (priv->reg.scan_type));
+        pp->channel = cpu_to_le16((uint16_t) (priv->reg.channel));
+        pp->rate_set.size = priv->reg.rate_set.size;
+        memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
+               priv->reg.rate_set.size);
+
+        capability = 0x0000;
+        if (priv->reg.preamble == SHORT_PREAMBLE) {
+                /* short preamble */
+                capability |= BSS_CAP_SHORT_PREAMBLE;
+        }
+        capability &= ~(BSS_CAP_PBCC);  /* pbcc not support */
+        if (priv->reg.phy_type != D_11B_ONLY_MODE) {
+                capability |= BSS_CAP_SHORT_SLOT_TIME;  /* ShortSlotTime support */
+                capability &= ~(BSS_CAP_DSSS_OFDM);     /* DSSS OFDM */
+        }
+        pp->capability = cpu_to_le16((uint16_t) capability);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+static
+void hostif_infrastructure_set_request(struct ks_wlan_private *priv)
+{
+        struct hostif_infrastructure_set_request_t *pp;
+        uint16_t capability;
+
+        DPRINTK(3, "ssid.size=%d \n", priv->reg.ssid.size);
+
+        /* make primitive */
+        pp = (struct hostif_infrastructure_set_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_INFRA_SET_REQ);
+        pp->phy_type = cpu_to_le16((uint16_t) (priv->reg.phy_type));
+        pp->cts_mode = cpu_to_le16((uint16_t) (priv->reg.cts_mode));
+        pp->scan_type = cpu_to_le16((uint16_t) (priv->reg.scan_type));
+
+        pp->rate_set.size = priv->reg.rate_set.size;
+        memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
+               priv->reg.rate_set.size);
+        pp->ssid.size = priv->reg.ssid.size;
+        memcpy(&pp->ssid.body[0], &priv->reg.ssid.body[0], priv->reg.ssid.size);
+
+        capability = 0x0000;
+        if (priv->reg.preamble == SHORT_PREAMBLE) {
+                /* short preamble */
+                capability |= BSS_CAP_SHORT_PREAMBLE;
+        }
+        capability &= ~(BSS_CAP_PBCC);  /* pbcc not support */
+        if (priv->reg.phy_type != D_11B_ONLY_MODE) {
+                capability |= BSS_CAP_SHORT_SLOT_TIME;  /* ShortSlotTime support */
+                capability &= ~(BSS_CAP_DSSS_OFDM);     /* DSSS OFDM not support */
+        }
+        pp->capability = cpu_to_le16((uint16_t) capability);
+        pp->beacon_lost_count =
+            cpu_to_le16((uint16_t) (priv->reg.beacon_lost_count));
+        pp->auth_type = cpu_to_le16((uint16_t) (priv->reg.authenticate_type));
+
+        pp->channel_list.body[0] = 1;
+        pp->channel_list.body[1] = 8;
+        pp->channel_list.body[2] = 2;
+        pp->channel_list.body[3] = 9;
+        pp->channel_list.body[4] = 3;
+        pp->channel_list.body[5] = 10;
+        pp->channel_list.body[6] = 4;
+        pp->channel_list.body[7] = 11;
+        pp->channel_list.body[8] = 5;
+        pp->channel_list.body[9] = 12;
+        pp->channel_list.body[10] = 6;
+        pp->channel_list.body[11] = 13;
+        pp->channel_list.body[12] = 7;
+        if (priv->reg.phy_type == D_11G_ONLY_MODE) {
+                pp->channel_list.size = 13;
+        } else {
+                pp->channel_list.body[13] = 14;
+                pp->channel_list.size = 14;
+        }
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+void hostif_infrastructure_set2_request(struct ks_wlan_private *priv)
+{
+        struct hostif_infrastructure_set2_request_t *pp;
+        uint16_t capability;
+
+        DPRINTK(2, "ssid.size=%d \n", priv->reg.ssid.size);
+
+        /* make primitive */
+        pp = (struct hostif_infrastructure_set2_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_INFRA_SET2_REQ);
+        pp->phy_type = cpu_to_le16((uint16_t) (priv->reg.phy_type));
+        pp->cts_mode = cpu_to_le16((uint16_t) (priv->reg.cts_mode));
+        pp->scan_type = cpu_to_le16((uint16_t) (priv->reg.scan_type));
+
+        pp->rate_set.size = priv->reg.rate_set.size;
+        memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
+               priv->reg.rate_set.size);
+        pp->ssid.size = priv->reg.ssid.size;
+        memcpy(&pp->ssid.body[0], &priv->reg.ssid.body[0], priv->reg.ssid.size);
+
+        capability = 0x0000;
+        if (priv->reg.preamble == SHORT_PREAMBLE) {
+                /* short preamble */
+                capability |= BSS_CAP_SHORT_PREAMBLE;
+        }
+        capability &= ~(BSS_CAP_PBCC);  /* pbcc not support */
+        if (priv->reg.phy_type != D_11B_ONLY_MODE) {
+                capability |= BSS_CAP_SHORT_SLOT_TIME;  /* ShortSlotTime support */
+                capability &= ~(BSS_CAP_DSSS_OFDM);     /* DSSS OFDM not support */
+        }
+        pp->capability = cpu_to_le16((uint16_t) capability);
+        pp->beacon_lost_count =
+            cpu_to_le16((uint16_t) (priv->reg.beacon_lost_count));
+        pp->auth_type = cpu_to_le16((uint16_t) (priv->reg.authenticate_type));
+
+        pp->channel_list.body[0] = 1;
+        pp->channel_list.body[1] = 8;
+        pp->channel_list.body[2] = 2;
+        pp->channel_list.body[3] = 9;
+        pp->channel_list.body[4] = 3;
+        pp->channel_list.body[5] = 10;
+        pp->channel_list.body[6] = 4;
+        pp->channel_list.body[7] = 11;
+        pp->channel_list.body[8] = 5;
+        pp->channel_list.body[9] = 12;
+        pp->channel_list.body[10] = 6;
+        pp->channel_list.body[11] = 13;
+        pp->channel_list.body[12] = 7;
+        if (priv->reg.phy_type == D_11G_ONLY_MODE) {
+                pp->channel_list.size = 13;
+        } else {
+                pp->channel_list.body[13] = 14;
+                pp->channel_list.size = 14;
+        }
+
+        memcpy(pp->bssid, priv->reg.bssid, ETH_ALEN);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+static
+void hostif_adhoc_set_request(struct ks_wlan_private *priv)
+{
+        struct hostif_adhoc_set_request_t *pp;
+        uint16_t capability;
+
+        DPRINTK(3, "\n");
+
+        /* make primitive */
+        pp = (struct hostif_adhoc_set_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        memset(pp, 0, sizeof(*pp));
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_ADH_SET_REQ);
+        pp->phy_type = cpu_to_le16((uint16_t) (priv->reg.phy_type));
+        pp->cts_mode = cpu_to_le16((uint16_t) (priv->reg.cts_mode));
+        pp->scan_type = cpu_to_le16((uint16_t) (priv->reg.scan_type));
+        pp->channel = cpu_to_le16((uint16_t) (priv->reg.channel));
+        pp->rate_set.size = priv->reg.rate_set.size;
+        memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
+               priv->reg.rate_set.size);
+        pp->ssid.size = priv->reg.ssid.size;
+        memcpy(&pp->ssid.body[0], &priv->reg.ssid.body[0], priv->reg.ssid.size);
+
+        capability = 0x0000;
+        if (priv->reg.preamble == SHORT_PREAMBLE) {
+                /* short preamble */
+                capability |= BSS_CAP_SHORT_PREAMBLE;
+        }
+        capability &= ~(BSS_CAP_PBCC);  /* pbcc not support */
+        if (priv->reg.phy_type != D_11B_ONLY_MODE) {
+                capability |= BSS_CAP_SHORT_SLOT_TIME;  /* ShortSlotTime support */
+                capability &= ~(BSS_CAP_DSSS_OFDM);     /* DSSS OFDM not support */
+        }
+        pp->capability = cpu_to_le16((uint16_t) capability);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+static
+void hostif_adhoc_set2_request(struct ks_wlan_private *priv)
+{
+        struct hostif_adhoc_set2_request_t *pp;
+        uint16_t capability;
+
+        DPRINTK(3, "\n");
+
+        /* make primitive */
+        pp = (struct hostif_adhoc_set2_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        memset(pp, 0, sizeof(*pp));
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_ADH_SET_REQ);
+        pp->phy_type = cpu_to_le16((uint16_t) (priv->reg.phy_type));
+        pp->cts_mode = cpu_to_le16((uint16_t) (priv->reg.cts_mode));
+        pp->scan_type = cpu_to_le16((uint16_t) (priv->reg.scan_type));
+        pp->rate_set.size = priv->reg.rate_set.size;
+        memcpy(&pp->rate_set.body[0], &priv->reg.rate_set.body[0],
+               priv->reg.rate_set.size);
+        pp->ssid.size = priv->reg.ssid.size;
+        memcpy(&pp->ssid.body[0], &priv->reg.ssid.body[0], priv->reg.ssid.size);
+
+        capability = 0x0000;
+        if (priv->reg.preamble == SHORT_PREAMBLE) {
+                /* short preamble */
+                capability |= BSS_CAP_SHORT_PREAMBLE;
+        }
+        capability &= ~(BSS_CAP_PBCC);  /* pbcc not support */
+        if (priv->reg.phy_type != D_11B_ONLY_MODE) {
+                capability |= BSS_CAP_SHORT_SLOT_TIME;  /* ShortSlotTime support */
+                capability &= ~(BSS_CAP_DSSS_OFDM);     /* DSSS OFDM not support */
+        }
+        pp->capability = cpu_to_le16((uint16_t) capability);
+
+        pp->channel_list.body[0] = priv->reg.channel;
+        pp->channel_list.size = 1;
+        memcpy(pp->bssid, priv->reg.bssid, ETH_ALEN);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+static
+void hostif_stop_request(struct ks_wlan_private *priv)
+{
+        struct hostif_stop_request_t *pp;
+
+        DPRINTK(3, "\n");
+
+        /* make primitive */
+        pp = (struct hostif_stop_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_STOP_REQ);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+static
+void hostif_phy_information_request(struct ks_wlan_private *priv)
+{
+        struct hostif_phy_information_request_t *pp;
+
+        DPRINTK(3, "\n");
+
+        /* make primitive */
+        pp = (struct hostif_phy_information_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_PHY_INFO_REQ);
+        if (priv->reg.phy_info_timer) {
+                pp->type = cpu_to_le16((uint16_t) TIME_TYPE);
+                pp->time = cpu_to_le16((uint16_t) (priv->reg.phy_info_timer));
+        } else {
+                pp->type = cpu_to_le16((uint16_t) NORMAL_TYPE);
+                pp->time = cpu_to_le16((uint16_t) 0);
+        }
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+static
+void hostif_power_mngmt_request(struct ks_wlan_private *priv,
+                                unsigned long mode, unsigned long wake_up,
+                                unsigned long receiveDTIMs)
+{
+        struct hostif_power_mngmt_request_t *pp;
+
+        DPRINTK(3, "mode=%lu wake_up=%lu receiveDTIMs=%lu\n", mode, wake_up,
+                receiveDTIMs);
+        /* make primitive */
+        pp = (struct hostif_power_mngmt_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_POWERMGT_REQ);
+        pp->mode = cpu_to_le32((uint32_t) mode);
+        pp->wake_up = cpu_to_le32((uint32_t) wake_up);
+        pp->receiveDTIMs = cpu_to_le32((uint32_t) receiveDTIMs);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+static
+void hostif_sleep_request(struct ks_wlan_private *priv, unsigned long mode)
+{
+        struct hostif_sleep_request_t *pp;
+
+        DPRINTK(3, "mode=%lu \n", mode);
+
+        if (mode == SLP_SLEEP) {
+                /* make primitive */
+                pp = (struct hostif_sleep_request_t *)
+                    kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+                if (pp == NULL) {
+                        DPRINTK(3, "allocate memory failed..\n");
+                        return;
+                }
+                pp->header.size =
+                    cpu_to_le16((uint16_t)
+                                (sizeof(*pp) - sizeof(pp->header.size)));
+                pp->header.event = cpu_to_le16((uint16_t) HIF_SLEEP_REQ);
+
+                /* send to device request */
+                ps_confirm_wait_inc(priv);
+                ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL,
+                              NULL);
+        } else if (mode == SLP_ACTIVE) {
+                atomic_set(&priv->sleepstatus.wakeup_request, 1);
+                queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,
+                                   &priv->ks_wlan_hw.rw_wq, 1);
+        } else {
+                DPRINTK(3, "invalid mode %ld \n", mode);
+                return;
+        }
+}
+
+static
+void hostif_bss_scan_request(struct ks_wlan_private *priv,
+                             unsigned long scan_type, uint8_t * scan_ssid,
+                             uint8_t scan_ssid_len)
+{
+        struct hostif_bss_scan_request_t *pp;
+
+        DPRINTK(2, "\n");
+        /* make primitive */
+        pp = (struct hostif_bss_scan_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_SCAN_REQ);
+        pp->scan_type = scan_type;
+
+        pp->ch_time_min = cpu_to_le32((uint32_t) 110);  /* default value */
+        pp->ch_time_max = cpu_to_le32((uint32_t) 130);  /* default value */
+        pp->channel_list.body[0] = 1;
+        pp->channel_list.body[1] = 8;
+        pp->channel_list.body[2] = 2;
+        pp->channel_list.body[3] = 9;
+        pp->channel_list.body[4] = 3;
+        pp->channel_list.body[5] = 10;
+        pp->channel_list.body[6] = 4;
+        pp->channel_list.body[7] = 11;
+        pp->channel_list.body[8] = 5;
+        pp->channel_list.body[9] = 12;
+        pp->channel_list.body[10] = 6;
+        pp->channel_list.body[11] = 13;
+        pp->channel_list.body[12] = 7;
+        if (priv->reg.phy_type == D_11G_ONLY_MODE) {
+                pp->channel_list.size = 13;
+        } else {
+                pp->channel_list.body[13] = 14;
+                pp->channel_list.size = 14;
+        }
+        pp->ssid.size = 0;
+
+        /* specified SSID SCAN */
+        if (scan_ssid_len > 0 && scan_ssid_len <= 32) {
+                pp->ssid.size = scan_ssid_len;
+                memcpy(&pp->ssid.body[0], scan_ssid, scan_ssid_len);
+        }
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+
+        priv->aplist.size = 0;
+        priv->scan_ind_count = 0;
+}
+
+static
+void hostif_mic_failure_request(struct ks_wlan_private *priv,
+                                unsigned short failure_count,
+                                unsigned short timer)
+{
+        struct hostif_mic_failure_request_t *pp;
+
+        DPRINTK(3, "count=%d :: timer=%d\n", failure_count, timer);
+        /* make primitive */
+        pp = (struct hostif_mic_failure_request_t *)
+            kmalloc(hif_align_size(sizeof(*pp)), KS_WLAN_MEM_FLAG);
+        if (pp == NULL) {
+                DPRINTK(3, "allocate memory failed..\n");
+                return;
+        }
+        pp->header.size =
+            cpu_to_le16((uint16_t) (sizeof(*pp) - sizeof(pp->header.size)));
+        pp->header.event = cpu_to_le16((uint16_t) HIF_MIC_FAILURE_REQ);
+        pp->failure_count = cpu_to_le16((uint16_t) failure_count);
+        pp->timer = cpu_to_le16((uint16_t) timer);
+
+        /* send to device request */
+        ps_confirm_wait_inc(priv);
+        ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp)), NULL, NULL, NULL);
+}
+
+/* Device I/O Recieve indicate */
+static void devio_rec_ind(struct ks_wlan_private *priv, unsigned char *p,
+                          unsigned int size)
+{
+        if (priv->device_open_status) {
+                spin_lock(&priv->dev_read_lock);        /* request spin lock */
+                priv->dev_data[atomic_read(&priv->rec_count)] = p;
+                priv->dev_size[atomic_read(&priv->rec_count)] = size;
+
+                if (atomic_read(&priv->event_count) != DEVICE_STOCK_COUNT) {
+                        /* rx event count inc */
+                        atomic_inc(&priv->event_count);
+                }
+                atomic_inc(&priv->rec_count);
+                if (atomic_read(&priv->rec_count) == DEVICE_STOCK_COUNT)
+                        atomic_set(&priv->rec_count, 0);
+
+                wake_up_interruptible_all(&priv->devread_wait);
+
+                /* release spin lock */
+                spin_unlock(&priv->dev_read_lock);
+        }
+}
+
+void hostif_receive(struct ks_wlan_private *priv, unsigned char *p,
+                    unsigned int size)
+{
+        DPRINTK(4, "\n");
+
+        devio_rec_ind(priv, p, size);
+
+        priv->rxp = p;
+        priv->rx_size = size;
+
+        if (get_WORD(priv) == priv->rx_size) {  /* length check !! */
+                hostif_event_check(priv);       /* event check */
+        }
+}
+
+static
+void hostif_sme_set_wep(struct ks_wlan_private *priv, int type)
+{
+        uint32_t val;
+        switch (type) {
+        case SME_WEP_INDEX_REQUEST:
+                val = cpu_to_le32((uint32_t) (priv->reg.wep_index));
+                hostif_mib_set_request(priv, DOT11_WEP_DEFAULT_KEY_ID,
+                                       sizeof(val), MIB_VALUE_TYPE_INT, &val);
+                break;
+        case SME_WEP_KEY1_REQUEST:
+                if (!priv->wpa.wpa_enabled)
+                        hostif_mib_set_request(priv,
+                                               DOT11_WEP_DEFAULT_KEY_VALUE1,
+                                               priv->reg.wep_key[0].size,
+                                               MIB_VALUE_TYPE_OSTRING,
+                                               &priv->reg.wep_key[0].val[0]);
+                break;
+        case SME_WEP_KEY2_REQUEST:
+                if (!priv->wpa.wpa_enabled)
+                        hostif_mib_set_request(priv,
+                                               DOT11_WEP_DEFAULT_KEY_VALUE2,
+                                               priv->reg.wep_key[1].size,
+                                               MIB_VALUE_TYPE_OSTRING,
+                                               &priv->reg.wep_key[1].val[0]);
+                break;
+        case SME_WEP_KEY3_REQUEST:
+                if (!priv->wpa.wpa_enabled)
+                        hostif_mib_set_request(priv,
+                                               DOT11_WEP_DEFAULT_KEY_VALUE3,
+                                               priv->reg.wep_key[2].size,
+                                               MIB_VALUE_TYPE_OSTRING,
+                                               &priv->reg.wep_key[2].val[0]);
+                break;
+        case SME_WEP_KEY4_REQUEST:
+                if (!priv->wpa.wpa_enabled)
+                        hostif_mib_set_request(priv,
+                                               DOT11_WEP_DEFAULT_KEY_VALUE4,
+                                               priv->reg.wep_key[3].size,
+                                               MIB_VALUE_TYPE_OSTRING,
+                                               &priv->reg.wep_key[3].val[0]);
+                break;
+        case SME_WEP_FLAG_REQUEST:
+                val = cpu_to_le32((uint32_t) (priv->reg.privacy_invoked));
+                hostif_mib_set_request(priv, DOT11_PRIVACY_INVOKED,
+                                       sizeof(val), MIB_VALUE_TYPE_BOOL, &val);
+                break;
+        }
+
+        return;
+}
+
+struct wpa_suite_t {
+        unsigned short size;
+        unsigned char suite[4][CIPHER_ID_LEN];
+} __attribute__ ((packed));
+
+struct rsn_mode_t {
+        uint32_t rsn_mode;
+        uint16_t rsn_capability;
+} __attribute__ ((packed));
+
+static
+void hostif_sme_set_rsn(struct ks_wlan_private *priv, int type)
+{
+        struct wpa_suite_t wpa_suite;
+        struct rsn_mode_t rsn_mode;
+        uint32_t val;
+
+        memset(&wpa_suite, 0, sizeof(wpa_suite));
+
+        switch (type) {
+        case SME_RSN_UCAST_REQUEST:
+                wpa_suite.size = cpu_to_le16((uint16_t) 1);
+                switch (priv->wpa.pairwise_suite) {
+                case IW_AUTH_CIPHER_NONE:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_NONE, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_NONE, CIPHER_ID_LEN);
+                        break;
+                case IW_AUTH_CIPHER_WEP40:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_WEP40, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_WEP40, CIPHER_ID_LEN);
+                        break;
+                case IW_AUTH_CIPHER_TKIP:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_TKIP, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_TKIP, CIPHER_ID_LEN);
+                        break;
+                case IW_AUTH_CIPHER_CCMP:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_CCMP, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_CCMP, CIPHER_ID_LEN);
+                        break;
+                case IW_AUTH_CIPHER_WEP104:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_WEP104, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_WEP104, CIPHER_ID_LEN);
+                        break;
+                }
+
+                hostif_mib_set_request(priv, DOT11_RSN_CONFIG_UNICAST_CIPHER,
+                                       sizeof(wpa_suite.size) +
+                                       CIPHER_ID_LEN * wpa_suite.size,
+                                       MIB_VALUE_TYPE_OSTRING, &wpa_suite);
+                break;
+        case SME_RSN_MCAST_REQUEST:
+                switch (priv->wpa.group_suite) {
+                case IW_AUTH_CIPHER_NONE:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_NONE, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_NONE, CIPHER_ID_LEN);
+                        break;
+                case IW_AUTH_CIPHER_WEP40:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_WEP40, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_WEP40, CIPHER_ID_LEN);
+                        break;
+                case IW_AUTH_CIPHER_TKIP:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_TKIP, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_TKIP, CIPHER_ID_LEN);
+                        break;
+                case IW_AUTH_CIPHER_CCMP:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_CCMP, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_CCMP, CIPHER_ID_LEN);
+                        break;
+                case IW_AUTH_CIPHER_WEP104:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA2_WEP104, CIPHER_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       CIPHER_ID_WPA_WEP104, CIPHER_ID_LEN);
+                        break;
+                }
+
+                hostif_mib_set_request(priv, DOT11_RSN_CONFIG_MULTICAST_CIPHER,
+                                       CIPHER_ID_LEN, MIB_VALUE_TYPE_OSTRING,
+                                       &wpa_suite.suite[0][0]);
+                break;
+        case SME_RSN_AUTH_REQUEST:
+                wpa_suite.size = cpu_to_le16((uint16_t) 1);
+                switch (priv->wpa.key_mgmt_suite) {
+                case IW_AUTH_KEY_MGMT_802_1X:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       KEY_MGMT_ID_WPA2_1X, KEY_MGMT_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       KEY_MGMT_ID_WPA_1X, KEY_MGMT_ID_LEN);
+                        break;
+                case IW_AUTH_KEY_MGMT_PSK:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       KEY_MGMT_ID_WPA2_PSK, KEY_MGMT_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       KEY_MGMT_ID_WPA_PSK, KEY_MGMT_ID_LEN);
+                        break;
+                case 0:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       KEY_MGMT_ID_WPA2_NONE, KEY_MGMT_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       KEY_MGMT_ID_WPA_NONE, KEY_MGMT_ID_LEN);
+                        break;
+                case 4:
+                        if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)
+                                memcpy(&wpa_suite.suite[0][0],
+                                       KEY_MGMT_ID_WPA2_WPANONE,
+                                       KEY_MGMT_ID_LEN);
+                        else
+                                memcpy(&wpa_suite.suite[0][0],
+                                       KEY_MGMT_ID_WPA_WPANONE,
+                                       KEY_MGMT_ID_LEN);
+                        break;
+                }
+
+                hostif_mib_set_request(priv, DOT11_RSN_CONFIG_AUTH_SUITE,
+                                       sizeof(wpa_suite.size) +
+                                       KEY_MGMT_ID_LEN * wpa_suite.size,
+                                       MIB_VALUE_TYPE_OSTRING, &wpa_suite);
+                break;
+        case SME_RSN_ENABLED_REQUEST:
+                val = cpu_to_le32((uint32_t) (priv->wpa.rsn_enabled));
+                hostif_mib_set_request(priv, DOT11_RSN_ENABLED,
+                                       sizeof(val), MIB_VALUE_TYPE_BOOL, &val);
+                break;
+        case SME_RSN_MODE_REQUEST:
+                if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) {
+                        rsn_mode.rsn_mode =
+                            cpu_to_le32((uint32_t) RSN_MODE_WPA2);
+                        rsn_mode.rsn_capability = cpu_to_le16((uint16_t) 0);
+                } else if (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA) {
+                        rsn_mode.rsn_mode =
+                            cpu_to_le32((uint32_t) RSN_MODE_WPA);
+                        rsn_mode.rsn_capability = cpu_to_le16((uint16_t) 0);
+                } else {
+                        rsn_mode.rsn_mode =
+                            cpu_to_le32((uint32_t) RSN_MODE_NONE);
+                        rsn_mode.rsn_capability = cpu_to_le16((uint16_t) 0);
+                }
+                hostif_mib_set_request(priv, LOCAL_RSN_MODE, sizeof(rsn_mode),
+                                       MIB_VALUE_TYPE_OSTRING, &rsn_mode);
+                break;
+
+        }
+        return;
+}
+
+static
+void hostif_sme_mode_setup(struct ks_wlan_private *priv)
+{
+        unsigned char rate_size;
+        unsigned char rate_octet[RATE_SET_MAX_SIZE];
+        int i = 0;
+
+        /* rate setting if rate segging is auto for changing phy_type (#94) */
+        if (priv->reg.tx_rate == TX_RATE_FULL_AUTO) {
+                if (priv->reg.phy_type == D_11B_ONLY_MODE) {
+                        priv->reg.rate_set.body[3] = TX_RATE_11M;
+                        priv->reg.rate_set.body[2] = TX_RATE_5M;
+                        priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
+                        priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
+                        priv->reg.rate_set.size = 4;
+                } else {        /* D_11G_ONLY_MODE or D_11BG_COMPATIBLE_MODE */
+                        priv->reg.rate_set.body[11] = TX_RATE_54M;
+                        priv->reg.rate_set.body[10] = TX_RATE_48M;
+                        priv->reg.rate_set.body[9] = TX_RATE_36M;
+                        priv->reg.rate_set.body[8] = TX_RATE_18M;
+                        priv->reg.rate_set.body[7] = TX_RATE_9M;
+                        priv->reg.rate_set.body[6] = TX_RATE_24M | BASIC_RATE;
+                        priv->reg.rate_set.body[5] = TX_RATE_12M | BASIC_RATE;
+                        priv->reg.rate_set.body[4] = TX_RATE_6M | BASIC_RATE;
+                        priv->reg.rate_set.body[3] = TX_RATE_11M | BASIC_RATE;
+                        priv->reg.rate_set.body[2] = TX_RATE_5M | BASIC_RATE;
+                        priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
+                        priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
+                        priv->reg.rate_set.size = 12;
+                }
+        }
+
+        /* rate mask by phy setting */
+        if (priv->reg.phy_type == D_11B_ONLY_MODE) {
+                for (i = 0; i < priv->reg.rate_set.size; i++) {
+                        if (IS_11B_RATE(priv->reg.rate_set.body[i])) {
+                                if ((priv->reg.rate_set.body[i] & RATE_MASK) >=
+                                    TX_RATE_5M)
+                                        rate_octet[i] =
+                                            priv->reg.rate_set.
+                                            body[i] & RATE_MASK;
+                                else
+                                        rate_octet[i] =
+                                            priv->reg.rate_set.body[i];
+                        } else
+                                break;
+                }
+
+        } else {        /* D_11G_ONLY_MODE or D_11BG_COMPATIBLE_MODE */
+                for (i = 0; i < priv->reg.rate_set.size; i++) {
+                        if (IS_11BG_RATE(priv->reg.rate_set.body[i])) {
+                                if (IS_OFDM_EXT_RATE
+                                    (priv->reg.rate_set.body[i]))
+                                        rate_octet[i] =
+                                            priv->reg.rate_set.
+                                            body[i] & RATE_MASK;
+                                else
+                                        rate_octet[i] =
+                                            priv->reg.rate_set.body[i];
+                        } else
+                                break;
+                }
+        }
+        rate_size = i;
+        if (rate_size == 0) {
+                if (priv->reg.phy_type == D_11G_ONLY_MODE)
+                        rate_octet[0] = TX_RATE_6M | BASIC_RATE;
+                else
+                        rate_octet[0] = TX_RATE_2M | BASIC_RATE;
+                rate_size = 1;
+        }
+
+        /* rate set update */
+        priv->reg.rate_set.size = rate_size;
+        memcpy(&priv->reg.rate_set.body[0], &rate_octet[0], rate_size);
+
+        switch (priv->reg.operation_mode) {
+        case MODE_PSEUDO_ADHOC:
+                /* Pseudo Ad-Hoc mode */
+                hostif_ps_adhoc_set_request(priv);
+                break;
+        case MODE_INFRASTRUCTURE:
+                /* Infrastructure mode */
+                if (!is_valid_ether_addr((u8 *) priv->reg.bssid)) {
+                        hostif_infrastructure_set_request(priv);
+                } else {
+                        hostif_infrastructure_set2_request(priv);
+                        DPRINTK(2,
+                                "Infra bssid = %02x:%02x:%02x:%02x:%02x:%02x\n",
+                                priv->reg.bssid[0], priv->reg.bssid[1],
+                                priv->reg.bssid[2], priv->reg.bssid[3],
+                                priv->reg.bssid[4], priv->reg.bssid[5]);
+                }
+                break;
+        case MODE_ADHOC:
+                /* IEEE802.11 Ad-Hoc mode */
+                if (!is_valid_ether_addr((u8 *) priv->reg.bssid)) {
+                        hostif_adhoc_set_request(priv);
+                } else {
+                        hostif_adhoc_set2_request(priv);
+                        DPRINTK(2,
+                                "Adhoc bssid = %02x:%02x:%02x:%02x:%02x:%02x\n",
+                                priv->reg.bssid[0], priv->reg.bssid[1],
+                                priv->reg.bssid[2], priv->reg.bssid[3],
+                                priv->reg.bssid[4], priv->reg.bssid[5]);
+                }
+                break;
+        default:
+                break;
+        }
+
+        return;
+}
+
+static
+void hostif_sme_multicast_set(struct ks_wlan_private *priv)
+{
+
+        struct net_device *dev = priv->net_dev;
+        int mc_count;
+        struct netdev_hw_addr *ha;
+        char set_address[NIC_MAX_MCAST_LIST * ETH_ALEN];
+        unsigned long filter_type;
+        int i = 0;
+
+        DPRINTK(3, "\n");
+
+        spin_lock(&priv->multicast_spin);
+
+        memset(set_address, 0, NIC_MAX_MCAST_LIST * ETH_ALEN);
+
+        if (dev->flags & IFF_PROMISC) {
+                filter_type = cpu_to_le32((uint32_t) MCAST_FILTER_PROMISC);
+                hostif_mib_set_request(priv, LOCAL_MULTICAST_FILTER,
+                                       sizeof(filter_type), MIB_VALUE_TYPE_BOOL,
+                                       &filter_type);
+        } else if ((netdev_mc_count(dev) > NIC_MAX_MCAST_LIST)
+                   || (dev->flags & IFF_ALLMULTI)) {
+                filter_type = cpu_to_le32((uint32_t) MCAST_FILTER_MCASTALL);
+                hostif_mib_set_request(priv, LOCAL_MULTICAST_FILTER,
+                                       sizeof(filter_type), MIB_VALUE_TYPE_BOOL,
+                                       &filter_type);
+        } else {
+                if (priv->sme_i.sme_flag & SME_MULTICAST) {
+                        mc_count = netdev_mc_count(dev);
+                        netdev_for_each_mc_addr(ha, dev) {
+                                memcpy(&set_address[i * ETH_ALEN], ha->addr,
+                                       ETH_ALEN);
+                                i++;
+                        }
+                        priv->sme_i.sme_flag &= ~SME_MULTICAST;
+                        hostif_mib_set_request(priv, LOCAL_MULTICAST_ADDRESS,
+                                               (ETH_ALEN * mc_count),
+                                               MIB_VALUE_TYPE_OSTRING,
+                                               &set_address[0]);
+                } else {
+                        filter_type =
+                            cpu_to_le32((uint32_t) MCAST_FILTER_MCAST);
+                        priv->sme_i.sme_flag |= SME_MULTICAST;
+                        hostif_mib_set_request(priv, LOCAL_MULTICAST_FILTER,
+                                               sizeof(filter_type),
+                                               MIB_VALUE_TYPE_BOOL,
+                                               &filter_type);
+                }
+        }
+
+        spin_unlock(&priv->multicast_spin);
+
+}
+
+static
+void hostif_sme_powermgt_set(struct ks_wlan_private *priv)
+{
+        unsigned long mode, wake_up, receiveDTIMs;
+
+        DPRINTK(3, "\n");
+        switch (priv->reg.powermgt) {
+        case POWMGT_ACTIVE_MODE:
+                mode = POWER_ACTIVE;
+                wake_up = 0;
+                receiveDTIMs = 0;
+                break;
+        case POWMGT_SAVE1_MODE:
+                if (priv->reg.operation_mode == MODE_INFRASTRUCTURE) {
+                        mode = POWER_SAVE;
+                        wake_up = 0;
+                        receiveDTIMs = 0;
+                } else {
+                        mode = POWER_ACTIVE;
+                        wake_up = 0;
+                        receiveDTIMs = 0;
+                }
+                break;
+        case POWMGT_SAVE2_MODE:
+                if (priv->reg.operation_mode == MODE_INFRASTRUCTURE) {
+                        mode = POWER_SAVE;
+                        wake_up = 0;
+                        receiveDTIMs = 1;
+                } else {
+                        mode = POWER_ACTIVE;
+                        wake_up = 0;
+                        receiveDTIMs = 0;
+                }
+                break;
+        default:
+                mode = POWER_ACTIVE;
+                wake_up = 0;
+                receiveDTIMs = 0;
+                break;
+        }
+        hostif_power_mngmt_request(priv, mode, wake_up, receiveDTIMs);
+
+        return;
+}
+
+static
+void hostif_sme_sleep_set(struct ks_wlan_private *priv)
+{
+        DPRINTK(3, "\n");
+        switch (priv->sleep_mode) {
+        case SLP_SLEEP:
+                hostif_sleep_request(priv, priv->sleep_mode);
+                break;
+        case SLP_ACTIVE:
+                hostif_sleep_request(priv, priv->sleep_mode);
+                break;
+        default:
+                break;
+        }
+
+        return;
+}
+
+static
+void hostif_sme_set_key(struct ks_wlan_private *priv, int type)
+{
+        uint32_t val;
+        switch (type) {
+        case SME_SET_FLAG:
+                val = cpu_to_le32((uint32_t) (priv->reg.privacy_invoked));
+                hostif_mib_set_request(priv, DOT11_PRIVACY_INVOKED,
+                                       sizeof(val), MIB_VALUE_TYPE_BOOL, &val);
+                break;
+        case SME_SET_TXKEY:
+                val = cpu_to_le32((uint32_t) (priv->wpa.txkey));
+                hostif_mib_set_request(priv, DOT11_WEP_DEFAULT_KEY_ID,
+                                       sizeof(val), MIB_VALUE_TYPE_INT, &val);
+                break;
+        case SME_SET_KEY1:
+                hostif_mib_set_request(priv, DOT11_WEP_DEFAULT_KEY_VALUE1,
+                                       priv->wpa.key[0].key_len,
+                                       MIB_VALUE_TYPE_OSTRING,
+                                       &priv->wpa.key[0].key_val[0]);
+                break;
+        case SME_SET_KEY2:
+                hostif_mib_set_request(priv, DOT11_WEP_DEFAULT_KEY_VALUE2,
+                                       priv->wpa.key[1].key_len,
+                                       MIB_VALUE_TYPE_OSTRING,
+                                       &priv->wpa.key[1].key_val[0]);
+                break;
+        case SME_SET_KEY3:
+                hostif_mib_set_request(priv, DOT11_WEP_DEFAULT_KEY_VALUE3,
+                                       priv->wpa.key[2].key_len,
+                                       MIB_VALUE_TYPE_OSTRING,
+                                       &priv->wpa.key[2].key_val[0]);
+                break;
+        case SME_SET_KEY4:
+                hostif_mib_set_request(priv, DOT11_WEP_DEFAULT_KEY_VALUE4,
+                                       priv->wpa.key[3].key_len,
+                                       MIB_VALUE_TYPE_OSTRING,
+                                       &priv->wpa.key[3].key_val[0]);
+                break;
+        case SME_SET_PMK_TSC:
+                hostif_mib_set_request(priv, DOT11_PMK_TSC,
+                                       WPA_RX_SEQ_LEN, MIB_VALUE_TYPE_OSTRING,
+                                       &priv->wpa.key[0].rx_seq[0]);
+                break;
+        case SME_SET_GMK1_TSC:
+                hostif_mib_set_request(priv, DOT11_GMK1_TSC,
+                                       WPA_RX_SEQ_LEN, MIB_VALUE_TYPE_OSTRING,
+                                       &priv->wpa.key[1].rx_seq[0]);
+                break;
+        case SME_SET_GMK2_TSC:
+                hostif_mib_set_request(priv, DOT11_GMK2_TSC,
+                                       WPA_RX_SEQ_LEN, MIB_VALUE_TYPE_OSTRING,
+                                       &priv->wpa.key[2].rx_seq[0]);
+                break;
+        }
+        return;
+}
+
+static
+void hostif_sme_set_pmksa(struct ks_wlan_private *priv)
+{
+        struct pmk_cache_t {
+                uint16_t size;
+                struct {
+                        uint8_t bssid[ETH_ALEN];
+                        uint8_t pmkid[IW_PMKID_LEN];
+                } __attribute__ ((packed)) list[PMK_LIST_MAX];
+        } __attribute__ ((packed)) pmkcache;
+        struct pmk_t *pmk;
+        struct list_head *ptr;
+        int i;
+
+        DPRINTK(4, "pmklist.size=%d\n", priv->pmklist.size);
+        i = 0;
+        list_for_each(ptr, &priv->pmklist.head) {
+                pmk = list_entry(ptr, struct pmk_t, list);
+                if (i < PMK_LIST_MAX) {
+                        memcpy(pmkcache.list[i].bssid, pmk->bssid, ETH_ALEN);
+                        memcpy(pmkcache.list[i].pmkid, pmk->pmkid,
+                               IW_PMKID_LEN);
+                        i++;
+                }
+        }
+        pmkcache.size = cpu_to_le16((uint16_t) (priv->pmklist.size));
+        hostif_mib_set_request(priv, LOCAL_PMK,
+                               sizeof(priv->pmklist.size) + (ETH_ALEN +
+                                                             IW_PMKID_LEN) *
+                               (priv->pmklist.size), MIB_VALUE_TYPE_OSTRING,
+                               &pmkcache);
+}
+
+/* execute sme */
+static
+void hostif_sme_execute(struct ks_wlan_private *priv, int event)
+{
+        uint32_t val;
+
+        DPRINTK(3, "event=%d\n", event);
+        switch (event) {
+        case SME_START:
+                if (priv->dev_state == DEVICE_STATE_BOOT) {
+                        hostif_mib_get_request(priv, DOT11_MAC_ADDRESS);
+                }
+                break;
+        case SME_MULTICAST_REQUEST:
+                hostif_sme_multicast_set(priv);
+                break;
+        case SME_MACADDRESS_SET_REQUEST:
+                hostif_mib_set_request(priv, LOCAL_CURRENTADDRESS, ETH_ALEN,
+                                       MIB_VALUE_TYPE_OSTRING,
+                                       &priv->eth_addr[0]);
+                break;
+        case SME_BSS_SCAN_REQUEST:
+                hostif_bss_scan_request(priv, priv->reg.scan_type,
+                                        priv->scan_ssid, priv->scan_ssid_len);
+                break;
+        case SME_POW_MNGMT_REQUEST:
+                hostif_sme_powermgt_set(priv);
+                break;
+        case SME_PHY_INFO_REQUEST:
+                hostif_phy_information_request(priv);
+                break;
+        case SME_MIC_FAILURE_REQUEST:
+                if (priv->wpa.mic_failure.failure == 1) {
+                        hostif_mic_failure_request(priv,
+                                                   priv->wpa.mic_failure.
+                                                   failure - 1, 0);
+                } else if (priv->wpa.mic_failure.failure == 2) {
+                        hostif_mic_failure_request(priv,
+                                                   priv->wpa.mic_failure.
+                                                   failure - 1,
+                                                   priv->wpa.mic_failure.
+                                                   counter);
+                } else
+                        DPRINTK(4,
+                                "SME_MIC_FAILURE_REQUEST: failure count=%u error?\n",
+                                priv->wpa.mic_failure.failure);
+                break;
+        case SME_MIC_FAILURE_CONFIRM:
+                if (priv->wpa.mic_failure.failure == 2) {
+                        if (priv->wpa.mic_failure.stop)
+                                priv->wpa.mic_failure.stop = 0;
+                        priv->wpa.mic_failure.failure = 0;
+                        hostif_start_request(priv, priv->reg.operation_mode);
+                }
+                break;
+        case SME_GET_MAC_ADDRESS:
+                if (priv->dev_state == DEVICE_STATE_BOOT) {
+                        hostif_mib_get_request(priv, DOT11_PRODUCT_VERSION);
+                }
+                break;
+        case SME_GET_PRODUCT_VERSION:
+                if (priv->dev_state == DEVICE_STATE_BOOT) {
+                        priv->dev_state = DEVICE_STATE_PREINIT;
+                }
+                break;
+        case SME_STOP_REQUEST:
+                hostif_stop_request(priv);
+                break;
+        case SME_RTS_THRESHOLD_REQUEST:
+                val = cpu_to_le32((uint32_t) (priv->reg.rts));
+                hostif_mib_set_request(priv, DOT11_RTS_THRESHOLD,
+                                       sizeof(val), MIB_VALUE_TYPE_INT, &val);
+                break;
+        case SME_FRAGMENTATION_THRESHOLD_REQUEST:
+                val = cpu_to_le32((uint32_t) (priv->reg.fragment));
+                hostif_mib_set_request(priv, DOT11_FRAGMENTATION_THRESHOLD,
+                                       sizeof(val), MIB_VALUE_TYPE_INT, &val);
+                break;
+        case SME_WEP_INDEX_REQUEST:
+        case SME_WEP_KEY1_REQUEST:
+        case SME_WEP_KEY2_REQUEST:
+        case SME_WEP_KEY3_REQUEST:
+        case SME_WEP_KEY4_REQUEST:
+        case SME_WEP_FLAG_REQUEST:
+                hostif_sme_set_wep(priv, event);
+                break;
+        case SME_RSN_UCAST_REQUEST:
+        case SME_RSN_MCAST_REQUEST:
+        case SME_RSN_AUTH_REQUEST:
+        case SME_RSN_ENABLED_REQUEST:
+        case SME_RSN_MODE_REQUEST:
+                hostif_sme_set_rsn(priv, event);
+                break;
+        case SME_SET_FLAG:
+        case SME_SET_TXKEY:
+        case SME_SET_KEY1:
+        case SME_SET_KEY2:
+        case SME_SET_KEY3:
+        case SME_SET_KEY4:
+        case SME_SET_PMK_TSC:
+        case SME_SET_GMK1_TSC:
+        case SME_SET_GMK2_TSC:
+                hostif_sme_set_key(priv, event);
+                break;
+        case SME_SET_PMKSA:
+                hostif_sme_set_pmksa(priv);
+                break;
+#ifdef WPS
+        case SME_WPS_ENABLE_REQUEST:
+                hostif_mib_set_request(priv, LOCAL_WPS_ENABLE,
+                                       sizeof(priv->wps.wps_enabled),
+                                       MIB_VALUE_TYPE_INT,
+                                       &priv->wps.wps_enabled);
+                break;
+        case SME_WPS_PROBE_REQUEST:
+                hostif_mib_set_request(priv, LOCAL_WPS_PROBE_REQ,
+                                       priv->wps.ielen,
+                                       MIB_VALUE_TYPE_OSTRING, priv->wps.ie);
+                break;
+#endif /* WPS */
+        case SME_MODE_SET_REQUEST:
+                hostif_sme_mode_setup(priv);
+                break;
+        case SME_SET_GAIN:
+                hostif_mib_set_request(priv, LOCAL_GAIN,
+                                       sizeof(priv->gain),
+                                       MIB_VALUE_TYPE_OSTRING, &priv->gain);
+                break;
+        case SME_GET_GAIN:
+                hostif_mib_get_request(priv, LOCAL_GAIN);
+                break;
+        case SME_GET_EEPROM_CKSUM:
+                priv->eeprom_checksum = EEPROM_FW_NOT_SUPPORT;  /* initialize */
+                hostif_mib_get_request(priv, LOCAL_EEPROM_SUM);
+                break;
+        case SME_START_REQUEST:
+                hostif_start_request(priv, priv->reg.operation_mode);
+                break;
+        case SME_START_CONFIRM:
+                /* for power save */
+                atomic_set(&priv->psstatus.snooze_guard, 0);
+                atomic_set(&priv->psstatus.confirm_wait, 0);
+                if (priv->dev_state == DEVICE_STATE_PREINIT) {
+                        priv->dev_state = DEVICE_STATE_INIT;
+                }
+                /* wake_up_interruptible_all(&priv->confirm_wait); */
+                complete(&priv->confirm_wait);
+                break;
+        case SME_SLEEP_REQUEST:
+                hostif_sme_sleep_set(priv);
+                break;
+        case SME_SET_REGION:
+                val = cpu_to_le32((uint32_t) (priv->region));
+                hostif_mib_set_request(priv, LOCAL_REGION,
+                                       sizeof(val), MIB_VALUE_TYPE_INT, &val);
+                break;
+        case SME_MULTICAST_CONFIRM:
+        case SME_BSS_SCAN_CONFIRM:
+        case SME_POW_MNGMT_CONFIRM:
+        case SME_PHY_INFO_CONFIRM:
+        case SME_STOP_CONFIRM:
+        case SME_RTS_THRESHOLD_CONFIRM:
+        case SME_FRAGMENTATION_THRESHOLD_CONFIRM:
+        case SME_WEP_INDEX_CONFIRM:
+        case SME_WEP_KEY1_CONFIRM:
+        case SME_WEP_KEY2_CONFIRM:
+        case SME_WEP_KEY3_CONFIRM:
+        case SME_WEP_KEY4_CONFIRM:
+        case SME_WEP_FLAG_CONFIRM:
+        case SME_RSN_UCAST_CONFIRM:
+        case SME_RSN_MCAST_CONFIRM:
+        case SME_RSN_AUTH_CONFIRM:
+        case SME_RSN_ENABLED_CONFIRM:
+        case SME_RSN_MODE_CONFIRM:
+        case SME_MODE_SET_CONFIRM:
+                break;
+        case SME_TERMINATE:
+        default:
+                break;
+        }
+}
+
+static
+void hostif_sme_task(unsigned long dev)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
+
+        DPRINTK(3, "\n");
+
+        if (priv->dev_state >= DEVICE_STATE_BOOT) {
+                if (0 < cnt_smeqbody(priv)
+                    && priv->dev_state >= DEVICE_STATE_BOOT) {
+                        hostif_sme_execute(priv,
+                                           priv->sme_i.event_buff[priv->sme_i.
+                                                                  qhead]);
+                        inc_smeqhead(priv);
+                        if (0 < cnt_smeqbody(priv))
+                                tasklet_schedule(&priv->sme_task);
+                }
+        }
+        return;
+}
+
+/* send to Station Management Entity module */
+void hostif_sme_enqueue(struct ks_wlan_private *priv, unsigned short event)
+{
+        DPRINTK(3, "\n");
+
+        /* enqueue sme event */
+        if (cnt_smeqbody(priv) < (SME_EVENT_BUFF_SIZE - 1)) {
+                priv->sme_i.event_buff[priv->sme_i.qtail] = event;
+                inc_smeqtail(priv);
+                //DPRINTK(3,"inc_smeqtail \n");
+#ifdef KS_WLAN_DEBUG
+                if (priv->sme_i.max_event_count < cnt_smeqbody(priv))
+                        priv->sme_i.max_event_count = cnt_smeqbody(priv);
+#endif /* KS_WLAN_DEBUG */
+        } else {
+                /* in case of buffer overflow */
+                //DPRINTK(2,"sme queue buffer overflow\n");
+                printk("sme queue buffer overflow\n");
+        }
+
+        tasklet_schedule(&priv->sme_task);
+
+}
+
+int hostif_init(struct ks_wlan_private *priv)
+{
+        int rc = 0;
+        int i;
+
+        DPRINTK(3, "\n");
+
+        priv->aplist.size = 0;
+        for (i = 0; i < LOCAL_APLIST_MAX; i++)
+                memset(&(priv->aplist.ap[i]), 0, sizeof(struct local_ap_t));
+        priv->infra_status = 0;
+        priv->current_rate = 4;
+        priv->connect_status = DISCONNECT_STATUS;
+
+        spin_lock_init(&priv->multicast_spin);
+
+        spin_lock_init(&priv->dev_read_lock);
+        init_waitqueue_head(&priv->devread_wait);
+        priv->dev_count = 0;
+        atomic_set(&priv->event_count, 0);
+        atomic_set(&priv->rec_count, 0);
+
+        /* for power save */
+        atomic_set(&priv->psstatus.status, PS_NONE);
+        atomic_set(&priv->psstatus.confirm_wait, 0);
+        atomic_set(&priv->psstatus.snooze_guard, 0);
+        /* init_waitqueue_head(&priv->psstatus.wakeup_wait); */
+        init_completion(&priv->psstatus.wakeup_wait);
+        //INIT_WORK(&priv->ks_wlan_wakeup_task, ks_wlan_hw_wakeup_task, (void *)priv);
+        INIT_WORK(&priv->ks_wlan_wakeup_task, ks_wlan_hw_wakeup_task);
+
+        /* WPA */
+        memset(&(priv->wpa), 0, sizeof(priv->wpa));
+        priv->wpa.rsn_enabled = 0;
+        priv->wpa.mic_failure.failure = 0;
+        priv->wpa.mic_failure.last_failure_time = 0;
+        priv->wpa.mic_failure.stop = 0;
+        memset(&(priv->pmklist), 0, sizeof(priv->pmklist));
+        INIT_LIST_HEAD(&priv->pmklist.head);
+        for (i = 0; i < PMK_LIST_MAX; i++)
+                INIT_LIST_HEAD(&priv->pmklist.pmk[i].list);
+
+        priv->sme_i.sme_status = SME_IDLE;
+        priv->sme_i.qhead = priv->sme_i.qtail = 0;
+#ifdef KS_WLAN_DEBUG
+        priv->sme_i.max_event_count = 0;
+#endif
+        spin_lock_init(&priv->sme_i.sme_spin);
+        priv->sme_i.sme_flag = 0;
+
+        tasklet_init(&priv->sme_task, hostif_sme_task, (unsigned long)priv);
+
+        return rc;
+}
+
+void hostif_exit(struct ks_wlan_private *priv)
+{
+        tasklet_kill(&priv->sme_task);
+        return;
+}
diff --git a/drivers/staging/ks7010/ks_hostif.h b/drivers/staging/ks7010/ks_hostif.h
new file mode 100644
index 000000000000..dc806b5b47be
--- /dev/null
+++ b/drivers/staging/ks7010/ks_hostif.h
@@ -0,0 +1,644 @@
+/*
+ *   Driver for KeyStream wireless LAN
+ *   
+ *   Copyright (c) 2005-2008 KeyStream Corp.
+ *   Copyright (C) 2009 Renesas Technology Corp.
+ *
+ *   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.
+ */
+
+#ifndef _KS_HOSTIF_H_
+#define _KS_HOSTIF_H_
+/*
+ * HOST-MAC I/F events
+ */
+#define HIF_DATA_REQ            0xE001
+#define HIF_DATA_IND            0xE801
+#define HIF_MIB_GET_REQ         0xE002
+#define HIF_MIB_GET_CONF        0xE802
+#define HIF_MIB_SET_REQ         0xE003
+#define HIF_MIB_SET_CONF        0xE803
+#define HIF_POWERMGT_REQ        0xE004
+#define HIF_POWERMGT_CONF       0xE804
+#define HIF_START_REQ           0xE005
+#define HIF_START_CONF          0xE805
+#define HIF_CONNECT_IND         0xE806
+#define HIF_STOP_REQ            0xE006
+#define HIF_STOP_CONF           0xE807
+#define HIF_PS_ADH_SET_REQ      0xE007
+#define HIF_PS_ADH_SET_CONF     0xE808
+#define HIF_INFRA_SET_REQ       0xE008
+#define HIF_INFRA_SET_CONF      0xE809
+#define HIF_ADH_SET_REQ         0xE009
+#define HIF_ADH_SET_CONF        0xE80A
+#define HIF_AP_SET_REQ          0xE00A
+#define HIF_AP_SET_CONF         0xE80B
+#define HIF_ASSOC_INFO_IND      0xE80C
+#define HIF_MIC_FAILURE_REQ     0xE00B
+#define HIF_MIC_FAILURE_CONF    0xE80D
+#define HIF_SCAN_REQ            0xE00C
+#define HIF_SCAN_CONF           0xE80E
+#define HIF_PHY_INFO_REQ        0xE00D
+#define HIF_PHY_INFO_CONF       0xE80F
+#define HIF_SLEEP_REQ           0xE00E
+#define HIF_SLEEP_CONF          0xE810
+#define HIF_PHY_INFO_IND        0xE811
+#define HIF_SCAN_IND            0xE812
+#define HIF_INFRA_SET2_REQ      0xE00F
+#define HIF_INFRA_SET2_CONF     0xE813
+#define HIF_ADH_SET2_REQ        0xE010
+#define HIF_ADH_SET2_CONF       0xE814
+
+#define HIF_REQ_MAX             0xE010
+
+/*
+ * HOST-MAC I/F data structure
+ * Byte alignmet Little Endian
+ */
+
+struct hostif_hdr {
+        uint16_t size;
+        uint16_t event;
+} __attribute__ ((packed));
+
+struct hostif_data_request_t {
+        struct hostif_hdr header;
+        uint16_t auth_type;
+#define TYPE_DATA 0x0000
+#define TYPE_AUTH 0x0001
+        uint16_t reserved;
+        uint8_t data[0];
+} __attribute__ ((packed));
+
+struct hostif_data_indication_t {
+        struct hostif_hdr header;
+        uint16_t auth_type;
+/* #define TYPE_DATA 0x0000 */
+#define TYPE_PMK1 0x0001
+#define TYPE_GMK1 0x0002
+#define TYPE_GMK2 0x0003
+        uint16_t reserved;
+        uint8_t data[0];
+} __attribute__ ((packed));
+
+#define CHANNEL_LIST_MAX_SIZE 14
+struct channel_list_t {
+        uint8_t size;
+        uint8_t body[CHANNEL_LIST_MAX_SIZE];
+        uint8_t pad;
+} __attribute__ ((packed));
+
+/* MIB Attribute */
+#define DOT11_MAC_ADDRESS                 0x21010100    /* MAC Address (R) */
+#define DOT11_PRODUCT_VERSION             0x31024100    /* FirmWare Version (R) */
+#define DOT11_RTS_THRESHOLD               0x21020100    /* RTS Threshold (R/W) */
+#define DOT11_FRAGMENTATION_THRESHOLD     0x21050100    /* Fragment Threshold (R/W) */
+#define DOT11_PRIVACY_INVOKED             0x15010100    /* WEP ON/OFF (W) */
+#define DOT11_WEP_DEFAULT_KEY_ID          0x15020100    /* WEP Index (W) */
+#define DOT11_WEP_DEFAULT_KEY_VALUE1      0x13020101    /* WEP Key#1(TKIP AES: PairwiseTemporalKey) (W) */
+#define DOT11_WEP_DEFAULT_KEY_VALUE2      0x13020102    /* WEP Key#2(TKIP AES: GroupKey1) (W) */
+#define DOT11_WEP_DEFAULT_KEY_VALUE3      0x13020103    /* WEP Key#3(TKIP AES: GroupKey2) (W) */
+#define DOT11_WEP_DEFAULT_KEY_VALUE4      0x13020104    /* WEP Key#4 (W) */
+#define DOT11_WEP_LIST                    0x13020100    /* WEP LIST */
+#define DOT11_DESIRED_SSID                0x11090100    /* SSID */
+#define DOT11_CURRENT_CHANNEL             0x45010100    /* channel set */
+#define DOT11_OPERATION_RATE_SET          0x11110100    /* rate set */
+
+#define LOCAL_AP_SEARCH_INTEAVAL          0xF1010100    /* AP search interval (R/W) */
+#define LOCAL_CURRENTADDRESS              0xF1050100    /* MAC Adress change (W) */
+#define LOCAL_MULTICAST_ADDRESS           0xF1060100    /* Multicast Adress (W) */
+#define LOCAL_MULTICAST_FILTER            0xF1060200    /* Multicast Adress Filter enable/disable (W) */
+#define LOCAL_SEARCHED_AP_LIST            0xF1030100    /* AP list (R) */
+#define LOCAL_LINK_AP_STATUS              0xF1040100    /* Link AP status (R) */
+#define LOCAL_PACKET_STATISTICS           0xF1020100    /* tx,rx packets statistics */
+#define LOCAL_AP_SCAN_LIST_TYPE_SET       0xF1030200    /* AP_SCAN_LIST_TYPE */
+
+#define DOT11_RSN_ENABLED                 0x15070100    /* WPA enable/disable (W) */
+#define LOCAL_RSN_MODE                    0x56010100    /* RSN mode WPA/WPA2 (W) */
+#define DOT11_RSN_CONFIG_MULTICAST_CIPHER 0x51040100    /* GroupKeyCipherSuite (W) */
+#define DOT11_RSN_CONFIG_UNICAST_CIPHER   0x52020100    /* PairwiseKeyCipherSuite (W) */
+#define DOT11_RSN_CONFIG_AUTH_SUITE       0x53020100    /* AuthenticationKeyManagementSuite (W) */
+#define DOT11_RSN_CONFIG_VERSION          0x51020100    /* RSN version (W) */
+#define LOCAL_RSN_CONFIG_ALL              0x5F010100    /* RSN CONFIG ALL (W) */
+#define DOT11_PMK_TSC                     0x55010100    /* PMK_TSC (W) */
+#define DOT11_GMK1_TSC                    0x55010101    /* GMK1_TSC (W) */
+#define DOT11_GMK2_TSC                    0x55010102    /* GMK2_TSC (W) */
+#define DOT11_GMK3_TSC                    0x55010103    /* GMK3_TSC */
+#define LOCAL_PMK                         0x58010100    /* Pairwise Master Key cache (W) */
+
+#define LOCAL_REGION                      0xF10A0100    /* Region setting */
+
+#ifdef WPS
+#define LOCAL_WPS_ENABLE                  0xF10B0100    /* WiFi Protected Setup */
+#define LOCAL_WPS_PROBE_REQ               0xF10C0100    /* WPS Probe Request */
+#endif /* WPS */
+
+#define LOCAL_GAIN                        0xF10D0100    /* Carrer sense threshold for demo ato show */
+#define LOCAL_EEPROM_SUM                  0xF10E0100    /* EEPROM checksum information */
+
+struct hostif_mib_get_request_t {
+        struct hostif_hdr header;
+        uint32_t mib_attribute;
+} __attribute__ ((packed));
+
+struct hostif_mib_value_t {
+        uint16_t size;
+        uint16_t type;
+#define MIB_VALUE_TYPE_NULL     0
+#define MIB_VALUE_TYPE_INT      1
+#define MIB_VALUE_TYPE_BOOL     2
+#define MIB_VALUE_TYPE_COUNT32  3
+#define MIB_VALUE_TYPE_OSTRING  4
+        uint8_t body[0];
+} __attribute__ ((packed));
+
+struct hostif_mib_get_confirm_t {
+        struct hostif_hdr header;
+        uint32_t mib_status;
+#define MIB_SUCCESS    0
+#define MIB_INVALID    1
+#define MIB_READ_ONLY  2
+#define MIB_WRITE_ONLY 3
+        uint32_t mib_attribute;
+        struct hostif_mib_value_t mib_value;
+} __attribute__ ((packed));
+
+struct hostif_mib_set_request_t {
+        struct hostif_hdr header;
+        uint32_t mib_attribute;
+        struct hostif_mib_value_t mib_value;
+} __attribute__ ((packed));
+
+struct hostif_mib_set_confirm_t {
+        struct hostif_hdr header;
+        uint32_t mib_status;
+        uint32_t mib_attribute;
+} __attribute__ ((packed));
+
+struct hostif_power_mngmt_request_t {
+        struct hostif_hdr header;
+        uint32_t mode;
+#define POWER_ACTIVE  1
+#define POWER_SAVE    2
+        uint32_t wake_up;
+#define SLEEP_FALSE 0
+#define SLEEP_TRUE  1   /* not used */
+        uint32_t receiveDTIMs;
+#define DTIM_FALSE 0
+#define DTIM_TRUE  1
+} __attribute__ ((packed));
+
+/* power management mode */
+enum {
+        POWMGT_ACTIVE_MODE = 0,
+        POWMGT_SAVE1_MODE,
+        POWMGT_SAVE2_MODE
+};
+
+#define RESULT_SUCCESS            0
+#define RESULT_INVALID_PARAMETERS 1
+#define RESULT_NOT_SUPPORTED      2
+/* #define      RESULT_ALREADY_RUNNING    3 */
+#define RESULT_ALREADY_RUNNING    7
+
+struct hostif_power_mngmt_confirm_t {
+        struct hostif_hdr header;
+        uint16_t result_code;
+} __attribute__ ((packed));
+
+struct hostif_start_request_t {
+        struct hostif_hdr header;
+        uint16_t mode;
+#define MODE_PSEUDO_ADHOC   0
+#define MODE_INFRASTRUCTURE 1
+#define MODE_AP             2   /* not used */
+#define MODE_ADHOC          3
+} __attribute__ ((packed));
+
+struct hostif_start_confirm_t {
+        struct hostif_hdr header;
+        uint16_t result_code;
+} __attribute__ ((packed));
+
+#define SSID_MAX_SIZE 32
+struct ssid_t {
+        uint8_t size;
+        uint8_t body[SSID_MAX_SIZE];
+        uint8_t ssid_pad;
+} __attribute__ ((packed));
+
+#define RATE_SET_MAX_SIZE 16
+struct rate_set8_t {
+        uint8_t size;
+        uint8_t body[8];
+        uint8_t rate_pad;
+} __attribute__ ((packed));
+
+struct FhParms_t {
+        uint16_t dwellTime;
+        uint8_t hopSet;
+        uint8_t hopPattern;
+        uint8_t hopIndex;
+} __attribute__ ((packed));
+
+struct DsParms_t {
+        uint8_t channel;
+} __attribute__ ((packed));
+
+struct CfParms_t {
+        uint8_t count;
+        uint8_t period;
+        uint16_t maxDuration;
+        uint16_t durRemaining;
+} __attribute__ ((packed));
+
+struct IbssParms_t {
+        uint16_t atimWindow;
+} __attribute__ ((packed));
+
+struct rsn_t {
+        uint8_t size;
+#define RSN_BODY_SIZE 64
+        uint8_t body[RSN_BODY_SIZE];
+} __attribute__ ((packed));
+
+struct ErpParams_t {
+        uint8_t erp_info;
+} __attribute__ ((packed));
+
+struct rate_set16_t {
+        uint8_t size;
+        uint8_t body[16];
+        uint8_t rate_pad;
+} __attribute__ ((packed));
+
+struct ap_info_t {
+        uint8_t bssid[6];       /* +00 */
+        uint8_t rssi;   /* +06 */
+        uint8_t sq;     /* +07 */
+        uint8_t noise;  /* +08 */
+        uint8_t pad0;   /* +09 */
+        uint16_t beacon_period; /* +10 */
+        uint16_t capability;    /* +12 */
+#define BSS_CAP_ESS             (1<<0)
+#define BSS_CAP_IBSS            (1<<1)
+#define BSS_CAP_CF_POLABLE      (1<<2)
+#define BSS_CAP_CF_POLL_REQ     (1<<3)
+#define BSS_CAP_PRIVACY         (1<<4)
+#define BSS_CAP_SHORT_PREAMBLE  (1<<5)
+#define BSS_CAP_PBCC            (1<<6)
+#define BSS_CAP_CHANNEL_AGILITY (1<<7)
+#define BSS_CAP_SHORT_SLOT_TIME (1<<10)
+#define BSS_CAP_DSSS_OFDM       (1<<13)
+        uint8_t frame_type;     /* +14 */
+        uint8_t ch_info;        /* +15 */
+#define FRAME_TYPE_BEACON       0x80
+#define FRAME_TYPE_PROBE_RESP   0x50
+        uint16_t body_size;     /* +16 */
+        uint8_t body[1024];     /* +18 */
+        /* +1032 */
+} __attribute__ ((packed));
+
+struct link_ap_info_t {
+        uint8_t bssid[6];       /* +00 */
+        uint8_t rssi;   /* +06 */
+        uint8_t sq;     /* +07 */
+        uint8_t noise;  /* +08 */
+        uint8_t pad0;   /* +09 */
+        uint16_t beacon_period; /* +10 */
+        uint16_t capability;    /* +12 */
+        struct rate_set8_t rate_set;    /* +14 */
+        struct FhParms_t fh_parameter;  /* +24 */
+        struct DsParms_t ds_parameter;  /* +29 */
+        struct CfParms_t cf_parameter;  /* +30 */
+        struct IbssParms_t ibss_parameter;      /* +36 */
+        struct ErpParams_t erp_parameter;       /* +38 */
+        uint8_t pad1;   /* +39 */
+        struct rate_set8_t ext_rate_set;        /* +40 */
+        uint8_t DTIM_period;    /* +50 */
+        uint8_t rsn_mode;       /* +51 */
+#define RSN_MODE_NONE   0
+#define RSN_MODE_WPA    1
+#define RSN_MODE_WPA2   2
+        struct {
+                uint8_t size;   /* +52 */
+                uint8_t body[128];      /* +53 */
+        } __attribute__ ((packed)) rsn;
+} __attribute__ ((packed));
+
+struct hostif_connect_indication_t {
+        struct hostif_hdr header;
+        uint16_t connect_code;
+#define RESULT_CONNECT    0
+#define RESULT_DISCONNECT 1
+        struct link_ap_info_t link_ap_info;
+} __attribute__ ((packed));
+
+struct hostif_stop_request_t {
+        struct hostif_hdr header;
+} __attribute__ ((packed));
+
+struct hostif_stop_confirm_t {
+        struct hostif_hdr header;
+        uint16_t result_code;
+} __attribute__ ((packed));
+
+struct hostif_ps_adhoc_set_request_t {
+        struct hostif_hdr header;
+        uint16_t phy_type;
+#define D_11B_ONLY_MODE         0
+#define D_11G_ONLY_MODE         1
+#define D_11BG_COMPATIBLE_MODE  2
+#define D_11A_ONLY_MODE         3
+        uint16_t cts_mode;
+#define CTS_MODE_FALSE  0
+#define CTS_MODE_TRUE   1
+        uint16_t channel;
+        struct rate_set16_t rate_set;
+        uint16_t capability;    /* bit5:preamble bit6:pbcc pbcc not supported always 0 
+                                 * bit10:ShortSlotTime bit13:DSSS-OFDM DSSS-OFDM not supported always 0 */
+        uint16_t scan_type;
+} __attribute__ ((packed));
+
+struct hostif_ps_adhoc_set_confirm_t {
+        struct hostif_hdr header;
+        uint16_t result_code;
+} __attribute__ ((packed));
+
+struct hostif_infrastructure_set_request_t {
+        struct hostif_hdr header;
+        uint16_t phy_type;
+        uint16_t cts_mode;
+        struct rate_set16_t rate_set;
+        struct ssid_t ssid;
+        uint16_t capability;    /* bit5:preamble bit6:pbcc pbcc not supported always 0 
+                                 * bit10:ShortSlotTime bit13:DSSS-OFDM DSSS-OFDM not supported always 0 */
+        uint16_t beacon_lost_count;
+        uint16_t auth_type;
+#define AUTH_TYPE_OPEN_SYSTEM 0
+#define AUTH_TYPE_SHARED_KEY  1
+        struct channel_list_t channel_list;
+        uint16_t scan_type;
+} __attribute__ ((packed));
+
+struct hostif_infrastructure_set2_request_t {
+        struct hostif_hdr header;
+        uint16_t phy_type;
+        uint16_t cts_mode;
+        struct rate_set16_t rate_set;
+        struct ssid_t ssid;
+        uint16_t capability;    /* bit5:preamble bit6:pbcc pbcc not supported always 0 
+                                 * bit10:ShortSlotTime bit13:DSSS-OFDM DSSS-OFDM not supported always 0 */
+        uint16_t beacon_lost_count;
+        uint16_t auth_type;
+#define AUTH_TYPE_OPEN_SYSTEM 0
+#define AUTH_TYPE_SHARED_KEY  1
+        struct channel_list_t channel_list;
+        uint16_t scan_type;
+        uint8_t bssid[ETH_ALEN];
+} __attribute__ ((packed));
+
+struct hostif_infrastructure_set_confirm_t {
+        struct hostif_hdr header;
+        uint16_t result_code;
+} __attribute__ ((packed));
+
+struct hostif_adhoc_set_request_t {
+        struct hostif_hdr header;
+        uint16_t phy_type;
+        uint16_t cts_mode;
+        uint16_t channel;
+        struct rate_set16_t rate_set;
+        struct ssid_t ssid;
+        uint16_t capability;    /* bit5:preamble bit6:pbcc pbcc not supported always 0 
+                                 * bit10:ShortSlotTime bit13:DSSS-OFDM DSSS-OFDM not supported always 0 */
+        uint16_t scan_type;
+} __attribute__ ((packed));
+
+struct hostif_adhoc_set2_request_t {
+        struct hostif_hdr header;
+        uint16_t phy_type;
+        uint16_t cts_mode;
+        uint16_t reserved;
+        struct rate_set16_t rate_set;
+        struct ssid_t ssid;
+        uint16_t capability;    /* bit5:preamble bit6:pbcc pbcc not supported always 0 
+                                 * bit10:ShortSlotTime bit13:DSSS-OFDM DSSS-OFDM not supported always 0 */
+        uint16_t scan_type;
+        struct channel_list_t channel_list;
+        uint8_t bssid[ETH_ALEN];
+} __attribute__ ((packed));
+
+struct hostif_adhoc_set_confirm_t {
+        struct hostif_hdr header;
+        uint16_t result_code;
+} __attribute__ ((packed));
+
+struct last_associate_t {
+        uint8_t type;
+        uint8_t status;
+} __attribute__ ((packed));
+
+struct association_request_t {
+        uint8_t type;
+#define FRAME_TYPE_ASSOC_REQ    0x00
+#define FRAME_TYPE_REASSOC_REQ  0x20
+        uint8_t pad;
+        uint16_t capability;
+        uint16_t listen_interval;
+        uint8_t ap_address[6];
+        uint16_t reqIEs_size;
+} __attribute__ ((packed));
+
+struct association_response_t {
+        uint8_t type;
+#define FRAME_TYPE_ASSOC_RESP   0x10
+#define FRAME_TYPE_REASSOC_RESP 0x30
+        uint8_t pad;
+        uint16_t capability;
+        uint16_t status;
+        uint16_t association_id;
+        uint16_t respIEs_size;
+} __attribute__ ((packed));
+
+struct hostif_associate_indication_t {
+        struct hostif_hdr header;
+        struct association_request_t assoc_req;
+        struct association_response_t assoc_resp;
+        /* followed by (reqIEs_size + respIEs_size) octets of data */
+        /* reqIEs data *//* respIEs data */
+} __attribute__ ((packed));
+
+struct hostif_bss_scan_request_t {
+        struct hostif_hdr header;
+        uint8_t scan_type;
+#define ACTIVE_SCAN  0
+#define PASSIVE_SCAN 1
+        uint8_t pad[3];
+        uint32_t ch_time_min;
+        uint32_t ch_time_max;
+        struct channel_list_t channel_list;
+        struct ssid_t ssid;
+} __attribute__ ((packed));
+
+struct hostif_bss_scan_confirm_t {
+        struct hostif_hdr header;
+        uint16_t result_code;
+        uint16_t reserved;
+} __attribute__ ((packed));
+
+struct hostif_phy_information_request_t {
+        struct hostif_hdr header;
+        uint16_t type;
+#define NORMAL_TYPE     0
+#define TIME_TYPE       1
+        uint16_t time;  /* unit 100ms */
+} __attribute__ ((packed));
+
+struct hostif_phy_information_confirm_t {
+        struct hostif_hdr header;
+        uint8_t rssi;
+        uint8_t sq;
+        uint8_t noise;
+        uint8_t link_speed;
+        uint32_t tx_frame;
+        uint32_t rx_frame;
+        uint32_t tx_error;
+        uint32_t rx_error;
+} __attribute__ ((packed));
+
+/* sleep mode */
+#define SLP_ACTIVE  0
+#define SLP_SLEEP   1
+struct hostif_sleep_request_t {
+        struct hostif_hdr header;
+} __attribute__ ((packed));
+
+struct hostif_sleep_confirm_t {
+        struct hostif_hdr header;
+        uint16_t result_code;
+} __attribute__ ((packed));
+
+struct hostif_mic_failure_request_t {
+        struct hostif_hdr header;
+        uint16_t failure_count;
+        uint16_t timer;
+} __attribute__ ((packed));
+
+struct hostif_mic_failure_confirm_t {
+        struct hostif_hdr header;
+        uint16_t result_code;
+} __attribute__ ((packed));
+
+#define BASIC_RATE      0x80
+#define RATE_MASK       0x7F
+
+#define TX_RATE_AUTO      0xff
+#define TX_RATE_1M_FIXED  0
+#define TX_RATE_2M_FIXED  1
+#define TX_RATE_1_2M_AUTO 2
+#define TX_RATE_5M_FIXED  3
+#define TX_RATE_11M_FIXED 4
+
+#define TX_RATE_FULL_AUTO       0
+#define TX_RATE_11_AUTO         1
+#define TX_RATE_11B_AUTO        2
+#define TX_RATE_11BG_AUTO       3
+#define TX_RATE_MANUAL_AUTO     4
+#define TX_RATE_FIXED           5
+
+/* 11b rate */
+#define TX_RATE_1M      (uint8_t)(10/5) /* 11b 11g basic rate */
+#define TX_RATE_2M      (uint8_t)(20/5) /* 11b 11g basic rate */
+#define TX_RATE_5M      (uint8_t)(55/5) /* 11g basic rate */
+#define TX_RATE_11M     (uint8_t)(110/5)        /* 11g basic rate */
+
+/* 11g rate */
+#define TX_RATE_6M      (uint8_t)(60/5) /* 11g basic rate */
+#define TX_RATE_12M     (uint8_t)(120/5)        /* 11g basic rate */
+#define TX_RATE_24M     (uint8_t)(240/5)        /* 11g basic rate */
+#define TX_RATE_9M      (uint8_t)(90/5)
+#define TX_RATE_18M     (uint8_t)(180/5)
+#define TX_RATE_36M     (uint8_t)(360/5)
+#define TX_RATE_48M     (uint8_t)(480/5)
+#define TX_RATE_54M     (uint8_t)(540/5)
+
+#define IS_11B_RATE(A) (((A&RATE_MASK)==TX_RATE_1M)||((A&RATE_MASK)==TX_RATE_2M)||\
+                        ((A&RATE_MASK)==TX_RATE_5M)||((A&RATE_MASK)==TX_RATE_11M))
+
+#define IS_OFDM_RATE(A) (((A&RATE_MASK)==TX_RATE_6M)||((A&RATE_MASK)==TX_RATE_12M)||\
+                        ((A&RATE_MASK)==TX_RATE_24M)||((A&RATE_MASK)==TX_RATE_9M)||\
+                        ((A&RATE_MASK)==TX_RATE_18M)||((A&RATE_MASK)==TX_RATE_36M)||\
+                        ((A&RATE_MASK)==TX_RATE_48M)||((A&RATE_MASK)==TX_RATE_54M))
+
+#define IS_11BG_RATE(A) (IS_11B_RATE(A)||IS_OFDM_RATE(A))
+
+#define IS_OFDM_EXT_RATE(A)  (((A&RATE_MASK)==TX_RATE_9M)||((A&RATE_MASK)==TX_RATE_18M)||\
+                             ((A&RATE_MASK)==TX_RATE_36M)||((A&RATE_MASK)==TX_RATE_48M)||\
+                             ((A&RATE_MASK)==TX_RATE_54M))
+
+enum {
+        CONNECT_STATUS = 0,
+        DISCONNECT_STATUS
+};
+
+/* preamble type */
+enum {
+        LONG_PREAMBLE = 0,
+        SHORT_PREAMBLE
+};
+
+/* multicast filter */
+#define MCAST_FILTER_MCAST    0
+#define MCAST_FILTER_MCASTALL 1
+#define MCAST_FILTER_PROMISC  2
+
+#define NIC_MAX_MCAST_LIST 32
+
+/* macro function */
+#define HIF_EVENT_MASK 0xE800
+#define IS_HIF_IND(_EVENT)  ((_EVENT&HIF_EVENT_MASK)==0xE800  && \
+                             ((_EVENT&~HIF_EVENT_MASK)==0x0001 || \
+                              (_EVENT&~HIF_EVENT_MASK)==0x0006 || \
+                              (_EVENT&~HIF_EVENT_MASK)==0x000C || \
+                              (_EVENT&~HIF_EVENT_MASK)==0x0011 || \
+                              (_EVENT&~HIF_EVENT_MASK)==0x0012))
+
+#define IS_HIF_CONF(_EVENT) ((_EVENT&HIF_EVENT_MASK)==0xE800  && \
+                             (_EVENT&~HIF_EVENT_MASK)>0x0000  && \
+                             (_EVENT&~HIF_EVENT_MASK)<0x0012  && \
+                             !IS_HIF_IND(_EVENT) )
+
+#ifdef __KERNEL__
+
+#include "ks_wlan.h"
+
+/* function prototype */
+extern int hostif_data_request(struct ks_wlan_private *priv,
+                               struct sk_buff *packet);
+extern void hostif_receive(struct ks_wlan_private *priv, unsigned char *p,
+                           unsigned int size);
+extern void hostif_sme_enqueue(struct ks_wlan_private *priv, uint16_t event);
+extern int hostif_init(struct ks_wlan_private *priv);
+extern void hostif_exit(struct ks_wlan_private *priv);
+
+static
+inline int hif_align_size(int size)
+{
+#ifdef  KS_ATOM
+        if (size < 1024)
+                size = 1024;
+#endif
+#ifdef  DEVICE_ALIGNMENT
+        return (size % DEVICE_ALIGNMENT) ? size + DEVICE_ALIGNMENT -
+            (size % DEVICE_ALIGNMENT) : size;
+#else
+        return size;
+#endif
+}
+
+#endif /* __KERNEL__ */
+
+#endif /* _KS_HOSTIF_H_ */
diff --git a/drivers/staging/ks7010/ks_wlan.h b/drivers/staging/ks7010/ks_wlan.h
new file mode 100644
index 000000000000..f05dc0122fcb
--- /dev/null
+++ b/drivers/staging/ks7010/ks_wlan.h
@@ -0,0 +1,505 @@
+/*
+ *   Driver for KeyStream IEEE802.11 b/g wireless LAN cards.
+ *
+ *   Copyright (C) 2006-2008 KeyStream Corp.
+ *   Copyright (C) 2009 Renesas Technology Corp.
+ *
+ *   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.
+ */
+
+#ifndef _KS_WLAN_H
+#define _KS_WLAN_H
+
+#define WPS
+
+#include <linux/version.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+
+#include <linux/spinlock.h>     /* spinlock_t                                   */
+#include <linux/sched.h>        /* wait_queue_head_t                            */
+#include <linux/types.h>        /* pid_t                                        */
+#include <linux/netdevice.h>    /* struct net_device_stats,  struct sk_buff     */
+#include <linux/etherdevice.h>
+#include <linux/wireless.h>
+#include <asm/atomic.h> /* struct atmic_t                               */
+#include <linux/timer.h>        /* struct timer_list */
+#include <linux/string.h>
+#include <linux/completion.h>   /* struct completion */
+#include <linux/workqueue.h>
+
+#include <asm/io.h>
+
+#include "ks7010_sdio.h"
+
+#ifdef KS_WLAN_DEBUG
+#define DPRINTK(n, fmt, args...) \
+                 if (KS_WLAN_DEBUG>(n)) printk(KERN_NOTICE "%s: "fmt, __FUNCTION__, ## args)
+#else
+#define DPRINTK(n, fmt, args...)
+#endif
+
+struct ks_wlan_parameter {
+        uint8_t operation_mode; /* Operation Mode */
+        uint8_t channel;        /*  Channel */
+        uint8_t tx_rate;        /*  Transmit Rate */
+        struct {
+                uint8_t size;
+                uint8_t body[16];
+        } rate_set;
+        uint8_t bssid[ETH_ALEN];        /* BSSID */
+        struct {
+                uint8_t size;
+                uint8_t body[32 + 1];
+        } ssid; /*  SSID */
+        uint8_t preamble;       /*  Preamble */
+        uint8_t powermgt;       /*  PowerManagementMode */
+        uint32_t scan_type;     /*  AP List Scan Type */
+#define BEACON_LOST_COUNT_MIN 0
+#define BEACON_LOST_COUNT_MAX 65535
+        uint32_t beacon_lost_count;     /*  Beacon Lost Count */
+        uint32_t rts;   /*  RTS Threashold */
+        uint32_t fragment;      /*  Fragmentation Threashold */
+        uint32_t privacy_invoked;
+        uint32_t wep_index;
+        struct {
+                uint8_t size;
+                uint8_t val[13 * 2 + 1];
+        } wep_key[4];
+        uint16_t authenticate_type;
+        uint16_t phy_type;      /* 11b/11g/11bg mode type */
+        uint16_t cts_mode;      /* for 11g/11bg mode cts mode */
+        uint16_t phy_info_timer;        /* phy information timer */
+};
+
+enum {
+        DEVICE_STATE_OFF = 0,   /* this means hw_unavailable is != 0 */
+        DEVICE_STATE_PREBOOT,   /* we are in a pre-boot state (empty RAM) */
+        DEVICE_STATE_BOOT,      /* boot state (fw upload, run fw) */
+        DEVICE_STATE_PREINIT,   /* pre-init state */
+        DEVICE_STATE_INIT,      /* init state (restore MIB backup to device) */
+        DEVICE_STATE_READY,     /* driver&device are in operational state */
+        DEVICE_STATE_SLEEP      /* device in sleep mode */
+};
+
+/* SME flag */
+#define SME_MODE_SET        (1<<0)
+#define SME_RTS             (1<<1)
+#define SME_FRAG            (1<<2)
+#define SME_WEP_FLAG        (1<<3)
+#define SME_WEP_INDEX       (1<<4)
+#define SME_WEP_VAL1        (1<<5)
+#define SME_WEP_VAL2        (1<<6)
+#define SME_WEP_VAL3        (1<<7)
+#define SME_WEP_VAL4        (1<<8)
+#define SME_WEP_VAL_MASK    (SME_WEP_VAL1|SME_WEP_VAL2|SME_WEP_VAL3|SME_WEP_VAL4)
+#define SME_RSN             (1<<9)
+#define SME_RSN_MULTICAST   (1<<10)
+#define SME_RSN_UNICAST     (1<<11)
+#define SME_RSN_AUTH        (1<<12)
+
+#define SME_AP_SCAN         (1<<13)
+#define SME_MULTICAST       (1<<14)
+
+/* SME Event */
+enum {
+        SME_START,
+
+        SME_MULTICAST_REQUEST,
+        SME_MACADDRESS_SET_REQUEST,
+        SME_BSS_SCAN_REQUEST,
+        SME_SET_FLAG,
+        SME_SET_TXKEY,
+        SME_SET_KEY1,
+        SME_SET_KEY2,
+        SME_SET_KEY3,
+        SME_SET_KEY4,
+        SME_SET_PMK_TSC,
+        SME_SET_GMK1_TSC,
+        SME_SET_GMK2_TSC,
+        SME_SET_GMK3_TSC,
+        SME_SET_PMKSA,
+        SME_POW_MNGMT_REQUEST,
+        SME_PHY_INFO_REQUEST,
+        SME_MIC_FAILURE_REQUEST,
+        SME_GET_MAC_ADDRESS,
+        SME_GET_PRODUCT_VERSION,
+        SME_STOP_REQUEST,
+        SME_RTS_THRESHOLD_REQUEST,
+        SME_FRAGMENTATION_THRESHOLD_REQUEST,
+        SME_WEP_INDEX_REQUEST,
+        SME_WEP_KEY1_REQUEST,
+        SME_WEP_KEY2_REQUEST,
+        SME_WEP_KEY3_REQUEST,
+        SME_WEP_KEY4_REQUEST,
+        SME_WEP_FLAG_REQUEST,
+        SME_RSN_UCAST_REQUEST,
+        SME_RSN_MCAST_REQUEST,
+        SME_RSN_AUTH_REQUEST,
+        SME_RSN_ENABLED_REQUEST,
+        SME_RSN_MODE_REQUEST,
+#ifdef WPS
+        SME_WPS_ENABLE_REQUEST,
+        SME_WPS_PROBE_REQUEST,
+#endif
+        SME_SET_GAIN,
+        SME_GET_GAIN,
+        SME_SLEEP_REQUEST,
+        SME_SET_REGION,
+        SME_MODE_SET_REQUEST,
+        SME_START_REQUEST,
+        SME_GET_EEPROM_CKSUM,
+
+        SME_MIC_FAILURE_CONFIRM,
+        SME_START_CONFIRM,
+
+        SME_MULTICAST_CONFIRM,
+        SME_BSS_SCAN_CONFIRM,
+        SME_GET_CURRENT_AP,
+        SME_POW_MNGMT_CONFIRM,
+        SME_PHY_INFO_CONFIRM,
+        SME_STOP_CONFIRM,
+        SME_RTS_THRESHOLD_CONFIRM,
+        SME_FRAGMENTATION_THRESHOLD_CONFIRM,
+        SME_WEP_INDEX_CONFIRM,
+        SME_WEP_KEY1_CONFIRM,
+        SME_WEP_KEY2_CONFIRM,
+        SME_WEP_KEY3_CONFIRM,
+        SME_WEP_KEY4_CONFIRM,
+        SME_WEP_FLAG_CONFIRM,
+        SME_RSN_UCAST_CONFIRM,
+        SME_RSN_MCAST_CONFIRM,
+        SME_RSN_AUTH_CONFIRM,
+        SME_RSN_ENABLED_CONFIRM,
+        SME_RSN_MODE_CONFIRM,
+        SME_MODE_SET_CONFIRM,
+        SME_SLEEP_CONFIRM,
+
+        SME_RSN_SET_CONFIRM,
+        SME_WEP_SET_CONFIRM,
+        SME_TERMINATE,
+
+        SME_EVENT_SIZE  /* end */
+};
+
+/* SME Status */
+enum {
+        SME_IDLE,
+        SME_SETUP,
+        SME_DISCONNECT,
+        SME_CONNECT
+};
+
+#define SME_EVENT_BUFF_SIZE     128
+
+struct sme_info {
+        int sme_status;
+        int event_buff[SME_EVENT_BUFF_SIZE];
+        unsigned int qhead;
+        unsigned int qtail;
+#ifdef KS_WLAN_DEBUG
+        /* for debug */
+        unsigned int max_event_count;
+#endif
+        spinlock_t sme_spin;
+        unsigned long sme_flag;
+};
+
+struct hostt_t {
+        int buff[SME_EVENT_BUFF_SIZE];
+        unsigned int qhead;
+        unsigned int qtail;
+};
+
+#define RSN_IE_BODY_MAX 64
+struct rsn_ie_t {
+        uint8_t id;     /* 0xdd = WPA or 0x30 = RSN */
+        uint8_t size;   /* max ? 255 ? */
+        uint8_t body[RSN_IE_BODY_MAX];
+} __attribute__ ((packed));
+
+#ifdef WPS
+#define WPS_IE_BODY_MAX 255
+struct wps_ie_t {
+        uint8_t id;     /* 221 'dd <len> 00 50 F2 04' */
+        uint8_t size;   /* max ? 255 ? */
+        uint8_t body[WPS_IE_BODY_MAX];
+} __attribute__ ((packed));
+#endif /* WPS */
+
+struct local_ap_t {
+        uint8_t bssid[6];
+        uint8_t rssi;
+        uint8_t sq;
+        struct {
+                uint8_t size;
+                uint8_t body[32];
+                uint8_t ssid_pad;
+        } ssid;
+        struct {
+                uint8_t size;
+                uint8_t body[16];
+                uint8_t rate_pad;
+        } rate_set;
+        uint16_t capability;
+        uint8_t channel;
+        uint8_t noise;
+        struct rsn_ie_t wpa_ie;
+        struct rsn_ie_t rsn_ie;
+#ifdef WPS
+        struct wps_ie_t wps_ie;
+#endif /* WPS */
+};
+
+#define LOCAL_APLIST_MAX 31
+#define LOCAL_CURRENT_AP LOCAL_APLIST_MAX
+struct local_aplist_t {
+        int size;
+        struct local_ap_t ap[LOCAL_APLIST_MAX + 1];
+};
+
+struct local_gain_t {
+        uint8_t TxMode;
+        uint8_t RxMode;
+        uint8_t TxGain;
+        uint8_t RxGain;
+};
+
+struct local_eeprom_sum_t {
+        uint8_t type;
+        uint8_t result;
+};
+
+enum {
+        EEPROM_OK,
+        EEPROM_CHECKSUM_NONE,
+        EEPROM_FW_NOT_SUPPORT,
+        EEPROM_NG,
+};
+
+/* Power Save Status */
+enum {
+        PS_NONE,
+        PS_ACTIVE_SET,
+        PS_SAVE_SET,
+        PS_CONF_WAIT,
+        PS_SNOOZE,
+        PS_WAKEUP
+};
+
+struct power_save_status_t {
+        atomic_t status;        /* initialvalue 0 */
+        struct completion wakeup_wait;
+        atomic_t confirm_wait;
+        atomic_t snooze_guard;
+};
+
+struct sleep_status_t {
+        atomic_t status;        /* initialvalue 0 */
+        atomic_t doze_request;
+        atomic_t wakeup_request;
+};
+
+/* WPA */
+struct scan_ext_t {
+        unsigned int flag;
+        char ssid[IW_ESSID_MAX_SIZE + 1];
+};
+
+enum {
+        CIPHER_NONE,
+        CIPHER_WEP40,
+        CIPHER_TKIP,
+        CIPHER_CCMP,
+        CIPHER_WEP104
+};
+
+#define CIPHER_ID_WPA_NONE    "\x00\x50\xf2\x00"
+#define CIPHER_ID_WPA_WEP40   "\x00\x50\xf2\x01"
+#define CIPHER_ID_WPA_TKIP    "\x00\x50\xf2\x02"
+#define CIPHER_ID_WPA_CCMP    "\x00\x50\xf2\x04"
+#define CIPHER_ID_WPA_WEP104  "\x00\x50\xf2\x05"
+
+#define CIPHER_ID_WPA2_NONE   "\x00\x0f\xac\x00"
+#define CIPHER_ID_WPA2_WEP40  "\x00\x0f\xac\x01"
+#define CIPHER_ID_WPA2_TKIP   "\x00\x0f\xac\x02"
+#define CIPHER_ID_WPA2_CCMP   "\x00\x0f\xac\x04"
+#define CIPHER_ID_WPA2_WEP104 "\x00\x0f\xac\x05"
+
+#define CIPHER_ID_LEN    4
+
+enum {
+        KEY_MGMT_802_1X,
+        KEY_MGMT_PSK,
+        KEY_MGMT_WPANONE,
+};
+
+#define KEY_MGMT_ID_WPA_NONE     "\x00\x50\xf2\x00"
+#define KEY_MGMT_ID_WPA_1X       "\x00\x50\xf2\x01"
+#define KEY_MGMT_ID_WPA_PSK      "\x00\x50\xf2\x02"
+#define KEY_MGMT_ID_WPA_WPANONE  "\x00\x50\xf2\xff"
+
+#define KEY_MGMT_ID_WPA2_NONE    "\x00\x0f\xac\x00"
+#define KEY_MGMT_ID_WPA2_1X      "\x00\x0f\xac\x01"
+#define KEY_MGMT_ID_WPA2_PSK     "\x00\x0f\xac\x02"
+#define KEY_MGMT_ID_WPA2_WPANONE "\x00\x0f\xac\xff"
+
+#define KEY_MGMT_ID_LEN  4
+
+#define MIC_KEY_SIZE 8
+
+struct wpa_key_t {
+        uint32_t ext_flags;     /* IW_ENCODE_EXT_xxx */
+        uint8_t tx_seq[IW_ENCODE_SEQ_MAX_SIZE]; /* LSB first */
+        uint8_t rx_seq[IW_ENCODE_SEQ_MAX_SIZE]; /* LSB first */
+        struct sockaddr addr;   /* ff:ff:ff:ff:ff:ff for broadcast/multicast
+                                 * (group) keys or unicast address for
+                                 * individual keys */
+        uint16_t alg;
+        uint16_t key_len;       /* WEP: 5 or 13, TKIP: 32, CCMP: 16 */
+        uint8_t key_val[IW_ENCODING_TOKEN_MAX];
+        uint8_t tx_mic_key[MIC_KEY_SIZE];
+        uint8_t rx_mic_key[MIC_KEY_SIZE];
+};
+#define WPA_KEY_INDEX_MAX 4
+#define WPA_RX_SEQ_LEN 6
+
+struct mic_failure_t {
+        uint16_t failure;       /* MIC Failure counter 0 or 1 or 2 */
+        uint16_t counter;       /* 1sec counter 0-60 */
+        uint32_t last_failure_time;
+        int stop;       /* stop flag */
+};
+
+struct wpa_status_t {
+        int wpa_enabled;
+        unsigned int rsn_enabled;
+        int version;
+        int pairwise_suite;     /* unicast cipher */
+        int group_suite;        /* multicast cipher */
+        int key_mgmt_suite;     /* authentication key management suite */
+        int auth_alg;
+        int txkey;
+        struct wpa_key_t key[WPA_KEY_INDEX_MAX];
+        struct scan_ext_t scan_ext;
+        struct mic_failure_t mic_failure;
+};
+
+#include <linux/list.h>
+#define PMK_LIST_MAX 8
+struct pmk_list_t {
+        uint16_t size;
+        struct list_head head;
+        struct pmk_t {
+                struct list_head list;
+                uint8_t bssid[ETH_ALEN];
+                uint8_t pmkid[IW_PMKID_LEN];
+        } pmk[PMK_LIST_MAX];
+};
+
+#ifdef WPS
+struct wps_status_t {
+        int wps_enabled;
+        int ielen;
+        uint8_t ie[255];
+};
+#endif /* WPS */
+
+struct ks_wlan_private {
+
+        struct hw_info_t ks_wlan_hw;    /* hardware information */
+
+        struct net_device *net_dev;
+        int reg_net;    /* register_netdev */
+        struct net_device_stats nstats;
+        struct iw_statistics wstats;
+
+        struct completion confirm_wait;
+
+        /* trx device & sme */
+        struct tx_device tx_dev;
+        struct rx_device rx_dev;
+        struct sme_info sme_i;
+        u8 *rxp;
+        unsigned int rx_size;
+        struct tasklet_struct sme_task;
+        struct work_struct ks_wlan_wakeup_task;
+        int scan_ind_count;
+
+        unsigned char eth_addr[ETH_ALEN];
+
+        struct local_aplist_t aplist;
+        struct local_ap_t current_ap;
+        struct power_save_status_t psstatus;
+        struct sleep_status_t sleepstatus;
+        struct wpa_status_t wpa;
+        struct pmk_list_t pmklist;
+        /* wireless parameter */
+        struct ks_wlan_parameter reg;
+        uint8_t current_rate;
+
+        char nick[IW_ESSID_MAX_SIZE + 1];
+
+        spinlock_t multicast_spin;
+
+        spinlock_t dev_read_lock;
+        wait_queue_head_t devread_wait;
+
+        unsigned int need_commit;       /* for ioctl */
+
+        /* DeviceIoControl */
+        int device_open_status;
+        atomic_t event_count;
+        atomic_t rec_count;
+        int dev_count;
+#define DEVICE_STOCK_COUNT 20
+        unsigned char *dev_data[DEVICE_STOCK_COUNT];
+        int dev_size[DEVICE_STOCK_COUNT];
+
+        /* ioctl : IOCTL_FIRMWARE_VERSION */
+        unsigned char firmware_version[128 + 1];
+        int version_size;
+
+        int mac_address_valid;  /* Mac Address Status */
+
+        int dev_state;
+
+        struct sk_buff *skb;
+        unsigned int cur_rx;    /* Index into the Rx buffer of next Rx pkt. */
+        /* spinlock_t lock; */
+#define FORCE_DISCONNECT    0x80000000
+#define CONNECT_STATUS_MASK 0x7FFFFFFF
+        uint32_t connect_status;        /* connect status */
+        int infra_status;       /* Infractructure status */
+
+        uint8_t data_buff[0x1000];
+
+        uint8_t scan_ssid_len;
+        uint8_t scan_ssid[IW_ESSID_MAX_SIZE + 1];
+        struct local_gain_t gain;
+#ifdef WPS
+        struct net_device *l2_dev;
+        int l2_fd;
+        struct wps_status_t wps;
+#endif /* WPS */
+        uint8_t sleep_mode;
+
+        uint8_t region;
+        struct local_eeprom_sum_t eeprom_sum;
+        uint8_t eeprom_checksum;
+
+        struct hostt_t hostt;
+
+        unsigned long last_doze;
+        unsigned long last_wakeup;
+
+        uint wakeup_count;      /* for detect wakeup loop */
+};
+
+extern int ks_wlan_net_start(struct net_device *dev);
+extern int ks_wlan_net_stop(struct net_device *dev);
+
+#endif /* _KS_WLAN_H */
diff --git a/drivers/staging/ks7010/ks_wlan_ioctl.h b/drivers/staging/ks7010/ks_wlan_ioctl.h
new file mode 100644
index 000000000000..49369e497808
--- /dev/null
+++ b/drivers/staging/ks7010/ks_wlan_ioctl.h
@@ -0,0 +1,67 @@
+/*
+ *   Driver for KeyStream 11b/g wireless LAN
+ *   
+ *   Copyright (c) 2005-2008 KeyStream Corp.
+ *   Copyright (C) 2009 Renesas Technology Corp.
+ *
+ *   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.
+ */
+
+#ifndef _KS_WLAN_IOCTL_H
+#define _KS_WLAN_IOCTL_H
+
+#include <linux/wireless.h>
+/* The low order bit identify a SET (0) or a GET (1) ioctl.  */
+
+/*                                      SIOCIWFIRSTPRIV+0 */
+/* former KS_WLAN_GET_DRIVER_VERSION    SIOCIWFIRSTPRIV+1 */
+/*                                      SIOCIWFIRSTPRIV+2 */
+#define KS_WLAN_GET_FIRM_VERSION        SIOCIWFIRSTPRIV+3
+#ifdef WPS
+#define KS_WLAN_SET_WPS_ENABLE          SIOCIWFIRSTPRIV+4
+#define KS_WLAN_GET_WPS_ENABLE          SIOCIWFIRSTPRIV+5
+#define KS_WLAN_SET_WPS_PROBE_REQ       SIOCIWFIRSTPRIV+6
+#endif
+#define KS_WLAN_GET_EEPROM_CKSUM        SIOCIWFIRSTPRIV+7
+#define KS_WLAN_SET_PREAMBLE            SIOCIWFIRSTPRIV+8
+#define KS_WLAN_GET_PREAMBLE            SIOCIWFIRSTPRIV+9
+#define KS_WLAN_SET_POWER_SAVE          SIOCIWFIRSTPRIV+10
+#define KS_WLAN_GET_POWER_SAVE          SIOCIWFIRSTPRIV+11
+#define KS_WLAN_SET_SCAN_TYPE           SIOCIWFIRSTPRIV+12
+#define KS_WLAN_GET_SCAN_TYPE           SIOCIWFIRSTPRIV+13
+#define KS_WLAN_SET_RX_GAIN             SIOCIWFIRSTPRIV+14
+#define KS_WLAN_GET_RX_GAIN             SIOCIWFIRSTPRIV+15
+#define KS_WLAN_HOSTT                   SIOCIWFIRSTPRIV+16      /* unused */
+//#define KS_WLAN_SET_REGION            SIOCIWFIRSTPRIV+17
+#define KS_WLAN_SET_BEACON_LOST         SIOCIWFIRSTPRIV+18
+#define KS_WLAN_GET_BEACON_LOST         SIOCIWFIRSTPRIV+19
+
+#define KS_WLAN_SET_TX_GAIN             SIOCIWFIRSTPRIV+20
+#define KS_WLAN_GET_TX_GAIN             SIOCIWFIRSTPRIV+21
+
+/* for KS7010 */
+#define KS_WLAN_SET_PHY_TYPE            SIOCIWFIRSTPRIV+22
+#define KS_WLAN_GET_PHY_TYPE            SIOCIWFIRSTPRIV+23
+#define KS_WLAN_SET_CTS_MODE            SIOCIWFIRSTPRIV+24
+#define KS_WLAN_GET_CTS_MODE            SIOCIWFIRSTPRIV+25
+/*                                      SIOCIWFIRSTPRIV+26 */
+/*                                      SIOCIWFIRSTPRIV+27 */
+#define KS_WLAN_SET_SLEEP_MODE          SIOCIWFIRSTPRIV+28      /* sleep mode */
+#define KS_WLAN_GET_SLEEP_MODE          SIOCIWFIRSTPRIV+29      /* sleep mode */
+/*                                      SIOCIWFIRSTPRIV+30 */
+/*                                      SIOCIWFIRSTPRIV+31 */
+
+#ifdef __KERNEL__
+
+#include "ks_wlan.h"
+#include <linux/netdevice.h>
+
+extern int ks_wlan_read_config_file(struct ks_wlan_private *priv);
+extern int ks_wlan_setup_parameter(struct ks_wlan_private *priv,
+                                   unsigned int commit_flag);
+
+#endif /* __KERNEL__ */
+
+#endif /* _KS_WLAN_IOCTL_H */
diff --git a/drivers/staging/ks7010/ks_wlan_net.c b/drivers/staging/ks7010/ks_wlan_net.c
new file mode 100644
index 000000000000..1e21eb1c4667
--- /dev/null
+++ b/drivers/staging/ks7010/ks_wlan_net.c
@@ -0,0 +1,3528 @@
+/*
+ *   Driver for KeyStream 11b/g wireless LAN
+ *
+ *   Copyright (C) 2005-2008 KeyStream Corp.
+ *   Copyright (C) 2009 Renesas Technology Corp.
+ *
+ *   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.
+ */
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/compiler.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/if_arp.h>
+#include <linux/rtnetlink.h>
+#include <linux/delay.h>
+#include <linux/completion.h>
+#include <linux/mii.h>
+#include <linux/pci.h>
+#include <linux/ctype.h>
+#include <linux/timer.h>
+#include <asm/atomic.h>
+#include <linux/io.h>
+#include <asm/uaccess.h>
+
+static int wep_on_off;
+#define WEP_OFF         0
+#define WEP_ON_64BIT    1
+#define WEP_ON_128BIT   2
+
+#include "ks_wlan.h"
+#include "ks_hostif.h"
+#include "ks_wlan_ioctl.h"
+
+/* Include Wireless Extension definition and check version */
+#include <linux/wireless.h>
+#define WIRELESS_SPY    /* enable iwspy support */
+#include <net/iw_handler.h>     /* New driver API */
+
+/* Frequency list (map channels to frequencies) */
+static const long frequency_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
+        2447, 2452, 2457, 2462, 2467, 2472, 2484
+};
+
+/* A few details needed for WEP (Wireless Equivalent Privacy) */
+#define MAX_KEY_SIZE 13 /* 128 (?) bits */
+#define MIN_KEY_SIZE  5 /* 40 bits RC4 - WEP */
+typedef struct wep_key_t {
+        u16 len;
+        u8 key[16];     /* 40-bit and 104-bit keys */
+} wep_key_t;
+
+/* Backward compatibility */
+#ifndef IW_ENCODE_NOKEY
+#define IW_ENCODE_NOKEY 0x0800  /* Key is write only, so not present */
+#define IW_ENCODE_MODE  (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
+#endif /* IW_ENCODE_NOKEY */
+
+/* List of Wireless Handlers (new API) */
+static const struct iw_handler_def ks_wlan_handler_def;
+
+#define KSC_OPNOTSUPP   /* Operation Not Support */
+
+/*
+ *      function prototypes
+ */
+extern int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p,
+                         unsigned long size,
+                         void (*complete_handler) (void *arg1, void *arg2),
+                         void *arg1, void *arg2);
+static int ks_wlan_open(struct net_device *dev);
+static void ks_wlan_tx_timeout(struct net_device *dev);
+static int ks_wlan_start_xmit(struct sk_buff *skb, struct net_device *dev);
+static int ks_wlan_close(struct net_device *dev);
+static void ks_wlan_set_multicast_list(struct net_device *dev);
+static struct net_device_stats *ks_wlan_get_stats(struct net_device *dev);
+static int ks_wlan_set_mac_address(struct net_device *dev, void *addr);
+static int ks_wlan_netdev_ioctl(struct net_device *dev, struct ifreq *rq,
+                                int cmd);
+
+static atomic_t update_phyinfo;
+static struct timer_list update_phyinfo_timer;
+static
+int ks_wlan_update_phy_information(struct ks_wlan_private *priv)
+{
+        struct iw_statistics *wstats = &priv->wstats;
+
+        DPRINTK(4, "in_interrupt = %ld\n", in_interrupt());
+
+        if (priv->dev_state < DEVICE_STATE_READY) {
+                return -1;      /* not finished initialize */
+        }
+        if (atomic_read(&update_phyinfo))
+                return 1;
+
+        /* The status */
+        wstats->status = priv->reg.operation_mode;      /* Operation mode */
+
+        /* Signal quality and co. But where is the noise level ??? */
+        hostif_sme_enqueue(priv, SME_PHY_INFO_REQUEST);
+
+        /* interruptible_sleep_on_timeout(&priv->confirm_wait, HZ/2); */
+        if (!wait_for_completion_interruptible_timeout
+            (&priv->confirm_wait, HZ / 2)) {
+                DPRINTK(1, "wait time out!!\n");
+        }
+
+        atomic_inc(&update_phyinfo);
+        update_phyinfo_timer.expires = jiffies + HZ;    /* 1sec */
+        add_timer(&update_phyinfo_timer);
+
+        return 0;
+}
+
+static
+void ks_wlan_update_phyinfo_timeout(unsigned long ptr)
+{
+        DPRINTK(4, "in_interrupt = %ld\n", in_interrupt());
+        atomic_set(&update_phyinfo, 0);
+}
+
+int ks_wlan_setup_parameter(struct ks_wlan_private *priv,
+                            unsigned int commit_flag)
+{
+        DPRINTK(2, "\n");
+
+        hostif_sme_enqueue(priv, SME_STOP_REQUEST);
+
+        if (commit_flag & SME_RTS)
+                hostif_sme_enqueue(priv, SME_RTS_THRESHOLD_REQUEST);
+        if (commit_flag & SME_FRAG)
+                hostif_sme_enqueue(priv, SME_FRAGMENTATION_THRESHOLD_REQUEST);
+
+        if (commit_flag & SME_WEP_INDEX)
+                hostif_sme_enqueue(priv, SME_WEP_INDEX_REQUEST);
+        if (commit_flag & SME_WEP_VAL1)
+                hostif_sme_enqueue(priv, SME_WEP_KEY1_REQUEST);
+        if (commit_flag & SME_WEP_VAL2)
+                hostif_sme_enqueue(priv, SME_WEP_KEY2_REQUEST);
+        if (commit_flag & SME_WEP_VAL3)
+                hostif_sme_enqueue(priv, SME_WEP_KEY3_REQUEST);
+        if (commit_flag & SME_WEP_VAL4)
+                hostif_sme_enqueue(priv, SME_WEP_KEY4_REQUEST);
+        if (commit_flag & SME_WEP_FLAG)
+                hostif_sme_enqueue(priv, SME_WEP_FLAG_REQUEST);
+
+        if (commit_flag & SME_RSN) {
+                hostif_sme_enqueue(priv, SME_RSN_ENABLED_REQUEST);
+                hostif_sme_enqueue(priv, SME_RSN_MODE_REQUEST);
+        }
+        if (commit_flag & SME_RSN_MULTICAST)
+                hostif_sme_enqueue(priv, SME_RSN_MCAST_REQUEST);
+        if (commit_flag & SME_RSN_UNICAST)
+                hostif_sme_enqueue(priv, SME_RSN_UCAST_REQUEST);
+        if (commit_flag & SME_RSN_AUTH)
+                hostif_sme_enqueue(priv, SME_RSN_AUTH_REQUEST);
+
+        hostif_sme_enqueue(priv, SME_MODE_SET_REQUEST);
+
+        hostif_sme_enqueue(priv, SME_START_REQUEST);
+
+        return 0;
+}
+
+/*
+ * Initial Wireless Extension code for Ks_Wlannet driver by :
+ *      Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
+ * Conversion to new driver API by :
+ *      Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
+ * Javier also did a good amount of work here, adding some new extensions
+ * and fixing my code. Let's just say that without him this code just
+ * would not work at all... - Jean II
+ */
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get protocol name */
+static int ks_wlan_get_name(struct net_device *dev,
+                            struct iw_request_info *info, char *cwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (priv->dev_state < DEVICE_STATE_READY) {
+                strcpy(cwrq, "NOT READY!");
+        } else if (priv->reg.phy_type == D_11B_ONLY_MODE) {
+                strcpy(cwrq, "IEEE 802.11b");
+        } else if (priv->reg.phy_type == D_11G_ONLY_MODE) {
+                strcpy(cwrq, "IEEE 802.11g");
+        } else {
+                strcpy(cwrq, "IEEE 802.11b/g");
+        }
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set frequency */
+static int ks_wlan_set_freq(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_freq *fwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        int rc = -EINPROGRESS;  /* Call commit handler */
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /* If setting by frequency, convert to a channel */
+        if ((fwrq->e == 1) &&
+            (fwrq->m >= (int)2.412e8) && (fwrq->m <= (int)2.487e8)) {
+                int f = fwrq->m / 100000;
+                int c = 0;
+                while ((c < 14) && (f != frequency_list[c]))
+                        c++;
+                /* Hack to fall through... */
+                fwrq->e = 0;
+                fwrq->m = c + 1;
+        }
+        /* Setting by channel number */
+        if ((fwrq->m > 1000) || (fwrq->e > 0))
+                rc = -EOPNOTSUPP;
+        else {
+                int channel = fwrq->m;
+                /* We should do a better check than that,
+                 * based on the card capability !!! */
+                if ((channel < 1) || (channel > 14)) {
+                        printk(KERN_DEBUG
+                               "%s: New channel value of %d is invalid!\n",
+                               dev->name, fwrq->m);
+                        rc = -EINVAL;
+                } else {
+                        /* Yes ! We can set it !!! */
+                        priv->reg.channel = (u8) (channel);
+                        priv->need_commit |= SME_MODE_SET;
+                }
+        }
+
+        return rc;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get frequency */
+static int ks_wlan_get_freq(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_freq *fwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        int f;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+                f = (int)priv->current_ap.channel;
+        } else
+                f = (int)priv->reg.channel;
+        fwrq->m = frequency_list[f - 1] * 100000;
+        fwrq->e = 1;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set ESSID */
+static int ks_wlan_set_essid(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        size_t len;
+
+        DPRINTK(2, " %d\n", dwrq->flags);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /* Check if we asked for `any' */
+        if (dwrq->flags == 0) {
+                /* Just send an empty SSID list */
+                memset(priv->reg.ssid.body, 0, sizeof(priv->reg.ssid.body));
+                priv->reg.ssid.size = 0;
+        } else {
+#if 1
+                len = dwrq->length;
+                /* iwconfig uses nul termination in SSID.. */
+                if (len > 0 && extra[len - 1] == '\0')
+                        len--;
+
+                /* Check the size of the string */
+                if (len > IW_ESSID_MAX_SIZE) {
+                        return -EINVAL;
+                }
+#else
+                /* Check the size of the string */
+                if (dwrq->length > IW_ESSID_MAX_SIZE + 1) {
+                        return -E2BIG;
+                }
+#endif
+
+                /* Set the SSID */
+                memset(priv->reg.ssid.body, 0, sizeof(priv->reg.ssid.body));
+
+#if 1
+                memcpy(priv->reg.ssid.body, extra, len);
+                priv->reg.ssid.size = len;
+#else
+                memcpy(priv->reg.ssid.body, extra, dwrq->length);
+                priv->reg.ssid.size = dwrq->length;
+#endif
+        }
+        /* Write it to the card */
+        priv->need_commit |= SME_MODE_SET;
+
+//      return  -EINPROGRESS;   /* Call commit handler */
+        ks_wlan_setup_parameter(priv, priv->need_commit);
+        priv->need_commit = 0;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get ESSID */
+static int ks_wlan_get_essid(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /* Note : if dwrq->flags != 0, we should
+         * get the relevant SSID from the SSID list... */
+        if (priv->reg.ssid.size) {
+                /* Get the current SSID */
+                memcpy(extra, priv->reg.ssid.body, priv->reg.ssid.size);
+#if 0
+                extra[priv->reg.ssid.size] = '\0';
+#endif
+                /* If none, we may want to get the one that was set */
+
+                /* Push it out ! */
+#if 1
+                dwrq->length = priv->reg.ssid.size;
+#else
+                dwrq->length = priv->reg.ssid.size + 1;
+#endif
+                dwrq->flags = 1;        /* active */
+        } else {
+#if 1
+                dwrq->length = 0;
+#else
+                extra[0] = '\0';
+                dwrq->length = 1;
+#endif
+                dwrq->flags = 0;        /* ANY */
+        }
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set AP address */
+static int ks_wlan_set_wap(struct net_device *dev, struct iw_request_info *info,
+                           struct sockaddr *ap_addr, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (priv->reg.operation_mode == MODE_ADHOC ||
+            priv->reg.operation_mode == MODE_INFRASTRUCTURE) {
+                memcpy(priv->reg.bssid, (u8 *) & ap_addr->sa_data, ETH_ALEN);
+
+                if (is_valid_ether_addr((u8 *) priv->reg.bssid)) {
+                        priv->need_commit |= SME_MODE_SET;
+                }
+        } else {
+                memset(priv->reg.bssid, 0x0, ETH_ALEN);
+                return -EOPNOTSUPP;
+        }
+
+        DPRINTK(2, "bssid = %02x:%02x:%02x:%02x:%02x:%02x\n",
+                priv->reg.bssid[0], priv->reg.bssid[1], priv->reg.bssid[2],
+                priv->reg.bssid[3], priv->reg.bssid[4], priv->reg.bssid[5]);
+
+        /* Write it to the card */
+        if (priv->need_commit) {
+                priv->need_commit |= SME_MODE_SET;
+                return -EINPROGRESS;    /* Call commit handler */
+        }
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get AP address */
+static int ks_wlan_get_wap(struct net_device *dev, struct iw_request_info *info,
+                           struct sockaddr *awrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+                memcpy(awrq->sa_data, &(priv->current_ap.bssid[0]), ETH_ALEN);
+        } else {
+                memset(awrq->sa_data, 0, ETH_ALEN);
+        }
+
+        awrq->sa_family = ARPHRD_ETHER;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set Nickname */
+static int ks_wlan_set_nick(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_point *dwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /* Check the size of the string */
+        if (dwrq->length > 16 + 1) {
+                return -E2BIG;
+        }
+        memset(priv->nick, 0, sizeof(priv->nick));
+        memcpy(priv->nick, extra, dwrq->length);
+
+        return -EINPROGRESS;    /* Call commit handler */
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get Nickname */
+static int ks_wlan_get_nick(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_point *dwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        strncpy(extra, priv->nick, 16);
+        extra[16] = '\0';
+        dwrq->length = strlen(extra) + 1;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set Bit-Rate */
+static int ks_wlan_set_rate(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_param *vwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        int i = 0;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (priv->reg.phy_type == D_11B_ONLY_MODE) {
+                if (vwrq->fixed == 1) {
+                        switch (vwrq->value) {
+                        case 11000000:
+                        case 5500000:
+                                priv->reg.rate_set.body[0] =
+                                    (uint8_t) (vwrq->value / 500000);
+                                break;
+                        case 2000000:
+                        case 1000000:
+                                priv->reg.rate_set.body[0] =
+                                    ((uint8_t) (vwrq->value / 500000)) |
+                                    BASIC_RATE;
+                                break;
+                        default:
+                                return -EINVAL;
+                        }
+                        priv->reg.tx_rate = TX_RATE_FIXED;
+                        priv->reg.rate_set.size = 1;
+                } else {        /* vwrq->fixed == 0 */
+                        if (vwrq->value > 0) {
+                                switch (vwrq->value) {
+                                case 11000000:
+                                        priv->reg.rate_set.body[3] =
+                                            TX_RATE_11M;
+                                        i++;
+                                case 5500000:
+                                        priv->reg.rate_set.body[2] = TX_RATE_5M;
+                                        i++;
+                                case 2000000:
+                                        priv->reg.rate_set.body[1] =
+                                            TX_RATE_2M | BASIC_RATE;
+                                        i++;
+                                case 1000000:
+                                        priv->reg.rate_set.body[0] =
+                                            TX_RATE_1M | BASIC_RATE;
+                                        i++;
+                                        break;
+                                default:
+                                        return -EINVAL;
+                                }
+                                priv->reg.tx_rate = TX_RATE_MANUAL_AUTO;
+                                priv->reg.rate_set.size = i;
+                        } else {
+                                priv->reg.rate_set.body[3] = TX_RATE_11M;
+                                priv->reg.rate_set.body[2] = TX_RATE_5M;
+                                priv->reg.rate_set.body[1] =
+                                    TX_RATE_2M | BASIC_RATE;
+                                priv->reg.rate_set.body[0] =
+                                    TX_RATE_1M | BASIC_RATE;
+                                priv->reg.tx_rate = TX_RATE_FULL_AUTO;
+                                priv->reg.rate_set.size = 4;
+                        }
+                }
+        } else {        /* D_11B_ONLY_MODE or  D_11BG_COMPATIBLE_MODE */
+                if (vwrq->fixed == 1) {
+                        switch (vwrq->value) {
+                        case 54000000:
+                        case 48000000:
+                        case 36000000:
+                        case 18000000:
+                        case 9000000:
+                                priv->reg.rate_set.body[0] =
+                                    (uint8_t) (vwrq->value / 500000);
+                                break;
+                        case 24000000:
+                        case 12000000:
+                        case 11000000:
+                        case 6000000:
+                        case 5500000:
+                        case 2000000:
+                        case 1000000:
+                                priv->reg.rate_set.body[0] =
+                                    ((uint8_t) (vwrq->value / 500000)) |
+                                    BASIC_RATE;
+                                break;
+                        default:
+                                return -EINVAL;
+                        }
+                        priv->reg.tx_rate = TX_RATE_FIXED;
+                        priv->reg.rate_set.size = 1;
+                } else {        /* vwrq->fixed == 0 */
+                        if (vwrq->value > 0) {
+                                switch (vwrq->value) {
+                                case 54000000:
+                                        priv->reg.rate_set.body[11] =
+                                            TX_RATE_54M;
+                                        i++;
+                                case 48000000:
+                                        priv->reg.rate_set.body[10] =
+                                            TX_RATE_48M;
+                                        i++;
+                                case 36000000:
+                                        priv->reg.rate_set.body[9] =
+                                            TX_RATE_36M;
+                                        i++;
+                                case 24000000:
+                                case 18000000:
+                                case 12000000:
+                                case 11000000:
+                                case 9000000:
+                                case 6000000:
+                                        if (vwrq->value == 24000000) {
+                                                priv->reg.rate_set.body[8] =
+                                                    TX_RATE_18M;
+                                                i++;
+                                                priv->reg.rate_set.body[7] =
+                                                    TX_RATE_9M;
+                                                i++;
+                                                priv->reg.rate_set.body[6] =
+                                                    TX_RATE_24M | BASIC_RATE;
+                                                i++;
+                                                priv->reg.rate_set.body[5] =
+                                                    TX_RATE_12M | BASIC_RATE;
+                                                i++;
+                                                priv->reg.rate_set.body[4] =
+                                                    TX_RATE_6M | BASIC_RATE;
+                                                i++;
+                                                priv->reg.rate_set.body[3] =
+                                                    TX_RATE_11M | BASIC_RATE;
+                                                i++;
+                                        } else if (vwrq->value == 18000000) {
+                                                priv->reg.rate_set.body[7] =
+                                                    TX_RATE_18M;
+                                                i++;
+                                                priv->reg.rate_set.body[6] =
+                                                    TX_RATE_9M;
+                                                i++;
+                                                priv->reg.rate_set.body[5] =
+                                                    TX_RATE_12M | BASIC_RATE;
+                                                i++;
+                                                priv->reg.rate_set.body[4] =
+                                                    TX_RATE_6M | BASIC_RATE;
+                                                i++;
+                                                priv->reg.rate_set.body[3] =
+                                                    TX_RATE_11M | BASIC_RATE;
+                                                i++;
+                                        } else if (vwrq->value == 12000000) {
+                                                priv->reg.rate_set.body[6] =
+                                                    TX_RATE_9M;
+                                                i++;
+                                                priv->reg.rate_set.body[5] =
+                                                    TX_RATE_12M | BASIC_RATE;
+                                                i++;
+                                                priv->reg.rate_set.body[4] =
+                                                    TX_RATE_6M | BASIC_RATE;
+                                                i++;
+                                                priv->reg.rate_set.body[3] =
+                                                    TX_RATE_11M | BASIC_RATE;
+                                                i++;
+                                        } else if (vwrq->value == 11000000) {
+                                                priv->reg.rate_set.body[5] =
+                                                    TX_RATE_9M;
+                                                i++;
+                                                priv->reg.rate_set.body[4] =
+                                                    TX_RATE_6M | BASIC_RATE;
+                                                i++;
+                                                priv->reg.rate_set.body[3] =
+                                                    TX_RATE_11M | BASIC_RATE;
+                                                i++;
+                                        } else if (vwrq->value == 9000000) {
+                                                priv->reg.rate_set.body[4] =
+                                                    TX_RATE_9M;
+                                                i++;
+                                                priv->reg.rate_set.body[3] =
+                                                    TX_RATE_6M | BASIC_RATE;
+                                                i++;
+                                        } else {        /* vwrq->value == 6000000 */
+                                                priv->reg.rate_set.body[3] =
+                                                    TX_RATE_6M | BASIC_RATE;
+                                                i++;
+                                        }
+                                case 5500000:
+                                        priv->reg.rate_set.body[2] =
+                                            TX_RATE_5M | BASIC_RATE;
+                                        i++;
+                                case 2000000:
+                                        priv->reg.rate_set.body[1] =
+                                            TX_RATE_2M | BASIC_RATE;
+                                        i++;
+                                case 1000000:
+                                        priv->reg.rate_set.body[0] =
+                                            TX_RATE_1M | BASIC_RATE;
+                                        i++;
+                                        break;
+                                default:
+                                        return -EINVAL;
+                                }
+                                priv->reg.tx_rate = TX_RATE_MANUAL_AUTO;
+                                priv->reg.rate_set.size = i;
+                        } else {
+                                priv->reg.rate_set.body[11] = TX_RATE_54M;
+                                priv->reg.rate_set.body[10] = TX_RATE_48M;
+                                priv->reg.rate_set.body[9] = TX_RATE_36M;
+                                priv->reg.rate_set.body[8] = TX_RATE_18M;
+                                priv->reg.rate_set.body[7] = TX_RATE_9M;
+                                priv->reg.rate_set.body[6] =
+                                    TX_RATE_24M | BASIC_RATE;
+                                priv->reg.rate_set.body[5] =
+                                    TX_RATE_12M | BASIC_RATE;
+                                priv->reg.rate_set.body[4] =
+                                    TX_RATE_6M | BASIC_RATE;
+                                priv->reg.rate_set.body[3] =
+                                    TX_RATE_11M | BASIC_RATE;
+                                priv->reg.rate_set.body[2] =
+                                    TX_RATE_5M | BASIC_RATE;
+                                priv->reg.rate_set.body[1] =
+                                    TX_RATE_2M | BASIC_RATE;
+                                priv->reg.rate_set.body[0] =
+                                    TX_RATE_1M | BASIC_RATE;
+                                priv->reg.tx_rate = TX_RATE_FULL_AUTO;
+                                priv->reg.rate_set.size = 12;
+                        }
+                }
+        }
+
+        priv->need_commit |= SME_MODE_SET;
+
+        return -EINPROGRESS;    /* Call commit handler */
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get Bit-Rate */
+static int ks_wlan_get_rate(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_param *vwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        DPRINTK(2, "in_interrupt = %ld update_phyinfo = %d\n",
+                in_interrupt(), atomic_read(&update_phyinfo));
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (!atomic_read(&update_phyinfo)) {
+                ks_wlan_update_phy_information(priv);
+        }
+        vwrq->value = ((priv->current_rate) & RATE_MASK) * 500000;
+        if (priv->reg.tx_rate == TX_RATE_FIXED)
+                vwrq->fixed = 1;
+        else
+                vwrq->fixed = 0;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set RTS threshold */
+static int ks_wlan_set_rts(struct net_device *dev, struct iw_request_info *info,
+                           struct iw_param *vwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        int rthr = vwrq->value;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (vwrq->disabled)
+                rthr = 2347;
+        if ((rthr < 0) || (rthr > 2347)) {
+                return -EINVAL;
+        }
+        priv->reg.rts = rthr;
+        priv->need_commit |= SME_RTS;
+
+        return -EINPROGRESS;    /* Call commit handler */
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get RTS threshold */
+static int ks_wlan_get_rts(struct net_device *dev, struct iw_request_info *info,
+                           struct iw_param *vwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        vwrq->value = priv->reg.rts;
+        vwrq->disabled = (vwrq->value >= 2347);
+        vwrq->fixed = 1;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set Fragmentation threshold */
+static int ks_wlan_set_frag(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_param *vwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        int fthr = vwrq->value;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (vwrq->disabled)
+                fthr = 2346;
+        if ((fthr < 256) || (fthr > 2346)) {
+                return -EINVAL;
+        }
+        fthr &= ~0x1;   /* Get an even value - is it really needed ??? */
+        priv->reg.fragment = fthr;
+        priv->need_commit |= SME_FRAG;
+
+        return -EINPROGRESS;    /* Call commit handler */
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get Fragmentation threshold */
+static int ks_wlan_get_frag(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_param *vwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        vwrq->value = priv->reg.fragment;
+        vwrq->disabled = (vwrq->value >= 2346);
+        vwrq->fixed = 1;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set Mode of Operation */
+static int ks_wlan_set_mode(struct net_device *dev,
+                            struct iw_request_info *info, __u32 * uwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        DPRINTK(2, "mode=%d\n", *uwrq);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        switch (*uwrq) {
+        case IW_MODE_ADHOC:
+                priv->reg.operation_mode = MODE_ADHOC;
+                priv->need_commit |= SME_MODE_SET;
+                break;
+        case IW_MODE_INFRA:
+                priv->reg.operation_mode = MODE_INFRASTRUCTURE;
+                priv->need_commit |= SME_MODE_SET;
+                break;
+        case IW_MODE_AUTO:
+        case IW_MODE_MASTER:
+        case IW_MODE_REPEAT:
+        case IW_MODE_SECOND:
+        case IW_MODE_MONITOR:
+        default:
+                return -EINVAL;
+        }
+
+        return -EINPROGRESS;    /* Call commit handler */
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get Mode of Operation */
+static int ks_wlan_get_mode(struct net_device *dev,
+                            struct iw_request_info *info, __u32 * uwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /* If not managed, assume it's ad-hoc */
+        switch (priv->reg.operation_mode) {
+        case MODE_INFRASTRUCTURE:
+                *uwrq = IW_MODE_INFRA;
+                break;
+        case MODE_ADHOC:
+                *uwrq = IW_MODE_ADHOC;
+                break;
+        default:
+                *uwrq = IW_MODE_ADHOC;
+        }
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set Encryption Key */
+static int ks_wlan_set_encode(struct net_device *dev,
+                              struct iw_request_info *info,
+                              struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        wep_key_t key;
+        int index = (dwrq->flags & IW_ENCODE_INDEX);
+        int current_index = priv->reg.wep_index;
+        int i;
+
+        DPRINTK(2, "flags=%04X\n", dwrq->flags);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /* index check */
+        if ((index < 0) || (index > 4))
+                return -EINVAL;
+        else if (index == 0)
+                index = current_index;
+        else
+                index--;
+
+        /* Is WEP supported ? */
+        /* Basic checking: do we have a key to set ? */
+        if (dwrq->length > 0) {
+                if (dwrq->length > MAX_KEY_SIZE) {      /* Check the size of the key */
+                        return -EINVAL;
+                }
+                if (dwrq->length > MIN_KEY_SIZE) {      /* Set the length */
+                        key.len = MAX_KEY_SIZE;
+                        priv->reg.privacy_invoked = 0x01;
+                        priv->need_commit |= SME_WEP_FLAG;
+                        wep_on_off = WEP_ON_128BIT;
+                } else {
+                        if (dwrq->length > 0) {
+                                key.len = MIN_KEY_SIZE;
+                                priv->reg.privacy_invoked = 0x01;
+                                priv->need_commit |= SME_WEP_FLAG;
+                                wep_on_off = WEP_ON_64BIT;
+                        } else {        /* Disable the key */
+                                key.len = 0;
+                        }
+                }
+                /* Check if the key is not marked as invalid */
+                if (!(dwrq->flags & IW_ENCODE_NOKEY)) {
+                        /* Cleanup */
+                        memset(key.key, 0, MAX_KEY_SIZE);
+                        /* Copy the key in the driver */
+                        if (copy_from_user
+                            (key.key, dwrq->pointer, dwrq->length)) {
+                                key.len = 0;
+                                return -EFAULT;
+                        }
+                        /* Send the key to the card */
+                        priv->reg.wep_key[index].size = key.len;
+                        for (i = 0; i < (priv->reg.wep_key[index].size); i++) {
+                                priv->reg.wep_key[index].val[i] = key.key[i];
+                        }
+                        priv->need_commit |= (SME_WEP_VAL1 << index);
+                        priv->reg.wep_index = index;
+                        priv->need_commit |= SME_WEP_INDEX;
+                }
+        } else {
+                if (dwrq->flags & IW_ENCODE_DISABLED) {
+                        priv->reg.wep_key[0].size = 0;
+                        priv->reg.wep_key[1].size = 0;
+                        priv->reg.wep_key[2].size = 0;
+                        priv->reg.wep_key[3].size = 0;
+                        priv->reg.privacy_invoked = 0x00;
+                        if (priv->reg.authenticate_type == AUTH_TYPE_SHARED_KEY) {
+                                priv->need_commit |= SME_MODE_SET;
+                        }
+                        priv->reg.authenticate_type = AUTH_TYPE_OPEN_SYSTEM;
+                        wep_on_off = WEP_OFF;
+                        priv->need_commit |= SME_WEP_FLAG;
+                } else {
+                        /* Do we want to just set the transmit key index ? */
+                        if ((index >= 0) && (index < 4)) {
+                                /* set_wep_key(priv, index, 0, 0, 1);   xxx */
+                                if (priv->reg.wep_key[index].size) {
+                                        priv->reg.wep_index = index;
+                                        priv->need_commit |= SME_WEP_INDEX;
+                                } else
+                                        return -EINVAL;
+                        }
+                }
+        }
+
+        /* Commit the changes if needed */
+        if (dwrq->flags & IW_ENCODE_MODE)
+                priv->need_commit |= SME_WEP_FLAG;
+
+        if (dwrq->flags & IW_ENCODE_OPEN) {
+                if (priv->reg.authenticate_type == AUTH_TYPE_SHARED_KEY) {
+                        priv->need_commit |= SME_MODE_SET;
+                }
+                priv->reg.authenticate_type = AUTH_TYPE_OPEN_SYSTEM;
+        } else if (dwrq->flags & IW_ENCODE_RESTRICTED) {
+                if (priv->reg.authenticate_type == AUTH_TYPE_OPEN_SYSTEM) {
+                        priv->need_commit |= SME_MODE_SET;
+                }
+                priv->reg.authenticate_type = AUTH_TYPE_SHARED_KEY;
+        }
+//      return -EINPROGRESS;            /* Call commit handler */
+        if (priv->need_commit) {
+                ks_wlan_setup_parameter(priv, priv->need_commit);
+                priv->need_commit = 0;
+        }
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get Encryption Key */
+static int ks_wlan_get_encode(struct net_device *dev,
+                              struct iw_request_info *info,
+                              struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        char zeros[16];
+        int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        dwrq->flags = IW_ENCODE_DISABLED;
+
+        /* Check encryption mode */
+        switch (priv->reg.authenticate_type) {
+        case AUTH_TYPE_OPEN_SYSTEM:
+                dwrq->flags = IW_ENCODE_OPEN;
+                break;
+        case AUTH_TYPE_SHARED_KEY:
+                dwrq->flags = IW_ENCODE_RESTRICTED;
+                break;
+        }
+
+        memset(zeros, 0, sizeof(zeros));
+
+        /* Which key do we want ? -1 -> tx index */
+        if ((index < 0) || (index >= 4))
+                index = priv->reg.wep_index;
+        if (priv->reg.privacy_invoked) {
+                dwrq->flags &= ~IW_ENCODE_DISABLED;
+                /* dwrq->flags |= IW_ENCODE_NOKEY; */
+        }
+        dwrq->flags |= index + 1;
+        DPRINTK(2, "encoding flag = 0x%04X\n", dwrq->flags);
+        /* Copy the key to the user buffer */
+        if ((index >= 0) && (index < 4))
+                dwrq->length = priv->reg.wep_key[index].size;
+        if (dwrq->length > 16) {
+                dwrq->length = 0;
+        }
+#if 1   /* IW_ENCODE_NOKEY; */
+        if (dwrq->length) {
+                if ((index >= 0) && (index < 4))
+                        memcpy(extra, priv->reg.wep_key[index].val,
+                               dwrq->length);
+        } else
+                memcpy(extra, zeros, dwrq->length);
+#endif
+        return 0;
+}
+
+#ifndef KSC_OPNOTSUPP
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set Tx-Power */
+static int ks_wlan_set_txpow(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_param *vwrq, char *extra)
+{
+        return -EOPNOTSUPP;     /* Not Support */
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get Tx-Power */
+static int ks_wlan_get_txpow(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_param *vwrq, char *extra)
+{
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /* Not Support */
+        vwrq->value = 0;
+        vwrq->disabled = (vwrq->value == 0);
+        vwrq->fixed = 1;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set Retry limits */
+static int ks_wlan_set_retry(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_param *vwrq, char *extra)
+{
+        return -EOPNOTSUPP;     /* Not Support */
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get Retry limits */
+static int ks_wlan_get_retry(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_param *vwrq, char *extra)
+{
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /* Not Support */
+        vwrq->value = 0;
+        vwrq->disabled = (vwrq->value == 0);
+        vwrq->fixed = 1;
+        return 0;
+}
+#endif /* KSC_OPNOTSUPP */
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get range info */
+static int ks_wlan_get_range(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        struct iw_range *range = (struct iw_range *)extra;
+        int i, k;
+
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        dwrq->length = sizeof(struct iw_range);
+        memset(range, 0, sizeof(*range));
+        range->min_nwid = 0x0000;
+        range->max_nwid = 0x0000;
+        range->num_channels = 14;
+        /* Should be based on cap_rid.country to give only
+         * what the current card support */
+        k = 0;
+        for (i = 0; i < 13; i++) {      /* channel 1 -- 13 */
+                range->freq[k].i = i + 1;       /* List index */
+                range->freq[k].m = frequency_list[i] * 100000;
+                range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
+        }
+        range->num_frequency = k;
+        if (priv->reg.phy_type == D_11B_ONLY_MODE || priv->reg.phy_type == D_11BG_COMPATIBLE_MODE) {    /* channel 14 */
+                range->freq[13].i = 14; /* List index */
+                range->freq[13].m = frequency_list[13] * 100000;
+                range->freq[13].e = 1;  /* Values in table in MHz -> * 10^5 * 10 */
+                range->num_frequency = 14;
+        }
+
+        /* Hum... Should put the right values there */
+        range->max_qual.qual = 100;
+        range->max_qual.level = 256 - 128;      /* 0 dBm? */
+        range->max_qual.noise = 256 - 128;
+        range->sensitivity = 1;
+
+        if (priv->reg.phy_type == D_11B_ONLY_MODE) {
+                range->bitrate[0] = 1e6;
+                range->bitrate[1] = 2e6;
+                range->bitrate[2] = 5.5e6;
+                range->bitrate[3] = 11e6;
+                range->num_bitrates = 4;
+        } else {        /* D_11G_ONLY_MODE or D_11BG_COMPATIBLE_MODE */
+                range->bitrate[0] = 1e6;
+                range->bitrate[1] = 2e6;
+                range->bitrate[2] = 5.5e6;
+                range->bitrate[3] = 11e6;
+
+                range->bitrate[4] = 6e6;
+                range->bitrate[5] = 9e6;
+                range->bitrate[6] = 12e6;
+                if (IW_MAX_BITRATES < 9) {
+                        range->bitrate[7] = 54e6;
+                        range->num_bitrates = 8;
+                } else {
+                        range->bitrate[7] = 18e6;
+                        range->bitrate[8] = 24e6;
+                        range->bitrate[9] = 36e6;
+                        range->bitrate[10] = 48e6;
+                        range->bitrate[11] = 54e6;
+
+                        range->num_bitrates = 12;
+                }
+        }
+
+        /* Set an indication of the max TCP throughput
+         * in bit/s that we can expect using this interface.
+         * May be use for QoS stuff... Jean II */
+        if (i > 2)
+                range->throughput = 5000 * 1000;
+        else
+                range->throughput = 1500 * 1000;
+
+        range->min_rts = 0;
+        range->max_rts = 2347;
+        range->min_frag = 256;
+        range->max_frag = 2346;
+
+        range->encoding_size[0] = 5;    /* WEP: RC4 40 bits */
+        range->encoding_size[1] = 13;   /* WEP: RC4 ~128 bits */
+        range->num_encoding_sizes = 2;
+        range->max_encoding_tokens = 4;
+
+        /* power management not support */
+        range->pmp_flags = IW_POWER_ON;
+        range->pmt_flags = IW_POWER_ON;
+        range->pm_capa = 0;
+
+        /* Transmit Power - values are in dBm( or mW) */
+        range->txpower[0] = -256;
+        range->num_txpower = 1;
+        range->txpower_capa = IW_TXPOW_DBM;
+        /* range->txpower_capa = IW_TXPOW_MWATT; */
+
+        range->we_version_source = 21;
+        range->we_version_compiled = WIRELESS_EXT;
+
+        range->retry_capa = IW_RETRY_ON;
+        range->retry_flags = IW_RETRY_ON;
+        range->r_time_flags = IW_RETRY_ON;
+
+        /* Experimental measurements - boundary 11/5.5 Mb/s */
+        /* Note : with or without the (local->rssi), results
+         * are somewhat different. - Jean II */
+        range->avg_qual.qual = 50;
+        range->avg_qual.level = 186;    /* -70 dBm */
+        range->avg_qual.noise = 0;
+
+        /* Event capability (kernel + driver) */
+        range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
+                                IW_EVENT_CAPA_MASK(SIOCGIWAP) |
+                                IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
+        range->event_capa[1] = IW_EVENT_CAPA_K_1;
+        range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVCUSTOM) |
+                                IW_EVENT_CAPA_MASK(IWEVMICHAELMICFAILURE));
+
+        /* encode extension (WPA) capability */
+        range->enc_capa = (IW_ENC_CAPA_WPA |
+                           IW_ENC_CAPA_WPA2 |
+                           IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP);
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set Power Management */
+static int ks_wlan_set_power(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_param *vwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        short enabled;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        enabled = vwrq->disabled ? 0 : 1;
+        if (enabled == 0) {     /* 0 */
+                priv->reg.powermgt = POWMGT_ACTIVE_MODE;
+        } else if (enabled) {   /* 1 */
+                if (priv->reg.operation_mode == MODE_INFRASTRUCTURE)
+                        priv->reg.powermgt = POWMGT_SAVE1_MODE;
+                else
+                        return -EINVAL;
+        } else if (enabled) {   /* 2 */
+                if (priv->reg.operation_mode == MODE_INFRASTRUCTURE)
+                        priv->reg.powermgt = POWMGT_SAVE2_MODE;
+                else
+                        return -EINVAL;
+        } else
+                return -EINVAL;
+
+        hostif_sme_enqueue(priv, SME_POW_MNGMT_REQUEST);
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get Power Management */
+static int ks_wlan_get_power(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_param *vwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (priv->reg.powermgt > 0)
+                vwrq->disabled = 0;
+        else
+                vwrq->disabled = 1;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get wirless statistics */
+static int ks_wlan_get_iwstats(struct net_device *dev,
+                               struct iw_request_info *info,
+                               struct iw_quality *vwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        vwrq->qual = 0; /* not supported */
+        vwrq->level = priv->wstats.qual.level;
+        vwrq->noise = 0;        /* not supported */
+        vwrq->updated = 0;
+
+        return 0;
+}
+
+#ifndef KSC_OPNOTSUPP
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set Sensitivity */
+static int ks_wlan_set_sens(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_param *vwrq,
+                            char *extra)
+{
+        return -EOPNOTSUPP;     /* Not Support */
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get Sensitivity */
+static int ks_wlan_get_sens(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_param *vwrq,
+                            char *extra)
+{
+        /* Not Support */
+        vwrq->value = 0;
+        vwrq->disabled = (vwrq->value == 0);
+        vwrq->fixed = 1;
+        return 0;
+}
+#endif /* KSC_OPNOTSUPP */
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get AP List */
+/* Note : this is deprecated in favor of IWSCAN */
+static int ks_wlan_get_aplist(struct net_device *dev,
+                              struct iw_request_info *info,
+                              struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        struct sockaddr *address = (struct sockaddr *)extra;
+        struct iw_quality qual[LOCAL_APLIST_MAX];
+
+        int i;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        for (i = 0; i < priv->aplist.size; i++) {
+                memcpy(address[i].sa_data, &(priv->aplist.ap[i].bssid[0]),
+                       ETH_ALEN);
+                address[i].sa_family = ARPHRD_ETHER;
+                qual[i].level = 256 - priv->aplist.ap[i].rssi;
+                qual[i].qual = priv->aplist.ap[i].sq;
+                qual[i].noise = 0;      /* invalid noise value */
+                qual[i].updated = 7;
+        }
+        if (i) {
+                dwrq->flags = 1;        /* Should be define'd */
+                memcpy(extra + sizeof(struct sockaddr) * i,
+                       &qual, sizeof(struct iw_quality) * i);
+        }
+        dwrq->length = i;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : Initiate Scan */
+static int ks_wlan_set_scan(struct net_device *dev,
+                            struct iw_request_info *info,
+                            union iwreq_data *wrqu, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        struct iw_scan_req *req = NULL;
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /* specified SSID SCAN */
+        if (wrqu->data.length == sizeof(struct iw_scan_req)
+            && wrqu->data.flags & IW_SCAN_THIS_ESSID) {
+                req = (struct iw_scan_req *)extra;
+                priv->scan_ssid_len = req->essid_len;
+                memcpy(priv->scan_ssid, req->essid, priv->scan_ssid_len);
+        } else {
+                priv->scan_ssid_len = 0;
+        }
+
+        priv->sme_i.sme_flag |= SME_AP_SCAN;
+        hostif_sme_enqueue(priv, SME_BSS_SCAN_REQUEST);
+
+        /* At this point, just return to the user. */
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Translate scan data returned from the card to a card independent
+ * format that the Wireless Tools will understand - Jean II
+ */
+static inline char *ks_wlan_translate_scan(struct net_device *dev,
+                                           struct iw_request_info *info,
+                                           char *current_ev, char *end_buf,
+                                           struct local_ap_t *ap)
+{
+        /* struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv; */
+        struct iw_event iwe;    /* Temporary buffer */
+        u16 capabilities;
+        char *current_val;      /* For rates */
+        int i;
+        static const char rsn_leader[] = "rsn_ie=";
+        static const char wpa_leader[] = "wpa_ie=";
+        char buf0[RSN_IE_BODY_MAX * 2 + 30];
+        char buf1[RSN_IE_BODY_MAX * 2 + 30];
+        char *pbuf;
+        /* First entry *MUST* be the AP MAC address */
+        iwe.cmd = SIOCGIWAP;
+        iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
+        memcpy(iwe.u.ap_addr.sa_data, ap->bssid, ETH_ALEN);
+        current_ev =
+            iwe_stream_add_event(info, current_ev, end_buf, &iwe,
+                                 IW_EV_ADDR_LEN);
+
+        /* Other entries will be displayed in the order we give them */
+
+        /* Add the ESSID */
+        iwe.u.data.length = ap->ssid.size;
+        if (iwe.u.data.length > 32)
+                iwe.u.data.length = 32;
+        iwe.cmd = SIOCGIWESSID;
+        iwe.u.data.flags = 1;
+        current_ev =
+            iwe_stream_add_point(info, current_ev, end_buf, &iwe,
+                                 &(ap->ssid.body[0]));
+
+        /* Add mode */
+        iwe.cmd = SIOCGIWMODE;
+        capabilities = le16_to_cpu(ap->capability);
+        if (capabilities & (BSS_CAP_ESS | BSS_CAP_IBSS)) {
+                if (capabilities & BSS_CAP_ESS)
+                        iwe.u.mode = IW_MODE_INFRA;
+                else
+                        iwe.u.mode = IW_MODE_ADHOC;
+                current_ev =
+                    iwe_stream_add_event(info, current_ev, end_buf, &iwe,
+                                         IW_EV_UINT_LEN);
+        }
+
+        /* Add frequency */
+        iwe.cmd = SIOCGIWFREQ;
+        iwe.u.freq.m = ap->channel;
+        iwe.u.freq.m = frequency_list[iwe.u.freq.m - 1] * 100000;
+        iwe.u.freq.e = 1;
+        current_ev =
+            iwe_stream_add_event(info, current_ev, end_buf, &iwe,
+                                 IW_EV_FREQ_LEN);
+
+        /* Add quality statistics */
+        iwe.cmd = IWEVQUAL;
+        iwe.u.qual.level = 256 - ap->rssi;
+        iwe.u.qual.qual = ap->sq;
+        iwe.u.qual.noise = 0;   /* invalid noise value */
+        current_ev =
+            iwe_stream_add_event(info, current_ev, end_buf, &iwe,
+                                 IW_EV_QUAL_LEN);
+
+        /* Add encryption capability */
+        iwe.cmd = SIOCGIWENCODE;
+        if (capabilities & BSS_CAP_PRIVACY)
+                iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
+        else
+                iwe.u.data.flags = IW_ENCODE_DISABLED;
+        iwe.u.data.length = 0;
+        current_ev =
+            iwe_stream_add_point(info, current_ev, end_buf, &iwe,
+                                 &(ap->ssid.body[0]));
+
+        /* Rate : stuffing multiple values in a single event require a bit
+         * more of magic - Jean II */
+        current_val = current_ev + IW_EV_LCP_LEN;
+
+        iwe.cmd = SIOCGIWRATE;
+        /* Those two flags are ignored... */
+        iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
+
+        /* Max 16 values */
+        for (i = 0; i < 16; i++) {
+                /* NULL terminated */
+                if (i >= ap->rate_set.size)
+                        break;
+                /* Bit rate given in 500 kb/s units (+ 0x80) */
+                iwe.u.bitrate.value = ((ap->rate_set.body[i] & 0x7f) * 500000);
+                /* Add new value to event */
+                current_val =
+                    iwe_stream_add_value(info, current_ev, current_val, end_buf,
+                                         &iwe, IW_EV_PARAM_LEN);
+        }
+        /* Check if we added any event */
+        if ((current_val - current_ev) > IW_EV_LCP_LEN)
+                current_ev = current_val;
+
+#define GENERIC_INFO_ELEM_ID 0xdd
+#define RSN_INFO_ELEM_ID 0x30
+        if (ap->rsn_ie.id == RSN_INFO_ELEM_ID && ap->rsn_ie.size != 0) {
+                pbuf = &buf0[0];
+                memset(&iwe, 0, sizeof(iwe));
+                iwe.cmd = IWEVCUSTOM;
+                memcpy(buf0, rsn_leader, sizeof(rsn_leader) - 1);
+                iwe.u.data.length += sizeof(rsn_leader) - 1;
+                pbuf += sizeof(rsn_leader) - 1;
+
+                pbuf += sprintf(pbuf, "%02x", ap->rsn_ie.id);
+                pbuf += sprintf(pbuf, "%02x", ap->rsn_ie.size);
+                iwe.u.data.length += 4;
+
+                for (i = 0; i < ap->rsn_ie.size; i++)
+                        pbuf += sprintf(pbuf, "%02x", ap->rsn_ie.body[i]);
+                iwe.u.data.length += (ap->rsn_ie.size) * 2;
+
+                DPRINTK(4, "ap->rsn.size=%d\n", ap->rsn_ie.size);
+
+                current_ev =
+                    iwe_stream_add_point(info, current_ev, end_buf, &iwe,
+                                         &buf0[0]);
+        }
+        if (ap->wpa_ie.id == GENERIC_INFO_ELEM_ID && ap->wpa_ie.size != 0) {
+                pbuf = &buf1[0];
+                memset(&iwe, 0, sizeof(iwe));
+                iwe.cmd = IWEVCUSTOM;
+                memcpy(buf1, wpa_leader, sizeof(wpa_leader) - 1);
+                iwe.u.data.length += sizeof(wpa_leader) - 1;
+                pbuf += sizeof(wpa_leader) - 1;
+
+                pbuf += sprintf(pbuf, "%02x", ap->wpa_ie.id);
+                pbuf += sprintf(pbuf, "%02x", ap->wpa_ie.size);
+                iwe.u.data.length += 4;
+
+                for (i = 0; i < ap->wpa_ie.size; i++)
+                        pbuf += sprintf(pbuf, "%02x", ap->wpa_ie.body[i]);
+                iwe.u.data.length += (ap->wpa_ie.size) * 2;
+
+                DPRINTK(4, "ap->rsn.size=%d\n", ap->wpa_ie.size);
+                DPRINTK(4, "iwe.u.data.length=%d\n", iwe.u.data.length);
+
+                current_ev =
+                    iwe_stream_add_point(info, current_ev, end_buf, &iwe,
+                                         &buf1[0]);
+        }
+
+        /* The other data in the scan result are not really
+         * interesting, so for now drop it - Jean II */
+        return current_ev;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : Read Scan Results */
+static int ks_wlan_get_scan(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_point *dwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        int i;
+        char *current_ev = extra;
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (priv->sme_i.sme_flag & SME_AP_SCAN) {
+                DPRINTK(2, "flag AP_SCAN\n");
+                return -EAGAIN;
+        }
+
+        if (priv->aplist.size == 0) {
+                /* Client error, no scan results...
+                 * The caller need to restart the scan. */
+                DPRINTK(2, "aplist 0\n");
+                return -ENODATA;
+        }
+#if 0
+        /* current connect ap */
+        if ((priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) {
+                if ((extra + dwrq->length) - current_ev <= IW_EV_ADDR_LEN) {
+                        dwrq->length = 0;
+                        return -E2BIG;
+                }
+                current_ev = ks_wlan_translate_scan(dev, current_ev,
+//                                                  extra + IW_SCAN_MAX_DATA,
+                                                    extra + dwrq->length,
+                                                    &(priv->current_ap));
+        }
+#endif
+        /* Read and parse all entries */
+        for (i = 0; i < priv->aplist.size; i++) {
+                if ((extra + dwrq->length) - current_ev <= IW_EV_ADDR_LEN) {
+                        dwrq->length = 0;
+                        return -E2BIG;
+                }
+                /* Translate to WE format this entry */
+                current_ev = ks_wlan_translate_scan(dev, info, current_ev,
+//                                                  extra + IW_SCAN_MAX_DATA,
+                                                    extra + dwrq->length,
+                                                    &(priv->aplist.ap[i]));
+        }
+        /* Length of data */
+        dwrq->length = (current_ev - extra);
+        dwrq->flags = 0;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Commit handler : called after a bunch of SET operations */
+static int ks_wlan_config_commit(struct net_device *dev,
+                                 struct iw_request_info *info, void *zwrq,
+                                 char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (!priv->need_commit)
+                return 0;
+
+        ks_wlan_setup_parameter(priv, priv->need_commit);
+        priv->need_commit = 0;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless handler : set association ie params */
+static int ks_wlan_set_genie(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        return 0;
+//      return -EOPNOTSUPP;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless handler : set authentication mode params */
+static int ks_wlan_set_auth_mode(struct net_device *dev,
+                                 struct iw_request_info *info,
+                                 struct iw_param *vwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        int index = (vwrq->flags & IW_AUTH_INDEX);
+        int value = vwrq->value;
+
+        DPRINTK(2, "index=%d:value=%08X\n", index, value);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        switch (index) {
+        case IW_AUTH_WPA_VERSION:       /* 0 */
+                switch (value) {
+                case IW_AUTH_WPA_VERSION_DISABLED:
+                        priv->wpa.version = value;
+                        if (priv->wpa.rsn_enabled) {
+                                priv->wpa.rsn_enabled = 0;
+                        }
+                        priv->need_commit |= SME_RSN;
+                        break;
+                case IW_AUTH_WPA_VERSION_WPA:
+                case IW_AUTH_WPA_VERSION_WPA2:
+                        priv->wpa.version = value;
+                        if (!(priv->wpa.rsn_enabled)) {
+                                priv->wpa.rsn_enabled = 1;
+                        }
+                        priv->need_commit |= SME_RSN;
+                        break;
+                default:
+                        return -EOPNOTSUPP;
+                }
+                break;
+        case IW_AUTH_CIPHER_PAIRWISE:   /* 1 */
+                switch (value) {
+                case IW_AUTH_CIPHER_NONE:
+                        if (priv->reg.privacy_invoked) {
+                                priv->reg.privacy_invoked = 0x00;
+                                priv->need_commit |= SME_WEP_FLAG;
+                        }
+                        break;
+                case IW_AUTH_CIPHER_WEP40:
+                case IW_AUTH_CIPHER_TKIP:
+                case IW_AUTH_CIPHER_CCMP:
+                case IW_AUTH_CIPHER_WEP104:
+                        if (!priv->reg.privacy_invoked) {
+                                priv->reg.privacy_invoked = 0x01;
+                                priv->need_commit |= SME_WEP_FLAG;
+                        }
+                        priv->wpa.pairwise_suite = value;
+                        priv->need_commit |= SME_RSN_UNICAST;
+                        break;
+                default:
+                        return -EOPNOTSUPP;
+                }
+                break;
+        case IW_AUTH_CIPHER_GROUP:      /* 2 */
+                switch (value) {
+                case IW_AUTH_CIPHER_NONE:
+                        if (priv->reg.privacy_invoked) {
+                                priv->reg.privacy_invoked = 0x00;
+                                priv->need_commit |= SME_WEP_FLAG;
+                        }
+                        break;
+                case IW_AUTH_CIPHER_WEP40:
+                case IW_AUTH_CIPHER_TKIP:
+                case IW_AUTH_CIPHER_CCMP:
+                case IW_AUTH_CIPHER_WEP104:
+                        if (!priv->reg.privacy_invoked) {
+                                priv->reg.privacy_invoked = 0x01;
+                                priv->need_commit |= SME_WEP_FLAG;
+                        }
+                        priv->wpa.group_suite = value;
+                        priv->need_commit |= SME_RSN_MULTICAST;
+                        break;
+                default:
+                        return -EOPNOTSUPP;
+                }
+                break;
+        case IW_AUTH_KEY_MGMT:  /* 3 */
+                switch (value) {
+                case IW_AUTH_KEY_MGMT_802_1X:
+                case IW_AUTH_KEY_MGMT_PSK:
+                case 0: /* NONE or 802_1X_NO_WPA */
+                case 4: /* WPA_NONE */
+                        priv->wpa.key_mgmt_suite = value;
+                        priv->need_commit |= SME_RSN_AUTH;
+                        break;
+                default:
+                        return -EOPNOTSUPP;
+                }
+                break;
+        case IW_AUTH_80211_AUTH_ALG:    /* 6 */
+                switch (value) {
+                case IW_AUTH_ALG_OPEN_SYSTEM:
+                        priv->wpa.auth_alg = value;
+                        priv->reg.authenticate_type = AUTH_TYPE_OPEN_SYSTEM;
+                        break;
+                case IW_AUTH_ALG_SHARED_KEY:
+                        priv->wpa.auth_alg = value;
+                        priv->reg.authenticate_type = AUTH_TYPE_SHARED_KEY;
+                        break;
+                case IW_AUTH_ALG_LEAP:
+                default:
+                        return -EOPNOTSUPP;
+                }
+                priv->need_commit |= SME_MODE_SET;
+                break;
+        case IW_AUTH_WPA_ENABLED:       /* 7 */
+                priv->wpa.wpa_enabled = value;
+                break;
+        case IW_AUTH_PRIVACY_INVOKED:   /* 10 */
+                if ((value && !priv->reg.privacy_invoked) ||
+                    (!value && priv->reg.privacy_invoked)) {
+                        priv->reg.privacy_invoked = value ? 0x01 : 0x00;
+                        priv->need_commit |= SME_WEP_FLAG;
+                }
+                break;
+        case IW_AUTH_RX_UNENCRYPTED_EAPOL:      /* 4 */
+        case IW_AUTH_TKIP_COUNTERMEASURES:      /* 5 */
+        case IW_AUTH_DROP_UNENCRYPTED:  /* 8 */
+        case IW_AUTH_ROAMING_CONTROL:   /* 9 */
+        default:
+                break;
+        }
+
+        /* return -EINPROGRESS; */
+        if (priv->need_commit) {
+                ks_wlan_setup_parameter(priv, priv->need_commit);
+                priv->need_commit = 0;
+        }
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless handler : get authentication mode params */
+static int ks_wlan_get_auth_mode(struct net_device *dev,
+                                 struct iw_request_info *info,
+                                 struct iw_param *vwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        int index = (vwrq->flags & IW_AUTH_INDEX);
+        DPRINTK(2, "index=%d\n", index);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /*  WPA (not used ?? wpa_supplicant) */
+        switch (index) {
+        case IW_AUTH_WPA_VERSION:
+                vwrq->value = priv->wpa.version;
+                break;
+        case IW_AUTH_CIPHER_PAIRWISE:
+                vwrq->value = priv->wpa.pairwise_suite;
+                break;
+        case IW_AUTH_CIPHER_GROUP:
+                vwrq->value = priv->wpa.group_suite;
+                break;
+        case IW_AUTH_KEY_MGMT:
+                vwrq->value = priv->wpa.key_mgmt_suite;
+                break;
+        case IW_AUTH_80211_AUTH_ALG:
+                vwrq->value = priv->wpa.auth_alg;
+                break;
+        case IW_AUTH_WPA_ENABLED:
+                vwrq->value = priv->wpa.rsn_enabled;
+                break;
+        case IW_AUTH_RX_UNENCRYPTED_EAPOL:      /* OK??? */
+        case IW_AUTH_TKIP_COUNTERMEASURES:
+        case IW_AUTH_DROP_UNENCRYPTED:
+        default:
+                /* return -EOPNOTSUPP; */
+                break;
+        }
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set encoding token & mode (WPA)*/
+static int ks_wlan_set_encode_ext(struct net_device *dev,
+                                  struct iw_request_info *info,
+                                  struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        struct iw_encode_ext *enc;
+        int index = dwrq->flags & IW_ENCODE_INDEX;
+        unsigned int commit = 0;
+
+        enc = (struct iw_encode_ext *)extra;
+
+        DPRINTK(2, "flags=%04X:: ext_flags=%08X\n", dwrq->flags,
+                enc->ext_flags);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (index < 1 || index > 4)
+                return -EINVAL;
+        else
+                index--;
+
+        if (dwrq->flags & IW_ENCODE_DISABLED) {
+                priv->wpa.key[index].key_len = 0;
+        }
+
+        if (enc) {
+                priv->wpa.key[index].ext_flags = enc->ext_flags;
+                if (enc->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
+                        priv->wpa.txkey = index;
+                        commit |= SME_WEP_INDEX;
+                } else if (enc->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
+                        memcpy(&priv->wpa.key[index].rx_seq[0],
+                               enc->rx_seq, IW_ENCODE_SEQ_MAX_SIZE);
+                }
+
+                memcpy(&priv->wpa.key[index].addr.sa_data[0],
+                       &enc->addr.sa_data[0], ETH_ALEN);
+
+                switch (enc->alg) {
+                case IW_ENCODE_ALG_NONE:
+                        if (priv->reg.privacy_invoked) {
+                                priv->reg.privacy_invoked = 0x00;
+                                commit |= SME_WEP_FLAG;
+                        }
+                        priv->wpa.key[index].key_len = 0;
+
+                        break;
+                case IW_ENCODE_ALG_WEP:
+                case IW_ENCODE_ALG_CCMP:
+                        if (!priv->reg.privacy_invoked) {
+                                priv->reg.privacy_invoked = 0x01;
+                                commit |= SME_WEP_FLAG;
+                        }
+                        if (enc->key_len) {
+                                memcpy(&priv->wpa.key[index].key_val[0],
+                                       &enc->key[0], enc->key_len);
+                                priv->wpa.key[index].key_len = enc->key_len;
+                                commit |= (SME_WEP_VAL1 << index);
+                        }
+                        break;
+                case IW_ENCODE_ALG_TKIP:
+                        if (!priv->reg.privacy_invoked) {
+                                priv->reg.privacy_invoked = 0x01;
+                                commit |= SME_WEP_FLAG;
+                        }
+                        if (enc->key_len == 32) {
+                                memcpy(&priv->wpa.key[index].key_val[0],
+                                       &enc->key[0], enc->key_len - 16);
+                                priv->wpa.key[index].key_len =
+                                    enc->key_len - 16;
+                                if (priv->wpa.key_mgmt_suite == 4) {    /* WPA_NONE */
+                                        memcpy(&priv->wpa.key[index].
+                                               tx_mic_key[0], &enc->key[16], 8);
+                                        memcpy(&priv->wpa.key[index].
+                                               rx_mic_key[0], &enc->key[16], 8);
+                                } else {
+                                        memcpy(&priv->wpa.key[index].
+                                               tx_mic_key[0], &enc->key[16], 8);
+                                        memcpy(&priv->wpa.key[index].
+                                               rx_mic_key[0], &enc->key[24], 8);
+                                }
+                                commit |= (SME_WEP_VAL1 << index);
+                        }
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                priv->wpa.key[index].alg = enc->alg;
+        } else
+                return -EINVAL;
+
+        if (commit) {
+                if (commit & SME_WEP_INDEX)
+                        hostif_sme_enqueue(priv, SME_SET_TXKEY);
+                if (commit & SME_WEP_VAL_MASK)
+                        hostif_sme_enqueue(priv, SME_SET_KEY1 + index);
+                if (commit & SME_WEP_FLAG)
+                        hostif_sme_enqueue(priv, SME_WEP_FLAG_REQUEST);
+        }
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : get encoding token & mode (WPA)*/
+static int ks_wlan_get_encode_ext(struct net_device *dev,
+                                  struct iw_request_info *info,
+                                  struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+
+        /* for SLEEP MODE */
+        /*  WPA (not used ?? wpa_supplicant)
+           struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+           struct iw_encode_ext *enc;
+           enc = (struct iw_encode_ext *)extra;
+           int index = dwrq->flags & IW_ENCODE_INDEX;
+           WPA (not used ?? wpa_supplicant) */
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : PMKSA cache operation (WPA2) */
+static int ks_wlan_set_pmksa(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        struct iw_pmksa *pmksa;
+        int i;
+        struct pmk_t *pmk;
+        struct list_head *ptr;
+
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (!extra) {
+                return -EINVAL;
+        }
+        pmksa = (struct iw_pmksa *)extra;
+        DPRINTK(2, "cmd=%d\n", pmksa->cmd);
+
+        switch (pmksa->cmd) {
+        case IW_PMKSA_ADD:
+                if (list_empty(&priv->pmklist.head)) {  /* new list */
+                        for (i = 0; i < PMK_LIST_MAX; i++) {
+                                pmk = &priv->pmklist.pmk[i];
+                                if (!memcmp
+                                    ("\x00\x00\x00\x00\x00\x00", pmk->bssid,
+                                     ETH_ALEN))
+                                        break;
+                        }
+                        memcpy(pmk->bssid, pmksa->bssid.sa_data, ETH_ALEN);
+                        memcpy(pmk->pmkid, pmksa->pmkid, IW_PMKID_LEN);
+                        list_add(&pmk->list, &priv->pmklist.head);
+                        priv->pmklist.size++;
+                } else {        /* search cache data */
+                        list_for_each(ptr, &priv->pmklist.head) {
+                                pmk = list_entry(ptr, struct pmk_t, list);
+                                if (!memcmp(pmksa->bssid.sa_data, pmk->bssid, ETH_ALEN)) {      /* match address! list move to head. */
+                                        memcpy(pmk->pmkid, pmksa->pmkid,
+                                               IW_PMKID_LEN);
+                                        list_move(&pmk->list,
+                                                  &priv->pmklist.head);
+                                        break;
+                                }
+                        }
+                        if (ptr == &priv->pmklist.head) {       /* not find address. */
+                                if (PMK_LIST_MAX > priv->pmklist.size) {        /* new cache data */
+                                        for (i = 0; i < PMK_LIST_MAX; i++) {
+                                                pmk = &priv->pmklist.pmk[i];
+                                                if (!memcmp
+                                                    ("\x00\x00\x00\x00\x00\x00",
+                                                     pmk->bssid, ETH_ALEN))
+                                                        break;
+                                        }
+                                        memcpy(pmk->bssid, pmksa->bssid.sa_data,
+                                               ETH_ALEN);
+                                        memcpy(pmk->pmkid, pmksa->pmkid,
+                                               IW_PMKID_LEN);
+                                        list_add(&pmk->list,
+                                                 &priv->pmklist.head);
+                                        priv->pmklist.size++;
+                                } else {        /* overwrite old cache data */
+                                        pmk =
+                                            list_entry(priv->pmklist.head.prev,
+                                                       struct pmk_t, list);
+                                        memcpy(pmk->bssid, pmksa->bssid.sa_data,
+                                               ETH_ALEN);
+                                        memcpy(pmk->pmkid, pmksa->pmkid,
+                                               IW_PMKID_LEN);
+                                        list_move(&pmk->list,
+                                                  &priv->pmklist.head);
+                                }
+                        }
+                }
+                break;
+        case IW_PMKSA_REMOVE:
+                if (list_empty(&priv->pmklist.head)) {  /* list empty */
+                        return -EINVAL;
+                } else {        /* search cache data */
+                        list_for_each(ptr, &priv->pmklist.head) {
+                                pmk = list_entry(ptr, struct pmk_t, list);
+                                if (!memcmp(pmksa->bssid.sa_data, pmk->bssid, ETH_ALEN)) {      /* match address! list del. */
+                                        memset(pmk->bssid, 0, ETH_ALEN);
+                                        memset(pmk->pmkid, 0, IW_PMKID_LEN);
+                                        list_del_init(&pmk->list);
+                                        break;
+                                }
+                        }
+                        if (ptr == &priv->pmklist.head) {       /* not find address. */
+                                return 0;
+                        }
+                }
+                break;
+        case IW_PMKSA_FLUSH:
+                memset(&(priv->pmklist), 0, sizeof(priv->pmklist));
+                INIT_LIST_HEAD(&priv->pmklist.head);
+                for (i = 0; i < PMK_LIST_MAX; i++)
+                        INIT_LIST_HEAD(&priv->pmklist.pmk[i].list);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        hostif_sme_enqueue(priv, SME_SET_PMKSA);
+        return 0;
+}
+
+static struct iw_statistics *ks_get_wireless_stats(struct net_device *dev)
+{
+
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        struct iw_statistics *wstats = &priv->wstats;
+
+        if (!atomic_read(&update_phyinfo)) {
+                if (priv->dev_state < DEVICE_STATE_READY)
+                        return NULL;    /* not finished initialize */
+                else
+                        return wstats;
+        }
+
+        /* Packets discarded in the wireless adapter due to wireless
+         * specific problems */
+        wstats->discard.nwid = 0;       /* Rx invalid nwid      */
+        wstats->discard.code = 0;       /* Rx invalid crypt     */
+        wstats->discard.fragment = 0;   /* Rx invalid frag      */
+        wstats->discard.retries = 0;    /* Tx excessive retries */
+        wstats->discard.misc = 0;       /* Invalid misc         */
+        wstats->miss.beacon = 0;        /* Missed beacon        */
+
+        return wstats;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : set stop request */
+static int ks_wlan_set_stop_request(struct net_device *dev,
+                                    struct iw_request_info *info, __u32 * uwrq,
+                                    char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (!(*uwrq))
+                return -EINVAL;
+
+        hostif_sme_enqueue(priv, SME_STOP_REQUEST);
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Wireless Handler : set MLME */
+#include <linux/ieee80211.h>
+static int ks_wlan_set_mlme(struct net_device *dev,
+                            struct iw_request_info *info, struct iw_point *dwrq,
+                            char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        struct iw_mlme *mlme = (struct iw_mlme *)extra;
+        __u32 mode;
+
+        DPRINTK(2, ":%d :%d\n", mlme->cmd, mlme->reason_code);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        switch (mlme->cmd) {
+        case IW_MLME_DEAUTH:
+                if (mlme->reason_code == WLAN_REASON_MIC_FAILURE) {
+                        return 0;
+                }
+        case IW_MLME_DISASSOC:
+                mode = 1;
+                return ks_wlan_set_stop_request(dev, NULL, &mode, NULL);
+        default:
+                return -EOPNOTSUPP;     /* Not Support */
+        }
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get firemware version */
+static int ks_wlan_get_firmware_version(struct net_device *dev,
+                                        struct iw_request_info *info,
+                                        struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        strcpy(extra, &(priv->firmware_version[0]));
+        dwrq->length = priv->version_size + 1;
+        return 0;
+}
+
+#if 0
+/*------------------------------------------------------------------*/
+/* Private handler : set force disconnect status */
+static int ks_wlan_set_detach(struct net_device *dev,
+                              struct iw_request_info *info, __u32 * uwrq,
+                              char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq == CONNECT_STATUS) {  /* 0 */
+                priv->connect_status &= ~FORCE_DISCONNECT;
+                if ((priv->connect_status & CONNECT_STATUS_MASK) ==
+                    CONNECT_STATUS)
+                        netif_carrier_on(dev);
+        } else if (*uwrq == DISCONNECT_STATUS) {        /* 1 */
+                priv->connect_status |= FORCE_DISCONNECT;
+                netif_carrier_off(dev);
+        } else
+                return -EINVAL;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get force disconnect status */
+static int ks_wlan_get_detach(struct net_device *dev,
+                              struct iw_request_info *info, __u32 * uwrq,
+                              char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = ((priv->connect_status & FORCE_DISCONNECT) ? 1 : 0);
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get connect status */
+static int ks_wlan_get_connect(struct net_device *dev,
+                               struct iw_request_info *info, __u32 * uwrq,
+                               char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = (priv->connect_status & CONNECT_STATUS_MASK);
+        return 0;
+}
+#endif
+
+/*------------------------------------------------------------------*/
+/* Private handler : set preamble */
+static int ks_wlan_set_preamble(struct net_device *dev,
+                                struct iw_request_info *info, __u32 * uwrq,
+                                char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq == LONG_PREAMBLE) {   /* 0 */
+                priv->reg.preamble = LONG_PREAMBLE;
+        } else if (*uwrq == SHORT_PREAMBLE) {   /* 1 */
+                priv->reg.preamble = SHORT_PREAMBLE;
+        } else
+                return -EINVAL;
+
+        priv->need_commit |= SME_MODE_SET;
+        return -EINPROGRESS;    /* Call commit handler */
+
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get preamble */
+static int ks_wlan_get_preamble(struct net_device *dev,
+                                struct iw_request_info *info, __u32 * uwrq,
+                                char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->reg.preamble;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : set power save mode */
+static int ks_wlan_set_powermgt(struct net_device *dev,
+                                struct iw_request_info *info, __u32 * uwrq,
+                                char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq == POWMGT_ACTIVE_MODE) {      /* 0 */
+                priv->reg.powermgt = POWMGT_ACTIVE_MODE;
+        } else if (*uwrq == POWMGT_SAVE1_MODE) {        /* 1 */
+                if (priv->reg.operation_mode == MODE_INFRASTRUCTURE)
+                        priv->reg.powermgt = POWMGT_SAVE1_MODE;
+                else
+                        return -EINVAL;
+        } else if (*uwrq == POWMGT_SAVE2_MODE) {        /* 2 */
+                if (priv->reg.operation_mode == MODE_INFRASTRUCTURE)
+                        priv->reg.powermgt = POWMGT_SAVE2_MODE;
+                else
+                        return -EINVAL;
+        } else
+                return -EINVAL;
+
+        hostif_sme_enqueue(priv, SME_POW_MNGMT_REQUEST);
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get power save made */
+static int ks_wlan_get_powermgt(struct net_device *dev,
+                                struct iw_request_info *info, __u32 * uwrq,
+                                char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->reg.powermgt;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : set scan type */
+static int ks_wlan_set_scan_type(struct net_device *dev,
+                                 struct iw_request_info *info, __u32 * uwrq,
+                                 char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq == ACTIVE_SCAN) {     /* 0 */
+                priv->reg.scan_type = ACTIVE_SCAN;
+        } else if (*uwrq == PASSIVE_SCAN) {     /* 1 */
+                priv->reg.scan_type = PASSIVE_SCAN;
+        } else
+                return -EINVAL;
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get scan type */
+static int ks_wlan_get_scan_type(struct net_device *dev,
+                                 struct iw_request_info *info, __u32 * uwrq,
+                                 char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->reg.scan_type;
+        return 0;
+}
+
+#if 0
+/*------------------------------------------------------------------*/
+/* Private handler : write raw data to device */
+static int ks_wlan_data_write(struct net_device *dev,
+                              struct iw_request_info *info,
+                              struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+        unsigned char *wbuff = NULL;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        wbuff = (unsigned char *)kmalloc(dwrq->length, GFP_ATOMIC);
+        if (!wbuff)
+                return -EFAULT;
+        memcpy(wbuff, extra, dwrq->length);
+
+        /* write to device */
+        ks_wlan_hw_tx(priv, wbuff, dwrq->length, NULL, NULL, NULL);
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : read raw data form device */
+static int ks_wlan_data_read(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+        unsigned short read_length;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (!atomic_read(&priv->event_count)) {
+                if (priv->dev_state < DEVICE_STATE_BOOT) {      /* Remove device */
+                        read_length = 4;
+                        memset(extra, 0xff, read_length);
+                        dwrq->length = read_length;
+                        return 0;
+                }
+                read_length = 0;
+                memset(extra, 0, 1);
+                dwrq->length = 0;
+                return 0;
+        }
+
+        if (atomic_read(&priv->event_count) > 0)
+                atomic_dec(&priv->event_count);
+
+        spin_lock(&priv->dev_read_lock);        /* request spin lock */
+
+        /* Copy length max size 0x07ff */
+        if (priv->dev_size[priv->dev_count] > 2047)
+                read_length = 2047;
+        else
+                read_length = priv->dev_size[priv->dev_count];
+
+        /* Copy data */
+        memcpy(extra, &(priv->dev_data[priv->dev_count][0]), read_length);
+
+        spin_unlock(&priv->dev_read_lock);      /* release spin lock */
+
+        /* Initialize */
+        priv->dev_data[priv->dev_count] = 0;
+        priv->dev_size[priv->dev_count] = 0;
+
+        priv->dev_count++;
+        if (priv->dev_count == DEVICE_STOCK_COUNT)
+                priv->dev_count = 0;
+
+        /* Set read size */
+        dwrq->length = read_length;
+
+        return 0;
+}
+#endif
+
+#if 0
+/*------------------------------------------------------------------*/
+/* Private handler : get wep string */
+#define WEP_ASCII_BUFF_SIZE (17+64*4+1)
+static int ks_wlan_get_wep_ascii(struct net_device *dev,
+                                 struct iw_request_info *info,
+                                 struct iw_point *dwrq, char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+        int i, j, len = 0;
+        char tmp[WEP_ASCII_BUFF_SIZE];
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        strcpy(tmp, " WEP keys ASCII \n");
+        len += strlen(" WEP keys ASCII \n");
+
+        for (i = 0; i < 4; i++) {
+                strcpy(tmp + len, "\t[");
+                len += strlen("\t[");
+                tmp[len] = '1' + i;
+                len++;
+                strcpy(tmp + len, "] ");
+                len += strlen("] ");
+                if (priv->reg.wep_key[i].size) {
+                        strcpy(tmp + len,
+                               (priv->reg.wep_key[i].size <
+                                6 ? "(40bits) [" : "(104bits) ["));
+                        len +=
+                            strlen((priv->reg.wep_key[i].size <
+                                    6 ? "(40bits) [" : "(104bits) ["));
+                        for (j = 0; j < priv->reg.wep_key[i].size; j++, len++)
+                                tmp[len] =
+                                    (isprint(priv->reg.wep_key[i].val[j]) ?
+                                     priv->reg.wep_key[i].val[j] : ' ');
+
+                        strcpy(tmp + len, "]\n");
+                        len += strlen("]\n");
+                } else {
+                        strcpy(tmp + len, "off\n");
+                        len += strlen("off\n");
+                }
+        }
+
+        memcpy(extra, tmp, len);
+        dwrq->length = len + 1;
+        return 0;
+}
+#endif
+
+/*------------------------------------------------------------------*/
+/* Private handler : set beacon lost count */
+static int ks_wlan_set_beacon_lost(struct net_device *dev,
+                                   struct iw_request_info *info, __u32 * uwrq,
+                                   char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq >= BEACON_LOST_COUNT_MIN && *uwrq <= BEACON_LOST_COUNT_MAX) {
+                priv->reg.beacon_lost_count = *uwrq;
+        } else
+                return -EINVAL;
+
+        if (priv->reg.operation_mode == MODE_INFRASTRUCTURE) {
+                priv->need_commit |= SME_MODE_SET;
+                return -EINPROGRESS;    /* Call commit handler */
+        } else
+                return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get beacon lost count */
+static int ks_wlan_get_beacon_lost(struct net_device *dev,
+                                   struct iw_request_info *info, __u32 * uwrq,
+                                   char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->reg.beacon_lost_count;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : set phy type */
+static int ks_wlan_set_phy_type(struct net_device *dev,
+                                struct iw_request_info *info, __u32 * uwrq,
+                                char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq == D_11B_ONLY_MODE) { /* 0 */
+                priv->reg.phy_type = D_11B_ONLY_MODE;
+        } else if (*uwrq == D_11G_ONLY_MODE) {  /* 1 */
+                priv->reg.phy_type = D_11G_ONLY_MODE;
+        } else if (*uwrq == D_11BG_COMPATIBLE_MODE) {   /* 2 */
+                priv->reg.phy_type = D_11BG_COMPATIBLE_MODE;
+        } else
+                return -EINVAL;
+
+        priv->need_commit |= SME_MODE_SET;
+        return -EINPROGRESS;    /* Call commit handler */
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get phy type */
+static int ks_wlan_get_phy_type(struct net_device *dev,
+                                struct iw_request_info *info, __u32 * uwrq,
+                                char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->reg.phy_type;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : set cts mode */
+static int ks_wlan_set_cts_mode(struct net_device *dev,
+                                struct iw_request_info *info, __u32 * uwrq,
+                                char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq == CTS_MODE_FALSE) {  /* 0 */
+                priv->reg.cts_mode = CTS_MODE_FALSE;
+        } else if (*uwrq == CTS_MODE_TRUE) {    /* 1 */
+                if (priv->reg.phy_type == D_11G_ONLY_MODE ||
+                    priv->reg.phy_type == D_11BG_COMPATIBLE_MODE)
+                        priv->reg.cts_mode = CTS_MODE_TRUE;
+                else
+                        priv->reg.cts_mode = CTS_MODE_FALSE;
+        } else
+                return -EINVAL;
+
+        priv->need_commit |= SME_MODE_SET;
+        return -EINPROGRESS;    /* Call commit handler */
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get cts mode */
+static int ks_wlan_get_cts_mode(struct net_device *dev,
+                                struct iw_request_info *info, __u32 * uwrq,
+                                char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->reg.cts_mode;
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : set sleep mode */
+static int ks_wlan_set_sleep_mode(struct net_device *dev,
+                                  struct iw_request_info *info,
+                                  __u32 * uwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        DPRINTK(2, "\n");
+
+        if (*uwrq == SLP_SLEEP) {
+                priv->sleep_mode = *uwrq;
+                printk("SET_SLEEP_MODE %d\n", priv->sleep_mode);
+
+                hostif_sme_enqueue(priv, SME_STOP_REQUEST);
+                hostif_sme_enqueue(priv, SME_SLEEP_REQUEST);
+
+        } else if (*uwrq == SLP_ACTIVE) {
+                priv->sleep_mode = *uwrq;
+                printk("SET_SLEEP_MODE %d\n", priv->sleep_mode);
+                hostif_sme_enqueue(priv, SME_SLEEP_REQUEST);
+        } else {
+                printk("SET_SLEEP_MODE %d errror\n", *uwrq);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get sleep mode */
+static int ks_wlan_get_sleep_mode(struct net_device *dev,
+                                  struct iw_request_info *info,
+                                  __u32 * uwrq, char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        DPRINTK(2, "GET_SLEEP_MODE %d\n", priv->sleep_mode);
+        *uwrq = priv->sleep_mode;
+
+        return 0;
+}
+
+#if 0
+/*------------------------------------------------------------------*/
+/* Private handler : set phy information timer */
+static int ks_wlan_set_phy_information_timer(struct net_device *dev,
+                                             struct iw_request_info *info,
+                                             __u32 * uwrq, char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq >= 0 && *uwrq <= 0xFFFF)      /* 0-65535 */
+                priv->reg.phy_info_timer = (uint16_t) * uwrq;
+        else
+                return -EINVAL;
+
+        hostif_sme_enqueue(priv, SME_PHY_INFO_REQUEST);
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get phy information timer */
+static int ks_wlan_get_phy_information_timer(struct net_device *dev,
+                                             struct iw_request_info *info,
+                                             __u32 * uwrq, char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->reg.phy_info_timer;
+        return 0;
+}
+#endif
+
+#ifdef WPS
+/*------------------------------------------------------------------*/
+/* Private handler : set WPS enable */
+static int ks_wlan_set_wps_enable(struct net_device *dev,
+                                  struct iw_request_info *info, __u32 * uwrq,
+                                  char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq == 0 || *uwrq == 1)
+                priv->wps.wps_enabled = *uwrq;
+        else
+                return -EINVAL;
+
+        hostif_sme_enqueue(priv, SME_WPS_ENABLE_REQUEST);
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get WPS enable */
+static int ks_wlan_get_wps_enable(struct net_device *dev,
+                                  struct iw_request_info *info, __u32 * uwrq,
+                                  char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->wps.wps_enabled;
+        printk("return=%d\n", *uwrq);
+
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : set WPS probe req */
+static int ks_wlan_set_wps_probe_req(struct net_device *dev,
+                                     struct iw_request_info *info,
+                                     struct iw_point *dwrq, char *extra)
+{
+        uint8_t *p = extra;
+        unsigned char len;
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        DPRINTK(2, "dwrq->length=%d\n", dwrq->length);
+
+        /* length check */
+        if (p[1] + 2 != dwrq->length || dwrq->length > 256) {
+                return -EINVAL;
+        }
+
+        priv->wps.ielen = p[1] + 2 + 1; /* IE header + IE + sizeof(len) */
+        len = p[1] + 2; /* IE header + IE */
+
+        memcpy(priv->wps.ie, &len, sizeof(len));
+        p = memcpy(priv->wps.ie + 1, p, len);
+
+        DPRINTK(2, "%d(%#x): %02X %02X %02X %02X ... %02X %02X %02X\n",
+                priv->wps.ielen, priv->wps.ielen, p[0], p[1], p[2], p[3],
+                p[priv->wps.ielen - 3], p[priv->wps.ielen - 2],
+                p[priv->wps.ielen - 1]);
+
+        hostif_sme_enqueue(priv, SME_WPS_PROBE_REQUEST);
+
+        return 0;
+}
+
+#if 0
+/*------------------------------------------------------------------*/
+/* Private handler : get WPS probe req */
+static int ks_wlan_get_wps_probe_req(struct net_device *dev,
+                                     struct iw_request_info *info,
+                                     __u32 * uwrq, char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+        DPRINTK(2, "\n");
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        return 0;
+}
+#endif
+#endif /* WPS */
+
+/*------------------------------------------------------------------*/
+/* Private handler : set tx gain control value */
+static int ks_wlan_set_tx_gain(struct net_device *dev,
+                               struct iw_request_info *info, __u32 * uwrq,
+                               char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq >= 0 && *uwrq <= 0xFF)        /* 0-255 */
+                priv->gain.TxGain = (uint8_t) * uwrq;
+        else
+                return -EINVAL;
+
+        if (priv->gain.TxGain < 0xFF)
+                priv->gain.TxMode = 1;
+        else
+                priv->gain.TxMode = 0;
+
+        hostif_sme_enqueue(priv, SME_SET_GAIN);
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get tx gain control value */
+static int ks_wlan_get_tx_gain(struct net_device *dev,
+                               struct iw_request_info *info, __u32 * uwrq,
+                               char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->gain.TxGain;
+        hostif_sme_enqueue(priv, SME_GET_GAIN);
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : set rx gain control value */
+static int ks_wlan_set_rx_gain(struct net_device *dev,
+                               struct iw_request_info *info, __u32 * uwrq,
+                               char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq >= 0 && *uwrq <= 0xFF)        /* 0-255 */
+                priv->gain.RxGain = (uint8_t) * uwrq;
+        else
+                return -EINVAL;
+
+        if (priv->gain.RxGain < 0xFF)
+                priv->gain.RxMode = 1;
+        else
+                priv->gain.RxMode = 0;
+
+        hostif_sme_enqueue(priv, SME_SET_GAIN);
+        return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get rx gain control value */
+static int ks_wlan_get_rx_gain(struct net_device *dev,
+                               struct iw_request_info *info, __u32 * uwrq,
+                               char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        *uwrq = priv->gain.RxGain;
+        hostif_sme_enqueue(priv, SME_GET_GAIN);
+        return 0;
+}
+
+#if 0
+/*------------------------------------------------------------------*/
+/* Private handler : set region value */
+static int ks_wlan_set_region(struct net_device *dev,
+                              struct iw_request_info *info, __u32 * uwrq,
+                              char *extra)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev->priv;
+
+        if (priv->sleep_mode == SLP_SLEEP) {
+                return -EPERM;
+        }
+        /* for SLEEP MODE */
+        if (*uwrq >= 0x9 && *uwrq <= 0xF)       /* 0x9-0xf */
+                priv->region = (uint8_t) * uwrq;
+        else
+                return -EINVAL;
+
+        hostif_sme_enqueue(priv, SME_SET_REGION);
+        return 0;
+}
+#endif
+
+/*------------------------------------------------------------------*/
+/* Private handler : get eeprom checksum result */
+static int ks_wlan_get_eeprom_cksum(struct net_device *dev,
+                                    struct iw_request_info *info, __u32 * uwrq,
+                                    char *extra)
+{
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        *uwrq = priv->eeprom_checksum;
+        return 0;
+}
+
+static void print_hif_event(int event)
+{
+
+        switch (event) {
+        case HIF_DATA_REQ:
+                printk("HIF_DATA_REQ\n");
+                break;
+        case HIF_DATA_IND:
+                printk("HIF_DATA_IND\n");
+                break;
+        case HIF_MIB_GET_REQ:
+                printk("HIF_MIB_GET_REQ\n");
+                break;
+        case HIF_MIB_GET_CONF:
+                printk("HIF_MIB_GET_CONF\n");
+                break;
+        case HIF_MIB_SET_REQ:
+                printk("HIF_MIB_SET_REQ\n");
+                break;
+        case HIF_MIB_SET_CONF:
+                printk("HIF_MIB_SET_CONF\n");
+                break;
+        case HIF_POWERMGT_REQ:
+                printk("HIF_POWERMGT_REQ\n");
+                break;
+        case HIF_POWERMGT_CONF:
+                printk("HIF_POWERMGT_CONF\n");
+                break;
+        case HIF_START_REQ:
+                printk("HIF_START_REQ\n");
+                break;
+        case HIF_START_CONF:
+                printk("HIF_START_CONF\n");
+                break;
+        case HIF_CONNECT_IND:
+                printk("HIF_CONNECT_IND\n");
+                break;
+        case HIF_STOP_REQ:
+                printk("HIF_STOP_REQ\n");
+                break;
+        case HIF_STOP_CONF:
+                printk("HIF_STOP_CONF\n");
+                break;
+        case HIF_PS_ADH_SET_REQ:
+                printk("HIF_PS_ADH_SET_REQ\n");
+                break;
+        case HIF_PS_ADH_SET_CONF:
+                printk("HIF_PS_ADH_SET_CONF\n");
+                break;
+        case HIF_INFRA_SET_REQ:
+                printk("HIF_INFRA_SET_REQ\n");
+                break;
+        case HIF_INFRA_SET_CONF:
+                printk("HIF_INFRA_SET_CONF\n");
+                break;
+        case HIF_ADH_SET_REQ:
+                printk("HIF_ADH_SET_REQ\n");
+                break;
+        case HIF_ADH_SET_CONF:
+                printk("HIF_ADH_SET_CONF\n");
+                break;
+        case HIF_AP_SET_REQ:
+                printk("HIF_AP_SET_REQ\n");
+                break;
+        case HIF_AP_SET_CONF:
+                printk("HIF_AP_SET_CONF\n");
+                break;
+        case HIF_ASSOC_INFO_IND:
+                printk("HIF_ASSOC_INFO_IND\n");
+                break;
+        case HIF_MIC_FAILURE_REQ:
+                printk("HIF_MIC_FAILURE_REQ\n");
+                break;
+        case HIF_MIC_FAILURE_CONF:
+                printk("HIF_MIC_FAILURE_CONF\n");
+                break;
+        case HIF_SCAN_REQ:
+                printk("HIF_SCAN_REQ\n");
+                break;
+        case HIF_SCAN_CONF:
+                printk("HIF_SCAN_CONF\n");
+                break;
+        case HIF_PHY_INFO_REQ:
+                printk("HIF_PHY_INFO_REQ\n");
+                break;
+        case HIF_PHY_INFO_CONF:
+                printk("HIF_PHY_INFO_CONF\n");
+                break;
+        case HIF_SLEEP_REQ:
+                printk("HIF_SLEEP_REQ\n");
+                break;
+        case HIF_SLEEP_CONF:
+                printk("HIF_SLEEP_CONF\n");
+                break;
+        case HIF_PHY_INFO_IND:
+                printk("HIF_PHY_INFO_IND\n");
+                break;
+        case HIF_SCAN_IND:
+                printk("HIF_SCAN_IND\n");
+                break;
+        case HIF_INFRA_SET2_REQ:
+                printk("HIF_INFRA_SET2_REQ\n");
+                break;
+        case HIF_INFRA_SET2_CONF:
+                printk("HIF_INFRA_SET2_CONF\n");
+                break;
+        case HIF_ADH_SET2_REQ:
+                printk("HIF_ADH_SET2_REQ\n");
+                break;
+        case HIF_ADH_SET2_CONF:
+                printk("HIF_ADH_SET2_CONF\n");
+        }
+}
+
+/*------------------------------------------------------------------*/
+/* Private handler : get host command history */
+static int ks_wlan_hostt(struct net_device *dev, struct iw_request_info *info,
+                         __u32 * uwrq, char *extra)
+{
+        int i, event;
+        struct ks_wlan_private *priv =
+            (struct ks_wlan_private *)netdev_priv(dev);
+
+        for (i = 63; i >= 0; i--) {
+                event =
+                    priv->hostt.buff[(priv->hostt.qtail - 1 - i) %
+                                     SME_EVENT_BUFF_SIZE];
+                print_hif_event(event);
+        }
+        return 0;
+}
+
+/* Structures to export the Wireless Handlers */
+
+static const struct iw_priv_args ks_wlan_private_args[] = {
+/*{ cmd, set_args, get_args, name[16] } */
+        {KS_WLAN_GET_FIRM_VERSION, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_CHAR | (128 + 1), "GetFirmwareVer"},
+#ifdef WPS
+        {KS_WLAN_SET_WPS_ENABLE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetWPSEnable"},
+        {KS_WLAN_GET_WPS_ENABLE, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetW"},
+        {KS_WLAN_SET_WPS_PROBE_REQ, IW_PRIV_TYPE_BYTE | 2047, IW_PRIV_TYPE_NONE,
+         "SetWPSProbeReq"},
+#endif /* WPS */
+        {KS_WLAN_SET_PREAMBLE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetPreamble"},
+        {KS_WLAN_GET_PREAMBLE, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetPreamble"},
+        {KS_WLAN_SET_POWER_SAVE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetPowerSave"},
+        {KS_WLAN_GET_POWER_SAVE, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetPowerSave"},
+        {KS_WLAN_SET_SCAN_TYPE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetScanType"},
+        {KS_WLAN_GET_SCAN_TYPE, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetScanType"},
+        {KS_WLAN_SET_RX_GAIN, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetRxGain"},
+        {KS_WLAN_GET_RX_GAIN, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetRxGain"},
+        {KS_WLAN_HOSTT, IW_PRIV_TYPE_NONE, IW_PRIV_TYPE_CHAR | (128 + 1),
+         "hostt"},
+        {KS_WLAN_SET_BEACON_LOST, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetBeaconLost"},
+        {KS_WLAN_GET_BEACON_LOST, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetBeaconLost"},
+        {KS_WLAN_SET_SLEEP_MODE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetSleepMode"},
+        {KS_WLAN_GET_SLEEP_MODE, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetSleepMode"},
+        {KS_WLAN_SET_TX_GAIN, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetTxGain"},
+        {KS_WLAN_GET_TX_GAIN, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetTxGain"},
+        {KS_WLAN_SET_PHY_TYPE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetPhyType"},
+        {KS_WLAN_GET_PHY_TYPE, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetPhyType"},
+        {KS_WLAN_SET_CTS_MODE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+         IW_PRIV_TYPE_NONE, "SetCtsMode"},
+        {KS_WLAN_GET_CTS_MODE, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetCtsMode"},
+        {KS_WLAN_GET_EEPROM_CKSUM, IW_PRIV_TYPE_NONE,
+         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "GetChecksum"},
+};
+
+static const iw_handler ks_wlan_handler[] = {
+        (iw_handler) ks_wlan_config_commit,     /* SIOCSIWCOMMIT */
+        (iw_handler) ks_wlan_get_name,  /* SIOCGIWNAME */
+        (iw_handler) NULL,      /* SIOCSIWNWID */
+        (iw_handler) NULL,      /* SIOCGIWNWID */
+        (iw_handler) ks_wlan_set_freq,  /* SIOCSIWFREQ */
+        (iw_handler) ks_wlan_get_freq,  /* SIOCGIWFREQ */
+        (iw_handler) ks_wlan_set_mode,  /* SIOCSIWMODE */
+        (iw_handler) ks_wlan_get_mode,  /* SIOCGIWMODE */
+#ifndef KSC_OPNOTSUPP
+        (iw_handler) ks_wlan_set_sens,  /* SIOCSIWSENS */
+        (iw_handler) ks_wlan_get_sens,  /* SIOCGIWSENS */
+#else /* KSC_OPNOTSUPP */
+        (iw_handler) NULL,      /* SIOCSIWSENS */
+        (iw_handler) NULL,      /* SIOCGIWSENS */
+#endif /* KSC_OPNOTSUPP */
+        (iw_handler) NULL,      /* SIOCSIWRANGE */
+        (iw_handler) ks_wlan_get_range, /* SIOCGIWRANGE */
+        (iw_handler) NULL,      /* SIOCSIWPRIV */
+        (iw_handler) NULL,      /* SIOCGIWPRIV */
+        (iw_handler) NULL,      /* SIOCSIWSTATS */
+        (iw_handler) ks_wlan_get_iwstats,       /* SIOCGIWSTATS */
+        (iw_handler) NULL,      /* SIOCSIWSPY */
+        (iw_handler) NULL,      /* SIOCGIWSPY */
+        (iw_handler) NULL,      /* SIOCSIWTHRSPY */
+        (iw_handler) NULL,      /* SIOCGIWTHRSPY */
+        (iw_handler) ks_wlan_set_wap,   /* SIOCSIWAP */
+        (iw_handler) ks_wlan_get_wap,   /* SIOCGIWAP */
+//      (iw_handler) NULL,                      /* SIOCSIWMLME */
+        (iw_handler) ks_wlan_set_mlme,  /* SIOCSIWMLME */
+        (iw_handler) ks_wlan_get_aplist,        /* SIOCGIWAPLIST */
+        (iw_handler) ks_wlan_set_scan,  /* SIOCSIWSCAN */
+        (iw_handler) ks_wlan_get_scan,  /* SIOCGIWSCAN */
+        (iw_handler) ks_wlan_set_essid, /* SIOCSIWESSID */
+        (iw_handler) ks_wlan_get_essid, /* SIOCGIWESSID */
+        (iw_handler) ks_wlan_set_nick,  /* SIOCSIWNICKN */
+        (iw_handler) ks_wlan_get_nick,  /* SIOCGIWNICKN */
+        (iw_handler) NULL,      /* -- hole -- */
+        (iw_handler) NULL,      /* -- hole -- */
+        (iw_handler) ks_wlan_set_rate,  /* SIOCSIWRATE */
+        (iw_handler) ks_wlan_get_rate,  /* SIOCGIWRATE */
+        (iw_handler) ks_wlan_set_rts,   /* SIOCSIWRTS */
+        (iw_handler) ks_wlan_get_rts,   /* SIOCGIWRTS */
+        (iw_handler) ks_wlan_set_frag,  /* SIOCSIWFRAG */
+        (iw_handler) ks_wlan_get_frag,  /* SIOCGIWFRAG */
+#ifndef KSC_OPNOTSUPP
+        (iw_handler) ks_wlan_set_txpow, /* SIOCSIWTXPOW */
+        (iw_handler) ks_wlan_get_txpow, /* SIOCGIWTXPOW */
+        (iw_handler) ks_wlan_set_retry, /* SIOCSIWRETRY */
+        (iw_handler) ks_wlan_get_retry, /* SIOCGIWRETRY */
+#else /* KSC_OPNOTSUPP */
+        (iw_handler) NULL,      /* SIOCSIWTXPOW */
+        (iw_handler) NULL,      /* SIOCGIWTXPOW */
+        (iw_handler) NULL,      /* SIOCSIWRETRY */
+        (iw_handler) NULL,      /* SIOCGIWRETRY */
+#endif /* KSC_OPNOTSUPP */
+        (iw_handler) ks_wlan_set_encode,        /* SIOCSIWENCODE */
+        (iw_handler) ks_wlan_get_encode,        /* SIOCGIWENCODE */
+        (iw_handler) ks_wlan_set_power, /* SIOCSIWPOWER */
+        (iw_handler) ks_wlan_get_power, /* SIOCGIWPOWER */
+        (iw_handler) NULL,      /* -- hole -- */
+        (iw_handler) NULL,      /* -- hole -- */
+//      (iw_handler) NULL,                      /* SIOCSIWGENIE */
+        (iw_handler) ks_wlan_set_genie, /* SIOCSIWGENIE */
+        (iw_handler) NULL,      /* SIOCGIWGENIE */
+        (iw_handler) ks_wlan_set_auth_mode,     /* SIOCSIWAUTH */
+        (iw_handler) ks_wlan_get_auth_mode,     /* SIOCGIWAUTH */
+        (iw_handler) ks_wlan_set_encode_ext,    /* SIOCSIWENCODEEXT */
+        (iw_handler) ks_wlan_get_encode_ext,    /* SIOCGIWENCODEEXT */
+        (iw_handler) ks_wlan_set_pmksa, /* SIOCSIWPMKSA */
+        (iw_handler) NULL,      /* -- hole -- */
+};
+
+/* private_handler */
+static const iw_handler ks_wlan_private_handler[] = {
+        (iw_handler) NULL,      /*  0 */
+        (iw_handler) NULL,      /*  1, used to be: KS_WLAN_GET_DRIVER_VERSION */
+        (iw_handler) NULL,      /*  2 */
+        (iw_handler) ks_wlan_get_firmware_version,      /*  3 KS_WLAN_GET_FIRM_VERSION */
+#ifdef WPS
+        (iw_handler) ks_wlan_set_wps_enable,    /*  4 KS_WLAN_SET_WPS_ENABLE  */
+        (iw_handler) ks_wlan_get_wps_enable,    /*  5 KS_WLAN_GET_WPS_ENABLE  */
+        (iw_handler) ks_wlan_set_wps_probe_req, /*  6 KS_WLAN_SET_WPS_PROBE_REQ */
+#else
+        (iw_handler) NULL,      /*  4 */
+        (iw_handler) NULL,      /*  5 */
+        (iw_handler) NULL,      /*  6 */
+#endif /* WPS */
+
+        (iw_handler) ks_wlan_get_eeprom_cksum,  /*  7 KS_WLAN_GET_CONNECT */
+        (iw_handler) ks_wlan_set_preamble,      /*  8 KS_WLAN_SET_PREAMBLE */
+        (iw_handler) ks_wlan_get_preamble,      /*  9 KS_WLAN_GET_PREAMBLE */
+        (iw_handler) ks_wlan_set_powermgt,      /* 10 KS_WLAN_SET_POWER_SAVE */
+        (iw_handler) ks_wlan_get_powermgt,      /* 11 KS_WLAN_GET_POWER_SAVE */
+        (iw_handler) ks_wlan_set_scan_type,     /* 12 KS_WLAN_SET_SCAN_TYPE */
+        (iw_handler) ks_wlan_get_scan_type,     /* 13 KS_WLAN_GET_SCAN_TYPE */
+        (iw_handler) ks_wlan_set_rx_gain,       /* 14 KS_WLAN_SET_RX_GAIN */
+        (iw_handler) ks_wlan_get_rx_gain,       /* 15 KS_WLAN_GET_RX_GAIN */
+        (iw_handler) ks_wlan_hostt,     /* 16 KS_WLAN_HOSTT */
+        (iw_handler) NULL,      /* 17 */
+        (iw_handler) ks_wlan_set_beacon_lost,   /* 18 KS_WLAN_SET_BECAN_LOST */
+        (iw_handler) ks_wlan_get_beacon_lost,   /* 19 KS_WLAN_GET_BECAN_LOST */
+        (iw_handler) ks_wlan_set_tx_gain,       /* 20 KS_WLAN_SET_TX_GAIN */
+        (iw_handler) ks_wlan_get_tx_gain,       /* 21 KS_WLAN_GET_TX_GAIN */
+        (iw_handler) ks_wlan_set_phy_type,      /* 22 KS_WLAN_SET_PHY_TYPE */
+        (iw_handler) ks_wlan_get_phy_type,      /* 23 KS_WLAN_GET_PHY_TYPE */
+        (iw_handler) ks_wlan_set_cts_mode,      /* 24 KS_WLAN_SET_CTS_MODE */
+        (iw_handler) ks_wlan_get_cts_mode,      /* 25 KS_WLAN_GET_CTS_MODE */
+        (iw_handler) NULL,      /* 26 */
+        (iw_handler) NULL,      /* 27 */
+        (iw_handler) ks_wlan_set_sleep_mode,    /* 28 KS_WLAN_SET_SLEEP_MODE */
+        (iw_handler) ks_wlan_get_sleep_mode,    /* 29 KS_WLAN_GET_SLEEP_MODE */
+        (iw_handler) NULL,      /* 30 */
+        (iw_handler) NULL,      /* 31 */
+};
+
+static const struct iw_handler_def ks_wlan_handler_def = {
+        .num_standard = sizeof(ks_wlan_handler) / sizeof(iw_handler),
+        .num_private = sizeof(ks_wlan_private_handler) / sizeof(iw_handler),
+        .num_private_args =
+            sizeof(ks_wlan_private_args) / sizeof(struct iw_priv_args),
+        .standard = (iw_handler *) ks_wlan_handler,
+        .private = (iw_handler *) ks_wlan_private_handler,
+        .private_args = (struct iw_priv_args *)ks_wlan_private_args,
+        .get_wireless_stats = ks_get_wireless_stats,
+};
+
+static int ks_wlan_netdev_ioctl(struct net_device *dev, struct ifreq *rq,
+                                int cmd)
+{
+        int rc = 0;
+        struct iwreq *wrq = (struct iwreq *)rq;
+        switch (cmd) {
+        case SIOCIWFIRSTPRIV + 20:      /* KS_WLAN_SET_STOP_REQ */
+                rc = ks_wlan_set_stop_request(dev, NULL, &(wrq->u.mode), NULL);
+                break;
+                // All other calls are currently unsupported
+        default:
+                rc = -EOPNOTSUPP;
+        }
+
+        DPRINTK(5, "return=%d\n", rc);
+        return rc;
+}
+
+static
+struct net_device_stats *ks_wlan_get_stats(struct net_device *dev)
+{
+        struct ks_wlan_private *priv = netdev_priv(dev);
+
+        if (priv->dev_state < DEVICE_STATE_READY) {
+                return NULL;    /* not finished initialize */
+        }
+
+        return &priv->nstats;
+}
+
+static
+int ks_wlan_set_mac_address(struct net_device *dev, void *addr)
+{
+        struct ks_wlan_private *priv = netdev_priv(dev);
+        struct sockaddr *mac_addr = (struct sockaddr *)addr;
+        if (netif_running(dev))
+                return -EBUSY;
+        memcpy(dev->dev_addr, mac_addr->sa_data, dev->addr_len);
+        memcpy(priv->eth_addr, mac_addr->sa_data, ETH_ALEN);
+
+        priv->mac_address_valid = 0;
+        hostif_sme_enqueue(priv, SME_MACADDRESS_SET_REQUEST);
+        printk(KERN_INFO
+               "ks_wlan: MAC ADDRESS = %02x:%02x:%02x:%02x:%02x:%02x\n",
+               priv->eth_addr[0], priv->eth_addr[1], priv->eth_addr[2],
+               priv->eth_addr[3], priv->eth_addr[4], priv->eth_addr[5]);
+        return 0;
+}
+
+static
+void ks_wlan_tx_timeout(struct net_device *dev)
+{
+        struct ks_wlan_private *priv = netdev_priv(dev);
+
+        DPRINTK(1, "head(%d) tail(%d)!!\n", priv->tx_dev.qhead,
+                priv->tx_dev.qtail);
+        if (!netif_queue_stopped(dev)) {
+                netif_stop_queue(dev);
+        }
+        priv->nstats.tx_errors++;
+        netif_wake_queue(dev);
+
+        return;
+}
+
+static
+int ks_wlan_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct ks_wlan_private *priv = netdev_priv(dev);
+        int rc = 0;
+
+        DPRINTK(3, "in_interrupt()=%ld\n", in_interrupt());
+
+        if (skb == NULL) {
+                printk(KERN_ERR "ks_wlan:  skb == NULL!!!\n");
+                return 0;
+        }
+        if (priv->dev_state < DEVICE_STATE_READY) {
+                dev_kfree_skb(skb);
+                return 0;       /* not finished initialize */
+        }
+
+        if (netif_running(dev))
+                netif_stop_queue(dev);
+
+        rc = hostif_data_request(priv, skb);
+        netif_trans_update(dev);
+
+        DPRINTK(4, "rc=%d\n", rc);
+        if (rc) {
+                rc = 0;
+        }
+
+        return rc;
+}
+
+void send_packet_complete(void *arg1, void *arg2)
+{
+        struct ks_wlan_private *priv = (struct ks_wlan_private *)arg1;
+        struct sk_buff *packet = (struct sk_buff *)arg2;
+
+        DPRINTK(3, "\n");
+
+        priv->nstats.tx_bytes += packet->len;
+        priv->nstats.tx_packets++;
+
+        if (netif_queue_stopped(priv->net_dev))
+                netif_wake_queue(priv->net_dev);
+
+        if (packet) {
+                dev_kfree_skb(packet);
+                packet = NULL;
+        }
+
+}
+
+/* Set or clear the multicast filter for this adaptor.
+   This routine is not state sensitive and need not be SMP locked. */
+static
+void ks_wlan_set_multicast_list(struct net_device *dev)
+{
+        struct ks_wlan_private *priv = netdev_priv(dev);
+
+        DPRINTK(4, "\n");
+        if (priv->dev_state < DEVICE_STATE_READY) {
+                return; /* not finished initialize */
+        }
+        hostif_sme_enqueue(priv, SME_MULTICAST_REQUEST);
+
+        return;
+}
+
+static
+int ks_wlan_open(struct net_device *dev)
+{
+        struct ks_wlan_private *priv = netdev_priv(dev);
+
+        priv->cur_rx = 0;
+
+        if (!priv->mac_address_valid) {
+                printk(KERN_ERR "ks_wlan : %s Not READY !!\n", dev->name);
+                return -EBUSY;
+        } else
+                netif_start_queue(dev);
+
+        return 0;
+}
+
+static
+int ks_wlan_close(struct net_device *dev)
+{
+
+        netif_stop_queue(dev);
+
+        DPRINTK(4, "%s: Shutting down ethercard, status was 0x%4.4x.\n",
+                dev->name, 0x00);
+
+        return 0;
+}
+
+/* Operational parameters that usually are not changed. */
+/* Time in jiffies before concluding the transmitter is hung. */
+#define TX_TIMEOUT  (3*HZ)
+static const unsigned char dummy_addr[] =
+    { 0x00, 0x0b, 0xe3, 0x00, 0x00, 0x00 };
+
+static const struct net_device_ops ks_wlan_netdev_ops = {
+        .ndo_start_xmit = ks_wlan_start_xmit,
+        .ndo_open = ks_wlan_open,
+        .ndo_stop = ks_wlan_close,
+        .ndo_do_ioctl = ks_wlan_netdev_ioctl,
+        .ndo_set_mac_address = ks_wlan_set_mac_address,
+        .ndo_get_stats = ks_wlan_get_stats,
+        .ndo_tx_timeout = ks_wlan_tx_timeout,
+        .ndo_set_rx_mode = ks_wlan_set_multicast_list,
+};
+
+int ks_wlan_net_start(struct net_device *dev)
+{
+        struct ks_wlan_private *priv;
+        /* int rc; */
+
+        priv = netdev_priv(dev);
+        priv->mac_address_valid = 0;
+        priv->need_commit = 0;
+
+        priv->device_open_status = 1;
+
+        /* phy information update timer */
+        atomic_set(&update_phyinfo, 0);
+        init_timer(&update_phyinfo_timer);
+        update_phyinfo_timer.function = ks_wlan_update_phyinfo_timeout;
+        update_phyinfo_timer.data = (unsigned long)priv;
+
+        /* dummy address set */
+        memcpy(priv->eth_addr, dummy_addr, ETH_ALEN);
+        dev->dev_addr[0] = priv->eth_addr[0];
+        dev->dev_addr[1] = priv->eth_addr[1];
+        dev->dev_addr[2] = priv->eth_addr[2];
+        dev->dev_addr[3] = priv->eth_addr[3];
+        dev->dev_addr[4] = priv->eth_addr[4];
+        dev->dev_addr[5] = priv->eth_addr[5];
+        dev->dev_addr[6] = 0x00;
+        dev->dev_addr[7] = 0x00;
+
+        /* The ks_wlan-specific entries in the device structure. */
+        dev->netdev_ops = &ks_wlan_netdev_ops;
+        dev->wireless_handlers = (struct iw_handler_def *)&ks_wlan_handler_def;
+        dev->watchdog_timeo = TX_TIMEOUT;
+
+        netif_carrier_off(dev);
+
+        return 0;
+}
+
+int ks_wlan_net_stop(struct net_device *dev)
+{
+        struct ks_wlan_private *priv = netdev_priv(dev);
+
+        int ret = 0;
+        priv->device_open_status = 0;
+        del_timer_sync(&update_phyinfo_timer);
+
+        if (netif_running(dev))
+                netif_stop_queue(dev);
+
+        return ret;
+}
+
+int ks_wlan_reset(struct net_device *dev)
+{
+        return 0;
+}
diff --git a/drivers/staging/ks7010/michael_mic.c b/drivers/staging/ks7010/michael_mic.c
new file mode 100644
index 000000000000..e14c109b3cab
--- /dev/null
+++ b/drivers/staging/ks7010/michael_mic.c
@@ -0,0 +1,139 @@
+/*
+ *   Driver for KeyStream wireless LAN
+ *
+ *   Copyright (C) 2005-2008 KeyStream Corp.
+ *   Copyright (C) 2009 Renesas Technology Corp.
+ *
+ *   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.
+ */
+
+#include <linux/types.h>
+#include <linux/string.h>
+#include "michael_mic.h"
+
+// Rotation functions on 32 bit values
+#define ROL32( A, n )   ( ((A) << (n)) | ( ((A)>>(32-(n))) & ( (1UL << (n)) - 1 ) ) )
+#define ROR32( A, n )   ROL32( (A), 32-(n) )
+// Convert from Byte[] to UInt32 in a portable way
+#define getUInt32( A, B )       (uint32_t)(A[B+0] << 0) + (A[B+1] << 8) + (A[B+2] << 16) + (A[B+3] << 24)
+
+// Convert from UInt32 to Byte[] in a portable way
+#define putUInt32( A, B, C )    A[B+0] = (uint8_t) (C & 0xff);          \
+                                A[B+1] = (uint8_t) ((C>>8) & 0xff);     \
+                                A[B+2] = (uint8_t) ((C>>16) & 0xff);    \
+                                A[B+3] = (uint8_t) ((C>>24) & 0xff)
+
+// Reset the state to the empty message.
+#define MichaelClear( A )       A->L = A->K0; \
+                                A->R = A->K1; \
+                                A->nBytesInM = 0;
+
+static
+void MichaelInitializeFunction(struct michel_mic_t *Mic, uint8_t * key)
+{
+        // Set the key
+        Mic->K0 = getUInt32(key, 0);
+        Mic->K1 = getUInt32(key, 4);
+
+        //clear();
+        MichaelClear(Mic);
+}
+
+#define MichaelBlockFunction(L, R)                              \
+do{                                                             \
+        R ^= ROL32( L, 17 );                                    \
+        L += R;                                                 \
+        R ^= ((L & 0xff00ff00) >> 8) | ((L & 0x00ff00ff) << 8); \
+        L += R;                                                 \
+        R ^= ROL32( L, 3 );                                     \
+        L += R;                                                 \
+        R ^= ROR32( L, 2 );                                     \
+        L += R;                                                 \
+}while(0)
+
+static
+void MichaelAppend(struct michel_mic_t *Mic, uint8_t * src, int nBytes)
+{
+        int addlen;
+        if (Mic->nBytesInM) {
+                addlen = 4 - Mic->nBytesInM;
+                if (addlen > nBytes)
+                        addlen = nBytes;
+                memcpy(&Mic->M[Mic->nBytesInM], src, addlen);
+                Mic->nBytesInM += addlen;
+                src += addlen;
+                nBytes -= addlen;
+
+                if (Mic->nBytesInM < 4)
+                        return;
+
+                Mic->L ^= getUInt32(Mic->M, 0);
+                MichaelBlockFunction(Mic->L, Mic->R);
+                Mic->nBytesInM = 0;
+        }
+
+        while (nBytes >= 4) {
+                Mic->L ^= getUInt32(src, 0);
+                MichaelBlockFunction(Mic->L, Mic->R);
+                src += 4;
+                nBytes -= 4;
+        }
+
+        if (nBytes > 0) {
+                Mic->nBytesInM = nBytes;
+                memcpy(Mic->M, src, nBytes);
+        }
+}
+
+static
+void MichaelGetMIC(struct michel_mic_t *Mic, uint8_t * dst)
+{
+        uint8_t *data = Mic->M;
+        switch (Mic->nBytesInM) {
+        case 0:
+                Mic->L ^= 0x5a;
+                break;
+        case 1:
+                Mic->L ^= data[0] | 0x5a00;
+                break;
+        case 2:
+                Mic->L ^= data[0] | (data[1] << 8) | 0x5a0000;
+                break;
+        case 3:
+                Mic->L ^= data[0] | (data[1] << 8) | (data[2] << 16) |
+                    0x5a000000;
+                break;
+        }
+        MichaelBlockFunction(Mic->L, Mic->R);
+        MichaelBlockFunction(Mic->L, Mic->R);
+        // The appendByte function has already computed the result.
+        putUInt32(dst, 0, Mic->L);
+        putUInt32(dst, 4, Mic->R);
+
+        // Reset to the empty message.
+        MichaelClear(Mic);
+}
+
+void MichaelMICFunction(struct michel_mic_t *Mic, uint8_t * Key,
+                        uint8_t * Data, int Len, uint8_t priority,
+                        uint8_t * Result)
+{
+        uint8_t pad_data[4] = { priority, 0, 0, 0 };
+        // Compute the MIC value
+        /*
+         * IEEE802.11i  page 47
+         * Figure 43g TKIP MIC processing format
+         * +--+--+--------+--+----+--+--+--+--+--+--+--+--+
+         * |6 |6 |1       |3 |M   |1 |1 |1 |1 |1 |1 |1 |1 | Octet
+         * +--+--+--------+--+----+--+--+--+--+--+--+--+--+
+         * |DA|SA|Priority|0 |Data|M0|M1|M2|M3|M4|M5|M6|M7|
+         * +--+--+--------+--+----+--+--+--+--+--+--+--+--+
+         */
+        MichaelInitializeFunction(Mic, Key);
+        MichaelAppend(Mic, (uint8_t *) Data, 12);       /* |DA|SA| */
+        MichaelAppend(Mic, pad_data, 4);        /* |Priority|0|0|0| */
+        MichaelAppend(Mic, (uint8_t *) (Data + 12), Len - 12);  /* |Data| */
+        MichaelGetMIC(Mic, Result);
+}
diff --git a/drivers/staging/ks7010/michael_mic.h b/drivers/staging/ks7010/michael_mic.h
new file mode 100644
index 000000000000..c7e4eb280961
--- /dev/null
+++ b/drivers/staging/ks7010/michael_mic.h
@@ -0,0 +1,26 @@
+/*
+ *   Driver for KeyStream wireless LAN
+ *
+ *   Copyright (C) 2005-2008 KeyStream Corp.
+ *   Copyright (C) 2009 Renesas Technology Corp.
+ *
+ *   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.
+ */
+
+/* MichelMIC routine define */
+struct michel_mic_t {
+        uint32_t K0;    // Key 
+        uint32_t K1;    // Key 
+        uint32_t L;     // Current state 
+        uint32_t R;     // Current state 
+        uint8_t M[4];   // Message accumulator (single word) 
+        int nBytesInM;  // # bytes in M 
+        uint8_t Result[8];
+};
+
+extern
+void MichaelMICFunction(struct michel_mic_t *Mic, uint8_t * Key,
+                        uint8_t * Data, int Len, uint8_t priority,
+                        uint8_t * Result);
diff --git a/drivers/staging/lustre/include/linux/libcfs/curproc.h b/drivers/staging/lustre/include/linux/libcfs/curproc.h
index 1edfca58c1c6..be0675d8ff5e 100644
--- a/drivers/staging/lustre/include/linux/libcfs/curproc.h
+++ b/drivers/staging/lustre/include/linux/libcfs/curproc.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs.h b/drivers/staging/lustre/include/linux/libcfs/libcfs.h
index 4141afb101bb..3f6447c65042 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_debug.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_debug.h
index 455c54d0d17c..25adab19fd86 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_debug.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_debug.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_fail.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_fail.h
index 2e008bffc89a..d3f9a6020ee3 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_fail.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_fail.h
@@ -16,10 +16,6 @@
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see http://www.gnu.org/licenses
  *
- * Please contact Oracle Corporation, Inc., 500 Oracle Parkway, Redwood Shores,
- * CA 94065 USA or visit www.oracle.com if you need additional information or
- * have any questions.
- *
  * GPL HEADER END
  */
 /*
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_hash.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_hash.h
index 119986bc7961..6949a1846635 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_hash.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_hash.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_ioctl.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_ioctl.h
index 4b9102bd95d5..cce6b58e3682 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_ioctl.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_ioctl.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_prim.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_prim.h
index ac4e8cfe6c8c..8c75d5075590 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_prim.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_prim.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_private.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_private.h
index 2fd2a9690a34..4daa3823f60a 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_private.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_private.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_string.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_string.h
index e02cde5aeca1..0ee60ff336f2 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_string.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_string.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_time.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_time.h
index 2c7ec2d28f38..008da4497bda 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_time.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_time.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_workitem.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_workitem.h
index f9b20c5accbf..a7e1340e69a1 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_workitem.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_workitem.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/linux/libcfs.h b/drivers/staging/lustre/include/linux/libcfs/linux/libcfs.h
index a268ef7aa19d..e8695e4a39d1 100644
--- a/drivers/staging/lustre/include/linux/libcfs/linux/libcfs.h
+++ b/drivers/staging/lustre/include/linux/libcfs/linux/libcfs.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/libcfs/linux/linux-time.h b/drivers/staging/lustre/include/linux/libcfs/linux/linux-time.h
index 7656b09b8752..b646acd1f7e7 100644
--- a/drivers/staging/lustre/include/linux/libcfs/linux/linux-time.h
+++ b/drivers/staging/lustre/include/linux/libcfs/linux/linux-time.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/include/linux/lnet/lib-dlc.h b/drivers/staging/lustre/include/linux/lnet/lib-dlc.h
index 6ce9accb91ad..dfff17088403 100644
--- a/drivers/staging/lustre/include/linux/lnet/lib-dlc.h
+++ b/drivers/staging/lustre/include/linux/lnet/lib-dlc.h
@@ -35,7 +35,7 @@
 #define MAX_NUM_SHOW_ENTRIES    32
 #define LNET_MAX_STR_LEN        128
 #define LNET_MAX_SHOW_NUM_CPT   128
-#define LNET_UNDEFINED_HOPS     ((__u32) -1)
+#define LNET_UNDEFINED_HOPS     ((__u32)(-1))
 
 struct lnet_ioctl_config_lnd_cmn_tunables {
         __u32 lct_version;
diff --git a/drivers/staging/lustre/include/linux/lnet/lib-types.h b/drivers/staging/lustre/include/linux/lnet/lib-types.h
index 24c4a08e6dc6..7967b013cbae 100644
--- a/drivers/staging/lustre/include/linux/lnet/lib-types.h
+++ b/drivers/staging/lustre/include/linux/lnet/lib-types.h
@@ -38,6 +38,7 @@
 #include <linux/kthread.h>
 #include <linux/uio.h>
 #include <linux/types.h>
+#include <linux/completion.h>
 
 #include "types.h"
 #include "lnetctl.h"
@@ -610,7 +611,7 @@ typedef struct {
         /* rcd ready for free */
         struct list_head                  ln_rcd_zombie;
         /* serialise startup/shutdown */
-        struct semaphore                  ln_rc_signal;
+        struct completion                 ln_rc_signal;
 
         struct mutex                      ln_api_mutex;
         struct mutex                      ln_lnd_mutex;
diff --git a/drivers/staging/lustre/include/linux/lnet/types.h b/drivers/staging/lustre/include/linux/lnet/types.h
index 1c679cb72785..e098b6c086e1 100644
--- a/drivers/staging/lustre/include/linux/lnet/types.h
+++ b/drivers/staging/lustre/include/linux/lnet/types.h
@@ -68,9 +68,9 @@ typedef __u64 lnet_nid_t;
 typedef __u32 lnet_pid_t;
 
 /** wildcard NID that matches any end-point address */
-#define LNET_NID_ANY    ((lnet_nid_t) -1)
+#define LNET_NID_ANY    ((lnet_nid_t)(-1))
 /** wildcard PID that matches any lnet_pid_t */
-#define LNET_PID_ANY    ((lnet_pid_t) -1)
+#define LNET_PID_ANY    ((lnet_pid_t)(-1))
 
 #define LNET_PID_RESERVED 0xf0000000 /* reserved bits in PID */
 #define LNET_PID_USERFLAG 0x80000000 /* set in userspace peers */
diff --git a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c
index 6c59f2ff2220..4f5978b3767b 100644
--- a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c
+++ b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -44,7 +40,7 @@
 
 static lnd_t the_o2iblnd;
 
-kib_data_t kiblnd_data;
+struct kib_data kiblnd_data;
 
 static __u32 kiblnd_cksum(void *ptr, int nob)
 {
@@ -98,40 +94,40 @@ static char *kiblnd_msgtype2str(int type)
 
 static int kiblnd_msgtype2size(int type)
 {
-        const int hdr_size = offsetof(kib_msg_t, ibm_u);
+        const int hdr_size = offsetof(struct kib_msg, ibm_u);
 
         switch (type) {
         case IBLND_MSG_CONNREQ:
         case IBLND_MSG_CONNACK:
-                return hdr_size + sizeof(kib_connparams_t);
+                return hdr_size + sizeof(struct kib_connparams);
 
         case IBLND_MSG_NOOP:
                 return hdr_size;
 
         case IBLND_MSG_IMMEDIATE:
-                return offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[0]);
+                return offsetof(struct kib_msg, ibm_u.immediate.ibim_payload[0]);
 
         case IBLND_MSG_PUT_REQ:
-                return hdr_size + sizeof(kib_putreq_msg_t);
+                return hdr_size + sizeof(struct kib_putreq_msg);
 
         case IBLND_MSG_PUT_ACK:
-                return hdr_size + sizeof(kib_putack_msg_t);
+                return hdr_size + sizeof(struct kib_putack_msg);
 
         case IBLND_MSG_GET_REQ:
-                return hdr_size + sizeof(kib_get_msg_t);
+                return hdr_size + sizeof(struct kib_get_msg);
 
         case IBLND_MSG_PUT_NAK:
         case IBLND_MSG_PUT_DONE:
         case IBLND_MSG_GET_DONE:
-                return hdr_size + sizeof(kib_completion_msg_t);
+                return hdr_size + sizeof(struct kib_completion_msg);
         default:
                 return -1;
         }
 }
 
-static int kiblnd_unpack_rd(kib_msg_t *msg, int flip)
+static int kiblnd_unpack_rd(struct kib_msg *msg, int flip)
 {
-        kib_rdma_desc_t *rd;
+        struct kib_rdma_desc *rd;
         int nob;
         int n;
         int i;
@@ -156,7 +152,7 @@ static int kiblnd_unpack_rd(kib_msg_t *msg, int flip)
                 return 1;
         }
 
-        nob = offsetof(kib_msg_t, ibm_u) +
+        nob = offsetof(struct kib_msg, ibm_u) +
               kiblnd_rd_msg_size(rd, msg->ibm_type, n);
 
         if (msg->ibm_nob < nob) {
@@ -176,10 +172,10 @@ static int kiblnd_unpack_rd(kib_msg_t *msg, int flip)
         return 0;
 }
 
-void kiblnd_pack_msg(lnet_ni_t *ni, kib_msg_t *msg, int version,
+void kiblnd_pack_msg(lnet_ni_t *ni, struct kib_msg *msg, int version,
                      int credits, lnet_nid_t dstnid, __u64 dststamp)
 {
-        kib_net_t *net = ni->ni_data;
+        struct kib_net *net = ni->ni_data;
 
         /*
          * CAVEAT EMPTOR! all message fields not set here should have been
@@ -202,9 +198,9 @@ void kiblnd_pack_msg(lnet_ni_t *ni, kib_msg_t *msg, int version,
         }
 }
 
-int kiblnd_unpack_msg(kib_msg_t *msg, int nob)
+int kiblnd_unpack_msg(struct kib_msg *msg, int nob)
 {
-        const int hdr_size = offsetof(kib_msg_t, ibm_u);
+        const int hdr_size = offsetof(struct kib_msg, ibm_u);
         __u32 msg_cksum;
         __u16 version;
         int msg_nob;
@@ -315,10 +311,10 @@ int kiblnd_unpack_msg(kib_msg_t *msg, int nob)
         return 0;
 }
 
-int kiblnd_create_peer(lnet_ni_t *ni, kib_peer_t **peerp, lnet_nid_t nid)
+int kiblnd_create_peer(lnet_ni_t *ni, struct kib_peer **peerp, lnet_nid_t nid)
 {
-        kib_peer_t *peer;
-        kib_net_t *net = ni->ni_data;
+        struct kib_peer *peer;
+        struct kib_net *net = ni->ni_data;
         int cpt = lnet_cpt_of_nid(nid);
         unsigned long flags;
 
@@ -357,9 +353,9 @@ int kiblnd_create_peer(lnet_ni_t *ni, kib_peer_t **peerp, lnet_nid_t nid)
         return 0;
 }
 
-void kiblnd_destroy_peer(kib_peer_t *peer)
+void kiblnd_destroy_peer(struct kib_peer *peer)
 {
-        kib_net_t *net = peer->ibp_ni->ni_data;
+        struct kib_net *net = peer->ibp_ni->ni_data;
 
         LASSERT(net);
         LASSERT(!atomic_read(&peer->ibp_refcount));
@@ -378,7 +374,7 @@ void kiblnd_destroy_peer(kib_peer_t *peer)
         atomic_dec(&net->ibn_npeers);
 }
 
-kib_peer_t *kiblnd_find_peer_locked(lnet_nid_t nid)
+struct kib_peer *kiblnd_find_peer_locked(lnet_nid_t nid)
 {
         /*
          * the caller is responsible for accounting the additional reference
@@ -386,10 +382,10 @@ kib_peer_t *kiblnd_find_peer_locked(lnet_nid_t nid)
          */
         struct list_head *peer_list = kiblnd_nid2peerlist(nid);
         struct list_head *tmp;
-        kib_peer_t *peer;
+        struct kib_peer *peer;
 
         list_for_each(tmp, peer_list) {
-                peer = list_entry(tmp, kib_peer_t, ibp_list);
+                peer = list_entry(tmp, struct kib_peer, ibp_list);
                 LASSERT(!kiblnd_peer_idle(peer));
 
                 if (peer->ibp_nid != nid)
@@ -404,7 +400,7 @@ kib_peer_t *kiblnd_find_peer_locked(lnet_nid_t nid)
         return NULL;
 }
 
-void kiblnd_unlink_peer_locked(kib_peer_t *peer)
+void kiblnd_unlink_peer_locked(struct kib_peer *peer)
 {
         LASSERT(list_empty(&peer->ibp_conns));
 
@@ -417,7 +413,7 @@ void kiblnd_unlink_peer_locked(kib_peer_t *peer)
 static int kiblnd_get_peer_info(lnet_ni_t *ni, int index,
                                 lnet_nid_t *nidp, int *count)
 {
-        kib_peer_t *peer;
+        struct kib_peer *peer;
         struct list_head *ptmp;
         int i;
         unsigned long flags;
@@ -426,7 +422,7 @@ static int kiblnd_get_peer_info(lnet_ni_t *ni, int index,
 
         for (i = 0; i < kiblnd_data.kib_peer_hash_size; i++) {
                 list_for_each(ptmp, &kiblnd_data.kib_peers[i]) {
-                        peer = list_entry(ptmp, kib_peer_t, ibp_list);
+                        peer = list_entry(ptmp, struct kib_peer, ibp_list);
                         LASSERT(!kiblnd_peer_idle(peer));
 
                         if (peer->ibp_ni != ni)
@@ -448,17 +444,17 @@ static int kiblnd_get_peer_info(lnet_ni_t *ni, int index,
         return -ENOENT;
 }
 
-static void kiblnd_del_peer_locked(kib_peer_t *peer)
+static void kiblnd_del_peer_locked(struct kib_peer *peer)
 {
         struct list_head *ctmp;
         struct list_head *cnxt;
-        kib_conn_t *conn;
+        struct kib_conn *conn;
 
         if (list_empty(&peer->ibp_conns)) {
                 kiblnd_unlink_peer_locked(peer);
         } else {
                 list_for_each_safe(ctmp, cnxt, &peer->ibp_conns) {
-                        conn = list_entry(ctmp, kib_conn_t, ibc_list);
+                        conn = list_entry(ctmp, struct kib_conn, ibc_list);
 
                         kiblnd_close_conn_locked(conn, 0);
                 }
@@ -475,7 +471,7 @@ static int kiblnd_del_peer(lnet_ni_t *ni, lnet_nid_t nid)
         LIST_HEAD(zombies);
         struct list_head *ptmp;
         struct list_head *pnxt;
-        kib_peer_t *peer;
+        struct kib_peer *peer;
         int lo;
         int hi;
         int i;
@@ -494,7 +490,7 @@ static int kiblnd_del_peer(lnet_ni_t *ni, lnet_nid_t nid)
 
         for (i = lo; i <= hi; i++) {
                 list_for_each_safe(ptmp, pnxt, &kiblnd_data.kib_peers[i]) {
-                        peer = list_entry(ptmp, kib_peer_t, ibp_list);
+                        peer = list_entry(ptmp, struct kib_peer, ibp_list);
                         LASSERT(!kiblnd_peer_idle(peer));
 
                         if (peer->ibp_ni != ni)
@@ -522,11 +518,11 @@ static int kiblnd_del_peer(lnet_ni_t *ni, lnet_nid_t nid)
         return rc;
 }
 
-static kib_conn_t *kiblnd_get_conn_by_idx(lnet_ni_t *ni, int index)
+static struct kib_conn *kiblnd_get_conn_by_idx(lnet_ni_t *ni, int index)
 {
-        kib_peer_t *peer;
+        struct kib_peer *peer;
         struct list_head *ptmp;
-        kib_conn_t *conn;
+        struct kib_conn *conn;
         struct list_head *ctmp;
         int i;
         unsigned long flags;
@@ -535,7 +531,7 @@ static kib_conn_t *kiblnd_get_conn_by_idx(lnet_ni_t *ni, int index)
 
         for (i = 0; i < kiblnd_data.kib_peer_hash_size; i++) {
                 list_for_each(ptmp, &kiblnd_data.kib_peers[i]) {
-                        peer = list_entry(ptmp, kib_peer_t, ibp_list);
+                        peer = list_entry(ptmp, struct kib_peer, ibp_list);
                         LASSERT(!kiblnd_peer_idle(peer));
 
                         if (peer->ibp_ni != ni)
@@ -545,7 +541,7 @@ static kib_conn_t *kiblnd_get_conn_by_idx(lnet_ni_t *ni, int index)
                                 if (index-- > 0)
                                         continue;
 
-                                conn = list_entry(ctmp, kib_conn_t,
+                                conn = list_entry(ctmp, struct kib_conn,
                                                   ibc_list);
                                 kiblnd_conn_addref(conn);
                                 read_unlock_irqrestore(
@@ -594,7 +590,7 @@ static void kiblnd_setup_mtu_locked(struct rdma_cm_id *cmid)
                 cmid->route.path_rec->mtu = mtu;
 }
 
-static int kiblnd_get_completion_vector(kib_conn_t *conn, int cpt)
+static int kiblnd_get_completion_vector(struct kib_conn *conn, int cpt)
 {
         cpumask_t *mask;
         int vectors;
@@ -621,7 +617,7 @@ static int kiblnd_get_completion_vector(kib_conn_t *conn, int cpt)
         return 1;
 }
 
-kib_conn_t *kiblnd_create_conn(kib_peer_t *peer, struct rdma_cm_id *cmid,
+struct kib_conn *kiblnd_create_conn(struct kib_peer *peer, struct rdma_cm_id *cmid,
                                int state, int version)
 {
         /*
@@ -634,12 +630,12 @@ kib_conn_t *kiblnd_create_conn(kib_peer_t *peer, struct rdma_cm_id *cmid,
          * its ref on 'cmid').
          */
         rwlock_t *glock = &kiblnd_data.kib_global_lock;
-        kib_net_t *net = peer->ibp_ni->ni_data;
-        kib_dev_t *dev;
+        struct kib_net *net = peer->ibp_ni->ni_data;
+        struct kib_dev *dev;
         struct ib_qp_init_attr *init_qp_attr;
         struct kib_sched_info *sched;
         struct ib_cq_init_attr cq_attr = {};
-        kib_conn_t *conn;
+        struct kib_conn *conn;
         struct ib_cq *cq;
         unsigned long flags;
         int cpt;
@@ -723,7 +719,7 @@ kib_conn_t *kiblnd_create_conn(kib_peer_t *peer, struct rdma_cm_id *cmid,
         write_unlock_irqrestore(glock, flags);
 
         LIBCFS_CPT_ALLOC(conn->ibc_rxs, lnet_cpt_table(), cpt,
-                         IBLND_RX_MSGS(conn) * sizeof(kib_rx_t));
+                         IBLND_RX_MSGS(conn) * sizeof(struct kib_rx));
         if (!conn->ibc_rxs) {
                 CERROR("Cannot allocate RX buffers\n");
                 goto failed_2;
@@ -833,10 +829,10 @@ kib_conn_t *kiblnd_create_conn(kib_peer_t *peer, struct rdma_cm_id *cmid,
         return NULL;
 }
 
-void kiblnd_destroy_conn(kib_conn_t *conn, bool free_conn)
+void kiblnd_destroy_conn(struct kib_conn *conn, bool free_conn)
 {
         struct rdma_cm_id *cmid = conn->ibc_cmid;
-        kib_peer_t *peer = conn->ibc_peer;
+        struct kib_peer *peer = conn->ibc_peer;
         int rc;
 
         LASSERT(!in_interrupt());
@@ -879,7 +875,7 @@ void kiblnd_destroy_conn(kib_conn_t *conn, bool free_conn)
 
         if (conn->ibc_rxs) {
                 LIBCFS_FREE(conn->ibc_rxs,
-                            IBLND_RX_MSGS(conn) * sizeof(kib_rx_t));
+                            IBLND_RX_MSGS(conn) * sizeof(struct kib_rx));
         }
 
         if (conn->ibc_connvars)
@@ -890,7 +886,7 @@ void kiblnd_destroy_conn(kib_conn_t *conn, bool free_conn)
 
         /* See CAVEAT EMPTOR above in kiblnd_create_conn */
         if (conn->ibc_state != IBLND_CONN_INIT) {
-                kib_net_t *net = peer->ibp_ni->ni_data;
+                struct kib_net *net = peer->ibp_ni->ni_data;
 
                 kiblnd_peer_decref(peer);
                 rdma_destroy_id(cmid);
@@ -900,15 +896,15 @@ void kiblnd_destroy_conn(kib_conn_t *conn, bool free_conn)
         LIBCFS_FREE(conn, sizeof(*conn));
 }
 
-int kiblnd_close_peer_conns_locked(kib_peer_t *peer, int why)
+int kiblnd_close_peer_conns_locked(struct kib_peer *peer, int why)
 {
-        kib_conn_t *conn;
+        struct kib_conn *conn;
         struct list_head *ctmp;
         struct list_head *cnxt;
         int count = 0;
 
         list_for_each_safe(ctmp, cnxt, &peer->ibp_conns) {
-                conn = list_entry(ctmp, kib_conn_t, ibc_list);
+                conn = list_entry(ctmp, struct kib_conn, ibc_list);
 
                 CDEBUG(D_NET, "Closing conn -> %s, version: %x, reason: %d\n",
                        libcfs_nid2str(peer->ibp_nid),
@@ -921,16 +917,16 @@ int kiblnd_close_peer_conns_locked(kib_peer_t *peer, int why)
         return count;
 }
 
-int kiblnd_close_stale_conns_locked(kib_peer_t *peer,
+int kiblnd_close_stale_conns_locked(struct kib_peer *peer,
                                     int version, __u64 incarnation)
 {
-        kib_conn_t *conn;
+        struct kib_conn *conn;
         struct list_head *ctmp;
         struct list_head *cnxt;
         int count = 0;
 
         list_for_each_safe(ctmp, cnxt, &peer->ibp_conns) {
-                conn = list_entry(ctmp, kib_conn_t, ibc_list);
+                conn = list_entry(ctmp, struct kib_conn, ibc_list);
 
                 if (conn->ibc_version     == version &&
                     conn->ibc_incarnation == incarnation)
@@ -951,7 +947,7 @@ int kiblnd_close_stale_conns_locked(kib_peer_t *peer,
 
 static int kiblnd_close_matching_conns(lnet_ni_t *ni, lnet_nid_t nid)
 {
-        kib_peer_t *peer;
+        struct kib_peer *peer;
         struct list_head *ptmp;
         struct list_head *pnxt;
         int lo;
@@ -972,7 +968,7 @@ static int kiblnd_close_matching_conns(lnet_ni_t *ni, lnet_nid_t nid)
 
         for (i = lo; i <= hi; i++) {
                 list_for_each_safe(ptmp, pnxt, &kiblnd_data.kib_peers[i]) {
-                        peer = list_entry(ptmp, kib_peer_t, ibp_list);
+                        peer = list_entry(ptmp, struct kib_peer, ibp_list);
                         LASSERT(!kiblnd_peer_idle(peer));
 
                         if (peer->ibp_ni != ni)
@@ -1016,7 +1012,7 @@ static int kiblnd_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
                 break;
         }
         case IOC_LIBCFS_GET_CONN: {
-                kib_conn_t *conn;
+                struct kib_conn *conn;
 
                 rc = 0;
                 conn = kiblnd_get_conn_by_idx(ni, data->ioc_count);
@@ -1052,7 +1048,7 @@ static void kiblnd_query(lnet_ni_t *ni, lnet_nid_t nid, unsigned long *when)
         unsigned long last_alive = 0;
         unsigned long now = cfs_time_current();
         rwlock_t *glock = &kiblnd_data.kib_global_lock;
-        kib_peer_t *peer;
+        struct kib_peer *peer;
         unsigned long flags;
 
         read_lock_irqsave(glock, flags);
@@ -1078,7 +1074,7 @@ static void kiblnd_query(lnet_ni_t *ni, lnet_nid_t nid, unsigned long *when)
                last_alive ? cfs_duration_sec(now - last_alive) : -1);
 }
 
-static void kiblnd_free_pages(kib_pages_t *p)
+static void kiblnd_free_pages(struct kib_pages *p)
 {
         int npages = p->ibp_npages;
         int i;
@@ -1088,22 +1084,22 @@ static void kiblnd_free_pages(kib_pages_t *p)
                         __free_page(p->ibp_pages[i]);
         }
 
-        LIBCFS_FREE(p, offsetof(kib_pages_t, ibp_pages[npages]));
+        LIBCFS_FREE(p, offsetof(struct kib_pages, ibp_pages[npages]));
 }
 
-int kiblnd_alloc_pages(kib_pages_t **pp, int cpt, int npages)
+int kiblnd_alloc_pages(struct kib_pages **pp, int cpt, int npages)
 {
-        kib_pages_t *p;
+        struct kib_pages *p;
         int i;
 
         LIBCFS_CPT_ALLOC(p, lnet_cpt_table(), cpt,
-                         offsetof(kib_pages_t, ibp_pages[npages]));
+                         offsetof(struct kib_pages, ibp_pages[npages]));
         if (!p) {
                 CERROR("Can't allocate descriptor for %d pages\n", npages);
                 return -ENOMEM;
         }
 
-        memset(p, 0, offsetof(kib_pages_t, ibp_pages[npages]));
+        memset(p, 0, offsetof(struct kib_pages, ibp_pages[npages]));
         p->ibp_npages = npages;
 
         for (i = 0; i < npages; i++) {
@@ -1121,9 +1117,9 @@ int kiblnd_alloc_pages(kib_pages_t **pp, int cpt, int npages)
         return 0;
 }
 
-void kiblnd_unmap_rx_descs(kib_conn_t *conn)
+void kiblnd_unmap_rx_descs(struct kib_conn *conn)
 {
-        kib_rx_t *rx;
+        struct kib_rx *rx;
         int i;
 
         LASSERT(conn->ibc_rxs);
@@ -1145,9 +1141,9 @@ void kiblnd_unmap_rx_descs(kib_conn_t *conn)
         conn->ibc_rx_pages = NULL;
 }
 
-void kiblnd_map_rx_descs(kib_conn_t *conn)
+void kiblnd_map_rx_descs(struct kib_conn *conn)
 {
-        kib_rx_t *rx;
+        struct kib_rx *rx;
         struct page *pg;
         int pg_off;
         int ipg;
@@ -1158,7 +1154,7 @@ void kiblnd_map_rx_descs(kib_conn_t *conn)
                 rx = &conn->ibc_rxs[i];
 
                 rx->rx_conn = conn;
-                rx->rx_msg = (kib_msg_t *)(((char *)page_address(pg)) + pg_off);
+                rx->rx_msg = (struct kib_msg *)(((char *)page_address(pg)) + pg_off);
 
                 rx->rx_msgaddr = kiblnd_dma_map_single(conn->ibc_hdev->ibh_ibdev,
                                                        rx->rx_msg,
@@ -1183,10 +1179,10 @@ void kiblnd_map_rx_descs(kib_conn_t *conn)
         }
 }
 
-static void kiblnd_unmap_tx_pool(kib_tx_pool_t *tpo)
+static void kiblnd_unmap_tx_pool(struct kib_tx_pool *tpo)
 {
-        kib_hca_dev_t *hdev = tpo->tpo_hdev;
-        kib_tx_t *tx;
+        struct kib_hca_dev *hdev = tpo->tpo_hdev;
+        struct kib_tx *tx;
         int i;
 
         LASSERT(!tpo->tpo_pool.po_allocated);
@@ -1206,9 +1202,9 @@ static void kiblnd_unmap_tx_pool(kib_tx_pool_t *tpo)
         tpo->tpo_hdev = NULL;
 }
 
-static kib_hca_dev_t *kiblnd_current_hdev(kib_dev_t *dev)
+static struct kib_hca_dev *kiblnd_current_hdev(struct kib_dev *dev)
 {
-        kib_hca_dev_t *hdev;
+        struct kib_hca_dev *hdev;
         unsigned long flags;
         int i = 0;
 
@@ -1232,14 +1228,14 @@ static kib_hca_dev_t *kiblnd_current_hdev(kib_dev_t *dev)
         return hdev;
 }
 
-static void kiblnd_map_tx_pool(kib_tx_pool_t *tpo)
+static void kiblnd_map_tx_pool(struct kib_tx_pool *tpo)
 {
-        kib_pages_t *txpgs = tpo->tpo_tx_pages;
-        kib_pool_t *pool = &tpo->tpo_pool;
-        kib_net_t *net = pool->po_owner->ps_net;
-        kib_dev_t *dev;
+        struct kib_pages *txpgs = tpo->tpo_tx_pages;
+        struct kib_pool *pool = &tpo->tpo_pool;
+        struct kib_net *net = pool->po_owner->ps_net;
+        struct kib_dev *dev;
         struct page *page;
-        kib_tx_t *tx;
+        struct kib_tx *tx;
         int page_offset;
         int ipage;
         int i;
@@ -1260,7 +1256,7 @@ static void kiblnd_map_tx_pool(kib_tx_pool_t *tpo)
                 page = txpgs->ibp_pages[ipage];
                 tx = &tpo->tpo_tx_descs[i];
 
-                tx->tx_msg = (kib_msg_t *)(((char *)page_address(page)) +
+                tx->tx_msg = (struct kib_msg *)(((char *)page_address(page)) +
                                            page_offset);
 
                 tx->tx_msgaddr = kiblnd_dma_map_single(
@@ -1283,11 +1279,11 @@ static void kiblnd_map_tx_pool(kib_tx_pool_t *tpo)
         }
 }
 
-struct ib_mr *kiblnd_find_rd_dma_mr(struct lnet_ni *ni, kib_rdma_desc_t *rd,
+struct ib_mr *kiblnd_find_rd_dma_mr(struct lnet_ni *ni, struct kib_rdma_desc *rd,
                                     int negotiated_nfrags)
 {
-        kib_net_t *net = ni->ni_data;
-        kib_hca_dev_t *hdev = net->ibn_dev->ibd_hdev;
+        struct kib_net *net = ni->ni_data;
+        struct kib_hca_dev *hdev = net->ibn_dev->ibd_hdev;
         struct lnet_ioctl_config_o2iblnd_tunables *tunables;
         __u16 nfrags;
         int mod;
@@ -1304,7 +1300,7 @@ struct ib_mr *kiblnd_find_rd_dma_mr(struct lnet_ni *ni, kib_rdma_desc_t *rd,
         return hdev->ibh_mrs;
 }
 
-static void kiblnd_destroy_fmr_pool(kib_fmr_pool_t *fpo)
+static void kiblnd_destroy_fmr_pool(struct kib_fmr_pool *fpo)
 {
         LASSERT(!fpo->fpo_map_count);
 
@@ -1335,7 +1331,7 @@ static void kiblnd_destroy_fmr_pool(kib_fmr_pool_t *fpo)
 
 static void kiblnd_destroy_fmr_pool_list(struct list_head *head)
 {
-        kib_fmr_pool_t *fpo, *tmp;
+        struct kib_fmr_pool *fpo, *tmp;
 
         list_for_each_entry_safe(fpo, tmp, head, fpo_list) {
                 list_del(&fpo->fpo_list);
@@ -1361,7 +1357,7 @@ kiblnd_fmr_flush_trigger(struct lnet_ioctl_config_o2iblnd_tunables *tunables,
         return max(IBLND_FMR_POOL_FLUSH, size);
 }
 
-static int kiblnd_alloc_fmr_pool(kib_fmr_poolset_t *fps, kib_fmr_pool_t *fpo)
+static int kiblnd_alloc_fmr_pool(struct kib_fmr_poolset *fps, struct kib_fmr_pool *fpo)
 {
         struct ib_fmr_pool_param param = {
                 .max_pages_per_fmr = LNET_MAX_PAYLOAD / PAGE_SIZE,
@@ -1388,7 +1384,7 @@ static int kiblnd_alloc_fmr_pool(kib_fmr_poolset_t *fps, kib_fmr_pool_t *fpo)
         return rc;
 }
 
-static int kiblnd_alloc_freg_pool(kib_fmr_poolset_t *fps, kib_fmr_pool_t *fpo)
+static int kiblnd_alloc_freg_pool(struct kib_fmr_poolset *fps, struct kib_fmr_pool *fpo)
 {
         struct kib_fast_reg_descriptor *frd, *tmp;
         int i, rc;
@@ -1438,12 +1434,12 @@ out:
         return rc;
 }
 
-static int kiblnd_create_fmr_pool(kib_fmr_poolset_t *fps,
-                                  kib_fmr_pool_t **pp_fpo)
+static int kiblnd_create_fmr_pool(struct kib_fmr_poolset *fps,
+                                  struct kib_fmr_pool **pp_fpo)
 {
-        kib_dev_t *dev = fps->fps_net->ibn_dev;
+        struct kib_dev *dev = fps->fps_net->ibn_dev;
         struct ib_device_attr *dev_attr;
-        kib_fmr_pool_t *fpo;
+        struct kib_fmr_pool *fpo;
         int rc;
 
         LIBCFS_CPT_ALLOC(fpo, lnet_cpt_table(), fps->fps_cpt, sizeof(*fpo));
@@ -1488,7 +1484,7 @@ out_fpo:
         return rc;
 }
 
-static void kiblnd_fail_fmr_poolset(kib_fmr_poolset_t *fps,
+static void kiblnd_fail_fmr_poolset(struct kib_fmr_poolset *fps,
                                     struct list_head *zombies)
 {
         if (!fps->fps_net) /* intialized? */
@@ -1497,8 +1493,8 @@ static void kiblnd_fail_fmr_poolset(kib_fmr_poolset_t *fps,
         spin_lock(&fps->fps_lock);
 
         while (!list_empty(&fps->fps_pool_list)) {
-                kib_fmr_pool_t *fpo = list_entry(fps->fps_pool_list.next,
-                                                 kib_fmr_pool_t, fpo_list);
+                struct kib_fmr_pool *fpo = list_entry(fps->fps_pool_list.next,
+                                                 struct kib_fmr_pool, fpo_list);
                 fpo->fpo_failed = 1;
                 list_del(&fpo->fpo_list);
                 if (!fpo->fpo_map_count)
@@ -1510,7 +1506,7 @@ static void kiblnd_fail_fmr_poolset(kib_fmr_poolset_t *fps,
         spin_unlock(&fps->fps_lock);
 }
 
-static void kiblnd_fini_fmr_poolset(kib_fmr_poolset_t *fps)
+static void kiblnd_fini_fmr_poolset(struct kib_fmr_poolset *fps)
 {
         if (fps->fps_net) { /* initialized? */
                 kiblnd_destroy_fmr_pool_list(&fps->fps_failed_pool_list);
@@ -1519,11 +1515,11 @@ static void kiblnd_fini_fmr_poolset(kib_fmr_poolset_t *fps)
 }
 
 static int
-kiblnd_init_fmr_poolset(kib_fmr_poolset_t *fps, int cpt, int ncpts,
-                        kib_net_t *net,
+kiblnd_init_fmr_poolset(struct kib_fmr_poolset *fps, int cpt, int ncpts,
+                        struct kib_net *net,
                         struct lnet_ioctl_config_o2iblnd_tunables *tunables)
 {
-        kib_fmr_pool_t *fpo;
+        struct kib_fmr_pool *fpo;
         int rc;
 
         memset(fps, 0, sizeof(*fps));
@@ -1546,7 +1542,7 @@ kiblnd_init_fmr_poolset(kib_fmr_poolset_t *fps, int cpt, int ncpts,
         return rc;
 }
 
-static int kiblnd_fmr_pool_is_idle(kib_fmr_pool_t *fpo, unsigned long now)
+static int kiblnd_fmr_pool_is_idle(struct kib_fmr_pool *fpo, unsigned long now)
 {
         if (fpo->fpo_map_count) /* still in use */
                 return 0;
@@ -1556,10 +1552,10 @@ static int kiblnd_fmr_pool_is_idle(kib_fmr_pool_t *fpo, unsigned long now)
 }
 
 static int
-kiblnd_map_tx_pages(kib_tx_t *tx, kib_rdma_desc_t *rd)
+kiblnd_map_tx_pages(struct kib_tx *tx, struct kib_rdma_desc *rd)
 {
         __u64 *pages = tx->tx_pages;
-        kib_hca_dev_t *hdev;
+        struct kib_hca_dev *hdev;
         int npages;
         int size;
         int i;
@@ -1577,13 +1573,13 @@ kiblnd_map_tx_pages(kib_tx_t *tx, kib_rdma_desc_t *rd)
         return npages;
 }
 
-void kiblnd_fmr_pool_unmap(kib_fmr_t *fmr, int status)
+void kiblnd_fmr_pool_unmap(struct kib_fmr *fmr, int status)
 {
         LIST_HEAD(zombies);
-        kib_fmr_pool_t *fpo = fmr->fmr_pool;
-        kib_fmr_poolset_t *fps;
+        struct kib_fmr_pool *fpo = fmr->fmr_pool;
+        struct kib_fmr_poolset *fps;
         unsigned long now = cfs_time_current();
-        kib_fmr_pool_t *tmp;
+        struct kib_fmr_pool *tmp;
         int rc;
 
         if (!fpo)
@@ -1633,14 +1629,14 @@ void kiblnd_fmr_pool_unmap(kib_fmr_t *fmr, int status)
                 kiblnd_destroy_fmr_pool_list(&zombies);
 }
 
-int kiblnd_fmr_pool_map(kib_fmr_poolset_t *fps, kib_tx_t *tx,
-                        kib_rdma_desc_t *rd, __u32 nob, __u64 iov,
-                        kib_fmr_t *fmr)
+int kiblnd_fmr_pool_map(struct kib_fmr_poolset *fps, struct kib_tx *tx,
+                        struct kib_rdma_desc *rd, __u32 nob, __u64 iov,
+                        struct kib_fmr *fmr)
 {
         __u64 *pages = tx->tx_pages;
         bool is_rx = (rd != tx->tx_rd);
         bool tx_pages_mapped = 0;
-        kib_fmr_pool_t *fpo;
+        struct kib_fmr_pool *fpo;
         int npages = 0;
         __u64 version;
         int rc;
@@ -1780,7 +1776,7 @@ int kiblnd_fmr_pool_map(kib_fmr_poolset_t *fps, kib_tx_t *tx,
         goto again;
 }
 
-static void kiblnd_fini_pool(kib_pool_t *pool)
+static void kiblnd_fini_pool(struct kib_pool *pool)
 {
         LASSERT(list_empty(&pool->po_free_list));
         LASSERT(!pool->po_allocated);
@@ -1788,7 +1784,7 @@ static void kiblnd_fini_pool(kib_pool_t *pool)
         CDEBUG(D_NET, "Finalize %s pool\n", pool->po_owner->ps_name);
 }
 
-static void kiblnd_init_pool(kib_poolset_t *ps, kib_pool_t *pool, int size)
+static void kiblnd_init_pool(struct kib_poolset *ps, struct kib_pool *pool, int size)
 {
         CDEBUG(D_NET, "Initialize %s pool\n", ps->ps_name);
 
@@ -1801,10 +1797,10 @@ static void kiblnd_init_pool(kib_poolset_t *ps, kib_pool_t *pool, int size)
 
 static void kiblnd_destroy_pool_list(struct list_head *head)
 {
-        kib_pool_t *pool;
+        struct kib_pool *pool;
 
         while (!list_empty(head)) {
-                pool = list_entry(head->next, kib_pool_t, po_list);
+                pool = list_entry(head->next, struct kib_pool, po_list);
                 list_del(&pool->po_list);
 
                 LASSERT(pool->po_owner);
@@ -1812,15 +1808,15 @@ static void kiblnd_destroy_pool_list(struct list_head *head)
         }
 }
 
-static void kiblnd_fail_poolset(kib_poolset_t *ps, struct list_head *zombies)
+static void kiblnd_fail_poolset(struct kib_poolset *ps, struct list_head *zombies)
 {
         if (!ps->ps_net) /* intialized? */
                 return;
 
         spin_lock(&ps->ps_lock);
         while (!list_empty(&ps->ps_pool_list)) {
-                kib_pool_t *po = list_entry(ps->ps_pool_list.next,
-                                            kib_pool_t, po_list);
+                struct kib_pool *po = list_entry(ps->ps_pool_list.next,
+                                            struct kib_pool, po_list);
                 po->po_failed = 1;
                 list_del(&po->po_list);
                 if (!po->po_allocated)
@@ -1831,7 +1827,7 @@ static void kiblnd_fail_poolset(kib_poolset_t *ps, struct list_head *zombies)
         spin_unlock(&ps->ps_lock);
 }
 
-static void kiblnd_fini_poolset(kib_poolset_t *ps)
+static void kiblnd_fini_poolset(struct kib_poolset *ps)
 {
         if (ps->ps_net) { /* initialized? */
                 kiblnd_destroy_pool_list(&ps->ps_failed_pool_list);
@@ -1839,14 +1835,14 @@ static void kiblnd_fini_poolset(kib_poolset_t *ps)
         }
 }
 
-static int kiblnd_init_poolset(kib_poolset_t *ps, int cpt,
-                               kib_net_t *net, char *name, int size,
+static int kiblnd_init_poolset(struct kib_poolset *ps, int cpt,
+                               struct kib_net *net, char *name, int size,
                                kib_ps_pool_create_t po_create,
                                kib_ps_pool_destroy_t po_destroy,
                                kib_ps_node_init_t nd_init,
                                kib_ps_node_fini_t nd_fini)
 {
-        kib_pool_t *pool;
+        struct kib_pool *pool;
         int rc;
 
         memset(ps, 0, sizeof(*ps));
@@ -1874,7 +1870,7 @@ static int kiblnd_init_poolset(kib_poolset_t *ps, int cpt,
         return rc;
 }
 
-static int kiblnd_pool_is_idle(kib_pool_t *pool, unsigned long now)
+static int kiblnd_pool_is_idle(struct kib_pool *pool, unsigned long now)
 {
         if (pool->po_allocated) /* still in use */
                 return 0;
@@ -1883,11 +1879,11 @@ static int kiblnd_pool_is_idle(kib_pool_t *pool, unsigned long now)
         return cfs_time_aftereq(now, pool->po_deadline);
 }
 
-void kiblnd_pool_free_node(kib_pool_t *pool, struct list_head *node)
+void kiblnd_pool_free_node(struct kib_pool *pool, struct list_head *node)
 {
         LIST_HEAD(zombies);
-        kib_poolset_t *ps = pool->po_owner;
-        kib_pool_t *tmp;
+        struct kib_poolset *ps = pool->po_owner;
+        struct kib_pool *tmp;
         unsigned long now = cfs_time_current();
 
         spin_lock(&ps->ps_lock);
@@ -1913,10 +1909,10 @@ void kiblnd_pool_free_node(kib_pool_t *pool, struct list_head *node)
                 kiblnd_destroy_pool_list(&zombies);
 }
 
-struct list_head *kiblnd_pool_alloc_node(kib_poolset_t *ps)
+struct list_head *kiblnd_pool_alloc_node(struct kib_poolset *ps)
 {
         struct list_head *node;
-        kib_pool_t *pool;
+        struct kib_pool *pool;
         unsigned int interval = 1;
         unsigned long time_before;
         unsigned int trips = 0;
@@ -1986,9 +1982,9 @@ struct list_head *kiblnd_pool_alloc_node(kib_poolset_t *ps)
         goto again;
 }
 
-static void kiblnd_destroy_tx_pool(kib_pool_t *pool)
+static void kiblnd_destroy_tx_pool(struct kib_pool *pool)
 {
-        kib_tx_pool_t *tpo = container_of(pool, kib_tx_pool_t, tpo_pool);
+        struct kib_tx_pool *tpo = container_of(pool, struct kib_tx_pool, tpo_pool);
         int i;
 
         LASSERT(!pool->po_allocated);
@@ -2002,7 +1998,7 @@ static void kiblnd_destroy_tx_pool(kib_pool_t *pool)
                 goto out;
 
         for (i = 0; i < pool->po_size; i++) {
-                kib_tx_t *tx = &tpo->tpo_tx_descs[i];
+                struct kib_tx *tx = &tpo->tpo_tx_descs[i];
 
                 list_del(&tx->tx_list);
                 if (tx->tx_pages)
@@ -2011,8 +2007,8 @@ static void kiblnd_destroy_tx_pool(kib_pool_t *pool)
                                     sizeof(*tx->tx_pages));
                 if (tx->tx_frags)
                         LIBCFS_FREE(tx->tx_frags,
-                                    IBLND_MAX_RDMA_FRAGS *
-                                            sizeof(*tx->tx_frags));
+                                    (1 + IBLND_MAX_RDMA_FRAGS) *
+                                     sizeof(*tx->tx_frags));
                 if (tx->tx_wrq)
                         LIBCFS_FREE(tx->tx_wrq,
                                     (1 + IBLND_MAX_RDMA_FRAGS) *
@@ -2023,12 +2019,12 @@ static void kiblnd_destroy_tx_pool(kib_pool_t *pool)
                                     sizeof(*tx->tx_sge));
                 if (tx->tx_rd)
                         LIBCFS_FREE(tx->tx_rd,
-                                    offsetof(kib_rdma_desc_t,
+                                    offsetof(struct kib_rdma_desc,
                                              rd_frags[IBLND_MAX_RDMA_FRAGS]));
         }
 
         LIBCFS_FREE(tpo->tpo_tx_descs,
-                    pool->po_size * sizeof(kib_tx_t));
+                    pool->po_size * sizeof(struct kib_tx));
 out:
         kiblnd_fini_pool(pool);
         LIBCFS_FREE(tpo, sizeof(*tpo));
@@ -2041,13 +2037,13 @@ static int kiblnd_tx_pool_size(int ncpts)
         return max(IBLND_TX_POOL, ntx);
 }
 
-static int kiblnd_create_tx_pool(kib_poolset_t *ps, int size,
-                                 kib_pool_t **pp_po)
+static int kiblnd_create_tx_pool(struct kib_poolset *ps, int size,
+                                 struct kib_pool **pp_po)
 {
         int i;
         int npg;
-        kib_pool_t *pool;
-        kib_tx_pool_t *tpo;
+        struct kib_pool *pool;
+        struct kib_tx_pool *tpo;
 
         LIBCFS_CPT_ALLOC(tpo, lnet_cpt_table(), ps->ps_cpt, sizeof(*tpo));
         if (!tpo) {
@@ -2068,17 +2064,17 @@ static int kiblnd_create_tx_pool(kib_poolset_t *ps, int size,
         }
 
         LIBCFS_CPT_ALLOC(tpo->tpo_tx_descs, lnet_cpt_table(), ps->ps_cpt,
-                         size * sizeof(kib_tx_t));
+                         size * sizeof(struct kib_tx));
         if (!tpo->tpo_tx_descs) {
                 CERROR("Can't allocate %d tx descriptors\n", size);
                 ps->ps_pool_destroy(pool);
                 return -ENOMEM;
         }
 
-        memset(tpo->tpo_tx_descs, 0, size * sizeof(kib_tx_t));
+        memset(tpo->tpo_tx_descs, 0, size * sizeof(struct kib_tx));
 
         for (i = 0; i < size; i++) {
-                kib_tx_t *tx = &tpo->tpo_tx_descs[i];
+                struct kib_tx *tx = &tpo->tpo_tx_descs[i];
 
                 tx->tx_pool = tpo;
                 if (ps->ps_net->ibn_fmr_ps) {
@@ -2090,11 +2086,12 @@ static int kiblnd_create_tx_pool(kib_poolset_t *ps, int size,
                 }
 
                 LIBCFS_CPT_ALLOC(tx->tx_frags, lnet_cpt_table(), ps->ps_cpt,
-                                 IBLND_MAX_RDMA_FRAGS * sizeof(*tx->tx_frags));
+                                 (1 + IBLND_MAX_RDMA_FRAGS) *
+                                 sizeof(*tx->tx_frags));
                 if (!tx->tx_frags)
                         break;
 
-                sg_init_table(tx->tx_frags, IBLND_MAX_RDMA_FRAGS);
+                sg_init_table(tx->tx_frags, IBLND_MAX_RDMA_FRAGS + 1);
 
                 LIBCFS_CPT_ALLOC(tx->tx_wrq, lnet_cpt_table(), ps->ps_cpt,
                                  (1 + IBLND_MAX_RDMA_FRAGS) *
@@ -2109,7 +2106,7 @@ static int kiblnd_create_tx_pool(kib_poolset_t *ps, int size,
                         break;
 
                 LIBCFS_CPT_ALLOC(tx->tx_rd, lnet_cpt_table(), ps->ps_cpt,
-                                 offsetof(kib_rdma_desc_t,
+                                 offsetof(struct kib_rdma_desc,
                                           rd_frags[IBLND_MAX_RDMA_FRAGS]));
                 if (!tx->tx_rd)
                         break;
@@ -2125,22 +2122,23 @@ static int kiblnd_create_tx_pool(kib_poolset_t *ps, int size,
         return -ENOMEM;
 }
 
-static void kiblnd_tx_init(kib_pool_t *pool, struct list_head *node)
+static void kiblnd_tx_init(struct kib_pool *pool, struct list_head *node)
 {
-        kib_tx_poolset_t *tps = container_of(pool->po_owner, kib_tx_poolset_t,
-                                             tps_poolset);
-        kib_tx_t *tx  = list_entry(node, kib_tx_t, tx_list);
+        struct kib_tx_poolset *tps = container_of(pool->po_owner,
+                                                  struct kib_tx_poolset,
+                                                  tps_poolset);
+        struct kib_tx *tx = list_entry(node, struct kib_tx, tx_list);
 
         tx->tx_cookie = tps->tps_next_tx_cookie++;
 }
 
-static void kiblnd_net_fini_pools(kib_net_t *net)
+static void kiblnd_net_fini_pools(struct kib_net *net)
 {
         int i;
 
         cfs_cpt_for_each(i, lnet_cpt_table()) {
-                kib_tx_poolset_t *tps;
-                kib_fmr_poolset_t *fps;
+                struct kib_tx_poolset *tps;
+                struct kib_fmr_poolset *fps;
 
                 if (net->ibn_tx_ps) {
                         tps = net->ibn_tx_ps[i];
@@ -2164,7 +2162,7 @@ static void kiblnd_net_fini_pools(kib_net_t *net)
         }
 }
 
-static int kiblnd_net_init_pools(kib_net_t *net, lnet_ni_t *ni, __u32 *cpts,
+static int kiblnd_net_init_pools(struct kib_net *net, lnet_ni_t *ni, __u32 *cpts,
                                  int ncpts)
 {
         struct lnet_ioctl_config_o2iblnd_tunables *tunables;
@@ -2206,7 +2204,7 @@ static int kiblnd_net_init_pools(kib_net_t *net, lnet_ni_t *ni, __u32 *cpts,
          * number of CPTs that exist, i.e net->ibn_fmr_ps[cpt].
          */
         net->ibn_fmr_ps = cfs_percpt_alloc(lnet_cpt_table(),
-                                           sizeof(kib_fmr_poolset_t));
+                                           sizeof(struct kib_fmr_poolset));
         if (!net->ibn_fmr_ps) {
                 CERROR("Failed to allocate FMR pool array\n");
                 rc = -ENOMEM;
@@ -2234,7 +2232,7 @@ static int kiblnd_net_init_pools(kib_net_t *net, lnet_ni_t *ni, __u32 *cpts,
          * number of CPTs that exist, i.e net->ibn_tx_ps[cpt].
          */
         net->ibn_tx_ps = cfs_percpt_alloc(lnet_cpt_table(),
-                                          sizeof(kib_tx_poolset_t));
+                                          sizeof(struct kib_tx_poolset));
         if (!net->ibn_tx_ps) {
                 CERROR("Failed to allocate tx pool array\n");
                 rc = -ENOMEM;
@@ -2263,7 +2261,7 @@ static int kiblnd_net_init_pools(kib_net_t *net, lnet_ni_t *ni, __u32 *cpts,
         return rc;
 }
 
-static int kiblnd_hdev_get_attr(kib_hca_dev_t *hdev)
+static int kiblnd_hdev_get_attr(struct kib_hca_dev *hdev)
 {
         /*
          * It's safe to assume a HCA can handle a page size
@@ -2283,7 +2281,7 @@ static int kiblnd_hdev_get_attr(kib_hca_dev_t *hdev)
         return -EINVAL;
 }
 
-static void kiblnd_hdev_cleanup_mrs(kib_hca_dev_t *hdev)
+static void kiblnd_hdev_cleanup_mrs(struct kib_hca_dev *hdev)
 {
         if (!hdev->ibh_mrs)
                 return;
@@ -2293,7 +2291,7 @@ static void kiblnd_hdev_cleanup_mrs(kib_hca_dev_t *hdev)
         hdev->ibh_mrs = NULL;
 }
 
-void kiblnd_hdev_destroy(kib_hca_dev_t *hdev)
+void kiblnd_hdev_destroy(struct kib_hca_dev *hdev)
 {
         kiblnd_hdev_cleanup_mrs(hdev);
 
@@ -2306,7 +2304,7 @@ void kiblnd_hdev_destroy(kib_hca_dev_t *hdev)
         LIBCFS_FREE(hdev, sizeof(*hdev));
 }
 
-static int kiblnd_hdev_setup_mrs(kib_hca_dev_t *hdev)
+static int kiblnd_hdev_setup_mrs(struct kib_hca_dev *hdev)
 {
         struct ib_mr *mr;
         int rc;
@@ -2335,7 +2333,7 @@ static int kiblnd_dummy_callback(struct rdma_cm_id *cmid,
         return 0;
 }
 
-static int kiblnd_dev_need_failover(kib_dev_t *dev)
+static int kiblnd_dev_need_failover(struct kib_dev *dev)
 {
         struct rdma_cm_id *cmid;
         struct sockaddr_in srcaddr;
@@ -2389,15 +2387,15 @@ static int kiblnd_dev_need_failover(kib_dev_t *dev)
         return rc;
 }
 
-int kiblnd_dev_failover(kib_dev_t *dev)
+int kiblnd_dev_failover(struct kib_dev *dev)
 {
         LIST_HEAD(zombie_tpo);
         LIST_HEAD(zombie_ppo);
         LIST_HEAD(zombie_fpo);
         struct rdma_cm_id *cmid  = NULL;
-        kib_hca_dev_t *hdev  = NULL;
+        struct kib_hca_dev *hdev  = NULL;
         struct ib_pd *pd;
-        kib_net_t *net;
+        struct kib_net *net;
         struct sockaddr_in addr;
         unsigned long flags;
         int rc = 0;
@@ -2522,7 +2520,7 @@ int kiblnd_dev_failover(kib_dev_t *dev)
         return rc;
 }
 
-void kiblnd_destroy_dev(kib_dev_t *dev)
+void kiblnd_destroy_dev(struct kib_dev *dev)
 {
         LASSERT(!dev->ibd_nnets);
         LASSERT(list_empty(&dev->ibd_nets));
@@ -2536,10 +2534,10 @@ void kiblnd_destroy_dev(kib_dev_t *dev)
         LIBCFS_FREE(dev, sizeof(*dev));
 }
 
-static kib_dev_t *kiblnd_create_dev(char *ifname)
+static struct kib_dev *kiblnd_create_dev(char *ifname)
 {
         struct net_device *netdev;
-        kib_dev_t *dev;
+        struct kib_dev *dev;
         __u32 netmask;
         __u32 ip;
         int up;
@@ -2654,7 +2652,7 @@ static void kiblnd_base_shutdown(void)
 
 static void kiblnd_shutdown(lnet_ni_t *ni)
 {
-        kib_net_t *net = ni->ni_data;
+        struct kib_net *net = ni->ni_data;
         rwlock_t *g_lock = &kiblnd_data.kib_global_lock;
         int i;
         unsigned long flags;
@@ -2851,7 +2849,7 @@ static int kiblnd_start_schedulers(struct kib_sched_info *sched)
         return rc;
 }
 
-static int kiblnd_dev_start_threads(kib_dev_t *dev, int newdev, __u32 *cpts,
+static int kiblnd_dev_start_threads(struct kib_dev *dev, int newdev, __u32 *cpts,
                                     int ncpts)
 {
         int cpt;
@@ -2877,10 +2875,10 @@ static int kiblnd_dev_start_threads(kib_dev_t *dev, int newdev, __u32 *cpts,
         return 0;
 }
 
-static kib_dev_t *kiblnd_dev_search(char *ifname)
+static struct kib_dev *kiblnd_dev_search(char *ifname)
 {
-        kib_dev_t *alias = NULL;
-        kib_dev_t *dev;
+        struct kib_dev *alias = NULL;
+        struct kib_dev *dev;
         char *colon;
         char *colon2;
 
@@ -2912,8 +2910,8 @@ static kib_dev_t *kiblnd_dev_search(char *ifname)
 static int kiblnd_startup(lnet_ni_t *ni)
 {
         char *ifname;
-        kib_dev_t *ibdev = NULL;
-        kib_net_t *net;
+        struct kib_dev *ibdev = NULL;
+        struct kib_net *net;
         struct timespec64 tv;
         unsigned long flags;
         int rc;
@@ -3020,11 +3018,11 @@ static void __exit ko2iblnd_exit(void)
 
 static int __init ko2iblnd_init(void)
 {
-        CLASSERT(sizeof(kib_msg_t) <= IBLND_MSG_SIZE);
-        CLASSERT(offsetof(kib_msg_t,
+        CLASSERT(sizeof(struct kib_msg) <= IBLND_MSG_SIZE);
+        CLASSERT(offsetof(struct kib_msg,
                           ibm_u.get.ibgm_rd.rd_frags[IBLND_MAX_RDMA_FRAGS])
                           <= IBLND_MSG_SIZE);
-        CLASSERT(offsetof(kib_msg_t,
+        CLASSERT(offsetof(struct kib_msg,
                           ibm_u.putack.ibpam_rd.rd_frags[IBLND_MAX_RDMA_FRAGS])
                           <= IBLND_MSG_SIZE);
 
diff --git a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h
index b22984fd9ad3..078a0c3e8845 100644
--- a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h
+++ b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -78,12 +74,12 @@
 #define IBLND_N_SCHED                   2
 #define IBLND_N_SCHED_HIGH              4
 
-typedef struct {
+struct kib_tunables {
         int *kib_dev_failover;           /* HCA failover */
         unsigned int *kib_service;       /* IB service number */
         int *kib_min_reconnect_interval; /* first failed connection retry... */
         int *kib_max_reconnect_interval; /* exponentially increasing to this */
-        int *kib_cksum;                  /* checksum kib_msg_t? */
+        int *kib_cksum;                  /* checksum struct kib_msg? */
         int *kib_timeout;                /* comms timeout (seconds) */
         int *kib_keepalive;              /* keepalive timeout (seconds) */
         int *kib_ntx;                    /* # tx descs */
@@ -94,22 +90,22 @@ typedef struct {
         int *kib_require_priv_port;      /* accept only privileged ports */
         int *kib_use_priv_port; /* use privileged port for active connect */
         int *kib_nscheds;                /* # threads on each CPT */
-} kib_tunables_t;
+};
 
-extern kib_tunables_t  kiblnd_tunables;
+extern struct kib_tunables  kiblnd_tunables;
 
 #define IBLND_MSG_QUEUE_SIZE_V1   8 /* V1 only : # messages/RDMAs in-flight */
 #define IBLND_CREDIT_HIGHWATER_V1 7 /* V1 only : when eagerly to return credits */
 
 #define IBLND_CREDITS_DEFAULT     8 /* default # of peer credits */
-#define IBLND_CREDITS_MAX         ((typeof(((kib_msg_t *) 0)->ibm_credits)) - 1)  /* Max # of peer credits */
+#define IBLND_CREDITS_MAX         ((typeof(((struct kib_msg *)0)->ibm_credits)) - 1)  /* Max # of peer credits */
 
 /* when eagerly to return credits */
 #define IBLND_CREDITS_HIGHWATER(t, v)   ((v) == IBLND_MSG_VERSION_1 ? \
                                         IBLND_CREDIT_HIGHWATER_V1 : \
                                         t->lnd_peercredits_hiw)
 
-#define kiblnd_rdma_create_id(cb, dev, ps, qpt) rdma_create_id(&init_net, \
+#define kiblnd_rdma_create_id(cb, dev, ps, qpt) rdma_create_id(current->nsproxy->net_ns, \
                                                                cb, dev, \
                                                                ps, qpt)
 
@@ -150,7 +146,7 @@ struct kib_hca_dev;
 #define KIB_IFNAME_SIZE       256
 #endif
 
-typedef struct {
+struct kib_dev {
         struct list_head   ibd_list;            /* chain on kib_devs */
         struct list_head   ibd_fail_list;       /* chain on kib_failed_devs */
         __u32              ibd_ifip;            /* IPoIB interface IP */
@@ -165,9 +161,9 @@ typedef struct {
         unsigned int ibd_can_failover; /* IPoIB interface is a bonding master */
         struct list_head   ibd_nets;
         struct kib_hca_dev *ibd_hdev;
-} kib_dev_t;
+};
 
-typedef struct kib_hca_dev {
+struct kib_hca_dev {
         struct rdma_cm_id  *ibh_cmid;           /* listener cmid */
         struct ib_device   *ibh_ibdev;          /* IB device */
         int                ibh_page_shift;      /* page shift of current HCA */
@@ -177,19 +173,19 @@ typedef struct kib_hca_dev {
         __u64              ibh_mr_size;         /* size of MR */
         struct ib_mr       *ibh_mrs;            /* global MR */
         struct ib_pd       *ibh_pd;             /* PD */
-        kib_dev_t          *ibh_dev;            /* owner */
+        struct kib_dev     *ibh_dev;            /* owner */
         atomic_t           ibh_ref;             /* refcount */
-} kib_hca_dev_t;
+};
 
 /** # of seconds to keep pool alive */
 #define IBLND_POOL_DEADLINE     300
 /** # of seconds to retry if allocation failed */
 #define IBLND_POOL_RETRY        1
 
-typedef struct {
+struct kib_pages {
         int                ibp_npages;          /* # pages */
         struct page        *ibp_pages[0];       /* page array */
-} kib_pages_t;
+};
 
 struct kib_pool;
 struct kib_poolset;
@@ -204,7 +200,7 @@ struct kib_net;
 
 #define IBLND_POOL_NAME_LEN     32
 
-typedef struct kib_poolset {
+struct kib_poolset {
         spinlock_t            ps_lock;            /* serialize */
         struct kib_net        *ps_net;            /* network it belongs to */
         char                  ps_name[IBLND_POOL_NAME_LEN]; /* pool set name */
@@ -220,31 +216,31 @@ typedef struct kib_poolset {
         kib_ps_pool_destroy_t ps_pool_destroy;    /* destroy a pool */
         kib_ps_node_init_t    ps_node_init; /* initialize new allocated node */
         kib_ps_node_fini_t    ps_node_fini;       /* finalize node */
-} kib_poolset_t;
+};
 
-typedef struct kib_pool {
+struct kib_pool {
         struct list_head      po_list;       /* chain on pool list */
         struct list_head      po_free_list;  /* pre-allocated node */
-        kib_poolset_t         *po_owner;     /* pool_set of this pool */
+        struct kib_poolset      *po_owner;      /* pool_set of this pool */
         unsigned long         po_deadline;   /* deadline of this pool */
         int                   po_allocated;  /* # of elements in use */
         int                   po_failed;     /* pool is created on failed HCA */
         int                   po_size;       /* # of pre-allocated elements */
-} kib_pool_t;
+};
 
-typedef struct {
-        kib_poolset_t         tps_poolset;        /* pool-set */
+struct kib_tx_poolset {
+        struct kib_poolset      tps_poolset;            /* pool-set */
         __u64                 tps_next_tx_cookie; /* cookie of TX */
-} kib_tx_poolset_t;
+};
 
-typedef struct {
-        kib_pool_t            tpo_pool;           /* pool */
-        struct kib_hca_dev    *tpo_hdev;          /* device for this pool */
-        struct kib_tx         *tpo_tx_descs;      /* all the tx descriptors */
-        kib_pages_t           *tpo_tx_pages;      /* premapped tx msg pages */
-} kib_tx_pool_t;
+struct kib_tx_pool {
+        struct kib_pool          tpo_pool;      /* pool */
+        struct kib_hca_dev      *tpo_hdev;      /* device for this pool */
+        struct kib_tx           *tpo_tx_descs;  /* all the tx descriptors */
+        struct kib_pages        *tpo_tx_pages;  /* premapped tx msg pages */
+};
 
-typedef struct {
+struct kib_fmr_poolset {
         spinlock_t            fps_lock;            /* serialize */
         struct kib_net        *fps_net;            /* IB network */
         struct list_head      fps_pool_list;       /* FMR pool list */
@@ -257,7 +253,7 @@ typedef struct {
         int                   fps_increasing;      /* is allocating new pool */
         unsigned long         fps_next_retry;      /* time stamp for retry if*/
                                                    /* failed to allocate */
-} kib_fmr_poolset_t;
+};
 
 struct kib_fast_reg_descriptor { /* For fast registration */
         struct list_head                 frd_list;
@@ -267,10 +263,10 @@ struct kib_fast_reg_descriptor { /* For fast registration */
         bool                             frd_valid;
 };
 
-typedef struct {
-        struct list_head      fpo_list;            /* chain on pool list */
-        struct kib_hca_dev    *fpo_hdev;           /* device for this pool */
-        kib_fmr_poolset_t     *fpo_owner;          /* owner of this pool */
+struct kib_fmr_pool {
+        struct list_head         fpo_list;      /* chain on pool list */
+        struct kib_hca_dev      *fpo_hdev;      /* device for this pool */
+        struct kib_fmr_poolset  *fpo_owner;     /* owner of this pool */
         union {
                 struct {
                         struct ib_fmr_pool *fpo_fmr_pool; /* IB FMR pool */
@@ -284,17 +280,17 @@ typedef struct {
         int                   fpo_failed;          /* fmr pool is failed */
         int                   fpo_map_count;       /* # of mapped FMR */
         int                   fpo_is_fmr;
-} kib_fmr_pool_t;
+};
 
-typedef struct {
-        kib_fmr_pool_t                  *fmr_pool;      /* pool of FMR */
+struct kib_fmr {
+        struct kib_fmr_pool             *fmr_pool;      /* pool of FMR */
         struct ib_pool_fmr              *fmr_pfmr;      /* IB pool fmr */
         struct kib_fast_reg_descriptor  *fmr_frd;
         u32                              fmr_key;
-} kib_fmr_t;
+};
 
-typedef struct kib_net {
-        struct list_head      ibn_list;       /* chain on kib_dev_t::ibd_nets */
+struct kib_net {
+        struct list_head      ibn_list;       /* chain on struct kib_dev::ibd_nets */
         __u64                 ibn_incarnation;/* my epoch */
         int                   ibn_init;       /* initialisation state */
         int                   ibn_shutdown;   /* shutting down? */
@@ -302,11 +298,11 @@ typedef struct kib_net {
         atomic_t              ibn_npeers;     /* # peers extant */
         atomic_t              ibn_nconns;     /* # connections extant */
 
-        kib_tx_poolset_t      **ibn_tx_ps;    /* tx pool-set */
-        kib_fmr_poolset_t     **ibn_fmr_ps;   /* fmr pool-set */
+        struct kib_tx_poolset   **ibn_tx_ps;    /* tx pool-set */
+        struct kib_fmr_poolset  **ibn_fmr_ps;   /* fmr pool-set */
 
-        kib_dev_t             *ibn_dev;       /* underlying IB device */
-} kib_net_t;
+        struct kib_dev          *ibn_dev;       /* underlying IB device */
+};
 
 #define KIB_THREAD_SHIFT                16
 #define KIB_THREAD_ID(cpt, tid)         ((cpt) << KIB_THREAD_SHIFT | (tid))
@@ -322,7 +318,7 @@ struct kib_sched_info {
         int                ibs_cpt;      /* CPT id */
 };
 
-typedef struct {
+struct kib_data {
         int               kib_init;           /* initialisation state */
         int               kib_shutdown;       /* shut down? */
         struct list_head  kib_devs;           /* IB devices extant */
@@ -349,7 +345,7 @@ typedef struct {
         spinlock_t kib_connd_lock;          /* serialise */
         struct ib_qp_attr kib_error_qpa;    /* QP->ERROR */
         struct kib_sched_info **kib_scheds; /* percpt data for schedulers */
-} kib_data_t;
+};
 
 #define IBLND_INIT_NOTHING 0
 #define IBLND_INIT_DATA    1
@@ -360,51 +356,51 @@ typedef struct {
  * These are sent in sender's byte order (i.e. receiver flips).
  */
 
-typedef struct kib_connparams {
+struct kib_connparams {
         __u16        ibcp_queue_depth;
         __u16        ibcp_max_frags;
         __u32        ibcp_max_msg_size;
-} WIRE_ATTR kib_connparams_t;
+} WIRE_ATTR;
 
-typedef struct {
+struct kib_immediate_msg {
         lnet_hdr_t   ibim_hdr;        /* portals header */
         char         ibim_payload[0]; /* piggy-backed payload */
-} WIRE_ATTR kib_immediate_msg_t;
+} WIRE_ATTR;
 
-typedef struct {
+struct kib_rdma_frag {
         __u32        rf_nob;          /* # bytes this frag */
         __u64        rf_addr;         /* CAVEAT EMPTOR: misaligned!! */
-} WIRE_ATTR kib_rdma_frag_t;
+} WIRE_ATTR;
 
-typedef struct {
+struct kib_rdma_desc {
         __u32           rd_key;       /* local/remote key */
         __u32           rd_nfrags;    /* # fragments */
-        kib_rdma_frag_t rd_frags[0];  /* buffer frags */
-} WIRE_ATTR kib_rdma_desc_t;
+        struct kib_rdma_frag    rd_frags[0];    /* buffer frags */
+} WIRE_ATTR;
 
-typedef struct {
+struct kib_putreq_msg {
         lnet_hdr_t      ibprm_hdr;    /* portals header */
         __u64           ibprm_cookie; /* opaque completion cookie */
-} WIRE_ATTR kib_putreq_msg_t;
+} WIRE_ATTR;
 
-typedef struct {
+struct kib_putack_msg {
         __u64           ibpam_src_cookie; /* reflected completion cookie */
         __u64           ibpam_dst_cookie; /* opaque completion cookie */
-        kib_rdma_desc_t ibpam_rd;         /* sender's sink buffer */
-} WIRE_ATTR kib_putack_msg_t;
+        struct kib_rdma_desc ibpam_rd;         /* sender's sink buffer */
+} WIRE_ATTR;
 
-typedef struct {
+struct kib_get_msg {
         lnet_hdr_t      ibgm_hdr;     /* portals header */
         __u64           ibgm_cookie;  /* opaque completion cookie */
-        kib_rdma_desc_t ibgm_rd;      /* rdma descriptor */
-} WIRE_ATTR kib_get_msg_t;
+        struct kib_rdma_desc ibgm_rd;      /* rdma descriptor */
+} WIRE_ATTR;
 
-typedef struct {
+struct kib_completion_msg {
         __u64           ibcm_cookie;  /* opaque completion cookie */
         __s32           ibcm_status;  /* < 0 failure: >= 0 length */
-} WIRE_ATTR kib_completion_msg_t;
+} WIRE_ATTR;
 
-typedef struct {
+struct kib_msg {
         /* First 2 fields fixed FOR ALL TIME */
         __u32           ibm_magic;    /* I'm an ibnal message */
         __u16           ibm_version;  /* this is my version number */
@@ -419,14 +415,14 @@ typedef struct {
         __u64           ibm_dststamp; /* destination's incarnation */
 
         union {
-                kib_connparams_t     connparams;
-                kib_immediate_msg_t  immediate;
-                kib_putreq_msg_t     putreq;
-                kib_putack_msg_t     putack;
-                kib_get_msg_t        get;
-                kib_completion_msg_t completion;
+                struct kib_connparams           connparams;
+                struct kib_immediate_msg        immediate;
+                struct kib_putreq_msg           putreq;
+                struct kib_putack_msg           putack;
+                struct kib_get_msg              get;
+                struct kib_completion_msg       completion;
         } WIRE_ATTR ibm_u;
-} WIRE_ATTR kib_msg_t;
+} WIRE_ATTR;
 
 #define IBLND_MSG_MAGIC     LNET_PROTO_IB_MAGIC /* unique magic */
 
@@ -445,14 +441,14 @@ typedef struct {
 #define IBLND_MSG_GET_REQ   0xd6        /* getreq (sink->src) */
 #define IBLND_MSG_GET_DONE  0xd7        /* completion (src->sink: all OK) */
 
-typedef struct {
+struct kib_rej {
         __u32            ibr_magic;       /* sender's magic */
         __u16            ibr_version;     /* sender's version */
         __u8             ibr_why;         /* reject reason */
         __u8             ibr_padding;     /* padding */
         __u64            ibr_incarnation; /* incarnation of peer */
-        kib_connparams_t ibr_cp;          /* connection parameters */
-} WIRE_ATTR kib_rej_t;
+        struct kib_connparams ibr_cp;          /* connection parameters */
+} WIRE_ATTR;
 
 /* connection rejection reasons */
 #define IBLND_REJECT_CONN_RACE      1 /* You lost connection race */
@@ -467,28 +463,26 @@ typedef struct {
 
 /***********************************************************************/
 
-typedef struct kib_rx                         /* receive message */
-{
+struct kib_rx {                                 /* receive message */
         struct list_head       rx_list;       /* queue for attention */
         struct kib_conn        *rx_conn;      /* owning conn */
         int                    rx_nob; /* # bytes received (-1 while posted) */
         enum ib_wc_status      rx_status;     /* completion status */
-        kib_msg_t              *rx_msg;       /* message buffer (host vaddr) */
+        struct kib_msg          *rx_msg;        /* message buffer (host vaddr) */
         __u64                  rx_msgaddr;    /* message buffer (I/O addr) */
         DECLARE_PCI_UNMAP_ADDR(rx_msgunmap);  /* for dma_unmap_single() */
         struct ib_recv_wr      rx_wrq;        /* receive work item... */
         struct ib_sge          rx_sge;        /* ...and its memory */
-} kib_rx_t;
+};
 
 #define IBLND_POSTRX_DONT_POST    0 /* don't post */
 #define IBLND_POSTRX_NO_CREDIT    1 /* post: no credits */
 #define IBLND_POSTRX_PEER_CREDIT  2 /* post: give peer back 1 credit */
 #define IBLND_POSTRX_RSRVD_CREDIT 3 /* post: give self back 1 reserved credit */
 
-typedef struct kib_tx                         /* transmit message */
-{
+struct kib_tx {                                 /* transmit message */
         struct list_head      tx_list; /* queue on idle_txs ibc_tx_queue etc. */
-        kib_tx_pool_t         *tx_pool;       /* pool I'm from */
+        struct kib_tx_pool      *tx_pool;       /* pool I'm from */
         struct kib_conn       *tx_conn;       /* owning conn */
         short                 tx_sending;     /* # tx callbacks outstanding */
         short                 tx_queued;      /* queued for sending */
@@ -497,28 +491,28 @@ typedef struct kib_tx                         /* transmit message */
         unsigned long         tx_deadline;    /* completion deadline */
         __u64                 tx_cookie;      /* completion cookie */
         lnet_msg_t *tx_lntmsg[2]; /* lnet msgs to finalize on completion */
-        kib_msg_t             *tx_msg;        /* message buffer (host vaddr) */
+        struct kib_msg        *tx_msg;        /* message buffer (host vaddr) */
         __u64                 tx_msgaddr;     /* message buffer (I/O addr) */
         DECLARE_PCI_UNMAP_ADDR(tx_msgunmap);  /* for dma_unmap_single() */
         int                   tx_nwrq;        /* # send work items */
         struct ib_rdma_wr     *tx_wrq;        /* send work items... */
         struct ib_sge         *tx_sge;        /* ...and their memory */
-        kib_rdma_desc_t       *tx_rd;         /* rdma descriptor */
+        struct kib_rdma_desc  *tx_rd;         /* rdma descriptor */
         int                   tx_nfrags;      /* # entries in... */
         struct scatterlist    *tx_frags;      /* dma_map_sg descriptor */
         __u64                 *tx_pages;      /* rdma phys page addrs */
-        kib_fmr_t             fmr;            /* FMR */
+        struct kib_fmr        fmr;            /* FMR */
         int                   tx_dmadir;      /* dma direction */
-} kib_tx_t;
+};
 
-typedef struct kib_connvars {
-        kib_msg_t cv_msg; /* connection-in-progress variables */
-} kib_connvars_t;
+struct kib_connvars {
+        struct kib_msg cv_msg; /* connection-in-progress variables */
+};
 
-typedef struct kib_conn {
+struct kib_conn {
         struct kib_sched_info *ibc_sched;      /* scheduler information */
         struct kib_peer       *ibc_peer;       /* owning peer */
-        kib_hca_dev_t         *ibc_hdev;       /* HCA bound on */
+        struct kib_hca_dev         *ibc_hdev;       /* HCA bound on */
         struct list_head ibc_list;             /* stash on peer's conn list */
         struct list_head      ibc_sched_list;  /* schedule for attention */
         __u16                 ibc_version;     /* version of connection */
@@ -553,14 +547,14 @@ typedef struct kib_conn {
                                                /* reserve an ACK/DONE msg */
         struct list_head ibc_active_txs; /* active tx awaiting completion */
         spinlock_t            ibc_lock;        /* serialise */
-        kib_rx_t              *ibc_rxs;        /* the rx descs */
-        kib_pages_t           *ibc_rx_pages;   /* premapped rx msg pages */
+        struct kib_rx              *ibc_rxs;        /* the rx descs */
+        struct kib_pages           *ibc_rx_pages;   /* premapped rx msg pages */
 
         struct rdma_cm_id     *ibc_cmid;       /* CM id */
         struct ib_cq          *ibc_cq;         /* completion queue */
 
-        kib_connvars_t        *ibc_connvars; /* in-progress connection state */
-} kib_conn_t;
+        struct kib_connvars     *ibc_connvars;  /* in-progress connection state */
+};
 
 #define IBLND_CONN_INIT           0      /* being initialised */
 #define IBLND_CONN_ACTIVE_CONNECT 1      /* active sending req */
@@ -569,7 +563,7 @@ typedef struct kib_conn {
 #define IBLND_CONN_CLOSING        4      /* being closed */
 #define IBLND_CONN_DISCONNECTED   5      /* disconnected */
 
-typedef struct kib_peer {
+struct kib_peer {
         struct list_head ibp_list;        /* stash on global peer list */
         lnet_nid_t       ibp_nid;         /* who's on the other end(s) */
         lnet_ni_t        *ibp_ni;         /* LNet interface */
@@ -596,11 +590,11 @@ typedef struct kib_peer {
         __u16            ibp_max_frags;
         /* max_peer_credits */
         __u16            ibp_queue_depth;
-} kib_peer_t;
+};
 
-extern kib_data_t kiblnd_data;
+extern struct kib_data kiblnd_data;
 
-void kiblnd_hdev_destroy(kib_hca_dev_t *hdev);
+void kiblnd_hdev_destroy(struct kib_hca_dev *hdev);
 
 int kiblnd_msg_queue_size(int version, struct lnet_ni *ni);
 
@@ -645,14 +639,14 @@ kiblnd_concurrent_sends(int version, struct lnet_ni *ni)
 }
 
 static inline void
-kiblnd_hdev_addref_locked(kib_hca_dev_t *hdev)
+kiblnd_hdev_addref_locked(struct kib_hca_dev *hdev)
 {
         LASSERT(atomic_read(&hdev->ibh_ref) > 0);
         atomic_inc(&hdev->ibh_ref);
 }
 
 static inline void
-kiblnd_hdev_decref(kib_hca_dev_t *hdev)
+kiblnd_hdev_decref(struct kib_hca_dev *hdev)
 {
         LASSERT(atomic_read(&hdev->ibh_ref) > 0);
         if (atomic_dec_and_test(&hdev->ibh_ref))
@@ -660,7 +654,7 @@ kiblnd_hdev_decref(kib_hca_dev_t *hdev)
 }
 
 static inline int
-kiblnd_dev_can_failover(kib_dev_t *dev)
+kiblnd_dev_can_failover(struct kib_dev *dev)
 {
         if (!list_empty(&dev->ibd_fail_list)) /* already scheduled */
                 return 0;
@@ -716,7 +710,7 @@ do {							    \
 } while (0)
 
 static inline bool
-kiblnd_peer_connecting(kib_peer_t *peer)
+kiblnd_peer_connecting(struct kib_peer *peer)
 {
         return peer->ibp_connecting ||
                peer->ibp_reconnecting ||
@@ -724,7 +718,7 @@ kiblnd_peer_connecting(kib_peer_t *peer)
 }
 
 static inline bool
-kiblnd_peer_idle(kib_peer_t *peer)
+kiblnd_peer_idle(struct kib_peer *peer)
 {
         return !kiblnd_peer_connecting(peer) && list_empty(&peer->ibp_conns);
 }
@@ -739,23 +733,23 @@ kiblnd_nid2peerlist(lnet_nid_t nid)
 }
 
 static inline int
-kiblnd_peer_active(kib_peer_t *peer)
+kiblnd_peer_active(struct kib_peer *peer)
 {
         /* Am I in the peer hash table? */
         return !list_empty(&peer->ibp_list);
 }
 
-static inline kib_conn_t *
-kiblnd_get_conn_locked(kib_peer_t *peer)
+static inline struct kib_conn *
+kiblnd_get_conn_locked(struct kib_peer *peer)
 {
         LASSERT(!list_empty(&peer->ibp_conns));
 
         /* just return the first connection */
-        return list_entry(peer->ibp_conns.next, kib_conn_t, ibc_list);
+        return list_entry(peer->ibp_conns.next, struct kib_conn, ibc_list);
 }
 
 static inline int
-kiblnd_send_keepalive(kib_conn_t *conn)
+kiblnd_send_keepalive(struct kib_conn *conn)
 {
         return (*kiblnd_tunables.kib_keepalive > 0) &&
                 cfs_time_after(jiffies, conn->ibc_last_send +
@@ -764,7 +758,7 @@ kiblnd_send_keepalive(kib_conn_t *conn)
 }
 
 static inline int
-kiblnd_need_noop(kib_conn_t *conn)
+kiblnd_need_noop(struct kib_conn *conn)
 {
         struct lnet_ioctl_config_o2iblnd_tunables *tunables;
         lnet_ni_t *ni = conn->ibc_peer->ibp_ni;
@@ -800,14 +794,14 @@ kiblnd_need_noop(kib_conn_t *conn)
 }
 
 static inline void
-kiblnd_abort_receives(kib_conn_t *conn)
+kiblnd_abort_receives(struct kib_conn *conn)
 {
         ib_modify_qp(conn->ibc_cmid->qp,
                      &kiblnd_data.kib_error_qpa, IB_QP_STATE);
 }
 
 static inline const char *
-kiblnd_queue2str(kib_conn_t *conn, struct list_head *q)
+kiblnd_queue2str(struct kib_conn *conn, struct list_head *q)
 {
         if (q == &conn->ibc_tx_queue)
                 return "tx_queue";
@@ -858,21 +852,21 @@ kiblnd_wreqid2type(__u64 wreqid)
 }
 
 static inline void
-kiblnd_set_conn_state(kib_conn_t *conn, int state)
+kiblnd_set_conn_state(struct kib_conn *conn, int state)
 {
         conn->ibc_state = state;
         mb();
 }
 
 static inline void
-kiblnd_init_msg(kib_msg_t *msg, int type, int body_nob)
+kiblnd_init_msg(struct kib_msg *msg, int type, int body_nob)
 {
         msg->ibm_type = type;
-        msg->ibm_nob  = offsetof(kib_msg_t, ibm_u) + body_nob;
+        msg->ibm_nob  = offsetof(struct kib_msg, ibm_u) + body_nob;
 }
 
 static inline int
-kiblnd_rd_size(kib_rdma_desc_t *rd)
+kiblnd_rd_size(struct kib_rdma_desc *rd)
 {
         int   i;
         int   size;
@@ -884,25 +878,25 @@ kiblnd_rd_size(kib_rdma_desc_t *rd)
 }
 
 static inline __u64
-kiblnd_rd_frag_addr(kib_rdma_desc_t *rd, int index)
+kiblnd_rd_frag_addr(struct kib_rdma_desc *rd, int index)
 {
         return rd->rd_frags[index].rf_addr;
 }
 
 static inline __u32
-kiblnd_rd_frag_size(kib_rdma_desc_t *rd, int index)
+kiblnd_rd_frag_size(struct kib_rdma_desc *rd, int index)
 {
         return rd->rd_frags[index].rf_nob;
 }
 
 static inline __u32
-kiblnd_rd_frag_key(kib_rdma_desc_t *rd, int index)
+kiblnd_rd_frag_key(struct kib_rdma_desc *rd, int index)
 {
         return rd->rd_key;
 }
 
 static inline int
-kiblnd_rd_consume_frag(kib_rdma_desc_t *rd, int index, __u32 nob)
+kiblnd_rd_consume_frag(struct kib_rdma_desc *rd, int index, __u32 nob)
 {
         if (nob < rd->rd_frags[index].rf_nob) {
                 rd->rd_frags[index].rf_addr += nob;
@@ -915,14 +909,14 @@ kiblnd_rd_consume_frag(kib_rdma_desc_t *rd, int index, __u32 nob)
 }
 
 static inline int
-kiblnd_rd_msg_size(kib_rdma_desc_t *rd, int msgtype, int n)
+kiblnd_rd_msg_size(struct kib_rdma_desc *rd, int msgtype, int n)
 {
         LASSERT(msgtype == IBLND_MSG_GET_REQ ||
                 msgtype == IBLND_MSG_PUT_ACK);
 
         return msgtype == IBLND_MSG_GET_REQ ?
-               offsetof(kib_get_msg_t, ibgm_rd.rd_frags[n]) :
-               offsetof(kib_putack_msg_t, ibpam_rd.rd_frags[n]);
+               offsetof(struct kib_get_msg, ibgm_rd.rd_frags[n]) :
+               offsetof(struct kib_putack_msg, ibpam_rd.rd_frags[n]);
 }
 
 static inline __u64
@@ -981,17 +975,17 @@ static inline unsigned int kiblnd_sg_dma_len(struct ib_device *dev,
 #define KIBLND_CONN_PARAM(e)     ((e)->param.conn.private_data)
 #define KIBLND_CONN_PARAM_LEN(e) ((e)->param.conn.private_data_len)
 
-struct ib_mr *kiblnd_find_rd_dma_mr(struct lnet_ni *ni, kib_rdma_desc_t *rd,
+struct ib_mr *kiblnd_find_rd_dma_mr(struct lnet_ni *ni, struct kib_rdma_desc *rd,
                                     int negotiated_nfrags);
-void kiblnd_map_rx_descs(kib_conn_t *conn);
-void kiblnd_unmap_rx_descs(kib_conn_t *conn);
-void kiblnd_pool_free_node(kib_pool_t *pool, struct list_head *node);
-struct list_head *kiblnd_pool_alloc_node(kib_poolset_t *ps);
+void kiblnd_map_rx_descs(struct kib_conn *conn);
+void kiblnd_unmap_rx_descs(struct kib_conn *conn);
+void kiblnd_pool_free_node(struct kib_pool *pool, struct list_head *node);
+struct list_head *kiblnd_pool_alloc_node(struct kib_poolset *ps);
 
-int  kiblnd_fmr_pool_map(kib_fmr_poolset_t *fps, kib_tx_t *tx,
-                         kib_rdma_desc_t *rd, __u32 nob, __u64 iov,
-                         kib_fmr_t *fmr);
-void kiblnd_fmr_pool_unmap(kib_fmr_t *fmr, int status);
+int  kiblnd_fmr_pool_map(struct kib_fmr_poolset *fps, struct kib_tx *tx,
+                         struct kib_rdma_desc *rd, __u32 nob, __u64 iov,
+                         struct kib_fmr *fmr);
+void kiblnd_fmr_pool_unmap(struct kib_fmr *fmr, int status);
 
 int kiblnd_tunables_setup(struct lnet_ni *ni);
 void kiblnd_tunables_init(void);
@@ -1001,30 +995,31 @@ int  kiblnd_scheduler(void *arg);
 int  kiblnd_thread_start(int (*fn)(void *arg), void *arg, char *name);
 int  kiblnd_failover_thread(void *arg);
 
-int  kiblnd_alloc_pages(kib_pages_t **pp, int cpt, int npages);
+int  kiblnd_alloc_pages(struct kib_pages **pp, int cpt, int npages);
 
 int  kiblnd_cm_callback(struct rdma_cm_id *cmid,
                         struct rdma_cm_event *event);
 int  kiblnd_translate_mtu(int value);
 
-int  kiblnd_dev_failover(kib_dev_t *dev);
-int  kiblnd_create_peer(lnet_ni_t *ni, kib_peer_t **peerp, lnet_nid_t nid);
-void kiblnd_destroy_peer(kib_peer_t *peer);
-bool kiblnd_reconnect_peer(kib_peer_t *peer);
-void kiblnd_destroy_dev(kib_dev_t *dev);
-void kiblnd_unlink_peer_locked(kib_peer_t *peer);
-kib_peer_t *kiblnd_find_peer_locked(lnet_nid_t nid);
-int  kiblnd_close_stale_conns_locked(kib_peer_t *peer,
+int  kiblnd_dev_failover(struct kib_dev *dev);
+int  kiblnd_create_peer(lnet_ni_t *ni, struct kib_peer **peerp, lnet_nid_t nid);
+void kiblnd_destroy_peer(struct kib_peer *peer);
+bool kiblnd_reconnect_peer(struct kib_peer *peer);
+void kiblnd_destroy_dev(struct kib_dev *dev);
+void kiblnd_unlink_peer_locked(struct kib_peer *peer);
+struct kib_peer *kiblnd_find_peer_locked(lnet_nid_t nid);
+int  kiblnd_close_stale_conns_locked(struct kib_peer *peer,
                                      int version, __u64 incarnation);
-int  kiblnd_close_peer_conns_locked(kib_peer_t *peer, int why);
+int  kiblnd_close_peer_conns_locked(struct kib_peer *peer, int why);
 
-kib_conn_t *kiblnd_create_conn(kib_peer_t *peer, struct rdma_cm_id *cmid,
-                               int state, int version);
-void kiblnd_destroy_conn(kib_conn_t *conn, bool free_conn);
-void kiblnd_close_conn(kib_conn_t *conn, int error);
-void kiblnd_close_conn_locked(kib_conn_t *conn, int error);
+struct kib_conn *kiblnd_create_conn(struct kib_peer *peer,
+                                    struct rdma_cm_id *cmid,
+                                    int state, int version);
+void kiblnd_destroy_conn(struct kib_conn *conn, bool free_conn);
+void kiblnd_close_conn(struct kib_conn *conn, int error);
+void kiblnd_close_conn_locked(struct kib_conn *conn, int error);
 
-void kiblnd_launch_tx(lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid);
+void kiblnd_launch_tx(lnet_ni_t *ni, struct kib_tx *tx, lnet_nid_t nid);
 void kiblnd_txlist_done(lnet_ni_t *ni, struct list_head *txlist,
                         int status);
 
@@ -1032,10 +1027,10 @@ void kiblnd_qp_event(struct ib_event *event, void *arg);
 void kiblnd_cq_event(struct ib_event *event, void *arg);
 void kiblnd_cq_completion(struct ib_cq *cq, void *arg);
 
-void kiblnd_pack_msg(lnet_ni_t *ni, kib_msg_t *msg, int version,
+void kiblnd_pack_msg(lnet_ni_t *ni, struct kib_msg *msg, int version,
                      int credits, lnet_nid_t dstnid, __u64 dststamp);
-int  kiblnd_unpack_msg(kib_msg_t *msg, int nob);
-int  kiblnd_post_rx(kib_rx_t *rx, int credit);
+int  kiblnd_unpack_msg(struct kib_msg *msg, int nob);
+int  kiblnd_post_rx(struct kib_rx *rx, int credit);
 
 int  kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
 int  kiblnd_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed,
diff --git a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c
index 845e49a52430..596a697b9d39 100644
--- a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c
+++ b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -40,22 +36,22 @@
 
 #include "o2iblnd.h"
 
-static void kiblnd_peer_alive(kib_peer_t *peer);
-static void kiblnd_peer_connect_failed(kib_peer_t *peer, int active, int error);
-static void kiblnd_check_sends(kib_conn_t *conn);
-static void kiblnd_init_tx_msg(lnet_ni_t *ni, kib_tx_t *tx,
+static void kiblnd_peer_alive(struct kib_peer *peer);
+static void kiblnd_peer_connect_failed(struct kib_peer *peer, int active, int error);
+static void kiblnd_check_sends(struct kib_conn *conn);
+static void kiblnd_init_tx_msg(lnet_ni_t *ni, struct kib_tx *tx,
                                 int type, int body_nob);
-static int kiblnd_init_rdma(kib_conn_t *conn, kib_tx_t *tx, int type,
-                             int resid, kib_rdma_desc_t *dstrd, __u64 dstcookie);
-static void kiblnd_queue_tx_locked(kib_tx_t *tx, kib_conn_t *conn);
-static void kiblnd_queue_tx(kib_tx_t *tx, kib_conn_t *conn);
-static void kiblnd_unmap_tx(lnet_ni_t *ni, kib_tx_t *tx);
+static int kiblnd_init_rdma(struct kib_conn *conn, struct kib_tx *tx, int type,
+                             int resid, struct kib_rdma_desc *dstrd, __u64 dstcookie);
+static void kiblnd_queue_tx_locked(struct kib_tx *tx, struct kib_conn *conn);
+static void kiblnd_queue_tx(struct kib_tx *tx, struct kib_conn *conn);
+static void kiblnd_unmap_tx(lnet_ni_t *ni, struct kib_tx *tx);
 
 static void
-kiblnd_tx_done(lnet_ni_t *ni, kib_tx_t *tx)
+kiblnd_tx_done(lnet_ni_t *ni, struct kib_tx *tx)
 {
         lnet_msg_t *lntmsg[2];
-        kib_net_t *net = ni->ni_data;
+        struct kib_net *net = ni->ni_data;
         int rc;
         int i;
 
@@ -97,10 +93,10 @@ kiblnd_tx_done(lnet_ni_t *ni, kib_tx_t *tx)
 void
 kiblnd_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int status)
 {
-        kib_tx_t *tx;
+        struct kib_tx *tx;
 
         while (!list_empty(txlist)) {
-                tx = list_entry(txlist->next, kib_tx_t, tx_list);
+                tx = list_entry(txlist->next, struct kib_tx, tx_list);
 
                 list_del(&tx->tx_list);
                 /* complete now */
@@ -110,19 +106,19 @@ kiblnd_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int status)
         }
 }
 
-static kib_tx_t *
+static struct kib_tx *
 kiblnd_get_idle_tx(lnet_ni_t *ni, lnet_nid_t target)
 {
-        kib_net_t *net = (kib_net_t *)ni->ni_data;
+        struct kib_net *net = (struct kib_net *)ni->ni_data;
         struct list_head *node;
-        kib_tx_t *tx;
-        kib_tx_poolset_t *tps;
+        struct kib_tx *tx;
+        struct kib_tx_poolset *tps;
 
         tps = net->ibn_tx_ps[lnet_cpt_of_nid(target)];
         node = kiblnd_pool_alloc_node(&tps->tps_poolset);
         if (!node)
                 return NULL;
-        tx = list_entry(node, kib_tx_t, tx_list);
+        tx = list_entry(node, struct kib_tx, tx_list);
 
         LASSERT(!tx->tx_nwrq);
         LASSERT(!tx->tx_queued);
@@ -138,9 +134,9 @@ kiblnd_get_idle_tx(lnet_ni_t *ni, lnet_nid_t target)
 }
 
 static void
-kiblnd_drop_rx(kib_rx_t *rx)
+kiblnd_drop_rx(struct kib_rx *rx)
 {
-        kib_conn_t *conn = rx->rx_conn;
+        struct kib_conn *conn = rx->rx_conn;
         struct kib_sched_info *sched = conn->ibc_sched;
         unsigned long flags;
 
@@ -153,10 +149,10 @@ kiblnd_drop_rx(kib_rx_t *rx)
 }
 
 int
-kiblnd_post_rx(kib_rx_t *rx, int credit)
+kiblnd_post_rx(struct kib_rx *rx, int credit)
 {
-        kib_conn_t *conn = rx->rx_conn;
-        kib_net_t *net = conn->ibc_peer->ibp_ni->ni_data;
+        struct kib_conn *conn = rx->rx_conn;
+        struct kib_net *net = conn->ibc_peer->ibp_ni->ni_data;
         struct ib_recv_wr *bad_wrq = NULL;
         struct ib_mr *mr = conn->ibc_hdev->ibh_mrs;
         int rc;
@@ -223,13 +219,13 @@ out:
         return rc;
 }
 
-static kib_tx_t *
-kiblnd_find_waiting_tx_locked(kib_conn_t *conn, int txtype, __u64 cookie)
+static struct kib_tx *
+kiblnd_find_waiting_tx_locked(struct kib_conn *conn, int txtype, __u64 cookie)
 {
         struct list_head *tmp;
 
         list_for_each(tmp, &conn->ibc_active_txs) {
-                kib_tx_t *tx = list_entry(tmp, kib_tx_t, tx_list);
+                struct kib_tx *tx = list_entry(tmp, struct kib_tx, tx_list);
 
                 LASSERT(!tx->tx_queued);
                 LASSERT(tx->tx_sending || tx->tx_waiting);
@@ -249,9 +245,9 @@ kiblnd_find_waiting_tx_locked(kib_conn_t *conn, int txtype, __u64 cookie)
 }
 
 static void
-kiblnd_handle_completion(kib_conn_t *conn, int txtype, int status, __u64 cookie)
+kiblnd_handle_completion(struct kib_conn *conn, int txtype, int status, __u64 cookie)
 {
-        kib_tx_t *tx;
+        struct kib_tx *tx;
         lnet_ni_t *ni = conn->ibc_peer->ibp_ni;
         int idle;
 
@@ -287,10 +283,10 @@ kiblnd_handle_completion(kib_conn_t *conn, int txtype, int status, __u64 cookie)
 }
 
 static void
-kiblnd_send_completion(kib_conn_t *conn, int type, int status, __u64 cookie)
+kiblnd_send_completion(struct kib_conn *conn, int type, int status, __u64 cookie)
 {
         lnet_ni_t *ni = conn->ibc_peer->ibp_ni;
-        kib_tx_t *tx = kiblnd_get_idle_tx(ni, conn->ibc_peer->ibp_nid);
+        struct kib_tx *tx = kiblnd_get_idle_tx(ni, conn->ibc_peer->ibp_nid);
 
         if (!tx) {
                 CERROR("Can't get tx for completion %x for %s\n",
@@ -300,19 +296,19 @@ kiblnd_send_completion(kib_conn_t *conn, int type, int status, __u64 cookie)
 
         tx->tx_msg->ibm_u.completion.ibcm_status = status;
         tx->tx_msg->ibm_u.completion.ibcm_cookie = cookie;
-        kiblnd_init_tx_msg(ni, tx, type, sizeof(kib_completion_msg_t));
+        kiblnd_init_tx_msg(ni, tx, type, sizeof(struct kib_completion_msg));
 
         kiblnd_queue_tx(tx, conn);
 }
 
 static void
-kiblnd_handle_rx(kib_rx_t *rx)
+kiblnd_handle_rx(struct kib_rx *rx)
 {
-        kib_msg_t *msg = rx->rx_msg;
-        kib_conn_t *conn = rx->rx_conn;
+        struct kib_msg *msg = rx->rx_msg;
+        struct kib_conn *conn = rx->rx_conn;
         lnet_ni_t *ni = conn->ibc_peer->ibp_ni;
         int credits = msg->ibm_credits;
-        kib_tx_t *tx;
+        struct kib_tx *tx;
         int rc = 0;
         int rc2;
         int post_credit;
@@ -467,12 +463,12 @@ kiblnd_handle_rx(kib_rx_t *rx)
 }
 
 static void
-kiblnd_rx_complete(kib_rx_t *rx, int status, int nob)
+kiblnd_rx_complete(struct kib_rx *rx, int status, int nob)
 {
-        kib_msg_t *msg = rx->rx_msg;
-        kib_conn_t *conn = rx->rx_conn;
+        struct kib_msg *msg = rx->rx_msg;
+        struct kib_conn *conn = rx->rx_conn;
         lnet_ni_t *ni = conn->ibc_peer->ibp_ni;
-        kib_net_t *net = ni->ni_data;
+        struct kib_net *net = ni->ni_data;
         int rc;
         int err = -EIO;
 
@@ -561,10 +557,10 @@ kiblnd_kvaddr_to_page(unsigned long vaddr)
 }
 
 static int
-kiblnd_fmr_map_tx(kib_net_t *net, kib_tx_t *tx, kib_rdma_desc_t *rd, __u32 nob)
+kiblnd_fmr_map_tx(struct kib_net *net, struct kib_tx *tx, struct kib_rdma_desc *rd, __u32 nob)
 {
-        kib_hca_dev_t *hdev;
-        kib_fmr_poolset_t *fps;
+        struct kib_hca_dev *hdev;
+        struct kib_fmr_poolset *fps;
         int cpt;
         int rc;
 
@@ -593,9 +589,9 @@ kiblnd_fmr_map_tx(kib_net_t *net, kib_tx_t *tx, kib_rdma_desc_t *rd, __u32 nob)
         return 0;
 }
 
-static void kiblnd_unmap_tx(lnet_ni_t *ni, kib_tx_t *tx)
+static void kiblnd_unmap_tx(lnet_ni_t *ni, struct kib_tx *tx)
 {
-        kib_net_t *net = ni->ni_data;
+        struct kib_net *net = ni->ni_data;
 
         LASSERT(net);
 
@@ -609,11 +605,11 @@ static void kiblnd_unmap_tx(lnet_ni_t *ni, kib_tx_t *tx)
         }
 }
 
-static int kiblnd_map_tx(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
+static int kiblnd_map_tx(lnet_ni_t *ni, struct kib_tx *tx, struct kib_rdma_desc *rd,
                          int nfrags)
 {
-        kib_net_t *net = ni->ni_data;
-        kib_hca_dev_t *hdev = net->ibn_dev->ibd_hdev;
+        struct kib_net *net = ni->ni_data;
+        struct kib_hca_dev *hdev = net->ibn_dev->ibd_hdev;
         struct ib_mr *mr    = NULL;
         __u32 nob;
         int i;
@@ -651,10 +647,10 @@ static int kiblnd_map_tx(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
 }
 
 static int
-kiblnd_setup_rd_iov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
+kiblnd_setup_rd_iov(lnet_ni_t *ni, struct kib_tx *tx, struct kib_rdma_desc *rd,
                     unsigned int niov, struct kvec *iov, int offset, int nob)
 {
-        kib_net_t *net = ni->ni_data;
+        struct kib_net *net = ni->ni_data;
         struct page *page;
         struct scatterlist *sg;
         unsigned long vaddr;
@@ -689,6 +685,10 @@ kiblnd_setup_rd_iov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
 
                 sg_set_page(sg, page, fragnob, page_offset);
                 sg = sg_next(sg);
+                if (!sg) {
+                        CERROR("lacking enough sg entries to map tx\n");
+                        return -EFAULT;
+                }
 
                 if (offset + fragnob < iov->iov_len) {
                         offset += fragnob;
@@ -704,10 +704,10 @@ kiblnd_setup_rd_iov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
 }
 
 static int
-kiblnd_setup_rd_kiov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
+kiblnd_setup_rd_kiov(lnet_ni_t *ni, struct kib_tx *tx, struct kib_rdma_desc *rd,
                      int nkiov, lnet_kiov_t *kiov, int offset, int nob)
 {
-        kib_net_t *net = ni->ni_data;
+        struct kib_net *net = ni->ni_data;
         struct scatterlist *sg;
         int fragnob;
 
@@ -733,6 +733,10 @@ kiblnd_setup_rd_kiov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
                 sg_set_page(sg, kiov->kiov_page, fragnob,
                             kiov->kiov_offset + offset);
                 sg = sg_next(sg);
+                if (!sg) {
+                        CERROR("lacking enough sg entries to map tx\n");
+                        return -EFAULT;
+                }
 
                 offset = 0;
                 kiov++;
@@ -744,11 +748,11 @@ kiblnd_setup_rd_kiov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
 }
 
 static int
-kiblnd_post_tx_locked(kib_conn_t *conn, kib_tx_t *tx, int credit)
+kiblnd_post_tx_locked(struct kib_conn *conn, struct kib_tx *tx, int credit)
         __must_hold(&conn->ibc_lock)
 {
-        kib_msg_t *msg = tx->tx_msg;
-        kib_peer_t *peer = conn->ibc_peer;
+        struct kib_msg *msg = tx->tx_msg;
+        struct kib_peer *peer = conn->ibc_peer;
         struct lnet_ni *ni = peer->ibp_ni;
         int ver = conn->ibc_version;
         int rc;
@@ -901,11 +905,11 @@ kiblnd_post_tx_locked(kib_conn_t *conn, kib_tx_t *tx, int credit)
 }
 
 static void
-kiblnd_check_sends(kib_conn_t *conn)
+kiblnd_check_sends(struct kib_conn *conn)
 {
         int ver = conn->ibc_version;
         lnet_ni_t *ni = conn->ibc_peer->ibp_ni;
-        kib_tx_t *tx;
+        struct kib_tx *tx;
 
         /* Don't send anything until after the connection is established */
         if (conn->ibc_state < IBLND_CONN_ESTABLISHED) {
@@ -924,7 +928,7 @@ kiblnd_check_sends(kib_conn_t *conn)
         while (conn->ibc_reserved_credits > 0 &&
                !list_empty(&conn->ibc_tx_queue_rsrvd)) {
                 tx = list_entry(conn->ibc_tx_queue_rsrvd.next,
-                                kib_tx_t, tx_list);
+                                struct kib_tx, tx_list);
                 list_del(&tx->tx_list);
                 list_add_tail(&tx->tx_list, &conn->ibc_tx_queue);
                 conn->ibc_reserved_credits--;
@@ -948,16 +952,16 @@ kiblnd_check_sends(kib_conn_t *conn)
                 if (!list_empty(&conn->ibc_tx_queue_nocred)) {
                         credit = 0;
                         tx = list_entry(conn->ibc_tx_queue_nocred.next,
-                                        kib_tx_t, tx_list);
+                                        struct kib_tx, tx_list);
                 } else if (!list_empty(&conn->ibc_tx_noops)) {
                         LASSERT(!IBLND_OOB_CAPABLE(ver));
                         credit = 1;
                         tx = list_entry(conn->ibc_tx_noops.next,
-                                        kib_tx_t, tx_list);
+                                        struct kib_tx, tx_list);
                 } else if (!list_empty(&conn->ibc_tx_queue)) {
                         credit = 1;
                         tx = list_entry(conn->ibc_tx_queue.next,
-                                        kib_tx_t, tx_list);
+                                        struct kib_tx, tx_list);
                 } else {
                         break;
                 }
@@ -970,10 +974,10 @@ kiblnd_check_sends(kib_conn_t *conn)
 }
 
 static void
-kiblnd_tx_complete(kib_tx_t *tx, int status)
+kiblnd_tx_complete(struct kib_tx *tx, int status)
 {
         int failed = (status != IB_WC_SUCCESS);
-        kib_conn_t *conn = tx->tx_conn;
+        struct kib_conn *conn = tx->tx_conn;
         int idle;
 
         LASSERT(tx->tx_sending > 0);
@@ -1025,12 +1029,12 @@ kiblnd_tx_complete(kib_tx_t *tx, int status)
 }
 
 static void
-kiblnd_init_tx_msg(lnet_ni_t *ni, kib_tx_t *tx, int type, int body_nob)
+kiblnd_init_tx_msg(lnet_ni_t *ni, struct kib_tx *tx, int type, int body_nob)
 {
-        kib_hca_dev_t *hdev = tx->tx_pool->tpo_hdev;
+        struct kib_hca_dev *hdev = tx->tx_pool->tpo_hdev;
         struct ib_sge *sge = &tx->tx_sge[tx->tx_nwrq];
         struct ib_rdma_wr *wrq = &tx->tx_wrq[tx->tx_nwrq];
-        int nob = offsetof(kib_msg_t, ibm_u) + body_nob;
+        int nob = offsetof(struct kib_msg, ibm_u) + body_nob;
         struct ib_mr *mr = hdev->ibh_mrs;
 
         LASSERT(tx->tx_nwrq >= 0);
@@ -1057,11 +1061,11 @@ kiblnd_init_tx_msg(lnet_ni_t *ni, kib_tx_t *tx, int type, int body_nob)
 }
 
 static int
-kiblnd_init_rdma(kib_conn_t *conn, kib_tx_t *tx, int type,
-                 int resid, kib_rdma_desc_t *dstrd, __u64 dstcookie)
+kiblnd_init_rdma(struct kib_conn *conn, struct kib_tx *tx, int type,
+                 int resid, struct kib_rdma_desc *dstrd, __u64 dstcookie)
 {
-        kib_msg_t *ibmsg = tx->tx_msg;
-        kib_rdma_desc_t *srcrd = tx->tx_rd;
+        struct kib_msg *ibmsg = tx->tx_msg;
+        struct kib_rdma_desc *srcrd = tx->tx_rd;
         struct ib_sge *sge = &tx->tx_sge[0];
         struct ib_rdma_wr *wrq, *next;
         int rc  = resid;
@@ -1099,7 +1103,7 @@ kiblnd_init_rdma(kib_conn_t *conn, kib_tx_t *tx, int type,
 
                 wrknob = min(min(kiblnd_rd_frag_size(srcrd, srcidx),
                                  kiblnd_rd_frag_size(dstrd, dstidx)),
-                             (__u32) resid);
+                             (__u32)resid);
 
                 sge = &tx->tx_sge[tx->tx_nwrq];
                 sge->addr   = kiblnd_rd_frag_addr(srcrd, srcidx);
@@ -1135,13 +1139,13 @@ kiblnd_init_rdma(kib_conn_t *conn, kib_tx_t *tx, int type,
         ibmsg->ibm_u.completion.ibcm_status = rc;
         ibmsg->ibm_u.completion.ibcm_cookie = dstcookie;
         kiblnd_init_tx_msg(conn->ibc_peer->ibp_ni, tx,
-                           type, sizeof(kib_completion_msg_t));
+                           type, sizeof(struct kib_completion_msg));
 
         return rc;
 }
 
 static void
-kiblnd_queue_tx_locked(kib_tx_t *tx, kib_conn_t *conn)
+kiblnd_queue_tx_locked(struct kib_tx *tx, struct kib_conn *conn)
 {
         struct list_head *q;
 
@@ -1196,7 +1200,7 @@ kiblnd_queue_tx_locked(kib_tx_t *tx, kib_conn_t *conn)
 }
 
 static void
-kiblnd_queue_tx(kib_tx_t *tx, kib_conn_t *conn)
+kiblnd_queue_tx(struct kib_tx *tx, struct kib_conn *conn)
 {
         spin_lock(&conn->ibc_lock);
         kiblnd_queue_tx_locked(tx, conn);
@@ -1243,11 +1247,11 @@ static int kiblnd_resolve_addr(struct rdma_cm_id *cmid,
 }
 
 static void
-kiblnd_connect_peer(kib_peer_t *peer)
+kiblnd_connect_peer(struct kib_peer *peer)
 {
         struct rdma_cm_id *cmid;
-        kib_dev_t *dev;
-        kib_net_t *net = peer->ibp_ni->ni_data;
+        struct kib_dev *dev;
+        struct kib_net *net = peer->ibp_ni->ni_data;
         struct sockaddr_in srcaddr;
         struct sockaddr_in dstaddr;
         int rc;
@@ -1311,7 +1315,7 @@ kiblnd_connect_peer(kib_peer_t *peer)
 }
 
 bool
-kiblnd_reconnect_peer(kib_peer_t *peer)
+kiblnd_reconnect_peer(struct kib_peer *peer)
 {
         rwlock_t *glock = &kiblnd_data.kib_global_lock;
         char *reason = NULL;
@@ -1361,11 +1365,11 @@ no_reconnect:
 }
 
 void
-kiblnd_launch_tx(lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid)
+kiblnd_launch_tx(lnet_ni_t *ni, struct kib_tx *tx, lnet_nid_t nid)
 {
-        kib_peer_t *peer;
-        kib_peer_t *peer2;
-        kib_conn_t *conn;
+        struct kib_peer *peer;
+        struct kib_peer *peer2;
+        struct kib_conn *conn;
         rwlock_t *g_lock = &kiblnd_data.kib_global_lock;
         unsigned long flags;
         int rc;
@@ -1468,7 +1472,7 @@ kiblnd_launch_tx(lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid)
         peer->ibp_connecting = 1;
 
         /* always called with a ref on ni, which prevents ni being shutdown */
-        LASSERT(!((kib_net_t *)ni->ni_data)->ibn_shutdown);
+        LASSERT(!((struct kib_net *)ni->ni_data)->ibn_shutdown);
 
         if (tx)
                 list_add_tail(&tx->tx_list, &peer->ibp_tx_queue);
@@ -1495,9 +1499,9 @@ kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
         lnet_kiov_t *payload_kiov = lntmsg->msg_kiov;
         unsigned int payload_offset = lntmsg->msg_offset;
         unsigned int payload_nob = lntmsg->msg_len;
-        kib_msg_t *ibmsg;
-        kib_rdma_desc_t  *rd;
-        kib_tx_t *tx;
+        struct kib_msg *ibmsg;
+        struct kib_rdma_desc  *rd;
+        struct kib_tx *tx;
         int nob;
         int rc;
 
@@ -1528,7 +1532,7 @@ kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
                         break;            /* send IMMEDIATE */
 
                 /* is the REPLY message too small for RDMA? */
-                nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[lntmsg->msg_md->md_length]);
+                nob = offsetof(struct kib_msg, ibm_u.immediate.ibim_payload[lntmsg->msg_md->md_length]);
                 if (nob <= IBLND_MSG_SIZE)
                         break;            /* send IMMEDIATE */
 
@@ -1558,7 +1562,7 @@ kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
                         return -EIO;
                 }
 
-                nob = offsetof(kib_get_msg_t, ibgm_rd.rd_frags[rd->rd_nfrags]);
+                nob = offsetof(struct kib_get_msg, ibgm_rd.rd_frags[rd->rd_nfrags]);
                 ibmsg->ibm_u.get.ibgm_cookie = tx->tx_cookie;
                 ibmsg->ibm_u.get.ibgm_hdr = *hdr;
 
@@ -1580,7 +1584,7 @@ kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
         case LNET_MSG_REPLY:
         case LNET_MSG_PUT:
                 /* Is the payload small enough not to need RDMA? */
-                nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[payload_nob]);
+                nob = offsetof(struct kib_msg, ibm_u.immediate.ibim_payload[payload_nob]);
                 if (nob <= IBLND_MSG_SIZE)
                         break;            /* send IMMEDIATE */
 
@@ -1610,7 +1614,7 @@ kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
                 ibmsg = tx->tx_msg;
                 ibmsg->ibm_u.putreq.ibprm_hdr = *hdr;
                 ibmsg->ibm_u.putreq.ibprm_cookie = tx->tx_cookie;
-                kiblnd_init_tx_msg(ni, tx, IBLND_MSG_PUT_REQ, sizeof(kib_putreq_msg_t));
+                kiblnd_init_tx_msg(ni, tx, IBLND_MSG_PUT_REQ, sizeof(struct kib_putreq_msg));
 
                 tx->tx_lntmsg[0] = lntmsg;      /* finalise lntmsg on completion */
                 tx->tx_waiting = 1;          /* waiting for PUT_{ACK,NAK} */
@@ -1620,7 +1624,7 @@ kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
 
         /* send IMMEDIATE */
 
-        LASSERT(offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[payload_nob])
+        LASSERT(offsetof(struct kib_msg, ibm_u.immediate.ibim_payload[payload_nob])
                  <= IBLND_MSG_SIZE);
 
         tx = kiblnd_get_idle_tx(ni, target.nid);
@@ -1635,16 +1639,16 @@ kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
 
         if (payload_kiov)
                 lnet_copy_kiov2flat(IBLND_MSG_SIZE, ibmsg,
-                                    offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+                                    offsetof(struct kib_msg, ibm_u.immediate.ibim_payload),
                                     payload_niov, payload_kiov,
                                     payload_offset, payload_nob);
         else
                 lnet_copy_iov2flat(IBLND_MSG_SIZE, ibmsg,
-                                   offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+                                   offsetof(struct kib_msg, ibm_u.immediate.ibim_payload),
                                    payload_niov, payload_iov,
                                    payload_offset, payload_nob);
 
-        nob = offsetof(kib_immediate_msg_t, ibim_payload[payload_nob]);
+        nob = offsetof(struct kib_immediate_msg, ibim_payload[payload_nob]);
         kiblnd_init_tx_msg(ni, tx, IBLND_MSG_IMMEDIATE, nob);
 
         tx->tx_lntmsg[0] = lntmsg;            /* finalise lntmsg on completion */
@@ -1653,7 +1657,7 @@ kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
 }
 
 static void
-kiblnd_reply(lnet_ni_t *ni, kib_rx_t *rx, lnet_msg_t *lntmsg)
+kiblnd_reply(lnet_ni_t *ni, struct kib_rx *rx, lnet_msg_t *lntmsg)
 {
         lnet_process_id_t target = lntmsg->msg_target;
         unsigned int niov = lntmsg->msg_niov;
@@ -1661,7 +1665,7 @@ kiblnd_reply(lnet_ni_t *ni, kib_rx_t *rx, lnet_msg_t *lntmsg)
         lnet_kiov_t *kiov = lntmsg->msg_kiov;
         unsigned int offset = lntmsg->msg_offset;
         unsigned int nob = lntmsg->msg_len;
-        kib_tx_t *tx;
+        struct kib_tx *tx;
         int rc;
 
         tx = kiblnd_get_idle_tx(ni, rx->rx_conn->ibc_peer->ibp_nid);
@@ -1718,10 +1722,10 @@ kiblnd_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed,
             unsigned int niov, struct kvec *iov, lnet_kiov_t *kiov,
             unsigned int offset, unsigned int mlen, unsigned int rlen)
 {
-        kib_rx_t *rx = private;
-        kib_msg_t *rxmsg = rx->rx_msg;
-        kib_conn_t *conn = rx->rx_conn;
-        kib_tx_t *tx;
+        struct kib_rx *rx = private;
+        struct kib_msg *rxmsg = rx->rx_msg;
+        struct kib_conn *conn = rx->rx_conn;
+        struct kib_tx *tx;
         int nob;
         int post_credit = IBLND_POSTRX_PEER_CREDIT;
         int rc = 0;
@@ -1736,7 +1740,7 @@ kiblnd_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed,
                 LBUG();
 
         case IBLND_MSG_IMMEDIATE:
-                nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[rlen]);
+                nob = offsetof(struct kib_msg, ibm_u.immediate.ibim_payload[rlen]);
                 if (nob > rx->rx_nob) {
                         CERROR("Immediate message from %s too big: %d(%d)\n",
                                libcfs_nid2str(rxmsg->ibm_u.immediate.ibim_hdr.src_nid),
@@ -1748,19 +1752,19 @@ kiblnd_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed,
                 if (kiov)
                         lnet_copy_flat2kiov(niov, kiov, offset,
                                             IBLND_MSG_SIZE, rxmsg,
-                                            offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+                                            offsetof(struct kib_msg, ibm_u.immediate.ibim_payload),
                                             mlen);
                 else
                         lnet_copy_flat2iov(niov, iov, offset,
                                            IBLND_MSG_SIZE, rxmsg,
-                                           offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+                                           offsetof(struct kib_msg, ibm_u.immediate.ibim_payload),
                                            mlen);
                 lnet_finalize(ni, lntmsg, 0);
                 break;
 
         case IBLND_MSG_PUT_REQ: {
-                kib_msg_t       *txmsg;
-                kib_rdma_desc_t *rd;
+                struct kib_msg  *txmsg;
+                struct kib_rdma_desc *rd;
 
                 if (!mlen) {
                         lnet_finalize(ni, lntmsg, 0);
@@ -1796,7 +1800,7 @@ kiblnd_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed,
                         break;
                 }
 
-                nob = offsetof(kib_putack_msg_t, ibpam_rd.rd_frags[rd->rd_nfrags]);
+                nob = offsetof(struct kib_putack_msg, ibpam_rd.rd_frags[rd->rd_nfrags]);
                 txmsg->ibm_u.putack.ibpam_src_cookie = rxmsg->ibm_u.putreq.ibprm_cookie;
                 txmsg->ibm_u.putack.ibpam_dst_cookie = tx->tx_cookie;
 
@@ -1847,7 +1851,7 @@ kiblnd_thread_fini(void)
 }
 
 static void
-kiblnd_peer_alive(kib_peer_t *peer)
+kiblnd_peer_alive(struct kib_peer *peer)
 {
         /* This is racy, but everyone's only writing cfs_time_current() */
         peer->ibp_last_alive = cfs_time_current();
@@ -1855,7 +1859,7 @@ kiblnd_peer_alive(kib_peer_t *peer)
 }
 
 static void
-kiblnd_peer_notify(kib_peer_t *peer)
+kiblnd_peer_notify(struct kib_peer *peer)
 {
         int error = 0;
         unsigned long last_alive = 0;
@@ -1878,7 +1882,7 @@ kiblnd_peer_notify(kib_peer_t *peer)
 }
 
 void
-kiblnd_close_conn_locked(kib_conn_t *conn, int error)
+kiblnd_close_conn_locked(struct kib_conn *conn, int error)
 {
         /*
          * This just does the immediate housekeeping. 'error' is zero for a
@@ -1888,8 +1892,8 @@ kiblnd_close_conn_locked(kib_conn_t *conn, int error)
          * already dealing with it (either to set it up or tear it down).
          * Caller holds kib_global_lock exclusively in irq context
          */
-        kib_peer_t *peer = conn->ibc_peer;
-        kib_dev_t *dev;
+        struct kib_peer *peer = conn->ibc_peer;
+        struct kib_dev *dev;
         unsigned long flags;
 
         LASSERT(error || conn->ibc_state >= IBLND_CONN_ESTABLISHED);
@@ -1918,7 +1922,7 @@ kiblnd_close_conn_locked(kib_conn_t *conn, int error)
                         list_empty(&conn->ibc_active_txs) ? "" : "(waiting)");
         }
 
-        dev = ((kib_net_t *)peer->ibp_ni->ni_data)->ibn_dev;
+        dev = ((struct kib_net *)peer->ibp_ni->ni_data)->ibn_dev;
         list_del(&conn->ibc_list);
         /* connd (see below) takes over ibc_list's ref */
 
@@ -1948,7 +1952,7 @@ kiblnd_close_conn_locked(kib_conn_t *conn, int error)
 }
 
 void
-kiblnd_close_conn(kib_conn_t *conn, int error)
+kiblnd_close_conn(struct kib_conn *conn, int error)
 {
         unsigned long flags;
 
@@ -1960,11 +1964,11 @@ kiblnd_close_conn(kib_conn_t *conn, int error)
 }
 
 static void
-kiblnd_handle_early_rxs(kib_conn_t *conn)
+kiblnd_handle_early_rxs(struct kib_conn *conn)
 {
         unsigned long flags;
-        kib_rx_t *rx;
-        kib_rx_t *tmp;
+        struct kib_rx *rx;
+        struct kib_rx *tmp;
 
         LASSERT(!in_interrupt());
         LASSERT(conn->ibc_state >= IBLND_CONN_ESTABLISHED);
@@ -1982,17 +1986,17 @@ kiblnd_handle_early_rxs(kib_conn_t *conn)
 }
 
 static void
-kiblnd_abort_txs(kib_conn_t *conn, struct list_head *txs)
+kiblnd_abort_txs(struct kib_conn *conn, struct list_head *txs)
 {
         LIST_HEAD(zombies);
         struct list_head *tmp;
         struct list_head *nxt;
-        kib_tx_t *tx;
+        struct kib_tx *tx;
 
         spin_lock(&conn->ibc_lock);
 
         list_for_each_safe(tmp, nxt, txs) {
-                tx = list_entry(tmp, kib_tx_t, tx_list);
+                tx = list_entry(tmp, struct kib_tx, tx_list);
 
                 if (txs == &conn->ibc_active_txs) {
                         LASSERT(!tx->tx_queued);
@@ -2017,7 +2021,7 @@ kiblnd_abort_txs(kib_conn_t *conn, struct list_head *txs)
 }
 
 static void
-kiblnd_finalise_conn(kib_conn_t *conn)
+kiblnd_finalise_conn(struct kib_conn *conn)
 {
         LASSERT(!in_interrupt());
         LASSERT(conn->ibc_state > IBLND_CONN_INIT);
@@ -2045,7 +2049,7 @@ kiblnd_finalise_conn(kib_conn_t *conn)
 }
 
 static void
-kiblnd_peer_connect_failed(kib_peer_t *peer, int active, int error)
+kiblnd_peer_connect_failed(struct kib_peer *peer, int active, int error)
 {
         LIST_HEAD(zombies);
         unsigned long flags;
@@ -2099,11 +2103,11 @@ kiblnd_peer_connect_failed(kib_peer_t *peer, int active, int error)
 }
 
 static void
-kiblnd_connreq_done(kib_conn_t *conn, int status)
+kiblnd_connreq_done(struct kib_conn *conn, int status)
 {
-        kib_peer_t *peer = conn->ibc_peer;
-        kib_tx_t *tx;
-        kib_tx_t *tmp;
+        struct kib_peer *peer = conn->ibc_peer;
+        struct kib_tx *tx;
+        struct kib_tx *tmp;
         struct list_head txs;
         unsigned long flags;
         int active;
@@ -2209,7 +2213,7 @@ kiblnd_connreq_done(kib_conn_t *conn, int status)
 }
 
 static void
-kiblnd_reject(struct rdma_cm_id *cmid, kib_rej_t *rej)
+kiblnd_reject(struct rdma_cm_id *cmid, struct kib_rej *rej)
 {
         int rc;
 
@@ -2223,17 +2227,17 @@ static int
 kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
 {
         rwlock_t *g_lock = &kiblnd_data.kib_global_lock;
-        kib_msg_t *reqmsg = priv;
-        kib_msg_t *ackmsg;
-        kib_dev_t *ibdev;
-        kib_peer_t *peer;
-        kib_peer_t *peer2;
-        kib_conn_t *conn;
+        struct kib_msg *reqmsg = priv;
+        struct kib_msg *ackmsg;
+        struct kib_dev *ibdev;
+        struct kib_peer *peer;
+        struct kib_peer *peer2;
+        struct kib_conn *conn;
         lnet_ni_t *ni  = NULL;
-        kib_net_t *net = NULL;
+        struct kib_net *net = NULL;
         lnet_nid_t nid;
         struct rdma_conn_param cp;
-        kib_rej_t rej;
+        struct kib_rej rej;
         int version = IBLND_MSG_VERSION;
         unsigned long flags;
         int rc;
@@ -2242,7 +2246,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
         LASSERT(!in_interrupt());
 
         /* cmid inherits 'context' from the corresponding listener id */
-        ibdev = (kib_dev_t *)cmid->context;
+        ibdev = (struct kib_dev *)cmid->context;
         LASSERT(ibdev);
 
         memset(&rej, 0, sizeof(rej));
@@ -2260,7 +2264,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
                 goto failed;
         }
 
-        if (priv_nob < offsetof(kib_msg_t, ibm_type)) {
+        if (priv_nob < offsetof(struct kib_msg, ibm_type)) {
                 CERROR("Short connection request\n");
                 goto failed;
         }
@@ -2295,7 +2299,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
         ni = lnet_net2ni(LNET_NIDNET(reqmsg->ibm_dstnid));
 
         if (ni) {
-                net = (kib_net_t *)ni->ni_data;
+                net = (struct kib_net *)ni->ni_data;
                 rej.ibr_incarnation = net->ibn_incarnation;
         }
 
@@ -2534,11 +2538,11 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
 }
 
 static void
-kiblnd_check_reconnect(kib_conn_t *conn, int version,
-                       __u64 incarnation, int why, kib_connparams_t *cp)
+kiblnd_check_reconnect(struct kib_conn *conn, int version,
+                       __u64 incarnation, int why, struct kib_connparams *cp)
 {
         rwlock_t *glock = &kiblnd_data.kib_global_lock;
-        kib_peer_t *peer = conn->ibc_peer;
+        struct kib_peer *peer = conn->ibc_peer;
         char *reason;
         int msg_size = IBLND_MSG_SIZE;
         int frag_num = -1;
@@ -2647,9 +2651,9 @@ out:
 }
 
 static void
-kiblnd_rejected(kib_conn_t *conn, int reason, void *priv, int priv_nob)
+kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob)
 {
-        kib_peer_t *peer = conn->ibc_peer;
+        struct kib_peer *peer = conn->ibc_peer;
 
         LASSERT(!in_interrupt());
         LASSERT(conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT);
@@ -2667,9 +2671,9 @@ kiblnd_rejected(kib_conn_t *conn, int reason, void *priv, int priv_nob)
                 break;
 
         case IB_CM_REJ_CONSUMER_DEFINED:
-                if (priv_nob >= offsetof(kib_rej_t, ibr_padding)) {
-                        kib_rej_t *rej = priv;
-                        kib_connparams_t *cp = NULL;
+                if (priv_nob >= offsetof(struct kib_rej, ibr_padding)) {
+                        struct kib_rej *rej = priv;
+                        struct kib_connparams *cp = NULL;
                         int flip = 0;
                         __u64 incarnation = -1;
 
@@ -2692,7 +2696,7 @@ kiblnd_rejected(kib_conn_t *conn, int reason, void *priv, int priv_nob)
                                 flip = 1;
                         }
 
-                        if (priv_nob >= sizeof(kib_rej_t) &&
+                        if (priv_nob >= sizeof(struct kib_rej) &&
                             rej->ibr_version > IBLND_MSG_VERSION_1) {
                                 /*
                                  * priv_nob is always 148 in current version
@@ -2775,12 +2779,12 @@ kiblnd_rejected(kib_conn_t *conn, int reason, void *priv, int priv_nob)
 }
 
 static void
-kiblnd_check_connreply(kib_conn_t *conn, void *priv, int priv_nob)
+kiblnd_check_connreply(struct kib_conn *conn, void *priv, int priv_nob)
 {
-        kib_peer_t *peer = conn->ibc_peer;
+        struct kib_peer *peer = conn->ibc_peer;
         lnet_ni_t *ni = peer->ibp_ni;
-        kib_net_t *net = ni->ni_data;
-        kib_msg_t *msg = priv;
+        struct kib_net *net = ni->ni_data;
+        struct kib_msg *msg = priv;
         int ver = conn->ibc_version;
         int rc = kiblnd_unpack_msg(msg, priv_nob);
         unsigned long flags;
@@ -2877,9 +2881,9 @@ kiblnd_check_connreply(kib_conn_t *conn, void *priv, int priv_nob)
 static int
 kiblnd_active_connect(struct rdma_cm_id *cmid)
 {
-        kib_peer_t *peer = (kib_peer_t *)cmid->context;
-        kib_conn_t *conn;
-        kib_msg_t *msg;
+        struct kib_peer *peer = (struct kib_peer *)cmid->context;
+        struct kib_conn *conn;
+        struct kib_msg *msg;
         struct rdma_conn_param cp;
         int version;
         __u64 incarnation;
@@ -2944,8 +2948,8 @@ kiblnd_active_connect(struct rdma_cm_id *cmid)
 int
 kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
 {
-        kib_peer_t *peer;
-        kib_conn_t *conn;
+        struct kib_peer *peer;
+        struct kib_conn *conn;
         int rc;
 
         switch (event->event) {
@@ -2963,7 +2967,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                 return rc;
 
         case RDMA_CM_EVENT_ADDR_ERROR:
-                peer = (kib_peer_t *)cmid->context;
+                peer = (struct kib_peer *)cmid->context;
                 CNETERR("%s: ADDR ERROR %d\n",
                         libcfs_nid2str(peer->ibp_nid), event->status);
                 kiblnd_peer_connect_failed(peer, 1, -EHOSTUNREACH);
@@ -2971,7 +2975,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                 return -EHOSTUNREACH;      /* rc destroys cmid */
 
         case RDMA_CM_EVENT_ADDR_RESOLVED:
-                peer = (kib_peer_t *)cmid->context;
+                peer = (struct kib_peer *)cmid->context;
 
                 CDEBUG(D_NET, "%s Addr resolved: %d\n",
                        libcfs_nid2str(peer->ibp_nid), event->status);
@@ -2994,7 +2998,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                 return rc;                    /* rc destroys cmid */
 
         case RDMA_CM_EVENT_ROUTE_ERROR:
-                peer = (kib_peer_t *)cmid->context;
+                peer = (struct kib_peer *)cmid->context;
                 CNETERR("%s: ROUTE ERROR %d\n",
                         libcfs_nid2str(peer->ibp_nid), event->status);
                 kiblnd_peer_connect_failed(peer, 1, -EHOSTUNREACH);
@@ -3002,7 +3006,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                 return -EHOSTUNREACH;      /* rc destroys cmid */
 
         case RDMA_CM_EVENT_ROUTE_RESOLVED:
-                peer = (kib_peer_t *)cmid->context;
+                peer = (struct kib_peer *)cmid->context;
                 CDEBUG(D_NET, "%s Route resolved: %d\n",
                        libcfs_nid2str(peer->ibp_nid), event->status);
 
@@ -3016,7 +3020,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                 return event->status;      /* rc destroys cmid */
 
         case RDMA_CM_EVENT_UNREACHABLE:
-                conn = (kib_conn_t *)cmid->context;
+                conn = (struct kib_conn *)cmid->context;
                 LASSERT(conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT ||
                         conn->ibc_state == IBLND_CONN_PASSIVE_WAIT);
                 CNETERR("%s: UNREACHABLE %d\n",
@@ -3026,7 +3030,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                 return 0;
 
         case RDMA_CM_EVENT_CONNECT_ERROR:
-                conn = (kib_conn_t *)cmid->context;
+                conn = (struct kib_conn *)cmid->context;
                 LASSERT(conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT ||
                         conn->ibc_state == IBLND_CONN_PASSIVE_WAIT);
                 CNETERR("%s: CONNECT ERROR %d\n",
@@ -3036,7 +3040,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                 return 0;
 
         case RDMA_CM_EVENT_REJECTED:
-                conn = (kib_conn_t *)cmid->context;
+                conn = (struct kib_conn *)cmid->context;
                 switch (conn->ibc_state) {
                 default:
                         LBUG();
@@ -3058,7 +3062,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                 return 0;
 
         case RDMA_CM_EVENT_ESTABLISHED:
-                conn = (kib_conn_t *)cmid->context;
+                conn = (struct kib_conn *)cmid->context;
                 switch (conn->ibc_state) {
                 default:
                         LBUG();
@@ -3084,7 +3088,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                 CDEBUG(D_NET, "Ignore TIMEWAIT_EXIT event\n");
                 return 0;
         case RDMA_CM_EVENT_DISCONNECTED:
-                conn = (kib_conn_t *)cmid->context;
+                conn = (struct kib_conn *)cmid->context;
                 if (conn->ibc_state < IBLND_CONN_ESTABLISHED) {
                         CERROR("%s DISCONNECTED\n",
                                libcfs_nid2str(conn->ibc_peer->ibp_nid));
@@ -3113,13 +3117,13 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
 }
 
 static int
-kiblnd_check_txs_locked(kib_conn_t *conn, struct list_head *txs)
+kiblnd_check_txs_locked(struct kib_conn *conn, struct list_head *txs)
 {
-        kib_tx_t *tx;
+        struct kib_tx *tx;
         struct list_head *ttmp;
 
         list_for_each(ttmp, txs) {
-                tx = list_entry(ttmp, kib_tx_t, tx_list);
+                tx = list_entry(ttmp, struct kib_tx, tx_list);
 
                 if (txs != &conn->ibc_active_txs) {
                         LASSERT(tx->tx_queued);
@@ -3140,7 +3144,7 @@ kiblnd_check_txs_locked(kib_conn_t *conn, struct list_head *txs)
 }
 
 static int
-kiblnd_conn_timed_out_locked(kib_conn_t *conn)
+kiblnd_conn_timed_out_locked(struct kib_conn *conn)
 {
         return  kiblnd_check_txs_locked(conn, &conn->ibc_tx_queue) ||
                 kiblnd_check_txs_locked(conn, &conn->ibc_tx_noops) ||
@@ -3156,10 +3160,10 @@ kiblnd_check_conns(int idx)
         LIST_HEAD(checksends);
         struct list_head *peers = &kiblnd_data.kib_peers[idx];
         struct list_head *ptmp;
-        kib_peer_t *peer;
-        kib_conn_t *conn;
-        kib_conn_t *temp;
-        kib_conn_t *tmp;
+        struct kib_peer *peer;
+        struct kib_conn *conn;
+        struct kib_conn *temp;
+        struct kib_conn *tmp;
         struct list_head *ctmp;
         unsigned long flags;
 
@@ -3171,13 +3175,13 @@ kiblnd_check_conns(int idx)
         read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
 
         list_for_each(ptmp, peers) {
-                peer = list_entry(ptmp, kib_peer_t, ibp_list);
+                peer = list_entry(ptmp, struct kib_peer, ibp_list);
 
                 list_for_each(ctmp, &peer->ibp_conns) {
                         int timedout;
                         int sendnoop;
 
-                        conn = list_entry(ctmp, kib_conn_t, ibc_list);
+                        conn = list_entry(ctmp, struct kib_conn, ibc_list);
 
                         LASSERT(conn->ibc_state == IBLND_CONN_ESTABLISHED);
 
@@ -3235,7 +3239,7 @@ kiblnd_check_conns(int idx)
 }
 
 static void
-kiblnd_disconnect_conn(kib_conn_t *conn)
+kiblnd_disconnect_conn(struct kib_conn *conn)
 {
         LASSERT(!in_interrupt());
         LASSERT(current == kiblnd_data.kib_connd);
@@ -3264,7 +3268,7 @@ kiblnd_connd(void *arg)
         spinlock_t *lock= &kiblnd_data.kib_connd_lock;
         wait_queue_t wait;
         unsigned long flags;
-        kib_conn_t *conn;
+        struct kib_conn *conn;
         int timeout;
         int i;
         int dropped_lock;
@@ -3284,10 +3288,10 @@ kiblnd_connd(void *arg)
                 dropped_lock = 0;
 
                 if (!list_empty(&kiblnd_data.kib_connd_zombies)) {
-                        kib_peer_t *peer = NULL;
+                        struct kib_peer *peer = NULL;
 
                         conn = list_entry(kiblnd_data.kib_connd_zombies.next,
-                                          kib_conn_t, ibc_list);
+                                          struct kib_conn, ibc_list);
                         list_del(&conn->ibc_list);
                         if (conn->ibc_reconnect) {
                                 peer = conn->ibc_peer;
@@ -3314,7 +3318,7 @@ kiblnd_connd(void *arg)
 
                 if (!list_empty(&kiblnd_data.kib_connd_conns)) {
                         conn = list_entry(kiblnd_data.kib_connd_conns.next,
-                                          kib_conn_t, ibc_list);
+                                          struct kib_conn, ibc_list);
                         list_del(&conn->ibc_list);
 
                         spin_unlock_irqrestore(lock, flags);
@@ -3338,7 +3342,7 @@ kiblnd_connd(void *arg)
                                 break;
 
                         conn = list_entry(kiblnd_data.kib_reconn_list.next,
-                                          kib_conn_t, ibc_list);
+                                          struct kib_conn, ibc_list);
                         list_del(&conn->ibc_list);
 
                         spin_unlock_irqrestore(lock, flags);
@@ -3409,7 +3413,7 @@ kiblnd_connd(void *arg)
 void
 kiblnd_qp_event(struct ib_event *event, void *arg)
 {
-        kib_conn_t *conn = arg;
+        struct kib_conn *conn = arg;
 
         switch (event->event) {
         case IB_EVENT_COMM_EST:
@@ -3471,7 +3475,7 @@ kiblnd_cq_completion(struct ib_cq *cq, void *arg)
          * occurred.  But in this case, !ibc_nrx && !ibc_nsends_posted
          * and this CQ is about to be destroyed so I NOOP.
          */
-        kib_conn_t *conn = arg;
+        struct kib_conn *conn = arg;
         struct kib_sched_info *sched = conn->ibc_sched;
         unsigned long flags;
 
@@ -3498,7 +3502,7 @@ kiblnd_cq_completion(struct ib_cq *cq, void *arg)
 void
 kiblnd_cq_event(struct ib_event *event, void *arg)
 {
-        kib_conn_t *conn = arg;
+        struct kib_conn *conn = arg;
 
         CERROR("%s: async CQ event type %d\n",
                libcfs_nid2str(conn->ibc_peer->ibp_nid), event->event);
@@ -3509,7 +3513,7 @@ kiblnd_scheduler(void *arg)
 {
         long id = (long)arg;
         struct kib_sched_info *sched;
-        kib_conn_t *conn;
+        struct kib_conn *conn;
         wait_queue_t wait;
         unsigned long flags;
         struct ib_wc wc;
@@ -3544,7 +3548,7 @@ kiblnd_scheduler(void *arg)
                 did_something = 0;
 
                 if (!list_empty(&sched->ibs_conns)) {
-                        conn = list_entry(sched->ibs_conns.next, kib_conn_t,
+                        conn = list_entry(sched->ibs_conns.next, struct kib_conn,
                                           ibc_sched_list);
                         /* take over kib_sched_conns' ref on conn... */
                         LASSERT(conn->ibc_scheduled);
@@ -3644,7 +3648,7 @@ int
 kiblnd_failover_thread(void *arg)
 {
         rwlock_t *glock = &kiblnd_data.kib_global_lock;
-        kib_dev_t *dev;
+        struct kib_dev *dev;
         wait_queue_t wait;
         unsigned long flags;
         int rc;
diff --git a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_modparams.c b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_modparams.c
index f8fdd4ae3dbf..44e960f60833 100644
--- a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_modparams.c
+++ b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_modparams.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -145,7 +141,7 @@ static int use_privileged_port = 1;
 module_param(use_privileged_port, int, 0644);
 MODULE_PARM_DESC(use_privileged_port, "use privileged port when initiating connection");
 
-kib_tunables_t kiblnd_tunables = {
+struct kib_tunables kiblnd_tunables = {
         .kib_dev_failover      = &dev_failover,
         .kib_service           = &service,
         .kib_cksum             = &cksum,
diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c
index 406c0e7a57b9..07ec540946cd 100644
--- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c
+++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -44,14 +40,14 @@
 #include "socklnd.h"
 
 static lnd_t the_ksocklnd;
-ksock_nal_data_t ksocknal_data;
+struct ksock_nal_data ksocknal_data;
 
-static ksock_interface_t *
+static struct ksock_interface *
 ksocknal_ip2iface(lnet_ni_t *ni, __u32 ip)
 {
-        ksock_net_t *net = ni->ni_data;
+        struct ksock_net *net = ni->ni_data;
         int i;
-        ksock_interface_t *iface;
+        struct ksock_interface *iface;
 
         for (i = 0; i < net->ksnn_ninterfaces; i++) {
                 LASSERT(i < LNET_MAX_INTERFACES);
@@ -64,10 +60,10 @@ ksocknal_ip2iface(lnet_ni_t *ni, __u32 ip)
         return NULL;
 }
 
-static ksock_route_t *
+static struct ksock_route *
 ksocknal_create_route(__u32 ipaddr, int port)
 {
-        ksock_route_t *route;
+        struct ksock_route *route;
 
         LIBCFS_ALLOC(route, sizeof(*route));
         if (!route)
@@ -89,7 +85,7 @@ ksocknal_create_route(__u32 ipaddr, int port)
 }
 
 void
-ksocknal_destroy_route(ksock_route_t *route)
+ksocknal_destroy_route(struct ksock_route *route)
 {
         LASSERT(!atomic_read(&route->ksnr_refcount));
 
@@ -100,11 +96,11 @@ ksocknal_destroy_route(ksock_route_t *route)
 }
 
 static int
-ksocknal_create_peer(ksock_peer_t **peerp, lnet_ni_t *ni, lnet_process_id_t id)
+ksocknal_create_peer(struct ksock_peer **peerp, lnet_ni_t *ni, lnet_process_id_t id)
 {
         int cpt = lnet_cpt_of_nid(id.nid);
-        ksock_net_t *net = ni->ni_data;
-        ksock_peer_t *peer;
+        struct ksock_net *net = ni->ni_data;
+        struct ksock_peer *peer;
 
         LASSERT(id.nid != LNET_NID_ANY);
         LASSERT(id.pid != LNET_PID_ANY);
@@ -148,9 +144,9 @@ ksocknal_create_peer(ksock_peer_t **peerp, lnet_ni_t *ni, lnet_process_id_t id)
 }
 
 void
-ksocknal_destroy_peer(ksock_peer_t *peer)
+ksocknal_destroy_peer(struct ksock_peer *peer)
 {
-        ksock_net_t *net = peer->ksnp_ni->ni_data;
+        struct ksock_net *net = peer->ksnp_ni->ni_data;
 
         CDEBUG(D_NET, "peer %s %p deleted\n",
                libcfs_id2str(peer->ksnp_id), peer);
@@ -175,15 +171,15 @@ ksocknal_destroy_peer(ksock_peer_t *peer)
         spin_unlock_bh(&net->ksnn_lock);
 }
 
-ksock_peer_t *
+struct ksock_peer *
 ksocknal_find_peer_locked(lnet_ni_t *ni, lnet_process_id_t id)
 {
         struct list_head *peer_list = ksocknal_nid2peerlist(id.nid);
         struct list_head *tmp;
-        ksock_peer_t *peer;
+        struct ksock_peer *peer;
 
         list_for_each(tmp, peer_list) {
-                peer = list_entry(tmp, ksock_peer_t, ksnp_list);
+                peer = list_entry(tmp, struct ksock_peer, ksnp_list);
 
                 LASSERT(!peer->ksnp_closing);
 
@@ -202,10 +198,10 @@ ksocknal_find_peer_locked(lnet_ni_t *ni, lnet_process_id_t id)
         return NULL;
 }
 
-ksock_peer_t *
+struct ksock_peer *
 ksocknal_find_peer(lnet_ni_t *ni, lnet_process_id_t id)
 {
-        ksock_peer_t *peer;
+        struct ksock_peer *peer;
 
         read_lock(&ksocknal_data.ksnd_global_lock);
         peer = ksocknal_find_peer_locked(ni, id);
@@ -217,11 +213,11 @@ ksocknal_find_peer(lnet_ni_t *ni, lnet_process_id_t id)
 }
 
 static void
-ksocknal_unlink_peer_locked(ksock_peer_t *peer)
+ksocknal_unlink_peer_locked(struct ksock_peer *peer)
 {
         int i;
         __u32 ip;
-        ksock_interface_t *iface;
+        struct ksock_interface *iface;
 
         for (i = 0; i < peer->ksnp_n_passive_ips; i++) {
                 LASSERT(i < LNET_MAX_INTERFACES);
@@ -253,9 +249,9 @@ ksocknal_get_peer_info(lnet_ni_t *ni, int index,
                        lnet_process_id_t *id, __u32 *myip, __u32 *peer_ip,
                        int *port, int *conn_count, int *share_count)
 {
-        ksock_peer_t *peer;
+        struct ksock_peer *peer;
         struct list_head *ptmp;
-        ksock_route_t *route;
+        struct ksock_route *route;
         struct list_head *rtmp;
         int i;
         int j;
@@ -265,7 +261,7 @@ ksocknal_get_peer_info(lnet_ni_t *ni, int index,
 
         for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) {
                 list_for_each(ptmp, &ksocknal_data.ksnd_peers[i]) {
-                        peer = list_entry(ptmp, ksock_peer_t, ksnp_list);
+                        peer = list_entry(ptmp, struct ksock_peer, ksnp_list);
 
                         if (peer->ksnp_ni != ni)
                                 continue;
@@ -303,7 +299,7 @@ ksocknal_get_peer_info(lnet_ni_t *ni, int index,
                                 if (index-- > 0)
                                         continue;
 
-                                route = list_entry(rtmp, ksock_route_t,
+                                route = list_entry(rtmp, struct ksock_route,
                                                    ksnr_list);
 
                                 *id = peer->ksnp_id;
@@ -323,11 +319,11 @@ ksocknal_get_peer_info(lnet_ni_t *ni, int index,
 }
 
 static void
-ksocknal_associate_route_conn_locked(ksock_route_t *route, ksock_conn_t *conn)
+ksocknal_associate_route_conn_locked(struct ksock_route *route, struct ksock_conn *conn)
 {
-        ksock_peer_t *peer = route->ksnr_peer;
+        struct ksock_peer *peer = route->ksnr_peer;
         int type = conn->ksnc_type;
-        ksock_interface_t *iface;
+        struct ksock_interface *iface;
 
         conn->ksnc_route = route;
         ksocknal_route_addref(route);
@@ -369,11 +365,11 @@ ksocknal_associate_route_conn_locked(ksock_route_t *route, ksock_conn_t *conn)
 }
 
 static void
-ksocknal_add_route_locked(ksock_peer_t *peer, ksock_route_t *route)
+ksocknal_add_route_locked(struct ksock_peer *peer, struct ksock_route *route)
 {
         struct list_head *tmp;
-        ksock_conn_t *conn;
-        ksock_route_t *route2;
+        struct ksock_conn *conn;
+        struct ksock_route *route2;
 
         LASSERT(!peer->ksnp_closing);
         LASSERT(!route->ksnr_peer);
@@ -383,7 +379,7 @@ ksocknal_add_route_locked(ksock_peer_t *peer, ksock_route_t *route)
 
         /* LASSERT(unique) */
         list_for_each(tmp, &peer->ksnp_routes) {
-                route2 = list_entry(tmp, ksock_route_t, ksnr_list);
+                route2 = list_entry(tmp, struct ksock_route, ksnr_list);
 
                 if (route2->ksnr_ipaddr == route->ksnr_ipaddr) {
                         CERROR("Duplicate route %s %pI4h\n",
@@ -399,7 +395,7 @@ ksocknal_add_route_locked(ksock_peer_t *peer, ksock_route_t *route)
         list_add_tail(&route->ksnr_list, &peer->ksnp_routes);
 
         list_for_each(tmp, &peer->ksnp_conns) {
-                conn = list_entry(tmp, ksock_conn_t, ksnc_list);
+                conn = list_entry(tmp, struct ksock_conn, ksnc_list);
 
                 if (conn->ksnc_ipaddr != route->ksnr_ipaddr)
                         continue;
@@ -410,11 +406,11 @@ ksocknal_add_route_locked(ksock_peer_t *peer, ksock_route_t *route)
 }
 
 static void
-ksocknal_del_route_locked(ksock_route_t *route)
+ksocknal_del_route_locked(struct ksock_route *route)
 {
-        ksock_peer_t *peer = route->ksnr_peer;
-        ksock_interface_t *iface;
-        ksock_conn_t *conn;
+        struct ksock_peer *peer = route->ksnr_peer;
+        struct ksock_interface *iface;
+        struct ksock_conn *conn;
         struct list_head *ctmp;
         struct list_head *cnxt;
 
@@ -422,7 +418,7 @@ ksocknal_del_route_locked(ksock_route_t *route)
 
         /* Close associated conns */
         list_for_each_safe(ctmp, cnxt, &peer->ksnp_conns) {
-                conn = list_entry(ctmp, ksock_conn_t, ksnc_list);
+                conn = list_entry(ctmp, struct ksock_conn, ksnc_list);
 
                 if (conn->ksnc_route != route)
                         continue;
@@ -455,10 +451,10 @@ int
 ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port)
 {
         struct list_head *tmp;
-        ksock_peer_t *peer;
-        ksock_peer_t *peer2;
-        ksock_route_t *route;
-        ksock_route_t *route2;
+        struct ksock_peer *peer;
+        struct ksock_peer *peer2;
+        struct ksock_route *route;
+        struct ksock_route *route2;
         int rc;
 
         if (id.nid == LNET_NID_ANY ||
@@ -479,7 +475,7 @@ ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port)
         write_lock_bh(&ksocknal_data.ksnd_global_lock);
 
         /* always called with a ref on ni, so shutdown can't have started */
-        LASSERT(!((ksock_net_t *) ni->ni_data)->ksnn_shutdown);
+        LASSERT(!((struct ksock_net *)ni->ni_data)->ksnn_shutdown);
 
         peer2 = ksocknal_find_peer_locked(ni, id);
         if (peer2) {
@@ -493,7 +489,7 @@ ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port)
 
         route2 = NULL;
         list_for_each(tmp, &peer->ksnp_routes) {
-                route2 = list_entry(tmp, ksock_route_t, ksnr_list);
+                route2 = list_entry(tmp, struct ksock_route, ksnr_list);
 
                 if (route2->ksnr_ipaddr == ipaddr)
                         break;
@@ -514,10 +510,10 @@ ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port)
 }
 
 static void
-ksocknal_del_peer_locked(ksock_peer_t *peer, __u32 ip)
+ksocknal_del_peer_locked(struct ksock_peer *peer, __u32 ip)
 {
-        ksock_conn_t *conn;
-        ksock_route_t *route;
+        struct ksock_conn *conn;
+        struct ksock_route *route;
         struct list_head *tmp;
         struct list_head *nxt;
         int nshared;
@@ -528,7 +524,7 @@ ksocknal_del_peer_locked(ksock_peer_t *peer, __u32 ip)
         ksocknal_peer_addref(peer);
 
         list_for_each_safe(tmp, nxt, &peer->ksnp_routes) {
-                route = list_entry(tmp, ksock_route_t, ksnr_list);
+                route = list_entry(tmp, struct ksock_route, ksnr_list);
 
                 /* no match */
                 if (!(!ip || route->ksnr_ipaddr == ip))
@@ -541,7 +537,7 @@ ksocknal_del_peer_locked(ksock_peer_t *peer, __u32 ip)
 
         nshared = 0;
         list_for_each_safe(tmp, nxt, &peer->ksnp_routes) {
-                route = list_entry(tmp, ksock_route_t, ksnr_list);
+                route = list_entry(tmp, struct ksock_route, ksnr_list);
                 nshared += route->ksnr_share_count;
         }
 
@@ -551,7 +547,7 @@ ksocknal_del_peer_locked(ksock_peer_t *peer, __u32 ip)
                  * left
                  */
                 list_for_each_safe(tmp, nxt, &peer->ksnp_routes) {
-                        route = list_entry(tmp, ksock_route_t, ksnr_list);
+                        route = list_entry(tmp, struct ksock_route, ksnr_list);
 
                         /* we should only be removing auto-entries */
                         LASSERT(!route->ksnr_share_count);
@@ -559,7 +555,7 @@ ksocknal_del_peer_locked(ksock_peer_t *peer, __u32 ip)
                 }
 
                 list_for_each_safe(tmp, nxt, &peer->ksnp_conns) {
-                        conn = list_entry(tmp, ksock_conn_t, ksnc_list);
+                        conn = list_entry(tmp, struct ksock_conn, ksnc_list);
 
                         ksocknal_close_conn_locked(conn, 0);
                 }
@@ -575,7 +571,7 @@ ksocknal_del_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ip)
         LIST_HEAD(zombies);
         struct list_head *ptmp;
         struct list_head *pnxt;
-        ksock_peer_t *peer;
+        struct ksock_peer *peer;
         int lo;
         int hi;
         int i;
@@ -593,7 +589,7 @@ ksocknal_del_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ip)
 
         for (i = lo; i <= hi; i++) {
                 list_for_each_safe(ptmp, pnxt, &ksocknal_data.ksnd_peers[i]) {
-                        peer = list_entry(ptmp, ksock_peer_t, ksnp_list);
+                        peer = list_entry(ptmp, struct ksock_peer, ksnp_list);
 
                         if (peer->ksnp_ni != ni)
                                 continue;
@@ -628,12 +624,12 @@ ksocknal_del_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ip)
         return rc;
 }
 
-static ksock_conn_t *
+static struct ksock_conn *
 ksocknal_get_conn_by_idx(lnet_ni_t *ni, int index)
 {
-        ksock_peer_t *peer;
+        struct ksock_peer *peer;
         struct list_head *ptmp;
-        ksock_conn_t *conn;
+        struct ksock_conn *conn;
         struct list_head *ctmp;
         int i;
 
@@ -641,7 +637,7 @@ ksocknal_get_conn_by_idx(lnet_ni_t *ni, int index)
 
         for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) {
                 list_for_each(ptmp, &ksocknal_data.ksnd_peers[i]) {
-                        peer = list_entry(ptmp, ksock_peer_t, ksnp_list);
+                        peer = list_entry(ptmp, struct ksock_peer, ksnp_list);
 
                         LASSERT(!peer->ksnp_closing);
 
@@ -652,7 +648,7 @@ ksocknal_get_conn_by_idx(lnet_ni_t *ni, int index)
                                 if (index-- > 0)
                                         continue;
 
-                                conn = list_entry(ctmp, ksock_conn_t,
+                                conn = list_entry(ctmp, struct ksock_conn,
                                                   ksnc_list);
                                 ksocknal_conn_addref(conn);
                                 read_unlock(&ksocknal_data.ksnd_global_lock);
@@ -665,11 +661,11 @@ ksocknal_get_conn_by_idx(lnet_ni_t *ni, int index)
         return NULL;
 }
 
-static ksock_sched_t *
+static struct ksock_sched *
 ksocknal_choose_scheduler_locked(unsigned int cpt)
 {
         struct ksock_sched_info *info = ksocknal_data.ksnd_sched_info[cpt];
-        ksock_sched_t *sched;
+        struct ksock_sched *sched;
         int i;
 
         LASSERT(info->ksi_nthreads > 0);
@@ -691,7 +687,7 @@ ksocknal_choose_scheduler_locked(unsigned int cpt)
 static int
 ksocknal_local_ipvec(lnet_ni_t *ni, __u32 *ipaddrs)
 {
-        ksock_net_t *net = ni->ni_data;
+        struct ksock_net *net = ni->ni_data;
         int i;
         int nip;
 
@@ -719,7 +715,7 @@ ksocknal_local_ipvec(lnet_ni_t *ni, __u32 *ipaddrs)
 }
 
 static int
-ksocknal_match_peerip(ksock_interface_t *iface, __u32 *ips, int nips)
+ksocknal_match_peerip(struct ksock_interface *iface, __u32 *ips, int nips)
 {
         int best_netmatch = 0;
         int best_xor      = 0;
@@ -751,12 +747,12 @@ ksocknal_match_peerip(ksock_interface_t *iface, __u32 *ips, int nips)
 }
 
 static int
-ksocknal_select_ips(ksock_peer_t *peer, __u32 *peerips, int n_peerips)
+ksocknal_select_ips(struct ksock_peer *peer, __u32 *peerips, int n_peerips)
 {
         rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock;
-        ksock_net_t *net = peer->ksnp_ni->ni_data;
-        ksock_interface_t *iface;
-        ksock_interface_t *best_iface;
+        struct ksock_net *net = peer->ksnp_ni->ni_data;
+        struct ksock_interface *iface;
+        struct ksock_interface *best_iface;
         int n_ips;
         int i;
         int j;
@@ -862,17 +858,17 @@ ksocknal_select_ips(ksock_peer_t *peer, __u32 *peerips, int n_peerips)
 }
 
 static void
-ksocknal_create_routes(ksock_peer_t *peer, int port,
+ksocknal_create_routes(struct ksock_peer *peer, int port,
                        __u32 *peer_ipaddrs, int npeer_ipaddrs)
 {
-        ksock_route_t *newroute = NULL;
+        struct ksock_route *newroute = NULL;
         rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock;
         lnet_ni_t *ni = peer->ksnp_ni;
-        ksock_net_t *net = ni->ni_data;
+        struct ksock_net *net = ni->ni_data;
         struct list_head *rtmp;
-        ksock_route_t *route;
-        ksock_interface_t *iface;
-        ksock_interface_t *best_iface;
+        struct ksock_route *route;
+        struct ksock_interface *iface;
+        struct ksock_interface *best_iface;
         int best_netmatch;
         int this_netmatch;
         int best_nroutes;
@@ -919,7 +915,7 @@ ksocknal_create_routes(ksock_peer_t *peer, int port,
                 /* Already got a route? */
                 route = NULL;
                 list_for_each(rtmp, &peer->ksnp_routes) {
-                        route = list_entry(rtmp, ksock_route_t, ksnr_list);
+                        route = list_entry(rtmp, struct ksock_route, ksnr_list);
 
                         if (route->ksnr_ipaddr == newroute->ksnr_ipaddr)
                                 break;
@@ -941,7 +937,7 @@ ksocknal_create_routes(ksock_peer_t *peer, int port,
 
                         /* Using this interface already? */
                         list_for_each(rtmp, &peer->ksnp_routes) {
-                                route = list_entry(rtmp, ksock_route_t,
+                                route = list_entry(rtmp, struct ksock_route,
                                                    ksnr_list);
 
                                 if (route->ksnr_myipaddr == iface->ksni_ipaddr)
@@ -985,7 +981,7 @@ ksocknal_create_routes(ksock_peer_t *peer, int port,
 int
 ksocknal_accept(lnet_ni_t *ni, struct socket *sock)
 {
-        ksock_connreq_t *cr;
+        struct ksock_connreq *cr;
         int rc;
         __u32 peer_ip;
         int peer_port;
@@ -1014,9 +1010,9 @@ ksocknal_accept(lnet_ni_t *ni, struct socket *sock)
 }
 
 static int
-ksocknal_connecting(ksock_peer_t *peer, __u32 ipaddr)
+ksocknal_connecting(struct ksock_peer *peer, __u32 ipaddr)
 {
-        ksock_route_t *route;
+        struct ksock_route *route;
 
         list_for_each_entry(route, &peer->ksnp_routes, ksnr_list) {
                 if (route->ksnr_ipaddr == ipaddr)
@@ -1026,7 +1022,7 @@ ksocknal_connecting(ksock_peer_t *peer, __u32 ipaddr)
 }
 
 int
-ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route,
+ksocknal_create_conn(lnet_ni_t *ni, struct ksock_route *route,
                      struct socket *sock, int type)
 {
         rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock;
@@ -1034,15 +1030,15 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route,
         lnet_process_id_t peerid;
         struct list_head *tmp;
         __u64 incarnation;
-        ksock_conn_t *conn;
-        ksock_conn_t *conn2;
-        ksock_peer_t *peer = NULL;
-        ksock_peer_t *peer2;
-        ksock_sched_t *sched;
+        struct ksock_conn *conn;
+        struct ksock_conn *conn2;
+        struct ksock_peer *peer = NULL;
+        struct ksock_peer *peer2;
+        struct ksock_sched *sched;
         ksock_hello_msg_t *hello;
         int cpt;
-        ksock_tx_t *tx;
-        ksock_tx_t *txtmp;
+        struct ksock_tx *tx;
+        struct ksock_tx *txtmp;
         int rc;
         int active;
         char *warn = NULL;
@@ -1150,7 +1146,7 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route,
                 write_lock_bh(global_lock);
 
                 /* called with a ref on ni, so shutdown can't have started */
-                LASSERT(!((ksock_net_t *) ni->ni_data)->ksnn_shutdown);
+                LASSERT(!((struct ksock_net *)ni->ni_data)->ksnn_shutdown);
 
                 peer2 = ksocknal_find_peer_locked(ni, peerid);
                 if (!peer2) {
@@ -1233,7 +1229,7 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route,
          */
         if (conn->ksnc_ipaddr != conn->ksnc_myipaddr) {
                 list_for_each(tmp, &peer->ksnp_conns) {
-                        conn2 = list_entry(tmp, ksock_conn_t, ksnc_list);
+                        conn2 = list_entry(tmp, struct ksock_conn, ksnc_list);
 
                         if (conn2->ksnc_ipaddr != conn->ksnc_ipaddr ||
                             conn2->ksnc_myipaddr != conn->ksnc_myipaddr ||
@@ -1273,7 +1269,7 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route,
          * continually create duplicate routes.
          */
         list_for_each(tmp, &peer->ksnp_routes) {
-                route = list_entry(tmp, ksock_route_t, ksnr_list);
+                route = list_entry(tmp, struct ksock_route, ksnr_list);
 
                 if (route->ksnr_ipaddr != conn->ksnc_ipaddr)
                         continue;
@@ -1432,16 +1428,16 @@ failed_0:
 }
 
 void
-ksocknal_close_conn_locked(ksock_conn_t *conn, int error)
+ksocknal_close_conn_locked(struct ksock_conn *conn, int error)
 {
         /*
          * This just does the immmediate housekeeping, and queues the
          * connection for the reaper to terminate.
          * Caller holds ksnd_global_lock exclusively in irq context
          */
-        ksock_peer_t *peer = conn->ksnc_peer;
-        ksock_route_t *route;
-        ksock_conn_t *conn2;
+        struct ksock_peer *peer = conn->ksnc_peer;
+        struct ksock_route *route;
+        struct ksock_conn *conn2;
         struct list_head *tmp;
 
         LASSERT(!peer->ksnp_error);
@@ -1459,7 +1455,7 @@ ksocknal_close_conn_locked(ksock_conn_t *conn, int error)
 
                 conn2 = NULL;
                 list_for_each(tmp, &peer->ksnp_conns) {
-                        conn2 = list_entry(tmp, ksock_conn_t, ksnc_list);
+                        conn2 = list_entry(tmp, struct ksock_conn, ksnc_list);
 
                         if (conn2->ksnc_route == route &&
                             conn2->ksnc_type == conn->ksnc_type)
@@ -1484,7 +1480,7 @@ ksocknal_close_conn_locked(ksock_conn_t *conn, int error)
                 /* No more connections to this peer */
 
                 if (!list_empty(&peer->ksnp_tx_queue)) {
-                        ksock_tx_t *tx;
+                        struct ksock_tx *tx;
 
                         LASSERT(conn->ksnc_proto == &ksocknal_protocol_v3x);
 
@@ -1524,7 +1520,7 @@ ksocknal_close_conn_locked(ksock_conn_t *conn, int error)
 }
 
 void
-ksocknal_peer_failed(ksock_peer_t *peer)
+ksocknal_peer_failed(struct ksock_peer *peer)
 {
         int notify = 0;
         unsigned long last_alive = 0;
@@ -1552,12 +1548,12 @@ ksocknal_peer_failed(ksock_peer_t *peer)
 }
 
 void
-ksocknal_finalize_zcreq(ksock_conn_t *conn)
+ksocknal_finalize_zcreq(struct ksock_conn *conn)
 {
-        ksock_peer_t *peer = conn->ksnc_peer;
-        ksock_tx_t *tx;
-        ksock_tx_t *temp;
-        ksock_tx_t *tmp;
+        struct ksock_peer *peer = conn->ksnc_peer;
+        struct ksock_tx *tx;
+        struct ksock_tx *temp;
+        struct ksock_tx *tmp;
         LIST_HEAD(zlist);
 
         /*
@@ -1589,7 +1585,7 @@ ksocknal_finalize_zcreq(ksock_conn_t *conn)
 }
 
 void
-ksocknal_terminate_conn(ksock_conn_t *conn)
+ksocknal_terminate_conn(struct ksock_conn *conn)
 {
         /*
          * This gets called by the reaper (guaranteed thread context) to
@@ -1597,8 +1593,8 @@ ksocknal_terminate_conn(ksock_conn_t *conn)
          * ksnc_refcount will eventually hit zero, and then the reaper will
          * destroy it.
          */
-        ksock_peer_t *peer = conn->ksnc_peer;
-        ksock_sched_t *sched = conn->ksnc_scheduler;
+        struct ksock_peer *peer = conn->ksnc_peer;
+        struct ksock_sched *sched = conn->ksnc_scheduler;
         int failed = 0;
 
         LASSERT(conn->ksnc_closing);
@@ -1656,7 +1652,7 @@ ksocknal_terminate_conn(ksock_conn_t *conn)
 }
 
 void
-ksocknal_queue_zombie_conn(ksock_conn_t *conn)
+ksocknal_queue_zombie_conn(struct ksock_conn *conn)
 {
         /* Queue the conn for the reaper to destroy */
 
@@ -1670,7 +1666,7 @@ ksocknal_queue_zombie_conn(ksock_conn_t *conn)
 }
 
 void
-ksocknal_destroy_conn(ksock_conn_t *conn)
+ksocknal_destroy_conn(struct ksock_conn *conn)
 {
         unsigned long last_rcv;
 
@@ -1730,15 +1726,15 @@ ksocknal_destroy_conn(ksock_conn_t *conn)
 }
 
 int
-ksocknal_close_peer_conns_locked(ksock_peer_t *peer, __u32 ipaddr, int why)
+ksocknal_close_peer_conns_locked(struct ksock_peer *peer, __u32 ipaddr, int why)
 {
-        ksock_conn_t *conn;
+        struct ksock_conn *conn;
         struct list_head *ctmp;
         struct list_head *cnxt;
         int count = 0;
 
         list_for_each_safe(ctmp, cnxt, &peer->ksnp_conns) {
-                conn = list_entry(ctmp, ksock_conn_t, ksnc_list);
+                conn = list_entry(ctmp, struct ksock_conn, ksnc_list);
 
                 if (!ipaddr || conn->ksnc_ipaddr == ipaddr) {
                         count++;
@@ -1750,9 +1746,9 @@ ksocknal_close_peer_conns_locked(ksock_peer_t *peer, __u32 ipaddr, int why)
 }
 
 int
-ksocknal_close_conn_and_siblings(ksock_conn_t *conn, int why)
+ksocknal_close_conn_and_siblings(struct ksock_conn *conn, int why)
 {
-        ksock_peer_t *peer = conn->ksnc_peer;
+        struct ksock_peer *peer = conn->ksnc_peer;
         __u32 ipaddr = conn->ksnc_ipaddr;
         int count;
 
@@ -1768,7 +1764,7 @@ ksocknal_close_conn_and_siblings(ksock_conn_t *conn, int why)
 int
 ksocknal_close_matching_conns(lnet_process_id_t id, __u32 ipaddr)
 {
-        ksock_peer_t *peer;
+        struct ksock_peer *peer;
         struct list_head *ptmp;
         struct list_head *pnxt;
         int lo;
@@ -1789,7 +1785,7 @@ ksocknal_close_matching_conns(lnet_process_id_t id, __u32 ipaddr)
         for (i = lo; i <= hi; i++) {
                 list_for_each_safe(ptmp, pnxt,
                                    &ksocknal_data.ksnd_peers[i]) {
-                        peer = list_entry(ptmp, ksock_peer_t, ksnp_list);
+                        peer = list_entry(ptmp, struct ksock_peer, ksnp_list);
 
                         if (!((id.nid == LNET_NID_ANY || id.nid == peer->ksnp_id.nid) &&
                               (id.pid == LNET_PID_ANY || id.pid == peer->ksnp_id.pid)))
@@ -1844,7 +1840,7 @@ ksocknal_query(lnet_ni_t *ni, lnet_nid_t nid, unsigned long *when)
         int connect = 1;
         unsigned long last_alive = 0;
         unsigned long now = cfs_time_current();
-        ksock_peer_t *peer = NULL;
+        struct ksock_peer *peer = NULL;
         rwlock_t *glock = &ksocknal_data.ksnd_global_lock;
         lnet_process_id_t id = {
                 .nid = nid,
@@ -1856,11 +1852,11 @@ ksocknal_query(lnet_ni_t *ni, lnet_nid_t nid, unsigned long *when)
         peer = ksocknal_find_peer_locked(ni, id);
         if (peer) {
                 struct list_head *tmp;
-                ksock_conn_t *conn;
+                struct ksock_conn *conn;
                 int bufnob;
 
                 list_for_each(tmp, &peer->ksnp_conns) {
-                        conn = list_entry(tmp, ksock_conn_t, ksnc_list);
+                        conn = list_entry(tmp, struct ksock_conn, ksnc_list);
                         bufnob = conn->ksnc_sock->sk->sk_wmem_queued;
 
                         if (bufnob < conn->ksnc_tx_bufnob) {
@@ -1902,12 +1898,12 @@ ksocknal_query(lnet_ni_t *ni, lnet_nid_t nid, unsigned long *when)
 }
 
 static void
-ksocknal_push_peer(ksock_peer_t *peer)
+ksocknal_push_peer(struct ksock_peer *peer)
 {
         int index;
         int i;
         struct list_head *tmp;
-        ksock_conn_t *conn;
+        struct ksock_conn *conn;
 
         for (index = 0; ; index++) {
                 read_lock(&ksocknal_data.ksnd_global_lock);
@@ -1917,7 +1913,7 @@ ksocknal_push_peer(ksock_peer_t *peer)
 
                 list_for_each(tmp, &peer->ksnp_conns) {
                         if (i++ == index) {
-                                conn = list_entry(tmp, ksock_conn_t,
+                                conn = list_entry(tmp, struct ksock_conn,
                                                   ksnc_list);
                                 ksocknal_conn_addref(conn);
                                 break;
@@ -1954,7 +1950,7 @@ static int ksocknal_push(lnet_ni_t *ni, lnet_process_id_t id)
                 int peer_off; /* searching offset in peer hash table */
 
                 for (peer_off = 0; ; peer_off++) {
-                        ksock_peer_t *peer;
+                        struct ksock_peer *peer;
                         int i = 0;
 
                         read_lock(&ksocknal_data.ksnd_global_lock);
@@ -1986,15 +1982,15 @@ static int ksocknal_push(lnet_ni_t *ni, lnet_process_id_t id)
 static int
 ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask)
 {
-        ksock_net_t *net = ni->ni_data;
-        ksock_interface_t *iface;
+        struct ksock_net *net = ni->ni_data;
+        struct ksock_interface *iface;
         int rc;
         int i;
         int j;
         struct list_head *ptmp;
-        ksock_peer_t *peer;
+        struct ksock_peer *peer;
         struct list_head *rtmp;
-        ksock_route_t *route;
+        struct ksock_route *route;
 
         if (!ipaddress || !netmask)
                 return -EINVAL;
@@ -2017,7 +2013,7 @@ ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask)
 
                 for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) {
                         list_for_each(ptmp, &ksocknal_data.ksnd_peers[i]) {
-                                peer = list_entry(ptmp, ksock_peer_t,
+                                peer = list_entry(ptmp, struct ksock_peer,
                                                   ksnp_list);
 
                                 for (j = 0; j < peer->ksnp_n_passive_ips; j++)
@@ -2025,7 +2021,7 @@ ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask)
                                                 iface->ksni_npeers++;
 
                                 list_for_each(rtmp, &peer->ksnp_routes) {
-                                        route = list_entry(rtmp, ksock_route_t,
+                                        route = list_entry(rtmp, struct ksock_route,
                                                            ksnr_list);
 
                                         if (route->ksnr_myipaddr == ipaddress)
@@ -2044,12 +2040,12 @@ ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask)
 }
 
 static void
-ksocknal_peer_del_interface_locked(ksock_peer_t *peer, __u32 ipaddr)
+ksocknal_peer_del_interface_locked(struct ksock_peer *peer, __u32 ipaddr)
 {
         struct list_head *tmp;
         struct list_head *nxt;
-        ksock_route_t *route;
-        ksock_conn_t *conn;
+        struct ksock_route *route;
+        struct ksock_conn *conn;
         int i;
         int j;
 
@@ -2063,7 +2059,7 @@ ksocknal_peer_del_interface_locked(ksock_peer_t *peer, __u32 ipaddr)
                 }
 
         list_for_each_safe(tmp, nxt, &peer->ksnp_routes) {
-                route = list_entry(tmp, ksock_route_t, ksnr_list);
+                route = list_entry(tmp, struct ksock_route, ksnr_list);
 
                 if (route->ksnr_myipaddr != ipaddr)
                         continue;
@@ -2077,7 +2073,7 @@ ksocknal_peer_del_interface_locked(ksock_peer_t *peer, __u32 ipaddr)
         }
 
         list_for_each_safe(tmp, nxt, &peer->ksnp_conns) {
-                conn = list_entry(tmp, ksock_conn_t, ksnc_list);
+                conn = list_entry(tmp, struct ksock_conn, ksnc_list);
 
                 if (conn->ksnc_myipaddr == ipaddr)
                         ksocknal_close_conn_locked(conn, 0);
@@ -2087,11 +2083,11 @@ ksocknal_peer_del_interface_locked(ksock_peer_t *peer, __u32 ipaddr)
 static int
 ksocknal_del_interface(lnet_ni_t *ni, __u32 ipaddress)
 {
-        ksock_net_t *net = ni->ni_data;
+        struct ksock_net *net = ni->ni_data;
         int rc = -ENOENT;
         struct list_head *tmp;
         struct list_head *nxt;
-        ksock_peer_t *peer;
+        struct ksock_peer *peer;
         __u32 this_ip;
         int i;
         int j;
@@ -2115,7 +2111,7 @@ ksocknal_del_interface(lnet_ni_t *ni, __u32 ipaddress)
                 for (j = 0; j < ksocknal_data.ksnd_peer_hash_size; j++) {
                         list_for_each_safe(tmp, nxt,
                                            &ksocknal_data.ksnd_peers[j]) {
-                                peer = list_entry(tmp, ksock_peer_t, ksnp_list);
+                                peer = list_entry(tmp, struct ksock_peer, ksnp_list);
 
                                 if (peer->ksnp_ni != ni)
                                         continue;
@@ -2139,8 +2135,8 @@ ksocknal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
 
         switch (cmd) {
         case IOC_LIBCFS_GET_INTERFACE: {
-                ksock_net_t       *net = ni->ni_data;
-                ksock_interface_t *iface;
+                struct ksock_net       *net = ni->ni_data;
+                struct ksock_interface *iface;
 
                 read_lock(&ksocknal_data.ksnd_global_lock);
 
@@ -2209,7 +2205,7 @@ ksocknal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
                 int txmem;
                 int rxmem;
                 int nagle;
-                ksock_conn_t *conn = ksocknal_get_conn_by_idx(ni, data->ioc_count);
+                struct ksock_conn *conn = ksocknal_get_conn_by_idx(ni, data->ioc_count);
 
                 if (!conn)
                         return -ENOENT;
@@ -2284,8 +2280,8 @@ ksocknal_free_buffers(void)
 
         if (!list_empty(&ksocknal_data.ksnd_idle_noop_txs)) {
                 struct list_head zlist;
-                ksock_tx_t *tx;
-                ksock_tx_t *temp;
+                struct ksock_tx *tx;
+                struct ksock_tx *temp;
 
                 list_add(&zlist, &ksocknal_data.ksnd_idle_noop_txs);
                 list_del_init(&ksocknal_data.ksnd_idle_noop_txs);
@@ -2304,7 +2300,7 @@ static void
 ksocknal_base_shutdown(void)
 {
         struct ksock_sched_info *info;
-        ksock_sched_t *sched;
+        struct ksock_sched *sched;
         int i;
         int j;
 
@@ -2446,7 +2442,7 @@ ksocknal_base_startup(void)
                 goto failed;
 
         cfs_percpt_for_each(info, i, ksocknal_data.ksnd_sched_info) {
-                ksock_sched_t *sched;
+                struct ksock_sched *sched;
                 int nthrs;
 
                 nthrs = cfs_cpt_weight(lnet_cpt_table(), i);
@@ -2534,7 +2530,7 @@ ksocknal_base_startup(void)
 static void
 ksocknal_debug_peerhash(lnet_ni_t *ni)
 {
-        ksock_peer_t *peer = NULL;
+        struct ksock_peer *peer = NULL;
         struct list_head *tmp;
         int i;
 
@@ -2542,7 +2538,7 @@ ksocknal_debug_peerhash(lnet_ni_t *ni)
 
         for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) {
                 list_for_each(tmp, &ksocknal_data.ksnd_peers[i]) {
-                        peer = list_entry(tmp, ksock_peer_t, ksnp_list);
+                        peer = list_entry(tmp, struct ksock_peer, ksnp_list);
 
                         if (peer->ksnp_ni == ni)
                                 break;
@@ -2552,8 +2548,8 @@ ksocknal_debug_peerhash(lnet_ni_t *ni)
         }
 
         if (peer) {
-                ksock_route_t *route;
-                ksock_conn_t  *conn;
+                struct ksock_route *route;
+                struct ksock_conn  *conn;
 
                 CWARN("Active peer on shutdown: %s, ref %d, scnt %d, closing %d, accepting %d, err %d, zcookie %llu, txq %d, zc_req %d\n",
                       libcfs_id2str(peer->ksnp_id),
@@ -2565,7 +2561,7 @@ ksocknal_debug_peerhash(lnet_ni_t *ni)
                       !list_empty(&peer->ksnp_zc_req_list));
 
                 list_for_each(tmp, &peer->ksnp_routes) {
-                        route = list_entry(tmp, ksock_route_t, ksnr_list);
+                        route = list_entry(tmp, struct ksock_route, ksnr_list);
                         CWARN("Route: ref %d, schd %d, conn %d, cnted %d, del %d\n",
                               atomic_read(&route->ksnr_refcount),
                               route->ksnr_scheduled, route->ksnr_connecting,
@@ -2573,7 +2569,7 @@ ksocknal_debug_peerhash(lnet_ni_t *ni)
                 }
 
                 list_for_each(tmp, &peer->ksnp_conns) {
-                        conn = list_entry(tmp, ksock_conn_t, ksnc_list);
+                        conn = list_entry(tmp, struct ksock_conn, ksnc_list);
                         CWARN("Conn: ref %d, sref %d, t %d, c %d\n",
                               atomic_read(&conn->ksnc_conn_refcount),
                               atomic_read(&conn->ksnc_sock_refcount),
@@ -2587,7 +2583,7 @@ ksocknal_debug_peerhash(lnet_ni_t *ni)
 void
 ksocknal_shutdown(lnet_ni_t *ni)
 {
-        ksock_net_t *net = ni->ni_data;
+        struct ksock_net *net = ni->ni_data;
         int i;
         lnet_process_id_t anyid = {0};
 
@@ -2637,7 +2633,7 @@ ksocknal_shutdown(lnet_ni_t *ni)
 }
 
 static int
-ksocknal_enumerate_interfaces(ksock_net_t *net)
+ksocknal_enumerate_interfaces(struct ksock_net *net)
 {
         char **names;
         int i;
@@ -2694,7 +2690,7 @@ ksocknal_enumerate_interfaces(ksock_net_t *net)
 }
 
 static int
-ksocknal_search_new_ipif(ksock_net_t *net)
+ksocknal_search_new_ipif(struct ksock_net *net)
 {
         int new_ipif = 0;
         int i;
@@ -2703,7 +2699,7 @@ ksocknal_search_new_ipif(ksock_net_t *net)
                 char *ifnam = &net->ksnn_interfaces[i].ksni_name[0];
                 char *colon = strchr(ifnam, ':');
                 int found  = 0;
-                ksock_net_t *tmp;
+                struct ksock_net *tmp;
                 int j;
 
                 if (colon) /* ignore alias device */
@@ -2760,7 +2756,7 @@ ksocknal_start_schedulers(struct ksock_sched_info *info)
         for (i = 0; i < nthrs; i++) {
                 long id;
                 char name[20];
-                ksock_sched_t *sched;
+                struct ksock_sched *sched;
 
                 id = KSOCK_THREAD_ID(info->ksi_cpt, info->ksi_nthreads + i);
                 sched = &info->ksi_scheds[KSOCK_THREAD_SID(id)];
@@ -2782,7 +2778,7 @@ ksocknal_start_schedulers(struct ksock_sched_info *info)
 }
 
 static int
-ksocknal_net_start_threads(ksock_net_t *net, __u32 *cpts, int ncpts)
+ksocknal_net_start_threads(struct ksock_net *net, __u32 *cpts, int ncpts)
 {
         int newif = ksocknal_search_new_ipif(net);
         int rc;
@@ -2810,7 +2806,7 @@ ksocknal_net_start_threads(ksock_net_t *net, __u32 *cpts, int ncpts)
 int
 ksocknal_startup(lnet_ni_t *ni)
 {
-        ksock_net_t *net;
+        struct ksock_net *net;
         int rc;
         int i;
 
diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.h b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.h
index a60d72f9432f..a56632b4ee37 100644
--- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.h
+++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.h
@@ -77,8 +77,7 @@
 
 struct ksock_sched_info;
 
-typedef struct                            /* per scheduler state */
-{
+struct ksock_sched {                            /* per scheduler state */
         spinlock_t              kss_lock;       /* serialise */
         struct list_head        kss_rx_conns;   /* conn waiting to be read */
         struct list_head        kss_tx_conns;   /* conn waiting to be written */
@@ -89,13 +88,13 @@ typedef struct				  /* per scheduler state */
         struct ksock_sched_info *kss_info;      /* owner of it */
         struct page             *kss_rx_scratch_pgs[LNET_MAX_IOV];
         struct kvec             kss_scratch_iov[LNET_MAX_IOV];
-} ksock_sched_t;
+};
 
 struct ksock_sched_info {
         int                     ksi_nthreads_max; /* max allowed threads */
         int                     ksi_nthreads;     /* number of threads */
         int                     ksi_cpt;          /* CPT id */
-        ksock_sched_t           *ksi_scheds;      /* array of schedulers */
+        struct ksock_sched      *ksi_scheds;      /* array of schedulers */
 };
 
 #define KSOCK_CPT_SHIFT           16
@@ -103,16 +102,15 @@ struct ksock_sched_info {
 #define KSOCK_THREAD_CPT(id)      ((id) >> KSOCK_CPT_SHIFT)
 #define KSOCK_THREAD_SID(id)      ((id) & ((1UL << KSOCK_CPT_SHIFT) - 1))
 
-typedef struct                                  /* in-use interface */
-{
+struct ksock_interface {                        /* in-use interface */
         __u32           ksni_ipaddr;            /* interface's IP address */
         __u32           ksni_netmask;           /* interface's network mask */
         int             ksni_nroutes;           /* # routes using (active) */
         int             ksni_npeers;            /* # peers using (passive) */
         char            ksni_name[IFNAMSIZ];    /* interface name */
-} ksock_interface_t;
+};
 
-typedef struct {
+struct ksock_tunables {
         int          *ksnd_timeout;            /* "stuck" socket timeout
                                                 * (seconds) */
         int          *ksnd_nscheds;            /* # scheduler threads in each
@@ -155,24 +153,24 @@ typedef struct {
                                                 * Chelsio TOE) */
         int          *ksnd_zc_recv_min_nfrags; /* minimum # of fragments to
                                                 * enable ZC receive */
-} ksock_tunables_t;
+};
 
-typedef struct {
+struct ksock_net {
         __u64             ksnn_incarnation;     /* my epoch */
         spinlock_t        ksnn_lock;            /* serialise */
         struct list_head          ksnn_list;            /* chain on global list */
         int               ksnn_npeers;          /* # peers */
         int               ksnn_shutdown;        /* shutting down? */
         int               ksnn_ninterfaces;     /* IP interfaces */
-        ksock_interface_t ksnn_interfaces[LNET_MAX_INTERFACES];
-} ksock_net_t;
+        struct ksock_interface ksnn_interfaces[LNET_MAX_INTERFACES];
+};
 
 /** connd timeout */
 #define SOCKNAL_CONND_TIMEOUT  120
 /** reserved thread for accepting & creating new connd */
 #define SOCKNAL_CONND_RESV     1
 
-typedef struct {
+struct ksock_nal_data {
         int                     ksnd_init;              /* initialisation state
                                                          */
         int                     ksnd_nnets;             /* # networks set up */
@@ -229,7 +227,7 @@ typedef struct {
         spinlock_t              ksnd_tx_lock;           /* serialise, g_lock
                                                          * unsafe */
 
-} ksock_nal_data_t;
+};
 
 #define SOCKNAL_INIT_NOTHING 0
 #define SOCKNAL_INIT_DATA    1
@@ -250,8 +248,7 @@ struct ksock_peer;  /* forward ref */
 struct ksock_route; /* forward ref */
 struct ksock_proto; /* forward ref */
 
-typedef struct                             /* transmit packet */
-{
+struct ksock_tx {                          /* transmit packet */
         struct list_head  tx_list;         /* queue on conn for transmission etc
                                             */
         struct list_head  tx_zc_list;      /* queue on peer for ZC request */
@@ -281,20 +278,20 @@ typedef struct                             /* transmit packet */
                         struct kvec iov[1];  /* virt hdr + payload */
                 } virt;
         } tx_frags;
-} ksock_tx_t;
+};
 
-#define KSOCK_NOOP_TX_SIZE (offsetof(ksock_tx_t, tx_frags.paged.kiov[0]))
+#define KSOCK_NOOP_TX_SIZE (offsetof(struct ksock_tx, tx_frags.paged.kiov[0]))
 
-/* network zero copy callback descriptor embedded in ksock_tx_t */
+/* network zero copy callback descriptor embedded in struct ksock_tx */
 
 /*
  * space for the rx frag descriptors; we either read a single contiguous
  * header, or up to LNET_MAX_IOV frags of payload of either type.
  */
-typedef union {
+union ksock_rxiovspace {
         struct kvec      iov[LNET_MAX_IOV];
         lnet_kiov_t      kiov[LNET_MAX_IOV];
-} ksock_rxiovspace_t;
+};
 
 #define SOCKNAL_RX_KSM_HEADER   1 /* reading ksock message header */
 #define SOCKNAL_RX_LNET_HEADER  2 /* reading lnet message header */
@@ -303,7 +300,7 @@ typedef union {
 #define SOCKNAL_RX_LNET_PAYLOAD 5 /* reading lnet payload (to deliver here) */
 #define SOCKNAL_RX_SLOP         6 /* skipping body */
 
-typedef struct ksock_conn {
+struct ksock_conn {
         struct ksock_peer  *ksnc_peer;        /* owning peer */
         struct ksock_route *ksnc_route;       /* owning route */
         struct list_head   ksnc_list;         /* stash on peer's conn list */
@@ -314,8 +311,8 @@ typedef struct ksock_conn {
                                                      * write_space() callback */
         atomic_t           ksnc_conn_refcount;/* conn refcount */
         atomic_t           ksnc_sock_refcount;/* sock refcount */
-        ksock_sched_t      *ksnc_scheduler;   /* who schedules this connection
-                                               */
+        struct ksock_sched *ksnc_scheduler;     /* who schedules this connection
+                                                 */
         __u32              ksnc_myipaddr;     /* my IP */
         __u32              ksnc_ipaddr;       /* peer's IP */
         int                ksnc_port;         /* peer's port */
@@ -341,7 +338,7 @@ typedef struct ksock_conn {
         struct kvec        *ksnc_rx_iov;      /* the iovec frags */
         int                ksnc_rx_nkiov;     /* # page frags */
         lnet_kiov_t        *ksnc_rx_kiov;     /* the page frags */
-        ksock_rxiovspace_t ksnc_rx_iov_space; /* space for frag descriptors */
+        union ksock_rxiovspace ksnc_rx_iov_space; /* space for frag descriptors */
         __u32              ksnc_rx_csum;      /* partial checksum for incoming
                                                * data */
         void               *ksnc_cookie;      /* rx lnet_finalize passthru arg
@@ -357,7 +354,7 @@ typedef struct ksock_conn {
         struct list_head   ksnc_tx_list;      /* where I enq waiting for output
                                                * space */
         struct list_head   ksnc_tx_queue;     /* packets waiting to be sent */
-        ksock_tx_t         *ksnc_tx_carrier;  /* next TX that can carry a LNet
+        struct ksock_tx         *ksnc_tx_carrier;  /* next TX that can carry a LNet
                                                * message or ZC-ACK */
         unsigned long      ksnc_tx_deadline;  /* when (in jiffies) tx times out
                                                */
@@ -367,9 +364,9 @@ typedef struct ksock_conn {
         int                ksnc_tx_scheduled; /* being progressed */
         unsigned long      ksnc_tx_last_post; /* time stamp of the last posted
                                                * TX */
-} ksock_conn_t;
+};
 
-typedef struct ksock_route {
+struct ksock_route {
         struct list_head  ksnr_list;           /* chain on peer route list */
         struct list_head  ksnr_connd_list;     /* chain on ksnr_connd_routes */
         struct ksock_peer *ksnr_peer;          /* owning peer */
@@ -389,11 +386,11 @@ typedef struct ksock_route {
         unsigned int      ksnr_share_count;    /* created explicitly? */
         int               ksnr_conn_count;     /* # conns established by this
                                                 * route */
-} ksock_route_t;
+};
 
 #define SOCKNAL_KEEPALIVE_PING 1 /* cookie for keepalive ping */
 
-typedef struct ksock_peer {
+struct ksock_peer {
         struct list_head   ksnp_list;           /* stash on global peer list */
         unsigned long      ksnp_last_alive;     /* when (in jiffies) I was last
                                                  * alive */
@@ -420,49 +417,49 @@ typedef struct ksock_peer {
 
         /* preferred local interfaces */
         __u32              ksnp_passive_ips[LNET_MAX_INTERFACES];
-} ksock_peer_t;
+};
 
-typedef struct ksock_connreq {
+struct ksock_connreq {
         struct list_head ksncr_list;  /* stash on ksnd_connd_connreqs */
         lnet_ni_t        *ksncr_ni;   /* chosen NI */
         struct socket    *ksncr_sock; /* accepted socket */
-} ksock_connreq_t;
+};
 
-extern ksock_nal_data_t ksocknal_data;
-extern ksock_tunables_t ksocknal_tunables;
+extern struct ksock_nal_data ksocknal_data;
+extern struct ksock_tunables ksocknal_tunables;
 
 #define SOCKNAL_MATCH_NO  0 /* TX can't match type of connection */
 #define SOCKNAL_MATCH_YES 1 /* TX matches type of connection */
 #define SOCKNAL_MATCH_MAY 2 /* TX can be sent on the connection, but not
                              * preferred */
 
-typedef struct ksock_proto {
+struct ksock_proto {
         /* version number of protocol */
         int        pro_version;
 
         /* handshake function */
-        int        (*pro_send_hello)(ksock_conn_t *, ksock_hello_msg_t *);
+        int        (*pro_send_hello)(struct ksock_conn *, ksock_hello_msg_t *);
 
         /* handshake function */
-        int        (*pro_recv_hello)(ksock_conn_t *, ksock_hello_msg_t *, int);
+        int        (*pro_recv_hello)(struct ksock_conn *, ksock_hello_msg_t *, int);
 
         /* message pack */
-        void       (*pro_pack)(ksock_tx_t *);
+        void       (*pro_pack)(struct ksock_tx *);
 
         /* message unpack */
         void       (*pro_unpack)(ksock_msg_t *);
 
         /* queue tx on the connection */
-        ksock_tx_t *(*pro_queue_tx_msg)(ksock_conn_t *, ksock_tx_t *);
+        struct ksock_tx *(*pro_queue_tx_msg)(struct ksock_conn *, struct ksock_tx *);
 
         /* queue ZC ack on the connection */
-        int        (*pro_queue_tx_zcack)(ksock_conn_t *, ksock_tx_t *, __u64);
+        int        (*pro_queue_tx_zcack)(struct ksock_conn *, struct ksock_tx *, __u64);
 
         /* handle ZC request */
-        int        (*pro_handle_zcreq)(ksock_conn_t *, __u64, int);
+        int        (*pro_handle_zcreq)(struct ksock_conn *, __u64, int);
 
         /* handle ZC ACK */
-        int        (*pro_handle_zcack)(ksock_conn_t *, __u64, __u64);
+        int        (*pro_handle_zcack)(struct ksock_conn *, __u64, __u64);
 
         /*
          * msg type matches the connection type:
@@ -471,12 +468,12 @@ typedef struct ksock_proto {
          *   return MATCH_YES : matching type
          *   return MATCH_MAY : can be backup
          */
-        int        (*pro_match_tx)(ksock_conn_t *, ksock_tx_t *, int);
-} ksock_proto_t;
+        int        (*pro_match_tx)(struct ksock_conn *, struct ksock_tx *, int);
+};
 
-extern ksock_proto_t ksocknal_protocol_v1x;
-extern ksock_proto_t ksocknal_protocol_v2x;
-extern ksock_proto_t ksocknal_protocol_v3x;
+extern struct ksock_proto ksocknal_protocol_v1x;
+extern struct ksock_proto ksocknal_protocol_v2x;
+extern struct ksock_proto ksocknal_protocol_v3x;
 
 #define KSOCK_PROTO_V1_MAJOR LNET_PROTO_TCP_VERSION_MAJOR
 #define KSOCK_PROTO_V1_MINOR LNET_PROTO_TCP_VERSION_MINOR
@@ -517,17 +514,17 @@ ksocknal_nid2peerlist(lnet_nid_t nid)
 }
 
 static inline void
-ksocknal_conn_addref(ksock_conn_t *conn)
+ksocknal_conn_addref(struct ksock_conn *conn)
 {
         LASSERT(atomic_read(&conn->ksnc_conn_refcount) > 0);
         atomic_inc(&conn->ksnc_conn_refcount);
 }
 
-void ksocknal_queue_zombie_conn(ksock_conn_t *conn);
-void ksocknal_finalize_zcreq(ksock_conn_t *conn);
+void ksocknal_queue_zombie_conn(struct ksock_conn *conn);
+void ksocknal_finalize_zcreq(struct ksock_conn *conn);
 
 static inline void
-ksocknal_conn_decref(ksock_conn_t *conn)
+ksocknal_conn_decref(struct ksock_conn *conn)
 {
         LASSERT(atomic_read(&conn->ksnc_conn_refcount) > 0);
         if (atomic_dec_and_test(&conn->ksnc_conn_refcount))
@@ -535,7 +532,7 @@ ksocknal_conn_decref(ksock_conn_t *conn)
 }
 
 static inline int
-ksocknal_connsock_addref(ksock_conn_t *conn)
+ksocknal_connsock_addref(struct ksock_conn *conn)
 {
         int rc = -ESHUTDOWN;
 
@@ -551,7 +548,7 @@ ksocknal_connsock_addref(ksock_conn_t *conn)
 }
 
 static inline void
-ksocknal_connsock_decref(ksock_conn_t *conn)
+ksocknal_connsock_decref(struct ksock_conn *conn)
 {
         LASSERT(atomic_read(&conn->ksnc_sock_refcount) > 0);
         if (atomic_dec_and_test(&conn->ksnc_sock_refcount)) {
@@ -563,17 +560,17 @@ ksocknal_connsock_decref(ksock_conn_t *conn)
 }
 
 static inline void
-ksocknal_tx_addref(ksock_tx_t *tx)
+ksocknal_tx_addref(struct ksock_tx *tx)
 {
         LASSERT(atomic_read(&tx->tx_refcount) > 0);
         atomic_inc(&tx->tx_refcount);
 }
 
-void ksocknal_tx_prep(ksock_conn_t *, ksock_tx_t *tx);
-void ksocknal_tx_done(lnet_ni_t *ni, ksock_tx_t *tx);
+void ksocknal_tx_prep(struct ksock_conn *, struct ksock_tx *tx);
+void ksocknal_tx_done(lnet_ni_t *ni, struct ksock_tx *tx);
 
 static inline void
-ksocknal_tx_decref(ksock_tx_t *tx)
+ksocknal_tx_decref(struct ksock_tx *tx)
 {
         LASSERT(atomic_read(&tx->tx_refcount) > 0);
         if (atomic_dec_and_test(&tx->tx_refcount))
@@ -581,16 +578,16 @@ ksocknal_tx_decref(ksock_tx_t *tx)
 }
 
 static inline void
-ksocknal_route_addref(ksock_route_t *route)
+ksocknal_route_addref(struct ksock_route *route)
 {
         LASSERT(atomic_read(&route->ksnr_refcount) > 0);
         atomic_inc(&route->ksnr_refcount);
 }
 
-void ksocknal_destroy_route(ksock_route_t *route);
+void ksocknal_destroy_route(struct ksock_route *route);
 
 static inline void
-ksocknal_route_decref(ksock_route_t *route)
+ksocknal_route_decref(struct ksock_route *route)
 {
         LASSERT(atomic_read(&route->ksnr_refcount) > 0);
         if (atomic_dec_and_test(&route->ksnr_refcount))
@@ -598,16 +595,16 @@ ksocknal_route_decref(ksock_route_t *route)
 }
 
 static inline void
-ksocknal_peer_addref(ksock_peer_t *peer)
+ksocknal_peer_addref(struct ksock_peer *peer)
 {
         LASSERT(atomic_read(&peer->ksnp_refcount) > 0);
         atomic_inc(&peer->ksnp_refcount);
 }
 
-void ksocknal_destroy_peer(ksock_peer_t *peer);
+void ksocknal_destroy_peer(struct ksock_peer *peer);
 
 static inline void
-ksocknal_peer_decref(ksock_peer_t *peer)
+ksocknal_peer_decref(struct ksock_peer *peer)
 {
         LASSERT(atomic_read(&peer->ksnp_refcount) > 0);
         if (atomic_dec_and_test(&peer->ksnp_refcount))
@@ -625,71 +622,71 @@ int ksocknal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
 int ksocknal_accept(lnet_ni_t *ni, struct socket *sock);
 
 int ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ip, int port);
-ksock_peer_t *ksocknal_find_peer_locked(lnet_ni_t *ni, lnet_process_id_t id);
-ksock_peer_t *ksocknal_find_peer(lnet_ni_t *ni, lnet_process_id_t id);
-void ksocknal_peer_failed(ksock_peer_t *peer);
-int ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route,
+struct ksock_peer *ksocknal_find_peer_locked(lnet_ni_t *ni, lnet_process_id_t id);
+struct ksock_peer *ksocknal_find_peer(lnet_ni_t *ni, lnet_process_id_t id);
+void ksocknal_peer_failed(struct ksock_peer *peer);
+int ksocknal_create_conn(lnet_ni_t *ni, struct ksock_route *route,
                          struct socket *sock, int type);
-void ksocknal_close_conn_locked(ksock_conn_t *conn, int why);
-void ksocknal_terminate_conn(ksock_conn_t *conn);
-void ksocknal_destroy_conn(ksock_conn_t *conn);
-int  ksocknal_close_peer_conns_locked(ksock_peer_t *peer,
+void ksocknal_close_conn_locked(struct ksock_conn *conn, int why);
+void ksocknal_terminate_conn(struct ksock_conn *conn);
+void ksocknal_destroy_conn(struct ksock_conn *conn);
+int  ksocknal_close_peer_conns_locked(struct ksock_peer *peer,
                                       __u32 ipaddr, int why);
-int ksocknal_close_conn_and_siblings(ksock_conn_t *conn, int why);
+int ksocknal_close_conn_and_siblings(struct ksock_conn *conn, int why);
 int ksocknal_close_matching_conns(lnet_process_id_t id, __u32 ipaddr);
-ksock_conn_t *ksocknal_find_conn_locked(ksock_peer_t *peer,
-                                        ksock_tx_t *tx, int nonblk);
+struct ksock_conn *ksocknal_find_conn_locked(struct ksock_peer *peer,
+                                        struct ksock_tx *tx, int nonblk);
 
-int  ksocknal_launch_packet(lnet_ni_t *ni, ksock_tx_t *tx,
+int  ksocknal_launch_packet(lnet_ni_t *ni, struct ksock_tx *tx,
                             lnet_process_id_t id);
-ksock_tx_t *ksocknal_alloc_tx(int type, int size);
-void ksocknal_free_tx(ksock_tx_t *tx);
-ksock_tx_t *ksocknal_alloc_tx_noop(__u64 cookie, int nonblk);
-void ksocknal_next_tx_carrier(ksock_conn_t *conn);
-void ksocknal_queue_tx_locked(ksock_tx_t *tx, ksock_conn_t *conn);
+struct ksock_tx *ksocknal_alloc_tx(int type, int size);
+void ksocknal_free_tx(struct ksock_tx *tx);
+struct ksock_tx *ksocknal_alloc_tx_noop(__u64 cookie, int nonblk);
+void ksocknal_next_tx_carrier(struct ksock_conn *conn);
+void ksocknal_queue_tx_locked(struct ksock_tx *tx, struct ksock_conn *conn);
 void ksocknal_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int error);
 void ksocknal_notify(lnet_ni_t *ni, lnet_nid_t gw_nid, int alive);
 void ksocknal_query(struct lnet_ni *ni, lnet_nid_t nid, unsigned long *when);
 int ksocknal_thread_start(int (*fn)(void *arg), void *arg, char *name);
 void ksocknal_thread_fini(void);
-void ksocknal_launch_all_connections_locked(ksock_peer_t *peer);
-ksock_route_t *ksocknal_find_connectable_route_locked(ksock_peer_t *peer);
-ksock_route_t *ksocknal_find_connecting_route_locked(ksock_peer_t *peer);
-int ksocknal_new_packet(ksock_conn_t *conn, int skip);
+void ksocknal_launch_all_connections_locked(struct ksock_peer *peer);
+struct ksock_route *ksocknal_find_connectable_route_locked(struct ksock_peer *peer);
+struct ksock_route *ksocknal_find_connecting_route_locked(struct ksock_peer *peer);
+int ksocknal_new_packet(struct ksock_conn *conn, int skip);
 int ksocknal_scheduler(void *arg);
 int ksocknal_connd(void *arg);
 int ksocknal_reaper(void *arg);
-int ksocknal_send_hello(lnet_ni_t *ni, ksock_conn_t *conn,
+int ksocknal_send_hello(lnet_ni_t *ni, struct ksock_conn *conn,
                         lnet_nid_t peer_nid, ksock_hello_msg_t *hello);
-int ksocknal_recv_hello(lnet_ni_t *ni, ksock_conn_t *conn,
+int ksocknal_recv_hello(lnet_ni_t *ni, struct ksock_conn *conn,
                         ksock_hello_msg_t *hello, lnet_process_id_t *id,
                         __u64 *incarnation);
-void ksocknal_read_callback(ksock_conn_t *conn);
-void ksocknal_write_callback(ksock_conn_t *conn);
-
-int ksocknal_lib_zc_capable(ksock_conn_t *conn);
-void ksocknal_lib_save_callback(struct socket *sock, ksock_conn_t *conn);
-void ksocknal_lib_set_callback(struct socket *sock,  ksock_conn_t *conn);
-void ksocknal_lib_reset_callback(struct socket *sock, ksock_conn_t *conn);
-void ksocknal_lib_push_conn(ksock_conn_t *conn);
-int ksocknal_lib_get_conn_addrs(ksock_conn_t *conn);
+void ksocknal_read_callback(struct ksock_conn *conn);
+void ksocknal_write_callback(struct ksock_conn *conn);
+
+int ksocknal_lib_zc_capable(struct ksock_conn *conn);
+void ksocknal_lib_save_callback(struct socket *sock, struct ksock_conn *conn);
+void ksocknal_lib_set_callback(struct socket *sock,  struct ksock_conn *conn);
+void ksocknal_lib_reset_callback(struct socket *sock, struct ksock_conn *conn);
+void ksocknal_lib_push_conn(struct ksock_conn *conn);
+int ksocknal_lib_get_conn_addrs(struct ksock_conn *conn);
 int ksocknal_lib_setup_sock(struct socket *so);
-int ksocknal_lib_send_iov(ksock_conn_t *conn, ksock_tx_t *tx);
-int ksocknal_lib_send_kiov(ksock_conn_t *conn, ksock_tx_t *tx);
-void ksocknal_lib_eager_ack(ksock_conn_t *conn);
-int ksocknal_lib_recv_iov(ksock_conn_t *conn);
-int ksocknal_lib_recv_kiov(ksock_conn_t *conn);
-int ksocknal_lib_get_conn_tunables(ksock_conn_t *conn, int *txmem,
+int ksocknal_lib_send_iov(struct ksock_conn *conn, struct ksock_tx *tx);
+int ksocknal_lib_send_kiov(struct ksock_conn *conn, struct ksock_tx *tx);
+void ksocknal_lib_eager_ack(struct ksock_conn *conn);
+int ksocknal_lib_recv_iov(struct ksock_conn *conn);
+int ksocknal_lib_recv_kiov(struct ksock_conn *conn);
+int ksocknal_lib_get_conn_tunables(struct ksock_conn *conn, int *txmem,
                                    int *rxmem, int *nagle);
 
-void ksocknal_read_callback(ksock_conn_t *conn);
-void ksocknal_write_callback(ksock_conn_t *conn);
+void ksocknal_read_callback(struct ksock_conn *conn);
+void ksocknal_write_callback(struct ksock_conn *conn);
 
 int ksocknal_tunables_init(void);
 
-void ksocknal_lib_csum_tx(ksock_tx_t *tx);
+void ksocknal_lib_csum_tx(struct ksock_tx *tx);
 
-int ksocknal_lib_memory_pressure(ksock_conn_t *conn);
+int ksocknal_lib_memory_pressure(struct ksock_conn *conn);
 int ksocknal_lib_bind_thread_to_cpu(int id);
 
 #endif /* _SOCKLND_SOCKLND_H_ */
diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c
index 976fd78926e0..303576d815c6 100644
--- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c
+++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c
@@ -23,10 +23,10 @@
 
 #include "socklnd.h"
 
-ksock_tx_t *
+struct ksock_tx *
 ksocknal_alloc_tx(int type, int size)
 {
-        ksock_tx_t *tx = NULL;
+        struct ksock_tx *tx = NULL;
 
         if (type == KSOCK_MSG_NOOP) {
                 LASSERT(size == KSOCK_NOOP_TX_SIZE);
@@ -36,7 +36,7 @@ ksocknal_alloc_tx(int type, int size)
 
                 if (!list_empty(&ksocknal_data.ksnd_idle_noop_txs)) {
                         tx = list_entry(ksocknal_data.ksnd_idle_noop_txs. \
-                                            next, ksock_tx_t, tx_list);
+                                            next, struct ksock_tx, tx_list);
                         LASSERT(tx->tx_desc_size == size);
                         list_del(&tx->tx_list);
                 }
@@ -61,10 +61,10 @@ ksocknal_alloc_tx(int type, int size)
         return tx;
 }
 
-ksock_tx_t *
+struct ksock_tx *
 ksocknal_alloc_tx_noop(__u64 cookie, int nonblk)
 {
-        ksock_tx_t *tx;
+        struct ksock_tx *tx;
 
         tx = ksocknal_alloc_tx(KSOCK_MSG_NOOP, KSOCK_NOOP_TX_SIZE);
         if (!tx) {
@@ -87,7 +87,7 @@ ksocknal_alloc_tx_noop(__u64 cookie, int nonblk)
 }
 
 void
-ksocknal_free_tx(ksock_tx_t *tx)
+ksocknal_free_tx(struct ksock_tx *tx)
 {
         atomic_dec(&ksocknal_data.ksnd_nactive_txs);
 
@@ -104,7 +104,7 @@ ksocknal_free_tx(ksock_tx_t *tx)
 }
 
 static int
-ksocknal_send_iov(ksock_conn_t *conn, ksock_tx_t *tx)
+ksocknal_send_iov(struct ksock_conn *conn, struct ksock_tx *tx)
 {
         struct kvec *iov = tx->tx_iov;
         int nob;
@@ -126,7 +126,7 @@ ksocknal_send_iov(ksock_conn_t *conn, ksock_tx_t *tx)
         do {
                 LASSERT(tx->tx_niov > 0);
 
-                if (nob < (int) iov->iov_len) {
+                if (nob < (int)iov->iov_len) {
                         iov->iov_base = (void *)((char *)iov->iov_base + nob);
                         iov->iov_len -= nob;
                         return rc;
@@ -141,7 +141,7 @@ ksocknal_send_iov(ksock_conn_t *conn, ksock_tx_t *tx)
 }
 
 static int
-ksocknal_send_kiov(ksock_conn_t *conn, ksock_tx_t *tx)
+ksocknal_send_kiov(struct ksock_conn *conn, struct ksock_tx *tx)
 {
         lnet_kiov_t *kiov = tx->tx_kiov;
         int nob;
@@ -179,7 +179,7 @@ ksocknal_send_kiov(ksock_conn_t *conn, ksock_tx_t *tx)
 }
 
 static int
-ksocknal_transmit(ksock_conn_t *conn, ksock_tx_t *tx)
+ksocknal_transmit(struct ksock_conn *conn, struct ksock_tx *tx)
 {
         int rc;
         int bufnob;
@@ -247,7 +247,7 @@ ksocknal_transmit(ksock_conn_t *conn, ksock_tx_t *tx)
 }
 
 static int
-ksocknal_recv_iov(ksock_conn_t *conn)
+ksocknal_recv_iov(struct ksock_conn *conn)
 {
         struct kvec *iov = conn->ksnc_rx_iov;
         int nob;
@@ -294,7 +294,7 @@ ksocknal_recv_iov(ksock_conn_t *conn)
 }
 
 static int
-ksocknal_recv_kiov(ksock_conn_t *conn)
+ksocknal_recv_kiov(struct ksock_conn *conn)
 {
         lnet_kiov_t *kiov = conn->ksnc_rx_kiov;
         int nob;
@@ -326,7 +326,7 @@ ksocknal_recv_kiov(ksock_conn_t *conn)
         do {
                 LASSERT(conn->ksnc_rx_nkiov > 0);
 
-                if (nob < (int) kiov->kiov_len) {
+                if (nob < (int)kiov->kiov_len) {
                         kiov->kiov_offset += nob;
                         kiov->kiov_len -= nob;
                         return -EAGAIN;
@@ -341,7 +341,7 @@ ksocknal_recv_kiov(ksock_conn_t *conn)
 }
 
 static int
-ksocknal_receive(ksock_conn_t *conn)
+ksocknal_receive(struct ksock_conn *conn)
 {
         /*
          * Return 1 on success, 0 on EOF, < 0 on error.
@@ -391,7 +391,7 @@ ksocknal_receive(ksock_conn_t *conn)
 }
 
 void
-ksocknal_tx_done(lnet_ni_t *ni, ksock_tx_t *tx)
+ksocknal_tx_done(lnet_ni_t *ni, struct ksock_tx *tx)
 {
         lnet_msg_t *lnetmsg = tx->tx_lnetmsg;
         int rc = (!tx->tx_resid && !tx->tx_zc_aborted) ? 0 : -EIO;
@@ -412,10 +412,10 @@ ksocknal_tx_done(lnet_ni_t *ni, ksock_tx_t *tx)
 void
 ksocknal_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int error)
 {
-        ksock_tx_t *tx;
+        struct ksock_tx *tx;
 
         while (!list_empty(txlist)) {
-                tx = list_entry(txlist->next, ksock_tx_t, tx_list);
+                tx = list_entry(txlist->next, struct ksock_tx, tx_list);
 
                 if (error && tx->tx_lnetmsg) {
                         CNETERR("Deleting packet type %d len %d %s->%s\n",
@@ -435,10 +435,10 @@ ksocknal_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int error)
 }
 
 static void
-ksocknal_check_zc_req(ksock_tx_t *tx)
+ksocknal_check_zc_req(struct ksock_tx *tx)
 {
-        ksock_conn_t *conn = tx->tx_conn;
-        ksock_peer_t *peer = conn->ksnc_peer;
+        struct ksock_conn *conn = tx->tx_conn;
+        struct ksock_peer *peer = conn->ksnc_peer;
 
         /*
          * Set tx_msg.ksm_zc_cookies[0] to a unique non-zero cookie and add tx
@@ -482,9 +482,9 @@ ksocknal_check_zc_req(ksock_tx_t *tx)
 }
 
 static void
-ksocknal_uncheck_zc_req(ksock_tx_t *tx)
+ksocknal_uncheck_zc_req(struct ksock_tx *tx)
 {
-        ksock_peer_t *peer = tx->tx_conn->ksnc_peer;
+        struct ksock_peer *peer = tx->tx_conn->ksnc_peer;
 
         LASSERT(tx->tx_msg.ksm_type != KSOCK_MSG_NOOP);
         LASSERT(tx->tx_zc_capable);
@@ -508,7 +508,7 @@ ksocknal_uncheck_zc_req(ksock_tx_t *tx)
 }
 
 static int
-ksocknal_process_transmit(ksock_conn_t *conn, ksock_tx_t *tx)
+ksocknal_process_transmit(struct ksock_conn *conn, struct ksock_tx *tx)
 {
         int rc;
 
@@ -583,7 +583,7 @@ ksocknal_process_transmit(ksock_conn_t *conn, ksock_tx_t *tx)
 }
 
 static void
-ksocknal_launch_connection_locked(ksock_route_t *route)
+ksocknal_launch_connection_locked(struct ksock_route *route)
 {
         /* called holding write lock on ksnd_global_lock */
 
@@ -604,9 +604,9 @@ ksocknal_launch_connection_locked(ksock_route_t *route)
 }
 
 void
-ksocknal_launch_all_connections_locked(ksock_peer_t *peer)
+ksocknal_launch_all_connections_locked(struct ksock_peer *peer)
 {
-        ksock_route_t *route;
+        struct ksock_route *route;
 
         /* called holding write lock on ksnd_global_lock */
         for (;;) {
@@ -619,18 +619,18 @@ ksocknal_launch_all_connections_locked(ksock_peer_t *peer)
         }
 }
 
-ksock_conn_t *
-ksocknal_find_conn_locked(ksock_peer_t *peer, ksock_tx_t *tx, int nonblk)
+struct ksock_conn *
+ksocknal_find_conn_locked(struct ksock_peer *peer, struct ksock_tx *tx, int nonblk)
 {
         struct list_head *tmp;
-        ksock_conn_t *conn;
-        ksock_conn_t *typed = NULL;
-        ksock_conn_t *fallback = NULL;
+        struct ksock_conn *conn;
+        struct ksock_conn *typed = NULL;
+        struct ksock_conn *fallback = NULL;
         int tnob = 0;
         int fnob = 0;
 
         list_for_each(tmp, &peer->ksnp_conns) {
-                ksock_conn_t *c  = list_entry(tmp, ksock_conn_t, ksnc_list);
+                struct ksock_conn *c  = list_entry(tmp, struct ksock_conn, ksnc_list);
                 int nob = atomic_read(&c->ksnc_tx_nob) +
                         c->ksnc_sock->sk->sk_wmem_queued;
                 int rc;
@@ -677,7 +677,7 @@ ksocknal_find_conn_locked(ksock_peer_t *peer, ksock_tx_t *tx, int nonblk)
 }
 
 void
-ksocknal_tx_prep(ksock_conn_t *conn, ksock_tx_t *tx)
+ksocknal_tx_prep(struct ksock_conn *conn, struct ksock_tx *tx)
 {
         conn->ksnc_proto->pro_pack(tx);
 
@@ -687,11 +687,11 @@ ksocknal_tx_prep(ksock_conn_t *conn, ksock_tx_t *tx)
 }
 
 void
-ksocknal_queue_tx_locked(ksock_tx_t *tx, ksock_conn_t *conn)
+ksocknal_queue_tx_locked(struct ksock_tx *tx, struct ksock_conn *conn)
 {
-        ksock_sched_t *sched = conn->ksnc_scheduler;
+        struct ksock_sched *sched = conn->ksnc_scheduler;
         ksock_msg_t *msg = &tx->tx_msg;
-        ksock_tx_t *ztx = NULL;
+        struct ksock_tx *ztx = NULL;
         int bufnob = 0;
 
         /*
@@ -784,15 +784,15 @@ ksocknal_queue_tx_locked(ksock_tx_t *tx, ksock_conn_t *conn)
         spin_unlock_bh(&sched->kss_lock);
 }
 
-ksock_route_t *
-ksocknal_find_connectable_route_locked(ksock_peer_t *peer)
+struct ksock_route *
+ksocknal_find_connectable_route_locked(struct ksock_peer *peer)
 {
         unsigned long now = cfs_time_current();
         struct list_head *tmp;
-        ksock_route_t *route;
+        struct ksock_route *route;
 
         list_for_each(tmp, &peer->ksnp_routes) {
-                route = list_entry(tmp, ksock_route_t, ksnr_list);
+                route = list_entry(tmp, struct ksock_route, ksnr_list);
 
                 LASSERT(!route->ksnr_connecting || route->ksnr_scheduled);
 
@@ -820,14 +820,14 @@ ksocknal_find_connectable_route_locked(ksock_peer_t *peer)
         return NULL;
 }
 
-ksock_route_t *
-ksocknal_find_connecting_route_locked(ksock_peer_t *peer)
+struct ksock_route *
+ksocknal_find_connecting_route_locked(struct ksock_peer *peer)
 {
         struct list_head *tmp;
-        ksock_route_t *route;
+        struct ksock_route *route;
 
         list_for_each(tmp, &peer->ksnp_routes) {
-                route = list_entry(tmp, ksock_route_t, ksnr_list);
+                route = list_entry(tmp, struct ksock_route, ksnr_list);
 
                 LASSERT(!route->ksnr_connecting || route->ksnr_scheduled);
 
@@ -839,10 +839,10 @@ ksocknal_find_connecting_route_locked(ksock_peer_t *peer)
 }
 
 int
-ksocknal_launch_packet(lnet_ni_t *ni, ksock_tx_t *tx, lnet_process_id_t id)
+ksocknal_launch_packet(lnet_ni_t *ni, struct ksock_tx *tx, lnet_process_id_t id)
 {
-        ksock_peer_t *peer;
-        ksock_conn_t *conn;
+        struct ksock_peer *peer;
+        struct ksock_conn *conn;
         rwlock_t *g_lock;
         int retry;
         int rc;
@@ -942,7 +942,7 @@ ksocknal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
         lnet_kiov_t *payload_kiov = lntmsg->msg_kiov;
         unsigned int payload_offset = lntmsg->msg_offset;
         unsigned int payload_nob = lntmsg->msg_len;
-        ksock_tx_t *tx;
+        struct ksock_tx *tx;
         int desc_size;
         int rc;
 
@@ -960,10 +960,10 @@ ksocknal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
         LASSERT(!in_interrupt());
 
         if (payload_iov)
-                desc_size = offsetof(ksock_tx_t,
+                desc_size = offsetof(struct ksock_tx,
                                      tx_frags.virt.iov[1 + payload_niov]);
         else
-                desc_size = offsetof(ksock_tx_t,
+                desc_size = offsetof(struct ksock_tx,
                                      tx_frags.paged.kiov[payload_niov]);
 
         if (lntmsg->msg_vmflush)
@@ -1037,7 +1037,7 @@ ksocknal_thread_fini(void)
 }
 
 int
-ksocknal_new_packet(ksock_conn_t *conn, int nob_to_skip)
+ksocknal_new_packet(struct ksock_conn *conn, int nob_to_skip)
 {
         static char ksocknal_slop_buffer[4096];
 
@@ -1120,7 +1120,7 @@ ksocknal_new_packet(ksock_conn_t *conn, int nob_to_skip)
 }
 
 static int
-ksocknal_process_receive(ksock_conn_t *conn)
+ksocknal_process_receive(struct ksock_conn *conn)
 {
         lnet_hdr_t *lhdr;
         lnet_process_id_t *id;
@@ -1328,8 +1328,8 @@ ksocknal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
               unsigned int niov, struct kvec *iov, lnet_kiov_t *kiov,
               unsigned int offset, unsigned int mlen, unsigned int rlen)
 {
-        ksock_conn_t *conn = private;
-        ksock_sched_t *sched = conn->ksnc_scheduler;
+        struct ksock_conn *conn = private;
+        struct ksock_sched *sched = conn->ksnc_scheduler;
 
         LASSERT(mlen <= rlen);
         LASSERT(niov <= LNET_MAX_IOV);
@@ -1382,7 +1382,7 @@ ksocknal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
 }
 
 static inline int
-ksocknal_sched_cansleep(ksock_sched_t *sched)
+ksocknal_sched_cansleep(struct ksock_sched *sched)
 {
         int rc;
 
@@ -1399,9 +1399,9 @@ ksocknal_sched_cansleep(ksock_sched_t *sched)
 int ksocknal_scheduler(void *arg)
 {
         struct ksock_sched_info *info;
-        ksock_sched_t *sched;
-        ksock_conn_t *conn;
-        ksock_tx_t *tx;
+        struct ksock_sched *sched;
+        struct ksock_conn *conn;
+        struct ksock_tx *tx;
         int rc;
         int nloops = 0;
         long id = (long)arg;
@@ -1426,7 +1426,7 @@ int ksocknal_scheduler(void *arg)
 
                 if (!list_empty(&sched->kss_rx_conns)) {
                         conn = list_entry(sched->kss_rx_conns.next,
-                                          ksock_conn_t, ksnc_rx_list);
+                                          struct ksock_conn, ksnc_rx_list);
                         list_del(&conn->ksnc_rx_list);
 
                         LASSERT(conn->ksnc_rx_scheduled);
@@ -1481,7 +1481,7 @@ int ksocknal_scheduler(void *arg)
                         }
 
                         conn = list_entry(sched->kss_tx_conns.next,
-                                          ksock_conn_t, ksnc_tx_list);
+                                          struct ksock_conn, ksnc_tx_list);
                         list_del(&conn->ksnc_tx_list);
 
                         LASSERT(conn->ksnc_tx_scheduled);
@@ -1489,7 +1489,7 @@ int ksocknal_scheduler(void *arg)
                         LASSERT(!list_empty(&conn->ksnc_tx_queue));
 
                         tx = list_entry(conn->ksnc_tx_queue.next,
-                                        ksock_tx_t, tx_list);
+                                        struct ksock_tx, tx_list);
 
                         if (conn->ksnc_tx_carrier == tx)
                                 ksocknal_next_tx_carrier(conn);
@@ -1575,9 +1575,9 @@ int ksocknal_scheduler(void *arg)
  * Add connection to kss_rx_conns of scheduler
  * and wakeup the scheduler.
  */
-void ksocknal_read_callback(ksock_conn_t *conn)
+void ksocknal_read_callback(struct ksock_conn *conn)
 {
-        ksock_sched_t *sched;
+        struct ksock_sched *sched;
 
         sched = conn->ksnc_scheduler;
 
@@ -1600,9 +1600,9 @@ void ksocknal_read_callback(ksock_conn_t *conn)
  * Add connection to kss_tx_conns of scheduler
  * and wakeup the scheduler.
  */
-void ksocknal_write_callback(ksock_conn_t *conn)
+void ksocknal_write_callback(struct ksock_conn *conn)
 {
-        ksock_sched_t *sched;
+        struct ksock_sched *sched;
 
         sched = conn->ksnc_scheduler;
 
@@ -1623,7 +1623,7 @@ void ksocknal_write_callback(ksock_conn_t *conn)
         spin_unlock_bh(&sched->kss_lock);
 }
 
-static ksock_proto_t *
+static struct ksock_proto *
 ksocknal_parse_proto_version(ksock_hello_msg_t *hello)
 {
         __u32 version = 0;
@@ -1666,11 +1666,11 @@ ksocknal_parse_proto_version(ksock_hello_msg_t *hello)
 }
 
 int
-ksocknal_send_hello(lnet_ni_t *ni, ksock_conn_t *conn,
+ksocknal_send_hello(lnet_ni_t *ni, struct ksock_conn *conn,
                     lnet_nid_t peer_nid, ksock_hello_msg_t *hello)
 {
         /* CAVEAT EMPTOR: this byte flips 'ipaddrs' */
-        ksock_net_t *net = (ksock_net_t *)ni->ni_data;
+        struct ksock_net *net = (struct ksock_net *)ni->ni_data;
 
         LASSERT(hello->kshm_nips <= LNET_MAX_INTERFACES);
 
@@ -1704,7 +1704,7 @@ ksocknal_invert_type(int type)
 }
 
 int
-ksocknal_recv_hello(lnet_ni_t *ni, ksock_conn_t *conn,
+ksocknal_recv_hello(lnet_ni_t *ni, struct ksock_conn *conn,
                     ksock_hello_msg_t *hello, lnet_process_id_t *peerid,
                     __u64 *incarnation)
 {
@@ -1718,7 +1718,7 @@ ksocknal_recv_hello(lnet_ni_t *ni, ksock_conn_t *conn,
         int timeout;
         int proto_match;
         int rc;
-        ksock_proto_t *proto;
+        struct ksock_proto *proto;
         lnet_process_id_t recv_id;
 
         /* socket type set on active connections - not set on passive */
@@ -1847,10 +1847,10 @@ ksocknal_recv_hello(lnet_ni_t *ni, ksock_conn_t *conn,
 }
 
 static int
-ksocknal_connect(ksock_route_t *route)
+ksocknal_connect(struct ksock_route *route)
 {
         LIST_HEAD(zombies);
-        ksock_peer_t *peer = route->ksnr_peer;
+        struct ksock_peer *peer = route->ksnr_peer;
         int type;
         int wanted;
         struct socket *sock;
@@ -1989,7 +1989,7 @@ ksocknal_connect(ksock_route_t *route)
         if (!list_empty(&peer->ksnp_tx_queue) &&
             !peer->ksnp_accepting &&
             !ksocknal_find_connecting_route_locked(peer)) {
-                ksock_conn_t *conn;
+                struct ksock_conn *conn;
 
                 /*
                  * ksnp_tx_queue is queued on a conn on successful
@@ -1997,7 +1997,7 @@ ksocknal_connect(ksock_route_t *route)
                  */
                 if (!list_empty(&peer->ksnp_conns)) {
                         conn = list_entry(peer->ksnp_conns.next,
-                                          ksock_conn_t, ksnc_list);
+                                          struct ksock_conn, ksnc_list);
                         LASSERT(conn->ksnc_proto == &ksocknal_protocol_v3x);
                 }
 
@@ -2131,10 +2131,10 @@ ksocknal_connd_check_stop(time64_t sec, long *timeout)
  * Go through connd_routes queue looking for a route that we can process
  * right now, @timeout_p can be updated if we need to come back later
  */
-static ksock_route_t *
+static struct ksock_route *
 ksocknal_connd_get_route_locked(signed long *timeout_p)
 {
-        ksock_route_t *route;
+        struct ksock_route *route;
         unsigned long now;
 
         now = cfs_time_current();
@@ -2158,7 +2158,7 @@ int
 ksocknal_connd(void *arg)
 {
         spinlock_t *connd_lock = &ksocknal_data.ksnd_connd_lock;
-        ksock_connreq_t *cr;
+        struct ksock_connreq *cr;
         wait_queue_t wait;
         int nloops = 0;
         int cons_retry = 0;
@@ -2174,7 +2174,7 @@ ksocknal_connd(void *arg)
         ksocknal_data.ksnd_connd_running++;
 
         while (!ksocknal_data.ksnd_shuttingdown) {
-                ksock_route_t *route = NULL;
+                struct ksock_route *route = NULL;
                 time64_t sec = ktime_get_real_seconds();
                 long timeout = MAX_SCHEDULE_TIMEOUT;
                 int dropped_lock = 0;
@@ -2192,8 +2192,8 @@ ksocknal_connd(void *arg)
 
                 if (!list_empty(&ksocknal_data.ksnd_connd_connreqs)) {
                         /* Connection accepted by the listener */
-                        cr = list_entry(ksocknal_data.ksnd_connd_connreqs. \
-                                            next, ksock_connreq_t, ksncr_list);
+                        cr = list_entry(ksocknal_data.ksnd_connd_connreqs.next,
+                                        struct ksock_connreq, ksncr_list);
 
                         list_del(&cr->ksncr_list);
                         spin_unlock_bh(connd_lock);
@@ -2267,17 +2267,17 @@ ksocknal_connd(void *arg)
         return 0;
 }
 
-static ksock_conn_t *
-ksocknal_find_timed_out_conn(ksock_peer_t *peer)
+static struct ksock_conn *
+ksocknal_find_timed_out_conn(struct ksock_peer *peer)
 {
         /* We're called with a shared lock on ksnd_global_lock */
-        ksock_conn_t *conn;
+        struct ksock_conn *conn;
         struct list_head *ctmp;
 
         list_for_each(ctmp, &peer->ksnp_conns) {
                 int error;
 
-                conn = list_entry(ctmp, ksock_conn_t, ksnc_list);
+                conn = list_entry(ctmp, struct ksock_conn, ksnc_list);
 
                 /* Don't need the {get,put}connsock dance to deref ksnc_sock */
                 LASSERT(!conn->ksnc_closing);
@@ -2351,10 +2351,10 @@ ksocknal_find_timed_out_conn(ksock_peer_t *peer)
 }
 
 static inline void
-ksocknal_flush_stale_txs(ksock_peer_t *peer)
+ksocknal_flush_stale_txs(struct ksock_peer *peer)
 {
-        ksock_tx_t *tx;
-        ksock_tx_t *tmp;
+        struct ksock_tx *tx;
+        struct ksock_tx *tmp;
         LIST_HEAD(stale_txs);
 
         write_lock_bh(&ksocknal_data.ksnd_global_lock);
@@ -2374,12 +2374,12 @@ ksocknal_flush_stale_txs(ksock_peer_t *peer)
 }
 
 static int
-ksocknal_send_keepalive_locked(ksock_peer_t *peer)
+ksocknal_send_keepalive_locked(struct ksock_peer *peer)
         __must_hold(&ksocknal_data.ksnd_global_lock)
 {
-        ksock_sched_t *sched;
-        ksock_conn_t *conn;
-        ksock_tx_t *tx;
+        struct ksock_sched *sched;
+        struct ksock_conn *conn;
+        struct ksock_tx *tx;
 
         if (list_empty(&peer->ksnp_conns)) /* last_alive will be updated by create_conn */
                 return 0;
@@ -2440,9 +2440,9 @@ static void
 ksocknal_check_peer_timeouts(int idx)
 {
         struct list_head *peers = &ksocknal_data.ksnd_peers[idx];
-        ksock_peer_t *peer;
-        ksock_conn_t *conn;
-        ksock_tx_t *tx;
+        struct ksock_peer *peer;
+        struct ksock_conn *conn;
+        struct ksock_tx *tx;
 
  again:
         /*
@@ -2483,8 +2483,8 @@ ksocknal_check_peer_timeouts(int idx)
                  * holding only shared lock
                  */
                 if (!list_empty(&peer->ksnp_tx_queue)) {
-                        ksock_tx_t *tx = list_entry(peer->ksnp_tx_queue.next,
-                                                    ksock_tx_t, tx_list);
+                        struct ksock_tx *tx = list_entry(peer->ksnp_tx_queue.next,
+                                                    struct ksock_tx, tx_list);
 
                         if (cfs_time_aftereq(cfs_time_current(),
                                              tx->tx_deadline)) {
@@ -2518,7 +2518,7 @@ ksocknal_check_peer_timeouts(int idx)
                 }
 
                 tx = list_entry(peer->ksnp_zc_req_list.next,
-                                ksock_tx_t, tx_zc_list);
+                                struct ksock_tx, tx_zc_list);
                 deadline = tx->tx_deadline;
                 resid = tx->tx_resid;
                 conn = tx->tx_conn;
@@ -2544,8 +2544,8 @@ int
 ksocknal_reaper(void *arg)
 {
         wait_queue_t wait;
-        ksock_conn_t *conn;
-        ksock_sched_t *sched;
+        struct ksock_conn *conn;
+        struct ksock_sched *sched;
         struct list_head enomem_conns;
         int nenomem_conns;
         long timeout;
@@ -2563,7 +2563,7 @@ ksocknal_reaper(void *arg)
         while (!ksocknal_data.ksnd_shuttingdown) {
                 if (!list_empty(&ksocknal_data.ksnd_deathrow_conns)) {
                         conn = list_entry(ksocknal_data.ksnd_deathrow_conns.next,
-                                          ksock_conn_t, ksnc_list);
+                                          struct ksock_conn, ksnc_list);
                         list_del(&conn->ksnc_list);
 
                         spin_unlock_bh(&ksocknal_data.ksnd_reaper_lock);
@@ -2577,7 +2577,7 @@ ksocknal_reaper(void *arg)
 
                 if (!list_empty(&ksocknal_data.ksnd_zombie_conns)) {
                         conn = list_entry(ksocknal_data.ksnd_zombie_conns.next,
-                                          ksock_conn_t, ksnc_list);
+                                          struct ksock_conn, ksnc_list);
                         list_del(&conn->ksnc_list);
 
                         spin_unlock_bh(&ksocknal_data.ksnd_reaper_lock);
@@ -2599,7 +2599,7 @@ ksocknal_reaper(void *arg)
                 /* reschedule all the connections that stalled with ENOMEM... */
                 nenomem_conns = 0;
                 while (!list_empty(&enomem_conns)) {
-                        conn = list_entry(enomem_conns.next, ksock_conn_t,
+                        conn = list_entry(enomem_conns.next, struct ksock_conn,
                                           ksnc_tx_list);
                         list_del(&conn->ksnc_tx_list);
 
diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c
index 964b4e338fe0..6a17757fce1e 100644
--- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c
+++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -37,7 +33,7 @@
 #include "socklnd.h"
 
 int
-ksocknal_lib_get_conn_addrs(ksock_conn_t *conn)
+ksocknal_lib_get_conn_addrs(struct ksock_conn *conn)
 {
         int rc = lnet_sock_getaddr(conn->ksnc_sock, 1, &conn->ksnc_ipaddr,
                                    &conn->ksnc_port);
@@ -60,7 +56,7 @@ ksocknal_lib_get_conn_addrs(ksock_conn_t *conn)
 }
 
 int
-ksocknal_lib_zc_capable(ksock_conn_t *conn)
+ksocknal_lib_zc_capable(struct ksock_conn *conn)
 {
         int caps = conn->ksnc_sock->sk->sk_route_caps;
 
@@ -75,7 +71,7 @@ ksocknal_lib_zc_capable(ksock_conn_t *conn)
 }
 
 int
-ksocknal_lib_send_iov(ksock_conn_t *conn, ksock_tx_t *tx)
+ksocknal_lib_send_iov(struct ksock_conn *conn, struct ksock_tx *tx)
 {
         struct socket *sock = conn->ksnc_sock;
         int nob;
@@ -118,7 +114,7 @@ ksocknal_lib_send_iov(ksock_conn_t *conn, ksock_tx_t *tx)
 }
 
 int
-ksocknal_lib_send_kiov(ksock_conn_t *conn, ksock_tx_t *tx)
+ksocknal_lib_send_kiov(struct ksock_conn *conn, struct ksock_tx *tx)
 {
         struct socket *sock = conn->ksnc_sock;
         lnet_kiov_t *kiov = tx->tx_kiov;
@@ -187,7 +183,7 @@ ksocknal_lib_send_kiov(ksock_conn_t *conn, ksock_tx_t *tx)
 }
 
 void
-ksocknal_lib_eager_ack(ksock_conn_t *conn)
+ksocknal_lib_eager_ack(struct ksock_conn *conn)
 {
         int opt = 1;
         struct socket *sock = conn->ksnc_sock;
@@ -203,7 +199,7 @@ ksocknal_lib_eager_ack(ksock_conn_t *conn)
 }
 
 int
-ksocknal_lib_recv_iov(ksock_conn_t *conn)
+ksocknal_lib_recv_iov(struct ksock_conn *conn)
 {
 #if SOCKNAL_SINGLE_FRAG_RX
         struct kvec scratch;
@@ -309,7 +305,7 @@ ksocknal_lib_kiov_vmap(lnet_kiov_t *kiov, int niov,
 }
 
 int
-ksocknal_lib_recv_kiov(ksock_conn_t *conn)
+ksocknal_lib_recv_kiov(struct ksock_conn *conn)
 {
 #if SOCKNAL_SINGLE_FRAG_RX || !SOCKNAL_RISK_KMAP_DEADLOCK
         struct kvec scratch;
@@ -393,7 +389,7 @@ ksocknal_lib_recv_kiov(ksock_conn_t *conn)
 }
 
 void
-ksocknal_lib_csum_tx(ksock_tx_t *tx)
+ksocknal_lib_csum_tx(struct ksock_tx *tx)
 {
         int i;
         __u32 csum;
@@ -432,7 +428,7 @@ ksocknal_lib_csum_tx(ksock_tx_t *tx)
 }
 
 int
-ksocknal_lib_get_conn_tunables(ksock_conn_t *conn, int *txmem, int *rxmem, int *nagle)
+ksocknal_lib_get_conn_tunables(struct ksock_conn *conn, int *txmem, int *rxmem, int *nagle)
 {
         struct socket *sock = conn->ksnc_sock;
         int len;
@@ -562,7 +558,7 @@ ksocknal_lib_setup_sock(struct socket *sock)
 }
 
 void
-ksocknal_lib_push_conn(ksock_conn_t *conn)
+ksocknal_lib_push_conn(struct ksock_conn *conn)
 {
         struct sock *sk;
         struct tcp_sock *tp;
@@ -599,7 +595,7 @@ ksocknal_lib_push_conn(ksock_conn_t *conn)
 static void
 ksocknal_data_ready(struct sock *sk)
 {
-        ksock_conn_t *conn;
+        struct ksock_conn *conn;
 
         /* interleave correctly with closing sockets... */
         LASSERT(!in_irq());
@@ -619,7 +615,7 @@ ksocknal_data_ready(struct sock *sk)
 static void
 ksocknal_write_space(struct sock *sk)
 {
-        ksock_conn_t *conn;
+        struct ksock_conn *conn;
         int wspace;
         int min_wpace;
 
@@ -663,14 +659,14 @@ ksocknal_write_space(struct sock *sk)
 }
 
 void
-ksocknal_lib_save_callback(struct socket *sock, ksock_conn_t *conn)
+ksocknal_lib_save_callback(struct socket *sock, struct ksock_conn *conn)
 {
         conn->ksnc_saved_data_ready = sock->sk->sk_data_ready;
         conn->ksnc_saved_write_space = sock->sk->sk_write_space;
 }
 
 void
-ksocknal_lib_set_callback(struct socket *sock,  ksock_conn_t *conn)
+ksocknal_lib_set_callback(struct socket *sock,  struct ksock_conn *conn)
 {
         sock->sk->sk_user_data = conn;
         sock->sk->sk_data_ready = ksocknal_data_ready;
@@ -678,7 +674,7 @@ ksocknal_lib_set_callback(struct socket *sock,  ksock_conn_t *conn)
 }
 
 void
-ksocknal_lib_reset_callback(struct socket *sock, ksock_conn_t *conn)
+ksocknal_lib_reset_callback(struct socket *sock, struct ksock_conn *conn)
 {
         /*
          * Remove conn's network callbacks.
@@ -697,10 +693,10 @@ ksocknal_lib_reset_callback(struct socket *sock, ksock_conn_t *conn)
 }
 
 int
-ksocknal_lib_memory_pressure(ksock_conn_t *conn)
+ksocknal_lib_memory_pressure(struct ksock_conn *conn)
 {
         int rc = 0;
-        ksock_sched_t *sched;
+        struct ksock_sched *sched;
 
         sched = conn->ksnc_scheduler;
         spin_lock_bh(&sched->kss_lock);
diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_modparams.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_modparams.c
index 6329cbe66573..fc7eec83ac07 100644
--- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_modparams.c
+++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_modparams.c
@@ -139,7 +139,7 @@ module_param(protocol, int, 0644);
 MODULE_PARM_DESC(protocol, "protocol version");
 #endif
 
-ksock_tunables_t ksocknal_tunables;
+struct ksock_tunables ksocknal_tunables;
 
 int ksocknal_tunables_init(void)
 {
diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c
index 32cc31e4cc29..82e174f6d9fe 100644
--- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c
+++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c
@@ -38,8 +38,8 @@
  *   pro_match_tx()       : Called holding glock
  */
 
-static ksock_tx_t *
-ksocknal_queue_tx_msg_v1(ksock_conn_t *conn, ksock_tx_t *tx_msg)
+static struct ksock_tx *
+ksocknal_queue_tx_msg_v1(struct ksock_conn *conn, struct ksock_tx *tx_msg)
 {
         /* V1.x, just enqueue it */
         list_add_tail(&tx_msg->tx_list, &conn->ksnc_tx_queue);
@@ -47,9 +47,9 @@ ksocknal_queue_tx_msg_v1(ksock_conn_t *conn, ksock_tx_t *tx_msg)
 }
 
 void
-ksocknal_next_tx_carrier(ksock_conn_t *conn)
+ksocknal_next_tx_carrier(struct ksock_conn *conn)
 {
-        ksock_tx_t *tx = conn->ksnc_tx_carrier;
+        struct ksock_tx *tx = conn->ksnc_tx_carrier;
 
         /* Called holding BH lock: conn->ksnc_scheduler->kss_lock */
         LASSERT(!list_empty(&conn->ksnc_tx_queue));
@@ -66,10 +66,10 @@ ksocknal_next_tx_carrier(ksock_conn_t *conn)
 }
 
 static int
-ksocknal_queue_tx_zcack_v2(ksock_conn_t *conn,
-                           ksock_tx_t *tx_ack, __u64 cookie)
+ksocknal_queue_tx_zcack_v2(struct ksock_conn *conn,
+                           struct ksock_tx *tx_ack, __u64 cookie)
 {
-        ksock_tx_t *tx = conn->ksnc_tx_carrier;
+        struct ksock_tx *tx = conn->ksnc_tx_carrier;
 
         LASSERT(!tx_ack ||
                 tx_ack->tx_msg.ksm_type == KSOCK_MSG_NOOP);
@@ -112,10 +112,10 @@ ksocknal_queue_tx_zcack_v2(ksock_conn_t *conn,
         return 1;
 }
 
-static ksock_tx_t *
-ksocknal_queue_tx_msg_v2(ksock_conn_t *conn, ksock_tx_t *tx_msg)
+static struct ksock_tx *
+ksocknal_queue_tx_msg_v2(struct ksock_conn *conn, struct ksock_tx *tx_msg)
 {
-        ksock_tx_t *tx  = conn->ksnc_tx_carrier;
+        struct ksock_tx *tx  = conn->ksnc_tx_carrier;
 
         /*
          * Enqueue tx_msg:
@@ -149,10 +149,10 @@ ksocknal_queue_tx_msg_v2(ksock_conn_t *conn, ksock_tx_t *tx_msg)
 }
 
 static int
-ksocknal_queue_tx_zcack_v3(ksock_conn_t *conn,
-                           ksock_tx_t *tx_ack, __u64 cookie)
+ksocknal_queue_tx_zcack_v3(struct ksock_conn *conn,
+                           struct ksock_tx *tx_ack, __u64 cookie)
 {
-        ksock_tx_t *tx;
+        struct ksock_tx *tx;
 
         if (conn->ksnc_type != SOCKLND_CONN_ACK)
                 return ksocknal_queue_tx_zcack_v2(conn, tx_ack, cookie);
@@ -267,7 +267,7 @@ ksocknal_queue_tx_zcack_v3(ksock_conn_t *conn,
 }
 
 static int
-ksocknal_match_tx(ksock_conn_t *conn, ksock_tx_t *tx, int nonblk)
+ksocknal_match_tx(struct ksock_conn *conn, struct ksock_tx *tx, int nonblk)
 {
         int nob;
 
@@ -311,7 +311,7 @@ ksocknal_match_tx(ksock_conn_t *conn, ksock_tx_t *tx, int nonblk)
 }
 
 static int
-ksocknal_match_tx_v3(ksock_conn_t *conn, ksock_tx_t *tx, int nonblk)
+ksocknal_match_tx_v3(struct ksock_conn *conn, struct ksock_tx *tx, int nonblk)
 {
         int nob;
 
@@ -355,18 +355,18 @@ ksocknal_match_tx_v3(ksock_conn_t *conn, ksock_tx_t *tx, int nonblk)
 
 /* (Sink) handle incoming ZC request from sender */
 static int
-ksocknal_handle_zcreq(ksock_conn_t *c, __u64 cookie, int remote)
+ksocknal_handle_zcreq(struct ksock_conn *c, __u64 cookie, int remote)
 {
-        ksock_peer_t *peer = c->ksnc_peer;
-        ksock_conn_t *conn;
-        ksock_tx_t *tx;
+        struct ksock_peer *peer = c->ksnc_peer;
+        struct ksock_conn *conn;
+        struct ksock_tx *tx;
         int rc;
 
         read_lock(&ksocknal_data.ksnd_global_lock);
 
         conn = ksocknal_find_conn_locked(peer, NULL, !!remote);
         if (conn) {
-                ksock_sched_t *sched = conn->ksnc_scheduler;
+                struct ksock_sched *sched = conn->ksnc_scheduler;
 
                 LASSERT(conn->ksnc_proto->pro_queue_tx_zcack);
 
@@ -399,12 +399,12 @@ ksocknal_handle_zcreq(ksock_conn_t *c, __u64 cookie, int remote)
 
 /* (Sender) handle ZC_ACK from sink */
 static int
-ksocknal_handle_zcack(ksock_conn_t *conn, __u64 cookie1, __u64 cookie2)
+ksocknal_handle_zcack(struct ksock_conn *conn, __u64 cookie1, __u64 cookie2)
 {
-        ksock_peer_t *peer = conn->ksnc_peer;
-        ksock_tx_t *tx;
-        ksock_tx_t *temp;
-        ksock_tx_t *tmp;
+        struct ksock_peer *peer = conn->ksnc_peer;
+        struct ksock_tx *tx;
+        struct ksock_tx *temp;
+        struct ksock_tx *tmp;
         LIST_HEAD(zlist);
         int count;
 
@@ -446,7 +446,7 @@ ksocknal_handle_zcack(ksock_conn_t *conn, __u64 cookie1, __u64 cookie2)
 }
 
 static int
-ksocknal_send_hello_v1(ksock_conn_t *conn, ksock_hello_msg_t *hello)
+ksocknal_send_hello_v1(struct ksock_conn *conn, ksock_hello_msg_t *hello)
 {
         struct socket *sock = conn->ksnc_sock;
         lnet_hdr_t *hdr;
@@ -503,7 +503,7 @@ ksocknal_send_hello_v1(ksock_conn_t *conn, ksock_hello_msg_t *hello)
         if (!hello->kshm_nips)
                 goto out;
 
-        for (i = 0; i < (int) hello->kshm_nips; i++)
+        for (i = 0; i < (int)hello->kshm_nips; i++)
                 hello->kshm_ips[i] = __cpu_to_le32(hello->kshm_ips[i]);
 
         rc = lnet_sock_write(sock, hello->kshm_ips,
@@ -521,7 +521,7 @@ out:
 }
 
 static int
-ksocknal_send_hello_v2(ksock_conn_t *conn, ksock_hello_msg_t *hello)
+ksocknal_send_hello_v2(struct ksock_conn *conn, ksock_hello_msg_t *hello)
 {
         struct socket *sock = conn->ksnc_sock;
         int rc;
@@ -563,7 +563,7 @@ ksocknal_send_hello_v2(ksock_conn_t *conn, ksock_hello_msg_t *hello)
 }
 
 static int
-ksocknal_recv_hello_v1(ksock_conn_t *conn, ksock_hello_msg_t *hello,
+ksocknal_recv_hello_v1(struct ksock_conn *conn, ksock_hello_msg_t *hello,
                        int timeout)
 {
         struct socket *sock = conn->ksnc_sock;
@@ -622,7 +622,7 @@ ksocknal_recv_hello_v1(ksock_conn_t *conn, ksock_hello_msg_t *hello,
                 goto out;
         }
 
-        for (i = 0; i < (int) hello->kshm_nips; i++) {
+        for (i = 0; i < (int)hello->kshm_nips; i++) {
                 hello->kshm_ips[i] = __le32_to_cpu(hello->kshm_ips[i]);
 
                 if (!hello->kshm_ips[i]) {
@@ -639,7 +639,7 @@ out:
 }
 
 static int
-ksocknal_recv_hello_v2(ksock_conn_t *conn, ksock_hello_msg_t *hello, int timeout)
+ksocknal_recv_hello_v2(struct ksock_conn *conn, ksock_hello_msg_t *hello, int timeout)
 {
         struct socket *sock = conn->ksnc_sock;
         int rc;
@@ -690,7 +690,7 @@ ksocknal_recv_hello_v2(ksock_conn_t *conn, ksock_hello_msg_t *hello, int timeout
                 return rc;
         }
 
-        for (i = 0; i < (int) hello->kshm_nips; i++) {
+        for (i = 0; i < (int)hello->kshm_nips; i++) {
                 if (conn->ksnc_flip)
                         __swab32s(&hello->kshm_ips[i]);
 
@@ -705,7 +705,7 @@ ksocknal_recv_hello_v2(ksock_conn_t *conn, ksock_hello_msg_t *hello, int timeout
 }
 
 static void
-ksocknal_pack_msg_v1(ksock_tx_t *tx)
+ksocknal_pack_msg_v1(struct ksock_tx *tx)
 {
         /* V1.x has no KSOCK_MSG_NOOP */
         LASSERT(tx->tx_msg.ksm_type != KSOCK_MSG_NOOP);
@@ -719,7 +719,7 @@ ksocknal_pack_msg_v1(ksock_tx_t *tx)
 }
 
 static void
-ksocknal_pack_msg_v2(ksock_tx_t *tx)
+ksocknal_pack_msg_v2(struct ksock_tx *tx)
 {
         tx->tx_iov[0].iov_base = &tx->tx_msg;
 
@@ -755,7 +755,7 @@ ksocknal_unpack_msg_v2(ksock_msg_t *msg)
         return;  /* Do nothing */
 }
 
-ksock_proto_t  ksocknal_protocol_v1x = {
+struct ksock_proto ksocknal_protocol_v1x = {
         .pro_version        = KSOCK_PROTO_V1,
         .pro_send_hello     = ksocknal_send_hello_v1,
         .pro_recv_hello     = ksocknal_recv_hello_v1,
@@ -768,7 +768,7 @@ ksock_proto_t  ksocknal_protocol_v1x = {
         .pro_match_tx       = ksocknal_match_tx
 };
 
-ksock_proto_t  ksocknal_protocol_v2x = {
+struct ksock_proto ksocknal_protocol_v2x = {
         .pro_version        = KSOCK_PROTO_V2,
         .pro_send_hello     = ksocknal_send_hello_v2,
         .pro_recv_hello     = ksocknal_recv_hello_v2,
@@ -781,7 +781,7 @@ ksock_proto_t  ksocknal_protocol_v2x = {
         .pro_match_tx       = ksocknal_match_tx
 };
 
-ksock_proto_t  ksocknal_protocol_v3x = {
+struct ksock_proto ksocknal_protocol_v3x = {
         .pro_version        = KSOCK_PROTO_V3,
         .pro_send_hello     = ksocknal_send_hello_v2,
         .pro_recv_hello     = ksocknal_recv_hello_v2,
diff --git a/drivers/staging/lustre/lnet/libcfs/debug.c b/drivers/staging/lustre/lnet/libcfs/debug.c
index 8c260c3d5da4..75a2a42f7d0c 100644
--- a/drivers/staging/lustre/lnet/libcfs/debug.c
+++ b/drivers/staging/lustre/lnet/libcfs/debug.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/fail.c b/drivers/staging/lustre/lnet/libcfs/fail.c
index 086e690bd6f2..9288ee08d1f7 100644
--- a/drivers/staging/lustre/lnet/libcfs/fail.c
+++ b/drivers/staging/lustre/lnet/libcfs/fail.c
@@ -16,10 +16,6 @@
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see http://www.gnu.org/licenses
  *
- * Please contact Oracle Corporation, Inc., 500 Oracle Parkway, Redwood Shores,
- * CA 94065 USA or visit www.oracle.com if you need additional information or
- * have any questions.
- *
  * GPL HEADER END
  */
 /*
diff --git a/drivers/staging/lustre/lnet/libcfs/hash.c b/drivers/staging/lustre/lnet/libcfs/hash.c
index cc45ed82b2be..23283b6e09ab 100644
--- a/drivers/staging/lustre/lnet/libcfs/hash.c
+++ b/drivers/staging/lustre/lnet/libcfs/hash.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/libcfs_string.c b/drivers/staging/lustre/lnet/libcfs/libcfs_string.c
index 50ac1536db4b..fc697cdfcdaf 100644
--- a/drivers/staging/lustre/lnet/libcfs/libcfs_string.c
+++ b/drivers/staging/lustre/lnet/libcfs/libcfs_string.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/linux/linux-crypto.c b/drivers/staging/lustre/lnet/libcfs/linux/linux-crypto.c
index 84f9b7b47581..5c0116ade909 100644
--- a/drivers/staging/lustre/lnet/libcfs/linux/linux-crypto.c
+++ b/drivers/staging/lustre/lnet/libcfs/linux/linux-crypto.c
@@ -99,6 +99,7 @@ static int cfs_crypto_hash_alloc(enum cfs_crypto_hash_alg hash_alg,
                                          (*type)->cht_size);
 
         if (err != 0) {
+                ahash_request_free(*req);
                 crypto_free_ahash(tfm);
                 return err;
         }
diff --git a/drivers/staging/lustre/lnet/libcfs/linux/linux-curproc.c b/drivers/staging/lustre/lnet/libcfs/linux/linux-curproc.c
index 13d31e8a931d..3e22cad18a8b 100644
--- a/drivers/staging/lustre/lnet/libcfs/linux/linux-curproc.c
+++ b/drivers/staging/lustre/lnet/libcfs/linux/linux-curproc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/linux/linux-debug.c b/drivers/staging/lustre/lnet/libcfs/linux/linux-debug.c
index 638e4b33d3a9..435b784c52f8 100644
--- a/drivers/staging/lustre/lnet/libcfs/linux/linux-debug.c
+++ b/drivers/staging/lustre/lnet/libcfs/linux/linux-debug.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/linux/linux-mem.c b/drivers/staging/lustre/lnet/libcfs/linux/linux-mem.c
index 86f32ffc5d04..a6a76a681ea9 100644
--- a/drivers/staging/lustre/lnet/libcfs/linux/linux-mem.c
+++ b/drivers/staging/lustre/lnet/libcfs/linux/linux-mem.c
@@ -11,7 +11,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  */
 /*
diff --git a/drivers/staging/lustre/lnet/libcfs/linux/linux-module.c b/drivers/staging/lustre/lnet/libcfs/linux/linux-module.c
index d89f71ee45b2..38308f8b6aae 100644
--- a/drivers/staging/lustre/lnet/libcfs/linux/linux-module.c
+++ b/drivers/staging/lustre/lnet/libcfs/linux/linux-module.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/linux/linux-prim.c b/drivers/staging/lustre/lnet/libcfs/linux/linux-prim.c
index bbe19a684c81..291d286eab48 100644
--- a/drivers/staging/lustre/lnet/libcfs/linux/linux-prim.c
+++ b/drivers/staging/lustre/lnet/libcfs/linux/linux-prim.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/linux/linux-tracefile.c b/drivers/staging/lustre/lnet/libcfs/linux/linux-tracefile.c
index 91c2ae8f9d67..8b551d2708ba 100644
--- a/drivers/staging/lustre/lnet/libcfs/linux/linux-tracefile.c
+++ b/drivers/staging/lustre/lnet/libcfs/linux/linux-tracefile.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/module.c b/drivers/staging/lustre/lnet/libcfs/module.c
index f2d041118cf7..86b4d25cad46 100644
--- a/drivers/staging/lustre/lnet/libcfs/module.c
+++ b/drivers/staging/lustre/lnet/libcfs/module.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/prng.c b/drivers/staging/lustre/lnet/libcfs/prng.c
index c75ae9a68e76..a9bdb284fd15 100644
--- a/drivers/staging/lustre/lnet/libcfs/prng.c
+++ b/drivers/staging/lustre/lnet/libcfs/prng.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/tracefile.c b/drivers/staging/lustre/lnet/libcfs/tracefile.c
index 7739b9469c5a..1c7efdfaffcf 100644
--- a/drivers/staging/lustre/lnet/libcfs/tracefile.c
+++ b/drivers/staging/lustre/lnet/libcfs/tracefile.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/tracefile.h b/drivers/staging/lustre/lnet/libcfs/tracefile.h
index ac84e7f4c859..d878676bc375 100644
--- a/drivers/staging/lustre/lnet/libcfs/tracefile.h
+++ b/drivers/staging/lustre/lnet/libcfs/tracefile.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/libcfs/workitem.c b/drivers/staging/lustre/lnet/libcfs/workitem.c
index 92236ae59e49..e98c818a14fb 100644
--- a/drivers/staging/lustre/lnet/libcfs/workitem.c
+++ b/drivers/staging/lustre/lnet/libcfs/workitem.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/acceptor.c b/drivers/staging/lustre/lnet/lnet/acceptor.c
index 1452bb3ad9eb..8c50c99d82d5 100644
--- a/drivers/staging/lustre/lnet/lnet/acceptor.c
+++ b/drivers/staging/lustre/lnet/lnet/acceptor.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/api-ni.c b/drivers/staging/lustre/lnet/lnet/api-ni.c
index fe0dbe7468e7..346db892f275 100644
--- a/drivers/staging/lustre/lnet/lnet/api-ni.c
+++ b/drivers/staging/lustre/lnet/lnet/api-ni.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -1677,7 +1673,7 @@ lnet_fill_ni_info(struct lnet_ni *ni, struct lnet_ioctl_config_data *config)
         if (!ni || !config)
                 return;
 
-        net_config = (struct lnet_ioctl_net_config *) config->cfg_bulk;
+        net_config = (struct lnet_ioctl_net_config *)config->cfg_bulk;
         if (!net_config)
                 return;
 
diff --git a/drivers/staging/lustre/lnet/lnet/config.c b/drivers/staging/lustre/lnet/lnet/config.c
index 480cc9c6caab..a72afdf68bb2 100644
--- a/drivers/staging/lustre/lnet/lnet/config.c
+++ b/drivers/staging/lustre/lnet/lnet/config.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/lib-eq.c b/drivers/staging/lustre/lnet/lnet/lib-eq.c
index adbcadbab1be..d05c6cc797f6 100644
--- a/drivers/staging/lustre/lnet/lnet/lib-eq.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-eq.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/lib-md.c b/drivers/staging/lustre/lnet/lnet/lib-md.c
index 75d31217bf92..1834bf7a27ef 100644
--- a/drivers/staging/lustre/lnet/lnet/lib-md.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-md.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/lib-me.c b/drivers/staging/lustre/lnet/lnet/lib-me.c
index e671aed373df..b430046dc294 100644
--- a/drivers/staging/lustre/lnet/lnet/lib-me.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-me.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/lib-move.c b/drivers/staging/lustre/lnet/lnet/lib-move.c
index c5d5bedb3128..e6d3b801d87d 100644
--- a/drivers/staging/lustre/lnet/lnet/lib-move.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-move.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/lib-msg.c b/drivers/staging/lustre/lnet/lnet/lib-msg.c
index f879d7f28708..910e106e221d 100644
--- a/drivers/staging/lustre/lnet/lnet/lib-msg.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-msg.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/lo.c b/drivers/staging/lustre/lnet/lnet/lo.c
index 468eda611bf8..08402712a452 100644
--- a/drivers/staging/lustre/lnet/lnet/lo.c
+++ b/drivers/staging/lustre/lnet/lnet/lo.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/module.c b/drivers/staging/lustre/lnet/lnet/module.c
index 246b5c141d01..4ffbd3e441e8 100644
--- a/drivers/staging/lustre/lnet/lnet/module.c
+++ b/drivers/staging/lustre/lnet/lnet/module.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -200,7 +196,7 @@ static int __init lnet_init(void)
                  * Have to schedule a separate thread to avoid deadlocking
                  * in modload
                  */
-                (void) kthread_run(lnet_configure, NULL, "lnet_initd");
+                (void)kthread_run(lnet_configure, NULL, "lnet_initd");
         }
 
         return 0;
diff --git a/drivers/staging/lustre/lnet/lnet/net_fault.c b/drivers/staging/lustre/lnet/lnet/net_fault.c
index 7d76f28d3a7a..e4aceb71c4ec 100644
--- a/drivers/staging/lustre/lnet/lnet/net_fault.c
+++ b/drivers/staging/lustre/lnet/lnet/net_fault.c
@@ -760,9 +760,7 @@ lnet_delay_rule_add(struct lnet_fault_attr *attr)
                 wait_event(delay_dd.dd_ctl_waitq, delay_dd.dd_running);
         }
 
-        init_timer(&rule->dl_timer);
-        rule->dl_timer.function = delay_timer_cb;
-        rule->dl_timer.data = (unsigned long)rule;
+        setup_timer(&rule->dl_timer, delay_timer_cb, (unsigned long)rule);
 
         spin_lock_init(&rule->dl_lock);
         INIT_LIST_HEAD(&rule->dl_msg_list);
diff --git a/drivers/staging/lustre/lnet/lnet/nidstrings.c b/drivers/staging/lustre/lnet/lnet/nidstrings.c
index ebf468fbc64f..a6d7a6159b8f 100644
--- a/drivers/staging/lustre/lnet/lnet/nidstrings.c
+++ b/drivers/staging/lustre/lnet/lnet/nidstrings.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/peer.c b/drivers/staging/lustre/lnet/lnet/peer.c
index b026feebc03a..e8061916c241 100644
--- a/drivers/staging/lustre/lnet/lnet/peer.c
+++ b/drivers/staging/lustre/lnet/lnet/peer.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/lnet/router.c b/drivers/staging/lustre/lnet/lnet/router.c
index b01dc424c514..063543233035 100644
--- a/drivers/staging/lustre/lnet/lnet/router.c
+++ b/drivers/staging/lustre/lnet/lnet/router.c
@@ -18,6 +18,7 @@
  */
 
 #define DEBUG_SUBSYSTEM S_LNET
+#include <linux/completion.h>
 #include "../../include/linux/lnet/lib-lnet.h"
 
 #define LNET_NRB_TINY_MIN       512     /* min value for each CPT */
@@ -1065,7 +1066,7 @@ lnet_router_checker_start(void)
                 return -EINVAL;
         }
 
-        sema_init(&the_lnet.ln_rc_signal, 0);
+        init_completion(&the_lnet.ln_rc_signal);
 
         rc = LNetEQAlloc(0, lnet_router_checker_event, &the_lnet.ln_rc_eqh);
         if (rc) {
@@ -1079,7 +1080,7 @@ lnet_router_checker_start(void)
                 rc = PTR_ERR(task);
                 CERROR("Can't start router checker thread: %d\n", rc);
                 /* block until event callback signals exit */
-                down(&the_lnet.ln_rc_signal);
+                wait_for_completion(&the_lnet.ln_rc_signal);
                 rc = LNetEQFree(the_lnet.ln_rc_eqh);
                 LASSERT(!rc);
                 the_lnet.ln_rc_state = LNET_RC_STATE_SHUTDOWN;
@@ -1112,7 +1113,7 @@ lnet_router_checker_stop(void)
         wake_up(&the_lnet.ln_rc_waitq);
 
         /* block until event callback signals exit */
-        down(&the_lnet.ln_rc_signal);
+        wait_for_completion(&the_lnet.ln_rc_signal);
         LASSERT(the_lnet.ln_rc_state == LNET_RC_STATE_SHUTDOWN);
 
         rc = LNetEQFree(the_lnet.ln_rc_eqh);
@@ -1295,7 +1296,7 @@ rescan:
         lnet_prune_rc_data(1); /* wait for UNLINK */
 
         the_lnet.ln_rc_state = LNET_RC_STATE_SHUTDOWN;
-        up(&the_lnet.ln_rc_signal);
+        complete(&the_lnet.ln_rc_signal);
         /* The unlink event callback will signal final completion */
         return 0;
 }
diff --git a/drivers/staging/lustre/lnet/selftest/brw_test.c b/drivers/staging/lustre/lnet/selftest/brw_test.c
index a63d86c4c10d..13d0454e7fcb 100644
--- a/drivers/staging/lustre/lnet/selftest/brw_test.c
+++ b/drivers/staging/lustre/lnet/selftest/brw_test.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/conctl.c b/drivers/staging/lustre/lnet/selftest/conctl.c
index 408c614b6ca3..b786f8b4a73d 100644
--- a/drivers/staging/lustre/lnet/selftest/conctl.c
+++ b/drivers/staging/lustre/lnet/selftest/conctl.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/conrpc.c b/drivers/staging/lustre/lnet/selftest/conrpc.c
index 6f687581117d..1be3cad727ae 100644
--- a/drivers/staging/lustre/lnet/selftest/conrpc.c
+++ b/drivers/staging/lustre/lnet/selftest/conrpc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/conrpc.h b/drivers/staging/lustre/lnet/selftest/conrpc.h
index 90c3385a355c..7ec6fc96959e 100644
--- a/drivers/staging/lustre/lnet/selftest/conrpc.h
+++ b/drivers/staging/lustre/lnet/selftest/conrpc.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/console.c b/drivers/staging/lustre/lnet/selftest/console.c
index a03e52d29d3f..4c33621f06da 100644
--- a/drivers/staging/lustre/lnet/selftest/console.c
+++ b/drivers/staging/lustre/lnet/selftest/console.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/console.h b/drivers/staging/lustre/lnet/selftest/console.h
index becd22e41da9..78b147732615 100644
--- a/drivers/staging/lustre/lnet/selftest/console.h
+++ b/drivers/staging/lustre/lnet/selftest/console.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/framework.c b/drivers/staging/lustre/lnet/selftest/framework.c
index 30e4f71f14c2..c2f121f44d33 100644
--- a/drivers/staging/lustre/lnet/selftest/framework.c
+++ b/drivers/staging/lustre/lnet/selftest/framework.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/module.c b/drivers/staging/lustre/lnet/selftest/module.c
index cc046b1d4d0a..71485f992297 100644
--- a/drivers/staging/lustre/lnet/selftest/module.c
+++ b/drivers/staging/lustre/lnet/selftest/module.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/ping_test.c b/drivers/staging/lustre/lnet/selftest/ping_test.c
index ad26fe9dd4af..9331ca4e3606 100644
--- a/drivers/staging/lustre/lnet/selftest/ping_test.c
+++ b/drivers/staging/lustre/lnet/selftest/ping_test.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/rpc.c b/drivers/staging/lustre/lnet/selftest/rpc.c
index 3c45a7cfae18..3b26d6eb4240 100644
--- a/drivers/staging/lustre/lnet/selftest/rpc.c
+++ b/drivers/staging/lustre/lnet/selftest/rpc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/rpc.h b/drivers/staging/lustre/lnet/selftest/rpc.h
index c9b904cade16..4ab2ee264004 100644
--- a/drivers/staging/lustre/lnet/selftest/rpc.h
+++ b/drivers/staging/lustre/lnet/selftest/rpc.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/selftest.h b/drivers/staging/lustre/lnet/selftest/selftest.h
index 4eac1c9e639f..d033ac03d953 100644
--- a/drivers/staging/lustre/lnet/selftest/selftest.h
+++ b/drivers/staging/lustre/lnet/selftest/selftest.h
@@ -15,12 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- * copy of GPLv2].
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/timer.c b/drivers/staging/lustre/lnet/selftest/timer.c
index b6c4aae007af..dcd22580b1f0 100644
--- a/drivers/staging/lustre/lnet/selftest/timer.c
+++ b/drivers/staging/lustre/lnet/selftest/timer.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lnet/selftest/timer.h b/drivers/staging/lustre/lnet/selftest/timer.h
index f1fbebd8a67c..441d6d6b4f8e 100644
--- a/drivers/staging/lustre/lnet/selftest/timer.h
+++ b/drivers/staging/lustre/lnet/selftest/timer.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/Kconfig b/drivers/staging/lustre/lustre/Kconfig
index 8ac7cd4d6fdb..9f5d75f166e7 100644
--- a/drivers/staging/lustre/lustre/Kconfig
+++ b/drivers/staging/lustre/lustre/Kconfig
@@ -54,9 +54,3 @@ config LUSTRE_TRANSLATE_ERRNOS
         bool
         depends on LUSTRE_FS && !X86
         default y
-
-config LUSTRE_LLITE_LLOOP
-        tristate "Lustre virtual block device"
-        depends on LUSTRE_FS && BLOCK
-        depends on !PPC_64K_PAGES && !ARM64_64K_PAGES && !MICROBLAZE_64K_PAGES && !PAGE_SIZE_64KB && !IA64_PAGE_SIZE_64KB && !PARISC_PAGE_SIZE_64KB
-        default m
diff --git a/drivers/staging/lustre/lustre/fid/fid_internal.h b/drivers/staging/lustre/lustre/fid/fid_internal.h
index b79a813977cf..5c53773ecc5a 100644
--- a/drivers/staging/lustre/lustre/fid/fid_internal.h
+++ b/drivers/staging/lustre/lustre/fid/fid_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/fid/fid_lib.c b/drivers/staging/lustre/lustre/fid/fid_lib.c
index dd65159ebb38..99ae7eb6720e 100644
--- a/drivers/staging/lustre/lustre/fid/fid_lib.c
+++ b/drivers/staging/lustre/lustre/fid/fid_lib.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/fid/fid_request.c b/drivers/staging/lustre/lustre/fid/fid_request.c
index 3a4df626462f..454744d25956 100644
--- a/drivers/staging/lustre/lustre/fid/fid_request.c
+++ b/drivers/staging/lustre/lustre/fid/fid_request.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -98,8 +94,10 @@ static int seq_client_rpc(struct lu_client_seq *seq,
                  * request here, otherwise if MDT0 is failed(umounted),
                  * it can not release the export of MDT0
                  */
-                if (seq->lcs_type == LUSTRE_SEQ_DATA)
-                        req->rq_no_delay = req->rq_no_resend = 1;
+                if (seq->lcs_type == LUSTRE_SEQ_DATA) {
+                        req->rq_no_delay = 1;
+                        req->rq_no_resend = 1;
+                }
                 debug_mask = D_CONSOLE;
         } else {
                 if (seq->lcs_type == LUSTRE_SEQ_METADATA) {
diff --git a/drivers/staging/lustre/lustre/fid/lproc_fid.c b/drivers/staging/lustre/lustre/fid/lproc_fid.c
index 1f0e78686278..81b7ca9ea2fd 100644
--- a/drivers/staging/lustre/lustre/fid/lproc_fid.c
+++ b/drivers/staging/lustre/lustre/fid/lproc_fid.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/fld/fld_cache.c b/drivers/staging/lustre/lustre/fld/fld_cache.c
index 5a04e99d9249..0100a935f4ff 100644
--- a/drivers/staging/lustre/lustre/fld/fld_cache.c
+++ b/drivers/staging/lustre/lustre/fld/fld_cache.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/fld/fld_internal.h b/drivers/staging/lustre/lustre/fld/fld_internal.h
index 75d6a48637a9..f0efe5b9fbec 100644
--- a/drivers/staging/lustre/lustre/fld/fld_internal.h
+++ b/drivers/staging/lustre/lustre/fld/fld_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/fld/fld_request.c b/drivers/staging/lustre/lustre/fld/fld_request.c
index 304c0ec268c9..e59d626a1548 100644
--- a/drivers/staging/lustre/lustre/fld/fld_request.c
+++ b/drivers/staging/lustre/lustre/fld/fld_request.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/fld/lproc_fld.c b/drivers/staging/lustre/lustre/fld/lproc_fld.c
index ca898befeba6..61ac420798af 100644
--- a/drivers/staging/lustre/lustre/fld/lproc_fld.c
+++ b/drivers/staging/lustre/lustre/fld/lproc_fld.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/cl_object.h b/drivers/staging/lustre/lustre/include/cl_object.h
index d4c33dd110ab..36ca93548e80 100644
--- a/drivers/staging/lustre/lustre/include/cl_object.h
+++ b/drivers/staging/lustre/lustre/include/cl_object.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/interval_tree.h b/drivers/staging/lustre/lustre/include/interval_tree.h
index f6df3f33e770..4a15228b5570 100644
--- a/drivers/staging/lustre/lustre/include/interval_tree.h
+++ b/drivers/staging/lustre/lustre/include/interval_tree.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/linux/lustre_compat25.h b/drivers/staging/lustre/lustre/include/linux/lustre_compat25.h
index 79d8f93075d1..1eb64ec4bed4 100644
--- a/drivers/staging/lustre/lustre/include/linux/lustre_compat25.h
+++ b/drivers/staging/lustre/lustre/include/linux/lustre_compat25.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/linux/lustre_lite.h b/drivers/staging/lustre/lustre/include/linux/lustre_lite.h
index 3420cfd1278d..d18e8a76bb25 100644
--- a/drivers/staging/lustre/lustre/include/linux/lustre_lite.h
+++ b/drivers/staging/lustre/lustre/include/linux/lustre_lite.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/linux/lustre_patchless_compat.h b/drivers/staging/lustre/lustre/include/linux/lustre_patchless_compat.h
index c6c7f54637fb..5842cb18b49e 100644
--- a/drivers/staging/lustre/lustre/include/linux/lustre_patchless_compat.h
+++ b/drivers/staging/lustre/lustre/include/linux/lustre_patchless_compat.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/linux/lustre_user.h b/drivers/staging/lustre/lustre/include/linux/lustre_user.h
index 9cc2849f3f85..e967950e8536 100644
--- a/drivers/staging/lustre/lustre/include/linux/lustre_user.h
+++ b/drivers/staging/lustre/lustre/include/linux/lustre_user.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lprocfs_status.h b/drivers/staging/lustre/lustre/include/lprocfs_status.h
index 4146c9c3999f..d68e60e7fef7 100644
--- a/drivers/staging/lustre/lustre/include/lprocfs_status.h
+++ b/drivers/staging/lustre/lustre/include/lprocfs_status.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lu_object.h b/drivers/staging/lustre/lustre/include/lu_object.h
index 2816512185af..c6281e61beed 100644
--- a/drivers/staging/lustre/lustre/include/lu_object.h
+++ b/drivers/staging/lustre/lustre/include/lu_object.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre/ll_fiemap.h b/drivers/staging/lustre/lustre/include/lustre/ll_fiemap.h
index 07d45de69dd9..c2340d643e84 100644
--- a/drivers/staging/lustre/lustre/include/lustre/ll_fiemap.h
+++ b/drivers/staging/lustre/lustre/include/lustre/ll_fiemap.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h b/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
index 9c53c1792dc8..fac7215cb2ba 100644
--- a/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
+++ b/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -386,7 +382,7 @@ static inline __u64 fid_ver_oid(const struct lu_fid *fid)
  * used for other purposes and not risk collisions with existing inodes.
  *
  * Different FID Format
- * http://arch.lustre.org/index.php?title=Interoperability_fids_zfs#NEW.0
+ * http://wiki.old.lustre.org/index.php/Architecture_-_Interoperability_fids_zfs
  */
 enum fid_seq {
         FID_SEQ_OST_MDT0        = 0,
@@ -704,7 +700,7 @@ static inline int fid_set_id(struct lu_fid *fid, __u64 oid)
  * be passed through unchanged.  Only legacy OST objects in "group 0"
  * will be mapped into the IDIF namespace so that they can fit into the
  * struct lu_fid fields without loss.  For reference see:
- * http://arch.lustre.org/index.php?title=Interoperability_fids_zfs
+ * http://wiki.old.lustre.org/index.php/Architecture_-_Interoperability_fids_zfs
  */
 static inline int ostid_to_fid(struct lu_fid *fid, struct ost_id *ostid,
                                __u32 ost_idx)
diff --git a/drivers/staging/lustre/lustre/include/lustre/lustre_user.h b/drivers/staging/lustre/lustre/include/lustre/lustre_user.h
index 59ba48ac31a7..a6e351a95466 100644
--- a/drivers/staging/lustre/lustre/include/lustre/lustre_user.h
+++ b/drivers/staging/lustre/lustre/include/lustre/lustre_user.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_acl.h b/drivers/staging/lustre/lustre/include/lustre_acl.h
index aa4cfa7b749d..fecabe139b1f 100644
--- a/drivers/staging/lustre/lustre/include/lustre_acl.h
+++ b/drivers/staging/lustre/lustre/include/lustre_acl.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_cfg.h b/drivers/staging/lustre/lustre/include/lustre_cfg.h
index e229e91f7f56..95a0be13c0fb 100644
--- a/drivers/staging/lustre/lustre/include/lustre_cfg.h
+++ b/drivers/staging/lustre/lustre/include/lustre_cfg.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_debug.h b/drivers/staging/lustre/lustre/include/lustre_debug.h
index 8a089413c92e..93c1bdaf71a4 100644
--- a/drivers/staging/lustre/lustre/include/lustre_debug.h
+++ b/drivers/staging/lustre/lustre/include/lustre_debug.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_disk.h b/drivers/staging/lustre/lustre/include/lustre_disk.h
index b36821ffb252..8886458748c1 100644
--- a/drivers/staging/lustre/lustre/include/lustre_disk.h
+++ b/drivers/staging/lustre/lustre/include/lustre_disk.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_dlm.h b/drivers/staging/lustre/lustre/include/lustre_dlm.h
index 9cade144faca..63085a0e504f 100644
--- a/drivers/staging/lustre/lustre/include/lustre_dlm.h
+++ b/drivers/staging/lustre/lustre/include/lustre_dlm.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_eacl.h b/drivers/staging/lustre/lustre/include/lustre_eacl.h
index 0b66593a9526..e5eadc4d4ce0 100644
--- a/drivers/staging/lustre/lustre/include/lustre_eacl.h
+++ b/drivers/staging/lustre/lustre/include/lustre_eacl.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_export.h b/drivers/staging/lustre/lustre/include/lustre_export.h
index 3014d27e6dc2..7c3ed55b3834 100644
--- a/drivers/staging/lustre/lustre/include/lustre_export.h
+++ b/drivers/staging/lustre/lustre/include/lustre_export.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_fid.h b/drivers/staging/lustre/lustre/include/lustre_fid.h
index 12e8b585c2b4..743671a547ef 100644
--- a/drivers/staging/lustre/lustre/include/lustre_fid.h
+++ b/drivers/staging/lustre/lustre/include/lustre_fid.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -45,7 +41,7 @@
  *
  * @{
  *
- * http://wiki.lustre.org/index.php/Architecture_-_Interoperability_fids_zfs
+ * http://wiki.old.lustre.org/index.php/Architecture_-_Interoperability_fids_zfs
  * describes the FID namespace and interoperability requirements for FIDs.
  * The important parts of that document are included here for reference.
  *
diff --git a/drivers/staging/lustre/lustre/include/lustre_fld.h b/drivers/staging/lustre/lustre/include/lustre_fld.h
index 4cf2b0e61672..932410d3e3cc 100644
--- a/drivers/staging/lustre/lustre/include/lustre_fld.h
+++ b/drivers/staging/lustre/lustre/include/lustre_fld.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_ha.h b/drivers/staging/lustre/lustre/include/lustre_ha.h
index 5488a698dabd..cde7ed702c86 100644
--- a/drivers/staging/lustre/lustre/include/lustre_ha.h
+++ b/drivers/staging/lustre/lustre/include/lustre_ha.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_handles.h b/drivers/staging/lustre/lustre/include/lustre_handles.h
index 27f169d2ed34..1a63a6b9e116 100644
--- a/drivers/staging/lustre/lustre/include/lustre_handles.h
+++ b/drivers/staging/lustre/lustre/include/lustre_handles.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_import.h b/drivers/staging/lustre/lustre/include/lustre_import.h
index 8325c82b3ebf..4445be7a59dd 100644
--- a/drivers/staging/lustre/lustre/include/lustre_import.h
+++ b/drivers/staging/lustre/lustre/include/lustre_import.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_intent.h b/drivers/staging/lustre/lustre/include/lustre_intent.h
index c491d52d86a2..fdc6236f52d9 100644
--- a/drivers/staging/lustre/lustre/include/lustre_intent.h
+++ b/drivers/staging/lustre/lustre/include/lustre_intent.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_lib.h b/drivers/staging/lustre/lustre/include/lustre_lib.h
index 00b976766aef..06958f217fc8 100644
--- a/drivers/staging/lustre/lustre/include/lustre_lib.h
+++ b/drivers/staging/lustre/lustre/include/lustre_lib.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_lite.h b/drivers/staging/lustre/lustre/include/lustre_lite.h
index fcc5ebbceed8..b16897702559 100644
--- a/drivers/staging/lustre/lustre/include/lustre_lite.h
+++ b/drivers/staging/lustre/lustre/include/lustre_lite.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_log.h b/drivers/staging/lustre/lustre/include/lustre_log.h
index 49618e186824..b96e02317bfc 100644
--- a/drivers/staging/lustre/lustre/include/lustre_log.h
+++ b/drivers/staging/lustre/lustre/include/lustre_log.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_mdc.h b/drivers/staging/lustre/lustre/include/lustre_mdc.h
index f267ff8a6ec8..0ef4226da1bb 100644
--- a/drivers/staging/lustre/lustre/include/lustre_mdc.h
+++ b/drivers/staging/lustre/lustre/include/lustre_mdc.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_mds.h b/drivers/staging/lustre/lustre/include/lustre_mds.h
index 95d27ddecfb3..4104bd9bd5c4 100644
--- a/drivers/staging/lustre/lustre/include/lustre_mds.h
+++ b/drivers/staging/lustre/lustre/include/lustre_mds.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_net.h b/drivers/staging/lustre/lustre/include/lustre_net.h
index a7973d5de168..dba4d1d7afac 100644
--- a/drivers/staging/lustre/lustre/include/lustre_net.h
+++ b/drivers/staging/lustre/lustre/include/lustre_net.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_param.h b/drivers/staging/lustre/lustre/include/lustre_param.h
index a42cf90c1cd8..82aadd32c2b8 100644
--- a/drivers/staging/lustre/lustre/include/lustre_param.h
+++ b/drivers/staging/lustre/lustre/include/lustre_param.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_req_layout.h b/drivers/staging/lustre/lustre/include/lustre_req_layout.h
index 0aac4391ea16..d00aae54e849 100644
--- a/drivers/staging/lustre/lustre/include/lustre_req_layout.h
+++ b/drivers/staging/lustre/lustre/include/lustre_req_layout.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/lustre_sec.h b/drivers/staging/lustre/lustre/include/lustre_sec.h
index 01b4e6726a68..90c183424802 100644
--- a/drivers/staging/lustre/lustre/include/lustre_sec.h
+++ b/drivers/staging/lustre/lustre/include/lustre_sec.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -221,13 +217,13 @@ enum sptlrpc_bulk_service {
 
 #define SPTLRPC_FLVR_DEFAULT        SPTLRPC_FLVR_NULL
 
-#define SPTLRPC_FLVR_INVALID        ((__u32) 0xFFFFFFFF)
-#define SPTLRPC_FLVR_ANY                ((__u32) 0xFFF00000)
+#define SPTLRPC_FLVR_INVALID        ((__u32)0xFFFFFFFF)
+#define SPTLRPC_FLVR_ANY                ((__u32)0xFFF00000)
 
 /**
  * extract the useful part from wire flavor
  */
-#define WIRE_FLVR(wflvr)                (((__u32) (wflvr)) & 0x000FFFFF)
+#define WIRE_FLVR(wflvr)                (((__u32)(wflvr)) & 0x000FFFFF)
 
 /** @} flavor */
 
diff --git a/drivers/staging/lustre/lustre/include/obd.h b/drivers/staging/lustre/lustre/include/obd.h
index 2d926e0ee647..e654d42dc8cc 100644
--- a/drivers/staging/lustre/lustre/include/obd.h
+++ b/drivers/staging/lustre/lustre/include/obd.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/obd_cksum.h b/drivers/staging/lustre/lustre/include/obd_cksum.h
index f6c18df906a8..a8a81e662a56 100644
--- a/drivers/staging/lustre/lustre/include/obd_cksum.h
+++ b/drivers/staging/lustre/lustre/include/obd_cksum.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/obd_class.h b/drivers/staging/lustre/lustre/include/obd_class.h
index 32863bcb30b9..21967440b46a 100644
--- a/drivers/staging/lustre/lustre/include/obd_class.h
+++ b/drivers/staging/lustre/lustre/include/obd_class.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/include/obd_support.h b/drivers/staging/lustre/lustre/include/obd_support.h
index 60034d39b00d..cdf20d6470d7 100644
--- a/drivers/staging/lustre/lustre/include/obd_support.h
+++ b/drivers/staging/lustre/lustre/include/obd_support.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/interval_tree.c b/drivers/staging/lustre/lustre/ldlm/interval_tree.c
index 323060626fdf..f4a70ebddeaf 100644
--- a/drivers/staging/lustre/lustre/ldlm/interval_tree.c
+++ b/drivers/staging/lustre/lustre/ldlm/interval_tree.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/l_lock.c b/drivers/staging/lustre/lustre/ldlm/l_lock.c
index 621323f6ee60..ea8840cb9056 100644
--- a/drivers/staging/lustre/lustre/ldlm/l_lock.c
+++ b/drivers/staging/lustre/lustre/ldlm/l_lock.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_extent.c b/drivers/staging/lustre/lustre/ldlm/ldlm_extent.c
index cf1f1783632f..f5023d9b78f5 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_extent.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_extent.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_flock.c b/drivers/staging/lustre/lustre/ldlm/ldlm_flock.c
index 349bfcc9b331..d6b61bc39135 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_flock.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_flock.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -259,14 +255,13 @@ reprocess:
                          * overflow and underflow.
                          */
                         if ((new->l_policy_data.l_flock.start >
-                             (lock->l_policy_data.l_flock.end + 1))
-                            && (lock->l_policy_data.l_flock.end !=
-                                OBD_OBJECT_EOF))
+                             (lock->l_policy_data.l_flock.end + 1)) &&
+                            (lock->l_policy_data.l_flock.end != OBD_OBJECT_EOF))
                                 continue;
 
                         if ((new->l_policy_data.l_flock.end <
-                             (lock->l_policy_data.l_flock.start - 1))
-                            && (lock->l_policy_data.l_flock.start != 0))
+                             (lock->l_policy_data.l_flock.start - 1)) &&
+                            (lock->l_policy_data.l_flock.start != 0))
                                 break;
 
                         if (new->l_policy_data.l_flock.start <
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_inodebits.c b/drivers/staging/lustre/lustre/ldlm/ldlm_inodebits.c
index b1bed1e17d32..79f4e6fa193e 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_inodebits.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_inodebits.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_internal.h b/drivers/staging/lustre/lustre/ldlm/ldlm_internal.h
index 32f227f37799..e4cf65d2d3b1 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_internal.h
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_lib.c b/drivers/staging/lustre/lustre/ldlm/ldlm_lib.c
index b4ffbe2fc4ed..7c832aae7d5e 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_lib.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_lib.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -345,7 +341,8 @@ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg)
          * Set cl_chksum* to CRC32 for now to avoid returning screwed info
          * through procfs.
          */
-        cli->cl_cksum_type = cli->cl_supp_cksum_types = OBD_CKSUM_CRC32;
+        cli->cl_cksum_type = OBD_CKSUM_CRC32;
+        cli->cl_supp_cksum_types = OBD_CKSUM_CRC32;
         atomic_set(&cli->cl_resends, OSC_DEFAULT_RESENDS);
 
         /* This value may be reduced at connect time in
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c b/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
index bff94ea12d6f..1ecdfa2021f5 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_lockd.c b/drivers/staging/lustre/lustre/ldlm/ldlm_lockd.c
index ab739f079a48..3eab0591caa9 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_lockd.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_lockd.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -1011,9 +1007,11 @@ static int ldlm_setup(void)
                 blp->blp_min_threads = LDLM_NTHRS_INIT;
                 blp->blp_max_threads = LDLM_NTHRS_MAX;
         } else {
-                blp->blp_min_threads = blp->blp_max_threads =
-                        min_t(int, LDLM_NTHRS_MAX, max_t(int, LDLM_NTHRS_INIT,
-                                                         ldlm_num_threads));
+                blp->blp_min_threads = min_t(int, LDLM_NTHRS_MAX,
+                                             max_t(int, LDLM_NTHRS_INIT,
+                                                   ldlm_num_threads));
+
+                blp->blp_max_threads = blp->blp_min_threads;
         }
 
         for (i = 0; i < blp->blp_min_threads; i++) {
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_plain.c b/drivers/staging/lustre/lustre/ldlm/ldlm_plain.c
index 0c1965ddabb9..0aed39c46154 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_plain.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_plain.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c b/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
index b913ba9cf97c..657ed4012776 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_request.c b/drivers/staging/lustre/lustre/ldlm/ldlm_request.c
index 107314e284a0..471ab0865a75 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_request.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_request.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_resource.c b/drivers/staging/lustre/lustre/ldlm/ldlm_resource.c
index e99c89c34cd0..f7c95b7ebe92 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_resource.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_resource.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/Makefile b/drivers/staging/lustre/lustre/llite/Makefile
index 2ce10ff01b80..19701e781328 100644
--- a/drivers/staging/lustre/lustre/llite/Makefile
+++ b/drivers/staging/lustre/lustre/llite/Makefile
@@ -1,5 +1,4 @@
 obj-$(CONFIG_LUSTRE_FS) += lustre.o
-obj-$(CONFIG_LUSTRE_LLITE_LLOOP) += llite_lloop.o
 lustre-y := dcache.o dir.o file.o llite_close.o llite_lib.o llite_nfs.o \
             rw.o namei.o symlink.o llite_mmap.o \
             xattr.o xattr_cache.o remote_perm.o llite_rmtacl.o \
@@ -7,5 +6,3 @@ lustre-y := dcache.o dir.o file.o llite_close.o llite_lib.o llite_nfs.o \
             glimpse.o lcommon_cl.o lcommon_misc.o \
             vvp_dev.o vvp_page.o vvp_lock.o vvp_io.o vvp_object.o vvp_req.o \
             lproc_llite.o
-
-llite_lloop-y := lloop.o
diff --git a/drivers/staging/lustre/lustre/llite/dcache.c b/drivers/staging/lustre/lustre/llite/dcache.c
index 1b6f82a1a435..9d13d5e933ba 100644
--- a/drivers/staging/lustre/lustre/llite/dcache.c
+++ b/drivers/staging/lustre/lustre/llite/dcache.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/dir.c b/drivers/staging/lustre/lustre/llite/dir.c
index 4b00d1ac84fb..99735f6e9cd6 100644
--- a/drivers/staging/lustre/lustre/llite/dir.c
+++ b/drivers/staging/lustre/lustre/llite/dir.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -1076,17 +1072,11 @@ static int copy_and_ioctl(int cmd, struct obd_export *exp,
         void *copy;
         int rc;
 
-        copy = kzalloc(size, GFP_NOFS);
-        if (!copy)
-                return -ENOMEM;
-
-        if (copy_from_user(copy, data, size)) {
-                rc = -EFAULT;
-                goto out;
-        }
+        copy = memdup_user(data, size);
+        if (IS_ERR(copy))
+                return PTR_ERR(copy);
 
         rc = obd_iocontrol(cmd, exp, size, copy, NULL);
-out:
         kfree(copy);
 
         return rc;
diff --git a/drivers/staging/lustre/lustre/llite/file.c b/drivers/staging/lustre/lustre/llite/file.c
index f47f2acaf90c..b0c4548245dd 100644
--- a/drivers/staging/lustre/lustre/llite/file.c
+++ b/drivers/staging/lustre/lustre/llite/file.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -519,6 +515,11 @@ static int ll_local_open(struct file *file, struct lookup_intent *it,
         LUSTRE_FPRIVATE(file) = fd;
         ll_readahead_init(inode, &fd->fd_ras);
         fd->fd_omode = it->it_flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
+
+        /* ll_cl_context initialize */
+        rwlock_init(&fd->fd_lock);
+        INIT_LIST_HEAD(&fd->fd_lccs);
+
         return 0;
 }
 
@@ -1178,7 +1179,9 @@ restart:
                         CERROR("Unknown IO type - %u\n", vio->vui_io_subtype);
                         LBUG();
                 }
+                ll_cl_add(file, env, io);
                 result = cl_io_loop(env, io);
+                ll_cl_remove(file, env);
                 if (args->via_io_subtype == IO_NORMAL)
                         up_read(&lli->lli_trunc_sem);
                 if (write_mutex_locked)
@@ -1410,7 +1413,7 @@ out_unlock:
 out:
         return rc;
 out_req_free:
-        ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
+        ptlrpc_req_finished((struct ptlrpc_request *)oit.d.lustre.it_data);
         goto out;
 }
 
@@ -3124,6 +3127,9 @@ struct posix_acl *ll_get_acl(struct inode *inode, int type)
         spin_lock(&lli->lli_lock);
         /* VFS' acl_permission_check->check_acl will release the refcount */
         acl = posix_acl_dup(lli->lli_posix_acl);
+#ifdef CONFIG_FS_POSIX_ACL
+        forget_cached_acl(inode, type);
+#endif
         spin_unlock(&lli->lli_lock);
 
         return acl;
diff --git a/drivers/staging/lustre/lustre/llite/glimpse.c b/drivers/staging/lustre/lustre/llite/glimpse.c
index d8ea75424e2f..92004a05f9ee 100644
--- a/drivers/staging/lustre/lustre/llite/glimpse.c
+++ b/drivers/staging/lustre/lustre/llite/glimpse.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/lcommon_cl.c b/drivers/staging/lustre/lustre/llite/lcommon_cl.c
index 6c00715b438f..396e4e4f0715 100644
--- a/drivers/staging/lustre/lustre/llite/lcommon_cl.c
+++ b/drivers/staging/lustre/lustre/llite/lcommon_cl.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/lcommon_misc.c b/drivers/staging/lustre/lustre/llite/lcommon_misc.c
index 12f3e71f48c2..8a508ed1136d 100644
--- a/drivers/staging/lustre/lustre/llite/lcommon_misc.c
+++ b/drivers/staging/lustre/lustre/llite/lcommon_misc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/llite_close.c b/drivers/staging/lustre/lustre/llite/llite_close.c
index 2df551d3ae6c..2326b40a0870 100644
--- a/drivers/staging/lustre/lustre/llite/llite_close.c
+++ b/drivers/staging/lustre/lustre/llite/llite_close.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/llite_internal.h b/drivers/staging/lustre/lustre/llite/llite_internal.h
index 3f2f30b6542c..7c1a3254a24e 100644
--- a/drivers/staging/lustre/lustre/llite/llite_internal.h
+++ b/drivers/staging/lustre/lustre/llite/llite_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -640,6 +636,8 @@ struct ll_file_data {
          * false: unknown failure, should report.
          */
         bool fd_write_failed;
+        rwlock_t fd_lock; /* protect lcc list */
+        struct list_head fd_lccs; /* list of ll_cl_context */
 };
 
 struct lov_stripe_md;
@@ -715,8 +713,9 @@ void ll_readahead_init(struct inode *inode, struct ll_readahead_state *ras);
 int ll_readahead(const struct lu_env *env, struct cl_io *io,
                  struct cl_page_list *queue, struct ll_readahead_state *ras,
                  bool hit);
-struct ll_cl_context *ll_cl_init(struct file *file, struct page *vmpage);
-void ll_cl_fini(struct ll_cl_context *lcc);
+struct ll_cl_context *ll_cl_find(struct file *file);
+void ll_cl_add(struct file *file, const struct lu_env *env, struct cl_io *io);
+void ll_cl_remove(struct file *file, const struct lu_env *env);
 
 extern const struct address_space_operations ll_aops;
 
@@ -858,11 +857,11 @@ struct vvp_io_args {
 };
 
 struct ll_cl_context {
+        struct list_head         lcc_list;
         void       *lcc_cookie;
+        const struct lu_env     *lcc_env;
         struct cl_io   *lcc_io;
         struct cl_page *lcc_page;
-        struct lu_env  *lcc_env;
-        int          lcc_refcheck;
 };
 
 struct ll_thread_info {
diff --git a/drivers/staging/lustre/lustre/llite/llite_lib.c b/drivers/staging/lustre/lustre/llite/llite_lib.c
index 96c7e9fc6e5f..ac833dbeb6e6 100644
--- a/drivers/staging/lustre/lustre/llite/llite_lib.c
+++ b/drivers/staging/lustre/lustre/llite/llite_lib.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -864,7 +860,8 @@ int ll_fill_super(struct super_block *sb, struct vfsmount *mnt)
         try_module_get(THIS_MODULE);
 
         /* client additional sb info */
-        lsi->lsi_llsbi = sbi = ll_init_sbi(sb);
+        sbi = ll_init_sbi(sb);
+        lsi->lsi_llsbi = sbi;
         if (!sbi) {
                 module_put(THIS_MODULE);
                 kfree(cfg);
diff --git a/drivers/staging/lustre/lustre/llite/llite_mmap.c b/drivers/staging/lustre/lustre/llite/llite_mmap.c
index 88ef1cac9e0f..fb1c3b613f59 100644
--- a/drivers/staging/lustre/lustre/llite/llite_mmap.c
+++ b/drivers/staging/lustre/lustre/llite/llite_mmap.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -315,8 +311,13 @@ static int ll_fault0(struct vm_area_struct *vma, struct vm_fault *vmf)
                 vio->u.fault.ft_flags = 0;
                 vio->u.fault.ft_flags_valid = false;
 
+                /* May call ll_readpage() */
+                ll_cl_add(vma->vm_file, env, io);
+
                 result = cl_io_loop(env, io);
 
+                ll_cl_remove(vma->vm_file, env);
+
                 /* ft_flags are only valid if we reached
                  * the call to filemap_fault
                  */
diff --git a/drivers/staging/lustre/lustre/llite/llite_nfs.c b/drivers/staging/lustre/lustre/llite/llite_nfs.c
index c1eef6198b25..d7878e504aca 100644
--- a/drivers/staging/lustre/lustre/llite/llite_nfs.c
+++ b/drivers/staging/lustre/lustre/llite/llite_nfs.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/llite_rmtacl.c b/drivers/staging/lustre/lustre/llite/llite_rmtacl.c
index 8509b07cb5c7..edb92f9f2d70 100644
--- a/drivers/staging/lustre/lustre/llite/llite_rmtacl.c
+++ b/drivers/staging/lustre/lustre/llite/llite_rmtacl.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/lloop.c b/drivers/staging/lustre/lustre/llite/lloop.c
deleted file mode 100644
index 813a9a354e5f..000000000000
--- a/drivers/staging/lustre/lustre/llite/lloop.c
+++ /dev/null
@@ -1,883 +0,0 @@
-/*
- * GPL HEADER START
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 only,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License version 2 for more details (a copy is included
- * in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU General Public License
- * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- *
- * GPL HEADER END
- */
-/*
- * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
- * Use is subject to license terms.
- *
- * Copyright (c) 2011, 2012, Intel Corporation.
- */
-/*
- * This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
- */
-
-/*
- *  linux/drivers/block/loop.c
- *
- *  Written by Theodore Ts'o, 3/29/93
- *
- * Copyright 1993 by Theodore Ts'o.  Redistribution of this file is
- * permitted under the GNU General Public License.
- *
- * Modularized and updated for 1.1.16 kernel - Mitch Dsouza 28th May 1994
- * Adapted for 1.3.59 kernel - Andries Brouwer, 1 Feb 1996
- *
- * Fixed do_loop_request() re-entrancy - Vincent.Renardias@waw.com Mar 20, 1997
- *
- * Added devfs support - Richard Gooch <rgooch@atnf.csiro.au> 16-Jan-1998
- *
- * Handle sparse backing files correctly - Kenn Humborg, Jun 28, 1998
- *
- * Loadable modules and other fixes by AK, 1998
- *
- * Maximum number of loop devices now dynamic via max_loop module parameter.
- * Russell Kroll <rkroll@exploits.org> 19990701
- *
- * Maximum number of loop devices when compiled-in now selectable by passing
- * max_loop=<1-255> to the kernel on boot.
- * Erik I. Bols?, <eriki@himolde.no>, Oct 31, 1999
- *
- * Completely rewrite request handling to be make_request_fn style and
- * non blocking, pushing work to a helper thread. Lots of fixes from
- * Al Viro too.
- * Jens Axboe <axboe@suse.de>, Nov 2000
- *
- * Support up to 256 loop devices
- * Heinz Mauelshagen <mge@sistina.com>, Feb 2002
- *
- * Support for falling back on the write file operation when the address space
- * operations prepare_write and/or commit_write are not available on the
- * backing filesystem.
- * Anton Altaparmakov, 16 Feb 2005
- *
- * Still To Fix:
- * - Advisory locking is ignored here.
- * - Should use an own CAP_* category instead of CAP_SYS_ADMIN
- *
- */
-
-#include <linux/module.h>
-
-#include <linux/sched.h>
-#include <linux/fs.h>
-#include <linux/file.h>
-#include <linux/stat.h>
-#include <linux/errno.h>
-#include <linux/major.h>
-#include <linux/wait.h>
-#include <linux/blkdev.h>
-#include <linux/blkpg.h>
-#include <linux/init.h>
-#include <linux/swap.h>
-#include <linux/slab.h>
-#include <linux/suspend.h>
-#include <linux/writeback.h>
-#include <linux/buffer_head.h>          /* for invalidate_bdev() */
-#include <linux/completion.h>
-#include <linux/highmem.h>
-#include <linux/gfp.h>
-#include <linux/pagevec.h>
-#include <linux/uaccess.h>
-
-#include "../include/lustre_lib.h"
-#include "../include/lustre_lite.h"
-#include "llite_internal.h"
-
-#define LLOOP_MAX_SEGMENTS      LNET_MAX_IOV
-
-/* Possible states of device */
-enum {
-        LLOOP_UNBOUND,
-        LLOOP_BOUND,
-        LLOOP_RUNDOWN,
-};
-
-struct lloop_device {
-        int               lo_number;
-        int               lo_refcnt;
-        loff_t         lo_offset;
-        loff_t         lo_sizelimit;
-        int               lo_flags;
-        struct file      *lo_backing_file;
-        struct block_device *lo_device;
-        unsigned             lo_blocksize;
-
-        gfp_t             old_gfp_mask;
-
-        spinlock_t              lo_lock;
-        struct bio              *lo_bio;
-        struct bio              *lo_biotail;
-        int                     lo_state;
-        struct semaphore        lo_sem;
-        struct mutex            lo_ctl_mutex;
-        atomic_t         lo_pending;
-        wait_queue_head_t         lo_bh_wait;
-
-        struct request_queue *lo_queue;
-
-        const struct lu_env *lo_env;
-        struct cl_io     lo_io;
-        struct ll_dio_pages  lo_pvec;
-
-        /* data to handle bio for lustre. */
-        struct lo_request_data {
-                struct page *lrd_pages[LLOOP_MAX_SEGMENTS];
-                loff_t       lrd_offsets[LLOOP_MAX_SEGMENTS];
-        } lo_requests[1];
-};
-
-/*
- * Loop flags
- */
-enum {
-        LO_FLAGS_READ_ONLY       = 1,
-};
-
-static int lloop_major;
-#define MAX_LOOP_DEFAULT  16
-static int max_loop = MAX_LOOP_DEFAULT;
-static struct lloop_device *loop_dev;
-static struct gendisk **disks;
-static struct mutex lloop_mutex;
-static void *ll_iocontrol_magic;
-
-static loff_t get_loop_size(struct lloop_device *lo, struct file *file)
-{
-        loff_t size, offset, loopsize;
-
-        /* Compute loopsize in bytes */
-        size = i_size_read(file->f_mapping->host);
-        offset = lo->lo_offset;
-        loopsize = size - offset;
-        if (lo->lo_sizelimit > 0 && lo->lo_sizelimit < loopsize)
-                loopsize = lo->lo_sizelimit;
-
-        /*
-         * Unfortunately, if we want to do I/O on the device,
-         * the number of 512-byte sectors has to fit into a sector_t.
-         */
-        return loopsize >> 9;
-}
-
-static int do_bio_lustrebacked(struct lloop_device *lo, struct bio *head)
-{
-        const struct lu_env  *env   = lo->lo_env;
-        struct cl_io     *io    = &lo->lo_io;
-        struct inode     *inode = file_inode(lo->lo_backing_file);
-        struct cl_object     *obj = ll_i2info(inode)->lli_clob;
-        pgoff_t        offset;
-        int                ret;
-        int                rw;
-        u32                page_count = 0;
-        struct bio_vec       bvec;
-        struct bvec_iter   iter;
-        struct bio         *bio;
-        ssize_t        bytes;
-
-        struct ll_dio_pages  *pvec = &lo->lo_pvec;
-        struct page      **pages = pvec->ldp_pages;
-        loff_t         *offsets = pvec->ldp_offsets;
-
-        truncate_inode_pages(inode->i_mapping, 0);
-
-        /* initialize the IO */
-        memset(io, 0, sizeof(*io));
-        io->ci_obj = obj;
-        ret = cl_io_init(env, io, CIT_MISC, obj);
-        if (ret)
-                return io->ci_result;
-        io->ci_lockreq = CILR_NEVER;
-
-        rw = head->bi_rw;
-        for (bio = head; bio ; bio = bio->bi_next) {
-                LASSERT(rw == bio->bi_rw);
-
-                offset = (pgoff_t)(bio->bi_iter.bi_sector << 9) + lo->lo_offset;
-                bio_for_each_segment(bvec, bio, iter) {
-                        BUG_ON(bvec.bv_offset != 0);
-                        BUG_ON(bvec.bv_len != PAGE_SIZE);
-
-                        pages[page_count] = bvec.bv_page;
-                        offsets[page_count] = offset;
-                        page_count++;
-                        offset += bvec.bv_len;
-                }
-                LASSERT(page_count <= LLOOP_MAX_SEGMENTS);
-        }
-
-        ll_stats_ops_tally(ll_i2sbi(inode),
-                        (rw == WRITE) ? LPROC_LL_BRW_WRITE : LPROC_LL_BRW_READ,
-                        page_count);
-
-        pvec->ldp_size = page_count << PAGE_SHIFT;
-        pvec->ldp_nr = page_count;
-
-        /* FIXME: in ll_direct_rw_pages, it has to allocate many cl_page{}s to
-         * write those pages into OST. Even worse case is that more pages
-         * would be asked to write out to swap space, and then finally get here
-         * again.
-         * Unfortunately this is NOT easy to fix.
-         * Thoughts on solution:
-         * 0. Define a reserved pool for cl_pages, which could be a list of
-         *    pre-allocated cl_pages;
-         * 1. Define a new operation in cl_object_operations{}, says clo_depth,
-         *    which measures how many layers for this lustre object. Generally
-         *    speaking, the depth would be 2, one for llite, and one for lovsub.
-         *    However, for SNS, there will be more since we need additional page
-         *    to store parity;
-         * 2. Reserve the # of (page_count * depth) cl_pages from the reserved
-         *    pool. Afterwards, the clio would allocate the pages from reserved
-         *    pool, this guarantees we needn't allocate the cl_pages from
-         *    generic cl_page slab cache.
-         *    Of course, if there is NOT enough pages in the pool, we might
-         *    be asked to write less pages once, this purely depends on
-         *    implementation. Anyway, we should be careful to avoid deadlocking.
-         */
-        inode_lock(inode);
-        bytes = ll_direct_rw_pages(env, io, rw, inode, pvec);
-        inode_unlock(inode);
-        cl_io_fini(env, io);
-        return (bytes == pvec->ldp_size) ? 0 : (int)bytes;
-}
-
-/*
- * Add bio to back of pending list
- */
-static void loop_add_bio(struct lloop_device *lo, struct bio *bio)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&lo->lo_lock, flags);
-        if (lo->lo_biotail) {
-                lo->lo_biotail->bi_next = bio;
-                lo->lo_biotail = bio;
-        } else {
-                lo->lo_bio = lo->lo_biotail = bio;
-        }
-        spin_unlock_irqrestore(&lo->lo_lock, flags);
-
-        atomic_inc(&lo->lo_pending);
-        if (waitqueue_active(&lo->lo_bh_wait))
-                wake_up(&lo->lo_bh_wait);
-}
-
-/*
- * Grab first pending buffer
- */
-static unsigned int loop_get_bio(struct lloop_device *lo, struct bio **req)
-{
-        struct bio *first;
-        struct bio **bio;
-        unsigned int count = 0;
-        unsigned int page_count = 0;
-        int rw;
-
-        spin_lock_irq(&lo->lo_lock);
-        first = lo->lo_bio;
-        if (unlikely(!first)) {
-                spin_unlock_irq(&lo->lo_lock);
-                return 0;
-        }
-
-        /* TODO: need to split the bio, too bad. */
-        LASSERT(first->bi_vcnt <= LLOOP_MAX_SEGMENTS);
-
-        rw = first->bi_rw;
-        bio = &lo->lo_bio;
-        while (*bio && (*bio)->bi_rw == rw) {
-                CDEBUG(D_INFO, "bio sector %llu size %u count %u vcnt%u\n",
-                       (unsigned long long)(*bio)->bi_iter.bi_sector,
-                       (*bio)->bi_iter.bi_size,
-                       page_count, (*bio)->bi_vcnt);
-                if (page_count + (*bio)->bi_vcnt > LLOOP_MAX_SEGMENTS)
-                        break;
-
-                page_count += (*bio)->bi_vcnt;
-                count++;
-                bio = &(*bio)->bi_next;
-        }
-        if (*bio) {
-                /* Some of bios can't be mergeable. */
-                lo->lo_bio = *bio;
-                *bio = NULL;
-        } else {
-                /* Hit the end of queue */
-                lo->lo_biotail = NULL;
-                lo->lo_bio = NULL;
-        }
-        *req = first;
-        spin_unlock_irq(&lo->lo_lock);
-        return count;
-}
-
-static blk_qc_t loop_make_request(struct request_queue *q, struct bio *old_bio)
-{
-        struct lloop_device *lo = q->queuedata;
-        int rw = bio_rw(old_bio);
-        int inactive;
-
-        blk_queue_split(q, &old_bio, q->bio_split);
-
-        if (!lo)
-                goto err;
-
-        CDEBUG(D_INFO, "submit bio sector %llu size %u\n",
-               (unsigned long long)old_bio->bi_iter.bi_sector,
-               old_bio->bi_iter.bi_size);
-
-        spin_lock_irq(&lo->lo_lock);
-        inactive = lo->lo_state != LLOOP_BOUND;
-        spin_unlock_irq(&lo->lo_lock);
-        if (inactive)
-                goto err;
-
-        if (rw == WRITE) {
-                if (lo->lo_flags & LO_FLAGS_READ_ONLY)
-                        goto err;
-        } else if (rw == READA) {
-                rw = READ;
-        } else if (rw != READ) {
-                CERROR("lloop: unknown command (%x)\n", rw);
-                goto err;
-        }
-        loop_add_bio(lo, old_bio);
-        return BLK_QC_T_NONE;
-err:
-        bio_io_error(old_bio);
-        return BLK_QC_T_NONE;
-}
-
-static inline void loop_handle_bio(struct lloop_device *lo, struct bio *bio)
-{
-        int ret;
-
-        ret = do_bio_lustrebacked(lo, bio);
-        while (bio) {
-                struct bio *tmp = bio->bi_next;
-
-                bio->bi_next = NULL;
-                bio->bi_error = ret;
-                bio_endio(bio);
-                bio = tmp;
-        }
-}
-
-static inline int loop_active(struct lloop_device *lo)
-{
-        return atomic_read(&lo->lo_pending) ||
-                (lo->lo_state == LLOOP_RUNDOWN);
-}
-
-/*
- * worker thread that handles reads/writes to file backed loop devices,
- * to avoid blocking in our make_request_fn.
- */
-static int loop_thread(void *data)
-{
-        struct lloop_device *lo = data;
-        struct bio *bio;
-        unsigned int count;
-        unsigned long times = 0;
-        unsigned long total_count = 0;
-
-        struct lu_env *env;
-        int refcheck;
-        int ret = 0;
-
-        set_user_nice(current, MIN_NICE);
-
-        lo->lo_state = LLOOP_BOUND;
-
-        env = cl_env_get(&refcheck);
-        if (IS_ERR(env)) {
-                ret = PTR_ERR(env);
-                goto out;
-        }
-
-        lo->lo_env = env;
-        memset(&lo->lo_pvec, 0, sizeof(lo->lo_pvec));
-        lo->lo_pvec.ldp_pages   = lo->lo_requests[0].lrd_pages;
-        lo->lo_pvec.ldp_offsets = lo->lo_requests[0].lrd_offsets;
-
-        /*
-         * up sem, we are running
-         */
-        up(&lo->lo_sem);
-
-        for (;;) {
-                wait_event(lo->lo_bh_wait, loop_active(lo));
-                if (!atomic_read(&lo->lo_pending)) {
-                        int exiting = 0;
-
-                        spin_lock_irq(&lo->lo_lock);
-                        exiting = (lo->lo_state == LLOOP_RUNDOWN);
-                        spin_unlock_irq(&lo->lo_lock);
-                        if (exiting)
-                                break;
-                }
-
-                bio = NULL;
-                count = loop_get_bio(lo, &bio);
-                if (!count) {
-                        CWARN("lloop(minor: %d): missing bio\n", lo->lo_number);
-                        continue;
-                }
-
-                total_count += count;
-                if (total_count < count) {     /* overflow */
-                        total_count = count;
-                        times = 1;
-                } else {
-                        times++;
-                }
-                if ((times & 127) == 0) {
-                        CDEBUG(D_INFO, "total: %lu, count: %lu, avg: %lu\n",
-                               total_count, times, total_count / times);
-                }
-
-                LASSERT(bio);
-                LASSERT(count <= atomic_read(&lo->lo_pending));
-                loop_handle_bio(lo, bio);
-                atomic_sub(count, &lo->lo_pending);
-        }
-        cl_env_put(env, &refcheck);
-
-out:
-        up(&lo->lo_sem);
-        return ret;
-}
-
-static int loop_set_fd(struct lloop_device *lo, struct file *unused,
-                       struct block_device *bdev, struct file *file)
-{
-        struct inode     *inode;
-        struct address_space *mapping;
-        int                lo_flags = 0;
-        int                error;
-        loff_t          size;
-
-        if (!try_module_get(THIS_MODULE))
-                return -ENODEV;
-
-        error = -EBUSY;
-        if (lo->lo_state != LLOOP_UNBOUND)
-                goto out;
-
-        mapping = file->f_mapping;
-        inode = mapping->host;
-
-        error = -EINVAL;
-        if (!S_ISREG(inode->i_mode) || inode->i_sb->s_magic != LL_SUPER_MAGIC)
-                goto out;
-
-        if (!(file->f_mode & FMODE_WRITE))
-                lo_flags |= LO_FLAGS_READ_ONLY;
-
-        size = get_loop_size(lo, file);
-
-        if ((loff_t)(sector_t)size != size) {
-                error = -EFBIG;
-                goto out;
-        }
-
-        /* remove all pages in cache so as dirty pages not to be existent. */
-        truncate_inode_pages(mapping, 0);
-
-        set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0);
-
-        lo->lo_blocksize = PAGE_SIZE;
-        lo->lo_device = bdev;
-        lo->lo_flags = lo_flags;
-        lo->lo_backing_file = file;
-        lo->lo_sizelimit = 0;
-        lo->old_gfp_mask = mapping_gfp_mask(mapping);
-        mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
-
-        lo->lo_bio = lo->lo_biotail = NULL;
-
-        /*
-         * set queue make_request_fn, and add limits based on lower level
-         * device
-         */
-        blk_queue_make_request(lo->lo_queue, loop_make_request);
-        lo->lo_queue->queuedata = lo;
-
-        /* queue parameters */
-        CLASSERT(PAGE_SIZE < (1 << (sizeof(unsigned short) * 8)));
-        blk_queue_logical_block_size(lo->lo_queue,
-                                     (unsigned short)PAGE_SIZE);
-        blk_queue_max_hw_sectors(lo->lo_queue,
-                                 LLOOP_MAX_SEGMENTS << (PAGE_SHIFT - 9));
-        blk_queue_max_segments(lo->lo_queue, LLOOP_MAX_SEGMENTS);
-
-        set_capacity(disks[lo->lo_number], size);
-        bd_set_size(bdev, size << 9);
-
-        set_blocksize(bdev, lo->lo_blocksize);
-
-        kthread_run(loop_thread, lo, "lloop%d", lo->lo_number);
-        down(&lo->lo_sem);
-        return 0;
-
-out:
-        /* This is safe: open() is still holding a reference. */
-        module_put(THIS_MODULE);
-        return error;
-}
-
-static int loop_clr_fd(struct lloop_device *lo, struct block_device *bdev,
-                       int count)
-{
-        struct file *filp = lo->lo_backing_file;
-        gfp_t gfp = lo->old_gfp_mask;
-
-        if (lo->lo_state != LLOOP_BOUND)
-                return -ENXIO;
-
-        if (lo->lo_refcnt > count)      /* we needed one fd for the ioctl */
-                return -EBUSY;
-
-        if (!filp)
-                return -EINVAL;
-
-        spin_lock_irq(&lo->lo_lock);
-        lo->lo_state = LLOOP_RUNDOWN;
-        spin_unlock_irq(&lo->lo_lock);
-        wake_up(&lo->lo_bh_wait);
-
-        down(&lo->lo_sem);
-        lo->lo_backing_file = NULL;
-        lo->lo_device = NULL;
-        lo->lo_offset = 0;
-        lo->lo_sizelimit = 0;
-        lo->lo_flags = 0;
-        invalidate_bdev(bdev);
-        set_capacity(disks[lo->lo_number], 0);
-        bd_set_size(bdev, 0);
-        mapping_set_gfp_mask(filp->f_mapping, gfp);
-        lo->lo_state = LLOOP_UNBOUND;
-        fput(filp);
-        /* This is safe: open() is still holding a reference. */
-        module_put(THIS_MODULE);
-        return 0;
-}
-
-static int lo_open(struct block_device *bdev, fmode_t mode)
-{
-        struct lloop_device *lo = bdev->bd_disk->private_data;
-
-        mutex_lock(&lo->lo_ctl_mutex);
-        lo->lo_refcnt++;
-        mutex_unlock(&lo->lo_ctl_mutex);
-
-        return 0;
-}
-
-static void lo_release(struct gendisk *disk, fmode_t mode)
-{
-        struct lloop_device *lo = disk->private_data;
-
-        mutex_lock(&lo->lo_ctl_mutex);
-        --lo->lo_refcnt;
-        mutex_unlock(&lo->lo_ctl_mutex);
-}
-
-/* lloop device node's ioctl function. */
-static int lo_ioctl(struct block_device *bdev, fmode_t mode,
-                    unsigned int cmd, unsigned long arg)
-{
-        struct lloop_device *lo = bdev->bd_disk->private_data;
-        struct inode *inode = NULL;
-        int err = 0;
-
-        mutex_lock(&lloop_mutex);
-        switch (cmd) {
-        case LL_IOC_LLOOP_DETACH: {
-                err = loop_clr_fd(lo, bdev, 2);
-                if (err == 0)
-                        blkdev_put(bdev, 0); /* grabbed in LLOOP_ATTACH */
-                break;
-        }
-
-        case LL_IOC_LLOOP_INFO: {
-                struct lu_fid fid;
-
-                if (!lo->lo_backing_file) {
-                        err = -ENOENT;
-                        break;
-                }
-                if (!inode)
-                        inode = file_inode(lo->lo_backing_file);
-                if (lo->lo_state == LLOOP_BOUND)
-                        fid = ll_i2info(inode)->lli_fid;
-                else
-                        fid_zero(&fid);
-
-                if (copy_to_user((void __user *)arg, &fid, sizeof(fid)))
-                        err = -EFAULT;
-                break;
-        }
-
-        default:
-                err = -EINVAL;
-                break;
-        }
-        mutex_unlock(&lloop_mutex);
-
-        return err;
-}
-
-static struct block_device_operations lo_fops = {
-        .owner =        THIS_MODULE,
-        .open =  lo_open,
-        .release =      lo_release,
-        .ioctl =        lo_ioctl,
-};
-
-/* dynamic iocontrol callback.
- * This callback is registered in lloop_init and will be called by
- * ll_iocontrol_call.
- *
- * This is a llite regular file ioctl function. It takes the responsibility
- * of attaching or detaching a file by a lloop's device number.
- */
-static enum llioc_iter lloop_ioctl(struct inode *unused, struct file *file,
-                                   unsigned int cmd, unsigned long arg,
-                                   void *magic, int *rcp)
-{
-        struct lloop_device *lo = NULL;
-        struct block_device *bdev = NULL;
-        int err = 0;
-        dev_t dev;
-
-        if (magic != ll_iocontrol_magic)
-                return LLIOC_CONT;
-
-        if (!disks) {
-                err = -ENODEV;
-                goto out1;
-        }
-
-        CWARN("Enter llop_ioctl\n");
-
-        mutex_lock(&lloop_mutex);
-        switch (cmd) {
-        case LL_IOC_LLOOP_ATTACH: {
-                struct lloop_device *lo_free = NULL;
-                int i;
-
-                for (i = 0; i < max_loop; i++, lo = NULL) {
-                        lo = &loop_dev[i];
-                        if (lo->lo_state == LLOOP_UNBOUND) {
-                                if (!lo_free)
-                                        lo_free = lo;
-                                continue;
-                        }
-                        if (file_inode(lo->lo_backing_file) == file_inode(file))
-                                break;
-                }
-                if (lo || !lo_free) {
-                        err = -EBUSY;
-                        goto out;
-                }
-
-                lo = lo_free;
-                dev = MKDEV(lloop_major, lo->lo_number);
-
-                /* quit if the used pointer is writable */
-                if (put_user((long)old_encode_dev(dev), (long __user *)arg)) {
-                        err = -EFAULT;
-                        goto out;
-                }
-
-                bdev = blkdev_get_by_dev(dev, file->f_mode, NULL);
-                if (IS_ERR(bdev)) {
-                        err = PTR_ERR(bdev);
-                        goto out;
-                }
-
-                get_file(file);
-                err = loop_set_fd(lo, NULL, bdev, file);
-                if (err) {
-                        fput(file);
-                        blkdev_put(bdev, 0);
-                }
-
-                break;
-        }
-
-        case LL_IOC_LLOOP_DETACH_BYDEV: {
-                int minor;
-
-                dev = old_decode_dev(arg);
-                if (MAJOR(dev) != lloop_major) {
-                        err = -EINVAL;
-                        goto out;
-                }
-
-                minor = MINOR(dev);
-                if (minor > max_loop - 1) {
-                        err = -EINVAL;
-                        goto out;
-                }
-
-                lo = &loop_dev[minor];
-                if (lo->lo_state != LLOOP_BOUND) {
-                        err = -EINVAL;
-                        goto out;
-                }
-
-                bdev = lo->lo_device;
-                err = loop_clr_fd(lo, bdev, 1);
-                if (err == 0)
-                        blkdev_put(bdev, 0); /* grabbed in LLOOP_ATTACH */
-
-                break;
-        }
-
-        default:
-                err = -EINVAL;
-                break;
-        }
-
-out:
-        mutex_unlock(&lloop_mutex);
-out1:
-        if (rcp)
-                *rcp = err;
-        return LLIOC_STOP;
-}
-
-static int __init lloop_init(void)
-{
-        int     i;
-        unsigned int cmdlist[] = {
-                LL_IOC_LLOOP_ATTACH,
-                LL_IOC_LLOOP_DETACH_BYDEV,
-        };
-
-        if (max_loop < 1 || max_loop > 256) {
-                max_loop = MAX_LOOP_DEFAULT;
-                CWARN("lloop: invalid max_loop (must be between 1 and 256), using default (%u)\n",
-                      max_loop);
-        }
-
-        lloop_major = register_blkdev(0, "lloop");
-        if (lloop_major < 0)
-                return -EIO;
-
-        CDEBUG(D_CONFIG, "registered lloop major %d with %u minors\n",
-               lloop_major, max_loop);
-
-        ll_iocontrol_magic = ll_iocontrol_register(lloop_ioctl, 2, cmdlist);
-        if (!ll_iocontrol_magic)
-                goto out_mem1;
-
-        loop_dev = kcalloc(max_loop, sizeof(*loop_dev), GFP_KERNEL);
-        if (!loop_dev)
-                goto out_mem1;
-
-        disks = kcalloc(max_loop, sizeof(*disks), GFP_KERNEL);
-        if (!disks)
-                goto out_mem2;
-
-        for (i = 0; i < max_loop; i++) {
-                disks[i] = alloc_disk(1);
-                if (!disks[i])
-                        goto out_mem3;
-        }
-
-        mutex_init(&lloop_mutex);
-
-        for (i = 0; i < max_loop; i++) {
-                struct lloop_device *lo = &loop_dev[i];
-                struct gendisk *disk = disks[i];
-
-                lo->lo_queue = blk_alloc_queue(GFP_KERNEL);
-                if (!lo->lo_queue)
-                        goto out_mem4;
-
-                mutex_init(&lo->lo_ctl_mutex);
-                sema_init(&lo->lo_sem, 0);
-                init_waitqueue_head(&lo->lo_bh_wait);
-                lo->lo_number = i;
-                spin_lock_init(&lo->lo_lock);
-                disk->major = lloop_major;
-                disk->first_minor = i;
-                disk->fops = &lo_fops;
-                sprintf(disk->disk_name, "lloop%d", i);
-                disk->private_data = lo;
-                disk->queue = lo->lo_queue;
-        }
-
-        /* We cannot fail after we call this, so another loop!*/
-        for (i = 0; i < max_loop; i++)
-                add_disk(disks[i]);
-        return 0;
-
-out_mem4:
-        while (i--)
-                blk_cleanup_queue(loop_dev[i].lo_queue);
-        i = max_loop;
-out_mem3:
-        while (i--)
-                put_disk(disks[i]);
-        kfree(disks);
-out_mem2:
-        kfree(loop_dev);
-out_mem1:
-        unregister_blkdev(lloop_major, "lloop");
-        ll_iocontrol_unregister(ll_iocontrol_magic);
-        CERROR("lloop: ran out of memory\n");
-        return -ENOMEM;
-}
-
-static void lloop_exit(void)
-{
-        int i;
-
-        ll_iocontrol_unregister(ll_iocontrol_magic);
-        for (i = 0; i < max_loop; i++) {
-                del_gendisk(disks[i]);
-                blk_cleanup_queue(loop_dev[i].lo_queue);
-                put_disk(disks[i]);
-        }
-
-        unregister_blkdev(lloop_major, "lloop");
-
-        kfree(disks);
-        kfree(loop_dev);
-}
-
-module_param(max_loop, int, 0444);
-MODULE_PARM_DESC(max_loop, "maximum of lloop_device");
-MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
-MODULE_DESCRIPTION("Lustre virtual block device");
-MODULE_VERSION(LUSTRE_VERSION_STRING);
-MODULE_LICENSE("GPL");
-
-module_init(lloop_init);
-module_exit(lloop_exit);
diff --git a/drivers/staging/lustre/lustre/llite/lproc_llite.c b/drivers/staging/lustre/lustre/llite/lproc_llite.c
index 55d62eb11957..6e9a8a5920c0 100644
--- a/drivers/staging/lustre/lustre/llite/lproc_llite.c
+++ b/drivers/staging/lustre/lustre/llite/lproc_llite.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/namei.c b/drivers/staging/lustre/lustre/llite/namei.c
index 5eba0ebae10f..d7459bdea82e 100644
--- a/drivers/staging/lustre/lustre/llite/namei.c
+++ b/drivers/staging/lustre/lustre/llite/namei.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -318,7 +314,8 @@ static struct dentry *ll_find_alias(struct inode *inode, struct dentry *dentry)
         if (hlist_empty(&inode->i_dentry))
                 return NULL;
 
-        discon_alias = invalid_alias = NULL;
+        discon_alias = NULL;
+        invalid_alias = NULL;
 
         ll_lock_dcache(inode);
         hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
diff --git a/drivers/staging/lustre/lustre/llite/remote_perm.c b/drivers/staging/lustre/lustre/llite/remote_perm.c
index e9d25317cd28..9df9e784ae3e 100644
--- a/drivers/staging/lustre/lustre/llite/remote_perm.c
+++ b/drivers/staging/lustre/lustre/llite/remote_perm.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/rw.c b/drivers/staging/lustre/lustre/llite/rw.c
index 336397773fbb..87393c4bd51e 100644
--- a/drivers/staging/lustre/lustre/llite/rw.c
+++ b/drivers/staging/lustre/lustre/llite/rw.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -59,84 +55,6 @@
 #include "llite_internal.h"
 #include "../include/linux/lustre_compat25.h"
 
-/**
- * Finalizes cl-data before exiting typical address_space operation. Dual to
- * ll_cl_init().
- */
-void ll_cl_fini(struct ll_cl_context *lcc)
-{
-        struct lu_env  *env  = lcc->lcc_env;
-        struct cl_io   *io   = lcc->lcc_io;
-        struct cl_page *page = lcc->lcc_page;
-
-        LASSERT(lcc->lcc_cookie == current);
-        LASSERT(env);
-
-        if (page) {
-                lu_ref_del(&page->cp_reference, "cl_io", io);
-                cl_page_put(env, page);
-        }
-
-        cl_env_put(env, &lcc->lcc_refcheck);
-}
-
-/**
- * Initializes common cl-data at the typical address_space operation entry
- * point.
- */
-struct ll_cl_context *ll_cl_init(struct file *file, struct page *vmpage)
-{
-        struct ll_cl_context *lcc;
-        struct lu_env    *env;
-        struct cl_io     *io;
-        struct cl_object *clob;
-        struct vvp_io    *vio;
-
-        int refcheck;
-        int result = 0;
-
-        clob = ll_i2info(file_inode(file))->lli_clob;
-        LASSERT(clob);
-
-        env = cl_env_get(&refcheck);
-        if (IS_ERR(env))
-                return ERR_CAST(env);
-
-        lcc = &ll_env_info(env)->lti_io_ctx;
-        memset(lcc, 0, sizeof(*lcc));
-        lcc->lcc_env = env;
-        lcc->lcc_refcheck = refcheck;
-        lcc->lcc_cookie = current;
-
-        vio = vvp_env_io(env);
-        io = vio->vui_cl.cis_io;
-        lcc->lcc_io = io;
-        if (!io)
-                result = -EIO;
-
-        if (result == 0 && vmpage) {
-                struct cl_page   *page;
-
-                LASSERT(io->ci_state == CIS_IO_GOING);
-                LASSERT(vio->vui_fd == LUSTRE_FPRIVATE(file));
-                page = cl_page_find(env, clob, vmpage->index, vmpage,
-                                    CPT_CACHEABLE);
-                if (!IS_ERR(page)) {
-                        lcc->lcc_page = page;
-                        lu_ref_add(&page->cp_reference, "cl_io", io);
-                        result = 0;
-                } else {
-                        result = PTR_ERR(page);
-                }
-        }
-        if (result) {
-                ll_cl_fini(lcc);
-                lcc = ERR_PTR(result);
-        }
-
-        return lcc;
-}
-
 static void ll_ra_stats_inc_sbi(struct ll_sb_info *sbi, enum ra_stat which);
 
 /**
@@ -1112,17 +1030,70 @@ int ll_writepages(struct address_space *mapping, struct writeback_control *wbc)
         return result;
 }
 
+struct ll_cl_context *ll_cl_find(struct file *file)
+{
+        struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
+        struct ll_cl_context *lcc;
+        struct ll_cl_context *found = NULL;
+
+        read_lock(&fd->fd_lock);
+        list_for_each_entry(lcc, &fd->fd_lccs, lcc_list) {
+                if (lcc->lcc_cookie == current) {
+                        found = lcc;
+                        break;
+                }
+        }
+        read_unlock(&fd->fd_lock);
+
+        return found;
+}
+
+void ll_cl_add(struct file *file, const struct lu_env *env, struct cl_io *io)
+{
+        struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
+        struct ll_cl_context *lcc = &ll_env_info(env)->lti_io_ctx;
+
+        memset(lcc, 0, sizeof(*lcc));
+        INIT_LIST_HEAD(&lcc->lcc_list);
+        lcc->lcc_cookie = current;
+        lcc->lcc_env = env;
+        lcc->lcc_io = io;
+
+        write_lock(&fd->fd_lock);
+        list_add(&lcc->lcc_list, &fd->fd_lccs);
+        write_unlock(&fd->fd_lock);
+}
+
+void ll_cl_remove(struct file *file, const struct lu_env *env)
+{
+        struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
+        struct ll_cl_context *lcc = &ll_env_info(env)->lti_io_ctx;
+
+        write_lock(&fd->fd_lock);
+        list_del_init(&lcc->lcc_list);
+        write_unlock(&fd->fd_lock);
+}
+
 int ll_readpage(struct file *file, struct page *vmpage)
 {
+        struct cl_object *clob = ll_i2info(file_inode(file))->lli_clob;
         struct ll_cl_context *lcc;
+        const struct lu_env  *env;
+        struct cl_io   *io;
+        struct cl_page *page;
         int result;
 
-        lcc = ll_cl_init(file, vmpage);
-        if (!IS_ERR(lcc)) {
-                struct lu_env  *env  = lcc->lcc_env;
-                struct cl_io   *io   = lcc->lcc_io;
-                struct cl_page *page = lcc->lcc_page;
+        lcc = ll_cl_find(file);
+        if (!lcc) {
+                unlock_page(vmpage);
+                return -EIO;
+        }
 
+        env = lcc->lcc_env;
+        io = lcc->lcc_io;
+        LASSERT(io->ci_state == CIS_IO_GOING);
+        page = cl_page_find(env, clob, vmpage->index, vmpage, CPT_CACHEABLE);
+        if (!IS_ERR(page)) {
                 LASSERT(page->cp_type == CPT_CACHEABLE);
                 if (likely(!PageUptodate(vmpage))) {
                         cl_page_assume(env, io, page);
@@ -1132,10 +1103,10 @@ int ll_readpage(struct file *file, struct page *vmpage)
                         unlock_page(vmpage);
                         result = 0;
                 }
-                ll_cl_fini(lcc);
+                cl_page_put(env, page);
         } else {
                 unlock_page(vmpage);
-                result = PTR_ERR(lcc);
+                result = PTR_ERR(page);
         }
         return result;
 }
diff --git a/drivers/staging/lustre/lustre/llite/rw26.c b/drivers/staging/lustre/lustre/llite/rw26.c
index c12a048fce59..d98c7acc0832 100644
--- a/drivers/staging/lustre/lustre/llite/rw26.c
+++ b/drivers/staging/lustre/lustre/llite/rw26.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -489,7 +485,7 @@ static int ll_write_begin(struct file *file, struct address_space *mapping,
                           struct page **pagep, void **fsdata)
 {
         struct ll_cl_context *lcc;
-        struct lu_env  *env;
+        const struct lu_env  *env;
         struct cl_io   *io;
         struct cl_page *page;
         struct cl_object *clob = ll_i2info(mapping->host)->lli_clob;
@@ -501,9 +497,9 @@ static int ll_write_begin(struct file *file, struct address_space *mapping,
 
         CDEBUG(D_VFSTRACE, "Writing %lu of %d to %d bytes\n", index, from, len);
 
-        lcc = ll_cl_init(file, NULL);
-        if (IS_ERR(lcc)) {
-                result = PTR_ERR(lcc);
+        lcc = ll_cl_find(file);
+        if (!lcc) {
+                result = -EIO;
                 goto out;
         }
 
@@ -579,8 +575,6 @@ out:
                         unlock_page(vmpage);
                         put_page(vmpage);
                 }
-                if (!IS_ERR(lcc))
-                        ll_cl_fini(lcc);
         } else {
                 *pagep = vmpage;
                 *fsdata = lcc;
@@ -593,7 +587,7 @@ static int ll_write_end(struct file *file, struct address_space *mapping,
                         struct page *vmpage, void *fsdata)
 {
         struct ll_cl_context *lcc = fsdata;
-        struct lu_env *env;
+        const struct lu_env *env;
         struct cl_io *io;
         struct vvp_io *vio;
         struct cl_page *page;
@@ -631,6 +625,10 @@ static int ll_write_end(struct file *file, struct address_space *mapping,
         } else {
                 cl_page_disown(env, io, page);
 
+                lcc->lcc_page = NULL;
+                lu_ref_del(&page->cp_reference, "cl_io", io);
+                cl_page_put(env, page);
+
                 /* page list is not contiguous now, commit it now */
                 unplug = true;
         }
@@ -639,7 +637,6 @@ static int ll_write_end(struct file *file, struct address_space *mapping,
             file->f_flags & O_SYNC || IS_SYNC(file_inode(file)))
                 result = vvp_io_write_commit(env, io);
 
-        ll_cl_fini(lcc);
         return result >= 0 ? copied : result;
 }
 
diff --git a/drivers/staging/lustre/lustre/llite/statahead.c b/drivers/staging/lustre/lustre/llite/statahead.c
index 6322f88661e8..03ad858039f0 100644
--- a/drivers/staging/lustre/lustre/llite/statahead.c
+++ b/drivers/staging/lustre/lustre/llite/statahead.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/super25.c b/drivers/staging/lustre/lustre/llite/super25.c
index 415750b0bff4..b40ea79bb6f2 100644
--- a/drivers/staging/lustre/lustre/llite/super25.c
+++ b/drivers/staging/lustre/lustre/llite/super25.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/symlink.c b/drivers/staging/lustre/lustre/llite/symlink.c
index 3fc736ccf85e..8c8bdfe1ad71 100644
--- a/drivers/staging/lustre/lustre/llite/symlink.c
+++ b/drivers/staging/lustre/lustre/llite/symlink.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/vvp_dev.c b/drivers/staging/lustre/lustre/llite/vvp_dev.c
index 47101de1c020..e623216e962d 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_dev.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_dev.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -150,8 +146,8 @@ struct lu_context_key vvp_session_key = {
         .lct_fini = vvp_session_key_fini
 };
 
-void *vvp_thread_key_init(const struct lu_context *ctx,
-                          struct lu_context_key *key)
+static void *vvp_thread_key_init(const struct lu_context *ctx,
+                                 struct lu_context_key *key)
 {
         struct vvp_thread_info *vti;
 
@@ -161,8 +157,8 @@ void *vvp_thread_key_init(const struct lu_context *ctx,
         return vti;
 }
 
-void vvp_thread_key_fini(const struct lu_context *ctx,
-                         struct lu_context_key *key, void *data)
+static void vvp_thread_key_fini(const struct lu_context *ctx,
+                                struct lu_context_key *key, void *data)
 {
         struct vvp_thread_info *vti = data;
 
@@ -564,7 +560,7 @@ static int vvp_pgcache_show(struct seq_file *f, void *v)
 
         env = cl_env_get(&refcheck);
         if (!IS_ERR(env)) {
-                pos = *(loff_t *) v;
+                pos = *(loff_t *)v;
                 vvp_pgcache_id_unpack(pos, &id);
                 sbi = f->private;
                 clob = vvp_pgcache_obj(env, &sbi->ll_cl->cd_lu_dev, &id);
diff --git a/drivers/staging/lustre/lustre/llite/vvp_internal.h b/drivers/staging/lustre/lustre/llite/vvp_internal.h
index 27b9b0a01f32..79fc428461ed 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_internal.h
+++ b/drivers/staging/lustre/lustre/llite/vvp_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/vvp_io.c b/drivers/staging/lustre/lustre/llite/vvp_io.c
index 5bf9592ae5d2..94916dcc6caa 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_io.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_io.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -47,8 +43,8 @@
 #include "llite_internal.h"
 #include "vvp_internal.h"
 
-struct vvp_io *cl2vvp_io(const struct lu_env *env,
-                         const struct cl_io_slice *slice)
+static struct vvp_io *cl2vvp_io(const struct lu_env *env,
+                                const struct cl_io_slice *slice)
 {
         struct vvp_io *vio;
 
@@ -954,7 +950,8 @@ static int vvp_io_write_start(const struct lu_env *env,
                  * out-of-order writes.
                  */
                 ll_merge_attr(env, inode);
-                pos = io->u.ci_wr.wr.crw_pos = i_size_read(inode);
+                pos = i_size_read(inode);
+                io->u.ci_wr.wr.crw_pos = pos;
                 vio->vui_iocb->ki_pos = pos;
         } else {
                 LASSERT(vio->vui_iocb->ki_pos == pos);
@@ -1259,7 +1256,7 @@ static int vvp_io_read_page(const struct lu_env *env,
         return 0;
 }
 
-void vvp_io_end(const struct lu_env *env, const struct cl_io_slice *ios)
+static void vvp_io_end(const struct lu_env *env, const struct cl_io_slice *ios)
 {
         CLOBINVRNT(env, ios->cis_io->ci_obj,
                    vvp_object_invariant(ios->cis_io->ci_obj));
diff --git a/drivers/staging/lustre/lustre/llite/vvp_lock.c b/drivers/staging/lustre/lustre/llite/vvp_lock.c
index f5bd6c22e112..64be0c9df35b 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_lock.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_lock.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/vvp_object.c b/drivers/staging/lustre/lustre/llite/vvp_object.c
index 18c9df7ebdda..2c520b0bf6ca 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_object.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_object.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/vvp_page.c b/drivers/staging/lustre/lustre/llite/vvp_page.c
index 6cd2af7a958f..2e566d90bb94 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_page.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_page.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/llite/vvp_req.c b/drivers/staging/lustre/lustre/llite/vvp_req.c
index fb886291a4e2..9fe9d6c0a7d1 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_req.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_req.c
@@ -60,10 +60,10 @@ static inline struct vvp_req *cl2vvp_req(const struct cl_req_slice *slice)
  *    - o_ioepoch,
  *
  */
-void vvp_req_attr_set(const struct lu_env *env,
-                      const struct cl_req_slice *slice,
-                      const struct cl_object *obj,
-                      struct cl_req_attr *attr, u64 flags)
+static void vvp_req_attr_set(const struct lu_env *env,
+                             const struct cl_req_slice *slice,
+                             const struct cl_object *obj,
+                             struct cl_req_attr *attr, u64 flags)
 {
         struct inode *inode;
         struct obdo  *oa;
@@ -87,8 +87,8 @@ void vvp_req_attr_set(const struct lu_env *env,
                JOBSTATS_JOBID_SIZE);
 }
 
-void vvp_req_completion(const struct lu_env *env,
-                        const struct cl_req_slice *slice, int ioret)
+static void vvp_req_completion(const struct lu_env *env,
+                               const struct cl_req_slice *slice, int ioret)
 {
         struct vvp_req *vrq;
 
diff --git a/drivers/staging/lustre/lustre/llite/xattr.c b/drivers/staging/lustre/lustre/llite/xattr.c
index 608014b0dbcd..6ce790e1aa58 100644
--- a/drivers/staging/lustre/lustre/llite/xattr.c
+++ b/drivers/staging/lustre/lustre/llite/xattr.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lmv/lmv_fld.c b/drivers/staging/lustre/lustre/lmv/lmv_fld.c
index 378691b2a062..a3d170aa6fd2 100644
--- a/drivers/staging/lustre/lustre/lmv/lmv_fld.c
+++ b/drivers/staging/lustre/lustre/lmv/lmv_fld.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lmv/lmv_intent.c b/drivers/staging/lustre/lustre/lmv/lmv_intent.c
index e0958eaed054..980c9d45afb2 100644
--- a/drivers/staging/lustre/lustre/lmv/lmv_intent.c
+++ b/drivers/staging/lustre/lustre/lmv/lmv_intent.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lmv/lmv_internal.h b/drivers/staging/lustre/lustre/lmv/lmv_internal.h
index 7007e4c48035..0beafc49b8d2 100644
--- a/drivers/staging/lustre/lustre/lmv/lmv_internal.h
+++ b/drivers/staging/lustre/lustre/lmv/lmv_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lmv/lmv_obd.c b/drivers/staging/lustre/lustre/lmv/lmv_obd.c
index 9e31f6b03f9e..ab4f4fbf0951 100644
--- a/drivers/staging/lustre/lustre/lmv/lmv_obd.c
+++ b/drivers/staging/lustre/lustre/lmv/lmv_obd.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -2686,7 +2682,7 @@ static int lmv_quotactl(struct obd_device *unused, struct obd_export *exp,
         struct lmv_obd      *lmv = &obd->u.lmv;
         struct lmv_tgt_desc *tgt = lmv->tgts[0];
         int               rc = 0, i;
-        __u64           curspace, curinodes;
+        __u64 curspace = 0, curinodes = 0;
 
         if (!tgt || !tgt->ltd_exp || !tgt->ltd_active ||
             !lmv->desc.ld_tgt_count) {
@@ -2699,7 +2695,6 @@ static int lmv_quotactl(struct obd_device *unused, struct obd_export *exp,
                 return rc;
         }
 
-        curspace = curinodes = 0;
         for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
                 int err;
 
diff --git a/drivers/staging/lustre/lustre/lmv/lproc_lmv.c b/drivers/staging/lustre/lustre/lmv/lproc_lmv.c
index b39e364a29ab..c29c361eb0cc 100644
--- a/drivers/staging/lustre/lustre/lmv/lproc_lmv.c
+++ b/drivers/staging/lustre/lustre/lmv/lproc_lmv.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_cl_internal.h b/drivers/staging/lustre/lustre/lov/lov_cl_internal.h
index ac9744e887ae..9740568d9521 100644
--- a/drivers/staging/lustre/lustre/lov/lov_cl_internal.h
+++ b/drivers/staging/lustre/lustre/lov/lov_cl_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_dev.c b/drivers/staging/lustre/lustre/lov/lov_dev.c
index dae8e89bcf6d..b1f260d43bc7 100644
--- a/drivers/staging/lustre/lustre/lov/lov_dev.c
+++ b/drivers/staging/lustre/lustre/lov/lov_dev.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_ea.c b/drivers/staging/lustre/lustre/lov/lov_ea.c
index 460f0fa5e6b1..5053dead17bb 100644
--- a/drivers/staging/lustre/lustre/lov/lov_ea.c
+++ b/drivers/staging/lustre/lustre/lov/lov_ea.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_internal.h b/drivers/staging/lustre/lustre/lov/lov_internal.h
index eef9afac8467..12bd511e8988 100644
--- a/drivers/staging/lustre/lustre/lov/lov_internal.h
+++ b/drivers/staging/lustre/lustre/lov/lov_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_io.c b/drivers/staging/lustre/lustre/lov/lov_io.c
index 86cb3f8f9246..84032a510254 100644
--- a/drivers/staging/lustre/lustre/lov/lov_io.c
+++ b/drivers/staging/lustre/lustre/lov/lov_io.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_lock.c b/drivers/staging/lustre/lustre/lov/lov_lock.c
index 1b203d18c6e9..f3a0583f28f5 100644
--- a/drivers/staging/lustre/lustre/lov/lov_lock.c
+++ b/drivers/staging/lustre/lustre/lov/lov_lock.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_merge.c b/drivers/staging/lustre/lustre/lov/lov_merge.c
index 56ef41d17ad7..b9c90865fdfc 100644
--- a/drivers/staging/lustre/lustre/lov/lov_merge.c
+++ b/drivers/staging/lustre/lustre/lov/lov_merge.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_obd.c b/drivers/staging/lustre/lustre/lov/lov_obd.c
index e15ef2ece893..c87096ee8d38 100644
--- a/drivers/staging/lustre/lustre/lov/lov_obd.c
+++ b/drivers/staging/lustre/lustre/lov/lov_obd.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -1772,7 +1768,8 @@ static int lov_fiemap(struct lov_obd *lov, __u32 keylen, void *key,
         fm_start = fiemap->fm_start;
         fm_length = fiemap->fm_length;
         /* Calculate start stripe, last stripe and length of mapping */
-        actual_start_stripe = start_stripe = lov_stripe_number(lsm, fm_start);
+        start_stripe = lov_stripe_number(lsm, fm_start);
+        actual_start_stripe = start_stripe;
         fm_end = (fm_length == ~0ULL ? fm_key->oa.o_size :
                                                 fm_start + fm_length - 1);
         /* If fm_length != ~0ULL but fm_start+fm_length-1 exceeds file size */
@@ -2095,11 +2092,9 @@ static int lov_set_info_async(const struct lu_env *env, struct obd_export *exp,
         u32 count;
         int i, rc = 0, err;
         struct lov_tgt_desc *tgt;
-        unsigned incr, check_uuid,
-                 do_inactive, no_set;
-        unsigned next_id = 0,  mds_con = 0;
+        unsigned int incr = 0, check_uuid = 0, do_inactive = 0, no_set = 0;
+        unsigned int next_id = 0, mds_con = 0;
 
-        incr = check_uuid = do_inactive = no_set = 0;
         if (!set) {
                 no_set = 1;
                 set = ptlrpc_prep_set();
diff --git a/drivers/staging/lustre/lustre/lov/lov_object.c b/drivers/staging/lustre/lustre/lov/lov_object.c
index 561d493b2cdf..ec55b8837270 100644
--- a/drivers/staging/lustre/lustre/lov/lov_object.c
+++ b/drivers/staging/lustre/lustre/lov/lov_object.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_offset.c b/drivers/staging/lustre/lustre/lov/lov_offset.c
index 9302f06c34ef..ecca74fbff00 100644
--- a/drivers/staging/lustre/lustre/lov/lov_offset.c
+++ b/drivers/staging/lustre/lustre/lov/lov_offset.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -74,7 +70,7 @@ pgoff_t lov_stripe_pgoff(struct lov_stripe_md *lsm, pgoff_t stripe_index,
 {
         loff_t offset;
 
-        offset = lov_stripe_size(lsm, stripe_index << PAGE_SHIFT, stripe);
+        offset = lov_stripe_size(lsm, (stripe_index << PAGE_SHIFT) + 1, stripe);
         return offset >> PAGE_SHIFT;
 }
 
diff --git a/drivers/staging/lustre/lustre/lov/lov_pack.c b/drivers/staging/lustre/lustre/lov/lov_pack.c
index 0215ea54df8d..869ef41b13ca 100644
--- a/drivers/staging/lustre/lustre/lov/lov_pack.c
+++ b/drivers/staging/lustre/lustre/lov/lov_pack.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_page.c b/drivers/staging/lustre/lustre/lov/lov_page.c
index 0306f00c3f33..c17026f14896 100644
--- a/drivers/staging/lustre/lustre/lov/lov_page.c
+++ b/drivers/staging/lustre/lustre/lov/lov_page.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_pool.c b/drivers/staging/lustre/lustre/lov/lov_pool.c
index 690292ecebdc..4c2d21729589 100644
--- a/drivers/staging/lustre/lustre/lov/lov_pool.c
+++ b/drivers/staging/lustre/lustre/lov/lov_pool.c
@@ -14,12 +14,8 @@
  * in the LICENSE file that accompanied this code).
  *
  * You should have received a copy of the GNU General Public License
- * version 2 along with this program; If not, see [sun.com URL with a
- * copy of GPLv2].
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * version 2 along with this program; If not, see
+ * http://http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lov_request.c b/drivers/staging/lustre/lustre/lov/lov_request.c
index 1be4b921c01f..4099b51f826e 100644
--- a/drivers/staging/lustre/lustre/lov/lov_request.c
+++ b/drivers/staging/lustre/lustre/lov/lov_request.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lovsub_dev.c b/drivers/staging/lustre/lustre/lov/lovsub_dev.c
index 35f6b1d66ff4..b519a1940e1e 100644
--- a/drivers/staging/lustre/lustre/lov/lovsub_dev.c
+++ b/drivers/staging/lustre/lustre/lov/lovsub_dev.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lovsub_io.c b/drivers/staging/lustre/lustre/lov/lovsub_io.c
index 783ec687a4e7..6a9820218a3e 100644
--- a/drivers/staging/lustre/lustre/lov/lovsub_io.c
+++ b/drivers/staging/lustre/lustre/lov/lovsub_io.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lovsub_lock.c b/drivers/staging/lustre/lustre/lov/lovsub_lock.c
index e92edfb618b7..38f9b735c241 100644
--- a/drivers/staging/lustre/lustre/lov/lovsub_lock.c
+++ b/drivers/staging/lustre/lustre/lov/lovsub_lock.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lovsub_object.c b/drivers/staging/lustre/lustre/lov/lovsub_object.c
index bcaae1e5b840..fb2f2660b3e9 100644
--- a/drivers/staging/lustre/lustre/lov/lovsub_object.c
+++ b/drivers/staging/lustre/lustre/lov/lovsub_object.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lovsub_page.c b/drivers/staging/lustre/lustre/lov/lovsub_page.c
index 9badedcce2bf..b2e68c3e820d 100644
--- a/drivers/staging/lustre/lustre/lov/lovsub_page.c
+++ b/drivers/staging/lustre/lustre/lov/lovsub_page.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/lov/lproc_lov.c b/drivers/staging/lustre/lustre/lov/lproc_lov.c
index 0dcb6b6a7782..eb6d30d34e3a 100644
--- a/drivers/staging/lustre/lustre/lov/lproc_lov.c
+++ b/drivers/staging/lustre/lustre/lov/lproc_lov.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/mdc/lproc_mdc.c b/drivers/staging/lustre/lustre/mdc/lproc_mdc.c
index 5c7a15dd7bd2..98d15fb247bc 100644
--- a/drivers/staging/lustre/lustre/mdc/lproc_mdc.c
+++ b/drivers/staging/lustre/lustre/mdc/lproc_mdc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/mdc/mdc_internal.h b/drivers/staging/lustre/lustre/mdc/mdc_internal.h
index c5519aeb0d8a..58f2841cabe4 100644
--- a/drivers/staging/lustre/lustre/mdc/mdc_internal.h
+++ b/drivers/staging/lustre/lustre/mdc/mdc_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/mdc/mdc_lib.c b/drivers/staging/lustre/lustre/mdc/mdc_lib.c
index 856c54e03b6b..2703113f32c8 100644
--- a/drivers/staging/lustre/lustre/mdc/mdc_lib.c
+++ b/drivers/staging/lustre/lustre/mdc/mdc_lib.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/mdc/mdc_locks.c b/drivers/staging/lustre/lustre/mdc/mdc_locks.c
index 3b1bc9111b93..b3954204c4df 100644
--- a/drivers/staging/lustre/lustre/mdc/mdc_locks.c
+++ b/drivers/staging/lustre/lustre/mdc/mdc_locks.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/mdc/mdc_reint.c b/drivers/staging/lustre/lustre/mdc/mdc_reint.c
index 4ef3db147f87..661488ee03f3 100644
--- a/drivers/staging/lustre/lustre/mdc/mdc_reint.c
+++ b/drivers/staging/lustre/lustre/mdc/mdc_reint.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/mdc/mdc_request.c b/drivers/staging/lustre/lustre/mdc/mdc_request.c
index 86b7445365f4..f371e1df47a4 100644
--- a/drivers/staging/lustre/lustre/mdc/mdc_request.c
+++ b/drivers/staging/lustre/lustre/mdc/mdc_request.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -1807,7 +1803,7 @@ static int mdc_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
         case IOC_OBD_STATFS: {
                 struct obd_statfs stat_buf = {0};
 
-                if (*((__u32 *) data->ioc_inlbuf2) != 0) {
+                if (*((__u32 *)data->ioc_inlbuf2) != 0) {
                         rc = -ENODEV;
                         goto out;
                 }
@@ -2001,7 +1997,7 @@ static int mdc_hsm_copytool_send(int len, void *val)
 
         if (len < sizeof(*lh) + sizeof(*hal)) {
                 CERROR("Short HSM message %d < %d\n", len,
-                       (int) (sizeof(*lh) + sizeof(*hal)));
+                       (int)(sizeof(*lh) + sizeof(*hal)));
                 return -EPROTO;
         }
         if (lh->kuc_magic == __swab16(KUC_MAGIC)) {
diff --git a/drivers/staging/lustre/lustre/mgc/lproc_mgc.c b/drivers/staging/lustre/lustre/mgc/lproc_mgc.c
index 8d5bc5a751a4..0735220b2a18 100644
--- a/drivers/staging/lustre/lustre/mgc/lproc_mgc.c
+++ b/drivers/staging/lustre/lustre/mgc/lproc_mgc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/mgc/mgc_internal.h b/drivers/staging/lustre/lustre/mgc/mgc_internal.h
index 82fb8f46e037..f146f7521c92 100644
--- a/drivers/staging/lustre/lustre/mgc/mgc_internal.h
+++ b/drivers/staging/lustre/lustre/mgc/mgc_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/mgc/mgc_request.c b/drivers/staging/lustre/lustre/mgc/mgc_request.c
index 2311a437c441..fbbf2762ac84 100644
--- a/drivers/staging/lustre/lustre/mgc/mgc_request.c
+++ b/drivers/staging/lustre/lustre/mgc/mgc_request.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -1034,7 +1030,7 @@ static int mgc_set_info_async(const struct lu_env *env, struct obd_export *exp,
                 rc = sptlrpc_parse_flavor(val, &flvr);
                 if (rc) {
                         CERROR("invalid sptlrpc flavor %s to MGS\n",
-                               (char *) val);
+                               (char *)val);
                         return rc;
                 }
 
@@ -1050,7 +1046,7 @@ static int mgc_set_info_async(const struct lu_env *env, struct obd_export *exp,
                         sptlrpc_flavor2name(&cli->cl_flvr_mgc,
                                             str, sizeof(str));
                         LCONSOLE_ERROR("asking sptlrpc flavor %s to MGS but currently %s is in use\n",
-                                       (char *) val, str);
+                                       (char *)val, str);
                         rc = -EPERM;
                 }
                 return rc;
diff --git a/drivers/staging/lustre/lustre/obdclass/acl.c b/drivers/staging/lustre/lustre/obdclass/acl.c
index 0e02ae97b7ed..30d8b4209716 100644
--- a/drivers/staging/lustre/lustre/obdclass/acl.c
+++ b/drivers/staging/lustre/lustre/obdclass/acl.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/cl_internal.h b/drivers/staging/lustre/lustre/obdclass/cl_internal.h
index 7eb0ad7b3644..e866754a42d5 100644
--- a/drivers/staging/lustre/lustre/obdclass/cl_internal.h
+++ b/drivers/staging/lustre/lustre/obdclass/cl_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/cl_io.c b/drivers/staging/lustre/lustre/obdclass/cl_io.c
index 583fb5f33889..e72f1fc00a13 100644
--- a/drivers/staging/lustre/lustre/obdclass/cl_io.c
+++ b/drivers/staging/lustre/lustre/obdclass/cl_io.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/cl_lock.c b/drivers/staging/lustre/lustre/obdclass/cl_lock.c
index 26a576b63a72..9d7b5939b0fd 100644
--- a/drivers/staging/lustre/lustre/obdclass/cl_lock.c
+++ b/drivers/staging/lustre/lustre/obdclass/cl_lock.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/cl_object.c b/drivers/staging/lustre/lustre/obdclass/cl_object.c
index 5940f30318ec..91a5806d0239 100644
--- a/drivers/staging/lustre/lustre/obdclass/cl_object.c
+++ b/drivers/staging/lustre/lustre/obdclass/cl_object.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -577,7 +573,7 @@ static inline struct cl_env *cl_env_fetch(void)
 {
         struct cl_env *cle;
 
-        cle = cfs_hash_lookup(cl_env_hash, (void *) (long) current->pid);
+        cle = cfs_hash_lookup(cl_env_hash, (void *)(long)current->pid);
         LASSERT(ergo(cle, cle->ce_magic == &cl_env_init0));
         return cle;
 }
@@ -588,7 +584,7 @@ static inline void cl_env_attach(struct cl_env *cle)
                 int rc;
 
                 LASSERT(!cle->ce_owner);
-                cle->ce_owner = (void *) (long) current->pid;
+                cle->ce_owner = (void *)(long)current->pid;
                 rc = cfs_hash_add_unique(cl_env_hash, cle->ce_owner,
                                          &cle->ce_node);
                 LASSERT(rc == 0);
@@ -599,7 +595,7 @@ static inline void cl_env_do_detach(struct cl_env *cle)
 {
         void *cookie;
 
-        LASSERT(cle->ce_owner == (void *) (long) current->pid);
+        LASSERT(cle->ce_owner == (void *)(long)current->pid);
         cookie = cfs_hash_del(cl_env_hash, cle->ce_owner,
                               &cle->ce_node);
         LASSERT(cookie == cle);
diff --git a/drivers/staging/lustre/lustre/obdclass/cl_page.c b/drivers/staging/lustre/lustre/obdclass/cl_page.c
index b754f516e557..71bff493cfc7 100644
--- a/drivers/staging/lustre/lustre/obdclass/cl_page.c
+++ b/drivers/staging/lustre/lustre/obdclass/cl_page.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/class_obd.c b/drivers/staging/lustre/lustre/obdclass/class_obd.c
index f48816af8be7..d9d2a1952b8b 100644
--- a/drivers/staging/lustre/lustre/obdclass/class_obd.c
+++ b/drivers/staging/lustre/lustre/obdclass/class_obd.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/debug.c b/drivers/staging/lustre/lustre/obdclass/debug.c
index e4edfb2c0a20..8acf67239fa8 100644
--- a/drivers/staging/lustre/lustre/obdclass/debug.c
+++ b/drivers/staging/lustre/lustre/obdclass/debug.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/genops.c b/drivers/staging/lustre/lustre/obdclass/genops.c
index d95f11d62a32..99c2da632b51 100644
--- a/drivers/staging/lustre/lustre/obdclass/genops.c
+++ b/drivers/staging/lustre/lustre/obdclass/genops.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/kernelcomm.c b/drivers/staging/lustre/lustre/obdclass/kernelcomm.c
index 8405eccdac19..a0f65c470f4d 100644
--- a/drivers/staging/lustre/lustre/obdclass/kernelcomm.c
+++ b/drivers/staging/lustre/lustre/obdclass/kernelcomm.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/linux/linux-module.c b/drivers/staging/lustre/lustre/obdclass/linux/linux-module.c
index 2cd4522462d9..33342bfcc90e 100644
--- a/drivers/staging/lustre/lustre/obdclass/linux/linux-module.c
+++ b/drivers/staging/lustre/lustre/obdclass/linux/linux-module.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/linux/linux-obdo.c b/drivers/staging/lustre/lustre/obdclass/linux/linux-obdo.c
index b41b65e2f021..c6cc6a7666e3 100644
--- a/drivers/staging/lustre/lustre/obdclass/linux/linux-obdo.c
+++ b/drivers/staging/lustre/lustre/obdclass/linux/linux-obdo.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c b/drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c
index e6bf414a4444..8f70dd2686f9 100644
--- a/drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c
+++ b/drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/llog.c b/drivers/staging/lustre/lustre/obdclass/llog.c
index 79194d8cb587..1784ca063428 100644
--- a/drivers/staging/lustre/lustre/obdclass/llog.c
+++ b/drivers/staging/lustre/lustre/obdclass/llog.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -123,8 +119,10 @@ static int llog_read_header(const struct lu_env *env,
                 handle->lgh_last_idx = 0; /* header is record with index 0 */
                 llh->llh_count = 1;      /* for the header record */
                 llh->llh_hdr.lrh_type = LLOG_HDR_MAGIC;
-                llh->llh_hdr.lrh_len = llh->llh_tail.lrt_len = LLOG_CHUNK_SIZE;
-                llh->llh_hdr.lrh_index = llh->llh_tail.lrt_index = 0;
+                llh->llh_hdr.lrh_len = LLOG_CHUNK_SIZE;
+                llh->llh_tail.lrt_len = LLOG_CHUNK_SIZE;
+                llh->llh_hdr.lrh_index = 0;
+                llh->llh_tail.lrt_index = 0;
                 llh->llh_timestamp = ktime_get_real_seconds();
                 if (uuid)
                         memcpy(&llh->llh_tgtuuid, uuid,
diff --git a/drivers/staging/lustre/lustre/obdclass/llog_cat.c b/drivers/staging/lustre/lustre/obdclass/llog_cat.c
index c27d4ec1df9e..a82a2950295a 100644
--- a/drivers/staging/lustre/lustre/obdclass/llog_cat.c
+++ b/drivers/staging/lustre/lustre/obdclass/llog_cat.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/llog_internal.h b/drivers/staging/lustre/lustre/obdclass/llog_internal.h
index 7fb48dda355e..f7949525d952 100644
--- a/drivers/staging/lustre/lustre/obdclass/llog_internal.h
+++ b/drivers/staging/lustre/lustre/obdclass/llog_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/llog_obd.c b/drivers/staging/lustre/lustre/obdclass/llog_obd.c
index 826623f528da..6ace7e097859 100644
--- a/drivers/staging/lustre/lustre/obdclass/llog_obd.c
+++ b/drivers/staging/lustre/lustre/obdclass/llog_obd.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/llog_swab.c b/drivers/staging/lustre/lustre/obdclass/llog_swab.c
index 967ba2e1bfcb..f7b9b190350c 100644
--- a/drivers/staging/lustre/lustre/obdclass/llog_swab.c
+++ b/drivers/staging/lustre/lustre/obdclass/llog_swab.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/lprocfs_status.c b/drivers/staging/lustre/lustre/obdclass/lprocfs_status.c
index 5a1eae1de2ec..279b625f1afe 100644
--- a/drivers/staging/lustre/lustre/obdclass/lprocfs_status.c
+++ b/drivers/staging/lustre/lustre/obdclass/lprocfs_status.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/lu_object.c b/drivers/staging/lustre/lustre/obdclass/lu_object.c
index e04385760f21..9b03059f34d6 100644
--- a/drivers/staging/lustre/lustre/obdclass/lu_object.c
+++ b/drivers/staging/lustre/lustre/obdclass/lu_object.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/lu_ref.c b/drivers/staging/lustre/lustre/obdclass/lu_ref.c
index 993697b660f6..e9f6040d19eb 100644
--- a/drivers/staging/lustre/lustre/obdclass/lu_ref.c
+++ b/drivers/staging/lustre/lustre/obdclass/lu_ref.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/lustre_handles.c b/drivers/staging/lustre/lustre/obdclass/lustre_handles.c
index 403ceea06186..082f530c527c 100644
--- a/drivers/staging/lustre/lustre/obdclass/lustre_handles.c
+++ b/drivers/staging/lustre/lustre/obdclass/lustre_handles.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/lustre_peer.c b/drivers/staging/lustre/lustre/obdclass/lustre_peer.c
index b1abe023bb35..5974a9bf77c0 100644
--- a/drivers/staging/lustre/lustre/obdclass/lustre_peer.c
+++ b/drivers/staging/lustre/lustre/obdclass/lustre_peer.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/obd_config.c b/drivers/staging/lustre/lustre/obdclass/obd_config.c
index cb1d65c3d95d..0eab1236501b 100644
--- a/drivers/staging/lustre/lustre/obdclass/obd_config.c
+++ b/drivers/staging/lustre/lustre/obdclass/obd_config.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -1021,8 +1017,8 @@ int class_process_proc_param(char *prefix, struct lprocfs_vars *lvars,
                 /* Search proc entries */
                 while (lvars[j].name) {
                         var = &lvars[j];
-                        if (!class_match_param(key, var->name, NULL)
-                            && keylen == strlen(var->name)) {
+                        if (!class_match_param(key, var->name, NULL) &&
+                            keylen == strlen(var->name)) {
                                 matched++;
                                 rc = -EROFS;
                                 if (var->fops && var->fops->write) {
@@ -1077,7 +1073,7 @@ int class_config_llog_handler(const struct lu_env *env,
 {
         struct config_llog_instance *clli = data;
         int cfg_len = rec->lrh_len;
-        char *cfg_buf = (char *) (rec + 1);
+        char *cfg_buf = (char *)(rec + 1);
         int rc = 0;
 
         switch (rec->lrh_type) {
diff --git a/drivers/staging/lustre/lustre/obdclass/obd_mount.c b/drivers/staging/lustre/lustre/obdclass/obd_mount.c
index e0c90adc72a7..aa84a50e9904 100644
--- a/drivers/staging/lustre/lustre/obdclass/obd_mount.c
+++ b/drivers/staging/lustre/lustre/obdclass/obd_mount.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -192,7 +188,7 @@ static int lustre_start_simple(char *obdname, char *type, char *uuid,
         return rc;
 }
 
-DEFINE_MUTEX(mgc_start_lock);
+static DEFINE_MUTEX(mgc_start_lock);
 
 /** Set up a mgc obd to process startup logs
  *
diff --git a/drivers/staging/lustre/lustre/obdclass/obdo.c b/drivers/staging/lustre/lustre/obdclass/obdo.c
index 748e33f017d5..8583a4a8c206 100644
--- a/drivers/staging/lustre/lustre/obdclass/obdo.c
+++ b/drivers/staging/lustre/lustre/obdclass/obdo.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/statfs_pack.c b/drivers/staging/lustre/lustre/obdclass/statfs_pack.c
index fb4e3ae845e0..4bad1fa27d40 100644
--- a/drivers/staging/lustre/lustre/obdclass/statfs_pack.c
+++ b/drivers/staging/lustre/lustre/obdclass/statfs_pack.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdclass/uuid.c b/drivers/staging/lustre/lustre/obdclass/uuid.c
index b0b0157a6334..abd9b1ae72cd 100644
--- a/drivers/staging/lustre/lustre/obdclass/uuid.c
+++ b/drivers/staging/lustre/lustre/obdclass/uuid.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/obdecho/echo_client.c b/drivers/staging/lustre/lustre/obdecho/echo_client.c
index 91ef06f17934..5b29c4a44fe5 100644
--- a/drivers/staging/lustre/lustre/obdecho/echo_client.c
+++ b/drivers/staging/lustre/lustre/obdecho/echo_client.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/osc/lproc_osc.c b/drivers/staging/lustre/lustre/osc/lproc_osc.c
index 33a113213bf5..7e83d395b998 100644
--- a/drivers/staging/lustre/lustre/osc/lproc_osc.c
+++ b/drivers/staging/lustre/lustre/osc/lproc_osc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/osc/osc_cache.c b/drivers/staging/lustre/lustre/osc/osc_cache.c
index 5a14bea961b4..1a6df43dfd4f 100644
--- a/drivers/staging/lustre/lustre/osc/osc_cache.c
+++ b/drivers/staging/lustre/lustre/osc/osc_cache.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -2773,7 +2769,8 @@ int osc_queue_sync_pages(const struct lu_env *env, struct osc_object *obj,
         ext->oe_sync = 1;
         ext->oe_urgent = 1;
         ext->oe_start = start;
-        ext->oe_end = ext->oe_max_end = end;
+        ext->oe_end = end;
+        ext->oe_max_end = end;
         ext->oe_obj = obj;
         ext->oe_srvlock = !!(brw_flags & OBD_BRW_SRVLOCK);
         ext->oe_nr_pages = page_count;
@@ -3308,7 +3305,8 @@ int osc_lock_discard_pages(const struct lu_env *env, struct osc_object *osc,
                 goto out;
 
         cb = mode == CLM_READ ? check_and_discard_cb : discard_cb;
-        info->oti_fn_index = info->oti_next_index = start;
+        info->oti_fn_index = start;
+        info->oti_next_index = start;
         do {
                 res = osc_page_gang_lookup(env, io, osc,
                                            info->oti_next_index, end, cb, osc);
diff --git a/drivers/staging/lustre/lustre/osc/osc_cl_internal.h b/drivers/staging/lustre/lustre/osc/osc_cl_internal.h
index ae19d396b537..437c6595a6cf 100644
--- a/drivers/staging/lustre/lustre/osc/osc_cl_internal.h
+++ b/drivers/staging/lustre/lustre/osc/osc_cl_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -356,11 +352,6 @@ struct osc_page {
          */
         unsigned              ops_transfer_pinned:1,
         /**
-         * True for a `temporary page' created by read-ahead code, probably
-         * outside of any DLM lock.
-         */
-                              ops_temp:1,
-        /**
          * in LRU?
          */
                               ops_in_lru:1,
diff --git a/drivers/staging/lustre/lustre/osc/osc_dev.c b/drivers/staging/lustre/lustre/osc/osc_dev.c
index d4fe507f165f..83d30c135ba4 100644
--- a/drivers/staging/lustre/lustre/osc/osc_dev.c
+++ b/drivers/staging/lustre/lustre/osc/osc_dev.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/osc/osc_internal.h b/drivers/staging/lustre/lustre/osc/osc_internal.h
index 7fad8278150f..7a27f0961955 100644
--- a/drivers/staging/lustre/lustre/osc/osc_internal.h
+++ b/drivers/staging/lustre/lustre/osc/osc_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/osc/osc_io.c b/drivers/staging/lustre/lustre/osc/osc_io.c
index d534b0e0edf6..6e3dcd38913f 100644
--- a/drivers/staging/lustre/lustre/osc/osc_io.c
+++ b/drivers/staging/lustre/lustre/osc/osc_io.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -221,7 +217,8 @@ static void osc_page_touch_at(const struct lu_env *env,
                kms > loi->loi_kms ? "" : "not ", loi->loi_kms, kms,
                loi->loi_lvb.lvb_size);
 
-        attr->cat_mtime = attr->cat_ctime = LTIME_S(CURRENT_TIME);
+        attr->cat_ctime = LTIME_S(CURRENT_TIME);
+        attr->cat_mtime = attr->cat_ctime;
         valid = CAT_MTIME | CAT_CTIME;
         if (kms > loi->loi_kms) {
                 attr->cat_kms = kms;
@@ -458,7 +455,8 @@ static int osc_io_setattr_start(const struct lu_env *env,
                         unsigned int cl_valid = 0;
 
                         if (ia_valid & ATTR_SIZE) {
-                                attr->cat_size = attr->cat_kms = size;
+                                attr->cat_size = size;
+                                attr->cat_kms = size;
                                 cl_valid = CAT_SIZE | CAT_KMS;
                         }
                         if (ia_valid & ATTR_MTIME_SET) {
@@ -526,7 +524,8 @@ static void osc_io_setattr_end(const struct lu_env *env,
 
         if (cbargs->opc_rpc_sent) {
                 wait_for_completion(&cbargs->opc_sync);
-                result = io->ci_result = cbargs->opc_rc;
+                result = cbargs->opc_rc;
+                io->ci_result = cbargs->opc_rc;
         }
         if (result == 0) {
                 if (oio->oi_lockless) {
@@ -575,7 +574,8 @@ static int osc_io_write_start(const struct lu_env *env,
 
         OBD_FAIL_TIMEOUT(OBD_FAIL_OSC_DELAY_SETTIME, 1);
         cl_object_attr_lock(obj);
-        attr->cat_mtime = attr->cat_ctime = ktime_get_real_seconds();
+        attr->cat_ctime = ktime_get_real_seconds();
+        attr->cat_mtime = attr->cat_ctime;
         rc = cl_object_attr_set(env, obj, attr, CAT_MTIME | CAT_CTIME);
         cl_object_attr_unlock(obj);
 
diff --git a/drivers/staging/lustre/lustre/osc/osc_lock.c b/drivers/staging/lustre/lustre/osc/osc_lock.c
index 16f9cd9d3b12..42def38d998b 100644
--- a/drivers/staging/lustre/lustre/osc/osc_lock.c
+++ b/drivers/staging/lustre/lustre/osc/osc_lock.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -1120,7 +1116,8 @@ static void osc_lock_set_writer(const struct lu_env *env,
                 }
         } else {
                 LASSERT(cl_io_is_mkwrite(io));
-                io_start = io_end = io->u.ci_fault.ft_index;
+                io_start = io->u.ci_fault.ft_index;
+                io_end = io->u.ci_fault.ft_index;
         }
 
         if (descr->cld_mode >= CLM_WRITE &&
diff --git a/drivers/staging/lustre/lustre/osc/osc_object.c b/drivers/staging/lustre/lustre/osc/osc_object.c
index 738ab10ab274..d211d1905e83 100644
--- a/drivers/staging/lustre/lustre/osc/osc_object.c
+++ b/drivers/staging/lustre/lustre/osc/osc_object.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/osc/osc_page.c b/drivers/staging/lustre/lustre/osc/osc_page.c
index c29c2eabe39c..57d8a5aa8bfb 100644
--- a/drivers/staging/lustre/lustre/osc/osc_page.c
+++ b/drivers/staging/lustre/lustre/osc/osc_page.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -52,13 +48,6 @@ static int osc_lru_reserve(const struct lu_env *env, struct osc_object *obj,
  *  @{
  */
 
-static int osc_page_protected(const struct lu_env *env,
-                              const struct osc_page *opg,
-                              enum cl_lock_mode mode, int unref)
-{
-        return 1;
-}
-
 /*****************************************************************************
  *
  * Page operations.
@@ -110,8 +99,6 @@ int osc_page_cache_add(const struct lu_env *env,
         struct osc_page *opg = cl2osc_page(slice);
         int result;
 
-        LINVRNT(osc_page_protected(env, opg, CLM_WRITE, 0));
-
         osc_page_transfer_get(opg, "transfer\0cache");
         result = osc_queue_async_io(env, io, opg);
         if (result != 0)
@@ -214,8 +201,6 @@ static void osc_page_delete(const struct lu_env *env,
         struct osc_object *obj = cl2osc(opg->ops_cl.cpl_obj);
         int rc;
 
-        LINVRNT(opg->ops_temp || osc_page_protected(env, opg, CLM_READ, 1));
-
         CDEBUG(D_TRACE, "%p\n", opg);
         osc_page_transfer_put(env, opg);
         rc = osc_teardown_async_page(env, obj, opg);
@@ -254,8 +239,6 @@ static void osc_page_clip(const struct lu_env *env,
         struct osc_page *opg = cl2osc_page(slice);
         struct osc_async_page *oap = &opg->ops_oap;
 
-        LINVRNT(osc_page_protected(env, opg, CLM_READ, 0));
-
         opg->ops_from = from;
         opg->ops_to = to;
         spin_lock(&oap->oap_lock);
@@ -269,8 +252,6 @@ static int osc_page_cancel(const struct lu_env *env,
         struct osc_page *opg = cl2osc_page(slice);
         int rc = 0;
 
-        LINVRNT(osc_page_protected(env, opg, CLM_READ, 0));
-
         /* Check if the transferring against this page
          * is completed, or not even queued.
          */
@@ -320,10 +301,6 @@ int osc_page_init(const struct lu_env *env, struct cl_object *obj,
                 cl_page_slice_add(page, &opg->ops_cl, obj, index,
                                   &osc_page_ops);
         }
-        /*
-         * Cannot assert osc_page_protected() here as read-ahead
-         * creates temporary pages outside of a lock.
-         */
         /* ops_inflight and ops_lru are the same field, but it doesn't
          * hurt to initialize it twice :-)
          */
@@ -382,9 +359,6 @@ void osc_page_submit(const struct lu_env *env, struct osc_page *opg,
         struct osc_async_page *oap = &opg->ops_oap;
         struct osc_object *obj = oap->oap_obj;
 
-        LINVRNT(osc_page_protected(env, opg,
-                                   crt == CRT_WRITE ? CLM_WRITE : CLM_READ, 1));
-
         LASSERTF(oap->oap_magic == OAP_MAGIC, "Bad oap magic: oap %p, magic 0x%x\n",
                  oap, oap->oap_magic);
         LASSERT(oap->oap_async_flags & ASYNC_READY);
diff --git a/drivers/staging/lustre/lustre/osc/osc_request.c b/drivers/staging/lustre/lustre/osc/osc_request.c
index 47417f88fe3c..7260027bb595 100644
--- a/drivers/staging/lustre/lustre/osc/osc_request.c
+++ b/drivers/staging/lustre/lustre/osc/osc_request.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -474,7 +470,8 @@ static int osc_real_create(struct obd_export *exp, struct obdo *oa,
                 DEBUG_REQ(D_HA, req,
                           "delorphan from OST integration");
                 /* Don't resend the delorphan req */
-                req->rq_no_resend = req->rq_no_delay = 1;
+                req->rq_no_resend = 1;
+                req->rq_no_delay = 1;
         }
 
         rc = ptlrpc_queue_wait(req);
@@ -2775,7 +2772,8 @@ static int osc_get_info(const struct lu_env *env, struct obd_export *exp,
                 tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
                 memcpy(tmp, key, keylen);
 
-                req->rq_no_delay = req->rq_no_resend = 1;
+                req->rq_no_delay = 1;
+                req->rq_no_resend = 1;
                 ptlrpc_request_set_replen(req);
                 rc = ptlrpc_queue_wait(req);
                 if (rc)
diff --git a/drivers/staging/lustre/lustre/ptlrpc/client.c b/drivers/staging/lustre/lustre/ptlrpc/client.c
index 4b7912a2cb52..22bf8930433b 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/client.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/client.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -3024,8 +3020,10 @@ void *ptlrpcd_alloc_work(struct obd_import *imp,
         req->rq_interpret_reply = work_interpreter;
         /* don't want reply */
         req->rq_receiving_reply = 0;
-        req->rq_req_unlink = req->rq_reply_unlink = 0;
-        req->rq_no_delay = req->rq_no_resend = 1;
+        req->rq_req_unlink = 0;
+        req->rq_reply_unlink = 0;
+        req->rq_no_delay = 1;
+        req->rq_no_resend = 1;
         req->rq_pill.rc_fmt = (void *)&worker_format;
 
         spin_lock_init(&req->rq_lock);
diff --git a/drivers/staging/lustre/lustre/ptlrpc/connection.c b/drivers/staging/lustre/lustre/ptlrpc/connection.c
index a14daff3fca0..177a379da9fa 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/connection.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/connection.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/events.c b/drivers/staging/lustre/lustre/ptlrpc/events.c
index fdcde9bbd788..b8ca7d60867a 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/events.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/events.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/import.c b/drivers/staging/lustre/lustre/ptlrpc/import.c
index a4f7544f46b8..914bbd2956fb 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/import.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/import.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -698,7 +694,8 @@ int ptlrpc_connect_import(struct obd_import *imp)
 
         lustre_msg_add_op_flags(request->rq_reqmsg, MSG_CONNECT_NEXT_VER);
 
-        request->rq_no_resend = request->rq_no_delay = 1;
+        request->rq_no_resend = 1;
+        request->rq_no_delay = 1;
         request->rq_send_state = LUSTRE_IMP_CONNECTING;
         /* Allow a slightly larger reply for future growth compatibility */
         req_capsule_set_size(&request->rq_pill, &RMF_CONNECT_DATA, RCL_SERVER,
diff --git a/drivers/staging/lustre/lustre/ptlrpc/layout.c b/drivers/staging/lustre/lustre/ptlrpc/layout.c
index c0ecd1625dc4..e6ff97daefa4 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/layout.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/layout.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/llog_client.c b/drivers/staging/lustre/lustre/ptlrpc/llog_client.c
index a23ac5f9ae96..0f55c01feba8 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/llog_client.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/llog_client.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/llog_net.c b/drivers/staging/lustre/lustre/ptlrpc/llog_net.c
index fbccb62213b5..bccdace7e51f 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/llog_net.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/llog_net.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c b/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c
index 64c0f1e17f36..bc93b75744e1 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -872,7 +868,8 @@ ptlrpc_lprocfs_svc_req_history_next(struct seq_file *s,
 
                 if (i > srhi->srhi_idx) { /* reset iterator for a new CPT */
                         srhi->srhi_req = NULL;
-                        seq = srhi->srhi_seq = 0;
+                        seq = 0;
+                        srhi->srhi_seq = 0;
                 } else { /* the next sequence */
                         seq = srhi->srhi_seq + (1 << svc->srv_cpt_bits);
                 }
@@ -1161,7 +1158,6 @@ void ptlrpc_lprocfs_brw(struct ptlrpc_request *req, int bytes)
 
         lprocfs_counter_add(svc_stats, idx, bytes);
 }
-
 EXPORT_SYMBOL(ptlrpc_lprocfs_brw);
 
 void ptlrpc_lprocfs_unregister_service(struct ptlrpc_service *svc)
diff --git a/drivers/staging/lustre/lustre/ptlrpc/niobuf.c b/drivers/staging/lustre/lustre/ptlrpc/niobuf.c
index 10b8fe82a342..ff9a95cb1832 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/niobuf.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/niobuf.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/nrs.c b/drivers/staging/lustre/lustre/ptlrpc/nrs.c
index c444f516856f..d88faf61e740 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/nrs.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/nrs.c
@@ -769,7 +769,7 @@ static int nrs_policy_register(struct ptlrpc_nrs *nrs,
         spin_unlock(&nrs->nrs_lock);
 
         if (rc != 0)
-                (void) nrs_policy_unregister(nrs, policy->pol_desc->pd_name);
+                (void)nrs_policy_unregister(nrs, policy->pol_desc->pd_name);
 
         return rc;
 }
diff --git a/drivers/staging/lustre/lustre/ptlrpc/pack_generic.c b/drivers/staging/lustre/lustre/ptlrpc/pack_generic.c
index 811acf6fc786..9ff58a1cad42 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/pack_generic.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/pack_generic.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/pers.c b/drivers/staging/lustre/lustre/ptlrpc/pers.c
index ec3af109a1d7..6c820e944171 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/pers.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/pers.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/pinger.c b/drivers/staging/lustre/lustre/ptlrpc/pinger.c
index 8a869315c258..c0529d808d81 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/pinger.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/pinger.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -57,7 +53,8 @@ ptlrpc_prep_ping(struct obd_import *imp)
                                         LUSTRE_OBD_VERSION, OBD_PING);
         if (req) {
                 ptlrpc_request_set_replen(req);
-                req->rq_no_resend = req->rq_no_delay = 1;
+                req->rq_no_resend = 1;
+                req->rq_no_delay = 1;
         }
         return req;
 }
diff --git a/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_internal.h b/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_internal.h
index 6ca26c98de1b..97e97e22b866 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_internal.h
+++ b/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_internal.h
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_module.c b/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_module.c
index a8ec0e9d7b2e..a70d5843f30e 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_module.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/ptlrpc_module.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/ptlrpcd.c b/drivers/staging/lustre/lustre/ptlrpc/ptlrpcd.c
index 76a355a9db8b..b0cf5859b1f1 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/ptlrpcd.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/ptlrpcd.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/recover.c b/drivers/staging/lustre/lustre/ptlrpc/recover.c
index 30d9a164e52d..718b3a8d61c6 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/recover.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/recover.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec.c b/drivers/staging/lustre/lustre/ptlrpc/sec.c
index 187fd1d6898c..f3b477305df6 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/sec.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/sec.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -1104,7 +1100,7 @@ int sptlrpc_cli_unwrap_early_reply(struct ptlrpc_request *req,
         early_req->rq_flvr = req->rq_flvr;
         early_req->rq_repbuf = early_buf;
         early_req->rq_repbuf_len = early_bufsz;
-        early_req->rq_repdata = (struct lustre_msg *) early_buf;
+        early_req->rq_repdata = (struct lustre_msg *)early_buf;
         early_req->rq_repdata_len = early_size;
         early_req->rq_early = 1;
         early_req->rq_reqmsg = req->rq_reqmsg;
@@ -1556,7 +1552,7 @@ void _sptlrpc_enlarge_msg_inplace(struct lustre_msg *msg,
         /* move from segment + 1 to end segment */
         LASSERT(msg->lm_magic == LUSTRE_MSG_MAGIC_V2);
         oldmsg_size = lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
-        movesize = oldmsg_size - ((unsigned long) src - (unsigned long) msg);
+        movesize = oldmsg_size - ((unsigned long)src - (unsigned long)msg);
         LASSERT(movesize >= 0);
 
         if (movesize)
@@ -2196,6 +2192,9 @@ int sptlrpc_pack_user_desc(struct lustre_msg *msg, int offset)
 
         pud = lustre_msg_buf(msg, offset, 0);
 
+        if (!pud)
+                return -EINVAL;
+
         pud->pud_uid = from_kuid(&init_user_ns, current_uid());
         pud->pud_gid = from_kgid(&init_user_ns, current_gid());
         pud->pud_fsuid = from_kuid(&init_user_ns, current_fsuid());
diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c b/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c
index 02e6cda4c995..5f4d79718589 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -273,7 +269,7 @@ static unsigned long enc_pools_shrink_scan(struct shrinker *s,
 static inline
 int npages_to_npools(unsigned long npages)
 {
-        return (int) ((npages + PAGES_PER_POOL - 1) / PAGES_PER_POOL);
+        return (int)((npages + PAGES_PER_POOL - 1) / PAGES_PER_POOL);
 }
 
 /*
diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_config.c b/drivers/staging/lustre/lustre/ptlrpc/sec_config.c
index a51b18bbfd34..1238c873bfdf 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/sec_config.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/sec_config.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -648,7 +644,7 @@ static int logname2fsname(const char *logname, char *buf, int buflen)
                 return -EINVAL;
         }
 
-        len = min((int) (ptr - logname), buflen - 1);
+        len = min((int)(ptr - logname), buflen - 1);
 
         memcpy(buf, logname, len);
         buf[len] = '\0';
diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c b/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c
index 9082da06b28a..9b9801ece582 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/sec_gc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_lproc.c b/drivers/staging/lustre/lustre/ptlrpc/sec_lproc.c
index e610a8ddd223..07273f577969 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/sec_lproc.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/sec_lproc.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_null.c b/drivers/staging/lustre/lustre/ptlrpc/sec_null.c
index 40e5349de38c..70a61e12bb7b 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/sec_null.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/sec_null.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -60,7 +56,7 @@ static struct ptlrpc_svc_ctx    null_svc_ctx;
 static inline
 void null_encode_sec_part(struct lustre_msg *msg, enum lustre_sec_part sp)
 {
-        msg->lm_secflvr |= (((__u32) sp) & 0xFF) << 24;
+        msg->lm_secflvr |= (((__u32)sp) & 0xFF) << 24;
 }
 
 static inline
@@ -265,7 +261,8 @@ int null_enlarge_reqbuf(struct ptlrpc_sec *sec,
                 memcpy(newbuf, req->rq_reqbuf, req->rq_reqlen);
 
                 kvfree(req->rq_reqbuf);
-                req->rq_reqbuf = req->rq_reqmsg = newbuf;
+                req->rq_reqbuf = newbuf;
+                req->rq_reqmsg = newbuf;
                 req->rq_reqbuf_len = alloc_size;
 
                 if (req->rq_import)
@@ -329,7 +326,7 @@ int null_alloc_rs(struct ptlrpc_request *req, int msgsize)
         rs->rs_svc_ctx = req->rq_svc_ctx;
         atomic_inc(&req->rq_svc_ctx->sc_refcount);
 
-        rs->rs_repbuf = (struct lustre_msg *) (rs + 1);
+        rs->rs_repbuf = (struct lustre_msg *)(rs + 1);
         rs->rs_repbuf_len = rs_size - sizeof(*rs);
         rs->rs_msg = rs->rs_repbuf;
 
diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_plain.c b/drivers/staging/lustre/lustre/ptlrpc/sec_plain.c
index 37c9f4c453de..5c4590b0c521 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/sec_plain.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/sec_plain.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -298,7 +294,7 @@ int plain_cli_wrap_bulk(struct ptlrpc_cli_ctx *ctx,
         LASSERT(req->rq_reqbuf->lm_bufcount == PLAIN_PACK_SEGMENTS);
 
         bsd = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_BULK_OFF, 0);
-        token = (struct plain_bulk_token *) bsd->bsd_data;
+        token = (struct plain_bulk_token *)bsd->bsd_data;
 
         bsd->bsd_version = 0;
         bsd->bsd_flags = 0;
@@ -343,7 +339,7 @@ int plain_cli_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
         LASSERT(req->rq_repdata->lm_bufcount == PLAIN_PACK_SEGMENTS);
 
         bsdv = lustre_msg_buf(req->rq_repdata, PLAIN_PACK_BULK_OFF, 0);
-        tokenv = (struct plain_bulk_token *) bsdv->bsd_data;
+        tokenv = (struct plain_bulk_token *)bsdv->bsd_data;
 
         if (req->rq_bulk_write) {
                 if (bsdv->bsd_flags & BSD_FL_ERR)
@@ -574,8 +570,12 @@ int plain_alloc_reqbuf(struct ptlrpc_sec *sec,
         lustre_init_msg_v2(req->rq_reqbuf, PLAIN_PACK_SEGMENTS, buflens, NULL);
         req->rq_reqmsg = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_MSG_OFF, 0);
 
-        if (req->rq_pack_udesc)
-                sptlrpc_pack_user_desc(req->rq_reqbuf, PLAIN_PACK_USER_OFF);
+        if (req->rq_pack_udesc) {
+                int rc = sptlrpc_pack_user_desc(req->rq_reqbuf,
+                                              PLAIN_PACK_USER_OFF);
+                if (rc < 0)
+                        return rc;
+        }
 
         return 0;
 }
@@ -811,7 +811,7 @@ int plain_alloc_rs(struct ptlrpc_request *req, int msgsize)
 
         rs->rs_svc_ctx = req->rq_svc_ctx;
         atomic_inc(&req->rq_svc_ctx->sc_refcount);
-        rs->rs_repbuf = (struct lustre_msg *) (rs + 1);
+        rs->rs_repbuf = (struct lustre_msg *)(rs + 1);
         rs->rs_repbuf_len = rs_size - sizeof(*rs);
 
         lustre_init_msg_v2(rs->rs_repbuf, PLAIN_PACK_SEGMENTS, buflens, NULL);
@@ -891,7 +891,7 @@ int plain_svc_unwrap_bulk(struct ptlrpc_request *req,
         LASSERT(req->rq_pack_bulk);
 
         bsdr = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_BULK_OFF, 0);
-        tokenr = (struct plain_bulk_token *) bsdr->bsd_data;
+        tokenr = (struct plain_bulk_token *)bsdr->bsd_data;
         bsdv = lustre_msg_buf(rs->rs_repbuf, PLAIN_PACK_BULK_OFF, 0);
 
         bsdv->bsd_version = 0;
@@ -926,7 +926,7 @@ int plain_svc_wrap_bulk(struct ptlrpc_request *req,
 
         bsdr = lustre_msg_buf(req->rq_reqbuf, PLAIN_PACK_BULK_OFF, 0);
         bsdv = lustre_msg_buf(rs->rs_repbuf, PLAIN_PACK_BULK_OFF, 0);
-        tokenv = (struct plain_bulk_token *) bsdv->bsd_data;
+        tokenv = (struct plain_bulk_token *)bsdv->bsd_data;
 
         bsdv->bsd_version = 0;
         bsdv->bsd_type = SPTLRPC_BULK_DEFAULT;
diff --git a/drivers/staging/lustre/lustre/ptlrpc/service.c b/drivers/staging/lustre/lustre/ptlrpc/service.c
index 17c7b9749f67..4788c4940c2a 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/service.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/service.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/lustre/lustre/ptlrpc/wiretest.c b/drivers/staging/lustre/lustre/ptlrpc/wiretest.c
index aacc8108391d..9fd9de958fe2 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/wiretest.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/wiretest.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
diff --git a/drivers/staging/rtl8192u/ieee80211/ieee80211.h b/drivers/staging/rtl8192u/ieee80211/ieee80211.h
index 68931e5ecd8f..09e9499b7f9d 100644
--- a/drivers/staging/rtl8192u/ieee80211/ieee80211.h
+++ b/drivers/staging/rtl8192u/ieee80211/ieee80211.h
@@ -1799,8 +1799,8 @@ struct ieee80211_device {
         short scanning;
         short proto_started;
 
-        struct semaphore wx_sem;
-        struct semaphore scan_sem;
+        struct mutex wx_mutex;
+        struct mutex scan_mutex;
 
         spinlock_t mgmt_tx_lock;
         spinlock_t beacon_lock;
diff --git a/drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c b/drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c
index d705595766a9..49db1b75cd05 100644
--- a/drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c
+++ b/drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c
@@ -427,7 +427,7 @@ void ieee80211_softmac_scan_syncro(struct ieee80211_device *ieee)
         short ch = 0;
         u8 channel_map[MAX_CHANNEL_NUMBER+1];
         memcpy(channel_map, GET_DOT11D_INFO(ieee)->channel_map, MAX_CHANNEL_NUMBER+1);
-        down(&ieee->scan_sem);
+        mutex_lock(&ieee->scan_mutex);
 
         while(1)
         {
@@ -475,13 +475,13 @@ void ieee80211_softmac_scan_syncro(struct ieee80211_device *ieee)
 out:
         if(ieee->state < IEEE80211_LINKED){
                 ieee->actscanning = false;
-                up(&ieee->scan_sem);
+                mutex_unlock(&ieee->scan_mutex);
         }
         else{
         ieee->sync_scan_hurryup = 0;
         if(IS_DOT11D_ENABLE(ieee))
                 DOT11D_ScanComplete(ieee);
-        up(&ieee->scan_sem);
+        mutex_unlock(&ieee->scan_mutex);
 }
 }
 EXPORT_SYMBOL(ieee80211_softmac_scan_syncro);
@@ -495,7 +495,7 @@ static void ieee80211_softmac_scan_wq(struct work_struct *work)
         memcpy(channel_map, GET_DOT11D_INFO(ieee)->channel_map, MAX_CHANNEL_NUMBER+1);
         if(!ieee->ieee_up)
                 return;
-        down(&ieee->scan_sem);
+        mutex_lock(&ieee->scan_mutex);
         do{
                 ieee->current_network.channel =
                         (ieee->current_network.channel + 1) % MAX_CHANNEL_NUMBER;
@@ -517,7 +517,7 @@ static void ieee80211_softmac_scan_wq(struct work_struct *work)
 
         schedule_delayed_work(&ieee->softmac_scan_wq, IEEE80211_SOFTMAC_SCAN_TIME);
 
-        up(&ieee->scan_sem);
+        mutex_unlock(&ieee->scan_mutex);
         return;
 out:
         if(IS_DOT11D_ENABLE(ieee))
@@ -525,7 +525,7 @@ out:
         ieee->actscanning = false;
         watchdog = 0;
         ieee->scanning = 0;
-        up(&ieee->scan_sem);
+        mutex_unlock(&ieee->scan_mutex);
 }
 
 
@@ -579,7 +579,7 @@ static void ieee80211_softmac_stop_scan(struct ieee80211_device *ieee)
 
         //ieee->sync_scan_hurryup = 1;
 
-        down(&ieee->scan_sem);
+        mutex_lock(&ieee->scan_mutex);
 //      spin_lock_irqsave(&ieee->lock, flags);
 
         if (ieee->scanning == 1) {
@@ -589,7 +589,7 @@ static void ieee80211_softmac_stop_scan(struct ieee80211_device *ieee)
         }
 
 //      spin_unlock_irqrestore(&ieee->lock, flags);
-        up(&ieee->scan_sem);
+        mutex_unlock(&ieee->scan_mutex);
 }
 
 void ieee80211_stop_scan(struct ieee80211_device *ieee)
@@ -621,7 +621,7 @@ static void ieee80211_start_scan(struct ieee80211_device *ieee)
 
 }
 
-/* called with wx_sem held */
+/* called with wx_mutex held */
 void ieee80211_start_scan_syncro(struct ieee80211_device *ieee)
 {
         if (IS_DOT11D_ENABLE(ieee) )
@@ -1389,7 +1389,7 @@ static void ieee80211_associate_procedure_wq(struct work_struct *work)
 {
         struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, associate_procedure_wq);
         ieee->sync_scan_hurryup = 1;
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
 
         if (ieee->data_hard_stop)
                 ieee->data_hard_stop(ieee->dev);
@@ -1402,7 +1402,7 @@ static void ieee80211_associate_procedure_wq(struct work_struct *work)
         ieee->associate_seq = 1;
         ieee80211_associate_step1(ieee);
 
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
 }
 
 inline void ieee80211_softmac_new_net(struct ieee80211_device *ieee, struct ieee80211_network *net)
@@ -2331,7 +2331,7 @@ static void ieee80211_start_ibss_wq(struct work_struct *work)
         struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, start_ibss_wq);
         /* iwconfig mode ad-hoc will schedule this and return
          * on the other hand this will block further iwconfig SET
-         * operations because of the wx_sem hold.
+         * operations because of the wx_mutex hold.
          * Anyway some most set operations set a flag to speed-up
          * (abort) this wq (when syncro scanning) before sleeping
          * on the semaphore
@@ -2340,7 +2340,7 @@ static void ieee80211_start_ibss_wq(struct work_struct *work)
                 printk("==========oh driver down return\n");
                 return;
         }
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
 
         if (ieee->current_network.ssid_len == 0) {
                 strcpy(ieee->current_network.ssid, IEEE80211_DEFAULT_TX_ESSID);
@@ -2431,7 +2431,7 @@ static void ieee80211_start_ibss_wq(struct work_struct *work)
                 ieee->data_hard_resume(ieee->dev);
         netif_carrier_on(ieee->dev);
 
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
 }
 
 inline void ieee80211_start_ibss(struct ieee80211_device *ieee)
@@ -2439,7 +2439,7 @@ inline void ieee80211_start_ibss(struct ieee80211_device *ieee)
         schedule_delayed_work(&ieee->start_ibss_wq, 150);
 }
 
-/* this is called only in user context, with wx_sem held */
+/* this is called only in user context, with wx_mutex held */
 void ieee80211_start_bss(struct ieee80211_device *ieee)
 {
         unsigned long flags;
@@ -2505,7 +2505,7 @@ static void ieee80211_associate_retry_wq(struct work_struct *work)
         struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, associate_retry_wq);
         unsigned long flags;
 
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
         if(!ieee->proto_started)
                 goto exit;
 
@@ -2537,7 +2537,7 @@ static void ieee80211_associate_retry_wq(struct work_struct *work)
         spin_unlock_irqrestore(&ieee->lock, flags);
 
 exit:
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
 }
 
 struct sk_buff *ieee80211_get_beacon_(struct ieee80211_device *ieee)
@@ -2583,9 +2583,9 @@ EXPORT_SYMBOL(ieee80211_get_beacon);
 void ieee80211_softmac_stop_protocol(struct ieee80211_device *ieee)
 {
         ieee->sync_scan_hurryup = 1;
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
         ieee80211_stop_protocol(ieee);
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
 }
 EXPORT_SYMBOL(ieee80211_softmac_stop_protocol);
 
@@ -2609,9 +2609,9 @@ void ieee80211_stop_protocol(struct ieee80211_device *ieee)
 void ieee80211_softmac_start_protocol(struct ieee80211_device *ieee)
 {
         ieee->sync_scan_hurryup = 0;
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
         ieee80211_start_protocol(ieee);
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
 }
 EXPORT_SYMBOL(ieee80211_softmac_start_protocol);
 
@@ -2728,8 +2728,8 @@ void ieee80211_softmac_init(struct ieee80211_device *ieee)
         INIT_WORK(&ieee->wx_sync_scan_wq, ieee80211_wx_sync_scan_wq);
 
 
-        sema_init(&ieee->wx_sem, 1);
-        sema_init(&ieee->scan_sem, 1);
+        mutex_init(&ieee->wx_mutex);
+        mutex_init(&ieee->scan_mutex);
 
         spin_lock_init(&ieee->mgmt_tx_lock);
         spin_lock_init(&ieee->beacon_lock);
@@ -2742,14 +2742,14 @@ void ieee80211_softmac_init(struct ieee80211_device *ieee)
 
 void ieee80211_softmac_free(struct ieee80211_device *ieee)
 {
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
         kfree(ieee->pDot11dInfo);
         ieee->pDot11dInfo = NULL;
         del_timer_sync(&ieee->associate_timer);
 
         cancel_delayed_work(&ieee->associate_retry_wq);
 
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
 }
 
 /********************************************************
@@ -3138,7 +3138,7 @@ int ieee80211_wpa_supplicant_ioctl(struct ieee80211_device *ieee, struct iw_poin
         struct ieee_param *param;
         int ret=0;
 
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
         //IEEE_DEBUG_INFO("wpa_supplicant: len=%d\n", p->length);
 
         if (p->length < sizeof(struct ieee_param) || !p->pointer) {
@@ -3183,7 +3183,7 @@ int ieee80211_wpa_supplicant_ioctl(struct ieee80211_device *ieee, struct iw_poin
 
         kfree(param);
 out:
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
 
         return ret;
 }
diff --git a/drivers/staging/rtl8192u/ieee80211/ieee80211_softmac_wx.c b/drivers/staging/rtl8192u/ieee80211/ieee80211_softmac_wx.c
index aad288a1f9e3..21bd0dc40888 100644
--- a/drivers/staging/rtl8192u/ieee80211/ieee80211_softmac_wx.c
+++ b/drivers/staging/rtl8192u/ieee80211/ieee80211_softmac_wx.c
@@ -34,7 +34,7 @@ int ieee80211_wx_set_freq(struct ieee80211_device *ieee, struct iw_request_info
         int ret;
         struct iw_freq *fwrq = &wrqu->freq;
 
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
 
         if (ieee->iw_mode == IW_MODE_INFRA) {
                 ret = -EOPNOTSUPP;
@@ -79,7 +79,7 @@ int ieee80211_wx_set_freq(struct ieee80211_device *ieee, struct iw_request_info
 
         ret = 0;
 out:
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
         return ret;
 }
 EXPORT_SYMBOL(ieee80211_wx_set_freq);
@@ -145,7 +145,7 @@ int ieee80211_wx_set_wap(struct ieee80211_device *ieee,
 
         ieee->sync_scan_hurryup = 1;
 
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
         /* use ifconfig hw ether */
         if (ieee->iw_mode == IW_MODE_MASTER) {
                 ret = -1;
@@ -173,7 +173,7 @@ int ieee80211_wx_set_wap(struct ieee80211_device *ieee,
         if (ifup)
                 ieee80211_start_protocol(ieee);
 out:
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
         return ret;
 }
 EXPORT_SYMBOL(ieee80211_wx_set_wap);
@@ -274,7 +274,7 @@ int ieee80211_wx_set_mode(struct ieee80211_device *ieee, struct iw_request_info
 
         ieee->sync_scan_hurryup = 1;
 
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
 
         if (wrqu->mode == ieee->iw_mode)
                 goto out;
@@ -293,7 +293,7 @@ int ieee80211_wx_set_mode(struct ieee80211_device *ieee, struct iw_request_info
         }
 
 out:
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
         return 0;
 }
 EXPORT_SYMBOL(ieee80211_wx_set_mode);
@@ -353,7 +353,7 @@ void ieee80211_wx_sync_scan_wq(struct work_struct *work)
                 ieee80211_start_send_beacons(ieee);
 
         netif_carrier_on(ieee->dev);
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
 
 }
 
@@ -362,7 +362,7 @@ int ieee80211_wx_set_scan(struct ieee80211_device *ieee, struct iw_request_info
 {
         int ret = 0;
 
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
 
         if (ieee->iw_mode == IW_MODE_MONITOR || !(ieee->proto_started)) {
                 ret = -1;
@@ -376,7 +376,7 @@ int ieee80211_wx_set_scan(struct ieee80211_device *ieee, struct iw_request_info
         }
 
 out:
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
         return ret;
 }
 EXPORT_SYMBOL(ieee80211_wx_set_scan);
@@ -391,7 +391,7 @@ int ieee80211_wx_set_essid(struct ieee80211_device *ieee,
         unsigned long flags;
 
         ieee->sync_scan_hurryup = 1;
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
 
         proto_started = ieee->proto_started;
 
@@ -430,7 +430,7 @@ int ieee80211_wx_set_essid(struct ieee80211_device *ieee,
         if (proto_started)
                 ieee80211_start_protocol(ieee);
 out:
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
         return ret;
 }
 EXPORT_SYMBOL(ieee80211_wx_set_essid);
@@ -453,7 +453,7 @@ int ieee80211_wx_set_rawtx(struct ieee80211_device *ieee,
         int enable = (parms[0] > 0);
         short prev = ieee->raw_tx;
 
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
 
         if (enable)
                 ieee->raw_tx = 1;
@@ -475,7 +475,7 @@ int ieee80211_wx_set_rawtx(struct ieee80211_device *ieee,
                         netif_carrier_off(ieee->dev);
         }
 
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
 
         return 0;
 }
@@ -514,7 +514,7 @@ int ieee80211_wx_set_power(struct ieee80211_device *ieee,
 {
         int ret = 0;
 
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
 
         if (wrqu->power.disabled) {
                 ieee->ps = IEEE80211_PS_DISABLED;
@@ -553,7 +553,7 @@ int ieee80211_wx_set_power(struct ieee80211_device *ieee,
 
         }
 exit:
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
         return ret;
 
 }
@@ -564,7 +564,7 @@ int ieee80211_wx_get_power(struct ieee80211_device *ieee,
                                  struct iw_request_info *info,
                                  union iwreq_data *wrqu, char *extra)
 {
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
 
         if (ieee->ps == IEEE80211_PS_DISABLED) {
                 wrqu->power.disabled = 1;
@@ -592,7 +592,7 @@ int ieee80211_wx_get_power(struct ieee80211_device *ieee,
                 wrqu->power.flags |= IW_POWER_UNICAST_R;
 
 exit:
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
         return 0;
 
 }
diff --git a/drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c b/drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c
index 208be5fc527a..563d7fed6e1c 100644
--- a/drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c
+++ b/drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c
@@ -253,7 +253,7 @@ int ieee80211_wx_get_scan(struct ieee80211_device *ieee,
         int i = 0;
         int err = 0;
         IEEE80211_DEBUG_WX("Getting scan\n");
-        down(&ieee->wx_sem);
+        mutex_lock(&ieee->wx_mutex);
         spin_lock_irqsave(&ieee->lock, flags);
 
         list_for_each_entry(network, &ieee->network_list, list) {
@@ -262,7 +262,7 @@ int ieee80211_wx_get_scan(struct ieee80211_device *ieee,
                 {
                         err = -E2BIG;
                         break;
-                                                                                                }
+                }
                 if (ieee->scan_age == 0 ||
                     time_after(network->last_scanned + ieee->scan_age, jiffies))
                         ev = rtl819x_translate_scan(ieee, ev, stop, network, info);
@@ -277,7 +277,7 @@ int ieee80211_wx_get_scan(struct ieee80211_device *ieee,
         }
 
         spin_unlock_irqrestore(&ieee->lock, flags);
-        up(&ieee->wx_sem);
+        mutex_unlock(&ieee->wx_mutex);
         wrqu->data.length = ev -  extra;
         wrqu->data.flags = 0;
 
diff --git a/drivers/staging/rtl8192u/r8180_93cx6.c b/drivers/staging/rtl8192u/r8180_93cx6.c
index 97d9b3f49114..f35defc36fd9 100644
--- a/drivers/staging/rtl8192u/r8180_93cx6.c
+++ b/drivers/staging/rtl8192u/r8180_93cx6.c
@@ -23,8 +23,11 @@
 static void eprom_cs(struct net_device *dev, short bit)
 {
         u8 cmdreg;
+        int err;
 
-        read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
+        err = read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
+        if (err)
+                return;
         if (bit)
                 /* enable EPROM */
                 write_nic_byte_E(dev, EPROM_CMD, cmdreg | EPROM_CS_BIT);
@@ -40,8 +43,11 @@ static void eprom_cs(struct net_device *dev, short bit)
 static void eprom_ck_cycle(struct net_device *dev)
 {
         u8 cmdreg;
+        int err;
 
-        read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
+        err = read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
+        if (err)
+                return;
         write_nic_byte_E(dev, EPROM_CMD, cmdreg | EPROM_CK_BIT);
         force_pci_posting(dev);
         udelay(EPROM_DELAY);
@@ -56,8 +62,11 @@ static void eprom_ck_cycle(struct net_device *dev)
 static void eprom_w(struct net_device *dev, short bit)
 {
         u8 cmdreg;
+        int err;
 
-        read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
+        err = read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
+        if (err)
+                return;
         if (bit)
                 write_nic_byte_E(dev, EPROM_CMD, cmdreg | EPROM_W_BIT);
         else
@@ -71,8 +80,12 @@ static void eprom_w(struct net_device *dev, short bit)
 static short eprom_r(struct net_device *dev)
 {
         u8 bit;
+        int err;
+
+        err = read_nic_byte_E(dev, EPROM_CMD, &bit);
+        if (err)
+                return err;
 
-        read_nic_byte_E(dev, EPROM_CMD, &bit);
         udelay(EPROM_DELAY);
 
         if (bit & EPROM_R_BIT)
@@ -93,7 +106,7 @@ static void eprom_send_bits_string(struct net_device *dev, short b[], int len)
 }
 
 
-u32 eprom_read(struct net_device *dev, u32 addr)
+int eprom_read(struct net_device *dev, u32 addr)
 {
         struct r8192_priv *priv = ieee80211_priv(dev);
         short read_cmd[] = {1, 1, 0};
@@ -101,6 +114,7 @@ u32 eprom_read(struct net_device *dev, u32 addr)
         int i;
         int addr_len;
         u32 ret;
+        int err;
 
         ret = 0;
         /* enable EPROM programming */
@@ -144,7 +158,11 @@ u32 eprom_read(struct net_device *dev, u32 addr)
                  * and reading data. (eeprom outs a dummy 0)
                  */
                 eprom_ck_cycle(dev);
-                ret |= (eprom_r(dev)<<(15-i));
+                err = eprom_r(dev);
+                if (err < 0)
+                        return err;
+
+                ret |= err<<(15-i);
         }
 
         eprom_cs(dev, 0);
diff --git a/drivers/staging/rtl8192u/r8180_93cx6.h b/drivers/staging/rtl8192u/r8180_93cx6.h
index b840348eb5e3..9cf7f587c3ab 100644
--- a/drivers/staging/rtl8192u/r8180_93cx6.h
+++ b/drivers/staging/rtl8192u/r8180_93cx6.h
@@ -40,4 +40,4 @@
 #define EPROM_TXPW1 0x3d
 
 
-u32 eprom_read(struct net_device *dev, u32 addr); /* reads a 16 bits word */
+int eprom_read(struct net_device *dev, u32 addr); /* reads a 16 bits word */
diff --git a/drivers/staging/rtl8192u/r8192U.h b/drivers/staging/rtl8192u/r8192U.h
index ee1c72267811..821afc0ddac5 100644
--- a/drivers/staging/rtl8192u/r8192U.h
+++ b/drivers/staging/rtl8192u/r8192U.h
@@ -879,8 +879,7 @@ typedef struct r8192_priv {
         /* If 1, allow bad crc frame, reception in monitor mode */
         short crcmon;
 
-        struct semaphore wx_sem;
-        struct semaphore rf_sem;        /* Used to lock rf write operation */
+        struct mutex wx_mutex;
 
         u8 rf_type;                     /* 0: 1T2R, 1: 2T4R */
         RT_RF_TYPE_819xU rf_chip;
@@ -1129,10 +1128,10 @@ int read_nic_byte(struct net_device *dev, int x, u8 *data);
 int read_nic_byte_E(struct net_device *dev, int x, u8 *data);
 int read_nic_dword(struct net_device *dev, int x, u32 *data);
 int read_nic_word(struct net_device *dev, int x, u16 *data);
-void write_nic_byte(struct net_device *dev, int x, u8 y);
-void write_nic_byte_E(struct net_device *dev, int x, u8 y);
-void write_nic_word(struct net_device *dev, int x, u16 y);
-void write_nic_dword(struct net_device *dev, int x, u32 y);
+int write_nic_byte(struct net_device *dev, int x, u8 y);
+int write_nic_byte_E(struct net_device *dev, int x, u8 y);
+int write_nic_word(struct net_device *dev, int x, u16 y);
+int write_nic_dword(struct net_device *dev, int x, u32 y);
 void force_pci_posting(struct net_device *dev);
 
 void rtl8192_rtx_disable(struct net_device *);
diff --git a/drivers/staging/rtl8192u/r8192U_core.c b/drivers/staging/rtl8192u/r8192U_core.c
index 8c1d73719147..dd0970facdf5 100644
--- a/drivers/staging/rtl8192u/r8192U_core.c
+++ b/drivers/staging/rtl8192u/r8192U_core.c
@@ -253,7 +253,7 @@ u32 read_cam(struct net_device *dev, u8 addr)
         return data;
 }
 
-void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
+int write_nic_byte_E(struct net_device *dev, int indx, u8 data)
 {
         int status;
         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
@@ -261,7 +261,7 @@ void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
         u8 *usbdata = kzalloc(sizeof(data), GFP_KERNEL);
 
         if (!usbdata)
-                return;
+                return -ENOMEM;
         *usbdata = data;
 
         status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
@@ -269,9 +269,12 @@ void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
                                  indx | 0xfe00, 0, usbdata, 1, HZ / 2);
         kfree(usbdata);
 
-        if (status < 0)
+        if (status < 0){
                 netdev_err(dev, "write_nic_byte_E TimeOut! status: %d\n",
                            status);
+                return status;
+        }
+        return 0;
 }
 
 int read_nic_byte_E(struct net_device *dev, int indx, u8 *data)
@@ -299,7 +302,7 @@ int read_nic_byte_E(struct net_device *dev, int indx, u8 *data)
 }
 
 /* as 92U has extend page from 4 to 16, so modify functions below. */
-void write_nic_byte(struct net_device *dev, int indx, u8 data)
+int write_nic_byte(struct net_device *dev, int indx, u8 data)
 {
         int status;
 
@@ -308,7 +311,7 @@ void write_nic_byte(struct net_device *dev, int indx, u8 data)
         u8 *usbdata = kzalloc(sizeof(data), GFP_KERNEL);
 
         if (!usbdata)
-                return;
+                return -ENOMEM;
         *usbdata = data;
 
         status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
@@ -317,12 +320,16 @@ void write_nic_byte(struct net_device *dev, int indx, u8 data)
                                  usbdata, 1, HZ / 2);
         kfree(usbdata);
 
-        if (status < 0)
+        if (status < 0) {
                 netdev_err(dev, "write_nic_byte TimeOut! status: %d\n", status);
+                return status;
+        }
+
+        return 0;
 }
 
 
-void write_nic_word(struct net_device *dev, int indx, u16 data)
+int write_nic_word(struct net_device *dev, int indx, u16 data)
 {
         int status;
 
@@ -331,7 +338,7 @@ void write_nic_word(struct net_device *dev, int indx, u16 data)
         u16 *usbdata = kzalloc(sizeof(data), GFP_KERNEL);
 
         if (!usbdata)
-                return;
+                return -ENOMEM;
         *usbdata = data;
 
         status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
@@ -340,12 +347,16 @@ void write_nic_word(struct net_device *dev, int indx, u16 data)
                                  usbdata, 2, HZ / 2);
         kfree(usbdata);
 
-        if (status < 0)
+        if (status < 0) {
                 netdev_err(dev, "write_nic_word TimeOut! status: %d\n", status);
+                return status;
+        }
+
+        return 0;
 }
 
 
-void write_nic_dword(struct net_device *dev, int indx, u32 data)
+int write_nic_dword(struct net_device *dev, int indx, u32 data)
 {
         int status;
 
@@ -354,7 +365,7 @@ void write_nic_dword(struct net_device *dev, int indx, u32 data)
         u32 *usbdata = kzalloc(sizeof(data), GFP_KERNEL);
 
         if (!usbdata)
-                return;
+                return -ENOMEM;
         *usbdata = data;
 
         status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
@@ -364,9 +375,13 @@ void write_nic_dword(struct net_device *dev, int indx, u32 data)
         kfree(usbdata);
 
 
-        if (status < 0)
+        if (status < 0) {
                 netdev_err(dev, "write_nic_dword TimeOut! status: %d\n",
                            status);
+                return status;
+        }
+
+        return 0;
 }
 
 
@@ -2361,8 +2376,7 @@ static void rtl8192_init_priv_lock(struct r8192_priv *priv)
 {
         spin_lock_init(&priv->tx_lock);
         spin_lock_init(&priv->irq_lock);
-        sema_init(&priv->wx_sem, 1);
-        sema_init(&priv->rf_sem, 1);
+        mutex_init(&priv->wx_mutex);
         mutex_init(&priv->mutex);
 }
 
@@ -2421,7 +2435,7 @@ static inline u16 endian_swap(u16 *data)
         return *data;
 }
 
-static void rtl8192_read_eeprom_info(struct net_device *dev)
+static int rtl8192_read_eeprom_info(struct net_device *dev)
 {
         u16 wEPROM_ID = 0;
         u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
@@ -2429,9 +2443,13 @@ static void rtl8192_read_eeprom_info(struct net_device *dev)
         struct r8192_priv *priv = ieee80211_priv(dev);
         u16 tmpValue = 0;
         int i;
+        int ret;
 
         RT_TRACE(COMP_EPROM, "===========>%s()\n", __func__);
-        wEPROM_ID = eprom_read(dev, 0); /* first read EEPROM ID out; */
+        ret = eprom_read(dev, 0); /* first read EEPROM ID out; */
+        if (ret < 0)
+                return ret;
+        wEPROM_ID = (u16)ret;
         RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
 
         if (wEPROM_ID != RTL8190_EEPROM_ID)
@@ -2443,13 +2461,25 @@ static void rtl8192_read_eeprom_info(struct net_device *dev)
 
         if (bLoad_From_EEPOM) {
                 tmpValue = eprom_read(dev, EEPROM_VID >> 1);
+                ret = eprom_read(dev, EEPROM_VID >> 1);
+                if (ret < 0)
+                        return ret;
+                tmpValue = (u16)ret;
                 priv->eeprom_vid = endian_swap(&tmpValue);
-                priv->eeprom_pid = eprom_read(dev, EEPROM_PID >> 1);
-                tmpValue = eprom_read(dev, EEPROM_ChannelPlan >> 1);
+                ret = eprom_read(dev, EEPROM_PID >> 1);
+                if (ret < 0)
+                        return ret;
+                priv->eeprom_pid = (u16)ret;
+                ret = eprom_read(dev, EEPROM_ChannelPlan >> 1);
+                if (ret < 0)
+                        return ret;
+                tmpValue = (u16)ret;
                 priv->eeprom_ChannelPlan = (tmpValue & 0xff00) >> 8;
                 priv->btxpowerdata_readfromEEPORM = true;
-                priv->eeprom_CustomerID =
-                        eprom_read(dev, (EEPROM_Customer_ID >> 1)) >> 8;
+                ret = eprom_read(dev, (EEPROM_Customer_ID >> 1)) >> 8;
+                if (ret < 0)
+                        return ret;
+                priv->eeprom_CustomerID = (u16)ret;
         } else {
                 priv->eeprom_vid = 0;
                 priv->eeprom_pid = 0;
@@ -2467,10 +2497,10 @@ static void rtl8192_read_eeprom_info(struct net_device *dev)
                 int i;
 
                 for (i = 0; i < 6; i += 2) {
-                        u16 tmp = 0;
-
-                        tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i) >> 1));
-                        *(u16 *)(&dev->dev_addr[i]) = tmp;
+                        ret = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i) >> 1));
+                        if (ret < 0)
+                                return ret;
+                        *(u16 *)(&dev->dev_addr[i]) = (u16)ret;
                 }
         } else {
                 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
@@ -2482,52 +2512,72 @@ static void rtl8192_read_eeprom_info(struct net_device *dev)
 
         if (priv->card_8192_version == (u8)VERSION_819xU_A) {
                 /* read Tx power gain offset of legacy OFDM to HT rate */
-                if (bLoad_From_EEPOM)
-                        priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff >> 1)) & 0xff00) >> 8;
-                else
+                if (bLoad_From_EEPOM) {
+                        ret = eprom_read(dev, (EEPROM_TxPowerDiff >> 1));
+                        if (ret < 0)
+                                return ret;
+                        priv->EEPROMTxPowerDiff = ((u16)ret & 0xff00) >> 8;
+                } else
                         priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
                 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
                 /* read ThermalMeter from EEPROM */
-                if (bLoad_From_EEPOM)
-                        priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter >> 1)) & 0x00ff);
-                else
+                if (bLoad_From_EEPOM) {
+                        ret = eprom_read(dev, (EEPROM_ThermalMeter >> 1));
+                        if (ret < 0)
+                                return ret;
+                        priv->EEPROMThermalMeter = (u8)((u16)ret & 0x00ff);
+                } else
                         priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
                 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
                 /* for tx power track */
                 priv->TSSI_13dBm = priv->EEPROMThermalMeter * 100;
                 /* read antenna tx power offset of B/C/D to A from EEPROM */
-                if (bLoad_From_EEPOM)
-                        priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff >> 1)) & 0x0f00) >> 8;
-                else
+                if (bLoad_From_EEPOM) {
+                        ret = eprom_read(dev, (EEPROM_PwDiff >> 1));
+                        if (ret < 0)
+                                return ret;
+                        priv->EEPROMPwDiff = ((u16)ret & 0x0f00) >> 8;
+                } else
                         priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
                 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
                 /* Read CrystalCap from EEPROM */
-                if (bLoad_From_EEPOM)
-                        priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap >> 1)) & 0x0f);
-                else
+                if (bLoad_From_EEPOM) {
+                        ret = eprom_read(dev, (EEPROM_CrystalCap >> 1));
+                        if (ret < 0)
+                                return ret;
+                        priv->EEPROMCrystalCap = (u16)ret & 0x0f;
+                } else
                         priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
                 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
                 /* get per-channel Tx power level */
-                if (bLoad_From_EEPOM)
-                        priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver >> 1)) & 0xff00) >> 8;
-                else
+                if (bLoad_From_EEPOM) {
+                        ret = eprom_read(dev, (EEPROM_TxPwIndex_Ver >> 1));
+                        if (ret < 0)
+                                return ret;
+                        priv->EEPROM_Def_Ver = ((u16)ret & 0xff00) >> 8;
+                } else
                         priv->EEPROM_Def_Ver = 1;
                 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
                 if (priv->EEPROM_Def_Ver == 0) { /* old eeprom definition */
                         int i;
 
-                        if (bLoad_From_EEPOM)
-                                priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK >> 1)) & 0xff) >> 8;
-                        else
+                        if (bLoad_From_EEPOM) {
+                                ret = eprom_read(dev, (EEPROM_TxPwIndex_CCK >> 1));
+                                if (ret < 0)
+                                        return ret;
+                                priv->EEPROMTxPowerLevelCCK = ((u16)ret & 0xff) >> 8;
+                        } else
                                 priv->EEPROMTxPowerLevelCCK = 0x10;
                         RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
                         for (i = 0; i < 3; i++) {
                                 if (bLoad_From_EEPOM) {
-                                        tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G + i) >> 1);
+                                        ret = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G + i) >> 1);
+                                        if ( ret < 0)
+                                                return ret;
                                         if (((EEPROM_TxPwIndex_OFDM_24G + i) % 2) == 0)
-                                                tmpValue = tmpValue & 0x00ff;
+                                                tmpValue = (u16)ret & 0x00ff;
                                         else
-                                                tmpValue = (tmpValue & 0xff00) >> 8;
+                                                tmpValue = ((u16)ret & 0xff00) >> 8;
                                 } else {
                                         tmpValue = 0x10;
                                 }
@@ -2536,17 +2586,21 @@ static void rtl8192_read_eeprom_info(struct net_device *dev)
                         }
                 } else if (priv->EEPROM_Def_Ver == 1) {
                         if (bLoad_From_EEPOM) {
-                                tmpValue = eprom_read(dev,
-                                                EEPROM_TxPwIndex_CCK_V1 >> 1);
-                                tmpValue = (tmpValue & 0xff00) >> 8;
+                                ret = eprom_read(dev, EEPROM_TxPwIndex_CCK_V1 >> 1);
+                                if (ret < 0)
+                                        return ret;
+                                tmpValue = ((u16)ret & 0xff00) >> 8;
                         } else {
                                 tmpValue = 0x10;
                         }
                         priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
 
-                        if (bLoad_From_EEPOM)
-                                tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2) >> 1);
-                        else
+                        if (bLoad_From_EEPOM) {
+                                ret = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2) >> 1);
+                                if (ret < 0)
+                                        return ret;
+                                tmpValue = (u16)ret;
+                        } else
                                 tmpValue = 0x1010;
                         *((u16 *)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
                         if (bLoad_From_EEPOM)
@@ -2644,6 +2698,8 @@ static void rtl8192_read_eeprom_info(struct net_device *dev)
         init_rate_adaptive(dev);
 
         RT_TRACE(COMP_EPROM, "<===========%s()\n", __func__);
+
+        return 0;
 }
 
 static short rtl8192_get_channel_map(struct net_device *dev)
@@ -2664,6 +2720,7 @@ static short rtl8192_get_channel_map(struct net_device *dev)
 static short rtl8192_init(struct net_device *dev)
 {
         struct r8192_priv *priv = ieee80211_priv(dev);
+        int err;
 
         memset(&(priv->stats), 0, sizeof(struct Stats));
         memset(priv->txqueue_to_outpipemap, 0, 9);
@@ -2685,7 +2742,14 @@ static short rtl8192_init(struct net_device *dev)
         rtl8192_init_priv_lock(priv);
         rtl8192_init_priv_task(dev);
         rtl8192_get_eeprom_size(dev);
-        rtl8192_read_eeprom_info(dev);
+        err = rtl8192_read_eeprom_info(dev);
+        if (err) {
+                DMESG("Reading EEPROM info failed");
+                kfree(priv->pFirmware);
+                priv->pFirmware = NULL;
+                free_ieee80211(dev);
+                return err;
+        }
         rtl8192_get_channel_map(dev);
         init_hal_dm(dev);
         setup_timer(&priv->watch_dog_timer, watch_dog_timer_callback,
@@ -3303,12 +3367,12 @@ RESET_START:
 
                 /* Set the variable for reset. */
                 priv->ResetProgress = RESET_TYPE_SILENT;
-                down(&priv->wx_sem);
+                mutex_lock(&priv->wx_mutex);
                 if (priv->up == 0) {
                         RT_TRACE(COMP_ERR,
                                  "%s():the driver is not up! return\n",
                                  __func__);
-                        up(&priv->wx_sem);
+                        mutex_unlock(&priv->wx_mutex);
                         return;
                 }
                 priv->up = 0;
@@ -3323,19 +3387,19 @@ RESET_START:
 
                 ieee->sync_scan_hurryup = 1;
                 if (ieee->state == IEEE80211_LINKED) {
-                        down(&ieee->wx_sem);
+                        mutex_lock(&ieee->wx_mutex);
                         netdev_dbg(dev, "ieee->state is IEEE80211_LINKED\n");
                         ieee80211_stop_send_beacons(priv->ieee80211);
                         del_timer_sync(&ieee->associate_timer);
                         cancel_delayed_work(&ieee->associate_retry_wq);
                         ieee80211_stop_scan(ieee);
                         netif_carrier_off(dev);
-                        up(&ieee->wx_sem);
+                        mutex_unlock(&ieee->wx_mutex);
                 } else {
                         netdev_dbg(dev, "ieee->state is NOT LINKED\n");
                         ieee80211_softmac_stop_protocol(priv->ieee80211);
                 }
-                up(&priv->wx_sem);
+                mutex_unlock(&priv->wx_mutex);
                 RT_TRACE(COMP_RESET,
                          "%s():<==========down process is finished\n",
                          __func__);
@@ -3533,9 +3597,9 @@ static int rtl8192_open(struct net_device *dev)
         struct r8192_priv *priv = ieee80211_priv(dev);
         int ret;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
         ret = rtl8192_up(dev);
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return ret;
 }
 
@@ -3556,11 +3620,11 @@ static int rtl8192_close(struct net_device *dev)
         struct r8192_priv *priv = ieee80211_priv(dev);
         int ret;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = rtl8192_down(dev);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return ret;
 }
@@ -3632,11 +3696,11 @@ static void rtl8192_restart(struct work_struct *work)
                                                reset_wq);
         struct net_device *dev = priv->ieee80211->dev;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         rtl8192_commit(dev);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 }
 
 static void r8192_set_multicast(struct net_device *dev)
@@ -3659,12 +3723,12 @@ static int r8192_set_mac_adr(struct net_device *dev, void *mac)
         struct r8192_priv *priv = ieee80211_priv(dev);
         struct sockaddr *addr = mac;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ether_addr_copy(dev->dev_addr, addr->sa_data);
 
         schedule_work(&priv->reset_wq);
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return 0;
 }
@@ -3681,7 +3745,7 @@ static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
         struct iw_point *p = &wrq->u.data;
         struct ieee_param *ipw = NULL;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
 
         if (p->length < sizeof(struct ieee_param) || !p->pointer) {
@@ -3774,7 +3838,7 @@ static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
         kfree(ipw);
         ipw = NULL;
 out:
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return ret;
 }
 
diff --git a/drivers/staging/rtl8192u/r8192U_wx.c b/drivers/staging/rtl8192u/r8192U_wx.c
index 837704de3ea4..d2f2f246063f 100644
--- a/drivers/staging/rtl8192u/r8192U_wx.c
+++ b/drivers/staging/rtl8192u/r8192U_wx.c
@@ -67,11 +67,11 @@ static int r8192_wx_set_rate(struct net_device *dev,
         int ret;
         struct r8192_priv *priv = ieee80211_priv(dev);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_set_rate(priv->ieee80211, info, wrqu, extra);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return ret;
 }
@@ -83,11 +83,11 @@ static int r8192_wx_set_rts(struct net_device *dev,
         int ret;
         struct r8192_priv *priv = ieee80211_priv(dev);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_set_rts(priv->ieee80211, info, wrqu, extra);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return ret;
 }
@@ -108,11 +108,11 @@ static int r8192_wx_set_power(struct net_device *dev,
         int ret;
         struct r8192_priv *priv = ieee80211_priv(dev);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_set_power(priv->ieee80211, info, wrqu, extra);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return ret;
 }
@@ -132,11 +132,11 @@ static int r8192_wx_force_reset(struct net_device *dev,
 {
         struct r8192_priv *priv = ieee80211_priv(dev);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         netdev_dbg(dev, "%s(): force reset ! extra is %d\n", __func__, *extra);
         priv->force_reset = *extra;
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return 0;
 
 }
@@ -148,11 +148,11 @@ static int r8192_wx_set_rawtx(struct net_device *dev,
         struct r8192_priv *priv = ieee80211_priv(dev);
         int ret;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_set_rawtx(priv->ieee80211, info, wrqu, extra);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return ret;
 
@@ -166,7 +166,7 @@ static int r8192_wx_set_crcmon(struct net_device *dev,
         int *parms = (int *)extra;
         int enable = (parms[0] > 0);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         if (enable)
                 priv->crcmon = 1;
@@ -176,7 +176,7 @@ static int r8192_wx_set_crcmon(struct net_device *dev,
         DMESG("bad CRC in monitor mode are %s",
               priv->crcmon ? "accepted" : "rejected");
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return 0;
 }
@@ -187,13 +187,13 @@ static int r8192_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
         struct r8192_priv *priv = ieee80211_priv(dev);
         int ret;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_set_mode(priv->ieee80211, a, wrqu, b);
 
         rtl8192_set_rxconf(dev);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return ret;
 }
 
@@ -338,7 +338,7 @@ static int r8192_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
                 }
         }
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
         if (priv->ieee80211->state != IEEE80211_LINKED) {
                 priv->ieee80211->scanning = 0;
                 ieee80211_softmac_scan_syncro(priv->ieee80211);
@@ -346,7 +346,7 @@ static int r8192_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
         } else {
                 ret = ieee80211_wx_set_scan(priv->ieee80211, a, wrqu, b);
         }
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return ret;
 }
 
@@ -361,11 +361,11 @@ static int r8192_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
         if (!priv->up)
                 return -ENETDOWN;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_get_scan(priv->ieee80211, a, wrqu, b);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return ret;
 }
@@ -377,11 +377,11 @@ static int r8192_wx_set_essid(struct net_device *dev,
         struct r8192_priv *priv = ieee80211_priv(dev);
         int ret;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_set_essid(priv->ieee80211, a, wrqu, b);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return ret;
 }
@@ -393,11 +393,11 @@ static int r8192_wx_get_essid(struct net_device *dev,
         int ret;
         struct r8192_priv *priv = ieee80211_priv(dev);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_get_essid(priv->ieee80211, a, wrqu, b);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return ret;
 }
@@ -408,11 +408,11 @@ static int r8192_wx_set_freq(struct net_device *dev, struct iw_request_info *a,
         int ret;
         struct r8192_priv *priv = ieee80211_priv(dev);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_set_freq(priv->ieee80211, a, wrqu, b);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return ret;
 }
 
@@ -468,11 +468,11 @@ static int r8192_wx_set_wap(struct net_device *dev,
         int ret;
         struct r8192_priv *priv = ieee80211_priv(dev);
         /* struct sockaddr *temp = (struct sockaddr *)awrq; */
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         ret = ieee80211_wx_set_wap(priv->ieee80211, info, awrq, extra);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return ret;
 
@@ -515,12 +515,12 @@ static int r8192_wx_set_enc(struct net_device *dev,
         if (!priv->up)
                 return -ENETDOWN;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         RT_TRACE(COMP_SEC, "Setting SW wep key");
         ret = ieee80211_wx_set_encode(priv->ieee80211, info, wrqu, key);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
 
 
@@ -619,7 +619,7 @@ static int r8192_wx_set_retry(struct net_device *dev,
         struct r8192_priv *priv = ieee80211_priv(dev);
         int err = 0;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
 
         if (wrqu->retry.flags & IW_RETRY_LIFETIME ||
             wrqu->retry.disabled){
@@ -652,7 +652,7 @@ static int r8192_wx_set_retry(struct net_device *dev,
 
         rtl8192_commit(dev);
 exit:
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return err;
 }
@@ -701,7 +701,7 @@ static int r8192_wx_set_sens(struct net_device *dev,
         struct r8192_priv *priv = ieee80211_priv(dev);
         short err = 0;
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
         if (priv->rf_set_sens == NULL) {
                 err = -1; /* we have not this support for this radio */
                 goto exit;
@@ -712,7 +712,7 @@ static int r8192_wx_set_sens(struct net_device *dev,
                 err = -EINVAL;
 
 exit:
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
 
         return err;
 }
@@ -727,7 +727,7 @@ static int r8192_wx_set_enc_ext(struct net_device *dev,
         struct ieee80211_device *ieee = priv->ieee80211;
 
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
         ret = ieee80211_wx_set_encode_ext(priv->ieee80211, info, wrqu, extra);
 
         {
@@ -790,7 +790,7 @@ static int r8192_wx_set_enc_ext(struct net_device *dev,
 
 end_hw_sec:
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return ret;
 
 }
@@ -801,9 +801,9 @@ static int r8192_wx_set_auth(struct net_device *dev,
         int ret = 0;
         struct r8192_priv *priv = ieee80211_priv(dev);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
         ret = ieee80211_wx_set_auth(priv->ieee80211, info, &(data->param), extra);
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return ret;
 }
 
@@ -815,10 +815,10 @@ static int r8192_wx_set_mlme(struct net_device *dev,
         int ret = 0;
         struct r8192_priv *priv = ieee80211_priv(dev);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
         ret = ieee80211_wx_set_mlme(priv->ieee80211, info, wrqu, extra);
 
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return ret;
 }
 
@@ -829,9 +829,9 @@ static int r8192_wx_set_gen_ie(struct net_device *dev,
         int ret = 0;
         struct r8192_priv *priv = ieee80211_priv(dev);
 
-        down(&priv->wx_sem);
+        mutex_lock(&priv->wx_mutex);
         ret = ieee80211_wx_set_gen_ie(priv->ieee80211, extra, data->data.length);
-        up(&priv->wx_sem);
+        mutex_unlock(&priv->wx_mutex);
         return ret;
 
 
diff --git a/drivers/staging/unisys/visorbus/iovmcall_gnuc.h b/drivers/staging/unisys/visorbus/iovmcall_gnuc.h
index b08b6ecc8d31..98ea7f381a3c 100644
--- a/drivers/staging/unisys/visorbus/iovmcall_gnuc.h
+++ b/drivers/staging/unisys/visorbus/iovmcall_gnuc.h
@@ -22,7 +22,7 @@ __unisys_vmcall_gnuc(unsigned long tuple, unsigned long reg_ebx,
 
         cpuid(0x00000001, &cpuid_eax, &cpuid_ebx, &cpuid_ecx, &cpuid_edx);
         if (!(cpuid_ecx & 0x80000000))
-                return -1;
+                return -EPERM;
 
         __asm__ __volatile__(".byte 0x00f, 0x001, 0x0c1" : "=a"(result) :
                 "a"(tuple), "b"(reg_ebx), "c"(reg_ecx));
@@ -40,7 +40,7 @@ __unisys_extended_vmcall_gnuc(unsigned long long tuple,
 
         cpuid(0x00000001, &cpuid_eax, &cpuid_ebx, &cpuid_ecx, &cpuid_edx);
         if (!(cpuid_ecx & 0x80000000))
-                return -1;
+                return -EPERM;
 
         __asm__ __volatile__(".byte 0x00f, 0x001, 0x0c1" : "=a"(result) :
                 "a"(tuple), "b"(reg_ebx), "c"(reg_ecx), "d"(reg_edx));
diff --git a/drivers/staging/unisys/visorbus/visorbus_main.c b/drivers/staging/unisys/visorbus/visorbus_main.c
index 3a147dbbd7b5..d32b8980a1cf 100644
--- a/drivers/staging/unisys/visorbus/visorbus_main.c
+++ b/drivers/staging/unisys/visorbus/visorbus_main.c
@@ -876,10 +876,10 @@ write_vbus_chp_info(struct visorchannel *chan,
         int off = sizeof(struct channel_header) + hdr_info->chp_info_offset;
 
         if (hdr_info->chp_info_offset == 0)
-                return -1;
+                return -EFAULT;
 
         if (visorchannel_write(chan, off, info, sizeof(*info)) < 0)
-                return -1;
+                return -EFAULT;
         return 0;
 }
 
@@ -895,10 +895,10 @@ write_vbus_bus_info(struct visorchannel *chan,
         int off = sizeof(struct channel_header) + hdr_info->bus_info_offset;
 
         if (hdr_info->bus_info_offset == 0)
-                return -1;
+                return -EFAULT;
 
         if (visorchannel_write(chan, off, info, sizeof(*info)) < 0)
-                return -1;
+                return -EFAULT;
         return 0;
 }
 
@@ -915,10 +915,10 @@ write_vbus_dev_info(struct visorchannel *chan,
             (hdr_info->device_info_struct_bytes * devix);
 
         if (hdr_info->dev_info_offset == 0)
-                return -1;
+                return -EFAULT;
 
         if (visorchannel_write(chan, off, info, sizeof(*info)) < 0)
-                return -1;
+                return -EFAULT;
         return 0;
 }
 
diff --git a/drivers/staging/unisys/visorbus/visorchipset.c b/drivers/staging/unisys/visorbus/visorchipset.c
index 5ba5936e2203..d248c946a13b 100644
--- a/drivers/staging/unisys/visorbus/visorchipset.c
+++ b/drivers/staging/unisys/visorbus/visorchipset.c
@@ -1613,7 +1613,7 @@ parahotplug_request_complete(int id, u16 active)
         }
 
         spin_unlock(&parahotplug_request_list_lock);
-        return -1;
+        return -EINVAL;
 }
 
 /*
diff --git a/drivers/staging/unisys/visorhba/visorhba_main.c b/drivers/staging/unisys/visorhba/visorhba_main.c
index 6a4570d10642..120ba2097e02 100644
--- a/drivers/staging/unisys/visorhba/visorhba_main.c
+++ b/drivers/staging/unisys/visorhba/visorhba_main.c
@@ -16,6 +16,8 @@
 #include <linux/debugfs.h>
 #include <linux/skbuff.h>
 #include <linux/kthread.h>
+#include <linux/idr.h>
+#include <linux/seq_file.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_cmnd.h>
@@ -33,7 +35,6 @@
 #define MAX_BUF                 8192
 #define MAX_PENDING_REQUESTS    (MIN_NUMSIGNALS * 2)
 #define VISORHBA_ERROR_COUNT    30
-#define VISORHBA_OPEN_MAX       1
 
 static int visorhba_queue_command_lck(struct scsi_cmnd *scsicmd,
                                       void (*visorhba_cmnd_done)
@@ -50,14 +51,7 @@ static int visorhba_pause(struct visor_device *dev,
 static int visorhba_resume(struct visor_device *dev,
                            visorbus_state_complete_func complete_func);
 
-static ssize_t info_debugfs_read(struct file *file, char __user *buf,
-                                 size_t len, loff_t *offset);
-static int set_no_disk_inquiry_result(unsigned char *buf,
-                                      size_t len, bool is_lun0);
 static struct dentry *visorhba_debugfs_dir;
-static const struct file_operations debugfs_info_fops = {
-        .read = info_debugfs_read,
-};
 
 /* GUIDS for HBA channel type supported by this driver */
 static struct visor_channeltype_descriptor visorhba_channel_types[] = {
@@ -99,14 +93,6 @@ struct scsipending {
         char cmdtype;           /* Type of pointer that is being stored */
 };
 
-/* Work Data for dar_work_queue */
-struct diskaddremove {
-        u8 add;                 /* 0-remove, 1-add */
-        struct Scsi_Host *shost; /* Scsi Host for this visorhba instance */
-        u32 channel, id, lun;   /* Disk Path */
-        struct diskaddremove *next;
-};
-
 /* Each scsi_host has a host_data area that contains this struct. */
 struct visorhba_devdata {
         struct Scsi_Host *scsihost;
@@ -133,14 +119,21 @@ struct visorhba_devdata {
         int devnum;
         struct task_struct *thread;
         int thread_wait_ms;
+
+        /*
+         * allows us to pass int handles back-and-forth between us and
+         * iovm, instead of raw pointers
+         */
+        struct idr idr;
+
+        struct dentry *debugfs_dir;
+        struct dentry *debugfs_info;
 };
 
 struct visorhba_devices_open {
         struct visorhba_devdata *devdata;
 };
 
-static struct visorhba_devices_open visorhbas_open[VISORHBA_OPEN_MAX];
-
 #define for_each_vdisk_match(iter, list, match)                   \
         for (iter = &list->head; iter->next; iter = iter->next) \
                 if ((iter->channel == match->channel) &&                  \
@@ -191,7 +184,7 @@ static void visor_thread_stop(struct task_struct *task)
  *      Partition so that it can be handled when it completes. If new is
  *      NULL it is assumed the entry refers only to the cmdrsp.
  *      Returns insert_location where entry was added,
- *      SCSI_MLQUEUE_DEVICE_BUSY if it can't
+ *      -EBUSY if it can't
  */
 static int add_scsipending_entry(struct visorhba_devdata *devdata,
                                  char cmdtype, void *new)
@@ -206,7 +199,7 @@ static int add_scsipending_entry(struct visorhba_devdata *devdata,
                 insert_location = (insert_location + 1) % MAX_PENDING_REQUESTS;
                 if (insert_location == (int)devdata->nextinsert) {
                         spin_unlock_irqrestore(&devdata->privlock, flags);
-                        return -1;
+                        return -EBUSY;
                 }
         }
 
@@ -269,6 +262,62 @@ static struct uiscmdrsp *get_scsipending_cmdrsp(struct visorhba_devdata *ddata,
 }
 
 /**
+ *      simple_idr_get - associate a provided pointer with an int value
+ *                       1 <= value <= INT_MAX, and return this int value;
+ *                       the pointer value can be obtained later by passing
+ *                       this int value to idr_find()
+ *      @idrtable: the data object maintaining the pointer<-->int mappings
+ *      @p: the pointer value to be remembered
+ *      @lock: a spinlock used when exclusive access to idrtable is needed
+ */
+static unsigned int simple_idr_get(struct idr *idrtable, void *p,
+                                   spinlock_t *lock)
+{
+        int id;
+        unsigned long flags;
+
+        idr_preload(GFP_KERNEL);
+        spin_lock_irqsave(lock, flags);
+        id = idr_alloc(idrtable, p, 1, INT_MAX, GFP_NOWAIT);
+        spin_unlock_irqrestore(lock, flags);
+        idr_preload_end();
+        if (id < 0)
+                return 0;  /* failure */
+        return (unsigned int)(id);  /* idr_alloc() guarantees > 0 */
+}
+
+/**
+ *      setup_scsitaskmgmt_handles - stash the necessary handles so that the
+ *                                   completion processing logic for a taskmgmt
+ *                                   cmd will be able to find who to wake up
+ *                                   and where to stash the result
+ */
+static void setup_scsitaskmgmt_handles(struct idr *idrtable, spinlock_t *lock,
+                                       struct uiscmdrsp *cmdrsp,
+                                       wait_queue_head_t *event, int *result)
+{
+        /* specify the event that has to be triggered when this */
+        /* cmd is complete */
+        cmdrsp->scsitaskmgmt.notify_handle =
+                simple_idr_get(idrtable, event, lock);
+        cmdrsp->scsitaskmgmt.notifyresult_handle =
+                simple_idr_get(idrtable, result, lock);
+}
+
+/**
+ *      cleanup_scsitaskmgmt_handles - forget handles created by
+ *                                     setup_scsitaskmgmt_handles()
+ */
+static void cleanup_scsitaskmgmt_handles(struct idr *idrtable,
+                                         struct uiscmdrsp *cmdrsp)
+{
+        if (cmdrsp->scsitaskmgmt.notify_handle)
+                idr_remove(idrtable, cmdrsp->scsitaskmgmt.notify_handle);
+        if (cmdrsp->scsitaskmgmt.notifyresult_handle)
+                idr_remove(idrtable, cmdrsp->scsitaskmgmt.notifyresult_handle);
+}
+
+/**
  *      forward_taskmgmt_command - send taskmegmt command to the Service
  *                                 Partition
  *      @tasktype: Type of taskmgmt command
@@ -303,10 +352,8 @@ static int forward_taskmgmt_command(enum task_mgmt_types tasktype,
 
         /* issue TASK_MGMT_ABORT_TASK */
         cmdrsp->cmdtype = CMD_SCSITASKMGMT_TYPE;
-        /* specify the event that has to be triggered when this */
-        /* cmd is complete */
-        cmdrsp->scsitaskmgmt.notify_handle = (u64)&notifyevent;
-        cmdrsp->scsitaskmgmt.notifyresult_handle = (u64)&notifyresult;
+        setup_scsitaskmgmt_handles(&devdata->idr, &devdata->privlock, cmdrsp,
+                                   &notifyevent, &notifyresult);
 
         /* save destination */
         cmdrsp->scsitaskmgmt.tasktype = tasktype;
@@ -315,6 +362,8 @@ static int forward_taskmgmt_command(enum task_mgmt_types tasktype,
         cmdrsp->scsitaskmgmt.vdest.lun = scsidev->lun;
         cmdrsp->scsitaskmgmt.handle = scsicmd_id;
 
+        dev_dbg(&scsidev->sdev_gendev,
+                "visorhba: initiating type=%d taskmgmt command\n", tasktype);
         if (!visorchannel_signalinsert(devdata->dev->visorchannel,
                                        IOCHAN_TO_IOPART,
                                        cmdrsp))
@@ -327,17 +376,23 @@ static int forward_taskmgmt_command(enum task_mgmt_types tasktype,
                                 msecs_to_jiffies(45000)))
                 goto err_del_scsipending_ent;
 
+        dev_dbg(&scsidev->sdev_gendev,
+                "visorhba: taskmgmt type=%d success; result=0x%x\n",
+                 tasktype, notifyresult);
         if (tasktype == TASK_MGMT_ABORT_TASK)
                 scsicmd->result = DID_ABORT << 16;
         else
                 scsicmd->result = DID_RESET << 16;
 
         scsicmd->scsi_done(scsicmd);
-
+        cleanup_scsitaskmgmt_handles(&devdata->idr, cmdrsp);
         return SUCCESS;
 
 err_del_scsipending_ent:
+        dev_dbg(&scsidev->sdev_gendev,
+                "visorhba: taskmgmt type=%d not executed\n", tasktype);
         del_scsipending_ent(devdata, scsicmd_id);
+        cleanup_scsitaskmgmt_handles(&devdata->idr, cmdrsp);
         return FAILED;
 }
 
@@ -606,64 +661,76 @@ static struct scsi_host_template visorhba_driver_template = {
 };
 
 /**
- *      info_debugfs_read - debugfs interface to dump visorhba states
- *      @file: Debug file
- *      @buf: buffer to send back to user
- *      @len: len that can be written to buf
- *      @offset: offset into buf
+ *      info_debugfs_show - debugfs interface to dump visorhba states
  *
- *      Dumps information about the visorhba driver and devices
- *      TODO: Make this per vhba
- *      Returns bytes_read
+ *      This presents a file in the debugfs tree named:
+ *          /visorhba/vbus<x>:dev<y>/info
  */
-static ssize_t info_debugfs_read(struct file *file, char __user *buf,
-                                 size_t len, loff_t *offset)
+static int info_debugfs_show(struct seq_file *seq, void *v)
 {
-        ssize_t bytes_read = 0;
-        int str_pos = 0;
-        u64 phys_flags_addr;
-        int i;
-        struct visorhba_devdata *devdata;
-        char *vbuf;
+        struct visorhba_devdata *devdata = seq->private;
+
+        seq_printf(seq, "max_buff_len = %u\n", devdata->max_buff_len);
+        seq_printf(seq, "interrupts_rcvd = %llu\n", devdata->interrupts_rcvd);
+        seq_printf(seq, "interrupts_disabled = %llu\n",
+                   devdata->interrupts_disabled);
+        seq_printf(seq, "interrupts_notme = %llu\n",
+                   devdata->interrupts_notme);
+        seq_printf(seq, "flags_addr = %p\n", devdata->flags_addr);
+        if (devdata->flags_addr) {
+                u64 phys_flags_addr =
+                        virt_to_phys((__force  void *)devdata->flags_addr);
+                seq_printf(seq, "phys_flags_addr = 0x%016llx\n",
+                           phys_flags_addr);
+                seq_printf(seq, "FeatureFlags = %llu\n",
+                           (__le64)readq(devdata->flags_addr));
+        }
+        seq_printf(seq, "acquire_failed_cnt = %llu\n",
+                   devdata->acquire_failed_cnt);
 
-        if (len > MAX_BUF)
-                len = MAX_BUF;
-        vbuf = kzalloc(len, GFP_KERNEL);
-        if (!vbuf)
-                return -ENOMEM;
+        return 0;
+}
+
+static int info_debugfs_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, info_debugfs_show, inode->i_private);
+}
 
-        for (i = 0; i < VISORHBA_OPEN_MAX; i++) {
-                if (!visorhbas_open[i].devdata)
-                        continue;
-
-                devdata = visorhbas_open[i].devdata;
-
-                str_pos += scnprintf(vbuf + str_pos,
-                                len - str_pos, "max_buff_len:%u\n",
-                                devdata->max_buff_len);
-
-                str_pos += scnprintf(vbuf + str_pos, len - str_pos,
-                                "\ninterrupts_rcvd = %llu, interrupts_disabled = %llu\n",
-                                devdata->interrupts_rcvd,
-                                devdata->interrupts_disabled);
-                str_pos += scnprintf(vbuf + str_pos,
-                                len - str_pos, "\ninterrupts_notme = %llu,\n",
-                                devdata->interrupts_notme);
-                phys_flags_addr = virt_to_phys((__force  void *)
-                                               devdata->flags_addr);
-                str_pos += scnprintf(vbuf + str_pos, len - str_pos,
-                                "flags_addr = %p, phys_flags_addr=0x%016llx, FeatureFlags=%llu\n",
-                                devdata->flags_addr, phys_flags_addr,
-                                (__le64)readq(devdata->flags_addr));
-                str_pos += scnprintf(vbuf + str_pos,
-                        len - str_pos, "acquire_failed_cnt:%llu\n",
-                        devdata->acquire_failed_cnt);
-                str_pos += scnprintf(vbuf + str_pos, len - str_pos, "\n");
+static const struct file_operations info_debugfs_fops = {
+        .owner = THIS_MODULE,
+        .open = info_debugfs_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+/**
+ *      complete_taskmgmt_command - complete task management
+ *      @cmdrsp: Response from the IOVM
+ *
+ *      Service Partition returned the result of the task management
+ *      command. Wake up anyone waiting for it.
+ *      Returns void
+ */
+static inline void complete_taskmgmt_command
+(struct idr *idrtable, struct uiscmdrsp *cmdrsp, int result)
+{
+        wait_queue_head_t *wq =
+                idr_find(idrtable, cmdrsp->scsitaskmgmt.notify_handle);
+        int *scsi_result_ptr =
+                idr_find(idrtable, cmdrsp->scsitaskmgmt.notifyresult_handle);
+
+        if (unlikely(!(wq && scsi_result_ptr))) {
+                pr_err("visorhba: no completion context; cmd will time out\n");
+                return;
         }
 
-        bytes_read = simple_read_from_buffer(buf, len, offset, vbuf, str_pos);
-        kfree(vbuf);
-        return bytes_read;
+        /* copy the result of the taskmgmt and
+         * wake up the error handler that is waiting for this
+         */
+        pr_debug("visorhba: notifying initiator with result=0x%x\n", result);
+        *scsi_result_ptr = result;
+        wake_up_all(wq);
 }
 
 /**
@@ -701,17 +768,8 @@ static void visorhba_serverdown_complete(struct visorhba_devdata *devdata)
                         break;
                 case CMD_SCSITASKMGMT_TYPE:
                         cmdrsp = pendingdel->sent;
-                        cmdrsp->scsitaskmgmt.notifyresult_handle
-                                                        = TASK_MGMT_FAILED;
-                        wake_up_all((wait_queue_head_t *)
-                                    cmdrsp->scsitaskmgmt.notify_handle);
-                        break;
-                case CMD_VDISKMGMT_TYPE:
-                        cmdrsp = pendingdel->sent;
-                        cmdrsp->vdiskmgmt.notifyresult_handle
-                                                        = VDISK_MGMT_FAILED;
-                        wake_up_all((wait_queue_head_t *)
-                                    cmdrsp->vdiskmgmt.notify_handle);
+                        complete_taskmgmt_command(&devdata->idr, cmdrsp,
+                                                  TASK_MGMT_FAILED);
                         break;
                 default:
                         break;
@@ -878,89 +936,6 @@ complete_scsi_command(struct uiscmdrsp *cmdrsp, struct scsi_cmnd *scsicmd)
         scsicmd->scsi_done(scsicmd);
 }
 
-/* DELETE VDISK TASK MGMT COMMANDS */
-static inline void complete_vdiskmgmt_command(struct uiscmdrsp *cmdrsp)
-{
-        /* copy the result of the taskmgmt and
-         * wake up the error handler that is waiting for this
-         */
-        cmdrsp->vdiskmgmt.notifyresult_handle = cmdrsp->vdiskmgmt.result;
-        wake_up_all((wait_queue_head_t *)cmdrsp->vdiskmgmt.notify_handle);
-}
-
-/**
- *      complete_taskmgmt_command - complete task management
- *      @cmdrsp: Response from the IOVM
- *
- *      Service Partition returned the result of the task management
- *      command. Wake up anyone waiting for it.
- *      Returns void
- */
-static inline void complete_taskmgmt_command(struct uiscmdrsp *cmdrsp)
-{
-        /* copy the result of the taskgmgt and
-         * wake up the error handler that is waiting for this
-         */
-        cmdrsp->vdiskmgmt.notifyresult_handle = cmdrsp->vdiskmgmt.result;
-        wake_up_all((wait_queue_head_t *)cmdrsp->scsitaskmgmt.notify_handle);
-}
-
-static struct work_struct dar_work_queue;
-static struct diskaddremove *dar_work_queue_head;
-static spinlock_t dar_work_queue_lock; /* Lock to protet dar_work_queue_head */
-static unsigned short dar_work_queue_sched;
-
-/**
- *      queue_disk_add_remove - IOSP has sent us a add/remove request
- *      @dar: disk add/remove request
- *
- *      Queue the work needed to add/remove a disk.
- *      Returns void
- */
-static inline void queue_disk_add_remove(struct diskaddremove *dar)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&dar_work_queue_lock, flags);
-        if (!dar_work_queue_head) {
-                dar_work_queue_head = dar;
-                dar->next = NULL;
-        } else {
-                dar->next = dar_work_queue_head;
-                dar_work_queue_head = dar;
-        }
-        if (!dar_work_queue_sched) {
-                schedule_work(&dar_work_queue);
-                dar_work_queue_sched = 1;
-        }
-        spin_unlock_irqrestore(&dar_work_queue_lock, flags);
-}
-
-/**
- *      process_disk_notify - IOSP has sent a process disk notify event
- *      @shost: Scsi hot
- *      @cmdrsp: Response from the IOSP
- *
- *      Queue it to the work queue.
- *      Return void.
- */
-static void process_disk_notify(struct Scsi_Host *shost,
-                                struct uiscmdrsp *cmdrsp)
-{
-        struct diskaddremove *dar;
-
-        dar = kzalloc(sizeof(*dar), GFP_ATOMIC);
-        if (!dar)
-                return;
-
-        dar->add = cmdrsp->disknotify.add;
-        dar->shost = shost;
-        dar->channel = cmdrsp->disknotify.channel;
-        dar->id = cmdrsp->disknotify.id;
-        dar->lun = cmdrsp->disknotify.lun;
-        queue_disk_add_remove(dar);
-}
-
 /**
  *      drain_queue - pull responses out of iochannel
  *      @cmdrsp: Response from the IOSP
@@ -973,7 +948,6 @@ static void
 drain_queue(struct uiscmdrsp *cmdrsp, struct visorhba_devdata *devdata)
 {
         struct scsi_cmnd *scsicmd;
-        struct Scsi_Host *shost = devdata->scsihost;
 
         while (1) {
                 if (!visorchannel_signalremove(devdata->dev->visorchannel,
@@ -995,21 +969,12 @@ drain_queue(struct uiscmdrsp *cmdrsp, struct visorhba_devdata *devdata)
                         if (!del_scsipending_ent(devdata,
                                                  cmdrsp->scsitaskmgmt.handle))
                                 break;
-                        complete_taskmgmt_command(cmdrsp);
-                } else if (cmdrsp->cmdtype == CMD_NOTIFYGUEST_TYPE) {
-                        /* The vHba pointer has no meaning in a
-                         * guest partition. Let's be safe and set it
-                         * to NULL now. Do not use it here!
-                         */
-                        cmdrsp->disknotify.v_hba = NULL;
-                        process_disk_notify(shost, cmdrsp);
-                } else if (cmdrsp->cmdtype == CMD_VDISKMGMT_TYPE) {
-                        if (!del_scsipending_ent(devdata,
-                                                 cmdrsp->vdiskmgmt.handle))
-                                break;
-                        complete_vdiskmgmt_command(cmdrsp);
-                }
-                /* cmdrsp is now available for resuse */
+                        complete_taskmgmt_command(&devdata->idr, cmdrsp,
+                                                  cmdrsp->scsitaskmgmt.result);
+                } else if (cmdrsp->cmdtype == CMD_NOTIFYGUEST_TYPE)
+                        dev_err_once(&devdata->dev->device,
+                                     "ignoring unsupported NOTIFYGUEST\n");
+                /* cmdrsp is now available for re-use */
         }
 }
 
@@ -1107,7 +1072,7 @@ static int visorhba_probe(struct visor_device *dev)
         struct Scsi_Host *scsihost;
         struct vhba_config_max max;
         struct visorhba_devdata *devdata = NULL;
-        int i, err, channel_offset;
+        int err, channel_offset;
         u64 features;
 
         scsihost = scsi_host_alloc(&visorhba_driver_template,
@@ -1122,9 +1087,9 @@ static int visorhba_probe(struct visor_device *dev)
         if (err < 0)
                 goto err_scsi_host_put;
 
-        scsihost->max_id = (unsigned)max.max_id;
-        scsihost->max_lun = (unsigned)max.max_lun;
-        scsihost->cmd_per_lun = (unsigned)max.cmd_per_lun;
+        scsihost->max_id = (unsigned int)max.max_id;
+        scsihost->max_lun = (unsigned int)max.max_lun;
+        scsihost->cmd_per_lun = (unsigned int)max.cmd_per_lun;
         scsihost->max_sectors =
             (unsigned short)(max.max_io_size >> 9);
         scsihost->sg_tablesize =
@@ -1136,16 +1101,24 @@ static int visorhba_probe(struct visor_device *dev)
                 goto err_scsi_host_put;
 
         devdata = (struct visorhba_devdata *)scsihost->hostdata;
-        for (i = 0; i < VISORHBA_OPEN_MAX; i++) {
-                if (!visorhbas_open[i].devdata) {
-                        visorhbas_open[i].devdata = devdata;
-                        break;
-                }
-        }
-
         devdata->dev = dev;
         dev_set_drvdata(&dev->device, devdata);
 
+        devdata->debugfs_dir = debugfs_create_dir(dev_name(&dev->device),
+                                                  visorhba_debugfs_dir);
+        if (!devdata->debugfs_dir) {
+                err = -ENOMEM;
+                goto err_scsi_remove_host;
+        }
+        devdata->debugfs_info =
+                debugfs_create_file("info", S_IRUSR | S_IRGRP,
+                                    devdata->debugfs_dir, devdata,
+                                    &info_debugfs_fops);
+        if (!devdata->debugfs_info) {
+                err = -ENOMEM;
+                goto err_debugfs_dir;
+        }
+
         init_waitqueue_head(&devdata->rsp_queue);
         spin_lock_init(&devdata->privlock);
         devdata->serverdown = false;
@@ -1156,11 +1129,13 @@ static int visorhba_probe(struct visor_device *dev)
                                   channel_header.features);
         err = visorbus_read_channel(dev, channel_offset, &features, 8);
         if (err)
-                goto err_scsi_remove_host;
+                goto err_debugfs_info;
         features |= ULTRA_IO_CHANNEL_IS_POLLING;
         err = visorbus_write_channel(dev, channel_offset, &features, 8);
         if (err)
-                goto err_scsi_remove_host;
+                goto err_debugfs_info;
+
+        idr_init(&devdata->idr);
 
         devdata->thread_wait_ms = 2;
         devdata->thread = visor_thread_start(process_incoming_rsps, devdata,
@@ -1170,6 +1145,12 @@ static int visorhba_probe(struct visor_device *dev)
 
         return 0;
 
+err_debugfs_info:
+        debugfs_remove(devdata->debugfs_info);
+
+err_debugfs_dir:
+        debugfs_remove_recursive(devdata->debugfs_dir);
+
 err_scsi_remove_host:
         scsi_remove_host(scsihost);
 
@@ -1198,7 +1179,11 @@ static void visorhba_remove(struct visor_device *dev)
         scsi_remove_host(scsihost);
         scsi_host_put(scsihost);
 
+        idr_destroy(&devdata->idr);
+
         dev_set_drvdata(&dev->device, NULL);
+        debugfs_remove(devdata->debugfs_info);
+        debugfs_remove_recursive(devdata->debugfs_dir);
 }
 
 /**
@@ -1209,26 +1194,17 @@ static void visorhba_remove(struct visor_device *dev)
  */
 static int visorhba_init(void)
 {
-        struct dentry *ret;
         int rc = -ENOMEM;
 
         visorhba_debugfs_dir = debugfs_create_dir("visorhba", NULL);
         if (!visorhba_debugfs_dir)
                 return -ENOMEM;
 
-        ret = debugfs_create_file("info", S_IRUSR, visorhba_debugfs_dir, NULL,
-                                  &debugfs_info_fops);
-
-        if (!ret) {
-                rc = -EIO;
-                goto cleanup_debugfs;
-        }
-
         rc = visorbus_register_visor_driver(&visorhba_driver);
         if (rc)
                 goto cleanup_debugfs;
 
-        return rc;
+        return 0;
 
 cleanup_debugfs:
         debugfs_remove_recursive(visorhba_debugfs_dir);
diff --git a/drivers/staging/unisys/visorinput/visorinput.c b/drivers/staging/unisys/visorinput/visorinput.c
index 12a3570780fc..d67cd76327c0 100644
--- a/drivers/staging/unisys/visorinput/visorinput.c
+++ b/drivers/staging/unisys/visorinput/visorinput.c
@@ -506,7 +506,7 @@ calc_button(int x)
         case 3:
                 return BTN_RIGHT;
         default:
-                return -1;
+                return -EINVAL;
         }
 }
 
diff --git a/drivers/staging/unisys/visornic/visornic_main.c b/drivers/staging/unisys/visornic/visornic_main.c
index fd7c9a6cb6f3..a28388d3ddc2 100644
--- a/drivers/staging/unisys/visornic/visornic_main.c
+++ b/drivers/staging/unisys/visornic/visornic_main.c
@@ -1000,25 +1000,28 @@ visornic_set_multi(struct net_device *netdev)
         struct uiscmdrsp *cmdrsp;
         struct visornic_devdata *devdata = netdev_priv(netdev);
 
-        /* any filtering changes */
-        if (devdata->old_flags != netdev->flags) {
-                if ((netdev->flags & IFF_PROMISC) !=
-                    (devdata->old_flags & IFF_PROMISC)) {
-                        cmdrsp = kmalloc(SIZEOF_CMDRSP, GFP_ATOMIC);
-                        if (!cmdrsp)
-                                return;
-                        cmdrsp->cmdtype = CMD_NET_TYPE;
-                        cmdrsp->net.type = NET_RCV_PROMISC;
-                        cmdrsp->net.enbdis.context = netdev;
-                        cmdrsp->net.enbdis.enable =
-                                netdev->flags & IFF_PROMISC;
-                        visorchannel_signalinsert(devdata->dev->visorchannel,
-                                                  IOCHAN_TO_IOPART,
-                                                  cmdrsp);
-                        kfree(cmdrsp);
-                }
-                devdata->old_flags = netdev->flags;
-        }
+        if (devdata->old_flags == netdev->flags)
+                return;
+
+        if ((netdev->flags & IFF_PROMISC) ==
+            (devdata->old_flags & IFF_PROMISC))
+                goto out_save_flags;
+
+        cmdrsp = kmalloc(SIZEOF_CMDRSP, GFP_ATOMIC);
+        if (!cmdrsp)
+                return;
+        cmdrsp->cmdtype = CMD_NET_TYPE;
+        cmdrsp->net.type = NET_RCV_PROMISC;
+        cmdrsp->net.enbdis.context = netdev;
+        cmdrsp->net.enbdis.enable =
+                netdev->flags & IFF_PROMISC;
+        visorchannel_signalinsert(devdata->dev->visorchannel,
+                                  IOCHAN_TO_IOPART,
+                                  cmdrsp);
+        kfree(cmdrsp);
+
+out_save_flags:
+        devdata->old_flags = netdev->flags;
 }
 
 /**
@@ -1134,7 +1137,7 @@ repost_return(struct uiscmdrsp *cmdrsp, struct visornic_devdata *devdata,
  *
  *      Got a receive packet back from the IO Part, handle it and send
  *      it up the stack.
- *      Returns void
+ *      Returns 1 iff an skb was receieved, otherwise 0
  */
 static int
 visornic_rx(struct uiscmdrsp *cmdrsp)
@@ -1145,7 +1148,6 @@ visornic_rx(struct uiscmdrsp *cmdrsp)
         int cc, currsize, off;
         struct ethhdr *eth;
         unsigned long flags;
-        int rx_count = 0;
 
         /* post new rcv buf to the other end using the cmdrsp we have at hand
          * post it without holding lock - but we'll use the signal lock to
@@ -1177,7 +1179,7 @@ visornic_rx(struct uiscmdrsp *cmdrsp)
                  */
                 spin_unlock_irqrestore(&devdata->priv_lock, flags);
                 repost_return(cmdrsp, devdata, skb, netdev);
-                return rx_count;
+                return 0;
         }
 
         spin_unlock_irqrestore(&devdata->priv_lock, flags);
@@ -1196,7 +1198,7 @@ visornic_rx(struct uiscmdrsp *cmdrsp)
                         if (repost_return(cmdrsp, devdata, skb, netdev) < 0)
                                 dev_err(&devdata->netdev->dev,
                                         "repost_return failed");
-                        return rx_count;
+                        return 0;
                 }
                 /* length rcvd is greater than firstfrag in this skb rcv buf  */
                 skb->tail += RCVPOST_BUF_SIZE;  /* amount in skb->data */
@@ -1212,7 +1214,7 @@ visornic_rx(struct uiscmdrsp *cmdrsp)
                         if (repost_return(cmdrsp, devdata, skb, netdev) < 0)
                                 dev_err(&devdata->netdev->dev,
                                         "repost_return failed");
-                        return rx_count;
+                        return 0;
                 }
                 skb->tail += skb->len;
                 skb->data_len = 0;      /* nothing rcvd in frag_list */
@@ -1231,7 +1233,7 @@ visornic_rx(struct uiscmdrsp *cmdrsp)
         if (cmdrsp->net.rcv.rcvbuf[0] != skb) {
                 if (repost_return(cmdrsp, devdata, skb, netdev) < 0)
                         dev_err(&devdata->netdev->dev, "repost_return failed");
-                return rx_count;
+                return 0;
         }
 
         if (cmdrsp->net.rcv.numrcvbufs > 1) {
@@ -1313,10 +1315,9 @@ visornic_rx(struct uiscmdrsp *cmdrsp)
                 /* drop packet - don't forward it up to OS */
                 devdata->n_rcv_packets_not_accepted++;
                 repost_return(cmdrsp, devdata, skb, netdev);
-                return rx_count;
+                return 0;
         } while (0);
 
-        rx_count++;
         netif_receive_skb(skb);
         /* netif_rx returns various values, but "in practice most drivers
          * ignore the return value
@@ -1329,7 +1330,7 @@ visornic_rx(struct uiscmdrsp *cmdrsp)
          * new rcv buffer.
          */
         repost_return(cmdrsp, devdata, skb, netdev);
-        return rx_count;
+        return 1;
 }
 
 /**
@@ -1339,13 +1340,11 @@ visornic_rx(struct uiscmdrsp *cmdrsp)
  *
  *      Setup initial values for the visornic based on channel and default
  *      values.
- *      Returns a pointer to the devdata if successful, else NULL
+ *      Returns a pointer to the devdata structure
  */
 static struct visornic_devdata *
 devdata_initialize(struct visornic_devdata *devdata, struct visor_device *dev)
 {
-        if (!devdata)
-                return NULL;
         devdata->dev = dev;
         devdata->incarnation_id = get_jiffies_64();
         return devdata;
@@ -1793,7 +1792,7 @@ static int visornic_probe(struct visor_device *dev)
                                   sizeof(struct sk_buff *), GFP_KERNEL);
         if (!devdata->rcvbuf) {
                 err = -ENOMEM;
-                goto cleanup_rcvbuf;
+                goto cleanup_netdev;
         }
 
         /* set the net_xmit outstanding threshold */
@@ -1814,12 +1813,12 @@ static int visornic_probe(struct visor_device *dev)
         devdata->cmdrsp_rcv = kmalloc(SIZEOF_CMDRSP, GFP_ATOMIC);
         if (!devdata->cmdrsp_rcv) {
                 err = -ENOMEM;
-                goto cleanup_cmdrsp_rcv;
+                goto cleanup_rcvbuf;
         }
         devdata->xmit_cmdrsp = kmalloc(SIZEOF_CMDRSP, GFP_ATOMIC);
         if (!devdata->xmit_cmdrsp) {
                 err = -ENOMEM;
-                goto cleanup_xmit_cmdrsp;
+                goto cleanup_cmdrsp_rcv;
         }
         INIT_WORK(&devdata->timeout_reset, visornic_timeout_reset);
         devdata->server_down = false;
@@ -2088,8 +2087,10 @@ static int visornic_init(void)
                 goto cleanup_debugfs;
 
         err = visorbus_register_visor_driver(&visornic_driver);
-        if (!err)
-                return 0;
+        if (err)
+                goto cleanup_debugfs;
+
+        return 0;
 
 cleanup_debugfs:
         debugfs_remove_recursive(visornic_debugfs_dir);
diff --git a/include/linux/fence.h b/include/linux/fence.h
index 2056e9fd0138..1de1b3f6fb76 100644
--- a/include/linux/fence.h
+++ b/include/linux/fence.h
@@ -81,8 +81,6 @@ struct fence {
         unsigned long flags;
         ktime_t timestamp;
         int status;
-        struct list_head child_list;
-        struct list_head active_list;
 };
 
 enum fence_flag_bits {
diff --git a/include/linux/iio/common/st_sensors.h b/include/linux/iio/common/st_sensors.h
index 99403b19092f..28052cddaa03 100644
--- a/include/linux/iio/common/st_sensors.h
+++ b/include/linux/iio/common/st_sensors.h
@@ -256,8 +256,6 @@ struct st_sensor_data {
 
 #ifdef CONFIG_IIO_BUFFER
 irqreturn_t st_sensors_trigger_handler(int irq, void *p);
-
-int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf);
 #endif
 
 #ifdef CONFIG_IIO_TRIGGER
@@ -287,7 +285,7 @@ int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable);
 
 int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable);
 
-void st_sensors_power_enable(struct iio_dev *indio_dev);
+int st_sensors_power_enable(struct iio_dev *indio_dev);
 
 void st_sensors_power_disable(struct iio_dev *indio_dev);
 
diff --git a/include/linux/iio/sw_device.h b/include/linux/iio/sw_device.h
new file mode 100644
index 000000000000..23ca41515527
--- /dev/null
+++ b/include/linux/iio/sw_device.h
@@ -0,0 +1,70 @@
+/*
+ * Industrial I/O software device interface
+ *
+ * Copyright (c) 2016 Intel Corporation
+ *
+ * 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.
+ */
+
+#ifndef __IIO_SW_DEVICE
+#define __IIO_SW_DEVICE
+
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/iio/iio.h>
+#include <linux/configfs.h>
+
+#define module_iio_sw_device_driver(__iio_sw_device_type) \
+        module_driver(__iio_sw_device_type, iio_register_sw_device_type, \
+                      iio_unregister_sw_device_type)
+
+struct iio_sw_device_ops;
+
+struct iio_sw_device_type {
+        const char *name;
+        struct module *owner;
+        const struct iio_sw_device_ops *ops;
+        struct list_head list;
+        struct config_group *group;
+};
+
+struct iio_sw_device {
+        struct iio_dev *device;
+        struct iio_sw_device_type *device_type;
+        struct config_group group;
+};
+
+struct iio_sw_device_ops {
+        struct iio_sw_device* (*probe)(const char *);
+        int (*remove)(struct iio_sw_device *);
+};
+
+static inline
+struct iio_sw_device *to_iio_sw_device(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct iio_sw_device,
+                            group);
+}
+
+int iio_register_sw_device_type(struct iio_sw_device_type *dt);
+void iio_unregister_sw_device_type(struct iio_sw_device_type *dt);
+
+struct iio_sw_device *iio_sw_device_create(const char *, const char *);
+void iio_sw_device_destroy(struct iio_sw_device *);
+
+int iio_sw_device_type_configfs_register(struct iio_sw_device_type *dt);
+void iio_sw_device_type_configfs_unregister(struct iio_sw_device_type *dt);
+
+static inline
+void iio_swd_group_init_type_name(struct iio_sw_device *d,
+                                  const char *name,
+                                  struct config_item_type *type)
+{
+#ifdef CONFIG_CONFIGFS_FS
+        config_group_init_type_name(&d->group, name, type);
+#endif
+}
+
+#endif /* __IIO_SW_DEVICE */
diff --git a/include/uapi/linux/iio/types.h b/include/uapi/linux/iio/types.h
index b0916fc72cce..22e5e589a274 100644
--- a/include/uapi/linux/iio/types.h
+++ b/include/uapi/linux/iio/types.h
@@ -39,6 +39,7 @@ enum iio_chan_type {
         IIO_RESISTANCE,
         IIO_PH,
         IIO_UVINDEX,
+        IIO_ELECTRICALCONDUCTIVITY,
 };
 
 enum iio_modifier {
diff --git a/tools/iio/Makefile b/tools/iio/Makefile
index 3a7a54f59713..5446d625e17d 100644
--- a/tools/iio/Makefile
+++ b/tools/iio/Makefile
@@ -1,16 +1,31 @@
 CC = $(CROSS_COMPILE)gcc
 CFLAGS += -Wall -g -D_GNU_SOURCE
 
-all: iio_event_monitor lsiio generic_buffer
+BINDIR=usr/bin
+INSTALL_PROGRAM=install -m 755 -p
+DEL_FILE=rm -f
+
+all: iio_event_monitor lsiio iio_generic_buffer
 
 iio_event_monitor: iio_event_monitor.o iio_utils.o
 
 lsiio: lsiio.o iio_utils.o
 
-generic_buffer: generic_buffer.o iio_utils.o
+iio_generic_buffer: iio_generic_buffer.o iio_utils.o
 
 %.o: %.c iio_utils.h
 
+install:
+        - mkdir -p $(INSTALL_ROOT)/$(BINDIR)
+        - $(INSTALL_PROGRAM) "iio_event_monitor" "$(INSTALL_ROOT)/$(BINDIR)/iio_event_monitor"
+        - $(INSTALL_PROGRAM) "lsiio" "$(INSTALL_ROOT)/$(BINDIR)/lsiio"
+        - $(INSTALL_PROGRAM) "iio_generic_buffer" "$(INSTALL_ROOT)/$(BINDIR)/iio_generic_buffer"
+
+uninstall:
+        $(DEL_FILE) "$(INSTALL_ROOT)/$(BINDIR)/iio_event_monitor"
+        $(DEL_FILE) "$(INSTALL_ROOT)/$(BINDIR)/lsiio"
+        $(DEL_FILE) "$(INSTALL_ROOT)/$(BINDIR)/iio_generic_buffer"
+
 .PHONY: clean
 clean:
-        rm -f *.o iio_event_monitor lsiio generic_buffer
+        rm -f *.o iio_event_monitor lsiio iio_generic_buffer
diff --git a/tools/iio/generic_buffer.c b/tools/iio/iio_generic_buffer.c
index 2429c78de940..e8c30521e99c 100644
--- a/tools/iio/generic_buffer.c
+++ b/tools/iio/iio_generic_buffer.c
@@ -32,6 +32,8 @@
 #include <endian.h>
 #include <getopt.h>
 #include <inttypes.h>
+#include <stdbool.h>
+#include <signal.h>
 #include "iio_utils.h"
 
 /**
@@ -249,11 +251,82 @@ void print_usage(void)
                 "  -e         Disable wait for event (new data)\n"
                 "  -g         Use trigger-less mode\n"
                 "  -l <n>     Set buffer length to n samples\n"
-                "  -n <name>  Set device name (mandatory)\n"
-                "  -t <name>  Set trigger name\n"
+                "  --device-name -n <name>\n"
+                "  --device-num -N <num>\n"
+                "        Set device by name or number (mandatory)\n"
+                "  --trigger-name -t <name>\n"
+                "  --trigger-num -T <num>\n"
+                "        Set trigger by name or number\n"
                 "  -w <n>     Set delay between reads in us (event-less mode)\n");
 }
 
+enum autochan autochannels = AUTOCHANNELS_DISABLED;
+char *dev_dir_name = NULL;
+char *buf_dir_name = NULL;
+bool current_trigger_set = false;
+
+void cleanup(void)
+{
+        int ret;
+
+        /* Disable trigger */
+        if (dev_dir_name && current_trigger_set) {
+                /* Disconnect the trigger - just write a dummy name. */
+                ret = write_sysfs_string("trigger/current_trigger",
+                                         dev_dir_name, "NULL");
+                if (ret < 0)
+                        fprintf(stderr, "Failed to disable trigger: %s\n",
+                                strerror(-ret));
+                current_trigger_set = false;
+        }
+
+        /* Disable buffer */
+        if (buf_dir_name) {
+                ret = write_sysfs_int("enable", buf_dir_name, 0);
+                if (ret < 0)
+                        fprintf(stderr, "Failed to disable buffer: %s\n",
+                                strerror(-ret));
+        }
+
+        /* Disable channels if auto-enabled */
+        if (dev_dir_name && autochannels == AUTOCHANNELS_ACTIVE) {
+                ret = enable_disable_all_channels(dev_dir_name, 0);
+                if (ret)
+                        fprintf(stderr, "Failed to disable all channels\n");
+                autochannels = AUTOCHANNELS_DISABLED;
+        }
+}
+
+void sig_handler(int signum)
+{
+        fprintf(stderr, "Caught signal %d\n", signum);
+        cleanup();
+        exit(-signum);
+}
+
+void register_cleanup(void)
+{
+        struct sigaction sa = { .sa_handler = sig_handler };
+        const int signums[] = { SIGINT, SIGTERM, SIGABRT };
+        int ret, i;
+
+        for (i = 0; i < ARRAY_SIZE(signums); ++i) {
+                ret = sigaction(signums[i], &sa, NULL);
+                if (ret) {
+                        perror("Failed to register signal handler");
+                        exit(-1);
+                }
+        }
+}
+
+static const struct option longopts[] = {
+        { "device-name",        1, 0, 'n' },
+        { "device-num",         1, 0, 'N' },
+        { "trigger-name",       1, 0, 't' },
+        { "trigger-num",        1, 0, 'T' },
+        { },
+};
+
 int main(int argc, char **argv)
 {
         unsigned long num_loops = 2;
@@ -261,26 +334,25 @@ int main(int argc, char **argv)
         unsigned long buf_len = 128;
 
         int ret, c, i, j, toread;
-        int fp;
+        int fp = -1;
 
-        int num_channels;
+        int num_channels = 0;
         char *trigger_name = NULL, *device_name = NULL;
-        char *dev_dir_name, *buf_dir_name;
 
-        int datardytrigger = 1;
-        char *data;
+        char *data = NULL;
         ssize_t read_size;
-        int dev_num, trig_num;
-        char *buffer_access;
+        int dev_num = -1, trig_num;
+        char *buffer_access = NULL;
         int scan_size;
         int noevents = 0;
         int notrigger = 0;
-        enum autochan autochannels = AUTOCHANNELS_DISABLED;
         char *dummy;
 
         struct iio_channel_info *channels;
 
-        while ((c = getopt(argc, argv, "ac:egl:n:t:w:")) != -1) {
+        register_cleanup();
+
+        while ((c = getopt_long(argc, argv, "ac:egl:n:N:t:T:w:", longopts, NULL)) != -1) {
                 switch (c) {
                 case 'a':
                         autochannels = AUTOCHANNELS_ENABLED;
@@ -288,8 +360,10 @@ int main(int argc, char **argv)
                 case 'c':
                         errno = 0;
                         num_loops = strtoul(optarg, &dummy, 10);
-                        if (errno)
-                                return -errno;
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
 
                         break;
                 case 'e':
@@ -301,49 +375,102 @@ int main(int argc, char **argv)
                 case 'l':
                         errno = 0;
                         buf_len = strtoul(optarg, &dummy, 10);
-                        if (errno)
-                                return -errno;
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
 
                         break;
                 case 'n':
-                        device_name = optarg;
+                        device_name = strdup(optarg);
+                        break;
+                case 'N':
+                        errno = 0;
+                        dev_num = strtoul(optarg, &dummy, 10);
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
                         break;
                 case 't':
-                        trigger_name = optarg;
-                        datardytrigger = 0;
+                        trigger_name = strdup(optarg);
                         break;
-                case 'w':
+                case 'T':
                         errno = 0;
-                        timedelay = strtoul(optarg, &dummy, 10);
+                        trig_num = strtoul(optarg, &dummy, 10);
                         if (errno)
                                 return -errno;
                         break;
+                case 'w':
+                        errno = 0;
+                        timedelay = strtoul(optarg, &dummy, 10);
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
+                        break;
                 case '?':
                         print_usage();
-                        return -1;
+                        ret = -1;
+                        goto error;
                 }
         }
 
-        if (!device_name) {
-                fprintf(stderr, "Device name not set\n");
-                print_usage();
-                return -1;
-        }
-
         /* Find the device requested */
-        dev_num = find_type_by_name(device_name, "iio:device");
-        if (dev_num < 0) {
-                fprintf(stderr, "Failed to find the %s\n", device_name);
-                return dev_num;
+        if (dev_num < 0 && !device_name) {
+                fprintf(stderr, "Device not set\n");
+                print_usage();
+                ret = -1;
+                goto error;
+        } else if (dev_num >= 0 && device_name) {
+                fprintf(stderr, "Only one of --device-num or --device-name needs to be set\n");
+                print_usage();
+                ret = -1;
+                goto error;
+        } else if (dev_num < 0) {
+                dev_num = find_type_by_name(device_name, "iio:device");
+                if (dev_num < 0) {
+                        fprintf(stderr, "Failed to find the %s\n", device_name);
+                        ret = dev_num;
+                        goto error;
+                }
         }
-
         printf("iio device number being used is %d\n", dev_num);
 
         ret = asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
         if (ret < 0)
                 return -ENOMEM;
+        /* Fetch device_name if specified by number */
+        if (!device_name) {
+                device_name = malloc(IIO_MAX_NAME_LENGTH);
+                if (!device_name) {
+                        ret = -ENOMEM;
+                        goto error;
+                }
+                ret = read_sysfs_string("name", dev_dir_name, device_name);
+                if (ret < 0) {
+                        fprintf(stderr, "Failed to read name of device %d\n", dev_num);
+                        goto error;
+                }
+        }
 
-        if (!notrigger) {
+        if (notrigger) {
+                printf("trigger-less mode selected\n");
+        } if (trig_num > 0) {
+                char *trig_dev_name;
+                ret = asprintf(&trig_dev_name, "%strigger%d", iio_dir, trig_num);
+                if (ret < 0) {
+                        return -ENOMEM;
+                }
+                trigger_name = malloc(IIO_MAX_NAME_LENGTH);
+                ret = read_sysfs_string("name", trig_dev_name, trigger_name);
+                free(trig_dev_name);
+                if (ret < 0) {
+                        fprintf(stderr, "Failed to read trigger%d name from\n", trig_num);
+                        return ret;
+                }
+                printf("iio trigger number being used is %d\n", trig_num);
+        } else {
                 if (!trigger_name) {
                         /*
                          * Build the trigger name. If it is device associated
@@ -354,7 +481,7 @@ int main(int argc, char **argv)
                                        "%s-dev%d", device_name, dev_num);
                         if (ret < 0) {
                                 ret = -ENOMEM;
-                                goto error_free_dev_dir_name;
+                                goto error;
                         }
                 }
 
@@ -367,7 +494,7 @@ int main(int argc, char **argv)
                                        "%s-trigger", device_name);
                         if (ret < 0) {
                                 ret = -ENOMEM;
-                                goto error_free_dev_dir_name;
+                                goto error;
                         }
                 }
 
@@ -376,12 +503,10 @@ int main(int argc, char **argv)
                         fprintf(stderr, "Failed to find the trigger %s\n",
                                 trigger_name);
                         ret = trig_num;
-                        goto error_free_triggername;
+                        goto error;
                 }
 
                 printf("iio trigger number being used is %d\n", trig_num);
-        } else {
-                printf("trigger-less mode selected\n");
         }
 
         /*
@@ -392,7 +517,7 @@ int main(int argc, char **argv)
         if (ret) {
                 fprintf(stderr, "Problem reading scan element information\n"
                         "diag %s\n", dev_dir_name);
-                goto error_free_triggername;
+                goto error;
         }
         if (num_channels && autochannels == AUTOCHANNELS_ENABLED) {
                 fprintf(stderr, "Auto-channels selected but some channels "
@@ -407,7 +532,7 @@ int main(int argc, char **argv)
                 ret = enable_disable_all_channels(dev_dir_name, 1);
                 if (ret) {
                         fprintf(stderr, "Failed to enable all channels\n");
-                        goto error_free_triggername;
+                        goto error;
                 }
 
                 /* This flags that we need to disable the channels again */
@@ -419,12 +544,12 @@ int main(int argc, char **argv)
                         fprintf(stderr, "Problem reading scan element "
                                 "information\n"
                                 "diag %s\n", dev_dir_name);
-                        goto error_disable_channels;
+                        goto error;
                 }
                 if (!num_channels) {
                         fprintf(stderr, "Still no channels after "
                                 "auto-enabling, giving up\n");
-                        goto error_disable_channels;
+                        goto error;
                 }
         }
 
@@ -436,7 +561,7 @@ int main(int argc, char **argv)
                         "/*_en or pass -a to autoenable channels and "
                         "try again.\n", dev_dir_name);
                 ret = -ENOENT;
-                goto error_free_triggername;
+                goto error;
         }
 
         /*
@@ -448,7 +573,7 @@ int main(int argc, char **argv)
                        "%siio:device%d/buffer", iio_dir, dev_num);
         if (ret < 0) {
                 ret = -ENOMEM;
-                goto error_free_channels;
+                goto error;
         }
 
         if (!notrigger) {
@@ -463,34 +588,34 @@ int main(int argc, char **argv)
                 if (ret < 0) {
                         fprintf(stderr,
                                 "Failed to write current_trigger file\n");
-                        goto error_free_buf_dir_name;
+                        goto error;
                 }
         }
 
         /* Setup ring buffer parameters */
         ret = write_sysfs_int("length", buf_dir_name, buf_len);
         if (ret < 0)
-                goto error_free_buf_dir_name;
+                goto error;
 
         /* Enable the buffer */
         ret = write_sysfs_int("enable", buf_dir_name, 1);
         if (ret < 0) {
                 fprintf(stderr,
                         "Failed to enable buffer: %s\n", strerror(-ret));
-                goto error_free_buf_dir_name;
+                goto error;
         }
 
         scan_size = size_from_channelarray(channels, num_channels);
         data = malloc(scan_size * buf_len);
         if (!data) {
                 ret = -ENOMEM;
-                goto error_free_buf_dir_name;
+                goto error;
         }
 
         ret = asprintf(&buffer_access, "/dev/iio:device%d", dev_num);
         if (ret < 0) {
                 ret = -ENOMEM;
-                goto error_free_data;
+                goto error;
         }
 
         /* Attempt to open non blocking the access dev */
@@ -498,7 +623,7 @@ int main(int argc, char **argv)
         if (fp == -1) { /* TODO: If it isn't there make the node */
                 ret = -errno;
                 fprintf(stderr, "Failed to open %s\n", buffer_access);
-                goto error_free_buffer_access;
+                goto error;
         }
 
         for (j = 0; j < num_loops; j++) {
@@ -511,7 +636,7 @@ int main(int argc, char **argv)
                         ret = poll(&pfd, 1, -1);
                         if (ret < 0) {
                                 ret = -errno;
-                                goto error_close_buffer_access;
+                                goto error;
                         } else if (ret == 0) {
                                 continue;
                         }
@@ -536,45 +661,21 @@ int main(int argc, char **argv)
                                      num_channels);
         }
 
-        /* Stop the buffer */
-        ret = write_sysfs_int("enable", buf_dir_name, 0);
-        if (ret < 0)
-                goto error_close_buffer_access;
+error:
+        cleanup();
 
-        if (!notrigger)
-                /* Disconnect the trigger - just write a dummy name. */
-                ret = write_sysfs_string("trigger/current_trigger",
-                                         dev_dir_name, "NULL");
-                if (ret < 0)
-                        fprintf(stderr, "Failed to write to %s\n",
-                                dev_dir_name);
-
-error_close_buffer_access:
-        if (close(fp) == -1)
+        if (fp >= 0 && close(fp) == -1)
                 perror("Failed to close buffer");
-
-error_free_buffer_access:
         free(buffer_access);
-error_free_data:
         free(data);
-error_free_buf_dir_name:
         free(buf_dir_name);
-error_free_channels:
         for (i = num_channels - 1; i >= 0; i--) {
                 free(channels[i].name);
                 free(channels[i].generic_name);
         }
         free(channels);
-error_free_triggername:
-        if (datardytrigger)
-                free(trigger_name);
-error_disable_channels:
-        if (autochannels == AUTOCHANNELS_ACTIVE) {
-                ret = enable_disable_all_channels(dev_dir_name, 0);
-                if (ret)
-                        fprintf(stderr, "Failed to disable all channels\n");
-        }
-error_free_dev_dir_name:
+        free(trigger_name);
+        free(device_name);
         free(dev_dir_name);
 
         return ret;