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