sysinit.c

用于TM1300/PNX1300系列DSP（主要用于视频处理）的操作系统pSOS。包括全部源码

#endif

#ifdef KC_FATAL
    PsosCfg.kc_fatal            = KC_FATAL;
#endif

#ifdef KC_IDLESTK
    PsosCfg.kc_idlestk		= KC_IDLESTK;
#else
    PsosCfg.kc_idlestk		= KC_ROOTSSTK;
#endif

    PsosCfg.kc_rootpri          = KC_ROOTPRI;

#ifdef KC_NMUTEX
    PsosCfg.kc_nmutex		= KC_NMUTEX;
#else
    PsosCfg.kc_nmutex		= 10;
#endif

#ifdef KC_NCVAR
    PsosCfg.kc_ncvar		= KC_NCVAR;
#else
    PsosCfg.kc_ncvar		= 5;
#endif

#ifdef KC_NTVAR
    PsosCfg.kc_ntvar		= KC_NTVAR;
#else
    PsosCfg.kc_ntvar		= 5;
#endif

#ifdef KC_NTSD
    PsosCfg.kc_ntsd		= KC_NTSD;
#else
    PsosCfg.kc_ntsd		= 10;
#endif

#ifdef KC_MAXSCMAJOR
    PsosCfg.kc_maxscmajor	= KC_MAXSCMAJOR;
#else
    PsosCfg.kc_maxscmajor	= 4;
#endif

#ifdef KC_NCOCB
    PsosCfg.kc_ncocb		= KC_NCOCB;
#else
    PsosCfg.kc_ncocb		= 5;
#endif
    PsosCfg.kc_tsdanchor	= &global_tsdanchor;

    PsosCfg.kc_psoscode         = (fvoidp) & pSOSHead;
#ifdef SC_STACK_OVF_CHECK 
    PsosCfg.kc_stackcheck_size  = SC_STACK_OVF_CHECK;
#else
    PsosCfg.kc_stackcheck_size  = 2 * sizeof(long);
#endif

#if SC_PSOSM
    MultiprocCfg.mc_nodenum     = SysVars.SmNode;

    MultiprocCfg.mc_kicode      = ((void (*) ()) ki_call);
    MultiprocCfg.mc_nnode       = SysVars.Kism;

    MultiprocCfg.mc_nglbobj     = MC_NGLBOBJ;
    MultiprocCfg.mc_nagent      = MC_NAGENT;
    MultiprocCfg.mc_flags       = MC_FLAGS;
    MultiprocCfg.mc_roster      = MC_ROSTER;

    MultiprocCfg.mc_dprext      = (ULONG)-1;
    MultiprocCfg.mc_dprint      = (ULONG)-1;
    MultiprocCfg.mc_dprlen      = (ULONG)-1;
    MultiprocCfg.mc_kimaxbuf    = MC_KIMAXBUF;	/* size not # of buffs! */
    MultiprocCfg.mc_asyncerr    = MC_ASYNCERR;
#endif


    NodeCfg.mp_ct  = &MultiprocCfg;
    NodeCfg.psosct = &PsosCfg;



/*---------------------------------------------------------------------*/
/* The memory starting at "FreeMemStart" is available for allocation.  */
/* Call any high-level drivers that are configured so they can grab    */
/* some of this memory if they need it.  This technique allows us to   */
/* build systems in which the drivers use different numbers of buffers */
/* without having to re-compile the drivers.                           */
/*---------------------------------------------------------------------*/
#ifdef __TCS__
    mem_size     = ((ULONG)&mem_size) - sbrk(0) - MARGIN;
    FreeMemPtr   = (UCHAR *) sbrk(mem_size);
#else
    mem_size     = 8000000;
    FreeMemPtr   = (UCHAR *) malloc(mem_size);
