1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * A iio driver for the light sensor ISL 29018/29023/29035.
4 *
5 * IIO driver for monitoring ambient light intensity in luxi, proximity
6 * sensing and infrared sensing.
7 *
8 * Copyright (c) 2010, NVIDIA Corporation.
9 */
10
11 #include <linux/module.h>
12 #include <linux/i2c.h>
13 #include <linux/err.h>
14 #include <linux/mutex.h>
15 #include <linux/delay.h>
16 #include <linux/regmap.h>
17 #include <linux/regulator/consumer.h>
18 #include <linux/slab.h>
19 #include <linux/iio/iio.h>
20 #include <linux/iio/sysfs.h>
21 #include <linux/acpi.h>
22
23 #define ISL29018_CONV_TIME_MS 100
24
25 #define ISL29018_REG_ADD_COMMAND1 0x00
26 #define ISL29018_CMD1_OPMODE_SHIFT 5
27 #define ISL29018_CMD1_OPMODE_MASK (7 << ISL29018_CMD1_OPMODE_SHIFT)
28 #define ISL29018_CMD1_OPMODE_POWER_DOWN 0
29 #define ISL29018_CMD1_OPMODE_ALS_ONCE 1
30 #define ISL29018_CMD1_OPMODE_IR_ONCE 2
31 #define ISL29018_CMD1_OPMODE_PROX_ONCE 3
32
33 #define ISL29018_REG_ADD_COMMAND2 0x01
34 #define ISL29018_CMD2_RESOLUTION_SHIFT 2
35 #define ISL29018_CMD2_RESOLUTION_MASK (0x3 << ISL29018_CMD2_RESOLUTION_SHIFT)
36
37 #define ISL29018_CMD2_RANGE_SHIFT 0
38 #define ISL29018_CMD2_RANGE_MASK (0x3 << ISL29018_CMD2_RANGE_SHIFT)
39
40 #define ISL29018_CMD2_SCHEME_SHIFT 7
41 #define ISL29018_CMD2_SCHEME_MASK (0x1 << ISL29018_CMD2_SCHEME_SHIFT)
42
43 #define ISL29018_REG_ADD_DATA_LSB 0x02
44 #define ISL29018_REG_ADD_DATA_MSB 0x03
45
46 #define ISL29018_REG_TEST 0x08
47 #define ISL29018_TEST_SHIFT 0
48 #define ISL29018_TEST_MASK (0xFF << ISL29018_TEST_SHIFT)
49
50 #define ISL29035_REG_DEVICE_ID 0x0F
51 #define ISL29035_DEVICE_ID_SHIFT 0x03
52 #define ISL29035_DEVICE_ID_MASK (0x7 << ISL29035_DEVICE_ID_SHIFT)
53 #define ISL29035_DEVICE_ID 0x5
54 #define ISL29035_BOUT_SHIFT 0x07
55 #define ISL29035_BOUT_MASK (0x01 << ISL29035_BOUT_SHIFT)
56
57 enum isl29018_int_time {
58 ISL29018_INT_TIME_16,
59 ISL29018_INT_TIME_12,
60 ISL29018_INT_TIME_8,
61 ISL29018_INT_TIME_4,
62 };
63
64 static const unsigned int isl29018_int_utimes[3][4] = {
65 {90000, 5630, 351, 21},
66 {90000, 5600, 352, 22},
67 {105000, 6500, 410, 25},
68 };
69
70 static const struct isl29018_scale {
71 unsigned int scale;
72 unsigned int uscale;
73 } isl29018_scales[4][4] = {
74 { {0, 15258}, {0, 61035}, {0, 244140}, {0, 976562} },
75 { {0, 244140}, {0, 976562}, {3, 906250}, {15, 625000} },
76 { {3, 906250}, {15, 625000}, {62, 500000}, {250, 0} },
77 { {62, 500000}, {250, 0}, {1000, 0}, {4000, 0} }
78 };
79
80 struct isl29018_chip {
81 struct regmap *regmap;
82 struct mutex lock;
83 int type;
84 unsigned int calibscale;
85 unsigned int ucalibscale;
86 unsigned int int_time;
87 struct isl29018_scale scale;
88 int prox_scheme;
89 bool suspended;
90 struct regulator *vcc_reg;
91 };
92
isl29018_set_integration_time(struct isl29018_chip * chip,unsigned int utime)93 static int isl29018_set_integration_time(struct isl29018_chip *chip,
94 unsigned int utime)
95 {
96 unsigned int i;
97 int ret;
98 unsigned int int_time, new_int_time;
99
100 for (i = 0; i < ARRAY_SIZE(isl29018_int_utimes[chip->type]); ++i) {
101 if (utime == isl29018_int_utimes[chip->type][i]) {
102 new_int_time = i;
103 break;
104 }
105 }
106
107 if (i >= ARRAY_SIZE(isl29018_int_utimes[chip->type]))
108 return -EINVAL;
109
110 ret = regmap_update_bits(chip->regmap, ISL29018_REG_ADD_COMMAND2,
111 ISL29018_CMD2_RESOLUTION_MASK,
112 i << ISL29018_CMD2_RESOLUTION_SHIFT);
113 if (ret < 0)
114 return ret;
115
116 /* Keep the same range when integration time changes */
117 int_time = chip->int_time;
118 for (i = 0; i < ARRAY_SIZE(isl29018_scales[int_time]); ++i) {
119 if (chip->scale.scale == isl29018_scales[int_time][i].scale &&
120 chip->scale.uscale == isl29018_scales[int_time][i].uscale) {
121 chip->scale = isl29018_scales[new_int_time][i];
122 break;
123 }
124 }
125 chip->int_time = new_int_time;
126
127 return 0;
128 }
129
isl29018_set_scale(struct isl29018_chip * chip,int scale,int uscale)130 static int isl29018_set_scale(struct isl29018_chip *chip, int scale, int uscale)
131 {
132 unsigned int i;
133 int ret;
134 struct isl29018_scale new_scale;
135
136 for (i = 0; i < ARRAY_SIZE(isl29018_scales[chip->int_time]); ++i) {
137 if (scale == isl29018_scales[chip->int_time][i].scale &&
138 uscale == isl29018_scales[chip->int_time][i].uscale) {
139 new_scale = isl29018_scales[chip->int_time][i];
140 break;
141 }
142 }
143
144 if (i >= ARRAY_SIZE(isl29018_scales[chip->int_time]))
145 return -EINVAL;
146
147 ret = regmap_update_bits(chip->regmap, ISL29018_REG_ADD_COMMAND2,
148 ISL29018_CMD2_RANGE_MASK,
149 i << ISL29018_CMD2_RANGE_SHIFT);
150 if (ret < 0)
151 return ret;
152
153 chip->scale = new_scale;
154
155 return 0;
156 }
157
isl29018_read_sensor_input(struct isl29018_chip * chip,int mode)158 static int isl29018_read_sensor_input(struct isl29018_chip *chip, int mode)
159 {
160 int status;
161 unsigned int lsb;
162 unsigned int msb;
163 struct device *dev = regmap_get_device(chip->regmap);
164
165 /* Set mode */
166 status = regmap_write(chip->regmap, ISL29018_REG_ADD_COMMAND1,
167 mode << ISL29018_CMD1_OPMODE_SHIFT);
168 if (status) {
169 dev_err(dev,
170 "Error in setting operating mode err %d\n", status);
171 return status;
172 }
173 msleep(ISL29018_CONV_TIME_MS);
174 status = regmap_read(chip->regmap, ISL29018_REG_ADD_DATA_LSB, &lsb);
175 if (status < 0) {
176 dev_err(dev,
177 "Error in reading LSB DATA with err %d\n", status);
178 return status;
179 }
180
181 status = regmap_read(chip->regmap, ISL29018_REG_ADD_DATA_MSB, &msb);
182 if (status < 0) {
183 dev_err(dev,
184 "Error in reading MSB DATA with error %d\n", status);
185 return status;
186 }
187 dev_vdbg(dev, "MSB 0x%x and LSB 0x%x\n", msb, lsb);
188
189 return (msb << 8) | lsb;
190 }
191
isl29018_read_lux(struct isl29018_chip * chip,int * lux)192 static int isl29018_read_lux(struct isl29018_chip *chip, int *lux)
193 {
194 int lux_data;
195 unsigned int data_x_range;
196
197 lux_data = isl29018_read_sensor_input(chip,
198 ISL29018_CMD1_OPMODE_ALS_ONCE);
199 if (lux_data < 0)
200 return lux_data;
201
202 data_x_range = lux_data * chip->scale.scale +
203 lux_data * chip->scale.uscale / 1000000;
204 *lux = data_x_range * chip->calibscale +
205 data_x_range * chip->ucalibscale / 1000000;
206
207 return 0;
208 }
209
isl29018_read_ir(struct isl29018_chip * chip,int * ir)210 static int isl29018_read_ir(struct isl29018_chip *chip, int *ir)
211 {
212 int ir_data;
213
214 ir_data = isl29018_read_sensor_input(chip,
215 ISL29018_CMD1_OPMODE_IR_ONCE);
216 if (ir_data < 0)
217 return ir_data;
218
219 *ir = ir_data;
220
221 return 0;
222 }
223
isl29018_read_proximity_ir(struct isl29018_chip * chip,int scheme,int * near_ir)224 static int isl29018_read_proximity_ir(struct isl29018_chip *chip, int scheme,
225 int *near_ir)
226 {
227 int status;
228 int prox_data = -1;
229 int ir_data = -1;
230 struct device *dev = regmap_get_device(chip->regmap);
231
232 /* Do proximity sensing with required scheme */
233 status = regmap_update_bits(chip->regmap, ISL29018_REG_ADD_COMMAND2,
234 ISL29018_CMD2_SCHEME_MASK,
235 scheme << ISL29018_CMD2_SCHEME_SHIFT);
236 if (status) {
237 dev_err(dev, "Error in setting operating mode\n");
238 return status;
239 }
240
241 prox_data = isl29018_read_sensor_input(chip,
242 ISL29018_CMD1_OPMODE_PROX_ONCE);
243 if (prox_data < 0)
244 return prox_data;
245
246 if (scheme == 1) {
247 *near_ir = prox_data;
248 return 0;
249 }
250
251 ir_data = isl29018_read_sensor_input(chip,
252 ISL29018_CMD1_OPMODE_IR_ONCE);
253 if (ir_data < 0)
254 return ir_data;
255
256 if (prox_data >= ir_data)
257 *near_ir = prox_data - ir_data;
258 else
259 *near_ir = 0;
260
261 return 0;
262 }
263
in_illuminance_scale_available_show(struct device * dev,struct device_attribute * attr,char * buf)264 static ssize_t in_illuminance_scale_available_show
265 (struct device *dev, struct device_attribute *attr,
266 char *buf)
267 {
268 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
269 struct isl29018_chip *chip = iio_priv(indio_dev);
270 unsigned int i;
271 int len = 0;
272
273 mutex_lock(&chip->lock);
274 for (i = 0; i < ARRAY_SIZE(isl29018_scales[chip->int_time]); ++i)
275 len += sprintf(buf + len, "%d.%06d ",
276 isl29018_scales[chip->int_time][i].scale,
277 isl29018_scales[chip->int_time][i].uscale);
278 mutex_unlock(&chip->lock);
279
280 buf[len - 1] = '\n';
281
282 return len;
283 }
284
in_illuminance_integration_time_available_show(struct device * dev,struct device_attribute * attr,char * buf)285 static ssize_t in_illuminance_integration_time_available_show
286 (struct device *dev, struct device_attribute *attr,
287 char *buf)
288 {
289 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
290 struct isl29018_chip *chip = iio_priv(indio_dev);
291 unsigned int i;
292 int len = 0;
293
294 for (i = 0; i < ARRAY_SIZE(isl29018_int_utimes[chip->type]); ++i)
295 len += sprintf(buf + len, "0.%06d ",
296 isl29018_int_utimes[chip->type][i]);
297
298 buf[len - 1] = '\n';
299
300 return len;
301 }
302
303 /*
304 * From ISL29018 Data Sheet (FN6619.4, Oct 8, 2012) regarding the
305 * infrared suppression:
306 *
307 * Proximity Sensing Scheme: Bit 7. This bit programs the function
308 * of the proximity detection. Logic 0 of this bit, Scheme 0, makes
309 * full n (4, 8, 12, 16) bits (unsigned) proximity detection. The range
310 * of Scheme 0 proximity count is from 0 to 2^n. Logic 1 of this bit,
311 * Scheme 1, makes n-1 (3, 7, 11, 15) bits (2's complementary)
312 * proximity_less_ambient detection. The range of Scheme 1
313 * proximity count is from -2^(n-1) to 2^(n-1) . The sign bit is extended
314 * for resolutions less than 16. While Scheme 0 has wider dynamic
315 * range, Scheme 1 proximity detection is less affected by the
316 * ambient IR noise variation.
317 *
318 * 0 Sensing IR from LED and ambient
319 * 1 Sensing IR from LED with ambient IR rejection
320 */
proximity_on_chip_ambient_infrared_suppression_show(struct device * dev,struct device_attribute * attr,char * buf)321 static ssize_t proximity_on_chip_ambient_infrared_suppression_show
322 (struct device *dev, struct device_attribute *attr,
323 char *buf)
324 {
325 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
326 struct isl29018_chip *chip = iio_priv(indio_dev);
327
328 /*
329 * Return the "proximity scheme" i.e. if the chip does on chip
330 * infrared suppression (1 means perform on chip suppression)
331 */
332 return sprintf(buf, "%d\n", chip->prox_scheme);
333 }
334
proximity_on_chip_ambient_infrared_suppression_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)335 static ssize_t proximity_on_chip_ambient_infrared_suppression_store
336 (struct device *dev, struct device_attribute *attr,
337 const char *buf, size_t count)
338 {
339 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
340 struct isl29018_chip *chip = iio_priv(indio_dev);
341 int val;
342
343 if (kstrtoint(buf, 10, &val))
344 return -EINVAL;
345 if (!(val == 0 || val == 1))
346 return -EINVAL;
347
348 /*
349 * Get the "proximity scheme" i.e. if the chip does on chip
350 * infrared suppression (1 means perform on chip suppression)
351 */
352 mutex_lock(&chip->lock);
353 chip->prox_scheme = val;
354 mutex_unlock(&chip->lock);
355
356 return count;
357 }
358
isl29018_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)359 static int isl29018_write_raw(struct iio_dev *indio_dev,
360 struct iio_chan_spec const *chan,
361 int val,
362 int val2,
363 long mask)
364 {
365 struct isl29018_chip *chip = iio_priv(indio_dev);
366 int ret = -EINVAL;
367
368 mutex_lock(&chip->lock);
369 if (chip->suspended) {
370 ret = -EBUSY;
371 goto write_done;
372 }
373 switch (mask) {
374 case IIO_CHAN_INFO_CALIBSCALE:
375 if (chan->type == IIO_LIGHT) {
376 chip->calibscale = val;
377 chip->ucalibscale = val2;
378 ret = 0;
379 }
380 break;
381 case IIO_CHAN_INFO_INT_TIME:
382 if (chan->type == IIO_LIGHT && !val)
383 ret = isl29018_set_integration_time(chip, val2);
384 break;
385 case IIO_CHAN_INFO_SCALE:
386 if (chan->type == IIO_LIGHT)
387 ret = isl29018_set_scale(chip, val, val2);
388 break;
389 default:
390 break;
391 }
392
393 write_done:
394 mutex_unlock(&chip->lock);
395
396 return ret;
397 }
398
isl29018_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)399 static int isl29018_read_raw(struct iio_dev *indio_dev,
400 struct iio_chan_spec const *chan,
401 int *val,
402 int *val2,
403 long mask)
404 {
405 int ret = -EINVAL;
406 struct isl29018_chip *chip = iio_priv(indio_dev);
407
408 mutex_lock(&chip->lock);
409 if (chip->suspended) {
410 ret = -EBUSY;
411 goto read_done;
412 }
413 switch (mask) {
414 case IIO_CHAN_INFO_RAW:
415 case IIO_CHAN_INFO_PROCESSED:
416 switch (chan->type) {
417 case IIO_LIGHT:
418 ret = isl29018_read_lux(chip, val);
419 break;
420 case IIO_INTENSITY:
421 ret = isl29018_read_ir(chip, val);
422 break;
423 case IIO_PROXIMITY:
424 ret = isl29018_read_proximity_ir(chip,
425 chip->prox_scheme,
426 val);
427 break;
428 default:
429 break;
430 }
431 if (!ret)
432 ret = IIO_VAL_INT;
433 break;
434 case IIO_CHAN_INFO_INT_TIME:
435 if (chan->type == IIO_LIGHT) {
436 *val = 0;
437 *val2 = isl29018_int_utimes[chip->type][chip->int_time];
438 ret = IIO_VAL_INT_PLUS_MICRO;
439 }
440 break;
441 case IIO_CHAN_INFO_SCALE:
442 if (chan->type == IIO_LIGHT) {
443 *val = chip->scale.scale;
444 *val2 = chip->scale.uscale;
445 ret = IIO_VAL_INT_PLUS_MICRO;
446 }
447 break;
448 case IIO_CHAN_INFO_CALIBSCALE:
449 if (chan->type == IIO_LIGHT) {
450 *val = chip->calibscale;
451 *val2 = chip->ucalibscale;
452 ret = IIO_VAL_INT_PLUS_MICRO;
453 }
454 break;
455 default:
456 break;
457 }
458
459 read_done:
460 mutex_unlock(&chip->lock);
461
462 return ret;
463 }
464
465 #define ISL29018_LIGHT_CHANNEL { \
466 .type = IIO_LIGHT, \
467 .indexed = 1, \
468 .channel = 0, \
469 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | \
470 BIT(IIO_CHAN_INFO_CALIBSCALE) | \
471 BIT(IIO_CHAN_INFO_SCALE) | \
472 BIT(IIO_CHAN_INFO_INT_TIME), \
473 }
474
475 #define ISL29018_IR_CHANNEL { \
476 .type = IIO_INTENSITY, \
477 .modified = 1, \
478 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
479 .channel2 = IIO_MOD_LIGHT_IR, \
480 }
481
482 #define ISL29018_PROXIMITY_CHANNEL { \
483 .type = IIO_PROXIMITY, \
484 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
485 }
486
487 static const struct iio_chan_spec isl29018_channels[] = {
488 ISL29018_LIGHT_CHANNEL,
489 ISL29018_IR_CHANNEL,
490 ISL29018_PROXIMITY_CHANNEL,
491 };
492
493 static const struct iio_chan_spec isl29023_channels[] = {
494 ISL29018_LIGHT_CHANNEL,
495 ISL29018_IR_CHANNEL,
496 };
497
498 static IIO_DEVICE_ATTR_RO(in_illuminance_integration_time_available, 0);
499 static IIO_DEVICE_ATTR_RO(in_illuminance_scale_available, 0);
500 static IIO_DEVICE_ATTR_RW(proximity_on_chip_ambient_infrared_suppression, 0);
501
502 #define ISL29018_DEV_ATTR(name) (&iio_dev_attr_##name.dev_attr.attr)
503
504 static struct attribute *isl29018_attributes[] = {
505 ISL29018_DEV_ATTR(in_illuminance_scale_available),
506 ISL29018_DEV_ATTR(in_illuminance_integration_time_available),
507 ISL29018_DEV_ATTR(proximity_on_chip_ambient_infrared_suppression),
508 NULL
509 };
510
511 static struct attribute *isl29023_attributes[] = {
512 ISL29018_DEV_ATTR(in_illuminance_scale_available),
513 ISL29018_DEV_ATTR(in_illuminance_integration_time_available),
514 NULL
515 };
516
517 static const struct attribute_group isl29018_group = {
518 .attrs = isl29018_attributes,
519 };
520
521 static const struct attribute_group isl29023_group = {
522 .attrs = isl29023_attributes,
523 };
524
525 enum {
526 isl29018,
527 isl29023,
528 isl29035,
529 };
530
isl29018_chip_init(struct isl29018_chip * chip)531 static int isl29018_chip_init(struct isl29018_chip *chip)
532 {
533 int status;
534 struct device *dev = regmap_get_device(chip->regmap);
535
536 if (chip->type == isl29035) {
537 unsigned int id;
538
539 status = regmap_read(chip->regmap, ISL29035_REG_DEVICE_ID, &id);
540 if (status < 0) {
541 dev_err(dev,
542 "Error reading ID register with error %d\n",
543 status);
544 return status;
545 }
546
547 id = (id & ISL29035_DEVICE_ID_MASK) >> ISL29035_DEVICE_ID_SHIFT;
548
549 if (id != ISL29035_DEVICE_ID)
550 return -ENODEV;
551
552 /* Clear brownout bit */
553 status = regmap_update_bits(chip->regmap,
554 ISL29035_REG_DEVICE_ID,
555 ISL29035_BOUT_MASK, 0);
556 if (status < 0)
557 return status;
558 }
559
560 /*
561 * Code added per Intersil Application Note 1534:
562 * When VDD sinks to approximately 1.8V or below, some of
563 * the part's registers may change their state. When VDD
564 * recovers to 2.25V (or greater), the part may thus be in an
565 * unknown mode of operation. The user can return the part to
566 * a known mode of operation either by (a) setting VDD = 0V for
567 * 1 second or more and then powering back up with a slew rate
568 * of 0.5V/ms or greater, or (b) via I2C disable all ALS/PROX
569 * conversions, clear the test registers, and then rewrite all
570 * registers to the desired values.
571 * ...
572 * For ISL29011, ISL29018, ISL29021, ISL29023
573 * 1. Write 0x00 to register 0x08 (TEST)
574 * 2. Write 0x00 to register 0x00 (CMD1)
575 * 3. Rewrite all registers to the desired values
576 *
577 * ISL29018 Data Sheet (FN6619.1, Feb 11, 2010) essentially says
578 * the same thing EXCEPT the data sheet asks for a 1ms delay after
579 * writing the CMD1 register.
580 */
581 status = regmap_write(chip->regmap, ISL29018_REG_TEST, 0x0);
582 if (status < 0) {
583 dev_err(dev, "Failed to clear isl29018 TEST reg.(%d)\n",
584 status);
585 return status;
586 }
587
588 /*
589 * See Intersil AN1534 comments above.
590 * "Operating Mode" (COMMAND1) register is reprogrammed when
591 * data is read from the device.
592 */
593 status = regmap_write(chip->regmap, ISL29018_REG_ADD_COMMAND1, 0);
594 if (status < 0) {
595 dev_err(dev, "Failed to clear isl29018 CMD1 reg.(%d)\n",
596 status);
597 return status;
598 }
599
600 usleep_range(1000, 2000); /* per data sheet, page 10 */
601
602 /* Set defaults */
603 status = isl29018_set_scale(chip, chip->scale.scale,
604 chip->scale.uscale);
605 if (status < 0) {
606 dev_err(dev, "Init of isl29018 fails\n");
607 return status;
608 }
609
610 status = isl29018_set_integration_time(chip,
611 isl29018_int_utimes[chip->type][chip->int_time]);
612 if (status < 0)
613 dev_err(dev, "Init of isl29018 fails\n");
614
615 return status;
616 }
617
618 static const struct iio_info isl29018_info = {
619 .attrs = &isl29018_group,
620 .read_raw = isl29018_read_raw,
621 .write_raw = isl29018_write_raw,
622 };
623
624 static const struct iio_info isl29023_info = {
625 .attrs = &isl29023_group,
626 .read_raw = isl29018_read_raw,
627 .write_raw = isl29018_write_raw,
628 };
629
isl29018_is_volatile_reg(struct device * dev,unsigned int reg)630 static bool isl29018_is_volatile_reg(struct device *dev, unsigned int reg)
631 {
632 switch (reg) {
633 case ISL29018_REG_ADD_DATA_LSB:
634 case ISL29018_REG_ADD_DATA_MSB:
635 case ISL29018_REG_ADD_COMMAND1:
636 case ISL29018_REG_TEST:
637 case ISL29035_REG_DEVICE_ID:
638 return true;
639 default:
640 return false;
641 }
642 }
643
644 static const struct regmap_config isl29018_regmap_config = {
645 .reg_bits = 8,
646 .val_bits = 8,
647 .volatile_reg = isl29018_is_volatile_reg,
648 .max_register = ISL29018_REG_TEST,
649 .num_reg_defaults_raw = ISL29018_REG_TEST + 1,
650 .cache_type = REGCACHE_RBTREE,
651 };
652
653 static const struct regmap_config isl29035_regmap_config = {
654 .reg_bits = 8,
655 .val_bits = 8,
656 .volatile_reg = isl29018_is_volatile_reg,
657 .max_register = ISL29035_REG_DEVICE_ID,
658 .num_reg_defaults_raw = ISL29035_REG_DEVICE_ID + 1,
659 .cache_type = REGCACHE_RBTREE,
660 };
661
662 struct isl29018_chip_info {
663 const struct iio_chan_spec *channels;
664 int num_channels;
665 const struct iio_info *indio_info;
666 const struct regmap_config *regmap_cfg;
667 };
668
669 static const struct isl29018_chip_info isl29018_chip_info_tbl[] = {
670 [isl29018] = {
671 .channels = isl29018_channels,
672 .num_channels = ARRAY_SIZE(isl29018_channels),
673 .indio_info = &isl29018_info,
674 .regmap_cfg = &isl29018_regmap_config,
675 },
676 [isl29023] = {
677 .channels = isl29023_channels,
678 .num_channels = ARRAY_SIZE(isl29023_channels),
679 .indio_info = &isl29023_info,
680 .regmap_cfg = &isl29018_regmap_config,
681 },
682 [isl29035] = {
683 .channels = isl29023_channels,
684 .num_channels = ARRAY_SIZE(isl29023_channels),
685 .indio_info = &isl29023_info,
686 .regmap_cfg = &isl29035_regmap_config,
687 },
688 };
689
isl29018_match_acpi_device(struct device * dev,int * data)690 static const char *isl29018_match_acpi_device(struct device *dev, int *data)
691 {
692 const struct acpi_device_id *id;
693
694 id = acpi_match_device(dev->driver->acpi_match_table, dev);
695
696 if (!id)
697 return NULL;
698
699 *data = (int)id->driver_data;
700
701 return dev_name(dev);
702 }
703
isl29018_disable_regulator_action(void * _data)704 static void isl29018_disable_regulator_action(void *_data)
705 {
706 struct isl29018_chip *chip = _data;
707 int err;
708
709 err = regulator_disable(chip->vcc_reg);
710 if (err)
711 pr_err("failed to disable isl29018's VCC regulator!\n");
712 }
713
isl29018_probe(struct i2c_client * client)714 static int isl29018_probe(struct i2c_client *client)
715 {
716 const struct i2c_device_id *id = i2c_client_get_device_id(client);
717 struct isl29018_chip *chip;
718 struct iio_dev *indio_dev;
719 int err;
720 const char *name = NULL;
721 int dev_id = 0;
722
723 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
724 if (!indio_dev)
725 return -ENOMEM;
726
727 chip = iio_priv(indio_dev);
728
729 i2c_set_clientdata(client, indio_dev);
730
731 if (id) {
732 name = id->name;
733 dev_id = id->driver_data;
734 }
735
736 if (ACPI_HANDLE(&client->dev))
737 name = isl29018_match_acpi_device(&client->dev, &dev_id);
738
739 mutex_init(&chip->lock);
740
741 chip->type = dev_id;
742 chip->calibscale = 1;
743 chip->ucalibscale = 0;
744 chip->int_time = ISL29018_INT_TIME_16;
745 chip->scale = isl29018_scales[chip->int_time][0];
746 chip->suspended = false;
747
748 chip->vcc_reg = devm_regulator_get(&client->dev, "vcc");
749 if (IS_ERR(chip->vcc_reg))
750 return dev_err_probe(&client->dev, PTR_ERR(chip->vcc_reg),
751 "failed to get VCC regulator!\n");
752
753 err = regulator_enable(chip->vcc_reg);
754 if (err) {
755 dev_err(&client->dev, "failed to enable VCC regulator!\n");
756 return err;
757 }
758
759 err = devm_add_action_or_reset(&client->dev, isl29018_disable_regulator_action,
760 chip);
761 if (err) {
762 dev_err(&client->dev, "failed to setup regulator cleanup action!\n");
763 return err;
764 }
765
766 chip->regmap = devm_regmap_init_i2c(client,
767 isl29018_chip_info_tbl[dev_id].regmap_cfg);
768 if (IS_ERR(chip->regmap)) {
769 err = PTR_ERR(chip->regmap);
770 dev_err(&client->dev, "regmap initialization fails: %d\n", err);
771 return err;
772 }
773
774 err = isl29018_chip_init(chip);
775 if (err)
776 return err;
777
778 indio_dev->info = isl29018_chip_info_tbl[dev_id].indio_info;
779 indio_dev->channels = isl29018_chip_info_tbl[dev_id].channels;
780 indio_dev->num_channels = isl29018_chip_info_tbl[dev_id].num_channels;
781 indio_dev->name = name;
782 indio_dev->modes = INDIO_DIRECT_MODE;
783
784 return devm_iio_device_register(&client->dev, indio_dev);
785 }
786
isl29018_suspend(struct device * dev)787 static int isl29018_suspend(struct device *dev)
788 {
789 struct isl29018_chip *chip = iio_priv(dev_get_drvdata(dev));
790 int ret;
791
792 mutex_lock(&chip->lock);
793
794 /*
795 * Since this driver uses only polling commands, we are by default in
796 * auto shutdown (ie, power-down) mode.
797 * So we do not have much to do here.
798 */
799 chip->suspended = true;
800 ret = regulator_disable(chip->vcc_reg);
801 if (ret)
802 dev_err(dev, "failed to disable VCC regulator\n");
803
804 mutex_unlock(&chip->lock);
805
806 return ret;
807 }
808
isl29018_resume(struct device * dev)809 static int isl29018_resume(struct device *dev)
810 {
811 struct isl29018_chip *chip = iio_priv(dev_get_drvdata(dev));
812 int err;
813
814 mutex_lock(&chip->lock);
815
816 err = regulator_enable(chip->vcc_reg);
817 if (err) {
818 dev_err(dev, "failed to enable VCC regulator\n");
819 mutex_unlock(&chip->lock);
820 return err;
821 }
822
823 err = isl29018_chip_init(chip);
824 if (!err)
825 chip->suspended = false;
826
827 mutex_unlock(&chip->lock);
828
829 return err;
830 }
831
832 static DEFINE_SIMPLE_DEV_PM_OPS(isl29018_pm_ops, isl29018_suspend,
833 isl29018_resume);
834
835 #ifdef CONFIG_ACPI
836 static const struct acpi_device_id isl29018_acpi_match[] = {
837 {"ISL29018", isl29018},
838 {"ISL29023", isl29023},
839 {"ISL29035", isl29035},
840 {},
841 };
842 MODULE_DEVICE_TABLE(acpi, isl29018_acpi_match);
843 #endif
844
845 static const struct i2c_device_id isl29018_id[] = {
846 {"isl29018", isl29018},
847 {"isl29023", isl29023},
848 {"isl29035", isl29035},
849 {}
850 };
851 MODULE_DEVICE_TABLE(i2c, isl29018_id);
852
853 static const struct of_device_id isl29018_of_match[] = {
854 { .compatible = "isil,isl29018", },
855 { .compatible = "isil,isl29023", },
856 { .compatible = "isil,isl29035", },
857 { },
858 };
859 MODULE_DEVICE_TABLE(of, isl29018_of_match);
860
861 static struct i2c_driver isl29018_driver = {
862 .driver = {
863 .name = "isl29018",
864 .acpi_match_table = ACPI_PTR(isl29018_acpi_match),
865 .pm = pm_sleep_ptr(&isl29018_pm_ops),
866 .of_match_table = isl29018_of_match,
867 },
868 .probe = isl29018_probe,
869 .id_table = isl29018_id,
870 };
871 module_i2c_driver(isl29018_driver);
872
873 MODULE_DESCRIPTION("ISL29018 Ambient Light Sensor driver");
874 MODULE_LICENSE("GPL");
875