drv_852smc.c

motorola mpc系列 mpc852cpu bsp

#include "Typedef.h"
#include "Bsp.h"
#include "ppc860sio.h"
#include "ads860.h"
#include "config.h"
#include "DPRAMDisp.h"
#include "Drv_852SMC.h"


_U32 g_DecCount=0; 


#if ( SMC_TXINT && SMC_RXINT )
DrvStruc_S Serial_DrvInfo[MAX_SERIAL_DRIVER_NUM] =
{
    {"serial",CPM_SMC1,
        M852_SMC1_RX_BD_BUFF, SMC1_RX_BD_CNT,
        M852_SMC1_TX_BD_BUFF, SMC1_TX_BD_CNT,
        M852_SMC1_RX_BD_BUFF,
        M852_SMC1_TX_BD_BUFF,
        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
        NULL, NULL, Drv_SmcCreate, NULL, NULL, NULL, NULL, Drv_SmcIOctrl,
        NULL
    },
};

#elif SMC_TXINT
DrvStruc_S Serial_DrvInfo[MAX_SERIAL_DRIVER_NUM] =
{
    {"serial",CPM_SMC1,
        M852_SMC1_RX_BD_BUFF, 0x01,
        M852_SMC1_TX_BD_BUFF, SMC1_TX_BD_CNT,
        M852_SMC1_RX_BD_BUFF,
        M852_SMC1_TX_BD_BUFF,
        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
        NULL, NULL, Drv_SmcCreate, NULL, NULL, NULL, NULL, Drv_SmcIOctrl,
        NULL
    },
};


#elif SMC_RXINT
DrvStruc_S Serial_DrvInfo[MAX_SERIAL_DRIVER_NUM] =
{
    {"serial",CPM_SMC1,
        M852_SMC1_RX_BD_BUFF, SMC1_RX_BD_CNT,
        M852_SMC1_TX_BD_BUFF, 0x01,
        M852_SMC1_RX_BD_BUFF,
        M852_SMC1_TX_BD_BUFF,
        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
        NULL, NULL, Drv_SmcCreate, NULL, NULL, NULL, NULL, Drv_SmcIOctrl,
        NULL
    },
};

#else

DrvStruc_S Serial_DrvInfo[MAX_SERIAL_DRIVER_NUM] =
{
    {"serial",CPM_SMC1,
        M852_SMC1_RX_BD_BUFF, SMC1_RX_BD_CNT,
        M852_SMC1_TX_BD_BUFF, SMC1_TX_BD_CNT,
        M852_SMC1_RX_BD_BUFF,
        M852_SMC1_TX_BD_BUFF,
        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
        NULL, NULL, Drv_SmcCreate, NULL, NULL, NULL, NULL, Drv_SmcIOctrl,
        NULL
    },
};


#endif

extern STATUS 	intConnect (VOIDFUNCPTR *vector, VOIDFUNCPTR routine,
	       	    	    int parameter);

extern UINT32 vxImmrGet (void);

extern _U32 gSMC1StartFlag;
extern _U32 g_DecCount;

static void Drv_SmcTxEnable(_U32 u32Channel);
static void Drv_SmcRxEnable(_U32 u32Channel);
void Drv_SmcTxDisable(_U32 u32Channel);
void Drv_SmcRxDisable(_U32 u32Channel);
static void Drv_SmcInitRxBDs(_U32 u32Channel);
static void Drv_SmcInitTxBDs(_U32 u32Channel);

void Drv_Smc1InitReg( void );
void Drv_SmcInitReg( _U32 u32Channel );
void Drv_SmcSetBaut(_U32 u32Channel, _U32 BautRate);
_U32 Drv_SmcGetBaut(_U32 u32Channel);

_U32 Drv_SmcIOctrl(_U8 u8Type,_U32 u32Channel, _U16 u16Cmd, _U32 pData);

/*_U32 gSMCBautRate = 115200;*/

_U32 gSMCBautRate = 9600;

SMC_UART_PARAM_RAM* gpSmcUartParam;


#if ( SMC_TXINT || SMC_RXINT )
STSMCPARA gstSmc1Para;
extern _U32 TickCount;