#endif


    BSP_RAM_BASE = (int) FreeMemPtr;
    BSP_RAM_END  = (int) (mem_size + BSP_RAM_BASE - 1);

    if (FreeMemPtr == (UCHAR *) -1) SysInitFail(MemErrMsg);


/*---------------------------------------------------------------------*/
/* Check that the parameters make sense, then build the component      */
/* configuration tables, and give out memory to the different psos     */
/* parts.                                                              */
/*---------------------------------------------------------------------*/

    FreeMemPtr = BuildConfigTables(FreeMemPtr);
    mem_size   = (int)BSP_RAM_END +1 - (int)FreeMemPtr;

    if (mem_size < 0) SysInitFail(MemErrMsg);

    Carve_PSOS_Memory(&FreeMemPtr, &mem_size);


/*---------------------------------------------------------------------*/
/* Set region 0 area                                                   */
/*---------------------------------------------------------------------*/
#define EMPTY_REGIONSIZE  1024
    /*---------------------------------------------------------------------*/
    /* Since region 0 size cannot be greather than 32,767 times the unit   */
    /* size calculate the max unit size then choose the lesser of the max  */
    /* unit size or the rest of memory.                                    */
    /*---------------------------------------------------------------------*/
    rn0max = KC_RN0USIZE * ((1 << 15) - 1);

    FreeMemPtr = (void *)ALIGN((long)FreeMemPtr, 4);
    mem_size   = (int)BSP_RAM_END +1 - (int)FreeMemPtr;

    if (mem_size < 0) SysInitFail(MemErrMsg);

    PsosCfg.kc_rn0sadr = (void *) FreeMemPtr;

#if   defined (TCS_REGION0_SIZE)
    if ( mem_size > TCS_REGION0_SIZE ) { mem_size= TCS_REGION0_SIZE; }
#elif defined (TCS_MALLOC_USE)
#if (TCS_MALLOC_USE != NO)
    if ( mem_size > EMPTY_REGIONSIZE ) { mem_size= EMPTY_REGIONSIZE; }
#endif
#endif

    if ( mem_size < EMPTY_REGIONSIZE ) { mem_size= EMPTY_REGIONSIZE; }

    if ( mem_size > rn0max ) { mem_size= rn0max; }

    mem_size = TRUNC(mem_size,4);

    PsosCfg.kc_rn0len = mem_size;

    FreeMemPtr += mem_size;
    mem_size    = (int)BSP_RAM_END +1 - (int)FreeMemPtr;

/*---------------------------------------------------------------------*/
/* Give all unused memory back to sbrk                                 */
/*---------------------------------------------------------------------*/

#ifdef __TCS__
    BSP_RAM_END -= mem_size;
    sbrk( -mem_size );
#endif
}





/***********************************************************************/
/* InstallDriver: Adds a device driver to PsosIO table                 */
/*                                                                     */
/*  INPUTS:                                                            */
/*  unsigned short major_number    device major number                 */
/*  void (*dev_init)(),            device init procedure               */
/*  void (*dev_open)(),            device open procedure               */
/*  void (*dev_close)(),           device close procedure              */
/*  void (*dev_read)(),            device read procedure               */
/*  void (*dev_write)(),           device write procedure              */
/*  void (*dev_ioctl)(),           device control procedure            */
/*  unsigned long  rsvd1,          reserved                            */
/*  unsigned short rsvd2,          reserved                            */
/*  unsigned short flags)          Set to auto initialize the device   */
/*                                                                     */
/*     RETURNS: 0 if successfull 1 if major number out of range        */
/*     NOTE(S): assumes SC_DEVMAX defined in sys_conf.h                */
/*              This function is only useful before pSOS+ has been     */
/*              initialized.                                           */
/*                                                                     */
/***********************************************************************/
void 
InstallDriver(
	      unsigned short major_number,
	      void (*dev_init) (struct ioparms *),
	      void (*dev_open) (struct ioparms *),
	      void (*dev_close) (struct ioparms *),
	      void (*dev_read) (struct ioparms *),
	      void (*dev_write) (struct ioparms *),
	      void (*dev_ioctl) (struct ioparms *),
	      unsigned long rsvd1,
	      unsigned short rsvd2,
	      unsigned short flags)
{
    if ((major_number == 0) || (major_number > SC_DEVMAX))
    {
	SysInitFail("Cannot install driver; major number out of range");
    }
    else if (PsosIO[major_number].dev_init != (void (*) ()) -1)
    {
	SysInitFail("Duplicate major device numbers encountered");
    }
    else
    {
	PsosIO[major_number].dev_init = dev_init;
	PsosIO[major_number].dev_open = dev_open;
	PsosIO[major_number].dev_close = dev_close;
	PsosIO[major_number].dev_read = dev_read;
	PsosIO[major_number].dev_write = dev_write;
	PsosIO[major_number].dev_ioctl = dev_ioctl;
	PsosIO[major_number].rsvd2 = rsvd2;
	PsosIO[major_number].flags = flags;
    }
}




