?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.2.1
[linux/fpc-iii.git] / drivers / misc / apds990x.c
blob3739ffa9cdf132e28098ad088b620c655c624dce
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 #ifdef CONFIG_PM
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 int ret;
700
701 ret = kstrtoul(buf, 0, &value);
702 if (ret)
703 return ret;
704
705 chip->lux_calib = value;
706
707 return len;
708 }
709
710 static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, apds990x_lux_calib_show,
711 apds990x_lux_calib_store);
712
713 static ssize_t apds990x_rate_avail(struct device *dev,
714 struct device_attribute *attr, char *buf)
715 {
716 int i;
717 int pos = 0;
718 for (i = 0; i < ARRAY_SIZE(arates_hz); i++)
719 pos += sprintf(buf + pos, "%d ", arates_hz[i]);
720 sprintf(buf + pos - 1, "\n");
721 return pos;
722 }
723
724 static ssize_t apds990x_rate_show(struct device *dev,
725 struct device_attribute *attr, char *buf)
726 {
727 struct apds990x_chip *chip = dev_get_drvdata(dev);
728 return sprintf(buf, "%d\n", chip->arate);
729 }
730
731 static int apds990x_set_arate(struct apds990x_chip *chip, int rate)
732 {
733 int i;
734
735 for (i = 0; i < ARRAY_SIZE(arates_hz); i++)
736 if (rate >= arates_hz[i])
737 break;
738
739 if (i == ARRAY_SIZE(arates_hz))
740 return -EINVAL;
741
742 /* Pick up corresponding persistence value */
743 chip->lux_persistence = apersis[i];
744 chip->arate = arates_hz[i];
745
746 /* If the chip is not in use, don't try to access it */
747 if (pm_runtime_suspended(&chip->client->dev))
748 return 0;
749
750 /* Persistence levels */
751 return apds990x_write_byte(chip, APDS990X_PERS,
752 (chip->lux_persistence << APDS990X_APERS_SHIFT) |
753 (chip->prox_persistence << APDS990X_PPERS_SHIFT));
754 }
755
756 static ssize_t apds990x_rate_store(struct device *dev,
757 struct device_attribute *attr,
758 const char *buf, size_t len)
759 {
760 struct apds990x_chip *chip = dev_get_drvdata(dev);
761 unsigned long value;
762 int ret;
763
764 ret = kstrtoul(buf, 0, &value);
765 if (ret)
766 return ret;
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 int ret;
820
821 ret = kstrtoul(buf, 0, &value);
822 if (ret)
823 return ret;
824
825 mutex_lock(&chip->mutex);
826
827 if (!chip->prox_en)
828 chip->prox_data = 0;
829
830 if (value)
831 chip->prox_en++;
832 else if (chip->prox_en > 0)
833 chip->prox_en--;
834
835 if (!pm_runtime_suspended(dev))
836 apds990x_mode_on(chip);
837 mutex_unlock(&chip->mutex);
838 return len;
839 }
840
841 static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, apds990x_prox_enable_show,
842 apds990x_prox_enable_store);
843
844 static const char reporting_modes[][9] = {"trigger", "periodic"};
845
846 static ssize_t apds990x_prox_reporting_mode_show(struct device *dev,
847 struct device_attribute *attr, char *buf)
848 {
849 struct apds990x_chip *chip = dev_get_drvdata(dev);
850 return sprintf(buf, "%s\n",
851 reporting_modes[!!chip->prox_continuous_mode]);
852 }
853
854 static ssize_t apds990x_prox_reporting_mode_store(struct device *dev,
855 struct device_attribute *attr,
856 const char *buf, size_t len)
857 {
858 struct apds990x_chip *chip = dev_get_drvdata(dev);
859
860 if (sysfs_streq(buf, reporting_modes[0]))
861 chip->prox_continuous_mode = 0;
862 else if (sysfs_streq(buf, reporting_modes[1]))
863 chip->prox_continuous_mode = 1;
864 else
865 return -EINVAL;
866 return len;
867 }
868
869 static DEVICE_ATTR(prox0_reporting_mode, S_IRUGO | S_IWUSR,
870 apds990x_prox_reporting_mode_show,
871 apds990x_prox_reporting_mode_store);
872
873 static ssize_t apds990x_prox_reporting_avail_show(struct device *dev,
874 struct device_attribute *attr, char *buf)
875 {
876 return sprintf(buf, "%s %s\n", reporting_modes[0], reporting_modes[1]);
877 }
878
879 static DEVICE_ATTR(prox0_reporting_mode_avail, S_IRUGO | S_IWUSR,
880 apds990x_prox_reporting_avail_show, NULL);
881
882
883 static ssize_t apds990x_lux_thresh_above_show(struct device *dev,
884 struct device_attribute *attr, char *buf)
885 {
886 struct apds990x_chip *chip = dev_get_drvdata(dev);
887 return sprintf(buf, "%d\n", chip->lux_thres_hi);
888 }
889
890 static ssize_t apds990x_lux_thresh_below_show(struct device *dev,
891 struct device_attribute *attr, char *buf)
892 {
893 struct apds990x_chip *chip = dev_get_drvdata(dev);
894 return sprintf(buf, "%d\n", chip->lux_thres_lo);
895 }
896
897 static ssize_t apds990x_set_lux_thresh(struct apds990x_chip *chip, u32 *target,
898 const char *buf)
899 {
900 unsigned long thresh;
901 int ret;
902
903 ret = kstrtoul(buf, 0, &thresh);
904 if (ret)
905 return ret;
906
907 if (thresh > APDS_RANGE)
908 return -EINVAL;
909
910 mutex_lock(&chip->mutex);
911 *target = thresh;
912 /*
913 * Don't update values in HW if we are still waiting for
914 * first interrupt to come after device handle open call.
915 */
916 if (!chip->lux_wait_fresh_res)
917 apds990x_refresh_athres(chip);
918 mutex_unlock(&chip->mutex);
919 return ret;
920
921 }
922
923 static ssize_t apds990x_lux_thresh_above_store(struct device *dev,
924 struct device_attribute *attr,
925 const char *buf, size_t len)
926 {
927 struct apds990x_chip *chip = dev_get_drvdata(dev);
928 int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_hi, buf);
929 if (ret < 0)
930 return ret;
931 return len;
932 }
933
934 static ssize_t apds990x_lux_thresh_below_store(struct device *dev,
935 struct device_attribute *attr,
936 const char *buf, size_t len)
937 {
938 struct apds990x_chip *chip = dev_get_drvdata(dev);
939 int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_lo, buf);
940 if (ret < 0)
941 return ret;
942 return len;
943 }
944
945 static DEVICE_ATTR(lux0_thresh_above_value, S_IRUGO | S_IWUSR,
946 apds990x_lux_thresh_above_show,
947 apds990x_lux_thresh_above_store);
948
949 static DEVICE_ATTR(lux0_thresh_below_value, S_IRUGO | S_IWUSR,
950 apds990x_lux_thresh_below_show,
951 apds990x_lux_thresh_below_store);
952
953 static ssize_t apds990x_prox_threshold_show(struct device *dev,
954 struct device_attribute *attr, char *buf)
955 {
956 struct apds990x_chip *chip = dev_get_drvdata(dev);
957 return sprintf(buf, "%d\n", chip->prox_thres);
958 }
959
960 static ssize_t apds990x_prox_threshold_store(struct device *dev,
961 struct device_attribute *attr,
962 const char *buf, size_t len)
963 {
964 struct apds990x_chip *chip = dev_get_drvdata(dev);
965 unsigned long value;
966 int ret;
967
968 ret = kstrtoul(buf, 0, &value);
969 if (ret)
970 return ret;
971
972 if ((value > APDS_RANGE) || (value == 0) ||
973 (value < APDS_PROX_HYSTERESIS))
974 return -EINVAL;
975
976 mutex_lock(&chip->mutex);
977 chip->prox_thres = value;
978
979 apds990x_force_p_refresh(chip);
980 mutex_unlock(&chip->mutex);
981 return len;
982 }
983
984 static DEVICE_ATTR(prox0_thresh_above_value, S_IRUGO | S_IWUSR,
985 apds990x_prox_threshold_show,
986 apds990x_prox_threshold_store);
987
988 static ssize_t apds990x_power_state_show(struct device *dev,
989 struct device_attribute *attr, char *buf)
990 {
991 return sprintf(buf, "%d\n", !pm_runtime_suspended(dev));
992 return 0;
993 }
994
995 static ssize_t apds990x_power_state_store(struct device *dev,
996 struct device_attribute *attr,
997 const char *buf, size_t len)
998 {
999 struct apds990x_chip *chip = dev_get_drvdata(dev);
1000 unsigned long value;
1001 int ret;
1002
1003 ret = kstrtoul(buf, 0, &value);
1004 if (ret)
1005 return ret;
1006
1007 if (value) {
1008 pm_runtime_get_sync(dev);
1009 mutex_lock(&chip->mutex);
1010 chip->lux_wait_fresh_res = true;
1011 apds990x_force_a_refresh(chip);
1012 apds990x_force_p_refresh(chip);
1013 mutex_unlock(&chip->mutex);
1014 } else {
1015 if (!pm_runtime_suspended(dev))
1016 pm_runtime_put(dev);
1017 }
1018 return len;
1019 }
1020
1021 static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR,
1022 apds990x_power_state_show,
1023 apds990x_power_state_store);
1024
1025 static ssize_t apds990x_chip_id_show(struct device *dev,
1026 struct device_attribute *attr, char *buf)
1027 {
1028 struct apds990x_chip *chip = dev_get_drvdata(dev);
1029 return sprintf(buf, "%s %d\n", chip->chipname, chip->revision);
1030 }
1031
1032 static DEVICE_ATTR(chip_id, S_IRUGO, apds990x_chip_id_show, NULL);
1033
1034 static struct attribute *sysfs_attrs_ctrl[] = {
1035 &dev_attr_lux0_calibscale.attr,
1036 &dev_attr_lux0_calibscale_default.attr,
1037 &dev_attr_lux0_input.attr,
1038 &dev_attr_lux0_sensor_range.attr,
1039 &dev_attr_lux0_rate.attr,
1040 &dev_attr_lux0_rate_avail.attr,
1041 &dev_attr_lux0_thresh_above_value.attr,
1042 &dev_attr_lux0_thresh_below_value.attr,
1043 &dev_attr_prox0_raw_en.attr,
1044 &dev_attr_prox0_raw.attr,
1045 &dev_attr_prox0_sensor_range.attr,
1046 &dev_attr_prox0_thresh_above_value.attr,
1047 &dev_attr_prox0_reporting_mode.attr,
1048 &dev_attr_prox0_reporting_mode_avail.attr,
1049 &dev_attr_chip_id.attr,
1050 &dev_attr_power_state.attr,
1051 NULL
1052 };
1053
1054 static struct attribute_group apds990x_attribute_group[] = {
1055 {.attrs = sysfs_attrs_ctrl },
1056 };
1057
1058 static int apds990x_probe(struct i2c_client *client,
1059 const struct i2c_device_id *id)
1060 {
1061 struct apds990x_chip *chip;
1062 int err;
1063
1064 chip = kzalloc(sizeof *chip, GFP_KERNEL);
1065 if (!chip)
1066 return -ENOMEM;
1067
1068 i2c_set_clientdata(client, chip);
1069 chip->client = client;
1070
1071 init_waitqueue_head(&chip->wait);
1072 mutex_init(&chip->mutex);
1073 chip->pdata = client->dev.platform_data;
1074
1075 if (chip->pdata == NULL) {
1076 dev_err(&client->dev, "platform data is mandatory\n");
1077 err = -EINVAL;
1078 goto fail1;
1079 }
1080
1081 if (chip->pdata->cf.ga == 0) {
1082 /* set uncovered sensor default parameters */
1083 chip->cf.ga = 1966; /* 0.48 * APDS_PARAM_SCALE */
1084 chip->cf.cf1 = 4096; /* 1.00 * APDS_PARAM_SCALE */
1085 chip->cf.irf1 = 9134; /* 2.23 * APDS_PARAM_SCALE */
1086 chip->cf.cf2 = 2867; /* 0.70 * APDS_PARAM_SCALE */
1087 chip->cf.irf2 = 5816; /* 1.42 * APDS_PARAM_SCALE */
1088 chip->cf.df = 52;
1089 } else {
1090 chip->cf = chip->pdata->cf;
1091 }
1092
1093 /* precalculate inverse chip factors for threshold control */
1094 chip->rcf.afactor =
1095 (chip->cf.irf1 - chip->cf.irf2) * APDS_PARAM_SCALE /
1096 (chip->cf.cf1 - chip->cf.cf2);
1097 chip->rcf.cf1 = APDS_PARAM_SCALE * APDS_PARAM_SCALE /
1098 chip->cf.cf1;
1099 chip->rcf.irf1 = chip->cf.irf1 * APDS_PARAM_SCALE /
1100 chip->cf.cf1;
1101 chip->rcf.cf2 = APDS_PARAM_SCALE * APDS_PARAM_SCALE /
1102 chip->cf.cf2;
1103 chip->rcf.irf2 = chip->cf.irf2 * APDS_PARAM_SCALE /
1104 chip->cf.cf2;
1105
1106 /* Set something to start with */
1107 chip->lux_thres_hi = APDS_LUX_DEF_THRES_HI;
1108 chip->lux_thres_lo = APDS_LUX_DEF_THRES_LO;
1109 chip->lux_calib = APDS_LUX_NEUTRAL_CALIB_VALUE;
1110
1111 chip->prox_thres = APDS_PROX_DEF_THRES;
1112 chip->pdrive = chip->pdata->pdrive;
1113 chip->pdiode = APDS_PDIODE_IR;
1114 chip->pgain = APDS_PGAIN_1X;
1115 chip->prox_calib = APDS_PROX_NEUTRAL_CALIB_VALUE;
1116 chip->prox_persistence = APDS_DEFAULT_PROX_PERS;
1117 chip->prox_continuous_mode = false;
1118
1119 chip->regs[0].supply = reg_vcc;
1120 chip->regs[1].supply = reg_vled;
1121
1122 err = regulator_bulk_get(&client->dev,
1123 ARRAY_SIZE(chip->regs), chip->regs);
1124 if (err < 0) {
1125 dev_err(&client->dev, "Cannot get regulators\n");
1126 goto fail1;
1127 }
1128
1129 err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs);
1130 if (err < 0) {
1131 dev_err(&client->dev, "Cannot enable regulators\n");
1132 goto fail2;
1133 }
1134
1135 usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY);
1136
1137 err = apds990x_detect(chip);
1138 if (err < 0) {
1139 dev_err(&client->dev, "APDS990X not found\n");
1140 goto fail3;
1141 }
1142
1143 pm_runtime_set_active(&client->dev);
1144
1145 apds990x_configure(chip);
1146 apds990x_set_arate(chip, APDS_LUX_DEFAULT_RATE);
1147 apds990x_mode_on(chip);
1148
1149 pm_runtime_enable(&client->dev);
1150
1151 if (chip->pdata->setup_resources) {
1152 err = chip->pdata->setup_resources();
1153 if (err) {
1154 err = -EINVAL;
1155 goto fail3;
1156 }
1157 }
1158
1159 err = sysfs_create_group(&chip->client->dev.kobj,
1160 apds990x_attribute_group);
1161 if (err < 0) {
1162 dev_err(&chip->client->dev, "Sysfs registration failed\n");
1163 goto fail4;
1164 }
1165
1166 err = request_threaded_irq(client->irq, NULL,
1167 apds990x_irq,
1168 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_LOW |
1169 IRQF_ONESHOT,
1170 "apds990x", chip);
1171 if (err) {
1172 dev_err(&client->dev, "could not get IRQ %d\n",
1173 client->irq);
1174 goto fail5;
1175 }
1176 return err;
1177 fail5:
1178 sysfs_remove_group(&chip->client->dev.kobj,
1179 &apds990x_attribute_group[0]);
1180 fail4:
1181 if (chip->pdata && chip->pdata->release_resources)
1182 chip->pdata->release_resources();
1183 fail3:
1184 regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs);
1185 fail2:
1186 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs);
1187 fail1:
1188 kfree(chip);
1189 return err;
1190 }
1191
1192 static int apds990x_remove(struct i2c_client *client)
1193 {
1194 struct apds990x_chip *chip = i2c_get_clientdata(client);
1195
1196 free_irq(client->irq, chip);
1197 sysfs_remove_group(&chip->client->dev.kobj,
1198 apds990x_attribute_group);
1199
1200 if (chip->pdata && chip->pdata->release_resources)
1201 chip->pdata->release_resources();
1202
1203 if (!pm_runtime_suspended(&client->dev))
1204 apds990x_chip_off(chip);
1205
1206 pm_runtime_disable(&client->dev);
1207 pm_runtime_set_suspended(&client->dev);
1208
1209 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs);
1210
1211 kfree(chip);
1212 return 0;
1213 }
1214
1215 #ifdef CONFIG_PM_SLEEP
1216 static int apds990x_suspend(struct device *dev)
1217 {
1218 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
1219 struct apds990x_chip *chip = i2c_get_clientdata(client);
1220
1221 apds990x_chip_off(chip);
1222 return 0;
1223 }
1224
1225 static int apds990x_resume(struct device *dev)
1226 {
1227 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
1228 struct apds990x_chip *chip = i2c_get_clientdata(client);
1229
1230 /*
1231 * If we were enabled at suspend time, it is expected
1232 * everything works nice and smoothly. Chip_on is enough
1233 */
1234 apds990x_chip_on(chip);
1235
1236 return 0;
1237 }
1238 #endif
1239
1240 #ifdef CONFIG_PM
1241 static int apds990x_runtime_suspend(struct device *dev)
1242 {
1243 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
1244 struct apds990x_chip *chip = i2c_get_clientdata(client);
1245
1246 apds990x_chip_off(chip);
1247 return 0;
1248 }
1249
1250 static int apds990x_runtime_resume(struct device *dev)
1251 {
1252 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
1253 struct apds990x_chip *chip = i2c_get_clientdata(client);
1254
1255 apds990x_chip_on(chip);
1256 return 0;
1257 }
1258
1259 #endif
1260
1261 static const struct i2c_device_id apds990x_id[] = {
1262 {"apds990x", 0 },
1263 {}
1264 };
1265
1266 MODULE_DEVICE_TABLE(i2c, apds990x_id);
1267
1268 static const struct dev_pm_ops apds990x_pm_ops = {
1269 SET_SYSTEM_SLEEP_PM_OPS(apds990x_suspend, apds990x_resume)
1270 SET_RUNTIME_PM_OPS(apds990x_runtime_suspend,
1271 apds990x_runtime_resume,
1272 NULL)
1273 };
1274
1275 static struct i2c_driver apds990x_driver = {
1276 .driver = {
1277 .name = "apds990x",
1278 .owner = THIS_MODULE,
1279 .pm = &apds990x_pm_ops,
1280 },
1281 .probe = apds990x_probe,
1282 .remove = apds990x_remove,
1283 .id_table = apds990x_id,
1284 };
1285
1286 module_i2c_driver(apds990x_driver);
1287
1288 MODULE_DESCRIPTION("APDS990X combined ALS and proximity sensor");
1289 MODULE_AUTHOR("Samu Onkalo, Nokia Corporation");
1290 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support