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 chip->lux_calib = value; 704 705 return len; 706 } 707 708 static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, apds990x_lux_calib_show, 709 apds990x_lux_calib_store); 710 711 static ssize_t apds990x_rate_avail(struct device *dev, 712 struct device_attribute *attr, char *buf) 713 { 714 int i; 715 int pos = 0; 716 for (i = 0; i < ARRAY_SIZE(arates_hz); i++) 717 pos += sprintf(buf + pos, "%d ", arates_hz[i]); 718 sprintf(buf + pos - 1, "\n"); 719 return pos; 720 } 721 722 static ssize_t apds990x_rate_show(struct device *dev, 723 struct device_attribute *attr, char *buf) 724 { 725 struct apds990x_chip *chip = dev_get_drvdata(dev); 726 return sprintf(buf, "%d\n", chip->arate); 727 } 728 729 static int apds990x_set_arate(struct apds990x_chip *chip, int rate) 730 { 731 int i; 732 733 for (i = 0; i < ARRAY_SIZE(arates_hz); i++) 734 if (rate >= arates_hz[i]) 735 break; 736 737 if (i == ARRAY_SIZE(arates_hz)) 738 return -EINVAL; 739 740 /* Pick up corresponding persistence value */ 741 chip->lux_persistence = apersis[i]; 742 chip->arate = arates_hz[i]; 743 744 /* If the chip is not in use, don't try to access it */ 745 if (pm_runtime_suspended(&chip->client->dev)) 746 return 0; 747 748 /* Persistence levels */ 749 return apds990x_write_byte(chip, APDS990X_PERS, 750 (chip->lux_persistence << APDS990X_APERS_SHIFT) | 751 (chip->prox_persistence << APDS990X_PPERS_SHIFT)); 752 } 753 754 static ssize_t apds990x_rate_store(struct device *dev, 755 struct device_attribute *attr, 756 const char *buf, size_t len) 757 { 758 struct apds990x_chip *chip = dev_get_drvdata(dev); 759 unsigned long value; 760 int ret; 761 762 if (strict_strtoul(buf, 0, &value)) 763 return -EINVAL; 764 765 mutex_lock(&chip->mutex); 766 ret = apds990x_set_arate(chip, value); 767 mutex_unlock(&chip->mutex); 768 769 if (ret < 0) 770 return ret; 771 return len; 772 } 773 774 static DEVICE_ATTR(lux0_rate_avail, S_IRUGO, apds990x_rate_avail, NULL); 775 776 static DEVICE_ATTR(lux0_rate, S_IRUGO | S_IWUSR, apds990x_rate_show, 777 apds990x_rate_store); 778 779 static ssize_t apds990x_prox_show(struct device *dev, 780 struct device_attribute *attr, char *buf) 781 { 782 ssize_t ret; 783 struct apds990x_chip *chip = dev_get_drvdata(dev); 784 if (pm_runtime_suspended(dev) || !chip->prox_en) 785 return -EIO; 786 787 mutex_lock(&chip->mutex); 788 ret = sprintf(buf, "%d\n", chip->prox_data); 789 mutex_unlock(&chip->mutex); 790 return ret; 791 } 792 793 static DEVICE_ATTR(prox0_raw, S_IRUGO, apds990x_prox_show, NULL); 794 795 static ssize_t apds990x_prox_range_show(struct device *dev, 796 struct device_attribute *attr, char *buf) 797 { 798 return sprintf(buf, "%u\n", APDS_PROX_RANGE); 799 } 800 801 static DEVICE_ATTR(prox0_sensor_range, S_IRUGO, apds990x_prox_range_show, NULL); 802 803 static ssize_t apds990x_prox_enable_show(struct device *dev, 804 struct device_attribute *attr, char *buf) 805 { 806 struct apds990x_chip *chip = dev_get_drvdata(dev); 807 return sprintf(buf, "%d\n", chip->prox_en); 808 } 809 810 static ssize_t apds990x_prox_enable_store(struct device *dev, 811 struct device_attribute *attr, 812 const char *buf, size_t len) 813 { 814 struct apds990x_chip *chip = dev_get_drvdata(dev); 815 unsigned long value; 816 817 if (strict_strtoul(buf, 0, &value)) 818 return -EINVAL; 819 820 mutex_lock(&chip->mutex); 821 822 if (!chip->prox_en) 823 chip->prox_data = 0; 824 825 if (value) 826 chip->prox_en++; 827 else if (chip->prox_en > 0) 828 chip->prox_en--; 829 830 if (!pm_runtime_suspended(dev)) 831 apds990x_mode_on(chip); 832 mutex_unlock(&chip->mutex); 833 return len; 834 } 835 836 static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, apds990x_prox_enable_show, 837 apds990x_prox_enable_store); 838 839 static const char reporting_modes[][9] = {"trigger", "periodic"}; 840 841 static ssize_t apds990x_prox_reporting_mode_show(struct device *dev, 842 struct device_attribute *attr, char *buf) 843 { 844 struct apds990x_chip *chip = dev_get_drvdata(dev); 845 return sprintf(buf, "%s\n", 846 reporting_modes[!!chip->prox_continuous_mode]); 847 } 848 849 static ssize_t apds990x_prox_reporting_mode_store(struct device *dev, 850 struct device_attribute *attr, 851 const char *buf, size_t len) 852 { 853 struct apds990x_chip *chip = dev_get_drvdata(dev); 854 855 if (sysfs_streq(buf, reporting_modes[0])) 856 chip->prox_continuous_mode = 0; 857 else if (sysfs_streq(buf, reporting_modes[1])) 858 chip->prox_continuous_mode = 1; 859 else 860 return -EINVAL; 861 return len; 862 } 863 864 static DEVICE_ATTR(prox0_reporting_mode, S_IRUGO | S_IWUSR, 865 apds990x_prox_reporting_mode_show, 866 apds990x_prox_reporting_mode_store); 867 868 static ssize_t apds990x_prox_reporting_avail_show(struct device *dev, 869 struct device_attribute *attr, char *buf) 870 { 871 return sprintf(buf, "%s %s\n", reporting_modes[0], reporting_modes[1]); 872 } 873 874 static DEVICE_ATTR(prox0_reporting_mode_avail, S_IRUGO | S_IWUSR, 875 apds990x_prox_reporting_avail_show, NULL); 876 877 878 static ssize_t apds990x_lux_thresh_above_show(struct device *dev, 879 struct device_attribute *attr, char *buf) 880 { 881 struct apds990x_chip *chip = dev_get_drvdata(dev); 882 return sprintf(buf, "%d\n", chip->lux_thres_hi); 883 } 884 885 static ssize_t apds990x_lux_thresh_below_show(struct device *dev, 886 struct device_attribute *attr, char *buf) 887 { 888 struct apds990x_chip *chip = dev_get_drvdata(dev); 889 return sprintf(buf, "%d\n", chip->lux_thres_lo); 890 } 891 892 static ssize_t apds990x_set_lux_thresh(struct apds990x_chip *chip, u32 *target, 893 const char *buf) 894 { 895 int ret = 0; 896 unsigned long thresh; 897 898 if (strict_strtoul(buf, 0, &thresh)) 899 return -EINVAL; 900 901 if (thresh > APDS_RANGE) 902 return -EINVAL; 903 904 mutex_lock(&chip->mutex); 905 *target = thresh; 906 /* 907 * Don't update values in HW if we are still waiting for 908 * first interrupt to come after device handle open call. 909 */ 910 if (!chip->lux_wait_fresh_res) 911 apds990x_refresh_athres(chip); 912 mutex_unlock(&chip->mutex); 913 return ret; 914 915 } 916 917 static ssize_t apds990x_lux_thresh_above_store(struct device *dev, 918 struct device_attribute *attr, 919 const char *buf, size_t len) 920 { 921 struct apds990x_chip *chip = dev_get_drvdata(dev); 922 int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_hi, buf); 923 if (ret < 0) 924 return ret; 925 return len; 926 } 927 928 static ssize_t apds990x_lux_thresh_below_store(struct device *dev, 929 struct device_attribute *attr, 930 const char *buf, size_t len) 931 { 932 struct apds990x_chip *chip = dev_get_drvdata(dev); 933 int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_lo, buf); 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 return sprintf(buf, "%d\n", chip->prox_thres); 952 } 953 954 static ssize_t apds990x_prox_threshold_store(struct device *dev, 955 struct device_attribute *attr, 956 const char *buf, size_t len) 957 { 958 struct apds990x_chip *chip = dev_get_drvdata(dev); 959 unsigned long value; 960 961 if (strict_strtoul(buf, 0, &value)) 962 return -EINVAL; 963 964 if ((value > APDS_RANGE) || (value == 0) || 965 (value < APDS_PROX_HYSTERESIS)) 966 return -EINVAL; 967 968 mutex_lock(&chip->mutex); 969 chip->prox_thres = value; 970 971 apds990x_force_p_refresh(chip); 972 mutex_unlock(&chip->mutex); 973 return len; 974 } 975 976 static DEVICE_ATTR(prox0_thresh_above_value, S_IRUGO | S_IWUSR, 977 apds990x_prox_threshold_show, 978 apds990x_prox_threshold_store); 979 980 static ssize_t apds990x_power_state_show(struct device *dev, 981 struct device_attribute *attr, char *buf) 982 { 983 return sprintf(buf, "%d\n", !pm_runtime_suspended(dev)); 984 return 0; 985 } 986 987 static ssize_t apds990x_power_state_store(struct device *dev, 988 struct device_attribute *attr, 989 const char *buf, size_t len) 990 { 991 struct apds990x_chip *chip = dev_get_drvdata(dev); 992 unsigned long value; 993 994 if (strict_strtoul(buf, 0, &value)) 995 return -EINVAL; 996 if (value) { 997 pm_runtime_get_sync(dev); 998 mutex_lock(&chip->mutex); 999 chip->lux_wait_fresh_res = true; 1000 apds990x_force_a_refresh(chip); 1001 apds990x_force_p_refresh(chip); 1002 mutex_unlock(&chip->mutex); 1003 } else { 1004 if (!pm_runtime_suspended(dev)) 1005 pm_runtime_put(dev); 1006 } 1007 return len; 1008 } 1009 1010 static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR, 1011 apds990x_power_state_show, 1012 apds990x_power_state_store); 1013 1014 static ssize_t apds990x_chip_id_show(struct device *dev, 1015 struct device_attribute *attr, char *buf) 1016 { 1017 struct apds990x_chip *chip = dev_get_drvdata(dev); 1018 return sprintf(buf, "%s %d\n", chip->chipname, chip->revision); 1019 } 1020 1021 static DEVICE_ATTR(chip_id, S_IRUGO, apds990x_chip_id_show, NULL); 1022 1023 static struct attribute *sysfs_attrs_ctrl[] = { 1024 &dev_attr_lux0_calibscale.attr, 1025 &dev_attr_lux0_calibscale_default.attr, 1026 &dev_attr_lux0_input.attr, 1027 &dev_attr_lux0_sensor_range.attr, 1028 &dev_attr_lux0_rate.attr, 1029 &dev_attr_lux0_rate_avail.attr, 1030 &dev_attr_lux0_thresh_above_value.attr, 1031 &dev_attr_lux0_thresh_below_value.attr, 1032 &dev_attr_prox0_raw_en.attr, 1033 &dev_attr_prox0_raw.attr, 1034 &dev_attr_prox0_sensor_range.attr, 1035 &dev_attr_prox0_thresh_above_value.attr, 1036 &dev_attr_prox0_reporting_mode.attr, 1037 &dev_attr_prox0_reporting_mode_avail.attr, 1038 &dev_attr_chip_id.attr, 1039 &dev_attr_power_state.attr, 1040 NULL 1041 }; 1042 1043 static struct attribute_group apds990x_attribute_group[] = { 1044 {.attrs = sysfs_attrs_ctrl }, 1045 }; 1046 1047 static int apds990x_probe(struct i2c_client *client, 1048 const struct i2c_device_id *id) 1049 { 1050 struct apds990x_chip *chip; 1051 int err; 1052 1053 chip = kzalloc(sizeof *chip, GFP_KERNEL); 1054 if (!chip) 1055 return -ENOMEM; 1056 1057 i2c_set_clientdata(client, chip); 1058 chip->client = client; 1059 1060 init_waitqueue_head(&chip->wait); 1061 mutex_init(&chip->mutex); 1062 chip->pdata = client->dev.platform_data; 1063 1064 if (chip->pdata == NULL) { 1065 dev_err(&client->dev, "platform data is mandatory\n"); 1066 err = -EINVAL; 1067 goto fail1; 1068 } 1069 1070 if (chip->pdata->cf.ga == 0) { 1071 /* set uncovered sensor default parameters */ 1072 chip->cf.ga = 1966; /* 0.48 * APDS_PARAM_SCALE */ 1073 chip->cf.cf1 = 4096; /* 1.00 * APDS_PARAM_SCALE */ 1074 chip->cf.irf1 = 9134; /* 2.23 * APDS_PARAM_SCALE */ 1075 chip->cf.cf2 = 2867; /* 0.70 * APDS_PARAM_SCALE */ 1076 chip->cf.irf2 = 5816; /* 1.42 * APDS_PARAM_SCALE */ 1077 chip->cf.df = 52; 1078 } else { 1079 chip->cf = chip->pdata->cf; 1080 } 1081 1082 /* precalculate inverse chip factors for threshold control */ 1083 chip->rcf.afactor = 1084 (chip->cf.irf1 - chip->cf.irf2) * APDS_PARAM_SCALE / 1085 (chip->cf.cf1 - chip->cf.cf2); 1086 chip->rcf.cf1 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / 1087 chip->cf.cf1; 1088 chip->rcf.irf1 = chip->cf.irf1 * APDS_PARAM_SCALE / 1089 chip->cf.cf1; 1090 chip->rcf.cf2 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / 1091 chip->cf.cf2; 1092 chip->rcf.irf2 = chip->cf.irf2 * APDS_PARAM_SCALE / 1093 chip->cf.cf2; 1094 1095 /* Set something to start with */ 1096 chip->lux_thres_hi = APDS_LUX_DEF_THRES_HI; 1097 chip->lux_thres_lo = APDS_LUX_DEF_THRES_LO; 1098 chip->lux_calib = APDS_LUX_NEUTRAL_CALIB_VALUE; 1099 1100 chip->prox_thres = APDS_PROX_DEF_THRES; 1101 chip->pdrive = chip->pdata->pdrive; 1102 chip->pdiode = APDS_PDIODE_IR; 1103 chip->pgain = APDS_PGAIN_1X; 1104 chip->prox_calib = APDS_PROX_NEUTRAL_CALIB_VALUE; 1105 chip->prox_persistence = APDS_DEFAULT_PROX_PERS; 1106 chip->prox_continuous_mode = false; 1107 1108 chip->regs[0].supply = reg_vcc; 1109 chip->regs[1].supply = reg_vled; 1110 1111 err = regulator_bulk_get(&client->dev, 1112 ARRAY_SIZE(chip->regs), chip->regs); 1113 if (err < 0) { 1114 dev_err(&client->dev, "Cannot get regulators\n"); 1115 goto fail1; 1116 } 1117 1118 err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs); 1119 if (err < 0) { 1120 dev_err(&client->dev, "Cannot enable regulators\n"); 1121 goto fail2; 1122 } 1123 1124 usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY); 1125 1126 err = apds990x_detect(chip); 1127 if (err < 0) { 1128 dev_err(&client->dev, "APDS990X not found\n"); 1129 goto fail3; 1130 } 1131 1132 pm_runtime_set_active(&client->dev); 1133 1134 apds990x_configure(chip); 1135 apds990x_set_arate(chip, APDS_LUX_DEFAULT_RATE); 1136 apds990x_mode_on(chip); 1137 1138 pm_runtime_enable(&client->dev); 1139 1140 if (chip->pdata->setup_resources) { 1141 err = chip->pdata->setup_resources(); 1142 if (err) { 1143 err = -EINVAL; 1144 goto fail3; 1145 } 1146 } 1147 1148 err = sysfs_create_group(&chip->client->dev.kobj, 1149 apds990x_attribute_group); 1150 if (err < 0) { 1151 dev_err(&chip->client->dev, "Sysfs registration failed\n"); 1152 goto fail4; 1153 } 1154 1155 err = request_threaded_irq(client->irq, NULL, 1156 apds990x_irq, 1157 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_LOW | 1158 IRQF_ONESHOT, 1159 "apds990x", chip); 1160 if (err) { 1161 dev_err(&client->dev, "could not get IRQ %d\n", 1162 client->irq); 1163 goto fail5; 1164 } 1165 return err; 1166 fail5: 1167 sysfs_remove_group(&chip->client->dev.kobj, 1168 &apds990x_attribute_group[0]); 1169 fail4: 1170 if (chip->pdata && chip->pdata->release_resources) 1171 chip->pdata->release_resources(); 1172 fail3: 1173 regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); 1174 fail2: 1175 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); 1176 fail1: 1177 kfree(chip); 1178 return err; 1179 } 1180 1181 static int apds990x_remove(struct i2c_client *client) 1182 { 1183 struct apds990x_chip *chip = i2c_get_clientdata(client); 1184 1185 free_irq(client->irq, chip); 1186 sysfs_remove_group(&chip->client->dev.kobj, 1187 apds990x_attribute_group); 1188 1189 if (chip->pdata && chip->pdata->release_resources) 1190 chip->pdata->release_resources(); 1191 1192 if (!pm_runtime_suspended(&client->dev)) 1193 apds990x_chip_off(chip); 1194 1195 pm_runtime_disable(&client->dev); 1196 pm_runtime_set_suspended(&client->dev); 1197 1198 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); 1199 1200 kfree(chip); 1201 return 0; 1202 } 1203 1204 #ifdef CONFIG_PM_SLEEP 1205 static int apds990x_suspend(struct device *dev) 1206 { 1207 struct i2c_client *client = container_of(dev, struct i2c_client, dev); 1208 struct apds990x_chip *chip = i2c_get_clientdata(client); 1209 1210 apds990x_chip_off(chip); 1211 return 0; 1212 } 1213 1214 static int apds990x_resume(struct device *dev) 1215 { 1216 struct i2c_client *client = container_of(dev, struct i2c_client, dev); 1217 struct apds990x_chip *chip = i2c_get_clientdata(client); 1218 1219 /* 1220 * If we were enabled at suspend time, it is expected 1221 * everything works nice and smoothly. Chip_on is enough 1222 */ 1223 apds990x_chip_on(chip); 1224 1225 return 0; 1226 } 1227 #endif 1228 1229 #ifdef CONFIG_PM_RUNTIME 1230 static int apds990x_runtime_suspend(struct device *dev) 1231 { 1232 struct i2c_client *client = container_of(dev, struct i2c_client, dev); 1233 struct apds990x_chip *chip = i2c_get_clientdata(client); 1234 1235 apds990x_chip_off(chip); 1236 return 0; 1237 } 1238 1239 static int apds990x_runtime_resume(struct device *dev) 1240 { 1241 struct i2c_client *client = container_of(dev, struct i2c_client, dev); 1242 struct apds990x_chip *chip = i2c_get_clientdata(client); 1243 1244 apds990x_chip_on(chip); 1245 return 0; 1246 } 1247 1248 #endif 1249 1250 static const struct i2c_device_id apds990x_id[] = { 1251 {"apds990x", 0 }, 1252 {} 1253 }; 1254 1255 MODULE_DEVICE_TABLE(i2c, apds990x_id); 1256 1257 static const struct dev_pm_ops apds990x_pm_ops = { 1258 SET_SYSTEM_SLEEP_PM_OPS(apds990x_suspend, apds990x_resume) 1259 SET_RUNTIME_PM_OPS(apds990x_runtime_suspend, 1260 apds990x_runtime_resume, 1261 NULL) 1262 }; 1263 1264 static struct i2c_driver apds990x_driver = { 1265 .driver = { 1266 .name = "apds990x", 1267 .owner = THIS_MODULE, 1268 .pm = &apds990x_pm_ops, 1269 }, 1270 .probe = apds990x_probe, 1271 .remove = apds990x_remove, 1272 .id_table = apds990x_id, 1273 }; 1274 1275 module_i2c_driver(apds990x_driver); 1276 1277 MODULE_DESCRIPTION("APDS990X combined ALS and proximity sensor"); 1278 MODULE_AUTHOR("Samu Onkalo, Nokia Corporation"); 1279 MODULE_LICENSE("GPL v2"); 1280