smt.c

GM5621原代码

	{
		msgs("ERROR: Transaction was not opened due to Port 0x%X is invalid",W_Port);
		SMT_SendFailed(comm_use, EvOdd, GENERIC_ER);
		return;	
	}

	//define transaction ID
	for(W_Index =0; W_Index <=255; W_Index++)
	{
		B_LastId++ ;
		// check if transaction with this ID is not opened yet
		for( B_Count =0; B_Count <MAX_TRANSACTION_NUMBER; B_Count++ )
		{
			if((SMT_TransArray[B_Count].B_Status == TRANSACTION_OPENED) &&
			   (SMT_TransArray[B_Count].ID == B_LastId)) 
			 break;
		}
		// continue if ID used
		if(B_Count == MAX_TRANSACTION_NUMBER) 
			break;
	}

	if(W_Index > 255)
	{
		msgs("ERROR: Can not find ID for this transaction ",0);
		SMT_SendFailed(comm_use, EvOdd, GENERIC_ER);
		return; 
	}
	
   msgs("Open Transaction: Port = 0x%d ",W_Port);

   SMT_TransArray[CurrentTransNumber].ID       = B_LastId;
   SMT_TransArray[CurrentTransNumber].Port     = W_Port;
   SMT_TransArray[CurrentTransNumber].Bp_Buff  = NULL_PTR;
   SMT_TransArray[CurrentTransNumber].BuffSize = 0;
   SMT_TransArray[CurrentTransNumber].B_Status = TRANSACTION_OPENED;
   SMT_TransArray[CurrentTransNumber].W_Count  = 0;
   SMT_TransArray[CurrentTransNumber].B_CurCmd = IDLE_CMD;

   // Sending response:

   OutMsg.len    = 6;
   OutMsg.cmd    = CMD_SMTProtocol;
   OutMsg.BUF[0] = CM_TM_BIT | EvOdd;
   OutMsg.BUF[1] = TRANSACTION_OPENED;
   OutMsg.BUF[2] = SMT_TransArray[CurrentTransNumber].ID;

   gm_TimerStart(SMT_TransArray[CurrentTransNumber].B_TmrNum, SMT_TRANSACTION_TIMEOUT );
   msgs("Transaction OPENED, ID = 0x%x ",SMT_TransArray[CurrentTransNumber].ID);
   msgs("Transaction OPENED, NUM = 0x%x ",CurrentTransNumber);

   gm_CommsSendReply((gmt_MsgStruct far*)&OutMsg, comm_use);
}

//******************************************************************************
//
// FUNCTION     :   void SMT_CloseTransaction(BYTE msgpkt[], BYTE comm_use, BYTE EvOdd)
// USAGE        :   This function close transaction and send response to PC
//
// INPUT        :   BYTE msgpkt[] = msgpkt array from SMT message
//                  BYTE comm_use  = SERIAL_USE or DDC2BI_USE
//                  BYTE EvOdd = Even/Odd message count
// OUTPUT       :   None
//
//******************************************************************************
void SMT_CloseTransaction(BYTE msgpkt[], BYTE comm_use, BYTE EvOdd)
{
   BYTE TransID;
   BYTE CurrentTransNumber = 0xFF;
   BYTE B_Count;

   TransID = msgpkt[0];

   for(B_Count =0; B_Count <MAX_TRANSACTION_NUMBER; B_Count++)
   {
      if(SMT_TransArray[B_Count].ID == TransID)
      {
	  	   if(SMT_TransArray[B_Count].B_Status != TRANSACTION_CLOSED)
            CurrentTransNumber = B_Count;
         break;
      }
   }
   msgs("CloseTransaction(). Transaction table index = %d ",CurrentTransNumber);
   if(CurrentTransNumber == 0xFF)
   {
	   msgs("ERROR: Invalid Transaction ID - NOT FOUND TRANSACTION WITH THIS ID  = %x ",TransID);
      SMT_SendFailed(comm_use, EvOdd, TRANS_ID_ER);
      return;
   }

   if(SMT_TransArray[CurrentTransNumber].B_Status == TRANSACTION_CLOSED)// what if trasaction is in a BUSY state?
   {																	//WHY? may be just close trasaction without checking status?
      // Send Failed
      msgs("ERROR: Invalid Transaction ID ",0);
      SMT_SendFailed(comm_use, EvOdd, TRANS_ID_ER);
      return;
   }
   SMT_TransArray[CurrentTransNumber].Port     = 0;
   SMT_TransArray[CurrentTransNumber].Bp_Buff  = NULL_PTR;
   SMT_TransArray[CurrentTransNumber].BuffSize = 0;
   SMT_TransArray[CurrentTransNumber].B_Status = TRANSACTION_CLOSED;
   SMT_TransArray[CurrentTransNumber].W_Count  = 0;


   OutMsg.len     = 6;
   OutMsg.cmd     = CMD_SMTProtocol;
   OutMsg.BUF[0]  = CM_TM_BIT | EvOdd;
   OutMsg.BUF[1]  = TRANSACTION_CLOSED;
   OutMsg.BUF[2]  = SMT_TransArray[CurrentTransNumber].ID;

   msgs("Transaction 0x%x was closed.",OutMsg.BUF[2]);
   SMT_TransArray[CurrentTransNumber].ID = 0;

   gm_TimerStop(SMT_TransArray[CurrentTransNumber].B_TmrNum);

   gm_CommsSendReply((gmt_MsgStruct far*)&OutMsg, comm_use);
}

