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