firmware/timer.c

   1 /***************************************************************************
   2 *             __________               __   ___.
   3 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7 *                     \/            \/     \/    \/            \/
   8 * $Id$
   9 *
  10 * Copyright (C) 2005 Jens Arnold
  11 *
  12 * All files in this archive are subject to the GNU General Public License.
  13 * See the file COPYING in the source tree root for full license agreement.
  14 *
  15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16 * KIND, either express or implied.
  17 *
  18 ****************************************************************************/
  19
  20 #include <stdbool.h>
  21 #include "config.h"
  22 #include "cpu.h"
  23 #include "system.h"
  24 #include "timer.h"
  25 #include "logf.h"
  26
  27 static int timer_prio = -1;
  28 void SHAREDBSS_ATTR (*pfn_timer)(void) = NULL;      /* timer callback */
  29 void SHAREDBSS_ATTR (*pfn_unregister)(void) = NULL; /* unregister callback */
  30 #ifdef CPU_COLDFIRE
  31 static int base_prescale;
  32 #elif defined CPU_PP || CONFIG_CPU == PNX0101
  33 static long SHAREDBSS_ATTR cycles_new = 0;
  34 #endif
  35
  36 /* interrupt handler */
  37 #if CONFIG_CPU == SH7034
  38 void IMIA4(void) __attribute__((interrupt_handler));
  39 void IMIA4(void)
  40 {
  41     if (pfn_timer != NULL)
  42         pfn_timer();
  43     and_b(~0x01, &TSR4); /* clear the interrupt */
  44 }
  45 #elif defined CPU_COLDFIRE
  46 void TIMER1(void) __attribute__ ((interrupt_handler));
  47 void TIMER1(void)
  48 {
  49     if (pfn_timer != NULL)
  50         pfn_timer();
  51     TER1 = 0xff; /* clear all events */
  52 }
  53 #elif defined(CPU_PP)
  54 void TIMER2(void)
  55 {
  56     TIMER2_VAL; /* ACK interrupt */
  57     if (cycles_new > 0)
  58     {
  59         TIMER2_CFG = 0xc0000000 | (cycles_new - 1);
  60         cycles_new = 0;
  61     }
  62     if (pfn_timer != NULL)
  63     {
  64         cycles_new = -1;
  65         /* "lock" the variable, in case timer_set_period()
  66          * is called within pfn_timer() */
  67         pfn_timer();
  68         cycles_new = 0;
  69     }
  70 }
  71 #elif CONFIG_CPU == PNX0101
  72 void TIMER1_ISR(void)
  73 {
  74     if (cycles_new > 0)
  75     {
  76         TIMER1.load = cycles_new - 1;
  77         cycles_new = 0;
  78     }
  79     if (pfn_timer != NULL)
  80     {
  81         cycles_new = -1;
  82         /* "lock" the variable, in case timer_set_period()
  83          * is called within pfn_timer() */
  84         pfn_timer();
  85         cycles_new = 0;
  86     }
  87     TIMER1.clr = 1; /* clear the interrupt */
  88 }
  89 #endif /* CONFIG_CPU */
  90
  91 static bool timer_set(long cycles, bool start)
  92 {
  93 #if (CONFIG_CPU == SH7034) || defined(CPU_COLDFIRE)
  94     int phi = 0; /* bits for the prescaler */
  95     int prescale = 1;
  96
  97     while (cycles > 0x10000)
  98     {   /* work out the smallest prescaler that makes it fit */
  99 #if CONFIG_CPU == SH7034
 100         phi++;
 101 #endif
 102         prescale *= 2;
 103         cycles >>= 1;
 104     }
 105 #endif
 106
 107 #if CONFIG_CPU == PNX0101
 108     if (start)
 109     {
 110         if (pfn_unregister != NULL)
 111         {
 112             pfn_unregister();
 113             pfn_unregister = NULL;
 114         }
 115         TIMER1.ctrl &= ~0x80; /* disable the counter */
 116         TIMER1.ctrl |= 0x40;  /* reload after counting down to zero */
 117         TIMER1.ctrl &= ~0xc;  /* no prescaler */
 118         TIMER1.clr = 1;       /* clear an interrupt event */
 119     }
 120     if (start || (cycles_new == -1)) /* within isr, cycles_new is "locked" */
 121     {                                /* enable timer */
 122         TIMER1.load = cycles - 1;
 123         TIMER1.ctrl |= 0x80;        /* enable the counter */
 124     }
 125     else
 126         cycles_new = cycles;
 127
 128     return true;
 129 #elif CONFIG_CPU == SH7034
 130     if (prescale > 8)
 131         return false;
 132
 133     if (start)
 134     {
 135         if (pfn_unregister != NULL)
 136         {
 137             pfn_unregister();
 138             pfn_unregister = NULL;
 139         }
 140
 141         and_b(~0x10, &TSTR); /* Stop the timer 4 */
 142         and_b(~0x10, &TSNC); /* No synchronization */
 143         and_b(~0x10, &TMDR); /* Operate normally */
 144
 145         TIER4 = 0xF9;        /* Enable GRA match interrupt */
 146     }
 147
 148     TCR4 = 0x20 | phi;   /* clear at GRA match, set prescaler */
 149     GRA4 = (unsigned short)(cycles - 1);
 150     if (start || (TCNT4 >= GRA4))
 151         TCNT4 = 0;
 152     and_b(~0x01, &TSR4); /* clear an eventual interrupt */
 153
 154     return true;
 155 #elif defined CPU_COLDFIRE
 156     if (prescale > 4096/CPUFREQ_MAX_MULT)
 157         return false;
 158
 159     if (prescale > 256/CPUFREQ_MAX_MULT)
 160     {
 161         phi = 0x05;      /* prescale sysclk/16, timer enabled */
 162         prescale >>= 4;
 163     }
 164     else
 165         phi = 0x03;      /* prescale sysclk, timer enabled */
 166
 167     base_prescale = prescale;
 168     prescale *= (cpu_frequency / CPU_FREQ);
 169
 170     if (start)
 171     {
 172         if (pfn_unregister != NULL)
 173         {
 174             pfn_unregister();
 175             pfn_unregister = NULL;
 176         }
 177         phi &= ~1;       /* timer disabled at start */
 178
 179         /* If it is already enabled, writing a 0 to the RST bit will clear
 180            the register, so we clear RST explicitly before writing the real
 181            data. */
 182         TMR1 = 0;
 183     }
 184
 185     /* We are using timer 1 */
 186     TMR1 = 0x0018 | (unsigned short)phi | ((unsigned short)(prescale - 1) << 8);
 187     TRR1 = (unsigned short)(cycles - 1);
 188     if (start || (TCN1 >= TRR1))
 189         TCN1 = 0; /* reset the timer */
 190     TER1 = 0xff;  /* clear all events */
 191
 192     return true;
 193 #elif defined(CPU_PP)
 194     if (cycles > 0x20000000 || cycles < 2)
 195         return false;
 196
 197     if (start)
 198     {
 199         if (pfn_unregister != NULL)
 200         {
 201             pfn_unregister();
 202             pfn_unregister = NULL;
 203         }
 204         CPU_INT_CLR = TIMER2_MASK;
 205         COP_INT_CLR = TIMER2_MASK;
 206     }
 207     if (start || (cycles_new == -1))  /* within isr, cycles_new is "locked" */
 208         TIMER2_CFG = 0xc0000000 | (cycles - 1);    /* enable timer */
 209     else
 210         cycles_new = cycles;
 211
 212     return true;
 213 #elif (CONFIG_CPU == IMX31L)
 214     /* TODO */
 215 #else
 216     return __TIMER_SET(cycles, start);
 217 #endif /* CONFIG_CPU */
 218 }
 219
 220 #ifdef CPU_COLDFIRE
 221 void timers_adjust_prescale(int multiplier, bool enable_irq)
 222 {
 223     /* tick timer */
 224     TMR0 = (TMR0 & 0x00ef)
 225          | ((unsigned short)(multiplier - 1) << 8)
 226          | (enable_irq ? 0x10 : 0);
 227
 228     if (pfn_timer)
 229     {
 230         /* user timer */
 231         int prescale = base_prescale * multiplier;
 232         TMR1 = (TMR1 & 0x00ef)
 233              | ((unsigned short)(prescale - 1) << 8)
 234              | (enable_irq ? 0x10 : 0);
 235     }
 236 }
 237 #endif
 238
 239 /* Register a user timer, called every <cycles> TIMER_FREQ cycles */
 240 bool timer_register(int reg_prio, void (*unregister_callback)(void),
 241                     long cycles, int int_prio, void (*timer_callback)(void)
 242                     IF_COP(, int core))
 243 {
 244     if (reg_prio <= timer_prio || cycles == 0)
 245         return false;
 246
 247 #if CONFIG_CPU == SH7034
 248     if (int_prio < 1 || int_prio > 15)
 249         return false;
 250 #endif
 251
 252     if (!timer_set(cycles, true))
 253         return false;
 254
 255     pfn_timer = timer_callback;
 256     pfn_unregister = unregister_callback;
 257     timer_prio = reg_prio;
 258
 259 #if CONFIG_CPU == SH7034
 260     IPRD = (IPRD & 0xFF0F) | int_prio << 4;  /* interrupt priority */
 261     or_b(0x10, &TSTR); /* start timer 4 */
 262     return true;
 263 #elif defined CPU_COLDFIRE
 264     ICR2 = 0x90;       /* interrupt on level 4.0 */
 265     and_l(~(1<<10), &IMR);
 266     TMR1 |= 1;         /* start timer */
 267     return true;
 268 #elif defined(CPU_PP)
 269     /* unmask interrupt source */
 270 #if NUM_CORES > 1
 271     if (core == COP)
 272         COP_INT_EN = TIMER2_MASK;
 273     else
 274 #endif
 275         CPU_INT_EN = TIMER2_MASK;
 276     return true;
 277 #elif CONFIG_CPU == PNX0101
 278     irq_set_int_handler(IRQ_TIMER1, TIMER1_ISR);
 279     irq_enable_int(IRQ_TIMER1);
 280     return true;
 281 #elif CONFIG_CPU == IMX31L
 282     /* TODO */
 283 #else
 284     return __TIMER_REGISTER(reg_prio, unregister_callback, cycles,
 285                             int_prio, timer_callback);
 286 #endif
 287     /* Cover for targets that don't use all these */
 288     (void)reg_prio;
 289     (void)unregister_callback;
 290     (void)cycles;
 291     /* TODO: Implement for PortalPlayer and iFP (if possible) */
 292     (void)int_prio;
 293     (void)timer_callback;
 294 }
 295
 296 bool timer_set_period(long cycles)
 297 {
 298     return timer_set(cycles, false);
 299 }
 300
 301 void timer_unregister(void)
 302 {
 303 #if CONFIG_CPU == SH7034
 304     and_b(~0x10, &TSTR);    /* stop the timer 4 */
 305     IPRD = (IPRD & 0xFF0F); /* disable interrupt */
 306 #elif defined CPU_COLDFIRE
 307     TMR1 = 0;               /* disable timer 1 */
 308     or_l((1<<10), &IMR);    /* disable interrupt */
 309 #elif defined(CPU_PP)
 310     TIMER2_CFG = 0;         /* stop timer 2 */
 311     CPU_INT_CLR = TIMER2_MASK;
 312     COP_INT_CLR = TIMER2_MASK;
 313 #elif CONFIG_CPU == PNX0101
 314     TIMER1.ctrl &= ~0x80;  /* disable timer 1 */
 315     irq_disable_int(IRQ_TIMER1);
 316 #elif CONFIG_CPU == S3C2440
 317     __TIMER_UNREGISTER();
 318 #endif
 319     pfn_timer = NULL;
 320     pfn_unregister = NULL;
 321     timer_prio = -1;
 322 }
 323