isl29125.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * isl29125.c - Support for Intersil ISL29125 RGB light sensor
  4 *
  5 * Copyright (c) 2014 Peter Meerwald <pmeerw@pmeerw.net>
  6 *
  7 * RGB light sensor with 16-bit channels for red, green, blue);
  8 * 7-bit I2C slave address 0x44
  9 *
 10 * TODO: interrupt support, IR compensation, thresholds, 12bit
 11 */
 12
 13#include <linux/module.h>
 14#include <linux/i2c.h>
 15#include <linux/delay.h>
 16#include <linux/pm.h>
 17
 18#include <linux/iio/iio.h>
 19#include <linux/iio/sysfs.h>
 20#include <linux/iio/trigger_consumer.h>
 21#include <linux/iio/buffer.h>
 22#include <linux/iio/triggered_buffer.h>
 23
 24#define ISL29125_DRV_NAME "isl29125"
 25
 26#define ISL29125_DEVICE_ID 0x00
 27#define ISL29125_CONF1 0x01
 28#define ISL29125_CONF2 0x02
 29#define ISL29125_CONF3 0x03
 30#define ISL29125_STATUS 0x08
 31#define ISL29125_GREEN_DATA 0x09
 32#define ISL29125_RED_DATA 0x0b
 33#define ISL29125_BLUE_DATA 0x0d
 34
 35#define ISL29125_ID 0x7d
 36
 37#define ISL29125_MODE_MASK GENMASK(2, 0)
 38#define ISL29125_MODE_PD 0x0
 39#define ISL29125_MODE_G 0x1
 40#define ISL29125_MODE_R 0x2
 41#define ISL29125_MODE_B 0x3
 42#define ISL29125_MODE_RGB 0x5
 43
 44#define ISL29125_SENSING_RANGE_0 5722   /* 375 lux full range */
 45#define ISL29125_SENSING_RANGE_1 152590 /* 10k lux full range */
 46
 47#define ISL29125_MODE_RANGE BIT(3)
 48
 49#define ISL29125_STATUS_CONV BIT(1)
 50
 51struct isl29125_data {
 52	struct i2c_client *client;
 53	u8 conf1;
 54};
 55
 56#define ISL29125_CHANNEL(_color, _si) { \
 57	.type = IIO_INTENSITY, \
 58	.modified = 1, \
 59	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 60	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
 61	.channel2 = IIO_MOD_LIGHT_##_color, \
 62	.scan_index = _si, \
 63	.scan_type = { \
 64		.sign = 'u', \
 65		.realbits = 16, \
 66		.storagebits = 16, \
 67		.endianness = IIO_CPU, \
 68	}, \
 69}
 70
 71static const struct iio_chan_spec isl29125_channels[] = {
 72	ISL29125_CHANNEL(GREEN, 0),
 73	ISL29125_CHANNEL(RED, 1),
 74	ISL29125_CHANNEL(BLUE, 2),
 75	IIO_CHAN_SOFT_TIMESTAMP(3),
 76};
 77
 78static const struct {
 79	u8 mode, data;
 80} isl29125_regs[] = {
 81	{ISL29125_MODE_G, ISL29125_GREEN_DATA},
 82	{ISL29125_MODE_R, ISL29125_RED_DATA},
 83	{ISL29125_MODE_B, ISL29125_BLUE_DATA},
 84};
 85
 86static int isl29125_read_data(struct isl29125_data *data, int si)
 87{
 88	int tries = 5;
 89	int ret;
 90
 91	ret = i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
 92		data->conf1 | isl29125_regs[si].mode);
 93	if (ret < 0)
 94		return ret;
 95
 96	msleep(101);
 97
 98	while (tries--) {
 99		ret = i2c_smbus_read_byte_data(data->client, ISL29125_STATUS);
100		if (ret < 0)
101			goto fail;
102		if (ret & ISL29125_STATUS_CONV)
103			break;
104		msleep(20);
105	}
106
107	if (tries < 0) {
108		dev_err(&data->client->dev, "data not ready\n");
109		ret = -EIO;
110		goto fail;
111	}
112
113	ret = i2c_smbus_read_word_data(data->client, isl29125_regs[si].data);
114
115fail:
116	i2c_smbus_write_byte_data(data->client, ISL29125_CONF1, data->conf1);
117	return ret;
118}
119
120static int isl29125_read_raw(struct iio_dev *indio_dev,
121			   struct iio_chan_spec const *chan,
122			   int *val, int *val2, long mask)
123{
124	struct isl29125_data *data = iio_priv(indio_dev);
125	int ret;
126
127	switch (mask) {
128	case IIO_CHAN_INFO_RAW:
129		if (!iio_device_claim_direct(indio_dev))
130			return -EBUSY;
131		ret = isl29125_read_data(data, chan->scan_index);
132		iio_device_release_direct(indio_dev);
133		if (ret < 0)
134			return ret;
135		*val = ret;
136		return IIO_VAL_INT;
137	case IIO_CHAN_INFO_SCALE:
138		*val = 0;
139		if (data->conf1 & ISL29125_MODE_RANGE)
140			*val2 = ISL29125_SENSING_RANGE_1; /*10k lux full range*/
141		else
142			*val2 = ISL29125_SENSING_RANGE_0; /*375 lux full range*/
143		return IIO_VAL_INT_PLUS_MICRO;
144	}
145	return -EINVAL;
146}
147
148static int isl29125_write_raw(struct iio_dev *indio_dev,
149			       struct iio_chan_spec const *chan,
150			       int val, int val2, long mask)
151{
152	struct isl29125_data *data = iio_priv(indio_dev);
153
154	switch (mask) {
155	case IIO_CHAN_INFO_SCALE:
156		if (val != 0)
157			return -EINVAL;
158		if (val2 == ISL29125_SENSING_RANGE_1)
159			data->conf1 |= ISL29125_MODE_RANGE;
160		else if (val2 == ISL29125_SENSING_RANGE_0)
161			data->conf1 &= ~ISL29125_MODE_RANGE;
162		else
163			return -EINVAL;
164		return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
165			data->conf1);
166	default:
167		return -EINVAL;
168	}
169}
170
171static irqreturn_t isl29125_trigger_handler(int irq, void *p)
172{
173	struct iio_poll_func *pf = p;
174	struct iio_dev *indio_dev = pf->indio_dev;
175	struct isl29125_data *data = iio_priv(indio_dev);
176	int i, j = 0;
177	/* Ensure timestamp is naturally aligned */
178	struct {
179		u16 chans[3];
180		aligned_s64 timestamp;
181	} scan = { };
182
183	iio_for_each_active_channel(indio_dev, i) {
184		int ret = i2c_smbus_read_word_data(data->client,
185			isl29125_regs[i].data);
186		if (ret < 0)
187			goto done;
188
189		scan.chans[j++] = ret;
190	}
191
192	iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan),
193		iio_get_time_ns(indio_dev));
194
195done:
196	iio_trigger_notify_done(indio_dev->trig);
197
198	return IRQ_HANDLED;
199}
200
201static IIO_CONST_ATTR(scale_available, "0.005722 0.152590");
202
203static struct attribute *isl29125_attributes[] = {
204	&iio_const_attr_scale_available.dev_attr.attr,
205	NULL
206};
207
208static const struct attribute_group isl29125_attribute_group = {
209	.attrs = isl29125_attributes,
210};
211
212static const struct iio_info isl29125_info = {
213	.read_raw = isl29125_read_raw,
214	.write_raw = isl29125_write_raw,
215	.attrs = &isl29125_attribute_group,
216};
217
218static int isl29125_buffer_postenable(struct iio_dev *indio_dev)
219{
220	struct isl29125_data *data = iio_priv(indio_dev);
221
222	data->conf1 |= ISL29125_MODE_RGB;
223	return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
224		data->conf1);
225}
226
227static int isl29125_buffer_predisable(struct iio_dev *indio_dev)
228{
229	struct isl29125_data *data = iio_priv(indio_dev);
230
231	data->conf1 &= ~ISL29125_MODE_MASK;
232	data->conf1 |= ISL29125_MODE_PD;
233	return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
234		data->conf1);
235}
236
237static const struct iio_buffer_setup_ops isl29125_buffer_setup_ops = {
238	.postenable = isl29125_buffer_postenable,
239	.predisable = isl29125_buffer_predisable,
240};
241
242static int isl29125_probe(struct i2c_client *client)
243{
244	struct isl29125_data *data;
245	struct iio_dev *indio_dev;
246	int ret;
247
248	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
249	if (indio_dev == NULL)
250		return -ENOMEM;
251
252	data = iio_priv(indio_dev);
253	i2c_set_clientdata(client, indio_dev);
254	data->client = client;
255
256	indio_dev->info = &isl29125_info;
257	indio_dev->name = ISL29125_DRV_NAME;
258	indio_dev->channels = isl29125_channels;
259	indio_dev->num_channels = ARRAY_SIZE(isl29125_channels);
260	indio_dev->modes = INDIO_DIRECT_MODE;
261
262	ret = i2c_smbus_read_byte_data(data->client, ISL29125_DEVICE_ID);
263	if (ret < 0)
264		return ret;
265	if (ret != ISL29125_ID)
266		return -ENODEV;
267
268	data->conf1 = ISL29125_MODE_PD | ISL29125_MODE_RANGE;
269	ret = i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
270		data->conf1);
271	if (ret < 0)
272		return ret;
273
274	ret = i2c_smbus_write_byte_data(data->client, ISL29125_STATUS, 0);
275	if (ret < 0)
276		return ret;
277
278	ret = iio_triggered_buffer_setup(indio_dev, NULL,
279		isl29125_trigger_handler, &isl29125_buffer_setup_ops);
280	if (ret < 0)
281		return ret;
282
283	ret = iio_device_register(indio_dev);
284	if (ret < 0)
285		goto buffer_cleanup;
286
287	return 0;
288
289buffer_cleanup:
290	iio_triggered_buffer_cleanup(indio_dev);
291	return ret;
292}
293
294static int isl29125_powerdown(struct isl29125_data *data)
295{
296	return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
297		(data->conf1 & ~ISL29125_MODE_MASK) | ISL29125_MODE_PD);
298}
299
300static void isl29125_remove(struct i2c_client *client)
301{
302	struct iio_dev *indio_dev = i2c_get_clientdata(client);
303
304	iio_device_unregister(indio_dev);
305	iio_triggered_buffer_cleanup(indio_dev);
306	isl29125_powerdown(iio_priv(indio_dev));
307}
308
309static int isl29125_suspend(struct device *dev)
310{
311	struct isl29125_data *data = iio_priv(i2c_get_clientdata(
312		to_i2c_client(dev)));
313	return isl29125_powerdown(data);
314}
315
316static int isl29125_resume(struct device *dev)
317{
318	struct isl29125_data *data = iio_priv(i2c_get_clientdata(
319		to_i2c_client(dev)));
320	return i2c_smbus_write_byte_data(data->client, ISL29125_CONF1,
321		data->conf1);
322}
323
324static DEFINE_SIMPLE_DEV_PM_OPS(isl29125_pm_ops, isl29125_suspend,
325				isl29125_resume);
326
327static const struct i2c_device_id isl29125_id[] = {
328	{ "isl29125" },
329	{ }
330};
331MODULE_DEVICE_TABLE(i2c, isl29125_id);
332
333static struct i2c_driver isl29125_driver = {
334	.driver = {
335		.name	= ISL29125_DRV_NAME,
336		.pm	= pm_sleep_ptr(&isl29125_pm_ops),
337	},
338	.probe		= isl29125_probe,
339	.remove		= isl29125_remove,
340	.id_table	= isl29125_id,
341};
342module_i2c_driver(isl29125_driver);
343
344MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
345MODULE_DESCRIPTION("ISL29125 RGB light sensor driver");
346MODULE_LICENSE("GPL");