1/* 2 * 3 * arch/arm/mach-u300/gpio.c 4 * 5 * 6 * Copyright (C) 2007-2009 ST-Ericsson AB 7 * License terms: GNU General Public License (GPL) version 2 8 * U300 GPIO module. 9 * This can driver either of the two basic GPIO cores 10 * available in the U300 platforms: 11 * COH 901 335 - Used in DB3150 (U300 1.0) and DB3200 (U330 1.0) 12 * COH 901 571/3 - Used in DB3210 (U365 2.0) and DB3350 (U335 1.0) 13 * Notice that you also have inline macros in <asm-arch/gpio.h> 14 * Author: Linus Walleij <linus.walleij@stericsson.com> 15 * Author: Jonas Aaberg <jonas.aberg@stericsson.com> 16 * 17 */ 18#include <linux/module.h> 19#include <linux/interrupt.h> 20#include <linux/delay.h> 21#include <linux/errno.h> 22#include <linux/io.h> 23#include <linux/clk.h> 24#include <linux/err.h> 25#include <linux/platform_device.h> 26#include <linux/gpio.h> 27 28/* Reference to GPIO block clock */ 29static struct clk *clk; 30 31/* Memory resource */ 32static struct resource *memres; 33static void __iomem *virtbase; 34static struct device *gpiodev; 35 36struct u300_gpio_port { 37 const char *name; 38 int irq; 39 int number; 40}; 41 42 43static struct u300_gpio_port gpio_ports[] = { 44 { 45 .name = "gpio0", 46 .number = 0, 47 }, 48 { 49 .name = "gpio1", 50 .number = 1, 51 }, 52 { 53 .name = "gpio2", 54 .number = 2, 55 }, 56#ifdef U300_COH901571_3 57 { 58 .name = "gpio3", 59 .number = 3, 60 }, 61 { 62 .name = "gpio4", 63 .number = 4, 64 }, 65#ifdef CONFIG_MACH_U300_BS335 66 { 67 .name = "gpio5", 68 .number = 5, 69 }, 70 { 71 .name = "gpio6", 72 .number = 6, 73 }, 74#endif 75#endif 76 77}; 78 79 80#ifdef U300_COH901571_3 81 82/* Default input value */ 83#define DEFAULT_OUTPUT_LOW 0 84#define DEFAULT_OUTPUT_HIGH 1 85 86/* GPIO Pull-Up status */ 87#define DISABLE_PULL_UP 0 88#define ENABLE_PULL_UP 1 89 90#define GPIO_NOT_USED 0 91#define GPIO_IN 1 92#define GPIO_OUT 2 93 94struct u300_gpio_configuration_data { 95 unsigned char pin_usage; 96 unsigned char default_output_value; 97 unsigned char pull_up; 98}; 99 100/* Initial configuration */ 101const struct u300_gpio_configuration_data 102u300_gpio_config[U300_GPIO_NUM_PORTS][U300_GPIO_PINS_PER_PORT] = { 103#ifdef CONFIG_MACH_U300_BS335 104 /* Port 0, pins 0-7 */ 105 { 106 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 107 {GPIO_OUT, DEFAULT_OUTPUT_HIGH, DISABLE_PULL_UP}, 108 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 109 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 110 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 111 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 112 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 113 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP} 114 }, 115 /* Port 1, pins 0-7 */ 116 { 117 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 118 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 119 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 120 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 121 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 122 {GPIO_OUT, DEFAULT_OUTPUT_HIGH, DISABLE_PULL_UP}, 123 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 124 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP} 125 }, 126 /* Port 2, pins 0-7 */ 127 { 128 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 129 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 130 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 131 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 132 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 133 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 134 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 135 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP} 136 }, 137 /* Port 3, pins 0-7 */ 138 { 139 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 140 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 141 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 142 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 143 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 144 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 145 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 146 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP} 147 }, 148 /* Port 4, pins 0-7 */ 149 { 150 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 151 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 152 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 153 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 154 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 155 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 156 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 157 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP} 158 }, 159 /* Port 5, pins 0-7 */ 160 { 161 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 162 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 163 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 164 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 165 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 166 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 167 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 168 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP} 169 }, 170 /* Port 6, pind 0-7 */ 171 { 172 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 173 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 174 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 175 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 176 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 177 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 178 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 179 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP} 180 } 181#endif 182 183#ifdef CONFIG_MACH_U300_BS365 184 /* Port 0, pins 0-7 */ 185 { 186 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 187 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 188 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 189 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 190 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 191 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 192 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 193 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP} 194 }, 195 /* Port 1, pins 0-7 */ 196 { 197 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 198 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 199 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 200 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 201 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 202 {GPIO_OUT, DEFAULT_OUTPUT_HIGH, DISABLE_PULL_UP}, 203 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 204 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP} 205 }, 206 /* Port 2, pins 0-7 */ 207 { 208 {GPIO_IN, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 209 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 210 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 211 {GPIO_OUT, DEFAULT_OUTPUT_LOW, DISABLE_PULL_UP}, 212 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 213 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 214 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 215 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP} 216 }, 217 /* Port 3, pins 0-7 */ 218 { 219 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 220 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 221 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 222 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 223 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 224 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 225 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 226 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP} 227 }, 228 /* Port 4, pins 0-7 */ 229 { 230 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 231 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 232 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 233 {GPIO_IN, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 234 /* These 4 pins doesn't exist on DB3210 */ 235 {GPIO_OUT, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 236 {GPIO_OUT, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 237 {GPIO_OUT, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP}, 238 {GPIO_OUT, DEFAULT_OUTPUT_LOW, ENABLE_PULL_UP} 239 } 240#endif 241}; 242#endif 243 244 245/* No users == we can power down GPIO */ 246static int gpio_users; 247 248struct gpio_struct { 249 int (*callback)(void *); 250 void *data; 251 int users; 252}; 253 254static struct gpio_struct gpio_pin[U300_GPIO_MAX]; 255 256/* 257 * Let drivers register callback in order to get notified when there is 258 * an interrupt on the gpio pin 259 */ 260int gpio_register_callback(unsigned gpio, int (*func)(void *arg), void *data) 261{ 262 if (gpio_pin[gpio].callback) 263 dev_warn(gpiodev, "%s: WARNING: callback already " 264 "registered for gpio pin#%d\n", __func__, gpio); 265 gpio_pin[gpio].callback = func; 266 gpio_pin[gpio].data = data; 267 268 return 0; 269} 270EXPORT_SYMBOL(gpio_register_callback); 271 272int gpio_unregister_callback(unsigned gpio) 273{ 274 if (!gpio_pin[gpio].callback) 275 dev_warn(gpiodev, "%s: WARNING: callback already " 276 "unregistered for gpio pin#%d\n", __func__, gpio); 277 gpio_pin[gpio].callback = NULL; 278 gpio_pin[gpio].data = NULL; 279 280 return 0; 281} 282EXPORT_SYMBOL(gpio_unregister_callback); 283 284/* Non-zero means valid */ 285int gpio_is_valid(int number) 286{ 287 if (number >= 0 && 288 number < (U300_GPIO_NUM_PORTS * U300_GPIO_PINS_PER_PORT)) 289 return 1; 290 return 0; 291} 292EXPORT_SYMBOL(gpio_is_valid); 293 294int gpio_request(unsigned gpio, const char *label) 295{ 296 if (gpio_pin[gpio].users) 297 return -EINVAL; 298 else 299 gpio_pin[gpio].users++; 300 301 gpio_users++; 302 303 return 0; 304} 305EXPORT_SYMBOL(gpio_request); 306 307void gpio_free(unsigned gpio) 308{ 309 gpio_users--; 310 gpio_pin[gpio].users--; 311 if (unlikely(gpio_pin[gpio].users < 0)) { 312 dev_warn(gpiodev, "warning: gpio#%d release mismatch\n", 313 gpio); 314 gpio_pin[gpio].users = 0; 315 } 316 317 return; 318} 319EXPORT_SYMBOL(gpio_free); 320 321/* This returns zero or nonzero */ 322int gpio_get_value(unsigned gpio) 323{ 324 return readl(virtbase + U300_GPIO_PXPDIR + 325 PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING) & (1 << (gpio & 0x07)); 326} 327EXPORT_SYMBOL(gpio_get_value); 328 329/* 330 * We hope that the compiler will optimize away the unused branch 331 * in case "value" is a constant 332 */ 333void gpio_set_value(unsigned gpio, int value) 334{ 335 u32 val; 336 unsigned long flags; 337 338 local_irq_save(flags); 339 if (value) { 340 /* set */ 341 val = readl(virtbase + U300_GPIO_PXPDOR + 342 PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING) 343 & (1 << (gpio & 0x07)); 344 writel(val | (1 << (gpio & 0x07)), virtbase + 345 U300_GPIO_PXPDOR + 346 PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING); 347 } else { 348 /* clear */ 349 val = readl(virtbase + U300_GPIO_PXPDOR + 350 PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING) 351 & (1 << (gpio & 0x07)); 352 writel(val & ~(1 << (gpio & 0x07)), virtbase + 353 U300_GPIO_PXPDOR + 354 PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING); 355 } 356 local_irq_restore(flags); 357} 358EXPORT_SYMBOL(gpio_set_value); 359 360int gpio_direction_input(unsigned gpio) 361{ 362 unsigned long flags; 363 u32 val; 364 365 if (gpio > U300_GPIO_MAX) 366 return -EINVAL; 367 368 local_irq_save(flags); 369 val = readl(virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) * 370 U300_GPIO_PORTX_SPACING); 371 /* Mask out this pin*/ 372 val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << ((gpio & 0x07) << 1)); 373 /* This is not needed since it sets the bits to zero.*/ 374 /* val |= (U300_GPIO_PXPCR_PIN_MODE_INPUT << (gpio*2)); */ 375 writel(val, virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) * 376 U300_GPIO_PORTX_SPACING); 377 local_irq_restore(flags); 378 return 0; 379} 380EXPORT_SYMBOL(gpio_direction_input); 381 382int gpio_direction_output(unsigned gpio, int value) 383{ 384 unsigned long flags; 385 u32 val; 386 387 if (gpio > U300_GPIO_MAX) 388 return -EINVAL; 389 390 local_irq_save(flags); 391 val = readl(virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) * 392 U300_GPIO_PORTX_SPACING); 393 /* Mask out this pin */ 394 val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << ((gpio & 0x07) << 1)); 395 val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL 396 << ((gpio & 0x07) << 1)); 397 writel(val, virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) * 398 U300_GPIO_PORTX_SPACING); 399 gpio_set_value(gpio, value); 400 local_irq_restore(flags); 401 return 0; 402} 403EXPORT_SYMBOL(gpio_direction_output); 404 405/* 406 * Enable an IRQ, edge is rising edge (!= 0) or falling edge (==0). 407 */ 408void enable_irq_on_gpio_pin(unsigned gpio, int edge) 409{ 410 u32 val; 411 unsigned long flags; 412 local_irq_save(flags); 413 414 val = readl(virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) * 415 U300_GPIO_PORTX_SPACING); 416 val |= (1 << (gpio & 0x07)); 417 writel(val, virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) * 418 U300_GPIO_PORTX_SPACING); 419 val = readl(virtbase + U300_GPIO_PXICR + PIN_TO_PORT(gpio) * 420 U300_GPIO_PORTX_SPACING); 421 if (edge) 422 val |= (1 << (gpio & 0x07)); 423 else 424 val &= ~(1 << (gpio & 0x07)); 425 writel(val, virtbase + U300_GPIO_PXICR + PIN_TO_PORT(gpio) * 426 U300_GPIO_PORTX_SPACING); 427 local_irq_restore(flags); 428} 429EXPORT_SYMBOL(enable_irq_on_gpio_pin); 430 431void disable_irq_on_gpio_pin(unsigned gpio) 432{ 433 u32 val; 434 unsigned long flags; 435 436 local_irq_save(flags); 437 val = readl(virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) * 438 U300_GPIO_PORTX_SPACING); 439 val &= ~(1 << (gpio & 0x07)); 440 writel(val, virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) * 441 U300_GPIO_PORTX_SPACING); 442 local_irq_restore(flags); 443} 444EXPORT_SYMBOL(disable_irq_on_gpio_pin); 445 446/* Enable (value == 0) or disable (value == 1) internal pullup */ 447void gpio_pullup(unsigned gpio, int value) 448{ 449 u32 val; 450 unsigned long flags; 451 452 local_irq_save(flags); 453 if (value) { 454 val = readl(virtbase + U300_GPIO_PXPER + PIN_TO_PORT(gpio) * 455 U300_GPIO_PORTX_SPACING); 456 writel(val | (1 << (gpio & 0x07)), virtbase + U300_GPIO_PXPER + 457 PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING); 458 } else { 459 val = readl(virtbase + U300_GPIO_PXPER + PIN_TO_PORT(gpio) * 460 U300_GPIO_PORTX_SPACING); 461 writel(val & ~(1 << (gpio & 0x07)), virtbase + U300_GPIO_PXPER + 462 PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING); 463 } 464 local_irq_restore(flags); 465} 466EXPORT_SYMBOL(gpio_pullup); 467 468static irqreturn_t gpio_irq_handler(int irq, void *dev_id) 469{ 470 struct u300_gpio_port *port = dev_id; 471 u32 val; 472 int pin; 473 474 /* Read event register */ 475 val = readl(virtbase + U300_GPIO_PXIEV + port->number * 476 U300_GPIO_PORTX_SPACING); 477 /* Mask with enable register */ 478 val &= readl(virtbase + U300_GPIO_PXIEV + port->number * 479 U300_GPIO_PORTX_SPACING); 480 /* Mask relevant bits */ 481 val &= U300_GPIO_PXIEV_ALL_IRQ_EVENT_MASK; 482 /* ACK IRQ (clear event) */ 483 writel(val, virtbase + U300_GPIO_PXIEV + port->number * 484 U300_GPIO_PORTX_SPACING); 485 /* Print message */ 486 while (val != 0) { 487 unsigned gpio; 488 489 pin = __ffs(val); 490 /* mask off this pin */ 491 val &= ~(1 << pin); 492 gpio = (port->number << 3) + pin; 493 494 if (gpio_pin[gpio].callback) 495 (void)gpio_pin[gpio].callback(gpio_pin[gpio].data); 496 else 497 dev_dbg(gpiodev, "stray GPIO IRQ on line %d\n", 498 gpio); 499 } 500 return IRQ_HANDLED; 501} 502 503static void gpio_set_initial_values(void) 504{ 505#ifdef U300_COH901571_3 506 int i, j; 507 unsigned long flags; 508 u32 val; 509 510 /* Write default values to all pins */ 511 for (i = 0; i < U300_GPIO_NUM_PORTS; i++) { 512 val = 0; 513 for (j = 0; j < 8; j++) 514 val |= (u32) (u300_gpio_config[i][j].default_output_value != DEFAULT_OUTPUT_LOW) << j; 515 local_irq_save(flags); 516 writel(val, virtbase + U300_GPIO_PXPDOR + i * U300_GPIO_PORTX_SPACING); 517 local_irq_restore(flags); 518 } 519 520 /* 521 * Put all pins that are set to either 'GPIO_OUT' or 'GPIO_NOT_USED' 522 * to output and 'GPIO_IN' to input for each port. And initialize 523 * default value on outputs. 524 */ 525 for (i = 0; i < U300_GPIO_NUM_PORTS; i++) { 526 for (j = 0; j < U300_GPIO_PINS_PER_PORT; j++) { 527 local_irq_save(flags); 528 val = readl(virtbase + U300_GPIO_PXPCR + 529 i * U300_GPIO_PORTX_SPACING); 530 /* Mask out this pin */ 531 val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << (j << 1)); 532 533 if (u300_gpio_config[i][j].pin_usage != GPIO_IN) 534 val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL << (j << 1)); 535 writel(val, virtbase + U300_GPIO_PXPCR + 536 i * U300_GPIO_PORTX_SPACING); 537 local_irq_restore(flags); 538 } 539 } 540 541 /* Enable or disable the internal pull-ups in the GPIO ASIC block */ 542 for (i = 0; i < U300_GPIO_MAX; i++) { 543 val = 0; 544 for (j = 0; j < 8; j++) 545 val |= (u32)((u300_gpio_config[i][j].pull_up == DISABLE_PULL_UP) << j); 546 local_irq_save(flags); 547 writel(val, virtbase + U300_GPIO_PXPER + i * U300_GPIO_PORTX_SPACING); 548 local_irq_restore(flags); 549 } 550#endif 551} 552 553static int __init gpio_probe(struct platform_device *pdev) 554{ 555 u32 val; 556 int err = 0; 557 int i; 558 int num_irqs; 559 560 gpiodev = &pdev->dev; 561 memset(gpio_pin, 0, sizeof(gpio_pin)); 562 563 /* Get GPIO clock */ 564 clk = clk_get(&pdev->dev, NULL); 565 if (IS_ERR(clk)) { 566 err = PTR_ERR(clk); 567 dev_err(gpiodev, "could not get GPIO clock\n"); 568 goto err_no_clk; 569 } 570 err = clk_enable(clk); 571 if (err) { 572 dev_err(gpiodev, "could not enable GPIO clock\n"); 573 goto err_no_clk_enable; 574 } 575 576 memres = platform_get_resource(pdev, IORESOURCE_MEM, 0); 577 if (!memres) 578 goto err_no_resource; 579 580 if (request_mem_region(memres->start, memres->end - memres->start, "GPIO Controller") 581 == NULL) { 582 err = -ENODEV; 583 goto err_no_ioregion; 584 } 585 586 virtbase = ioremap(memres->start, resource_size(memres)); 587 if (!virtbase) { 588 err = -ENOMEM; 589 goto err_no_ioremap; 590 } 591 dev_info(gpiodev, "remapped 0x%08x to %p\n", 592 memres->start, virtbase); 593 594#ifdef U300_COH901335 595 dev_info(gpiodev, "initializing GPIO Controller COH 901 335\n"); 596 /* Turn on the GPIO block */ 597 writel(U300_GPIO_CR_BLOCK_CLOCK_ENABLE, virtbase + U300_GPIO_CR); 598#endif 599 600#ifdef U300_COH901571_3 601 dev_info(gpiodev, "initializing GPIO Controller COH 901 571/3\n"); 602 val = readl(virtbase + U300_GPIO_CR); 603 dev_info(gpiodev, "COH901571/3 block version: %d, " \ 604 "number of cores: %d\n", 605 ((val & 0x0000FE00) >> 9), 606 ((val & 0x000001FC) >> 2)); 607 writel(U300_GPIO_CR_BLOCK_CLKRQ_ENABLE, virtbase + U300_GPIO_CR); 608#endif 609 610 gpio_set_initial_values(); 611 612 for (num_irqs = 0 ; num_irqs < U300_GPIO_NUM_PORTS; num_irqs++) { 613 614 gpio_ports[num_irqs].irq = 615 platform_get_irq_byname(pdev, 616 gpio_ports[num_irqs].name); 617 618 err = request_irq(gpio_ports[num_irqs].irq, 619 gpio_irq_handler, IRQF_DISABLED, 620 gpio_ports[num_irqs].name, 621 &gpio_ports[num_irqs]); 622 if (err) { 623 dev_err(gpiodev, "cannot allocate IRQ for %s!\n", 624 gpio_ports[num_irqs].name); 625 goto err_no_irq; 626 } 627 /* Turns off PortX_irq_force */ 628 writel(0x0, virtbase + U300_GPIO_PXIFR + 629 num_irqs * U300_GPIO_PORTX_SPACING); 630 } 631 632 return 0; 633 634 err_no_irq: 635 for (i = 0; i < num_irqs; i++) 636 free_irq(gpio_ports[i].irq, &gpio_ports[i]); 637 iounmap(virtbase); 638 err_no_ioremap: 639 release_mem_region(memres->start, memres->end - memres->start); 640 err_no_ioregion: 641 err_no_resource: 642 clk_disable(clk); 643 err_no_clk_enable: 644 clk_put(clk); 645 err_no_clk: 646 dev_info(gpiodev, "module ERROR:%d\n", err); 647 return err; 648} 649 650static int __exit gpio_remove(struct platform_device *pdev) 651{ 652 int i; 653 654 /* Turn off the GPIO block */ 655 writel(0x00000000U, virtbase + U300_GPIO_CR); 656 for (i = 0 ; i < U300_GPIO_NUM_PORTS; i++) 657 free_irq(gpio_ports[i].irq, &gpio_ports[i]); 658 iounmap(virtbase); 659 release_mem_region(memres->start, memres->end - memres->start); 660 clk_disable(clk); 661 clk_put(clk); 662 return 0; 663} 664 665static struct platform_driver gpio_driver = { 666 .driver = { 667 .name = "u300-gpio", 668 }, 669 .remove = __exit_p(gpio_remove), 670}; 671 672 673static int __init u300_gpio_init(void) 674{ 675 return platform_driver_probe(&gpio_driver, gpio_probe); 676} 677 678static void __exit u300_gpio_exit(void) 679{ 680 platform_driver_unregister(&gpio_driver); 681} 682 683arch_initcall(u300_gpio_init); 684module_exit(u300_gpio_exit); 685 686MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>"); 687 688#ifdef U300_COH901571_3 689MODULE_DESCRIPTION("ST-Ericsson AB COH 901 571/3 GPIO driver"); 690#endif 691 692#ifdef U300_COH901335 693MODULE_DESCRIPTION("ST-Ericsson AB COH 901 335 GPIO driver"); 694#endif 695 696MODULE_LICENSE("GPL"); 697