1 /* 2 * Copyright (C) 2015 Broadcom Corporation 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License as 6 * published by the Free Software Foundation version 2. 7 * 8 * This program is distributed "as is" WITHOUT ANY WARRANTY of any 9 * kind, whether express or implied; without even the implied warranty 10 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 */ 13 14 #include <linux/bitops.h> 15 #include <linux/gpio/driver.h> 16 #include <linux/of_device.h> 17 #include <linux/of_irq.h> 18 #include <linux/module.h> 19 #include <linux/irqdomain.h> 20 #include <linux/irqchip/chained_irq.h> 21 #include <linux/interrupt.h> 22 #include <linux/reboot.h> 23 24 #define GIO_BANK_SIZE 0x20 25 #define GIO_ODEN(bank) (((bank) * GIO_BANK_SIZE) + 0x00) 26 #define GIO_DATA(bank) (((bank) * GIO_BANK_SIZE) + 0x04) 27 #define GIO_IODIR(bank) (((bank) * GIO_BANK_SIZE) + 0x08) 28 #define GIO_EC(bank) (((bank) * GIO_BANK_SIZE) + 0x0c) 29 #define GIO_EI(bank) (((bank) * GIO_BANK_SIZE) + 0x10) 30 #define GIO_MASK(bank) (((bank) * GIO_BANK_SIZE) + 0x14) 31 #define GIO_LEVEL(bank) (((bank) * GIO_BANK_SIZE) + 0x18) 32 #define GIO_STAT(bank) (((bank) * GIO_BANK_SIZE) + 0x1c) 33 34 struct brcmstb_gpio_bank { 35 struct list_head node; 36 int id; 37 struct gpio_chip gc; 38 struct brcmstb_gpio_priv *parent_priv; 39 u32 width; 40 struct irq_chip irq_chip; 41 }; 42 43 struct brcmstb_gpio_priv { 44 struct list_head bank_list; 45 void __iomem *reg_base; 46 struct platform_device *pdev; 47 int parent_irq; 48 int gpio_base; 49 bool can_wake; 50 int parent_wake_irq; 51 struct notifier_block reboot_notifier; 52 }; 53 54 #define MAX_GPIO_PER_BANK 32 55 #define GPIO_BANK(gpio) ((gpio) >> 5) 56 /* assumes MAX_GPIO_PER_BANK is a multiple of 2 */ 57 #define GPIO_BIT(gpio) ((gpio) & (MAX_GPIO_PER_BANK - 1)) 58 59 static inline struct brcmstb_gpio_priv * 60 brcmstb_gpio_gc_to_priv(struct gpio_chip *gc) 61 { 62 struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc); 63 return bank->parent_priv; 64 } 65 66 static void brcmstb_gpio_set_imask(struct brcmstb_gpio_bank *bank, 67 unsigned int offset, bool enable) 68 { 69 struct gpio_chip *gc = &bank->gc; 70 struct brcmstb_gpio_priv *priv = bank->parent_priv; 71 u32 mask = gc->pin2mask(gc, offset); 72 u32 imask; 73 unsigned long flags; 74 75 spin_lock_irqsave(&gc->bgpio_lock, flags); 76 imask = gc->read_reg(priv->reg_base + GIO_MASK(bank->id)); 77 if (enable) 78 imask |= mask; 79 else 80 imask &= ~mask; 81 gc->write_reg(priv->reg_base + GIO_MASK(bank->id), imask); 82 spin_unlock_irqrestore(&gc->bgpio_lock, flags); 83 } 84 85 /* -------------------- IRQ chip functions -------------------- */ 86 87 static void brcmstb_gpio_irq_mask(struct irq_data *d) 88 { 89 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 90 struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc); 91 92 brcmstb_gpio_set_imask(bank, d->hwirq, false); 93 } 94 95 static void brcmstb_gpio_irq_unmask(struct irq_data *d) 96 { 97 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 98 struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc); 99 100 brcmstb_gpio_set_imask(bank, d->hwirq, true); 101 } 102 103 static int brcmstb_gpio_irq_set_type(struct irq_data *d, unsigned int type) 104 { 105 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 106 struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc); 107 struct brcmstb_gpio_priv *priv = bank->parent_priv; 108 u32 mask = BIT(d->hwirq); 109 u32 edge_insensitive, iedge_insensitive; 110 u32 edge_config, iedge_config; 111 u32 level, ilevel; 112 unsigned long flags; 113 114 switch (type) { 115 case IRQ_TYPE_LEVEL_LOW: 116 level = 0; 117 edge_config = 0; 118 edge_insensitive = 0; 119 break; 120 case IRQ_TYPE_LEVEL_HIGH: 121 level = mask; 122 edge_config = 0; 123 edge_insensitive = 0; 124 break; 125 case IRQ_TYPE_EDGE_FALLING: 126 level = 0; 127 edge_config = 0; 128 edge_insensitive = 0; 129 break; 130 case IRQ_TYPE_EDGE_RISING: 131 level = 0; 132 edge_config = mask; 133 edge_insensitive = 0; 134 break; 135 case IRQ_TYPE_EDGE_BOTH: 136 level = 0; 137 edge_config = 0; /* don't care, but want known value */ 138 edge_insensitive = mask; 139 break; 140 default: 141 return -EINVAL; 142 } 143 144 spin_lock_irqsave(&bank->gc.bgpio_lock, flags); 145 146 iedge_config = bank->gc.read_reg(priv->reg_base + 147 GIO_EC(bank->id)) & ~mask; 148 iedge_insensitive = bank->gc.read_reg(priv->reg_base + 149 GIO_EI(bank->id)) & ~mask; 150 ilevel = bank->gc.read_reg(priv->reg_base + 151 GIO_LEVEL(bank->id)) & ~mask; 152 153 bank->gc.write_reg(priv->reg_base + GIO_EC(bank->id), 154 iedge_config | edge_config); 155 bank->gc.write_reg(priv->reg_base + GIO_EI(bank->id), 156 iedge_insensitive | edge_insensitive); 157 bank->gc.write_reg(priv->reg_base + GIO_LEVEL(bank->id), 158 ilevel | level); 159 160 spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags); 161 return 0; 162 } 163 164 static int brcmstb_gpio_priv_set_wake(struct brcmstb_gpio_priv *priv, 165 unsigned int enable) 166 { 167 int ret = 0; 168 169 /* 170 * Only enable wake IRQ once for however many hwirqs can wake 171 * since they all use the same wake IRQ. Mask will be set 172 * up appropriately thanks to IRQCHIP_MASK_ON_SUSPEND flag. 173 */ 174 if (enable) 175 ret = enable_irq_wake(priv->parent_wake_irq); 176 else 177 ret = disable_irq_wake(priv->parent_wake_irq); 178 if (ret) 179 dev_err(&priv->pdev->dev, "failed to %s wake-up interrupt\n", 180 enable ? "enable" : "disable"); 181 return ret; 182 } 183 184 static int brcmstb_gpio_irq_set_wake(struct irq_data *d, unsigned int enable) 185 { 186 struct gpio_chip *gc = irq_data_get_irq_chip_data(d); 187 struct brcmstb_gpio_priv *priv = brcmstb_gpio_gc_to_priv(gc); 188 189 return brcmstb_gpio_priv_set_wake(priv, enable); 190 } 191 192 static irqreturn_t brcmstb_gpio_wake_irq_handler(int irq, void *data) 193 { 194 struct brcmstb_gpio_priv *priv = data; 195 196 if (!priv || irq != priv->parent_wake_irq) 197 return IRQ_NONE; 198 pm_wakeup_event(&priv->pdev->dev, 0); 199 return IRQ_HANDLED; 200 } 201 202 static void brcmstb_gpio_irq_bank_handler(struct brcmstb_gpio_bank *bank) 203 { 204 struct brcmstb_gpio_priv *priv = bank->parent_priv; 205 struct irq_domain *irq_domain = bank->gc.irqdomain; 206 void __iomem *reg_base = priv->reg_base; 207 unsigned long status; 208 unsigned long flags; 209 210 spin_lock_irqsave(&bank->gc.bgpio_lock, flags); 211 while ((status = bank->gc.read_reg(reg_base + GIO_STAT(bank->id)) & 212 bank->gc.read_reg(reg_base + GIO_MASK(bank->id)))) { 213 int bit; 214 215 for_each_set_bit(bit, &status, 32) { 216 u32 stat = bank->gc.read_reg(reg_base + 217 GIO_STAT(bank->id)); 218 if (bit >= bank->width) 219 dev_warn(&priv->pdev->dev, 220 "IRQ for invalid GPIO (bank=%d, offset=%d)\n", 221 bank->id, bit); 222 bank->gc.write_reg(reg_base + GIO_STAT(bank->id), 223 stat | BIT(bit)); 224 generic_handle_irq(irq_find_mapping(irq_domain, bit)); 225 } 226 } 227 spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags); 228 } 229 230 /* Each UPG GIO block has one IRQ for all banks */ 231 static void brcmstb_gpio_irq_handler(struct irq_desc *desc) 232 { 233 struct gpio_chip *gc = irq_desc_get_handler_data(desc); 234 struct brcmstb_gpio_priv *priv = brcmstb_gpio_gc_to_priv(gc); 235 struct irq_chip *chip = irq_desc_get_chip(desc); 236 struct list_head *pos; 237 238 /* Interrupts weren't properly cleared during probe */ 239 BUG_ON(!priv || !chip); 240 241 chained_irq_enter(chip, desc); 242 list_for_each(pos, &priv->bank_list) { 243 struct brcmstb_gpio_bank *bank = 244 list_entry(pos, struct brcmstb_gpio_bank, node); 245 brcmstb_gpio_irq_bank_handler(bank); 246 } 247 chained_irq_exit(chip, desc); 248 } 249 250 static int brcmstb_gpio_reboot(struct notifier_block *nb, 251 unsigned long action, void *data) 252 { 253 struct brcmstb_gpio_priv *priv = 254 container_of(nb, struct brcmstb_gpio_priv, reboot_notifier); 255 256 /* Enable GPIO for S5 cold boot */ 257 if (action == SYS_POWER_OFF) 258 brcmstb_gpio_priv_set_wake(priv, 1); 259 260 return NOTIFY_DONE; 261 } 262 263 /* Make sure that the number of banks matches up between properties */ 264 static int brcmstb_gpio_sanity_check_banks(struct device *dev, 265 struct device_node *np, struct resource *res) 266 { 267 int res_num_banks = resource_size(res) / GIO_BANK_SIZE; 268 int num_banks = 269 of_property_count_u32_elems(np, "brcm,gpio-bank-widths"); 270 271 if (res_num_banks != num_banks) { 272 dev_err(dev, "Mismatch in banks: res had %d, bank-widths had %d\n", 273 res_num_banks, num_banks); 274 return -EINVAL; 275 } else { 276 return 0; 277 } 278 } 279 280 static int brcmstb_gpio_remove(struct platform_device *pdev) 281 { 282 struct brcmstb_gpio_priv *priv = platform_get_drvdata(pdev); 283 struct list_head *pos; 284 struct brcmstb_gpio_bank *bank; 285 int ret = 0; 286 287 if (!priv) { 288 dev_err(&pdev->dev, "called %s without drvdata!\n", __func__); 289 return -EFAULT; 290 } 291 292 /* 293 * You can lose return values below, but we report all errors, and it's 294 * more important to actually perform all of the steps. 295 */ 296 list_for_each(pos, &priv->bank_list) { 297 bank = list_entry(pos, struct brcmstb_gpio_bank, node); 298 gpiochip_remove(&bank->gc); 299 } 300 if (priv->reboot_notifier.notifier_call) { 301 ret = unregister_reboot_notifier(&priv->reboot_notifier); 302 if (ret) 303 dev_err(&pdev->dev, 304 "failed to unregister reboot notifier\n"); 305 } 306 return ret; 307 } 308 309 static int brcmstb_gpio_of_xlate(struct gpio_chip *gc, 310 const struct of_phandle_args *gpiospec, u32 *flags) 311 { 312 struct brcmstb_gpio_priv *priv = brcmstb_gpio_gc_to_priv(gc); 313 struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc); 314 int offset; 315 316 if (gc->of_gpio_n_cells != 2) { 317 WARN_ON(1); 318 return -EINVAL; 319 } 320 321 if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells)) 322 return -EINVAL; 323 324 offset = gpiospec->args[0] - (gc->base - priv->gpio_base); 325 if (offset >= gc->ngpio || offset < 0) 326 return -EINVAL; 327 328 if (unlikely(offset >= bank->width)) { 329 dev_warn_ratelimited(&priv->pdev->dev, 330 "Received request for invalid GPIO offset %d\n", 331 gpiospec->args[0]); 332 } 333 334 if (flags) 335 *flags = gpiospec->args[1]; 336 337 return offset; 338 } 339 340 /* Before calling, must have bank->parent_irq set and gpiochip registered */ 341 static int brcmstb_gpio_irq_setup(struct platform_device *pdev, 342 struct brcmstb_gpio_bank *bank) 343 { 344 struct brcmstb_gpio_priv *priv = bank->parent_priv; 345 struct device *dev = &pdev->dev; 346 struct device_node *np = dev->of_node; 347 348 bank->irq_chip.name = dev_name(dev); 349 bank->irq_chip.irq_mask = brcmstb_gpio_irq_mask; 350 bank->irq_chip.irq_unmask = brcmstb_gpio_irq_unmask; 351 bank->irq_chip.irq_set_type = brcmstb_gpio_irq_set_type; 352 353 /* Ensures that all non-wakeup IRQs are disabled at suspend */ 354 bank->irq_chip.flags = IRQCHIP_MASK_ON_SUSPEND; 355 356 if (IS_ENABLED(CONFIG_PM_SLEEP) && !priv->can_wake && 357 of_property_read_bool(np, "wakeup-source")) { 358 priv->parent_wake_irq = platform_get_irq(pdev, 1); 359 if (priv->parent_wake_irq < 0) { 360 dev_warn(dev, 361 "Couldn't get wake IRQ - GPIOs will not be able to wake from sleep"); 362 } else { 363 int err; 364 365 /* 366 * Set wakeup capability before requesting wakeup 367 * interrupt, so we can process boot-time "wakeups" 368 * (e.g., from S5 cold boot) 369 */ 370 device_set_wakeup_capable(dev, true); 371 device_wakeup_enable(dev); 372 err = devm_request_irq(dev, priv->parent_wake_irq, 373 brcmstb_gpio_wake_irq_handler, 0, 374 "brcmstb-gpio-wake", priv); 375 376 if (err < 0) { 377 dev_err(dev, "Couldn't request wake IRQ"); 378 return err; 379 } 380 381 priv->reboot_notifier.notifier_call = 382 brcmstb_gpio_reboot; 383 register_reboot_notifier(&priv->reboot_notifier); 384 priv->can_wake = true; 385 } 386 } 387 388 if (priv->can_wake) 389 bank->irq_chip.irq_set_wake = brcmstb_gpio_irq_set_wake; 390 391 gpiochip_irqchip_add(&bank->gc, &bank->irq_chip, 0, 392 handle_simple_irq, IRQ_TYPE_NONE); 393 gpiochip_set_chained_irqchip(&bank->gc, &bank->irq_chip, 394 priv->parent_irq, brcmstb_gpio_irq_handler); 395 396 return 0; 397 } 398 399 static int brcmstb_gpio_probe(struct platform_device *pdev) 400 { 401 struct device *dev = &pdev->dev; 402 struct device_node *np = dev->of_node; 403 void __iomem *reg_base; 404 struct brcmstb_gpio_priv *priv; 405 struct resource *res; 406 struct property *prop; 407 const __be32 *p; 408 u32 bank_width; 409 int num_banks = 0; 410 int err; 411 static int gpio_base; 412 unsigned long flags = 0; 413 414 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 415 if (!priv) 416 return -ENOMEM; 417 platform_set_drvdata(pdev, priv); 418 INIT_LIST_HEAD(&priv->bank_list); 419 420 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 421 reg_base = devm_ioremap_resource(dev, res); 422 if (IS_ERR(reg_base)) 423 return PTR_ERR(reg_base); 424 425 priv->gpio_base = gpio_base; 426 priv->reg_base = reg_base; 427 priv->pdev = pdev; 428 429 if (of_property_read_bool(np, "interrupt-controller")) { 430 priv->parent_irq = platform_get_irq(pdev, 0); 431 if (priv->parent_irq <= 0) { 432 dev_err(dev, "Couldn't get IRQ"); 433 return -ENOENT; 434 } 435 } else { 436 priv->parent_irq = -ENOENT; 437 } 438 439 if (brcmstb_gpio_sanity_check_banks(dev, np, res)) 440 return -EINVAL; 441 442 /* 443 * MIPS endianness is configured by boot strap, which also reverses all 444 * bus endianness (i.e., big-endian CPU + big endian bus ==> native 445 * endian I/O). 446 * 447 * Other architectures (e.g., ARM) either do not support big endian, or 448 * else leave I/O in little endian mode. 449 */ 450 #if defined(CONFIG_MIPS) && defined(__BIG_ENDIAN) 451 flags = BGPIOF_BIG_ENDIAN_BYTE_ORDER; 452 #endif 453 454 of_property_for_each_u32(np, "brcm,gpio-bank-widths", prop, p, 455 bank_width) { 456 struct brcmstb_gpio_bank *bank; 457 struct gpio_chip *gc; 458 459 bank = devm_kzalloc(dev, sizeof(*bank), GFP_KERNEL); 460 if (!bank) { 461 err = -ENOMEM; 462 goto fail; 463 } 464 465 bank->parent_priv = priv; 466 bank->id = num_banks; 467 if (bank_width <= 0 || bank_width > MAX_GPIO_PER_BANK) { 468 dev_err(dev, "Invalid bank width %d\n", bank_width); 469 goto fail; 470 } else { 471 bank->width = bank_width; 472 } 473 474 /* 475 * Regs are 4 bytes wide, have data reg, no set/clear regs, 476 * and direction bits have 0 = output and 1 = input 477 */ 478 gc = &bank->gc; 479 err = bgpio_init(gc, dev, 4, 480 reg_base + GIO_DATA(bank->id), 481 NULL, NULL, NULL, 482 reg_base + GIO_IODIR(bank->id), flags); 483 if (err) { 484 dev_err(dev, "bgpio_init() failed\n"); 485 goto fail; 486 } 487 488 gc->of_node = np; 489 gc->owner = THIS_MODULE; 490 gc->label = np->full_name; 491 gc->base = gpio_base; 492 gc->of_gpio_n_cells = 2; 493 gc->of_xlate = brcmstb_gpio_of_xlate; 494 /* not all ngpio lines are valid, will use bank width later */ 495 gc->ngpio = MAX_GPIO_PER_BANK; 496 497 /* 498 * Mask all interrupts by default, since wakeup interrupts may 499 * be retained from S5 cold boot 500 */ 501 gc->write_reg(reg_base + GIO_MASK(bank->id), 0); 502 503 err = gpiochip_add_data(gc, bank); 504 if (err) { 505 dev_err(dev, "Could not add gpiochip for bank %d\n", 506 bank->id); 507 goto fail; 508 } 509 gpio_base += gc->ngpio; 510 511 if (priv->parent_irq > 0) { 512 err = brcmstb_gpio_irq_setup(pdev, bank); 513 if (err) 514 goto fail; 515 } 516 517 dev_dbg(dev, "bank=%d, base=%d, ngpio=%d, width=%d\n", bank->id, 518 gc->base, gc->ngpio, bank->width); 519 520 /* Everything looks good, so add bank to list */ 521 list_add(&bank->node, &priv->bank_list); 522 523 num_banks++; 524 } 525 526 dev_info(dev, "Registered %d banks (GPIO(s): %d-%d)\n", 527 num_banks, priv->gpio_base, gpio_base - 1); 528 529 return 0; 530 531 fail: 532 (void) brcmstb_gpio_remove(pdev); 533 return err; 534 } 535 536 static const struct of_device_id brcmstb_gpio_of_match[] = { 537 { .compatible = "brcm,brcmstb-gpio" }, 538 {}, 539 }; 540 541 MODULE_DEVICE_TABLE(of, brcmstb_gpio_of_match); 542 543 static struct platform_driver brcmstb_gpio_driver = { 544 .driver = { 545 .name = "brcmstb-gpio", 546 .of_match_table = brcmstb_gpio_of_match, 547 }, 548 .probe = brcmstb_gpio_probe, 549 .remove = brcmstb_gpio_remove, 550 }; 551 module_platform_driver(brcmstb_gpio_driver); 552 553 MODULE_AUTHOR("Gregory Fong"); 554 MODULE_DESCRIPTION("Driver for Broadcom BRCMSTB SoC UPG GPIO"); 555 MODULE_LICENSE("GPL v2"); 556