arch/avr32/mach-at32ap/pio.c

   1 /*
   2  * Atmel PIO2 Port Multiplexer support
   3  *
   4  * Copyright (C) 2004-2006 Atmel Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/clk.h>
  12 #include <linux/debugfs.h>
  13 #include <linux/fs.h>
  14 #include <linux/platform_device.h>
  15
  16 #include <asm/io.h>
  17
  18 #include <asm/arch/portmux.h>
  19
  20 #include "pio.h"
  21
  22 #define MAX_NR_PIO_DEVICES              8
  23
  24 struct pio_device {
  25         void __iomem *regs;
  26         const struct platform_device *pdev;
  27         struct clk *clk;
  28         u32 pinmux_mask;
  29         char name[32];
  30 };
  31
  32 static struct pio_device pio_dev[MAX_NR_PIO_DEVICES];
  33
  34 static struct pio_device *gpio_to_pio(unsigned int gpio)
  35 {
  36         struct pio_device *pio;
  37         unsigned int index;
  38
  39         index = gpio >> 5;
  40         if (index >= MAX_NR_PIO_DEVICES)
  41                 return NULL;
  42         pio = &pio_dev[index];
  43         if (!pio->regs)
  44                 return NULL;
  45
  46         return pio;
  47 }
  48
  49 /* Pin multiplexing API */
  50
  51 void __init at32_select_periph(unsigned int pin, unsigned int periph,
  52                                unsigned long flags)
  53 {
  54         struct pio_device *pio;
  55         unsigned int pin_index = pin & 0x1f;
  56         u32 mask = 1 << pin_index;
  57
  58         pio = gpio_to_pio(pin);
  59         if (unlikely(!pio)) {
  60                 printk("pio: invalid pin %u\n", pin);
  61                 goto fail;
  62         }
  63
  64         if (unlikely(test_and_set_bit(pin_index, &pio->pinmux_mask))) {
  65                 printk("%s: pin %u is busy\n", pio->name, pin_index);
  66                 goto fail;
  67         }
  68
  69         pio_writel(pio, PUER, mask);
  70         if (periph)
  71                 pio_writel(pio, BSR, mask);
  72         else
  73                 pio_writel(pio, ASR, mask);
  74
  75         pio_writel(pio, PDR, mask);
  76         if (!(flags & AT32_GPIOF_PULLUP))
  77                 pio_writel(pio, PUDR, mask);
  78
  79         return;
  80
  81 fail:
  82         dump_stack();
  83 }
  84
  85 void __init at32_select_gpio(unsigned int pin, unsigned long flags)
  86 {
  87         struct pio_device *pio;
  88         unsigned int pin_index = pin & 0x1f;
  89         u32 mask = 1 << pin_index;
  90
  91         pio = gpio_to_pio(pin);
  92         if (unlikely(!pio)) {
  93                 printk("pio: invalid pin %u\n", pin);
  94                 goto fail;
  95         }
  96
  97         if (unlikely(test_and_set_bit(pin_index, &pio->pinmux_mask))) {
  98                 printk("%s: pin %u is busy\n", pio->name, pin_index);
  99                 goto fail;
 100         }
 101
 102         pio_writel(pio, PUER, mask);
 103         if (flags & AT32_GPIOF_HIGH)
 104                 pio_writel(pio, SODR, mask);
 105         else
 106                 pio_writel(pio, CODR, mask);
 107         if (flags & AT32_GPIOF_OUTPUT)
 108                 pio_writel(pio, OER, mask);
 109         else
 110                 pio_writel(pio, ODR, mask);
 111
 112         pio_writel(pio, PER, mask);
 113         if (!(flags & AT32_GPIOF_PULLUP))
 114                 pio_writel(pio, PUDR, mask);
 115
 116         return;
 117
 118 fail:
 119         dump_stack();
 120 }
 121
 122 static int __init pio_probe(struct platform_device *pdev)
 123 {
 124         struct pio_device *pio = NULL;
 125
 126         BUG_ON(pdev->id >= MAX_NR_PIO_DEVICES);
 127         pio = &pio_dev[pdev->id];
 128         BUG_ON(!pio->regs);
 129
 130         /* TODO: Interrupts */
 131
 132         platform_set_drvdata(pdev, pio);
 133
 134         printk(KERN_INFO "%s: Atmel Port Multiplexer at 0x%p (irq %d)\n",
 135                pio->name, pio->regs, platform_get_irq(pdev, 0));
 136
 137         return 0;
 138 }
 139
 140 static struct platform_driver pio_driver = {
 141         .probe          = pio_probe,
 142         .driver         = {
 143                 .name           = "pio",
 144         },
 145 };
 146
 147 static int __init pio_init(void)
 148 {
 149         return platform_driver_register(&pio_driver);
 150 }
 151 subsys_initcall(pio_init);
 152
 153 void __init at32_init_pio(struct platform_device *pdev)
 154 {
 155         struct resource *regs;
 156         struct pio_device *pio;
 157
 158         if (pdev->id > MAX_NR_PIO_DEVICES) {
 159                 dev_err(&pdev->dev, "only %d PIO devices supported\n",
 160                         MAX_NR_PIO_DEVICES);
 161                 return;
 162         }
 163
 164         pio = &pio_dev[pdev->id];
 165         snprintf(pio->name, sizeof(pio->name), "pio%d", pdev->id);
 166
 167         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 168         if (!regs) {
 169                 dev_err(&pdev->dev, "no mmio resource defined\n");
 170                 return;
 171         }
 172
 173         pio->clk = clk_get(&pdev->dev, "mck");
 174         if (IS_ERR(pio->clk))
 175                 /*
 176                  * This is a fatal error, but if we continue we might
 177                  * be so lucky that we manage to initialize the
 178                  * console and display this message...
 179                  */
 180                 dev_err(&pdev->dev, "no mck clock defined\n");
 181         else
 182                 clk_enable(pio->clk);
 183
 184         pio->pdev = pdev;
 185         pio->regs = ioremap(regs->start, regs->end - regs->start + 1);
 186
 187         pio_writel(pio, ODR, ~0UL);
 188         pio_writel(pio, PER, ~0UL);
 189 }