1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * VEML6030 Ambient Light Sensor 4 * 5 * Copyright (c) 2019, Rishi Gupta <gupt21@gmail.com> 6 * 7 * Datasheet: https://www.vishay.com/docs/84366/veml6030.pdf 8 * Appnote-84367: https://www.vishay.com/docs/84367/designingveml6030.pdf 9 */ 10 11 #include <linux/module.h> 12 #include <linux/i2c.h> 13 #include <linux/err.h> 14 #include <linux/regmap.h> 15 #include <linux/interrupt.h> 16 #include <linux/pm_runtime.h> 17 #include <linux/iio/iio.h> 18 #include <linux/iio/sysfs.h> 19 #include <linux/iio/events.h> 20 21 /* Device registers */ 22 #define VEML6030_REG_ALS_CONF 0x00 23 #define VEML6030_REG_ALS_WH 0x01 24 #define VEML6030_REG_ALS_WL 0x02 25 #define VEML6030_REG_ALS_PSM 0x03 26 #define VEML6030_REG_ALS_DATA 0x04 27 #define VEML6030_REG_WH_DATA 0x05 28 #define VEML6030_REG_ALS_INT 0x06 29 30 /* Bit masks for specific functionality */ 31 #define VEML6030_ALS_IT GENMASK(9, 6) 32 #define VEML6030_PSM GENMASK(2, 1) 33 #define VEML6030_ALS_PERS GENMASK(5, 4) 34 #define VEML6030_ALS_GAIN GENMASK(12, 11) 35 #define VEML6030_PSM_EN BIT(0) 36 #define VEML6030_INT_TH_LOW BIT(15) 37 #define VEML6030_INT_TH_HIGH BIT(14) 38 #define VEML6030_ALS_INT_EN BIT(1) 39 #define VEML6030_ALS_SD BIT(0) 40 41 /* 42 * The resolution depends on both gain and integration time. The 43 * cur_resolution stores one of the resolution mentioned in the 44 * table during startup and gets updated whenever integration time 45 * or gain is changed. 46 * 47 * Table 'resolution and maximum detection range' in appnote 84367 48 * is visualized as a 2D array. The cur_gain stores index of gain 49 * in this table (0-3) while the cur_integration_time holds index 50 * of integration time (0-5). 51 */ 52 struct veml6030_data { 53 struct i2c_client *client; 54 struct regmap *regmap; 55 int cur_resolution; 56 int cur_gain; 57 int cur_integration_time; 58 }; 59 60 /* Integration time available in seconds */ 61 static IIO_CONST_ATTR(in_illuminance_integration_time_available, 62 "0.025 0.05 0.1 0.2 0.4 0.8"); 63 64 /* 65 * Scale is 1/gain. Value 0.125 is ALS gain x (1/8), 0.25 is 66 * ALS gain x (1/4), 1.0 = ALS gain x 1 and 2.0 is ALS gain x 2. 67 */ 68 static IIO_CONST_ATTR(in_illuminance_scale_available, 69 "0.125 0.25 1.0 2.0"); 70 71 static struct attribute *veml6030_attributes[] = { 72 &iio_const_attr_in_illuminance_integration_time_available.dev_attr.attr, 73 &iio_const_attr_in_illuminance_scale_available.dev_attr.attr, 74 NULL 75 }; 76 77 static const struct attribute_group veml6030_attr_group = { 78 .attrs = veml6030_attributes, 79 }; 80 81 /* 82 * Persistence = 1/2/4/8 x integration time 83 * Minimum time for which light readings must stay above configured 84 * threshold to assert the interrupt. 85 */ 86 static const char * const period_values[] = { 87 "0.1 0.2 0.4 0.8", 88 "0.2 0.4 0.8 1.6", 89 "0.4 0.8 1.6 3.2", 90 "0.8 1.6 3.2 6.4", 91 "0.05 0.1 0.2 0.4", 92 "0.025 0.050 0.1 0.2" 93 }; 94 95 /* 96 * Return list of valid period values in seconds corresponding to 97 * the currently active integration time. 98 */ 99 static ssize_t in_illuminance_period_available_show(struct device *dev, 100 struct device_attribute *attr, char *buf) 101 { 102 int ret, reg, x; 103 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 104 struct veml6030_data *data = iio_priv(indio_dev); 105 106 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®); 107 if (ret) { 108 dev_err(&data->client->dev, 109 "can't read als conf register %d\n", ret); 110 return ret; 111 } 112 113 ret = ((reg >> 6) & 0xF); 114 switch (ret) { 115 case 0: 116 case 1: 117 case 2: 118 case 3: 119 x = ret; 120 break; 121 case 8: 122 x = 4; 123 break; 124 case 12: 125 x = 5; 126 break; 127 default: 128 return -EINVAL; 129 } 130 131 return sysfs_emit(buf, "%s\n", period_values[x]); 132 } 133 134 static IIO_DEVICE_ATTR_RO(in_illuminance_period_available, 0); 135 136 static struct attribute *veml6030_event_attributes[] = { 137 &iio_dev_attr_in_illuminance_period_available.dev_attr.attr, 138 NULL 139 }; 140 141 static const struct attribute_group veml6030_event_attr_group = { 142 .attrs = veml6030_event_attributes, 143 }; 144 145 static int veml6030_als_pwr_on(struct veml6030_data *data) 146 { 147 return regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF, 148 VEML6030_ALS_SD, 0); 149 } 150 151 static int veml6030_als_shut_down(struct veml6030_data *data) 152 { 153 return regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF, 154 VEML6030_ALS_SD, 1); 155 } 156 157 static void veml6030_als_shut_down_action(void *data) 158 { 159 veml6030_als_shut_down(data); 160 } 161 162 static const struct iio_event_spec veml6030_event_spec[] = { 163 { 164 .type = IIO_EV_TYPE_THRESH, 165 .dir = IIO_EV_DIR_RISING, 166 .mask_separate = BIT(IIO_EV_INFO_VALUE), 167 }, { 168 .type = IIO_EV_TYPE_THRESH, 169 .dir = IIO_EV_DIR_FALLING, 170 .mask_separate = BIT(IIO_EV_INFO_VALUE), 171 }, { 172 .type = IIO_EV_TYPE_THRESH, 173 .dir = IIO_EV_DIR_EITHER, 174 .mask_separate = BIT(IIO_EV_INFO_PERIOD) | 175 BIT(IIO_EV_INFO_ENABLE), 176 }, 177 }; 178 179 /* Channel number */ 180 enum veml6030_chan { 181 CH_ALS, 182 CH_WHITE, 183 }; 184 185 static const struct iio_chan_spec veml6030_channels[] = { 186 { 187 .type = IIO_LIGHT, 188 .channel = CH_ALS, 189 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 190 BIT(IIO_CHAN_INFO_PROCESSED) | 191 BIT(IIO_CHAN_INFO_INT_TIME) | 192 BIT(IIO_CHAN_INFO_SCALE), 193 .event_spec = veml6030_event_spec, 194 .num_event_specs = ARRAY_SIZE(veml6030_event_spec), 195 }, 196 { 197 .type = IIO_INTENSITY, 198 .channel = CH_WHITE, 199 .modified = 1, 200 .channel2 = IIO_MOD_LIGHT_BOTH, 201 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 202 BIT(IIO_CHAN_INFO_PROCESSED), 203 }, 204 }; 205 206 static const struct regmap_config veml6030_regmap_config = { 207 .name = "veml6030_regmap", 208 .reg_bits = 8, 209 .val_bits = 16, 210 .max_register = VEML6030_REG_ALS_INT, 211 .val_format_endian = REGMAP_ENDIAN_LITTLE, 212 }; 213 214 static int veml6030_get_intgrn_tm(struct iio_dev *indio_dev, 215 int *val, int *val2) 216 { 217 int ret, reg; 218 struct veml6030_data *data = iio_priv(indio_dev); 219 220 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®); 221 if (ret) { 222 dev_err(&data->client->dev, 223 "can't read als conf register %d\n", ret); 224 return ret; 225 } 226 227 switch ((reg >> 6) & 0xF) { 228 case 0: 229 *val2 = 100000; 230 break; 231 case 1: 232 *val2 = 200000; 233 break; 234 case 2: 235 *val2 = 400000; 236 break; 237 case 3: 238 *val2 = 800000; 239 break; 240 case 8: 241 *val2 = 50000; 242 break; 243 case 12: 244 *val2 = 25000; 245 break; 246 default: 247 return -EINVAL; 248 } 249 250 *val = 0; 251 return IIO_VAL_INT_PLUS_MICRO; 252 } 253 254 static int veml6030_set_intgrn_tm(struct iio_dev *indio_dev, 255 int val, int val2) 256 { 257 int ret, new_int_time, int_idx; 258 struct veml6030_data *data = iio_priv(indio_dev); 259 260 if (val) 261 return -EINVAL; 262 263 switch (val2) { 264 case 25000: 265 new_int_time = 0x300; 266 int_idx = 5; 267 break; 268 case 50000: 269 new_int_time = 0x200; 270 int_idx = 4; 271 break; 272 case 100000: 273 new_int_time = 0x00; 274 int_idx = 3; 275 break; 276 case 200000: 277 new_int_time = 0x40; 278 int_idx = 2; 279 break; 280 case 400000: 281 new_int_time = 0x80; 282 int_idx = 1; 283 break; 284 case 800000: 285 new_int_time = 0xC0; 286 int_idx = 0; 287 break; 288 default: 289 return -EINVAL; 290 } 291 292 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF, 293 VEML6030_ALS_IT, new_int_time); 294 if (ret) { 295 dev_err(&data->client->dev, 296 "can't update als integration time %d\n", ret); 297 return ret; 298 } 299 300 /* 301 * Cache current integration time and update resolution. For every 302 * increase in integration time to next level, resolution is halved 303 * and vice-versa. 304 */ 305 if (data->cur_integration_time < int_idx) 306 data->cur_resolution <<= int_idx - data->cur_integration_time; 307 else if (data->cur_integration_time > int_idx) 308 data->cur_resolution >>= data->cur_integration_time - int_idx; 309 310 data->cur_integration_time = int_idx; 311 312 return ret; 313 } 314 315 static int veml6030_read_persistence(struct iio_dev *indio_dev, 316 int *val, int *val2) 317 { 318 int ret, reg, period, x, y; 319 struct veml6030_data *data = iio_priv(indio_dev); 320 321 ret = veml6030_get_intgrn_tm(indio_dev, &x, &y); 322 if (ret < 0) 323 return ret; 324 325 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®); 326 if (ret) { 327 dev_err(&data->client->dev, 328 "can't read als conf register %d\n", ret); 329 } 330 331 /* integration time multiplied by 1/2/4/8 */ 332 period = y * (1 << ((reg >> 4) & 0x03)); 333 334 *val = period / 1000000; 335 *val2 = period % 1000000; 336 337 return IIO_VAL_INT_PLUS_MICRO; 338 } 339 340 static int veml6030_write_persistence(struct iio_dev *indio_dev, 341 int val, int val2) 342 { 343 int ret, period, x, y; 344 struct veml6030_data *data = iio_priv(indio_dev); 345 346 ret = veml6030_get_intgrn_tm(indio_dev, &x, &y); 347 if (ret < 0) 348 return ret; 349 350 if (!val) { 351 period = val2 / y; 352 } else { 353 if ((val == 1) && (val2 == 600000)) 354 period = 1600000 / y; 355 else if ((val == 3) && (val2 == 200000)) 356 period = 3200000 / y; 357 else if ((val == 6) && (val2 == 400000)) 358 period = 6400000 / y; 359 else 360 period = -1; 361 } 362 363 if (period <= 0 || period > 8 || hweight8(period) != 1) 364 return -EINVAL; 365 366 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF, 367 VEML6030_ALS_PERS, (ffs(period) - 1) << 4); 368 if (ret) 369 dev_err(&data->client->dev, 370 "can't set persistence value %d\n", ret); 371 372 return ret; 373 } 374 375 static int veml6030_set_als_gain(struct iio_dev *indio_dev, 376 int val, int val2) 377 { 378 int ret, new_gain, gain_idx; 379 struct veml6030_data *data = iio_priv(indio_dev); 380 381 if (val == 0 && val2 == 125000) { 382 new_gain = 0x1000; /* 0x02 << 11 */ 383 gain_idx = 3; 384 } else if (val == 0 && val2 == 250000) { 385 new_gain = 0x1800; 386 gain_idx = 2; 387 } else if (val == 1 && val2 == 0) { 388 new_gain = 0x00; 389 gain_idx = 1; 390 } else if (val == 2 && val2 == 0) { 391 new_gain = 0x800; 392 gain_idx = 0; 393 } else { 394 return -EINVAL; 395 } 396 397 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF, 398 VEML6030_ALS_GAIN, new_gain); 399 if (ret) { 400 dev_err(&data->client->dev, 401 "can't set als gain %d\n", ret); 402 return ret; 403 } 404 405 /* 406 * Cache currently set gain & update resolution. For every 407 * increase in the gain to next level, resolution is halved 408 * and vice-versa. 409 */ 410 if (data->cur_gain < gain_idx) 411 data->cur_resolution <<= gain_idx - data->cur_gain; 412 else if (data->cur_gain > gain_idx) 413 data->cur_resolution >>= data->cur_gain - gain_idx; 414 415 data->cur_gain = gain_idx; 416 417 return ret; 418 } 419 420 static int veml6030_get_als_gain(struct iio_dev *indio_dev, 421 int *val, int *val2) 422 { 423 int ret, reg; 424 struct veml6030_data *data = iio_priv(indio_dev); 425 426 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®); 427 if (ret) { 428 dev_err(&data->client->dev, 429 "can't read als conf register %d\n", ret); 430 return ret; 431 } 432 433 switch ((reg >> 11) & 0x03) { 434 case 0: 435 *val = 1; 436 *val2 = 0; 437 break; 438 case 1: 439 *val = 2; 440 *val2 = 0; 441 break; 442 case 2: 443 *val = 0; 444 *val2 = 125000; 445 break; 446 case 3: 447 *val = 0; 448 *val2 = 250000; 449 break; 450 default: 451 return -EINVAL; 452 } 453 454 return IIO_VAL_INT_PLUS_MICRO; 455 } 456 457 static int veml6030_read_thresh(struct iio_dev *indio_dev, 458 int *val, int *val2, int dir) 459 { 460 int ret, reg; 461 struct veml6030_data *data = iio_priv(indio_dev); 462 463 if (dir == IIO_EV_DIR_RISING) 464 ret = regmap_read(data->regmap, VEML6030_REG_ALS_WH, ®); 465 else 466 ret = regmap_read(data->regmap, VEML6030_REG_ALS_WL, ®); 467 if (ret) { 468 dev_err(&data->client->dev, 469 "can't read als threshold value %d\n", ret); 470 return ret; 471 } 472 473 *val = reg & 0xffff; 474 return IIO_VAL_INT; 475 } 476 477 static int veml6030_write_thresh(struct iio_dev *indio_dev, 478 int val, int val2, int dir) 479 { 480 int ret; 481 struct veml6030_data *data = iio_priv(indio_dev); 482 483 if (val > 0xFFFF || val < 0 || val2) 484 return -EINVAL; 485 486 if (dir == IIO_EV_DIR_RISING) { 487 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, val); 488 if (ret) 489 dev_err(&data->client->dev, 490 "can't set high threshold %d\n", ret); 491 } else { 492 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, val); 493 if (ret) 494 dev_err(&data->client->dev, 495 "can't set low threshold %d\n", ret); 496 } 497 498 return ret; 499 } 500 501 /* 502 * Provide both raw as well as light reading in lux. 503 * light (in lux) = resolution * raw reading 504 */ 505 static int veml6030_read_raw(struct iio_dev *indio_dev, 506 struct iio_chan_spec const *chan, int *val, 507 int *val2, long mask) 508 { 509 int ret, reg; 510 struct veml6030_data *data = iio_priv(indio_dev); 511 struct regmap *regmap = data->regmap; 512 struct device *dev = &data->client->dev; 513 514 switch (mask) { 515 case IIO_CHAN_INFO_RAW: 516 case IIO_CHAN_INFO_PROCESSED: 517 switch (chan->type) { 518 case IIO_LIGHT: 519 ret = regmap_read(regmap, VEML6030_REG_ALS_DATA, ®); 520 if (ret < 0) { 521 dev_err(dev, "can't read als data %d\n", ret); 522 return ret; 523 } 524 if (mask == IIO_CHAN_INFO_PROCESSED) { 525 *val = (reg * data->cur_resolution) / 10000; 526 *val2 = (reg * data->cur_resolution) % 10000; 527 return IIO_VAL_INT_PLUS_MICRO; 528 } 529 *val = reg; 530 return IIO_VAL_INT; 531 case IIO_INTENSITY: 532 ret = regmap_read(regmap, VEML6030_REG_WH_DATA, ®); 533 if (ret < 0) { 534 dev_err(dev, "can't read white data %d\n", ret); 535 return ret; 536 } 537 if (mask == IIO_CHAN_INFO_PROCESSED) { 538 *val = (reg * data->cur_resolution) / 10000; 539 *val2 = (reg * data->cur_resolution) % 10000; 540 return IIO_VAL_INT_PLUS_MICRO; 541 } 542 *val = reg; 543 return IIO_VAL_INT; 544 default: 545 return -EINVAL; 546 } 547 case IIO_CHAN_INFO_INT_TIME: 548 if (chan->type == IIO_LIGHT) 549 return veml6030_get_intgrn_tm(indio_dev, val, val2); 550 return -EINVAL; 551 case IIO_CHAN_INFO_SCALE: 552 if (chan->type == IIO_LIGHT) 553 return veml6030_get_als_gain(indio_dev, val, val2); 554 return -EINVAL; 555 default: 556 return -EINVAL; 557 } 558 } 559 560 static int veml6030_write_raw(struct iio_dev *indio_dev, 561 struct iio_chan_spec const *chan, 562 int val, int val2, long mask) 563 { 564 switch (mask) { 565 case IIO_CHAN_INFO_INT_TIME: 566 switch (chan->type) { 567 case IIO_LIGHT: 568 return veml6030_set_intgrn_tm(indio_dev, val, val2); 569 default: 570 return -EINVAL; 571 } 572 case IIO_CHAN_INFO_SCALE: 573 switch (chan->type) { 574 case IIO_LIGHT: 575 return veml6030_set_als_gain(indio_dev, val, val2); 576 default: 577 return -EINVAL; 578 } 579 default: 580 return -EINVAL; 581 } 582 } 583 584 static int veml6030_read_event_val(struct iio_dev *indio_dev, 585 const struct iio_chan_spec *chan, enum iio_event_type type, 586 enum iio_event_direction dir, enum iio_event_info info, 587 int *val, int *val2) 588 { 589 switch (info) { 590 case IIO_EV_INFO_VALUE: 591 switch (dir) { 592 case IIO_EV_DIR_RISING: 593 case IIO_EV_DIR_FALLING: 594 return veml6030_read_thresh(indio_dev, val, val2, dir); 595 default: 596 return -EINVAL; 597 } 598 break; 599 case IIO_EV_INFO_PERIOD: 600 return veml6030_read_persistence(indio_dev, val, val2); 601 default: 602 return -EINVAL; 603 } 604 } 605 606 static int veml6030_write_event_val(struct iio_dev *indio_dev, 607 const struct iio_chan_spec *chan, enum iio_event_type type, 608 enum iio_event_direction dir, enum iio_event_info info, 609 int val, int val2) 610 { 611 switch (info) { 612 case IIO_EV_INFO_VALUE: 613 return veml6030_write_thresh(indio_dev, val, val2, dir); 614 case IIO_EV_INFO_PERIOD: 615 return veml6030_write_persistence(indio_dev, val, val2); 616 default: 617 return -EINVAL; 618 } 619 } 620 621 static int veml6030_read_interrupt_config(struct iio_dev *indio_dev, 622 const struct iio_chan_spec *chan, enum iio_event_type type, 623 enum iio_event_direction dir) 624 { 625 int ret, reg; 626 struct veml6030_data *data = iio_priv(indio_dev); 627 628 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®); 629 if (ret) { 630 dev_err(&data->client->dev, 631 "can't read als conf register %d\n", ret); 632 return ret; 633 } 634 635 if (reg & VEML6030_ALS_INT_EN) 636 return 1; 637 else 638 return 0; 639 } 640 641 /* 642 * Sensor should not be measuring light when interrupt is configured. 643 * Therefore correct sequence to configure interrupt functionality is: 644 * shut down -> enable/disable interrupt -> power on 645 * 646 * state = 1 enables interrupt, state = 0 disables interrupt 647 */ 648 static int veml6030_write_interrupt_config(struct iio_dev *indio_dev, 649 const struct iio_chan_spec *chan, enum iio_event_type type, 650 enum iio_event_direction dir, int state) 651 { 652 int ret; 653 struct veml6030_data *data = iio_priv(indio_dev); 654 655 if (state < 0 || state > 1) 656 return -EINVAL; 657 658 ret = veml6030_als_shut_down(data); 659 if (ret < 0) { 660 dev_err(&data->client->dev, 661 "can't disable als to configure interrupt %d\n", ret); 662 return ret; 663 } 664 665 /* enable interrupt + power on */ 666 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF, 667 VEML6030_ALS_INT_EN | VEML6030_ALS_SD, state << 1); 668 if (ret) 669 dev_err(&data->client->dev, 670 "can't enable interrupt & poweron als %d\n", ret); 671 672 return ret; 673 } 674 675 static const struct iio_info veml6030_info = { 676 .read_raw = veml6030_read_raw, 677 .write_raw = veml6030_write_raw, 678 .read_event_value = veml6030_read_event_val, 679 .write_event_value = veml6030_write_event_val, 680 .read_event_config = veml6030_read_interrupt_config, 681 .write_event_config = veml6030_write_interrupt_config, 682 .attrs = &veml6030_attr_group, 683 .event_attrs = &veml6030_event_attr_group, 684 }; 685 686 static const struct iio_info veml6030_info_no_irq = { 687 .read_raw = veml6030_read_raw, 688 .write_raw = veml6030_write_raw, 689 .attrs = &veml6030_attr_group, 690 }; 691 692 static irqreturn_t veml6030_event_handler(int irq, void *private) 693 { 694 int ret, reg, evtdir; 695 struct iio_dev *indio_dev = private; 696 struct veml6030_data *data = iio_priv(indio_dev); 697 698 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, ®); 699 if (ret) { 700 dev_err(&data->client->dev, 701 "can't read als interrupt register %d\n", ret); 702 return IRQ_HANDLED; 703 } 704 705 /* Spurious interrupt handling */ 706 if (!(reg & (VEML6030_INT_TH_HIGH | VEML6030_INT_TH_LOW))) 707 return IRQ_NONE; 708 709 if (reg & VEML6030_INT_TH_HIGH) 710 evtdir = IIO_EV_DIR_RISING; 711 else 712 evtdir = IIO_EV_DIR_FALLING; 713 714 iio_push_event(indio_dev, IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 715 0, IIO_EV_TYPE_THRESH, evtdir), 716 iio_get_time_ns(indio_dev)); 717 718 return IRQ_HANDLED; 719 } 720 721 /* 722 * Set ALS gain to 1/8, integration time to 100 ms, PSM to mode 2, 723 * persistence to 1 x integration time and the threshold 724 * interrupt disabled by default. First shutdown the sensor, 725 * update registers and then power on the sensor. 726 */ 727 static int veml6030_hw_init(struct iio_dev *indio_dev) 728 { 729 int ret, val; 730 struct veml6030_data *data = iio_priv(indio_dev); 731 struct i2c_client *client = data->client; 732 733 ret = veml6030_als_shut_down(data); 734 if (ret) { 735 dev_err(&client->dev, "can't shutdown als %d\n", ret); 736 return ret; 737 } 738 739 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 0x1001); 740 if (ret) { 741 dev_err(&client->dev, "can't setup als configs %d\n", ret); 742 return ret; 743 } 744 745 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM, 746 VEML6030_PSM | VEML6030_PSM_EN, 0x03); 747 if (ret) { 748 dev_err(&client->dev, "can't setup default PSM %d\n", ret); 749 return ret; 750 } 751 752 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF); 753 if (ret) { 754 dev_err(&client->dev, "can't setup high threshold %d\n", ret); 755 return ret; 756 } 757 758 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000); 759 if (ret) { 760 dev_err(&client->dev, "can't setup low threshold %d\n", ret); 761 return ret; 762 } 763 764 ret = veml6030_als_pwr_on(data); 765 if (ret) { 766 dev_err(&client->dev, "can't poweron als %d\n", ret); 767 return ret; 768 } 769 770 /* Wait 4 ms to let processor & oscillator start correctly */ 771 usleep_range(4000, 4002); 772 773 /* Clear stale interrupt status bits if any during start */ 774 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val); 775 if (ret < 0) { 776 dev_err(&client->dev, 777 "can't clear als interrupt status %d\n", ret); 778 return ret; 779 } 780 781 /* Cache currently active measurement parameters */ 782 data->cur_gain = 3; 783 data->cur_resolution = 4608; 784 data->cur_integration_time = 3; 785 786 return ret; 787 } 788 789 static int veml6030_probe(struct i2c_client *client, 790 const struct i2c_device_id *id) 791 { 792 int ret; 793 struct veml6030_data *data; 794 struct iio_dev *indio_dev; 795 struct regmap *regmap; 796 797 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 798 dev_err(&client->dev, "i2c adapter doesn't support plain i2c\n"); 799 return -EOPNOTSUPP; 800 } 801 802 regmap = devm_regmap_init_i2c(client, &veml6030_regmap_config); 803 if (IS_ERR(regmap)) { 804 dev_err(&client->dev, "can't setup regmap\n"); 805 return PTR_ERR(regmap); 806 } 807 808 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 809 if (!indio_dev) 810 return -ENOMEM; 811 812 data = iio_priv(indio_dev); 813 i2c_set_clientdata(client, indio_dev); 814 data->client = client; 815 data->regmap = regmap; 816 817 indio_dev->name = "veml6030"; 818 indio_dev->channels = veml6030_channels; 819 indio_dev->num_channels = ARRAY_SIZE(veml6030_channels); 820 indio_dev->modes = INDIO_DIRECT_MODE; 821 822 if (client->irq) { 823 ret = devm_request_threaded_irq(&client->dev, client->irq, 824 NULL, veml6030_event_handler, 825 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 826 "veml6030", indio_dev); 827 if (ret < 0) { 828 dev_err(&client->dev, 829 "irq %d request failed\n", client->irq); 830 return ret; 831 } 832 indio_dev->info = &veml6030_info; 833 } else { 834 indio_dev->info = &veml6030_info_no_irq; 835 } 836 837 ret = veml6030_hw_init(indio_dev); 838 if (ret < 0) 839 return ret; 840 841 ret = devm_add_action_or_reset(&client->dev, 842 veml6030_als_shut_down_action, data); 843 if (ret < 0) 844 return ret; 845 846 return devm_iio_device_register(&client->dev, indio_dev); 847 } 848 849 static int __maybe_unused veml6030_runtime_suspend(struct device *dev) 850 { 851 int ret; 852 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 853 struct veml6030_data *data = iio_priv(indio_dev); 854 855 ret = veml6030_als_shut_down(data); 856 if (ret < 0) 857 dev_err(&data->client->dev, "can't suspend als %d\n", ret); 858 859 return ret; 860 } 861 862 static int __maybe_unused veml6030_runtime_resume(struct device *dev) 863 { 864 int ret; 865 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 866 struct veml6030_data *data = iio_priv(indio_dev); 867 868 ret = veml6030_als_pwr_on(data); 869 if (ret < 0) 870 dev_err(&data->client->dev, "can't resume als %d\n", ret); 871 872 return ret; 873 } 874 875 static const struct dev_pm_ops veml6030_pm_ops = { 876 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 877 pm_runtime_force_resume) 878 SET_RUNTIME_PM_OPS(veml6030_runtime_suspend, 879 veml6030_runtime_resume, NULL) 880 }; 881 882 static const struct of_device_id veml6030_of_match[] = { 883 { .compatible = "vishay,veml6030" }, 884 { } 885 }; 886 MODULE_DEVICE_TABLE(of, veml6030_of_match); 887 888 static const struct i2c_device_id veml6030_id[] = { 889 { "veml6030", 0 }, 890 { } 891 }; 892 MODULE_DEVICE_TABLE(i2c, veml6030_id); 893 894 static struct i2c_driver veml6030_driver = { 895 .driver = { 896 .name = "veml6030", 897 .of_match_table = veml6030_of_match, 898 .pm = &veml6030_pm_ops, 899 }, 900 .probe = veml6030_probe, 901 .id_table = veml6030_id, 902 }; 903 module_i2c_driver(veml6030_driver); 904 905 MODULE_AUTHOR("Rishi Gupta <gupt21@gmail.com>"); 906 MODULE_DESCRIPTION("VEML6030 Ambient Light Sensor"); 907 MODULE_LICENSE("GPL v2"); 908