Root/
1 | /* |
2 | * This file is part of the APDS990x sensor driver. |
3 | * Chip is combined proximity and ambient light sensor. |
4 | * |
5 | * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). |
6 | * |
7 | * Contact: Samu Onkalo <samu.p.onkalo@nokia.com> |
8 | * |
9 | * This program is free software; you can redistribute it and/or |
10 | * modify it under the terms of the GNU General Public License |
11 | * version 2 as published by the Free Software Foundation. |
12 | * |
13 | * This program is distributed in the hope that it will be useful, but |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 | * General Public License for more details. |
17 | * |
18 | * You should have received a copy of the GNU General Public License |
19 | * along with this program; if not, write to the Free Software |
20 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA |
21 | * 02110-1301 USA |
22 | * |
23 | */ |
24 | |
25 | #include <linux/kernel.h> |
26 | #include <linux/module.h> |
27 | #include <linux/i2c.h> |
28 | #include <linux/interrupt.h> |
29 | #include <linux/mutex.h> |
30 | #include <linux/regulator/consumer.h> |
31 | #include <linux/pm_runtime.h> |
32 | #include <linux/delay.h> |
33 | #include <linux/wait.h> |
34 | #include <linux/slab.h> |
35 | #include <linux/i2c/apds990x.h> |
36 | |
37 | /* Register map */ |
38 | #define APDS990X_ENABLE 0x00 /* Enable of states and interrupts */ |
39 | #define APDS990X_ATIME 0x01 /* ALS ADC time */ |
40 | #define APDS990X_PTIME 0x02 /* Proximity ADC time */ |
41 | #define APDS990X_WTIME 0x03 /* Wait time */ |
42 | #define APDS990X_AILTL 0x04 /* ALS interrupt low threshold low byte */ |
43 | #define APDS990X_AILTH 0x05 /* ALS interrupt low threshold hi byte */ |
44 | #define APDS990X_AIHTL 0x06 /* ALS interrupt hi threshold low byte */ |
45 | #define APDS990X_AIHTH 0x07 /* ALS interrupt hi threshold hi byte */ |
46 | #define APDS990X_PILTL 0x08 /* Proximity interrupt low threshold low byte */ |
47 | #define APDS990X_PILTH 0x09 /* Proximity interrupt low threshold hi byte */ |
48 | #define APDS990X_PIHTL 0x0a /* Proximity interrupt hi threshold low byte */ |
49 | #define APDS990X_PIHTH 0x0b /* Proximity interrupt hi threshold hi byte */ |
50 | #define APDS990X_PERS 0x0c /* Interrupt persistence filters */ |
51 | #define APDS990X_CONFIG 0x0d /* Configuration */ |
52 | #define APDS990X_PPCOUNT 0x0e /* Proximity pulse count */ |
53 | #define APDS990X_CONTROL 0x0f /* Gain control register */ |
54 | #define APDS990X_REV 0x11 /* Revision Number */ |
55 | #define APDS990X_ID 0x12 /* Device ID */ |
56 | #define APDS990X_STATUS 0x13 /* Device status */ |
57 | #define APDS990X_CDATAL 0x14 /* Clear ADC low data register */ |
58 | #define APDS990X_CDATAH 0x15 /* Clear ADC high data register */ |
59 | #define APDS990X_IRDATAL 0x16 /* IR ADC low data register */ |
60 | #define APDS990X_IRDATAH 0x17 /* IR ADC high data register */ |
61 | #define APDS990X_PDATAL 0x18 /* Proximity ADC low data register */ |
62 | #define APDS990X_PDATAH 0x19 /* Proximity ADC high data register */ |
63 | |
64 | /* Control */ |
65 | #define APDS990X_MAX_AGAIN 3 |
66 | |
67 | /* Enable register */ |
68 | #define APDS990X_EN_PIEN (0x1 << 5) |
69 | #define APDS990X_EN_AIEN (0x1 << 4) |
70 | #define APDS990X_EN_WEN (0x1 << 3) |
71 | #define APDS990X_EN_PEN (0x1 << 2) |
72 | #define APDS990X_EN_AEN (0x1 << 1) |
73 | #define APDS990X_EN_PON (0x1 << 0) |
74 | #define APDS990X_EN_DISABLE_ALL 0 |
75 | |
76 | /* Status register */ |
77 | #define APDS990X_ST_PINT (0x1 << 5) |
78 | #define APDS990X_ST_AINT (0x1 << 4) |
79 | |
80 | /* I2C access types */ |
81 | #define APDS990x_CMD_TYPE_MASK (0x03 << 5) |
82 | #define APDS990x_CMD_TYPE_RB (0x00 << 5) /* Repeated byte */ |
83 | #define APDS990x_CMD_TYPE_INC (0x01 << 5) /* Auto increment */ |
84 | #define APDS990x_CMD_TYPE_SPE (0x03 << 5) /* Special function */ |
85 | |
86 | #define APDS990x_ADDR_SHIFT 0 |
87 | #define APDS990x_CMD 0x80 |
88 | |
89 | /* Interrupt ack commands */ |
90 | #define APDS990X_INT_ACK_ALS 0x6 |
91 | #define APDS990X_INT_ACK_PS 0x5 |
92 | #define APDS990X_INT_ACK_BOTH 0x7 |
93 | |
94 | /* ptime */ |
95 | #define APDS990X_PTIME_DEFAULT 0xff /* Recommended conversion time 2.7ms*/ |
96 | |
97 | /* wtime */ |
98 | #define APDS990X_WTIME_DEFAULT 0xee /* ~50ms wait time */ |
99 | |
100 | #define APDS990X_TIME_TO_ADC 1024 /* One timetick as ADC count value */ |
101 | |
102 | /* Persistence */ |
103 | #define APDS990X_APERS_SHIFT 0 |
104 | #define APDS990X_PPERS_SHIFT 4 |
105 | |
106 | /* Supported ID:s */ |
107 | #define APDS990X_ID_0 0x0 |
108 | #define APDS990X_ID_4 0x4 |
109 | #define APDS990X_ID_29 0x29 |
110 | |
111 | /* pgain and pdiode settings */ |
112 | #define APDS_PGAIN_1X 0x0 |
113 | #define APDS_PDIODE_IR 0x2 |
114 | |
115 | #define APDS990X_LUX_OUTPUT_SCALE 10 |
116 | |
117 | /* Reverse chip factors for threshold calculation */ |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 */ |
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 */ |
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 */ |
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 */ |
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 */ |
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 */ |
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 | |
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 | |
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 | |
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 | |
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 | #if defined(CONFIG_PM) || defined(CONFIG_PM_RUNTIME) |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
700 | if (strict_strtoul(buf, 0, &value)) |
701 | return -EINVAL; |
702 | |
703 | if (chip->lux_calib > APDS_RANGE) |
704 | return -EINVAL; |
705 | |
706 | chip->lux_calib = value; |
707 | |
708 | return len; |
709 | } |
710 | |
711 | static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, apds990x_lux_calib_show, |
712 | apds990x_lux_calib_store); |
713 | |
714 | static ssize_t apds990x_rate_avail(struct device *dev, |
715 | struct device_attribute *attr, char *buf) |
716 | { |
717 | int i; |
718 | int pos = 0; |
719 | for (i = 0; i < ARRAY_SIZE(arates_hz); i++) |
720 | pos += sprintf(buf + pos, "%d ", arates_hz[i]); |
721 | sprintf(buf + pos - 1, "\n"); |
722 | return pos; |
723 | } |
724 | |
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 | return sprintf(buf, "%d\n", chip->arate); |
730 | } |
731 | |
732 | static int apds990x_set_arate(struct apds990x_chip *chip, int rate) |
733 | { |
734 | int i; |
735 | |
736 | for (i = 0; i < ARRAY_SIZE(arates_hz); i++) |
737 | if (rate >= arates_hz[i]) |
738 | break; |
739 | |
740 | if (i == ARRAY_SIZE(arates_hz)) |
741 | return -EINVAL; |
742 | |
743 | /* Pick up corresponding persistence value */ |
744 | chip->lux_persistence = apersis[i]; |
745 | chip->arate = arates_hz[i]; |
746 | |
747 | /* If the chip is not in use, don't try to access it */ |
748 | if (pm_runtime_suspended(&chip->client->dev)) |
749 | return 0; |
750 | |
751 | /* Persistence levels */ |
752 | return apds990x_write_byte(chip, APDS990X_PERS, |
753 | (chip->lux_persistence << APDS990X_APERS_SHIFT) | |
754 | (chip->prox_persistence << APDS990X_PPERS_SHIFT)); |
755 | } |
756 | |
757 | static ssize_t apds990x_rate_store(struct device *dev, |
758 | struct device_attribute *attr, |
759 | const char *buf, size_t len) |
760 | { |
761 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
762 | unsigned long value; |
763 | int ret; |
764 | |
765 | if (strict_strtoul(buf, 0, &value)) |
766 | return -EINVAL; |
767 | |
768 | mutex_lock(&chip->mutex); |
769 | ret = apds990x_set_arate(chip, value); |
770 | mutex_unlock(&chip->mutex); |
771 | |
772 | if (ret < 0) |
773 | return ret; |
774 | return len; |
775 | } |
776 | |
777 | static DEVICE_ATTR(lux0_rate_avail, S_IRUGO, apds990x_rate_avail, NULL); |
778 | |
779 | static DEVICE_ATTR(lux0_rate, S_IRUGO | S_IWUSR, apds990x_rate_show, |
780 | apds990x_rate_store); |
781 | |
782 | static ssize_t apds990x_prox_show(struct device *dev, |
783 | struct device_attribute *attr, char *buf) |
784 | { |
785 | ssize_t ret; |
786 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
787 | if (pm_runtime_suspended(dev) || !chip->prox_en) |
788 | return -EIO; |
789 | |
790 | mutex_lock(&chip->mutex); |
791 | ret = sprintf(buf, "%d\n", chip->prox_data); |
792 | mutex_unlock(&chip->mutex); |
793 | return ret; |
794 | } |
795 | |
796 | static DEVICE_ATTR(prox0_raw, S_IRUGO, apds990x_prox_show, NULL); |
797 | |
798 | static ssize_t apds990x_prox_range_show(struct device *dev, |
799 | struct device_attribute *attr, char *buf) |
800 | { |
801 | return sprintf(buf, "%u\n", APDS_PROX_RANGE); |
802 | } |
803 | |
804 | static DEVICE_ATTR(prox0_sensor_range, S_IRUGO, apds990x_prox_range_show, NULL); |
805 | |
806 | static ssize_t apds990x_prox_enable_show(struct device *dev, |
807 | struct device_attribute *attr, char *buf) |
808 | { |
809 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
810 | return sprintf(buf, "%d\n", chip->prox_en); |
811 | } |
812 | |
813 | static ssize_t apds990x_prox_enable_store(struct device *dev, |
814 | struct device_attribute *attr, |
815 | const char *buf, size_t len) |
816 | { |
817 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
818 | unsigned long value; |
819 | |
820 | if (strict_strtoul(buf, 0, &value)) |
821 | return -EINVAL; |
822 | |
823 | mutex_lock(&chip->mutex); |
824 | |
825 | if (!chip->prox_en) |
826 | chip->prox_data = 0; |
827 | |
828 | if (value) |
829 | chip->prox_en++; |
830 | else if (chip->prox_en > 0) |
831 | chip->prox_en--; |
832 | |
833 | if (!pm_runtime_suspended(dev)) |
834 | apds990x_mode_on(chip); |
835 | mutex_unlock(&chip->mutex); |
836 | return len; |
837 | } |
838 | |
839 | static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, apds990x_prox_enable_show, |
840 | apds990x_prox_enable_store); |
841 | |
842 | static const char reporting_modes[][9] = {"trigger", "periodic"}; |
843 | |
844 | static ssize_t apds990x_prox_reporting_mode_show(struct device *dev, |
845 | struct device_attribute *attr, char *buf) |
846 | { |
847 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
848 | return sprintf(buf, "%s\n", |
849 | reporting_modes[!!chip->prox_continuous_mode]); |
850 | } |
851 | |
852 | static ssize_t apds990x_prox_reporting_mode_store(struct device *dev, |
853 | struct device_attribute *attr, |
854 | const char *buf, size_t len) |
855 | { |
856 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
857 | |
858 | if (sysfs_streq(buf, reporting_modes[0])) |
859 | chip->prox_continuous_mode = 0; |
860 | else if (sysfs_streq(buf, reporting_modes[1])) |
861 | chip->prox_continuous_mode = 1; |
862 | else |
863 | return -EINVAL; |
864 | return len; |
865 | } |
866 | |
867 | static DEVICE_ATTR(prox0_reporting_mode, S_IRUGO | S_IWUSR, |
868 | apds990x_prox_reporting_mode_show, |
869 | apds990x_prox_reporting_mode_store); |
870 | |
871 | static ssize_t apds990x_prox_reporting_avail_show(struct device *dev, |
872 | struct device_attribute *attr, char *buf) |
873 | { |
874 | return sprintf(buf, "%s %s\n", reporting_modes[0], reporting_modes[1]); |
875 | } |
876 | |
877 | static DEVICE_ATTR(prox0_reporting_mode_avail, S_IRUGO | S_IWUSR, |
878 | apds990x_prox_reporting_avail_show, NULL); |
879 | |
880 | |
881 | static ssize_t apds990x_lux_thresh_above_show(struct device *dev, |
882 | struct device_attribute *attr, char *buf) |
883 | { |
884 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
885 | return sprintf(buf, "%d\n", chip->lux_thres_hi); |
886 | } |
887 | |
888 | static ssize_t apds990x_lux_thresh_below_show(struct device *dev, |
889 | struct device_attribute *attr, char *buf) |
890 | { |
891 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
892 | return sprintf(buf, "%d\n", chip->lux_thres_lo); |
893 | } |
894 | |
895 | static ssize_t apds990x_set_lux_thresh(struct apds990x_chip *chip, u32 *target, |
896 | const char *buf) |
897 | { |
898 | int ret = 0; |
899 | unsigned long thresh; |
900 | |
901 | if (strict_strtoul(buf, 0, &thresh)) |
902 | return -EINVAL; |
903 | |
904 | if (thresh > APDS_RANGE) |
905 | return -EINVAL; |
906 | |
907 | mutex_lock(&chip->mutex); |
908 | *target = thresh; |
909 | /* |
910 | * Don't update values in HW if we are still waiting for |
911 | * first interrupt to come after device handle open call. |
912 | */ |
913 | if (!chip->lux_wait_fresh_res) |
914 | apds990x_refresh_athres(chip); |
915 | mutex_unlock(&chip->mutex); |
916 | return ret; |
917 | |
918 | } |
919 | |
920 | static ssize_t apds990x_lux_thresh_above_store(struct device *dev, |
921 | struct device_attribute *attr, |
922 | const char *buf, size_t len) |
923 | { |
924 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
925 | int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_hi, buf); |
926 | if (ret < 0) |
927 | return ret; |
928 | return len; |
929 | } |
930 | |
931 | static ssize_t apds990x_lux_thresh_below_store(struct device *dev, |
932 | struct device_attribute *attr, |
933 | const char *buf, size_t len) |
934 | { |
935 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
936 | int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_lo, buf); |
937 | if (ret < 0) |
938 | return ret; |
939 | return len; |
940 | } |
941 | |
942 | static DEVICE_ATTR(lux0_thresh_above_value, S_IRUGO | S_IWUSR, |
943 | apds990x_lux_thresh_above_show, |
944 | apds990x_lux_thresh_above_store); |
945 | |
946 | static DEVICE_ATTR(lux0_thresh_below_value, S_IRUGO | S_IWUSR, |
947 | apds990x_lux_thresh_below_show, |
948 | apds990x_lux_thresh_below_store); |
949 | |
950 | static ssize_t apds990x_prox_threshold_show(struct device *dev, |
951 | struct device_attribute *attr, char *buf) |
952 | { |
953 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
954 | return sprintf(buf, "%d\n", chip->prox_thres); |
955 | } |
956 | |
957 | static ssize_t apds990x_prox_threshold_store(struct device *dev, |
958 | struct device_attribute *attr, |
959 | const char *buf, size_t len) |
960 | { |
961 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
962 | unsigned long value; |
963 | |
964 | if (strict_strtoul(buf, 0, &value)) |
965 | return -EINVAL; |
966 | |
967 | if ((value > APDS_RANGE) || (value == 0) || |
968 | (value < APDS_PROX_HYSTERESIS)) |
969 | return -EINVAL; |
970 | |
971 | mutex_lock(&chip->mutex); |
972 | chip->prox_thres = value; |
973 | |
974 | apds990x_force_p_refresh(chip); |
975 | mutex_unlock(&chip->mutex); |
976 | return len; |
977 | } |
978 | |
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, "%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 | |
997 | if (strict_strtoul(buf, 0, &value)) |
998 | return -EINVAL; |
999 | if (value) { |
1000 | pm_runtime_get_sync(dev); |
1001 | mutex_lock(&chip->mutex); |
1002 | chip->lux_wait_fresh_res = true; |
1003 | apds990x_force_a_refresh(chip); |
1004 | apds990x_force_p_refresh(chip); |
1005 | mutex_unlock(&chip->mutex); |
1006 | } else { |
1007 | if (!pm_runtime_suspended(dev)) |
1008 | pm_runtime_put(dev); |
1009 | } |
1010 | return len; |
1011 | } |
1012 | |
1013 | static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR, |
1014 | apds990x_power_state_show, |
1015 | apds990x_power_state_store); |
1016 | |
1017 | static ssize_t apds990x_chip_id_show(struct device *dev, |
1018 | struct device_attribute *attr, char *buf) |
1019 | { |
1020 | struct apds990x_chip *chip = dev_get_drvdata(dev); |
1021 | return sprintf(buf, "%s %d\n", chip->chipname, chip->revision); |
1022 | } |
1023 | |
1024 | static DEVICE_ATTR(chip_id, S_IRUGO, apds990x_chip_id_show, NULL); |
1025 | |
1026 | static struct attribute *sysfs_attrs_ctrl[] = { |
1027 | &dev_attr_lux0_calibscale.attr, |
1028 | &dev_attr_lux0_calibscale_default.attr, |
1029 | &dev_attr_lux0_input.attr, |
1030 | &dev_attr_lux0_sensor_range.attr, |
1031 | &dev_attr_lux0_rate.attr, |
1032 | &dev_attr_lux0_rate_avail.attr, |
1033 | &dev_attr_lux0_thresh_above_value.attr, |
1034 | &dev_attr_lux0_thresh_below_value.attr, |
1035 | &dev_attr_prox0_raw_en.attr, |
1036 | &dev_attr_prox0_raw.attr, |
1037 | &dev_attr_prox0_sensor_range.attr, |
1038 | &dev_attr_prox0_thresh_above_value.attr, |
1039 | &dev_attr_prox0_reporting_mode.attr, |
1040 | &dev_attr_prox0_reporting_mode_avail.attr, |
1041 | &dev_attr_chip_id.attr, |
1042 | &dev_attr_power_state.attr, |
1043 | NULL |
1044 | }; |
1045 | |
1046 | static struct attribute_group apds990x_attribute_group[] = { |
1047 | {.attrs = sysfs_attrs_ctrl }, |
1048 | }; |
1049 | |
1050 | static int apds990x_probe(struct i2c_client *client, |
1051 | const struct i2c_device_id *id) |
1052 | { |
1053 | struct apds990x_chip *chip; |
1054 | int err; |
1055 | |
1056 | chip = kzalloc(sizeof *chip, GFP_KERNEL); |
1057 | if (!chip) |
1058 | return -ENOMEM; |
1059 | |
1060 | i2c_set_clientdata(client, chip); |
1061 | chip->client = client; |
1062 | |
1063 | init_waitqueue_head(&chip->wait); |
1064 | mutex_init(&chip->mutex); |
1065 | chip->pdata = client->dev.platform_data; |
1066 | |
1067 | if (chip->pdata == NULL) { |
1068 | dev_err(&client->dev, "platform data is mandatory\n"); |
1069 | err = -EINVAL; |
1070 | goto fail1; |
1071 | } |
1072 | |
1073 | if (chip->pdata->cf.ga == 0) { |
1074 | /* set uncovered sensor default parameters */ |
1075 | chip->cf.ga = 1966; /* 0.48 * APDS_PARAM_SCALE */ |
1076 | chip->cf.cf1 = 4096; /* 1.00 * APDS_PARAM_SCALE */ |
1077 | chip->cf.irf1 = 9134; /* 2.23 * APDS_PARAM_SCALE */ |
1078 | chip->cf.cf2 = 2867; /* 0.70 * APDS_PARAM_SCALE */ |
1079 | chip->cf.irf2 = 5816; /* 1.42 * APDS_PARAM_SCALE */ |
1080 | chip->cf.df = 52; |
1081 | } else { |
1082 | chip->cf = chip->pdata->cf; |
1083 | } |
1084 | |
1085 | /* precalculate inverse chip factors for threshold control */ |
1086 | chip->rcf.afactor = |
1087 | (chip->cf.irf1 - chip->cf.irf2) * APDS_PARAM_SCALE / |
1088 | (chip->cf.cf1 - chip->cf.cf2); |
1089 | chip->rcf.cf1 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / |
1090 | chip->cf.cf1; |
1091 | chip->rcf.irf1 = chip->cf.irf1 * APDS_PARAM_SCALE / |
1092 | chip->cf.cf1; |
1093 | chip->rcf.cf2 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / |
1094 | chip->cf.cf2; |
1095 | chip->rcf.irf2 = chip->cf.irf2 * APDS_PARAM_SCALE / |
1096 | chip->cf.cf2; |
1097 | |
1098 | /* Set something to start with */ |
1099 | chip->lux_thres_hi = APDS_LUX_DEF_THRES_HI; |
1100 | chip->lux_thres_lo = APDS_LUX_DEF_THRES_LO; |
1101 | chip->lux_calib = APDS_LUX_NEUTRAL_CALIB_VALUE; |
1102 | |
1103 | chip->prox_thres = APDS_PROX_DEF_THRES; |
1104 | chip->pdrive = chip->pdata->pdrive; |
1105 | chip->pdiode = APDS_PDIODE_IR; |
1106 | chip->pgain = APDS_PGAIN_1X; |
1107 | chip->prox_calib = APDS_PROX_NEUTRAL_CALIB_VALUE; |
1108 | chip->prox_persistence = APDS_DEFAULT_PROX_PERS; |
1109 | chip->prox_continuous_mode = false; |
1110 | |
1111 | chip->regs[0].supply = reg_vcc; |
1112 | chip->regs[1].supply = reg_vled; |
1113 | |
1114 | err = regulator_bulk_get(&client->dev, |
1115 | ARRAY_SIZE(chip->regs), chip->regs); |
1116 | if (err < 0) { |
1117 | dev_err(&client->dev, "Cannot get regulators\n"); |
1118 | goto fail1; |
1119 | } |
1120 | |
1121 | err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs); |
1122 | if (err < 0) { |
1123 | dev_err(&client->dev, "Cannot enable regulators\n"); |
1124 | goto fail2; |
1125 | } |
1126 | |
1127 | usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY); |
1128 | |
1129 | err = apds990x_detect(chip); |
1130 | if (err < 0) { |
1131 | dev_err(&client->dev, "APDS990X not found\n"); |
1132 | goto fail3; |
1133 | } |
1134 | |
1135 | pm_runtime_set_active(&client->dev); |
1136 | |
1137 | apds990x_configure(chip); |
1138 | apds990x_set_arate(chip, APDS_LUX_DEFAULT_RATE); |
1139 | apds990x_mode_on(chip); |
1140 | |
1141 | pm_runtime_enable(&client->dev); |
1142 | |
1143 | if (chip->pdata->setup_resources) { |
1144 | err = chip->pdata->setup_resources(); |
1145 | if (err) { |
1146 | err = -EINVAL; |
1147 | goto fail3; |
1148 | } |
1149 | } |
1150 | |
1151 | err = sysfs_create_group(&chip->client->dev.kobj, |
1152 | apds990x_attribute_group); |
1153 | if (err < 0) { |
1154 | dev_err(&chip->client->dev, "Sysfs registration failed\n"); |
1155 | goto fail4; |
1156 | } |
1157 | |
1158 | err = request_threaded_irq(client->irq, NULL, |
1159 | apds990x_irq, |
1160 | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_LOW | |
1161 | IRQF_ONESHOT, |
1162 | "apds990x", chip); |
1163 | if (err) { |
1164 | dev_err(&client->dev, "could not get IRQ %d\n", |
1165 | client->irq); |
1166 | goto fail5; |
1167 | } |
1168 | return err; |
1169 | fail5: |
1170 | sysfs_remove_group(&chip->client->dev.kobj, |
1171 | &apds990x_attribute_group[0]); |
1172 | fail4: |
1173 | if (chip->pdata && chip->pdata->release_resources) |
1174 | chip->pdata->release_resources(); |
1175 | fail3: |
1176 | regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); |
1177 | fail2: |
1178 | regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); |
1179 | fail1: |
1180 | kfree(chip); |
1181 | return err; |
1182 | } |
1183 | |
1184 | static int apds990x_remove(struct i2c_client *client) |
1185 | { |
1186 | struct apds990x_chip *chip = i2c_get_clientdata(client); |
1187 | |
1188 | free_irq(client->irq, chip); |
1189 | sysfs_remove_group(&chip->client->dev.kobj, |
1190 | apds990x_attribute_group); |
1191 | |
1192 | if (chip->pdata && chip->pdata->release_resources) |
1193 | chip->pdata->release_resources(); |
1194 | |
1195 | if (!pm_runtime_suspended(&client->dev)) |
1196 | apds990x_chip_off(chip); |
1197 | |
1198 | pm_runtime_disable(&client->dev); |
1199 | pm_runtime_set_suspended(&client->dev); |
1200 | |
1201 | regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); |
1202 | |
1203 | kfree(chip); |
1204 | return 0; |
1205 | } |
1206 | |
1207 | #ifdef CONFIG_PM |
1208 | static int apds990x_suspend(struct device *dev) |
1209 | { |
1210 | struct i2c_client *client = container_of(dev, struct i2c_client, dev); |
1211 | struct apds990x_chip *chip = i2c_get_clientdata(client); |
1212 | |
1213 | apds990x_chip_off(chip); |
1214 | return 0; |
1215 | } |
1216 | |
1217 | static int apds990x_resume(struct device *dev) |
1218 | { |
1219 | struct i2c_client *client = container_of(dev, struct i2c_client, dev); |
1220 | struct apds990x_chip *chip = i2c_get_clientdata(client); |
1221 | |
1222 | /* |
1223 | * If we were enabled at suspend time, it is expected |
1224 | * everything works nice and smoothly. Chip_on is enough |
1225 | */ |
1226 | apds990x_chip_on(chip); |
1227 | |
1228 | return 0; |
1229 | } |
1230 | #else |
1231 | #define apds990x_suspend NULL |
1232 | #define apds990x_resume NULL |
1233 | #define apds990x_shutdown NULL |
1234 | #endif |
1235 | |
1236 | #ifdef CONFIG_PM_RUNTIME |
1237 | static int apds990x_runtime_suspend(struct device *dev) |
1238 | { |
1239 | struct i2c_client *client = container_of(dev, struct i2c_client, dev); |
1240 | struct apds990x_chip *chip = i2c_get_clientdata(client); |
1241 | |
1242 | apds990x_chip_off(chip); |
1243 | return 0; |
1244 | } |
1245 | |
1246 | static int apds990x_runtime_resume(struct device *dev) |
1247 | { |
1248 | struct i2c_client *client = container_of(dev, struct i2c_client, dev); |
1249 | struct apds990x_chip *chip = i2c_get_clientdata(client); |
1250 | |
1251 | apds990x_chip_on(chip); |
1252 | return 0; |
1253 | } |
1254 | |
1255 | #endif |
1256 | |
1257 | static const struct i2c_device_id apds990x_id[] = { |
1258 | {"apds990x", 0 }, |
1259 | {} |
1260 | }; |
1261 | |
1262 | MODULE_DEVICE_TABLE(i2c, apds990x_id); |
1263 | |
1264 | static const struct dev_pm_ops apds990x_pm_ops = { |
1265 | SET_SYSTEM_SLEEP_PM_OPS(apds990x_suspend, apds990x_resume) |
1266 | SET_RUNTIME_PM_OPS(apds990x_runtime_suspend, |
1267 | apds990x_runtime_resume, |
1268 | NULL) |
1269 | }; |
1270 | |
1271 | static struct i2c_driver apds990x_driver = { |
1272 | .driver = { |
1273 | .name = "apds990x", |
1274 | .owner = THIS_MODULE, |
1275 | .pm = &apds990x_pm_ops, |
1276 | }, |
1277 | .probe = apds990x_probe, |
1278 | .remove = apds990x_remove, |
1279 | .id_table = apds990x_id, |
1280 | }; |
1281 | |
1282 | module_i2c_driver(apds990x_driver); |
1283 | |
1284 | MODULE_DESCRIPTION("APDS990X combined ALS and proximity sensor"); |
1285 | MODULE_AUTHOR("Samu Onkalo, Nokia Corporation"); |
1286 | MODULE_LICENSE("GPL v2"); |
1287 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9