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_idx, it_sel; 525 struct veml6030_data *data = iio_priv(indio_dev); 526 527 ret = regmap_field_read(data->rf.it, &it_idx); 528 if (ret) 529 return ret; 530 531 ret = iio_gts_find_gain_time_sel_for_scale(&data->gts, val, val2, 532 &gain_sel, &it_sel); 533 if (ret) 534 return ret; 535 536 ret = regmap_field_write(data->rf.it, it_sel); 537 if (ret) 538 return ret; 539 540 ret = regmap_field_write(data->rf.gain, gain_sel); 541 if (ret) 542 return ret; 543 544 return 0; 545 } 546 547 static int veml6030_read_thresh(struct iio_dev *indio_dev, 548 int *val, int *val2, int dir) 549 { 550 int ret, reg; 551 struct veml6030_data *data = iio_priv(indio_dev); 552 553 if (dir == IIO_EV_DIR_RISING) 554 ret = regmap_read(data->regmap, VEML6030_REG_ALS_WH, ®); 555 else 556 ret = regmap_read(data->regmap, VEML6030_REG_ALS_WL, ®); 557 if (ret) { 558 dev_err(&data->client->dev, 559 "can't read als threshold value %d\n", ret); 560 return ret; 561 } 562 563 *val = reg & 0xffff; 564 return IIO_VAL_INT; 565 } 566 567 static int veml6030_write_thresh(struct iio_dev *indio_dev, 568 int val, int val2, int dir) 569 { 570 int ret; 571 struct veml6030_data *data = iio_priv(indio_dev); 572 573 if (val > 0xFFFF || val < 0 || val2) 574 return -EINVAL; 575 576 if (dir == IIO_EV_DIR_RISING) { 577 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, val); 578 if (ret) 579 dev_err(&data->client->dev, 580 "can't set high threshold %d\n", ret); 581 } else { 582 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, val); 583 if (ret) 584 dev_err(&data->client->dev, 585 "can't set low threshold %d\n", ret); 586 } 587 588 return ret; 589 } 590 591 static int veml6030_get_total_gain(struct veml6030_data *data) 592 { 593 int gain, it, reg, ret; 594 595 ret = regmap_field_read(data->rf.gain, ®); 596 if (ret) 597 return ret; 598 599 gain = iio_gts_find_gain_by_sel(&data->gts, reg); 600 if (gain < 0) 601 return gain; 602 603 ret = regmap_field_read(data->rf.it, ®); 604 if (ret) 605 return ret; 606 607 it = iio_gts_find_int_time_by_sel(&data->gts, reg); 608 if (it < 0) 609 return it; 610 611 return iio_gts_get_total_gain(&data->gts, gain, it); 612 } 613 614 static int veml6030_get_scale(struct veml6030_data *data, int *val, int *val2) 615 { 616 int gain, it, reg, ret; 617 618 ret = regmap_field_read(data->rf.gain, ®); 619 if (ret) 620 return ret; 621 622 gain = iio_gts_find_gain_by_sel(&data->gts, reg); 623 if (gain < 0) 624 return gain; 625 626 ret = regmap_field_read(data->rf.it, ®); 627 if (ret) 628 return ret; 629 630 it = iio_gts_find_int_time_by_sel(&data->gts, reg); 631 if (it < 0) 632 return it; 633 634 ret = iio_gts_get_scale(&data->gts, gain, it, val, val2); 635 if (ret) 636 return ret; 637 638 return IIO_VAL_INT_PLUS_NANO; 639 } 640 641 static int veml6030_process_als(struct veml6030_data *data, int raw, 642 int *val, int *val2) 643 { 644 int total_gain; 645 646 total_gain = veml6030_get_total_gain(data); 647 if (total_gain < 0) 648 return total_gain; 649 650 *val = raw * data->chip->max_scale / total_gain / 10000; 651 *val2 = raw * data->chip->max_scale / total_gain % 10000 * 100; 652 653 return IIO_VAL_INT_PLUS_MICRO; 654 } 655 656 /* 657 * Provide both raw as well as light reading in lux. 658 * light (in lux) = resolution * raw reading 659 */ 660 static int veml6030_read_raw(struct iio_dev *indio_dev, 661 struct iio_chan_spec const *chan, int *val, 662 int *val2, long mask) 663 { 664 int ret, reg; 665 struct veml6030_data *data = iio_priv(indio_dev); 666 struct regmap *regmap = data->regmap; 667 struct device *dev = &data->client->dev; 668 669 switch (mask) { 670 case IIO_CHAN_INFO_RAW: 671 case IIO_CHAN_INFO_PROCESSED: 672 switch (chan->type) { 673 case IIO_LIGHT: 674 ret = regmap_read(regmap, VEML6030_REG_ALS_DATA, ®); 675 if (ret < 0) { 676 dev_err(dev, "can't read als data %d\n", ret); 677 return ret; 678 } 679 if (mask == IIO_CHAN_INFO_PROCESSED) 680 return veml6030_process_als(data, reg, val, val2); 681 682 *val = reg; 683 return IIO_VAL_INT; 684 case IIO_INTENSITY: 685 ret = regmap_read(regmap, VEML6030_REG_WH_DATA, ®); 686 if (ret < 0) { 687 dev_err(dev, "can't read white data %d\n", ret); 688 return ret; 689 } 690 *val = reg; 691 return IIO_VAL_INT; 692 default: 693 return -EINVAL; 694 } 695 case IIO_CHAN_INFO_INT_TIME: 696 return veml6030_get_it(data, val, val2); 697 case IIO_CHAN_INFO_SCALE: 698 return veml6030_get_scale(data, val, val2); 699 default: 700 return -EINVAL; 701 } 702 } 703 704 static int veml6030_read_avail(struct iio_dev *indio_dev, 705 struct iio_chan_spec const *chan, 706 const int **vals, int *type, int *length, 707 long mask) 708 { 709 struct veml6030_data *data = iio_priv(indio_dev); 710 711 switch (mask) { 712 case IIO_CHAN_INFO_INT_TIME: 713 return iio_gts_avail_times(&data->gts, vals, type, length); 714 case IIO_CHAN_INFO_SCALE: 715 return iio_gts_all_avail_scales(&data->gts, vals, type, length); 716 } 717 718 return -EINVAL; 719 } 720 721 static int veml6030_write_raw(struct iio_dev *indio_dev, 722 struct iio_chan_spec const *chan, 723 int val, int val2, long mask) 724 { 725 switch (mask) { 726 case IIO_CHAN_INFO_INT_TIME: 727 return veml6030_set_it(indio_dev, val, val2); 728 case IIO_CHAN_INFO_SCALE: 729 return veml6030_set_scale(indio_dev, val, val2); 730 default: 731 return -EINVAL; 732 } 733 } 734 735 static int veml6030_write_raw_get_fmt(struct iio_dev *indio_dev, 736 struct iio_chan_spec const *chan, 737 long mask) 738 { 739 switch (mask) { 740 case IIO_CHAN_INFO_SCALE: 741 return IIO_VAL_INT_PLUS_NANO; 742 case IIO_CHAN_INFO_INT_TIME: 743 return IIO_VAL_INT_PLUS_MICRO; 744 default: 745 return -EINVAL; 746 } 747 } 748 749 static int veml6030_read_event_val(struct iio_dev *indio_dev, 750 const struct iio_chan_spec *chan, enum iio_event_type type, 751 enum iio_event_direction dir, enum iio_event_info info, 752 int *val, int *val2) 753 { 754 switch (info) { 755 case IIO_EV_INFO_VALUE: 756 switch (dir) { 757 case IIO_EV_DIR_RISING: 758 case IIO_EV_DIR_FALLING: 759 return veml6030_read_thresh(indio_dev, val, val2, dir); 760 default: 761 return -EINVAL; 762 } 763 break; 764 case IIO_EV_INFO_PERIOD: 765 return veml6030_read_persistence(indio_dev, val, val2); 766 default: 767 return -EINVAL; 768 } 769 } 770 771 static int veml6030_write_event_val(struct iio_dev *indio_dev, 772 const struct iio_chan_spec *chan, enum iio_event_type type, 773 enum iio_event_direction dir, enum iio_event_info info, 774 int val, int val2) 775 { 776 switch (info) { 777 case IIO_EV_INFO_VALUE: 778 return veml6030_write_thresh(indio_dev, val, val2, dir); 779 case IIO_EV_INFO_PERIOD: 780 return veml6030_write_persistence(indio_dev, val, val2); 781 default: 782 return -EINVAL; 783 } 784 } 785 786 static int veml6030_read_interrupt_config(struct iio_dev *indio_dev, 787 const struct iio_chan_spec *chan, enum iio_event_type type, 788 enum iio_event_direction dir) 789 { 790 int ret, reg; 791 struct veml6030_data *data = iio_priv(indio_dev); 792 793 ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, ®); 794 if (ret) { 795 dev_err(&data->client->dev, 796 "can't read als conf register %d\n", ret); 797 return ret; 798 } 799 800 if (reg & VEML6030_ALS_INT_EN) 801 return 1; 802 else 803 return 0; 804 } 805 806 /* 807 * Sensor should not be measuring light when interrupt is configured. 808 * Therefore correct sequence to configure interrupt functionality is: 809 * shut down -> enable/disable interrupt -> power on 810 * 811 * state = 1 enables interrupt, state = 0 disables interrupt 812 */ 813 static int veml6030_write_interrupt_config(struct iio_dev *indio_dev, 814 const struct iio_chan_spec *chan, enum iio_event_type type, 815 enum iio_event_direction dir, bool state) 816 { 817 int ret; 818 struct veml6030_data *data = iio_priv(indio_dev); 819 820 ret = veml6030_als_shut_down(data); 821 if (ret < 0) { 822 dev_err(&data->client->dev, 823 "can't disable als to configure interrupt %d\n", ret); 824 return ret; 825 } 826 827 /* enable interrupt + power on */ 828 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF, 829 VEML6030_ALS_INT_EN | VEML6030_ALS_SD, state << 1); 830 if (ret) 831 dev_err(&data->client->dev, 832 "can't enable interrupt & poweron als %d\n", ret); 833 834 return ret; 835 } 836 837 static const struct iio_info veml6030_info = { 838 .read_raw = veml6030_read_raw, 839 .read_avail = veml6030_read_avail, 840 .write_raw = veml6030_write_raw, 841 .write_raw_get_fmt = veml6030_write_raw_get_fmt, 842 .read_event_value = veml6030_read_event_val, 843 .write_event_value = veml6030_write_event_val, 844 .read_event_config = veml6030_read_interrupt_config, 845 .write_event_config = veml6030_write_interrupt_config, 846 .event_attrs = &veml6030_event_attr_group, 847 }; 848 849 static const struct iio_info veml6030_info_no_irq = { 850 .read_raw = veml6030_read_raw, 851 .read_avail = veml6030_read_avail, 852 .write_raw = veml6030_write_raw, 853 .write_raw_get_fmt = veml6030_write_raw_get_fmt, 854 }; 855 856 static irqreturn_t veml6030_event_handler(int irq, void *private) 857 { 858 int ret, reg, evtdir; 859 struct iio_dev *indio_dev = private; 860 struct veml6030_data *data = iio_priv(indio_dev); 861 862 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, ®); 863 if (ret) { 864 dev_err(&data->client->dev, 865 "can't read als interrupt register %d\n", ret); 866 return IRQ_HANDLED; 867 } 868 869 /* Spurious interrupt handling */ 870 if (!(reg & (VEML6030_INT_TH_HIGH | VEML6030_INT_TH_LOW))) 871 return IRQ_NONE; 872 873 if (reg & VEML6030_INT_TH_HIGH) 874 evtdir = IIO_EV_DIR_RISING; 875 else 876 evtdir = IIO_EV_DIR_FALLING; 877 878 iio_push_event(indio_dev, IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 879 0, IIO_EV_TYPE_THRESH, evtdir), 880 iio_get_time_ns(indio_dev)); 881 882 return IRQ_HANDLED; 883 } 884 885 static irqreturn_t veml6030_trigger_handler(int irq, void *p) 886 { 887 struct iio_poll_func *pf = p; 888 struct iio_dev *iio = pf->indio_dev; 889 struct veml6030_data *data = iio_priv(iio); 890 unsigned int reg; 891 int ch, ret, i = 0; 892 struct { 893 u16 chans[2]; 894 aligned_s64 timestamp; 895 } scan; 896 897 memset(&scan, 0, sizeof(scan)); 898 899 iio_for_each_active_channel(iio, ch) { 900 ret = regmap_read(data->regmap, VEML6030_REG_DATA(ch), 901 ®); 902 if (ret) 903 goto done; 904 905 scan.chans[i++] = reg; 906 } 907 908 iio_push_to_buffers_with_timestamp(iio, &scan, pf->timestamp); 909 910 done: 911 iio_trigger_notify_done(iio->trig); 912 913 return IRQ_HANDLED; 914 } 915 916 static int veml6030_set_info(struct iio_dev *indio_dev) 917 { 918 struct veml6030_data *data = iio_priv(indio_dev); 919 struct i2c_client *client = data->client; 920 int ret; 921 922 if (client->irq) { 923 ret = devm_request_threaded_irq(&client->dev, client->irq, 924 NULL, veml6030_event_handler, 925 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 926 indio_dev->name, indio_dev); 927 if (ret < 0) 928 return dev_err_probe(&client->dev, ret, 929 "irq %d request failed\n", 930 client->irq); 931 932 indio_dev->info = &veml6030_info; 933 } else { 934 indio_dev->info = &veml6030_info_no_irq; 935 } 936 937 return 0; 938 } 939 940 static int veml7700_set_info(struct iio_dev *indio_dev) 941 { 942 indio_dev->info = &veml6030_info_no_irq; 943 944 return 0; 945 } 946 947 static int veml6030_regfield_init(struct iio_dev *indio_dev) 948 { 949 struct veml6030_data *data = iio_priv(indio_dev); 950 struct regmap *regmap = data->regmap; 951 struct device *dev = &data->client->dev; 952 struct regmap_field *rm_field; 953 struct veml6030_rf *rf = &data->rf; 954 955 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->it_rf); 956 if (IS_ERR(rm_field)) 957 return PTR_ERR(rm_field); 958 rf->it = rm_field; 959 960 rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->gain_rf); 961 if (IS_ERR(rm_field)) 962 return PTR_ERR(rm_field); 963 rf->gain = rm_field; 964 965 return 0; 966 } 967 968 /* 969 * Set ALS gain to 1/8, integration time to 100 ms, PSM to mode 2, 970 * persistence to 1 x integration time and the threshold 971 * interrupt disabled by default. First shutdown the sensor, 972 * update registers and then power on the sensor. 973 */ 974 static int veml6030_hw_init(struct iio_dev *indio_dev, struct device *dev) 975 { 976 int ret, val; 977 struct veml6030_data *data = iio_priv(indio_dev); 978 979 ret = devm_iio_init_iio_gts(dev, 2, 150400000, 980 veml6030_gain_sel, ARRAY_SIZE(veml6030_gain_sel), 981 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel), 982 &data->gts); 983 if (ret) 984 return dev_err_probe(dev, ret, "failed to init iio gts\n"); 985 986 ret = veml6030_als_shut_down(data); 987 if (ret) 988 return dev_err_probe(dev, ret, "can't shutdown als\n"); 989 990 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 0x1001); 991 if (ret) 992 return dev_err_probe(dev, ret, "can't setup als configs\n"); 993 994 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM, 995 VEML6030_PSM | VEML6030_PSM_EN, 0x03); 996 if (ret) 997 return dev_err_probe(dev, ret, "can't setup default PSM\n"); 998 999 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF); 1000 if (ret) 1001 return dev_err_probe(dev, ret, "can't setup high threshold\n"); 1002 1003 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000); 1004 if (ret) 1005 return dev_err_probe(dev, ret, "can't setup low threshold\n"); 1006 1007 ret = veml6030_als_pwr_on(data); 1008 if (ret) 1009 return dev_err_probe(dev, ret, "can't poweron als\n"); 1010 1011 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data); 1012 if (ret < 0) 1013 return ret; 1014 1015 /* Clear stale interrupt status bits if any during start */ 1016 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val); 1017 if (ret < 0) 1018 return dev_err_probe(dev, ret, 1019 "can't clear als interrupt status\n"); 1020 1021 return ret; 1022 } 1023 1024 /* 1025 * Set ALS gain to 1/8, integration time to 100 ms, ALS and WHITE 1026 * channel enabled, ALS channel interrupt, PSM enabled, 1027 * PSM_WAIT = 0.8 s, persistence to 1 x integration time and the 1028 * threshold interrupt disabled by default. First shutdown the sensor, 1029 * update registers and then power on the sensor. 1030 */ 1031 static int veml6035_hw_init(struct iio_dev *indio_dev, struct device *dev) 1032 { 1033 int ret, val; 1034 struct veml6030_data *data = iio_priv(indio_dev); 1035 1036 ret = devm_iio_init_iio_gts(dev, 0, 409600000, 1037 veml6035_gain_sel, ARRAY_SIZE(veml6035_gain_sel), 1038 veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel), 1039 &data->gts); 1040 if (ret) 1041 return dev_err_probe(dev, ret, "failed to init iio gts\n"); 1042 1043 ret = veml6030_als_shut_down(data); 1044 if (ret) 1045 return dev_err_probe(dev, ret, "can't shutdown als\n"); 1046 1047 ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 1048 VEML6035_SENS | VEML6035_CHAN_EN | VEML6030_ALS_SD); 1049 if (ret) 1050 return dev_err_probe(dev, ret, "can't setup als configs\n"); 1051 1052 ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM, 1053 VEML6030_PSM | VEML6030_PSM_EN, 0x03); 1054 if (ret) 1055 return dev_err_probe(dev, ret, "can't setup default PSM\n"); 1056 1057 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF); 1058 if (ret) 1059 return dev_err_probe(dev, ret, "can't setup high threshold\n"); 1060 1061 ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000); 1062 if (ret) 1063 return dev_err_probe(dev, ret, "can't setup low threshold\n"); 1064 1065 ret = veml6030_als_pwr_on(data); 1066 if (ret) 1067 return dev_err_probe(dev, ret, "can't poweron als\n"); 1068 1069 ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data); 1070 if (ret < 0) 1071 return ret; 1072 1073 /* Clear stale interrupt status bits if any during start */ 1074 ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val); 1075 if (ret < 0) 1076 return dev_err_probe(dev, ret, 1077 "can't clear als interrupt status\n"); 1078 1079 return 0; 1080 } 1081 1082 static int veml6030_probe(struct i2c_client *client) 1083 { 1084 int ret; 1085 struct veml6030_data *data; 1086 struct iio_dev *indio_dev; 1087 struct regmap *regmap; 1088 1089 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 1090 return dev_err_probe(&client->dev, -EOPNOTSUPP, 1091 "i2c adapter doesn't support plain i2c\n"); 1092 1093 regmap = devm_regmap_init_i2c(client, &veml6030_regmap_config); 1094 if (IS_ERR(regmap)) 1095 return dev_err_probe(&client->dev, PTR_ERR(regmap), 1096 "can't setup regmap\n"); 1097 1098 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1099 if (!indio_dev) 1100 return -ENOMEM; 1101 1102 data = iio_priv(indio_dev); 1103 i2c_set_clientdata(client, indio_dev); 1104 data->client = client; 1105 data->regmap = regmap; 1106 1107 ret = devm_regulator_get_enable(&client->dev, "vdd"); 1108 if (ret) 1109 return dev_err_probe(&client->dev, ret, 1110 "failed to enable regulator\n"); 1111 1112 data->chip = i2c_get_match_data(client); 1113 if (!data->chip) 1114 return -EINVAL; 1115 1116 indio_dev->name = data->chip->name; 1117 indio_dev->channels = data->chip->channels; 1118 indio_dev->num_channels = data->chip->num_channels; 1119 indio_dev->modes = INDIO_DIRECT_MODE; 1120 1121 ret = data->chip->set_info(indio_dev); 1122 if (ret < 0) 1123 return ret; 1124 1125 ret = veml6030_regfield_init(indio_dev); 1126 if (ret) 1127 return dev_err_probe(&client->dev, ret, 1128 "failed to init regfields\n"); 1129 1130 ret = data->chip->hw_init(indio_dev, &client->dev); 1131 if (ret < 0) 1132 return ret; 1133 1134 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL, 1135 veml6030_trigger_handler, NULL); 1136 if (ret) 1137 return dev_err_probe(&client->dev, ret, 1138 "Failed to register triggered buffer"); 1139 1140 return devm_iio_device_register(&client->dev, indio_dev); 1141 } 1142 1143 static int veml6030_runtime_suspend(struct device *dev) 1144 { 1145 int ret; 1146 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1147 struct veml6030_data *data = iio_priv(indio_dev); 1148 1149 ret = veml6030_als_shut_down(data); 1150 if (ret < 0) 1151 dev_err(&data->client->dev, "can't suspend als %d\n", ret); 1152 1153 return ret; 1154 } 1155 1156 static int veml6030_runtime_resume(struct device *dev) 1157 { 1158 int ret; 1159 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1160 struct veml6030_data *data = iio_priv(indio_dev); 1161 1162 ret = veml6030_als_pwr_on(data); 1163 if (ret < 0) 1164 dev_err(&data->client->dev, "can't resume als %d\n", ret); 1165 1166 return ret; 1167 } 1168 1169 static DEFINE_RUNTIME_DEV_PM_OPS(veml6030_pm_ops, veml6030_runtime_suspend, 1170 veml6030_runtime_resume, NULL); 1171 1172 static const struct veml603x_chip veml6030_chip = { 1173 .name = "veml6030", 1174 .channels = veml6030_channels, 1175 .num_channels = ARRAY_SIZE(veml6030_channels), 1176 .gain_rf = VEML6030_GAIN_RF, 1177 .it_rf = VEML6030_IT_RF, 1178 .max_scale = VEML6030_MAX_SCALE, 1179 .hw_init = veml6030_hw_init, 1180 .set_info = veml6030_set_info, 1181 }; 1182 1183 static const struct veml603x_chip veml6035_chip = { 1184 .name = "veml6035", 1185 .channels = veml6030_channels, 1186 .num_channels = ARRAY_SIZE(veml6030_channels), 1187 .gain_rf = VEML6035_GAIN_RF, 1188 .it_rf = VEML6030_IT_RF, 1189 .max_scale = VEML6035_MAX_SCALE, 1190 .hw_init = veml6035_hw_init, 1191 .set_info = veml6030_set_info, 1192 }; 1193 1194 static const struct veml603x_chip veml7700_chip = { 1195 .name = "veml7700", 1196 .channels = veml7700_channels, 1197 .num_channels = ARRAY_SIZE(veml7700_channels), 1198 .gain_rf = VEML6030_GAIN_RF, 1199 .it_rf = VEML6030_IT_RF, 1200 .max_scale = VEML6030_MAX_SCALE, 1201 .hw_init = veml6030_hw_init, 1202 .set_info = veml7700_set_info, 1203 }; 1204 1205 static const struct of_device_id veml6030_of_match[] = { 1206 { 1207 .compatible = "vishay,veml6030", 1208 .data = &veml6030_chip, 1209 }, 1210 { 1211 .compatible = "vishay,veml6035", 1212 .data = &veml6035_chip, 1213 }, 1214 { 1215 .compatible = "vishay,veml7700", 1216 .data = &veml7700_chip, 1217 }, 1218 { } 1219 }; 1220 MODULE_DEVICE_TABLE(of, veml6030_of_match); 1221 1222 static const struct i2c_device_id veml6030_id[] = { 1223 { "veml6030", (kernel_ulong_t)&veml6030_chip}, 1224 { "veml6035", (kernel_ulong_t)&veml6035_chip}, 1225 { "veml7700", (kernel_ulong_t)&veml7700_chip}, 1226 { } 1227 }; 1228 MODULE_DEVICE_TABLE(i2c, veml6030_id); 1229 1230 static struct i2c_driver veml6030_driver = { 1231 .driver = { 1232 .name = "veml6030", 1233 .of_match_table = veml6030_of_match, 1234 .pm = pm_ptr(&veml6030_pm_ops), 1235 }, 1236 .probe = veml6030_probe, 1237 .id_table = veml6030_id, 1238 }; 1239 module_i2c_driver(veml6030_driver); 1240 1241 MODULE_AUTHOR("Rishi Gupta <gupt21@gmail.com>"); 1242 MODULE_DESCRIPTION("VEML6030 Ambient Light Sensor"); 1243 MODULE_LICENSE("GPL v2"); 1244 MODULE_IMPORT_NS("IIO_GTS_HELPER"); 1245