xref: /openbmc/linux/drivers/iio/light/si1145.c (revision 7cf15f42)
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  * @buffer:	Used to pack data read from sensor.
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 	 * 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  */
__si1145_command_reset(struct si1145_data * data)200 static 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(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(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  */
si1145_command(struct si1145_data * data,u8 cmd)235 static 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(data->client, SI1145_REG_COMMAND, 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(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 
309 out:
310 	mutex_unlock(&data->cmdlock);
311 
312 	return ret;
313 }
314 
si1145_param_update(struct si1145_data * data,u8 op,u8 param,u8 value)315 static 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(data->client,
321 		SI1145_REG_PARAM_WR, value);
322 	if (ret < 0)
323 		return ret;
324 
325 	return si1145_command(data, op | (param & 0x1F));
326 }
327 
si1145_param_set(struct si1145_data * data,u8 param,u8 value)328 static 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 */
si1145_param_query(struct si1145_data * data,u8 param)334 static 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(data->client, SI1145_REG_PARAM_RD);
343 }
344 
345 /* Expand 8 bit compressed value to 16 bit, see Silabs AN498 */
si1145_uncompress(u8 x)346 static 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 */
si1145_compress(u16 x)363 static 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 */
si1145_set_meas_rate(struct si1145_data * data,int interval)399 static 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(data->client,
403 			SI1145_REG_MEAS_RATE, interval);
404 	else
405 		return i2c_smbus_write_byte_data(data->client,
406 			SI1145_REG_MEAS_RATE, interval);
407 }
408 
si1145_read_samp_freq(struct si1145_data * data,int * val,int * val2)409 static 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(data->meas_rate);
416 	return IIO_VAL_FRACTIONAL;
417 }
418 
419 /* Set the samp freq in driver private data */
si1145_store_samp_freq(struct si1145_data * data,int val)420 static 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, 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(meas_rate);
439 
440 out:
441 	mutex_unlock(&data->lock);
442 
443 	return ret;
444 }
445 
si1145_trigger_handler(int irq,void * private)446 static 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(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 				data->client, indio_dev->channels[i].address,
483 				sizeof(u16) * run, &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(data->client,
492 				SI1145_REG_IRQ_STATUS,
493 				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->buffer,
499 		iio_get_time_ns(indio_dev));
500 
501 done:
502 	iio_trigger_notify_done(indio_dev->trig);
503 	return IRQ_HANDLED;
504 }
505 
si1145_set_chlist(struct iio_dev * indio_dev,unsigned long scan_mask)506 static 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, 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, reg);
557 
558 	return ret < 0 ? ret : 0;
559 }
560 
si1145_measure(struct iio_dev * indio_dev,struct iio_chan_spec const * chan)561 static 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(data->client, 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  */
585 static const int si1145_proximity_scale_available[] = {
586 	128, 64, 32, 16, 8, 4};
587 static const int si1145_intensity_scale_available[] = {
588 	128, 64, 32, 16, 8, 4, 2, 1};
589 static IIO_CONST_ATTR(in_proximity_scale_available,
590 	"128 64 32 16 8 4");
591 static IIO_CONST_ATTR(in_intensity_scale_available,
592 	"128 64 32 16 8 4 2 1");
593 static IIO_CONST_ATTR(in_intensity_ir_scale_available,
594 	"128 64 32 16 8 4 2 1");
595 
si1145_scale_from_adcgain(int regval)596 static int si1145_scale_from_adcgain(int regval)
597 {
598 	return 128 >> regval;
599 }
600 
si1145_proximity_adcgain_from_scale(int val,int val2)601 static 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 
si1145_intensity_adcgain_from_scale(int val,int val2)611 static 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 
si1145_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)621 static 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(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, reg);
686 		if (ret < 0)
687 			return ret;
688 
689 		*val = si1145_scale_from_adcgain(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(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 
si1145_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)720 static 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, reg1, 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, reg2, (~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(data->client, reg1);
782 		if (ret < 0) {
783 			iio_device_release_direct_mode(indio_dev);
784 			return ret;
785 		}
786 		ret = i2c_smbus_write_byte_data(data->client, reg1,
787 			(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 
881 static 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 
890 static 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 
900 static 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 
912 static 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 
926 static 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 
937 static 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 
950 static 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 
965 static 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 
971 static 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 
978 static const struct attribute_group si1132_attribute_group = {
979 	.attrs = si1132_attributes,
980 };
981 
982 static const struct attribute_group si114x_attribute_group = {
983 	.attrs = si114x_attributes,
984 };
985 
986 
987 static 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 
993 static 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 
1002 static 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 
si1145_initialize(struct si1145_data * data)1012 static 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, 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, 0);
1031 	if (ret < 0)
1032 		return ret;
1033 
1034 	/* Initialize sampling freq to 10 Hz */
1035 	ret = si1145_store_samp_freq(data, 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 						(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, 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, 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, 0x03);
1088 	if (ret < 0)
1089 		return ret;
1090 
1091 	ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_COUNTER,
1092 			       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, 0x01);
1103 	if (ret < 0)
1104 		return ret;
1105 
1106 	ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_COUNTER,
1107 			       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(data->client,
1120 						SI1145_REG_UCOEF1,
1121 						SI1145_UCOEF1_DEFAULT);
1122 		if (ret < 0)
1123 			return ret;
1124 		ret = i2c_smbus_write_byte_data(data->client,
1125 				SI1145_REG_UCOEF2, SI1145_UCOEF2_DEFAULT);
1126 		if (ret < 0)
1127 			return ret;
1128 		ret = i2c_smbus_write_byte_data(data->client,
1129 				SI1145_REG_UCOEF3, SI1145_UCOEF3_DEFAULT);
1130 		if (ret < 0)
1131 			return ret;
1132 		ret = i2c_smbus_write_byte_data(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  */
si1145_buffer_preenable(struct iio_dev * indio_dev)1146 static 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, *indio_dev->active_scan_mask);
1153 	mutex_unlock(&data->lock);
1154 
1155 	return ret;
1156 }
1157 
si1145_validate_scan_mask(struct iio_dev * indio_dev,const unsigned long * scan_mask)1158 static 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 
1174 static 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  */
si1145_trigger_set_state(struct iio_trigger * trig,bool state)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 
si1145_probe_trigger(struct iio_dev * indio_dev)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, iio_device_id(indio_dev));
1246 	if (!trig)
1247 		return -ENOMEM;
1248 
1249 	trig->ops = &si1145_trigger_ops;
1250 	iio_trigger_set_drvdata(trig, indio_dev);
1251 
1252 	ret = devm_request_irq(&client->dev, client->irq,
1253 			  iio_trigger_generic_data_rdy_poll,
1254 			  IRQF_TRIGGER_FALLING,
1255 			  "si1145_irq",
1256 			  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(&client->dev, trig);
1263 	if (ret)
1264 		return ret;
1265 
1266 	data->trig = trig;
1267 	indio_dev->trig = iio_trigger_get(data->trig);
1268 
1269 	return 0;
1270 }
1271 
si1145_probe(struct i2c_client * client)1272 static 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(&client->dev, sizeof(*data));
1281 	if (!indio_dev)
1282 		return -ENOMEM;
1283 
1284 	data = iio_priv(indio_dev);
1285 	i2c_set_clientdata(client, 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(data->client,
1290 						 SI1145_REG_PART_ID);
1291 	if (ret < 0)
1292 		return ret;
1293 	rev_id = ret = i2c_smbus_read_byte_data(data->client,
1294 						SI1145_REG_REV_ID);
1295 	if (ret < 0)
1296 		return ret;
1297 	seq_id = ret = i2c_smbus_read_byte_data(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 
1339 static 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 };
1349 MODULE_DEVICE_TABLE(i2c, si1145_ids);
1350 
1351 static struct i2c_driver si1145_driver = {
1352 	.driver = {
1353 		.name   = "si1145",
1354 	},
1355 	.probe = si1145_probe,
1356 	.id_table = si1145_ids,
1357 };
1358 
1359 module_i2c_driver(si1145_driver);
1360 
1361 MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
1362 MODULE_DESCRIPTION("Silabs SI1132 and SI1141/2/3/5/6/7 proximity, ambient light and UV index sensor driver");
1363 MODULE_LICENSE("GPL");
1364