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