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