drivers/pinctrl/bcm/pinctrl-bcm2835.c

   1 /*
   2  * Driver for Broadcom BCM2835 GPIO unit (pinctrl + GPIO)
   3  *
   4  * Copyright (C) 2012 Chris Boot, Simon Arlott, Stephen Warren
   5  *
   6  * This driver is inspired by:
   7  * pinctrl-nomadik.c, please see original file for copyright information
   8  * pinctrl-tegra.c, please see original file for copyright information
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #include <linux/bitmap.h>
  22 #include <linux/bug.h>
  23 #include <linux/delay.h>
  24 #include <linux/device.h>
  25 #include <linux/err.h>
  26 #include <linux/gpio/driver.h>
  27 #include <linux/io.h>
  28 #include <linux/irq.h>
  29 #include <linux/irqdesc.h>
  30 #include <linux/module.h>
  31 #include <linux/of_address.h>
  32 #include <linux/of.h>
  33 #include <linux/of_irq.h>
  34 #include <linux/pinctrl/consumer.h>
  35 #include <linux/pinctrl/machine.h>
  36 #include <linux/pinctrl/pinconf.h>
  37 #include <linux/pinctrl/pinctrl.h>
  38 #include <linux/pinctrl/pinmux.h>
  39 #include <linux/platform_device.h>
  40 #include <linux/seq_file.h>
  41 #include <linux/slab.h>
  42 #include <linux/spinlock.h>
  43 #include <linux/types.h>
  44
  45 #define MODULE_NAME "pinctrl-bcm2835"
  46 #define BCM2835_NUM_GPIOS 54
  47 #define BCM2835_NUM_BANKS 2
  48 #define BCM2835_NUM_IRQS  3
  49
  50 #define BCM2835_PIN_BITMAP_SZ \
  51         DIV_ROUND_UP(BCM2835_NUM_GPIOS, sizeof(unsigned long) * 8)
  52
  53 /* GPIO register offsets */
  54 #define GPFSEL0         0x0     /* Function Select */
  55 #define GPSET0          0x1c    /* Pin Output Set */
  56 #define GPCLR0          0x28    /* Pin Output Clear */
  57 #define GPLEV0          0x34    /* Pin Level */
  58 #define GPEDS0          0x40    /* Pin Event Detect Status */
  59 #define GPREN0          0x4c    /* Pin Rising Edge Detect Enable */
  60 #define GPFEN0          0x58    /* Pin Falling Edge Detect Enable */
  61 #define GPHEN0          0x64    /* Pin High Detect Enable */
  62 #define GPLEN0          0x70    /* Pin Low Detect Enable */
  63 #define GPAREN0         0x7c    /* Pin Async Rising Edge Detect */
  64 #define GPAFEN0         0x88    /* Pin Async Falling Edge Detect */
  65 #define GPPUD           0x94    /* Pin Pull-up/down Enable */
  66 #define GPPUDCLK0       0x98    /* Pin Pull-up/down Enable Clock */
  67
  68 #define FSEL_REG(p)             (GPFSEL0 + (((p) / 10) * 4))
  69 #define FSEL_SHIFT(p)           (((p) % 10) * 3)
  70 #define GPIO_REG_OFFSET(p)      ((p) / 32)
  71 #define GPIO_REG_SHIFT(p)       ((p) % 32)
  72
  73 enum bcm2835_pinconf_param {
  74         /* argument: bcm2835_pinconf_pull */
  75         BCM2835_PINCONF_PARAM_PULL,
  76 };
  77
  78 #define BCM2835_PINCONF_PACK(_param_, _arg_) ((_param_) << 16 | (_arg_))
  79 #define BCM2835_PINCONF_UNPACK_PARAM(_conf_) ((_conf_) >> 16)
  80 #define BCM2835_PINCONF_UNPACK_ARG(_conf_) ((_conf_) & 0xffff)
  81
  82 struct bcm2835_pinctrl {
  83         struct device *dev;
  84         void __iomem *base;
  85         int irq[BCM2835_NUM_IRQS];
  86
  87         /* note: locking assumes each bank will have its own unsigned long */
  88         unsigned long enabled_irq_map[BCM2835_NUM_BANKS];
  89         unsigned int irq_type[BCM2835_NUM_GPIOS];
  90
  91         struct pinctrl_dev *pctl_dev;
  92         struct gpio_chip gpio_chip;
  93         struct pinctrl_gpio_range gpio_range;
  94
  95         int irq_group[BCM2835_NUM_IRQS];
  96         spinlock_t irq_lock[BCM2835_NUM_BANKS];
  97 };
  98
  99 /* pins are just named GPIO0..GPIO53 */
 100 #define BCM2835_GPIO_PIN(a) PINCTRL_PIN(a, "gpio" #a)
 101 static struct pinctrl_pin_desc bcm2835_gpio_pins[] = {
 102         BCM2835_GPIO_PIN(0),
 103         BCM2835_GPIO_PIN(1),
 104         BCM2835_GPIO_PIN(2),
 105         BCM2835_GPIO_PIN(3),
 106         BCM2835_GPIO_PIN(4),
 107         BCM2835_GPIO_PIN(5),
 108         BCM2835_GPIO_PIN(6),
 109         BCM2835_GPIO_PIN(7),
 110         BCM2835_GPIO_PIN(8),
 111         BCM2835_GPIO_PIN(9),
 112         BCM2835_GPIO_PIN(10),
 113         BCM2835_GPIO_PIN(11),
 114         BCM2835_GPIO_PIN(12),
 115         BCM2835_GPIO_PIN(13),
 116         BCM2835_GPIO_PIN(14),
 117         BCM2835_GPIO_PIN(15),
 118         BCM2835_GPIO_PIN(16),
 119         BCM2835_GPIO_PIN(17),
 120         BCM2835_GPIO_PIN(18),
 121         BCM2835_GPIO_PIN(19),
 122         BCM2835_GPIO_PIN(20),
 123         BCM2835_GPIO_PIN(21),
 124         BCM2835_GPIO_PIN(22),
 125         BCM2835_GPIO_PIN(23),
 126         BCM2835_GPIO_PIN(24),
 127         BCM2835_GPIO_PIN(25),
 128         BCM2835_GPIO_PIN(26),
 129         BCM2835_GPIO_PIN(27),
 130         BCM2835_GPIO_PIN(28),
 131         BCM2835_GPIO_PIN(29),
 132         BCM2835_GPIO_PIN(30),
 133         BCM2835_GPIO_PIN(31),
 134         BCM2835_GPIO_PIN(32),
 135         BCM2835_GPIO_PIN(33),
 136         BCM2835_GPIO_PIN(34),
 137         BCM2835_GPIO_PIN(35),
 138         BCM2835_GPIO_PIN(36),
 139         BCM2835_GPIO_PIN(37),
 140         BCM2835_GPIO_PIN(38),
 141         BCM2835_GPIO_PIN(39),
 142         BCM2835_GPIO_PIN(40),
 143         BCM2835_GPIO_PIN(41),
 144         BCM2835_GPIO_PIN(42),
 145         BCM2835_GPIO_PIN(43),
 146         BCM2835_GPIO_PIN(44),
 147         BCM2835_GPIO_PIN(45),
 148         BCM2835_GPIO_PIN(46),
 149         BCM2835_GPIO_PIN(47),
 150         BCM2835_GPIO_PIN(48),
 151         BCM2835_GPIO_PIN(49),
 152         BCM2835_GPIO_PIN(50),
 153         BCM2835_GPIO_PIN(51),
 154         BCM2835_GPIO_PIN(52),
 155         BCM2835_GPIO_PIN(53),
 156 };
 157
 158 /* one pin per group */
 159 static const char * const bcm2835_gpio_groups[] = {
 160         "gpio0",
 161         "gpio1",
 162         "gpio2",
 163         "gpio3",
 164         "gpio4",
 165         "gpio5",
 166         "gpio6",
 167         "gpio7",
 168         "gpio8",
 169         "gpio9",
 170         "gpio10",
 171         "gpio11",
 172         "gpio12",
 173         "gpio13",
 174         "gpio14",
 175         "gpio15",
 176         "gpio16",
 177         "gpio17",
 178         "gpio18",
 179         "gpio19",
 180         "gpio20",
 181         "gpio21",
 182         "gpio22",
 183         "gpio23",
 184         "gpio24",
 185         "gpio25",
 186         "gpio26",
 187         "gpio27",
 188         "gpio28",
 189         "gpio29",
 190         "gpio30",
 191         "gpio31",
 192         "gpio32",
 193         "gpio33",
 194         "gpio34",
 195         "gpio35",
 196         "gpio36",
 197         "gpio37",
 198         "gpio38",
 199         "gpio39",
 200         "gpio40",
 201         "gpio41",
 202         "gpio42",
 203         "gpio43",
 204         "gpio44",
 205         "gpio45",
 206         "gpio46",
 207         "gpio47",
 208         "gpio48",
 209         "gpio49",
 210         "gpio50",
 211         "gpio51",
 212         "gpio52",
 213         "gpio53",
 214 };
 215
 216 enum bcm2835_fsel {
 217         BCM2835_FSEL_GPIO_IN = 0,
 218         BCM2835_FSEL_GPIO_OUT = 1,
 219         BCM2835_FSEL_ALT0 = 4,
 220         BCM2835_FSEL_ALT1 = 5,
 221         BCM2835_FSEL_ALT2 = 6,
 222         BCM2835_FSEL_ALT3 = 7,
 223         BCM2835_FSEL_ALT4 = 3,
 224         BCM2835_FSEL_ALT5 = 2,
 225         BCM2835_FSEL_COUNT = 8,
 226         BCM2835_FSEL_MASK = 0x7,
 227 };
 228
 229 static const char * const bcm2835_functions[BCM2835_FSEL_COUNT] = {
 230         [BCM2835_FSEL_GPIO_IN] = "gpio_in",
 231         [BCM2835_FSEL_GPIO_OUT] = "gpio_out",
 232         [BCM2835_FSEL_ALT0] = "alt0",
 233         [BCM2835_FSEL_ALT1] = "alt1",
 234         [BCM2835_FSEL_ALT2] = "alt2",
 235         [BCM2835_FSEL_ALT3] = "alt3",
 236         [BCM2835_FSEL_ALT4] = "alt4",
 237         [BCM2835_FSEL_ALT5] = "alt5",
 238 };
 239
 240 static const char * const irq_type_names[] = {
 241         [IRQ_TYPE_NONE] = "none",
 242         [IRQ_TYPE_EDGE_RISING] = "edge-rising",
 243         [IRQ_TYPE_EDGE_FALLING] = "edge-falling",
 244         [IRQ_TYPE_EDGE_BOTH] = "edge-both",
 245         [IRQ_TYPE_LEVEL_HIGH] = "level-high",
 246         [IRQ_TYPE_LEVEL_LOW] = "level-low",
 247 };
 248
 249 static inline u32 bcm2835_gpio_rd(struct bcm2835_pinctrl *pc, unsigned reg)
 250 {
 251         return readl(pc->base + reg);
 252 }
 253
 254 static inline void bcm2835_gpio_wr(struct bcm2835_pinctrl *pc, unsigned reg,
 255                 u32 val)
 256 {
 257         writel(val, pc->base + reg);
 258 }
 259
 260 static inline int bcm2835_gpio_get_bit(struct bcm2835_pinctrl *pc, unsigned reg,
 261                 unsigned bit)
 262 {
 263         reg += GPIO_REG_OFFSET(bit) * 4;
 264         return (bcm2835_gpio_rd(pc, reg) >> GPIO_REG_SHIFT(bit)) & 1;
 265 }
 266
 267 /* note NOT a read/modify/write cycle */
 268 static inline void bcm2835_gpio_set_bit(struct bcm2835_pinctrl *pc,
 269                 unsigned reg, unsigned bit)
 270 {
 271         reg += GPIO_REG_OFFSET(bit) * 4;
 272         bcm2835_gpio_wr(pc, reg, BIT(GPIO_REG_SHIFT(bit)));
 273 }
 274
 275 static inline enum bcm2835_fsel bcm2835_pinctrl_fsel_get(
 276                 struct bcm2835_pinctrl *pc, unsigned pin)
 277 {
 278         u32 val = bcm2835_gpio_rd(pc, FSEL_REG(pin));
 279         enum bcm2835_fsel status = (val >> FSEL_SHIFT(pin)) & BCM2835_FSEL_MASK;
 280
 281         dev_dbg(pc->dev, "get %08x (%u => %s)\n", val, pin,
 282                         bcm2835_functions[status]);
 283
 284         return status;
 285 }
 286
 287 static inline void bcm2835_pinctrl_fsel_set(
 288                 struct bcm2835_pinctrl *pc, unsigned pin,
 289                 enum bcm2835_fsel fsel)
 290 {
 291         u32 val = bcm2835_gpio_rd(pc, FSEL_REG(pin));
 292         enum bcm2835_fsel cur = (val >> FSEL_SHIFT(pin)) & BCM2835_FSEL_MASK;
 293
 294         dev_dbg(pc->dev, "read %08x (%u => %s)\n", val, pin,
 295                         bcm2835_functions[cur]);
 296
 297         if (cur == fsel)
 298                 return;
 299
 300         if (cur != BCM2835_FSEL_GPIO_IN && fsel != BCM2835_FSEL_GPIO_IN) {
 301                 /* always transition through GPIO_IN */
 302                 val &= ~(BCM2835_FSEL_MASK << FSEL_SHIFT(pin));
 303                 val |= BCM2835_FSEL_GPIO_IN << FSEL_SHIFT(pin);
 304
 305                 dev_dbg(pc->dev, "trans %08x (%u <= %s)\n", val, pin,
 306                                 bcm2835_functions[BCM2835_FSEL_GPIO_IN]);
 307                 bcm2835_gpio_wr(pc, FSEL_REG(pin), val);
 308         }
 309
 310         val &= ~(BCM2835_FSEL_MASK << FSEL_SHIFT(pin));
 311         val |= fsel << FSEL_SHIFT(pin);
 312
 313         dev_dbg(pc->dev, "write %08x (%u <= %s)\n", val, pin,
 314                         bcm2835_functions[fsel]);
 315         bcm2835_gpio_wr(pc, FSEL_REG(pin), val);
 316 }
 317
 318 static int bcm2835_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 319 {
 320         return pinctrl_gpio_direction_input(chip->base + offset);
 321 }
 322
 323 static int bcm2835_gpio_get(struct gpio_chip *chip, unsigned offset)
 324 {
 325         struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 326
 327         return bcm2835_gpio_get_bit(pc, GPLEV0, offset);
 328 }
 329
 330 static int bcm2835_gpio_get_direction(struct gpio_chip *chip, unsigned int offset)
 331 {
 332         struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 333         enum bcm2835_fsel fsel = bcm2835_pinctrl_fsel_get(pc, offset);
 334
 335         /* Alternative function doesn't clearly provide a direction */
 336         if (fsel > BCM2835_FSEL_GPIO_OUT)
 337                 return -EINVAL;
 338
 339         return (fsel == BCM2835_FSEL_GPIO_IN);
 340 }
 341
 342 static void bcm2835_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 343 {
 344         struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 345
 346         bcm2835_gpio_set_bit(pc, value ? GPSET0 : GPCLR0, offset);
 347 }
 348
 349 static int bcm2835_gpio_direction_output(struct gpio_chip *chip,
 350                 unsigned offset, int value)
 351 {
 352         bcm2835_gpio_set(chip, offset, value);
 353         return pinctrl_gpio_direction_output(chip->base + offset);
 354 }
 355
 356 static struct gpio_chip bcm2835_gpio_chip = {
 357         .label = MODULE_NAME,
 358         .owner = THIS_MODULE,
 359         .request = gpiochip_generic_request,
 360         .free = gpiochip_generic_free,
 361         .direction_input = bcm2835_gpio_direction_input,
 362         .direction_output = bcm2835_gpio_direction_output,
 363         .get_direction = bcm2835_gpio_get_direction,
 364         .get = bcm2835_gpio_get,
 365         .set = bcm2835_gpio_set,
 366         .base = -1,
 367         .ngpio = BCM2835_NUM_GPIOS,
 368         .can_sleep = false,
 369 };
 370
 371 static void bcm2835_gpio_irq_handle_bank(struct bcm2835_pinctrl *pc,
 372                                          unsigned int bank, u32 mask)
 373 {
 374         unsigned long events;
 375         unsigned offset;
 376         unsigned gpio;
 377         unsigned int type;
 378
 379         events = bcm2835_gpio_rd(pc, GPEDS0 + bank * 4);
 380         events &= mask;
 381         events &= pc->enabled_irq_map[bank];
 382         for_each_set_bit(offset, &events, 32) {
 383                 gpio = (32 * bank) + offset;
 384                 /* FIXME: no clue why the code looks up the type here */
 385                 type = pc->irq_type[gpio];
 386
 387                 generic_handle_irq(irq_linear_revmap(pc->gpio_chip.irqdomain,
 388                                                      gpio));
 389         }
 390 }
 391
 392 static void bcm2835_gpio_irq_handler(struct irq_desc *desc)
 393 {
 394         struct gpio_chip *chip = irq_desc_get_handler_data(desc);
 395         struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 396         struct irq_chip *host_chip = irq_desc_get_chip(desc);
 397         int irq = irq_desc_get_irq(desc);
 398         int group;
 399         int i;
 400
 401         for (i = 0; i < ARRAY_SIZE(pc->irq); i++) {
 402                 if (pc->irq[i] == irq) {
 403                         group = pc->irq_group[i];
 404                         break;
 405                 }
 406         }
 407         /* This should not happen, every IRQ has a bank */
 408         if (i == ARRAY_SIZE(pc->irq))
 409                 BUG();
 410
 411         chained_irq_enter(host_chip, desc);
 412
 413         switch (group) {
 414         case 0: /* IRQ0 covers GPIOs 0-27 */
 415                 bcm2835_gpio_irq_handle_bank(pc, 0, 0x0fffffff);
 416                 break;
 417         case 1: /* IRQ1 covers GPIOs 28-45 */
 418                 bcm2835_gpio_irq_handle_bank(pc, 0, 0xf0000000);
 419                 bcm2835_gpio_irq_handle_bank(pc, 1, 0x00003fff);
 420                 break;
 421         case 2: /* IRQ2 covers GPIOs 46-53 */
 422                 bcm2835_gpio_irq_handle_bank(pc, 1, 0x003fc000);
 423                 break;
 424         }
 425
 426         chained_irq_exit(host_chip, desc);
 427 }
 428
 429 static inline void __bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc,
 430         unsigned reg, unsigned offset, bool enable)
 431 {
 432         u32 value;
 433         reg += GPIO_REG_OFFSET(offset) * 4;
 434         value = bcm2835_gpio_rd(pc, reg);
 435         if (enable)
 436                 value |= BIT(GPIO_REG_SHIFT(offset));
 437         else
 438                 value &= ~(BIT(GPIO_REG_SHIFT(offset)));
 439         bcm2835_gpio_wr(pc, reg, value);
 440 }
 441
 442 /* fast path for IRQ handler */
 443 static void bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc,
 444         unsigned offset, bool enable)
 445 {
 446         switch (pc->irq_type[offset]) {
 447         case IRQ_TYPE_EDGE_RISING:
 448                 __bcm2835_gpio_irq_config(pc, GPREN0, offset, enable);
 449                 break;
 450
 451         case IRQ_TYPE_EDGE_FALLING:
 452                 __bcm2835_gpio_irq_config(pc, GPFEN0, offset, enable);
 453                 break;
 454
 455         case IRQ_TYPE_EDGE_BOTH:
 456                 __bcm2835_gpio_irq_config(pc, GPREN0, offset, enable);
 457                 __bcm2835_gpio_irq_config(pc, GPFEN0, offset, enable);
 458                 break;
 459
 460         case IRQ_TYPE_LEVEL_HIGH:
 461                 __bcm2835_gpio_irq_config(pc, GPHEN0, offset, enable);
 462                 break;
 463
 464         case IRQ_TYPE_LEVEL_LOW:
 465                 __bcm2835_gpio_irq_config(pc, GPLEN0, offset, enable);
 466                 break;
 467         }
 468 }
 469
 470 static void bcm2835_gpio_irq_enable(struct irq_data *data)
 471 {
 472         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
 473         struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 474         unsigned gpio = irqd_to_hwirq(data);
 475         unsigned offset = GPIO_REG_SHIFT(gpio);
 476         unsigned bank = GPIO_REG_OFFSET(gpio);
 477         unsigned long flags;
 478
 479         spin_lock_irqsave(&pc->irq_lock[bank], flags);
 480         set_bit(offset, &pc->enabled_irq_map[bank]);
 481         bcm2835_gpio_irq_config(pc, gpio, true);
 482         spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
 483 }
 484
 485 static void bcm2835_gpio_irq_disable(struct irq_data *data)
 486 {
 487         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
 488         struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 489         unsigned gpio = irqd_to_hwirq(data);
 490         unsigned offset = GPIO_REG_SHIFT(gpio);
 491         unsigned bank = GPIO_REG_OFFSET(gpio);
 492         unsigned long flags;
 493
 494         spin_lock_irqsave(&pc->irq_lock[bank], flags);
 495         bcm2835_gpio_irq_config(pc, gpio, false);
 496         /* Clear events that were latched prior to clearing event sources */
 497         bcm2835_gpio_set_bit(pc, GPEDS0, gpio);
 498         clear_bit(offset, &pc->enabled_irq_map[bank]);
 499         spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
 500 }
 501
 502 static int __bcm2835_gpio_irq_set_type_disabled(struct bcm2835_pinctrl *pc,
 503         unsigned offset, unsigned int type)
 504 {
 505         switch (type) {
 506         case IRQ_TYPE_NONE:
 507         case IRQ_TYPE_EDGE_RISING:
 508         case IRQ_TYPE_EDGE_FALLING:
 509         case IRQ_TYPE_EDGE_BOTH:
 510         case IRQ_TYPE_LEVEL_HIGH:
 511         case IRQ_TYPE_LEVEL_LOW:
 512                 pc->irq_type[offset] = type;
 513                 break;
 514
 515         default:
 516                 return -EINVAL;
 517         }
 518         return 0;
 519 }
 520
 521 /* slower path for reconfiguring IRQ type */
 522 static int __bcm2835_gpio_irq_set_type_enabled(struct bcm2835_pinctrl *pc,
 523         unsigned offset, unsigned int type)
 524 {
 525         switch (type) {
 526         case IRQ_TYPE_NONE:
 527                 if (pc->irq_type[offset] != type) {
 528                         bcm2835_gpio_irq_config(pc, offset, false);
 529                         pc->irq_type[offset] = type;
 530                 }
 531                 break;
 532
 533         case IRQ_TYPE_EDGE_RISING:
 534                 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_BOTH) {
 535                         /* RISING already enabled, disable FALLING */
 536                         pc->irq_type[offset] = IRQ_TYPE_EDGE_FALLING;
 537                         bcm2835_gpio_irq_config(pc, offset, false);
 538                         pc->irq_type[offset] = type;
 539                 } else if (pc->irq_type[offset] != type) {
 540                         bcm2835_gpio_irq_config(pc, offset, false);
 541                         pc->irq_type[offset] = type;
 542                         bcm2835_gpio_irq_config(pc, offset, true);
 543                 }
 544                 break;
 545
 546         case IRQ_TYPE_EDGE_FALLING:
 547                 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_BOTH) {
 548                         /* FALLING already enabled, disable RISING */
 549                         pc->irq_type[offset] = IRQ_TYPE_EDGE_RISING;
 550                         bcm2835_gpio_irq_config(pc, offset, false);
 551                         pc->irq_type[offset] = type;
 552                 } else if (pc->irq_type[offset] != type) {
 553                         bcm2835_gpio_irq_config(pc, offset, false);
 554                         pc->irq_type[offset] = type;
 555                         bcm2835_gpio_irq_config(pc, offset, true);
 556                 }
 557                 break;
 558
 559         case IRQ_TYPE_EDGE_BOTH:
 560                 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_RISING) {
 561                         /* RISING already enabled, enable FALLING too */
 562                         pc->irq_type[offset] = IRQ_TYPE_EDGE_FALLING;
 563                         bcm2835_gpio_irq_config(pc, offset, true);
 564                         pc->irq_type[offset] = type;
 565                 } else if (pc->irq_type[offset] == IRQ_TYPE_EDGE_FALLING) {
 566                         /* FALLING already enabled, enable RISING too */
 567                         pc->irq_type[offset] = IRQ_TYPE_EDGE_RISING;
 568                         bcm2835_gpio_irq_config(pc, offset, true);
 569                         pc->irq_type[offset] = type;
 570                 } else if (pc->irq_type[offset] != type) {
 571                         bcm2835_gpio_irq_config(pc, offset, false);
 572                         pc->irq_type[offset] = type;
 573                         bcm2835_gpio_irq_config(pc, offset, true);
 574                 }
 575                 break;
 576
 577         case IRQ_TYPE_LEVEL_HIGH:
 578         case IRQ_TYPE_LEVEL_LOW:
 579                 if (pc->irq_type[offset] != type) {
 580                         bcm2835_gpio_irq_config(pc, offset, false);
 581                         pc->irq_type[offset] = type;
 582                         bcm2835_gpio_irq_config(pc, offset, true);
 583                 }
 584                 break;
 585
 586         default:
 587                 return -EINVAL;
 588         }
 589         return 0;
 590 }
 591
 592 static int bcm2835_gpio_irq_set_type(struct irq_data *data, unsigned int type)
 593 {
 594         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
 595         struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 596         unsigned gpio = irqd_to_hwirq(data);
 597         unsigned offset = GPIO_REG_SHIFT(gpio);
 598         unsigned bank = GPIO_REG_OFFSET(gpio);
 599         unsigned long flags;
 600         int ret;
 601
 602         spin_lock_irqsave(&pc->irq_lock[bank], flags);
 603
 604         if (test_bit(offset, &pc->enabled_irq_map[bank]))
 605                 ret = __bcm2835_gpio_irq_set_type_enabled(pc, gpio, type);
 606         else
 607                 ret = __bcm2835_gpio_irq_set_type_disabled(pc, gpio, type);
 608
 609         if (type & IRQ_TYPE_EDGE_BOTH)
 610                 irq_set_handler_locked(data, handle_edge_irq);
 611         else
 612                 irq_set_handler_locked(data, handle_level_irq);
 613
 614         spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
 615
 616         return ret;
 617 }
 618
 619 static void bcm2835_gpio_irq_ack(struct irq_data *data)
 620 {
 621         struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
 622         struct bcm2835_pinctrl *pc = gpiochip_get_data(chip);
 623         unsigned gpio = irqd_to_hwirq(data);
 624
 625         bcm2835_gpio_set_bit(pc, GPEDS0, gpio);
 626 }
 627
 628 static struct irq_chip bcm2835_gpio_irq_chip = {
 629         .name = MODULE_NAME,
 630         .irq_enable = bcm2835_gpio_irq_enable,
 631         .irq_disable = bcm2835_gpio_irq_disable,
 632         .irq_set_type = bcm2835_gpio_irq_set_type,
 633         .irq_ack = bcm2835_gpio_irq_ack,
 634         .irq_mask = bcm2835_gpio_irq_disable,
 635         .irq_unmask = bcm2835_gpio_irq_enable,
 636 };
 637
 638 static int bcm2835_pctl_get_groups_count(struct pinctrl_dev *pctldev)
 639 {
 640         return ARRAY_SIZE(bcm2835_gpio_groups);
 641 }
 642
 643 static const char *bcm2835_pctl_get_group_name(struct pinctrl_dev *pctldev,
 644                 unsigned selector)
 645 {
 646         return bcm2835_gpio_groups[selector];
 647 }
 648
 649 static int bcm2835_pctl_get_group_pins(struct pinctrl_dev *pctldev,
 650                 unsigned selector,
 651                 const unsigned **pins,
 652                 unsigned *num_pins)
 653 {
 654         *pins = &bcm2835_gpio_pins[selector].number;
 655         *num_pins = 1;
 656
 657         return 0;
 658 }
 659
 660 static void bcm2835_pctl_pin_dbg_show(struct pinctrl_dev *pctldev,
 661                 struct seq_file *s,
 662                 unsigned offset)
 663 {
 664         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
 665         struct gpio_chip *chip = &pc->gpio_chip;
 666         enum bcm2835_fsel fsel = bcm2835_pinctrl_fsel_get(pc, offset);
 667         const char *fname = bcm2835_functions[fsel];
 668         int value = bcm2835_gpio_get_bit(pc, GPLEV0, offset);
 669         int irq = irq_find_mapping(chip->irqdomain, offset);
 670
 671         seq_printf(s, "function %s in %s; irq %d (%s)",
 672                 fname, value ? "hi" : "lo",
 673                 irq, irq_type_names[pc->irq_type[offset]]);
 674 }
 675
 676 static void bcm2835_pctl_dt_free_map(struct pinctrl_dev *pctldev,
 677                 struct pinctrl_map *maps, unsigned num_maps)
 678 {
 679         int i;
 680
 681         for (i = 0; i < num_maps; i++)
 682                 if (maps[i].type == PIN_MAP_TYPE_CONFIGS_PIN)
 683                         kfree(maps[i].data.configs.configs);
 684
 685         kfree(maps);
 686 }
 687
 688 static int bcm2835_pctl_dt_node_to_map_func(struct bcm2835_pinctrl *pc,
 689                 struct device_node *np, u32 pin, u32 fnum,
 690                 struct pinctrl_map **maps)
 691 {
 692         struct pinctrl_map *map = *maps;
 693
 694         if (fnum >= ARRAY_SIZE(bcm2835_functions)) {
 695                 dev_err(pc->dev, "%s: invalid brcm,function %d\n",
 696                         of_node_full_name(np), fnum);
 697                 return -EINVAL;
 698         }
 699
 700         map->type = PIN_MAP_TYPE_MUX_GROUP;
 701         map->data.mux.group = bcm2835_gpio_groups[pin];
 702         map->data.mux.function = bcm2835_functions[fnum];
 703         (*maps)++;
 704
 705         return 0;
 706 }
 707
 708 static int bcm2835_pctl_dt_node_to_map_pull(struct bcm2835_pinctrl *pc,
 709                 struct device_node *np, u32 pin, u32 pull,
 710                 struct pinctrl_map **maps)
 711 {
 712         struct pinctrl_map *map = *maps;
 713         unsigned long *configs;
 714
 715         if (pull > 2) {
 716                 dev_err(pc->dev, "%s: invalid brcm,pull %d\n",
 717                         of_node_full_name(np), pull);
 718                 return -EINVAL;
 719         }
 720
 721         configs = kzalloc(sizeof(*configs), GFP_KERNEL);
 722         if (!configs)
 723                 return -ENOMEM;
 724         configs[0] = BCM2835_PINCONF_PACK(BCM2835_PINCONF_PARAM_PULL, pull);
 725
 726         map->type = PIN_MAP_TYPE_CONFIGS_PIN;
 727         map->data.configs.group_or_pin = bcm2835_gpio_pins[pin].name;
 728         map->data.configs.configs = configs;
 729         map->data.configs.num_configs = 1;
 730         (*maps)++;
 731
 732         return 0;
 733 }
 734
 735 static int bcm2835_pctl_dt_node_to_map(struct pinctrl_dev *pctldev,
 736                 struct device_node *np,
 737                 struct pinctrl_map **map, unsigned *num_maps)
 738 {
 739         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
 740         struct property *pins, *funcs, *pulls;
 741         int num_pins, num_funcs, num_pulls, maps_per_pin;
 742         struct pinctrl_map *maps, *cur_map;
 743         int i, err;
 744         u32 pin, func, pull;
 745
 746         pins = of_find_property(np, "brcm,pins", NULL);
 747         if (!pins) {
 748                 dev_err(pc->dev, "%s: missing brcm,pins property\n",
 749                                 of_node_full_name(np));
 750                 return -EINVAL;
 751         }
 752
 753         funcs = of_find_property(np, "brcm,function", NULL);
 754         pulls = of_find_property(np, "brcm,pull", NULL);
 755
 756         if (!funcs && !pulls) {
 757                 dev_err(pc->dev,
 758                         "%s: neither brcm,function nor brcm,pull specified\n",
 759                         of_node_full_name(np));
 760                 return -EINVAL;
 761         }
 762
 763         num_pins = pins->length / 4;
 764         num_funcs = funcs ? (funcs->length / 4) : 0;
 765         num_pulls = pulls ? (pulls->length / 4) : 0;
 766
 767         if (num_funcs > 1 && num_funcs != num_pins) {
 768                 dev_err(pc->dev,
 769                         "%s: brcm,function must have 1 or %d entries\n",
 770                         of_node_full_name(np), num_pins);
 771                 return -EINVAL;
 772         }
 773
 774         if (num_pulls > 1 && num_pulls != num_pins) {
 775                 dev_err(pc->dev,
 776                         "%s: brcm,pull must have 1 or %d entries\n",
 777                         of_node_full_name(np), num_pins);
 778                 return -EINVAL;
 779         }
 780
 781         maps_per_pin = 0;
 782         if (num_funcs)
 783                 maps_per_pin++;
 784         if (num_pulls)
 785                 maps_per_pin++;
 786         cur_map = maps = kzalloc(num_pins * maps_per_pin * sizeof(*maps),
 787                                 GFP_KERNEL);
 788         if (!maps)
 789                 return -ENOMEM;
 790
 791         for (i = 0; i < num_pins; i++) {
 792                 err = of_property_read_u32_index(np, "brcm,pins", i, &pin);
 793                 if (err)
 794                         goto out;
 795                 if (pin >= ARRAY_SIZE(bcm2835_gpio_pins)) {
 796                         dev_err(pc->dev, "%s: invalid brcm,pins value %d\n",
 797                                 of_node_full_name(np), pin);
 798                         err = -EINVAL;
 799                         goto out;
 800                 }
 801
 802                 if (num_funcs) {
 803                         err = of_property_read_u32_index(np, "brcm,function",
 804                                         (num_funcs > 1) ? i : 0, &func);
 805                         if (err)
 806                                 goto out;
 807                         err = bcm2835_pctl_dt_node_to_map_func(pc, np, pin,
 808                                                         func, &cur_map);
 809                         if (err)
 810                                 goto out;
 811                 }
 812                 if (num_pulls) {
 813                         err = of_property_read_u32_index(np, "brcm,pull",
 814                                         (num_pulls > 1) ? i : 0, &pull);
 815                         if (err)
 816                                 goto out;
 817                         err = bcm2835_pctl_dt_node_to_map_pull(pc, np, pin,
 818                                                         pull, &cur_map);
 819                         if (err)
 820                                 goto out;
 821                 }
 822         }
 823
 824         *map = maps;
 825         *num_maps = num_pins * maps_per_pin;
 826
 827         return 0;
 828
 829 out:
 830         bcm2835_pctl_dt_free_map(pctldev, maps, num_pins * maps_per_pin);
 831         return err;
 832 }
 833
 834 static const struct pinctrl_ops bcm2835_pctl_ops = {
 835         .get_groups_count = bcm2835_pctl_get_groups_count,
 836         .get_group_name = bcm2835_pctl_get_group_name,
 837         .get_group_pins = bcm2835_pctl_get_group_pins,
 838         .pin_dbg_show = bcm2835_pctl_pin_dbg_show,
 839         .dt_node_to_map = bcm2835_pctl_dt_node_to_map,
 840         .dt_free_map = bcm2835_pctl_dt_free_map,
 841 };
 842
 843 static int bcm2835_pmx_free(struct pinctrl_dev *pctldev,
 844                 unsigned offset)
 845 {
 846         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
 847
 848         /* disable by setting to GPIO_IN */
 849         bcm2835_pinctrl_fsel_set(pc, offset, BCM2835_FSEL_GPIO_IN);
 850         return 0;
 851 }
 852
 853 static int bcm2835_pmx_get_functions_count(struct pinctrl_dev *pctldev)
 854 {
 855         return BCM2835_FSEL_COUNT;
 856 }
 857
 858 static const char *bcm2835_pmx_get_function_name(struct pinctrl_dev *pctldev,
 859                 unsigned selector)
 860 {
 861         return bcm2835_functions[selector];
 862 }
 863
 864 static int bcm2835_pmx_get_function_groups(struct pinctrl_dev *pctldev,
 865                 unsigned selector,
 866                 const char * const **groups,
 867                 unsigned * const num_groups)
 868 {
 869         /* every pin can do every function */
 870         *groups = bcm2835_gpio_groups;
 871         *num_groups = ARRAY_SIZE(bcm2835_gpio_groups);
 872
 873         return 0;
 874 }
 875
 876 static int bcm2835_pmx_set(struct pinctrl_dev *pctldev,
 877                 unsigned func_selector,
 878                 unsigned group_selector)
 879 {
 880         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
 881
 882         bcm2835_pinctrl_fsel_set(pc, group_selector, func_selector);
 883
 884         return 0;
 885 }
 886
 887 static void bcm2835_pmx_gpio_disable_free(struct pinctrl_dev *pctldev,
 888                 struct pinctrl_gpio_range *range,
 889                 unsigned offset)
 890 {
 891         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
 892
 893         /* disable by setting to GPIO_IN */
 894         bcm2835_pinctrl_fsel_set(pc, offset, BCM2835_FSEL_GPIO_IN);
 895 }
 896
 897 static int bcm2835_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
 898                 struct pinctrl_gpio_range *range,
 899                 unsigned offset,
 900                 bool input)
 901 {
 902         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
 903         enum bcm2835_fsel fsel = input ?
 904                 BCM2835_FSEL_GPIO_IN : BCM2835_FSEL_GPIO_OUT;
 905
 906         bcm2835_pinctrl_fsel_set(pc, offset, fsel);
 907
 908         return 0;
 909 }
 910
 911 static const struct pinmux_ops bcm2835_pmx_ops = {
 912         .free = bcm2835_pmx_free,
 913         .get_functions_count = bcm2835_pmx_get_functions_count,
 914         .get_function_name = bcm2835_pmx_get_function_name,
 915         .get_function_groups = bcm2835_pmx_get_function_groups,
 916         .set_mux = bcm2835_pmx_set,
 917         .gpio_disable_free = bcm2835_pmx_gpio_disable_free,
 918         .gpio_set_direction = bcm2835_pmx_gpio_set_direction,
 919 };
 920
 921 static int bcm2835_pinconf_get(struct pinctrl_dev *pctldev,
 922                         unsigned pin, unsigned long *config)
 923 {
 924         /* No way to read back config in HW */
 925         return -ENOTSUPP;
 926 }
 927
 928 static int bcm2835_pinconf_set(struct pinctrl_dev *pctldev,
 929                         unsigned pin, unsigned long *configs,
 930                         unsigned num_configs)
 931 {
 932         struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
 933         enum bcm2835_pinconf_param param;
 934         u16 arg;
 935         u32 off, bit;
 936         int i;
 937
 938         for (i = 0; i < num_configs; i++) {
 939                 param = BCM2835_PINCONF_UNPACK_PARAM(configs[i]);
 940                 arg = BCM2835_PINCONF_UNPACK_ARG(configs[i]);
 941
 942                 if (param != BCM2835_PINCONF_PARAM_PULL)
 943                         return -EINVAL;
 944
 945                 off = GPIO_REG_OFFSET(pin);
 946                 bit = GPIO_REG_SHIFT(pin);
 947
 948                 bcm2835_gpio_wr(pc, GPPUD, arg & 3);
 949                 /*
 950                  * BCM2835 datasheet say to wait 150 cycles, but not of what.
 951                  * But the VideoCore firmware delay for this operation
 952                  * based nearly on the same amount of VPU cycles and this clock
 953                  * runs at 250 MHz.
 954                  */
 955                 udelay(1);
 956                 bcm2835_gpio_wr(pc, GPPUDCLK0 + (off * 4), BIT(bit));
 957                 udelay(1);
 958                 bcm2835_gpio_wr(pc, GPPUDCLK0 + (off * 4), 0);
 959         } /* for each config */
 960
 961         return 0;
 962 }
 963
 964 static const struct pinconf_ops bcm2835_pinconf_ops = {
 965         .pin_config_get = bcm2835_pinconf_get,
 966         .pin_config_set = bcm2835_pinconf_set,
 967 };
 968
 969 static struct pinctrl_desc bcm2835_pinctrl_desc = {
 970         .name = MODULE_NAME,
 971         .pins = bcm2835_gpio_pins,
 972         .npins = ARRAY_SIZE(bcm2835_gpio_pins),
 973         .pctlops = &bcm2835_pctl_ops,
 974         .pmxops = &bcm2835_pmx_ops,
 975         .confops = &bcm2835_pinconf_ops,
 976         .owner = THIS_MODULE,
 977 };
 978
 979 static struct pinctrl_gpio_range bcm2835_pinctrl_gpio_range = {
 980         .name = MODULE_NAME,
 981         .npins = BCM2835_NUM_GPIOS,
 982 };
 983
 984 static int bcm2835_pinctrl_probe(struct platform_device *pdev)
 985 {
 986         struct device *dev = &pdev->dev;
 987         struct device_node *np = dev->of_node;
 988         struct bcm2835_pinctrl *pc;
 989         struct resource iomem;
 990         int err, i;
 991         BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_pins) != BCM2835_NUM_GPIOS);
 992         BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_groups) != BCM2835_NUM_GPIOS);
 993
 994         pc = devm_kzalloc(dev, sizeof(*pc), GFP_KERNEL);
 995         if (!pc)
 996                 return -ENOMEM;
 997
 998         platform_set_drvdata(pdev, pc);
 999         pc->dev = dev;
