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