Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / arch / blackfin / kernel / gptimers.c
1 /*
2  * gptimers.c - Blackfin General Purpose Timer core API
3  *
4  * Copyright (c) 2005-2008 Analog Devices Inc.
5  * Copyright (C) 2005 John DeHority
6  * Copyright (C) 2006 Hella Aglaia GmbH (awe@aglaia-gmbh.de)
7  *
8  * Licensed under the GPLv2.
9  */
10
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13
14 #include <asm/io.h>
15 #include <asm/blackfin.h>
16 #include <asm/gptimers.h>
17
18 #ifdef DEBUG
19 # define tassert(expr)
20 #else
21 # define tassert(expr) \
22         if (!(expr)) \
23                 printk(KERN_DEBUG "%s:%s:%i: Assertion failed: " #expr "\n", __FILE__, __func__, __LINE__);
24 #endif
25
26 #define BFIN_TIMER_NUM_GROUP  (BFIN_TIMER_OCTET(MAX_BLACKFIN_GPTIMERS - 1) + 1)
27
28 typedef struct {
29         uint16_t config;
30         uint16_t __pad;
31         uint32_t counter;
32         uint32_t period;
33         uint32_t width;
34 } GPTIMER_timer_regs;
35
36 typedef struct {
37         uint16_t enable;
38         uint16_t __pad0;
39         uint16_t disable;
40         uint16_t __pad1;
41         uint32_t status;
42 } GPTIMER_group_regs;
43
44 static volatile GPTIMER_timer_regs *const timer_regs[MAX_BLACKFIN_GPTIMERS] =
45 {
46         (GPTIMER_timer_regs *)TIMER0_CONFIG,
47         (GPTIMER_timer_regs *)TIMER1_CONFIG,
48         (GPTIMER_timer_regs *)TIMER2_CONFIG,
49 #if (MAX_BLACKFIN_GPTIMERS > 3)
50         (GPTIMER_timer_regs *)TIMER3_CONFIG,
51         (GPTIMER_timer_regs *)TIMER4_CONFIG,
52         (GPTIMER_timer_regs *)TIMER5_CONFIG,
53         (GPTIMER_timer_regs *)TIMER6_CONFIG,
54         (GPTIMER_timer_regs *)TIMER7_CONFIG,
55 #endif
56 #if (MAX_BLACKFIN_GPTIMERS > 8)
57         (GPTIMER_timer_regs *)TIMER8_CONFIG,
58         (GPTIMER_timer_regs *)TIMER9_CONFIG,
59         (GPTIMER_timer_regs *)TIMER10_CONFIG,
60         (GPTIMER_timer_regs *)TIMER11_CONFIG,
61 #endif
62 };
63
64 static volatile GPTIMER_group_regs *const group_regs[BFIN_TIMER_NUM_GROUP] =
65 {
66         (GPTIMER_group_regs *)TIMER0_GROUP_REG,
67 #if (MAX_BLACKFIN_GPTIMERS > 8)
68         (GPTIMER_group_regs *)TIMER8_GROUP_REG,
69 #endif
70 };
71
72 static uint32_t const trun_mask[MAX_BLACKFIN_GPTIMERS] =
73 {
74         TIMER_STATUS_TRUN0,
75         TIMER_STATUS_TRUN1,
76         TIMER_STATUS_TRUN2,
77 #if (MAX_BLACKFIN_GPTIMERS > 3)
78         TIMER_STATUS_TRUN3,
79         TIMER_STATUS_TRUN4,
80         TIMER_STATUS_TRUN5,
81         TIMER_STATUS_TRUN6,
82         TIMER_STATUS_TRUN7,
83 #endif
84 #if (MAX_BLACKFIN_GPTIMERS > 8)
85         TIMER_STATUS_TRUN8,
86         TIMER_STATUS_TRUN9,
87         TIMER_STATUS_TRUN10,
88         TIMER_STATUS_TRUN11,
89 #endif
90 };
91
92 static uint32_t const tovf_mask[MAX_BLACKFIN_GPTIMERS] =
93 {
94         TIMER_STATUS_TOVF0,
95         TIMER_STATUS_TOVF1,
96         TIMER_STATUS_TOVF2,
97 #if (MAX_BLACKFIN_GPTIMERS > 3)
98         TIMER_STATUS_TOVF3,
99         TIMER_STATUS_TOVF4,
100         TIMER_STATUS_TOVF5,
101         TIMER_STATUS_TOVF6,
102         TIMER_STATUS_TOVF7,
103 #endif
104 #if (MAX_BLACKFIN_GPTIMERS > 8)
105         TIMER_STATUS_TOVF8,
106         TIMER_STATUS_TOVF9,
107         TIMER_STATUS_TOVF10,
108         TIMER_STATUS_TOVF11,
109 #endif
110 };
111
112 static uint32_t const timil_mask[MAX_BLACKFIN_GPTIMERS] =
113 {
114         TIMER_STATUS_TIMIL0,
115         TIMER_STATUS_TIMIL1,
116         TIMER_STATUS_TIMIL2,
117 #if (MAX_BLACKFIN_GPTIMERS > 3)
118         TIMER_STATUS_TIMIL3,
119         TIMER_STATUS_TIMIL4,
120         TIMER_STATUS_TIMIL5,
121         TIMER_STATUS_TIMIL6,
122         TIMER_STATUS_TIMIL7,
123 #endif
124 #if (MAX_BLACKFIN_GPTIMERS > 8)
125         TIMER_STATUS_TIMIL8,
126         TIMER_STATUS_TIMIL9,
127         TIMER_STATUS_TIMIL10,
128         TIMER_STATUS_TIMIL11,
129 #endif
130 };
131
132 void set_gptimer_pwidth(int timer_id, uint32_t value)
133 {
134         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
135         timer_regs[timer_id]->width = value;
136         SSYNC();
137 }
138 EXPORT_SYMBOL(set_gptimer_pwidth);
139
140 uint32_t get_gptimer_pwidth(int timer_id)
141 {
142         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
143         return timer_regs[timer_id]->width;
144 }
145 EXPORT_SYMBOL(get_gptimer_pwidth);
146
147 void set_gptimer_period(int timer_id, uint32_t period)
148 {
149         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
150         timer_regs[timer_id]->period = period;
151         SSYNC();
152 }
153 EXPORT_SYMBOL(set_gptimer_period);
154
155 uint32_t get_gptimer_period(int timer_id)
156 {
157         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
158         return timer_regs[timer_id]->period;
159 }
160 EXPORT_SYMBOL(get_gptimer_period);
161
162 uint32_t get_gptimer_count(int timer_id)
163 {
164         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
165         return timer_regs[timer_id]->counter;
166 }
167 EXPORT_SYMBOL(get_gptimer_count);
168
169 uint32_t get_gptimer_status(int group)
170 {
171         tassert(group < BFIN_TIMER_NUM_GROUP);
172         return group_regs[group]->status;
173 }
174 EXPORT_SYMBOL(get_gptimer_status);
175
176 void set_gptimer_status(int group, uint32_t value)
177 {
178         tassert(group < BFIN_TIMER_NUM_GROUP);
179         group_regs[group]->status = value;
180         SSYNC();
181 }
182 EXPORT_SYMBOL(set_gptimer_status);
183
184 uint16_t get_gptimer_intr(int timer_id)
185 {
186         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
187         return (group_regs[BFIN_TIMER_OCTET(timer_id)]->status & timil_mask[timer_id]) ? 1 : 0;
188 }
189 EXPORT_SYMBOL(get_gptimer_intr);
190
191 void clear_gptimer_intr(int timer_id)
192 {
193         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
194         group_regs[BFIN_TIMER_OCTET(timer_id)]->status = timil_mask[timer_id];
195 }
196 EXPORT_SYMBOL(clear_gptimer_intr);
197
198 uint16_t get_gptimer_over(int timer_id)
199 {
200         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
201         return (group_regs[BFIN_TIMER_OCTET(timer_id)]->status & tovf_mask[timer_id]) ? 1 : 0;
202 }
203 EXPORT_SYMBOL(get_gptimer_over);
204
205 void clear_gptimer_over(int timer_id)
206 {
207         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
208         group_regs[BFIN_TIMER_OCTET(timer_id)]->status = tovf_mask[timer_id];
209 }
210 EXPORT_SYMBOL(clear_gptimer_over);
211
212 void set_gptimer_config(int timer_id, uint16_t config)
213 {
214         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
215         timer_regs[timer_id]->config = config;
216         SSYNC();
217 }
218 EXPORT_SYMBOL(set_gptimer_config);
219
220 uint16_t get_gptimer_config(int timer_id)
221 {
222         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
223         return timer_regs[timer_id]->config;
224 }
225 EXPORT_SYMBOL(get_gptimer_config);
226
227 void enable_gptimers(uint16_t mask)
228 {
229         int i;
230         tassert((mask & ~BLACKFIN_GPTIMER_IDMASK) == 0);
231         for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i) {
232                 group_regs[i]->enable = mask & 0xFF;
233                 mask >>= 8;
234         }
235         SSYNC();
236 }
237 EXPORT_SYMBOL(enable_gptimers);
238
239 void disable_gptimers(uint16_t mask)
240 {
241         int i;
242         uint16_t m = mask;
243         tassert((mask & ~BLACKFIN_GPTIMER_IDMASK) == 0);
244         for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i) {
245                 group_regs[i]->disable = m & 0xFF;
246                 m >>= 8;
247         }
248         for (i = 0; i < MAX_BLACKFIN_GPTIMERS; ++i)
249                 if (mask & (1 << i))
250                         group_regs[BFIN_TIMER_OCTET(i)]->status |= trun_mask[i];
251         SSYNC();
252 }
253 EXPORT_SYMBOL(disable_gptimers);
254
255 void set_gptimer_pulse_hi(int timer_id)
256 {
257         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
258         timer_regs[timer_id]->config |= TIMER_PULSE_HI;
259         SSYNC();
260 }
261 EXPORT_SYMBOL(set_gptimer_pulse_hi);
262
263 void clear_gptimer_pulse_hi(int timer_id)
264 {
265         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
266         timer_regs[timer_id]->config &= ~TIMER_PULSE_HI;
267         SSYNC();
268 }
269 EXPORT_SYMBOL(clear_gptimer_pulse_hi);
270
271 uint16_t get_enabled_gptimers(void)
272 {
273         int i;
274         uint16_t result = 0;
275         for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i)
276                 result |= (group_regs[i]->enable << (i << 3));
277         return result;
278 }
279 EXPORT_SYMBOL(get_enabled_gptimers);
280
281 MODULE_AUTHOR("Axel Weiss (awe@aglaia-gmbh.de)");
282 MODULE_DESCRIPTION("Blackfin General Purpose Timers API");
283 MODULE_LICENSE("GPL");