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 dev_err_probe(&client->dev, ret, 925 "irq %d request failed\n", 926 client->irq); 927 928 indio_dev->info = &veml6030_info; 929 } else { 930 indio_dev->info = &veml6030_info_no_irq; 931 } 932 933 return 0; 934 } 935 936 static int veml7700_set_info(struct iio_dev *indio_dev) 937 { 938 indio_dev->info = &veml6030_info_no_irq; 939 940 return 0; 941 } 942 943 static int veml6030_regfield_init(struct iio_dev *indio_dev) 944 { 945 struct veml6030_data *data = iio_priv(indio_dev); 946 struct regmap *regmap = data->regmap; 947 struct device *dev = &data->client->dev; 948 struct regmap_field *rm_field; 949 struct veml6030_rf *rf = &data->rf; 950 951 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->it_rf); 952 if (IS_ERR(rm_field)) 953 return PTR_ERR(rm_field); 954 rf->it = rm_field; 955 956 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->gain_rf); 957 if (IS_ERR(rm_field)) 958 return PTR_ERR(rm_field); 959 rf->gain = rm_field; 960 961 return 0; 962 } 963 964 /* 965 * Set ALS gain to 1/8, integration time to 100 ms, PSM to mode 2, 966 * persistence to 1 x integration time and the threshold 967 * interrupt disabled by default. First shutdown the sensor, 968 * update registers and then power on the sensor. 969 */ 970 static int veml6030_hw_init(struct iio_dev *indio_dev, struct device *dev) 971 { 972 int ret, val; 973 struct veml6030_data *data = iio_priv(indio_dev); 974 975 ret = devm_iio_init_iio_gts(dev, 2, 150400000, 976 veml6030_gain_sel, ARRAY_SIZE(veml6030_gain_sel), 977 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel), 978 &data->gts); 979 if (ret) 980 return dev_err_probe(dev, ret, "failed to init iio gts\n"); 981 982 ret = veml6030_als_shut_down(data); 983 if (ret) 984 return dev_err_probe(dev, ret, "can't shutdown als\n"); 985 986 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 0x1001); 987 if (ret) 988 return dev_err_probe(dev, ret, "can't setup als configs\n"); 989 990 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM, 991 VEML6030_PSM | VEML6030_PSM_EN, 0x03); 992 if (ret) 993 return dev_err_probe(dev, ret, "can't setup default PSM\n"); 994 995 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF); 996 if (ret) 997 return dev_err_probe(dev, ret, "can't setup high threshold\n"); 998 999 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000); 1000 if (ret) 1001 return dev_err_probe(dev, ret, "can't setup low threshold\n"); 1002 1003 ret = veml6030_als_pwr_on(data); 1004 if (ret) 1005 return dev_err_probe(dev, ret, "can't poweron als\n"); 1006 1007 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data); 1008 if (ret < 0) 1009 return ret; 1010 1011 /* Clear stale interrupt status bits if any during start */ 1012 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val); 1013 if (ret < 0) 1014 return dev_err_probe(dev, ret, 1015 "can't clear als interrupt status\n"); 1016 1017 return ret; 1018 } 1019 1020 /* 1021 * Set ALS gain to 1/8, integration time to 100 ms, ALS and WHITE 1022 * channel enabled, ALS channel interrupt, PSM enabled, 1023 * PSM_WAIT = 0.8 s, persistence to 1 x integration time and the 1024 * threshold interrupt disabled by default. First shutdown the sensor, 1025 * update registers and then power on the sensor. 1026 */ 1027 static int veml6035_hw_init(struct iio_dev *indio_dev, struct device *dev) 1028 { 1029 int ret, val; 1030 struct veml6030_data *data = iio_priv(indio_dev); 1031 1032 ret = devm_iio_init_iio_gts(dev, 0, 409600000, 1033 veml6035_gain_sel, ARRAY_SIZE(veml6035_gain_sel), 1034 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel), 1035 &data->gts); 1036 if (ret) 1037 return dev_err_probe(dev, ret, "failed to init iio gts\n"); 1038 1039 ret = veml6030_als_shut_down(data); 1040 if (ret) 1041 return dev_err_probe(dev, ret, "can't shutdown als\n"); 1042 1043 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 1044 VEML6035_SENS | VEML6035_CHAN_EN | VEML6030_ALS_SD); 1045 if (ret) 1046 return dev_err_probe(dev, ret, "can't setup als configs\n"); 1047 1048 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM, 1049 VEML6030_PSM | VEML6030_PSM_EN, 0x03); 1050 if (ret) 1051 return dev_err_probe(dev, ret, "can't setup default PSM\n"); 1052 1053 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF); 1054 if (ret) 1055 return dev_err_probe(dev, ret, "can't setup high threshold\n"); 1056 1057 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000); 1058 if (ret) 1059 return dev_err_probe(dev, ret, "can't setup low threshold\n"); 1060 1061 ret = veml6030_als_pwr_on(data); 1062 if (ret) 1063 return dev_err_probe(dev, ret, "can't poweron als\n"); 1064 1065 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data); 1066 if (ret < 0) 1067 return ret; 1068 1069 /* Clear stale interrupt status bits if any during start */ 1070 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val); 1071 if (ret < 0) 1072 return dev_err_probe(dev, ret, 1073 "can't clear als interrupt status\n"); 1074 1075 return 0; 1076 } 1077 1078 static int veml6030_probe(struct i2c_client *client) 1079 { 1080 int ret; 1081 struct veml6030_data *data; 1082 struct iio_dev *indio_dev; 1083 struct regmap *regmap; 1084 1085 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 1086 return dev_err_probe(&client->dev, -EOPNOTSUPP, 1087 "i2c adapter doesn't support plain i2c\n"); 1088 1089 regmap = devm_regmap_init_i2c(client, &veml6030_regmap_config); 1090 if (IS_ERR(regmap)) 1091 return dev_err_probe(&client->dev, PTR_ERR(regmap), 1092 "can't setup regmap\n"); 1093 1094 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1095 if (!indio_dev) 1096 return -ENOMEM; 1097 1098 data = iio_priv(indio_dev); 1099 i2c_set_clientdata(client, indio_dev); 1100 data->client = client; 1101 data->regmap = regmap; 1102 1103 ret = devm_regulator_get_enable(&client->dev, "vdd"); 1104 if (ret) 1105 return dev_err_probe(&client->dev, ret, 1106 "failed to enable regulator\n"); 1107 1108 data->chip = i2c_get_match_data(client); 1109 if (!data->chip) 1110 return -EINVAL; 1111 1112 indio_dev->name = data->chip->name; 1113 indio_dev->channels = data->chip->channels; 1114 indio_dev->num_channels = data->chip->num_channels; 1115 indio_dev->modes = INDIO_DIRECT_MODE; 1116 1117 ret = data->chip->set_info(indio_dev); 1118 if (ret < 0) 1119 return ret; 1120 1121 ret = veml6030_regfield_init(indio_dev); 1122 if (ret) 1123 return dev_err_probe(&client->dev, ret, 1124 "failed to init regfields\n"); 1125 1126 ret = data->chip->hw_init(indio_dev, &client->dev); 1127 if (ret < 0) 1128 return ret; 1129 1130 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL, 1131 veml6030_trigger_handler, NULL); 1132 if (ret) 1133 return dev_err_probe(&client->dev, ret, 1134 "Failed to register triggered buffer"); 1135 1136 return devm_iio_device_register(&client->dev, indio_dev); 1137 } 1138 1139 static int veml6030_runtime_suspend(struct device *dev) 1140 { 1141 int ret; 1142 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1143 struct veml6030_data *data = iio_priv(indio_dev); 1144 1145 ret = veml6030_als_shut_down(data); 1146 if (ret < 0) 1147 dev_err(&data->client->dev, "can't suspend als %d\n", ret); 1148 1149 return ret; 1150 } 1151 1152 static int veml6030_runtime_resume(struct device *dev) 1153 { 1154 int ret; 1155 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1156 struct veml6030_data *data = iio_priv(indio_dev); 1157 1158 ret = veml6030_als_pwr_on(data); 1159 if (ret < 0) 1160 dev_err(&data->client->dev, "can't resume als %d\n", ret); 1161 1162 return ret; 1163 } 1164 1165 static DEFINE_RUNTIME_DEV_PM_OPS(veml6030_pm_ops, veml6030_runtime_suspend, 1166 veml6030_runtime_resume, NULL); 1167 1168 static const struct veml603x_chip veml6030_chip = { 1169 .name = "veml6030", 1170 .channels = veml6030_channels, 1171 .num_channels = ARRAY_SIZE(veml6030_channels), 1172 .gain_rf = VEML6030_GAIN_RF, 1173 .it_rf = VEML6030_IT_RF, 1174 .max_scale = VEML6030_MAX_SCALE, 1175 .hw_init = veml6030_hw_init, 1176 .set_info = veml6030_set_info, 1177 }; 1178 1179 static const struct veml603x_chip veml6035_chip = { 1180 .name = "veml6035", 1181 .channels = veml6030_channels, 1182 .num_channels = ARRAY_SIZE(veml6030_channels), 1183 .gain_rf = VEML6035_GAIN_RF, 1184 .it_rf = VEML6030_IT_RF, 1185 .max_scale = VEML6035_MAX_SCALE, 1186 .hw_init = veml6035_hw_init, 1187 .set_info = veml6030_set_info, 1188 }; 1189 1190 static const struct veml603x_chip veml7700_chip = { 1191 .name = "veml7700", 1192 .channels = veml7700_channels, 1193 .num_channels = ARRAY_SIZE(veml7700_channels), 1194 .gain_rf = VEML6030_GAIN_RF, 1195 .it_rf = VEML6030_IT_RF, 1196 .max_scale = VEML6030_MAX_SCALE, 1197 .hw_init = veml6030_hw_init, 1198 .set_info = veml7700_set_info, 1199 }; 1200 1201 static const struct of_device_id veml6030_of_match[] = { 1202 { 1203 .compatible = "vishay,veml6030", 1204 .data = &veml6030_chip, 1205 }, 1206 { 1207 .compatible = "vishay,veml6035", 1208 .data = &veml6035_chip, 1209 }, 1210 { 1211 .compatible = "vishay,veml7700", 1212 .data = &veml7700_chip, 1213 }, 1214 { } 1215 }; 1216 MODULE_DEVICE_TABLE(of, veml6030_of_match); 1217 1218 static const struct i2c_device_id veml6030_id[] = { 1219 { .name = "veml6030", .driver_data = (kernel_ulong_t)&veml6030_chip }, 1220 { .name = "veml6035", .driver_data = (kernel_ulong_t)&veml6035_chip }, 1221 { .name = "veml7700", .driver_data = (kernel_ulong_t)&veml7700_chip }, 1222 { } 1223 }; 1224 MODULE_DEVICE_TABLE(i2c, veml6030_id); 1225 1226 static struct i2c_driver veml6030_driver = { 1227 .driver = { 1228 .name = "veml6030", 1229 .of_match_table = veml6030_of_match, 1230 .pm = pm_ptr(&veml6030_pm_ops), 1231 }, 1232 .probe = veml6030_probe, 1233 .id_table = veml6030_id, 1234 }; 1235 module_i2c_driver(veml6030_driver); 1236 1237 MODULE_AUTHOR("Rishi Gupta <gupt21@gmail.com>"); 1238 MODULE_DESCRIPTION("VEML6030 Ambient Light Sensor"); 1239 MODULE_LICENSE("GPL v2"); 1240 MODULE_IMPORT_NS("IIO_GTS_HELPER"); 1241