_U32 Drv_SmcGetSmc1Para( char *pData )
{
    SerBD   *pCurTxBD, *pCurRxBD;
    DrvStruc_S *pDrvStruct;

    if( pData == NULL )
    {
        return FAILURE;
    }

    pDrvStruct = &Serial_DrvInfo[0];
    sprintf( pData, "\r\n SMC1 driver para:" );

    pCurTxBD = (SerBD *)pDrvStruct->CurTBDPoint;
    pCurRxBD = (SerBD *)pDrvStruct->CurRBDPoint;

    sprintf(pData + strlen(pData), "\r\n Send buff addr : 0x%lx",
        (_U32)(gstSmc1Para.ucSmcSendBuff) );
    sprintf(pData + strlen(pData), "\r\n Send head      : 0x%lx",
        gstSmc1Para.ulSmcSendHead );
    sprintf(pData + strlen(pData), "\r\n Send tail      : 0x%lx",
        gstSmc1Para.ulSmcSendTail);
    sprintf(pData + strlen(pData), "\r\n Send status    : 0x%x",
        gstSmc1Para.ucSmcSendStatus);

    sprintf(pData + strlen(pData), "\r\n Send FailTimes : 0x%lx",
        gstSmc1Para.ulTxFailTimes);
    sprintf(pData + strlen(pData), "\r\n Send len       : 0x%lx",
        gstSmc1Para.ulTxLen);

    sprintf(pData + strlen(pData), "\r\n Send INT flag  : 0x%lx",
        gstSmc1Para.ulSmcIntFlag);
    sprintf(pData + strlen(pData), "\r\n Send last tick : 0x%lx",
        gstSmc1Para.ulSmcLastTick);
    sprintf(pData + strlen(pData), "\r\n Send Abnormity : 0x%lx",
        gstSmc1Para.ulSmcAbnormity);

    sprintf(pData + strlen(pData), "\r\n Recv buff addr : 0x%lx",
        (_U32)(gstSmc1Para.ucSmcRecvBuff) );
    sprintf(pData + strlen(pData), "\r\n Recv head      : 0x%lx",
        gstSmc1Para.ulSmcRecvHead);
    sprintf(pData + strlen(pData), "\r\n Recv tail      : 0x%lx",
        gstSmc1Para.ulSmcRecvTail);
    sprintf(pData + strlen(pData), "\r\n Recv status    : 0x%x",
        gstSmc1Para.ucSmcRecvStatus);

    sprintf(pData + strlen(pData), "\r\n RxTx int num   : 0x%lx",
        gstSmc1Para.ulSmcInt);
    sprintf(pData + strlen(pData), "\r\n Rx   int num   : 0x%lx",
        gstSmc1Para.ulSmcRxInt);
    sprintf(pData + strlen(pData), "\r\n Tx   int num   : 0x%lx",
        gstSmc1Para.ulSmcTxInt);
    sprintf(pData + strlen(pData), "\r\n BSY  int num   : 0x%lx",
        gstSmc1Para.ulSmcBSYInt);
    sprintf(pData + strlen(pData), "\r\n BRK  int num   : 0x%lx",
        gstSmc1Para.ulSmcBRKInt);
    sprintf(pData + strlen(pData), "\r\n BRKE int num   : 0x%lx",
        gstSmc1Para.ulSmcBRKEInt);

    sprintf(pData + strlen(pData), "\r\n Tx BD status   : 0x%x",
        pCurTxBD->bd_cstatus );
    sprintf(pData + strlen(pData), "\r\n Tx BD len      : 0x%x",
		pCurTxBD->bd_length );
    sprintf(pData + strlen(pData), "\r\n Tx BD info     : 0x%x",
	    *(pCurTxBD->bd_addr) );

    sprintf(pData + strlen(pData), "\r\n Rx BD status   : 0x%x",
        pCurRxBD->bd_cstatus );
    sprintf(pData + strlen(pData), "\r\n Rx BD len      : 0x%x",
		pCurRxBD->bd_length );
    sprintf(pData + strlen(pData), "\r\n Rx BD info     : 0x%x",
	    *(pCurRxBD->bd_addr) );

    return SUCCESS;

}




static _VOID Drv_SmcParaInit( _U32 u32Channel )
{
    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return;
    }

    memset( &gstSmc1Para, 0x00, sizeof( STSMCPARA ) );
    gstSmc1Para.ucSmcSendBuff   = malloc(SMC1_SEND_BUFF_LEN);
    if( gstSmc1Para.ucSmcSendBuff == NULL ) 
    {
	
    }
    gstSmc1Para.ucSmcRecvBuff   = malloc(SMC1_RECV_BUFF_LEN);
    if( gstSmc1Para.ucSmcRecvBuff == NULL ) 
    {
	
    }
    gstSmc1Para.ucSmcSendStatus = SMC1_IDLE;
    gstSmc1Para.ucSmcRecvStatus = SMC1_IDLE;
    gstSmc1Para.ulSmcIntFlag    = TRUE;

	return;
}

