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

Pull staging driver updates from Greg KH:
 "Here's the big staging driver patchset for 4.1-rc1.

  There's a lot of patches here, the Outreachy application period
  happened during this development cycle, so that means that there was a
  lot of cleanup patches accepted.  Other than the normal coding style
  and sparse fixes here, there are some driver updates and work toward
  making some of the drivers into "mergable" shape (like the Unisys
  drivers.)

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

* tag 'staging-4.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (1214 commits)
  staging: lustre: orthography & coding style
  staging: lustre: lnet: lnet: fix error return code
  staging: lustre: fix sparse warning
  Revert "Staging: sm750fb: Fix C99 Comments"
  Staging: rtl8192u: use correct array for debug output
  staging: rtl8192e: Remove dead code
  staging: rtl8192e: Comment cleanup (style/format)
  staging: rtl8192e: Fix indentation in rtllib_rx_auth_resp()
  staging: rtl8192e: Decrease nesting of rtllib_rx_auth_resp()
  staging: rtl8192e: Divide rtllib_rx_auth()
  staging: rtl8192e: Fix PRINTK_WITHOUT_KERN_LEVEL warnings
  staging: rtl8192e: Fix DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON warning
  staging: rtl8192e: Fix BRACES warning
  staging: rtl8192e: Fix LINE_CONTINUATIONS warning
  staging: rtl8192e: Fix UNNECESSARY_PARENTHESES warnings
  staging: rtl8192e: remove unused EXPORT_SYMBOL_RSL macro
  staging: rtl8192e: Fix RETURN_VOID warnings
  staging: rtl8192e: Fix UNNECESSARY_ELSE warning
  staging: rtl8723au: Remove unneeded comments
  staging: rtl8723au: Use __func__ in trace logs
  ...

7 files changed, 347 insertions, 12 deletions

diff --git a/drivers/iio/light/Kconfig b/drivers/iio/light/Kconfig
index a224afd6380c..01a1a16ab7be 100644
--- a/drivers/iio/light/Kconfig
+++ b/drivers/iio/light/Kconfig
@@ -59,6 +59,16 @@ config CM3232
          To compile this driver as a module, choose M here:
          the module will be called cm3232.
 
+config CM3323
+        depends on I2C
+        tristate "Capella CM3323 color light sensor"
+        help
+         Say Y here if you want to build a driver for Capela CM3323
+         color sensor.
+
+         To compile this driver as a module, choose M here: the module will
+         be called cm3323.
+
 config CM36651
         depends on I2C
         tristate "CM36651 driver"
diff --git a/drivers/iio/light/Makefile b/drivers/iio/light/Makefile
index b12a5160d9e0..ad7c30fe443b 100644
--- a/drivers/iio/light/Makefile
+++ b/drivers/iio/light/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_AL3320A)		+= al3320a.o
 obj-$(CONFIG_APDS9300)          += apds9300.o
 obj-$(CONFIG_CM32181)           += cm32181.o
 obj-$(CONFIG_CM3232)            += cm3232.o
+obj-$(CONFIG_CM3323)            += cm3323.o
 obj-$(CONFIG_CM36651)           += cm36651.o
 obj-$(CONFIG_GP2AP020A00F)      += gp2ap020a00f.o
 obj-$(CONFIG_HID_SENSOR_ALS)    += hid-sensor-als.o
diff --git a/drivers/iio/light/cm3232.c b/drivers/iio/light/cm3232.c
index 90e3519a91de..39c8d99cc48e 100644
--- a/drivers/iio/light/cm3232.c
+++ b/drivers/iio/light/cm3232.c
@@ -378,6 +378,39 @@ static const struct i2c_device_id cm3232_id[] = {
         {}
 };
 
