xref: /openbmc/linux/drivers/iio/proximity/rfd77402.c (revision 7cf15f42)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * rfd77402.c - Support for RF Digital RFD77402 Time-of-Flight (distance) sensor
4  *
5  * Copyright 2017 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
6  *
7  * 7-bit I2C slave address 0x4c
8  *
9  * TODO: interrupt
10  * https://media.digikey.com/pdf/Data%20Sheets/RF%20Digital%20PDFs/RFD77402.pdf
11  */
12 
13 #include <linux/module.h>
14 #include <linux/i2c.h>
15 #include <linux/delay.h>
16 
17 #include <linux/iio/iio.h>
18 
19 #define RFD77402_DRV_NAME "rfd77402"
20 
21 #define RFD77402_ICSR		0x00 /* Interrupt Control Status Register */
22 #define RFD77402_ICSR_INT_MODE	BIT(2)
23 #define RFD77402_ICSR_INT_POL	BIT(3)
24 #define RFD77402_ICSR_RESULT	BIT(4)
25 #define RFD77402_ICSR_M2H_MSG	BIT(5)
26 #define RFD77402_ICSR_H2M_MSG	BIT(6)
27 #define RFD77402_ICSR_RESET	BIT(7)
28 
29 #define RFD77402_CMD_R		0x04
30 #define RFD77402_CMD_SINGLE	0x01
31 #define RFD77402_CMD_STANDBY	0x10
32 #define RFD77402_CMD_MCPU_OFF	0x11
33 #define RFD77402_CMD_MCPU_ON	0x12
34 #define RFD77402_CMD_RESET	BIT(6)
35 #define RFD77402_CMD_VALID	BIT(7)
36 
37 #define RFD77402_STATUS_R	0x06
38 #define RFD77402_STATUS_PM_MASK	GENMASK(4, 0)
39 #define RFD77402_STATUS_STANDBY	0x00
40 #define RFD77402_STATUS_MCPU_OFF	0x10
41 #define RFD77402_STATUS_MCPU_ON	0x18
42 
43 #define RFD77402_RESULT_R	0x08
44 #define RFD77402_RESULT_DIST_MASK	GENMASK(12, 2)
45 #define RFD77402_RESULT_ERR_MASK	GENMASK(14, 13)
46 #define RFD77402_RESULT_VALID	BIT(15)
47 
48 #define RFD77402_PMU_CFG	0x14
49 #define RFD77402_PMU_MCPU_INIT	BIT(9)
50 
51 #define RFD77402_I2C_INIT_CFG	0x1c
52 #define RFD77402_I2C_ADDR_INCR	BIT(0)
53 #define RFD77402_I2C_DATA_INCR	BIT(2)
54 #define RFD77402_I2C_HOST_DEBUG	BIT(5)
55 #define RFD77402_I2C_MCPU_DEBUG	BIT(6)
56 
57 #define RFD77402_CMD_CFGR_A	0x0c
58 #define RFD77402_CMD_CFGR_B	0x0e
59 #define RFD77402_HFCFG_0	0x20
60 #define RFD77402_HFCFG_1	0x22
61 #define RFD77402_HFCFG_2	0x24
62 #define RFD77402_HFCFG_3	0x26
63 
64 #define RFD77402_MOD_CHIP_ID	0x28
65 
66 /* magic configuration values from datasheet */
67 static const struct {
68 	u8 reg;
69 	u16 val;
70 } rf77402_tof_config[] = {
71 	{RFD77402_CMD_CFGR_A,	0xe100},
72 	{RFD77402_CMD_CFGR_B,	0x10ff},
73 	{RFD77402_HFCFG_0,	0x07d0},
74 	{RFD77402_HFCFG_1,	0x5008},
75 	{RFD77402_HFCFG_2,	0xa041},
76 	{RFD77402_HFCFG_3,	0x45d4},
77 };
78 
79 struct rfd77402_data {
80 	struct i2c_client *client;
81 	/* Serialize reads from the sensor */
82 	struct mutex lock;
83 };
84 
85 static const struct iio_chan_spec rfd77402_channels[] = {
86 	{
87 		.type = IIO_DISTANCE,
88 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
89 				      BIT(IIO_CHAN_INFO_SCALE),
90 	},
91 };
92 
rfd77402_set_state(struct i2c_client * client,u8 state,u16 check)93 static int rfd77402_set_state(struct i2c_client *client, u8 state, u16 check)
94 {
95 	int ret;
96 
97 	ret = i2c_smbus_write_byte_data(client, RFD77402_CMD_R,
98 					state | RFD77402_CMD_VALID);
99 	if (ret < 0)
100 		return ret;
101 
102 	usleep_range(10000, 20000);
103 
104 	ret = i2c_smbus_read_word_data(client, RFD77402_STATUS_R);
105 	if (ret < 0)
106 		return ret;
107 	if ((ret & RFD77402_STATUS_PM_MASK) != check)
108 		return -ENODEV;
109 
110 	return 0;
111 }
112 
rfd77402_measure(struct i2c_client * client)113 static int rfd77402_measure(struct i2c_client *client)
114 {
115 	int ret;
116 	int tries = 10;
117 
118 	ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_ON,
119 				 RFD77402_STATUS_MCPU_ON);
120 	if (ret < 0)
121 		return ret;
122 
123 	ret = i2c_smbus_write_byte_data(client, RFD77402_CMD_R,
124 					RFD77402_CMD_SINGLE |
125 					RFD77402_CMD_VALID);
126 	if (ret < 0)
127 		goto err;
128 
129 	while (tries-- > 0) {
130 		ret = i2c_smbus_read_byte_data(client, RFD77402_ICSR);
131 		if (ret < 0)
132 			goto err;
133 		if (ret & RFD77402_ICSR_RESULT)
134 			break;
135 		msleep(20);
136 	}
137 
138 	if (tries < 0) {
139 		ret = -ETIMEDOUT;
140 		goto err;
141 	}
142 
143 	ret = i2c_smbus_read_word_data(client, RFD77402_RESULT_R);
144 	if (ret < 0)
145 		goto err;
146 
147 	if ((ret & RFD77402_RESULT_ERR_MASK) ||
148 	    !(ret & RFD77402_RESULT_VALID)) {
149 		ret = -EIO;
150 		goto err;
151 	}
152 
153 	return (ret & RFD77402_RESULT_DIST_MASK) >> 2;
154 
155 err:
156 	rfd77402_set_state(client, RFD77402_CMD_MCPU_OFF,
157 			   RFD77402_STATUS_MCPU_OFF);
158 	return ret;
159 }
160 
rfd77402_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)161 static int rfd77402_read_raw(struct iio_dev *indio_dev,
162 			     struct iio_chan_spec const *chan,
163 			     int *val, int *val2, long mask)
164 {
165 	struct rfd77402_data *data = iio_priv(indio_dev);
166 	int ret;
167 
168 	switch (mask) {
169 	case IIO_CHAN_INFO_RAW:
170 		mutex_lock(&data->lock);
171 		ret = rfd77402_measure(data->client);
172 		mutex_unlock(&data->lock);
173 		if (ret < 0)
174 			return ret;
175 		*val = ret;
176 		return IIO_VAL_INT;
177 	case IIO_CHAN_INFO_SCALE:
178 		/* 1 LSB is 1 mm */
179 		*val = 0;
180 		*val2 = 1000;
181 		return IIO_VAL_INT_PLUS_MICRO;
182 	default:
183 		return -EINVAL;
184 	}
185 }
186 
187 static const struct iio_info rfd77402_info = {
188 	.read_raw = rfd77402_read_raw,
189 };
190 
rfd77402_init(struct i2c_client * client)191 static int rfd77402_init(struct i2c_client *client)
192 {
193 	int ret, i;
194 
195 	ret = rfd77402_set_state(client, RFD77402_CMD_STANDBY,
196 				 RFD77402_STATUS_STANDBY);
197 	if (ret < 0)
198 		return ret;
199 
200 	/* configure INT pad as push-pull, active low */
201 	ret = i2c_smbus_write_byte_data(client, RFD77402_ICSR,
202 					RFD77402_ICSR_INT_MODE);
203 	if (ret < 0)
204 		return ret;
205 
206 	/* I2C configuration */
207 	ret = i2c_smbus_write_word_data(client, RFD77402_I2C_INIT_CFG,
208 					RFD77402_I2C_ADDR_INCR |
209 					RFD77402_I2C_DATA_INCR |
210 					RFD77402_I2C_HOST_DEBUG	|
211 					RFD77402_I2C_MCPU_DEBUG);
212 	if (ret < 0)
213 		return ret;
214 
215 	/* set initialization */
216 	ret = i2c_smbus_write_word_data(client, RFD77402_PMU_CFG, 0x0500);
217 	if (ret < 0)
218 		return ret;
219 
220 	ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_OFF,
221 				 RFD77402_STATUS_MCPU_OFF);
222 	if (ret < 0)
223 		return ret;
224 
225 	/* set initialization */
226 	ret = i2c_smbus_write_word_data(client, RFD77402_PMU_CFG, 0x0600);
227 	if (ret < 0)
228 		return ret;
229 
230 	ret = rfd77402_set_state(client, RFD77402_CMD_MCPU_ON,
231 				 RFD77402_STATUS_MCPU_ON);
232 	if (ret < 0)
233 		return ret;
234 
235 	for (i = 0; i < ARRAY_SIZE(rf77402_tof_config); i++) {
236 		ret = i2c_smbus_write_word_data(client,
237 						rf77402_tof_config[i].reg,
238 						rf77402_tof_config[i].val);
239 		if (ret < 0)
240 			return ret;
241 	}
242 
243 	ret = rfd77402_set_state(client, RFD77402_CMD_STANDBY,
244 				 RFD77402_STATUS_STANDBY);
245 
246 	return ret;
247 }
248 
rfd77402_powerdown(struct i2c_client * client)249 static int rfd77402_powerdown(struct i2c_client *client)
250 {
251 	return rfd77402_set_state(client, RFD77402_CMD_STANDBY,
252 				  RFD77402_STATUS_STANDBY);
253 }
254 
rfd77402_disable(void * client)255 static void rfd77402_disable(void *client)
256 {
257 	rfd77402_powerdown(client);
258 }
259 
rfd77402_probe(struct i2c_client * client)260 static int rfd77402_probe(struct i2c_client *client)
261 {
262 	struct rfd77402_data *data;
263 	struct iio_dev *indio_dev;
264 	int ret;
265 
266 	ret = i2c_smbus_read_word_data(client, RFD77402_MOD_CHIP_ID);
267 	if (ret < 0)
268 		return ret;
269 	if (ret != 0xad01 && ret != 0xad02) /* known chip ids */
270 		return -ENODEV;
271 
272 	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
273 	if (!indio_dev)
274 		return -ENOMEM;
275 
276 	data = iio_priv(indio_dev);
277 	data->client = client;
278 	mutex_init(&data->lock);
279 
280 	indio_dev->info = &rfd77402_info;
281 	indio_dev->channels = rfd77402_channels;
282 	indio_dev->num_channels = ARRAY_SIZE(rfd77402_channels);
283 	indio_dev->name = RFD77402_DRV_NAME;
284 	indio_dev->modes = INDIO_DIRECT_MODE;
285 
286 	ret = rfd77402_init(client);
287 	if (ret < 0)
288 		return ret;
289 
290 	ret = devm_add_action_or_reset(&client->dev, rfd77402_disable, client);
291 	if (ret)
292 		return ret;
293 
294 	return devm_iio_device_register(&client->dev, indio_dev);
295 }
296 
rfd77402_suspend(struct device * dev)297 static int rfd77402_suspend(struct device *dev)
298 {
299 	return rfd77402_powerdown(to_i2c_client(dev));
300 }
301 
rfd77402_resume(struct device * dev)302 static int rfd77402_resume(struct device *dev)
303 {
304 	return rfd77402_init(to_i2c_client(dev));
305 }
306 
307 static DEFINE_SIMPLE_DEV_PM_OPS(rfd77402_pm_ops, rfd77402_suspend,
308 				rfd77402_resume);
309 
310 static const struct i2c_device_id rfd77402_id[] = {
311 	{ "rfd77402", 0 },
312 	{ }
313 };
314 MODULE_DEVICE_TABLE(i2c, rfd77402_id);
315 
316 static struct i2c_driver rfd77402_driver = {
317 	.driver = {
318 		.name   = RFD77402_DRV_NAME,
319 		.pm     = pm_sleep_ptr(&rfd77402_pm_ops),
320 	},
321 	.probe = rfd77402_probe,
322 	.id_table = rfd77402_id,
323 };
324 
325 module_i2c_driver(rfd77402_driver);
326 
327 MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
328 MODULE_DESCRIPTION("RFD77402 Time-of-Flight sensor driver");
329 MODULE_LICENSE("GPL");
330