treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / iio / light / tsl2583.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Device driver for monitoring ambient light intensity (lux)
4  * within the TAOS tsl258x family of devices (tsl2580, tsl2581, tsl2583).
5  *
6  * Copyright (c) 2011, TAOS Corporation.
7  * Copyright (c) 2016-2017 Brian Masney <masneyb@onstation.org>
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/i2c.h>
12 #include <linux/errno.h>
13 #include <linux/delay.h>
14 #include <linux/string.h>
15 #include <linux/mutex.h>
16 #include <linux/unistd.h>
17 #include <linux/slab.h>
18 #include <linux/module.h>
19 #include <linux/iio/iio.h>
20 #include <linux/iio/sysfs.h>
21 #include <linux/pm_runtime.h>
22
23 /* Device Registers and Masks */
24 #define TSL2583_CNTRL                   0x00
25 #define TSL2583_ALS_TIME                0X01
26 #define TSL2583_INTERRUPT               0x02
27 #define TSL2583_GAIN                    0x07
28 #define TSL2583_REVID                   0x11
29 #define TSL2583_CHIPID                  0x12
30 #define TSL2583_ALS_CHAN0LO             0x14
31 #define TSL2583_ALS_CHAN0HI             0x15
32 #define TSL2583_ALS_CHAN1LO             0x16
33 #define TSL2583_ALS_CHAN1HI             0x17
34 #define TSL2583_TMR_LO                  0x18
35 #define TSL2583_TMR_HI                  0x19
36
37 /* tsl2583 cmd reg masks */
38 #define TSL2583_CMD_REG                 0x80
39 #define TSL2583_CMD_SPL_FN              0x60
40 #define TSL2583_CMD_ALS_INT_CLR         0x01
41
42 /* tsl2583 cntrl reg masks */
43 #define TSL2583_CNTL_ADC_ENBL           0x02
44 #define TSL2583_CNTL_PWR_OFF            0x00
45 #define TSL2583_CNTL_PWR_ON             0x01
46
47 /* tsl2583 status reg masks */
48 #define TSL2583_STA_ADC_VALID           0x01
49 #define TSL2583_STA_ADC_INTR            0x10
50
51 /* Lux calculation constants */
52 #define TSL2583_LUX_CALC_OVER_FLOW      65535
53
54 #define TSL2583_INTERRUPT_DISABLED      0x00
55
56 #define TSL2583_CHIP_ID                 0x90
57 #define TSL2583_CHIP_ID_MASK            0xf0
58
59 #define TSL2583_POWER_OFF_DELAY_MS      2000
60
61 /* Per-device data */
62 struct tsl2583_als_info {
63         u16 als_ch0;
64         u16 als_ch1;
65         u16 lux;
66 };
67
68 struct tsl2583_lux {
69         unsigned int ratio;
70         unsigned int ch0;
71         unsigned int ch1;
72 };
73
74 static const struct tsl2583_lux tsl2583_default_lux[] = {
75         {  9830,  8520, 15729 },
76         { 12452, 10807, 23344 },
77         { 14746,  6383, 11705 },
78         { 17695,  4063,  6554 },
79         {     0,     0,     0 }  /* Termination segment */
80 };
81
82 #define TSL2583_MAX_LUX_TABLE_ENTRIES 11
83
84 struct tsl2583_settings {
85         int als_time;
86         int als_gain;
87         int als_gain_trim;
88         int als_cal_target;
89
90         /*
91          * This structure is intentionally large to accommodate updates via
92          * sysfs. Sized to 11 = max 10 segments + 1 termination segment.
93          * Assumption is that one and only one type of glass used.
94          */
95         struct tsl2583_lux als_device_lux[TSL2583_MAX_LUX_TABLE_ENTRIES];
96 };
97
98 struct tsl2583_chip {
99         struct mutex als_mutex;
100         struct i2c_client *client;
101         struct tsl2583_als_info als_cur_info;
102         struct tsl2583_settings als_settings;
103         int als_time_scale;
104         int als_saturation;
105 };
106
107 struct gainadj {
108         s16 ch0;
109         s16 ch1;
110         s16 mean;
111 };
112
113 /* Index = (0 - 3) Used to validate the gain selection index */
114 static const struct gainadj gainadj[] = {
115         { 1, 1, 1 },
116         { 8, 8, 8 },
117         { 16, 16, 16 },
118         { 107, 115, 111 }
119 };
120
121 /*
122  * Provides initial operational parameter defaults.
123  * These defaults may be changed through the device's sysfs files.
124  */
125 static void tsl2583_defaults(struct tsl2583_chip *chip)
126 {
127         /*
128          * The integration time must be a multiple of 50ms and within the
129          * range [50, 600] ms.
130          */
131         chip->als_settings.als_time = 100;
132
133         /*
134          * This is an index into the gainadj table. Assume clear glass as the
135          * default.
136          */
137         chip->als_settings.als_gain = 0;
138
139         /* Default gain trim to account for aperture effects */
140         chip->als_settings.als_gain_trim = 1000;
141
142         /* Known external ALS reading used for calibration */
143         chip->als_settings.als_cal_target = 130;
144
145         /* Default lux table. */
146         memcpy(chip->als_settings.als_device_lux, tsl2583_default_lux,
147                sizeof(tsl2583_default_lux));
148 }
149
150 /*
151  * Reads and calculates current lux value.
152  * The raw ch0 and ch1 values of the ambient light sensed in the last
153  * integration cycle are read from the device.
154  * Time scale factor array values are adjusted based on the integration time.
155  * The raw values are multiplied by a scale factor, and device gain is obtained
156  * using gain index. Limit checks are done next, then the ratio of a multiple
157  * of ch1 value, to the ch0 value, is calculated. The array als_device_lux[]
158  * declared above is then scanned to find the first ratio value that is just
159  * above the ratio we just calculated. The ch0 and ch1 multiplier constants in
160  * the array are then used along with the time scale factor array values, to
161  * calculate the lux.
162  */
163 static int tsl2583_get_lux(struct iio_dev *indio_dev)
164 {
165         u16 ch0, ch1; /* separated ch0/ch1 data from device */
166         u32 lux; /* raw lux calculated from device data */
167         u64 lux64;
168         u32 ratio;
169         u8 buf[5];
170         struct tsl2583_lux *p;
171         struct tsl2583_chip *chip = iio_priv(indio_dev);
172         int i, ret;
173
174         ret = i2c_smbus_read_byte_data(chip->client, TSL2583_CMD_REG);
175         if (ret < 0) {
176                 dev_err(&chip->client->dev, "%s: failed to read CMD_REG register\n",
177                         __func__);
178                 goto done;
179         }
180
181         /* is data new & valid */
182         if (!(ret & TSL2583_STA_ADC_INTR)) {
183                 dev_err(&chip->client->dev, "%s: data not valid; returning last value\n",
184                         __func__);
185                 ret = chip->als_cur_info.lux; /* return LAST VALUE */
186                 goto done;
187         }
188
189         for (i = 0; i < 4; i++) {
190                 int reg = TSL2583_CMD_REG | (TSL2583_ALS_CHAN0LO + i);
191
192                 ret = i2c_smbus_read_byte_data(chip->client, reg);
193                 if (ret < 0) {
194                         dev_err(&chip->client->dev, "%s: failed to read register %x\n",
195                                 __func__, reg);
196                         goto done;
197                 }
198                 buf[i] = ret;
199         }
200
201         /*
202          * Clear the pending interrupt status bit on the chip to allow the next
203          * integration cycle to start. This has to be done even though this
204          * driver currently does not support interrupts.
205          */
206         ret = i2c_smbus_write_byte(chip->client,
207                                    (TSL2583_CMD_REG | TSL2583_CMD_SPL_FN |
208                                     TSL2583_CMD_ALS_INT_CLR));
209         if (ret < 0) {
210                 dev_err(&chip->client->dev, "%s: failed to clear the interrupt bit\n",
211                         __func__);
212                 goto done; /* have no data, so return failure */
213         }
214
215         /* extract ALS/lux data */
216         ch0 = le16_to_cpup((const __le16 *)&buf[0]);
217         ch1 = le16_to_cpup((const __le16 *)&buf[2]);
218
219         chip->als_cur_info.als_ch0 = ch0;
220         chip->als_cur_info.als_ch1 = ch1;
221
222         if ((ch0 >= chip->als_saturation) || (ch1 >= chip->als_saturation))
223                 goto return_max;
224
225         if (!ch0) {
226                 /*
227                  * The sensor appears to be in total darkness so set the
228                  * calculated lux to 0 and return early to avoid a division by
229                  * zero below when calculating the ratio.
230                  */
231                 ret = 0;
232                 chip->als_cur_info.lux = 0;
233                 goto done;
234         }
235
236         /* calculate ratio */
237         ratio = (ch1 << 15) / ch0;
238
239         /* convert to unscaled lux using the pointer to the table */
240         for (p = (struct tsl2583_lux *)chip->als_settings.als_device_lux;
241              p->ratio != 0 && p->ratio < ratio; p++)
242                 ;
243
244         if (p->ratio == 0) {
245                 lux = 0;
246         } else {
247                 u32 ch0lux, ch1lux;
248
249                 ch0lux = ((ch0 * p->ch0) +
250                           (gainadj[chip->als_settings.als_gain].ch0 >> 1))
251                          / gainadj[chip->als_settings.als_gain].ch0;
252                 ch1lux = ((ch1 * p->ch1) +
253                           (gainadj[chip->als_settings.als_gain].ch1 >> 1))
254                          / gainadj[chip->als_settings.als_gain].ch1;
255
256                 /* note: lux is 31 bit max at this point */
257                 if (ch1lux > ch0lux) {
258                         dev_dbg(&chip->client->dev, "%s: No Data - Returning 0\n",
259                                 __func__);
260                         ret = 0;
261                         chip->als_cur_info.lux = 0;
262                         goto done;
263                 }
264
265                 lux = ch0lux - ch1lux;
266         }
267
268         /* adjust for active time scale */
269         if (chip->als_time_scale == 0)
270                 lux = 0;
271         else
272                 lux = (lux + (chip->als_time_scale >> 1)) /
273                         chip->als_time_scale;
274
275         /*
276          * Adjust for active gain scale.
277          * The tsl2583_default_lux tables above have a factor of 8192 built in,
278          * so we need to shift right.
279          * User-specified gain provides a multiplier.
280          * Apply user-specified gain before shifting right to retain precision.
281          * Use 64 bits to avoid overflow on multiplication.
282          * Then go back to 32 bits before division to avoid using div_u64().
283          */
284         lux64 = lux;
285         lux64 = lux64 * chip->als_settings.als_gain_trim;
286         lux64 >>= 13;
287         lux = lux64;
288         lux = (lux + 500) / 1000;
289
290         if (lux > TSL2583_LUX_CALC_OVER_FLOW) { /* check for overflow */
291 return_max:
292                 lux = TSL2583_LUX_CALC_OVER_FLOW;
293         }
294
295         /* Update the structure with the latest VALID lux. */
296         chip->als_cur_info.lux = lux;
297         ret = lux;
298
299 done:
300         return ret;
301 }
302
303 /*
304  * Obtain single reading and calculate the als_gain_trim (later used
305  * to derive actual lux).
306  * Return updated gain_trim value.
307  */
308 static int tsl2583_als_calibrate(struct iio_dev *indio_dev)
309 {
310         struct tsl2583_chip *chip = iio_priv(indio_dev);
311         unsigned int gain_trim_val;
312         int ret;
313         int lux_val;
314
315         ret = i2c_smbus_read_byte_data(chip->client,
316                                        TSL2583_CMD_REG | TSL2583_CNTRL);
317         if (ret < 0) {
318                 dev_err(&chip->client->dev,
319                         "%s: failed to read from the CNTRL register\n",
320                         __func__);
321                 return ret;
322         }
323
324         if ((ret & (TSL2583_CNTL_ADC_ENBL | TSL2583_CNTL_PWR_ON))
325                         != (TSL2583_CNTL_ADC_ENBL | TSL2583_CNTL_PWR_ON)) {
326                 dev_err(&chip->client->dev,
327                         "%s: Device is not powered on and/or ADC is not enabled\n",
328                         __func__);
329                 return -EINVAL;
330         } else if ((ret & TSL2583_STA_ADC_VALID) != TSL2583_STA_ADC_VALID) {
331                 dev_err(&chip->client->dev,
332                         "%s: The two ADC channels have not completed an integration cycle\n",
333                         __func__);
334                 return -ENODATA;
335         }
336
337         lux_val = tsl2583_get_lux(indio_dev);
338         if (lux_val < 0) {
339                 dev_err(&chip->client->dev, "%s: failed to get lux\n",
340                         __func__);
341                 return lux_val;
342         }
343
344         gain_trim_val = (unsigned int)(((chip->als_settings.als_cal_target)
345                         * chip->als_settings.als_gain_trim) / lux_val);
346         if ((gain_trim_val < 250) || (gain_trim_val > 4000)) {
347                 dev_err(&chip->client->dev,
348                         "%s: trim_val of %d is not within the range [250, 4000]\n",
349                         __func__, gain_trim_val);
350                 return -ENODATA;
351         }
352
353         chip->als_settings.als_gain_trim = (int)gain_trim_val;
354
355         return 0;
356 }
357
358 static int tsl2583_set_als_time(struct tsl2583_chip *chip)
359 {
360         int als_count, als_time, ret;
361         u8 val;
362
363         /* determine als integration register */
364         als_count = (chip->als_settings.als_time * 100 + 135) / 270;
365         if (!als_count)
366                 als_count = 1; /* ensure at least one cycle */
367
368         /* convert back to time (encompasses overrides) */
369         als_time = (als_count * 27 + 5) / 10;
370
371         val = 256 - als_count;
372         ret = i2c_smbus_write_byte_data(chip->client,
373                                         TSL2583_CMD_REG | TSL2583_ALS_TIME,
374                                         val);
375         if (ret < 0) {
376                 dev_err(&chip->client->dev, "%s: failed to set the als time to %d\n",
377                         __func__, val);
378                 return ret;
379         }
380
381         /* set chip struct re scaling and saturation */
382         chip->als_saturation = als_count * 922; /* 90% of full scale */
383         chip->als_time_scale = (als_time + 25) / 50;
384
385         return ret;
386 }
387
388 static int tsl2583_set_als_gain(struct tsl2583_chip *chip)
389 {
390         int ret;
391
392         /* Set the gain based on als_settings struct */
393         ret = i2c_smbus_write_byte_data(chip->client,
394                                         TSL2583_CMD_REG | TSL2583_GAIN,
395                                         chip->als_settings.als_gain);
396         if (ret < 0)
397                 dev_err(&chip->client->dev,
398                         "%s: failed to set the gain to %d\n", __func__,
399                         chip->als_settings.als_gain);
400
401         return ret;
402 }
403
404 static int tsl2583_set_power_state(struct tsl2583_chip *chip, u8 state)
405 {
406         int ret;
407
408         ret = i2c_smbus_write_byte_data(chip->client,
409                                         TSL2583_CMD_REG | TSL2583_CNTRL, state);
410         if (ret < 0)
411                 dev_err(&chip->client->dev,
412                         "%s: failed to set the power state to %d\n", __func__,
413                         state);
414
415         return ret;
416 }
417
418 /*
419  * Turn the device on.
420  * Configuration must be set before calling this function.
421  */
422 static int tsl2583_chip_init_and_power_on(struct iio_dev *indio_dev)
423 {
424         struct tsl2583_chip *chip = iio_priv(indio_dev);
425         int ret;
426
427         /* Power on the device; ADC off. */
428         ret = tsl2583_set_power_state(chip, TSL2583_CNTL_PWR_ON);
429         if (ret < 0)
430                 return ret;
431
432         ret = i2c_smbus_write_byte_data(chip->client,
433                                         TSL2583_CMD_REG | TSL2583_INTERRUPT,
434                                         TSL2583_INTERRUPT_DISABLED);
435         if (ret < 0) {
436                 dev_err(&chip->client->dev,
437                         "%s: failed to disable interrupts\n", __func__);
438                 return ret;
439         }
440
441         ret = tsl2583_set_als_time(chip);
442         if (ret < 0)
443                 return ret;
444
445         ret = tsl2583_set_als_gain(chip);
446         if (ret < 0)
447                 return ret;
448
449         usleep_range(3000, 3500);
450
451         ret = tsl2583_set_power_state(chip, TSL2583_CNTL_PWR_ON |
452                                             TSL2583_CNTL_ADC_ENBL);
453         if (ret < 0)
454                 return ret;
455
456         return ret;
457 }
458
459 /* Sysfs Interface Functions */
460
461 static ssize_t in_illuminance_input_target_show(struct device *dev,
462                                                 struct device_attribute *attr,
463                                                 char *buf)
464 {
465         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
466         struct tsl2583_chip *chip = iio_priv(indio_dev);
467         int ret;
468
469         mutex_lock(&chip->als_mutex);
470         ret = sprintf(buf, "%d\n", chip->als_settings.als_cal_target);
471         mutex_unlock(&chip->als_mutex);
472
473         return ret;
474 }
475
476 static ssize_t in_illuminance_input_target_store(struct device *dev,
477                                                  struct device_attribute *attr,
478                                                  const char *buf, size_t len)
479 {
480         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
481         struct tsl2583_chip *chip = iio_priv(indio_dev);
482         int value;
483
484         if (kstrtoint(buf, 0, &value) || !value)
485                 return -EINVAL;
486
487         mutex_lock(&chip->als_mutex);
488         chip->als_settings.als_cal_target = value;
489         mutex_unlock(&chip->als_mutex);
490
491         return len;
492 }
493
494 static ssize_t in_illuminance_calibrate_store(struct device *dev,
495                                               struct device_attribute *attr,
496                                               const char *buf, size_t len)
497 {
498         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
499         struct tsl2583_chip *chip = iio_priv(indio_dev);
500         int value, ret;
501
502         if (kstrtoint(buf, 0, &value) || value != 1)
503                 return -EINVAL;
504
505         mutex_lock(&chip->als_mutex);
506
507         ret = tsl2583_als_calibrate(indio_dev);
508         if (ret < 0)
509                 goto done;
510
511         ret = len;
512 done:
513         mutex_unlock(&chip->als_mutex);
514
515         return ret;
516 }
517
518 static ssize_t in_illuminance_lux_table_show(struct device *dev,
519                                              struct device_attribute *attr,
520                                              char *buf)
521 {
522         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
523         struct tsl2583_chip *chip = iio_priv(indio_dev);
524         unsigned int i;
525         int offset = 0;
526
527         for (i = 0; i < ARRAY_SIZE(chip->als_settings.als_device_lux); i++) {
528                 offset += sprintf(buf + offset, "%u,%u,%u,",
529                                   chip->als_settings.als_device_lux[i].ratio,
530                                   chip->als_settings.als_device_lux[i].ch0,
531                                   chip->als_settings.als_device_lux[i].ch1);
532                 if (chip->als_settings.als_device_lux[i].ratio == 0) {
533                         /*
534                          * We just printed the first "0" entry.
535                          * Now get rid of the extra "," and break.
536                          */
537                         offset--;
538                         break;
539                 }
540         }
541
542         offset += sprintf(buf + offset, "\n");
543
544         return offset;
545 }
546
547 static ssize_t in_illuminance_lux_table_store(struct device *dev,
548                                               struct device_attribute *attr,
549                                               const char *buf, size_t len)
550 {
551         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
552         struct tsl2583_chip *chip = iio_priv(indio_dev);
553         const unsigned int max_ints = TSL2583_MAX_LUX_TABLE_ENTRIES * 3;
554         int value[TSL2583_MAX_LUX_TABLE_ENTRIES * 3 + 1];
555         int ret = -EINVAL;
556         unsigned int n;
557
558         mutex_lock(&chip->als_mutex);
559
560         get_options(buf, ARRAY_SIZE(value), value);
561
562         /*
563          * We now have an array of ints starting at value[1], and
564          * enumerated by value[0].
565          * We expect each group of three ints is one table entry,
566          * and the last table entry is all 0.
567          */
568         n = value[0];
569         if ((n % 3) || n < 6 || n > max_ints) {
570                 dev_err(dev,
571                         "%s: The number of entries in the lux table must be a multiple of 3 and within the range [6, %d]\n",
572                         __func__, max_ints);
573                 goto done;
574         }
575         if ((value[n - 2] | value[n - 1] | value[n]) != 0) {
576                 dev_err(dev, "%s: The last 3 entries in the lux table must be zeros.\n",
577                         __func__);
578                 goto done;
579         }
580
581         memcpy(chip->als_settings.als_device_lux, &value[1],
582                value[0] * sizeof(value[1]));
583
584         ret = len;
585
586 done:
587         mutex_unlock(&chip->als_mutex);
588
589         return ret;
590 }
591
592 static IIO_CONST_ATTR(in_illuminance_calibscale_available, "1 8 16 111");
593 static IIO_CONST_ATTR(in_illuminance_integration_time_available,
594                       "0.050 0.100 0.150 0.200 0.250 0.300 0.350 0.400 0.450 0.500 0.550 0.600 0.650");
595 static IIO_DEVICE_ATTR_RW(in_illuminance_input_target, 0);
596 static IIO_DEVICE_ATTR_WO(in_illuminance_calibrate, 0);
597 static IIO_DEVICE_ATTR_RW(in_illuminance_lux_table, 0);
598
599 static struct attribute *sysfs_attrs_ctrl[] = {
600         &iio_const_attr_in_illuminance_calibscale_available.dev_attr.attr,
601         &iio_const_attr_in_illuminance_integration_time_available.dev_attr.attr,
602         &iio_dev_attr_in_illuminance_input_target.dev_attr.attr,
603         &iio_dev_attr_in_illuminance_calibrate.dev_attr.attr,
604         &iio_dev_attr_in_illuminance_lux_table.dev_attr.attr,
605         NULL
606 };
607
608 static const struct attribute_group tsl2583_attribute_group = {
609         .attrs = sysfs_attrs_ctrl,
610 };
611
612 static const struct iio_chan_spec tsl2583_channels[] = {
613         {
614                 .type = IIO_LIGHT,
615                 .modified = 1,
616                 .channel2 = IIO_MOD_LIGHT_IR,
617                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
618         },
619         {
620                 .type = IIO_LIGHT,
621                 .modified = 1,
622                 .channel2 = IIO_MOD_LIGHT_BOTH,
623                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
624         },
625         {
626                 .type = IIO_LIGHT,
627                 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
628                                       BIT(IIO_CHAN_INFO_CALIBBIAS) |
629                                       BIT(IIO_CHAN_INFO_CALIBSCALE) |
630                                       BIT(IIO_CHAN_INFO_INT_TIME),
631         },
632 };
633
634 static int tsl2583_set_pm_runtime_busy(struct tsl2583_chip *chip, bool on)
635 {
636         int ret;
637
638         if (on) {
639                 ret = pm_runtime_get_sync(&chip->client->dev);
640                 if (ret < 0)
641                         pm_runtime_put_noidle(&chip->client->dev);
642         } else {
643                 pm_runtime_mark_last_busy(&chip->client->dev);
644                 ret = pm_runtime_put_autosuspend(&chip->client->dev);
645         }
646
647         return ret;
648 }
649
650 static int tsl2583_read_raw(struct iio_dev *indio_dev,
651                             struct iio_chan_spec const *chan,
652                             int *val, int *val2, long mask)
653 {
654         struct tsl2583_chip *chip = iio_priv(indio_dev);
655         int ret, pm_ret;
656
657         ret = tsl2583_set_pm_runtime_busy(chip, true);
658         if (ret < 0)
659                 return ret;
660
661         mutex_lock(&chip->als_mutex);
662
663         ret = -EINVAL;
664         switch (mask) {
665         case IIO_CHAN_INFO_RAW:
666                 if (chan->type == IIO_LIGHT) {
667                         ret = tsl2583_get_lux(indio_dev);
668                         if (ret < 0)
669                                 goto read_done;
670
671                         /*
672                          * From page 20 of the TSL2581, TSL2583 data
673                          * sheet (TAOS134 − MARCH 2011):
674                          *
675                          * One of the photodiodes (channel 0) is
676                          * sensitive to both visible and infrared light,
677                          * while the second photodiode (channel 1) is
678                          * sensitive primarily to infrared light.
679                          */
680                         if (chan->channel2 == IIO_MOD_LIGHT_BOTH)
681                                 *val = chip->als_cur_info.als_ch0;
682                         else
683                                 *val = chip->als_cur_info.als_ch1;
684
685                         ret = IIO_VAL_INT;
686                 }
687                 break;
688         case IIO_CHAN_INFO_PROCESSED:
689                 if (chan->type == IIO_LIGHT) {
690                         ret = tsl2583_get_lux(indio_dev);
691                         if (ret < 0)
692                                 goto read_done;
693
694                         *val = ret;
695                         ret = IIO_VAL_INT;
696                 }
697                 break;
698         case IIO_CHAN_INFO_CALIBBIAS:
699                 if (chan->type == IIO_LIGHT) {
700                         *val = chip->als_settings.als_gain_trim;
701                         ret = IIO_VAL_INT;
702                 }
703                 break;
704         case IIO_CHAN_INFO_CALIBSCALE:
705                 if (chan->type == IIO_LIGHT) {
706                         *val = gainadj[chip->als_settings.als_gain].mean;
707                         ret = IIO_VAL_INT;
708                 }
709                 break;
710         case IIO_CHAN_INFO_INT_TIME:
711                 if (chan->type == IIO_LIGHT) {
712                         *val = 0;
713                         *val2 = chip->als_settings.als_time;
714                         ret = IIO_VAL_INT_PLUS_MICRO;
715                 }
716                 break;
717         default:
718                 break;
719         }
720
721 read_done:
722         mutex_unlock(&chip->als_mutex);
723
724         if (ret < 0)
725                 return ret;
726
727         /*
728          * Preserve the ret variable if the call to
729          * tsl2583_set_pm_runtime_busy() is successful so the reading
730          * (if applicable) is returned to user space.
731          */
732         pm_ret = tsl2583_set_pm_runtime_busy(chip, false);
733         if (pm_ret < 0)
734                 return pm_ret;
735
736         return ret;
737 }
738
739 static int tsl2583_write_raw(struct iio_dev *indio_dev,
740                              struct iio_chan_spec const *chan,
741                              int val, int val2, long mask)
742 {
743         struct tsl2583_chip *chip = iio_priv(indio_dev);
744         int ret;
745
746         ret = tsl2583_set_pm_runtime_busy(chip, true);
747         if (ret < 0)
748                 return ret;
749
750         mutex_lock(&chip->als_mutex);
751
752         ret = -EINVAL;
753         switch (mask) {
754         case IIO_CHAN_INFO_CALIBBIAS:
755                 if (chan->type == IIO_LIGHT) {
756                         chip->als_settings.als_gain_trim = val;
757                         ret = 0;
758                 }
759                 break;
760         case IIO_CHAN_INFO_CALIBSCALE:
761                 if (chan->type == IIO_LIGHT) {
762                         unsigned int i;
763
764                         for (i = 0; i < ARRAY_SIZE(gainadj); i++) {
765                                 if (gainadj[i].mean == val) {
766                                         chip->als_settings.als_gain = i;
767                                         ret = tsl2583_set_als_gain(chip);
768                                         break;
769                                 }
770                         }
771                 }
772                 break;
773         case IIO_CHAN_INFO_INT_TIME:
774                 if (chan->type == IIO_LIGHT && !val && val2 >= 50 &&
775                     val2 <= 650 && !(val2 % 50)) {
776                         chip->als_settings.als_time = val2;
777                         ret = tsl2583_set_als_time(chip);
778                 }
779                 break;
780         default:
781                 break;
782         }
783
784         mutex_unlock(&chip->als_mutex);
785
786         if (ret < 0)
787                 return ret;
788
789         ret = tsl2583_set_pm_runtime_busy(chip, false);
790         if (ret < 0)
791                 return ret;
792
793         return ret;
794 }
795
796 static const struct iio_info tsl2583_info = {
797         .attrs = &tsl2583_attribute_group,
798         .read_raw = tsl2583_read_raw,
799         .write_raw = tsl2583_write_raw,
800 };
801
802 static int tsl2583_probe(struct i2c_client *clientp,
803                          const struct i2c_device_id *idp)
804 {
805         int ret;
806         struct tsl2583_chip *chip;
807         struct iio_dev *indio_dev;
808
809         if (!i2c_check_functionality(clientp->adapter,
810                                      I2C_FUNC_SMBUS_BYTE_DATA)) {
811                 dev_err(&clientp->dev, "%s: i2c smbus byte data functionality is unsupported\n",
812                         __func__);
813                 return -EOPNOTSUPP;
814         }
815
816         indio_dev = devm_iio_device_alloc(&clientp->dev, sizeof(*chip));
817         if (!indio_dev)
818                 return -ENOMEM;
819
820         chip = iio_priv(indio_dev);
821         chip->client = clientp;
822         i2c_set_clientdata(clientp, indio_dev);
823
824         mutex_init(&chip->als_mutex);
825
826         ret = i2c_smbus_read_byte_data(clientp,
827                                        TSL2583_CMD_REG | TSL2583_CHIPID);
828         if (ret < 0) {
829                 dev_err(&clientp->dev,
830                         "%s: failed to read the chip ID register\n", __func__);
831                 return ret;
832         }
833
834         if ((ret & TSL2583_CHIP_ID_MASK) != TSL2583_CHIP_ID) {
835                 dev_err(&clientp->dev, "%s: received an unknown chip ID %x\n",
836                         __func__, ret);
837                 return -EINVAL;
838         }
839
840         indio_dev->info = &tsl2583_info;
841         indio_dev->channels = tsl2583_channels;
842         indio_dev->num_channels = ARRAY_SIZE(tsl2583_channels);
843         indio_dev->dev.parent = &clientp->dev;
844         indio_dev->modes = INDIO_DIRECT_MODE;
845         indio_dev->name = chip->client->name;
846
847         pm_runtime_enable(&clientp->dev);
848         pm_runtime_set_autosuspend_delay(&clientp->dev,
849                                          TSL2583_POWER_OFF_DELAY_MS);
850         pm_runtime_use_autosuspend(&clientp->dev);
851
852         ret = devm_iio_device_register(indio_dev->dev.parent, indio_dev);
853         if (ret) {
854                 dev_err(&clientp->dev, "%s: iio registration failed\n",
855                         __func__);
856                 return ret;
857         }
858
859         /* Load up the V2 defaults (these are hard coded defaults for now) */
860         tsl2583_defaults(chip);
861
862         dev_info(&clientp->dev, "Light sensor found.\n");
863
864         return 0;
865 }
866
867 static int tsl2583_remove(struct i2c_client *client)
868 {
869         struct iio_dev *indio_dev = i2c_get_clientdata(client);
870         struct tsl2583_chip *chip = iio_priv(indio_dev);
871
872         iio_device_unregister(indio_dev);
873
874         pm_runtime_disable(&client->dev);
875         pm_runtime_set_suspended(&client->dev);
876         pm_runtime_put_noidle(&client->dev);
877
878         return tsl2583_set_power_state(chip, TSL2583_CNTL_PWR_OFF);
879 }
880
881 static int __maybe_unused tsl2583_suspend(struct device *dev)
882 {
883         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
884         struct tsl2583_chip *chip = iio_priv(indio_dev);
885         int ret;
886
887         mutex_lock(&chip->als_mutex);
888
889         ret = tsl2583_set_power_state(chip, TSL2583_CNTL_PWR_OFF);
890
891         mutex_unlock(&chip->als_mutex);
892
893         return ret;
894 }
895
896 static int __maybe_unused tsl2583_resume(struct device *dev)
897 {
898         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
899         struct tsl2583_chip *chip = iio_priv(indio_dev);
900         int ret;
901
902         mutex_lock(&chip->als_mutex);
903
904         ret = tsl2583_chip_init_and_power_on(indio_dev);
905
906         mutex_unlock(&chip->als_mutex);
907
908         return ret;
909 }
910
911 static const struct dev_pm_ops tsl2583_pm_ops = {
912         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
913                                 pm_runtime_force_resume)
914         SET_RUNTIME_PM_OPS(tsl2583_suspend, tsl2583_resume, NULL)
915 };
916
917 static const struct i2c_device_id tsl2583_idtable[] = {
918         { "tsl2580", 0 },
919         { "tsl2581", 1 },
920         { "tsl2583", 2 },
921         {}
922 };
923 MODULE_DEVICE_TABLE(i2c, tsl2583_idtable);
924
925 static const struct of_device_id tsl2583_of_match[] = {
926         { .compatible = "amstaos,tsl2580", },
927         { .compatible = "amstaos,tsl2581", },
928         { .compatible = "amstaos,tsl2583", },
929         { },
930 };
931 MODULE_DEVICE_TABLE(of, tsl2583_of_match);
932
933 /* Driver definition */
934 static struct i2c_driver tsl2583_driver = {
935         .driver = {
936                 .name = "tsl2583",
937                 .pm = &tsl2583_pm_ops,
938                 .of_match_table = tsl2583_of_match,
939         },
940         .id_table = tsl2583_idtable,
941         .probe = tsl2583_probe,
942         .remove = tsl2583_remove,
943 };
944 module_i2c_driver(tsl2583_driver);
945
946 MODULE_AUTHOR("J. August Brenner <jbrenner@taosinc.com>");
947 MODULE_AUTHOR("Brian Masney <masneyb@onstation.org>");
948 MODULE_DESCRIPTION("TAOS tsl2583 ambient light sensor driver");
949 MODULE_LICENSE("GPL");