1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * GPIO driver for the ACCES PCIe-IDIO-24 family 4 * Copyright (C) 2018 William Breathitt Gray 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License, version 2, as 8 * published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * This driver supports the following ACCES devices: PCIe-IDIO-24, 16 * PCIe-IDI-24, PCIe-IDO-24, and PCIe-IDIO-12. 17 */ 18 #include <linux/bitmap.h> 19 #include <linux/bitops.h> 20 #include <linux/device.h> 21 #include <linux/errno.h> 22 #include <linux/gpio/driver.h> 23 #include <linux/interrupt.h> 24 #include <linux/irqdesc.h> 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/pci.h> 28 #include <linux/spinlock.h> 29 #include <linux/types.h> 30 31 /** 32 * struct idio_24_gpio_reg - GPIO device registers structure 33 * @out0_7: Read: FET Outputs 0-7 34 * Write: FET Outputs 0-7 35 * @out8_15: Read: FET Outputs 8-15 36 * Write: FET Outputs 8-15 37 * @out16_23: Read: FET Outputs 16-23 38 * Write: FET Outputs 16-23 39 * @ttl_out0_7: Read: TTL/CMOS Outputs 0-7 40 * Write: TTL/CMOS Outputs 0-7 41 * @in0_7: Read: Isolated Inputs 0-7 42 * Write: Reserved 43 * @in8_15: Read: Isolated Inputs 8-15 44 * Write: Reserved 45 * @in16_23: Read: Isolated Inputs 16-23 46 * Write: Reserved 47 * @ttl_in0_7: Read: TTL/CMOS Inputs 0-7 48 * Write: Reserved 49 * @cos0_7: Read: COS Status Inputs 0-7 50 * Write: COS Clear Inputs 0-7 51 * @cos8_15: Read: COS Status Inputs 8-15 52 * Write: COS Clear Inputs 8-15 53 * @cos16_23: Read: COS Status Inputs 16-23 54 * Write: COS Clear Inputs 16-23 55 * @cos_ttl0_7: Read: COS Status TTL/CMOS 0-7 56 * Write: COS Clear TTL/CMOS 0-7 57 * @ctl: Read: Control Register 58 * Write: Control Register 59 * @reserved: Read: Reserved 60 * Write: Reserved 61 * @cos_enable: Read: COS Enable 62 * Write: COS Enable 63 * @soft_reset: Read: IRQ Output Pin Status 64 * Write: Software Board Reset 65 */ 66 struct idio_24_gpio_reg { 67 u8 out0_7; 68 u8 out8_15; 69 u8 out16_23; 70 u8 ttl_out0_7; 71 u8 in0_7; 72 u8 in8_15; 73 u8 in16_23; 74 u8 ttl_in0_7; 75 u8 cos0_7; 76 u8 cos8_15; 77 u8 cos16_23; 78 u8 cos_ttl0_7; 79 u8 ctl; 80 u8 reserved; 81 u8 cos_enable; 82 u8 soft_reset; 83 }; 84 85 /** 86 * struct idio_24_gpio - GPIO device private data structure 87 * @chip: instance of the gpio_chip 88 * @lock: synchronization lock to prevent I/O race conditions 89 * @reg: I/O address offset for the GPIO device registers 90 * @irq_mask: I/O bits affected by interrupts 91 */ 92 struct idio_24_gpio { 93 struct gpio_chip chip; 94 raw_spinlock_t lock; 95 struct idio_24_gpio_reg __iomem *reg; 96 unsigned long irq_mask; 97 }; 98 99 static int idio_24_gpio_get_direction(struct gpio_chip *chip, 100 unsigned int offset) 101 { 102 struct idio_24_gpio *const idio24gpio = gpiochip_get_data(chip); 103 const unsigned long out_mode_mask = BIT(1); 104 105 /* FET Outputs */ 106 if (offset < 24) 107 return 0; 108 109 /* Isolated Inputs */ 110 if (offset < 48) 111 return 1; 112 113 /* TTL/CMOS I/O */ 114 /* OUT MODE = 1 when TTL/CMOS Output Mode is set */ 115 return !(ioread8(&idio24gpio->reg->ctl) & out_mode_mask); 116 } 117 118 static int idio_24_gpio_direction_input(struct gpio_chip *chip, 119 unsigned int offset) 120 { 121 struct idio_24_gpio *const idio24gpio = gpiochip_get_data(chip); 122 unsigned long flags; 123 unsigned int ctl_state; 124 const unsigned long out_mode_mask = BIT(1); 125 126 /* TTL/CMOS I/O */ 127 if (offset > 47) { 128 raw_spin_lock_irqsave(&idio24gpio->lock, flags); 129 130 /* Clear TTL/CMOS Output Mode */ 131 ctl_state = ioread8(&idio24gpio->reg->ctl) & ~out_mode_mask; 132 iowrite8(ctl_state, &idio24gpio->reg->ctl); 133 134 raw_spin_unlock_irqrestore(&idio24gpio->lock, flags); 135 } 136 137 return 0; 138 } 139 140 static int idio_24_gpio_direction_output(struct gpio_chip *chip, 141 unsigned int offset, int value) 142 { 143 struct idio_24_gpio *const idio24gpio = gpiochip_get_data(chip); 144 unsigned long flags; 145 unsigned int ctl_state; 146 const unsigned long out_mode_mask = BIT(1); 147 148 /* TTL/CMOS I/O */ 149 if (offset > 47) { 150 raw_spin_lock_irqsave(&idio24gpio->lock, flags); 151 152 /* Set TTL/CMOS Output Mode */ 153 ctl_state = ioread8(&idio24gpio->reg->ctl) | out_mode_mask; 154 iowrite8(ctl_state, &idio24gpio->reg->ctl); 155 156 raw_spin_unlock_irqrestore(&idio24gpio->lock, flags); 157 } 158 159 chip->set(chip, offset, value); 160 return 0; 161 } 162 163 static int idio_24_gpio_get(struct gpio_chip *chip, unsigned int offset) 164 { 165 struct idio_24_gpio *const idio24gpio = gpiochip_get_data(chip); 166 const unsigned long offset_mask = BIT(offset % 8); 167 const unsigned long out_mode_mask = BIT(1); 168 169 /* FET Outputs */ 170 if (offset < 8) 171 return !!(ioread8(&idio24gpio->reg->out0_7) & offset_mask); 172 173 if (offset < 16) 174 return !!(ioread8(&idio24gpio->reg->out8_15) & offset_mask); 175 176 if (offset < 24) 177 return !!(ioread8(&idio24gpio->reg->out16_23) & offset_mask); 178 179 /* Isolated Inputs */ 180 if (offset < 32) 181 return !!(ioread8(&idio24gpio->reg->in0_7) & offset_mask); 182 183 if (offset < 40) 184 return !!(ioread8(&idio24gpio->reg->in8_15) & offset_mask); 185 186 if (offset < 48) 187 return !!(ioread8(&idio24gpio->reg->in16_23) & offset_mask); 188 189 /* TTL/CMOS Outputs */ 190 if (ioread8(&idio24gpio->reg->ctl) & out_mode_mask) 191 return !!(ioread8(&idio24gpio->reg->ttl_out0_7) & offset_mask); 192 193 /* TTL/CMOS Inputs */ 194 return !!(ioread8(&idio24gpio->reg->ttl_in0_7) & offset_mask); 195 } 196 197 static int idio_24_gpio_get_multiple(struct gpio_chip *chip, 198 unsigned long *mask, unsigned long *bits) 199 { 200 struct idio_24_gpio *const idio24gpio = gpiochip_get_data(chip); 201 size_t i; 202 const unsigned int gpio_reg_size = 8; 203 unsigned int bits_offset; 204 size_t word_index; 205 unsigned int word_offset; 206 unsigned long word_mask; 207 const unsigned long port_mask = GENMASK(gpio_reg_size - 1, 0); 208 unsigned long port_state; 209 void __iomem *ports[] = { 210 &idio24gpio->reg->out0_7, &idio24gpio->reg->out8_15, 211 &idio24gpio->reg->out16_23, &idio24gpio->reg->in0_7, 212 &idio24gpio->reg->in8_15, &idio24gpio->reg->in16_23, 213 }; 214 const unsigned long out_mode_mask = BIT(1); 215 216 /* clear bits array to a clean slate */ 217 bitmap_zero(bits, chip->ngpio); 218 219 /* get bits are evaluated a gpio port register at a time */ 220 for (i = 0; i < ARRAY_SIZE(ports) + 1; i++) { 221 /* gpio offset in bits array */ 222 bits_offset = i * gpio_reg_size; 223 224 /* word index for bits array */ 225 word_index = BIT_WORD(bits_offset); 226 227 /* gpio offset within current word of bits array */ 228 word_offset = bits_offset % BITS_PER_LONG; 229 230 /* mask of get bits for current gpio within current word */ 231 word_mask = mask[word_index] & (port_mask << word_offset); 232 if (!word_mask) { 233 /* no get bits in this port so skip to next one */ 234 continue; 235 } 236 237 /* read bits from current gpio port (port 6 is TTL GPIO) */ 238 if (i < 6) 239 port_state = ioread8(ports[i]); 240 else if (ioread8(&idio24gpio->reg->ctl) & out_mode_mask) 241 port_state = ioread8(&idio24gpio->reg->ttl_out0_7); 242 else 243 port_state = ioread8(&idio24gpio->reg->ttl_in0_7); 244 245 /* store acquired bits at respective bits array offset */ 246 bits[word_index] |= port_state << word_offset; 247 } 248 249 return 0; 250 } 251 252 static void idio_24_gpio_set(struct gpio_chip *chip, unsigned int offset, 253 int value) 254 { 255 struct idio_24_gpio *const idio24gpio = gpiochip_get_data(chip); 256 const unsigned long out_mode_mask = BIT(1); 257 void __iomem *base; 258 const unsigned int mask = BIT(offset % 8); 259 unsigned long flags; 260 unsigned int out_state; 261 262 /* Isolated Inputs */ 263 if (offset > 23 && offset < 48) 264 return; 265 266 /* TTL/CMOS Inputs */ 267 if (offset > 47 && !(ioread8(&idio24gpio->reg->ctl) & out_mode_mask)) 268 return; 269 270 /* TTL/CMOS Outputs */ 271 if (offset > 47) 272 base = &idio24gpio->reg->ttl_out0_7; 273 /* FET Outputs */ 274 else if (offset > 15) 275 base = &idio24gpio->reg->out16_23; 276 else if (offset > 7) 277 base = &idio24gpio->reg->out8_15; 278 else 279 base = &idio24gpio->reg->out0_7; 280 281 raw_spin_lock_irqsave(&idio24gpio->lock, flags); 282 283 if (value) 284 out_state = ioread8(base) | mask; 285 else 286 out_state = ioread8(base) & ~mask; 287 288 iowrite8(out_state, base); 289 290 raw_spin_unlock_irqrestore(&idio24gpio->lock, flags); 291 } 292 293 static void idio_24_gpio_set_multiple(struct gpio_chip *chip, 294 unsigned long *mask, unsigned long *bits) 295 { 296 struct idio_24_gpio *const idio24gpio = gpiochip_get_data(chip); 297 size_t i; 298 unsigned long bits_offset; 299 unsigned long gpio_mask; 300 const unsigned int gpio_reg_size = 8; 301 const unsigned long port_mask = GENMASK(gpio_reg_size, 0); 302 unsigned long flags; 303 unsigned int out_state; 304 void __iomem *ports[] = { 305 &idio24gpio->reg->out0_7, &idio24gpio->reg->out8_15, 306 &idio24gpio->reg->out16_23 307 }; 308 const unsigned long out_mode_mask = BIT(1); 309 const unsigned int ttl_offset = 48; 310 const size_t ttl_i = BIT_WORD(ttl_offset); 311 const unsigned int word_offset = ttl_offset % BITS_PER_LONG; 312 const unsigned long ttl_mask = (mask[ttl_i] >> word_offset) & port_mask; 313 const unsigned long ttl_bits = (bits[ttl_i] >> word_offset) & ttl_mask; 314 315 /* set bits are processed a gpio port register at a time */ 316 for (i = 0; i < ARRAY_SIZE(ports); i++) { 317 /* gpio offset in bits array */ 318 bits_offset = i * gpio_reg_size; 319 320 /* check if any set bits for current port */ 321 gpio_mask = (*mask >> bits_offset) & port_mask; 322 if (!gpio_mask) { 323 /* no set bits for this port so move on to next port */ 324 continue; 325 } 326 327 raw_spin_lock_irqsave(&idio24gpio->lock, flags); 328 329 /* process output lines */ 330 out_state = ioread8(ports[i]) & ~gpio_mask; 331 out_state |= (*bits >> bits_offset) & gpio_mask; 332 iowrite8(out_state, ports[i]); 333 334 raw_spin_unlock_irqrestore(&idio24gpio->lock, flags); 335 } 336 337 /* check if setting TTL lines and if they are in output mode */ 338 if (!ttl_mask || !(ioread8(&idio24gpio->reg->ctl) & out_mode_mask)) 339 return; 340 341 /* handle TTL output */ 342 raw_spin_lock_irqsave(&idio24gpio->lock, flags); 343 344 /* process output lines */ 345 out_state = ioread8(&idio24gpio->reg->ttl_out0_7) & ~ttl_mask; 346 out_state |= ttl_bits; 347 iowrite8(out_state, &idio24gpio->reg->ttl_out0_7); 348 349 raw_spin_unlock_irqrestore(&idio24gpio->lock, flags); 350 } 351 352 static void idio_24_irq_ack(struct irq_data *data) 353 { 354 } 355 356 static void idio_24_irq_mask(struct irq_data *data) 357 { 358 struct gpio_chip *const chip = irq_data_get_irq_chip_data(data); 359 struct idio_24_gpio *const idio24gpio = gpiochip_get_data(chip); 360 unsigned long flags; 361 const unsigned long bit_offset = irqd_to_hwirq(data) - 24; 362 unsigned char new_irq_mask; 363 const unsigned long bank_offset = bit_offset/8 * 8; 364 unsigned char cos_enable_state; 365 366 raw_spin_lock_irqsave(&idio24gpio->lock, flags); 367 368 idio24gpio->irq_mask &= BIT(bit_offset); 369 new_irq_mask = idio24gpio->irq_mask >> bank_offset; 370 371 if (!new_irq_mask) { 372 cos_enable_state = ioread8(&idio24gpio->reg->cos_enable); 373 374 /* Disable Rising Edge detection */ 375 cos_enable_state &= ~BIT(bank_offset); 376 /* Disable Falling Edge detection */ 377 cos_enable_state &= ~BIT(bank_offset + 4); 378 379 iowrite8(cos_enable_state, &idio24gpio->reg->cos_enable); 380 } 381 382 raw_spin_unlock_irqrestore(&idio24gpio->lock, flags); 383 } 384 385 static void idio_24_irq_unmask(struct irq_data *data) 386 { 387 struct gpio_chip *const chip = irq_data_get_irq_chip_data(data); 388 struct idio_24_gpio *const idio24gpio = gpiochip_get_data(chip); 389 unsigned long flags; 390 unsigned char prev_irq_mask; 391 const unsigned long bit_offset = irqd_to_hwirq(data) - 24; 392 const unsigned long bank_offset = bit_offset/8 * 8; 393 unsigned char cos_enable_state; 394 395 raw_spin_lock_irqsave(&idio24gpio->lock, flags); 396 397 prev_irq_mask = idio24gpio->irq_mask >> bank_offset; 398 idio24gpio->irq_mask |= BIT(bit_offset); 399 400 if (!prev_irq_mask) { 401 cos_enable_state = ioread8(&idio24gpio->reg->cos_enable); 402 403 /* Enable Rising Edge detection */ 404 cos_enable_state |= BIT(bank_offset); 405 /* Enable Falling Edge detection */ 406 cos_enable_state |= BIT(bank_offset + 4); 407 408 iowrite8(cos_enable_state, &idio24gpio->reg->cos_enable); 409 } 410 411 raw_spin_unlock_irqrestore(&idio24gpio->lock, flags); 412 } 413 414 static int idio_24_irq_set_type(struct irq_data *data, unsigned int flow_type) 415 { 416 /* The only valid irq types are none and both-edges */ 417 if (flow_type != IRQ_TYPE_NONE && 418 (flow_type & IRQ_TYPE_EDGE_BOTH) != IRQ_TYPE_EDGE_BOTH) 419 return -EINVAL; 420 421 return 0; 422 } 423 424 static struct irq_chip idio_24_irqchip = { 425 .name = "pcie-idio-24", 426 .irq_ack = idio_24_irq_ack, 427 .irq_mask = idio_24_irq_mask, 428 .irq_unmask = idio_24_irq_unmask, 429 .irq_set_type = idio_24_irq_set_type 430 }; 431 432 static irqreturn_t idio_24_irq_handler(int irq, void *dev_id) 433 { 434 struct idio_24_gpio *const idio24gpio = dev_id; 435 unsigned long irq_status; 436 struct gpio_chip *const chip = &idio24gpio->chip; 437 unsigned long irq_mask; 438 int gpio; 439 440 raw_spin_lock(&idio24gpio->lock); 441 442 /* Read Change-Of-State status */ 443 irq_status = ioread32(&idio24gpio->reg->cos0_7); 444 445 raw_spin_unlock(&idio24gpio->lock); 446 447 /* Make sure our device generated IRQ */ 448 if (!irq_status) 449 return IRQ_NONE; 450 451 /* Handle only unmasked IRQ */ 452 irq_mask = idio24gpio->irq_mask & irq_status; 453 454 for_each_set_bit(gpio, &irq_mask, chip->ngpio - 24) 455 generic_handle_irq(irq_find_mapping(chip->irq.domain, 456 gpio + 24)); 457 458 raw_spin_lock(&idio24gpio->lock); 459 460 /* Clear Change-Of-State status */ 461 iowrite32(irq_status, &idio24gpio->reg->cos0_7); 462 463 raw_spin_unlock(&idio24gpio->lock); 464 465 return IRQ_HANDLED; 466 } 467 468 #define IDIO_24_NGPIO 56 469 static const char *idio_24_names[IDIO_24_NGPIO] = { 470 "OUT0", "OUT1", "OUT2", "OUT3", "OUT4", "OUT5", "OUT6", "OUT7", 471 "OUT8", "OUT9", "OUT10", "OUT11", "OUT12", "OUT13", "OUT14", "OUT15", 472 "OUT16", "OUT17", "OUT18", "OUT19", "OUT20", "OUT21", "OUT22", "OUT23", 473 "IIN0", "IIN1", "IIN2", "IIN3", "IIN4", "IIN5", "IIN6", "IIN7", 474 "IIN8", "IIN9", "IIN10", "IIN11", "IIN12", "IIN13", "IIN14", "IIN15", 475 "IIN16", "IIN17", "IIN18", "IIN19", "IIN20", "IIN21", "IIN22", "IIN23", 476 "TTL0", "TTL1", "TTL2", "TTL3", "TTL4", "TTL5", "TTL6", "TTL7" 477 }; 478 479 static int idio_24_probe(struct pci_dev *pdev, const struct pci_device_id *id) 480 { 481 struct device *const dev = &pdev->dev; 482 struct idio_24_gpio *idio24gpio; 483 int err; 484 const size_t pci_bar_index = 2; 485 const char *const name = pci_name(pdev); 486 487 idio24gpio = devm_kzalloc(dev, sizeof(*idio24gpio), GFP_KERNEL); 488 if (!idio24gpio) 489 return -ENOMEM; 490 491 err = pcim_enable_device(pdev); 492 if (err) { 493 dev_err(dev, "Failed to enable PCI device (%d)\n", err); 494 return err; 495 } 496 497 err = pcim_iomap_regions(pdev, BIT(pci_bar_index), name); 498 if (err) { 499 dev_err(dev, "Unable to map PCI I/O addresses (%d)\n", err); 500 return err; 501 } 502 503 idio24gpio->reg = pcim_iomap_table(pdev)[pci_bar_index]; 504 505 idio24gpio->chip.label = name; 506 idio24gpio->chip.parent = dev; 507 idio24gpio->chip.owner = THIS_MODULE; 508 idio24gpio->chip.base = -1; 509 idio24gpio->chip.ngpio = IDIO_24_NGPIO; 510 idio24gpio->chip.names = idio_24_names; 511 idio24gpio->chip.get_direction = idio_24_gpio_get_direction; 512 idio24gpio->chip.direction_input = idio_24_gpio_direction_input; 513 idio24gpio->chip.direction_output = idio_24_gpio_direction_output; 514 idio24gpio->chip.get = idio_24_gpio_get; 515 idio24gpio->chip.get_multiple = idio_24_gpio_get_multiple; 516 idio24gpio->chip.set = idio_24_gpio_set; 517 idio24gpio->chip.set_multiple = idio_24_gpio_set_multiple; 518 519 raw_spin_lock_init(&idio24gpio->lock); 520 521 /* Software board reset */ 522 iowrite8(0, &idio24gpio->reg->soft_reset); 523 524 err = devm_gpiochip_add_data(dev, &idio24gpio->chip, idio24gpio); 525 if (err) { 526 dev_err(dev, "GPIO registering failed (%d)\n", err); 527 return err; 528 } 529 530 err = gpiochip_irqchip_add(&idio24gpio->chip, &idio_24_irqchip, 0, 531 handle_edge_irq, IRQ_TYPE_NONE); 532 if (err) { 533 dev_err(dev, "Could not add irqchip (%d)\n", err); 534 return err; 535 } 536 537 err = devm_request_irq(dev, pdev->irq, idio_24_irq_handler, IRQF_SHARED, 538 name, idio24gpio); 539 if (err) { 540 dev_err(dev, "IRQ handler registering failed (%d)\n", err); 541 return err; 542 } 543 544 return 0; 545 } 546 547 static const struct pci_device_id idio_24_pci_dev_id[] = { 548 { PCI_DEVICE(0x494F, 0x0FD0) }, { PCI_DEVICE(0x494F, 0x0BD0) }, 549 { PCI_DEVICE(0x494F, 0x07D0) }, { PCI_DEVICE(0x494F, 0x0FC0) }, 550 { 0 } 551 }; 552 MODULE_DEVICE_TABLE(pci, idio_24_pci_dev_id); 553 554 static struct pci_driver idio_24_driver = { 555 .name = "pcie-idio-24", 556 .id_table = idio_24_pci_dev_id, 557 .probe = idio_24_probe 558 }; 559 560 module_pci_driver(idio_24_driver); 561 562 MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>"); 563 MODULE_DESCRIPTION("ACCES PCIe-IDIO-24 GPIO driver"); 564 MODULE_LICENSE("GPL v2"); 565