Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 1 | /* |
Grant Likely | c103de2 | 2011-06-04 18:38:28 -0600 | [diff] [blame] | 2 | * Timberdale FPGA GPIO driver |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 3 | * Copyright (c) 2009 Intel Corporation |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License version 2 as |
| 7 | * published by the Free Software Foundation. |
| 8 | * |
| 9 | * This program is distributed in the hope that it will be useful, |
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 | * GNU General Public License for more details. |
| 13 | * |
| 14 | * You should have received a copy of the GNU General Public License |
| 15 | * along with this program; if not, write to the Free Software |
| 16 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 17 | */ |
| 18 | |
| 19 | /* Supports: |
| 20 | * Timberdale FPGA GPIO |
| 21 | */ |
| 22 | |
| 23 | #include <linux/module.h> |
| 24 | #include <linux/gpio.h> |
| 25 | #include <linux/platform_device.h> |
David Miller | e3cb91c | 2010-03-05 13:41:36 -0800 | [diff] [blame] | 26 | #include <linux/irq.h> |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 27 | #include <linux/io.h> |
| 28 | #include <linux/timb_gpio.h> |
| 29 | #include <linux/interrupt.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 30 | #include <linux/slab.h> |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 31 | |
| 32 | #define DRIVER_NAME "timb-gpio" |
| 33 | |
| 34 | #define TGPIOVAL 0x00 |
| 35 | #define TGPIODIR 0x04 |
| 36 | #define TGPIO_IER 0x08 |
| 37 | #define TGPIO_ISR 0x0c |
| 38 | #define TGPIO_IPR 0x10 |
| 39 | #define TGPIO_ICR 0x14 |
| 40 | #define TGPIO_FLR 0x18 |
| 41 | #define TGPIO_LVR 0x1c |
Richard Röjfors | 8c35c89 | 2010-03-05 13:44:35 -0800 | [diff] [blame] | 42 | #define TGPIO_VER 0x20 |
| 43 | #define TGPIO_BFLR 0x24 |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 44 | |
| 45 | struct timbgpio { |
| 46 | void __iomem *membase; |
| 47 | spinlock_t lock; /* mutual exclusion */ |
| 48 | struct gpio_chip gpio; |
| 49 | int irq_base; |
Tomas Hallenberg | 76d800a | 2010-10-27 15:33:17 -0700 | [diff] [blame] | 50 | unsigned long last_ier; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 51 | }; |
| 52 | |
| 53 | static int timbgpio_update_bit(struct gpio_chip *gpio, unsigned index, |
| 54 | unsigned offset, bool enabled) |
| 55 | { |
| 56 | struct timbgpio *tgpio = container_of(gpio, struct timbgpio, gpio); |
| 57 | u32 reg; |
| 58 | |
| 59 | spin_lock(&tgpio->lock); |
| 60 | reg = ioread32(tgpio->membase + offset); |
| 61 | |
| 62 | if (enabled) |
| 63 | reg |= (1 << index); |
| 64 | else |
| 65 | reg &= ~(1 << index); |
| 66 | |
| 67 | iowrite32(reg, tgpio->membase + offset); |
| 68 | spin_unlock(&tgpio->lock); |
| 69 | |
| 70 | return 0; |
| 71 | } |
| 72 | |
| 73 | static int timbgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr) |
| 74 | { |
| 75 | return timbgpio_update_bit(gpio, nr, TGPIODIR, true); |
| 76 | } |
| 77 | |
| 78 | static int timbgpio_gpio_get(struct gpio_chip *gpio, unsigned nr) |
| 79 | { |
| 80 | struct timbgpio *tgpio = container_of(gpio, struct timbgpio, gpio); |
| 81 | u32 value; |
| 82 | |
| 83 | value = ioread32(tgpio->membase + TGPIOVAL); |
| 84 | return (value & (1 << nr)) ? 1 : 0; |
| 85 | } |
| 86 | |
| 87 | static int timbgpio_gpio_direction_output(struct gpio_chip *gpio, |
| 88 | unsigned nr, int val) |
| 89 | { |
| 90 | return timbgpio_update_bit(gpio, nr, TGPIODIR, false); |
| 91 | } |
| 92 | |
| 93 | static void timbgpio_gpio_set(struct gpio_chip *gpio, |
| 94 | unsigned nr, int val) |
| 95 | { |
| 96 | timbgpio_update_bit(gpio, nr, TGPIOVAL, val != 0); |
| 97 | } |
| 98 | |
| 99 | static int timbgpio_to_irq(struct gpio_chip *gpio, unsigned offset) |
| 100 | { |
| 101 | struct timbgpio *tgpio = container_of(gpio, struct timbgpio, gpio); |
| 102 | |
| 103 | if (tgpio->irq_base <= 0) |
| 104 | return -EINVAL; |
| 105 | |
| 106 | return tgpio->irq_base + offset; |
| 107 | } |
| 108 | |
| 109 | /* |
| 110 | * GPIO IRQ |
| 111 | */ |
Lennert Buytenhek | a1f5f22 | 2011-01-12 17:00:19 -0800 | [diff] [blame] | 112 | static void timbgpio_irq_disable(struct irq_data *d) |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 113 | { |
Lennert Buytenhek | a1f5f22 | 2011-01-12 17:00:19 -0800 | [diff] [blame] | 114 | struct timbgpio *tgpio = irq_data_get_irq_chip_data(d); |
| 115 | int offset = d->irq - tgpio->irq_base; |
Tomas Hallenberg | 76d800a | 2010-10-27 15:33:17 -0700 | [diff] [blame] | 116 | unsigned long flags; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 117 | |
Tomas Hallenberg | 76d800a | 2010-10-27 15:33:17 -0700 | [diff] [blame] | 118 | spin_lock_irqsave(&tgpio->lock, flags); |
Dan Carpenter | d79550a | 2012-10-11 09:56:35 +0300 | [diff] [blame] | 119 | tgpio->last_ier &= ~(1UL << offset); |
Tomas Hallenberg | 76d800a | 2010-10-27 15:33:17 -0700 | [diff] [blame] | 120 | iowrite32(tgpio->last_ier, tgpio->membase + TGPIO_IER); |
| 121 | spin_unlock_irqrestore(&tgpio->lock, flags); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 122 | } |
| 123 | |
Lennert Buytenhek | a1f5f22 | 2011-01-12 17:00:19 -0800 | [diff] [blame] | 124 | static void timbgpio_irq_enable(struct irq_data *d) |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 125 | { |
Lennert Buytenhek | a1f5f22 | 2011-01-12 17:00:19 -0800 | [diff] [blame] | 126 | struct timbgpio *tgpio = irq_data_get_irq_chip_data(d); |
| 127 | int offset = d->irq - tgpio->irq_base; |
Tomas Hallenberg | 76d800a | 2010-10-27 15:33:17 -0700 | [diff] [blame] | 128 | unsigned long flags; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 129 | |
Tomas Hallenberg | 76d800a | 2010-10-27 15:33:17 -0700 | [diff] [blame] | 130 | spin_lock_irqsave(&tgpio->lock, flags); |
Dan Carpenter | d79550a | 2012-10-11 09:56:35 +0300 | [diff] [blame] | 131 | tgpio->last_ier |= 1UL << offset; |
Tomas Hallenberg | 76d800a | 2010-10-27 15:33:17 -0700 | [diff] [blame] | 132 | iowrite32(tgpio->last_ier, tgpio->membase + TGPIO_IER); |
| 133 | spin_unlock_irqrestore(&tgpio->lock, flags); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 134 | } |
| 135 | |
Lennert Buytenhek | a1f5f22 | 2011-01-12 17:00:19 -0800 | [diff] [blame] | 136 | static int timbgpio_irq_type(struct irq_data *d, unsigned trigger) |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 137 | { |
Lennert Buytenhek | a1f5f22 | 2011-01-12 17:00:19 -0800 | [diff] [blame] | 138 | struct timbgpio *tgpio = irq_data_get_irq_chip_data(d); |
| 139 | int offset = d->irq - tgpio->irq_base; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 140 | unsigned long flags; |
Richard Röjfors | 8c35c89 | 2010-03-05 13:44:35 -0800 | [diff] [blame] | 141 | u32 lvr, flr, bflr = 0; |
| 142 | u32 ver; |
Julia Lawall | 2a48180 | 2010-04-06 14:34:48 -0700 | [diff] [blame] | 143 | int ret = 0; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 144 | |
| 145 | if (offset < 0 || offset > tgpio->gpio.ngpio) |
| 146 | return -EINVAL; |
| 147 | |
Richard Röjfors | 8c35c89 | 2010-03-05 13:44:35 -0800 | [diff] [blame] | 148 | ver = ioread32(tgpio->membase + TGPIO_VER); |
| 149 | |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 150 | spin_lock_irqsave(&tgpio->lock, flags); |
| 151 | |
| 152 | lvr = ioread32(tgpio->membase + TGPIO_LVR); |
| 153 | flr = ioread32(tgpio->membase + TGPIO_FLR); |
Richard Röjfors | 8c35c89 | 2010-03-05 13:44:35 -0800 | [diff] [blame] | 154 | if (ver > 2) |
| 155 | bflr = ioread32(tgpio->membase + TGPIO_BFLR); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 156 | |
| 157 | if (trigger & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW)) { |
Richard Röjfors | 8c35c89 | 2010-03-05 13:44:35 -0800 | [diff] [blame] | 158 | bflr &= ~(1 << offset); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 159 | flr &= ~(1 << offset); |
| 160 | if (trigger & IRQ_TYPE_LEVEL_HIGH) |
| 161 | lvr |= 1 << offset; |
| 162 | else |
| 163 | lvr &= ~(1 << offset); |
| 164 | } |
| 165 | |
Richard Röjfors | 8c35c89 | 2010-03-05 13:44:35 -0800 | [diff] [blame] | 166 | if ((trigger & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH) { |
Julia Lawall | 2a48180 | 2010-04-06 14:34:48 -0700 | [diff] [blame] | 167 | if (ver < 3) { |
| 168 | ret = -EINVAL; |
| 169 | goto out; |
Laurent Navet | 8a29a40 | 2013-03-20 13:16:03 +0100 | [diff] [blame] | 170 | } else { |
Richard Röjfors | 8c35c89 | 2010-03-05 13:44:35 -0800 | [diff] [blame] | 171 | flr |= 1 << offset; |
| 172 | bflr |= 1 << offset; |
| 173 | } |
| 174 | } else { |
| 175 | bflr &= ~(1 << offset); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 176 | flr |= 1 << offset; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 177 | if (trigger & IRQ_TYPE_EDGE_FALLING) |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 178 | lvr &= ~(1 << offset); |
Richard Röjfors | 8c35c89 | 2010-03-05 13:44:35 -0800 | [diff] [blame] | 179 | else |
| 180 | lvr |= 1 << offset; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 181 | } |
| 182 | |
| 183 | iowrite32(lvr, tgpio->membase + TGPIO_LVR); |
| 184 | iowrite32(flr, tgpio->membase + TGPIO_FLR); |
Richard Röjfors | 8c35c89 | 2010-03-05 13:44:35 -0800 | [diff] [blame] | 185 | if (ver > 2) |
| 186 | iowrite32(bflr, tgpio->membase + TGPIO_BFLR); |
| 187 | |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 188 | iowrite32(1 << offset, tgpio->membase + TGPIO_ICR); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 189 | |
Julia Lawall | 2a48180 | 2010-04-06 14:34:48 -0700 | [diff] [blame] | 190 | out: |
| 191 | spin_unlock_irqrestore(&tgpio->lock, flags); |
| 192 | return ret; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 193 | } |
| 194 | |
Lennert Buytenhek | 7f5db6a | 2011-01-14 09:44:19 +0100 | [diff] [blame] | 195 | static void timbgpio_irq(unsigned int irq, struct irq_desc *desc) |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 196 | { |
Jiang Liu | 476f8b4 | 2015-06-04 12:13:15 +0800 | [diff] [blame] | 197 | struct timbgpio *tgpio = irq_desc_get_handler_data(desc); |
| 198 | struct irq_data *data = irq_desc_get_irq_data(desc); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 199 | unsigned long ipr; |
| 200 | int offset; |
| 201 | |
Jiang Liu | 476f8b4 | 2015-06-04 12:13:15 +0800 | [diff] [blame] | 202 | data->chip->irq_ack(data); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 203 | ipr = ioread32(tgpio->membase + TGPIO_IPR); |
| 204 | iowrite32(ipr, tgpio->membase + TGPIO_ICR); |
| 205 | |
Tomas Hallenberg | 76d800a | 2010-10-27 15:33:17 -0700 | [diff] [blame] | 206 | /* |
| 207 | * Some versions of the hardware trash the IER register if more than |
| 208 | * one interrupt is received simultaneously. |
| 209 | */ |
| 210 | iowrite32(0, tgpio->membase + TGPIO_IER); |
| 211 | |
Akinobu Mita | 984b3f5 | 2010-03-05 13:41:37 -0800 | [diff] [blame] | 212 | for_each_set_bit(offset, &ipr, tgpio->gpio.ngpio) |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 213 | generic_handle_irq(timbgpio_to_irq(&tgpio->gpio, offset)); |
Tomas Hallenberg | 76d800a | 2010-10-27 15:33:17 -0700 | [diff] [blame] | 214 | |
| 215 | iowrite32(tgpio->last_ier, tgpio->membase + TGPIO_IER); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | static struct irq_chip timbgpio_irqchip = { |
| 219 | .name = "GPIO", |
Lennert Buytenhek | a1f5f22 | 2011-01-12 17:00:19 -0800 | [diff] [blame] | 220 | .irq_enable = timbgpio_irq_enable, |
| 221 | .irq_disable = timbgpio_irq_disable, |
| 222 | .irq_set_type = timbgpio_irq_type, |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 223 | }; |
| 224 | |
Bill Pemberton | 3836309 | 2012-11-19 13:22:34 -0500 | [diff] [blame] | 225 | static int timbgpio_probe(struct platform_device *pdev) |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 226 | { |
| 227 | int err, i; |
abdoulaye berthe | 0ed3398 | 2014-05-13 03:21:42 +0200 | [diff] [blame] | 228 | struct device *dev = &pdev->dev; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 229 | struct gpio_chip *gc; |
| 230 | struct timbgpio *tgpio; |
| 231 | struct resource *iomem; |
Jingoo Han | e56aee1 | 2013-07-30 17:08:05 +0900 | [diff] [blame] | 232 | struct timbgpio_platform_data *pdata = dev_get_platdata(&pdev->dev); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 233 | int irq = platform_get_irq(pdev, 0); |
| 234 | |
| 235 | if (!pdata || pdata->nr_pins > 32) { |
abdoulaye berthe | 0ed3398 | 2014-05-13 03:21:42 +0200 | [diff] [blame] | 236 | dev_err(dev, "Invalid platform data\n"); |
| 237 | return -EINVAL; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 241 | if (!iomem) { |
abdoulaye berthe | 0ed3398 | 2014-05-13 03:21:42 +0200 | [diff] [blame] | 242 | dev_err(dev, "Unable to get resource\n"); |
| 243 | return -EINVAL; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 244 | } |
| 245 | |
abdoulaye berthe | 0ed3398 | 2014-05-13 03:21:42 +0200 | [diff] [blame] | 246 | tgpio = devm_kzalloc(dev, sizeof(struct timbgpio), GFP_KERNEL); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 247 | if (!tgpio) { |
abdoulaye berthe | 0ed3398 | 2014-05-13 03:21:42 +0200 | [diff] [blame] | 248 | dev_err(dev, "Memory alloc failed\n"); |
| 249 | return -EINVAL; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 250 | } |
| 251 | tgpio->irq_base = pdata->irq_base; |
| 252 | |
| 253 | spin_lock_init(&tgpio->lock); |
| 254 | |
abdoulaye berthe | 0ed3398 | 2014-05-13 03:21:42 +0200 | [diff] [blame] | 255 | if (!devm_request_mem_region(dev, iomem->start, resource_size(iomem), |
| 256 | DRIVER_NAME)) { |
| 257 | dev_err(dev, "Region already claimed\n"); |
| 258 | return -EBUSY; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 259 | } |
| 260 | |
abdoulaye berthe | 0ed3398 | 2014-05-13 03:21:42 +0200 | [diff] [blame] | 261 | tgpio->membase = devm_ioremap(dev, iomem->start, resource_size(iomem)); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 262 | if (!tgpio->membase) { |
abdoulaye berthe | 0ed3398 | 2014-05-13 03:21:42 +0200 | [diff] [blame] | 263 | dev_err(dev, "Cannot ioremap\n"); |
| 264 | return -ENOMEM; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 265 | } |
| 266 | |
| 267 | gc = &tgpio->gpio; |
| 268 | |
| 269 | gc->label = dev_name(&pdev->dev); |
| 270 | gc->owner = THIS_MODULE; |
| 271 | gc->dev = &pdev->dev; |
| 272 | gc->direction_input = timbgpio_gpio_direction_input; |
| 273 | gc->get = timbgpio_gpio_get; |
| 274 | gc->direction_output = timbgpio_gpio_direction_output; |
| 275 | gc->set = timbgpio_gpio_set; |
| 276 | gc->to_irq = (irq >= 0 && tgpio->irq_base > 0) ? timbgpio_to_irq : NULL; |
| 277 | gc->dbg_show = NULL; |
| 278 | gc->base = pdata->gpio_base; |
| 279 | gc->ngpio = pdata->nr_pins; |
Linus Walleij | 9fb1f39 | 2013-12-04 14:42:46 +0100 | [diff] [blame] | 280 | gc->can_sleep = false; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 281 | |
| 282 | err = gpiochip_add(gc); |
| 283 | if (err) |
abdoulaye berthe | 0ed3398 | 2014-05-13 03:21:42 +0200 | [diff] [blame] | 284 | return err; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 285 | |
| 286 | platform_set_drvdata(pdev, tgpio); |
| 287 | |
| 288 | /* make sure to disable interrupts */ |
| 289 | iowrite32(0x0, tgpio->membase + TGPIO_IER); |
| 290 | |
| 291 | if (irq < 0 || tgpio->irq_base <= 0) |
| 292 | return 0; |
| 293 | |
| 294 | for (i = 0; i < pdata->nr_pins; i++) { |
Linus Walleij | e5428a6 | 2013-11-26 14:28:32 +0100 | [diff] [blame] | 295 | irq_set_chip_and_handler(tgpio->irq_base + i, |
| 296 | &timbgpio_irqchip, handle_simple_irq); |
Thomas Gleixner | b51804b | 2011-03-24 21:27:36 +0000 | [diff] [blame] | 297 | irq_set_chip_data(tgpio->irq_base + i, tgpio); |
Rob Herring | 23393d4 | 2015-07-27 15:55:16 -0500 | [diff] [blame] | 298 | irq_clear_status_flags(tgpio->irq_base + i, IRQ_NOREQUEST | IRQ_NOPROBE); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 299 | } |
| 300 | |
Thomas Gleixner | 8a52211 | 2015-06-21 21:10:47 +0200 | [diff] [blame] | 301 | irq_set_chained_handler_and_data(irq, timbgpio_irq, tgpio); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 302 | |
| 303 | return 0; |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 304 | } |
| 305 | |
Bill Pemberton | 206210c | 2012-11-19 13:25:50 -0500 | [diff] [blame] | 306 | static int timbgpio_remove(struct platform_device *pdev) |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 307 | { |
Jingoo Han | e56aee1 | 2013-07-30 17:08:05 +0900 | [diff] [blame] | 308 | struct timbgpio_platform_data *pdata = dev_get_platdata(&pdev->dev); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 309 | struct timbgpio *tgpio = platform_get_drvdata(pdev); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 310 | int irq = platform_get_irq(pdev, 0); |
| 311 | |
| 312 | if (irq >= 0 && tgpio->irq_base > 0) { |
| 313 | int i; |
Samuel Ortiz | 3271d38 | 2011-04-08 01:23:57 +0200 | [diff] [blame] | 314 | for (i = 0; i < pdata->nr_pins; i++) { |
Thomas Gleixner | b51804b | 2011-03-24 21:27:36 +0000 | [diff] [blame] | 315 | irq_set_chip(tgpio->irq_base + i, NULL); |
| 316 | irq_set_chip_data(tgpio->irq_base + i, NULL); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 317 | } |
| 318 | |
Thomas Gleixner | b51804b | 2011-03-24 21:27:36 +0000 | [diff] [blame] | 319 | irq_set_handler(irq, NULL); |
| 320 | irq_set_handler_data(irq, NULL); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 321 | } |
| 322 | |
abdoulaye berthe | 9f5132a | 2014-07-12 22:30:12 +0200 | [diff] [blame] | 323 | gpiochip_remove(&tgpio->gpio); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 324 | |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 325 | return 0; |
| 326 | } |
| 327 | |
| 328 | static struct platform_driver timbgpio_platform_driver = { |
| 329 | .driver = { |
| 330 | .name = DRIVER_NAME, |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 331 | }, |
| 332 | .probe = timbgpio_probe, |
| 333 | .remove = timbgpio_remove, |
| 334 | }; |
| 335 | |
| 336 | /*--------------------------------------------------------------------------*/ |
| 337 | |
Mark Brown | 6f61415 | 2011-12-08 00:24:00 +0800 | [diff] [blame] | 338 | module_platform_driver(timbgpio_platform_driver); |
Richard Röjfors | 35570ac | 2009-12-15 16:46:18 -0800 | [diff] [blame] | 339 | |
| 340 | MODULE_DESCRIPTION("Timberdale GPIO driver"); |
| 341 | MODULE_LICENSE("GPL v2"); |
| 342 | MODULE_AUTHOR("Mocean Laboratories"); |
| 343 | MODULE_ALIAS("platform:"DRIVER_NAME); |
| 344 | |