1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2015 Intel Corporation
4 *
5 * Driver for UPISEMI us5182d Proximity and Ambient Light Sensor.
6 *
7 * To do: Interrupt support.
8 */
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/delay.h>
13 #include <linux/i2c.h>
14 #include <linux/iio/events.h>
15 #include <linux/iio/iio.h>
16 #include <linux/interrupt.h>
17 #include <linux/irq.h>
18 #include <linux/iio/sysfs.h>
19 #include <linux/mutex.h>
20 #include <linux/pm.h>
21 #include <linux/pm_runtime.h>
22
23 #define US5182D_REG_CFG0 0x00
24 #define US5182D_CFG0_ONESHOT_EN BIT(6)
25 #define US5182D_CFG0_SHUTDOWN_EN BIT(7)
26 #define US5182D_CFG0_WORD_ENABLE BIT(0)
27 #define US5182D_CFG0_PROX BIT(3)
28 #define US5182D_CFG0_PX_IRQ BIT(2)
29
30 #define US5182D_REG_CFG1 0x01
31 #define US5182D_CFG1_ALS_RES16 BIT(4)
32 #define US5182D_CFG1_AGAIN_DEFAULT 0x00
33
34 #define US5182D_REG_CFG2 0x02
35 #define US5182D_CFG2_PX_RES16 BIT(4)
36 #define US5182D_CFG2_PXGAIN_DEFAULT BIT(2)
37
38 #define US5182D_REG_CFG3 0x03
39 #define US5182D_CFG3_LED_CURRENT100 (BIT(4) | BIT(5))
40 #define US5182D_CFG3_INT_SOURCE_PX BIT(3)
41
42 #define US5182D_REG_CFG4 0x10
43
44 /*
45 * Registers for tuning the auto dark current cancelling feature.
46 * DARK_TH(reg 0x27,0x28) - threshold (counts) for auto dark cancelling.
47 * when ALS > DARK_TH --> ALS_Code = ALS - Upper(0x2A) * Dark
48 * when ALS < DARK_TH --> ALS_Code = ALS - Lower(0x29) * Dark
49 */
50 #define US5182D_REG_UDARK_TH 0x27
51 #define US5182D_REG_DARK_AUTO_EN 0x2b
52 #define US5182D_REG_AUTO_LDARK_GAIN 0x29
53 #define US5182D_REG_AUTO_HDARK_GAIN 0x2a
54
55 /* Thresholds for events: px low (0x08-l, 0x09-h), px high (0x0a-l 0x0b-h) */
56 #define US5182D_REG_PXL_TH 0x08
57 #define US5182D_REG_PXH_TH 0x0a
58
59 #define US5182D_REG_PXL_TH_DEFAULT 1000
60 #define US5182D_REG_PXH_TH_DEFAULT 30000
61
62 #define US5182D_OPMODE_ALS 0x01
63 #define US5182D_OPMODE_PX 0x02
64 #define US5182D_OPMODE_SHIFT 4
65
66 #define US5182D_REG_DARK_AUTO_EN_DEFAULT 0x80
67 #define US5182D_REG_AUTO_LDARK_GAIN_DEFAULT 0x16
68 #define US5182D_REG_AUTO_HDARK_GAIN_DEFAULT 0x00
69
70 #define US5182D_REG_ADL 0x0c
71 #define US5182D_REG_PDL 0x0e
72
73 #define US5182D_REG_MODE_STORE 0x21
74 #define US5182D_STORE_MODE 0x01
75
76 #define US5182D_REG_CHIPID 0xb2
77
78 #define US5182D_OPMODE_MASK GENMASK(5, 4)
79 #define US5182D_AGAIN_MASK 0x07
80 #define US5182D_RESET_CHIP 0x01
81
82 #define US5182D_CHIPID 0x26
83 #define US5182D_DRV_NAME "us5182d"
84
85 #define US5182D_GA_RESOLUTION 1000
86
87 #define US5182D_READ_BYTE 1
88 #define US5182D_READ_WORD 2
89 #define US5182D_OPSTORE_SLEEP_TIME 20 /* ms */
90 #define US5182D_SLEEP_MS 3000 /* ms */
91 #define US5182D_PXH_TH_DISABLE 0xffff
92 #define US5182D_PXL_TH_DISABLE 0x0000
93
94 /* Available ranges: [12354, 7065, 3998, 2202, 1285, 498, 256, 138] lux */
95 static const int us5182d_scales[] = {188500, 107800, 61000, 33600, 19600, 7600,
96 3900, 2100};
97
98 /*
99 * Experimental thresholds that work with US5182D sensor on evaluation board
100 * roughly between 12-32 lux
101 */
102 static u16 us5182d_dark_ths_vals[] = {170, 200, 512, 512, 800, 2000, 4000,
103 8000};
104
105 enum mode {
106 US5182D_ALS_PX,
107 US5182D_ALS_ONLY,
108 US5182D_PX_ONLY
109 };
110
111 enum pmode {
112 US5182D_CONTINUOUS,
113 US5182D_ONESHOT
114 };
115
116 struct us5182d_data {
117 struct i2c_client *client;
118 struct mutex lock;
119
120 /* Glass attenuation factor */
121 u32 ga;
122
123 /* Dark gain tuning */
124 u8 lower_dark_gain;
125 u8 upper_dark_gain;
126 u16 *us5182d_dark_ths;
127
128 u16 px_low_th;
129 u16 px_high_th;
130
131 int rising_en;
132 int falling_en;
133
134 u8 opmode;
135 u8 power_mode;
136
137 bool als_enabled;
138 bool px_enabled;
139
140 bool default_continuous;
141 };
142
143 static IIO_CONST_ATTR(in_illuminance_scale_available,
144 "0.0021 0.0039 0.0076 0.0196 0.0336 0.061 0.1078 0.1885");
145
146 static struct attribute *us5182d_attrs[] = {
147 &iio_const_attr_in_illuminance_scale_available.dev_attr.attr,
148 NULL
149 };
150
151 static const struct attribute_group us5182d_attr_group = {
152 .attrs = us5182d_attrs,
153 };
154
155 static const struct {
156 u8 reg;
157 u8 val;
158 } us5182d_regvals[] = {
159 {US5182D_REG_CFG0, US5182D_CFG0_WORD_ENABLE},
160 {US5182D_REG_CFG1, US5182D_CFG1_ALS_RES16},
161 {US5182D_REG_CFG2, (US5182D_CFG2_PX_RES16 |
162 US5182D_CFG2_PXGAIN_DEFAULT)},
163 {US5182D_REG_CFG3, US5182D_CFG3_LED_CURRENT100 |
164 US5182D_CFG3_INT_SOURCE_PX},
165 {US5182D_REG_CFG4, 0x00},
166 };
167
168 static const struct iio_event_spec us5182d_events[] = {
169 {
170 .type = IIO_EV_TYPE_THRESH,
171 .dir = IIO_EV_DIR_RISING,
172 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
173 BIT(IIO_EV_INFO_ENABLE),
174 },
175 {
176 .type = IIO_EV_TYPE_THRESH,
177 .dir = IIO_EV_DIR_FALLING,
178 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
179 BIT(IIO_EV_INFO_ENABLE),
180 },
181 };
182
183 static const struct iio_chan_spec us5182d_channels[] = {
184 {
185 .type = IIO_LIGHT,
186 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
187 BIT(IIO_CHAN_INFO_SCALE),
188 },
189 {
190 .type = IIO_PROXIMITY,
191 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
192 .event_spec = us5182d_events,
193 .num_event_specs = ARRAY_SIZE(us5182d_events),
194 }
195 };
196
us5182d_oneshot_en(struct us5182d_data * data)197 static int us5182d_oneshot_en(struct us5182d_data *data)
198 {
199 int ret;
200
201 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG0);
202 if (ret < 0)
203 return ret;
204
205 /*
206 * In oneshot mode the chip will power itself down after taking the
207 * required measurement.
208 */
209 ret = ret | US5182D_CFG0_ONESHOT_EN;
210
211 return i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG0, ret);
212 }
213
us5182d_set_opmode(struct us5182d_data * data,u8 mode)214 static int us5182d_set_opmode(struct us5182d_data *data, u8 mode)
215 {
216 int ret;
217
218 if (mode == data->opmode)
219 return 0;
220
221 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG0);
222 if (ret < 0)
223 return ret;
224
225 /* update mode */
226 ret = ret & ~US5182D_OPMODE_MASK;
227 ret = ret | (mode << US5182D_OPMODE_SHIFT);
228
229 /*
230 * After updating the operating mode, the chip requires that
231 * the operation is stored, by writing 1 in the STORE_MODE
232 * register (auto-clearing).
233 */
234 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG0, ret);
235 if (ret < 0)
236 return ret;
237
238 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_MODE_STORE,
239 US5182D_STORE_MODE);
240 if (ret < 0)
241 return ret;
242
243 data->opmode = mode;
244 msleep(US5182D_OPSTORE_SLEEP_TIME);
245
246 return 0;
247 }
248
us5182d_als_enable(struct us5182d_data * data)249 static int us5182d_als_enable(struct us5182d_data *data)
250 {
251 int ret;
252 u8 mode;
253
254 if (data->power_mode == US5182D_ONESHOT) {
255 ret = us5182d_set_opmode(data, US5182D_ALS_ONLY);
256 if (ret < 0)
257 return ret;
258 data->px_enabled = false;
259 }
260
261 if (data->als_enabled)
262 return 0;
263
264 mode = data->px_enabled ? US5182D_ALS_PX : US5182D_ALS_ONLY;
265
266 ret = us5182d_set_opmode(data, mode);
267 if (ret < 0)
268 return ret;
269
270 data->als_enabled = true;
271
272 return 0;
273 }
274
us5182d_px_enable(struct us5182d_data * data)275 static int us5182d_px_enable(struct us5182d_data *data)
276 {
277 int ret;
278 u8 mode;
279
280 if (data->power_mode == US5182D_ONESHOT) {
281 ret = us5182d_set_opmode(data, US5182D_PX_ONLY);
282 if (ret < 0)
283 return ret;
284 data->als_enabled = false;
285 }
286
287 if (data->px_enabled)
288 return 0;
289
290 mode = data->als_enabled ? US5182D_ALS_PX : US5182D_PX_ONLY;
291
292 ret = us5182d_set_opmode(data, mode);
293 if (ret < 0)
294 return ret;
295
296 data->px_enabled = true;
297
298 return 0;
299 }
300
us5182d_get_als(struct us5182d_data * data)301 static int us5182d_get_als(struct us5182d_data *data)
302 {
303 int ret;
304 unsigned long result;
305
306 ret = us5182d_als_enable(data);
307 if (ret < 0)
308 return ret;
309
310 ret = i2c_smbus_read_word_data(data->client,
311 US5182D_REG_ADL);
312 if (ret < 0)
313 return ret;
314
315 result = ret * data->ga / US5182D_GA_RESOLUTION;
316 if (result > 0xffff)
317 result = 0xffff;
318
319 return result;
320 }
321
us5182d_get_px(struct us5182d_data * data)322 static int us5182d_get_px(struct us5182d_data *data)
323 {
324 int ret;
325
326 ret = us5182d_px_enable(data);
327 if (ret < 0)
328 return ret;
329
330 return i2c_smbus_read_word_data(data->client,
331 US5182D_REG_PDL);
332 }
333
us5182d_shutdown_en(struct us5182d_data * data,u8 state)334 static int us5182d_shutdown_en(struct us5182d_data *data, u8 state)
335 {
336 int ret;
337
338 if (data->power_mode == US5182D_ONESHOT)
339 return 0;
340
341 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG0);
342 if (ret < 0)
343 return ret;
344
345 ret = ret & ~US5182D_CFG0_SHUTDOWN_EN;
346 ret = ret | state;
347
348 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG0, ret);
349 if (ret < 0)
350 return ret;
351
352 if (state & US5182D_CFG0_SHUTDOWN_EN) {
353 data->als_enabled = false;
354 data->px_enabled = false;
355 }
356
357 return ret;
358 }
359
360
us5182d_set_power_state(struct us5182d_data * data,bool on)361 static int us5182d_set_power_state(struct us5182d_data *data, bool on)
362 {
363 if (data->power_mode == US5182D_ONESHOT)
364 return 0;
365
366 if (on)
367 return pm_runtime_resume_and_get(&data->client->dev);
368
369 return pm_runtime_put_autosuspend(&data->client->dev);
370 }
371
us5182d_read_value(struct us5182d_data * data,struct iio_chan_spec const * chan)372 static int us5182d_read_value(struct us5182d_data *data,
373 struct iio_chan_spec const *chan)
374 {
375 int ret, value;
376
377 mutex_lock(&data->lock);
378
379 if (data->power_mode == US5182D_ONESHOT) {
380 ret = us5182d_oneshot_en(data);
381 if (ret < 0)
382 goto out_err;
383 }
384
385 ret = us5182d_set_power_state(data, true);
386 if (ret < 0)
387 goto out_err;
388
389 if (chan->type == IIO_LIGHT)
390 ret = us5182d_get_als(data);
391 else
392 ret = us5182d_get_px(data);
393 if (ret < 0)
394 goto out_poweroff;
395
396 value = ret;
397
398 ret = us5182d_set_power_state(data, false);
399 if (ret < 0)
400 goto out_err;
401
402 mutex_unlock(&data->lock);
403 return value;
404
405 out_poweroff:
406 us5182d_set_power_state(data, false);
407 out_err:
408 mutex_unlock(&data->lock);
409 return ret;
410 }
411
us5182d_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)412 static int us5182d_read_raw(struct iio_dev *indio_dev,
413 struct iio_chan_spec const *chan, int *val,
414 int *val2, long mask)
415 {
416 struct us5182d_data *data = iio_priv(indio_dev);
417 int ret;
418
419 switch (mask) {
420 case IIO_CHAN_INFO_RAW:
421 ret = us5182d_read_value(data, chan);
422 if (ret < 0)
423 return ret;
424 *val = ret;
425 return IIO_VAL_INT;
426 case IIO_CHAN_INFO_SCALE:
427 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG1);
428 if (ret < 0)
429 return ret;
430 *val = 0;
431 *val2 = us5182d_scales[ret & US5182D_AGAIN_MASK];
432 return IIO_VAL_INT_PLUS_MICRO;
433 default:
434 return -EINVAL;
435 }
436 }
437
438 /**
439 * us5182d_update_dark_th - update Darh_Th registers
440 * @data: us5182d_data structure
441 * @index: index in us5182d_dark_ths array to use for the updated value
442 *
443 * Function needs to be called with a lock held because it needs two i2c write
444 * byte operations as these registers (0x27 0x28) don't work in word mode
445 * accessing.
446 */
us5182d_update_dark_th(struct us5182d_data * data,int index)447 static int us5182d_update_dark_th(struct us5182d_data *data, int index)
448 {
449 __be16 dark_th = cpu_to_be16(data->us5182d_dark_ths[index]);
450 int ret;
451
452 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_UDARK_TH,
453 ((u8 *)&dark_th)[0]);
454 if (ret < 0)
455 return ret;
456
457 return i2c_smbus_write_byte_data(data->client, US5182D_REG_UDARK_TH + 1,
458 ((u8 *)&dark_th)[1]);
459 }
460
461 /**
462 * us5182d_apply_scale - update the ALS scale
463 * @data: us5182d_data structure
464 * @index: index in us5182d_scales array to use for the updated value
465 *
466 * Function needs to be called with a lock held as we're having more than one
467 * i2c operation.
468 */
us5182d_apply_scale(struct us5182d_data * data,int index)469 static int us5182d_apply_scale(struct us5182d_data *data, int index)
470 {
471 int ret;
472
473 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG1);
474 if (ret < 0)
475 return ret;
476
477 ret = ret & (~US5182D_AGAIN_MASK);
478 ret |= index;
479
480 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG1, ret);
481 if (ret < 0)
482 return ret;
483
484 return us5182d_update_dark_th(data, index);
485 }
486
us5182d_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)487 static int us5182d_write_raw(struct iio_dev *indio_dev,
488 struct iio_chan_spec const *chan, int val,
489 int val2, long mask)
490 {
491 struct us5182d_data *data = iio_priv(indio_dev);
492 int ret, i;
493
494 switch (mask) {
495 case IIO_CHAN_INFO_SCALE:
496 if (val != 0)
497 return -EINVAL;
498 for (i = 0; i < ARRAY_SIZE(us5182d_scales); i++)
499 if (val2 == us5182d_scales[i]) {
500 mutex_lock(&data->lock);
501 ret = us5182d_apply_scale(data, i);
502 mutex_unlock(&data->lock);
503 return ret;
504 }
505 break;
506 default:
507 return -EINVAL;
508 }
509
510 return -EINVAL;
511 }
512
us5182d_setup_prox(struct iio_dev * indio_dev,enum iio_event_direction dir,u16 val)513 static int us5182d_setup_prox(struct iio_dev *indio_dev,
514 enum iio_event_direction dir, u16 val)
515 {
516 struct us5182d_data *data = iio_priv(indio_dev);
517
518 if (dir == IIO_EV_DIR_FALLING)
519 return i2c_smbus_write_word_data(data->client,
520 US5182D_REG_PXL_TH, val);
521 else if (dir == IIO_EV_DIR_RISING)
522 return i2c_smbus_write_word_data(data->client,
523 US5182D_REG_PXH_TH, val);
524
525 return 0;
526 }
527
us5182d_read_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)528 static int us5182d_read_thresh(struct iio_dev *indio_dev,
529 const struct iio_chan_spec *chan, enum iio_event_type type,
530 enum iio_event_direction dir, enum iio_event_info info, int *val,
531 int *val2)
532 {
533 struct us5182d_data *data = iio_priv(indio_dev);
534
535 switch (dir) {
536 case IIO_EV_DIR_RISING:
537 mutex_lock(&data->lock);
538 *val = data->px_high_th;
539 mutex_unlock(&data->lock);
540 break;
541 case IIO_EV_DIR_FALLING:
542 mutex_lock(&data->lock);
543 *val = data->px_low_th;
544 mutex_unlock(&data->lock);
545 break;
546 default:
547 return -EINVAL;
548 }
549
550 return IIO_VAL_INT;
551 }
552
us5182d_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)553 static int us5182d_write_thresh(struct iio_dev *indio_dev,
554 const struct iio_chan_spec *chan, enum iio_event_type type,
555 enum iio_event_direction dir, enum iio_event_info info, int val,
556 int val2)
557 {
558 struct us5182d_data *data = iio_priv(indio_dev);
559 int ret;
560
561 if (val < 0 || val > USHRT_MAX || val2 != 0)
562 return -EINVAL;
563
564 switch (dir) {
565 case IIO_EV_DIR_RISING:
566 mutex_lock(&data->lock);
567 if (data->rising_en) {
568 ret = us5182d_setup_prox(indio_dev, dir, val);
569 if (ret < 0)
570 goto err;
571 }
572 data->px_high_th = val;
573 mutex_unlock(&data->lock);
574 break;
575 case IIO_EV_DIR_FALLING:
576 mutex_lock(&data->lock);
577 if (data->falling_en) {
578 ret = us5182d_setup_prox(indio_dev, dir, val);
579 if (ret < 0)
580 goto err;
581 }
582 data->px_low_th = val;
583 mutex_unlock(&data->lock);
584 break;
585 default:
586 return -EINVAL;
587 }
588
589 return 0;
590 err:
591 mutex_unlock(&data->lock);
592 return ret;
593 }
594
us5182d_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)595 static int us5182d_read_event_config(struct iio_dev *indio_dev,
596 const struct iio_chan_spec *chan, enum iio_event_type type,
597 enum iio_event_direction dir)
598 {
599 struct us5182d_data *data = iio_priv(indio_dev);
600 int ret;
601
602 switch (dir) {
603 case IIO_EV_DIR_RISING:
604 mutex_lock(&data->lock);
605 ret = data->rising_en;
606 mutex_unlock(&data->lock);
607 break;
608 case IIO_EV_DIR_FALLING:
609 mutex_lock(&data->lock);
610 ret = data->falling_en;
611 mutex_unlock(&data->lock);
612 break;
613 default:
614 ret = -EINVAL;
615 break;
616 }
617
618 return ret;
619 }
620
us5182d_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)621 static int us5182d_write_event_config(struct iio_dev *indio_dev,
622 const struct iio_chan_spec *chan, enum iio_event_type type,
623 enum iio_event_direction dir, bool state)
624 {
625 struct us5182d_data *data = iio_priv(indio_dev);
626 int ret;
627 u16 new_th;
628
629 mutex_lock(&data->lock);
630
631 switch (dir) {
632 case IIO_EV_DIR_RISING:
633 if (data->rising_en == state) {
634 mutex_unlock(&data->lock);
635 return 0;
636 }
637 new_th = US5182D_PXH_TH_DISABLE;
638 if (state) {
639 data->power_mode = US5182D_CONTINUOUS;
640 ret = us5182d_set_power_state(data, true);
641 if (ret < 0)
642 goto err;
643 ret = us5182d_px_enable(data);
644 if (ret < 0)
645 goto err_poweroff;
646 new_th = data->px_high_th;
647 }
648 ret = us5182d_setup_prox(indio_dev, dir, new_th);
649 if (ret < 0)
650 goto err_poweroff;
651 data->rising_en = state;
652 break;
653 case IIO_EV_DIR_FALLING:
654 if (data->falling_en == state) {
655 mutex_unlock(&data->lock);
656 return 0;
657 }
658 new_th = US5182D_PXL_TH_DISABLE;
659 if (state) {
660 data->power_mode = US5182D_CONTINUOUS;
661 ret = us5182d_set_power_state(data, true);
662 if (ret < 0)
663 goto err;
664 ret = us5182d_px_enable(data);
665 if (ret < 0)
666 goto err_poweroff;
667 new_th = data->px_low_th;
668 }
669 ret = us5182d_setup_prox(indio_dev, dir, new_th);
670 if (ret < 0)
671 goto err_poweroff;
672 data->falling_en = state;
673 break;
674 default:
675 ret = -EINVAL;
676 goto err;
677 }
678
679 if (!state) {
680 ret = us5182d_set_power_state(data, false);
681 if (ret < 0)
682 goto err;
683 }
684
685 if (!data->falling_en && !data->rising_en && !data->default_continuous)
686 data->power_mode = US5182D_ONESHOT;
687
688 mutex_unlock(&data->lock);
689 return 0;
690
691 err_poweroff:
692 if (state)
693 us5182d_set_power_state(data, false);
694 err:
695 mutex_unlock(&data->lock);
696 return ret;
697 }
698
699 static const struct iio_info us5182d_info = {
700 .read_raw = us5182d_read_raw,
701 .write_raw = us5182d_write_raw,
702 .attrs = &us5182d_attr_group,
703 .read_event_value = &us5182d_read_thresh,
704 .write_event_value = &us5182d_write_thresh,
705 .read_event_config = &us5182d_read_event_config,
706 .write_event_config = &us5182d_write_event_config,
707 };
708
us5182d_reset(struct iio_dev * indio_dev)709 static int us5182d_reset(struct iio_dev *indio_dev)
710 {
711 struct us5182d_data *data = iio_priv(indio_dev);
712
713 return i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG3,
714 US5182D_RESET_CHIP);
715 }
716
us5182d_init(struct iio_dev * indio_dev)717 static int us5182d_init(struct iio_dev *indio_dev)
718 {
719 struct us5182d_data *data = iio_priv(indio_dev);
720 int i, ret;
721
722 ret = us5182d_reset(indio_dev);
723 if (ret < 0)
724 return ret;
725
726 data->opmode = 0;
727 data->power_mode = US5182D_CONTINUOUS;
728 data->px_low_th = US5182D_REG_PXL_TH_DEFAULT;
729 data->px_high_th = US5182D_REG_PXH_TH_DEFAULT;
730
731 for (i = 0; i < ARRAY_SIZE(us5182d_regvals); i++) {
732 ret = i2c_smbus_write_byte_data(data->client,
733 us5182d_regvals[i].reg,
734 us5182d_regvals[i].val);
735 if (ret < 0)
736 return ret;
737 }
738
739 data->als_enabled = true;
740 data->px_enabled = true;
741
742 if (!data->default_continuous) {
743 ret = us5182d_shutdown_en(data, US5182D_CFG0_SHUTDOWN_EN);
744 if (ret < 0)
745 return ret;
746 data->power_mode = US5182D_ONESHOT;
747 }
748
749 return ret;
750 }
751
us5182d_get_platform_data(struct iio_dev * indio_dev)752 static void us5182d_get_platform_data(struct iio_dev *indio_dev)
753 {
754 struct us5182d_data *data = iio_priv(indio_dev);
755
756 if (device_property_read_u32(&data->client->dev, "upisemi,glass-coef",
757 &data->ga))
758 data->ga = US5182D_GA_RESOLUTION;
759 if (device_property_read_u16_array(&data->client->dev,
760 "upisemi,dark-ths",
761 data->us5182d_dark_ths,
762 ARRAY_SIZE(us5182d_dark_ths_vals)))
763 data->us5182d_dark_ths = us5182d_dark_ths_vals;
764 if (device_property_read_u8(&data->client->dev,
765 "upisemi,upper-dark-gain",
766 &data->upper_dark_gain))
767 data->upper_dark_gain = US5182D_REG_AUTO_HDARK_GAIN_DEFAULT;
768 if (device_property_read_u8(&data->client->dev,
769 "upisemi,lower-dark-gain",
770 &data->lower_dark_gain))
771 data->lower_dark_gain = US5182D_REG_AUTO_LDARK_GAIN_DEFAULT;
772 data->default_continuous = device_property_read_bool(&data->client->dev,
773 "upisemi,continuous");
774 }
775
us5182d_dark_gain_config(struct iio_dev * indio_dev)776 static int us5182d_dark_gain_config(struct iio_dev *indio_dev)
777 {
778 struct us5182d_data *data = iio_priv(indio_dev);
779 int ret;
780
781 ret = us5182d_update_dark_th(data, US5182D_CFG1_AGAIN_DEFAULT);
782 if (ret < 0)
783 return ret;
784
785 ret = i2c_smbus_write_byte_data(data->client,
786 US5182D_REG_AUTO_LDARK_GAIN,
787 data->lower_dark_gain);
788 if (ret < 0)
789 return ret;
790
791 ret = i2c_smbus_write_byte_data(data->client,
792 US5182D_REG_AUTO_HDARK_GAIN,
793 data->upper_dark_gain);
794 if (ret < 0)
795 return ret;
796
797 return i2c_smbus_write_byte_data(data->client, US5182D_REG_DARK_AUTO_EN,
798 US5182D_REG_DARK_AUTO_EN_DEFAULT);
799 }
800
us5182d_irq_thread_handler(int irq,void * private)801 static irqreturn_t us5182d_irq_thread_handler(int irq, void *private)
802 {
803 struct iio_dev *indio_dev = private;
804 struct us5182d_data *data = iio_priv(indio_dev);
805 enum iio_event_direction dir;
806 int ret;
807 u64 ev;
808
809 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG0);
810 if (ret < 0) {
811 dev_err(&data->client->dev, "i2c transfer error in irq\n");
812 return IRQ_HANDLED;
813 }
814
815 dir = ret & US5182D_CFG0_PROX ? IIO_EV_DIR_RISING : IIO_EV_DIR_FALLING;
816 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 1, IIO_EV_TYPE_THRESH, dir);
817
818 iio_push_event(indio_dev, ev, iio_get_time_ns(indio_dev));
819
820 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG0,
821 ret & ~US5182D_CFG0_PX_IRQ);
822 if (ret < 0)
823 dev_err(&data->client->dev, "i2c transfer error in irq\n");
824
825 return IRQ_HANDLED;
826 }
827
us5182d_probe(struct i2c_client * client)828 static int us5182d_probe(struct i2c_client *client)
829 {
830 struct us5182d_data *data;
831 struct iio_dev *indio_dev;
832 int ret;
833
834 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
835 if (!indio_dev)
836 return -ENOMEM;
837
838 data = iio_priv(indio_dev);
839 i2c_set_clientdata(client, indio_dev);
840 data->client = client;
841
842 mutex_init(&data->lock);
843
844 indio_dev->info = &us5182d_info;
845 indio_dev->name = US5182D_DRV_NAME;
846 indio_dev->channels = us5182d_channels;
847 indio_dev->num_channels = ARRAY_SIZE(us5182d_channels);
848 indio_dev->modes = INDIO_DIRECT_MODE;
849
850 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CHIPID);
851 if (ret != US5182D_CHIPID) {
852 dev_err(&data->client->dev,
853 "Failed to detect US5182 light chip\n");
854 return (ret < 0) ? ret : -ENODEV;
855 }
856
857 if (client->irq > 0) {
858 ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
859 us5182d_irq_thread_handler,
860 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
861 "us5182d-irq", indio_dev);
862 if (ret < 0)
863 return ret;
864 } else
865 dev_warn(&client->dev, "no valid irq found\n");
866
867 us5182d_get_platform_data(indio_dev);
868 ret = us5182d_init(indio_dev);
869 if (ret < 0)
870 return ret;
871
872 ret = us5182d_dark_gain_config(indio_dev);
873 if (ret < 0)
874 goto out_err;
875
876 if (data->default_continuous) {
877 ret = pm_runtime_set_active(&client->dev);
878 if (ret < 0)
879 goto out_err;
880 }
881
882 pm_runtime_enable(&client->dev);
883 pm_runtime_set_autosuspend_delay(&client->dev,
884 US5182D_SLEEP_MS);
885 pm_runtime_use_autosuspend(&client->dev);
886
887 ret = iio_device_register(indio_dev);
888 if (ret < 0)
889 goto out_err;
890
891 return 0;
892
893 out_err:
894 us5182d_shutdown_en(data, US5182D_CFG0_SHUTDOWN_EN);
895 return ret;
896
897 }
898
us5182d_remove(struct i2c_client * client)899 static void us5182d_remove(struct i2c_client *client)
900 {
901 struct us5182d_data *data = iio_priv(i2c_get_clientdata(client));
902 int ret;
903
904 iio_device_unregister(i2c_get_clientdata(client));
905
906 pm_runtime_disable(&client->dev);
907 pm_runtime_set_suspended(&client->dev);
908
909 ret = us5182d_shutdown_en(data, US5182D_CFG0_SHUTDOWN_EN);
910 if (ret)
911 dev_warn(&client->dev, "Failed to shut down (%pe)\n",
912 ERR_PTR(ret));
913 }
914
us5182d_suspend(struct device * dev)915 static int us5182d_suspend(struct device *dev)
916 {
917 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
918 struct us5182d_data *data = iio_priv(indio_dev);
919
920 if (data->power_mode == US5182D_CONTINUOUS)
921 return us5182d_shutdown_en(data, US5182D_CFG0_SHUTDOWN_EN);
922
923 return 0;
924 }
925
us5182d_resume(struct device * dev)926 static int us5182d_resume(struct device *dev)
927 {
928 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
929 struct us5182d_data *data = iio_priv(indio_dev);
930
931 if (data->power_mode == US5182D_CONTINUOUS)
932 return us5182d_shutdown_en(data,
933 ~US5182D_CFG0_SHUTDOWN_EN & 0xff);
934
935 return 0;
936 }
937
938 static const struct dev_pm_ops us5182d_pm_ops = {
939 SYSTEM_SLEEP_PM_OPS(us5182d_suspend, us5182d_resume)
940 RUNTIME_PM_OPS(us5182d_suspend, us5182d_resume, NULL)
941 };
942
943 static const struct acpi_device_id us5182d_acpi_match[] = {
944 { "USD5182", 0 },
945 { }
946 };
947
948 MODULE_DEVICE_TABLE(acpi, us5182d_acpi_match);
949
950 static const struct i2c_device_id us5182d_id[] = {
951 { .name = "usd5182" },
952 { }
953 };
954
955 MODULE_DEVICE_TABLE(i2c, us5182d_id);
956
957 static const struct of_device_id us5182d_of_match[] = {
958 { .compatible = "upisemi,usd5182" },
959 { }
960 };
961 MODULE_DEVICE_TABLE(of, us5182d_of_match);
962
963 static struct i2c_driver us5182d_driver = {
964 .driver = {
965 .name = US5182D_DRV_NAME,
966 .pm = pm_ptr(&us5182d_pm_ops),
967 .of_match_table = us5182d_of_match,
968 .acpi_match_table = us5182d_acpi_match,
969 },
970 .probe = us5182d_probe,
971 .remove = us5182d_remove,
972 .id_table = us5182d_id,
973
974 };
975 module_i2c_driver(us5182d_driver);
976
977 MODULE_AUTHOR("Adriana Reus <adriana.reus@intel.com>");
978 MODULE_DESCRIPTION("Driver for us5182d Proximity and Light Sensor");
979 MODULE_LICENSE("GPL v2");
980