+#ifdef CONFIG_PM_SLEEP
+static int cm3232_suspend(struct device *dev)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+        struct cm3232_chip *chip = iio_priv(indio_dev);
+        struct i2c_client *client = chip->client;
+        int ret;
+
+        chip->regs_cmd |= CM3232_CMD_ALS_DISABLE;
+        ret = i2c_smbus_write_byte_data(client, CM3232_REG_ADDR_CMD,
+                                        chip->regs_cmd);
+
+        return ret;
+}
+
+static int cm3232_resume(struct device *dev)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+        struct cm3232_chip *chip = iio_priv(indio_dev);
+        struct i2c_client *client = chip->client;
+        int ret;
+
+        chip->regs_cmd &= ~CM3232_CMD_ALS_DISABLE;
+        ret = i2c_smbus_write_byte_data(client, CM3232_REG_ADDR_CMD,
+                                        chip->regs_cmd | CM3232_CMD_ALS_RESET);
+
+        return ret;
+}
+
+static const struct dev_pm_ops cm3232_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(cm3232_suspend, cm3232_resume)};
+#endif
+
 MODULE_DEVICE_TABLE(i2c, cm3232_id);
 
 static const struct of_device_id cm3232_of_match[] = {
@@ -390,6 +423,9 @@ static struct i2c_driver cm3232_driver = {
                 .name   = "cm3232",
                 .owner  = THIS_MODULE,
                 .of_match_table = of_match_ptr(cm3232_of_match),
+#ifdef CONFIG_PM_SLEEP
+                .pm     = &cm3232_pm_ops,
+#endif
         },
         .id_table       = cm3232_id,
         .probe          = cm3232_probe,
diff --git a/drivers/iio/light/cm3323.c b/drivers/iio/light/cm3323.c
new file mode 100644
index 000000000000..869033e48a1f
--- /dev/null
+++ b/drivers/iio/light/cm3323.c
@@ -0,0 +1,286 @@
+/*
+ * CM3323 - Capella Color Light Sensor
+ *
+ * Copyright (c) 2015, 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 CM3323 (7-bit I2C slave address 0x10)
+ *
+ * TODO: calibscale to correct the lens factor
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/mutex.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define CM3323_DRV_NAME "cm3323"
+
+#define CM3323_CMD_CONF         0x00
+#define CM3323_CMD_RED_DATA     0x08
+#define CM3323_CMD_GREEN_DATA   0x09
+#define CM3323_CMD_BLUE_DATA    0x0A
+#define CM3323_CMD_CLEAR_DATA   0x0B
+
+#define CM3323_CONF_SD_BIT      BIT(0) /* sensor disable */
+#define CM3323_CONF_AF_BIT      BIT(1) /* auto/manual force mode */
+#define CM3323_CONF_IT_MASK     (BIT(4) | BIT(5) | BIT(6))
+#define CM3323_CONF_IT_SHIFT    4
+
+#define CM3323_INT_TIME_AVAILABLE "0.04 0.08 0.16 0.32 0.64 1.28"
+
+static const struct {
+        int val;
+        int val2;
+} cm3323_int_time[] = {
+        {0, 40000},  /* 40 ms */
+        {0, 80000},  /* 80 ms */
+        {0, 160000}, /* 160 ms */
+        {0, 320000}, /* 320 ms */
+        {0, 640000}, /* 640 ms */
+        {1, 280000}, /* 1280 ms */
+};
+
+struct cm3323_data {
+        struct i2c_client *client;
+        u16 reg_conf;
+        struct mutex mutex;
+};
+
+#define CM3323_COLOR_CHANNEL(_color, _addr) { \
+        .type = IIO_INTENSITY, \
+        .modified = 1, \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+        .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME), \
+        .channel2 = IIO_MOD_LIGHT_##_color, \
+        .address = _addr, \
+}
+
+static const struct iio_chan_spec cm3323_channels[] = {
+        CM3323_COLOR_CHANNEL(RED, CM3323_CMD_RED_DATA),
+        CM3323_COLOR_CHANNEL(GREEN, CM3323_CMD_GREEN_DATA),
+        CM3323_COLOR_CHANNEL(BLUE, CM3323_CMD_BLUE_DATA),
+        CM3323_COLOR_CHANNEL(CLEAR, CM3323_CMD_CLEAR_DATA),
+};
+
+static IIO_CONST_ATTR_INT_TIME_AVAIL(CM3323_INT_TIME_AVAILABLE);
+
+static struct attribute *cm3323_attributes[] = {
+        &iio_const_attr_integration_time_available.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group cm3323_attribute_group = {
+        .attrs = cm3323_attributes,
+};
+
+static int cm3323_init(struct iio_dev *indio_dev)
+{
+        int ret;
+        struct cm3323_data *data = iio_priv(indio_dev);
+
+        ret = i2c_smbus_read_word_data(data->client, CM3323_CMD_CONF);
+        if (ret < 0) {
+                dev_err(&data->client->dev, "Error reading reg_conf\n");
+                return ret;
+        }
+
+        /* enable sensor and set auto force mode */
+        ret &= ~(CM3323_CONF_SD_BIT | CM3323_CONF_AF_BIT);
+
+        ret = i2c_smbus_write_word_data(data->client, CM3323_CMD_CONF, ret);
+        if (ret < 0) {
+                dev_err(&data->client->dev, "Error writing reg_conf\n");
+                return ret;
+        }
+
+        data->reg_conf = ret;
+
+        return 0;
+}
+
+static void cm3323_disable(struct iio_dev *indio_dev)
+{
+        int ret;
+        struct cm3323_data *data = iio_priv(indio_dev);
+
+        ret = i2c_smbus_write_word_data(data->client, CM3323_CMD_CONF,
+                                        CM3323_CONF_SD_BIT);
+        if (ret < 0)
+                dev_err(&data->client->dev, "Error writing reg_conf\n");
+}
+
+static int cm3323_set_it_bits(struct cm3323_data *data, int val, int val2)
+{
+        int i, ret;
+        u16 reg_conf;
+
+        for (i = 0; i < ARRAY_SIZE(cm3323_int_time); i++) {
+                if (val == cm3323_int_time[i].val &&
+                    val2 == cm3323_int_time[i].val2) {
+                        reg_conf = data->reg_conf;
+                        reg_conf |= i << CM3323_CONF_IT_SHIFT;
+
+                        ret = i2c_smbus_write_word_data(data->client,
+                                                        CM3323_CMD_CONF,
+                                                        reg_conf);
+                        if (ret < 0)
+                                return ret;
+
+                        data->reg_conf = reg_conf;
+                        return 0;
+                }
+        }
+        return -EINVAL;
+}
+
+static int cm3323_get_it_bits(struct cm3323_data *data)
+{
+        int bits;
+
+        bits = (data->reg_conf & CM3323_CONF_IT_MASK) >>
+                CM3323_CONF_IT_SHIFT;
+
+        if (bits >= ARRAY_SIZE(cm3323_int_time))
+                return -EINVAL;
+        return bits;
+}
+
+static int cm3323_read_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan, int *val,
+                           int *val2, long mask)
+{
+        int i, ret;
+        struct cm3323_data *data = iio_priv(indio_dev);
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                mutex_lock(&data->mutex);
+                ret = i2c_smbus_read_word_data(data->client, chan->address);
+                if (ret < 0) {
+                        mutex_unlock(&data->mutex);
+                        return ret;
+                }
+                *val = ret;
+                mutex_unlock(&data->mutex);
+
+                return IIO_VAL_INT;
+        case IIO_CHAN_INFO_INT_TIME:
+                mutex_lock(&data->mutex);
+                i = cm3323_get_it_bits(data);
+                if (i < 0) {
+                        mutex_unlock(&data->mutex);
+                        return -EINVAL;
+                }
+
+                *val = cm3323_int_time[i].val;
+                *val2 = cm3323_int_time[i].val2;
+                mutex_unlock(&data->mutex);
+
+                return IIO_VAL_INT_PLUS_MICRO;
+        default:
+                return -EINVAL;
+        }
+}
+
+static int cm3323_write_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan, int val,
+                            int val2, long mask)
+{
+        struct cm3323_data *data = iio_priv(indio_dev);
+        int ret;
+
+        switch (mask) {
+        case IIO_CHAN_INFO_INT_TIME:
+                mutex_lock(&data->mutex);
+                ret = cm3323_set_it_bits(data, val, val2);
+                mutex_unlock(&data->mutex);
+
+                return ret;
+        default:
+                return -EINVAL;
+        }
+}
+
+static const struct iio_info cm3323_info = {
+        .driver_module  = THIS_MODULE,
+        .read_raw       = cm3323_read_raw,
+        .write_raw      = cm3323_write_raw,
+        .attrs          = &cm3323_attribute_group,
+};
+
+static int cm3323_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        struct cm3323_data *data;
+        struct iio_dev *indio_dev;
+        int ret;
+
+        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+        if (!indio_dev)
+                return -ENOMEM;
+
+        data = iio_priv(indio_dev);
+        i2c_set_clientdata(client, indio_dev);
+        data->client = client;
+
+        mutex_init(&data->mutex);
+
+        indio_dev->dev.parent = &client->dev;
+        indio_dev->info = &cm3323_info;
+        indio_dev->name = CM3323_DRV_NAME;
+        indio_dev->channels = cm3323_channels;
+        indio_dev->num_channels = ARRAY_SIZE(cm3323_channels);
+        indio_dev->modes = INDIO_DIRECT_MODE;
+
+        ret = cm3323_init(indio_dev);
+        if (ret < 0) {
+                dev_err(&client->dev, "cm3323 chip init failed\n");
+                return ret;
+        }
+        ret = iio_device_register(indio_dev);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed to register iio dev\n");
+                goto err_init;
+        }
+        return 0;
+err_init:
+        cm3323_disable(indio_dev);
+        return ret;
+}
+
+static int cm3323_remove(struct i2c_client *client)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(client);
+
+        iio_device_unregister(indio_dev);
+        cm3323_disable(indio_dev);
+
+        return 0;
+}
+
+static const struct i2c_device_id cm3323_id[] = {
+        {"cm3323", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, cm3323_id);
+
+static struct i2c_driver cm3323_driver = {
+        .driver = {
+                .name = CM3323_DRV_NAME,
+        },
+        .probe          = cm3323_probe,
+        .remove         = cm3323_remove,
+        .id_table       = cm3323_id,
+};
+
+module_i2c_driver(cm3323_driver);
+
+MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
+MODULE_DESCRIPTION("Capella CM3323 Color Light Sensor driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/light/gp2ap020a00f.c b/drivers/iio/light/gp2ap020a00f.c
index 221ed16de1f7..32b6449833fa 100644
--- a/drivers/iio/light/gp2ap020a00f.c
+++ b/drivers/iio/light/gp2ap020a00f.c
@@ -46,6 +46,7 @@
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
+#include <asm/unaligned.h>
 #include <linux/iio/buffer.h>
 #include <linux/iio/events.h>
 #include <linux/iio/iio.h>
@@ -966,7 +967,6 @@ static irqreturn_t gp2ap020a00f_trigger_handler(int irq, void *data)
         struct iio_dev *indio_dev = pf->indio_dev;
         struct gp2ap020a00f_data *priv = iio_priv(indio_dev);
         size_t d_size = 0;
-        __le32 light_lux;
         int i, out_val, ret;
 
         for_each_set_bit(i, indio_dev->active_scan_mask,
@@ -981,8 +981,8 @@ static irqreturn_t gp2ap020a00f_trigger_handler(int irq, void *data)
                     i == GP2AP020A00F_SCAN_MODE_LIGHT_IR) {
                         out_val = le16_to_cpup((__le16 *)&priv->buffer[d_size]);
                         gp2ap020a00f_output_to_lux(priv, &out_val);
-                        light_lux = cpu_to_le32(out_val);
-                        memcpy(&priv->buffer[d_size], (u8 *)&light_lux, 4);
+
+                        put_unaligned_le32(out_val, &priv->buffer[d_size]);
                         d_size += 4;
                 } else {
                         d_size += 2;
diff --git a/drivers/iio/light/jsa1212.c b/drivers/iio/light/jsa1212.c
index 29de7e7d9562..3a3af89beaf9 100644
--- a/drivers/iio/light/jsa1212.c
+++ b/drivers/iio/light/jsa1212.c
@@ -308,7 +308,7 @@ static bool jsa1212_is_volatile_reg(struct device *dev, unsigned int reg)
         }
 }
 
-static struct regmap_config jsa1212_regmap_config = {
+static const struct regmap_config jsa1212_regmap_config = {
         .name =  JSA1212_REGMAP_NAME,
         .reg_bits = 8,
         .val_bits = 8,
diff --git a/drivers/iio/light/ltr501.c b/drivers/iio/light/ltr501.c
index 62b7072af4de..78b87839c4b9 100644
--- a/drivers/iio/light/ltr501.c
+++ b/drivers/iio/light/ltr501.c
@@ -333,6 +333,13 @@ static int ltr501_init(struct ltr501_data *data)
                 data->ps_contr);
 }
 
+static int ltr501_powerdown(struct ltr501_data *data)
+{
+        return ltr501_write_contr(data->client,
+                                  data->als_contr & ~LTR501_CONTR_ACTIVE,
+                                  data->ps_contr & ~LTR501_CONTR_ACTIVE);
+}
+
 static int ltr501_probe(struct i2c_client *client,
                           const struct i2c_device_id *id)
 {
@@ -370,7 +377,7 @@ static int ltr501_probe(struct i2c_client *client,
         ret = iio_triggered_buffer_setup(indio_dev, NULL,
                 ltr501_trigger_handler, NULL);
         if (ret)
-                return ret;
+                goto powerdown_on_error;
 
         ret = iio_device_register(indio_dev);
         if (ret)
@@ -380,16 +387,11 @@ static int ltr501_probe(struct i2c_client *client,
 
 error_unreg_buffer:
         iio_triggered_buffer_cleanup(indio_dev);
+powerdown_on_error:
+        ltr501_powerdown(data);
         return ret;
 }
 
-static int ltr501_powerdown(struct ltr501_data *data)
-{
-        return ltr501_write_contr(data->client,
-                data->als_contr & ~LTR501_CONTR_ACTIVE,
-                data->ps_contr & ~LTR501_CONTR_ACTIVE);
-}
-
 static int ltr501_remove(struct i2c_client *client)
 {
         struct iio_dev *indio_dev = i2c_get_clientdata(client);