/*计算队列中空闲队列个数*/
static _U32 GetSmc1SendFreeNum( VOID )
{
    _U32     ulFreeBuff;

    if( gstSmc1Para.ulSmcSendTail >= gstSmc1Para.ulSmcSendHead )
    {
        ulFreeBuff = SMC1_SEND_BUFF_LEN - (gstSmc1Para.ulSmcSendTail - gstSmc1Para.ulSmcSendHead + 1);
    }
    else
    {
        ulFreeBuff = gstSmc1Para.ulSmcSendHead - gstSmc1Para.ulSmcSendTail;
    }

    return ulFreeBuff;
}




_U32 GetSmc1RecvFreeNum( VOID )
{
    _U32     ulFreeBuff;

    if( gstSmc1Para.ulSmcRecvTail >= gstSmc1Para.ulSmcRecvHead )
    {
        ulFreeBuff = SMC1_RECV_BUFF_LEN - gstSmc1Para.ulSmcRecvTail + gstSmc1Para.ulSmcRecvHead - 1;
    }
    else
    {
        ulFreeBuff = gstSmc1Para.ulSmcRecvHead - gstSmc1Para.ulSmcRecvTail;
    }

    return ulFreeBuff;
}



_U32 Drv_Smc1GetData( _U8 *pucChar )
{
	*pucChar = G_NULL_BYTE;
	if( gstSmc1Para.ulSmcRecvHead == gstSmc1Para.ulSmcRecvTail )
	{
		return FAILURE;
	}

    *pucChar = gstSmc1Para.ucSmcRecvBuff[gstSmc1Para.ulSmcRecvHead];
	gstSmc1Para.ulSmcRecvHead = ( gstSmc1Para.ulSmcRecvHead + 1 ) % SMC1_RECV_BUFF_LEN;

	return SUCCESS;
}
_U32 Drv_SmcGetData( _U32 u32Channel, _U8 *pucChar )
{
    DrvStruc_S *pDrvStruct;

    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return G_FAILURE;
    }

    return Drv_Smc1GetData(pucChar);
}


_U32 Drv_Smc1Print( _U8 *pucBuff, _U32 ulLen )
{
    _U32    	i, ulRet;
    _U32    	ulFreeBuff;
    _U32    	ulPrintNum;
    _U32    	BDIndex;
    SerBD      *pCurTxBD;
    DrvStruc_S *pDrvStruct;

    _U32        ulCurTick, ulTick = 0;

    ulRet = G_SUCCESS;

    if( ulLen >= SMC1_SEND_BUFF_LEN )
    {
        ulLen = SMC1_SEND_BUFF_LEN - 1;
        
        ulRet = G_FAILURE;
    	gstSmc1Para.ulTxFailTimes++;
    }

    /*一下为保护代码,防止吊死 多次发送强制串口发送*/
    if( gstSmc1Para.ulSmcIntFlag == FALSE )
    {
        ulCurTick = TickCount;
        if( ulCurTick >= gstSmc1Para.ulSmcLastTick )
        {
            ulTick = ulCurTick - gstSmc1Para.ulSmcLastTick;
            if( ulTick > 1 )
            {
                gstSmc1Para.ulSmcAbnormity++;

        	    pDrvStruct = &Serial_DrvInfo[0];

        	    pCurTxBD = (SerBD *)pDrvStruct->CurTBDPoint;
        	    BDIndex  = (pDrvStruct->CurTBDPoint - pDrvStruct->TBDBase)/sizeof(SerBD);

                /*挂BD表，强制发送字符0*/
        	    *(pCurTxBD->bd_addr)  = 0;
        	    pCurTxBD->bd_length   = 1;

        	    if (BDIndex == (pDrvStruct->TBDSize - 1))
        	    {
        	        pCurTxBD->bd_cstatus |= 0xB000;
        	        pDrvStruct->CurTBDPoint = pDrvStruct->TBDBase;
        	    }
        	    else
        	    {
        	        pCurTxBD->bd_cstatus |= 0x9000;
        	        pCurTxBD++;
        	        pDrvStruct->CurTBDPoint = (_U32)pCurTxBD;
        	    }
            }
        }
    }

    gstSmc1Para.ulSmcIntFlag  = FALSE;
    gstSmc1Para.ulSmcLastTick = TickCount;

    ulFreeBuff = GetSmc1SendFreeNum();      	/* 取空闲队列个数*/
    if( ulFreeBuff < ulLen )                	/* 队列已满!!!*/
    {
        ulLen = ulFreeBuff;
        ulRet = G_FAILURE;
    	gstSmc1Para.ulTxFailTimes++;
    }

    /*一下为保护代码,防止吊死 多次发送失败初始化串口*/
    ulPrintNum = ulLen;
	gstSmc1Para.ulTxLen += ulLen;

    for( i = 0; i < ulPrintNum; i++ )       /* 拷贝打印消息*/
    {
        gstSmc1Para.ucSmcSendBuff[ gstSmc1Para.ulSmcSendTail ] = pucBuff[i];
        gstSmc1Para.ulSmcSendTail = ( gstSmc1Para.ulSmcSendTail + 1 ) % SMC1_SEND_BUFF_LEN;
    }

    if( gstSmc1Para.ucSmcSendStatus == SMC1_IDLE )
    {
        gstSmc1Para.ucSmcSendStatus = SMC1_BUSY;

	    pDrvStruct = &Serial_DrvInfo[0];

	    pCurTxBD = (SerBD *)pDrvStruct->CurTBDPoint;
	    BDIndex  = (pDrvStruct->CurTBDPoint - pDrvStruct->TBDBase)/sizeof(SerBD);

        /* 挂BD表*/
	    *(pCurTxBD->bd_addr)  = gstSmc1Para.ucSmcSendBuff[gstSmc1Para.ulSmcSendHead];
	    pCurTxBD->bd_length   = 1;

	    if (BDIndex == (pDrvStruct->TBDSize - 1))
	    {
	        pCurTxBD->bd_cstatus |= 0xB000;
	        pDrvStruct->CurTBDPoint = pDrvStruct->TBDBase;
	    }
	    else
	    {
	        pCurTxBD->bd_cstatus |= 0x9000;
	        pCurTxBD++;
	        pDrvStruct->CurTBDPoint = (_U32)pCurTxBD;
	    }
    }

    return ulRet;
}





