drv_852smc.c

motorola mpc系列 mpc852cpu bsp

void Drv_Smc1InitReg( void )
{
    DrvStruc_S *pDrvStruct;

    pDrvStruct = &Serial_DrvInfo[0];

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

    /* 配置串口波特率, Div16 = 0, divider = 324, enable */
/*    *BRGC1(DEFAULT_IMMR_ADRS) = (gSMC1BautRate | 0x10000);*/

    *BRGC3(DEFAULT_IMMR_ADRS) = 0x10000 + ( (BAUD_RATE_VALUE(gSMCBautRate))<<1 );
/*    *BRGC3(DEFAULT_IMMR_ADRS) = 0x10000 + ( ((FREQ_50_MHZ/ (16*9600)) - 1)<<1 );
    *BRGC3(DEFAULT_IMMR_ADRS) = 0x10000 + ( ((64800000/ (16*9600)) - 1)<<1 );
*/
    *SIMODE(DEFAULT_IMMR_ADRS) &=  (0xffff0fff);
    *SIMODE(DEFAULT_IMMR_ADRS) |=  (DRV_SMC1_SIMODE_NMSI | DRV_SMC1_SIMODE_CS_BRG3);


    /* 取得SMC1的基址 */
/* gpSmcUartParam = (SMC_UART_PARAM_RAM*)(PPC860_DPR_SMC1(DPRAM(DEFAULT_IMMR_ADRS)));*/
    gpSmcUartParam = (SMC_UART_PARAM_RAM*)(DEFAULT_IMMR_ADRS+0x3e80);

    gpSmcUartParam->RBASE = (_U16)(M852_SMC1_RX_BD_BUFF - DEFAULT_IMMR_ADRS);
    gpSmcUartParam->TBASE = (_U16)(M852_SMC1_TX_BD_BUFF - DEFAULT_IMMR_ADRS);
/* gpSmcUartParam->RBASE = (short)(pDrvStruct->RBDBase - (_U32)DEFAULT_IMMR_ADRS);
 gpSmcUartParam->TBASE = (short)(pDrvStruct->TBDBase - (_U32)DEFAULT_IMMR_ADRS);
*/

    /* SMC1, flg reference to 19.5.2 of 860UM.pdf*/
    *CPCR(DEFAULT_IMMR_ADRS) = 0x0091;
    while ((*CPCR(DEFAULT_IMMR_ADRS) & 0x0001) != 0)
        ;

    *SDCR(DEFAULT_IMMR_ADRS) = DRV_SMC_SDCR_RAID_BR5;

    /* big edian */
    gpSmcUartParam->RFCR = 0x18;
    gpSmcUartParam->TFCR = 0x18;

    /* 定义接收buffer长度 */
    gpSmcUartParam->MRBLR = 1;

    /* 定义字符间延迟 */
    gpSmcUartParam->MAX_IDL = 1;

    gpSmcUartParam->BRKCR = 1;
    gpSmcUartParam->BRKEC = 0;
    gpSmcUartParam->BRKLN = 0;


#if ( SMC_TXINT || SMC_RXINT )
        /* 清事件 */
        *SMCE1(DEFAULT_IMMR_ADRS) = 0xFF;

	#if ( SMC_TXINT && SMC_RXINT )
        /* 打开接收发送中断 */
        *SMCM1(DEFAULT_IMMR_ADRS) = 0x57;
	#elif SMC_RXINT
        /* 打开接收中断 */
        *SMCM1(DEFAULT_IMMR_ADRS) |= 0x55;
	#elif SMC_TXINT
        /* 打开发送中断 */
        *SMCM1(DEFAULT_IMMR_ADRS) |= 0x56;
	#else
        /* 关闭所有中断 */
        *SMCM1(DEFAULT_IMMR_ADRS) = 0x00;
	#endif

        *CISR(DEFAULT_IMMR_ADRS) |= CISR_SMC1;
        *CIPR(DEFAULT_IMMR_ADRS) |= CIPR_SMC1;
        *CIMR(DEFAULT_IMMR_ADRS) |= CIMR_SMC1;
#else
        /* 清事件 */
        *SMCE1(DEFAULT_IMMR_ADRS) = 0xFF;

        /* 关闭所有中断 */
        *SMCM1(DEFAULT_IMMR_ADRS) = 0x00;
#endif

/*    *CICR(DEFAULT_IMMR_ADRS) = 0;
    *CIPR(DEFAULT_IMMR_ADRS) = 0xFFFFFFFF;
    *CIMR(DEFAULT_IMMR_ADRS) = 0;
*/
    /* 8位模式, 无校验, 1位停止位, uart模式, 正常操作(无环回) */
    *SMCMR1(DEFAULT_IMMR_ADRS) = 0x4820;

     return;
}



