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 */
 104struct reverse_factors {
 105	u32 afactor;
 106	int cf1;
 107	int irf1;
 108	int cf2;
 109	int irf2;
 110};
 111
 112struct 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
 176static 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 */
 179static const u16 arates_hz[] = {10, 5, 2, 1};
 180static const u8 apersis[] = {1, 2, 4, 5};
 181
 182/* Regulators */
 183static const char reg_vcc[] = "Vdd";
 184static const char reg_vled[] = "Vled";
 185
 186static 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
 199static 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
 212static 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
 224static 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
 236static 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
 248static 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
 306static 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 */
 319static 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 */
 344static 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 */
 360static 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 */
 368static 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 */
 376static 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 */
 431static 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
 452static 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
 474static 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
 536static 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
 566static 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
 598static 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
 615static 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
 622static 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
 651static DEVICE_ATTR(lux0_input, S_IRUGO, apds990x_lux_show, NULL);
 652
 653static 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
 659static DEVICE_ATTR(lux0_sensor_range, S_IRUGO, apds990x_lux_range_show, NULL);
 660
 661static 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
 667static DEVICE_ATTR(lux0_calibscale_default, S_IRUGO,
 668		apds990x_lux_calib_format_show, NULL);
 669
 670static 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
 678static 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
 695static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, apds990x_lux_calib_show,
 696		apds990x_lux_calib_store);
 697
 698static 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
 710static 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
 718static 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
 743static 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
 764static DEVICE_ATTR(lux0_rate_avail, S_IRUGO, apds990x_rate_avail, NULL);
 765
 766static DEVICE_ATTR(lux0_rate, S_IRUGO | S_IWUSR, apds990x_rate_show,
 767						 apds990x_rate_store);
 768
 769static 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
 784static DEVICE_ATTR(prox0_raw, S_IRUGO, apds990x_prox_show, NULL);
 785
 786static 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
 792static DEVICE_ATTR(prox0_sensor_range, S_IRUGO, apds990x_prox_range_show, NULL);
 793
 794static 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
 802static 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
 830static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, apds990x_prox_enable_show,
 831						   apds990x_prox_enable_store);
 832
 833static const char *reporting_modes[] = {"trigger", "periodic"};
 834
 835static 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
 844static 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
 859static DEVICE_ATTR(prox0_reporting_mode, S_IRUGO | S_IWUSR,
 860		apds990x_prox_reporting_mode_show,
 861		apds990x_prox_reporting_mode_store);
 862
 863static 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
 869static DEVICE_ATTR(prox0_reporting_mode_avail, S_IRUGO | S_IWUSR,
 870		apds990x_prox_reporting_avail_show, NULL);
 871
 872
 873static 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
 881static 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
 889static 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
 915static 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
 927static 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
 939static DEVICE_ATTR(lux0_thresh_above_value, S_IRUGO | S_IWUSR,
 940		apds990x_lux_thresh_above_show,
 941		apds990x_lux_thresh_above_store);
 942
 943static DEVICE_ATTR(lux0_thresh_below_value, S_IRUGO | S_IWUSR,
 944		apds990x_lux_thresh_below_show,
 945		apds990x_lux_thresh_below_store);
 946
 947static 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
 955static 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
 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	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
1016static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR,
1017		apds990x_power_state_show,
1018		apds990x_power_state_store);
1019
1020static 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
1028static DEVICE_ATTR(chip_id, S_IRUGO, apds990x_chip_id_show, NULL);
1029
1030static 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
1050static const struct attribute_group apds990x_attribute_group[] = {
1051	{.attrs = sysfs_attrs_ctrl },
1052};
1053
1054static int apds990x_probe(struct i2c_client *client)
 
