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 IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim); 1083 if (IIO_DEV_ACQUIRE_FAILED(claim)) 1084 return -EBUSY; 1085 1086 /* Protect against event capture. */ 1087 if (vcnl4010_is_in_periodic_mode(data)) 1088 return -EBUSY; 1089 1090 return vcnl4000_read_raw(indio_dev, chan, val, val2, mask); 1091 } 1092 case IIO_CHAN_INFO_SAMP_FREQ: 1093 switch (chan->type) { 1094 case IIO_PROXIMITY: 1095 ret = vcnl4010_read_proxy_samp_freq(data, val, val2); 1096 if (ret < 0) 1097 return ret; 1098 return IIO_VAL_INT_PLUS_MICRO; 1099 default: 1100 return -EINVAL; 1101 } 1102 default: 1103 return -EINVAL; 1104 } 1105 } 1106 1107 static int vcnl4010_read_avail(struct iio_dev *indio_dev, 1108 struct iio_chan_spec const *chan, 1109 const int **vals, int *type, int *length, 1110 long mask) 1111 { 1112 switch (mask) { 1113 case IIO_CHAN_INFO_SAMP_FREQ: 1114 *vals = (int *)vcnl4010_prox_sampling_frequency; 1115 *type = IIO_VAL_INT_PLUS_MICRO; 1116 *length = 2 * ARRAY_SIZE(vcnl4010_prox_sampling_frequency); 1117 return IIO_AVAIL_LIST; 1118 default: 1119 return -EINVAL; 1120 } 1121 } 1122 1123 static int vcnl4010_write_proxy_samp_freq(struct vcnl4000_data *data, int val, 1124 int val2) 1125 { 1126 unsigned int i; 1127 int index = -1; 1128 1129 for (i = 0; i < ARRAY_SIZE(vcnl4010_prox_sampling_frequency); i++) { 1130 if (val == vcnl4010_prox_sampling_frequency[i][0] && 1131 val2 == vcnl4010_prox_sampling_frequency[i][1]) { 1132 index = i; 1133 break; 1134 } 1135 } 1136 1137 if (index < 0) 1138 return -EINVAL; 1139 1140 return i2c_smbus_write_byte_data(data->client, VCNL4010_PROX_RATE, 1141 index); 1142 } 1143 1144 static int vcnl4010_write_raw(struct iio_dev *indio_dev, 1145 struct iio_chan_spec const *chan, 1146 int val, int val2, long mask) 1147 { 1148 struct vcnl4000_data *data = iio_priv(indio_dev); 1149 1150 IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim); 1151 if (IIO_DEV_ACQUIRE_FAILED(claim)) 1152 return -EBUSY; 1153 1154 /* Protect against event capture. */ 1155 if (vcnl4010_is_in_periodic_mode(data)) 1156 return -EBUSY; 1157 1158 switch (mask) { 1159 case IIO_CHAN_INFO_SAMP_FREQ: 1160 switch (chan->type) { 1161 case IIO_PROXIMITY: 1162 return vcnl4010_write_proxy_samp_freq(data, val, val2); 1163 default: 1164 return -EINVAL; 1165 } 1166 default: 1167 return -EINVAL; 1168 } 1169 } 1170 1171 static int vcnl4010_read_event(struct iio_dev *indio_dev, 1172 const struct iio_chan_spec *chan, 1173 enum iio_event_type type, 1174 enum iio_event_direction dir, 1175 enum iio_event_info info, 1176 int *val, int *val2) 1177 { 1178 int ret; 1179 struct vcnl4000_data *data = iio_priv(indio_dev); 1180 1181 switch (info) { 1182 case IIO_EV_INFO_VALUE: 1183 switch (dir) { 1184 case IIO_EV_DIR_RISING: 1185 ret = vcnl4000_read_data(data, VCNL4010_HIGH_THR_HI, 1186 val); 1187 if (ret < 0) 1188 return ret; 1189 return IIO_VAL_INT; 1190 case IIO_EV_DIR_FALLING: 1191 ret = vcnl4000_read_data(data, VCNL4010_LOW_THR_HI, 1192 val); 1193 if (ret < 0) 1194 return ret; 1195 return IIO_VAL_INT; 1196 default: 1197 return -EINVAL; 1198 } 1199 default: 1200 return -EINVAL; 1201 } 1202 } 1203 1204 static int vcnl4010_write_event(struct iio_dev *indio_dev, 1205 const struct iio_chan_spec *chan, 1206 enum iio_event_type type, 1207 enum iio_event_direction dir, 1208 enum iio_event_info info, 1209 int val, int val2) 1210 { 1211 int ret; 1212 struct vcnl4000_data *data = iio_priv(indio_dev); 1213 1214 switch (info) { 1215 case IIO_EV_INFO_VALUE: 1216 switch (dir) { 1217 case IIO_EV_DIR_RISING: 1218 ret = vcnl4000_write_data(data, VCNL4010_HIGH_THR_HI, 1219 val); 1220 if (ret < 0) 1221 return ret; 1222 return IIO_VAL_INT; 1223 case IIO_EV_DIR_FALLING: 1224 ret = vcnl4000_write_data(data, VCNL4010_LOW_THR_HI, 1225 val); 1226 if (ret < 0) 1227 return ret; 1228 return IIO_VAL_INT; 1229 default: 1230 return -EINVAL; 1231 } 1232 default: 1233 return -EINVAL; 1234 } 1235 } 1236 1237 static int vcnl4040_read_event(struct iio_dev *indio_dev, 1238 const struct iio_chan_spec *chan, 1239 enum iio_event_type type, 1240 enum iio_event_direction dir, 1241 enum iio_event_info info, 1242 int *val, int *val2) 1243 { 1244 int ret; 1245 struct vcnl4000_data *data = iio_priv(indio_dev); 1246 1247 switch (chan->type) { 1248 case IIO_LIGHT: 1249 switch (info) { 1250 case IIO_EV_INFO_PERIOD: 1251 return vcnl4040_read_als_period(data, val, val2); 1252 case IIO_EV_INFO_VALUE: 1253 switch (dir) { 1254 case IIO_EV_DIR_RISING: 1255 ret = i2c_smbus_read_word_data(data->client, 1256 VCNL4040_ALS_THDH_LM); 1257 break; 1258 case IIO_EV_DIR_FALLING: 1259 ret = i2c_smbus_read_word_data(data->client, 1260 VCNL4040_ALS_THDL_LM); 1261 break; 1262 default: 1263 return -EINVAL; 1264 } 1265 break; 1266 default: 1267 return -EINVAL; 1268 } 1269 break; 1270 case IIO_PROXIMITY: 1271 switch (info) { 1272 case IIO_EV_INFO_PERIOD: 1273 return vcnl4040_read_ps_period(data, val, val2); 1274 case IIO_EV_INFO_VALUE: 1275 switch (dir) { 1276 case IIO_EV_DIR_RISING: 1277 ret = i2c_smbus_read_word_data(data->client, 1278 VCNL4040_PS_THDH_LM); 1279 break; 1280 case IIO_EV_DIR_FALLING: 1281 ret = i2c_smbus_read_word_data(data->client, 1282 VCNL4040_PS_THDL_LM); 1283 break; 1284 default: 1285 return -EINVAL; 1286 } 1287 break; 1288 default: 1289 return -EINVAL; 1290 } 1291 break; 1292 default: 1293 return -EINVAL; 1294 } 1295 if (ret < 0) 1296 return ret; 1297 *val = ret; 1298 return IIO_VAL_INT; 1299 } 1300 1301 static int vcnl4040_write_event(struct iio_dev *indio_dev, 1302 const struct iio_chan_spec *chan, 1303 enum iio_event_type type, 1304 enum iio_event_direction dir, 1305 enum iio_event_info info, 1306 int val, int val2) 1307 { 1308 int ret; 1309 struct vcnl4000_data *data = iio_priv(indio_dev); 1310 1311 switch (chan->type) { 1312 case IIO_LIGHT: 1313 switch (info) { 1314 case IIO_EV_INFO_PERIOD: 1315 return vcnl4040_write_als_period(data, val, val2); 1316 case IIO_EV_INFO_VALUE: 1317 switch (dir) { 1318 case IIO_EV_DIR_RISING: 1319 ret = i2c_smbus_write_word_data(data->client, 1320 VCNL4040_ALS_THDH_LM, 1321 val); 1322 break; 1323 case IIO_EV_DIR_FALLING: 1324 ret = i2c_smbus_write_word_data(data->client, 1325 VCNL4040_ALS_THDL_LM, 1326 val); 1327 break; 1328 default: 1329 return -EINVAL; 1330 } 1331 break; 1332 default: 1333 return -EINVAL; 1334 } 1335 break; 1336 case IIO_PROXIMITY: 1337 switch (info) { 1338 case IIO_EV_INFO_PERIOD: 1339 return vcnl4040_write_ps_period(data, val, val2); 1340 case IIO_EV_INFO_VALUE: 1341 switch (dir) { 1342 case IIO_EV_DIR_RISING: 1343 ret = i2c_smbus_write_word_data(data->client, 1344 VCNL4040_PS_THDH_LM, 1345 val); 1346 break; 1347 case IIO_EV_DIR_FALLING: 1348 ret = i2c_smbus_write_word_data(data->client, 1349 VCNL4040_PS_THDL_LM, 1350 val); 1351 break; 1352 default: 1353 return -EINVAL; 1354 } 1355 break; 1356 default: 1357 return -EINVAL; 1358 } 1359 break; 1360 default: 1361 return -EINVAL; 1362 } 1363 if (ret < 0) 1364 return ret; 1365 return IIO_VAL_INT; 1366 } 1367 1368 static bool vcnl4010_is_thr_enabled(struct vcnl4000_data *data) 1369 { 1370 int ret; 1371 1372 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_INT_CTRL); 1373 if (ret < 0) 1374 return false; 1375 1376 return !!(ret & VCNL4010_INT_THR_EN); 1377 } 1378 1379 static int vcnl4010_read_event_config(struct iio_dev *indio_dev, 1380 const struct iio_chan_spec *chan, 1381 enum iio_event_type type, 1382 enum iio_event_direction dir) 1383 { 1384 struct vcnl4000_data *data = iio_priv(indio_dev); 1385 1386 switch (chan->type) { 1387 case IIO_PROXIMITY: 1388 return vcnl4010_is_thr_enabled(data); 1389 default: 1390 return -EINVAL; 1391 } 1392 } 1393 1394 static int vcnl4010_config_threshold_enable(struct vcnl4000_data *data) 1395 { 1396 int ret; 1397 1398 /* Enable periodic measurement of proximity data. */ 1399 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 1400 VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN); 1401 if (ret < 0) 1402 return ret; 1403 1404 /* 1405 * Enable interrupts on threshold, for proximity data by 1406 * default. 1407 */ 1408 return i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 1409 VCNL4010_INT_THR_EN); 1410 } 1411 1412 static int vcnl4010_config_threshold_disable(struct vcnl4000_data *data) 1413 { 1414 int ret; 1415 1416 if (!vcnl4010_is_thr_enabled(data)) 1417 return 0; 1418 1419 ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0); 1420 if (ret < 0) 1421 return ret; 1422 1423 return i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 0); 1424 } 1425 1426 static int vcnl4010_config_threshold(struct iio_dev *indio_dev, bool state) 1427 { 1428 struct vcnl4000_data *data = iio_priv(indio_dev); 1429 1430 if (state) { 1431 IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim); 1432 if (IIO_DEV_ACQUIRE_FAILED(claim)) 1433 return -EBUSY; 1434 1435 return vcnl4010_config_threshold_enable(data); 1436 } else { 1437 return vcnl4010_config_threshold_disable(data); 1438 } 1439 } 1440 1441 static int vcnl4010_write_event_config(struct iio_dev *indio_dev, 1442 const struct iio_chan_spec *chan, 1443 enum iio_event_type type, 1444 enum iio_event_direction dir, 1445 bool state) 1446 { 1447 switch (chan->type) { 1448 case IIO_PROXIMITY: 1449 return vcnl4010_config_threshold(indio_dev, state); 1450 default: 1451 return -EINVAL; 1452 } 1453 } 1454 1455 static int vcnl4040_read_event_config(struct iio_dev *indio_dev, 1456 const struct iio_chan_spec *chan, 1457 enum iio_event_type type, 1458 enum iio_event_direction dir) 1459 { 1460 int ret; 1461 struct vcnl4000_data *data = iio_priv(indio_dev); 1462 1463 switch (chan->type) { 1464 case IIO_LIGHT: 1465 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 1466 if (ret < 0) 1467 return ret; 1468 1469 data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, ret); 1470 1471 return data->als_int; 1472 case IIO_PROXIMITY: 1473 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 1474 if (ret < 0) 1475 return ret; 1476 1477 data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, ret); 1478 1479 return (dir == IIO_EV_DIR_RISING) ? 1480 FIELD_GET(VCNL4040_PS_IF_AWAY, ret) : 1481 FIELD_GET(VCNL4040_PS_IF_CLOSE, ret); 1482 default: 1483 return -EINVAL; 1484 } 1485 } 1486 1487 static int vcnl4040_write_event_config(struct iio_dev *indio_dev, 1488 const struct iio_chan_spec *chan, 1489 enum iio_event_type type, 1490 enum iio_event_direction dir, 1491 bool state) 1492 { 1493 int ret = -EINVAL; 1494 u16 val, mask; 1495 struct vcnl4000_data *data = iio_priv(indio_dev); 1496 1497 mutex_lock(&data->vcnl4000_lock); 1498 1499 switch (chan->type) { 1500 case IIO_LIGHT: 1501 ret = i2c_smbus_read_word_data(data->client, VCNL4200_AL_CONF); 1502 if (ret < 0) 1503 goto out; 1504 1505 mask = VCNL4040_ALS_CONF_INT_EN; 1506 if (state) 1507 val = (ret | mask); 1508 else 1509 val = (ret & ~mask); 1510 1511 data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, val); 1512 ret = i2c_smbus_write_word_data(data->client, VCNL4200_AL_CONF, 1513 val); 1514 break; 1515 case IIO_PROXIMITY: 1516 ret = i2c_smbus_read_word_data(data->client, VCNL4200_PS_CONF1); 1517 if (ret < 0) 1518 goto out; 1519 1520 if (dir == IIO_EV_DIR_RISING) 1521 mask = VCNL4040_PS_IF_AWAY; 1522 else 1523 mask = VCNL4040_PS_IF_CLOSE; 1524 1525 val = state ? (ret | mask) : (ret & ~mask); 1526 1527 data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, val); 1528 ret = i2c_smbus_write_word_data(data->client, VCNL4200_PS_CONF1, 1529 val); 1530 break; 1531 default: 1532 break; 1533 } 1534 1535 out: 1536 mutex_unlock(&data->vcnl4000_lock); 1537 1538 return ret; 1539 } 1540 1541 static irqreturn_t vcnl4040_irq_thread(int irq, void *p) 1542 { 1543 struct iio_dev *indio_dev = p; 1544 struct vcnl4000_data *data = iio_priv(indio_dev); 1545 int ret; 1546 1547 ret = i2c_smbus_read_word_data(data->client, data->chip_spec->int_reg); 1548 if (ret < 0) 1549 return IRQ_HANDLED; 1550 1551 if (ret & VCNL4040_PS_IF_CLOSE) { 1552 iio_push_event(indio_dev, 1553 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0, 1554 IIO_EV_TYPE_THRESH, 1555 IIO_EV_DIR_RISING), 1556 iio_get_time_ns(indio_dev)); 1557 } 1558 1559 if (ret & VCNL4040_PS_IF_AWAY) { 1560 iio_push_event(indio_dev, 1561 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0, 1562 IIO_EV_TYPE_THRESH, 1563 IIO_EV_DIR_FALLING), 1564 iio_get_time_ns(indio_dev)); 1565 } 1566 1567 if (ret & VCNL4040_ALS_FALLING) { 1568 iio_push_event(indio_dev, 1569 IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0, 1570 IIO_EV_TYPE_THRESH, 1571 IIO_EV_DIR_FALLING), 1572 iio_get_time_ns(indio_dev)); 1573 } 1574 1575 if (ret & VCNL4040_ALS_RISING) { 1576 iio_push_event(indio_dev, 1577 IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0, 1578 IIO_EV_TYPE_THRESH, 1579 IIO_EV_DIR_RISING), 1580 iio_get_time_ns(indio_dev)); 1581 } 1582 1583 return IRQ_HANDLED; 1584 } 1585 1586 static ssize_t vcnl4000_read_near_level(struct iio_dev *indio_dev, 1587 uintptr_t priv, 1588 const struct iio_chan_spec *chan, 1589 char *buf) 1590 { 1591 struct vcnl4000_data *data = iio_priv(indio_dev); 1592 1593 return sprintf(buf, "%u\n", data->near_level); 1594 } 1595 1596 static irqreturn_t vcnl4010_irq_thread(int irq, void *p) 1597 { 1598 struct iio_dev *indio_dev = p; 1599 struct vcnl4000_data *data = iio_priv(indio_dev); 1600 unsigned long isr; 1601 int ret; 1602 1603 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR); 1604 if (ret < 0) 1605 goto end; 1606 1607 isr = ret; 1608 1609 if (isr & VCNL4010_INT_THR) { 1610 if (test_bit(VCNL4010_INT_THR_LOW, &isr)) { 1611 iio_push_event(indio_dev, 1612 IIO_UNMOD_EVENT_CODE( 1613 IIO_PROXIMITY, 1614 1, 1615 IIO_EV_TYPE_THRESH, 1616 IIO_EV_DIR_FALLING), 1617 iio_get_time_ns(indio_dev)); 1618 } 1619 1620 if (test_bit(VCNL4010_INT_THR_HIGH, &isr)) { 1621 iio_push_event(indio_dev, 1622 IIO_UNMOD_EVENT_CODE( 1623 IIO_PROXIMITY, 1624 1, 1625 IIO_EV_TYPE_THRESH, 1626 IIO_EV_DIR_RISING), 1627 iio_get_time_ns(indio_dev)); 1628 } 1629 1630 i2c_smbus_write_byte_data(data->client, VCNL4010_ISR, 1631 isr & VCNL4010_INT_THR); 1632 } 1633 1634 if (isr & VCNL4010_INT_DRDY && iio_buffer_enabled(indio_dev)) 1635 iio_trigger_poll_nested(indio_dev->trig); 1636 1637 end: 1638 return IRQ_HANDLED; 1639 } 1640 1641 static irqreturn_t vcnl4010_trigger_handler(int irq, void *p) 1642 { 1643 struct iio_poll_func *pf = p; 1644 struct iio_dev *indio_dev = pf->indio_dev; 1645 struct vcnl4000_data *data = iio_priv(indio_dev); 1646 const unsigned long *active_scan_mask = indio_dev->active_scan_mask; 1647 struct { 1648 u16 chan; 1649 aligned_s64 ts; 1650 } scan = { }; 1651 bool data_read = false; 1652 unsigned long isr; 1653 int val = 0; 1654 int ret; 1655 1656 ret = i2c_smbus_read_byte_data(data->client, VCNL4010_ISR); 1657 if (ret < 0) 1658 goto end; 1659 1660 isr = ret; 1661 1662 if (test_bit(0, active_scan_mask)) { 1663 if (test_bit(VCNL4010_INT_PROXIMITY, &isr)) { 1664 ret = vcnl4000_read_data(data, 1665 VCNL4000_PS_RESULT_HI, 1666 &val); 1667 if (ret < 0) 1668 goto end; 1669 1670 scan.chan = val; 1671 data_read = true; 1672 } 1673 } 1674 1675 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_ISR, 1676 isr & VCNL4010_INT_DRDY); 1677 if (ret < 0) 1678 goto end; 1679 1680 if (!data_read) 1681 goto end; 1682 1683 iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan), 1684 iio_get_time_ns(indio_dev)); 1685 1686 end: 1687 iio_trigger_notify_done(indio_dev->trig); 1688 return IRQ_HANDLED; 1689 } 1690 1691 static int vcnl4010_buffer_postenable(struct iio_dev *indio_dev) 1692 { 1693 struct vcnl4000_data *data = iio_priv(indio_dev); 1694 int ret; 1695 int cmd; 1696 1697 /* Do not enable the buffer if we are already capturing events. */ 1698 if (vcnl4010_is_in_periodic_mode(data)) 1699 return -EBUSY; 1700 1701 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 1702 VCNL4010_INT_PROX_EN); 1703 if (ret < 0) 1704 return ret; 1705 1706 cmd = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN; 1707 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, cmd); 1708 } 1709 1710 static int vcnl4010_buffer_predisable(struct iio_dev *indio_dev) 1711 { 1712 struct vcnl4000_data *data = iio_priv(indio_dev); 1713 int ret; 1714 1715 ret = i2c_smbus_write_byte_data(data->client, VCNL4010_INT_CTRL, 0); 1716 if (ret < 0) 1717 return ret; 1718 1719 return i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND, 0); 1720 } 1721 1722 static const struct iio_buffer_setup_ops vcnl4010_buffer_ops = { 1723 .postenable = &vcnl4010_buffer_postenable, 1724 .predisable = &vcnl4010_buffer_predisable, 1725 }; 1726 1727 static const struct iio_chan_spec_ext_info vcnl4000_ext_info[] = { 1728 { 1729 .name = "nearlevel", 1730 .shared = IIO_SEPARATE, 1731 .read = vcnl4000_read_near_level, 1732 }, 1733 { } 1734 }; 1735 1736 static const struct iio_event_spec vcnl4000_event_spec[] = { 1737 { 1738 .type = IIO_EV_TYPE_THRESH, 1739 .dir = IIO_EV_DIR_RISING, 1740 .mask_separate = BIT(IIO_EV_INFO_VALUE), 1741 }, { 1742 .type = IIO_EV_TYPE_THRESH, 1743 .dir = IIO_EV_DIR_FALLING, 1744 .mask_separate = BIT(IIO_EV_INFO_VALUE), 1745 }, { 1746 .type = IIO_EV_TYPE_THRESH, 1747 .dir = IIO_EV_DIR_EITHER, 1748 .mask_separate = BIT(IIO_EV_INFO_ENABLE), 1749 } 1750 }; 1751 1752 static const struct iio_event_spec vcnl4040_als_event_spec[] = { 1753 { 1754 .type = IIO_EV_TYPE_THRESH, 1755 .dir = IIO_EV_DIR_RISING, 1756 .mask_separate = BIT(IIO_EV_INFO_VALUE), 1757 }, { 1758 .type = IIO_EV_TYPE_THRESH, 1759 .dir = IIO_EV_DIR_FALLING, 1760 .mask_separate = BIT(IIO_EV_INFO_VALUE), 1761 }, { 1762 .type = IIO_EV_TYPE_THRESH, 1763 .dir = IIO_EV_DIR_EITHER, 1764 .mask_separate = BIT(IIO_EV_INFO_ENABLE) | BIT(IIO_EV_INFO_PERIOD), 1765 }, 1766 }; 1767 1768 static const struct iio_event_spec vcnl4040_event_spec[] = { 1769 { 1770 .type = IIO_EV_TYPE_THRESH, 1771 .dir = IIO_EV_DIR_RISING, 1772 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE), 1773 }, { 1774 .type = IIO_EV_TYPE_THRESH, 1775 .dir = IIO_EV_DIR_FALLING, 1776 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE), 1777 }, { 1778 .type = IIO_EV_TYPE_THRESH, 1779 .dir = IIO_EV_DIR_EITHER, 1780 .mask_separate = BIT(IIO_EV_INFO_PERIOD), 1781 }, 1782 }; 1783 1784 static const struct iio_chan_spec vcnl4000_channels[] = { 1785 { 1786 .type = IIO_LIGHT, 1787 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1788 BIT(IIO_CHAN_INFO_SCALE), 1789 }, { 1790 .type = IIO_PROXIMITY, 1791 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 1792 .ext_info = vcnl4000_ext_info, 1793 } 1794 }; 1795 1796 static const struct iio_chan_spec vcnl4010_channels[] = { 1797 { 1798 .type = IIO_LIGHT, 1799 .scan_index = -1, 1800 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1801 BIT(IIO_CHAN_INFO_SCALE), 1802 }, { 1803 .type = IIO_PROXIMITY, 1804 .scan_index = 0, 1805 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1806 BIT(IIO_CHAN_INFO_SAMP_FREQ), 1807 .info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ), 1808 .event_spec = vcnl4000_event_spec, 1809 .num_event_specs = ARRAY_SIZE(vcnl4000_event_spec), 1810 .ext_info = vcnl4000_ext_info, 1811 .scan_type = { 1812 .sign = 'u', 1813 .realbits = 16, 1814 .storagebits = 16, 1815 .endianness = IIO_CPU, 1816 }, 1817 }, 1818 IIO_CHAN_SOFT_TIMESTAMP(1), 1819 }; 1820 1821 static const struct iio_chan_spec vcnl4040_channels[] = { 1822 { 1823 .type = IIO_LIGHT, 1824 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1825 BIT(IIO_CHAN_INFO_SCALE) | 1826 BIT(IIO_CHAN_INFO_INT_TIME), 1827 .info_mask_separate_available = BIT(IIO_CHAN_INFO_INT_TIME), 1828 .event_spec = vcnl4040_als_event_spec, 1829 .num_event_specs = ARRAY_SIZE(vcnl4040_als_event_spec), 1830 }, { 1831 .type = IIO_PROXIMITY, 1832 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 1833 BIT(IIO_CHAN_INFO_INT_TIME) | 1834 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) | 1835 BIT(IIO_CHAN_INFO_CALIBBIAS), 1836 .info_mask_separate_available = BIT(IIO_CHAN_INFO_INT_TIME) | 1837 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) | 1838 BIT(IIO_CHAN_INFO_CALIBBIAS), 1839 .ext_info = vcnl4000_ext_info, 1840 .event_spec = vcnl4040_event_spec, 1841 .num_event_specs = ARRAY_SIZE(vcnl4040_event_spec), 1842 } 1843 }; 1844 1845 static const struct iio_info vcnl4000_info = { 1846 .read_raw = vcnl4000_read_raw, 1847 }; 1848 1849 static const struct iio_info vcnl4010_info = { 1850 .read_raw = vcnl4010_read_raw, 1851 .read_avail = vcnl4010_read_avail, 1852 .write_raw = vcnl4010_write_raw, 1853 .read_event_value = vcnl4010_read_event, 1854 .write_event_value = vcnl4010_write_event, 1855 .read_event_config = vcnl4010_read_event_config, 1856 .write_event_config = vcnl4010_write_event_config, 1857 }; 1858 1859 static const struct iio_info vcnl4040_info = { 1860 .read_raw = vcnl4000_read_raw, 1861 .write_raw = vcnl4040_write_raw, 1862 .read_event_value = vcnl4040_read_event, 1863 .write_event_value = vcnl4040_write_event, 1864 .read_event_config = vcnl4040_read_event_config, 1865 .write_event_config = vcnl4040_write_event_config, 1866 .read_avail = vcnl4040_read_avail, 1867 }; 1868 1869 static const struct vcnl4000_chip_spec vcnl4000_chip_spec_cfg[] = { 1870 [VCNL4000] = { 1871 .prod = "VCNL4000", 1872 .init = vcnl4000_init, 1873 .measure_light = vcnl4000_measure_light, 1874 .measure_proximity = vcnl4000_measure_proximity, 1875 .set_power_state = vcnl4000_set_power_state, 1876 .channels = vcnl4000_channels, 1877 .num_channels = ARRAY_SIZE(vcnl4000_channels), 1878 .info = &vcnl4000_info, 1879 }, 1880 [VCNL4010] = { 1881 .prod = "VCNL4010/4020", 1882 .init = vcnl4000_init, 1883 .measure_light = vcnl4000_measure_light, 1884 .measure_proximity = vcnl4000_measure_proximity, 1885 .set_power_state = vcnl4000_set_power_state, 1886 .channels = vcnl4010_channels, 1887 .num_channels = ARRAY_SIZE(vcnl4010_channels), 1888 .info = &vcnl4010_info, 1889 .irq_thread = vcnl4010_irq_thread, 1890 .trig_buffer_func = vcnl4010_trigger_handler, 1891 .buffer_setup_ops = &vcnl4010_buffer_ops, 1892 }, 1893 [VCNL4040] = { 1894 .prod = "VCNL4040", 1895 .init = vcnl4200_init, 1896 .measure_light = vcnl4200_measure_light, 1897 .measure_proximity = vcnl4200_measure_proximity, 1898 .set_power_state = vcnl4200_set_power_state, 1899 .channels = vcnl4040_channels, 1900 .num_channels = ARRAY_SIZE(vcnl4040_channels), 1901 .info = &vcnl4040_info, 1902 .irq_thread = vcnl4040_irq_thread, 1903 .int_reg = VCNL4040_INT_FLAGS, 1904 .ps_it_times = &vcnl4040_ps_it_times, 1905 .num_ps_it_times = ARRAY_SIZE(vcnl4040_ps_it_times), 1906 .als_it_times = &vcnl4040_als_it_times, 1907 .num_als_it_times = ARRAY_SIZE(vcnl4040_als_it_times), 1908 .ulux_step = 100000, 1909 }, 1910 [VCNL4200] = { 1911 .prod = "VCNL4200", 1912 .init = vcnl4200_init, 1913 .measure_light = vcnl4200_measure_light, 1914 .measure_proximity = vcnl4200_measure_proximity, 1915 .set_power_state = vcnl4200_set_power_state, 1916 .channels = vcnl4040_channels, 1917 .num_channels = ARRAY_SIZE(vcnl4000_channels), 1918 .info = &vcnl4040_info, 1919 .irq_thread = vcnl4040_irq_thread, 1920 .int_reg = VCNL4200_INT_FLAGS, 1921 .ps_it_times = &vcnl4200_ps_it_times, 1922 .num_ps_it_times = ARRAY_SIZE(vcnl4200_ps_it_times), 1923 .als_it_times = &vcnl4200_als_it_times, 1924 .num_als_it_times = ARRAY_SIZE(vcnl4200_als_it_times), 1925 .ulux_step = 24000, 1926 }, 1927 }; 1928 1929 static const struct iio_trigger_ops vcnl4010_trigger_ops = { 1930 .validate_device = iio_trigger_validate_own_device, 1931 }; 1932 1933 static int vcnl4010_probe_trigger(struct iio_dev *indio_dev) 1934 { 1935 struct vcnl4000_data *data = iio_priv(indio_dev); 1936 struct i2c_client *client = data->client; 1937 struct iio_trigger *trigger; 1938 1939 trigger = devm_iio_trigger_alloc(&client->dev, "%s-dev%d", 1940 indio_dev->name, 1941 iio_device_id(indio_dev)); 1942 if (!trigger) 1943 return -ENOMEM; 1944 1945 trigger->ops = &vcnl4010_trigger_ops; 1946 iio_trigger_set_drvdata(trigger, indio_dev); 1947 1948 return devm_iio_trigger_register(&client->dev, trigger); 1949 } 1950 1951 static int vcnl4000_probe(struct i2c_client *client) 1952 { 1953 const struct i2c_device_id *id = i2c_client_get_device_id(client); 1954 struct vcnl4000_data *data; 1955 struct iio_dev *indio_dev; 1956 int ret; 1957 1958 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1959 if (!indio_dev) 1960 return -ENOMEM; 1961 1962 data = iio_priv(indio_dev); 1963 i2c_set_clientdata(client, indio_dev); 1964 data->client = client; 1965 data->id = id->driver_data; 1966 data->chip_spec = &vcnl4000_chip_spec_cfg[data->id]; 1967 1968 mutex_init(&data->vcnl4000_lock); 1969 1970 ret = data->chip_spec->init(data); 1971 if (ret < 0) 1972 return ret; 1973 1974 dev_dbg(&client->dev, "%s Ambient light/proximity sensor, Rev: %02x\n", 1975 data->chip_spec->prod, data->rev); 1976 1977 if (device_property_read_u32(&client->dev, "proximity-near-level", 1978 &data->near_level)) 1979 data->near_level = 0; 1980 1981 indio_dev->info = data->chip_spec->info; 1982 indio_dev->channels = data->chip_spec->channels; 1983 indio_dev->num_channels = data->chip_spec->num_channels; 1984 indio_dev->name = VCNL4000_DRV_NAME; 1985 indio_dev->modes = INDIO_DIRECT_MODE; 1986 1987 if (data->chip_spec->trig_buffer_func && 1988 data->chip_spec->buffer_setup_ops) { 1989 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, 1990 NULL, 1991 data->chip_spec->trig_buffer_func, 1992 data->chip_spec->buffer_setup_ops); 1993 if (ret < 0) { 1994 dev_err(&client->dev, 1995 "unable to setup iio triggered buffer\n"); 1996 return ret; 1997 } 1998 } 1999 2000 if (client->irq && data->chip_spec->irq_thread) { 2001 ret = devm_request_threaded_irq(&client->dev, client->irq, 2002 NULL, data->chip_spec->irq_thread, 2003 IRQF_TRIGGER_FALLING | 2004 IRQF_ONESHOT, 2005 "vcnl4000_irq", 2006 indio_dev); 2007 if (ret < 0) { 2008 dev_err(&client->dev, "irq request failed\n"); 2009 return ret; 2010 } 2011 2012 ret = vcnl4010_probe_trigger(indio_dev); 2013 if (ret < 0) 2014 return ret; 2015 } 2016 2017 ret = pm_runtime_set_active(&client->dev); 2018 if (ret < 0) 2019 goto fail_poweroff; 2020 2021 ret = iio_device_register(indio_dev); 2022 if (ret < 0) 2023 goto fail_poweroff; 2024 2025 pm_runtime_enable(&client->dev); 2026 pm_runtime_set_autosuspend_delay(&client->dev, VCNL4000_SLEEP_DELAY_MS); 2027 pm_runtime_use_autosuspend(&client->dev); 2028 2029 return 0; 2030 fail_poweroff: 2031 data->chip_spec->set_power_state(data, false); 2032 return ret; 2033 } 2034 2035 static const struct of_device_id vcnl_4000_of_match[] = { 2036 { 2037 .compatible = "vishay,vcnl4000", 2038 .data = (void *)VCNL4000, 2039 }, 2040 { 2041 .compatible = "vishay,vcnl4010", 2042 .data = (void *)VCNL4010, 2043 }, 2044 { 2045 .compatible = "vishay,vcnl4020", 2046 .data = (void *)VCNL4010, 2047 }, 2048 { 2049 .compatible = "vishay,vcnl4040", 2050 .data = (void *)VCNL4040, 2051 }, 2052 { 2053 .compatible = "vishay,vcnl4200", 2054 .data = (void *)VCNL4200, 2055 }, 2056 { } 2057 }; 2058 MODULE_DEVICE_TABLE(of, vcnl_4000_of_match); 2059 2060 static void vcnl4000_remove(struct i2c_client *client) 2061 { 2062 struct iio_dev *indio_dev = i2c_get_clientdata(client); 2063 struct vcnl4000_data *data = iio_priv(indio_dev); 2064 int ret; 2065 2066 pm_runtime_dont_use_autosuspend(&client->dev); 2067 pm_runtime_disable(&client->dev); 2068 iio_device_unregister(indio_dev); 2069 pm_runtime_set_suspended(&client->dev); 2070 2071 ret = data->chip_spec->set_power_state(data, false); 2072 if (ret) 2073 dev_warn(&client->dev, "Failed to power down (%pe)\n", 2074 ERR_PTR(ret)); 2075 } 2076 2077 static int vcnl4000_runtime_suspend(struct device *dev) 2078 { 2079 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 2080 struct vcnl4000_data *data = iio_priv(indio_dev); 2081 2082 return data->chip_spec->set_power_state(data, false); 2083 } 2084 2085 static int vcnl4000_runtime_resume(struct device *dev) 2086 { 2087 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 2088 struct vcnl4000_data *data = iio_priv(indio_dev); 2089 2090 return data->chip_spec->set_power_state(data, true); 2091 } 2092 2093 static DEFINE_RUNTIME_DEV_PM_OPS(vcnl4000_pm_ops, vcnl4000_runtime_suspend, 2094 vcnl4000_runtime_resume, NULL); 2095 2096 static struct i2c_driver vcnl4000_driver = { 2097 .driver = { 2098 .name = VCNL4000_DRV_NAME, 2099 .pm = pm_ptr(&vcnl4000_pm_ops), 2100 .of_match_table = vcnl_4000_of_match, 2101 }, 2102 .probe = vcnl4000_probe, 2103 .id_table = vcnl4000_id, 2104 .remove = vcnl4000_remove, 2105 }; 2106 2107 module_i2c_driver(vcnl4000_driver); 2108 2109 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>"); 2110 MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>"); 2111 MODULE_DESCRIPTION("Vishay VCNL4000 proximity/ambient light sensor driver"); 2112 MODULE_LICENSE("GPL"); 2113