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