_U32 Drv_SmcPrint( _U8 *pucBuff, _U32  ulLen )
{
     if( Drv_Smc1Print(pucBuff, ulLen) == G_FAILURE )
     {
         return G_FAILURE;
     }

     return G_SUCCESS;
}

static _VOID Drv_Smc1IntProc( _VOID )
{
	_U8 	 ucSmcInt;
    _U32    BDIndex;
#if SMC_RXINT
    SerBD   *pCurRxBD;
#endif

#if SMC_TXINT
    SerBD   *pCurTxBD;
#endif

    DrvStruc_S *pDrvStruct;

	gstSmc1Para.ulSmcInt++;

    pDrvStruct = &Serial_DrvInfo[0];


	ucSmcInt = *SMCE1(DEFAULT_IMMR_ADRS);
    *SMCE1(DEFAULT_IMMR_ADRS) = 0xFF;

#if SMC_RXINT
    if( ucSmcInt & 0x01 )
    {
		gstSmc1Para.ulSmcRxInt++;
	    pCurRxBD = (SerBD *)pDrvStruct->CurRBDPoint;
	    BDIndex  = (pDrvStruct->CurRBDPoint - pDrvStruct->RBDBase)/sizeof(SerBD);

		if( (pCurRxBD->bd_cstatus  &  0x8000) == 0 )
		{
			if( 0 != GetSmc1RecvFreeNum() )
			{
				gstSmc1Para.ulSmcRecvTail = ( gstSmc1Para.ulSmcRecvTail + 1 ) % SMC1_RECV_BUFF_LEN;
				gstSmc1Para.ucSmcRecvBuff[ gstSmc1Para.ulSmcRecvTail] = *(pCurRxBD->bd_addr);
			}

	        if (BDIndex == (pDrvStruct->RBDSize - 1))
	        {
	            pCurRxBD->bd_cstatus |= 0xB000;
	            pDrvStruct->CurRBDPoint = pDrvStruct->RBDBase;
	        }
	        else
	        {
	            pCurRxBD->bd_cstatus |= 0x9000;
	            pCurRxBD++;
	            pDrvStruct->CurRBDPoint = (_U32)pCurRxBD;
	        }
		}
    }
#endif

#if SMC_TXINT
    if( ucSmcInt & 0x02 )    /* 发送中断处理*/
    {
        gstSmc1Para.ulSmcIntFlag  = TRUE;

		gstSmc1Para.ulSmcTxInt++;
        gstSmc1Para.ulSmcSendHead = ( gstSmc1Para.ulSmcSendHead + 1 ) % SMC1_SEND_BUFF_LEN;
        if( gstSmc1Para.ulSmcSendHead != gstSmc1Para.ulSmcSendTail )
        {
		    pCurTxBD = (SerBD *)pDrvStruct->CurTBDPoint;
		    BDIndex  = (pDrvStruct->CurTBDPoint - pDrvStruct->TBDBase)/sizeof(SerBD);

            /* 挂BD表*/
		    *(pCurTxBD->bd_addr)  = gstSmc1Para.ucSmcSendBuff[gstSmc1Para.ulSmcSendHead];
		    pCurTxBD->bd_length   = 1;

		    if( BDIndex == ( pDrvStruct->TBDSize - 1 ) )
		    {
		        pCurTxBD->bd_cstatus |= 0xB000;
		        pDrvStruct->CurTBDPoint = pDrvStruct->TBDBase;
		    }
		    else
		    {
		        pCurTxBD->bd_cstatus |= 0x9000;
		        pCurTxBD++;
		        pDrvStruct->CurTBDPoint = (_U32)pCurTxBD;
		    }
        }
        else
        {
            gstSmc1Para.ucSmcSendStatus = SMC1_IDLE;
        }
    }
#endif

    if( ucSmcInt & 0x04 )
    {
        gstSmc1Para.ulSmcBSYInt++;
    }

    if( ucSmcInt & 0x10 )
    {
        gstSmc1Para.ulSmcBRKInt++;
    }

    if( ucSmcInt & 0x40 )
    {
        gstSmc1Para.ulSmcBRKEInt++;
    }

    *CISR(DEFAULT_IMMR_ADRS) |= CISR_SMC1;

}


