system.c

有线电视系统前端设备复用器原代码。 用语接受卫星信号

/*------------------------------------------------------------------------------*/
/* Project Name: Multiplexer of MPEG-II                                         */
/* Module  Name: system function module                                         */
/* Purpose     :                                                                */
/* Author      : LingYiChuan                                                    */
/* Date        : 2000/9/20                                                      */
/* Version     : 1.0                                                            */
/* Copyright HignSun Dvision, All Right Reservered.                             */
/*------------------------------------------------------------------------------*/
#include "psos.h"
#include <prepc.h>
#include <probe.h>
#include "constant.h"

#include "sys_conf.h"

#include "caproc.h"

extern unsigned char Connected;

extern unsigned long MemRng0,MemRng1,MemRng2,MemRng3,MemCount;

extern void my_Delay(unsigned long int dly_ms);
typedef struct STRUCT_MEM_HEAD
{
	unsigned long RngID;
	unsigned long Length;
	unsigned char Info[24];
	unsigned long MemHead;
}MEM_HEAD;

MEM_HEAD     MemList[128];


void Display( const char *fmt, ... );
void Display1( const char *fmt, ... );

/*----------------------------------------------------------------------------*/
/* 内存拷贝函数                                                               */
/*----------------------------------------------------------------------------*/
void MemCopy(unsigned char *Des,unsigned char *Src,unsigned long Len)
{
	int i;
	for(i=0;i<Len;i++)
		*(unsigned char *)(Des+i)=*(unsigned char *)(Src+i);

	/*
	memcpy((void *)Des,(const void *)Src,(size_t)Len);
	*/
}

void MemSet(unsigned char *Des,unsigned long Len,unsigned char Val)
{
	int i;
	for(i=0;i<Len;i++)
		*(unsigned char *)(Des+i)=Val;
}


#if 0
void *MemAlloc(unsigned char RngID,char* TaskName, unsigned long Len)
{
	unsigned long rc;
	void          *ptr;
	unsigned long Size;


	Size=Len;

	if((Size<=0)||(Size>=0x100000))  
	{
		Display("Task or function: %s Memory block alloc failed, size too small or too big. \n",TaskName);
		return NULL;
	}

	if((Size + 32) % 0x100)
	{
		Size=( (Size + 32) / 0x100 +1) * 0x100 - 32;
	}

	switch(RngID)
	{
	case RNG0ID:
		{
			rc = rn_getseg(MemRng0, Size+32, RN_WAIT, 500, &ptr);
			break;
		}
	case RNG1ID:
		{
			rc = rn_getseg(MemRng1, Size+32, RN_WAIT, 500, &ptr);
			break;
		}
	case RNG2ID:
		{
			rc = rn_getseg(MemRng2, Size+32, RN_WAIT, 500, &ptr);
			break;
		}
	case RNG3ID:
		{
			rc = rn_getseg(MemRng3, Size+32, RN_WAIT, 500, &ptr);
			break;
		}
	default:
		{
			Display("Function MemAlloc(): invalid RngID \n");
			return NULL;
		}
	}
	if(rc)
	{
			Display("Function MemAlloc(): rn_getseg return error:%d \n",rc);
			return NULL;
	}
	else
	{
	
		/* Display("Task or function: %s allocate a memory.\n",TaskName); */


		*(unsigned long *)ptr=(unsigned long)RngID;
		*(unsigned long *)(ptr+4)=(unsigned long)Size;

		MemCopy((unsigned char *)(ptr + 8),TaskName,24);
		
		MemList[MemCount].RngID   =RngID;
		MemList[MemCount].Length  =Size;
		MemList[MemCount].MemHead =(unsigned long)ptr;

		MemCopy((unsigned char *)&(MemList[MemCount].Info),(unsigned char *)TaskName,24);

		MemCount++;

		return (void*)((unsigned char *)ptr+32);
	}

	
}

void    MemFree(void *ptr)
{
	void *p;
	
	unsigned long rc;

	unsigned char RngID;


	if(ptr == NULL) 
		return;
	
	p=(void *)((unsigned long)ptr-32);

	RngID=*(unsigned long *)p;

	switch(RngID)
	{
	case RNG0ID:
		rc=rn_retseg(MemRng0,p);
		break;
	case RNG1ID:
		rc=rn_retseg(MemRng1,p);
		break;
	case RNG2ID:
		rc=rn_retseg(MemRng2,p);
		break;
	case RNG3ID:
		rc=rn_retseg(MemRng3,p);
		break;
	default:
		Display("Function MemFree(): unrecognized RNGID found.\n");
	}

	if(rc)
	{
			Display("Function MemFree(): rn_retseg return error:%d \n",rc);
			return;
	}
	else
	{
		MemList[MemCount].RngID   =0;
		MemList[MemCount].Length  =0;
		MemList[MemCount].MemHead =0;
		MemList[MemCount].Info[0]='\0';
	
		MemCount--;

		ptr=NULL;
	}
}

