vdk.cpp

lwip tcp/ip 协议栈 adsp BF533 DSP 移植 用 visual dsp++ 编译

/* =============================================================================
 *
 *  Description: This VDK Configuration file is automatically generated 
 *               by the VisualDSP++ IDDE and should not be modified.
 *
 * ===========================================================================*/

#include "VDK.h"
#include <VDK_Internals.h>

#ifndef NULL
#define NULL 0
#endif


#include "lwip_sysboot_threadtype.h"
#include "lwip/ADI_TOOLS_IOEThreadType.h"




INT_ASM_ROUT(_TimerISR__3VDK)

namespace VDK
{

	/*************************************************************************
	 *	Thread Types:
	 */

#pragma retain_name
	VDK::IDTableElement g_ThreadIDElements[10+1];
#pragma retain_name
	VDK::ThreadTable g_ThreadTable(g_ThreadIDElements, 10+1);
	

#pragma retain_name
    VDK::ThreadTemplate	g_ThreadTemplates[] = 
	{
		INIT_THREADTEMPLATE_("klwip_sysboot_threadtype",kPriority5, 512,  ::lwip_sysboot_threadtype_Wrapper::Create  ,ksystem_heap ,ksystem_heap,false),
		INIT_THREADTEMPLATE_("kADI_TOOLS_IOEThreadType",kPriority5, 512,  ::ADI_TOOLS_IOEThreadType_Wrapper::Create  ,ksystem_heap ,ksystem_heap,false)
	};

 	// Number of thread templates
#pragma retain_name
	unsigned int kNumThreadTemplates = sizeof(g_ThreadTemplates)/sizeof(ThreadTemplate);

#ifdef VDK_INCLUDE_IO_
	/***************************************************************************
	 * IO Templates: 
	 */

#pragma retain_name
	VDK::IDTableElement g_DevIDElements[0];

#pragma retain_name
	VDK::IODeviceTable g_IOdevTable(g_DevIDElements, 0);

#pragma retain_name
	extern const unsigned int kMaxNumIOObjects=0;
#pragma retain_name
	VDK::IODeviceTemplate g_IOTemplates[] = 
	{
		0 // no I/O objects have been defined
	};
#pragma retain_name
	unsigned int kNumIOTemplates = sizeof(g_IOTemplates)/sizeof(IODeviceTemplate);

#ifdef VDK_BOOT_OBJECTS_IO_

#pragma retain_name
	BootIOObjectInfo g_BootIOObjects[] = 
	{

	};
#pragma retain_name
	unsigned int kNumBootIOObjects = sizeof(g_BootIOObjects)/sizeof(BootIOObjectInfo);

#endif // VDK_BOOT_OBJECTS_IO_
#endif // VDK_INCLUDE_IO_


	/*************************************************************************
	 *	Idle Thread:
	 */
#pragma retain_name
	IdleThreadInfo g_IdleThreadInfo = { 256, ksystem_heap};

	/*************************************************************************

	 *	Boot Threads:
	 */


	// The maximum number of running threads in a system
#pragma retain_name
    unsigned int kMaxNumThreads = 10;

	// The list of threads to create at boot time
#pragma retain_name
 	BootThreadInfo g_BootThreadInfo[] = 	
	{ 
		{ &g_ThreadTemplates[klwip_sysboot_threadtype], 0 }
	}; 

#pragma retain_name
	unsigned int kNumBootThreads = sizeof( g_BootThreadInfo ) / sizeof( BootThreadInfo );

	/**************************************************************************
	 * Round Robin (time-slice) mode: 
	 * 
	 * Defines which priority levels will execute in round robin (time sliced) mode.
	 */
	
#pragma retain_name
	VDK::Bitfield g_RoundRobinInitPriority(  

		0 );

