calibrate.c 7.59 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6
/* calibrate.c: default delay calibration
 *
 * Excised from init/main.c
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

7
#include <linux/jiffies.h>
Linus Torvalds's avatar
Linus Torvalds committed
8 9
#include <linux/delay.h>
#include <linux/init.h>
Andrew Morton's avatar
Andrew Morton committed
10
#include <linux/timex.h>
11
#include <linux/smp.h>
12

13
unsigned long lpj_fine;
Randy Dunlap's avatar
Randy Dunlap committed
14
unsigned long preset_lpj;
Linus Torvalds's avatar
Linus Torvalds committed
15 16 17 18 19 20 21 22
static int __init lpj_setup(char *str)
{
	preset_lpj = simple_strtoul(str,NULL,0);
	return 1;
}

__setup("lpj=", lpj_setup);

23 24 25 26 27 28 29 30 31 32
#ifdef ARCH_HAS_READ_CURRENT_TIMER

/* This routine uses the read_current_timer() routine and gets the
 * loops per jiffy directly, instead of guessing it using delay().
 * Also, this code tries to handle non-maskable asynchronous events
 * (like SMIs)
 */
#define DELAY_CALIBRATION_TICKS			((HZ < 100) ? 1 : (HZ/100))
#define MAX_DIRECT_CALIBRATION_RETRIES		5

33
static unsigned long __cpuinit calibrate_delay_direct(void)
34 35 36 37
{
	unsigned long pre_start, start, post_start;
	unsigned long pre_end, end, post_end;
	unsigned long start_jiffies;
38 39 40
	unsigned long timer_rate_min, timer_rate_max;
	unsigned long good_timer_sum = 0;
	unsigned long good_timer_count = 0;
41 42 43
	unsigned long measured_times[MAX_DIRECT_CALIBRATION_RETRIES];
	int max = -1; /* index of measured_times with max/min values or not set */
	int min = -1;
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
	int i;

	if (read_current_timer(&pre_start) < 0 )
		return 0;

	/*
	 * A simple loop like
	 *	while ( jiffies < start_jiffies+1)
	 *		start = read_current_timer();
	 * will not do. As we don't really know whether jiffy switch
	 * happened first or timer_value was read first. And some asynchronous
	 * event can happen between these two events introducing errors in lpj.
	 *
	 * So, we do
	 * 1. pre_start <- When we are sure that jiffy switch hasn't happened
	 * 2. check jiffy switch
	 * 3. start <- timer value before or after jiffy switch
	 * 4. post_start <- When we are sure that jiffy switch has happened
	 *
	 * Note, we don't know anything about order of 2 and 3.
	 * Now, by looking at post_start and pre_start difference, we can
	 * check whether any asynchronous event happened or not
	 */

	for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) {
		pre_start = 0;
		read_current_timer(&start);
		start_jiffies = jiffies;
72
		while (time_before_eq(jiffies, start_jiffies + 1)) {
73 74 75 76 77 78 79
			pre_start = start;
			read_current_timer(&start);
		}
		read_current_timer(&post_start);

		pre_end = 0;
		end = post_start;
80 81
		while (time_before_eq(jiffies, start_jiffies + 1 +
					       DELAY_CALIBRATION_TICKS)) {
82 83 84 85 86
			pre_end = end;
			read_current_timer(&end);
		}
		read_current_timer(&post_end);

87 88 89 90
		timer_rate_max = (post_end - pre_start) /
					DELAY_CALIBRATION_TICKS;
		timer_rate_min = (pre_end - post_start) /
					DELAY_CALIBRATION_TICKS;
91 92

		/*
93
		 * If the upper limit and lower limit of the timer_rate is
94 95
		 * >= 12.5% apart, redo calibration.
		 */
96 97 98 99 100 101
		if (start >= post_end)
			printk(KERN_NOTICE "calibrate_delay_direct() ignoring "
					"timer_rate as we had a TSC wrap around"
					" start=%lu >=post_end=%lu\n",
				start, post_end);
		if (start < post_end && pre_start != 0 && pre_end != 0 &&
102 103 104
		    (timer_rate_max - timer_rate_min) < (timer_rate_max >> 3)) {
			good_timer_count++;
			good_timer_sum += timer_rate_max;
105 106 107 108 109 110 111 112
			measured_times[i] = timer_rate_max;
			if (max < 0 || timer_rate_max > measured_times[max])
				max = i;
			if (min < 0 || timer_rate_max < measured_times[min])
				min = i;
		} else
			measured_times[i] = 0;

113 114
	}

115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
	/*
	 * Find the maximum & minimum - if they differ too much throw out the
	 * one with the largest difference from the mean and try again...
	 */
	while (good_timer_count > 1) {
		unsigned long estimate;
		unsigned long maxdiff;

		/* compute the estimate */
		estimate = (good_timer_sum/good_timer_count);
		maxdiff = estimate >> 3;

		/* if range is within 12% let's take it */
		if ((measured_times[max] - measured_times[min]) < maxdiff)
			return estimate;

		/* ok - drop the worse value and try again... */
		good_timer_sum = 0;
		good_timer_count = 0;
		if ((measured_times[max] - estimate) <
				(estimate - measured_times[min])) {
			printk(KERN_NOTICE "calibrate_delay_direct() dropping "
					"min bogoMips estimate %d = %lu\n",
				min, measured_times[min]);
			measured_times[min] = 0;
			min = max;
		} else {
			printk(KERN_NOTICE "calibrate_delay_direct() dropping "
					"max bogoMips estimate %d = %lu\n",
				max, measured_times[max]);
			measured_times[max] = 0;
			max = min;
		}

		for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) {
			if (measured_times[i] == 0)
				continue;
			good_timer_count++;
			good_timer_sum += measured_times[i];
			if (measured_times[i] < measured_times[min])
				min = i;
			if (measured_times[i] > measured_times[max])
				max = i;
		}

	}
