if101_operation.c~

cmmb if101 linux driver sample

/* 
 * IF101 Operations Definition 
 * 
 * The API define the available function call for customer IF101 driver   
 *
 * Innofidei Inc.
 *
 * By: Mason Chen <[e-mail]>
 *
 * Release:
 * 	Version 0.1 	: 20080106
 * 	Version 0.2 	: 20080123
 *
 */

#include "IF101_Operation.h"
#include "IF101_Communication.h"

/*
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/delay.h>
*/



static INNO_RETURN_CODE INNO_SPI_Exec_Cmd(int cmd, unsigned char *rsp);
static INNO_RETURN_CODE INNO_I2C_Send_Cmd(unsigned char *cmd);
static INNO_RETURN_CODE INNO_I2C_Read_Rsp(unsigned char *rsp, unsigned char cmd);

INNO_RETURN_CODE INNO_SPI_Test(void)
{
	unsigned char data;
	INNO_RETURN_CODE ret = INNO_NO_ERROR;

	ret = INNO_SPI_Write_One_Byte(0x1);
	
	if(ret == INNO_NO_ERROR)
		printk("write one byte successfully");
	else
		printk("write one byte failed");

	ret = INNO_SPI_Read_One_Byte(&data);
	
	if(ret == INNO_NO_ERROR)
		printk("read one byte successfully");
	else
		printk("read one byte failed");

	printk("read data == %d", data);		

	if(data == 0x42)
		return INNO_NO_ERROR;
	else
		return INNO_GENERAL_ERROR;
}

INNO_RETURN_CODE INNO_GetChannelLength(unsigned int *lg0_channel_length, unsigned int *lg1_channel_length)
{
	INNO_RETURN_CODE ret = INNO_NO_ERROR;	
	unsigned char intr_status;
	unsigned char l_byte = 0, m_byte = 0, h_byte = 0;

	*lg0_channel_length = 0; 
	*lg1_channel_length = 0; 

	INNO_SPI_Exec_Cmd(READ_INT_STATUS, &intr_status);
	if(intr_status & LG0_DATA_RDY){
		ret = INNO_SPI_Exec_Cmd(READ_LG0_LEN_LOW, &l_byte);
		ret = INNO_SPI_Exec_Cmd(READ_LG0_LEN_MID, &m_byte);
		ret = INNO_SPI_Exec_Cmd(READ_LG0_LEN_HIGH,&h_byte);
		if(ret != INNO_NO_ERROR)
			return ret;

		*lg0_channel_length = (h_byte << 16) | (m_byte << 8) | l_byte;
	} 

	l_byte = 0; 
	m_byte = 0; 
	h_byte = 0;
	if(intr_status & LG1_DATA_RDY){
		ret = INNO_SPI_Exec_Cmd(READ_LG1_LEN_LOW, &l_byte);
		ret = INNO_SPI_Exec_Cmd(READ_LG1_LEN_MID, &m_byte);
		ret = INNO_SPI_Exec_Cmd(READ_LG1_LEN_HIGH, &h_byte);
		if(ret != INNO_NO_ERROR)
			return ret;

		*lg1_channel_length = (h_byte << 16) | (m_byte << 8) | l_byte;
	} 
	
	return ret;
} 

INNO_RETURN_CODE INNO_GetChannelData(CHANNEL_NUM channel_num, unsigned char *buffer, int channel_length)
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;
	unsigned char fetch_data_cmd = 0;

	switch(channel_num){
		case LG0_CHANNEL:
			fetch_data_cmd = (unsigned char)FETCH_LG0_DATA; 		
			break;
		case LG1_CHANNEL:
			fetch_data_cmd = (unsigned char)FETCH_LG1_DATA; 		
			break;
		default:
			return INNO_PARAMETER_ERROR;
	}	

	ret = INNO_SPI_Write_One_Byte(fetch_data_cmd);
	if(ret != INNO_NO_ERROR)
		return ret;
	
	ret = INNO_SPI_Read_Bytes(buffer, channel_length); 
	if(ret != INNO_NO_ERROR)
		return ret;

	return ret;

}

