?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/nouveau: consume the return of large GSP message
[drm/drm-misc.git] / drivers / iio / light / tsl2772.c
blob349afdcbe30dd0c4c0fbabaa16ff7832e407e8ee
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
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
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
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 */
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 */
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
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
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
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 */
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 */
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
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
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
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
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 */
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
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
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
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
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
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
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
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
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
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
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 bool 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;
1090 else
1091 chip->settings.prox_interrupt_en = val;
1092
1093 return tsl2772_invoke_change(indio_dev);
1094 }
1095
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
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
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
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 */
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
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
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
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
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");
Kernel DRM miscellaneous fixes and cross-tree changes