_U32 Drv_Smc1GetRegStatus( char *pData )
{

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

    sprintf(pData, "\r\n SMC1 driver register status:");

    sprintf(pData + strlen(pData), "\r\n SMC1 BASE : 0x%lx",
        (_U32)PPC860_DPR_SMC1(DPRAM(DEFAULT_IMMR_ADRS)));
    sprintf(pData + strlen(pData), "\r\n BRGC1 : 0x%x",
        *BRGC3(DEFAULT_IMMR_ADRS));
    sprintf(pData + strlen(pData), "\r\n RBASE : 0x%x",
        gpSmcUartParam->RBASE);
    sprintf(pData + strlen(pData), "\r\n TBASE : 0x%x",
        gpSmcUartParam->TBASE);
    sprintf(pData + strlen(pData), "\r\n RFCR  : 0x%x",
	    gpSmcUartParam->RFCR);
    sprintf(pData + strlen(pData), "\r\n TFCR  : 0x%x",
	    gpSmcUartParam->TFCR);
    sprintf(pData + strlen(pData), "\r\n MRBLR : 0x%x",
		gpSmcUartParam->MRBLR);
    sprintf(pData + strlen(pData), "\r\n MAX_IDL: 0x%x",
        gpSmcUartParam->MAX_IDL);
    sprintf(pData + strlen(pData), "\r\n BRKLN : 0x%x",
        gpSmcUartParam->BRKLN);
    sprintf(pData + strlen(pData), "\r\n BRKEC : 0x%x",
        gpSmcUartParam->BRKEC);
    sprintf(pData + strlen(pData), "\r\n BRKCR : 0x%x",
        gpSmcUartParam->BRKCR);
    sprintf(pData + strlen(pData), "\r\n SMCE1 : 0x%x",
        *SMCE1(DEFAULT_IMMR_ADRS));
    sprintf(pData + strlen(pData), "\r\n SMCM1 : 0x%x",
        *SMCM1(DEFAULT_IMMR_ADRS));
    sprintf(pData + strlen(pData), "\r\n SMCMR1 : 0x%x",
        *SMCMR1(DEFAULT_IMMR_ADRS));

    return SUCCESS;

}





static void Drv_SmcInitRxBDs( _U32 u32Channel )
{
    SerBD *pBD;
    _U32 BDindex;
    unsigned char *pBuf = NULL;
    DrvStruc_S *pDrvStruct;

    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return ;
    }

    pDrvStruct = &Serial_DrvInfo[u32Channel];
    /*be careful!we should set the RBDBase is the full address!*/
    pBD = (SerBD *)pDrvStruct->RBDBase;
    pDrvStruct->CurRBDPoint = (_U32)pBD;