	// If the priority is in round robin mode, set the period in Ticks.
	// For all priorities not in RR mode, the period MUST be set to 1.
	
#pragma retain_name
	VDK::Ticks  g_RoundRobinInitPeriod[] = 		
	{
		1,			// The Idle thread priority
		1,		// kPriority30
		1,		// kPriority29
		1,		// kPriority28
		1,		// kPriority27
		1,		// kPriority26
		1,		// kPriority25
		1,		// kPriority24
		1,		// kPriority23
		1,		// kPriority22
		1,		// kPriority21
		1,		// kPriority20
		1,		// kPriority19
		1,		// kPriority18
		1,		// kPriority17
		1,		// kPriority16
		1,		// kPriority15
		1,		// kPriority14
		1,		// kPriority13
		1,		// kPriority12
		1,		// kPriority11
		1,		// kPriority10
		1,		// kPriority9
		1,		// kPriority8
		1,		// kPriority7
		1,		// kPriority6
		1,		// kPriority5
		1,		// kPriority4
		1,		// kPriority3
		1,		// kPriority2
		1,		// kPriority1
	};

#ifdef VDK_INCLUDE_MEMORYPOOLS_ 
	/*************************************************************************
	 *	Memory Pools:
	 */					
#pragma retain_name
	extern const unsigned int kMaxNumActiveMemoryPools=0;

#pragma retain_name
	VDK::IDTableElement g_MemIDElements[0];

#pragma retain_name
	VDK::MemoryPoolTable g_MemoryPoolTable(g_MemIDElements, (0)) ;

#pragma retain_name
	VDK::PoolID g_MessagePoolID;

#ifdef VDK_BOOT_MEMORYPOOLS_

#pragma retain_name
struct BootPoolInfo g_BootMemoryPools[] =
	{ 
 
	};

#pragma retain_name
unsigned int kNumBootPools = sizeof (g_BootMemoryPools)/sizeof(BootPoolInfo); 




#else

#pragma retain_name
	unsigned int kNumBootPools = 0;    // Number of boot pools

#endif //VDK_BOOT_MEMORYPOOLS_
#endif // VDK_INCLUDE_MEMORYPOOLS_


#pragma retain_name
        float g_TickPeriod = .1;

#pragma retain_name
        unsigned int g_ClockFrequency = 270.000;

#pragma retain_name
	unsigned int g_ClockPrescale = 0;

#pragma retain_name
	unsigned int g_ClockPeriod = 27000;

#pragma retain_name
        unsigned int g_StackAlignment   = VDK_STACK_ALIGNMENT_ ;
#if VDK_INSTRUMENTATION_LEVEL_==2
    // Setup the history buffer
#pragma retain_name
    VDK::HistoryBuffer::HistoryEvent    g_HistoryEnums[256];
#pragma retain_name
    VDK::HistoryBuffer                  g_History(256, g_HistoryEnums);
#endif

	/*************************************************************************
	 * Semaphores:
	 */
	
#pragma retain_name
	extern const unsigned int kMaxNumActiveSemaphores=44;
#pragma retain_name
	VDK::IDTableElement g_SemIDElements[44 +1];
#pragma retain_name
        SemaphoreTable g_SemaphoreTable(g_SemIDElements, 44) ;


#ifdef VDK_BOOT_SEMAPHORES_
#pragma retain_name
    SemaphoreInfo  g_BootSemaphores[] = 
	{

	};
#pragma retain_name
    unsigned int kNumBootSemaphores = sizeof (g_BootSemaphores)/sizeof(SemaphoreInfo);    // Number of boot semaphores

#endif // VDK_BOOT_SEMAPHORES_

#ifdef VDK_MULTIPLE_HEAPS_
#pragma retain_name
    HeapInfo g_Heaps[] =
	{
		{ 0, 0 }
	};

#pragma retain_name
HeapID g_SemaphoreHeap = ksystem_heap; 

#pragma retain_name
HeapID g_DeviceFlagHeap = ksystem_heap;

#pragma retain_name
HeapID g_IOObjectHeap = ksystem_heap;

#pragma retain_name
    unsigned int kNumHeaps = sizeof (g_Heaps)/sizeof(HeapInfo);    // Number of heaps
#endif

#ifdef VDK_INCLUDE_EVENTS_

	/*************************************************************************
	 * EventBits: 
	 */
	
	// Initialize the global system EventBit state.  This is a bitfield, so the
	// bit value needs to be shifted into position and OR'd to the total. 
	
#pragma retain_name
	VDK::Bitfield 	g_EventBitState(

		0 );
	
