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