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