1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * This file is part of the APDS990x sensor driver. 4 * Chip is combined proximity and ambient light sensor. 5 * 6 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 7 * 8 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com> 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/i2c.h> 14 #include <linux/interrupt.h> 15 #include <linux/mutex.h> 16 #include <linux/regulator/consumer.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/delay.h> 19 #include <linux/wait.h> 20 #include <linux/slab.h> 21 #include <linux/platform_data/apds990x.h> 22 23 /* Register map */ 24 #define APDS990X_ENABLE 0x00 /* Enable of states and interrupts */ 25 #define APDS990X_ATIME 0x01 /* ALS ADC time */ 26 #define APDS990X_PTIME 0x02 /* Proximity ADC time */ 27 #define APDS990X_WTIME 0x03 /* Wait time */ 28 #define APDS990X_AILTL 0x04 /* ALS interrupt low threshold low byte */ 29 #define APDS990X_AILTH 0x05 /* ALS interrupt low threshold hi byte */ 30 #define APDS990X_AIHTL 0x06 /* ALS interrupt hi threshold low byte */ 31 #define APDS990X_AIHTH 0x07 /* ALS interrupt hi threshold hi byte */ 32 #define APDS990X_PILTL 0x08 /* Proximity interrupt low threshold low byte */ 33 #define APDS990X_PILTH 0x09 /* Proximity interrupt low threshold hi byte */ 34 #define APDS990X_PIHTL 0x0a /* Proximity interrupt hi threshold low byte */ 35 #define APDS990X_PIHTH 0x0b /* Proximity interrupt hi threshold hi byte */ 36 #define APDS990X_PERS 0x0c /* Interrupt persistence filters */ 37 #define APDS990X_CONFIG 0x0d /* Configuration */ 38 #define APDS990X_PPCOUNT 0x0e /* Proximity pulse count */ 39 #define APDS990X_CONTROL 0x0f /* Gain control register */ 40 #define APDS990X_REV 0x11 /* Revision Number */ 41 #define APDS990X_ID 0x12 /* Device ID */ 42 #define APDS990X_STATUS 0x13 /* Device status */ 43 #define APDS990X_CDATAL 0x14 /* Clear ADC low data register */ 44 #define APDS990X_CDATAH 0x15 /* Clear ADC high data register */ 45 #define APDS990X_IRDATAL 0x16 /* IR ADC low data register */ 46 #define APDS990X_IRDATAH 0x17 /* IR ADC high data register */ 47 #define APDS990X_PDATAL 0x18 /* Proximity ADC low data register */ 48 #define APDS990X_PDATAH 0x19 /* Proximity ADC high data register */ 49 50 /* Control */ 51 #define APDS990X_MAX_AGAIN 3 52 53 /* Enable register */ 54 #define APDS990X_EN_PIEN (0x1 << 5) 55 #define APDS990X_EN_AIEN (0x1 << 4) 56 #define APDS990X_EN_WEN (0x1 << 3) 57 #define APDS990X_EN_PEN (0x1 << 2) 58 #define APDS990X_EN_AEN (0x1 << 1) 59 #define APDS990X_EN_PON (0x1 << 0) 60 #define APDS990X_EN_DISABLE_ALL 0 61 62 /* Status register */ 63 #define APDS990X_ST_PINT (0x1 << 5) 64 #define APDS990X_ST_AINT (0x1 << 4) 65 66 /* I2C access types */ 67 #define APDS990x_CMD_TYPE_MASK (0x03 << 5) 68 #define APDS990x_CMD_TYPE_RB (0x00 << 5) /* Repeated byte */ 69 #define APDS990x_CMD_TYPE_INC (0x01 << 5) /* Auto increment */ 70 #define APDS990x_CMD_TYPE_SPE (0x03 << 5) /* Special function */ 71 72 #define APDS990x_ADDR_SHIFT 0 73 #define APDS990x_CMD 0x80 74 75 /* Interrupt ack commands */ 76 #define APDS990X_INT_ACK_ALS 0x6 77 #define APDS990X_INT_ACK_PS 0x5 78 #define APDS990X_INT_ACK_BOTH 0x7 79 80 /* ptime */ 81 #define APDS990X_PTIME_DEFAULT 0xff /* Recommended conversion time 2.7ms*/ 82 83 /* wtime */ 84 #define APDS990X_WTIME_DEFAULT 0xee /* ~50ms wait time */ 85 86 #define APDS990X_TIME_TO_ADC 1024 /* One timetick as ADC count value */ 87 88 /* Persistence */ 89 #define APDS990X_APERS_SHIFT 0 90 #define APDS990X_PPERS_SHIFT 4 91 92 /* Supported ID:s */ 93 #define APDS990X_ID_0 0x0 94 #define APDS990X_ID_4 0x4 95 #define APDS990X_ID_29 0x29 96 97 /* pgain and pdiode settings */ 98 #define APDS_PGAIN_1X 0x0 99 #define APDS_PDIODE_IR 0x2 100 101 #define APDS990X_LUX_OUTPUT_SCALE 10 102 103 /* Reverse chip factors for threshold calculation */ 104 struct reverse_factors { 105 u32 afactor; 106 int cf1; 107 int irf1; 108 int cf2; 109 int irf2; 110 }; 111 112 struct apds990x_chip { 113 struct apds990x_platform_data *pdata; 114 struct i2c_client *client; 115 struct mutex mutex; /* avoid parallel access */ 116 struct regulator_bulk_data regs[2]; 117 wait_queue_head_t wait; 118 119 int prox_en; 120 bool prox_continuous_mode; 121 bool lux_wait_fresh_res; 122 123 /* Chip parameters */ 124 struct apds990x_chip_factors cf; 125 struct reverse_factors rcf; 126 u16 atime; /* als integration time */ 127 u16 arate; /* als reporting rate */ 128 u16 a_max_result; /* Max possible ADC value with current atime */ 129 u8 again_meas; /* Gain used in last measurement */ 130 u8 again_next; /* Next calculated gain */ 131 u8 pgain; 132 u8 pdiode; 133 u8 pdrive; 134 u8 lux_persistence; 135 u8 prox_persistence; 136 137 u32 lux_raw; 138 u32 lux; 139 u16 lux_clear; 140 u16 lux_ir; 141 u16 lux_calib; 142 u32 lux_thres_hi; 143 u32 lux_thres_lo; 144 145 u32 prox_thres; 146 u16 prox_data; 147 u16 prox_calib; 148 149 char chipname[10]; 150 u8 revision; 151 }; 152 153 #define APDS_CALIB_SCALER 8192 154 #define APDS_LUX_NEUTRAL_CALIB_VALUE (1 * APDS_CALIB_SCALER) 155 #define APDS_PROX_NEUTRAL_CALIB_VALUE (1 * APDS_CALIB_SCALER) 156 157 #define APDS_PROX_DEF_THRES 600 158 #define APDS_PROX_HYSTERESIS 50 159 #define APDS_LUX_DEF_THRES_HI 101 160 #define APDS_LUX_DEF_THRES_LO 100 161 #define APDS_DEFAULT_PROX_PERS 1 162 163 #define APDS_TIMEOUT 2000 164 #define APDS_STARTUP_DELAY 25000 /* us */ 165 #define APDS_RANGE 65535 166 #define APDS_PROX_RANGE 1023 167 #define APDS_LUX_GAIN_LO_LIMIT 100 168 #define APDS_LUX_GAIN_LO_LIMIT_STRICT 25 169 170 #define TIMESTEP 87 /* 2.7ms is about 87 / 32 */ 171 #define TIME_STEP_SCALER 32 172 173 #define APDS_LUX_AVERAGING_TIME 50 /* tolerates 50/60Hz ripple */ 174 #define APDS_LUX_DEFAULT_RATE 200 175 176 static const u8 again[] = {1, 8, 16, 120}; /* ALS gain steps */ 177 178 /* Following two tables must match i.e 10Hz rate means 1 as persistence value */ 179 static const u16 arates_hz[] = {10, 5, 2, 1}; 180 static const u8 apersis[] = {1, 2, 4, 5}; 181 182 /* Regulators */ 183 static const char reg_vcc[] = "Vdd"; 184 static const char reg_vled[] = "Vled"; 185 186 static int apds990x_read_byte(struct apds990x_chip *chip, u8 reg, u8 *data) 187 { 188 struct i2c_client *client = chip->client; 189 s32 ret; 190 191 reg &= ~APDS990x_CMD_TYPE_MASK; 192 reg |= APDS990x_CMD | APDS990x_CMD_TYPE_RB; 193 194 ret = i2c_smbus_read_byte_data(client, reg); 195 *data = ret; 196 return (int)ret; 197 } 198 199 static int apds990x_read_word(struct apds990x_chip *chip, u8 reg, u16 *data) 200 { 201 struct i2c_client *client = chip->client; 202 s32 ret; 203 204 reg &= ~APDS990x_CMD_TYPE_MASK; 205 reg |= APDS990x_CMD | APDS990x_CMD_TYPE_INC; 206 207 ret = i2c_smbus_read_word_data(client, reg); 208 *data = ret; 209 return (int)ret; 210 } 211 212 static int apds990x_write_byte(struct apds990x_chip *chip, u8 reg, u8 data) 213 { 214 struct i2c_client *client = chip->client; 215 s32 ret; 216 217 reg &= ~APDS990x_CMD_TYPE_MASK; 218 reg |= APDS990x_CMD | APDS990x_CMD_TYPE_RB; 219 220 ret = i2c_smbus_write_byte_data(client, reg, data); 221 return (int)ret; 222 } 223 224 static int apds990x_write_word(struct apds990x_chip *chip, u8 reg, u16 data) 225 { 226 struct i2c_client *client = chip->client; 227 s32 ret; 228 229 reg &= ~APDS990x_CMD_TYPE_MASK; 230 reg |= APDS990x_CMD | APDS990x_CMD_TYPE_INC; 231 232 ret = i2c_smbus_write_word_data(client, reg, data); 233 return (int)ret; 234 } 235 236 static int apds990x_mode_on(struct apds990x_chip *chip) 237 { 238 /* ALS is mandatory, proximity optional */ 239 u8 reg = APDS990X_EN_AIEN | APDS990X_EN_PON | APDS990X_EN_AEN | 240 APDS990X_EN_WEN; 241 242 if (chip->prox_en) 243 reg |= APDS990X_EN_PIEN | APDS990X_EN_PEN; 244 245 return apds990x_write_byte(chip, APDS990X_ENABLE, reg); 246 } 247 248 static u16 apds990x_lux_to_threshold(struct apds990x_chip *chip, u32 lux) 249 { 250 u32 thres; 251 u32 cpl; 252 u32 ir; 253 254 if (lux == 0) 255 return 0; 256 else if (lux == APDS_RANGE) 257 return APDS_RANGE; 258 259 /* 260 * Reported LUX value is a combination of the IR and CLEAR channel 261 * values. However, interrupt threshold is only for clear channel. 262 * This function approximates needed HW threshold value for a given 263 * LUX value in the current lightning type. 264 * IR level compared to visible light varies heavily depending on the 265 * source of the light 266 * 267 * Calculate threshold value for the next measurement period. 268 * Math: threshold = lux * cpl where 269 * cpl = atime * again / (glass_attenuation * device_factor) 270 * (count-per-lux) 271 * 272 * First remove calibration. Division by four is to avoid overflow 273 */ 274 lux = lux * (APDS_CALIB_SCALER / 4) / (chip->lux_calib / 4); 275 276 /* Multiplication by 64 is to increase accuracy */ 277 cpl = ((u32)chip->atime * (u32)again[chip->again_next] * 278 APDS_PARAM_SCALE * 64) / (chip->cf.ga * chip->cf.df); 279 280 thres = lux * cpl / 64; 281 /* 282 * Convert IR light from the latest result to match with 283 * new gain step. This helps to adapt with the current 284 * source of light. 285 */ 286 ir = (u32)chip->lux_ir * (u32)again[chip->again_next] / 287 (u32)again[chip->again_meas]; 288 289 /* 290 * Compensate count with IR light impact 291 * IAC1 > IAC2 (see apds990x_get_lux for formulas) 292 */ 293 if (chip->lux_clear * APDS_PARAM_SCALE >= 294 chip->rcf.afactor * chip->lux_ir) 295 thres = (chip->rcf.cf1 * thres + chip->rcf.irf1 * ir) / 296 APDS_PARAM_SCALE; 297 else 298 thres = (chip->rcf.cf2 * thres + chip->rcf.irf2 * ir) / 299 APDS_PARAM_SCALE; 300 301 if (thres >= chip->a_max_result) 302 thres = chip->a_max_result - 1; 303 return thres; 304 } 305 306 static inline int apds990x_set_atime(struct apds990x_chip *chip, u32 time_ms) 307 { 308 u8 reg_value; 309 310 chip->atime = time_ms; 311 /* Formula is specified in the data sheet */ 312 reg_value = 256 - ((time_ms * TIME_STEP_SCALER) / TIMESTEP); 313 /* Calculate max ADC value for given integration time */ 314 chip->a_max_result = (u16)(256 - reg_value) * APDS990X_TIME_TO_ADC; 315 return apds990x_write_byte(chip, APDS990X_ATIME, reg_value); 316 } 317 318 /* Called always with mutex locked */ 319 static int apds990x_refresh_pthres(struct apds990x_chip *chip, int data) 320 { 321 int ret, lo, hi; 322 323 /* If the chip is not in use, don't try to access it */ 324 if (pm_runtime_suspended(&chip->client->dev)) 325 return 0; 326 327 if (data < chip->prox_thres) { 328 lo = 0; 329 hi = chip->prox_thres; 330 } else { 331 lo = chip->prox_thres - APDS_PROX_HYSTERESIS; 332 if (chip->prox_continuous_mode) 333 hi = chip->prox_thres; 334 else 335 hi = APDS_RANGE; 336 } 337 338 ret = apds990x_write_word(chip, APDS990X_PILTL, lo); 339 ret |= apds990x_write_word(chip, APDS990X_PIHTL, hi); 340 return ret; 341 } 342 343 /* Called always with mutex locked */ 344 static int apds990x_refresh_athres(struct apds990x_chip *chip) 345 { 346 int ret; 347 /* If the chip is not in use, don't try to access it */ 348 if (pm_runtime_suspended(&chip->client->dev)) 349 return 0; 350 351 ret = apds990x_write_word(chip, APDS990X_AILTL, 352 apds990x_lux_to_threshold(chip, chip->lux_thres_lo)); 353 ret |= apds990x_write_word(chip, APDS990X_AIHTL, 354 apds990x_lux_to_threshold(chip, chip->lux_thres_hi)); 355 356 return ret; 357 } 358 359 /* Called always with mutex locked */ 360 static void apds990x_force_a_refresh(struct apds990x_chip *chip) 361 { 362 /* This will force ALS interrupt after the next measurement. */ 363 apds990x_write_word(chip, APDS990X_AILTL, APDS_LUX_DEF_THRES_LO); 364 apds990x_write_word(chip, APDS990X_AIHTL, APDS_LUX_DEF_THRES_HI); 365 } 366 367 /* Called always with mutex locked */ 368 static void apds990x_force_p_refresh(struct apds990x_chip *chip) 369 { 370 /* This will force proximity interrupt after the next measurement. */ 371 apds990x_write_word(chip, APDS990X_PILTL, APDS_PROX_DEF_THRES - 1); 372 apds990x_write_word(chip, APDS990X_PIHTL, APDS_PROX_DEF_THRES); 373 } 374 375 /* Called always with mutex locked */ 376 static int apds990x_calc_again(struct apds990x_chip *chip) 377 { 378 int curr_again = chip->again_meas; 379 int next_again = chip->again_meas; 380 int ret = 0; 381 382 /* Calculate suitable als gain */ 383 if (chip->lux_clear == chip->a_max_result) 384 next_again -= 2; /* ALS saturated. Decrease gain by 2 steps */ 385 else if (chip->lux_clear > chip->a_max_result / 2) 386 next_again--; 387 else if (chip->lux_clear < APDS_LUX_GAIN_LO_LIMIT_STRICT) 388 next_again += 2; /* Too dark. Increase gain by 2 steps */ 389 else if (chip->lux_clear < APDS_LUX_GAIN_LO_LIMIT) 390 next_again++; 391 392 /* Limit gain to available range */ 393 if (next_again < 0) 394 next_again = 0; 395 else if (next_again > APDS990X_MAX_AGAIN) 396 next_again = APDS990X_MAX_AGAIN; 397 398 /* Let's check can we trust the measured result */ 399 if (chip->lux_clear == chip->a_max_result) 400 /* Result can be totally garbage due to saturation */ 401 ret = -ERANGE; 402 else if (next_again != curr_again && 403 chip->lux_clear < APDS_LUX_GAIN_LO_LIMIT_STRICT) 404 /* 405 * Gain is changed and measurement result is very small. 406 * Result can be totally garbage due to underflow 407 */ 408 ret = -ERANGE; 409 410 chip->again_next = next_again; 411 apds990x_write_byte(chip, APDS990X_CONTROL, 412 (chip->pdrive << 6) | 413 (chip->pdiode << 4) | 414 (chip->pgain << 2) | 415 (chip->again_next << 0)); 416 417 /* 418 * Error means bad result -> re-measurement is needed. The forced 419 * refresh uses fastest possible persistence setting to get result 420 * as soon as possible. 421 */ 422 if (ret < 0) 423 apds990x_force_a_refresh(chip); 424 else 425 apds990x_refresh_athres(chip); 426 427 return ret; 428 } 429 430 /* Called always with mutex locked */ 431 static int apds990x_get_lux(struct apds990x_chip *chip, int clear, int ir) 432 { 433 int iac, iac1, iac2; /* IR adjusted counts */ 434 u32 lpc; /* Lux per count */ 435 436 /* Formulas: 437 * iac1 = CF1 * CLEAR_CH - IRF1 * IR_CH 438 * iac2 = CF2 * CLEAR_CH - IRF2 * IR_CH 439 */ 440 iac1 = (chip->cf.cf1 * clear - chip->cf.irf1 * ir) / APDS_PARAM_SCALE; 441 iac2 = (chip->cf.cf2 * clear - chip->cf.irf2 * ir) / APDS_PARAM_SCALE; 442 443 iac = max(iac1, iac2); 444 iac = max(iac, 0); 445 446 lpc = APDS990X_LUX_OUTPUT_SCALE * (chip->cf.df * chip->cf.ga) / 447 (u32)(again[chip->again_meas] * (u32)chip->atime); 448 449 return (iac * lpc) / APDS_PARAM_SCALE; 450 } 451 452 static int apds990x_ack_int(struct apds990x_chip *chip, u8 mode) 453 { 454 struct i2c_client *client = chip->client; 455 s32 ret; 456 u8 reg = APDS990x_CMD | APDS990x_CMD_TYPE_SPE; 457 458 switch (mode & (APDS990X_ST_AINT | APDS990X_ST_PINT)) { 459 case APDS990X_ST_AINT: 460 reg |= APDS990X_INT_ACK_ALS; 461 break; 462 case APDS990X_ST_PINT: 463 reg |= APDS990X_INT_ACK_PS; 464 break; 465 default: 466 reg |= APDS990X_INT_ACK_BOTH; 467 break; 468 } 469 470 ret = i2c_smbus_read_byte_data(client, reg); 471 return (int)ret; 472 } 473 474 static irqreturn_t apds990x_irq(int irq, void *data) 475 { 476 struct apds990x_chip *chip = data; 477 u8 status; 478 479 apds990x_read_byte(chip, APDS990X_STATUS, &status); 480 apds990x_ack_int(chip, status); 481 482 mutex_lock(&chip->mutex); 483 if (!pm_runtime_suspended(&chip->client->dev)) { 484 if (status & APDS990X_ST_AINT) { 485 apds990x_read_word(chip, APDS990X_CDATAL, 486 &chip->lux_clear); 487 apds990x_read_word(chip, APDS990X_IRDATAL, 488 &chip->lux_ir); 489 /* Store used gain for calculations */ 490 chip->again_meas = chip->again_next; 491 492 chip->lux_raw = apds990x_get_lux(chip, 493 chip->lux_clear, 494 chip->lux_ir); 495 496 if (apds990x_calc_again(chip) == 0) { 497 /* Result is valid */ 498 chip->lux = chip->lux_raw; 499 chip->lux_wait_fresh_res = false; 500 wake_up(&chip->wait); 501 sysfs_notify(&chip->client->dev.kobj, 502 NULL, "lux0_input"); 503 } 504 } 505 506 if ((status & APDS990X_ST_PINT) && chip->prox_en) { 507 u16 clr_ch; 508 509 apds990x_read_word(chip, APDS990X_CDATAL, &clr_ch); 510 /* 511 * If ALS channel is saturated at min gain, 512 * proximity gives false posivite values. 513 * Just ignore them. 514 */ 515 if (chip->again_meas == 0 && 516 clr_ch == chip->a_max_result) 517 chip->prox_data = 0; 518 else 519 apds990x_read_word(chip, 520 APDS990X_PDATAL, 521 &chip->prox_data); 522 523 apds990x_refresh_pthres(chip, chip->prox_data); 524 if (chip->prox_data < chip->prox_thres) 525 chip->prox_data = 0; 526 else if (!chip->prox_continuous_mode) 527 chip->prox_data = APDS_PROX_RANGE; 528 sysfs_notify(&chip->client->dev.kobj, 529 NULL, "prox0_raw"); 530 } 531 } 532 mutex_unlock(&chip->mutex); 533 return IRQ_HANDLED; 534 } 535 536 static int apds990x_configure(struct apds990x_chip *chip) 537 { 538 /* It is recommended to use disabled mode during these operations */ 539 apds990x_write_byte(chip, APDS990X_ENABLE, APDS990X_EN_DISABLE_ALL); 540 541 /* conversion and wait times for different state machince states */ 542 apds990x_write_byte(chip, APDS990X_PTIME, APDS990X_PTIME_DEFAULT); 543 apds990x_write_byte(chip, APDS990X_WTIME, APDS990X_WTIME_DEFAULT); 544 apds990x_set_atime(chip, APDS_LUX_AVERAGING_TIME); 545 546 apds990x_write_byte(chip, APDS990X_CONFIG, 0); 547 548 /* Persistence levels */ 549 apds990x_write_byte(chip, APDS990X_PERS, 550 (chip->lux_persistence << APDS990X_APERS_SHIFT) | 551 (chip->prox_persistence << APDS990X_PPERS_SHIFT)); 552 553 apds990x_write_byte(chip, APDS990X_PPCOUNT, chip->pdata->ppcount); 554 555 /* Start with relatively small gain */ 556 chip->again_meas = 1; 557 chip->again_next = 1; 558 apds990x_write_byte(chip, APDS990X_CONTROL, 559 (chip->pdrive << 6) | 560 (chip->pdiode << 4) | 561 (chip->pgain << 2) | 562 (chip->again_next << 0)); 563 return 0; 564 } 565 566 static int apds990x_detect(struct apds990x_chip *chip) 567 { 568 struct i2c_client *client = chip->client; 569 int ret; 570 u8 id; 571 572 ret = apds990x_read_byte(chip, APDS990X_ID, &id); 573 if (ret < 0) { 574 dev_err(&client->dev, "ID read failed\n"); 575 return ret; 576 } 577 578 ret = apds990x_read_byte(chip, APDS990X_REV, &chip->revision); 579 if (ret < 0) { 580 dev_err(&client->dev, "REV read failed\n"); 581 return ret; 582 } 583 584 switch (id) { 585 case APDS990X_ID_0: 586 case APDS990X_ID_4: 587 case APDS990X_ID_29: 588 snprintf(chip->chipname, sizeof(chip->chipname), "APDS-990x"); 589 break; 590 default: 591 ret = -ENODEV; 592 break; 593 } 594 return ret; 595 } 596 597 #ifdef CONFIG_PM 598 static int apds990x_chip_on(struct apds990x_chip *chip) 599 { 600 int err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), 601 chip->regs); 602 if (err < 0) 603 return err; 604 605 usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY); 606 607 /* Refresh all configs in case of regulators were off */ 608 chip->prox_data = 0; 609 apds990x_configure(chip); 610 apds990x_mode_on(chip); 611 return 0; 612 } 613 #endif 614 615 static int apds990x_chip_off(struct apds990x_chip *chip) 616 { 617 apds990x_write_byte(chip, APDS990X_ENABLE, APDS990X_EN_DISABLE_ALL); 618 regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); 619 return 0; 620 } 621 622 static ssize_t apds990x_lux_show(struct device *dev, 623 struct device_attribute *attr, char *buf) 624 { 625 struct apds990x_chip *chip = dev_get_drvdata(dev); 626 ssize_t ret; 627 u32 result; 628 long timeout; 629 630 if (pm_runtime_suspended(dev)) 631 return -EIO; 632 633 timeout = wait_event_interruptible_timeout(chip->wait, 634 !chip->lux_wait_fresh_res, 635 msecs_to_jiffies(APDS_TIMEOUT)); 636 if (!timeout) 637 return -EIO; 638 639 mutex_lock(&chip->mutex); 640 result = (chip->lux * chip->lux_calib) / APDS_CALIB_SCALER; 641 if (result > (APDS_RANGE * APDS990X_LUX_OUTPUT_SCALE)) 642 result = APDS_RANGE * APDS990X_LUX_OUTPUT_SCALE; 643 644 ret = sprintf(buf, "%d.%d\n", 645 result / APDS990X_LUX_OUTPUT_SCALE, 646 result % APDS990X_LUX_OUTPUT_SCALE); 647 mutex_unlock(&chip->mutex); 648 return ret; 649 } 650 651 static DEVICE_ATTR(lux0_input, S_IRUGO, apds990x_lux_show, NULL); 652 653 static ssize_t apds990x_lux_range_show(struct device *dev, 654 struct device_attribute *attr, char *buf) 655 { 656 return sprintf(buf, "%u\n", APDS_RANGE); 657 } 658 659 static DEVICE_ATTR(lux0_sensor_range, S_IRUGO, apds990x_lux_range_show, NULL); 660 661 static ssize_t apds990x_lux_calib_format_show(struct device *dev, 662 struct device_attribute *attr, char *buf) 663 { 664 return sprintf(buf, "%u\n", APDS_CALIB_SCALER); 665 } 666 667 static DEVICE_ATTR(lux0_calibscale_default, S_IRUGO, 668 apds990x_lux_calib_format_show, NULL); 669 670 static ssize_t apds990x_lux_calib_show(struct device *dev, 671 struct device_attribute *attr, char *buf) 672 { 673 struct apds990x_chip *chip = dev_get_drvdata(dev); 674 675 return sprintf(buf, "%u\n", chip->lux_calib); 676 } 677 678 static ssize_t apds990x_lux_calib_store(struct device *dev, 679 struct device_attribute *attr, 680 const char *buf, size_t len) 681 { 682 struct apds990x_chip *chip = dev_get_drvdata(dev); 683 unsigned long value; 684 int ret; 685 686 ret = kstrtoul(buf, 0, &value); 687 if (ret) 688 return ret; 689 690 chip->lux_calib = value; 691 692 return len; 693 } 694 695 static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, apds990x_lux_calib_show, 696 apds990x_lux_calib_store); 697 698 static ssize_t apds990x_rate_avail(struct device *dev, 699 struct device_attribute *attr, char *buf) 700 { 701 int i; 702 int pos = 0; 703 704 for (i = 0; i < ARRAY_SIZE(arates_hz); i++) 705 pos += sprintf(buf + pos, "%d ", arates_hz[i]); 706 sprintf(buf + pos - 1, "\n"); 707 return pos; 708 } 709 710 static ssize_t apds990x_rate_show(struct device *dev, 711 struct device_attribute *attr, char *buf) 712 { 713 struct apds990x_chip *chip = dev_get_drvdata(dev); 714 715 return sprintf(buf, "%d\n", chip->arate); 716 } 717 718 static int apds990x_set_arate(struct apds990x_chip *chip, int rate) 719 { 720 int i; 721 722 for (i = 0; i < ARRAY_SIZE(arates_hz); i++) 723 if (rate >= arates_hz[i]) 724 break; 725 726 if (i == ARRAY_SIZE(arates_hz)) 727 return -EINVAL; 728 729 /* Pick up corresponding persistence value */ 730 chip->lux_persistence = apersis[i]; 731 chip->arate = arates_hz[i]; 732 733 /* If the chip is not in use, don't try to access it */ 734 if (pm_runtime_suspended(&chip->client->dev)) 735 return 0; 736 737 /* Persistence levels */ 738 return apds990x_write_byte(chip, APDS990X_PERS, 739 (chip->lux_persistence << APDS990X_APERS_SHIFT) | 740 (chip->prox_persistence << APDS990X_PPERS_SHIFT)); 741 } 742 743 static ssize_t apds990x_rate_store(struct device *dev, 744 struct device_attribute *attr, 745 const char *buf, size_t len) 746 { 747 struct apds990x_chip *chip = dev_get_drvdata(dev); 748 unsigned long value; 749 int ret; 750 751 ret = kstrtoul(buf, 0, &value); 752 if (ret) 753 return ret; 754 755 mutex_lock(&chip->mutex); 756 ret = apds990x_set_arate(chip, value); 757 mutex_unlock(&chip->mutex); 758 759 if (ret < 0) 760 return ret; 761 return len; 762 } 763 764 static DEVICE_ATTR(lux0_rate_avail, S_IRUGO, apds990x_rate_avail, NULL); 765 766 static DEVICE_ATTR(lux0_rate, S_IRUGO | S_IWUSR, apds990x_rate_show, 767 apds990x_rate_store); 768 769 static ssize_t apds990x_prox_show(struct device *dev, 770 struct device_attribute *attr, char *buf) 771 { 772 ssize_t ret; 773 struct apds990x_chip *chip = dev_get_drvdata(dev); 774 775 if (pm_runtime_suspended(dev) || !chip->prox_en) 776 return -EIO; 777 778 mutex_lock(&chip->mutex); 779 ret = sprintf(buf, "%d\n", chip->prox_data); 780 mutex_unlock(&chip->mutex); 781 return ret; 782 } 783 784 static DEVICE_ATTR(prox0_raw, S_IRUGO, apds990x_prox_show, NULL); 785 786 static ssize_t apds990x_prox_range_show(struct device *dev, 787 struct device_attribute *attr, char *buf) 788 { 789 return sprintf(buf, "%u\n", APDS_PROX_RANGE); 790 } 791 792 static DEVICE_ATTR(prox0_sensor_range, S_IRUGO, apds990x_prox_range_show, NULL); 793 794 static ssize_t apds990x_prox_enable_show(struct device *dev, 795 struct device_attribute *attr, char *buf) 796 { 797 struct apds990x_chip *chip = dev_get_drvdata(dev); 798 799 return sprintf(buf, "%d\n", chip->prox_en); 800 } 801 802 static ssize_t apds990x_prox_enable_store(struct device *dev, 803 struct device_attribute *attr, 804 const char *buf, size_t len) 805 { 806 struct apds990x_chip *chip = dev_get_drvdata(dev); 807 unsigned long value; 808 int ret; 809 810 ret = kstrtoul(buf, 0, &value); 811 if (ret) 812 return ret; 813 814 mutex_lock(&chip->mutex); 815 816 if (!chip->prox_en) 817 chip->prox_data = 0; 818 819 if (value) 820 chip->prox_en++; 821 else if (chip->prox_en > 0) 822 chip->prox_en--; 823 824 if (!pm_runtime_suspended(dev)) 825 apds990x_mode_on(chip); 826 mutex_unlock(&chip->mutex); 827 return len; 828 } 829 830 static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, apds990x_prox_enable_show, 831 apds990x_prox_enable_store); 832 833 static const char *reporting_modes[] = {"trigger", "periodic"}; 834 835 static ssize_t apds990x_prox_reporting_mode_show(struct device *dev, 836 struct device_attribute *attr, char *buf) 837 { 838 struct apds990x_chip *chip = dev_get_drvdata(dev); 839 840 return sprintf(buf, "%s\n", 841 reporting_modes[!!chip->prox_continuous_mode]); 842 } 843 844 static ssize_t apds990x_prox_reporting_mode_store(struct device *dev, 845 struct device_attribute *attr, 846 const char *buf, size_t len) 847 { 848 struct apds990x_chip *chip = dev_get_drvdata(dev); 849 int ret; 850 851 ret = sysfs_match_string(reporting_modes, buf); 852 if (ret < 0) 853 return ret; 854 855 chip->prox_continuous_mode = ret; 856 return len; 857 } 858 859 static DEVICE_ATTR(prox0_reporting_mode, S_IRUGO | S_IWUSR, 860 apds990x_prox_reporting_mode_show, 861 apds990x_prox_reporting_mode_store); 862 863 static ssize_t apds990x_prox_reporting_avail_show(struct device *dev, 864 struct device_attribute *attr, char *buf) 865 { 866 return sprintf(buf, "%s %s\n", reporting_modes[0], reporting_modes[1]); 867 } 868 869 static DEVICE_ATTR(prox0_reporting_mode_avail, S_IRUGO | S_IWUSR, 870 apds990x_prox_reporting_avail_show, NULL); 871 872 873 static ssize_t apds990x_lux_thresh_above_show(struct device *dev, 874 struct device_attribute *attr, char *buf) 875 { 876 struct apds990x_chip *chip = dev_get_drvdata(dev); 877 878 return sprintf(buf, "%d\n", chip->lux_thres_hi); 879 } 880 881 static ssize_t apds990x_lux_thresh_below_show(struct device *dev, 882 struct device_attribute *attr, char *buf) 883 { 884 struct apds990x_chip *chip = dev_get_drvdata(dev); 885 886 return sprintf(buf, "%d\n", chip->lux_thres_lo); 887 } 888 889 static ssize_t apds990x_set_lux_thresh(struct apds990x_chip *chip, u32 *target, 890 const char *buf) 891 { 892 unsigned long thresh; 893 int ret; 894 895 ret = kstrtoul(buf, 0, &thresh); 896 if (ret) 897 return ret; 898 899 if (thresh > APDS_RANGE) 900 return -EINVAL; 901 902 mutex_lock(&chip->mutex); 903 *target = thresh; 904 /* 905 * Don't update values in HW if we are still waiting for 906 * first interrupt to come after device handle open call. 907 */ 908 if (!chip->lux_wait_fresh_res) 909 apds990x_refresh_athres(chip); 910 mutex_unlock(&chip->mutex); 911 return ret; 912 913 } 914 915 static ssize_t apds990x_lux_thresh_above_store(struct device *dev, 916 struct device_attribute *attr, 917 const char *buf, size_t len) 918 { 919 struct apds990x_chip *chip = dev_get_drvdata(dev); 920 int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_hi, buf); 921 922 if (ret < 0) 923 return ret; 924 return len; 925 } 926 927 static ssize_t apds990x_lux_thresh_below_store(struct device *dev, 928 struct device_attribute *attr, 929 const char *buf, size_t len) 930 { 931 struct apds990x_chip *chip = dev_get_drvdata(dev); 932 int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_lo, buf); 933 934 if (ret < 0) 935 return ret; 936 return len; 937 } 938 939 static DEVICE_ATTR(lux0_thresh_above_value, S_IRUGO | S_IWUSR, 940 apds990x_lux_thresh_above_show, 941 apds990x_lux_thresh_above_store); 942 943 static DEVICE_ATTR(lux0_thresh_below_value, S_IRUGO | S_IWUSR, 944 apds990x_lux_thresh_below_show, 945 apds990x_lux_thresh_below_store); 946 947 static ssize_t apds990x_prox_threshold_show(struct device *dev, 948 struct device_attribute *attr, char *buf) 949 { 950 struct apds990x_chip *chip = dev_get_drvdata(dev); 951 952 return sprintf(buf, "%d\n", chip->prox_thres); 953 } 954 955 static ssize_t apds990x_prox_threshold_store(struct device *dev, 956 struct device_attribute *attr, 957 const char *buf, size_t len) 958 { 959 struct apds990x_chip *chip = dev_get_drvdata(dev); 960 unsigned long value; 961 int ret; 962 963 ret = kstrtoul(buf, 0, &value); 964 if (ret) 965 return ret; 966 967 if ((value > APDS_RANGE) || (value == 0) || 968 (value < APDS_PROX_HYSTERESIS)) 969 return -EINVAL; 970 971 mutex_lock(&chip->mutex); 972 chip->prox_thres = value; 973 974 apds990x_force_p_refresh(chip); 975 mutex_unlock(&chip->mutex); 976 return len; 977 } 978 979 static DEVICE_ATTR(prox0_thresh_above_value, S_IRUGO | S_IWUSR, 980 apds990x_prox_threshold_show, 981 apds990x_prox_threshold_store); 982 983 static ssize_t apds990x_power_state_show(struct device *dev, 984 struct device_attribute *attr, char *buf) 985 { 986 return sprintf(buf, "%d\n", !pm_runtime_suspended(dev)); 987 return 0; 988 } 989 990 static ssize_t apds990x_power_state_store(struct device *dev, 991 struct device_attribute *attr, 992 const char *buf, size_t len) 993 { 994 struct apds990x_chip *chip = dev_get_drvdata(dev); 995 unsigned long value; 996 int ret; 997 998 ret = kstrtoul(buf, 0, &value); 999 if (ret) 1000 return ret; 1001 1002 if (value) { 1003 pm_runtime_get_sync(dev); 1004 mutex_lock(&chip->mutex); 1005 chip->lux_wait_fresh_res = true; 1006 apds990x_force_a_refresh(chip); 1007 apds990x_force_p_refresh(chip); 1008 mutex_unlock(&chip->mutex); 1009 } else { 1010 if (!pm_runtime_suspended(dev)) 1011 pm_runtime_put(dev); 1012 } 1013 return len; 1014 } 1015 1016 static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR, 1017 apds990x_power_state_show, 1018 apds990x_power_state_store); 1019 1020 static ssize_t apds990x_chip_id_show(struct device *dev, 1021 struct device_attribute *attr, char *buf) 1022 { 1023 struct apds990x_chip *chip = dev_get_drvdata(dev); 1024 1025 return sprintf(buf, "%s %d\n", chip->chipname, chip->revision); 1026 } 1027 1028 static DEVICE_ATTR(chip_id, S_IRUGO, apds990x_chip_id_show, NULL); 1029 1030 static struct attribute *sysfs_attrs_ctrl[] = { 1031 &dev_attr_lux0_calibscale.attr, 1032 &dev_attr_lux0_calibscale_default.attr, 1033 &dev_attr_lux0_input.attr, 1034 &dev_attr_lux0_sensor_range.attr, 1035 &dev_attr_lux0_rate.attr, 1036 &dev_attr_lux0_rate_avail.attr, 1037 &dev_attr_lux0_thresh_above_value.attr, 1038 &dev_attr_lux0_thresh_below_value.attr, 1039 &dev_attr_prox0_raw_en.attr, 1040 &dev_attr_prox0_raw.attr, 1041 &dev_attr_prox0_sensor_range.attr, 1042 &dev_attr_prox0_thresh_above_value.attr, 1043 &dev_attr_prox0_reporting_mode.attr, 1044 &dev_attr_prox0_reporting_mode_avail.attr, 1045 &dev_attr_chip_id.attr, 1046 &dev_attr_power_state.attr, 1047 NULL 1048 }; 1049 1050 static const struct attribute_group apds990x_attribute_group[] = { 1051 {.attrs = sysfs_attrs_ctrl }, 1052 }; 1053 1054 static int apds990x_probe(struct i2c_client *client, 1055 const struct i2c_device_id *id) 1056 { 1057 struct apds990x_chip *chip; 1058 int err; 1059 1060 chip = kzalloc(sizeof *chip, GFP_KERNEL); 1061 if (!chip) 1062 return -ENOMEM; 1063 1064 i2c_set_clientdata(client, chip); 1065 chip->client = client; 1066 1067 init_waitqueue_head(&chip->wait); 1068 mutex_init(&chip->mutex); 1069 chip->pdata = client->dev.platform_data; 1070 1071 if (chip->pdata == NULL) { 1072 dev_err(&client->dev, "platform data is mandatory\n"); 1073 err = -EINVAL; 1074 goto fail1; 1075 } 1076 1077 if (chip->pdata->cf.ga == 0) { 1078 /* set uncovered sensor default parameters */ 1079 chip->cf.ga = 1966; /* 0.48 * APDS_PARAM_SCALE */ 1080 chip->cf.cf1 = 4096; /* 1.00 * APDS_PARAM_SCALE */ 1081 chip->cf.irf1 = 9134; /* 2.23 * APDS_PARAM_SCALE */ 1082 chip->cf.cf2 = 2867; /* 0.70 * APDS_PARAM_SCALE */ 1083 chip->cf.irf2 = 5816; /* 1.42 * APDS_PARAM_SCALE */ 1084 chip->cf.df = 52; 1085 } else { 1086 chip->cf = chip->pdata->cf; 1087 } 1088 1089 /* precalculate inverse chip factors for threshold control */ 1090 chip->rcf.afactor = 1091 (chip->cf.irf1 - chip->cf.irf2) * APDS_PARAM_SCALE / 1092 (chip->cf.cf1 - chip->cf.cf2); 1093 chip->rcf.cf1 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / 1094 chip->cf.cf1; 1095 chip->rcf.irf1 = chip->cf.irf1 * APDS_PARAM_SCALE / 1096 chip->cf.cf1; 1097 chip->rcf.cf2 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / 1098 chip->cf.cf2; 1099 chip->rcf.irf2 = chip->cf.irf2 * APDS_PARAM_SCALE / 1100 chip->cf.cf2; 1101 1102 /* Set something to start with */ 1103 chip->lux_thres_hi = APDS_LUX_DEF_THRES_HI; 1104 chip->lux_thres_lo = APDS_LUX_DEF_THRES_LO; 1105 chip->lux_calib = APDS_LUX_NEUTRAL_CALIB_VALUE; 1106 1107 chip->prox_thres = APDS_PROX_DEF_THRES; 1108 chip->pdrive = chip->pdata->pdrive; 1109 chip->pdiode = APDS_PDIODE_IR; 1110 chip->pgain = APDS_PGAIN_1X; 1111 chip->prox_calib = APDS_PROX_NEUTRAL_CALIB_VALUE; 1112 chip->prox_persistence = APDS_DEFAULT_PROX_PERS; 1113 chip->prox_continuous_mode = false; 1114 1115 chip->regs[0].supply = reg_vcc; 1116 chip->regs[1].supply = reg_vled; 1117 1118 err = regulator_bulk_get(&client->dev, 1119 ARRAY_SIZE(chip->regs), chip->regs); 1120 if (err < 0) { 1121 dev_err(&client->dev, "Cannot get regulators\n"); 1122 goto fail1; 1123 } 1124 1125 err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs); 1126 if (err < 0) { 1127 dev_err(&client->dev, "Cannot enable regulators\n"); 1128 goto fail2; 1129 } 1130 1131 usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY); 1132 1133 err = apds990x_detect(chip); 1134 if (err < 0) { 1135 dev_err(&client->dev, "APDS990X not found\n"); 1136 goto fail3; 1137 } 1138 1139 pm_runtime_set_active(&client->dev); 1140 1141 apds990x_configure(chip); 1142 apds990x_set_arate(chip, APDS_LUX_DEFAULT_RATE); 1143 apds990x_mode_on(chip); 1144 1145 pm_runtime_enable(&client->dev); 1146 1147 if (chip->pdata->setup_resources) { 1148 err = chip->pdata->setup_resources(); 1149 if (err) { 1150 err = -EINVAL; 1151 goto fail3; 1152 } 1153 } 1154 1155 err = sysfs_create_group(&chip->client->dev.kobj, 1156 apds990x_attribute_group); 1157 if (err < 0) { 1158 dev_err(&chip->client->dev, "Sysfs registration failed\n"); 1159 goto fail4; 1160 } 1161 1162 err = request_threaded_irq(client->irq, NULL, 1163 apds990x_irq, 1164 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_LOW | 1165 IRQF_ONESHOT, 1166 "apds990x", chip); 1167 if (err) { 1168 dev_err(&client->dev, "could not get IRQ %d\n", 1169 client->irq); 1170 goto fail5; 1171 } 1172 return err; 1173 fail5: 1174 sysfs_remove_group(&chip->client->dev.kobj, 1175 &apds990x_attribute_group[0]); 1176 fail4: 1177 if (chip->pdata && chip->pdata->release_resources) 1178 chip->pdata->release_resources(); 1179 fail3: 1180 regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); 1181 fail2: 1182 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); 1183 fail1: 1184 kfree(chip); 1185 return err; 1186 } 1187 1188 static void apds990x_remove(struct i2c_client *client) 1189 { 1190 struct apds990x_chip *chip = i2c_get_clientdata(client); 1191 1192 free_irq(client->irq, chip); 1193 sysfs_remove_group(&chip->client->dev.kobj, 1194 apds990x_attribute_group); 1195 1196 if (chip->pdata && chip->pdata->release_resources) 1197 chip->pdata->release_resources(); 1198 1199 if (!pm_runtime_suspended(&client->dev)) 1200 apds990x_chip_off(chip); 1201 1202 pm_runtime_disable(&client->dev); 1203 pm_runtime_set_suspended(&client->dev); 1204 1205 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); 1206 1207 kfree(chip); 1208 } 1209 1210 #ifdef CONFIG_PM_SLEEP 1211 static int apds990x_suspend(struct device *dev) 1212 { 1213 struct i2c_client *client = to_i2c_client(dev); 1214 struct apds990x_chip *chip = i2c_get_clientdata(client); 1215 1216 apds990x_chip_off(chip); 1217 return 0; 1218 } 1219 1220 static int apds990x_resume(struct device *dev) 1221 { 1222 struct i2c_client *client = to_i2c_client(dev); 1223 struct apds990x_chip *chip = i2c_get_clientdata(client); 1224 1225 /* 1226 * If we were enabled at suspend time, it is expected 1227 * everything works nice and smoothly. Chip_on is enough 1228 */ 1229 apds990x_chip_on(chip); 1230 1231 return 0; 1232 } 1233 #endif 1234 1235 #ifdef CONFIG_PM 1236 static int apds990x_runtime_suspend(struct device *dev) 1237 { 1238 struct i2c_client *client = to_i2c_client(dev); 1239 struct apds990x_chip *chip = i2c_get_clientdata(client); 1240 1241 apds990x_chip_off(chip); 1242 return 0; 1243 } 1244 1245 static int apds990x_runtime_resume(struct device *dev) 1246 { 1247 struct i2c_client *client = to_i2c_client(dev); 1248 struct apds990x_chip *chip = i2c_get_clientdata(client); 1249 1250 apds990x_chip_on(chip); 1251 return 0; 1252 } 1253 1254 #endif 1255 1256 static const struct i2c_device_id apds990x_id[] = { 1257 {"apds990x", 0 }, 1258 {} 1259 }; 1260 1261 MODULE_DEVICE_TABLE(i2c, apds990x_id); 1262 1263 static const struct dev_pm_ops apds990x_pm_ops = { 1264 SET_SYSTEM_SLEEP_PM_OPS(apds990x_suspend, apds990x_resume) 1265 SET_RUNTIME_PM_OPS(apds990x_runtime_suspend, 1266 apds990x_runtime_resume, 1267 NULL) 1268 }; 1269 1270 static struct i2c_driver apds990x_driver = { 1271 .driver = { 1272 .name = "apds990x", 1273 .pm = &apds990x_pm_ops, 1274 }, 1275 .probe = apds990x_probe, 1276 .remove = apds990x_remove, 1277 .id_table = apds990x_id, 1278 }; 1279 1280 module_i2c_driver(apds990x_driver); 1281 1282 MODULE_DESCRIPTION("APDS990X combined ALS and proximity sensor"); 1283 MODULE_AUTHOR("Samu Onkalo, Nokia Corporation"); 1284 MODULE_LICENSE("GPL v2"); 1285