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