vde_sc.tpl

VRTX 商用嵌入式实时操作系统

/***************************************************************************
*
*               Copyright (c) 1995 MICROTEC RESEARCH INC.
*
*       All rights reserved. MICROTEC RESEARCH's source code is an unpublished
*       work and the use of a copyright notice does not imply otherwise.
*       This source code contains confidential, trade secret material of
*       MICROTEC RESEARCH. Any attempt or participation in deciphering,
*       decoding, reverse engineering or in any way altering the source code
*       is strictly prohibited, unless the prior written consent of
*       MICROTEC RESEARCH is obtained.
*
****************************************************************************/
/*
* vde_sc.c - VRTXsa Help functions for the VRTX Debug Environment macros
*
* This module is used for two purposes:
*
*   1) To make system calls possible from the XRAY command line.
*
*   2) To make it possible for XRAY to display the calling point
*      for VRTXsa system calls. This avoids the "not in source module"
*      message when the TSCOPE command is used to scope a task that is 
*      pended or rescheduled in a system call (almost always the case). 
*
* NOTE:
*  To use the features above this module should be compiled and linked into 
*  the user system. To enable the calling-point-display a special header file
*  "vrtxild.h" must be used instead of the original "vrtxil.h". This directs 
*  all user calls to the dummy functions below.
*
*/

#include <vrtxil.h>

/* force frame use (LINK/UNLK instructions) */
#pragma option -Kf


void sysc_dummy(void)	/* dummy routine, called to set XDM context */
{
}

/*
 * All functions that are likely to cause rescheduling are defined in C
 */

void scx_adelay(struct timespec time, int* errp)
{
  sc_adelay(time, errp);
}

void scx_delay(long timeout)
{
  sc_delay(timeout);
}

int scx_fpend(int id, long timeout, int mask, int opt, int* errp)
{
  return sc_fpend(id, timeout, mask, opt, errp);
}

void scx_fpost(int id, int mask, int* errp)
{
  sc_fpost(id, mask, errp);
}

void scx_mpend(int id, unsigned long timeout, int* errp)
{
  sc_mpend(id, timeout, errp);
}

void scx_mpost(int id, int* errp)
{
  sc_mpost(id, errp);
}

char *scx_pend(char** mbox, long timeout, int* errp)
{
  return sc_pend(mbox, timeout, errp);
}

void scx_post(char** mbox, char* msg, int* errp)
{
  sc_post(mbox, msg, errp);
}

void scx_putc(int chr)
{
  sc_putc(chr);
}

void scx_qbrdcst(int id, char* msg, int* errp)
{
  sc_qbrdcst(id, msg, errp);
}

void scx_qjam(int id, char* msg, int* errp)
{
  sc_qjam(id, msg, errp);
}

char *scx_qpend(int id, long timeout, int* errp)
{
  return sc_qpend(id, timeout, errp);
}

void scx_qpost(int id, char* msg, int* errp)
{
  sc_qpost(id, msg, errp);
}

/* special version os sc_sclock for call from syscall macro */
void scx_sclock2(long sec, long nanosec, long ns_per_tick, int* errp)
{
  struct timespec time; 
  time.seconds = sec;
  time.nanoseconds = nanosec; 
  sc_sclock(time, ns_per_tick, errp);
}

void scx_spend(int id, long timeout, int* errp)
{
  sc_spend(id, timeout, errp);
}

void scx_spost(int id, int* errp)
{
  sc_spost(id, errp);
}

int scx_tcreate(void* task, int tid, int pri, int* errp)
{
  return sc_tcreate(task, tid, pri, errp);
}

int scx_tecreate(void* task, int tid, int pri, int mode,
		     unsigned long ustack, unsigned long sstack, 
		     char* paddr, unsigned long psize, int* errp)
{
  return sc_tecreate(task, tid, pri, mode, ustack, sstack, paddr, psize, errp);
}

void scx_tpriority(int id, int pri, int* errp)
{
  sc_tpriority(id, pri, errp);
}

void scx_tresume(int tid, int code, int* errp)
{
  sc_tresume(tid, code, errp);
}

void scx_unlock(void)
{
  sc_unlock();
}

void scx_waitc(int chr, int* errp)
{
  sc_waitc(chr, errp);
}

/*
 * the following calls might be replaced by JUMPs in the future
 * the calls does not normally cause rescheduling
 */

char *scx_accept(char** mbox, int* errp)
{
  return sc_accept(mbox, errp);
}

char scx_acceptc(int* errp)
{
  return sc_acceptc(errp);
}

