blob: 50bdc29591c059612b0c5d58b0f3ce8cedfd32c6 [file] [log] [blame]
Linus Walleijdae5f0a2018-09-25 09:08:48 +02001// SPDX-License-Identifier: GPL-2.0+
Anton Vorontsovaeec56e2010-10-27 15:33:15 -07002/*
Grant Likelyc103de22011-06-04 18:38:28 -06003 * Generic driver for memory-mapped GPIO controllers.
Anton Vorontsovaeec56e2010-10-27 15:33:15 -07004 *
5 * Copyright 2008 MontaVista Software, Inc.
6 * Copyright 2008,2010 Anton Vorontsov <cbouatmailru@gmail.com>
7 *
Anton Vorontsovaeec56e2010-10-27 15:33:15 -07008 * ....``.```~~~~````.`.`.`.`.```````'',,,.........`````......`.......
9 * ...`` ```````..
10 * ..The simplest form of a GPIO controller that the driver supports is``
11 * `.just a single "data" register, where GPIO state can be read and/or `
12 * `,..written. ,,..``~~~~ .....``.`.`.~~.```.`.........``````.```````
13 * `````````
14 ___
15_/~~|___/~| . ```~~~~~~ ___/___\___ ,~.`.`.`.`````.~~...,,,,...
16__________|~$@~~~ %~ /o*o*o*o*o*o\ .. Implementing such a GPIO .
17o ` ~~~~\___/~~~~ ` controller in FPGA is ,.`
18 `....trivial..'~`.```.```
19 * ```````
20 * .```````~~~~`..`.``.``.
21 * . The driver supports `... ,..```.`~~~```````````````....````.``,,
22 * . big-endian notation, just`. .. A bit more sophisticated controllers ,
23 * . register the device with -be`. .with a pair of set/clear-bit registers ,
24 * `.. suffix. ```~~`````....`.` . affecting the data register and the .`
25 * ``.`.``...``` ```.. output pins are also supported.`
26 * ^^ `````.`````````.,``~``~``~~``````
27 * . ^^
28 * ,..`.`.`...````````````......`.`.`.`.`.`..`.`.`..
29 * .. The expectation is that in at least some cases . ,-~~~-,
30 * .this will be used with roll-your-own ASIC/FPGA .` \ /
31 * .logic in Verilog or VHDL. ~~~`````````..`````~~` \ /
32 * ..````````......``````````` \o_
33 * |
34 * ^^ / \
35 *
36 * ...`````~~`.....``.`..........``````.`.``.```........``.
37 * ` 8, 16, 32 and 64 bits registers are supported, and``.
38 * . the number of GPIOs is determined by the width of ~
39 * .. the registers. ,............```.`.`..`.`.~~~.`.`.`~
40 * `.......````.```
41 */
42
43#include <linux/init.h>
Jamie Iles280df6b2011-05-20 00:40:19 -060044#include <linux/err.h>
Anton Vorontsovaeec56e2010-10-27 15:33:15 -070045#include <linux/bug.h>
46#include <linux/kernel.h>
47#include <linux/module.h>
48#include <linux/spinlock.h>
49#include <linux/compiler.h>
50#include <linux/types.h>
51#include <linux/errno.h>
52#include <linux/log2.h>
53#include <linux/ioport.h>
54#include <linux/io.h>
Linus Walleij0f4630f2015-12-04 14:02:58 +010055#include <linux/gpio/driver.h>
Anton Vorontsovaeec56e2010-10-27 15:33:15 -070056#include <linux/slab.h>
Linus Walleij4b637392016-01-05 11:13:28 +010057#include <linux/bitops.h>
Anton Vorontsovaeec56e2010-10-27 15:33:15 -070058#include <linux/platform_device.h>
59#include <linux/mod_devicetable.h>
Álvaro Fernández Rojase6986132016-05-13 23:07:11 +020060#include <linux/of.h>
61#include <linux/of_device.h>
Anton Vorontsovaeec56e2010-10-27 15:33:15 -070062
Jamie Iles8467afe2011-05-20 00:40:14 -060063static void bgpio_write8(void __iomem *reg, unsigned long data)
Anton Vorontsovaeec56e2010-10-27 15:33:15 -070064{
Jamie Ilesfd996232011-05-20 00:40:17 -060065 writeb(data, reg);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -070066}
67
Jamie Iles8467afe2011-05-20 00:40:14 -060068static unsigned long bgpio_read8(void __iomem *reg)
Anton Vorontsovaeec56e2010-10-27 15:33:15 -070069{
Jamie Ilesfd996232011-05-20 00:40:17 -060070 return readb(reg);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -070071}
72
Jamie Iles8467afe2011-05-20 00:40:14 -060073static void bgpio_write16(void __iomem *reg, unsigned long data)
74{
Jamie Ilesfd996232011-05-20 00:40:17 -060075 writew(data, reg);
Jamie Iles8467afe2011-05-20 00:40:14 -060076}
77
78static unsigned long bgpio_read16(void __iomem *reg)
79{
Jamie Ilesfd996232011-05-20 00:40:17 -060080 return readw(reg);
Jamie Iles8467afe2011-05-20 00:40:14 -060081}
82
83static void bgpio_write32(void __iomem *reg, unsigned long data)
84{
Jamie Ilesfd996232011-05-20 00:40:17 -060085 writel(data, reg);
Jamie Iles8467afe2011-05-20 00:40:14 -060086}
87
88static unsigned long bgpio_read32(void __iomem *reg)
89{
Jamie Ilesfd996232011-05-20 00:40:17 -060090 return readl(reg);
Jamie Iles8467afe2011-05-20 00:40:14 -060091}
92
93#if BITS_PER_LONG >= 64
94static void bgpio_write64(void __iomem *reg, unsigned long data)
95{
Jamie Ilesfd996232011-05-20 00:40:17 -060096 writeq(data, reg);
Jamie Iles8467afe2011-05-20 00:40:14 -060097}
98
99static unsigned long bgpio_read64(void __iomem *reg)
100{
Jamie Ilesfd996232011-05-20 00:40:17 -0600101 return readq(reg);
Jamie Iles8467afe2011-05-20 00:40:14 -0600102}
103#endif /* BITS_PER_LONG >= 64 */
104
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100105static void bgpio_write16be(void __iomem *reg, unsigned long data)
106{
107 iowrite16be(data, reg);
108}
109
110static unsigned long bgpio_read16be(void __iomem *reg)
111{
112 return ioread16be(reg);
113}
114
115static void bgpio_write32be(void __iomem *reg, unsigned long data)
116{
117 iowrite32be(data, reg);
118}
119
120static unsigned long bgpio_read32be(void __iomem *reg)
121{
122 return ioread32be(reg);
123}
124
Linus Walleij24efd942017-10-20 16:31:27 +0200125static unsigned long bgpio_line2mask(struct gpio_chip *gc, unsigned int line)
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700126{
Linus Walleij24efd942017-10-20 16:31:27 +0200127 if (gc->be_bits)
128 return BIT(gc->bgpio_bits - 1 - line);
129 return BIT(line);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700130}
131
Vladimir Zapolskiyb19e7f52015-04-29 18:34:59 +0300132static int bgpio_get_set(struct gpio_chip *gc, unsigned int gpio)
133{
Linus Walleij24efd942017-10-20 16:31:27 +0200134 unsigned long pinmask = bgpio_line2mask(gc, gpio);
Linus Walleijd799a4d2018-08-03 00:52:18 +0200135 bool dir = !!(gc->bgpio_dir & pinmask);
Vladimir Zapolskiyb19e7f52015-04-29 18:34:59 +0300136
Linus Walleijd799a4d2018-08-03 00:52:18 +0200137 /*
138 * If the direction is OUT we read the value from the SET
139 * register, and if the direction is IN we read the value
140 * from the DAT register.
141 *
142 * If the direction bits are inverted, naturally this gets
143 * inverted too.
144 */
145 if (gc->bgpio_dir_inverted)
146 dir = !dir;
147
148 if (dir)
Linus Walleij0f4630f2015-12-04 14:02:58 +0100149 return !!(gc->read_reg(gc->reg_set) & pinmask);
Vladimir Zapolskiyb19e7f52015-04-29 18:34:59 +0300150 else
Linus Walleij0f4630f2015-12-04 14:02:58 +0100151 return !!(gc->read_reg(gc->reg_dat) & pinmask);
Vladimir Zapolskiyb19e7f52015-04-29 18:34:59 +0300152}
153
Linus Walleij80057cb42017-10-19 23:30:12 +0200154/*
155 * This assumes that the bits in the GPIO register are in native endianness.
156 * We only assign the function pointer if we have that.
157 */
158static int bgpio_get_set_multiple(struct gpio_chip *gc, unsigned long *mask,
159 unsigned long *bits)
160{
161 unsigned long get_mask = 0;
162 unsigned long set_mask = 0;
Linus Walleij80057cb42017-10-19 23:30:12 +0200163
Linus Walleij07c7b6a2018-01-16 09:51:51 +0100164 /* Make sure we first clear any bits that are zero when we read the register */
165 *bits &= ~*mask;
166
167 /* Exploit the fact that we know which directions are set */
Linus Walleijd799a4d2018-08-03 00:52:18 +0200168 if (gc->bgpio_dir_inverted) {
169 set_mask = *mask & ~gc->bgpio_dir;
170 get_mask = *mask & gc->bgpio_dir;
171 } else {
172 set_mask = *mask & gc->bgpio_dir;
173 get_mask = *mask & ~gc->bgpio_dir;
174 }
Linus Walleij80057cb42017-10-19 23:30:12 +0200175
176 if (set_mask)
177 *bits |= gc->read_reg(gc->reg_set) & set_mask;
178 if (get_mask)
179 *bits |= gc->read_reg(gc->reg_dat) & get_mask;
180
181 return 0;
182}
183
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700184static int bgpio_get(struct gpio_chip *gc, unsigned int gpio)
185{
Linus Walleij24efd942017-10-20 16:31:27 +0200186 return !!(gc->read_reg(gc->reg_dat) & bgpio_line2mask(gc, gpio));
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700187}
188
Linus Walleij80057cb42017-10-19 23:30:12 +0200189/*
190 * This only works if the bits in the GPIO register are in native endianness.
Linus Walleij80057cb42017-10-19 23:30:12 +0200191 */
192static int bgpio_get_multiple(struct gpio_chip *gc, unsigned long *mask,
193 unsigned long *bits)
194{
Linus Walleij07c7b6a2018-01-16 09:51:51 +0100195 /* Make sure we first clear any bits that are zero when we read the register */
196 *bits &= ~*mask;
197 *bits |= gc->read_reg(gc->reg_dat) & *mask;
Linus Walleij80057cb42017-10-19 23:30:12 +0200198 return 0;
199}
200
201/*
202 * With big endian mirrored bit order it becomes more tedious.
203 */
204static int bgpio_get_multiple_be(struct gpio_chip *gc, unsigned long *mask,
205 unsigned long *bits)
206{
207 unsigned long readmask = 0;
208 unsigned long val;
209 int bit;
210
Linus Walleij07c7b6a2018-01-16 09:51:51 +0100211 /* Make sure we first clear any bits that are zero when we read the register */
212 *bits &= ~*mask;
213
Linus Walleij80057cb42017-10-19 23:30:12 +0200214 /* Create a mirrored mask */
Linus Walleij07c7b6a2018-01-16 09:51:51 +0100215 bit = -1;
216 while ((bit = find_next_bit(mask, gc->ngpio, bit + 1)) < gc->ngpio)
Linus Walleij80057cb42017-10-19 23:30:12 +0200217 readmask |= bgpio_line2mask(gc, bit);
218
219 /* Read the register */
220 val = gc->read_reg(gc->reg_dat) & readmask;
221
222 /*
223 * Mirror the result into the "bits" result, this will give line 0
224 * in bit 0 ... line 31 in bit 31 for a 32bit register.
225 */
Linus Walleij07c7b6a2018-01-16 09:51:51 +0100226 bit = -1;
227 while ((bit = find_next_bit(&val, gc->ngpio, bit + 1)) < gc->ngpio)
Linus Walleij80057cb42017-10-19 23:30:12 +0200228 *bits |= bgpio_line2mask(gc, bit);
229
230 return 0;
231}
232
Rabin Vincent91492a42015-07-22 15:05:18 +0200233static void bgpio_set_none(struct gpio_chip *gc, unsigned int gpio, int val)
234{
235}
236
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700237static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
238{
Linus Walleij24efd942017-10-20 16:31:27 +0200239 unsigned long mask = bgpio_line2mask(gc, gpio);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700240 unsigned long flags;
241
Linus Walleij0f4630f2015-12-04 14:02:58 +0100242 spin_lock_irqsave(&gc->bgpio_lock, flags);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700243
244 if (val)
Linus Walleij0f4630f2015-12-04 14:02:58 +0100245 gc->bgpio_data |= mask;
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700246 else
Linus Walleij0f4630f2015-12-04 14:02:58 +0100247 gc->bgpio_data &= ~mask;
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700248
Linus Walleij0f4630f2015-12-04 14:02:58 +0100249 gc->write_reg(gc->reg_dat, gc->bgpio_data);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700250
Linus Walleij0f4630f2015-12-04 14:02:58 +0100251 spin_unlock_irqrestore(&gc->bgpio_lock, flags);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700252}
253
Jamie Ilese027d6f2011-05-20 00:40:16 -0600254static void bgpio_set_with_clear(struct gpio_chip *gc, unsigned int gpio,
255 int val)
256{
Linus Walleij24efd942017-10-20 16:31:27 +0200257 unsigned long mask = bgpio_line2mask(gc, gpio);
Jamie Ilese027d6f2011-05-20 00:40:16 -0600258
259 if (val)
Linus Walleij0f4630f2015-12-04 14:02:58 +0100260 gc->write_reg(gc->reg_set, mask);
Jamie Ilese027d6f2011-05-20 00:40:16 -0600261 else
Linus Walleij0f4630f2015-12-04 14:02:58 +0100262 gc->write_reg(gc->reg_clr, mask);
Jamie Ilese027d6f2011-05-20 00:40:16 -0600263}
264
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600265static void bgpio_set_set(struct gpio_chip *gc, unsigned int gpio, int val)
266{
Linus Walleij24efd942017-10-20 16:31:27 +0200267 unsigned long mask = bgpio_line2mask(gc, gpio);
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600268 unsigned long flags;
269
Linus Walleij0f4630f2015-12-04 14:02:58 +0100270 spin_lock_irqsave(&gc->bgpio_lock, flags);
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600271
272 if (val)
Linus Walleij0f4630f2015-12-04 14:02:58 +0100273 gc->bgpio_data |= mask;
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600274 else
Linus Walleij0f4630f2015-12-04 14:02:58 +0100275 gc->bgpio_data &= ~mask;
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600276
Linus Walleij0f4630f2015-12-04 14:02:58 +0100277 gc->write_reg(gc->reg_set, gc->bgpio_data);
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600278
Linus Walleij0f4630f2015-12-04 14:02:58 +0100279 spin_unlock_irqrestore(&gc->bgpio_lock, flags);
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600280}
281
Linus Walleij0f4630f2015-12-04 14:02:58 +0100282static void bgpio_multiple_get_masks(struct gpio_chip *gc,
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100283 unsigned long *mask, unsigned long *bits,
284 unsigned long *set_mask,
285 unsigned long *clear_mask)
286{
287 int i;
288
289 *set_mask = 0;
290 *clear_mask = 0;
291
Linus Walleij0f4630f2015-12-04 14:02:58 +0100292 for (i = 0; i < gc->bgpio_bits; i++) {
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100293 if (*mask == 0)
294 break;
295 if (__test_and_clear_bit(i, mask)) {
296 if (test_bit(i, bits))
Linus Walleij24efd942017-10-20 16:31:27 +0200297 *set_mask |= bgpio_line2mask(gc, i);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100298 else
Linus Walleij24efd942017-10-20 16:31:27 +0200299 *clear_mask |= bgpio_line2mask(gc, i);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100300 }
301 }
302}
303
Linus Walleij0f4630f2015-12-04 14:02:58 +0100304static void bgpio_set_multiple_single_reg(struct gpio_chip *gc,
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100305 unsigned long *mask,
306 unsigned long *bits,
307 void __iomem *reg)
308{
309 unsigned long flags;
310 unsigned long set_mask, clear_mask;
311
Linus Walleij0f4630f2015-12-04 14:02:58 +0100312 spin_lock_irqsave(&gc->bgpio_lock, flags);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100313
Linus Walleij0f4630f2015-12-04 14:02:58 +0100314 bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100315
Linus Walleij0f4630f2015-12-04 14:02:58 +0100316 gc->bgpio_data |= set_mask;
317 gc->bgpio_data &= ~clear_mask;
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100318
Linus Walleij0f4630f2015-12-04 14:02:58 +0100319 gc->write_reg(reg, gc->bgpio_data);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100320
Linus Walleij0f4630f2015-12-04 14:02:58 +0100321 spin_unlock_irqrestore(&gc->bgpio_lock, flags);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100322}
323
324static void bgpio_set_multiple(struct gpio_chip *gc, unsigned long *mask,
325 unsigned long *bits)
326{
Linus Walleij0f4630f2015-12-04 14:02:58 +0100327 bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_dat);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100328}
329
330static void bgpio_set_multiple_set(struct gpio_chip *gc, unsigned long *mask,
331 unsigned long *bits)
332{
Linus Walleij0f4630f2015-12-04 14:02:58 +0100333 bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_set);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100334}
335
336static void bgpio_set_multiple_with_clear(struct gpio_chip *gc,
337 unsigned long *mask,
338 unsigned long *bits)
339{
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100340 unsigned long set_mask, clear_mask;
341
Linus Walleij0f4630f2015-12-04 14:02:58 +0100342 bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100343
344 if (set_mask)
Linus Walleij0f4630f2015-12-04 14:02:58 +0100345 gc->write_reg(gc->reg_set, set_mask);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100346 if (clear_mask)
Linus Walleij0f4630f2015-12-04 14:02:58 +0100347 gc->write_reg(gc->reg_clr, clear_mask);
Rojhalat Ibrahim73c4ced2015-01-14 15:46:38 +0100348}
349
Jamie Iles31029112011-05-20 00:40:17 -0600350static int bgpio_simple_dir_in(struct gpio_chip *gc, unsigned int gpio)
351{
352 return 0;
353}
354
Rabin Vincent91492a42015-07-22 15:05:18 +0200355static int bgpio_dir_out_err(struct gpio_chip *gc, unsigned int gpio,
356 int val)
357{
358 return -EINVAL;
359}
360
Jamie Iles31029112011-05-20 00:40:17 -0600361static int bgpio_simple_dir_out(struct gpio_chip *gc, unsigned int gpio,
362 int val)
363{
364 gc->set(gc, gpio, val);
365
366 return 0;
367}
368
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700369static int bgpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
370{
Jamie Iles31029112011-05-20 00:40:17 -0600371 unsigned long flags;
372
Linus Walleij0f4630f2015-12-04 14:02:58 +0100373 spin_lock_irqsave(&gc->bgpio_lock, flags);
Jamie Iles31029112011-05-20 00:40:17 -0600374
Linus Walleijd799a4d2018-08-03 00:52:18 +0200375 if (gc->bgpio_dir_inverted)
376 gc->bgpio_dir |= bgpio_line2mask(gc, gpio);
377 else
378 gc->bgpio_dir &= ~bgpio_line2mask(gc, gpio);
Linus Walleij0f4630f2015-12-04 14:02:58 +0100379 gc->write_reg(gc->reg_dir, gc->bgpio_dir);
Jamie Iles31029112011-05-20 00:40:17 -0600380
Linus Walleij0f4630f2015-12-04 14:02:58 +0100381 spin_unlock_irqrestore(&gc->bgpio_lock, flags);
Jamie Iles31029112011-05-20 00:40:17 -0600382
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700383 return 0;
384}
385
Philipp Zabeldb3b0fc2015-06-12 18:20:35 +0200386static int bgpio_get_dir(struct gpio_chip *gc, unsigned int gpio)
387{
Linus Walleij0f4630f2015-12-04 14:02:58 +0100388 /* Return 0 if output, 1 of input */
Linus Walleijd799a4d2018-08-03 00:52:18 +0200389 if (gc->bgpio_dir_inverted)
390 return !!(gc->read_reg(gc->reg_dir) & bgpio_line2mask(gc, gpio));
391 else
392 return !(gc->read_reg(gc->reg_dir) & bgpio_line2mask(gc, gpio));
Philipp Zabeldb3b0fc2015-06-12 18:20:35 +0200393}
394
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700395static int bgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
396{
Jamie Iles31029112011-05-20 00:40:17 -0600397 unsigned long flags;
398
Jamie Ilese027d6f2011-05-20 00:40:16 -0600399 gc->set(gc, gpio, val);
400
Linus Walleij0f4630f2015-12-04 14:02:58 +0100401 spin_lock_irqsave(&gc->bgpio_lock, flags);
Jamie Iles31029112011-05-20 00:40:17 -0600402
Linus Walleijd799a4d2018-08-03 00:52:18 +0200403 if (gc->bgpio_dir_inverted)
404 gc->bgpio_dir &= ~bgpio_line2mask(gc, gpio);
405 else
406 gc->bgpio_dir |= bgpio_line2mask(gc, gpio);
Linus Walleij0f4630f2015-12-04 14:02:58 +0100407 gc->write_reg(gc->reg_dir, gc->bgpio_dir);
Jamie Iles31029112011-05-20 00:40:17 -0600408
Linus Walleij0f4630f2015-12-04 14:02:58 +0100409 spin_unlock_irqrestore(&gc->bgpio_lock, flags);
Jamie Iles31029112011-05-20 00:40:17 -0600410
411 return 0;
412}
413
Jamie Iles280df6b2011-05-20 00:40:19 -0600414static int bgpio_setup_accessors(struct device *dev,
Linus Walleij0f4630f2015-12-04 14:02:58 +0100415 struct gpio_chip *gc,
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100416 bool byte_be)
Jamie Iles364b5e82011-05-20 00:40:16 -0600417{
Jamie Iles8467afe2011-05-20 00:40:14 -0600418
Linus Walleij0f4630f2015-12-04 14:02:58 +0100419 switch (gc->bgpio_bits) {
Jamie Iles8467afe2011-05-20 00:40:14 -0600420 case 8:
Linus Walleij0f4630f2015-12-04 14:02:58 +0100421 gc->read_reg = bgpio_read8;
422 gc->write_reg = bgpio_write8;
Jamie Iles8467afe2011-05-20 00:40:14 -0600423 break;
424 case 16:
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100425 if (byte_be) {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100426 gc->read_reg = bgpio_read16be;
427 gc->write_reg = bgpio_write16be;
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100428 } else {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100429 gc->read_reg = bgpio_read16;
430 gc->write_reg = bgpio_write16;
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100431 }
Jamie Iles8467afe2011-05-20 00:40:14 -0600432 break;
433 case 32:
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100434 if (byte_be) {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100435 gc->read_reg = bgpio_read32be;
436 gc->write_reg = bgpio_write32be;
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100437 } else {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100438 gc->read_reg = bgpio_read32;
439 gc->write_reg = bgpio_write32;
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100440 }
Jamie Iles8467afe2011-05-20 00:40:14 -0600441 break;
442#if BITS_PER_LONG >= 64
443 case 64:
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100444 if (byte_be) {
445 dev_err(dev,
446 "64 bit big endian byte order unsupported\n");
447 return -EINVAL;
448 } else {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100449 gc->read_reg = bgpio_read64;
450 gc->write_reg = bgpio_write64;
Andreas Larsson2b78f1e2013-03-15 14:45:38 +0100451 }
Jamie Iles8467afe2011-05-20 00:40:14 -0600452 break;
453#endif /* BITS_PER_LONG >= 64 */
454 default:
Linus Walleij0f4630f2015-12-04 14:02:58 +0100455 dev_err(dev, "unsupported data width %u bits\n", gc->bgpio_bits);
Jamie Iles8467afe2011-05-20 00:40:14 -0600456 return -EINVAL;
457 }
458
Jamie Iles8467afe2011-05-20 00:40:14 -0600459 return 0;
460}
461
Jamie Ilese027d6f2011-05-20 00:40:16 -0600462/*
463 * Create the device and allocate the resources. For setting GPIO's there are
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600464 * three supported configurations:
Jamie Ilese027d6f2011-05-20 00:40:16 -0600465 *
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600466 * - single input/output register resource (named "dat").
Jamie Ilese027d6f2011-05-20 00:40:16 -0600467 * - set/clear pair (named "set" and "clr").
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600468 * - single output register resource and single input resource ("set" and
469 * dat").
Jamie Ilese027d6f2011-05-20 00:40:16 -0600470 *
471 * For the single output register, this drives a 1 by setting a bit and a zero
472 * by clearing a bit. For the set clr pair, this drives a 1 by setting a bit
473 * in the set register and clears it by setting a bit in the clear register.
474 * The configuration is detected by which resources are present.
Jamie Iles31029112011-05-20 00:40:17 -0600475 *
476 * For setting the GPIO direction, there are three supported configurations:
477 *
478 * - simple bidirection GPIO that requires no configuration.
479 * - an output direction register (named "dirout") where a 1 bit
480 * indicates the GPIO is an output.
481 * - an input direction register (named "dirin") where a 1 bit indicates
482 * the GPIO is an input.
Jamie Ilese027d6f2011-05-20 00:40:16 -0600483 */
Linus Walleij0f4630f2015-12-04 14:02:58 +0100484static int bgpio_setup_io(struct gpio_chip *gc,
Jamie Iles280df6b2011-05-20 00:40:19 -0600485 void __iomem *dat,
486 void __iomem *set,
Vladimir Zapolskiyb19e7f52015-04-29 18:34:59 +0300487 void __iomem *clr,
488 unsigned long flags)
Jamie Iles8467afe2011-05-20 00:40:14 -0600489{
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700490
Linus Walleij0f4630f2015-12-04 14:02:58 +0100491 gc->reg_dat = dat;
492 if (!gc->reg_dat)
Jamie Iles280df6b2011-05-20 00:40:19 -0600493 return -EINVAL;
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700494
Jamie Iles280df6b2011-05-20 00:40:19 -0600495 if (set && clr) {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100496 gc->reg_set = set;
497 gc->reg_clr = clr;
498 gc->set = bgpio_set_with_clear;
499 gc->set_multiple = bgpio_set_multiple_with_clear;
Jamie Iles280df6b2011-05-20 00:40:19 -0600500 } else if (set && !clr) {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100501 gc->reg_set = set;
502 gc->set = bgpio_set_set;
503 gc->set_multiple = bgpio_set_multiple_set;
Rabin Vincent91492a42015-07-22 15:05:18 +0200504 } else if (flags & BGPIOF_NO_OUTPUT) {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100505 gc->set = bgpio_set_none;
506 gc->set_multiple = NULL;
Jamie Ilese027d6f2011-05-20 00:40:16 -0600507 } else {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100508 gc->set = bgpio_set;
509 gc->set_multiple = bgpio_set_multiple;
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700510 }
511
Vladimir Zapolskiyb19e7f52015-04-29 18:34:59 +0300512 if (!(flags & BGPIOF_UNREADABLE_REG_SET) &&
Linus Walleij80057cb42017-10-19 23:30:12 +0200513 (flags & BGPIOF_READ_OUTPUT_REG_SET)) {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100514 gc->get = bgpio_get_set;
Linus Walleij80057cb42017-10-19 23:30:12 +0200515 if (!gc->be_bits)
516 gc->get_multiple = bgpio_get_set_multiple;
517 /*
518 * We deliberately avoid assigning the ->get_multiple() call
519 * for big endian mirrored registers which are ALSO reflecting
520 * their value in the set register when used as output. It is
521 * simply too much complexity, let the GPIO core fall back to
522 * reading each line individually in that fringe case.
523 */
524 } else {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100525 gc->get = bgpio_get;
Linus Walleij80057cb42017-10-19 23:30:12 +0200526 if (gc->be_bits)
527 gc->get_multiple = bgpio_get_multiple_be;
528 else
529 gc->get_multiple = bgpio_get_multiple;
530 }
Jamie Ilesdd86a0c2011-05-20 00:40:16 -0600531
Jamie Ilese027d6f2011-05-20 00:40:16 -0600532 return 0;
533}
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700534
Linus Walleij0f4630f2015-12-04 14:02:58 +0100535static int bgpio_setup_direction(struct gpio_chip *gc,
Jamie Iles280df6b2011-05-20 00:40:19 -0600536 void __iomem *dirout,
Rabin Vincent91492a42015-07-22 15:05:18 +0200537 void __iomem *dirin,
538 unsigned long flags)
Jamie Iles31029112011-05-20 00:40:17 -0600539{
Jamie Iles280df6b2011-05-20 00:40:19 -0600540 if (dirout && dirin) {
Jamie Iles31029112011-05-20 00:40:17 -0600541 return -EINVAL;
Jamie Iles280df6b2011-05-20 00:40:19 -0600542 } else if (dirout) {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100543 gc->reg_dir = dirout;
544 gc->direction_output = bgpio_dir_out;
545 gc->direction_input = bgpio_dir_in;
546 gc->get_direction = bgpio_get_dir;
Jamie Iles280df6b2011-05-20 00:40:19 -0600547 } else if (dirin) {
Linus Walleij0f4630f2015-12-04 14:02:58 +0100548 gc->reg_dir = dirin;
Linus Walleijd799a4d2018-08-03 00:52:18 +0200549 gc->direction_output = bgpio_dir_out;
550 gc->direction_input = bgpio_dir_in;
551 gc->get_direction = bgpio_get_dir;
552 gc->bgpio_dir_inverted = true;
Jamie Iles31029112011-05-20 00:40:17 -0600553 } else {
Rabin Vincent91492a42015-07-22 15:05:18 +0200554 if (flags & BGPIOF_NO_OUTPUT)
Linus Walleij0f4630f2015-12-04 14:02:58 +0100555 gc->direction_output = bgpio_dir_out_err;
Rabin Vincent91492a42015-07-22 15:05:18 +0200556 else
Linus Walleij0f4630f2015-12-04 14:02:58 +0100557 gc->direction_output = bgpio_simple_dir_out;
558 gc->direction_input = bgpio_simple_dir_in;
Jamie Iles31029112011-05-20 00:40:17 -0600559 }
560
561 return 0;
562}
563
Anthony Fee7b42e3d2014-05-19 18:49:14 +0100564static int bgpio_request(struct gpio_chip *chip, unsigned gpio_pin)
565{
566 if (gpio_pin < chip->ngpio)
567 return 0;
568
569 return -EINVAL;
570}
571
Linus Walleijd799a4d2018-08-03 00:52:18 +0200572/**
573 * bgpio_init() - Initialize generic GPIO accessor functions
574 * @gc: the GPIO chip to set up
575 * @dev: the parent device of the new GPIO chip (compulsory)
576 * @sz: the size (width) of the MMIO registers in bytes, typically 1, 2 or 4
577 * @dat: MMIO address for the register to READ the value of the GPIO lines, it
578 * is expected that a 1 in the corresponding bit in this register means the
579 * line is asserted
580 * @set: MMIO address for the register to SET the value of the GPIO lines, it is
581 * expected that we write the line with 1 in this register to drive the GPIO line
582 * high.
583 * @clr: MMIO address for the register to CLEAR the value of the GPIO lines, it is
584 * expected that we write the line with 1 in this register to drive the GPIO line
585 * low. It is allowed to leave this address as NULL, in that case the SET register
586 * will be assumed to also clear the GPIO lines, by actively writing the line
587 * with 0.
588 * @dirout: MMIO address for the register to set the line as OUTPUT. It is assumed
589 * that setting a line to 1 in this register will turn that line into an
590 * output line. Conversely, setting the line to 0 will turn that line into
591 * an input. Either this or @dirin can be defined, but never both.
592 * @dirin: MMIO address for the register to set this line as INPUT. It is assumed
593 * that setting a line to 1 in this register will turn that line into an
594 * input line. Conversely, setting the line to 0 will turn that line into
595 * an output. Either this or @dirout can be defined, but never both.
596 * @flags: Different flags that will affect the behaviour of the device, such as
597 * endianness etc.
598 */
Linus Walleij0f4630f2015-12-04 14:02:58 +0100599int bgpio_init(struct gpio_chip *gc, struct device *dev,
Russell King4f5b0482011-09-14 16:22:29 -0700600 unsigned long sz, void __iomem *dat, void __iomem *set,
601 void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
Shawn Guo3e11f7b2012-05-19 21:34:58 +0800602 unsigned long flags)
Jamie Iles280df6b2011-05-20 00:40:19 -0600603{
Jamie Ilese027d6f2011-05-20 00:40:16 -0600604 int ret;
Jamie Ilese027d6f2011-05-20 00:40:16 -0600605
Jamie Iles280df6b2011-05-20 00:40:19 -0600606 if (!is_power_of_2(sz))
607 return -EINVAL;
Jamie Ilese027d6f2011-05-20 00:40:16 -0600608
Linus Walleij0f4630f2015-12-04 14:02:58 +0100609 gc->bgpio_bits = sz * 8;
610 if (gc->bgpio_bits > BITS_PER_LONG)
Jamie Iles280df6b2011-05-20 00:40:19 -0600611 return -EINVAL;
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700612
Linus Walleij0f4630f2015-12-04 14:02:58 +0100613 spin_lock_init(&gc->bgpio_lock);
614 gc->parent = dev;
615 gc->label = dev_name(dev);
616 gc->base = -1;
617 gc->ngpio = gc->bgpio_bits;
618 gc->request = bgpio_request;
Linus Walleij80057cb42017-10-19 23:30:12 +0200619 gc->be_bits = !!(flags & BGPIOF_BIG_ENDIAN);
Jamie Iles280df6b2011-05-20 00:40:19 -0600620
Linus Walleij0f4630f2015-12-04 14:02:58 +0100621 ret = bgpio_setup_io(gc, dat, set, clr, flags);
Jamie Iles280df6b2011-05-20 00:40:19 -0600622 if (ret)
623 return ret;
624
Linus Walleij24efd942017-10-20 16:31:27 +0200625 ret = bgpio_setup_accessors(dev, gc, flags & BGPIOF_BIG_ENDIAN_BYTE_ORDER);
Jamie Iles280df6b2011-05-20 00:40:19 -0600626 if (ret)
627 return ret;
628
Linus Walleij0f4630f2015-12-04 14:02:58 +0100629 ret = bgpio_setup_direction(gc, dirout, dirin, flags);
Jamie Iles31029112011-05-20 00:40:17 -0600630 if (ret)
631 return ret;
632
Linus Walleij0f4630f2015-12-04 14:02:58 +0100633 gc->bgpio_data = gc->read_reg(gc->reg_dat);
634 if (gc->set == bgpio_set_set &&
Shawn Guo3e11f7b2012-05-19 21:34:58 +0800635 !(flags & BGPIOF_UNREADABLE_REG_SET))
Linus Walleij0f4630f2015-12-04 14:02:58 +0100636 gc->bgpio_data = gc->read_reg(gc->reg_set);
637 if (gc->reg_dir && !(flags & BGPIOF_UNREADABLE_REG_DIR))
638 gc->bgpio_dir = gc->read_reg(gc->reg_dir);
Jamie Iles924e7a92011-05-20 00:40:15 -0600639
Jamie Iles280df6b2011-05-20 00:40:19 -0600640 return ret;
641}
642EXPORT_SYMBOL_GPL(bgpio_init);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700643
Christian Lamparter8f01c9d2016-04-29 02:53:14 +0200644#if IS_ENABLED(CONFIG_GPIO_GENERIC_PLATFORM)
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700645
Jamie Iles280df6b2011-05-20 00:40:19 -0600646static void __iomem *bgpio_map(struct platform_device *pdev,
647 const char *name,
Heiner Kallweit8d240262015-09-30 23:52:36 +0200648 resource_size_t sane_sz)
Jamie Iles280df6b2011-05-20 00:40:19 -0600649{
Jamie Iles280df6b2011-05-20 00:40:19 -0600650 struct resource *r;
Jamie Iles280df6b2011-05-20 00:40:19 -0600651 resource_size_t sz;
Jamie Iles280df6b2011-05-20 00:40:19 -0600652
653 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
Heiner Kallweit8d240262015-09-30 23:52:36 +0200654 if (!r)
Guenter Roeckb2f68b62015-10-21 00:12:00 -0700655 return NULL;
Jamie Iles280df6b2011-05-20 00:40:19 -0600656
657 sz = resource_size(r);
Heiner Kallweit8d240262015-09-30 23:52:36 +0200658 if (sz != sane_sz)
659 return IOMEM_ERR_PTR(-EINVAL);
Jamie Iles280df6b2011-05-20 00:40:19 -0600660
Heiner Kallweit8d240262015-09-30 23:52:36 +0200661 return devm_ioremap_resource(&pdev->dev, r);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700662}
663
Álvaro Fernández Rojase6986132016-05-13 23:07:11 +0200664#ifdef CONFIG_OF
665static const struct of_device_id bgpio_of_match[] = {
Christian Lamparter05cc9952016-08-03 14:05:57 +0200666 { .compatible = "brcm,bcm6345-gpio" },
Christian Lamparterc0d30ec2016-05-13 23:07:12 +0200667 { .compatible = "wd,mbl-gpio" },
Nathan Sullivanb8c90192017-03-14 11:13:22 -0500668 { .compatible = "ni,169445-nand-gpio" },
Álvaro Fernández Rojase6986132016-05-13 23:07:11 +0200669 { }
670};
671MODULE_DEVICE_TABLE(of, bgpio_of_match);
672
673static struct bgpio_pdata *bgpio_parse_dt(struct platform_device *pdev,
674 unsigned long *flags)
675{
676 struct bgpio_pdata *pdata;
677
678 if (!of_match_device(bgpio_of_match, &pdev->dev))
679 return NULL;
680
681 pdata = devm_kzalloc(&pdev->dev, sizeof(struct bgpio_pdata),
682 GFP_KERNEL);
683 if (!pdata)
684 return ERR_PTR(-ENOMEM);
685
686 pdata->base = -1;
687
Christian Lamparter05cc9952016-08-03 14:05:57 +0200688 if (of_device_is_big_endian(pdev->dev.of_node))
689 *flags |= BGPIOF_BIG_ENDIAN_BYTE_ORDER;
690
Christian Lamparterc0d30ec2016-05-13 23:07:12 +0200691 if (of_property_read_bool(pdev->dev.of_node, "no-output"))
692 *flags |= BGPIOF_NO_OUTPUT;
693
Álvaro Fernández Rojase6986132016-05-13 23:07:11 +0200694 return pdata;
695}
696#else
697static struct bgpio_pdata *bgpio_parse_dt(struct platform_device *pdev,
698 unsigned long *flags)
699{
700 return NULL;
701}
702#endif /* CONFIG_OF */
703
Bill Pemberton38363092012-11-19 13:22:34 -0500704static int bgpio_pdev_probe(struct platform_device *pdev)
Jamie Iles280df6b2011-05-20 00:40:19 -0600705{
706 struct device *dev = &pdev->dev;
707 struct resource *r;
708 void __iomem *dat;
709 void __iomem *set;
710 void __iomem *clr;
711 void __iomem *dirout;
712 void __iomem *dirin;
713 unsigned long sz;
Álvaro Fernández Rojase6986132016-05-13 23:07:11 +0200714 unsigned long flags = 0;
Jamie Iles280df6b2011-05-20 00:40:19 -0600715 int err;
Linus Walleij0f4630f2015-12-04 14:02:58 +0100716 struct gpio_chip *gc;
Álvaro Fernández Rojase6986132016-05-13 23:07:11 +0200717 struct bgpio_pdata *pdata;
718
719 pdata = bgpio_parse_dt(pdev, &flags);
720 if (IS_ERR(pdata))
721 return PTR_ERR(pdata);
722
723 if (!pdata) {
724 pdata = dev_get_platdata(dev);
725 flags = pdev->id_entry->driver_data;
726 }
Jamie Iles280df6b2011-05-20 00:40:19 -0600727
728 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dat");
729 if (!r)
730 return -EINVAL;
731
732 sz = resource_size(r);
733
Heiner Kallweit8d240262015-09-30 23:52:36 +0200734 dat = bgpio_map(pdev, "dat", sz);
735 if (IS_ERR(dat))
736 return PTR_ERR(dat);
Jamie Iles280df6b2011-05-20 00:40:19 -0600737
Heiner Kallweit8d240262015-09-30 23:52:36 +0200738 set = bgpio_map(pdev, "set", sz);
739 if (IS_ERR(set))
740 return PTR_ERR(set);
Jamie Iles280df6b2011-05-20 00:40:19 -0600741
Heiner Kallweit8d240262015-09-30 23:52:36 +0200742 clr = bgpio_map(pdev, "clr", sz);
743 if (IS_ERR(clr))
744 return PTR_ERR(clr);
Jamie Iles280df6b2011-05-20 00:40:19 -0600745
Heiner Kallweit8d240262015-09-30 23:52:36 +0200746 dirout = bgpio_map(pdev, "dirout", sz);
747 if (IS_ERR(dirout))
748 return PTR_ERR(dirout);
Jamie Iles280df6b2011-05-20 00:40:19 -0600749
Heiner Kallweit8d240262015-09-30 23:52:36 +0200750 dirin = bgpio_map(pdev, "dirin", sz);
751 if (IS_ERR(dirin))
752 return PTR_ERR(dirin);
Jamie Iles280df6b2011-05-20 00:40:19 -0600753
Linus Walleij0f4630f2015-12-04 14:02:58 +0100754 gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL);
755 if (!gc)
Jamie Iles280df6b2011-05-20 00:40:19 -0600756 return -ENOMEM;
757
Linus Walleij0f4630f2015-12-04 14:02:58 +0100758 err = bgpio_init(gc, dev, sz, dat, set, clr, dirout, dirin, flags);
Jamie Iles280df6b2011-05-20 00:40:19 -0600759 if (err)
760 return err;
761
762 if (pdata) {
Pawel Moll781f6d72014-01-30 13:18:57 +0000763 if (pdata->label)
Linus Walleij0f4630f2015-12-04 14:02:58 +0100764 gc->label = pdata->label;
765 gc->base = pdata->base;
Jamie Iles280df6b2011-05-20 00:40:19 -0600766 if (pdata->ngpio > 0)
Linus Walleij0f4630f2015-12-04 14:02:58 +0100767 gc->ngpio = pdata->ngpio;
Jamie Iles280df6b2011-05-20 00:40:19 -0600768 }
769
Linus Walleij0f4630f2015-12-04 14:02:58 +0100770 platform_set_drvdata(pdev, gc);
Jamie Iles280df6b2011-05-20 00:40:19 -0600771
Laxman Dewanganc05f8132016-02-22 17:43:28 +0530772 return devm_gpiochip_add_data(&pdev->dev, gc, NULL);
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700773}
774
775static const struct platform_device_id bgpio_id_table[] = {
Alexander Shiyan19338532014-03-16 09:10:34 +0400776 {
777 .name = "basic-mmio-gpio",
778 .driver_data = 0,
779 }, {
780 .name = "basic-mmio-gpio-be",
781 .driver_data = BGPIOF_BIG_ENDIAN,
782 },
783 { }
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700784};
785MODULE_DEVICE_TABLE(platform, bgpio_id_table);
786
787static struct platform_driver bgpio_driver = {
788 .driver = {
789 .name = "basic-mmio-gpio",
Álvaro Fernández Rojase6986132016-05-13 23:07:11 +0200790 .of_match_table = of_match_ptr(bgpio_of_match),
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700791 },
792 .id_table = bgpio_id_table,
Jamie Iles280df6b2011-05-20 00:40:19 -0600793 .probe = bgpio_pdev_probe,
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700794};
795
Mark Brown6f614152011-12-08 00:24:00 +0800796module_platform_driver(bgpio_driver);
Jamie Iles280df6b2011-05-20 00:40:19 -0600797
Grant Likelyc103de22011-06-04 18:38:28 -0600798#endif /* CONFIG_GPIO_GENERIC_PLATFORM */
Anton Vorontsovaeec56e2010-10-27 15:33:15 -0700799
800MODULE_DESCRIPTION("Driver for basic memory-mapped GPIO controllers");
801MODULE_AUTHOR("Anton Vorontsov <cbouatmailru@gmail.com>");
802MODULE_LICENSE("GPL");