cdr18uat.c

UART驱动程序

       /* simple verification... avoid some syncronization problems */
       if (RX_Buffer[0]!='R') {
            u8_dr18_NbDataRX = 0;   	
       }
  }
}/* p_dr18_UARTSearchCommand */




/* FUNCTIONAL DESCRIPTION
 *
 * This function stop the ring
 *
 * INTERFACE DECLARATION
 */
void p_dr18_UARTRingOFF(void)
{
  p_os10_PutMsgInfo(FTMI_ID,0, PS_RINGER_OFF_IND, 1);	
}/* p_dr18_UARTRingOFF */



/* FUNCTIONAL DESCRIPTION
 *
 * This function start the ring
 *
 * INTERFACE DECLARATION
 */
void p_dr18_UARTRingON(void)
{
  /*I need to send two times the message RINGER_ON because the SMS 
  * doesn't care of the first message*/
  /*only one ring*/
  p_os10_PutMsgInfo(FTMI_ID,0, PS_RINGER_ON_IND, 1);
//  p_os10_PutMsgInfo(FTMI_ID,0, PS_RINGER_OFF_IND, 0);
//  p_os10_PutMsgInfo(FTMI_ID,0, PS_RINGER_ON_IND, 0);
}/* p_dr18_UARTRingON */



#endif /* (NR_IOM_LINES>0) */


#ifdef UART

/* FUNCTIONAL DESCRIPTION
 *
 * This function transmits a sequence of bytes.
 * It does not wait for completion, so the buffer should not be
 * written to immediately after invokation. To be sure, p_dr18_UARTTxWait()
 * may be called.
 * However, only one asynchronous transmission may be scheduled.
 * So it might be possible that an invocation has to wait for
 * completion of a previous one.
 *
 * PARAMETER
 * buf        buffer of bytes to transmit
 * len        number of bytes to transmit (0..254)
 *
 * INTERFACE DECLARATION
 */
void p_dr18_UARTTx(u8 *pu8_Buf, u8 u8_Len)
{
  p_dr18_UARTTxWait();         /* assert: queue is empty      */
  pu8_dr18_UARTTxJob= pu8_Buf; /* queue buffer                */
 
  G_u8_dr08_UARTTxBusy= 1;     /* flag for the outside        */
  
  /* No extra interrupt is used as in the previous implementation. */
  u8_dr18_UARTTxLen= u8_Len; /* store number of TI ints     */
  VOLATILE(sys2_UART.thr,u8) = *pu8_dr18_UARTTxJob++;
} /* p_dr18_UARTTx */

/* FUNCTIONAL DESCRIPTION
 *
 * This function receives and returns a single byte.
 *
 * If currently no byte is present, the function waits.
 * The return type is char as the prototype has to be 
 * compatible to _getkey.
 *
 * PARAMETER
 * return    the byte received
 *
 * INTERFACE DECLARATION
 */
char p_dr18_UARTRcv(void)   /* == _getkey() */
{
  u8 u8_Byt;

  while(!VOLATILE(G_u8_dr08_UARTRcvFlag,u8))
  {
      /* do nothing, wait for UART interrupt */
  }
  
  SYS5_DISABLE_IRQ;
#ifdef DR18_RX_BUFFER_SIZE  
  u16_dr18_RxBufferReadIndex =
               (u16_dr18_RxBufferReadIndex + 1) % DR18_RX_BUFFER_SIZE;
  u8_Byt= u8_dr18_RxBuffer[u16_dr18_RxBufferReadIndex];

  if (DR18_RX_BUFFER_EMPTY)
  {
      /* Backwards compatible to old kbhit */
      G_u8_dr08_UARTRcvFlag= 0;
  }
#else
  u8_Byt= u8_dr18_UARTRcvByte;
  G_u8_dr08_UARTRcvFlag= 0;
#endif
  /* Enable Interrupt */
  SYS5_ENABLE_IRQ;
  return u8_Byt;
} /* p_dr18_UARTRcv */


/* FUNCTIONAL DESCRIPTION
 *
 * This function waits for completion of the current transmission.
 *
 * INTERFACE DECLARATION
 */
void p_dr18_UARTTxWait(void)
{
  while(VOLATILE(u8_dr18_UARTTxLen,u8))
  {
      /* do nothing */
  }
} /* p_dr18_UARTTxWait */

void p_dr18_UARTInterrupt(void)
  
/* For documentation purpose, the following obsolete implementation
   is NOT removed. */
