drivers/misc/apds990x.c

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