arch/ppc-chrp/efika/timer/ticks.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7 #include <asm/mpc5200b.h>
   8 #include <asm/io.h>
   9 #include <aros/asmcall.h>
  10 #include <exec/execbase.h>
  11
  12 #include <inttypes.h>
  13 #include <proto/exec.h>
  14 #include <proto/timer.h>
  15
  16 #include "lowlevel.h"
  17
  18 // tick2usec -  64424510 for 66.666666MHz
  19 // tick2usec - 130150524 for 33.000000MHz
  20
  21 inline uint32_t __attribute__((const)) tick2usec(uint32_t tick)
  22 {
  23     uint32_t retval;
  24     uint64_t tmp = ((uint64_t)tick) * 130150524;
  25
  26     retval = (tmp + 0x7fffffff) >> 32;
  27
  28     return retval;
  29 }
  30
  31 inline uint32_t __attribute__((const)) usec2tick(uint32_t usec)
  32 {
  33     uint32_t retval;
  34 //    uint64_t tmp = ((uint64_t)usec) * 286331150203ULL;
  35 //
  36 //    retval = (tmp + 0x7fffffff) >> 32;
  37
  38     retval = usec * 33;
  39
  40     return retval;
  41 }
  42
  43 void EClockUpdate(struct TimerBase *TimerBase)
  44 {
  45     uint32_t time;
  46     uint32_t diff;
  47     int show = 0;
  48
  49     time = mftbl();
  50     diff = (time - TimerBase->tb_prev_tick);
  51     TimerBase->tb_prev_tick = time;
  52
  53     TimerBase->tb_ticks_total += diff;
  54
  55     TimerBase->tb_ticks_sec += diff;
  56     TimerBase->tb_ticks_elapsed += diff;
  57
  58     if (TimerBase->tb_ticks_sec >= 33000000)
  59     {
  60         TimerBase->tb_ticks_sec -= 33000000;
  61         TimerBase->tb_CurrentTime.tv_secs++;
  62
  63         show = 1;
  64     }
  65
  66     if (TimerBase->tb_ticks_elapsed >= 33000000)
  67     {
  68         TimerBase->tb_ticks_elapsed -= 33000000;
  69         TimerBase->tb_Elapsed.tv_secs++;
  70     }
  71
  72     TimerBase->tb_Elapsed.tv_micro = tick2usec(TimerBase->tb_ticks_elapsed);
  73     TimerBase->tb_CurrentTime.tv_micro = tick2usec(TimerBase->tb_ticks_sec);
  74
  75 //    if (show)
  76 //    {
  77 //        bug("[timer] CurrentTime: %d:%06d\n", TimerBase->tb_CurrentTime.tv_secs, TimerBase->tb_CurrentTime.tv_micro);
  78 //        bug("[timer] %08x %08x %d %d \n", tbc_expected, tbc_achieved, tbc_achieved-tbc_expected, corr);
  79 //    }
  80 }
  81
  82 void EClockSet(struct TimerBase *TimerBase)
  83 {
  84     TimerBase->tb_ticks_sec = usec2tick(TimerBase->tb_CurrentTime.tv_micro);
  85 }
  86
  87 extern volatile slt_t *slice_timer;
  88
  89 void TimerSetup(struct TimerBase *TimerBase, uint32_t waste)
  90 {
  91     int32_t delay = 660000;  /* 50Hz in worst case */
  92     struct timeval time;
  93     struct timerequest *tr;
  94     uint32_t current_time;
  95
  96     tr = (struct timerequest *)GetHead(&TimerBase->tb_Lists[TL_WAITVBL]);
  97
  98     if (tr)
  99     {
 100         time.tv_micro = tr->tr_time.tv_micro;
 101         time.tv_secs  = tr->tr_time.tv_secs;
 102
 103         SubTime(&time, &TimerBase->tb_CurrentTime);
 104
 105         if ((LONG)time.tv_secs < 0)
 106         {
 107             delay = 0;
 108         }
 109         else if (time.tv_secs == 0)
 110         {
 111 //            if (time.tv_micro < 20000)
 112 //            {
 113                 if (delay > usec2tick(time.tv_micro))
 114                     delay = usec2tick(time.tv_micro);
 115 //            }
 116         }
 117     }
 118
 119     tr = (struct timerequest *)GetHead(&TimerBase->tb_Lists[TL_VBLANK]);
 120
 121     if (tr)
 122     {
 123         time.tv_micro = tr->tr_time.tv_micro;
 124         time.tv_secs  = tr->tr_time.tv_secs;
 125
 126         SubTime(&time, &TimerBase->tb_Elapsed);
 127
 128         if ((LONG)time.tv_secs < 0)
 129         {
 130             delay = 0;
 131         }
 132         else if (time.tv_secs == 0)
 133         {
 134 //            if (time.tv_micro < 20000)
 135 //            {
 136                 if (delay > usec2tick(time.tv_micro))
 137                     delay = usec2tick(time.tv_micro);
 138 //            }
 139         }
 140     }
 141
 142     current_time = mftbl();
 143     delay -= ((int32_t)(current_time - waste)) + corr;
 144
 145     if (delay < 256) delay = 256;
 146
 147     tbc_expected = current_time + delay;
 148
 149     /* Stop the timer */
 150     outl(SLT_CF_INTRENA, &slice_timer->slt_cf);
 151     /* Set the delay */
 152     outl(delay, &slice_timer->slt_tc);
 153     /* Let timer go */
 154     outl(SLT_CF_INTRENA | SLT_CF_ENABLE, &slice_timer->slt_cf);
 155     /* Clear interrupt request. */
 156     outl(SLT_TS_ST, &slice_timer->slt_ts);
 157 }