/*
 pBuf = (unsigned char *)(pDrvStruct->RBDBase + pDrvStruct->RBDSize*sizeof(SerBD));
*/
    pBuf = (unsigned char *)(M852_SMC1_RX_BUFF);

    for( BDindex = 0; BDindex < pDrvStruct->RBDSize; BDindex++ )
    {
        pBD->bd_length = 0;    /* reset */
        pBD->bd_addr   = pBuf++;

        if( BDindex != (pDrvStruct->RBDSize - 1) )
        {
#if SMC_RXINT
            pBD->bd_cstatus = 0x9000; /*0x8000; */  /* Empty */  /* Empty */
#else
            pBD->bd_cstatus = 0x8000; /*0x8000; */  /* Empty */  /* Empty */
#endif
        }
        else
        {
#if SMC_RXINT
            pBD->bd_cstatus = 0xB000;   /* Empty, Wrap */ 
#else
            pBD->bd_cstatus = 0xA000;   /* Empty, Wrap */ 
#endif
        }
        pBD++;
    }
    return;
}


static void Drv_SmcInitTxBDs(_U32 u32Channel)
{
    SerBD *pBD;
    _U8 BDindex;
    unsigned char *pBuf = NULL;
    DrvStruc_S *pDrvStruct;

    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return ;
    }

    pDrvStruct = &Serial_DrvInfo[u32Channel];
    pBD = (SerBD *)pDrvStruct->TBDBase;
    pDrvStruct->CurTBDPoint = (_U32)pBD;

/*
 pBuf = (unsigned char *)(pDrvStruct->TBDBase + pDrvStruct->TBDSize*sizeof(SerBD));
*/
    pBuf = (unsigned char *)(M852_SMC1_TX_BUFF);

    for( BDindex = 0; BDindex < pDrvStruct->TBDSize; BDindex++ )
    {
        pBD->bd_length = 0;    /* reset */
        pBD->bd_addr   = pBuf++;

        if( BDindex != (pDrvStruct->TBDSize - 1) )
        {
            pBD->bd_cstatus = 0x0000;
        }
        else
        {
            pBD->bd_cstatus = 0x2000;
        }
        pBD++;
    }
    return;
}


void Drv_SmcSetBaut( _U32 u32Channel, _U32 BautRate )
{
    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return;
    }

    if( gSMCBautRate != BautRate )
    {
        gSMCBautRate = BautRate;

        *BRGC3(DEFAULT_IMMR_ADRS) = 0x10000 + (BAUD_RATE_VALUE(gSMCBautRate)<<1) + 1;
    }

    return;
}


_U32 Drv_SmcGetBaut( _U32 u32Channel )
{
    if( u32Channel >= MAX_SERIAL_DRIVER_NUM )
    {
        return 0;
    }
    return gSMCBautRate;
}



_U32 Drv_SmcPutChar( _U8 u8Type,_U32 u32Channel, unsigned char ucData )
{
    SerBD *pCurTxBD;
    _U32 BDIndex, WaitCount = 0;
    DrvStruc_S *pDrvStruct;

    if( u8Type != VPL_SERIAL )
    {
        return FAILURE;
    }

    pDrvStruct = &Serial_DrvInfo[u32Channel];

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

    /*等待当前BD空*/
    while( (pCurTxBD->bd_cstatus & 0x8000)&&(WaitCount++ < DRV_SMC_TX_MAX_WAIT_COUNT) )
    {
    }

    if( WaitCount >= DRV_SMC_TX_MAX_WAIT_COUNT )
    {
        return FAILURE;
    }

    *(pCurTxBD->bd_addr)  = ucData;
    pCurTxBD->bd_length   = 1;

    if( BDIndex == (pDrvStruct->TBDSize - 1) )
    {
#if SMC_TXINT
        pCurTxBD->bd_cstatus |= 0xB000;/*0xa000;*/
#else
        pCurTxBD->bd_cstatus |= 0xA000;/*0xa000;*/
#endif
        pDrvStruct->CurTBDPoint = pDrvStruct->TBDBase;
    }
    else
    {
#if SMC_TXINT
        pCurTxBD->bd_cstatus |= 0x9000; /*  0x8000;*/
#else
        pCurTxBD->bd_cstatus |= 0x8000; /*  0x8000;*/
#endif
        pCurTxBD++;
        pDrvStruct->CurTBDPoint = (_U32)pCurTxBD;
    }
    
    return SUCCESS;
}

