1 /*
2  *  linux/drivers/clocksource/timer-sp.c
3  *
4  *  Copyright (C) 1999 - 2003 ARM Limited
5  *  Copyright (C) 2000 Deep Blue Solutions Ltd
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21 #include <linux/clk.h>
22 #include <linux/clocksource.h>
23 #include <linux/clockchips.h>
24 #include <linux/err.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/io.h>
28 #include <linux/of.h>
29 #include <linux/of_address.h>
30 #include <linux/of_clk.h>
31 #include <linux/of_irq.h>
32 #include <linux/sched_clock.h>
33 
34 #include <clocksource/timer-sp804.h>
35 
36 #include "timer-sp.h"
37 
38 static long __init sp804_get_clock_rate(struct clk *clk)
39 {
40 	long rate;
41 	int err;
42 
43 	err = clk_prepare(clk);
44 	if (err) {
45 		pr_err("sp804: clock failed to prepare: %d\n", err);
46 		clk_put(clk);
47 		return err;
48 	}
49 
50 	err = clk_enable(clk);
51 	if (err) {
52 		pr_err("sp804: clock failed to enable: %d\n", err);
53 		clk_unprepare(clk);
54 		clk_put(clk);
55 		return err;
56 	}
57 
58 	rate = clk_get_rate(clk);
59 	if (rate < 0) {
60 		pr_err("sp804: clock failed to get rate: %ld\n", rate);
61 		clk_disable(clk);
62 		clk_unprepare(clk);
63 		clk_put(clk);
64 	}
65 
66 	return rate;
67 }
68 
69 static void __iomem *sched_clock_base;
70 
71 static u64 notrace sp804_read(void)
72 {
73 	return ~readl_relaxed(sched_clock_base + TIMER_VALUE);
74 }
75 
76 void __init sp804_timer_disable(void __iomem *base)
77 {
78 	writel(0, base + TIMER_CTRL);
79 }
80 
81 int  __init __sp804_clocksource_and_sched_clock_init(void __iomem *base,
82 						     const char *name,
83 						     struct clk *clk,
84 						     int use_sched_clock)
85 {
86 	long rate;
87 
88 	if (!clk) {
89 		clk = clk_get_sys("sp804", name);
90 		if (IS_ERR(clk)) {
91 			pr_err("sp804: clock not found: %d\n",
92 			       (int)PTR_ERR(clk));
93 			return PTR_ERR(clk);
94 		}
95 	}
96 
97 	rate = sp804_get_clock_rate(clk);
98 	if (rate < 0)
99 		return -EINVAL;
100 
101 	/* setup timer 0 as free-running clocksource */
102 	writel(0, base + TIMER_CTRL);
103 	writel(0xffffffff, base + TIMER_LOAD);
104 	writel(0xffffffff, base + TIMER_VALUE);
105 	writel(TIMER_CTRL_32BIT | TIMER_CTRL_ENABLE | TIMER_CTRL_PERIODIC,
106 		base + TIMER_CTRL);
107 
108 	clocksource_mmio_init(base + TIMER_VALUE, name,
109 		rate, 200, 32, clocksource_mmio_readl_down);
110 
111 	if (use_sched_clock) {
112 		sched_clock_base = base;
113 		sched_clock_register(sp804_read, 32, rate);
114 	}
115 
116 	return 0;
117 }
118 
119 
120 static void __iomem *clkevt_base;
121 static unsigned long clkevt_reload;
122 
123 /*
124  * IRQ handler for the timer
125  */
126 static irqreturn_t sp804_timer_interrupt(int irq, void *dev_id)
127 {
128 	struct clock_event_device *evt = dev_id;
129 
130 	/* clear the interrupt */
131 	writel(1, clkevt_base + TIMER_INTCLR);
132 
133 	evt->event_handler(evt);
134 
135 	return IRQ_HANDLED;
136 }
137 
138 static inline void timer_shutdown(struct clock_event_device *evt)
139 {
140 	writel(0, clkevt_base + TIMER_CTRL);
141 }
142 
143 static int sp804_shutdown(struct clock_event_device *evt)
144 {
145 	timer_shutdown(evt);
146 	return 0;
147 }
148 
149 static int sp804_set_periodic(struct clock_event_device *evt)
150 {
151 	unsigned long ctrl = TIMER_CTRL_32BIT | TIMER_CTRL_IE |
152 			     TIMER_CTRL_PERIODIC | TIMER_CTRL_ENABLE;
153 
154 	timer_shutdown(evt);
155 	writel(clkevt_reload, clkevt_base + TIMER_LOAD);
156 	writel(ctrl, clkevt_base + TIMER_CTRL);
157 	return 0;
158 }
159 
160 static int sp804_set_next_event(unsigned long next,
161 	struct clock_event_device *evt)
162 {
163 	unsigned long ctrl = TIMER_CTRL_32BIT | TIMER_CTRL_IE |
164 			     TIMER_CTRL_ONESHOT | TIMER_CTRL_ENABLE;
165 
166 	writel(next, clkevt_base + TIMER_LOAD);
167 	writel(ctrl, clkevt_base + TIMER_CTRL);
168 
169 	return 0;
170 }
171 
172 static struct clock_event_device sp804_clockevent = {
173 	.features		= CLOCK_EVT_FEAT_PERIODIC |
174 				  CLOCK_EVT_FEAT_ONESHOT |
175 				  CLOCK_EVT_FEAT_DYNIRQ,
176 	.set_state_shutdown	= sp804_shutdown,
177 	.set_state_periodic	= sp804_set_periodic,
178 	.set_state_oneshot	= sp804_shutdown,
179 	.tick_resume		= sp804_shutdown,
180 	.set_next_event		= sp804_set_next_event,
181 	.rating			= 300,
182 };
183 
184 static struct irqaction sp804_timer_irq = {
185 	.name		= "timer",
186 	.flags		= IRQF_TIMER | IRQF_IRQPOLL,
187 	.handler	= sp804_timer_interrupt,
188 	.dev_id		= &sp804_clockevent,
189 };
190 
191 int __init __sp804_clockevents_init(void __iomem *base, unsigned int irq, struct clk *clk, const char *name)
192 {
193 	struct clock_event_device *evt = &sp804_clockevent;
194 	long rate;
195 
196 	if (!clk)
197 		clk = clk_get_sys("sp804", name);
198 	if (IS_ERR(clk)) {
199 		pr_err("sp804: %s clock not found: %d\n", name,
200 			(int)PTR_ERR(clk));
201 		return PTR_ERR(clk);
202 	}
203 
204 	rate = sp804_get_clock_rate(clk);
205 	if (rate < 0)
206 		return -EINVAL;
207 
208 	clkevt_base = base;
209 	clkevt_reload = DIV_ROUND_CLOSEST(rate, HZ);
210 	evt->name = name;
211 	evt->irq = irq;
212 	evt->cpumask = cpu_possible_mask;
213 
214 	writel(0, base + TIMER_CTRL);
215 
216 	setup_irq(irq, &sp804_timer_irq);
217 	clockevents_config_and_register(evt, rate, 0xf, 0xffffffff);
218 
219 	return 0;
220 }
221 
222 static int __init sp804_of_init(struct device_node *np)
223 {
224 	static bool initialized = false;
225 	void __iomem *base;
226 	int irq, ret = -EINVAL;
227 	u32 irq_num = 0;
228 	struct clk *clk1, *clk2;
229 	const char *name = of_get_property(np, "compatible", NULL);
230 
231 	base = of_iomap(np, 0);
232 	if (!base)
233 		return -ENXIO;
234 
235 	/* Ensure timers are disabled */
236 	writel(0, base + TIMER_CTRL);
237 	writel(0, base + TIMER_2_BASE + TIMER_CTRL);
238 
239 	if (initialized || !of_device_is_available(np)) {
240 		ret = -EINVAL;
241 		goto err;
242 	}
243 
244 	clk1 = of_clk_get(np, 0);
245 	if (IS_ERR(clk1))
246 		clk1 = NULL;
247 
248 	/* Get the 2nd clock if the timer has 3 timer clocks */
249 	if (of_clk_get_parent_count(np) == 3) {
250 		clk2 = of_clk_get(np, 1);
251 		if (IS_ERR(clk2)) {
252 			pr_err("sp804: %pOFn clock not found: %d\n", np,
253 				(int)PTR_ERR(clk2));
254 			clk2 = NULL;
255 		}
256 	} else
257 		clk2 = clk1;
258 
259 	irq = irq_of_parse_and_map(np, 0);
260 	if (irq <= 0)
261 		goto err;
262 
263 	of_property_read_u32(np, "arm,sp804-has-irq", &irq_num);
264 	if (irq_num == 2) {
265 
266 		ret = __sp804_clockevents_init(base + TIMER_2_BASE, irq, clk2, name);
267 		if (ret)
268 			goto err;
269 
270 		ret = __sp804_clocksource_and_sched_clock_init(base, name, clk1, 1);
271 		if (ret)
272 			goto err;
273 	} else {
274 
275 		ret = __sp804_clockevents_init(base, irq, clk1 , name);
276 		if (ret)
277 			goto err;
278 
279 		ret =__sp804_clocksource_and_sched_clock_init(base + TIMER_2_BASE,
280 							      name, clk2, 1);
281 		if (ret)
282 			goto err;
283 	}
284 	initialized = true;
285 
286 	return 0;
287 err:
288 	iounmap(base);
289 	return ret;
290 }
291 TIMER_OF_DECLARE(sp804, "arm,sp804", sp804_of_init);
292 
293 static int __init integrator_cp_of_init(struct device_node *np)
294 {
295 	static int init_count = 0;
296 	void __iomem *base;
297 	int irq, ret = -EINVAL;
298 	const char *name = of_get_property(np, "compatible", NULL);
299 	struct clk *clk;
300 
301 	base = of_iomap(np, 0);
302 	if (!base) {
303 		pr_err("Failed to iomap\n");
304 		return -ENXIO;
305 	}
306 
307 	clk = of_clk_get(np, 0);
308 	if (IS_ERR(clk)) {
309 		pr_err("Failed to get clock\n");
310 		return PTR_ERR(clk);
311 	}
312 
313 	/* Ensure timer is disabled */
314 	writel(0, base + TIMER_CTRL);
315 
316 	if (init_count == 2 || !of_device_is_available(np))
317 		goto err;
318 
319 	if (!init_count) {
320 		ret = __sp804_clocksource_and_sched_clock_init(base, name, clk, 0);
321 		if (ret)
322 			goto err;
323 	} else {
324 		irq = irq_of_parse_and_map(np, 0);
325 		if (irq <= 0)
326 			goto err;
327 
328 		ret = __sp804_clockevents_init(base, irq, clk, name);
329 		if (ret)
330 			goto err;
331 	}
332 
333 	init_count++;
334 	return 0;
335 err:
336 	iounmap(base);
337 	return ret;
338 }
339 TIMER_OF_DECLARE(intcp, "arm,integrator-cp-timer", integrator_cp_of_init);
340