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