1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * vcnl4000.c - Support for Vishay VCNL4000/4010/4020/4040/4200 combined ambient 4 * light and proximity sensor 5 * 6 * Copyright 2012 Peter Meerwald <pmeerw@pmeerw.net> 7 * Copyright 2019 Pursim SPC 8 * Copyright 2020 Mathieu Othacehe <m.othacehe@gmail.com> 9 * 10 * IIO driver for: 11 * VCNL4000/10/20 (7-bit I2C slave address 0x13) 12 * VCNL4040 (7-bit I2C slave address 0x60) 13 * VCNL4200 (7-bit I2C slave address 0x51) 14 * 15 * TODO: 16 * allow to adjust IR current 17 * interrupts (VCNL4040, VCNL4200) 18 */ 19 20 #include <linux/module.h> 21 #include <linux/i2c.h> 22 #include <linux/err.h> 23 #include <linux/delay.h> 24 #include <linux/pm_runtime.h> 25 #include <linux/interrupt.h> 26 27 #include <linux/iio/buffer.h> 28 #include <linux/iio/events.h> 29 #include <linux/iio/iio.h> 30 #include <linux/iio/sysfs.h> 31 #include <linux/iio/trigger.h> 32 #include <linux/iio/trigger_consumer.h> 33 #include <linux/iio/triggered_buffer.h> 34 35 #define VCNL4000_DRV_NAME "vcnl4000" 36 #define VCNL4000_PROD_ID 0x01 37 #define VCNL4010_PROD_ID 0x02 /* for VCNL4020, VCNL4010 */ 38 #define VCNL4040_PROD_ID 0x86 39 #define VCNL4200_PROD_ID 0x58 40 41 #define VCNL4000_COMMAND 0x80 /* Command register */ 42 #define VCNL4000_PROD_REV 0x81 /* Product ID and Revision ID */ 43 #define VCNL4010_PROX_RATE 0x82 /* Proximity rate */ 44 #define VCNL4000_LED_CURRENT 0x83 /* IR LED current for proximity mode */ 45 #define VCNL4000_AL_PARAM 0x84 /* Ambient light parameter register */ 46 #define VCNL4010_ALS_PARAM 0x84 /* ALS rate */ 47 #define VCNL4000_AL_RESULT_HI 0x85 /* Ambient light result register, MSB */ 48 #define VCNL4000_AL_RESULT_LO 0x86 /* Ambient light result register, LSB */ 49 #define VCNL4000_PS_RESULT_HI 0x87 /* Proximity result register, MSB */ 50 #define VCNL4000_PS_RESULT_LO 0x88 /* Proximity result register, LSB */ 51 #define VCNL4000_PS_MEAS_FREQ 0x89 /* Proximity test signal frequency */ 52 #define VCNL4010_INT_CTRL 0x89 /* Interrupt control */ 53 #define VCNL4000_PS_MOD_ADJ 0x8a /* Proximity modulator timing adjustment */ 54 #define VCNL4010_LOW_THR_HI 0x8a /* Low threshold, MSB */ 55 #define VCNL4010_LOW_THR_LO 0x8b /* Low threshold, LSB */ 56 #define VCNL4010_HIGH_THR_HI 0x8c /* High threshold, MSB */ 57 #define VCNL4010_HIGH_THR_LO 0x8d /* High threshold, LSB */ 58 #define VCNL4010_ISR 0x8e /* Interrupt status */ 59 60 #define VCNL4200_AL_CONF 0x00 /* Ambient light configuration */ 61 #define VCNL4200_PS_CONF1 0x03 /* Proximity configuration */ 62 #define VCNL4200_PS_DATA 0x08 /* Proximity data */ 63 #define VCNL4200_AL_DATA 0x09 /* Ambient light data */ 64 #define VCNL4200_DEV_ID 0x0e /* Device ID, slave address and version */ 65 66 #define VCNL4040_DEV_ID 0x0c /* Device ID and version */ 67 68 /* Bit masks for COMMAND register */ 69 #define VCNL4000_AL_RDY BIT(6) /* ALS data ready? */ 70 #define VCNL4000_PS_RDY BIT(5) /* proximity data ready? */ 71 #define VCNL4000_AL_OD BIT(4) /* start on-demand ALS measurement */ 72 #define VCNL4000_PS_OD BIT(3) /* start on-demand proximity measurement */ 73 #define VCNL4000_ALS_EN BIT(2) /* start ALS measurement */ 74 #define VCNL4000_PROX_EN BIT(1) /* start proximity measurement */ 75 #define VCNL4000_SELF_TIMED_EN BIT(0) /* start self-timed measurement */ 76 77 /* Bit masks for interrupt registers. */ 78 #define VCNL4010_INT_THR_SEL BIT(0) /* Select threshold interrupt source */ 79 #define VCNL4010_INT_THR_EN BIT(1) /* Threshold interrupt type */ 80 #define VCNL4010_INT_ALS_EN BIT(2) /* Enable on ALS data ready */ 81 #define VCNL4010_INT_PROX_EN BIT(3) /* Enable on proximity data ready */ 82 83 #define VCNL4010_INT_THR_HIGH 0 /* High threshold exceeded */ 84 #define VCNL4010_INT_THR_LOW 1 /* Low threshold exceeded */ 85 #define VCNL4010_INT_ALS 2 /* ALS data ready */ 86 #define VCNL4010_INT_PROXIMITY 3 /* Proximity data ready */ 87 88 #define VCNL4010_INT_THR \ 89 (BIT(VCNL4010_INT_THR_LOW) | BIT(VCNL4010_INT_THR_HIGH)) 90 #define VCNL4010_INT_DRDY \ 91 (BIT(VCNL4010_INT_PROXIMITY) | BIT(VCNL4010_INT_ALS)) 92 93 static const int vcnl4010_prox_sampling_frequency[][2] = { 94 {1, 950000}, 95 {3, 906250}, 96 {7, 812500}, 97 {16, 625000}, 98 {31, 250000}, 99 {62, 500000}, 100 {125, 0}, 101 {250, 0}, 102 }; 103 104 #define VCNL4000_SLEEP_DELAY_MS 2000 /* before we enter pm_runtime_suspend */ 105 106 enum vcnl4000_device_ids { 107 VCNL4000, 108 VCNL4010, 109 VCNL4040, 110 VCNL4200, 111 }; 112 113 struct vcnl4200_channel { 114 u8 reg; 115 ktime_t last_measurement; 116 ktime_t sampling_rate; 117 struct mutex lock; 118 }; 119 120 struct vcnl4000_data { 121 struct i2c_client *client; 122 enum vcnl4000_device_ids id; 123 int rev; 124 int al_scale; 125 const struct vcnl4000_chip_spec *chip_spec; 126 struct mutex vcnl4000_lock; 127 struct vcnl4200_channel vcnl4200_al; 128 struct vcnl4200_channel vcnl4200_ps; 129 uint32_t near_level; 130 }; 131 132 struct vcnl4000_chip_spec { 133 const char *prod; 134 struct iio_chan_spec const *channels; 135 const int num_channels; 136 const struct iio_info *info; 137 bool irq_support; 138 int (*init)(struct vcnl4000_data *data); 139 int (*measure_light)(struct vcnl4000_data *data, int *val); 140 int (*measure_proximity)(struct vcnl4000_data *data, int *val); 141 int (*set_power_state)(struct vcnl4000_data *data, bool on); 142 }; 143 144 static const struct i2c_device_id vcnl4000_id[] = { 145 { "vcnl4000", VCNL4000 }, 146 { "vcnl4010", VCNL4010 }, 147 { "vcnl4020", VCNL4010 }, 148 { "vcnl4040", VCNL4040 }, 149 { "vcnl4200", VCNL4200 }, 150 { } 151 }; 152 MODULE_DEVICE_TABLE(i2c, vcnl4000_id); 153 154 static int vcnl4000_set_power_state(struct vcnl4000_data *data, bool on) 155 { 156 /* no suspend op */ 157 return 0; 158 } 159 160 static int vcnl4000_init(struct vcnl4000_data *data) 161 { 162 int ret, prod_id; 163 164 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_PROD_REV); 165 if (ret < 0) 166 return ret; 167 168 prod_id = ret >> 4; 169 switch (prod_id) { 170 case VCNL4000_PROD_ID: 171 if (data->id != VCNL4000) 172 dev_warn(&data->client->dev, 173 "wrong device id, use vcnl4000"); 174 break; 175 case VCNL4010_PROD_ID: 176 if (data->id != VCNL4010) 177 dev_warn(&data->client->dev, 178 "wrong device id, use vcnl4010/4020"); 179 break; 180 default: 181 return -ENODEV; 182 } 183 184 data->rev = ret & 0xf; 185 data->al_scale = 250000; 186 mutex_init(&data->vcnl4000_lock); 187 188 return data->chip_spec->set_power_state(data, true); 189 }; 190 191 static int vcnl4200_set_power_state(struct vcnl4000_data *data, bool on) 192 { 193 u16 val = on ? 0 /* power on */ : 1 /* shut down */; 194 int ret; 195 196 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF, val); 197 if (ret < 0) 198 return ret; 199 200 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, val); 201 if (ret < 0) 202 return ret; 203 204 if (on) { 205 /* Wait at least one integration cycle before fetching data */ 206 data->vcnl4200_al.last_measurement = ktime_get(); 207 data->vcnl4200_ps.last_measurement = ktime_get(); 208 } 209 210 return 0; 211 } 212 213 static int vcnl4200_init(struct vcnl4000_data *data) 214 { 215 int ret, id; 216 217 ret = i2c_smbus_read_word_data(data->client, VCNL4200_DEV_ID); 218 if (ret < 0) 219 return ret; 220 221 id = ret & 0xff; 222 223 if (id != VCNL4200_PROD_ID) { 224 ret = i2c_smbus_read_word_data(data->client, VCNL4040_DEV_ID); 225 if (ret < 0) 226 return ret; 227 228 id = ret & 0xff; 229 230 if (id != VCNL4040_PROD_ID) 231 return -ENODEV; 232 } 233 234 dev_dbg(&data->client->dev, "device id 0x%x", id); 235 236 data->rev = (ret >> 8) & 0xf; 237 238 data->vcnl4200_al.reg = VCNL4200_AL_DATA; 239 data->vcnl4200_ps.reg = VCNL4200_PS_DATA; 240 switch (id) { 241 case VCNL4200_PROD_ID: 242 /* Default wait time is 50ms, add 20% tolerance. */ 243 data->vcnl4200_al.sampling_rate = ktime_set(0, 60000 * 1000); 244 /* Default wait time is 4.8ms, add 20% tolerance. */ 245 data->vcnl4200_ps.sampling_rate = ktime_set(0, 5760 * 1000); 246 data->al_scale = 24000; 247 break; 248 case VCNL4040_PROD_ID: 249 /* Default wait time is 80ms, add 20% tolerance. */ 250 data->vcnl4200_al.sampling_rate = ktime_set(0, 96000 * 1000); 251 /* Default wait time is 5ms, add 20% tolerance. */ 252 data->vcnl4200_ps.sampling_rate = ktime_set(0, 6000 * 1000); 253 data->al_scale = 120000; 254 break; 255 } 256 mutex_init(&data->vcnl4200_al.lock); 257 mutex_init(&data->vcnl4200_ps.lock); 258 259 ret = data->chip_spec->set_power_state(data, true); 260 if (ret < 0) 261 return ret; 262 263 return 0; 264 }; 265 266 static int vcnl4000_read_data(struct vcnl4000_data *data, u8 data_reg, int *val) 267 { 268 s32 ret; 269 270 ret = i2c_smbus_read_word_swapped(data->client, data_reg); 271 if (ret < 0) 272 return ret; 273 274 *val = ret; 275 return 0; 276 } 277 278 static int vcnl4000_write_data(struct vcnl4000_data *data, u8 data_reg, int val) 279 { 280 if (val > U16_MAX) 281 return -ERANGE; 282 283 return i2c_smbus_write_word_swapped(data->client, data_reg, val); 284 } 285 286 287 static int vcnl4000_measure(struct vcnl4000_data *data, u8 req_mask, 288 u8 rdy_mask, u8 data_reg, int *val) 289 { 290 int tries = 20; 291 int ret; 292 293 mutex_lock(&data->vcnl4000_lock); 294 295 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 296 req_mask); 297 if (ret < 0) 298 goto fail; 299 300 /* wait for data to become ready */ 301 while (tries--) { 302 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND); 303 if (ret < 0) 304 goto fail; 305 if (ret & rdy_mask) 306 break; 307 msleep(20); /* measurement takes up to 100 ms */ 308 } 309 310 if (tries < 0) { 311 dev_err(&data->client->dev, 312 "vcnl4000_measure() failed, data not ready\n"); 313 ret = -EIO; 314 goto fail; 315 } 316 317 ret = vcnl4000_read_data(data, data_reg, val); 318 if (ret < 0) 319 goto fail; 320 321 mutex_unlock(&data->vcnl4000_lock); 322 323 return 0; 324 325 fail: 326 mutex_unlock(&data->vcnl4000_lock); 327 return ret; 328 } 329 330 static int vcnl4200_measure(struct vcnl4000_data *data, 331 struct vcnl4200_channel *chan, int *val) 332 { 333 int ret; 334 s64 delta; 335 ktime_t next_measurement; 336 337 mutex_lock(&chan->lock); 338 339 next_measurement = ktime_add(chan->last_measurement, 340 chan->sampling_rate); 341 delta = ktime_us_delta(next_measurement, ktime_get()); 342 if (delta > 0) 343 usleep_range(delta, delta + 500); 344 chan->last_measurement = ktime_get(); 345 346 mutex_unlock(&chan->lock); 347 348 ret = i2c_smbus_read_word_data(data->client, chan->reg); 349 if (ret < 0) 350 return ret; 351 352 *val = ret; 353 354 return 0; 355 } 356 357 static int vcnl4000_measure_light(struct vcnl4000_data *data, int *val) 358 { 359 return vcnl4000_measure(data, 360 VCNL4000_AL_OD, VCNL4000_AL_RDY, 361 VCNL4000_AL_RESULT_HI, val); 362 } 363 364 static int vcnl4200_measure_light(struct vcnl4000_data *data, int *val) 365 { 366 return vcnl4200_measure(data, &data->vcnl4200_al, val); 367 } 368 369 static int vcnl4000_measure_proximity(struct vcnl4000_data *data, int *val) 370 { 371 return vcnl4000_measure(data, 372 VCNL4000_PS_OD, VCNL4000_PS_RDY, 373 VCNL4000_PS_RESULT_HI, val); 374 } 375 376 static int vcnl4200_measure_proximity(struct vcnl4000_data *data, int *val) 377 { 378 return vcnl4200_measure(data, &data->vcnl4200_ps, val); 379 } 380 381 static int vcnl4010_read_proxy_samp_freq(struct vcnl4000_data *data, int *val, 382 int *val2) 383 { 384 int ret; 385 386 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_PROX_RATE); 387 if (ret < 0) 388 return ret; 389 390 if (ret >= ARRAY_SIZE(vcnl4010_prox_sampling_frequency)) 391 return -EINVAL; 392 393 *val = vcnl4010_prox_sampling_frequency[ret][0]; 394 *val2 = vcnl4010_prox_sampling_frequency[ret][1]; 395 396 return 0; 397 } 398 399 static bool vcnl4010_is_in_periodic_mode(struct vcnl4000_data *data) 400 { 401 int ret; 402 403 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND); 404 if (ret < 0) 405 return false; 406 407 return !!(ret & VCNL4000_SELF_TIMED_EN); 408 } 409 410 static int vcnl4000_set_pm_runtime_state(struct vcnl4000_data *data, bool on) 411 { 412 struct device *dev = &data->client->dev; 413 int ret; 414 415 if (on) { 416 ret = pm_runtime_get_sync(dev); 417 if (ret < 0) 418 pm_runtime_put_noidle(dev); 419 } else { 420 pm_runtime_mark_last_busy(dev); 421 ret = pm_runtime_put_autosuspend(dev); 422 } 423 424 return ret; 425 } 426 427 static int vcnl4000_read_raw(struct iio_dev *indio_dev, 428 struct iio_chan_spec const *chan, 429 int *val, int *val2, long mask) 430 { 431 int ret; 432 struct vcnl4000_data *data = iio_priv(indio_dev); 433 434 switch (mask) { 435 case IIO_CHAN_INFO_RAW: 436 ret = vcnl4000_set_pm_runtime_state(data, true); 437 if (ret < 0) 438 return ret; 439 440 switch (chan->type) { 441 case IIO_LIGHT: 442 ret = data->chip_spec->measure_light(data, val); 443 if (!ret) 444 ret = IIO_VAL_INT; 445 break; 446 case IIO_PROXIMITY: 447 ret = data->chip_spec->measure_proximity(data, val); 448 if (!ret) 449 ret = IIO_VAL_INT; 450 break; 451 default: 452 ret = -EINVAL; 453 } 454 vcnl4000_set_pm_runtime_state(data, false); 455 return ret; 456 case IIO_CHAN_INFO_SCALE: 457 if (chan->type != IIO_LIGHT) 458 return -EINVAL; 459 460 *val = 0; 461 *val2 = data->al_scale; 462 return IIO_VAL_INT_PLUS_MICRO; 463 default: 464 return -EINVAL; 465 } 466 } 467 468 static int vcnl4010_read_raw(struct iio_dev *indio_dev, 469 struct iio_chan_spec const *chan, 470 int *val, int *val2, long mask) 471 { 472 int ret; 473 struct vcnl4000_data *data = iio_priv(indio_dev); 474 475 switch (mask) { 476 case IIO_CHAN_INFO_RAW: 477 case IIO_CHAN_INFO_SCALE: 478 ret = iio_device_claim_direct_mode(indio_dev); 479 if (ret) 480 return ret; 481 482 /* Protect against event capture. */ 483 if (vcnl4010_is_in_periodic_mode(data)) { 484 ret = -EBUSY; 485 } else { 486 ret = vcnl4000_read_raw(indio_dev, chan, val, val2, 487 mask); 488 } 489 490 iio_device_release_direct_mode(indio_dev); 491 return ret; 492 case IIO_CHAN_INFO_SAMP_FREQ: 493 switch (chan->type) { 494 case IIO_PROXIMITY: 495 ret = vcnl4010_read_proxy_samp_freq(data, val, val2); 496 if (ret < 0) 497 return ret; 498 return IIO_VAL_INT_PLUS_MICRO; 499 default: 500 return -EINVAL; 501 } 502 default: 503 return -EINVAL; 504 } 505 } 506 507 static int vcnl4010_read_avail(struct iio_dev *indio_dev, 508 struct iio_chan_spec const *chan, 509 const int **vals, int *type, int *length, 510 long mask) 511 { 512 switch (mask) { 513 case IIO_CHAN_INFO_SAMP_FREQ: 514 *vals = (int *)vcnl4010_prox_sampling_frequency; 515 *type = IIO_VAL_INT_PLUS_MICRO; 516 *length = 2 * ARRAY_SIZE(vcnl4010_prox_sampling_frequency); 517 return IIO_AVAIL_LIST; 518 default: 519 return -EINVAL; 520 } 521 } 522 523 static int vcnl4010_write_proxy_samp_freq(struct vcnl4000_data *data, int val, 524 int val2) 525 { 526 unsigned int i; 527 int index = -1; 528 529 for (i = 0; i < ARRAY_SIZE(vcnl4010_prox_sampling_frequency); i++) { 530 if (val == vcnl4010_prox_sampling_frequency[i][0] && 531 val2 == vcnl4010_prox_sampling_frequency[i][1]) { 532 index = i; 533 break; 534 } 535 } 536 537 if (index < 0) 538 return -EINVAL; 539 540 return i2c_smbus_write_byte_data(data->client, VCNL4010_PROX_RATE, 541 index); 542 } 543 544 static int vcnl4010_write_raw(struct iio_dev *indio_dev, 545 struct iio_chan_spec const *chan, 546 int val, int val2, long mask) 547 { 548 int ret; 549 struct vcnl4000_data *data = iio_priv(indio_dev); 550 551 ret = iio_device_claim_direct_mode(indio_dev); 552 if (ret) 553 return ret; 554 555 /* Protect against event capture. */ 556 if (vcnl4010_is_in_periodic_mode(data)) { 557 ret = -EBUSY; 558 goto end; 559 } 560 561 switch (mask) { 562 case IIO_CHAN_INFO_SAMP_FREQ: 563 switch (chan->type) { 564 case IIO_PROXIMITY: 565 ret = vcnl4010_write_proxy_samp_freq(data, val, val2); 566 goto end; 567 default: 568 ret = -EINVAL; 569 goto end; 570 } 571 default: 572 ret = -EINVAL; 573 goto end; 574 } 575 576 end: 577 iio_device_release_direct_mode(indio_dev); 578 return ret; 579 } 580 581 static int vcnl4010_read_event(struct iio_dev *indio_dev, 582 const struct iio_chan_spec *chan, 583 enum iio_event_type type, 584 enum iio_event_direction dir, 585 enum iio_event_info info, 586 int *val, int *val2) 587 { 588 int ret; 589 struct vcnl4000_data *data = iio_priv(indio_dev); 590 591 switch (info) { 592 case IIO_EV_INFO_VALUE: 593 switch (dir) { 594 case IIO_EV_DIR_RISING: 595 ret = vcnl4000_read_data(data, VCNL4010_HIGH_THR_HI, 596 val); 597 if (ret < 0) 598 return ret; 599 return IIO_VAL_INT; 600 case IIO_EV_DIR_FALLING: 601 ret = vcnl4000_read_data(data, VCNL4010_LOW_THR_HI, 602 val); 603 if (ret < 0) 604 return ret; 605 return IIO_VAL_INT; 606 default: 607 return -EINVAL; 608 } 609 default: 610 return -EINVAL; 611 } 612 } 613 614 static int vcnl4010_write_event(struct iio_dev *indio_dev, 615 const struct iio_chan_spec *chan, 616 enum iio_event_type type, 617 enum iio_event_direction dir, 618 enum iio_event_info info, 619 int val, int val2) 620 { 621 int ret; 622 struct vcnl4000_data *data = iio_priv(indio_dev); 623 624 switch (info) { 625 case IIO_EV_INFO_VALUE: 626 switch (dir) { 627 case IIO_EV_DIR_RISING: 628 ret = vcnl4000_write_data(data, VCNL4010_HIGH_THR_HI, 629 val); 630 if (ret < 0) 631 return ret; 632 return IIO_VAL_INT; 633 case IIO_EV_DIR_FALLING: 634 ret = vcnl4000_write_data(data, VCNL4010_LOW_THR_HI, 635 val); 636 if (ret < 0) 637 return ret; 638 return IIO_VAL_INT; 639 default: 640 return -EINVAL; 641 } 642 default: 643 return -EINVAL; 644 } 645 } 646 647 static bool vcnl4010_is_thr_enabled(struct vcnl4000_data *data) 648 { 649 int ret; 650 651 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_INT_CTRL); 652 if (ret < 0) 653 return false; 654 655 return !!(ret & VCNL4010_INT_THR_EN); 656 } 657 658 static int vcnl4010_read_event_config(struct iio_dev *indio_dev, 659 const struct iio_chan_spec *chan, 660 enum iio_event_type type, 661 enum iio_event_direction dir) 662 { 663 struct vcnl4000_data *data = iio_priv(indio_dev); 664 665 switch (chan->type) { 666 case IIO_PROXIMITY: 667 return vcnl4010_is_thr_enabled(data); 668 default: 669 return -EINVAL; 670 } 671 } 672 673 static int vcnl4010_config_threshold(struct iio_dev *indio_dev, bool state) 674 { 675 struct vcnl4000_data *data = iio_priv(indio_dev); 676 int ret; 677 int icr; 678 int command; 679 680 if (state) { 681 ret = iio_device_claim_direct_mode(indio_dev); 682 if (ret) 683 return ret; 684 685 /* Enable periodic measurement of proximity data. */ 686 command = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN; 687 688 /* 689 * Enable interrupts on threshold, for proximity data by 690 * default. 691 */ 692 icr = VCNL4010_INT_THR_EN; 693 } else { 694 if (!vcnl4010_is_thr_enabled(data)) 695 return 0; 696 697 command = 0; 698 icr = 0; 699 } 700 701 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 702 command); 703 if (ret < 0) 704 goto end; 705 706 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, icr); 707 708 end: 709 if (state) 710 iio_device_release_direct_mode(indio_dev); 711 712 return ret; 713 } 714 715 static int vcnl4010_write_event_config(struct iio_dev *indio_dev, 716 const struct iio_chan_spec *chan, 717 enum iio_event_type type, 718 enum iio_event_direction dir, 719 int state) 720 { 721 switch (chan->type) { 722 case IIO_PROXIMITY: 723 return vcnl4010_config_threshold(indio_dev, state); 724 default: 725 return -EINVAL; 726 } 727 } 728 729 static ssize_t vcnl4000_read_near_level(struct iio_dev *indio_dev, 730 uintptr_t priv, 731 const struct iio_chan_spec *chan, 732 char *buf) 733 { 734 struct vcnl4000_data *data = iio_priv(indio_dev); 735 736 return sprintf(buf, "%u\n", data->near_level); 737 } 738 739 static const struct iio_chan_spec_ext_info vcnl4000_ext_info[] = { 740 { 741 .name = "nearlevel", 742 .shared = IIO_SEPARATE, 743 .read = vcnl4000_read_near_level, 744 }, 745 { /* sentinel */ } 746 }; 747 748 static const struct iio_event_spec vcnl4000_event_spec[] = { 749 { 750 .type = IIO_EV_TYPE_THRESH, 751 .dir = IIO_EV_DIR_RISING, 752 .mask_separate = BIT(IIO_EV_INFO_VALUE), 753 }, { 754 .type = IIO_EV_TYPE_THRESH, 755 .dir = IIO_EV_DIR_FALLING, 756 .mask_separate = BIT(IIO_EV_INFO_VALUE), 757 }, { 758 .type = IIO_EV_TYPE_THRESH, 759 .dir = IIO_EV_DIR_EITHER, 760 .mask_separate = BIT(IIO_EV_INFO_ENABLE), 761 } 762 }; 763 764 static const struct iio_chan_spec vcnl4000_channels[] = { 765 { 766 .type = IIO_LIGHT, 767 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 768 BIT(IIO_CHAN_INFO_SCALE), 769 }, { 770 .type = IIO_PROXIMITY, 771 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 772 .ext_info = vcnl4000_ext_info, 773 } 774 }; 775 776 static const struct iio_chan_spec vcnl4010_channels[] = { 777 { 778 .type = IIO_LIGHT, 779 .scan_index = -1, 780 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 781 BIT(IIO_CHAN_INFO_SCALE), 782 }, { 783 .type = IIO_PROXIMITY, 784 .scan_index = 0, 785 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 786 BIT(IIO_CHAN_INFO_SAMP_FREQ), 787 .info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ), 788 .event_spec = vcnl4000_event_spec, 789 .num_event_specs = ARRAY_SIZE(vcnl4000_event_spec), 790 .ext_info = vcnl4000_ext_info, 791 .scan_type = { 792 .sign = 'u', 793 .realbits = 16, 794 .storagebits = 16, 795 .endianness = IIO_CPU, 796 }, 797 }, 798 IIO_CHAN_SOFT_TIMESTAMP(1), 799 }; 800 801 static const struct iio_info vcnl4000_info = { 802 .read_raw = vcnl4000_read_raw, 803 }; 804 805 static const struct iio_info vcnl4010_info = { 806 .read_raw = vcnl4010_read_raw, 807 .read_avail = vcnl4010_read_avail, 808 .write_raw = vcnl4010_write_raw, 809 .read_event_value = vcnl4010_read_event, 810 .write_event_value = vcnl4010_write_event, 811 .read_event_config = vcnl4010_read_event_config, 812 .write_event_config = vcnl4010_write_event_config, 813 }; 814 815 static const struct vcnl4000_chip_spec vcnl4000_chip_spec_cfg[] = { 816 [VCNL4000] = { 817 .prod = "VCNL4000", 818 .init = vcnl4000_init, 819 .measure_light = vcnl4000_measure_light, 820 .measure_proximity = vcnl4000_measure_proximity, 821 .set_power_state = vcnl4000_set_power_state, 822 .channels = vcnl4000_channels, 823 .num_channels = ARRAY_SIZE(vcnl4000_channels), 824 .info = &vcnl4000_info, 825 .irq_support = false, 826 }, 827 [VCNL4010] = { 828 .prod = "VCNL4010/4020", 829 .init = vcnl4000_init, 830 .measure_light = vcnl4000_measure_light, 831 .measure_proximity = vcnl4000_measure_proximity, 832 .set_power_state = vcnl4000_set_power_state, 833 .channels = vcnl4010_channels, 834 .num_channels = ARRAY_SIZE(vcnl4010_channels), 835 .info = &vcnl4010_info, 836 .irq_support = true, 837 }, 838 [VCNL4040] = { 839 .prod = "VCNL4040", 840 .init = vcnl4200_init, 841 .measure_light = vcnl4200_measure_light, 842 .measure_proximity = vcnl4200_measure_proximity, 843 .set_power_state = vcnl4200_set_power_state, 844 .channels = vcnl4000_channels, 845 .num_channels = ARRAY_SIZE(vcnl4000_channels), 846 .info = &vcnl4000_info, 847 .irq_support = false, 848 }, 849 [VCNL4200] = { 850 .prod = "VCNL4200", 851 .init = vcnl4200_init, 852 .measure_light = vcnl4200_measure_light, 853 .measure_proximity = vcnl4200_measure_proximity, 854 .set_power_state = vcnl4200_set_power_state, 855 .channels = vcnl4000_channels, 856 .num_channels = ARRAY_SIZE(vcnl4000_channels), 857 .info = &vcnl4000_info, 858 .irq_support = false, 859 }, 860 }; 861 862 static irqreturn_t vcnl4010_irq_thread(int irq, void *p) 863 { 864 struct iio_dev *indio_dev = p; 865 struct vcnl4000_data *data = iio_priv(indio_dev); 866 unsigned long isr; 867 int ret; 868 869 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR); 870 if (ret < 0) 871 goto end; 872 873 isr = ret; 874 875 if (isr & VCNL4010_INT_THR) { 876 if (test_bit(VCNL4010_INT_THR_LOW, &isr)) { 877 iio_push_event(indio_dev, 878 IIO_UNMOD_EVENT_CODE( 879 IIO_PROXIMITY, 880 1, 881 IIO_EV_TYPE_THRESH, 882 IIO_EV_DIR_FALLING), 883 iio_get_time_ns(indio_dev)); 884 } 885 886 if (test_bit(VCNL4010_INT_THR_HIGH, &isr)) { 887 iio_push_event(indio_dev, 888 IIO_UNMOD_EVENT_CODE( 889 IIO_PROXIMITY, 890 1, 891 IIO_EV_TYPE_THRESH, 892 IIO_EV_DIR_RISING), 893 iio_get_time_ns(indio_dev)); 894 } 895 896 i2c_smbus_write_byte_data(data->client, VCNL4010_ISR, 897 isr & VCNL4010_INT_THR); 898 } 899 900 if (isr & VCNL4010_INT_DRDY && iio_buffer_enabled(indio_dev)) 901 iio_trigger_poll_chained(indio_dev->trig); 902 903 end: 904 return IRQ_HANDLED; 905 } 906 907 static irqreturn_t vcnl4010_trigger_handler(int irq, void *p) 908 { 909 struct iio_poll_func *pf = p; 910 struct iio_dev *indio_dev = pf->indio_dev; 911 struct vcnl4000_data *data = iio_priv(indio_dev); 912 const unsigned long *active_scan_mask = indio_dev->active_scan_mask; 913 u16 buffer[8] = {0}; /* 1x16-bit + ts */ 914 bool data_read = false; 915 unsigned long isr; 916 int val = 0; 917 int ret; 918 919 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR); 920 if (ret < 0) 921 goto end; 922 923 isr = ret; 924 925 if (test_bit(0, active_scan_mask)) { 926 if (test_bit(VCNL4010_INT_PROXIMITY, &isr)) { 927 ret = vcnl4000_read_data(data, 928 VCNL4000_PS_RESULT_HI, 929 &val); 930 if (ret < 0) 931 goto end; 932 933 buffer[0] = val; 934 data_read = true; 935 } 936 } 937 938 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_ISR, 939 isr & VCNL4010_INT_DRDY); 940 if (ret < 0) 941 goto end; 942 943 if (!data_read) 944 goto end; 945 946 iio_push_to_buffers_with_timestamp(indio_dev, buffer, 947 iio_get_time_ns(indio_dev)); 948 949 end: 950 iio_trigger_notify_done(indio_dev->trig); 951 return IRQ_HANDLED; 952 } 953 954 static int vcnl4010_buffer_postenable(struct iio_dev *indio_dev) 955 { 956 struct vcnl4000_data *data = iio_priv(indio_dev); 957 int ret; 958 int cmd; 959 960 /* Do not enable the buffer if we are already capturing events. */ 961 if (vcnl4010_is_in_periodic_mode(data)) 962 return -EBUSY; 963 964 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 965 VCNL4010_INT_PROX_EN); 966 if (ret < 0) 967 return ret; 968 969 cmd = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN; 970 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, cmd); 971 } 972 973 static int vcnl4010_buffer_predisable(struct iio_dev *indio_dev) 974 { 975 struct vcnl4000_data *data = iio_priv(indio_dev); 976 int ret; 977 978 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 0); 979 if (ret < 0) 980 return ret; 981 982 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0); 983 } 984 985 static const struct iio_buffer_setup_ops vcnl4010_buffer_ops = { 986 .postenable = &vcnl4010_buffer_postenable, 987 .predisable = &vcnl4010_buffer_predisable, 988 }; 989 990 static const struct iio_trigger_ops vcnl4010_trigger_ops = { 991 .validate_device = iio_trigger_validate_own_device, 992 }; 993 994 static int vcnl4010_probe_trigger(struct iio_dev *indio_dev) 995 { 996 struct vcnl4000_data *data = iio_priv(indio_dev); 997 struct i2c_client *client = data->client; 998 struct iio_trigger *trigger; 999 1000 trigger = devm_iio_trigger_alloc(&client->dev, "%s-dev%d", 1001 indio_dev->name, indio_dev->id); 1002 if (!trigger) 1003 return -ENOMEM; 1004 1005 trigger->dev.parent = &client->dev; 1006 trigger->ops = &vcnl4010_trigger_ops; 1007 iio_trigger_set_drvdata(trigger, indio_dev); 1008 1009 return devm_iio_trigger_register(&client->dev, trigger); 1010 } 1011 1012 static int vcnl4000_probe(struct i2c_client *client, 1013 const struct i2c_device_id *id) 1014 { 1015 struct vcnl4000_data *data; 1016 struct iio_dev *indio_dev; 1017 int ret; 1018 1019 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1020 if (!indio_dev) 1021 return -ENOMEM; 1022 1023 data = iio_priv(indio_dev); 1024 i2c_set_clientdata(client, indio_dev); 1025 data->client = client; 1026 data->id = id->driver_data; 1027 data->chip_spec = &vcnl4000_chip_spec_cfg[data->id]; 1028 1029 ret = data->chip_spec->init(data); 1030 if (ret < 0) 1031 return ret; 1032 1033 dev_dbg(&client->dev, "%s Ambient light/proximity sensor, Rev: %02x\n", 1034 data->chip_spec->prod, data->rev); 1035 1036 if (device_property_read_u32(&client->dev, "proximity-near-level", 1037 &data->near_level)) 1038 data->near_level = 0; 1039 1040 indio_dev->info = data->chip_spec->info; 1041 indio_dev->channels = data->chip_spec->channels; 1042 indio_dev->num_channels = data->chip_spec->num_channels; 1043 indio_dev->name = VCNL4000_DRV_NAME; 1044 indio_dev->modes = INDIO_DIRECT_MODE; 1045 1046 if (client->irq && data->chip_spec->irq_support) { 1047 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, 1048 NULL, 1049 vcnl4010_trigger_handler, 1050 &vcnl4010_buffer_ops); 1051 if (ret < 0) { 1052 dev_err(&client->dev, 1053 "unable to setup iio triggered buffer\n"); 1054 return ret; 1055 } 1056 1057 ret = devm_request_threaded_irq(&client->dev, client->irq, 1058 NULL, vcnl4010_irq_thread, 1059 IRQF_TRIGGER_FALLING | 1060 IRQF_ONESHOT, 1061 "vcnl4010_irq", 1062 indio_dev); 1063 if (ret < 0) { 1064 dev_err(&client->dev, "irq request failed\n"); 1065 return ret; 1066 } 1067 1068 ret = vcnl4010_probe_trigger(indio_dev); 1069 if (ret < 0) 1070 return ret; 1071 } 1072 1073 ret = pm_runtime_set_active(&client->dev); 1074 if (ret < 0) 1075 goto fail_poweroff; 1076 1077 ret = iio_device_register(indio_dev); 1078 if (ret < 0) 1079 goto fail_poweroff; 1080 1081 pm_runtime_enable(&client->dev); 1082 pm_runtime_set_autosuspend_delay(&client->dev, VCNL4000_SLEEP_DELAY_MS); 1083 pm_runtime_use_autosuspend(&client->dev); 1084 1085 return 0; 1086 fail_poweroff: 1087 data->chip_spec->set_power_state(data, false); 1088 return ret; 1089 } 1090 1091 static const struct of_device_id vcnl_4000_of_match[] = { 1092 { 1093 .compatible = "vishay,vcnl4000", 1094 .data = (void *)VCNL4000, 1095 }, 1096 { 1097 .compatible = "vishay,vcnl4010", 1098 .data = (void *)VCNL4010, 1099 }, 1100 { 1101 .compatible = "vishay,vcnl4020", 1102 .data = (void *)VCNL4010, 1103 }, 1104 { 1105 .compatible = "vishay,vcnl4040", 1106 .data = (void *)VCNL4040, 1107 }, 1108 { 1109 .compatible = "vishay,vcnl4200", 1110 .data = (void *)VCNL4200, 1111 }, 1112 {}, 1113 }; 1114 MODULE_DEVICE_TABLE(of, vcnl_4000_of_match); 1115 1116 static int vcnl4000_remove(struct i2c_client *client) 1117 { 1118 struct iio_dev *indio_dev = i2c_get_clientdata(client); 1119 struct vcnl4000_data *data = iio_priv(indio_dev); 1120 1121 pm_runtime_dont_use_autosuspend(&client->dev); 1122 pm_runtime_disable(&client->dev); 1123 iio_device_unregister(indio_dev); 1124 pm_runtime_set_suspended(&client->dev); 1125 1126 return data->chip_spec->set_power_state(data, false); 1127 } 1128 1129 static int __maybe_unused vcnl4000_runtime_suspend(struct device *dev) 1130 { 1131 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1132 struct vcnl4000_data *data = iio_priv(indio_dev); 1133 1134 return data->chip_spec->set_power_state(data, false); 1135 } 1136 1137 static int __maybe_unused vcnl4000_runtime_resume(struct device *dev) 1138 { 1139 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1140 struct vcnl4000_data *data = iio_priv(indio_dev); 1141 1142 return data->chip_spec->set_power_state(data, true); 1143 } 1144 1145 static const struct dev_pm_ops vcnl4000_pm_ops = { 1146 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 1147 pm_runtime_force_resume) 1148 SET_RUNTIME_PM_OPS(vcnl4000_runtime_suspend, 1149 vcnl4000_runtime_resume, NULL) 1150 }; 1151 1152 static struct i2c_driver vcnl4000_driver = { 1153 .driver = { 1154 .name = VCNL4000_DRV_NAME, 1155 .pm = &vcnl4000_pm_ops, 1156 .of_match_table = vcnl_4000_of_match, 1157 }, 1158 .probe = vcnl4000_probe, 1159 .id_table = vcnl4000_id, 1160 .remove = vcnl4000_remove, 1161 }; 1162 1163 module_i2c_driver(vcnl4000_driver); 1164 1165 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>"); 1166 MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>"); 1167 MODULE_DESCRIPTION("Vishay VCNL4000 proximity/ambient light sensor driver"); 1168 MODULE_LICENSE("GPL"); 1169