161

162 163 164
	printk(KERN_NOTICE "calibrate_delay_direct() failed to get a good "
	       "estimate for loops_per_jiffy.\nProbably due to long platform "
		"interrupts. Consider using \"lpj=\" boot option.\n");
165 166 167
	return 0;
}
#else
168
static unsigned long __cpuinit calibrate_delay_direct(void) {return 0;}
169 170
#endif

Linus Torvalds's avatar
Linus Torvalds committed
171 172
/*
 * This is the number of bits of precision for the loops_per_jiffy.  Each
173 174
 * time we refine our estimate after the first takes 1.5/HZ seconds, so try
 * to start with a good estimate.
175
 * For the boot cpu we can skip the delay calibration and assign it a value
176 177
 * calculated based on the timer frequency.
 * For the rest of the CPUs we cannot assume that the timer frequency is same as
178
 * the cpu frequency, hence do the calibration for those.
Linus Torvalds's avatar
Linus Torvalds committed
179 180 181
 */
#define LPS_PREC 8

182
static unsigned long __cpuinit calibrate_delay_converge(void)
Linus Torvalds's avatar
Linus Torvalds committed
183
{
184
	/* First stage - slowly accelerate to find initial bounds */
185
	unsigned long lpj, lpj_base, ticks, loopadd, loopadd_base, chop_limit;
186
	int trials = 0, band = 0, trial_in_band = 0;
187 188

	lpj = (1<<12);
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208

	/* wait for "start of" clock tick */
	ticks = jiffies;
	while (ticks == jiffies)
		; /* nothing */
	/* Go .. */
	ticks = jiffies;
	do {
		if (++trial_in_band == (1<<band)) {
			++band;
			trial_in_band = 0;
		}
		__delay(lpj * band);
		trials += band;
	} while (ticks == jiffies);
	/*
	 * We overshot, so retreat to a clear underestimate. Then estimate
	 * the largest likely undershoot. This defines our chop bounds.
	 */
	trials -= band;
209 210 211 212 213 214
	loopadd_base = lpj * band;
	lpj_base = lpj * trials;

recalibrate:
	lpj = lpj_base;
	loopadd = loopadd_base;
215 216 217

	/*
	 * Do a binary approximation to get lpj set to
218
	 * equal one clock (up to LPS_PREC bits)
219
	 */
220
	chop_limit = lpj >> LPS_PREC;
221 222
	while (loopadd > chop_limit) {
		lpj += loopadd;
223 224
		ticks = jiffies;
		while (ticks == jiffies)
225
			; /* nothing */
226 227 228
		ticks = jiffies;
		__delay(lpj);
		if (jiffies != ticks)	/* longer than 1 tick */
229 230
			lpj -= loopadd;
		loopadd >>= 1;
231
	}
232 233 234 235 236 237 238 239 240 241
	/*
	 * If we incremented every single time possible, presume we've
	 * massively underestimated initially, and retry with a higher
	 * start, and larger range. (Only seen on x86_64, due to SMIs)
	 */
	if (lpj + loopadd * 2 == lpj_base + loopadd_base * 2) {
		lpj_base = lpj;
		loopadd_base <<= 2;
		goto recalibrate;
	}
242 243 244 245 246 247

	return lpj;
}

void __cpuinit calibrate_delay(void)
{
248
	static bool printed;
Linus Torvalds's avatar
Linus Torvalds committed
249 250 251

	if (preset_lpj) {
		loops_per_jiffy = preset_lpj;
252 253 254 255
		if (!printed)
			pr_info("Calibrating delay loop (skipped) "
				"preset value.. ");
	} else if ((!printed) && lpj_fine) {
256
		loops_per_jiffy = lpj_fine;
257
		pr_info("Calibrating delay loop (skipped), "
258
			"value calculated using timer frequency.. ");
259
	} else if ((loops_per_jiffy = calibrate_delay_direct()) != 0) {
260 261 262
		if (!printed)
			pr_info("Calibrating delay using timer "
				"specific routine.. ");
Linus Torvalds's avatar
Linus Torvalds committed
263
	} else {
264 265
		if (!printed)
			pr_info("Calibrating delay loop... ");
266
		loops_per_jiffy = calibrate_delay_converge();
Linus Torvalds's avatar
Linus Torvalds committed
267
	}
268 269
	if (!printed)
		pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)\n",
270 271
			loops_per_jiffy/(500000/HZ),
			(loops_per_jiffy/(5000/HZ)) % 100, loops_per_jiffy);
272 273

	printed = true;
Linus Torvalds's avatar
Linus Torvalds committed
274
}