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/bitfield.h> 21 #include <linux/module.h> 22 #include <linux/i2c.h> 23 #include <linux/err.h> 24 #include <linux/delay.h> 25 #include <linux/pm_runtime.h> 26 #include <linux/interrupt.h> 27 #include <linux/units.h> 28 29 #include <linux/iio/buffer.h> 30 #include <linux/iio/events.h> 31 #include <linux/iio/iio.h> 32 #include <linux/iio/sysfs.h> 33 #include <linux/iio/trigger.h> 34 #include <linux/iio/trigger_consumer.h> 35 #include <linux/iio/triggered_buffer.h> 36 37 #define VCNL4000_DRV_NAME "vcnl4000" 38 #define VCNL4000_PROD_ID 0x01 39 #define VCNL4010_PROD_ID 0x02 /* for VCNL4020, VCNL4010 */ 40 #define VCNL4040_PROD_ID 0x86 41 #define VCNL4200_PROD_ID 0x58 42 43 #define VCNL4000_COMMAND 0x80 /* Command register */ 44 #define VCNL4000_PROD_REV 0x81 /* Product ID and Revision ID */ 45 #define VCNL4010_PROX_RATE 0x82 /* Proximity rate */ 46 #define VCNL4000_LED_CURRENT 0x83 /* IR LED current for proximity mode */ 47 #define VCNL4000_AL_PARAM 0x84 /* Ambient light parameter register */ 48 #define VCNL4010_ALS_PARAM 0x84 /* ALS rate */ 49 #define VCNL4000_AL_RESULT_HI 0x85 /* Ambient light result register, MSB */ 50 #define VCNL4000_AL_RESULT_LO 0x86 /* Ambient light result register, LSB */ 51 #define VCNL4000_PS_RESULT_HI 0x87 /* Proximity result register, MSB */ 52 #define VCNL4000_PS_RESULT_LO 0x88 /* Proximity result register, LSB */ 53 #define VCNL4000_PS_MEAS_FREQ 0x89 /* Proximity test signal frequency */ 54 #define VCNL4010_INT_CTRL 0x89 /* Interrupt control */ 55 #define VCNL4000_PS_MOD_ADJ 0x8a /* Proximity modulator timing adjustment */ 56 #define VCNL4010_LOW_THR_HI 0x8a /* Low threshold, MSB */ 57 #define VCNL4010_LOW_THR_LO 0x8b /* Low threshold, LSB */ 58 #define VCNL4010_HIGH_THR_HI 0x8c /* High threshold, MSB */ 59 #define VCNL4010_HIGH_THR_LO 0x8d /* High threshold, LSB */ 60 #define VCNL4010_ISR 0x8e /* Interrupt status */ 61 62 #define VCNL4200_AL_CONF 0x00 /* Ambient light configuration */ 63 #define VCNL4200_PS_CONF1 0x03 /* Proximity configuration */ 64 #define VCNL4200_PS_CONF3 0x04 /* Proximity configuration */ 65 #define VCNL4040_PS_THDL_LM 0x06 /* Proximity threshold low */ 66 #define VCNL4040_PS_THDH_LM 0x07 /* Proximity threshold high */ 67 #define VCNL4040_ALS_THDL_LM 0x02 /* Ambient light threshold low */ 68 #define VCNL4040_ALS_THDH_LM 0x01 /* Ambient light threshold high */ 69 #define VCNL4200_PS_DATA 0x08 /* Proximity data */ 70 #define VCNL4200_AL_DATA 0x09 /* Ambient light data */ 71 #define VCNL4040_INT_FLAGS 0x0b /* Interrupt register */ 72 #define VCNL4200_INT_FLAGS 0x0d /* Interrupt register */ 73 #define VCNL4200_DEV_ID 0x0e /* Device ID, slave address and version */ 74 75 #define VCNL4040_DEV_ID 0x0c /* Device ID and version */ 76 77 /* Bit masks for COMMAND register */ 78 #define VCNL4000_AL_RDY BIT(6) /* ALS data ready? */ 79 #define VCNL4000_PS_RDY BIT(5) /* proximity data ready? */ 80 #define VCNL4000_AL_OD BIT(4) /* start on-demand ALS measurement */ 81 #define VCNL4000_PS_OD BIT(3) /* start on-demand proximity measurement */ 82 #define VCNL4000_ALS_EN BIT(2) /* start ALS measurement */ 83 #define VCNL4000_PROX_EN BIT(1) /* start proximity measurement */ 84 #define VCNL4000_SELF_TIMED_EN BIT(0) /* start self-timed measurement */ 85 86 #define VCNL4040_ALS_CONF_ALS_SHUTDOWN BIT(0) 87 #define VCNL4040_ALS_CONF_IT GENMASK(7, 6) /* Ambient integration time */ 88 #define VCNL4040_ALS_CONF_INT_EN BIT(1) /* Ambient light Interrupt enable */ 89 #define VCNL4040_ALS_CONF_PERS GENMASK(3, 2) /* Ambient interrupt persistence setting */ 90 #define VCNL4040_PS_CONF1_PS_SHUTDOWN BIT(0) 91 #define VCNL4040_PS_CONF2_PS_IT GENMASK(3, 1) /* Proximity integration time */ 92 #define VCNL4040_CONF1_PS_PERS GENMASK(5, 4) /* Proximity interrupt persistence setting */ 93 #define VCNL4040_PS_CONF2_PS_INT GENMASK(9, 8) /* Proximity interrupt mode */ 94 #define VCNL4040_PS_CONF3_MPS GENMASK(6, 5) /* Proximity multi pulse number */ 95 #define VCNL4040_PS_MS_LED_I GENMASK(10, 8) /* Proximity current */ 96 #define VCNL4040_PS_IF_AWAY BIT(8) /* Proximity event cross low threshold */ 97 #define VCNL4040_PS_IF_CLOSE BIT(9) /* Proximity event cross high threshold */ 98 #define VCNL4040_ALS_RISING BIT(12) /* Ambient Light cross high threshold */ 99 #define VCNL4040_ALS_FALLING BIT(13) /* Ambient Light cross low threshold */ 100 101 /* Bit masks for interrupt registers. */ 102 #define VCNL4010_INT_THR_SEL BIT(0) /* Select threshold interrupt source */ 103 #define VCNL4010_INT_THR_EN BIT(1) /* Threshold interrupt type */ 104 #define VCNL4010_INT_ALS_EN BIT(2) /* Enable on ALS data ready */ 105 #define VCNL4010_INT_PROX_EN BIT(3) /* Enable on proximity data ready */ 106 107 #define VCNL4010_INT_THR_HIGH 0 /* High threshold exceeded */ 108 #define VCNL4010_INT_THR_LOW 1 /* Low threshold exceeded */ 109 #define VCNL4010_INT_ALS 2 /* ALS data ready */ 110 #define VCNL4010_INT_PROXIMITY 3 /* Proximity data ready */ 111 112 #define VCNL4010_INT_THR \ 113 (BIT(VCNL4010_INT_THR_LOW) | BIT(VCNL4010_INT_THR_HIGH)) 114 #define VCNL4010_INT_DRDY \ 115 (BIT(VCNL4010_INT_PROXIMITY) | BIT(VCNL4010_INT_ALS)) 116 117 static const int vcnl4010_prox_sampling_frequency[][2] = { 118 {1, 950000}, 119 {3, 906250}, 120 {7, 812500}, 121 {16, 625000}, 122 {31, 250000}, 123 {62, 500000}, 124 {125, 0}, 125 {250, 0}, 126 }; 127 128 static const int vcnl4040_ps_it_times[][2] = { 129 {0, 100}, 130 {0, 150}, 131 {0, 200}, 132 {0, 250}, 133 {0, 300}, 134 {0, 350}, 135 {0, 400}, 136 {0, 800}, 137 }; 138 139 static const int vcnl4200_ps_it_times[][2] = { 140 {0, 96}, 141 {0, 144}, 142 {0, 192}, 143 {0, 384}, 144 {0, 768}, 145 {0, 864}, 146 }; 147 148 static const int vcnl4040_als_it_times[][2] = { 149 {0, 80000}, 150 {0, 160000}, 151 {0, 320000}, 152 {0, 640000}, 153 }; 154 155 static const int vcnl4200_als_it_times[][2] = { 156 {0, 50000}, 157 {0, 100000}, 158 {0, 200000}, 159 {0, 400000}, 160 }; 161 162 static const int vcnl4040_ps_calibbias_ua[][2] = { 163 {0, 50000}, 164 {0, 75000}, 165 {0, 100000}, 166 {0, 120000}, 167 {0, 140000}, 168 {0, 160000}, 169 {0, 180000}, 170 {0, 200000}, 171 }; 172 173 static const int vcnl4040_als_persistence[] = {1, 2, 4, 8}; 174 static const int vcnl4040_ps_persistence[] = {1, 2, 3, 4}; 175 static const int vcnl4040_ps_oversampling_ratio[] = {1, 2, 4, 8}; 176 177 #define VCNL4000_SLEEP_DELAY_MS 2000 /* before we enter pm_runtime_suspend */ 178 179 enum vcnl4000_device_ids { 180 VCNL4000, 181 VCNL4010, 182 VCNL4040, 183 VCNL4200, 184 }; 185 186 struct vcnl4200_channel { 187 u8 reg; 188 ktime_t last_measurement; 189 ktime_t sampling_rate; 190 struct mutex lock; 191 }; 192 193 struct vcnl4000_data { 194 struct i2c_client *client; 195 enum vcnl4000_device_ids id; 196 int rev; 197 int al_scale; 198 u8 ps_int; /* proximity interrupt mode */ 199 u8 als_int; /* ambient light interrupt mode*/ 200 const struct vcnl4000_chip_spec *chip_spec; 201 struct mutex vcnl4000_lock; 202 struct vcnl4200_channel vcnl4200_al; 203 struct vcnl4200_channel vcnl4200_ps; 204 uint32_t near_level; 205 }; 206 207 struct vcnl4000_chip_spec { 208 const char *prod; 209 struct iio_chan_spec const *channels; 210 const int num_channels; 211 const struct iio_info *info; 212 const struct iio_buffer_setup_ops *buffer_setup_ops; 213 int (*init)(struct vcnl4000_data *data); 214 int (*measure_light)(struct vcnl4000_data *data, int *val); 215 int (*measure_proximity)(struct vcnl4000_data *data, int *val); 216 int (*set_power_state)(struct vcnl4000_data *data, bool on); 217 irqreturn_t (*irq_thread)(int irq, void *priv); 218 irqreturn_t (*trig_buffer_func)(int irq, void *priv); 219 220 u8 int_reg; 221 const int(*ps_it_times)[][2]; 222 const int num_ps_it_times; 223 const int(*als_it_times)[][2]; 224 const int num_als_it_times; 225 const unsigned int ulux_step; 226 }; 227 228 static const struct i2c_device_id vcnl4000_id[] = { 229 { "vcnl4000", VCNL4000 }, 230 { "vcnl4010", VCNL4010 }, 231 { "vcnl4020", VCNL4010 }, 232 { "vcnl4040", VCNL4040 }, 233 { "vcnl4200", VCNL4200 }, 234 { } 235 }; 236 MODULE_DEVICE_TABLE(i2c, vcnl4000_id); 237 238 static int vcnl4000_set_power_state(struct vcnl4000_data *data, bool on) 239 { 240 /* no suspend op */ 241 return 0; 242 } 243 244 static int vcnl4000_init(struct vcnl4000_data *data) 245 { 246 int ret, prod_id; 247 248 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_PROD_REV); 249 if (ret < 0) 250 return ret; 251 252 prod_id = ret >> 4; 253 switch (prod_id) { 254 case VCNL4000_PROD_ID: 255 if (data->id != VCNL4000) 256 dev_warn(&data->client->dev, 257 "wrong device id, use vcnl4000"); 258 break; 259 case VCNL4010_PROD_ID: 260 if (data->id != VCNL4010) 261 dev_warn(&data->client->dev, 262 "wrong device id, use vcnl4010/4020"); 263 break; 264 default: 265 return -ENODEV; 266 } 267 268 data->rev = ret & 0xf; 269 data->al_scale = 250000; 270 271 return data->chip_spec->set_power_state(data, true); 272 }; 273 274 static ssize_t vcnl4000_write_als_enable(struct vcnl4000_data *data, bool en) 275 { 276 int ret; 277 278 mutex_lock(&data->vcnl4000_lock); 279 280 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 281 if (ret < 0) 282 goto out; 283 284 if (en) 285 ret &= ~VCNL4040_ALS_CONF_ALS_SHUTDOWN; 286 else 287 ret |= VCNL4040_ALS_CONF_ALS_SHUTDOWN; 288 289 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF, ret); 290 291 out: 292 mutex_unlock(&data->vcnl4000_lock); 293 294 return ret; 295 } 296 297 static ssize_t vcnl4000_write_ps_enable(struct vcnl4000_data *data, bool en) 298 { 299 int ret; 300 301 mutex_lock(&data->vcnl4000_lock); 302 303 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 304 if (ret < 0) 305 goto out; 306 307 if (en) 308 ret &= ~VCNL4040_PS_CONF1_PS_SHUTDOWN; 309 else 310 ret |= VCNL4040_PS_CONF1_PS_SHUTDOWN; 311 312 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, ret); 313 314 out: 315 mutex_unlock(&data->vcnl4000_lock); 316 317 return ret; 318 } 319 320 static int vcnl4200_set_power_state(struct vcnl4000_data *data, bool on) 321 { 322 int ret; 323 324 /* Do not power down if interrupts are enabled */ 325 if (!on && (data->ps_int || data->als_int)) 326 return 0; 327 328 ret = vcnl4000_write_als_enable(data, on); 329 if (ret < 0) 330 return ret; 331 332 ret = vcnl4000_write_ps_enable(data, on); 333 if (ret < 0) 334 return ret; 335 336 if (on) { 337 /* Wait at least one integration cycle before fetching data */ 338 data->vcnl4200_al.last_measurement = ktime_get(); 339 data->vcnl4200_ps.last_measurement = ktime_get(); 340 } 341 342 return 0; 343 } 344 345 static int vcnl4200_init(struct vcnl4000_data *data) 346 { 347 int ret, id; 348 349 ret = i2c_smbus_read_word_data(data->client, VCNL4200_DEV_ID); 350 if (ret < 0) 351 return ret; 352 353 id = ret & 0xff; 354 355 if (id != VCNL4200_PROD_ID) { 356 ret = i2c_smbus_read_word_data(data->client, VCNL4040_DEV_ID); 357 if (ret < 0) 358 return ret; 359 360 id = ret & 0xff; 361 362 if (id != VCNL4040_PROD_ID) 363 return -ENODEV; 364 } 365 366 dev_dbg(&data->client->dev, "device id 0x%x", id); 367 368 data->rev = (ret >> 8) & 0xf; 369 data->ps_int = 0; 370 data->als_int = 0; 371 372 data->vcnl4200_al.reg = VCNL4200_AL_DATA; 373 data->vcnl4200_ps.reg = VCNL4200_PS_DATA; 374 switch (id) { 375 case VCNL4200_PROD_ID: 376 /* Default wait time is 50ms, add 20% tolerance. */ 377 data->vcnl4200_al.sampling_rate = ktime_set(0, 60000 * 1000); 378 /* Default wait time is 4.8ms, add 20% tolerance. */ 379 data->vcnl4200_ps.sampling_rate = ktime_set(0, 5760 * 1000); 380 break; 381 case VCNL4040_PROD_ID: 382 /* Default wait time is 80ms, add 20% tolerance. */ 383 data->vcnl4200_al.sampling_rate = ktime_set(0, 96000 * 1000); 384 /* Default wait time is 5ms, add 20% tolerance. */ 385 data->vcnl4200_ps.sampling_rate = ktime_set(0, 6000 * 1000); 386 break; 387 } 388 data->al_scale = data->chip_spec->ulux_step; 389 mutex_init(&data->vcnl4200_al.lock); 390 mutex_init(&data->vcnl4200_ps.lock); 391 392 ret = data->chip_spec->set_power_state(data, true); 393 if (ret < 0) 394 return ret; 395 396 return 0; 397 }; 398 399 static int vcnl4000_read_data(struct vcnl4000_data *data, u8 data_reg, int *val) 400 { 401 s32 ret; 402 403 ret = i2c_smbus_read_word_swapped(data->client, data_reg); 404 if (ret < 0) 405 return ret; 406 407 *val = ret; 408 return 0; 409 } 410 411 static int vcnl4000_write_data(struct vcnl4000_data *data, u8 data_reg, int val) 412 { 413 if (val > U16_MAX) 414 return -ERANGE; 415 416 return i2c_smbus_write_word_swapped(data->client, data_reg, val); 417 } 418 419 420 static int vcnl4000_measure(struct vcnl4000_data *data, u8 req_mask, 421 u8 rdy_mask, u8 data_reg, int *val) 422 { 423 int tries = 20; 424 int ret; 425 426 mutex_lock(&data->vcnl4000_lock); 427 428 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 429 req_mask); 430 if (ret < 0) 431 goto fail; 432 433 /* wait for data to become ready */ 434 while (tries--) { 435 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND); 436 if (ret < 0) 437 goto fail; 438 if (ret & rdy_mask) 439 break; 440 msleep(20); /* measurement takes up to 100 ms */ 441 } 442 443 if (tries < 0) { 444 dev_err(&data->client->dev, 445 "vcnl4000_measure() failed, data not ready\n"); 446 ret = -EIO; 447 goto fail; 448 } 449 450 ret = vcnl4000_read_data(data, data_reg, val); 451 if (ret < 0) 452 goto fail; 453 454 mutex_unlock(&data->vcnl4000_lock); 455 456 return 0; 457 458 fail: 459 mutex_unlock(&data->vcnl4000_lock); 460 return ret; 461 } 462 463 static int vcnl4200_measure(struct vcnl4000_data *data, 464 struct vcnl4200_channel *chan, int *val) 465 { 466 int ret; 467 s64 delta; 468 ktime_t next_measurement; 469 470 mutex_lock(&chan->lock); 471 472 next_measurement = ktime_add(chan->last_measurement, 473 chan->sampling_rate); 474 delta = ktime_us_delta(next_measurement, ktime_get()); 475 if (delta > 0) 476 usleep_range(delta, delta + 500); 477 chan->last_measurement = ktime_get(); 478 479 mutex_unlock(&chan->lock); 480 481 ret = i2c_smbus_read_word_data(data->client, chan->reg); 482 if (ret < 0) 483 return ret; 484 485 *val = ret; 486 487 return 0; 488 } 489 490 static int vcnl4000_measure_light(struct vcnl4000_data *data, int *val) 491 { 492 return vcnl4000_measure(data, 493 VCNL4000_AL_OD, VCNL4000_AL_RDY, 494 VCNL4000_AL_RESULT_HI, val); 495 } 496 497 static int vcnl4200_measure_light(struct vcnl4000_data *data, int *val) 498 { 499 return vcnl4200_measure(data, &data->vcnl4200_al, val); 500 } 501 502 static int vcnl4000_measure_proximity(struct vcnl4000_data *data, int *val) 503 { 504 return vcnl4000_measure(data, 505 VCNL4000_PS_OD, VCNL4000_PS_RDY, 506 VCNL4000_PS_RESULT_HI, val); 507 } 508 509 static int vcnl4200_measure_proximity(struct vcnl4000_data *data, int *val) 510 { 511 return vcnl4200_measure(data, &data->vcnl4200_ps, val); 512 } 513 514 static int vcnl4010_read_proxy_samp_freq(struct vcnl4000_data *data, int *val, 515 int *val2) 516 { 517 int ret; 518 519 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_PROX_RATE); 520 if (ret < 0) 521 return ret; 522 523 if (ret >= ARRAY_SIZE(vcnl4010_prox_sampling_frequency)) 524 return -EINVAL; 525 526 *val = vcnl4010_prox_sampling_frequency[ret][0]; 527 *val2 = vcnl4010_prox_sampling_frequency[ret][1]; 528 529 return 0; 530 } 531 532 static bool vcnl4010_is_in_periodic_mode(struct vcnl4000_data *data) 533 { 534 int ret; 535 536 ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND); 537 if (ret < 0) 538 return false; 539 540 return !!(ret & VCNL4000_SELF_TIMED_EN); 541 } 542 543 static int vcnl4000_set_pm_runtime_state(struct vcnl4000_data *data, bool on) 544 { 545 struct device *dev = &data->client->dev; 546 int ret; 547 548 if (on) { 549 ret = pm_runtime_resume_and_get(dev); 550 } else { 551 pm_runtime_mark_last_busy(dev); 552 ret = pm_runtime_put_autosuspend(dev); 553 } 554 555 return ret; 556 } 557 558 static int vcnl4040_read_als_it(struct vcnl4000_data *data, int *val, int *val2) 559 { 560 int ret; 561 562 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 563 if (ret < 0) 564 return ret; 565 566 ret = FIELD_GET(VCNL4040_ALS_CONF_IT, ret); 567 if (ret >= data->chip_spec->num_als_it_times) 568 return -EINVAL; 569 570 *val = (*data->chip_spec->als_it_times)[ret][0]; 571 *val2 = (*data->chip_spec->als_it_times)[ret][1]; 572 573 return 0; 574 } 575 576 static ssize_t vcnl4040_write_als_it(struct vcnl4000_data *data, int val) 577 { 578 unsigned int i; 579 int ret; 580 u16 regval; 581 582 for (i = 0; i < data->chip_spec->num_als_it_times; i++) { 583 if (val == (*data->chip_spec->als_it_times)[i][1]) 584 break; 585 } 586 587 if (i == data->chip_spec->num_als_it_times) 588 return -EINVAL; 589 590 data->vcnl4200_al.sampling_rate = ktime_set(0, val * 1200); 591 data->al_scale = div_u64(mul_u32_u32(data->chip_spec->ulux_step, 592 (*data->chip_spec->als_it_times)[0][1]), 593 val); 594 595 mutex_lock(&data->vcnl4000_lock); 596 597 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 598 if (ret < 0) 599 goto out_unlock; 600 601 regval = FIELD_PREP(VCNL4040_ALS_CONF_IT, i); 602 regval |= (ret & ~VCNL4040_ALS_CONF_IT); 603 ret = i2c_smbus_write_word_data(data->client, 604 VCNL4200_AL_CONF, 605 regval); 606 607 out_unlock: 608 mutex_unlock(&data->vcnl4000_lock); 609 return ret; 610 } 611 612 static int vcnl4040_read_ps_it(struct vcnl4000_data *data, int *val, int *val2) 613 { 614 int ret; 615 616 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 617 if (ret < 0) 618 return ret; 619 620 ret = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret); 621 622 if (ret >= data->chip_spec->num_ps_it_times) 623 return -EINVAL; 624 625 *val = (*data->chip_spec->ps_it_times)[ret][0]; 626 *val2 = (*data->chip_spec->ps_it_times)[ret][1]; 627 628 return 0; 629 } 630 631 static ssize_t vcnl4040_write_ps_it(struct vcnl4000_data *data, int val) 632 { 633 unsigned int i; 634 int ret, index = -1; 635 u16 regval; 636 637 for (i = 0; i < data->chip_spec->num_ps_it_times; i++) { 638 if (val == (*data->chip_spec->ps_it_times)[i][1]) { 639 index = i; 640 break; 641 } 642 } 643 644 if (index < 0) 645 return -EINVAL; 646 647 data->vcnl4200_ps.sampling_rate = ktime_set(0, val * 60 * NSEC_PER_USEC); 648 649 mutex_lock(&data->vcnl4000_lock); 650 651 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 652 if (ret < 0) 653 goto out; 654 655 regval = (ret & ~VCNL4040_PS_CONF2_PS_IT) | 656 FIELD_PREP(VCNL4040_PS_CONF2_PS_IT, index); 657 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, 658 regval); 659 660 out: 661 mutex_unlock(&data->vcnl4000_lock); 662 return ret; 663 } 664 665 static ssize_t vcnl4040_read_als_period(struct vcnl4000_data *data, int *val, int *val2) 666 { 667 int ret, ret_pers, it; 668 int64_t val_c; 669 670 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 671 if (ret < 0) 672 return ret; 673 674 ret_pers = FIELD_GET(VCNL4040_ALS_CONF_PERS, ret); 675 if (ret_pers >= ARRAY_SIZE(vcnl4040_als_persistence)) 676 return -EINVAL; 677 678 it = FIELD_GET(VCNL4040_ALS_CONF_IT, ret); 679 if (it >= data->chip_spec->num_als_it_times) 680 return -EINVAL; 681 682 val_c = mul_u32_u32((*data->chip_spec->als_it_times)[it][1], 683 vcnl4040_als_persistence[ret_pers]); 684 *val = div_u64_rem(val_c, MICRO, val2); 685 686 return IIO_VAL_INT_PLUS_MICRO; 687 } 688 689 static ssize_t vcnl4040_write_als_period(struct vcnl4000_data *data, int val, int val2) 690 { 691 unsigned int i; 692 int ret, it; 693 u16 regval; 694 u64 val_n = mul_u32_u32(val, MICRO) + val2; 695 696 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 697 if (ret < 0) 698 return ret; 699 700 it = FIELD_GET(VCNL4040_ALS_CONF_IT, ret); 701 if (it >= data->chip_spec->num_als_it_times) 702 return -EINVAL; 703 704 for (i = 0; i < ARRAY_SIZE(vcnl4040_als_persistence) - 1; i++) { 705 if (val_n < mul_u32_u32(vcnl4040_als_persistence[i], 706 (*data->chip_spec->als_it_times)[it][1])) 707 break; 708 } 709 710 mutex_lock(&data->vcnl4000_lock); 711 712 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 713 if (ret < 0) 714 goto out_unlock; 715 716 regval = FIELD_PREP(VCNL4040_ALS_CONF_PERS, i); 717 regval |= (ret & ~VCNL4040_ALS_CONF_PERS); 718 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF, 719 regval); 720 721 out_unlock: 722 mutex_unlock(&data->vcnl4000_lock); 723 return ret; 724 } 725 726 static ssize_t vcnl4040_read_ps_period(struct vcnl4000_data *data, int *val, int *val2) 727 { 728 int ret, ret_pers, it; 729 730 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 731 if (ret < 0) 732 return ret; 733 734 ret_pers = FIELD_GET(VCNL4040_CONF1_PS_PERS, ret); 735 if (ret_pers >= ARRAY_SIZE(vcnl4040_ps_persistence)) 736 return -EINVAL; 737 738 it = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret); 739 if (it >= data->chip_spec->num_ps_it_times) 740 return -EINVAL; 741 742 *val = (*data->chip_spec->ps_it_times)[it][0]; 743 *val2 = (*data->chip_spec->ps_it_times)[it][1] * 744 vcnl4040_ps_persistence[ret_pers]; 745 746 return IIO_VAL_INT_PLUS_MICRO; 747 } 748 749 static ssize_t vcnl4040_write_ps_period(struct vcnl4000_data *data, int val, int val2) 750 { 751 int ret, it, i; 752 u16 regval; 753 754 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 755 if (ret < 0) 756 return ret; 757 758 it = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret); 759 if (it >= data->chip_spec->num_ps_it_times) 760 return -EINVAL; 761 762 if (val > 0) 763 i = ARRAY_SIZE(vcnl4040_ps_persistence) - 1; 764 else { 765 for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_persistence) - 1; i++) { 766 if (val2 <= vcnl4040_ps_persistence[i] * 767 (*data->chip_spec->ps_it_times)[it][1]) 768 break; 769 } 770 } 771 772 mutex_lock(&data->vcnl4000_lock); 773 774 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 775 if (ret < 0) 776 goto out_unlock; 777 778 regval = FIELD_PREP(VCNL4040_CONF1_PS_PERS, i); 779 regval |= (ret & ~VCNL4040_CONF1_PS_PERS); 780 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, 781 regval); 782 783 out_unlock: 784 mutex_unlock(&data->vcnl4000_lock); 785 return ret; 786 } 787 788 static ssize_t vcnl4040_read_ps_oversampling_ratio(struct vcnl4000_data *data, int *val) 789 { 790 int ret; 791 792 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3); 793 if (ret < 0) 794 return ret; 795 796 ret = FIELD_GET(VCNL4040_PS_CONF3_MPS, ret); 797 if (ret >= ARRAY_SIZE(vcnl4040_ps_oversampling_ratio)) 798 return -EINVAL; 799 800 *val = vcnl4040_ps_oversampling_ratio[ret]; 801 802 return ret; 803 } 804 805 static ssize_t vcnl4040_write_ps_oversampling_ratio(struct vcnl4000_data *data, int val) 806 { 807 unsigned int i; 808 int ret; 809 u16 regval; 810 811 for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_oversampling_ratio); i++) { 812 if (val == vcnl4040_ps_oversampling_ratio[i]) 813 break; 814 } 815 816 if (i >= ARRAY_SIZE(vcnl4040_ps_oversampling_ratio)) 817 return -EINVAL; 818 819 mutex_lock(&data->vcnl4000_lock); 820 821 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3); 822 if (ret < 0) 823 goto out_unlock; 824 825 regval = FIELD_PREP(VCNL4040_PS_CONF3_MPS, i); 826 regval |= (ret & ~VCNL4040_PS_CONF3_MPS); 827 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF3, 828 regval); 829 830 out_unlock: 831 mutex_unlock(&data->vcnl4000_lock); 832 return ret; 833 } 834 835 static ssize_t vcnl4040_read_ps_calibbias(struct vcnl4000_data *data, int *val, int *val2) 836 { 837 int ret; 838 839 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3); 840 if (ret < 0) 841 return ret; 842 843 ret = FIELD_GET(VCNL4040_PS_MS_LED_I, ret); 844 if (ret >= ARRAY_SIZE(vcnl4040_ps_calibbias_ua)) 845 return -EINVAL; 846 847 *val = vcnl4040_ps_calibbias_ua[ret][0]; 848 *val2 = vcnl4040_ps_calibbias_ua[ret][1]; 849 850 return ret; 851 } 852 853 static ssize_t vcnl4040_write_ps_calibbias(struct vcnl4000_data *data, int val) 854 { 855 unsigned int i; 856 int ret; 857 u16 regval; 858 859 for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_calibbias_ua); i++) { 860 if (val == vcnl4040_ps_calibbias_ua[i][1]) 861 break; 862 } 863 864 if (i >= ARRAY_SIZE(vcnl4040_ps_calibbias_ua)) 865 return -EINVAL; 866 867 mutex_lock(&data->vcnl4000_lock); 868 869 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF3); 870 if (ret < 0) 871 goto out_unlock; 872 873 regval = (ret & ~VCNL4040_PS_MS_LED_I); 874 regval |= FIELD_PREP(VCNL4040_PS_MS_LED_I, i); 875 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF3, 876 regval); 877 878 out_unlock: 879 mutex_unlock(&data->vcnl4000_lock); 880 return ret; 881 } 882 883 static int vcnl4000_read_raw(struct iio_dev *indio_dev, 884 struct iio_chan_spec const *chan, 885 int *val, int *val2, long mask) 886 { 887 int ret; 888 struct vcnl4000_data *data = iio_priv(indio_dev); 889 890 switch (mask) { 891 case IIO_CHAN_INFO_RAW: 892 ret = vcnl4000_set_pm_runtime_state(data, true); 893 if (ret < 0) 894 return ret; 895 896 switch (chan->type) { 897 case IIO_LIGHT: 898 ret = data->chip_spec->measure_light(data, val); 899 if (!ret) 900 ret = IIO_VAL_INT; 901 break; 902 case IIO_PROXIMITY: 903 ret = data->chip_spec->measure_proximity(data, val); 904 if (!ret) 905 ret = IIO_VAL_INT; 906 break; 907 default: 908 ret = -EINVAL; 909 } 910 vcnl4000_set_pm_runtime_state(data, false); 911 return ret; 912 case IIO_CHAN_INFO_SCALE: 913 if (chan->type != IIO_LIGHT) 914 return -EINVAL; 915 916 *val = 0; 917 *val2 = data->al_scale; 918 return IIO_VAL_INT_PLUS_MICRO; 919 case IIO_CHAN_INFO_INT_TIME: 920 switch (chan->type) { 921 case IIO_LIGHT: 922 ret = vcnl4040_read_als_it(data, val, val2); 923 break; 924 case IIO_PROXIMITY: 925 ret = vcnl4040_read_ps_it(data, val, val2); 926 break; 927 default: 928 return -EINVAL; 929 } 930 if (ret < 0) 931 return ret; 932 return IIO_VAL_INT_PLUS_MICRO; 933 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 934 switch (chan->type) { 935 case IIO_PROXIMITY: 936 ret = vcnl4040_read_ps_oversampling_ratio(data, val); 937 if (ret < 0) 938 return ret; 939 return IIO_VAL_INT; 940 default: 941 return -EINVAL; 942 } 943 case IIO_CHAN_INFO_CALIBBIAS: 944 switch (chan->type) { 945 case IIO_PROXIMITY: 946 ret = vcnl4040_read_ps_calibbias(data, val, val2); 947 if (ret < 0) 948 return ret; 949 return IIO_VAL_INT_PLUS_MICRO; 950 default: 951 return -EINVAL; 952 } 953 default: 954 return -EINVAL; 955 } 956 } 957 958 static int vcnl4040_write_raw(struct iio_dev *indio_dev, 959 struct iio_chan_spec const *chan, 960 int val, int val2, long mask) 961 { 962 struct vcnl4000_data *data = iio_priv(indio_dev); 963 964 switch (mask) { 965 case IIO_CHAN_INFO_INT_TIME: 966 if (val != 0) 967 return -EINVAL; 968 switch (chan->type) { 969 case IIO_LIGHT: 970 return vcnl4040_write_als_it(data, val2); 971 case IIO_PROXIMITY: 972 return vcnl4040_write_ps_it(data, val2); 973 default: 974 return -EINVAL; 975 } 976 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 977 switch (chan->type) { 978 case IIO_PROXIMITY: 979 return vcnl4040_write_ps_oversampling_ratio(data, val); 980 default: 981 return -EINVAL; 982 } 983 case IIO_CHAN_INFO_CALIBBIAS: 984 switch (chan->type) { 985 case IIO_PROXIMITY: 986 return vcnl4040_write_ps_calibbias(data, val2); 987 default: 988 return -EINVAL; 989 } 990 default: 991 return -EINVAL; 992 } 993 } 994 995 static int vcnl4040_read_avail(struct iio_dev *indio_dev, 996 struct iio_chan_spec const *chan, 997 const int **vals, int *type, int *length, 998 long mask) 999 { 1000 struct vcnl4000_data *data = iio_priv(indio_dev); 1001 1002 switch (mask) { 1003 case IIO_CHAN_INFO_INT_TIME: 1004 switch (chan->type) { 1005 case IIO_LIGHT: 1006 *vals = (int *)(*data->chip_spec->als_it_times); 1007 *length = 2 * data->chip_spec->num_als_it_times; 1008 break; 1009 case IIO_PROXIMITY: 1010 *vals = (int *)(*data->chip_spec->ps_it_times); 1011 *length = 2 * data->chip_spec->num_ps_it_times; 1012 break; 1013 default: 1014 return -EINVAL; 1015 } 1016 *type = IIO_VAL_INT_PLUS_MICRO; 1017 return IIO_AVAIL_LIST; 1018 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 1019 switch (chan->type) { 1020 case IIO_PROXIMITY: 1021 *vals = (int *)vcnl4040_ps_oversampling_ratio; 1022 *length = ARRAY_SIZE(vcnl4040_ps_oversampling_ratio); 1023 *type = IIO_VAL_INT; 1024 return IIO_AVAIL_LIST; 1025 default: 1026 return -EINVAL; 1027 } 1028 case IIO_CHAN_INFO_CALIBBIAS: 1029 switch (chan->type) { 1030 case IIO_PROXIMITY: 1031 *vals = (int *)vcnl4040_ps_calibbias_ua; 1032 *length = 2 * ARRAY_SIZE(vcnl4040_ps_calibbias_ua); 1033 *type = IIO_VAL_INT_PLUS_MICRO; 1034 return IIO_AVAIL_LIST; 1035 default: 1036 return -EINVAL; 1037 } 1038 default: 1039 return -EINVAL; 1040 } 1041 } 1042 1043 static int vcnl4010_read_raw(struct iio_dev *indio_dev, 1044 struct iio_chan_spec const *chan, 1045 int *val, int *val2, long mask) 1046 { 1047 int ret; 1048 struct vcnl4000_data *data = iio_priv(indio_dev); 1049 1050 switch (mask) { 1051 case IIO_CHAN_INFO_RAW: 1052 case IIO_CHAN_INFO_SCALE: 1053 ret = iio_device_claim_direct_mode(indio_dev); 1054 if (ret) 1055 return ret; 1056 1057 /* Protect against event capture. */ 1058 if (vcnl4010_is_in_periodic_mode(data)) { 1059 ret = -EBUSY; 1060 } else { 1061 ret = vcnl4000_read_raw(indio_dev, chan, val, val2, 1062 mask); 1063 } 1064 1065 iio_device_release_direct_mode(indio_dev); 1066 return ret; 1067 case IIO_CHAN_INFO_SAMP_FREQ: 1068 switch (chan->type) { 1069 case IIO_PROXIMITY: 1070 ret = vcnl4010_read_proxy_samp_freq(data, val, val2); 1071 if (ret < 0) 1072 return ret; 1073 return IIO_VAL_INT_PLUS_MICRO; 1074 default: 1075 return -EINVAL; 1076 } 1077 default: 1078 return -EINVAL; 1079 } 1080 } 1081 1082 static int vcnl4010_read_avail(struct iio_dev *indio_dev, 1083 struct iio_chan_spec const *chan, 1084 const int **vals, int *type, int *length, 1085 long mask) 1086 { 1087 switch (mask) { 1088 case IIO_CHAN_INFO_SAMP_FREQ: 1089 *vals = (int *)vcnl4010_prox_sampling_frequency; 1090 *type = IIO_VAL_INT_PLUS_MICRO; 1091 *length = 2 * ARRAY_SIZE(vcnl4010_prox_sampling_frequency); 1092 return IIO_AVAIL_LIST; 1093 default: 1094 return -EINVAL; 1095 } 1096 } 1097 1098 static int vcnl4010_write_proxy_samp_freq(struct vcnl4000_data *data, int val, 1099 int val2) 1100 { 1101 unsigned int i; 1102 int index = -1; 1103 1104 for (i = 0; i < ARRAY_SIZE(vcnl4010_prox_sampling_frequency); i++) { 1105 if (val == vcnl4010_prox_sampling_frequency[i][0] && 1106 val2 == vcnl4010_prox_sampling_frequency[i][1]) { 1107 index = i; 1108 break; 1109 } 1110 } 1111 1112 if (index < 0) 1113 return -EINVAL; 1114 1115 return i2c_smbus_write_byte_data(data->client, VCNL4010_PROX_RATE, 1116 index); 1117 } 1118 1119 static int vcnl4010_write_raw(struct iio_dev *indio_dev, 1120 struct iio_chan_spec const *chan, 1121 int val, int val2, long mask) 1122 { 1123 int ret; 1124 struct vcnl4000_data *data = iio_priv(indio_dev); 1125 1126 ret = iio_device_claim_direct_mode(indio_dev); 1127 if (ret) 1128 return ret; 1129 1130 /* Protect against event capture. */ 1131 if (vcnl4010_is_in_periodic_mode(data)) { 1132 ret = -EBUSY; 1133 goto end; 1134 } 1135 1136 switch (mask) { 1137 case IIO_CHAN_INFO_SAMP_FREQ: 1138 switch (chan->type) { 1139 case IIO_PROXIMITY: 1140 ret = vcnl4010_write_proxy_samp_freq(data, val, val2); 1141 goto end; 1142 default: 1143 ret = -EINVAL; 1144 goto end; 1145 } 1146 default: 1147 ret = -EINVAL; 1148 goto end; 1149 } 1150 1151 end: 1152 iio_device_release_direct_mode(indio_dev); 1153 return ret; 1154 } 1155 1156 static int vcnl4010_read_event(struct iio_dev *indio_dev, 1157 const struct iio_chan_spec *chan, 1158 enum iio_event_type type, 1159 enum iio_event_direction dir, 1160 enum iio_event_info info, 1161 int *val, int *val2) 1162 { 1163 int ret; 1164 struct vcnl4000_data *data = iio_priv(indio_dev); 1165 1166 switch (info) { 1167 case IIO_EV_INFO_VALUE: 1168 switch (dir) { 1169 case IIO_EV_DIR_RISING: 1170 ret = vcnl4000_read_data(data, VCNL4010_HIGH_THR_HI, 1171 val); 1172 if (ret < 0) 1173 return ret; 1174 return IIO_VAL_INT; 1175 case IIO_EV_DIR_FALLING: 1176 ret = vcnl4000_read_data(data, VCNL4010_LOW_THR_HI, 1177 val); 1178 if (ret < 0) 1179 return ret; 1180 return IIO_VAL_INT; 1181 default: 1182 return -EINVAL; 1183 } 1184 default: 1185 return -EINVAL; 1186 } 1187 } 1188 1189 static int vcnl4010_write_event(struct iio_dev *indio_dev, 1190 const struct iio_chan_spec *chan, 1191 enum iio_event_type type, 1192 enum iio_event_direction dir, 1193 enum iio_event_info info, 1194 int val, int val2) 1195 { 1196 int ret; 1197 struct vcnl4000_data *data = iio_priv(indio_dev); 1198 1199 switch (info) { 1200 case IIO_EV_INFO_VALUE: 1201 switch (dir) { 1202 case IIO_EV_DIR_RISING: 1203 ret = vcnl4000_write_data(data, VCNL4010_HIGH_THR_HI, 1204 val); 1205 if (ret < 0) 1206 return ret; 1207 return IIO_VAL_INT; 1208 case IIO_EV_DIR_FALLING: 1209 ret = vcnl4000_write_data(data, VCNL4010_LOW_THR_HI, 1210 val); 1211 if (ret < 0) 1212 return ret; 1213 return IIO_VAL_INT; 1214 default: 1215 return -EINVAL; 1216 } 1217 default: 1218 return -EINVAL; 1219 } 1220 } 1221 1222 static int vcnl4040_read_event(struct iio_dev *indio_dev, 1223 const struct iio_chan_spec *chan, 1224 enum iio_event_type type, 1225 enum iio_event_direction dir, 1226 enum iio_event_info info, 1227 int *val, int *val2) 1228 { 1229 int ret; 1230 struct vcnl4000_data *data = iio_priv(indio_dev); 1231 1232 switch (chan->type) { 1233 case IIO_LIGHT: 1234 switch (info) { 1235 case IIO_EV_INFO_PERIOD: 1236 return vcnl4040_read_als_period(data, val, val2); 1237 case IIO_EV_INFO_VALUE: 1238 switch (dir) { 1239 case IIO_EV_DIR_RISING: 1240 ret = i2c_smbus_read_word_data(data->client, 1241 VCNL4040_ALS_THDH_LM); 1242 break; 1243 case IIO_EV_DIR_FALLING: 1244 ret = i2c_smbus_read_word_data(data->client, 1245 VCNL4040_ALS_THDL_LM); 1246 break; 1247 default: 1248 return -EINVAL; 1249 } 1250 break; 1251 default: 1252 return -EINVAL; 1253 } 1254 break; 1255 case IIO_PROXIMITY: 1256 switch (info) { 1257 case IIO_EV_INFO_PERIOD: 1258 return vcnl4040_read_ps_period(data, val, val2); 1259 case IIO_EV_INFO_VALUE: 1260 switch (dir) { 1261 case IIO_EV_DIR_RISING: 1262 ret = i2c_smbus_read_word_data(data->client, 1263 VCNL4040_PS_THDH_LM); 1264 break; 1265 case IIO_EV_DIR_FALLING: 1266 ret = i2c_smbus_read_word_data(data->client, 1267 VCNL4040_PS_THDL_LM); 1268 break; 1269 default: 1270 return -EINVAL; 1271 } 1272 break; 1273 default: 1274 return -EINVAL; 1275 } 1276 break; 1277 default: 1278 return -EINVAL; 1279 } 1280 if (ret < 0) 1281 return ret; 1282 *val = ret; 1283 return IIO_VAL_INT; 1284 } 1285 1286 static int vcnl4040_write_event(struct iio_dev *indio_dev, 1287 const struct iio_chan_spec *chan, 1288 enum iio_event_type type, 1289 enum iio_event_direction dir, 1290 enum iio_event_info info, 1291 int val, int val2) 1292 { 1293 int ret; 1294 struct vcnl4000_data *data = iio_priv(indio_dev); 1295 1296 switch (chan->type) { 1297 case IIO_LIGHT: 1298 switch (info) { 1299 case IIO_EV_INFO_PERIOD: 1300 return vcnl4040_write_als_period(data, val, val2); 1301 case IIO_EV_INFO_VALUE: 1302 switch (dir) { 1303 case IIO_EV_DIR_RISING: 1304 ret = i2c_smbus_write_word_data(data->client, 1305 VCNL4040_ALS_THDH_LM, 1306 val); 1307 break; 1308 case IIO_EV_DIR_FALLING: 1309 ret = i2c_smbus_write_word_data(data->client, 1310 VCNL4040_ALS_THDL_LM, 1311 val); 1312 break; 1313 default: 1314 return -EINVAL; 1315 } 1316 break; 1317 default: 1318 return -EINVAL; 1319 } 1320 break; 1321 case IIO_PROXIMITY: 1322 switch (info) { 1323 case IIO_EV_INFO_PERIOD: 1324 return vcnl4040_write_ps_period(data, val, val2); 1325 case IIO_EV_INFO_VALUE: 1326 switch (dir) { 1327 case IIO_EV_DIR_RISING: 1328 ret = i2c_smbus_write_word_data(data->client, 1329 VCNL4040_PS_THDH_LM, 1330 val); 1331 break; 1332 case IIO_EV_DIR_FALLING: 1333 ret = i2c_smbus_write_word_data(data->client, 1334 VCNL4040_PS_THDL_LM, 1335 val); 1336 break; 1337 default: 1338 return -EINVAL; 1339 } 1340 break; 1341 default: 1342 return -EINVAL; 1343 } 1344 break; 1345 default: 1346 return -EINVAL; 1347 } 1348 if (ret < 0) 1349 return ret; 1350 return IIO_VAL_INT; 1351 } 1352 1353 static bool vcnl4010_is_thr_enabled(struct vcnl4000_data *data) 1354 { 1355 int ret; 1356 1357 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_INT_CTRL); 1358 if (ret < 0) 1359 return false; 1360 1361 return !!(ret & VCNL4010_INT_THR_EN); 1362 } 1363 1364 static int vcnl4010_read_event_config(struct iio_dev *indio_dev, 1365 const struct iio_chan_spec *chan, 1366 enum iio_event_type type, 1367 enum iio_event_direction dir) 1368 { 1369 struct vcnl4000_data *data = iio_priv(indio_dev); 1370 1371 switch (chan->type) { 1372 case IIO_PROXIMITY: 1373 return vcnl4010_is_thr_enabled(data); 1374 default: 1375 return -EINVAL; 1376 } 1377 } 1378 1379 static int vcnl4010_config_threshold(struct iio_dev *indio_dev, bool state) 1380 { 1381 struct vcnl4000_data *data = iio_priv(indio_dev); 1382 int ret; 1383 int icr; 1384 int command; 1385 1386 if (state) { 1387 ret = iio_device_claim_direct_mode(indio_dev); 1388 if (ret) 1389 return ret; 1390 1391 /* Enable periodic measurement of proximity data. */ 1392 command = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN; 1393 1394 /* 1395 * Enable interrupts on threshold, for proximity data by 1396 * default. 1397 */ 1398 icr = VCNL4010_INT_THR_EN; 1399 } else { 1400 if (!vcnl4010_is_thr_enabled(data)) 1401 return 0; 1402 1403 command = 0; 1404 icr = 0; 1405 } 1406 1407 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 1408 command); 1409 if (ret < 0) 1410 goto end; 1411 1412 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, icr); 1413 1414 end: 1415 if (state) 1416 iio_device_release_direct_mode(indio_dev); 1417 1418 return ret; 1419 } 1420 1421 static int vcnl4010_write_event_config(struct iio_dev *indio_dev, 1422 const struct iio_chan_spec *chan, 1423 enum iio_event_type type, 1424 enum iio_event_direction dir, 1425 int state) 1426 { 1427 switch (chan->type) { 1428 case IIO_PROXIMITY: 1429 return vcnl4010_config_threshold(indio_dev, state); 1430 default: 1431 return -EINVAL; 1432 } 1433 } 1434 1435 static int vcnl4040_read_event_config(struct iio_dev *indio_dev, 1436 const struct iio_chan_spec *chan, 1437 enum iio_event_type type, 1438 enum iio_event_direction dir) 1439 { 1440 int ret; 1441 struct vcnl4000_data *data = iio_priv(indio_dev); 1442 1443 switch (chan->type) { 1444 case IIO_LIGHT: 1445 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 1446 if (ret < 0) 1447 return ret; 1448 1449 data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, ret); 1450 1451 return data->als_int; 1452 case IIO_PROXIMITY: 1453 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 1454 if (ret < 0) 1455 return ret; 1456 1457 data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, ret); 1458 1459 return (dir == IIO_EV_DIR_RISING) ? 1460 FIELD_GET(VCNL4040_PS_IF_AWAY, ret) : 1461 FIELD_GET(VCNL4040_PS_IF_CLOSE, ret); 1462 default: 1463 return -EINVAL; 1464 } 1465 } 1466 1467 static int vcnl4040_write_event_config(struct iio_dev *indio_dev, 1468 const struct iio_chan_spec *chan, 1469 enum iio_event_type type, 1470 enum iio_event_direction dir, int state) 1471 { 1472 int ret = -EINVAL; 1473 u16 val, mask; 1474 struct vcnl4000_data *data = iio_priv(indio_dev); 1475 1476 mutex_lock(&data->vcnl4000_lock); 1477 1478 switch (chan->type) { 1479 case IIO_LIGHT: 1480 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 1481 if (ret < 0) 1482 goto out; 1483 1484 mask = VCNL4040_ALS_CONF_INT_EN; 1485 if (state) 1486 val = (ret | mask); 1487 else 1488 val = (ret & ~mask); 1489 1490 data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, val); 1491 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF, 1492 val); 1493 break; 1494 case IIO_PROXIMITY: 1495 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 1496 if (ret < 0) 1497 goto out; 1498 1499 if (dir == IIO_EV_DIR_RISING) 1500 mask = VCNL4040_PS_IF_AWAY; 1501 else 1502 mask = VCNL4040_PS_IF_CLOSE; 1503 1504 val = state ? (ret | mask) : (ret & ~mask); 1505 1506 data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, val); 1507 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, 1508 val); 1509 break; 1510 default: 1511 break; 1512 } 1513 1514 out: 1515 mutex_unlock(&data->vcnl4000_lock); 1516 1517 return ret; 1518 } 1519 1520 static irqreturn_t vcnl4040_irq_thread(int irq, void *p) 1521 { 1522 struct iio_dev *indio_dev = p; 1523 struct vcnl4000_data *data = iio_priv(indio_dev); 1524 int ret; 1525 1526 ret = i2c_smbus_read_word_data(data->client, data->chip_spec->int_reg); 1527 if (ret < 0) 1528 return IRQ_HANDLED; 1529 1530 if (ret & VCNL4040_PS_IF_CLOSE) { 1531 iio_push_event(indio_dev, 1532 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0, 1533 IIO_EV_TYPE_THRESH, 1534 IIO_EV_DIR_RISING), 1535 iio_get_time_ns(indio_dev)); 1536 } 1537 1538 if (ret & VCNL4040_PS_IF_AWAY) { 1539 iio_push_event(indio_dev, 1540 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0, 1541 IIO_EV_TYPE_THRESH, 1542 IIO_EV_DIR_FALLING), 1543 iio_get_time_ns(indio_dev)); 1544 } 1545 1546 if (ret & VCNL4040_ALS_FALLING) { 1547 iio_push_event(indio_dev, 1548 IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0, 1549 IIO_EV_TYPE_THRESH, 1550 IIO_EV_DIR_FALLING), 1551 iio_get_time_ns(indio_dev)); 1552 } 1553 1554 if (ret & VCNL4040_ALS_RISING) { 1555 iio_push_event(indio_dev, 1556 IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0, 1557 IIO_EV_TYPE_THRESH, 1558 IIO_EV_DIR_RISING), 1559 iio_get_time_ns(indio_dev)); 1560 } 1561 1562 return IRQ_HANDLED; 1563 } 1564 1565 static ssize_t vcnl4000_read_near_level(struct iio_dev *indio_dev, 1566 uintptr_t priv, 1567 const struct iio_chan_spec *chan, 1568 char *buf) 1569 { 1570 struct vcnl4000_data *data = iio_priv(indio_dev); 1571 1572 return sprintf(buf, "%u\n", data->near_level); 1573 } 1574 1575 static irqreturn_t vcnl4010_irq_thread(int irq, void *p) 1576 { 1577 struct iio_dev *indio_dev = p; 1578 struct vcnl4000_data *data = iio_priv(indio_dev); 1579 unsigned long isr; 1580 int ret; 1581 1582 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR); 1583 if (ret < 0) 1584 goto end; 1585 1586 isr = ret; 1587 1588 if (isr & VCNL4010_INT_THR) { 1589 if (test_bit(VCNL4010_INT_THR_LOW, &isr)) { 1590 iio_push_event(indio_dev, 1591 IIO_UNMOD_EVENT_CODE( 1592 IIO_PROXIMITY, 1593 1, 1594 IIO_EV_TYPE_THRESH, 1595 IIO_EV_DIR_FALLING), 1596 iio_get_time_ns(indio_dev)); 1597 } 1598 1599 if (test_bit(VCNL4010_INT_THR_HIGH, &isr)) { 1600 iio_push_event(indio_dev, 1601 IIO_UNMOD_EVENT_CODE( 1602 IIO_PROXIMITY, 1603 1, 1604 IIO_EV_TYPE_THRESH, 1605 IIO_EV_DIR_RISING), 1606 iio_get_time_ns(indio_dev)); 1607 } 1608 1609 i2c_smbus_write_byte_data(data->client, VCNL4010_ISR, 1610 isr & VCNL4010_INT_THR); 1611 } 1612 1613 if (isr & VCNL4010_INT_DRDY && iio_buffer_enabled(indio_dev)) 1614 iio_trigger_poll_nested(indio_dev->trig); 1615 1616 end: 1617 return IRQ_HANDLED; 1618 } 1619 1620 static irqreturn_t vcnl4010_trigger_handler(int irq, void *p) 1621 { 1622 struct iio_poll_func *pf = p; 1623 struct iio_dev *indio_dev = pf->indio_dev; 1624 struct vcnl4000_data *data = iio_priv(indio_dev); 1625 const unsigned long *active_scan_mask = indio_dev->active_scan_mask; 1626 u16 buffer[8] __aligned(8) = {0}; /* 1x16-bit + naturally aligned ts */ 1627 bool data_read = false; 1628 unsigned long isr; 1629 int val = 0; 1630 int ret; 1631 1632 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR); 1633 if (ret < 0) 1634 goto end; 1635 1636 isr = ret; 1637 1638 if (test_bit(0, active_scan_mask)) { 1639 if (test_bit(VCNL4010_INT_PROXIMITY, &isr)) { 1640 ret = vcnl4000_read_data(data, 1641 VCNL4000_PS_RESULT_HI, 1642 &val); 1643 if (ret < 0) 1644 goto end; 1645 1646 buffer[0] = val; 1647 data_read = true; 1648 } 1649 } 1650 1651 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_ISR, 1652 isr & VCNL4010_INT_DRDY); 1653 if (ret < 0) 1654 goto end; 1655 1656 if (!data_read) 1657 goto end; 1658 1659 iio_push_to_buffers_with_timestamp(indio_dev, buffer, 1660 iio_get_time_ns(indio_dev)); 1661 1662 end: 1663 iio_trigger_notify_done(indio_dev->trig); 1664 return IRQ_HANDLED; 1665 } 1666 1667 static int vcnl4010_buffer_postenable(struct iio_dev *indio_dev) 1668 { 1669 struct vcnl4000_data *data = iio_priv(indio_dev); 1670 int ret; 1671 int cmd; 1672 1673 /* Do not enable the buffer if we are already capturing events. */ 1674 if (vcnl4010_is_in_periodic_mode(data)) 1675 return -EBUSY; 1676 1677 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 1678 VCNL4010_INT_PROX_EN); 1679 if (ret < 0) 1680 return ret; 1681 1682 cmd = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN; 1683 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, cmd); 1684 } 1685 1686 static int vcnl4010_buffer_predisable(struct iio_dev *indio_dev) 1687 { 1688 struct vcnl4000_data *data = iio_priv(indio_dev); 1689 int ret; 1690 1691 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 0); 1692 if (ret < 0) 1693 return ret; 1694 1695 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0); 1696 } 1697 1698 static const struct iio_buffer_setup_ops vcnl4010_buffer_ops = { 1699 .postenable = &vcnl4010_buffer_postenable, 1700 .predisable = &vcnl4010_buffer_predisable, 1701 }; 1702 1703 static const struct iio_chan_spec_ext_info vcnl4000_ext_info[] = { 1704 { 1705 .name = "nearlevel", 1706 .shared = IIO_SEPARATE, 1707 .read = vcnl4000_read_near_level, 1708 }, 1709 { /* sentinel */ } 1710 }; 1711 1712 static const struct iio_event_spec vcnl4000_event_spec[] = { 1713 { 1714 .type = IIO_EV_TYPE_THRESH, 1715 .dir = IIO_EV_DIR_RISING, 1716 .mask_separate = BIT(IIO_EV_INFO_VALUE), 1717 }, { 1718 .type = IIO_EV_TYPE_THRESH, 1719 .dir = IIO_EV_DIR_FALLING, 1720 .mask_separate = BIT(IIO_EV_INFO_VALUE), 1721 }, { 1722 .type = IIO_EV_TYPE_THRESH, 1723 .dir = IIO_EV_DIR_EITHER, 1724 .mask_separate = BIT(IIO_EV_INFO_ENABLE), 1725 } 1726 }; 1727 1728 static const struct iio_event_spec vcnl4040_als_event_spec[] = { 1729 { 1730 .type = IIO_EV_TYPE_THRESH, 1731 .dir = IIO_EV_DIR_RISING, 1732 .mask_separate = BIT(IIO_EV_INFO_VALUE), 1733 }, { 1734 .type = IIO_EV_TYPE_THRESH, 1735 .dir = IIO_EV_DIR_FALLING, 1736 .mask_separate = BIT(IIO_EV_INFO_VALUE), 1737 }, { 1738 .type = IIO_EV_TYPE_THRESH, 1739 .dir = IIO_EV_DIR_EITHER, 1740 .mask_separate = BIT(IIO_EV_INFO_ENABLE) | BIT(IIO_EV_INFO_PERIOD), 1741 }, 1742 }; 1743 1744 static const struct iio_event_spec vcnl4040_event_spec[] = { 1745 { 1746 .type = IIO_EV_TYPE_THRESH, 1747 .dir = IIO_EV_DIR_RISING, 1748 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE), 1749 }, { 1750 .type = IIO_EV_TYPE_THRESH, 1751 .dir = IIO_EV_DIR_FALLING, 1752 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE), 1753 }, { 1754 .type = IIO_EV_TYPE_THRESH, 1755 .dir = IIO_EV_DIR_EITHER, 1756 .mask_separate = BIT(IIO_EV_INFO_PERIOD), 1757 }, 1758 }; 1759 1760 static const struct iio_chan_spec vcnl4000_channels[] = { 1761 { 1762 .type = IIO_LIGHT, 1763 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1764 BIT(IIO_CHAN_INFO_SCALE), 1765 }, { 1766 .type = IIO_PROXIMITY, 1767 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 1768 .ext_info = vcnl4000_ext_info, 1769 } 1770 }; 1771 1772 static const struct iio_chan_spec vcnl4010_channels[] = { 1773 { 1774 .type = IIO_LIGHT, 1775 .scan_index = -1, 1776 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1777 BIT(IIO_CHAN_INFO_SCALE), 1778 }, { 1779 .type = IIO_PROXIMITY, 1780 .scan_index = 0, 1781 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1782 BIT(IIO_CHAN_INFO_SAMP_FREQ), 1783 .info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ), 1784 .event_spec = vcnl4000_event_spec, 1785 .num_event_specs = ARRAY_SIZE(vcnl4000_event_spec), 1786 .ext_info = vcnl4000_ext_info, 1787 .scan_type = { 1788 .sign = 'u', 1789 .realbits = 16, 1790 .storagebits = 16, 1791 .endianness = IIO_CPU, 1792 }, 1793 }, 1794 IIO_CHAN_SOFT_TIMESTAMP(1), 1795 }; 1796 1797 static const struct iio_chan_spec vcnl4040_channels[] = { 1798 { 1799 .type = IIO_LIGHT, 1800 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1801 BIT(IIO_CHAN_INFO_SCALE) | 1802 BIT(IIO_CHAN_INFO_INT_TIME), 1803 .info_mask_separate_available = BIT(IIO_CHAN_INFO_INT_TIME), 1804 .event_spec = vcnl4040_als_event_spec, 1805 .num_event_specs = ARRAY_SIZE(vcnl4040_als_event_spec), 1806 }, { 1807 .type = IIO_PROXIMITY, 1808 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1809 BIT(IIO_CHAN_INFO_INT_TIME) | 1810 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) | 1811 BIT(IIO_CHAN_INFO_CALIBBIAS), 1812 .info_mask_separate_available = BIT(IIO_CHAN_INFO_INT_TIME) | 1813 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) | 1814 BIT(IIO_CHAN_INFO_CALIBBIAS), 1815 .ext_info = vcnl4000_ext_info, 1816 .event_spec = vcnl4040_event_spec, 1817 .num_event_specs = ARRAY_SIZE(vcnl4040_event_spec), 1818 } 1819 }; 1820 1821 static const struct iio_info vcnl4000_info = { 1822 .read_raw = vcnl4000_read_raw, 1823 }; 1824 1825 static const struct iio_info vcnl4010_info = { 1826 .read_raw = vcnl4010_read_raw, 1827 .read_avail = vcnl4010_read_avail, 1828 .write_raw = vcnl4010_write_raw, 1829 .read_event_value = vcnl4010_read_event, 1830 .write_event_value = vcnl4010_write_event, 1831 .read_event_config = vcnl4010_read_event_config, 1832 .write_event_config = vcnl4010_write_event_config, 1833 }; 1834 1835 static const struct iio_info vcnl4040_info = { 1836 .read_raw = vcnl4000_read_raw, 1837 .write_raw = vcnl4040_write_raw, 1838 .read_event_value = vcnl4040_read_event, 1839 .write_event_value = vcnl4040_write_event, 1840 .read_event_config = vcnl4040_read_event_config, 1841 .write_event_config = vcnl4040_write_event_config, 1842 .read_avail = vcnl4040_read_avail, 1843 }; 1844 1845 static const struct vcnl4000_chip_spec vcnl4000_chip_spec_cfg[] = { 1846 [VCNL4000] = { 1847 .prod = "VCNL4000", 1848 .init = vcnl4000_init, 1849 .measure_light = vcnl4000_measure_light, 1850 .measure_proximity = vcnl4000_measure_proximity, 1851 .set_power_state = vcnl4000_set_power_state, 1852 .channels = vcnl4000_channels, 1853 .num_channels = ARRAY_SIZE(vcnl4000_channels), 1854 .info = &vcnl4000_info, 1855 }, 1856 [VCNL4010] = { 1857 .prod = "VCNL4010/4020", 1858 .init = vcnl4000_init, 1859 .measure_light = vcnl4000_measure_light, 1860 .measure_proximity = vcnl4000_measure_proximity, 1861 .set_power_state = vcnl4000_set_power_state, 1862 .channels = vcnl4010_channels, 1863 .num_channels = ARRAY_SIZE(vcnl4010_channels), 1864 .info = &vcnl4010_info, 1865 .irq_thread = vcnl4010_irq_thread, 1866 .trig_buffer_func = vcnl4010_trigger_handler, 1867 .buffer_setup_ops = &vcnl4010_buffer_ops, 1868 }, 1869 [VCNL4040] = { 1870 .prod = "VCNL4040", 1871 .init = vcnl4200_init, 1872 .measure_light = vcnl4200_measure_light, 1873 .measure_proximity = vcnl4200_measure_proximity, 1874 .set_power_state = vcnl4200_set_power_state, 1875 .channels = vcnl4040_channels, 1876 .num_channels = ARRAY_SIZE(vcnl4040_channels), 1877 .info = &vcnl4040_info, 1878 .irq_thread = vcnl4040_irq_thread, 1879 .int_reg = VCNL4040_INT_FLAGS, 1880 .ps_it_times = &vcnl4040_ps_it_times, 1881 .num_ps_it_times = ARRAY_SIZE(vcnl4040_ps_it_times), 1882 .als_it_times = &vcnl4040_als_it_times, 1883 .num_als_it_times = ARRAY_SIZE(vcnl4040_als_it_times), 1884 .ulux_step = 100000, 1885 }, 1886 [VCNL4200] = { 1887 .prod = "VCNL4200", 1888 .init = vcnl4200_init, 1889 .measure_light = vcnl4200_measure_light, 1890 .measure_proximity = vcnl4200_measure_proximity, 1891 .set_power_state = vcnl4200_set_power_state, 1892 .channels = vcnl4040_channels, 1893 .num_channels = ARRAY_SIZE(vcnl4000_channels), 1894 .info = &vcnl4040_info, 1895 .irq_thread = vcnl4040_irq_thread, 1896 .int_reg = VCNL4200_INT_FLAGS, 1897 .ps_it_times = &vcnl4200_ps_it_times, 1898 .num_ps_it_times = ARRAY_SIZE(vcnl4200_ps_it_times), 1899 .als_it_times = &vcnl4200_als_it_times, 1900 .num_als_it_times = ARRAY_SIZE(vcnl4200_als_it_times), 1901 .ulux_step = 24000, 1902 }, 1903 }; 1904 1905 static const struct iio_trigger_ops vcnl4010_trigger_ops = { 1906 .validate_device = iio_trigger_validate_own_device, 1907 }; 1908 1909 static int vcnl4010_probe_trigger(struct iio_dev *indio_dev) 1910 { 1911 struct vcnl4000_data *data = iio_priv(indio_dev); 1912 struct i2c_client *client = data->client; 1913 struct iio_trigger *trigger; 1914 1915 trigger = devm_iio_trigger_alloc(&client->dev, "%s-dev%d", 1916 indio_dev->name, 1917 iio_device_id(indio_dev)); 1918 if (!trigger) 1919 return -ENOMEM; 1920 1921 trigger->ops = &vcnl4010_trigger_ops; 1922 iio_trigger_set_drvdata(trigger, indio_dev); 1923 1924 return devm_iio_trigger_register(&client->dev, trigger); 1925 } 1926 1927 static int vcnl4000_probe(struct i2c_client *client) 1928 { 1929 const struct i2c_device_id *id = i2c_client_get_device_id(client); 1930 struct vcnl4000_data *data; 1931 struct iio_dev *indio_dev; 1932 int ret; 1933 1934 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1935 if (!indio_dev) 1936 return -ENOMEM; 1937 1938 data = iio_priv(indio_dev); 1939 i2c_set_clientdata(client, indio_dev); 1940 data->client = client; 1941 data->id = id->driver_data; 1942 data->chip_spec = &vcnl4000_chip_spec_cfg[data->id]; 1943 1944 mutex_init(&data->vcnl4000_lock); 1945 1946 ret = data->chip_spec->init(data); 1947 if (ret < 0) 1948 return ret; 1949 1950 dev_dbg(&client->dev, "%s Ambient light/proximity sensor, Rev: %02x\n", 1951 data->chip_spec->prod, data->rev); 1952 1953 if (device_property_read_u32(&client->dev, "proximity-near-level", 1954 &data->near_level)) 1955 data->near_level = 0; 1956 1957 indio_dev->info = data->chip_spec->info; 1958 indio_dev->channels = data->chip_spec->channels; 1959 indio_dev->num_channels = data->chip_spec->num_channels; 1960 indio_dev->name = VCNL4000_DRV_NAME; 1961 indio_dev->modes = INDIO_DIRECT_MODE; 1962 1963 if (data->chip_spec->trig_buffer_func && 1964 data->chip_spec->buffer_setup_ops) { 1965 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, 1966 NULL, 1967 data->chip_spec->trig_buffer_func, 1968 data->chip_spec->buffer_setup_ops); 1969 if (ret < 0) { 1970 dev_err(&client->dev, 1971 "unable to setup iio triggered buffer\n"); 1972 return ret; 1973 } 1974 } 1975 1976 if (client->irq && data->chip_spec->irq_thread) { 1977 ret = devm_request_threaded_irq(&client->dev, client->irq, 1978 NULL, data->chip_spec->irq_thread, 1979 IRQF_TRIGGER_FALLING | 1980 IRQF_ONESHOT, 1981 "vcnl4000_irq", 1982 indio_dev); 1983 if (ret < 0) { 1984 dev_err(&client->dev, "irq request failed\n"); 1985 return ret; 1986 } 1987 1988 ret = vcnl4010_probe_trigger(indio_dev); 1989 if (ret < 0) 1990 return ret; 1991 } 1992 1993 ret = pm_runtime_set_active(&client->dev); 1994 if (ret < 0) 1995 goto fail_poweroff; 1996 1997 ret = iio_device_register(indio_dev); 1998 if (ret < 0) 1999 goto fail_poweroff; 2000 2001 pm_runtime_enable(&client->dev); 2002 pm_runtime_set_autosuspend_delay(&client->dev, VCNL4000_SLEEP_DELAY_MS); 2003 pm_runtime_use_autosuspend(&client->dev); 2004 2005 return 0; 2006 fail_poweroff: 2007 data->chip_spec->set_power_state(data, false); 2008 return ret; 2009 } 2010 2011 static const struct of_device_id vcnl_4000_of_match[] = { 2012 { 2013 .compatible = "vishay,vcnl4000", 2014 .data = (void *)VCNL4000, 2015 }, 2016 { 2017 .compatible = "vishay,vcnl4010", 2018 .data = (void *)VCNL4010, 2019 }, 2020 { 2021 .compatible = "vishay,vcnl4020", 2022 .data = (void *)VCNL4010, 2023 }, 2024 { 2025 .compatible = "vishay,vcnl4040", 2026 .data = (void *)VCNL4040, 2027 }, 2028 { 2029 .compatible = "vishay,vcnl4200", 2030 .data = (void *)VCNL4200, 2031 }, 2032 {}, 2033 }; 2034 MODULE_DEVICE_TABLE(of, vcnl_4000_of_match); 2035 2036 static void vcnl4000_remove(struct i2c_client *client) 2037 { 2038 struct iio_dev *indio_dev = i2c_get_clientdata(client); 2039 struct vcnl4000_data *data = iio_priv(indio_dev); 2040 int ret; 2041 2042 pm_runtime_dont_use_autosuspend(&client->dev); 2043 pm_runtime_disable(&client->dev); 2044 iio_device_unregister(indio_dev); 2045 pm_runtime_set_suspended(&client->dev); 2046 2047 ret = data->chip_spec->set_power_state(data, false); 2048 if (ret) 2049 dev_warn(&client->dev, "Failed to power down (%pe)\n", 2050 ERR_PTR(ret)); 2051 } 2052 2053 static int vcnl4000_runtime_suspend(struct device *dev) 2054 { 2055 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 2056 struct vcnl4000_data *data = iio_priv(indio_dev); 2057 2058 return data->chip_spec->set_power_state(data, false); 2059 } 2060 2061 static int vcnl4000_runtime_resume(struct device *dev) 2062 { 2063 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 2064 struct vcnl4000_data *data = iio_priv(indio_dev); 2065 2066 return data->chip_spec->set_power_state(data, true); 2067 } 2068 2069 static DEFINE_RUNTIME_DEV_PM_OPS(vcnl4000_pm_ops, vcnl4000_runtime_suspend, 2070 vcnl4000_runtime_resume, NULL); 2071 2072 static struct i2c_driver vcnl4000_driver = { 2073 .driver = { 2074 .name = VCNL4000_DRV_NAME, 2075 .pm = pm_ptr(&vcnl4000_pm_ops), 2076 .of_match_table = vcnl_4000_of_match, 2077 }, 2078 .probe = vcnl4000_probe, 2079 .id_table = vcnl4000_id, 2080 .remove = vcnl4000_remove, 2081 }; 2082 2083 module_i2c_driver(vcnl4000_driver); 2084 2085 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>"); 2086 MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>"); 2087 MODULE_DESCRIPTION("Vishay VCNL4000 proximity/ambient light sensor driver"); 2088 MODULE_LICENSE("GPL"); 2089