Update copyrights
[linux-2.6.git] / drivers / misc / apds990x.c
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 __devinit 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 __devexit 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   = __devexit_p(apds990x_remove),
1279         .id_table = apds990x_id,
1280 };
1281
1282 static int __init apds990x_init(void)
1283 {
1284         return i2c_add_driver(&apds990x_driver);
1285 }
1286
1287 static void __exit apds990x_exit(void)
1288 {
1289         i2c_del_driver(&apds990x_driver);
1290 }
1291
1292 MODULE_DESCRIPTION("APDS990X combined ALS and proximity sensor");
1293 MODULE_AUTHOR("Samu Onkalo, Nokia Corporation");
1294 MODULE_LICENSE("GPL v2");
1295
1296 module_init(apds990x_init);
1297 module_exit(apds990x_exit);