iio/proximity/rfd77402.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * rfd77402.c - Support for RF Digital RFD77402 Time-of-Flight (distance) sensor
0004  *
0005  * Copyright 2017 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
0006  *
0007  * 7-bit I2C slave address 0x4c
0008  *
0009  * TODO: interrupt
0010  * https://media.digikey.com/pdf/Data%20Sheets/RF%20Digital%20PDFs/RFD77402.pdf
0011  */
0012
0013 #include <linux/module.h>
0014 #include <linux/i2c.h>
0015 #include <linux/delay.h>
0016
0017 #include <linux/iio/iio.h>
0018
0019 #define RFD77402_DRV_NAME "rfd77402"
0020
0021 #define RFD77402_ICSR       0x00 /* Interrupt Control Status Register */
0022 #define RFD77402_ICSR_INT_MODE  BIT(2)
0023 #define RFD77402_ICSR_INT_POL   BIT(3)
0024 #define RFD77402_ICSR_RESULT    BIT(4)
0025 #define RFD77402_ICSR_M2H_MSG   BIT(5)
0026 #define RFD77402_ICSR_H2M_MSG   BIT(6)
0027 #define RFD77402_ICSR_RESET BIT(7)
0028
0029 #define RFD77402_CMD_R      0x04
0030 #define RFD77402_CMD_SINGLE 0x01
0031 #define RFD77402_CMD_STANDBY    0x10
0032 #define RFD77402_CMD_MCPU_OFF   0x11
0033 #define RFD77402_CMD_MCPU_ON    0x12
0034 #define RFD77402_CMD_RESET  BIT(6)
0035 #define RFD77402_CMD_VALID  BIT(7)
0036
0037 #define RFD77402_STATUS_R   0x06
0038 #define RFD77402_STATUS_PM_MASK GENMASK(4, 0)
0039 #define RFD77402_STATUS_STANDBY 0x00
0040 #define RFD77402_STATUS_MCPU_OFF    0x10
0041 #define RFD77402_STATUS_MCPU_ON 0x18
0042
0043 #define RFD77402_RESULT_R   0x08
0044 #define RFD77402_RESULT_DIST_MASK   GENMASK(12, 2)
0045 #define RFD77402_RESULT_ERR_MASK    GENMASK(14, 13)
0046 #define RFD77402_RESULT_VALID   BIT(15)
0047
0048 #define RFD77402_PMU_CFG    0x14
0049 #define RFD77402_PMU_MCPU_INIT  BIT(9)
0050
0051 #define RFD77402_I2C_INIT_CFG   0x1c
0052 #define RFD77402_I2C_ADDR_INCR  BIT(0)
0053 #define RFD77402_I2C_DATA_INCR  BIT(2)
0054 #define RFD77402_I2C_HOST_DEBUG BIT(5)
0055 #define RFD77402_I2C_MCPU_DEBUG BIT(6)
0056
0057 #define RFD77402_CMD_CFGR_A 0x0c
0058 #define RFD77402_CMD_CFGR_B 0x0e
0059 #define RFD77402_HFCFG_0    0x20
0060 #define RFD77402_HFCFG_1    0x22
0061 #define RFD77402_HFCFG_2    0x24
0062 #define RFD77402_HFCFG_3    0x26
0063
0064 #define RFD77402_MOD_CHIP_ID    0x28
0065
0066 /* magic configuration values from datasheet */
0067 static const struct {
0068     u8 reg;
0069     u16 val;
0070 } rf77402_tof_config[] = {
0071     {RFD77402_CMD_CFGR_A,   0xe100},
0072     {RFD77402_CMD_CFGR_B,   0x10ff},
0073     {RFD77402_HFCFG_0,  0x07d0},
0074     {RFD77402_HFCFG_1,  0x5008},
0075     {RFD77402_HFCFG_2,  0xa041},
0076     {RFD77402_HFCFG_3,  0x45d4},
0077 };
0078
0079 struct rfd77402_data {
0080     struct i2c_client *client;
0081     /* Serialize reads from the sensor */
0082     struct mutex lock;
0083 };
0084
0085 static const struct iio_chan_spec rfd77402_channels[] = {
0086     {
0087         .type = IIO_DISTANCE,
0088         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
0089                       BIT(IIO_CHAN_INFO_SCALE),
0090     },
0091 };
0092
0093 static int rfd77402_set_state(struct i2c_client *client, u8 state, u16 check)
0094 {
0095     int ret;
0096
0097     ret = i2c_smbus_write_byte_data(client, RFD77402_CMD_R,
0098                     state | RFD77402_CMD_VALID);
0099     if (ret < 0)
0100         return ret;
0101
0102     usleep_range(10000, 20000);
0103
0104     ret = i2c_smbus_read_word_data(client, RFD77402_STATUS_R);
0105     if (ret < 0)
0106         return ret;
0107     if ((ret & RFD77402_STATUS_PM_MASK) != check)
0108         return -ENODEV;
0109
0110     return 0;
0111 }
0112
0113 static int rfd77402_measure(struct i2c_client *client)
0114 {
0115     int ret;
0116     int tries = 10;
0117
0118     ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_ON,
0119                  RFD77402_STATUS_MCPU_ON);
0120     if (ret < 0)
0121         return ret;
0122
0123     ret = i2c_smbus_write_byte_data(client, RFD77402_CMD_R,
0124                     RFD77402_CMD_SINGLE |
0125                     RFD77402_CMD_VALID);
0126     if (ret < 0)
0127         goto err;
0128
0129     while (tries-- > 0) {
0130         ret = i2c_smbus_read_byte_data(client, RFD77402_ICSR);
0131         if (ret < 0)
0132             goto err;
0133         if (ret & RFD77402_ICSR_RESULT)
0134             break;
0135         msleep(20);
0136     }
0137
0138     if (tries < 0) {
0139         ret = -ETIMEDOUT;
0140         goto err;
0141     }
0142
0143     ret = i2c_smbus_read_word_data(client, RFD77402_RESULT_R);
0144     if (ret < 0)
0145         goto err;
0146
0147     if ((ret & RFD77402_RESULT_ERR_MASK) ||
0148         !(ret & RFD77402_RESULT_VALID)) {
0149         ret = -EIO;
0150         goto err;
0151     }
0152
0153     return (ret & RFD77402_RESULT_DIST_MASK) >> 2;
0154
0155 err:
0156     rfd77402_set_state(client, RFD77402_CMD_MCPU_OFF,
0157                RFD77402_STATUS_MCPU_OFF);
0158     return ret;
0159 }
0160
0161 static int rfd77402_read_raw(struct iio_dev *indio_dev,
0162                  struct iio_chan_spec const *chan,
0163                  int *val, int *val2, long mask)
0164 {
0165     struct rfd77402_data *data = iio_priv(indio_dev);
0166     int ret;
0167
0168     switch (mask) {
0169     case IIO_CHAN_INFO_RAW:
0170         mutex_lock(&data->lock);
0171         ret = rfd77402_measure(data->client);
0172         mutex_unlock(&data->lock);
0173         if (ret < 0)
0174             return ret;
0175         *val = ret;
0176         return IIO_VAL_INT;
0177     case IIO_CHAN_INFO_SCALE:
0178         /* 1 LSB is 1 mm */
0179         *val = 0;
0180         *val2 = 1000;
0181         return IIO_VAL_INT_PLUS_MICRO;
0182     default:
0183         return -EINVAL;
0184     }
0185 }
0186
0187 static const struct iio_info rfd77402_info = {
0188     .read_raw = rfd77402_read_raw,
0189 };
0190
0191 static int rfd77402_init(struct i2c_client *client)
0192 {
0193     int ret, i;
0194
0195     ret = rfd77402_set_state(client, RFD77402_CMD_STANDBY,
0196                  RFD77402_STATUS_STANDBY);
0197     if (ret < 0)
0198         return ret;
0199
0200     /* configure INT pad as push-pull, active low */
0201     ret = i2c_smbus_write_byte_data(client, RFD77402_ICSR,
0202                     RFD77402_ICSR_INT_MODE);
0203     if (ret < 0)
0204         return ret;
0205
0206     /* I2C configuration */
0207     ret = i2c_smbus_write_word_data(client, RFD77402_I2C_INIT_CFG,
0208                     RFD77402_I2C_ADDR_INCR |
0209                     RFD77402_I2C_DATA_INCR |
0210                     RFD77402_I2C_HOST_DEBUG |
0211                     RFD77402_I2C_MCPU_DEBUG);
0212     if (ret < 0)
0213         return ret;
0214
0215     /* set initialization */
0216     ret = i2c_smbus_write_word_data(client, RFD77402_PMU_CFG, 0x0500);
0217     if (ret < 0)
0218         return ret;
0219
0220     ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_OFF,
0221                  RFD77402_STATUS_MCPU_OFF);
0222     if (ret < 0)
0223         return ret;
0224
0225     /* set initialization */
0226     ret = i2c_smbus_write_word_data(client, RFD77402_PMU_CFG, 0x0600);
0227     if (ret < 0)
0228         return ret;
0229
0230     ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_ON,
0231                  RFD77402_STATUS_MCPU_ON);
0232     if (ret < 0)
0233         return ret;
0234
0235     for (i = 0; i < ARRAY_SIZE(rf77402_tof_config); i++) {
0236         ret = i2c_smbus_write_word_data(client,
0237                         rf77402_tof_config[i].reg,
0238                         rf77402_tof_config[i].val);
0239         if (ret < 0)
0240             return ret;
0241     }
0242
0243     ret = rfd77402_set_state(client, RFD77402_CMD_STANDBY,
0244                  RFD77402_STATUS_STANDBY);
0245
0246     return ret;
0247 }
0248
0249 static int rfd77402_powerdown(struct i2c_client *client)
0250 {
0251     return rfd77402_set_state(client, RFD77402_CMD_STANDBY,
0252                   RFD77402_STATUS_STANDBY);
0253 }
0254
0255 static void rfd77402_disable(void *client)
0256 {
0257     rfd77402_powerdown(client);
0258 }
0259
0260 static int rfd77402_probe(struct i2c_client *client,
0261               const struct i2c_device_id *id)
0262 {
0263     struct rfd77402_data *data;
0264     struct iio_dev *indio_dev;
0265     int ret;
0266
0267     ret = i2c_smbus_read_word_data(client, RFD77402_MOD_CHIP_ID);
0268     if (ret < 0)
0269         return ret;
0270     if (ret != 0xad01 && ret != 0xad02) /* known chip ids */
0271         return -ENODEV;
0272
0273     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
0274     if (!indio_dev)
0275         return -ENOMEM;
0276
0277     data = iio_priv(indio_dev);
0278     data->client = client;
0279     mutex_init(&data->lock);
0280
0281     indio_dev->info = &rfd77402_info;
0282     indio_dev->channels = rfd77402_channels;
0283     indio_dev->num_channels = ARRAY_SIZE(rfd77402_channels);
0284     indio_dev->name = RFD77402_DRV_NAME;
0285     indio_dev->modes = INDIO_DIRECT_MODE;
0286
0287     ret = rfd77402_init(client);
0288     if (ret < 0)
0289         return ret;
0290
0291     ret = devm_add_action_or_reset(&client->dev, rfd77402_disable, client);
0292     if (ret)
0293         return ret;
0294
0295     return devm_iio_device_register(&client->dev, indio_dev);
0296 }
0297
0298 static int rfd77402_suspend(struct device *dev)
0299 {
0300     return rfd77402_powerdown(to_i2c_client(dev));
0301 }
0302
0303 static int rfd77402_resume(struct device *dev)
0304 {
0305     return rfd77402_init(to_i2c_client(dev));
0306 }
0307
0308 static DEFINE_SIMPLE_DEV_PM_OPS(rfd77402_pm_ops, rfd77402_suspend,
0309                 rfd77402_resume);
0310
0311 static const struct i2c_device_id rfd77402_id[] = {
0312     { "rfd77402", 0 },
0313     { }
0314 };
0315 MODULE_DEVICE_TABLE(i2c, rfd77402_id);
0316
0317 static struct i2c_driver rfd77402_driver = {
0318     .driver = {
0319         .name   = RFD77402_DRV_NAME,
0320         .pm     = pm_sleep_ptr(&rfd77402_pm_ops),
0321     },
0322     .probe  = rfd77402_probe,
0323     .id_table = rfd77402_id,
0324 };
0325
0326 module_i2c_driver(rfd77402_driver);
0327
0328 MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
0329 MODULE_DESCRIPTION("RFD77402 Time-of-Flight sensor driver");
0330 MODULE_LICENSE("GPL");