1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * IIO driver for the light sensor ISL76682.
4 * ISL76682 is Ambient Light Sensor
5 *
6 * Copyright (c) 2023 Marek Vasut <marex@denx.de>
7 */
8
9#include <linux/array_size.h>
10#include <linux/bits.h>
11#include <linux/cleanup.h>
12#include <linux/delay.h>
13#include <linux/err.h>
14#include <linux/i2c.h>
15#include <linux/module.h>
16#include <linux/mutex.h>
17#include <linux/regmap.h>
18#include <linux/types.h>
19
20#include <linux/iio/iio.h>
21
22#define ISL76682_REG_COMMAND			0x00
23
24#define ISL76682_COMMAND_EN			BIT(7)
25#define ISL76682_COMMAND_MODE_CONTINUOUS	BIT(6)
26#define ISL76682_COMMAND_LIGHT_IR		BIT(5)
27
28#define ISL76682_COMMAND_RANGE_LUX_1K		0x0
29#define ISL76682_COMMAND_RANGE_LUX_4K		0x1
30#define ISL76682_COMMAND_RANGE_LUX_16K		0x2
31#define ISL76682_COMMAND_RANGE_LUX_64K		0x3
32#define ISL76682_COMMAND_RANGE_LUX_MASK		GENMASK(1, 0)
33
34#define ISL76682_REG_ALSIR_L			0x01
35
36#define ISL76682_REG_ALSIR_U			0x02
37
38#define ISL76682_NUM_REGS			(ISL76682_REG_ALSIR_U + 1)
39
40#define ISL76682_CONV_TIME_MS			100
41#define ISL76682_INT_TIME_US			90000
42
43#define ISL76682_ADC_MAX			(BIT(16) - 1)
44
45struct isl76682_chip {
46	/*
47	 * Lock to synchronize access to device command register
48	 * and the content of range variable below.
49	 */
50	struct mutex			lock;
51	struct regmap			*regmap;
52	u8				range;
53	u8				command;
54};
55
56struct isl76682_range {
57	u8				range;
58	u32				als;
59	u32				ir;
60};
61
62static struct isl76682_range isl76682_range_table[] = {
63	{ ISL76682_COMMAND_RANGE_LUX_1K, 15000, 10500 },
64	{ ISL76682_COMMAND_RANGE_LUX_4K, 60000, 42000 },
65	{ ISL76682_COMMAND_RANGE_LUX_16K, 240000, 168000 },
66	{ ISL76682_COMMAND_RANGE_LUX_64K, 960000, 673000 }
67};
68
69static int isl76682_get(struct isl76682_chip *chip, bool mode_ir, int *data)
70{
71	u8 command;
72	int ret;
73
74	command = ISL76682_COMMAND_EN | ISL76682_COMMAND_MODE_CONTINUOUS |
75		  chip->range;
76
77	if (mode_ir)
78		command |= ISL76682_COMMAND_LIGHT_IR;
79
80	if (command != chip->command) {
81		ret = regmap_write(chip->regmap, ISL76682_REG_COMMAND, command);
82		if (ret)
83			return ret;
84
85		/* Need to wait for conversion time if ALS/IR mode enabled */
86		msleep(ISL76682_CONV_TIME_MS);
87
88		chip->command = command;
89	}
90
91	ret = regmap_bulk_read(chip->regmap, ISL76682_REG_ALSIR_L, data, 2);
92	*data &= ISL76682_ADC_MAX;
93	return ret;
94}
95
96static int isl76682_write_raw(struct iio_dev *indio_dev,
97			      struct iio_chan_spec const *chan,
98			      int val, int val2, long mask)
99{
100	struct isl76682_chip *chip = iio_priv(indio_dev);
101	int i;
102
103	if (mask != IIO_CHAN_INFO_SCALE)
104		return -EINVAL;
105
106	if (val != 0)
107		return -EINVAL;
108
109	for (i = 0; i < ARRAY_SIZE(isl76682_range_table); i++) {
110		if (chan->type == IIO_LIGHT && val2 != isl76682_range_table[i].als)
111			continue;
112		if (chan->type == IIO_INTENSITY && val2 != isl76682_range_table[i].ir)
113			continue;
114
115		scoped_guard(mutex, &chip->lock)
116			chip->range = isl76682_range_table[i].range;
117		return 0;
118	}
119
120	return -EINVAL;
121}
122
123static int isl76682_read_raw(struct iio_dev *indio_dev,
124			     struct iio_chan_spec const *chan,
125			     int *val, int *val2, long mask)
126{
127	struct isl76682_chip *chip = iio_priv(indio_dev);
128	int ret;
129	int i;
130
131	guard(mutex)(&chip->lock);
132
133	switch (mask) {
134	case IIO_CHAN_INFO_RAW:
135		switch (chan->type) {
136		case IIO_LIGHT:
137			ret = isl76682_get(chip, false, val);
138			return (ret < 0) ? ret : IIO_VAL_INT;
139		case IIO_INTENSITY:
140			ret = isl76682_get(chip, true, val);
141			return (ret < 0) ? ret : IIO_VAL_INT;
142		default:
143			return -EINVAL;
144		}
145	case IIO_CHAN_INFO_SCALE:
146		for (i = 0; i < ARRAY_SIZE(isl76682_range_table); i++) {
147			if (chip->range != isl76682_range_table[i].range)
148				continue;
149
150			*val = 0;
151			switch (chan->type) {
152			case IIO_LIGHT:
153				*val2 = isl76682_range_table[i].als;
154				return IIO_VAL_INT_PLUS_MICRO;
155			case IIO_INTENSITY:
156				*val2 = isl76682_range_table[i].ir;
157				return IIO_VAL_INT_PLUS_MICRO;
158			default:
159				return -EINVAL;
160			}
161		}
162		return -EINVAL;
163	case IIO_CHAN_INFO_INT_TIME:
164		*val = 0;
165		*val2 = ISL76682_INT_TIME_US;
166		return IIO_VAL_INT_PLUS_MICRO;
167	default:
168		return -EINVAL;
169	}
170}
171
172static int illuminance_scale_available[] = {
173	0, 15000,
174	0, 60000,
175	0, 240000,
176	0, 960000,
177};
178
179static int intensity_scale_available[] = {
180	0, 10500,
181	0, 42000,
182	0, 168000,
183	0, 673000,
184};
185
186static int isl76682_read_avail(struct iio_dev *indio_dev,
187			       struct iio_chan_spec const *chan,
188			       const int **vals, int *type,
189			       int *length, long mask)
190{
191	switch (mask) {
192	case IIO_CHAN_INFO_SCALE:
193		switch (chan->type) {
194		case IIO_LIGHT:
195			*vals = illuminance_scale_available;
196			*length = ARRAY_SIZE(illuminance_scale_available);
197			*type = IIO_VAL_INT_PLUS_MICRO;
198			return IIO_AVAIL_LIST;
199		case IIO_INTENSITY:
200			*vals = intensity_scale_available;
201			*length = ARRAY_SIZE(intensity_scale_available);
202			*type = IIO_VAL_INT_PLUS_MICRO;
203			return IIO_AVAIL_LIST;
204		default:
205			return -EINVAL;
206		}
207	default:
208		return -EINVAL;
209	}
210}
211
212static const struct iio_chan_spec isl76682_channels[] = {
213	{
214		.type = IIO_LIGHT,
215		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
216				      BIT(IIO_CHAN_INFO_SCALE),
217		.info_mask_shared_by_type_available = BIT(IIO_CHAN_INFO_SCALE),
218		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME),
219	}, {
220		.type = IIO_INTENSITY,
221		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
222				      BIT(IIO_CHAN_INFO_SCALE),
223		.info_mask_shared_by_type_available = BIT(IIO_CHAN_INFO_SCALE),
224		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME),
225	}
226};
227
228static const struct iio_info isl76682_info = {
229	.read_avail	= isl76682_read_avail,
230	.read_raw	= isl76682_read_raw,
231	.write_raw	= isl76682_write_raw,
232};
233
234static int isl76682_clear_configure_reg(struct isl76682_chip *chip)
235{
236	struct device *dev = regmap_get_device(chip->regmap);
237	int ret;
238
239	ret = regmap_write(chip->regmap, ISL76682_REG_COMMAND, 0x0);
240	if (ret < 0)
241		dev_err(dev, "Error %d clearing the CONFIGURE register\n", ret);
242
243	/*
244	 * In the success case, the command register was zeroed out.
245	 *
246	 * In the error case, we do not know in which state the command
247	 * register is, so we assume it is zeroed out, so that it would
248	 * be reprogrammed at the next data read out, and at that time
249	 * we hope it would be reprogrammed successfully. That is very
250	 * much a best effort approach.
251	 */
252	chip->command = 0;
253
254	return ret;
255}
256
257static void isl76682_reset_action(void *chip)
258{
259	isl76682_clear_configure_reg(chip);
260}
261
262static bool isl76682_is_volatile_reg(struct device *dev, unsigned int reg)
263{
264	switch (reg) {
265	case ISL76682_REG_ALSIR_L:
266	case ISL76682_REG_ALSIR_U:
267		return true;
268	default:
269		return false;
270	}
271}
272
273static const struct regmap_config isl76682_regmap_config = {
274	.reg_bits		= 8,
275	.val_bits		= 8,
276	.volatile_reg		= isl76682_is_volatile_reg,
277	.max_register		= ISL76682_NUM_REGS - 1,
278	.num_reg_defaults_raw	= ISL76682_NUM_REGS,
279	.cache_type		= REGCACHE_FLAT,
280};
281
282static int isl76682_probe(struct i2c_client *client)
283{
284	struct device *dev = &client->dev;
285	struct isl76682_chip *chip;
286	struct iio_dev *indio_dev;
287	int ret;
288
289	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
290	if (!indio_dev)
291		return -ENOMEM;
292
293	chip = iio_priv(indio_dev);
294
295	mutex_init(&chip->lock);
296
297	chip->regmap = devm_regmap_init_i2c(client, &isl76682_regmap_config);
298	ret = PTR_ERR_OR_ZERO(chip->regmap);
299	if (ret)
300		return dev_err_probe(dev, ret, "Error initializing regmap\n");
301
302	chip->range = ISL76682_COMMAND_RANGE_LUX_1K;
303
304	ret = isl76682_clear_configure_reg(chip);
305	if (ret < 0)
306		return ret;
307
308	ret = devm_add_action_or_reset(dev, isl76682_reset_action, chip);
309	if (ret)
310		return ret;
311
312	indio_dev->info = &isl76682_info;
313	indio_dev->channels = isl76682_channels;
314	indio_dev->num_channels = ARRAY_SIZE(isl76682_channels);
315	indio_dev->name = "isl76682";
316	indio_dev->modes = INDIO_DIRECT_MODE;
317
318	return devm_iio_device_register(dev, indio_dev);
319}
320
321static const struct i2c_device_id isl76682_id[] = {
322	{ "isl76682" },
323	{ }
324};
325MODULE_DEVICE_TABLE(i2c, isl76682_id);
326
327static const struct of_device_id isl76682_of_match[] = {
328	{ .compatible = "isil,isl76682" },
329	{ }
330};
331MODULE_DEVICE_TABLE(of, isl76682_of_match);
332
333static struct i2c_driver isl76682_driver = {
334	.driver  = {
335		.name		= "isl76682",
336		.of_match_table	= isl76682_of_match,
337	},
338	.probe		= isl76682_probe,
339	.id_table	= isl76682_id,
340};
341module_i2c_driver(isl76682_driver);
342
343MODULE_DESCRIPTION("ISL76682 Ambient Light Sensor driver");
344MODULE_LICENSE("GPL");
345MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
346