staging: rtl8188eu: rename HalSetBrateCfg() - style
[linux/fpc-iii.git] / drivers / clocksource / time-efm32.c
blob257e810ec1ad1dd25e7ec4e3263f7bf2816ef1f5
1 /*
2 * Copyright (C) 2013 Pengutronix
3 * Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>
5 * This program is free software; you can redistribute it and/or modify it under
6 * the terms of the GNU General Public License version 2 as published by the
7 * Free Software Foundation.
8 */
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/kernel.h>
13 #include <linux/clocksource.h>
14 #include <linux/clockchips.h>
15 #include <linux/irq.h>
16 #include <linux/interrupt.h>
17 #include <linux/of.h>
18 #include <linux/of_address.h>
19 #include <linux/of_irq.h>
20 #include <linux/clk.h>
22 #define TIMERn_CTRL 0x00
23 #define TIMERn_CTRL_PRESC(val) (((val) & 0xf) << 24)
24 #define TIMERn_CTRL_PRESC_1024 TIMERn_CTRL_PRESC(10)
25 #define TIMERn_CTRL_CLKSEL(val) (((val) & 0x3) << 16)
26 #define TIMERn_CTRL_CLKSEL_PRESCHFPERCLK TIMERn_CTRL_CLKSEL(0)
27 #define TIMERn_CTRL_OSMEN 0x00000010
28 #define TIMERn_CTRL_MODE(val) (((val) & 0x3) << 0)
29 #define TIMERn_CTRL_MODE_UP TIMERn_CTRL_MODE(0)
30 #define TIMERn_CTRL_MODE_DOWN TIMERn_CTRL_MODE(1)
32 #define TIMERn_CMD 0x04
33 #define TIMERn_CMD_START 0x00000001
34 #define TIMERn_CMD_STOP 0x00000002
36 #define TIMERn_IEN 0x0c
37 #define TIMERn_IF 0x10
38 #define TIMERn_IFS 0x14
39 #define TIMERn_IFC 0x18
40 #define TIMERn_IRQ_UF 0x00000002
42 #define TIMERn_TOP 0x1c
43 #define TIMERn_CNT 0x24
45 struct efm32_clock_event_ddata {
46 struct clock_event_device evtdev;
47 void __iomem *base;
48 unsigned periodic_top;
51 static int efm32_clock_event_shutdown(struct clock_event_device *evtdev)
53 struct efm32_clock_event_ddata *ddata =
54 container_of(evtdev, struct efm32_clock_event_ddata, evtdev);
56 writel_relaxed(TIMERn_CMD_STOP, ddata->base + TIMERn_CMD);
57 return 0;
60 static int efm32_clock_event_set_oneshot(struct clock_event_device *evtdev)
62 struct efm32_clock_event_ddata *ddata =
63 container_of(evtdev, struct efm32_clock_event_ddata, evtdev);
65 writel_relaxed(TIMERn_CMD_STOP, ddata->base + TIMERn_CMD);
66 writel_relaxed(TIMERn_CTRL_PRESC_1024 |
67 TIMERn_CTRL_CLKSEL_PRESCHFPERCLK |
68 TIMERn_CTRL_OSMEN |
69 TIMERn_CTRL_MODE_DOWN,
70 ddata->base + TIMERn_CTRL);
71 return 0;
74 static int efm32_clock_event_set_periodic(struct clock_event_device *evtdev)
76 struct efm32_clock_event_ddata *ddata =
77 container_of(evtdev, struct efm32_clock_event_ddata, evtdev);
79 writel_relaxed(TIMERn_CMD_STOP, ddata->base + TIMERn_CMD);
80 writel_relaxed(ddata->periodic_top, ddata->base + TIMERn_TOP);
81 writel_relaxed(TIMERn_CTRL_PRESC_1024 |
82 TIMERn_CTRL_CLKSEL_PRESCHFPERCLK |
83 TIMERn_CTRL_MODE_DOWN,
84 ddata->base + TIMERn_CTRL);
85 writel_relaxed(TIMERn_CMD_START, ddata->base + TIMERn_CMD);
86 return 0;
89 static int efm32_clock_event_set_next_event(unsigned long evt,
90 struct clock_event_device *evtdev)
92 struct efm32_clock_event_ddata *ddata =
93 container_of(evtdev, struct efm32_clock_event_ddata, evtdev);
95 writel_relaxed(TIMERn_CMD_STOP, ddata->base + TIMERn_CMD);
96 writel_relaxed(evt, ddata->base + TIMERn_CNT);
97 writel_relaxed(TIMERn_CMD_START, ddata->base + TIMERn_CMD);
99 return 0;
102 static irqreturn_t efm32_clock_event_handler(int irq, void *dev_id)
104 struct efm32_clock_event_ddata *ddata = dev_id;
106 writel_relaxed(TIMERn_IRQ_UF, ddata->base + TIMERn_IFC);
108 ddata->evtdev.event_handler(&ddata->evtdev);
110 return IRQ_HANDLED;
113 static struct efm32_clock_event_ddata clock_event_ddata = {
114 .evtdev = {
115 .name = "efm32 clockevent",
116 .features = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_PERIODIC,
117 .set_state_shutdown = efm32_clock_event_shutdown,
118 .set_state_periodic = efm32_clock_event_set_periodic,
119 .set_state_oneshot = efm32_clock_event_set_oneshot,
120 .set_next_event = efm32_clock_event_set_next_event,
121 .rating = 200,
125 static struct irqaction efm32_clock_event_irq = {
126 .name = "efm32 clockevent",
127 .flags = IRQF_TIMER,
128 .handler = efm32_clock_event_handler,
129 .dev_id = &clock_event_ddata,
132 static int __init efm32_clocksource_init(struct device_node *np)
134 struct clk *clk;
135 void __iomem *base;
136 unsigned long rate;
137 int ret;
139 clk = of_clk_get(np, 0);
140 if (IS_ERR(clk)) {
141 ret = PTR_ERR(clk);
142 pr_err("failed to get clock for clocksource (%d)\n", ret);
143 goto err_clk_get;
146 ret = clk_prepare_enable(clk);
147 if (ret) {
148 pr_err("failed to enable timer clock for clocksource (%d)\n",
149 ret);
150 goto err_clk_enable;
152 rate = clk_get_rate(clk);
154 base = of_iomap(np, 0);
155 if (!base) {
156 ret = -EADDRNOTAVAIL;
157 pr_err("failed to map registers for clocksource\n");
158 goto err_iomap;
161 writel_relaxed(TIMERn_CTRL_PRESC_1024 |
162 TIMERn_CTRL_CLKSEL_PRESCHFPERCLK |
163 TIMERn_CTRL_MODE_UP, base + TIMERn_CTRL);
164 writel_relaxed(TIMERn_CMD_START, base + TIMERn_CMD);
166 ret = clocksource_mmio_init(base + TIMERn_CNT, "efm32 timer",
167 DIV_ROUND_CLOSEST(rate, 1024), 200, 16,
168 clocksource_mmio_readl_up);
169 if (ret) {
170 pr_err("failed to init clocksource (%d)\n", ret);
171 goto err_clocksource_init;
174 return 0;
176 err_clocksource_init:
178 iounmap(base);
179 err_iomap:
181 clk_disable_unprepare(clk);
182 err_clk_enable:
184 clk_put(clk);
185 err_clk_get:
187 return ret;
190 static int __init efm32_clockevent_init(struct device_node *np)
192 struct clk *clk;
193 void __iomem *base;
194 unsigned long rate;
195 int irq;
196 int ret;
198 clk = of_clk_get(np, 0);
199 if (IS_ERR(clk)) {
200 ret = PTR_ERR(clk);
201 pr_err("failed to get clock for clockevent (%d)\n", ret);
202 goto err_clk_get;
205 ret = clk_prepare_enable(clk);
206 if (ret) {
207 pr_err("failed to enable timer clock for clockevent (%d)\n",
208 ret);
209 goto err_clk_enable;
211 rate = clk_get_rate(clk);
213 base = of_iomap(np, 0);
214 if (!base) {
215 ret = -EADDRNOTAVAIL;
216 pr_err("failed to map registers for clockevent\n");
217 goto err_iomap;
220 irq = irq_of_parse_and_map(np, 0);
221 if (!irq) {
222 ret = -ENOENT;
223 pr_err("failed to get irq for clockevent\n");
224 goto err_get_irq;
227 writel_relaxed(TIMERn_IRQ_UF, base + TIMERn_IEN);
229 clock_event_ddata.base = base;
230 clock_event_ddata.periodic_top = DIV_ROUND_CLOSEST(rate, 1024 * HZ);
232 clockevents_config_and_register(&clock_event_ddata.evtdev,
233 DIV_ROUND_CLOSEST(rate, 1024),
234 0xf, 0xffff);
236 ret = setup_irq(irq, &efm32_clock_event_irq);
237 if (ret) {
238 pr_err("Failed setup irq\n");
239 goto err_setup_irq;
242 return 0;
244 err_setup_irq:
245 err_get_irq:
247 iounmap(base);
248 err_iomap:
250 clk_disable_unprepare(clk);
251 err_clk_enable:
253 clk_put(clk);
254 err_clk_get:
256 return ret;
260 * This function asserts that we have exactly one clocksource and one
261 * clock_event_device in the end.
263 static int __init efm32_timer_init(struct device_node *np)
265 static int has_clocksource, has_clockevent;
266 int ret = 0;
268 if (!has_clocksource) {
269 ret = efm32_clocksource_init(np);
270 if (!ret) {
271 has_clocksource = 1;
272 return 0;
276 if (!has_clockevent) {
277 ret = efm32_clockevent_init(np);
278 if (!ret) {
279 has_clockevent = 1;
280 return 0;
284 return ret;
286 TIMER_OF_DECLARE(efm32compat, "efm32,timer", efm32_timer_init);
287 TIMER_OF_DECLARE(efm32, "energymicro,efm32-timer", efm32_timer_init);