dvb_caservice.c

我国有线电视条件接受标准目前还没有统一

			pstService->product_list[iPos].end_date.SS);
		g_stService.stServiceTable.aucProductID[iPos] = pstService->product_list[iPos].product_ID;
		uiDays = TransYMD(pstService->product_list[iPos].start_date.YY,pstService->product_list[iPos].start_date.MM,
			pstService->product_list[iPos].start_date.DD);
		g_stService.stServiceTable.auiStartTime[iPos] = (UINT32)((uiDays << 16) | (pstService->product_list[iPos].start_date.HH << 8)
			| pstService->product_list[iPos].start_date.MINUTE );
		uiDays = TransYMD(pstService->product_list[iPos].end_date.YY,pstService->product_list[iPos].end_date.MM,
			pstService->product_list[iPos].end_date.DD);
		g_stService.stServiceTable.auiEndTime[iPos] = (UINT32)((uiDays << 16) | (pstService->product_list[iPos].end_date.HH << 8)
			| pstService->product_list[iPos].end_date.MINUTE );
	}

	ST_SERVICE_TABLE *pstServiceTable = NULL;
	pstServiceTable = (ST_SERVICE_TABLE *)malloc(sizeof(ST_SERVICE_TABLE));
	if(pstServiceTable)
	{
		for(iPos = 0; iPos < DVB_CA_SERVICE_STB_MARK_TIMES; iPos++)
		{
			memset(pstServiceTable, 0x0, sizeof(ST_SERVICE_TABLE));
			DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_SERVICE_TABLE_OFFSET + iPos * (sizeof(ST_SERVICE_TABLE)), (UINT8 *)pstServiceTable, sizeof(ST_SERVICE_TABLE));
			if(pstServiceTable->ucVer == 0xFF)
				break;
		}	
		if(iPos < DVB_CA_SERVICE_STB_MARK_TIMES)
		{
			DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_SERVICE_TABLE_OFFSET + iPos * (sizeof(ST_SERVICE_TABLE)),(UINT8 *)(&(g_stService.stServiceTable)), sizeof(ST_SERVICE_TABLE));		
		}
		if(iPos >= ((DVB_CA_SERVICE_STB_MARK_TIMES * 2) / 3))
		{
			g_iRefresh = 1;
		}
		free(pstServiceTable);
	}	
	return 0;
}

void DVB_CAService_SetStbMark(UINT8 ucStbMark)
{
	UINT8 ucLastStbMark = 0xFF;
	int iPos;
	if(ucStbMark != 0 && ucStbMark != 1)
		return;
	if(ucStbMark == 0xFF || ucStbMark == g_stService.ucStbMark)
		return;


	g_stService.ucStbMark = ucStbMark;
	
	for(iPos = 0; iPos < DVB_CA_SERVICE_STB_MARK_TIMES; iPos++)
	{
		UINT8 ucTempStbMark = 0xFF;
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_STB_MARK_OFFSET + iPos *sizeof(UINT8) ,&ucTempStbMark, sizeof(UINT8));
		if(ucTempStbMark == 0xFF)
			break;
		ucLastStbMark = ucTempStbMark;
	}

	if(iPos < DVB_CA_SERVICE_STB_MARK_TIMES)
	{
		if(iPos > 0 && ((ucLastStbMark & ucStbMark) == ucStbMark))
			iPos--;
		DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_STB_MARK_OFFSET + iPos *sizeof(UINT8) ,(UINT8 *)&ucStbMark, sizeof(UINT8));
	}
	
	if(iPos >= ((DVB_CA_SERVICE_STB_MARK_TIMES * 2) / 3))
	{
		g_iRefresh = 1;
	}		
}

UINT32 DVB_CAService_GetAreaID(void)
{
	return g_stService.stServiceTable.uiAreaID;
}

