aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c')
-rw-r--r--drivers/media/tdmb/tcc3170/src/tcbd_stream_parser/tcbd_stream_parser.c532
1 files changed, 276 insertions, 256 deletions
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;
}