arch/arm/plat-orion/gpio.c

   1 /*
   2  * arch/arm/plat-orion/gpio.c
   3  *
   4  * Marvell Orion SoC GPIO handling.
   5  *
   6  * This file is licensed under the terms of the GNU General Public
   7  * License version 2.  This program is licensed "as is" without any
   8  * warranty of any kind, whether express or implied.
   9  */
  10
  11 #define DEBUG
  12
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/irq.h>
  16 #include <linux/irqdomain.h>
  17 #include <linux/module.h>
  18 #include <linux/spinlock.h>
  19 #include <linux/bitops.h>
  20 #include <linux/io.h>
  21 #include <linux/gpio.h>
  22 #include <linux/leds.h>
  23 #include <linux/of.h>
  24 #include <linux/of_irq.h>
  25 #include <linux/of_address.h>
  26 #include <plat/orion-gpio.h>
  27
  28 /*
  29  * GPIO unit register offsets.
  30  */
  31 #define GPIO_OUT_OFF            0x0000
  32 #define GPIO_IO_CONF_OFF        0x0004
  33 #define GPIO_BLINK_EN_OFF       0x0008
  34 #define GPIO_IN_POL_OFF         0x000c
  35 #define GPIO_DATA_IN_OFF        0x0010
  36 #define GPIO_EDGE_CAUSE_OFF     0x0014
  37 #define GPIO_EDGE_MASK_OFF      0x0018
  38 #define GPIO_LEVEL_MASK_OFF     0x001c
  39
  40 struct orion_gpio_chip {
  41         struct gpio_chip        chip;
  42         spinlock_t              lock;
  43         void __iomem            *base;
  44         unsigned long           valid_input;
  45         unsigned long           valid_output;
  46         int                     mask_offset;
  47         int                     secondary_irq_base;
  48         struct irq_domain       *domain;
  49 };
  50
  51 static void __iomem *GPIO_OUT(struct orion_gpio_chip *ochip)
  52 {
  53         return ochip->base + GPIO_OUT_OFF;
  54 }
  55
  56 static void __iomem *GPIO_IO_CONF(struct orion_gpio_chip *ochip)
  57 {
  58         return ochip->base + GPIO_IO_CONF_OFF;
  59 }
  60
  61 static void __iomem *GPIO_BLINK_EN(struct orion_gpio_chip *ochip)
  62 {
  63         return ochip->base + GPIO_BLINK_EN_OFF;
  64 }
  65
  66 static void __iomem *GPIO_IN_POL(struct orion_gpio_chip *ochip)
  67 {
  68         return ochip->base + GPIO_IN_POL_OFF;
  69 }
  70
  71 static void __iomem *GPIO_DATA_IN(struct orion_gpio_chip *ochip)
  72 {
  73         return ochip->base + GPIO_DATA_IN_OFF;
  74 }
  75
  76 static void __iomem *GPIO_EDGE_CAUSE(struct orion_gpio_chip *ochip)
  77 {
  78         return ochip->base + GPIO_EDGE_CAUSE_OFF;
  79 }
  80
  81 static void __iomem *GPIO_EDGE_MASK(struct orion_gpio_chip *ochip)
  82 {
  83         return ochip->base + ochip->mask_offset + GPIO_EDGE_MASK_OFF;
  84 }
  85
  86 static void __iomem *GPIO_LEVEL_MASK(struct orion_gpio_chip *ochip)
  87 {
  88         return ochip->base + ochip->mask_offset + GPIO_LEVEL_MASK_OFF;
  89 }
  90
  91
  92 static struct orion_gpio_chip orion_gpio_chips[2];
  93 static int orion_gpio_chip_count;
  94
  95 static inline void
  96 __set_direction(struct orion_gpio_chip *ochip, unsigned pin, int input)
  97 {
  98         u32 u;
  99
 100         u = readl(GPIO_IO_CONF(ochip));
 101         if (input)
 102                 u |= 1 << pin;
 103         else
 104                 u &= ~(1 << pin);
 105         writel(u, GPIO_IO_CONF(ochip));
 106 }
 107
 108 static void __set_level(struct orion_gpio_chip *ochip, unsigned pin, int high)
 109 {
 110         u32 u;
 111
 112         u = readl(GPIO_OUT(ochip));
 113         if (high)
 114                 u |= 1 << pin;
 115         else
 116                 u &= ~(1 << pin);
 117         writel(u, GPIO_OUT(ochip));
 118 }
 119
 120 static inline void
 121 __set_blinking(struct orion_gpio_chip *ochip, unsigned pin, int blink)
 122 {
 123         u32 u;
 124
 125         u = readl(GPIO_BLINK_EN(ochip));
 126         if (blink)
 127                 u |= 1 << pin;
 128         else
 129                 u &= ~(1 << pin);
 130         writel(u, GPIO_BLINK_EN(ochip));
 131 }
 132
 133 static inline int
 134 orion_gpio_is_valid(struct orion_gpio_chip *ochip, unsigned pin, int mode)
 135 {
 136         if (pin >= ochip->chip.ngpio)
 137                 goto err_out;
 138
 139         if ((mode & GPIO_INPUT_OK) && !test_bit(pin, &ochip->valid_input))
 140                 goto err_out;
 141
 142         if ((mode & GPIO_OUTPUT_OK) && !test_bit(pin, &ochip->valid_output))
 143                 goto err_out;
 144
 145         return 1;
 146
 147 err_out:
 148         pr_debug("%s: invalid GPIO %d\n", __func__, pin);
 149         return false;
 150 }
 151
 152 /*
 153  * GENERIC_GPIO primitives.
 154  */
 155 static int orion_gpio_request(struct gpio_chip *chip, unsigned pin)
 156 {
 157         struct orion_gpio_chip *ochip =
 158                 container_of(chip, struct orion_gpio_chip, chip);
 159
 160         if (orion_gpio_is_valid(ochip, pin, GPIO_INPUT_OK) ||
 161             orion_gpio_is_valid(ochip, pin, GPIO_OUTPUT_OK))
 162                 return 0;
 163
 164         return -EINVAL;
 165 }
 166
 167 static int orion_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
 168 {
 169         struct orion_gpio_chip *ochip =
 170                 container_of(chip, struct orion_gpio_chip, chip);
 171         unsigned long flags;
 172
 173         if (!orion_gpio_is_valid(ochip, pin, GPIO_INPUT_OK))
 174                 return -EINVAL;
 175
 176         spin_lock_irqsave(&ochip->lock, flags);
 177         __set_direction(ochip, pin, 1);
 178         spin_unlock_irqrestore(&ochip->lock, flags);
 179
 180         return 0;
 181 }
 182
 183 static int orion_gpio_get(struct gpio_chip *chip, unsigned pin)
 184 {
 185         struct orion_gpio_chip *ochip =
 186                 container_of(chip, struct orion_gpio_chip, chip);
 187         int val;
 188
 189         if (readl(GPIO_IO_CONF(ochip)) & (1 << pin)) {
 190                 val = readl(GPIO_DATA_IN(ochip)) ^ readl(GPIO_IN_POL(ochip));
 191         } else {
 192                 val = readl(GPIO_OUT(ochip));
 193         }
 194
 195         return (val >> pin) & 1;
 196 }
 197
 198 static int
 199 orion_gpio_direction_output(struct gpio_chip *chip, unsigned pin, int value)
 200 {
 201         struct orion_gpio_chip *ochip =
 202                 container_of(chip, struct orion_gpio_chip, chip);
 203         unsigned long flags;
 204
 205         if (!orion_gpio_is_valid(ochip, pin, GPIO_OUTPUT_OK))
 206                 return -EINVAL;
 207
 208         spin_lock_irqsave(&ochip->lock, flags);
 209         __set_blinking(ochip, pin, 0);
 210         __set_level(ochip, pin, value);
 211         __set_direction(ochip, pin, 0);
 212         spin_unlock_irqrestore(&ochip->lock, flags);
 213
 214         return 0;
 215 }
 216
 217 static void orion_gpio_set(struct gpio_chip *chip, unsigned pin, int value)
 218 {
 219         struct orion_gpio_chip *ochip =
 220                 container_of(chip, struct orion_gpio_chip, chip);
 221         unsigned long flags;
 222
 223         spin_lock_irqsave(&ochip->lock, flags);
 224         __set_level(ochip, pin, value);
 225         spin_unlock_irqrestore(&ochip->lock, flags);
 226 }
 227
 228 static int orion_gpio_to_irq(struct gpio_chip *chip, unsigned pin)
 229 {
 230         struct orion_gpio_chip *ochip =
 231                 container_of(chip, struct orion_gpio_chip, chip);
 232
 233         return irq_create_mapping(ochip->domain,
 234                                   ochip->secondary_irq_base + pin);
 235 }
 236
 237 /*
 238  * Orion-specific GPIO API extensions.
 239  */
 240 static struct orion_gpio_chip *orion_gpio_chip_find(int pin)
 241 {
 242         int i;
 243
 244         for (i = 0; i < orion_gpio_chip_count; i++) {
 245                 struct orion_gpio_chip *ochip = orion_gpio_chips + i;
 246                 struct gpio_chip *chip = &ochip->chip;
 247
 248                 if (pin >= chip->base && pin < chip->base + chip->ngpio)
 249                         return ochip;
 250         }
 251
 252         return NULL;
 253 }
 254
 255 void __init orion_gpio_set_unused(unsigned pin)
 256 {
 257         struct orion_gpio_chip *ochip = orion_gpio_chip_find(pin);
 258
 259         if (ochip == NULL)
 260                 return;
 261
 262         pin -= ochip->chip.base;
 263
 264         /* Configure as output, drive low. */
 265         __set_level(ochip, pin, 0);
 266         __set_direction(ochip, pin, 0);
 267 }
 268
 269 void __init orion_gpio_set_valid(unsigned pin, int mode)
 270 {
 271         struct orion_gpio_chip *ochip = orion_gpio_chip_find(pin);
 272
 273         if (ochip == NULL)
 274                 return;
 275
 276         pin -= ochip->chip.base;
 277
 278         if (mode == 1)
 279                 mode = GPIO_INPUT_OK | GPIO_OUTPUT_OK;
 280
 281         if (mode & GPIO_INPUT_OK)
 282                 __set_bit(pin, &ochip->valid_input);
 283         else
 284                 __clear_bit(pin, &ochip->valid_input);
 285
 286         if (mode & GPIO_OUTPUT_OK)
 287                 __set_bit(pin, &ochip->valid_output);
 288         else
 289                 __clear_bit(pin, &ochip->valid_output);
 290 }
 291
 292 void orion_gpio_set_blink(unsigned pin, int blink)
 293 {
 294         struct orion_gpio_chip *ochip = orion_gpio_chip_find(pin);
 295         unsigned long flags;
 296
 297         if (ochip == NULL)
 298                 return;
 299
 300         spin_lock_irqsave(&ochip->lock, flags);
 301         __set_level(ochip, pin & 31, 0);
 302         __set_blinking(ochip, pin & 31, blink);
 303         spin_unlock_irqrestore(&ochip->lock, flags);
 304 }
 305 EXPORT_SYMBOL(orion_gpio_set_blink);
 306
 307 #define ORION_BLINK_HALF_PERIOD 100 /* ms */
 308
 309 int orion_gpio_led_blink_set(unsigned gpio, int state,
 310         unsigned long *delay_on, unsigned long *delay_off)
 311 {
 312
 313         if (delay_on && delay_off && !*delay_on && !*delay_off)
 314                 *delay_on = *delay_off = ORION_BLINK_HALF_PERIOD;
 315
 316         switch (state) {
 317         case GPIO_LED_NO_BLINK_LOW:
 318         case GPIO_LED_NO_BLINK_HIGH:
 319                 orion_gpio_set_blink(gpio, 0);
 320                 gpio_set_value(gpio, state);
 321                 break;
 322         case GPIO_LED_BLINK:
 323                 orion_gpio_set_blink(gpio, 1);
 324         }
 325         return 0;
 326 }
 327 EXPORT_SYMBOL_GPL(orion_gpio_led_blink_set);
 328
 329
 330 /*****************************************************************************
 331  * Orion GPIO IRQ
 332  *
 333  * GPIO_IN_POL register controls whether GPIO_DATA_IN will hold the same
 334  * value of the line or the opposite value.
 335  *
 336  * Level IRQ handlers: DATA_IN is used directly as cause register.
 337  *                     Interrupt are masked by LEVEL_MASK registers.
 338  * Edge IRQ handlers:  Change in DATA_IN are latched in EDGE_CAUSE.
 339  *                     Interrupt are masked by EDGE_MASK registers.
 340  * Both-edge handlers: Similar to regular Edge handlers, but also swaps
 341  *                     the polarity to catch the next line transaction.
 342  *                     This is a race condition that might not perfectly
 343  *                     work on some use cases.
 344  *
 345  * Every eight GPIO lines are grouped (OR'ed) before going up to main
 346  * cause register.
 347  *
 348  *                    EDGE  cause    mask
 349  *        data-in   /--------| |-----| |----\
 350  *     -----| |-----                         ---- to main cause reg
 351  *           X      \----------------| |----/
 352  *        polarity    LEVEL          mask
 353  *
 354  ****************************************************************************/
 355
 356 static int gpio_irq_set_type(struct irq_data *d, u32 type)
 357 {
 358         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
 359         struct irq_chip_type *ct = irq_data_get_chip_type(d);
 360         struct orion_gpio_chip *ochip = gc->private;
 361         int pin;
 362         u32 u;
 363
 364         pin = d->hwirq - ochip->secondary_irq_base;
 365
 366         u = readl(GPIO_IO_CONF(ochip)) & (1 << pin);
 367         if (!u) {
 368                 return -EINVAL;
 369         }
 370
 371         type &= IRQ_TYPE_SENSE_MASK;
 372         if (type == IRQ_TYPE_NONE)
 373                 return -EINVAL;
 374
 375         /* Check if we need to change chip and handler */
 376         if (!(ct->type & type))
 377                 if (irq_setup_alt_chip(d, type))
 378                         return -EINVAL;
 379
 380         /*
 381          * Configure interrupt polarity.
 382          */
 383         if (type == IRQ_TYPE_EDGE_RISING || type == IRQ_TYPE_LEVEL_HIGH) {
 384                 u = readl(GPIO_IN_POL(ochip));
 385                 u &= ~(1 << pin);
 386                 writel(u, GPIO_IN_POL(ochip));
 387         } else if (type == IRQ_TYPE_EDGE_FALLING || type == IRQ_TYPE_LEVEL_LOW) {
 388                 u = readl(GPIO_IN_POL(ochip));
 389                 u |= 1 << pin;
 390                 writel(u, GPIO_IN_POL(ochip));
 391         } else if (type == IRQ_TYPE_EDGE_BOTH) {
 392                 u32 v;
 393
 394                 v = readl(GPIO_IN_POL(ochip)) ^ readl(GPIO_DATA_IN(ochip));
 395
 396                 /*
 397                  * set initial polarity based on current input level
 398                  */
 399                 u = readl(GPIO_IN_POL(ochip));
 400                 if (v & (1 << pin))
 401                         u |= 1 << pin;          /* falling */
 402                 else
 403                         u &= ~(1 << pin);       /* rising */
 404                 writel(u, GPIO_IN_POL(ochip));
 405         }
 406         return 0;
 407 }
 408
 409 static void gpio_irq_handler(unsigned irq, struct irq_desc *desc)
 410 {
 411         struct orion_gpio_chip *ochip = irq_get_handler_data(irq);
 412         u32 cause, type;
 413         int i;
 414
 415         if (ochip == NULL)
 416                 return;
 417
 418         cause = readl(GPIO_DATA_IN(ochip)) & readl(GPIO_LEVEL_MASK(ochip));
 419         cause |= readl(GPIO_EDGE_CAUSE(ochip)) & readl(GPIO_EDGE_MASK(ochip));
 420
 421         for (i = 0; i < ochip->chip.ngpio; i++) {
 422                 int irq;
 423
 424                 irq = ochip->secondary_irq_base + i;
 425
 426                 if (!(cause & (1 << i)))
 427                         continue;
 428
 429                 type = irqd_get_trigger_type(irq_get_irq_data(irq));
 430                 if ((type & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH) {
 431                         /* Swap polarity (race with GPIO line) */
 432                         u32 polarity;
 433
 434                         polarity = readl(GPIO_IN_POL(ochip));
 435                         polarity ^= 1 << i;
 436                         writel(polarity, GPIO_IN_POL(ochip));
 437                 }
 438                 generic_handle_irq(irq);
 439         }
 440 }
 441
 442 void __init orion_gpio_init(struct device_node *np,
 443                             int gpio_base, int ngpio,
 444                             void __iomem *base, int mask_offset,
 445                             int secondary_irq_base,
 446                             int irqs[4])
 447 {
 448         struct orion_gpio_chip *ochip;
 449         struct irq_chip_generic *gc;
 450         struct irq_chip_type *ct;
 451         char gc_label[16];
 452         int i;
 453
 454         if (orion_gpio_chip_count == ARRAY_SIZE(orion_gpio_chips))
 455                 return;
 456
 457         snprintf(gc_label, sizeof(gc_label), "orion_gpio%d",
 458                 orion_gpio_chip_count);
 459
 460         ochip = orion_gpio_chips + orion_gpio_chip_count;
 461         ochip->chip.label = kstrdup(gc_label, GFP_KERNEL);
 462         ochip->chip.request = orion_gpio_request;
 463         ochip->chip.direction_input = orion_gpio_direction_input;
 464         ochip->chip.get = orion_gpio_get;
 465         ochip->chip.direction_output = orion_gpio_direction_output;
 466         ochip->chip.set = orion_gpio_set;
 467         ochip->chip.to_irq = orion_gpio_to_irq;
 468         ochip->chip.base = gpio_base;
 469         ochip->chip.ngpio = ngpio;
 470         ochip->chip.can_sleep = 0;
 471 #ifdef CONFIG_OF
 472         ochip->chip.of_node = np;
 473 #endif
 474
 475         spin_lock_init(&ochip->lock);
 476         ochip->base = (void __iomem *)base;
 477         ochip->valid_input = 0;
 478         ochip->valid_output = 0;
 479         ochip->mask_offset = mask_offset;
 480         ochip->secondary_irq_base = secondary_irq_base;
 481
 482         gpiochip_add(&ochip->chip);
 483
 484         /*
 485          * Mask and clear GPIO interrupts.
 486          */
 487         writel(0, GPIO_EDGE_CAUSE(ochip));
 488         writel(0, GPIO_EDGE_MASK(ochip));
 489         writel(0, GPIO_LEVEL_MASK(ochip));
 490
 491         /* Setup the interrupt handlers. Each chip can have up to 4
 492          * interrupt handlers, with each handler dealing with 8 GPIO
 493          * pins. */
 494
 495         for (i = 0; i < 4; i++) {
 496                 if (irqs[i]) {
 497                         irq_set_handler_data(irqs[i], ochip);
 498                         irq_set_chained_handler(irqs[i], gpio_irq_handler);
 499                 }
 500         }
 501
 502         gc = irq_alloc_generic_chip("orion_gpio_irq", 2,
 503                                     secondary_irq_base,
 504                                     ochip->base, handle_level_irq);
 505         gc->private = ochip;
 506         ct = gc->chip_types;
 507         ct->regs.mask = ochip->mask_offset + GPIO_LEVEL_MASK_OFF;
 508         ct->type = IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW;
 509         ct->chip.irq_mask = irq_gc_mask_clr_bit;
 510         ct->chip.irq_unmask = irq_gc_mask_set_bit;
 511         ct->chip.irq_set_type = gpio_irq_set_type;
 512         ct->chip.name = ochip->chip.label;
 513
 514         ct++;
 515         ct->regs.mask = ochip->mask_offset + GPIO_EDGE_MASK_OFF;
 516         ct->regs.ack = GPIO_EDGE_CAUSE_OFF;
 517         ct->type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
 518         ct->chip.irq_ack = irq_gc_ack_clr_bit;
 519         ct->chip.irq_mask = irq_gc_mask_clr_bit;
 520         ct->chip.irq_unmask = irq_gc_mask_set_bit;
 521         ct->chip.irq_set_type = gpio_irq_set_type;
 522         ct->handler = handle_edge_irq;
 523         ct->chip.name = ochip->chip.label;
 524
 525         irq_setup_generic_chip(gc, IRQ_MSK(ngpio), IRQ_GC_INIT_MASK_CACHE,
 526                                IRQ_NOREQUEST, IRQ_LEVEL | IRQ_NOPROBE);
 527
 528         /* Setup irq domain on top of the generic chip. */
 529         ochip->domain = irq_domain_add_legacy(np,
 530                                               ochip->chip.ngpio,
 531                                               ochip->secondary_irq_base,
 532                                               ochip->secondary_irq_base,
 533                                               &irq_domain_simple_ops,
 534                                               ochip);
 535         if (!ochip->domain)
 536                 panic("%s: couldn't allocate irq domain (DT).\n",
 537                       ochip->chip.label);
 538
 539         orion_gpio_chip_count++;
 540 }
 541
 542 #ifdef CONFIG_OF
 543 static void __init orion_gpio_of_init_one(struct device_node *np,
 544                                           int irq_gpio_base)
 545 {
 546         int ngpio, gpio_base, mask_offset;
 547         void __iomem *base;
 548         int ret, i;
 549         int irqs[4];
 550         int secondary_irq_base;
 551
 552         ret = of_property_read_u32(np, "ngpio", &ngpio);
 553         if (ret)
 554                 goto out;
 555         ret = of_property_read_u32(np, "mask-offset", &mask_offset);
 556         if (ret == -EINVAL)
 557                 mask_offset = 0;
 558         else
 559                 goto out;
 560         base = of_iomap(np, 0);
 561         if (!base)
 562                 goto out;
 563
 564         secondary_irq_base = irq_gpio_base + (32 * orion_gpio_chip_count);
 565         gpio_base = 32 * orion_gpio_chip_count;
 566
 567         /* Get the interrupt numbers. Each chip can have up to 4
 568          * interrupt handlers, with each handler dealing with 8 GPIO
 569          * pins. */
 570
 571         for (i = 0; i < 4; i++)
 572                 irqs[i] = irq_of_parse_and_map(np, i);
 573
 574         orion_gpio_init(np, gpio_base, ngpio, base, mask_offset,
 575                         secondary_irq_base, irqs);
 576         return;
 577 out:
 578         pr_err("%s: %s: missing mandatory property\n", __func__, np->name);
 579 }
 580
 581 void __init orion_gpio_of_init(int irq_gpio_base)
 582 {
 583         struct device_node *np;
 584
 585         for_each_compatible_node(np, NULL, "marvell,orion-gpio")
 586                 orion_gpio_of_init_one(np, irq_gpio_base);
 587 }
 588 #endif