n3implat7bd92.c

NORTi3 is a realtime multitasking operating system conforming to the micro-ITRON 3.0 specification.

/*****************************************************************************/
/* NORTi3/ARM Interval Interrpt Handler (兪PLAT)                             */
/*                                                                           */
/*  Copyright (c)  1995-2000, MiSPO Co., Ltd.                                */
/*  All rights reserved.                                                     */
/*                                                                           */
/*  24/Nov/1999                                                              */
/*  22/May/2000  撪晹儗僕僗僞傪儚乕僪傾僋僙僗偺傒偵巇條曄峏                  */
/* 15/Nov/2001  uPLAT-7B梡偺僿僢僟僼傽僀儖柤曄峏                             */
/* 15/Nov/2001  僞僀儅廃婜偺嶼弌傪CGB偐傜弌椡偝傟傞CLKTMR偵傛偭偰媮傔傞曽朄  */
/*               偵曄峏                                                      */
/*****************************************************************************/
#include "norti3.h"
#include "nosys3s.h"
#include "okimpla2.h"

#include "drv_reg.h"


/* CPU clock */

#define MHz         1000000L
#ifndef HCLK
#define HCLK        32*MHz  //192*1000000L         /* CPU clock [Hz] */
#endif

//#define CLKTMR    (HCLK/16)	/* Frequency of CLKTMR terminal (Hz) */
#define CLKTMR    (HCLK)	/* Frequency of CLKTMR terminal (Hz) */

/* Interrupt vector Table */

#ifndef INTVEC
#define INTVEC      0x1000000L
#endif
#ifndef INTVSZ
#define INTVSZ      512
#endif

/* Interrupt priority */

#ifndef IP
#define IP          1
#endif
#if ((IP <= 0) || (IP > 7))
  #error illegal interrupt priority! (IP = 1 to 7)
#endif

/* Function protype */

INTHDR interr(void);
INTHDR inthdr(void);

/* define interval timer interrupt */
const T_DINT dint_inthdr = { TA_HLNG, inthdr, IP };

/*****************************************************************************
* Not defined interrupt
*
*   interr();
******************************************************************************/

INTHDR interr(void)
{
    ent_int();                      /* Start Interrrupt Handler  */

    /* (If need) discribe here */

    ret_int();                      /* End Interrrup Handler */
}

/*****************************************************************************
* Initialize Interrupt
*
* intini();
*
* Called from Kernel initialize routine乮sysini乯with disable interrupt
******************************************************************************/

ER intini(void)
{
  #if (INTVSZ!=0)
    int i;

    /* Initialize vector table */

    for (i = 0; i < (INTVSZ) / 4; i++)
        ((UW *)INTVEC)[i] = (UW)interr;
  #endif

    return E_OK;
}

/*****************************************************************************
* Define Interrupt Handler
*
*   ercd = def_int(dintno, const T_DINT *pk_dint);
*
*       UINT dintno;     Interrupt no
*       T_DINT *pk_dint; Interrupt handler define information
*         ATR intatr;    Interrupt handler atribute (TA_HLNG only乯
*         FP inthdr;     Handler address
*       ER ercd;         Error code
*
******************************************************************************/

ER def_int(UINT dintno, const T_DINT *pk_dint)
{
  #if (INTVSZ==0)

    return E_NOSPT;

  #else

    UINT i, psw;
    UW *p;
    FP fp;

    i = dintno;
	
    if (i >= (INTVSZ) / 4)
        return E_PAR;
    p = (UW *)INTVEC + i;

    if (pk_dint == (T_DINT *)NADR)
        fp = (FP)interr;
    else
        fp = pk_dint->inthdr;

    psw = vdis_psw();
    *p = (UW)fp;
    vset_psw(psw);
    return E_OK;

  #endif
}

/*****************************************************************************
* Get handler address
*
*   FP get_irq_func(void);
*
******************************************************************************/
FP get_irq_func(void)
{
    UW  intno;
    FP  fp;

    intno = sfr_inl(IRN);
    fp    = (FP)(*((UW *)INTVEC + intno));

    return fp;
}

/*****************************************************************************
* Clear interrupt in service
*
*   void clr_in_service(void);
*
******************************************************************************/
void clr_in_service(void)
{
     sfr_outl(CILCL, 0xffffffff);
}

/*****************************************************************************
* Start interval timer
*
* 宍幃  intini();
*
******************************************************************************/

ER intsta(void)
{
    UH tc;

  #if ((CLKTMR * MSEC)/(16*1000L) <= 0x10000L)
    tc = (UH)(0x10000 - (CLKTMR * MSEC)/(16*1000L));
  //  tc = 0;
  #else
    #error time constant overflow
  #endif

  #if (INTVSZ!=0)
    def_int(INT_SYSTEM_TIMER, &dint_inthdr);
  #endif

    sfr_outl(TMEN, 0);
    sfr_outl(TMRLR, tc);
    sfr_outl(ILC0, (sfr_inl(ILC0) & 0xfffffff0) | IP);
    sfr_outl(TMEN, TMEN_TCEN);

    return E_OK;
}

/*****************************************************************************
* Interval Timer Handler
*
******************************************************************************/

static void inthdr_body(void)
{
    sig_tim();                          /* sysclock routine */

    sfr_outl(TMOVF, 0x0001);
}

INTHDR inthdr(void)
{
    ent_int();                      /* Start intrrupt handler */
    inthdr_body();                  /* handler funciton */
    ret_int();                      /* End interrupt */
}

/* EOF */