	// Allocate memory for EventBits using the same value as kNumEventBits.  
	
#pragma retain_name
	unsigned int kNumEventBits = 0;	//  total number of entries in enum 
#pragma retain_name
	VDK::EventBit g_EventBits[0];

	/*************************************************************************
	 * Events: 
	 */
	
#pragma retain_name
	VDK::Event g_Events[] =		
	{

	};

#pragma retain_name
	unsigned int kNumEvents = sizeof (g_Events)/sizeof(Event);

#endif // ifdef VDK_INCLUDE_EVENTS_

	/*************************************************************************
	 * Device Flags: 
	 */

#ifdef VDK_INCLUDE_DEVICE_FLAGS_

#pragma retain_name
        extern const unsigned int kMaxNumActiveDevFlags=0;
#pragma retain_name
        VDK::IDTableElement g_DevFlagsIDElements[0];
#pragma retain_name
        VDK::DeviceFlagTable     g_DeviceFlagTable(g_DevFlagsIDElements, 0) ;

#ifdef VDK_BOOT_DEVICE_FLAGS_
#pragma retain_name
    unsigned int kNumBootDeviceFlags = 0;

#endif // VDK_BOOT_DEVICE_FLAGS_

#endif // VDK_INCLUDE_DEVICE_FLAGS_


	/*************************************************************************
	 * Messages: 
	 */

#ifdef VDK_INCLUDE_MESSAGES_
#pragma retain_name
        extern const unsigned int kMaxNumActiveMessages=0;

	void MessageQueueCleanup(MessageQueue*);

#pragma retain_name
		VDK::IDTableElement g_MsgIDElements[0];
#pragma retain_name
        VDK::MessageTable     g_MessageTable( g_MsgIDElements, 0) ;
#pragma retain_name
	void (*g_MessageQueueCleanup)(VDK::MessageQueue *) = MessageQueueCleanup;
#else
#pragma retain_name
	void (*g_MessageQueueCleanup)(VDK::MessageQueue *) = NULL;

#endif

#pragma retain_name
	unsigned int g_localNode =0;

#pragma retain_name
	unsigned short g_ChannelRoutingMask =0;


#pragma retain_name
	ThreadID g_vRoutingThreads[]=
	{
		(ThreadID) 0
	};

#pragma retain_name
	ThreadID g_vRoutingThreads2[]=
	{
		(ThreadID) 0
	};

#pragma retain_name
    unsigned int kNumRoutingNodes = 0;    // Number of routing nodes

#pragma retain_name
	MsgThreadEntry g_RoutingThreadInfo[] =
	{
		INIT_RTHREAD_(NULL, (VDK::Priority) 0, 0,  NULL   ,ksystem_heap ,ksystem_heap, false, (VDK::ThreadID) 0, (VDK::IOID) 0,"0", (VDK::RoutingDirection) 0)
	};

#pragma retain_name
    unsigned int kNumRoutingThreads = 0; // Number of routing threads



#pragma retain_name
	VDK::MarshallingEntry g_vMarshallingTable[] =
	{
		{0,0}
	};

#pragma retain_name
    unsigned int kNumMarshalledTypes = 0 ;    // Number of marshalling message types



	/*************************************************************************
	 * Interrupt Service Routines
	 */

#pragma retain_name
	IMASKStruct g_InitialISRMask = 
	{
		EVT_IVTMR
			| 

		0
	};

#pragma retain_name
        IMASKStruct g_InitialISRMask2 =
        {

                0
        };

#pragma retain_name
      void UserDefinedInterruptServiceRoutines( void )
      {
		INTVECTOR(seg_EVT_IVTMR, _TimerISR__3VDK)

      }

#pragma retain_name
	BootFuncPointers g_InitBootFunctionP[] = 
	{ 
			VDK::InitBootThreads,
			VDK::InitISRMask,
			VDK::SetTimer
 
	}; 

#pragma retain_name
	unsigned int kNumBootEntries = sizeof (g_InitBootFunctionP)/sizeof(BootFuncPointers) ; 



}  // namespace VDK

/* ========================================================================== */