/*---------------------------------------------------------------------*/
/* Compile-time checks                                                 */
/*---------------------------------------------------------------------*/
#if SC_PSOS && SC_PSOSM
#error "Cannot use both pSOS+ and pSOS+m!"
#endif
#if (SC_DEV_SERIAL && BSP_SERIAL)
#if(SC_DEV_SERIAL > SC_DEVMAX)
#error "SC_DEV_SERIAL cannot be > SC_DEVMAX"
#endif
#endif
#if SC_DEV_TIMER
#if(SC_DEV_TIMER > SC_DEVMAX)
#error "SC_DEV_TIMER cannot be > SC_DEVMAX"
#endif
#if (!SC_PSOS && !SC_PSOSM)
#error "Must have pSOS+ or pSOS+m in system to use tick timer!"
#endif
#endif
#if SC_DEV_RAMDISK
#if(SC_DEV_RAMDISK > SC_DEVMAX)
#error "SC_DEV_RAMDISK cannot be > SC_DEVMAX"
#endif
#endif
#if (SC_DEV_SCSI && BSP_SCSI)
#if(SC_DEV_RAMDISK > SC_DEVMAX)
#error "SC_DEV_RAMDISK cannot be > SC_DEVMAX"
#endif
#endif
#if (SC_DEV_TFTP)
#if(SC_DEV_TFTP > SC_DEVMAX)
#error "SC_DEV_TFTP cannot be > SC_DEVMAX"
#endif
#endif


/*---------------------------------------------------------------------*/
/* PSOS startup as TCS application                                     */
/*---------------------------------------------------------------------*/

extern long _REDIRECT_MALLOC;

int    __argc;
char **__argv;


#ifdef __TCS__

	main(int argc, char **argv)
	{
	#ifdef TCS_MALLOC_USE
	    #if (TCS_MALLOC_USE)
		_REDIRECT_MALLOC= 0;
	    #endif
	#endif
	    __argc= argc;
	    __argv= argv;
	
	    SysInit();
	    InitBoard();
	    _psos_start();
	}


#else

	#include <AppModel.h>
	
	static void 
	_main(int argc, char **argv)
	{
	#ifdef TCS_MALLOC_USE
	    #if (TCS_MALLOC_USE)
		_REDIRECT_MALLOC= 0;
	    #endif
	#endif
	    __argc= argc;
	    __argv= argv;
	
	    SysInit();
	    InitBoard();
	    _psos_start();
	}
	
	
	main(int argc, char **argv)
	{
	    int         status;
	    AppModel_AppId app;
	    _AppModel_init(KC_SYSSTK);
	    _tmInit();
	    app = AppModel_get_new_appid(AppModel_root);
	    app->argc = argc;
	    app->argv = argv;
	    app->entry_point = (Pointer) _main;
	    status = _AppModel_run_application(app);
	    return status;
	}


#endif