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 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 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 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 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 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 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 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 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 */ 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 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 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 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 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 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 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 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 714 static int isl29018_probe(struct i2c_client *client, 715 const struct i2c_device_id *id) 716 { 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 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 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