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