1 /*
2  * GPIO driver for the ACCES 104-IDIO-16 family
3  * Copyright (C) 2015 William Breathitt Gray
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, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * This driver supports the following ACCES devices: 104-IDIO-16,
15  * 104-IDIO-16E, 104-IDO-16, 104-IDIO-8, 104-IDIO-8E, and 104-IDO-8.
16  */
17 #include <linux/bitops.h>
18 #include <linux/device.h>
19 #include <linux/errno.h>
20 #include <linux/gpio/driver.h>
21 #include <linux/io.h>
22 #include <linux/ioport.h>
23 #include <linux/interrupt.h>
24 #include <linux/irqdesc.h>
25 #include <linux/isa.h>
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/moduleparam.h>
29 #include <linux/spinlock.h>
30 
31 #define IDIO_16_EXTENT 8
32 #define MAX_NUM_IDIO_16 max_num_isa_dev(IDIO_16_EXTENT)
33 
34 static unsigned int base[MAX_NUM_IDIO_16];
35 static unsigned int num_idio_16;
36 module_param_hw_array(base, uint, ioport, &num_idio_16, 0);
37 MODULE_PARM_DESC(base, "ACCES 104-IDIO-16 base addresses");
38 
39 static unsigned int irq[MAX_NUM_IDIO_16];
40 module_param_hw_array(irq, uint, irq, NULL, 0);
41 MODULE_PARM_DESC(irq, "ACCES 104-IDIO-16 interrupt line numbers");
42 
43 /**
44  * struct idio_16_gpio - GPIO device private data structure
45  * @chip:	instance of the gpio_chip
46  * @lock:	synchronization lock to prevent I/O race conditions
47  * @irq_mask:	I/O bits affected by interrupts
48  * @base:	base port address of the GPIO device
49  * @out_state:	output bits state
50  */
51 struct idio_16_gpio {
52 	struct gpio_chip chip;
53 	raw_spinlock_t lock;
54 	unsigned long irq_mask;
55 	unsigned base;
56 	unsigned out_state;
57 };
58 
59 static int idio_16_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
60 {
61 	if (offset > 15)
62 		return 1;
63 
64 	return 0;
65 }
66 
67 static int idio_16_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
68 {
69 	return 0;
70 }
71 
72 static int idio_16_gpio_direction_output(struct gpio_chip *chip,
73 	unsigned offset, int value)
74 {
75 	chip->set(chip, offset, value);
76 	return 0;
77 }
78 
79 static int idio_16_gpio_get(struct gpio_chip *chip, unsigned offset)
80 {
81 	struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
82 	const unsigned mask = BIT(offset-16);
83 
84 	if (offset < 16)
85 		return -EINVAL;
86 
87 	if (offset < 24)
88 		return !!(inb(idio16gpio->base + 1) & mask);
89 
90 	return !!(inb(idio16gpio->base + 5) & (mask>>8));
91 }
92 
93 static void idio_16_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
94 {
95 	struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
96 	const unsigned mask = BIT(offset);
97 	unsigned long flags;
98 
99 	if (offset > 15)
100 		return;
101 
102 	raw_spin_lock_irqsave(&idio16gpio->lock, flags);
103 
104 	if (value)
105 		idio16gpio->out_state |= mask;
106 	else
107 		idio16gpio->out_state &= ~mask;
108 
109 	if (offset > 7)
110 		outb(idio16gpio->out_state >> 8, idio16gpio->base + 4);
111 	else
112 		outb(idio16gpio->out_state, idio16gpio->base);
113 
114 	raw_spin_unlock_irqrestore(&idio16gpio->lock, flags);
115 }
116 
117 static void idio_16_gpio_set_multiple(struct gpio_chip *chip,
118 	unsigned long *mask, unsigned long *bits)
119 {
120 	struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
121 	unsigned long flags;
122 
123 	raw_spin_lock_irqsave(&idio16gpio->lock, flags);
124 
125 	idio16gpio->out_state &= ~*mask;
126 	idio16gpio->out_state |= *mask & *bits;
127 
128 	if (*mask & 0xFF)
129 		outb(idio16gpio->out_state, idio16gpio->base);
130 	if ((*mask >> 8) & 0xFF)
131 		outb(idio16gpio->out_state >> 8, idio16gpio->base + 4);
132 
133 	raw_spin_unlock_irqrestore(&idio16gpio->lock, flags);
134 }
135 
136 static void idio_16_irq_ack(struct irq_data *data)
137 {
138 }
139 
140 static void idio_16_irq_mask(struct irq_data *data)
141 {
142 	struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
143 	struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
144 	const unsigned long mask = BIT(irqd_to_hwirq(data));
145 	unsigned long flags;
146 
147 	idio16gpio->irq_mask &= ~mask;
148 
149 	if (!idio16gpio->irq_mask) {
150 		raw_spin_lock_irqsave(&idio16gpio->lock, flags);
151 
152 		outb(0, idio16gpio->base + 2);
153 
154 		raw_spin_unlock_irqrestore(&idio16gpio->lock, flags);
155 	}
156 }
157 
158 static void idio_16_irq_unmask(struct irq_data *data)
159 {
160 	struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
161 	struct idio_16_gpio *const idio16gpio = gpiochip_get_data(chip);
162 	const unsigned long mask = BIT(irqd_to_hwirq(data));
163 	const unsigned long prev_irq_mask = idio16gpio->irq_mask;
164 	unsigned long flags;
165 
166 	idio16gpio->irq_mask |= mask;
167 
168 	if (!prev_irq_mask) {
169 		raw_spin_lock_irqsave(&idio16gpio->lock, flags);
170 
171 		inb(idio16gpio->base + 2);
172 
173 		raw_spin_unlock_irqrestore(&idio16gpio->lock, flags);
174 	}
175 }
176 
177 static int idio_16_irq_set_type(struct irq_data *data, unsigned flow_type)
178 {
179 	/* The only valid irq types are none and both-edges */
180 	if (flow_type != IRQ_TYPE_NONE &&
181 		(flow_type & IRQ_TYPE_EDGE_BOTH) != IRQ_TYPE_EDGE_BOTH)
182 		return -EINVAL;
183 
184 	return 0;
185 }
186 
187 static struct irq_chip idio_16_irqchip = {
188 	.name = "104-idio-16",
189 	.irq_ack = idio_16_irq_ack,
190 	.irq_mask = idio_16_irq_mask,
191 	.irq_unmask = idio_16_irq_unmask,
192 	.irq_set_type = idio_16_irq_set_type
193 };
194 
195 static irqreturn_t idio_16_irq_handler(int irq, void *dev_id)
196 {
197 	struct idio_16_gpio *const idio16gpio = dev_id;
198 	struct gpio_chip *const chip = &idio16gpio->chip;
199 	int gpio;
200 
201 	for_each_set_bit(gpio, &idio16gpio->irq_mask, chip->ngpio)
202 		generic_handle_irq(irq_find_mapping(chip->irq.domain, gpio));
203 
204 	raw_spin_lock(&idio16gpio->lock);
205 
206 	outb(0, idio16gpio->base + 1);
207 
208 	raw_spin_unlock(&idio16gpio->lock);
209 
210 	return IRQ_HANDLED;
211 }
212 
213 #define IDIO_16_NGPIO 32
214 static const char *idio_16_names[IDIO_16_NGPIO] = {
215 	"OUT0", "OUT1", "OUT2", "OUT3", "OUT4", "OUT5", "OUT6", "OUT7",
216 	"OUT8", "OUT9", "OUT10", "OUT11", "OUT12", "OUT13", "OUT14", "OUT15",
217 	"IIN0", "IIN1", "IIN2", "IIN3", "IIN4", "IIN5", "IIN6", "IIN7",
218 	"IIN8", "IIN9", "IIN10", "IIN11", "IIN12", "IIN13", "IIN14", "IIN15"
219 };
220 
221 static int idio_16_probe(struct device *dev, unsigned int id)
222 {
223 	struct idio_16_gpio *idio16gpio;
224 	const char *const name = dev_name(dev);
225 	int err;
226 
227 	idio16gpio = devm_kzalloc(dev, sizeof(*idio16gpio), GFP_KERNEL);
228 	if (!idio16gpio)
229 		return -ENOMEM;
230 
231 	if (!devm_request_region(dev, base[id], IDIO_16_EXTENT, name)) {
232 		dev_err(dev, "Unable to lock port addresses (0x%X-0x%X)\n",
233 			base[id], base[id] + IDIO_16_EXTENT);
234 		return -EBUSY;
235 	}
236 
237 	idio16gpio->chip.label = name;
238 	idio16gpio->chip.parent = dev;
239 	idio16gpio->chip.owner = THIS_MODULE;
240 	idio16gpio->chip.base = -1;
241 	idio16gpio->chip.ngpio = IDIO_16_NGPIO;
242 	idio16gpio->chip.names = idio_16_names;
243 	idio16gpio->chip.get_direction = idio_16_gpio_get_direction;
244 	idio16gpio->chip.direction_input = idio_16_gpio_direction_input;
245 	idio16gpio->chip.direction_output = idio_16_gpio_direction_output;
246 	idio16gpio->chip.get = idio_16_gpio_get;
247 	idio16gpio->chip.set = idio_16_gpio_set;
248 	idio16gpio->chip.set_multiple = idio_16_gpio_set_multiple;
249 	idio16gpio->base = base[id];
250 	idio16gpio->out_state = 0xFFFF;
251 
252 	raw_spin_lock_init(&idio16gpio->lock);
253 
254 	err = devm_gpiochip_add_data(dev, &idio16gpio->chip, idio16gpio);
255 	if (err) {
256 		dev_err(dev, "GPIO registering failed (%d)\n", err);
257 		return err;
258 	}
259 
260 	/* Disable IRQ by default */
261 	outb(0, base[id] + 2);
262 	outb(0, base[id] + 1);
263 
264 	err = gpiochip_irqchip_add(&idio16gpio->chip, &idio_16_irqchip, 0,
265 		handle_edge_irq, IRQ_TYPE_NONE);
266 	if (err) {
267 		dev_err(dev, "Could not add irqchip (%d)\n", err);
268 		return err;
269 	}
270 
271 	err = devm_request_irq(dev, irq[id], idio_16_irq_handler, 0, name,
272 		idio16gpio);
273 	if (err) {
274 		dev_err(dev, "IRQ handler registering failed (%d)\n", err);
275 		return err;
276 	}
277 
278 	return 0;
279 }
280 
281 static struct isa_driver idio_16_driver = {
282 	.probe = idio_16_probe,
283 	.driver = {
284 		.name = "104-idio-16"
285 	},
286 };
287 
288 module_isa_driver(idio_16_driver, num_idio_16);
289 
290 MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>");
291 MODULE_DESCRIPTION("ACCES 104-IDIO-16 GPIO driver");
292 MODULE_LICENSE("GPL v2");
293