1 From 0f4630f3720e7e6e921bf525c8357fea7ef3dbab Mon Sep 17 00:00:00 2001
2 From: Linus Walleij <linus.walleij@linaro.org>
3 Date: Fri, 4 Dec 2015 14:02:58 +0100
4 Subject: [PATCH] gpio: generic: factor into gpio_chip struct
6 The separate struct bgpio_chip has been a pain to handle, both
7 by being confusingly similar in name to struct gpio_chip and
8 for being contained inside a struct so that struct gpio_chip
9 is contained in a struct contained in a struct, making several
10 steps of dereferencing necessary.
12 Make things simpler: include the fields directly into
13 <linux/gpio/driver.h>, #ifdef:ed for CONFIG_GENERIC_GPIO, and
14 get rid of the <linux/basic_mmio_gpio.h> altogether. Prefix
15 some of the member variables with bgpio_* and add proper
16 kerneldoc while we're at it.
18 Modify all users to handle the change and use a struct
19 gpio_chip directly. And while we're at it: replace all
20 container_of() dereferencing by gpiochip_get_data() and
21 registering the gpio_chip with gpiochip_add_data().
24 Cc: Alexander Shiyan <shc_work@mail.ru>
25 Cc: Shawn Guo <shawnguo@kernel.org>
26 Cc: Sascha Hauer <kernel@pengutronix.de>
27 Cc: Kukjin Kim <kgene@kernel.org>
28 Cc: Alexandre Courbot <gnurou@gmail.com>
29 Cc: Brian Norris <computersforpeace@gmail.com>
30 Cc: Florian Fainelli <f.fainelli@gmail.com>
31 Cc: Sudeep Holla <sudeep.holla@arm.com>
32 Cc: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
33 Cc: Nicolas Pitre <nicolas.pitre@linaro.org>
34 Cc: Olof Johansson <olof@lixom.net>
35 Cc: Vladimir Zapolskiy <vladimir_zapolskiy@mentor.com>
36 Cc: Rabin Vincent <rabin@rab.in>
37 Cc: linux-arm-kernel@lists.infradead.org
38 Cc: linux-omap@vger.kernel.org
39 Cc: linux-samsung-soc@vger.kernel.org
40 Cc: bcm-kernel-feedback-list@broadcom.com
41 Acked-by: Gregory Fong <gregory.0xf0@gmail.com>
42 Acked-by: Liviu Dudau <Liviu.Dudau@arm.com>
43 Acked-by: H Hartley Sweeten <hsweeten@visionengravers.com>
44 Acked-by: Tony Lindgren <tony@atomide.com>
45 Acked-by: Krzysztof Kozlowski <k.kozlowski@samsung.com>
46 Acked-by: Lee Jones <lee.jones@linaro.org>
47 Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
49 arch/arm/mach-clps711x/board-autcpu12.c | 2 +-
50 arch/arm/mach-clps711x/board-p720t.c | 2 +-
51 arch/arm/mach-imx/mach-mx21ads.c | 2 +-
52 arch/arm/mach-omap1/board-ams-delta.c | 2 +-
53 arch/arm/mach-s3c64xx/mach-crag6410.c | 2 +-
54 drivers/gpio/gpio-74xx-mmio.c | 37 ++--
55 drivers/gpio/gpio-brcmstb.c | 80 ++++-----
56 drivers/gpio/gpio-clps711x.c | 28 +--
57 drivers/gpio/gpio-dwapb.c | 92 +++++-----
58 drivers/gpio/gpio-ep93xx.c | 25 +--
59 drivers/gpio/gpio-etraxfs.c | 49 +++---
60 drivers/gpio/gpio-ge.c | 24 +--
61 drivers/gpio/gpio-generic.c | 292 +++++++++++++++-----------------
62 drivers/gpio/gpio-grgpio.c | 73 ++++----
63 drivers/gpio/gpio-moxart.c | 29 ++--
64 drivers/gpio/gpio-mxc.c | 27 ++-
65 drivers/gpio/gpio-mxs.c | 33 ++--
66 drivers/gpio/gpio-sodaville.c | 13 +-
67 drivers/gpio/gpio-xgene-sb.c | 40 ++---
68 drivers/mfd/vexpress-sysreg.c | 8 +-
69 include/linux/basic_mmio_gpio.h | 80 ---------
70 include/linux/gpio/driver.h | 54 ++++++
71 22 files changed, 442 insertions(+), 552 deletions(-)
72 delete mode 100644 include/linux/basic_mmio_gpio.h
74 --- a/arch/arm/mach-clps711x/board-autcpu12.c
75 +++ b/arch/arm/mach-clps711x/board-autcpu12.c
77 #include <linux/mtd/partitions.h>
78 #include <linux/mtd/nand-gpio.h>
79 #include <linux/platform_device.h>
80 -#include <linux/basic_mmio_gpio.h>
81 +#include <linux/gpio/driver.h>
83 #include <mach/hardware.h>
84 #include <asm/sizes.h>
85 --- a/arch/arm/mach-clps711x/board-p720t.c
86 +++ b/arch/arm/mach-clps711x/board-p720t.c
88 #include <linux/leds.h>
89 #include <linux/sizes.h>
90 #include <linux/backlight.h>
91 -#include <linux/basic_mmio_gpio.h>
92 +#include <linux/gpio/driver.h>
93 #include <linux/platform_device.h>
94 #include <linux/mtd/partitions.h>
95 #include <linux/mtd/nand-gpio.h>
96 --- a/arch/arm/mach-imx/mach-mx21ads.c
97 +++ b/arch/arm/mach-imx/mach-mx21ads.c
99 #include <linux/platform_device.h>
100 #include <linux/mtd/mtd.h>
101 #include <linux/mtd/physmap.h>
102 -#include <linux/basic_mmio_gpio.h>
103 +#include <linux/gpio/driver.h>
104 #include <linux/gpio.h>
105 #include <linux/regulator/fixed.h>
106 #include <linux/regulator/machine.h>
107 --- a/arch/arm/mach-omap1/board-ams-delta.c
108 +++ b/arch/arm/mach-omap1/board-ams-delta.c
110 * it under the terms of the GNU General Public License version 2 as
111 * published by the Free Software Foundation.
113 -#include <linux/basic_mmio_gpio.h>
114 +#include <linux/gpio/driver.h>
115 #include <linux/gpio.h>
116 #include <linux/kernel.h>
117 #include <linux/init.h>
118 --- a/arch/arm/mach-s3c64xx/mach-crag6410.c
119 +++ b/arch/arm/mach-s3c64xx/mach-crag6410.c
121 #include <linux/pwm_backlight.h>
122 #include <linux/dm9000.h>
123 #include <linux/gpio_keys.h>
124 -#include <linux/basic_mmio_gpio.h>
125 +#include <linux/gpio/driver.h>
126 #include <linux/spi/spi.h>
128 #include <linux/platform_data/pca953x.h>
129 --- a/drivers/gpio/gpio-74xx-mmio.c
130 +++ b/drivers/gpio/gpio-74xx-mmio.c
134 #include <linux/err.h>
135 -#include <linux/gpio.h>
136 #include <linux/module.h>
137 #include <linux/of_device.h>
138 -#include <linux/basic_mmio_gpio.h>
139 +#include <linux/gpio/driver.h>
140 #include <linux/platform_device.h>
142 #define MMIO_74XX_DIR_IN (0 << 8)
144 #define MMIO_74XX_BIT_CNT(x) ((x) & 0xff)
146 struct mmio_74xx_gpio_priv {
147 - struct bgpio_chip bgc;
148 + struct gpio_chip gc;
152 @@ -78,30 +77,23 @@ static const struct of_device_id mmio_74
154 MODULE_DEVICE_TABLE(of, mmio_74xx_gpio_ids);
156 -static inline struct mmio_74xx_gpio_priv *to_74xx_gpio(struct gpio_chip *gc)
158 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
160 - return container_of(bgc, struct mmio_74xx_gpio_priv, bgc);
163 static int mmio_74xx_get_direction(struct gpio_chip *gc, unsigned offset)
165 - struct mmio_74xx_gpio_priv *priv = to_74xx_gpio(gc);
166 + struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
168 - return (priv->flags & MMIO_74XX_DIR_OUT) ? GPIOF_DIR_OUT : GPIOF_DIR_IN;
169 + return !(priv->flags & MMIO_74XX_DIR_OUT);
172 static int mmio_74xx_dir_in(struct gpio_chip *gc, unsigned int gpio)
174 - struct mmio_74xx_gpio_priv *priv = to_74xx_gpio(gc);
175 + struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
177 return (priv->flags & MMIO_74XX_DIR_OUT) ? -ENOTSUPP : 0;
180 static int mmio_74xx_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
182 - struct mmio_74xx_gpio_priv *priv = to_74xx_gpio(gc);
183 + struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
185 if (priv->flags & MMIO_74XX_DIR_OUT) {
186 gc->set(gc, gpio, val);
187 @@ -134,28 +126,29 @@ static int mmio_74xx_gpio_probe(struct p
189 priv->flags = (uintptr_t) of_id->data;
191 - err = bgpio_init(&priv->bgc, &pdev->dev,
192 + err = bgpio_init(&priv->gc, &pdev->dev,
193 DIV_ROUND_UP(MMIO_74XX_BIT_CNT(priv->flags), 8),
194 dat, NULL, NULL, NULL, NULL, 0);
198 - priv->bgc.gc.direction_input = mmio_74xx_dir_in;
199 - priv->bgc.gc.direction_output = mmio_74xx_dir_out;
200 - priv->bgc.gc.get_direction = mmio_74xx_get_direction;
201 - priv->bgc.gc.ngpio = MMIO_74XX_BIT_CNT(priv->flags);
202 - priv->bgc.gc.owner = THIS_MODULE;
203 + priv->gc.direction_input = mmio_74xx_dir_in;
204 + priv->gc.direction_output = mmio_74xx_dir_out;
205 + priv->gc.get_direction = mmio_74xx_get_direction;
206 + priv->gc.ngpio = MMIO_74XX_BIT_CNT(priv->flags);
207 + priv->gc.owner = THIS_MODULE;
209 platform_set_drvdata(pdev, priv);
211 - return gpiochip_add(&priv->bgc.gc);
212 + return gpiochip_add_data(&priv->gc, priv);
215 static int mmio_74xx_gpio_remove(struct platform_device *pdev)
217 struct mmio_74xx_gpio_priv *priv = platform_get_drvdata(pdev);
219 - return bgpio_remove(&priv->bgc);
220 + gpiochip_remove(&priv->gc);
224 static struct platform_driver mmio_74xx_gpio_driver = {
225 --- a/drivers/gpio/gpio-brcmstb.c
226 +++ b/drivers/gpio/gpio-brcmstb.c
228 #include <linux/of_device.h>
229 #include <linux/of_irq.h>
230 #include <linux/module.h>
231 -#include <linux/basic_mmio_gpio.h>
232 #include <linux/irqdomain.h>
233 #include <linux/irqchip/chained_irq.h>
234 #include <linux/interrupt.h>
236 struct brcmstb_gpio_bank {
237 struct list_head node;
239 - struct bgpio_chip bgc;
240 + struct gpio_chip gc;
241 struct brcmstb_gpio_priv *parent_priv;
243 struct irq_chip irq_chip;
244 @@ -57,37 +56,30 @@ struct brcmstb_gpio_priv {
245 /* assumes MAX_GPIO_PER_BANK is a multiple of 2 */
246 #define GPIO_BIT(gpio) ((gpio) & (MAX_GPIO_PER_BANK - 1))
248 -static inline struct brcmstb_gpio_bank *
249 -brcmstb_gpio_gc_to_bank(struct gpio_chip *gc)
251 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
252 - return container_of(bgc, struct brcmstb_gpio_bank, bgc);
255 static inline struct brcmstb_gpio_priv *
256 brcmstb_gpio_gc_to_priv(struct gpio_chip *gc)
258 - struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
259 + struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
260 return bank->parent_priv;
263 static void brcmstb_gpio_set_imask(struct brcmstb_gpio_bank *bank,
264 unsigned int offset, bool enable)
266 - struct bgpio_chip *bgc = &bank->bgc;
267 + struct gpio_chip *gc = &bank->gc;
268 struct brcmstb_gpio_priv *priv = bank->parent_priv;
269 - u32 mask = bgc->pin2mask(bgc, offset);
270 + u32 mask = gc->pin2mask(gc, offset);
274 - spin_lock_irqsave(&bgc->lock, flags);
275 - imask = bgc->read_reg(priv->reg_base + GIO_MASK(bank->id));
276 + spin_lock_irqsave(&gc->bgpio_lock, flags);
277 + imask = gc->read_reg(priv->reg_base + GIO_MASK(bank->id));
282 - bgc->write_reg(priv->reg_base + GIO_MASK(bank->id), imask);
283 - spin_unlock_irqrestore(&bgc->lock, flags);
284 + gc->write_reg(priv->reg_base + GIO_MASK(bank->id), imask);
285 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
288 /* -------------------- IRQ chip functions -------------------- */
289 @@ -95,7 +87,7 @@ static void brcmstb_gpio_set_imask(struc
290 static void brcmstb_gpio_irq_mask(struct irq_data *d)
292 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
293 - struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
294 + struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
296 brcmstb_gpio_set_imask(bank, d->hwirq, false);
298 @@ -103,7 +95,7 @@ static void brcmstb_gpio_irq_mask(struct
299 static void brcmstb_gpio_irq_unmask(struct irq_data *d)
301 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
302 - struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
303 + struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
305 brcmstb_gpio_set_imask(bank, d->hwirq, true);
307 @@ -111,7 +103,7 @@ static void brcmstb_gpio_irq_unmask(stru
308 static int brcmstb_gpio_irq_set_type(struct irq_data *d, unsigned int type)
310 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
311 - struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
312 + struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
313 struct brcmstb_gpio_priv *priv = bank->parent_priv;
314 u32 mask = BIT(d->hwirq);
315 u32 edge_insensitive, iedge_insensitive;
316 @@ -149,23 +141,23 @@ static int brcmstb_gpio_irq_set_type(str
320 - spin_lock_irqsave(&bank->bgc.lock, flags);
321 + spin_lock_irqsave(&bank->gc.bgpio_lock, flags);
323 - iedge_config = bank->bgc.read_reg(priv->reg_base +
324 + iedge_config = bank->gc.read_reg(priv->reg_base +
325 GIO_EC(bank->id)) & ~mask;
326 - iedge_insensitive = bank->bgc.read_reg(priv->reg_base +
327 + iedge_insensitive = bank->gc.read_reg(priv->reg_base +
328 GIO_EI(bank->id)) & ~mask;
329 - ilevel = bank->bgc.read_reg(priv->reg_base +
330 + ilevel = bank->gc.read_reg(priv->reg_base +
331 GIO_LEVEL(bank->id)) & ~mask;
333 - bank->bgc.write_reg(priv->reg_base + GIO_EC(bank->id),
334 + bank->gc.write_reg(priv->reg_base + GIO_EC(bank->id),
335 iedge_config | edge_config);
336 - bank->bgc.write_reg(priv->reg_base + GIO_EI(bank->id),
337 + bank->gc.write_reg(priv->reg_base + GIO_EI(bank->id),
338 iedge_insensitive | edge_insensitive);
339 - bank->bgc.write_reg(priv->reg_base + GIO_LEVEL(bank->id),
340 + bank->gc.write_reg(priv->reg_base + GIO_LEVEL(bank->id),
343 - spin_unlock_irqrestore(&bank->bgc.lock, flags);
344 + spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags);
348 @@ -210,29 +202,29 @@ static irqreturn_t brcmstb_gpio_wake_irq
349 static void brcmstb_gpio_irq_bank_handler(struct brcmstb_gpio_bank *bank)
351 struct brcmstb_gpio_priv *priv = bank->parent_priv;
352 - struct irq_domain *irq_domain = bank->bgc.gc.irqdomain;
353 + struct irq_domain *irq_domain = bank->gc.irqdomain;
354 void __iomem *reg_base = priv->reg_base;
355 unsigned long status;
358 - spin_lock_irqsave(&bank->bgc.lock, flags);
359 - while ((status = bank->bgc.read_reg(reg_base + GIO_STAT(bank->id)) &
360 - bank->bgc.read_reg(reg_base + GIO_MASK(bank->id)))) {
361 + spin_lock_irqsave(&bank->gc.bgpio_lock, flags);
362 + while ((status = bank->gc.read_reg(reg_base + GIO_STAT(bank->id)) &
363 + bank->gc.read_reg(reg_base + GIO_MASK(bank->id)))) {
366 for_each_set_bit(bit, &status, 32) {
367 - u32 stat = bank->bgc.read_reg(reg_base +
368 + u32 stat = bank->gc.read_reg(reg_base +
370 if (bit >= bank->width)
371 dev_warn(&priv->pdev->dev,
372 "IRQ for invalid GPIO (bank=%d, offset=%d)\n",
374 - bank->bgc.write_reg(reg_base + GIO_STAT(bank->id),
375 + bank->gc.write_reg(reg_base + GIO_STAT(bank->id),
377 generic_handle_irq(irq_find_mapping(irq_domain, bit));
380 - spin_unlock_irqrestore(&bank->bgc.lock, flags);
381 + spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags);
384 /* Each UPG GIO block has one IRQ for all banks */
385 @@ -303,9 +295,7 @@ static int brcmstb_gpio_remove(struct pl
387 list_for_each(pos, &priv->bank_list) {
388 bank = list_entry(pos, struct brcmstb_gpio_bank, node);
389 - ret = bgpio_remove(&bank->bgc);
391 - dev_err(&pdev->dev, "gpiochip_remove fail in cleanup\n");
392 + gpiochip_remove(&bank->gc);
394 if (priv->reboot_notifier.notifier_call) {
395 ret = unregister_reboot_notifier(&priv->reboot_notifier);
396 @@ -320,7 +310,7 @@ static int brcmstb_gpio_of_xlate(struct
397 const struct of_phandle_args *gpiospec, u32 *flags)
399 struct brcmstb_gpio_priv *priv = brcmstb_gpio_gc_to_priv(gc);
400 - struct brcmstb_gpio_bank *bank = brcmstb_gpio_gc_to_bank(gc);
401 + struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
404 if (gc->of_gpio_n_cells != 2) {
405 @@ -398,9 +388,9 @@ static int brcmstb_gpio_irq_setup(struct
407 bank->irq_chip.irq_set_wake = brcmstb_gpio_irq_set_wake;
409 - gpiochip_irqchip_add(&bank->bgc.gc, &bank->irq_chip, 0,
410 + gpiochip_irqchip_add(&bank->gc, &bank->irq_chip, 0,
411 handle_simple_irq, IRQ_TYPE_NONE);
412 - gpiochip_set_chained_irqchip(&bank->bgc.gc, &bank->irq_chip,
413 + gpiochip_set_chained_irqchip(&bank->gc, &bank->irq_chip,
414 priv->parent_irq, brcmstb_gpio_irq_handler);
417 @@ -451,7 +441,6 @@ static int brcmstb_gpio_probe(struct pla
418 of_property_for_each_u32(np, "brcm,gpio-bank-widths", prop, p,
420 struct brcmstb_gpio_bank *bank;
421 - struct bgpio_chip *bgc;
422 struct gpio_chip *gc;
424 bank = devm_kzalloc(dev, sizeof(*bank), GFP_KERNEL);
425 @@ -473,8 +462,8 @@ static int brcmstb_gpio_probe(struct pla
426 * Regs are 4 bytes wide, have data reg, no set/clear regs,
427 * and direction bits have 0 = output and 1 = input
430 - err = bgpio_init(bgc, dev, 4,
432 + err = bgpio_init(gc, dev, 4,
433 reg_base + GIO_DATA(bank->id),
435 reg_base + GIO_IODIR(bank->id), 0);
436 @@ -483,7 +472,6 @@ static int brcmstb_gpio_probe(struct pla
442 gc->owner = THIS_MODULE;
443 gc->label = np->full_name;
444 @@ -497,9 +485,9 @@ static int brcmstb_gpio_probe(struct pla
445 * Mask all interrupts by default, since wakeup interrupts may
446 * be retained from S5 cold boot
448 - bank->bgc.write_reg(reg_base + GIO_MASK(bank->id), 0);
449 + gc->write_reg(reg_base + GIO_MASK(bank->id), 0);
451 - err = gpiochip_add(gc);
452 + err = gpiochip_add_data(gc, bank);
454 dev_err(dev, "Could not add gpiochip for bank %d\n",
456 --- a/drivers/gpio/gpio-clps711x.c
457 +++ b/drivers/gpio/gpio-clps711x.c
461 #include <linux/err.h>
462 -#include <linux/gpio.h>
463 #include <linux/module.h>
464 -#include <linux/basic_mmio_gpio.h>
465 +#include <linux/gpio/driver.h>
466 #include <linux/platform_device.h>
468 static int clps711x_gpio_probe(struct platform_device *pdev)
470 struct device_node *np = pdev->dev.of_node;
471 void __iomem *dat, *dir;
472 - struct bgpio_chip *bgc;
473 + struct gpio_chip *gc;
474 struct resource *res;
475 int err, id = np ? of_alias_get_id(np, "gpio") : pdev->id;
477 if ((id < 0) || (id > 4))
480 - bgc = devm_kzalloc(&pdev->dev, sizeof(*bgc), GFP_KERNEL);
482 + gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL);
486 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
487 @@ -43,11 +42,11 @@ static int clps711x_gpio_probe(struct pl
490 /* PORTD is inverted logic for direction register */
491 - err = bgpio_init(bgc, &pdev->dev, 1, dat, NULL, NULL,
492 + err = bgpio_init(gc, &pdev->dev, 1, dat, NULL, NULL,
496 - err = bgpio_init(bgc, &pdev->dev, 1, dat, NULL, NULL,
497 + err = bgpio_init(gc, &pdev->dev, 1, dat, NULL, NULL,
501 @@ -58,24 +57,25 @@ static int clps711x_gpio_probe(struct pl
504 /* PORTE is 3 lines only */
512 - bgc->gc.base = id * 8;
513 - bgc->gc.owner = THIS_MODULE;
514 - platform_set_drvdata(pdev, bgc);
516 + gc->owner = THIS_MODULE;
517 + platform_set_drvdata(pdev, gc);
519 - return gpiochip_add(&bgc->gc);
520 + return gpiochip_add_data(gc, NULL);
523 static int clps711x_gpio_remove(struct platform_device *pdev)
525 - struct bgpio_chip *bgc = platform_get_drvdata(pdev);
526 + struct gpio_chip *gc = platform_get_drvdata(pdev);
528 - return bgpio_remove(bgc);
529 + gpiochip_remove(gc);
533 static const struct of_device_id __maybe_unused clps711x_gpio_ids[] = {
534 --- a/drivers/gpio/gpio-dwapb.c
535 +++ b/drivers/gpio/gpio-dwapb.c
538 * All enquiries to support@picochip.com
540 -#include <linux/basic_mmio_gpio.h>
541 +#include <linux/gpio/driver.h>
542 +/* FIXME: for gpio_get_value(), replace this with direct register read */
543 +#include <linux/gpio.h>
544 #include <linux/err.h>
545 #include <linux/init.h>
546 #include <linux/interrupt.h>
547 @@ -66,7 +68,7 @@ struct dwapb_context {
550 struct dwapb_gpio_port {
551 - struct bgpio_chip bgc;
552 + struct gpio_chip gc;
554 struct dwapb_gpio *gpio;
555 #ifdef CONFIG_PM_SLEEP
556 @@ -83,33 +85,26 @@ struct dwapb_gpio {
557 struct irq_domain *domain;
560 -static inline struct dwapb_gpio_port *
561 -to_dwapb_gpio_port(struct bgpio_chip *bgc)
563 - return container_of(bgc, struct dwapb_gpio_port, bgc);
566 static inline u32 dwapb_read(struct dwapb_gpio *gpio, unsigned int offset)
568 - struct bgpio_chip *bgc = &gpio->ports[0].bgc;
569 + struct gpio_chip *gc = &gpio->ports[0].gc;
570 void __iomem *reg_base = gpio->regs;
572 - return bgc->read_reg(reg_base + offset);
573 + return gc->read_reg(reg_base + offset);
576 static inline void dwapb_write(struct dwapb_gpio *gpio, unsigned int offset,
579 - struct bgpio_chip *bgc = &gpio->ports[0].bgc;
580 + struct gpio_chip *gc = &gpio->ports[0].gc;
581 void __iomem *reg_base = gpio->regs;
583 - bgc->write_reg(reg_base + offset, val);
584 + gc->write_reg(reg_base + offset, val);
587 static int dwapb_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
589 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
590 - struct dwapb_gpio_port *port = to_dwapb_gpio_port(bgc);
591 + struct dwapb_gpio_port *port = gpiochip_get_data(gc);
592 struct dwapb_gpio *gpio = port->gpio;
594 return irq_find_mapping(gpio->domain, offset);
595 @@ -119,7 +114,7 @@ static void dwapb_toggle_trigger(struct
597 u32 v = dwapb_read(gpio, GPIO_INT_POLARITY);
599 - if (gpio_get_value(gpio->ports[0].bgc.gc.base + offs))
600 + if (gpio_get_value(gpio->ports[0].gc.base + offs))
604 @@ -162,39 +157,39 @@ static void dwapb_irq_enable(struct irq_
606 struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
607 struct dwapb_gpio *gpio = igc->private;
608 - struct bgpio_chip *bgc = &gpio->ports[0].bgc;
609 + struct gpio_chip *gc = &gpio->ports[0].gc;
613 - spin_lock_irqsave(&bgc->lock, flags);
614 + spin_lock_irqsave(&gc->bgpio_lock, flags);
615 val = dwapb_read(gpio, GPIO_INTEN);
616 val |= BIT(d->hwirq);
617 dwapb_write(gpio, GPIO_INTEN, val);
618 - spin_unlock_irqrestore(&bgc->lock, flags);
619 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
622 static void dwapb_irq_disable(struct irq_data *d)
624 struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
625 struct dwapb_gpio *gpio = igc->private;
626 - struct bgpio_chip *bgc = &gpio->ports[0].bgc;
627 + struct gpio_chip *gc = &gpio->ports[0].gc;
631 - spin_lock_irqsave(&bgc->lock, flags);
632 + spin_lock_irqsave(&gc->bgpio_lock, flags);
633 val = dwapb_read(gpio, GPIO_INTEN);
634 val &= ~BIT(d->hwirq);
635 dwapb_write(gpio, GPIO_INTEN, val);
636 - spin_unlock_irqrestore(&bgc->lock, flags);
637 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
640 static int dwapb_irq_reqres(struct irq_data *d)
642 struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
643 struct dwapb_gpio *gpio = igc->private;
644 - struct bgpio_chip *bgc = &gpio->ports[0].bgc;
645 + struct gpio_chip *gc = &gpio->ports[0].gc;
647 - if (gpiochip_lock_as_irq(&bgc->gc, irqd_to_hwirq(d))) {
648 + if (gpiochip_lock_as_irq(gc, irqd_to_hwirq(d))) {
649 dev_err(gpio->dev, "unable to lock HW IRQ %lu for IRQ\n",
652 @@ -206,16 +201,16 @@ static void dwapb_irq_relres(struct irq_
654 struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
655 struct dwapb_gpio *gpio = igc->private;
656 - struct bgpio_chip *bgc = &gpio->ports[0].bgc;
657 + struct gpio_chip *gc = &gpio->ports[0].gc;
659 - gpiochip_unlock_as_irq(&bgc->gc, irqd_to_hwirq(d));
660 + gpiochip_unlock_as_irq(gc, irqd_to_hwirq(d));
663 static int dwapb_irq_set_type(struct irq_data *d, u32 type)
665 struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
666 struct dwapb_gpio *gpio = igc->private;
667 - struct bgpio_chip *bgc = &gpio->ports[0].bgc;
668 + struct gpio_chip *gc = &gpio->ports[0].gc;
670 unsigned long level, polarity, flags;
672 @@ -223,7 +218,7 @@ static int dwapb_irq_set_type(struct irq
673 IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW))
676 - spin_lock_irqsave(&bgc->lock, flags);
677 + spin_lock_irqsave(&gc->bgpio_lock, flags);
678 level = dwapb_read(gpio, GPIO_INTTYPE_LEVEL);
679 polarity = dwapb_read(gpio, GPIO_INT_POLARITY);
681 @@ -254,7 +249,7 @@ static int dwapb_irq_set_type(struct irq
683 dwapb_write(gpio, GPIO_INTTYPE_LEVEL, level);
684 dwapb_write(gpio, GPIO_INT_POLARITY, polarity);
685 - spin_unlock_irqrestore(&bgc->lock, flags);
686 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
690 @@ -262,13 +257,12 @@ static int dwapb_irq_set_type(struct irq
691 static int dwapb_gpio_set_debounce(struct gpio_chip *gc,
692 unsigned offset, unsigned debounce)
694 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
695 - struct dwapb_gpio_port *port = to_dwapb_gpio_port(bgc);
696 + struct dwapb_gpio_port *port = gpiochip_get_data(gc);
697 struct dwapb_gpio *gpio = port->gpio;
698 unsigned long flags, val_deb;
699 - unsigned long mask = bgc->pin2mask(bgc, offset);
700 + unsigned long mask = gc->pin2mask(gc, offset);
702 - spin_lock_irqsave(&bgc->lock, flags);
703 + spin_lock_irqsave(&gc->bgpio_lock, flags);
705 val_deb = dwapb_read(gpio, GPIO_PORTA_DEBOUNCE);
707 @@ -276,7 +270,7 @@ static int dwapb_gpio_set_debounce(struc
709 dwapb_write(gpio, GPIO_PORTA_DEBOUNCE, val_deb & ~mask);
711 - spin_unlock_irqrestore(&bgc->lock, flags);
712 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
716 @@ -295,7 +289,7 @@ static void dwapb_configure_irqs(struct
717 struct dwapb_gpio_port *port,
718 struct dwapb_port_property *pp)
720 - struct gpio_chip *gc = &port->bgc.gc;
721 + struct gpio_chip *gc = &port->gc;
722 struct device_node *node = pp->node;
723 struct irq_chip_generic *irq_gc = NULL;
724 unsigned int hwirq, ngpio = gc->ngpio;
725 @@ -369,13 +363,13 @@ static void dwapb_configure_irqs(struct
726 for (hwirq = 0 ; hwirq < ngpio ; hwirq++)
727 irq_create_mapping(gpio->domain, hwirq);
729 - port->bgc.gc.to_irq = dwapb_gpio_to_irq;
730 + port->gc.to_irq = dwapb_gpio_to_irq;
733 static void dwapb_irq_teardown(struct dwapb_gpio *gpio)
735 struct dwapb_gpio_port *port = &gpio->ports[0];
736 - struct gpio_chip *gc = &port->bgc.gc;
737 + struct gpio_chip *gc = &port->gc;
738 unsigned int ngpio = gc->ngpio;
739 irq_hw_number_t hwirq;
741 @@ -412,7 +406,7 @@ static int dwapb_gpio_add_port(struct dw
742 dirout = gpio->regs + GPIO_SWPORTA_DDR +
743 (pp->idx * GPIO_SWPORT_DDR_SIZE);
745 - err = bgpio_init(&port->bgc, gpio->dev, 4, dat, set, NULL, dirout,
746 + err = bgpio_init(&port->gc, gpio->dev, 4, dat, set, NULL, dirout,
749 dev_err(gpio->dev, "failed to init gpio chip for %s\n",
750 @@ -421,19 +415,19 @@ static int dwapb_gpio_add_port(struct dw
753 #ifdef CONFIG_OF_GPIO
754 - port->bgc.gc.of_node = pp->node;
755 + port->gc.of_node = pp->node;
757 - port->bgc.gc.ngpio = pp->ngpio;
758 - port->bgc.gc.base = pp->gpio_base;
759 + port->gc.ngpio = pp->ngpio;
760 + port->gc.base = pp->gpio_base;
762 /* Only port A support debounce */
764 - port->bgc.gc.set_debounce = dwapb_gpio_set_debounce;
765 + port->gc.set_debounce = dwapb_gpio_set_debounce;
768 dwapb_configure_irqs(gpio, port, pp);
770 - err = gpiochip_add(&port->bgc.gc);
771 + err = gpiochip_add_data(&port->gc, port);
773 dev_err(gpio->dev, "failed to register gpiochip for %s\n",
775 @@ -449,7 +443,7 @@ static void dwapb_gpio_unregister(struct
777 for (m = 0; m < gpio->nr_ports; ++m)
778 if (gpio->ports[m].is_registered)
779 - gpiochip_remove(&gpio->ports[m].bgc.gc);
780 + gpiochip_remove(&gpio->ports[m].gc);
783 static struct dwapb_platform_data *
784 @@ -591,11 +585,11 @@ static int dwapb_gpio_suspend(struct dev
786 struct platform_device *pdev = to_platform_device(dev);
787 struct dwapb_gpio *gpio = platform_get_drvdata(pdev);
788 - struct bgpio_chip *bgc = &gpio->ports[0].bgc;
789 + struct gpio_chip *gc = &gpio->ports[0].gc;
793 - spin_lock_irqsave(&bgc->lock, flags);
794 + spin_lock_irqsave(&gc->bgpio_lock, flags);
795 for (i = 0; i < gpio->nr_ports; i++) {
797 unsigned int idx = gpio->ports[i].idx;
798 @@ -624,7 +618,7 @@ static int dwapb_gpio_suspend(struct dev
799 dwapb_write(gpio, GPIO_INTMASK, 0xffffffff);
802 - spin_unlock_irqrestore(&bgc->lock, flags);
803 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
807 @@ -633,11 +627,11 @@ static int dwapb_gpio_resume(struct devi
809 struct platform_device *pdev = to_platform_device(dev);
810 struct dwapb_gpio *gpio = platform_get_drvdata(pdev);
811 - struct bgpio_chip *bgc = &gpio->ports[0].bgc;
812 + struct gpio_chip *gc = &gpio->ports[0].gc;
816 - spin_lock_irqsave(&bgc->lock, flags);
817 + spin_lock_irqsave(&gc->bgpio_lock, flags);
818 for (i = 0; i < gpio->nr_ports; i++) {
820 unsigned int idx = gpio->ports[i].idx;
821 @@ -666,7 +660,7 @@ static int dwapb_gpio_resume(struct devi
822 dwapb_write(gpio, GPIO_PORTA_EOI, 0xffffffff);
825 - spin_unlock_irqrestore(&bgc->lock, flags);
826 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
830 --- a/drivers/gpio/gpio-ep93xx.c
831 +++ b/drivers/gpio/gpio-ep93xx.c
833 #include <linux/module.h>
834 #include <linux/platform_device.h>
835 #include <linux/io.h>
836 -#include <linux/gpio.h>
837 #include <linux/irq.h>
838 #include <linux/slab.h>
839 -#include <linux/basic_mmio_gpio.h>
840 +#include <linux/gpio/driver.h>
841 +/* FIXME: this is here for gpio_to_irq() - get rid of this! */
842 +#include <linux/gpio.h>
844 #include <mach/hardware.h>
845 #include <mach/gpio-ep93xx.h>
849 void __iomem *mmio_base;
850 - struct bgpio_chip bgc[8];
851 + struct gpio_chip gc[8];
854 /*************************************************************************
855 @@ -319,26 +320,26 @@ static int ep93xx_gpio_to_irq(struct gpi
859 -static int ep93xx_gpio_add_bank(struct bgpio_chip *bgc, struct device *dev,
860 +static int ep93xx_gpio_add_bank(struct gpio_chip *gc, struct device *dev,
861 void __iomem *mmio_base, struct ep93xx_gpio_bank *bank)
863 void __iomem *data = mmio_base + bank->data;
864 void __iomem *dir = mmio_base + bank->dir;
867 - err = bgpio_init(bgc, dev, 1, data, NULL, NULL, dir, NULL, 0);
868 + err = bgpio_init(gc, dev, 1, data, NULL, NULL, dir, NULL, 0);
872 - bgc->gc.label = bank->label;
873 - bgc->gc.base = bank->base;
874 + gc->label = bank->label;
875 + gc->base = bank->base;
877 if (bank->has_debounce) {
878 - bgc->gc.set_debounce = ep93xx_gpio_set_debounce;
879 - bgc->gc.to_irq = ep93xx_gpio_to_irq;
880 + gc->set_debounce = ep93xx_gpio_set_debounce;
881 + gc->to_irq = ep93xx_gpio_to_irq;
884 - return gpiochip_add(&bgc->gc);
885 + return gpiochip_add_data(gc, NULL);
888 static int ep93xx_gpio_probe(struct platform_device *pdev)
889 @@ -358,10 +359,10 @@ static int ep93xx_gpio_probe(struct plat
890 return PTR_ERR(ep93xx_gpio->mmio_base);
892 for (i = 0; i < ARRAY_SIZE(ep93xx_gpio_banks); i++) {
893 - struct bgpio_chip *bgc = &ep93xx_gpio->bgc[i];
894 + struct gpio_chip *gc = &ep93xx_gpio->gc[i];
895 struct ep93xx_gpio_bank *bank = &ep93xx_gpio_banks[i];
897 - if (ep93xx_gpio_add_bank(bgc, &pdev->dev,
898 + if (ep93xx_gpio_add_bank(gc, &pdev->dev,
899 ep93xx_gpio->mmio_base, bank))
900 dev_warn(&pdev->dev, "Unable to add gpio bank %s\n",
902 --- a/drivers/gpio/gpio-etraxfs.c
903 +++ b/drivers/gpio/gpio-etraxfs.c
905 #include <linux/kernel.h>
906 #include <linux/init.h>
907 -#include <linux/gpio.h>
908 #include <linux/gpio/driver.h>
909 #include <linux/of_gpio.h>
910 #include <linux/io.h>
911 #include <linux/interrupt.h>
912 #include <linux/platform_device.h>
913 -#include <linux/basic_mmio_gpio.h>
915 #define ETRAX_FS_rw_pa_dout 0
916 #define ETRAX_FS_r_pa_din 4
917 @@ -67,7 +65,7 @@ struct etraxfs_gpio_block {
920 struct etraxfs_gpio_chip {
921 - struct bgpio_chip bgc;
922 + struct gpio_chip gc;
923 struct etraxfs_gpio_block *block;
926 @@ -176,11 +174,6 @@ static const struct etraxfs_gpio_info et
927 .rw_intr_pins = ARTPEC3_rw_intr_pins,
930 -static struct etraxfs_gpio_chip *to_etraxfs(struct gpio_chip *gc)
932 - return container_of(gc, struct etraxfs_gpio_chip, bgc.gc);
935 static unsigned int etraxfs_gpio_chip_to_port(struct gpio_chip *gc)
937 return gc->label[0] - 'A';
938 @@ -220,13 +213,13 @@ static unsigned int etraxfs_gpio_to_grou
939 static unsigned int etraxfs_gpio_to_group_pin(struct etraxfs_gpio_chip *chip,
942 - return 4 * etraxfs_gpio_chip_to_port(&chip->bgc.gc) + gpio / 8;
943 + return 4 * etraxfs_gpio_chip_to_port(&chip->gc) + gpio / 8;
946 static void etraxfs_gpio_irq_ack(struct irq_data *d)
948 struct etraxfs_gpio_chip *chip =
949 - to_etraxfs(irq_data_get_irq_chip_data(d));
950 + gpiochip_get_data(irq_data_get_irq_chip_data(d));
951 struct etraxfs_gpio_block *block = chip->block;
952 unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
954 @@ -236,7 +229,7 @@ static void etraxfs_gpio_irq_ack(struct
955 static void etraxfs_gpio_irq_mask(struct irq_data *d)
957 struct etraxfs_gpio_chip *chip =
958 - to_etraxfs(irq_data_get_irq_chip_data(d));
959 + gpiochip_get_data(irq_data_get_irq_chip_data(d));
960 struct etraxfs_gpio_block *block = chip->block;
961 unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
963 @@ -249,7 +242,7 @@ static void etraxfs_gpio_irq_mask(struct
964 static void etraxfs_gpio_irq_unmask(struct irq_data *d)
966 struct etraxfs_gpio_chip *chip =
967 - to_etraxfs(irq_data_get_irq_chip_data(d));
968 + gpiochip_get_data(irq_data_get_irq_chip_data(d));
969 struct etraxfs_gpio_block *block = chip->block;
970 unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
972 @@ -262,7 +255,7 @@ static void etraxfs_gpio_irq_unmask(stru
973 static int etraxfs_gpio_irq_set_type(struct irq_data *d, u32 type)
975 struct etraxfs_gpio_chip *chip =
976 - to_etraxfs(irq_data_get_irq_chip_data(d));
977 + gpiochip_get_data(irq_data_get_irq_chip_data(d));
978 struct etraxfs_gpio_block *block = chip->block;
979 unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
981 @@ -299,7 +292,7 @@ static int etraxfs_gpio_irq_set_type(str
982 static int etraxfs_gpio_irq_request_resources(struct irq_data *d)
984 struct etraxfs_gpio_chip *chip =
985 - to_etraxfs(irq_data_get_irq_chip_data(d));
986 + gpiochip_get_data(irq_data_get_irq_chip_data(d));
987 struct etraxfs_gpio_block *block = chip->block;
988 unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
990 @@ -308,7 +301,7 @@ static int etraxfs_gpio_irq_request_reso
991 if (block->group[grpirq])
994 - ret = gpiochip_lock_as_irq(&chip->bgc.gc, d->hwirq);
995 + ret = gpiochip_lock_as_irq(&chip->gc, d->hwirq);
999 @@ -330,13 +323,13 @@ out:
1000 static void etraxfs_gpio_irq_release_resources(struct irq_data *d)
1002 struct etraxfs_gpio_chip *chip =
1003 - to_etraxfs(irq_data_get_irq_chip_data(d));
1004 + gpiochip_get_data(irq_data_get_irq_chip_data(d));
1005 struct etraxfs_gpio_block *block = chip->block;
1006 unsigned int grpirq = etraxfs_gpio_to_group_irq(d->hwirq);
1008 spin_lock(&block->lock);
1009 block->group[grpirq] = 0;
1010 - gpiochip_unlock_as_irq(&chip->bgc.gc, d->hwirq);
1011 + gpiochip_unlock_as_irq(&chip->gc, d->hwirq);
1012 spin_unlock(&block->lock);
1015 @@ -419,7 +412,7 @@ static int etraxfs_gpio_probe(struct pla
1017 for (i = 0; i < info->num_ports; i++) {
1018 struct etraxfs_gpio_chip *chip = &chips[i];
1019 - struct bgpio_chip *bgc = &chip->bgc;
1020 + struct gpio_chip *gc = &chip->gc;
1021 const struct etraxfs_gpio_port *port = &info->ports[i];
1022 unsigned long flags = BGPIOF_READ_OUTPUT_REG_SET;
1023 void __iomem *dat = regs + port->din;
1024 @@ -433,7 +426,7 @@ static int etraxfs_gpio_probe(struct pla
1025 flags = BGPIOF_NO_OUTPUT;
1028 - ret = bgpio_init(bgc, dev, 4,
1029 + ret = bgpio_init(gc, dev, 4,
1030 dat, set, NULL, dirout, NULL,
1033 @@ -442,28 +435,28 @@ static int etraxfs_gpio_probe(struct pla
1037 - bgc->gc.ngpio = port->ngpio;
1038 - bgc->gc.label = port->label;
1039 + gc->ngpio = port->ngpio;
1040 + gc->label = port->label;
1042 - bgc->gc.of_node = dev->of_node;
1043 - bgc->gc.of_gpio_n_cells = 3;
1044 - bgc->gc.of_xlate = etraxfs_gpio_of_xlate;
1045 + gc->of_node = dev->of_node;
1046 + gc->of_gpio_n_cells = 3;
1047 + gc->of_xlate = etraxfs_gpio_of_xlate;
1049 - ret = gpiochip_add(&bgc->gc);
1050 + ret = gpiochip_add_data(gc, chip);
1052 dev_err(dev, "Unable to register port %s\n",
1058 if (i > 0 && !allportsirq)
1061 - ret = gpiochip_irqchip_add(&bgc->gc, &etraxfs_gpio_irq_chip, 0,
1062 + ret = gpiochip_irqchip_add(gc, &etraxfs_gpio_irq_chip, 0,
1063 handle_level_irq, IRQ_TYPE_NONE);
1065 dev_err(dev, "Unable to add irqchip to port %s\n",
1071 --- a/drivers/gpio/gpio-ge.c
1072 +++ b/drivers/gpio/gpio-ge.c
1074 #include <linux/of_gpio.h>
1075 #include <linux/of_address.h>
1076 #include <linux/module.h>
1077 -#include <linux/basic_mmio_gpio.h>
1078 +#include <linux/gpio/driver.h>
1080 #define GEF_GPIO_DIRECT 0x00
1081 #define GEF_GPIO_IN 0x04
1082 @@ -55,19 +55,19 @@ static int __init gef_gpio_probe(struct
1084 const struct of_device_id *of_id =
1085 of_match_device(gef_gpio_ids, &pdev->dev);
1086 - struct bgpio_chip *bgc;
1087 + struct gpio_chip *gc;
1091 - bgc = devm_kzalloc(&pdev->dev, sizeof(*bgc), GFP_KERNEL);
1093 + gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL);
1097 regs = of_iomap(pdev->dev.of_node, 0);
1101 - ret = bgpio_init(bgc, &pdev->dev, 4, regs + GEF_GPIO_IN,
1102 + ret = bgpio_init(gc, &pdev->dev, 4, regs + GEF_GPIO_IN,
1103 regs + GEF_GPIO_OUT, NULL, NULL,
1104 regs + GEF_GPIO_DIRECT, BGPIOF_BIG_ENDIAN_BYTE_ORDER);
1106 @@ -76,20 +76,20 @@ static int __init gef_gpio_probe(struct
1109 /* Setup pointers to chip functions */
1110 - bgc->gc.label = devm_kstrdup(&pdev->dev, pdev->dev.of_node->full_name,
1111 + gc->label = devm_kstrdup(&pdev->dev, pdev->dev.of_node->full_name,
1113 - if (!bgc->gc.label) {
1119 - bgc->gc.base = -1;
1120 - bgc->gc.ngpio = (u16)(uintptr_t)of_id->data;
1121 - bgc->gc.of_gpio_n_cells = 2;
1122 - bgc->gc.of_node = pdev->dev.of_node;
1124 + gc->ngpio = (u16)(uintptr_t)of_id->data;
1125 + gc->of_gpio_n_cells = 2;
1126 + gc->of_node = pdev->dev.of_node;
1128 /* This function adds a memory mapped GPIO chip */
1129 - ret = gpiochip_add(&bgc->gc);
1130 + ret = gpiochip_add_data(gc, NULL);
1134 --- a/drivers/gpio/gpio-generic.c
1135 +++ b/drivers/gpio/gpio-generic.c
1136 @@ -56,11 +56,10 @@ o ` ~~~~\___/
1137 #include <linux/log2.h>
1138 #include <linux/ioport.h>
1139 #include <linux/io.h>
1140 -#include <linux/gpio.h>
1141 +#include <linux/gpio/driver.h>
1142 #include <linux/slab.h>
1143 #include <linux/platform_device.h>
1144 #include <linux/mod_devicetable.h>
1145 -#include <linux/basic_mmio_gpio.h>
1147 static void bgpio_write8(void __iomem *reg, unsigned long data)
1149 @@ -124,33 +123,30 @@ static unsigned long bgpio_read32be(void
1150 return ioread32be(reg);
1153 -static unsigned long bgpio_pin2mask(struct bgpio_chip *bgc, unsigned int pin)
1154 +static unsigned long bgpio_pin2mask(struct gpio_chip *gc, unsigned int pin)
1159 -static unsigned long bgpio_pin2mask_be(struct bgpio_chip *bgc,
1160 +static unsigned long bgpio_pin2mask_be(struct gpio_chip *gc,
1163 - return 1 << (bgc->bits - 1 - pin);
1164 + return 1 << (gc->bgpio_bits - 1 - pin);
1167 static int bgpio_get_set(struct gpio_chip *gc, unsigned int gpio)
1169 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1170 - unsigned long pinmask = bgc->pin2mask(bgc, gpio);
1171 + unsigned long pinmask = gc->pin2mask(gc, gpio);
1173 - if (bgc->dir & pinmask)
1174 - return !!(bgc->read_reg(bgc->reg_set) & pinmask);
1175 + if (gc->bgpio_dir & pinmask)
1176 + return !!(gc->read_reg(gc->reg_set) & pinmask);
1178 - return !!(bgc->read_reg(bgc->reg_dat) & pinmask);
1179 + return !!(gc->read_reg(gc->reg_dat) & pinmask);
1182 static int bgpio_get(struct gpio_chip *gc, unsigned int gpio)
1184 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1186 - return !!(bgc->read_reg(bgc->reg_dat) & bgc->pin2mask(bgc, gpio));
1187 + return !!(gc->read_reg(gc->reg_dat) & gc->pin2mask(gc, gpio));
1190 static void bgpio_set_none(struct gpio_chip *gc, unsigned int gpio, int val)
1191 @@ -159,53 +155,50 @@ static void bgpio_set_none(struct gpio_c
1193 static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
1195 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1196 - unsigned long mask = bgc->pin2mask(bgc, gpio);
1197 + unsigned long mask = gc->pin2mask(gc, gpio);
1198 unsigned long flags;
1200 - spin_lock_irqsave(&bgc->lock, flags);
1201 + spin_lock_irqsave(&gc->bgpio_lock, flags);
1204 - bgc->data |= mask;
1205 + gc->bgpio_data |= mask;
1207 - bgc->data &= ~mask;
1208 + gc->bgpio_data &= ~mask;
1210 - bgc->write_reg(bgc->reg_dat, bgc->data);
1211 + gc->write_reg(gc->reg_dat, gc->bgpio_data);
1213 - spin_unlock_irqrestore(&bgc->lock, flags);
1214 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
1217 static void bgpio_set_with_clear(struct gpio_chip *gc, unsigned int gpio,
1220 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1221 - unsigned long mask = bgc->pin2mask(bgc, gpio);
1222 + unsigned long mask = gc->pin2mask(gc, gpio);
1225 - bgc->write_reg(bgc->reg_set, mask);
1226 + gc->write_reg(gc->reg_set, mask);
1228 - bgc->write_reg(bgc->reg_clr, mask);
1229 + gc->write_reg(gc->reg_clr, mask);
1232 static void bgpio_set_set(struct gpio_chip *gc, unsigned int gpio, int val)
1234 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1235 - unsigned long mask = bgc->pin2mask(bgc, gpio);
1236 + unsigned long mask = gc->pin2mask(gc, gpio);
1237 unsigned long flags;
1239 - spin_lock_irqsave(&bgc->lock, flags);
1240 + spin_lock_irqsave(&gc->bgpio_lock, flags);
1243 - bgc->data |= mask;
1244 + gc->bgpio_data |= mask;
1246 - bgc->data &= ~mask;
1247 + gc->bgpio_data &= ~mask;
1249 - bgc->write_reg(bgc->reg_set, bgc->data);
1250 + gc->write_reg(gc->reg_set, gc->bgpio_data);
1252 - spin_unlock_irqrestore(&bgc->lock, flags);
1253 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
1256 -static void bgpio_multiple_get_masks(struct bgpio_chip *bgc,
1257 +static void bgpio_multiple_get_masks(struct gpio_chip *gc,
1258 unsigned long *mask, unsigned long *bits,
1259 unsigned long *set_mask,
1260 unsigned long *clear_mask)
1261 @@ -215,19 +208,19 @@ static void bgpio_multiple_get_masks(str
1265 - for (i = 0; i < bgc->bits; i++) {
1266 + for (i = 0; i < gc->bgpio_bits; i++) {
1269 if (__test_and_clear_bit(i, mask)) {
1270 if (test_bit(i, bits))
1271 - *set_mask |= bgc->pin2mask(bgc, i);
1272 + *set_mask |= gc->pin2mask(gc, i);
1274 - *clear_mask |= bgc->pin2mask(bgc, i);
1275 + *clear_mask |= gc->pin2mask(gc, i);
1280 -static void bgpio_set_multiple_single_reg(struct bgpio_chip *bgc,
1281 +static void bgpio_set_multiple_single_reg(struct gpio_chip *gc,
1282 unsigned long *mask,
1283 unsigned long *bits,
1285 @@ -235,47 +228,42 @@ static void bgpio_set_multiple_single_re
1286 unsigned long flags;
1287 unsigned long set_mask, clear_mask;
1289 - spin_lock_irqsave(&bgc->lock, flags);
1290 + spin_lock_irqsave(&gc->bgpio_lock, flags);
1292 - bgpio_multiple_get_masks(bgc, mask, bits, &set_mask, &clear_mask);
1293 + bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask);
1295 - bgc->data |= set_mask;
1296 - bgc->data &= ~clear_mask;
1297 + gc->bgpio_data |= set_mask;
1298 + gc->bgpio_data &= ~clear_mask;
1300 - bgc->write_reg(reg, bgc->data);
1301 + gc->write_reg(reg, gc->bgpio_data);
1303 - spin_unlock_irqrestore(&bgc->lock, flags);
1304 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
1307 static void bgpio_set_multiple(struct gpio_chip *gc, unsigned long *mask,
1308 unsigned long *bits)
1310 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1312 - bgpio_set_multiple_single_reg(bgc, mask, bits, bgc->reg_dat);
1313 + bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_dat);
1316 static void bgpio_set_multiple_set(struct gpio_chip *gc, unsigned long *mask,
1317 unsigned long *bits)
1319 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1321 - bgpio_set_multiple_single_reg(bgc, mask, bits, bgc->reg_set);
1322 + bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_set);
1325 static void bgpio_set_multiple_with_clear(struct gpio_chip *gc,
1326 unsigned long *mask,
1327 unsigned long *bits)
1329 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1330 unsigned long set_mask, clear_mask;
1332 - bgpio_multiple_get_masks(bgc, mask, bits, &set_mask, &clear_mask);
1333 + bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask);
1336 - bgc->write_reg(bgc->reg_set, set_mask);
1337 + gc->write_reg(gc->reg_set, set_mask);
1339 - bgc->write_reg(bgc->reg_clr, clear_mask);
1340 + gc->write_reg(gc->reg_clr, clear_mask);
1343 static int bgpio_simple_dir_in(struct gpio_chip *gc, unsigned int gpio)
1344 @@ -299,111 +287,103 @@ static int bgpio_simple_dir_out(struct g
1346 static int bgpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
1348 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1349 unsigned long flags;
1351 - spin_lock_irqsave(&bgc->lock, flags);
1352 + spin_lock_irqsave(&gc->bgpio_lock, flags);
1354 - bgc->dir &= ~bgc->pin2mask(bgc, gpio);
1355 - bgc->write_reg(bgc->reg_dir, bgc->dir);
1356 + gc->bgpio_dir &= ~gc->pin2mask(gc, gpio);
1357 + gc->write_reg(gc->reg_dir, gc->bgpio_dir);
1359 - spin_unlock_irqrestore(&bgc->lock, flags);
1360 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
1365 static int bgpio_get_dir(struct gpio_chip *gc, unsigned int gpio)
1367 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1369 - return (bgc->read_reg(bgc->reg_dir) & bgc->pin2mask(bgc, gpio)) ?
1370 - GPIOF_DIR_OUT : GPIOF_DIR_IN;
1371 + /* Return 0 if output, 1 of input */
1372 + return !(gc->read_reg(gc->reg_dir) & gc->pin2mask(gc, gpio));
1375 static int bgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
1377 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1378 unsigned long flags;
1380 gc->set(gc, gpio, val);
1382 - spin_lock_irqsave(&bgc->lock, flags);
1383 + spin_lock_irqsave(&gc->bgpio_lock, flags);
1385 - bgc->dir |= bgc->pin2mask(bgc, gpio);
1386 - bgc->write_reg(bgc->reg_dir, bgc->dir);
1387 + gc->bgpio_dir |= gc->pin2mask(gc, gpio);
1388 + gc->write_reg(gc->reg_dir, gc->bgpio_dir);
1390 - spin_unlock_irqrestore(&bgc->lock, flags);
1391 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
1396 static int bgpio_dir_in_inv(struct gpio_chip *gc, unsigned int gpio)
1398 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1399 unsigned long flags;
1401 - spin_lock_irqsave(&bgc->lock, flags);
1402 + spin_lock_irqsave(&gc->bgpio_lock, flags);
1404 - bgc->dir |= bgc->pin2mask(bgc, gpio);
1405 - bgc->write_reg(bgc->reg_dir, bgc->dir);
1406 + gc->bgpio_dir |= gc->pin2mask(gc, gpio);
1407 + gc->write_reg(gc->reg_dir, gc->bgpio_dir);
1409 - spin_unlock_irqrestore(&bgc->lock, flags);
1410 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
1415 static int bgpio_dir_out_inv(struct gpio_chip *gc, unsigned int gpio, int val)
1417 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1418 unsigned long flags;
1420 gc->set(gc, gpio, val);
1422 - spin_lock_irqsave(&bgc->lock, flags);
1423 + spin_lock_irqsave(&gc->bgpio_lock, flags);
1425 - bgc->dir &= ~bgc->pin2mask(bgc, gpio);
1426 - bgc->write_reg(bgc->reg_dir, bgc->dir);
1427 + gc->bgpio_dir &= ~gc->pin2mask(gc, gpio);
1428 + gc->write_reg(gc->reg_dir, gc->bgpio_dir);
1430 - spin_unlock_irqrestore(&bgc->lock, flags);
1431 + spin_unlock_irqrestore(&gc->bgpio_lock, flags);
1436 static int bgpio_get_dir_inv(struct gpio_chip *gc, unsigned int gpio)
1438 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1440 - return (bgc->read_reg(bgc->reg_dir) & bgc->pin2mask(bgc, gpio)) ?
1441 - GPIOF_DIR_IN : GPIOF_DIR_OUT;
1442 + /* Return 0 if output, 1 if input */
1443 + return !!(gc->read_reg(gc->reg_dir) & gc->pin2mask(gc, gpio));
1446 static int bgpio_setup_accessors(struct device *dev,
1447 - struct bgpio_chip *bgc,
1448 + struct gpio_chip *gc,
1453 - switch (bgc->bits) {
1454 + switch (gc->bgpio_bits) {
1456 - bgc->read_reg = bgpio_read8;
1457 - bgc->write_reg = bgpio_write8;
1458 + gc->read_reg = bgpio_read8;
1459 + gc->write_reg = bgpio_write8;
1463 - bgc->read_reg = bgpio_read16be;
1464 - bgc->write_reg = bgpio_write16be;
1465 + gc->read_reg = bgpio_read16be;
1466 + gc->write_reg = bgpio_write16be;
1468 - bgc->read_reg = bgpio_read16;
1469 - bgc->write_reg = bgpio_write16;
1470 + gc->read_reg = bgpio_read16;
1471 + gc->write_reg = bgpio_write16;
1476 - bgc->read_reg = bgpio_read32be;
1477 - bgc->write_reg = bgpio_write32be;
1478 + gc->read_reg = bgpio_read32be;
1479 + gc->write_reg = bgpio_write32be;
1481 - bgc->read_reg = bgpio_read32;
1482 - bgc->write_reg = bgpio_write32;
1483 + gc->read_reg = bgpio_read32;
1484 + gc->write_reg = bgpio_write32;
1487 #if BITS_PER_LONG >= 64
1488 @@ -413,17 +393,17 @@ static int bgpio_setup_accessors(struct
1489 "64 bit big endian byte order unsupported\n");
1492 - bgc->read_reg = bgpio_read64;
1493 - bgc->write_reg = bgpio_write64;
1494 + gc->read_reg = bgpio_read64;
1495 + gc->write_reg = bgpio_write64;
1498 #endif /* BITS_PER_LONG >= 64 */
1500 - dev_err(dev, "unsupported data width %u bits\n", bgc->bits);
1501 + dev_err(dev, "unsupported data width %u bits\n", gc->bgpio_bits);
1505 - bgc->pin2mask = bit_be ? bgpio_pin2mask_be : bgpio_pin2mask;
1506 + gc->pin2mask = bit_be ? bgpio_pin2mask_be : bgpio_pin2mask;
1510 @@ -450,44 +430,44 @@ static int bgpio_setup_accessors(struct
1511 * - an input direction register (named "dirin") where a 1 bit indicates
1512 * the GPIO is an input.
1514 -static int bgpio_setup_io(struct bgpio_chip *bgc,
1515 +static int bgpio_setup_io(struct gpio_chip *gc,
1519 unsigned long flags)
1522 - bgc->reg_dat = dat;
1523 - if (!bgc->reg_dat)
1524 + gc->reg_dat = dat;
1529 - bgc->reg_set = set;
1530 - bgc->reg_clr = clr;
1531 - bgc->gc.set = bgpio_set_with_clear;
1532 - bgc->gc.set_multiple = bgpio_set_multiple_with_clear;
1533 + gc->reg_set = set;
1534 + gc->reg_clr = clr;
1535 + gc->set = bgpio_set_with_clear;
1536 + gc->set_multiple = bgpio_set_multiple_with_clear;
1537 } else if (set && !clr) {
1538 - bgc->reg_set = set;
1539 - bgc->gc.set = bgpio_set_set;
1540 - bgc->gc.set_multiple = bgpio_set_multiple_set;
1541 + gc->reg_set = set;
1542 + gc->set = bgpio_set_set;
1543 + gc->set_multiple = bgpio_set_multiple_set;
1544 } else if (flags & BGPIOF_NO_OUTPUT) {
1545 - bgc->gc.set = bgpio_set_none;
1546 - bgc->gc.set_multiple = NULL;
1547 + gc->set = bgpio_set_none;
1548 + gc->set_multiple = NULL;
1550 - bgc->gc.set = bgpio_set;
1551 - bgc->gc.set_multiple = bgpio_set_multiple;
1552 + gc->set = bgpio_set;
1553 + gc->set_multiple = bgpio_set_multiple;
1556 if (!(flags & BGPIOF_UNREADABLE_REG_SET) &&
1557 (flags & BGPIOF_READ_OUTPUT_REG_SET))
1558 - bgc->gc.get = bgpio_get_set;
1559 + gc->get = bgpio_get_set;
1561 - bgc->gc.get = bgpio_get;
1562 + gc->get = bgpio_get;
1567 -static int bgpio_setup_direction(struct bgpio_chip *bgc,
1568 +static int bgpio_setup_direction(struct gpio_chip *gc,
1569 void __iomem *dirout,
1570 void __iomem *dirin,
1571 unsigned long flags)
1572 @@ -495,21 +475,21 @@ static int bgpio_setup_direction(struct
1573 if (dirout && dirin) {
1575 } else if (dirout) {
1576 - bgc->reg_dir = dirout;
1577 - bgc->gc.direction_output = bgpio_dir_out;
1578 - bgc->gc.direction_input = bgpio_dir_in;
1579 - bgc->gc.get_direction = bgpio_get_dir;
1580 + gc->reg_dir = dirout;
1581 + gc->direction_output = bgpio_dir_out;
1582 + gc->direction_input = bgpio_dir_in;
1583 + gc->get_direction = bgpio_get_dir;
1585 - bgc->reg_dir = dirin;
1586 - bgc->gc.direction_output = bgpio_dir_out_inv;
1587 - bgc->gc.direction_input = bgpio_dir_in_inv;
1588 - bgc->gc.get_direction = bgpio_get_dir_inv;
1589 + gc->reg_dir = dirin;
1590 + gc->direction_output = bgpio_dir_out_inv;
1591 + gc->direction_input = bgpio_dir_in_inv;
1592 + gc->get_direction = bgpio_get_dir_inv;
1594 if (flags & BGPIOF_NO_OUTPUT)
1595 - bgc->gc.direction_output = bgpio_dir_out_err;
1596 + gc->direction_output = bgpio_dir_out_err;
1598 - bgc->gc.direction_output = bgpio_simple_dir_out;
1599 - bgc->gc.direction_input = bgpio_simple_dir_in;
1600 + gc->direction_output = bgpio_simple_dir_out;
1601 + gc->direction_input = bgpio_simple_dir_in;
1605 @@ -523,14 +503,7 @@ static int bgpio_request(struct gpio_chi
1609 -int bgpio_remove(struct bgpio_chip *bgc)
1611 - gpiochip_remove(&bgc->gc);
1614 -EXPORT_SYMBOL_GPL(bgpio_remove);
1616 -int bgpio_init(struct bgpio_chip *bgc, struct device *dev,
1617 +int bgpio_init(struct gpio_chip *gc, struct device *dev,
1618 unsigned long sz, void __iomem *dat, void __iomem *set,
1619 void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
1620 unsigned long flags)
1621 @@ -540,36 +513,36 @@ int bgpio_init(struct bgpio_chip *bgc, s
1622 if (!is_power_of_2(sz))
1625 - bgc->bits = sz * 8;
1626 - if (bgc->bits > BITS_PER_LONG)
1627 + gc->bgpio_bits = sz * 8;
1628 + if (gc->bgpio_bits > BITS_PER_LONG)
1631 - spin_lock_init(&bgc->lock);
1632 - bgc->gc.dev = dev;
1633 - bgc->gc.label = dev_name(dev);
1634 - bgc->gc.base = -1;
1635 - bgc->gc.ngpio = bgc->bits;
1636 - bgc->gc.request = bgpio_request;
1637 + spin_lock_init(&gc->bgpio_lock);
1639 + gc->label = dev_name(dev);
1641 + gc->ngpio = gc->bgpio_bits;
1642 + gc->request = bgpio_request;
1644 - ret = bgpio_setup_io(bgc, dat, set, clr, flags);
1645 + ret = bgpio_setup_io(gc, dat, set, clr, flags);
1649 - ret = bgpio_setup_accessors(dev, bgc, flags & BGPIOF_BIG_ENDIAN,
1650 + ret = bgpio_setup_accessors(dev, gc, flags & BGPIOF_BIG_ENDIAN,
1651 flags & BGPIOF_BIG_ENDIAN_BYTE_ORDER);
1655 - ret = bgpio_setup_direction(bgc, dirout, dirin, flags);
1656 + ret = bgpio_setup_direction(gc, dirout, dirin, flags);
1660 - bgc->data = bgc->read_reg(bgc->reg_dat);
1661 - if (bgc->gc.set == bgpio_set_set &&
1662 + gc->bgpio_data = gc->read_reg(gc->reg_dat);
1663 + if (gc->set == bgpio_set_set &&
1664 !(flags & BGPIOF_UNREADABLE_REG_SET))
1665 - bgc->data = bgc->read_reg(bgc->reg_set);
1666 - if (bgc->reg_dir && !(flags & BGPIOF_UNREADABLE_REG_DIR))
1667 - bgc->dir = bgc->read_reg(bgc->reg_dir);
1668 + gc->bgpio_data = gc->read_reg(gc->reg_set);
1669 + if (gc->reg_dir && !(flags & BGPIOF_UNREADABLE_REG_DIR))
1670 + gc->bgpio_dir = gc->read_reg(gc->reg_dir);
1674 @@ -607,7 +580,7 @@ static int bgpio_pdev_probe(struct platf
1676 unsigned long flags = pdev->id_entry->driver_data;
1678 - struct bgpio_chip *bgc;
1679 + struct gpio_chip *gc;
1680 struct bgpio_pdata *pdata = dev_get_platdata(dev);
1682 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dat");
1683 @@ -636,32 +609,33 @@ static int bgpio_pdev_probe(struct platf
1685 return PTR_ERR(dirin);
1687 - bgc = devm_kzalloc(&pdev->dev, sizeof(*bgc), GFP_KERNEL);
1689 + gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL);
1693 - err = bgpio_init(bgc, dev, sz, dat, set, clr, dirout, dirin, flags);
1694 + err = bgpio_init(gc, dev, sz, dat, set, clr, dirout, dirin, flags);
1700 - bgc->gc.label = pdata->label;
1701 - bgc->gc.base = pdata->base;
1702 + gc->label = pdata->label;
1703 + gc->base = pdata->base;
1704 if (pdata->ngpio > 0)
1705 - bgc->gc.ngpio = pdata->ngpio;
1706 + gc->ngpio = pdata->ngpio;
1709 - platform_set_drvdata(pdev, bgc);
1710 + platform_set_drvdata(pdev, gc);
1712 - return gpiochip_add(&bgc->gc);
1713 + return gpiochip_add_data(gc, NULL);
1716 static int bgpio_pdev_remove(struct platform_device *pdev)
1718 - struct bgpio_chip *bgc = platform_get_drvdata(pdev);
1719 + struct gpio_chip *gc = platform_get_drvdata(pdev);
1721 - return bgpio_remove(bgc);
1722 + gpiochip_remove(gc);
1726 static const struct platform_device_id bgpio_id_table[] = {
1727 --- a/drivers/gpio/gpio-grgpio.c
1728 +++ b/drivers/gpio/gpio-grgpio.c
1730 #include <linux/gpio.h>
1731 #include <linux/slab.h>
1732 #include <linux/err.h>
1733 -#include <linux/basic_mmio_gpio.h>
1734 +#include <linux/gpio/driver.h>
1735 #include <linux/interrupt.h>
1736 #include <linux/irq.h>
1737 #include <linux/irqdomain.h>
1738 @@ -63,7 +63,7 @@ struct grgpio_lirq {
1741 struct grgpio_priv {
1742 - struct bgpio_chip bgc;
1743 + struct gpio_chip gc;
1747 @@ -92,29 +92,22 @@ struct grgpio_priv {
1748 struct grgpio_lirq lirqs[GRGPIO_MAX_NGPIO];
1751 -static inline struct grgpio_priv *grgpio_gc_to_priv(struct gpio_chip *gc)
1753 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
1755 - return container_of(bgc, struct grgpio_priv, bgc);
1758 static void grgpio_set_imask(struct grgpio_priv *priv, unsigned int offset,
1761 - struct bgpio_chip *bgc = &priv->bgc;
1762 - unsigned long mask = bgc->pin2mask(bgc, offset);
1763 + struct gpio_chip *gc = &priv->gc;
1764 + unsigned long mask = gc->pin2mask(gc, offset);
1767 priv->imask |= mask;
1769 priv->imask &= ~mask;
1770 - bgc->write_reg(priv->regs + GRGPIO_IMASK, priv->imask);
1771 + gc->write_reg(priv->regs + GRGPIO_IMASK, priv->imask);
1774 static int grgpio_to_irq(struct gpio_chip *gc, unsigned offset)
1776 - struct grgpio_priv *priv = grgpio_gc_to_priv(gc);
1777 + struct grgpio_priv *priv = gpiochip_get_data(gc);
1779 if (offset >= gc->ngpio)
1781 @@ -158,15 +151,15 @@ static int grgpio_irq_set_type(struct ir
1785 - spin_lock_irqsave(&priv->bgc.lock, flags);
1786 + spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
1788 - ipol = priv->bgc.read_reg(priv->regs + GRGPIO_IPOL) & ~mask;
1789 - iedge = priv->bgc.read_reg(priv->regs + GRGPIO_IEDGE) & ~mask;
1790 + ipol = priv->gc.read_reg(priv->regs + GRGPIO_IPOL) & ~mask;
1791 + iedge = priv->gc.read_reg(priv->regs + GRGPIO_IEDGE) & ~mask;
1793 - priv->bgc.write_reg(priv->regs + GRGPIO_IPOL, ipol | pol);
1794 - priv->bgc.write_reg(priv->regs + GRGPIO_IEDGE, iedge | edge);
1795 + priv->gc.write_reg(priv->regs + GRGPIO_IPOL, ipol | pol);
1796 + priv->gc.write_reg(priv->regs + GRGPIO_IEDGE, iedge | edge);
1798 - spin_unlock_irqrestore(&priv->bgc.lock, flags);
1799 + spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
1803 @@ -177,11 +170,11 @@ static void grgpio_irq_mask(struct irq_d
1804 int offset = d->hwirq;
1805 unsigned long flags;
1807 - spin_lock_irqsave(&priv->bgc.lock, flags);
1808 + spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
1810 grgpio_set_imask(priv, offset, 0);
1812 - spin_unlock_irqrestore(&priv->bgc.lock, flags);
1813 + spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
1816 static void grgpio_irq_unmask(struct irq_data *d)
1817 @@ -190,11 +183,11 @@ static void grgpio_irq_unmask(struct irq
1818 int offset = d->hwirq;
1819 unsigned long flags;
1821 - spin_lock_irqsave(&priv->bgc.lock, flags);
1822 + spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
1824 grgpio_set_imask(priv, offset, 1);
1826 - spin_unlock_irqrestore(&priv->bgc.lock, flags);
1827 + spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
1830 static struct irq_chip grgpio_irq_chip = {
1831 @@ -207,12 +200,12 @@ static struct irq_chip grgpio_irq_chip =
1832 static irqreturn_t grgpio_irq_handler(int irq, void *dev)
1834 struct grgpio_priv *priv = dev;
1835 - int ngpio = priv->bgc.gc.ngpio;
1836 + int ngpio = priv->gc.ngpio;
1837 unsigned long flags;
1841 - spin_lock_irqsave(&priv->bgc.lock, flags);
1842 + spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
1845 * For each gpio line, call its interrupt handler if it its underlying
1846 @@ -228,7 +221,7 @@ static irqreturn_t grgpio_irq_handler(in
1850 - spin_unlock_irqrestore(&priv->bgc.lock, flags);
1851 + spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
1854 dev_warn(priv->dev, "No gpio line matched irq %d\n", irq);
1855 @@ -260,7 +253,7 @@ static int grgpio_irq_map(struct irq_dom
1856 dev_dbg(priv->dev, "Mapping irq %d for gpio line %d\n",
1859 - spin_lock_irqsave(&priv->bgc.lock, flags);
1860 + spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
1862 /* Request underlying irq if not already requested */
1864 @@ -273,14 +266,14 @@ static int grgpio_irq_map(struct irq_dom
1865 "Could not request underlying irq %d\n",
1868 - spin_unlock_irqrestore(&priv->bgc.lock, flags);
1869 + spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
1876 - spin_unlock_irqrestore(&priv->bgc.lock, flags);
1877 + spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
1880 irq_set_chip_data(irq, priv);
1881 @@ -298,13 +291,13 @@ static void grgpio_irq_unmap(struct irq_
1882 struct grgpio_lirq *lirq;
1883 struct grgpio_uirq *uirq;
1884 unsigned long flags;
1885 - int ngpio = priv->bgc.gc.ngpio;
1886 + int ngpio = priv->gc.ngpio;
1889 irq_set_chip_and_handler(irq, NULL, NULL);
1890 irq_set_chip_data(irq, NULL);
1892 - spin_lock_irqsave(&priv->bgc.lock, flags);
1893 + spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
1895 /* Free underlying irq if last user unmapped */
1897 @@ -326,7 +319,7 @@ static void grgpio_irq_unmap(struct irq_
1898 free_irq(uirq->uirq, priv);
1901 - spin_unlock_irqrestore(&priv->bgc.lock, flags);
1902 + spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
1905 static const struct irq_domain_ops grgpio_irq_domain_ops = {
1906 @@ -341,7 +334,6 @@ static int grgpio_probe(struct platform_
1907 struct device_node *np = ofdev->dev.of_node;
1909 struct gpio_chip *gc;
1910 - struct bgpio_chip *bgc;
1911 struct grgpio_priv *priv;
1912 struct resource *res;
1914 @@ -359,8 +351,8 @@ static int grgpio_probe(struct platform_
1916 return PTR_ERR(regs);
1919 - err = bgpio_init(bgc, &ofdev->dev, 4, regs + GRGPIO_DATA,
1921 + err = bgpio_init(gc, &ofdev->dev, 4, regs + GRGPIO_DATA,
1922 regs + GRGPIO_OUTPUT, NULL, regs + GRGPIO_DIR, NULL,
1923 BGPIOF_BIG_ENDIAN_BYTE_ORDER);
1925 @@ -369,10 +361,9 @@ static int grgpio_probe(struct platform_
1929 - priv->imask = bgc->read_reg(regs + GRGPIO_IMASK);
1930 + priv->imask = gc->read_reg(regs + GRGPIO_IMASK);
1931 priv->dev = &ofdev->dev;
1935 gc->owner = THIS_MODULE;
1936 gc->to_irq = grgpio_to_irq;
1937 @@ -435,7 +426,7 @@ static int grgpio_probe(struct platform_
1939 platform_set_drvdata(ofdev, priv);
1941 - err = gpiochip_add(gc);
1942 + err = gpiochip_add_data(gc, priv);
1944 dev_err(&ofdev->dev, "Could not add gpiochip\n");
1946 @@ -456,7 +447,7 @@ static int grgpio_remove(struct platform
1950 - spin_lock_irqsave(&priv->bgc.lock, flags);
1951 + spin_lock_irqsave(&priv->gc.bgpio_lock, flags);
1954 for (i = 0; i < GRGPIO_MAX_NGPIO; i++) {
1955 @@ -467,13 +458,13 @@ static int grgpio_remove(struct platform
1959 - gpiochip_remove(&priv->bgc.gc);
1960 + gpiochip_remove(&priv->gc);
1963 irq_domain_remove(priv->domain);
1966 - spin_unlock_irqrestore(&priv->bgc.lock, flags);
1967 + spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags);
1971 --- a/drivers/gpio/gpio-moxart.c
1972 +++ b/drivers/gpio/gpio-moxart.c
1974 #include <linux/init.h>
1975 #include <linux/irq.h>
1976 #include <linux/io.h>
1977 -#include <linux/gpio.h>
1978 #include <linux/platform_device.h>
1979 #include <linux/module.h>
1980 #include <linux/of_address.h>
1982 #include <linux/delay.h>
1983 #include <linux/timer.h>
1984 #include <linux/bitops.h>
1985 -#include <linux/basic_mmio_gpio.h>
1986 +#include <linux/gpio/driver.h>
1988 #define GPIO_DATA_OUT 0x00
1989 #define GPIO_DATA_IN 0x04
1990 @@ -33,12 +32,12 @@ static int moxart_gpio_probe(struct plat
1992 struct device *dev = &pdev->dev;
1993 struct resource *res;
1994 - struct bgpio_chip *bgc;
1995 + struct gpio_chip *gc;
1999 - bgc = devm_kzalloc(dev, sizeof(*bgc), GFP_KERNEL);
2001 + gc = devm_kzalloc(dev, sizeof(*gc), GFP_KERNEL);
2005 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2006 @@ -46,7 +45,7 @@ static int moxart_gpio_probe(struct plat
2008 return PTR_ERR(base);
2010 - ret = bgpio_init(bgc, dev, 4, base + GPIO_DATA_IN,
2011 + ret = bgpio_init(gc, dev, 4, base + GPIO_DATA_IN,
2012 base + GPIO_DATA_OUT, NULL,
2013 base + GPIO_PIN_DIRECTION, NULL,
2014 BGPIOF_READ_OUTPUT_REG_SET);
2015 @@ -55,16 +54,16 @@ static int moxart_gpio_probe(struct plat
2019 - bgc->gc.label = "moxart-gpio";
2020 - bgc->gc.request = gpiochip_generic_request;
2021 - bgc->gc.free = gpiochip_generic_free;
2022 - bgc->data = bgc->read_reg(bgc->reg_set);
2024 - bgc->gc.ngpio = 32;
2025 - bgc->gc.dev = dev;
2026 - bgc->gc.owner = THIS_MODULE;
2027 + gc->label = "moxart-gpio";
2028 + gc->request = gpiochip_generic_request;
2029 + gc->free = gpiochip_generic_free;
2030 + gc->bgpio_data = bgc->read_reg(bgc->reg_set);
2034 + gc->owner = THIS_MODULE;
2036 - ret = gpiochip_add(&bgc->gc);
2037 + ret = gpiochip_add_data(gc, NULL);
2039 dev_err(dev, "%s: gpiochip_add failed\n",
2040 dev->of_node->full_name);
2041 --- a/drivers/gpio/gpio-mxc.c
2042 +++ b/drivers/gpio/gpio-mxc.c
2044 #include <linux/irq.h>
2045 #include <linux/irqdomain.h>
2046 #include <linux/irqchip/chained_irq.h>
2047 -#include <linux/gpio.h>
2048 #include <linux/platform_device.h>
2049 #include <linux/slab.h>
2050 -#include <linux/basic_mmio_gpio.h>
2051 +#include <linux/gpio/driver.h>
2052 +/* FIXME: for gpio_get_value() replace this with direct register read */
2053 +#include <linux/gpio.h>
2054 #include <linux/of.h>
2055 #include <linux/of_device.h>
2056 #include <linux/module.h>
2057 @@ -64,7 +65,7 @@ struct mxc_gpio_port {
2060 struct irq_domain *domain;
2061 - struct bgpio_chip bgc;
2062 + struct gpio_chip gc;
2066 @@ -172,7 +173,7 @@ static int gpio_set_irq_type(struct irq_
2067 struct mxc_gpio_port *port = gc->private;
2069 u32 gpio_idx = d->hwirq;
2070 - u32 gpio = port->bgc.gc.base + gpio_idx;
2071 + u32 gpio = port->gc.base + gpio_idx;
2073 void __iomem *reg = port->base;
2075 @@ -398,9 +399,7 @@ static void mxc_gpio_get_hw(struct platf
2077 static int mxc_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
2079 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
2080 - struct mxc_gpio_port *port =
2081 - container_of(bgc, struct mxc_gpio_port, bgc);
2082 + struct mxc_gpio_port *port = gpiochip_get_data(gc);
2084 return irq_find_mapping(port->domain, offset);
2086 @@ -451,7 +450,7 @@ static int mxc_gpio_probe(struct platfor
2090 - err = bgpio_init(&port->bgc, &pdev->dev, 4,
2091 + err = bgpio_init(&port->gc, &pdev->dev, 4,
2092 port->base + GPIO_PSR,
2093 port->base + GPIO_DR, NULL,
2094 port->base + GPIO_GDIR, NULL,
2095 @@ -459,13 +458,13 @@ static int mxc_gpio_probe(struct platfor
2099 - port->bgc.gc.to_irq = mxc_gpio_to_irq;
2100 - port->bgc.gc.base = (pdev->id < 0) ? of_alias_get_id(np, "gpio") * 32 :
2101 + port->gc.to_irq = mxc_gpio_to_irq;
2102 + port->gc.base = (pdev->id < 0) ? of_alias_get_id(np, "gpio") * 32 :
2105 - err = gpiochip_add(&port->bgc.gc);
2106 + err = gpiochip_add_data(&port->gc, port);
2108 - goto out_bgpio_remove;
2111 irq_base = irq_alloc_descs(-1, 0, 32, numa_node_id());
2113 @@ -494,9 +493,7 @@ out_irqdomain_remove:
2115 irq_free_descs(irq_base, 32);
2116 out_gpiochip_remove:
2117 - gpiochip_remove(&port->bgc.gc);
2119 - bgpio_remove(&port->bgc);
2120 + gpiochip_remove(&port->gc);
2122 dev_info(&pdev->dev, "%s failed with errno %d\n", __func__, err);
2124 --- a/drivers/gpio/gpio-mxs.c
2125 +++ b/drivers/gpio/gpio-mxs.c
2127 #include <linux/io.h>
2128 #include <linux/irq.h>
2129 #include <linux/irqdomain.h>
2130 -#include <linux/gpio.h>
2131 #include <linux/of.h>
2132 #include <linux/of_address.h>
2133 #include <linux/of_device.h>
2134 #include <linux/platform_device.h>
2135 #include <linux/slab.h>
2136 -#include <linux/basic_mmio_gpio.h>
2137 +#include <linux/gpio/driver.h>
2138 +/* FIXME: for gpio_get_value(), replace this by direct register read */
2139 +#include <linux/gpio.h>
2140 #include <linux/module.h>
2143 @@ -64,7 +65,7 @@ struct mxs_gpio_port {
2146 struct irq_domain *domain;
2147 - struct bgpio_chip bgc;
2148 + struct gpio_chip gc;
2149 enum mxs_gpio_id devid;
2152 @@ -93,7 +94,7 @@ static int mxs_gpio_set_irq_type(struct
2153 port->both_edges &= ~pin_mask;
2155 case IRQ_TYPE_EDGE_BOTH:
2156 - val = gpio_get_value(port->bgc.gc.base + d->hwirq);
2157 + val = gpio_get_value(port->gc.base + d->hwirq);
2159 edge = GPIO_INT_FALL_EDGE;
2161 @@ -225,18 +226,14 @@ static int __init mxs_gpio_init_gc(struc
2163 static int mxs_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
2165 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
2166 - struct mxs_gpio_port *port =
2167 - container_of(bgc, struct mxs_gpio_port, bgc);
2168 + struct mxs_gpio_port *port = gpiochip_get_data(gc);
2170 return irq_find_mapping(port->domain, offset);
2173 static int mxs_gpio_get_direction(struct gpio_chip *gc, unsigned offset)
2175 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
2176 - struct mxs_gpio_port *port =
2177 - container_of(bgc, struct mxs_gpio_port, bgc);
2178 + struct mxs_gpio_port *port = gpiochip_get_data(gc);
2179 u32 mask = 1 << offset;
2182 @@ -330,26 +327,24 @@ static int mxs_gpio_probe(struct platfor
2183 irq_set_chained_handler_and_data(port->irq, mxs_gpio_irq_handler,
2186 - err = bgpio_init(&port->bgc, &pdev->dev, 4,
2187 + err = bgpio_init(&port->gc, &pdev->dev, 4,
2188 port->base + PINCTRL_DIN(port),
2189 port->base + PINCTRL_DOUT(port) + MXS_SET,
2190 port->base + PINCTRL_DOUT(port) + MXS_CLR,
2191 port->base + PINCTRL_DOE(port), NULL, 0);
2193 - goto out_irqdesc_free;
2194 + goto out_irqdomain_remove;
2196 - port->bgc.gc.to_irq = mxs_gpio_to_irq;
2197 - port->bgc.gc.get_direction = mxs_gpio_get_direction;
2198 - port->bgc.gc.base = port->id * 32;
2199 + port->gc.to_irq = mxs_gpio_to_irq;
2200 + port->gc.get_direction = mxs_gpio_get_direction;
2201 + port->gc.base = port->id * 32;
2203 - err = gpiochip_add(&port->bgc.gc);
2204 + err = gpiochip_add_data(&port->gc, port);
2206 - goto out_bgpio_remove;
2207 + goto out_irqdomain_remove;
2212 - bgpio_remove(&port->bgc);
2213 out_irqdomain_remove:
2214 irq_domain_remove(port->domain);
2216 --- a/drivers/gpio/gpio-sodaville.c
2217 +++ b/drivers/gpio/gpio-sodaville.c
2221 #include <linux/errno.h>
2222 -#include <linux/gpio.h>
2223 #include <linux/init.h>
2224 #include <linux/io.h>
2225 #include <linux/irq.h>
2227 #include <linux/pci.h>
2228 #include <linux/platform_device.h>
2229 #include <linux/of_irq.h>
2230 -#include <linux/basic_mmio_gpio.h>
2231 +#include <linux/gpio/driver.h>
2233 #define DRV_NAME "sdv_gpio"
2234 #define SDV_NUM_PUB_GPIOS 12
2235 @@ -43,7 +42,7 @@ struct sdv_gpio_chip_data {
2236 void __iomem *gpio_pub_base;
2237 struct irq_domain *id;
2238 struct irq_chip_generic *gc;
2239 - struct bgpio_chip bgpio;
2240 + struct gpio_chip chip;
2243 static int sdv_gpio_pub_set_type(struct irq_data *d, unsigned int type)
2244 @@ -226,14 +225,14 @@ static int sdv_gpio_probe(struct pci_dev
2245 writel(mux_val, sd->gpio_pub_base + GPMUXCTL);
2248 - ret = bgpio_init(&sd->bgpio, &pdev->dev, 4,
2249 + ret = bgpio_init(&sd->chip, &pdev->dev, 4,
2250 sd->gpio_pub_base + GPINR, sd->gpio_pub_base + GPOUTR,
2251 NULL, sd->gpio_pub_base + GPOER, NULL, 0);
2254 - sd->bgpio.gc.ngpio = SDV_NUM_PUB_GPIOS;
2255 + sd->chip.ngpio = SDV_NUM_PUB_GPIOS;
2257 - ret = gpiochip_add(&sd->bgpio.gc);
2258 + ret = gpiochip_add_data(&sd->chip, sd);
2260 dev_err(&pdev->dev, "gpiochip_add() failed.\n");
2262 @@ -265,7 +264,7 @@ static void sdv_gpio_remove(struct pci_d
2263 free_irq(pdev->irq, sd);
2264 irq_free_descs(sd->irq_base, SDV_NUM_PUB_GPIOS);
2266 - gpiochip_remove(&sd->bgpio.gc);
2267 + gpiochip_remove(&sd->chip);
2268 pci_release_region(pdev, GPIO_BAR);
2269 iounmap(sd->gpio_pub_base);
2270 pci_disable_device(pdev);
2271 --- a/drivers/gpio/gpio-xgene-sb.c
2272 +++ b/drivers/gpio/gpio-xgene-sb.c
2274 #include <linux/io.h>
2275 #include <linux/platform_device.h>
2276 #include <linux/of_gpio.h>
2277 -#include <linux/gpio.h>
2278 #include <linux/gpio/driver.h>
2279 #include <linux/acpi.h>
2280 -#include <linux/basic_mmio_gpio.h>
2282 #include "gpiolib.h"
2287 * struct xgene_gpio_sb - GPIO-Standby private data structure.
2288 - * @bgc: memory-mapped GPIO controllers.
2289 + * @gc: memory-mapped GPIO controllers.
2290 * @irq: Mapping GPIO pins and interrupt number
2291 * nirq: Number of GPIO pins that supports interrupt
2293 struct xgene_gpio_sb {
2294 - struct bgpio_chip bgc;
2295 + struct gpio_chip gc;
2300 -static inline struct xgene_gpio_sb *to_xgene_gpio_sb(struct gpio_chip *gc)
2302 - struct bgpio_chip *bgc = to_bgpio_chip(gc);
2304 - return container_of(bgc, struct xgene_gpio_sb, bgc);
2307 -static void xgene_gpio_set_bit(struct bgpio_chip *bgc, void __iomem *reg, u32 gpio, int val)
2308 +static void xgene_gpio_set_bit(struct gpio_chip *gc, void __iomem *reg, u32 gpio, int val)
2312 - data = bgc->read_reg(reg);
2313 + data = gc->read_reg(reg);
2315 data |= GPIO_MASK(gpio);
2317 data &= ~GPIO_MASK(gpio);
2318 - bgc->write_reg(reg, data);
2319 + gc->write_reg(reg, data);
2322 static int apm_gpio_sb_to_irq(struct gpio_chip *gc, u32 gpio)
2324 - struct xgene_gpio_sb *priv = to_xgene_gpio_sb(gc);
2325 + struct xgene_gpio_sb *priv = gpiochip_get_data(gc);
2327 if (priv->irq[gpio])
2328 return priv->irq[gpio];
2329 @@ -99,15 +90,15 @@ static int xgene_gpio_sb_probe(struct pl
2331 return PTR_ERR(regs);
2333 - ret = bgpio_init(&priv->bgc, &pdev->dev, 4,
2334 + ret = bgpio_init(&priv->gc, &pdev->dev, 4,
2335 regs + MPA_GPIO_IN_ADDR,
2336 regs + MPA_GPIO_OUT_ADDR, NULL,
2337 regs + MPA_GPIO_OE_ADDR, NULL, 0);
2341 - priv->bgc.gc.to_irq = apm_gpio_sb_to_irq;
2342 - priv->bgc.gc.ngpio = XGENE_MAX_GPIO_DS;
2343 + priv->gc.to_irq = apm_gpio_sb_to_irq;
2344 + priv->gc.ngpio = XGENE_MAX_GPIO_DS;
2346 priv->nirq = XGENE_MAX_GPIO_DS_IRQ;
2348 @@ -118,14 +109,14 @@ static int xgene_gpio_sb_probe(struct pl
2350 for (i = 0; i < priv->nirq; i++) {
2351 priv->irq[default_lines[i]] = platform_get_irq(pdev, i);
2352 - xgene_gpio_set_bit(&priv->bgc, regs + MPA_GPIO_SEL_LO,
2353 + xgene_gpio_set_bit(&priv->gc, regs + MPA_GPIO_SEL_LO,
2354 default_lines[i] * 2, 1);
2355 - xgene_gpio_set_bit(&priv->bgc, regs + MPA_GPIO_INT_LVL, i, 1);
2356 + xgene_gpio_set_bit(&priv->gc, regs + MPA_GPIO_INT_LVL, i, 1);
2359 platform_set_drvdata(pdev, priv);
2361 - ret = gpiochip_add(&priv->bgc.gc);
2362 + ret = gpiochip_add_data(&priv->gc, priv);
2364 dev_err(&pdev->dev, "failed to register X-Gene GPIO Standby driver\n");
2366 @@ -133,7 +124,7 @@ static int xgene_gpio_sb_probe(struct pl
2368 if (priv->nirq > 0) {
2369 /* Register interrupt handlers for gpio signaled acpi events */
2370 - acpi_gpiochip_request_interrupts(&priv->bgc.gc);
2371 + acpi_gpiochip_request_interrupts(&priv->gc);
2375 @@ -144,10 +135,11 @@ static int xgene_gpio_sb_remove(struct p
2376 struct xgene_gpio_sb *priv = platform_get_drvdata(pdev);
2378 if (priv->nirq > 0) {
2379 - acpi_gpiochip_free_interrupts(&priv->bgc.gc);
2380 + acpi_gpiochip_free_interrupts(&priv->gc);
2383 - return bgpio_remove(&priv->bgc);
2384 + gpiochip_remove(&priv->gc);
2388 static const struct of_device_id xgene_gpio_sb_of_match[] = {
2389 --- a/drivers/mfd/vexpress-sysreg.c
2390 +++ b/drivers/mfd/vexpress-sysreg.c
2392 * Copyright (C) 2012 ARM Limited
2395 -#include <linux/basic_mmio_gpio.h>
2396 +#include <linux/gpio/driver.h>
2397 #include <linux/err.h>
2398 #include <linux/io.h>
2399 #include <linux/mfd/core.h>
2400 @@ -164,7 +164,7 @@ static int vexpress_sysreg_probe(struct
2402 struct resource *mem;
2404 - struct bgpio_chip *mmc_gpio_chip;
2405 + struct gpio_chip *mmc_gpio_chip;
2409 @@ -201,8 +201,8 @@ static int vexpress_sysreg_probe(struct
2411 bgpio_init(mmc_gpio_chip, &pdev->dev, 0x4, base + SYS_MCI,
2412 NULL, NULL, NULL, NULL, 0);
2413 - mmc_gpio_chip->gc.ngpio = 2;
2414 - gpiochip_add(&mmc_gpio_chip->gc);
2415 + mmc_gpio_chip->ngpio = 2;
2416 + gpiochip_add(mmc_gpio_chip);
2418 return mfd_add_devices(&pdev->dev, PLATFORM_DEVID_AUTO,
2419 vexpress_sysreg_cells,
2420 --- a/include/linux/basic_mmio_gpio.h
2424 - * Basic memory-mapped GPIO controllers.
2426 - * Copyright 2008 MontaVista Software, Inc.
2427 - * Copyright 2008,2010 Anton Vorontsov <cbouatmailru@gmail.com>
2429 - * This program is free software; you can redistribute it and/or modify it
2430 - * under the terms of the GNU General Public License as published by the
2431 - * Free Software Foundation; either version 2 of the License, or (at your
2432 - * option) any later version.
2435 -#ifndef __BASIC_MMIO_GPIO_H
2436 -#define __BASIC_MMIO_GPIO_H
2438 -#include <linux/gpio.h>
2439 -#include <linux/types.h>
2440 -#include <linux/compiler.h>
2441 -#include <linux/spinlock_types.h>
2443 -struct bgpio_pdata {
2444 - const char *label;
2451 -struct bgpio_chip {
2452 - struct gpio_chip gc;
2454 - unsigned long (*read_reg)(void __iomem *reg);
2455 - void (*write_reg)(void __iomem *reg, unsigned long data);
2457 - void __iomem *reg_dat;
2458 - void __iomem *reg_set;
2459 - void __iomem *reg_clr;
2460 - void __iomem *reg_dir;
2462 - /* Number of bits (GPIOs): <register width> * 8. */
2466 - * Some GPIO controllers work with the big-endian bits notation,
2467 - * e.g. in a 8-bits register, GPIO7 is the least significant bit.
2469 - unsigned long (*pin2mask)(struct bgpio_chip *bgc, unsigned int pin);
2472 - * Used to lock bgpio_chip->data. Also, this is needed to keep
2473 - * shadowed and real data registers writes together.
2477 - /* Shadowed data register to clear/set bits safely. */
2478 - unsigned long data;
2480 - /* Shadowed direction registers to clear/set direction safely. */
2481 - unsigned long dir;
2484 -static inline struct bgpio_chip *to_bgpio_chip(struct gpio_chip *gc)
2486 - return container_of(gc, struct bgpio_chip, gc);
2489 -int bgpio_remove(struct bgpio_chip *bgc);
2490 -int bgpio_init(struct bgpio_chip *bgc, struct device *dev,
2491 - unsigned long sz, void __iomem *dat, void __iomem *set,
2492 - void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
2493 - unsigned long flags);
2495 -#define BGPIOF_BIG_ENDIAN BIT(0)
2496 -#define BGPIOF_UNREADABLE_REG_SET BIT(1) /* reg_set is unreadable */
2497 -#define BGPIOF_UNREADABLE_REG_DIR BIT(2) /* reg_dir is unreadable */
2498 -#define BGPIOF_BIG_ENDIAN_BYTE_ORDER BIT(3)
2499 -#define BGPIOF_READ_OUTPUT_REG_SET BIT(4) /* reg_set stores output value */
2500 -#define BGPIOF_NO_OUTPUT BIT(5) /* only input */
2502 -#endif /* __BASIC_MMIO_GPIO_H */
2503 --- a/include/linux/gpio/driver.h
2504 +++ b/include/linux/gpio/driver.h
2506 #include <linux/irqdomain.h>
2507 #include <linux/lockdep.h>
2508 #include <linux/pinctrl/pinctrl.h>
2509 +#include <linux/kconfig.h>
2513 @@ -66,6 +67,23 @@ struct seq_file;
2515 * @irq_not_threaded: flag must be set if @can_sleep is set but the
2516 * IRQs don't need to be threaded
2517 + * @read_reg: reader function for generic GPIO
2518 + * @write_reg: writer function for generic GPIO
2519 + * @pin2mask: some generic GPIO controllers work with the big-endian bits
2520 + * notation, e.g. in a 8-bits register, GPIO7 is the least significant
2521 + * bit. This callback assigns the right bit mask.
2522 + * @reg_dat: data (in) register for generic GPIO
2523 + * @reg_set: output set register (out=high) for generic GPIO
2524 + * @reg_clk: output clear register (out=low) for generic GPIO
2525 + * @reg_dir: direction setting register for generic GPIO
2526 + * @bgpio_bits: number of register bits used for a generic GPIO i.e.
2527 + * <register width> * 8
2528 + * @bgpio_lock: used to lock chip->bgpio_data. Also, this is needed to keep
2529 + * shadowed and real data registers writes together.
2530 + * @bgpio_data: shadowed data register for generic GPIO to clear/set bits
2532 + * @bgpio_dir: shadowed direction register for generic GPIO to clear/set
2533 + * direction safely.
2534 * @irqchip: GPIO IRQ chip impl, provided by GPIO driver
2535 * @irqdomain: Interrupt translation domain; responsible for mapping
2536 * between GPIO hwirq number and linux irq number
2537 @@ -129,6 +147,20 @@ struct gpio_chip {
2539 bool irq_not_threaded;
2541 +#if IS_ENABLED(CONFIG_GPIO_GENERIC)
2542 + unsigned long (*read_reg)(void __iomem *reg);
2543 + void (*write_reg)(void __iomem *reg, unsigned long data);
2544 + unsigned long (*pin2mask)(struct gpio_chip *gc, unsigned int pin);
2545 + void __iomem *reg_dat;
2546 + void __iomem *reg_set;
2547 + void __iomem *reg_clr;
2548 + void __iomem *reg_dir;
2550 + spinlock_t bgpio_lock;
2551 + unsigned long bgpio_data;
2552 + unsigned long bgpio_dir;
2555 #ifdef CONFIG_GPIOLIB_IRQCHIP
2557 * With CONFIG_GPIOLIB_IRQCHIP we get an irqchip inside the gpiolib
2558 @@ -189,6 +221,28 @@ static inline void *gpiochip_get_data(st
2560 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc);
2562 +#if IS_ENABLED(CONFIG_GPIO_GENERIC)
2564 +struct bgpio_pdata {
2565 + const char *label;
2570 +int bgpio_init(struct gpio_chip *gc, struct device *dev,
2571 + unsigned long sz, void __iomem *dat, void __iomem *set,
2572 + void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
2573 + unsigned long flags);
2575 +#define BGPIOF_BIG_ENDIAN BIT(0)
2576 +#define BGPIOF_UNREADABLE_REG_SET BIT(1) /* reg_set is unreadable */
2577 +#define BGPIOF_UNREADABLE_REG_DIR BIT(2) /* reg_dir is unreadable */
2578 +#define BGPIOF_BIG_ENDIAN_BYTE_ORDER BIT(3)
2579 +#define BGPIOF_READ_OUTPUT_REG_SET BIT(4) /* reg_set stores output value */
2580 +#define BGPIOF_NO_OUTPUT BIT(5) /* only input */
2584 #ifdef CONFIG_GPIOLIB_IRQCHIP
2586 void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,