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