release/src-rt-6.x.4708/linux/linux-2.6.36/arch/mips/kernel/csrc-powertv.c

   1 /*
   2  * Copyright (C) 2008 Scientific-Atlanta, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   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.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18 /*
  19  * The file comes from kernel/csrc-r4k.c
  20  */
  21 #include <linux/clocksource.h>
  22 #include <linux/init.h>
  23
  24 #include <asm/time.h>                   /* Not included in linux/time.h */
  25
  26 #include <asm/mach-powertv/asic_regs.h>
  27 #include "powertv-clock.h"
  28
  29 /* MIPS PLL Register Definitions */
  30 #define PLL_GET_M(x)            (((x) >> 8) & 0x000000FF)
  31 #define PLL_GET_N(x)            (((x) >> 16) & 0x000000FF)
  32 #define PLL_GET_P(x)            (((x) >> 24) & 0x00000007)
  33
  34 /*
  35  * returns:  Clock frequency in kHz
  36  */
  37 unsigned int __init mips_get_pll_freq(void)
  38 {
  39         unsigned int pll_reg, m, n, p;
  40         unsigned int fin = 54000; /* Base frequency in kHz */
  41         unsigned int fout;
  42
  43         /* Read PLL register setting */
  44         pll_reg = asic_read(mips_pll_setup);
  45         m = PLL_GET_M(pll_reg);
  46         n = PLL_GET_N(pll_reg);
  47         p = PLL_GET_P(pll_reg);
  48         pr_info("MIPS PLL Register:0x%x  M=%d  N=%d  P=%d\n", pll_reg, m, n, p);
  49
  50         /* Calculate clock frequency = (2 * N * 54MHz) / (M * (2**P)) */
  51         fout = ((2 * n * fin) / (m * (0x01 << p)));
  52
  53         pr_info("MIPS Clock Freq=%d kHz\n", fout);
  54
  55         return fout;
  56 }
  57
  58 static cycle_t c0_hpt_read(struct clocksource *cs)
  59 {
  60         return read_c0_count();
  61 }
  62
  63 static struct clocksource clocksource_mips = {
  64         .name           = "powertv-counter",
  65         .read           = c0_hpt_read,
  66         .mask           = CLOCKSOURCE_MASK(32),
  67         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
  68 };
  69
  70 static void __init powertv_c0_hpt_clocksource_init(void)
  71 {
  72         unsigned int pll_freq = mips_get_pll_freq();
  73
  74         pr_info("CPU frequency %d.%02d MHz\n", pll_freq / 1000,
  75                 (pll_freq % 1000) * 100 / 1000);
  76
  77         mips_hpt_frequency = pll_freq / 2 * 1000;
  78
  79         clocksource_mips.rating = 200 + mips_hpt_frequency / 10000000;
  80
  81         clocksource_set_clock(&clocksource_mips, mips_hpt_frequency);
  82
  83         clocksource_register(&clocksource_mips);
  84 }
  85
  86 /**
  87  * struct tim_c - free running counter
  88  * @hi: High 16 bits of the counter
  89  * @lo: Low 32 bits of the counter
  90  *
  91  * Lays out the structure of the free running counter in memory. This counter
  92  * increments at a rate of 27 MHz/8 on all platforms.
  93  */
  94 struct tim_c {
  95         unsigned int hi;
  96         unsigned int lo;
  97 };
  98
  99 static struct tim_c *tim_c;
 100
 101 static cycle_t tim_c_read(struct clocksource *cs)
 102 {
 103         unsigned int hi;
 104         unsigned int next_hi;
 105         unsigned int lo;
 106
 107         hi = readl(&tim_c->hi);
 108
 109         for (;;) {
 110                 lo = readl(&tim_c->lo);
 111                 next_hi = readl(&tim_c->hi);
 112                 if (next_hi == hi)
 113                         break;
 114                 hi = next_hi;
 115         }
 116
 117 pr_crit("%s: read %llx\n", __func__, ((u64) hi << 32) | lo);
 118         return ((u64) hi << 32) | lo;
 119 }
 120
 121 #define TIM_C_SIZE              48              /* # bits in the timer */
 122
 123 static struct clocksource clocksource_tim_c = {
 124         .name           = "powertv-tim_c",
 125         .read           = tim_c_read,
 126         .mask           = CLOCKSOURCE_MASK(TIM_C_SIZE),
 127         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 128 };
 129
 130 /**
 131  * powertv_tim_c_clocksource_init - set up a clock source for the TIM_C clock
 132  *
 133  * The hard part here is coming up with a constant k and shift s such that
 134  * the 48-bit TIM_C value multiplied by k doesn't overflow and that value,
 135  * when shifted right by s, yields the corresponding number of nanoseconds.
 136  * We know that TIM_C counts at 27 MHz/8, so each cycle corresponds to
 137  * 1 / (27,000,000/8) seconds. Multiply that by a billion and you get the
 138  * number of nanoseconds. Since the TIM_C value has 48 bits and the math is
 139  * done in 64 bits, avoiding an overflow means that k must be less than
 140  * 64 - 48 = 16 bits.
 141  */
 142 static void __init powertv_tim_c_clocksource_init(void)
 143 {
 144         int                     prescale;
 145         unsigned long           dividend;
 146         unsigned long           k;
 147         int                     s;
 148         const int               max_k_bits = (64 - 48) - 1;
 149         const unsigned long     billion = 1000000000;
 150         const unsigned long     counts_per_second = 27000000 / 8;
 151
 152         prescale = BITS_PER_LONG - ilog2(billion) - 1;
 153         dividend = billion << prescale;
 154         k = dividend / counts_per_second;
 155         s = ilog2(k) - max_k_bits;
 156
 157         if (s < 0)
 158                 s = prescale;
 159
 160         else {
 161                 k >>= s;
 162                 s += prescale;
 163         }
 164
 165         clocksource_tim_c.mult = k;
 166         clocksource_tim_c.shift = s;
 167         clocksource_tim_c.rating = 200;
 168
 169         clocksource_register(&clocksource_tim_c);
 170         tim_c = (struct tim_c *) asic_reg_addr(tim_ch);
 171 }
 172
 173 /**
 174  powertv_clocksource_init - initialize all clocksources
 175  */
 176 void __init powertv_clocksource_init(void)
 177 {
 178         powertv_c0_hpt_clocksource_init();
 179         powertv_tim_c_clocksource_init();
 180 }