Merge branch 'pcmcia' of git://git.kernel.org/pub/scm/linux/kernel/git/brodo/pcmcia
[linux-2.6-microblaze.git] / drivers / gpio / gpio-arizona.c
1 /*
2  * gpiolib support for Wolfson Arizona class devices
3  *
4  * Copyright 2012 Wolfson Microelectronics PLC.
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7  *
8  *  This program is free software; you can redistribute  it and/or modify it
9  *  under  the terms of  the GNU General  Public License as published by the
10  *  Free Software Foundation;  either version 2 of the  License, or (at your
11  *  option) any later version.
12  *
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/gpio/driver.h>
19 #include <linux/platform_device.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/seq_file.h>
22
23 #include <linux/mfd/arizona/core.h>
24 #include <linux/mfd/arizona/pdata.h>
25 #include <linux/mfd/arizona/registers.h>
26
27 struct arizona_gpio {
28         struct arizona *arizona;
29         struct gpio_chip gpio_chip;
30 };
31
32 static int arizona_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
33 {
34         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
35         struct arizona *arizona = arizona_gpio->arizona;
36         bool persistent = gpiochip_line_is_persistent(chip, offset);
37         bool change;
38         int ret;
39
40         ret = regmap_update_bits_check(arizona->regmap,
41                                        ARIZONA_GPIO1_CTRL + offset,
42                                        ARIZONA_GPN_DIR, ARIZONA_GPN_DIR,
43                                        &change);
44         if (ret < 0)
45                 return ret;
46
47         if (change && persistent) {
48                 pm_runtime_mark_last_busy(chip->parent);
49                 pm_runtime_put_autosuspend(chip->parent);
50         }
51
52         return 0;
53 }
54
55 static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset)
56 {
57         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
58         struct arizona *arizona = arizona_gpio->arizona;
59         unsigned int reg, val;
60         int ret;
61
62         reg = ARIZONA_GPIO1_CTRL + offset;
63         ret = regmap_read(arizona->regmap, reg, &val);
64         if (ret < 0)
65                 return ret;
66
67         /* Resume to read actual registers for input pins */
68         if (val & ARIZONA_GPN_DIR) {
69                 ret = pm_runtime_get_sync(chip->parent);
70                 if (ret < 0) {
71                         dev_err(chip->parent, "Failed to resume: %d\n", ret);
72                         return ret;
73                 }
74
75                 /* Register is cached, drop it to ensure a physical read */
76                 ret = regcache_drop_region(arizona->regmap, reg, reg);
77                 if (ret < 0) {
78                         dev_err(chip->parent, "Failed to drop cache: %d\n",
79                                 ret);
80                         return ret;
81                 }
82
83                 ret = regmap_read(arizona->regmap, reg, &val);
84                 if (ret < 0)
85                         return ret;
86
87                 pm_runtime_mark_last_busy(chip->parent);
88                 pm_runtime_put_autosuspend(chip->parent);
89         }
90
91         if (val & ARIZONA_GPN_LVL)
92                 return 1;
93         else
94                 return 0;
95 }
96
97 static int arizona_gpio_direction_out(struct gpio_chip *chip,
98                                      unsigned offset, int value)
99 {
100         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
101         struct arizona *arizona = arizona_gpio->arizona;
102         bool persistent = gpiochip_line_is_persistent(chip, offset);
103         unsigned int val;
104         int ret;
105
106         ret = regmap_read(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, &val);
107         if (ret < 0)
108                 return ret;
109
110         if ((val & ARIZONA_GPN_DIR) && persistent) {
111                 ret = pm_runtime_get_sync(chip->parent);
112                 if (ret < 0) {
113                         dev_err(chip->parent, "Failed to resume: %d\n", ret);
114                         return ret;
115                 }
116         }
117
118         if (value)
119                 value = ARIZONA_GPN_LVL;
120
121         return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
122                                   ARIZONA_GPN_DIR | ARIZONA_GPN_LVL, value);
123 }
124
125 static void arizona_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
126 {
127         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
128         struct arizona *arizona = arizona_gpio->arizona;
129
130         if (value)
131                 value = ARIZONA_GPN_LVL;
132
133         regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
134                            ARIZONA_GPN_LVL, value);
135 }
136
137 static const struct gpio_chip template_chip = {
138         .label                  = "arizona",
139         .owner                  = THIS_MODULE,
140         .direction_input        = arizona_gpio_direction_in,
141         .get                    = arizona_gpio_get,
142         .direction_output       = arizona_gpio_direction_out,
143         .set                    = arizona_gpio_set,
144         .can_sleep              = true,
145 };
146
147 static int arizona_gpio_probe(struct platform_device *pdev)
148 {
149         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
150         struct arizona_pdata *pdata = dev_get_platdata(arizona->dev);
151         struct arizona_gpio *arizona_gpio;
152         int ret;
153
154         arizona_gpio = devm_kzalloc(&pdev->dev, sizeof(*arizona_gpio),
155                                     GFP_KERNEL);
156         if (!arizona_gpio)
157                 return -ENOMEM;
158
159         arizona_gpio->arizona = arizona;
160         arizona_gpio->gpio_chip = template_chip;
161         arizona_gpio->gpio_chip.parent = &pdev->dev;
162 #ifdef CONFIG_OF_GPIO
163         arizona_gpio->gpio_chip.of_node = arizona->dev->of_node;
164 #endif
165
166         switch (arizona->type) {
167         case WM5102:
168         case WM5110:
169         case WM8280:
170         case WM8997:
171         case WM8998:
172         case WM1814:
173                 arizona_gpio->gpio_chip.ngpio = 5;
174                 break;
175         case WM1831:
176         case CS47L24:
177                 arizona_gpio->gpio_chip.ngpio = 2;
178                 break;
179         default:
180                 dev_err(&pdev->dev, "Unknown chip variant %d\n",
181                         arizona->type);
182                 return -EINVAL;
183         }
184
185         if (pdata && pdata->gpio_base)
186                 arizona_gpio->gpio_chip.base = pdata->gpio_base;
187         else
188                 arizona_gpio->gpio_chip.base = -1;
189
190         pm_runtime_enable(&pdev->dev);
191
192         ret = devm_gpiochip_add_data(&pdev->dev, &arizona_gpio->gpio_chip,
193                                      arizona_gpio);
194         if (ret < 0) {
195                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
196                         ret);
197                 return ret;
198         }
199
200         return 0;
201 }
202
203 static struct platform_driver arizona_gpio_driver = {
204         .driver.name    = "arizona-gpio",
205         .probe          = arizona_gpio_probe,
206 };
207
208 module_platform_driver(arizona_gpio_driver);
209
210 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
211 MODULE_DESCRIPTION("GPIO interface for Arizona devices");
212 MODULE_LICENSE("GPL");
213 MODULE_ALIAS("platform:arizona-gpio");