cas_key.c

EMU_FTAbox_ref441328_code_source ali m3327

	{
		CAS_ERROR_PRINTF("MEM_Write: write flash error!\n");
		return !SUCCESS;
	}
#endif
}





INT32 default_data_crc_write(UINT8 *write_buffer, UINT32 write_size)
{
	extern OSAL_ID sto_wr_sema;
	INT32 ret;
	struct sto_device *sto_flash_dev;
	UINT32 param;

	UINT32 key_table_addr;
	UINT32 chunk_id = DEFAULTDATA_TABLE_CHUNK_ID;
	CHUNK_HEADER chuck_hdr;
	UINT8 *buffer = NULL;

	if((write_buffer == NULL) || (write_size <= 0) || (write_size > DEFAULTDATA_TABLE_SECTOR_LENTH))
	{
		CAS_ERROR_PRINTF("MEM_Write: invalid parameter\n");
		return !SUCCESS;
	}
	
	/* get table info base addr by using chunk */
	if(get_chunk_header(chunk_id, &chuck_hdr) == 0)
	{
		CAS_ERROR_PRINTF("MEM_Write: get keytable base addr failed!\n");
		return !SUCCESS;
	}

	key_table_addr = (UINT32)chunk_goto(&chunk_id, 0xFFFFFFFF, 1) + 12 ;
	key_table_addr -= SYS_FLASH_BASE_ADDR;	// key_table address in flash
	
	sto_flash_dev = (struct sto_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_STO);
	if(sto_flash_dev == NULL)
	{
		CAS_ERROR_PRINTF("MEM_Write: dev_get_by_name failed!\n");
		return !SUCCESS;
	}
	if (sto_open(sto_flash_dev) != SUCCESS)
	{
		CAS_ERROR_PRINTF("MEM_Write: sto_open failed!\n");
		return !SUCCESS;
	}

	buffer = osal_memory_allocate(DEFAULTDATA_TABLE_SECTOR_LENTH);
	if(!buffer)
		return !SUCCESS;
	sto_io_control(sto_flash_dev,STO_DRIVER_SECTOR_BUFFER,buffer);
	sto_io_control(sto_flash_dev, STO_DRIVER_SET_FLAG, STO_FLAG_AUTO_ERASE | STO_FLAG_SAVE_REST);
	//param = key_table_addr << 10;
	//param |= KEY_TABLE_SECTOR_LENTH >> 10;
	//ret = sto_io_control(sto_flash_dev, STO_DRIVER_SECTOR_ERASE, param);
	//if(ret != SUCCESS)
	//{
	//	CAS_ERROR_PRINTF("MEM_Write: Erase failed!\n");
	//	return !SUCCESS;
	//}

#if 1	//not USE_FLASH_COMMON || M3327_2M 
	/*sto_wr_sema is defined and used by database which reads and writes flash frequently*/
//	while(osal_semaphore_capture(sto_wr_sema, 1000) != SUCCESS)
//		CAS_ERROR_PRINTF("MEM_Write: sto_wr_sema capture timeout\n");
	ret = sto_lseek(sto_flash_dev, key_table_addr, STO_LSEEK_SET);
	if ((UINT32) ret != key_table_addr)
	{
		osal_semaphore_release(sto_wr_sema);
		CAS_ERROR_PRINTF("MEM_Write: seek base failed!\n");
		sto_io_control(sto_flash_dev,STO_FLAG_SAVE_REST,NULL);
		sto_io_control(sto_flash_dev, STO_DRIVER_SET_FLAG, 0);
		if(buffer)
			osal_memory_free(buffer);
		return !SUCCESS;
	}
	ret = sto_write(sto_flash_dev, write_buffer, write_size);
	if((UINT32) ret != write_size)
	{
		osal_semaphore_release(sto_wr_sema);
		CAS_ERROR_PRINTF("MEM_Write: here is not blank at:%x!\n", write_buffer);
		sto_io_control(sto_flash_dev,STO_FLAG_SAVE_REST,NULL);
		sto_io_control(sto_flash_dev, STO_DRIVER_SET_FLAG, 0);
		if(buffer)
			osal_memory_free(buffer);
		return !SUCCESS;
	}
	sto_io_control(sto_flash_dev,STO_FLAG_SAVE_REST,NULL);
	sto_io_control(sto_flash_dev, STO_DRIVER_SET_FLAG, 0);
	if(buffer)
		osal_memory_free(buffer);
//	osal_semaphore_release(sto_wr_sema);
	return SUCCESS;
#else
	ret = sto_modify(sto_flash_dev, key_table_addr, write_buffer, write_size);
	if((UINT32) ret != write_size)
	{
		CAS_ERROR_PRINTF("MEM_Write: write flash error!\n");
		return !SUCCESS;
	}
#endif
}