unsigned long CreateMemRgn()
{
	unsigned long rc;
	unsigned long asize;
	char Rng0[4],Rng1[4],Rng2[4],Rng3[4];
	void *seg_ptr;

	strcpy(Rng0,"Rng0");	
	strcpy(Rng1,"Rng1");	
	strcpy(Rng2,"Rng2");
	strcpy(Rng3,"Rng3");

	/*--------------------------------------------------------------------------*/
	/* 分配Rng0, 8Mbyte区域, 最小内存单元为256字节.			                	*/
	/*--------------------------------------------------------------------------*/
	rc = rn_getseg(0, RNG0SIZE + 4, RN_NOWAIT, 0, &seg_ptr);
	if(rc) {
		Display(" Rng0 create error! ");
	
		return rc;
	}
	seg_ptr = (void *)((unsigned long)((char *)seg_ptr + 3) & ~3);
	rc=rn_create(Rng0,seg_ptr,RNG0SIZE,256,0,&MemRng0,&asize);
	if(rc) {
		Display(" Rng0 create error! ");
	
		return rc;
	}
	/*--------------------------------------------------------------------------*/
	/* 分配Rng1, 8Mbyte区域, 最小内存单元为256字节.		                		*/
	/*--------------------------------------------------------------------------*/
	rc = rn_getseg(0, RNG1SIZE + 4, RN_NOWAIT, 0, &seg_ptr);
	if(rc) {
		Display(" Rng1 create error! ");

		return rc;
	}
	seg_ptr = (void *)((unsigned long)((char *)seg_ptr + 3) & ~3);
	rc=rn_create(Rng1,seg_ptr,RNG1SIZE,256,0,&MemRng1,&asize);
	if(rc) {
		Display(" Rng1 create error! ");

		return rc;
	}

	/*--------------------------------------------------------------------------*/
	/* 分配Rng2, 8Mbyte区域, 最小内存单元为256字节.	                			*/
	/*--------------------------------------------------------------------------*/
	rc = rn_getseg(0, RNG2SIZE + 4, RN_NOWAIT, 0, &seg_ptr);
	if(rc) {
		Display(" Rng2 create error! ");

		return rc;
	}
	seg_ptr = (void *)((unsigned long)((char *)seg_ptr + 3) & ~3);
	rc=rn_create(Rng2,seg_ptr,RNG2SIZE,256,0,&MemRng2,&asize);
	if(rc) {
		Display(" Rng2 create error! ");

		return rc;
	}

#if 0
	/*--------------------------------------------------------------------------*/
	/* 分配Rng3, 8Mbyte区域, 最小内存单元为256字节.	                			*/
	/*--------------------------------------------------------------------------*/
	rc = rn_getseg(0, RNG3SIZE + 4, RN_NOWAIT, 0, &seg_ptr);
	if(rc) {
		Display(" Rng3 create error! ");

		return rc;
	}
	seg_ptr = (void *)((unsigned long)((char *)seg_ptr + 3) & ~3);
	rc=rn_create(Rng3,seg_ptr,RNG3SIZE,256,0,&MemRng3,&asize);
	if(rc) {
		Display(" Rng3 create error! ");

		return rc;
	}
#endif

	return NOERR;
}
#endif


void *MemAlloc(unsigned char RngID,char* TaskName, unsigned long Len)
{
	/*memcpy(MemList[MemCount].Info,TaskName,strlen(TaskName)>24?24:strlen(TaskName));*/
	MemCount++;
	return  malloc((size_t)Len);
}


void    MemFree(void *ptr)
{
	if(ptr==NULL)
		return;

	free(ptr);
	ptr=NULL;

	MemCount--; 
}

unsigned long CreateMemRgn()
{
	return 0;
}

unsigned long CreateQueue(char *QueueName, unsigned long *qid)
{
	unsigned long rc;

	rc=q_create(QueueName,1024,Q_LOCAL|Q_FIFO|Q_NOLIMIT|Q_PRIBUF,qid);

	return rc;
}

unsigned long DeleteQueue(char *QueueName)
{
	unsigned long rc, tqid;
	char Que_name[4];

	Que_name[0]=QueueName[0];
	Que_name[1]=QueueName[1];
	Que_name[2]=QueueName[2];
	Que_name[3]=QueueName[3];

    rc = q_ident(Que_name, 0, &tqid);

	if(rc)
		return rc;
	else
	{
		rc=q_delete(tqid);
		return rc;
	}
}

unsigned long SendQueueUrgent( char *QueueName, unsigned long MsgBuf[4])
{
	MESSAGE       Msg;

	unsigned long rc, tqid;
	char Que_name[4];

	Que_name[0]=QueueName[0];
	Que_name[1]=QueueName[1];
	Que_name[2]=QueueName[2];
	Que_name[3]=QueueName[3];

	Msg.MsgType=MsgBuf[1];
	Msg.Pdata  =(char *)MsgBuf[3];

	rc = q_ident(Que_name, 0, &tqid);
	if(rc)
	{
		Display("Queue %s identfied error \n",QueueName);	
		return rc;
	}
	rc = q_urgent(tqid, MsgBuf);
	if(rc)
	{
		Display("Queue %s urgent send error,errorcode=0x%x \n", QueueName,rc);
		return rc;
	}
	return NOERR;
}

