1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2011 LAPIS Semiconductor Co., Ltd. 4 */ 5 #include <linux/bits.h> 6 #include <linux/gpio/driver.h> 7 #include <linux/interrupt.h> 8 #include <linux/irq.h> 9 #include <linux/kernel.h> 10 #include <linux/module.h> 11 #include <linux/pci.h> 12 #include <linux/slab.h> 13 14 #define PCH_EDGE_FALLING 0 15 #define PCH_EDGE_RISING 1 16 #define PCH_LEVEL_L 2 17 #define PCH_LEVEL_H 3 18 #define PCH_EDGE_BOTH 4 19 #define PCH_IM_MASK GENMASK(2, 0) 20 21 #define PCH_IRQ_BASE 24 22 23 struct pch_regs { 24 u32 ien; 25 u32 istatus; 26 u32 idisp; 27 u32 iclr; 28 u32 imask; 29 u32 imaskclr; 30 u32 po; 31 u32 pi; 32 u32 pm; 33 u32 im0; 34 u32 im1; 35 u32 reserved[3]; 36 u32 gpio_use_sel; 37 u32 reset; 38 }; 39 40 enum pch_type_t { 41 INTEL_EG20T_PCH, 42 OKISEMI_ML7223m_IOH, /* LAPIS Semiconductor ML7223 IOH PCIe Bus-m */ 43 OKISEMI_ML7223n_IOH /* LAPIS Semiconductor ML7223 IOH PCIe Bus-n */ 44 }; 45 46 /* Specifies number of GPIO PINS */ 47 static int gpio_pins[] = { 48 [INTEL_EG20T_PCH] = 12, 49 [OKISEMI_ML7223m_IOH] = 8, 50 [OKISEMI_ML7223n_IOH] = 8, 51 }; 52 53 /** 54 * struct pch_gpio_reg_data - The register store data. 55 * @ien_reg: To store contents of IEN register. 56 * @imask_reg: To store contents of IMASK register. 57 * @po_reg: To store contents of PO register. 58 * @pm_reg: To store contents of PM register. 59 * @im0_reg: To store contents of IM0 register. 60 * @im1_reg: To store contents of IM1 register. 61 * @gpio_use_sel_reg : To store contents of GPIO_USE_SEL register. 62 * (Only ML7223 Bus-n) 63 */ 64 struct pch_gpio_reg_data { 65 u32 ien_reg; 66 u32 imask_reg; 67 u32 po_reg; 68 u32 pm_reg; 69 u32 im0_reg; 70 u32 im1_reg; 71 u32 gpio_use_sel_reg; 72 }; 73 74 /** 75 * struct pch_gpio - GPIO private data structure. 76 * @base: PCI base address of Memory mapped I/O register. 77 * @reg: Memory mapped PCH GPIO register list. 78 * @dev: Pointer to device structure. 79 * @gpio: Data for GPIO infrastructure. 80 * @pch_gpio_reg: Memory mapped Register data is saved here 81 * when suspend. 82 * @lock: Used for register access protection 83 * @irq_base: Save base of IRQ number for interrupt 84 * @ioh: IOH ID 85 * @spinlock: Used for register access protection 86 */ 87 struct pch_gpio { 88 void __iomem *base; 89 struct pch_regs __iomem *reg; 90 struct device *dev; 91 struct gpio_chip gpio; 92 struct pch_gpio_reg_data pch_gpio_reg; 93 int irq_base; 94 enum pch_type_t ioh; 95 spinlock_t spinlock; 96 }; 97 98 static void pch_gpio_set(struct gpio_chip *gpio, unsigned nr, int val) 99 { 100 u32 reg_val; 101 struct pch_gpio *chip = gpiochip_get_data(gpio); 102 unsigned long flags; 103 104 spin_lock_irqsave(&chip->spinlock, flags); 105 reg_val = ioread32(&chip->reg->po); 106 if (val) 107 reg_val |= BIT(nr); 108 else 109 reg_val &= ~BIT(nr); 110 111 iowrite32(reg_val, &chip->reg->po); 112 spin_unlock_irqrestore(&chip->spinlock, flags); 113 } 114 115 static int pch_gpio_get(struct gpio_chip *gpio, unsigned nr) 116 { 117 struct pch_gpio *chip = gpiochip_get_data(gpio); 118 119 return !!(ioread32(&chip->reg->pi) & BIT(nr)); 120 } 121 122 static int pch_gpio_direction_output(struct gpio_chip *gpio, unsigned nr, 123 int val) 124 { 125 struct pch_gpio *chip = gpiochip_get_data(gpio); 126 u32 pm; 127 u32 reg_val; 128 unsigned long flags; 129 130 spin_lock_irqsave(&chip->spinlock, flags); 131 132 reg_val = ioread32(&chip->reg->po); 133 if (val) 134 reg_val |= BIT(nr); 135 else 136 reg_val &= ~BIT(nr); 137 iowrite32(reg_val, &chip->reg->po); 138 139 pm = ioread32(&chip->reg->pm); 140 pm &= BIT(gpio_pins[chip->ioh]) - 1; 141 pm |= BIT(nr); 142 iowrite32(pm, &chip->reg->pm); 143 144 spin_unlock_irqrestore(&chip->spinlock, flags); 145 146 return 0; 147 } 148 149 static int pch_gpio_direction_input(struct gpio_chip *gpio, unsigned nr) 150 { 151 struct pch_gpio *chip = gpiochip_get_data(gpio); 152 u32 pm; 153 unsigned long flags; 154 155 spin_lock_irqsave(&chip->spinlock, flags); 156 pm = ioread32(&chip->reg->pm); 157 pm &= BIT(gpio_pins[chip->ioh]) - 1; 158 pm &= ~BIT(nr); 159 iowrite32(pm, &chip->reg->pm); 160 spin_unlock_irqrestore(&chip->spinlock, flags); 161 162 return 0; 163 } 164 165 /* 166 * Save register configuration and disable interrupts. 167 */ 168 static void __maybe_unused pch_gpio_save_reg_conf(struct pch_gpio *chip) 169 { 170 chip->pch_gpio_reg.ien_reg = ioread32(&chip->reg->ien); 171 chip->pch_gpio_reg.imask_reg = ioread32(&chip->reg->imask); 172 chip->pch_gpio_reg.po_reg = ioread32(&chip->reg->po); 173 chip->pch_gpio_reg.pm_reg = ioread32(&chip->reg->pm); 174 chip->pch_gpio_reg.im0_reg = ioread32(&chip->reg->im0); 175 if (chip->ioh == INTEL_EG20T_PCH) 176 chip->pch_gpio_reg.im1_reg = ioread32(&chip->reg->im1); 177 if (chip->ioh == OKISEMI_ML7223n_IOH) 178 chip->pch_gpio_reg.gpio_use_sel_reg = ioread32(&chip->reg->gpio_use_sel); 179 } 180 181 /* 182 * This function restores the register configuration of the GPIO device. 183 */ 184 static void __maybe_unused pch_gpio_restore_reg_conf(struct pch_gpio *chip) 185 { 186 iowrite32(chip->pch_gpio_reg.ien_reg, &chip->reg->ien); 187 iowrite32(chip->pch_gpio_reg.imask_reg, &chip->reg->imask); 188 /* to store contents of PO register */ 189 iowrite32(chip->pch_gpio_reg.po_reg, &chip->reg->po); 190 /* to store contents of PM register */ 191 iowrite32(chip->pch_gpio_reg.pm_reg, &chip->reg->pm); 192 iowrite32(chip->pch_gpio_reg.im0_reg, &chip->reg->im0); 193 if (chip->ioh == INTEL_EG20T_PCH) 194 iowrite32(chip->pch_gpio_reg.im1_reg, &chip->reg->im1); 195 if (chip->ioh == OKISEMI_ML7223n_IOH) 196 iowrite32(chip->pch_gpio_reg.gpio_use_sel_reg, &chip->reg->gpio_use_sel); 197 } 198 199 static int pch_gpio_to_irq(struct gpio_chip *gpio, unsigned offset) 200 { 201 struct pch_gpio *chip = gpiochip_get_data(gpio); 202 return chip->irq_base + offset; 203 } 204 205 static void pch_gpio_setup(struct pch_gpio *chip) 206 { 207 struct gpio_chip *gpio = &chip->gpio; 208 209 gpio->label = dev_name(chip->dev); 210 gpio->parent = chip->dev; 211 gpio->owner = THIS_MODULE; 212 gpio->direction_input = pch_gpio_direction_input; 213 gpio->get = pch_gpio_get; 214 gpio->direction_output = pch_gpio_direction_output; 215 gpio->set = pch_gpio_set; 216 gpio->base = -1; 217 gpio->ngpio = gpio_pins[chip->ioh]; 218 gpio->can_sleep = false; 219 gpio->to_irq = pch_gpio_to_irq; 220 } 221 222 static int pch_irq_type(struct irq_data *d, unsigned int type) 223 { 224 struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d); 225 struct pch_gpio *chip = gc->private; 226 u32 im, im_pos, val; 227 u32 __iomem *im_reg; 228 unsigned long flags; 229 int ch, irq = d->irq; 230 231 ch = irq - chip->irq_base; 232 if (irq < chip->irq_base + 8) { 233 im_reg = &chip->reg->im0; 234 im_pos = ch - 0; 235 } else { 236 im_reg = &chip->reg->im1; 237 im_pos = ch - 8; 238 } 239 dev_dbg(chip->dev, "irq=%d type=%d ch=%d pos=%d\n", irq, type, ch, im_pos); 240 241 switch (type) { 242 case IRQ_TYPE_EDGE_RISING: 243 val = PCH_EDGE_RISING; 244 break; 245 case IRQ_TYPE_EDGE_FALLING: 246 val = PCH_EDGE_FALLING; 247 break; 248 case IRQ_TYPE_EDGE_BOTH: 249 val = PCH_EDGE_BOTH; 250 break; 251 case IRQ_TYPE_LEVEL_HIGH: 252 val = PCH_LEVEL_H; 253 break; 254 case IRQ_TYPE_LEVEL_LOW: 255 val = PCH_LEVEL_L; 256 break; 257 default: 258 return 0; 259 } 260 261 spin_lock_irqsave(&chip->spinlock, flags); 262 263 /* Set interrupt mode */ 264 im = ioread32(im_reg) & ~(PCH_IM_MASK << (im_pos * 4)); 265 iowrite32(im | (val << (im_pos * 4)), im_reg); 266 267 /* And the handler */ 268 if (type & IRQ_TYPE_LEVEL_MASK) 269 irq_set_handler_locked(d, handle_level_irq); 270 else if (type & IRQ_TYPE_EDGE_BOTH) 271 irq_set_handler_locked(d, handle_edge_irq); 272 273 spin_unlock_irqrestore(&chip->spinlock, flags); 274 return 0; 275 } 276 277 static void pch_irq_unmask(struct irq_data *d) 278 { 279 struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d); 280 struct pch_gpio *chip = gc->private; 281 282 iowrite32(BIT(d->irq - chip->irq_base), &chip->reg->imaskclr); 283 } 284 285 static void pch_irq_mask(struct irq_data *d) 286 { 287 struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d); 288 struct pch_gpio *chip = gc->private; 289 290 iowrite32(BIT(d->irq - chip->irq_base), &chip->reg->imask); 291 } 292 293 static void pch_irq_ack(struct irq_data *d) 294 { 295 struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d); 296 struct pch_gpio *chip = gc->private; 297 298 iowrite32(BIT(d->irq - chip->irq_base), &chip->reg->iclr); 299 } 300 301 static irqreturn_t pch_gpio_handler(int irq, void *dev_id) 302 { 303 struct pch_gpio *chip = dev_id; 304 unsigned long reg_val = ioread32(&chip->reg->istatus); 305 int i; 306 307 dev_dbg(chip->dev, "irq=%d status=0x%lx\n", irq, reg_val); 308 309 reg_val &= BIT(gpio_pins[chip->ioh]) - 1; 310 for_each_set_bit(i, ®_val, gpio_pins[chip->ioh]) 311 generic_handle_irq(chip->irq_base + i); 312 313 return IRQ_RETVAL(reg_val); 314 } 315 316 static int pch_gpio_alloc_generic_chip(struct pch_gpio *chip, 317 unsigned int irq_start, 318 unsigned int num) 319 { 320 struct irq_chip_generic *gc; 321 struct irq_chip_type *ct; 322 int rv; 323 324 gc = devm_irq_alloc_generic_chip(chip->dev, "pch_gpio", 1, irq_start, 325 chip->base, handle_simple_irq); 326 if (!gc) 327 return -ENOMEM; 328 329 gc->private = chip; 330 ct = gc->chip_types; 331 332 ct->chip.irq_ack = pch_irq_ack; 333 ct->chip.irq_mask = pch_irq_mask; 334 ct->chip.irq_unmask = pch_irq_unmask; 335 ct->chip.irq_set_type = pch_irq_type; 336 337 rv = devm_irq_setup_generic_chip(chip->dev, gc, IRQ_MSK(num), 338 IRQ_GC_INIT_MASK_CACHE, 339 IRQ_NOREQUEST | IRQ_NOPROBE, 0); 340 341 return rv; 342 } 343 344 static int pch_gpio_probe(struct pci_dev *pdev, 345 const struct pci_device_id *id) 346 { 347 s32 ret; 348 struct pch_gpio *chip; 349 int irq_base; 350 351 chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL); 352 if (chip == NULL) 353 return -ENOMEM; 354 355 chip->dev = &pdev->dev; 356 ret = pcim_enable_device(pdev); 357 if (ret) { 358 dev_err(&pdev->dev, "pci_enable_device FAILED"); 359 return ret; 360 } 361 362 ret = pcim_iomap_regions(pdev, BIT(1), KBUILD_MODNAME); 363 if (ret) { 364 dev_err(&pdev->dev, "pci_request_regions FAILED-%d", ret); 365 return ret; 366 } 367 368 chip->base = pcim_iomap_table(pdev)[1]; 369 370 if (pdev->device == 0x8803) 371 chip->ioh = INTEL_EG20T_PCH; 372 else if (pdev->device == 0x8014) 373 chip->ioh = OKISEMI_ML7223m_IOH; 374 else if (pdev->device == 0x8043) 375 chip->ioh = OKISEMI_ML7223n_IOH; 376 377 chip->reg = chip->base; 378 pci_set_drvdata(pdev, chip); 379 spin_lock_init(&chip->spinlock); 380 pch_gpio_setup(chip); 381 382 ret = devm_gpiochip_add_data(&pdev->dev, &chip->gpio, chip); 383 if (ret) { 384 dev_err(&pdev->dev, "PCH gpio: Failed to register GPIO\n"); 385 return ret; 386 } 387 388 irq_base = devm_irq_alloc_descs(&pdev->dev, -1, 0, 389 gpio_pins[chip->ioh], NUMA_NO_NODE); 390 if (irq_base < 0) { 391 dev_warn(&pdev->dev, "PCH gpio: Failed to get IRQ base num\n"); 392 chip->irq_base = -1; 393 return 0; 394 } 395 chip->irq_base = irq_base; 396 397 /* Mask all interrupts, but enable them */ 398 iowrite32(BIT(gpio_pins[chip->ioh]) - 1, &chip->reg->imask); 399 iowrite32(BIT(gpio_pins[chip->ioh]) - 1, &chip->reg->ien); 400 401 ret = devm_request_irq(&pdev->dev, pdev->irq, pch_gpio_handler, 402 IRQF_SHARED, KBUILD_MODNAME, chip); 403 if (ret) { 404 dev_err(&pdev->dev, "request_irq failed\n"); 405 return ret; 406 } 407 408 return pch_gpio_alloc_generic_chip(chip, irq_base, gpio_pins[chip->ioh]); 409 } 410 411 static int __maybe_unused pch_gpio_suspend(struct device *dev) 412 { 413 struct pch_gpio *chip = dev_get_drvdata(dev); 414 unsigned long flags; 415 416 spin_lock_irqsave(&chip->spinlock, flags); 417 pch_gpio_save_reg_conf(chip); 418 spin_unlock_irqrestore(&chip->spinlock, flags); 419 420 return 0; 421 } 422 423 static int __maybe_unused pch_gpio_resume(struct device *dev) 424 { 425 struct pch_gpio *chip = dev_get_drvdata(dev); 426 unsigned long flags; 427 428 spin_lock_irqsave(&chip->spinlock, flags); 429 iowrite32(0x01, &chip->reg->reset); 430 iowrite32(0x00, &chip->reg->reset); 431 pch_gpio_restore_reg_conf(chip); 432 spin_unlock_irqrestore(&chip->spinlock, flags); 433 434 return 0; 435 } 436 437 static SIMPLE_DEV_PM_OPS(pch_gpio_pm_ops, pch_gpio_suspend, pch_gpio_resume); 438 439 static const struct pci_device_id pch_gpio_pcidev_id[] = { 440 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x8803) }, 441 { PCI_DEVICE(PCI_VENDOR_ID_ROHM, 0x8014) }, 442 { PCI_DEVICE(PCI_VENDOR_ID_ROHM, 0x8043) }, 443 { PCI_DEVICE(PCI_VENDOR_ID_ROHM, 0x8803) }, 444 { 0, } 445 }; 446 MODULE_DEVICE_TABLE(pci, pch_gpio_pcidev_id); 447 448 static struct pci_driver pch_gpio_driver = { 449 .name = "pch_gpio", 450 .id_table = pch_gpio_pcidev_id, 451 .probe = pch_gpio_probe, 452 .driver = { 453 .pm = &pch_gpio_pm_ops, 454 }, 455 }; 456 457 module_pci_driver(pch_gpio_driver); 458 459 MODULE_DESCRIPTION("PCH GPIO PCI Driver"); 460 MODULE_LICENSE("GPL v2"); 461