regulator: max77663: register all regulators in single probe
[linux-3.10.git] / drivers / mfd / max77663-core.c
1 /*
2  * drivers/mfd/max77663-core.c
3  * Max77663 mfd driver (I2C bus access)
4  *
5  * Copyright 2011 Maxim Integrated Products, Inc.
6  * Copyright (C) 2011-2012 NVIDIA Corporation
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of the
11  * License, or (at your option) any later version.
12  *
13  */
14
15 #include <linux/interrupt.h>
16 #include <linux/i2c.h>
17 #include <linux/slab.h>
18 #include <linux/ratelimit.h>
19 #include <linux/kthread.h>
20 #include <linux/mfd/core.h>
21 #include <linux/platform_device.h>
22 #include <linux/regmap.h>
23 #include <linux/seq_file.h>
24 #include <linux/debugfs.h>
25 #include <linux/delay.h>
26 #include <linux/uaccess.h>
27 #include <linux/module.h>
28
29 #include <linux/mfd/max77663-core.h>
30
31 /* RTC i2c slave address */
32 #define MAX77663_RTC_I2C_ADDR           0x48
33
34 /* Registers */
35 #define MAX77663_REG_IRQ_TOP            0x05
36 #define MAX77663_REG_LBT_IRQ            0x06
37 #define MAX77663_REG_SD_IRQ             0x07
38 #define MAX77663_REG_LDOX_IRQ           0x08
39 #define MAX77663_REG_LDO8_IRQ           0x09
40 #define MAX77663_REG_GPIO_IRQ           0x0A
41 #define MAX77663_REG_ONOFF_IRQ          0x0B
42 #define MAX77663_REG_NVER               0x0C
43 #define MAX77663_REG_IRQ_TOP_MASK       0x0D
44 #define MAX77663_REG_LBT_IRQ_MASK       0x0E
45 #define MAX77663_REG_SD_IRQ_MASK        0x0F
46 #define MAX77663_REG_LDOX_IRQ_MASK      0x10
47 #define MAX77663_REG_LDO8_IRQ_MASK      0x11
48 #define MAX77663_REG_ONOFF_IRQ_MASK     0x12
49 #define MAX77663_REG_GPIO_CTRL0         0x36
50 #define MAX77663_REG_GPIO_CTRL1         0x37
51 #define MAX77663_REG_GPIO_CTRL2         0x38
52 #define MAX77663_REG_GPIO_CTRL3         0x39
53 #define MAX77663_REG_GPIO_CTRL4         0x3A
54 #define MAX77663_REG_GPIO_CTRL5         0x3B
55 #define MAX77663_REG_GPIO_CTRL6         0x3C
56 #define MAX77663_REG_GPIO_CTRL7         0x3D
57 #define MAX77663_REG_GPIO_PU            0x3E
58 #define MAX77663_REG_GPIO_PD            0x3F
59 #define MAX77663_REG_GPIO_ALT           0x40
60 #define MAX77663_REG_ONOFF_CFG1         0x41
61 #define MAX77663_REG_ONOFF_CFG2         0x42
62 #define MAX77663_REG_CID5                       0x5D
63
64 #define IRQ_TOP_GLBL_MASK               (1 << 7)
65 #define IRQ_TOP_GLBL_SHIFT              7
66 #define IRQ_TOP_SD_MASK                 (1 << 6)
67 #define IRQ_TOP_SD_SHIFT                6
68 #define IRQ_TOP_LDO_MASK                (1 << 5)
69 #define IRQ_TOP_LDO_SHIFT               5
70 #define IRQ_TOP_GPIO_MASK               (1 << 4)
71 #define IRQ_TOP_GPIO_SHIFT              4
72 #define IRQ_TOP_RTC_MASK                (1 << 3)
73 #define IRQ_TOP_RTC_SHIFT               3
74 #define IRQ_TOP_32K_MASK                (1 << 2)
75 #define IRQ_TOP_32K_SHIFT               2
76 #define IRQ_TOP_ONOFF_MASK              (1 << 1)
77 #define IRQ_TOP_ONOFF_SHIFT             1
78 #define IRQ_TOP_NVER_MASK               (1 << 0)
79 #define IRQ_TOP_NVER_SHIFT              0
80
81 #define IRQ_GLBL_MASK                   (1 << 0)
82
83 #define IRQ_LBT_BASE                    MAX77663_IRQ_LBT_LB
84 #define IRQ_LBT_END                     MAX77663_IRQ_LBT_THERM_ALRM2
85
86 #define IRQ_GPIO_BASE                   MAX77663_IRQ_GPIO0
87 #define IRQ_GPIO_END                    MAX77663_IRQ_GPIO7
88
89 #define IRQ_ONOFF_BASE                  MAX77663_IRQ_ONOFF_HRDPOWRN
90 #define IRQ_ONOFF_END                   MAX77663_IRQ_ONOFF_ACOK_RISING
91
92 #define GPIO_REG_ADDR(offset)           (MAX77663_REG_GPIO_CTRL0 + offset)
93
94 #define GPIO_CTRL_DBNC_MASK             (3 << 6)
95 #define GPIO_CTRL_DBNC_SHIFT            6
96 #define GPIO_CTRL_REFE_IRQ_MASK         (3 << 4)
97 #define GPIO_CTRL_REFE_IRQ_SHIFT        4
98 #define GPIO_CTRL_DOUT_MASK             (1 << 3)
99 #define GPIO_CTRL_DOUT_SHIFT            3
100 #define GPIO_CTRL_DIN_MASK              (1 << 2)
101 #define GPIO_CTRL_DIN_SHIFT             2
102 #define GPIO_CTRL_DIR_MASK              (1 << 1)
103 #define GPIO_CTRL_DIR_SHIFT             1
104 #define GPIO_CTRL_OUT_DRV_MASK          (1 << 0)
105 #define GPIO_CTRL_OUT_DRV_SHIFT         0
106
107 #define GPIO_REFE_IRQ_NONE              0
108 #define GPIO_REFE_IRQ_EDGE_FALLING      1
109 #define GPIO_REFE_IRQ_EDGE_RISING       2
110 #define GPIO_REFE_IRQ_EDGE_BOTH         3
111
112 #define GPIO_DBNC_NONE                  0
113 #define GPIO_DBNC_8MS                   1
114 #define GPIO_DBNC_16MS                  2
115 #define GPIO_DBNC_32MS                  3
116
117 #define ONOFF_SFT_RST_MASK              (1 << 7)
118 #define ONOFF_SLPEN_MASK                (1 << 2)
119 #define ONOFF_PWR_OFF_MASK              (1 << 1)
120
121 #define ONOFF_SLP_LPM_MASK              (1 << 5)
122
123 #define ONOFF_IRQ_EN0_RISING            (1 << 3)
124
125 enum {
126         CACHE_IRQ_LBT,
127         CACHE_IRQ_SD,
128         CACHE_IRQ_LDO,
129         CACHE_IRQ_ONOFF,
130         CACHE_IRQ_NR,
131 };
132
133 struct max77663_irq_data {
134         int mask_reg;
135         u16 mask;
136         u8 top_mask;
137         u8 top_shift;
138         int cache_idx;
139         bool is_rtc;
140         bool is_unmask;
141         u8 trigger_type;
142 };
143
144 struct max77663_chip {
145         struct device *dev;
146         struct i2c_client *i2c_power;
147         struct i2c_client *i2c_rtc;
148         struct regmap *regmap_power;
149         struct regmap *regmap_rtc;
150
151         struct max77663_platform_data *pdata;
152         struct mutex io_lock;
153
154         struct irq_chip irq;
155         struct mutex irq_lock;
156         int irq_base;
157         int irq_top_count[8];
158         u8 cache_irq_top_mask;
159         u16 cache_irq_mask[CACHE_IRQ_NR];
160
161         u8 rtc_i2c_addr;
162 };
163
164 struct max77663_chip *max77663_chip;
165
166 static struct resource gpio_resources[] = {
167         {
168                 .start  = MAX77663_IRQ_INT_TOP_GPIO,
169                 .end    = MAX77663_IRQ_INT_TOP_GPIO,
170                 .flags  = IORESOURCE_IRQ,
171         }
172 };
173
174 static struct resource rtc_resources[] = {
175         {
176                 .start  = MAX77663_IRQ_RTC,
177                 .end    = MAX77663_IRQ_RTC,
178                 .flags  = IORESOURCE_IRQ,
179         }
180 };
181
182 static struct mfd_cell max77663_cells[] = {
183         {
184                 .name = "max77663-gpio",
185                 .num_resources  = ARRAY_SIZE(gpio_resources),
186                 .resources      = &gpio_resources[0],
187         }, {
188                 .name = "max77663-pmic",
189         }, {
190                 .name = "max77663-rtc",
191                 .num_resources  = ARRAY_SIZE(rtc_resources),
192                 .resources      = &rtc_resources[0],
193         },
194 };
195
196 #define IRQ_DATA_LBT(_name, _shift)                     \
197         [MAX77663_IRQ_LBT_##_name] = {                  \
198                 .mask_reg = MAX77663_REG_LBT_IRQ_MASK,  \
199                 .mask = (1 << _shift),                  \
200                 .top_mask = IRQ_TOP_GLBL_MASK,          \
201                 .top_shift = IRQ_TOP_GLBL_SHIFT,        \
202                 .cache_idx = CACHE_IRQ_LBT,             \
203         }
204
205 #define IRQ_DATA_GPIO_TOP()                             \
206         [MAX77663_IRQ_INT_TOP_GPIO] = {                 \
207                 .top_mask = IRQ_TOP_GPIO_MASK,          \
208                 .top_shift = IRQ_TOP_GPIO_SHIFT,        \
209                 .cache_idx = -1,                        \
210         }
211
212 #define IRQ_DATA_ONOFF(_name, _shift)                   \
213         [MAX77663_IRQ_ONOFF_##_name] = {                \
214                 .mask_reg = MAX77663_REG_ONOFF_IRQ_MASK,\
215                 .mask = (1 << _shift),                  \
216                 .top_mask = IRQ_TOP_ONOFF_MASK,         \
217                 .top_shift = IRQ_TOP_ONOFF_SHIFT,       \
218                 .cache_idx = CACHE_IRQ_ONOFF,           \
219         }
220
221 static struct max77663_irq_data max77663_irqs[MAX77663_IRQ_NR] = {
222         IRQ_DATA_GPIO_TOP(),
223         IRQ_DATA_LBT(LB, 3),
224         IRQ_DATA_LBT(THERM_ALRM1, 2),
225         IRQ_DATA_LBT(THERM_ALRM2, 1),
226         IRQ_DATA_ONOFF(HRDPOWRN,     0),
227         IRQ_DATA_ONOFF(EN0_1SEC,     1),
228         IRQ_DATA_ONOFF(EN0_FALLING,  2),
229         IRQ_DATA_ONOFF(EN0_RISING,   3),
230         IRQ_DATA_ONOFF(LID_FALLING,  4),
231         IRQ_DATA_ONOFF(LID_RISING,   5),
232         IRQ_DATA_ONOFF(ACOK_FALLING, 6),
233         IRQ_DATA_ONOFF(ACOK_RISING,  7),
234         [MAX77663_IRQ_RTC] = {
235                 .top_mask = IRQ_TOP_RTC_MASK,
236                 .top_shift = IRQ_TOP_RTC_SHIFT,
237                 .cache_idx = -1,
238                 .is_rtc = 1,
239         },
240         [MAX77663_IRQ_SD_PF] = {
241                 .mask_reg = MAX77663_REG_SD_IRQ_MASK,
242                 .mask = 0xF8,
243                 .top_mask = IRQ_TOP_SD_MASK,
244                 .top_shift = IRQ_TOP_SD_SHIFT,
245                 .cache_idx = CACHE_IRQ_SD,
246         },
247         [MAX77663_IRQ_LDO_PF] = {
248                 .mask_reg = MAX77663_REG_LDOX_IRQ_MASK,
249                 .mask = 0x1FF,
250                 .top_mask = IRQ_TOP_LDO_MASK,
251                 .top_shift = IRQ_TOP_LDO_SHIFT,
252                 .cache_idx = CACHE_IRQ_LDO,
253         },
254         [MAX77663_IRQ_32K] = {
255                 .top_mask = IRQ_TOP_32K_MASK,
256                 .top_shift = IRQ_TOP_32K_SHIFT,
257                 .cache_idx = -1,
258         },
259         [MAX77663_IRQ_NVER] = {
260                 .top_mask = IRQ_TOP_NVER_MASK,
261                 .top_shift = IRQ_TOP_NVER_SHIFT,
262                 .cache_idx = -1,
263         },
264 };
265
266 /* MAX77663 PMU doesn't allow PWR_OFF and SFT_RST setting in ONOFF_CFG1
267  * at the same time. So if it try to set PWR_OFF and SFT_RST to ONOFF_CFG1
268  * simultaneously, handle only SFT_RST and ignore PWR_OFF.
269  */
270 #define CHECK_ONOFF_CFG1_MASK   (ONOFF_SFT_RST_MASK | ONOFF_PWR_OFF_MASK)
271 #define CHECK_ONOFF_CFG1(_addr, _val)                   \
272         unlikely((_addr == MAX77663_REG_ONOFF_CFG1) &&  \
273                  ((_val & CHECK_ONOFF_CFG1_MASK) == CHECK_ONOFF_CFG1_MASK))
274
275 static inline int max77663_i2c_write(struct max77663_chip *chip, u8 addr,
276                                      void *src, u32 bytes, bool is_rtc)
277 {
278         int ret = 0;
279
280         dev_dbg(chip->dev, "i2c_write: addr=0x%02x, src=0x%02x, bytes=%u\n",
281                 addr, *((u8 *)src), bytes);
282
283         if (is_rtc) {
284                 /* RTC registers support sequential writing */
285                 ret = regmap_bulk_write(chip->regmap_rtc, addr, src, bytes);
286         } else {
287                 /* Power registers support register-data pair writing */
288                 u8 *src8 = (u8 *)src;
289                 unsigned int val;
290                 int i;
291
292                 for (i = 0; i < bytes; i++) {
293                         if (CHECK_ONOFF_CFG1(addr, *src8))
294                                 val = *src8++ & ~ONOFF_PWR_OFF_MASK;
295                         else
296                                 val = *src8++;
297                         ret = regmap_write(chip->regmap_power, addr, val);
298                         if (ret < 0)
299                                 break;
300                         addr++;
301                 }
302         }
303         if (ret < 0)
304                 dev_err(chip->dev, "%s() failed, e %d\n", __func__, ret);
305         return ret;
306 }
307
308 static inline int max77663_i2c_read(struct max77663_chip *chip, u8 addr,
309                                     void *dest, u32 bytes, bool is_rtc)
310 {
311         int ret = 0;
312         struct regmap *regmap = chip->regmap_power;
313
314         if (is_rtc)
315                 regmap = chip->regmap_rtc;
316         ret = regmap_bulk_read(regmap, addr, dest, bytes);
317         if (ret < 0) {
318                 dev_err(chip->dev, "%s() failed, e %d\n", __func__, ret);
319                 return ret;
320         }
321
322         dev_dbg(chip->dev, "i2c_read: addr=0x%02x, dest=0x%02x, bytes=%u\n",
323                 addr, *((u8 *)dest), bytes);
324         return ret;
325 }
326
327 int max77663_read(struct device *dev, u8 addr, void *values, u32 len,
328                   bool is_rtc)
329 {
330         struct max77663_chip *chip = dev_get_drvdata(dev);
331         int ret;
332
333         mutex_lock(&chip->io_lock);
334         ret = max77663_i2c_read(chip, addr, values, len, is_rtc);
335         mutex_unlock(&chip->io_lock);
336         return ret;
337 }
338 EXPORT_SYMBOL(max77663_read);
339
340 int max77663_write(struct device *dev, u8 addr, void *values, u32 len,
341                    bool is_rtc)
342 {
343         struct max77663_chip *chip = dev_get_drvdata(dev);
344         int ret;
345
346         mutex_lock(&chip->io_lock);
347         ret = max77663_i2c_write(chip, addr, values, len, is_rtc);
348         mutex_unlock(&chip->io_lock);
349         return ret;
350 }
351 EXPORT_SYMBOL(max77663_write);
352
353 int max77663_set_bits(struct device *dev, u8 addr, u8 mask, u8 value,
354                       bool is_rtc)
355 {
356         struct max77663_chip *chip = dev_get_drvdata(dev);
357         int ret;
358         struct regmap *regmap = chip->regmap_power;
359
360         if (is_rtc)
361                 regmap = chip->regmap_rtc;
362
363         mutex_lock(&chip->io_lock);
364         ret = regmap_update_bits(regmap, addr, mask, value);
365         mutex_unlock(&chip->io_lock);
366         return ret;
367 }
368 EXPORT_SYMBOL(max77663_set_bits);
369
370 static void max77663_power_off(void)
371 {
372         struct max77663_chip *chip = max77663_chip;
373
374         if (!chip)
375                 return;
376
377         dev_info(chip->dev, "%s: Global shutdown\n", __func__);
378         max77663_set_bits(chip->dev, MAX77663_REG_ONOFF_CFG1,
379                           ONOFF_SFT_RST_MASK, ONOFF_SFT_RST_MASK, 0);
380 }
381
382 static int max77663_sleep(struct max77663_chip *chip, bool on)
383 {
384         int ret = 0;
385
386         if (chip->pdata->flags & SLP_LPM_ENABLE) {
387                 /* Put the power rails into Low-Power mode during sleep mode,
388                  * if the power rail's power mode is GLPM. */
389                 ret = max77663_set_bits(chip->dev, MAX77663_REG_ONOFF_CFG2,
390                                         ONOFF_SLP_LPM_MASK,
391                                         on ? ONOFF_SLP_LPM_MASK : 0, 0);
392                 if (ret < 0)
393                         return ret;
394         }
395
396         /* Enable sleep that AP can be placed into sleep mode
397          * by pulling EN1 low */
398         return max77663_set_bits(chip->dev, MAX77663_REG_ONOFF_CFG1,
399                                  ONOFF_SLPEN_MASK,
400                                  on ? ONOFF_SLPEN_MASK : 0, 0);
401 }
402
403 static inline int max77663_cache_write(struct device *dev, u8 addr, u8 mask,
404                                        u8 val, u8 *cache)
405 {
406         u8 new_val;
407         int ret;
408
409         new_val = (*cache & ~mask) | (val & mask);
410         if (*cache != new_val) {
411                 ret = max77663_write(dev, addr, &new_val, 1, 0);
412                 if (ret < 0)
413                         return ret;
414                 *cache = new_val;
415         }
416         return 0;
417 }
418
419 static void max77663_irq_mask(struct irq_data *data)
420 {
421         struct max77663_chip *chip = irq_data_get_irq_chip_data(data);
422
423         max77663_irqs[data->irq - chip->irq_base].is_unmask = 0;
424 }
425
426 static void max77663_irq_unmask(struct irq_data *data)
427 {
428         struct max77663_chip *chip = irq_data_get_irq_chip_data(data);
429
430         max77663_irqs[data->irq - chip->irq_base].is_unmask = 1;
431 }
432
433 static void max77663_irq_lock(struct irq_data *data)
434 {
435         struct max77663_chip *chip = irq_data_get_irq_chip_data(data);
436
437         mutex_lock(&chip->irq_lock);
438 }
439
440 static void max77663_irq_sync_unlock(struct irq_data *data)
441 {
442         struct max77663_chip *chip = irq_data_get_irq_chip_data(data);
443         struct max77663_irq_data *irq_data =
444                         &max77663_irqs[data->irq - chip->irq_base];
445         int idx = irq_data->cache_idx;
446         u8 irq_top_mask = chip->cache_irq_top_mask;
447         u16 irq_mask = chip->cache_irq_mask[idx];
448         int update_irq_top = 0;
449         u32 len = 1;
450         int ret;
451
452         if (irq_data->is_unmask) {
453                 if (chip->irq_top_count[irq_data->top_shift] == 0)
454                         update_irq_top = 1;
455                 chip->irq_top_count[irq_data->top_shift]++;
456
457                 if (irq_data->top_mask != IRQ_TOP_GLBL_MASK)
458                         irq_top_mask &= ~irq_data->top_mask;
459
460                 if (idx != -1)
461                         irq_mask &= ~irq_data->mask;
462         } else {
463                 if (chip->irq_top_count[irq_data->top_shift] == 1)
464                         update_irq_top = 1;
465
466                 if (--chip->irq_top_count[irq_data->top_shift] < 0)
467                         chip->irq_top_count[irq_data->top_shift] = 0;
468
469                 if (irq_data->top_mask != IRQ_TOP_GLBL_MASK)
470                         irq_top_mask |= irq_data->top_mask;
471
472                 if (idx != -1)
473                         irq_mask |= irq_data->mask;
474         }
475
476         if ((idx != -1) && (irq_mask != chip->cache_irq_mask[idx])) {
477                 if (irq_data->top_mask == IRQ_TOP_LDO_MASK)
478                         len = 2;
479
480                 ret = max77663_write(chip->dev, irq_data->mask_reg,
481                                      &irq_mask, len, irq_data->is_rtc);
482                 if (ret < 0)
483                         goto out;
484
485                 chip->cache_irq_mask[idx] = irq_mask;
486         }
487
488         if (update_irq_top && (irq_top_mask != chip->cache_irq_top_mask)) {
489                 ret = max77663_cache_write(chip->dev, MAX77663_REG_IRQ_TOP_MASK,
490                                            irq_data->top_mask, irq_top_mask,
491                                            &chip->cache_irq_top_mask);
492                 if (ret < 0)
493                         goto out;
494         }
495
496 out:
497         mutex_unlock(&chip->irq_lock);
498 }
499
500 static inline int max77663_do_irq(struct max77663_chip *chip, u8 addr,
501                                   int irq_base, int irq_end)
502 {
503         struct max77663_irq_data *irq_data = NULL;
504         int irqs_to_handle[irq_end - irq_base + 1];
505         int handled = 0;
506         u16 val;
507         u32 len = 1;
508         int i;
509         int ret;
510
511         ret = max77663_read(chip->dev, addr, &val, len, 0);
512         if (ret < 0)
513                 return ret;
514
515         for (i = irq_base; i <= irq_end; i++) {
516                 irq_data = &max77663_irqs[i];
517                 if (val & irq_data->mask) {
518                         irqs_to_handle[handled] = i + chip->irq_base;
519                         handled++;
520                 }
521         }
522
523         for (i = 0; i < handled; i++)
524                 handle_nested_irq(irqs_to_handle[i]);
525
526         return 0;
527 }
528
529 static irqreturn_t max77663_irq(int irq, void *data)
530 {
531         struct max77663_chip *chip = data;
532         u8 irq_top;
533         int ret;
534
535         ret = max77663_read(chip->dev, MAX77663_REG_IRQ_TOP, &irq_top, 1, 0);
536         if (ret < 0) {
537                 dev_err(chip->dev, "irq: Failed to get irq top status\n");
538                 return IRQ_NONE;
539         }
540
541         if (irq_top & IRQ_TOP_GLBL_MASK) {
542                 ret = max77663_do_irq(chip, MAX77663_REG_LBT_IRQ, IRQ_LBT_BASE,
543                                       IRQ_LBT_END);
544                 if (ret < 0)
545                         return IRQ_NONE;
546         }
547
548         if (irq_top & IRQ_TOP_GPIO_MASK)
549                 handle_nested_irq(MAX77663_IRQ_INT_TOP_GPIO + chip->irq_base);
550
551         if (irq_top & IRQ_TOP_ONOFF_MASK) {
552                 ret = max77663_do_irq(chip, MAX77663_REG_ONOFF_IRQ,
553                                       IRQ_ONOFF_BASE, IRQ_ONOFF_END);
554                 if (ret < 0)
555                         return IRQ_NONE;
556         }
557
558         if (irq_top & IRQ_TOP_RTC_MASK)
559                 handle_nested_irq(MAX77663_IRQ_RTC + chip->irq_base);
560
561         if (irq_top & IRQ_TOP_SD_MASK)
562                 handle_nested_irq(MAX77663_IRQ_SD_PF + chip->irq_base);
563
564         if (irq_top & IRQ_TOP_LDO_MASK)
565                 handle_nested_irq(MAX77663_IRQ_LDO_PF + chip->irq_base);
566
567         if (irq_top & IRQ_TOP_32K_MASK)
568                 handle_nested_irq(MAX77663_IRQ_32K + chip->irq_base);
569
570         if (irq_top & IRQ_TOP_NVER_MASK)
571                 handle_nested_irq(MAX77663_IRQ_NVER + chip->irq_base);
572
573         return IRQ_HANDLED;
574 }
575
576 static struct irq_chip max77663_irq_chip = {
577         .name = "max77663-irq",
578         .irq_mask = max77663_irq_mask,
579         .irq_unmask = max77663_irq_unmask,
580         .irq_bus_lock = max77663_irq_lock,
581         .irq_bus_sync_unlock = max77663_irq_sync_unlock,
582 };
583
584 static int max77663_irq_init(struct max77663_chip *chip)
585 {
586         u32 temp;
587         int i, ret = 0;
588
589         mutex_init(&chip->irq_lock);
590
591         /* Mask all interrupts */
592         chip->cache_irq_top_mask = 0xFF;
593         chip->cache_irq_mask[CACHE_IRQ_LBT] = 0x0F;
594         chip->cache_irq_mask[CACHE_IRQ_SD] = 0xFF;
595         chip->cache_irq_mask[CACHE_IRQ_LDO] = 0xFFFF;
596         chip->cache_irq_mask[CACHE_IRQ_ONOFF] = 0xFF;
597
598         max77663_write(chip->dev, MAX77663_REG_IRQ_TOP_MASK,
599                        &chip->cache_irq_top_mask, 1, 0);
600         max77663_write(chip->dev, MAX77663_REG_LBT_IRQ_MASK,
601                        &chip->cache_irq_mask[CACHE_IRQ_LBT], 1, 0);
602         max77663_write(chip->dev, MAX77663_REG_SD_IRQ_MASK,
603                        &chip->cache_irq_mask[CACHE_IRQ_SD], 1, 0);
604         max77663_write(chip->dev, MAX77663_REG_LDOX_IRQ_MASK,
605                        &chip->cache_irq_mask[CACHE_IRQ_LDO], 2, 0);
606         max77663_write(chip->dev, MAX77663_REG_ONOFF_IRQ_MASK,
607                        &chip->cache_irq_mask[CACHE_IRQ_ONOFF], 1, 0);
608
609         /* Clear all interrups */
610         max77663_read(chip->dev, MAX77663_REG_LBT_IRQ, &temp, 1, 0);
611         max77663_read(chip->dev, MAX77663_REG_SD_IRQ, &temp, 1, 0);
612         max77663_read(chip->dev, MAX77663_REG_LDOX_IRQ, &temp, 2, 0);
613         //max77663_read(chip->dev, MAX77663_REG_GPIO_IRQ, &temp, 1, 0);
614         max77663_read(chip->dev, MAX77663_REG_ONOFF_IRQ, &temp, 1, 0);
615
616         for (i = chip->irq_base; i < (MAX77663_IRQ_NR + chip->irq_base); i++) {
617                 int irq = i - chip->irq_base;
618                 if (i >= NR_IRQS) {
619                         dev_err(chip->dev,
620                                 "irq_init: Can't set irq chip for irq %d\n", i);
621                         continue;
622                 }
623                 if ((irq >= MAX77663_IRQ_GPIO0) && (irq <= MAX77663_IRQ_GPIO7))
624                         continue;
625
626                 irq_set_chip_data(i, chip);
627
628                 irq_set_chip_and_handler(i, &max77663_irq_chip, handle_edge_irq);
629 #ifdef CONFIG_ARM
630                 set_irq_flags(i, IRQF_VALID);
631 #else
632                 irq_set_noprobe(i);
633 #endif
634                 irq_set_nested_thread(i, 1);
635         }
636
637         ret = request_threaded_irq(chip->i2c_power->irq, NULL, max77663_irq,
638                                    IRQF_ONESHOT, "max77663", chip);
639         if (ret) {
640                 dev_err(chip->dev, "irq_init: Failed to request irq %d\n",
641                         chip->i2c_power->irq);
642                 return ret;
643         }
644
645         device_init_wakeup(chip->dev, 1);
646         enable_irq_wake(chip->i2c_power->irq);
647
648         chip->cache_irq_top_mask &= ~IRQ_TOP_GLBL_MASK;
649         max77663_write(chip->dev, MAX77663_REG_IRQ_TOP_MASK,
650                        &chip->cache_irq_top_mask, 1, 0);
651
652         chip->cache_irq_mask[CACHE_IRQ_LBT] &= ~IRQ_GLBL_MASK;
653         max77663_write(chip->dev, MAX77663_REG_LBT_IRQ_MASK,
654                        &chip->cache_irq_mask[CACHE_IRQ_LBT], 1, 0);
655
656         chip->cache_irq_mask[CACHE_IRQ_ONOFF] &= ~ONOFF_IRQ_EN0_RISING;
657         max77663_write(chip->dev, MAX77663_REG_ONOFF_IRQ_MASK,
658                        &chip->cache_irq_mask[CACHE_IRQ_ONOFF], 1, 0);
659
660         return 0;
661 }
662
663 static void max77663_irq_exit(struct max77663_chip *chip)
664 {
665         if (chip->i2c_power->irq)
666                 free_irq(chip->i2c_power->irq, chip);
667 }
668
669 #ifdef CONFIG_DEBUG_FS
670 static struct dentry *max77663_dentry_regs;
671
672 static int max77663_debugfs_dump_regs(struct max77663_chip *chip, char *label,
673                                       u8 *addrs, int num_addrs, char *buf,
674                                       ssize_t *len, int is_rtc)
675 {
676         ssize_t count = *len;
677         u8 val;
678         int ret = 0;
679         int i;
680
681         count += sprintf(buf + count, "%s\n", label);
682         if (count >= PAGE_SIZE - 1)
683                 return -ERANGE;
684
685         for (i = 0; i < num_addrs; i++) {
686                 count += sprintf(buf + count, "0x%02x: ", addrs[i]);
687                 if (count >= PAGE_SIZE - 1)
688                         return -ERANGE;
689
690                 ret = max77663_read(chip->dev, addrs[i], &val, 1, is_rtc);
691                 if (ret == 0)
692                         count += sprintf(buf + count, "0x%02x\n", val);
693                 else
694                         count += sprintf(buf + count, "<read fail: %d>\n", ret);
695
696                 if (count >= PAGE_SIZE - 1)
697                         return -ERANGE;
698         }
699
700         *len = count;
701         return 0;
702 }
703
704 static int max77663_debugfs_regs_open(struct inode *inode, struct file *file)
705 {
706         file->private_data = inode->i_private;
707         return 0;
708 }
709
710 static ssize_t max77663_debugfs_regs_read(struct file *file,
711                                           char __user *user_buf,
712                                           size_t count, loff_t *ppos)
713 {
714         struct max77663_chip *chip = file->private_data;
715         char *buf;
716         size_t len = 0;
717         ssize_t ret;
718
719         /* Excluded interrupt status register to prevent register clear */
720         u8 global_regs[] = { 0x00, 0x01, 0x02, 0x05, 0x0D, 0x0E, 0x13 };
721         u8 sd_regs[] = {
722                 0x07, 0x0F, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
723                 0x1E, 0x1F, 0x20, 0x21, 0x22
724         };
725         u8 ldo_regs[] = {
726                 0x10, 0x11, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A,
727                 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34,
728                 0x35
729         };
730         u8 gpio_regs[] = {
731                 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
732                 0x40
733         };
734         u8 rtc_regs[] = {
735                 0x01, 0x02, 0x03, 0x04, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
736                 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
737                 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B
738         };
739         u8 osc_32k_regs[] = { 0x03 };
740         u8 bbc_regs[] = { 0x04 };
741         u8 onoff_regs[] = { 0x12, 0x15, 0x41, 0x42 };
742         u8 fps_regs[] = {
743                 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C,
744                 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
745                 0x57
746         };
747         u8 cid_regs[] = { 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D };
748
749         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
750         if (!buf)
751                 return -ENOMEM;
752
753         len += sprintf(buf + len, "MAX77663 Registers\n");
754         max77663_debugfs_dump_regs(chip, "[Global]", global_regs,
755                                    ARRAY_SIZE(global_regs), buf, &len, 0);
756         max77663_debugfs_dump_regs(chip, "[Step-Down]", sd_regs,
757                                    ARRAY_SIZE(sd_regs), buf, &len, 0);
758         max77663_debugfs_dump_regs(chip, "[LDO]", ldo_regs,
759                                    ARRAY_SIZE(ldo_regs), buf, &len, 0);
760         max77663_debugfs_dump_regs(chip, "[GPIO]", gpio_regs,
761                                    ARRAY_SIZE(gpio_regs), buf, &len, 0);
762         max77663_debugfs_dump_regs(chip, "[RTC]", rtc_regs,
763                                    ARRAY_SIZE(rtc_regs), buf, &len, 1);
764         max77663_debugfs_dump_regs(chip, "[32kHz Oscillator]", osc_32k_regs,
765                                    ARRAY_SIZE(osc_32k_regs), buf, &len, 0);
766         max77663_debugfs_dump_regs(chip, "[Backup Battery Charger]", bbc_regs,
767                                    ARRAY_SIZE(bbc_regs), buf, &len, 0);
768         max77663_debugfs_dump_regs(chip, "[On/OFF Controller]", onoff_regs,
769                                    ARRAY_SIZE(onoff_regs), buf, &len, 0);
770         max77663_debugfs_dump_regs(chip, "[Flexible Power Sequencer]", fps_regs,
771                                    ARRAY_SIZE(fps_regs), buf, &len, 0);
772         max77663_debugfs_dump_regs(chip, "[Chip Identification]", cid_regs,
773                                    ARRAY_SIZE(cid_regs), buf, &len, 0);
774
775         ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
776         kfree(buf);
777
778         return ret;
779 }
780
781 static const struct file_operations max77663_debugfs_regs_fops = {
782         .open = max77663_debugfs_regs_open,
783         .read = max77663_debugfs_regs_read,
784 };
785
786 static void max77663_debugfs_init(struct max77663_chip *chip)
787 {
788         max77663_dentry_regs = debugfs_create_file(chip->i2c_power->name,
789                                                    0444, 0, chip,
790                                                    &max77663_debugfs_regs_fops);
791         if (!max77663_dentry_regs)
792                 dev_warn(chip->dev,
793                          "debugfs_init: Failed to create debugfs file\n");
794 }
795
796 static void max77663_debugfs_exit(struct max77663_chip *chip)
797 {
798         debugfs_remove(max77663_dentry_regs);
799 }
800 #else
801 static inline void max77663_debugfs_init(struct max77663_chip *chip)
802 {
803 }
804
805 static inline void max77663_debugfs_exit(struct max77663_chip *chip)
806 {
807 }
808 #endif /* CONFIG_DEBUG_FS */
809
810 static bool rd_wr_reg_power(struct device *dev, unsigned int reg)
811 {
812         if (reg < 0x60)
813                 return true;
814
815         dev_err(dev, "non-existing reg %s() reg 0x%x\n", __func__, reg);
816         BUG();
817         return false;
818 }
819
820 static bool rd_wr_reg_rtc(struct device *dev, unsigned int reg)
821 {
822         if (reg < 0x1C)
823                 return true;
824
825         dev_err(dev, "non-existing reg %s() reg 0x%x\n", __func__, reg);
826         BUG();
827         return false;
828 }
829
830 static const struct regmap_config max77663_regmap_config_power = {
831         .reg_bits = 8,
832         .val_bits = 8,
833         .max_register = 0x60,
834         .writeable_reg = rd_wr_reg_power,
835         .readable_reg = rd_wr_reg_power,
836         .cache_type = REGCACHE_RBTREE,
837 };
838
839 static const struct regmap_config max77663_regmap_config_rtc = {
840         .reg_bits = 8,
841         .val_bits = 8,
842         .max_register = 0x1C,
843         .writeable_reg = rd_wr_reg_rtc,
844         .readable_reg = rd_wr_reg_rtc,
845         .cache_type = REGCACHE_RBTREE,
846 };
847
848 static int max77663_probe(struct i2c_client *client,
849                           const struct i2c_device_id *id)
850 {
851         struct max77663_platform_data *pdata = client->dev.platform_data;
852         struct max77663_chip *chip;
853         int ret = 0;
854         u8 val;
855
856         if (pdata == NULL) {
857                 dev_err(&client->dev, "probe: Invalid platform_data\n");
858                 return -ENODEV;
859         }
860
861         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
862         if (chip == NULL) {
863                 dev_err(&client->dev, "probe: kzalloc() failed\n");
864                 return -ENOMEM;
865         }
866         max77663_chip = chip;
867
868         chip->i2c_power = client;
869         i2c_set_clientdata(client, chip);
870
871         chip->regmap_power = devm_regmap_init_i2c(client,
872                                         &max77663_regmap_config_power);
873         if (IS_ERR(chip->regmap_power)) {
874                 ret = PTR_ERR(chip->regmap_power);
875                 dev_err(&client->dev, "power regmap init failed: %d\n", ret);
876                 return ret;
877         }
878
879         if (pdata->rtc_i2c_addr)
880                 chip->rtc_i2c_addr = pdata->rtc_i2c_addr;
881         else
882                 chip->rtc_i2c_addr = MAX77663_RTC_I2C_ADDR;
883
884         chip->i2c_rtc = i2c_new_dummy(client->adapter, chip->rtc_i2c_addr);
885         if (!chip->i2c_rtc) {
886                 dev_err(&client->dev, "can't attach client at addr 0x%x\n",
887                                 chip->rtc_i2c_addr);
888                 return -ENOMEM;
889         }
890         i2c_set_clientdata(chip->i2c_rtc, chip);
891
892         chip->regmap_rtc = devm_regmap_init_i2c(chip->i2c_rtc,
893                                         &max77663_regmap_config_rtc);
894         if (IS_ERR(chip->regmap_rtc)) {
895                 ret = PTR_ERR(chip->regmap_rtc);
896                 dev_err(&client->dev, "rtc tegmap init failed: %d\n", ret);
897                 goto out_rtc_regmap_fail;
898         }
899
900         chip->dev = &client->dev;
901         chip->pdata = pdata;
902         chip->irq_base = pdata->irq_base;
903         mutex_init(&chip->io_lock);
904
905         /* Dummy read to see if chip is present or not*/
906         ret = max77663_read(chip->dev, MAX77663_REG_CID5, &val, 1, 0);
907         if (ret < 0) {
908                 dev_err(chip->dev, "preinit: Failed to get register 0x%x\n",
909                                 MAX77663_REG_CID5);
910                 return ret;
911         }
912
913         max77663_irq_init(chip);
914         max77663_debugfs_init(chip);
915         ret = max77663_sleep(chip, false);
916         if (ret < 0) {
917                 dev_err(&client->dev, "probe: Failed to disable sleep\n");
918                 goto out_exit;
919         }
920
921         if (pdata->use_power_off && !pm_power_off)
922                 pm_power_off = max77663_power_off;
923
924         ret =  mfd_add_devices(&client->dev, -1, max77663_cells,
925                         ARRAY_SIZE(max77663_cells), NULL, chip->irq_base);
926         if (ret < 0) {
927                  dev_err(&client->dev, "mfd add dev failed, e = %d\n", ret);
928                 goto out_exit;
929         }
930
931         ret = mfd_add_devices(&client->dev, 0, pdata->sub_devices,
932                               pdata->num_subdevs, NULL, 0);
933         if (ret != 0) {
934                 dev_err(&client->dev, "probe: Failed to add subdev: %d\n", ret);
935                 goto out_mfd_clean;
936         }
937
938         return 0;
939
940 out_mfd_clean:
941         mfd_remove_devices(chip->dev);
942 out_exit:
943         max77663_debugfs_exit(chip);
944         max77663_irq_exit(chip);
945         mutex_destroy(&chip->io_lock);
946
947 out_rtc_regmap_fail:
948         i2c_unregister_device(chip->i2c_rtc);
949         max77663_chip = NULL;
950         return ret;
951 }
952
953 static int max77663_remove(struct i2c_client *client)
954 {
955         struct max77663_chip *chip = i2c_get_clientdata(client);
956
957         mfd_remove_devices(chip->dev);
958         max77663_debugfs_exit(chip);
959         max77663_irq_exit(chip);
960         mutex_destroy(&chip->io_lock);
961         i2c_unregister_device(chip->i2c_rtc);
962         max77663_chip = NULL;
963
964         return 0;
965 }
966
967 #ifdef CONFIG_PM_SLEEP
968 static int max77663_suspend(struct device *dev)
969 {
970         struct i2c_client *client = to_i2c_client(dev);
971         struct max77663_chip *chip = i2c_get_clientdata(client);
972         int ret;
973
974         if (client->irq)
975                 disable_irq(client->irq);
976
977         ret = max77663_sleep(chip, true);
978         if (ret < 0)
979                 dev_err(dev, "suspend: Failed to enable sleep\n");
980
981         return ret;
982 }
983
984 static int max77663_resume(struct device *dev)
985 {
986         struct i2c_client *client = to_i2c_client(dev);
987         struct max77663_chip *chip = i2c_get_clientdata(client);
988         int ret;
989
990         ret = max77663_sleep(chip, false);
991         if (ret < 0) {
992                 dev_err(dev, "resume: Failed to disable sleep\n");
993                 return ret;
994         }
995
996         if (client->irq)
997                 enable_irq(client->irq);
998
999         return 0;
1000 }
1001 #else
1002 #define max77663_suspend      NULL
1003 #define max77663_resume       NULL
1004 #endif /* CONFIG_PM_SLEEP */
1005
1006 static const struct i2c_device_id max77663_id[] = {
1007         {"max77663", 0},
1008         {},
1009 };
1010 MODULE_DEVICE_TABLE(i2c, max77663_id);
1011
1012 static const struct dev_pm_ops max77663_pm = {
1013         .suspend = max77663_suspend,
1014         .resume = max77663_resume,
1015 };
1016
1017 static struct i2c_driver max77663_driver = {
1018         .driver = {
1019                 .name = "max77663",
1020                 .owner = THIS_MODULE,
1021                 .pm = &max77663_pm,
1022         },
1023         .probe = max77663_probe,
1024         .remove = max77663_remove,
1025         .id_table = max77663_id,
1026 };
1027
1028 static int __init max77663_init(void)
1029 {
1030         return i2c_add_driver(&max77663_driver);
1031 }
1032 subsys_initcall(max77663_init);
1033
1034 static void __exit max77663_exit(void)
1035 {
1036         i2c_del_driver(&max77663_driver);
1037 }
1038 module_exit(max77663_exit);
1039
1040 MODULE_LICENSE("GPL v2");
1041 MODULE_DESCRIPTION("MAX77663 Multi Function Device Core Driver");
1042 MODULE_VERSION("1.0");