1/* calibrate.c: default delay calibration 2 * 3 * Excised from init/main.c 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7#include <linux/jiffies.h> 8#include <linux/delay.h> 9#include <linux/init.h> 10 11#include <asm/timex.h> 12 13static unsigned long preset_lpj; 14static int __init lpj_setup(char *str) 15{ 16 preset_lpj = simple_strtoul(str,NULL,0); 17 return 1; 18} 19 20__setup("lpj=", lpj_setup); 21 22#ifdef ARCH_HAS_READ_CURRENT_TIMER 23 24/* This routine uses the read_current_timer() routine and gets the 25 * loops per jiffy directly, instead of guessing it using delay(). 26 * Also, this code tries to handle non-maskable asynchronous events 27 * (like SMIs) 28 */ 29#define DELAY_CALIBRATION_TICKS ((HZ < 100) ? 1 : (HZ/100)) 30#define MAX_DIRECT_CALIBRATION_RETRIES 5 31 32static unsigned long __devinit calibrate_delay_direct(void) 33{ 34 unsigned long pre_start, start, post_start; 35 unsigned long pre_end, end, post_end; 36 unsigned long start_jiffies; 37 unsigned long tsc_rate_min, tsc_rate_max; 38 unsigned long good_tsc_sum = 0; 39 unsigned long good_tsc_count = 0; 40 int i; 41 42 if (read_current_timer(&pre_start) < 0 ) 43 return 0; 44 45 /* 46 * A simple loop like 47 * while ( jiffies < start_jiffies+1) 48 * start = read_current_timer(); 49 * will not do. As we don't really know whether jiffy switch 50 * happened first or timer_value was read first. And some asynchronous 51 * event can happen between these two events introducing errors in lpj. 52 * 53 * So, we do 54 * 1. pre_start <- When we are sure that jiffy switch hasn't happened 55 * 2. check jiffy switch 56 * 3. start <- timer value before or after jiffy switch 57 * 4. post_start <- When we are sure that jiffy switch has happened 58 * 59 * Note, we don't know anything about order of 2 and 3. 60 * Now, by looking at post_start and pre_start difference, we can 61 * check whether any asynchronous event happened or not 62 */ 63 64 for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) { 65 pre_start = 0; 66 read_current_timer(&start); 67 start_jiffies = jiffies; 68 while (jiffies <= (start_jiffies + 1)) { 69 pre_start = start; 70 read_current_timer(&start); 71 } 72 read_current_timer(&post_start); 73 74 pre_end = 0; 75 end = post_start; 76 while (jiffies <= 77 (start_jiffies + 1 + DELAY_CALIBRATION_TICKS)) { 78 pre_end = end; 79 read_current_timer(&end); 80 } 81 read_current_timer(&post_end); 82 83 tsc_rate_max = (post_end - pre_start) / DELAY_CALIBRATION_TICKS; 84 tsc_rate_min = (pre_end - post_start) / DELAY_CALIBRATION_TICKS; 85 86 /* 87 * If the upper limit and lower limit of the tsc_rate is 88 * >= 12.5% apart, redo calibration. 89 */ 90 if (pre_start != 0 && pre_end != 0 && 91 (tsc_rate_max - tsc_rate_min) < (tsc_rate_max >> 3)) { 92 good_tsc_count++; 93 good_tsc_sum += tsc_rate_max; 94 } 95 } 96 97 if (good_tsc_count) 98 return (good_tsc_sum/good_tsc_count); 99 100 printk(KERN_WARNING "calibrate_delay_direct() failed to get a good " 101 "estimate for loops_per_jiffy.\nProbably due to long platform interrupts. Consider using \"lpj=\" boot option.\n"); 102 return 0; 103} 104#else 105static unsigned long __devinit calibrate_delay_direct(void) {return 0;} 106#endif 107 108#if defined(CONFIG_BCM947XX) && defined(CONFIG_HWSIM) 109#include <asm/time.h> 110#endif 111 112/* 113 * This is the number of bits of precision for the loops_per_jiffy. Each 114 * bit takes on average 1.5/HZ seconds. This (like the original) is a little 115 * better than 1% 116 */ 117#define LPS_PREC 8 118 119void __devinit calibrate_delay(void) 120{ 121 unsigned long ticks, loopbit; 122 int lps_precision = LPS_PREC; 123 124#if defined(CONFIG_BCM947XX) && defined(CONFIG_HWSIM) 125 preset_lpj = 10 * (mips_hpt_frequency / 1000); 126#endif 127 if (preset_lpj) { 128 loops_per_jiffy = preset_lpj; 129 printk("Calibrating delay loop (skipped)... " 130 "%lu.%02lu BogoMIPS preset\n", 131 loops_per_jiffy/(500000/HZ), 132 (loops_per_jiffy/(5000/HZ)) % 100); 133 } else if ((loops_per_jiffy = calibrate_delay_direct()) != 0) { 134 printk("Calibrating delay using timer specific routine.. "); 135 printk("%lu.%02lu BogoMIPS (lpj=%lu)\n", 136 loops_per_jiffy/(500000/HZ), 137 (loops_per_jiffy/(5000/HZ)) % 100, 138 loops_per_jiffy); 139 } else { 140 loops_per_jiffy = (1<<12); 141 142 printk(KERN_DEBUG "Calibrating delay loop... "); 143 while ((loops_per_jiffy <<= 1) != 0) { 144 /* wait for "start of" clock tick */ 145 ticks = jiffies; 146 while (ticks == jiffies) 147 /* nothing */; 148 /* Go .. */ 149 ticks = jiffies; 150 __delay(loops_per_jiffy); 151 ticks = jiffies - ticks; 152 if (ticks) 153 break; 154 } 155 156 /* 157 * Do a binary approximation to get loops_per_jiffy set to 158 * equal one clock (up to lps_precision bits) 159 */ 160 loops_per_jiffy >>= 1; 161 loopbit = loops_per_jiffy; 162 while (lps_precision-- && (loopbit >>= 1)) { 163 loops_per_jiffy |= loopbit; 164 ticks = jiffies; 165 while (ticks == jiffies) 166 /* nothing */; 167 ticks = jiffies; 168 __delay(loops_per_jiffy); 169 if (jiffies != ticks) /* longer than 1 tick */ 170 loops_per_jiffy &= ~loopbit; 171 } 172 173 /* Round the value and print it */ 174 printk("%lu.%02lu BogoMIPS (lpj=%lu)\n", 175 loops_per_jiffy/(500000/HZ), 176 (loops_per_jiffy/(5000/HZ)) % 100, 177 loops_per_jiffy); 178 } 179 180} 181