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