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

   1 #define DEBUG 1
   2
   3 #include <aros/debug.h>
   4 #include <asm/mpc5200b.h>
   5 #include <asm/io.h>
   6
   7 #include <aros/asmcall.h>
   8 #include <hardware/intbits.h>
   9 #include <exec/execbase.h>
  10
  11 #include <inttypes.h>
  12 #include <proto/exec.h>
  13 #include <proto/timer.h>
  14
  15 #include "lowlevel.h"
  16
  17 uint32_t tbc_expected;
  18 uint32_t tbc_achieved;
  19 int32_t corr;
  20
  21 volatile slt_t *slice_timer;
  22
  23 // tick2usec -  64424510 for 66.666666MHz
  24 // tick2usec - 130150524 for 33.000000MHz
  25
  26 inline uint32_t __attribute__((const)) tick2usec(uint32_t tick)
  27 {
  28     uint32_t retval;
  29     uint64_t tmp = ((uint64_t)tick) * 130150524;
  30
  31     retval = (tmp + 0x7fffffff) >> 32;
  32
  33     return retval;
  34 }
  35
  36 inline uint32_t __attribute__((const)) usec2tick(uint32_t usec)
  37 {
  38     uint32_t retval;
  39 //    uint64_t tmp = ((uint64_t)usec) * 286331150203ULL;
  40 //
  41 //    retval = (tmp + 0x7fffffff) >> 32;
  42
  43     retval = usec * 33;
  44
  45     return retval;
  46 }
  47
  48 void EClockUpdate(struct TimerBase *TimerBase)
  49 {
  50     uint32_t time;
  51     uint32_t diff;
  52     int show = 0;
  53
  54     time = mftbl();
  55     diff = (time - TimerBase->tb_prev_tick);
  56     TimerBase->tb_prev_tick = time;
  57
  58     TimerBase->tb_ticks_total += diff;
  59
  60     TimerBase->tb_ticks_sec += diff;
  61     TimerBase->tb_ticks_elapsed += diff;
  62
  63     if (TimerBase->tb_ticks_sec >= 33000000)
  64     {
  65         TimerBase->tb_ticks_sec -= 33000000;
  66         TimerBase->tb_CurrentTime.tv_secs++;
  67
  68         show = 1;
  69     }
  70
  71     if (TimerBase->tb_ticks_elapsed >= 33000000)
  72     {
  73         TimerBase->tb_ticks_elapsed -= 33000000;
  74         TimerBase->tb_Elapsed.tv_secs++;
  75     }
  76
  77     TimerBase->tb_Elapsed.tv_micro = tick2usec(TimerBase->tb_ticks_elapsed);
  78     TimerBase->tb_CurrentTime.tv_micro = tick2usec(TimerBase->tb_ticks_sec);
  79
  80 //    if (show)
  81 //    {
  82 //        bug("[timer] CurrentTime: %d:%06d\n", TimerBase->tb_CurrentTime.tv_secs, TimerBase->tb_CurrentTime.tv_micro);
  83 //        bug("[timer] %08x %08x %d %d \n", tbc_expected, tbc_achieved, tbc_achieved-tbc_expected, corr);
  84 //    }
  85 }
  86
  87 void EClockSet(struct TimerBase *TimerBase)
  88 {
  89     TimerBase->tb_ticks_sec = usec2tick(TimerBase->tb_CurrentTime.tv_micro);
  90 }
  91
  92 void TimerSetup(struct TimerBase *TimerBase, uint32_t waste)
  93 {
  94     int32_t delay = 660000;  /* 50Hz in worst case */
  95     struct timeval time;
  96     struct timerequest *tr;
  97     uint32_t current_time;
  98
  99     tr = (struct timerequest *)GetHead(&TimerBase->tb_Lists[TL_WAITVBL]);
 100
 101     if (tr)
 102     {
 103         time.tv_micro = tr->tr_time.tv_micro;
 104         time.tv_secs  = tr->tr_time.tv_secs;
 105
 106         SubTime(&time, &TimerBase->tb_CurrentTime);
 107
 108         if ((LONG)time.tv_secs < 0)
 109         {
 110             delay = 0;
 111         }
 112         else if (time.tv_secs == 0)
 113         {
 114 //            if (time.tv_micro < 20000)
 115 //            {
 116                 if (delay > usec2tick(time.tv_micro))
 117                     delay = usec2tick(time.tv_micro);
 118 //            }
 119         }
 120     }
 121
 122     tr = (struct timerequest *)GetHead(&TimerBase->tb_Lists[TL_VBLANK]);
 123
 124     if (tr)
 125     {
 126         time.tv_micro = tr->tr_time.tv_micro;
 127         time.tv_secs  = tr->tr_time.tv_secs;
 128
 129         SubTime(&time, &TimerBase->tb_Elapsed);
 130
 131         if ((LONG)time.tv_secs < 0)
 132         {
 133             delay = 0;
 134         }
 135         else if (time.tv_secs == 0)
 136         {
 137 //            if (time.tv_micro < 20000)
 138 //            {
 139                 if (delay > usec2tick(time.tv_micro))
 140                     delay = usec2tick(time.tv_micro);
 141 //            }
 142         }
 143     }
 144
 145     current_time = mftbl();
 146     delay -= ((int32_t)(current_time - waste)) + corr;
 147
 148     if (delay < 256) delay = 256;
 149
 150     tbc_expected = current_time + delay;
 151
 152     /* Stop the timer */
 153     outl(SLT_CF_INTRENA, &slice_timer->slt_cf);
 154     /* Set the delay */
 155     outl(delay, &slice_timer->slt_tc);
 156     /* Let timer go */
 157     outl(SLT_CF_INTRENA | SLT_CF_ENABLE, &slice_timer->slt_cf);
 158     /* Clear interrupt request. */
 159     outl(SLT_TS_ST, &slice_timer->slt_ts);
 160 }
 161
 162 /*
 163     This is a slightly faster version of AddTime() that we use here. It
 164     also saves the function call overhead...
 165 */
 166 #define FastAddTime(d, s)\
 167     (d)->tv_micro += (s)->tv_micro;\
 168     (d)->tv_secs += (s)->tv_secs;\
 169     if((d)->tv_micro > 999999) {\
 170         (d)->tv_secs++;\
 171         (d)->tv_micro -= 1000000;\
 172     }
 173
 174 BOOL timer_addToWaitList(struct TimerBase *, struct MinList *, struct timerequest *);
 175
 176 void SliceHandler(struct TimerBase *TimerBase, struct ExecBase *SysBase)
 177 {
 178     uint32_t startup_time = mftbl();
 179
 180     if (inl(&slice_timer->slt_ts) & SLT_TS_ST)
 181     {
 182         struct timerequest *tr, *next;
 183
 184         /* Clear interrupt request. */
 185         outl(SLT_TS_ST, &slice_timer->slt_ts);
 186         sync();
 187         /* Stop the timer */
 188         outl(0, &slice_timer->slt_cf);
 189 //        outl(SLT_CF_RUNWAIT | SLT_CF_INTRENA | SLT_CF_ENABLE, &slice_timer->slt_cf);
 190
 191 //        D(bug("[timer] SliceHandler on %08x%08x slt->cv=%08x\n", (uint32_t)(mftb() >> 32),mftbl(),inl(&slice_timer->slt_cv)));
 192
 193         EClockUpdate(TimerBase);
 194
 195         tbc_achieved = startup_time;
 196
 197         /* Timer errors bigger than approx 15 microseconds shouldn't be taken into account */
 198         //if (tbc_achieved > tbc_expected) // && (tbc_achieved - tbc_expected) < 1000)
 199         {
 200             corr = ((int32_t)(tbc_achieved - tbc_expected))-1;
 201         }
 202
 203
 204         /*
 205             Go through the "wait for x seconds" list and return requests
 206             that have completed. A completed request is one whose time
 207             is less than that of the elapsed time.
 208         */
 209         ForeachNodeSafe(&TimerBase->tb_Lists[TL_VBLANK], tr, next)
 210         {
 211             if(CmpTime(&TimerBase->tb_Elapsed, &tr->tr_time) <= 0)
 212             {
 213                 if (tr == &TimerBase->tb_vblank_timerequest)
 214                 {
 215                     struct IntVector *iv = &SysBase->IntVects[INTB_VERTB];
 216
 217                     /* VBlank Emu */
 218
 219                     if (iv->iv_Code)
 220                     {
 221                         AROS_UFC5(void, iv->iv_Code,
 222                             AROS_UFCA(ULONG, 0, D1),
 223                             AROS_UFCA(ULONG, 0, A0),
 224                             AROS_UFCA(APTR, iv->iv_Data, A1),
 225                             AROS_UFCA(APTR, iv->iv_Code, A5),
 226                             AROS_UFCA(struct ExecBase *, SysBase, A6)
 227                         );
 228                     }
 229                     /* Automatically requeue/reactivate request */
 230
 231                     Remove((struct Node *)tr);
 232                     tr->tr_node.io_Command = TR_ADDREQUEST;
 233                     tr->tr_time.tv_secs = 0;
 234                     tr->tr_time.tv_micro = 1000000 / SysBase->VBlankFrequency;
 235                     AddTime(&tr->tr_time, &TimerBase->tb_Elapsed);
 236
 237                     timer_addToWaitList(TimerBase, &TimerBase->tb_Lists[TL_VBLANK], tr);
 238                 }
 239                 else
 240                 {
 241                     /* This request has finished */
 242                     Remove((struct Node *)tr);
 243                     tr->tr_time.tv_secs = tr->tr_time.tv_micro = 0;
 244                     tr->tr_node.io_Error = 0;
 245                     ReplyMsg((struct Message *)tr);
 246                 }
 247             }
 248             else
 249             {
 250                 /*
 251                     The first request hasn't finished, as all requests are in
 252                     order, we don't bother searching through the remaining
 253                 */
 254                 break;
 255             }
 256         }
 257
 258         /*
 259             The other this is the "wait until a specified time". Here a request
 260             is complete if the time we are waiting for is before the current time.
 261         */
 262         ForeachNodeSafe(&TimerBase->tb_Lists[TL_WAITVBL], tr, next)
 263         {
 264             if(CmpTime(&TimerBase->tb_CurrentTime, &tr->tr_time) <= 0)
 265             {
 266                 /* This request has finished */
 267                 Remove((struct Node *)tr);
 268                 tr->tr_time.tv_secs = tr->tr_time.tv_micro = 0;
 269                 tr->tr_node.io_Error = 0;
 270                 ReplyMsg((struct Message *)tr);
 271             }
 272             else
 273             {
 274                 /*
 275                     The first request hasn't finished, as all requests are in
 276                     order, we don't bother searching through the remaining
 277                 */
 278                 break;
 279             }
 280         }
 281         TimerSetup(TimerBase, startup_time);
 282     }
 283 }