]>
Commit | Line | Data |
---|---|---|
c942fddf | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
ac4f6eee JB |
2 | /* |
3 | * Device driver for monitoring ambient light intensity (lux) | |
aadc4c90 | 4 | * within the TAOS tsl258x family of devices (tsl2580, tsl2581, tsl2583). |
ac4f6eee JB |
5 | * |
6 | * Copyright (c) 2011, TAOS Corporation. | |
371894f5 | 7 | * Copyright (c) 2016-2017 Brian Masney <masneyb@onstation.org> |
ac4f6eee JB |
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> | |
99c97852 | 18 | #include <linux/module.h> |
06458e27 | 19 | #include <linux/iio/iio.h> |
b2fa81be | 20 | #include <linux/iio/sysfs.h> |
371894f5 | 21 | #include <linux/pm_runtime.h> |
ac4f6eee | 22 | |
ac4f6eee | 23 | /* Device Registers and Masks */ |
686c5922 BM |
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 | |
ac4f6eee JB |
36 | |
37 | /* tsl2583 cmd reg masks */ | |
686c5922 BM |
38 | #define TSL2583_CMD_REG 0x80 |
39 | #define TSL2583_CMD_SPL_FN 0x60 | |
8391c882 | 40 | #define TSL2583_CMD_ALS_INT_CLR 0x01 |
ac4f6eee JB |
41 | |
42 | /* tsl2583 cntrl reg masks */ | |
8391c882 | 43 | #define TSL2583_CNTL_ADC_ENBL 0x02 |
686c5922 BM |
44 | #define TSL2583_CNTL_PWR_OFF 0x00 |
45 | #define TSL2583_CNTL_PWR_ON 0x01 | |
ac4f6eee JB |
46 | |
47 | /* tsl2583 status reg masks */ | |
8391c882 BM |
48 | #define TSL2583_STA_ADC_VALID 0x01 |
49 | #define TSL2583_STA_ADC_INTR 0x10 | |
ac4f6eee JB |
50 | |
51 | /* Lux calculation constants */ | |
8391c882 | 52 | #define TSL2583_LUX_CALC_OVER_FLOW 65535 |
ac4f6eee | 53 | |
c908fb76 BM |
54 | #define TSL2583_INTERRUPT_DISABLED 0x00 |
55 | ||
6bd0cb2b BM |
56 | #define TSL2583_CHIP_ID 0x90 |
57 | #define TSL2583_CHIP_ID_MASK 0xf0 | |
58 | ||
371894f5 BM |
59 | #define TSL2583_POWER_OFF_DELAY_MS 2000 |
60 | ||
ac4f6eee | 61 | /* Per-device data */ |
686c5922 | 62 | struct tsl2583_als_info { |
ac4f6eee JB |
63 | u16 als_ch0; |
64 | u16 als_ch1; | |
65 | u16 lux; | |
66 | }; | |
67 | ||
0b6b361e BM |
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 | ||
686c5922 | 84 | struct tsl2583_settings { |
ac4f6eee JB |
85 | int als_time; |
86 | int als_gain; | |
87 | int als_gain_trim; | |
88 | int als_cal_target; | |
0b6b361e BM |
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]; | |
ac4f6eee JB |
96 | }; |
97 | ||
98 | struct tsl2583_chip { | |
99 | struct mutex als_mutex; | |
100 | struct i2c_client *client; | |
686c5922 BM |
101 | struct tsl2583_als_info als_cur_info; |
102 | struct tsl2583_settings als_settings; | |
ac4f6eee JB |
103 | int als_time_scale; |
104 | int als_saturation; | |
ac4f6eee JB |
105 | }; |
106 | ||
ac4f6eee JB |
107 | struct gainadj { |
108 | s16 ch0; | |
109 | s16 ch1; | |
143c30f4 | 110 | s16 mean; |
ac4f6eee JB |
111 | }; |
112 | ||
113 | /* Index = (0 - 3) Used to validate the gain selection index */ | |
114 | static const struct gainadj gainadj[] = { | |
143c30f4 BM |
115 | { 1, 1, 1 }, |
116 | { 8, 8, 8 }, | |
117 | { 16, 16, 16 }, | |
118 | { 107, 115, 111 } | |
ac4f6eee JB |
119 | }; |
120 | ||
121 | /* | |
122 | * Provides initial operational parameter defaults. | |
123 | * These defaults may be changed through the device's sysfs files. | |
124 | */ | |
686c5922 | 125 | static void tsl2583_defaults(struct tsl2583_chip *chip) |
ac4f6eee | 126 | { |
4a0f3614 BM |
127 | /* |
128 | * The integration time must be a multiple of 50ms and within the | |
129 | * range [50, 600] ms. | |
130 | */ | |
686c5922 | 131 | chip->als_settings.als_time = 100; |
4a0f3614 BM |
132 | |
133 | /* | |
134 | * This is an index into the gainadj table. Assume clear glass as the | |
135 | * default. | |
136 | */ | |
686c5922 | 137 | chip->als_settings.als_gain = 0; |
4a0f3614 BM |
138 | |
139 | /* Default gain trim to account for aperture effects */ | |
686c5922 | 140 | chip->als_settings.als_gain_trim = 1000; |
4a0f3614 | 141 | |
ac4f6eee | 142 | /* Known external ALS reading used for calibration */ |
686c5922 | 143 | chip->als_settings.als_cal_target = 130; |
0b6b361e BM |
144 | |
145 | /* Default lux table. */ | |
146 | memcpy(chip->als_settings.als_device_lux, tsl2583_default_lux, | |
147 | sizeof(tsl2583_default_lux)); | |
ac4f6eee JB |
148 | } |
149 | ||
ac4f6eee JB |
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 | |
0b6b361e | 157 | * of ch1 value, to the ch0 value, is calculated. The array als_device_lux[] |
ac4f6eee JB |
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 | */ | |
686c5922 | 163 | static int tsl2583_get_lux(struct iio_dev *indio_dev) |
ac4f6eee JB |
164 | { |
165 | u16 ch0, ch1; /* separated ch0/ch1 data from device */ | |
166 | u32 lux; /* raw lux calculated from device data */ | |
014fcb1d | 167 | u64 lux64; |
ac4f6eee JB |
168 | u32 ratio; |
169 | u8 buf[5]; | |
686c5922 | 170 | struct tsl2583_lux *p; |
e05e5f23 | 171 | struct tsl2583_chip *chip = iio_priv(indio_dev); |
ac4f6eee | 172 | int i, ret; |
ac4f6eee | 173 | |
686c5922 | 174 | ret = i2c_smbus_read_byte_data(chip->client, TSL2583_CMD_REG); |
ac4f6eee | 175 | if (ret < 0) { |
24ad430e BM |
176 | dev_err(&chip->client->dev, "%s: failed to read CMD_REG register\n", |
177 | __func__); | |
b3d94155 | 178 | goto done; |
ac4f6eee | 179 | } |
6ba5dee9 | 180 | |
ac4f6eee | 181 | /* is data new & valid */ |
686c5922 | 182 | if (!(ret & TSL2583_STA_ADC_INTR)) { |
24ad430e BM |
183 | dev_err(&chip->client->dev, "%s: data not valid; returning last value\n", |
184 | __func__); | |
ac4f6eee | 185 | ret = chip->als_cur_info.lux; /* return LAST VALUE */ |
b3d94155 | 186 | goto done; |
ac4f6eee JB |
187 | } |
188 | ||
189 | for (i = 0; i < 4; i++) { | |
686c5922 | 190 | int reg = TSL2583_CMD_REG | (TSL2583_ALS_CHAN0LO + i); |
f6077f43 | 191 | |
6ba5dee9 | 192 | ret = i2c_smbus_read_byte_data(chip->client, reg); |
ac4f6eee | 193 | if (ret < 0) { |
24ad430e BM |
194 | dev_err(&chip->client->dev, "%s: failed to read register %x\n", |
195 | __func__, reg); | |
b3d94155 | 196 | goto done; |
ac4f6eee | 197 | } |
6ba5dee9 | 198 | buf[i] = ret; |
ac4f6eee JB |
199 | } |
200 | ||
7f3829a3 | 201 | /* |
2fb2848f BM |
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. | |
7f3829a3 | 205 | */ |
e05e5f23 | 206 | ret = i2c_smbus_write_byte(chip->client, |
686c5922 BM |
207 | (TSL2583_CMD_REG | TSL2583_CMD_SPL_FN | |
208 | TSL2583_CMD_ALS_INT_CLR)); | |
ac4f6eee | 209 | if (ret < 0) { |
24ad430e BM |
210 | dev_err(&chip->client->dev, "%s: failed to clear the interrupt bit\n", |
211 | __func__); | |
b3d94155 | 212 | goto done; /* have no data, so return failure */ |
ac4f6eee JB |
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 | ||
d59b7b68 | 225 | if (!ch0) { |
043c1da7 BM |
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 | */ | |
ddab4a02 ERR |
231 | ret = 0; |
232 | chip->als_cur_info.lux = 0; | |
b3d94155 | 233 | goto done; |
ac4f6eee | 234 | } |
184f916f | 235 | |
ac4f6eee JB |
236 | /* calculate ratio */ |
237 | ratio = (ch1 << 15) / ch0; | |
184f916f | 238 | |
ac4f6eee | 239 | /* convert to unscaled lux using the pointer to the table */ |
0b6b361e | 240 | for (p = (struct tsl2583_lux *)chip->als_settings.als_device_lux; |
ac4f6eee JB |
241 | p->ratio != 0 && p->ratio < ratio; p++) |
242 | ; | |
243 | ||
244 | if (p->ratio == 0) { | |
245 | lux = 0; | |
246 | } else { | |
ed912556 BM |
247 | u32 ch0lux, ch1lux; |
248 | ||
ac4f6eee | 249 | ch0lux = ((ch0 * p->ch0) + |
686c5922 BM |
250 | (gainadj[chip->als_settings.als_gain].ch0 >> 1)) |
251 | / gainadj[chip->als_settings.als_gain].ch0; | |
ac4f6eee | 252 | ch1lux = ((ch1 * p->ch1) + |
686c5922 BM |
253 | (gainadj[chip->als_settings.als_gain].ch1 >> 1)) |
254 | / gainadj[chip->als_settings.als_gain].ch1; | |
ac4f6eee | 255 | |
ed912556 BM |
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; | |
ac4f6eee JB |
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 | ||
2a1e3f07 BM |
275 | /* |
276 | * Adjust for active gain scale. | |
0b6b361e | 277 | * The tsl2583_default_lux tables above have a factor of 8192 built in, |
014fcb1d BF |
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; | |
686c5922 | 285 | lux64 = lux64 * chip->als_settings.als_gain_trim; |
014fcb1d BF |
286 | lux64 >>= 13; |
287 | lux = lux64; | |
288 | lux = (lux + 500) / 1000; | |
184f916f | 289 | |
686c5922 | 290 | if (lux > TSL2583_LUX_CALC_OVER_FLOW) { /* check for overflow */ |
ac4f6eee | 291 | return_max: |
686c5922 | 292 | lux = TSL2583_LUX_CALC_OVER_FLOW; |
ac4f6eee JB |
293 | } |
294 | ||
295 | /* Update the structure with the latest VALID lux. */ | |
296 | chip->als_cur_info.lux = lux; | |
297 | ret = lux; | |
298 | ||
b3d94155 | 299 | done: |
ac4f6eee JB |
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 | */ | |
686c5922 | 308 | static int tsl2583_als_calibrate(struct iio_dev *indio_dev) |
ac4f6eee | 309 | { |
e05e5f23 | 310 | struct tsl2583_chip *chip = iio_priv(indio_dev); |
ac4f6eee JB |
311 | unsigned int gain_trim_val; |
312 | int ret; | |
313 | int lux_val; | |
314 | ||
6ba5dee9 | 315 | ret = i2c_smbus_read_byte_data(chip->client, |
686c5922 | 316 | TSL2583_CMD_REG | TSL2583_CNTRL); |
ac4f6eee | 317 | if (ret < 0) { |
e05e5f23 | 318 | dev_err(&chip->client->dev, |
24ad430e | 319 | "%s: failed to read from the CNTRL register\n", |
9d5f36d2 BM |
320 | __func__); |
321 | return ret; | |
322 | } | |
323 | ||
686c5922 BM |
324 | if ((ret & (TSL2583_CNTL_ADC_ENBL | TSL2583_CNTL_PWR_ON)) |
325 | != (TSL2583_CNTL_ADC_ENBL | TSL2583_CNTL_PWR_ON)) { | |
e05e5f23 | 326 | dev_err(&chip->client->dev, |
24ad430e BM |
327 | "%s: Device is not powered on and/or ADC is not enabled\n", |
328 | __func__); | |
20d823af | 329 | return -EINVAL; |
686c5922 | 330 | } else if ((ret & TSL2583_STA_ADC_VALID) != TSL2583_STA_ADC_VALID) { |
e05e5f23 | 331 | dev_err(&chip->client->dev, |
24ad430e BM |
332 | "%s: The two ADC channels have not completed an integration cycle\n", |
333 | __func__); | |
ac4f6eee JB |
334 | return -ENODATA; |
335 | } | |
184f916f | 336 | |
686c5922 | 337 | lux_val = tsl2583_get_lux(indio_dev); |
ac4f6eee | 338 | if (lux_val < 0) { |
24ad430e BM |
339 | dev_err(&chip->client->dev, "%s: failed to get lux\n", |
340 | __func__); | |
ac4f6eee JB |
341 | return lux_val; |
342 | } | |
184f916f | 343 | |
686c5922 BM |
344 | gain_trim_val = (unsigned int)(((chip->als_settings.als_cal_target) |
345 | * chip->als_settings.als_gain_trim) / lux_val); | |
ac4f6eee | 346 | if ((gain_trim_val < 250) || (gain_trim_val > 4000)) { |
e05e5f23 | 347 | dev_err(&chip->client->dev, |
24ad430e BM |
348 | "%s: trim_val of %d is not within the range [250, 4000]\n", |
349 | __func__, gain_trim_val); | |
ac4f6eee JB |
350 | return -ENODATA; |
351 | } | |
184f916f | 352 | |
686c5922 | 353 | chip->als_settings.als_gain_trim = (int)gain_trim_val; |
ac4f6eee | 354 | |
a8898dce | 355 | return 0; |
ac4f6eee JB |
356 | } |
357 | ||
2167769a BM |
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 */ | |
686c5922 | 364 | als_count = (chip->als_settings.als_time * 100 + 135) / 270; |
2167769a BM |
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, | |
686c5922 | 373 | TSL2583_CMD_REG | TSL2583_ALS_TIME, |
2167769a BM |
374 | val); |
375 | if (ret < 0) { | |
24ad430e | 376 | dev_err(&chip->client->dev, "%s: failed to set the als time to %d\n", |
2167769a BM |
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 | ||
686c5922 | 392 | /* Set the gain based on als_settings struct */ |
2167769a | 393 | ret = i2c_smbus_write_byte_data(chip->client, |
686c5922 BM |
394 | TSL2583_CMD_REG | TSL2583_GAIN, |
395 | chip->als_settings.als_gain); | |
2167769a | 396 | if (ret < 0) |
24ad430e BM |
397 | dev_err(&chip->client->dev, |
398 | "%s: failed to set the gain to %d\n", __func__, | |
686c5922 | 399 | chip->als_settings.als_gain); |
2167769a BM |
400 | |
401 | return ret; | |
402 | } | |
403 | ||
c908fb76 BM |
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, | |
686c5922 | 409 | TSL2583_CMD_REG | TSL2583_CNTRL, state); |
c908fb76 | 410 | if (ret < 0) |
24ad430e BM |
411 | dev_err(&chip->client->dev, |
412 | "%s: failed to set the power state to %d\n", __func__, | |
413 | state); | |
c908fb76 BM |
414 | |
415 | return ret; | |
416 | } | |
417 | ||
ac4f6eee JB |
418 | /* |
419 | * Turn the device on. | |
420 | * Configuration must be set before calling this function. | |
421 | */ | |
c908fb76 | 422 | static int tsl2583_chip_init_and_power_on(struct iio_dev *indio_dev) |
ac4f6eee | 423 | { |
e05e5f23 | 424 | struct tsl2583_chip *chip = iio_priv(indio_dev); |
2167769a | 425 | int ret; |
ac4f6eee | 426 | |
c908fb76 | 427 | /* Power on the device; ADC off. */ |
686c5922 | 428 | ret = tsl2583_set_power_state(chip, TSL2583_CNTL_PWR_ON); |
c908fb76 BM |
429 | if (ret < 0) |
430 | return ret; | |
431 | ||
432 | ret = i2c_smbus_write_byte_data(chip->client, | |
686c5922 | 433 | TSL2583_CMD_REG | TSL2583_INTERRUPT, |
c908fb76 BM |
434 | TSL2583_INTERRUPT_DISABLED); |
435 | if (ret < 0) { | |
24ad430e BM |
436 | dev_err(&chip->client->dev, |
437 | "%s: failed to disable interrupts\n", __func__); | |
c908fb76 BM |
438 | return ret; |
439 | } | |
440 | ||
2167769a BM |
441 | ret = tsl2583_set_als_time(chip); |
442 | if (ret < 0) | |
c908fb76 | 443 | return ret; |
ac4f6eee | 444 | |
2167769a BM |
445 | ret = tsl2583_set_als_gain(chip); |
446 | if (ret < 0) | |
c908fb76 | 447 | return ret; |
ac4f6eee | 448 | |
7fe704ce | 449 | usleep_range(3000, 3500); |
c908fb76 | 450 | |
686c5922 BM |
451 | ret = tsl2583_set_power_state(chip, TSL2583_CNTL_PWR_ON | |
452 | TSL2583_CNTL_ADC_ENBL); | |
c908fb76 | 453 | if (ret < 0) |
67fc0120 | 454 | return ret; |
c908fb76 | 455 | |
ac4f6eee JB |
456 | return ret; |
457 | } | |
458 | ||
ac4f6eee | 459 | /* Sysfs Interface Functions */ |
ac4f6eee | 460 | |
b2fa81be BM |
461 | static ssize_t in_illuminance_input_target_show(struct device *dev, |
462 | struct device_attribute *attr, | |
463 | char *buf) | |
ac4f6eee | 464 | { |
96f691f9 | 465 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
e05e5f23 | 466 | struct tsl2583_chip *chip = iio_priv(indio_dev); |
1b7e9e2c BM |
467 | int ret; |
468 | ||
469 | mutex_lock(&chip->als_mutex); | |
686c5922 | 470 | ret = sprintf(buf, "%d\n", chip->als_settings.als_cal_target); |
1b7e9e2c | 471 | mutex_unlock(&chip->als_mutex); |
ac4f6eee | 472 | |
1b7e9e2c | 473 | return ret; |
ac4f6eee JB |
474 | } |
475 | ||
b2fa81be BM |
476 | static ssize_t in_illuminance_input_target_store(struct device *dev, |
477 | struct device_attribute *attr, | |
478 | const char *buf, size_t len) | |
ac4f6eee | 479 | { |
96f691f9 | 480 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
e05e5f23 | 481 | struct tsl2583_chip *chip = iio_priv(indio_dev); |
e5e26dd5 | 482 | int value; |
ac4f6eee | 483 | |
f375a49f | 484 | if (kstrtoint(buf, 0, &value) || !value) |
ac4f6eee JB |
485 | return -EINVAL; |
486 | ||
1b7e9e2c | 487 | mutex_lock(&chip->als_mutex); |
686c5922 | 488 | chip->als_settings.als_cal_target = value; |
1b7e9e2c | 489 | mutex_unlock(&chip->als_mutex); |
ac4f6eee JB |
490 | |
491 | return len; | |
492 | } | |
493 | ||
b2fa81be BM |
494 | static ssize_t in_illuminance_calibrate_store(struct device *dev, |
495 | struct device_attribute *attr, | |
496 | const char *buf, size_t len) | |
ac4f6eee | 497 | { |
96f691f9 | 498 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
1b7e9e2c | 499 | struct tsl2583_chip *chip = iio_priv(indio_dev); |
acf9ead8 | 500 | int value, ret; |
ac4f6eee | 501 | |
f375a49f | 502 | if (kstrtoint(buf, 0, &value) || value != 1) |
ac4f6eee JB |
503 | return -EINVAL; |
504 | ||
1b7e9e2c | 505 | mutex_lock(&chip->als_mutex); |
acf9ead8 | 506 | |
686c5922 | 507 | ret = tsl2583_als_calibrate(indio_dev); |
acf9ead8 BM |
508 | if (ret < 0) |
509 | goto done; | |
510 | ||
511 | ret = len; | |
512 | done: | |
1b7e9e2c | 513 | mutex_unlock(&chip->als_mutex); |
ac4f6eee | 514 | |
acf9ead8 | 515 | return ret; |
ac4f6eee JB |
516 | } |
517 | ||
b2fa81be BM |
518 | static ssize_t in_illuminance_lux_table_show(struct device *dev, |
519 | struct device_attribute *attr, | |
520 | char *buf) | |
ac4f6eee | 521 | { |
0b6b361e BM |
522 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
523 | struct tsl2583_chip *chip = iio_priv(indio_dev); | |
6d94de6a | 524 | unsigned int i; |
ac4f6eee JB |
525 | int offset = 0; |
526 | ||
0b6b361e | 527 | for (i = 0; i < ARRAY_SIZE(chip->als_settings.als_device_lux); i++) { |
3a70eb87 | 528 | offset += sprintf(buf + offset, "%u,%u,%u,", |
0b6b361e BM |
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) { | |
7f3829a3 ERR |
533 | /* |
534 | * We just printed the first "0" entry. | |
535 | * Now get rid of the extra "," and break. | |
536 | */ | |
ac4f6eee JB |
537 | offset--; |
538 | break; | |
539 | } | |
540 | } | |
541 | ||
542 | offset += sprintf(buf + offset, "\n"); | |
184f916f | 543 | |
ac4f6eee JB |
544 | return offset; |
545 | } | |
546 | ||
b2fa81be BM |
547 | static ssize_t in_illuminance_lux_table_store(struct device *dev, |
548 | struct device_attribute *attr, | |
549 | const char *buf, size_t len) | |
ac4f6eee | 550 | { |
96f691f9 | 551 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
e05e5f23 | 552 | struct tsl2583_chip *chip = iio_priv(indio_dev); |
0b6b361e | 553 | const unsigned int max_ints = TSL2583_MAX_LUX_TABLE_ENTRIES * 3; |
0e8d2b0f | 554 | int value[TSL2583_MAX_LUX_TABLE_ENTRIES * 3 + 1]; |
6d94de6a BM |
555 | int ret = -EINVAL; |
556 | unsigned int n; | |
ac4f6eee | 557 | |
1b7e9e2c BM |
558 | mutex_lock(&chip->als_mutex); |
559 | ||
ac4f6eee JB |
560 | get_options(buf, ARRAY_SIZE(value), value); |
561 | ||
2a1e3f07 BM |
562 | /* |
563 | * We now have an array of ints starting at value[1], and | |
ac4f6eee JB |
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]; | |
0b6b361e | 569 | if ((n % 3) || n < 6 || n > max_ints) { |
24ad430e | 570 | dev_err(dev, |
0b6b361e BM |
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); | |
84bc1704 | 573 | goto done; |
ac4f6eee | 574 | } |
1ad51360 | 575 | if ((value[n - 2] | value[n - 1] | value[n]) != 0) { |
24ad430e BM |
576 | dev_err(dev, "%s: The last 3 entries in the lux table must be zeros.\n", |
577 | __func__); | |
84bc1704 | 578 | goto done; |
ac4f6eee JB |
579 | } |
580 | ||
0b6b361e BM |
581 | memcpy(chip->als_settings.als_device_lux, &value[1], |
582 | value[0] * sizeof(value[1])); | |
ac4f6eee | 583 | |
84bc1704 BM |
584 | ret = len; |
585 | ||
586 | done: | |
1b7e9e2c BM |
587 | mutex_unlock(&chip->als_mutex); |
588 | ||
84bc1704 | 589 | return ret; |
ac4f6eee JB |
590 | } |
591 | ||
b2fa81be BM |
592 | static IIO_CONST_ATTR(in_illuminance_calibscale_available, "1 8 16 111"); |
593 | static IIO_CONST_ATTR(in_illuminance_integration_time_available, | |
4833dc4b | 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"); |
b2fa81be BM |
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); | |
ac4f6eee JB |
598 | |
599 | static struct attribute *sysfs_attrs_ctrl[] = { | |
b2fa81be BM |
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, | |
ac4f6eee JB |
605 | NULL |
606 | }; | |
607 | ||
58fce732 | 608 | static const struct attribute_group tsl2583_attribute_group = { |
ac4f6eee JB |
609 | .attrs = sysfs_attrs_ctrl, |
610 | }; | |
611 | ||
b3d94155 BM |
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) | | |
143c30f4 | 629 | BIT(IIO_CHAN_INFO_CALIBSCALE) | |
b3d94155 BM |
630 | BIT(IIO_CHAN_INFO_INT_TIME), |
631 | }, | |
632 | }; | |
633 | ||
371894f5 BM |
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 | ||
b3d94155 BM |
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); | |
371894f5 | 655 | int ret, pm_ret; |
b3d94155 | 656 | |
371894f5 BM |
657 | ret = tsl2583_set_pm_runtime_busy(chip, true); |
658 | if (ret < 0) | |
659 | return ret; | |
b3d94155 | 660 | |
371894f5 | 661 | mutex_lock(&chip->als_mutex); |
b3d94155 | 662 | |
371894f5 | 663 | ret = -EINVAL; |
b3d94155 BM |
664 | switch (mask) { |
665 | case IIO_CHAN_INFO_RAW: | |
666 | if (chan->type == IIO_LIGHT) { | |
686c5922 | 667 | ret = tsl2583_get_lux(indio_dev); |
b3d94155 BM |
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) { | |
686c5922 | 690 | ret = tsl2583_get_lux(indio_dev); |
b3d94155 BM |
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) { | |
686c5922 | 700 | *val = chip->als_settings.als_gain_trim; |
b3d94155 BM |
701 | ret = IIO_VAL_INT; |
702 | } | |
703 | break; | |
143c30f4 BM |
704 | case IIO_CHAN_INFO_CALIBSCALE: |
705 | if (chan->type == IIO_LIGHT) { | |
686c5922 | 706 | *val = gainadj[chip->als_settings.als_gain].mean; |
143c30f4 BM |
707 | ret = IIO_VAL_INT; |
708 | } | |
709 | break; | |
b3d94155 BM |
710 | case IIO_CHAN_INFO_INT_TIME: |
711 | if (chan->type == IIO_LIGHT) { | |
712 | *val = 0; | |
686c5922 | 713 | *val2 = chip->als_settings.als_time; |
b3d94155 BM |
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 | ||
371894f5 BM |
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 | ||
b3d94155 BM |
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); | |
371894f5 | 744 | int ret; |
b3d94155 | 745 | |
371894f5 BM |
746 | ret = tsl2583_set_pm_runtime_busy(chip, true); |
747 | if (ret < 0) | |
748 | return ret; | |
b3d94155 | 749 | |
371894f5 | 750 | mutex_lock(&chip->als_mutex); |
b3d94155 | 751 | |
371894f5 | 752 | ret = -EINVAL; |
b3d94155 BM |
753 | switch (mask) { |
754 | case IIO_CHAN_INFO_CALIBBIAS: | |
755 | if (chan->type == IIO_LIGHT) { | |
686c5922 | 756 | chip->als_settings.als_gain_trim = val; |
b3d94155 BM |
757 | ret = 0; |
758 | } | |
759 | break; | |
143c30f4 BM |
760 | case IIO_CHAN_INFO_CALIBSCALE: |
761 | if (chan->type == IIO_LIGHT) { | |
6d94de6a | 762 | unsigned int i; |
143c30f4 BM |
763 | |
764 | for (i = 0; i < ARRAY_SIZE(gainadj); i++) { | |
765 | if (gainadj[i].mean == val) { | |
686c5922 | 766 | chip->als_settings.als_gain = i; |
2167769a | 767 | ret = tsl2583_set_als_gain(chip); |
143c30f4 BM |
768 | break; |
769 | } | |
770 | } | |
771 | } | |
772 | break; | |
b3d94155 BM |
773 | case IIO_CHAN_INFO_INT_TIME: |
774 | if (chan->type == IIO_LIGHT && !val && val2 >= 50 && | |
775 | val2 <= 650 && !(val2 % 50)) { | |
686c5922 | 776 | chip->als_settings.als_time = val2; |
2167769a | 777 | ret = tsl2583_set_als_time(chip); |
b3d94155 BM |
778 | } |
779 | break; | |
780 | default: | |
781 | break; | |
782 | } | |
783 | ||
b3d94155 BM |
784 | mutex_unlock(&chip->als_mutex); |
785 | ||
371894f5 BM |
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 | ||
b3d94155 BM |
793 | return ret; |
794 | } | |
795 | ||
6fe8135f JC |
796 | static const struct iio_info tsl2583_info = { |
797 | .attrs = &tsl2583_attribute_group, | |
b3d94155 BM |
798 | .read_raw = tsl2583_read_raw, |
799 | .write_raw = tsl2583_write_raw, | |
6fe8135f JC |
800 | }; |
801 | ||
686c5922 BM |
802 | static int tsl2583_probe(struct i2c_client *clientp, |
803 | const struct i2c_device_id *idp) | |
ac4f6eee | 804 | { |
6bd0cb2b | 805 | int ret; |
e05e5f23 JC |
806 | struct tsl2583_chip *chip; |
807 | struct iio_dev *indio_dev; | |
ac4f6eee JB |
808 | |
809 | if (!i2c_check_functionality(clientp->adapter, | |
ca52c88c | 810 | I2C_FUNC_SMBUS_BYTE_DATA)) { |
24ad430e BM |
811 | dev_err(&clientp->dev, "%s: i2c smbus byte data functionality is unsupported\n", |
812 | __func__); | |
ac4f6eee JB |
813 | return -EOPNOTSUPP; |
814 | } | |
815 | ||
664716ae SK |
816 | indio_dev = devm_iio_device_alloc(&clientp->dev, sizeof(*chip)); |
817 | if (!indio_dev) | |
818 | return -ENOMEM; | |
184f916f | 819 | |
e05e5f23 | 820 | chip = iio_priv(indio_dev); |
ac4f6eee | 821 | chip->client = clientp; |
e05e5f23 | 822 | i2c_set_clientdata(clientp, indio_dev); |
ac4f6eee JB |
823 | |
824 | mutex_init(&chip->als_mutex); | |
ac4f6eee | 825 | |
6bd0cb2b | 826 | ret = i2c_smbus_read_byte_data(clientp, |
686c5922 | 827 | TSL2583_CMD_REG | TSL2583_CHIPID); |
6bd0cb2b BM |
828 | if (ret < 0) { |
829 | dev_err(&clientp->dev, | |
24ad430e | 830 | "%s: failed to read the chip ID register\n", __func__); |
6bd0cb2b | 831 | return ret; |
ac4f6eee JB |
832 | } |
833 | ||
6bd0cb2b | 834 | if ((ret & TSL2583_CHIP_ID_MASK) != TSL2583_CHIP_ID) { |
24ad430e BM |
835 | dev_err(&clientp->dev, "%s: received an unknown chip ID %x\n", |
836 | __func__, ret); | |
664716ae | 837 | return -EINVAL; |
ac4f6eee JB |
838 | } |
839 | ||
e05e5f23 | 840 | indio_dev->info = &tsl2583_info; |
b3d94155 BM |
841 | indio_dev->channels = tsl2583_channels; |
842 | indio_dev->num_channels = ARRAY_SIZE(tsl2583_channels); | |
e05e5f23 JC |
843 | indio_dev->dev.parent = &clientp->dev; |
844 | indio_dev->modes = INDIO_DIRECT_MODE; | |
845 | indio_dev->name = chip->client->name; | |
184f916f | 846 | |
371894f5 BM |
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 | ||
86727e30 | 852 | ret = devm_iio_device_register(indio_dev->dev.parent, indio_dev); |
ac4f6eee | 853 | if (ret) { |
24ad430e BM |
854 | dev_err(&clientp->dev, "%s: iio registration failed\n", |
855 | __func__); | |
664716ae | 856 | return ret; |
ac4f6eee JB |
857 | } |
858 | ||
859 | /* Load up the V2 defaults (these are hard coded defaults for now) */ | |
686c5922 | 860 | tsl2583_defaults(chip); |
ac4f6eee | 861 | |
ac4f6eee | 862 | dev_info(&clientp->dev, "Light sensor found.\n"); |
184f916f | 863 | |
ac4f6eee | 864 | return 0; |
ac4f6eee JB |
865 | } |
866 | ||
371894f5 BM |
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 | ||
686c5922 | 881 | static int __maybe_unused tsl2583_suspend(struct device *dev) |
ac4f6eee | 882 | { |
01788c53 | 883 | struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); |
e05e5f23 | 884 | struct tsl2583_chip *chip = iio_priv(indio_dev); |
0859fdd3 | 885 | int ret; |
ac4f6eee JB |
886 | |
887 | mutex_lock(&chip->als_mutex); | |
888 | ||
686c5922 | 889 | ret = tsl2583_set_power_state(chip, TSL2583_CNTL_PWR_OFF); |
ac4f6eee JB |
890 | |
891 | mutex_unlock(&chip->als_mutex); | |
184f916f | 892 | |
ac4f6eee JB |
893 | return ret; |
894 | } | |
895 | ||
686c5922 | 896 | static int __maybe_unused tsl2583_resume(struct device *dev) |
ac4f6eee | 897 | { |
01788c53 | 898 | struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); |
e05e5f23 | 899 | struct tsl2583_chip *chip = iio_priv(indio_dev); |
0859fdd3 | 900 | int ret; |
ac4f6eee JB |
901 | |
902 | mutex_lock(&chip->als_mutex); | |
903 | ||
2ff8a35b | 904 | ret = tsl2583_chip_init_and_power_on(indio_dev); |
ac4f6eee JB |
905 | |
906 | mutex_unlock(&chip->als_mutex); | |
184f916f | 907 | |
ac4f6eee JB |
908 | return ret; |
909 | } | |
910 | ||
371894f5 BM |
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 | }; | |
ac4f6eee | 916 | |
3282fa3c | 917 | static const struct i2c_device_id tsl2583_idtable[] = { |
ac4f6eee JB |
918 | { "tsl2580", 0 }, |
919 | { "tsl2581", 1 }, | |
920 | { "tsl2583", 2 }, | |
921 | {} | |
922 | }; | |
686c5922 | 923 | MODULE_DEVICE_TABLE(i2c, tsl2583_idtable); |
ac4f6eee | 924 | |
686c5922 | 925 | static const struct of_device_id tsl2583_of_match[] = { |
a3b6b4b6 BM |
926 | { .compatible = "amstaos,tsl2580", }, |
927 | { .compatible = "amstaos,tsl2581", }, | |
928 | { .compatible = "amstaos,tsl2583", }, | |
929 | { }, | |
930 | }; | |
686c5922 | 931 | MODULE_DEVICE_TABLE(of, tsl2583_of_match); |
a3b6b4b6 | 932 | |
ac4f6eee | 933 | /* Driver definition */ |
686c5922 | 934 | static struct i2c_driver tsl2583_driver = { |
ac4f6eee JB |
935 | .driver = { |
936 | .name = "tsl2583", | |
686c5922 BM |
937 | .pm = &tsl2583_pm_ops, |
938 | .of_match_table = tsl2583_of_match, | |
ac4f6eee | 939 | }, |
686c5922 BM |
940 | .id_table = tsl2583_idtable, |
941 | .probe = tsl2583_probe, | |
371894f5 | 942 | .remove = tsl2583_remove, |
ac4f6eee | 943 | }; |
686c5922 | 944 | module_i2c_driver(tsl2583_driver); |
ac4f6eee | 945 | |
c45a226f BM |
946 | MODULE_AUTHOR("J. August Brenner <jbrenner@taosinc.com>"); |
947 | MODULE_AUTHOR("Brian Masney <masneyb@onstation.org>"); | |
ac4f6eee JB |
948 | MODULE_DESCRIPTION("TAOS tsl2583 ambient light sensor driver"); |
949 | MODULE_LICENSE("GPL"); |