2 * Copyright (C) 1993-1996 Bas Laarhoven.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; see the file COPYING. If not, write to
16 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
19 * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-calibr.c,v $
21 * $Date: 1997/10/05 19:18:08 $
23 * GP calibration routine for processor speed dependent
27 #include <linux/config.h>
28 #include <linux/errno.h>
29 #include <linux/jiffies.h>
30 #include <asm/system.h>
32 #if defined(__alpha__)
33 # include <asm/hwrpb.h>
34 #elif defined(__i386__) || defined(__x86_64__)
35 # include <linux/timex.h>
37 #include <linux/ftape.h>
38 #include "../lowlevel/ftape-tracing.h"
39 #include "../lowlevel/ftape-calibr.h"
40 #include "../lowlevel/fdc-io.h"
44 #if !defined(__alpha__) && !defined(__i386__) && !defined(__x86_64__)
45 # error Ftape is not implemented for this architecture!
48 #if defined(__alpha__)
49 static unsigned long ps_per_cycle = 0;
52 static spinlock_t calibr_lock;
55 * Note: On Intel PCs, the clock ticks at 100 Hz (HZ==100) which is
56 * too slow for certain timeouts (and that clock doesn't even tick
57 * when interrupts are disabled). For that reason, the 8254 timer is
58 * used directly to implement fine-grained timeouts. However, on
59 * Alpha PCs, the 8254 is *not* used to implement the clock tick
60 * (which is 1024 Hz, normally) and the 8254 timer runs at some
61 * "random" frequency (it seems to run at 18Hz, but it's not safe to
62 * rely on this value). Instead, we use the Alpha's "rpcc"
63 * instruction to read cycle counts. As this is a 32 bit counter,
64 * it will overflow only once per 30 seconds (on a 200MHz machine),
68 unsigned int ftape_timestamp(void)
70 #if defined(__alpha__)
73 asm volatile ("rpcc %0" : "=r" (r));
75 #elif defined(__i386__) || defined(__x86_64__)
80 spin_lock_irqsave(&calibr_lock, flags);
81 outb_p(0x00, 0x43); /* latch the count ASAP */
82 lo = inb_p(0x40); /* read the latched count */
85 spin_unlock_irqrestore(&calibr_lock, flags);
86 return ((hi + 1) * (unsigned int) LATCH) - lo; /* downcounter ! */
90 static unsigned int short_ftape_timestamp(void)
92 #if defined(__alpha__)
93 return ftape_timestamp();
94 #elif defined(__i386__) || defined(__x86_64__)
98 spin_lock_irqsave(&calibr_lock, flags);
99 outb_p(0x00, 0x43); /* latch the count ASAP */
100 count = inb_p(0x40); /* read the latched count */
101 count |= inb(0x40) << 8;
102 spin_unlock_irqrestore(&calibr_lock, flags);
103 return (LATCH - count); /* normal: downcounter */
107 static unsigned int diff(unsigned int t0, unsigned int t1)
109 #if defined(__alpha__)
110 return (t1 <= t0) ? t1 + (1UL << 32) - t0 : t1 - t0;
111 #elif defined(__i386__) || defined(__x86_64__)
113 * This is tricky: to work for both short and full ftape_timestamps
114 * we'll have to discriminate between these.
115 * If it _looks_ like short stamps with wrapping around we'll
116 * asume it are. This will generate a small error if it really
117 * was a (very large) delta from full ftape_timestamps.
119 return (t1 <= t0 && t0 <= LATCH) ? t1 + LATCH - t0 : t1 - t0;
123 static unsigned int usecs(unsigned int count)
125 #if defined(__alpha__)
126 return (ps_per_cycle * count) / 1000000UL;
127 #elif defined(__i386__) || defined(__x86_64__)
128 return (10000 * count) / ((CLOCK_TICK_RATE + 50) / 100);
132 unsigned int ftape_timediff(unsigned int t0, unsigned int t1)
135 * Calculate difference in usec for ftape_timestamp results t0 & t1.
136 * Note that on the i386 platform with short time-stamps, the
137 * maximum allowed timespan is 1/HZ or we'll lose ticks!
139 return usecs(diff(t0, t1));
142 /* To get an indication of the I/O performance,
143 * measure the duration of the inb() function.
145 static void time_inb(void)
153 spin_lock_irqsave(&calibr_lock, flags);
154 t0 = short_ftape_timestamp();
155 for (i = 0; i < 1000; ++i) {
156 status = inb(fdc.msr);
158 t1 = short_ftape_timestamp();
159 spin_unlock_irqrestore(&calibr_lock, flags);
160 TRACE(ft_t_info, "inb() duration: %d nsec", ftape_timediff(t0, t1));
164 static void init_clock(void)
166 #if defined(__i386__) || defined(__x86_64__)
171 /* Haven't studied on why, but there sometimes is a problem
172 * with the tick timer readout. The two bytes get swapped.
173 * This hack solves that problem by doing one extra input.
175 for (i = 0; i < 1000; ++i) {
176 t = short_ftape_timestamp();
178 inb_p(0x40); /* get in sync again */
179 TRACE(ft_t_warn, "clock counter fixed");
183 #elif defined(__alpha__)
184 #if CONFIG_FT_ALPHA_CLOCK == 0
185 #error You must define and set CONFIG_FT_ALPHA_CLOCK in 'make config' !
187 extern struct hwrpb_struct *hwrpb;
190 if (hwrpb->cycle_freq != 0) {
191 ps_per_cycle = (1000*1000*1000*1000UL) / hwrpb->cycle_freq;
194 * HELP: Linux 2.0.x doesn't set cycle_freq on my noname !
196 ps_per_cycle = (1000*1000*1000*1000UL) / CONFIG_FT_ALPHA_CLOCK;
203 * Input: function taking int count as parameter.
204 * pointers to calculated calibration variables.
206 void ftape_calibrate(char *name,
207 void (*fun) (unsigned int),
208 unsigned int *calibr_count,
209 unsigned int *calibr_time)
211 static int first_time = 1;
216 #if defined(__i386__) || defined(__x86_64__)
217 unsigned int old_tc = 0;
218 unsigned int old_count = 1;
219 unsigned int old_time = 1;
221 TRACE_FUN(ft_t_flow);
223 if (first_time) { /* get idea of I/O performance */
228 /* value of timeout must be set so that on very slow systems
229 * it will give a time less than one jiffy, and on
230 * very fast systems it'll give reasonable precision.
234 for (i = 0; i < 15; ++i) {
238 unsigned int multiple;
242 *calibr_time = count; /* set TC to 1 */
243 spin_lock_irqsave(&calibr_lock, flags);
244 fun(0); /* dummy, get code into cache */
245 t0 = short_ftape_timestamp();
246 fun(0); /* overhead + one test */
247 t1 = short_ftape_timestamp();
249 t0 = short_ftape_timestamp();
250 fun(count); /* overhead + count tests */
251 t1 = short_ftape_timestamp();
252 multiple = diff(t0, t1);
253 spin_unlock_irqrestore(&calibr_lock, flags);
254 time = ftape_timediff(0, multiple - once);
255 tc = (1000 * time) / (count - 1);
256 TRACE(ft_t_any, "once:%3d us,%6d times:%6d us, TC:%5d ns",
257 usecs(once), count - 1, usecs(multiple), tc);
258 #if defined(__alpha__)
260 * Increase the calibration count exponentially until the
261 * calibration time exceeds 100 ms.
263 if (time >= 100*1000) {
266 #elif defined(__i386__) || defined(__x86_64__)
268 * increase the count until the resulting time nears 2/HZ,
269 * then the tc will drop sharply because we lose LATCH counts.
271 if (tc <= old_tc / 2) {
282 *calibr_count = count - 1;
284 TRACE(ft_t_info, "TC for `%s()' = %d nsec (at %d counts)",
285 name, (1000 * *calibr_time) / *calibr_count, *calibr_count);