gpio: tegra: configure debouncing of key only for T210
[linux-3.10.git] / drivers / gpio / gpio-max77663.c
1 /*
2  * MAXIM MAX77663 GPIO driver
3  *
4  * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
5  * Author: Laxman dewangan <ldewangan@nvidia.com>
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms and conditions of the GNU General Public License,
9  * version 2, as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <linux/debugfs.h>
21 #include <linux/errno.h>
22 #include <linux/gpio.h>
23 #include <linux/interrupt.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/mfd/max77663-core.h>
27 #include <linux/of_device.h>
28 #include <linux/platform_device.h>
29 #include <linux/seq_file.h>
30
31 /* GPIO control registers */
32 #define MAX77663_REG_GPIO_IRQ           0x0A
33 #define MAX77663_REG_GPIO_CTRL0         0x36
34 #define MAX77663_REG_GPIO_CTRL1         0x37
35 #define MAX77663_REG_GPIO_CTRL2         0x38
36 #define MAX77663_REG_GPIO_CTRL3         0x39
37 #define MAX77663_REG_GPIO_CTRL4         0x3A
38 #define MAX77663_REG_GPIO_CTRL5         0x3B
39 #define MAX77663_REG_GPIO_CTRL6         0x3C
40 #define MAX77663_REG_GPIO_CTRL7         0x3D
41 #define MAX77663_REG_GPIO_PU            0x3E
42 #define MAX77663_REG_GPIO_PD            0x3F
43 #define MAX77663_REG_GPIO_ALT           0x40
44
45 #define GPIO_REG_ADDR(offset) (MAX77663_REG_GPIO_CTRL0 + offset)
46
47 #define GPIO_CTRL_DBNC_MASK             (3 << 6)
48 #define GPIO_CTRL_DBNC_SHIFT            6
49 #define GPIO_CTRL_REFE_IRQ_MASK         (3 << 4)
50 #define GPIO_CTRL_REFE_IRQ_SHIFT        4
51 #define GPIO_CTRL_DOUT_MASK             (1 << 3)
52 #define GPIO_CTRL_DOUT_SHIFT            3
53 #define GPIO_CTRL_DIN_MASK              (1 << 2)
54 #define GPIO_CTRL_DIN_SHIFT             2
55 #define GPIO_CTRL_DIR_MASK              (1 << 1)
56 #define GPIO_CTRL_DIR_SHIFT             1
57 #define GPIO_CTRL_OUT_DRV_MASK          (1 << 0)
58 #define GPIO_CTRL_OUT_DRV_SHIFT         0
59 #define GPIO_DBNC_NONE                  0
60 #define GPIO_DBNC_8MS                   1
61 #define GPIO_DBNC_16MS                  2
62 #define GPIO_DBNC_32MS                  3
63
64 #define MAX77663_GPIO_IRQ(n) (MAX77663_IRQ_GPIO0 + n)
65
66 #define GPIO_REFE_IRQ_NONE              0
67 #define GPIO_REFE_IRQ_EDGE_FALLING      1
68 #define GPIO_REFE_IRQ_EDGE_RISING       2
69 #define GPIO_REFE_IRQ_EDGE_BOTH         3
70
71 struct max77663_gpio {
72         struct gpio_chip        gpio_chip;
73         struct irq_chip         irq_chip;
74         struct device           *parent;
75         struct device           *dev;
76         struct                  mutex irq_lock;
77         int                     gpio_irq;
78         int                     irq_base;
79         int                     gpio_base;
80         unsigned int            trigger_type[MAX77663_GPIO_NR];
81         u8                      cache_gpio_ctrl[MAX77663_GPIO_NR];
82         u8                      cache_gpio_pu;
83         u8                      cache_gpio_pd;
84         u8                      cache_gpio_alt;
85 };
86
87 static struct max77663_gpio *max77663_gpio_chip;
88
89 static inline struct max77663_gpio *to_max77663_gpio(struct gpio_chip *gpio)
90 {
91         return container_of(gpio, struct max77663_gpio, gpio_chip);
92 }
93
94 static inline int max77663_cache_write(struct device *dev, u8 addr, u8 mask,
95                         u8 val, u8 *cache)
96 {
97         u8 new_val;
98         int ret;
99
100         new_val = (*cache & ~mask) | (val & mask);
101         if (*cache != new_val) {
102                 ret = max77663_write(dev, addr, &new_val, 1, 0);
103                 if (ret < 0)
104                         return ret;
105                 *cache = new_val;
106         }
107         return 0;
108 }
109
110 static int max77663_gpio_set_pull_up(struct max77663_gpio *max77663_gpio,
111                 int offset, int pull_up)
112 {
113         u8 val = 0;
114
115         if ((offset < MAX77663_GPIO0) || (MAX77663_GPIO7 < offset))
116                 return -EINVAL;
117
118         if (pull_up == GPIO_PU_ENABLE)
119                 val = (1 << offset);
120
121         return max77663_cache_write(max77663_gpio->parent, MAX77663_REG_GPIO_PU,
122                         (1 << offset), val, &max77663_gpio->cache_gpio_pu);
123 }
124
125 static int max77663_gpio_set_pull_down(struct max77663_gpio *max77663_gpio,
126                 int offset, int pull_down)
127 {
128         u8 val = 0;
129
130         if ((offset < MAX77663_GPIO0) || (MAX77663_GPIO7 < offset))
131                 return -EINVAL;
132
133         if (pull_down == GPIO_PD_ENABLE)
134                 val = (1 << offset);
135
136         return max77663_cache_write(max77663_gpio->parent, MAX77663_REG_GPIO_PD,
137                         (1 << offset), val, &max77663_gpio->cache_gpio_pd);
138 }
139
140 static inline int max77663_gpio_is_alternate(
141                 struct max77663_gpio *max77663_gpio, int offset)
142 {
143         return (max77663_gpio->cache_gpio_alt & (1 << offset)) ? 1 : 0;
144 }
145
146 static int max77663_gpio_config_alternate(int gpio, int alternate)
147 {
148         struct max77663_gpio *max77663_gpio = max77663_gpio_chip;
149         u8 val = 0;
150         int ret = 0;
151
152         if (!max77663_gpio)
153                 return -ENXIO;
154
155         gpio -= max77663_gpio->gpio_base;
156         if ((gpio < MAX77663_GPIO0) || (MAX77663_GPIO7 < gpio))
157                 return -EINVAL;
158
159         if (alternate == GPIO_ALT_ENABLE) {
160                 val = (1 << gpio);
161                 if (gpio == MAX77663_GPIO7) {
162                         ret = max77663_gpio_set_pull_up(max77663_gpio, gpio, 0);
163                         if (ret < 0)
164                                 return ret;
165
166                         ret = max77663_gpio_set_pull_down(max77663_gpio,
167                                                 gpio, 0);
168                         if (ret < 0)
169                                 return ret;
170                 }
171         }
172
173         return max77663_cache_write(max77663_gpio->parent,
174                         MAX77663_REG_GPIO_ALT,
175                         (1 << gpio), val, &max77663_gpio->cache_gpio_alt);
176 }
177
178 static int max77663_gpio_dir_input(struct gpio_chip *gpio, unsigned offset)
179 {
180         struct max77663_gpio *max77663_gpio = to_max77663_gpio(gpio);
181
182         if (max77663_gpio_is_alternate(max77663_gpio, offset)) {
183                 dev_warn(max77663_gpio->dev,
184                         "gpio%u is used as alternate mode\n", offset);
185                 return 0;
186         }
187
188         return max77663_cache_write(max77663_gpio->parent,
189                                 GPIO_REG_ADDR(offset),
190                                 GPIO_CTRL_DIR_MASK, GPIO_CTRL_DIR_MASK,
191                                 &max77663_gpio->cache_gpio_ctrl[offset]);
192 }
193
194 static int max77663_gpio_get(struct gpio_chip *gpio, unsigned offset)
195 {
196         struct max77663_gpio *max77663_gpio = to_max77663_gpio(gpio);
197         u8 val;
198         int ret;
199
200         if (max77663_gpio_is_alternate(max77663_gpio, offset)) {
201                 dev_warn(max77663_gpio->dev,
202                         "gpio%u is used as alternate mode\n", offset);
203                 return 0;
204         }
205
206         ret = max77663_read(max77663_gpio->parent, GPIO_REG_ADDR(offset),
207                         &val, 1, 0);
208         if (ret < 0)
209                 return ret;
210
211         max77663_gpio->cache_gpio_ctrl[offset] = val;
212         return (val & GPIO_CTRL_DIN_MASK) >> GPIO_CTRL_DIN_SHIFT;
213 }
214
215 static int max77663_gpio_dir_output(struct gpio_chip *gpio, unsigned offset,
216                                 int value)
217 {
218         struct max77663_gpio *max77663_gpio = to_max77663_gpio(gpio);
219         u8 mask = GPIO_CTRL_DIR_MASK | GPIO_CTRL_DOUT_MASK;
220         u8 val = (value ? 1 : 0) << GPIO_CTRL_DOUT_SHIFT;
221
222         if (max77663_gpio_is_alternate(max77663_gpio, offset)) {
223                 dev_warn(max77663_gpio->dev,
224                         "gpio%u is used as alternate mode\n", offset);
225                 return 0;
226         }
227
228         return max77663_cache_write(max77663_gpio->parent,
229                         GPIO_REG_ADDR(offset), mask, val,
230                         &max77663_gpio->cache_gpio_ctrl[offset]);
231 }
232
233 static int max77663_gpio_set_debounce(struct gpio_chip *gpio,
234                 unsigned offset, unsigned debounce)
235 {
236         struct max77663_gpio *max77663_gpio = to_max77663_gpio(gpio);
237         u8 shift = GPIO_CTRL_DBNC_SHIFT;
238         u8 val = 0;
239
240         if (max77663_gpio_is_alternate(max77663_gpio, offset)) {
241                 dev_warn(max77663_gpio->dev,
242                         "gpio%u is used as alternate mode\n", offset);
243                 return 0;
244         }
245
246         if (debounce == 0)
247                 val = 0;
248         else if ((0 < debounce) && (debounce <= 8))
249                 val = (GPIO_DBNC_8MS << shift);
250         else if ((8 < debounce) && (debounce <= 16))
251                 val = (GPIO_DBNC_16MS << shift);
252         else if ((16 < debounce) && (debounce <= 32))
253                 val = (GPIO_DBNC_32MS << shift);
254         else
255                 return -EINVAL;
256
257         return max77663_cache_write(max77663_gpio->parent,
258                         GPIO_REG_ADDR(offset),
259                         GPIO_CTRL_DBNC_MASK, val,
260                         &max77663_gpio->cache_gpio_ctrl[offset]);
261 }
262
263 static void max77663_gpio_set(struct gpio_chip *gpio, unsigned offset,
264                         int value)
265 {
266         struct max77663_gpio *max77663_gpio = to_max77663_gpio(gpio);
267         u8 val = (value ? 1 : 0) << GPIO_CTRL_DOUT_SHIFT;
268
269         if (max77663_gpio_is_alternate(max77663_gpio, offset)) {
270                 dev_warn(max77663_gpio->dev,
271                         "gpio%u is used as alternate mode\n", offset);
272                 return;
273         }
274
275         max77663_cache_write(max77663_gpio->parent, GPIO_REG_ADDR(offset),
276                         GPIO_CTRL_DOUT_MASK, val,
277                         &max77663_gpio->cache_gpio_ctrl[offset]);
278 }
279
280 static int max77663_gpio_to_irq(struct gpio_chip *gpio, unsigned offset)
281 {
282         struct max77663_gpio *max77663_gpio = to_max77663_gpio(gpio);
283
284         return max77663_gpio->irq_base + offset;
285 }
286
287 static int max77663_gpio_set_config(struct max77663_gpio *max77663_gpio,
288                                 struct max77663_gpio_config *gpio_cfg)
289 {
290         int gpio = gpio_cfg->gpio;
291         u8 val = 0, mask = 0;
292         int ret = 0;
293
294         if ((gpio < MAX77663_GPIO0) || (MAX77663_GPIO7 < gpio))
295                 return -EINVAL;
296
297         if (gpio_cfg->pull_up != GPIO_PU_DEF) {
298                 ret = max77663_gpio_set_pull_up(max77663_gpio, gpio,
299                                         gpio_cfg->pull_up);
300                 if (ret < 0) {
301                         dev_err(max77663_gpio->dev,
302                                 "Failed to set gpio%d pull-up\n", gpio);
303                         return ret;
304                 }
305         }
306
307         if (gpio_cfg->pull_down != GPIO_PD_DEF) {
308                 ret = max77663_gpio_set_pull_down(max77663_gpio, gpio,
309                                         gpio_cfg->pull_down);
310                 if (ret < 0) {
311                         dev_err(max77663_gpio->dev,
312                                 "Failed to set gpio%d pull-down\n", gpio);
313                         return ret;
314                 }
315         }
316
317         if (gpio_cfg->dir != GPIO_DIR_DEF) {
318                 mask = GPIO_CTRL_DIR_MASK;
319                 if (gpio_cfg->dir == GPIO_DIR_IN) {
320                         val |= GPIO_CTRL_DIR_MASK;
321                 } else {
322                         if (gpio_cfg->dout != GPIO_DOUT_DEF) {
323                                 mask |= GPIO_CTRL_DOUT_MASK;
324                                 if (gpio_cfg->dout == GPIO_DOUT_HIGH)
325                                         val |= GPIO_CTRL_DOUT_MASK;
326                         }
327
328                         if (gpio_cfg->out_drv != GPIO_OUT_DRV_DEF) {
329                                 mask |= GPIO_CTRL_OUT_DRV_MASK;
330                                 if (gpio_cfg->out_drv == GPIO_OUT_DRV_PUSH_PULL)
331                                         val |= GPIO_CTRL_OUT_DRV_MASK;
332                         }
333                 }
334
335                 ret = max77663_cache_write(max77663_gpio->parent,
336                                 GPIO_REG_ADDR(gpio), mask,
337                                 val, &max77663_gpio->cache_gpio_ctrl[gpio]);
338                 if (ret < 0) {
339                         dev_err(max77663_gpio->dev,
340                                 "Failed to set gpio%d control\n", gpio);
341                         return ret;
342                 }
343         }
344
345         if (gpio_cfg->alternate != GPIO_ALT_DEF) {
346                 ret = max77663_gpio_config_alternate(
347                                 gpio + max77663_gpio->gpio_base,
348                                 gpio_cfg->alternate);
349                 if (ret < 0) {
350                         dev_err(max77663_gpio->dev,
351                                 "Failed to set gpio%d alternate\n", gpio);
352                         return ret;
353                 }
354         }
355
356         return 0;
357 }
358
359 static void max77663_gpio_irq_lock(struct irq_data *data)
360 {
361         struct max77663_gpio *max77663_gpio = irq_data_get_irq_chip_data(data);
362
363         mutex_lock(&max77663_gpio->irq_lock);
364 }
365
366 static void max77663_gpio_irq_sync_unlock(struct irq_data *data)
367 {
368         struct max77663_gpio *max77663_gpio = irq_data_get_irq_chip_data(data);
369
370         mutex_unlock(&max77663_gpio->irq_lock);
371 }
372
373 static void max77663_gpio_irq_mask(struct irq_data *data)
374 {
375         struct max77663_gpio *max77663_gpio = irq_data_get_irq_chip_data(data);
376         int offset = data->irq - max77663_gpio->irq_base;
377         int ret;
378
379         ret = max77663_cache_write(max77663_gpio->parent,
380                         GPIO_REG_ADDR(offset), 0x30, 0x0,
381                         &max77663_gpio->cache_gpio_ctrl[offset]);
382         if (ret < 0)
383                 dev_err(max77663_gpio->dev,
384                         "gpio register write failed, e %d\n", ret);
385 }
386
387 static void max77663_gpio_irq_unmask(struct irq_data *data)
388 {
389         struct max77663_gpio *max77663_gpio = irq_data_get_irq_chip_data(data);
390         int irq_mask = GPIO_REFE_IRQ_EDGE_FALLING << GPIO_CTRL_REFE_IRQ_SHIFT;
391         int offset = data->irq - max77663_gpio->irq_base;
392         int ret;
393
394         if (max77663_gpio->trigger_type[offset])
395                 irq_mask = max77663_gpio->trigger_type[offset];
396         ret = max77663_cache_write(max77663_gpio->parent,
397                         GPIO_REG_ADDR(offset), 0x30, irq_mask,
398                         &max77663_gpio->cache_gpio_ctrl[offset]);
399         if (ret < 0)
400                 dev_err(max77663_gpio->dev,
401                         "gpio register write failed, e %d\n", ret);
402 }
403
404 static int max77663_irq_gpio_set_type(struct irq_data *data, unsigned int type)
405 {
406         struct max77663_gpio *max77663_gpio = irq_data_get_irq_chip_data(data);
407         unsigned offset = data->irq - max77663_gpio->irq_base;
408         u8 val;
409         int ret;
410
411         switch (type) {
412         case IRQ_TYPE_NONE:
413         case IRQ_TYPE_EDGE_FALLING:
414                 val = (GPIO_REFE_IRQ_EDGE_FALLING << GPIO_CTRL_REFE_IRQ_SHIFT);
415                 break;
416
417         case IRQ_TYPE_EDGE_RISING:
418                 val = (GPIO_REFE_IRQ_EDGE_RISING << GPIO_CTRL_REFE_IRQ_SHIFT);
419                 break;
420
421         case IRQ_TYPE_EDGE_BOTH:
422                 val = (GPIO_REFE_IRQ_EDGE_BOTH << GPIO_CTRL_REFE_IRQ_SHIFT);
423                 break;
424
425         default:
426                 return -EINVAL;
427         }
428
429         max77663_gpio->trigger_type[offset] = type;
430         ret = max77663_cache_write(max77663_gpio->parent,
431                         GPIO_REG_ADDR(offset), 0x30, val,
432                         &max77663_gpio->cache_gpio_ctrl[offset]);
433         if (ret < 0)
434                 dev_err(max77663_gpio->dev,
435                                 "gpio register write failed, e %d\n", ret);
436
437         return ret;
438 }
439
440 static irqreturn_t max77663_gpio_isr(int irq, void *data)
441 {
442         struct max77663_gpio *max77663_gpio = data;
443         int ret;
444         int i;
445         u8 val;
446
447         ret = max77663_read(max77663_gpio->dev, MAX77663_REG_GPIO_IRQ,
448                                         &val, 1, 0);
449         if (ret < 0) {
450                 dev_err(max77663_gpio->dev,
451                         "gpio irq reg read Failed %d\n", ret);
452                 return IRQ_NONE;
453         }
454
455         for (i = 0; i < MAX77663_GPIO_NR; ++i) {
456                 if (val & (1 << i))
457                         handle_nested_irq(max77663_gpio->irq_base + i);
458         }
459         return IRQ_HANDLED;
460 }
461
462 static int max77663_gpio_irq_init(struct max77663_gpio *max77663_gpio,
463                 struct max77663_platform_data *pdata)
464 {
465         int i;
466         u8 val;
467         int ret;
468
469         max77663_gpio->irq_base = pdata->irq_base + MAX77663_GPIO_IRQ(0);
470         max77663_gpio->irq_chip.name = "max77663-gpio-irq";
471         max77663_gpio->irq_chip.irq_mask = max77663_gpio_irq_mask;
472         max77663_gpio->irq_chip.irq_unmask = max77663_gpio_irq_unmask;
473         max77663_gpio->irq_chip.irq_set_type = max77663_irq_gpio_set_type;
474         max77663_gpio->irq_chip.irq_bus_lock = max77663_gpio_irq_lock;
475         max77663_gpio->irq_chip.irq_bus_sync_unlock =
476                                         max77663_gpio_irq_sync_unlock;
477
478         for (i = 0; i < MAX77663_GPIO_NR; ++i) {
479                 int irq = max77663_gpio->irq_base + i;
480                 irq_set_chip_data(irq, max77663_gpio);
481                 irq_set_chip_and_handler(irq, &max77663_gpio->irq_chip,
482                                         handle_simple_irq);
483                 irq_set_nested_thread(irq, 1);
484 #ifdef CONFIG_ARM
485                 set_irq_flags(irq, IRQF_VALID);
486 #else
487                 irq_set_noprobe(irq);
488 #endif
489         }
490
491         /* IRQ_LVL2_GPIO is rea on clear */
492         max77663_read(max77663_gpio->parent, MAX77663_REG_GPIO_IRQ, &val, 1, 0);
493
494         ret = request_threaded_irq(max77663_gpio->gpio_irq, NULL,
495                         max77663_gpio_isr, IRQF_ONESHOT, "max77663-gpio-irq",
496                         max77663_gpio);
497         if (ret < 0)
498                 dev_err(max77663_gpio->dev, "Failed to request irq %d, e %d\n",
499                         max77663_gpio->gpio_irq, ret);
500         return ret;
501 }
502
503 static void max77663_gpio_irq_remove(struct max77663_gpio *max77663_gpio)
504 {
505         int gpio;
506
507         for (gpio = 0; gpio < MAX77663_GPIO_NR; ++gpio) {
508                 int irq = max77663_gpio->irq_base + gpio;
509 #ifdef CONFIG_ARM
510                 set_irq_flags(irq, 0);
511 #endif
512                 irq_set_chip_and_handler(irq, NULL, NULL);
513                 irq_set_chip_data(irq, NULL);
514         }
515         free_irq(max77663_gpio->gpio_irq, max77663_gpio);
516 }
517
518 static int max77663_gpio_init_regs(struct max77663_gpio *max77663_gpio,
519                 struct max77663_platform_data *pdata)
520 {
521         int ret;
522         int i;
523
524         ret = max77663_read(max77663_gpio->parent, MAX77663_REG_GPIO_CTRL0,
525                         &max77663_gpio->cache_gpio_ctrl, MAX77663_GPIO_NR, 0);
526         if (ret < 0) {
527                 dev_err(max77663_gpio->dev, "Failed to get gpio control\n");
528                 return ret;
529         }
530
531         ret = max77663_read(max77663_gpio->parent, MAX77663_REG_GPIO_PU,
532                         &max77663_gpio->cache_gpio_pu, 1, 0);
533         if (ret < 0) {
534                 dev_err(max77663_gpio->dev, "Failed to get gpio pull-up\n");
535                 return ret;
536         }
537
538         ret = max77663_read(max77663_gpio->parent, MAX77663_REG_GPIO_PD,
539                         &max77663_gpio->cache_gpio_pd, 1, 0);
540         if (ret < 0) {
541                 dev_err(max77663_gpio->dev, "Failed to get gpio pull-down\n");
542                 return ret;
543         }
544
545         ret = max77663_read(max77663_gpio->parent, MAX77663_REG_GPIO_ALT,
546                         &max77663_gpio->cache_gpio_alt, 1, 0);
547         if (ret < 0) {
548                 dev_err(max77663_gpio->dev, "Failed to get gpio alternate\n");
549                 return ret;
550         }
551
552         for (i = 0; i < pdata->num_gpio_cfgs; i++) {
553                 ret = max77663_gpio_set_config(max77663_gpio,
554                                         &pdata->gpio_cfgs[i]);
555                 if (ret < 0) {
556                         dev_err(max77663_gpio->dev,
557                                 "Failed to set gpio config\n");
558                         return ret;
559                 }
560         }
561
562         return 0;
563 }
564
565 static int max77663_gpio_probe(struct platform_device *pdev)
566 {
567         struct max77663_platform_data *pdata;
568         struct max77663_gpio *max77663_gpio;
569         int ret;
570         int gpio_irq;
571
572         pdata = dev_get_platdata(pdev->dev.parent);
573         if (!pdata) {
574                 dev_err(&pdev->dev, "Platform data not found\n");
575                 return -ENODEV;
576         }
577
578         gpio_irq = platform_get_irq(pdev, 0);
579         if (gpio_irq <= 0) {
580                 dev_err(&pdev->dev, "Gpio interrupt is not available\n");
581                 return -ENODEV;
582         }
583
584         max77663_gpio = devm_kzalloc(&pdev->dev,
585                                 sizeof(*max77663_gpio), GFP_KERNEL);
586         if (!max77663_gpio) {
587                 dev_err(&pdev->dev, "Could not allocate max77663_gpio\n");
588                 return -ENOMEM;
589         }
590
591         mutex_init(&max77663_gpio->irq_lock);
592         max77663_gpio->parent = pdev->dev.parent;
593         max77663_gpio->dev = &pdev->dev;
594         max77663_gpio->gpio_irq = gpio_irq;
595
596         max77663_gpio->gpio_chip.owner = THIS_MODULE;
597         max77663_gpio->gpio_chip.label = pdev->name;
598         max77663_gpio->gpio_chip.dev = &pdev->dev;
599         max77663_gpio->gpio_chip.direction_input = max77663_gpio_dir_input;
600         max77663_gpio->gpio_chip.get = max77663_gpio_get;
601         max77663_gpio->gpio_chip.direction_output = max77663_gpio_dir_output;
602         max77663_gpio->gpio_chip.set_debounce = max77663_gpio_set_debounce;
603         max77663_gpio->gpio_chip.set = max77663_gpio_set;
604         max77663_gpio->gpio_chip.to_irq = max77663_gpio_to_irq;
605         max77663_gpio->gpio_chip.ngpio = MAX77663_GPIO_NR;
606         max77663_gpio->gpio_chip.can_sleep = 1;
607         if (pdata->gpio_base)
608                 max77663_gpio->gpio_chip.base = pdata->gpio_base;
609         else
610                 max77663_gpio->gpio_chip.base = -1;
611
612         max77663_gpio_chip = max77663_gpio;
613         ret = max77663_gpio_init_regs(max77663_gpio, pdata);
614         if (ret < 0) {
615                 dev_err(&pdev->dev, "gpio_init regs failed\n");
616                 return ret;
617         }
618
619         ret = gpiochip_add(&max77663_gpio->gpio_chip);
620         if (ret < 0) {
621                 dev_err(&pdev->dev, "gpio_init: Failed to add gpiomax77663_gpio\n");
622                 return ret;
623         }
624         max77663_gpio->gpio_base = max77663_gpio->gpio_chip.base;
625
626         ret = max77663_gpio_irq_init(max77663_gpio, pdata);
627         if (ret < 0) {
628                 dev_err(&pdev->dev, "gpio irq init failed, e %d\n", ret);
629                 goto fail;
630         }
631
632         platform_set_drvdata(pdev, max77663_gpio);
633         return 0;
634
635 fail:
636         if (gpiochip_remove(&max77663_gpio->gpio_chip))
637                 dev_err(&pdev->dev, "%s gpiochip_remove failed\n", __func__);
638
639         return ret;
640 }
641
642 static int max77663_gpio_remove(struct platform_device *pdev)
643 {
644         struct max77663_gpio *max77663_gpio = platform_get_drvdata(pdev);
645
646         max77663_gpio_irq_remove(max77663_gpio);
647         max77663_gpio_chip = 0;
648
649         return gpiochip_remove(&max77663_gpio->gpio_chip);
650 }
651
652 static struct platform_driver max77663_gpio_driver = {
653         .driver.name    = "max77663-gpio",
654         .driver.owner   = THIS_MODULE,
655         .probe          = max77663_gpio_probe,
656         .remove         = max77663_gpio_remove,
657 };
658
659 static int __init max77663_gpio_init(void)
660 {
661         return platform_driver_register(&max77663_gpio_driver);
662 }
663 subsys_initcall(max77663_gpio_init);
664
665 static void __exit max77663_gpio_exit(void)
666 {
667         platform_driver_unregister(&max77663_gpio_driver);
668 }
669 module_exit(max77663_gpio_exit);
670
671 MODULE_ALIAS("platform:max77663-gpio");
672 MODULE_DESCRIPTION("GPIO interface for MAX77663 PMIC");
673 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
674 MODULE_LICENSE("GPL v2");