1000
1001         err = of_address_to_resource(np, 0, &iomem);
1002         if (err) {
1003                 dev_err(dev, "could not get IO memory\n");
1004                 return err;
1005         }
1006
1007         pc->base = devm_ioremap_resource(dev, &iomem);
1008         if (IS_ERR(pc->base))
1009                 return PTR_ERR(pc->base);
1010
1011         pc->gpio_chip = bcm2835_gpio_chip;
1012         pc->gpio_chip.parent = dev;
1013         pc->gpio_chip.of_node = np;
1014
1015         for (i = 0; i < BCM2835_NUM_BANKS; i++) {
1016                 unsigned long events;
1017                 unsigned offset;
1018
1019                 /* clear event detection flags */
1020                 bcm2835_gpio_wr(pc, GPREN0 + i * 4, 0);
1021                 bcm2835_gpio_wr(pc, GPFEN0 + i * 4, 0);
1022                 bcm2835_gpio_wr(pc, GPHEN0 + i * 4, 0);
1023                 bcm2835_gpio_wr(pc, GPLEN0 + i * 4, 0);
1024                 bcm2835_gpio_wr(pc, GPAREN0 + i * 4, 0);
1025                 bcm2835_gpio_wr(pc, GPAFEN0 + i * 4, 0);
1026
1027                 /* clear all the events */
1028                 events = bcm2835_gpio_rd(pc, GPEDS0 + i * 4);
1029                 for_each_set_bit(offset, &events, 32)
1030                         bcm2835_gpio_wr(pc, GPEDS0 + i * 4, BIT(offset));
1031
1032                 spin_lock_init(&pc->irq_lock[i]);
1033         }
1034
1035         err = gpiochip_add_data(&pc->gpio_chip, pc);
1036         if (err) {
1037                 dev_err(dev, "could not add GPIO chip\n");
1038                 return err;
1039         }
1040
1041         err = gpiochip_irqchip_add(&pc->gpio_chip, &bcm2835_gpio_irq_chip,
1042                                    0, handle_level_irq, IRQ_TYPE_NONE);
1043         if (err) {
1044                 dev_info(dev, "could not add irqchip\n");
1045                 return err;
1046         }
1047
1048         for (i = 0; i < BCM2835_NUM_IRQS; i++) {
1049                 pc->irq[i] = irq_of_parse_and_map(np, i);
1050                 pc->irq_group[i] = i;
1051                 /*
1052                  * Use the same handler for all groups: this is necessary
1053                  * since we use one gpiochip to cover all lines - the
1054                  * irq handler then needs to figure out which group and
1055                  * bank that was firing the IRQ and look up the per-group
1056                  * and bank data.
1057                  */
1058                 gpiochip_set_chained_irqchip(&pc->gpio_chip,
1059                                              &bcm2835_gpio_irq_chip,
1060                                              pc->irq[i],
1061                                              bcm2835_gpio_irq_handler);
1062         }
1063
1064         pc->pctl_dev = devm_pinctrl_register(dev, &bcm2835_pinctrl_desc, pc);
1065         if (IS_ERR(pc->pctl_dev)) {
1066                 gpiochip_remove(&pc->gpio_chip);
1067                 return PTR_ERR(pc->pctl_dev);
1068         }
1069
1070         pc->gpio_range = bcm2835_pinctrl_gpio_range;
1071         pc->gpio_range.base = pc->gpio_chip.base;
1072         pc->gpio_range.gc = &pc->gpio_chip;
1073         pinctrl_add_gpio_range(pc->pctl_dev, &pc->gpio_range);
1074
1075         return 0;
1076 }
1077
1078 static int bcm2835_pinctrl_remove(struct platform_device *pdev)
1079 {
1080         struct bcm2835_pinctrl *pc = platform_get_drvdata(pdev);
1081
1082         gpiochip_remove(&pc->gpio_chip);
1083
1084         return 0;
1085 }
1086
1087 static const struct of_device_id bcm2835_pinctrl_match[] = {
1088         { .compatible = "brcm,bcm2835-gpio" },
1089         {}
1090 };
1091 MODULE_DEVICE_TABLE(of, bcm2835_pinctrl_match);
1092
1093 static struct platform_driver bcm2835_pinctrl_driver = {
1094         .probe = bcm2835_pinctrl_probe,
1095         .remove = bcm2835_pinctrl_remove,
1096         .driver = {
1097                 .name = MODULE_NAME,
1098                 .of_match_table = bcm2835_pinctrl_match,
1099         },
1100 };
1101 module_platform_driver(bcm2835_pinctrl_driver);
1102
1103 MODULE_AUTHOR("Chris Boot, Simon Arlott, Stephen Warren");
1104 MODULE_DESCRIPTION("BCM2835 Pin control driver");
1105 MODULE_LICENSE("GPL");