← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/misc/apds990x.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
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);