Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/staging/iio/light/isl29018.c

  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 
 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 
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 
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 
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 
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 
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 */
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 
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 */
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 
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 */
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 
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 */
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 
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 
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 
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 
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 
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 
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
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 
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 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us