_U32 Drv_SmcGetChar( _U8 u8Type, _U32 u32Channel, unsigned char *ucData )
{
#if SMC_RXINT
	(void)u32Channel;/*pclint*/
#else
    SerBD *pCurRxBD;
    _U32 BDIndex;
/* _U32 WaitCount = 0;*/
    DrvStruc_S *pDrvStruct;

#endif
    (void)u8Type;/*pclint*/

#if SMC_RXINT
	return Drv_SmcGetData( u32Channel, ucData );
#else
    pDrvStruct = &Serial_DrvInfo[u32Channel];

    pCurRxBD = (SerBD *)pDrvStruct->CurRBDPoint;
    BDIndex  = (pDrvStruct->CurRBDPoint - pDrvStruct->RBDBase)/sizeof(SerBD);

/*
    while( (pCurRxBD->bd_cstatus & 0x8000) && (WaitCount++ < DRV_SMC_RX_MAX_WAIT_COUNT) )
        ;
*/
    
    if( (pCurRxBD->bd_cstatus & 0x8000) != 0 )
    {
        return G_FAILURE;
    }


    *ucData = *(pCurRxBD->bd_addr);

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

    return SUCCESS;

#endif
}

_U32 Drv_SerialIOctrl(_U16 u16Cmd, _U32 pData)
{
    return Drv_SmcIOctrl(VPL_SERIAL, 0, u16Cmd, pData);
}

_U32 Drv_SmcIOctrl(_U8 u8Type,_U32 u32Channel, _U16 u16Cmd, _U32 pData)
{
    if( (u32Channel>=MAX_SERIAL_DRIVER_NUM) || (u8Type!=VPL_SERIAL) )
    {
        return FAILURE;
    }

    switch( u16Cmd )
    {
        case DRV_SERIAL_SETBAUT:
            if( pData == 0 )
            {
                return FAILURE;
            }
            Drv_SmcSetBaut( u32Channel, pData );
            break;
            
        case DRV_SERIAL_GETBAUT:
            *(_U32 *)pData = Drv_SmcGetBaut( u32Channel );
            break;
            
        default:
            return FAILURE;
    }
    return SUCCESS;
}


_U32 Drv_SmcIOctrlSelf( _U8 u8Type, _U32 u32Channel , _U16 u16Cmd, _U32 pData )
{
#ifndef MAKE_BOOTROM 
    _U32 ulSucNum = 0, ulFailNum = 0;
#endif

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

    switch( u16Cmd )
    {
        case DRV_SERIAL_SETBAUT:
            if( pData == 0 )
            {
                return FAILURE;
            }

            Drv_SmcSetBaut( u32Channel, pData );
            return SUCCESS;

        case DRV_SERIAL_GETBAUT:
            *(_U32 *)pData = Drv_SmcGetBaut(u32Channel);
            return SUCCESS;

        case DRV_SERIAL_REG_STATUS:
            if( u32Channel == 0 )
            {
                Drv_Smc1GetRegStatus( (char *)pData );
            }

            return SUCCESS;

        case DRV_SERIAL_PUT_CHAR:
            Drv_SmcPutChar( VPL_SERIAL, u32Channel, pData );
            return SUCCESS;

        case DRV_SERIAL_SEND_ENABLE:
            Drv_SmcTxEnable(u32Channel);
            return SUCCESS;

        case DRV_SERIAL_RECEIVE_ENABLE:
            Drv_SmcRxEnable(u32Channel);
            return SUCCESS;

        case DRV_SERIAL_SEND_DISABLE:
            Drv_SmcTxDisable(u32Channel);
            return SUCCESS;

        case DRV_SERIAL_RECEIVE_DISABLE:
            Drv_SmcRxDisable(u32Channel);
            return SUCCESS;

        case DRV_SERIAL_INIT:
            Drv_SmcInitReg( u32Channel );
            return SUCCESS;

#ifndef MAKE_BOOTROM /*一下宏内为测试代码*/
        case DRV_SERIAL_SEND_TEST:
            g_DecCount = *( (_U32 *)pData );

            while( 0 != g_DecCount )
            {
                if( G_SUCCESS != Drv_Print( "c" ) )
                {
                    ulFailNum++;
                }
                else
                {
                    ulSucNum++;
                }
            }

            *( (_U32 *)pData + 1 ) = ulSucNum;
            *( (_U32 *)pData + 2 ) = ulFailNum;
            return SUCCESS;
#endif

#if SMC_TXINT
        case DRV_SERIAL_SEND_CC_CHAR:
            Drv_SmcPrint( "cc", 2 );
            return SUCCESS;

        case DRV_SERIAL_RECEIVE_TEST:
            if( SUCCESS == Drv_SmcGetData(u32Channel, (char *)pData ) )
            {
                return SUCCESS;
            }
            else
            {
                return FAILURE;
            }

        case DRV_SERIAL_GET_PARA:
            if (0 == u32Channel)
            {
                Drv_SmcGetSmc1Para( (char *)pData );
            }
            return SUCCESS;
#endif

        default:
            return FAILURE;
    }
}


