/*****************************************************************************
* 函 数 名 : BSP_DLOAD_GetProductId
*
* 功能描述 : 获取产品名称字符串
*
* 输入参数 : BSP_S8 *str :字符串缓冲区
* BSP_S32 len :字符串长度
* 输出参数 : BSP_S8 *str :字符串缓冲区
*
* 返 回 值 : DLOAD_ERR_INVALID_PARA :输入参数非法
* VER_ERROR :失败
* 其它 :返回字符串长度
*
* 其它说明 : AT模块调用
* 正常模式支持
* 下载模式支持
*
*****************************************************************************/
BSP_S32 BSP_DLOAD_GetProductId(char *str, BSP_U32 len)
{
static bool b_geted=false;
static char* product_id=NULL;
if((NULL == str) || (len <= 0))
{
ver_print_error("param error!\n");
return VER_ERROR;
}
if(!b_geted){
b_geted=true;
product_id = bsp_version_get_dloadid();
}
if(!product_id)
{
ver_print_error("get product dload ID failed !\n");
return VER_ERROR;
}
strncpy(str,product_id,len);
return VER_OK;
}
/*****************************************************************************
* 函 数 名 : BSP_DLOAD_GetSoftwareVer
* 功能描述 : 获取软件版本号
* 输入参数 :
BSP_S8 *str : 字符串缓冲区
* BSP_S32 len : 字符串长度
* 输出参数 :
BSP_S8 *str : 字符串缓冲区
* 返 回 值 :
BSP_ERROR : 输入参数非法
* 其它 : 返回字符串长度
* 其它说明 : AT模块调用
* 正常模式支持
* 下载模式支持
*****************************************************************************/
BSP_S32 BSP_DLOAD_GetSoftwareVer(char *str, BSP_U32 len)
{
static bool b_geted=false;
static char* software_ver=NULL;
if((NULL == str) || (len <= 0))
{
ver_print_error("param error!\n");
return VER_ERROR;
}
if(!b_geted){
b_geted=true;
software_ver = bsp_version_get_firmware();
}
if(!software_ver)
{
ver_print_error("get software version failed !\n");
return VER_ERROR;
}
strncpy(str,software_ver,len);
return VER_OK;
}
BSP_S32 BSP_DLOAD_GetISOVer(char *pVersionInfo,BSP_U32 ulLength)
{
static bool b_geted = false;
static char* iso_ver=NULL;
if(VERSION_MAX_LEN>ulLength||NULL==pVersionInfo){
ver_print_error("pVersionInfo = %d, ulLength = %d error.\n",(int)pVersionInfo,(int)ulLength);
return ERROR;
}
if(!b_geted){
b_geted=true;
iso_ver = bsp_version_get_iso();
}
if(!iso_ver)
{
ver_print_error("get iso version fail.\n");
return ERROR;
}
strncpy(pVersionInfo,iso_ver,ulLength);
return OK;
}
/*lint -save -e958*/
int bsp_version_memversion_ctrl(char *pcData, unsigned char ucLength, COMP_TYPE_I ucType, unsigned char ucMode)
/*lint -save restore*/
{
/*lint -save -e958*/
u8 *lpv_VerTmp;
u8 liv_Index;
u8 ucLen;
/*lint -save restore*/
if(ucType >= VER_INFO_NUM)
{
ver_print_error("Version Info Type Error\n");
return ERROR;
}
if (ucMode > VERIONWRITEMODE)
{
ver_print_error("Control Mode Error\n");/*[false alarm]*/
return ERROR;
}
ucLen = ucLength;
if((VERIONWRITEMODE == ucMode)&&(ucLen > VER_MAX_LENGTH))
{
ver_print_error("Version Info Length Error\n");/*[false alarm]*/
ucLen = VER_MAX_LENGTH;
}
if((VERIONWRITEMODE == ucMode)&&(0 == ucLen))
{
/*lint -save -e18 -e718 -e746*/
ucLen = (u8)(strlen((const char *)pcData)+1);
/*lint -restore*/
if(ucLen >= VER_MAX_LENGTH)
{
ucLen = VER_MAX_LENGTH;
}
}
if(NULL == pcData)
{
ver_print_error("Data Buffer Pointer Null\n");
return ERROR;
}
lpv_VerTmp = (u8 *)verCheckInfo[ucType].CompVer;
for(liv_Index = 0; liv_Index < ucLen; liv_Index++)
{
if(ucMode)
{
*(lpv_VerTmp + liv_Index) = *((u8 *)pcData + liv_Index);
}
else
{
*((u8 *)pcData + liv_Index) = *(lpv_VerTmp + liv_Index);/*[false alarm]*/
}
}
return OK;
}
/*****************************************************************************
* 函 数 名 : bsp_version_acore_init
*
* 功能描述 : acore版本号初始化
*
* 参数说明 : 无
*
*返回值 : 无
*****************************************************************************/
int bsp_version_acore_init(void)
{
int ret = VER_ERROR;
memset((void *)(&huawei_product_info), 0, sizeof(PRODUCT_INFO_NV_STRU));
ret = bsp_version_productinfo_init();
if(VER_ERROR==ret)
ver_print_error("bsp_version_productinfo_init fail! ");
else
ver_print_error("bsp version acore init OK!\n");
mdrv_ver_init();
return ret;
}
/*****************************************************************************
* 函 数 : bsp_version_get_hardware
* 功 能 : 获取硬件版本号(硬件版本名称+ Ver.+硬件子版本号+A)
*****************************************************************************/
char * bsp_version_get_hardware(void)
{
u32 len;
static bool b_geted=false;
static char hardware_version[VERSION_MAX_LEN];
char hardware_sub_ver = 0;
if((HW_VER_INVALID == huawei_product_info.index))
{
ver_print_error("huawei_product_info.index = HW_VER_INVALID\n");
return NULL;
}
if(!b_geted){
/*lint -save -e18 -e718 -e746*/
len = (unsigned int)(strlen(huawei_product_info.hwVer) + strlen(" Ver.X"));
hardware_sub_ver = (char)huawei_product_info.hwIdSub+'A';
(void)memset((void *)hardware_version, 0, MemparamType(len));
/*lint -restore*/
/* coverity[secure_coding] */
strncat(strncat(hardware_version, huawei_product_info.hwVer, strlen(huawei_product_info.hwVer)), " Ver.", strlen(" Ver."));
*((hardware_version + len) - 1) = hardware_sub_ver;
*(hardware_version + len) = 0;
b_geted=true;
}
return (char *)hardware_version;
}
/*****************************************************************************
函 数 名 : BSP_InitPlatformVerInfo
功能描述 : 初始化芯片的版本号
输入参数 : 无
输出参数 : none
返 回 值 : void
*****************************************************************************/
void BSP_InitPlatformVerInfo(void)
{
u32 addr;
u32 product_type=0xff;
COMP_TYPE_I comp_type;
/*获取硬件版本号*/
product_type = bsp_version_get_board_chip_type();
if(HW_VER_INVALID==product_type){
ver_print_error("get board chip type fail!\n");
}
if(HW_VER_PRODUCT_P531_FPGA == product_type){
comp_type=VER_SOC;
}
else{
comp_type=VER_ASIC;
}
addr=get_hi_version_id_version_id();
bsp_version_write_chip_version(addr,comp_type);
if(HW_VER_PRODUCT_P531_FPGA == product_type||HW_VER_PRODUCT_UDP == product_type||HW_VER_K3V3_UDP == product_type){
bsp_version_write_chip_version(HI_GBBP_REG_BASE_ADDR_VIRT+HAL_GBBP_VERSION_ADDR,VER_GBBP);
bsp_version_write_chip_version(HI_WBBP_REG_BASE_ADDR_VIRT+(WBBP_VERSION_ADDR-SOC_BBP_WCDMA_BASE_ADDR),VER_WBBP);
}
return;
}
/*****************************************************************************
* 函 数 : bsp_get_product_out_name
* 功 能 : 获取外部产品名称
*****************************************************************************/
char * bsp_version_get_product_out_name(void)
{
if(HW_VER_INVALID == huawei_product_info.index)
{
ver_print_error("huawei_product_info.index = HW_VER_INVALID\n");
return NULL;
}
return (char *)huawei_product_info.productId;
}
/*************************************************
函 数 名 : BSP_MNTN_ProductTypeGet
功能描述: 返回当前产品类型
输入参数: 无
输出参数: 无
返 回 值 :
0:STICK
1:MOD
2:E5
3:CPE
*************************************************/
BSP_U32 BSP_MNTN_ProductTypeGet(void)
{
unsigned int id = 0xffffffff;
eProductType product_type = PRODUCT_TYPE_STICK; /* default to stick */
id = (unsigned int)bsp_version_get_hwversion_index();
if(HW_VER_INVALID==id){
ver_print_error("[bsp_get_board_chip_type]:get hw version failed!hw_ver:0x%x\n",id);
return product_type;
}
/* UDP默认返回stick形态 */
if(HW_VER_UDP_MASK == (id & HW_VER_UDP_MASK))
{
return product_type;
}
/* 其他产品版，根据hakdc获取的形态返回 */
switch((enum hkac_product_type)((id & HW_VER_PRODUCT_TYPE_MASK) >> HW_VER_PRODUCT_TYPE_OS))
{
case HKADC_PRODUCT_TYPE_E5:
product_type = PRODUCT_TYPE_E5;
break;
case HKADC_PRODUCT_TYPE_STICK:
product_type = PRODUCT_TYPE_STICK;
break;
case HKADC_PRODUCT_TYPE_PHONE:
product_type = PRODUCT_TYPE_PHONE;
break;
case HKADC_PRODUCT_TYPE_PAD:
product_type = PRODUCT_TYPE_PAD;
break;
case HKADC_PRODUCT_TYPE_MOD:
product_type = PRODUCT_TYPE_MOD;
break;
case HKADC_PRODUCT_TYPE_CPE:
product_type = PRODUCT_TYPE_CPE;
break;
default:/* default to stick */
product_type = PRODUCT_TYPE_STICK;
break;
}
return (BSP_U32)product_type;
}
/*****************************************************************************
* 函 数 名 : bsp_version_productinfo_init
*
* 功能描述 : 读NV(0xD115)的值到huawei_product_info
*
* 参数说明 : 无
*
*返回值 : VER_ERROR表示读取异常
* VER_OK表示读取正常
*****************************************************************************/
static __inline__ int bsp_version_productinfo_init(void)
{
u32 ret = 0;
u32 hw_ver = bsp_get_version_info()->board_id;
/*lint -save -e26 -e119*/
ret = bsp_nvm_read(NV_ID_DRV_NV_VERSION_INIT,(u8*)&huawei_product_info,sizeof(PRODUCT_INFO_NV_STRU));
if(NV_OK != ret)
{
ver_print_error(" bsp_nvm_read failed!\n");
return VER_ERROR;
}
if(hw_ver!=huawei_product_info.index){
ver_print_error(" product id(0x%x) is not defined in xml!\n",hw_ver);
huawei_product_info.index = hw_ver;
return VER_ERROR;
}
/*lint -restore*/
return VER_OK;
}
static void bsp_version_write_chip_version(u32 addr,COMP_TYPE_I comp_type)
{
u8 soc_version_info[VER_MAX_LENGTH] = {0};
s32 ret=OK;
/* coverity[secure_coding] */
sprintf((char *)soc_version_info,"%#x",addr);
ret = bsp_version_memversion_ctrl((char*)soc_version_info,
VER_MAX_LENGTH, comp_type, VERIONWRITEMODE);
if( OK != ret )
{
ver_print_error(" Write %d Version Info fail. \n", comp_type);
}
}
/*****************************************************************************
* 函 数 名 : BSP_DLOAD_GetDloadVer
*
* 功能描述 : 查询下载协议版本号。该信息BSP固定写为2.0。
*
* 输入参数 :
char *str :字符串缓冲区
* BSP_S32 len :字符串长度
* 输出参数 : BSP_S8 *str :字符串缓冲区
*
* 返 回 值 : DLOAD_ERROR :输入参数非法
* 其它 :返回字符串长度
*
* 其它说明 : AT模块调用
* 正常模式支持
* 下载模式支持
*****************************************************************************/
BSP_S32 BSP_DLOAD_GetDloadVer(char *str, BSP_U32 len)
{
ver_print_info("getDloadVersion\r\n");
if((NULL == str) || (len <= 0) || ((UINT32)len < sizeof(DLOAD_VERSION)))
{
ver_print_error("param error!\n");
return VER_ERROR;
}
memset(str, 0x0, (UINT32)len);
memcpy(str, DLOAD_VERSION, sizeof(DLOAD_VERSION));
return VER_OK;
}
/*****************************************************************************
* 函 数 : bsp_get_firmware_version
* 功 能 : 获取软件版本号
*****************************************************************************/
char * bsp_version_get_firmware(void)
{
u32 ret = VER_OK;
/*lint -save -e26 -e119*/
ret=bsp_nvm_read(NV_ID_DRV_NV_DRV_VERSION_REPLACE_I, (u8 *)&nv_sw_ver, sizeof(NV_SW_VER_STRU));
if(NV_OK != ret){
ver_print_error("get NV_SW_VERSION_REPLACE failed!\n");
return (char*)PRODUCT_DLOAD_SOFTWARE_VER;
}
else if(0 == nv_sw_ver.nvStatus){
return (char*)PRODUCT_DLOAD_SOFTWARE_VER;
}
/*lint -restore*/
return (char *)nv_sw_ver.nv_version_info;
}
/*****************************************************************************
函 数 名 : BSP_MNTN_GetProductIdInter
功能描述 : 产品名称完整版本读接口。
输入参数 : pProductIdInter：为调用者待保存返回的产品名称完整版本的内存首地址；
ulLength ：为调用者待保存返回的产品名称完整版本的内存大小；
输出参数 : 无。
返 回 值 : 0: 操作成功；
-1：操作失败。
*****************************************************************************/
int BSP_MNTN_GetProductIdInter(char * pProductIdInter, unsigned int ulLength)
{
static bool b_geted=false;
static char* inner_name=NULL;
if(!b_geted){
b_geted=true;
inner_name = bsp_version_get_product_inner_name();
}
if(!inner_name)
{
ver_print_error("get product inner name failed !\n");
return ERROR;
}
strncpy(pProductIdInter,inner_name,ulLength);
return OK;
}
/*****************************************************************************
* 函 数 名 : BSP_HwGetHwVersion
* 功能描述 : 获取硬件版本名称
* 输入参数 : char* pHwVersion,字符串指针，保证不小于32字节
* 输出参数 : 无
* 返 回 值 : 无
* 修改记录 :
*****************************************************************************/
BSP_S32 BSP_HwGetHwVersion (char* pFullHwVersion, BSP_U32 ulLength)
{
static bool b_geted=false;
static char* hw_version=NULL;
if(!b_geted){
b_geted=true;
hw_version = bsp_version_get_hardware();
}
if(!hw_version)
{
ver_print_error("get product hardware version failed !\n");
return ERROR;
}
strncpy(pFullHwVersion,hw_version,ulLength);
return OK;
}
/*****************************************************************************
函 数 名 : bsp_version_get_platform_info
功能描述 : 获取芯片的版本号
输入参数 : 无
输出参数 : Platform_info:芯片的版本号
返 回 值 : void
*****************************************************************************/
static void bsp_version_get_platform_info(unsigned int *platform_info)
{
/*board FPGA*/
u32 product_type = 0xff;
product_type = bsp_version_get_board_chip_type();
if(HW_VER_INVALID==product_type){
ver_print_error("get board chip type fail!\n");
return ;
}
switch(product_type){
case HW_VER_PRODUCT_P531_FPGA:
case HW_VER_K3V3_FPGA:
*platform_info=VER_SOC;
break;
default:
*platform_info=VER_ASIC;
}
}
int BSP_DLOAD_GetDloadInfo(unsigned char atCmdBuf[], unsigned int dloadType)
{
int ret=VER_OK;
static bool b_geted=false;
static struct dload_info_type dload_info={"\0","\0","\0"};
if(!b_geted){
b_geted=true;
ret=bsp_dload_get_dload_info(&dload_info);
if(VER_OK!=ret){
ver_print_error("get dload info failed !\n");
return VER_ERROR;
}
}
/* coverity[secure_coding] */
sprintf((char *)atCmdBuf,"\r\n\r\nswver:%s\r\n\
\r\niso:%s\r\n\
\r\nproduct name:%s\r\n\
\r\ndload type:%d\r\n\
\r\nOK\r\n",dload_info.software_ver,dload_info.iso_ver,dload_info.product_name,dloadType);
return VER_OK;
}
/*****************************************************************************
* 函数 : bsp_get_board_chip_type
* 功能 : get board type and chip type
* 输入 : void
* 输出 : void
* 返回 : BOARD_TYPE_E
*****************************************************************************/
u32 bsp_version_get_board_chip_type(void)
{
unsigned int type = 0xffffffff;
type = (u32)bsp_version_get_hwversion_index();
if(HW_VER_INVALID==type){
ver_print_error("[bsp_get_board_chip_type]:get hw version failed!hw_ver:0x%x\n",type);
return type;
}
/*若为udp，只返回UDP硬件版本号，屏蔽射频扣板信息*/
if(HW_VER_UDP_MASK==(type & HW_VER_UDP_MASK)){
return HW_VER_PRODUCT_UDP;
}
/*若为k3v3UDP,只返回UDP硬件版本号*/
if(HW_VER_K3V3_UDP_MASK == (type & HW_VER_K3V3_UDP_MASK)){
return HW_VER_K3V3_UDP;
}
/*若为k3v3FPGA,只返回FPGA硬件版本号*/
if(HW_VER_K3V3_FPGA_MASK == (type & HW_VER_K3V3_FPGA_MASK)){
return HW_VER_K3V3_FPGA;
}
/*若为k3v3 plus,只返回UDP硬件版本号*/
if(HW_VER_K3V3_PLUS_UDP_MASK == (type & HW_VER_K3V3_PLUS_UDP_MASK)){
return HW_VER_K3V3_UDP;/*暂时适配，后续删除*/
}
if(HW_VER_V711_UDP_MASK == (type & HW_VER_V711_UDP_MASK)){
return HW_VER_V711_UDP;
}
return type;
}
int BSP_GetProductName (char * pProductName, unsigned int ulLength)
{
static bool b_geted=false;
static char* pout_name=NULL;
if((BSP_NULL == pProductName) || (0 == ulLength))
{
return ERROR;
}
if(!b_geted){
b_geted=true;
pout_name = bsp_version_get_product_out_name();
}
if(!pout_name)
{
ver_print_error("get product out name failed !\n");
return ERROR;
}
strncpy(pProductName, pout_name, ulLength);
return OK;
}
/*****************************************************************************
* 函 数 : bsp_get_product_inner_name
* 功 能 : 获取内部产品名称(内部产品名+ 内部产品名plus)
*****************************************************************************/
char * bsp_version_get_product_inner_name(void)
{
unsigned int len;
static bool b_geted=false;
static char product_inner_name[VERSION_MAX_LEN];
if( HW_VER_INVALID == huawei_product_info.index)
{
ver_print_error("huawei_product_info.index = HW_VER_INVALID\n");
return NULL;
}
if(!b_geted){
len = (unsigned int)(strlen(huawei_product_info.name)+ strlen(huawei_product_info.namePlus));
(void)memset((void*)product_inner_name, 0, MemparamType(len));
/* coverity[secure_coding] */
strncat(strncat(product_inner_name,huawei_product_info.name, strlen(huawei_product_info.name)), huawei_product_info.namePlus, strlen(huawei_product_info.namePlus));
*(product_inner_name+len) = 0;
b_geted=true;
}
return (char*)product_inner_name;
}
/*****************************************************************************
* 函 数 : bsp_version_debug
* 功 能 : 用于调试查看版本号相关信息
*****************************************************************************/
int bsp_version_debug(void)
{
if(huawei_product_info.index == HW_VER_INVALID){
ver_print_error("huawei_product_info.index = HW_VER_INVALID\n");
return VER_ERROR;
}
ver_print_error("\n\n1 . the element value of nv(0xd115):\n");
ver_print_error("Hardware index :0x%x\n",huawei_product_info.index);
ver_print_error("hw_Sub_ver :0x%x\n",huawei_product_info.hwIdSub);
ver_print_error("Inner name :%s\n",huawei_product_info.name);
ver_print_error("name plus :%s\n",huawei_product_info.namePlus);
ver_print_error("HardWare ver :%s\n",huawei_product_info.hwVer);
ver_print_error("DLOAD_ID :%s\n",huawei_product_info.dloadId);
ver_print_error("Out name :%s\n",huawei_product_info.productId);
ver_print_error("\n\n2 . the element value of nv(0xc362):\n");
ver_print_error("nvStatus :0x%x\n",nv_sw_ver.nvStatus);
ver_print_error("nv_version_info:%s\n",nv_sw_ver.nv_version_info);
ver_print_error("\n\n3 . get from func(bsp_version_get_xxx):\n");
ver_print_error("HardWare ver :%s\n",bsp_version_get_hardware());
ver_print_error("Inner name :%s\n",bsp_version_get_product_inner_name());
ver_print_error("Out name :%s\n",bsp_version_get_product_out_name());
ver_print_error("Build_time :%s\n",bsp_version_get_build_date_time());
ver_print_error("Chip_ver :%s\n",bsp_version_get_chip());
ver_print_error("Firmware :%s\n",bsp_version_get_firmware());
ver_print_error("Release_ver :%s\n",bsp_version_get_release());
ver_print_error("\n\n4 . get from bsp_get_version_info:\n");
ver_print_error("board_id :0x%x\n",bsp_get_version_info()->board_id);
ver_print_error("board_id_udp_masked :0x%x\n",bsp_get_version_info()->board_id_udp_masked);
ver_print_error("chip_version :0x%x\n",bsp_get_version_info()->chip_version);
ver_print_error("chip_type :0x%x\n",bsp_get_version_info()->chip_type);
ver_print_error("plat_type :0x%x (0:asic a:fpga e:emu)\n",bsp_get_version_info()->plat_type);
ver_print_error("board_type(for drv) :0x%x (0:bbit 1:sft 2:asic 3:soc)\n",bsp_get_version_info()->board_type);
ver_print_error("board_type(for mdrv):0x%x (0:bbit 1:sft 2:asic)\n",(BOARD_ACTUAL_TYPE_E)bsp_get_version_info()->board_type);
ver_print_error("bbit_type :0x%x (1:dallas 2:722 3:chicago)\n",bsp_get_version_info()->bbit_type);
ver_print_error("product_type :0x%x (0:mbb 1:phone)\n",bsp_get_version_info()->product_type);
ver_print_error("product_name :0x%x\n",bsp_get_version_info()->product_name);
return VER_OK;
}
/*****************************************************************************
* 函 数 名 : BSP_GetBuildVersion
*
* 功能描述 :
*
* 输入参数 :
* 输出参数 : 无
*
* 返 回 值 : 无
*
* 修改记录 : 2011-3-29 wuzechun creat
*
*****************************************************************************/
UE_SW_BUILD_VER_INFO_STRU* BSP_GetBuildVersion(void)
{
#define MAX_VER_SECTION 8
#define VER_PART_LEN 3
#define VERC_PART_LEN 2
static UE_SW_BUILD_VER_INFO_STRU st = {0,0,0,0,0,0,0,{0},{0}};
static bool binited = false;
int ret;
char * pCur, * pFind;
char au8Args[MAX_VER_SECTION] = {0};
u32 verno;
if(!binited)
{
pCur = PRODUCT_VERSION_STR;
pFind = pCur;
while (NULL != (pCur = strchr(pCur, 'V')) )
{
pCur++;
if (isdigit(*(pCur)))
{
memset(au8Args, 0, MAX_VER_SECTION);
strncpy(au8Args, pCur, VER_PART_LEN);
ret = strict_strtoul(au8Args, 10, (unsigned long *)&verno);
if(ret)
{
ver_print_error("kstrtouint error:ret %#x, au8Args:%s\n", ret, au8Args);
return (&st);
}
st.ulVVerNo = (u16)verno;
break;
}
}
pCur = pFind;
while (NULL != (pCur = strchr(pFind, 'R')) )
{
pCur++;
if (isdigit(*(pCur-2)) && isdigit(*(pCur)))
{
memset(au8Args, 0, MAX_VER_SECTION);
strncpy(au8Args, pCur, VER_PART_LEN);
ret = strict_strtoul(au8Args, 10, (unsigned long *)&verno);
if(ret)
{
ver_print_error("kstrtouint error:ret %#x, au8Args:%s\n", ret, au8Args);
return (&st);
}
st.ulRVerNo = (u16)verno;
break;
}
}
pCur = pFind;
while (NULL != (pCur = strchr(pFind, 'C')) )
{
pCur++;
if (isdigit(*(pCur-2)) && isdigit(*(pCur)))
{
memset(au8Args, 0, MAX_VER_SECTION);
strncpy(au8Args, pCur, VERC_PART_LEN);
pCur += VERC_PART_LEN;
ret = strict_strtoul(au8Args, 10, (unsigned long *)&verno);
if(ret)
{
ver_print_error("kstrtouint error:ret %#x, au8Args:%s\n", ret, au8Args);
return (&st);
}
st.ulCVerNo = (u16)verno;
break;
}
}
pCur = pFind;
while (NULL != (pCur = strchr(pFind, 'B')) )
{
pCur++;
if (isdigit(*(pCur-2)) && isdigit(*(pCur)))
{
memset(au8Args, 0, MAX_VER_SECTION);
strncpy(au8Args, pCur, VER_PART_LEN);
ret = strict_strtoul(au8Args, 10, (unsigned long *)&verno);
if(ret)
{
ver_print_error("kstrtouint error:ret %#x, au8Args:%s\n", ret, au8Args);
return (&st);
}
st.ulBVerNo = (u16)verno;
break;
}
}
pCur = pFind;
while (NULL != (pCur = strstr(pFind, "SPC")) )
{
pCur+=3;
if (isdigit(*(pCur-4)) && isdigit(*(pCur)))
{
memset(au8Args, 0, MAX_VER_SECTION);
strncpy(au8Args, pCur, VER_PART_LEN);
ret = strict_strtoul(au8Args, 10, (unsigned long *)&verno);
if(ret)
{
ver_print_error("kstrtouint error:ret %#x, au8Args:%s\n", ret, au8Args);
return (&st);
}
st.ulSpcNo = (u16)verno;
break;
}
}
st.ulProductNo = BSP_MNTN_ProductTypeGet();
/* coverity[buffer_size_warning] */
strncpy(st.acBuildDate, __DATE__, BUILD_DATE_LEN);
strncpy(st.acBuildTime, __TIME__, BUILD_TIME_LEN);
}
return (&st);
}