//******************************************************************************
//
// FUNCTION     :   void SMT_SendStatusSMT(BYTE msgpkt[], BYTE comm_use, BYTE EvOdd)
// USAGE        :   This function send status of transaction to PC
//
// INPUT        :   BYTE msgpkt[] = msgpkt array from SMT message
//                  BYTE comm_use  = SERIAL_USE or DDC2BI_USE
//                  BYTE EvOdd = Even/Odd message count
// OUTPUT       :   None
//
//******************************************************************************
void SMT_SendStatusSMT(BYTE msgpkt[], BYTE comm_use, BYTE EvOdd)
{
   BYTE TransID;
   BYTE CurrentTransNumber = 0xFF;
   BYTE B_Count;

   TransID = msgpkt[0];

   for(B_Count =0; B_Count <MAX_TRANSACTION_NUMBER; B_Count++)
   {
      if(SMT_TransArray[B_Count].ID == TransID)
      {
         CurrentTransNumber = B_Count;
         break;
      }
   }
   msgs("Transaction table index = = %d ",CurrentTransNumber);
   if(CurrentTransNumber == 0xFF)
   {
      msgs("ERROR: Invalid Transaction ID - NOT FOUND TRANSACTION WITH THIS ID  = %x ",TransID);
      SMT_SendFailed(comm_use, EvOdd, TRANS_ID_ER);
      return;
   }

   OutMsg.len    = 7;
   OutMsg.cmd    = CMD_SMTProtocol;
   OutMsg.BUF[0] = CM_TM_BIT | EvOdd;
   OutMsg.BUF[1] = GET_STATUS_CMD;
   OutMsg.BUF[2] = TransID;
   OutMsg.BUF[3] = SMT_TransArray[CurrentTransNumber].B_Status;

   gm_TimerStart(SMT_TransArray[CurrentTransNumber].B_TmrNum, SMT_TRANSACTION_TIMEOUT );

   gm_CommsSendReply((gmt_MsgStruct far*)&OutMsg, comm_use);
}

//******************************************************************************
//
// FUNCTION     :   void SMT_SendFailed(BYTE comm_use, BYTE EvOdd, BYTE B_Reason)
// USAGE        :   This function send response "Failed" to PC
//
// INPUT        :   BYTE comm_use  = SERIAL_USE or DDC2BI_USE
//                  BYTE EvOdd = Even/Odd message count
//                  BYTE B_Reason = The reason of fail
// OUTPUT       :   None
//
//******************************************************************************
void SMT_SendFailed(BYTE comm_use, BYTE EvOdd, BYTE B_Reason)
{

   OutMsg.len    = 6;
   OutMsg.cmd    = CMD_SMTProtocol;
   OutMsg.BUF[0] = CM_TM_BIT | EvOdd;
   OutMsg.BUF[1] = FAILED;
   OutMsg.BUF[2] = B_Reason;

   OldEvOdd = 0xFF;
   gm_CommsSendReply((gmt_MsgStruct far*)&OutMsg, comm_use);
}

