2 * Device driver for monitoring ambient light intensity (lux)
3 * within the TAOS tsl258x family of devices (tsl2580, tsl2581).
5 * Copyright (c) 2011, TAOS Corporation.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22 #include <linux/kernel.h>
23 #include <linux/i2c.h>
24 #include <linux/errno.h>
25 #include <linux/delay.h>
26 #include <linux/string.h>
27 #include <linux/mutex.h>
28 #include <linux/unistd.h>
29 #include <linux/slab.h>
30 #include <linux/module.h>
31 #include <linux/iio/iio.h>
33 #define TSL258X_MAX_DEVICE_REGS 32
35 /* Triton register offsets */
36 #define TSL258X_REG_MAX 8
38 /* Device Registers and Masks */
39 #define TSL258X_CNTRL 0x00
40 #define TSL258X_ALS_TIME 0X01
41 #define TSL258X_INTERRUPT 0x02
42 #define TSL258X_GAIN 0x07
43 #define TSL258X_REVID 0x11
44 #define TSL258X_CHIPID 0x12
45 #define TSL258X_ALS_CHAN0LO 0x14
46 #define TSL258X_ALS_CHAN0HI 0x15
47 #define TSL258X_ALS_CHAN1LO 0x16
48 #define TSL258X_ALS_CHAN1HI 0x17
49 #define TSL258X_TMR_LO 0x18
50 #define TSL258X_TMR_HI 0x19
52 /* tsl2583 cmd reg masks */
53 #define TSL258X_CMD_REG 0x80
54 #define TSL258X_CMD_SPL_FN 0x60
55 #define TSL258X_CMD_ALS_INT_CLR 0X01
57 /* tsl2583 cntrl reg masks */
58 #define TSL258X_CNTL_ADC_ENBL 0x02
59 #define TSL258X_CNTL_PWR_ON 0x01
61 /* tsl2583 status reg masks */
62 #define TSL258X_STA_ADC_VALID 0x01
63 #define TSL258X_STA_ADC_INTR 0x10
65 /* Lux calculation constants */
66 #define TSL258X_LUX_CALC_OVER_FLOW 65535
69 TSL258X_CHIP_UNKNOWN
= 0,
70 TSL258X_CHIP_WORKING
= 1,
71 TSL258X_CHIP_SUSPENDED
= 2
75 struct taos_als_info
{
81 struct taos_settings
{
89 struct mutex als_mutex
;
90 struct i2c_client
*client
;
91 struct taos_als_info als_cur_info
;
92 struct taos_settings taos_settings
;
100 * Initial values for device - this values can/will be changed by driver.
101 * and applications as needed.
102 * These values are dynamic.
104 static const u8 taos_config
[8] = {
105 0x00, 0xee, 0x00, 0x03, 0x00, 0xFF, 0xFF, 0x00
106 }; /* cntrl atime intC Athl0 Athl1 Athh0 Athh1 gain */
114 /* This structure is intentionally large to accommodate updates via sysfs. */
115 /* Sized to 11 = max 10 segments + 1 termination segment */
116 /* Assumption is one and only one type of glass used */
117 static struct taos_lux taos_device_lux
[11] = {
118 { 9830, 8520, 15729 },
119 { 12452, 10807, 23344 },
120 { 14746, 6383, 11705 },
121 { 17695, 4063, 6554 },
129 /* Index = (0 - 3) Used to validate the gain selection index */
130 static const struct gainadj gainadj
[] = {
138 * Provides initial operational parameter defaults.
139 * These defaults may be changed through the device's sysfs files.
141 static void taos_defaults(struct tsl2583_chip
*chip
)
143 /* Operational parameters */
144 chip
->taos_settings
.als_time
= 100;
145 /* must be a multiple of 50mS */
146 chip
->taos_settings
.als_gain
= 0;
147 /* this is actually an index into the gain table */
148 /* assume clear glass as default */
149 chip
->taos_settings
.als_gain_trim
= 1000;
150 /* default gain trim to account for aperture effects */
151 chip
->taos_settings
.als_cal_target
= 130;
152 /* Known external ALS reading used for calibration */
156 * Read a number of bytes starting at register (reg) location.
157 * Return 0, or i2c_smbus_write_byte ERROR code.
160 taos_i2c_read(struct i2c_client
*client
, u8 reg
, u8
*val
, unsigned int len
)
164 for (i
= 0; i
< len
; i
++) {
165 /* select register to write */
166 ret
= i2c_smbus_write_byte(client
, (TSL258X_CMD_REG
| reg
));
168 dev_err(&client
->dev
,
169 "taos_i2c_read failed to write register %x\n",
174 *val
= i2c_smbus_read_byte(client
);
182 * Reads and calculates current lux value.
183 * The raw ch0 and ch1 values of the ambient light sensed in the last
184 * integration cycle are read from the device.
185 * Time scale factor array values are adjusted based on the integration time.
186 * The raw values are multiplied by a scale factor, and device gain is obtained
187 * using gain index. Limit checks are done next, then the ratio of a multiple
188 * of ch1 value, to the ch0 value, is calculated. The array taos_device_lux[]
189 * declared above is then scanned to find the first ratio value that is just
190 * above the ratio we just calculated. The ch0 and ch1 multiplier constants in
191 * the array are then used along with the time scale factor array values, to
194 static int taos_get_lux(struct iio_dev
*indio_dev
)
196 u16 ch0
, ch1
; /* separated ch0/ch1 data from device */
197 u32 lux
; /* raw lux calculated from device data */
202 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
207 if (mutex_trylock(&chip
->als_mutex
) == 0) {
208 dev_info(&chip
->client
->dev
, "taos_get_lux device is busy\n");
209 return chip
->als_cur_info
.lux
; /* busy, so return LAST VALUE */
212 if (chip
->taos_chip_status
!= TSL258X_CHIP_WORKING
) {
213 /* device is not enabled */
214 dev_err(&chip
->client
->dev
, "taos_get_lux device is not enabled\n");
219 ret
= taos_i2c_read(chip
->client
, (TSL258X_CMD_REG
), &buf
[0], 1);
221 dev_err(&chip
->client
->dev
, "taos_get_lux failed to read CMD_REG\n");
224 /* is data new & valid */
225 if (!(buf
[0] & TSL258X_STA_ADC_INTR
)) {
226 dev_err(&chip
->client
->dev
, "taos_get_lux data not valid\n");
227 ret
= chip
->als_cur_info
.lux
; /* return LAST VALUE */
231 for (i
= 0; i
< 4; i
++) {
232 int reg
= TSL258X_CMD_REG
| (TSL258X_ALS_CHAN0LO
+ i
);
234 ret
= taos_i2c_read(chip
->client
, reg
, &buf
[i
], 1);
236 dev_err(&chip
->client
->dev
,
237 "taos_get_lux failed to read register %x\n",
244 * clear status, really interrupt status (interrupts are off), but
245 * we use the bit anyway - don't forget 0x80 - this is a command
247 ret
= i2c_smbus_write_byte(chip
->client
,
248 (TSL258X_CMD_REG
| TSL258X_CMD_SPL_FN
|
249 TSL258X_CMD_ALS_INT_CLR
));
252 dev_err(&chip
->client
->dev
,
253 "taos_i2c_write_command failed in taos_get_lux, err = %d\n",
255 goto out_unlock
; /* have no data, so return failure */
258 /* extract ALS/lux data */
259 ch0
= le16_to_cpup((const __le16
*)&buf
[0]);
260 ch1
= le16_to_cpup((const __le16
*)&buf
[2]);
262 chip
->als_cur_info
.als_ch0
= ch0
;
263 chip
->als_cur_info
.als_ch1
= ch1
;
265 if ((ch0
>= chip
->als_saturation
) || (ch1
>= chip
->als_saturation
))
269 /* have no data, so return LAST VALUE */
271 chip
->als_cur_info
.lux
= 0;
274 /* calculate ratio */
275 ratio
= (ch1
<< 15) / ch0
;
276 /* convert to unscaled lux using the pointer to the table */
277 for (p
= (struct taos_lux
*)taos_device_lux
;
278 p
->ratio
!= 0 && p
->ratio
< ratio
; p
++)
284 ch0lux
= ((ch0
* p
->ch0
) +
285 (gainadj
[chip
->taos_settings
.als_gain
].ch0
>> 1))
286 / gainadj
[chip
->taos_settings
.als_gain
].ch0
;
287 ch1lux
= ((ch1
* p
->ch1
) +
288 (gainadj
[chip
->taos_settings
.als_gain
].ch1
>> 1))
289 / gainadj
[chip
->taos_settings
.als_gain
].ch1
;
290 lux
= ch0lux
- ch1lux
;
293 /* note: lux is 31 bit max at this point */
294 if (ch1lux
> ch0lux
) {
295 dev_dbg(&chip
->client
->dev
, "No Data - Return last value\n");
297 chip
->als_cur_info
.lux
= 0;
301 /* adjust for active time scale */
302 if (chip
->als_time_scale
== 0)
305 lux
= (lux
+ (chip
->als_time_scale
>> 1)) /
306 chip
->als_time_scale
;
308 /* Adjust for active gain scale.
309 * The taos_device_lux tables above have a factor of 8192 built in,
310 * so we need to shift right.
311 * User-specified gain provides a multiplier.
312 * Apply user-specified gain before shifting right to retain precision.
313 * Use 64 bits to avoid overflow on multiplication.
314 * Then go back to 32 bits before division to avoid using div_u64().
317 lux64
= lux64
* chip
->taos_settings
.als_gain_trim
;
320 lux
= (lux
+ 500) / 1000;
321 if (lux
> TSL258X_LUX_CALC_OVER_FLOW
) { /* check for overflow */
323 lux
= TSL258X_LUX_CALC_OVER_FLOW
;
326 /* Update the structure with the latest VALID lux. */
327 chip
->als_cur_info
.lux
= lux
;
331 mutex_unlock(&chip
->als_mutex
);
336 * Obtain single reading and calculate the als_gain_trim (later used
337 * to derive actual lux).
338 * Return updated gain_trim value.
340 static int taos_als_calibrate(struct iio_dev
*indio_dev
)
342 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
344 unsigned int gain_trim_val
;
348 ret
= i2c_smbus_write_byte(chip
->client
,
349 (TSL258X_CMD_REG
| TSL258X_CNTRL
));
351 dev_err(&chip
->client
->dev
,
352 "taos_als_calibrate failed to reach the CNTRL register, ret=%d\n",
357 reg_val
= i2c_smbus_read_byte(chip
->client
);
358 if ((reg_val
& (TSL258X_CNTL_ADC_ENBL
| TSL258X_CNTL_PWR_ON
))
359 != (TSL258X_CNTL_ADC_ENBL
| TSL258X_CNTL_PWR_ON
)) {
360 dev_err(&chip
->client
->dev
,
361 "taos_als_calibrate failed: device not powered on with ADC enabled\n");
365 ret
= i2c_smbus_write_byte(chip
->client
,
366 (TSL258X_CMD_REG
| TSL258X_CNTRL
));
368 dev_err(&chip
->client
->dev
,
369 "taos_als_calibrate failed to reach the STATUS register, ret=%d\n",
373 reg_val
= i2c_smbus_read_byte(chip
->client
);
375 if ((reg_val
& TSL258X_STA_ADC_VALID
) != TSL258X_STA_ADC_VALID
) {
376 dev_err(&chip
->client
->dev
,
377 "taos_als_calibrate failed: STATUS - ADC not valid.\n");
380 lux_val
= taos_get_lux(indio_dev
);
382 dev_err(&chip
->client
->dev
, "taos_als_calibrate failed to get lux\n");
385 gain_trim_val
= (unsigned int)(((chip
->taos_settings
.als_cal_target
)
386 * chip
->taos_settings
.als_gain_trim
) / lux_val
);
388 if ((gain_trim_val
< 250) || (gain_trim_val
> 4000)) {
389 dev_err(&chip
->client
->dev
,
390 "taos_als_calibrate failed: trim_val of %d is out of range\n",
394 chip
->taos_settings
.als_gain_trim
= (int)gain_trim_val
;
396 return (int)gain_trim_val
;
400 * Turn the device on.
401 * Configuration must be set before calling this function.
403 static int taos_chip_on(struct iio_dev
*indio_dev
)
411 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
413 /* and make sure we're not already on */
414 if (chip
->taos_chip_status
== TSL258X_CHIP_WORKING
) {
415 /* if forcing a register update - turn off, then on */
416 dev_info(&chip
->client
->dev
, "device is already enabled\n");
420 /* determine als integration register */
421 als_count
= (chip
->taos_settings
.als_time
* 100 + 135) / 270;
423 als_count
= 1; /* ensure at least one cycle */
425 /* convert back to time (encompasses overrides) */
426 als_time
= (als_count
* 27 + 5) / 10;
427 chip
->taos_config
[TSL258X_ALS_TIME
] = 256 - als_count
;
429 /* Set the gain based on taos_settings struct */
430 chip
->taos_config
[TSL258X_GAIN
] = chip
->taos_settings
.als_gain
;
432 /* set chip struct re scaling and saturation */
433 chip
->als_saturation
= als_count
* 922; /* 90% of full scale */
434 chip
->als_time_scale
= (als_time
+ 25) / 50;
437 * TSL258x Specific power-on / adc enable sequence
438 * Power on the device 1st.
440 utmp
= TSL258X_CNTL_PWR_ON
;
441 ret
= i2c_smbus_write_byte_data(chip
->client
,
442 TSL258X_CMD_REG
| TSL258X_CNTRL
, utmp
);
444 dev_err(&chip
->client
->dev
, "taos_chip_on failed on CNTRL reg.\n");
449 * Use the following shadow copy for our delay before enabling ADC.
450 * Write all the registers.
452 for (i
= 0, uP
= chip
->taos_config
; i
< TSL258X_REG_MAX
; i
++) {
453 ret
= i2c_smbus_write_byte_data(chip
->client
,
457 dev_err(&chip
->client
->dev
,
458 "taos_chip_on failed on reg %d.\n", i
);
463 usleep_range(3000, 3500);
466 * initialize the desired mode of operation
468 utmp
= TSL258X_CNTL_PWR_ON
| TSL258X_CNTL_ADC_ENBL
;
469 ret
= i2c_smbus_write_byte_data(chip
->client
,
470 TSL258X_CMD_REG
| TSL258X_CNTRL
,
473 dev_err(&chip
->client
->dev
, "taos_chip_on failed on 2nd CTRL reg.\n");
476 chip
->taos_chip_status
= TSL258X_CHIP_WORKING
;
481 static int taos_chip_off(struct iio_dev
*indio_dev
)
483 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
485 /* turn device off */
486 chip
->taos_chip_status
= TSL258X_CHIP_SUSPENDED
;
487 return i2c_smbus_write_byte_data(chip
->client
,
488 TSL258X_CMD_REG
| TSL258X_CNTRL
,
492 /* Sysfs Interface Functions */
494 static ssize_t
taos_power_state_show(struct device
*dev
,
495 struct device_attribute
*attr
, char *buf
)
497 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
498 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
500 return sprintf(buf
, "%d\n", chip
->taos_chip_status
);
503 static ssize_t
taos_power_state_store(struct device
*dev
,
504 struct device_attribute
*attr
,
505 const char *buf
, size_t len
)
507 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
510 if (kstrtoint(buf
, 0, &value
))
514 taos_chip_off(indio_dev
);
516 taos_chip_on(indio_dev
);
521 static ssize_t
taos_gain_show(struct device
*dev
,
522 struct device_attribute
*attr
, char *buf
)
524 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
525 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
528 switch (chip
->taos_settings
.als_gain
) {
543 return sprintf(buf
, "%s\n", gain
);
546 static ssize_t
taos_gain_store(struct device
*dev
,
547 struct device_attribute
*attr
,
548 const char *buf
, size_t len
)
550 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
551 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
554 if (kstrtoint(buf
, 0, &value
))
559 chip
->taos_settings
.als_gain
= 0;
562 chip
->taos_settings
.als_gain
= 1;
565 chip
->taos_settings
.als_gain
= 2;
568 chip
->taos_settings
.als_gain
= 3;
571 dev_err(dev
, "Invalid Gain Index (must be 1,8,16,111)\n");
578 static ssize_t
taos_gain_available_show(struct device
*dev
,
579 struct device_attribute
*attr
,
582 return sprintf(buf
, "%s\n", "1 8 16 111");
585 static ssize_t
taos_als_time_show(struct device
*dev
,
586 struct device_attribute
*attr
, char *buf
)
588 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
589 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
591 return sprintf(buf
, "%d\n", chip
->taos_settings
.als_time
);
594 static ssize_t
taos_als_time_store(struct device
*dev
,
595 struct device_attribute
*attr
,
596 const char *buf
, size_t len
)
598 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
599 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
602 if (kstrtoint(buf
, 0, &value
))
605 if ((value
< 50) || (value
> 650))
611 chip
->taos_settings
.als_time
= value
;
616 static ssize_t
taos_als_time_available_show(struct device
*dev
,
617 struct device_attribute
*attr
,
620 return sprintf(buf
, "%s\n",
621 "50 100 150 200 250 300 350 400 450 500 550 600 650");
624 static ssize_t
taos_als_trim_show(struct device
*dev
,
625 struct device_attribute
*attr
, char *buf
)
627 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
628 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
630 return sprintf(buf
, "%d\n", chip
->taos_settings
.als_gain_trim
);
633 static ssize_t
taos_als_trim_store(struct device
*dev
,
634 struct device_attribute
*attr
,
635 const char *buf
, size_t len
)
637 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
638 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
641 if (kstrtoint(buf
, 0, &value
))
645 chip
->taos_settings
.als_gain_trim
= value
;
650 static ssize_t
taos_als_cal_target_show(struct device
*dev
,
651 struct device_attribute
*attr
,
654 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
655 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
657 return sprintf(buf
, "%d\n", chip
->taos_settings
.als_cal_target
);
660 static ssize_t
taos_als_cal_target_store(struct device
*dev
,
661 struct device_attribute
*attr
,
662 const char *buf
, size_t len
)
664 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
665 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
668 if (kstrtoint(buf
, 0, &value
))
672 chip
->taos_settings
.als_cal_target
= value
;
677 static ssize_t
taos_lux_show(struct device
*dev
, struct device_attribute
*attr
,
682 ret
= taos_get_lux(dev_to_iio_dev(dev
));
686 return sprintf(buf
, "%d\n", ret
);
689 static ssize_t
taos_do_calibrate(struct device
*dev
,
690 struct device_attribute
*attr
,
691 const char *buf
, size_t len
)
693 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
696 if (kstrtoint(buf
, 0, &value
))
700 taos_als_calibrate(indio_dev
);
705 static ssize_t
taos_luxtable_show(struct device
*dev
,
706 struct device_attribute
*attr
, char *buf
)
711 for (i
= 0; i
< ARRAY_SIZE(taos_device_lux
); i
++) {
712 offset
+= sprintf(buf
+ offset
, "%u,%u,%u,",
713 taos_device_lux
[i
].ratio
,
714 taos_device_lux
[i
].ch0
,
715 taos_device_lux
[i
].ch1
);
716 if (taos_device_lux
[i
].ratio
== 0) {
718 * We just printed the first "0" entry.
719 * Now get rid of the extra "," and break.
726 offset
+= sprintf(buf
+ offset
, "\n");
730 static ssize_t
taos_luxtable_store(struct device
*dev
,
731 struct device_attribute
*attr
,
732 const char *buf
, size_t len
)
734 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
735 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
736 int value
[ARRAY_SIZE(taos_device_lux
) * 3 + 1];
739 get_options(buf
, ARRAY_SIZE(value
), value
);
741 /* We now have an array of ints starting at value[1], and
742 * enumerated by value[0].
743 * We expect each group of three ints is one table entry,
744 * and the last table entry is all 0.
747 if ((n
% 3) || n
< 6 || n
> ((ARRAY_SIZE(taos_device_lux
) - 1) * 3)) {
748 dev_info(dev
, "LUX TABLE INPUT ERROR 1 Value[0]=%d\n", n
);
751 if ((value
[(n
- 2)] | value
[(n
- 1)] | value
[n
]) != 0) {
752 dev_info(dev
, "LUX TABLE INPUT ERROR 2 Value[0]=%d\n", n
);
756 if (chip
->taos_chip_status
== TSL258X_CHIP_WORKING
)
757 taos_chip_off(indio_dev
);
759 /* Zero out the table */
760 memset(taos_device_lux
, 0, sizeof(taos_device_lux
));
761 memcpy(taos_device_lux
, &value
[1], (value
[0] * 4));
763 taos_chip_on(indio_dev
);
768 static DEVICE_ATTR(power_state
, S_IRUGO
| S_IWUSR
,
769 taos_power_state_show
, taos_power_state_store
);
771 static DEVICE_ATTR(illuminance0_calibscale
, S_IRUGO
| S_IWUSR
,
772 taos_gain_show
, taos_gain_store
);
773 static DEVICE_ATTR(illuminance0_calibscale_available
, S_IRUGO
,
774 taos_gain_available_show
, NULL
);
776 static DEVICE_ATTR(illuminance0_integration_time
, S_IRUGO
| S_IWUSR
,
777 taos_als_time_show
, taos_als_time_store
);
778 static DEVICE_ATTR(illuminance0_integration_time_available
, S_IRUGO
,
779 taos_als_time_available_show
, NULL
);
781 static DEVICE_ATTR(illuminance0_calibbias
, S_IRUGO
| S_IWUSR
,
782 taos_als_trim_show
, taos_als_trim_store
);
784 static DEVICE_ATTR(illuminance0_input_target
, S_IRUGO
| S_IWUSR
,
785 taos_als_cal_target_show
, taos_als_cal_target_store
);
787 static DEVICE_ATTR(illuminance0_input
, S_IRUGO
, taos_lux_show
, NULL
);
788 static DEVICE_ATTR(illuminance0_calibrate
, S_IWUSR
, NULL
, taos_do_calibrate
);
789 static DEVICE_ATTR(illuminance0_lux_table
, S_IRUGO
| S_IWUSR
,
790 taos_luxtable_show
, taos_luxtable_store
);
792 static struct attribute
*sysfs_attrs_ctrl
[] = {
793 &dev_attr_power_state
.attr
,
794 &dev_attr_illuminance0_calibscale
.attr
, /* Gain */
795 &dev_attr_illuminance0_calibscale_available
.attr
,
796 &dev_attr_illuminance0_integration_time
.attr
, /* I time*/
797 &dev_attr_illuminance0_integration_time_available
.attr
,
798 &dev_attr_illuminance0_calibbias
.attr
, /* trim */
799 &dev_attr_illuminance0_input_target
.attr
,
800 &dev_attr_illuminance0_input
.attr
,
801 &dev_attr_illuminance0_calibrate
.attr
,
802 &dev_attr_illuminance0_lux_table
.attr
,
806 static const struct attribute_group tsl2583_attribute_group
= {
807 .attrs
= sysfs_attrs_ctrl
,
810 /* Use the default register values to identify the Taos device */
811 static int taos_tsl258x_device(unsigned char *bufp
)
813 return ((bufp
[TSL258X_CHIPID
] & 0xf0) == 0x90);
816 static const struct iio_info tsl2583_info
= {
817 .attrs
= &tsl2583_attribute_group
,
818 .driver_module
= THIS_MODULE
,
822 * Client probe function - When a valid device is found, the driver's device
823 * data structure is updated, and initialization completes successfully.
825 static int taos_probe(struct i2c_client
*clientp
,
826 const struct i2c_device_id
*idp
)
829 unsigned char buf
[TSL258X_MAX_DEVICE_REGS
];
830 struct tsl2583_chip
*chip
;
831 struct iio_dev
*indio_dev
;
833 if (!i2c_check_functionality(clientp
->adapter
,
834 I2C_FUNC_SMBUS_BYTE_DATA
)) {
835 dev_err(&clientp
->dev
, "taos_probe() - i2c smbus byte data func unsupported\n");
839 indio_dev
= devm_iio_device_alloc(&clientp
->dev
, sizeof(*chip
));
842 chip
= iio_priv(indio_dev
);
843 chip
->client
= clientp
;
844 i2c_set_clientdata(clientp
, indio_dev
);
846 mutex_init(&chip
->als_mutex
);
847 chip
->taos_chip_status
= TSL258X_CHIP_UNKNOWN
;
848 memcpy(chip
->taos_config
, taos_config
, sizeof(chip
->taos_config
));
850 for (i
= 0; i
< TSL258X_MAX_DEVICE_REGS
; i
++) {
851 ret
= i2c_smbus_write_byte(clientp
,
852 (TSL258X_CMD_REG
| (TSL258X_CNTRL
+ i
)));
854 dev_err(&clientp
->dev
,
855 "i2c_smbus_write_byte to cmd reg failed in taos_probe(), err = %d\n",
859 ret
= i2c_smbus_read_byte(clientp
);
861 dev_err(&clientp
->dev
,
862 "i2c_smbus_read_byte from reg failed in taos_probe(), err = %d\n",
869 if (!taos_tsl258x_device(buf
)) {
870 dev_info(&clientp
->dev
,
871 "i2c device found but does not match expected id in taos_probe()\n");
875 ret
= i2c_smbus_write_byte(clientp
, (TSL258X_CMD_REG
| TSL258X_CNTRL
));
877 dev_err(&clientp
->dev
,
878 "i2c_smbus_write_byte() to cmd reg failed in taos_probe(), err = %d\n",
883 indio_dev
->info
= &tsl2583_info
;
884 indio_dev
->dev
.parent
= &clientp
->dev
;
885 indio_dev
->modes
= INDIO_DIRECT_MODE
;
886 indio_dev
->name
= chip
->client
->name
;
887 ret
= devm_iio_device_register(indio_dev
->dev
.parent
, indio_dev
);
889 dev_err(&clientp
->dev
, "iio registration failed\n");
893 /* Load up the V2 defaults (these are hard coded defaults for now) */
896 /* Make sure the chip is on */
897 taos_chip_on(indio_dev
);
899 dev_info(&clientp
->dev
, "Light sensor found.\n");
903 #ifdef CONFIG_PM_SLEEP
904 static int taos_suspend(struct device
*dev
)
906 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
907 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
910 mutex_lock(&chip
->als_mutex
);
912 if (chip
->taos_chip_status
== TSL258X_CHIP_WORKING
) {
913 ret
= taos_chip_off(indio_dev
);
914 chip
->taos_chip_status
= TSL258X_CHIP_SUSPENDED
;
917 mutex_unlock(&chip
->als_mutex
);
921 static int taos_resume(struct device
*dev
)
923 struct iio_dev
*indio_dev
= i2c_get_clientdata(to_i2c_client(dev
));
924 struct tsl2583_chip
*chip
= iio_priv(indio_dev
);
927 mutex_lock(&chip
->als_mutex
);
929 if (chip
->taos_chip_status
== TSL258X_CHIP_SUSPENDED
)
930 ret
= taos_chip_on(indio_dev
);
932 mutex_unlock(&chip
->als_mutex
);
936 static SIMPLE_DEV_PM_OPS(taos_pm_ops
, taos_suspend
, taos_resume
);
937 #define TAOS_PM_OPS (&taos_pm_ops)
939 #define TAOS_PM_OPS NULL
942 static struct i2c_device_id taos_idtable
[] = {
948 MODULE_DEVICE_TABLE(i2c
, taos_idtable
);
950 /* Driver definition */
951 static struct i2c_driver taos_driver
= {
956 .id_table
= taos_idtable
,
959 module_i2c_driver(taos_driver
);
961 MODULE_AUTHOR("J. August Brenner<jbrenner@taosinc.com>");
962 MODULE_DESCRIPTION("TAOS tsl2583 ambient light sensor driver");
963 MODULE_LICENSE("GPL");