iio: common: NVS v209 common timestamps
[linux-3.10.git] / drivers / iio / light / nvs_max4400x.c
1 /* Copyright (c) 2014-2015, NVIDIA CORPORATION.  All rights reserved.
2  *
3  * This software is licensed under the terms of the GNU General Public
4  * License version 2, as published by the Free Software Foundation, and
5  * may be copied, distributed, and modified under those terms.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  */
12
13 /* The NVS = NVidia Sensor framework */
14 /* See nvs_iio.c and nvs.h for documentation */
15 /* See nvs_light.c and nvs_light.h for documentation */
16 /* See nvs_proximity.c and nvs_proximity.h for documentation */
17
18
19 #include <linux/i2c.h>
20 #include <linux/module.h>
21 #include <linux/slab.h>
22 #include <linux/err.h>
23 #include <linux/delay.h>
24 #include <linux/regulator/consumer.h>
25 #include <linux/workqueue.h>
26 #include <linux/interrupt.h>
27 #include <linux/of.h>
28 #include <linux/nvs.h>
29 #include <linux/nvs_light.h>
30 #include <linux/nvs_proximity.h>
31
32
33 #define MX_VENDOR                       "Maxim"
34 #define MX_NAME                         "max4400x"
35 #define MX_NAME_MAX44005                "max44005"
36 #define MX_NAME_MAX44006                "max44006"
37 #define MX_NAME_MAX44008                "max44008"
38 #define MX_DEVID_MAX44005               (0x05)
39 #define MX_DEVID_MAX44006               (0x06)
40 #define MX_DEVID_MAX44008               (0x08)
41 #define MX_HW_DELAY_MS                  (1)
42 #define MX_POLL_DLY_MS_DFLT             (2000)
43 #define MX_POLL_DLY_MS_MIN              (100)
44 #define MX_POLL_DLY_MS_MAX              (60000)
45 #define MX_AMB_CFG_DFLT                 (0x40)
46 #define MX_PRX_CFG_DFLT                 (0x12)
47 /* light defines */
48 #define MX_LIGHT_VERSION                (1)
49 #define MX_LIGHT_MAX_RANGE_IVAL         (14323)
50 #define MX_LIGHT_MAX_RANGE_MICRO        (0)
51 #define MX_LIGHT_RESOLUTION_IVAL        (0)
52 #define MX_LIGHT_RESOLUTION_MICRO       (14000)
53 #define MX_LIGHT_MILLIAMP_IVAL          (0)
54 #define MX_LIGHT_MILLIAMP_MICRO         (13500)
55 #define MX_LIGHT_SCALE_IVAL             (0)
56 #define MX_LIGHT_SCALE_MICRO            (1000)
57 #define MX_LIGHT_THRESHOLD_DFLT         (50)
58 /* proximity defines */
59 #define MX_PROX_VERSION                 (1)
60 /* binary proximity when max_range and resolution are 1.0 */
61 #define MX_PROX_MAX_RANGE_IVAL          (1)
62 #define MX_PROX_MAX_RANGE_MICRO         (0)
63 #define MX_PROX_RESOLUTION_IVAL         (1)
64 #define MX_PROX_RESOLUTION_MICRO        (0)
65 #define MX_PROX_MILLIAMP_IVAL           (10)
66 #define MX_PROX_MILLIAMP_MICRO          (19500)
67 #define MX_PROX_SCALE_IVAL              (0)
68 #define MX_PROX_SCALE_MICRO             (0)
69 #define MX_PROX_THRESHOLD_LO_DFLT       (10)
70 #define MX_PROX_THRESHOLD_HI_DFLT       (100)
71 /* HW registers */
72 #define MX_REG_STS                      (0x00)
73 #define MX_REG_STS_POR                  (0x04)
74 #define MX_REG_STS_RESET                (4)
75 #define MX_REG_STS_SHDN                 (3)
76 #define MX_REG_STS_PWRON                (2)
77 #define MX_REG_STS_PRXINTS              (1)
78 #define MX_REG_STS_AMBINTS              (0)
79 #define MX_REG_CFG_MAIN                 (0x01)
80 #define MX_REG_CFG_MAIN_POR             (0x00)
81 #define MX_REG_CFG_MAIN_MODE            (4)
82 #define MX_REG_CFG_MAIN_AMBSEL          (2)
83 #define MX_REG_CFG_MAIN_PRXINTE         (1)
84 #define MX_REG_CFG_MAIN_AMBINTE         (0)
85 #define MX_REG_CFG_MAIN_INTE_MASK       (0x03)
86 #define MX_REG_CFG_AMB                  (0x02)
87 #define MX_REG_CFG_AMB_POR              (0x20)
88 #define MX_REG_CFG_AMB_TRIM             (7)
89 #define MX_REG_CFG_AMB_COMPEN           (6)
90 #define MX_REG_CFG_AMB_TEMPEN           (5)
91 #define MX_REG_CFG_AMB_AMBTIM           (2)
92 #define MX_REG_CFG_AMB_AMBTIM_MASK      (0x1C)
93 #define MX_REG_CFG_AMB_AMBPGA           (0)
94 #define MX_REG_CFG_AMB_AMBPGA_MASK      (0x03)
95 #define MX_REG_CFG_PRX                  (0x03)
96 #define MX_REG_CFG_PRX_DRV              (4)
97 #define MX_REG_CFG_PRX_PRXTIM           (1)
98 #define MX_REG_CFG_PRX_PRXPGA           (0)
99 #define MX_REG_DATA_AMB_CLEAR           (0x04)
100 #define MX_REG_DATA_AMB_CLEAR_H         (0x04)
101 #define MX_REG_DATA_AMB_CLEAR_L         (0x05)
102 #define MX_REG_DATA_AMB_RED_H           (0x06)
103 #define MX_REG_DATA_AMB_RED_L           (0x07)
104 #define MX_REG_DATA_AMB_GREEN_H         (0x08)
105 #define MX_REG_DATA_AMB_GREEN_L         (0x09)
106 #define MX_REG_DATA_AMB_BLUE_H          (0x0A)
107 #define MX_REG_DATA_AMB_BLUE_L          (0x0B)
108 #define MX_REG_DATA_AMB_IR_H            (0x0C)
109 #define MX_REG_DATA_AMB_IR_L            (0x0D)
110 #define MX_REG_DATA_AMB_IRCOMP_H        (0x0E)
111 #define MX_REG_DATA_AMB_IRCOMP_L        (0x0F)
112 #define MX_REG_DATA_PROX_H              (0x10)
113 #define MX_REG_DATA_PROX_L              (0x11)
114 #define MX_REG_DATA_TEMP_H              (0x12)
115 #define MX_REG_DATA_TEMP_L              (0x13)
116 #define MX_REG_AMB_UPTHR_H              (0x14)
117 #define MX_REG_AMB_UPTHR_L              (0x15)
118 #define MX_REG_AMB_LOTHR_H              (0x16)
119 #define MX_REG_AMB_LOTHR_L              (0x17)
120 #define MX_REG_CFG_THR                  (0x18)
121 #define MX_REG_CFG_THR_PRXPST           (2)
122 #define MX_REG_CFG_THR_AMBPST           (0)
123 #define MX_REG_PRX_UPTHR_H              (0x19)
124 #define MX_REG_PRX_UPTHR_L              (0x1A)
125 #define MX_REG_PRX_LOTHR_H              (0x1B)
126 #define MX_REG_PRX_LOTHR_L              (0x1C)
127 #define MX_REG_TRIM_CLEAR               (0x1D)
128 #define MX_REG_TRIM_RED                 (0x1E)
129 #define MX_REG_TRIM_GREEN               (0x1F)
130 #define MX_REG_TRIM_BLUE                (0x20)
131 #define MX_REG_TRIM_IR                  (0x21)
132
133 #define MX_DEV_LIGHT                    (0)
134 #define MX_DEV_PROX                     (1)
135 #define MX_DEV_N                        (2)
136
137
138 /* regulator names in order of powering on */
139 static char *mx_vregs[] = {
140         "vdd",
141 };
142
143 static unsigned short mx_i2c_addrs[] = {
144         0x40,
145         0x41,
146         0x44,
147         0x45,
148 };
149
150 /* enable bit mask of MX_DEV_ (MX_DEV_TEMP would be bit 2) */
151 static u8 mx_mode_tbl[] = {             /* device enable */
152         0x00,                           /* nothing */
153         0x00,                           /* light */
154         0x50,                           /* proximity */
155         0x30,                           /* proximity + light */
156         0x00,                           /* temp */
157         0x00,                           /* temp + light */
158         0x30,                           /* temp + proximity */
159         0x30                            /* temp + proximity + light */
160 };
161
162 /* 1 nW/cm^2 = 0.00683 lux */
163 static struct nvs_light_dynamic mx_nld_tbl_44005[] = {
164         {{0, 20490},  {335,   687670}, {0, 13500}, 100, 0x00},
165         {{0, 81960},  {1342,  750680}, {0, 13500}, 100, 0x01},
166         {{0, 327680}, {5368,  381440}, {0, 13500}, 100, 0x02},
167         {{5, 245440}, {85936, 43520},  {0, 13500}, 100, 0x03}
168 };
169
170 static struct nvs_light_dynamic mx_nld_tbl_44006[] = {
171         {{0, 13660},  {223,   791780}, {0, 13500}, 100, 0x00},
172         {{0, 54640},  {895,   167120}, {0, 13500}, 100, 0x01},
173         {{0, 218560}, {3580,  668480}, {0, 13500}, 100, 0x02},
174         {{3, 496960}, {57290, 695680}, {0, 13500}, 100, 0x03}
175 };
176
177 static unsigned int mx_ambtim_mask[] = {
178         0x3FFF,                         /* 14 bits */
179         0x0FFF,                         /* 12 bits */
180         0x03FF,                         /* 10 bits */
181         0x00FF,                         /* 8 bits */
182         0x3FFF,                         /* 14 bits */
183         0x3FFF,                         /* N/A */
184         0x3FFF,                         /* N/A */
185         0x3FFF,                         /* N/A */
186 };
187
188 struct mx_state {
189         struct i2c_client *i2c;
190         struct nvs_fn_if *nvs;
191         void *nvs_st[MX_DEV_N];
192         struct sensor_cfg cfg[MX_DEV_N];
193         struct delayed_work dw;
194         struct regulator_bulk_data vreg[ARRAY_SIZE(mx_vregs)];
195         struct nvs_light light;
196         struct nvs_proximity prox;
197         unsigned int sts;               /* status flags */
198         unsigned int errs;              /* error count */
199         unsigned int enabled;           /* enable status */
200         u16 i2c_addr;                   /* I2C address */
201         u8 dev_id;                      /* device ID */
202         u8 amb_cfg;                     /* ambient configuration register */
203         u8 prx_cfg;                     /* proximity configuration register */
204         u8 thr_cfg;                     /* threshold persist register */
205         u8 rc_main_cfg;                 /* cache of main configuration */
206         u8 rc_amb_cfg;                  /* cache of ambient configuration */
207 };
208
209
210 static void mx_err(struct mx_state *st)
211 {
212         st->errs++;
213         if (!st->errs)
214                 st->errs--;
215 }
216
217 static void mx_mutex_lock(struct mx_state *st)
218 {
219         unsigned int i;
220
221         if (st->nvs) {
222                 for (i = 0; i < MX_DEV_N; i++) {
223                         if (st->nvs_st[i])
224                                 st->nvs->nvs_mutex_lock(st->nvs_st[i]);
225                 }
226         }
227 }
228
229 static void mx_mutex_unlock(struct mx_state *st)
230 {
231         unsigned int i;
232
233         if (st->nvs) {
234                 for (i = 0; i < MX_DEV_N; i++) {
235                         if (st->nvs_st[i])
236                                 st->nvs->nvs_mutex_unlock(st->nvs_st[i]);
237                 }
238         }
239 }
240
241 static int mx_i2c_read(struct mx_state *st, u8 reg, u16 len, u8 *val)
242 {
243         struct i2c_msg msg[2];
244         int ret = -ENODEV;
245
246         if (st->i2c_addr) {
247                 msg[0].addr = st->i2c_addr;
248                 msg[0].flags = 0;
249                 msg[0].len = 1;
250                 msg[0].buf = &reg;
251                 msg[1].addr = st->i2c_addr;
252                 msg[1].flags = I2C_M_RD;
253                 msg[1].len = len;
254                 msg[1].buf = val;
255                 if (i2c_transfer(st->i2c->adapter, msg, 2) == 2) {
256                         ret = 0;
257                 } else {
258                         mx_err(st);
259                         ret = -EIO;
260                 }
261         }
262         return ret;
263 }
264
265 static int mx_i2c_rd(struct mx_state *st, u8 reg, u8 *val)
266 {
267         return mx_i2c_read(st, reg, 1, val);
268 }
269
270 static int mx_i2c_write(struct mx_state *st, u16 len, u8 *buf)
271 {
272         struct i2c_msg msg;
273         int ret = -ENODEV;
274
275         if (st->i2c_addr) {
276                 msg.addr = st->i2c_addr;
277                 msg.flags = 0;
278                 msg.len = len;
279                 msg.buf = buf;
280                 if (i2c_transfer(st->i2c->adapter, &msg, 1) == 1) {
281                         ret = 0;
282                 } else {
283                         mx_err(st);
284                         ret = -EIO;
285                 }
286         }
287
288         return ret;
289 }
290
291 static int mx_i2c_wr(struct mx_state *st, u8 reg, u8 val)
292 {
293         u8 buf[2];
294
295         buf[0] = reg;
296         buf[1] = val;
297         return mx_i2c_write(st, sizeof(buf), buf);
298 }
299
300 static void mx_cfg(struct mx_state *st)
301 {
302         unsigned int i;
303
304         i = st->rc_amb_cfg & MX_REG_CFG_AMB_AMBTIM_MASK;
305         i >>= MX_REG_CFG_AMB_AMBTIM;
306         st->light.hw_mask = mx_ambtim_mask[i];
307 }
308
309 static int mx_reset_sw(struct mx_state *st)
310 {
311         int ret;
312
313         ret = mx_i2c_wr(st, MX_REG_STS, (1 << MX_REG_STS_RESET));
314         if (!ret) {
315                 mdelay(MX_HW_DELAY_MS);
316                 st->rc_main_cfg = MX_REG_CFG_MAIN_POR;
317                 st->rc_amb_cfg = MX_REG_CFG_AMB_POR;
318                 mx_cfg(st);
319         }
320         return ret;
321 }
322
323 static int mx_pm(struct mx_state *st, bool enable)
324 {
325         int ret = 0;
326
327         if (enable) {
328                 nvs_vregs_enable(&st->i2c->dev, st->vreg,
329                                  ARRAY_SIZE(mx_vregs));
330                 if (ret)
331                         mdelay(MX_HW_DELAY_MS);
332                 ret = mx_reset_sw(st);
333         } else {
334                 ret = nvs_vregs_sts(st->vreg, ARRAY_SIZE(mx_vregs));
335                 if ((ret < 0) || (ret == ARRAY_SIZE(mx_vregs))) {
336                         ret = mx_i2c_wr(st, MX_REG_CFG_PRX, 0);
337                         ret |= mx_i2c_wr(st, MX_REG_STS, 1 << MX_REG_STS_SHDN);
338                 } else if (ret > 0) {
339                         nvs_vregs_enable(&st->i2c->dev, st->vreg,
340                                          ARRAY_SIZE(mx_vregs));
341                         mdelay(MX_HW_DELAY_MS);
342                         ret = mx_i2c_wr(st, MX_REG_CFG_PRX, 0);
343                         ret |= mx_i2c_wr(st, MX_REG_STS, 1 << MX_REG_STS_SHDN);
344                 }
345                 ret |= nvs_vregs_disable(&st->i2c->dev, st->vreg,
346                                          ARRAY_SIZE(mx_vregs));
347         }
348         if (ret > 0)
349                 ret = 0;
350         if (ret) {
351                 dev_err(&st->i2c->dev, "%s pwr=%x ERR=%d\n",
352                         __func__, enable, ret);
353         } else {
354                 if (st->sts & NVS_STS_SPEW_MSG)
355                         dev_info(&st->i2c->dev, "%s pwr=%x\n",
356                                  __func__, enable);
357         }
358         return ret;
359 }
360
361 static void mx_pm_exit(struct mx_state *st)
362 {
363         mx_pm(st, false);
364         nvs_vregs_exit(&st->i2c->dev, st->vreg, ARRAY_SIZE(mx_vregs));
365 }
366
367 static int mx_pm_init(struct mx_state *st)
368 {
369         int ret;
370
371         st->enabled = 0;
372         nvs_vregs_init(&st->i2c->dev,
373                        st->vreg, ARRAY_SIZE(mx_vregs), mx_vregs);
374         ret = mx_pm(st, true);
375         return ret;
376 }
377
378 static int mx_cmd_wr(struct mx_state *st, unsigned int enable, bool irq_en)
379 {
380         u8 amb_cfg = st->amb_cfg;
381         u8 main_cfg = 0;
382         int ret;
383         int ret_t = 0;
384
385         amb_cfg |= mx_nld_tbl_44005[st->light.nld_i].driver_data;
386         if (amb_cfg != st->rc_amb_cfg) {
387                 ret = mx_i2c_wr(st, MX_REG_CFG_AMB, amb_cfg);
388                 if (ret) {
389                         ret_t |= ret;
390                 } else {
391                         st->rc_amb_cfg = amb_cfg;
392                         mx_cfg(st);
393                 }
394                 if (st->sts & NVS_STS_SPEW_MSG)
395                         dev_info(&st->i2c->dev, "%s amb_cfg=%hhx err=%d\n",
396                                  __func__, amb_cfg, ret);
397         }
398         main_cfg = mx_mode_tbl[enable];
399         if (irq_en && st->i2c->irq) {
400                 if (enable & (1 << MX_DEV_LIGHT))
401                         main_cfg |= (1 << MX_REG_CFG_MAIN_AMBINTE);
402                 if (enable & (1 << MX_DEV_PROX))
403                         main_cfg |= (1 << MX_REG_CFG_MAIN_PRXINTE);
404         }
405         if (main_cfg != st->rc_main_cfg) {
406                 ret = mx_i2c_wr(st, MX_REG_CFG_MAIN, main_cfg);
407                 if (ret)
408                         ret_t |= ret;
409                 else
410                         st->rc_main_cfg = main_cfg;
411                 if (st->sts & NVS_STS_SPEW_MSG)
412                         dev_info(&st->i2c->dev, "%s main_cfg=%hhx err=%d\n",
413                                  __func__, main_cfg, ret);
414         }
415         if (st->rc_main_cfg & MX_REG_CFG_MAIN_INTE_MASK)
416                 ret_t = RET_HW_UPDATE; /* flag IRQ enabled */
417         return ret_t;
418 }
419
420 static int mx_thr_wr(struct mx_state *st, u8 reg, u16 thr_lo, u16 thr_hi)
421 {
422         u8 buf[5];
423         u16 thr_be;
424         int ret = RET_POLL_NEXT;
425
426         if (st->i2c->irq) {
427                 buf[0] = reg;
428                 thr_be = cpu_to_be16(thr_hi);
429                 buf[1] = thr_be & 0xFF;
430                 buf[2] = thr_be >> 8;
431                 thr_be = cpu_to_be16(thr_lo);
432                 buf[3] = thr_be & 0xFF;
433                 buf[4] = thr_be >> 8;
434                 ret = mx_i2c_write(st, sizeof(buf), buf);
435                 if (st->sts & NVS_STS_SPEW_MSG)
436                         dev_info(&st->i2c->dev,
437                                  "%s reg=%hhx lo=%hd hi=%hd ret=%d\n",
438                                  __func__, reg, thr_lo, thr_hi, ret);
439         }
440         return ret;
441 }
442
443 static int mx_rd_light(struct mx_state *st, s64 ts)
444 {
445         u16 hw;
446         int ret;
447
448         ret = mx_i2c_read(st, MX_REG_DATA_AMB_CLEAR, 2, (u8 *)&hw);
449         if (ret)
450                 return ret;
451
452         hw = be16_to_cpu(hw);
453         if (st->sts & NVS_STS_SPEW_DATA)
454                 dev_info(&st->i2c->dev,
455                          "poll light hw %hu %lld  diff=%d %lldns  index=%u\n",
456                          hw, ts, hw - st->light.hw, ts - st->light.timestamp,
457                          st->light.nld_i);
458         st->light.hw = hw;
459         st->light.timestamp = ts;
460         ret = nvs_light_read(&st->light);
461         if (ret < RET_HW_UPDATE)
462                 /* either poll or nothing to do */
463                 return ret;
464
465         ret = mx_thr_wr(st, MX_REG_AMB_UPTHR_H,
466                         st->light.hw_thresh_lo, st->light.hw_thresh_hi);
467         return ret;
468 }
469
470 static int mx_rd_prox(struct mx_state *st, s64 ts)
471 {
472         u16 hw;
473         int ret;
474
475         ret = mx_i2c_read(st, MX_REG_DATA_PROX_H, 2, (u8 *)&hw);
476         if (ret)
477                 return ret;
478
479         hw = be16_to_cpu(hw);
480         if (st->sts & NVS_STS_SPEW_DATA)
481                 dev_info(&st->i2c->dev,
482                          "poll proximity hw %hu %lld  diff=%d %lldns\n",
483                          hw, ts, hw - st->prox.hw, ts - st->prox.timestamp);
484         st->prox.hw = hw;
485         st->prox.timestamp = ts;
486         ret = nvs_proximity_read(&st->prox);
487         if (ret < RET_HW_UPDATE)
488                 /* either poll or nothing to do */
489                 return ret;
490
491         ret = mx_thr_wr(st, MX_REG_PRX_UPTHR_H,
492                         st->prox.hw_thresh_lo, st->prox.hw_thresh_hi);
493         return ret;
494 }
495
496 static int mx_en(struct mx_state *st, unsigned int enable)
497 {
498         int ret;
499
500         ret = mx_i2c_wr(st, MX_REG_CFG_THR, st->thr_cfg);
501         if (enable & (1 << MX_DEV_PROX)) {
502                 ret |= mx_i2c_wr(st, MX_REG_CFG_PRX, st->prx_cfg);
503                 if (st->prx_cfg & (1 << MX_REG_CFG_PRX_PRXTIM))
504                         st->prox.hw_mask = 0x00FF;
505                 else
506                         st->prox.hw_mask = 0x03FF;
507                 nvs_proximity_enable(&st->prox);
508         }
509         if (enable & (1 << MX_DEV_LIGHT))
510                 nvs_light_enable(&st->light);
511         ret |= mx_cmd_wr(st, enable, false);
512         if (st->sts & NVS_STS_SPEW_MSG) {
513                 if (enable & (1 << MX_DEV_PROX))
514                         dev_info(&st->i2c->dev,
515                                  "%s thr_cfg=%hhx prx_cfg=%hhx err=%d\n",
516                                  __func__, st->thr_cfg, st->prx_cfg, ret);
517                 else
518                         dev_info(&st->i2c->dev, "%s thr_cfg=%hhx err=%d\n",
519                                  __func__, st->thr_cfg, ret);
520         }
521         return ret;
522 }
523
524 static int mx_rd(struct mx_state *st)
525 {
526         u8 sts;
527         s64 ts;
528         int ret;
529
530         /* clear possible IRQ */
531         ret = mx_i2c_rd(st, MX_REG_STS, &sts);
532         if (ret)
533                 return ret;
534
535         if (sts & (1 << MX_REG_STS_PWRON)) {
536                 /* restart */
537                 mx_en(st, st->enabled);
538                 return RET_POLL_NEXT;
539         }
540
541         ts = nvs_timestamp();
542         if (st->enabled & (1 << MX_DEV_PROX))
543                 ret |= mx_rd_prox(st, ts);
544         if (st->enabled & (1 << MX_DEV_LIGHT))
545                 ret |= mx_rd_light(st, ts);
546         if (ret < 0)
547                 /* poll if error or more reporting */
548                 ret = mx_cmd_wr(st, st->enabled, false);
549         else
550                 ret = mx_cmd_wr(st, st->enabled, true);
551         return ret;
552 }
553
554 static unsigned int mx_polldelay(struct mx_state *st)
555 {
556         unsigned int poll_delay_ms = MX_POLL_DLY_MS_DFLT;
557
558         if (st->enabled & (1 << MX_DEV_LIGHT))
559                 poll_delay_ms = st->light.poll_delay_ms;
560         if (st->enabled & (1 << MX_DEV_PROX)) {
561                 if (poll_delay_ms > st->prox.poll_delay_ms)
562                         poll_delay_ms = st->prox.poll_delay_ms;
563         }
564         return poll_delay_ms;
565 }
566
567 static void mx_read(struct mx_state *st)
568 {
569         int ret;
570
571         mx_mutex_lock(st);
572         if (st->enabled) {
573                 ret = mx_rd(st);
574                 if (ret < 1)
575                         schedule_delayed_work(&st->dw,
576                                            msecs_to_jiffies(mx_polldelay(st)));
577         }
578         mx_mutex_unlock(st);
579 }
580
581 static void mx_work(struct work_struct *ws)
582 {
583         struct mx_state *st = container_of((struct delayed_work *)ws,
584                                            struct mx_state, dw);
585
586         mx_read(st);
587 }
588
589 static irqreturn_t mx_irq_thread(int irq, void *dev_id)
590 {
591         struct mx_state *st = (struct mx_state *)dev_id;
592
593         if (st->sts & NVS_STS_SPEW_IRQ)
594                 dev_info(&st->i2c->dev, "%s\n", __func__);
595         mx_read(st);
596         return IRQ_HANDLED;
597 }
598
599 static int mx_disable(struct mx_state *st, int snsr_id)
600 {
601         bool disable = true;
602         int ret = 0;
603
604         if (snsr_id >= 0) {
605                 if (st->enabled & ~(1 << snsr_id)) {
606                         st->enabled &= ~(1 << snsr_id);
607                         disable = false;
608                         if (snsr_id == MX_DEV_PROX)
609                                 ret = mx_i2c_wr(st, MX_REG_CFG_PRX, 0);
610                 }
611         }
612         if (disable) {
613                 cancel_delayed_work(&st->dw);
614                 ret |= mx_pm(st, false);
615                 if (!ret)
616                         st->enabled = 0;
617         }
618         return ret;
619 }
620
621 static int mx_enable(void *client, int snsr_id, int enable)
622 {
623         struct mx_state *st = (struct mx_state *)client;
624         int ret;
625
626         if (enable < 0)
627                 return st->enabled & (1 << snsr_id);
628
629         if (enable) {
630                 enable = st->enabled | (1 << snsr_id);
631                 ret = mx_pm(st, true);
632                 if (!ret) {
633                         ret = mx_en(st, enable);
634                         if (ret < 0) {
635                                 mx_disable(st, snsr_id);
636                         } else {
637                                 st->enabled = enable;
638                                 schedule_delayed_work(&st->dw,
639                                          msecs_to_jiffies(MX_POLL_DLY_MS_MIN));
640                         }
641                 }
642         } else {
643                 ret = mx_disable(st, snsr_id);
644         }
645         return ret;
646 }
647
648 static int mx_batch(void *client, int snsr_id, int flags,
649                     unsigned int period, unsigned int timeout)
650 {
651         struct mx_state *st = (struct mx_state *)client;
652
653         if (timeout)
654                 /* timeout not supported (no HW FIFO) */
655                 return -EINVAL;
656
657         if (snsr_id == MX_DEV_LIGHT)
658                 st->light.delay_us = period;
659         else if (snsr_id == MX_DEV_PROX)
660                 st->prox.delay_us = period;
661         return 0;
662 }
663
664 static int mx_thresh_lo(void *client, int snsr_id, int thresh_lo)
665 {
666         struct mx_state *st = (struct mx_state *)client;
667
668         if (snsr_id == MX_DEV_LIGHT)
669                 nvs_light_threshold_calibrate_lo(&st->light, thresh_lo);
670         else if (snsr_id == MX_DEV_PROX)
671                 nvs_proximity_threshold_calibrate_lo(&st->prox, thresh_lo);
672
673         return 0;
674 }
675
676 static int mx_thresh_hi(void *client, int snsr_id, int thresh_hi)
677 {
678         struct mx_state *st = (struct mx_state *)client;
679
680         if (snsr_id == MX_DEV_LIGHT)
681                 nvs_light_threshold_calibrate_hi(&st->light, thresh_hi);
682         else if (snsr_id == MX_DEV_PROX)
683                 nvs_proximity_threshold_calibrate_hi(&st->prox, thresh_hi);
684         return 0;
685 }
686
687 static int mx_regs(void *client, int snsr_id, char *buf)
688 {
689         struct mx_state *st = (struct mx_state *)client;
690         ssize_t t;
691         u8 val[2];
692         u8 i;
693         int ret;
694
695         t = sprintf(buf, "registers:\n");
696         for (i = 0; i <= MX_REG_CFG_PRX; i++) {
697                 ret = mx_i2c_rd(st, i, val);
698                 if (!ret)
699                         t += sprintf(buf + t, "0x%hhx=0x%hhx\n",
700                                      i, val[0]);
701         }
702         for (i = MX_REG_DATA_AMB_CLEAR; i < MX_REG_CFG_THR; i += 2) {
703                 ret = mx_i2c_read(st, i, 2, val);
704                 if (!ret)
705                         t += sprintf(buf + t, "0x%hhx:0x%hhx=0x%hx\n",
706                                 i, i + 1, be16_to_cpup((__be16 *)val));
707         }
708         ret = mx_i2c_rd(st, MX_REG_CFG_THR, val);
709         if (!ret)
710                 t += sprintf(buf + t, "0x%hhx=0x%hhx\n",
711                              MX_REG_CFG_THR, val[0]);
712         for (i = MX_REG_PRX_UPTHR_H; i < MX_REG_TRIM_CLEAR; i += 2) {
713                 ret = mx_i2c_read(st, i, 2, val);
714                 if (!ret)
715                         t += sprintf(buf + t, "0x%hhx:0x%hhx=0x%hx\n",
716                                 i, i + 1, be16_to_cpup((__be16 *)val));
717         }
718         for (i = MX_REG_TRIM_CLEAR; i <= MX_REG_TRIM_IR; i++) {
719                 ret = mx_i2c_rd(st, i, val);
720                 if (!ret)
721                         t += sprintf(buf + t, "0x%hhx=0x%hhx\n",
722                                      i, val[0]);
723         }
724         return t;
725 }
726
727 static struct nvs_fn_dev mx_fn_dev = {
728         .enable                         = mx_enable,
729         .batch                          = mx_batch,
730         .thresh_lo                      = mx_thresh_lo,
731         .thresh_hi                      = mx_thresh_hi,
732         .regs                           = mx_regs,
733 };
734
735 static int mx_suspend(struct device *dev)
736 {
737         struct i2c_client *client = to_i2c_client(dev);
738         struct mx_state *st = i2c_get_clientdata(client);
739         unsigned int i;
740         int ret = 0;
741
742         st->sts |= NVS_STS_SUSPEND;
743         if (st->nvs) {
744                 for (i = 0; i < MX_DEV_N; i++) {
745                         if (st->nvs_st[i])
746                                 ret |= st->nvs->suspend(st->nvs_st[i]);
747                 }
748         }
749         if (st->sts & NVS_STS_SPEW_MSG)
750                 dev_info(&client->dev, "%s\n", __func__);
751         return ret;
752 }
753
754 static int mx_resume(struct device *dev)
755 {
756         struct i2c_client *client = to_i2c_client(dev);
757         struct mx_state *st = i2c_get_clientdata(client);
758         unsigned int i;
759         int ret = 0;
760
761         if (st->nvs) {
762                 for (i = 0; i < MX_DEV_N; i++) {
763                         if (st->nvs_st[i])
764                                 ret |= st->nvs->resume(st->nvs_st[i]);
765                 }
766         }
767         st->sts &= ~NVS_STS_SUSPEND;
768         if (st->sts & NVS_STS_SPEW_MSG)
769                 dev_info(&client->dev, "%s\n", __func__);
770         return 0;
771 }
772
773 static SIMPLE_DEV_PM_OPS(mx_pm_ops, mx_suspend, mx_resume);
774
775 static void mx_shutdown(struct i2c_client *client)
776 {
777         struct mx_state *st = i2c_get_clientdata(client);
778         unsigned int i;
779
780         st->sts |= NVS_STS_SHUTDOWN;
781         if (st->nvs) {
782                 for (i = 0; i < MX_DEV_N; i++) {
783                         if (st->nvs_st[i])
784                                 st->nvs->shutdown(st->nvs_st[i]);
785                 }
786         }
787         if (st->sts & NVS_STS_SPEW_MSG)
788                 dev_info(&client->dev, "%s\n", __func__);
789 }
790
791 static int mx_remove(struct i2c_client *client)
792 {
793         struct mx_state *st = i2c_get_clientdata(client);
794         unsigned int i;
795
796         if (st != NULL) {
797                 mx_shutdown(client);
798                 if (st->nvs) {
799                         for (i = 0; i < MX_DEV_N; i++) {
800                                 if (st->nvs_st[i])
801                                         st->nvs->remove(st->nvs_st[i]);
802                         }
803                 }
804                 if (st->dw.wq)
805                         destroy_workqueue(st->dw.wq);
806                 mx_pm_exit(st);
807         }
808         dev_info(&client->dev, "%s\n", __func__);
809         return 0;
810 }
811
812 static void mx_id_part(struct mx_state *st, const char *part)
813 {
814         unsigned int i;
815
816         for (i = 0; i < MX_DEV_N; i++)
817                 st->cfg[i].part = part;
818 }
819
820 static int mx_id_dev(struct mx_state *st, const char *name)
821 {
822         struct nvs_light_dynamic *mx_nld_tbl;
823         u8 val;
824         unsigned int i;
825         int ret = 0;
826
827         if (!strcmp(name, MX_NAME_MAX44008)) {
828                 st->dev_id = MX_DEVID_MAX44008;
829                 mx_id_part(st, MX_NAME_MAX44008);
830         } else if (!strcmp(name, MX_NAME_MAX44006)) {
831                 st->dev_id = MX_DEVID_MAX44006;
832                 mx_id_part(st, MX_NAME_MAX44006);
833         } else if (!strcmp(name, MX_NAME_MAX44005)) {
834                 st->dev_id = MX_DEVID_MAX44005;
835                 mx_id_part(st, MX_NAME_MAX44005);
836         } else {
837                 /* There is no way to auto-detect the device since the
838                  * MX44006/8 has actual proximity HW that works but just
839                  * doesn't have the undetectable LED driver HW.  And of
840                  * course there isn't an ID register either.  So we'll
841                  * just confirm that our device exists and default to the
842                  * MX44005 with proximity support if using max4400x.
843                  */
844                 st->dev_id = MX_DEVID_MAX44005;
845                 mx_id_part(st, MX_NAME_MAX44005);
846                 ret = mx_reset_sw(st);
847                 ret |= mx_i2c_rd(st, MX_REG_STS, &val);
848                 if (ret)
849                         return -ENODEV;
850
851                 if (val != MX_REG_STS_POR)
852                         return -ENODEV;
853         }
854
855         if (st->dev_id == MX_DEVID_MAX44005)
856                 mx_nld_tbl = mx_nld_tbl_44005;
857         else
858                 mx_nld_tbl = mx_nld_tbl_44006;
859         st->light.nld_tbl = mx_nld_tbl;
860         i = st->light.nld_i_lo;
861         st->cfg[MX_DEV_LIGHT].resolution.ival = mx_nld_tbl[i].resolution.ival;
862         st->cfg[MX_DEV_LIGHT].resolution.fval = mx_nld_tbl[i].resolution.fval;
863         i = st->light.nld_i_hi;
864         st->cfg[MX_DEV_LIGHT].max_range.ival = mx_nld_tbl[i].max_range.ival;
865         st->cfg[MX_DEV_LIGHT].max_range.fval = mx_nld_tbl[i].max_range.fval;
866         st->cfg[MX_DEV_LIGHT].delay_us_min = mx_nld_tbl[i].delay_min_ms * 1000;
867         return ret;
868 }
869
870 static int mx_id_i2c(struct mx_state *st, const char *name)
871 {
872         int i;
873         int ret;
874
875         for (i = 0; i < ARRAY_SIZE(mx_i2c_addrs); i++) {
876                 if (st->i2c->addr == mx_i2c_addrs[i])
877                         break;
878         }
879
880         if (i < ARRAY_SIZE(mx_i2c_addrs)) {
881                 st->i2c_addr = st->i2c->addr;
882                 ret = mx_id_dev(st, name);
883         } else {
884                 name = MX_NAME;
885                 for (i = 0; i < ARRAY_SIZE(mx_i2c_addrs); i++) {
886                         st->i2c_addr = mx_i2c_addrs[i];
887                         ret = mx_id_dev(st, name);
888                         if (!ret)
889                                 break;
890                 }
891         }
892         if (ret)
893                 st->i2c_addr = 0;
894         return ret;
895 }
896
897 struct sensor_cfg mx_cfg_dflt[] = {
898         {
899                 .name                   = NVS_LIGHT_STRING,
900                 .snsr_id                = MX_DEV_LIGHT,
901                 .ch_n                   = 1,
902                 .ch_sz                  = 4,
903                 .part                   = MX_NAME,
904                 .vendor                 = MX_VENDOR,
905                 .version                = MX_LIGHT_VERSION,
906                 .max_range              = {
907                         .ival           = MX_LIGHT_MAX_RANGE_IVAL,
908                         .fval           = MX_LIGHT_MAX_RANGE_MICRO,
909                 },
910                 .resolution             = {
911                         .ival           = MX_LIGHT_RESOLUTION_IVAL,
912                         .fval           = MX_LIGHT_RESOLUTION_MICRO,
913                 },
914                 .milliamp               = {
915                         .ival           = MX_LIGHT_MILLIAMP_IVAL,
916                         .fval           = MX_LIGHT_MILLIAMP_MICRO,
917                 },
918                 .delay_us_min           = MX_POLL_DLY_MS_MIN * 1000,
919                 .delay_us_max           = MX_POLL_DLY_MS_MAX * 1000,
920                 .flags                  = SENSOR_FLAG_ON_CHANGE_MODE,
921                 .scale                  = {
922                         .ival           = MX_LIGHT_SCALE_IVAL,
923                         .fval           = MX_LIGHT_SCALE_MICRO,
924                 },
925                 .thresh_lo              = MX_LIGHT_THRESHOLD_DFLT,
926                 .thresh_hi              = MX_LIGHT_THRESHOLD_DFLT,
927         },
928         {
929                 .name                   = NVS_PROXIMITY_STRING,
930                 .ch_n                   = 1,
931                 .ch_sz                  = 4,
932                 .part                   = MX_NAME,
933                 .vendor                 = MX_VENDOR,
934                 .version                = MX_PROX_VERSION,
935                 .max_range              = {
936                         .ival           = MX_PROX_MAX_RANGE_IVAL,
937                         .fval           = MX_PROX_MAX_RANGE_MICRO,
938                 },
939                 .resolution             = {
940                         .ival           = MX_PROX_RESOLUTION_IVAL,
941                         .fval           = MX_PROX_RESOLUTION_MICRO,
942                 },
943                 .milliamp               = {
944                         .ival           = MX_PROX_MILLIAMP_IVAL,
945                         .fval           = MX_PROX_MILLIAMP_MICRO,
946                 },
947                 .delay_us_min           = MX_POLL_DLY_MS_MIN * 1000,
948                 .delay_us_max           = MX_POLL_DLY_MS_MAX * 1000,
949                 .flags                  = SENSOR_FLAG_ON_CHANGE_MODE |
950                                           SENSOR_FLAG_WAKE_UP,
951                 .scale                  = {
952                         .ival           = MX_PROX_SCALE_IVAL,
953                         .fval           = MX_PROX_SCALE_MICRO,
954                 },
955                 .thresh_lo              = MX_PROX_THRESHOLD_LO_DFLT,
956                 .thresh_hi              = MX_PROX_THRESHOLD_HI_DFLT,
957         },
958 };
959
960 static int mx_of_dt(struct mx_state *st, struct device_node *dn)
961 {
962         unsigned int i;
963         int ret;
964
965         for (i = 0; i < MX_DEV_N; i++)
966                 memcpy(&st->cfg[i], &mx_cfg_dflt[i], sizeof(st->cfg[0]));
967         st->light.cfg = &st->cfg[MX_DEV_LIGHT];
968         st->prox.cfg = &st->cfg[MX_DEV_PROX];
969         /* default device specific parameters */
970         st->amb_cfg = MX_AMB_CFG_DFLT;
971         st->prx_cfg = MX_PRX_CFG_DFLT;
972         /* device tree parameters */
973         if (dn) {
974                 /* common NVS parameters */
975                 for (i = 0; i < MX_DEV_N; i++) {
976                         ret = nvs_of_dt(dn, &st->cfg[i], NULL);
977                         if (ret == -ENODEV)
978                                 /* the entire device has been disabled */
979                                 return -ENODEV;
980                 }
981
982                 /* device specific parameters */
983                 of_property_read_u8(dn, "ambient_cfg_reg", &st->amb_cfg);
984                 of_property_read_u8(dn, "proximity_cfg_reg", &st->prx_cfg);
985                 of_property_read_u8(dn, "threshold_persist_reg", &st->thr_cfg);
986         }
987         /* this device supports these programmable parameters */
988         if (nvs_light_of_dt(&st->light, dn, NULL)) {
989                 st->light.nld_i_lo = 0;
990                 st->light.nld_i_hi = ARRAY_SIZE(mx_nld_tbl_44005) - 1;
991         }
992         return 0;
993 }
994
995 static int mx_probe(struct i2c_client *client, const struct i2c_device_id *id)
996 {
997         struct mx_state *st;
998         unsigned long irqflags;
999         unsigned int n;
1000         unsigned int i;
1001         int ret;
1002
1003         dev_info(&client->dev, "%s\n", __func__);
1004         st = devm_kzalloc(&client->dev, sizeof(*st), GFP_KERNEL);
1005         if (st == NULL) {
1006                 dev_err(&client->dev, "%s devm_kzalloc ERR\n", __func__);
1007                 return -ENOMEM;
1008         }
1009
1010         i2c_set_clientdata(client, st);
1011         st->i2c = client;
1012         ret = mx_of_dt(st, client->dev.of_node);
1013         if (ret) {
1014                 if (ret == -ENODEV) {
1015                         dev_info(&client->dev, "%s DT disabled\n", __func__);
1016                 } else {
1017                         dev_err(&client->dev, "%s _of_dt ERR\n", __func__);
1018                         ret = -ENODEV;
1019                 }
1020                 goto mx_probe_exit;
1021         }
1022
1023         mx_pm_init(st);
1024         ret = mx_id_i2c(st, id->name);
1025         if (ret) {
1026                 dev_err(&client->dev, "%s _id_i2c ERR\n", __func__);
1027                 ret = -ENODEV;
1028                 goto mx_probe_exit;
1029         }
1030
1031         mx_pm(st, false);
1032         mx_fn_dev.sts = &st->sts;
1033         mx_fn_dev.errs = &st->errs;
1034         st->nvs = nvs_iio();
1035         if (st->nvs == NULL) {
1036                 ret = -ENODEV;
1037                 goto mx_probe_exit;
1038         }
1039
1040         st->light.handler = st->nvs->handler;
1041         st->prox.handler = st->nvs->handler;
1042         n = 0;
1043         for (i = 0; i < MX_DEV_N; i++) {
1044                 if (st->dev_id != MX_DEVID_MAX44005) {
1045                         if (st->cfg[i].snsr_id == MX_DEV_PROX) {
1046                                 st->cfg[i].snsr_id = -1;
1047                                 continue;
1048                         }
1049                 }
1050
1051                 ret = st->nvs->probe(&st->nvs_st[i], st, &client->dev,
1052                                      &mx_fn_dev, &st->cfg[i]);
1053                 if (!ret)
1054                         n++;
1055         }
1056         if (!n) {
1057                 dev_err(&client->dev, "%s nvs_probe ERR\n", __func__);
1058                 ret = -ENODEV;
1059                 goto mx_probe_exit;
1060         }
1061
1062         st->light.nvs_st = st->nvs_st[MX_DEV_LIGHT];
1063         st->prox.nvs_st = st->nvs_st[MX_DEV_PROX];
1064         INIT_DELAYED_WORK(&st->dw, mx_work);
1065         if (client->irq) {
1066                 irqflags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
1067                 for (i = 0; i < MX_DEV_N; i++) {
1068                         if (st->cfg[i].snsr_id >= 0) {
1069                                 if (st->cfg[i].flags & SENSOR_FLAG_WAKE_UP)
1070                                         irqflags |= IRQF_NO_SUSPEND;
1071                         }
1072                 }
1073                 ret = request_threaded_irq(client->irq, NULL, mx_irq_thread,
1074                                            irqflags, MX_NAME, st);
1075                 if (ret) {
1076                         dev_err(&client->dev, "%s req_threaded_irq ERR %d\n",
1077                                 __func__, ret);
1078                         ret = -ENOMEM;
1079                         goto mx_probe_exit;
1080                 }
1081         }
1082
1083         dev_info(&client->dev, "%s done\n", __func__);
1084         return 0;
1085
1086 mx_probe_exit:
1087         mx_remove(client);
1088         return ret;
1089 }
1090
1091 static const struct i2c_device_id mx_i2c_device_id[] = {
1092         { MX_NAME, 0 },
1093         { MX_NAME_MAX44005, 0 },
1094         { MX_NAME_MAX44006, 0 },
1095         { MX_NAME_MAX44008, 0 },
1096         {}
1097 };
1098
1099 MODULE_DEVICE_TABLE(i2c, mx_i2c_device_id);
1100
1101 static const struct of_device_id mx_of_match[] = {
1102         { .compatible = "maxim,max4400x", },
1103         { .compatible = "maxim,max44005", },
1104         { .compatible = "maxim,max44006", },
1105         { .compatible = "maxim,max44008", },
1106         {},
1107 };
1108
1109 MODULE_DEVICE_TABLE(of, mx_of_match);
1110
1111 static struct i2c_driver mx_driver = {
1112         .class          = I2C_CLASS_HWMON,
1113         .probe          = mx_probe,
1114         .remove         = mx_remove,
1115         .shutdown       = mx_shutdown,
1116         .driver = {
1117                 .name           = MX_NAME,
1118                 .owner          = THIS_MODULE,
1119                 .of_match_table = of_match_ptr(mx_of_match),
1120                 .pm             = &mx_pm_ops,
1121         },
1122         .id_table       = mx_i2c_device_id,
1123 };
1124 module_i2c_driver(mx_driver);
1125
1126 MODULE_LICENSE("GPL");
1127 MODULE_DESCRIPTION("MAX4400x driver");
1128 MODULE_AUTHOR("NVIDIA Corporation");