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