//******************************************************************************
//
// FUNCTION     :   void SMT_SendReTransmit(BYTE TransID, BYTE comm_use, BYTE EvOdd, WORD W_Delay_ms)
// USAGE        :   This function send Re-Transmit command to PC
//
// INPUT        :   BYTE TransID = Transition ID
//                  BYTE comm_use  = SERIAL_USE or DDC2BI_USE
//                  BYTE EvOdd = Even/Odd message count
//                  WORD W_Delay_ms = Delay in ms 
// OUTPUT       :   None
//
//******************************************************************************
void SMT_SendReTransmit(BYTE TransID, BYTE comm_use, BYTE EvOdd, WORD W_Delay_ms)
{
	BYTE B_Count;
   comm_use = comm_use;
	
	for(B_Count =0; B_Count <MAX_TRANSACTION_NUMBER; B_Count++)
	{
	   if(SMT_TransArray[B_Count].ID == TransID)
	   {
		  break;
	   }
	}
   OutMsg.len    = 8;
   OutMsg.cmd    = CMD_SMTProtocol;
   OutMsg.BUF[0] = CM_TM_BIT | EvOdd;
   OutMsg.BUF[1] = RE_TRANSMIT_CMD;
   OutMsg.BUF[2] = TransID;
   OutMsg.BUF[3] = W_Delay_ms & 0xFF;
   OutMsg.BUF[4] = (W_Delay_ms >> 8) & 0xFF;
   gm_TimerStart(SMT_TransArray[B_Count].B_TmrNum, SMT_TRANSACTION_TIMEOUT );

   gm_CommsSendReply((gmt_MsgStruct far*)&OutMsg, comm_use);
}



//******************************************************************************
//
// FUNCTION     :   BYTE SMT_MessageHandler(MsgPacket_t *message, BYTE comm_use)
// USAGE        :   This function parse the SMT messages
//
// INPUT        :   MsgPacket_t *message = SMT message
//                  BYTE comm_use  = SERIAL_USE or DDC2BI_USE
// OUTPUT       :   0 = if no error, 1 = if error is found
//
//******************************************************************************

BYTE SMT_MessageHandler(MsgPacket_t * message, BYTE comm_use)
{
   BYTE EvOdd;
   BYTE B_Count;
   WORD W_PortID;
   WORD W_TblIndex;

	// delay for overwork VB script problem
//	gm_Delay10ms(10);
	//Initiate transaction context table SMT_TransArray if it is first transaction.
    //TODO: Initiator must be modified if more possible transaction statuses are added
	if((SMT_TransArray[0].B_Status!=TRANSACTION_CLOSED) && 
	   (SMT_TransArray[0].B_Status!=TRANSACTION_OPENED))
	{
		for(B_Count =0; B_Count <MAX_TRANSACTION_NUMBER; B_Count++)
		{
			SMT_TransArray[B_Count].ID = 0xFF;
			SMT_TransArray[B_Count].B_Status = TRANSACTION_CLOSED;
			SMT_TransArray[B_Count].B_TmrNum = SMT_TIMEOUT_0_TMR + B_Count;
		}
	}		

   if ((message->msgType & CM_TM_BIT))
   	if (message->control == OPEN_TRANSACTION_CMD)
      {
   		OldEvOdd = 0xFF;
      }

   EvOdd = message->msgType & EVEN_ODD_BIT;

   if((OldEvOdd == 0xFF) || (OldEvOdd != EvOdd))
   {
      OldEvOdd = EvOdd;
   }
   else
   {
      if(OldEvOdd == EvOdd)
      {
         SMT_SendFailed(comm_use, EvOdd, CORRUPT_MSG_ER);
         msgs("ERROR OF SMT: Even/Odd message count is wrong.",0);
         return 1;
      }
   }
// close expired transactions
	for(B_Count =0; B_Count <MAX_TRANSACTION_NUMBER; B_Count++)
	{
		if((SMT_TransArray[B_Count].B_Status != TRANSACTION_CLOSED) &&
		   (gm_TimerCheck(SMT_TransArray[B_Count].B_TmrNum) == gmd_TMR_TIMED_OUT))
		{
			SMT_TransArray[B_Count].B_Status = TRANSACTION_CLOSED;
			msgs("Transaction 0x%X is closed because of timeout ",SMT_TransArray[B_Count].ID);
		}
	}
//parse message
   if(message->msgType & CM_TM_BIT)      // Is it a Control Message ?
   {
      msgs("Message Control = %d ",message->control);
      switch(message->control)      // Yes
      {
         case OPEN_TRANSACTION_CMD:  // Open Transaction
            SMT_OpenTransaction(message->msgpkt, comm_use, EvOdd);
            break;
         case CLOSE_TRANSACTION_CMD: // Close Transaction
            SMT_CloseTransaction(message->msgpkt, comm_use, EvOdd);
			//sweng0328: Fix Media Processor bug
			gm_WriteRegByte(ACC_SNAP_SLOPE, 0x88);
			gm_WriteRegByte(ACC_TOTAL_PIXEL, 0x0D);
			
            break;
         case GET_STATUS_CMD:       // Get Status
            SMT_SendStatusSMT(message->msgpkt, comm_use, EvOdd);
            break;
         default:
		 	msgs("ERROR: Unknown Message Control Code = %d ",message->control);
            SMT_SendFailed(comm_use, EvOdd, CORRUPT_MSG_ER);
            return 1;
      };
   }
   else		// This is a Transport Message
   {
      //WORD W_CMD;
      BYTE B_Count;
      BYTE CurrentTransNumber = 0xFF;

      for(B_Count =0; B_Count <MAX_TRANSACTION_NUMBER; B_Count++)
      {
         if(SMT_TransArray[B_Count].ID == message->control)
         {
            CurrentTransNumber = B_Count;
            break;
         }
      }

      if(CurrentTransNumber == 0xFF)
      {
		   msgs("ERROR: Invalid Transaction ID - NOT FOUND TRANSACTION WITH THIS ID	= %x ",message->control);
         SMT_SendFailed(comm_use, EvOdd, TRANS_ID_ER);
         return 1;
      }
	  
      if(SMT_TransArray[CurrentTransNumber].B_Status != TRANSACTION_OPENED)
      {
         msgs("ERROR: Invalid Transaction ID. THIS TRANSACTION IS NOT OPENED. = %x ",message->control);
         SMT_SendFailed(comm_use, EvOdd, TRANS_ID_ER);
         return 1;
      }

      // Get port ID numnber
      W_PortID = SMT_TransArray[CurrentTransNumber].Port;

      // Call an apprpriate Port Handler depending on Port ID 
      for(W_TblIndex =0;;W_TblIndex++)
      {
         //look for port ID in the handlers LUT
         WORD W_TblPort = SMT_Port2HandlerTable[W_TblIndex].PortID;

         //End of LUT is reached?
         if(W_TblPort < MAX_SMTPORT)
         {
            // Is it desirted port?
            if(W_PortID == W_TblPort)
            {
               // Is the pointer to handler valid?
               if(SMT_Port2HandlerTable[W_TblIndex].Fp_SMT_MsgHandler != NULL_PTR)
               {
                  // execute the handler
                  msgs("Transport message to port 0x%X",W_PortID);
                  gm_TimerStart(SMT_TransArray[CurrentTransNumber].B_TmrNum, SMT_TRANSACTION_TIMEOUT);
                  SMT_Port2HandlerTable[W_TblIndex].Fp_SMT_MsgHandler(message, comm_use);
                  return 0;
               }
               else
                  break; // port is not supported
            }
            // continue
         }
         else 
            break; // end of table is reached
      }

      //treat situation when no port id is found in the hadlers LUT
      msgs("ERROR: Port 0x%X is not supported.",W_PortID);
      SMT_SendFailed(comm_use, EvOdd, GENERIC_ER);
      return 1;
   }

   return 0;
}