INT32 api_cas_mem_write(UINT8 *write_buffer, UINT32 write_size)
{
	extern OSAL_ID sto_wr_sema;
	INT32 ret;
	struct sto_device *sto_flash_dev;
	UINT32 param;

	UINT32 key_table_addr;
	UINT32 chunk_id = KEY_TABLE_CHUNK_ID;
	CHUNK_HEADER chuck_hdr;
	UINT8 *buffer = NULL;

	if((write_buffer == NULL) || (write_size <= 0) || (write_size > KEY_TABLE_SECTOR_LENTH))
	{
		CAS_ERROR_PRINTF("MEM_Write: invalid parameter\n");
		return !SUCCESS;
	}
	
	/* get table info base addr by using chunk */
	if(get_chunk_header(chunk_id, &chuck_hdr) == 0)
	{
		CAS_ERROR_PRINTF("MEM_Write: get keytable base addr failed!\n");
		return !SUCCESS;
	}

	key_table_addr = (UINT32)chunk_goto(&chunk_id, 0xFFFFFFFF, 1) + CHUNK_HEADER_SIZE ;
	key_table_addr -= SYS_FLASH_BASE_ADDR;	// key_table address in flash
	
	sto_flash_dev = (struct sto_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_STO);
	if(sto_flash_dev == NULL)
	{
		CAS_ERROR_PRINTF("MEM_Write: dev_get_by_name failed!\n");
		return !SUCCESS;
	}
	if (sto_open(sto_flash_dev) != SUCCESS)
	{
		CAS_ERROR_PRINTF("MEM_Write: sto_open failed!\n");
		return !SUCCESS;
	}

	buffer = osal_memory_allocate(0x10000);
	if(!buffer)
		return !SUCCESS;
	sto_io_control(sto_flash_dev,STO_DRIVER_SECTOR_BUFFER,buffer);
	sto_io_control(sto_flash_dev, STO_DRIVER_SET_FLAG, STO_FLAG_AUTO_ERASE | STO_FLAG_SAVE_REST);
	//param = key_table_addr << 10;
	//param |= KEY_TABLE_SECTOR_LENTH >> 10;
	//ret = sto_io_control(sto_flash_dev, STO_DRIVER_SECTOR_ERASE, param);
	//if(ret != SUCCESS)
	//{
	//	CAS_ERROR_PRINTF("MEM_Write: Erase failed!\n");
	//	return !SUCCESS;
	//}

#if 1	//not USE_FLASH_COMMON || M3327_2M 
	/*sto_wr_sema is defined and used by database which reads and writes flash frequently*/
//	while(osal_semaphore_capture(sto_wr_sema, 1000) != SUCCESS)
//		CAS_ERROR_PRINTF("MEM_Write: sto_wr_sema capture timeout\n");
	ret = sto_lseek(sto_flash_dev, key_table_addr, STO_LSEEK_SET);
	if ((UINT32) ret != key_table_addr)
	{
		osal_semaphore_release(sto_wr_sema);
		CAS_ERROR_PRINTF("MEM_Write: seek base failed!\n");
		sto_io_control(sto_flash_dev,STO_FLAG_SAVE_REST,NULL);
		sto_io_control(sto_flash_dev, STO_DRIVER_SET_FLAG, 0);
		if(buffer)
			osal_memory_free(buffer);
		return !SUCCESS;
	}
	ret = sto_write(sto_flash_dev, write_buffer, write_size);
	if((UINT32) ret != write_size)
	{
		osal_semaphore_release(sto_wr_sema);
		CAS_ERROR_PRINTF("MEM_Write: here is not blank at:%x!\n", write_buffer);
		sto_io_control(sto_flash_dev,STO_FLAG_SAVE_REST,NULL);
		sto_io_control(sto_flash_dev, STO_DRIVER_SET_FLAG, 0);
		if(buffer)
			osal_memory_free(buffer);
		return !SUCCESS;
	}
	sto_io_control(sto_flash_dev,STO_FLAG_SAVE_REST,NULL);
	sto_io_control(sto_flash_dev, STO_DRIVER_SET_FLAG, 0);
	if(buffer)
		osal_memory_free(buffer);
//	osal_semaphore_release(sto_wr_sema);
	return SUCCESS;
#else
	ret = sto_modify(sto_flash_dev, key_table_addr, write_buffer, write_size);
	if((UINT32) ret != write_size)
	{
		CAS_ERROR_PRINTF("MEM_Write: write flash error!\n");
		return !SUCCESS;
	}
#endif
}

