tcs3414.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * tcs3414.c - Support for TAOS TCS3414 digital color sensor
  4 *
  5 * Copyright (c) 2014 Peter Meerwald <pmeerw@pmeerw.net>
  6 *
  7 * Digital color sensor with 16-bit channels for red, green, blue, clear);
  8 * 7-bit I2C slave address 0x39 (TCS3414) or 0x29, 0x49, 0x59 (TCS3413,
  9 * TCS3415, TCS3416, resp.)
 10 *
 11 * TODO: sync, interrupt support, thresholds, prescaler
 12 */
 13
 14#include <linux/module.h>
 15#include <linux/i2c.h>
 16#include <linux/delay.h>
 17#include <linux/pm.h>
 18
 19#include <linux/iio/iio.h>
 20#include <linux/iio/sysfs.h>
 21#include <linux/iio/trigger_consumer.h>
 22#include <linux/iio/buffer.h>
 23#include <linux/iio/triggered_buffer.h>
 24
 25#define TCS3414_DRV_NAME "tcs3414"
 26
 27#define TCS3414_COMMAND BIT(7)
 28#define TCS3414_COMMAND_WORD (TCS3414_COMMAND | BIT(5))
 29
 30#define TCS3414_CONTROL (TCS3414_COMMAND | 0x00)
 31#define TCS3414_TIMING (TCS3414_COMMAND | 0x01)
 32#define TCS3414_ID (TCS3414_COMMAND | 0x04)
 33#define TCS3414_GAIN (TCS3414_COMMAND | 0x07)
 34#define TCS3414_DATA_GREEN (TCS3414_COMMAND_WORD | 0x10)
 35#define TCS3414_DATA_RED (TCS3414_COMMAND_WORD | 0x12)
 36#define TCS3414_DATA_BLUE (TCS3414_COMMAND_WORD | 0x14)
 37#define TCS3414_DATA_CLEAR (TCS3414_COMMAND_WORD | 0x16)
 38
 39#define TCS3414_CONTROL_ADC_VALID BIT(4)
 40#define TCS3414_CONTROL_ADC_EN BIT(1)
 41#define TCS3414_CONTROL_POWER BIT(0)
 42
 43#define TCS3414_INTEG_MASK GENMASK(1, 0)
 44#define TCS3414_INTEG_12MS 0x0
 45#define TCS3414_INTEG_100MS 0x1
 46#define TCS3414_INTEG_400MS 0x2
 47
 48#define TCS3414_GAIN_MASK GENMASK(5, 4)
 49#define TCS3414_GAIN_SHIFT 4
 50
 51struct tcs3414_data {
 52	struct i2c_client *client;
 53	u8 control;
 54	u8 gain;
 55	u8 timing;
 56};
 57
 58#define TCS3414_CHANNEL(_color, _si, _addr) { \
 59	.type = IIO_INTENSITY, \
 60	.modified = 1, \
 61	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 62	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
 63		BIT(IIO_CHAN_INFO_INT_TIME), \
 64	.channel2 = IIO_MOD_LIGHT_##_color, \
 65	.address = _addr, \
 66	.scan_index = _si, \
 67	.scan_type = { \
 68		.sign = 'u', \
 69		.realbits = 16, \
 70		.storagebits = 16, \
 71		.endianness = IIO_CPU, \
 72	}, \
 73}
 74
 75/* scale factors: 1/gain */
 76static const int tcs3414_scales[][2] = {
 77	{1, 0}, {0, 250000}, {0, 62500}, {0, 15625}
 78};
 79
 80/* integration time in ms */
 81static const int tcs3414_times[] = { 12, 100, 400 };
 82
 83static const struct iio_chan_spec tcs3414_channels[] = {
 84	TCS3414_CHANNEL(GREEN, 0, TCS3414_DATA_GREEN),
 85	TCS3414_CHANNEL(RED, 1, TCS3414_DATA_RED),
 86	TCS3414_CHANNEL(BLUE, 2, TCS3414_DATA_BLUE),
 87	TCS3414_CHANNEL(CLEAR, 3, TCS3414_DATA_CLEAR),
 88	IIO_CHAN_SOFT_TIMESTAMP(4),
 89};
 90
 91static int tcs3414_req_data(struct tcs3414_data *data)
 92{
 93	int tries = 25;
 94	int ret;
 95
 96	ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
 97		data->control | TCS3414_CONTROL_ADC_EN);
 98	if (ret < 0)
 99		return ret;
