Merge tag 'for-3.9-rc1' of git://gitorious.org/linux-pwm/linux-pwm
[~shefty/rdma-dev.git] / drivers / gpio / gpio-vt8500.c
1 /* drivers/gpio/gpio-vt8500.c
2  *
3  * Copyright (C) 2012 Tony Prisk <linux@prisktech.co.nz>
4  * Based on arch/arm/mach-vt8500/gpio.c:
5  * - Copyright (C) 2010 Alexey Charkov <alchark@gmail.com>
6  *
7  * This software is licensed under the terms of the GNU General Public
8  * License version 2, as published by the Free Software Foundation, and
9  * may be copied, distributed, and modified under those terms.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  */
17
18 #include <linux/module.h>
19 #include <linux/err.h>
20 #include <linux/io.h>
21 #include <linux/gpio.h>
22 #include <linux/platform_device.h>
23 #include <linux/bitops.h>
24 #include <linux/of.h>
25 #include <linux/of_address.h>
26 #include <linux/of_irq.h>
27 #include <linux/of_device.h>
28
29 /*
30         We handle GPIOs by bank, each bank containing up to 32 GPIOs covered
31         by one set of registers (although not all may be valid).
32
33         Because different SoC's have different register offsets, we pass the
34         register offsets as data in vt8500_gpio_dt_ids[].
35
36         A value of NO_REG is used to indicate that this register is not
37         supported. Only used for ->en at the moment.
38 */
39
40 #define NO_REG  0xFFFF
41
42 /*
43  * struct vt8500_gpio_bank_regoffsets
44  * @en: offset to enable register of the bank
45  * @dir: offset to direction register of the bank
46  * @data_out: offset to the data out register of the bank
47  * @data_in: offset to the data in register of the bank
48  * @ngpio: highest valid pin in this bank
49  */
50
51 struct vt8500_gpio_bank_regoffsets {
52         unsigned int    en;
53         unsigned int    dir;
54         unsigned int    data_out;
55         unsigned int    data_in;
56         unsigned char   ngpio;
57 };
58
59 struct vt8500_gpio_data {
60         unsigned int                            num_banks;
61         struct vt8500_gpio_bank_regoffsets      banks[];
62 };
63
64 #define VT8500_BANK(__en, __dir, __out, __in, __ngpio)          \
65 {                                                               \
66         .en = __en,                                             \
67         .dir = __dir,                                           \
68         .data_out = __out,                                      \
69         .data_in = __in,                                        \
70         .ngpio = __ngpio,                                       \
71 }
72
73 static struct vt8500_gpio_data vt8500_data = {
74         .num_banks      = 7,
75         .banks  = {
76                 VT8500_BANK(0x00, 0x20, 0x40, 0x60, 26),
77                 VT8500_BANK(0x04, 0x24, 0x44, 0x64, 28),
78                 VT8500_BANK(0x08, 0x28, 0x48, 0x68, 31),
79                 VT8500_BANK(0x0C, 0x2C, 0x4C, 0x6C, 19),
80                 VT8500_BANK(0x10, 0x30, 0x50, 0x70, 19),
81                 VT8500_BANK(0x14, 0x34, 0x54, 0x74, 23),
82                 VT8500_BANK(NO_REG, 0x3C, 0x5C, 0x7C, 9),
83         },
84 };
85
86 static struct vt8500_gpio_data wm8505_data = {
87         .num_banks      = 10,
88         .banks  = {
89                 VT8500_BANK(0x40, 0x68, 0x90, 0xB8, 8),
90                 VT8500_BANK(0x44, 0x6C, 0x94, 0xBC, 32),
91                 VT8500_BANK(0x48, 0x70, 0x98, 0xC0, 6),
92                 VT8500_BANK(0x4C, 0x74, 0x9C, 0xC4, 16),
93                 VT8500_BANK(0x50, 0x78, 0xA0, 0xC8, 25),
94                 VT8500_BANK(0x54, 0x7C, 0xA4, 0xCC, 5),
95                 VT8500_BANK(0x58, 0x80, 0xA8, 0xD0, 5),
96                 VT8500_BANK(0x5C, 0x84, 0xAC, 0xD4, 12),
97                 VT8500_BANK(0x60, 0x88, 0xB0, 0xD8, 16),
98                 VT8500_BANK(0x64, 0x8C, 0xB4, 0xDC, 22),
99                 VT8500_BANK(0x500, 0x504, 0x508, 0x50C, 6),
100         },
101 };
102
103 /*
104  * No information about which bits are valid so we just make
105  * them all available until its figured out.
106  */
107 static struct vt8500_gpio_data wm8650_data = {
108         .num_banks      = 9,
109         .banks  = {
110                 VT8500_BANK(0x40, 0x80, 0xC0, 0x00, 32),
111                 VT8500_BANK(0x44, 0x84, 0xC4, 0x04, 32),
112                 VT8500_BANK(0x48, 0x88, 0xC8, 0x08, 32),
113                 VT8500_BANK(0x4C, 0x8C, 0xCC, 0x0C, 32),
114                 VT8500_BANK(0x50, 0x90, 0xD0, 0x10, 32),
115                 VT8500_BANK(0x54, 0x94, 0xD4, 0x14, 32),
116                 VT8500_BANK(0x58, 0x98, 0xD8, 0x18, 32),
117                 VT8500_BANK(0x5C, 0x9C, 0xDC, 0x1C, 32),
118                 VT8500_BANK(0x7C, 0xBC, 0xFC, 0x3C, 32),
119                 VT8500_BANK(0x500, 0x504, 0x508, 0x50C, 6),
120         },
121 };
122
123 struct vt8500_gpio_chip {
124         struct gpio_chip                chip;
125
126         const struct vt8500_gpio_bank_regoffsets *regs;
127         void __iomem    *base;
128 };
129
130
131 #define to_vt8500(__chip) container_of(__chip, struct vt8500_gpio_chip, chip)
132
133 static int vt8500_gpio_request(struct gpio_chip *chip, unsigned offset)
134 {
135         u32 val;
136         struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
137
138         if (vt8500_chip->regs->en == NO_REG)
139                 return 0;
140
141         val = readl_relaxed(vt8500_chip->base + vt8500_chip->regs->en);
142         val |= BIT(offset);
143         writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->en);
144
145         return 0;
146 }
147
148 static void vt8500_gpio_free(struct gpio_chip *chip, unsigned offset)
149 {
150         struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
151         u32 val;
152
153         if (vt8500_chip->regs->en == NO_REG)
154                 return;
155
156         val = readl_relaxed(vt8500_chip->base + vt8500_chip->regs->en);
157         val &= ~BIT(offset);
158         writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->en);
159 }
160
161 static int vt8500_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
162 {
163         struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
164
165         u32 val = readl_relaxed(vt8500_chip->base + vt8500_chip->regs->dir);
166         val &= ~BIT(offset);
167         writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->dir);
168
169         return 0;
170 }
171
172 static int vt8500_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
173                                                                 int value)
174 {
175         struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
176
177         u32 val = readl_relaxed(vt8500_chip->base + vt8500_chip->regs->dir);
178         val |= BIT(offset);
179         writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->dir);
180
181         if (value) {
182                 val = readl_relaxed(vt8500_chip->base +
183                                                 vt8500_chip->regs->data_out);
184                 val |= BIT(offset);
185                 writel_relaxed(val, vt8500_chip->base +
186                                                 vt8500_chip->regs->data_out);
187         }
188         return 0;
189 }
190
191 static int vt8500_gpio_get_value(struct gpio_chip *chip, unsigned offset)
192 {
193         struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
194
195         return (readl_relaxed(vt8500_chip->base + vt8500_chip->regs->data_in) >>
196                                                                 offset) & 1;
197 }
198
199 static void vt8500_gpio_set_value(struct gpio_chip *chip, unsigned offset,
200                                                                 int value)
201 {
202         struct vt8500_gpio_chip *vt8500_chip = to_vt8500(chip);
203
204         u32 val = readl_relaxed(vt8500_chip->base +
205                                                 vt8500_chip->regs->data_out);
206         if (value)
207                 val |= BIT(offset);
208         else
209                 val &= ~BIT(offset);
210
211         writel_relaxed(val, vt8500_chip->base + vt8500_chip->regs->data_out);
212 }
213
214 static int vt8500_of_xlate(struct gpio_chip *gc,
215                             const struct of_phandle_args *gpiospec, u32 *flags)
216 {
217         /* bank if specificed in gpiospec->args[0] */
218         if (flags)
219                 *flags = gpiospec->args[2];
220
221         return gpiospec->args[1];
222 }
223
224 static int vt8500_add_chips(struct platform_device *pdev, void __iomem *base,
225                                 const struct vt8500_gpio_data *data)
226 {
227         struct vt8500_gpio_chip *vtchip;
228         struct gpio_chip *chip;
229         int i;
230         int pin_cnt = 0;
231
232         vtchip = devm_kzalloc(&pdev->dev,
233                         sizeof(struct vt8500_gpio_chip) * data->num_banks,
234                         GFP_KERNEL);
235         if (!vtchip) {
236                 pr_err("%s: failed to allocate chip memory\n", __func__);
237                 return -ENOMEM;
238         }
239
240         for (i = 0; i < data->num_banks; i++) {
241                 vtchip[i].base = base;
242                 vtchip[i].regs = &data->banks[i];
243
244                 chip = &vtchip[i].chip;
245
246                 chip->of_xlate = vt8500_of_xlate;
247                 chip->of_gpio_n_cells = 3;
248                 chip->of_node = pdev->dev.of_node;
249
250                 chip->request = vt8500_gpio_request;
251                 chip->free = vt8500_gpio_free;
252                 chip->direction_input = vt8500_gpio_direction_input;
253                 chip->direction_output = vt8500_gpio_direction_output;
254                 chip->get = vt8500_gpio_get_value;
255                 chip->set = vt8500_gpio_set_value;
256                 chip->can_sleep = 0;
257                 chip->base = pin_cnt;
258                 chip->ngpio = data->banks[i].ngpio;
259
260                 pin_cnt += data->banks[i].ngpio;
261
262                 gpiochip_add(chip);
263         }
264         return 0;
265 }
266
267 static struct of_device_id vt8500_gpio_dt_ids[] = {
268         { .compatible = "via,vt8500-gpio", .data = &vt8500_data, },
269         { .compatible = "wm,wm8505-gpio", .data = &wm8505_data, },
270         { .compatible = "wm,wm8650-gpio", .data = &wm8650_data, },
271         { /* Sentinel */ },
272 };
273
274 static int vt8500_gpio_probe(struct platform_device *pdev)
275 {
276         void __iomem *gpio_base;
277         struct device_node *np;
278         const struct of_device_id *of_id =
279                                 of_match_device(vt8500_gpio_dt_ids, &pdev->dev);
280
281         if (!of_id) {
282                 dev_err(&pdev->dev, "Failed to find gpio controller\n");
283                 return -ENODEV;
284         }
285
286         np = pdev->dev.of_node;
287         if (!np) {
288                 dev_err(&pdev->dev, "Missing GPIO description in devicetree\n");
289                 return -EFAULT;
290         }
291
292         gpio_base = of_iomap(np, 0);
293         if (!gpio_base) {
294                 dev_err(&pdev->dev, "Unable to map GPIO registers\n");
295                 of_node_put(np);
296                 return -ENOMEM;
297         }
298
299         vt8500_add_chips(pdev, gpio_base, of_id->data);
300
301         return 0;
302 }
303
304 static struct platform_driver vt8500_gpio_driver = {
305         .probe          = vt8500_gpio_probe,
306         .driver         = {
307                 .name   = "vt8500-gpio",
308                 .owner  = THIS_MODULE,
309                 .of_match_table = vt8500_gpio_dt_ids,
310         },
311 };
312
313 module_platform_driver(vt8500_gpio_driver);
314
315 MODULE_DESCRIPTION("VT8500 GPIO Driver");
316 MODULE_AUTHOR("Tony Prisk <linux@prisktech.co.nz>");
317 MODULE_LICENSE("GPL v2");
318 MODULE_DEVICE_TABLE(of, vt8500_gpio_dt_ids);