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