arch/arm/mach-pxa/clock.c

   1 /*
   2  *  linux/arch/arm/mach-sa1100/clock.c
   3  */
   4 #include <linux/module.h>
   5 #include <linux/kernel.h>
   6 #include <linux/list.h>
   7 #include <linux/errno.h>
   8 #include <linux/err.h>
   9 #include <linux/string.h>
  10 #include <linux/clk.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/delay.h>
  14
  15 #include <asm/arch/pxa2xx-regs.h>
  16 #include <asm/arch/pxa2xx-gpio.h>
  17 #include <asm/hardware.h>
  18
  19 #include "devices.h"
  20 #include "generic.h"
  21 #include "clock.h"
  22
  23 static LIST_HEAD(clocks);
  24 static DEFINE_MUTEX(clocks_mutex);
  25 static DEFINE_SPINLOCK(clocks_lock);
  26
  27 static struct clk *clk_lookup(struct device *dev, const char *id)
  28 {
  29         struct clk *p;
  30
  31         list_for_each_entry(p, &clocks, node)
  32                 if (strcmp(id, p->name) == 0 && p->dev == dev)
  33                         return p;
  34
  35         return NULL;
  36 }
  37
  38 struct clk *clk_get(struct device *dev, const char *id)
  39 {
  40         struct clk *p, *clk = ERR_PTR(-ENOENT);
  41
  42         mutex_lock(&clocks_mutex);
  43         p = clk_lookup(dev, id);
  44         if (!p)
  45                 p = clk_lookup(NULL, id);
  46         if (p)
  47                 clk = p;
  48         mutex_unlock(&clocks_mutex);
  49
  50         return clk;
  51 }
  52 EXPORT_SYMBOL(clk_get);
  53
  54 void clk_put(struct clk *clk)
  55 {
  56 }
  57 EXPORT_SYMBOL(clk_put);
  58
  59 int clk_enable(struct clk *clk)
  60 {
  61         unsigned long flags;
  62
  63         spin_lock_irqsave(&clocks_lock, flags);
  64         if (clk->enabled++ == 0)
  65                 clk->ops->enable(clk);
  66         spin_unlock_irqrestore(&clocks_lock, flags);
  67
  68         if (clk->delay)
  69                 udelay(clk->delay);
  70
  71         return 0;
  72 }
  73 EXPORT_SYMBOL(clk_enable);
  74
  75 void clk_disable(struct clk *clk)
  76 {
  77         unsigned long flags;
  78
  79         WARN_ON(clk->enabled == 0);
  80
  81         spin_lock_irqsave(&clocks_lock, flags);
  82         if (--clk->enabled == 0)
  83                 clk->ops->disable(clk);
  84         spin_unlock_irqrestore(&clocks_lock, flags);
  85 }
  86 EXPORT_SYMBOL(clk_disable);
  87
  88 unsigned long clk_get_rate(struct clk *clk)
  89 {
  90         unsigned long rate;
  91
  92         rate = clk->rate;
  93         if (clk->ops->getrate)
  94                 rate = clk->ops->getrate(clk);
  95
  96         return rate;
  97 }
  98 EXPORT_SYMBOL(clk_get_rate);
  99
 100
 101 static void clk_gpio27_enable(struct clk *clk)
 102 {
 103         pxa_gpio_mode(GPIO11_3_6MHz_MD);
 104 }
 105
 106 static void clk_gpio27_disable(struct clk *clk)
 107 {
 108 }
 109
 110 static const struct clkops clk_gpio27_ops = {
 111         .enable         = clk_gpio27_enable,
 112         .disable        = clk_gpio27_disable,
 113 };
 114
 115
 116 void clk_cken_enable(struct clk *clk)
 117 {
 118         CKEN |= 1 << clk->cken;
 119 }
 120
 121 void clk_cken_disable(struct clk *clk)
 122 {
 123         CKEN &= ~(1 << clk->cken);
 124 }
 125
 126 const struct clkops clk_cken_ops = {
 127         .enable         = clk_cken_enable,
 128         .disable        = clk_cken_disable,
 129 };
 130
 131 static struct clk common_clks[] = {
 132         {
 133                 .name           = "GPIO27_CLK",
 134                 .ops            = &clk_gpio27_ops,
 135                 .rate           = 3686400,
 136         },
 137 };
 138
 139 void clks_register(struct clk *clks, size_t num)
 140 {
 141         int i;
 142
 143         mutex_lock(&clocks_mutex);
 144         for (i = 0; i < num; i++)
 145                 list_add(&clks[i].node, &clocks);
 146         mutex_unlock(&clocks_mutex);
 147 }
 148
 149 static int __init clk_init(void)
 150 {
 151         clks_register(common_clks, ARRAY_SIZE(common_clks));
 152         return 0;
 153 }
 154 arch_initcall(clk_init);