INNO_RETURN_CODE INNO_I2C_Test(void)
{
	unsigned char data = 0;
	printk("INNO_i2c_test\n");//zc

	INNO_I2C_Write(0xFF, 0);

//	INNO_I2C_Read(0x0bd, &data);
//	printk("data === %d", data);	

	INNO_I2C_Write(0xBF, 0x55);
	INNO_I2C_Read(0xBF, &data);
	if(data == 0x55)
		return INNO_NO_ERROR;
	else{ 
		return INNO_GENERAL_ERROR;
	}

}

INNO_RETURN_CODE INNO_GetFirmwareVersion(unsigned char *major_version, unsigned char *minor_version)
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;
	unsigned char cmd[8] = {0,0,0,0,0,0,0,0};
	unsigned char rsp[8] = {0,0,0,0,0,0,0,0};

	cmd[0] = CMD_GET_FW_VER;
	ret = INNO_I2C_Send_Cmd(cmd);
	if(ret != INNO_NO_ERROR){
		return ret;
	}

	ret = INNO_I2C_Read_Rsp(rsp, cmd[0]);
	if(ret != INNO_NO_ERROR){
		return ret;
	}

	*major_version = rsp[1];
	*minor_version = rsp[3];

	return ret;
}

INNO_RETURN_CODE INNO_SetTunerFrequency(unsigned char frequency_dot, CP_TYPE cp_type)
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;
	unsigned char cmd[8] = {0,0,0,0,0,0,0,0};

	cmd[0] = CMD_SET_FREQUENCY;
	cmd[1] = frequency_dot;
	cmd[2] = cp_type;
	ret = INNO_I2C_Send_Cmd(cmd);

	return ret;
}


INNO_RETURN_CODE INNO_ScanFrequency(unsigned char freq_start, unsigned char freq_end)
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;
	unsigned char cmd[8] = {0,0,0,0,0,0,0,0};

	cmd[0] = CMD_SCAN_FREQUENCY;
	cmd[1] = freq_start;
	cmd[2] = freq_end;
	cmd[3] = 0x01;
	ret = INNO_I2C_Send_Cmd(cmd);

	return ret;

}

INNO_RETURN_CODE INNO_SetPowerManagement(PM_MODE pm)
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;
	unsigned char cmd[8] = {0,0,0,0,0,0,0,0};

	cmd[0] = CMD_SET_PM;
	cmd[1] = pm;
	ret = INNO_I2C_Send_Cmd(cmd);
	if(ret != INNO_NO_ERROR)
		return ret;

	return ret;
}

INNO_RETURN_CODE INNO_SetDemodConfig(DEMOD_CONFIG demod_config[2])
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;
	unsigned char cmd[8] = {0,0,0,0,0,0,0,0};
	int i = 0;
	
	cmd[0] = CMD_SET_CHANNEL_CONFIG;
	for(i = 0; i < 2; i++){
		cmd[i*3+1] = demod_config[i].ts_start & 0x3F;
		cmd[i*3+2] = demod_config[i].ts_count & 0x3F;
		cmd[i*3+3] = ((demod_config[i].modulate_type & 0x3 ) << 6) |
				((demod_config[i].rs_mode & 0x3) << 4) |
				((demod_config[i].outer_mode & 0x3) << 2) | 
				(demod_config[i].ldpc_mode & 0x3);
	}

	ret = INNO_I2C_Send_Cmd(cmd);
	if(ret != INNO_NO_ERROR)
		return ret;

	return ret;
}


INNO_RETURN_CODE INNO_SetReceiveTs0(void)
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;
	DEMOD_CONFIG demod_setting[2];

	demod_setting[0].ts_start = 0;
	demod_setting[0].ts_count = 1;
	demod_setting[0].modulate_type = DEMAP_BPSK; 
	demod_setting[0].rs_mode = RS_240_240; 
	demod_setting[0].outer_mode = OUTER_MODE_1; 
	demod_setting[0].ldpc_mode = LDPC_1_DIV_2; 

	demod_setting[1].ts_start = 0;
	demod_setting[1].ts_count = 0;
	demod_setting[1].modulate_type = 0; 
	demod_setting[1].rs_mode = 0; 
	demod_setting[1].outer_mode = 0; 
	demod_setting[1].ldpc_mode = 0; 

	ret = INNO_SetDemodConfig(demod_setting);

	return ret;
}