INT32 api_cas_mem_read(UINT8* read_buffer, UINT32 read_size)
{
	UINT32 key_table_addr;
	UINT32 chunk_id = KEY_TABLE_CHUNK_ID;
	CHUNK_HEADER chuck_hdr;

	if((read_buffer == NULL) || (read_size <= 0))
	{
		CAS_ERROR_PRINTF("MEM_Read: invalid parameter\n");
		return !SUCCESS;
	}
	
	/* get table info base addr by using chunk */
	if(get_chunk_header(chunk_id, &chuck_hdr) == 0)
	{
		CAS_ERROR_PRINTF("MEM_Read: get keytable base addr failed!\n");
		return !SUCCESS;
	}
	key_table_addr = (UINT32) chunk_goto(&chunk_id, 0xFFFFFFFF, 1) + CHUNK_HEADER_SIZE;

//	CAS_DEBUG_PRINTF("MEM_Read: key_table_addr=%x!\n", key_table_addr);

	MEMCPY(read_buffer, (UINT8 *) key_table_addr, read_size);	//Can not do this with updated interface
		
	return SUCCESS;
}

#ifdef  _Patch 
INT32 api_cas_load_keycode()
{
	UINT32 key_table_addr;
	UINT32 chunk_id = KEY_TABLE_CHUNK_ID;
	CHUNK_HEADER chuck_hdr;

	/* get table info base addr by using chunk */
	if(get_chunk_header(chunk_id, &chuck_hdr) == 0)
	{
		cas_print("api_cas_load_keycode :: get_chunk_header    failed\r\n");
		return !SUCCESS;
	}
	key_table_addr = (UINT32) chunk_goto(&chunk_id, 0xFFFFFFFF, 1) + CHUNK_HEADER_SIZE;

	if(RearrangeCASEditDBFromFlash((UINT8 *) key_table_addr, (0x10000-128))){
		return SUCCESS;
	}
		
	cas_print("api_cas_load_keycode ::     failed\r\n");
	return !SUCCESS;
}

unsigned char * api_cas_get_addr()
{
	UINT32 chunk_id = KEY_TABLE_CHUNK_ID;
	CHUNK_HEADER chuck_hdr;

	/* get table info base addr by using chunk */
	if(get_chunk_header(chunk_id, &chuck_hdr) == 0)
	{
		cas_print("api_cas_get_addr :: get_chunk_header    failed\r\n");
		return CAS_NULL;
	}
	return (unsigned char *)(chunk_goto(&chunk_id, 0xFFFFFFFF, 1) + CHUNK_HEADER_SIZE);
}


#endif