void scx_call(int fcode, char* pkt, int* errp)
{
  sc_call(fcode, pkt, errp);
}

int scx_fclear(int id, int mask, int* errp)
{
  return sc_fclear(id, mask, errp);
}

int scx_fcreate(int* errp)
{
  return sc_fcreate(errp);
}

void scx_fdelete(int id, int opt, int* errp)
{
  sc_fdelete(id, opt, errp);
}

int scx_finquiry(int id, int* errp)
{
  return sc_finquiry(id, errp);
}

char* scx_gblock(int id, int* errp)
{
  return sc_gblock(id, errp);
}

void scx_gclock(struct timespec *time, unsigned long *nsp, int* errp)
{
  sc_gclock(time, nsp, errp);
}

int scx_getc(void)
{
  return sc_getc();
}

long scx_gtime(void)
{
  return sc_gtime();
}

long scx_gversion(void)
{
  return sc_gversion();
}

char* scx_halloc(int id, unsigned long size, int* errp)
{
  return sc_halloc(id, size, errp);
}

int scx_hcreate(char* addr, unsigned long hsize, unsigned int log2size, int* errp)
{
  return sc_hcreate(addr, hsize, log2size, errp);
}

void scx_hdelete(int id, int opt, int* errp)
{
  sc_hdelete(id, opt, errp);
}

void scx_hfree(int id, char* blockp, int* errp)
{
  sc_hfree(id, blockp, errp);
}

void scx_hinquiry(int* info, int id, int* errp)
{
  sc_hinquiry(info, id, errp);
}

void scx_lock(void)
{
  sc_lock();
}

void scx_maccept(int id, int* errp)
{
  sc_maccept(id, errp);
}

int scx_mcreate(unsigned int opt, int* errp)
{
  return sc_mcreate(opt, errp);
}

void scx_mdelete(int id, int opt, int* errp)
{
  sc_mdelete(id, opt, errp);
}

int scx_minquiry(int id, int* errp)
{
  return sc_minquiry(id, errp);
}

int scx_pcreate(int id, char* paddr, unsigned long psize, 
		     unsigned long bsize, int* errp)
{
  return sc_pcreate(id, paddr, psize, bsize, errp) ;
}

void scx_pdelete(int id, unsigned int opt, int* errp)
{
  sc_pdelete(id, opt, errp);
}

void scx_pextend(int id, char* paddr, unsigned long psize, int* errp)
{
  sc_pextend(id, paddr, psize, errp);
}

void scx_pinquiry(unsigned long *info, int id, int* errp)
{
  sc_pinquiry(info, id, errp);
}

char* scx_qaccept(int id, int* errp)
{
  return sc_qaccept(id, errp);
}

int scx_qcreate(int id, int qsize, int* errp)
{
  return sc_qcreate(id, qsize, errp);
}

void scx_qdelete(int id, int opt, int* errp)
{
  sc_qdelete(id, opt, errp);
}

int scx_qecreate(int id, int qsize, int opt, int* errp)
{
  return sc_qecreate(id, qsize, opt, errp);
}

char *scx_qinquiry(int id, int* countp, int* errp)
{
  return sc_qinquiry(id, countp, errp);
}

void scx_rblock(int id, char* blockp, int* errp)
{
  sc_rblock(id, blockp, errp);
}

void scx_saccept(int id, int* errp)
{
  sc_saccept(id, errp);
}

void scx_sclock(struct timespec time, unsigned long ns, int* errp)
{
  sc_sclock(time, ns, errp);
}

int scx_screate(int init, int opt, int* errp)
{
  return sc_screate(init, opt, errp);
}

void scx_sdelete(int id, int opt, int* errp)
{
  sc_sdelete(id, opt, errp);
}

int scx_sinquiry(int id, int* errp)
{
  return sc_sinquiry(id, errp);
}

void scx_stime(long time)
{
  sc_stime(time);
}

void scx_tdelete(int tid, int code, int* errp)
{
  sc_tdelete(tid, code, errp);
}

void *scx_tinquiry(int* info, int tid, int* errp)
{
  return sc_tinquiry(info, tid, errp);
}

void scx_tslice(unsigned short int ticks)
{
  sc_tslice(ticks);
}

void scx_tsuspend(int id, int code, int* errp)
{
  sc_tsuspend(id, code, errp);
}

void uix_rxchr(char chr, int* errp)
{
  ui_rxchr(chr, errp);
}

void uix_timer(void)
{
  ui_timer();
}

char uix_txrdy(int* errp)
{
  return ui_txrdy(errp);
}