drivers/clk/versatile/clk-sp810.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License version 2 as
   4  * published by the Free Software Foundation.
   5  *
   6  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  * GNU General Public License for more details.
  10  *
  11  * Copyright (C) 2013 ARM Limited
  12  */
  13
  14 #include <linux/amba/sp810.h>
  15 #include <linux/clkdev.h>
  16 #include <linux/clk-provider.h>
  17 #include <linux/err.h>
  18 #include <linux/of.h>
  19 #include <linux/of_address.h>
  20
  21 #define to_clk_sp810_timerclken(_hw) \
  22                 container_of(_hw, struct clk_sp810_timerclken, hw)
  23
  24 struct clk_sp810;
  25
  26 struct clk_sp810_timerclken {
  27         struct clk_hw hw;
  28         struct clk *clk;
  29         struct clk_sp810 *sp810;
  30         int channel;
  31 };
  32
  33 struct clk_sp810 {
  34         struct device_node *node;
  35         int refclk_index, timclk_index;
  36         void __iomem *base;
  37         spinlock_t lock;
  38         struct clk_sp810_timerclken timerclken[4];
  39         struct clk *refclk;
  40         struct clk *timclk;
  41 };
  42
  43 static u8 clk_sp810_timerclken_get_parent(struct clk_hw *hw)
  44 {
  45         struct clk_sp810_timerclken *timerclken = to_clk_sp810_timerclken(hw);
  46         u32 val = readl(timerclken->sp810->base + SCCTRL);
  47
  48         return !!(val & (1 << SCCTRL_TIMERENnSEL_SHIFT(timerclken->channel)));
  49 }
  50
  51 static int clk_sp810_timerclken_set_parent(struct clk_hw *hw, u8 index)
  52 {
  53         struct clk_sp810_timerclken *timerclken = to_clk_sp810_timerclken(hw);
  54         struct clk_sp810 *sp810 = timerclken->sp810;
  55         u32 val, shift = SCCTRL_TIMERENnSEL_SHIFT(timerclken->channel);
  56         unsigned long flags = 0;
  57
  58         if (WARN_ON(index > 1))
  59                 return -EINVAL;
  60
  61         spin_lock_irqsave(&sp810->lock, flags);
  62
  63         val = readl(sp810->base + SCCTRL);
  64         val &= ~(1 << shift);
  65         val |= index << shift;
  66         writel(val, sp810->base + SCCTRL);
  67
  68         spin_unlock_irqrestore(&sp810->lock, flags);
  69
  70         return 0;
  71 }
  72
  73 /*
  74  * FIXME - setting the parent every time .prepare is invoked is inefficient.
  75  * This is better handled by a dedicated clock tree configuration mechanism at
  76  * init-time.  Revisit this later when such a mechanism exists
  77  */
  78 static int clk_sp810_timerclken_prepare(struct clk_hw *hw)
  79 {
  80         struct clk_sp810_timerclken *timerclken = to_clk_sp810_timerclken(hw);
  81         struct clk_sp810 *sp810 = timerclken->sp810;
  82         struct clk *old_parent = __clk_get_parent(hw->clk);
  83         struct clk *new_parent;
  84
  85         if (!sp810->refclk)
  86                 sp810->refclk = of_clk_get(sp810->node, sp810->refclk_index);
  87
  88         if (!sp810->timclk)
  89                 sp810->timclk = of_clk_get(sp810->node, sp810->timclk_index);
  90
  91         if (WARN_ON(IS_ERR(sp810->refclk) || IS_ERR(sp810->timclk)))
  92                 return -ENOENT;
  93
  94         /* Select fastest parent */
  95         if (clk_get_rate(sp810->refclk) > clk_get_rate(sp810->timclk))
  96                 new_parent = sp810->refclk;
  97         else
  98                 new_parent = sp810->timclk;
  99
 100         /* Switch the parent if necessary */
 101         if (old_parent != new_parent) {
 102                 clk_prepare(new_parent);
 103                 clk_set_parent(hw->clk, new_parent);
 104                 clk_unprepare(old_parent);
 105         }
 106
 107         return 0;
 108 }
 109
 110 static void clk_sp810_timerclken_unprepare(struct clk_hw *hw)
 111 {
 112         struct clk_sp810_timerclken *timerclken = to_clk_sp810_timerclken(hw);
 113         struct clk_sp810 *sp810 = timerclken->sp810;
 114
 115         clk_put(sp810->timclk);
 116         clk_put(sp810->refclk);
 117 }
 118
 119 static const struct clk_ops clk_sp810_timerclken_ops = {
 120         .prepare = clk_sp810_timerclken_prepare,
 121         .unprepare = clk_sp810_timerclken_unprepare,
 122         .get_parent = clk_sp810_timerclken_get_parent,
 123         .set_parent = clk_sp810_timerclken_set_parent,
 124 };
 125
 126 struct clk *clk_sp810_timerclken_of_get(struct of_phandle_args *clkspec,
 127                 void *data)
 128 {
 129         struct clk_sp810 *sp810 = data;
 130
 131         if (WARN_ON(clkspec->args_count != 1 || clkspec->args[0] >
 132                         ARRAY_SIZE(sp810->timerclken)))
 133                 return NULL;
 134
 135         return sp810->timerclken[clkspec->args[0]].clk;
 136 }
 137
 138 void __init clk_sp810_of_setup(struct device_node *node)
 139 {
 140         struct clk_sp810 *sp810 = kzalloc(sizeof(*sp810), GFP_KERNEL);
 141         const char *parent_names[2];
 142         char name[12];
 143         struct clk_init_data init;
 144         int i;
 145
 146         if (!sp810) {
 147                 pr_err("Failed to allocate memory for SP810!\n");
 148                 return;
 149         }
 150
 151         sp810->refclk_index = of_property_match_string(node, "clock-names",
 152                         "refclk");
 153         parent_names[0] = of_clk_get_parent_name(node, sp810->refclk_index);
 154
 155         sp810->timclk_index = of_property_match_string(node, "clock-names",
 156                         "timclk");
 157         parent_names[1] = of_clk_get_parent_name(node, sp810->timclk_index);
 158
 159         if (parent_names[0] <= 0 || parent_names[1] <= 0) {
 160                 pr_warn("Failed to obtain parent clocks for SP810!\n");
 161                 return;
 162         }
 163
 164         sp810->node = node;
 165         sp810->base = of_iomap(node, 0);
 166         spin_lock_init(&sp810->lock);
 167
 168         init.name = name;
 169         init.ops = &clk_sp810_timerclken_ops;
 170         init.flags = CLK_IS_BASIC;
 171         init.parent_names = parent_names;
 172         init.num_parents = ARRAY_SIZE(parent_names);
 173
 174         for (i = 0; i < ARRAY_SIZE(sp810->timerclken); i++) {
 175                 snprintf(name, ARRAY_SIZE(name), "timerclken%d", i);
 176
 177                 sp810->timerclken[i].sp810 = sp810;
 178                 sp810->timerclken[i].channel = i;
 179                 sp810->timerclken[i].hw.init = &init;
 180
 181                 sp810->timerclken[i].clk = clk_register(NULL,
 182                                 &sp810->timerclken[i].hw);
 183                 WARN_ON(IS_ERR(sp810->timerclken[i].clk));
 184         }
 185
 186         of_clk_add_provider(node, clk_sp810_timerclken_of_get, sp810);
 187 }
 188 CLK_OF_DECLARE(sp810, "arm,sp810", clk_sp810_of_setup);