?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / iio / light / as73211.c
blob7b32dfaee9b32cbad7dfae385ce05b85d6c6f9da
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Support for AMS AS73211 JENCOLOR(R) Digital XYZ Sensor
4 *
5 * Author: Christian Eggers <ceggers@arri.de>
6 *
7 * Copyright (c) 2020 ARRI Lighting
8 *
9 * Color light sensor with 16-bit channels for x, y, z and temperature);
10 * 7-bit I2C slave address 0x74 .. 0x77.
11 *
12 * Datasheet: https://ams.com/documents/20143/36005/AS73211_DS000556_3-01.pdf
13 */
14
15 #include <linux/bitfield.h>
16 #include <linux/completion.h>
17 #include <linux/delay.h>
18 #include <linux/i2c.h>
19 #include <linux/iio/buffer.h>
20 #include <linux/iio/iio.h>
21 #include <linux/iio/sysfs.h>
22 #include <linux/iio/trigger_consumer.h>
23 #include <linux/iio/triggered_buffer.h>
24 #include <linux/module.h>
25 #include <linux/mutex.h>
26 #include <linux/pm.h>
27
28 #define HZ_PER_KHZ 1000
29
30 #define AS73211_DRV_NAME "as73211"
31
32 /* AS73211 configuration registers */
33 #define AS73211_REG_OSR 0x0
34 #define AS73211_REG_AGEN 0x2
35 #define AS73211_REG_CREG1 0x6
36 #define AS73211_REG_CREG2 0x7
37 #define AS73211_REG_CREG3 0x8
38
39 /* AS73211 output register bank */
40 #define AS73211_OUT_OSR_STATUS 0
41 #define AS73211_OUT_TEMP 1
42 #define AS73211_OUT_MRES1 2
43 #define AS73211_OUT_MRES2 3
44 #define AS73211_OUT_MRES3 4
45
46 #define AS73211_OSR_SS BIT(7)
47 #define AS73211_OSR_PD BIT(6)
48 #define AS73211_OSR_SW_RES BIT(3)
49 #define AS73211_OSR_DOS_MASK GENMASK(2, 0)
50 #define AS73211_OSR_DOS_CONFIG FIELD_PREP(AS73211_OSR_DOS_MASK, 0x2)
51 #define AS73211_OSR_DOS_MEASURE FIELD_PREP(AS73211_OSR_DOS_MASK, 0x3)
52
53 #define AS73211_AGEN_DEVID_MASK GENMASK(7, 4)
54 #define AS73211_AGEN_DEVID(x) FIELD_PREP(AS73211_AGEN_DEVID_MASK, (x))
55 #define AS73211_AGEN_MUT_MASK GENMASK(3, 0)
56 #define AS73211_AGEN_MUT(x) FIELD_PREP(AS73211_AGEN_MUT_MASK, (x))
57
58 #define AS73211_CREG1_GAIN_MASK GENMASK(7, 4)
59 #define AS73211_CREG1_GAIN_1 11
60 #define AS73211_CREG1_TIME_MASK GENMASK(3, 0)
61
62 #define AS73211_CREG3_CCLK_MASK GENMASK(1, 0)
63
64 #define AS73211_OSR_STATUS_OUTCONVOF BIT(15)
65 #define AS73211_OSR_STATUS_MRESOF BIT(14)
66 #define AS73211_OSR_STATUS_ADCOF BIT(13)
67 #define AS73211_OSR_STATUS_LDATA BIT(12)
68 #define AS73211_OSR_STATUS_NDATA BIT(11)
69 #define AS73211_OSR_STATUS_NOTREADY BIT(10)
70
71 #define AS73211_SAMPLE_FREQ_BASE 1024000
72
73 #define AS73211_SAMPLE_TIME_NUM 15
74 #define AS73211_SAMPLE_TIME_MAX_MS BIT(AS73211_SAMPLE_TIME_NUM - 1)
75
76 /* Available sample frequencies are 1.024MHz multiplied by powers of two. */
77 static const int as73211_samp_freq_avail[] = {
78 AS73211_SAMPLE_FREQ_BASE * 1,
79 AS73211_SAMPLE_FREQ_BASE * 2,
80 AS73211_SAMPLE_FREQ_BASE * 4,
81 AS73211_SAMPLE_FREQ_BASE * 8,
82 };
83
84 static const int as73211_hardwaregain_avail[] = {
85 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048,
86 };
87
88 /**
89 * struct as73211_data - Instance data for one AS73211
90 * @client: I2C client.
91 * @osr: Cached Operational State Register.
92 * @creg1: Cached Configuration Register 1.
93 * @creg2: Cached Configuration Register 2.
94 * @creg3: Cached Configuration Register 3.
95 * @mutex: Keeps cached registers in sync with the device.
96 * @completion: Completion to wait for interrupt.
97 * @int_time_avail: Available integration times (depend on sampling frequency).
98 */
99 struct as73211_data {
100 struct i2c_client *client;
101 u8 osr;
102 u8 creg1;
103 u8 creg2;
104 u8 creg3;
105 struct mutex mutex;
106 struct completion completion;
107 int int_time_avail[AS73211_SAMPLE_TIME_NUM * 2];
108 };
109
110 #define AS73211_COLOR_CHANNEL(_color, _si, _addr) { \
111 .type = IIO_INTENSITY, \
112 .modified = 1, \
113 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \
114 .info_mask_shared_by_type = \
115 BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
116 BIT(IIO_CHAN_INFO_HARDWAREGAIN) | \
117 BIT(IIO_CHAN_INFO_INT_TIME), \
118 .info_mask_shared_by_type_available = \
119 BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
120 BIT(IIO_CHAN_INFO_HARDWAREGAIN) | \
121 BIT(IIO_CHAN_INFO_INT_TIME), \
122 .channel2 = IIO_MOD_##_color, \
123 .address = _addr, \
124 .scan_index = _si, \
125 .scan_type = { \
126 .sign = 'u', \
127 .realbits = 16, \
128 .storagebits = 16, \
129 .endianness = IIO_LE, \
130 }, \
131 }
132
133 #define AS73211_OFFSET_TEMP_INT (-66)
134 #define AS73211_OFFSET_TEMP_MICRO 900000
135 #define AS73211_SCALE_TEMP_INT 0
136 #define AS73211_SCALE_TEMP_MICRO 50000
137
138 #define AS73211_SCALE_X 277071108 /* nW/m^2 */
139 #define AS73211_SCALE_Y 298384270 /* nW/m^2 */
140 #define AS73211_SCALE_Z 160241927 /* nW/m^2 */
141
142 /* Channel order MUST match devices result register order */
143 #define AS73211_SCAN_INDEX_TEMP 0
144 #define AS73211_SCAN_INDEX_X 1
145 #define AS73211_SCAN_INDEX_Y 2
146 #define AS73211_SCAN_INDEX_Z 3
147 #define AS73211_SCAN_INDEX_TS 4
148
149 #define AS73211_SCAN_MASK_COLOR ( \
150 BIT(AS73211_SCAN_INDEX_X) | \
151 BIT(AS73211_SCAN_INDEX_Y) | \
152 BIT(AS73211_SCAN_INDEX_Z))
153
154 #define AS73211_SCAN_MASK_ALL ( \
155 BIT(AS73211_SCAN_INDEX_TEMP) | \
156 AS73211_SCAN_MASK_COLOR)
157
158 static const struct iio_chan_spec as73211_channels[] = {
159 {
160 .type = IIO_TEMP,
161 .info_mask_separate =
162 BIT(IIO_CHAN_INFO_RAW) |
163 BIT(IIO_CHAN_INFO_OFFSET) |
164 BIT(IIO_CHAN_INFO_SCALE),
165 .address = AS73211_OUT_TEMP,
166 .scan_index = AS73211_SCAN_INDEX_TEMP,
167 .scan_type = {
168 .sign = 'u',
169 .realbits = 16,
170 .storagebits = 16,
171 .endianness = IIO_LE,
172 }
173 },
174 AS73211_COLOR_CHANNEL(X, AS73211_SCAN_INDEX_X, AS73211_OUT_MRES1),
175 AS73211_COLOR_CHANNEL(Y, AS73211_SCAN_INDEX_Y, AS73211_OUT_MRES2),
176 AS73211_COLOR_CHANNEL(Z, AS73211_SCAN_INDEX_Z, AS73211_OUT_MRES3),
177 IIO_CHAN_SOFT_TIMESTAMP(AS73211_SCAN_INDEX_TS),
178 };
179
180 static unsigned int as73211_integration_time_1024cyc(struct as73211_data *data)
181 {
182 /*
183 * Return integration time in units of 1024 clock cycles. Integration time
184 * in CREG1 is in powers of 2 (x 1024 cycles).
185 */
186 return BIT(FIELD_GET(AS73211_CREG1_TIME_MASK, data->creg1));
187 }
188
189 static unsigned int as73211_integration_time_us(struct as73211_data *data,
190 unsigned int integration_time_1024cyc)
191 {
192 /*
193 * f_samp is configured in CREG3 in powers of 2 (x 1.024 MHz)
194 * t_cycl is configured in CREG1 in powers of 2 (x 1024 cycles)
195 * t_int_us = 1 / (f_samp) * t_cycl * US_PER_SEC
196 * = 1 / (2^CREG3_CCLK * 1,024,000) * 2^CREG1_CYCLES * 1,024 * US_PER_SEC
197 * = 2^(-CREG3_CCLK) * 2^CREG1_CYCLES * 1,000
198 * In order to get rid of negative exponents, we extend the "fraction"
199 * by 2^3 (CREG3_CCLK,max = 3)
200 * t_int_us = 2^(3-CREG3_CCLK) * 2^CREG1_CYCLES * 125
201 */
202 return BIT(3 - FIELD_GET(AS73211_CREG3_CCLK_MASK, data->creg3)) *
203 integration_time_1024cyc * 125;
204 }
205
206 static void as73211_integration_time_calc_avail(struct as73211_data *data)
207 {
208 int i;
209
210 for (i = 0; i < ARRAY_SIZE(data->int_time_avail) / 2; i++) {
211 unsigned int time_us = as73211_integration_time_us(data, BIT(i));
212
213 data->int_time_avail[i * 2 + 0] = time_us / USEC_PER_SEC;
214 data->int_time_avail[i * 2 + 1] = time_us % USEC_PER_SEC;
215 }
216 }
217
218 static unsigned int as73211_gain(struct as73211_data *data)
219 {
220 /* gain can be calculated from CREG1 as 2^(11 - CREG1_GAIN) */
221 return BIT(AS73211_CREG1_GAIN_1 - FIELD_GET(AS73211_CREG1_GAIN_MASK, data->creg1));
222 }
223
224 /* must be called with as73211_data::mutex held. */
225 static int as73211_req_data(struct as73211_data *data)
226 {
227 unsigned int time_us = as73211_integration_time_us(data,
228 as73211_integration_time_1024cyc(data));
229 struct device *dev = &data->client->dev;
230 union i2c_smbus_data smbus_data;
231 u16 osr_status;
232 int ret;
233
234 if (data->client->irq)
235 reinit_completion(&data->completion);
236
237 /*
238 * During measurement, there should be no traffic on the i2c bus as the
239 * electrical noise would disturb the measurement process.
240 */
241 i2c_lock_bus(data->client->adapter, I2C_LOCK_SEGMENT);
242
243 data->osr &= ~AS73211_OSR_DOS_MASK;
244 data->osr |= AS73211_OSR_DOS_MEASURE | AS73211_OSR_SS;
245
246 smbus_data.byte = data->osr;
247 ret = __i2c_smbus_xfer(data->client->adapter, data->client->addr,
248 data->client->flags, I2C_SMBUS_WRITE,
249 AS73211_REG_OSR, I2C_SMBUS_BYTE_DATA, &smbus_data);
250 if (ret < 0) {
251 i2c_unlock_bus(data->client->adapter, I2C_LOCK_SEGMENT);
252 return ret;
253 }
254
255 /*
256 * Reset AS73211_OSR_SS (is self clearing) in order to avoid unintentional
257 * triggering of further measurements later.
258 */
259 data->osr &= ~AS73211_OSR_SS;
260
261 /*
262 * Add 33% extra margin for the timeout. fclk,min = fclk,typ - 27%.
263 */
264 time_us += time_us / 3;
265 if (data->client->irq) {
266 ret = wait_for_completion_timeout(&data->completion, usecs_to_jiffies(time_us));
267 if (!ret) {
268 dev_err(dev, "timeout waiting for READY IRQ\n");
269 i2c_unlock_bus(data->client->adapter, I2C_LOCK_SEGMENT);
270 return -ETIMEDOUT;
271 }
272 } else {
273 /* Wait integration time */
274 usleep_range(time_us, 2 * time_us);
275 }
276
277 i2c_unlock_bus(data->client->adapter, I2C_LOCK_SEGMENT);
278
279 ret = i2c_smbus_read_word_data(data->client, AS73211_OUT_OSR_STATUS);
280 if (ret < 0)
281 return ret;
282
283 osr_status = ret;
284 if (osr_status != (AS73211_OSR_DOS_MEASURE | AS73211_OSR_STATUS_NDATA)) {
285 if (osr_status & AS73211_OSR_SS) {
286 dev_err(dev, "%s() Measurement has not stopped\n", __func__);
287 return -ETIME;
288 }
289 if (osr_status & AS73211_OSR_STATUS_NOTREADY) {
290 dev_err(dev, "%s() Data is not ready\n", __func__);
291 return -ENODATA;
292 }
293 if (!(osr_status & AS73211_OSR_STATUS_NDATA)) {
294 dev_err(dev, "%s() No new data available\n", __func__);
295 return -ENODATA;
296 }
297 if (osr_status & AS73211_OSR_STATUS_LDATA) {
298 dev_err(dev, "%s() Result buffer overrun\n", __func__);
299 return -ENOBUFS;
300 }
301 if (osr_status & AS73211_OSR_STATUS_ADCOF) {
302 dev_err(dev, "%s() ADC overflow\n", __func__);
303 return -EOVERFLOW;
304 }
305 if (osr_status & AS73211_OSR_STATUS_MRESOF) {
306 dev_err(dev, "%s() Measurement result overflow\n", __func__);
307 return -EOVERFLOW;
308 }
309 if (osr_status & AS73211_OSR_STATUS_OUTCONVOF) {
310 dev_err(dev, "%s() Timer overflow\n", __func__);
311 return -EOVERFLOW;
312 }
313 dev_err(dev, "%s() Unexpected status value\n", __func__);
314 return -EIO;
315 }
316
317 return 0;
318 }
319
320 static int as73211_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
321 int *val, int *val2, long mask)
322 {
323 struct as73211_data *data = iio_priv(indio_dev);
324
325 switch (mask) {
326 case IIO_CHAN_INFO_RAW: {
327 int ret;
328
329 ret = iio_device_claim_direct_mode(indio_dev);
330 if (ret < 0)
331 return ret;
332
333 ret = as73211_req_data(data);
334 if (ret < 0) {
335 iio_device_release_direct_mode(indio_dev);
336 return ret;
337 }
338
339 ret = i2c_smbus_read_word_data(data->client, chan->address);
340 iio_device_release_direct_mode(indio_dev);
341 if (ret < 0)
342 return ret;
343
344 *val = ret;
345 return IIO_VAL_INT;
346 }
347 case IIO_CHAN_INFO_OFFSET:
348 *val = AS73211_OFFSET_TEMP_INT;
349 *val2 = AS73211_OFFSET_TEMP_MICRO;
350 return IIO_VAL_INT_PLUS_MICRO;
351
352 case IIO_CHAN_INFO_SCALE:
353 switch (chan->type) {
354 case IIO_TEMP:
355 *val = AS73211_SCALE_TEMP_INT;
356 *val2 = AS73211_SCALE_TEMP_MICRO;
357 return IIO_VAL_INT_PLUS_MICRO;
358
359 case IIO_INTENSITY: {
360 unsigned int scale;
361
362 switch (chan->channel2) {
363 case IIO_MOD_X:
364 scale = AS73211_SCALE_X;
365 break;
366 case IIO_MOD_Y:
367 scale = AS73211_SCALE_Y;
368 break;
369 case IIO_MOD_Z:
370 scale = AS73211_SCALE_Z;
371 break;
372 default:
373 return -EINVAL;
374 }
375 scale /= as73211_gain(data);
376 scale /= as73211_integration_time_1024cyc(data);
377 *val = scale;
378 return IIO_VAL_INT;
379
380 default:
381 return -EINVAL;
382 }}
383
384 case IIO_CHAN_INFO_SAMP_FREQ:
385 /* f_samp is configured in CREG3 in powers of 2 (x 1.024 MHz) */
386 *val = BIT(FIELD_GET(AS73211_CREG3_CCLK_MASK, data->creg3)) *
387 AS73211_SAMPLE_FREQ_BASE;
388 return IIO_VAL_INT;
389
390 case IIO_CHAN_INFO_HARDWAREGAIN:
391 *val = as73211_gain(data);
392 return IIO_VAL_INT;
393
394 case IIO_CHAN_INFO_INT_TIME: {
395 unsigned int time_us;
396
397 mutex_lock(&data->mutex);
398 time_us = as73211_integration_time_us(data, as73211_integration_time_1024cyc(data));
399 mutex_unlock(&data->mutex);
400 *val = time_us / USEC_PER_SEC;
401 *val2 = time_us % USEC_PER_SEC;
402 return IIO_VAL_INT_PLUS_MICRO;
403
404 default:
405 return -EINVAL;
406 }}
407 }
408
409 static int as73211_read_avail(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
410 const int **vals, int *type, int *length, long mask)
411 {
412 struct as73211_data *data = iio_priv(indio_dev);
413
414 switch (mask) {
415 case IIO_CHAN_INFO_SAMP_FREQ:
416 *length = ARRAY_SIZE(as73211_samp_freq_avail);
417 *vals = as73211_samp_freq_avail;
418 *type = IIO_VAL_INT;
419 return IIO_AVAIL_LIST;
420
421 case IIO_CHAN_INFO_HARDWAREGAIN:
422 *length = ARRAY_SIZE(as73211_hardwaregain_avail);
423 *vals = as73211_hardwaregain_avail;
424 *type = IIO_VAL_INT;
425 return IIO_AVAIL_LIST;
426
427 case IIO_CHAN_INFO_INT_TIME:
428 *length = ARRAY_SIZE(data->int_time_avail);
429 *vals = data->int_time_avail;
430 *type = IIO_VAL_INT_PLUS_MICRO;
431 return IIO_AVAIL_LIST;
432
433 default:
434 return -EINVAL;
435 }
436 }
437
438 static int _as73211_write_raw(struct iio_dev *indio_dev,
439 struct iio_chan_spec const *chan __always_unused,
440 int val, int val2, long mask)
441 {
442 struct as73211_data *data = iio_priv(indio_dev);
443 int ret;
444
445 switch (mask) {
446 case IIO_CHAN_INFO_SAMP_FREQ: {
447 int reg_bits, freq_kHz = val / HZ_PER_KHZ; /* 1024, 2048, ... */
448
449 /* val must be 1024 * 2^x */
450 if (val < 0 || (freq_kHz * HZ_PER_KHZ) != val ||
451 !is_power_of_2(freq_kHz) || val2)
452 return -EINVAL;
453
454 /* f_samp is configured in CREG3 in powers of 2 (x 1.024 MHz (=2^10)) */
455 reg_bits = ilog2(freq_kHz) - 10;
456 if (!FIELD_FIT(AS73211_CREG3_CCLK_MASK, reg_bits))
457 return -EINVAL;
458
459 data->creg3 &= ~AS73211_CREG3_CCLK_MASK;
460 data->creg3 |= FIELD_PREP(AS73211_CREG3_CCLK_MASK, reg_bits);
461 as73211_integration_time_calc_avail(data);
462
463 ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_CREG3, data->creg3);
464 if (ret < 0)
465 return ret;
466
467 return 0;
468 }
469 case IIO_CHAN_INFO_HARDWAREGAIN: {
470 unsigned int reg_bits;
471
472 if (val < 0 || !is_power_of_2(val) || val2)
473 return -EINVAL;
474
475 /* gain can be calculated from CREG1 as 2^(11 - CREG1_GAIN) */
476 reg_bits = AS73211_CREG1_GAIN_1 - ilog2(val);
477 if (!FIELD_FIT(AS73211_CREG1_GAIN_MASK, reg_bits))
478 return -EINVAL;
479
480 data->creg1 &= ~AS73211_CREG1_GAIN_MASK;
481 data->creg1 |= FIELD_PREP(AS73211_CREG1_GAIN_MASK, reg_bits);
482
483 ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_CREG1, data->creg1);
484 if (ret < 0)
485 return ret;
486
487 return 0;
488 }
489 case IIO_CHAN_INFO_INT_TIME: {
490 int val_us = val * USEC_PER_SEC + val2;
491 int time_ms;
492 int reg_bits;
493
494 /* f_samp is configured in CREG3 in powers of 2 (x 1.024 MHz) */
495 int f_samp_1_024mhz = BIT(FIELD_GET(AS73211_CREG3_CCLK_MASK, data->creg3));
496
497 /*
498 * time_ms = time_us * US_PER_MS * f_samp_1_024mhz / MHZ_PER_HZ
499 * = time_us * f_samp_1_024mhz / 1000
500 */
501 time_ms = (val_us * f_samp_1_024mhz) / 1000; /* 1 ms, 2 ms, ... (power of two) */
502 if (time_ms < 0 || !is_power_of_2(time_ms) || time_ms > AS73211_SAMPLE_TIME_MAX_MS)
503 return -EINVAL;
504
505 reg_bits = ilog2(time_ms);
506 if (!FIELD_FIT(AS73211_CREG1_TIME_MASK, reg_bits))
507 return -EINVAL; /* not possible due to previous tests */
508
509 data->creg1 &= ~AS73211_CREG1_TIME_MASK;
510 data->creg1 |= FIELD_PREP(AS73211_CREG1_TIME_MASK, reg_bits);
511
512 ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_CREG1, data->creg1);
513 if (ret < 0)
514 return ret;
515
516 return 0;
517
518 default:
519 return -EINVAL;
520 }}
521 }
522
523 static int as73211_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
524 int val, int val2, long mask)
525 {
526 struct as73211_data *data = iio_priv(indio_dev);
527 int ret;
528
529 mutex_lock(&data->mutex);
530
531 ret = iio_device_claim_direct_mode(indio_dev);
532 if (ret < 0)
533 goto error_unlock;
534
535 /* Need to switch to config mode ... */
536 if ((data->osr & AS73211_OSR_DOS_MASK) != AS73211_OSR_DOS_CONFIG) {
537 data->osr &= ~AS73211_OSR_DOS_MASK;
538 data->osr |= AS73211_OSR_DOS_CONFIG;
539
540 ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_OSR, data->osr);
541 if (ret < 0)
542 goto error_release;
543 }
544
545 ret = _as73211_write_raw(indio_dev, chan, val, val2, mask);
546
547 error_release:
548 iio_device_release_direct_mode(indio_dev);
549 error_unlock:
550 mutex_unlock(&data->mutex);
551 return ret;
552 }
553
554 static irqreturn_t as73211_ready_handler(int irq __always_unused, void *priv)
555 {
556 struct as73211_data *data = iio_priv(priv);
557
558 complete(&data->completion);
559
560 return IRQ_HANDLED;
561 }
562
563 static irqreturn_t as73211_trigger_handler(int irq __always_unused, void *p)
564 {
565 struct iio_poll_func *pf = p;
566 struct iio_dev *indio_dev = pf->indio_dev;
567 struct as73211_data *data = iio_priv(indio_dev);
568 struct {
569 __le16 chan[4];
570 s64 ts __aligned(8);
571 } scan;
572 int data_result, ret;
573
574 mutex_lock(&data->mutex);
575
576 data_result = as73211_req_data(data);
577 if (data_result < 0 && data_result != -EOVERFLOW)
578 goto done; /* don't push any data for errors other than EOVERFLOW */
579
580 if (*indio_dev->active_scan_mask == AS73211_SCAN_MASK_ALL) {
581 /* Optimization for reading all (color + temperature) channels */
582 u8 addr = as73211_channels[0].address;
583 struct i2c_msg msgs[] = {
584 {
585 .addr = data->client->addr,
586 .flags = 0,
587 .len = 1,
588 .buf = &addr,
589 },
590 {
591 .addr = data->client->addr,
592 .flags = I2C_M_RD,
593 .len = sizeof(scan.chan),
594 .buf = (u8 *)&scan.chan,
595 },
596 };
597
598 ret = i2c_transfer(data->client->adapter, msgs, ARRAY_SIZE(msgs));
599 if (ret < 0)
600 goto done;
601 } else {
602 /* Optimization for reading only color channels */
603
604 /* AS73211 starts reading at address 2 */
605 ret = i2c_master_recv(data->client,
606 (char *)&scan.chan[1], 3 * sizeof(scan.chan[1]));
607 if (ret < 0)
608 goto done;
609 }
610
611 if (data_result) {
612 /*
613 * Saturate all channels (in case of overflows). Temperature channel
614 * is not affected by overflows.
615 */
616 scan.chan[1] = cpu_to_le16(U16_MAX);
617 scan.chan[2] = cpu_to_le16(U16_MAX);
618 scan.chan[3] = cpu_to_le16(U16_MAX);
619 }
620
621 iio_push_to_buffers_with_timestamp(indio_dev, &scan, iio_get_time_ns(indio_dev));
622
623 done:
624 mutex_unlock(&data->mutex);
625 iio_trigger_notify_done(indio_dev->trig);
626
627 return IRQ_HANDLED;
628 }
629
630 static const struct iio_info as73211_info = {
631 .read_raw = as73211_read_raw,
632 .read_avail = as73211_read_avail,
633 .write_raw = as73211_write_raw,
634 };
635
636 static int as73211_power(struct iio_dev *indio_dev, bool state)
637 {
638 struct as73211_data *data = iio_priv(indio_dev);
639 int ret;
640
641 mutex_lock(&data->mutex);
642
643 if (state)
644 data->osr &= ~AS73211_OSR_PD;
645 else
646 data->osr |= AS73211_OSR_PD;
647
648 ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_OSR, data->osr);
649
650 mutex_unlock(&data->mutex);
651
652 if (ret < 0)
653 return ret;
654
655 return 0;
656 }
657
658 static void as73211_power_disable(void *data)
659 {
660 struct iio_dev *indio_dev = data;
661
662 as73211_power(indio_dev, false);
663 }
664
665 static int as73211_probe(struct i2c_client *client)
666 {
667 struct device *dev = &client->dev;
668 struct as73211_data *data;
669 struct iio_dev *indio_dev;
670 int ret;
671
672 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
673 if (!indio_dev)
674 return -ENOMEM;
675
676 data = iio_priv(indio_dev);
677 i2c_set_clientdata(client, indio_dev);
678 data->client = client;
679
680 mutex_init(&data->mutex);
681 init_completion(&data->completion);
682
683 indio_dev->info = &as73211_info;
684 indio_dev->name = AS73211_DRV_NAME;
685 indio_dev->channels = as73211_channels;
686 indio_dev->num_channels = ARRAY_SIZE(as73211_channels);
687 indio_dev->modes = INDIO_DIRECT_MODE;
688
689 ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_OSR);
690 if (ret < 0)
691 return ret;
692 data->osr = ret;
693
694 /* reset device */
695 data->osr |= AS73211_OSR_SW_RES;
696 ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_OSR, data->osr);
697 if (ret < 0)
698 return ret;
699
700 ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_OSR);
701 if (ret < 0)
702 return ret;
703 data->osr = ret;
704
705 /*
706 * Reading AGEN is only possible after reset (AGEN is not available if
707 * device is in measurement mode).
708 */
709 ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_AGEN);
710 if (ret < 0)
711 return ret;
712
713 /* At the time of writing this driver, only DEVID 2 and MUT 1 are known. */
714 if ((ret & AS73211_AGEN_DEVID_MASK) != AS73211_AGEN_DEVID(2) ||
715 (ret & AS73211_AGEN_MUT_MASK) != AS73211_AGEN_MUT(1))
716 return -ENODEV;
717
718 ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_CREG1);
719 if (ret < 0)
720 return ret;
721 data->creg1 = ret;
722
723 ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_CREG2);
724 if (ret < 0)
725 return ret;
726 data->creg2 = ret;
727
728 ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_CREG3);
729 if (ret < 0)
730 return ret;
731 data->creg3 = ret;
732 as73211_integration_time_calc_avail(data);
733
734 ret = as73211_power(indio_dev, true);
735 if (ret < 0)
736 return ret;
737
738 ret = devm_add_action_or_reset(dev, as73211_power_disable, indio_dev);
739 if (ret)
740 return ret;
741
742 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL, as73211_trigger_handler, NULL);
743 if (ret)
744 return ret;
745
746 if (client->irq) {
747 ret = devm_request_threaded_irq(&client->dev, client->irq,
748 NULL,
749 as73211_ready_handler,
750 IRQF_ONESHOT,
751 client->name, indio_dev);
752 if (ret)
753 return ret;
754 }
755
756 return devm_iio_device_register(dev, indio_dev);
757 }
758
759 static int __maybe_unused as73211_suspend(struct device *dev)
760 {
761 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
762
763 return as73211_power(indio_dev, false);
764 }
765
766 static int __maybe_unused as73211_resume(struct device *dev)
767 {
768 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
769
770 return as73211_power(indio_dev, true);
771 }
772
773 static SIMPLE_DEV_PM_OPS(as73211_pm_ops, as73211_suspend, as73211_resume);
774
775 static const struct of_device_id as73211_of_match[] = {
776 { .compatible = "ams,as73211" },
777 { }
778 };
779 MODULE_DEVICE_TABLE(of, as73211_of_match);
780
781 static const struct i2c_device_id as73211_id[] = {
782 { "as73211", 0 },
783 { }
784 };
785 MODULE_DEVICE_TABLE(i2c, as73211_id);
786
787 static struct i2c_driver as73211_driver = {
788 .driver = {
789 .name = AS73211_DRV_NAME,
790 .of_match_table = as73211_of_match,
791 .pm = &as73211_pm_ops,
792 },
793 .probe_new = as73211_probe,
794 .id_table = as73211_id,
795 };
796 module_i2c_driver(as73211_driver);
797
798 MODULE_AUTHOR("Christian Eggers <ceggers@arri.de>");
799 MODULE_DESCRIPTION("AS73211 XYZ True Color Sensor driver");
800 MODULE_LICENSE("GPL");
Linux with added FPC-III support