1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * si1145.c - Support for Silabs SI1132 and SI1141/2/3/5/6/7 combined ambient
4 * light, UV index and proximity sensors
5 *
6 * Copyright 2014-16 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
7 * Copyright 2016 Crestez Dan Leonard <leonard.crestez@intel.com>
8 *
9 * SI1132 (7-bit I2C slave address 0x60)
10 * SI1141/2/3 (7-bit I2C slave address 0x5a)
11 * SI1145/6/6 (7-bit I2C slave address 0x60)
12 */
13
14#include <linux/module.h>
15#include <linux/i2c.h>
16#include <linux/err.h>
17#include <linux/slab.h>
18#include <linux/delay.h>
19#include <linux/irq.h>
20
21#include <linux/iio/iio.h>
22#include <linux/iio/sysfs.h>
23#include <linux/iio/trigger.h>
24#include <linux/iio/trigger_consumer.h>
25#include <linux/iio/triggered_buffer.h>
26#include <linux/iio/buffer.h>
27#include <linux/util_macros.h>
28
29#define SI1145_REG_PART_ID 0x00
30#define SI1145_REG_REV_ID 0x01
31#define SI1145_REG_SEQ_ID 0x02
32#define SI1145_REG_INT_CFG 0x03
33#define SI1145_REG_IRQ_ENABLE 0x04
34#define SI1145_REG_IRQ_MODE 0x05
35#define SI1145_REG_HW_KEY 0x07
36#define SI1145_REG_MEAS_RATE 0x08
37#define SI1145_REG_PS_LED21 0x0f
38#define SI1145_REG_PS_LED3 0x10
39#define SI1145_REG_UCOEF1 0x13
40#define SI1145_REG_UCOEF2 0x14
41#define SI1145_REG_UCOEF3 0x15
42#define SI1145_REG_UCOEF4 0x16
43#define SI1145_REG_PARAM_WR 0x17
44#define SI1145_REG_COMMAND 0x18
45#define SI1145_REG_RESPONSE 0x20
46#define SI1145_REG_IRQ_STATUS 0x21
47#define SI1145_REG_ALSVIS_DATA 0x22
48#define SI1145_REG_ALSIR_DATA 0x24
49#define SI1145_REG_PS1_DATA 0x26
50#define SI1145_REG_PS2_DATA 0x28
51#define SI1145_REG_PS3_DATA 0x2a
52#define SI1145_REG_AUX_DATA 0x2c
53#define SI1145_REG_PARAM_RD 0x2e
54#define SI1145_REG_CHIP_STAT 0x30
55
56#define SI1145_UCOEF1_DEFAULT 0x7b
57#define SI1145_UCOEF2_DEFAULT 0x6b
58#define SI1145_UCOEF3_DEFAULT 0x01
59#define SI1145_UCOEF4_DEFAULT 0x00
60
61/* Helper to figure out PS_LED register / shift per channel */
62#define SI1145_PS_LED_REG(ch) \
63 (((ch) == 2) ? SI1145_REG_PS_LED3 : SI1145_REG_PS_LED21)
64#define SI1145_PS_LED_SHIFT(ch) \
65 (((ch) == 1) ? 4 : 0)
66
67/* Parameter offsets */
68#define SI1145_PARAM_CHLIST 0x01
69#define SI1145_PARAM_PSLED12_SELECT 0x02
70#define SI1145_PARAM_PSLED3_SELECT 0x03
71#define SI1145_PARAM_PS_ENCODING 0x05
72#define SI1145_PARAM_ALS_ENCODING 0x06
73#define SI1145_PARAM_PS1_ADC_MUX 0x07
74#define SI1145_PARAM_PS2_ADC_MUX 0x08
75#define SI1145_PARAM_PS3_ADC_MUX 0x09
76#define SI1145_PARAM_PS_ADC_COUNTER 0x0a
77#define SI1145_PARAM_PS_ADC_GAIN 0x0b
78#define SI1145_PARAM_PS_ADC_MISC 0x0c
79#define SI1145_PARAM_ALS_ADC_MUX 0x0d
80#define SI1145_PARAM_ALSIR_ADC_MUX 0x0e
81#define SI1145_PARAM_AUX_ADC_MUX 0x0f
82#define SI1145_PARAM_ALSVIS_ADC_COUNTER 0x10
83#define SI1145_PARAM_ALSVIS_ADC_GAIN 0x11
84#define SI1145_PARAM_ALSVIS_ADC_MISC 0x12
85#define SI1145_PARAM_LED_RECOVERY 0x1c
86#define SI1145_PARAM_ALSIR_ADC_COUNTER 0x1d
87#define SI1145_PARAM_ALSIR_ADC_GAIN 0x1e
88#define SI1145_PARAM_ALSIR_ADC_MISC 0x1f
89#define SI1145_PARAM_ADC_OFFSET 0x1a
90
91/* Channel enable masks for CHLIST parameter */
92#define SI1145_CHLIST_EN_PS1 BIT(0)
93#define SI1145_CHLIST_EN_PS2 BIT(1)
94#define SI1145_CHLIST_EN_PS3 BIT(2)
95#define SI1145_CHLIST_EN_ALSVIS BIT(4)
96#define SI1145_CHLIST_EN_ALSIR BIT(5)
97#define SI1145_CHLIST_EN_AUX BIT(6)
98#define SI1145_CHLIST_EN_UV BIT(7)
99
100/* Proximity measurement mode for ADC_MISC parameter */
101#define SI1145_PS_ADC_MODE_NORMAL BIT(2)
102/* Signal range mask for ADC_MISC parameter */
103#define SI1145_ADC_MISC_RANGE BIT(5)
104
105/* Commands for REG_COMMAND */
106#define SI1145_CMD_NOP 0x00
107#define SI1145_CMD_RESET 0x01
108#define SI1145_CMD_PS_FORCE 0x05
109#define SI1145_CMD_ALS_FORCE 0x06
110#define SI1145_CMD_PSALS_FORCE 0x07
111#define SI1145_CMD_PS_PAUSE 0x09
112#define SI1145_CMD_ALS_PAUSE 0x0a
113#define SI1145_CMD_PSALS_PAUSE 0x0b
114#define SI1145_CMD_PS_AUTO 0x0d
115#define SI1145_CMD_ALS_AUTO 0x0e
116#define SI1145_CMD_PSALS_AUTO 0x0f
117#define SI1145_CMD_PARAM_QUERY 0x80
118#define SI1145_CMD_PARAM_SET 0xa0
119
120#define SI1145_RSP_INVALID_SETTING 0x80
121#define SI1145_RSP_COUNTER_MASK 0x0F
122
123/* Minimum sleep after each command to ensure it's received */
124#define SI1145_COMMAND_MINSLEEP_MS 5
125/* Return -ETIMEDOUT after this long */
126#define SI1145_COMMAND_TIMEOUT_MS 25
127
128/* Interrupt configuration masks for INT_CFG register */
129#define SI1145_INT_CFG_OE BIT(0) /* enable interrupt */
130#define SI1145_INT_CFG_MODE BIT(1) /* auto reset interrupt pin */
131
132/* Interrupt enable masks for IRQ_ENABLE register */
133#define SI1145_MASK_ALL_IE (BIT(4) | BIT(3) | BIT(2) | BIT(0))
134
135#define SI1145_MUX_TEMP 0x65
136#define SI1145_MUX_VDD 0x75
137
138/* Proximity LED current; see Table 2 in datasheet */
139#define SI1145_LED_CURRENT_45mA 0x04
140
141enum {
142 SI1132,
143 SI1141,
144 SI1142,
145 SI1143,
146 SI1145,
147 SI1146,
148 SI1147,
149};
150
151struct si1145_part_info {
152 u8 part;
153 const struct iio_info *iio_info;
154 const struct iio_chan_spec *channels;
155 unsigned int num_channels;
156 unsigned int num_leds;
157 bool uncompressed_meas_rate;
158};
159
160/**
161 * struct si1145_data - si1145 chip state data
162 * @client: I2C client
163 * @lock: mutex to protect shared state.
164 * @cmdlock: Low-level mutex to protect command execution only
165 * @rsp_seq: Next expected response number or -1 if counter reset required
166 * @scan_mask: Saved scan mask to avoid duplicate set_chlist
167 * @autonomous: If automatic measurements are active (for buffer support)
168 * @part_info: Part information
169 * @trig: Pointer to iio trigger
170 * @meas_rate: Value of MEAS_RATE register. Only set in HW in auto mode
171 * @buffer: Used to pack data read from sensor.
172 */
173struct si1145_data {
174 struct i2c_client *client;
175 struct mutex lock;
176 struct mutex cmdlock;
177 int rsp_seq;
178 const struct si1145_part_info *part_info;
179 unsigned long scan_mask;
180 bool autonomous;
181 struct iio_trigger *trig;
182 int meas_rate;
183 /*
184 * Ensure timestamp will be naturally aligned if present.
185 * Maximum buffer size (may be only partly used if not all
186 * channels are enabled):
187 * 6*2 bytes channels data + 4 bytes alignment +
188 * 8 bytes timestamp
189 */
190 u8 buffer[24] __aligned(8);
191};
192
193/*
194 * __si1145_command_reset() - Send CMD_NOP and wait for response 0
195 *
196 * Does not modify data->rsp_seq
197 *
198 * Return: 0 on success and -errno on error.
199 */
200static int __si1145_command_reset(struct si1145_data *data)
201{
202 struct device *dev = &data->client->dev;
203 unsigned long stop_jiffies;
204 int ret;
205
206 ret = i2c_smbus_write_byte_data(client: data->client, SI1145_REG_COMMAND,
207 SI1145_CMD_NOP);
208 if (ret < 0)
209 return ret;
210 msleep(SI1145_COMMAND_MINSLEEP_MS);
211
212 stop_jiffies = jiffies + SI1145_COMMAND_TIMEOUT_MS * HZ / 1000;
213 while (true) {
214 ret = i2c_smbus_read_byte_data(client: data->client,
215 SI1145_REG_RESPONSE);
216 if (ret <= 0)
217 return ret;
218 if (time_after(jiffies, stop_jiffies)) {
219 dev_warn(dev, "timeout on reset\n");
220 return -ETIMEDOUT;
221 }
222 msleep(SI1145_COMMAND_MINSLEEP_MS);
223 }
224}
225
226/*
227 * si1145_command() - Execute a command and poll the response register
228 *
229 * All conversion overflows are reported as -EOVERFLOW
230 * INVALID_SETTING is reported as -EINVAL
231 * Timeouts are reported as -ETIMEDOUT
232 *
233 * Return: 0 on success or -errno on failure
234 */
235static int si1145_command(struct si1145_data *data, u8 cmd)
236{
237 struct device *dev = &data->client->dev;
238 unsigned long stop_jiffies;
239 int ret;
240
241 mutex_lock(&data->cmdlock);
242
243 if (data->rsp_seq < 0) {
244 ret = __si1145_command_reset(data);
245 if (ret < 0) {
246 dev_err(dev, "failed to reset command counter, ret=%d\n",
247 ret);
248 goto out;
249 }
250 data->rsp_seq = 0;
251 }
252
253 ret = i2c_smbus_write_byte_data(client: data->client, SI1145_REG_COMMAND, value: cmd);
254 if (ret) {
255 dev_warn(dev, "failed to write command, ret=%d\n", ret);
256 goto out;
257 }
258 /* Sleep a little to ensure the command is received */
259 msleep(SI1145_COMMAND_MINSLEEP_MS);
260
261 stop_jiffies = jiffies + SI1145_COMMAND_TIMEOUT_MS * HZ / 1000;
262 while (true) {
263 ret = i2c_smbus_read_byte_data(client: data->client,
264 SI1145_REG_RESPONSE);
265 if (ret < 0) {
266 dev_warn(dev, "failed to read response, ret=%d\n", ret);
267 break;
268 }
269
270 if ((ret & ~SI1145_RSP_COUNTER_MASK) == 0) {
271 if (ret == data->rsp_seq) {
272 if (time_after(jiffies, stop_jiffies)) {
273 dev_warn(dev, "timeout on command 0x%02x\n",
274 cmd);
275 ret = -ETIMEDOUT;
276 break;
277 }
278 msleep(SI1145_COMMAND_MINSLEEP_MS);
279 continue;
280 }
281 if (ret == ((data->rsp_seq + 1) &
282 SI1145_RSP_COUNTER_MASK)) {
283 data->rsp_seq = ret;
284 ret = 0;
285 break;
286 }
287 dev_warn(dev, "unexpected response counter %d instead of %d\n",
288 ret, (data->rsp_seq + 1) &
289 SI1145_RSP_COUNTER_MASK);
290 ret = -EIO;
291 } else {
292 if (ret == SI1145_RSP_INVALID_SETTING) {
293 dev_warn(dev, "INVALID_SETTING error on command 0x%02x\n",
294 cmd);
295 ret = -EINVAL;
296 } else {
297 /* All overflows are treated identically */
298 dev_dbg(dev, "overflow, ret=%d, cmd=0x%02x\n",
299 ret, cmd);
300 ret = -EOVERFLOW;
301 }
302 }
303
304 /* Force a counter reset next time */
305 data->rsp_seq = -1;
306 break;
307 }
308
309out:
310 mutex_unlock(lock: &data->cmdlock);
311
312 return ret;
313}
314
315static int si1145_param_update(struct si1145_data *data, u8 op, u8 param,
316 u8 value)
317{
318 int ret;
319
320 ret = i2c_smbus_write_byte_data(client: data->client,
321 SI1145_REG_PARAM_WR, value);
322 if (ret < 0)
323 return ret;
324
325 return si1145_command(data, cmd: op | (param & 0x1F));
326}
327
328static int si1145_param_set(struct si1145_data *data, u8 param, u8 value)
329{
330 return si1145_param_update(data, SI1145_CMD_PARAM_SET, param, value);
331}
332
333/* Set param. Returns negative errno or current value */
334static int si1145_param_query(struct si1145_data *data, u8 param)
335{
336 int ret;
337
338 ret = si1145_command(data, SI1145_CMD_PARAM_QUERY | (param & 0x1F));
339 if (ret < 0)
340 return ret;
341
342 return i2c_smbus_read_byte_data(client: data->client, SI1145_REG_PARAM_RD);
343}
344
345/* Expand 8 bit compressed value to 16 bit, see Silabs AN498 */
346static u16 si1145_uncompress(u8 x)
347{
348 u16 result = 0;
349 u8 exponent = 0;
350
351 if (x < 8)
352 return 0;
353
354 exponent = (x & 0xf0) >> 4;
355 result = 0x10 | (x & 0x0f);
356
357 if (exponent >= 4)
358 return result << (exponent - 4);
359 return result >> (4 - exponent);
360}
361
362/* Compress 16 bit value to 8 bit, see Silabs AN498 */
363static u8 si1145_compress(u16 x)
364{
365 u32 exponent = 0;
366 u32 significand = 0;
367 u32 tmp = x;
368
369 if (x == 0x0000)
370 return 0x00;
371 if (x == 0x0001)
372 return 0x08;
373
374 while (1) {
375 tmp >>= 1;
376 exponent += 1;
377 if (tmp == 1)
378 break;
379 }
380
381 if (exponent < 5) {
382 significand = x << (4 - exponent);
383 return (exponent << 4) | (significand & 0xF);
384 }
385
386 significand = x >> (exponent - 5);
387 if (significand & 1) {
388 significand += 2;
389 if (significand & 0x0040) {
390 exponent += 1;
391 significand >>= 1;
392 }
393 }
394
395 return (exponent << 4) | ((significand >> 1) & 0xF);
396}
397
398/* Write meas_rate in hardware */
399static int si1145_set_meas_rate(struct si1145_data *data, int interval)
400{
401 if (data->part_info->uncompressed_meas_rate)
402 return i2c_smbus_write_word_data(client: data->client,
403 SI1145_REG_MEAS_RATE, value: interval);
404 else
405 return i2c_smbus_write_byte_data(client: data->client,
406 SI1145_REG_MEAS_RATE, value: interval);
407}
408
409static int si1145_read_samp_freq(struct si1145_data *data, int *val, int *val2)
410{
411 *val = 32000;
412 if (data->part_info->uncompressed_meas_rate)
413 *val2 = data->meas_rate;
414 else
415 *val2 = si1145_uncompress(x: data->meas_rate);
416 return IIO_VAL_FRACTIONAL;
417}
418
419/* Set the samp freq in driver private data */
420static int si1145_store_samp_freq(struct si1145_data *data, int val)
421{
422 int ret = 0;
423 int meas_rate;
424
425 if (val <= 0 || val > 32000)
426 return -ERANGE;
427 meas_rate = 32000 / val;
428
429 mutex_lock(&data->lock);
430 if (data->autonomous) {
431 ret = si1145_set_meas_rate(data, interval: meas_rate);
432 if (ret)
433 goto out;
434 }
435 if (data->part_info->uncompressed_meas_rate)
436 data->meas_rate = meas_rate;
437 else
438 data->meas_rate = si1145_compress(x: meas_rate);
439
440out:
441 mutex_unlock(lock: &data->lock);
442
443 return ret;
444}
445
446static irqreturn_t si1145_trigger_handler(int irq, void *private)
447{
448 struct iio_poll_func *pf = private;
449 struct iio_dev *indio_dev = pf->indio_dev;
450 struct si1145_data *data = iio_priv(indio_dev);
451 int i, j = 0;
452 int ret;
453 u8 irq_status = 0;
454
455 if (!data->autonomous) {
456 ret = si1145_command(data, SI1145_CMD_PSALS_FORCE);
457 if (ret < 0 && ret != -EOVERFLOW)
458 goto done;
459 } else {
460 irq_status = ret = i2c_smbus_read_byte_data(client: data->client,
461 SI1145_REG_IRQ_STATUS);
462 if (ret < 0)
463 goto done;
464 if (!(irq_status & SI1145_MASK_ALL_IE))
465 goto done;
466 }
467
468 for_each_set_bit(i, indio_dev->active_scan_mask,
469 indio_dev->masklength) {
470 int run = 1;
471
472 while (i + run < indio_dev->masklength) {
473 if (!test_bit(i + run, indio_dev->active_scan_mask))
474 break;
475 if (indio_dev->channels[i + run].address !=
476 indio_dev->channels[i].address + 2 * run)
477 break;
478 run++;
479 }
480
481 ret = i2c_smbus_read_i2c_block_data_or_emulated(
482 client: data->client, command: indio_dev->channels[i].address,
483 length: sizeof(u16) * run, values: &data->buffer[j]);
484 if (ret < 0)
485 goto done;
486 j += run * sizeof(u16);
487 i += run - 1;
488 }
489
490 if (data->autonomous) {
491 ret = i2c_smbus_write_byte_data(client: data->client,
492 SI1145_REG_IRQ_STATUS,
493 value: irq_status & SI1145_MASK_ALL_IE);
494 if (ret < 0)
495 goto done;
496 }
497
498 iio_push_to_buffers_with_timestamp(indio_dev, data: data->buffer,
499 timestamp: iio_get_time_ns(indio_dev));
500
501done:
502 iio_trigger_notify_done(trig: indio_dev->trig);
503 return IRQ_HANDLED;
504}
505
506static int si1145_set_chlist(struct iio_dev *indio_dev, unsigned long scan_mask)
507{
508 struct si1145_data *data = iio_priv(indio_dev);
509 u8 reg = 0, mux;
510 int ret;
511 int i;
512
513 /* channel list already set, no need to reprogram */
514 if (data->scan_mask == scan_mask)
515 return 0;
516
517 for_each_set_bit(i, &scan_mask, indio_dev->masklength) {
518 switch (indio_dev->channels[i].address) {
519 case SI1145_REG_ALSVIS_DATA:
520 reg |= SI1145_CHLIST_EN_ALSVIS;
521 break;
522 case SI1145_REG_ALSIR_DATA:
523 reg |= SI1145_CHLIST_EN_ALSIR;
524 break;
525 case SI1145_REG_PS1_DATA:
526 reg |= SI1145_CHLIST_EN_PS1;
527 break;
528 case SI1145_REG_PS2_DATA:
529 reg |= SI1145_CHLIST_EN_PS2;
530 break;
531 case SI1145_REG_PS3_DATA:
532 reg |= SI1145_CHLIST_EN_PS3;
533 break;
534 case SI1145_REG_AUX_DATA:
535 switch (indio_dev->channels[i].type) {
536 case IIO_UVINDEX:
537 reg |= SI1145_CHLIST_EN_UV;
538 break;
539 default:
540 reg |= SI1145_CHLIST_EN_AUX;
541 if (indio_dev->channels[i].type == IIO_TEMP)
542 mux = SI1145_MUX_TEMP;
543 else
544 mux = SI1145_MUX_VDD;
545 ret = si1145_param_set(data,
546 SI1145_PARAM_AUX_ADC_MUX, value: mux);
547 if (ret < 0)
548 return ret;
549
550 break;
551 }
552 }
553 }
554
555 data->scan_mask = scan_mask;
556 ret = si1145_param_set(data, SI1145_PARAM_CHLIST, value: reg);
557
558 return ret < 0 ? ret : 0;
559}
560
561static int si1145_measure(struct iio_dev *indio_dev,
562 struct iio_chan_spec const *chan)
563{
564 struct si1145_data *data = iio_priv(indio_dev);
565 u8 cmd;
566 int ret;
567
568 ret = si1145_set_chlist(indio_dev, BIT(chan->scan_index));
569 if (ret < 0)
570 return ret;
571
572 cmd = (chan->type == IIO_PROXIMITY) ? SI1145_CMD_PS_FORCE :
573 SI1145_CMD_ALS_FORCE;
574 ret = si1145_command(data, cmd);
575 if (ret < 0 && ret != -EOVERFLOW)
576 return ret;
577
578 return i2c_smbus_read_word_data(client: data->client, command: chan->address);
579}
580
581/*
582 * Conversion between iio scale and ADC_GAIN values
583 * These could be further adjusted but proximity/intensity are dimensionless
584 */
585static const int si1145_proximity_scale_available[] = {
586 128, 64, 32, 16, 8, 4};
587static const int si1145_intensity_scale_available[] = {
588 128, 64, 32, 16, 8, 4, 2, 1};
589static IIO_CONST_ATTR(in_proximity_scale_available,
590 "128 64 32 16 8 4");
591static IIO_CONST_ATTR(in_intensity_scale_available,
592 "128 64 32 16 8 4 2 1");
593static IIO_CONST_ATTR(in_intensity_ir_scale_available,
594 "128 64 32 16 8 4 2 1");
595
596static int si1145_scale_from_adcgain(int regval)
597{
598 return 128 >> regval;
599}
600
601static int si1145_proximity_adcgain_from_scale(int val, int val2)
602{
603 val = find_closest_descending(val, si1145_proximity_scale_available,
604 ARRAY_SIZE(si1145_proximity_scale_available));
605 if (val < 0 || val > 5 || val2 != 0)
606 return -EINVAL;
607
608 return val;
609}
610
611static int si1145_intensity_adcgain_from_scale(int val, int val2)
612{
613 val = find_closest_descending(val, si1145_intensity_scale_available,
614 ARRAY_SIZE(si1145_intensity_scale_available));
615 if (val < 0 || val > 7 || val2 != 0)
616 return -EINVAL;
617
618 return val;
619}
620
621static int si1145_read_raw(struct iio_dev *indio_dev,
622 struct iio_chan_spec const *chan,
623 int *val, int *val2, long mask)
624{
625 struct si1145_data *data = iio_priv(indio_dev);
626 int ret;
627 u8 reg;
628
629 switch (mask) {
630 case IIO_CHAN_INFO_RAW:
631 switch (chan->type) {
632 case IIO_INTENSITY:
633 case IIO_PROXIMITY:
634 case IIO_VOLTAGE:
635 case IIO_TEMP:
636 case IIO_UVINDEX:
637 ret = iio_device_claim_direct_mode(indio_dev);
638 if (ret)
639 return ret;
640 ret = si1145_measure(indio_dev, chan);
641 iio_device_release_direct_mode(indio_dev);
642
643 if (ret < 0)
644 return ret;
645
646 *val = ret;
647
648 return IIO_VAL_INT;
649 case IIO_CURRENT:
650 ret = i2c_smbus_read_byte_data(client: data->client,
651 SI1145_PS_LED_REG(chan->channel));
652 if (ret < 0)
653 return ret;
654
655 *val = (ret >> SI1145_PS_LED_SHIFT(chan->channel))
656 & 0x0f;
657
658 return IIO_VAL_INT;
659 default:
660 return -EINVAL;
661 }
662 case IIO_CHAN_INFO_SCALE:
663 switch (chan->type) {
664 case IIO_PROXIMITY:
665 reg = SI1145_PARAM_PS_ADC_GAIN;
666 break;
667 case IIO_INTENSITY:
668 if (chan->channel2 == IIO_MOD_LIGHT_IR)
669 reg = SI1145_PARAM_ALSIR_ADC_GAIN;
670 else
671 reg = SI1145_PARAM_ALSVIS_ADC_GAIN;
672 break;
673 case IIO_TEMP:
674 *val = 28;
675 *val2 = 571429;
676 return IIO_VAL_INT_PLUS_MICRO;
677 case IIO_UVINDEX:
678 *val = 0;
679 *val2 = 10000;
680 return IIO_VAL_INT_PLUS_MICRO;
681 default:
682 return -EINVAL;
683 }
684
685 ret = si1145_param_query(data, param: reg);
686 if (ret < 0)
687 return ret;
688
689 *val = si1145_scale_from_adcgain(regval: ret & 0x07);
690
691 return IIO_VAL_INT;
692 case IIO_CHAN_INFO_OFFSET:
693 switch (chan->type) {
694 case IIO_TEMP:
695 /*
696 * -ADC offset - ADC counts @ 25°C -
697 * 35 * ADC counts / °C
698 */
699 *val = -256 - 11136 + 25 * 35;
700 return IIO_VAL_INT;
701 default:
702 /*
703 * All ADC measurements have are by default offset
704 * by -256
705 * See AN498 5.6.3
706 */
707 ret = si1145_param_query(data, SI1145_PARAM_ADC_OFFSET);
708 if (ret < 0)
709 return ret;
710 *val = -si1145_uncompress(x: ret);
711 return IIO_VAL_INT;
712 }
713 case IIO_CHAN_INFO_SAMP_FREQ:
714 return si1145_read_samp_freq(data, val, val2);
715 default:
716 return -EINVAL;
717 }
718}
719
720static int si1145_write_raw(struct iio_dev *indio_dev,
721 struct iio_chan_spec const *chan,
722 int val, int val2, long mask)
723{
724 struct si1145_data *data = iio_priv(indio_dev);
725 u8 reg1, reg2, shift;
726 int ret;
727
728 switch (mask) {
729 case IIO_CHAN_INFO_SCALE:
730 switch (chan->type) {
731 case IIO_PROXIMITY:
732 val = si1145_proximity_adcgain_from_scale(val, val2);
733 if (val < 0)
734 return val;
735 reg1 = SI1145_PARAM_PS_ADC_GAIN;
736 reg2 = SI1145_PARAM_PS_ADC_COUNTER;
737 break;
738 case IIO_INTENSITY:
739 val = si1145_intensity_adcgain_from_scale(val, val2);
740 if (val < 0)
741 return val;
742 if (chan->channel2 == IIO_MOD_LIGHT_IR) {
743 reg1 = SI1145_PARAM_ALSIR_ADC_GAIN;
744 reg2 = SI1145_PARAM_ALSIR_ADC_COUNTER;
745 } else {
746 reg1 = SI1145_PARAM_ALSVIS_ADC_GAIN;
747 reg2 = SI1145_PARAM_ALSVIS_ADC_COUNTER;
748 }
749 break;
750 default:
751 return -EINVAL;
752 }
753
754 ret = iio_device_claim_direct_mode(indio_dev);
755 if (ret)
756 return ret;
757
758 ret = si1145_param_set(data, param: reg1, value: val);
759 if (ret < 0) {
760 iio_device_release_direct_mode(indio_dev);
761 return ret;
762 }
763 /* Set recovery period to one's complement of gain */
764 ret = si1145_param_set(data, param: reg2, value: (~val & 0x07) << 4);
765 iio_device_release_direct_mode(indio_dev);
766 return ret;
767 case IIO_CHAN_INFO_RAW:
768 if (chan->type != IIO_CURRENT)
769 return -EINVAL;
770
771 if (val < 0 || val > 15 || val2 != 0)
772 return -EINVAL;
773
774 reg1 = SI1145_PS_LED_REG(chan->channel);
775 shift = SI1145_PS_LED_SHIFT(chan->channel);
776
777 ret = iio_device_claim_direct_mode(indio_dev);
778 if (ret)
779 return ret;
780
781 ret = i2c_smbus_read_byte_data(client: data->client, command: reg1);
782 if (ret < 0) {
783 iio_device_release_direct_mode(indio_dev);
784 return ret;
785 }
786 ret = i2c_smbus_write_byte_data(client: data->client, command: reg1,
787 value: (ret & ~(0x0f << shift)) |
788 ((val & 0x0f) << shift));
789 iio_device_release_direct_mode(indio_dev);
790 return ret;
791 case IIO_CHAN_INFO_SAMP_FREQ:
792 return si1145_store_samp_freq(data, val);
793 default:
794 return -EINVAL;
795 }
796}
797
798#define SI1145_ST { \
799 .sign = 'u', \
800 .realbits = 16, \
801 .storagebits = 16, \
802 .endianness = IIO_LE, \
803}
804
805#define SI1145_INTENSITY_CHANNEL(_si) { \
806 .type = IIO_INTENSITY, \
807 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
808 BIT(IIO_CHAN_INFO_OFFSET) | \
809 BIT(IIO_CHAN_INFO_SCALE), \
810 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
811 .scan_type = SI1145_ST, \
812 .scan_index = _si, \
813 .address = SI1145_REG_ALSVIS_DATA, \
814}
815
816#define SI1145_INTENSITY_IR_CHANNEL(_si) { \
817 .type = IIO_INTENSITY, \
818 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
819 BIT(IIO_CHAN_INFO_OFFSET) | \
820 BIT(IIO_CHAN_INFO_SCALE), \
821 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
822 .modified = 1, \
823 .channel2 = IIO_MOD_LIGHT_IR, \
824 .scan_type = SI1145_ST, \
825 .scan_index = _si, \
826 .address = SI1145_REG_ALSIR_DATA, \
827}
828
829#define SI1145_TEMP_CHANNEL(_si) { \
830 .type = IIO_TEMP, \
831 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
832 BIT(IIO_CHAN_INFO_OFFSET) | \
833 BIT(IIO_CHAN_INFO_SCALE), \
834 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
835 .scan_type = SI1145_ST, \
836 .scan_index = _si, \
837 .address = SI1145_REG_AUX_DATA, \
838}
839
840#define SI1145_UV_CHANNEL(_si) { \
841 .type = IIO_UVINDEX, \
842 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
843 BIT(IIO_CHAN_INFO_SCALE), \
844 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
845 .scan_type = SI1145_ST, \
846 .scan_index = _si, \
847 .address = SI1145_REG_AUX_DATA, \
848}
849
850#define SI1145_PROXIMITY_CHANNEL(_si, _ch) { \
851 .type = IIO_PROXIMITY, \
852 .indexed = 1, \
853 .channel = _ch, \
854 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
855 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
856 BIT(IIO_CHAN_INFO_OFFSET), \
857 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
858 .scan_type = SI1145_ST, \
859 .scan_index = _si, \
860 .address = SI1145_REG_PS1_DATA + _ch * 2, \
861}
862
863#define SI1145_VOLTAGE_CHANNEL(_si) { \
864 .type = IIO_VOLTAGE, \
865 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
866 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
867 .scan_type = SI1145_ST, \
868 .scan_index = _si, \
869 .address = SI1145_REG_AUX_DATA, \
870}
871
872#define SI1145_CURRENT_CHANNEL(_ch) { \
873 .type = IIO_CURRENT, \
874 .indexed = 1, \
875 .channel = _ch, \
876 .output = 1, \
877 .scan_index = -1, \
878 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
879}
880
881static const struct iio_chan_spec si1132_channels[] = {
882 SI1145_INTENSITY_CHANNEL(0),
883 SI1145_INTENSITY_IR_CHANNEL(1),
884 SI1145_TEMP_CHANNEL(2),
885 SI1145_VOLTAGE_CHANNEL(3),
886 SI1145_UV_CHANNEL(4),
887 IIO_CHAN_SOFT_TIMESTAMP(6),
888};
889
890static const struct iio_chan_spec si1141_channels[] = {
891 SI1145_INTENSITY_CHANNEL(0),
892 SI1145_INTENSITY_IR_CHANNEL(1),
893 SI1145_PROXIMITY_CHANNEL(2, 0),
894 SI1145_TEMP_CHANNEL(3),
895 SI1145_VOLTAGE_CHANNEL(4),
896 IIO_CHAN_SOFT_TIMESTAMP(5),
897 SI1145_CURRENT_CHANNEL(0),
898};
899
900static const struct iio_chan_spec si1142_channels[] = {
901 SI1145_INTENSITY_CHANNEL(0),
902 SI1145_INTENSITY_IR_CHANNEL(1),
903 SI1145_PROXIMITY_CHANNEL(2, 0),
904 SI1145_PROXIMITY_CHANNEL(3, 1),
905 SI1145_TEMP_CHANNEL(4),
906 SI1145_VOLTAGE_CHANNEL(5),
907 IIO_CHAN_SOFT_TIMESTAMP(6),
908 SI1145_CURRENT_CHANNEL(0),
909 SI1145_CURRENT_CHANNEL(1),
910};
911
912static const struct iio_chan_spec si1143_channels[] = {
913 SI1145_INTENSITY_CHANNEL(0),
914 SI1145_INTENSITY_IR_CHANNEL(1),
915 SI1145_PROXIMITY_CHANNEL(2, 0),
916 SI1145_PROXIMITY_CHANNEL(3, 1),
917 SI1145_PROXIMITY_CHANNEL(4, 2),
918 SI1145_TEMP_CHANNEL(5),
919 SI1145_VOLTAGE_CHANNEL(6),
920 IIO_CHAN_SOFT_TIMESTAMP(7),
921 SI1145_CURRENT_CHANNEL(0),
922 SI1145_CURRENT_CHANNEL(1),
923 SI1145_CURRENT_CHANNEL(2),
924};
925
926static const struct iio_chan_spec si1145_channels[] = {
927 SI1145_INTENSITY_CHANNEL(0),
928 SI1145_INTENSITY_IR_CHANNEL(1),
929 SI1145_PROXIMITY_CHANNEL(2, 0),
930 SI1145_TEMP_CHANNEL(3),
931 SI1145_VOLTAGE_CHANNEL(4),
932 SI1145_UV_CHANNEL(5),
933 IIO_CHAN_SOFT_TIMESTAMP(6),
934 SI1145_CURRENT_CHANNEL(0),
935};
936
937static const struct iio_chan_spec si1146_channels[] = {
938 SI1145_INTENSITY_CHANNEL(0),
939 SI1145_INTENSITY_IR_CHANNEL(1),
940 SI1145_TEMP_CHANNEL(2),
941 SI1145_VOLTAGE_CHANNEL(3),
942 SI1145_UV_CHANNEL(4),
943 SI1145_PROXIMITY_CHANNEL(5, 0),
944 SI1145_PROXIMITY_CHANNEL(6, 1),
945 IIO_CHAN_SOFT_TIMESTAMP(7),
946 SI1145_CURRENT_CHANNEL(0),
947 SI1145_CURRENT_CHANNEL(1),
948};
949
950static const struct iio_chan_spec si1147_channels[] = {
951 SI1145_INTENSITY_CHANNEL(0),
952 SI1145_INTENSITY_IR_CHANNEL(1),
953 SI1145_PROXIMITY_CHANNEL(2, 0),
954 SI1145_PROXIMITY_CHANNEL(3, 1),
955 SI1145_PROXIMITY_CHANNEL(4, 2),
956 SI1145_TEMP_CHANNEL(5),
957 SI1145_VOLTAGE_CHANNEL(6),
958 SI1145_UV_CHANNEL(7),
959 IIO_CHAN_SOFT_TIMESTAMP(8),
960 SI1145_CURRENT_CHANNEL(0),
961 SI1145_CURRENT_CHANNEL(1),
962 SI1145_CURRENT_CHANNEL(2),
963};
964
965static struct attribute *si1132_attributes[] = {
966 &iio_const_attr_in_intensity_scale_available.dev_attr.attr,
967 &iio_const_attr_in_intensity_ir_scale_available.dev_attr.attr,
968 NULL,
969};
970
971static struct attribute *si114x_attributes[] = {
972 &iio_const_attr_in_intensity_scale_available.dev_attr.attr,
973 &iio_const_attr_in_intensity_ir_scale_available.dev_attr.attr,
974 &iio_const_attr_in_proximity_scale_available.dev_attr.attr,
975 NULL,
976};
977
978static const struct attribute_group si1132_attribute_group = {
979 .attrs = si1132_attributes,
980};
981
982static const struct attribute_group si114x_attribute_group = {
983 .attrs = si114x_attributes,
984};
985
986
987static const struct iio_info si1132_info = {
988 .read_raw = si1145_read_raw,
989 .write_raw = si1145_write_raw,
990 .attrs = &si1132_attribute_group,
991};
992
993static const struct iio_info si114x_info = {
994 .read_raw = si1145_read_raw,
995 .write_raw = si1145_write_raw,
996 .attrs = &si114x_attribute_group,
997};
998
999#define SI1145_PART(id, iio_info, chans, leds, uncompressed_meas_rate) \
1000 {id, iio_info, chans, ARRAY_SIZE(chans), leds, uncompressed_meas_rate}
1001
1002static const struct si1145_part_info si1145_part_info[] = {
1003 [SI1132] = SI1145_PART(0x32, &si1132_info, si1132_channels, 0, true),
1004 [SI1141] = SI1145_PART(0x41, &si114x_info, si1141_channels, 1, false),
1005 [SI1142] = SI1145_PART(0x42, &si114x_info, si1142_channels, 2, false),
1006 [SI1143] = SI1145_PART(0x43, &si114x_info, si1143_channels, 3, false),
1007 [SI1145] = SI1145_PART(0x45, &si114x_info, si1145_channels, 1, true),
1008 [SI1146] = SI1145_PART(0x46, &si114x_info, si1146_channels, 2, true),
1009 [SI1147] = SI1145_PART(0x47, &si114x_info, si1147_channels, 3, true),
1010};
1011
1012static int si1145_initialize(struct si1145_data *data)
1013{
1014 struct i2c_client *client = data->client;
1015 int ret;
1016
1017 ret = i2c_smbus_write_byte_data(client, SI1145_REG_COMMAND,
1018 SI1145_CMD_RESET);
1019 if (ret < 0)
1020 return ret;
1021 msleep(SI1145_COMMAND_TIMEOUT_MS);
1022
1023 /* Hardware key, magic value */
1024 ret = i2c_smbus_write_byte_data(client, SI1145_REG_HW_KEY, value: 0x17);
1025 if (ret < 0)
1026 return ret;
1027 msleep(SI1145_COMMAND_TIMEOUT_MS);
1028
1029 /* Turn off autonomous mode */
1030 ret = si1145_set_meas_rate(data, interval: 0);
1031 if (ret < 0)
1032 return ret;
1033
1034 /* Initialize sampling freq to 10 Hz */
1035 ret = si1145_store_samp_freq(data, val: 10);
1036 if (ret < 0)
1037 return ret;
1038
1039 /* Set LED currents to 45 mA; have 4 bits, see Table 2 in datasheet */
1040 switch (data->part_info->num_leds) {
1041 case 3:
1042 ret = i2c_smbus_write_byte_data(client,
1043 SI1145_REG_PS_LED3,
1044 SI1145_LED_CURRENT_45mA);
1045 if (ret < 0)
1046 return ret;
1047 fallthrough;
1048 case 2:
1049 ret = i2c_smbus_write_byte_data(client,
1050 SI1145_REG_PS_LED21,
1051 value: (SI1145_LED_CURRENT_45mA << 4) |
1052 SI1145_LED_CURRENT_45mA);
1053 break;
1054 case 1:
1055 ret = i2c_smbus_write_byte_data(client,
1056 SI1145_REG_PS_LED21,
1057 SI1145_LED_CURRENT_45mA);
1058 break;
1059 default:
1060 ret = 0;
1061 break;
1062 }
1063 if (ret < 0)
1064 return ret;
1065
1066 /* Set normal proximity measurement mode */
1067 ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_MISC,
1068 SI1145_PS_ADC_MODE_NORMAL);
1069 if (ret < 0)
1070 return ret;
1071
1072 ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_GAIN, value: 0x01);
1073 if (ret < 0)
1074 return ret;
1075
1076 /* ADC_COUNTER should be one complement of ADC_GAIN */
1077 ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_COUNTER, value: 0x06 << 4);
1078 if (ret < 0)
1079 return ret;
1080
1081 /* Set ALS visible measurement mode */
1082 ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_MISC,
1083 SI1145_ADC_MISC_RANGE);
1084 if (ret < 0)
1085 return ret;
1086
1087 ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_GAIN, value: 0x03);
1088 if (ret < 0)
1089 return ret;
1090
1091 ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_COUNTER,
1092 value: 0x04 << 4);
1093 if (ret < 0)
1094 return ret;
1095
1096 /* Set ALS IR measurement mode */
1097 ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_MISC,
1098 SI1145_ADC_MISC_RANGE);
1099 if (ret < 0)
1100 return ret;
1101
1102 ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_GAIN, value: 0x01);
1103 if (ret < 0)
1104 return ret;
1105
1106 ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_COUNTER,
1107 value: 0x06 << 4);
1108 if (ret < 0)
1109 return ret;
1110
1111 /*
1112 * Initialize UCOEF to default values in datasheet
1113 * These registers are normally zero on reset
1114 */
1115 if (data->part_info == &si1145_part_info[SI1132] ||
1116 data->part_info == &si1145_part_info[SI1145] ||
1117 data->part_info == &si1145_part_info[SI1146] ||
1118 data->part_info == &si1145_part_info[SI1147]) {
1119 ret = i2c_smbus_write_byte_data(client: data->client,
1120 SI1145_REG_UCOEF1,
1121 SI1145_UCOEF1_DEFAULT);
1122 if (ret < 0)
1123 return ret;
1124 ret = i2c_smbus_write_byte_data(client: data->client,
1125 SI1145_REG_UCOEF2, SI1145_UCOEF2_DEFAULT);
1126 if (ret < 0)
1127 return ret;
1128 ret = i2c_smbus_write_byte_data(client: data->client,
1129 SI1145_REG_UCOEF3, SI1145_UCOEF3_DEFAULT);
1130 if (ret < 0)
1131 return ret;
1132 ret = i2c_smbus_write_byte_data(client: data->client,
1133 SI1145_REG_UCOEF4, SI1145_UCOEF4_DEFAULT);
1134 if (ret < 0)
1135 return ret;
1136 }
1137
1138 return 0;
1139}
1140
1141/*
1142 * Program the channels we want to measure with CMD_PSALS_AUTO. No need for
1143 * _postdisable as we stop with CMD_PSALS_PAUSE; single measurement (direct)
1144 * mode reprograms the channels list anyway...
1145 */
1146static int si1145_buffer_preenable(struct iio_dev *indio_dev)
1147{
1148 struct si1145_data *data = iio_priv(indio_dev);
1149 int ret;
1150
1151 mutex_lock(&data->lock);
1152 ret = si1145_set_chlist(indio_dev, scan_mask: *indio_dev->active_scan_mask);
1153 mutex_unlock(lock: &data->lock);
1154
1155 return ret;
1156}
1157
1158static bool si1145_validate_scan_mask(struct iio_dev *indio_dev,
1159 const unsigned long *scan_mask)
1160{
1161 struct si1145_data *data = iio_priv(indio_dev);
1162 unsigned int count = 0;
1163 int i;
1164
1165 /* Check that at most one AUX channel is enabled */
1166 for_each_set_bit(i, scan_mask, data->part_info->num_channels) {
1167 if (indio_dev->channels[i].address == SI1145_REG_AUX_DATA)
1168 count++;
1169 }
1170
1171 return count <= 1;
1172}
1173
1174static const struct iio_buffer_setup_ops si1145_buffer_setup_ops = {
1175 .preenable = si1145_buffer_preenable,
1176 .validate_scan_mask = si1145_validate_scan_mask,
1177};
1178
1179/*
1180 * si1145_trigger_set_state() - Set trigger state
1181 *
1182 * When not using triggers interrupts are disabled and measurement rate is
1183 * set to zero in order to minimize power consumption.
1184 */
1185static int si1145_trigger_set_state(struct iio_trigger *trig, bool state)
1186{
1187 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1188 struct si1145_data *data = iio_priv(indio_dev);
1189 int err = 0, ret;
1190
1191 mutex_lock(&data->lock);
1192
1193 if (state) {
1194 data->autonomous = true;
1195 err = i2c_smbus_write_byte_data(client: data->client,
1196 SI1145_REG_INT_CFG, SI1145_INT_CFG_OE);
1197 if (err < 0)
1198 goto disable;
1199 err = i2c_smbus_write_byte_data(client: data->client,
1200 SI1145_REG_IRQ_ENABLE, SI1145_MASK_ALL_IE);
1201 if (err < 0)
1202 goto disable;
1203 err = si1145_set_meas_rate(data, interval: data->meas_rate);
1204 if (err < 0)
1205 goto disable;
1206 err = si1145_command(data, SI1145_CMD_PSALS_AUTO);
1207 if (err < 0)
1208 goto disable;
1209 } else {
1210disable:
1211 /* Disable as much as possible skipping errors */
1212 ret = si1145_command(data, SI1145_CMD_PSALS_PAUSE);
1213 if (ret < 0 && !err)
1214 err = ret;
1215 ret = si1145_set_meas_rate(data, interval: 0);
1216 if (ret < 0 && !err)
1217 err = ret;
1218 ret = i2c_smbus_write_byte_data(client: data->client,
1219 SI1145_REG_IRQ_ENABLE, value: 0);
1220 if (ret < 0 && !err)
1221 err = ret;
1222 ret = i2c_smbus_write_byte_data(client: data->client,
1223 SI1145_REG_INT_CFG, value: 0);
1224 if (ret < 0 && !err)
1225 err = ret;
1226 data->autonomous = false;
1227 }
1228
1229 mutex_unlock(lock: &data->lock);
1230 return err;
1231}
1232
1233static const struct iio_trigger_ops si1145_trigger_ops = {
1234 .set_trigger_state = si1145_trigger_set_state,
1235};
1236
1237static int si1145_probe_trigger(struct iio_dev *indio_dev)
1238{
1239 struct si1145_data *data = iio_priv(indio_dev);
1240 struct i2c_client *client = data->client;
1241 struct iio_trigger *trig;
1242 int ret;
1243
1244 trig = devm_iio_trigger_alloc(&client->dev,
1245 "%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
1246 if (!trig)
1247 return -ENOMEM;
1248
1249 trig->ops = &si1145_trigger_ops;
1250 iio_trigger_set_drvdata(trig, data: indio_dev);
1251
1252 ret = devm_request_irq(dev: &client->dev, irq: client->irq,
1253 handler: iio_trigger_generic_data_rdy_poll,
1254 IRQF_TRIGGER_FALLING,
1255 devname: "si1145_irq",
1256 dev_id: trig);
1257 if (ret < 0) {
1258 dev_err(&client->dev, "irq request failed\n");
1259 return ret;
1260 }
1261
1262 ret = devm_iio_trigger_register(dev: &client->dev, trig_info: trig);
1263 if (ret)
1264 return ret;
1265
1266 data->trig = trig;
1267 indio_dev->trig = iio_trigger_get(trig: data->trig);
1268
1269 return 0;
1270}
1271
1272static int si1145_probe(struct i2c_client *client)
1273{
1274 const struct i2c_device_id *id = i2c_client_get_device_id(client);
1275 struct si1145_data *data;
1276 struct iio_dev *indio_dev;
1277 u8 part_id, rev_id, seq_id;
1278 int ret;
1279
1280 indio_dev = devm_iio_device_alloc(parent: &client->dev, sizeof_priv: sizeof(*data));
1281 if (!indio_dev)
1282 return -ENOMEM;
1283
1284 data = iio_priv(indio_dev);
1285 i2c_set_clientdata(client, data: indio_dev);
1286 data->client = client;
1287 data->part_info = &si1145_part_info[id->driver_data];
1288
1289 part_id = ret = i2c_smbus_read_byte_data(client: data->client,
1290 SI1145_REG_PART_ID);
1291 if (ret < 0)
1292 return ret;
1293 rev_id = ret = i2c_smbus_read_byte_data(client: data->client,
1294 SI1145_REG_REV_ID);
1295 if (ret < 0)
1296 return ret;
1297 seq_id = ret = i2c_smbus_read_byte_data(client: data->client,
1298 SI1145_REG_SEQ_ID);
1299 if (ret < 0)
1300 return ret;
1301 dev_info(&client->dev, "device ID part 0x%02x rev 0x%02x seq 0x%02x\n",
1302 part_id, rev_id, seq_id);
1303 if (part_id != data->part_info->part) {
1304 dev_err(&client->dev, "part ID mismatch got 0x%02x, expected 0x%02x\n",
1305 part_id, data->part_info->part);
1306 return -ENODEV;
1307 }
1308
1309 indio_dev->name = id->name;
1310 indio_dev->channels = data->part_info->channels;
1311 indio_dev->num_channels = data->part_info->num_channels;
1312 indio_dev->info = data->part_info->iio_info;
1313 indio_dev->modes = INDIO_DIRECT_MODE;
1314
1315 mutex_init(&data->lock);
1316 mutex_init(&data->cmdlock);
1317
1318 ret = si1145_initialize(data);
1319 if (ret < 0)
1320 return ret;
1321
1322 ret = devm_iio_triggered_buffer_setup(&client->dev,
1323 indio_dev, NULL,
1324 si1145_trigger_handler, &si1145_buffer_setup_ops);
1325 if (ret < 0)
1326 return ret;
1327
1328 if (client->irq) {
1329 ret = si1145_probe_trigger(indio_dev);
1330 if (ret < 0)
1331 return ret;
1332 } else {
1333 dev_info(&client->dev, "no irq, using polling\n");
1334 }
1335
1336 return devm_iio_device_register(&client->dev, indio_dev);
1337}
1338
1339static const struct i2c_device_id si1145_ids[] = {
1340 { "si1132", SI1132 },
1341 { "si1141", SI1141 },
1342 { "si1142", SI1142 },
1343 { "si1143", SI1143 },
1344 { "si1145", SI1145 },
1345 { "si1146", SI1146 },
1346 { "si1147", SI1147 },
1347 { }
1348};
1349MODULE_DEVICE_TABLE(i2c, si1145_ids);
1350
1351static struct i2c_driver si1145_driver = {
1352 .driver = {
1353 .name = "si1145",
1354 },
1355 .probe = si1145_probe,
1356 .id_table = si1145_ids,
1357};
1358
1359module_i2c_driver(si1145_driver);
1360
1361MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
1362MODULE_DESCRIPTION("Silabs SI1132 and SI1141/2/3/5/6/7 proximity, ambient light and UV index sensor driver");
1363MODULE_LICENSE("GPL");
1364

source code of linux/drivers/iio/light/si1145.c