ASM = asm38
LINK = optlnk
-CFLAGS = -CP=300HA -DEBug -I=$(INC_DIR),$(SRC_DIR)
-AFLAGS = -CP=300HA -DEBug
+CFLAGS = -CP=300HA -DEBug -NOLOGO -I=$(INC_DIR),$(SRC_DIR)
+AFLAGS = -CP=300HA -DEBug -NOLOGO
LFLAGS =
OBJS_DIR = objs
int AutoId(void);
void WriteCfgDef(FILE* fp); // cfgファイル定義部書き出し
void WriteCfgIni(FILE* fp); // cfgファイル初期化部書き出し
+
+protected:
+ int m_iMinIntNo;
+ int m_iMaxIntNo;
};
// パラメーター構文設定
m_iParamSyntax[0] = 4; // 4つのパラメーターブロック
m_iParams = 1;
+
+ m_iMinIntNo = 0;
+ m_iMaxIntNo = -1;
}
// デストラクタ
// 自動ID番号割り当て
int CApiAttIsr::AutoId(void)
{
+ if ( m_iMaxIntNo == -1 )
+ {
+ m_iMinIntNo = _KERNEL_IRCATR_TMIN_INTNO;
+ m_iMaxIntNo = _KERNEL_IRCATR_TMAX_INTNO;
+ }
+
return CFG_ERR_OK;
}
return CFG_ERR_OK;
}
+ else if ( strcmp(pszApiName, "KERNEL_MIN_INTNO") == 0 )
+ {
+ m_iMinIntNo = atoi(pszParams);
+ return CFG_ERR_OK;
+ }
+ else if ( strcmp(pszApiName, "KERNEL_MAX_INTNO") == 0 )
+ {
+ m_iMaxIntNo = atoi(pszParams);
+ return CFG_ERR_OK;
+ }
return CFG_ERR_NOPROC;
}
"/* interrupt control objects */\n"
"/* ------------------------------------------ */\n"
, fp);
+
+ fprintf(
+ fp,
+ "\n"
+ "const INTNO _kernel_min_intno = %d;\n"
+ "const INTNO _kernel_max_intno = %d;\n",
+ m_iMinIntNo, m_iMaxIntNo);
// 割込み管理テーブル生成
- if ( _KERNEL_IRCATR_TMAX_INHNO - _KERNEL_IRCATR_TMIN_INHNO + 1 > 0 )
+ if ( m_iMaxIntNo - m_iMinIntNo + 1 > 0 )
{
fprintf(
fp,
"\n"
"_KERNEL_T_INTINF _kernel_int_tbl[%d];\n\n",
- _KERNEL_IRCATR_TMAX_INHNO - _KERNEL_IRCATR_TMIN_INHNO + 1);
+ m_iMaxIntNo - m_iMinIntNo + 1);
}
if ( m_iMaxId > 0 )
// ---------------------------------------------------------------------------
-// Copyright (C) 1998-2002 by Project HOS
+// Copyright (C) 1998-2006 by Project HOS
// ---------------------------------------------------------------------------
#endif
"_KERNEL_T_INHINF _kernel_inh_tbl[%d] =\n"
"\t{\n",
- KERNEL_TMAX_INH_INHNO - KERNEL_TMIN_INH_INHNO + 1);
+ _KERNEL_TMAX_INH_INHNO - _KERNEL_TMIN_INH_INHNO + 1);
- for ( i = KERNEL_TMIN_INH_INHNO; i <= KERNEL_TMAX_INH_INHNO; i++ )
+ for ( i = _KERNEL_TMIN_INH_INHNO; i <= _KERNEL_TMAX_INH_INHNO; i++ )
{
for ( j = 0; j < m_iObjs; j++ )
{
{
fprintf(fp, "\t\t{(FP)(%s)},\n", m_pParamPacks[j]->GetParam(DEFINH_INTHDR));
}
-#if _KERNEL_SPT_ISR
- else if ( i >= _KERNEL_IRCATR_TMIN_INHNO && i <= _KERNEL_IRCATR_TMAX_INHNO )
- {
- fprintf(fp, "\t\t{(FP)_KERNEL_EXE_IRC},\n");
- }
-#endif
else
{
fprintf(fp, "\t\t{(FP)NULL},\n");
# オプションフラグ
-AFLAGS += -CP=300HA:24 -DEBug
-CFLAGS += -CP=300HA:24 -DEBug -I=$(INC_KNL_DIR) -I=$(INC_PROC_DIR) -I=$(INC_IRC_DIR)
+AFLAGS += -CP=300HA:24 -DEBug -NOLOGO
+CFLAGS += -CP=300HA:24 -DEBug -NOLOGO -I=$(INC_KNL_DIR) -I=$(INC_PROC_DIR) -I=$(INC_IRC_DIR)
LFLAGS += -FOrm=Library
LINTFLAGS += -weak -I$(INC_KNL_DIR) -I$(INC_PROC_DIR) -I$(INC_IRC_DIR)
#define _KERNEL_IRCATR_INC_PATH "arm/ADuC7019"
-#define _KERNEL_IRCATR_TMIN_INHNO 1 /**< %jp{割込みハンドラ番号の最小値} */
-#define _KERNEL_IRCATR_TMAX_INHNO 23 /**< %jp{割込みハンドラ番号の最大値} */
+#define _KERNEL_IRCATR_TMIN_INTNO 1 /**< %jp{割込み番号の最小値} */
+#define _KERNEL_IRCATR_TMAX_INTNO 23 /**< %jp{割込み番号の最大値} */
#endif /* _KERNEL__arch__irc__ADuC7019__ircatr_h__ */
#define _KERNEL_INI_IRC() do {} while (0) /**< %jp{IRCの初期化ハンドラ} */
+#define _KERNEL_EXE_IRC() do {} while (0) /**< %jp{IRCの処理ハンドラ} */
#endif /* _KERNEL__arch__irc_none_h__ */
#define _KERNEL_IRCATR_IRC FALSE /**< %jp{IRCの有無} */
-#define _KERNEL_IRCATR_TMIN_INHNO 0 /**< %jp{割込みハンドラ番号の最小値} */
-#define _KERNEL_IRCATR_TMAX_INHNO 0 /**< %jp{割込みハンドラ番号の最大値} */
+#define _KERNEL_IRCATR_TMIN_INTNO 0 /**< %jp{割込みハンドラ番号の最小値} */
+#define _KERNEL_IRCATR_TMAX_INTNO 0 /**< %jp{割込みハンドラ番号の最大値} */
#endif /* _KERNEL__arch__none__ircatr_h__ */
#define _KERNEL__arch__irc_none_h__
-#define _KERNEL_INI_IRC() do {} while (0) /**< %jp{IRCの初期化ハンドラ} */
-#define _KERNEL_EXE_IRC _kernel_exe_isr /**< %jp{IRCの処理ルーチン} */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void _kernel_exe_isr(INTNO intno);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#define _KERNEL_INI_IRC() do {} while (0) /**< %jp{IRCの初期化ハンドラ} */
+#define _KERNEL_EXE_IRC(inhno) _kernel_exe_isr((INTNO)(inhno)) /**< %jp{IRCの処理ルーチン} */
#endif /* _KERNEL__arch__irc_none_h__ */
#define _KERNEL_IRCATR_IRC TRUE /**< %jp{IRCの有無} */
-#define _KERNEL_IRCATR_TMIN_INHNO _KERNEL_PROCATR_TMIN_INHNO /**< %jp{割込みハンドラ番号の最小値} */
-#define _KERNEL_IRCATR_TMAX_INHNO _KERNEL_PROCATR_TMAX_INHNO /**< %jp{割込みハンドラ番号の最大値} */
+#define _KERNEL_IRCATR_TMIN_INTNO _KERNEL_PROCATR_TMIN_INHNO /**< %jp{割込みハンドラ番号の最小値} */
+#define _KERNEL_IRCATR_TMAX_INTNO _KERNEL_PROCATR_TMAX_INHNO /**< %jp{割込みハンドラ番号の最大値} */
#endif /* _KERNEL__arch__simple__ircatr_h__ */
*/
-#ifndef _KERNEL__arch__proc__arm__arm_v4__proc_h__
-#define _KERNEL__arch__proc__arm__arm_v4__proc_h__
+#ifndef _KERNEL__arch__proc__mn1030__proc_h__
+#define _KERNEL__arch__proc__mn1030__proc_h__
extern "C" {
#endif
-void _kernel_ini_arc(void); /**< %jp{アーキテクチャ固有の初期化} */
+void _kernel_ini_prc(void); /**< %jp{プロセッサ固有の初期化} */
void _kernel_ena_int(void); /**< %jp{割り込み許可} */
void _kernel_dis_int(void); /**< %jp{割り込み禁止} */
void _kernel_wai_int(void); /**< %jp{割り込み待ち(アイドル時の処理)} */
-void _kernel_cre_ctx(_KERNEL_T_CTXCB *pk_ctxcb, VP isp, FP entry, VP_INT par1, VP_INT par2); /**< %jp{実行コンテキストの作成} */
+void _kernel_cre_ctx(UW par1, UW par2, _KERNEL_T_CTXCB *pk_ctxcb, VP isp, FP entry); /**< %jp{実行コンテキストの作成} */
void _kernel_del_ctx(_KERNEL_T_CTXCB *pk_ctxcb); /**< %jp{実行コンテキストの削除} */
-void _kernel_rst_ctx(VP_INT par1, VP_INT par2, FP entry, VP isp); /**< %jp{実行コンテキストのリスタート} */
+void _kernel_rst_ctx(UW par1, UW par2, FP entry, VP isp); /**< %jp{実行コンテキストのリスタート} */
void _kernel_sta_ctx(_KERNEL_T_CTXCB *pk_ctxcb); /**< %jp{実行コンテキストの開始} */
void _kernel_swi_ctx(_KERNEL_T_CTXCB *pk_ctxinf_nxt, _KERNEL_T_CTXCB *pk_ctxcb_now); /**< %jp{実行コンテキストの切替} */
#endif
-#define _KERNEL_INI_PRC() do {} while (0)
+#define _KERNEL_INI_PRC() _kernel_ini_prc() /**< %jp{プロセッサ固有の初期化} */
#define _KERNEL_ENA_INT() _kernel_ena_int() /**< %jp{割り込み許可} */
#define _KERNEL_DIS_INT() _kernel_dis_int() /**< %jp{割り込み禁止} */
#define _KERNEL_WAI_INT() _kernel_wai_int() /**< %jp{割り込み待ち(アイドル時の処理)} */
-#define _KERNEL_CRE_CTX(pk_ctxcb, stksz, stk, isp, entry, exinf1, exinf2) \
- _kernel_cre_ctx((pk_ctxcb), (isp), (entry), (exinf1), (exinf2))
+#define _KERNEL_CRE_CTX(pk_ctxcb, stksz, stk, isp, entry, par1, par2) \
+ _kernel_cre_ctx((UW)(par1), (UW)(par2), (pk_ctxcb), (isp), (entry))
#define _KERNEL_DEL_CTX(pk_ctxcb) _kernel_del_ctx(pk_ctxcb)
#define _KERNEL_RST_CTX(pk_ctxcb, stksz, stk, isp, entry, exinf1, exinf2) \
_kernel_rst_ctx((exinf1), (exinf2), (entry), (isp))
*/
-#ifndef _KERNEL__arch__proc__arm__arm_v4t__procatr_h__
-#define _KERNEL__arch__proc__arm__arm_v4t__procatr_h__
+#ifndef _KERNEL__arch__proc__mn1030__procatr_h__
+#define _KERNEL__arch__proc__mn1030__procatr_h__
/* %jp{プロセッサアーキテクチャ定義のあるインクルードパス} */
-#define _KERNEL_PROCATR_INC_PATH "arm/arm_v4t"
+#define _KERNEL_PROCATR_INC_PATH "mn103/mn1030"
/* %jp{プロセッサアーキテクチャに依存した属性} */
-#endif /* _KERNEL__arch__proc__arm__arm_v4t__procatr_h__ */
+#endif /* _KERNEL__arch__proc__mn1030__procatr_h__ */
/* end of file */
/* Control block */
#define _KERNEL_CFG_MPFCB_ALGORITHM _KERNEL_MPFCB_ALG_BLKARRAY
-#define _KERNEL_CFG_MPFCB_SPLIT_RO FALSE /**< %jp{TCBの不変部を分割してROM部配置とするか} */
+#define _KERNEL_CFG_MPFCB_SPLIT_RO FALSE /**< %jp{MPFCBの不変部を分割してROM部配置とするか} */
#define _KERNEL_CFG_MPFCB_BITFIELD FALSE /**< %jp{ビットフィールドを利用してTCBを圧縮するか} */
+/* ---------------------------------------------- */
+/* Interrupt Service Routines */
+/* ---------------------------------------------- */
+
+/* Control block */
+#define _KERNEL_CFG_ISRCB_ALGORITHM _KERNEL_ISRCB_ALG_PTRARRAY
+#define _KERNEL_CFG_ISRCB_SPLIT_RO FALSE /**< %jp{ISRCBの不変部を分割してROM部配置とするか} */
+#define _KERNEL_CFG_ISRCB_BITFIELD FALSE /**< %jp{ビットフィールドを利用してTCBを圧縮するか} */
+
+
+
+
/* ------------------------------------------------------------------ */
/* System Time Management */
/* ------------------------------------------------------------------ */
} _KERNEL_T_DPCCB;
-#define _KERNEL_DPC_SET_MSGQ(dcpcb, x) do { (dcpcb)->msgq = (x); } while (0)
-#define _KERNEL_DPC_GET_MSGQ(dcpcb) ((dcpcb)->msgq)
-#define _KERNEL_DPC_SET_MSGQSZ(dcpcb, x) do { (dcpcb)->msgqsz = (x); } while (0)
-#define _KERNEL_DPC_GET_MSGQSZ(dcpcb) ((dcpcb)->msgqsz)
-#define _KERNEL_DPC_SET_HEAD(dcpcb, x) do { (dcpcb)->msgqsz = (x); } while (0)
-#define _KERNEL_DPC_GET_HEAD(dcpcb) ((dcpcb)->msgqsz)
-#define _KERNEL_DPC_SET_TAIL(dcpcb, x) do { (dcpcb)->msgqsz = (x); } while (0)
-#define _KERNEL_DPC_GET_HEAD(dcpcb) ((dcpcb)->msgqsz)
-
-
#ifdef __cplusplus
extern "C" {
#endif
#endif
+
+/* ---------------------------------- */
+/* Isr-Handle */
+/* ---------------------------------- */
+
+struct _kernel_t_isrcb;
+typedef struct _kernel_t_isrcb *_KERNEL_T_ISRHDL;
+#define _KERNEL_ISRHDL_NULL 0
+
+
+
#endif /* _KERNEL__core__objhdl_h__ */
#define _KERNEL__object__inhobj_h__
-
/* %jp{割込みハンドラ情報} */
typedef struct _kernel_t_inhinf
{
/** %jp{割込みハンドラ情報テーブル} */
#if _KERNEL_SPT_DEF_INH
-extern _KERNEL_T_INHINF _kernel_inh_tbl[KERNEL_TMAX_INH_INHNO - KERNEL_TMIN_INH_INHNO + 1];
+extern _KERNEL_T_INHINF _kernel_inh_tbl[_KERNEL_TMAX_INH_INHNO - _KERNEL_TMIN_INH_INHNO + 1];
#else
-extern const _KERNEL_T_INHINF _kernel_inh_tbl[KERNEL_TMAX_INH_INHNO - KERNEL_TMIN_INH_INHNO + 1];
+extern const _KERNEL_T_INHINF _kernel_inh_tbl[_KERNEL_TMAX_INH_INHNO - _KERNEL_TMIN_INH_INHNO + 1];
#endif
-#define _KERNEL_INT_GET_INHINF(inhno) (&_kernel_inh_tbl[inhno - KERNEL_TMIN_INH_INHNO])
+#define _KERNEL_INT_GET_INHINF(inhno) (&_kernel_inh_tbl[inhno - _KERNEL_TMIN_INH_INHNO])
#define _KERNEL_INH_GET_INTHDR(inhno) (_KERNEL_INT_GET_INHINF(inhno)->inthdr);
#define _KERNEL_INH_SET_INTHDR(inhno, x) do { _KERNEL_INT_GET_INHINF(inhno)->inthdr = (x); } while(0)
#define _KERNEL__object__isrobj_h__
-typedef struct _kernel_t_isrcb* _KERNEL_T_ISRHDL;
+/* ------------------------------------------ */
+/* Interrupt manegement */
+/* ------------------------------------------ */
+
+struct _kernel_t_isrcb;
/* %jp{割込み情報} */
typedef struct _kernel_t_intinf
{
- _KERNEL_T_ISRHDL head;
+ _KERNEL_T_ISRHDL head;
} _KERNEL_T_INTINF;
-
/** %jp{割込み情報テーブル} */
#if _KERNEL_SPT_CRE_ISR || _KERNEL_SPT_ACRE_ISR
-extern _KERNEL_T_INTINF _kernel_int_tbl[_KERNEL_IRCATR_TMAX_INHNO - _KERNEL_IRCATR_TMIN_INHNO + 1];
+extern _KERNEL_T_INTINF _kernel_int_tbl[];
#else
-extern const _KERNEL_T_INTINF _kernel_int_tbl[_KERNEL_IRCATR_TMAX_INHNO - _KERNEL_IRCATR_TMIN_INHNO + 1];
+extern const _KERNEL_T_INTINF _kernel_int_tbl[];
#endif
-#define _KERNEL_INT_GET_INTINF(intno) (&_kernel_int_tbl[intno - _KERNEL_IRCATR_TMIN_INHNO])
+extern const INTNO _kernel_min_intno; /**< %jp{割り込み番号の最小値} */
+extern const INTNO _kernel_max_intno; /**< %jp{割り込み番号の最大値} */
+
+#define _KERNEL_INT_TMIN_INTNO (_kernel_min_intno)
+#define _KERNEL_INT_TMAX_INTNO (_kernel_max_intno)
+
+#define _KERNEL_INT_GET_INTINF(intno) (&_kernel_int_tbl[(intno) - _KERNEL_INT_TMIN_INTNO])
+#define _KERNEL_INT_GET_HEAD(intno) (_KERNEL_INT_GET_INTINF(intno)->head)
+#define _KERNEL_INT_SET_HEAD(intno, x) do { _KERNEL_INT_GET_INTINF(intno)->head = (x); } while (0)
+
+
+
+/* ------------------------------------------ */
+/* Primitive type definition */
+/* ------------------------------------------ */
+
+/* %jp{ISRのハンドルの型} */
+typedef _KERNEL_T_ISRHDL _KERNEL_ISR_T_ISRHDL;
+typedef _KERNEL_T_ISRHDL _KERNEL_ISRCB_T_ISRHDL;
+#define _KERNEL_ISRCB_TBITDEF_ISRHDL
+
+/* %jp{拡張情報の型} */
+typedef VP_INT _KERNEL_ISR_T_EXINF;
+typedef VP_INT _KERNEL_ISRCB_T_EXINF;
+#define _KERNEL_ISRCB_TBITDEF_EXINF
+
+/* %jp{割り込みサービスルーチンの開始番地の型} */
+typedef void (*_KERNEL_ISR_T_ISR)(VP_INT exinf);
+typedef void (*_KERNEL_ISRCB_T_ISR)(VP_INT exinf);
+#define _KERNEL_ISRCB_TBITDEF_ISR
+
+
+/* ------------------------------------------ */
+/* Control block */
+/* ------------------------------------------ */
+
+#if _KERNEL_ISRCB_SPLIT_RO
+
-#define _KERNEL_INT_GET_HEAD(intno) (_KERNEL_INT_GET_INTINF(intno)->head)
-#define _KERNEL_INT_SET_HEAD(intno, x) do { _KERNEL_INT_GET_INTINF(intno)->head = (x); } while (0)
+/* %jp{割込みサービスルーチンコントロールブロック(リードオンリー部)} */
+typedef struct _kernel_t_isrcb_ro
+{
+ _KERNEL_ISRCB_T_EXINF exinf _KERNEL_ISRCB_TBITDEF_EXINF; /**< %jp{割込みサービスルーチンの拡張情報} */
+ _KERNEL_ISRCB_T_ISR isr _KERNEL_ISRCB_TBITDEF_ISR; /**< %jp{割込みサービスルーチンの起動番地} */
+} _KERNEL_T_ISRCB_RO;
+typedef const _KERNEL_T_ISRCB_RO *_KERNEL_T_ISRCB_RO_PTR;
-/* %jp{割込みサービスルーチン制御ブロック} */
+/* %jp{割込みサービスルーチンコントロールブロック} */
typedef struct _kernel_t_isrcb
{
- VP_INT exinf; /**< %jp{割込みサービスルーチンの拡張情報} */
- FP isr; /**< %jp{割込みサービスルーチンの起動番地} */
- _KERNEL_T_ISRHDL next;
+ _KERNEL_ISRCB_T_ISRHDL next _KERNEL_ISRCB_TBITDEF_ISRHDL;
+
+#if _KERNEL_ISRCB_ALGORITHM == _KERNEL_ISRCB_ALG_PTRARRAY
+ _KERNEL_T_ISRCB_RO_PTR isrcb_ro; /**< %jp{割込みサービスルーチンコントロールブロックRO部へのポインタ} */
+#endif
} _KERNEL_T_ISRCB;
+typedef _KERNEL_T_ISRCB *_KERNEL_T_ISRCB_PTR;
-/* 割り込みサービスルーチン */
-extern _KERNEL_T_ISRCB *_kernel_isrcb_tbl[]; /* 割込みサービスルーチンコントロールブロックテーブル */
-extern const ID _kernel_max_isrid; /* 割込みサービスルーチンコントロールブロックの個数 */
+#else
-#define _KERNEL_TMIN_ISR_ISRID 1
-#define _KERNEL_TMAX_ISR_ISRID (_kernel_max_isrid)
+/* %jp{割込みサービスルーチンコントロールブロック} */
+typedef struct _kernel_t_isrcb
+{
+ _KERNEL_ISRCB_T_ISRHDL next _KERNEL_ISRCB_TBITDEF_ISRHDL; /**< %jp{次の割込みサービスルーチンコントロールブロックへのリンク */
+ _KERNEL_ISRCB_T_EXINF exinf _KERNEL_ISRCB_TBITDEF_EXINF; /**< %jp{割込みサービスルーチンの拡張情報} */
+ _KERNEL_ISRCB_T_ISR isr _KERNEL_ISRCB_TBITDEF_ISR; /**< %jp{割込みサービスルーチンの起動番地} */
+} _KERNEL_T_ISRCB;
+typedef _KERNEL_T_ISRCB _KERNEL_T_ISRCB_RO;
+typedef const _KERNEL_T_ISRCB_RO *_KERNEL_T_ISRCB_RO_PTR;
+typedef _KERNEL_T_ISRCB *_KERNEL_T_ISRCB_PTR;
-#define _KERNEL_ISR_ID2ISRCB(isrid) (_kernel_isrcb_tbl[(isrid) - _KERNEL_TMIN_ISR_ISRID])
-#define _KERNEL_ISR_ID2ISRHDL(isrid) (_kernel_isrcb_tbl[(isrid) - _KERNEL_TMIN_ISR_ISRID])
-#define _KERNEL_ISR_ISRPTR2ISRCB(isrhdl) (isrhdl)
-#define _KERNEL_ISR_CHECK_EXS(isrid) (_kernel_isrcb_tbl[(isrid) - _KERNEL_TMIN_ISR_ISRID] != NULL)
+#endif
-#define _KERNEL_ISR_GET_EXINF(isrhdl) (_KERNEL_ISR_ISRPTR2ISRCB(isrhdl)->exinf)
-#define _KERNEL_ISR_SET_EXINF(isrhdl, x) do { (_KERNEL_ISR_ISRPTR2ISRCB(isrhdl)->exinf) = (x); } while (0)
-#define _KERNEL_ISR_GET_ISR(isrhdl) (_KERNEL_ISR_ISRPTR2ISRCB(isrhdl)->isr)
-#define _KERNEL_ISR_SET_ISR(isrhdl, x) do { (_KERNEL_ISR_ISRPTR2ISRCB(isrhdl)->isr) = (x); } while (0)
+/* ------------------------------------------ */
+/* ID range */
+/* ------------------------------------------ */
-#define _KERNEL_ISR_GET_NEXT(isrhdl) (_KERNEL_ISR_ISRPTR2ISRCB(isrhdl)->next)
-#define _KERNEL_ISR_SET_NEXT(isrhdl, x) do { (_KERNEL_ISR_ISRPTR2ISRCB(isrhdl)->next) = (x); } while (0)
+extern const ID _kernel_max_isrid; /* %jp{割込みサービスルーチンIDの最大値} */
+#define _KERNEL_ISR_TMIN_ID (1) /**< %jp{割込みサービスルーチンIDの最小値} */
+#define _KERNEL_ISR_TMAX_ID (_kernel_max_isrid) /**< %jp{割込みサービスルーチンIDの最大値} */
+#define _KERNEL_ISR_CHECK_ISRID(isrid) ((isrid) >= _KERNEL_ISR_TMIN_ID && (isrid) <= _KERNEL_ISR_TMAX_ID)
+ /**< %jp{ID範囲チェック} */
/* ------------------------------------------ */
-/* 関数宣言 */
+/* Control block tables */
/* ------------------------------------------ */
+#if _KERNEL_ISRCB_ALGORITHM == _KERNEL_ISRCB_ALG_BLKARRAY
+#if _KERNEL_ISRCB_SPLIT_RO
+
+/* %jp{ブロック配列管理でRO分離の場合}%en{block array} */
+extern _KERNEL_T_ISRCB _kernel_isrcb_tbl[]; /**< %jp{割り込みサービスルーチンコントロールブロックテーブル} */
+extern const _KERNEL_T_ISRCB_RO _kernel_isrcb_ro_tbl[]; /**< %jp{割り込みサービスルーチンコントロールブロック(リードオンリー部)テーブル} */
+#define _KERNEL_ISR_ID2ISRCB(isrid) (&_kernel_isrcb_tbl[(isrid) - _KERNEL_ISR_TMIN_ID]) /**< %jp{コントロールブロックの取得} */
+#define _KERNEL_ISR_CHECK_EXS(isrid) (_kernel_isrcb_ro_tbl[(isrid) - _KERNEL_ISR_TMIN_ID].isr != NULL)
+ /**< %jp{オブジェクトの存在チェック} */
+
+#else
+
+/* %jp{ブロック配列管理の場合}%en{block array} */
+extern _KERNEL_T_ISRCB _kernel_isrcb_tbl[]; /**< %jp{割り込みサービスルーチンコントロールブロックテーブル} */
+#define _KERNEL_ISR_ID2ISRCB(isrid) (&_kernel_isrcb_tbl[(isrid) - _KERNEL_ISR_TMIN_ID]) /**< %jp{コントロールブロックの取得} */
+#define _KERNEL_ISR_CHECK_EXS(isrid) (_kernel_isrcb_tbl[(isrid) - _KERNEL_ISR_TMIN_ID].isr != NULL)
+ /**< %jp{オブジェクトの存在チェック} */
+
+#endif
+
+#elif _KERNEL_ISRCB_ALGORITHM == _KERNEL_ISRCB_ALG_PTRARRAY
+
+/* %jp{ポインタ配列管理の場合}%en{pointer array} */
+extern _KERNEL_T_ISRCB *_kernel_isrcb_tbl[]; /**< %jp{割り込みサービスルーチンコントロールブロックテーブル} */
+#define _KERNEL_ISR_ID2ISRCB(isrid) (_kernel_isrcb_tbl[(isrid) - _KERNEL_ISR_TMIN_ID]) /**< %jp{割り込みサービスルーチンIDからISRCB アドレスを取得} */
+#define _KERNEL_ISR_CHECK_EXS(isrid) (_KERNEL_ISR_ID2ISRCB(isrid) != NULL) /**< %jp{オブジェクトの存在チェック} */
+
+#endif
+
+
+
+/* ------------------------------------------ */
+/* Convert Handle */
+/* ------------------------------------------ */
+
+#if _KERNEL_ISRHDL_ID /* %en{ISRHDL is ID}%jp{タスクポインタにIDを使う} */
+
+#define _KERNEL_ISR_ID2ISRHDL(isrid) (isrid)
+#define _KERNEL_ISR_ISRHDL2ID(isrhdl) (isrhdl)
+#define _KERNEL_ISR_ISRCB2ISRHDL(isrcb) _KERNEL_ISR_ISRCB2ID(isrcb)
+#define _KERNEL_ISR_ISRHDL2ISRCB(isrhdl) _KERNEL_ISR_ID2ISRCB(isrhdl)
+#define _KERNEL_ISR_GET_ISRHDL(isrid, isrcb) (isrid)
+
+#else /* %en{ISRHDL is address of ISRCB}%jp{タスクポインタにISRCBのアドレスを使う} */
+
+#define _KERNEL_ISR_ID2ISRHDL(isrid) _KERNEL_ISR_ID2ISRCB(isrid)
+#define _KERNEL_ISR_ISRHDL2ID(isrhdl) _KERNEL_ISR_ISRCB2ID(isrhdl)
+#define _KERNEL_ISR_ISRCB2ISRHDL(isrhcb) (isrhcb)
+#define _KERNEL_ISR_ISRHDL2ISRCB(isrhdl) (isrhdl)
+#define _KERNEL_ISR_GET_ISRHDL(isrid, isrcb) (isrcb)
+
+#endif
+
+
+
+/* ------------------------------------------ */
+/* Accessor for ISRCB */
+/* ------------------------------------------ */
+
+/* isrcb_ro */
+#if !_KERNEL_ISRCB_SPLIT_RO
+#define _KERNEL_ISR_GET_ISRCB_RO(isrid, isrcb) (isrcb)
+#else
+#if _KERNEL_ISRCB_ALGORITHM == _KERNEL_ISRCB_ALG_BLKARRAY /* %jp{ISRCBを単純配列で管理}%en{array of block} */
+#define _KERNEL_ISR_GET_ISRCB_RO(isrid, isrcb) (&_kernel_isrcb_ro_tbl[(isrid)])
+#elif _KERNEL_ISRCB_ALGORITHM == _KERNEL_ISRCB_ALG_PTRARRAY /* %jp{ISRCBをポインタ配列で管理}%en{array of pointer} */
+#define _KERNEL_ISR_GET_ISRCB_RO(isrid, isrcb) ((isrcb)->isrcb_ro)
+#endif
+#endif
+
+#define _KERNEL_ISR_ISRHDL2ISRCBRO(isrhdl) _KERNEL_ISR_GET_ISRCB_RO(_KERNEL_ISR_ISRHDL2ID(isrhdl), _KERNEL_ISR_ISRHDL2ISRCB(isrhdl))
+
+
+#define _KERNEL_ISR_SET_NEXT(isrcb, x) do { (isrcb)->next = (_KERNEL_ISRCB_T_ISRHDL)(x); } while (0)
+#define _KERNEL_ISR_GET_NEXT(isrcb) ((_KERNEL_ISR_T_ISRHDL)(isrcb)->next)
+
+
+#define _KERNEL_ISR_SET_EXINF(isrcb_ro, x) do { (isrcb_ro)->exinf = (_KERNEL_ISRCB_T_EXINF)(x); } while (0)
+#define _KERNEL_ISR_GET_EXINF(isrcb_ro) ((_KERNEL_ISR_T_EXINF)(isrcb_ro)->exinf)
+
+#define _KERNEL_ISR_SET_ISR(isrcb_ro, x) do { (isrcb_ro)->isr = (_KERNEL_ISRCB_T_ISR)(x); } while (0)
+#define _KERNEL_ISR_GET_ISR(isrcb_ro) ((_KERNEL_ISRCB_T_ISR)(isrcb_ro)->isr)
+
+
+
+/* ------------------------------------------ */
+/* Functions */
+/* ------------------------------------------ */
#ifdef __cplusplus
extern "C" {
/* %jp{ポインタ配列管理の場合}%en{pointer array} */
extern _KERNEL_T_SEMCB *_kernel_semcb_tbl[]; /**< %jp{セマフォコントロールブロックテーブル} */
-#define _KERNEL_SEM_ID2SEMCB(semid) (_kernel_semcb_tbl[(semid) - _KERNEL_TMIN_SEMID]) /**< %jp{セマフォIDからSEMCB アドレスを取得} */
+#define _KERNEL_SEM_ID2SEMCB(semid) (_kernel_semcb_tbl[(semid) - _KERNEL_SEM_TMIN_ID]) /**< %jp{セマフォIDからSEMCB アドレスを取得} */
#define _KERNEL_SEM_CHECK_EXS(semid) (_KERNEL_SEM_ID2SEMCB(semid) != NULL) /**< %jp{オブジェクトの存在チェック} */
#endif
-
/* ------------------------------------------ */
/* Convert Handle */
/* ------------------------------------------ */
#endif
+
/* ------------------------------------------ */
/* Accessor for TCB */
/* ------------------------------------------ */
#define _KERNEL_SPT_ALM FALSE
#define _KERNEL_SPT_OVR FALSE
+/* %jp{割込みハンドラサポートの判定} */
+#if _KERNEL_SPT_DEF_INH || _KERNEL_SPT_SDEF_INH
+#define _KERNEL_SPT_INH TRUE
+#else
+#define _KERNEL_SPT_INH FALSE
+#endif
/* %jp{割込みサービスルーチンサポートの判定} */
#if _KERNEL_IRCATR_IRC && (_KERNEL_SPT_CRE_ISR || _KERNEL_SPT_SCRE_ISR) && (_KERNEL_CFG_TMAX_ISRID) > 0
/* inh */
/* ------------------------------------------------------------------ */
-#define KERNEL_TMIN_INH_INHNO _KERNEL_PROCATR_TMIN_INHNO
-#define KERNEL_TMAX_INH_INHNO _KERNEL_PROCATR_TMAX_INHNO
+#define _KERNEL_TMIN_INH_INHNO _KERNEL_PROCATR_TMIN_INHNO
+#define _KERNEL_TMAX_INH_INHNO _KERNEL_PROCATR_TMAX_INHNO
+#if 0
#define KERNEL_TMIN_ISR_INTNO _KERNEL_IRCATR_TMIN_INHNO
#define KERNEL_TMAX_ISR_INTNO _KERNEL_IRCATR_TMAX_INHNO
+#endif
+
+
+
+/* ---------------------------------------------- */
+/* Interrupt Service Routines */
+/* ---------------------------------------------- */
+
+#define _KERNEL_ISRCB_ALG_BLKARRAY 1
+#define _KERNEL_ISRCB_ALG_PTRARRAY 2
+
+/* Control block */
+#define _KERNEL_ISRCB_ALGORITHM _KERNEL_CFG_ISRCB_ALGORITHM
+#define _KERNEL_ISRCB_BITFIELD _KERNEL_CFG_ISRCB_BITFIELD
+
+/* %jp{ブロック配列で動的生成がある場合はRO分離は不可} */
+#if (_KERNEL_ISRCB_ALGORITHM == _KERNEL_ISRCB_ALG_BLKARRAY) && (_KERNEL_SPT_CRE_ISR || _KERNEL_SPT_ACRE_ISR)
+#define _KERNEL_ISRCB_SPLIT_RO FALSE
+#else
+#define _KERNEL_ISRCB_SPLIT_RO _KERNEL_CFG_MBXCB_SPLIT_RO
+#endif
+#define _KERNEL_ISRCB_NEXT TRUE
+#define _KERNEL_ISRCB_EXINF TRUE
+#define _KERNEL_ISRCB_ISR TRUE
#endif /* _KERNEL__parser__parsknl_h__ */
+/**
+ * Hyper Operating System V4 Advance
+ *
+ * @file rcv_adtq.c
+ * @brief %jp{非同期データキュー受信}%en{Receive from Asynchronous Data Queue}
+ *
+ * Copyright (C) 1998-2006 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
#include "core/core.h"
#include "core/adtq.h"
/* %jp{データ取り出し} */
adtq = _KERNEL_ADTQ_GET_ADTQ(adtqcb);
- *p_data = adtq[tail];
+ *p_data = adtq[head];
/* %jp{次の末尾位置計算} */
- head++;
- if ( head >= _KERNEL_ADTQ_GET_ADTQCNT(adtqcb) )
+ if ( head < _KERNEL_ADTQ_GET_ADTQCNT(adtqcb) - 1 )
+ {
+ head++;
+ }
+ else
{
head = 0;
}
_KERNEL_ADTQ_SET_HEAD(adtqcb, head);
}
+
+/* end of file */
+/**
+ * Hyper Operating System V4 Advance
+ *
+ * @file rcv_adtq.c
+ * @brief %jp{非同期データキュー 送信可能データ個数参照}
+ *
+ * Copyright (C) 1998-2006 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
#include "core/core.h"
#include "core/adtq.h"
}
+/* end of file */
+
+/**
+ * Hyper Operating System V4 Advance
+ *
+ * @file rcv_adtq.c
+ * @brief %jp{非同期データキュー 送信済みデータ個数参照}
+ *
+ * Copyright (C) 1998-2006 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
#include "core/core.h"
#include "core/adtq.h"
}
}
+
+/* end of file */
+/**
+ * Hyper Operating System V4 Advance
+ *
+ * @file rcv_adtq.c
+ * @brief %jp{非同期データキュー送信}%en{Send to Asynchronous Data Queue}
+ *
+ * Copyright (C) 1998-2006 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
#include "core/core.h"
#include "core/adtq.h"
}
+/* end of file */
+
#include "object/inhobj.h"
-
/* %jp{割り込みハンドラの処理} */
void _kernel_exe_inh(INHNO inhno)
{
- const _KERNEL_T_INHINF *pk_inhinf;
+ _KERNEL_ENA_INT(); /* %jp{多重割込み許可} */
+
+ /* %jp{割り込みハンドラの処理} */
+#if _KERNEL_SPT_INH
+ {
+ const _KERNEL_T_INHINF *pk_inhinf;
- pk_inhinf = _KERNEL_INT_GET_INHINF(inhno);
+ pk_inhinf = _KERNEL_INT_GET_INHINF(inhno);
- if ( pk_inhinf->inthdr != NULL )
- {
- _KERNEL_ENA_INT(); /* %jp{多重割込み許可} */
- pk_inhinf->inthdr(inhno); /* %jp{割込みハンドラの処理} */
- _KERNEL_DIS_INT(); /* %jp{割込み禁止} */
+ if ( pk_inhinf->inthdr != NULL )
+ {
+ pk_inhinf->inthdr(inhno); /* %jp{割込みハンドラの処理} */
+ }
}
-}
+#endif
+
+ /* %jp{割り込みコントローラの処理} */
+#if _KERNEL_SPT_ISR
+ _KERNEL_EXE_IRC(inhno);
+#endif
+ _KERNEL_DIS_INT(); /* %jp{割込み禁止} */
+}
/* end of file */
_KERNEL_ENTER_SVC(); /* %jp{サービスコールに入る}%en{enter service-call} */
/* %jp{空きID探索} */
- for ( isrid = _KERNEL_TMAX_ISR_ISRID; isrid >= _KERNEL_TMIN_ISR_ISRID; isrid-- )
+ for ( isrid = _KERNEL_ISR_TMAX_ID; isrid >= _KERNEL_ISR_TMIN_ID; isrid-- )
{
if ( !_KERNEL_ISR_CHECK_EXS(isrid) )
{
break;
}
}
- if ( isrid <= _KERNEL_TMIN_ISR_ISRID )
+ if ( isrid <= _KERNEL_ISR_TMIN_ID )
{
_KERNEL_LEAVE_SVC(); /* %jp{サービスコールから出る}%en{leave service-call} */
return E_NOID; /* %jp{ID番号不足} */
/* %jp{割り込みの処理} */
void _kernel_exe_isr(INTNO intno)
{
- _KERNEL_T_ISRHDL isrhdl;
+ _KERNEL_T_ISRCB_RO_PTR isrcb_ro;
+ _KERNEL_T_ISRCB_PTR isrcb;
+ _KERNEL_T_ISRHDL isrhdl;
- isrhdl = _KERNEL_INT_GET_HEAD(intno);
- while ( isrhdl != NULL )
+ isrhdl = _KERNEL_INT_GET_HEAD(intno);
+ isrcb = _KERNEL_ISR_ISRHDL2ISRCB(isrhdl);
+ isrcb_ro = _KERNEL_ISR_ISRHDL2ISRCBRO(isrhdl);
+
+ while ( isrhdl != _KERNEL_ISRHDL_NULL )
{
- _KERNEL_ISR_GET_ISR(isrhdl)(_KERNEL_ISR_GET_EXINF(isrhdl));
+ _KERNEL_ISR_GET_ISR(isrcb_ro)(_KERNEL_ISR_GET_EXINF(isrcb_ro));
- isrhdl = _KERNEL_ISR_GET_NEXT(isrhdl);
+ isrhdl = _KERNEL_ISR_GET_NEXT(isrcb);
}
-
- _kernel_dis_int();
}
#endif
-/** %jp{セマフォの生成}%en{Create Semaphore}
- * @param pk_ctsk %jp{セマフォ生成情報}%en{}
- * @return Error code or task ID
- */
+
ER _kernel_cre_isr(ID isrid, const T_CISR *pk_cisr)
{
- _KERNEL_T_ISRHDL isrhdl;
-
+ _KERNEL_T_ISRCB *isrcb;
+ _KERNEL_T_ISRCB_RO *isrcb_ro;
+
+ /* %jp{メモリ確保}%en{get memory} */
+#if _KERNEL_ISRCB_ALGORITHM == _KERNEL_ISRCB_ALG_BLKARRAY
+ {
+ isrcb = _KERNEL_ISR_ID2ISRCB(isrid);
+ isrcb_ro = isrcb;
+ }
+#elif _KERNEL_ISRCB_ALGORITHM == _KERNEL_ISRCB_ALG_PTRARRAY
+#if _KERNEL_ISRCB_SPLIT_RO
{
- VP mem;
+ /* %jp{ISRCB領域がポインタ管理で、ROM/RAM分離の場合} */
+ VP mem;
+ SIZE memsz;
+ /* %jp{メモリサイズ決定} */
+ memsz = _KERNEL_SYS_ALG_MEM(sizeof(_KERNEL_T_ISRCB))
+ + _KERNEL_SYS_ALG_MEM(sizeof(_KERNEL_T_ISRCB_RO));
+
+ /* %jp{メモリ確保} */
+ mem = _KERNEL_SYS_ALC_MEM(memsz);
+
+ /* %jp{メモリ不足チェック} */
+#if _KERNEL_SPT_KCRE_ISR_E_NOMEM
+ if ( mem == NULL )
+ {
+ return E_NOMEM;
+ }
+#endif
+
+ /* %jp{メモリ割り当て} */
+ isrcb = (_KERNEL_T_ISRCB *)mem;
+ isrcb_ro = (_KERNEL_T_ISRCB_RO *)((VB *)mem + _KERNEL_SYS_ALG_MEM(sizeof(_KERNEL_T_ISRCB)));
+ _KERNEL_ISR_ID2ISRCB(isrid) = isrcb;
+ _KERNEL_ISR_ID2ISRCB(isrid)->isrcb_ro = (const _KERNEL_T_ISRCB_RO *)isrcb_ro;
+ }
+#else
+ {
+ VP mem;
+
+ /* %jp{メモリ確保} */
mem = _KERNEL_SYS_ALC_MEM(sizeof(_KERNEL_T_ISRCB));
+
+ /* %jp{メモリ不足チェック} */
+#if _KERNEL_SPT_KCRE_ISR_E_NOMEM
if ( mem == NULL )
{
return E_NOMEM;
}
+#endif
- _KERNEL_ISR_ID2ISRCB(isrid) = (_KERNEL_T_ISRCB *)mem;
+ /* %jp{メモリ割り当て} */
+ isrcb = (_KERNEL_T_ISRCB *)mem;
+ isrcb_ro = (_KERNEL_T_ISRCB_RO *)mem;
+ _KERNEL_ISR_ID2ISRCB(isrid) = isrcb;
}
+#endif
+#endif
+
+ /* %jp{メンバ初期化} */
+ _KERNEL_ISR_SET_EXINF(isrcb_ro, pk_cisr->exinf);
+ _KERNEL_ISR_SET_ISR(isrcb_ro, pk_cisr->isr);
+
+
+#if _KERNEL_SPT_DPC
+ _KERNEL_DIS_INT(); /* %jp{割込み禁止} */
+#endif
- isrhdl = _KERNEL_ISR_ID2ISRHDL(isrid);
-
- /* %jp{メンバの設定} */
- _KERNEL_ISR_SET_EXINF(isrhdl, pk_cisr->exinf);
- _KERNEL_ISR_SET_ISR(isrhdl, pk_cisr->isr);
-
/* %jp{割り込みリストの先頭に繋ぐ} */
- _KERNEL_ISR_SET_NEXT(isrhdl, _KERNEL_INT_GET_HEAD(pk_cisr->intno));
- _KERNEL_INT_SET_HEAD(pk_cisr->intno, isrhdl);
+ _KERNEL_ISR_SET_NEXT(isrcb, _KERNEL_INT_GET_HEAD(pk_cisr->intno));
+ _KERNEL_INT_SET_HEAD(pk_cisr->intno, _KERNEL_ISR_GET_ISRHDL(isrid, isrcb));
+
+#if _KERNEL_SPT_DPC
+ if ( !_KERNEL_SYS_SNS_LOC() ) { _KERNEL_DIS_INT(); } /* %jp{割込み許可} */
+#endif
return E_OK;
}
OSDN Git Service