#endif


_U32 Drv_SmcCreate( _U8 u8Type,_U32 u32Channel )
{
    DrvStruc_S *pDrvStruct;

    if( (u32Channel >= MAX_SERIAL_DRIVER_NUM) || (u8Type != VPL_SERIAL) )
    {
        return FAILURE;
    }
   
   
#if SMC_TXINT
	Drv_SmcParaInit(u32Channel);
#endif

/* SMC1*/
    *PBPAR(DEFAULT_IMMR_ADRS) |=  (PB24|PB25);
    *PBDIR(DEFAULT_IMMR_ADRS) &= ~(PB24|PB25);
    *PBODR(DEFAULT_IMMR_ADRS) &= ~(PB24|PB25);

    pDrvStruct = &Serial_DrvInfo[u32Channel];

    Drv_SmcTxDisable( u32Channel );
    Drv_SmcRxDisable( u32Channel );

    Drv_SmcInitReg( u32Channel );

    Drv_SmcInitRxBDs( u32Channel );
    Drv_SmcInitTxBDs( u32Channel );

    Drv_SmcTxEnable( u32Channel );
    Drv_SmcRxEnable( u32Channel );

#if SMC_TXINT
    intConnect( (VOIDFUNCPTR *)IV_SMC1, Drv_Smc1IntProc, NULL );  /// 0x1d
#endif

    gSMC1StartFlag = 1;

#if 0
    Drv_Print("\r\nSize of SMC_UART_PARAM_RAM = %d(0x%x)", 
               sizeof(SMC_UART_PARAM_RAM), sizeof(SMC_UART_PARAM_RAM) );
#endif
    
    return SUCCESS;
}

static void Drv_SmcTxEnable(_U32 u32Channel)
{
    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return;
    }

    *M852_SMCMR1(DEFAULT_IMMR_ADRS) |= DRV_SMC_TX_ENABLE;

    return;
}

static void Drv_SmcRxEnable(_U32 u32Channel)
{
    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return;
    }

    *M852_SMCMR1(DEFAULT_IMMR_ADRS) |= DRV_SMC_RX_ENABLE;
    
    return;
}


void Drv_SmcTxDisable( _U32 u32Channel )
{
    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return;
    }

    *M852_SMCMR1(DEFAULT_IMMR_ADRS) &= (~DRV_SMC_TX_ENABLE);

    return;
}


void Drv_SmcRxDisable( _U32 u32Channel )
{
    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return;
    }

    *M852_SMCMR1(DEFAULT_IMMR_ADRS) &= (~DRV_SMC_RX_ENABLE);

    return;
}


void Drv_SmcInitReg( _U32 u32Channel )
{
    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return;
    }

    Drv_Smc1InitReg();
    
    return;
}