INNO_RETURN_CODE INNO_SetReceiveProgram(int channel_0_ts_start,int channel_0_ts_count,int channel_1_ts_start, int channel_1_ts_count)
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;
	DEMOD_CONFIG demod_setting[2];

	demod_setting[0].ts_start = channel_0_ts_start;
	demod_setting[0].ts_count = channel_0_ts_count;
	demod_setting[0].modulate_type = DEMAP_QPSK; 
	demod_setting[0].rs_mode = RS_240_224; 
	demod_setting[0].outer_mode = OUTER_MODE_1; 
	demod_setting[0].ldpc_mode = LDPC_1_DIV_2; 

	demod_setting[1].ts_start = channel_1_ts_start;
	demod_setting[1].ts_count = channel_1_ts_count;
	demod_setting[1].modulate_type = DEMAP_QPSK; 
	demod_setting[1].rs_mode = RS_240_224; 
	demod_setting[1].outer_mode = OUTER_MODE_1; 
	demod_setting[1].ldpc_mode = LDPC_1_DIV_2; 

	ret = INNO_SetDemodConfig(demod_setting);

	return ret;
}


INNO_RETURN_CODE INNO_GetDemodConfig(DEMOD_CONFIG demod_config[2])
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;
	unsigned char cmd[8] = {0,0,0,0,0,0,0,0};
	unsigned char rsp[8] = {0,0,0,0,0,0,0,0};

	cmd[0] = CMD_GET_CHANNEL_CONFIG;

	ret = INNO_I2C_Send_Cmd(cmd);
	if(ret != INNO_NO_ERROR)
		return ret;

	ret = INNO_I2C_Read_Rsp(rsp, cmd[0]);
	if(ret != INNO_NO_ERROR)
		return ret;

	demod_config[0].ts_start = rsp[1];
	demod_config[0].ts_count = rsp[2];
	demod_config[0].modulate_type = (rsp[3] >> 6) & 0x3;
	demod_config[0].rs_mode = (rsp[3] >> 4) & 0x3;
	demod_config[0].outer_mode = (rsp[3] >> 2) & 0x3;
	demod_config[0].ldpc_mode = rsp[3] & 0x3;

	demod_config[1].ts_start = rsp[4];
	demod_config[1].ts_count = rsp[5];
	demod_config[1].modulate_type = (rsp[6] >> 6) & 0x3;
	demod_config[1].rs_mode = (rsp[6] >> 4) & 0x3;
	demod_config[1].outer_mode = (rsp[6] >> 2) & 0x3;
	demod_config[1].ldpc_mode = rsp[6] & 0x3;

	
	return ret;
}

INNO_RETURN_CODE INNO_GetSystemStatus(SYS_STATUS *sys_status)
{
	unsigned char data;
	
	INNO_I2C_Write(0xFF, 0);

	INNO_I2C_Read(0xCC,&data);
	sys_status->lock = (data == 0x8);

	INNO_I2C_Read(0xBC, &data);
	sys_status->cp_type = data & 0x1;
	sys_status->scan_result = (data & 0x2) >> 1;
	sys_status->scan_process = (data & 0x4) >> 2;

	INNO_I2C_Read(0xBD, &data);
	sys_status->current_frequency = data;

	INNO_I2C_Read(0xBE, &data);
	sys_status->signal_strength = data;

	INNO_I2C_Read(0xBF, &data);
	sys_status->ldpc_err_percent = data;

	return INNO_NO_ERROR;
}




static INNO_RETURN_CODE INNO_SPI_Exec_Cmd(int cmd, unsigned char *rsp)
{
	INNO_RETURN_CODE ret = INNO_GENERAL_ERROR;

	ret = INNO_SPI_Write_One_Byte((unsigned char)cmd);	
	if(ret != INNO_NO_ERROR)
		return ret;

	ret = INNO_SPI_Read_One_Byte(rsp);
	if(ret != INNO_NO_ERROR)
		return ret;

	return ret;
}