_U32 Drv_Print(const char *pStr, ...)
{
    va_list Ap;
    char OutStr[1024];
    
    char *pCurChar;
    _U32 ulRet, ulLen = 0;

    
    
    if( gSMC1StartFlag == 0 )
    {
        return FAILURE;
    }
    
    
    if( strlen(pStr) > 1023 )
    {
        return FAILURE;
    }

    va_start(Ap, pStr);
    OutStr[0] = '\0';
    ulRet = vsprintf(OutStr, pStr, Ap);
    va_end(Ap);


    ulRet = SUCCESS;
    ulLen = (_U32)strlen(OutStr);
    pCurChar = OutStr;
	#if SMC_TXINT
	return Drv_SmcPrint( OutStr, ulLen );
	#else
    while( (ulRet == SUCCESS)&&(ulLen != 0) )
    {
        ulRet += (_U32)Drv_SmcPutChar( VPL_SERIAL,0, (_U8)*pCurChar );
        if( *(pCurChar + 1) == '\n' )
        {
            ulRet += (_U32)Drv_SmcPutChar(VPL_SERIAL,0, '\r');
        }
        pCurChar++;
        ulLen--;
    }
	#endif

    return SUCCESS;
}

void InChar ( unsigned char *szString, unsigned long *ret )
{
    int rt;

    rt = Drv_SmcGetChar(VPL_SERIAL,0, szString);
    if( rt == SUCCESS )
        *ret = SUCCESS;
    else
        *ret = FAILURE;

    return;
}

void LoadCtrl_Receive(char *pString, _U32 MaxLength)
{
    _U32 i = 0;
    unsigned char ReadChar;

    while(i <= MaxLength - 1)
    {
        while(Drv_SmcGetChar(VPL_SERIAL,0, &ReadChar)!=SUCCESS)
        {
        }
        switch(ReadChar)
        {
            case 0x0a:
            case 0x0d:
                pString[i] = 0;
                return;
            case 0x08:
            	if (i != 0)
            	{
	            	i--;
	            	(void)Drv_SmcPutChar(VPL_SERIAL,0,ReadChar);

            	}
            	break;
            default:
            	if (i == MaxLength - 1)
            	{
            		break;
            	}
                (void)Drv_SmcPutChar(VPL_SERIAL,0,ReadChar);
                pString[i] = (char)ReadChar;
                i++;
                break;
        }
    }

    pString[MaxLength - 1] = 0;

}