drivers/misc/apds990x.c

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