Linux-2.6.12-rc2
[linux-2.6.git] / drivers / net / skfp / hwt.c
1 /******************************************************************************
2  *
3  *      (C)Copyright 1998,1999 SysKonnect,
4  *      a business unit of Schneider & Koch & Co. Datensysteme GmbH.
5  *
6  *      See the file "skfddi.c" for further information.
7  *
8  *      This program is free software; you can redistribute it and/or modify
9  *      it under the terms of the GNU General Public License as published by
10  *      the Free Software Foundation; either version 2 of the License, or
11  *      (at your option) any later version.
12  *
13  *      The information in this file is provided "AS IS" without warranty.
14  *
15  ******************************************************************************/
16
17 /*
18  * Timer Driver for FBI board (timer chip 82C54)
19  */
20
21 /*
22  * Modifications:
23  *
24  *      28-Jun-1994 sw  Edit v1.6.
25  *                      MCA: Added support for the SK-NET FDDI-FM2 adapter. The
26  *                       following functions have been added(+) or modified(*):
27  *                       hwt_start(*), hwt_stop(*), hwt_restart(*), hwt_read(*)
28  */
29
30 #include "h/types.h"
31 #include "h/fddi.h"
32 #include "h/smc.h"
33
34 #ifndef lint
35 static const char ID_sccs[] = "@(#)hwt.c        1.13 97/04/23 (C) SK " ;
36 #endif
37
38 /*
39  * Prototypes of local functions.
40  */
41 /* 28-Jun-1994 sw - Note: hwt_restart() is also used in module 'drvfbi.c'. */
42 /*static void hwt_restart() ; */
43
44 /************************
45  *
46  *      hwt_start
47  *
48  *      Start hardware timer (clock ticks are 16us).
49  *
50  *      void hwt_start(
51  *              struct s_smc *smc,
52  *              u_long time) ;
53  * In
54  *      smc - A pointer to the SMT Context structure.
55  *
56  *      time - The time in units of 16us to load the timer with.
57  * Out
58  *      Nothing.
59  *
60  ************************/
61 #define HWT_MAX (65000)
62
63 void hwt_start(struct s_smc *smc, u_long time)
64 {
65         u_short cnt ;
66
67         if (time > HWT_MAX)
68                 time = HWT_MAX ;
69
70         smc->hw.t_start = time ;
71         smc->hw.t_stop = 0L ;
72
73         cnt = (u_short)time ;
74         /*
75          * if time < 16 us
76          *      time = 16 us
77          */
78         if (!cnt)
79                 cnt++ ;
80 #ifndef PCI
81         /*
82          * 6.25MHz -> CLK0 : T0 (cnt0 = 16us)   -> OUT0
83          *    OUT0 -> CLK1 : T1 (cnt1)  OUT1    -> ISRA(IS_TIMINT)
84          */
85         OUT_82c54_TIMER(3,1<<6 | 3<<4 | 0<<1) ; /* counter 1, mode 0 */
86         OUT_82c54_TIMER(1,cnt & 0xff) ;         /* LSB */
87         OUT_82c54_TIMER(1,(cnt>>8) & 0xff) ;    /* MSB */
88         /*
89          * start timer by switching counter 0 to mode 3
90          *      T0 resolution 16 us (CLK0=0.16us)
91          */
92         OUT_82c54_TIMER(3,0<<6 | 3<<4 | 3<<1) ; /* counter 0, mode 3 */
93         OUT_82c54_TIMER(0,100) ;                /* LSB */
94         OUT_82c54_TIMER(0,0) ;                  /* MSB */
95 #else   /* PCI */
96         outpd(ADDR(B2_TI_INI), (u_long) cnt * 200) ;    /* Load timer value. */
97         outpw(ADDR(B2_TI_CRTL), TIM_START) ;            /* Start timer. */
98 #endif  /* PCI */
99         smc->hw.timer_activ = TRUE ;
100 }
101
102 /************************
103  *
104  *      hwt_stop
105  *
106  *      Stop hardware timer.
107  *
108  *      void hwt_stop(
109  *              struct s_smc *smc) ;
110  * In
111  *      smc - A pointer to the SMT Context structure.
112  * Out
113  *      Nothing.
114  *
115  ************************/
116 void hwt_stop(struct s_smc *smc)
117 {
118 #ifndef PCI
119         /* stop counter 0 by switching to mode 0 */
120         OUT_82c54_TIMER(3,0<<6 | 3<<4 | 0<<1) ; /* counter 0, mode 0 */
121         OUT_82c54_TIMER(0,0) ;                  /* LSB */
122         OUT_82c54_TIMER(0,0) ;                  /* MSB */
123 #else   /* PCI */
124         outpw(ADDR(B2_TI_CRTL), TIM_STOP) ;
125         outpw(ADDR(B2_TI_CRTL), TIM_CL_IRQ) ;
126 #endif  /* PCI */
127
128         smc->hw.timer_activ = FALSE ;
129 }
130
131 /************************
132  *
133  *      hwt_init
134  *
135  *      Initialize hardware timer.
136  *
137  *      void hwt_init(
138  *              struct s_smc *smc) ;
139  * In
140  *      smc - A pointer to the SMT Context structure.
141  * Out
142  *      Nothing.
143  *
144  ************************/
145 void hwt_init(struct s_smc *smc)
146 {
147         smc->hw.t_start = 0 ;
148         smc->hw.t_stop  = 0 ;
149         smc->hw.timer_activ = FALSE ;
150
151         hwt_restart(smc) ;
152 }
153
154 /************************
155  *
156  *      hwt_restart
157  *
158  *      Clear timer interrupt.
159  *
160  *      void hwt_restart(
161  *              struct s_smc *smc) ;
162  * In
163  *      smc - A pointer to the SMT Context structure.
164  * Out
165  *      Nothing.
166  *
167  ************************/
168 void hwt_restart(struct s_smc *smc)
169 {
170         hwt_stop(smc) ;
171 #ifndef PCI
172         OUT_82c54_TIMER(3,1<<6 | 3<<4 | 0<<1) ; /* counter 1, mode 0 */
173         OUT_82c54_TIMER(1,1 ) ;                 /* LSB */
174         OUT_82c54_TIMER(1,0 ) ;                 /* MSB */
175 #endif
176 }
177
178 /************************
179  *
180  *      hwt_read
181  *
182  *      Stop hardware timer and read time elapsed since last start.
183  *
184  *      u_long hwt_read(smc) ;
185  * In
186  *      smc - A pointer to the SMT Context structure.
187  * Out
188  *      The elapsed time since last start in units of 16us.
189  *
190  ************************/
191 u_long hwt_read(struct s_smc *smc)
192 {
193         u_short tr ;
194 #ifndef PCI
195         u_short is ;
196 #else
197         u_long  is ;
198 #endif
199
200         if (smc->hw.timer_activ) {
201                 hwt_stop(smc) ;
202 #ifndef PCI
203                 OUT_82c54_TIMER(3,1<<6) ;       /* latch command */
204                 tr = IN_82c54_TIMER(1) & 0xff ;
205                 tr += (IN_82c54_TIMER(1) & 0xff)<<8 ;
206 #else   /* PCI */
207                 tr = (u_short)((inpd(ADDR(B2_TI_VAL))/200) & 0xffff) ;
208 #endif  /* PCI */
209                 is = GET_ISR() ;
210                 /* Check if timer expired (or wraparound). */
211                 if ((tr > smc->hw.t_start) || (is & IS_TIMINT)) {
212                         hwt_restart(smc) ;
213                         smc->hw.t_stop = smc->hw.t_start ;
214                 }
215                 else
216                         smc->hw.t_stop = smc->hw.t_start - tr ;
217         }
218         return (smc->hw.t_stop) ;
219 }
220
221 #ifdef  PCI
222 /************************
223  *
224  *      hwt_quick_read
225  *
226  *      Stop hardware timer and read timer value and start the timer again.
227  *
228  *      u_long hwt_read(smc) ;
229  * In
230  *      smc - A pointer to the SMT Context structure.
231  * Out
232  *      current timer value in units of 80ns.
233  *
234  ************************/
235 u_long hwt_quick_read(struct s_smc *smc)
236 {
237         u_long interval ;
238         u_long time ;
239
240         interval = inpd(ADDR(B2_TI_INI)) ;
241         outpw(ADDR(B2_TI_CRTL), TIM_STOP) ;
242         time = inpd(ADDR(B2_TI_VAL)) ;
243         outpd(ADDR(B2_TI_INI),time) ;
244         outpw(ADDR(B2_TI_CRTL), TIM_START) ;
245         outpd(ADDR(B2_TI_INI),interval) ;
246
247         return(time) ;
248 }
249
250 /************************
251  *
252  *      hwt_wait_time(smc,start,duration)
253  *
254  *      This function returnes after the amount of time is elapsed
255  *      since the start time.
256  * 
257  * para start           start time
258  *      duration        time to wait
259  *
260  * NOTE: The fuction will return immediately, if the timer is not 
261  *       started
262  ************************/
263 void hwt_wait_time(struct s_smc *smc, u_long start, long int duration)
264 {
265         long    diff ;
266         long    interval ;
267         int     wrapped ;
268
269         /*
270          * check if timer is running
271          */
272         if (smc->hw.timer_activ == FALSE ||
273                 hwt_quick_read(smc) == hwt_quick_read(smc)) {
274                 return ;
275         }
276
277         interval = inpd(ADDR(B2_TI_INI)) ;
278         if (interval > duration) {
279                 do {
280                         diff = (long)(start - hwt_quick_read(smc)) ;
281                         if (diff < 0) {
282                                 diff += interval ;
283                         }
284                 } while (diff <= duration) ;
285         }
286         else {
287                 diff = interval ;
288                 wrapped = 0 ;
289                 do {
290                         if (!wrapped) {
291                                 if (hwt_quick_read(smc) >= start) {
292                                         diff += interval ;
293                                         wrapped = 1 ;
294                                 }
295                         }
296                         else {
297                                 if (hwt_quick_read(smc) < start) {
298                                         wrapped = 0 ;
299                                 }
300                         }
301                 } while (diff <= duration) ;
302         }
303 }
304 #endif
305