Merge branch 'master' into for-next
[linux-2.6-microblaze.git] / drivers / gpio / gpio-pci-idio-16.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * GPIO driver for the ACCES PCI-IDIO-16
4  * Copyright (C) 2017 William Breathitt Gray
5  */
6 #include <linux/bitmap.h>
7 #include <linux/bitops.h>
8 #include <linux/device.h>
9 #include <linux/errno.h>
10 #include <linux/gpio/driver.h>
11 #include <linux/interrupt.h>
12 #include <linux/irqdesc.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/pci.h>
16 #include <linux/spinlock.h>
17 #include <linux/types.h>
18
19 /**
20  * struct idio_16_gpio_reg - GPIO device registers structure
21  * @out0_7:     Read: FET Drive Outputs 0-7
22  *              Write: FET Drive Outputs 0-7
23  * @in0_7:      Read: Isolated Inputs 0-7
24  *              Write: Clear Interrupt
25  * @irq_ctl:    Read: Enable IRQ
26  *              Write: Disable IRQ
27  * @filter_ctl: Read: Activate Input Filters 0-15
28  *              Write: Deactivate Input Filters 0-15
29  * @out8_15:    Read: FET Drive Outputs 8-15
30  *              Write: FET Drive Outputs 8-15
31  * @in8_15:     Read: Isolated Inputs 8-15
32  *              Write: Unused
33  * @irq_status: Read: Interrupt status
34  *              Write: Unused
35  */
36 struct idio_16_gpio_reg {
37         u8 out0_7;
38         u8 in0_7;
39         u8 irq_ctl;
40         u8 filter_ctl;
41         u8 out8_15;
42         u8 in8_15;
43         u8 irq_status;
44 };
45
46 /**
47  * struct idio_16_gpio - GPIO device private data structure
48  * @chip:       instance of the gpio_chip
49  * @lock:       synchronization lock to prevent I/O race conditions
50  * @reg:        I/O address offset for the GPIO device registers
51  * @irq_mask:   I/O bits affected by interrupts
52  */
53 struct idio_16_gpio {
54         struct gpio_chip chip;
55         raw_spinlock_t lock;
56         struct idio_16_gpio_reg __iomem *reg;
57         unsigned long irq_mask;
58 };
59
60 static int idio_16_gpio_get_direction(struct gpio_chip *chip,
61         unsigned int offset)
62 {
63         if (offset > 15)
64                 return GPIO_LINE_DIRECTION_IN;
65
66         return GPIO_LINE_DIRECTION_OUT;
67 }
68
69 static int idio_16_gpio_direction_input(struct gpio_chip *chip,
70         unsigned int offset)
71 {
72         return 0;
73 }
74
75 static int idio_16_gpio_direction_output(struct gpio_chip *chip,
76         unsigned int offset, int value)
77 {
78         chip->set(chip, offset, value);
79         return 0;
80 }
81
82 static int idio_16_gpio_get(struct gpio_chip *chip, unsigned int offset)
83 {
84         struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
85         unsigned long mask = BIT(offset);
86
87         if (offset < 8)
88                 return !!(ioread8(&idio16gpio->reg->out0_7) & mask);
89
90         if (offset < 16)
91                 return !!(ioread8(&idio16gpio->reg->out8_15) & (mask >> 8));
92
93         if (offset < 24)
94                 return !!(ioread8(&idio16gpio->reg->in0_7) & (mask >> 16));
95
96         return !!(ioread8(&idio16gpio->reg->in8_15) & (mask >> 24));
97 }
98
99 static int idio_16_gpio_get_multiple(struct gpio_chip *chip,
100         unsigned long *mask, unsigned long *bits)
101 {
102         struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
103         unsigned long offset;
104         unsigned long gpio_mask;
105         void __iomem *ports[] = {
106                 &idio16gpio->reg->out0_7, &idio16gpio->reg->out8_15,
107                 &idio16gpio->reg->in0_7, &idio16gpio->reg->in8_15,
108         };
109         void __iomem *port_addr;
110         unsigned long port_state;
111
112         /* clear bits array to a clean slate */
113         bitmap_zero(bits, chip->ngpio);
114
115         for_each_set_clump8(offset, gpio_mask, mask, ARRAY_SIZE(ports) * 8) {
116                 port_addr = ports[offset / 8];
117                 port_state = ioread8(port_addr) & gpio_mask;
118
119                 bitmap_set_value8(bits, port_state, offset);
120         }
121
122         return 0;
123 }
124
125 static void idio_16_gpio_set(struct gpio_chip *chip, unsigned int offset,
126         int value)
127 {
128         struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
129         unsigned int mask = BIT(offset);
130         void __iomem *base;
131         unsigned long flags;
132         unsigned int out_state;
133
134         if (offset > 15)
135                 return;
136
137         if (offset > 7) {
138                 mask >>= 8;
139                 base = &idio16gpio->reg->out8_15;
140         } else
141                 base = &idio16gpio->reg->out0_7;
142
143         raw_spin_lock_irqsave(&idio16gpio->lock, flags);
144
145         if (value)
146                 out_state = ioread8(base) | mask;
147         else
148                 out_state = ioread8(base) & ~mask;
149
150         iowrite8(out_state, base);
151
152         raw_spin_unlock_irqrestore(&idio16gpio->lock, flags);
153 }
154
155 static void idio_16_gpio_set_multiple(struct gpio_chip *chip,
156         unsigned long *mask, unsigned long *bits)
157 {
158         struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
159         unsigned long offset;
160         unsigned long gpio_mask;
161         void __iomem *ports[] = {
162                 &idio16gpio->reg->out0_7, &idio16gpio->reg->out8_15,
163         };
164         size_t index;
165         void __iomem *port_addr;
166         unsigned long bitmask;
167         unsigned long flags;
168         unsigned long out_state;
169
170         for_each_set_clump8(offset, gpio_mask, mask, ARRAY_SIZE(ports) * 8) {
171                 index = offset / 8;
172                 port_addr = ports[index];
173
174                 bitmask = bitmap_get_value8(bits, offset) & gpio_mask;
175
176                 raw_spin_lock_irqsave(&idio16gpio->lock, flags);
177
178                 out_state = ioread8(port_addr) & ~gpio_mask;
179                 out_state |= bitmask;
180                 iowrite8(out_state, port_addr);
181
182                 raw_spin_unlock_irqrestore(&idio16gpio->lock, flags);
183         }
184 }
185
186 static void idio_16_irq_ack(struct irq_data *data)
187 {
188 }
189
190 static void idio_16_irq_mask(struct irq_data *data)
191 {
192         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
193         struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
194         const unsigned long mask = BIT(irqd_to_hwirq(data));
195         unsigned long flags;
196
197         idio16gpio->irq_mask &= ~mask;
198
199         if (!idio16gpio->irq_mask) {
200                 raw_spin_lock_irqsave(&idio16gpio->lock, flags);
201
202                 iowrite8(0, &idio16gpio->reg->irq_ctl);
203
204                 raw_spin_unlock_irqrestore(&idio16gpio->lock, flags);
205         }
206 }
207
208 static void idio_16_irq_unmask(struct irq_data *data)
209 {
210         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
211         struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
212         const unsigned long mask = BIT(irqd_to_hwirq(data));
213         const unsigned long prev_irq_mask = idio16gpio->irq_mask;
214         unsigned long flags;
215
216         idio16gpio->irq_mask |= mask;
217
218         if (!prev_irq_mask) {
219                 raw_spin_lock_irqsave(&idio16gpio->lock, flags);
220
221                 ioread8(&idio16gpio->reg->irq_ctl);
222
223                 raw_spin_unlock_irqrestore(&idio16gpio->lock, flags);
224         }
225 }
226
227 static int idio_16_irq_set_type(struct irq_data *data, unsigned int flow_type)
228 {
229         /* The only valid irq types are none and both-edges */
230         if (flow_type != IRQ_TYPE_NONE &&
231                 (flow_type & IRQ_TYPE_EDGE_BOTH) != IRQ_TYPE_EDGE_BOTH)
232                 return -EINVAL;
233
234         return 0;
235 }
236
237 static struct irq_chip idio_16_irqchip = {
238         .name = "pci-idio-16",
239         .irq_ack = idio_16_irq_ack,
240         .irq_mask = idio_16_irq_mask,
241         .irq_unmask = idio_16_irq_unmask,
242         .irq_set_type = idio_16_irq_set_type
243 };
244
245 static irqreturn_t idio_16_irq_handler(int irq, void *dev_id)
246 {
247         struct idio_16_gpio *const idio16gpio = dev_id;
248         unsigned int irq_status;
249         struct gpio_chip *const chip = &idio16gpio->chip;
250         int gpio;
251
252         raw_spin_lock(&idio16gpio->lock);
253
254         irq_status = ioread8(&idio16gpio->reg->irq_status);
255
256         raw_spin_unlock(&idio16gpio->lock);
257
258         /* Make sure our device generated IRQ */
259         if (!(irq_status & 0x3) || !(irq_status & 0x4))
260                 return IRQ_NONE;
261
262         for_each_set_bit(gpio, &idio16gpio->irq_mask, chip->ngpio)
263                 generic_handle_irq(irq_find_mapping(chip->irq.domain, gpio));
264
265         raw_spin_lock(&idio16gpio->lock);
266
267         /* Clear interrupt */
268         iowrite8(0, &idio16gpio->reg->in0_7);
269
270         raw_spin_unlock(&idio16gpio->lock);
271
272         return IRQ_HANDLED;
273 }
274
275 #define IDIO_16_NGPIO 32
276 static const char *idio_16_names[IDIO_16_NGPIO] = {
277         "OUT0", "OUT1", "OUT2", "OUT3", "OUT4", "OUT5", "OUT6", "OUT7",
278         "OUT8", "OUT9", "OUT10", "OUT11", "OUT12", "OUT13", "OUT14", "OUT15",
279         "IIN0", "IIN1", "IIN2", "IIN3", "IIN4", "IIN5", "IIN6", "IIN7",
280         "IIN8", "IIN9", "IIN10", "IIN11", "IIN12", "IIN13", "IIN14", "IIN15"
281 };
282
283 static int idio_16_irq_init_hw(struct gpio_chip *gc)
284 {
285         struct idio_16_gpio *const idio16gpio = gpiochip_get_data(gc);
286
287         /* Disable IRQ by default and clear any pending interrupt */
288         iowrite8(0, &idio16gpio->reg->irq_ctl);
289         iowrite8(0, &idio16gpio->reg->in0_7);
290
291         return 0;
292 }
293
294 static int idio_16_probe(struct pci_dev *pdev, const struct pci_device_id *id)
295 {
296         struct device *const dev = &pdev->dev;
297         struct idio_16_gpio *idio16gpio;
298         int err;
299         const size_t pci_bar_index = 2;
300         const char *const name = pci_name(pdev);
301         struct gpio_irq_chip *girq;
302
303         idio16gpio = devm_kzalloc(dev, sizeof(*idio16gpio), GFP_KERNEL);
304         if (!idio16gpio)
305                 return -ENOMEM;
306
307         err = pcim_enable_device(pdev);
308         if (err) {
309                 dev_err(dev, "Failed to enable PCI device (%d)\n", err);
310                 return err;
311         }
312
313         err = pcim_iomap_regions(pdev, BIT(pci_bar_index), name);
314         if (err) {
315                 dev_err(dev, "Unable to map PCI I/O addresses (%d)\n", err);
316                 return err;
317         }
318
319         idio16gpio->reg = pcim_iomap_table(pdev)[pci_bar_index];
320
321         /* Deactivate input filters */
322         iowrite8(0, &idio16gpio->reg->filter_ctl);
323
324         idio16gpio->chip.label = name;
325         idio16gpio->chip.parent = dev;
326         idio16gpio->chip.owner = THIS_MODULE;
327         idio16gpio->chip.base = -1;
328         idio16gpio->chip.ngpio = IDIO_16_NGPIO;
329         idio16gpio->chip.names = idio_16_names;
330         idio16gpio->chip.get_direction = idio_16_gpio_get_direction;
331         idio16gpio->chip.direction_input = idio_16_gpio_direction_input;
332         idio16gpio->chip.direction_output = idio_16_gpio_direction_output;
333         idio16gpio->chip.get = idio_16_gpio_get;
334         idio16gpio->chip.get_multiple = idio_16_gpio_get_multiple;
335         idio16gpio->chip.set = idio_16_gpio_set;
336         idio16gpio->chip.set_multiple = idio_16_gpio_set_multiple;
337
338         girq = &idio16gpio->chip.irq;
339         girq->chip = &idio_16_irqchip;
340         /* This will let us handle the parent IRQ in the driver */
341         girq->parent_handler = NULL;
342         girq->num_parents = 0;
343         girq->parents = NULL;
344         girq->default_type = IRQ_TYPE_NONE;
345         girq->handler = handle_edge_irq;
346         girq->init_hw = idio_16_irq_init_hw;
347
348         raw_spin_lock_init(&idio16gpio->lock);
349
350         err = devm_gpiochip_add_data(dev, &idio16gpio->chip, idio16gpio);
351         if (err) {
352                 dev_err(dev, "GPIO registering failed (%d)\n", err);
353                 return err;
354         }
355
356         err = devm_request_irq(dev, pdev->irq, idio_16_irq_handler, IRQF_SHARED,
357                 name, idio16gpio);
358         if (err) {
359                 dev_err(dev, "IRQ handler registering failed (%d)\n", err);
360                 return err;
361         }
362
363         return 0;
364 }
365
366 static const struct pci_device_id idio_16_pci_dev_id[] = {
367         { PCI_DEVICE(0x494F, 0x0DC8) }, { 0 }
368 };
369 MODULE_DEVICE_TABLE(pci, idio_16_pci_dev_id);
370
371 static struct pci_driver idio_16_driver = {
372         .name = "pci-idio-16",
373         .id_table = idio_16_pci_dev_id,
374         .probe = idio_16_probe
375 };
376
377 module_pci_driver(idio_16_driver);
378
379 MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>");
380 MODULE_DESCRIPTION("ACCES PCI-IDIO-16 GPIO driver");
381 MODULE_LICENSE("GPL v2");