int DVB_CAService_SetNetwork(UINT32 uiNetworkID)
{
	int iResult = 0;
	int iPos;
	UINT32 uiLastNetworkID = 0xFFFFFFFF;
	if(uiNetworkID == 0xFFFFFFFF || uiNetworkID == g_stService.uiNetworkID)
		return iResult;
	ca_printf("g_stService.uiNetworkID:%d:%d\n",g_stService.uiNetworkID, uiNetworkID);

	if(g_stService.uiNetworkID != 0xFFFFFFFF)
	{
		ST_SERVICE_TABLE *pstServiceTable = NULL;

		iResult = -1;
		if(g_stService.uiNetworkID != 0)
		{
			g_stService.stServiceTable.ucEnable = 0;
		}
		else			
			g_stService.stServiceTable.ucEnable = 0x0F;

		pstServiceTable = (ST_SERVICE_TABLE *)malloc(sizeof(ST_SERVICE_TABLE));
		if(pstServiceTable)
		{
			for(iPos = 0 ; iPos < DVB_CA_SERVICE_SERVICE_TIMES; iPos++)
			{
				memset(pstServiceTable, 0x0, sizeof(ST_SERVICE_TABLE));
				DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_SERVICE_TABLE_OFFSET + iPos * (sizeof(ST_SERVICE_TABLE)), (UINT8 *)pstServiceTable, sizeof(ST_SERVICE_TABLE));
				if(pstServiceTable->ucVer == 0xFF)
					break;
			}
			if(iPos > 0)
			{
				DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_SERVICE_TABLE_OFFSET + (iPos-1) * (sizeof(ST_SERVICE_TABLE)),(UINT8 *)&g_stService.stServiceTable, sizeof(ST_SERVICE_TABLE));
			}
			free(pstServiceTable);
			pstServiceTable = NULL;
		}
		
	}
	
	g_stService.uiNetworkID = uiNetworkID;
	
	for(iPos = 0; iPos < DVB_CA_SERVICE_NETWORK_TIMES; iPos++)
	{
		UINT32 uiTempNetworkID = 0xFFFFFFFF;
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR+ DVB_CA_SERVICE_NETWOKR_OFFSET + iPos *sizeof(UINT32) ,(UINT8 *)&uiTempNetworkID, sizeof(UINT32));
		if(uiTempNetworkID == 0xFFFFFFFF)
			break;
		uiLastNetworkID = uiTempNetworkID;
	}

	if(iPos < DVB_CA_SERVICE_NETWORK_TIMES)
	{
		if(iPos > 0 && ((uiLastNetworkID & uiNetworkID) == uiNetworkID))
			iPos--;
		DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_NETWOKR_OFFSET + iPos *sizeof(UINT32) ,(UINT8 *)&uiNetworkID, sizeof(UINT32));
	}
	
	if(iPos >= ((DVB_CA_SERVICE_NETWORK_TIMES * 2) / 3))
	{
		g_iRefresh = 1;
	}	
	return iResult;
}


static void DVB_CAService_Save(void)
{

	DVB_CAService_FlashEarse(DVB_CA_SERVICE_ADDR, 64 * 1024);
	
	DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_HEAD_OFFSET, (UINT8 *)&g_stService.uiMagic, DVB_CA_SERVICE_HEAD_SIZE);
	
	if(g_stService.stServiceTable.ucVer != 0xFF)
	{
		DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_SERVICE_TABLE_OFFSET,(UINT8 *)&g_stService.stServiceTable, sizeof(ST_SERVICE_TABLE));
	}
	if(g_stService.ucStbMark != 0xFF)
		DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_STB_MARK_OFFSET,&g_stService.ucStbMark, 1);
	if(g_stService.uiNetworkID != 0xFFFFFFFF)
		DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_NETWOKR_OFFSET,(UINT8 *)&g_stService.uiNetworkID, 4);
	#if defined(SDT_CA_50)
	DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_FACETIME_OFFSET,&g_stService.ucFaceTime, 1);
	DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_FREQVER_OFFSET,&g_stService.ucFreqVer, 1);
	DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_NETNAME_OFFSET,g_stService.aucNetName, NET_NAME_LEN);
	#endif
}

static int DVB_CAService_Load(void)
{
	int iReturn = CA_SERVICE_SUCCESS;
	int iResult = CA_SERVICE_SUCCESS;
	
	memset(&g_stService, 0x0, sizeof(ST_SERVICE));

	DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_HEAD_OFFSET  ,(UINT8 *)&g_stService.uiMagic, DVB_CA_SERVICE_HEAD_SIZE);
	
	if(g_stService.uiMagic != DVB_CA_MAIGC_CODE)
	{
		DVB_CAService_FlashEarse(DVB_CA_SERVICE_ADDR, 64 * 1024);
		g_stService.uiMagic = DVB_CA_MAIGC_CODE;
		DVB_CAService_FlashWrite(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_HEAD_OFFSET, (UINT8 *)&g_stService.uiMagic, DVB_CA_SERVICE_HEAD_SIZE);
	}
	iResult = DVB_CAService_LoadServiceTable();
	if(iResult != CA_SERVICE_SUCCESS)
		iReturn = iResult;
	iResult = DVB_CAService_LoadStbMark();
	if(iResult != CA_SERVICE_SUCCESS)
		iReturn = iResult;
	iResult = DVB_CAService_LoadNetwork();
	if(iResult != CA_SERVICE_SUCCESS)
		iReturn = iResult;
	
