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