kernel.h

用于嵌入式系统的TCP/IP协议栈

/***********************************************************************/
/*                                                                     */
/*   Module:  kernel.h                                                 */
/*   Release: 2001.3                                                   */
/*   Version: 2000.0                                                   */
/*   Purpose: Kernel prototypes and constants                          */
/*                                                                     */
/*---------------------------------------------------------------------*/
/*                                                                     */
/*               Copyright 2000, Blunk Microsystems                    */
/*                      ALL RIGHTS RESERVED                            */
/*                                                                     */
/*   Licensees have the non-exclusive right to use, modify, or extract */
/*   this computer program for software development at a single site.  */
/*   This program may be resold or disseminated in executable format   */
/*   only. The source code may not be redistributed or resold.         */
/*                                                                     */
/***********************************************************************/
#ifndef _KERNEL_H /* Don't include this file more than once */
#define _KERNEL_H

#ifdef __cplusplus
extern "C"
{
#endif

/***********************************************************************/
/* Symbol Definitions                                                  */
/***********************************************************************/
/*
** Task Property Flags
*/
#define OS_RROBIN       1
#define OS_FLOAT_PT     2

/*
** Flags for Semaphore/Queue Mode for Task Queueing
*/
#define OS_FIFO         0
#define OS_PRIORITY     1

/*
** Flags for Wait-Option
*/
#define WAIT_FOREVER    ((ui32)-1)
#define NO_WAIT         0

/*
** Task Stack Size Codes
*/
#define STACK_512       69
#define STACK_1KB       70
#define STACK_2KB       71
#define STACK_4KB       72
#define STACK_8KB       73
#define STACK_16KB      74

/***********************************************************************/
/* Type Declarations                                                   */
/***********************************************************************/
typedef unsigned long TASK; /* Task Control Block */
typedef unsigned long TMR;  /* Timer Control Block */
typedef unsigned long MTX;  /* Mutex Control Block */
typedef unsigned long SEM;  /* Semaphore Control Block */
typedef unsigned long QUE;  /* Queue Control Block */
typedef unsigned long NEX;  /* Nexus Control Block */
typedef unsigned long PART; /* Partition Control Block */
typedef unsigned long RGN;  /* Region Control Block */

/***********************************************************************/
/* Variable Declarations                                               */
/***********************************************************************/
extern vui32 OsTickCount;
extern ui32 OsSecCount;
extern ui32 OsTicksPerSec;
extern ui32 OsTicksPerSlice;
extern ui8  OsTaskLocked;
TASK t_ident_call(void);
#define RunningTask   t_ident_call()
extern TASK RunningTask;
extern ui8  OsMainStack;
extern ui8  OsIdleStack;
extern ui8  OsIsrStack;
extern PART OsPart;

/***********************************************************************/
/* Function Prototypes                                                 */
/***********************************************************************/
/*
** Task Related Routines
*/
TASK taskCreate(const char name[8], ui8 stack_size, ui8 priority,
                void (*funcp)(ui32 msg), ui32 msg, ui32 flags);
int  taskDelete(TASK tid);
int  taskSuspend(TASK tid);
int  taskResume(TASK tid);
void taskSleep(ui32 wait_opt);
void taskWake(TASK tid);
void taskSetReg(TASK tid, ui8 reg_num, ui32 value);
ui32 taskGetReg(TASK tid, ui8 reg_num);
void taskSetPri(TASK tid, uint priority);
uint taskGetPri(TASK tid);
char *taskGetName(TASK tid);
TASK taskGetId(const char name[8]);
void taskLock(void);

/*
** Mutex Related Routines
*/
MTX mutCreate(const char name[8]);
int mutDelete(MTX mtx);
int mutPost(MTX mtx);
int mutPend(MTX mtx, ui32 wait_opt);
MTX mutGetId(const char name[8]);

/*
** Semaphore Related Routines
*/
SEM  semCreate(const char name[8], int init_count, int mode);
void semDelete(SEM sem);
void semPost(SEM sem);
int  semPend(SEM sem, ui32 wait_opt);
SEM  semGetId(const char name[8]);

/*
** Queue Related Routines
*/
QUE  queCreate(const char name[8], int limit, int mode);
void queDelete(QUE qid);
int  quePost(QUE qid, ui32 msg);
ui32 quePend(QUE qid, ui32 wait_opt);
void queFlush(QUE qid);
QUE  queGetId(const char name[8]);

/*
** Nexus Related Routines
*/
NEX  nexCreate(const char name[8]);
void nexDelete(NEX nex);
void nexPost(NEX nex, ui32 event);
ui32 nexPend(NEX nex, ui32 mask, ui32 wait_opt);
NEX  nexGetId(const char name[8]);

/*
** Timer Related Routines
*/
TMR tmrCreate(const char name[8]);
int tmrDelete(TMR timer);
int tmrStop(TMR timer);
int tmrStopped(TMR timer);
int semPostAfter(int ticks, SEM sem, TMR timer);
int semPostEvery(int ticks, SEM sem, TMR timer);
int quePostAfter(int ticks, QUE qid, ui32 msg, TMR timer);
int quePostEvery(int ticks, QUE qid, ui32 msg, TMR timer);
int nexPostAfter(int ticks, NEX nid, ui32 event, TMR timer);
int nexPostEvery(int ticks, NEX nid, ui32 event, TMR timer);
int tmrCallAfter(int ticks, int (*func)(ui32 arg), ui32 arg, TMR timer);

/*
** Partition Related Routines
*/
PART  partCreate(const char name[8], ui32 base_addr, ui32 length);
void  partDelete(PART part);
PART  partGetId(const char name[8]);
void *partGet16(PART part);
void *partGet32(PART part);
void *partGet64(PART part);
void *partGet128(PART part);
void *partGet256(PART part);
void *partGet512(PART part);
void *partGet1K(PART part);
void *partGet2K(PART part);
void *partGet4K(PART part);
void *partGet8K(PART part);
void *partGet16K(PART part);
void *partGet32K(PART part);
void *partGet64K(PART part);
void  partRet16(PART part, void *bufp);
void  partRet32(PART part, void *bufp);
void  partRet64(PART part, void *bufp);
void  partRet128(PART part, void *bufp);
void  partRet256(PART part, void *bufp);
void  partRet512(PART part, void *bufp);
void  partRet1K(PART part, void *bufp);
void  partRet2K(PART part, void *bufp);
void  partRet4K(PART part, void *bufp);
void  partRet8K(PART part, void *bufp);
void  partRet16K(PART part, void *bufp);
void  partRet32K(PART part, void *bufp);
void  partRet64K(PART part, void *bufp);
void *partGetBuf(PART part, long size);
void  partRetBuf(PART part, void *bufp, long size);

/*
** Region Related Routines
*/
RGN   rgnCreate(const char name[8], ui32 base_addr, ui32 length);
void  rgnDelete(RGN rgn);
RGN   rgnGetId(const char name[8]);
void *rgnMalloc(RGN rgn, ui32 size);
void *rgnCalloc(RGN rgn, ui32 size);
void *rgnRealloc(RGN rgn, void *ptr, ui32 user_size);
void  rgnFree(RGN rgn, void *ptr);

/*
** Interrupt Related Routines
*/
int  isrCreate(uint vector, void (*func_ptr)(void));
void isrDelete(uint vector, void (*func_ptr)(void));
void isrMask(void);
void isrUnmask(void);
int  isrMasked(void);

/*
** Kernel Support Routines
*/
void OsInit(void);
void OsStart(void);
void OsIdleTask(ui32 unused);
void OsAuditStacks(void);
void OsMemCheck(void);
void OsTick(void);
void OsUnknownExcept(void);
void *OsModule(int req, ...);
void OsDataMark(ui32 type, ui32 value);
void OsIsrStart(void);
void OsIsrFinish(void);

/*
** Driver Support Routines
*/
int rd32(ui32 addr, ui32 *val);
int rd16(ui32 addr, ui16 *val);
int rd_8(ui32 addr, ui8  *val);
int wr32(ui32 addr, ui32  val);
int wr16(ui32 addr, uint  val);
int wr_8(ui32 addr, uint  val);

/***********************************************************************/
/* Error Codes (written to errno)                                      */
/***********************************************************************/
#define ENOMEM  12  /* out of memory */
typedef enum kern_errs
{
/*
** Non-fatal Errors
*/
  OS_CHAIN_ERR = 100,
  OS_IS_SUSPENDED,
  OS_NOT_OWNER,
  OS_NOT_SUSPENDED,
  OS_OBJ_DELETED,
  OS_OWN_MUTEX,
  OS_QUEUE_FULL,
  OS_TIMED_OUT,
  OS_TMR_IN_USE,
  OS_WOULD_BLOCK,
  OS_UNK_ISR,

/*
** Fatal Errors
*/
  OS_INTERNAL,
  OS_INVALID_ID,
  OS_ISR_ILLEGAL,
  OS_PARM_ERR,
  OS_STACK_OVERFLOW,
  OS_UNBALANCE
} KernelErrors;

#ifdef __cplusplus
}
#endif

#endif /* _KERNEL_H */