1 files changed, 40 insertions, 62 deletions

diff --git a/drivers/hwmon/ads7828.c b/drivers/hwmon/ads7828.c
index a622d40eec17..bce4e9ff21bf 100644
--- a/drivers/hwmon/ads7828.c
+++ b/drivers/hwmon/ads7828.c
@@ -30,14 +30,12 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
-#include <linux/jiffies.h>
 #include <linux/module.h>
-#include <linux/mutex.h>
 #include <linux/platform_data/ads7828.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 
 /* The ADS7828 registers */
-#define ADS7828_NCH             8       /* 8 channels supported */
 #define ADS7828_CMD_SD_SE       0x80    /* Single ended inputs */
 #define ADS7828_CMD_PD1         0x04    /* Internal vref OFF && A/D ON */
 #define ADS7828_CMD_PD3         0x0C    /* Internal vref ON && A/D ON */
@@ -50,17 +48,9 @@ enum ads7828_chips { ads7828, ads7830 };
 
 /* Client specific data */
 struct ads7828_data {
-        struct i2c_client *client;
-        struct mutex update_lock;       /* Mutex protecting updates */
-        unsigned long last_updated;     /* Last updated time (in jiffies) */
-        u16 adc_input[ADS7828_NCH];     /* ADS7828_NCH samples */
-        bool valid;                     /* Validity flag */
-        bool diff_input;                /* Differential input */
-        bool ext_vref;                  /* External voltage reference */
-        unsigned int vref_mv;           /* voltage reference value */
+        struct regmap *regmap;
         u8 cmd_byte;                    /* Command byte without channel bits */
         unsigned int lsb_resol;         /* Resolution of the ADC sample LSB */
-        s32 (*read_channel)(const struct i2c_client *client, u8 command);
 };
 
 /* Command byte C2,C1,C0 - see datasheet */
@@ -69,42 +59,22 @@ static inline u8 ads7828_cmd_byte(u8 cmd, int ch)
         return cmd | (((ch >> 1) | (ch & 0x01) << 2) << 4);
 }
 
-/* Update data for the device (all 8 channels) */
-static struct ads7828_data *ads7828_update_device(struct device *dev)
-{
-        struct ads7828_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = data->client;
-
-        mutex_lock(&data->update_lock);
-
-        if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
-                        || !data->valid) {
-                unsigned int ch;
-                dev_dbg(&client->dev, "Starting ads7828 update\n");
-
-                for (ch = 0; ch < ADS7828_NCH; ch++) {
-                        u8 cmd = ads7828_cmd_byte(data->cmd_byte, ch);
-                        data->adc_input[ch] = data->read_channel(client, cmd);
-                }
-                data->last_updated = jiffies;
-                data->valid = true;
-        }
-
-        mutex_unlock(&data->update_lock);
-
-        return data;
-}
-
 /* sysfs callback function */
 static ssize_t ads7828_show_in(struct device *dev, struct device_attribute *da,
                                char *buf)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
-        struct ads7828_data *data = ads7828_update_device(dev);
-        unsigned int value = DIV_ROUND_CLOSEST(data->adc_input[attr->index] *
-                                               data->lsb_resol, 1000);
+        struct ads7828_data *data = dev_get_drvdata(dev);
+        u8 cmd = ads7828_cmd_byte(data->cmd_byte, attr->index);
+        unsigned int regval;
+        int err;
 
-        return sprintf(buf, "%d\n", value);
+        err = regmap_read(data->regmap, cmd, &regval);
+        if (err < 0)
+                return err;
+
+        return sprintf(buf, "%d\n",
+                       DIV_ROUND_CLOSEST(regval * data->lsb_resol, 1000));
 }
 
 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ads7828_show_in, NULL, 0);
@@ -130,6 +100,16 @@ static struct attribute *ads7828_attrs[] = {
 
 ATTRIBUTE_GROUPS(ads7828);
 
+static const struct regmap_config ads2828_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 16,
+};
+
+static const struct regmap_config ads2830_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+};
+
 static int ads7828_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
@@ -137,42 +117,40 @@ static int ads7828_probe(struct i2c_client *client,
         struct ads7828_platform_data *pdata = dev_get_platdata(dev);
         struct ads7828_data *data;
         struct device *hwmon_dev;
+        unsigned int vref_mv = ADS7828_INT_VREF_MV;
+        bool diff_input = false;
+        bool ext_vref = false;
 
         data = devm_kzalloc(dev, sizeof(struct ads7828_data), GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
         if (pdata) {
-                data->diff_input = pdata->diff_input;
-                data->ext_vref = pdata->ext_vref;
-                if (data->ext_vref)
-                        data->vref_mv = pdata->vref_mv;
+                diff_input = pdata->diff_input;
+                ext_vref = pdata->ext_vref;
+                if (ext_vref && pdata->vref_mv)
+                        vref_mv = pdata->vref_mv;
         }
 
-        /* Bound Vref with min/max values if it was provided */
-        if (data->vref_mv)
-                data->vref_mv = clamp_val(data->vref_mv,
-                                          ADS7828_EXT_VREF_MV_MIN,
-                                          ADS7828_EXT_VREF_MV_MAX);
-        else
-                data->vref_mv = ADS7828_INT_VREF_MV;
+        /* Bound Vref with min/max values */
+        vref_mv = clamp_val(vref_mv, ADS7828_EXT_VREF_MV_MIN,
+                            ADS7828_EXT_VREF_MV_MAX);
 
         /* ADS7828 uses 12-bit samples, while ADS7830 is 8-bit */
         if (id->driver_data == ads7828) {
-                data->lsb_resol = DIV_ROUND_CLOSEST(data->vref_mv * 1000, 4096);
-                data->read_channel = i2c_smbus_read_word_swapped;
+                data->lsb_resol = DIV_ROUND_CLOSEST(vref_mv * 1000, 4096);
+                data->regmap = devm_regmap_init_i2c(client,
+                                                    &ads2828_regmap_config);
         } else {
-                data->lsb_resol = DIV_ROUND_CLOSEST(data->vref_mv * 1000, 256);
-                data->read_channel = i2c_smbus_read_byte_data;
+                data->lsb_resol = DIV_ROUND_CLOSEST(vref_mv * 1000, 256);
+                data->regmap = devm_regmap_init_i2c(client,
+                                                    &ads2830_regmap_config);
         }
 
-        data->cmd_byte = data->ext_vref ? ADS7828_CMD_PD1 : ADS7828_CMD_PD3;
-        if (!data->diff_input)
+        data->cmd_byte = ext_vref ? ADS7828_CMD_PD1 : ADS7828_CMD_PD3;
+        if (!diff_input)
                 data->cmd_byte |= ADS7828_CMD_SD_SE;
 
-        data->client = client;
-        mutex_init(&data->update_lock);
-
         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
                                                            data,
                                                            ads7828_groups);