static INNO_RETURN_CODE INNO_I2C_Write_Byte(unsigned char value, unsigned char CodeOrPayload)
{	
	unsigned char status = 0;
	int j = 0;
	//int i = 0;

	INNO_I2C_Write(0xFF, I2C_COMMUNICATION_PAGE);
	for(j = 0; j< 1000; j++){
		INNO_I2C_Read(I2C_CMD_STATUS_ADDR, &status);
		if((status & CMD_BUSY) == 0){ 
			INNO_I2C_Write(I2C_CMD_DATA_ADDR, value);
			INNO_I2C_Write(I2C_CMD_STATUS_ADDR, CodeOrPayload);
			return INNO_NO_ERROR;

		}
		//please add 1ms delay here
	//	for(i = 0; i < 1000; i++);
		medelay(1);
	}

	//timeout
	return INNO_TIMEOUT_ERROR;

}

static INNO_RETURN_CODE INNO_I2C_Read_Byte(unsigned char *value)
{	
	unsigned char Local_Sen_Status = 0;
	int j = 0;
	//int i = 0;

	INNO_I2C_Write(0xFF, I2C_COMMUNICATION_PAGE);
	for(j = 0; j< 1000; j++){
		INNO_I2C_Read(I2C_RSP_STATUS_ADDR, &Local_Sen_Status);
		if((Local_Sen_Status & RSP_DATA_VALID) == RSP_DATA_VALID){
			INNO_I2C_Read(I2C_RSP_DATA_ADDR, value);
			INNO_I2C_Write(I2C_RSP_STATUS_ADDR, 0x0);
			return INNO_NO_ERROR;
		}
		//please add 1ms delay here	
		mdelay(1);

	}

	//timeout
	return INNO_TIMEOUT_ERROR;
}

static INNO_RETURN_CODE INNO_I2C_Send_Cmd(unsigned char *cmd)
{
	unsigned char Local_CRC = 0xA5;
	int ret = INNO_NO_ERROR;
	int i = 0;
	unsigned char end = 0;


	ret = INNO_I2C_Write_Byte(cmd[0], CMD_CODE);
	if(ret != INNO_NO_ERROR)
	{
		printk("write cmd_code error!\n");
		return ret;
	}

	Local_CRC ^= cmd[0];

	for(i = 1; i< 7; i++){
		ret = INNO_I2C_Write_Byte(cmd[i], CMD_PAYLOAD);
		if(ret != INNO_NO_ERROR)
		{
			printk("write payload error!\n");	
			return ret;
		}
		Local_CRC ^= cmd[i];
	}

	cmd[7] = Local_CRC;

	ret = INNO_I2C_Write_Byte(Local_CRC, CMD_PAYLOAD);
	if(ret != INNO_NO_ERROR)
	{
		printk("write cmdpayload error\n");
		return ret;
	}

	for(i = 0; i< 100; i++){
		ret = INNO_I2C_Read_Byte(&end);
		if(ret != INNO_NO_ERROR)
		{	
			printk("read error!!!!\n");
			return ret;
		}
		else
		{
			printk("read successfully\n");
		}
		if(end == 0xF9)
			return INNO_NO_ERROR;

	}

	return INNO_FW_OPERATION_ERROR;
}

static INNO_RETURN_CODE INNO_I2C_Read_Rsp(unsigned char *rsp, unsigned char cmd)
{
	unsigned char Local_CRC = 0xA5;
	int i = 0;
	int ret = 0;

	for(i = 0; i< 7; i++){
		ret = INNO_I2C_Read_Byte(rsp + i);
		if(ret != INNO_NO_ERROR)
			return ret;
		Local_CRC ^= rsp[i];
	}

	
	INNO_I2C_Read_Byte(rsp + 7);
	if(Local_CRC == rsp[7])		//FIXME: FW bug? should use above if()?
		return INNO_NO_ERROR;
	else 
		return INNO_FW_OPERATION_ERROR;
}


/*
static unsigned char Get_Freq_Num(unsigned int freq)
{
	unsigned char i = 0;
	for(i = 0; i< 70; i++)
		if(FREQ_TABLE[i] == freq)
			return i;

	return 0;
}
*/