cpu/mpc8xx/speed.c

   1 /*
   2  * (C) Copyright 2000-2002
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 #include <common.h>
  25 #include <mpc8xx.h>
  26 #include <asm/processor.h>
  27
  28 #define PITC_SHIFT 16
  29 #define PITR_SHIFT 16
  30 /* pitc values to time for 58/8192 seconds (about 70.8 milliseconds) */
  31 #define SPEED_PIT_COUNTS 58
  32 #define SPEED_PITC       ((SPEED_PIT_COUNTS - 1) << PITC_SHIFT)
  33 #define SPEED_PITC_INIT  ((SPEED_PIT_COUNTS + 1) << PITC_SHIFT)
  34
  35 /* Access functions for the Machine State Register */
  36 static __inline__ unsigned long get_msr(void)
  37 {
  38         unsigned long msr;
  39
  40         asm volatile("mfmsr %0" : "=r" (msr) :);
  41         return msr;
  42 }
  43
  44 static __inline__ void set_msr(unsigned long msr)
  45 {
  46         asm volatile("mtmsr %0" : : "r" (msr));
  47 }
  48
  49 /* ------------------------------------------------------------------------- */
  50
  51 /*
  52  * Measure CPU clock speed (core clock GCLK1, GCLK2),
  53  * also determine bus clock speed (checking bus divider factor)
  54  *
  55  * (Approx. GCLK frequency in Hz)
  56  *
  57  * Initializes timer 2 and PIT, but disables them before return.
  58  * [Use timer 2, because MPC823 CPUs mask 0.x do not have timers 3 and 4]
  59  *
  60  * When measuring the CPU clock against the PIT, we count cpu clocks
  61  * for 58/8192 seconds with a prescale divide by 177 for the cpu clock.
  62  * These strange values for the timing interval and prescaling are used
  63  * because the formula for the CPU clock is:
  64  *
  65  *   CPU clock = count * (177 * (8192 / 58))
  66  *
  67  *             = count * 24999.7241
  68  *
  69  *   which is very close to
  70  *
  71  *             = count * 25000
  72  *
  73  * Since the count gives the CPU clock divided by 25000, we can get
  74  * the CPU clock rounded to the nearest 0.1 MHz by
  75  *
  76  *   CPU clock = ((count + 2) / 4) * 100000;
  77  *
  78  * The rounding is important since the measurement is sometimes going
  79  * to be high or low by 0.025 MHz, depending on exactly how the clocks
  80  * and counters interact. By rounding we get the exact answer for any
  81  * CPU clock that is an even multiple of 0.1 MHz.
  82  */
  83
  84 unsigned long measure_gclk(void)
  85 {
  86         volatile immap_t *immr = (immap_t *) CFG_IMMR;
  87         volatile cpmtimer8xx_t *timerp = &immr->im_cpmtimer;
  88         ulong timer2_val;
  89         ulong msr_val;
  90
  91 #ifdef CONFIG_MPC866_et_al
  92         /* dont use OSCM, only use EXTCLK/512 */
  93         immr->im_clkrst.car_sccr |= SCCR_RTSEL | SCCR_RTDIV;
  94 #else
  95         immr->im_clkrst.car_sccr &= ~(SCCR_RTSEL | SCCR_RTDIV);
  96 #endif
  97
  98         /* Reset + Stop Timer 2, no cascading
  99          */
 100         timerp->cpmt_tgcr &= ~(TGCR_CAS2 | TGCR_RST2);
 101
 102         /* Keep stopped, halt in debug mode
 103          */
 104         timerp->cpmt_tgcr |= (TGCR_FRZ2 | TGCR_STP2);
 105
 106         /* Timer 2 setup:
 107          * Output ref. interrupt disable, int. clock
 108          * Prescale by 177. Note that prescaler divides by value + 1
 109          * so we must subtract 1 here.
 110          */
 111         timerp->cpmt_tmr2 = ((177 - 1) << TMR_PS_SHIFT) | TMR_ICLK_IN_GEN;
 112
 113         timerp->cpmt_tcn2 = 0;          /* reset state      */
 114         timerp->cpmt_tgcr |= TGCR_RST2; /* enable timer 2   */
 115
 116         /*
 117          * PIT setup:
 118          *
 119          * We want to time for SPEED_PITC_COUNTS counts (of 8192 Hz),
 120          * so the count value would be SPEED_PITC_COUNTS - 1.
 121          * But there would be an uncertainty in the start time of 1/4
 122          * count since when we enable the PIT the count is not
 123          * synchronized to the 32768 Hz oscillator. The trick here is
 124          * to start the count higher and wait until the PIT count
 125          * changes to the required value before starting timer 2.
 126          *
 127          * One count high should be enough, but occasionally the start
 128          * is off by 1 or 2 counts of 32768 Hz. With the start value
 129          * set two counts high it seems very reliable.
 130          */
 131
 132         immr->im_sitk.sitk_pitck = KAPWR_KEY;   /* PIT initialization */
 133         immr->im_sit.sit_pitc = SPEED_PITC_INIT;
 134
 135         immr->im_sitk.sitk_piscrk = KAPWR_KEY;
 136         immr->im_sit.sit_piscr = CFG_PISCR;
 137
 138         /*
 139          * Start measurement - disable interrupts, just in case
 140          */
 141         msr_val = get_msr ();
 142         set_msr (msr_val & ~MSR_EE);
 143
 144         immr->im_sit.sit_piscr |= PISCR_PTE;
 145
 146         /* spin until get exact count when we want to start */
 147         while (immr->im_sit.sit_pitr > SPEED_PITC);
 148
 149         timerp->cpmt_tgcr &= ~TGCR_STP2;        /* Start Timer 2    */
 150         while ((immr->im_sit.sit_piscr & PISCR_PS) == 0);
 151         timerp->cpmt_tgcr |= TGCR_STP2;         /* Stop  Timer 2    */
 152
 153         /* re-enable external interrupts if they were on */
 154         set_msr (msr_val);
 155
 156         /* Disable timer and PIT
 157          */
 158         timer2_val = timerp->cpmt_tcn2;         /* save before reset timer */
 159
 160         timerp->cpmt_tgcr &= ~(TGCR_RST2 | TGCR_FRZ2 | TGCR_STP2);
 161         immr->im_sit.sit_piscr &= ~PISCR_PTE;
 162
 163 #ifdef CONFIG_MPC866_et_al
 164         /* not using OSCM, using XIN, so scale appropriately */
 165         return (((timer2_val + 2) / 4) * (CFG_8XX_XIN/512))/8192 * 100000L;
 166 #else
 167         return ((timer2_val + 2) / 4) * 100000L;        /* convert to Hz    */
 168 #endif
 169 }
 170
 171 /*
 172  * get_clocks() fills in gd->cpu_clock depending on CONFIG_8xx_GCLK_FREQ
 173  * or (if it is not defined) measure_gclk() (which uses the ref clock)
 174  * from above.
 175  */
 176 int get_clocks (void)
 177 {
 178         DECLARE_GLOBAL_DATA_PTR;
 179
 180         volatile immap_t *immr = (immap_t *) CFG_IMMR;
 181 #ifndef CONFIG_8xx_GCLK_FREQ
 182         gd->cpu_clk = measure_gclk();
 183 #else /* CONFIG_8xx_GCLK_FREQ */
 184         /*
 185          * If for some reason measuring the gclk frequency won't
 186          * work, we return the hardwired value.
 187          * (For example, the cogent CMA286-60 CPU module has no
 188          * separate oscillator for PITRTCLK)
 189          */
 190
 191         gd->cpu_clk = CONFIG_8xx_GCLK_FREQ;
 192
 193 #endif /* CONFIG_8xx_GCLK_FREQ */
 194
 195         if ((immr->im_clkrst.car_sccr & SCCR_EBDF11) == 0) {
 196                 /* No Bus Divider active */
 197                 gd->bus_clk = gd->cpu_clk;
 198         } else {
 199                 /* The MPC8xx has only one BDF: half clock speed */
 200                 gd->bus_clk = gd->cpu_clk / 2;
 201         }
 202
 203         return (0);
 204 }
 205
 206 /* ------------------------------------------------------------------------- */