?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / iio / light / lm3533-als.c
blob8a621244dd0126fc5bfa345e347137b69851e4d5
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * lm3533-als.c -- LM3533 Ambient Light Sensor driver
4 *
5 * Copyright (C) 2011-2012 Texas Instruments
6 *
7 * Author: Johan Hovold <jhovold@gmail.com>
8 */
9
10 #include <linux/atomic.h>
11 #include <linux/fs.h>
12 #include <linux/interrupt.h>
13 #include <linux/io.h>
14 #include <linux/iio/events.h>
15 #include <linux/iio/iio.h>
16 #include <linux/module.h>
17 #include <linux/mutex.h>
18 #include <linux/mfd/core.h>
19 #include <linux/platform_device.h>
20 #include <linux/slab.h>
21 #include <linux/uaccess.h>
22
23 #include <linux/mfd/lm3533.h>
24
25
26 #define LM3533_ALS_RESISTOR_MIN 1
27 #define LM3533_ALS_RESISTOR_MAX 127
28 #define LM3533_ALS_CHANNEL_CURRENT_MAX 2
29 #define LM3533_ALS_THRESH_MAX 3
30 #define LM3533_ALS_ZONE_MAX 4
31
32 #define LM3533_REG_ALS_RESISTOR_SELECT 0x30
33 #define LM3533_REG_ALS_CONF 0x31
34 #define LM3533_REG_ALS_ZONE_INFO 0x34
35 #define LM3533_REG_ALS_READ_ADC_RAW 0x37
36 #define LM3533_REG_ALS_READ_ADC_AVERAGE 0x38
37 #define LM3533_REG_ALS_BOUNDARY_BASE 0x50
38 #define LM3533_REG_ALS_TARGET_BASE 0x60
39
40 #define LM3533_ALS_ENABLE_MASK 0x01
41 #define LM3533_ALS_INPUT_MODE_MASK 0x02
42 #define LM3533_ALS_INT_ENABLE_MASK 0x01
43
44 #define LM3533_ALS_ZONE_SHIFT 2
45 #define LM3533_ALS_ZONE_MASK 0x1c
46
47 #define LM3533_ALS_FLAG_INT_ENABLED 1
48
49
50 struct lm3533_als {
51 struct lm3533 *lm3533;
52 struct platform_device *pdev;
53
54 unsigned long flags;
55 int irq;
56
57 atomic_t zone;
58 struct mutex thresh_mutex;
59 };
60
61
62 static int lm3533_als_get_adc(struct iio_dev *indio_dev, bool average,
63 int *adc)
64 {
65 struct lm3533_als *als = iio_priv(indio_dev);
66 u8 reg;
67 u8 val;
68 int ret;
69
70 if (average)
71 reg = LM3533_REG_ALS_READ_ADC_AVERAGE;
72 else
73 reg = LM3533_REG_ALS_READ_ADC_RAW;
74
75 ret = lm3533_read(als->lm3533, reg, &val);
76 if (ret) {
77 dev_err(&indio_dev->dev, "failed to read adc\n");
78 return ret;
79 }
80
81 *adc = val;
82
83 return 0;
84 }
85
86 static int _lm3533_als_get_zone(struct iio_dev *indio_dev, u8 *zone)
87 {
88 struct lm3533_als *als = iio_priv(indio_dev);
89 u8 val;
90 int ret;
91
92 ret = lm3533_read(als->lm3533, LM3533_REG_ALS_ZONE_INFO, &val);
93 if (ret) {
94 dev_err(&indio_dev->dev, "failed to read zone\n");
95 return ret;
96 }
97
98 val = (val & LM3533_ALS_ZONE_MASK) >> LM3533_ALS_ZONE_SHIFT;
99 *zone = min_t(u8, val, LM3533_ALS_ZONE_MAX);
100
101 return 0;
102 }
103
104 static int lm3533_als_get_zone(struct iio_dev *indio_dev, u8 *zone)
105 {
106 struct lm3533_als *als = iio_priv(indio_dev);
107 int ret;
108
109 if (test_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags)) {
110 *zone = atomic_read(&als->zone);
111 } else {
112 ret = _lm3533_als_get_zone(indio_dev, zone);
113 if (ret)
114 return ret;
115 }
116
117 return 0;
118 }
119
120 /*
121 * channel output channel 0..2
122 * zone zone 0..4
123 */
124 static inline u8 lm3533_als_get_target_reg(unsigned channel, unsigned zone)
125 {
126 return LM3533_REG_ALS_TARGET_BASE + 5 * channel + zone;
127 }
128
129 static int lm3533_als_get_target(struct iio_dev *indio_dev, unsigned channel,
130 unsigned zone, u8 *val)
131 {
132 struct lm3533_als *als = iio_priv(indio_dev);
133 u8 reg;
134 int ret;
135
136 if (channel > LM3533_ALS_CHANNEL_CURRENT_MAX)
137 return -EINVAL;
138
139 if (zone > LM3533_ALS_ZONE_MAX)
140 return -EINVAL;
141
142 reg = lm3533_als_get_target_reg(channel, zone);
143 ret = lm3533_read(als->lm3533, reg, val);
144 if (ret)
145 dev_err(&indio_dev->dev, "failed to get target current\n");
146
147 return ret;
148 }
149
150 static int lm3533_als_set_target(struct iio_dev *indio_dev, unsigned channel,
151 unsigned zone, u8 val)
152 {
153 struct lm3533_als *als = iio_priv(indio_dev);
154 u8 reg;
155 int ret;
156
157 if (channel > LM3533_ALS_CHANNEL_CURRENT_MAX)
158 return -EINVAL;
159
160 if (zone > LM3533_ALS_ZONE_MAX)
161 return -EINVAL;
162
163 reg = lm3533_als_get_target_reg(channel, zone);
164 ret = lm3533_write(als->lm3533, reg, val);
165 if (ret)
166 dev_err(&indio_dev->dev, "failed to set target current\n");
167
168 return ret;
169 }
170
171 static int lm3533_als_get_current(struct iio_dev *indio_dev, unsigned channel,
172 int *val)
173 {
174 u8 zone;
175 u8 target;
176 int ret;
177
178 ret = lm3533_als_get_zone(indio_dev, &zone);
179 if (ret)
180 return ret;
181
182 ret = lm3533_als_get_target(indio_dev, channel, zone, &target);
183 if (ret)
184 return ret;
185
186 *val = target;
187
188 return 0;
189 }
190
191 static int lm3533_als_read_raw(struct iio_dev *indio_dev,
192 struct iio_chan_spec const *chan,
193 int *val, int *val2, long mask)
194 {
195 int ret;
196
197 switch (mask) {
198 case IIO_CHAN_INFO_RAW:
199 switch (chan->type) {
200 case IIO_LIGHT:
201 ret = lm3533_als_get_adc(indio_dev, false, val);
202 break;
203 case IIO_CURRENT:
204 ret = lm3533_als_get_current(indio_dev, chan->channel,
205 val);
206 break;
207 default:
208 return -EINVAL;
209 }
210 break;
211 case IIO_CHAN_INFO_AVERAGE_RAW:
212 ret = lm3533_als_get_adc(indio_dev, true, val);
213 break;
214 default:
215 return -EINVAL;
216 }
217
218 if (ret)
219 return ret;
220
221 return IIO_VAL_INT;
222 }
223
224 #define CHANNEL_CURRENT(_channel) \
225 { \
226 .type = IIO_CURRENT, \
227 .channel = _channel, \
228 .indexed = true, \
229 .output = true, \
230 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
231 }
232
233 static const struct iio_chan_spec lm3533_als_channels[] = {
234 {
235 .type = IIO_LIGHT,
236 .channel = 0,
237 .indexed = true,
238 .info_mask_separate = BIT(IIO_CHAN_INFO_AVERAGE_RAW) |
239 BIT(IIO_CHAN_INFO_RAW),
240 },
241 CHANNEL_CURRENT(0),
242 CHANNEL_CURRENT(1),
243 CHANNEL_CURRENT(2),
244 };
245
246 static irqreturn_t lm3533_als_isr(int irq, void *dev_id)
247 {
248
249 struct iio_dev *indio_dev = dev_id;
250 struct lm3533_als *als = iio_priv(indio_dev);
251 u8 zone;
252 int ret;
253
254 /* Clear interrupt by reading the ALS zone register. */
255 ret = _lm3533_als_get_zone(indio_dev, &zone);
256 if (ret)
257 goto out;
258
259 atomic_set(&als->zone, zone);
260
261 iio_push_event(indio_dev,
262 IIO_UNMOD_EVENT_CODE(IIO_LIGHT,
263 0,
264 IIO_EV_TYPE_THRESH,
265 IIO_EV_DIR_EITHER),
266 iio_get_time_ns(indio_dev));
267 out:
268 return IRQ_HANDLED;
269 }
270
271 static int lm3533_als_set_int_mode(struct iio_dev *indio_dev, int enable)
272 {
273 struct lm3533_als *als = iio_priv(indio_dev);
274 u8 mask = LM3533_ALS_INT_ENABLE_MASK;
275 u8 val;
276 int ret;
277
278 if (enable)
279 val = mask;
280 else
281 val = 0;
282
283 ret = lm3533_update(als->lm3533, LM3533_REG_ALS_ZONE_INFO, val, mask);
284 if (ret) {
285 dev_err(&indio_dev->dev, "failed to set int mode %d\n",
286 enable);
287 return ret;
288 }
289
290 return 0;
291 }
292
293 static int lm3533_als_get_int_mode(struct iio_dev *indio_dev, int *enable)
294 {
295 struct lm3533_als *als = iio_priv(indio_dev);
296 u8 mask = LM3533_ALS_INT_ENABLE_MASK;
297 u8 val;
298 int ret;
299
300 ret = lm3533_read(als->lm3533, LM3533_REG_ALS_ZONE_INFO, &val);
301 if (ret) {
302 dev_err(&indio_dev->dev, "failed to get int mode\n");
303 return ret;
304 }
305
306 *enable = !!(val & mask);
307
308 return 0;
309 }
310
311 static inline u8 lm3533_als_get_threshold_reg(unsigned nr, bool raising)
312 {
313 u8 offset = !raising;
314
315 return LM3533_REG_ALS_BOUNDARY_BASE + 2 * nr + offset;
316 }
317
318 static int lm3533_als_get_threshold(struct iio_dev *indio_dev, unsigned nr,
319 bool raising, u8 *val)
320 {
321 struct lm3533_als *als = iio_priv(indio_dev);
322 u8 reg;
323 int ret;
324
325 if (nr > LM3533_ALS_THRESH_MAX)
326 return -EINVAL;
327
328 reg = lm3533_als_get_threshold_reg(nr, raising);
329 ret = lm3533_read(als->lm3533, reg, val);
330 if (ret)
331 dev_err(&indio_dev->dev, "failed to get threshold\n");
332
333 return ret;
334 }
335
336 static int lm3533_als_set_threshold(struct iio_dev *indio_dev, unsigned nr,
337 bool raising, u8 val)
338 {
339 struct lm3533_als *als = iio_priv(indio_dev);
340 u8 val2;
341 u8 reg, reg2;
342 int ret;
343
344 if (nr > LM3533_ALS_THRESH_MAX)
345 return -EINVAL;
346
347 reg = lm3533_als_get_threshold_reg(nr, raising);
348 reg2 = lm3533_als_get_threshold_reg(nr, !raising);
349
350 mutex_lock(&als->thresh_mutex);
351 ret = lm3533_read(als->lm3533, reg2, &val2);
352 if (ret) {
353 dev_err(&indio_dev->dev, "failed to get threshold\n");
354 goto out;
355 }
356 /*
357 * This device does not allow negative hysteresis (in fact, it uses
358 * whichever value is smaller as the lower bound) so we need to make
359 * sure that thresh_falling <= thresh_raising.
360 */
361 if ((raising && (val < val2)) || (!raising && (val > val2))) {
362 ret = -EINVAL;
363 goto out;
364 }
365
366 ret = lm3533_write(als->lm3533, reg, val);
367 if (ret) {
368 dev_err(&indio_dev->dev, "failed to set threshold\n");
369 goto out;
370 }
371 out:
372 mutex_unlock(&als->thresh_mutex);
373
374 return ret;
375 }
376
377 static int lm3533_als_get_hysteresis(struct iio_dev *indio_dev, unsigned nr,
378 u8 *val)
379 {
380 struct lm3533_als *als = iio_priv(indio_dev);
381 u8 falling;
382 u8 raising;
383 int ret;
384
385 if (nr > LM3533_ALS_THRESH_MAX)
386 return -EINVAL;
387
388 mutex_lock(&als->thresh_mutex);
389 ret = lm3533_als_get_threshold(indio_dev, nr, false, &falling);
390 if (ret)
391 goto out;
392 ret = lm3533_als_get_threshold(indio_dev, nr, true, &raising);
393 if (ret)
394 goto out;
395
396 *val = raising - falling;
397 out:
398 mutex_unlock(&als->thresh_mutex);
399
400 return ret;
401 }
402
403 static ssize_t show_thresh_either_en(struct device *dev,
404 struct device_attribute *attr,
405 char *buf)
406 {
407 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
408 struct lm3533_als *als = iio_priv(indio_dev);
409 int enable;
410 int ret;
411
412 if (als->irq) {
413 ret = lm3533_als_get_int_mode(indio_dev, &enable);
414 if (ret)
415 return ret;
416 } else {
417 enable = 0;
418 }
419
420 return scnprintf(buf, PAGE_SIZE, "%u\n", enable);
421 }
422
423 static ssize_t store_thresh_either_en(struct device *dev,
424 struct device_attribute *attr,
425 const char *buf, size_t len)
426 {
427 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
428 struct lm3533_als *als = iio_priv(indio_dev);
429 unsigned long enable;
430 bool int_enabled;
431 u8 zone;
432 int ret;
433
434 if (!als->irq)
435 return -EBUSY;
436
437 if (kstrtoul(buf, 0, &enable))
438 return -EINVAL;
439
440 int_enabled = test_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
441
442 if (enable && !int_enabled) {
443 ret = lm3533_als_get_zone(indio_dev, &zone);
444 if (ret)
445 return ret;
446
447 atomic_set(&als->zone, zone);
448
449 set_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
450 }
451
452 ret = lm3533_als_set_int_mode(indio_dev, enable);
453 if (ret) {
454 if (!int_enabled)
455 clear_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
456
457 return ret;
458 }
459
460 if (!enable)
461 clear_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
462
463 return len;
464 }
465
466 static ssize_t show_zone(struct device *dev,
467 struct device_attribute *attr, char *buf)
468 {
469 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
470 u8 zone;
471 int ret;
472
473 ret = lm3533_als_get_zone(indio_dev, &zone);
474 if (ret)
475 return ret;
476
477 return scnprintf(buf, PAGE_SIZE, "%u\n", zone);
478 }
479
480 enum lm3533_als_attribute_type {
481 LM3533_ATTR_TYPE_HYSTERESIS,
482 LM3533_ATTR_TYPE_TARGET,
483 LM3533_ATTR_TYPE_THRESH_FALLING,
484 LM3533_ATTR_TYPE_THRESH_RAISING,
485 };
486
487 struct lm3533_als_attribute {
488 struct device_attribute dev_attr;
489 enum lm3533_als_attribute_type type;
490 u8 val1;
491 u8 val2;
492 };
493
494 static inline struct lm3533_als_attribute *
495 to_lm3533_als_attr(struct device_attribute *attr)
496 {
497 return container_of(attr, struct lm3533_als_attribute, dev_attr);
498 }
499
500 static ssize_t show_als_attr(struct device *dev,
501 struct device_attribute *attr,
502 char *buf)
503 {
504 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
505 struct lm3533_als_attribute *als_attr = to_lm3533_als_attr(attr);
506 u8 val;
507 int ret;
508
509 switch (als_attr->type) {
510 case LM3533_ATTR_TYPE_HYSTERESIS:
511 ret = lm3533_als_get_hysteresis(indio_dev, als_attr->val1,
512 &val);
513 break;
514 case LM3533_ATTR_TYPE_TARGET:
515 ret = lm3533_als_get_target(indio_dev, als_attr->val1,
516 als_attr->val2, &val);
517 break;
518 case LM3533_ATTR_TYPE_THRESH_FALLING:
519 ret = lm3533_als_get_threshold(indio_dev, als_attr->val1,
520 false, &val);
521 break;
522 case LM3533_ATTR_TYPE_THRESH_RAISING:
523 ret = lm3533_als_get_threshold(indio_dev, als_attr->val1,
524 true, &val);
525 break;
526 default:
527 ret = -ENXIO;
528 }
529
530 if (ret)
531 return ret;
532
533 return scnprintf(buf, PAGE_SIZE, "%u\n", val);
534 }
535
536 static ssize_t store_als_attr(struct device *dev,
537 struct device_attribute *attr,
538 const char *buf, size_t len)
539 {
540 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
541 struct lm3533_als_attribute *als_attr = to_lm3533_als_attr(attr);
542 u8 val;
543 int ret;
544
545 if (kstrtou8(buf, 0, &val))
546 return -EINVAL;
547
548 switch (als_attr->type) {
549 case LM3533_ATTR_TYPE_TARGET:
550 ret = lm3533_als_set_target(indio_dev, als_attr->val1,
551 als_attr->val2, val);
552 break;
553 case LM3533_ATTR_TYPE_THRESH_FALLING:
554 ret = lm3533_als_set_threshold(indio_dev, als_attr->val1,
555 false, val);
556 break;
557 case LM3533_ATTR_TYPE_THRESH_RAISING:
558 ret = lm3533_als_set_threshold(indio_dev, als_attr->val1,
559 true, val);
560 break;
561 default:
562 ret = -ENXIO;
563 }
564
565 if (ret)
566 return ret;
567
568 return len;
569 }
570
571 #define ALS_ATTR(_name, _mode, _show, _store, _type, _val1, _val2) \
572 { .dev_attr = __ATTR(_name, _mode, _show, _store), \
573 .type = _type, \
574 .val1 = _val1, \
575 .val2 = _val2 }
576
577 #define LM3533_ALS_ATTR(_name, _mode, _show, _store, _type, _val1, _val2) \
578 struct lm3533_als_attribute lm3533_als_attr_##_name = \
579 ALS_ATTR(_name, _mode, _show, _store, _type, _val1, _val2)
580
581 #define ALS_TARGET_ATTR_RW(_channel, _zone) \
582 LM3533_ALS_ATTR(out_current##_channel##_current##_zone##_raw, \
583 S_IRUGO | S_IWUSR, \
584 show_als_attr, store_als_attr, \
585 LM3533_ATTR_TYPE_TARGET, _channel, _zone)
586 /*
587 * ALS output current values (ALS mapper targets)
588 *
589 * out_current[0-2]_current[0-4]_raw 0-255
590 */
591 static ALS_TARGET_ATTR_RW(0, 0);
592 static ALS_TARGET_ATTR_RW(0, 1);
593 static ALS_TARGET_ATTR_RW(0, 2);
594 static ALS_TARGET_ATTR_RW(0, 3);
595 static ALS_TARGET_ATTR_RW(0, 4);
596
597 static ALS_TARGET_ATTR_RW(1, 0);
598 static ALS_TARGET_ATTR_RW(1, 1);
599 static ALS_TARGET_ATTR_RW(1, 2);
600 static ALS_TARGET_ATTR_RW(1, 3);
601 static ALS_TARGET_ATTR_RW(1, 4);
602
603 static ALS_TARGET_ATTR_RW(2, 0);
604 static ALS_TARGET_ATTR_RW(2, 1);
605 static ALS_TARGET_ATTR_RW(2, 2);
606 static ALS_TARGET_ATTR_RW(2, 3);
607 static ALS_TARGET_ATTR_RW(2, 4);
608
609 #define ALS_THRESH_FALLING_ATTR_RW(_nr) \
610 LM3533_ALS_ATTR(in_illuminance0_thresh##_nr##_falling_value, \
611 S_IRUGO | S_IWUSR, \
612 show_als_attr, store_als_attr, \
613 LM3533_ATTR_TYPE_THRESH_FALLING, _nr, 0)
614
615 #define ALS_THRESH_RAISING_ATTR_RW(_nr) \
616 LM3533_ALS_ATTR(in_illuminance0_thresh##_nr##_raising_value, \
617 S_IRUGO | S_IWUSR, \
618 show_als_attr, store_als_attr, \
619 LM3533_ATTR_TYPE_THRESH_RAISING, _nr, 0)
620 /*
621 * ALS Zone thresholds (boundaries)
622 *
623 * in_illuminance0_thresh[0-3]_falling_value 0-255
624 * in_illuminance0_thresh[0-3]_raising_value 0-255
625 */
626 static ALS_THRESH_FALLING_ATTR_RW(0);
627 static ALS_THRESH_FALLING_ATTR_RW(1);
628 static ALS_THRESH_FALLING_ATTR_RW(2);
629 static ALS_THRESH_FALLING_ATTR_RW(3);
630
631 static ALS_THRESH_RAISING_ATTR_RW(0);
632 static ALS_THRESH_RAISING_ATTR_RW(1);
633 static ALS_THRESH_RAISING_ATTR_RW(2);
634 static ALS_THRESH_RAISING_ATTR_RW(3);
635
636 #define ALS_HYSTERESIS_ATTR_RO(_nr) \
637 LM3533_ALS_ATTR(in_illuminance0_thresh##_nr##_hysteresis, \
638 S_IRUGO, show_als_attr, NULL, \
639 LM3533_ATTR_TYPE_HYSTERESIS, _nr, 0)
640 /*
641 * ALS Zone threshold hysteresis
642 *
643 * threshY_hysteresis = threshY_raising - threshY_falling
644 *
645 * in_illuminance0_thresh[0-3]_hysteresis 0-255
646 * in_illuminance0_thresh[0-3]_hysteresis 0-255
647 */
648 static ALS_HYSTERESIS_ATTR_RO(0);
649 static ALS_HYSTERESIS_ATTR_RO(1);
650 static ALS_HYSTERESIS_ATTR_RO(2);
651 static ALS_HYSTERESIS_ATTR_RO(3);
652
653 #define ILLUMINANCE_ATTR_RO(_name) \
654 DEVICE_ATTR(in_illuminance0_##_name, S_IRUGO, show_##_name, NULL)
655 #define ILLUMINANCE_ATTR_RW(_name) \
656 DEVICE_ATTR(in_illuminance0_##_name, S_IRUGO | S_IWUSR, \
657 show_##_name, store_##_name)
658 /*
659 * ALS Zone threshold-event enable
660 *
661 * in_illuminance0_thresh_either_en 0,1
662 */
663 static ILLUMINANCE_ATTR_RW(thresh_either_en);
664
665 /*
666 * ALS Current Zone
667 *
668 * in_illuminance0_zone 0-4
669 */
670 static ILLUMINANCE_ATTR_RO(zone);
671
672 static struct attribute *lm3533_als_event_attributes[] = {
673 &dev_attr_in_illuminance0_thresh_either_en.attr,
674 &lm3533_als_attr_in_illuminance0_thresh0_falling_value.dev_attr.attr,
675 &lm3533_als_attr_in_illuminance0_thresh0_hysteresis.dev_attr.attr,
676 &lm3533_als_attr_in_illuminance0_thresh0_raising_value.dev_attr.attr,
677 &lm3533_als_attr_in_illuminance0_thresh1_falling_value.dev_attr.attr,
678 &lm3533_als_attr_in_illuminance0_thresh1_hysteresis.dev_attr.attr,
679 &lm3533_als_attr_in_illuminance0_thresh1_raising_value.dev_attr.attr,
680 &lm3533_als_attr_in_illuminance0_thresh2_falling_value.dev_attr.attr,
681 &lm3533_als_attr_in_illuminance0_thresh2_hysteresis.dev_attr.attr,
682 &lm3533_als_attr_in_illuminance0_thresh2_raising_value.dev_attr.attr,
683 &lm3533_als_attr_in_illuminance0_thresh3_falling_value.dev_attr.attr,
684 &lm3533_als_attr_in_illuminance0_thresh3_hysteresis.dev_attr.attr,
685 &lm3533_als_attr_in_illuminance0_thresh3_raising_value.dev_attr.attr,
686 NULL
687 };
688
689 static const struct attribute_group lm3533_als_event_attribute_group = {
690 .attrs = lm3533_als_event_attributes
691 };
692
693 static struct attribute *lm3533_als_attributes[] = {
694 &dev_attr_in_illuminance0_zone.attr,
695 &lm3533_als_attr_out_current0_current0_raw.dev_attr.attr,
696 &lm3533_als_attr_out_current0_current1_raw.dev_attr.attr,
697 &lm3533_als_attr_out_current0_current2_raw.dev_attr.attr,
698 &lm3533_als_attr_out_current0_current3_raw.dev_attr.attr,
699 &lm3533_als_attr_out_current0_current4_raw.dev_attr.attr,
700 &lm3533_als_attr_out_current1_current0_raw.dev_attr.attr,
701 &lm3533_als_attr_out_current1_current1_raw.dev_attr.attr,
702 &lm3533_als_attr_out_current1_current2_raw.dev_attr.attr,
703 &lm3533_als_attr_out_current1_current3_raw.dev_attr.attr,
704 &lm3533_als_attr_out_current1_current4_raw.dev_attr.attr,
705 &lm3533_als_attr_out_current2_current0_raw.dev_attr.attr,
706 &lm3533_als_attr_out_current2_current1_raw.dev_attr.attr,
707 &lm3533_als_attr_out_current2_current2_raw.dev_attr.attr,
708 &lm3533_als_attr_out_current2_current3_raw.dev_attr.attr,
709 &lm3533_als_attr_out_current2_current4_raw.dev_attr.attr,
710 NULL
711 };
712
713 static const struct attribute_group lm3533_als_attribute_group = {
714 .attrs = lm3533_als_attributes
715 };
716
717 static int lm3533_als_set_input_mode(struct lm3533_als *als, bool pwm_mode)
718 {
719 u8 mask = LM3533_ALS_INPUT_MODE_MASK;
720 u8 val;
721 int ret;
722
723 if (pwm_mode)
724 val = mask; /* pwm input */
725 else
726 val = 0; /* analog input */
727
728 ret = lm3533_update(als->lm3533, LM3533_REG_ALS_CONF, val, mask);
729 if (ret) {
730 dev_err(&als->pdev->dev, "failed to set input mode %d\n",
731 pwm_mode);
732 return ret;
733 }
734
735 return 0;
736 }
737
738 static int lm3533_als_set_resistor(struct lm3533_als *als, u8 val)
739 {
740 int ret;
741
742 if (val < LM3533_ALS_RESISTOR_MIN || val > LM3533_ALS_RESISTOR_MAX) {
743 dev_err(&als->pdev->dev, "invalid resistor value\n");
744 return -EINVAL;
745 }
746
747 ret = lm3533_write(als->lm3533, LM3533_REG_ALS_RESISTOR_SELECT, val);
748 if (ret) {
749 dev_err(&als->pdev->dev, "failed to set resistor\n");
750 return ret;
751 }
752
753 return 0;
754 }
755
756 static int lm3533_als_setup(struct lm3533_als *als,
757 struct lm3533_als_platform_data *pdata)
758 {
759 int ret;
760
761 ret = lm3533_als_set_input_mode(als, pdata->pwm_mode);
762 if (ret)
763 return ret;
764
765 /* ALS input is always high impedance in PWM-mode. */
766 if (!pdata->pwm_mode) {
767 ret = lm3533_als_set_resistor(als, pdata->r_select);
768 if (ret)
769 return ret;
770 }
771
772 return 0;
773 }
774
775 static int lm3533_als_setup_irq(struct lm3533_als *als, void *dev)
776 {
777 u8 mask = LM3533_ALS_INT_ENABLE_MASK;
778 int ret;
779
780 /* Make sure interrupts are disabled. */
781 ret = lm3533_update(als->lm3533, LM3533_REG_ALS_ZONE_INFO, 0, mask);
782 if (ret) {
783 dev_err(&als->pdev->dev, "failed to disable interrupts\n");
784 return ret;
785 }
786
787 ret = request_threaded_irq(als->irq, NULL, lm3533_als_isr,
788 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
789 dev_name(&als->pdev->dev), dev);
790 if (ret) {
791 dev_err(&als->pdev->dev, "failed to request irq %d\n",
792 als->irq);
793 return ret;
794 }
795
796 return 0;
797 }
798
799 static int lm3533_als_enable(struct lm3533_als *als)
800 {
801 u8 mask = LM3533_ALS_ENABLE_MASK;
802 int ret;
803
804 ret = lm3533_update(als->lm3533, LM3533_REG_ALS_CONF, mask, mask);
805 if (ret)
806 dev_err(&als->pdev->dev, "failed to enable ALS\n");
807
808 return ret;
809 }
810
811 static int lm3533_als_disable(struct lm3533_als *als)
812 {
813 u8 mask = LM3533_ALS_ENABLE_MASK;
814 int ret;
815
816 ret = lm3533_update(als->lm3533, LM3533_REG_ALS_CONF, 0, mask);
817 if (ret)
818 dev_err(&als->pdev->dev, "failed to disable ALS\n");
819
820 return ret;
821 }
822
823 static const struct iio_info lm3533_als_info = {
824 .attrs = &lm3533_als_attribute_group,
825 .event_attrs = &lm3533_als_event_attribute_group,
826 .read_raw = &lm3533_als_read_raw,
827 };
828
829 static int lm3533_als_probe(struct platform_device *pdev)
830 {
831 struct lm3533 *lm3533;
832 struct lm3533_als_platform_data *pdata;
833 struct lm3533_als *als;
834 struct iio_dev *indio_dev;
835 int ret;
836
837 lm3533 = dev_get_drvdata(pdev->dev.parent);
838 if (!lm3533)
839 return -EINVAL;
840
841 pdata = pdev->dev.platform_data;
842 if (!pdata) {
843 dev_err(&pdev->dev, "no platform data\n");
844 return -EINVAL;
845 }
846
847 indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*als));
848 if (!indio_dev)
849 return -ENOMEM;
850
851 indio_dev->info = &lm3533_als_info;
852 indio_dev->channels = lm3533_als_channels;
853 indio_dev->num_channels = ARRAY_SIZE(lm3533_als_channels);
854 indio_dev->name = dev_name(&pdev->dev);
855 iio_device_set_parent(indio_dev, pdev->dev.parent);
856 indio_dev->modes = INDIO_DIRECT_MODE;
857
858 als = iio_priv(indio_dev);
859 als->lm3533 = lm3533;
860 als->pdev = pdev;
861 als->irq = lm3533->irq;
862 atomic_set(&als->zone, 0);
863 mutex_init(&als->thresh_mutex);
864
865 platform_set_drvdata(pdev, indio_dev);
866
867 if (als->irq) {
868 ret = lm3533_als_setup_irq(als, indio_dev);
869 if (ret)
870 return ret;
871 }
872
873 ret = lm3533_als_setup(als, pdata);
874 if (ret)
875 goto err_free_irq;
876
877 ret = lm3533_als_enable(als);
878 if (ret)
879 goto err_free_irq;
880
881 ret = iio_device_register(indio_dev);
882 if (ret) {
883 dev_err(&pdev->dev, "failed to register ALS\n");
884 goto err_disable;
885 }
886
887 return 0;
888
889 err_disable:
890 lm3533_als_disable(als);
891 err_free_irq:
892 if (als->irq)
893 free_irq(als->irq, indio_dev);
894
895 return ret;
896 }
897
898 static int lm3533_als_remove(struct platform_device *pdev)
899 {
900 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
901 struct lm3533_als *als = iio_priv(indio_dev);
902
903 lm3533_als_set_int_mode(indio_dev, false);
904 iio_device_unregister(indio_dev);
905 lm3533_als_disable(als);
906 if (als->irq)
907 free_irq(als->irq, indio_dev);
908
909 return 0;
910 }
911
912 static struct platform_driver lm3533_als_driver = {
913 .driver = {
914 .name = "lm3533-als",
915 },
916 .probe = lm3533_als_probe,
917 .remove = lm3533_als_remove,
918 };
919 module_platform_driver(lm3533_als_driver);
920
921 MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>");
922 MODULE_DESCRIPTION("LM3533 Ambient Light Sensor driver");
923 MODULE_LICENSE("GPL");
924 MODULE_ALIAS("platform:lm3533-als");
Linux with added FPC-III support