1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * VEML6030, VMEL6035 and VEML7700 Ambient Light Sensors 4 * 5 * Copyright (c) 2019, Rishi Gupta <gupt21@gmail.com> 6 * 7 * VEML6030: 8 * Datasheet: https://www.vishay.com/docs/84366/veml6030.pdf 9 * Appnote-84367: https://www.vishay.com/docs/84367/designingveml6030.pdf 10 * 11 * VEML6035: 12 * Datasheet: https://www.vishay.com/docs/84889/veml6035.pdf 13 * Appnote-84944: https://www.vishay.com/docs/84944/designingveml6035.pdf 14 * 15 * VEML7700: 16 * Datasheet: https://www.vishay.com/docs/84286/veml7700.pdf 17 * Appnote-84323: https://www.vishay.com/docs/84323/designingveml7700.pdf 18 */ 19 20 #include <linux/bitfield.h> 21 #include <linux/module.h> 22 #include <linux/i2c.h> 23 #include <linux/err.h> 24 #include <linux/regmap.h> 25 #include <linux/interrupt.h> 26 #include <linux/pm_runtime.h> 27 #include <linux/units.h> 28 #include <linux/regulator/consumer.h> 29 #include <linux/iio/iio.h> 30 #include <linux/iio/sysfs.h> 31 #include <linux/iio/events.h> 32 #include <linux/iio/iio-gts-helper.h> 33 #include <linux/iio/trigger_consumer.h> 34 #include <linux/iio/triggered_buffer.h> 35 36 /* Device registers */ 37 #define VEML6030_REG_ALS_CONF 0x00 38 #define VEML6030_REG_ALS_WH 0x01 39 #define VEML6030_REG_ALS_WL 0x02 40 #define VEML6030_REG_ALS_PSM 0x03 41 #define VEML6030_REG_ALS_DATA 0x04 42 #define VEML6030_REG_WH_DATA 0x05 43 #define VEML6030_REG_ALS_INT 0x06 44 #define VEML6030_REG_DATA(ch) (VEML6030_REG_ALS_DATA + (ch)) 45 46 /* Bit masks for specific functionality */ 47 #define VEML6030_ALS_IT GENMASK(9, 6) 48 #define VEML6030_PSM GENMASK(2, 1) 49 #define VEML6030_ALS_PERS GENMASK(5, 4) 50 #define VEML6030_ALS_GAIN GENMASK(12, 11) 51 #define VEML6030_PSM_EN BIT(0) 52 #define VEML6030_INT_TH_LOW BIT(15) 53 #define VEML6030_INT_TH_HIGH BIT(14) 54 #define VEML6030_ALS_INT_EN BIT(1) 55 #define VEML6030_ALS_SD BIT(0) 56 57 #define VEML6035_GAIN_M GENMASK(12, 10) 58 #define VEML6035_GAIN BIT(10) 59 #define VEML6035_DG BIT(11) 60 #define VEML6035_SENS BIT(12) 61 #define VEML6035_INT_CHAN BIT(3) 62 #define VEML6035_CHAN_EN BIT(2) 63 64 /* Regfields */ 65 #define VEML6030_GAIN_RF REG_FIELD(VEML6030_REG_ALS_CONF, 11, 12) 66 #define VEML6030_IT_RF REG_FIELD(VEML6030_REG_ALS_CONF, 6, 9) 67 68 #define VEML6035_GAIN_RF REG_FIELD(VEML6030_REG_ALS_CONF, 10, 12) 69 70 /* Maximum scales x 10000 to work with integers */ 71 #define VEML6030_MAX_SCALE 21504 72 #define VEML6035_MAX_SCALE 4096 73 74 enum veml6030_scan { 75 VEML6030_SCAN_ALS, 76 VEML6030_SCAN_WH, 77 VEML6030_SCAN_TIMESTAMP, 78 }; 79 80 struct veml6030_rf { 81 struct regmap_field *it; 82 struct regmap_field *gain; 83 }; 84 85 struct veml603x_chip { 86 const char *name; 87 const struct iio_chan_spec *channels; 88 const int num_channels; 89 const struct reg_field gain_rf; 90 const struct reg_field it_rf; 91 const int max_scale; 92 int (*hw_init)(struct iio_dev *indio_dev, struct device *dev); 93 int (*set_info)(struct iio_dev *indio_dev); 94 }; 95 96 /* 97 * The resolution depends on both gain and integration time. The 98 * cur_resolution stores one of the resolution mentioned in the 99 * table during startup and gets updated whenever integration time 100 * or gain is changed. 101 * 102 * Table 'resolution and maximum detection range' in the appnotes 103 * is visualized as a 2D array. The cur_gain stores index of gain 104 * in this table (0-3 for VEML6030, 0-5 for VEML6035) while the 105 * cur_integration_time holds index of integration time (0-5). 106 */ 107 struct veml6030_data { 108 struct i2c_client *client; 109 struct regmap *regmap; 110 struct veml6030_rf rf; 111 const struct veml603x_chip *chip; 112 struct iio_gts gts; 113 114 }; 115 116 #define VEML6030_SEL_IT_25MS 0x0C 117 #define VEML6030_SEL_IT_50MS 0x08 118 #define VEML6030_SEL_IT_100MS 0x00 119 #define VEML6030_SEL_IT_200MS 0x01 120 #define VEML6030_SEL_IT_400MS 0x02 121 #define VEML6030_SEL_IT_800MS 0x03 122 static const struct iio_itime_sel_mul veml6030_it_sel[] = { 123 GAIN_SCALE_ITIME_US(25000, VEML6030_SEL_IT_25MS, 1), 124 GAIN_SCALE_ITIME_US(50000, VEML6030_SEL_IT_50MS, 2), 125 GAIN_SCALE_ITIME_US(100000, VEML6030_SEL_IT_100MS, 4), 126 GAIN_SCALE_ITIME_US(200000, VEML6030_SEL_IT_200MS, 8), 127 GAIN_SCALE_ITIME_US(400000, VEML6030_SEL_IT_400MS, 16), 128 GAIN_SCALE_ITIME_US(800000, VEML6030_SEL_IT_800MS, 32), 129 }; 130 131 /* Gains are multiplied by 8 to work with integers. The values in the 132 * iio-gts tables don't need corrections because the maximum value of 133 * the scale refers to GAIN = x1, and the rest of the values are 134 * obtained from the resulting linear function. 135 */ 136 #define VEML6030_SEL_MILLI_GAIN_X125 2 137 #define VEML6030_SEL_MILLI_GAIN_X250 3 138 #define VEML6030_SEL_MILLI_GAIN_X1000 0 139 #define VEML6030_SEL_MILLI_GAIN_X2000 1 140 static const struct iio_gain_sel_pair veml6030_gain_sel[] = { 141 GAIN_SCALE_GAIN(1, VEML6030_SEL_MILLI_GAIN_X125), 142 GAIN_SCALE_GAIN(2, VEML6030_SEL_MILLI_GAIN_X250), 143 GAIN_SCALE_GAIN(8, VEML6030_SEL_MILLI_GAIN_X1000), 144 GAIN_SCALE_GAIN(16, VEML6030_SEL_MILLI_GAIN_X2000), 145 }; 146 147 #define VEML6035_SEL_MILLI_GAIN_X125 4 148 #define VEML6035_SEL_MILLI_GAIN_X250 5 149 #define VEML6035_SEL_MILLI_GAIN_X500 7 150 #define VEML6035_SEL_MILLI_GAIN_X1000 0 151 #define VEML6035_SEL_MILLI_GAIN_X2000 1 152 #define VEML6035_SEL_MILLI_GAIN_X4000 3 153 static const struct iio_gain_sel_pair veml6035_gain_sel[] = { 154 GAIN_SCALE_GAIN(1, VEML6035_SEL_MILLI_GAIN_X125), 155 GAIN_SCALE_GAIN(2, VEML6035_SEL_MILLI_GAIN_X250), 156 GAIN_SCALE_GAIN(4, VEML6035_SEL_MILLI_GAIN_X500), 157 GAIN_SCALE_GAIN(8, VEML6035_SEL_MILLI_GAIN_X1000), 158 GAIN_SCALE_GAIN(16, VEML6035_SEL_MILLI_GAIN_X2000), 159 GAIN_SCALE_GAIN(32, VEML6035_SEL_MILLI_GAIN_X4000), 160 }; 161 162 /* 163 * Persistence = 1/2/4/8 x integration time 164 * Minimum time for which light readings must stay above configured 165 * threshold to assert the interrupt. 166 */ 167 static const char * const period_values[] = { 168 "0.1 0.2 0.4 0.8", 169 "0.2 0.4 0.8 1.6", 170 "0.4 0.8 1.6 3.2", 171 "0.8 1.6 3.2 6.4", 172 "0.05 0.1 0.2 0.4", 173 "0.025 0.050 0.1 0.2" 174 }; 175 176 /* 177 * Return list of valid period values in seconds corresponding to 178 * the currently active integration time. 179 */ 180 static ssize_t in_illuminance_period_available_show(struct device *dev, 181 struct device_attribute *attr, char *buf) 182 { 183 struct veml6030_data *data = iio_priv(dev_to_iio_dev(dev)); 184 int ret, reg, x; 185 186 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®); 187 if (ret) { 188 dev_err(&data->client->dev, 189 "can't read als conf register %d\n", ret); 190 return ret; 191 } 192 193 ret = ((reg >> 6) & 0xF); 194 switch (ret) { 195 case 0: 196 case 1: 197 case 2: 198 case 3: 199 x = ret; 200 break; 201 case 8: 202 x = 4; 203 break; 204 case 12: 205 x = 5; 206 break; 207 default: 208 return -EINVAL; 209 } 210 211 return sysfs_emit(buf, "%s\n", period_values[x]); 212 } 213 214 static IIO_DEVICE_ATTR_RO(in_illuminance_period_available, 0); 215 216 static struct attribute *veml6030_event_attributes[] = { 217 &iio_dev_attr_in_illuminance_period_available.dev_attr.attr, 218 NULL 219 }; 220 221 static const struct attribute_group veml6030_event_attr_group = { 222 .attrs = veml6030_event_attributes, 223 }; 224 225 static int veml6030_als_pwr_on(struct veml6030_data *data) 226 { 227 int ret; 228 229 ret = regmap_clear_bits(data->regmap, VEML6030_REG_ALS_CONF, 230 VEML6030_ALS_SD); 231 if (ret) 232 return ret; 233 234 /* Wait 4 ms to let processor & oscillator start correctly */ 235 fsleep(4000); 236 237 return 0; 238 } 239 240 static int veml6030_als_shut_down(struct veml6030_data *data) 241 { 242 return regmap_set_bits(data->regmap, VEML6030_REG_ALS_CONF, 243 VEML6030_ALS_SD); 244 } 245 246 static void veml6030_als_shut_down_action(void *data) 247 { 248 veml6030_als_shut_down(data); 249 } 250 251 static const struct iio_event_spec veml6030_event_spec[] = { 252 { 253 .type = IIO_EV_TYPE_THRESH, 254 .dir = IIO_EV_DIR_RISING, 255 .mask_separate = BIT(IIO_EV_INFO_VALUE), 256 }, { 257 .type = IIO_EV_TYPE_THRESH, 258 .dir = IIO_EV_DIR_FALLING, 259 .mask_separate = BIT(IIO_EV_INFO_VALUE), 260 }, { 261 .type = IIO_EV_TYPE_THRESH, 262 .dir = IIO_EV_DIR_EITHER, 263 .mask_separate = BIT(IIO_EV_INFO_PERIOD) | 264 BIT(IIO_EV_INFO_ENABLE), 265 }, 266 }; 267 268 /* Channel number */ 269 enum veml6030_chan { 270 CH_ALS, 271 CH_WHITE, 272 }; 273 274 static const struct iio_chan_spec veml6030_channels[] = { 275 { 276 .type = IIO_LIGHT, 277 .channel = CH_ALS, 278 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 279 BIT(IIO_CHAN_INFO_PROCESSED) | 280 BIT(IIO_CHAN_INFO_INT_TIME) | 281 BIT(IIO_CHAN_INFO_SCALE), 282 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) | 283 BIT(IIO_CHAN_INFO_SCALE), 284 .event_spec = veml6030_event_spec, 285 .num_event_specs = ARRAY_SIZE(veml6030_event_spec), 286 .scan_index = VEML6030_SCAN_ALS, 287 .scan_type = { 288 .sign = 'u', 289 .realbits = 16, 290 .storagebits = 16, 291 .endianness = IIO_CPU, 292 }, 293 }, 294 { 295 .type = IIO_INTENSITY, 296 .channel = CH_WHITE, 297 .modified = 1, 298 .channel2 = IIO_MOD_LIGHT_BOTH, 299 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 300 BIT(IIO_CHAN_INFO_INT_TIME) | 301 BIT(IIO_CHAN_INFO_SCALE), 302 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) | 303 BIT(IIO_CHAN_INFO_SCALE), 304 .scan_index = VEML6030_SCAN_WH, 305 .scan_type = { 306 .sign = 'u', 307 .realbits = 16, 308 .storagebits = 16, 309 .endianness = IIO_CPU, 310 }, 311 }, 312 IIO_CHAN_SOFT_TIMESTAMP(VEML6030_SCAN_TIMESTAMP), 313 }; 314 315 static const struct iio_chan_spec veml7700_channels[] = { 316 { 317 .type = IIO_LIGHT, 318 .channel = CH_ALS, 319 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 320 BIT(IIO_CHAN_INFO_PROCESSED) | 321 BIT(IIO_CHAN_INFO_INT_TIME) | 322 BIT(IIO_CHAN_INFO_SCALE), 323 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) | 324 BIT(IIO_CHAN_INFO_SCALE), 325 .scan_index = VEML6030_SCAN_ALS, 326 .scan_type = { 327 .sign = 'u', 328 .realbits = 16, 329 .storagebits = 16, 330 .endianness = IIO_CPU, 331 }, 332 }, 333 { 334 .type = IIO_INTENSITY, 335 .channel = CH_WHITE, 336 .modified = 1, 337 .channel2 = IIO_MOD_LIGHT_BOTH, 338 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 339 BIT(IIO_CHAN_INFO_INT_TIME) | 340 BIT(IIO_CHAN_INFO_SCALE), 341 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) | 342 BIT(IIO_CHAN_INFO_SCALE), 343 .scan_index = VEML6030_SCAN_WH, 344 .scan_type = { 345 .sign = 'u', 346 .realbits = 16, 347 .storagebits = 16, 348 .endianness = IIO_CPU, 349 }, 350 }, 351 IIO_CHAN_SOFT_TIMESTAMP(VEML6030_SCAN_TIMESTAMP), 352 }; 353 354 static const struct regmap_range veml6030_readable_ranges[] = { 355 regmap_reg_range(VEML6030_REG_ALS_CONF, VEML6030_REG_ALS_INT), 356 }; 357 358 static const struct regmap_access_table veml6030_readable_table = { 359 .yes_ranges = veml6030_readable_ranges, 360 .n_yes_ranges = ARRAY_SIZE(veml6030_readable_ranges), 361 }; 362 363 static const struct regmap_range veml6030_writable_ranges[] = { 364 regmap_reg_range(VEML6030_REG_ALS_CONF, VEML6030_REG_ALS_PSM), 365 }; 366 367 static const struct regmap_access_table veml6030_writable_table = { 368 .yes_ranges = veml6030_writable_ranges, 369 .n_yes_ranges = ARRAY_SIZE(veml6030_writable_ranges), 370 }; 371 372 static const struct regmap_range veml6030_volatile_ranges[] = { 373 regmap_reg_range(VEML6030_REG_ALS_DATA, VEML6030_REG_WH_DATA), 374 }; 375 376 static const struct regmap_access_table veml6030_volatile_table = { 377 .yes_ranges = veml6030_volatile_ranges, 378 .n_yes_ranges = ARRAY_SIZE(veml6030_volatile_ranges), 379 }; 380 381 static const struct regmap_config veml6030_regmap_config = { 382 .name = "veml6030_regmap", 383 .reg_bits = 8, 384 .val_bits = 16, 385 .max_register = VEML6030_REG_ALS_INT, 386 .val_format_endian = REGMAP_ENDIAN_LITTLE, 387 .rd_table = &veml6030_readable_table, 388 .wr_table = &veml6030_writable_table, 389 .volatile_table = &veml6030_volatile_table, 390 .cache_type = REGCACHE_RBTREE, 391 }; 392 393 static int veml6030_get_it(struct veml6030_data *data, int *val, int *val2) 394 { 395 int ret, it_idx; 396 397 ret = regmap_field_read(data->rf.it, &it_idx); 398 if (ret) 399 return ret; 400 401 ret = iio_gts_find_int_time_by_sel(&data->gts, it_idx); 402 if (ret < 0) 403 return ret; 404 405 *val2 = ret; 406 *val = 0; 407 408 return IIO_VAL_INT_PLUS_MICRO; 409 } 410 411 static int veml6030_set_it(struct iio_dev *indio_dev, int val, int val2) 412 { 413 struct veml6030_data *data = iio_priv(indio_dev); 414 int ret, gain_idx, it_idx, new_gain, prev_gain, prev_it; 415 bool in_range; 416 417 if (val || !iio_gts_valid_time(&data->gts, val2)) 418 return -EINVAL; 419 420 ret = regmap_field_read(data->rf.it, &it_idx); 421 if (ret) 422 return ret; 423 424 ret = regmap_field_read(data->rf.gain, &gain_idx); 425 if (ret) 426 return ret; 427 428 prev_it = iio_gts_find_int_time_by_sel(&data->gts, it_idx); 429 if (prev_it < 0) 430 return prev_it; 431 432 if (prev_it == val2) 433 return 0; 434 435 prev_gain = iio_gts_find_gain_by_sel(&data->gts, gain_idx); 436 if (prev_gain < 0) 437 return prev_gain; 438 439 ret = iio_gts_find_new_gain_by_gain_time_min(&data->gts, prev_gain, prev_it, 440 val2, &new_gain, &in_range); 441 if (ret) 442 return ret; 443 444 if (!in_range) 445 dev_dbg(&data->client->dev, "Optimal gain out of range\n"); 446 447 ret = iio_gts_find_sel_by_int_time(&data->gts, val2); 448 if (ret < 0) 449 return ret; 450 451 ret = regmap_field_write(data->rf.it, ret); 452 if (ret) 453 return ret; 454 455 ret = iio_gts_find_sel_by_gain(&data->gts, new_gain); 456 if (ret < 0) 457 return ret; 458 459 return regmap_field_write(data->rf.gain, ret); 460 } 461 462 static int veml6030_read_persistence(struct iio_dev *indio_dev, 463 int *val, int *val2) 464 { 465 int ret, reg, period, x, y; 466 struct veml6030_data *data = iio_priv(indio_dev); 467 468 ret = veml6030_get_it(data, &x, &y); 469 if (ret < 0) 470 return ret; 471 472 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®); 473 if (ret) { 474 dev_err(&data->client->dev, 475 "can't read als conf register %d\n", ret); 476 } 477 478 /* integration time multiplied by 1/2/4/8 */ 479 period = y * (1 << ((reg >> 4) & 0x03)); 480 481 *val = period / 1000000; 482 *val2 = period % 1000000; 483 484 return IIO_VAL_INT_PLUS_MICRO; 485 } 486 487 static int veml6030_write_persistence(struct iio_dev *indio_dev, 488 int val, int val2) 489 { 490 int ret, period, x, y; 491 struct veml6030_data *data = iio_priv(indio_dev); 492 493 ret = veml6030_get_it(data, &x, &y); 494 if (ret < 0) 495 return ret; 496 497 if (!val) { 498 period = val2 / y; 499 } else { 500 if ((val == 1) && (val2 == 600000)) 501 period = 1600000 / y; 502 else if ((val == 3) && (val2 == 200000)) 503 period = 3200000 / y; 504 else if ((val == 6) && (val2 == 400000)) 505 period = 6400000 / y; 506 else 507 period = -1; 508 } 509 510 if (period <= 0 || period > 8 || hweight8(period) != 1) 511 return -EINVAL; 512 513 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF, 514 VEML6030_ALS_PERS, (ffs(period) - 1) << 4); 515 if (ret) 516 dev_err(&data->client->dev, 517 "can't set persistence value %d\n", ret); 518 519 return ret; 520 } 521 522 static int veml6030_set_scale(struct iio_dev *indio_dev, int val, int val2) 523 { 524 int ret, gain_sel, it_sel; 525 struct veml6030_data *data = iio_priv(indio_dev); 526 527 ret = iio_gts_find_gain_time_sel_for_scale(&data->gts, val, val2, 528 &gain_sel, &it_sel); 529 if (ret) 530 return ret; 531 532 ret = regmap_field_write(data->rf.it, it_sel); 533 if (ret) 534 return ret; 535 536 ret = regmap_field_write(data->rf.gain, gain_sel); 537 if (ret) 538 return ret; 539 540 return 0; 541 } 542 543 static int veml6030_read_thresh(struct iio_dev *indio_dev, 544 int *val, int *val2, int dir) 545 { 546 int ret, reg; 547 struct veml6030_data *data = iio_priv(indio_dev); 548 549 if (dir == IIO_EV_DIR_RISING) 550 ret = regmap_read(data->regmap, VEML6030_REG_ALS_WH, ®); 551 else 552 ret = regmap_read(data->regmap, VEML6030_REG_ALS_WL, ®); 553 if (ret) { 554 dev_err(&data->client->dev, 555 "can't read als threshold value %d\n", ret); 556 return ret; 557 } 558 559 *val = reg & 0xffff; 560 return IIO_VAL_INT; 561 } 562 563 static int veml6030_write_thresh(struct iio_dev *indio_dev, 564 int val, int val2, int dir) 565 { 566 int ret; 567 struct veml6030_data *data = iio_priv(indio_dev); 568 569 if (val > 0xFFFF || val < 0 || val2) 570 return -EINVAL; 571 572 if (dir == IIO_EV_DIR_RISING) { 573 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, val); 574 if (ret) 575 dev_err(&data->client->dev, 576 "can't set high threshold %d\n", ret); 577 } else { 578 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, val); 579 if (ret) 580 dev_err(&data->client->dev, 581 "can't set low threshold %d\n", ret); 582 } 583 584 return ret; 585 } 586 587 static int veml6030_get_total_gain(struct veml6030_data *data) 588 { 589 int gain, it, reg, ret; 590 591 ret = regmap_field_read(data->rf.gain, ®); 592 if (ret) 593 return ret; 594 595 gain = iio_gts_find_gain_by_sel(&data->gts, reg); 596 if (gain < 0) 597 return gain; 598 599 ret = regmap_field_read(data->rf.it, ®); 600 if (ret) 601 return ret; 602 603 it = iio_gts_find_int_time_by_sel(&data->gts, reg); 604 if (it < 0) 605 return it; 606 607 return iio_gts_get_total_gain(&data->gts, gain, it); 608 } 609 610 static int veml6030_get_scale(struct veml6030_data *data, int *val, int *val2) 611 { 612 int gain, it, reg, ret; 613 614 ret = regmap_field_read(data->rf.gain, ®); 615 if (ret) 616 return ret; 617 618 gain = iio_gts_find_gain_by_sel(&data->gts, reg); 619 if (gain < 0) 620 return gain; 621 622 ret = regmap_field_read(data->rf.it, ®); 623 if (ret) 624 return ret; 625 626 it = iio_gts_find_int_time_by_sel(&data->gts, reg); 627 if (it < 0) 628 return it; 629 630 ret = iio_gts_get_scale(&data->gts, gain, it, val, val2); 631 if (ret) 632 return ret; 633 634 return IIO_VAL_INT_PLUS_NANO; 635 } 636 637 static int veml6030_process_als(struct veml6030_data *data, int raw, 638 int *val, int *val2) 639 { 640 int total_gain; 641 642 total_gain = veml6030_get_total_gain(data); 643 if (total_gain < 0) 644 return total_gain; 645 646 *val = raw * data->chip->max_scale / total_gain / 10000; 647 *val2 = raw * data->chip->max_scale / total_gain % 10000 * 100; 648 649 return IIO_VAL_INT_PLUS_MICRO; 650 } 651 652 /* 653 * Provide both raw as well as light reading in lux. 654 * light (in lux) = resolution * raw reading 655 */ 656 static int veml6030_read_raw(struct iio_dev *indio_dev, 657 struct iio_chan_spec const *chan, int *val, 658 int *val2, long mask) 659 { 660 int ret, reg; 661 struct veml6030_data *data = iio_priv(indio_dev); 662 struct regmap *regmap = data->regmap; 663 struct device *dev = &data->client->dev; 664 665 switch (mask) { 666 case IIO_CHAN_INFO_RAW: 667 case IIO_CHAN_INFO_PROCESSED: 668 switch (chan->type) { 669 case IIO_LIGHT: 670 ret = regmap_read(regmap, VEML6030_REG_ALS_DATA, ®); 671 if (ret < 0) { 672 dev_err(dev, "can't read als data %d\n", ret); 673 return ret; 674 } 675 if (mask == IIO_CHAN_INFO_PROCESSED) 676 return veml6030_process_als(data, reg, val, val2); 677 678 *val = reg; 679 return IIO_VAL_INT; 680 case IIO_INTENSITY: 681 ret = regmap_read(regmap, VEML6030_REG_WH_DATA, ®); 682 if (ret < 0) { 683 dev_err(dev, "can't read white data %d\n", ret); 684 return ret; 685 } 686 *val = reg; 687 return IIO_VAL_INT; 688 default: 689 return -EINVAL; 690 } 691 case IIO_CHAN_INFO_INT_TIME: 692 return veml6030_get_it(data, val, val2); 693 case IIO_CHAN_INFO_SCALE: 694 return veml6030_get_scale(data, val, val2); 695 default: 696 return -EINVAL; 697 } 698 } 699 700 static int veml6030_read_avail(struct iio_dev *indio_dev, 701 struct iio_chan_spec const *chan, 702 const int **vals, int *type, int *length, 703 long mask) 704 { 705 struct veml6030_data *data = iio_priv(indio_dev); 706 707 switch (mask) { 708 case IIO_CHAN_INFO_INT_TIME: 709 return iio_gts_avail_times(&data->gts, vals, type, length); 710 case IIO_CHAN_INFO_SCALE: 711 return iio_gts_all_avail_scales(&data->gts, vals, type, length); 712 } 713 714 return -EINVAL; 715 } 716 717 static int veml6030_write_raw(struct iio_dev *indio_dev, 718 struct iio_chan_spec const *chan, 719 int val, int val2, long mask) 720 { 721 switch (mask) { 722 case IIO_CHAN_INFO_INT_TIME: 723 return veml6030_set_it(indio_dev, val, val2); 724 case IIO_CHAN_INFO_SCALE: 725 return veml6030_set_scale(indio_dev, val, val2); 726 default: 727 return -EINVAL; 728 } 729 } 730 731 static int veml6030_write_raw_get_fmt(struct iio_dev *indio_dev, 732 struct iio_chan_spec const *chan, 733 long mask) 734 { 735 switch (mask) { 736 case IIO_CHAN_INFO_SCALE: 737 return IIO_VAL_INT_PLUS_NANO; 738 case IIO_CHAN_INFO_INT_TIME: 739 return IIO_VAL_INT_PLUS_MICRO; 740 default: 741 return -EINVAL; 742 } 743 } 744 745 static int veml6030_read_event_val(struct iio_dev *indio_dev, 746 const struct iio_chan_spec *chan, enum iio_event_type type, 747 enum iio_event_direction dir, enum iio_event_info info, 748 int *val, int *val2) 749 { 750 switch (info) { 751 case IIO_EV_INFO_VALUE: 752 switch (dir) { 753 case IIO_EV_DIR_RISING: 754 case IIO_EV_DIR_FALLING: 755 return veml6030_read_thresh(indio_dev, val, val2, dir); 756 default: 757 return -EINVAL; 758 } 759 break; 760 case IIO_EV_INFO_PERIOD: 761 return veml6030_read_persistence(indio_dev, val, val2); 762 default: 763 return -EINVAL; 764 } 765 } 766 767 static int veml6030_write_event_val(struct iio_dev *indio_dev, 768 const struct iio_chan_spec *chan, enum iio_event_type type, 769 enum iio_event_direction dir, enum iio_event_info info, 770 int val, int val2) 771 { 772 switch (info) { 773 case IIO_EV_INFO_VALUE: 774 return veml6030_write_thresh(indio_dev, val, val2, dir); 775 case IIO_EV_INFO_PERIOD: 776 return veml6030_write_persistence(indio_dev, val, val2); 777 default: 778 return -EINVAL; 779 } 780 } 781 782 static int veml6030_read_interrupt_config(struct iio_dev *indio_dev, 783 const struct iio_chan_spec *chan, enum iio_event_type type, 784 enum iio_event_direction dir) 785 { 786 int ret, reg; 787 struct veml6030_data *data = iio_priv(indio_dev); 788 789 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®); 790 if (ret) { 791 dev_err(&data->client->dev, 792 "can't read als conf register %d\n", ret); 793 return ret; 794 } 795 796 if (reg & VEML6030_ALS_INT_EN) 797 return 1; 798 else 799 return 0; 800 } 801 802 /* 803 * Sensor should not be measuring light when interrupt is configured. 804 * Therefore correct sequence to configure interrupt functionality is: 805 * shut down -> enable/disable interrupt -> power on 806 * 807 * state = 1 enables interrupt, state = 0 disables interrupt 808 */ 809 static int veml6030_write_interrupt_config(struct iio_dev *indio_dev, 810 const struct iio_chan_spec *chan, enum iio_event_type type, 811 enum iio_event_direction dir, bool state) 812 { 813 int ret; 814 struct veml6030_data *data = iio_priv(indio_dev); 815 816 ret = veml6030_als_shut_down(data); 817 if (ret < 0) { 818 dev_err(&data->client->dev, 819 "can't disable als to configure interrupt %d\n", ret); 820 return ret; 821 } 822 823 /* enable interrupt + power on */ 824 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF, 825 VEML6030_ALS_INT_EN | VEML6030_ALS_SD, state << 1); 826 if (ret) 827 dev_err(&data->client->dev, 828 "can't enable interrupt & poweron als %d\n", ret); 829 830 return ret; 831 } 832 833 static const struct iio_info veml6030_info = { 834 .read_raw = veml6030_read_raw, 835 .read_avail = veml6030_read_avail, 836 .write_raw = veml6030_write_raw, 837 .write_raw_get_fmt = veml6030_write_raw_get_fmt, 838 .read_event_value = veml6030_read_event_val, 839 .write_event_value = veml6030_write_event_val, 840 .read_event_config = veml6030_read_interrupt_config, 841 .write_event_config = veml6030_write_interrupt_config, 842 .event_attrs = &veml6030_event_attr_group, 843 }; 844 845 static const struct iio_info veml6030_info_no_irq = { 846 .read_raw = veml6030_read_raw, 847 .read_avail = veml6030_read_avail, 848 .write_raw = veml6030_write_raw, 849 .write_raw_get_fmt = veml6030_write_raw_get_fmt, 850 }; 851 852 static irqreturn_t veml6030_event_handler(int irq, void *private) 853 { 854 int ret, reg, evtdir; 855 struct iio_dev *indio_dev = private; 856 struct veml6030_data *data = iio_priv(indio_dev); 857 858 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, ®); 859 if (ret) { 860 dev_err(&data->client->dev, 861 "can't read als interrupt register %d\n", ret); 862 return IRQ_HANDLED; 863 } 864 865 /* Spurious interrupt handling */ 866 if (!(reg & (VEML6030_INT_TH_HIGH | VEML6030_INT_TH_LOW))) 867 return IRQ_NONE; 868 869 if (reg & VEML6030_INT_TH_HIGH) 870 evtdir = IIO_EV_DIR_RISING; 871 else 872 evtdir = IIO_EV_DIR_FALLING; 873 874 iio_push_event(indio_dev, IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 875 0, 876 IIO_EV_TYPE_THRESH, 877 evtdir), 878 iio_get_time_ns(indio_dev)); 879 880 return IRQ_HANDLED; 881 } 882 883 static irqreturn_t veml6030_trigger_handler(int irq, void *p) 884 { 885 struct iio_poll_func *pf = p; 886 struct iio_dev *iio = pf->indio_dev; 887 struct veml6030_data *data = iio_priv(iio); 888 unsigned int reg; 889 int ch, ret, i = 0; 890 struct { 891 u16 chans[2]; 892 aligned_s64 timestamp; 893 } scan = { }; 894 895 iio_for_each_active_channel(iio, ch) { 896 ret = regmap_read(data->regmap, VEML6030_REG_DATA(ch), 897 ®); 898 if (ret) 899 goto done; 900 901 scan.chans[i++] = reg; 902 } 903 904 iio_push_to_buffers_with_ts(iio, &scan, sizeof(scan), pf->timestamp); 905 906 done: 907 iio_trigger_notify_done(iio->trig); 908 909 return IRQ_HANDLED; 910 } 911 912 static int veml6030_set_info(struct iio_dev *indio_dev) 913 { 914 struct veml6030_data *data = iio_priv(indio_dev); 915 struct i2c_client *client = data->client; 916 int ret; 917 918 if (client->irq) { 919 ret = devm_request_threaded_irq(&client->dev, client->irq, 920 NULL, veml6030_event_handler, 921 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 922 indio_dev->name, indio_dev); 923 if (ret < 0) 924 return ret; 925 926 indio_dev->info = &veml6030_info; 927 } else { 928 indio_dev->info = &veml6030_info_no_irq; 929 } 930 931 return 0; 932 } 933 934 static int veml7700_set_info(struct iio_dev *indio_dev) 935 { 936 indio_dev->info = &veml6030_info_no_irq; 937 938 return 0; 939 } 940 941 static int veml6030_regfield_init(struct iio_dev *indio_dev) 942 { 943 struct veml6030_data *data = iio_priv(indio_dev); 944 struct regmap *regmap = data->regmap; 945 struct device *dev = &data->client->dev; 946 struct regmap_field *rm_field; 947 struct veml6030_rf *rf = &data->rf; 948 949 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->it_rf); 950 if (IS_ERR(rm_field)) 951 return PTR_ERR(rm_field); 952 rf->it = rm_field; 953 954 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->gain_rf); 955 if (IS_ERR(rm_field)) 956 return PTR_ERR(rm_field); 957 rf->gain = rm_field; 958 959 return 0; 960 } 961 962 /* 963 * Set ALS gain to 1/8, integration time to 100 ms, PSM to mode 2, 964 * persistence to 1 x integration time and the threshold 965 * interrupt disabled by default. First shutdown the sensor, 966 * update registers and then power on the sensor. 967 */ 968 static int veml6030_hw_init(struct iio_dev *indio_dev, struct device *dev) 969 { 970 int ret, val; 971 struct veml6030_data *data = iio_priv(indio_dev); 972 973 ret = devm_iio_init_iio_gts(dev, 2, 150400000, 974 veml6030_gain_sel, ARRAY_SIZE(veml6030_gain_sel), 975 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel), 976 &data->gts); 977 if (ret) 978 return dev_err_probe(dev, ret, "failed to init iio gts\n"); 979 980 ret = veml6030_als_shut_down(data); 981 if (ret) 982 return dev_err_probe(dev, ret, "can't shutdown als\n"); 983 984 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 0x1001); 985 if (ret) 986 return dev_err_probe(dev, ret, "can't setup als configs\n"); 987 988 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM, 989 VEML6030_PSM | VEML6030_PSM_EN, 0x03); 990 if (ret) 991 return dev_err_probe(dev, ret, "can't setup default PSM\n"); 992 993 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF); 994 if (ret) 995 return dev_err_probe(dev, ret, "can't setup high threshold\n"); 996 997 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000); 998 if (ret) 999 return dev_err_probe(dev, ret, "can't setup low threshold\n"); 1000 1001 ret = veml6030_als_pwr_on(data); 1002 if (ret) 1003 return dev_err_probe(dev, ret, "can't poweron als\n"); 1004 1005 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data); 1006 if (ret < 0) 1007 return ret; 1008 1009 /* Clear stale interrupt status bits if any during start */ 1010 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val); 1011 if (ret < 0) 1012 return dev_err_probe(dev, ret, 1013 "can't clear als interrupt status\n"); 1014 1015 return ret; 1016 } 1017 1018 /* 1019 * Set ALS gain to 1/8, integration time to 100 ms, ALS and WHITE 1020 * channel enabled, ALS channel interrupt, PSM enabled, 1021 * PSM_WAIT = 0.8 s, persistence to 1 x integration time and the 1022 * threshold interrupt disabled by default. First shutdown the sensor, 1023 * update registers and then power on the sensor. 1024 */ 1025 static int veml6035_hw_init(struct iio_dev *indio_dev, struct device *dev) 1026 { 1027 int ret, val; 1028 struct veml6030_data *data = iio_priv(indio_dev); 1029 1030 ret = devm_iio_init_iio_gts(dev, 0, 409600000, 1031 veml6035_gain_sel, ARRAY_SIZE(veml6035_gain_sel), 1032 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel), 1033 &data->gts); 1034 if (ret) 1035 return dev_err_probe(dev, ret, "failed to init iio gts\n"); 1036 1037 ret = veml6030_als_shut_down(data); 1038 if (ret) 1039 return dev_err_probe(dev, ret, "can't shutdown als\n"); 1040 1041 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 1042 VEML6035_SENS | VEML6035_CHAN_EN | VEML6030_ALS_SD); 1043 if (ret) 1044 return dev_err_probe(dev, ret, "can't setup als configs\n"); 1045 1046 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM, 1047 VEML6030_PSM | VEML6030_PSM_EN, 0x03); 1048 if (ret) 1049 return dev_err_probe(dev, ret, "can't setup default PSM\n"); 1050 1051 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF); 1052 if (ret) 1053 return dev_err_probe(dev, ret, "can't setup high threshold\n"); 1054 1055 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000); 1056 if (ret) 1057 return dev_err_probe(dev, ret, "can't setup low threshold\n"); 1058 1059 ret = veml6030_als_pwr_on(data); 1060 if (ret) 1061 return dev_err_probe(dev, ret, "can't poweron als\n"); 1062 1063 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data); 1064 if (ret < 0) 1065 return ret; 1066 1067 /* Clear stale interrupt status bits if any during start */ 1068 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val); 1069 if (ret < 0) 1070 return dev_err_probe(dev, ret, 1071 "can't clear als interrupt status\n"); 1072 1073 return 0; 1074 } 1075 1076 static int veml6030_probe(struct i2c_client *client) 1077 { 1078 int ret; 1079 struct veml6030_data *data; 1080 struct iio_dev *indio_dev; 1081 struct regmap *regmap; 1082 1083 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 1084 return dev_err_probe(&client->dev, -EOPNOTSUPP, 1085 "i2c adapter doesn't support plain i2c\n"); 1086 1087 regmap = devm_regmap_init_i2c(client, &veml6030_regmap_config); 1088 if (IS_ERR(regmap)) 1089 return dev_err_probe(&client->dev, PTR_ERR(regmap), 1090 "can't setup regmap\n"); 1091 1092 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1093 if (!indio_dev) 1094 return -ENOMEM; 1095 1096 data = iio_priv(indio_dev); 1097 i2c_set_clientdata(client, indio_dev); 1098 data->client = client; 1099 data->regmap = regmap; 1100 1101 ret = devm_regulator_get_enable(&client->dev, "vdd"); 1102 if (ret) 1103 return dev_err_probe(&client->dev, ret, 1104 "failed to enable regulator\n"); 1105 1106 data->chip = i2c_get_match_data(client); 1107 if (!data->chip) 1108 return -EINVAL; 1109 1110 indio_dev->name = data->chip->name; 1111 indio_dev->channels = data->chip->channels; 1112 indio_dev->num_channels = data->chip->num_channels; 1113 indio_dev->modes = INDIO_DIRECT_MODE; 1114 1115 ret = data->chip->set_info(indio_dev); 1116 if (ret < 0) 1117 return ret; 1118 1119 ret = veml6030_regfield_init(indio_dev); 1120 if (ret) 1121 return dev_err_probe(&client->dev, ret, 1122 "failed to init regfields\n"); 1123 1124 ret = data->chip->hw_init(indio_dev, &client->dev); 1125 if (ret < 0) 1126 return ret; 1127 1128 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL, 1129 veml6030_trigger_handler, NULL); 1130 if (ret) 1131 return dev_err_probe(&client->dev, ret, 1132 "Failed to register triggered buffer"); 1133 1134 return devm_iio_device_register(&client->dev, indio_dev); 1135 } 1136 1137 static int veml6030_runtime_suspend(struct device *dev) 1138 { 1139 int ret; 1140 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1141 struct veml6030_data *data = iio_priv(indio_dev); 1142 1143 ret = veml6030_als_shut_down(data); 1144 if (ret < 0) 1145 dev_err(&data->client->dev, "can't suspend als %d\n", ret); 1146 1147 return ret; 1148 } 1149 1150 static int veml6030_runtime_resume(struct device *dev) 1151 { 1152 int ret; 1153 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1154 struct veml6030_data *data = iio_priv(indio_dev); 1155 1156 ret = veml6030_als_pwr_on(data); 1157 if (ret < 0) 1158 dev_err(&data->client->dev, "can't resume als %d\n", ret); 1159 1160 return ret; 1161 } 1162 1163 static DEFINE_RUNTIME_DEV_PM_OPS(veml6030_pm_ops, veml6030_runtime_suspend, 1164 veml6030_runtime_resume, NULL); 1165 1166 static const struct veml603x_chip veml6030_chip = { 1167 .name = "veml6030", 1168 .channels = veml6030_channels, 1169 .num_channels = ARRAY_SIZE(veml6030_channels), 1170 .gain_rf = VEML6030_GAIN_RF, 1171 .it_rf = VEML6030_IT_RF, 1172 .max_scale = VEML6030_MAX_SCALE, 1173 .hw_init = veml6030_hw_init, 1174 .set_info = veml6030_set_info, 1175 }; 1176 1177 static const struct veml603x_chip veml6035_chip = { 1178 .name = "veml6035", 1179 .channels = veml6030_channels, 1180 .num_channels = ARRAY_SIZE(veml6030_channels), 1181 .gain_rf = VEML6035_GAIN_RF, 1182 .it_rf = VEML6030_IT_RF, 1183 .max_scale = VEML6035_MAX_SCALE, 1184 .hw_init = veml6035_hw_init, 1185 .set_info = veml6030_set_info, 1186 }; 1187 1188 static const struct veml603x_chip veml7700_chip = { 1189 .name = "veml7700", 1190 .channels = veml7700_channels, 1191 .num_channels = ARRAY_SIZE(veml7700_channels), 1192 .gain_rf = VEML6030_GAIN_RF, 1193 .it_rf = VEML6030_IT_RF, 1194 .max_scale = VEML6030_MAX_SCALE, 1195 .hw_init = veml6030_hw_init, 1196 .set_info = veml7700_set_info, 1197 }; 1198 1199 static const struct of_device_id veml6030_of_match[] = { 1200 { 1201 .compatible = "vishay,veml6030", 1202 .data = &veml6030_chip, 1203 }, 1204 { 1205 .compatible = "vishay,veml6035", 1206 .data = &veml6035_chip, 1207 }, 1208 { 1209 .compatible = "vishay,veml7700", 1210 .data = &veml7700_chip, 1211 }, 1212 { } 1213 }; 1214 MODULE_DEVICE_TABLE(of, veml6030_of_match); 1215 1216 static const struct i2c_device_id veml6030_id[] = { 1217 { .name = "veml6030", .driver_data = (kernel_ulong_t)&veml6030_chip }, 1218 { .name = "veml6035", .driver_data = (kernel_ulong_t)&veml6035_chip }, 1219 { .name = "veml7700", .driver_data = (kernel_ulong_t)&veml7700_chip }, 1220 { } 1221 }; 1222 MODULE_DEVICE_TABLE(i2c, veml6030_id); 1223 1224 static struct i2c_driver veml6030_driver = { 1225 .driver = { 1226 .name = "veml6030", 1227 .of_match_table = veml6030_of_match, 1228 .pm = pm_ptr(&veml6030_pm_ops), 1229 }, 1230 .probe = veml6030_probe, 1231 .id_table = veml6030_id, 1232 }; 1233 module_i2c_driver(veml6030_driver); 1234 1235 MODULE_AUTHOR("Rishi Gupta <gupt21@gmail.com>"); 1236 MODULE_DESCRIPTION("VEML6030 Ambient Light Sensor"); 1237 MODULE_LICENSE("GPL v2"); 1238 MODULE_IMPORT_NS("IIO_GTS_HELPER"); 1239