//  if (TI)     /* transmitted indication */
//   {
//       TI= 0;
//       if(u8_dr18_UARTTxLen>1) /* transmit byte */
//       {
// 	  u8_dr18_UARTTxLen--;
// 	  S0BUF= *pu8_dr18_UARTTxJob++;
//       }
//       else /* just confirmed the last byte */
//       {
// 	  u8_dr18_UARTTxLen= 0;
// 	  G_u8_dr08_UARTTxBusy= 0;         /* flag for the outside        */  
//       }
// 
//   }
//   if (RI)     /* received indication */
//   {
//       RI= 0;
//       u8_dr18_UARTRcvByte= S0BUF;
//       G_u8_dr08_UARTRcvFlag= 1;
//   }
{  
  u8 u8_IIR = VOLATILE(sys2_UART.iir,u8);
  u8 u8_LSR;
  
  do {
      u8_IIR = u8_IIR & SYS2_UART_IIR_IID_MASK;
            
      switch (u8_IIR) 
      {
	case SYS2_UART_IIR_IID_P4: //modem interrupt
	  break;
	  
	case SYS2_UART_IIR_IID_P3: //Transmit data register empty

	  /* more data to send ? */
	  if(u8_dr18_UARTTxLen>1)
	  {
	      u8_dr18_UARTTxLen--;
	      VOLATILE(sys2_UART.thr,u8) = *pu8_dr18_UARTTxJob++;
	  }
	  else /* just confirmed the last byte */
	  {
	      u8_dr18_UARTTxLen= 0;
	      G_u8_dr08_UARTTxBusy= 0;  
	  }

	  break;    		

	case SYS2_UART_IIR_IID_P2A: //Receive data available

#ifdef DR18_RX_BUFFER_SIZE
	  if (DR18_RX_BUFFER_FULL)
	  {
	      /* Buffer overflow, discard oldest unread character */
	      u16_dr18_RxBufferReadIndex =
		    (u16_dr18_RxBufferReadIndex + 1)% DR18_RX_BUFFER_SIZE;
	  }
	  u16_dr18_RxBufferWriteIndex =
	           (u16_dr18_RxBufferWriteIndex + 1)% DR18_RX_BUFFER_SIZE;
	  u8_dr18_RxBuffer[u16_dr18_RxBufferWriteIndex] =
	                                       VOLATILE(sys2_UART.rbr,u8);
#endif
	  u8_dr18_UARTRcvByte= VOLATILE(sys2_UART.rbr,u8);
	  G_u8_dr08_UARTRcvFlag= 1;
	  
#ifdef DATA_APP_DEMO
	  /* For the double slot demonstrator, UART is used to
	     communicate with the computer. */
	  p_hm17_RxDemoDataFromUART(u8_dr18_UARTRcvByte);
#endif	  

	  break;
	  
	case SYS2_UART_IIR_IID_P2B: //FIFO timeout
	  break;
	  
	case SYS2_UART_IIR_IID_P1: //Receive line status
	  u8_LSR = VOLATILE(sys2_UART.lsr,u8);
	  break;
	  
	default:
	  break;
      }

      u8_IIR = VOLATILE(sys2_UART.iir,u8);
  } while ((u8_IIR & SYS2_UART_IIR_PENDING)==0);
  
  
}
#endif /* UART */

#if (NR_IOM_LINES>0)
/* FUNCTIONAL DESCRIPTION
 *
 * This function is the UART interrupt handler.
 *
 * INTERFACE DECLARATION
 */