#if defined(SDT_CA_50)
	iResult = DVB_CAService_LoadFreqVer();
	if(iResult != CA_SERVICE_SUCCESS)
		iReturn = iResult;
	iResult = DVB_CAService_LoadFaceTime();
	if(iResult != CA_SERVICE_SUCCESS)
		iReturn = iResult;
	iResult = DVB_CAService_LoadNetName();
	if(iResult != CA_SERVICE_SUCCESS)
		iReturn = iResult;
#endif

	return iReturn;;
}

static int DVB_CAService_LoadNetwork(void)
{
	int iPos = 0;
	int iResult = 0;

	g_stService.uiNetworkID = 0xFFFFFFFF;

	for(iPos = 0 ; iPos < DVB_CA_SERVICE_NETWORK_TIMES; iPos++)
	{
		UINT32 uiNetworkID = 0xFFFFFFFF;
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_NETWOKR_OFFSET + iPos *sizeof(UINT32) ,(UINT8 *)&uiNetworkID, sizeof(UINT32));
		if(uiNetworkID == 0xFFFFFFFF)
			break;
		g_stService.uiNetworkID = uiNetworkID;
	}
	
	if(iPos >= ((DVB_CA_SERVICE_NETWORK_TIMES * 2) / 3))
	{
		iResult = -1;
	}

	return iResult;
}

#if defined(SDT_CA_50)
static int DVB_CAService_LoadNetName(void)
{
	int iPos = 0;
	int iResult = 0;

	memset(g_stService.aucNetName, 0x0, NET_NAME_LEN + 1);

	for(iPos = 0 ; iPos < DVB_CA_SERVICE_NETNAME_TIMES; iPos++)
	{
		UINT8 aucNetName[NET_NAME_LEN];
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_NETNAME_OFFSET+ iPos * NET_NAME_LEN,aucNetName, NET_NAME_LEN);
		if(aucNetName[0] == 0xFF)
			break;
		memset(g_stService.aucNetName, 0x0, NET_NAME_LEN + 1);
		memcpy(g_stService.aucNetName, aucNetName, NET_NAME_LEN);
	}
	
	if(iPos >= ((DVB_CA_SERVICE_NETNAME_TIMES * 2) / 3))
	{
		iResult = -1;
	}
	return iResult;
}

static int DVB_CAService_LoadFreqVer(void)
{
	int iPos = 0;
	int iResult = 0;

	g_stService.ucFreqVer= 0xFF;

	for(iPos = 0 ; iPos < DVB_CA_SERVICE_FREQVER_TIMES; iPos++)
	{
		UINT8 ucFreqVer = 0xFF;
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_FREQVER_OFFSET+ iPos,&ucFreqVer, 1);
		if(ucFreqVer == 0xFF)
			break;
		g_stService.ucFreqVer = ucFreqVer;
	}
	
	if(iPos >= ((DVB_CA_SERVICE_FREQVER_TIMES * 2) / 3))
	{
		iResult = -1;
	}
	return iResult;
}

static int DVB_CAService_LoadFaceTime(void)
{
	int iPos = 0;
	int iResult = 0;

	g_stService.ucFaceTime= 0x00;

	for(iPos = 0 ; iPos < DVB_CA_SERVICE_FACETIME_TIMES; iPos++)
	{
		UINT8 ucFaceTime = 0xFF;
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_FACETIME_OFFSET + iPos,&ucFaceTime, 1);
		if(ucFaceTime == 0xFF)
			break;
		g_stService.ucFaceTime = ucFaceTime;
	}
	
	if(iPos >= ((DVB_CA_SERVICE_FACETIME_TIMES * 2) / 3))
	{
		iResult = -1;
	}
	return iResult;
}
#endif

static int DVB_CAService_LoadStbMark(void)
{
	int iPos = 0;
	int iResult = 0;

	g_stService.ucStbMark = 0x00;

	for(iPos = 0 ; iPos < DVB_CA_SERVICE_STB_MARK_TIMES; iPos++)
	{
		UINT8 ucStbMark = 0xFF;
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_STB_MARK_OFFSET + iPos,&ucStbMark, 1);
		if(ucStbMark == 0xFF)
			break;
		g_stService.ucStbMark = ucStbMark;
	}
	
	if(iPos >= ((DVB_CA_SERVICE_STB_MARK_TIMES * 2) / 3))
	{
		iResult = -1;
	}
	return iResult;
}

