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