void p_dr18_UARTInterrupt(void)
{  
     u16 IIR      = 0x0000;
  
     IIR = VOLATILE(sys2_UART.iir,u8);

     do {
          IIR = IIR & 0x07;
          IIR = IIR >> 1;
            
          switch (IIR) 
          {
          case 0: //modem interrupt
               break;
          case 1: //Transmit data empty    
               switch (u8_dr18_CmdSend) 
               {
               case HKOF: //send next data HKOF	
                    u8_dr18_NbDataSend++;
                    if(u8_dr18_NbDataSend < DR18_NB_DATA_SEND)
                    {
                         VOLATILE(sys2_UART.thr,u8) = tab_HKOF[u8_dr18_NbDataSend];	
                    }
                    else
                    {
                         u8_dr18_NbDataSend = 0;
                         u8_dr18_CmdSend = 0; 
                         if(u8_dr18_CmdRcvd == RGOF)
                         {
                              delayUs(1000000);
                              p_dr18_UARTDial();   
                         } 
                    }
                    break;
               case HKON: 
                    u8_dr18_CmdRcvd = RGOF;
                    u8_dr18_NbDataSend++;
                    if(u8_dr18_NbDataSend < DR18_NB_DATA_SEND)
                    {
                         VOLATILE(sys2_UART.thr,u8) = tab_HKON[u8_dr18_NbDataSend];	
                    }
                    else
                    {
                         u8_dr18_NbDataSend = 0;
                         u8_dr18_CmdSend = 0;   
                    }
                    break;	  		
               case DIAL: 
                    u8_dr18_NbDataSend++;
                    if(u8_dr18_NbDataSend < DR18_NB_DATA_SEND_DIAL)
                    {
                         VOLATILE(sys2_UART.thr,u8) = tab_DIAL[u8_dr18_NbDataSend];	
                    }
                    else
                    {
                         u8_dr18_NbDataSend = 0;
                         u8_dr18_CmdSend = 0;    							    				
                    }
                    break;	  
               default:
                    break;
               }
               break;    		
               // break; ??
          case 2: //Receive data available
               RX_Buffer[u8_dr18_NbDataRX] = VOLATILE(sys2_UART.rbr,u8);    	
               if (u8_dr18_NbDataRX < DR18_NB_DATA_BUFFER)
                    u8_dr18_NbDataRX++;
               else
                    u8_dr18_NbDataRX=0;
               p_dr18_UARTSearchCommand();        				
               break;    	
          case 3: //Receive line status
               IIR = VOLATILE(sys2_UART.lsr,u8);
               break;
          case 6: //FIFO timeout
               break;
          default:
               break;
          }

          IIR = VOLATILE(sys2_UART.iir,u8);
     } while ((IIR & 0x01)==0);
} /* p_dr18_UARTInterrupt */

/* ####################################################################### */



/* FUNCTIONAL DESCRIPTION
 *
 * This function initializes the IOM driver to
 *
 * INTERFACE DECLARATION
 */
void p_dr18_IOMInit(u8 u8_Master)
{
		
  //configuration of GPIO in mode IOM bus
  VOLATILE(sys2_GPIO.mux1,u32) |= SYS2_GPIO1_IOM_SEL;	
  //selction of a clock divider in function of the speed of arm clock
  VOLATILE(sys0_SCU.clk_div,u32) |= 0x00000100;		
  //activation of the IOM bus
  VOLATILE(sys0_SCU.pb_pcon_on,u32) |= SYS0_SCU_IPINT_POWER_MASK;   
	
	
  /**** Start configuration of the IOM register ********/
  VOLATILE(sys2_IPINT.global,u32) = 0x0000;  
  if(u8_Master == 1)
  {
  	VOLATILE(sys2_IPINT.ipintcntl0,u32) = 
                SYS2_IP_MASTER | SYS2_IP_IOCK | SYS2_IP_IOD_PUSH_PULL_ALWAYS | 
                SYS2_IP_FSTYP_LFS | SYS2_IP_PCM2048khz;  	
  }
  else
  {
  	VOLATILE(sys2_IPINT.ipintcntl0,u32) =  
                SYS2_IP_IOCK | SYS2_IP_IOD_PUSH_PULL_ALWAYS | 
                SYS2_IP_FSTYP_LFS | SYS2_IP_PCM2048khz;
  }
  	
  VOLATILE(sys2_IPINT.ipintcntl1,u32)	= SYS2_IP_SLOT_MASK ;
	
}/* p_dr18_IOMInit */



# if(DAFEATURES & DAF_FSIHOOK_ARM)
void p_arm_customer_fsi_io(s32 *arm_dfl_sb)
{
  s32 s32_Am1 = 0;    
  s32 s32_Data0 = 0x0000;
   
  s32_Am1 = arm_dfl_sb[DSP_SB_AME1_OUTPUT];  //  AME1 output
  VOLATILE(sys2_IPINT.hpout0,u16) = s32_Am1<<8;    
   
  //delayUs(60);  
 
  s32_Data0 = VOLATILE(sys2_IPINT.hpin0,u16);   
  arm_dfl_sb[DSP_SB_AMD1_INPUT] = s32_Data0>>8;   //  AMD1 input      
}

# endif

#else /* (NR_IOM_LINES>0) */

# if(DAFEATURES & DAF_FSIHOOK_ARM)
void p_arm_customer_fsi_io(s32 *arm_dfl_sb)
{
}

# endif

#endif /* (NR_IOM_LINES>0) */