void testHash256()
{
INT32 i;
UINT32 hash[SHA256_HASH_SIZE] = { 0 };
UINT32 data[128] = { 0 };
for (i = 0; i < sizeof(data)/sizeof(data[0]); i++)
{
data[i] = i;
}
if(OK != SHA256Hash((UINT32)data, sizeof(data), hash))
{
print_info("\r\nsha256 err!");
}
else
{
for (i = 0; i < SHA256_HASH_SIZE; i++)
{
print_info_with_u32("\r\n 1: ", hash[i]);
}
}
if(OK != SHA256Hash((UINT32)data, sizeof(data), hash))
{
print_info("\r\nsha256 err!");
}
else
{
for (i = 0; i < SHA256_HASH_SIZE; i++)
{
print_info_with_u32("\r\n 2: ", hash[i]);
}
}
}
* 返 回 值 :
*
* 其它说明 :
*
*****************************************************************************/
INT32 handerExecDataPkt( apDlCtrlS *pstDlCtrl )
{
INT32 iRet;
int BOOT_RST_Addr;
if(!pstDlCtrl->bComplete)
{
(void)sendRepPkt(pstDlCtrl, REP_FILE_RECV_ERR);
return ERROR;
}
iRet = apSecChk(pstDlCtrl->ulAddress);
if(SEC_SUCCESS == iRet
||SEC_EFUSE_NOT_WRITE == iRet)
{
#ifdef START_TIME_TEST
print_info_with_u32("\r\ntime(ms):", (TIMER5_INIT_VALUE - INREG32(TIMER5_REGOFF_VALUE))/MS_TICKS);
#endif
ocrShareSave();
(void)sendRepPkt(pstDlCtrl, REP_ACK);
/* 不再返回 */
BOOT_RST_Addr = *(volatile UINT32 *)(pstDlCtrl->ulAddress + BOOT_RST_ADDR_OFFEST);
go((FUNCPTR)(pstDlCtrl->ulAddress + BOOT_RST_Addr));
}
else
{
/* 发送校验失败,等待AP复位,不再返回 */
/*****************************************************************************
* 函 数 名 : apSecChk
*
* 功能描述 : AP封装的安全校验函数
*
* 输入参数 :
* 输出参数 :
*
* 返 回 值 :
*
* 其它说明 :
*
*****************************************************************************/
INT32 apSecChk( UINT32 ulImgAddr )
{
INT32 iRet;
volatile tOcrShareData *pShareData = (tOcrShareData *)M3_TCM_SHARE_DATA_ADDR;
if(BL_CHECK_INSTRUCTION != *(volatile UINT32 *)(ulImgAddr + BL_CHECK_ADDR_OFFSET))
{
/* 镜像未烧入或错误镜像,返回错误供调用者处理 */
print_info("\r\nimage not program!" );
return SEC_NO_IMAGE;
}
if(!pShareData->bSecEn)
{
print_info("\r\nUnSec_boot!" );
return SEC_SUCCESS;
}
iRet = secCheck(ulImgAddr, IMAGE_TYPE_BOOTLOAD);
switch(iRet)
{
case SEC_SUCCESS:
/*安全校验通过*/
print_info("\r\nSec check ok!" ); /*lint !e616*/
break;
/* 进入下一case运行BootLoader */
case SEC_EFUSE_NOT_WRITE: /*lint !e825*/ /*EFUSE 未烧写*/
break;
case SEC_SHA_CALC_ERROR:
/* Hash计算不通过 */
case SEC_OEMCA_ERROR:
/* OEM CA校验不通过 */
case SEC_IMAGE_ERROR: /* 映像校验不通过 */
case SEC_ROOT_CA_ERROR:
/* 根CA校验错误 */
case SEC_IMAGE_LEN_ERROR:/*安全版本长度错误*/
print_info("\r\nSec check err!" );
break;
case SEC_EFUSE_READ_ERROR:
/*Efuse读取失败,使用看门狗复位,再次尝试读取*/
print_info("\r\nEfuse read err, reboot...");
/* Efuse读取失败,复位单板 */
setErrno(SYS_ERR_EFUSE_READ);
wdtRebootDelayMs(TIME_DELAY_MS_2000_FOR_EFUSE_READERR);
break;
default:
while(1) /*lint !e716*/
{
print_info_with_u32("\r\nunhandered ret:",(UINT32)iRet);
delay(1000*1000); /* 延时1s */
}
/*break; */ /*for pc lint*/
/*****************************************************************************
* 函 数 名 : nandReadBl
*
* 功能描述 : 根据实际长度读取BootLoader
*
* 输入参数 : dest BootLoader读取的目的地
* 输出参数 :
*
* 返 回 值 : OK 读取成功
* NAND_ECC_ERR ECC出现不可纠正的错误
* SEC_IMAGE_LEN_ERROR 长度错误
*
* 其它说明 :
*
*****************************************************************************/
int nandReadBl( UINT32 dest )
{
UINT32 blLen;
UINT32 ulEccType;
/* 配置IO复用,NAND取默认配置。*/
NF_IOS_SYS_CONFIG();
/* 配置脉宽为16 */
OUTREG32(NANDC_PWIDTH, 0x555);
delay(10);
/* 检查是否为Boot模式,如果不是,则直接重启,再次尝试读取 */
if(NANDC_OPMODE_BOOT != (INREG32(NANDC_CON) & NANDC_OPMODE_MASK))
{
print_info("\r\nnot in boot mode,reboot to try...");
setErrno(NAND_NO_IN_BOOTMODE);
wdtRebootDelayMs(TIME_DELAY_MS_6000_FOR_NF_OPBOOT);
}
/* 获取BootLoader长度 */
blLen = *(volatile UINT32 *)(FLASH_BOOT_ADDR+BL_LEN_INDEX);
/* 获取ECC Type */
ulEccType = INREG32(NANDC_CON) & NAND_ECC_TYPE_MASK;
/* 使能ECC情况下,产生ECC不可纠正的错误 */
if((NAND_ECC_TYPE_0 != ulEccType)
&& (INREG32(NANDC_INTS) & ECC_ERR_INVALID))
{
print_info("\r\necc err!");
return NAND_ECC_ERR;
}
/* 判断长度是否合法:不为零/字对齐/不翻转/不过大 */
/* 0x1234ABCD - read retry failed */
/* 0xABCD1234 - all block(0 to 7) is bad */
if((0 == blLen)
|| (blLen % 4)
|| (blLen + IDIO_LEN + OEM_CA_LEN + IDIO_LEN < blLen)
|| (blLen + IDIO_LEN + OEM_CA_LEN + IDIO_LEN > BOOTLOAD_SIZE_MAX))
{
print_info_with_u32("\r\nBL len err:", blLen);
return SEC_IMAGE_LEN_ERROR;
}
/* 加上镜像签名、OEM CA和OEM CA签名的长度 (安全校验时才添加)*/
blLen += IDIO_LEN + OEM_CA_LEN + IDIO_LEN;
delay(10);
/* Boot模式下直接读取整个BootLoader */
memcpy((void*)dest, (void*)FLASH_BOOT_ADDR, blLen);
return OK;
}
void testEfuseRead()
{
INT32 i, ret;
UINT32 value = 0;
for (i = 0; i < 8; i++)
{
ret =efuseRead(i, &value, 1);
if (ret)
{
print_info_with_u32("\r\nefuse read error, ret = ", ret);
}
else
{
print_info_with_u32("\r\nvalue = ", value);
}
}
}
* 返 回 值 :
*
* 其它说明 :
*
*****************************************************************************/
apDlStatusE apDlRecvPkt(apDlCtrlS *pstDlCtrl)
{
INT32 iRet;
UINT8 ucRecv;
//print_info("\r\nwait for a pkt...");
while(1) /*lint !e716*/
{
/* 每次处理一个字符 */
iRet = hsUartRecvData(pstDlCtrl->pstHsUartBuf, &ucRecv, 1);
if(HSUART_RECV_TIMEOUT == iRet)
{
return AP_DL_RECV_TIMEOUT;
}
else if(ERROR == iRet)
{
print_info_with_u32("hsuart recv err: ", (UINT32)iRet);
return AP_DL_ERR_RECV;
}
//print_info_with_u32(" ", (UINT32)ucRecv);
iRet = HDLC_Decap(pstDlCtrl->pstHdlcCtrl, ucRecv);
/* 完整接收一包数据,返回OK */
if(HDLC_OK == iRet)
{
return AP_DL_ERR_OK;
}
else if(HDLC_ERR_BUF_FULL == iRet)
{
print_info("\r\nhdlc buf full!");
return AP_DL_BUF_FULL;
/*****************************************************************************
* 函 数 名 : secBoot
*
* 功能描述 : 安全启动C入口函数
*
* 输入参数 :
* 输出参数 :
*
* 返 回 值 :
*
* 其它说明 :
*
*****************************************************************************/
void secBoot(void)
{
volatile UINT32 ulBootModeVal = 0x00;
volatile tOcrShareData *pShareData = (tOcrShareData*)M3_SRAM_SHARE_DATA_ADDR;
int retVal = 0x00;
int BOOT_RST_Addr = 0x00;
#if PLATFORM==PLATFORM_PORTING
//testEfuseRead();
//testHash256();
#endif
/* 初始化 */
timerInit();
pShareData->errno = 0;
pShareData->SHA256Hash = NULL;
pShareData->RSA = NULL;
pShareData->idioIdentify = NULL;
pShareData->bSecEn = FALSE;
pShareData->bRootCaInited = FALSE;
pShareData->pRootKey = NULL;
pShareData->ulOcrInitedFlag = FALSE;
pShareData->bsp_nand_get_spec_and_save = NULL;
/* 读取Efuse安全校验配置，获取安全标志 */
if(EFUSEC_SEC_EN == (INREG32(EFUSEC_HW_CFG) & EFUSEC_SEC_EN_MASK))
{
pShareData->bSecEn = TRUE;
}
/*判断USB自举软件标志是否有效*/
if((AUTO_ENUM_FLAG_VALUE == pShareData->ulEnumFlag)
|| (SC_AUTO_ENUM_EN == (INREG32(SC_STAT0) & SC_AUTO_ENUM_EN_BITMASK)))
{
/* 软标志有效或自举管脚为低电平，先清除标志,再进入自举流程*/
/*pShareData->ulEnumFlag = 0;*/ /* 不清除标志,供探针程序检查自举原因 */
usbBoot();
}
/*读取BOOTMODE*/
ulBootModeVal = INREG32(SC_STAT0) & SC_BOOTMODE_BITMASK;
switch(ulBootModeVal)
{
case BOOT_MODE_NAND_ID:
{
print_info("\r\nNF id boot!" );
retVal = nandReadBl(M3_TCM_BL_ADDR, NAND_PARSE_ID_MODE, &(pShareData->nandspec));
break;
}
case BOOT_MODE_NAND_BOOT:
{
print_info("\r\nNF boot only!" );
/* Nand默认在Boot模式下,直接拷贝bootload映像 */
retVal = nandReadBl(M3_TCM_BL_ADDR, ONLY_NAND_BOOT_MODE, &(pShareData->nandspec));
break;
}
case BOOT_MODE_NAND_EFUSE:
{
print_info("\r\nNF efuse boot!" );
retVal = nandReadBl(M3_TCM_BL_ADDR, EFUSE_BOOT_MODE, &(pShareData->nandspec));
break;
}
#if HSIC_CONFIG==YES
case BOOT_MODE_AP_HSIC:
{
print_info("\r\nHSIC boot!" );
/*通过HSIC将bootload映像读取*/
hsicBoot();
break;
}
#endif
#if SPI_CONFIG==YES
case BOOT_MODE_SPI:
{
print_info("\r\nSPI boot!" );
/*从SPI中将bootload映像读取*/
retVal = spiDevReadBl((UINT8*)M3_TCM_BL_ADDR);
break;
}
#endif
#if EMMC_CONFIG==YES
case BOOT_MODE_EMMC:
{
print_info("\r\nEMMC boot!" );
/*搬运bootload映像*/
retVal = emmc_read_bootloader(M3_TCM_BL_ADDR);
break;
}
#endif
#if HSUART_CONFIG==YES
case BOOT_MODE_AP_HSUART:
{
print_info("\r\nHSUART boot!" );
/* 不再返回 */
retVal = apDlMain(M3_TCM_BL_ADDR);
/* 防止apDlMain返回,这里打印错误 */
print_info_with_u32("\r\napDlMain exec err, ret:" , (UINT32)retVal);
setErrno(SYS_ERR_AP_DL_RETURNS);
/* 延时复位 */
wdtRebootDelayMs(TIME_DELAY_MS_4000_FOR_AP_RETURNS);
break; /*lint !e527*/
}
#endif
default:
{
#if PLATFORM==PLATFORM_PORTING
/* PORTING版本使用此模式烧写EFUSE */
print_info_with_u32("\r\nbootmode err, will write efuse on porting..." , ulBootModeVal);
testEfuseWrite();
usbBoot();
break;
#else
/* 复位,以防止Stick形态没有串口,从复位可以得知错误 */
print_info_with_u32("\r\nbootmode err:" , (ulBootModeVal>>SC_BOOTMODE_BITPOS));
setErrno(SYS_ERR_BOOT_MODE);
/* 延时复位 */
wdtRebootDelayMs(TIME_DELAY_MS_3000_FOR_BOOT_MODE);
break;
#endif
}
}
if(OK != retVal)
{
print_info_with_u32("\r\nBL read err, ret:", (UINT32)retVal);
setErrno(retVal);
usbBoot();
}
/*判断FLASH /E2/MMC是否烧入映像*/
if(BL_CHECK_INSTRUCTION != *(volatile UINT32 *)BL_CHECK_ADDR)
{
/*映像未烧入，向AP返回Nack, 或跳入USB自举流程*/
print_info("\r\nimage not program!" );
setErrno(SEC_NO_IMAGE);
usbBoot();
}
ocrShareSave();
/*非安全启动，直接运行*/
if(!pShareData->bSecEn)
{
print_info("\r\nUnSec_boot!" );
/*非安全，跳入TCM执行*/
BOOT_RST_Addr = *(volatile UINT32 *)BOOT_RST_ADDR_PP;
go((FUNCPTR)(M3_TCM_BL_ADDR + BOOT_RST_Addr));
}
/*安全启动，进行安全校验*/
retVal = secCheck((UINT32)M3_TCM_BL_ADDR, IMAGE_TYPE_BOOTLOAD);
#ifdef START_TIME_TEST
print_info_with_u32("\r\ntime(ms):", (TIMER5_INIT_VALUE - INREG32(TIMER5_REGOFF_VALUE))/MS_TICKS);
#endif
switch(retVal)
{
case SEC_SUCCESS:
/*安全校验通过*/
print_info("\r\nSec check ok!" ); /*lint !e616*/
/* 进入下一case运行BootLoader */
case SEC_EFUSE_NOT_WRITE: /*lint !e825*/ /*EFUSE 未烧写*/
/* 跳到TCM mem执行BOOTLOAD */
BOOT_RST_Addr = *(volatile UINT32 *)BOOT_RST_ADDR_PP;
go((FUNCPTR)(M3_TCM_BL_ADDR + BOOT_RST_Addr));
break;
case SEC_SHA_CALC_ERROR:
/* Hash计算不通过 */
case SEC_OEMCA_ERROR:
/* OEM CA校验不通过 */
case SEC_IMAGE_ERROR: /* 映像校验不通过 */
case SEC_ROOT_CA_ERROR:
/* 根CA校验错误 */
case SEC_IMAGE_LEN_ERROR:/*安全版本长度错误*/
print_info("\r\nSec check err!" );
setErrno(retVal);
usbBoot();
break;
case SEC_EFUSE_READ_ERROR:
/*Efuse读取失败,使用看门狗复位,再次尝试读取*/
print_info("\r\nEfuse read err, reboot...");
setErrno(SYS_ERR_EFUSE_READ);
wdtRebootDelayMs(TIME_DELAY_MS_2000_FOR_EFUSE_READERR);
break;
default:
print_info_with_u32("\r\nunhandered ret:",(UINT32)retVal);
setErrno(SYS_ERR_SEC_UNKNOWN_RET);
/* 延时1s */
wdtRebootDelayMs(TIME_DELAY_MS_5000_FOR_SEC_UNKNOWN_RET);
/*break; */ /*for pc lint*/
}
/*****************************************************************************
* 函 数 名 : secCheck
*
* 功能描述 : 安全校验总入口
*
* 输入参数 : ulImageAddr--映像地址,必须字对齐
* eImageTye--镜像类型
* 输出参数 :
*
* 返 回 值 : SEC_IMAGE_LEN_ERROR 镜像长度过长
* SEC_EFUSE_READ_ERROR Efuse读取错误
* SEC_EFUSE_NOT_WRITE Efuse未烧写
* SEC_SHA_CALC_ERROR SHA计算错误
* SEC_ROOT_CA_ERROR 根CA校验错误
* SEC_OEMCA_ERROR OEM CA校验错误
* SEC_IMAGE_ERROR 镜像签名校验错误
*
* 其它说明 :
*
*****************************************************************************/
int secCheck(UINT32 ulImageAddr, IMAGE_TYPE_E eImageTye)
{
int i;
UINT32 blLen = 0;
KEY_STRUCT *pstKeyRoot;
KEY_STRUCT *pstKeyBl; /*映像的公钥*/
UINT32 sha256HashCa[SHA256_HASH_SIZE]; /*用来存放SHA256值的临时buffer*/
UINT32 md5HashEfuse[MD5_HASH_SIZE]; /*用来存放SHA256值的MD5值的临时buffer*/
UINT32 md5HashCa[MD5_HASH_SIZE]; /*用来存放SHA256值的MD5值的临时buffer*/
UINT32 imageIdioAddr; /*镜像的签名的地址*/
UINT32 imageCaAddr; /*映像的CA的地址*/
UINT32 imageCaIdioAddr; /*映像的CA签名的地址*/
MD5_CTX md5_contex;
volatile tOcrShareData *pShareData = (tOcrShareData*)M3_SRAM_SHARE_DATA_ADDR;
/*获取bootload.bin文件的长度(字节数)*/
if(IMAGE_TYPE_DOWNLOAD != eImageTye)
{
blLen = *(volatile UINT32 *)(ulImageAddr+BL_LEN_INDEX);
}
else
{
blLen = *(volatile UINT32 *)(ulImageAddr+DOWNLOAD_BL_LEN_INDEX);
}
/* 判断长度是否合法:不为零/字对齐/不翻转/不过大 */
if((0 == blLen)
|| (blLen % 4)
|| (blLen + IDIO_LEN + OEM_CA_LEN + IDIO_LEN < blLen)
|| ((IMAGE_TYPE_DOWNLOAD != eImageTye) /* 若为USB自举版本，无需校验版本长度 */
&& (blLen + IDIO_LEN + OEM_CA_LEN + IDIO_LEN > BOOTLOAD_SIZE_MAX)))
{
print_info_with_u32("\r\nSec image len err: 0x", blLen);
return SEC_IMAGE_LEN_ERROR;
}
/* 获取镜像签名的位置 */
imageIdioAddr = ulImageAddr + blLen;
/* 获取OEM CA的位置 */
imageCaAddr = imageIdioAddr + IDIO_LEN;
/* 获取OEM CA签名的位置 */
imageCaIdioAddr = imageCaAddr + OEM_CA_LEN;
/* 根CA已经在RAM初始化程序中校验通过，加载程序不需再校验根CA */
if(IMAGE_TYPE_DOWNLOAD != eImageTye)
{
/* 读取Efuse中的根CA的Hash值 */
if(OK != efuseRead(EFUSE_GRP_ROOT_CA, md5HashEfuse, MD5_HASH_SIZE))
{
print_info("\r\nEfuse read err!");
return SEC_EFUSE_READ_ERROR;
}
/* 检查Efuse是否已烧写 */
if(EFUSE_NOT_WRITED == efuseWriteCheck(md5HashEfuse, MD5_HASH_SIZE))
{
pShareData->bRootCaInited = FALSE;
pShareData->bSecEn = FALSE; /* Efuse未烧写,无法获得根CA不使能安全校验 */
print_info("\r\nEfuse not write, sec will be disabled!" );
return SEC_EFUSE_NOT_WRITE;
}
pstKeyRoot = (KEY_STRUCT *)(ulImageAddr + ROOT_CA_INDEX);
/* 计算根公钥的Hash值 */
if(OK != SHA256Hash((UINT32)pstKeyRoot, ROOT_CA_LEN, sha256HashCa))
{
print_info("\r\nsha256 err!");
return SEC_SHA_CALC_ERROR;
}
MD5Init(&md5_contex);
MD5Update(&md5_contex, (unsigned char *)sha256HashCa, sizeof(sha256HashCa));
MD5Final(&md5_contex, (unsigned char*)md5HashCa);
/* 比较根公钥的Hash值 */
for(i=0; i<MD5_HASH_SIZE; i++)
{
if(md5HashEfuse[i] != md5HashCa[i])
{
print_info("\r\nRoot CA check err!");
return SEC_ROOT_CA_ERROR;
}
}
/* 保存根公钥，共享给BootLoader */
pShareData->pRootKey = pstKeyRoot;
pShareData->bRootCaInited = TRUE;
}
else
{
/* 防止未运行RAM初始化程序就直接运行USB加载程序 */
if(!pShareData->bRootCaInited)
{
print_info("root ca not inited!");
return SEC_ROOT_CA_ERROR;
}
}
/*鉴权映像证书*/
if(OK != idioIdentify(imageCaAddr, OEM_CA_LEN, pShareData->pRootKey, (UINT32*)imageCaIdioAddr))
{
print_info("\r\nOEM CA check err!" );
return SEC_OEMCA_ERROR;
}
/*鉴权bootload映像*/
pstKeyBl = (KEY_STRUCT *)imageCaAddr;
if(OK != idioIdentify(ulImageAddr, blLen, pstKeyBl, (UINT32*)imageIdioAddr))
{
print_info("\r\nimage check err!" );
return SEC_IMAGE_ERROR;
}
return SEC_SUCCESS;
}
* 返 回 值 :
*
* 其它说明 :
*
*****************************************************************************/
apDlStatusE apDlMain( UINT32 ulFileAddr )
{
INT32 iRet;
UINT8 ucPktType;
apDlCtrlS stApDlCtrl;
RECV_STR stHsRecvStr;
DLOAD_HDLC_S stHdlcCtrl;
apDlCtrlS *pstApDlCtrl = &stApDlCtrl;
pstApDlCtrl->pstHdlcCtrl = &stHdlcCtrl;
pstApDlCtrl->pstHsUartBuf = &stHsRecvStr;
apDlInit(pstApDlCtrl);
/* OnChipRom V7R1 通过HSUART下载的BootLoader或烧写引导程序放在固定位置运行 */
pstApDlCtrl->ulAddress = ulFileAddr;
while(1) /*lint !e716*/
{
iRet = apDlRecvPkt(pstApDlCtrl);
switch(iRet)
{
case AP_DL_BUF_FULL:
/* never return */
sendRepErrWaitReset(pstApDlCtrl, REP_FILE_RECV_BUF_FULL);
break;
case AP_DL_RECV_TIMEOUT:
/* never return */
(void)sendRepPkt(pstApDlCtrl, REP_FILE_RECV_TIMEOUT);
break;
case AP_DL_ERR_OK:
break;
default:
continue;
}
ucPktType = pstApDlCtrl->pstHdlcCtrl->au8DecapBuf[PKT_TYPE_OS];
//print_info_with_u32("\r\nrecv a pkt, type:", ucPktType);
switch(ucPktType)
{
/* 握手包,发送Ack */
case PKT_TYPE_CONNECT:
(void)sendRepPkt(pstApDlCtrl, REP_ACK);
iRet = OK;
break;
case PKT_TYPE_BAUD_SET:
{
iRet = handerBaudSetPkt(pstApDlCtrl);
break;
}
/* 执行指令,如果是从Flash直接启动命令,则不再返回 */
case PKT_TYPE_AP_CMD:
{
iRet = handerApCmdPkt(pstApDlCtrl);
break;
}
case PKT_TYPE_STAT_DATA:
{
iRet = handerStartDataPkt(pstApDlCtrl);
break;
}
case PKT_TYPE_MIDST_DATA:
iRet = handerMidstDataPkt(pstApDlCtrl);
break;
case PKT_TYPE_END_DATA:
iRet = handerEndDataPkt(pstApDlCtrl);
break;
/* 执行命令,不再返回 */
case PKT_TYPE_EXEC_DATA:
iRet = handerExecDataPkt(pstApDlCtrl);
break;
default:
/* 包类型错误,返回Nack */
break;
}
if(OK != iRet)
{
print_info_with_u32("\r\nhanderPkt err: ", (UINT32)iRet);
/*****************************************************************************
* 函 数 名 : hsUartSetBaud
*
* 功能描述 : HS UART设置波特率接口函数
*
* 输入参数 : UINT32 u32BaudRate 需要设置的波特率
*
* 输出参数 : 无
* 返 回 值 : OK 成功
* ERROR 失败
*
* 修改记录 :2011年7月15日 鲁婷 创建
*****************************************************************************/
HSUART_STATUS hsUartSetBaud(UINT32 u32BaudRate)
{
UINT32 u32Divisor = 0;
UINT32 u32DivisorLow = 0;
UINT32 u32DivisorHigh = 0;
UINT32 u32Discard = 0;
UINT32 u32Times = 0;
/* 计算分频比 */
switch(u32BaudRate)
{
case BAUDRATE_115200:
u32Divisor = HSUART_CLOCK_FREQ / (16 * BAUDRATE_115200);
break;
case BAUDRATE_9600:
u32Divisor = HSUART_CLOCK_FREQ / (16 * BAUDRATE_9600);
break;
case BAUDRATE_1M:
u32Divisor = HSUART_CLOCK_FREQ / (16 * BAUDRATE_1M);
break;
case BAUDRATE_2M:
u32Divisor = HSUART_CLOCK_FREQ / (16 * BAUDRATE_2M);
break;
case BAUDRATE_3M:
u32Divisor = HSUART_CLOCK_FREQ / (16 * BAUDRATE_3M);
break;
case BAUDRATE_4M:
u32Divisor = HSUART_CLOCK_FREQ / (16 * BAUDRATE_4M);
break;
default:
print_info_with_u32("\r\nbaudrate error baud :",u32BaudRate);
return HSUART_STATUS_BAUTRATE_ERR;
break; /*lint !e527*/
}
#if 0 /* 不会走到该分支 */
/* 判断是否支持该分频比 */
if(u32Divisor == 0)
{
print_info("\r\not support baudrate\r\n");
return HSUART_STATUS_BAUTRATE_ERR;
}
#endif
u32DivisorHigh = (u32Divisor&0xFF00) >> 8;
u32DivisorLow = u32Divisor&0xFF;
/* 读取UART 状态寄存器，看UART是否处于idle状态*/
u32Discard = INREG32(HSUART_BASE_ADDR + UART_USR);
while((u32Discard & 0x01)&&(u32Times<HSUUART_DELAY_TIMES))/*uart is busy*/
{
u32Discard = INREG32(HSUART_BASE_ADDR + UART_USR);
u32Times++;
delay(100);
}
if(HSUUART_DELAY_TIMES == u32Times)
{
print_info("\r\nhsuart busy\r\n");
return HSUART_STATUS_BAUTRATE_ERR;
}
/* USR bit[0]=0 即UART 处在idle 态时，才能对LCR bit[7]该位进行写操作*/
OUTREG32(HSUART_BASE_ADDR + UART_LCR, UART_DEF_LCR_DIVENABLE);
/* 配置DLH 和DLL 寄存器，设置分频比*/
OUTREG32(HSUART_BASE_ADDR + UART_DLL, u32DivisorLow);
OUTREG32(HSUART_BASE_ADDR + UART_DLH, u32DivisorHigh);
/* 配置外围发送和接收数据的数目为8bit,1停止位,无校验位,disable DLL&DLH */
OUTREG32(HSUART_BASE_ADDR + UART_LCR, UART_DEF_PARITY_NONE|UART_DEF_LCR_STP1|UART_DEF_LCR_CS8);
return HSUART_STATUS_OK;
}
