blob: 4e691e35483a7ee5425b36f6d33668f741bdca6a [file] [log] [blame]
Mike Turquette9d9f78e2012-03-15 23:11:20 -07001/*
2 * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
3 * Copyright (C) 2011-2012 Mike Turquette, Linaro Ltd <mturquette@linaro.org>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Gated clock implementation
10 */
11
12#include <linux/clk-provider.h>
13#include <linux/module.h>
14#include <linux/slab.h>
15#include <linux/io.h>
16#include <linux/err.h>
17#include <linux/string.h>
18
19/**
20 * DOC: basic gatable clock which can gate and ungate it's ouput
21 *
22 * Traits of this clock:
23 * prepare - clk_(un)prepare only ensures parent is (un)prepared
24 * enable - clk_enable and clk_disable are functional & control gating
25 * rate - inherits rate from parent. No clk_set_rate support
26 * parent - fixed parent. No clk_set_parent support
27 */
28
Viresh Kumarfbc42aa2012-04-17 16:45:37 +053029/*
30 * It works on following logic:
31 *
32 * For enabling clock, enable = 1
33 * set2dis = 1 -> clear bit -> set = 0
34 * set2dis = 0 -> set bit -> set = 1
35 *
36 * For disabling clock, enable = 0
37 * set2dis = 1 -> set bit -> set = 1
38 * set2dis = 0 -> clear bit -> set = 0
39 *
40 * So, result is always: enable xor set2dis.
41 */
42static void clk_gate_endisable(struct clk_hw *hw, int enable)
Mike Turquette9d9f78e2012-03-15 23:11:20 -070043{
Viresh Kumarfbc42aa2012-04-17 16:45:37 +053044 struct clk_gate *gate = to_clk_gate(hw);
45 int set = gate->flags & CLK_GATE_SET_TO_DISABLE ? 1 : 0;
Xiubo Li7af47242014-09-22 13:52:11 +080046 unsigned long uninitialized_var(flags);
Viresh Kumarfbc42aa2012-04-17 16:45:37 +053047 u32 reg;
48
49 set ^= enable;
Mike Turquette9d9f78e2012-03-15 23:11:20 -070050
51 if (gate->lock)
52 spin_lock_irqsave(gate->lock, flags);
Stephen Boyd661e2182015-07-24 12:21:12 -070053 else
54 __acquire(gate->lock);
Mike Turquette9d9f78e2012-03-15 23:11:20 -070055
Haojian Zhuang04577992013-06-08 22:47:19 +080056 if (gate->flags & CLK_GATE_HIWORD_MASK) {
57 reg = BIT(gate->bit_idx + 16);
58 if (set)
59 reg |= BIT(gate->bit_idx);
60 } else {
Gerhard Sittigaa514ce2013-07-22 14:14:40 +020061 reg = clk_readl(gate->reg);
Mike Turquette9d9f78e2012-03-15 23:11:20 -070062
Haojian Zhuang04577992013-06-08 22:47:19 +080063 if (set)
64 reg |= BIT(gate->bit_idx);
65 else
66 reg &= ~BIT(gate->bit_idx);
67 }
Mike Turquette9d9f78e2012-03-15 23:11:20 -070068
Gerhard Sittigaa514ce2013-07-22 14:14:40 +020069 clk_writel(reg, gate->reg);
Mike Turquette9d9f78e2012-03-15 23:11:20 -070070
71 if (gate->lock)
72 spin_unlock_irqrestore(gate->lock, flags);
Stephen Boyd661e2182015-07-24 12:21:12 -070073 else
74 __release(gate->lock);
Mike Turquette9d9f78e2012-03-15 23:11:20 -070075}
76
77static int clk_gate_enable(struct clk_hw *hw)
78{
Viresh Kumarfbc42aa2012-04-17 16:45:37 +053079 clk_gate_endisable(hw, 1);
Mike Turquette9d9f78e2012-03-15 23:11:20 -070080
81 return 0;
82}
Mike Turquette9d9f78e2012-03-15 23:11:20 -070083
84static void clk_gate_disable(struct clk_hw *hw)
85{
Viresh Kumarfbc42aa2012-04-17 16:45:37 +053086 clk_gate_endisable(hw, 0);
Mike Turquette9d9f78e2012-03-15 23:11:20 -070087}
Mike Turquette9d9f78e2012-03-15 23:11:20 -070088
89static int clk_gate_is_enabled(struct clk_hw *hw)
90{
91 u32 reg;
92 struct clk_gate *gate = to_clk_gate(hw);
93
Gerhard Sittigaa514ce2013-07-22 14:14:40 +020094 reg = clk_readl(gate->reg);
Mike Turquette9d9f78e2012-03-15 23:11:20 -070095
96 /* if a set bit disables this clk, flip it before masking */
97 if (gate->flags & CLK_GATE_SET_TO_DISABLE)
98 reg ^= BIT(gate->bit_idx);
99
100 reg &= BIT(gate->bit_idx);
101
102 return reg ? 1 : 0;
103}
Mike Turquette9d9f78e2012-03-15 23:11:20 -0700104
Shawn Guo822c2502012-03-27 15:23:22 +0800105const struct clk_ops clk_gate_ops = {
Mike Turquette9d9f78e2012-03-15 23:11:20 -0700106 .enable = clk_gate_enable,
107 .disable = clk_gate_disable,
108 .is_enabled = clk_gate_is_enabled,
109};
110EXPORT_SYMBOL_GPL(clk_gate_ops);
111
Mike Turquette27d54592012-03-26 17:51:03 -0700112/**
Stephen Boyde270d8c2016-02-06 23:54:45 -0800113 * clk_hw_register_gate - register a gate clock with the clock framework
Mike Turquette27d54592012-03-26 17:51:03 -0700114 * @dev: device that is registering this clock
115 * @name: name of this clock
116 * @parent_name: name of this clock's parent
117 * @flags: framework-specific flags for this clock
118 * @reg: register address to control gating of this clock
119 * @bit_idx: which bit in the register controls gating of this clock
120 * @clk_gate_flags: gate-specific flags for this clock
121 * @lock: shared register lock for this clock
122 */
Stephen Boyde270d8c2016-02-06 23:54:45 -0800123struct clk_hw *clk_hw_register_gate(struct device *dev, const char *name,
Mike Turquette9d9f78e2012-03-15 23:11:20 -0700124 const char *parent_name, unsigned long flags,
125 void __iomem *reg, u8 bit_idx,
126 u8 clk_gate_flags, spinlock_t *lock)
127{
128 struct clk_gate *gate;
Stephen Boyde270d8c2016-02-06 23:54:45 -0800129 struct clk_hw *hw;
Saravana Kannan0197b3e2012-04-25 22:58:56 -0700130 struct clk_init_data init;
Stephen Boyde270d8c2016-02-06 23:54:45 -0800131 int ret;
Mike Turquette9d9f78e2012-03-15 23:11:20 -0700132
Haojian Zhuang04577992013-06-08 22:47:19 +0800133 if (clk_gate_flags & CLK_GATE_HIWORD_MASK) {
Sergei Shtylyov2e9dcda2014-12-24 17:43:27 +0300134 if (bit_idx > 15) {
Haojian Zhuang04577992013-06-08 22:47:19 +0800135 pr_err("gate bit exceeds LOWORD field\n");
136 return ERR_PTR(-EINVAL);
137 }
138 }
139
Mike Turquette27d54592012-03-26 17:51:03 -0700140 /* allocate the gate */
Stephen Boydd122db72015-05-14 16:47:10 -0700141 gate = kzalloc(sizeof(*gate), GFP_KERNEL);
142 if (!gate)
Mike Turquette27d54592012-03-26 17:51:03 -0700143 return ERR_PTR(-ENOMEM);
Mike Turquette9d9f78e2012-03-15 23:11:20 -0700144
Saravana Kannan0197b3e2012-04-25 22:58:56 -0700145 init.name = name;
146 init.ops = &clk_gate_ops;
Rajendra Nayakf7d8caa2012-06-01 14:02:47 +0530147 init.flags = flags | CLK_IS_BASIC;
Saravana Kannan0197b3e2012-04-25 22:58:56 -0700148 init.parent_names = (parent_name ? &parent_name: NULL);
149 init.num_parents = (parent_name ? 1 : 0);
150
Mike Turquette9d9f78e2012-03-15 23:11:20 -0700151 /* struct clk_gate assignments */
152 gate->reg = reg;
153 gate->bit_idx = bit_idx;
154 gate->flags = clk_gate_flags;
155 gate->lock = lock;
Saravana Kannan0197b3e2012-04-25 22:58:56 -0700156 gate->hw.init = &init;
Mike Turquette9d9f78e2012-03-15 23:11:20 -0700157
Stephen Boyde270d8c2016-02-06 23:54:45 -0800158 hw = &gate->hw;
159 ret = clk_hw_register(dev, hw);
160 if (ret) {
Mike Turquette27d54592012-03-26 17:51:03 -0700161 kfree(gate);
Stephen Boyde270d8c2016-02-06 23:54:45 -0800162 hw = ERR_PTR(ret);
163 }
Mike Turquette27d54592012-03-26 17:51:03 -0700164
Stephen Boyde270d8c2016-02-06 23:54:45 -0800165 return hw;
166}
167EXPORT_SYMBOL_GPL(clk_hw_register_gate);
168
169struct clk *clk_register_gate(struct device *dev, const char *name,
170 const char *parent_name, unsigned long flags,
171 void __iomem *reg, u8 bit_idx,
172 u8 clk_gate_flags, spinlock_t *lock)
173{
174 struct clk_hw *hw;
175
176 hw = clk_hw_register_gate(dev, name, parent_name, flags, reg,
177 bit_idx, clk_gate_flags, lock);
178 if (IS_ERR(hw))
179 return ERR_CAST(hw);
180 return hw->clk;
Mike Turquette9d9f78e2012-03-15 23:11:20 -0700181}
Mike Turquette5cfe10b2013-08-15 19:06:29 -0700182EXPORT_SYMBOL_GPL(clk_register_gate);
Krzysztof Kozlowski4e3c0212015-01-05 10:52:40 +0100183
184void clk_unregister_gate(struct clk *clk)
185{
186 struct clk_gate *gate;
187 struct clk_hw *hw;
188
189 hw = __clk_get_hw(clk);
190 if (!hw)
191 return;
192
193 gate = to_clk_gate(hw);
194
195 clk_unregister(clk);
196 kfree(gate);
197}
198EXPORT_SYMBOL_GPL(clk_unregister_gate);
Stephen Boyde270d8c2016-02-06 23:54:45 -0800199
200void clk_hw_unregister_gate(struct clk_hw *hw)
201{
202 struct clk_gate *gate;
203
204 gate = to_clk_gate(hw);
205
206 clk_hw_unregister(hw);
207 kfree(gate);
208}
209EXPORT_SYMBOL_GPL(clk_hw_unregister_gate);