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