/*
                             *******************
******************************* C SOURCE FILE *******************************
**                           *******************                           **
**                                                                         **
** project      : The C Kernel                                             ** 
** filename     : CKTIMER.C                                                **
** version      : 2                                                        **
** last revised : August 22, 2004                                          **
**                                                                         **
*****************************************************************************
**                                                                         **
** Copyright (c) 1998-2004, P.K. van der Vlugt                             **
** All rights reserved.                                                    **
**                                                                         **
*****************************************************************************

VERSION HISTORY:
----------------

Version     : 1
Date        : June 01, 2003
Revised by  : P.K. van der Vlugt
Description : Original version.

Version     : 2
Date        : August 22, 2004
Revised by  : P.K. van der Vlugt
Description : * Changed module name to comply to new kernel module naming 
                convention.

*/

#define _CKTIMER_C_SRC

/****************************************************************************/
/**                                                                        **/
/**                     MODULES USED                                       **/
/**                                                                        **/
/****************************************************************************/

#include "ckqueue.h"
#include "cktimer.h"

/****************************************************************************/
/**                                                                        **/
/**                     DEFINITIONS AND MACROS                             **/
/**                                                                        **/
/****************************************************************************/

#define TAIL    (NR_OF_TIMERS + 1)

#define MAX_KEY 0xFFFF
#define MIN_KEY 0

/****************************************************************************/
/**                                                                        **/
/**                     TYPEDEFS AND STRUCTURES                            **/
/**                                                                        **/
/****************************************************************************/

/****************************************************************************/
/**                                                                        **/
/**                     PROTOTYPES OF LOCAL FUNCTIONS                      **/
/**                                                                        **/
/****************************************************************************/

#if NR_OF_TIMERS > 0
static void init (int8u id);

/****************************************************************************/
/**                                                                        **/
/**                     EXPORTED VARIABLES                                 **/
/**                                                                        **/
/****************************************************************************/

TimerType Timer[NR_OF_TIMERS];
QueueType TimerQ[NR_OF_TIMERS + 2];          /* + 2 for head and tail */

/****************************************************************************/
/**                                                                        **/
/**                     GLOBAL VARIABLES                                   **/
/**                                                                        **/
/****************************************************************************/

/****************************************************************************/
/**                                                                        **/
/**                     EXPORTED FUNCTIONS                                 **/
/**                                                                        **/
/****************************************************************************/

/****************************************************************************/
void TimerInit (void)
/****************************************************************************/
{
int8u id;
int16u h, t;

  /**** Initialize all id's ****/
  for (id = 0; id < NR_OF_TIMERS; id++)
    init (id);

  /**** Initialize TimerQ delta-list ****/
  h = HEAD;
  t = TAIL;

  /**** Initialize TimerQ Head ****/
  TimerQ[h].qkey  = MIN_KEY;
  TimerQ[h].qnext = t;
  TimerQ[h].qprev = LIST_EMPTY;

  /**** Initialize TimerQ Tail ****/
  TimerQ[t].qkey  = MAX_KEY;
  TimerQ[t].qnext = h;
  TimerQ[t].qprev = LIST_EMPTY;
}

/****************************************************************************/
int8u TimerAlloc (void)
/****************************************************************************/
{
int8u id;

  for (id = 0; id < NR_OF_TIMERS; id++)
  {
    /**** Search for a free Id ****/
    if (!Timer[id].req)
    {
      Timer[id].req = TRUE;
      break;
    }
  }

  return (id);
}

/****************************************************************************/
void TimerFree (int8u id)
/****************************************************************************/
{
  if (id >= NR_OF_TIMERS)
    return;

  init (id);
}

/****************************************************************************/
void InsertDeltaTimer (int8u id)
/****************************************************************************/
{
int16u prev, next, key;

  /**** Find out where to insert ****/
  key  = Timer[id].count;
  prev = HEAD;
  next = TimerQ[HEAD].qnext;
  while (TimerQ[next].qkey < key)
  {
    key = key - TimerQ[next].qkey;
    prev = next;
    next = TimerQ[next].qnext;
  }

  /**** Link item into delta list ****/
  TimerQ[id].qnext = next;
  TimerQ[id].qprev = prev;
  TimerQ[id].qkey  = key;

  TimerQ[prev].qnext = id;
  TimerQ[next].qprev = id;

  if (next < NR_OF_TIMERS)
    TimerQ[next].qkey = TimerQ[next].qkey - key;
}

/****************************************************************************/
void DeleteDeltaTimer (int8u tid)
/****************************************************************************/
{
int16u next, id;
int16u count;

  /**** First restore the remaining count ****/
  next = HEAD;
  count = 0;
  do
  {
    /**** Get next item ****/
    next = TimerQ[next].qnext;
    /**** Add up all the counts ****/
    count = count + TimerQ[next].qkey;
  }
  while (next != tid);
  /**** Now restore remaining count ****/
  Timer[next].count = count;

  /**** Make up time in list before deletion ****/
  next = TimerQ[tid].qnext;
  /**** Check if not tail ****/
  if (next < NR_OF_TIMERS)
    TimerQ[next].qkey = TimerQ[next].qkey + TimerQ[tid].qkey;

  /**** Delete the item from the list ****/
  id = TimerQ[tid].qprev;
  TimerQ[id].qnext = TimerQ[tid].qnext;
  id = TimerQ[tid].qnext;
  TimerQ[id].qprev = TimerQ[tid].qprev;
}

/****************************************************************************/
int8u GetFirstTimer (void)
/****************************************************************************/
{
int16u h, id;

  h = TimerQ[HEAD].qnext;
  if (h < NR_OF_TIMERS)
  {
    TimerQ[HEAD].qnext = TimerQ[h].qnext;
    id = TimerQ[h].qnext;
    TimerQ[id].qprev = TimerQ[h].qprev;

    return ((int8u) h);
  }
  else
    return (LIST_EMPTY);
}

/****************************************************************************/
/**                                                                        **/
/**                     LOCAL FUNCTIONS                                    **/
/**                                                                        **/
/****************************************************************************/

/****************************************************************************/
static void init (int8u id)
/****************************************************************************/
{
  Timer[id].req     = FALSE;
  Timer[id].running = FALSE;
  Timer[id].count   = 0;
  Timer[id].reload  = 0;
  Timer[id].sid     = NR_OF_SEMAS;
  TimerQ[id].qkey   = 0;
  TimerQ[id].qnext  = NR_OF_TIMERS;
  TimerQ[id].qprev  = NR_OF_TIMERS;
}
#endif

/****************************************************************************/
/**                                                                        **/
/**                               EOF                                      **/
/**                                                                        **/
/****************************************************************************/