diff options
Diffstat (limited to 'drivers/media/tdmb/tcc3170/src')
11 files changed, 749 insertions, 534 deletions
diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_api_common.c b/drivers/media/tdmb/tcc3170/src/tcbd_api_common.c index 5b42026..986f3d9 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_api_common.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_api_common.c @@ -31,12 +31,25 @@ #include "tcc317x_boot_tdmb.h" -s32 tcbd_device_start( - struct tcbd_device *_device, enum tcbd_clock_type _clock_type) +s32 tcbd_device_start(struct tcbd_device *_device, + enum tcbd_clock_type _clock_type) { s32 ret = 0, ver; u8 *dsp_rom = TCC317X_BOOT_DATA_TDMB; s32 size = TCC317X_BOOT_SIZE_TDMB; +#if defined(__DEBUG_DSP_ROM__) + static u8 dsp_rom_buff[MAX_SIZE_DSP_ROM]; + if (tcbd_debug_rom_from_fs() == 1) { + ret = tcbd_read_file(_device, tcbd_debug_rom_path(), + dsp_rom_buff, MAX_SIZE_DSP_ROM); + if (ret > 0) { + dsp_rom = dsp_rom_buff; + size = ret; + tcbd_debug(DEBUG_ERROR, "rom:%s, size:%d\n", + tcbd_debug_rom_path(), size); + } + } +#endif /*__DEBUG_DSP_ROM__*/ /* Initialize PLL */ tcbd_init_pll(_device, _clock_type); @@ -46,13 +59,13 @@ s32 tcbd_device_start( tcbd_enable_peri(_device); ret = tcbd_init_dsp(_device, dsp_rom, size); if (ret < 0) { - tcbd_debug(DEBUG_ERROR, - "failed to initialize dsp!! error:%d\n", ret); + tcbd_debug(DEBUG_ERROR, "failed to initialize dsp!! " + "error:%d\n", ret); return -TCERR_FATAL_ERROR; } else { tcbd_get_rom_version(_device, &ver); - tcbd_debug(DEBUG_API_COMMON, - "device start success!! version:0x%X\n", ver); + tcbd_debug(DEBUG_API_COMMON, "device start success!! " + "version:0x%X\n", ver); } return 0; } @@ -164,9 +177,9 @@ s32 tcbd_init_stream_data_config( return ret; } +#if defined(__CSPI_ONLY__) #if defined(__READ_FIXED_LENGTH__) -s32 tcbd_read_stream( - struct tcbd_device *_device, u8 *_buff, s32 *_size) +s32 tcbd_read_stream(struct tcbd_device *_device, u8 *_buff, s32 *_size) { u32 bytes_read = _device->intr_threshold; @@ -186,9 +199,8 @@ s32 tcbd_read_stream( return tcbd_reg_read_burst_fix( _device, TCBD_STREAM_CFG4, _buff, bytes_read); } -#else /* __READ_VARIABLE_LENGTH__ */ -s32 tcbd_read_stream( - struct tcbd_device *_device, u8 *_buff, s32 *_size) +#elif defined(__READ_VARIABLE_LENGTH__) +s32 tcbd_read_stream(struct tcbd_device *_device, u8 *_buff, s32 *_size) { u32 bytes_remain = 0; u32 bytes_read = _device->intr_threshold; @@ -217,7 +229,10 @@ s32 tcbd_read_stream( return tcbd_reg_read_burst_fix( _device, TCBD_STREAM_CFG4, _buff, bytes_read); } -#endif +#else +#error "you must define __READ_VARIABLE_LENGTH__ or __READ_FIXED_LENGTH__" +#endif /*!__READ_FIXED_LENGTH__ && !__READ_VARIABLE_LENGTH__*/ +#endif /*__CSPI_ONLY__*/ s32 tcbd_tune_frequency( struct tcbd_device *_device, u32 _freq_khz, s32 _bw_khz) @@ -233,32 +248,35 @@ s32 tcbd_tune_frequency( _device->curr_band = BAND_TYPE_BAND3; else _device->curr_band = BAND_TYPE_LBAND; - ret |= tcbd_reset_ip( - _device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_ALL); + ret |= tcbd_reset_ip(_device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_ALL); ret |= tcbd_rf_tune_frequency(_device, _freq_khz, _bw_khz); if (ret < 0) { - tcbd_debug(DEBUG_ERROR, - "failed to tune frequency to RF!! ret:%d\n", ret); + tcbd_debug(DEBUG_ERROR, "failed to tune frequency to RF!! " + "ret:%d\n", ret); return ret; } - if (_device->peri_type == PERI_TYPE_SPI_ONLY) { - /* enable fic buffer only*/ - ret |= tcbd_init_stream_data_config( - _device, - ENABLE_CMD_FIFO, - STREAM_DATA_ENABLE | - STREAM_HEADER_ON | - STREAM_MASK_BUFFERA, - TCBD_THRESHOLD_FIC); + switch (_device->peri_type) { + case PERI_TYPE_SPI_ONLY: + ret |= tcbd_init_stream_data_config(_device, ENABLE_CMD_FIFO, + STREAM_DATA_ENABLE | STREAM_HEADER_ON | + STREAM_MASK_BUFFERA, TCBD_THRESHOLD_FIC); + break; + case PERI_TYPE_STS: + ret |= tcbd_init_stream_data_config(_device, DISABLE_CMD_FIFO, + 0, 0); + break; + default: + tcbd_debug(DEBUG_ERROR, "%d not implemented!!\n", + _device->peri_type); + return -TCERR_FATAL_ERROR; } tcbd_init_status_manager(); ret |= tcbd_demod_tune_frequency(_device, _freq_khz, _bw_khz); if (ret < 0) { - tcbd_debug(DEBUG_ERROR, - "failed to tune frequency " + tcbd_debug(DEBUG_ERROR, "failed to tune frequency " "to demodulator!! ret:%d\n", ret); return ret; } @@ -268,8 +286,8 @@ s32 tcbd_tune_frequency( #if defined(__READ_VARIABLE_LENGTH__) _device->size_more_read = 0; #endif /*__READ_VARIABLE_LENGTH__*/ - tcbd_debug(DEBUG_API_COMMON, - " # Frequency set time :%lld\n", tcpal_diff_time(tick)); + tcbd_debug(DEBUG_API_COMMON, " # Frequency set time :%lld\n", + tcpal_diff_time(tick)); return ret; } @@ -318,8 +336,8 @@ s32 tcbd_wait_tune(struct tcbd_device *_device, u8 *_status) } while (tcpal_diff_time(time_tick) < time_tune_wait); if (cto && cfo) - tcbd_debug(DEBUG_API_COMMON, - "lock status : 0x%02X\n", *_status); + tcbd_debug(DEBUG_API_COMMON, "lock status : 0x%02X\n", + *_status); else ret = -TCERR_TUNE_FAILED; @@ -345,12 +363,11 @@ static inline s32 tcbd_calc_threshold(struct tcbd_service *_service) if (TCBD_MAX_THRESHOLD < threshold) threshold = TCBD_MAX_THRESHOLD; - tcbd_debug(DEBUG_API_COMMON, - "ptype:%s, bitrate :%d, interrupt threshold:%d\n", - (_service->ptype) ? "EEP" : "UEP", + tcbd_debug(DEBUG_API_COMMON, "ptype:%s, bitrate :%d, interrupt " + "threshold:%d\n", (_service->ptype) ? "EEP" : "UEP", _service->bitrate, threshold); - return threshold; + return threshold>>1; } static inline s32 tcbd_find_empty_slot( @@ -381,37 +398,37 @@ static inline s32 tcbd_find_used_slot( return -1; } -static inline s32 tcbd_set_service( - struct tcbd_device *_device, struct tcbd_service *_service) +#define FLAG_SHORT_PARAM 0 +#define FLAG_LONG_PARAM 1 +static inline s32 tcbd_set_service(struct tcbd_device *_device, + struct tcbd_service *_service, s32 _flag) { s32 ret = 0; - u32 threshold, sel_buff = 0, sel_stream = 0; + u32 threshold = 0, sel_buff = 0, sel_stream = 0; u8 en_cmd_fifo = 0; + sel_buff = STREAM_DATA_ENABLE | STREAM_HEADER_ON | + STREAM_MASK_BUFFERA; switch (_device->peri_type) { case PERI_TYPE_SPI_ONLY: -#if defined(__CALC_INTRRUPT_THRESHOLD__) - threshold = tcbd_calc_threshold(_service); - sel_stream = STREAM_SET_GARBAGE(threshold) | + if (_flag == FLAG_LONG_PARAM) { + threshold = tcbd_calc_threshold(_service); + sel_stream = STREAM_SET_GARBAGE(threshold) | STREAM_TYPE_ALL; -#else /* __CALC_INTRRUPT_THRESHOLD__ */ + } else { threshold = TCBD_MAX_THRESHOLD; sel_stream = STREAM_SET_GARBAGE(TCBD_MAX_THRESHOLD) | STREAM_TYPE_ALL; -#endif /* __CALC_INTRRUPT_THRESHOLD__ */ + } tcbd_debug(DEBUG_API_COMMON, "threshold : %d\n", threshold); en_cmd_fifo = ENABLE_CMD_FIFO; - sel_buff = STREAM_DATA_ENABLE | - STREAM_HEADER_ON | - STREAM_MASK_BUFFERA | - STREAM_MASK_BUFFERB; break; case PERI_TYPE_STS: en_cmd_fifo = DISABLE_CMD_FIFO; sel_stream = STREAM_TYPE_ALL; - sel_buff = STREAM_DATA_ENABLE | - STREAM_MASK_BUFFERA | - STREAM_MASK_BUFFERB; +#if !defined(__ALWAYS_FIC_ON__) + sel_buff &= ~(STREAM_HEADER_ON); +#endif /*__ALWAYS_FIC_ON__*/ break; default: tcbd_debug(DEBUG_ERROR, "not implemented!\n"); @@ -429,18 +446,20 @@ static inline s32 tcbd_set_service( #if defined(__READ_VARIABLE_LENGTH__) _device->size_more_read = 0; #endif /*__READ_VARIABLE_LENGTH__*/ + ret |= tcbd_disable_irq(_device, 0); ret |= tcbd_change_stream_type(_device, sel_stream); ret |= tcbd_init_stream_data_config( _device, en_cmd_fifo, sel_buff, threshold); ret |= tcbd_send_service_info(_device); - ret |= tcbd_enable_irq(_device, _device->enabled_irq); + if (_device->peri_type == PERI_TYPE_SPI_ONLY) + ret |= tcbd_enable_irq(_device, _device->enabled_irq); return ret; } -s32 tcbd_register_service( - struct tcbd_device *_device, u8 _subch_id, u8 _data_mode) +s32 tcbd_register_service(struct tcbd_device *_device, u8 _subch_id, + u8 _data_mode) { s32 empty_slot, empty_slot2x; struct tcbd_service service = {0, }; @@ -448,8 +467,7 @@ s32 tcbd_register_service( u32 *service_info = mult_service->service_info; if (tcbd_find_used_slot(mult_service, _subch_id) >= 0) { - tcbd_debug(DEBUG_ERROR, - "aready registerd service! " + tcbd_debug(DEBUG_ERROR, "aready registerd service! " "subch_id:%d\n", _subch_id); return -TCERR_AREADY_REGISTERED; } @@ -473,11 +491,11 @@ s32 tcbd_register_service( (empty_slot << 20) | (_data_mode << 16); - return tcbd_set_service(_device, &service); + return tcbd_set_service(_device, &service, FLAG_SHORT_PARAM); } -s32 tcbd_register_service_long( - struct tcbd_device *_device, struct tcbd_service *_service) +s32 tcbd_register_service_long(struct tcbd_device *_device, + struct tcbd_service *_service) { s32 empty_slot, empty_slot2x; u32 data_mode = 0; @@ -485,8 +503,7 @@ s32 tcbd_register_service_long( u32 *service_info = mult_service->service_info; if (tcbd_find_used_slot(mult_service, _service->subch_id) >= 0) { - tcbd_debug(DEBUG_ERROR, - "aready registerd service! " + tcbd_debug(DEBUG_ERROR, "aready registerd service! " "subch_id:%d\n", _service->subch_id); return -TCERR_AREADY_REGISTERED; } @@ -525,11 +542,10 @@ s32 tcbd_register_service_long( (_service->plevel << 8) | _service->bitrate; - return tcbd_set_service(_device, _service); + return tcbd_set_service(_device, _service, FLAG_LONG_PARAM); } -s32 tcbd_unregister_service( - struct tcbd_device *_device, u8 _subch_id) +s32 tcbd_unregister_service(struct tcbd_device *_device, u8 _subch_id) { s32 ret = 0; s32 service_idx; @@ -553,36 +569,57 @@ s32 tcbd_unregister_service( return ret; } -s32 tcbd_read_fic_data( - struct tcbd_device *_device, u8 *_buff, s32 _size) +s32 tcbd_read_fic_data(struct tcbd_device *_device, u8 *_buff, s32 _size) { s32 ret = 0; u32 addr_fic_buff; u8 status, err_status; - u64 tick; + tcbd_read_irq_status(_device, &status, &err_status); if (_size != TCBD_FIC_SIZE) { tcbd_debug(DEBUG_ERROR, "wrong fic size! %d\n", _size); - return -TCERR_INVALID_ARG; + ret = -TCERR_INVALID_ARG; + goto exit_read_fic; } - - ret = tcbd_read_irq_status(_device, &status, &err_status); if (status & TCBD_IRQ_STAT_FIFOAINIT) { addr_fic_buff = PHY_MEM_ADDR_A_START; - tick = tcpal_get_time(); - tcbd_debug(0, "status:0x%02X, err:0x%02X, %lld elapsed\n", - status, err_status, tcpal_diff_time(tick)); + tcbd_debug(DEBUG_INTRRUPT, "status:0x%02X, err:0x%02X\n", + status, err_status); ret = tcbd_mem_read(_device, addr_fic_buff, _buff, _size); - ret |= tcbd_clear_irq(_device, status); - } else { - ret |= -TCERR_NO_FIC_DATA; + } else + ret = -TCERR_NO_FIC_DATA; +exit_read_fic: + tcbd_clear_irq(_device, status); + return ret; } - ret |= tcbd_clear_irq(_device, status); +static s32 tcbd_disp_dsp_debug(struct tcbd_device *_device) +{ + s32 pos_buf = 0, ret, i; + u32 len = 0, *data = NULL; + u16 cmd; + s8 debug_buff[256]; + + tcbd_debug_mbox_rx(&cmd, &len, &data); + if (data == NULL) + return 0; + + ret = tcbd_read_mail_box(_device, cmd, len, data); + if (ret < 0) { + tcbd_debug(DEBUG_ERROR, "failed to read mail box, " + "err:%d\n", ret); return ret; } + for (i = 0; i < 6; i++) + pos_buf += sprintf(debug_buff + pos_buf, "[%d:%08X]", + i, data[i]); + tcbd_debug(DEBUG_INFO, "%s\n", debug_buff); + + return 0; +} + s32 tcbd_read_signal_info( struct tcbd_device *_device, struct tcbd_status_data *_status_data) @@ -595,6 +632,9 @@ s32 tcbd_read_signal_info( if (!_status_data) return -TCERR_INVALID_ARG; + if (tcbd_debug_spur_dbg() == 1) + tcbd_disp_dsp_debug(_device); + #if defined(__STATUS_IN_REGISTER__) ret = tcbd_reg_write(_device, TCBD_OP_STATUS0, 0x1); ret |= tcbd_reg_read_burst_fix(_device, diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_diagnosis/tcbd_diagnosis.c b/drivers/media/tdmb/tcc3170/src/tcbd_diagnosis/tcbd_diagnosis.c index ab5c1cb..e425df8 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_diagnosis/tcbd_diagnosis.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_diagnosis/tcbd_diagnosis.c @@ -188,6 +188,9 @@ static inline void tcbd_calc_pcber(struct tcbd_status_data *_status_data) else if (_status_data->pcber > MAX_PCBER * ERROR_LIMIT) _status_data->pcber = MAX_PCBER * ERROR_LIMIT; + if (_status_data->pcber <= 20) + _status_data->pcber = 0; + _status_data->pcber_moving_avg = tcbd_get_moving_avg( &moving_average[0], diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_drv_io.c b/drivers/media/tdmb/tcc3170/src/tcbd_drv_io.c index 964e532..e2bcbea 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_drv_io.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_drv_io.c @@ -42,7 +42,7 @@ s32 tcbd_io_open(struct tcbd_device *_device) if (tcbd_io_funcs.open == NULL) return -TCERR_IO_NOT_INITIALIZED; - tcpal_create_lock(&tcbd_io_funcs.sem, "tcbd_io_funcsSemaphore", 0); + tcpal_create_lock(&tcbd_io_funcs.sem, "tcbd_io_lock", 0); ret = tcbd_io_funcs.open(); if (ret < 0) @@ -80,7 +80,7 @@ s32 tcbd_reg_read( return -TCERR_IO_NOT_INITIALIZED; if (_device == NULL || _data == NULL) - return TCERR_INVALID_ARG; + return -TCERR_INVALID_ARG; tcpal_lock(&tcbd_io_funcs.sem); tcbd_io_funcs.chip_addr = _device->chip_addr; @@ -326,14 +326,14 @@ s32 tcbd_send_mail( sizeof(u32) + count * sizeof(u32)); ret |= tcbd_io_funcs.reg_write(TCBD_MAIL_CTRL, TCBD_MAIL_HOSTMAILPOST); if (ret < 0) - goto exittcbd_send_mail; + goto exit_send_mail; time_tick = tcpal_get_time(); do { elapsed = tcpal_diff_time(time_tick); if (elapsed > (u64)MAX_TIME_TO_WAIT_MAIL) { ret = -TCERR_WAIT_MAIL_TIMEOUT; - goto exittcbd_send_mail; + goto exit_send_mail; } /* latch mail status to register */ ret = tcbd_io_funcs.reg_write(TCBD_MAIL_FIFO_W, 0x5E); @@ -346,7 +346,7 @@ s32 tcbd_send_mail( tcbd_debug(DEBUG_DRV_IO, "cmd:0x%X, count:%d, elapsed time:%llu\n", _mail->cmd, count, elapsed); -exittcbd_send_mail: +exit_send_mail: tcpal_unlock(&tcbd_io_funcs.sem); return ret; } @@ -375,11 +375,10 @@ s32 tcbd_recv_mail( ret = -TCERR_WAIT_MAIL_TIMEOUT; if (ret < 0) - goto exittcbd_recv_mail; + goto exit_recv_mail; } while ((reg_data & 0xFC) < 3); /* check fifo status */ bytes_read = (reg_data >> 2) & 0x3F; - tcbd_debug(DEBUG_DRV_IO, - "cmd:0x%X, bytes_read:%d, elapsed time:%llu\n", + tcbd_debug(DEBUG_DRV_IO, "cmd:0x%X, bytes_read:%d, elapsed time:%llu\n", _mail->cmd, bytes_read, elapsed); ret = tcbd_io_funcs.reg_read_burst_fix( @@ -387,13 +386,12 @@ s32 tcbd_recv_mail( /*only warm boot cmd */ if (bytes_read == 4) { memcpy(_mail->data, mail_data, bytes_read); - goto exittcbd_recv_mail; + goto exit_recv_mail; } mail_hdr = *((u32 *)mail_data); if ((mail_hdr >> 24) != MB_SLAVEMAIL) { - tcbd_debug(DEBUG_ERROR, - "Error : cmd=0x%X bytes_read=%d\n", + tcbd_debug(DEBUG_ERROR, "Error : cmd=0x%X bytes_read=%d\n", _mail->cmd, bytes_read); tcbd_debug(DEBUG_ERROR, " [0x%02X][0x%02X][0x%02X][0x%02X]" "[0x%02X][0x%02X][0x%02X][0x%02X]\n", @@ -402,7 +400,7 @@ s32 tcbd_recv_mail( mail_data[6], mail_data[7]); ret = -TCERR_BROKEN_MAIL_HEADER; - goto exittcbd_recv_mail; + goto exit_recv_mail; } _mail->cmd = mail_hdr & 0xFFFF; _mail->status = (mail_hdr >> 16) & 0x7; @@ -410,18 +408,18 @@ s32 tcbd_recv_mail( tcbd_debug(DEBUG_ERROR, "Mail Error : status=0x%X, cmd=0x%X\n", _mail->status, _mail->cmd); ret = -TCERR_UNKNOWN_MAIL_STATUS; - goto exittcbd_recv_mail; + goto exit_recv_mail; } _mail->count = (bytes_read >> 2) - 1; memcpy(_mail->data, mail_data + 4, bytes_read - 4); -exittcbd_recv_mail: +exit_recv_mail: tcpal_unlock(&tcbd_io_funcs.sem); return ret; } -s32 tcbd_read_mail_box( - struct tcbd_device *_device, u16 _cmd, s32 _cnt, u32 *_data) +s32 tcbd_read_mail_box(struct tcbd_device *_device, u16 _cmd, s32 _cnt, + u32 *_data) { s32 ret = 0; struct tcbd_mail_data mail = {0, }; @@ -432,17 +430,87 @@ s32 tcbd_read_mail_box( ret = tcbd_send_mail(_device, &mail); if (ret < 0) { tcbd_debug(DEBUG_ERROR, "failed to send mail! %d\n", ret); - goto exti_read_mail_box; + goto exit_read_mail_box; } ret = tcbd_recv_mail(_device, &mail); if (ret < 0) { tcbd_debug(DEBUG_ERROR, "failed to recv mail! %d\n", ret); - goto exti_read_mail_box; + goto exit_read_mail_box; } memcpy((void *)_data, (void *)mail.data, _cnt * sizeof(u32)); -exti_read_mail_box: +exit_read_mail_box: + return ret; +} + +s32 tcbd_write_mail_box(struct tcbd_device *_device, u16 _cmd, s32 _cnt, + u32 *_data) +{ + u32 *data = NULL; + struct tcbd_mail_data mail = {0, }; + + if (_cnt > MAX_MAIL_COUNT || _data == NULL) { + tcbd_debug(DEBUG_ERROR, "invalid param, cnt:%d\n", _cnt); + return -TCERR_INVALID_ARG; + } + + mail.flag = MB_CMD_WRITE; + mail.cmd = _cmd; + mail.count = _cnt; + memcpy((void *)mail.data, (void *)_data, _cnt * sizeof(u32)); +#if defined(__DEBUG_DSP_ROM__) + tcbd_debug_mbox_tx(&_cmd, &_cnt, &data); + if (data != NULL) { + int i, sz = 0; + char print_buff[80]; + mail.cmd = _cmd; + mail.count = _cnt; + memcpy((void *)mail.data, (void *)data, _cnt * sizeof(u32)); + for (i = 0; i < _cnt; i++) + sz += sprintf(print_buff + sz, "[%08X]", data[i]); + + tcbd_debug(DEBUG_ERROR, "cmd 0x%X, cnt:%d, %s\n", + _cmd, _cnt, print_buff); + } +#endif /*__DEBUG_DSP_ROM__*/ + return tcbd_send_mail(_device, &mail); +} + +#if defined(__DEBUG_DSP_ROM__) +s32 tcbd_read_file(struct tcbd_device *_device, char *_path, u8 *_buff, + s32 _size) +{ + int ret; + struct file *flip = NULL; + mm_segment_t old_fs; + + if (_path == NULL) { + tcbd_debug(DEBUG_ERROR, "invalid filename! %s\n", _path); + return -1; + } + + if (_buff == NULL) { + tcbd_debug(DEBUG_ERROR, "Invaild pointer! 0x%X\n", (u32)_buff); + return -1; + } + + flip = filp_open(_path, O_RDWR, 0); + if (IS_ERR(flip)) { + tcbd_debug(DEBUG_ERROR, "%s open failed\n", _path); + return -1; + } + + old_fs = get_fs(); + set_fs(KERNEL_DS); + + flip->f_pos = 0; + ret = vfs_read(flip, _buff, _size, &flip->f_pos); + + filp_close(flip, NULL); + set_fs(old_fs); + return ret; } +#endif /*__DEBUG_DSP_ROM__*/ diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_drv_ip.c b/drivers/media/tdmb/tcc3170/src/tcbd_drv_ip.c index 96459ec..a5f81eb 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_drv_ip.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_drv_ip.c @@ -50,7 +50,7 @@ struct tcbd_boot_bin { static u32 clock_config_table[3][5] = { { 0x60, 0x00, 0x0F, 0x03, 19200}, - { 0x60, 0x00, 0x0C, 0x03, 24576}, + { 0x60, 0x01, 0x18, 0x03, 24576}, { 0x60, 0x01, 0x0F, 0x03, 38400} }; @@ -70,14 +70,27 @@ static struct tcbd_spur_data spur_data_table_default[] = { }; static struct tcbd_spur_data spur_data_table_24576[] = { + { 180064, 2, {(0x03C3<<16)|(0x030D), (0x03C2<<16)|(0x0308)} }, { 184736, 2, {(0x0092<<16)|(0x033A), (0x0098<<16)|(0x0332)} }, + { 188928, 2, {(0x00B1<<16)|(0x034F), (0x00B5<<16)|(0x034B)} }, + { 189008, 2, {(0x00C6<<16)|(0x0366), (0x00CA<<16)|(0x0363)} }, + { 195936, 2, {(0x0328<<16)|(0x037F), (0x0324<<16)|(0x037C)} }, { 196736, 2, {(0x0030<<16)|(0x030F), (0x0032<<16)|(0x0305)} }, - { 199280, 2, {(0x0373<<16)|(0x0337), (0x036D<<16)|(0x032F)} }, - { 205280, 2, {(0x00A5<<16)|(0x0349), (0x00AC<<16)|(0x0342)} }, - { 213008, 2, {(0x0006<<16)|(0x030A), (0x0006<<16)|(0x0300)} }, + { 199280, 2, {(0x000B<<16)|(0x030A), (0x000B<<16)|(0x0300)} }, + { 204640, 2, {(0x03C3<<16)|(0x030D), (0x03C2<<16)|(0x0308)} }, + { 205280, 2, {(0x039F<<16)|(0x031E), (0x039B<<16)|(0x0315)} }, + { 208736, 2, {(0x03C4<<16)|(0x0312), (0x03C2<<16)|(0x0308)} }, + { 213008, 2, {(0x0006<<16)|(0x0305), (0x0006<<16)|(0x0300)} }, + { 213360, 2, {(0x0086<<16)|(0x032C), (0x0089<<16)|(0x0328)} }, + { 229072, 2, {(0x038F<<16)|(0x031F), (0x038D<<16)|(0x031B)} }, + { 237488, 2, {(0x03E2<<16)|(0x0307), (0x03E1<<16)|(0x0302)} }, + { 1458096, 2, {(0x03E2<<16)|(0x0307), (0x03E1<<16)|(0x0302)} }, + { 1466656, 2, {(0x006B<<16)|(0x031E), (0x006D<<16)|(0x0319)} }, + { 1475216, 2, {(0x00D4<<16)|(0x037A), (0x00D8<<16)|(0x0377)} }, + { 1482064, 2, {(0x0325<<16)|(0x0384), (0x0321<<16)|(0x0382)} }, + { 1490624, 2, {(0x0389<<16)|(0x0322), (0x0387<<16)|(0x031E)} }, }; - #if defined(__AGC_TABLE_IN_DSP__) static struct tcbd_agc_data agc_data_table_lband[] = { {MBCMD_AGC_DAB_JAM, 3, @@ -159,7 +172,6 @@ s32 tcbd_send_spur_data(struct tcbd_device *_device, s32 _freq_khz) { s32 ret = 0, i; s32 size_table; - struct tcbd_mail_data mail = {0, }; struct tcbd_spur_data *spur_table; switch (_device->clock_type) { @@ -174,31 +186,27 @@ s32 tcbd_send_spur_data(struct tcbd_device *_device, s32 _freq_khz) size_table = ARRAY_SIZE(spur_data_table_default); break; } - mail.flag = MB_CMD_WRITE; - mail.cmd = MBCMD_FP_DAB_IIR; for (i = 0; i < size_table; i++) { - if (spur_table[i].freq_khz == _freq_khz) { - mail.count = spur_table[i].num_data; - memcpy(mail.data, spur_table[i].data, - mail.count * sizeof(u32)); - tcbd_debug(DEBUG_DRV_COMP, - "freq:%d, num mail data:%d\n", - _freq_khz, mail.count); - ret = tcbd_send_mail(_device, &mail); + if (spur_table[i].freq_khz != _freq_khz) + continue; + + tcbd_debug(DEBUG_DRV_COMP, "freq:%d, num mail data:%d\n", + _freq_khz, spur_table[i].num_data); + ret = tcbd_write_mail_box(_device, MBCMD_FP_DAB_IIR, + spur_table[i].num_data, + spur_table[i].data); break; } - } return ret; } -s32 tcbd_send_agc_data( - struct tcbd_device *_device, enum tcbd_band_type _band_type) +s32 tcbd_send_agc_data(struct tcbd_device *_device, + enum tcbd_band_type _band_type) { s32 ret = 0, i; s32 size_table; struct tcbd_agc_data *agc_table; - struct tcbd_mail_data mail = {0, }; switch (_band_type) { case BAND_TYPE_LBAND: @@ -210,20 +218,16 @@ s32 tcbd_send_agc_data( agc_table = agc_table_data_vhf; break; default: - tcbd_debug(DEBUG_ERROR, - "Unknown band type:%d\n", _band_type); + tcbd_debug(DEBUG_ERROR, "Unknown band type:%d\n", _band_type); return -1; } - tcbd_debug(DEBUG_DRV_COMP, "agc table size:%d, band:%s\n", - size_table, + tcbd_debug(DEBUG_DRV_COMP, "agc table size:%d, band:%s\n", size_table, (_band_type == BAND_TYPE_LBAND) ? "Lband" : "Band3"); - mail.flag = MB_CMD_WRITE; for (i = 0; i < size_table; i++) { - mail.cmd = agc_table[i].cmd; - mail.count = agc_table[i].num_data; - memcpy(mail.data, agc_table[i].data, mail.count * sizeof(u32)); - ret = tcbd_send_mail(_device, &mail); + ret |= tcbd_write_mail_box(_device, agc_table[i].cmd, + agc_table[i].num_data, + agc_table[i].data); } return ret; @@ -231,26 +235,19 @@ s32 tcbd_send_agc_data( s32 tcbd_send_frequency(struct tcbd_device *_device, s32 _freq_khz) { - s32 ret = 0; - struct tcbd_mail_data mail; + s32 data, ret = 0; tcbd_debug(DEBUG_DRV_COMP, "freq:%d\n", _freq_khz); - mail.flag = MB_CMD_WRITE; - mail.cmd = MBPARA_SYS_NUM_FREQ; - mail.count = 1; - mail.data[0] = 1; - ret |= tcbd_send_mail(_device, &mail); - - mail.cmd = MBPARA_SYS_FREQ_0_6; - mail.data[0] = _freq_khz; - ret |= tcbd_send_mail(_device, &mail); + data = 1; + ret |= tcbd_write_mail_box(_device, MBPARA_SYS_NUM_FREQ, 1, &data); + ret |= tcbd_write_mail_box(_device, MBPARA_SYS_FREQ_0_6, 1, &_freq_khz); return ret; } -static inline void tcbd_sort_start_cu( - struct tcbd_multi_service *_multi_svc, u32 *_svc_info) +static inline void tcbd_sort_start_cu(struct tcbd_multi_service *_multi_svc, + u32 *_svc_info) { s32 i, j; s32 start_cu[TCBD_MAX_NUM_SERVICE]; @@ -283,36 +280,24 @@ static inline void tcbd_sort_start_cu( } } for (i = 0; i < TCBD_MAX_NUM_SERVICE * 2; i++) - tcbd_debug(DEBUG_DRV_COMP, - "%02d: 0x%08X\n", i, _svc_info[i]); + tcbd_debug(DEBUG_DRV_COMP, "%02d: 0x%08X\n", i, _svc_info[i]); } s32 tcbd_send_service_info(struct tcbd_device *_device) { s32 ret = 0; - struct tcbd_mail_data mail = {0, } ; struct tcbd_multi_service *mult_service = &_device->mult_service; u32 sorted_svc_info[TCBD_MAX_NUM_SERVICE * 2]; u8 num_svc = TCBD_MAX_NUM_SERVICE; tcbd_sort_start_cu(mult_service, sorted_svc_info); - mail.cmd = MBPARA_SEL_CH_INFO_PRAM; - mail.count = num_svc; - memcpy(mail.data, sorted_svc_info, - num_svc * sizeof(u32)); - ret = tcbd_send_mail(_device, &mail); - - mail.cmd = MBPARA_SEL_CH_INFO_PRAM + 1; - mail.count = num_svc; - memcpy(mail.data, sorted_svc_info + num_svc, - num_svc * sizeof(u32)); - ret = tcbd_send_mail(_device, &mail); - - mail.cmd = MBPARA_SYS_DAB_MCI_UPDATE; - mail.count = 1; - mail.data[0] = mult_service->service_count; - ret |= tcbd_send_mail(_device, &mail); + ret = tcbd_write_mail_box(_device, MBPARA_SEL_CH_INFO_PRAM, + num_svc, sorted_svc_info); + ret |= tcbd_write_mail_box(_device, MBPARA_SEL_CH_INFO_PRAM + 1, + num_svc, sorted_svc_info + num_svc); + ret |= tcbd_write_mail_box(_device, MBPARA_SYS_DAB_MCI_UPDATE, 1, + &mult_service->service_count); tcbd_debug(DEBUG_DRV_COMP, "service count:%d\n", mult_service->service_count); return ret; @@ -355,7 +340,7 @@ s32 tcbd_enable_buffer(struct tcbd_device *_device) ret |= tcbd_reg_write(_device, TCBD_OBUFF_CONFIG, buff_en); return ret; } - +/*__DEBUG_TCBD__*/ s32 tcbd_init_buffer_region(struct tcbd_device *_device) { s32 i, ret = 0; @@ -410,8 +395,7 @@ s32 tcbd_init_buffer_region(struct tcbd_device *_device) return ret; } -s32 tcbd_change_memory_view( - struct tcbd_device *_device, +s32 tcbd_change_memory_view(struct tcbd_device *_device, enum tcbd_remap_type _remap) { return tcbd_reg_write(_device, TCBD_INIT_REMAP, (u8)_remap); @@ -432,8 +416,7 @@ u32 tcbd_get_osc_clock(struct tcbd_device *_device) return clock_config_table[(int)_device->clock_type][4]; } -s32 tcbd_init_pll( - struct tcbd_device *_device, enum tcbd_clock_type _ctype) +s32 tcbd_init_pll(struct tcbd_device *_device, enum tcbd_clock_type _ctype) { /* * _pll_data[0] = PLL_WAIT_TIME @@ -453,7 +436,11 @@ s32 tcbd_init_pll( _device->clock_type = _ctype; - clock_config = clock_config_table[(s32)_ctype]; + if (!tcbd_debug_spur_dbg()) + clock_config = clock_config_table[(s32)_ctype]; + else + clock_config = tcbd_debug_spur_clk_cfg(); + tcbd_debug(DEBUG_DRV_COMP, "osc clock:%d, P:%X, M:%X, S:%d\n", clock_config[1], clock_config[2], clock_config[3], clock_config[4]); @@ -497,18 +484,15 @@ static s32 tcbd_check_dsp(struct tcbd_device *_device) _device, TCBD_MAIL_FIFO_WIND, (u8 *)&status, 4); if (status != 0x1ACCE551) { - tcbd_debug(DEBUG_ERROR, - " # Error access mail [0x%X]\n", status); + tcbd_debug(DEBUG_ERROR, " # Error access mail [0x%X]\n", + status); return -TCERR_CANNOT_ACCESS_MAIL; } return ret; } -s32 tcbd_reset_ip( - struct tcbd_device *_device, - u8 _comp_en, - u8 _comp_rst) +s32 tcbd_reset_ip(struct tcbd_device *_device, u8 _comp_en, u8 _comp_rst) { s32 ret = 0; _device->processor = _comp_en; @@ -521,18 +505,13 @@ s32 tcbd_reset_ip( s32 tcbd_change_stream_type(struct tcbd_device *_device, u32 _format) { - struct tcbd_mail_data mail = {0, }; - - mail.flag = MB_CMD_WRITE; - mail.cmd = MBPARA_SYS_DAB_STREAM_SET; - mail.count = 1; - mail.data[0] = _format; _device->selected_stream = _format; - return tcbd_send_mail(_device, &mail); + return tcbd_write_mail_box(_device, MBPARA_SYS_DAB_STREAM_SET, + 1, &_format); } -s32 tcbd_demod_tune_frequency( - struct tcbd_device *_device, u32 _freq_khz, s32 _bw_khz) +s32 tcbd_demod_tune_frequency(struct tcbd_device *_device, u32 _freq_khz, + s32 _bw_khz) { s32 ret = 0; u32 sel_stream = 0; @@ -562,6 +541,7 @@ s32 tcbd_demod_tune_frequency( if (_device->curr_band != _device->prev_band) tcbd_send_agc_data(_device, _device->curr_band); + ret |= tcbd_set_pid_filter(_device, FILTER_ENABLE | FILTER_SYNCERR); ret |= tcbd_dsp_warm_start(_device); return ret; } @@ -626,15 +606,14 @@ s32 tcbd_dsp_warm_start(struct tcbd_device *_device) ret |= tcbd_recv_mail(_device, &mail); if (ret < 0 || mail.data[0] != 0x1ACCE551) { - tcbd_debug(DEBUG_ERROR, - " # Could not warm boot! [%08X]\n", mail.data[0]); + tcbd_debug(DEBUG_ERROR, " # Could not warm boot! [%08X]\n", + mail.data[0]); return -TCERR_WARMBOOT_FAIL; } ret = tcbd_start_demod(_device); if (ret >= 0) - tcbd_debug(DEBUG_DRV_COMP, - "Warm boot succeed! [0x%X] ret:%d\n", + tcbd_debug(DEBUG_DRV_COMP, "Warm boot succeed! [0x%X] ret:%d\n", mail.data[0], ret); return ret; } @@ -747,23 +726,17 @@ s32 tcbd_init_dsp(struct tcbd_device *_device, u8 *_boot_code, s32 _size) ret |= tcbd_change_memory_view(_device, EP_RAM0_RAM1); for (i = 0; i < num_table_entry && boot_bin[i].size; i++) { - tcbd_debug(DEBUG_API_COMMON, - "# download boot to 0x%X, size %d\n", - boot_bin[i].addr, boot_bin[i].size); - ret |= tcbd_mem_write( - _device, - boot_bin[i].addr, - boot_bin[i].data, + tcbd_debug(DEBUG_API_COMMON, "# download boot to 0x%X, " + "size %d\n", boot_bin[i].addr, boot_bin[i].size); - ret |= tcbd_reg_read_burst_cont(_device, - TCBD_CMDDMA_CRC32, - (u8 *)&dma_crc, - 4); - if (boot_bin[i].crc && - (SWAP32(dma_crc) != boot_bin[i].crc)) { - tcbd_debug(DEBUG_ERROR, - "# CRC Error DMA[0x%08X] != BIN[0x%08X]\n", - dma_crc, boot_bin[i].crc); + ret |= tcbd_mem_write(_device, boot_bin[i].addr, + boot_bin[i].data, boot_bin[i].size); + ret |= tcbd_reg_read_burst_cont(_device, TCBD_CMDDMA_CRC32, + (u8 *)&dma_crc, 4); + if (boot_bin[i].crc && (SWAP32(dma_crc) != boot_bin[i].crc)) { + tcbd_debug(DEBUG_ERROR, "# CRC Error DMA[0x%08X] !=" + " BIN[0x%08X]\n", dma_crc, + boot_bin[i].crc); return -TCERR_CRC_FAIL; } } @@ -828,3 +801,8 @@ s32 tcbd_check_dsp_status(struct tcbd_device *_device) } return 0; } + +s32 tcbd_set_pid_filter(struct tcbd_device *_device, u32 _filter) +{ + return tcbd_write_mail_box(_device, MBPARA_SYS_DAB_DP_FLT, 1, &_filter); +} diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_drv_peri.c b/drivers/media/tdmb/tcc3170/src/tcbd_drv_peri.c index 143b52d..8a162f7 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_drv_peri.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_drv_peri.c @@ -163,7 +163,7 @@ s32 tcbd_init_peri_gpio( break; } - tcbd_reg_write_burst_cont(_device, TCBD_GPIO_ALT, cfg_value, 10); + tcbd_reg_write_burst_cont(_device, TCBD_GPIO_ALT, cfg_value, 2); /*tcbd_reg_write_burst_cont(_device, TCBD_GPIO_DRV, drv_strength, 2);*/ return 0; } @@ -172,41 +172,41 @@ s32 tcbd_select_peri( struct tcbd_device *_device, enum tcbd_peri_type _peri_type) { s32 ret = 0; - u8 periMode[4] = {0, }; - u8 interface_speed = tcbd_calc_clock(_device, 3000, 10000); + u8 peri_mode[4] = {0, }; + u8 interface_speed = 4; /*tcbd_calc_clock(_device, 3000, 10000);*/ tcbd_debug(DEBUG_DRV_PERI, "peri type:%d, clock div:%d\n", (s32)(_peri_type), interface_speed); switch (_peri_type) { case PERI_TYPE_SPI_SLAVE: - tcbd_peri_spi_slave(periMode, interface_speed); + tcbd_peri_spi_slave(peri_mode, interface_speed); ret |= tcbd_reg_write_burst_cont( - _device, TCBD_PERI_MODE0, periMode, 2); + _device, TCBD_PERI_MODE0, peri_mode, 2); ret |= tcbd_reg_write(_device, TCBD_PERI_CTRL, 0x90); ret |= tcbd_init_peri_gpio(_device, PERI_TYPE_SPI_SLAVE); break; case PERI_TYPE_SPI_MASTER: - tcbd_peri_spi_master(periMode, interface_speed); + tcbd_peri_spi_master(peri_mode, interface_speed); ret |= tcbd_reg_write_burst_cont( - _device, TCBD_PERI_MODE0, periMode, 2); + _device, TCBD_PERI_MODE0, peri_mode, 2); ret |= tcbd_reg_write(_device, TCBD_PERI_CTRL, 0x90); ret |= tcbd_init_peri_gpio(_device, PERI_TYPE_SPI_MASTER); break; case PERI_TYPE_PTS: - tcbd_peri_pts(periMode, interface_speed); + tcbd_peri_pts(peri_mode, interface_speed); ret |= tcbd_reg_write_burst_cont( - _device, TCBD_PERI_MODE0, periMode, 4); + _device, TCBD_PERI_MODE0, peri_mode, 4); ret |= tcbd_init_peri_gpio(_device, PERI_TYPE_PTS); break; case PERI_TYPE_STS: - tcbd_peri_sts(periMode, interface_speed); + tcbd_peri_sts(peri_mode, interface_speed); ret |= tcbd_reg_write_burst_cont( - _device, TCBD_PERI_MODE0, periMode, 4); + _device, TCBD_PERI_MODE0, peri_mode, 4); ret |= tcbd_init_peri_gpio(_device, PERI_TYPE_STS); break; case PERI_TYPE_HPI: - tcbd_peri_hpi(periMode); - ret |= tcbd_reg_write(_device, TCBD_PERI_MODE0, periMode[0]); + tcbd_peri_hpi(peri_mode); + ret |= tcbd_reg_write(_device, TCBD_PERI_MODE0, peri_mode[0]); break; case PERI_TYPE_SPI_ONLY: ret |= tcbd_reg_write(_device, TCBD_PERI_CTRL, 0x80); diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_hal.c b/drivers/media/tdmb/tcc3170/src/tcbd_hal.c index 43c2eb3..fba77e7 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_hal.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_hal.c @@ -30,7 +30,10 @@ #include "tcpal_os.h" #include "tcpal_debug.h" #include "tcbd_hal.h" +#include "tcbd_feature.h" +#define __USE_DXB0_IRQ__ +/*#define __USE_DXB1_IRQ__*/ #ifdef __USE_TC_CPU__ static PGPIO RGPIO; @@ -51,22 +54,38 @@ void tchal_reset_device(void) { #ifdef __USE_TC_CPU__ tcbd_debug(DEBUG_TCHAL, "\n"); - +#if defined(__CSPI_ONLY__) /* select peripheral mode as SPI */ +#if defined(__USE_DXB1_IRQ__) BITCLR(RGPIO->GPAFN1, Hw16 - Hw12); /* DXB1_IRQ Set GPIO mode*/ BITSET(RGPIO->GPAEN, Hw11); /* DXB1_IRQ output mode*/ BITCLR(RGPIO->GPADAT, Hw11); /* DXB1_IRQ clear*/ +#elif defined(__USE_DXB0_IRQ__) + BITCLR(RGPIO->GPDFN1, Hw8 - Hw4); /* DXB0_IRQ Set GPIO mode*/ + BITSET(RGPIO->GPDEN, Hw9); /* DXB0_IRQ output mode*/ + BITCLR(RGPIO->GPDDAT, Hw9); /* DXB0_IRQ clear*/ +#endif /*__USE_DXB1_IRQ__*/ +#endif /*__CSPI_ONLY__*/ /* reset */ +#if defined(__CSPI_ONLY__) BITCLR(RGPIO->GPEFN1, Hw16 - Hw12); /* DXB1_RST# Set GPIO mode */ BITSET(RGPIO->GPEEN, Hw11);/* DXB1_RST# Set GPIO Output mode*/ BITCLR(RGPIO->GPEDAT, Hw11);/* DXB1_RST# Clear */ tcpal_msleep(10); BITSET(RGPIO->GPEDAT, Hw11);/* DXB1_RST# Set*/ +#elif defined(__I2C_STS__) + BITCLR(RGPIO->GPDFN1, Hw4 - Hw0); /* DXB0_RST# Set GPIO mode */ + BITSET(RGPIO->GPDEN, Hw8); /* DXB0_RST# Set GPIO Output mode*/ + BITCLR(RGPIO->GPDDAT, Hw8); /* DXB0_RST# Clear */ + tcpal_msleep(10); + BITSET(RGPIO->GPDDAT, Hw8); /* DXB0_RST# Set*/ +#else /*__CSPI_ONLY__ || __I2C_STS__*/ +#error "you must define __CSPI_ONLY__ or __I2C_STS__" +#endif /*!__CSPI_ONLY__ && !__I2C_STS__*/ #endif } - void tchal_power_on_device(void) { #ifdef __USE_TC_CPU__ @@ -92,21 +111,30 @@ void tchal_power_down_device(void) BITCLR(RGPIO->GPEFN0, Hw16 - Hw12); BITSET(RGPIO->GPEEN, Hw3);/* DXB1_PD Set GPIO Output mode*/ BITCLR(RGPIO->GPEDAT, Hw3);/* DXB1_PD Clear*/ +#if defined(__CSPI_ONLY__) BITCLR(RGPIO->GPEDAT, Hw11);/* DXB1_RST# Clear*/ - - BITCLR(RGPIO->GPAFN1, Hw16 - Hw12);/* DXB1_RST# Set GPIO mode*/ - BITSET(RGPIO->GPAEN, Hw11);/* DXB1_RST# Set GPIO Output mode*/ - BITCLR(RGPIO->GPADAT, Hw11);/* DXB1_RST# Clear*/ +#elif defined(__I2C_STS__) + BITCLR(RGPIO->GPDDAT, Hw8);/* DXB0_RST# Clear */ +#else +#error "you must define __CSPI_ONLY__ or __I2C_STS__" +#endif #endif } void tchal_irq_setup(void) { #ifdef __USE_TC_CPU__ +#if defined(__USE_DXB1_IRQ__) BITCLR(RGPIO->GPAFN1, Hw16 - Hw12);/* DXB1_IRQ Set GPIO mode*/ BITCLR(RGPIO->GPAEN, Hw11);/* DXB1_IRQ input mode*/ - BITCSET(RGPIO->EINTSEL0, Hw32 - Hw24, 11<<24); + BITCSET(RGPIO->EINTSEL0, Hw32 - Hw24, 11<<24); /*GPIO_A11*/ +#elif defined(__USE_DXB0_IRQ__) + BITCLR(RGPIO->GPDFN1, Hw8 - Hw4); /* DXB0_IRQ Set GPIO mode*/ + BITCLR(RGPIO->GPDEN, Hw9); /* DXB0_IRQ input mode*/ + + BITCSET(RGPIO->EINTSEL0, Hw32 - Hw24, 20<<24); /*GPIO_D9*/ +#endif /*__USE_DXB1_IRQ__*/ BITSET(RPIC->POL0, 1<<IRQ_TC317X); #endif } diff --git a/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c b/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c index db55f3d..229bcc1 100644 --- a/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c +++ b/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c @@ -27,8 +27,8 @@ #include "tcbd_stream_parser.h" #define SIZE_MSC_CACHE_BUFF (188*20) -#define SIZE_FIC_CACHE_BUFF (388*4) -#define SIZE_STATUS_CACHE_BUFF (32*4) +#define SIZE_FIC_CACHE_BUFF (388*2) +#define SIZE_STATUS_CACHE_BUFF (32*2) #if defined(__MERGE_EACH_TYPEOF_STREAM__) #define SIZE_MSC_STACK_BUFF (1024*16) @@ -39,12 +39,12 @@ #define MAX_SUBCH_ID (0x1<<6) enum tcbd_split_stream_state { STATE_NO_SYNC = 0, - STATE_READ_NEXT, STATE_OTHER, STATE_STATUS, STATE_MSC, STATE_FIC, STATE_GARBAGE, + STATE_ERROR }; #define HEADER_SIZE 4 @@ -66,6 +66,8 @@ struct merged_stream_info { #endif /* __MERGE_EACH_TYPEOF_STREAM__ */ struct tcbd_split_stream_data { + s32 dev_idx; + s32 header_err[2]; enum tcbd_split_stream_state state; s32 header_cnt; s32 remain; @@ -82,7 +84,7 @@ struct tcbd_split_stream_data { tcbd_stream_callback stream_callback; }; -static struct tcbd_split_stream_data tcbd_stream_spliter; +static struct tcbd_split_stream_data tcbd_stream_spliter[2]; static inline u8 tcbd_parity_check(u8 *parity) { @@ -94,139 +96,106 @@ static inline u8 tcbd_parity_check(u8 *parity) p = (p + ((parity[i] >> k) & 1)) & 1; } - if (p == 0) - tcbd_debug(DEBUG_ERROR, "Odd parity error\n"); - return p; } -static s32 tcbd_find_sync(struct tcbd_split_stream_data *_parser) -{ - s32 i; - s32 next_hdr, size = _parser->remain; - u8 *stream = _parser->buffer; - -#if defined(__FIND_HEADER_MORE__) - s32 j, first = 0, num_found = 0, data_size; -#endif /*__FIND_HEADER_MORE__ */ - - /* 1. SYNC_BYTE must exist at stream[3] */ - if ((stream[3] == SYNC_BYTE) && - (tcbd_parity_check(stream) == 1)) - return 0; - - /* 2. if SYNC_BYTE doesn't exist at stream[3] - then search SYNC_BYTE at whole stream*/ - for (i = 0; i < size; i++) { - if ((i < 3) || (stream[i] != SYNC_BYTE)) - continue; - - if (tcbd_parity_check(&stream[i - 3]) != 1) { - next_hdr = SWAP32(*((u32 *)&stream[i-3])); - tcbd_debug(DEBUG_ERROR, - "parity error!! find next byte, " - "offset:%d, header:0x%08X\n", - i, next_hdr); - continue; - } -#if !defined(__FIND_HEADER_MORE__) - tcbd_debug(DEBUG_STREAM_PARSER, - "found header offset %d\n", i-3); - return i - 3; -#else /* __FIND_HEADER_MORE__ */ - num_found = 1; - first = j = i - 3; - do { - data_size = - (stream[j + 1] << 7 | (stream[j+0] >> 1)) << 2; - j += (data_size + 4); - if (j >= size) - break; - - if ((stream[j + 3] == SYNC_BYTE) && - (tcbd_parity_check(stream + j) == 1)) { - tcbd_debug(DEBUG_STREAM_PARSER, - "header ok pos:%d," - "remain:%d\n", j, size); - num_found++; - } else { - next_hdr = - SWAP32(*((u32 *)(stream + j))); - tcbd_debug(DEBUG_ERROR, - "Header ERR!! [%02X] j = %d," - " size=%d, data_size:%d\n", - next_hdr, j, size, data_size); - num_found--; - break; - } - } while (j < size); - - if (num_found > 1) { - next_hdr = SWAP32(*((u32 *)(stream+first))); - tcbd_debug(DEBUG_STREAM_PARSER, - "offset:%d, header ok count : %d, 0x%08X\n", - first, num_found, next_hdr); - return first; - } -#endif /*__FIND_HEADER_MORE__*/ - } - return -i; -} +#define FIC_ID 0x00 +#define STATUS_ID 0x3F +#define GARBAGE_ID 0x04 +#define OTHER_CHIP_ID 0x3D -static inline s32 tcbd_parse_header(struct tcbd_split_stream_data *_parser) +static inline void tcbd_change_parser_state(struct op_header *header, + struct tcbd_split_stream_data *_parser) { - u8 *stream = _parser->buffer; - struct op_header *header = &_parser->header; + s32 size_limit[] = { -1, 4096, 32, 4096, 388, 4096}; + s8 *type[] = {NULL, "other", "status", "msc", "fic", "garbage"}; - if ((stream[3] != SYNC_BYTE) || - (tcbd_parity_check(stream) != 1)) { - tcbd_debug(DEBUG_ERROR, "wrong header! header:0x%08X\n", - SWAP32(*(u32 *)stream)); - memset(header, 0, sizeof(struct op_header)); - return HEADER_SIZE; - } - _parser->header_cnt++; - - header->sync = stream[3]; - header->type = (stream[2] & 0xC0) >> 6; - header->data_size = ((stream[1]<<7) | (stream[0]>>1)) << 2; - header->subch = stream[2] & 0x3F; - - _parser->state = STATE_NO_SYNC; switch ((enum DATA_TYPE)header->type) { case DATA_TYPE_MSC: - if (header->data_size != TCBD_FIC_SIZE) + if (header->data_size == 388) { + _parser->state = STATE_FIC; + header->type = DATA_TYPE_FIC; + } else _parser->state = STATE_MSC; break; case DATA_TYPE_FIC: - if (header->subch) + if (header->subch == GARBAGE_ID) _parser->state = STATE_GARBAGE; - else + else if (header->subch == FIC_ID) _parser->state = STATE_FIC; + else + _parser->state = STATE_ERROR; break; case DATA_TYPE_STATUS: - _parser->state = STATE_STATUS; + if (header->subch == STATUS_ID) + _parser->state = STATE_STATUS; + else + _parser->state = STATE_ERROR; break; case DATA_TYPE_OTHER: - _parser->state = STATE_OTHER; + if (header->subch == OTHER_CHIP_ID) + _parser->state = STATE_OTHER; + else + _parser->state = STATE_ERROR; break; default: + tcbd_debug(DEBUG_ERROR, "unknown data type!!"); + _parser->state = STATE_ERROR; + break; + } + switch (_parser->state) { + case STATE_ERROR: + _parser->header_err[1]++; + _parser->state = STATE_NO_SYNC; + break; + default: + if (size_limit[_parser->state] < header->data_size) { + tcbd_debug(DEBUG_ERROR, "wrong data size %s:%d!\n", + type[_parser->state], header->data_size); + _parser->header_err[1]++; + _parser->state = STATE_NO_SYNC; + + } else + _parser->header_cnt++; break; } - return HEADER_SIZE; } -static inline void tcbd_stack_chunk( - struct tcbd_split_stream_data *_parser, u8 *_buffer) +static s32 tcbd_parse_header(struct tcbd_split_stream_data *_parser) { - u8 *chunk_buff = (_buffer) ? _buffer : _parser->buffer; + u8 *stream = _parser->buffer; struct op_header *header = &_parser->header; + _parser->state = STATE_NO_SYNC; + if ((stream[3] != SYNC_BYTE) || (tcbd_parity_check(stream) != 1)) { + _parser->header_err[0]++; + return HEADER_SIZE; + } + + header->sync = stream[3]; + header->type = (stream[2] & 0xC0) >> 6; + header->data_size = ((stream[1]<<7) | (stream[0]>>1)) << 2; + header->subch = stream[2] & 0x3F; + + tcbd_debug(DEBUG_PARSE_HEADER, "sync:0x%02X, type:%d, size:%d\n", + header->sync, header->type, + header->data_size); + tcbd_change_parser_state(header, _parser); + + return HEADER_SIZE; +} + #if defined(__MERGE_EACH_TYPEOF_STREAM__) +static void tcbd_merge_each_stream(struct tcbd_split_stream_data *_parser, + u8 *chunk_buff) +{ static u8 msc_buff[TCBD_MAX_NUM_SERVICE][SIZE_MSC_STACK_BUFF]; static u8 fic_buff[SIZE_FIC_STACK_BUFF]; static u8 status_buff[SIZE_STATUS_STACK_BUFF]; + struct merged_stream_info *merged; + struct op_header *header = &_parser->header; + s32 sz_stack_buff[] = { SIZE_MSC_STACK_BUFF, SIZE_FIC_STACK_BUFF, @@ -236,7 +205,7 @@ static inline void tcbd_stack_chunk( switch (header->type) { case DATA_TYPE_MSC: if (_parser->num_subch >= TCBD_MAX_NUM_SERVICE) { - tcbd_debug(DEBUG_ERROR, "error!\n"); + tcbd_debug(DEBUG_ERROR, "exceeded max num service!\n"); return; } if (_parser->quick_msc_idx[header->subch] == 0xFF) @@ -245,10 +214,8 @@ static inline void tcbd_stack_chunk( quick_msc_idx = _parser->quick_msc_idx[header->subch]; if (quick_msc_idx >= TCBD_MAX_NUM_SERVICE) - tcbd_debug(DEBUG_ERROR, "quick_msc_idx:%d, " - "header->subch:%d\n", - quick_msc_idx, - header->subch); + tcbd_debug(DEBUG_ERROR, "quick_msc_idx:%d, header->" + "subch:%d\n", quick_msc_idx, header->subch); merged = &_parser->merged_msc[quick_msc_idx]; merged->buffer = msc_buff[quick_msc_idx]; @@ -267,114 +234,29 @@ static inline void tcbd_stack_chunk( return; } - if (merged->curr_pos + header->data_size > - sz_stack_buff[header->type]) { + if (merged->curr_pos+header->data_size > sz_stack_buff[header->type]) { tcbd_debug(DEBUG_ERROR, "overflow stack buffer!!\n"); return; } - tcbd_debug(DEBUG_STREAM_STACK, - "type:%d, subchid:%d, buffer:%p currpos:%d, size:%d\n", - header->type, - header->subch, - merged->buffer, - merged->curr_pos, + tcbd_debug(DEBUG_STREAM_STACK, "type:%d, subchid:%u, buffer:%p " + "currpos:%d, size:%d\n", header->type, header->subch, + merged->buffer, merged->curr_pos, header->data_size); + memcpy(merged->buffer + merged->curr_pos, chunk_buff, header->data_size); - memcpy(merged->buffer + merged->curr_pos, - chunk_buff, header->data_size); merged->curr_pos += header->data_size; - -#else /* __MERGE_EACH_TYPEOF_STREAM__ */ - if (_parser->stream_callback) { - _parser->stream_callback( - chunk_buff, - header->data_size, - header->subch, - header->type); - } -#endif /* !__MERGE_EACH_TYPEOF_STREAM__ */ } -static s32 tcbd_push_chunk( - struct tcbd_split_stream_data *_parser, u8 *_cached_buff) -{ - s32 move, pre_copied; - u8 *buffer = _parser->buffer; - s8 *type[] = {"msc", "fic", "status", "other"}; - s32 size_cache_buff[] = { - SIZE_MSC_CACHE_BUFF, - SIZE_FIC_CACHE_BUFF, - SIZE_STATUS_CACHE_BUFF}; - struct op_header *header = &_parser->header; - - if (_parser->next_read) { - if (_parser->state != STATE_GARBAGE) { - pre_copied = header->data_size - _parser->next_read; - - tcbd_debug(DEBUG_PARSING_PROC, - "send %s data %d bytes, pre:%d," - " curr:%d, buffer:%p\n", - type[header->type], - header->data_size, - pre_copied, - _parser->next_read, - _cached_buff); - - if (header->data_size > size_cache_buff[header->type]) - tcbd_debug(DEBUG_ERROR, - "overflow %s cache buffer!!\n", - type[header->type]); - memcpy(_cached_buff + pre_copied, buffer, - _parser->next_read); - tcbd_stack_chunk(_parser, _cached_buff); - } - move = _parser->next_read; - _parser->state = STATE_NO_SYNC; - _parser->next_read = 0; - } else if (_parser->remain >= header->data_size) { - if (_parser->state != STATE_GARBAGE) { - tcbd_debug(DEBUG_PARSING_PROC, - "send %s data %d bytes\n", - type[header->type], - header->data_size); - tcbd_stack_chunk(_parser, NULL); - } - _parser->state = STATE_NO_SYNC; - move = header->data_size; - } else { - if (_parser->state != STATE_GARBAGE) { - tcbd_debug(DEBUG_PARSING_PROC, - "keep %s data %d bytes buff:%p\n", - type[header->type], - _parser->remain, - _cached_buff); - - if (header->data_size > size_cache_buff[header->type]) - tcbd_debug(DEBUG_ERROR, - "overflow %s cache buffer!!\n", - type[header->type]); - memcpy(_cached_buff, buffer, _parser->remain); - } - _parser->next_read = header->data_size - _parser->remain; - move = _parser->remain; - } - return move; -} - -#if defined(__MERGE_EACH_TYPEOF_STREAM__) -static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) +static s32 tcbd_push_merged_stream(struct tcbd_split_stream_data *_parser) { register s32 i; struct merged_stream_info *merged = NULL; struct merged_stream_info *list_stream[] = { - NULL, - &_parser->merged_fic, - &_parser->merged_status, - NULL + NULL, &_parser->merged_fic, &_parser->merged_status, NULL }; tcbd_debug(DEBUG_STREAM_STACK, "header num:%d, num subch :%d\n", - tcbd_stream_spliter.header_cnt, _parser->num_subch); + _parser->header_cnt, _parser->num_subch); for (i = 0; i < _parser->num_subch; i++) { merged = &_parser->merged_msc[i]; if (!merged->buffer || !merged->curr_pos) @@ -382,10 +264,9 @@ static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) /* send merged data to user space */ if (_parser->stream_callback) { - _parser->stream_callback(merged->buffer, - merged->curr_pos, - merged->subch_id, - DATA_TYPE_MSC); + _parser->stream_callback(_parser->dev_idx, + merged->buffer, merged->curr_pos, + merged->subch_id, DATA_TYPE_MSC); merged->buffer = NULL; merged->curr_pos = 0; } @@ -398,7 +279,7 @@ static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) /* send merged data to user space */ if (_parser->stream_callback) { - _parser->stream_callback( + _parser->stream_callback(_parser->dev_idx, merged->buffer, merged->curr_pos, merged->subch_id, i); merged->buffer = NULL; @@ -409,97 +290,236 @@ static s32 tcbd_push_stream(struct tcbd_split_stream_data *_parser) } #endif /*__MERGE_EACH_TYPEOF_STREAM__ */ -s32 tcbd_split_stream(u8 *_stream, s32 _size) +static void tcbd_stack_chunk(struct tcbd_split_stream_data *_parser, + u8 *_buffer) +{ + u8 *chunk_buff = (_buffer) ? _buffer : _parser->buffer; +#if defined(__MERGE_EACH_TYPEOF_STREAM__) + tcbd_merge_each_stream(_parser, chunk_buff); +#else /* __MERGE_EACH_TYPEOF_STREAM__ */ + struct op_header *header = &_parser->header; + if (_parser->stream_callback) { + _parser->stream_callback(_parser->dev_idx, chunk_buff, + header->data_size, header->subch, header->type); + } +#endif /* !__MERGE_EACH_TYPEOF_STREAM__ */ +} + +static inline s32 tcbd_push_concat(struct tcbd_split_stream_data *_parser, + u8 *_cache_buff) +{ + s32 pre_copied, ret; + u8 *buffer = _parser->buffer; + struct op_header *header = &_parser->header; + + s8 *type[] = {"msc", "fic", "status", "other"}; + s32 size_cache_buff[] = { + SIZE_MSC_CACHE_BUFF, + SIZE_FIC_CACHE_BUFF, + SIZE_STATUS_CACHE_BUFF}; + + if (header->data_size > size_cache_buff[header->type]) { + tcbd_debug(DEBUG_ERROR, "overflow %s cache buffer!! size:%d\n", + type[header->type], header->data_size); + _parser->state = STATE_ERROR; + ret = HEADER_SIZE; + goto exit_func; + } + + pre_copied = header->data_size - _parser->next_read; + if (_parser->next_read > _parser->remain) { + memcpy(_cache_buff + pre_copied, buffer, _parser->remain); + _parser->next_read -= _parser->remain; + ret = _parser->remain; + tcbd_debug(DEBUG_PARSING_PROC, "keep %s data %d bytes, pre:%d," + "next:%d, buffer:%p\n", type[header->type], + _parser->remain, pre_copied, _parser->next_read, + _cache_buff); + } else { + memcpy(_cache_buff + pre_copied, buffer, _parser->next_read); + tcbd_stack_chunk(_parser, _cache_buff); + ret = _parser->next_read; + tcbd_debug(DEBUG_PARSING_PROC, "send %s data %d bytes, pre:%d," + "curr:%d, buffer:%p\n", type[header->type], + header->data_size, pre_copied, + _parser->next_read, _cache_buff); + _parser->state = STATE_NO_SYNC; + } + +exit_func: + return ret; +} + +static inline void tcbd_push_medium(struct tcbd_split_stream_data *_parser) +{ + struct op_header *header = &_parser->header; + s8 *type[] = {"msc", "fic", "status", "other"}; + + tcbd_debug(DEBUG_PARSING_PROC, "send %s data %d bytes\n", + type[header->type], header->data_size); + tcbd_stack_chunk(_parser, NULL); +} + +static inline s32 tcbd_cache_ramnant(struct tcbd_split_stream_data *_parser, + u8 *_cache_buff) +{ + struct op_header *header = &_parser->header; + u8 *buffer = _parser->buffer; + s8 *type[] = {"msc", "fic", "status", "other"}; + s32 size_cache_buff[] = { + SIZE_MSC_CACHE_BUFF, + SIZE_FIC_CACHE_BUFF, + SIZE_STATUS_CACHE_BUFF}; + + tcbd_debug(DEBUG_PARSING_PROC, "keep %s data %d bytes buff:%p\n", + type[header->type], _parser->remain, _cache_buff); + + if (header->data_size > size_cache_buff[header->type]) { + tcbd_debug(DEBUG_ERROR, "overflow %s cache buffer!! size:%d\n", + type[header->type], header->data_size); + _parser->state = STATE_ERROR; + return HEADER_SIZE; + } else { + memcpy(_cache_buff, buffer, _parser->remain); + return _parser->remain; + } +} + +static s32 tcbd_push_chunk(struct tcbd_split_stream_data *_parser, + u8 *_cached_buff) +{ + s32 move; + struct op_header *header = &_parser->header; + + if (_parser->next_read) { + if (_parser->state != STATE_GARBAGE) + move = tcbd_push_concat(_parser, _cached_buff); + else { + if (_parser->next_read > _parser->remain) { + _parser->next_read -= _parser->remain; + move = _parser->remain; + } else { + move = _parser->next_read; + _parser->state = STATE_NO_SYNC; + } + } + } else if (_parser->remain >= header->data_size) { + if (_parser->state != STATE_GARBAGE) + tcbd_push_medium(_parser); + + _parser->state = STATE_NO_SYNC; + move = header->data_size; + } else { + if (_parser->state != STATE_GARBAGE) + move = tcbd_cache_ramnant(_parser, _cached_buff); + else + move = _parser->remain; + + _parser->next_read = header->data_size - _parser->remain; + } + + switch (_parser->state) { + case STATE_NO_SYNC: +#if defined(__USING_TS_IF__) + if (_parser->next_read == 0) + move += 188 - ((move + SIZE_BUFF_HEADER) % 188); + else + move += 188 - (move % 188); +#endif /*__USING_TS_IF__*/ + case STATE_ERROR: + _parser->state = STATE_NO_SYNC; + _parser->next_read = 0; + default: + break; + } + + return move; +} + +s32 tcbd_split_stream(s32 _dev_idx, u8 *_stream, s32 _size) { s32 ret = 0; register s32 point, move; - /* buffer for un-handled spare data of each interrupt */ static u8 cache_buff_msc[SIZE_MSC_CACHE_BUFF]; static u8 cache_buff_fic[SIZE_FIC_CACHE_BUFF]; static u8 buff_cache_status[SIZE_STATUS_CACHE_BUFF]; - u64 time; + struct tcbd_split_stream_data *spliter = &tcbd_stream_spliter[_dev_idx]; + u64 time = 0; point = move = 0; - tcbd_stream_spliter.remain = _size; - tcbd_stream_spliter.header_cnt = 0; + spliter->remain = _size; + spliter->header_cnt = 0; + memset(spliter->header_err, 0, sizeof(spliter->header_err)); time = tcpal_get_time(); - while (tcbd_stream_spliter.remain > 0) { - tcbd_stream_spliter.buffer = _stream + point; - switch (tcbd_stream_spliter.state) { + while (spliter->remain > 0) { + spliter->buffer = _stream + point; + switch (spliter->state) { case STATE_NO_SYNC: - ret = tcbd_find_sync(&tcbd_stream_spliter); - if (ret < 0) { - tcbd_debug(DEBUG_STREAM_PARSER, - "could not find sync byte!! %d\n", ret); - tcbd_init_parser(NULL); - return ret; - } else if (ret > 0) { - point += ret; - tcbd_stream_spliter.buffer += ret; - tcbd_stream_spliter.remain -= ret; - } - move = tcbd_parse_header(&tcbd_stream_spliter); + move = tcbd_parse_header(spliter); break; case STATE_OTHER: - move = tcbd_parse_header(&tcbd_stream_spliter); + move = tcbd_parse_header(spliter); tcbd_debug(DEBUG_ERROR, "State Other!! size:%d\n", - tcbd_stream_spliter.header.data_size); + spliter->header.data_size); break; case STATE_MSC: - move = tcbd_push_chunk( - &tcbd_stream_spliter, - cache_buff_msc); + move = tcbd_push_chunk(spliter, cache_buff_msc); break; case STATE_FIC: - move = tcbd_push_chunk( - &tcbd_stream_spliter, - cache_buff_fic); + move = tcbd_push_chunk(spliter, cache_buff_fic); break; case STATE_STATUS: - move = tcbd_push_chunk( - &tcbd_stream_spliter, - buff_cache_status); + move = tcbd_push_chunk(spliter, buff_cache_status); break; + case STATE_GARBAGE: - move = tcbd_push_chunk(&tcbd_stream_spliter, NULL); + move = tcbd_push_chunk(spliter, NULL); tcbd_debug(DEBUG_STREAM_PARSER, "State Garbage!:%d\n", - tcbd_stream_spliter.header.data_size); + spliter->header.data_size); break; default: move = 0; point = 0; + spliter->state = STATE_NO_SYNC; + spliter->next_read = 0; tcbd_debug(DEBUG_ERROR, "something wrong!\n"); - break; + goto exit_func; } - tcbd_stream_spliter.remain -= move; + spliter->remain -= move; point += move; tcbd_debug(0, "remain:%d, point:%d, move:%d\n", - tcbd_stream_spliter.remain, point, move); + spliter->remain, point, move); } +exit_func: #if defined(__MERGE_EACH_TYPEOF_STREAM__) - ret = tcbd_push_stream(&tcbd_stream_spliter); + ret = tcbd_push_merged_stream(spliter); #endif /*__MERGE_EACH_TYPEOF_STREAM__*/ - tcbd_debug(DEBUG_PARSING_TIME, - "%lldms elapsed!\n", tcpal_diff_time(time)); + tcbd_debug(DEBUG_PARSING_TIME, "%lldms elapsed to parse!\n", + tcpal_diff_time(time)); + + if (spliter->header_err[0] || spliter->header_err[1]) + tcbd_debug(DEBUG_ERROR, "header err, parity:%d, state:%d\n", + spliter->header_err[0], spliter->header_err[1]); return ret; } -void tcbd_init_parser(tcbd_stream_callback _stream_callback) +void tcbd_init_parser(s32 _dev_idx, tcbd_stream_callback _stream_callback) { tcbd_stream_callback bak = NULL; + struct tcbd_split_stream_data *spliter = &tcbd_stream_spliter[_dev_idx]; - if (tcbd_stream_spliter.stream_callback) - bak = tcbd_stream_spliter.stream_callback; + if (spliter->stream_callback) + bak = spliter->stream_callback; - memset(&tcbd_stream_spliter, 0, sizeof(tcbd_stream_spliter)); + memset(spliter, 0, sizeof(struct tcbd_split_stream_data)); + spliter->dev_idx = _dev_idx; #if defined(__MERGE_EACH_TYPEOF_STREAM__) - memset(tcbd_stream_spliter.quick_msc_idx, 0xFF, - sizeof(tcbd_stream_spliter.quick_msc_idx)); + memset(spliter->quick_msc_idx, 0xFF, sizeof(spliter->quick_msc_idx)); #endif /*__MERGE_EACH_TYPEOF_STREAM__*/ if (_stream_callback) - tcbd_stream_spliter.stream_callback = _stream_callback; + spliter->stream_callback = _stream_callback; else if (bak) - tcbd_stream_spliter.stream_callback = bak; + spliter->stream_callback = bak; } diff --git a/drivers/media/tdmb/tcc3170/src/tcc_fic_decoder/tcc_fic_decoder.c b/drivers/media/tdmb/tcc3170/src/tcc_fic_decoder/tcc_fic_decoder.c index 3764bc1..8997c44 100644 --- a/drivers/media/tdmb/tcc3170/src/tcc_fic_decoder/tcc_fic_decoder.c +++ b/drivers/media/tdmb/tcc3170/src/tcc_fic_decoder/tcc_fic_decoder.c @@ -471,8 +471,8 @@ s32 tcc_fic_run_decoder(u8 *buff, s32 size) s32 num_broken_fib = 0; u16 fib_crc; - if (size != MAX_FIC_SIZE) { - tcbd_debug(DEBUG_ERROR, "invalid fic size!\n"); + if ((size%TCC_FIB_SIZE) != 0) { + tcbd_debug(DEBUG_ERROR, "invalid fic size:%d!\n", size); return -1; } while (size > cnt * TCC_FIB_SIZE) { diff --git a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_debug.c b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_debug.c index 80edd00..abe8ca7 100644 --- a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_debug.c +++ b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_debug.c @@ -20,14 +20,70 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include <linux/module.h> -#include <linux/kernel.h> -#include <linux/moduleparam.h> - #include "tcpal_os.h" #include "tcpal_debug.h" -module_param(tcbd_debug_class, int, 0644); +static s32 tcbd_spur_dbg; + +static s32 tcbd_spur_clock_config[5] = {0x60, 0x00, 0x0F, 0x02, 76800}; +static s32 clock_config_count = 5; + +static s32 tcbd_rom_from_fs; +static char *tcbd_rom_path = "/tmp/tcc3170.rom"; + +static u32 tcbd_mbox_rx[9] = {0, }; +static u32 tcbd_mbox_tx[9*10] = {0, }; + +static s32 mbox_rx_data_len = 9; +static s32 mbox_tx_data_len = 9*10; + +module_param(tcbd_rom_from_fs, int, 0664); +module_param(tcbd_rom_path, charp, 0664); +module_param(tcbd_spur_dbg, int, 0664); +module_param_array(tcbd_spur_clock_config, int, &clock_config_count, 0664); +module_param_array(tcbd_mbox_rx, int, &mbox_rx_data_len, 0664); +module_param_array(tcbd_mbox_tx, int, &mbox_tx_data_len, 0664); + +void tcbd_debug_mbox_rx(u16 *_cmd, s32 *_cnt, u32 **_data) +{ + *_cmd = tcbd_mbox_rx[0]; + *_cnt = tcbd_mbox_rx[1]; + *_data = &tcbd_mbox_rx[2]; +} + +void tcbd_debug_mbox_tx(u16 *_cmd, s32 *_cnt, u32 **_data) +{ + s32 i; + + for (i = 0; i < 10; i++) { + if (tcbd_mbox_tx[i * 9] != *_cmd) + continue; + *_cmd = tcbd_mbox_tx[i * 9 + 0]; + *_cnt = tcbd_mbox_tx[i * 9 + 1]; + *_data = &tcbd_mbox_tx[i * 9 + 2]; + break; + } +} + +s32 tcbd_debug_spur_dbg(void) +{ + return tcbd_spur_dbg; +} + +s32 tcbd_debug_rom_from_fs(void) +{ + return tcbd_rom_from_fs; +} + +s32 *tcbd_debug_spur_clk_cfg(void) +{ + return tcbd_spur_clock_config; +} + +char *tcbd_debug_rom_path(void) +{ + return tcbd_rom_path; +} u32 tcbd_debug_class = DEBUG_API_COMMON | @@ -45,3 +101,6 @@ u32 tcbd_debug_class = /*DEBUG_INTRRUPT | */ DEBUG_INFO | DEBUG_ERROR; + +module_param(tcbd_debug_class, int, 0664); + diff --git a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_io_i2c.c b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_io_i2c.c index aab737d..679c157 100644 --- a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_io_i2c.c +++ b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_io_i2c.c @@ -56,8 +56,8 @@ static s32 tcpal_i2c_probe( struct i2c_client *i2c, const struct i2c_device_id *id) { s32 ret = 0; - tcpal_i2c_client = i2c; + tcbd_debug(DEBUG_TCPAL_I2C, "tcpal_i2c_client : %p\n", i2c); return ret; } @@ -107,7 +107,7 @@ static s32 tcpal_i2c_add_device(void) i2c_put_adapter(adapter); if (!client) { tcbd_debug(DEBUG_TCPAL_I2C, - "can't add i2c device at %p\n", info.addr); + "can't add i2c device at 0x%X\n", info.addr); goto err_driver; } @@ -122,8 +122,6 @@ static s32 tcpal_i2c_close(void) { i2c_unregister_device(tcpal_i2c_client); i2c_del_driver(&tcpal_i2c_driver); - - tcbd_debug(DEBUG_TCPAL_I2C, "\n"); return 0; } diff --git a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_irq_handler.c b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_irq_handler.c index 5f159b3..b6cadaa 100644 --- a/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_irq_handler.c +++ b/drivers/media/tdmb/tcc3170/src/tcpal_linux/tcpal_irq_handler.c @@ -38,8 +38,6 @@ #include "tcc_fic_decoder.h" #include "tcbd_hal.h" -#define __WORKQUEUE__ - struct tcbd_irq_data { struct work_struct work; struct workqueue_struct *work_queue; @@ -51,6 +49,7 @@ struct tcbd_irq_data { static struct tcbd_irq_data tcbd_irq_handler_data; +#if defined(__CSPI_ONLY__) static inline void tcpal_split_stream(struct tcbd_irq_data *irq_data) { s32 size, ret = 0; @@ -60,10 +59,12 @@ static inline void tcpal_split_stream(struct tcbd_irq_data *irq_data) struct tcbd_device *device = irq_data->device; ret = tcbd_read_irq_status(device, &irq_status, &irq_error); + ret |= tcbd_clear_irq(device, irq_status); + ret |= tcbd_read_stream(device, buff_read, &size); - if (ret == 0 && !irq_error) { - tcbd_split_stream(buff_read, size); - } else { + if (ret == 0 && !irq_error) + tcbd_split_stream(0, buff_read, size); + else { tcbd_debug(DEBUG_ERROR, "### buffer is full, skip the data " "(ret:%d, status=0x%02X, error=0x%02X, %d) ###\n", ret, irq_status, irq_error, @@ -74,26 +75,11 @@ static inline void tcpal_split_stream(struct tcbd_irq_data *irq_data) device->selected_buff, device->intr_threshold); /*tcbd_reset_ip(device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_EP);*/ - tcbd_init_parser(NULL); + tcbd_init_parser(0, NULL); } - ret = tcbd_read_irq_status(device, &irq_status, &irq_error); - if (ret != 0 || irq_error != 0) { - tcbd_debug(DEBUG_ERROR, "### buffer is full, skip the data " - "(ret:%d, status=0x%02X, error=0x%02X) ###\n", - ret, irq_status, irq_error); - tcbd_init_stream_data_config(device, - ENABLE_CMD_FIFO, - device->selected_buff, - device->intr_threshold); - /*tcbd_reset_ip(device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_EP);*/ - tcbd_init_parser(NULL); - - } - tcbd_clear_irq(device, irq_status); } -#if defined(__WORKQUEUE__) -static void tcpal_stream_parsing_work(struct work_struct *_param) +static void tcpal_work_parse_stream(struct work_struct *_param) { u64 diff = tcpal_diff_time(tcbd_irq_handler_data.start_tick); struct tcbd_irq_data *irq_data = @@ -106,28 +92,11 @@ static void tcpal_stream_parsing_work(struct work_struct *_param) tcpal_split_stream(irq_data); enable_irq(irq_data->tcbd_irq); } -#endif /*__WORKQUEUE__*/ - -static irqreturn_t tcpal_irq_handler(s32 _irq, void *_param) -{ - struct tcbd_irq_data *irq_data = (struct tcbd_irq_data *)_param; - struct tcbd_device *device = irq_data->device; - disable_irq_nosync(irq_data->tcbd_irq); - if (device->is_pal_irq_en) { -#if defined(__WORKQUEUE__) - irq_data->start_tick = tcpal_get_time(); - queue_work(irq_data->work_queue, &irq_data->work); -#else /*__WORKQUEUE__*/ - tcpal_split_stream(irq_data); -#endif /*!__WORKQUEUE__*/ - tcbd_debug(DEBUG_INTRRUPT, "\n"); - } - return IRQ_HANDLED; -} s32 start_tune; static s32 tcpal_irq_stream_callback( + s32 _dev_idx, u8 *_stream, s32 _size, u8 _subch_id, @@ -175,27 +144,77 @@ skip_fic_parse: } return 0; } +#endif /*__CSPI_ONLY__*/ + +#if defined(__I2C_STS__) +static void tcpal_work_read_fic(struct work_struct *_param) +{ + s32 size = TCBD_FIC_SIZE, ret; + u8 buff[TCBD_FIC_SIZE]; + u64 diff; + struct tcbd_irq_data *irq_data = container_of(_param, + struct tcbd_irq_data, work); + struct tcbd_device *device = irq_data->device; + + diff = tcpal_diff_time(irq_data->start_tick); + tcbd_debug(DEBUG_INTRRUPT, "work delay :%d\n", (u32)diff); + + ret = tcbd_read_fic_data(device, buff, size); + if (ret < 0) { + tcbd_debug(DEBUG_ERROR, "failed to read fic! %d\n", ret); + goto exit_work; + } + + tcbd_enqueue_data(buff, size, 0, 1); + if (!start_tune) /* set by tune_frequency*/ + goto exit_work; + + ret = tcc_fic_run_decoder(buff, MAX_FIC_SIZE); + if (ret > 0) { + tcc_fic_get_ensbl_info(1); + start_tune = 0; + tcc_fic_parser_init(); + } +exit_work: + enable_irq(irq_data->tcbd_irq); +} +#endif /*__I2C_STS__*/ + +static irqreturn_t tcpal_irq_handler(s32 _irq, void *_param) +{ + struct tcbd_irq_data *irq_data = (struct tcbd_irq_data *)_param; + struct tcbd_device *device = irq_data->device; + + disable_irq_nosync(irq_data->tcbd_irq); + if (device->is_pal_irq_en) { + irq_data->start_tick = tcpal_get_time(); + queue_work(irq_data->work_queue, &irq_data->work); + tcbd_debug(DEBUG_INTRRUPT, "\n"); + } + return IRQ_HANDLED; +} s32 tcpal_irq_register_handler(void *_device) { s32 ret; -#if defined(__WORKQUEUE__) + tcbd_irq_handler_data.work_queue = create_singlethread_workqueue("tdmb_work"); tcbd_irq_handler_data.device = (struct tcbd_device *)_device; #if defined(__USE_TC_CPU__) tcbd_irq_handler_data.tcbd_irq = IRQ_TC317X; #endif /*__USE_TC_CPU__*/ - INIT_WORK(&tcbd_irq_handler_data.work, tcpal_stream_parsing_work); -#endif /*__WORKQUEUE__*/ - tcbd_init_parser(tcpal_irq_stream_callback); - ret = request_irq( - tcbd_irq_handler_data.tcbd_irq, - tcpal_irq_handler, +#if defined(__I2C_STS__) + INIT_WORK(&tcbd_irq_handler_data.work, tcpal_work_read_fic); +#elif defined(__CSPI_ONLY__) + INIT_WORK(&tcbd_irq_handler_data.work, tcpal_work_parse_stream); + tcbd_init_parser(0, tcpal_irq_stream_callback); +#endif /*__CSPI_ONLY__*/ + + ret = request_irq(tcbd_irq_handler_data.tcbd_irq, tcpal_irq_handler, IRQF_TRIGGER_FALLING | IRQF_DISABLED, - "tdmb_irq", - &tcbd_irq_handler_data); + "tdmb_irq", &tcbd_irq_handler_data); tcbd_debug(DEBUG_INTRRUPT, "request_irq : %d\n", (int)ret); return ret; } @@ -211,7 +230,9 @@ s32 tcpal_irq_unregister_handler(void) s32 tcpal_irq_enable(void) { - tcbd_init_parser(NULL); +#if defined(__CSPI_ONLY__) + tcbd_init_parser(0, NULL); +#endif /*__CSPI_ONLY__*/ tcbd_debug(DEBUG_INTRRUPT, "\n"); /* enable_irq(tcbd_irq_handler_data.tcbd_irq); */ return 0; |