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