Merge branch 'mpc86xx'
[platform/kernel/u-boot.git] / lib_m68k / time.c
1 /*
2  * (C) Copyright 2003 Josef Baumgartner <josef.baumgartner@telex.de>
3  *
4  * (C) Copyright 2000
5  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
6  *
7  * See file CREDITS for list of people who contributed to this
8  * project.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation; either version 2 of
13  * the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23  * MA 02111-1307 USA
24  */
25
26 #include <common.h>
27
28 #include <asm/mcftimer.h>
29
30 #ifdef  CONFIG_M5271
31 #include <asm/m5271.h>
32 #include <asm/immap_5271.h>
33 #endif
34
35 #ifdef  CONFIG_M5272
36 #include <asm/m5272.h>
37 #include <asm/immap_5272.h>
38 #endif
39
40 #ifdef  CONFIG_M5282
41 #include <asm/m5282.h>
42 #endif
43
44 #ifdef  CONFIG_M5249
45 #include <asm/m5249.h>
46 #include <asm/immap_5249.h>
47 #endif
48
49
50 static ulong timestamp;
51 #if defined(CONFIG_M5282) || defined(CONFIG_M5271)
52 static unsigned short lastinc;
53 #endif
54
55
56 #if defined(CONFIG_M5272)
57 /*
58  * We use timer 3 which is running with a period of 1 us
59  */
60 void udelay(unsigned long usec)
61 {
62         volatile timer_t *timerp = (timer_t *) (CFG_MBAR + MCFTIMER_BASE3);
63         uint start, now, tmp;
64
65         while (usec > 0) {
66                 if (usec > 65000)
67                         tmp = 65000;
68                 else
69                         tmp = usec;
70                 usec = usec - tmp;
71
72                 /* Set up TIMER 3 as timebase clock */
73                 timerp->timer_tmr = MCFTIMER_TMR_DISABLE;
74                 timerp->timer_tcn = 0;
75                 /* set period to 1 us */
76                 timerp->timer_tmr = (((CFG_CLK / 1000000) - 1)  << 8) | MCFTIMER_TMR_CLK1 |
77                                      MCFTIMER_TMR_FREERUN | MCFTIMER_TMR_ENABLE;
78
79                 start = now = timerp->timer_tcn;
80                 while (now < start + tmp)
81                         now = timerp->timer_tcn;
82         }
83 }
84
85 void mcf_timer_interrupt (void * not_used){
86         volatile timer_t *timerp = (timer_t *) (CFG_MBAR + MCFTIMER_BASE4);
87         volatile intctrl_t *intp = (intctrl_t *) (CFG_MBAR + MCFSIM_ICR1);
88
89         /* check for timer 4 interrupts */
90         if ((intp->int_isr & 0x01000000) != 0) {
91                 return;
92         }
93
94         /* reset timer */
95         timerp->timer_ter = MCFTIMER_TER_CAP | MCFTIMER_TER_REF;
96         timestamp ++;
97 }
98
99 void timer_init (void) {
100         volatile timer_t *timerp = (timer_t *) (CFG_MBAR + MCFTIMER_BASE4);
101         volatile intctrl_t *intp = (intctrl_t *) (CFG_MBAR + MCFSIM_ICR1);
102
103         timestamp = 0;
104
105         /* Set up TIMER 4 as clock */
106         timerp->timer_tmr = MCFTIMER_TMR_DISABLE;
107
108         /* initialize and enable timer 4 interrupt */
109         irq_install_handler (72, mcf_timer_interrupt, 0);
110         intp->int_icr1 |= 0x0000000d;
111
112         timerp->timer_tcn = 0;
113         timerp->timer_trr = 1000;       /* Interrupt every ms */
114         /* set a period of 1us, set timer mode to restart and enable timer and interrupt */
115         timerp->timer_tmr = (((CFG_CLK / 1000000) - 1)  << 8) | MCFTIMER_TMR_CLK1 |
116                 MCFTIMER_TMR_RESTART | MCFTIMER_TMR_ENORI | MCFTIMER_TMR_ENABLE;
117 }
118
119 void reset_timer (void)
120 {
121         timestamp = 0;
122 }
123
124 ulong get_timer (ulong base)
125 {
126         return (timestamp - base);
127 }
128
129 void set_timer (ulong t)
130 {
131         timestamp = t;
132 }
133 #endif
134
135 #if defined(CONFIG_M5282) || defined(CONFIG_M5271)
136
137 void udelay(unsigned long usec)
138 {
139         volatile unsigned short *timerp;
140         uint tmp;
141
142         timerp = (volatile unsigned short *) (CFG_MBAR + MCFTIMER_BASE3);
143
144         while (usec > 0) {
145                 if (usec > 65000)
146                         tmp = 65000;
147                 else
148                         tmp = usec;
149                 usec = usec - tmp;
150
151                 /* Set up TIMER 3 as timebase clock */
152                 timerp[MCFTIMER_PCSR] = MCFTIMER_PCSR_OVW;
153                 timerp[MCFTIMER_PMR] = 0;
154                 /* set period to 1 us */
155                 timerp[MCFTIMER_PCSR] =
156                         (5 << 8) | MCFTIMER_PCSR_EN | MCFTIMER_PCSR_OVW;
157
158                 timerp[MCFTIMER_PMR] = tmp;
159                 while (timerp[MCFTIMER_PCNTR] > 0);
160         }
161 }
162
163 void timer_init (void)
164 {
165         volatile unsigned short *timerp;
166
167         timerp = (volatile unsigned short *) (CFG_MBAR + MCFTIMER_BASE4);
168         timestamp = 0;
169
170         /* Set up TIMER 4 as poll clock */
171         timerp[MCFTIMER_PCSR] = MCFTIMER_PCSR_OVW;
172         timerp[MCFTIMER_PMR] = lastinc = 0;
173         timerp[MCFTIMER_PCSR] =
174                 (5 << 8) | MCFTIMER_PCSR_EN | MCFTIMER_PCSR_OVW;
175 }
176
177 void set_timer (ulong t)
178 {
179         volatile unsigned short *timerp;
180
181         timerp = (volatile unsigned short *) (CFG_MBAR + MCFTIMER_BASE4);
182         timestamp = 0;
183         timerp[MCFTIMER_PMR] = lastinc = 0;
184 }
185
186 ulong get_timer (ulong base)
187 {
188         unsigned short now, diff;
189         volatile unsigned short *timerp;
190
191         timerp = (volatile unsigned short *) (CFG_MBAR + MCFTIMER_BASE4);
192         now = timerp[MCFTIMER_PCNTR];
193         diff = -(now - lastinc);
194
195         timestamp += diff;
196         lastinc = now;
197         return timestamp - base;
198 }
199
200 void wait_ticks (unsigned long ticks)
201 {
202         set_timer (0);
203         while (get_timer (0) < ticks);
204 }
205 #endif
206
207
208 #if defined(CONFIG_M5249)
209 /*
210  * We use timer 1 which is running with a period of 1 us
211  */
212 void udelay(unsigned long usec)
213 {
214         volatile timer_t *timerp = (timer_t *) (CFG_MBAR + MCFTIMER_BASE1);
215         uint start, now, tmp;
216
217         while (usec > 0) {
218                 if (usec > 65000)
219                         tmp = 65000;
220                 else
221                         tmp = usec;
222                 usec = usec - tmp;
223
224                 /* Set up TIMER 1 as timebase clock */
225                 timerp->timer_tmr = MCFTIMER_TMR_DISABLE;
226                 timerp->timer_tcn = 0;
227                 /* set period to 1 us */
228                 /* on m5249 the system clock is (cpu_clk / 2) -> divide by 2000000 */
229                 timerp->timer_tmr = (((CFG_CLK / 2000000) - 1)  << 8) | MCFTIMER_TMR_CLK1 |
230                                      MCFTIMER_TMR_FREERUN | MCFTIMER_TMR_ENABLE;
231
232                 start = now = timerp->timer_tcn;
233                 while (now < start + tmp)
234                         now = timerp->timer_tcn;
235         }
236 }
237
238 void mcf_timer_interrupt (void * not_used){
239         volatile timer_t *timerp = (timer_t *) (CFG_MBAR + MCFTIMER_BASE2);
240
241         /* check for timer 2 interrupts */
242         if ((mbar_readLong(MCFSIM_IPR) & 0x00000400) == 0) {
243                 return;
244         }
245
246         /* reset timer */
247         timerp->timer_ter = MCFTIMER_TER_CAP | MCFTIMER_TER_REF;
248         timestamp ++;
249 }
250
251 void timer_init (void) {
252         volatile timer_t *timerp = (timer_t *) (CFG_MBAR + MCFTIMER_BASE2);
253
254         timestamp = 0;
255
256         /* Set up TIMER 2 as clock */
257         timerp->timer_tmr = MCFTIMER_TMR_DISABLE;
258
259         /* initialize and enable timer 2 interrupt */
260         irq_install_handler (31, mcf_timer_interrupt, 0);
261         mbar_writeLong(MCFSIM_IMR, mbar_readLong(MCFSIM_IMR) & ~0x00000400);
262         mbar_writeByte(MCFSIM_TIMER2ICR, MCFSIM_ICR_AUTOVEC | MCFSIM_ICR_LEVEL7 | MCFSIM_ICR_PRI3);
263
264         timerp->timer_tcn = 0;
265         timerp->timer_trr = 1000;       /* Interrupt every ms */
266         /* set a period of 1us, set timer mode to restart and enable timer and interrupt */
267         /* on m5249 the system clock is (cpu_clk / 2) -> divide by 2000000 */
268         timerp->timer_tmr = (((CFG_CLK / 2000000) - 1)  << 8) | MCFTIMER_TMR_CLK1 |
269                 MCFTIMER_TMR_RESTART | MCFTIMER_TMR_ENORI | MCFTIMER_TMR_ENABLE;
270 }
271
272 void reset_timer (void)
273 {
274         timestamp = 0;
275 }
276
277 ulong get_timer (ulong base)
278 {
279         return (timestamp - base);
280 }
281
282 void set_timer (ulong t)
283 {
284         timestamp = t;
285 }
286 #endif
287
288
289 /*
290  * This function is derived from PowerPC code (read timebase as long long).
291  * On M68K it just returns the timer value.
292  */
293 unsigned long long get_ticks(void)
294 {
295         return get_timer(0);
296 }
297
298 /*
299  * This function is derived from PowerPC code (timebase clock frequency).
300  * On M68K it returns the number of timer ticks per second.
301  */
302 ulong get_tbclk (void)
303 {
304         ulong tbclk;
305         tbclk = CFG_HZ;
306         return tbclk;
307 }