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