msgque.c

GM5621原代码

/*
	$Workfile:   msgque.c  $
	$Revision:   1.8  $
	$Date:   Sep 15 2004 17:15:24  $
*/

//******************************************************************
//
//          Copyright (C) 2002. GENESIS MICROCHIP INC.
//  All rights reserved.  No part of this program may be reproduced.
//
//	Genesis Microchip Corp., 2150 Gold Street
//			Alviso, CA 95002	USA
//  Genesis Microchip Inc., 165 Commerce Valley Dr. West
//          Thornhill, Ontario, Canada, L3T 7V8
//
//================================================================
//
//  MODULE: msgque.c
//
//  USAGE : This module contains the message queue code for implementing
//          a circular message que.
//
//******************************************************************

//******************************************************************
//                  I N C L U D E    F I L E S
//******************************************************************
#include "inc\all.h"

#define	DEBUG_QUE    1

#if DEBUG_QUE && DEBUG_MSG
	#define	msg(a,b)	gm_Print((const char far *)a,b)

	char far* getOsdMsgStr(BYTE message);
	char far* getPHMsgStr(BYTE message);
#else
	#define msg(a,b)
#endif

MsgQueueType OsdQ = {0,0,0}; // clear head and tail indices and size.
MsgQueueType PowerHandlerQ = {0,0,0}; // clear head and tail indices and size.


//******************************************************************************
//	DESCRIPTION	:	Adds a BYTE message to the circular queue.  If queue is
//					Full, the oldest message is over-written.
//	SYNTAX     	:	BYTE SendMsg(MsgQueueType *queue, BYTE message)
//	PARAMETERS	:	Pointer to desired message queue, and a BYTE size message.
//  RETURN		:	gmd_TRUE
//******************************************************************************
BYTE SendMsg(MsgQueueType *queue, BYTE message)
{
    if(queue->Size >= MAX_MSG_QUEUE_SIZE)
    	queue->Size--;

    queue->Size++;

    queue->Queue[queue->Head] = message;

    queue->Head++;
    if(queue->Head >= MAX_MSG_QUEUE_SIZE)
        queue->Head = 0;

	#if DEBUG_QUE && DEBUG_MSG
    if(queue == &OsdQ)
    {
    	msg("SendMsg >>>>>> OSD",0);
        msg(getOsdMsgStr(message),0);
    }
    else
    {
    	msg("SendMsg >>>>>> PH",0);
        msg(getPHMsgStr(message),0);
    }
    #endif

    return gmd_TRUE;
}

//******************************************************************************
//	DESCRIPTION	:	Retreves a BYTE message to the circular queue.
//	SYNTAX     	:	BYTE GetMsg(MsgQueueType *queue)
//	PARAMETERS	:	Pointer to desired message queue.
//  RETURN		:	Returns next message in queue or 0x00 if no message.
//******************************************************************************
BYTE GetMsg(MsgQueueType *queue)
{
    BYTE msg;

    if(!queue->Size)
        return (QUEUE_EMPTY);

    queue->Size--;
    msg = queue->Queue[queue->Tail];

    queue->Tail++;
    if(queue->Tail >= MAX_MSG_QUEUE_SIZE)
        queue->Tail = 0;

	return (msg);
}
//******************************************************************************
//	DESCRIPTION	:	Checks to see if there's a message pending.
//	SYNTAX     	:	BYTE GetMsg(MsgQueueType *queue)
//	PARAMETERS	:	Pointer to desired message queue.
//  RETURN		:	Returns gmd_TRUE/gmd_FALSE
//******************************************************************************
gmt_RET_STAT IsMsg(MsgQueueType *queue)
{
	 if(!queue->Size)
		  return gmd_FALSE;

	  return gmd_TRUE;
}

#if DEBUG_QUE && DEBUG_MSG
char far* getOsdMsgStr(BYTE message)
{
	switch(message)
	 {
		case MTO_POWER_ON           :
        	return "MTO_POWER_ON";
		case MTO_POWER_STANDBY      :
        	return "MTO_POWER_STANDBY";
		case MTO_POWER_SUSPEND      :
        	return "MTO_POWER_SUSPEND";
		case MTO_POWER_DOWN_NOTICE  :
        	return "MTO_POWER_DOWN_NOTICE";
		case MTO_POWER_DOWN         :
        	return "MTO_POWER_DOWN";
		case MTO_NO_SYNC            :
        	return "MTO_NO_SYNC";
		case MTO_NO_CABLE           :
        	return "MTO_NO_CABLE";
		case MTO_VALID_MODE         :
        	return "MTO_VALID_MODE";
		case MTO_MODE_CHANGE        :
        	return "MTO_MODE_CHANGE";
		case MTO_OUT_OF_RANGE       :
        	return "MTO_OUT_OF_RANGE";
		case MTO_SUBSAMPLE          :
        	return "MTO_SUBSAMPLE";
		case MTO_SPLASH_SCREEN      :
        	return "MTO_SPLASH_SCREEN";
		case MTO_AUTO_ADJ           :
        	return "MTO_AUTO_ADJ";
		case MTO_SYNC_STANDBY       :
        	return "MTO_SYNC_STANDBY";
		case MTO_SYNC_SUSPEND       :
			return "MTO_SYNC_SUSPEND";
		case MTO_REQ_HARD_POWER_DOWN       :
			return "MTO_REQ_HARD_POWER_DOWN";
      case MTO_INPUT_RGB:
			return  "MTO_INPUT_RGB";
      case MTO_INPUT_DVI:
			return  "MTO_INPUT_DVI";
      case MTO_START_AUTO:
			return  "MTO_START_AUTO";
      case MTO_AUTO_COMPLETE:
			return  "MTO_AUTO_COMPLETE";
      case MTO_AUTO_SUCCESS:
			return  "MTO_AUTO_SUCCESS";
      case MTO_AUTO_FAILED:
			return  "MTO_AUTO_FAILED";
        default :
        	return "unknown";
    }
}
char far* getPHMsgStr(BYTE message)
{
	switch(message)
    {
		case MTP_SOFTKEY_OFF :
        	return "MTP_SOFTKEY_OFF";
		case MTP_SOFTKEY_ON  :
        	return "MTP_SOFTKEY_ON";
		case MTP_POWER_DOWN  :
        	return "MTP_POWER_DOWN";
        default :
        	return "unknown";
    }
}
#endif