static int DVB_CAService_LoadServiceTable(void)
{
	int iPos = 0;
	int iResult = 0;
	ST_SERVICE_TABLE *pstServiceTable = NULL;

	memset(&g_stService.stServiceTable, 0x00, sizeof(ST_SERVICE_TABLE));
	g_stService.stServiceTable.ucEnable = 1;
	g_stService.stServiceTable.ucVer = 0xFF;
	
	pstServiceTable = (ST_SERVICE_TABLE *)malloc(sizeof(ST_SERVICE_TABLE));

	if(pstServiceTable == NULL)
		return iResult;
	
	for(iPos = 0 ; iPos < DVB_CA_SERVICE_SERVICE_TIMES; iPos++)
	{
		memset(pstServiceTable, 0x0, sizeof(ST_SERVICE_TABLE));
		pstServiceTable->ucEnable = 1;
		pstServiceTable->ucVer = 0xFF;	
		DVB_CAService_FlashRead(DVB_CA_SERVICE_ADDR + DVB_CA_SERVICE_SERVICE_TABLE_OFFSET + iPos * (sizeof(ST_SERVICE_TABLE)), (UINT8 *)pstServiceTable, sizeof(ST_SERVICE_TABLE));
		if(pstServiceTable->ucVer == 0xFF)
			break;
		memcpy(&g_stService.stServiceTable, pstServiceTable, sizeof(ST_SERVICE_TABLE));
	}
	
	if(iPos >= ((DVB_CA_SERVICE_SERVICE_TIMES * 2) / 3))
	{
		iResult = -1;
	}
	
	free(pstServiceTable);
	
	return iResult;
}

static int DVB_CAService_FlashEarse(UINT32 uiStartAdd, UINT32 iLen)
{
	int iResult = 0;
	#ifndef EEPROM_FLASH_STORE_INFO
		//memset((UINT8 *)(g_ucTempFlash + uiStartAdd - DVB_CA_SERVICE_ADDR), 0xFF, iLen);
		memset((UINT8 *)(g_ucTempFlash + uiStartAdd % (64 * 1024)), 0xFF, (64 * 1024));
	#else
		iResult = FlashEraseSecRange(uiStartAdd, iLen);
	#endif
	return iResult;
}

static int DVB_CAService_FlashWrite(UINT32 iStartAddr, BYTE *pBuf, UINT32 iLen)
{
	int iResult = 0;
	#ifndef EEPROM_FLASH_STORE_INFO
		memcpy((UINT8 *)(g_ucTempFlash + iStartAddr % (64 * 1024)), pBuf, iLen);
	#else
		iResult = FlashWrite(iStartAddr, pBuf,iLen);
	#endif
	return iResult;
}

static int DVB_CAService_FlashRead(UINT32 iStartAddr, BYTE *pBuf, UINT32 iLen)
{
	int iResult = 0;
	#ifndef EEPROM_FLASH_STORE_INFO
		memcpy(pBuf, (UINT8 *)(g_ucTempFlash + iStartAddr % (64 * 1024)), iLen);
	#else
		iResult = FlashRead(iStartAddr, pBuf,iLen);
	#endif
	return iResult;
}

UINT16 TransYMD(UINT8 ucYear, UINT8 ucMon, UINT8 ucDay)
{
	UINT16 usDay = 0;
	UINT8 ucMonth = 0;
	UINT8 aucMonthDay[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
	
	usDay = 365 * ucYear + (ucYear >> 2);
	if(ucYear > 0)
		usDay++;

	for(ucMonth  = 0; ucMonth < (ucMon -1); ucMonth++)
		usDay += aucMonthDay[ucMonth];

	if(((ucYear >> 2) == 0) && (ucMon > 2))
		usDay ++;

	usDay += (ucDay - 1);
	return usDay;	
}

void Trans2YMD(UINT16 usDays, UINT8 *pucYear, UINT8 *pucMon, UINT8 *pucDay)
{
	UINT16 usYearDay = 366;
	UINT8 ucMonth = 0;
	UINT8 aucMonthDay[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
	*pucYear = 0;
	*pucMon = 0;
	*pucDay = 0;

	
	while(usDays >= usYearDay)
	{
		(*pucYear) += 1;
		usDays -= usYearDay;
		if(((*pucYear) % 4) == 0)
			usYearDay = 366;
		else
			usYearDay = 365;
	}
	if(usYearDay == 366)
		aucMonthDay[1] = 29;
	
	while(usDays >= aucMonthDay[ucMonth])
	{
		usDays -= aucMonthDay[ucMonth];
		ucMonth ++;
	}

	*pucMon = ucMonth + 1;
	*pucDay = usDays + 1;
}