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