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