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/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");