xref: /openbmc/linux/drivers/iio/light/tsl2772.c (revision 7cf15f42)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Device driver for monitoring ambient light intensity in (lux) and proximity
4  * detection (prox) within the TAOS TSL2571, TSL2671, TMD2671, TSL2771, TMD2771,
5  * TSL2572, TSL2672, TMD2672, TSL2772, and TMD2772 devices.
6  *
7  * Copyright (c) 2012, TAOS Corporation.
8  * Copyright (c) 2017-2018 Brian Masney <masneyb@onstation.org>
9  */
10 
11 #include <linux/delay.h>
12 #include <linux/errno.h>
13 #include <linux/i2c.h>
14 #include <linux/interrupt.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/mutex.h>
18 #include <linux/property.h>
19 #include <linux/slab.h>
20 
21 #include <linux/iio/events.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/sysfs.h>
24 #include <linux/platform_data/tsl2772.h>
25 #include <linux/regulator/consumer.h>
26 
27 /* Cal defs */
28 #define PROX_STAT_CAL			0
29 #define PROX_STAT_SAMP			1
30 #define MAX_SAMPLES_CAL			200
31 
32 /* TSL2772 Device ID */
33 #define TRITON_ID			0x00
34 #define SWORDFISH_ID			0x30
35 #define HALIBUT_ID			0x20
36 
37 /* Lux calculation constants */
38 #define TSL2772_LUX_CALC_OVER_FLOW	65535
39 
40 /*
41  * TAOS Register definitions - Note: depending on device, some of these register
42  * are not used and the register address is benign.
43  */
44 
45 /* Register offsets */
46 #define TSL2772_MAX_CONFIG_REG		16
47 
48 /* Device Registers and Masks */
49 #define TSL2772_CNTRL			0x00
50 #define TSL2772_ALS_TIME		0X01
51 #define TSL2772_PRX_TIME		0x02
52 #define TSL2772_WAIT_TIME		0x03
53 #define TSL2772_ALS_MINTHRESHLO		0X04
54 #define TSL2772_ALS_MINTHRESHHI		0X05
55 #define TSL2772_ALS_MAXTHRESHLO		0X06
56 #define TSL2772_ALS_MAXTHRESHHI		0X07
57 #define TSL2772_PRX_MINTHRESHLO		0X08
58 #define TSL2772_PRX_MINTHRESHHI		0X09
59 #define TSL2772_PRX_MAXTHRESHLO		0X0A
60 #define TSL2772_PRX_MAXTHRESHHI		0X0B
61 #define TSL2772_PERSISTENCE		0x0C
62 #define TSL2772_ALS_PRX_CONFIG		0x0D
63 #define TSL2772_PRX_COUNT		0x0E
64 #define TSL2772_GAIN			0x0F
65 #define TSL2772_NOTUSED			0x10
66 #define TSL2772_REVID			0x11
67 #define TSL2772_CHIPID			0x12
68 #define TSL2772_STATUS			0x13
69 #define TSL2772_ALS_CHAN0LO		0x14
70 #define TSL2772_ALS_CHAN0HI		0x15
71 #define TSL2772_ALS_CHAN1LO		0x16
72 #define TSL2772_ALS_CHAN1HI		0x17
73 #define TSL2772_PRX_LO			0x18
74 #define TSL2772_PRX_HI			0x19
75 
76 /* tsl2772 cmd reg masks */
77 #define TSL2772_CMD_REG			0x80
78 #define TSL2772_CMD_SPL_FN		0x60
79 #define TSL2772_CMD_REPEAT_PROTO	0x00
80 #define TSL2772_CMD_AUTOINC_PROTO	0x20
81 
82 #define TSL2772_CMD_PROX_INT_CLR	0X05
83 #define TSL2772_CMD_ALS_INT_CLR		0x06
84 #define TSL2772_CMD_PROXALS_INT_CLR	0X07
85 
86 /* tsl2772 cntrl reg masks */
87 #define TSL2772_CNTL_ADC_ENBL		0x02
88 #define TSL2772_CNTL_PWR_ON		0x01
89 
90 /* tsl2772 status reg masks */
91 #define TSL2772_STA_ADC_VALID		0x01
92 #define TSL2772_STA_PRX_VALID		0x02
93 #define TSL2772_STA_ADC_PRX_VALID	(TSL2772_STA_ADC_VALID | \
94 					 TSL2772_STA_PRX_VALID)
95 #define TSL2772_STA_ALS_INTR		0x10
96 #define TSL2772_STA_PRX_INTR		0x20
97 
98 /* tsl2772 cntrl reg masks */
99 #define TSL2772_CNTL_REG_CLEAR		0x00
100 #define TSL2772_CNTL_PROX_INT_ENBL	0X20
101 #define TSL2772_CNTL_ALS_INT_ENBL	0X10
102 #define TSL2772_CNTL_WAIT_TMR_ENBL	0X08
103 #define TSL2772_CNTL_PROX_DET_ENBL	0X04
104 #define TSL2772_CNTL_PWRON		0x01
105 #define TSL2772_CNTL_ALSPON_ENBL	0x03
106 #define TSL2772_CNTL_INTALSPON_ENBL	0x13
107 #define TSL2772_CNTL_PROXPON_ENBL	0x0F
108 #define TSL2772_CNTL_INTPROXPON_ENBL	0x2F
109 
110 #define TSL2772_ALS_GAIN_TRIM_MIN	250
111 #define TSL2772_ALS_GAIN_TRIM_MAX	4000
112 
113 #define TSL2772_MAX_PROX_LEDS		2
114 
115 #define TSL2772_BOOT_MIN_SLEEP_TIME	10000
116 #define TSL2772_BOOT_MAX_SLEEP_TIME	28000
117 
118 /* Device family members */
119 enum {
120 	tsl2571,
121 	tsl2671,
122 	tmd2671,
123 	tsl2771,
124 	tmd2771,
125 	tsl2572,
126 	tsl2672,
127 	tmd2672,
128 	tsl2772,
129 	tmd2772,
130 	apds9930,
131 };
132 
133 enum {
134 	TSL2772_CHIP_UNKNOWN = 0,
135 	TSL2772_CHIP_WORKING = 1,
136 	TSL2772_CHIP_SUSPENDED = 2
137 };
138 
139 enum {
140 	TSL2772_SUPPLY_VDD = 0,
141 	TSL2772_SUPPLY_VDDIO = 1,
142 	TSL2772_NUM_SUPPLIES = 2
143 };
144 
145 /* Per-device data */
146 struct tsl2772_als_info {
147 	u16 als_ch0;
148 	u16 als_ch1;
149 	u16 lux;
150 };
151 
152 struct tsl2772_chip_info {
153 	int chan_table_elements;
154 	struct iio_chan_spec channel_with_events[4];
155 	struct iio_chan_spec channel_without_events[4];
156 	const struct iio_info *info;
157 };
158 
159 static const int tsl2772_led_currents[][2] = {
160 	{ 100000, TSL2772_100_mA },
161 	{  50000, TSL2772_50_mA },
162 	{  25000, TSL2772_25_mA },
163 	{  13000, TSL2772_13_mA },
164 	{      0, 0 }
165 };
166 
167 struct tsl2772_chip {
168 	kernel_ulong_t id;
169 	struct mutex prox_mutex;
170 	struct mutex als_mutex;
171 	struct i2c_client *client;
172 	struct regulator_bulk_data supplies[TSL2772_NUM_SUPPLIES];
173 	u16 prox_data;
174 	struct tsl2772_als_info als_cur_info;
175 	struct tsl2772_settings settings;
176 	struct tsl2772_platform_data *pdata;
177 	int als_gain_time_scale;
178 	int als_saturation;
179 	int tsl2772_chip_status;
180 	u8 tsl2772_config[TSL2772_MAX_CONFIG_REG];
181 	const struct tsl2772_chip_info	*chip_info;
182 	const struct iio_info *info;
183 	s64 event_timestamp;
184 	/*
185 	 * This structure is intentionally large to accommodate
186 	 * updates via sysfs.
187 	 * Sized to 9 = max 8 segments + 1 termination segment
188 	 */
189 	struct tsl2772_lux tsl2772_device_lux[TSL2772_MAX_LUX_TABLE_SIZE];
190 };
191 
192 /*
193  * Different devices require different coefficents, and these numbers were
194  * derived from the 'Lux Equation' section of the various device datasheets.
195  * All of these coefficients assume a Glass Attenuation (GA) factor of 1.
196  * The coefficients are multiplied by 1000 to avoid floating point operations.
197  * The two rows in each table correspond to the Lux1 and Lux2 equations from
198  * the datasheets.
199  */
200 static const struct tsl2772_lux tsl2x71_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
201 	{ 53000, 106000 },
202 	{ 31800,  53000 },
203 	{ 0,          0 },
204 };
205 
206 static const struct tsl2772_lux tmd2x71_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
207 	{ 24000,  48000 },
208 	{ 14400,  24000 },
209 	{ 0,          0 },
210 };
211 
212 static const struct tsl2772_lux tsl2x72_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
213 	{ 60000, 112200 },
214 	{ 37800,  60000 },
215 	{     0,      0 },
216 };
217 
218 static const struct tsl2772_lux tmd2x72_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
219 	{ 20000,  35000 },
220 	{ 12600,  20000 },
221 	{     0,      0 },
222 };
223 
224 static const struct tsl2772_lux apds9930_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
225 	{ 52000,  96824 },
226 	{ 38792,  67132 },
227 	{     0,      0 },
228 };
229 
230 static const struct tsl2772_lux *tsl2772_default_lux_table_group[] = {
231 	[tsl2571] = tsl2x71_lux_table,
232 	[tsl2671] = tsl2x71_lux_table,
233 	[tmd2671] = tmd2x71_lux_table,
234 	[tsl2771] = tsl2x71_lux_table,
235 	[tmd2771] = tmd2x71_lux_table,
236 	[tsl2572] = tsl2x72_lux_table,
237 	[tsl2672] = tsl2x72_lux_table,
238 	[tmd2672] = tmd2x72_lux_table,
239 	[tsl2772] = tsl2x72_lux_table,
240 	[tmd2772] = tmd2x72_lux_table,
241 	[apds9930] = apds9930_lux_table,
242 };
243 
244 static const struct tsl2772_settings tsl2772_default_settings = {
245 	.als_time = 255, /* 2.72 / 2.73 ms */
246 	.als_gain = 0,
247 	.prox_time = 255, /* 2.72 / 2.73 ms */
248 	.prox_gain = 0,
249 	.wait_time = 255,
250 	.als_prox_config = 0,
251 	.als_gain_trim = 1000,
252 	.als_cal_target = 150,
253 	.als_persistence = 1,
254 	.als_interrupt_en = false,
255 	.als_thresh_low = 200,
256 	.als_thresh_high = 256,
257 	.prox_persistence = 1,
258 	.prox_interrupt_en = false,
259 	.prox_thres_low  = 0,
260 	.prox_thres_high = 512,
261 	.prox_max_samples_cal = 30,
262 	.prox_pulse_count = 8,
263 	.prox_diode = TSL2772_DIODE1,
264 	.prox_power = TSL2772_100_mA
265 };
266 
267 static const s16 tsl2772_als_gain[] = {
268 	1,
269 	8,
270 	16,
271 	120
272 };
273 
274 static const s16 tsl2772_prox_gain[] = {
275 	1,
276 	2,
277 	4,
278 	8
279 };
280 
281 static const int tsl2772_int_time_avail[][6] = {
282 	[tsl2571] = { 0, 2720, 0, 2720, 0, 696000 },
283 	[tsl2671] = { 0, 2720, 0, 2720, 0, 696000 },
284 	[tmd2671] = { 0, 2720, 0, 2720, 0, 696000 },
285 	[tsl2771] = { 0, 2720, 0, 2720, 0, 696000 },
286 	[tmd2771] = { 0, 2720, 0, 2720, 0, 696000 },
287 	[tsl2572] = { 0, 2730, 0, 2730, 0, 699000 },
288 	[tsl2672] = { 0, 2730, 0, 2730, 0, 699000 },
289 	[tmd2672] = { 0, 2730, 0, 2730, 0, 699000 },
290 	[tsl2772] = { 0, 2730, 0, 2730, 0, 699000 },
291 	[tmd2772] = { 0, 2730, 0, 2730, 0, 699000 },
292 	[apds9930] = { 0, 2730, 0, 2730, 0, 699000 },
293 };
294 
295 static int tsl2772_int_calibscale_avail[] = { 1, 8, 16, 120 };
296 
297 static int tsl2772_prox_calibscale_avail[] = { 1, 2, 4, 8 };
298 
299 /* Channel variations */
300 enum {
301 	ALS,
302 	PRX,
303 	ALSPRX,
304 	PRX2,
305 	ALSPRX2,
306 };
307 
308 static const u8 device_channel_config[] = {
309 	[tsl2571] = ALS,
310 	[tsl2671] = PRX,
311 	[tmd2671] = PRX,
312 	[tsl2771] = ALSPRX,
313 	[tmd2771] = ALSPRX,
314 	[tsl2572] = ALS,
315 	[tsl2672] = PRX2,
316 	[tmd2672] = PRX2,
317 	[tsl2772] = ALSPRX2,
318 	[tmd2772] = ALSPRX2,
319 	[apds9930] = ALSPRX2,
320 };
321 
tsl2772_read_status(struct tsl2772_chip * chip)322 static int tsl2772_read_status(struct tsl2772_chip *chip)
323 {
324 	int ret;
325 
326 	ret = i2c_smbus_read_byte_data(chip->client,
327 				       TSL2772_CMD_REG | TSL2772_STATUS);
328 	if (ret < 0)
329 		dev_err(&chip->client->dev,
330 			"%s: failed to read STATUS register: %d\n", __func__,
331 			ret);
332 
333 	return ret;
334 }
335 
tsl2772_write_control_reg(struct tsl2772_chip * chip,u8 data)336 static int tsl2772_write_control_reg(struct tsl2772_chip *chip, u8 data)
337 {
338 	int ret;
339 
340 	ret = i2c_smbus_write_byte_data(chip->client,
341 					TSL2772_CMD_REG | TSL2772_CNTRL, data);
342 	if (ret < 0) {
343 		dev_err(&chip->client->dev,
344 			"%s: failed to write to control register %x: %d\n",
345 			__func__, data, ret);
346 	}
347 
348 	return ret;
349 }
350 
tsl2772_read_autoinc_regs(struct tsl2772_chip * chip,int lower_reg,int upper_reg)351 static int tsl2772_read_autoinc_regs(struct tsl2772_chip *chip, int lower_reg,
352 				     int upper_reg)
353 {
354 	u8 buf[2];
355 	int ret;
356 
357 	ret = i2c_smbus_write_byte(chip->client,
358 				   TSL2772_CMD_REG | TSL2772_CMD_AUTOINC_PROTO |
359 				   lower_reg);
360 	if (ret < 0) {
361 		dev_err(&chip->client->dev,
362 			"%s: failed to enable auto increment protocol: %d\n",
363 			__func__, ret);
364 		return ret;
365 	}
366 
367 	ret = i2c_smbus_read_byte_data(chip->client,
368 				       TSL2772_CMD_REG | lower_reg);
369 	if (ret < 0) {
370 		dev_err(&chip->client->dev,
371 			"%s: failed to read from register %x: %d\n", __func__,
372 			lower_reg, ret);
373 		return ret;
374 	}
375 	buf[0] = ret;
376 
377 	ret = i2c_smbus_read_byte_data(chip->client,
378 				       TSL2772_CMD_REG | upper_reg);
379 	if (ret < 0) {
380 		dev_err(&chip->client->dev,
381 			"%s: failed to read from register %x: %d\n", __func__,
382 			upper_reg, ret);
383 		return ret;
384 	}
385 	buf[1] = ret;
386 
387 	ret = i2c_smbus_write_byte(chip->client,
388 				   TSL2772_CMD_REG | TSL2772_CMD_REPEAT_PROTO |
389 				   lower_reg);
390 	if (ret < 0) {
391 		dev_err(&chip->client->dev,
392 			"%s: failed to enable repeated byte protocol: %d\n",
393 			__func__, ret);
394 		return ret;
395 	}
396 
397 	return le16_to_cpup((const __le16 *)&buf[0]);
398 }
399 
400 /**
401  * tsl2772_get_lux() - Reads and calculates current lux value.
402  * @indio_dev:	pointer to IIO device
403  *
404  * The raw ch0 and ch1 values of the ambient light sensed in the last
405  * integration cycle are read from the device. The raw values are multiplied
406  * by a device-specific scale factor, and divided by the integration time and
407  * device gain. The code supports multiple lux equations through the lux table
408  * coefficients. A lux gain trim is applied to each lux equation, and then the
409  * maximum lux within the interval 0..65535 is selected.
410  */
tsl2772_get_lux(struct iio_dev * indio_dev)411 static int tsl2772_get_lux(struct iio_dev *indio_dev)
412 {
413 	struct tsl2772_chip *chip = iio_priv(indio_dev);
414 	struct tsl2772_lux *p;
415 	int max_lux, ret;
416 	bool overflow;
417 
418 	mutex_lock(&chip->als_mutex);
419 
420 	if (chip->tsl2772_chip_status != TSL2772_CHIP_WORKING) {
421 		dev_err(&chip->client->dev, "%s: device is not enabled\n",
422 			__func__);
423 		ret = -EBUSY;
424 		goto out_unlock;
425 	}
426 
427 	ret = tsl2772_read_status(chip);
428 	if (ret < 0)
429 		goto out_unlock;
430 
431 	if (!(ret & TSL2772_STA_ADC_VALID)) {
432 		dev_err(&chip->client->dev,
433 			"%s: data not valid yet\n", __func__);
434 		ret = chip->als_cur_info.lux; /* return LAST VALUE */
435 		goto out_unlock;
436 	}
437 
438 	ret = tsl2772_read_autoinc_regs(chip, TSL2772_ALS_CHAN0LO,
439 					TSL2772_ALS_CHAN0HI);
440 	if (ret < 0)
441 		goto out_unlock;
442 	chip->als_cur_info.als_ch0 = ret;
443 
444 	ret = tsl2772_read_autoinc_regs(chip, TSL2772_ALS_CHAN1LO,
445 					TSL2772_ALS_CHAN1HI);
446 	if (ret < 0)
447 		goto out_unlock;
448 	chip->als_cur_info.als_ch1 = ret;
449 
450 	if (chip->als_cur_info.als_ch0 >= chip->als_saturation) {
451 		max_lux = TSL2772_LUX_CALC_OVER_FLOW;
452 		goto update_struct_with_max_lux;
453 	}
454 
455 	if (!chip->als_cur_info.als_ch0) {
456 		/* have no data, so return LAST VALUE */
457 		ret = chip->als_cur_info.lux;
458 		goto out_unlock;
459 	}
460 
461 	max_lux = 0;
462 	overflow = false;
463 	for (p = (struct tsl2772_lux *)chip->tsl2772_device_lux; p->ch0 != 0;
464 	     p++) {
465 		int lux;
466 
467 		lux = ((chip->als_cur_info.als_ch0 * p->ch0) -
468 		       (chip->als_cur_info.als_ch1 * p->ch1)) /
469 			chip->als_gain_time_scale;
470 
471 		/*
472 		 * The als_gain_trim can have a value within the range 250..4000
473 		 * and is a multiplier for the lux. A trim of 1000 makes no
474 		 * changes to the lux, less than 1000 scales it down, and
475 		 * greater than 1000 scales it up.
476 		 */
477 		lux = (lux * chip->settings.als_gain_trim) / 1000;
478 
479 		if (lux > TSL2772_LUX_CALC_OVER_FLOW) {
480 			overflow = true;
481 			continue;
482 		}
483 
484 		max_lux = max(max_lux, lux);
485 	}
486 
487 	if (overflow && max_lux == 0)
488 		max_lux = TSL2772_LUX_CALC_OVER_FLOW;
489 
490 update_struct_with_max_lux:
491 	chip->als_cur_info.lux = max_lux;
492 	ret = max_lux;
493 
494 out_unlock:
495 	mutex_unlock(&chip->als_mutex);
496 
497 	return ret;
498 }
499 
500 /**
501  * tsl2772_get_prox() - Reads proximity data registers and updates
502  *                      chip->prox_data.
503  *
504  * @indio_dev:	pointer to IIO device
505  */
tsl2772_get_prox(struct iio_dev * indio_dev)506 static int tsl2772_get_prox(struct iio_dev *indio_dev)
507 {
508 	struct tsl2772_chip *chip = iio_priv(indio_dev);
509 	int ret;
510 
511 	mutex_lock(&chip->prox_mutex);
512 
513 	ret = tsl2772_read_status(chip);
514 	if (ret < 0)
515 		goto prox_poll_err;
516 
517 	switch (chip->id) {
518 	case tsl2571:
519 	case tsl2671:
520 	case tmd2671:
521 	case tsl2771:
522 	case tmd2771:
523 		if (!(ret & TSL2772_STA_ADC_VALID)) {
524 			ret = -EINVAL;
525 			goto prox_poll_err;
526 		}
527 		break;
528 	case tsl2572:
529 	case tsl2672:
530 	case tmd2672:
531 	case tsl2772:
532 	case tmd2772:
533 	case apds9930:
534 		if (!(ret & TSL2772_STA_PRX_VALID)) {
535 			ret = -EINVAL;
536 			goto prox_poll_err;
537 		}
538 		break;
539 	}
540 
541 	ret = tsl2772_read_autoinc_regs(chip, TSL2772_PRX_LO, TSL2772_PRX_HI);
542 	if (ret < 0)
543 		goto prox_poll_err;
544 	chip->prox_data = ret;
545 
546 prox_poll_err:
547 	mutex_unlock(&chip->prox_mutex);
548 
549 	return ret;
550 }
551 
tsl2772_read_prox_led_current(struct tsl2772_chip * chip)552 static int tsl2772_read_prox_led_current(struct tsl2772_chip *chip)
553 {
554 	struct device *dev = &chip->client->dev;
555 	int ret, tmp, i;
556 
557 	ret = device_property_read_u32(dev, "led-max-microamp", &tmp);
558 	if (ret < 0)
559 		return ret;
560 
561 	for (i = 0; tsl2772_led_currents[i][0] != 0; i++) {
562 		if (tmp == tsl2772_led_currents[i][0]) {
563 			chip->settings.prox_power = tsl2772_led_currents[i][1];
564 			return 0;
565 		}
566 	}
567 
568 	dev_err(dev, "Invalid value %d for led-max-microamp\n", tmp);
569 
570 	return -EINVAL;
571 }
572 
tsl2772_read_prox_diodes(struct tsl2772_chip * chip)573 static int tsl2772_read_prox_diodes(struct tsl2772_chip *chip)
574 {
575 	struct device *dev = &chip->client->dev;
576 	int i, ret, num_leds, prox_diode_mask;
577 	u32 leds[TSL2772_MAX_PROX_LEDS];
578 
579 	ret = device_property_count_u32(dev, "amstaos,proximity-diodes");
580 	if (ret < 0)
581 		return ret;
582 
583 	num_leds = ret;
584 	if (num_leds > TSL2772_MAX_PROX_LEDS)
585 		num_leds = TSL2772_MAX_PROX_LEDS;
586 
587 	ret = device_property_read_u32_array(dev, "amstaos,proximity-diodes", leds, num_leds);
588 	if (ret < 0) {
589 		dev_err(dev, "Invalid value for amstaos,proximity-diodes: %d.\n", ret);
590 		return ret;
591 	}
592 
593 	prox_diode_mask = 0;
594 	for (i = 0; i < num_leds; i++) {
595 		if (leds[i] == 0)
596 			prox_diode_mask |= TSL2772_DIODE0;
597 		else if (leds[i] == 1)
598 			prox_diode_mask |= TSL2772_DIODE1;
599 		else {
600 			dev_err(dev, "Invalid value %d in amstaos,proximity-diodes.\n", leds[i]);
601 			return -EINVAL;
602 		}
603 	}
604 	chip->settings.prox_diode = prox_diode_mask;
605 
606 	return 0;
607 }
608 
tsl2772_parse_dt(struct tsl2772_chip * chip)609 static void tsl2772_parse_dt(struct tsl2772_chip *chip)
610 {
611 	tsl2772_read_prox_led_current(chip);
612 	tsl2772_read_prox_diodes(chip);
613 }
614 
615 /**
616  * tsl2772_defaults() - Populates the device nominal operating parameters
617  *                      with those provided by a 'platform' data struct or
618  *                      with prefined defaults.
619  *
620  * @chip:               pointer to device structure.
621  */
tsl2772_defaults(struct tsl2772_chip * chip)622 static void tsl2772_defaults(struct tsl2772_chip *chip)
623 {
624 	/* If Operational settings defined elsewhere.. */
625 	if (chip->pdata && chip->pdata->platform_default_settings)
626 		memcpy(&chip->settings, chip->pdata->platform_default_settings,
627 		       sizeof(tsl2772_default_settings));
628 	else
629 		memcpy(&chip->settings, &tsl2772_default_settings,
630 		       sizeof(tsl2772_default_settings));
631 
632 	/* Load up the proper lux table. */
633 	if (chip->pdata && chip->pdata->platform_lux_table[0].ch0 != 0)
634 		memcpy(chip->tsl2772_device_lux,
635 		       chip->pdata->platform_lux_table,
636 		       sizeof(chip->pdata->platform_lux_table));
637 	else
638 		memcpy(chip->tsl2772_device_lux,
639 		       tsl2772_default_lux_table_group[chip->id],
640 		       TSL2772_DEFAULT_TABLE_BYTES);
641 
642 	tsl2772_parse_dt(chip);
643 }
644 
645 /**
646  * tsl2772_als_calibrate() -	Obtain single reading and calculate
647  *                              the als_gain_trim.
648  *
649  * @indio_dev:	pointer to IIO device
650  */
tsl2772_als_calibrate(struct iio_dev * indio_dev)651 static int tsl2772_als_calibrate(struct iio_dev *indio_dev)
652 {
653 	struct tsl2772_chip *chip = iio_priv(indio_dev);
654 	int ret, lux_val;
655 
656 	ret = i2c_smbus_read_byte_data(chip->client,
657 				       TSL2772_CMD_REG | TSL2772_CNTRL);
658 	if (ret < 0) {
659 		dev_err(&chip->client->dev,
660 			"%s: failed to read from the CNTRL register\n",
661 			__func__);
662 		return ret;
663 	}
664 
665 	if ((ret & (TSL2772_CNTL_ADC_ENBL | TSL2772_CNTL_PWR_ON))
666 			!= (TSL2772_CNTL_ADC_ENBL | TSL2772_CNTL_PWR_ON)) {
667 		dev_err(&chip->client->dev,
668 			"%s: Device is not powered on and/or ADC is not enabled\n",
669 			__func__);
670 		return -EINVAL;
671 	} else if ((ret & TSL2772_STA_ADC_VALID) != TSL2772_STA_ADC_VALID) {
672 		dev_err(&chip->client->dev,
673 			"%s: The two ADC channels have not completed an integration cycle\n",
674 			__func__);
675 		return -ENODATA;
676 	}
677 
678 	lux_val = tsl2772_get_lux(indio_dev);
679 	if (lux_val < 0) {
680 		dev_err(&chip->client->dev,
681 			"%s: failed to get lux\n", __func__);
682 		return lux_val;
683 	}
684 	if (lux_val == 0)
685 		return -ERANGE;
686 
687 	ret = (chip->settings.als_cal_target * chip->settings.als_gain_trim) /
688 			lux_val;
689 	if (ret < TSL2772_ALS_GAIN_TRIM_MIN || ret > TSL2772_ALS_GAIN_TRIM_MAX)
690 		return -ERANGE;
691 
692 	chip->settings.als_gain_trim = ret;
693 
694 	return ret;
695 }
696 
tsl2772_disable_regulators_action(void * _data)697 static void tsl2772_disable_regulators_action(void *_data)
698 {
699 	struct tsl2772_chip *chip = _data;
700 
701 	regulator_bulk_disable(ARRAY_SIZE(chip->supplies), chip->supplies);
702 }
703 
tsl2772_chip_on(struct iio_dev * indio_dev)704 static int tsl2772_chip_on(struct iio_dev *indio_dev)
705 {
706 	struct tsl2772_chip *chip = iio_priv(indio_dev);
707 	int ret, i, als_count, als_time_us;
708 	u8 *dev_reg, reg_val;
709 
710 	/* Non calculated parameters */
711 	chip->tsl2772_config[TSL2772_ALS_TIME] = chip->settings.als_time;
712 	chip->tsl2772_config[TSL2772_PRX_TIME] = chip->settings.prox_time;
713 	chip->tsl2772_config[TSL2772_WAIT_TIME] = chip->settings.wait_time;
714 	chip->tsl2772_config[TSL2772_ALS_PRX_CONFIG] =
715 		chip->settings.als_prox_config;
716 
717 	chip->tsl2772_config[TSL2772_ALS_MINTHRESHLO] =
718 		(chip->settings.als_thresh_low) & 0xFF;
719 	chip->tsl2772_config[TSL2772_ALS_MINTHRESHHI] =
720 		(chip->settings.als_thresh_low >> 8) & 0xFF;
721 	chip->tsl2772_config[TSL2772_ALS_MAXTHRESHLO] =
722 		(chip->settings.als_thresh_high) & 0xFF;
723 	chip->tsl2772_config[TSL2772_ALS_MAXTHRESHHI] =
724 		(chip->settings.als_thresh_high >> 8) & 0xFF;
725 	chip->tsl2772_config[TSL2772_PERSISTENCE] =
726 		(chip->settings.prox_persistence & 0xFF) << 4 |
727 		(chip->settings.als_persistence & 0xFF);
728 
729 	chip->tsl2772_config[TSL2772_PRX_COUNT] =
730 			chip->settings.prox_pulse_count;
731 	chip->tsl2772_config[TSL2772_PRX_MINTHRESHLO] =
732 			(chip->settings.prox_thres_low) & 0xFF;
733 	chip->tsl2772_config[TSL2772_PRX_MINTHRESHHI] =
734 			(chip->settings.prox_thres_low >> 8) & 0xFF;
735 	chip->tsl2772_config[TSL2772_PRX_MAXTHRESHLO] =
736 			(chip->settings.prox_thres_high) & 0xFF;
737 	chip->tsl2772_config[TSL2772_PRX_MAXTHRESHHI] =
738 			(chip->settings.prox_thres_high >> 8) & 0xFF;
739 
740 	/* and make sure we're not already on */
741 	if (chip->tsl2772_chip_status == TSL2772_CHIP_WORKING) {
742 		/* if forcing a register update - turn off, then on */
743 		dev_info(&chip->client->dev, "device is already enabled\n");
744 		return -EINVAL;
745 	}
746 
747 	/* Set the gain based on tsl2772_settings struct */
748 	chip->tsl2772_config[TSL2772_GAIN] =
749 		(chip->settings.als_gain & 0xFF) |
750 		((chip->settings.prox_gain & 0xFF) << 2) |
751 		(chip->settings.prox_diode << 4) |
752 		(chip->settings.prox_power << 6);
753 
754 	/* set chip time scaling and saturation */
755 	als_count = 256 - chip->settings.als_time;
756 	als_time_us = als_count * tsl2772_int_time_avail[chip->id][3];
757 	chip->als_saturation = als_count * 768; /* 75% of full scale */
758 	chip->als_gain_time_scale = als_time_us *
759 		tsl2772_als_gain[chip->settings.als_gain];
760 
761 	/*
762 	 * TSL2772 Specific power-on / adc enable sequence
763 	 * Power on the device 1st.
764 	 */
765 	ret = tsl2772_write_control_reg(chip, TSL2772_CNTL_PWR_ON);
766 	if (ret < 0)
767 		return ret;
768 
769 	/*
770 	 * Use the following shadow copy for our delay before enabling ADC.
771 	 * Write all the registers.
772 	 */
773 	for (i = 0, dev_reg = chip->tsl2772_config;
774 			i < TSL2772_MAX_CONFIG_REG; i++) {
775 		int reg = TSL2772_CMD_REG + i;
776 
777 		ret = i2c_smbus_write_byte_data(chip->client, reg,
778 						*dev_reg++);
779 		if (ret < 0) {
780 			dev_err(&chip->client->dev,
781 				"%s: failed to write to register %x: %d\n",
782 				__func__, reg, ret);
783 			return ret;
784 		}
785 	}
786 
787 	/* Power-on settling time */
788 	usleep_range(3000, 3500);
789 
790 	reg_val = TSL2772_CNTL_PWR_ON | TSL2772_CNTL_ADC_ENBL |
791 		  TSL2772_CNTL_PROX_DET_ENBL;
792 	if (chip->settings.als_interrupt_en)
793 		reg_val |= TSL2772_CNTL_ALS_INT_ENBL;
794 	if (chip->settings.prox_interrupt_en)
795 		reg_val |= TSL2772_CNTL_PROX_INT_ENBL;
796 
797 	ret = tsl2772_write_control_reg(chip, reg_val);
798 	if (ret < 0)
799 		return ret;
800 
801 	ret = i2c_smbus_write_byte(chip->client,
802 				   TSL2772_CMD_REG | TSL2772_CMD_SPL_FN |
803 				   TSL2772_CMD_PROXALS_INT_CLR);
804 	if (ret < 0) {
805 		dev_err(&chip->client->dev,
806 			"%s: failed to clear interrupt status: %d\n",
807 			__func__, ret);
808 		return ret;
809 	}
810 
811 	chip->tsl2772_chip_status = TSL2772_CHIP_WORKING;
812 
813 	return ret;
814 }
815 
tsl2772_chip_off(struct iio_dev * indio_dev)816 static int tsl2772_chip_off(struct iio_dev *indio_dev)
817 {
818 	struct tsl2772_chip *chip = iio_priv(indio_dev);
819 
820 	/* turn device off */
821 	chip->tsl2772_chip_status = TSL2772_CHIP_SUSPENDED;
822 	return tsl2772_write_control_reg(chip, 0x00);
823 }
824 
tsl2772_chip_off_action(void * data)825 static void tsl2772_chip_off_action(void *data)
826 {
827 	struct iio_dev *indio_dev = data;
828 
829 	tsl2772_chip_off(indio_dev);
830 }
831 
832 /**
833  * tsl2772_invoke_change - power cycle the device to implement the user
834  *                         parameters
835  * @indio_dev:	pointer to IIO device
836  *
837  * Obtain and lock both ALS and PROX resources, determine and save device state
838  * (On/Off), cycle device to implement updated parameter, put device back into
839  * proper state, and unlock resource.
840  */
tsl2772_invoke_change(struct iio_dev * indio_dev)841 static int tsl2772_invoke_change(struct iio_dev *indio_dev)
842 {
843 	struct tsl2772_chip *chip = iio_priv(indio_dev);
844 	int device_status = chip->tsl2772_chip_status;
845 	int ret;
846 
847 	mutex_lock(&chip->als_mutex);
848 	mutex_lock(&chip->prox_mutex);
849 
850 	if (device_status == TSL2772_CHIP_WORKING) {
851 		ret = tsl2772_chip_off(indio_dev);
852 		if (ret < 0)
853 			goto unlock;
854 	}
855 
856 	ret = tsl2772_chip_on(indio_dev);
857 
858 unlock:
859 	mutex_unlock(&chip->prox_mutex);
860 	mutex_unlock(&chip->als_mutex);
861 
862 	return ret;
863 }
864 
tsl2772_prox_cal(struct iio_dev * indio_dev)865 static int tsl2772_prox_cal(struct iio_dev *indio_dev)
866 {
867 	struct tsl2772_chip *chip = iio_priv(indio_dev);
868 	int prox_history[MAX_SAMPLES_CAL + 1];
869 	int i, ret, mean, max, sample_sum;
870 
871 	if (chip->settings.prox_max_samples_cal < 1 ||
872 	    chip->settings.prox_max_samples_cal > MAX_SAMPLES_CAL)
873 		return -EINVAL;
874 
875 	for (i = 0; i < chip->settings.prox_max_samples_cal; i++) {
876 		usleep_range(15000, 17500);
877 		ret = tsl2772_get_prox(indio_dev);
878 		if (ret < 0)
879 			return ret;
880 
881 		prox_history[i] = chip->prox_data;
882 	}
883 
884 	sample_sum = 0;
885 	max = INT_MIN;
886 	for (i = 0; i < chip->settings.prox_max_samples_cal; i++) {
887 		sample_sum += prox_history[i];
888 		max = max(max, prox_history[i]);
889 	}
890 	mean = sample_sum / chip->settings.prox_max_samples_cal;
891 
892 	chip->settings.prox_thres_high = (max << 1) - mean;
893 
894 	return tsl2772_invoke_change(indio_dev);
895 }
896 
tsl2772_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)897 static int tsl2772_read_avail(struct iio_dev *indio_dev,
898 			      struct iio_chan_spec const *chan,
899 			      const int **vals, int *type, int *length,
900 			      long mask)
901 {
902 	struct tsl2772_chip *chip = iio_priv(indio_dev);
903 
904 	switch (mask) {
905 	case IIO_CHAN_INFO_CALIBSCALE:
906 		if (chan->type == IIO_INTENSITY) {
907 			*length = ARRAY_SIZE(tsl2772_int_calibscale_avail);
908 			*vals = tsl2772_int_calibscale_avail;
909 		} else {
910 			*length = ARRAY_SIZE(tsl2772_prox_calibscale_avail);
911 			*vals = tsl2772_prox_calibscale_avail;
912 		}
913 		*type = IIO_VAL_INT;
914 		return IIO_AVAIL_LIST;
915 	case IIO_CHAN_INFO_INT_TIME:
916 		*length = ARRAY_SIZE(tsl2772_int_time_avail[chip->id]);
917 		*vals = tsl2772_int_time_avail[chip->id];
918 		*type = IIO_VAL_INT_PLUS_MICRO;
919 		return IIO_AVAIL_RANGE;
920 	}
921 
922 	return -EINVAL;
923 }
924 
in_illuminance0_target_input_show(struct device * dev,struct device_attribute * attr,char * buf)925 static ssize_t in_illuminance0_target_input_show(struct device *dev,
926 						 struct device_attribute *attr,
927 						 char *buf)
928 {
929 	struct tsl2772_chip *chip = iio_priv(dev_to_iio_dev(dev));
930 
931 	return scnprintf(buf, PAGE_SIZE, "%d\n", chip->settings.als_cal_target);
932 }
933 
in_illuminance0_target_input_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)934 static ssize_t in_illuminance0_target_input_store(struct device *dev,
935 						  struct device_attribute *attr,
936 						  const char *buf, size_t len)
937 {
938 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
939 	struct tsl2772_chip *chip = iio_priv(indio_dev);
940 	u16 value;
941 	int ret;
942 
943 	if (kstrtou16(buf, 0, &value))
944 		return -EINVAL;
945 
946 	chip->settings.als_cal_target = value;
947 	ret = tsl2772_invoke_change(indio_dev);
948 	if (ret < 0)
949 		return ret;
950 
951 	return len;
952 }
953 
in_illuminance0_calibrate_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)954 static ssize_t in_illuminance0_calibrate_store(struct device *dev,
955 					       struct device_attribute *attr,
956 					       const char *buf, size_t len)
957 {
958 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
959 	bool value;
960 	int ret;
961 
962 	if (kstrtobool(buf, &value) || !value)
963 		return -EINVAL;
964 
965 	ret = tsl2772_als_calibrate(indio_dev);
966 	if (ret < 0)
967 		return ret;
968 
969 	ret = tsl2772_invoke_change(indio_dev);
970 	if (ret < 0)
971 		return ret;
972 
973 	return len;
974 }
975 
in_illuminance0_lux_table_show(struct device * dev,struct device_attribute * attr,char * buf)976 static ssize_t in_illuminance0_lux_table_show(struct device *dev,
977 					      struct device_attribute *attr,
978 					      char *buf)
979 {
980 	struct tsl2772_chip *chip = iio_priv(dev_to_iio_dev(dev));
981 	int i = 0;
982 	int offset = 0;
983 
984 	while (i < TSL2772_MAX_LUX_TABLE_SIZE) {
985 		offset += scnprintf(buf + offset, PAGE_SIZE - offset, "%u,%u,",
986 			chip->tsl2772_device_lux[i].ch0,
987 			chip->tsl2772_device_lux[i].ch1);
988 		if (chip->tsl2772_device_lux[i].ch0 == 0) {
989 			/*
990 			 * We just printed the first "0" entry.
991 			 * Now get rid of the extra "," and break.
992 			 */
993 			offset--;
994 			break;
995 		}
996 		i++;
997 	}
998 
999 	offset += scnprintf(buf + offset, PAGE_SIZE - offset, "\n");
1000 	return offset;
1001 }
1002 
in_illuminance0_lux_table_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1003 static ssize_t in_illuminance0_lux_table_store(struct device *dev,
1004 					       struct device_attribute *attr,
1005 					       const char *buf, size_t len)
1006 {
1007 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1008 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1009 	int value[ARRAY_SIZE(chip->tsl2772_device_lux) * 2 + 1];
1010 	int n, ret;
1011 
1012 	get_options(buf, ARRAY_SIZE(value), value);
1013 
1014 	/*
1015 	 * We now have an array of ints starting at value[1], and
1016 	 * enumerated by value[0].
1017 	 * We expect each group of two ints to be one table entry,
1018 	 * and the last table entry is all 0.
1019 	 */
1020 	n = value[0];
1021 	if ((n % 2) || n < 4 ||
1022 	    n > ((ARRAY_SIZE(chip->tsl2772_device_lux) - 1) * 2))
1023 		return -EINVAL;
1024 
1025 	if ((value[(n - 1)] | value[n]) != 0)
1026 		return -EINVAL;
1027 
1028 	if (chip->tsl2772_chip_status == TSL2772_CHIP_WORKING) {
1029 		ret = tsl2772_chip_off(indio_dev);
1030 		if (ret < 0)
1031 			return ret;
1032 	}
1033 
1034 	/* Zero out the table */
1035 	memset(chip->tsl2772_device_lux, 0, sizeof(chip->tsl2772_device_lux));
1036 	memcpy(chip->tsl2772_device_lux, &value[1], (value[0] * 4));
1037 
1038 	ret = tsl2772_invoke_change(indio_dev);
1039 	if (ret < 0)
1040 		return ret;
1041 
1042 	return len;
1043 }
1044 
in_proximity0_calibrate_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1045 static ssize_t in_proximity0_calibrate_store(struct device *dev,
1046 					     struct device_attribute *attr,
1047 					     const char *buf, size_t len)
1048 {
1049 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1050 	bool value;
1051 	int ret;
1052 
1053 	if (kstrtobool(buf, &value) || !value)
1054 		return -EINVAL;
1055 
1056 	ret = tsl2772_prox_cal(indio_dev);
1057 	if (ret < 0)
1058 		return ret;
1059 
1060 	ret = tsl2772_invoke_change(indio_dev);
1061 	if (ret < 0)
1062 		return ret;
1063 
1064 	return len;
1065 }
1066 
tsl2772_read_interrupt_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)1067 static int tsl2772_read_interrupt_config(struct iio_dev *indio_dev,
1068 					 const struct iio_chan_spec *chan,
1069 					 enum iio_event_type type,
1070 					 enum iio_event_direction dir)
1071 {
1072 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1073 
1074 	if (chan->type == IIO_INTENSITY)
1075 		return chip->settings.als_interrupt_en;
1076 	else
1077 		return chip->settings.prox_interrupt_en;
1078 }
1079 
tsl2772_write_interrupt_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,int val)1080 static int tsl2772_write_interrupt_config(struct iio_dev *indio_dev,
1081 					  const struct iio_chan_spec *chan,
1082 					  enum iio_event_type type,
1083 					  enum iio_event_direction dir,
1084 					  int val)
1085 {
1086 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1087 
1088 	if (chan->type == IIO_INTENSITY)
1089 		chip->settings.als_interrupt_en = val ? true : false;
1090 	else
1091 		chip->settings.prox_interrupt_en = val ? true : false;
1092 
1093 	return tsl2772_invoke_change(indio_dev);
1094 }
1095 
tsl2772_write_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)1096 static int tsl2772_write_event_value(struct iio_dev *indio_dev,
1097 				     const struct iio_chan_spec *chan,
1098 				     enum iio_event_type type,
1099 				     enum iio_event_direction dir,
1100 				     enum iio_event_info info,
1101 				     int val, int val2)
1102 {
1103 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1104 	int ret = -EINVAL, count, persistence;
1105 	u8 time;
1106 
1107 	switch (info) {
1108 	case IIO_EV_INFO_VALUE:
1109 		if (chan->type == IIO_INTENSITY) {
1110 			switch (dir) {
1111 			case IIO_EV_DIR_RISING:
1112 				chip->settings.als_thresh_high = val;
1113 				ret = 0;
1114 				break;
1115 			case IIO_EV_DIR_FALLING:
1116 				chip->settings.als_thresh_low = val;
1117 				ret = 0;
1118 				break;
1119 			default:
1120 				break;
1121 			}
1122 		} else {
1123 			switch (dir) {
1124 			case IIO_EV_DIR_RISING:
1125 				chip->settings.prox_thres_high = val;
1126 				ret = 0;
1127 				break;
1128 			case IIO_EV_DIR_FALLING:
1129 				chip->settings.prox_thres_low = val;
1130 				ret = 0;
1131 				break;
1132 			default:
1133 				break;
1134 			}
1135 		}
1136 		break;
1137 	case IIO_EV_INFO_PERIOD:
1138 		if (chan->type == IIO_INTENSITY)
1139 			time = chip->settings.als_time;
1140 		else
1141 			time = chip->settings.prox_time;
1142 
1143 		count = 256 - time;
1144 		persistence = ((val * 1000000) + val2) /
1145 			(count * tsl2772_int_time_avail[chip->id][3]);
1146 
1147 		if (chan->type == IIO_INTENSITY) {
1148 			/* ALS filter values are 1, 2, 3, 5, 10, 15, ..., 60 */
1149 			if (persistence > 3)
1150 				persistence = (persistence / 5) + 3;
1151 
1152 			chip->settings.als_persistence = persistence;
1153 		} else {
1154 			chip->settings.prox_persistence = persistence;
1155 		}
1156 
1157 		ret = 0;
1158 		break;
1159 	default:
1160 		break;
1161 	}
1162 
1163 	if (ret < 0)
1164 		return ret;
1165 
1166 	return tsl2772_invoke_change(indio_dev);
1167 }
1168 
tsl2772_read_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)1169 static int tsl2772_read_event_value(struct iio_dev *indio_dev,
1170 				    const struct iio_chan_spec *chan,
1171 				    enum iio_event_type type,
1172 				    enum iio_event_direction dir,
1173 				    enum iio_event_info info,
1174 				    int *val, int *val2)
1175 {
1176 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1177 	int filter_delay, persistence;
1178 	u8 time;
1179 
1180 	switch (info) {
1181 	case IIO_EV_INFO_VALUE:
1182 		if (chan->type == IIO_INTENSITY) {
1183 			switch (dir) {
1184 			case IIO_EV_DIR_RISING:
1185 				*val = chip->settings.als_thresh_high;
1186 				return IIO_VAL_INT;
1187 			case IIO_EV_DIR_FALLING:
1188 				*val = chip->settings.als_thresh_low;
1189 				return IIO_VAL_INT;
1190 			default:
1191 				return -EINVAL;
1192 			}
1193 		} else {
1194 			switch (dir) {
1195 			case IIO_EV_DIR_RISING:
1196 				*val = chip->settings.prox_thres_high;
1197 				return IIO_VAL_INT;
1198 			case IIO_EV_DIR_FALLING:
1199 				*val = chip->settings.prox_thres_low;
1200 				return IIO_VAL_INT;
1201 			default:
1202 				return -EINVAL;
1203 			}
1204 		}
1205 		break;
1206 	case IIO_EV_INFO_PERIOD:
1207 		if (chan->type == IIO_INTENSITY) {
1208 			time = chip->settings.als_time;
1209 			persistence = chip->settings.als_persistence;
1210 
1211 			/* ALS filter values are 1, 2, 3, 5, 10, 15, ..., 60 */
1212 			if (persistence > 3)
1213 				persistence = (persistence - 3) * 5;
1214 		} else {
1215 			time = chip->settings.prox_time;
1216 			persistence = chip->settings.prox_persistence;
1217 		}
1218 
1219 		filter_delay = persistence * (256 - time) *
1220 			tsl2772_int_time_avail[chip->id][3];
1221 
1222 		*val = filter_delay / 1000000;
1223 		*val2 = filter_delay % 1000000;
1224 		return IIO_VAL_INT_PLUS_MICRO;
1225 	default:
1226 		return -EINVAL;
1227 	}
1228 }
1229 
tsl2772_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)1230 static int tsl2772_read_raw(struct iio_dev *indio_dev,
1231 			    struct iio_chan_spec const *chan,
1232 			    int *val,
1233 			    int *val2,
1234 			    long mask)
1235 {
1236 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1237 
1238 	switch (mask) {
1239 	case IIO_CHAN_INFO_PROCESSED:
1240 		switch (chan->type) {
1241 		case IIO_LIGHT:
1242 			tsl2772_get_lux(indio_dev);
1243 			*val = chip->als_cur_info.lux;
1244 			return IIO_VAL_INT;
1245 		default:
1246 			return -EINVAL;
1247 		}
1248 	case IIO_CHAN_INFO_RAW:
1249 		switch (chan->type) {
1250 		case IIO_INTENSITY:
1251 			tsl2772_get_lux(indio_dev);
1252 			if (chan->channel == 0)
1253 				*val = chip->als_cur_info.als_ch0;
1254 			else
1255 				*val = chip->als_cur_info.als_ch1;
1256 			return IIO_VAL_INT;
1257 		case IIO_PROXIMITY:
1258 			tsl2772_get_prox(indio_dev);
1259 			*val = chip->prox_data;
1260 			return IIO_VAL_INT;
1261 		default:
1262 			return -EINVAL;
1263 		}
1264 		break;
1265 	case IIO_CHAN_INFO_CALIBSCALE:
1266 		if (chan->type == IIO_LIGHT)
1267 			*val = tsl2772_als_gain[chip->settings.als_gain];
1268 		else
1269 			*val = tsl2772_prox_gain[chip->settings.prox_gain];
1270 		return IIO_VAL_INT;
1271 	case IIO_CHAN_INFO_CALIBBIAS:
1272 		*val = chip->settings.als_gain_trim;
1273 		return IIO_VAL_INT;
1274 	case IIO_CHAN_INFO_INT_TIME:
1275 		*val = 0;
1276 		*val2 = (256 - chip->settings.als_time) *
1277 			tsl2772_int_time_avail[chip->id][3];
1278 		return IIO_VAL_INT_PLUS_MICRO;
1279 	default:
1280 		return -EINVAL;
1281 	}
1282 }
1283 
tsl2772_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)1284 static int tsl2772_write_raw(struct iio_dev *indio_dev,
1285 			     struct iio_chan_spec const *chan,
1286 			     int val,
1287 			     int val2,
1288 			     long mask)
1289 {
1290 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1291 
1292 	switch (mask) {
1293 	case IIO_CHAN_INFO_CALIBSCALE:
1294 		if (chan->type == IIO_INTENSITY) {
1295 			switch (val) {
1296 			case 1:
1297 				chip->settings.als_gain = 0;
1298 				break;
1299 			case 8:
1300 				chip->settings.als_gain = 1;
1301 				break;
1302 			case 16:
1303 				chip->settings.als_gain = 2;
1304 				break;
1305 			case 120:
1306 				chip->settings.als_gain = 3;
1307 				break;
1308 			default:
1309 				return -EINVAL;
1310 			}
1311 		} else {
1312 			switch (val) {
1313 			case 1:
1314 				chip->settings.prox_gain = 0;
1315 				break;
1316 			case 2:
1317 				chip->settings.prox_gain = 1;
1318 				break;
1319 			case 4:
1320 				chip->settings.prox_gain = 2;
1321 				break;
1322 			case 8:
1323 				chip->settings.prox_gain = 3;
1324 				break;
1325 			default:
1326 				return -EINVAL;
1327 			}
1328 		}
1329 		break;
1330 	case IIO_CHAN_INFO_CALIBBIAS:
1331 		if (val < TSL2772_ALS_GAIN_TRIM_MIN ||
1332 		    val > TSL2772_ALS_GAIN_TRIM_MAX)
1333 			return -EINVAL;
1334 
1335 		chip->settings.als_gain_trim = val;
1336 		break;
1337 	case IIO_CHAN_INFO_INT_TIME:
1338 		if (val != 0 || val2 < tsl2772_int_time_avail[chip->id][1] ||
1339 		    val2 > tsl2772_int_time_avail[chip->id][5])
1340 			return -EINVAL;
1341 
1342 		chip->settings.als_time = 256 -
1343 			(val2 / tsl2772_int_time_avail[chip->id][3]);
1344 		break;
1345 	default:
1346 		return -EINVAL;
1347 	}
1348 
1349 	return tsl2772_invoke_change(indio_dev);
1350 }
1351 
1352 static DEVICE_ATTR_RW(in_illuminance0_target_input);
1353 
1354 static DEVICE_ATTR_WO(in_illuminance0_calibrate);
1355 
1356 static DEVICE_ATTR_WO(in_proximity0_calibrate);
1357 
1358 static DEVICE_ATTR_RW(in_illuminance0_lux_table);
1359 
1360 /* Use the default register values to identify the Taos device */
tsl2772_device_id_verif(int id,int target)1361 static int tsl2772_device_id_verif(int id, int target)
1362 {
1363 	switch (target) {
1364 	case tsl2571:
1365 	case tsl2671:
1366 	case tsl2771:
1367 		return (id & 0xf0) == TRITON_ID;
1368 	case tmd2671:
1369 	case tmd2771:
1370 		return (id & 0xf0) == HALIBUT_ID;
1371 	case tsl2572:
1372 	case tsl2672:
1373 	case tmd2672:
1374 	case tsl2772:
1375 	case tmd2772:
1376 	case apds9930:
1377 		return (id & 0xf0) == SWORDFISH_ID;
1378 	}
1379 
1380 	return -EINVAL;
1381 }
1382 
tsl2772_event_handler(int irq,void * private)1383 static irqreturn_t tsl2772_event_handler(int irq, void *private)
1384 {
1385 	struct iio_dev *indio_dev = private;
1386 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1387 	s64 timestamp = iio_get_time_ns(indio_dev);
1388 	int ret;
1389 
1390 	ret = tsl2772_read_status(chip);
1391 	if (ret < 0)
1392 		return IRQ_HANDLED;
1393 
1394 	/* What type of interrupt do we need to process */
1395 	if (ret & TSL2772_STA_PRX_INTR) {
1396 		iio_push_event(indio_dev,
1397 			       IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY,
1398 						    0,
1399 						    IIO_EV_TYPE_THRESH,
1400 						    IIO_EV_DIR_EITHER),
1401 			       timestamp);
1402 	}
1403 
1404 	if (ret & TSL2772_STA_ALS_INTR) {
1405 		iio_push_event(indio_dev,
1406 			       IIO_UNMOD_EVENT_CODE(IIO_LIGHT,
1407 						    0,
1408 						    IIO_EV_TYPE_THRESH,
1409 						    IIO_EV_DIR_EITHER),
1410 			       timestamp);
1411 	}
1412 
1413 	ret = i2c_smbus_write_byte(chip->client,
1414 				   TSL2772_CMD_REG | TSL2772_CMD_SPL_FN |
1415 				   TSL2772_CMD_PROXALS_INT_CLR);
1416 	if (ret < 0)
1417 		dev_err(&chip->client->dev,
1418 			"%s: failed to clear interrupt status: %d\n",
1419 			__func__, ret);
1420 
1421 	return IRQ_HANDLED;
1422 }
1423 
1424 static struct attribute *tsl2772_ALS_device_attrs[] = {
1425 	&dev_attr_in_illuminance0_target_input.attr,
1426 	&dev_attr_in_illuminance0_calibrate.attr,
1427 	&dev_attr_in_illuminance0_lux_table.attr,
1428 	NULL
1429 };
1430 
1431 static struct attribute *tsl2772_PRX_device_attrs[] = {
1432 	&dev_attr_in_proximity0_calibrate.attr,
1433 	NULL
1434 };
1435 
1436 static struct attribute *tsl2772_ALSPRX_device_attrs[] = {
1437 	&dev_attr_in_illuminance0_target_input.attr,
1438 	&dev_attr_in_illuminance0_calibrate.attr,
1439 	&dev_attr_in_illuminance0_lux_table.attr,
1440 	NULL
1441 };
1442 
1443 static struct attribute *tsl2772_PRX2_device_attrs[] = {
1444 	&dev_attr_in_proximity0_calibrate.attr,
1445 	NULL
1446 };
1447 
1448 static struct attribute *tsl2772_ALSPRX2_device_attrs[] = {
1449 	&dev_attr_in_illuminance0_target_input.attr,
1450 	&dev_attr_in_illuminance0_calibrate.attr,
1451 	&dev_attr_in_illuminance0_lux_table.attr,
1452 	&dev_attr_in_proximity0_calibrate.attr,
1453 	NULL
1454 };
1455 
1456 static const struct attribute_group tsl2772_device_attr_group_tbl[] = {
1457 	[ALS] = {
1458 		.attrs = tsl2772_ALS_device_attrs,
1459 	},
1460 	[PRX] = {
1461 		.attrs = tsl2772_PRX_device_attrs,
1462 	},
1463 	[ALSPRX] = {
1464 		.attrs = tsl2772_ALSPRX_device_attrs,
1465 	},
1466 	[PRX2] = {
1467 		.attrs = tsl2772_PRX2_device_attrs,
1468 	},
1469 	[ALSPRX2] = {
1470 		.attrs = tsl2772_ALSPRX2_device_attrs,
1471 	},
1472 };
1473 
1474 #define TSL2772_DEVICE_INFO(type)[type] = \
1475 	{ \
1476 		.attrs = &tsl2772_device_attr_group_tbl[type], \
1477 		.read_raw = &tsl2772_read_raw, \
1478 		.read_avail = &tsl2772_read_avail, \
1479 		.write_raw = &tsl2772_write_raw, \
1480 		.read_event_value = &tsl2772_read_event_value, \
1481 		.write_event_value = &tsl2772_write_event_value, \
1482 		.read_event_config = &tsl2772_read_interrupt_config, \
1483 		.write_event_config = &tsl2772_write_interrupt_config, \
1484 	}
1485 
1486 static const struct iio_info tsl2772_device_info[] = {
1487 	TSL2772_DEVICE_INFO(ALS),
1488 	TSL2772_DEVICE_INFO(PRX),
1489 	TSL2772_DEVICE_INFO(ALSPRX),
1490 	TSL2772_DEVICE_INFO(PRX2),
1491 	TSL2772_DEVICE_INFO(ALSPRX2),
1492 };
1493 
1494 static const struct iio_event_spec tsl2772_events[] = {
1495 	{
1496 		.type = IIO_EV_TYPE_THRESH,
1497 		.dir = IIO_EV_DIR_RISING,
1498 		.mask_separate = BIT(IIO_EV_INFO_VALUE),
1499 	}, {
1500 		.type = IIO_EV_TYPE_THRESH,
1501 		.dir = IIO_EV_DIR_FALLING,
1502 		.mask_separate = BIT(IIO_EV_INFO_VALUE),
1503 	}, {
1504 		.type = IIO_EV_TYPE_THRESH,
1505 		.dir = IIO_EV_DIR_EITHER,
1506 		.mask_separate = BIT(IIO_EV_INFO_PERIOD) |
1507 			BIT(IIO_EV_INFO_ENABLE),
1508 	},
1509 };
1510 
1511 static const struct tsl2772_chip_info tsl2772_chip_info_tbl[] = {
1512 	[ALS] = {
1513 		.channel_with_events = {
1514 			{
1515 			.type = IIO_LIGHT,
1516 			.indexed = 1,
1517 			.channel = 0,
1518 			.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1519 			}, {
1520 			.type = IIO_INTENSITY,
1521 			.indexed = 1,
1522 			.channel = 0,
1523 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1524 				BIT(IIO_CHAN_INFO_INT_TIME) |
1525 				BIT(IIO_CHAN_INFO_CALIBSCALE) |
1526 				BIT(IIO_CHAN_INFO_CALIBBIAS),
1527 			.info_mask_separate_available =
1528 				BIT(IIO_CHAN_INFO_INT_TIME) |
1529 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1530 			.event_spec = tsl2772_events,
1531 			.num_event_specs = ARRAY_SIZE(tsl2772_events),
1532 			}, {
1533 			.type = IIO_INTENSITY,
1534 			.indexed = 1,
1535 			.channel = 1,
1536 			},
1537 		},
1538 		.channel_without_events = {
1539 			{
1540 			.type = IIO_LIGHT,
1541 			.indexed = 1,
1542 			.channel = 0,
1543 			.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1544 			}, {
1545 			.type = IIO_INTENSITY,
1546 			.indexed = 1,
1547 			.channel = 0,
1548 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1549 				BIT(IIO_CHAN_INFO_INT_TIME) |
1550 				BIT(IIO_CHAN_INFO_CALIBSCALE) |
1551 				BIT(IIO_CHAN_INFO_CALIBBIAS),
1552 			.info_mask_separate_available =
1553 				BIT(IIO_CHAN_INFO_INT_TIME) |
1554 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1555 			}, {
1556 			.type = IIO_INTENSITY,
1557 			.indexed = 1,
1558 			.channel = 1,
1559 			},
1560 		},
1561 		.chan_table_elements = 3,
1562 		.info = &tsl2772_device_info[ALS],
1563 	},
1564 	[PRX] = {
1565 		.channel_with_events = {
1566 			{
1567 			.type = IIO_PROXIMITY,
1568 			.indexed = 1,
1569 			.channel = 0,
1570 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1571 			.event_spec = tsl2772_events,
1572 			.num_event_specs = ARRAY_SIZE(tsl2772_events),
1573 			},
1574 		},
1575 		.channel_without_events = {
1576 			{
1577 			.type = IIO_PROXIMITY,
1578 			.indexed = 1,
1579 			.channel = 0,
1580 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1581 			},
1582 		},
1583 		.chan_table_elements = 1,
1584 		.info = &tsl2772_device_info[PRX],
1585 	},
1586 	[ALSPRX] = {
1587 		.channel_with_events = {
1588 			{
1589 			.type = IIO_LIGHT,
1590 			.indexed = 1,
1591 			.channel = 0,
1592 			.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1593 			}, {
1594 			.type = IIO_INTENSITY,
1595 			.indexed = 1,
1596 			.channel = 0,
1597 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1598 				BIT(IIO_CHAN_INFO_INT_TIME) |
1599 				BIT(IIO_CHAN_INFO_CALIBSCALE) |
1600 				BIT(IIO_CHAN_INFO_CALIBBIAS),
1601 			.info_mask_separate_available =
1602 				BIT(IIO_CHAN_INFO_INT_TIME) |
1603 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1604 			.event_spec = tsl2772_events,
1605 			.num_event_specs = ARRAY_SIZE(tsl2772_events),
1606 			}, {
1607 			.type = IIO_INTENSITY,
1608 			.indexed = 1,
1609 			.channel = 1,
1610 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1611 			}, {
1612 			.type = IIO_PROXIMITY,
1613 			.indexed = 1,
1614 			.channel = 0,
1615 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1616 			.event_spec = tsl2772_events,
1617 			.num_event_specs = ARRAY_SIZE(tsl2772_events),
1618 			},
1619 		},
1620 		.channel_without_events = {
1621 			{
1622 			.type = IIO_LIGHT,
1623 			.indexed = 1,
1624 			.channel = 0,
1625 			.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1626 			}, {
1627 			.type = IIO_INTENSITY,
1628 			.indexed = 1,
1629 			.channel = 0,
1630 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1631 				BIT(IIO_CHAN_INFO_INT_TIME) |
1632 				BIT(IIO_CHAN_INFO_CALIBSCALE) |
1633 				BIT(IIO_CHAN_INFO_CALIBBIAS),
1634 			.info_mask_separate_available =
1635 				BIT(IIO_CHAN_INFO_INT_TIME) |
1636 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1637 			}, {
1638 			.type = IIO_INTENSITY,
1639 			.indexed = 1,
1640 			.channel = 1,
1641 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1642 			}, {
1643 			.type = IIO_PROXIMITY,
1644 			.indexed = 1,
1645 			.channel = 0,
1646 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1647 			},
1648 		},
1649 		.chan_table_elements = 4,
1650 		.info = &tsl2772_device_info[ALSPRX],
1651 	},
1652 	[PRX2] = {
1653 		.channel_with_events = {
1654 			{
1655 			.type = IIO_PROXIMITY,
1656 			.indexed = 1,
1657 			.channel = 0,
1658 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1659 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1660 			.info_mask_separate_available =
1661 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1662 			.event_spec = tsl2772_events,
1663 			.num_event_specs = ARRAY_SIZE(tsl2772_events),
1664 			},
1665 		},
1666 		.channel_without_events = {
1667 			{
1668 			.type = IIO_PROXIMITY,
1669 			.indexed = 1,
1670 			.channel = 0,
1671 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1672 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1673 			.info_mask_separate_available =
1674 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1675 			},
1676 		},
1677 		.chan_table_elements = 1,
1678 		.info = &tsl2772_device_info[PRX2],
1679 	},
1680 	[ALSPRX2] = {
1681 		.channel_with_events = {
1682 			{
1683 			.type = IIO_LIGHT,
1684 			.indexed = 1,
1685 			.channel = 0,
1686 			.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1687 			}, {
1688 			.type = IIO_INTENSITY,
1689 			.indexed = 1,
1690 			.channel = 0,
1691 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1692 				BIT(IIO_CHAN_INFO_INT_TIME) |
1693 				BIT(IIO_CHAN_INFO_CALIBSCALE) |
1694 				BIT(IIO_CHAN_INFO_CALIBBIAS),
1695 			.info_mask_separate_available =
1696 				BIT(IIO_CHAN_INFO_INT_TIME) |
1697 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1698 			.event_spec = tsl2772_events,
1699 			.num_event_specs = ARRAY_SIZE(tsl2772_events),
1700 			}, {
1701 			.type = IIO_INTENSITY,
1702 			.indexed = 1,
1703 			.channel = 1,
1704 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1705 			}, {
1706 			.type = IIO_PROXIMITY,
1707 			.indexed = 1,
1708 			.channel = 0,
1709 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1710 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1711 			.info_mask_separate_available =
1712 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1713 			.event_spec = tsl2772_events,
1714 			.num_event_specs = ARRAY_SIZE(tsl2772_events),
1715 			},
1716 		},
1717 		.channel_without_events = {
1718 			{
1719 			.type = IIO_LIGHT,
1720 			.indexed = 1,
1721 			.channel = 0,
1722 			.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1723 			}, {
1724 			.type = IIO_INTENSITY,
1725 			.indexed = 1,
1726 			.channel = 0,
1727 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1728 				BIT(IIO_CHAN_INFO_INT_TIME) |
1729 				BIT(IIO_CHAN_INFO_CALIBSCALE) |
1730 				BIT(IIO_CHAN_INFO_CALIBBIAS),
1731 			.info_mask_separate_available =
1732 				BIT(IIO_CHAN_INFO_INT_TIME) |
1733 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1734 			}, {
1735 			.type = IIO_INTENSITY,
1736 			.indexed = 1,
1737 			.channel = 1,
1738 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1739 			}, {
1740 			.type = IIO_PROXIMITY,
1741 			.indexed = 1,
1742 			.channel = 0,
1743 			.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1744 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1745 			.info_mask_separate_available =
1746 				BIT(IIO_CHAN_INFO_CALIBSCALE),
1747 			},
1748 		},
1749 		.chan_table_elements = 4,
1750 		.info = &tsl2772_device_info[ALSPRX2],
1751 	},
1752 };
1753 
tsl2772_probe(struct i2c_client * clientp)1754 static int tsl2772_probe(struct i2c_client *clientp)
1755 {
1756 	const struct i2c_device_id *id = i2c_client_get_device_id(clientp);
1757 	struct iio_dev *indio_dev;
1758 	struct tsl2772_chip *chip;
1759 	int ret;
1760 
1761 	indio_dev = devm_iio_device_alloc(&clientp->dev, sizeof(*chip));
1762 	if (!indio_dev)
1763 		return -ENOMEM;
1764 
1765 	chip = iio_priv(indio_dev);
1766 	chip->client = clientp;
1767 	i2c_set_clientdata(clientp, indio_dev);
1768 
1769 	chip->supplies[TSL2772_SUPPLY_VDD].supply = "vdd";
1770 	chip->supplies[TSL2772_SUPPLY_VDDIO].supply = "vddio";
1771 
1772 	ret = devm_regulator_bulk_get(&clientp->dev,
1773 				      ARRAY_SIZE(chip->supplies),
1774 				      chip->supplies);
1775 	if (ret < 0)
1776 		return dev_err_probe(&clientp->dev, ret, "Failed to get regulators\n");
1777 
1778 	ret = regulator_bulk_enable(ARRAY_SIZE(chip->supplies), chip->supplies);
1779 	if (ret < 0) {
1780 		dev_err(&clientp->dev, "Failed to enable regulators: %d\n",
1781 			ret);
1782 		return ret;
1783 	}
1784 
1785 	ret = devm_add_action_or_reset(&clientp->dev,
1786 					tsl2772_disable_regulators_action,
1787 					chip);
1788 	if (ret < 0) {
1789 		dev_err(&clientp->dev, "Failed to setup regulator cleanup action %d\n",
1790 			ret);
1791 		return ret;
1792 	}
1793 
1794 	usleep_range(TSL2772_BOOT_MIN_SLEEP_TIME, TSL2772_BOOT_MAX_SLEEP_TIME);
1795 
1796 	ret = i2c_smbus_read_byte_data(chip->client,
1797 				       TSL2772_CMD_REG | TSL2772_CHIPID);
1798 	if (ret < 0)
1799 		return ret;
1800 
1801 	if (tsl2772_device_id_verif(ret, id->driver_data) <= 0) {
1802 		dev_info(&chip->client->dev,
1803 			 "%s: i2c device found does not match expected id\n",
1804 				__func__);
1805 		return -EINVAL;
1806 	}
1807 
1808 	ret = i2c_smbus_write_byte(clientp, TSL2772_CMD_REG | TSL2772_CNTRL);
1809 	if (ret < 0) {
1810 		dev_err(&clientp->dev,
1811 			"%s: Failed to write to CMD register: %d\n",
1812 			__func__, ret);
1813 		return ret;
1814 	}
1815 
1816 	mutex_init(&chip->als_mutex);
1817 	mutex_init(&chip->prox_mutex);
1818 
1819 	chip->tsl2772_chip_status = TSL2772_CHIP_UNKNOWN;
1820 	chip->pdata = dev_get_platdata(&clientp->dev);
1821 	chip->id = id->driver_data;
1822 	chip->chip_info =
1823 		&tsl2772_chip_info_tbl[device_channel_config[id->driver_data]];
1824 
1825 	indio_dev->info = chip->chip_info->info;
1826 	indio_dev->modes = INDIO_DIRECT_MODE;
1827 	indio_dev->name = chip->client->name;
1828 	indio_dev->num_channels = chip->chip_info->chan_table_elements;
1829 
1830 	if (clientp->irq) {
1831 		indio_dev->channels = chip->chip_info->channel_with_events;
1832 
1833 		ret = devm_request_threaded_irq(&clientp->dev, clientp->irq,
1834 						NULL,
1835 						&tsl2772_event_handler,
1836 						IRQF_TRIGGER_FALLING |
1837 						IRQF_ONESHOT,
1838 						"TSL2772_event",
1839 						indio_dev);
1840 		if (ret) {
1841 			dev_err(&clientp->dev,
1842 				"%s: irq request failed\n", __func__);
1843 			return ret;
1844 		}
1845 	} else {
1846 		indio_dev->channels = chip->chip_info->channel_without_events;
1847 	}
1848 
1849 	tsl2772_defaults(chip);
1850 	ret = tsl2772_chip_on(indio_dev);
1851 	if (ret < 0)
1852 		return ret;
1853 
1854 	ret = devm_add_action_or_reset(&clientp->dev,
1855 					tsl2772_chip_off_action,
1856 					indio_dev);
1857 	if (ret < 0)
1858 		return ret;
1859 
1860 	return devm_iio_device_register(&clientp->dev, indio_dev);
1861 }
1862 
tsl2772_suspend(struct device * dev)1863 static int tsl2772_suspend(struct device *dev)
1864 {
1865 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
1866 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1867 	int ret;
1868 
1869 	ret = tsl2772_chip_off(indio_dev);
1870 	regulator_bulk_disable(ARRAY_SIZE(chip->supplies), chip->supplies);
1871 
1872 	return ret;
1873 }
1874 
tsl2772_resume(struct device * dev)1875 static int tsl2772_resume(struct device *dev)
1876 {
1877 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
1878 	struct tsl2772_chip *chip = iio_priv(indio_dev);
1879 	int ret;
1880 
1881 	ret = regulator_bulk_enable(ARRAY_SIZE(chip->supplies), chip->supplies);
1882 	if (ret < 0)
1883 		return ret;
1884 
1885 	usleep_range(TSL2772_BOOT_MIN_SLEEP_TIME, TSL2772_BOOT_MAX_SLEEP_TIME);
1886 
1887 	return tsl2772_chip_on(indio_dev);
1888 }
1889 
1890 static const struct i2c_device_id tsl2772_idtable[] = {
1891 	{ "tsl2571", tsl2571 },
1892 	{ "tsl2671", tsl2671 },
1893 	{ "tmd2671", tmd2671 },
1894 	{ "tsl2771", tsl2771 },
1895 	{ "tmd2771", tmd2771 },
1896 	{ "tsl2572", tsl2572 },
1897 	{ "tsl2672", tsl2672 },
1898 	{ "tmd2672", tmd2672 },
1899 	{ "tsl2772", tsl2772 },
1900 	{ "tmd2772", tmd2772 },
1901 	{ "apds9930", apds9930 },
1902 	{}
1903 };
1904 
1905 MODULE_DEVICE_TABLE(i2c, tsl2772_idtable);
1906 
1907 static const struct of_device_id tsl2772_of_match[] = {
1908 	{ .compatible = "amstaos,tsl2571" },
1909 	{ .compatible = "amstaos,tsl2671" },
1910 	{ .compatible = "amstaos,tmd2671" },
1911 	{ .compatible = "amstaos,tsl2771" },
1912 	{ .compatible = "amstaos,tmd2771" },
1913 	{ .compatible = "amstaos,tsl2572" },
1914 	{ .compatible = "amstaos,tsl2672" },
1915 	{ .compatible = "amstaos,tmd2672" },
1916 	{ .compatible = "amstaos,tsl2772" },
1917 	{ .compatible = "amstaos,tmd2772" },
1918 	{ .compatible = "avago,apds9930" },
1919 	{}
1920 };
1921 MODULE_DEVICE_TABLE(of, tsl2772_of_match);
1922 
1923 static const struct dev_pm_ops tsl2772_pm_ops = {
1924 	.suspend = tsl2772_suspend,
1925 	.resume  = tsl2772_resume,
1926 };
1927 
1928 static struct i2c_driver tsl2772_driver = {
1929 	.driver = {
1930 		.name = "tsl2772",
1931 		.of_match_table = tsl2772_of_match,
1932 		.pm = &tsl2772_pm_ops,
1933 	},
1934 	.id_table = tsl2772_idtable,
1935 	.probe = tsl2772_probe,
1936 };
1937 
1938 module_i2c_driver(tsl2772_driver);
1939 
1940 MODULE_AUTHOR("J. August Brenner <Jon.Brenner@ams.com>");
1941 MODULE_AUTHOR("Brian Masney <masneyb@onstation.org>");
1942 MODULE_DESCRIPTION("TAOS tsl2772 ambient and proximity light sensor driver");
1943 MODULE_LICENSE("GPL");
1944