1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Driver for Broadcom BCM2835 GPIO unit (pinctrl + GPIO) 4 * 5 * Copyright (C) 2012 Chris Boot, Simon Arlott, Stephen Warren 6 * 7 * This driver is inspired by: 8 * pinctrl-nomadik.c, please see original file for copyright information 9 * pinctrl-tegra.c, please see original file for copyright information 10 */ 11 12 #include <linux/bitmap.h> 13 #include <linux/bug.h> 14 #include <linux/delay.h> 15 #include <linux/device.h> 16 #include <linux/err.h> 17 #include <linux/gpio/driver.h> 18 #include <linux/io.h> 19 #include <linux/irq.h> 20 #include <linux/irqdesc.h> 21 #include <linux/init.h> 22 #include <linux/of_address.h> 23 #include <linux/of.h> 24 #include <linux/of_irq.h> 25 #include <linux/pinctrl/consumer.h> 26 #include <linux/pinctrl/machine.h> 27 #include <linux/pinctrl/pinconf.h> 28 #include <linux/pinctrl/pinctrl.h> 29 #include <linux/pinctrl/pinmux.h> 30 #include <linux/pinctrl/pinconf-generic.h> 31 #include <linux/platform_device.h> 32 #include <linux/seq_file.h> 33 #include <linux/slab.h> 34 #include <linux/spinlock.h> 35 #include <linux/types.h> 36 #include <dt-bindings/pinctrl/bcm2835.h> 37 38 #define MODULE_NAME "pinctrl-bcm2835" 39 #define BCM2835_NUM_GPIOS 54 40 #define BCM2711_NUM_GPIOS 58 41 #define BCM2835_NUM_BANKS 2 42 #define BCM2835_NUM_IRQS 3 43 44 /* GPIO register offsets */ 45 #define GPFSEL0 0x0 /* Function Select */ 46 #define GPSET0 0x1c /* Pin Output Set */ 47 #define GPCLR0 0x28 /* Pin Output Clear */ 48 #define GPLEV0 0x34 /* Pin Level */ 49 #define GPEDS0 0x40 /* Pin Event Detect Status */ 50 #define GPREN0 0x4c /* Pin Rising Edge Detect Enable */ 51 #define GPFEN0 0x58 /* Pin Falling Edge Detect Enable */ 52 #define GPHEN0 0x64 /* Pin High Detect Enable */ 53 #define GPLEN0 0x70 /* Pin Low Detect Enable */ 54 #define GPAREN0 0x7c /* Pin Async Rising Edge Detect */ 55 #define GPAFEN0 0x88 /* Pin Async Falling Edge Detect */ 56 #define GPPUD 0x94 /* Pin Pull-up/down Enable */ 57 #define GPPUDCLK0 0x98 /* Pin Pull-up/down Enable Clock */ 58 #define GP_GPIO_PUP_PDN_CNTRL_REG0 0xe4 /* 2711 Pin Pull-up/down select */ 59 60 #define FSEL_REG(p) (GPFSEL0 + (((p) / 10) * 4)) 61 #define FSEL_SHIFT(p) (((p) % 10) * 3) 62 #define GPIO_REG_OFFSET(p) ((p) / 32) 63 #define GPIO_REG_SHIFT(p) ((p) % 32) 64 65 #define PUD_2711_MASK 0x3 66 #define PUD_2711_REG_OFFSET(p) ((p) / 16) 67 #define PUD_2711_REG_SHIFT(p) (((p) % 16) * 2) 68 69 /* argument: bcm2835_pinconf_pull */ 70 #define BCM2835_PINCONF_PARAM_PULL (PIN_CONFIG_END + 1) 71 72 #define BCM2711_PULL_NONE 0x0 73 #define BCM2711_PULL_UP 0x1 74 #define BCM2711_PULL_DOWN 0x2 75 76 struct bcm2835_pinctrl { 77 struct device *dev; 78 void __iomem *base; 79 80 /* note: locking assumes each bank will have its own unsigned long */ 81 unsigned long enabled_irq_map[BCM2835_NUM_BANKS]; 82 unsigned int irq_type[BCM2711_NUM_GPIOS]; 83 84 struct pinctrl_dev *pctl_dev; 85 struct gpio_chip gpio_chip; 86 struct pinctrl_desc pctl_desc; 87 struct pinctrl_gpio_range gpio_range; 88 89 raw_spinlock_t irq_lock[BCM2835_NUM_BANKS]; 90 }; 91 92 /* pins are just named GPIO0..GPIO53 */ 93 #define BCM2835_GPIO_PIN(a) PINCTRL_PIN(a, "gpio" #a) 94 static struct pinctrl_pin_desc bcm2835_gpio_pins[] = { 95 BCM2835_GPIO_PIN(0), 96 BCM2835_GPIO_PIN(1), 97 BCM2835_GPIO_PIN(2), 98 BCM2835_GPIO_PIN(3), 99 BCM2835_GPIO_PIN(4), 100 BCM2835_GPIO_PIN(5), 101 BCM2835_GPIO_PIN(6), 102 BCM2835_GPIO_PIN(7), 103 BCM2835_GPIO_PIN(8), 104 BCM2835_GPIO_PIN(9), 105 BCM2835_GPIO_PIN(10), 106 BCM2835_GPIO_PIN(11), 107 BCM2835_GPIO_PIN(12), 108 BCM2835_GPIO_PIN(13), 109 BCM2835_GPIO_PIN(14), 110 BCM2835_GPIO_PIN(15), 111 BCM2835_GPIO_PIN(16), 112 BCM2835_GPIO_PIN(17), 113 BCM2835_GPIO_PIN(18), 114 BCM2835_GPIO_PIN(19), 115 BCM2835_GPIO_PIN(20), 116 BCM2835_GPIO_PIN(21), 117 BCM2835_GPIO_PIN(22), 118 BCM2835_GPIO_PIN(23), 119 BCM2835_GPIO_PIN(24), 120 BCM2835_GPIO_PIN(25), 121 BCM2835_GPIO_PIN(26), 122 BCM2835_GPIO_PIN(27), 123 BCM2835_GPIO_PIN(28), 124 BCM2835_GPIO_PIN(29), 125 BCM2835_GPIO_PIN(30), 126 BCM2835_GPIO_PIN(31), 127 BCM2835_GPIO_PIN(32), 128 BCM2835_GPIO_PIN(33), 129 BCM2835_GPIO_PIN(34), 130 BCM2835_GPIO_PIN(35), 131 BCM2835_GPIO_PIN(36), 132 BCM2835_GPIO_PIN(37), 133 BCM2835_GPIO_PIN(38), 134 BCM2835_GPIO_PIN(39), 135 BCM2835_GPIO_PIN(40), 136 BCM2835_GPIO_PIN(41), 137 BCM2835_GPIO_PIN(42), 138 BCM2835_GPIO_PIN(43), 139 BCM2835_GPIO_PIN(44), 140 BCM2835_GPIO_PIN(45), 141 BCM2835_GPIO_PIN(46), 142 BCM2835_GPIO_PIN(47), 143 BCM2835_GPIO_PIN(48), 144 BCM2835_GPIO_PIN(49), 145 BCM2835_GPIO_PIN(50), 146 BCM2835_GPIO_PIN(51), 147 BCM2835_GPIO_PIN(52), 148 BCM2835_GPIO_PIN(53), 149 BCM2835_GPIO_PIN(54), 150 BCM2835_GPIO_PIN(55), 151 BCM2835_GPIO_PIN(56), 152 BCM2835_GPIO_PIN(57), 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 "gpio54", 212 "gpio55", 213 "gpio56", 214 "gpio57", 215 }; 216 217 enum bcm2835_fsel { 218 BCM2835_FSEL_COUNT = 8, 219 BCM2835_FSEL_MASK = 0x7, 220 }; 221 222 static const char * const bcm2835_functions[BCM2835_FSEL_COUNT] = { 223 [BCM2835_FSEL_GPIO_IN] = "gpio_in", 224 [BCM2835_FSEL_GPIO_OUT] = "gpio_out", 225 [BCM2835_FSEL_ALT0] = "alt0", 226 [BCM2835_FSEL_ALT1] = "alt1", 227 [BCM2835_FSEL_ALT2] = "alt2", 228 [BCM2835_FSEL_ALT3] = "alt3", 229 [BCM2835_FSEL_ALT4] = "alt4", 230 [BCM2835_FSEL_ALT5] = "alt5", 231 }; 232 233 static const char * const irq_type_names[] = { 234 [IRQ_TYPE_NONE] = "none", 235 [IRQ_TYPE_EDGE_RISING] = "edge-rising", 236 [IRQ_TYPE_EDGE_FALLING] = "edge-falling", 237 [IRQ_TYPE_EDGE_BOTH] = "edge-both", 238 [IRQ_TYPE_LEVEL_HIGH] = "level-high", 239 [IRQ_TYPE_LEVEL_LOW] = "level-low", 240 }; 241 242 static inline u32 bcm2835_gpio_rd(struct bcm2835_pinctrl *pc, unsigned reg) 243 { 244 return readl(pc->base + reg); 245 } 246 247 static inline void bcm2835_gpio_wr(struct bcm2835_pinctrl *pc, unsigned reg, 248 u32 val) 249 { 250 writel(val, pc->base + reg); 251 } 252 253 static inline int bcm2835_gpio_get_bit(struct bcm2835_pinctrl *pc, unsigned reg, 254 unsigned bit) 255 { 256 reg += GPIO_REG_OFFSET(bit) * 4; 257 return (bcm2835_gpio_rd(pc, reg) >> GPIO_REG_SHIFT(bit)) & 1; 258 } 259 260 /* note NOT a read/modify/write cycle */ 261 static inline void bcm2835_gpio_set_bit(struct bcm2835_pinctrl *pc, 262 unsigned reg, unsigned bit) 263 { 264 reg += GPIO_REG_OFFSET(bit) * 4; 265 bcm2835_gpio_wr(pc, reg, BIT(GPIO_REG_SHIFT(bit))); 266 } 267 268 static inline enum bcm2835_fsel bcm2835_pinctrl_fsel_get( 269 struct bcm2835_pinctrl *pc, unsigned pin) 270 { 271 u32 val = bcm2835_gpio_rd(pc, FSEL_REG(pin)); 272 enum bcm2835_fsel status = (val >> FSEL_SHIFT(pin)) & BCM2835_FSEL_MASK; 273 274 dev_dbg(pc->dev, "get %08x (%u => %s)\n", val, pin, 275 bcm2835_functions[status]); 276 277 return status; 278 } 279 280 static inline void bcm2835_pinctrl_fsel_set( 281 struct bcm2835_pinctrl *pc, unsigned pin, 282 enum bcm2835_fsel fsel) 283 { 284 u32 val = bcm2835_gpio_rd(pc, FSEL_REG(pin)); 285 enum bcm2835_fsel cur = (val >> FSEL_SHIFT(pin)) & BCM2835_FSEL_MASK; 286 287 dev_dbg(pc->dev, "read %08x (%u => %s)\n", val, pin, 288 bcm2835_functions[cur]); 289 290 if (cur == fsel) 291 return; 292 293 if (cur != BCM2835_FSEL_GPIO_IN && fsel != BCM2835_FSEL_GPIO_IN) { 294 /* always transition through GPIO_IN */ 295 val &= ~(BCM2835_FSEL_MASK << FSEL_SHIFT(pin)); 296 val |= BCM2835_FSEL_GPIO_IN << FSEL_SHIFT(pin); 297 298 dev_dbg(pc->dev, "trans %08x (%u <= %s)\n", val, pin, 299 bcm2835_functions[BCM2835_FSEL_GPIO_IN]); 300 bcm2835_gpio_wr(pc, FSEL_REG(pin), val); 301 } 302 303 val &= ~(BCM2835_FSEL_MASK << FSEL_SHIFT(pin)); 304 val |= fsel << FSEL_SHIFT(pin); 305 306 dev_dbg(pc->dev, "write %08x (%u <= %s)\n", val, pin, 307 bcm2835_functions[fsel]); 308 bcm2835_gpio_wr(pc, FSEL_REG(pin), val); 309 } 310 311 static int bcm2835_gpio_direction_input(struct gpio_chip *chip, unsigned offset) 312 { 313 return pinctrl_gpio_direction_input(chip->base + offset); 314 } 315 316 static int bcm2835_gpio_get(struct gpio_chip *chip, unsigned offset) 317 { 318 struct bcm2835_pinctrl *pc = gpiochip_get_data(chip); 319 320 return bcm2835_gpio_get_bit(pc, GPLEV0, offset); 321 } 322 323 static int bcm2835_gpio_get_direction(struct gpio_chip *chip, unsigned int offset) 324 { 325 struct bcm2835_pinctrl *pc = gpiochip_get_data(chip); 326 enum bcm2835_fsel fsel = bcm2835_pinctrl_fsel_get(pc, offset); 327 328 /* Alternative function doesn't clearly provide a direction */ 329 if (fsel > BCM2835_FSEL_GPIO_OUT) 330 return -EINVAL; 331 332 if (fsel == BCM2835_FSEL_GPIO_IN) 333 return GPIO_LINE_DIRECTION_IN; 334 335 return GPIO_LINE_DIRECTION_OUT; 336 } 337 338 static void bcm2835_gpio_set(struct gpio_chip *chip, unsigned offset, int value) 339 { 340 struct bcm2835_pinctrl *pc = gpiochip_get_data(chip); 341 342 bcm2835_gpio_set_bit(pc, value ? GPSET0 : GPCLR0, offset); 343 } 344 345 static int bcm2835_gpio_direction_output(struct gpio_chip *chip, 346 unsigned offset, int value) 347 { 348 bcm2835_gpio_set(chip, offset, value); 349 return pinctrl_gpio_direction_output(chip->base + offset); 350 } 351 352 static const struct gpio_chip bcm2835_gpio_chip = { 353 .label = MODULE_NAME, 354 .owner = THIS_MODULE, 355 .request = gpiochip_generic_request, 356 .free = gpiochip_generic_free, 357 .direction_input = bcm2835_gpio_direction_input, 358 .direction_output = bcm2835_gpio_direction_output, 359 .get_direction = bcm2835_gpio_get_direction, 360 .get = bcm2835_gpio_get, 361 .set = bcm2835_gpio_set, 362 .set_config = gpiochip_generic_config, 363 .base = -1, 364 .ngpio = BCM2835_NUM_GPIOS, 365 .can_sleep = false, 366 }; 367 368 static const struct gpio_chip bcm2711_gpio_chip = { 369 .label = "pinctrl-bcm2711", 370 .owner = THIS_MODULE, 371 .request = gpiochip_generic_request, 372 .free = gpiochip_generic_free, 373 .direction_input = bcm2835_gpio_direction_input, 374 .direction_output = bcm2835_gpio_direction_output, 375 .get_direction = bcm2835_gpio_get_direction, 376 .get = bcm2835_gpio_get, 377 .set = bcm2835_gpio_set, 378 .set_config = gpiochip_generic_config, 379 .base = -1, 380 .ngpio = BCM2711_NUM_GPIOS, 381 .can_sleep = false, 382 }; 383 384 static void bcm2835_gpio_irq_handle_bank(struct bcm2835_pinctrl *pc, 385 unsigned int bank, u32 mask) 386 { 387 unsigned long events; 388 unsigned offset; 389 unsigned gpio; 390 391 events = bcm2835_gpio_rd(pc, GPEDS0 + bank * 4); 392 events &= mask; 393 events &= pc->enabled_irq_map[bank]; 394 for_each_set_bit(offset, &events, 32) { 395 gpio = (32 * bank) + offset; 396 generic_handle_irq(irq_linear_revmap(pc->gpio_chip.irq.domain, 397 gpio)); 398 } 399 } 400 401 static void bcm2835_gpio_irq_handler(struct irq_desc *desc) 402 { 403 struct gpio_chip *chip = irq_desc_get_handler_data(desc); 404 struct bcm2835_pinctrl *pc = gpiochip_get_data(chip); 405 struct irq_chip *host_chip = irq_desc_get_chip(desc); 406 int irq = irq_desc_get_irq(desc); 407 int group; 408 int i; 409 410 for (i = 0; i < BCM2835_NUM_IRQS; i++) { 411 if (chip->irq.parents[i] == irq) { 412 group = i; 413 break; 414 } 415 } 416 /* This should not happen, every IRQ has a bank */ 417 if (i == BCM2835_NUM_IRQS) 418 BUG(); 419 420 chained_irq_enter(host_chip, desc); 421 422 switch (group) { 423 case 0: /* IRQ0 covers GPIOs 0-27 */ 424 bcm2835_gpio_irq_handle_bank(pc, 0, 0x0fffffff); 425 break; 426 case 1: /* IRQ1 covers GPIOs 28-45 */ 427 bcm2835_gpio_irq_handle_bank(pc, 0, 0xf0000000); 428 bcm2835_gpio_irq_handle_bank(pc, 1, 0x00003fff); 429 break; 430 case 2: /* IRQ2 covers GPIOs 46-57 */ 431 bcm2835_gpio_irq_handle_bank(pc, 1, 0x003fc000); 432 break; 433 } 434 435 chained_irq_exit(host_chip, desc); 436 } 437 438 static inline void __bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc, 439 unsigned reg, unsigned offset, bool enable) 440 { 441 u32 value; 442 reg += GPIO_REG_OFFSET(offset) * 4; 443 value = bcm2835_gpio_rd(pc, reg); 444 if (enable) 445 value |= BIT(GPIO_REG_SHIFT(offset)); 446 else 447 value &= ~(BIT(GPIO_REG_SHIFT(offset))); 448 bcm2835_gpio_wr(pc, reg, value); 449 } 450 451 /* fast path for IRQ handler */ 452 static void bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc, 453 unsigned offset, bool enable) 454 { 455 switch (pc->irq_type[offset]) { 456 case IRQ_TYPE_EDGE_RISING: 457 __bcm2835_gpio_irq_config(pc, GPREN0, offset, enable); 458 break; 459 460 case IRQ_TYPE_EDGE_FALLING: 461 __bcm2835_gpio_irq_config(pc, GPFEN0, offset, enable); 462 break; 463 464 case IRQ_TYPE_EDGE_BOTH: 465 __bcm2835_gpio_irq_config(pc, GPREN0, offset, enable); 466 __bcm2835_gpio_irq_config(pc, GPFEN0, offset, enable); 467 break; 468 469 case IRQ_TYPE_LEVEL_HIGH: 470 __bcm2835_gpio_irq_config(pc, GPHEN0, offset, enable); 471 break; 472 473 case IRQ_TYPE_LEVEL_LOW: 474 __bcm2835_gpio_irq_config(pc, GPLEN0, offset, enable); 475 break; 476 } 477 } 478 479 static void bcm2835_gpio_irq_enable(struct irq_data *data) 480 { 481 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 482 struct bcm2835_pinctrl *pc = gpiochip_get_data(chip); 483 unsigned gpio = irqd_to_hwirq(data); 484 unsigned offset = GPIO_REG_SHIFT(gpio); 485 unsigned bank = GPIO_REG_OFFSET(gpio); 486 unsigned long flags; 487 488 raw_spin_lock_irqsave(&pc->irq_lock[bank], flags); 489 set_bit(offset, &pc->enabled_irq_map[bank]); 490 bcm2835_gpio_irq_config(pc, gpio, true); 491 raw_spin_unlock_irqrestore(&pc->irq_lock[bank], flags); 492 } 493 494 static void bcm2835_gpio_irq_disable(struct irq_data *data) 495 { 496 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 497 struct bcm2835_pinctrl *pc = gpiochip_get_data(chip); 498 unsigned gpio = irqd_to_hwirq(data); 499 unsigned offset = GPIO_REG_SHIFT(gpio); 500 unsigned bank = GPIO_REG_OFFSET(gpio); 501 unsigned long flags; 502 503 raw_spin_lock_irqsave(&pc->irq_lock[bank], flags); 504 bcm2835_gpio_irq_config(pc, gpio, false); 505 /* Clear events that were latched prior to clearing event sources */ 506 bcm2835_gpio_set_bit(pc, GPEDS0, gpio); 507 clear_bit(offset, &pc->enabled_irq_map[bank]); 508 raw_spin_unlock_irqrestore(&pc->irq_lock[bank], flags); 509 } 510 511 static int __bcm2835_gpio_irq_set_type_disabled(struct bcm2835_pinctrl *pc, 512 unsigned offset, unsigned int type) 513 { 514 switch (type) { 515 case IRQ_TYPE_NONE: 516 case IRQ_TYPE_EDGE_RISING: 517 case IRQ_TYPE_EDGE_FALLING: 518 case IRQ_TYPE_EDGE_BOTH: 519 case IRQ_TYPE_LEVEL_HIGH: 520 case IRQ_TYPE_LEVEL_LOW: 521 pc->irq_type[offset] = type; 522 break; 523 524 default: 525 return -EINVAL; 526 } 527 return 0; 528 } 529 530 /* slower path for reconfiguring IRQ type */ 531 static int __bcm2835_gpio_irq_set_type_enabled(struct bcm2835_pinctrl *pc, 532 unsigned offset, unsigned int type) 533 { 534 switch (type) { 535 case IRQ_TYPE_NONE: 536 if (pc->irq_type[offset] != type) { 537 bcm2835_gpio_irq_config(pc, offset, false); 538 pc->irq_type[offset] = type; 539 } 540 break; 541 542 case IRQ_TYPE_EDGE_RISING: 543 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_BOTH) { 544 /* RISING already enabled, disable FALLING */ 545 pc->irq_type[offset] = IRQ_TYPE_EDGE_FALLING; 546 bcm2835_gpio_irq_config(pc, offset, false); 547 pc->irq_type[offset] = type; 548 } else if (pc->irq_type[offset] != type) { 549 bcm2835_gpio_irq_config(pc, offset, false); 550 pc->irq_type[offset] = type; 551 bcm2835_gpio_irq_config(pc, offset, true); 552 } 553 break; 554 555 case IRQ_TYPE_EDGE_FALLING: 556 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_BOTH) { 557 /* FALLING already enabled, disable RISING */ 558 pc->irq_type[offset] = IRQ_TYPE_EDGE_RISING; 559 bcm2835_gpio_irq_config(pc, offset, false); 560 pc->irq_type[offset] = type; 561 } else if (pc->irq_type[offset] != type) { 562 bcm2835_gpio_irq_config(pc, offset, false); 563 pc->irq_type[offset] = type; 564 bcm2835_gpio_irq_config(pc, offset, true); 565 } 566 break; 567 568 case IRQ_TYPE_EDGE_BOTH: 569 if (pc->irq_type[offset] == IRQ_TYPE_EDGE_RISING) { 570 /* RISING already enabled, enable FALLING too */ 571 pc->irq_type[offset] = IRQ_TYPE_EDGE_FALLING; 572 bcm2835_gpio_irq_config(pc, offset, true); 573 pc->irq_type[offset] = type; 574 } else if (pc->irq_type[offset] == IRQ_TYPE_EDGE_FALLING) { 575 /* FALLING already enabled, enable RISING too */ 576 pc->irq_type[offset] = IRQ_TYPE_EDGE_RISING; 577 bcm2835_gpio_irq_config(pc, offset, true); 578 pc->irq_type[offset] = type; 579 } else 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 case IRQ_TYPE_LEVEL_HIGH: 587 case IRQ_TYPE_LEVEL_LOW: 588 if (pc->irq_type[offset] != type) { 589 bcm2835_gpio_irq_config(pc, offset, false); 590 pc->irq_type[offset] = type; 591 bcm2835_gpio_irq_config(pc, offset, true); 592 } 593 break; 594 595 default: 596 return -EINVAL; 597 } 598 return 0; 599 } 600 601 static int bcm2835_gpio_irq_set_type(struct irq_data *data, unsigned int type) 602 { 603 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 604 struct bcm2835_pinctrl *pc = gpiochip_get_data(chip); 605 unsigned gpio = irqd_to_hwirq(data); 606 unsigned offset = GPIO_REG_SHIFT(gpio); 607 unsigned bank = GPIO_REG_OFFSET(gpio); 608 unsigned long flags; 609 int ret; 610 611 raw_spin_lock_irqsave(&pc->irq_lock[bank], flags); 612 613 if (test_bit(offset, &pc->enabled_irq_map[bank])) 614 ret = __bcm2835_gpio_irq_set_type_enabled(pc, gpio, type); 615 else 616 ret = __bcm2835_gpio_irq_set_type_disabled(pc, gpio, type); 617 618 if (type & IRQ_TYPE_EDGE_BOTH) 619 irq_set_handler_locked(data, handle_edge_irq); 620 else 621 irq_set_handler_locked(data, handle_level_irq); 622 623 raw_spin_unlock_irqrestore(&pc->irq_lock[bank], flags); 624 625 return ret; 626 } 627 628 static void bcm2835_gpio_irq_ack(struct irq_data *data) 629 { 630 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 631 struct bcm2835_pinctrl *pc = gpiochip_get_data(chip); 632 unsigned gpio = irqd_to_hwirq(data); 633 634 bcm2835_gpio_set_bit(pc, GPEDS0, gpio); 635 } 636 637 static struct irq_chip bcm2835_gpio_irq_chip = { 638 .name = MODULE_NAME, 639 .irq_enable = bcm2835_gpio_irq_enable, 640 .irq_disable = bcm2835_gpio_irq_disable, 641 .irq_set_type = bcm2835_gpio_irq_set_type, 642 .irq_ack = bcm2835_gpio_irq_ack, 643 .irq_mask = bcm2835_gpio_irq_disable, 644 .irq_unmask = bcm2835_gpio_irq_enable, 645 }; 646 647 static int bcm2835_pctl_get_groups_count(struct pinctrl_dev *pctldev) 648 { 649 return BCM2835_NUM_GPIOS; 650 } 651 652 static const char *bcm2835_pctl_get_group_name(struct pinctrl_dev *pctldev, 653 unsigned selector) 654 { 655 return bcm2835_gpio_groups[selector]; 656 } 657 658 static int bcm2835_pctl_get_group_pins(struct pinctrl_dev *pctldev, 659 unsigned selector, 660 const unsigned **pins, 661 unsigned *num_pins) 662 { 663 *pins = &bcm2835_gpio_pins[selector].number; 664 *num_pins = 1; 665 666 return 0; 667 } 668 669 static void bcm2835_pctl_pin_dbg_show(struct pinctrl_dev *pctldev, 670 struct seq_file *s, 671 unsigned offset) 672 { 673 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 674 struct gpio_chip *chip = &pc->gpio_chip; 675 enum bcm2835_fsel fsel = bcm2835_pinctrl_fsel_get(pc, offset); 676 const char *fname = bcm2835_functions[fsel]; 677 int value = bcm2835_gpio_get_bit(pc, GPLEV0, offset); 678 int irq = irq_find_mapping(chip->irq.domain, offset); 679 680 seq_printf(s, "function %s in %s; irq %d (%s)", 681 fname, value ? "hi" : "lo", 682 irq, irq_type_names[pc->irq_type[offset]]); 683 } 684 685 static void bcm2835_pctl_dt_free_map(struct pinctrl_dev *pctldev, 686 struct pinctrl_map *maps, unsigned num_maps) 687 { 688 int i; 689 690 for (i = 0; i < num_maps; i++) 691 if (maps[i].type == PIN_MAP_TYPE_CONFIGS_PIN) 692 kfree(maps[i].data.configs.configs); 693 694 kfree(maps); 695 } 696 697 static int bcm2835_pctl_dt_node_to_map_func(struct bcm2835_pinctrl *pc, 698 struct device_node *np, u32 pin, u32 fnum, 699 struct pinctrl_map **maps) 700 { 701 struct pinctrl_map *map = *maps; 702 703 if (fnum >= ARRAY_SIZE(bcm2835_functions)) { 704 dev_err(pc->dev, "%pOF: invalid brcm,function %d\n", np, fnum); 705 return -EINVAL; 706 } 707 708 map->type = PIN_MAP_TYPE_MUX_GROUP; 709 map->data.mux.group = bcm2835_gpio_groups[pin]; 710 map->data.mux.function = bcm2835_functions[fnum]; 711 (*maps)++; 712 713 return 0; 714 } 715 716 static int bcm2835_pctl_dt_node_to_map_pull(struct bcm2835_pinctrl *pc, 717 struct device_node *np, u32 pin, u32 pull, 718 struct pinctrl_map **maps) 719 { 720 struct pinctrl_map *map = *maps; 721 unsigned long *configs; 722 723 if (pull > 2) { 724 dev_err(pc->dev, "%pOF: invalid brcm,pull %d\n", np, pull); 725 return -EINVAL; 726 } 727 728 configs = kzalloc(sizeof(*configs), GFP_KERNEL); 729 if (!configs) 730 return -ENOMEM; 731 configs[0] = pinconf_to_config_packed(BCM2835_PINCONF_PARAM_PULL, pull); 732 733 map->type = PIN_MAP_TYPE_CONFIGS_PIN; 734 map->data.configs.group_or_pin = bcm2835_gpio_pins[pin].name; 735 map->data.configs.configs = configs; 736 map->data.configs.num_configs = 1; 737 (*maps)++; 738 739 return 0; 740 } 741 742 static int bcm2835_pctl_dt_node_to_map(struct pinctrl_dev *pctldev, 743 struct device_node *np, 744 struct pinctrl_map **map, unsigned int *num_maps) 745 { 746 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 747 struct property *pins, *funcs, *pulls; 748 int num_pins, num_funcs, num_pulls, maps_per_pin; 749 struct pinctrl_map *maps, *cur_map; 750 int i, err; 751 u32 pin, func, pull; 752 753 /* Check for generic binding in this node */ 754 err = pinconf_generic_dt_node_to_map_all(pctldev, np, map, num_maps); 755 if (err || *num_maps) 756 return err; 757 758 /* Generic binding did not find anything continue with legacy parse */ 759 pins = of_find_property(np, "brcm,pins", NULL); 760 if (!pins) { 761 dev_err(pc->dev, "%pOF: missing brcm,pins property\n", np); 762 return -EINVAL; 763 } 764 765 funcs = of_find_property(np, "brcm,function", NULL); 766 pulls = of_find_property(np, "brcm,pull", NULL); 767 768 if (!funcs && !pulls) { 769 dev_err(pc->dev, 770 "%pOF: neither brcm,function nor brcm,pull specified\n", 771 np); 772 return -EINVAL; 773 } 774 775 num_pins = pins->length / 4; 776 num_funcs = funcs ? (funcs->length / 4) : 0; 777 num_pulls = pulls ? (pulls->length / 4) : 0; 778 779 if (num_funcs > 1 && num_funcs != num_pins) { 780 dev_err(pc->dev, 781 "%pOF: brcm,function must have 1 or %d entries\n", 782 np, num_pins); 783 return -EINVAL; 784 } 785 786 if (num_pulls > 1 && num_pulls != num_pins) { 787 dev_err(pc->dev, 788 "%pOF: brcm,pull must have 1 or %d entries\n", 789 np, num_pins); 790 return -EINVAL; 791 } 792 793 maps_per_pin = 0; 794 if (num_funcs) 795 maps_per_pin++; 796 if (num_pulls) 797 maps_per_pin++; 798 cur_map = maps = kcalloc(num_pins * maps_per_pin, sizeof(*maps), 799 GFP_KERNEL); 800 if (!maps) 801 return -ENOMEM; 802 803 for (i = 0; i < num_pins; i++) { 804 err = of_property_read_u32_index(np, "brcm,pins", i, &pin); 805 if (err) 806 goto out; 807 if (pin >= pc->pctl_desc.npins) { 808 dev_err(pc->dev, "%pOF: invalid brcm,pins value %d\n", 809 np, pin); 810 err = -EINVAL; 811 goto out; 812 } 813 814 if (num_funcs) { 815 err = of_property_read_u32_index(np, "brcm,function", 816 (num_funcs > 1) ? i : 0, &func); 817 if (err) 818 goto out; 819 err = bcm2835_pctl_dt_node_to_map_func(pc, np, pin, 820 func, &cur_map); 821 if (err) 822 goto out; 823 } 824 if (num_pulls) { 825 err = of_property_read_u32_index(np, "brcm,pull", 826 (num_pulls > 1) ? i : 0, &pull); 827 if (err) 828 goto out; 829 err = bcm2835_pctl_dt_node_to_map_pull(pc, np, pin, 830 pull, &cur_map); 831 if (err) 832 goto out; 833 } 834 } 835 836 *map = maps; 837 *num_maps = num_pins * maps_per_pin; 838 839 return 0; 840 841 out: 842 bcm2835_pctl_dt_free_map(pctldev, maps, num_pins * maps_per_pin); 843 return err; 844 } 845 846 static const struct pinctrl_ops bcm2835_pctl_ops = { 847 .get_groups_count = bcm2835_pctl_get_groups_count, 848 .get_group_name = bcm2835_pctl_get_group_name, 849 .get_group_pins = bcm2835_pctl_get_group_pins, 850 .pin_dbg_show = bcm2835_pctl_pin_dbg_show, 851 .dt_node_to_map = bcm2835_pctl_dt_node_to_map, 852 .dt_free_map = bcm2835_pctl_dt_free_map, 853 }; 854 855 static int bcm2835_pmx_free(struct pinctrl_dev *pctldev, 856 unsigned offset) 857 { 858 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 859 860 /* disable by setting to GPIO_IN */ 861 bcm2835_pinctrl_fsel_set(pc, offset, BCM2835_FSEL_GPIO_IN); 862 return 0; 863 } 864 865 static int bcm2835_pmx_get_functions_count(struct pinctrl_dev *pctldev) 866 { 867 return BCM2835_FSEL_COUNT; 868 } 869 870 static const char *bcm2835_pmx_get_function_name(struct pinctrl_dev *pctldev, 871 unsigned selector) 872 { 873 return bcm2835_functions[selector]; 874 } 875 876 static int bcm2835_pmx_get_function_groups(struct pinctrl_dev *pctldev, 877 unsigned selector, 878 const char * const **groups, 879 unsigned * const num_groups) 880 { 881 /* every pin can do every function */ 882 *groups = bcm2835_gpio_groups; 883 *num_groups = BCM2835_NUM_GPIOS; 884 885 return 0; 886 } 887 888 static int bcm2835_pmx_set(struct pinctrl_dev *pctldev, 889 unsigned func_selector, 890 unsigned group_selector) 891 { 892 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 893 894 bcm2835_pinctrl_fsel_set(pc, group_selector, func_selector); 895 896 return 0; 897 } 898 899 static void bcm2835_pmx_gpio_disable_free(struct pinctrl_dev *pctldev, 900 struct pinctrl_gpio_range *range, 901 unsigned offset) 902 { 903 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 904 905 /* disable by setting to GPIO_IN */ 906 bcm2835_pinctrl_fsel_set(pc, offset, BCM2835_FSEL_GPIO_IN); 907 } 908 909 static int bcm2835_pmx_gpio_set_direction(struct pinctrl_dev *pctldev, 910 struct pinctrl_gpio_range *range, 911 unsigned offset, 912 bool input) 913 { 914 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 915 enum bcm2835_fsel fsel = input ? 916 BCM2835_FSEL_GPIO_IN : BCM2835_FSEL_GPIO_OUT; 917 918 bcm2835_pinctrl_fsel_set(pc, offset, fsel); 919 920 return 0; 921 } 922 923 static const struct pinmux_ops bcm2835_pmx_ops = { 924 .free = bcm2835_pmx_free, 925 .get_functions_count = bcm2835_pmx_get_functions_count, 926 .get_function_name = bcm2835_pmx_get_function_name, 927 .get_function_groups = bcm2835_pmx_get_function_groups, 928 .set_mux = bcm2835_pmx_set, 929 .gpio_disable_free = bcm2835_pmx_gpio_disable_free, 930 .gpio_set_direction = bcm2835_pmx_gpio_set_direction, 931 }; 932 933 static int bcm2835_pinconf_get(struct pinctrl_dev *pctldev, 934 unsigned pin, unsigned long *config) 935 { 936 /* No way to read back config in HW */ 937 return -ENOTSUPP; 938 } 939 940 static void bcm2835_pull_config_set(struct bcm2835_pinctrl *pc, 941 unsigned int pin, unsigned int arg) 942 { 943 u32 off, bit; 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 } 960 961 static int bcm2835_pinconf_set(struct pinctrl_dev *pctldev, 962 unsigned int pin, unsigned long *configs, 963 unsigned int num_configs) 964 { 965 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 966 u32 param, arg; 967 int i; 968 969 for (i = 0; i < num_configs; i++) { 970 param = pinconf_to_config_param(configs[i]); 971 arg = pinconf_to_config_argument(configs[i]); 972 973 switch (param) { 974 /* Set legacy brcm,pull */ 975 case BCM2835_PINCONF_PARAM_PULL: 976 bcm2835_pull_config_set(pc, pin, arg); 977 break; 978 979 /* Set pull generic bindings */ 980 case PIN_CONFIG_BIAS_DISABLE: 981 bcm2835_pull_config_set(pc, pin, BCM2835_PUD_OFF); 982 break; 983 984 case PIN_CONFIG_BIAS_PULL_DOWN: 985 bcm2835_pull_config_set(pc, pin, BCM2835_PUD_DOWN); 986 break; 987 988 case PIN_CONFIG_BIAS_PULL_UP: 989 bcm2835_pull_config_set(pc, pin, BCM2835_PUD_UP); 990 break; 991 992 /* Set output-high or output-low */ 993 case PIN_CONFIG_OUTPUT: 994 bcm2835_gpio_set_bit(pc, arg ? GPSET0 : GPCLR0, pin); 995 break; 996 997 default: 998 return -ENOTSUPP; 999 1000 } /* switch param type */ 1001 } /* for each config */ 1002 1003 return 0; 1004 } 1005 1006 static const struct pinconf_ops bcm2835_pinconf_ops = { 1007 .is_generic = true, 1008 .pin_config_get = bcm2835_pinconf_get, 1009 .pin_config_set = bcm2835_pinconf_set, 1010 }; 1011 1012 static void bcm2711_pull_config_set(struct bcm2835_pinctrl *pc, 1013 unsigned int pin, unsigned int arg) 1014 { 1015 u32 shifter; 1016 u32 value; 1017 u32 off; 1018 1019 off = PUD_2711_REG_OFFSET(pin); 1020 shifter = PUD_2711_REG_SHIFT(pin); 1021 1022 value = bcm2835_gpio_rd(pc, GP_GPIO_PUP_PDN_CNTRL_REG0 + (off * 4)); 1023 value &= ~(PUD_2711_MASK << shifter); 1024 value |= (arg << shifter); 1025 bcm2835_gpio_wr(pc, GP_GPIO_PUP_PDN_CNTRL_REG0 + (off * 4), value); 1026 } 1027 1028 static int bcm2711_pinconf_set(struct pinctrl_dev *pctldev, 1029 unsigned int pin, unsigned long *configs, 1030 unsigned int num_configs) 1031 { 1032 struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 1033 u32 param, arg; 1034 int i; 1035 1036 for (i = 0; i < num_configs; i++) { 1037 param = pinconf_to_config_param(configs[i]); 1038 arg = pinconf_to_config_argument(configs[i]); 1039 1040 switch (param) { 1041 /* convert legacy brcm,pull */ 1042 case BCM2835_PINCONF_PARAM_PULL: 1043 if (arg == BCM2835_PUD_UP) 1044 arg = BCM2711_PULL_UP; 1045 else if (arg == BCM2835_PUD_DOWN) 1046 arg = BCM2711_PULL_DOWN; 1047 else 1048 arg = BCM2711_PULL_NONE; 1049 1050 bcm2711_pull_config_set(pc, pin, arg); 1051 break; 1052 1053 /* Set pull generic bindings */ 1054 case PIN_CONFIG_BIAS_DISABLE: 1055 bcm2711_pull_config_set(pc, pin, BCM2711_PULL_NONE); 1056 break; 1057 case PIN_CONFIG_BIAS_PULL_DOWN: 1058 bcm2711_pull_config_set(pc, pin, BCM2711_PULL_DOWN); 1059 break; 1060 case PIN_CONFIG_BIAS_PULL_UP: 1061 bcm2711_pull_config_set(pc, pin, BCM2711_PULL_UP); 1062 break; 1063 1064 /* Set output-high or output-low */ 1065 case PIN_CONFIG_OUTPUT: 1066 bcm2835_gpio_set_bit(pc, arg ? GPSET0 : GPCLR0, pin); 1067 break; 1068 1069 default: 1070 return -ENOTSUPP; 1071 } 1072 } /* for each config */ 1073 1074 return 0; 1075 } 1076 1077 static const struct pinconf_ops bcm2711_pinconf_ops = { 1078 .is_generic = true, 1079 .pin_config_get = bcm2835_pinconf_get, 1080 .pin_config_set = bcm2711_pinconf_set, 1081 }; 1082 1083 static const struct pinctrl_desc bcm2835_pinctrl_desc = { 1084 .name = MODULE_NAME, 1085 .pins = bcm2835_gpio_pins, 1086 .npins = BCM2835_NUM_GPIOS, 1087 .pctlops = &bcm2835_pctl_ops, 1088 .pmxops = &bcm2835_pmx_ops, 1089 .confops = &bcm2835_pinconf_ops, 1090 .owner = THIS_MODULE, 1091 }; 1092 1093 static const struct pinctrl_desc bcm2711_pinctrl_desc = { 1094 .name = "pinctrl-bcm2711", 1095 .pins = bcm2835_gpio_pins, 1096 .npins = BCM2711_NUM_GPIOS, 1097 .pctlops = &bcm2835_pctl_ops, 1098 .pmxops = &bcm2835_pmx_ops, 1099 .confops = &bcm2711_pinconf_ops, 1100 .owner = THIS_MODULE, 1101 }; 1102 1103 static const struct pinctrl_gpio_range bcm2835_pinctrl_gpio_range = { 1104 .name = MODULE_NAME, 1105 .npins = BCM2835_NUM_GPIOS, 1106 }; 1107 1108 static const struct pinctrl_gpio_range bcm2711_pinctrl_gpio_range = { 1109 .name = "pinctrl-bcm2711", 1110 .npins = BCM2711_NUM_GPIOS, 1111 }; 1112 1113 struct bcm_plat_data { 1114 const struct gpio_chip *gpio_chip; 1115 const struct pinctrl_desc *pctl_desc; 1116 const struct pinctrl_gpio_range *gpio_range; 1117 }; 1118 1119 static const struct bcm_plat_data bcm2835_plat_data = { 1120 .gpio_chip = &bcm2835_gpio_chip, 1121 .pctl_desc = &bcm2835_pinctrl_desc, 1122 .gpio_range = &bcm2835_pinctrl_gpio_range, 1123 }; 1124 1125 static const struct bcm_plat_data bcm2711_plat_data = { 1126 .gpio_chip = &bcm2711_gpio_chip, 1127 .pctl_desc = &bcm2711_pinctrl_desc, 1128 .gpio_range = &bcm2711_pinctrl_gpio_range, 1129 }; 1130 1131 static const struct of_device_id bcm2835_pinctrl_match[] = { 1132 { 1133 .compatible = "brcm,bcm2835-gpio", 1134 .data = &bcm2835_plat_data, 1135 }, 1136 { 1137 .compatible = "brcm,bcm2711-gpio", 1138 .data = &bcm2711_plat_data, 1139 }, 1140 {} 1141 }; 1142 1143 static int bcm2835_pinctrl_probe(struct platform_device *pdev) 1144 { 1145 struct device *dev = &pdev->dev; 1146 struct device_node *np = dev->of_node; 1147 const struct bcm_plat_data *pdata; 1148 struct bcm2835_pinctrl *pc; 1149 struct gpio_irq_chip *girq; 1150 struct resource iomem; 1151 int err, i; 1152 const struct of_device_id *match; 1153 1154 BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_pins) != BCM2711_NUM_GPIOS); 1155 BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_groups) != BCM2711_NUM_GPIOS); 1156 1157 pc = devm_kzalloc(dev, sizeof(*pc), GFP_KERNEL); 1158 if (!pc) 1159 return -ENOMEM; 1160 1161 platform_set_drvdata(pdev, pc); 1162 pc->dev = dev; 1163 1164 err = of_address_to_resource(np, 0, &iomem); 1165 if (err) { 1166 dev_err(dev, "could not get IO memory\n"); 1167 return err; 1168 } 1169 1170 pc->base = devm_ioremap_resource(dev, &iomem); 1171 if (IS_ERR(pc->base)) 1172 return PTR_ERR(pc->base); 1173 1174 match = of_match_node(bcm2835_pinctrl_match, pdev->dev.of_node); 1175 if (!match) 1176 return -EINVAL; 1177 1178 pdata = match->data; 1179 1180 pc->gpio_chip = *pdata->gpio_chip; 1181 pc->gpio_chip.parent = dev; 1182 pc->gpio_chip.of_node = np; 1183 1184 for (i = 0; i < BCM2835_NUM_BANKS; i++) { 1185 unsigned long events; 1186 unsigned offset; 1187 1188 /* clear event detection flags */ 1189 bcm2835_gpio_wr(pc, GPREN0 + i * 4, 0); 1190 bcm2835_gpio_wr(pc, GPFEN0 + i * 4, 0); 1191 bcm2835_gpio_wr(pc, GPHEN0 + i * 4, 0); 1192 bcm2835_gpio_wr(pc, GPLEN0 + i * 4, 0); 1193 bcm2835_gpio_wr(pc, GPAREN0 + i * 4, 0); 1194 bcm2835_gpio_wr(pc, GPAFEN0 + i * 4, 0); 1195 1196 /* clear all the events */ 1197 events = bcm2835_gpio_rd(pc, GPEDS0 + i * 4); 1198 for_each_set_bit(offset, &events, 32) 1199 bcm2835_gpio_wr(pc, GPEDS0 + i * 4, BIT(offset)); 1200 1201 raw_spin_lock_init(&pc->irq_lock[i]); 1202 } 1203 1204 girq = &pc->gpio_chip.irq; 1205 girq->chip = &bcm2835_gpio_irq_chip; 1206 girq->parent_handler = bcm2835_gpio_irq_handler; 1207 girq->num_parents = BCM2835_NUM_IRQS; 1208 girq->parents = devm_kcalloc(dev, BCM2835_NUM_IRQS, 1209 sizeof(*girq->parents), 1210 GFP_KERNEL); 1211 if (!girq->parents) 1212 return -ENOMEM; 1213 /* 1214 * Use the same handler for all groups: this is necessary 1215 * since we use one gpiochip to cover all lines - the 1216 * irq handler then needs to figure out which group and 1217 * bank that was firing the IRQ and look up the per-group 1218 * and bank data. 1219 */ 1220 for (i = 0; i < BCM2835_NUM_IRQS; i++) 1221 girq->parents[i] = irq_of_parse_and_map(np, i); 1222 girq->default_type = IRQ_TYPE_NONE; 1223 girq->handler = handle_level_irq; 1224 1225 err = gpiochip_add_data(&pc->gpio_chip, pc); 1226 if (err) { 1227 dev_err(dev, "could not add GPIO chip\n"); 1228 return err; 1229 } 1230 1231 pc->pctl_desc = *pdata->pctl_desc; 1232 pc->pctl_dev = devm_pinctrl_register(dev, &pc->pctl_desc, pc); 1233 if (IS_ERR(pc->pctl_dev)) { 1234 gpiochip_remove(&pc->gpio_chip); 1235 return PTR_ERR(pc->pctl_dev); 1236 } 1237 1238 pc->gpio_range = *pdata->gpio_range; 1239 pc->gpio_range.base = pc->gpio_chip.base; 1240 pc->gpio_range.gc = &pc->gpio_chip; 1241 pinctrl_add_gpio_range(pc->pctl_dev, &pc->gpio_range); 1242 1243 return 0; 1244 } 1245 1246 static struct platform_driver bcm2835_pinctrl_driver = { 1247 .probe = bcm2835_pinctrl_probe, 1248 .driver = { 1249 .name = MODULE_NAME, 1250 .of_match_table = bcm2835_pinctrl_match, 1251 .suppress_bind_attrs = true, 1252 }, 1253 }; 1254 builtin_platform_driver(bcm2835_pinctrl_driver); 1255