Subversion Repositories eco32

/*

 * timer.c -- timer simulation

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <setjmp.h>

#include "common.h"

#include "console.h"

#include "error.h"

#include "except.h"

#include "cpu.h"

#include "timer.h"

#define TIME_WRAP       1000000         /* avoid overflow of current time */

/*

 * data structure for simulation timer

 */

typedef struct timer {

  struct timer *next;

  int alarm;

  void (*callback)(int param);

  int param;

} Timer;

/*

 * data structure for timer/counter device

 */

typedef struct {

  Word ctrl;

  Word divisor;

  Word counter;

  int irq;

} TimerCounter;

static Bool debug = false;

static Timer *activeTimers = NULL;

static Timer *freeTimers = NULL;

static int currentTime = 0;              /* measured in clock cycles */

static TimerCounter timerCounters[NUMBER_TMRCNT];

Word timerRead(Word addr) {

  int dev, reg;

  Word data;

  if (debug) {

    cPrintf("\n**** TIMER READ from 0x%08X", addr);

  }

  dev = addr >> 12;

  if (dev >= NUMBER_TMRCNT) {

    /* illegal device */

    throwException(EXC_BUS_TIMEOUT);

  }

  reg = addr & 0x0FFF;

  if (reg == TIMER_CTRL) {

    data = timerCounters[dev].ctrl;

  } else

  if (reg == TIMER_DIVISOR) {

    data = timerCounters[dev].divisor;

  } else

  if (reg == TIMER_COUNTER) {

    data = timerCounters[dev].counter;

  } else {

    /* illegal register */

    throwException(EXC_BUS_TIMEOUT);

  }

  if (debug) {

    cPrintf(", data = 0x%08X ****\n", data);

  }

  return data;

}

void timerWrite(Word addr, Word data) {

  int dev, reg;

  if (debug) {

    cPrintf("\n**** TIMER WRITE to 0x%08X, data = 0x%08X ****\n",

            addr, data);

  }

  dev = addr >> 12;

  if (dev >= NUMBER_TMRCNT) {

    /* illegal device */

    throwException(EXC_BUS_TIMEOUT);

  }

  reg = addr & 0x0FFF;

  if (reg == TIMER_CTRL) {

    if (data & TIMER_IEN) {

      timerCounters[dev].ctrl |= TIMER_IEN;

    } else {

      timerCounters[dev].ctrl &= ~TIMER_IEN;

    }

    if (data & TIMER_EXP) {

      timerCounters[dev].ctrl |= TIMER_EXP;

    } else {

      timerCounters[dev].ctrl &= ~TIMER_EXP;

    }

    if ((timerCounters[dev].ctrl & TIMER_IEN) != 0 &&

        (timerCounters[dev].ctrl & TIMER_EXP) != 0) {

      /* raise timer interrupt */

      cpuSetInterrupt(timerCounters[dev].irq);

    } else {

      /* lower timer interrupt */

      cpuResetInterrupt(timerCounters[dev].irq);

    }

  } else

  if (reg == TIMER_DIVISOR) {

    timerCounters[dev].divisor = data;

    timerCounters[dev].counter = data;

  } else {

    /* illegal register */

    throwException(EXC_BUS_TIMEOUT);

  }

}

void timerTick(void) {

  Timer *timer;

  void (*callback)(int param);

  int param;

  int i;

  /* increment current time */

  currentTime += CC_PER_INSTR;

  /* avoid overflow */

  if (currentTime >= TIME_WRAP) {

    currentTime -= TIME_WRAP;

    timer = activeTimers;

    while (timer != NULL) {

      timer->alarm -= TIME_WRAP;

      timer = timer->next;

    }

  }

  /* check whether any simulation timer expired */

  while (activeTimers != NULL &&

         currentTime >= activeTimers->alarm) {

    timer = activeTimers;

    activeTimers = timer->next;

    callback = timer->callback;

    param = timer->param;

    timer->next = freeTimers;

    freeTimers = timer;

    (*callback)(param);

  }

  /* decrement counters and check if an interrupt must be raised */

  for (i = 0; i < NUMBER_TMRCNT; i++) {

    if (timerCounters[i].counter <= CC_PER_INSTR) {

      timerCounters[i].counter += timerCounters[i].divisor - CC_PER_INSTR;

      timerCounters[i].ctrl |= TIMER_EXP;

      if (timerCounters[i].ctrl & TIMER_IEN) {

        /* raise timer interrupt */

        cpuSetInterrupt(timerCounters[i].irq);

      }

    } else {

      timerCounters[i].counter -= CC_PER_INSTR;

    }

  }

}

void timerStart(int usec, void (*callback)(int param), int param) {

  Timer *timer;

  Timer *p;

  if (freeTimers == NULL) {

    error("out of timers");

  }

  timer = freeTimers;

  freeTimers = timer->next;

  timer->alarm = currentTime + usec * CC_PER_USEC;

  timer->callback = callback;

  timer->param = param;

  if (activeTimers == NULL ||

      timer->alarm < activeTimers->alarm) {

    /* link into front of active timers queue */

    timer->next = activeTimers;

    activeTimers = timer;

  } else {

    /* link elsewhere into active timers queue */

    p = activeTimers;

    while (p->next != NULL &&

           p->next->alarm <= timer->alarm) {

      p = p->next;

    }

    timer->next = p->next;

    p->next = timer;

  }

}

void timerReset(void) {

  Timer *timer;

  int i;

  cPrintf("Resetting Timer...\n");

  while (activeTimers != NULL) {

    timer = activeTimers;

    activeTimers = timer->next;

    timer->next = freeTimers;

    freeTimers = timer;

  }

  for (i = 0; i < NUMBER_TMRCNT; i++) {

    timerCounters[i].ctrl = 0x00000000;

    timerCounters[i].divisor = 0xFFFFFFFF;

    timerCounters[i].counter = 0xFFFFFFFF;

    timerCounters[i].irq = IRQ_TIMER_0 + i;

  }

}

void timerInit(void) {

  Timer *timer;

  int i;

  for (i = 0; i < NUMBER_TIMERS; i++) {

    timer = malloc(sizeof(Timer));

    if (timer == NULL) {

      error("cannot allocate simulation timers");

    }

    timer->next = freeTimers;

    freeTimers = timer;

  }

  timerReset();

}

void timerExit(void) {

  Timer *timer;

  while (activeTimers != NULL) {

    timer = activeTimers;

    activeTimers = timer->next;

    timer->next = freeTimers;

    freeTimers = timer;

  }

  while (freeTimers != NULL) {

    timer = freeTimers;

    freeTimers = timer->next;

    free(timer);

  }

}