unsigned long SendQueue( char *QueueName, unsigned long MsgBuf[4])
{
	MESSAGE       Msg;

	unsigned long rc, tqid;
	char Que_name[4];

	Que_name[0]=QueueName[0];
	Que_name[1]=QueueName[1];
	Que_name[2]=QueueName[2];
	Que_name[3]=QueueName[3];

	Msg.MsgType=MsgBuf[1];
	Msg.Pdata  =(char *)MsgBuf[3];

    rc = q_ident(Que_name, 0, &tqid);
	if(rc)
	{
		Display("Queue %s identfied error \n",QueueName);	
		
		if((Msg.Pdata!=NULL)&&(Msg.MsgType!=MSG_MONI)&&(Msg.MsgType!=MSG_ALRM))
				MemFree(Msg.Pdata);

		return rc;
	}

	rc = q_send(tqid, MsgBuf);
	if(rc)
	{
		Display("Queue %s send error,errorcode=0x%x \n", QueueName,rc);

		if(QueueName=="TCPS")
		{
			Connected=FALSE;
			if((Msg.Pdata!=NULL)&&(Msg.MsgType!=MSG_MONI)&&(Msg.MsgType!=MSG_ALRM))
					MemFree(Msg.Pdata);
		}
		return rc;
	}
	return NOERR;
}

unsigned long ReceiveQueue( char *QueueName, unsigned long flag, unsigned long timeout,unsigned long MsgBuf[4])
{
	unsigned long rc, tqid;
	char Que_name[4];
	Que_name[0]=QueueName[0];
	Que_name[1]=QueueName[1];
	Que_name[2]=QueueName[2];
	Que_name[3]=QueueName[3];

    rc = q_ident(Que_name, 0, &tqid);
	if(rc)
	{
		Display("Queue %s identfied error \n",QueueName);
		return rc;
	}
	rc = q_receive(tqid, flag, timeout, MsgBuf);
	if(rc&&(flag!=Q_NOWAIT))
	{
		Display("Queue %s receive error,errorcode=0x%x \n", QueueName,rc);
		return rc;
	}
	return NOERR;
}


unsigned long CreateStartTask(char *TaskName, unsigned long TaskPrio, unsigned long SuperStack, unsigned long UserStack,
						unsigned long TaskMode,	void (*start_addr)(), unsigned long TaskArgument[4])
{
	unsigned long rc, tid;
	char Task_name[4];
	Task_name[0]=TaskName[0];	
	Task_name[1]=TaskName[1];
	Task_name[2]=TaskName[2];	
	Task_name[3]=TaskName[3];

	rc = t_create(Task_name, TaskPrio, SuperStack, UserStack,T_LOCAL, &tid);   
	if(rc) {
		Display(" Task %s create error ! ",Task_name);

		return rc;
    }
	/* rc = t_start(tid, TaskMode|T_ISR|T_NOTSLICE|T_NOPREEMPT, start_addr, TaskArgument); */
	rc = t_start(tid, TaskMode|T_ISR|T_NOPREEMPT, start_addr, TaskArgument);
	if(rc){
		Display(" Task %s start error !", Task_name);
	
		return rc;
	}
	else
		Display("Task %s start successfully \n",Task_name);

	return NOERR;
}

/*---------------------------------------------------------------------*/
/* function to display debug information                               */
/*---------------------------------------------------------------------*/
void Display( const char *fmt, ... )
{

	int		ret;
	char	dest[256];             				      		    
	va_list	ap;   
	
	MESSAGE Msg;
	char    *buf;

	return;
	
	va_start(ap, fmt);                              
	ret = vsprintf(dest, fmt, ap);
	va_end(ap);

#if SC_SD_DEBUG_MODE==DBG_XN
	db_output(dest, 0);
	db_output("\n", 0);
#endif

#ifdef LINGYC_APP_MON
	buf=(char *)MemAlloc(RNG2ID,"Display",ret);
       if(buf == NULL)
       	return;
	MemCopy(buf,dest,ret);

	Msg.Length=ret;
	Msg.Pdata =buf;

	SendQueue("APPM",(unsigned long *)&Msg);
#endif

}

void Display1( const char *fmt, ... )
{

	int		ret;
	char	dest[256];             				      		    
	va_list	ap;   
	
	MESSAGE Msg;
	char    *buf;

	va_start(ap, fmt);                              
	ret = vsprintf(dest, fmt, ap);
	va_end(ap);

#if SC_SD_DEBUG_MODE==DBG_XN
	db_output(dest, 0);
	db_output("\n", 0);
#endif

#ifdef LINGYC_APP_MON
	buf=(char *)MemAlloc(RNG2ID,"Display",ret);
	MemCopy(buf,dest,ret);

	Msg.Length=ret;
	Msg.Pdata =buf;

	SendQueue("APPM",(unsigned long *)&Msg);
#endif

}