1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Support for Lite-On LTR501 and similar ambient light and proximity sensors.
4 *
5 * Copyright 2014 Peter Meerwald <pmeerw@pmeerw.net>
6 *
7 * 7-bit I2C slave address 0x23
8 *
9 * TODO: IR LED characteristics
10 */
11
12 #include <linux/module.h>
13 #include <linux/i2c.h>
14 #include <linux/err.h>
15 #include <linux/delay.h>
16 #include <linux/regmap.h>
17 #include <linux/regulator/consumer.h>
18
19 #include <linux/iio/iio.h>
20 #include <linux/iio/events.h>
21 #include <linux/iio/sysfs.h>
22 #include <linux/iio/trigger_consumer.h>
23 #include <linux/iio/buffer.h>
24 #include <linux/iio/triggered_buffer.h>
25
26 #define LTR501_ALS_CONTR 0x80 /* ALS operation mode, SW reset */
27 #define LTR501_PS_CONTR 0x81 /* PS operation mode */
28 #define LTR501_PS_MEAS_RATE 0x84 /* measurement rate*/
29 #define LTR501_ALS_MEAS_RATE 0x85 /* ALS integ time, measurement rate*/
30 #define LTR501_PART_ID 0x86
31 #define LTR501_MANUFAC_ID 0x87
32 #define LTR501_ALS_DATA1 0x88 /* 16-bit, little endian */
33 #define LTR501_ALS_DATA1_UPPER 0x89 /* upper 8 bits of LTR501_ALS_DATA1 */
34 #define LTR501_ALS_DATA0 0x8a /* 16-bit, little endian */
35 #define LTR501_ALS_DATA0_UPPER 0x8b /* upper 8 bits of LTR501_ALS_DATA0 */
36 #define LTR501_ALS_PS_STATUS 0x8c
37 #define LTR501_PS_DATA 0x8d /* 16-bit, little endian */
38 #define LTR501_PS_DATA_UPPER 0x8e /* upper 8 bits of LTR501_PS_DATA */
39 #define LTR501_INTR 0x8f /* output mode, polarity, mode */
40 #define LTR501_PS_THRESH_UP 0x90 /* 11 bit, ps upper threshold */
41 #define LTR501_PS_THRESH_LOW 0x92 /* 11 bit, ps lower threshold */
42 #define LTR501_ALS_THRESH_UP 0x97 /* 16 bit, ALS upper threshold */
43 #define LTR501_ALS_THRESH_LOW 0x99 /* 16 bit, ALS lower threshold */
44 #define LTR501_INTR_PRST 0x9e /* ps thresh, als thresh */
45 #define LTR501_MAX_REG 0x9f
46
47 #define LTR501_ALS_CONTR_SW_RESET BIT(2)
48 #define LTR501_CONTR_PS_GAIN_MASK (BIT(3) | BIT(2))
49 #define LTR501_CONTR_PS_GAIN_SHIFT 2
50 #define LTR501_CONTR_ALS_GAIN_MASK BIT(3)
51 #define LTR501_CONTR_ACTIVE BIT(1)
52
53 #define LTR501_STATUS_ALS_INTR BIT(3)
54 #define LTR501_STATUS_ALS_RDY BIT(2)
55 #define LTR501_STATUS_PS_INTR BIT(1)
56 #define LTR501_STATUS_PS_RDY BIT(0)
57
58 #define LTR501_PS_DATA_MASK 0x7ff
59 #define LTR501_PS_THRESH_MASK 0x7ff
60 #define LTR501_ALS_THRESH_MASK 0xffff
61
62 #define LTR501_ALS_DEF_PERIOD 500000
63 #define LTR501_PS_DEF_PERIOD 100000
64
65 #define LTR501_LUX_CONV(vis_coeff, vis_data, ir_coeff, ir_data) \
66 ((vis_coeff * vis_data) - (ir_coeff * ir_data))
67
68 static const int int_time_mapping[] = {100000, 50000, 200000, 400000};
69
70 static const struct reg_field reg_field_it =
71 REG_FIELD(LTR501_ALS_MEAS_RATE, 3, 4);
72 static const struct reg_field reg_field_als_intr =
73 REG_FIELD(LTR501_INTR, 1, 1);
74 static const struct reg_field reg_field_ps_intr =
75 REG_FIELD(LTR501_INTR, 0, 0);
76 static const struct reg_field reg_field_als_rate =
77 REG_FIELD(LTR501_ALS_MEAS_RATE, 0, 2);
78 static const struct reg_field reg_field_ps_rate =
79 REG_FIELD(LTR501_PS_MEAS_RATE, 0, 3);
80 static const struct reg_field reg_field_als_prst =
81 REG_FIELD(LTR501_INTR_PRST, 0, 3);
82 static const struct reg_field reg_field_ps_prst =
83 REG_FIELD(LTR501_INTR_PRST, 4, 7);
84
85 struct ltr501_samp_table {
86 int freq_val; /* repetition frequency in micro HZ*/
87 int time_val; /* repetition rate in micro seconds */
88 };
89
90 #define LTR501_RESERVED_GAIN -1
91
92 enum {
93 ltr501 = 0,
94 ltr559,
95 ltr301,
96 ltr303,
97 };
98
99 struct ltr501_gain {
100 int scale;
101 int uscale;
102 };
103
104 static const struct ltr501_gain ltr501_als_gain_tbl[] = {
105 {1, 0},
106 {0, 5000},
107 };
108
109 static const struct ltr501_gain ltr559_als_gain_tbl[] = {
110 {1, 0},
111 {0, 500000},
112 {0, 250000},
113 {0, 125000},
114 {LTR501_RESERVED_GAIN, LTR501_RESERVED_GAIN},
115 {LTR501_RESERVED_GAIN, LTR501_RESERVED_GAIN},
116 {0, 20000},
117 {0, 10000},
118 };
119
120 static const struct ltr501_gain ltr501_ps_gain_tbl[] = {
121 {1, 0},
122 {0, 250000},
123 {0, 125000},
124 {0, 62500},
125 };
126
127 static const struct ltr501_gain ltr559_ps_gain_tbl[] = {
128 {0, 62500}, /* x16 gain */
129 {0, 31250}, /* x32 gain */
130 {0, 15625}, /* bits X1 are for x64 gain */
131 {0, 15624},
132 };
133
134 struct ltr501_chip_info {
135 u8 partid;
136 const struct ltr501_gain *als_gain;
137 int als_gain_tbl_size;
138 const struct ltr501_gain *ps_gain;
139 int ps_gain_tbl_size;
140 u8 als_mode_active;
141 u8 als_gain_mask;
142 u8 als_gain_shift;
143 struct iio_chan_spec const *channels;
144 const int no_channels;
145 const struct iio_info *info;
146 const struct iio_info *info_no_irq;
147 };
148
149 struct ltr501_data {
150 struct i2c_client *client;
151 struct mutex lock_als, lock_ps;
152 const struct ltr501_chip_info *chip_info;
153 u8 als_contr, ps_contr;
154 int als_period, ps_period; /* period in micro seconds */
155 struct regmap *regmap;
156 struct regmap_field *reg_it;
157 struct regmap_field *reg_als_intr;
158 struct regmap_field *reg_ps_intr;
159 struct regmap_field *reg_als_rate;
160 struct regmap_field *reg_ps_rate;
161 struct regmap_field *reg_als_prst;
162 struct regmap_field *reg_ps_prst;
163 uint32_t near_level;
164 };
165
166 static const struct ltr501_samp_table ltr501_als_samp_table[] = {
167 {20000000, 50000}, {10000000, 100000},
168 {5000000, 200000}, {2000000, 500000},
169 {1000000, 1000000}, {500000, 2000000},
170 {500000, 2000000}, {500000, 2000000}
171 };
172
173 static const struct ltr501_samp_table ltr501_ps_samp_table[] = {
174 {20000000, 50000}, {14285714, 70000},
175 {10000000, 100000}, {5000000, 200000},
176 {2000000, 500000}, {1000000, 1000000},
177 {500000, 2000000}, {500000, 2000000},
178 {500000, 2000000}
179 };
180
ltr501_match_samp_freq(const struct ltr501_samp_table * tab,int len,int val,int val2)181 static int ltr501_match_samp_freq(const struct ltr501_samp_table *tab,
182 int len, int val, int val2)
183 {
184 int i, freq;
185
186 freq = val * 1000000 + val2;
187
188 for (i = 0; i < len; i++) {
189 if (tab[i].freq_val == freq)
190 return i;
191 }
192
193 return -EINVAL;
194 }
195
ltr501_als_read_samp_freq(const struct ltr501_data * data,int * val,int * val2)196 static int ltr501_als_read_samp_freq(const struct ltr501_data *data,
197 int *val, int *val2)
198 {
199 int ret, i;
200
201 ret = regmap_field_read(data->reg_als_rate, &i);
202 if (ret < 0)
203 return ret;
204
205 if (i < 0 || i >= ARRAY_SIZE(ltr501_als_samp_table))
206 return -EINVAL;
207
208 *val = ltr501_als_samp_table[i].freq_val / 1000000;
209 *val2 = ltr501_als_samp_table[i].freq_val % 1000000;
210
211 return IIO_VAL_INT_PLUS_MICRO;
212 }
213
ltr501_ps_read_samp_freq(const struct ltr501_data * data,int * val,int * val2)214 static int ltr501_ps_read_samp_freq(const struct ltr501_data *data,
215 int *val, int *val2)
216 {
217 int ret, i;
218
219 ret = regmap_field_read(data->reg_ps_rate, &i);
220 if (ret < 0)
221 return ret;
222
223 if (i < 0 || i >= ARRAY_SIZE(ltr501_ps_samp_table))
224 return -EINVAL;
225
226 *val = ltr501_ps_samp_table[i].freq_val / 1000000;
227 *val2 = ltr501_ps_samp_table[i].freq_val % 1000000;
228
229 return IIO_VAL_INT_PLUS_MICRO;
230 }
231
ltr501_als_write_samp_freq(struct ltr501_data * data,int val,int val2)232 static int ltr501_als_write_samp_freq(struct ltr501_data *data,
233 int val, int val2)
234 {
235 int i, ret;
236
237 i = ltr501_match_samp_freq(ltr501_als_samp_table,
238 ARRAY_SIZE(ltr501_als_samp_table),
239 val, val2);
240
241 if (i < 0)
242 return i;
243
244 mutex_lock(&data->lock_als);
245 ret = regmap_field_write(data->reg_als_rate, i);
246 mutex_unlock(&data->lock_als);
247
248 return ret;
249 }
250
ltr501_ps_write_samp_freq(struct ltr501_data * data,int val,int val2)251 static int ltr501_ps_write_samp_freq(struct ltr501_data *data,
252 int val, int val2)
253 {
254 int i, ret;
255
256 i = ltr501_match_samp_freq(ltr501_ps_samp_table,
257 ARRAY_SIZE(ltr501_ps_samp_table),
258 val, val2);
259
260 if (i < 0)
261 return i;
262
263 mutex_lock(&data->lock_ps);
264 ret = regmap_field_write(data->reg_ps_rate, i);
265 mutex_unlock(&data->lock_ps);
266
267 return ret;
268 }
269
ltr501_als_read_samp_period(const struct ltr501_data * data,int * val)270 static int ltr501_als_read_samp_period(const struct ltr501_data *data, int *val)
271 {
272 int ret, i;
273
274 ret = regmap_field_read(data->reg_als_rate, &i);
275 if (ret < 0)
276 return ret;
277
278 if (i < 0 || i >= ARRAY_SIZE(ltr501_als_samp_table))
279 return -EINVAL;
280
281 *val = ltr501_als_samp_table[i].time_val;
282
283 return IIO_VAL_INT;
284 }
285
ltr501_ps_read_samp_period(const struct ltr501_data * data,int * val)286 static int ltr501_ps_read_samp_period(const struct ltr501_data *data, int *val)
287 {
288 int ret, i;
289
290 ret = regmap_field_read(data->reg_ps_rate, &i);
291 if (ret < 0)
292 return ret;
293
294 if (i < 0 || i >= ARRAY_SIZE(ltr501_ps_samp_table))
295 return -EINVAL;
296
297 *val = ltr501_ps_samp_table[i].time_val;
298
299 return IIO_VAL_INT;
300 }
301
302 /* IR and visible spectrum coeff's are given in data sheet */
ltr501_calculate_lux(u16 vis_data,u16 ir_data)303 static unsigned long ltr501_calculate_lux(u16 vis_data, u16 ir_data)
304 {
305 unsigned long ratio, lux;
306
307 if (vis_data == 0)
308 return 0;
309
310 /* multiply numerator by 100 to avoid handling ratio < 1 */
311 ratio = DIV_ROUND_UP(ir_data * 100, ir_data + vis_data);
312
313 if (ratio < 45)
314 lux = LTR501_LUX_CONV(1774, vis_data, -1105, ir_data);
315 else if (ratio >= 45 && ratio < 64)
316 lux = LTR501_LUX_CONV(3772, vis_data, 1336, ir_data);
317 else if (ratio >= 64 && ratio < 85)
318 lux = LTR501_LUX_CONV(1690, vis_data, 169, ir_data);
319 else
320 lux = 0;
321
322 return lux / 1000;
323 }
324
ltr501_drdy(const struct ltr501_data * data,u8 drdy_mask)325 static int ltr501_drdy(const struct ltr501_data *data, u8 drdy_mask)
326 {
327 int tries = 100;
328 int ret, status;
329
330 while (tries--) {
331 ret = regmap_read(data->regmap, LTR501_ALS_PS_STATUS, &status);
332 if (ret < 0)
333 return ret;
334 if ((status & drdy_mask) == drdy_mask)
335 return 0;
336 msleep(25);
337 }
338
339 dev_err(&data->client->dev, "ltr501_drdy() failed, data not ready\n");
340 return -EIO;
341 }
342
ltr501_set_it_time(struct ltr501_data * data,int it)343 static int ltr501_set_it_time(struct ltr501_data *data, int it)
344 {
345 int ret, i, index = -1, status;
346
347 for (i = 0; i < ARRAY_SIZE(int_time_mapping); i++) {
348 if (int_time_mapping[i] == it) {
349 index = i;
350 break;
351 }
352 }
353 /* Make sure integ time index is valid */
354 if (index < 0)
355 return -EINVAL;
356
357 ret = regmap_read(data->regmap, LTR501_ALS_CONTR, &status);
358 if (ret < 0)
359 return ret;
360
361 if (status & LTR501_CONTR_ALS_GAIN_MASK) {
362 /*
363 * 200 ms and 400 ms integ time can only be
364 * used in dynamic range 1
365 */
366 if (index > 1)
367 return -EINVAL;
368 } else
369 /* 50 ms integ time can only be used in dynamic range 2 */
370 if (index == 1)
371 return -EINVAL;
372
373 return regmap_field_write(data->reg_it, index);
374 }
375
376 /* read int time in micro seconds */
ltr501_read_it_time(const struct ltr501_data * data,int * val,int * val2)377 static int ltr501_read_it_time(const struct ltr501_data *data,
378 int *val, int *val2)
379 {
380 int ret, index;
381
382 ret = regmap_field_read(data->reg_it, &index);
383 if (ret < 0)
384 return ret;
385
386 /* Make sure integ time index is valid */
387 if (index < 0 || index >= ARRAY_SIZE(int_time_mapping))
388 return -EINVAL;
389
390 *val2 = int_time_mapping[index];
391 *val = 0;
392
393 return IIO_VAL_INT_PLUS_MICRO;
394 }
395
ltr501_read_als(const struct ltr501_data * data,__le16 buf[2])396 static int ltr501_read_als(const struct ltr501_data *data, __le16 buf[2])
397 {
398 int ret;
399
400 ret = ltr501_drdy(data, LTR501_STATUS_ALS_RDY);
401 if (ret < 0)
402 return ret;
403 /* always read both ALS channels in given order */
404 return regmap_bulk_read(data->regmap, LTR501_ALS_DATA1,
405 buf, 2 * sizeof(__le16));
406 }
407
ltr501_read_ps(const struct ltr501_data * data)408 static int ltr501_read_ps(const struct ltr501_data *data)
409 {
410 __le16 status;
411 int ret;
412
413 ret = ltr501_drdy(data, LTR501_STATUS_PS_RDY);
414 if (ret < 0)
415 return ret;
416
417 ret = regmap_bulk_read(data->regmap, LTR501_PS_DATA,
418 &status, sizeof(status));
419 if (ret < 0)
420 return ret;
421
422 return le16_to_cpu(status);
423 }
424
ltr501_read_intr_prst(const struct ltr501_data * data,enum iio_chan_type type,int * val2)425 static int ltr501_read_intr_prst(const struct ltr501_data *data,
426 enum iio_chan_type type,
427 int *val2)
428 {
429 int ret, samp_period, prst;
430
431 switch (type) {
432 case IIO_INTENSITY:
433 ret = regmap_field_read(data->reg_als_prst, &prst);
434 if (ret < 0)
435 return ret;
436
437 ret = ltr501_als_read_samp_period(data, &samp_period);
438
439 if (ret < 0)
440 return ret;
441 *val2 = samp_period * prst;
442 return IIO_VAL_INT_PLUS_MICRO;
443 case IIO_PROXIMITY:
444 ret = regmap_field_read(data->reg_ps_prst, &prst);
445 if (ret < 0)
446 return ret;
447
448 ret = ltr501_ps_read_samp_period(data, &samp_period);
449
450 if (ret < 0)
451 return ret;
452
453 *val2 = samp_period * prst;
454 return IIO_VAL_INT_PLUS_MICRO;
455 default:
456 return -EINVAL;
457 }
458
459 return -EINVAL;
460 }
461
ltr501_write_intr_prst(struct ltr501_data * data,enum iio_chan_type type,int val,int val2)462 static int ltr501_write_intr_prst(struct ltr501_data *data,
463 enum iio_chan_type type,
464 int val, int val2)
465 {
466 int ret, samp_period, new_val;
467 unsigned long period;
468
469 if (val < 0 || val2 < 0)
470 return -EINVAL;
471
472 /* period in microseconds */
473 period = ((val * 1000000) + val2);
474
475 switch (type) {
476 case IIO_INTENSITY:
477 ret = ltr501_als_read_samp_period(data, &samp_period);
478 if (ret < 0)
479 return ret;
480
481 /* period should be atleast equal to sampling period */
482 if (period < samp_period)
483 return -EINVAL;
484
485 new_val = DIV_ROUND_UP(period, samp_period);
486 if (new_val < 0 || new_val > 0x0f)
487 return -EINVAL;
488
489 mutex_lock(&data->lock_als);
490 ret = regmap_field_write(data->reg_als_prst, new_val);
491 mutex_unlock(&data->lock_als);
492 if (ret >= 0)
493 data->als_period = period;
494
495 return ret;
496 case IIO_PROXIMITY:
497 ret = ltr501_ps_read_samp_period(data, &samp_period);
498 if (ret < 0)
499 return ret;
500
501 /* period should be atleast equal to rate */
502 if (period < samp_period)
503 return -EINVAL;
504
505 new_val = DIV_ROUND_UP(period, samp_period);
506 if (new_val < 0 || new_val > 0x0f)
507 return -EINVAL;
508
509 mutex_lock(&data->lock_ps);
510 ret = regmap_field_write(data->reg_ps_prst, new_val);
511 mutex_unlock(&data->lock_ps);
512 if (ret >= 0)
513 data->ps_period = period;
514
515 return ret;
516 default:
517 return -EINVAL;
518 }
519
520 return -EINVAL;
521 }
522
ltr501_read_near_level(struct iio_dev * indio_dev,uintptr_t priv,const struct iio_chan_spec * chan,char * buf)523 static ssize_t ltr501_read_near_level(struct iio_dev *indio_dev,
524 uintptr_t priv,
525 const struct iio_chan_spec *chan,
526 char *buf)
527 {
528 struct ltr501_data *data = iio_priv(indio_dev);
529
530 return sprintf(buf, "%u\n", data->near_level);
531 }
532
533 static const struct iio_chan_spec_ext_info ltr501_ext_info[] = {
534 {
535 .name = "nearlevel",
536 .shared = IIO_SEPARATE,
537 .read = ltr501_read_near_level,
538 },
539 { }
540 };
541
542 static const struct iio_event_spec ltr501_als_event_spec[] = {
543 {
544 .type = IIO_EV_TYPE_THRESH,
545 .dir = IIO_EV_DIR_RISING,
546 .mask_separate = BIT(IIO_EV_INFO_VALUE),
547 }, {
548 .type = IIO_EV_TYPE_THRESH,
549 .dir = IIO_EV_DIR_FALLING,
550 .mask_separate = BIT(IIO_EV_INFO_VALUE),
551 }, {
552 .type = IIO_EV_TYPE_THRESH,
553 .dir = IIO_EV_DIR_EITHER,
554 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
555 BIT(IIO_EV_INFO_PERIOD),
556 },
557
558 };
559
560 static const struct iio_event_spec ltr501_pxs_event_spec[] = {
561 {
562 .type = IIO_EV_TYPE_THRESH,
563 .dir = IIO_EV_DIR_RISING,
564 .mask_separate = BIT(IIO_EV_INFO_VALUE),
565 }, {
566 .type = IIO_EV_TYPE_THRESH,
567 .dir = IIO_EV_DIR_FALLING,
568 .mask_separate = BIT(IIO_EV_INFO_VALUE),
569 }, {
570 .type = IIO_EV_TYPE_THRESH,
571 .dir = IIO_EV_DIR_EITHER,
572 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
573 BIT(IIO_EV_INFO_PERIOD),
574 },
575 };
576
577 #define LTR501_INTENSITY_CHANNEL(_idx, _addr, _mod, _shared, \
578 _evspec, _evsize) { \
579 .type = IIO_INTENSITY, \
580 .modified = 1, \
581 .address = (_addr), \
582 .channel2 = (_mod), \
583 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
584 .info_mask_shared_by_type = (_shared), \
585 .scan_index = (_idx), \
586 .scan_type = { \
587 .sign = 'u', \
588 .realbits = 16, \
589 .storagebits = 16, \
590 .endianness = IIO_CPU, \
591 }, \
592 .event_spec = _evspec,\
593 .num_event_specs = _evsize,\
594 }
595
596 #define LTR501_LIGHT_CHANNEL() { \
597 .type = IIO_LIGHT, \
598 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
599 .scan_index = -1, \
600 }
601
602 static const struct iio_chan_spec ltr501_channels[] = {
603 LTR501_LIGHT_CHANNEL(),
604 LTR501_INTENSITY_CHANNEL(0, LTR501_ALS_DATA0, IIO_MOD_LIGHT_BOTH, 0,
605 ltr501_als_event_spec,
606 ARRAY_SIZE(ltr501_als_event_spec)),
607 LTR501_INTENSITY_CHANNEL(1, LTR501_ALS_DATA1, IIO_MOD_LIGHT_IR,
608 BIT(IIO_CHAN_INFO_SCALE) |
609 BIT(IIO_CHAN_INFO_INT_TIME) |
610 BIT(IIO_CHAN_INFO_SAMP_FREQ),
611 NULL, 0),
612 {
613 .type = IIO_PROXIMITY,
614 .address = LTR501_PS_DATA,
615 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
616 BIT(IIO_CHAN_INFO_SCALE),
617 .scan_index = 2,
618 .scan_type = {
619 .sign = 'u',
620 .realbits = 11,
621 .storagebits = 16,
622 .endianness = IIO_CPU,
623 },
624 .event_spec = ltr501_pxs_event_spec,
625 .num_event_specs = ARRAY_SIZE(ltr501_pxs_event_spec),
626 .ext_info = ltr501_ext_info,
627 },
628 IIO_CHAN_SOFT_TIMESTAMP(3),
629 };
630
631 static const struct iio_chan_spec ltr301_channels[] = {
632 LTR501_LIGHT_CHANNEL(),
633 LTR501_INTENSITY_CHANNEL(0, LTR501_ALS_DATA0, IIO_MOD_LIGHT_BOTH, 0,
634 ltr501_als_event_spec,
635 ARRAY_SIZE(ltr501_als_event_spec)),
636 LTR501_INTENSITY_CHANNEL(1, LTR501_ALS_DATA1, IIO_MOD_LIGHT_IR,
637 BIT(IIO_CHAN_INFO_SCALE) |
638 BIT(IIO_CHAN_INFO_INT_TIME) |
639 BIT(IIO_CHAN_INFO_SAMP_FREQ),
640 NULL, 0),
641 IIO_CHAN_SOFT_TIMESTAMP(2),
642 };
643
ltr501_read_info_raw(struct ltr501_data * data,struct iio_chan_spec const * chan,int * val)644 static int ltr501_read_info_raw(struct ltr501_data *data,
645 struct iio_chan_spec const *chan,
646 int *val)
647 {
648 __le16 buf[2];
649 int ret;
650
651 switch (chan->type) {
652 case IIO_INTENSITY:
653 mutex_lock(&data->lock_als);
654 ret = ltr501_read_als(data, buf);
655 mutex_unlock(&data->lock_als);
656 if (ret < 0)
657 return ret;
658 *val = le16_to_cpu(chan->address == LTR501_ALS_DATA1 ?
659 buf[0] : buf[1]);
660 return IIO_VAL_INT;
661 case IIO_PROXIMITY:
662 mutex_lock(&data->lock_ps);
663 ret = ltr501_read_ps(data);
664 mutex_unlock(&data->lock_ps);
665 if (ret < 0)
666 return ret;
667 *val = ret & LTR501_PS_DATA_MASK;
668 return IIO_VAL_INT;
669 default:
670 return -EINVAL;
671 }
672 }
673
ltr501_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)674 static int ltr501_read_raw(struct iio_dev *indio_dev,
675 struct iio_chan_spec const *chan,
676 int *val, int *val2, long mask)
677 {
678 struct ltr501_data *data = iio_priv(indio_dev);
679 __le16 buf[2];
680 int ret, i;
681
682 switch (mask) {
683 case IIO_CHAN_INFO_PROCESSED:
684 switch (chan->type) {
685 case IIO_LIGHT:
686 if (!iio_device_claim_direct(indio_dev))
687 return -EBUSY;
688
689 mutex_lock(&data->lock_als);
690 ret = ltr501_read_als(data, buf);
691 mutex_unlock(&data->lock_als);
692 iio_device_release_direct(indio_dev);
693 if (ret < 0)
694 return ret;
695 *val = ltr501_calculate_lux(le16_to_cpu(buf[1]),
696 le16_to_cpu(buf[0]));
697 return IIO_VAL_INT;
698 default:
699 return -EINVAL;
700 }
701 case IIO_CHAN_INFO_RAW:
702 if (!iio_device_claim_direct(indio_dev))
703 return -EBUSY;
704
705 ret = ltr501_read_info_raw(data, chan, val);
706
707 iio_device_release_direct(indio_dev);
708 return ret;
709
710 case IIO_CHAN_INFO_SCALE:
711 switch (chan->type) {
712 case IIO_INTENSITY:
713 i = (data->als_contr & data->chip_info->als_gain_mask)
714 >> data->chip_info->als_gain_shift;
715 *val = data->chip_info->als_gain[i].scale;
716 *val2 = data->chip_info->als_gain[i].uscale;
717 return IIO_VAL_INT_PLUS_MICRO;
718 case IIO_PROXIMITY:
719 i = (data->ps_contr & LTR501_CONTR_PS_GAIN_MASK) >>
720 LTR501_CONTR_PS_GAIN_SHIFT;
721 *val = data->chip_info->ps_gain[i].scale;
722 *val2 = data->chip_info->ps_gain[i].uscale;
723 return IIO_VAL_INT_PLUS_MICRO;
724 default:
725 return -EINVAL;
726 }
727 case IIO_CHAN_INFO_INT_TIME:
728 switch (chan->type) {
729 case IIO_INTENSITY:
730 return ltr501_read_it_time(data, val, val2);
731 default:
732 return -EINVAL;
733 }
734 case IIO_CHAN_INFO_SAMP_FREQ:
735 switch (chan->type) {
736 case IIO_INTENSITY:
737 return ltr501_als_read_samp_freq(data, val, val2);
738 case IIO_PROXIMITY:
739 return ltr501_ps_read_samp_freq(data, val, val2);
740 default:
741 return -EINVAL;
742 }
743 }
744 return -EINVAL;
745 }
746
ltr501_get_gain_index(const struct ltr501_gain * gain,int size,int val,int val2)747 static int ltr501_get_gain_index(const struct ltr501_gain *gain, int size,
748 int val, int val2)
749 {
750 int i;
751
752 for (i = 0; i < size; i++)
753 if (val == gain[i].scale && val2 == gain[i].uscale)
754 return i;
755
756 return -EINVAL;
757 }
758
__ltr501_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)759 static int __ltr501_write_raw(struct iio_dev *indio_dev,
760 struct iio_chan_spec const *chan,
761 int val, int val2, long mask)
762 {
763 struct ltr501_data *data = iio_priv(indio_dev);
764 int i, ret, freq_val, freq_val2;
765 const struct ltr501_chip_info *info = data->chip_info;
766
767 switch (mask) {
768 case IIO_CHAN_INFO_SCALE:
769 switch (chan->type) {
770 case IIO_INTENSITY:
771 i = ltr501_get_gain_index(info->als_gain,
772 info->als_gain_tbl_size,
773 val, val2);
774 if (i < 0)
775 return i;
776
777 data->als_contr &= ~info->als_gain_mask;
778 data->als_contr |= i << info->als_gain_shift;
779
780 return regmap_write(data->regmap, LTR501_ALS_CONTR,
781 data->als_contr);
782 case IIO_PROXIMITY:
783 i = ltr501_get_gain_index(info->ps_gain,
784 info->ps_gain_tbl_size,
785 val, val2);
786 if (i < 0)
787 return i;
788
789 data->ps_contr &= ~LTR501_CONTR_PS_GAIN_MASK;
790 data->ps_contr |= i << LTR501_CONTR_PS_GAIN_SHIFT;
791
792 return regmap_write(data->regmap, LTR501_PS_CONTR,
793 data->ps_contr);
794 default:
795 return -EINVAL;
796 }
797
798 case IIO_CHAN_INFO_INT_TIME:
799 switch (chan->type) {
800 case IIO_INTENSITY:
801 if (val != 0)
802 return -EINVAL;
803
804 mutex_lock(&data->lock_als);
805 ret = ltr501_set_it_time(data, val2);
806 mutex_unlock(&data->lock_als);
807 return ret;
808 default:
809 return -EINVAL;
810 }
811
812 case IIO_CHAN_INFO_SAMP_FREQ:
813 switch (chan->type) {
814 case IIO_INTENSITY:
815 ret = ltr501_als_read_samp_freq(data, &freq_val,
816 &freq_val2);
817 if (ret < 0)
818 return ret;
819
820 ret = ltr501_als_write_samp_freq(data, val, val2);
821 if (ret < 0)
822 return ret;
823
824 /* update persistence count when changing frequency */
825 ret = ltr501_write_intr_prst(data, chan->type,
826 0, data->als_period);
827
828 if (ret < 0)
829 /* Do not ovewrite error */
830 ltr501_als_write_samp_freq(data, freq_val,
831 freq_val2);
832 return ret;
833 case IIO_PROXIMITY:
834 ret = ltr501_ps_read_samp_freq(data, &freq_val,
835 &freq_val2);
836 if (ret < 0)
837 return ret;
838
839 ret = ltr501_ps_write_samp_freq(data, val, val2);
840 if (ret < 0)
841 return ret;
842
843 /* update persistence count when changing frequency */
844 ret = ltr501_write_intr_prst(data, chan->type,
845 0, data->ps_period);
846
847 if (ret < 0)
848 /* Do not overwrite error */
849 ltr501_ps_write_samp_freq(data, freq_val,
850 freq_val2);
851 return ret;
852 default:
853 return -EINVAL;
854 }
855 default:
856 return -EINVAL;
857 }
858 }
859
ltr501_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)860 static int ltr501_write_raw(struct iio_dev *indio_dev,
861 struct iio_chan_spec const *chan,
862 int val, int val2, long mask)
863 {
864 int ret;
865
866 if (!iio_device_claim_direct(indio_dev))
867 return -EBUSY;
868
869 ret = __ltr501_write_raw(indio_dev, chan, val, val2, mask);
870
871 iio_device_release_direct(indio_dev);
872
873 return ret;
874 }
875
ltr501_read_thresh(const struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)876 static int ltr501_read_thresh(const struct iio_dev *indio_dev,
877 const struct iio_chan_spec *chan,
878 enum iio_event_type type,
879 enum iio_event_direction dir,
880 enum iio_event_info info,
881 int *val, int *val2)
882 {
883 const struct ltr501_data *data = iio_priv(indio_dev);
884 int ret, thresh_data;
885
886 switch (chan->type) {
887 case IIO_INTENSITY:
888 switch (dir) {
889 case IIO_EV_DIR_RISING:
890 ret = regmap_bulk_read(data->regmap,
891 LTR501_ALS_THRESH_UP,
892 &thresh_data, 2);
893 if (ret < 0)
894 return ret;
895 *val = thresh_data & LTR501_ALS_THRESH_MASK;
896 return IIO_VAL_INT;
897 case IIO_EV_DIR_FALLING:
898 ret = regmap_bulk_read(data->regmap,
899 LTR501_ALS_THRESH_LOW,
900 &thresh_data, 2);
901 if (ret < 0)
902 return ret;
903 *val = thresh_data & LTR501_ALS_THRESH_MASK;
904 return IIO_VAL_INT;
905 default:
906 return -EINVAL;
907 }
908 case IIO_PROXIMITY:
909 switch (dir) {
910 case IIO_EV_DIR_RISING:
911 ret = regmap_bulk_read(data->regmap,
912 LTR501_PS_THRESH_UP,
913 &thresh_data, 2);
914 if (ret < 0)
915 return ret;
916 *val = thresh_data & LTR501_PS_THRESH_MASK;
917 return IIO_VAL_INT;
918 case IIO_EV_DIR_FALLING:
919 ret = regmap_bulk_read(data->regmap,
920 LTR501_PS_THRESH_LOW,
921 &thresh_data, 2);
922 if (ret < 0)
923 return ret;
924 *val = thresh_data & LTR501_PS_THRESH_MASK;
925 return IIO_VAL_INT;
926 default:
927 return -EINVAL;
928 }
929 default:
930 return -EINVAL;
931 }
932
933 return -EINVAL;
934 }
935
ltr501_write_thresh(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)936 static int ltr501_write_thresh(struct iio_dev *indio_dev,
937 const struct iio_chan_spec *chan,
938 enum iio_event_type type,
939 enum iio_event_direction dir,
940 enum iio_event_info info,
941 int val, int val2)
942 {
943 struct ltr501_data *data = iio_priv(indio_dev);
944 int ret;
945
946 if (val < 0)
947 return -EINVAL;
948
949 switch (chan->type) {
950 case IIO_INTENSITY:
951 if (val > LTR501_ALS_THRESH_MASK)
952 return -EINVAL;
953 switch (dir) {
954 case IIO_EV_DIR_RISING:
955 mutex_lock(&data->lock_als);
956 ret = regmap_bulk_write(data->regmap,
957 LTR501_ALS_THRESH_UP,
958 &val, 2);
959 mutex_unlock(&data->lock_als);
960 return ret;
961 case IIO_EV_DIR_FALLING:
962 mutex_lock(&data->lock_als);
963 ret = regmap_bulk_write(data->regmap,
964 LTR501_ALS_THRESH_LOW,
965 &val, 2);
966 mutex_unlock(&data->lock_als);
967 return ret;
968 default:
969 return -EINVAL;
970 }
971 case IIO_PROXIMITY:
972 if (val > LTR501_PS_THRESH_MASK)
973 return -EINVAL;
974 switch (dir) {
975 case IIO_EV_DIR_RISING:
976 mutex_lock(&data->lock_ps);
977 ret = regmap_bulk_write(data->regmap,
978 LTR501_PS_THRESH_UP,
979 &val, 2);
980 mutex_unlock(&data->lock_ps);
981 return ret;
982 case IIO_EV_DIR_FALLING:
983 mutex_lock(&data->lock_ps);
984 ret = regmap_bulk_write(data->regmap,
985 LTR501_PS_THRESH_LOW,
986 &val, 2);
987 mutex_unlock(&data->lock_ps);
988 return ret;
989 default:
990 return -EINVAL;
991 }
992 default:
993 return -EINVAL;
994 }
995
996 return -EINVAL;
997 }
998
ltr501_read_event(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)999 static int ltr501_read_event(struct iio_dev *indio_dev,
1000 const struct iio_chan_spec *chan,
1001 enum iio_event_type type,
1002 enum iio_event_direction dir,
1003 enum iio_event_info info,
1004 int *val, int *val2)
1005 {
1006 int ret;
1007
1008 switch (info) {
1009 case IIO_EV_INFO_VALUE:
1010 return ltr501_read_thresh(indio_dev, chan, type, dir,
1011 info, val, val2);
1012 case IIO_EV_INFO_PERIOD:
1013 ret = ltr501_read_intr_prst(iio_priv(indio_dev),
1014 chan->type, val2);
1015 *val = *val2 / 1000000;
1016 *val2 = *val2 % 1000000;
1017 return ret;
1018 default:
1019 return -EINVAL;
1020 }
1021
1022 return -EINVAL;
1023 }
1024
ltr501_write_event(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)1025 static int ltr501_write_event(struct iio_dev *indio_dev,
1026 const struct iio_chan_spec *chan,
1027 enum iio_event_type type,
1028 enum iio_event_direction dir,
1029 enum iio_event_info info,
1030 int val, int val2)
1031 {
1032 switch (info) {
1033 case IIO_EV_INFO_VALUE:
1034 if (val2 != 0)
1035 return -EINVAL;
1036 return ltr501_write_thresh(indio_dev, chan, type, dir,
1037 info, val, val2);
1038 case IIO_EV_INFO_PERIOD:
1039 return ltr501_write_intr_prst(iio_priv(indio_dev), chan->type,
1040 val, val2);
1041 default:
1042 return -EINVAL;
1043 }
1044
1045 return -EINVAL;
1046 }
1047
ltr501_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)1048 static int ltr501_read_event_config(struct iio_dev *indio_dev,
1049 const struct iio_chan_spec *chan,
1050 enum iio_event_type type,
1051 enum iio_event_direction dir)
1052 {
1053 struct ltr501_data *data = iio_priv(indio_dev);
1054 int ret, status;
1055
1056 switch (chan->type) {
1057 case IIO_INTENSITY:
1058 ret = regmap_field_read(data->reg_als_intr, &status);
1059 if (ret < 0)
1060 return ret;
1061 return status;
1062 case IIO_PROXIMITY:
1063 ret = regmap_field_read(data->reg_ps_intr, &status);
1064 if (ret < 0)
1065 return ret;
1066 return status;
1067 default:
1068 return -EINVAL;
1069 }
1070
1071 return -EINVAL;
1072 }
1073
ltr501_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)1074 static int ltr501_write_event_config(struct iio_dev *indio_dev,
1075 const struct iio_chan_spec *chan,
1076 enum iio_event_type type,
1077 enum iio_event_direction dir, bool state)
1078 {
1079 struct ltr501_data *data = iio_priv(indio_dev);
1080 int ret;
1081
1082 switch (chan->type) {
1083 case IIO_INTENSITY:
1084 mutex_lock(&data->lock_als);
1085 ret = regmap_field_write(data->reg_als_intr, state);
1086 mutex_unlock(&data->lock_als);
1087 return ret;
1088 case IIO_PROXIMITY:
1089 mutex_lock(&data->lock_ps);
1090 ret = regmap_field_write(data->reg_ps_intr, state);
1091 mutex_unlock(&data->lock_ps);
1092 return ret;
1093 default:
1094 return -EINVAL;
1095 }
1096
1097 return -EINVAL;
1098 }
1099
ltr501_show_proximity_scale_avail(struct device * dev,struct device_attribute * attr,char * buf)1100 static ssize_t ltr501_show_proximity_scale_avail(struct device *dev,
1101 struct device_attribute *attr,
1102 char *buf)
1103 {
1104 struct ltr501_data *data = iio_priv(dev_to_iio_dev(dev));
1105 const struct ltr501_chip_info *info = data->chip_info;
1106 ssize_t len = 0;
1107 int i;
1108
1109 for (i = 0; i < info->ps_gain_tbl_size; i++) {
1110 if (info->ps_gain[i].scale == LTR501_RESERVED_GAIN)
1111 continue;
1112 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%06d ",
1113 info->ps_gain[i].scale,
1114 info->ps_gain[i].uscale);
1115 }
1116
1117 buf[len - 1] = '\n';
1118
1119 return len;
1120 }
1121
ltr501_show_intensity_scale_avail(struct device * dev,struct device_attribute * attr,char * buf)1122 static ssize_t ltr501_show_intensity_scale_avail(struct device *dev,
1123 struct device_attribute *attr,
1124 char *buf)
1125 {
1126 struct ltr501_data *data = iio_priv(dev_to_iio_dev(dev));
1127 const struct ltr501_chip_info *info = data->chip_info;
1128 ssize_t len = 0;
1129 int i;
1130
1131 for (i = 0; i < info->als_gain_tbl_size; i++) {
1132 if (info->als_gain[i].scale == LTR501_RESERVED_GAIN)
1133 continue;
1134 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%06d ",
1135 info->als_gain[i].scale,
1136 info->als_gain[i].uscale);
1137 }
1138
1139 buf[len - 1] = '\n';
1140
1141 return len;
1142 }
1143
1144 static IIO_CONST_ATTR_INT_TIME_AVAIL("0.05 0.1 0.2 0.4");
1145 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("20 10 5 2 1 0.5");
1146
1147 static IIO_DEVICE_ATTR(in_proximity_scale_available, S_IRUGO,
1148 ltr501_show_proximity_scale_avail, NULL, 0);
1149 static IIO_DEVICE_ATTR(in_intensity_scale_available, S_IRUGO,
1150 ltr501_show_intensity_scale_avail, NULL, 0);
1151
1152 static struct attribute *ltr501_attributes[] = {
1153 &iio_dev_attr_in_proximity_scale_available.dev_attr.attr,
1154 &iio_dev_attr_in_intensity_scale_available.dev_attr.attr,
1155 &iio_const_attr_integration_time_available.dev_attr.attr,
1156 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
1157 NULL
1158 };
1159
1160 static struct attribute *ltr301_attributes[] = {
1161 &iio_dev_attr_in_intensity_scale_available.dev_attr.attr,
1162 &iio_const_attr_integration_time_available.dev_attr.attr,
1163 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
1164 NULL
1165 };
1166
1167 static const struct attribute_group ltr501_attribute_group = {
1168 .attrs = ltr501_attributes,
1169 };
1170
1171 static const struct attribute_group ltr301_attribute_group = {
1172 .attrs = ltr301_attributes,
1173 };
1174
1175 static const struct iio_info ltr501_info_no_irq = {
1176 .read_raw = ltr501_read_raw,
1177 .write_raw = ltr501_write_raw,
1178 .attrs = <r501_attribute_group,
1179 };
1180
1181 static const struct iio_info ltr501_info = {
1182 .read_raw = ltr501_read_raw,
1183 .write_raw = ltr501_write_raw,
1184 .attrs = <r501_attribute_group,
1185 .read_event_value = <r501_read_event,
1186 .write_event_value = <r501_write_event,
1187 .read_event_config = <r501_read_event_config,
1188 .write_event_config = <r501_write_event_config,
1189 };
1190
1191 static const struct iio_info ltr301_info_no_irq = {
1192 .read_raw = ltr501_read_raw,
1193 .write_raw = ltr501_write_raw,
1194 .attrs = <r301_attribute_group,
1195 };
1196
1197 static const struct iio_info ltr301_info = {
1198 .read_raw = ltr501_read_raw,
1199 .write_raw = ltr501_write_raw,
1200 .attrs = <r301_attribute_group,
1201 .read_event_value = <r501_read_event,
1202 .write_event_value = <r501_write_event,
1203 .read_event_config = <r501_read_event_config,
1204 .write_event_config = <r501_write_event_config,
1205 };
1206
1207 static const struct ltr501_chip_info ltr501_chip_info_tbl[] = {
1208 [ltr501] = {
1209 .partid = 0x08,
1210 .als_gain = ltr501_als_gain_tbl,
1211 .als_gain_tbl_size = ARRAY_SIZE(ltr501_als_gain_tbl),
1212 .ps_gain = ltr501_ps_gain_tbl,
1213 .ps_gain_tbl_size = ARRAY_SIZE(ltr501_ps_gain_tbl),
1214 .als_mode_active = BIT(0) | BIT(1),
1215 .als_gain_mask = BIT(3),
1216 .als_gain_shift = 3,
1217 .info = <r501_info,
1218 .info_no_irq = <r501_info_no_irq,
1219 .channels = ltr501_channels,
1220 .no_channels = ARRAY_SIZE(ltr501_channels),
1221 },
1222 [ltr559] = {
1223 .partid = 0x09,
1224 .als_gain = ltr559_als_gain_tbl,
1225 .als_gain_tbl_size = ARRAY_SIZE(ltr559_als_gain_tbl),
1226 .ps_gain = ltr559_ps_gain_tbl,
1227 .ps_gain_tbl_size = ARRAY_SIZE(ltr559_ps_gain_tbl),
1228 .als_mode_active = BIT(0),
1229 .als_gain_mask = BIT(2) | BIT(3) | BIT(4),
1230 .als_gain_shift = 2,
1231 .info = <r501_info,
1232 .info_no_irq = <r501_info_no_irq,
1233 .channels = ltr501_channels,
1234 .no_channels = ARRAY_SIZE(ltr501_channels),
1235 },
1236 [ltr301] = {
1237 .partid = 0x08,
1238 .als_gain = ltr501_als_gain_tbl,
1239 .als_gain_tbl_size = ARRAY_SIZE(ltr501_als_gain_tbl),
1240 .als_mode_active = BIT(0) | BIT(1),
1241 .als_gain_mask = BIT(3),
1242 .als_gain_shift = 3,
1243 .info = <r301_info,
1244 .info_no_irq = <r301_info_no_irq,
1245 .channels = ltr301_channels,
1246 .no_channels = ARRAY_SIZE(ltr301_channels),
1247 },
1248 [ltr303] = {
1249 .partid = 0x0A,
1250 .als_gain = ltr559_als_gain_tbl,
1251 .als_gain_tbl_size = ARRAY_SIZE(ltr559_als_gain_tbl),
1252 .als_mode_active = BIT(0),
1253 .als_gain_mask = BIT(2) | BIT(3) | BIT(4),
1254 .als_gain_shift = 2,
1255 .info = <r301_info,
1256 .info_no_irq = <r301_info_no_irq,
1257 .channels = ltr301_channels,
1258 .no_channels = ARRAY_SIZE(ltr301_channels),
1259 },
1260 };
1261
ltr501_write_contr(struct ltr501_data * data,u8 als_val,u8 ps_val)1262 static int ltr501_write_contr(struct ltr501_data *data, u8 als_val, u8 ps_val)
1263 {
1264 int ret;
1265
1266 ret = regmap_write(data->regmap, LTR501_ALS_CONTR, als_val);
1267 if (ret < 0)
1268 return ret;
1269
1270 return regmap_write(data->regmap, LTR501_PS_CONTR, ps_val);
1271 }
1272
ltr501_trigger_handler(int irq,void * p)1273 static irqreturn_t ltr501_trigger_handler(int irq, void *p)
1274 {
1275 struct iio_poll_func *pf = p;
1276 struct iio_dev *indio_dev = pf->indio_dev;
1277 struct ltr501_data *data = iio_priv(indio_dev);
1278 struct {
1279 u16 channels[3];
1280 aligned_s64 ts;
1281 } scan = { };
1282 __le16 als_buf[2];
1283 u8 mask = 0;
1284 int j = 0;
1285 int ret, psdata;
1286
1287 /* figure out which data needs to be ready */
1288 if (test_bit(0, indio_dev->active_scan_mask) ||
1289 test_bit(1, indio_dev->active_scan_mask))
1290 mask |= LTR501_STATUS_ALS_RDY;
1291 if (test_bit(2, indio_dev->active_scan_mask))
1292 mask |= LTR501_STATUS_PS_RDY;
1293
1294 ret = ltr501_drdy(data, mask);
1295 if (ret < 0)
1296 goto done;
1297
1298 if (mask & LTR501_STATUS_ALS_RDY) {
1299 ret = regmap_bulk_read(data->regmap, LTR501_ALS_DATA1,
1300 als_buf, sizeof(als_buf));
1301 if (ret < 0)
1302 goto done;
1303 if (test_bit(0, indio_dev->active_scan_mask))
1304 scan.channels[j++] = le16_to_cpu(als_buf[1]);
1305 if (test_bit(1, indio_dev->active_scan_mask))
1306 scan.channels[j++] = le16_to_cpu(als_buf[0]);
1307 }
1308
1309 if (mask & LTR501_STATUS_PS_RDY) {
1310 ret = regmap_bulk_read(data->regmap, LTR501_PS_DATA,
1311 &psdata, 2);
1312 if (ret < 0)
1313 goto done;
1314 scan.channels[j++] = psdata & LTR501_PS_DATA_MASK;
1315 }
1316
1317 iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan),
1318 iio_get_time_ns(indio_dev));
1319
1320 done:
1321 iio_trigger_notify_done(indio_dev->trig);
1322
1323 return IRQ_HANDLED;
1324 }
1325
ltr501_interrupt_handler(int irq,void * private)1326 static irqreturn_t ltr501_interrupt_handler(int irq, void *private)
1327 {
1328 struct iio_dev *indio_dev = private;
1329 struct ltr501_data *data = iio_priv(indio_dev);
1330 int ret, status;
1331
1332 ret = regmap_read(data->regmap, LTR501_ALS_PS_STATUS, &status);
1333 if (ret < 0) {
1334 dev_err(&data->client->dev,
1335 "irq read int reg failed\n");
1336 return IRQ_HANDLED;
1337 }
1338
1339 if (status & LTR501_STATUS_ALS_INTR)
1340 iio_push_event(indio_dev,
1341 IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
1342 IIO_EV_TYPE_THRESH,
1343 IIO_EV_DIR_EITHER),
1344 iio_get_time_ns(indio_dev));
1345
1346 if (status & LTR501_STATUS_PS_INTR)
1347 iio_push_event(indio_dev,
1348 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
1349 IIO_EV_TYPE_THRESH,
1350 IIO_EV_DIR_EITHER),
1351 iio_get_time_ns(indio_dev));
1352
1353 return IRQ_HANDLED;
1354 }
1355
ltr501_init(struct ltr501_data * data)1356 static int ltr501_init(struct ltr501_data *data)
1357 {
1358 int ret, status;
1359
1360 ret = regmap_read(data->regmap, LTR501_ALS_CONTR, &status);
1361 if (ret < 0)
1362 return ret;
1363
1364 data->als_contr = status | data->chip_info->als_mode_active;
1365
1366 ret = regmap_read(data->regmap, LTR501_PS_CONTR, &status);
1367 if (ret < 0)
1368 return ret;
1369
1370 data->ps_contr = status | LTR501_CONTR_ACTIVE;
1371
1372 ret = ltr501_read_intr_prst(data, IIO_INTENSITY, &data->als_period);
1373 if (ret < 0)
1374 return ret;
1375
1376 ret = ltr501_read_intr_prst(data, IIO_PROXIMITY, &data->ps_period);
1377 if (ret < 0)
1378 return ret;
1379
1380 return ltr501_write_contr(data, data->als_contr, data->ps_contr);
1381 }
1382
ltr501_is_volatile_reg(struct device * dev,unsigned int reg)1383 static bool ltr501_is_volatile_reg(struct device *dev, unsigned int reg)
1384 {
1385 switch (reg) {
1386 case LTR501_ALS_DATA1:
1387 case LTR501_ALS_DATA1_UPPER:
1388 case LTR501_ALS_DATA0:
1389 case LTR501_ALS_DATA0_UPPER:
1390 case LTR501_ALS_PS_STATUS:
1391 case LTR501_PS_DATA:
1392 case LTR501_PS_DATA_UPPER:
1393 return true;
1394 default:
1395 return false;
1396 }
1397 }
1398
1399 static const struct regmap_config ltr501_regmap_config = {
1400 .name = "ltr501_regmap",
1401 .reg_bits = 8,
1402 .val_bits = 8,
1403 .max_register = LTR501_MAX_REG,
1404 .cache_type = REGCACHE_MAPLE,
1405 .volatile_reg = ltr501_is_volatile_reg,
1406 };
1407
ltr501_powerdown(struct ltr501_data * data)1408 static int ltr501_powerdown(struct ltr501_data *data)
1409 {
1410 return ltr501_write_contr(data, data->als_contr &
1411 ~data->chip_info->als_mode_active,
1412 data->ps_contr & ~LTR501_CONTR_ACTIVE);
1413 }
1414
ltr501_probe(struct i2c_client * client)1415 static int ltr501_probe(struct i2c_client *client)
1416 {
1417 const struct i2c_device_id *id = i2c_client_get_device_id(client);
1418 static const char * const regulator_names[] = { "vdd", "vddio" };
1419 struct ltr501_data *data;
1420 struct iio_dev *indio_dev;
1421 struct regmap *regmap;
1422 const void *ddata = NULL;
1423 int partid, chip_idx;
1424 const char *name;
1425 int ret;
1426
1427 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1428 if (!indio_dev)
1429 return -ENOMEM;
1430
1431 regmap = devm_regmap_init_i2c(client, <r501_regmap_config);
1432 if (IS_ERR(regmap)) {
1433 dev_err(&client->dev, "Regmap initialization failed.\n");
1434 return PTR_ERR(regmap);
1435 }
1436
1437 data = iio_priv(indio_dev);
1438 i2c_set_clientdata(client, indio_dev);
1439 data->client = client;
1440 data->regmap = regmap;
1441 mutex_init(&data->lock_als);
1442 mutex_init(&data->lock_ps);
1443
1444 ret = devm_regulator_bulk_get_enable(&client->dev,
1445 ARRAY_SIZE(regulator_names),
1446 regulator_names);
1447 if (ret)
1448 return dev_err_probe(&client->dev, ret,
1449 "Failed to get regulators\n");
1450
1451 data->reg_it = devm_regmap_field_alloc(&client->dev, regmap,
1452 reg_field_it);
1453 if (IS_ERR(data->reg_it)) {
1454 dev_err(&client->dev, "Integ time reg field init failed.\n");
1455 return PTR_ERR(data->reg_it);
1456 }
1457
1458 data->reg_als_intr = devm_regmap_field_alloc(&client->dev, regmap,
1459 reg_field_als_intr);
1460 if (IS_ERR(data->reg_als_intr)) {
1461 dev_err(&client->dev, "ALS intr mode reg field init failed\n");
1462 return PTR_ERR(data->reg_als_intr);
1463 }
1464
1465 data->reg_ps_intr = devm_regmap_field_alloc(&client->dev, regmap,
1466 reg_field_ps_intr);
1467 if (IS_ERR(data->reg_ps_intr)) {
1468 dev_err(&client->dev, "PS intr mode reg field init failed.\n");
1469 return PTR_ERR(data->reg_ps_intr);
1470 }
1471
1472 data->reg_als_rate = devm_regmap_field_alloc(&client->dev, regmap,
1473 reg_field_als_rate);
1474 if (IS_ERR(data->reg_als_rate)) {
1475 dev_err(&client->dev, "ALS samp rate field init failed.\n");
1476 return PTR_ERR(data->reg_als_rate);
1477 }
1478
1479 data->reg_ps_rate = devm_regmap_field_alloc(&client->dev, regmap,
1480 reg_field_ps_rate);
1481 if (IS_ERR(data->reg_ps_rate)) {
1482 dev_err(&client->dev, "PS samp rate field init failed.\n");
1483 return PTR_ERR(data->reg_ps_rate);
1484 }
1485
1486 data->reg_als_prst = devm_regmap_field_alloc(&client->dev, regmap,
1487 reg_field_als_prst);
1488 if (IS_ERR(data->reg_als_prst)) {
1489 dev_err(&client->dev, "ALS prst reg field init failed\n");
1490 return PTR_ERR(data->reg_als_prst);
1491 }
1492
1493 data->reg_ps_prst = devm_regmap_field_alloc(&client->dev, regmap,
1494 reg_field_ps_prst);
1495 if (IS_ERR(data->reg_ps_prst)) {
1496 dev_err(&client->dev, "PS prst reg field init failed.\n");
1497 return PTR_ERR(data->reg_ps_prst);
1498 }
1499
1500 ret = regmap_read(data->regmap, LTR501_PART_ID, &partid);
1501 if (ret < 0)
1502 return ret;
1503
1504 if (id) {
1505 name = id->name;
1506 chip_idx = id->driver_data;
1507 } else {
1508 name = iio_get_acpi_device_name_and_data(&client->dev, &ddata);
1509 chip_idx = (intptr_t)ddata;
1510 }
1511 if (!name)
1512 return -ENODEV;
1513
1514 data->chip_info = <r501_chip_info_tbl[chip_idx];
1515
1516 if ((partid >> 4) != data->chip_info->partid)
1517 return -ENODEV;
1518
1519 if (device_property_read_u32(&client->dev, "proximity-near-level",
1520 &data->near_level))
1521 data->near_level = 0;
1522
1523 indio_dev->info = data->chip_info->info;
1524 indio_dev->channels = data->chip_info->channels;
1525 indio_dev->num_channels = data->chip_info->no_channels;
1526 indio_dev->name = name;
1527 indio_dev->modes = INDIO_DIRECT_MODE;
1528
1529 ret = ltr501_init(data);
1530 if (ret < 0)
1531 return ret;
1532
1533 if (client->irq > 0) {
1534 ret = devm_request_threaded_irq(&client->dev, client->irq,
1535 NULL, ltr501_interrupt_handler,
1536 IRQF_TRIGGER_FALLING |
1537 IRQF_ONESHOT,
1538 "ltr501_thresh_event",
1539 indio_dev);
1540 if (ret) {
1541 dev_err(&client->dev, "request irq (%d) failed\n",
1542 client->irq);
1543 return ret;
1544 }
1545 } else {
1546 indio_dev->info = data->chip_info->info_no_irq;
1547 }
1548
1549 ret = iio_triggered_buffer_setup(indio_dev, NULL,
1550 ltr501_trigger_handler, NULL);
1551 if (ret)
1552 goto powerdown_on_error;
1553
1554 ret = iio_device_register(indio_dev);
1555 if (ret)
1556 goto error_unreg_buffer;
1557
1558 return 0;
1559
1560 error_unreg_buffer:
1561 iio_triggered_buffer_cleanup(indio_dev);
1562 powerdown_on_error:
1563 ltr501_powerdown(data);
1564 return ret;
1565 }
1566
ltr501_remove(struct i2c_client * client)1567 static void ltr501_remove(struct i2c_client *client)
1568 {
1569 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1570
1571 iio_device_unregister(indio_dev);
1572 iio_triggered_buffer_cleanup(indio_dev);
1573 ltr501_powerdown(iio_priv(indio_dev));
1574 }
1575
ltr501_suspend(struct device * dev)1576 static int ltr501_suspend(struct device *dev)
1577 {
1578 struct ltr501_data *data = iio_priv(i2c_get_clientdata(
1579 to_i2c_client(dev)));
1580 return ltr501_powerdown(data);
1581 }
1582
ltr501_resume(struct device * dev)1583 static int ltr501_resume(struct device *dev)
1584 {
1585 struct ltr501_data *data = iio_priv(i2c_get_clientdata(
1586 to_i2c_client(dev)));
1587
1588 return ltr501_write_contr(data, data->als_contr,
1589 data->ps_contr);
1590 }
1591
1592 static DEFINE_SIMPLE_DEV_PM_OPS(ltr501_pm_ops, ltr501_suspend, ltr501_resume);
1593
1594 static const struct acpi_device_id ltr_acpi_match[] = {
1595 { "LTER0301", ltr301 },
1596 /* https://www.catalog.update.microsoft.com/Search.aspx?q=lter0303 */
1597 { "LTER0303", ltr303 },
1598 { }
1599 };
1600 MODULE_DEVICE_TABLE(acpi, ltr_acpi_match);
1601
1602 static const struct i2c_device_id ltr501_id[] = {
1603 { .name = "ltr501", .driver_data = ltr501 },
1604 { .name = "ltr559", .driver_data = ltr559 },
1605 { .name = "ltr301", .driver_data = ltr301 },
1606 { .name = "ltr303", .driver_data = ltr303 },
1607 { }
1608 };
1609 MODULE_DEVICE_TABLE(i2c, ltr501_id);
1610
1611 static const struct of_device_id ltr501_of_match[] = {
1612 { .compatible = "liteon,ltr501", },
1613 { .compatible = "liteon,ltr559", },
1614 { .compatible = "liteon,ltr301", },
1615 { .compatible = "liteon,ltr303", },
1616 { }
1617 };
1618 MODULE_DEVICE_TABLE(of, ltr501_of_match);
1619
1620 static struct i2c_driver ltr501_driver = {
1621 .driver = {
1622 .name = "ltr501",
1623 .of_match_table = ltr501_of_match,
1624 .pm = pm_sleep_ptr(<r501_pm_ops),
1625 .acpi_match_table = ltr_acpi_match,
1626 },
1627 .probe = ltr501_probe,
1628 .remove = ltr501_remove,
1629 .id_table = ltr501_id,
1630 };
1631
1632 module_i2c_driver(ltr501_driver);
1633
1634 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
1635 MODULE_DESCRIPTION("Lite-On LTR501 ambient light and proximity sensor driver");
1636 MODULE_LICENSE("GPL");
1637