Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma

[linux-2.6-microblaze.git] / drivers / iio / proximity / rfd77402.c

diff --git a/drivers/iio/proximity/rfd77402.c b/drivers/iio/proximity/rfd77402.c
index 7a04723..8c06d02 100644 (file)
--- a/drivers/iio/proximity/rfd77402.c
+++ b/drivers/iio/proximity/rfd77402.c
@@ -90,18 +90,18 @@ static const struct iio_chan_spec rfd77402_channels[] = {
        },
 };
 
-static int rfd77402_set_state(struct rfd77402_data *data, u8 state, u16 check)
+static int rfd77402_set_state(struct i2c_client *client, u8 state, u16 check)
 {
        int ret;
 
-       ret = i2c_smbus_write_byte_data(data->client, RFD77402_CMD_R,
+       ret = i2c_smbus_write_byte_data(client, RFD77402_CMD_R,
                                        state | RFD77402_CMD_VALID);
        if (ret < 0)
                return ret;
 
        usleep_range(10000, 20000);
 
-       ret = i2c_smbus_read_word_data(data->client, RFD77402_STATUS_R);
+       ret = i2c_smbus_read_word_data(client, RFD77402_STATUS_R);
        if (ret < 0)
                return ret;
        if ((ret & RFD77402_STATUS_PM_MASK) != check)
@@ -110,24 +110,24 @@ static int rfd77402_set_state(struct rfd77402_data *data, u8 state, u16 check)
        return 0;
 }
 
-static int rfd77402_measure(struct rfd77402_data *data)
+static int rfd77402_measure(struct i2c_client *client)
 {
        int ret;
        int tries = 10;
 
-       ret = rfd77402_set_state(data, RFD77402_CMD_MCPU_ON,
+       ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_ON,
                                 RFD77402_STATUS_MCPU_ON);
        if (ret < 0)
                return ret;
 
-       ret = i2c_smbus_write_byte_data(data->client, RFD77402_CMD_R,
+       ret = i2c_smbus_write_byte_data(client, RFD77402_CMD_R,
                                        RFD77402_CMD_SINGLE |
                                        RFD77402_CMD_VALID);
        if (ret < 0)
                goto err;
 
        while (tries-- > 0) {
-               ret = i2c_smbus_read_byte_data(data->client, RFD77402_ICSR);
+               ret = i2c_smbus_read_byte_data(client, RFD77402_ICSR);
                if (ret < 0)
                        goto err;
                if (ret & RFD77402_ICSR_RESULT)
@@ -140,7 +140,7 @@ static int rfd77402_measure(struct rfd77402_data *data)
                goto err;
        }
 
-       ret = i2c_smbus_read_word_data(data->client, RFD77402_RESULT_R);
+       ret = i2c_smbus_read_word_data(client, RFD77402_RESULT_R);
        if (ret < 0)
                goto err;
 
@@ -153,7 +153,7 @@ static int rfd77402_measure(struct rfd77402_data *data)
        return (ret & RFD77402_RESULT_DIST_MASK) >> 2;
 
 err:
-       rfd77402_set_state(data, RFD77402_CMD_MCPU_OFF,
+       rfd77402_set_state(client, RFD77402_CMD_MCPU_OFF,
                           RFD77402_STATUS_MCPU_OFF);
        return ret;
 }
@@ -168,7 +168,7 @@ static int rfd77402_read_raw(struct iio_dev *indio_dev,
        switch (mask) {
        case IIO_CHAN_INFO_RAW:
                mutex_lock(&data->lock);
-               ret = rfd77402_measure(data);
+               ret = rfd77402_measure(data->client);
                mutex_unlock(&data->lock);
                if (ret < 0)
                        return ret;
@@ -188,23 +188,23 @@ static const struct iio_info rfd77402_info = {
        .read_raw = rfd77402_read_raw,
 };
 
-static int rfd77402_init(struct rfd77402_data *data)
+static int rfd77402_init(struct i2c_client *client)
 {
        int ret, i;
 
-       ret = rfd77402_set_state(data, RFD77402_CMD_STANDBY,
+       ret = rfd77402_set_state(client, RFD77402_CMD_STANDBY,
                                 RFD77402_STATUS_STANDBY);
        if (ret < 0)
                return ret;
 
        /* configure INT pad as push-pull, active low */
-       ret = i2c_smbus_write_byte_data(data->client, RFD77402_ICSR,
+       ret = i2c_smbus_write_byte_data(client, RFD77402_ICSR,
                                        RFD77402_ICSR_INT_MODE);
        if (ret < 0)
                return ret;
 
        /* I2C configuration */
-       ret = i2c_smbus_write_word_data(data->client, RFD77402_I2C_INIT_CFG,
+       ret = i2c_smbus_write_word_data(client, RFD77402_I2C_INIT_CFG,
                                        RFD77402_I2C_ADDR_INCR |
                                        RFD77402_I2C_DATA_INCR |
                                        RFD77402_I2C_HOST_DEBUG |
@@ -213,45 +213,50 @@ static int rfd77402_init(struct rfd77402_data *data)
                return ret;
 
        /* set initialization */
-       ret = i2c_smbus_write_word_data(data->client, RFD77402_PMU_CFG, 0x0500);
+       ret = i2c_smbus_write_word_data(client, RFD77402_PMU_CFG, 0x0500);
        if (ret < 0)
                return ret;
 
-       ret = rfd77402_set_state(data, RFD77402_CMD_MCPU_OFF,
+       ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_OFF,
                                 RFD77402_STATUS_MCPU_OFF);
        if (ret < 0)
                return ret;
 
        /* set initialization */
-       ret = i2c_smbus_write_word_data(data->client, RFD77402_PMU_CFG, 0x0600);
+       ret = i2c_smbus_write_word_data(client, RFD77402_PMU_CFG, 0x0600);
        if (ret < 0)
                return ret;
 
-       ret = rfd77402_set_state(data, RFD77402_CMD_MCPU_ON,
+       ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_ON,
                                 RFD77402_STATUS_MCPU_ON);
        if (ret < 0)
                return ret;
 
        for (i = 0; i < ARRAY_SIZE(rf77402_tof_config); i++) {
-               ret = i2c_smbus_write_word_data(data->client,
+               ret = i2c_smbus_write_word_data(client,
                                                rf77402_tof_config[i].reg,
                                                rf77402_tof_config[i].val);
                if (ret < 0)
                        return ret;
        }
 
-       ret = rfd77402_set_state(data, RFD77402_CMD_STANDBY,
+       ret = rfd77402_set_state(client, RFD77402_CMD_STANDBY,
                                 RFD77402_STATUS_STANDBY);
 
        return ret;
 }
 
-static int rfd77402_powerdown(struct rfd77402_data *data)
+static int rfd77402_powerdown(struct i2c_client *client)
 {
-       return rfd77402_set_state(data, RFD77402_CMD_STANDBY,
+       return rfd77402_set_state(client, RFD77402_CMD_STANDBY,
                                  RFD77402_STATUS_STANDBY);
 }
 
+static void rfd77402_disable(void *client)
+{
+       rfd77402_powerdown(client);
+}
+
 static int rfd77402_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
@@ -270,7 +275,6 @@ static int rfd77402_probe(struct i2c_client *client,
                return -ENOMEM;
 
        data = iio_priv(indio_dev);
-       i2c_set_clientdata(client, indio_dev);
        data->client = client;
        mutex_init(&data->lock);
 
@@ -280,46 +284,26 @@ static int rfd77402_probe(struct i2c_client *client,
        indio_dev->name = RFD77402_DRV_NAME;
        indio_dev->modes = INDIO_DIRECT_MODE;
 
-       ret = rfd77402_init(data);
+       ret = rfd77402_init(client);
        if (ret < 0)
                return ret;
 
-       ret = iio_device_register(indio_dev);
+       ret = devm_add_action_or_reset(&client->dev, rfd77402_disable, client);
        if (ret)
-               goto err_powerdown;
-
-       return 0;
-
-err_powerdown:
-       rfd77402_powerdown(data);
-       return ret;
-}
-
-static int rfd77402_remove(struct i2c_client *client)
-{
-       struct iio_dev *indio_dev = i2c_get_clientdata(client);
-
-       iio_device_unregister(indio_dev);
-       rfd77402_powerdown(iio_priv(indio_dev));
+               return ret;
 
-       return 0;
+       return devm_iio_device_register(&client->dev, indio_dev);
 }
 
 #ifdef CONFIG_PM_SLEEP
 static int rfd77402_suspend(struct device *dev)
 {
-       struct rfd77402_data *data = iio_priv(i2c_get_clientdata(
-                                    to_i2c_client(dev)));
-
-       return rfd77402_powerdown(data);
+       return rfd77402_powerdown(to_i2c_client(dev));
 }
 
 static int rfd77402_resume(struct device *dev)
 {
-       struct rfd77402_data *data = iio_priv(i2c_get_clientdata(
-                                    to_i2c_client(dev)));
-
-       return rfd77402_init(data);
+       return rfd77402_init(to_i2c_client(dev));
 }
 #endif
 
@@ -337,7 +321,6 @@ static struct i2c_driver rfd77402_driver = {
                .pm     = &rfd77402_pm_ops,
        },
        .probe  = rfd77402_probe,
-       .remove = rfd77402_remove,
        .id_table = rfd77402_id,
 };