//******************************************************************************
//
// FUNCTION     :   BYTE SMT_GetBuffer(BYTE  B_TransactionID, BYTE far * Bp_Buff, WORD W_Size)
// USAGE        :   This function allocates memory for parsers
//
// INPUT        :   MsgPacket_t *message = SMT message
//                  BYTE comm_use = SERIAL_USE or DDC2BI_USE
//
// OUTPUT       :   0 = if no error and buffer is free, 1 = if no error and buffer has data from previous messages
//					0xFF if error;
//
//******************************************************************************
BYTE SMT_GetBuffer(BYTE  B_TransactionID,  BYTE far * far * Bp_Buff, WORD W_Size)
{
	BYTE B_Index;
	BYTE B_RetCode = NEXT_REQUEST;

	//check requested memory size
	if(W_Size <= SMT_MAX_BUF_SIZE)
	{
	//look for transaction ID
 		for(B_Index =0; B_Index <MAX_TRANSACTION_NUMBER; B_Index++)
		{
			if(SMT_TransArray[B_Index].ID == B_TransactionID)
			{
				if(SMT_TransArray[B_Index].Bp_Buff == NULL_PTR)
				{
					//pointer is null when it is a first transport message
					//write buffer pointer to transaction structure and return 0
					SMT_TransArray[B_Index].Bp_Buff = (BYTE far *)&SMT_TransArray[B_Index].Ba_Buff[0];
					SMT_TransArray[B_Index].BuffSize = W_Size;
					B_RetCode = FIRST_REQUEST;
				}
				*Bp_Buff = (BYTE far *)SMT_TransArray[B_Index].Bp_Buff;
				return B_RetCode;
 			}
		}
	}
	return NO_MEMORY;// memory allocating error
}

#endif //Debug
#endif //USE_SMT