mfd: max77663: Set sleep enable bit before enter into suspend
[linux-2.6.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 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/gpio.h>
18 #include <linux/slab.h>
19 #include <linux/ratelimit.h>
20 #include <linux/kthread.h>
21 #include <linux/mfd/core.h>
22 #include <linux/platform_device.h>
23 #include <linux/seq_file.h>
24 #include <linux/debugfs.h>
25 #include <linux/delay.h>
26 #include <linux/uaccess.h>
27
28 #include <linux/mfd/max77663-core.h>
29
30 /* RTC i2c slave address */
31 #define MAX77663_RTC_I2C_ADDR           0x48
32
33 /* Registers */
34 #define MAX77663_REG_IRQ_TOP            0x05
35 #define MAX77663_REG_LBT_IRQ            0x06
36 #define MAX77663_REG_SD_IRQ             0x07
37 #define MAX77663_REG_LDOX_IRQ           0x08
38 #define MAX77663_REG_LDO8_IRQ           0x09
39 #define MAX77663_REG_GPIO_IRQ           0x0A
40 #define MAX77663_REG_ONOFF_IRQ          0x0B
41 #define MAX77663_REG_NVER               0x0C
42 #define MAX77663_REG_IRQ_TOP_MASK       0x0D
43 #define MAX77663_REG_LBT_IRQ_MASK       0x0E
44 #define MAX77663_REG_SD_IRQ_MASK        0x0F
45 #define MAX77663_REG_LDOX_IRQ_MASK      0x10
46 #define MAX77663_REG_LDO8_IRQ_MASK      0x11
47 #define MAX77663_REG_ONOFF_IRQ_MASK     0x12
48 #define MAX77663_REG_GPIO_CTRL0         0x36
49 #define MAX77663_REG_GPIO_CTRL1         0x37
50 #define MAX77663_REG_GPIO_CTRL2         0x38
51 #define MAX77663_REG_GPIO_CTRL3         0x39
52 #define MAX77663_REG_GPIO_CTRL4         0x3A
53 #define MAX77663_REG_GPIO_CTRL5         0x3B
54 #define MAX77663_REG_GPIO_CTRL6         0x3C
55 #define MAX77663_REG_GPIO_CTRL7         0x3D
56 #define MAX77663_REG_GPIO_PU            0x3E
57 #define MAX77663_REG_GPIO_PD            0x3F
58 #define MAX77663_REG_GPIO_ALT           0x40
59 #define MAX77663_REG_ONOFF_CFG1         0x41
60
61 #define IRQ_TOP_GLBL_MASK               (1 << 7)
62 #define IRQ_TOP_GLBL_SHIFT              7
63 #define IRQ_TOP_SD_MASK                 (1 << 6)
64 #define IRQ_TOP_SD_SHIFT                6
65 #define IRQ_TOP_LDO_MASK                (1 << 5)
66 #define IRQ_TOP_LDO_SHIFT               5
67 #define IRQ_TOP_GPIO_MASK               (1 << 4)
68 #define IRQ_TOP_GPIO_SHIFT              4
69 #define IRQ_TOP_RTC_MASK                (1 << 3)
70 #define IRQ_TOP_RTC_SHIFT               3
71 #define IRQ_TOP_32K_MASK                (1 << 2)
72 #define IRQ_TOP_32K_SHIFT               2
73 #define IRQ_TOP_ONOFF_MASK              (1 << 1)
74 #define IRQ_TOP_ONOFF_SHIFT             1
75 #define IRQ_TOP_NVER_MASK               (1 << 0)
76 #define IRQ_TOP_NVER_SHIFT              0
77
78 #define IRQ_GLBL_MASK                   (1 << 0)
79
80 #define IRQ_LBT_BASE                    MAX77663_IRQ_LBT_LB
81 #define IRQ_LBT_END                     MAX77663_IRQ_LBT_THERM_ALRM2
82
83 #define IRQ_GPIO_BASE                   MAX77663_IRQ_GPIO0
84 #define IRQ_GPIO_END                    MAX77663_IRQ_GPIO7
85
86 #define IRQ_ONOFF_BASE                  MAX77663_IRQ_ONOFF_HRDPOWRN
87 #define IRQ_ONOFF_END                   MAX77663_IRQ_ONOFF_ACOK_RISING
88
89 #define GPIO_REG_ADDR(offset)           (MAX77663_REG_GPIO_CTRL0 + offset)
90
91 #define GPIO_CTRL_DBNC_MASK             (3 << 6)
92 #define GPIO_CTRL_DBNC_SHIFT            6
93 #define GPIO_CTRL_REFE_IRQ_MASK         (3 << 4)
94 #define GPIO_CTRL_REFE_IRQ_SHIFT        4
95 #define GPIO_CTRL_DOUT_MASK             (1 << 3)
96 #define GPIO_CTRL_DOUT_SHIFT            3
97 #define GPIO_CTRL_DIN_MASK              (1 << 2)
98 #define GPIO_CTRL_DIN_SHIFT             2
99 #define GPIO_CTRL_DIR_MASK              (1 << 1)
100 #define GPIO_CTRL_DIR_SHIFT             1
101 #define GPIO_CTRL_OUT_DRV_MASK          (1 << 0)
102 #define GPIO_CTRL_OUT_DRV_SHIFT         0
103
104 #define GPIO_REFE_IRQ_NONE              0
105 #define GPIO_REFE_IRQ_EDGE_FALLING      1
106 #define GPIO_REFE_IRQ_EDGE_RISING       2
107 #define GPIO_REFE_IRQ_EDGE_BOTH         3
108
109 #define GPIO_DBNC_NONE                  0
110 #define GPIO_DBNC_8MS                   1
111 #define GPIO_DBNC_16MS                  2
112 #define GPIO_DBNC_32MS                  3
113
114 #define ONOFF_SFT_RST_MASK              (1 << 7)
115 #define ONOFF_SLPEN_MASK                (1 << 2)
116
117 enum {
118         CACHE_IRQ_LBT,
119         CACHE_IRQ_SD,
120         CACHE_IRQ_LDO,
121         CACHE_IRQ_ONOFF,
122         CACHE_IRQ_NR,
123 };
124
125 struct max77663_irq_data {
126         int mask_reg;
127         u16 mask;
128         u8 top_mask;
129         u8 top_shift;
130         int cache_idx;
131         bool is_rtc;
132         bool is_unmask;
133         u8 trigger_type;
134 };
135
136 struct max77663_chip {
137         struct device *dev;
138         struct i2c_client *i2c_power;
139         struct i2c_client *i2c_rtc;
140
141         struct max77663_platform_data *pdata;
142         struct mutex io_lock;
143
144         struct irq_chip irq;
145         struct mutex irq_lock;
146         int irq_base;
147         int irq_top_count[8];
148         u8 cache_irq_top_mask;
149         u16 cache_irq_mask[CACHE_IRQ_NR];
150
151         struct gpio_chip gpio;
152         int gpio_base;
153         u8 cache_gpio_ctrl[MAX77663_GPIO_NR];
154         u8 cache_gpio_pu;
155         u8 cache_gpio_pd;
156         u8 cache_gpio_alt;
157 };
158
159 struct max77663_chip *max77663_chip;
160
161 #define IRQ_DATA_LBT(_name, _shift)                     \
162         [MAX77663_IRQ_LBT_##_name] = {                  \
163                 .mask_reg = MAX77663_REG_LBT_IRQ_MASK,  \
164                 .mask = (1 << _shift),                  \
165                 .top_mask = IRQ_TOP_GLBL_MASK,          \
166                 .top_shift = IRQ_TOP_GLBL_SHIFT,        \
167                 .cache_idx = CACHE_IRQ_LBT,             \
168         }
169
170 #define IRQ_DATA_GPIO(_name)                            \
171         [MAX77663_IRQ_GPIO##_name] = {                  \
172                 .mask = (1 << _name),                   \
173                 .top_mask = IRQ_TOP_GPIO_MASK,          \
174                 .top_shift = IRQ_TOP_GPIO_SHIFT,        \
175                 .cache_idx = -1,                        \
176         }
177
178 #define IRQ_DATA_ONOFF(_name, _shift)                   \
179         [MAX77663_IRQ_ONOFF_##_name] = {                \
180                 .mask_reg = MAX77663_REG_ONOFF_IRQ_MASK,\
181                 .mask = (1 << _shift),                  \
182                 .top_mask = IRQ_TOP_ONOFF_MASK,         \
183                 .top_shift = IRQ_TOP_ONOFF_SHIFT,       \
184                 .cache_idx = CACHE_IRQ_ONOFF,           \
185         }
186
187 static struct max77663_irq_data max77663_irqs[MAX77663_IRQ_NR] = {
188         IRQ_DATA_LBT(LB, 3),
189         IRQ_DATA_LBT(THERM_ALRM1, 2),
190         IRQ_DATA_LBT(THERM_ALRM2, 1),
191         IRQ_DATA_GPIO(0),
192         IRQ_DATA_GPIO(1),
193         IRQ_DATA_GPIO(2),
194         IRQ_DATA_GPIO(3),
195         IRQ_DATA_GPIO(4),
196         IRQ_DATA_GPIO(5),
197         IRQ_DATA_GPIO(6),
198         IRQ_DATA_GPIO(7),
199         IRQ_DATA_ONOFF(HRDPOWRN,     0),
200         IRQ_DATA_ONOFF(EN0_1SEC,     1),
201         IRQ_DATA_ONOFF(EN0_FALLING,  2),
202         IRQ_DATA_ONOFF(EN0_RISING,   3),
203         IRQ_DATA_ONOFF(LID_FALLING,  4),
204         IRQ_DATA_ONOFF(LID_RISING,   5),
205         IRQ_DATA_ONOFF(ACOK_FALLING, 6),
206         IRQ_DATA_ONOFF(ACOK_RISING,  7),
207         [MAX77663_IRQ_RTC] = {
208                 .top_mask = IRQ_TOP_RTC_MASK,
209                 .top_shift = IRQ_TOP_RTC_SHIFT,
210                 .cache_idx = -1,
211                 .is_rtc = 1,
212         },
213         [MAX77663_IRQ_SD_PF] = {
214                 .mask_reg = MAX77663_REG_SD_IRQ_MASK,
215                 .mask = 0xF8,
216                 .top_mask = IRQ_TOP_SD_MASK,
217                 .top_shift = IRQ_TOP_SD_SHIFT,
218                 .cache_idx = CACHE_IRQ_SD,
219         },
220         [MAX77663_IRQ_LDO_PF] = {
221                 .mask_reg = MAX77663_REG_LDOX_IRQ_MASK,
222                 .mask = 0x1FF,
223                 .top_mask = IRQ_TOP_LDO_MASK,
224                 .top_shift = IRQ_TOP_LDO_SHIFT,
225                 .cache_idx = CACHE_IRQ_LDO,
226         },
227         [MAX77663_IRQ_32K] = {
228                 .top_mask = IRQ_TOP_32K_MASK,
229                 .top_shift = IRQ_TOP_32K_SHIFT,
230                 .cache_idx = -1,
231         },
232         [MAX77663_IRQ_NVER] = {
233                 .top_mask = IRQ_TOP_NVER_MASK,
234                 .top_shift = IRQ_TOP_NVER_SHIFT,
235                 .cache_idx = -1,
236         },
237 };
238
239 static inline int max77663_i2c_write(struct i2c_client *client, u8 addr,
240                                      void *src, u32 bytes)
241 {
242         u8 buf[bytes + 1];
243         int ret;
244
245         dev_dbg(&client->dev, "i2c_write: addr=0x%02x, src=0x%02x, bytes=%u\n",
246                 addr, *((u8 *)src), bytes);
247
248         if (client->addr == MAX77663_RTC_I2C_ADDR) {
249                 /* RTC registers support sequential writing */
250                 buf[0] = addr;
251                 memcpy(&buf[1], src, bytes);
252         } else {
253                 /* Power registers support register-data pair writing */
254                 u8 *src8 = (u8 *)src;
255                 int i;
256
257                 for (i = 0; i < (bytes * 2); i++) {
258                         if (i % 2)
259                                 buf[i] = *src8++;
260                         else
261                                 buf[i] = addr++;
262                 }
263                 bytes = (bytes * 2) - 1;
264         }
265
266         ret = i2c_master_send(client, buf, bytes + 1);
267         if (ret < 0)
268                 return ret;
269         return 0;
270 }
271
272 static inline int max77663_i2c_read(struct i2c_client *client, u8 addr,
273                                     void *dest, u32 bytes)
274 {
275         int ret;
276
277         if (bytes > 1) {
278                 ret = i2c_smbus_read_i2c_block_data(client, addr, bytes, dest);
279                 if (ret < 0)
280                         return ret;
281         } else {
282                 ret = i2c_smbus_read_byte_data(client, addr);
283                 if (ret < 0)
284                         return ret;
285
286                 *((u8 *)dest) = (u8)ret;
287         }
288
289         dev_dbg(&client->dev, "i2c_read: addr=0x%02x, dest=0x%02x, bytes=%u\n",
290                 addr, *((u8 *)dest), bytes);
291         return 0;
292 }
293
294 int max77663_read(struct device *dev, u8 addr, void *values, u32 len,
295                   bool is_rtc)
296 {
297         struct max77663_chip *chip = dev_get_drvdata(dev);
298         struct i2c_client *client = NULL;
299         int ret;
300
301         mutex_lock(&chip->io_lock);
302         if (!is_rtc)
303                 client = chip->i2c_power;
304         else
305                 client = chip->i2c_rtc;
306
307         ret = max77663_i2c_read(client, addr, values, len);
308         mutex_unlock(&chip->io_lock);
309         return ret;
310 }
311 EXPORT_SYMBOL(max77663_read);
312
313 int max77663_write(struct device *dev, u8 addr, void *values, u32 len,
314                    bool is_rtc)
315 {
316         struct max77663_chip *chip = dev_get_drvdata(dev);
317         struct i2c_client *client = NULL;
318         int ret;
319
320         mutex_lock(&chip->io_lock);
321         if (!is_rtc)
322                 client = chip->i2c_power;
323         else
324                 client = chip->i2c_rtc;
325
326         ret = max77663_i2c_write(client, addr, values, len);
327         mutex_unlock(&chip->io_lock);
328         return ret;
329 }
330 EXPORT_SYMBOL(max77663_write);
331
332 int max77663_set_bits(struct device *dev, u8 addr, u8 mask, u8 value,
333                       bool is_rtc)
334 {
335         struct max77663_chip *chip = dev_get_drvdata(dev);
336         struct i2c_client *client = NULL;
337         u8 tmp;
338         int ret;
339
340         mutex_lock(&chip->io_lock);
341         if (!is_rtc)
342                 client = chip->i2c_power;
343         else
344                 client = chip->i2c_rtc;
345
346         ret = max77663_i2c_read(client, addr, &tmp, 1);
347         if (ret == 0) {
348                 value = (tmp & ~mask) | (value & mask);
349                 ret = max77663_i2c_write(client, addr, &value, 1);
350         }
351         mutex_unlock(&chip->io_lock);
352         return ret;
353 }
354 EXPORT_SYMBOL(max77663_set_bits);
355
356 int max77663_power_off(void)
357 {
358         struct max77663_chip *chip = max77663_chip;
359
360         dev_info(chip->dev, "%s: Global shutdown\n", __func__);
361         return max77663_set_bits(chip->dev, MAX77663_REG_ONOFF_CFG1,
362                                  ONOFF_SFT_RST_MASK, ONOFF_SFT_RST_MASK, 0);
363 }
364 EXPORT_SYMBOL(max77663_power_off);
365
366 static inline int max77663_cache_write(struct device *dev, u8 addr, u8 mask,
367                                        u8 val, u8 *cache)
368 {
369         u8 new_val;
370         int ret;
371
372         new_val = (*cache & ~mask) | (val & mask);
373         if (*cache != new_val) {
374                 ret = max77663_write(dev, addr, &new_val, 1, 0);
375                 if (ret < 0)
376                         return ret;
377                 *cache = new_val;
378         }
379         return 0;
380 }
381
382 static inline
383 struct max77663_chip *max77663_chip_from_gpio(struct gpio_chip *gpio)
384 {
385         return container_of(gpio, struct max77663_chip, gpio);
386 }
387
388 static int max77663_gpio_set_pull_up(struct max77663_chip *chip, int offset,
389                                      int pull_up)
390 {
391         u8 val = 0;
392
393         if ((offset < MAX77663_GPIO0) || (MAX77663_GPIO7 < offset))
394                 return -EINVAL;
395
396         if (pull_up == GPIO_PU_ENABLE)
397                 val = (1 << offset);
398
399         return max77663_cache_write(chip->dev, MAX77663_REG_GPIO_PU,
400                                     (1 << offset), val, &chip->cache_gpio_pu);
401 }
402
403 static int max77663_gpio_set_pull_down(struct max77663_chip *chip, int offset,
404                                        int pull_down)
405 {
406         u8 val = 0;
407
408         if ((offset < MAX77663_GPIO0) || (MAX77663_GPIO7 < offset))
409                 return -EINVAL;
410
411         if (pull_down == GPIO_PD_ENABLE)
412                 val = (1 << offset);
413
414         return max77663_cache_write(chip->dev, MAX77663_REG_GPIO_PD,
415                                     (1 << offset), val, &chip->cache_gpio_pd);
416 }
417
418 static inline
419 int max77663_gpio_is_alternate(struct max77663_chip *chip, int offset)
420 {
421         return (chip->cache_gpio_alt & (1 << offset)) ? 1 : 0;
422 }
423
424 int max77663_gpio_set_alternate(int gpio, int alternate)
425 {
426         struct max77663_chip *chip = max77663_chip;
427         u8 val = 0;
428         int ret = 0;
429
430         if (!chip)
431                 return -ENXIO;
432
433         gpio -= chip->gpio_base;
434         if ((gpio < MAX77663_GPIO0) || (MAX77663_GPIO7 < gpio))
435                 return -EINVAL;
436
437         if (alternate == GPIO_ALT_ENABLE) {
438                 val = (1 << gpio);
439                 if (gpio == MAX77663_GPIO7) {
440                         ret = max77663_gpio_set_pull_up(chip, gpio, 0);
441                         if (ret < 0)
442                                 return ret;
443
444                         ret = max77663_gpio_set_pull_down(chip, gpio, 0);
445                         if (ret < 0)
446                                 return ret;
447                 }
448         }
449
450         return max77663_cache_write(chip->dev, MAX77663_REG_GPIO_ALT,
451                                     (1 << gpio), val, &chip->cache_gpio_alt);
452 }
453 EXPORT_SYMBOL(max77663_gpio_set_alternate);
454
455 static int max77663_gpio_dir_input(struct gpio_chip *gpio, unsigned offset)
456 {
457         struct max77663_chip *chip = max77663_chip_from_gpio(gpio);
458
459         if (max77663_gpio_is_alternate(chip, offset)) {
460                 dev_warn(chip->dev, "gpio_dir_input: "
461                         "gpio%u is used as alternate mode\n", offset);
462                 return 0;
463         }
464
465         return max77663_cache_write(chip->dev, GPIO_REG_ADDR(offset),
466                                     GPIO_CTRL_DIR_MASK, GPIO_CTRL_DIR_MASK,
467                                     &chip->cache_gpio_ctrl[offset]);
468 }
469
470 static int max77663_gpio_get(struct gpio_chip *gpio, unsigned offset)
471 {
472         struct max77663_chip *chip = max77663_chip_from_gpio(gpio);
473         u8 val;
474         int ret;
475
476         if (max77663_gpio_is_alternate(chip, offset)) {
477                 dev_warn(chip->dev, "gpio_get: "
478                         "gpio%u is used as alternate mode\n", offset);
479                 return 0;
480         }
481
482         ret = max77663_read(chip->dev, GPIO_REG_ADDR(offset), &val, 1, 0);
483         if (ret < 0)
484                 return ret;
485
486         chip->cache_gpio_ctrl[offset] = val;
487         return (val & GPIO_CTRL_DIN_MASK) >> GPIO_CTRL_DIN_SHIFT;
488 }
489
490 static int max77663_gpio_dir_output(struct gpio_chip *gpio, unsigned offset,
491                                     int value)
492 {
493         struct max77663_chip *chip = max77663_chip_from_gpio(gpio);
494         u8 mask = GPIO_CTRL_DIR_MASK | GPIO_CTRL_DOUT_MASK;
495         u8 val = (value ? 1 : 0) << GPIO_CTRL_DOUT_SHIFT;
496
497         if (max77663_gpio_is_alternate(chip, offset)) {
498                 dev_warn(chip->dev, "gpio_dir_output: "
499                         "gpio%u is used as alternate mode\n", offset);
500                 return 0;
501         }
502
503         return max77663_cache_write(chip->dev, GPIO_REG_ADDR(offset), mask, val,
504                                     &chip->cache_gpio_ctrl[offset]);
505 }
506
507 static int max77663_gpio_set_debounce(struct gpio_chip *gpio, unsigned offset,
508                                       unsigned debounce)
509 {
510         struct max77663_chip *chip = max77663_chip_from_gpio(gpio);
511         u8 shift = GPIO_CTRL_DBNC_SHIFT;
512         u8 val = 0;
513
514         if (max77663_gpio_is_alternate(chip, offset)) {
515                 dev_warn(chip->dev, "gpio_set_debounce: "
516                         "gpio%u is used as alternate mode\n", offset);
517                 return 0;
518         }
519
520         if (debounce == 0)
521                 val = 0;
522         else if ((0 < debounce) && (debounce <= 8))
523                 val = (GPIO_DBNC_8MS << shift);
524         else if ((8 < debounce) && (debounce <= 16))
525                 val = (GPIO_DBNC_16MS << shift);
526         else if ((16 < debounce) && (debounce <= 32))
527                 val = (GPIO_DBNC_32MS << shift);
528         else
529                 return -EINVAL;
530
531         return max77663_cache_write(chip->dev, GPIO_REG_ADDR(offset),
532                                     GPIO_CTRL_DBNC_MASK, val,
533                                     &chip->cache_gpio_ctrl[offset]);
534 }
535
536 static void max77663_gpio_set(struct gpio_chip *gpio, unsigned offset,
537                               int value)
538 {
539         struct max77663_chip *chip = max77663_chip_from_gpio(gpio);
540         u8 val = (value ? 1 : 0) << GPIO_CTRL_DOUT_SHIFT;
541
542         if (max77663_gpio_is_alternate(chip, offset)) {
543                 dev_warn(chip->dev, "gpio_set: "
544                         "gpio%u is used as alternate mode\n", offset);
545                 return;
546         }
547
548         max77663_cache_write(chip->dev, GPIO_REG_ADDR(offset),
549                              GPIO_CTRL_DOUT_MASK, val,
550                              &chip->cache_gpio_ctrl[offset]);
551 }
552
553 static int max77663_gpio_to_irq(struct gpio_chip *gpio, unsigned offset)
554 {
555         struct max77663_chip *chip = max77663_chip_from_gpio(gpio);
556
557         return chip->irq_base + IRQ_GPIO_BASE + offset;
558 }
559
560 #ifdef CONFIG_DEBUG_FS
561 static void max77663_gpio_dbg_show(struct seq_file *s, struct gpio_chip *gpio)
562 {
563         struct max77663_chip *chip = max77663_chip_from_gpio(gpio);
564         int i;
565
566         for (i = 0; i < gpio->ngpio; i++) {
567                 u8 ctrl_val;
568                 const char *label;
569                 int is_out;
570                 int ret;
571
572                 label = gpiochip_is_requested(gpio, i);
573                 if (!label)
574                         label = "Unrequested";
575
576                 seq_printf(s, " gpio-%-3d (%-20.20s) ", i + chip->gpio_base,
577                            label);
578
579                 if (chip->cache_gpio_alt & (1 << i)) {
580                         seq_printf(s, "alt\n");
581                         continue;
582                 }
583
584                 ret = max77663_read(chip->dev, GPIO_REG_ADDR(i), &ctrl_val, 1,
585                                     0);
586                 if (ret < 0) {
587                         seq_printf(s, "\n");
588                         continue;
589                 }
590
591                 is_out = ctrl_val & GPIO_CTRL_DIR_MASK ? 0 : 1;
592                 seq_printf(s, "%s %s", (is_out ? "out" : "in"), (is_out ?
593                            (ctrl_val & GPIO_CTRL_DOUT_MASK ? "hi" : "lo")
594                            : (ctrl_val & GPIO_CTRL_DIN_MASK ? "hi" : "lo")));
595
596                 if (!is_out) {
597                         int irq = gpio_to_irq(i + chip->gpio_base);
598                         struct irq_desc *desc = irq_to_desc(irq);
599                         u8 dbnc;
600
601                         if (irq >= 0 && desc->action) {
602                                 u8 mask = GPIO_CTRL_REFE_IRQ_MASK;
603                                 u8 shift = GPIO_CTRL_REFE_IRQ_SHIFT;
604                                 char *trigger;
605
606                                 switch ((ctrl_val & mask) >> shift) {
607                                 case GPIO_REFE_IRQ_EDGE_FALLING:
608                                         trigger = "edge-falling";
609                                         break;
610                                 case GPIO_REFE_IRQ_EDGE_RISING:
611                                         trigger = "edge-rising";
612                                         break;
613                                 case GPIO_REFE_IRQ_EDGE_BOTH:
614                                         trigger = "edge-both";
615                                         break;
616                                 default:
617                                         trigger = "masked";
618                                         break;
619                                 }
620
621                                 seq_printf(s, " irq-%d %s", irq, trigger);
622                         }
623
624                         dbnc = (ctrl_val & GPIO_CTRL_DBNC_MASK)
625                                 >> GPIO_CTRL_DBNC_SHIFT;
626                         seq_printf(s, " debounce-%s",
627                                    dbnc ==  GPIO_DBNC_8MS ? "8ms" :
628                                    dbnc ==  GPIO_DBNC_16MS ? "16ms" :
629                                    dbnc ==  GPIO_DBNC_32MS ? "32ms" : "none");
630                 } else {
631                         seq_printf(s, " %s",
632                                    (ctrl_val & GPIO_CTRL_OUT_DRV_MASK ?
633                                    "output-drive" : "open-drain"));
634                 }
635
636                 seq_printf(s, "\n");
637         }
638 }
639 #else
640 #define max77663_gpio_dbg_show          NULL
641 #endif /* CONFIG_DEBUG_FS */
642
643 static int max77663_gpio_set_config(struct max77663_chip *chip,
644                                     struct max77663_gpio_config *gpio_cfg)
645 {
646         int gpio = gpio_cfg->gpio;
647         u8 val = 0, mask = 0;
648         int ret = 0;
649
650         if ((gpio < MAX77663_GPIO0) || (MAX77663_GPIO7 < gpio))
651                 return -EINVAL;
652
653         if (gpio_cfg->pull_up != GPIO_PU_DEF) {
654                 ret = max77663_gpio_set_pull_up(chip, gpio, gpio_cfg->pull_up);
655                 if (ret < 0) {
656                         dev_err(chip->dev, "gpio_set_config: "
657                                 "Failed to set gpio%d pull-up\n", gpio);
658                         return ret;
659                 }
660         }
661
662         if (gpio_cfg->pull_down != GPIO_PD_DEF) {
663                 ret = max77663_gpio_set_pull_down(chip, gpio,
664                                                   gpio_cfg->pull_down);
665                 if (ret < 0) {
666                         dev_err(chip->dev, "gpio_set_config: "
667                                 "Failed to set gpio%d pull-down\n", gpio);
668                         return ret;
669                 }
670         }
671
672         if (gpio_cfg->dir != GPIO_DIR_DEF) {
673                 mask = GPIO_CTRL_DIR_MASK;
674                 if (gpio_cfg->dir == GPIO_DIR_IN) {
675                         val |= GPIO_CTRL_DIR_MASK;
676                 } else {
677                         if (gpio_cfg->dout != GPIO_DOUT_DEF) {
678                                 mask |= GPIO_CTRL_DOUT_MASK;
679                                 if (gpio_cfg->dout == GPIO_DOUT_HIGH)
680                                         val |= GPIO_CTRL_DOUT_MASK;
681                         }
682
683                         if (gpio_cfg->out_drv != GPIO_OUT_DRV_DEF) {
684                                 mask |= GPIO_CTRL_OUT_DRV_MASK;
685                                 if (gpio_cfg->out_drv == GPIO_OUT_DRV_PUSH_PULL)
686                                         val |= GPIO_CTRL_OUT_DRV_MASK;
687                         }
688                 }
689
690                 ret = max77663_cache_write(chip->dev, GPIO_REG_ADDR(gpio), mask,
691                                            val, &chip->cache_gpio_ctrl[gpio]);
692                 if (ret < 0) {
693                         dev_err(chip->dev, "gpio_set_config: "
694                                 "Failed to set gpio%d control\n", gpio);
695                         return ret;
696                 }
697         }
698
699         if (gpio_cfg->alternate != GPIO_ALT_DEF) {
700                 ret = max77663_gpio_set_alternate(gpio + chip->gpio_base,
701                                                   gpio_cfg->alternate);
702                 if (ret < 0) {
703                         dev_err(chip->dev, "gpio_set_config: "
704                                 "Failed to set gpio%d alternate\n", gpio);
705                         return ret;
706                 }
707         }
708
709         return 0;
710 }
711
712 static int max77663_gpio_init(struct max77663_chip *chip)
713 {
714         int i;
715         int ret;
716
717         chip->gpio.label = chip->i2c_power->name;
718         chip->gpio.dev = chip->dev;
719         chip->gpio.owner = THIS_MODULE;
720         chip->gpio.direction_input = max77663_gpio_dir_input;
721         chip->gpio.get = max77663_gpio_get;
722         chip->gpio.direction_output = max77663_gpio_dir_output;
723         chip->gpio.set_debounce = max77663_gpio_set_debounce;
724         chip->gpio.set = max77663_gpio_set;
725         chip->gpio.to_irq = max77663_gpio_to_irq;
726         chip->gpio.dbg_show = max77663_gpio_dbg_show;
727         chip->gpio.ngpio = MAX77663_GPIO_NR;
728         chip->gpio.can_sleep = 1;
729         if (chip->gpio_base)
730                 chip->gpio.base = chip->gpio_base;
731         else
732                 chip->gpio.base = -1;
733
734         ret = max77663_read(chip->dev, MAX77663_REG_GPIO_CTRL0,
735                             chip->cache_gpio_ctrl, MAX77663_GPIO_NR, 0);
736         if (ret < 0) {
737                 dev_err(chip->dev, "gpio_init: Failed to get gpio control\n");
738                 return ret;
739         }
740
741         ret = max77663_read(chip->dev, MAX77663_REG_GPIO_PU,
742                             &chip->cache_gpio_pu, 1, 0);
743         if (ret < 0) {
744                 dev_err(chip->dev, "gpio_init: Failed to get gpio pull-up\n");
745                 return ret;
746         }
747
748         ret = max77663_read(chip->dev, MAX77663_REG_GPIO_PD,
749                             &chip->cache_gpio_pd, 1, 0);
750         if (ret < 0) {
751                 dev_err(chip->dev, "gpio_init: Failed to get gpio pull-down\n");
752                 return ret;
753         }
754
755         ret = max77663_read(chip->dev, MAX77663_REG_GPIO_ALT,
756                             &chip->cache_gpio_alt, 1, 0);
757         if (ret < 0) {
758                 dev_err(chip->dev, "gpio_init: Failed to get gpio alternate\n");
759                 return ret;
760         }
761
762         ret = gpiochip_add(&chip->gpio);
763         if (ret < 0) {
764                 dev_err(chip->dev, "gpio_init: Failed to add gpiochip\n");
765                 return ret;
766         }
767         chip->gpio_base = chip->gpio.base;
768
769         for (i = 0; i < chip->pdata->num_gpio_cfgs; i++) {
770                 ret = max77663_gpio_set_config(chip,
771                                                &chip->pdata->gpio_cfgs[i]);
772                 if (ret < 0) {
773                         dev_err(chip->dev,
774                                 "gpio_init: Failed to set gpio config\n");
775                         return ret;
776                 }
777         }
778
779         return 0;
780 }
781
782 static void max77663_gpio_exit(struct max77663_chip *chip)
783 {
784         if (gpiochip_remove(&chip->gpio) < 0)
785                 dev_err(chip->dev, "gpio_exit: Failed to remove gpiochip\n");
786 }
787
788 static void max77663_irq_mask(struct irq_data *data)
789 {
790         struct max77663_chip *chip = irq_data_get_irq_chip_data(data);
791
792         max77663_irqs[data->irq - chip->irq_base].is_unmask = 0;
793 }
794
795 static void max77663_irq_unmask(struct irq_data *data)
796 {
797         struct max77663_chip *chip = irq_data_get_irq_chip_data(data);
798
799         max77663_irqs[data->irq - chip->irq_base].is_unmask = 1;
800 }
801
802 static void max77663_irq_lock(struct irq_data *data)
803 {
804         struct max77663_chip *chip = irq_data_get_irq_chip_data(data);
805
806         mutex_lock(&chip->irq_lock);
807 }
808
809 static void max77663_irq_sync_unlock(struct irq_data *data)
810 {
811         struct max77663_chip *chip = irq_data_get_irq_chip_data(data);
812         struct max77663_irq_data *irq_data =
813                         &max77663_irqs[data->irq - chip->irq_base];
814         int idx = irq_data->cache_idx;
815         u8 irq_top_mask = chip->cache_irq_top_mask;
816         u16 irq_mask = chip->cache_irq_mask[idx];
817         int update_irq_top = 0;
818         u32 len = 1;
819         int ret;
820
821         if (irq_data->is_unmask) {
822                 if (chip->irq_top_count[irq_data->top_shift] == 0)
823                         update_irq_top = 1;
824                 chip->irq_top_count[irq_data->top_shift]++;
825
826                 if (irq_data->top_mask != IRQ_TOP_GLBL_MASK)
827                         irq_top_mask &= ~irq_data->top_mask;
828
829                 if (idx != -1)
830                         irq_mask &= ~irq_data->mask;
831         } else {
832                 if (chip->irq_top_count[irq_data->top_shift] == 1)
833                         update_irq_top = 1;
834
835                 if (--chip->irq_top_count[irq_data->top_shift] < 0)
836                         chip->irq_top_count[irq_data->top_shift] = 0;
837
838                 if (irq_data->top_mask != IRQ_TOP_GLBL_MASK)
839                         irq_top_mask |= irq_data->top_mask;
840
841                 if (idx != -1)
842                         irq_mask |= irq_data->mask;
843         }
844
845         if ((idx != -1) && (irq_mask != chip->cache_irq_mask[idx])) {
846                 if (irq_data->top_mask == IRQ_TOP_LDO_MASK)
847                         len = 2;
848
849                 ret = max77663_write(chip->dev, irq_data->mask_reg,
850                                      &irq_mask, len, irq_data->is_rtc);
851                 if (ret < 0)
852                         goto out;
853
854                 chip->cache_irq_mask[idx] = irq_mask;
855         } else if ((idx == -1) && (irq_data->top_mask == IRQ_TOP_GPIO_MASK)) {
856                 unsigned offset = data->irq - chip->irq_base - IRQ_GPIO_BASE;
857                 u8 shift = GPIO_CTRL_REFE_IRQ_SHIFT;
858
859                 if (irq_data->is_unmask) {
860                         if (irq_data->trigger_type)
861                                 irq_mask = irq_data->trigger_type;
862                         else
863                                 irq_mask = GPIO_REFE_IRQ_EDGE_FALLING << shift;
864                 }
865
866                 ret = max77663_cache_write(chip->dev, GPIO_REG_ADDR(offset),
867                                            GPIO_CTRL_REFE_IRQ_MASK, irq_mask,
868                                            &chip->cache_gpio_ctrl[offset]);
869                 if (ret < 0)
870                         goto out;
871
872                 if (irq_data->is_unmask)
873                         irq_data->trigger_type = irq_mask;
874         }
875
876         if (update_irq_top && (irq_top_mask != chip->cache_irq_top_mask)) {
877                 ret = max77663_cache_write(chip->dev, MAX77663_REG_IRQ_TOP_MASK,
878                                            irq_data->top_mask, irq_top_mask,
879                                            &chip->cache_irq_top_mask);
880                 if (ret < 0)
881                         goto out;
882         }
883
884 out:
885         mutex_unlock(&chip->irq_lock);
886 }
887
888 static int max77663_irq_gpio_set_type(struct irq_data *data, unsigned int type)
889 {
890         struct max77663_chip *chip = irq_data_get_irq_chip_data(data);
891         struct max77663_irq_data *irq_data =
892                         &max77663_irqs[data->irq - chip->irq_base];
893         unsigned offset = data->irq - chip->irq_base - IRQ_GPIO_BASE;
894         u8 shift = GPIO_CTRL_REFE_IRQ_SHIFT;
895         u8 val;
896
897         switch (type) {
898         case IRQ_TYPE_NONE:
899         case IRQ_TYPE_EDGE_FALLING:
900                 val = (GPIO_REFE_IRQ_EDGE_FALLING << shift);
901                 break;
902         case IRQ_TYPE_EDGE_RISING:
903                 val = (GPIO_REFE_IRQ_EDGE_RISING << shift);
904                 break;
905         case IRQ_TYPE_EDGE_BOTH:
906                 val = (GPIO_REFE_IRQ_EDGE_BOTH << shift);
907                 break;
908         default:
909                 return -EINVAL;
910         }
911
912         irq_data->trigger_type = val;
913         if (!(chip->cache_gpio_ctrl[offset] & GPIO_CTRL_REFE_IRQ_MASK))
914                 return 0;
915
916         return max77663_cache_write(chip->dev, GPIO_REG_ADDR(offset),
917                                     GPIO_CTRL_REFE_IRQ_MASK, val,
918                                     &chip->cache_gpio_ctrl[offset]);
919 }
920
921 static inline int max77663_do_irq(struct max77663_chip *chip, u8 addr,
922                                   int irq_base, int irq_end)
923 {
924         struct max77663_irq_data *irq_data = NULL;
925         int irqs_to_handle[irq_end - irq_base + 1];
926         int handled = 0;
927         u16 val;
928         u32 len = 1;
929         int i;
930         int ret;
931
932         ret = max77663_read(chip->dev, addr, &val, len, 0);
933         if (ret < 0)
934                 return ret;
935
936         for (i = irq_base; i <= irq_end; i++) {
937                 irq_data = &max77663_irqs[i];
938                 if (val & irq_data->mask) {
939                         irqs_to_handle[handled] = i + chip->irq_base;
940                         handled++;
941                 }
942         }
943
944         for (i = 0; i < handled; i++)
945                 handle_nested_irq(irqs_to_handle[i]);
946
947         return 0;
948 }
949
950 static irqreturn_t max77663_irq(int irq, void *data)
951 {
952         struct max77663_chip *chip = data;
953         u8 irq_top;
954         int ret;
955
956         ret = max77663_read(chip->dev, MAX77663_REG_IRQ_TOP, &irq_top, 1, 0);
957         if (ret < 0) {
958                 dev_err(chip->dev, "irq: Failed to get irq top status\n");
959                 return IRQ_NONE;
960         }
961
962         if (irq_top & IRQ_TOP_GLBL_MASK) {
963                 ret = max77663_do_irq(chip, MAX77663_REG_LBT_IRQ, IRQ_LBT_BASE,
964                                       IRQ_LBT_END);
965                 if (ret < 0)
966                         return IRQ_NONE;
967         }
968
969         if (irq_top & IRQ_TOP_GPIO_MASK) {
970                 ret = max77663_do_irq(chip, MAX77663_REG_GPIO_IRQ,
971                                       IRQ_GPIO_BASE, IRQ_GPIO_END);
972                 if (ret < 0)
973                         return IRQ_NONE;
974         }
975
976         if (irq_top & IRQ_TOP_ONOFF_MASK) {
977                 ret = max77663_do_irq(chip, MAX77663_REG_ONOFF_IRQ,
978                                       IRQ_ONOFF_BASE, IRQ_ONOFF_END);
979                 if (ret < 0)
980                         return IRQ_NONE;
981         }
982
983         if (irq_top & IRQ_TOP_RTC_MASK)
984                 handle_nested_irq(MAX77663_IRQ_RTC + chip->irq_base);
985
986         if (irq_top & IRQ_TOP_SD_MASK)
987                 handle_nested_irq(MAX77663_IRQ_SD_PF + chip->irq_base);
988
989         if (irq_top & IRQ_TOP_LDO_MASK)
990                 handle_nested_irq(MAX77663_IRQ_LDO_PF + chip->irq_base);
991
992         if (irq_top & IRQ_TOP_32K_MASK)
993                 handle_nested_irq(MAX77663_IRQ_32K + chip->irq_base);
994
995         if (irq_top & IRQ_TOP_NVER_MASK)
996                 handle_nested_irq(MAX77663_IRQ_NVER + chip->irq_base);
997
998         return IRQ_HANDLED;
999 }
1000
1001 static struct irq_chip max77663_irq_gpio_chip = {
1002         .name = "max77663-irq",
1003         .irq_mask = max77663_irq_mask,
1004         .irq_unmask = max77663_irq_unmask,
1005         .irq_set_type = max77663_irq_gpio_set_type,
1006         .irq_bus_lock = max77663_irq_lock,
1007         .irq_bus_sync_unlock = max77663_irq_sync_unlock,
1008 };
1009
1010 static struct irq_chip max77663_irq_chip = {
1011         .name = "max77663-irq",
1012         .irq_mask = max77663_irq_mask,
1013         .irq_unmask = max77663_irq_unmask,
1014         .irq_bus_lock = max77663_irq_lock,
1015         .irq_bus_sync_unlock = max77663_irq_sync_unlock,
1016 };
1017
1018 static int max77663_irq_init(struct max77663_chip *chip)
1019 {
1020         unsigned long flags = IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_DISABLED;
1021         u32 temp;
1022         int i, ret = 0;
1023
1024         mutex_init(&chip->irq_lock);
1025
1026         /* Mask all interrupts */
1027         chip->cache_irq_top_mask = 0xFF;
1028         chip->cache_irq_mask[CACHE_IRQ_LBT] = 0x0F;
1029         chip->cache_irq_mask[CACHE_IRQ_SD] = 0xFF;
1030         chip->cache_irq_mask[CACHE_IRQ_LDO] = 0xFFFF;
1031         chip->cache_irq_mask[CACHE_IRQ_ONOFF] = 0xFF;
1032
1033         max77663_write(chip->dev, MAX77663_REG_IRQ_TOP_MASK,
1034                        &chip->cache_irq_top_mask, 1, 0);
1035         max77663_write(chip->dev, MAX77663_REG_LBT_IRQ_MASK,
1036                        &chip->cache_irq_mask[CACHE_IRQ_LBT], 1, 0);
1037         max77663_write(chip->dev, MAX77663_REG_SD_IRQ_MASK,
1038                        &chip->cache_irq_mask[CACHE_IRQ_SD], 1, 0);
1039         max77663_write(chip->dev, MAX77663_REG_LDOX_IRQ_MASK,
1040                        &chip->cache_irq_mask[CACHE_IRQ_LDO], 2, 0);
1041         max77663_write(chip->dev, MAX77663_REG_ONOFF_IRQ_MASK,
1042                        &chip->cache_irq_mask[CACHE_IRQ_ONOFF], 1, 0);
1043
1044         /* Clear all interrups */
1045         max77663_read(chip->dev, MAX77663_REG_LBT_IRQ, &temp, 1, 0);
1046         max77663_read(chip->dev, MAX77663_REG_SD_IRQ, &temp, 1, 0);
1047         max77663_read(chip->dev, MAX77663_REG_LDOX_IRQ, &temp, 2, 0);
1048         max77663_read(chip->dev, MAX77663_REG_GPIO_IRQ, &temp, 1, 0);
1049         max77663_read(chip->dev, MAX77663_REG_ONOFF_IRQ, &temp, 1, 0);
1050
1051         for (i = chip->irq_base; i < (MAX77663_IRQ_NR + chip->irq_base); i++) {
1052                 if (i >= NR_IRQS) {
1053                         dev_err(chip->dev,
1054                                 "irq_init: Can't set irq chip for irq %d\n", i);
1055                         continue;
1056                 }
1057
1058                 irq_set_chip_data(i, chip);
1059
1060                 if ((IRQ_GPIO_BASE <= i - chip->irq_base) &&
1061                                 (i - chip->irq_base <= IRQ_GPIO_END))
1062                         irq_set_chip_and_handler(i, &max77663_irq_gpio_chip,
1063                                                  handle_edge_irq);
1064                 else
1065                         irq_set_chip_and_handler(i, &max77663_irq_chip,
1066                                                  handle_edge_irq);
1067 #ifdef CONFIG_ARM
1068                 set_irq_flags(i, IRQF_VALID);
1069 #else
1070                 irq_set_noprobe(i);
1071 #endif
1072                 irq_set_nested_thread(i, 1);
1073         }
1074
1075         ret = request_threaded_irq(chip->i2c_power->irq, NULL, max77663_irq,
1076                                    flags, "max77663", chip);
1077         if (ret) {
1078                 dev_err(chip->dev, "irq_init: Failed to request irq %d\n",
1079                         chip->i2c_power->irq);
1080                 return ret;
1081         }
1082
1083         device_init_wakeup(chip->dev, 1);
1084         enable_irq_wake(chip->i2c_power->irq);
1085
1086         chip->cache_irq_top_mask &= ~IRQ_TOP_GLBL_MASK;
1087         max77663_write(chip->dev, MAX77663_REG_IRQ_TOP_MASK,
1088                        &chip->cache_irq_top_mask, 1, 0);
1089
1090         chip->cache_irq_mask[CACHE_IRQ_LBT] &= ~IRQ_GLBL_MASK;
1091         max77663_write(chip->dev, MAX77663_REG_LBT_IRQ_MASK,
1092                        &chip->cache_irq_mask[CACHE_IRQ_LBT], 1, 0);
1093
1094         return 0;
1095 }
1096
1097 static void max77663_irq_exit(struct max77663_chip *chip)
1098 {
1099         if (chip->i2c_power->irq)
1100                 free_irq(chip->i2c_power->irq, chip);
1101 }
1102
1103 #ifdef CONFIG_DEBUG_FS
1104 static struct dentry *max77663_dentry_regs;
1105
1106 static int max77663_debugfs_dump_regs(struct max77663_chip *chip, char *label,
1107                                       u8 *addrs, int num_addrs, char *buf,
1108                                       ssize_t *len, int is_rtc)
1109 {
1110         ssize_t count = *len;
1111         u8 val;
1112         int ret = 0;
1113         int i;
1114
1115         count += sprintf(buf + count, "%s\n", label);
1116         if (count >= PAGE_SIZE - 1)
1117                 return -ERANGE;
1118
1119         for (i = 0; i < num_addrs; i++) {
1120                 count += sprintf(buf + count, "0x%02x: ", addrs[i]);
1121                 if (count >= PAGE_SIZE - 1)
1122                         return -ERANGE;
1123
1124                 ret = max77663_read(chip->dev, addrs[i], &val, 1, is_rtc);
1125                 if (ret == 0)
1126                         count += sprintf(buf + count, "0x%02x\n", val);
1127                 else
1128                         count += sprintf(buf + count, "<read fail: %d>\n", ret);
1129
1130                 if (count >= PAGE_SIZE - 1)
1131                         return -ERANGE;
1132         }
1133
1134         *len = count;
1135         return 0;
1136 }
1137
1138 static int max77663_debugfs_regs_open(struct inode *inode, struct file *file)
1139 {
1140         file->private_data = inode->i_private;
1141         return 0;
1142 }
1143
1144 static ssize_t max77663_debugfs_regs_read(struct file *file,
1145                                           char __user *user_buf,
1146                                           size_t count, loff_t *ppos)
1147 {
1148         struct max77663_chip *chip = file->private_data;
1149         char *buf;
1150         size_t len = 0;
1151         ssize_t ret;
1152
1153         /* Excluded interrupt status register to prevent register clear */
1154         u8 global_regs[] = { 0x00, 0x01, 0x02, 0x05, 0x0D, 0x0E, 0x13 };
1155         u8 sd_regs[] = {
1156                 0x07, 0x0F, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
1157                 0x1E, 0x1F, 0x20, 0x21, 0x22
1158         };
1159         u8 ldo_regs[] = {
1160                 0x10, 0x11, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A,
1161                 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34,
1162                 0x35
1163         };
1164         u8 gpio_regs[] = {
1165                 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
1166                 0x40
1167         };
1168         u8 rtc_regs[] = {
1169                 0x01, 0x02, 0x03, 0x04, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
1170                 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
1171                 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B
1172         };
1173         u8 osc_32k_regs[] = { 0x03 };
1174         u8 bbc_regs[] = { 0x04 };
1175         u8 onoff_regs[] = { 0x12, 0x15, 0x41, 0x42 };
1176         u8 fps_regs[] = {
1177                 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C,
1178                 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
1179                 0x57
1180         };
1181         u8 cid_regs[] = { 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D };
1182
1183         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1184         if (!buf)
1185                 return -ENOMEM;
1186
1187         len += sprintf(buf + len, "MAX77663 Registers\n");
1188         max77663_debugfs_dump_regs(chip, "[Global]", global_regs,
1189                                    ARRAY_SIZE(global_regs), buf, &len, 0);
1190         max77663_debugfs_dump_regs(chip, "[Step-Down]", sd_regs,
1191                                    ARRAY_SIZE(sd_regs), buf, &len, 0);
1192         max77663_debugfs_dump_regs(chip, "[LDO]", ldo_regs,
1193                                    ARRAY_SIZE(ldo_regs), buf, &len, 0);
1194         max77663_debugfs_dump_regs(chip, "[GPIO]", gpio_regs,
1195                                    ARRAY_SIZE(gpio_regs), buf, &len, 0);
1196         max77663_debugfs_dump_regs(chip, "[RTC]", rtc_regs,
1197                                    ARRAY_SIZE(rtc_regs), buf, &len, 1);
1198         max77663_debugfs_dump_regs(chip, "[32kHz Oscillator]", osc_32k_regs,
1199                                    ARRAY_SIZE(osc_32k_regs), buf, &len, 0);
1200         max77663_debugfs_dump_regs(chip, "[Backup Battery Charger]", bbc_regs,
1201                                    ARRAY_SIZE(bbc_regs), buf, &len, 0);
1202         max77663_debugfs_dump_regs(chip, "[On/OFF Controller]", onoff_regs,
1203                                    ARRAY_SIZE(onoff_regs), buf, &len, 0);
1204         max77663_debugfs_dump_regs(chip, "[Flexible Power Sequencer]", fps_regs,
1205                                    ARRAY_SIZE(fps_regs), buf, &len, 0);
1206         max77663_debugfs_dump_regs(chip, "[Chip Identification]", cid_regs,
1207                                    ARRAY_SIZE(cid_regs), buf, &len, 0);
1208
1209         ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1210         kfree(buf);
1211
1212         return ret;
1213 }
1214
1215 static const struct file_operations max77663_debugfs_regs_fops = {
1216         .open = max77663_debugfs_regs_open,
1217         .read = max77663_debugfs_regs_read,
1218 };
1219
1220 static void max77663_debugfs_init(struct max77663_chip *chip)
1221 {
1222         max77663_dentry_regs = debugfs_create_file(chip->i2c_power->name,
1223                                                    0444, 0, chip,
1224                                                    &max77663_debugfs_regs_fops);
1225         if (!max77663_dentry_regs)
1226                 dev_warn(chip->dev,
1227                          "debugfs_init: Failed to create debugfs file\n");
1228 }
1229
1230 static void max77663_debugfs_exit(struct max77663_chip *chip)
1231 {
1232         debugfs_remove(max77663_dentry_regs);
1233 }
1234 #else
1235 static inline void max77663_debugfs_init(struct max77663_chip *chip)
1236 {
1237 }
1238
1239 static inline void max77663_debugfs_exit(struct max77663_chip *chip)
1240 {
1241 }
1242 #endif /* CONFIG_DEBUG_FS */
1243
1244 static int max77663_probe(struct i2c_client *client,
1245                           const struct i2c_device_id *id)
1246 {
1247         struct max77663_platform_data *pdata = client->dev.platform_data;
1248         struct max77663_chip *chip;
1249         int ret = 0;
1250
1251         if (pdata == NULL) {
1252                 dev_err(&client->dev, "probe: Invalid platform_data\n");
1253                 ret = -ENODEV;
1254                 goto out;
1255         }
1256
1257         chip = kzalloc(sizeof(struct max77663_chip), GFP_KERNEL);
1258         if (chip == NULL) {
1259                 dev_err(&client->dev, "probe: kzalloc() failed\n");
1260                 ret = -ENOMEM;
1261                 goto out;
1262         }
1263         max77663_chip = chip;
1264
1265         chip->i2c_power = client;
1266         i2c_set_clientdata(client, chip);
1267
1268         chip->i2c_rtc = i2c_new_dummy(client->adapter, MAX77663_RTC_I2C_ADDR);
1269         i2c_set_clientdata(chip->i2c_rtc, chip);
1270
1271         chip->dev = &client->dev;
1272         chip->pdata = pdata;
1273         chip->irq_base = pdata->irq_base;
1274         chip->gpio_base = pdata->gpio_base;
1275         mutex_init(&chip->io_lock);
1276
1277         max77663_gpio_init(chip);
1278         max77663_irq_init(chip);
1279         max77663_debugfs_init(chip);
1280
1281         ret = mfd_add_devices(&client->dev, 0, pdata->sub_devices,
1282                               pdata->num_subdevs, NULL, 0);
1283         if (ret  != 0) {
1284                 dev_err(&client->dev, "probe: Failed to add subdev: %d\n", ret);
1285                 goto out_exit;
1286         }
1287
1288         return 0;
1289
1290 out_exit:
1291         max77663_debugfs_exit(chip);
1292         max77663_gpio_exit(chip);
1293         max77663_irq_exit(chip);
1294         mutex_destroy(&chip->io_lock);
1295         max77663_chip = NULL;
1296         kfree(chip);
1297 out:
1298         return ret;
1299 }
1300
1301 static int __devexit max77663_remove(struct i2c_client *client)
1302 {
1303         struct max77663_chip *chip = i2c_get_clientdata(client);
1304
1305         mfd_remove_devices(chip->dev);
1306         max77663_debugfs_exit(chip);
1307         max77663_irq_exit(chip);
1308         max77663_gpio_exit(chip);
1309         mutex_destroy(&chip->io_lock);
1310         max77663_chip = NULL;
1311         kfree(chip);
1312
1313         return 0;
1314 }
1315
1316 #ifdef CONFIG_PM
1317 static int max77663_suspend(struct device *dev)
1318 {
1319         struct i2c_client *client = to_i2c_client(dev);
1320         struct max77663_chip *chip = i2c_get_clientdata(client);
1321         int ret;
1322
1323         if (client->irq)
1324                 disable_irq(client->irq);
1325
1326         /* Enable sleep that AP can be placed into sleep mode
1327          * by pulling EN1 low */
1328         ret = max77663_set_bits(chip->dev, MAX77663_REG_ONOFF_CFG1,
1329                                  ONOFF_SLPEN_MASK, ONOFF_SLPEN_MASK, 0);
1330         if (ret < 0)
1331                 dev_err(&client->dev,
1332                         "suspend: Failed to set ONOFF_CFG1(0x%02x)\n",
1333                         MAX77663_REG_ONOFF_CFG1);
1334
1335         return 0;
1336 }
1337
1338 static int max77663_resume(struct device *dev)
1339 {
1340         struct i2c_client *client = to_i2c_client(dev);
1341
1342         if (client->irq)
1343                 enable_irq(client->irq);
1344
1345         return 0;
1346 }
1347 #else
1348 #define max77663_suspend      NULL
1349 #define max77663_resume       NULL
1350 #endif /* CONFIG_PM */
1351
1352 static const struct i2c_device_id max77663_id[] = {
1353         {"max77663", 0},
1354         {},
1355 };
1356 MODULE_DEVICE_TABLE(i2c, max77663_id);
1357
1358 static const struct dev_pm_ops max77663_pm = {
1359         .suspend = max77663_suspend,
1360         .resume = max77663_resume,
1361 };
1362
1363 static struct i2c_driver max77663_driver = {
1364         .driver = {
1365                 .name = "max77663",
1366                 .owner = THIS_MODULE,
1367                 .pm = &max77663_pm,
1368         },
1369         .probe = max77663_probe,
1370         .remove = __devexit_p(max77663_remove),
1371         .id_table = max77663_id,
1372 };
1373
1374 static int __init max77663_init(void)
1375 {
1376         return i2c_add_driver(&max77663_driver);
1377 }
1378 arch_initcall(max77663_init);
1379
1380 static void __exit max77663_exit(void)
1381 {
1382         i2c_del_driver(&max77663_driver);
1383 }
1384 module_exit(max77663_exit);
1385
1386 MODULE_LICENSE("GPL v2");
1387 MODULE_DESCRIPTION("MAX77663 Multi Function Device Core Driver");
1388 MODULE_VERSION("1.0");