100
101	while (tries--) {
102		ret = i2c_smbus_read_byte_data(data->client, TCS3414_CONTROL);
103		if (ret < 0)
104			return ret;
105		if (ret & TCS3414_CONTROL_ADC_VALID)
106			break;
107		msleep(20);
108	}
109
110	ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
111		data->control);
112	if (ret < 0)
113		return ret;
114
115	if (tries < 0) {
116		dev_err(&data->client->dev, "data not ready\n");
117		return -EIO;
118	}
119
120	return 0;
121}
122
123static int tcs3414_read_raw(struct iio_dev *indio_dev,
124			   struct iio_chan_spec const *chan,
125			   int *val, int *val2, long mask)
126{
127	struct tcs3414_data *data = iio_priv(indio_dev);
128	int i, ret;
129
130	switch (mask) {
131	case IIO_CHAN_INFO_RAW:
132		if (!iio_device_claim_direct(indio_dev))
133			return -EBUSY;
134		ret = tcs3414_req_data(data);
135		if (ret < 0) {
136			iio_device_release_direct(indio_dev);
137			return ret;
138		}
139		ret = i2c_smbus_read_word_data(data->client, chan->address);
140		iio_device_release_direct(indio_dev);
141		if (ret < 0)
142			return ret;
143		*val = ret;
144		return IIO_VAL_INT;
145	case IIO_CHAN_INFO_SCALE:
146		i = (data->gain & TCS3414_GAIN_MASK) >> TCS3414_GAIN_SHIFT;
147		*val = tcs3414_scales[i][0];
148		*val2 = tcs3414_scales[i][1];
149		return IIO_VAL_INT_PLUS_MICRO;
150	case IIO_CHAN_INFO_INT_TIME:
151		*val = 0;
152		*val2 = tcs3414_times[data->timing & TCS3414_INTEG_MASK] * 1000;
153		return IIO_VAL_INT_PLUS_MICRO;
154	}
155	return -EINVAL;
156}
157
158static int tcs3414_write_raw(struct iio_dev *indio_dev,
159			       struct iio_chan_spec const *chan,
160			       int val, int val2, long mask)
161{
162	struct tcs3414_data *data = iio_priv(indio_dev);
163	int i;
164
165	switch (mask) {
166	case IIO_CHAN_INFO_SCALE:
167		for (i = 0; i < ARRAY_SIZE(tcs3414_scales); i++) {
168			if (val == tcs3414_scales[i][0] &&
169				val2 == tcs3414_scales[i][1]) {
170				data->gain &= ~TCS3414_GAIN_MASK;
171				data->gain |= i << TCS3414_GAIN_SHIFT;
172				return i2c_smbus_write_byte_data(
173					data->client, TCS3414_GAIN,
174					data->gain);
175			}
176		}
177		return -EINVAL;
178	case IIO_CHAN_INFO_INT_TIME:
179		if (val != 0)
180			return -EINVAL;
181		for (i = 0; i < ARRAY_SIZE(tcs3414_times); i++) {
182			if (val2 == tcs3414_times[i] * 1000) {
183				data->timing &= ~TCS3414_INTEG_MASK;
184				data->timing |= i;
185				return i2c_smbus_write_byte_data(
186					data->client, TCS3414_TIMING,
187					data->timing);
188			}
189		}
190		return -EINVAL;
191	default:
192		return -EINVAL;
193	}
194}
195
196static irqreturn_t tcs3414_trigger_handler(int irq, void *p)
197{
198	struct iio_poll_func *pf = p;
199	struct iio_dev *indio_dev = pf->indio_dev;
200	struct tcs3414_data *data = iio_priv(indio_dev);
201	int i, j = 0;
202	/* Ensure timestamp is naturally aligned */
203	struct {
204		u16 chans[4];
205		aligned_s64 timestamp;
206	} scan = { };
207
208
209	iio_for_each_active_channel(indio_dev, i) {
210		int ret = i2c_smbus_read_word_data(data->client,
211			TCS3414_DATA_GREEN + 2*i);
212		if (ret < 0)
213			goto done;
214
215		scan.chans[j++] = ret;
216	}
217
218	iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan),
219		iio_get_time_ns(indio_dev));
220
221done:
222	iio_trigger_notify_done(indio_dev->trig);
223
224	return IRQ_HANDLED;
225}
226
227static IIO_CONST_ATTR(scale_available, "1 0.25 0.0625 0.015625");
228static IIO_CONST_ATTR_INT_TIME_AVAIL("0.012 0.1 0.4");
229
230static struct attribute *tcs3414_attributes[] = {
231	&iio_const_attr_scale_available.dev_attr.attr,
232	&iio_const_attr_integration_time_available.dev_attr.attr,
233	NULL
234};
235
236static const struct attribute_group tcs3414_attribute_group = {
237	.attrs = tcs3414_attributes,
238};
239
240static const struct iio_info tcs3414_info = {
241	.read_raw = tcs3414_read_raw,
242	.write_raw = tcs3414_write_raw,
243	.attrs = &tcs3414_attribute_group,
244};
245
246static int tcs3414_buffer_postenable(struct iio_dev *indio_dev)
247{
248	struct tcs3414_data *data = iio_priv(indio_dev);
249
250	data->control |= TCS3414_CONTROL_ADC_EN;
251	return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
252		data->control);
253}
254
255static int tcs3414_buffer_predisable(struct iio_dev *indio_dev)
256{
257	struct tcs3414_data *data = iio_priv(indio_dev);
258
259	data->control &= ~TCS3414_CONTROL_ADC_EN;
260	return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
261		data->control);
262}
263
264static const struct iio_buffer_setup_ops tcs3414_buffer_setup_ops = {
265	.postenable = tcs3414_buffer_postenable,
266	.predisable = tcs3414_buffer_predisable,
267};
268
269static int tcs3414_powerdown(struct tcs3414_data *data)
270{
271	return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
272		data->control & ~(TCS3414_CONTROL_POWER |
273		TCS3414_CONTROL_ADC_EN));
274}
275
276static void tcs3414_powerdown_cleanup(void *data)
277{
278	tcs3414_powerdown(data);
279}
280
281static int tcs3414_probe(struct i2c_client *client)
282{
283	struct tcs3414_data *data;
284	struct iio_dev *indio_dev;
285	int ret;
286
287	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
288	if (indio_dev == NULL)
289		return -ENOMEM;
290
291	data = iio_priv(indio_dev);
292	i2c_set_clientdata(client, indio_dev);
293	data->client = client;
294
295	indio_dev->info = &tcs3414_info;
296	indio_dev->name = TCS3414_DRV_NAME;
297	indio_dev->channels = tcs3414_channels;
298	indio_dev->num_channels = ARRAY_SIZE(tcs3414_channels);
299	indio_dev->modes = INDIO_DIRECT_MODE;
300
301	ret = i2c_smbus_read_byte_data(data->client, TCS3414_ID);
302	if (ret < 0)
303		return ret;
304
305	switch (ret & 0xf0) {
306	case 0x00:
307		dev_info(&client->dev, "TCS3404 found\n");
308		break;
309	case 0x10:
310		dev_info(&client->dev, "TCS3413/14/15/16 found\n");
311		break;
312	default:
313		return -ENODEV;
314	}
315
316	data->control = TCS3414_CONTROL_POWER;
317	ret = i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
318		data->control);
319	if (ret < 0)
320		return ret;
321
322	ret = devm_add_action_or_reset(&client->dev, tcs3414_powerdown_cleanup,
323				       data);
324	if (ret < 0)
325		return ret;
326
327	data->timing = TCS3414_INTEG_12MS; /* free running */
328	ret = i2c_smbus_write_byte_data(data->client, TCS3414_TIMING,
329		data->timing);
330	if (ret < 0)
331		return ret;
332
333	ret = i2c_smbus_read_byte_data(data->client, TCS3414_GAIN);
334	if (ret < 0)
335		return ret;
336	data->gain = ret;
337
338	ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
339		tcs3414_trigger_handler, &tcs3414_buffer_setup_ops);
340	if (ret < 0)
341		return ret;
342
343	return devm_iio_device_register(&client->dev, indio_dev);
344}
345
346static int tcs3414_suspend(struct device *dev)
347{
348	struct tcs3414_data *data = iio_priv(i2c_get_clientdata(
349		to_i2c_client(dev)));
350	return tcs3414_powerdown(data);
351}
352
353static int tcs3414_resume(struct device *dev)
354{
355	struct tcs3414_data *data = iio_priv(i2c_get_clientdata(
356		to_i2c_client(dev)));
357	return i2c_smbus_write_byte_data(data->client, TCS3414_CONTROL,
358		data->control);
359}
360
361static DEFINE_SIMPLE_DEV_PM_OPS(tcs3414_pm_ops, tcs3414_suspend,
362				tcs3414_resume);
363
364static const struct i2c_device_id tcs3414_id[] = {
365	{ "tcs3414" },
366	{ }
367};
368MODULE_DEVICE_TABLE(i2c, tcs3414_id);
369
370static struct i2c_driver tcs3414_driver = {
371	.driver = {
372		.name	= TCS3414_DRV_NAME,
373		.pm	= pm_sleep_ptr(&tcs3414_pm_ops),
374	},
375	.probe		= tcs3414_probe,
376	.id_table	= tcs3414_id,
377};
378module_i2c_driver(tcs3414_driver);
379
380MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
381MODULE_DESCRIPTION("TCS3414 digital color sensors driver");
382MODULE_LICENSE("GPL");