GNU Linux-libre 5.19-rc6-gnu
[releases.git] / drivers / gpio / gpio-104-dio-48e.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * GPIO driver for the ACCES 104-DIO-48E series
4  * Copyright (C) 2016 William Breathitt Gray
5  *
6  * This driver supports the following ACCES devices: 104-DIO-48E and
7  * 104-DIO-24E.
8  */
9 #include <linux/bitmap.h>
10 #include <linux/bitops.h>
11 #include <linux/device.h>
12 #include <linux/errno.h>
13 #include <linux/gpio/driver.h>
14 #include <linux/io.h>
15 #include <linux/ioport.h>
16 #include <linux/interrupt.h>
17 #include <linux/irqdesc.h>
18 #include <linux/isa.h>
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/moduleparam.h>
22 #include <linux/spinlock.h>
23
24 #define DIO48E_EXTENT 16
25 #define MAX_NUM_DIO48E max_num_isa_dev(DIO48E_EXTENT)
26
27 static unsigned int base[MAX_NUM_DIO48E];
28 static unsigned int num_dio48e;
29 module_param_hw_array(base, uint, ioport, &num_dio48e, 0);
30 MODULE_PARM_DESC(base, "ACCES 104-DIO-48E base addresses");
31
32 static unsigned int irq[MAX_NUM_DIO48E];
33 module_param_hw_array(irq, uint, irq, NULL, 0);
34 MODULE_PARM_DESC(irq, "ACCES 104-DIO-48E interrupt line numbers");
35
36 /**
37  * struct dio48e_gpio - GPIO device private data structure
38  * @chip:       instance of the gpio_chip
39  * @io_state:   bit I/O state (whether bit is set to input or output)
40  * @out_state:  output bits state
41  * @control:    Control registers state
42  * @lock:       synchronization lock to prevent I/O race conditions
43  * @base:       base port address of the GPIO device
44  * @irq_mask:   I/O bits affected by interrupts
45  */
46 struct dio48e_gpio {
47         struct gpio_chip chip;
48         unsigned char io_state[6];
49         unsigned char out_state[6];
50         unsigned char control[2];
51         raw_spinlock_t lock;
52         void __iomem *base;
53         unsigned char irq_mask;
54 };
55
56 static int dio48e_gpio_get_direction(struct gpio_chip *chip, unsigned int offset)
57 {
58         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(chip);
59         const unsigned int port = offset / 8;
60         const unsigned int mask = BIT(offset % 8);
61
62         if (dio48egpio->io_state[port] & mask)
63                 return  GPIO_LINE_DIRECTION_IN;
64
65         return GPIO_LINE_DIRECTION_OUT;
66 }
67
68 static int dio48e_gpio_direction_input(struct gpio_chip *chip, unsigned int offset)
69 {
70         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(chip);
71         const unsigned int io_port = offset / 8;
72         const unsigned int control_port = io_port / 3;
73         void __iomem *const control_addr = dio48egpio->base + 3 + control_port * 4;
74         unsigned long flags;
75         unsigned int control;
76
77         raw_spin_lock_irqsave(&dio48egpio->lock, flags);
78
79         /* Check if configuring Port C */
80         if (io_port == 2 || io_port == 5) {
81                 /* Port C can be configured by nibble */
82                 if (offset % 8 > 3) {
83                         dio48egpio->io_state[io_port] |= 0xF0;
84                         dio48egpio->control[control_port] |= BIT(3);
85                 } else {
86                         dio48egpio->io_state[io_port] |= 0x0F;
87                         dio48egpio->control[control_port] |= BIT(0);
88                 }
89         } else {
90                 dio48egpio->io_state[io_port] |= 0xFF;
91                 if (io_port == 0 || io_port == 3)
92                         dio48egpio->control[control_port] |= BIT(4);
93                 else
94                         dio48egpio->control[control_port] |= BIT(1);
95         }
96
97         control = BIT(7) | dio48egpio->control[control_port];
98         iowrite8(control, control_addr);
99         control &= ~BIT(7);
100         iowrite8(control, control_addr);
101
102         raw_spin_unlock_irqrestore(&dio48egpio->lock, flags);
103
104         return 0;
105 }
106
107 static int dio48e_gpio_direction_output(struct gpio_chip *chip, unsigned int offset,
108                                         int value)
109 {
110         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(chip);
111         const unsigned int io_port = offset / 8;
112         const unsigned int control_port = io_port / 3;
113         const unsigned int mask = BIT(offset % 8);
114         void __iomem *const control_addr = dio48egpio->base + 3 + control_port * 4;
115         const unsigned int out_port = (io_port > 2) ? io_port + 1 : io_port;
116         unsigned long flags;
117         unsigned int control;
118
119         raw_spin_lock_irqsave(&dio48egpio->lock, flags);
120
121         /* Check if configuring Port C */
122         if (io_port == 2 || io_port == 5) {
123                 /* Port C can be configured by nibble */
124                 if (offset % 8 > 3) {
125                         dio48egpio->io_state[io_port] &= 0x0F;
126                         dio48egpio->control[control_port] &= ~BIT(3);
127                 } else {
128                         dio48egpio->io_state[io_port] &= 0xF0;
129                         dio48egpio->control[control_port] &= ~BIT(0);
130                 }
131         } else {
132                 dio48egpio->io_state[io_port] &= 0x00;
133                 if (io_port == 0 || io_port == 3)
134                         dio48egpio->control[control_port] &= ~BIT(4);
135                 else
136                         dio48egpio->control[control_port] &= ~BIT(1);
137         }
138
139         if (value)
140                 dio48egpio->out_state[io_port] |= mask;
141         else
142                 dio48egpio->out_state[io_port] &= ~mask;
143
144         control = BIT(7) | dio48egpio->control[control_port];
145         iowrite8(control, control_addr);
146
147         iowrite8(dio48egpio->out_state[io_port], dio48egpio->base + out_port);
148
149         control &= ~BIT(7);
150         iowrite8(control, control_addr);
151
152         raw_spin_unlock_irqrestore(&dio48egpio->lock, flags);
153
154         return 0;
155 }
156
157 static int dio48e_gpio_get(struct gpio_chip *chip, unsigned int offset)
158 {
159         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(chip);
160         const unsigned int port = offset / 8;
161         const unsigned int mask = BIT(offset % 8);
162         const unsigned int in_port = (port > 2) ? port + 1 : port;
163         unsigned long flags;
164         unsigned int port_state;
165
166         raw_spin_lock_irqsave(&dio48egpio->lock, flags);
167
168         /* ensure that GPIO is set for input */
169         if (!(dio48egpio->io_state[port] & mask)) {
170                 raw_spin_unlock_irqrestore(&dio48egpio->lock, flags);
171                 return -EINVAL;
172         }
173
174         port_state = ioread8(dio48egpio->base + in_port);
175
176         raw_spin_unlock_irqrestore(&dio48egpio->lock, flags);
177
178         return !!(port_state & mask);
179 }
180
181 static const size_t ports[] = { 0, 1, 2, 4, 5, 6 };
182
183 static int dio48e_gpio_get_multiple(struct gpio_chip *chip, unsigned long *mask,
184         unsigned long *bits)
185 {
186         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(chip);
187         unsigned long offset;
188         unsigned long gpio_mask;
189         void __iomem *port_addr;
190         unsigned long port_state;
191
192         /* clear bits array to a clean slate */
193         bitmap_zero(bits, chip->ngpio);
194
195         for_each_set_clump8(offset, gpio_mask, mask, ARRAY_SIZE(ports) * 8) {
196                 port_addr = dio48egpio->base + ports[offset / 8];
197                 port_state = ioread8(port_addr) & gpio_mask;
198
199                 bitmap_set_value8(bits, port_state, offset);
200         }
201
202         return 0;
203 }
204
205 static void dio48e_gpio_set(struct gpio_chip *chip, unsigned int offset, int value)
206 {
207         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(chip);
208         const unsigned int port = offset / 8;
209         const unsigned int mask = BIT(offset % 8);
210         const unsigned int out_port = (port > 2) ? port + 1 : port;
211         unsigned long flags;
212
213         raw_spin_lock_irqsave(&dio48egpio->lock, flags);
214
215         if (value)
216                 dio48egpio->out_state[port] |= mask;
217         else
218                 dio48egpio->out_state[port] &= ~mask;
219
220         iowrite8(dio48egpio->out_state[port], dio48egpio->base + out_port);
221
222         raw_spin_unlock_irqrestore(&dio48egpio->lock, flags);
223 }
224
225 static void dio48e_gpio_set_multiple(struct gpio_chip *chip,
226         unsigned long *mask, unsigned long *bits)
227 {
228         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(chip);
229         unsigned long offset;
230         unsigned long gpio_mask;
231         size_t index;
232         void __iomem *port_addr;
233         unsigned long bitmask;
234         unsigned long flags;
235
236         for_each_set_clump8(offset, gpio_mask, mask, ARRAY_SIZE(ports) * 8) {
237                 index = offset / 8;
238                 port_addr = dio48egpio->base + ports[index];
239
240                 bitmask = bitmap_get_value8(bits, offset) & gpio_mask;
241
242                 raw_spin_lock_irqsave(&dio48egpio->lock, flags);
243
244                 /* update output state data and set device gpio register */
245                 dio48egpio->out_state[index] &= ~gpio_mask;
246                 dio48egpio->out_state[index] |= bitmask;
247                 iowrite8(dio48egpio->out_state[index], port_addr);
248
249                 raw_spin_unlock_irqrestore(&dio48egpio->lock, flags);
250         }
251 }
252
253 static void dio48e_irq_ack(struct irq_data *data)
254 {
255 }
256
257 static void dio48e_irq_mask(struct irq_data *data)
258 {
259         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
260         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(chip);
261         const unsigned long offset = irqd_to_hwirq(data);
262         unsigned long flags;
263
264         /* only bit 3 on each respective Port C supports interrupts */
265         if (offset != 19 && offset != 43)
266                 return;
267
268         raw_spin_lock_irqsave(&dio48egpio->lock, flags);
269
270         if (offset == 19)
271                 dio48egpio->irq_mask &= ~BIT(0);
272         else
273                 dio48egpio->irq_mask &= ~BIT(1);
274
275         if (!dio48egpio->irq_mask)
276                 /* disable interrupts */
277                 ioread8(dio48egpio->base + 0xB);
278
279         raw_spin_unlock_irqrestore(&dio48egpio->lock, flags);
280 }
281
282 static void dio48e_irq_unmask(struct irq_data *data)
283 {
284         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
285         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(chip);
286         const unsigned long offset = irqd_to_hwirq(data);
287         unsigned long flags;
288
289         /* only bit 3 on each respective Port C supports interrupts */
290         if (offset != 19 && offset != 43)
291                 return;
292
293         raw_spin_lock_irqsave(&dio48egpio->lock, flags);
294
295         if (!dio48egpio->irq_mask) {
296                 /* enable interrupts */
297                 iowrite8(0x00, dio48egpio->base + 0xF);
298                 iowrite8(0x00, dio48egpio->base + 0xB);
299         }
300
301         if (offset == 19)
302                 dio48egpio->irq_mask |= BIT(0);
303         else
304                 dio48egpio->irq_mask |= BIT(1);
305
306         raw_spin_unlock_irqrestore(&dio48egpio->lock, flags);
307 }
308
309 static int dio48e_irq_set_type(struct irq_data *data, unsigned int flow_type)
310 {
311         const unsigned long offset = irqd_to_hwirq(data);
312
313         /* only bit 3 on each respective Port C supports interrupts */
314         if (offset != 19 && offset != 43)
315                 return -EINVAL;
316
317         if (flow_type != IRQ_TYPE_NONE && flow_type != IRQ_TYPE_EDGE_RISING)
318                 return -EINVAL;
319
320         return 0;
321 }
322
323 static struct irq_chip dio48e_irqchip = {
324         .name = "104-dio-48e",
325         .irq_ack = dio48e_irq_ack,
326         .irq_mask = dio48e_irq_mask,
327         .irq_unmask = dio48e_irq_unmask,
328         .irq_set_type = dio48e_irq_set_type
329 };
330
331 static irqreturn_t dio48e_irq_handler(int irq, void *dev_id)
332 {
333         struct dio48e_gpio *const dio48egpio = dev_id;
334         struct gpio_chip *const chip = &dio48egpio->chip;
335         const unsigned long irq_mask = dio48egpio->irq_mask;
336         unsigned long gpio;
337
338         for_each_set_bit(gpio, &irq_mask, 2)
339                 generic_handle_domain_irq(chip->irq.domain,
340                                           19 + gpio*24);
341
342         raw_spin_lock(&dio48egpio->lock);
343
344         iowrite8(0x00, dio48egpio->base + 0xF);
345
346         raw_spin_unlock(&dio48egpio->lock);
347
348         return IRQ_HANDLED;
349 }
350
351 #define DIO48E_NGPIO 48
352 static const char *dio48e_names[DIO48E_NGPIO] = {
353         "PPI Group 0 Port A 0", "PPI Group 0 Port A 1", "PPI Group 0 Port A 2",
354         "PPI Group 0 Port A 3", "PPI Group 0 Port A 4", "PPI Group 0 Port A 5",
355         "PPI Group 0 Port A 6", "PPI Group 0 Port A 7", "PPI Group 0 Port B 0",
356         "PPI Group 0 Port B 1", "PPI Group 0 Port B 2", "PPI Group 0 Port B 3",
357         "PPI Group 0 Port B 4", "PPI Group 0 Port B 5", "PPI Group 0 Port B 6",
358         "PPI Group 0 Port B 7", "PPI Group 0 Port C 0", "PPI Group 0 Port C 1",
359         "PPI Group 0 Port C 2", "PPI Group 0 Port C 3", "PPI Group 0 Port C 4",
360         "PPI Group 0 Port C 5", "PPI Group 0 Port C 6", "PPI Group 0 Port C 7",
361         "PPI Group 1 Port A 0", "PPI Group 1 Port A 1", "PPI Group 1 Port A 2",
362         "PPI Group 1 Port A 3", "PPI Group 1 Port A 4", "PPI Group 1 Port A 5",
363         "PPI Group 1 Port A 6", "PPI Group 1 Port A 7", "PPI Group 1 Port B 0",
364         "PPI Group 1 Port B 1", "PPI Group 1 Port B 2", "PPI Group 1 Port B 3",
365         "PPI Group 1 Port B 4", "PPI Group 1 Port B 5", "PPI Group 1 Port B 6",
366         "PPI Group 1 Port B 7", "PPI Group 1 Port C 0", "PPI Group 1 Port C 1",
367         "PPI Group 1 Port C 2", "PPI Group 1 Port C 3", "PPI Group 1 Port C 4",
368         "PPI Group 1 Port C 5", "PPI Group 1 Port C 6", "PPI Group 1 Port C 7"
369 };
370
371 static int dio48e_irq_init_hw(struct gpio_chip *gc)
372 {
373         struct dio48e_gpio *const dio48egpio = gpiochip_get_data(gc);
374
375         /* Disable IRQ by default */
376         ioread8(dio48egpio->base + 0xB);
377
378         return 0;
379 }
380
381 static int dio48e_probe(struct device *dev, unsigned int id)
382 {
383         struct dio48e_gpio *dio48egpio;
384         const char *const name = dev_name(dev);
385         struct gpio_irq_chip *girq;
386         int err;
387
388         dio48egpio = devm_kzalloc(dev, sizeof(*dio48egpio), GFP_KERNEL);
389         if (!dio48egpio)
390                 return -ENOMEM;
391
392         if (!devm_request_region(dev, base[id], DIO48E_EXTENT, name)) {
393                 dev_err(dev, "Unable to lock port addresses (0x%X-0x%X)\n",
394                         base[id], base[id] + DIO48E_EXTENT);
395                 return -EBUSY;
396         }
397
398         dio48egpio->base = devm_ioport_map(dev, base[id], DIO48E_EXTENT);
399         if (!dio48egpio->base)
400                 return -ENOMEM;
401
402         dio48egpio->chip.label = name;
403         dio48egpio->chip.parent = dev;
404         dio48egpio->chip.owner = THIS_MODULE;
405         dio48egpio->chip.base = -1;
406         dio48egpio->chip.ngpio = DIO48E_NGPIO;
407         dio48egpio->chip.names = dio48e_names;
408         dio48egpio->chip.get_direction = dio48e_gpio_get_direction;
409         dio48egpio->chip.direction_input = dio48e_gpio_direction_input;
410         dio48egpio->chip.direction_output = dio48e_gpio_direction_output;
411         dio48egpio->chip.get = dio48e_gpio_get;
412         dio48egpio->chip.get_multiple = dio48e_gpio_get_multiple;
413         dio48egpio->chip.set = dio48e_gpio_set;
414         dio48egpio->chip.set_multiple = dio48e_gpio_set_multiple;
415
416         girq = &dio48egpio->chip.irq;
417         girq->chip = &dio48e_irqchip;
418         /* This will let us handle the parent IRQ in the driver */
419         girq->parent_handler = NULL;
420         girq->num_parents = 0;
421         girq->parents = NULL;
422         girq->default_type = IRQ_TYPE_NONE;
423         girq->handler = handle_edge_irq;
424         girq->init_hw = dio48e_irq_init_hw;
425
426         raw_spin_lock_init(&dio48egpio->lock);
427
428         /* initialize all GPIO as output */
429         iowrite8(0x80, dio48egpio->base + 3);
430         iowrite8(0x00, dio48egpio->base);
431         iowrite8(0x00, dio48egpio->base + 1);
432         iowrite8(0x00, dio48egpio->base + 2);
433         iowrite8(0x00, dio48egpio->base + 3);
434         iowrite8(0x80, dio48egpio->base + 7);
435         iowrite8(0x00, dio48egpio->base + 4);
436         iowrite8(0x00, dio48egpio->base + 5);
437         iowrite8(0x00, dio48egpio->base + 6);
438         iowrite8(0x00, dio48egpio->base + 7);
439
440         err = devm_gpiochip_add_data(dev, &dio48egpio->chip, dio48egpio);
441         if (err) {
442                 dev_err(dev, "GPIO registering failed (%d)\n", err);
443                 return err;
444         }
445
446         err = devm_request_irq(dev, irq[id], dio48e_irq_handler, 0, name,
447                 dio48egpio);
448         if (err) {
449                 dev_err(dev, "IRQ handler registering failed (%d)\n", err);
450                 return err;
451         }
452
453         return 0;
454 }
455
456 static struct isa_driver dio48e_driver = {
457         .probe = dio48e_probe,
458         .driver = {
459                 .name = "104-dio-48e"
460         },
461 };
462 module_isa_driver(dio48e_driver, num_dio48e);
463
464 MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>");
465 MODULE_DESCRIPTION("ACCES 104-DIO-48E GPIO driver");
466 MODULE_LICENSE("GPL v2");