1 /*
2 * A iio driver for the light sensor ISL 29018/29023/29035.
3 *
4 * IIO driver for monitoring ambient light intensity in luxi, proximity
5 * sensing and infrared sensing.
6 *
7 * Copyright (c) 2010, NVIDIA Corporation.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful, but WITHOUT
15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17 * more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22 */
23
24 #include <linux/module.h>
25 #include <linux/i2c.h>
26 #include <linux/err.h>
27 #include <linux/mutex.h>
28 #include <linux/delay.h>
29 #include <linux/regmap.h>
30 #include <linux/slab.h>
31 #include <linux/iio/iio.h>
32 #include <linux/iio/sysfs.h>
33 #include <linux/acpi.h>
34
35 #define CONVERSION_TIME_MS 100
36
37 #define ISL29018_REG_ADD_COMMAND1 0x00
38 #define COMMMAND1_OPMODE_SHIFT 5
39 #define COMMMAND1_OPMODE_MASK (7 << COMMMAND1_OPMODE_SHIFT)
40 #define COMMMAND1_OPMODE_POWER_DOWN 0
41 #define COMMMAND1_OPMODE_ALS_ONCE 1
42 #define COMMMAND1_OPMODE_IR_ONCE 2
43 #define COMMMAND1_OPMODE_PROX_ONCE 3
44
45 #define ISL29018_REG_ADD_COMMANDII 0x01
46 #define COMMANDII_RESOLUTION_SHIFT 2
47 #define COMMANDII_RESOLUTION_MASK (0x3 << COMMANDII_RESOLUTION_SHIFT)
48
49 #define COMMANDII_RANGE_SHIFT 0
50 #define COMMANDII_RANGE_MASK (0x3 << COMMANDII_RANGE_SHIFT)
51
52 #define COMMANDII_SCHEME_SHIFT 7
53 #define COMMANDII_SCHEME_MASK (0x1 << COMMANDII_SCHEME_SHIFT)
54
55 #define ISL29018_REG_ADD_DATA_LSB 0x02
56 #define ISL29018_REG_ADD_DATA_MSB 0x03
57
58 #define ISL29018_REG_TEST 0x08
59 #define ISL29018_TEST_SHIFT 0
60 #define ISL29018_TEST_MASK (0xFF << ISL29018_TEST_SHIFT)
61
62 #define ISL29035_REG_DEVICE_ID 0x0F
63 #define ISL29035_DEVICE_ID_SHIFT 0x03
64 #define ISL29035_DEVICE_ID_MASK (0x7 << ISL29035_DEVICE_ID_SHIFT)
65 #define ISL29035_DEVICE_ID 0x5
66 #define ISL29035_BOUT_SHIFT 0x07
67 #define ISL29035_BOUT_MASK (0x01 << ISL29035_BOUT_SHIFT)
68
69 struct isl29018_chip {
70 struct device *dev;
71 struct regmap *regmap;
72 struct mutex lock;
73 int type;
74 unsigned int lux_scale;
75 unsigned int lux_uscale;
76 unsigned int range;
77 unsigned int adc_bit;
78 int prox_scheme;
79 bool suspended;
80 };
81
isl29018_set_range(struct isl29018_chip * chip,unsigned long range,unsigned int * new_range)82 static int isl29018_set_range(struct isl29018_chip *chip, unsigned long range,
83 unsigned int *new_range)
84 {
85 static const unsigned long supp_ranges[] = {1000, 4000, 16000, 64000};
86 int i;
87
88 for (i = 0; i < ARRAY_SIZE(supp_ranges); ++i) {
89 if (range <= supp_ranges[i]) {
90 *new_range = (unsigned int)supp_ranges[i];
91 break;
92 }
93 }
94
95 if (i >= ARRAY_SIZE(supp_ranges))
96 return -EINVAL;
97
98 return regmap_update_bits(chip->regmap, ISL29018_REG_ADD_COMMANDII,
99 COMMANDII_RANGE_MASK, i << COMMANDII_RANGE_SHIFT);
100 }
101
isl29018_set_resolution(struct isl29018_chip * chip,unsigned long adcbit,unsigned int * conf_adc_bit)102 static int isl29018_set_resolution(struct isl29018_chip *chip,
103 unsigned long adcbit, unsigned int *conf_adc_bit)
104 {
105 static const unsigned long supp_adcbit[] = {16, 12, 8, 4};
106 int i;
107
108 for (i = 0; i < ARRAY_SIZE(supp_adcbit); ++i) {
109 if (adcbit >= supp_adcbit[i]) {
110 *conf_adc_bit = (unsigned int)supp_adcbit[i];
111 break;
112 }
113 }
114
115 if (i >= ARRAY_SIZE(supp_adcbit))
116 return -EINVAL;
117
118 return regmap_update_bits(chip->regmap, ISL29018_REG_ADD_COMMANDII,
119 COMMANDII_RESOLUTION_MASK,
120 i << COMMANDII_RESOLUTION_SHIFT);
121 }
122
isl29018_read_sensor_input(struct isl29018_chip * chip,int mode)123 static int isl29018_read_sensor_input(struct isl29018_chip *chip, int mode)
124 {
125 int status;
126 unsigned int lsb;
127 unsigned int msb;
128
129 /* Set mode */
130 status = regmap_write(chip->regmap, ISL29018_REG_ADD_COMMAND1,
131 mode << COMMMAND1_OPMODE_SHIFT);
132 if (status) {
133 dev_err(chip->dev,
134 "Error in setting operating mode err %d\n", status);
135 return status;
136 }
137 msleep(CONVERSION_TIME_MS);
138 status = regmap_read(chip->regmap, ISL29018_REG_ADD_DATA_LSB, &lsb);
139 if (status < 0) {
140 dev_err(chip->dev,
141 "Error in reading LSB DATA with err %d\n", status);
142 return status;
143 }
144
145 status = regmap_read(chip->regmap, ISL29018_REG_ADD_DATA_MSB, &msb);
146 if (status < 0) {
147 dev_err(chip->dev,
148 "Error in reading MSB DATA with error %d\n", status);
149 return status;
150 }
151 dev_vdbg(chip->dev, "MSB 0x%x and LSB 0x%x\n", msb, lsb);
152
153 return (msb << 8) | lsb;
154 }
155
isl29018_read_lux(struct isl29018_chip * chip,int * lux)156 static int isl29018_read_lux(struct isl29018_chip *chip, int *lux)
157 {
158 int lux_data;
159 unsigned int data_x_range, lux_unshifted;
160
161 lux_data = isl29018_read_sensor_input(chip, COMMMAND1_OPMODE_ALS_ONCE);
162
163 if (lux_data < 0)
164 return lux_data;
165
166 /* To support fractional scaling, separate the unshifted lux
167 * into two calculations: int scaling and micro-scaling.
168 * lux_uscale ranges from 0-999999, so about 20 bits. Split
169 * the /1,000,000 in two to reduce the risk of over/underflow.
170 */
171 data_x_range = lux_data * chip->range;
172 lux_unshifted = data_x_range * chip->lux_scale;
173 lux_unshifted += data_x_range / 1000 * chip->lux_uscale / 1000;
174 *lux = lux_unshifted >> chip->adc_bit;
175
176 return 0;
177 }
178
isl29018_read_ir(struct isl29018_chip * chip,int * ir)179 static int isl29018_read_ir(struct isl29018_chip *chip, int *ir)
180 {
181 int ir_data;
182
183 ir_data = isl29018_read_sensor_input(chip, COMMMAND1_OPMODE_IR_ONCE);
184
185 if (ir_data < 0)
186 return ir_data;
187
188 *ir = ir_data;
189
190 return 0;
191 }
192
isl29018_read_proximity_ir(struct isl29018_chip * chip,int scheme,int * near_ir)193 static int isl29018_read_proximity_ir(struct isl29018_chip *chip, int scheme,
194 int *near_ir)
195 {
196 int status;
197 int prox_data = -1;
198 int ir_data = -1;
199
200 /* Do proximity sensing with required scheme */
201 status = regmap_update_bits(chip->regmap, ISL29018_REG_ADD_COMMANDII,
202 COMMANDII_SCHEME_MASK,
203 scheme << COMMANDII_SCHEME_SHIFT);
204 if (status) {
205 dev_err(chip->dev, "Error in setting operating mode\n");
206 return status;
207 }
208
209 prox_data = isl29018_read_sensor_input(chip,
210 COMMMAND1_OPMODE_PROX_ONCE);
211 if (prox_data < 0)
212 return prox_data;
213
214 if (scheme == 1) {
215 *near_ir = prox_data;
216 return 0;
217 }
218
219 ir_data = isl29018_read_sensor_input(chip, COMMMAND1_OPMODE_IR_ONCE);
220
221 if (ir_data < 0)
222 return ir_data;
223
224 if (prox_data >= ir_data)
225 *near_ir = prox_data - ir_data;
226 else
227 *near_ir = 0;
228
229 return 0;
230 }
231
232 /* Sysfs interface */
233 /* range */
show_range(struct device * dev,struct device_attribute * attr,char * buf)234 static ssize_t show_range(struct device *dev,
235 struct device_attribute *attr, char *buf)
236 {
237 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
238 struct isl29018_chip *chip = iio_priv(indio_dev);
239
240 return sprintf(buf, "%u\n", chip->range);
241 }
242
store_range(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)243 static ssize_t store_range(struct device *dev,
244 struct device_attribute *attr, const char *buf, size_t count)
245 {
246 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
247 struct isl29018_chip *chip = iio_priv(indio_dev);
248 int status;
249 unsigned long lval;
250 unsigned int new_range;
251
252 if (kstrtoul(buf, 10, &lval))
253 return -EINVAL;
254
255 if (!(lval == 1000UL || lval == 4000UL ||
256 lval == 16000UL || lval == 64000UL)) {
257 dev_err(dev, "The range is not supported\n");
258 return -EINVAL;
259 }
260
261 mutex_lock(&chip->lock);
262 status = isl29018_set_range(chip, lval, &new_range);
263 if (status < 0) {
264 mutex_unlock(&chip->lock);
265 dev_err(dev,
266 "Error in setting max range with err %d\n", status);
267 return status;
268 }
269 chip->range = new_range;
270 mutex_unlock(&chip->lock);
271
272 return count;
273 }
274
275 /* resolution */
show_resolution(struct device * dev,struct device_attribute * attr,char * buf)276 static ssize_t show_resolution(struct device *dev,
277 struct device_attribute *attr, char *buf)
278 {
279 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
280 struct isl29018_chip *chip = iio_priv(indio_dev);
281
282 return sprintf(buf, "%u\n", chip->adc_bit);
283 }
284
store_resolution(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)285 static ssize_t store_resolution(struct device *dev,
286 struct device_attribute *attr, const char *buf, size_t count)
287 {
288 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
289 struct isl29018_chip *chip = iio_priv(indio_dev);
290 int status;
291 unsigned int val;
292 unsigned int new_adc_bit;
293
294 if (kstrtouint(buf, 10, &val))
295 return -EINVAL;
296 if (!(val == 4 || val == 8 || val == 12 || val == 16)) {
297 dev_err(dev, "The resolution is not supported\n");
298 return -EINVAL;
299 }
300
301 mutex_lock(&chip->lock);
302 status = isl29018_set_resolution(chip, val, &new_adc_bit);
303 if (status < 0) {
304 mutex_unlock(&chip->lock);
305 dev_err(dev, "Error in setting resolution\n");
306 return status;
307 }
308 chip->adc_bit = new_adc_bit;
309 mutex_unlock(&chip->lock);
310
311 return count;
312 }
313
314 /* proximity scheme */
show_prox_infrared_suppression(struct device * dev,struct device_attribute * attr,char * buf)315 static ssize_t show_prox_infrared_suppression(struct device *dev,
316 struct device_attribute *attr, char *buf)
317 {
318 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
319 struct isl29018_chip *chip = iio_priv(indio_dev);
320
321 /* return the "proximity scheme" i.e. if the chip does on chip
322 infrared suppression (1 means perform on chip suppression) */
323 return sprintf(buf, "%d\n", chip->prox_scheme);
324 }
325
store_prox_infrared_suppression(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)326 static ssize_t store_prox_infrared_suppression(struct device *dev,
327 struct device_attribute *attr, const char *buf, size_t count)
328 {
329 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
330 struct isl29018_chip *chip = iio_priv(indio_dev);
331 int val;
332
333 if (kstrtoint(buf, 10, &val))
334 return -EINVAL;
335 if (!(val == 0 || val == 1)) {
336 dev_err(dev, "The mode is not supported\n");
337 return -EINVAL;
338 }
339
340 /* get the "proximity scheme" i.e. if the chip does on chip
341 infrared suppression (1 means perform on chip suppression) */
342 mutex_lock(&chip->lock);
343 chip->prox_scheme = val;
344 mutex_unlock(&chip->lock);
345
346 return count;
347 }
348
349 /* Channel IO */
isl29018_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)350 static int isl29018_write_raw(struct iio_dev *indio_dev,
351 struct iio_chan_spec const *chan,
352 int val,
353 int val2,
354 long mask)
355 {
356 struct isl29018_chip *chip = iio_priv(indio_dev);
357 int ret = -EINVAL;
358
359 mutex_lock(&chip->lock);
360 if (mask == IIO_CHAN_INFO_CALIBSCALE && chan->type == IIO_LIGHT) {
361 chip->lux_scale = val;
362 /* With no write_raw_get_fmt(), val2 is a MICRO fraction. */
363 chip->lux_uscale = val2;
364 ret = 0;
365 }
366 mutex_unlock(&chip->lock);
367
368 return ret;
369 }
370
isl29018_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)371 static int isl29018_read_raw(struct iio_dev *indio_dev,
372 struct iio_chan_spec const *chan,
373 int *val,
374 int *val2,
375 long mask)
376 {
377 int ret = -EINVAL;
378 struct isl29018_chip *chip = iio_priv(indio_dev);
379
380 mutex_lock(&chip->lock);
381 if (chip->suspended) {
382 mutex_unlock(&chip->lock);
383 return -EBUSY;
384 }
385 switch (mask) {
386 case IIO_CHAN_INFO_RAW:
387 case IIO_CHAN_INFO_PROCESSED:
388 switch (chan->type) {
389 case IIO_LIGHT:
390 ret = isl29018_read_lux(chip, val);
391 break;
392 case IIO_INTENSITY:
393 ret = isl29018_read_ir(chip, val);
394 break;
395 case IIO_PROXIMITY:
396 ret = isl29018_read_proximity_ir(chip,
397 chip->prox_scheme, val);
398 break;
399 default:
400 break;
401 }
402 if (!ret)
403 ret = IIO_VAL_INT;
404 break;
405 case IIO_CHAN_INFO_CALIBSCALE:
406 if (chan->type == IIO_LIGHT) {
407 *val = chip->lux_scale;
408 *val2 = chip->lux_uscale;
409 ret = IIO_VAL_INT_PLUS_MICRO;
410 }
411 break;
412 default:
413 break;
414 }
415 mutex_unlock(&chip->lock);
416 return ret;
417 }
418
419 #define ISL29018_LIGHT_CHANNEL { \
420 .type = IIO_LIGHT, \
421 .indexed = 1, \
422 .channel = 0, \
423 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | \
424 BIT(IIO_CHAN_INFO_CALIBSCALE), \
425 }
426
427 #define ISL29018_IR_CHANNEL { \
428 .type = IIO_INTENSITY, \
429 .modified = 1, \
430 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
431 .channel2 = IIO_MOD_LIGHT_IR, \
432 }
433
434 #define ISL29018_PROXIMITY_CHANNEL { \
435 .type = IIO_PROXIMITY, \
436 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
437 }
438
439 static const struct iio_chan_spec isl29018_channels[] = {
440 ISL29018_LIGHT_CHANNEL,
441 ISL29018_IR_CHANNEL,
442 ISL29018_PROXIMITY_CHANNEL,
443 };
444
445 static const struct iio_chan_spec isl29023_channels[] = {
446 ISL29018_LIGHT_CHANNEL,
447 ISL29018_IR_CHANNEL,
448 };
449
450 static IIO_DEVICE_ATTR(range, S_IRUGO | S_IWUSR, show_range, store_range, 0);
451 static IIO_CONST_ATTR(range_available, "1000 4000 16000 64000");
452 static IIO_CONST_ATTR(adc_resolution_available, "4 8 12 16");
453 static IIO_DEVICE_ATTR(adc_resolution, S_IRUGO | S_IWUSR,
454 show_resolution, store_resolution, 0);
455 static IIO_DEVICE_ATTR(proximity_on_chip_ambient_infrared_suppression,
456 S_IRUGO | S_IWUSR,
457 show_prox_infrared_suppression,
458 store_prox_infrared_suppression, 0);
459
460 #define ISL29018_DEV_ATTR(name) (&iio_dev_attr_##name.dev_attr.attr)
461 #define ISL29018_CONST_ATTR(name) (&iio_const_attr_##name.dev_attr.attr)
462 static struct attribute *isl29018_attributes[] = {
463 ISL29018_DEV_ATTR(range),
464 ISL29018_CONST_ATTR(range_available),
465 ISL29018_DEV_ATTR(adc_resolution),
466 ISL29018_CONST_ATTR(adc_resolution_available),
467 ISL29018_DEV_ATTR(proximity_on_chip_ambient_infrared_suppression),
468 NULL
469 };
470
471 static struct attribute *isl29023_attributes[] = {
472 ISL29018_DEV_ATTR(range),
473 ISL29018_CONST_ATTR(range_available),
474 ISL29018_DEV_ATTR(adc_resolution),
475 ISL29018_CONST_ATTR(adc_resolution_available),
476 NULL
477 };
478
479 static const struct attribute_group isl29018_group = {
480 .attrs = isl29018_attributes,
481 };
482
483 static const struct attribute_group isl29023_group = {
484 .attrs = isl29023_attributes,
485 };
486
isl29035_detect(struct isl29018_chip * chip)487 static int isl29035_detect(struct isl29018_chip *chip)
488 {
489 int status;
490 unsigned int id;
491
492 status = regmap_read(chip->regmap, ISL29035_REG_DEVICE_ID, &id);
493 if (status < 0) {
494 dev_err(chip->dev,
495 "Error reading ID register with error %d\n",
496 status);
497 return status;
498 }
499
500 id = (id & ISL29035_DEVICE_ID_MASK) >> ISL29035_DEVICE_ID_SHIFT;
501
502 if (id != ISL29035_DEVICE_ID)
503 return -ENODEV;
504
505 /* clear out brownout bit */
506 return regmap_update_bits(chip->regmap, ISL29035_REG_DEVICE_ID,
507 ISL29035_BOUT_MASK, 0);
508 }
509
510 enum {
511 isl29018,
512 isl29023,
513 isl29035,
514 };
515
isl29018_chip_init(struct isl29018_chip * chip)516 static int isl29018_chip_init(struct isl29018_chip *chip)
517 {
518 int status;
519 unsigned int new_adc_bit;
520 unsigned int new_range;
521
522 if (chip->type == isl29035) {
523 status = isl29035_detect(chip);
524 if (status < 0)
525 return status;
526 }
527
528 /* Code added per Intersil Application Note 1534:
529 * When VDD sinks to approximately 1.8V or below, some of
530 * the part's registers may change their state. When VDD
531 * recovers to 2.25V (or greater), the part may thus be in an
532 * unknown mode of operation. The user can return the part to
533 * a known mode of operation either by (a) setting VDD = 0V for
534 * 1 second or more and then powering back up with a slew rate
535 * of 0.5V/ms or greater, or (b) via I2C disable all ALS/PROX
536 * conversions, clear the test registers, and then rewrite all
537 * registers to the desired values.
538 * ...
539 * FOR ISL29011, ISL29018, ISL29021, ISL29023
540 * 1. Write 0x00 to register 0x08 (TEST)
541 * 2. Write 0x00 to register 0x00 (CMD1)
542 * 3. Rewrite all registers to the desired values
543 *
544 * ISL29018 Data Sheet (FN6619.1, Feb 11, 2010) essentially says
545 * the same thing EXCEPT the data sheet asks for a 1ms delay after
546 * writing the CMD1 register.
547 */
548 status = regmap_write(chip->regmap, ISL29018_REG_TEST, 0x0);
549 if (status < 0) {
550 dev_err(chip->dev, "Failed to clear isl29018 TEST reg.(%d)\n",
551 status);
552 return status;
553 }
554
555 /* See Intersil AN1534 comments above.
556 * "Operating Mode" (COMMAND1) register is reprogrammed when
557 * data is read from the device.
558 */
559 status = regmap_write(chip->regmap, ISL29018_REG_ADD_COMMAND1, 0);
560 if (status < 0) {
561 dev_err(chip->dev, "Failed to clear isl29018 CMD1 reg.(%d)\n",
562 status);
563 return status;
564 }
565
566 usleep_range(1000, 2000); /* per data sheet, page 10 */
567
568 /* set defaults */
569 status = isl29018_set_range(chip, chip->range, &new_range);
570 if (status < 0) {
571 dev_err(chip->dev, "Init of isl29018 fails\n");
572 return status;
573 }
574
575 status = isl29018_set_resolution(chip, chip->adc_bit,
576 &new_adc_bit);
577
578 return 0;
579 }
580
581 static const struct iio_info isl29018_info = {
582 .attrs = &isl29018_group,
583 .driver_module = THIS_MODULE,
584 .read_raw = &isl29018_read_raw,
585 .write_raw = &isl29018_write_raw,
586 };
587
588 static const struct iio_info isl29023_info = {
589 .attrs = &isl29023_group,
590 .driver_module = THIS_MODULE,
591 .read_raw = &isl29018_read_raw,
592 .write_raw = &isl29018_write_raw,
593 };
594
is_volatile_reg(struct device * dev,unsigned int reg)595 static bool is_volatile_reg(struct device *dev, unsigned int reg)
596 {
597 switch (reg) {
598 case ISL29018_REG_ADD_DATA_LSB:
599 case ISL29018_REG_ADD_DATA_MSB:
600 case ISL29018_REG_ADD_COMMAND1:
601 case ISL29018_REG_TEST:
602 case ISL29035_REG_DEVICE_ID:
603 return true;
604 default:
605 return false;
606 }
607 }
608
609 /*
610 * isl29018_regmap_config: regmap configuration.
611 * Use RBTREE mechanism for caching.
612 */
613 static const struct regmap_config isl29018_regmap_config = {
614 .reg_bits = 8,
615 .val_bits = 8,
616 .volatile_reg = is_volatile_reg,
617 .max_register = ISL29018_REG_TEST,
618 .num_reg_defaults_raw = ISL29018_REG_TEST + 1,
619 .cache_type = REGCACHE_RBTREE,
620 };
621
622 /* isl29035_regmap_config: regmap configuration for ISL29035 */
623 static const struct regmap_config isl29035_regmap_config = {
624 .reg_bits = 8,
625 .val_bits = 8,
626 .volatile_reg = is_volatile_reg,
627 .max_register = ISL29035_REG_DEVICE_ID,
628 .num_reg_defaults_raw = ISL29035_REG_DEVICE_ID + 1,
629 .cache_type = REGCACHE_RBTREE,
630 };
631
632 struct chip_info {
633 const struct iio_chan_spec *channels;
634 int num_channels;
635 const struct iio_info *indio_info;
636 const struct regmap_config *regmap_cfg;
637 };
638
639 static const struct chip_info chip_info_tbl[] = {
640 [isl29018] = {
641 .channels = isl29018_channels,
642 .num_channels = ARRAY_SIZE(isl29018_channels),
643 .indio_info = &isl29018_info,
644 .regmap_cfg = &isl29018_regmap_config,
645 },
646 [isl29023] = {
647 .channels = isl29023_channels,
648 .num_channels = ARRAY_SIZE(isl29023_channels),
649 .indio_info = &isl29023_info,
650 .regmap_cfg = &isl29018_regmap_config,
651 },
652 [isl29035] = {
653 .channels = isl29023_channels,
654 .num_channels = ARRAY_SIZE(isl29023_channels),
655 .indio_info = &isl29023_info,
656 .regmap_cfg = &isl29035_regmap_config,
657 },
658 };
659
isl29018_match_acpi_device(struct device * dev,int * data)660 static const char *isl29018_match_acpi_device(struct device *dev, int *data)
661 {
662 const struct acpi_device_id *id;
663
664 id = acpi_match_device(dev->driver->acpi_match_table, dev);
665
666 if (!id)
667 return NULL;
668
669 *data = (int) id->driver_data;
670
671 return dev_name(dev);
672 }
673
isl29018_probe(struct i2c_client * client,const struct i2c_device_id * id)674 static int isl29018_probe(struct i2c_client *client,
675 const struct i2c_device_id *id)
676 {
677 struct isl29018_chip *chip;
678 struct iio_dev *indio_dev;
679 int err;
680 const char *name = NULL;
681 int dev_id = 0;
682
683 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
684 if (indio_dev == NULL) {
685 dev_err(&client->dev, "iio allocation fails\n");
686 return -ENOMEM;
687 }
688 chip = iio_priv(indio_dev);
689
690 i2c_set_clientdata(client, indio_dev);
691 chip->dev = &client->dev;
692
693 if (id) {
694 name = id->name;
695 dev_id = id->driver_data;
696 }
697
698 if (ACPI_HANDLE(&client->dev))
699 name = isl29018_match_acpi_device(&client->dev, &dev_id);
700
701 mutex_init(&chip->lock);
702
703 chip->type = dev_id;
704 chip->lux_scale = 1;
705 chip->lux_uscale = 0;
706 chip->range = 1000;
707 chip->adc_bit = 16;
708 chip->suspended = false;
709
710 chip->regmap = devm_regmap_init_i2c(client,
711 chip_info_tbl[dev_id].regmap_cfg);
712 if (IS_ERR(chip->regmap)) {
713 err = PTR_ERR(chip->regmap);
714 dev_err(chip->dev, "regmap initialization failed: %d\n", err);
715 return err;
716 }
717
718 err = isl29018_chip_init(chip);
719 if (err)
720 return err;
721
722 indio_dev->info = chip_info_tbl[dev_id].indio_info;
723 indio_dev->channels = chip_info_tbl[dev_id].channels;
724 indio_dev->num_channels = chip_info_tbl[dev_id].num_channels;
725 indio_dev->name = name;
726 indio_dev->dev.parent = &client->dev;
727 indio_dev->modes = INDIO_DIRECT_MODE;
728 err = devm_iio_device_register(&client->dev, indio_dev);
729 if (err) {
730 dev_err(&client->dev, "iio registration fails\n");
731 return err;
732 }
733
734 return 0;
735 }
736
737 #ifdef CONFIG_PM_SLEEP
isl29018_suspend(struct device * dev)738 static int isl29018_suspend(struct device *dev)
739 {
740 struct isl29018_chip *chip = iio_priv(dev_get_drvdata(dev));
741
742 mutex_lock(&chip->lock);
743
744 /* Since this driver uses only polling commands, we are by default in
745 * auto shutdown (ie, power-down) mode.
746 * So we do not have much to do here.
747 */
748 chip->suspended = true;
749
750 mutex_unlock(&chip->lock);
751 return 0;
752 }
753
isl29018_resume(struct device * dev)754 static int isl29018_resume(struct device *dev)
755 {
756 struct isl29018_chip *chip = iio_priv(dev_get_drvdata(dev));
757 int err;
758
759 mutex_lock(&chip->lock);
760
761 err = isl29018_chip_init(chip);
762 if (!err)
763 chip->suspended = false;
764
765 mutex_unlock(&chip->lock);
766 return err;
767 }
768
769 static SIMPLE_DEV_PM_OPS(isl29018_pm_ops, isl29018_suspend, isl29018_resume);
770 #define ISL29018_PM_OPS (&isl29018_pm_ops)
771 #else
772 #define ISL29018_PM_OPS NULL
773 #endif
774
775 static const struct acpi_device_id isl29018_acpi_match[] = {
776 {"ISL29018", isl29018},
777 {"ISL29023", isl29023},
778 {"ISL29035", isl29035},
779 {},
780 };
781 MODULE_DEVICE_TABLE(acpi, isl29018_acpi_match);
782
783 static const struct i2c_device_id isl29018_id[] = {
784 {"isl29018", isl29018},
785 {"isl29023", isl29023},
786 {"isl29035", isl29035},
787 {}
788 };
789
790 MODULE_DEVICE_TABLE(i2c, isl29018_id);
791
792 static const struct of_device_id isl29018_of_match[] = {
793 { .compatible = "isil,isl29018", },
794 { .compatible = "isil,isl29023", },
795 { .compatible = "isil,isl29035", },
796 { },
797 };
798 MODULE_DEVICE_TABLE(of, isl29018_of_match);
799
800 static struct i2c_driver isl29018_driver = {
801 .class = I2C_CLASS_HWMON,
802 .driver = {
803 .name = "isl29018",
804 .acpi_match_table = ACPI_PTR(isl29018_acpi_match),
805 .pm = ISL29018_PM_OPS,
806 .owner = THIS_MODULE,
807 .of_match_table = isl29018_of_match,
808 },
809 .probe = isl29018_probe,
810 .id_table = isl29018_id,
811 };
812 module_i2c_driver(isl29018_driver);
813
814 MODULE_DESCRIPTION("ISL29018 Ambient Light Sensor driver");
815 MODULE_LICENSE("GPL");
816