drivers/gpio/gpio-brcmstb.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright (C) 2015-2017 Broadcom
   3
   4 #include <linux/bitops.h>
   5 #include <linux/gpio/driver.h>
   6 #include <linux/of_device.h>
   7 #include <linux/of_irq.h>
   8 #include <linux/module.h>
   9 #include <linux/irqdomain.h>
  10 #include <linux/irqchip/chained_irq.h>
  11 #include <linux/interrupt.h>
  12
  13 enum gio_reg_index {
  14         GIO_REG_ODEN = 0,
  15         GIO_REG_DATA,
  16         GIO_REG_IODIR,
  17         GIO_REG_EC,
  18         GIO_REG_EI,
  19         GIO_REG_MASK,
  20         GIO_REG_LEVEL,
  21         GIO_REG_STAT,
  22         NUMBER_OF_GIO_REGISTERS
  23 };
  24
  25 #define GIO_BANK_SIZE           (NUMBER_OF_GIO_REGISTERS * sizeof(u32))
  26 #define GIO_BANK_OFF(bank, off) (((bank) * GIO_BANK_SIZE) + (off * sizeof(u32)))
  27 #define GIO_ODEN(bank)          GIO_BANK_OFF(bank, GIO_REG_ODEN)
  28 #define GIO_DATA(bank)          GIO_BANK_OFF(bank, GIO_REG_DATA)
  29 #define GIO_IODIR(bank)         GIO_BANK_OFF(bank, GIO_REG_IODIR)
  30 #define GIO_EC(bank)            GIO_BANK_OFF(bank, GIO_REG_EC)
  31 #define GIO_EI(bank)            GIO_BANK_OFF(bank, GIO_REG_EI)
  32 #define GIO_MASK(bank)          GIO_BANK_OFF(bank, GIO_REG_MASK)
  33 #define GIO_LEVEL(bank)         GIO_BANK_OFF(bank, GIO_REG_LEVEL)
  34 #define GIO_STAT(bank)          GIO_BANK_OFF(bank, GIO_REG_STAT)
  35
  36 struct brcmstb_gpio_bank {
  37         struct list_head node;
  38         int id;
  39         struct gpio_chip gc;
  40         struct brcmstb_gpio_priv *parent_priv;
  41         u32 width;
  42         u32 wake_active;
  43         u32 saved_regs[GIO_REG_STAT]; /* Don't save and restore GIO_REG_STAT */
  44 };
  45
  46 struct brcmstb_gpio_priv {
  47         struct list_head bank_list;
  48         void __iomem *reg_base;
  49         struct platform_device *pdev;
  50         struct irq_domain *irq_domain;
  51         struct irq_chip irq_chip;
  52         int parent_irq;
  53         int gpio_base;
  54         int num_gpios;
  55         int parent_wake_irq;
  56 };
  57
  58 #define MAX_GPIO_PER_BANK       32
  59 #define GPIO_BANK(gpio)         ((gpio) >> 5)
  60 /* assumes MAX_GPIO_PER_BANK is a multiple of 2 */
  61 #define GPIO_BIT(gpio)          ((gpio) & (MAX_GPIO_PER_BANK - 1))
  62
  63 static inline struct brcmstb_gpio_priv *
  64 brcmstb_gpio_gc_to_priv(struct gpio_chip *gc)
  65 {
  66         struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
  67         return bank->parent_priv;
  68 }
  69
  70 static unsigned long
  71 __brcmstb_gpio_get_active_irqs(struct brcmstb_gpio_bank *bank)
  72 {
  73         void __iomem *reg_base = bank->parent_priv->reg_base;
  74
  75         return bank->gc.read_reg(reg_base + GIO_STAT(bank->id)) &
  76                bank->gc.read_reg(reg_base + GIO_MASK(bank->id));
  77 }
  78
  79 static unsigned long
  80 brcmstb_gpio_get_active_irqs(struct brcmstb_gpio_bank *bank)
  81 {
  82         unsigned long status;
  83         unsigned long flags;
  84
  85         raw_spin_lock_irqsave(&bank->gc.bgpio_lock, flags);
  86         status = __brcmstb_gpio_get_active_irqs(bank);
  87         raw_spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags);
  88
  89         return status;
  90 }
  91
  92 static int brcmstb_gpio_hwirq_to_offset(irq_hw_number_t hwirq,
  93                                         struct brcmstb_gpio_bank *bank)
  94 {
  95         return hwirq - (bank->gc.base - bank->parent_priv->gpio_base);
  96 }
  97
  98 static void brcmstb_gpio_set_imask(struct brcmstb_gpio_bank *bank,
  99                 unsigned int hwirq, bool enable)
 100 {
 101         struct gpio_chip *gc = &bank->gc;
 102         struct brcmstb_gpio_priv *priv = bank->parent_priv;
 103         u32 mask = BIT(brcmstb_gpio_hwirq_to_offset(hwirq, bank));
 104         u32 imask;
 105         unsigned long flags;
 106
 107         raw_spin_lock_irqsave(&gc->bgpio_lock, flags);
 108         imask = gc->read_reg(priv->reg_base + GIO_MASK(bank->id));
 109         if (enable)
 110                 imask |= mask;
 111         else
 112                 imask &= ~mask;
 113         gc->write_reg(priv->reg_base + GIO_MASK(bank->id), imask);
 114         raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags);
 115 }
 116
 117 static int brcmstb_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 118 {
 119         struct brcmstb_gpio_priv *priv = brcmstb_gpio_gc_to_priv(gc);
 120         /* gc_offset is relative to this gpio_chip; want real offset */
 121         int hwirq = offset + (gc->base - priv->gpio_base);
 122
 123         if (hwirq >= priv->num_gpios)
 124                 return -ENXIO;
 125         return irq_create_mapping(priv->irq_domain, hwirq);
 126 }
 127
 128 /* -------------------- IRQ chip functions -------------------- */
 129
 130 static void brcmstb_gpio_irq_mask(struct irq_data *d)
 131 {
 132         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 133         struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
 134
 135         brcmstb_gpio_set_imask(bank, d->hwirq, false);
 136 }
 137
 138 static void brcmstb_gpio_irq_unmask(struct irq_data *d)
 139 {
 140         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 141         struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
 142
 143         brcmstb_gpio_set_imask(bank, d->hwirq, true);
 144 }
 145
 146 static void brcmstb_gpio_irq_ack(struct irq_data *d)
 147 {
 148         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 149         struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
 150         struct brcmstb_gpio_priv *priv = bank->parent_priv;
 151         u32 mask = BIT(brcmstb_gpio_hwirq_to_offset(d->hwirq, bank));
 152
 153         gc->write_reg(priv->reg_base + GIO_STAT(bank->id), mask);
 154 }
 155
 156 static int brcmstb_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 157 {
 158         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 159         struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
 160         struct brcmstb_gpio_priv *priv = bank->parent_priv;
 161         u32 mask = BIT(brcmstb_gpio_hwirq_to_offset(d->hwirq, bank));
 162         u32 edge_insensitive, iedge_insensitive;
 163         u32 edge_config, iedge_config;
 164         u32 level, ilevel;
 165         unsigned long flags;
 166
 167         switch (type) {
 168         case IRQ_TYPE_LEVEL_LOW:
 169                 level = mask;
 170                 edge_config = 0;
 171                 edge_insensitive = 0;
 172                 break;
 173         case IRQ_TYPE_LEVEL_HIGH:
 174                 level = mask;
 175                 edge_config = mask;
 176                 edge_insensitive = 0;
 177                 break;
 178         case IRQ_TYPE_EDGE_FALLING:
 179                 level = 0;
 180                 edge_config = 0;
 181                 edge_insensitive = 0;
 182                 break;
 183         case IRQ_TYPE_EDGE_RISING:
 184                 level = 0;
 185                 edge_config = mask;
 186                 edge_insensitive = 0;
 187                 break;
 188         case IRQ_TYPE_EDGE_BOTH:
 189                 level = 0;
 190                 edge_config = 0;  /* don't care, but want known value */
 191                 edge_insensitive = mask;
 192                 break;
 193         default:
 194                 return -EINVAL;
 195         }
 196
 197         raw_spin_lock_irqsave(&bank->gc.bgpio_lock, flags);
 198
 199         iedge_config = bank->gc.read_reg(priv->reg_base +
 200                         GIO_EC(bank->id)) & ~mask;
 201         iedge_insensitive = bank->gc.read_reg(priv->reg_base +
 202                         GIO_EI(bank->id)) & ~mask;
 203         ilevel = bank->gc.read_reg(priv->reg_base +
 204                         GIO_LEVEL(bank->id)) & ~mask;
 205
 206         bank->gc.write_reg(priv->reg_base + GIO_EC(bank->id),
 207                         iedge_config | edge_config);
 208         bank->gc.write_reg(priv->reg_base + GIO_EI(bank->id),
 209                         iedge_insensitive | edge_insensitive);
 210         bank->gc.write_reg(priv->reg_base + GIO_LEVEL(bank->id),
 211                         ilevel | level);
 212
 213         raw_spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags);
 214         return 0;
 215 }
 216
 217 static int brcmstb_gpio_priv_set_wake(struct brcmstb_gpio_priv *priv,
 218                 unsigned int enable)
 219 {
 220         int ret = 0;
 221
 222         if (enable)
 223                 ret = enable_irq_wake(priv->parent_wake_irq);
 224         else
 225                 ret = disable_irq_wake(priv->parent_wake_irq);
 226         if (ret)
 227                 dev_err(&priv->pdev->dev, "failed to %s wake-up interrupt\n",
 228                                 enable ? "enable" : "disable");
 229         return ret;
 230 }
 231
 232 static int brcmstb_gpio_irq_set_wake(struct irq_data *d, unsigned int enable)
 233 {
 234         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 235         struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
 236         struct brcmstb_gpio_priv *priv = bank->parent_priv;
 237         u32 mask = BIT(brcmstb_gpio_hwirq_to_offset(d->hwirq, bank));
 238
 239         /*
 240          * Do not do anything specific for now, suspend/resume callbacks will
 241          * configure the interrupt mask appropriately
 242          */
 243         if (enable)
 244                 bank->wake_active |= mask;
 245         else
 246                 bank->wake_active &= ~mask;
 247
 248         return brcmstb_gpio_priv_set_wake(priv, enable);
 249 }
 250
 251 static irqreturn_t brcmstb_gpio_wake_irq_handler(int irq, void *data)
 252 {
 253         struct brcmstb_gpio_priv *priv = data;
 254
 255         if (!priv || irq != priv->parent_wake_irq)
 256                 return IRQ_NONE;
 257
 258         /* Nothing to do */
 259         return IRQ_HANDLED;
 260 }
 261
 262 static void brcmstb_gpio_irq_bank_handler(struct brcmstb_gpio_bank *bank)
 263 {
 264         struct brcmstb_gpio_priv *priv = bank->parent_priv;
 265         struct irq_domain *domain = priv->irq_domain;
 266         int hwbase = bank->gc.base - priv->gpio_base;
 267         unsigned long status;
 268
 269         while ((status = brcmstb_gpio_get_active_irqs(bank))) {
 270                 unsigned int offset;
 271
 272                 for_each_set_bit(offset, &status, 32) {
 273                         if (offset >= bank->width)
 274                                 dev_warn(&priv->pdev->dev,
 275                                          "IRQ for invalid GPIO (bank=%d, offset=%d)\n",
 276                                          bank->id, offset);
 277                         generic_handle_domain_irq(domain, hwbase + offset);
 278                 }
 279         }
 280 }
 281
 282 /* Each UPG GIO block has one IRQ for all banks */
 283 static void brcmstb_gpio_irq_handler(struct irq_desc *desc)
 284 {
 285         struct brcmstb_gpio_priv *priv = irq_desc_get_handler_data(desc);
 286         struct irq_chip *chip = irq_desc_get_chip(desc);
 287         struct brcmstb_gpio_bank *bank;
 288
 289         /* Interrupts weren't properly cleared during probe */
 290         BUG_ON(!priv || !chip);
 291
 292         chained_irq_enter(chip, desc);
 293         list_for_each_entry(bank, &priv->bank_list, node)
 294                 brcmstb_gpio_irq_bank_handler(bank);
 295         chained_irq_exit(chip, desc);
 296 }
 297
 298 static struct brcmstb_gpio_bank *brcmstb_gpio_hwirq_to_bank(
 299                 struct brcmstb_gpio_priv *priv, irq_hw_number_t hwirq)
 300 {
 301         struct brcmstb_gpio_bank *bank;
 302         int i = 0;
 303
 304         /* banks are in descending order */
 305         list_for_each_entry_reverse(bank, &priv->bank_list, node) {
 306                 i += bank->gc.ngpio;
 307                 if (hwirq < i)
 308                         return bank;
 309         }
 310         return NULL;
 311 }
 312
 313 /*
 314  * This lock class tells lockdep that GPIO irqs are in a different
 315  * category than their parents, so it won't report false recursion.
 316  */
 317 static struct lock_class_key brcmstb_gpio_irq_lock_class;
 318 static struct lock_class_key brcmstb_gpio_irq_request_class;
 319
 320
 321 static int brcmstb_gpio_irq_map(struct irq_domain *d, unsigned int irq,
 322                 irq_hw_number_t hwirq)
 323 {
 324         struct brcmstb_gpio_priv *priv = d->host_data;
 325         struct brcmstb_gpio_bank *bank =
 326                 brcmstb_gpio_hwirq_to_bank(priv, hwirq);
 327         struct platform_device *pdev = priv->pdev;
 328         int ret;
 329
 330         if (!bank)
 331                 return -EINVAL;
 332
 333         dev_dbg(&pdev->dev, "Mapping irq %d for gpio line %d (bank %d)\n",
 334                 irq, (int)hwirq, bank->id);
 335         ret = irq_set_chip_data(irq, &bank->gc);
 336         if (ret < 0)
 337                 return ret;
 338         irq_set_lockdep_class(irq, &brcmstb_gpio_irq_lock_class,
 339                               &brcmstb_gpio_irq_request_class);
 340         irq_set_chip_and_handler(irq, &priv->irq_chip, handle_level_irq);
 341         irq_set_noprobe(irq);
 342         return 0;
 343 }
 344
 345 static void brcmstb_gpio_irq_unmap(struct irq_domain *d, unsigned int irq)
 346 {
 347         irq_set_chip_and_handler(irq, NULL, NULL);
 348         irq_set_chip_data(irq, NULL);
 349 }
 350
 351 static const struct irq_domain_ops brcmstb_gpio_irq_domain_ops = {
 352         .map = brcmstb_gpio_irq_map,
 353         .unmap = brcmstb_gpio_irq_unmap,
 354         .xlate = irq_domain_xlate_twocell,
 355 };
 356
 357 /* Make sure that the number of banks matches up between properties */
 358 static int brcmstb_gpio_sanity_check_banks(struct device *dev,
 359                 struct device_node *np, struct resource *res)
 360 {
 361         int res_num_banks = resource_size(res) / GIO_BANK_SIZE;
 362         int num_banks =
 363                 of_property_count_u32_elems(np, "brcm,gpio-bank-widths");
 364
 365         if (res_num_banks != num_banks) {
 366                 dev_err(dev, "Mismatch in banks: res had %d, bank-widths had %d\n",
 367                                 res_num_banks, num_banks);
 368                 return -EINVAL;
 369         } else {
 370                 return 0;
 371         }
 372 }
 373
 374 static int brcmstb_gpio_remove(struct platform_device *pdev)
 375 {
 376         struct brcmstb_gpio_priv *priv = platform_get_drvdata(pdev);
 377         struct brcmstb_gpio_bank *bank;
 378         int offset, virq;
 379
 380         if (priv->parent_irq > 0)
 381                 irq_set_chained_handler_and_data(priv->parent_irq, NULL, NULL);
 382
 383         /* Remove all IRQ mappings and delete the domain */
 384         if (priv->irq_domain) {
 385                 for (offset = 0; offset < priv->num_gpios; offset++) {
 386                         virq = irq_find_mapping(priv->irq_domain, offset);
 387                         irq_dispose_mapping(virq);
 388                 }
 389                 irq_domain_remove(priv->irq_domain);
 390         }
 391
 392         /*
 393          * You can lose return values below, but we report all errors, and it's
 394          * more important to actually perform all of the steps.
 395          */
 396         list_for_each_entry(bank, &priv->bank_list, node)
 397                 gpiochip_remove(&bank->gc);
 398
 399         return 0;
 400 }
 401
 402 static int brcmstb_gpio_of_xlate(struct gpio_chip *gc,
 403                 const struct of_phandle_args *gpiospec, u32 *flags)
 404 {
 405         struct brcmstb_gpio_priv *priv = brcmstb_gpio_gc_to_priv(gc);
 406         struct brcmstb_gpio_bank *bank = gpiochip_get_data(gc);
 407         int offset;
 408
 409         if (gc->of_gpio_n_cells != 2) {
 410                 WARN_ON(1);
 411                 return -EINVAL;
 412         }
 413
 414         if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
 415                 return -EINVAL;
 416
 417         offset = gpiospec->args[0] - (gc->base - priv->gpio_base);
 418         if (offset >= gc->ngpio || offset < 0)
 419                 return -EINVAL;
 420
 421         if (unlikely(offset >= bank->width)) {
 422                 dev_warn_ratelimited(&priv->pdev->dev,
 423                         "Received request for invalid GPIO offset %d\n",
 424                         gpiospec->args[0]);
 425         }
 426
 427         if (flags)
 428                 *flags = gpiospec->args[1];
 429
 430         return offset;
 431 }
 432
 433 /* priv->parent_irq and priv->num_gpios must be set before calling */
 434 static int brcmstb_gpio_irq_setup(struct platform_device *pdev,
 435                 struct brcmstb_gpio_priv *priv)
 436 {
 437         struct device *dev = &pdev->dev;
 438         struct device_node *np = dev->of_node;
 439         int err;
 440
 441         priv->irq_domain =
 442                 irq_domain_add_linear(np, priv->num_gpios,
 443                                       &brcmstb_gpio_irq_domain_ops,
 444                                       priv);
 445         if (!priv->irq_domain) {
 446                 dev_err(dev, "Couldn't allocate IRQ domain\n");
 447                 return -ENXIO;
 448         }
 449
 450         if (of_property_read_bool(np, "wakeup-source")) {
 451                 priv->parent_wake_irq = platform_get_irq(pdev, 1);
 452                 if (priv->parent_wake_irq < 0) {
 453                         priv->parent_wake_irq = 0;
 454                         dev_warn(dev,
 455                                 "Couldn't get wake IRQ - GPIOs will not be able to wake from sleep");
 456                 } else {
 457                         /*
 458                          * Set wakeup capability so we can process boot-time
 459                          * "wakeups" (e.g., from S5 cold boot)
 460                          */
 461                         device_set_wakeup_capable(dev, true);
 462                         device_wakeup_enable(dev);
 463                         err = devm_request_irq(dev, priv->parent_wake_irq,
 464                                                brcmstb_gpio_wake_irq_handler,
 465                                                IRQF_SHARED,
 466                                                "brcmstb-gpio-wake", priv);
 467
 468                         if (err < 0) {
 469                                 dev_err(dev, "Couldn't request wake IRQ");
 470                                 goto out_free_domain;
 471                         }
 472                 }
 473         }
 474
 475         priv->irq_chip.name = dev_name(dev);
 476         priv->irq_chip.irq_disable = brcmstb_gpio_irq_mask;
 477         priv->irq_chip.irq_mask = brcmstb_gpio_irq_mask;
 478         priv->irq_chip.irq_unmask = brcmstb_gpio_irq_unmask;
 479         priv->irq_chip.irq_ack = brcmstb_gpio_irq_ack;
 480         priv->irq_chip.irq_set_type = brcmstb_gpio_irq_set_type;
 481
 482         if (priv->parent_wake_irq)
 483                 priv->irq_chip.irq_set_wake = brcmstb_gpio_irq_set_wake;
 484
 485         irq_set_chained_handler_and_data(priv->parent_irq,
 486                                          brcmstb_gpio_irq_handler, priv);
 487         irq_set_status_flags(priv->parent_irq, IRQ_DISABLE_UNLAZY);
 488
 489         return 0;
 490
 491 out_free_domain:
 492         irq_domain_remove(priv->irq_domain);
 493
 494         return err;
 495 }
 496
 497 static void brcmstb_gpio_bank_save(struct brcmstb_gpio_priv *priv,
 498                                    struct brcmstb_gpio_bank *bank)
 499 {
 500         struct gpio_chip *gc = &bank->gc;
 501         unsigned int i;
 502
 503         for (i = 0; i < GIO_REG_STAT; i++)
 504                 bank->saved_regs[i] = gc->read_reg(priv->reg_base +
 505                                                    GIO_BANK_OFF(bank->id, i));
 506 }
 507
 508 static void brcmstb_gpio_quiesce(struct device *dev, bool save)
 509 {
 510         struct brcmstb_gpio_priv *priv = dev_get_drvdata(dev);
 511         struct brcmstb_gpio_bank *bank;
 512         struct gpio_chip *gc;
 513         u32 imask;
 514
 515         /* disable non-wake interrupt */
 516         if (priv->parent_irq >= 0)
 517                 disable_irq(priv->parent_irq);
 518
 519         list_for_each_entry(bank, &priv->bank_list, node) {
 520                 gc = &bank->gc;
 521
 522                 if (save)
 523                         brcmstb_gpio_bank_save(priv, bank);
 524
 525                 /* Unmask GPIOs which have been flagged as wake-up sources */
 526                 if (priv->parent_wake_irq)
 527                         imask = bank->wake_active;
 528                 else
 529                         imask = 0;
 530                 gc->write_reg(priv->reg_base + GIO_MASK(bank->id),
 531                                imask);
 532         }
 533 }
 534
 535 static void brcmstb_gpio_shutdown(struct platform_device *pdev)
 536 {
 537         /* Enable GPIO for S5 cold boot */
 538         brcmstb_gpio_quiesce(&pdev->dev, false);
 539 }
 540
 541 #ifdef CONFIG_PM_SLEEP
 542 static void brcmstb_gpio_bank_restore(struct brcmstb_gpio_priv *priv,
 543                                       struct brcmstb_gpio_bank *bank)
 544 {
 545         struct gpio_chip *gc = &bank->gc;
 546         unsigned int i;
 547
 548         for (i = 0; i < GIO_REG_STAT; i++)
 549                 gc->write_reg(priv->reg_base + GIO_BANK_OFF(bank->id, i),
 550                               bank->saved_regs[i]);
 551 }
 552
 553 static int brcmstb_gpio_suspend(struct device *dev)
 554 {
 555         brcmstb_gpio_quiesce(dev, true);
 556         return 0;
 557 }
 558
 559 static int brcmstb_gpio_resume(struct device *dev)
 560 {
 561         struct brcmstb_gpio_priv *priv = dev_get_drvdata(dev);
 562         struct brcmstb_gpio_bank *bank;
 563         bool need_wakeup_event = false;
 564
 565         list_for_each_entry(bank, &priv->bank_list, node) {
 566                 need_wakeup_event |= !!__brcmstb_gpio_get_active_irqs(bank);
 567                 brcmstb_gpio_bank_restore(priv, bank);
 568         }
 569
 570         if (priv->parent_wake_irq && need_wakeup_event)
 571                 pm_wakeup_event(dev, 0);
 572
 573         /* enable non-wake interrupt */
 574         if (priv->parent_irq >= 0)
 575                 enable_irq(priv->parent_irq);
 576
 577         return 0;
 578 }
 579
 580 #else
 581 #define brcmstb_gpio_suspend    NULL
 582 #define brcmstb_gpio_resume     NULL
 583 #endif /* CONFIG_PM_SLEEP */
 584
 585 static const struct dev_pm_ops brcmstb_gpio_pm_ops = {
 586         .suspend_noirq  = brcmstb_gpio_suspend,
 587         .resume_noirq = brcmstb_gpio_resume,
 588 };
 589
 590 static int brcmstb_gpio_probe(struct platform_device *pdev)
 591 {
 592         struct device *dev = &pdev->dev;
 593         struct device_node *np = dev->of_node;
 594         void __iomem *reg_base;
 595         struct brcmstb_gpio_priv *priv;
 596         struct resource *res;
 597         struct property *prop;
 598         const __be32 *p;
 599         u32 bank_width;
 600         int num_banks = 0;
 601         int err;
 602         static int gpio_base;
 603         unsigned long flags = 0;
 604         bool need_wakeup_event = false;
 605
 606         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 607         if (!priv)
 608                 return -ENOMEM;
 609         platform_set_drvdata(pdev, priv);
 610         INIT_LIST_HEAD(&priv->bank_list);
 611
 612         reg_base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
 613         if (IS_ERR(reg_base))
 614                 return PTR_ERR(reg_base);
 615
 616         priv->gpio_base = gpio_base;
 617         priv->reg_base = reg_base;
 618         priv->pdev = pdev;
 619
 620         if (of_property_read_bool(np, "interrupt-controller")) {
 621                 priv->parent_irq = platform_get_irq(pdev, 0);
 622                 if (priv->parent_irq <= 0)
 623                         return -ENOENT;
 624         } else {
 625                 priv->parent_irq = -ENOENT;
 626         }
 627
 628         if (brcmstb_gpio_sanity_check_banks(dev, np, res))
 629                 return -EINVAL;
 630
 631         /*
 632          * MIPS endianness is configured by boot strap, which also reverses all
 633          * bus endianness (i.e., big-endian CPU + big endian bus ==> native
 634          * endian I/O).
 635          *
 636          * Other architectures (e.g., ARM) either do not support big endian, or
 637          * else leave I/O in little endian mode.
 638          */
 639 #if defined(CONFIG_MIPS) && defined(__BIG_ENDIAN)
 640         flags = BGPIOF_BIG_ENDIAN_BYTE_ORDER;
 641 #endif
 642
 643         of_property_for_each_u32(np, "brcm,gpio-bank-widths", prop, p,
 644                         bank_width) {
 645                 struct brcmstb_gpio_bank *bank;
 646                 struct gpio_chip *gc;
 647
 648                 /*
 649                  * If bank_width is 0, then there is an empty bank in the
 650                  * register block. Special handling for this case.
 651                  */
 652                 if (bank_width == 0) {
 653                         dev_dbg(dev, "Width 0 found: Empty bank @ %d\n",
 654                                 num_banks);
 655                         num_banks++;
 656                         gpio_base += MAX_GPIO_PER_BANK;
 657                         continue;
 658                 }
 659
 660                 bank = devm_kzalloc(dev, sizeof(*bank), GFP_KERNEL);
 661                 if (!bank) {
 662                         err = -ENOMEM;
 663                         goto fail;
 664                 }
 665
 666                 bank->parent_priv = priv;
 667                 bank->id = num_banks;
 668                 if (bank_width <= 0 || bank_width > MAX_GPIO_PER_BANK) {
 669                         dev_err(dev, "Invalid bank width %d\n", bank_width);
 670                         err = -EINVAL;
 671                         goto fail;
 672                 } else {
 673                         bank->width = bank_width;
 674                 }
 675
 676                 /*
 677                  * Regs are 4 bytes wide, have data reg, no set/clear regs,
 678                  * and direction bits have 0 = output and 1 = input
 679                  */
 680                 gc = &bank->gc;
 681                 err = bgpio_init(gc, dev, 4,
 682                                 reg_base + GIO_DATA(bank->id),
 683                                 NULL, NULL, NULL,
 684                                 reg_base + GIO_IODIR(bank->id), flags);
 685                 if (err) {
 686                         dev_err(dev, "bgpio_init() failed\n");
 687                         goto fail;
 688                 }
 689
 690                 gc->owner = THIS_MODULE;
 691                 gc->label = devm_kasprintf(dev, GFP_KERNEL, "%pOF", np);
 692                 if (!gc->label) {
 693                         err = -ENOMEM;
 694                         goto fail;
 695                 }
 696                 gc->base = gpio_base;
 697                 gc->of_gpio_n_cells = 2;
 698                 gc->of_xlate = brcmstb_gpio_of_xlate;
 699                 /* not all ngpio lines are valid, will use bank width later */
 700                 gc->ngpio = MAX_GPIO_PER_BANK;
 701                 gc->offset = bank->id * MAX_GPIO_PER_BANK;
 702                 if (priv->parent_irq > 0)
 703                         gc->to_irq = brcmstb_gpio_to_irq;
 704
 705                 /*
 706                  * Mask all interrupts by default, since wakeup interrupts may
 707                  * be retained from S5 cold boot
 708                  */
 709                 need_wakeup_event |= !!__brcmstb_gpio_get_active_irqs(bank);
 710                 gc->write_reg(reg_base + GIO_MASK(bank->id), 0);
 711
 712                 err = gpiochip_add_data(gc, bank);
 713                 if (err) {
 714                         dev_err(dev, "Could not add gpiochip for bank %d\n",
 715                                         bank->id);
 716                         goto fail;
 717                 }
 718                 gpio_base += gc->ngpio;
 719
 720                 dev_dbg(dev, "bank=%d, base=%d, ngpio=%d, width=%d\n", bank->id,
 721                         gc->base, gc->ngpio, bank->width);
 722
 723                 /* Everything looks good, so add bank to list */
 724                 list_add(&bank->node, &priv->bank_list);
 725
 726                 num_banks++;
 727         }
 728
 729         priv->num_gpios = gpio_base - priv->gpio_base;
 730         if (priv->parent_irq > 0) {
 731                 err = brcmstb_gpio_irq_setup(pdev, priv);
 732                 if (err)
 733                         goto fail;
 734         }
 735
 736         if (priv->parent_wake_irq && need_wakeup_event)
 737                 pm_wakeup_event(dev, 0);
 738
 739         return 0;
 740
 741 fail:
 742         (void) brcmstb_gpio_remove(pdev);
 743         return err;
 744 }
 745
 746 static const struct of_device_id brcmstb_gpio_of_match[] = {
 747         { .compatible = "brcm,brcmstb-gpio" },
 748         {},
 749 };
 750
 751 MODULE_DEVICE_TABLE(of, brcmstb_gpio_of_match);
 752
 753 static struct platform_driver brcmstb_gpio_driver = {
 754         .driver = {
 755                 .name = "brcmstb-gpio",
 756                 .of_match_table = brcmstb_gpio_of_match,
 757                 .pm = &brcmstb_gpio_pm_ops,
 758         },
 759         .probe = brcmstb_gpio_probe,
 760         .remove = brcmstb_gpio_remove,
 761         .shutdown = brcmstb_gpio_shutdown,
 762 };
 763 module_platform_driver(brcmstb_gpio_driver);
 764
 765 MODULE_AUTHOR("Gregory Fong");
 766 MODULE_DESCRIPTION("Driver for Broadcom BRCMSTB SoC UPG GPIO");
 767 MODULE_LICENSE("GPL v2");