1055{
1056	struct apds990x_chip *chip;
1057	int err;
1058
1059	chip = kzalloc(sizeof *chip, GFP_KERNEL);
1060	if (!chip)
1061		return -ENOMEM;
1062
1063	i2c_set_clientdata(client, chip);
1064	chip->client  = client;
1065
1066	init_waitqueue_head(&chip->wait);
1067	mutex_init(&chip->mutex);
1068	chip->pdata	= client->dev.platform_data;
1069
1070	if (chip->pdata == NULL) {
1071		dev_err(&client->dev, "platform data is mandatory\n");
1072		err = -EINVAL;
1073		goto fail1;
1074	}
1075
1076	if (chip->pdata->cf.ga == 0) {
1077		/* set uncovered sensor default parameters */
1078		chip->cf.ga = 1966; /* 0.48 * APDS_PARAM_SCALE */
1079		chip->cf.cf1 = 4096; /* 1.00 * APDS_PARAM_SCALE */
1080		chip->cf.irf1 = 9134; /* 2.23 * APDS_PARAM_SCALE */
1081		chip->cf.cf2 = 2867; /* 0.70 * APDS_PARAM_SCALE */
1082		chip->cf.irf2 = 5816; /* 1.42 * APDS_PARAM_SCALE */
1083		chip->cf.df = 52;
1084	} else {
1085		chip->cf = chip->pdata->cf;
1086	}
1087
1088	/* precalculate inverse chip factors for threshold control */
1089	chip->rcf.afactor =
1090		(chip->cf.irf1 - chip->cf.irf2) * APDS_PARAM_SCALE /
1091		(chip->cf.cf1 - chip->cf.cf2);
1092	chip->rcf.cf1 = APDS_PARAM_SCALE * APDS_PARAM_SCALE /
1093		chip->cf.cf1;
1094	chip->rcf.irf1 = chip->cf.irf1 * APDS_PARAM_SCALE /
1095		chip->cf.cf1;
1096	chip->rcf.cf2 = APDS_PARAM_SCALE * APDS_PARAM_SCALE /
1097		chip->cf.cf2;
1098	chip->rcf.irf2 = chip->cf.irf2 * APDS_PARAM_SCALE /
1099		chip->cf.cf2;
1100
1101	/* Set something to start with */
1102	chip->lux_thres_hi = APDS_LUX_DEF_THRES_HI;
1103	chip->lux_thres_lo = APDS_LUX_DEF_THRES_LO;
1104	chip->lux_calib = APDS_LUX_NEUTRAL_CALIB_VALUE;
1105
1106	chip->prox_thres = APDS_PROX_DEF_THRES;
1107	chip->pdrive = chip->pdata->pdrive;
1108	chip->pdiode = APDS_PDIODE_IR;
1109	chip->pgain = APDS_PGAIN_1X;
1110	chip->prox_calib = APDS_PROX_NEUTRAL_CALIB_VALUE;
1111	chip->prox_persistence = APDS_DEFAULT_PROX_PERS;
1112	chip->prox_continuous_mode = false;
1113
1114	chip->regs[0].supply = reg_vcc;
1115	chip->regs[1].supply = reg_vled;
1116
1117	err = regulator_bulk_get(&client->dev,
1118				 ARRAY_SIZE(chip->regs), chip->regs);
1119	if (err < 0) {
1120		dev_err(&client->dev, "Cannot get regulators\n");
1121		goto fail1;
1122	}
1123
1124	err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs);
1125	if (err < 0) {
1126		dev_err(&client->dev, "Cannot enable regulators\n");
1127		goto fail2;
1128	}
1129
1130	usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY);
1131
1132	err = apds990x_detect(chip);
1133	if (err < 0) {
1134		dev_err(&client->dev, "APDS990X not found\n");
1135		goto fail3;
1136	}
1137
1138	pm_runtime_set_active(&client->dev);
1139
1140	apds990x_configure(chip);
1141	apds990x_set_arate(chip, APDS_LUX_DEFAULT_RATE);
1142	apds990x_mode_on(chip);
1143
1144	pm_runtime_enable(&client->dev);
1145
1146	if (chip->pdata->setup_resources) {
1147		err = chip->pdata->setup_resources();
1148		if (err) {
1149			err = -EINVAL;
1150			goto fail3;
1151		}
1152	}
1153
1154	err = sysfs_create_group(&chip->client->dev.kobj,
1155				apds990x_attribute_group);
1156	if (err < 0) {
1157		dev_err(&chip->client->dev, "Sysfs registration failed\n");
1158		goto fail4;
1159	}
1160
1161	err = request_threaded_irq(client->irq, NULL,
1162				apds990x_irq,
1163				IRQF_TRIGGER_FALLING | IRQF_TRIGGER_LOW |
1164				IRQF_ONESHOT,
1165				"apds990x", chip);
1166	if (err) {
1167		dev_err(&client->dev, "could not get IRQ %d\n",
1168			client->irq);
1169		goto fail5;
1170	}
1171	return err;
1172fail5:
1173	sysfs_remove_group(&chip->client->dev.kobj,
1174			&apds990x_attribute_group[0]);
1175fail4:
1176	if (chip->pdata && chip->pdata->release_resources)
1177		chip->pdata->release_resources();
1178fail3:
1179	regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs);
1180fail2:
1181	regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs);
1182fail1:
1183	kfree(chip);
1184	return err;
1185}
1186
1187static void apds990x_remove(struct i2c_client *client)
1188{
1189	struct apds990x_chip *chip = i2c_get_clientdata(client);
1190
1191	free_irq(client->irq, chip);
1192	sysfs_remove_group(&chip->client->dev.kobj,
1193			apds990x_attribute_group);
1194
1195	if (chip->pdata && chip->pdata->release_resources)
1196		chip->pdata->release_resources();
1197
1198	if (!pm_runtime_suspended(&client->dev))
1199		apds990x_chip_off(chip);
1200
1201	pm_runtime_disable(&client->dev);
1202	pm_runtime_set_suspended(&client->dev);
1203
1204	regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs);
1205
1206	kfree(chip);
 
