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