1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2003-2015 Broadcom Corporation 4 * All Rights Reserved 5 */ 6 7 #include <linux/gpio/driver.h> 8 #include <linux/platform_device.h> 9 #include <linux/of_device.h> 10 #include <linux/module.h> 11 #include <linux/irq.h> 12 #include <linux/interrupt.h> 13 #include <linux/irqchip/chained_irq.h> 14 #include <linux/acpi.h> 15 16 /* 17 * XLP GPIO has multiple 32 bit registers for each feature where each register 18 * controls 32 pins. So, pins up to 64 require 2 32-bit registers and up to 96 19 * require 3 32-bit registers for each feature. 20 * Here we only define offset of the first register for each feature. Offset of 21 * the registers for pins greater than 32 can be calculated as following(Use 22 * GPIO_INT_STAT as example): 23 * 24 * offset = (gpio / XLP_GPIO_REGSZ) * 4; 25 * reg_addr = addr + offset; 26 * 27 * where addr is base address of the that feature register and gpio is the pin. 28 */ 29 #define GPIO_OUTPUT_EN 0x00 30 #define GPIO_PADDRV 0x08 31 #define GPIO_INT_EN00 0x18 32 #define GPIO_INT_EN10 0x20 33 #define GPIO_INT_EN20 0x28 34 #define GPIO_INT_EN30 0x30 35 #define GPIO_INT_POL 0x38 36 #define GPIO_INT_TYPE 0x40 37 #define GPIO_INT_STAT 0x48 38 39 #define GPIO_9XX_BYTESWAP 0X00 40 #define GPIO_9XX_CTRL 0X04 41 #define GPIO_9XX_OUTPUT_EN 0x14 42 #define GPIO_9XX_PADDRV 0x24 43 /* 44 * Only for 4 interrupt enable reg are defined for now, 45 * total reg available are 12. 46 */ 47 #define GPIO_9XX_INT_EN00 0x44 48 #define GPIO_9XX_INT_EN10 0x54 49 #define GPIO_9XX_INT_EN20 0x64 50 #define GPIO_9XX_INT_EN30 0x74 51 #define GPIO_9XX_INT_POL 0x104 52 #define GPIO_9XX_INT_TYPE 0x114 53 #define GPIO_9XX_INT_STAT 0x124 54 55 #define GPIO_3XX_INT_EN00 0x18 56 #define GPIO_3XX_INT_EN10 0x20 57 #define GPIO_3XX_INT_EN20 0x28 58 #define GPIO_3XX_INT_EN30 0x30 59 #define GPIO_3XX_INT_POL 0x78 60 #define GPIO_3XX_INT_TYPE 0x80 61 #define GPIO_3XX_INT_STAT 0x88 62 63 /* Interrupt type register mask */ 64 #define XLP_GPIO_IRQ_TYPE_LVL 0x0 65 #define XLP_GPIO_IRQ_TYPE_EDGE 0x1 66 67 /* Interrupt polarity register mask */ 68 #define XLP_GPIO_IRQ_POL_HIGH 0x0 69 #define XLP_GPIO_IRQ_POL_LOW 0x1 70 71 #define XLP_GPIO_REGSZ 32 72 #define XLP_GPIO_IRQ_BASE 768 73 #define XLP_MAX_NR_GPIO 96 74 75 /* XLP variants supported by this driver */ 76 enum { 77 XLP_GPIO_VARIANT_XLP832 = 1, 78 XLP_GPIO_VARIANT_XLP316, 79 XLP_GPIO_VARIANT_XLP208, 80 XLP_GPIO_VARIANT_XLP980, 81 XLP_GPIO_VARIANT_XLP532, 82 GPIO_VARIANT_VULCAN 83 }; 84 85 struct xlp_gpio_priv { 86 struct gpio_chip chip; 87 DECLARE_BITMAP(gpio_enabled_mask, XLP_MAX_NR_GPIO); 88 void __iomem *gpio_intr_en; /* pointer to first intr enable reg */ 89 void __iomem *gpio_intr_stat; /* pointer to first intr status reg */ 90 void __iomem *gpio_intr_type; /* pointer to first intr type reg */ 91 void __iomem *gpio_intr_pol; /* pointer to first intr polarity reg */ 92 void __iomem *gpio_out_en; /* pointer to first output enable reg */ 93 void __iomem *gpio_paddrv; /* pointer to first pad drive reg */ 94 spinlock_t lock; 95 }; 96 97 static int xlp_gpio_get_reg(void __iomem *addr, unsigned gpio) 98 { 99 u32 pos, regset; 100 101 pos = gpio % XLP_GPIO_REGSZ; 102 regset = (gpio / XLP_GPIO_REGSZ) * 4; 103 return !!(readl(addr + regset) & BIT(pos)); 104 } 105 106 static void xlp_gpio_set_reg(void __iomem *addr, unsigned gpio, int state) 107 { 108 u32 value, pos, regset; 109 110 pos = gpio % XLP_GPIO_REGSZ; 111 regset = (gpio / XLP_GPIO_REGSZ) * 4; 112 value = readl(addr + regset); 113 114 if (state) 115 value |= BIT(pos); 116 else 117 value &= ~BIT(pos); 118 119 writel(value, addr + regset); 120 } 121 122 static void xlp_gpio_irq_disable(struct irq_data *d) 123 { 124 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 125 struct xlp_gpio_priv *priv = gpiochip_get_data(gc); 126 unsigned long flags; 127 128 spin_lock_irqsave(&priv->lock, flags); 129 xlp_gpio_set_reg(priv->gpio_intr_en, d->hwirq, 0x0); 130 __clear_bit(d->hwirq, priv->gpio_enabled_mask); 131 spin_unlock_irqrestore(&priv->lock, flags); 132 } 133 134 static void xlp_gpio_irq_mask_ack(struct irq_data *d) 135 { 136 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 137 struct xlp_gpio_priv *priv = gpiochip_get_data(gc); 138 unsigned long flags; 139 140 spin_lock_irqsave(&priv->lock, flags); 141 xlp_gpio_set_reg(priv->gpio_intr_en, d->hwirq, 0x0); 142 xlp_gpio_set_reg(priv->gpio_intr_stat, d->hwirq, 0x1); 143 __clear_bit(d->hwirq, priv->gpio_enabled_mask); 144 spin_unlock_irqrestore(&priv->lock, flags); 145 } 146 147 static void xlp_gpio_irq_unmask(struct irq_data *d) 148 { 149 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 150 struct xlp_gpio_priv *priv = gpiochip_get_data(gc); 151 unsigned long flags; 152 153 spin_lock_irqsave(&priv->lock, flags); 154 xlp_gpio_set_reg(priv->gpio_intr_en, d->hwirq, 0x1); 155 __set_bit(d->hwirq, priv->gpio_enabled_mask); 156 spin_unlock_irqrestore(&priv->lock, flags); 157 } 158 159 static int xlp_gpio_set_irq_type(struct irq_data *d, unsigned int type) 160 { 161 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 162 struct xlp_gpio_priv *priv = gpiochip_get_data(gc); 163 int pol, irq_type; 164 165 switch (type) { 166 case IRQ_TYPE_EDGE_RISING: 167 irq_type = XLP_GPIO_IRQ_TYPE_EDGE; 168 pol = XLP_GPIO_IRQ_POL_HIGH; 169 break; 170 case IRQ_TYPE_EDGE_FALLING: 171 irq_type = XLP_GPIO_IRQ_TYPE_EDGE; 172 pol = XLP_GPIO_IRQ_POL_LOW; 173 break; 174 case IRQ_TYPE_LEVEL_HIGH: 175 irq_type = XLP_GPIO_IRQ_TYPE_LVL; 176 pol = XLP_GPIO_IRQ_POL_HIGH; 177 break; 178 case IRQ_TYPE_LEVEL_LOW: 179 irq_type = XLP_GPIO_IRQ_TYPE_LVL; 180 pol = XLP_GPIO_IRQ_POL_LOW; 181 break; 182 default: 183 return -EINVAL; 184 } 185 186 xlp_gpio_set_reg(priv->gpio_intr_type, d->hwirq, irq_type); 187 xlp_gpio_set_reg(priv->gpio_intr_pol, d->hwirq, pol); 188 189 return 0; 190 } 191 192 static struct irq_chip xlp_gpio_irq_chip = { 193 .name = "XLP-GPIO", 194 .irq_mask_ack = xlp_gpio_irq_mask_ack, 195 .irq_disable = xlp_gpio_irq_disable, 196 .irq_set_type = xlp_gpio_set_irq_type, 197 .irq_unmask = xlp_gpio_irq_unmask, 198 .flags = IRQCHIP_ONESHOT_SAFE, 199 }; 200 201 static void xlp_gpio_generic_handler(struct irq_desc *desc) 202 { 203 struct xlp_gpio_priv *priv = irq_desc_get_handler_data(desc); 204 struct irq_chip *irqchip = irq_desc_get_chip(desc); 205 int gpio, regoff; 206 u32 gpio_stat; 207 208 regoff = -1; 209 gpio_stat = 0; 210 211 chained_irq_enter(irqchip, desc); 212 for_each_set_bit(gpio, priv->gpio_enabled_mask, XLP_MAX_NR_GPIO) { 213 if (regoff != gpio / XLP_GPIO_REGSZ) { 214 regoff = gpio / XLP_GPIO_REGSZ; 215 gpio_stat = readl(priv->gpio_intr_stat + regoff * 4); 216 } 217 218 if (gpio_stat & BIT(gpio % XLP_GPIO_REGSZ)) 219 generic_handle_domain_irq(priv->chip.irq.domain, gpio); 220 } 221 chained_irq_exit(irqchip, desc); 222 } 223 224 static int xlp_gpio_dir_output(struct gpio_chip *gc, unsigned gpio, int state) 225 { 226 struct xlp_gpio_priv *priv = gpiochip_get_data(gc); 227 228 BUG_ON(gpio >= gc->ngpio); 229 xlp_gpio_set_reg(priv->gpio_out_en, gpio, 0x1); 230 231 return 0; 232 } 233 234 static int xlp_gpio_dir_input(struct gpio_chip *gc, unsigned gpio) 235 { 236 struct xlp_gpio_priv *priv = gpiochip_get_data(gc); 237 238 BUG_ON(gpio >= gc->ngpio); 239 xlp_gpio_set_reg(priv->gpio_out_en, gpio, 0x0); 240 241 return 0; 242 } 243 244 static int xlp_gpio_get(struct gpio_chip *gc, unsigned gpio) 245 { 246 struct xlp_gpio_priv *priv = gpiochip_get_data(gc); 247 248 BUG_ON(gpio >= gc->ngpio); 249 return xlp_gpio_get_reg(priv->gpio_paddrv, gpio); 250 } 251 252 static void xlp_gpio_set(struct gpio_chip *gc, unsigned gpio, int state) 253 { 254 struct xlp_gpio_priv *priv = gpiochip_get_data(gc); 255 256 BUG_ON(gpio >= gc->ngpio); 257 xlp_gpio_set_reg(priv->gpio_paddrv, gpio, state); 258 } 259 260 static const struct of_device_id xlp_gpio_of_ids[] = { 261 { 262 .compatible = "netlogic,xlp832-gpio", 263 .data = (void *)XLP_GPIO_VARIANT_XLP832, 264 }, 265 { 266 .compatible = "netlogic,xlp316-gpio", 267 .data = (void *)XLP_GPIO_VARIANT_XLP316, 268 }, 269 { 270 .compatible = "netlogic,xlp208-gpio", 271 .data = (void *)XLP_GPIO_VARIANT_XLP208, 272 }, 273 { 274 .compatible = "netlogic,xlp980-gpio", 275 .data = (void *)XLP_GPIO_VARIANT_XLP980, 276 }, 277 { 278 .compatible = "netlogic,xlp532-gpio", 279 .data = (void *)XLP_GPIO_VARIANT_XLP532, 280 }, 281 { 282 .compatible = "brcm,vulcan-gpio", 283 .data = (void *)GPIO_VARIANT_VULCAN, 284 }, 285 { /* sentinel */ }, 286 }; 287 MODULE_DEVICE_TABLE(of, xlp_gpio_of_ids); 288 289 static int xlp_gpio_probe(struct platform_device *pdev) 290 { 291 struct gpio_chip *gc; 292 struct gpio_irq_chip *girq; 293 struct xlp_gpio_priv *priv; 294 void __iomem *gpio_base; 295 int irq_base, irq, err; 296 int ngpio; 297 u32 soc_type; 298 299 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 300 if (!priv) 301 return -ENOMEM; 302 303 gpio_base = devm_platform_ioremap_resource(pdev, 0); 304 if (IS_ERR(gpio_base)) 305 return PTR_ERR(gpio_base); 306 307 irq = platform_get_irq(pdev, 0); 308 if (irq < 0) 309 return irq; 310 311 if (pdev->dev.of_node) { 312 soc_type = (uintptr_t)of_device_get_match_data(&pdev->dev); 313 } else { 314 const struct acpi_device_id *acpi_id; 315 316 acpi_id = acpi_match_device(pdev->dev.driver->acpi_match_table, 317 &pdev->dev); 318 if (!acpi_id || !acpi_id->driver_data) { 319 dev_err(&pdev->dev, "Unable to match ACPI ID\n"); 320 return -ENODEV; 321 } 322 soc_type = (uintptr_t) acpi_id->driver_data; 323 } 324 325 switch (soc_type) { 326 case XLP_GPIO_VARIANT_XLP832: 327 priv->gpio_out_en = gpio_base + GPIO_OUTPUT_EN; 328 priv->gpio_paddrv = gpio_base + GPIO_PADDRV; 329 priv->gpio_intr_stat = gpio_base + GPIO_INT_STAT; 330 priv->gpio_intr_type = gpio_base + GPIO_INT_TYPE; 331 priv->gpio_intr_pol = gpio_base + GPIO_INT_POL; 332 priv->gpio_intr_en = gpio_base + GPIO_INT_EN00; 333 ngpio = 41; 334 break; 335 case XLP_GPIO_VARIANT_XLP208: 336 case XLP_GPIO_VARIANT_XLP316: 337 priv->gpio_out_en = gpio_base + GPIO_OUTPUT_EN; 338 priv->gpio_paddrv = gpio_base + GPIO_PADDRV; 339 priv->gpio_intr_stat = gpio_base + GPIO_3XX_INT_STAT; 340 priv->gpio_intr_type = gpio_base + GPIO_3XX_INT_TYPE; 341 priv->gpio_intr_pol = gpio_base + GPIO_3XX_INT_POL; 342 priv->gpio_intr_en = gpio_base + GPIO_3XX_INT_EN00; 343 344 ngpio = (soc_type == XLP_GPIO_VARIANT_XLP208) ? 42 : 57; 345 break; 346 case XLP_GPIO_VARIANT_XLP980: 347 case XLP_GPIO_VARIANT_XLP532: 348 case GPIO_VARIANT_VULCAN: 349 priv->gpio_out_en = gpio_base + GPIO_9XX_OUTPUT_EN; 350 priv->gpio_paddrv = gpio_base + GPIO_9XX_PADDRV; 351 priv->gpio_intr_stat = gpio_base + GPIO_9XX_INT_STAT; 352 priv->gpio_intr_type = gpio_base + GPIO_9XX_INT_TYPE; 353 priv->gpio_intr_pol = gpio_base + GPIO_9XX_INT_POL; 354 priv->gpio_intr_en = gpio_base + GPIO_9XX_INT_EN00; 355 356 if (soc_type == XLP_GPIO_VARIANT_XLP980) 357 ngpio = 66; 358 else if (soc_type == XLP_GPIO_VARIANT_XLP532) 359 ngpio = 67; 360 else 361 ngpio = 70; 362 break; 363 default: 364 dev_err(&pdev->dev, "Unknown Processor type!\n"); 365 return -ENODEV; 366 } 367 368 bitmap_zero(priv->gpio_enabled_mask, XLP_MAX_NR_GPIO); 369 370 gc = &priv->chip; 371 372 gc->owner = THIS_MODULE; 373 gc->label = dev_name(&pdev->dev); 374 gc->base = 0; 375 gc->parent = &pdev->dev; 376 gc->ngpio = ngpio; 377 gc->of_node = pdev->dev.of_node; 378 gc->direction_output = xlp_gpio_dir_output; 379 gc->direction_input = xlp_gpio_dir_input; 380 gc->set = xlp_gpio_set; 381 gc->get = xlp_gpio_get; 382 383 spin_lock_init(&priv->lock); 384 385 /* XLP(MIPS) has fixed range for GPIO IRQs, Vulcan(ARM64) does not */ 386 if (soc_type != GPIO_VARIANT_VULCAN) { 387 irq_base = devm_irq_alloc_descs(&pdev->dev, -1, 388 XLP_GPIO_IRQ_BASE, 389 gc->ngpio, 0); 390 if (irq_base < 0) { 391 dev_err(&pdev->dev, "Failed to allocate IRQ numbers\n"); 392 return irq_base; 393 } 394 } else { 395 irq_base = 0; 396 } 397 398 girq = &gc->irq; 399 girq->chip = &xlp_gpio_irq_chip; 400 girq->parent_handler = xlp_gpio_generic_handler; 401 girq->num_parents = 1; 402 girq->parents = devm_kcalloc(&pdev->dev, 1, 403 sizeof(*girq->parents), 404 GFP_KERNEL); 405 if (!girq->parents) 406 return -ENOMEM; 407 girq->parents[0] = irq; 408 girq->first = irq_base; 409 girq->default_type = IRQ_TYPE_NONE; 410 girq->handler = handle_level_irq; 411 412 err = gpiochip_add_data(gc, priv); 413 if (err < 0) 414 return err; 415 416 dev_info(&pdev->dev, "registered %d GPIOs\n", gc->ngpio); 417 418 return 0; 419 } 420 421 #ifdef CONFIG_ACPI 422 static const struct acpi_device_id xlp_gpio_acpi_match[] = { 423 { "BRCM9006", GPIO_VARIANT_VULCAN }, 424 { "CAV9006", GPIO_VARIANT_VULCAN }, 425 {}, 426 }; 427 MODULE_DEVICE_TABLE(acpi, xlp_gpio_acpi_match); 428 #endif 429 430 static struct platform_driver xlp_gpio_driver = { 431 .driver = { 432 .name = "xlp-gpio", 433 .of_match_table = xlp_gpio_of_ids, 434 .acpi_match_table = ACPI_PTR(xlp_gpio_acpi_match), 435 }, 436 .probe = xlp_gpio_probe, 437 }; 438 module_platform_driver(xlp_gpio_driver); 439 440 MODULE_AUTHOR("Kamlakant Patel <kamlakant.patel@broadcom.com>"); 441 MODULE_AUTHOR("Ganesan Ramalingam <ganesanr@broadcom.com>"); 442 MODULE_DESCRIPTION("Netlogic XLP GPIO Driver"); 443 MODULE_LICENSE("GPL v2"); 444