1207}
1208
1209#ifdef CONFIG_PM_SLEEP
1210static int apds990x_suspend(struct device *dev)
1211{
1212	struct i2c_client *client = to_i2c_client(dev);
1213	struct apds990x_chip *chip = i2c_get_clientdata(client);
1214
1215	apds990x_chip_off(chip);
1216	return 0;
1217}
1218
1219static int apds990x_resume(struct device *dev)
1220{
1221	struct i2c_client *client = to_i2c_client(dev);
1222	struct apds990x_chip *chip = i2c_get_clientdata(client);
1223
1224	/*
1225	 * If we were enabled at suspend time, it is expected
1226	 * everything works nice and smoothly. Chip_on is enough
1227	 */
1228	apds990x_chip_on(chip);
1229
1230	return 0;
1231}
1232#endif
1233
1234#ifdef CONFIG_PM
1235static int apds990x_runtime_suspend(struct device *dev)
1236{
1237	struct i2c_client *client = to_i2c_client(dev);
1238	struct apds990x_chip *chip = i2c_get_clientdata(client);
1239
1240	apds990x_chip_off(chip);
1241	return 0;
1242}
1243
1244static int apds990x_runtime_resume(struct device *dev)
1245{
1246	struct i2c_client *client = to_i2c_client(dev);
1247	struct apds990x_chip *chip = i2c_get_clientdata(client);
1248
1249	apds990x_chip_on(chip);
1250	return 0;
1251}
1252
1253#endif
1254
1255static const struct i2c_device_id apds990x_id[] = {
1256	{"apds990x", 0 },
1257	{}
1258};
1259
1260MODULE_DEVICE_TABLE(i2c, apds990x_id);
1261
1262static const struct dev_pm_ops apds990x_pm_ops = {
1263	SET_SYSTEM_SLEEP_PM_OPS(apds990x_suspend, apds990x_resume)
1264	SET_RUNTIME_PM_OPS(apds990x_runtime_suspend,
1265			apds990x_runtime_resume,
1266			NULL)
1267};
1268
1269static struct i2c_driver apds990x_driver = {
1270	.driver	  = {
1271		.name	= "apds990x",
1272		.pm	= &apds990x_pm_ops,
1273	},
1274	.probe    = apds990x_probe,
1275	.remove	  = apds990x_remove,
1276	.id_table = apds990x_id,
1277};
1278
1279module_i2c_driver(apds990x_driver);
1280
1281MODULE_DESCRIPTION("APDS990X combined ALS and proximity sensor");
1282MODULE_AUTHOR("Samu Onkalo, Nokia Corporation");
1283MODULE_LICENSE("GPL v2");