Linus Walleij | dae5f0a | 2018-09-25 09:08:48 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 2 | /* |
Grant Likely | c103de2 | 2011-06-04 18:38:28 -0600 | [diff] [blame] | 3 | * Generic driver for memory-mapped GPIO controllers. |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 4 | * |
| 5 | * Copyright 2008 MontaVista Software, Inc. |
| 6 | * Copyright 2008,2010 Anton Vorontsov <cbouatmailru@gmail.com> |
| 7 | * |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 8 | * ....``.```~~~~````.`.`.`.`.```````'',,,.........`````......`....... |
| 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 . |
| 17 | o ` ~~~~\___/~~~~ ` 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 Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 44 | #include <linux/err.h> |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 45 | #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 Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 55 | #include <linux/gpio/driver.h> |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 56 | #include <linux/slab.h> |
Linus Walleij | 4b63739 | 2016-01-05 11:13:28 +0100 | [diff] [blame] | 57 | #include <linux/bitops.h> |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 58 | #include <linux/platform_device.h> |
| 59 | #include <linux/mod_devicetable.h> |
Álvaro Fernández Rojas | e698613 | 2016-05-13 23:07:11 +0200 | [diff] [blame] | 60 | #include <linux/of.h> |
| 61 | #include <linux/of_device.h> |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 62 | |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 63 | static void bgpio_write8(void __iomem *reg, unsigned long data) |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 64 | { |
Jamie Iles | fd99623 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 65 | writeb(data, reg); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 66 | } |
| 67 | |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 68 | static unsigned long bgpio_read8(void __iomem *reg) |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 69 | { |
Jamie Iles | fd99623 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 70 | return readb(reg); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 71 | } |
| 72 | |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 73 | static void bgpio_write16(void __iomem *reg, unsigned long data) |
| 74 | { |
Jamie Iles | fd99623 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 75 | writew(data, reg); |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 76 | } |
| 77 | |
| 78 | static unsigned long bgpio_read16(void __iomem *reg) |
| 79 | { |
Jamie Iles | fd99623 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 80 | return readw(reg); |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 81 | } |
| 82 | |
| 83 | static void bgpio_write32(void __iomem *reg, unsigned long data) |
| 84 | { |
Jamie Iles | fd99623 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 85 | writel(data, reg); |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | static unsigned long bgpio_read32(void __iomem *reg) |
| 89 | { |
Jamie Iles | fd99623 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 90 | return readl(reg); |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 91 | } |
| 92 | |
| 93 | #if BITS_PER_LONG >= 64 |
| 94 | static void bgpio_write64(void __iomem *reg, unsigned long data) |
| 95 | { |
Jamie Iles | fd99623 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 96 | writeq(data, reg); |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | static unsigned long bgpio_read64(void __iomem *reg) |
| 100 | { |
Jamie Iles | fd99623 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 101 | return readq(reg); |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 102 | } |
| 103 | #endif /* BITS_PER_LONG >= 64 */ |
| 104 | |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 105 | static void bgpio_write16be(void __iomem *reg, unsigned long data) |
| 106 | { |
| 107 | iowrite16be(data, reg); |
| 108 | } |
| 109 | |
| 110 | static unsigned long bgpio_read16be(void __iomem *reg) |
| 111 | { |
| 112 | return ioread16be(reg); |
| 113 | } |
| 114 | |
| 115 | static void bgpio_write32be(void __iomem *reg, unsigned long data) |
| 116 | { |
| 117 | iowrite32be(data, reg); |
| 118 | } |
| 119 | |
| 120 | static unsigned long bgpio_read32be(void __iomem *reg) |
| 121 | { |
| 122 | return ioread32be(reg); |
| 123 | } |
| 124 | |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 125 | static unsigned long bgpio_line2mask(struct gpio_chip *gc, unsigned int line) |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 126 | { |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 127 | if (gc->be_bits) |
| 128 | return BIT(gc->bgpio_bits - 1 - line); |
| 129 | return BIT(line); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 130 | } |
| 131 | |
Vladimir Zapolskiy | b19e7f5 | 2015-04-29 18:34:59 +0300 | [diff] [blame] | 132 | static int bgpio_get_set(struct gpio_chip *gc, unsigned int gpio) |
| 133 | { |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 134 | unsigned long pinmask = bgpio_line2mask(gc, gpio); |
Linus Walleij | d799a4d | 2018-08-03 00:52:18 +0200 | [diff] [blame] | 135 | bool dir = !!(gc->bgpio_dir & pinmask); |
Vladimir Zapolskiy | b19e7f5 | 2015-04-29 18:34:59 +0300 | [diff] [blame] | 136 | |
Linus Walleij | d799a4d | 2018-08-03 00:52:18 +0200 | [diff] [blame] | 137 | /* |
| 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 Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 149 | return !!(gc->read_reg(gc->reg_set) & pinmask); |
Vladimir Zapolskiy | b19e7f5 | 2015-04-29 18:34:59 +0300 | [diff] [blame] | 150 | else |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 151 | return !!(gc->read_reg(gc->reg_dat) & pinmask); |
Vladimir Zapolskiy | b19e7f5 | 2015-04-29 18:34:59 +0300 | [diff] [blame] | 152 | } |
| 153 | |
Linus Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 154 | /* |
| 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 | */ |
| 158 | static 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 Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 163 | |
Linus Walleij | 07c7b6a | 2018-01-16 09:51:51 +0100 | [diff] [blame] | 164 | /* 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 Walleij | d799a4d | 2018-08-03 00:52:18 +0200 | [diff] [blame] | 168 | 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 Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 175 | |
| 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 Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 184 | static int bgpio_get(struct gpio_chip *gc, unsigned int gpio) |
| 185 | { |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 186 | return !!(gc->read_reg(gc->reg_dat) & bgpio_line2mask(gc, gpio)); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 187 | } |
| 188 | |
Linus Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 189 | /* |
| 190 | * This only works if the bits in the GPIO register are in native endianness. |
Linus Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 191 | */ |
| 192 | static int bgpio_get_multiple(struct gpio_chip *gc, unsigned long *mask, |
| 193 | unsigned long *bits) |
| 194 | { |
Linus Walleij | 07c7b6a | 2018-01-16 09:51:51 +0100 | [diff] [blame] | 195 | /* 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 Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 198 | return 0; |
| 199 | } |
| 200 | |
| 201 | /* |
| 202 | * With big endian mirrored bit order it becomes more tedious. |
| 203 | */ |
| 204 | static 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 Walleij | 07c7b6a | 2018-01-16 09:51:51 +0100 | [diff] [blame] | 211 | /* Make sure we first clear any bits that are zero when we read the register */ |
| 212 | *bits &= ~*mask; |
| 213 | |
Linus Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 214 | /* Create a mirrored mask */ |
Linus Walleij | 07c7b6a | 2018-01-16 09:51:51 +0100 | [diff] [blame] | 215 | bit = -1; |
| 216 | while ((bit = find_next_bit(mask, gc->ngpio, bit + 1)) < gc->ngpio) |
Linus Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 217 | 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 Walleij | 07c7b6a | 2018-01-16 09:51:51 +0100 | [diff] [blame] | 226 | bit = -1; |
| 227 | while ((bit = find_next_bit(&val, gc->ngpio, bit + 1)) < gc->ngpio) |
Linus Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 228 | *bits |= bgpio_line2mask(gc, bit); |
| 229 | |
| 230 | return 0; |
| 231 | } |
| 232 | |
Rabin Vincent | 91492a4 | 2015-07-22 15:05:18 +0200 | [diff] [blame] | 233 | static void bgpio_set_none(struct gpio_chip *gc, unsigned int gpio, int val) |
| 234 | { |
| 235 | } |
| 236 | |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 237 | static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val) |
| 238 | { |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 239 | unsigned long mask = bgpio_line2mask(gc, gpio); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 240 | unsigned long flags; |
| 241 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 242 | spin_lock_irqsave(&gc->bgpio_lock, flags); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 243 | |
| 244 | if (val) |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 245 | gc->bgpio_data |= mask; |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 246 | else |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 247 | gc->bgpio_data &= ~mask; |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 248 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 249 | gc->write_reg(gc->reg_dat, gc->bgpio_data); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 250 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 251 | spin_unlock_irqrestore(&gc->bgpio_lock, flags); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 252 | } |
| 253 | |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 254 | static void bgpio_set_with_clear(struct gpio_chip *gc, unsigned int gpio, |
| 255 | int val) |
| 256 | { |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 257 | unsigned long mask = bgpio_line2mask(gc, gpio); |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 258 | |
| 259 | if (val) |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 260 | gc->write_reg(gc->reg_set, mask); |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 261 | else |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 262 | gc->write_reg(gc->reg_clr, mask); |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 263 | } |
| 264 | |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 265 | static void bgpio_set_set(struct gpio_chip *gc, unsigned int gpio, int val) |
| 266 | { |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 267 | unsigned long mask = bgpio_line2mask(gc, gpio); |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 268 | unsigned long flags; |
| 269 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 270 | spin_lock_irqsave(&gc->bgpio_lock, flags); |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 271 | |
| 272 | if (val) |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 273 | gc->bgpio_data |= mask; |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 274 | else |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 275 | gc->bgpio_data &= ~mask; |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 276 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 277 | gc->write_reg(gc->reg_set, gc->bgpio_data); |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 278 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 279 | spin_unlock_irqrestore(&gc->bgpio_lock, flags); |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 280 | } |
| 281 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 282 | static void bgpio_multiple_get_masks(struct gpio_chip *gc, |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 283 | 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 Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 292 | for (i = 0; i < gc->bgpio_bits; i++) { |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 293 | if (*mask == 0) |
| 294 | break; |
| 295 | if (__test_and_clear_bit(i, mask)) { |
| 296 | if (test_bit(i, bits)) |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 297 | *set_mask |= bgpio_line2mask(gc, i); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 298 | else |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 299 | *clear_mask |= bgpio_line2mask(gc, i); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 300 | } |
| 301 | } |
| 302 | } |
| 303 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 304 | static void bgpio_set_multiple_single_reg(struct gpio_chip *gc, |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 305 | 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 Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 312 | spin_lock_irqsave(&gc->bgpio_lock, flags); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 313 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 314 | bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 315 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 316 | gc->bgpio_data |= set_mask; |
| 317 | gc->bgpio_data &= ~clear_mask; |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 318 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 319 | gc->write_reg(reg, gc->bgpio_data); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 320 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 321 | spin_unlock_irqrestore(&gc->bgpio_lock, flags); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 322 | } |
| 323 | |
| 324 | static void bgpio_set_multiple(struct gpio_chip *gc, unsigned long *mask, |
| 325 | unsigned long *bits) |
| 326 | { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 327 | bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_dat); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 328 | } |
| 329 | |
| 330 | static void bgpio_set_multiple_set(struct gpio_chip *gc, unsigned long *mask, |
| 331 | unsigned long *bits) |
| 332 | { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 333 | bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_set); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 334 | } |
| 335 | |
| 336 | static void bgpio_set_multiple_with_clear(struct gpio_chip *gc, |
| 337 | unsigned long *mask, |
| 338 | unsigned long *bits) |
| 339 | { |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 340 | unsigned long set_mask, clear_mask; |
| 341 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 342 | bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 343 | |
| 344 | if (set_mask) |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 345 | gc->write_reg(gc->reg_set, set_mask); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 346 | if (clear_mask) |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 347 | gc->write_reg(gc->reg_clr, clear_mask); |
Rojhalat Ibrahim | 73c4ced | 2015-01-14 15:46:38 +0100 | [diff] [blame] | 348 | } |
| 349 | |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 350 | static int bgpio_simple_dir_in(struct gpio_chip *gc, unsigned int gpio) |
| 351 | { |
| 352 | return 0; |
| 353 | } |
| 354 | |
Rabin Vincent | 91492a4 | 2015-07-22 15:05:18 +0200 | [diff] [blame] | 355 | static int bgpio_dir_out_err(struct gpio_chip *gc, unsigned int gpio, |
| 356 | int val) |
| 357 | { |
| 358 | return -EINVAL; |
| 359 | } |
| 360 | |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 361 | static 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 Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 369 | static int bgpio_dir_in(struct gpio_chip *gc, unsigned int gpio) |
| 370 | { |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 371 | unsigned long flags; |
| 372 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 373 | spin_lock_irqsave(&gc->bgpio_lock, flags); |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 374 | |
Linus Walleij | d799a4d | 2018-08-03 00:52:18 +0200 | [diff] [blame] | 375 | if (gc->bgpio_dir_inverted) |
| 376 | gc->bgpio_dir |= bgpio_line2mask(gc, gpio); |
| 377 | else |
| 378 | gc->bgpio_dir &= ~bgpio_line2mask(gc, gpio); |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 379 | gc->write_reg(gc->reg_dir, gc->bgpio_dir); |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 380 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 381 | spin_unlock_irqrestore(&gc->bgpio_lock, flags); |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 382 | |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 383 | return 0; |
| 384 | } |
| 385 | |
Philipp Zabel | db3b0fc | 2015-06-12 18:20:35 +0200 | [diff] [blame] | 386 | static int bgpio_get_dir(struct gpio_chip *gc, unsigned int gpio) |
| 387 | { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 388 | /* Return 0 if output, 1 of input */ |
Linus Walleij | d799a4d | 2018-08-03 00:52:18 +0200 | [diff] [blame] | 389 | 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 Zabel | db3b0fc | 2015-06-12 18:20:35 +0200 | [diff] [blame] | 393 | } |
| 394 | |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 395 | static int bgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val) |
| 396 | { |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 397 | unsigned long flags; |
| 398 | |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 399 | gc->set(gc, gpio, val); |
| 400 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 401 | spin_lock_irqsave(&gc->bgpio_lock, flags); |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 402 | |
Linus Walleij | d799a4d | 2018-08-03 00:52:18 +0200 | [diff] [blame] | 403 | if (gc->bgpio_dir_inverted) |
| 404 | gc->bgpio_dir &= ~bgpio_line2mask(gc, gpio); |
| 405 | else |
| 406 | gc->bgpio_dir |= bgpio_line2mask(gc, gpio); |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 407 | gc->write_reg(gc->reg_dir, gc->bgpio_dir); |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 408 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 409 | spin_unlock_irqrestore(&gc->bgpio_lock, flags); |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 410 | |
| 411 | return 0; |
| 412 | } |
| 413 | |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 414 | static int bgpio_setup_accessors(struct device *dev, |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 415 | struct gpio_chip *gc, |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 416 | bool byte_be) |
Jamie Iles | 364b5e8 | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 417 | { |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 418 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 419 | switch (gc->bgpio_bits) { |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 420 | case 8: |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 421 | gc->read_reg = bgpio_read8; |
| 422 | gc->write_reg = bgpio_write8; |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 423 | break; |
| 424 | case 16: |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 425 | if (byte_be) { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 426 | gc->read_reg = bgpio_read16be; |
| 427 | gc->write_reg = bgpio_write16be; |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 428 | } else { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 429 | gc->read_reg = bgpio_read16; |
| 430 | gc->write_reg = bgpio_write16; |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 431 | } |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 432 | break; |
| 433 | case 32: |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 434 | if (byte_be) { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 435 | gc->read_reg = bgpio_read32be; |
| 436 | gc->write_reg = bgpio_write32be; |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 437 | } else { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 438 | gc->read_reg = bgpio_read32; |
| 439 | gc->write_reg = bgpio_write32; |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 440 | } |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 441 | break; |
| 442 | #if BITS_PER_LONG >= 64 |
| 443 | case 64: |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 444 | if (byte_be) { |
| 445 | dev_err(dev, |
| 446 | "64 bit big endian byte order unsupported\n"); |
| 447 | return -EINVAL; |
| 448 | } else { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 449 | gc->read_reg = bgpio_read64; |
| 450 | gc->write_reg = bgpio_write64; |
Andreas Larsson | 2b78f1e | 2013-03-15 14:45:38 +0100 | [diff] [blame] | 451 | } |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 452 | break; |
| 453 | #endif /* BITS_PER_LONG >= 64 */ |
| 454 | default: |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 455 | dev_err(dev, "unsupported data width %u bits\n", gc->bgpio_bits); |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 456 | return -EINVAL; |
| 457 | } |
| 458 | |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 459 | return 0; |
| 460 | } |
| 461 | |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 462 | /* |
| 463 | * Create the device and allocate the resources. For setting GPIO's there are |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 464 | * three supported configurations: |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 465 | * |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 466 | * - single input/output register resource (named "dat"). |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 467 | * - set/clear pair (named "set" and "clr"). |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 468 | * - single output register resource and single input resource ("set" and |
| 469 | * dat"). |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 470 | * |
| 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 Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 475 | * |
| 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 Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 483 | */ |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 484 | static int bgpio_setup_io(struct gpio_chip *gc, |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 485 | void __iomem *dat, |
| 486 | void __iomem *set, |
Vladimir Zapolskiy | b19e7f5 | 2015-04-29 18:34:59 +0300 | [diff] [blame] | 487 | void __iomem *clr, |
| 488 | unsigned long flags) |
Jamie Iles | 8467afe | 2011-05-20 00:40:14 -0600 | [diff] [blame] | 489 | { |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 490 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 491 | gc->reg_dat = dat; |
| 492 | if (!gc->reg_dat) |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 493 | return -EINVAL; |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 494 | |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 495 | if (set && clr) { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 496 | 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 Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 500 | } else if (set && !clr) { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 501 | gc->reg_set = set; |
| 502 | gc->set = bgpio_set_set; |
| 503 | gc->set_multiple = bgpio_set_multiple_set; |
Rabin Vincent | 91492a4 | 2015-07-22 15:05:18 +0200 | [diff] [blame] | 504 | } else if (flags & BGPIOF_NO_OUTPUT) { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 505 | gc->set = bgpio_set_none; |
| 506 | gc->set_multiple = NULL; |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 507 | } else { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 508 | gc->set = bgpio_set; |
| 509 | gc->set_multiple = bgpio_set_multiple; |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 510 | } |
| 511 | |
Vladimir Zapolskiy | b19e7f5 | 2015-04-29 18:34:59 +0300 | [diff] [blame] | 512 | if (!(flags & BGPIOF_UNREADABLE_REG_SET) && |
Linus Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 513 | (flags & BGPIOF_READ_OUTPUT_REG_SET)) { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 514 | gc->get = bgpio_get_set; |
Linus Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 515 | 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 Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 525 | gc->get = bgpio_get; |
Linus Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 526 | if (gc->be_bits) |
| 527 | gc->get_multiple = bgpio_get_multiple_be; |
| 528 | else |
| 529 | gc->get_multiple = bgpio_get_multiple; |
| 530 | } |
Jamie Iles | dd86a0c | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 531 | |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 532 | return 0; |
| 533 | } |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 534 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 535 | static int bgpio_setup_direction(struct gpio_chip *gc, |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 536 | void __iomem *dirout, |
Rabin Vincent | 91492a4 | 2015-07-22 15:05:18 +0200 | [diff] [blame] | 537 | void __iomem *dirin, |
| 538 | unsigned long flags) |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 539 | { |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 540 | if (dirout && dirin) { |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 541 | return -EINVAL; |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 542 | } else if (dirout) { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 543 | 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 Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 547 | } else if (dirin) { |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 548 | gc->reg_dir = dirin; |
Linus Walleij | d799a4d | 2018-08-03 00:52:18 +0200 | [diff] [blame] | 549 | 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 Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 553 | } else { |
Rabin Vincent | 91492a4 | 2015-07-22 15:05:18 +0200 | [diff] [blame] | 554 | if (flags & BGPIOF_NO_OUTPUT) |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 555 | gc->direction_output = bgpio_dir_out_err; |
Rabin Vincent | 91492a4 | 2015-07-22 15:05:18 +0200 | [diff] [blame] | 556 | else |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 557 | gc->direction_output = bgpio_simple_dir_out; |
| 558 | gc->direction_input = bgpio_simple_dir_in; |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 559 | } |
| 560 | |
| 561 | return 0; |
| 562 | } |
| 563 | |
Anthony Fee | 7b42e3d | 2014-05-19 18:49:14 +0100 | [diff] [blame] | 564 | static 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 Walleij | d799a4d | 2018-08-03 00:52:18 +0200 | [diff] [blame] | 572 | /** |
| 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 Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 599 | int bgpio_init(struct gpio_chip *gc, struct device *dev, |
Russell King | 4f5b048 | 2011-09-14 16:22:29 -0700 | [diff] [blame] | 600 | unsigned long sz, void __iomem *dat, void __iomem *set, |
| 601 | void __iomem *clr, void __iomem *dirout, void __iomem *dirin, |
Shawn Guo | 3e11f7b | 2012-05-19 21:34:58 +0800 | [diff] [blame] | 602 | unsigned long flags) |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 603 | { |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 604 | int ret; |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 605 | |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 606 | if (!is_power_of_2(sz)) |
| 607 | return -EINVAL; |
Jamie Iles | e027d6f | 2011-05-20 00:40:16 -0600 | [diff] [blame] | 608 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 609 | gc->bgpio_bits = sz * 8; |
| 610 | if (gc->bgpio_bits > BITS_PER_LONG) |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 611 | return -EINVAL; |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 612 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 613 | 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 Walleij | 80057cb4 | 2017-10-19 23:30:12 +0200 | [diff] [blame] | 619 | gc->be_bits = !!(flags & BGPIOF_BIG_ENDIAN); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 620 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 621 | ret = bgpio_setup_io(gc, dat, set, clr, flags); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 622 | if (ret) |
| 623 | return ret; |
| 624 | |
Linus Walleij | 24efd94 | 2017-10-20 16:31:27 +0200 | [diff] [blame] | 625 | ret = bgpio_setup_accessors(dev, gc, flags & BGPIOF_BIG_ENDIAN_BYTE_ORDER); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 626 | if (ret) |
| 627 | return ret; |
| 628 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 629 | ret = bgpio_setup_direction(gc, dirout, dirin, flags); |
Jamie Iles | 3102911 | 2011-05-20 00:40:17 -0600 | [diff] [blame] | 630 | if (ret) |
| 631 | return ret; |
| 632 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 633 | gc->bgpio_data = gc->read_reg(gc->reg_dat); |
| 634 | if (gc->set == bgpio_set_set && |
Shawn Guo | 3e11f7b | 2012-05-19 21:34:58 +0800 | [diff] [blame] | 635 | !(flags & BGPIOF_UNREADABLE_REG_SET)) |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 636 | 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 Iles | 924e7a9 | 2011-05-20 00:40:15 -0600 | [diff] [blame] | 639 | |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 640 | return ret; |
| 641 | } |
| 642 | EXPORT_SYMBOL_GPL(bgpio_init); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 643 | |
Christian Lamparter | 8f01c9d | 2016-04-29 02:53:14 +0200 | [diff] [blame] | 644 | #if IS_ENABLED(CONFIG_GPIO_GENERIC_PLATFORM) |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 645 | |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 646 | static void __iomem *bgpio_map(struct platform_device *pdev, |
| 647 | const char *name, |
Heiner Kallweit | 8d24026 | 2015-09-30 23:52:36 +0200 | [diff] [blame] | 648 | resource_size_t sane_sz) |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 649 | { |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 650 | struct resource *r; |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 651 | resource_size_t sz; |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 652 | |
| 653 | r = platform_get_resource_byname(pdev, IORESOURCE_MEM, name); |
Heiner Kallweit | 8d24026 | 2015-09-30 23:52:36 +0200 | [diff] [blame] | 654 | if (!r) |
Guenter Roeck | b2f68b6 | 2015-10-21 00:12:00 -0700 | [diff] [blame] | 655 | return NULL; |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 656 | |
| 657 | sz = resource_size(r); |
Heiner Kallweit | 8d24026 | 2015-09-30 23:52:36 +0200 | [diff] [blame] | 658 | if (sz != sane_sz) |
| 659 | return IOMEM_ERR_PTR(-EINVAL); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 660 | |
Heiner Kallweit | 8d24026 | 2015-09-30 23:52:36 +0200 | [diff] [blame] | 661 | return devm_ioremap_resource(&pdev->dev, r); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 662 | } |
| 663 | |
Álvaro Fernández Rojas | e698613 | 2016-05-13 23:07:11 +0200 | [diff] [blame] | 664 | #ifdef CONFIG_OF |
| 665 | static const struct of_device_id bgpio_of_match[] = { |
Christian Lamparter | 05cc995 | 2016-08-03 14:05:57 +0200 | [diff] [blame] | 666 | { .compatible = "brcm,bcm6345-gpio" }, |
Christian Lamparter | c0d30ec | 2016-05-13 23:07:12 +0200 | [diff] [blame] | 667 | { .compatible = "wd,mbl-gpio" }, |
Nathan Sullivan | b8c9019 | 2017-03-14 11:13:22 -0500 | [diff] [blame] | 668 | { .compatible = "ni,169445-nand-gpio" }, |
Álvaro Fernández Rojas | e698613 | 2016-05-13 23:07:11 +0200 | [diff] [blame] | 669 | { } |
| 670 | }; |
| 671 | MODULE_DEVICE_TABLE(of, bgpio_of_match); |
| 672 | |
| 673 | static 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 Lamparter | 05cc995 | 2016-08-03 14:05:57 +0200 | [diff] [blame] | 688 | if (of_device_is_big_endian(pdev->dev.of_node)) |
| 689 | *flags |= BGPIOF_BIG_ENDIAN_BYTE_ORDER; |
| 690 | |
Christian Lamparter | c0d30ec | 2016-05-13 23:07:12 +0200 | [diff] [blame] | 691 | if (of_property_read_bool(pdev->dev.of_node, "no-output")) |
| 692 | *flags |= BGPIOF_NO_OUTPUT; |
| 693 | |
Álvaro Fernández Rojas | e698613 | 2016-05-13 23:07:11 +0200 | [diff] [blame] | 694 | return pdata; |
| 695 | } |
| 696 | #else |
| 697 | static 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 Pemberton | 3836309 | 2012-11-19 13:22:34 -0500 | [diff] [blame] | 704 | static int bgpio_pdev_probe(struct platform_device *pdev) |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 705 | { |
| 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 Rojas | e698613 | 2016-05-13 23:07:11 +0200 | [diff] [blame] | 714 | unsigned long flags = 0; |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 715 | int err; |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 716 | struct gpio_chip *gc; |
Álvaro Fernández Rojas | e698613 | 2016-05-13 23:07:11 +0200 | [diff] [blame] | 717 | 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 Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 727 | |
| 728 | r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dat"); |
| 729 | if (!r) |
| 730 | return -EINVAL; |
| 731 | |
| 732 | sz = resource_size(r); |
| 733 | |
Heiner Kallweit | 8d24026 | 2015-09-30 23:52:36 +0200 | [diff] [blame] | 734 | dat = bgpio_map(pdev, "dat", sz); |
| 735 | if (IS_ERR(dat)) |
| 736 | return PTR_ERR(dat); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 737 | |
Heiner Kallweit | 8d24026 | 2015-09-30 23:52:36 +0200 | [diff] [blame] | 738 | set = bgpio_map(pdev, "set", sz); |
| 739 | if (IS_ERR(set)) |
| 740 | return PTR_ERR(set); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 741 | |
Heiner Kallweit | 8d24026 | 2015-09-30 23:52:36 +0200 | [diff] [blame] | 742 | clr = bgpio_map(pdev, "clr", sz); |
| 743 | if (IS_ERR(clr)) |
| 744 | return PTR_ERR(clr); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 745 | |
Heiner Kallweit | 8d24026 | 2015-09-30 23:52:36 +0200 | [diff] [blame] | 746 | dirout = bgpio_map(pdev, "dirout", sz); |
| 747 | if (IS_ERR(dirout)) |
| 748 | return PTR_ERR(dirout); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 749 | |
Heiner Kallweit | 8d24026 | 2015-09-30 23:52:36 +0200 | [diff] [blame] | 750 | dirin = bgpio_map(pdev, "dirin", sz); |
| 751 | if (IS_ERR(dirin)) |
| 752 | return PTR_ERR(dirin); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 753 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 754 | gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL); |
| 755 | if (!gc) |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 756 | return -ENOMEM; |
| 757 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 758 | err = bgpio_init(gc, dev, sz, dat, set, clr, dirout, dirin, flags); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 759 | if (err) |
| 760 | return err; |
| 761 | |
| 762 | if (pdata) { |
Pawel Moll | 781f6d7 | 2014-01-30 13:18:57 +0000 | [diff] [blame] | 763 | if (pdata->label) |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 764 | gc->label = pdata->label; |
| 765 | gc->base = pdata->base; |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 766 | if (pdata->ngpio > 0) |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 767 | gc->ngpio = pdata->ngpio; |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 768 | } |
| 769 | |
Linus Walleij | 0f4630f | 2015-12-04 14:02:58 +0100 | [diff] [blame] | 770 | platform_set_drvdata(pdev, gc); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 771 | |
Laxman Dewangan | c05f813 | 2016-02-22 17:43:28 +0530 | [diff] [blame] | 772 | return devm_gpiochip_add_data(&pdev->dev, gc, NULL); |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 773 | } |
| 774 | |
| 775 | static const struct platform_device_id bgpio_id_table[] = { |
Alexander Shiyan | 1933853 | 2014-03-16 09:10:34 +0400 | [diff] [blame] | 776 | { |
| 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 Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 784 | }; |
| 785 | MODULE_DEVICE_TABLE(platform, bgpio_id_table); |
| 786 | |
| 787 | static struct platform_driver bgpio_driver = { |
| 788 | .driver = { |
| 789 | .name = "basic-mmio-gpio", |
Álvaro Fernández Rojas | e698613 | 2016-05-13 23:07:11 +0200 | [diff] [blame] | 790 | .of_match_table = of_match_ptr(bgpio_of_match), |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 791 | }, |
| 792 | .id_table = bgpio_id_table, |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 793 | .probe = bgpio_pdev_probe, |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 794 | }; |
| 795 | |
Mark Brown | 6f61415 | 2011-12-08 00:24:00 +0800 | [diff] [blame] | 796 | module_platform_driver(bgpio_driver); |
Jamie Iles | 280df6b | 2011-05-20 00:40:19 -0600 | [diff] [blame] | 797 | |
Grant Likely | c103de2 | 2011-06-04 18:38:28 -0600 | [diff] [blame] | 798 | #endif /* CONFIG_GPIO_GENERIC_PLATFORM */ |
Anton Vorontsov | aeec56e | 2010-10-27 15:33:15 -0700 | [diff] [blame] | 799 | |
| 800 | MODULE_DESCRIPTION("Driver for basic memory-mapped GPIO controllers"); |
| 801 | MODULE_AUTHOR("Anton Vorontsov <cbouatmailru@gmail.com>"); |
| 802 | MODULE_LICENSE("GPL"); |