uint8_t AT24_read(struct eeprom_data *data) {
uint8_t ret = ESUCCESS;
uint8_t counter = 0;
uint8_t *p;
struct eeprom_data *tmp = (struct eeprom_data *)malloc(sizeof(tmp));
memset(tmp, 0, EEPROM_MU_WR_SIZE);
// Send EEPROM's i2c address + raise read flag
ret = I2CStart(at24_addr | TW_READ);
if (ret > 0)
return ret;
// Read one page
do {
if (counter + 1 == EEPROM_MU_WR_SIZE)
ret = I2CReadByte(p, I2C_NOACK);
else
ret = I2CReadByte(p, I2C_ACK);
if (ret > 0)
return EEEPDATAREAD;
tmp += *p++;
counter++;
} while (counter != EEPROM_MU_WR_SIZE);
I2CStop();
data = tmp;
return ESUCCESS;
}
int8_t *readAlarm(void)
{
uint8_t temp;
uint8_t i;
I2CStart(DS1307_ADDR);
I2CWriteByte(DS1307_A0_HOUR);
I2CStart(DS1307_ADDR | I2C_READ);
for (i = DS1307_A0_HOUR; i < DS1307_A0_WDAY; i++) {
temp = I2CReadByte(I2C_ACK);
alarm[i - DS1307_A0_HOUR] = temp;
}
temp = I2CReadByte(I2C_NOACK);
alarm[DS1307_A0_WDAY - DS1307_A0_HOUR] = temp;
I2CStop();
return alarm;
}
void I2CWriteBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t value) {
uint8_t b;
uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
I2CReadByte(devAddr, regAddr, &b);
value <<= (bitStart - length + 1);
value &= mask;
b &= ~(mask);
b |= value;
I2CWriteByte(devAddr, regAddr, b);
}
static int adv7179_device_init(void)
{
unsigned char regvalue1, regvalue2;
regvalue1 = I2CReadByte(I2C_ADV7179, 0x07);
I2CWriteByte(I2C_ADV7179, 0x07, 0xa5);
regvalue2 = I2CReadByte(I2C_ADV7179, 0x07);
if (regvalue2 != 0xa5)
{
printk("read adv7179 register is %x\n", regvalue2);
printk("check adv7179 error.\n");
return -EFAULT;
}
I2CWriteByte(I2C_ADV7179, 0x07, regvalue1);
if (norm_mode == VIDEO_NORM_NTSC)
{
if (init_vda(VIDEO_MODE_CCIR656, VIDEO_NORM_NTSC, VIDEO_MODE_MASTER) == 0)
{
return 0;
}
else
{
return -EFAULT;
}
}
else
{
if (init_vda(VIDEO_MODE_CCIR656, VIDEO_NORM_PAL, VIDEO_MODE_MASTER) == 0)
{
return 0;
}
else
{
return -EFAULT;
}
}
}
/**
@brief Get E4000 register byte.
*/
int
e4000_GetRegByte(
TUNER_MODULE *pTuner,
unsigned char RegAddr,
unsigned char *pReadingByte
)
{
// Call I2CReadByte() to read tuner register.
if(I2CReadByte(pTuner, NO_USE, RegAddr, pReadingByte) != E4000_I2C_SUCCESS)
goto error_status_execute_function;
return FUNCTION_SUCCESS;
error_status_execute_function:
return FUNCTION_ERROR;
}
uint8_t DS1307Read(uint8_t address,uint8_t *data)
{
uint8_t res; //result
//Start
I2CStart();
//SLA+W (for dummy write to set register pointer)
res=I2CWriteByte(0b11010000); //DS1307 address + W
//Error
if(!res) return FALSE;
//Now send the address of required register
res=I2CWriteByte(address);
//Error
if(!res) return FALSE;
//Repeat Start
I2CStart();
//SLA + R
res=I2CWriteByte(0b11010001); //DS1307 Address + R
//Error
if(!res) return FALSE;
//Now read the value with NACK
res=I2CReadByte(data,0);
//Error
if(!res) return FALSE;
//STOP
I2CStop();
return TRUE;
}
void I2CWriteBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t value) {
uint8_t b;
I2CReadByte(devAddr, regAddr, &b);
b = (value != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
I2CWriteByte(devAddr, regAddr, b);
}
void I2CReadBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *value) {
I2CReadByte(devAddr, regAddr, value);
*value = *value & (1 << bitNum);
}
void I2CReadBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *value) {
uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
I2CReadByte(devAddr, regAddr, value);
*value &= mask;
*value >>= (bitStart - length + 1);
}
/****************************************************************************\
* Function: GainControlinit
*
* Detailed Description:
* Configures gain control mode. (Registers 0x1d, 0x1e, 0x1f, 0x20, 0x21,
* 0x1a, 0x74h, 0x75h).
* User may wish to modify values depending on usage scenario.
* Routine configures LNA: autonomous gain control
* IF PWM gain control.
* PWM thresholds = default
* Mixer: switches when LNA gain =7.5dB
* Sensitivity / Linearity mode: manual switch
*
\****************************************************************************/
int GainControlinit(TUNER_MODULE *pTuner)
{
unsigned char writearray[5];
unsigned char read1[1];
int status;
unsigned char sum=255;
writearray[0] = 23;
status=I2CWriteByte(pTuner, 200,26,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
//printf("\nRegister 1a=%d", writearray[0]);
status=I2CReadByte(pTuner, 201,27,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
writearray[0] = 16;
writearray[1] = 4;
writearray[2] = 26;
writearray[3] = 15;
writearray[4] = 167;
status=I2CWriteArray(pTuner, 200,29,5,writearray);
//printf("\nRegister 1d=%d", writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
writearray[0] = 81;
status=I2CWriteByte(pTuner, 200,134,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
//printf("\nRegister 86=%d", writearray[0]);
//For Realtek - gain control logic
status=I2CReadByte(pTuner, 201,27,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
if(read1[0]<=sum)
{
sum=read1[0];
}
status=I2CWriteByte(pTuner, 200,31,writearray[2]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
status=I2CReadByte(pTuner, 201,27,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
if(read1[0] <= sum)
{
sum=read1[0];
}
status=I2CWriteByte(pTuner, 200,31,writearray[2]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
status=I2CReadByte(pTuner, 201,27,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
if(read1[0] <= sum)
{
sum=read1[0];
}
status=I2CWriteByte(pTuner, 200,31,writearray[2]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
status=I2CReadByte(pTuner, 201,27,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
if(read1[0] <= sum)
{
sum=read1[0];
}
status=I2CWriteByte(pTuner, 200,31,writearray[2]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
status=I2CReadByte(pTuner, 201,27,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
if (read1[0]<=sum)
{
sum=read1[0];
}
writearray[0]=sum;
status=I2CWriteByte(pTuner, 200,27,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
//printf("\nRegister 1b=%d", writearray[0]);
//printf("\nRegister 1e=%d", writearray[1]);
//printf("\nRegister 1f=%d", writearray[2]);
//printf("\nRegister 20=%d", writearray[3]);
//printf("\nRegister 21=%d", writearray[4]);
//writearray[0] = 3;
//writearray[1] = 252;
//writearray[2] = 3;
//writearray[3] = 252;
//I2CWriteArray(pTuner, 200,116,4,writearray);
//printf("\nRegister 74=%d", writearray[0]);
//printf("\nRegister 75=%d", writearray[1]);
//printf("\nRegister 76=%d", writearray[2]);
//printf("\nRegister 77=%d", writearray[3]);
return E4000_1_SUCCESS;
}
/****************************************************************************\
* Function: DCoffLUT
*
* Detailed Description:
* Populates DC offset LUT. (Registers 0x50 - 0x53, 0x60 - 0x63).
*
\****************************************************************************/
int DCoffLUT(TUNER_MODULE *pTuner)
{
unsigned char writearray[5];
int status;
unsigned char read1[1];
unsigned char IOFF;
unsigned char QOFF;
unsigned char RANGE1;
// unsigned char RANGE2;
unsigned char QRANGE;
unsigned char IRANGE;
writearray[0] = 0;
writearray[1] = 126;
writearray[2] = 36;
status=I2CWriteArray(pTuner, 200,21,3,writearray);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Sets mixer & IF stage 1 gain = 00 and IF stg 2+ to max gain.
writearray[0] = 1;
status=I2CWriteByte(pTuner, 200,41,writearray[0]);
// Instructs a DC offset calibration.
status=I2CReadByte(pTuner, 201,42,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
IOFF=read1[0];
status=I2CReadByte(pTuner, 201,43,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
QOFF=read1[0];
status=I2CReadByte(pTuner, 201,44,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
RANGE1=read1[0];
//reads DC offset values back
if(RANGE1>=32)
{
RANGE1 = RANGE1 -32;
}
if(RANGE1>=16)
{
RANGE1 = RANGE1 - 16;
}
IRANGE=RANGE1;
QRANGE = (read1[0] - RANGE1) / 16;
writearray[0] = (IRANGE * 64) + IOFF;
status=I2CWriteByte(pTuner, 200,96,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
writearray[0] = (QRANGE * 64) + QOFF;
status=I2CWriteByte(pTuner, 200,80,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Populate DC offset LUT
writearray[0] = 0;
writearray[1] = 127;
status=I2CWriteArray(pTuner, 200,21,2,writearray);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Sets mixer & IF stage 1 gain = 01 leaving IF stg 2+ at max gain.
writearray[0]= 1;
status=I2CWriteByte(pTuner, 200,41,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Instructs a DC offset calibration.
status=I2CReadByte(pTuner, 201,42,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
IOFF=read1[0];
status=I2CReadByte(pTuner, 201,43,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
QOFF=read1[0];
status=I2CReadByte(pTuner, 201,44,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
RANGE1=read1[0];
// Read DC offset values
if(RANGE1>=32)
{
RANGE1 = RANGE1 -32;
}
if(RANGE1>=16)
{
RANGE1 = RANGE1 - 16;
}
IRANGE = RANGE1;
QRANGE = (read1[0] - RANGE1) / 16;
writearray[0] = (IRANGE * 64) + IOFF;
status=I2CWriteByte(pTuner, 200,97,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
writearray[0] = (QRANGE * 64) + QOFF;
status=I2CWriteByte(pTuner, 200,81,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Populate DC offset LUT
writearray[0] = 1;
status=I2CWriteByte(pTuner, 200,21,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Sets mixer & IF stage 1 gain = 11 leaving IF stg 2+ at max gain.
writearray[0] = 1;
status=I2CWriteByte(pTuner, 200,41,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Instructs a DC offset calibration.
status=I2CReadByte(pTuner, 201,42,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
IOFF=read1[0];
status=I2CReadByte(pTuner, 201,43,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
QOFF=read1[0];
status=I2CReadByte(pTuner, 201,44,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
RANGE1 = read1[0];
// Read DC offset values
if(RANGE1>=32)
{
RANGE1 = RANGE1 -32;
}
if(RANGE1>=16)
{
RANGE1 = RANGE1 - 16;
}
IRANGE = RANGE1;
QRANGE = (read1[0] - RANGE1) / 16;
writearray[0] = (IRANGE * 64) + IOFF;
status=I2CWriteByte(pTuner, 200,99,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
writearray[0] = (QRANGE * 64) + QOFF;
status=I2CWriteByte(pTuner, 200,83,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Populate DC offset LUT
writearray[0] = 126;
status=I2CWriteByte(pTuner, 200,22,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Sets mixer & IF stage 1 gain = 11 leaving IF stg 2+ at max gain.
writearray[0] = 1;
status=I2CWriteByte(pTuner, 200,41,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
// Instructs a DC offset calibration.
status=I2CReadByte(pTuner, 201,42,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
IOFF=read1[0];
status=I2CReadByte(pTuner, 201,43,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
QOFF=read1[0];
status=I2CReadByte(pTuner, 201,44,read1);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
RANGE1=read1[0];
// Read DC offset values
if(RANGE1>=32)
{
RANGE1 = RANGE1 -32;
}
if(RANGE1>=16)
{
RANGE1 = RANGE1 - 16;
}
IRANGE = RANGE1;
QRANGE = (read1[0] - RANGE1) / 16;
writearray[0]=(IRANGE * 64) + IOFF;
status=I2CWriteByte(pTuner, 200,98,writearray[0]);
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
writearray[0] = (QRANGE * 64) + QOFF;
status=I2CWriteByte(pTuner, 200,82,writearray[0]);
// Populate DC offset LUT
if(status != E4000_I2C_SUCCESS)
{
return E4000_1_FAIL;
}
return E4000_1_SUCCESS;
}
