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
605 return 0;
606 }
607
tsl2772_parse_dt(struct tsl2772_chip * chip)608 static void tsl2772_parse_dt(struct tsl2772_chip *chip)
609 {
610 tsl2772_read_prox_led_current(chip);
611 tsl2772_read_prox_diodes(chip);
612 }
613
614 /**
615 * tsl2772_defaults() - Populates the device nominal operating parameters
616 * with those provided by a 'platform' data struct or
617 * with prefined defaults.
618 *
619 * @chip: pointer to device structure.
620 */
tsl2772_defaults(struct tsl2772_chip * chip)621 static void tsl2772_defaults(struct tsl2772_chip *chip)
622 {
623 /* If Operational settings defined elsewhere.. */
624 if (chip->pdata && chip->pdata->platform_default_settings)
625 memcpy(&chip->settings, chip->pdata->platform_default_settings,
626 sizeof(tsl2772_default_settings));
627 else
628 memcpy(&chip->settings, &tsl2772_default_settings,
629 sizeof(tsl2772_default_settings));
630
631 /* Load up the proper lux table. */
632 if (chip->pdata && chip->pdata->platform_lux_table[0].ch0 != 0)
633 memcpy(chip->tsl2772_device_lux,
634 chip->pdata->platform_lux_table,
635 sizeof(chip->pdata->platform_lux_table));
636 else
637 memcpy(chip->tsl2772_device_lux,
638 tsl2772_default_lux_table_group[chip->id],
639 TSL2772_DEFAULT_TABLE_BYTES);
640
641 tsl2772_parse_dt(chip);
642 }
643
644 /**
645 * tsl2772_als_calibrate() - Obtain single reading and calculate
646 * the als_gain_trim.
647 *
648 * @indio_dev: pointer to IIO device
649 */
tsl2772_als_calibrate(struct iio_dev * indio_dev)650 static int tsl2772_als_calibrate(struct iio_dev *indio_dev)
651 {
652 struct tsl2772_chip *chip = iio_priv(indio_dev);
653 int ret, lux_val;
654
655 ret = i2c_smbus_read_byte_data(chip->client,
656 TSL2772_CMD_REG | TSL2772_CNTRL);
657 if (ret < 0) {
658 dev_err(&chip->client->dev,
659 "%s: failed to read from the CNTRL register\n",
660 __func__);
661 return ret;
662 }
663
664 if ((ret & (TSL2772_CNTL_ADC_ENBL | TSL2772_CNTL_PWR_ON))
665 != (TSL2772_CNTL_ADC_ENBL | TSL2772_CNTL_PWR_ON)) {
666 dev_err(&chip->client->dev,
667 "%s: Device is not powered on and/or ADC is not enabled\n",
668 __func__);
669 return -EINVAL;
670 } else if ((ret & TSL2772_STA_ADC_VALID) != TSL2772_STA_ADC_VALID) {
671 dev_err(&chip->client->dev,
672 "%s: The two ADC channels have not completed an integration cycle\n",
673 __func__);
674 return -ENODATA;
675 }
676
677 lux_val = tsl2772_get_lux(indio_dev);
678 if (lux_val < 0) {
679 dev_err(&chip->client->dev,
680 "%s: failed to get lux\n", __func__);
681 return lux_val;
682 }
683 if (lux_val == 0)
684 return -ERANGE;
685
686 ret = (chip->settings.als_cal_target * chip->settings.als_gain_trim) /
687 lux_val;
688 if (ret < TSL2772_ALS_GAIN_TRIM_MIN || ret > TSL2772_ALS_GAIN_TRIM_MAX)
689 return -ERANGE;
690
691 chip->settings.als_gain_trim = ret;
692
693 return ret;
694 }
695
tsl2772_disable_regulators_action(void * _data)696 static void tsl2772_disable_regulators_action(void *_data)
697 {
698 struct tsl2772_chip *chip = _data;
699
700 regulator_bulk_disable(ARRAY_SIZE(chip->supplies), chip->supplies);
701 }
702
tsl2772_chip_on(struct iio_dev * indio_dev)703 static int tsl2772_chip_on(struct iio_dev *indio_dev)
704 {
705 struct tsl2772_chip *chip = iio_priv(indio_dev);
706 int ret, i, als_count, als_time_us;
707 u8 *dev_reg, reg_val;
708
709 /* Non calculated parameters */
710 chip->tsl2772_config[TSL2772_ALS_TIME] = chip->settings.als_time;
711 chip->tsl2772_config[TSL2772_PRX_TIME] = chip->settings.prox_time;
712 chip->tsl2772_config[TSL2772_WAIT_TIME] = chip->settings.wait_time;
713 chip->tsl2772_config[TSL2772_ALS_PRX_CONFIG] =
714 chip->settings.als_prox_config;
715
716 chip->tsl2772_config[TSL2772_ALS_MINTHRESHLO] =
717 (chip->settings.als_thresh_low) & 0xFF;
718 chip->tsl2772_config[TSL2772_ALS_MINTHRESHHI] =
719 (chip->settings.als_thresh_low >> 8) & 0xFF;
720 chip->tsl2772_config[TSL2772_ALS_MAXTHRESHLO] =
721 (chip->settings.als_thresh_high) & 0xFF;
722 chip->tsl2772_config[TSL2772_ALS_MAXTHRESHHI] =
723 (chip->settings.als_thresh_high >> 8) & 0xFF;
724 chip->tsl2772_config[TSL2772_PERSISTENCE] =
725 (chip->settings.prox_persistence & 0xFF) << 4 |
726 (chip->settings.als_persistence & 0xFF);
727
728 chip->tsl2772_config[TSL2772_PRX_COUNT] =
729 chip->settings.prox_pulse_count;
730 chip->tsl2772_config[TSL2772_PRX_MINTHRESHLO] =
731 (chip->settings.prox_thres_low) & 0xFF;
732 chip->tsl2772_config[TSL2772_PRX_MINTHRESHHI] =
733 (chip->settings.prox_thres_low >> 8) & 0xFF;
734 chip->tsl2772_config[TSL2772_PRX_MAXTHRESHLO] =
735 (chip->settings.prox_thres_high) & 0xFF;
736 chip->tsl2772_config[TSL2772_PRX_MAXTHRESHHI] =
737 (chip->settings.prox_thres_high >> 8) & 0xFF;
738
739 /* and make sure we're not already on */
740 if (chip->tsl2772_chip_status == TSL2772_CHIP_WORKING) {
741 /* if forcing a register update - turn off, then on */
742 dev_info(&chip->client->dev, "device is already enabled\n");
743 return -EINVAL;
744 }
745
746 /* Set the gain based on tsl2772_settings struct */
747 chip->tsl2772_config[TSL2772_GAIN] =
748 (chip->settings.als_gain & 0xFF) |
749 ((chip->settings.prox_gain & 0xFF) << 2) |
750 (chip->settings.prox_diode << 4) |
751 (chip->settings.prox_power << 6);
752
753 /* set chip time scaling and saturation */
754 als_count = 256 - chip->settings.als_time;
755 als_time_us = als_count * tsl2772_int_time_avail[chip->id][3];
756 chip->als_saturation = als_count * 768; /* 75% of full scale */
757 chip->als_gain_time_scale = als_time_us *
758 tsl2772_als_gain[chip->settings.als_gain];
759
760 /*
761 * TSL2772 Specific power-on / adc enable sequence
762 * Power on the device 1st.
763 */
764 ret = tsl2772_write_control_reg(chip, TSL2772_CNTL_PWR_ON);
765 if (ret < 0)
766 return ret;
767
768 /*
769 * Use the following shadow copy for our delay before enabling ADC.
770 * Write all the registers.
771 */
772 for (i = 0, dev_reg = chip->tsl2772_config;
773 i < TSL2772_MAX_CONFIG_REG; i++) {
774 int reg = TSL2772_CMD_REG + i;
775
776 ret = i2c_smbus_write_byte_data(chip->client, reg,
777 *dev_reg++);
778 if (ret < 0) {
779 dev_err(&chip->client->dev,
780 "%s: failed to write to register %x: %d\n",
781 __func__, reg, ret);
782 return ret;
783 }
784 }
785
786 /* Power-on settling time */
787 usleep_range(3000, 3500);
788
789 reg_val = TSL2772_CNTL_PWR_ON | TSL2772_CNTL_ADC_ENBL |
790 TSL2772_CNTL_PROX_DET_ENBL;
791 if (chip->settings.als_interrupt_en)
792 reg_val |= TSL2772_CNTL_ALS_INT_ENBL;
793 if (chip->settings.prox_interrupt_en)
794 reg_val |= TSL2772_CNTL_PROX_INT_ENBL;
795
796 ret = tsl2772_write_control_reg(chip, reg_val);
797 if (ret < 0)
798 return ret;
799
800 ret = i2c_smbus_write_byte(chip->client,
801 TSL2772_CMD_REG | TSL2772_CMD_SPL_FN |
802 TSL2772_CMD_PROXALS_INT_CLR);
803 if (ret < 0) {
804 dev_err(&chip->client->dev,
805 "%s: failed to clear interrupt status: %d\n",
806 __func__, ret);
807 return ret;
808 }
809
810 chip->tsl2772_chip_status = TSL2772_CHIP_WORKING;
811
812 return ret;
813 }
814
tsl2772_chip_off(struct iio_dev * indio_dev)815 static int tsl2772_chip_off(struct iio_dev *indio_dev)
816 {
817 struct tsl2772_chip *chip = iio_priv(indio_dev);
818
819 /* turn device off */
820 chip->tsl2772_chip_status = TSL2772_CHIP_SUSPENDED;
821 return tsl2772_write_control_reg(chip, 0x00);
822 }
823
tsl2772_chip_off_action(void * data)824 static void tsl2772_chip_off_action(void *data)
825 {
826 struct iio_dev *indio_dev = data;
827
828 tsl2772_chip_off(indio_dev);
829 }
830
831 /**
832 * tsl2772_invoke_change - power cycle the device to implement the user
833 * parameters
834 * @indio_dev: pointer to IIO device
835 *
836 * Obtain and lock both ALS and PROX resources, determine and save device state
837 * (On/Off), cycle device to implement updated parameter, put device back into
838 * proper state, and unlock resource.
839 */
tsl2772_invoke_change(struct iio_dev * indio_dev)840 static int tsl2772_invoke_change(struct iio_dev *indio_dev)
841 {
842 struct tsl2772_chip *chip = iio_priv(indio_dev);
843 int device_status = chip->tsl2772_chip_status;
844 int ret;
845
846 mutex_lock(&chip->als_mutex);
847 mutex_lock(&chip->prox_mutex);
848
849 if (device_status == TSL2772_CHIP_WORKING) {
850 ret = tsl2772_chip_off(indio_dev);
851 if (ret < 0)
852 goto unlock;
853 }
854
855 ret = tsl2772_chip_on(indio_dev);
856
857 unlock:
858 mutex_unlock(&chip->prox_mutex);
859 mutex_unlock(&chip->als_mutex);
860
861 return ret;
862 }
863
tsl2772_prox_cal(struct iio_dev * indio_dev)864 static int tsl2772_prox_cal(struct iio_dev *indio_dev)
865 {
866 struct tsl2772_chip *chip = iio_priv(indio_dev);
867 int prox_history[MAX_SAMPLES_CAL + 1];
868 int i, ret, mean, max, sample_sum;
869
870 if (chip->settings.prox_max_samples_cal < 1 ||
871 chip->settings.prox_max_samples_cal > MAX_SAMPLES_CAL)
872 return -EINVAL;
873
874 for (i = 0; i < chip->settings.prox_max_samples_cal; i++) {
875 usleep_range(15000, 17500);
876 ret = tsl2772_get_prox(indio_dev);
877 if (ret < 0)
878 return ret;
879
880 prox_history[i] = chip->prox_data;
881 }
882
883 sample_sum = 0;
884 max = INT_MIN;
885 for (i = 0; i < chip->settings.prox_max_samples_cal; i++) {
886 sample_sum += prox_history[i];
887 max = max(max, prox_history[i]);
888 }
889 mean = sample_sum / chip->settings.prox_max_samples_cal;
890
891 chip->settings.prox_thres_high = (max << 1) - mean;
892
893 return tsl2772_invoke_change(indio_dev);
894 }
895
tsl2772_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)896 static int tsl2772_read_avail(struct iio_dev *indio_dev,
897 struct iio_chan_spec const *chan,
898 const int **vals, int *type, int *length,
899 long mask)
900 {
901 struct tsl2772_chip *chip = iio_priv(indio_dev);
902
903 switch (mask) {
904 case IIO_CHAN_INFO_CALIBSCALE:
905 if (chan->type == IIO_INTENSITY) {
906 *length = ARRAY_SIZE(tsl2772_int_calibscale_avail);
907 *vals = tsl2772_int_calibscale_avail;
908 } else {
909 *length = ARRAY_SIZE(tsl2772_prox_calibscale_avail);
910 *vals = tsl2772_prox_calibscale_avail;
911 }
912 *type = IIO_VAL_INT;
913 return IIO_AVAIL_LIST;
914 case IIO_CHAN_INFO_INT_TIME:
915 *length = ARRAY_SIZE(tsl2772_int_time_avail[chip->id]);
916 *vals = tsl2772_int_time_avail[chip->id];
917 *type = IIO_VAL_INT_PLUS_MICRO;
918 return IIO_AVAIL_RANGE;
919 }
920
921 return -EINVAL;
922 }
923
in_illuminance0_target_input_show(struct device * dev,struct device_attribute * attr,char * buf)924 static ssize_t in_illuminance0_target_input_show(struct device *dev,
925 struct device_attribute *attr,
926 char *buf)
927 {
928 struct tsl2772_chip *chip = iio_priv(dev_to_iio_dev(dev));
929
930 return scnprintf(buf, PAGE_SIZE, "%d\n", chip->settings.als_cal_target);
931 }
932
in_illuminance0_target_input_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)933 static ssize_t in_illuminance0_target_input_store(struct device *dev,
934 struct device_attribute *attr,
935 const char *buf, size_t len)
936 {
937 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
938 struct tsl2772_chip *chip = iio_priv(indio_dev);
939 u16 value;
940 int ret;
941
942 if (kstrtou16(buf, 0, &value))
943 return -EINVAL;
944
945 chip->settings.als_cal_target = value;
946 ret = tsl2772_invoke_change(indio_dev);
947 if (ret < 0)
948 return ret;
949
950 return len;
951 }
952
in_illuminance0_calibrate_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)953 static ssize_t in_illuminance0_calibrate_store(struct device *dev,
954 struct device_attribute *attr,
955 const char *buf, size_t len)
956 {
957 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
958 bool value;
959 int ret;
960
961 if (kstrtobool(buf, &value) || !value)
962 return -EINVAL;
963
964 ret = tsl2772_als_calibrate(indio_dev);
965 if (ret < 0)
966 return ret;
967
968 ret = tsl2772_invoke_change(indio_dev);
969 if (ret < 0)
970 return ret;
971
972 return len;
973 }
974
in_illuminance0_lux_table_show(struct device * dev,struct device_attribute * attr,char * buf)975 static ssize_t in_illuminance0_lux_table_show(struct device *dev,
976 struct device_attribute *attr,
977 char *buf)
978 {
979 struct tsl2772_chip *chip = iio_priv(dev_to_iio_dev(dev));
980 int i = 0;
981 int offset = 0;
982
983 while (i < TSL2772_MAX_LUX_TABLE_SIZE) {
984 offset += scnprintf(buf + offset, PAGE_SIZE - offset, "%u,%u,",
985 chip->tsl2772_device_lux[i].ch0,
986 chip->tsl2772_device_lux[i].ch1);
987 if (chip->tsl2772_device_lux[i].ch0 == 0) {
988 /*
989 * We just printed the first "0" entry.
990 * Now get rid of the extra "," and break.
991 */
992 offset--;
993 break;
994 }
995 i++;
996 }
997
998 offset += scnprintf(buf + offset, PAGE_SIZE - offset, "\n");
999 return offset;
1000 }
1001
in_illuminance0_lux_table_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1002 static ssize_t in_illuminance0_lux_table_store(struct device *dev,
1003 struct device_attribute *attr,
1004 const char *buf, size_t len)
1005 {
1006 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1007 struct tsl2772_chip *chip = iio_priv(indio_dev);
1008 int value[ARRAY_SIZE(chip->tsl2772_device_lux) * 2 + 1];
1009 int n, ret;
1010
1011 get_options(buf, ARRAY_SIZE(value), value);
1012
1013 /*
1014 * We now have an array of ints starting at value[1], and
1015 * enumerated by value[0].
1016 * We expect each group of two ints to be one table entry,
1017 * and the last table entry is all 0.
1018 */
1019 n = value[0];
1020 if ((n % 2) || n < 4 ||
1021 n > ((ARRAY_SIZE(chip->tsl2772_device_lux) - 1) * 2))
1022 return -EINVAL;
1023
1024 if ((value[(n - 1)] | value[n]) != 0)
1025 return -EINVAL;
1026
1027 if (chip->tsl2772_chip_status == TSL2772_CHIP_WORKING) {
1028 ret = tsl2772_chip_off(indio_dev);
1029 if (ret < 0)
1030 return ret;
1031 }
1032
1033 /* Zero out the table */
1034 memset(chip->tsl2772_device_lux, 0, sizeof(chip->tsl2772_device_lux));
1035 memcpy(chip->tsl2772_device_lux, &value[1], (value[0] * 4));
1036
1037 ret = tsl2772_invoke_change(indio_dev);
1038 if (ret < 0)
1039 return ret;
1040
1041 return len;
1042 }
1043
in_proximity0_calibrate_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1044 static ssize_t in_proximity0_calibrate_store(struct device *dev,
1045 struct device_attribute *attr,
1046 const char *buf, size_t len)
1047 {
1048 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1049 bool value;
1050 int ret;
1051
1052 if (kstrtobool(buf, &value) || !value)
1053 return -EINVAL;
1054
1055 ret = tsl2772_prox_cal(indio_dev);
1056 if (ret < 0)
1057 return ret;
1058
1059 ret = tsl2772_invoke_change(indio_dev);
1060 if (ret < 0)
1061 return ret;
1062
1063 return len;
1064 }
1065
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)1066 static int tsl2772_read_interrupt_config(struct iio_dev *indio_dev,
1067 const struct iio_chan_spec *chan,
1068 enum iio_event_type type,
1069 enum iio_event_direction dir)
1070 {
1071 struct tsl2772_chip *chip = iio_priv(indio_dev);
1072
1073 if (chan->type == IIO_INTENSITY)
1074 return chip->settings.als_interrupt_en;
1075 else
1076 return chip->settings.prox_interrupt_en;
1077 }
1078
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)1079 static int tsl2772_write_interrupt_config(struct iio_dev *indio_dev,
1080 const struct iio_chan_spec *chan,
1081 enum iio_event_type type,
1082 enum iio_event_direction dir,
1083 int val)
1084 {
1085 struct tsl2772_chip *chip = iio_priv(indio_dev);
1086
1087 if (chan->type == IIO_INTENSITY)
1088 chip->settings.als_interrupt_en = val ? true : false;
1089 else
1090 chip->settings.prox_interrupt_en = val ? true : false;
1091
1092 return tsl2772_invoke_change(indio_dev);
1093 }
1094
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)1095 static int tsl2772_write_event_value(struct iio_dev *indio_dev,
1096 const struct iio_chan_spec *chan,
1097 enum iio_event_type type,
1098 enum iio_event_direction dir,
1099 enum iio_event_info info,
1100 int val, int val2)
1101 {
1102 struct tsl2772_chip *chip = iio_priv(indio_dev);
1103 int ret = -EINVAL, count, persistence;
1104 u8 time;
1105
1106 switch (info) {
1107 case IIO_EV_INFO_VALUE:
1108 if (chan->type == IIO_INTENSITY) {
1109 switch (dir) {
1110 case IIO_EV_DIR_RISING:
1111 chip->settings.als_thresh_high = val;
1112 ret = 0;
1113 break;
1114 case IIO_EV_DIR_FALLING:
1115 chip->settings.als_thresh_low = val;
1116 ret = 0;
1117 break;
1118 default:
1119 break;
1120 }
1121 } else {
1122 switch (dir) {
1123 case IIO_EV_DIR_RISING:
1124 chip->settings.prox_thres_high = val;
1125 ret = 0;
1126 break;
1127 case IIO_EV_DIR_FALLING:
1128 chip->settings.prox_thres_low = val;
1129 ret = 0;
1130 break;
1131 default:
1132 break;
1133 }
1134 }
1135 break;
1136 case IIO_EV_INFO_PERIOD:
1137 if (chan->type == IIO_INTENSITY)
1138 time = chip->settings.als_time;
1139 else
1140 time = chip->settings.prox_time;
1141
1142 count = 256 - time;
1143 persistence = ((val * 1000000) + val2) /
1144 (count * tsl2772_int_time_avail[chip->id][3]);
1145
1146 if (chan->type == IIO_INTENSITY) {
1147 /* ALS filter values are 1, 2, 3, 5, 10, 15, ..., 60 */
1148 if (persistence > 3)
1149 persistence = (persistence / 5) + 3;
1150
1151 chip->settings.als_persistence = persistence;
1152 } else {
1153 chip->settings.prox_persistence = persistence;
1154 }
1155
1156 ret = 0;
1157 break;
1158 default:
1159 break;
1160 }
1161
1162 if (ret < 0)
1163 return ret;
1164
1165 return tsl2772_invoke_change(indio_dev);
1166 }
1167
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)1168 static int tsl2772_read_event_value(struct iio_dev *indio_dev,
1169 const struct iio_chan_spec *chan,
1170 enum iio_event_type type,
1171 enum iio_event_direction dir,
1172 enum iio_event_info info,
1173 int *val, int *val2)
1174 {
1175 struct tsl2772_chip *chip = iio_priv(indio_dev);
1176 int filter_delay, persistence;
1177 u8 time;
1178
1179 switch (info) {
1180 case IIO_EV_INFO_VALUE:
1181 if (chan->type == IIO_INTENSITY) {
1182 switch (dir) {
1183 case IIO_EV_DIR_RISING:
1184 *val = chip->settings.als_thresh_high;
1185 return IIO_VAL_INT;
1186 case IIO_EV_DIR_FALLING:
1187 *val = chip->settings.als_thresh_low;
1188 return IIO_VAL_INT;
1189 default:
1190 return -EINVAL;
1191 }
1192 } else {
1193 switch (dir) {
1194 case IIO_EV_DIR_RISING:
1195 *val = chip->settings.prox_thres_high;
1196 return IIO_VAL_INT;
1197 case IIO_EV_DIR_FALLING:
1198 *val = chip->settings.prox_thres_low;
1199 return IIO_VAL_INT;
1200 default:
1201 return -EINVAL;
1202 }
1203 }
1204 break;
1205 case IIO_EV_INFO_PERIOD:
1206 if (chan->type == IIO_INTENSITY) {
1207 time = chip->settings.als_time;
1208 persistence = chip->settings.als_persistence;
1209
1210 /* ALS filter values are 1, 2, 3, 5, 10, 15, ..., 60 */
1211 if (persistence > 3)
1212 persistence = (persistence - 3) * 5;
1213 } else {
1214 time = chip->settings.prox_time;
1215 persistence = chip->settings.prox_persistence;
1216 }
1217
1218 filter_delay = persistence * (256 - time) *
1219 tsl2772_int_time_avail[chip->id][3];
1220
1221 *val = filter_delay / 1000000;
1222 *val2 = filter_delay % 1000000;
1223 return IIO_VAL_INT_PLUS_MICRO;
1224 default:
1225 return -EINVAL;
1226 }
1227 }
1228
tsl2772_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)1229 static int tsl2772_read_raw(struct iio_dev *indio_dev,
1230 struct iio_chan_spec const *chan,
1231 int *val,
1232 int *val2,
1233 long mask)
1234 {
1235 struct tsl2772_chip *chip = iio_priv(indio_dev);
1236
1237 switch (mask) {
1238 case IIO_CHAN_INFO_PROCESSED:
1239 switch (chan->type) {
1240 case IIO_LIGHT:
1241 tsl2772_get_lux(indio_dev);
1242 *val = chip->als_cur_info.lux;
1243 return IIO_VAL_INT;
1244 default:
1245 return -EINVAL;
1246 }
1247 case IIO_CHAN_INFO_RAW:
1248 switch (chan->type) {
1249 case IIO_INTENSITY:
1250 tsl2772_get_lux(indio_dev);
1251 if (chan->channel == 0)
1252 *val = chip->als_cur_info.als_ch0;
1253 else
1254 *val = chip->als_cur_info.als_ch1;
1255 return IIO_VAL_INT;
1256 case IIO_PROXIMITY:
1257 tsl2772_get_prox(indio_dev);
1258 *val = chip->prox_data;
1259 return IIO_VAL_INT;
1260 default:
1261 return -EINVAL;
1262 }
1263 break;
1264 case IIO_CHAN_INFO_CALIBSCALE:
1265 if (chan->type == IIO_LIGHT)
1266 *val = tsl2772_als_gain[chip->settings.als_gain];
1267 else
1268 *val = tsl2772_prox_gain[chip->settings.prox_gain];
1269 return IIO_VAL_INT;
1270 case IIO_CHAN_INFO_CALIBBIAS:
1271 *val = chip->settings.als_gain_trim;
1272 return IIO_VAL_INT;
1273 case IIO_CHAN_INFO_INT_TIME:
1274 *val = 0;
1275 *val2 = (256 - chip->settings.als_time) *
1276 tsl2772_int_time_avail[chip->id][3];
1277 return IIO_VAL_INT_PLUS_MICRO;
1278 default:
1279 return -EINVAL;
1280 }
1281 }
1282
tsl2772_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)1283 static int tsl2772_write_raw(struct iio_dev *indio_dev,
1284 struct iio_chan_spec const *chan,
1285 int val,
1286 int val2,
1287 long mask)
1288 {
1289 struct tsl2772_chip *chip = iio_priv(indio_dev);
1290
1291 switch (mask) {
1292 case IIO_CHAN_INFO_CALIBSCALE:
1293 if (chan->type == IIO_INTENSITY) {
1294 switch (val) {
1295 case 1:
1296 chip->settings.als_gain = 0;
1297 break;
1298 case 8:
1299 chip->settings.als_gain = 1;
1300 break;
1301 case 16:
1302 chip->settings.als_gain = 2;
1303 break;
1304 case 120:
1305 chip->settings.als_gain = 3;
1306 break;
1307 default:
1308 return -EINVAL;
1309 }
1310 } else {
1311 switch (val) {
1312 case 1:
1313 chip->settings.prox_gain = 0;
1314 break;
1315 case 2:
1316 chip->settings.prox_gain = 1;
1317 break;
1318 case 4:
1319 chip->settings.prox_gain = 2;
1320 break;
1321 case 8:
1322 chip->settings.prox_gain = 3;
1323 break;
1324 default:
1325 return -EINVAL;
1326 }
1327 }
1328 break;
1329 case IIO_CHAN_INFO_CALIBBIAS:
1330 if (val < TSL2772_ALS_GAIN_TRIM_MIN ||
1331 val > TSL2772_ALS_GAIN_TRIM_MAX)
1332 return -EINVAL;
1333
1334 chip->settings.als_gain_trim = val;
1335 break;
1336 case IIO_CHAN_INFO_INT_TIME:
1337 if (val != 0 || val2 < tsl2772_int_time_avail[chip->id][1] ||
1338 val2 > tsl2772_int_time_avail[chip->id][5])
1339 return -EINVAL;
1340
1341 chip->settings.als_time = 256 -
1342 (val2 / tsl2772_int_time_avail[chip->id][3]);
1343 break;
1344 default:
1345 return -EINVAL;
1346 }
1347
1348 return tsl2772_invoke_change(indio_dev);
1349 }
1350
1351 static DEVICE_ATTR_RW(in_illuminance0_target_input);
1352
1353 static DEVICE_ATTR_WO(in_illuminance0_calibrate);
1354
1355 static DEVICE_ATTR_WO(in_proximity0_calibrate);
1356
1357 static DEVICE_ATTR_RW(in_illuminance0_lux_table);
1358
1359 /* Use the default register values to identify the Taos device */
tsl2772_device_id_verif(int id,int target)1360 static int tsl2772_device_id_verif(int id, int target)
1361 {
1362 switch (target) {
1363 case tsl2571:
1364 case tsl2671:
1365 case tsl2771:
1366 return (id & 0xf0) == TRITON_ID;
1367 case tmd2671:
1368 case tmd2771:
1369 return (id & 0xf0) == HALIBUT_ID;
1370 case tsl2572:
1371 case tsl2672:
1372 case tmd2672:
1373 case tsl2772:
1374 case tmd2772:
1375 case apds9930:
1376 return (id & 0xf0) == SWORDFISH_ID;
1377 }
1378
1379 return -EINVAL;
1380 }
1381
tsl2772_event_handler(int irq,void * private)1382 static irqreturn_t tsl2772_event_handler(int irq, void *private)
1383 {
1384 struct iio_dev *indio_dev = private;
1385 struct tsl2772_chip *chip = iio_priv(indio_dev);
1386 s64 timestamp = iio_get_time_ns(indio_dev);
1387 int ret;
1388
1389 ret = tsl2772_read_status(chip);
1390 if (ret < 0)
1391 return IRQ_HANDLED;
1392
1393 /* What type of interrupt do we need to process */
1394 if (ret & TSL2772_STA_PRX_INTR) {
1395 iio_push_event(indio_dev,
1396 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY,
1397 0,
1398 IIO_EV_TYPE_THRESH,
1399 IIO_EV_DIR_EITHER),
1400 timestamp);
1401 }
1402
1403 if (ret & TSL2772_STA_ALS_INTR) {
1404 iio_push_event(indio_dev,
1405 IIO_UNMOD_EVENT_CODE(IIO_LIGHT,
1406 0,
1407 IIO_EV_TYPE_THRESH,
1408 IIO_EV_DIR_EITHER),
1409 timestamp);
1410 }
1411
1412 ret = i2c_smbus_write_byte(chip->client,
1413 TSL2772_CMD_REG | TSL2772_CMD_SPL_FN |
1414 TSL2772_CMD_PROXALS_INT_CLR);
1415 if (ret < 0)
1416 dev_err(&chip->client->dev,
1417 "%s: failed to clear interrupt status: %d\n",
1418 __func__, ret);
1419
1420 return IRQ_HANDLED;
1421 }
1422
1423 static struct attribute *tsl2772_ALS_device_attrs[] = {
1424 &dev_attr_in_illuminance0_target_input.attr,
1425 &dev_attr_in_illuminance0_calibrate.attr,
1426 &dev_attr_in_illuminance0_lux_table.attr,
1427 NULL
1428 };
1429
1430 static struct attribute *tsl2772_PRX_device_attrs[] = {
1431 &dev_attr_in_proximity0_calibrate.attr,
1432 NULL
1433 };
1434
1435 static struct attribute *tsl2772_ALSPRX_device_attrs[] = {
1436 &dev_attr_in_illuminance0_target_input.attr,
1437 &dev_attr_in_illuminance0_calibrate.attr,
1438 &dev_attr_in_illuminance0_lux_table.attr,
1439 NULL
1440 };
1441
1442 static struct attribute *tsl2772_PRX2_device_attrs[] = {
1443 &dev_attr_in_proximity0_calibrate.attr,
1444 NULL
1445 };
1446
1447 static struct attribute *tsl2772_ALSPRX2_device_attrs[] = {
1448 &dev_attr_in_illuminance0_target_input.attr,
1449 &dev_attr_in_illuminance0_calibrate.attr,
1450 &dev_attr_in_illuminance0_lux_table.attr,
1451 &dev_attr_in_proximity0_calibrate.attr,
1452 NULL
1453 };
1454
1455 static const struct attribute_group tsl2772_device_attr_group_tbl[] = {
1456 [ALS] = {
1457 .attrs = tsl2772_ALS_device_attrs,
1458 },
1459 [PRX] = {
1460 .attrs = tsl2772_PRX_device_attrs,
1461 },
1462 [ALSPRX] = {
1463 .attrs = tsl2772_ALSPRX_device_attrs,
1464 },
1465 [PRX2] = {
1466 .attrs = tsl2772_PRX2_device_attrs,
1467 },
1468 [ALSPRX2] = {
1469 .attrs = tsl2772_ALSPRX2_device_attrs,
1470 },
1471 };
1472
1473 #define TSL2772_DEVICE_INFO(type)[type] = \
1474 { \
1475 .attrs = &tsl2772_device_attr_group_tbl[type], \
1476 .read_raw = &tsl2772_read_raw, \
1477 .read_avail = &tsl2772_read_avail, \
1478 .write_raw = &tsl2772_write_raw, \
1479 .read_event_value = &tsl2772_read_event_value, \
1480 .write_event_value = &tsl2772_write_event_value, \
1481 .read_event_config = &tsl2772_read_interrupt_config, \
1482 .write_event_config = &tsl2772_write_interrupt_config, \
1483 }
1484
1485 static const struct iio_info tsl2772_device_info[] = {
1486 TSL2772_DEVICE_INFO(ALS),
1487 TSL2772_DEVICE_INFO(PRX),
1488 TSL2772_DEVICE_INFO(ALSPRX),
1489 TSL2772_DEVICE_INFO(PRX2),
1490 TSL2772_DEVICE_INFO(ALSPRX2),
1491 };
1492
1493 static const struct iio_event_spec tsl2772_events[] = {
1494 {
1495 .type = IIO_EV_TYPE_THRESH,
1496 .dir = IIO_EV_DIR_RISING,
1497 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1498 }, {
1499 .type = IIO_EV_TYPE_THRESH,
1500 .dir = IIO_EV_DIR_FALLING,
1501 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1502 }, {
1503 .type = IIO_EV_TYPE_THRESH,
1504 .dir = IIO_EV_DIR_EITHER,
1505 .mask_separate = BIT(IIO_EV_INFO_PERIOD) |
1506 BIT(IIO_EV_INFO_ENABLE),
1507 },
1508 };
1509
1510 static const struct tsl2772_chip_info tsl2772_chip_info_tbl[] = {
1511 [ALS] = {
1512 .channel_with_events = {
1513 {
1514 .type = IIO_LIGHT,
1515 .indexed = 1,
1516 .channel = 0,
1517 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1518 }, {
1519 .type = IIO_INTENSITY,
1520 .indexed = 1,
1521 .channel = 0,
1522 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1523 BIT(IIO_CHAN_INFO_INT_TIME) |
1524 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1525 BIT(IIO_CHAN_INFO_CALIBBIAS),
1526 .info_mask_separate_available =
1527 BIT(IIO_CHAN_INFO_INT_TIME) |
1528 BIT(IIO_CHAN_INFO_CALIBSCALE),
1529 .event_spec = tsl2772_events,
1530 .num_event_specs = ARRAY_SIZE(tsl2772_events),
1531 }, {
1532 .type = IIO_INTENSITY,
1533 .indexed = 1,
1534 .channel = 1,
1535 },
1536 },
1537 .channel_without_events = {
1538 {
1539 .type = IIO_LIGHT,
1540 .indexed = 1,
1541 .channel = 0,
1542 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1543 }, {
1544 .type = IIO_INTENSITY,
1545 .indexed = 1,
1546 .channel = 0,
1547 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1548 BIT(IIO_CHAN_INFO_INT_TIME) |
1549 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1550 BIT(IIO_CHAN_INFO_CALIBBIAS),
1551 .info_mask_separate_available =
1552 BIT(IIO_CHAN_INFO_INT_TIME) |
1553 BIT(IIO_CHAN_INFO_CALIBSCALE),
1554 }, {
1555 .type = IIO_INTENSITY,
1556 .indexed = 1,
1557 .channel = 1,
1558 },
1559 },
1560 .chan_table_elements = 3,
1561 .info = &tsl2772_device_info[ALS],
1562 },
1563 [PRX] = {
1564 .channel_with_events = {
1565 {
1566 .type = IIO_PROXIMITY,
1567 .indexed = 1,
1568 .channel = 0,
1569 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1570 .event_spec = tsl2772_events,
1571 .num_event_specs = ARRAY_SIZE(tsl2772_events),
1572 },
1573 },
1574 .channel_without_events = {
1575 {
1576 .type = IIO_PROXIMITY,
1577 .indexed = 1,
1578 .channel = 0,
1579 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1580 },
1581 },
1582 .chan_table_elements = 1,
1583 .info = &tsl2772_device_info[PRX],
1584 },
1585 [ALSPRX] = {
1586 .channel_with_events = {
1587 {
1588 .type = IIO_LIGHT,
1589 .indexed = 1,
1590 .channel = 0,
1591 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1592 }, {
1593 .type = IIO_INTENSITY,
1594 .indexed = 1,
1595 .channel = 0,
1596 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1597 BIT(IIO_CHAN_INFO_INT_TIME) |
1598 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1599 BIT(IIO_CHAN_INFO_CALIBBIAS),
1600 .info_mask_separate_available =
1601 BIT(IIO_CHAN_INFO_INT_TIME) |
1602 BIT(IIO_CHAN_INFO_CALIBSCALE),
1603 .event_spec = tsl2772_events,
1604 .num_event_specs = ARRAY_SIZE(tsl2772_events),
1605 }, {
1606 .type = IIO_INTENSITY,
1607 .indexed = 1,
1608 .channel = 1,
1609 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1610 }, {
1611 .type = IIO_PROXIMITY,
1612 .indexed = 1,
1613 .channel = 0,
1614 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1615 .event_spec = tsl2772_events,
1616 .num_event_specs = ARRAY_SIZE(tsl2772_events),
1617 },
1618 },
1619 .channel_without_events = {
1620 {
1621 .type = IIO_LIGHT,
1622 .indexed = 1,
1623 .channel = 0,
1624 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1625 }, {
1626 .type = IIO_INTENSITY,
1627 .indexed = 1,
1628 .channel = 0,
1629 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1630 BIT(IIO_CHAN_INFO_INT_TIME) |
1631 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1632 BIT(IIO_CHAN_INFO_CALIBBIAS),
1633 .info_mask_separate_available =
1634 BIT(IIO_CHAN_INFO_INT_TIME) |
1635 BIT(IIO_CHAN_INFO_CALIBSCALE),
1636 }, {
1637 .type = IIO_INTENSITY,
1638 .indexed = 1,
1639 .channel = 1,
1640 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1641 }, {
1642 .type = IIO_PROXIMITY,
1643 .indexed = 1,
1644 .channel = 0,
1645 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1646 },
1647 },
1648 .chan_table_elements = 4,
1649 .info = &tsl2772_device_info[ALSPRX],
1650 },
1651 [PRX2] = {
1652 .channel_with_events = {
1653 {
1654 .type = IIO_PROXIMITY,
1655 .indexed = 1,
1656 .channel = 0,
1657 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1658 BIT(IIO_CHAN_INFO_CALIBSCALE),
1659 .info_mask_separate_available =
1660 BIT(IIO_CHAN_INFO_CALIBSCALE),
1661 .event_spec = tsl2772_events,
1662 .num_event_specs = ARRAY_SIZE(tsl2772_events),
1663 },
1664 },
1665 .channel_without_events = {
1666 {
1667 .type = IIO_PROXIMITY,
1668 .indexed = 1,
1669 .channel = 0,
1670 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1671 BIT(IIO_CHAN_INFO_CALIBSCALE),
1672 .info_mask_separate_available =
1673 BIT(IIO_CHAN_INFO_CALIBSCALE),
1674 },
1675 },
1676 .chan_table_elements = 1,
1677 .info = &tsl2772_device_info[PRX2],
1678 },
1679 [ALSPRX2] = {
1680 .channel_with_events = {
1681 {
1682 .type = IIO_LIGHT,
1683 .indexed = 1,
1684 .channel = 0,
1685 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1686 }, {
1687 .type = IIO_INTENSITY,
1688 .indexed = 1,
1689 .channel = 0,
1690 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1691 BIT(IIO_CHAN_INFO_INT_TIME) |
1692 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1693 BIT(IIO_CHAN_INFO_CALIBBIAS),
1694 .info_mask_separate_available =
1695 BIT(IIO_CHAN_INFO_INT_TIME) |
1696 BIT(IIO_CHAN_INFO_CALIBSCALE),
1697 .event_spec = tsl2772_events,
1698 .num_event_specs = ARRAY_SIZE(tsl2772_events),
1699 }, {
1700 .type = IIO_INTENSITY,
1701 .indexed = 1,
1702 .channel = 1,
1703 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1704 }, {
1705 .type = IIO_PROXIMITY,
1706 .indexed = 1,
1707 .channel = 0,
1708 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1709 BIT(IIO_CHAN_INFO_CALIBSCALE),
1710 .info_mask_separate_available =
1711 BIT(IIO_CHAN_INFO_CALIBSCALE),
1712 .event_spec = tsl2772_events,
1713 .num_event_specs = ARRAY_SIZE(tsl2772_events),
1714 },
1715 },
1716 .channel_without_events = {
1717 {
1718 .type = IIO_LIGHT,
1719 .indexed = 1,
1720 .channel = 0,
1721 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1722 }, {
1723 .type = IIO_INTENSITY,
1724 .indexed = 1,
1725 .channel = 0,
1726 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1727 BIT(IIO_CHAN_INFO_INT_TIME) |
1728 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1729 BIT(IIO_CHAN_INFO_CALIBBIAS),
1730 .info_mask_separate_available =
1731 BIT(IIO_CHAN_INFO_INT_TIME) |
1732 BIT(IIO_CHAN_INFO_CALIBSCALE),
1733 }, {
1734 .type = IIO_INTENSITY,
1735 .indexed = 1,
1736 .channel = 1,
1737 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1738 }, {
1739 .type = IIO_PROXIMITY,
1740 .indexed = 1,
1741 .channel = 0,
1742 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1743 BIT(IIO_CHAN_INFO_CALIBSCALE),
1744 .info_mask_separate_available =
1745 BIT(IIO_CHAN_INFO_CALIBSCALE),
1746 },
1747 },
1748 .chan_table_elements = 4,
1749 .info = &tsl2772_device_info[ALSPRX2],
1750 },
1751 };
1752
tsl2772_probe(struct i2c_client * clientp)1753 static int tsl2772_probe(struct i2c_client *clientp)
1754 {
1755 const struct i2c_device_id *id = i2c_client_get_device_id(clientp);
1756 struct iio_dev *indio_dev;
1757 struct tsl2772_chip *chip;
1758 int ret;
1759
1760 indio_dev = devm_iio_device_alloc(&clientp->dev, sizeof(*chip));
1761 if (!indio_dev)
1762 return -ENOMEM;
1763
1764 chip = iio_priv(indio_dev);
1765 chip->client = clientp;
1766 i2c_set_clientdata(clientp, indio_dev);
1767
1768 chip->supplies[TSL2772_SUPPLY_VDD].supply = "vdd";
1769 chip->supplies[TSL2772_SUPPLY_VDDIO].supply = "vddio";
1770
1771 ret = devm_regulator_bulk_get(&clientp->dev,
1772 ARRAY_SIZE(chip->supplies),
1773 chip->supplies);
1774 if (ret < 0)
1775 return dev_err_probe(&clientp->dev, ret, "Failed to get regulators\n");
1776
1777 ret = regulator_bulk_enable(ARRAY_SIZE(chip->supplies), chip->supplies);
1778 if (ret < 0) {
1779 dev_err(&clientp->dev, "Failed to enable regulators: %d\n",
1780 ret);
1781 return ret;
1782 }
1783
1784 ret = devm_add_action_or_reset(&clientp->dev,
1785 tsl2772_disable_regulators_action,
1786 chip);
1787 if (ret < 0) {
1788 dev_err(&clientp->dev, "Failed to setup regulator cleanup action %d\n",
1789 ret);
1790 return ret;
1791 }
1792
1793 usleep_range(TSL2772_BOOT_MIN_SLEEP_TIME, TSL2772_BOOT_MAX_SLEEP_TIME);
1794
1795 ret = i2c_smbus_read_byte_data(chip->client,
1796 TSL2772_CMD_REG | TSL2772_CHIPID);
1797 if (ret < 0)
1798 return ret;
1799
1800 if (tsl2772_device_id_verif(ret, id->driver_data) <= 0) {
1801 dev_info(&chip->client->dev,
1802 "%s: i2c device found does not match expected id\n",
1803 __func__);
1804 return -EINVAL;
1805 }
1806
1807 ret = i2c_smbus_write_byte(clientp, TSL2772_CMD_REG | TSL2772_CNTRL);
1808 if (ret < 0) {
1809 dev_err(&clientp->dev,
1810 "%s: Failed to write to CMD register: %d\n",
1811 __func__, ret);
1812 return ret;
1813 }
1814
1815 mutex_init(&chip->als_mutex);
1816 mutex_init(&chip->prox_mutex);
1817
1818 chip->tsl2772_chip_status = TSL2772_CHIP_UNKNOWN;
1819 chip->pdata = dev_get_platdata(&clientp->dev);
1820 chip->id = id->driver_data;
1821 chip->chip_info =
1822 &tsl2772_chip_info_tbl[device_channel_config[id->driver_data]];
1823
1824 indio_dev->info = chip->chip_info->info;
1825 indio_dev->modes = INDIO_DIRECT_MODE;
1826 indio_dev->name = chip->client->name;
1827 indio_dev->num_channels = chip->chip_info->chan_table_elements;
1828
1829 if (clientp->irq) {
1830 indio_dev->channels = chip->chip_info->channel_with_events;
1831
1832 ret = devm_request_threaded_irq(&clientp->dev, clientp->irq,
1833 NULL,
1834 &tsl2772_event_handler,
1835 IRQF_TRIGGER_FALLING |
1836 IRQF_ONESHOT,
1837 "TSL2772_event",
1838 indio_dev);
1839 if (ret) {
1840 dev_err(&clientp->dev,
1841 "%s: irq request failed\n", __func__);
1842 return ret;
1843 }
1844 } else {
1845 indio_dev->channels = chip->chip_info->channel_without_events;
1846 }
1847
1848 tsl2772_defaults(chip);
1849 ret = tsl2772_chip_on(indio_dev);
1850 if (ret < 0)
1851 return ret;
1852
1853 ret = devm_add_action_or_reset(&clientp->dev,
1854 tsl2772_chip_off_action,
1855 indio_dev);
1856 if (ret < 0)
1857 return ret;
1858
1859 return devm_iio_device_register(&clientp->dev, indio_dev);
1860 }
1861
tsl2772_suspend(struct device * dev)1862 static int tsl2772_suspend(struct device *dev)
1863 {
1864 struct iio_dev *indio_dev = dev_get_drvdata(dev);
1865 struct tsl2772_chip *chip = iio_priv(indio_dev);
1866 int ret;
1867
1868 ret = tsl2772_chip_off(indio_dev);
1869 regulator_bulk_disable(ARRAY_SIZE(chip->supplies), chip->supplies);
1870
1871 return ret;
1872 }
1873
tsl2772_resume(struct device * dev)1874 static int tsl2772_resume(struct device *dev)
1875 {
1876 struct iio_dev *indio_dev = dev_get_drvdata(dev);
1877 struct tsl2772_chip *chip = iio_priv(indio_dev);
1878 int ret;
1879
1880 ret = regulator_bulk_enable(ARRAY_SIZE(chip->supplies), chip->supplies);
1881 if (ret < 0)
1882 return ret;
1883
1884 usleep_range(TSL2772_BOOT_MIN_SLEEP_TIME, TSL2772_BOOT_MAX_SLEEP_TIME);
1885
1886 return tsl2772_chip_on(indio_dev);
1887 }
1888
1889 static const struct i2c_device_id tsl2772_idtable[] = {
1890 { "tsl2571", tsl2571 },
1891 { "tsl2671", tsl2671 },
1892 { "tmd2671", tmd2671 },
1893 { "tsl2771", tsl2771 },
1894 { "tmd2771", tmd2771 },
1895 { "tsl2572", tsl2572 },
1896 { "tsl2672", tsl2672 },
1897 { "tmd2672", tmd2672 },
1898 { "tsl2772", tsl2772 },
1899 { "tmd2772", tmd2772 },
1900 { "apds9930", apds9930 },
1901 {}
1902 };
1903
1904 MODULE_DEVICE_TABLE(i2c, tsl2772_idtable);
1905
1906 static const struct of_device_id tsl2772_of_match[] = {
1907 { .compatible = "amstaos,tsl2571" },
1908 { .compatible = "amstaos,tsl2671" },
1909 { .compatible = "amstaos,tmd2671" },
1910 { .compatible = "amstaos,tsl2771" },
1911 { .compatible = "amstaos,tmd2771" },
1912 { .compatible = "amstaos,tsl2572" },
1913 { .compatible = "amstaos,tsl2672" },
1914 { .compatible = "amstaos,tmd2672" },
1915 { .compatible = "amstaos,tsl2772" },
1916 { .compatible = "amstaos,tmd2772" },
1917 { .compatible = "avago,apds9930" },
1918 {}
1919 };
1920 MODULE_DEVICE_TABLE(of, tsl2772_of_match);
1921
1922 static const struct dev_pm_ops tsl2772_pm_ops = {
1923 .suspend = tsl2772_suspend,
1924 .resume = tsl2772_resume,
1925 };
1926
1927 static struct i2c_driver tsl2772_driver = {
1928 .driver = {
1929 .name = "tsl2772",
1930 .of_match_table = tsl2772_of_match,
1931 .pm = &tsl2772_pm_ops,
1932 },
1933 .id_table = tsl2772_idtable,
1934 .probe_new = tsl2772_probe,
1935 };
1936
1937 module_i2c_driver(tsl2772_driver);
1938
1939 MODULE_AUTHOR("J. August Brenner <Jon.Brenner@ams.com>");
1940 MODULE_AUTHOR("Brian Masney <masneyb@onstation.org>");
1941 MODULE_DESCRIPTION("TAOS tsl2772 ambient and proximity light sensor driver");
1942 MODULE_LICENSE("GPL");
1943