void fc8080_isr(HANDLE handle)
{
u16 buf_int_status = 0;
u16 buf_ovr_status;
bbm_word_read(handle, BBM_BUF_STATUS, &buf_int_status);
bbm_word_read(handle, BBM_BUF_OVERRUN, &buf_ovr_status);
if (buf_int_status) {
bbm_word_write(handle, BBM_BUF_STATUS, buf_int_status);
fc8080_data(handle, buf_int_status);
if(buf_ovr_status) {
bbm_word_write(handle, BBM_BUF_OVERRUN, buf_ovr_status);
bbm_word_write(handle, BBM_BUF_OVERRUN, 0);
DPRINTK("[FC8080] Overrun clear\n");
}
}
#ifdef FC8080_OVERRUN_CLEAR
else {
if (buf_ovr_status) {
bbm_word_write(handle, BBM_BUF_OVERRUN, buf_ovr_status);
bbm_word_write(handle, BBM_BUF_OVERRUN, 0);
DPRINTK("[FC8080] Overrun occurred : 0x%x \n"
, buf_ovr_status);
fc8080_data(handle, buf_ovr_status);
}
}
#endif
}
int fci_i2c_init (HANDLE hDevice, int speed, int slaveaddr)
{
#if !defined (USE_PM8941_XO_A2)
u16 r = FC8150_FREQ_XTAL % (5 * speed);
u16 pr = (FC8150_FREQ_XTAL - r) / (5 * speed) - 1;
#else /* USE_PM8941_XO_A2 */
u16 r = 0;
u16 pr = 0;
u16 fc8150_freq_xtal = 19200;
if (use_pm8941_xo_a2_192000 == 1) {
fc8150_freq_xtal = 19200;
}
else {
fc8150_freq_xtal = 26000;
}
r = fc8150_freq_xtal % (5 * speed);
pr = (fc8150_freq_xtal - r) / (5 * speed) - 1;
#endif /* USE_PM8941_XO_A2 */
if(((5 * speed) >> 1) <= r)
pr++;
bbm_word_write(hDevice, BBM_I2C_PR_L, pr);
bbm_write(hDevice, BBM_I2C_CTR, 0xc0);
return BBM_OK;
}
int bbm_com_word_write(HANDLE hDevice, u16 addr, u16 data)
{
int res;
res = bbm_word_write(hDevice, addr, data);
return res;
}
void fc8080_isr(HANDLE handle)
{
u16 buf_int_status = 0;
bbm_word_read(handle, BBM_BUF_STATUS, &buf_int_status);
if (buf_int_status) {
bbm_word_write(handle, BBM_BUF_STATUS, buf_int_status);
fc8080_data(handle, buf_int_status);
}
buf_int_status = 0;
bbm_word_read(handle, BBM_BUF_STATUS, &buf_int_status);
if (buf_int_status) {
bbm_word_write(handle, BBM_BUF_STATUS, buf_int_status);
fc8080_data(handle, buf_int_status);
}
}
s32 bbm_com_word_write(HANDLE handle, DEVICEID devid, u16 addr, u16 data)
{
s32 res;
res = bbm_word_write(handle, devid, addr, data);
return res;
}
fci_s32 bbm_com_word_write(HANDLE handle, fci_u16 addr, fci_u16 data)
{
fci_s32 res;
res = bbm_word_write(handle, addr, data);
return res;
}
int BBM_WORD_WRITE(HANDLE hDevice, u16 addr, u16 data)
{
int res;
res = bbm_word_write(hDevice, addr, data);
return res;
}
int fci_i2c_init (HANDLE hDevice, int speed, int slaveaddr)
{
u16 r = bbm_xtal_freq % (5 * speed);
u16 pr = (bbm_xtal_freq - r) / (5 * speed) - 1;
if(((5 * speed) >> 1) <= r)
pr++;
bbm_word_write(hDevice, BBM_I2C_PR_L, pr);
bbm_write(hDevice, BBM_I2C_CTR, 0xc0);
return BBM_OK;
}
fci_s32 fci_hpi_write(HANDLE handle, fci_u8 chip, fci_u8 addr, fci_u8 alen, fci_u8 *data, fci_u8 len)
{
#ifdef FC8080_SPI
fci_s32 i;
for (i = 0; i < len; i++, data++)
bbm_word_write(handle, 0x0f00 | addr, (*data << 8) | *data);
#else
fci_s32 i;
for (i = 0; i < len; i++, data++)
bbm_write(handle, 0x0f00 | addr, *data);
/*return bbm_bulk_write(handle, 0x0f00 | addr, data, len);*/
#endif
return BBM_OK;
}
int fci_i2c_init (HANDLE hDevice, int speed, int slaveaddr)
{
fci_u16 pr, rpr =0;
pr = (fci_u16)((4800/speed) -1);
//pr=400;
bbm_word_write(hDevice, BBM_I2C_PR, pr);
bbm_word_read(hDevice, BBM_I2C_PR, &rpr);
if(pr != rpr) {
return BBM_NOK;
}
//i2c master core enable & interrupt enable
bbm_write(hDevice, BBM_I2C_CTR, 0xC0);
return BBM_OK;
}
s32 fci_hpi_write(HANDLE handle, DEVICEID devid,
u8 chip, u8 addr, u8 alen, u8 *data, u8 len)
{
#if !defined(BBM_I2C_SPI) && !defined(BBM_I2C_TSIF) && defined(BBM_ES) /* ONLY ES SPI */
s32 i;
mutex_lock(&fci_hpi_lock);
for (i = 0; i < len; i++, data++)
bbm_word_write(handle, devid, 0x0f00 | addr,
(*data << 8) | *data);
mutex_unlock(&fci_hpi_lock);
#else
s32 i;
mutex_lock(&fci_hpi_lock);
for (i = 0; i < len; i++, data++)
bbm_write(handle, devid, 0x0f00 | addr, *data);
mutex_unlock(&fci_hpi_lock);
#endif
return BBM_OK;
}
void fc8050_isr(HANDLE hDevice)
{
fci_u8 extIntStatus = 0;
//bbm_write(hDevice, BBM_COM_INT_ENABLE, 0);
bbm_read(hDevice, BBM_COM_INT_STATUS, &extIntStatus);
bbm_write(hDevice, BBM_COM_INT_STATUS, extIntStatus);
bbm_write(hDevice, BBM_COM_INT_STATUS, 0x00);
if(extIntStatus & BBM_MF_INT) {
fci_u16 mfIntStatus = 0;
fci_u16 size;
int i;
bbm_word_read(hDevice, BBM_BUF_STATUS, &mfIntStatus);
//bbm_word_write(hDevice, BBM_BUF_STATUS, mfIntStatus);
//bbm_word_write(hDevice, BBM_BUF_STATUS, 0x0000);
if(mfIntStatus & 0x0100) {
bbm_word_read(hDevice, BBM_BUF_FIC_THR, &size);
//wonhee.jeong test
if(size > 516)
{
printk("FIC Data size is bigger than 516.\n");
}
//
size += 1;
if(size-1) {
bbm_data(hDevice, BBM_COM_FIC_DATA, &ficBuffer[0], size);
if(pFicCallback)
(*pFicCallback)((fci_u32) hDevice, &ficBuffer[0], size);
}
}
for(i=0; i<8; i++) {
if(mfIntStatus & (1<<i)) {
bbm_word_read(hDevice, BBM_BUF_CH0_THR+i*2, &size);
//wonhee.jeong test
if(size > 8196)
{
printk("MSC Data size is bigger than 8196.\n");
}
//
size += 1;
if(size-1) {
fci_u8 subChId;
bbm_read(hDevice, BBM_BUF_CH0_SUBCH+i, &subChId);
subChId = subChId & 0x3f;
{
fci_u8 rsSubChId;
bbm_read(hDevice, BBM_CDI0_SUBCH_EN, &rsSubChId);
rsSubChId &= 0x3F;
if(rsSubChId == subChId)
tp_total_cnt += size/188;
}
bbm_data(hDevice, (BBM_COM_CH0_DATA+i), &mscBuffer[0], size);
if(size>384)
{
if(pMscCallback)
(*pMscCallback)(gMscUserData, subChId, &mscBuffer[2], size);
}
else
{
if(pMscCallback)
(*pMscCallback)(gMscUserData, subChId, &mscBuffer[0], size);
}
}
}
}
bbm_word_write(hDevice, BBM_BUF_STATUS, mfIntStatus);
bbm_word_write(hDevice, BBM_BUF_STATUS, 0x0000);
}
//bbm_write(hDevice, BBM_COM_INT_ENABLE, ENABLE_INT_MASK);
}
int fc8050_init(HANDLE hDevice)
{
u8 intMask;
fc8050_reset(hDevice);
fc8050_set_xtal(hDevice);
bbm_write(hDevice, BBM_BUF_MISC_CTRL, 0x19);
//bbm_write(hDevice, BBM_24M_CLK_EN, 0xff);
bbm_write(hDevice, BBM_VT_CONTROL, 0x03);
bbm_word_write(hDevice, BBM_SYNC_CNTRL, 0x0020);
bbm_write(hDevice, BBM_FIC_CRC_CONTROL, 0x03);
bbm_write(hDevice, BBM_BUF_TEST_MODE, 0x08);
bbm_write(hDevice, 0x33c, 0x03);
bbm_write(hDevice, BBM_FFT_MODEM_STSH, 0x03);
bbm_write(hDevice, BBM_DIDP_MODE, 0x01);
bbm_write(hDevice, BBM_SYNC_DET_CNTRL, 0x01);
bbm_word_write(hDevice, BBM_SYNC_DET_MAX_THRL, 0x0A00);
bbm_write(hDevice, BBM_SYNC_DET_MODE_ENABLE, 0x01);
bbm_write(hDevice, BBM_BUF_CLOCK_EN, 0xff);
bbm_write(hDevice, BBM_FFT_SCALEV_IFFT, 0xea);
bbm_write(hDevice, BBM_SYNC_FT_RANGE, 0x20);
bbm_write(hDevice, BBM_QDD_AGC530_EN, 0x53);
bbm_write(hDevice, BBM_QDD_BLOCK_AVG_SIZE, 0x48);
bbm_write(hDevice, BBM_QDD_BLOCK_AVG_SIZE_LOCK, 0x49);
bbm_word_write(hDevice, BBM_QDD_GAIN_CONSTANT, 0x0303);
bbm_write(hDevice, BBM_QDD_DET_CNT_BOUND, 0x60);
bbm_write(hDevice, BBM_QDD_REF_AMPL, 0x00);
bbm_write(hDevice, BBM_QDD_BW_CTRL_LOCK, 0x50);
bbm_write(hDevice, BBM_QDD_DC_CTRL, 0x3f);
bbm_write(hDevice, BBM_RS_CONTROL, 0x01);
bbm_word_write(hDevice, BBM_RS_BER_PERIOD, 0x14e);
#if defined(POWER_SAVE_MODE)
bbm_write(hDevice, BBM_DIDP_POWER_OPT0, 0x06);
bbm_write(hDevice, BBM_DIDP_ADD_N_SHIFT0, 0x41);
bbm_write(hDevice, BBM_DIDP_POWER_OPT1, 0x06);
bbm_write(hDevice, BBM_DIDP_ADD_N_SHIFT1, 0xf1);
bbm_write(hDevice, BBM_DIDP_POWER_OPT2, 0x07);
bbm_write(hDevice, BBM_FFT_ADC_CONTROL, 0x1c);
#else
bbm_write(hDevice, BBM_DIDP_POWER_OPT0, 0x04);
bbm_write(hDevice, BBM_DIDP_ADD_N_SHIFT0, 0x21);
bbm_write(hDevice, BBM_DIDP_POWER_OPT1, 0x05);
bbm_write(hDevice, BBM_DIDP_ADD_N_SHIFT1, 0x21);
bbm_write(hDevice, BBM_DIDP_POWER_OPT2, 0x05);
bbm_write(hDevice, BBM_FFT_ADC_CONTROL, 0x9c);
#endif
bbm_word_write(hDevice, BBM_BUF_FIC_START, FIC_BUF_START);
bbm_word_write(hDevice, BBM_BUF_FIC_END, FIC_BUF_END);
bbm_word_write(hDevice, BBM_BUF_FIC_THR, FIC_BUF_THR);
bbm_word_write(hDevice, BBM_BUF_CH0_START, CH0_BUF_START);
bbm_word_write(hDevice, BBM_BUF_CH0_END, CH0_BUF_END);
bbm_word_write(hDevice, BBM_BUF_CH0_THR, CH0_BUF_THR);
bbm_word_write(hDevice, BBM_BUF_CH1_START, CH1_BUF_START);
bbm_word_write(hDevice, BBM_BUF_CH1_END, CH1_BUF_END);
bbm_word_write(hDevice, BBM_BUF_CH1_THR, CH1_BUF_THR);
bbm_word_write(hDevice, BBM_BUF_CH2_START, CH2_BUF_START);
bbm_word_write(hDevice, BBM_BUF_CH2_END, CH2_BUF_END);
bbm_word_write(hDevice, BBM_BUF_CH2_THR, CH2_BUF_THR);
bbm_word_write(hDevice, BBM_BUF_CH3_START, CH3_BUF_START);
bbm_word_write(hDevice, BBM_BUF_CH3_END, CH3_BUF_END);
bbm_word_write(hDevice, BBM_BUF_CH3_THR, CH3_BUF_THR);
bbm_word_write(hDevice, BBM_BUF_INT, 0x01ff);
bbm_word_write(hDevice, BBM_BUF_ENABLE, 0x01ff);
intMask = BBM_MF_INT;
bbm_write(hDevice, BBM_COM_INT_ENABLE, intMask);
bbm_write(hDevice, BBM_COM_STATUS_ENABLE, intMask);
return BBM_OK;
}
static int fci_i2c_transfer (HANDLE hDevice, u8 cmd_type, u8 chip, u8 addr[], u8 addr_len, u8 data[], u8 data_len)
{
int i;
int result = I2C_OK;
#ifdef FEATURE_SIMPLE_INTERFACE
u16 cmd;
#endif
switch (cmd_type) {
case I2C_WRITE:
#ifdef FEATURE_SIMPLE_INTERFACE
cmd = (I2C_CR_STA | I2C_CR_WR);
cmd = (cmd<<8) | (chip | cmd_type);
bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
bbm_write(hDevice, BBM_I2C_TXR, chip | cmd_type);
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/);
#endif
result = WaitForXfer(hDevice);
if(result != I2C_OK) return result;
if (addr && addr_len) {
i = 0;
while ((i < addr_len) && (result == I2C_OK)) {
#ifdef FEATURE_SIMPLE_INTERFACE
cmd = (I2C_CR_WR);
cmd = (cmd<<8) | (addr[i]);
bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
bbm_write(hDevice, BBM_I2C_TXR, addr[i]);
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/);
#endif
result = WaitForXfer(hDevice);
if(result != I2C_OK) return result;
i++;
}
}
i = 0;
while ((i < data_len) && (result == I2C_OK)) {
#ifdef FEATURE_SIMPLE_INTERFACE
cmd = (I2C_CR_WR);
cmd = (cmd<<8) | (data[i]);
bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
bbm_write(hDevice, BBM_I2C_TXR, data[i]);
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/);
#endif
result = WaitForXfer(hDevice);
if(result != I2C_OK) return result;
i++;
}
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STO /*0x40*/);
result = WaitForXfer(hDevice);
if(result != I2C_OK) return result;
break;
case I2C_READ:
if (addr && addr_len) {
#ifdef FEATURE_SIMPLE_INTERFACE
cmd = (I2C_CR_STA | I2C_CR_WR);
cmd = (cmd<<8) | (chip | I2C_WRITE);
bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
bbm_write(hDevice, BBM_I2C_TXR, chip | I2C_WRITE);
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/); // send start
#endif
result = WaitForXfer(hDevice);
if(result != I2C_OK) {
return result;
}
i = 0;
while ((i < addr_len) && (result == I2C_OK)) {
#ifdef FEATURE_SIMPLE_INTERFACE
cmd = (I2C_CR_WR);
cmd = (cmd<<8) | (addr[i]);
bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
bbm_write(hDevice, BBM_I2C_TXR, addr[i]);
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/);
#endif
result = WaitForXfer(hDevice);
if(result != I2C_OK) {
return result;
}
i++;
}
}
#ifdef FEATURE_SIMPLE_INTERFACE
cmd = (I2C_CR_STA | I2C_CR_WR);
cmd = (cmd<<8) | (chip | I2C_READ);
bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
bbm_write(hDevice, BBM_I2C_TXR, chip | I2C_READ);
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/); // resend start
#endif
result = WaitForXfer(hDevice);
if(result != I2C_OK) {
return result;
}
i = 0;
while ((i < data_len) && (result == I2C_OK)) {
if (i == data_len - 1) {
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_RD|I2C_CR_NACK/*0x28*/); // No Ack Read
result = WaitForXfer(hDevice);
if((result != I2C_NACK) && (result != I2C_OK)){
PRINTF(hDevice, "NACK4-0[%02x]\n", result);
return result;
}
} else {
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_RD /*0x20*/); // Ack Read
result = WaitForXfer(hDevice);
if(result != I2C_OK){
PRINTF(hDevice, "NACK4-1[%02x]\n", result);
return result;
}
}
bbm_read(hDevice, BBM_I2C_RXR, &data[i]);
i++;
}
bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STO /*0x40*/); // send stop
result = WaitForXfer(hDevice);
if((result != I2C_NACK) && (result != I2C_OK)) {
PRINTF(hDevice, "NACK5[%02X]\n", result);
return result;
}
break;
default:
return I2C_NOK;
}
return I2C_OK;
}
s32 tuner_select(HANDLE handle, DEVICEID devid,
enum PRODUCT_TYPE product, enum BROADCAST_TYPE broadcast)
{
switch (product) {
case FC8300_TUNER:
tuner = &fc8300_tuner;
tuner_addr = FC8300_TUNER_ADDR;
broadcast_type = broadcast;
break;
}
if (tuner == NULL)
{
print_log(0,"ERROR tuner == NULL\n");
return BBM_E_TN_SELECT;
}
if (tuner->init(handle, devid, broadcast))
{
print_log(0,"tuner->init\n");
return BBM_E_TN_INIT;
}
fc8300_set_broadcast_mode(handle, devid, broadcast);
#ifdef BBM_ES
if (product == FC8300_TUNER) {
u8 chip_ver = 0x00;
tuner_i2c_read(handle, devid, 0xff, 1, &chip_ver, 1);
if (chip_ver == 0xc0)
return BBM_OK;
bbm_byte_write(handle, DIV_MASTER, BBM_RESYNC_ENABLE, 0xcf);
bbm_long_write(handle, DIV_BROADCAST, BBM_MEMORY_RWM0,
0x05555555);
bbm_byte_write(handle, DIV_BROADCAST, BBM_SFS_FTS_ERR_MAX_1SEG,
0x08);
bbm_byte_write(handle, DIV_BROADCAST, BBM_SFS_FTS_ERR_MAX_3SEG,
0x08);
bbm_byte_write(handle, DIV_BROADCAST, BBM_PGA_GAIN_MAX, 0x0c);
bbm_byte_write(handle, DIV_BROADCAST, BBM_CSF_GAIN_MAX, 0x09);
bbm_byte_write(handle, DIV_MASTER, BBM_FD_OUT_MODE, 0x03);
bbm_byte_write(handle, DIV_MASTER, BBM_DIV_START_MODE, 0x17);
bbm_byte_write(handle, DIV_BROADCAST,
BBM_PSAT_ON_REF_1SEG_QPSK, 0x1a);
bbm_byte_write(handle, DIV_BROADCAST,
BBM_PSAT_ON_REF_1SEG_16QAM, 0x1b);
switch (broadcast) {
case ISDBT_1SEG:
case ISDBTMM_1SEG:
case ISDBTSB_1SEG:
case ISDBT_CATV_1SEG:
case ISDBTSB_3SEG:
bbm_byte_write(handle, DIV_BROADCAST, BBM_SFS_MTH,
0x32);
break;
case ISDBT_13SEG:
case ISDBTMM_13SEG:
case ISDBT_CATV_13SEG:
bbm_byte_write(handle, DIV_BROADCAST, BBM_SFS_MTH,
0x31);
break;
}
#if defined(BBM_2_DIVERSITY) || defined(BBM_4_DIVERSITY)
bbm_byte_write(handle, DIV_MASTER, BBM_XTAL_OUTBUF_EN, 0x00);
bbm_byte_write(handle, DIV_MASTER, BBM_XTAL_OUTBUF_GAIN, 0x03);
bbm_word_write(handle, DIV_BROADCAST, BBM_FD_RD_LATENCY_1SEG,
0x1840);
bbm_byte_write(handle, DIV_BROADCAST, BBM_COMB_OFF, 0x80);
#else /* SINGLE */
bbm_word_write(handle, DIV_BROADCAST, BBM_FD_RD_LATENCY_1SEG,
0x0002);
#endif /* #if defined(BBM_2_DIVERSITY) || defined(BBM_4_DIVERSITY) */
}
#endif /* #ifdef BBM_ES */
return BBM_OK;
}
void fc8050_isr(HANDLE hDevice)
{
u8 ext_int_status = 0;
bbm_read(hDevice, BBM_COM_INT_STATUS, &ext_int_status);
bbm_write(hDevice, BBM_COM_INT_STATUS, ext_int_status);
bbm_write(hDevice, BBM_COM_INT_STATUS, 0x00);
if (ext_int_status & BBM_MF_INT) {
u16 buf_int_status = 0;
u16 size;
int i;
bbm_word_read(hDevice, BBM_BUF_STATUS, &buf_int_status);
bbm_word_write(hDevice, BBM_BUF_STATUS, buf_int_status);
bbm_word_write(hDevice, BBM_BUF_STATUS, 0x0000);
if (buf_int_status & 0x0100) {
bbm_word_read(hDevice, BBM_BUF_FIC_THR, &size);
size += 1;
if (size-1) {
bbm_data(hDevice, BBM_COM_FIC_DATA
, &fic_buffer[0], size);
#ifdef CONFIG_TDMB_SPI
if (fic_callback)
(*fic_callback)(fic_user_data
, &fic_buffer[2], size);
#else
if (fic_callback)
(*fic_callback)(fic_user_data
, &fic_buffer[0], size);
#endif
}
}
for (i = 0; i < 8; i++) {
if (buf_int_status & (1 << i)) {
bbm_word_read(hDevice
, BBM_BUF_CH0_THR+i*2, &size);
size += 1;
if (size-1) {
u8 sub_ch_id;
bbm_read(hDevice, BBM_BUF_CH0_SUBCH+i
, &sub_ch_id);
sub_ch_id = sub_ch_id & 0x3f;
bbm_data(hDevice, (BBM_COM_CH0_DATA+i)
, &msc_buffer[0], size);
#ifdef CONFIG_TDMB_SPI
if (msc_callback)
(*msc_callback)(
msc_user_data
, sub_ch_id
, &msc_buffer[2]
, size);
#else
if (msc_callback)
(*msc_callback)(
msc_user_data
, sub_ch_id
, &msc_buffer[0]
, size);
#endif
}
}
}
}
}
s32 fc8080_init(HANDLE handle)
{
#ifdef FC8080_I2C
#ifdef CONFIG_TDMB_TSIF_QC
bbm_write(handle, BBM_TSO_SELREG, 0xc4);
#else /* for S.LSI */
bbm_write(handle, BBM_TSO_SELREG, 0xc0);
#endif
#endif
fc8080_reset(handle);
fc8080_set_xtal(handle);
bbm_write(handle, BBM_LDO_VCTRL, 0x35);
bbm_write(handle, BBM_XTAL_CCTRL, 0x0A);
bbm_write(handle, BBM_RF_XTAL_EN, 0x0f);
bbm_write(handle, BBM_ADC_OPMODE, 0x67);
/*bbm_write(handle, BBM_FIC_CFG_CRC16, 0x03);*/
bbm_word_write(handle, BBM_OFDM_DET_MAX_THRESHOLD, 0x0a00);
bbm_write(handle, BBM_FTOFFSET_RANGE, 0x20);
bbm_write(handle, BBM_AGC530_EN, 0x53);
bbm_write(handle, BBM_BLOCK_AVG_SIZE_LOCK, 0x49);
bbm_word_write(handle, BBM_GAIN_CONSTANT, 0x0303);
bbm_write(handle, BBM_DET_CNT_BOUND, 0x60);
bbm_write(handle, BBM_UNLOCK_DETECT_EN, 0x00);
bbm_write(handle, BBM_DCE_CTRL, 0x27);
bbm_write(handle, BBM_PGA_GAIN_MAX, 0x18);
bbm_write(handle, BBM_PGA_GAIN_MIN, 0xe8);
#ifdef CONFIG_TDMB_XTAL_FREQ
if (main_xtal_freq == 24000)
bbm_write(handle, BBM_SYNC_MTH, 0x43);
else
bbm_write(handle, BBM_SYNC_MTH, 0xc3);
if ((main_xtal_freq == 16384) || (main_xtal_freq == 24576))
bbm_write(handle, BBM_SFSYNC_ON, 0x00);
else
bbm_write(handle, BBM_SFSYNC_ON, 0x01);
#else
#if (FC8080_FREQ_XTAL == 24000)
bbm_write(handle, BBM_SYNC_MTH, 0x43);
#else
bbm_write(handle, BBM_SYNC_MTH, 0xc3);
#endif
#if (FC8080_FREQ_XTAL == 16384) || (FC8080_FREQ_XTAL == 24576)
bbm_write(handle, BBM_SFSYNC_ON, 0x00);
#else
bbm_write(handle, BBM_SFSYNC_ON, 0x01);
#endif
#endif
bbm_write(handle, BBM_RESYNC_EN, 0x01);
bbm_write(handle, BBM_RESYNC_AUTO_CONDITION_EN, 0x00);
bbm_write(handle, BBM_MSC_CFG_SPD, 0xff);
#if defined(POWER_SAVE_MODE)
bbm_write(handle, BBM_PS0_RF_ENABLE, 0x06);
bbm_write(handle, BBM_PS1_ADC_ENABLE, 0x07);
bbm_write(handle, BBM_PS2_BB_ENABLE, 0x07);
bbm_write(handle, BBM_PS2_BB_ADD_SHIFT, 0x21);
#else
bbm_write(handle, BBM_PS0_RF_ENABLE, 0x04);
bbm_write(handle, BBM_PS1_ADC_ENABLE, 0x05);
bbm_write(handle, BBM_PS2_BB_ENABLE, 0x05);
#endif
bbm_write(handle, BBM_PS1_ADC_ADD_SHIFT, 0x71);
bbm_word_write(handle, BBM_BUF_FIC_START, FIC_BUF_START);
bbm_word_write(handle, BBM_BUF_FIC_END, FIC_BUF_END);
bbm_word_write(handle, BBM_BUF_FIC_THR, FIC_BUF_THR);
bbm_word_write(handle, BBM_BUF_CH0_START, CH0_BUF_START);
bbm_word_write(handle, BBM_BUF_CH0_END, CH0_BUF_END);
bbm_word_write(handle, BBM_BUF_CH0_THR, CH0_BUF_THR);
bbm_word_write(handle, BBM_BUF_CH1_START, CH1_BUF_START);
bbm_word_write(handle, BBM_BUF_CH1_END, CH1_BUF_END);
bbm_word_write(handle, BBM_BUF_CH1_THR, CH1_BUF_THR);
bbm_word_write(handle, BBM_BUF_CH2_START, CH2_BUF_START);
bbm_word_write(handle, BBM_BUF_CH2_END, CH2_BUF_END);
bbm_word_write(handle, BBM_BUF_CH2_THR, CH2_BUF_THR);
bbm_write(handle, BBM_DM_CTRL, 0xa0);
bbm_write(handle, BBM_OVERRUN_GAP, 0x06);
bbm_word_write(handle, BBM_BUF_INT, 0x0107);
bbm_word_write(handle, BBM_BUF_ENABLE, 0x0000);
#ifdef FC8080_I2C
bbm_write(handle, BBM_TSO_CLKDIV, 0x01);
#else
bbm_write(handle, BBM_MD_INT_EN, BBM_MF_INT);
bbm_write(handle, BBM_MD_INT_STATUS, BBM_MF_INT);
#endif
return BBM_OK;
}