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