path: root/tvapi/libtv/tv/CFbcCommunication.cpp (plain)
blob: 1e4749d44cb6ce9da1a2dba5e912444bf11a9655

1	#include <time.h>
2	#include "CFbcCommunication.h"
3	#include "CTvLog.h"
4	#include "../tvconfig/tvconfig.h"
5	#include "../tvutils/tvutils.h"
6	#define LOG_TAG "FBC"
7
8	static CFbcCommunication *gSingletonFBC = NULL;
9	CFbcCommunication *GetSingletonFBC()
10	{
11	if (gSingletonFBC == NULL) {
12	gSingletonFBC = new CFbcCommunication();
13	gSingletonFBC->start();
14	}
15
16	return gSingletonFBC;
17
18	}
19
20	CFbcCommunication::CFbcCommunication()
21	{
22	initCrc32Table();
23
24	m_event.data.fd = -1;
25	m_event.events = EPOLLIN | EPOLLET;
26
27	mpRevDataBuf = new unsigned char[512];
28
29	mUpgradeFlag = 0;
30	mbDownHaveSend = 0;//false
31	//mFbcMsgQueue.startMsgQueue();
32	mbFbcKeyEnterDown = 0;//false
33	mFbcEnterKeyDownTime = -1;
34	}
35
36	CFbcCommunication::~CFbcCommunication()
37	{
38	m_event.data.fd = mSerialPort.getFd();
39	m_event.events = EPOLLIN | EPOLLET;
40	mEpoll.del(mSerialPort.getFd(), &m_event);
41	closeAll();
42	delete[] mpRevDataBuf;
43	}
44
45	int CFbcCommunication::start()
46	{
47	#if 1
48	//int serial_port = config_get_int("TV", "fbc.communication.serial", SERIAL_C);
49	if (mSerialPort.OpenDevice(SERIAL_C) < 0) {
50	} else {
51	#if 0
52	LOGD("%s %d be called......\n", __FUNCTION__, __LINE__);
53	mSerialPort.set_opt(115200, 8, 1, 'N', 5000, 1);
54	#else
55	LOGD("%s %d be called......\n", __FUNCTION__, __LINE__);
56	mSerialPort.setup_serial();
57	#endif
58	}
59
60	if (mEpoll.create() < 0) {
61	return -1;
62	}
63
64	m_event.data.fd = mSerialPort.getFd();
65	m_event.events = EPOLLIN | EPOLLET;
66	mEpoll.add(mSerialPort.getFd(), &m_event);
67	#endif
68
69	#if 0
70	mHdmiCec.openFile(CEC_PATH);
71	m_event.data.fd = mHdmiCec.getFd();
72	m_event.events = EPOLLIN | EPOLLET;
73	mEpoll.add(mHdmiCec.getFd(), &m_event);
74	#endif
75
76	//timeout for long
77	mEpoll.setTimeout(3000);
78
79	this->run();
80	mTvInput.run();
81	return 0;
82	}
83
84	void CFbcCommunication::testUart()
85	{
86	unsigned char write_buf[64], read_buf[64];
87	int idx = 0;
88	memset(write_buf, 0, sizeof(write_buf));
89	memset(read_buf, 0, sizeof(read_buf));
90
91	write_buf[0] = 0x5a;
92	write_buf[1] = 0x5a;
93	write_buf[2] = 0xb;
94	write_buf[3] = 0x0;
95	write_buf[4] = 0x0;
96	write_buf[5] = 0x40;
97	write_buf[6] = 0x0;
98
99	write_buf[7] = 0x2;
100	write_buf[8] = 0x3c;
101	write_buf[9] = 0x75;
102	write_buf[10] = 0x30;
103	//LOGD("to write ..........\n");
104	mSerialPort.writeFile(write_buf, 11);
105	sleep(1);
106	//LOGD("to read........\n");
107	mSerialPort.readFile(read_buf, 12);
108	for (idx = 0; idx < 12; idx++)
109	LOGD("the data is:0x%x\n", read_buf[idx]);
110	LOGD("end....\n");
111	}
112
113	void CFbcCommunication::showTime(struct timeval *_time)
114	{
115	struct timeval curTime;
116
117	if (_time == NULL) {
118	gettimeofday(&curTime, NULL);
119	} else {
120	curTime.tv_sec = _time->tv_sec;
121	curTime.tv_usec = _time->tv_usec;
122	}
123	if (curTime.tv_usec > 100000) {
124	LOGD("[%d.%d]", curTime.tv_sec, curTime.tv_usec);
125	} else if (curTime.tv_usec > 10000) {
126	LOGD("[%d.0%d]", curTime.tv_sec, curTime.tv_usec);
127	} else if (curTime.tv_usec > 1000) {
128	LOGD("[%d.00%d]", curTime.tv_sec, curTime.tv_usec);
129	} else if (curTime.tv_usec > 100) {
130	LOGD("[%d.000%d]", curTime.tv_sec, curTime.tv_usec);
131	} else if (curTime.tv_usec > 10) {
132	LOGD("[%d.0000%d]", curTime.tv_sec, curTime.tv_usec);
133	} else if (curTime.tv_usec > 1) {
134	LOGD("[%d.00000%d]", curTime.tv_sec, curTime.tv_usec);
135	}
136	}
137	long CFbcCommunication::getTime(void)
138	{
139	struct timeval tv;
140	gettimeofday(&tv, NULL);
141	return tv.tv_sec * 1000 + tv.tv_usec / 1000;
142	}
143	void CFbcCommunication::initCrc32Table()
144	{
145	//生成Crc32的查询表
146	int i, j;
147	unsigned int Crc;
148	for (i = 0; i < 256; i++) {
149	Crc = i;
150	for (j = 0; j < 8; j++) {
151	if (Crc & 1)
152	Crc = (Crc >> 1) ^ 0xEDB88320;
153	else
154	Crc >>= 1;
155	}
156	mCrc32Table[i] = Crc;
157	}
158	}
159
160	void CFbcCommunication::sendAckCmd(bool isOk)
161	{
162	int crc32value = 0;
163	unsigned char ackcmd[12];
164	ackcmd[0] = 0x5A;
165	ackcmd[1] = 0x5A;
166	ackcmd[2] = 12;//little endian
167	ackcmd[3] = 0x00;
168	ackcmd[4] = 0x80;//ack flag
169	ackcmd[5] = 0xff;//cmd id
170	if (isOk) {
171	ackcmd[6] = 0xfe;
172	ackcmd[7] = 0x7f;
173	} else {
174	ackcmd[6] = 0x80;
175	ackcmd[7] = 0x01;
176	}
177	//*((unsigned int*) (ackcmd + 8)) = GetCrc32(ackcmd, 8);
178	crc32value = Calcrc32(0, ackcmd, 8);
179	ackcmd[8] = (crc32value >> 0) & 0xFF;
180	ackcmd[9] = (crc32value >> 8) & 0xFF;
181	ackcmd[10] = (crc32value >> 16) & 0xFF;
182	ackcmd[11] = (crc32value >> 24) & 0xFF;
183	LOGD("to send ack and crc is:0x%x\n", crc32value);
184	sendDataOneway(COMM_DEV_SERIAL, ackcmd, 12, 0x00000000);
185	}
186
187	/* 函数名：GetCrc32
188	* 函数原型：unsigned int GetCrc32(char* InStr,unsigned int len)
189	* 参数：InStr ---指向需要计算CRC32值的字符? * len ---为InStr的长帿 * 返回值为计算出来的CRC32结果? */
190	unsigned int CFbcCommunication::GetCrc32(unsigned char *InStr, unsigned int len)
191	{
192	//开始计算CRC32校验便
193	unsigned int Crc = 0xffffffff;
194	for (int i = 0; i < len; i++) {
195	Crc = (Crc >> 8) ^ mCrc32Table[(Crc & 0xFF) ^ InStr[i]];
196	}
197
198	Crc ^= 0xFFFFFFFF;
199	return Crc;
200	}
201
202	unsigned int CFbcCommunication::Calcrc32(unsigned int crc, const unsigned char *ptr, unsigned int buf_len)
203	{
204	static const unsigned int s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
205	0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
206	};
207	unsigned int crcu32 = crc;
208	if (buf_len < 0)
209	return 0;
210	if (!ptr) return 0;
211	crcu32 = ~crcu32;
212	while (buf_len--) {
213	unsigned char b = *ptr++;
214	crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b & 0xF)];
215	crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b >> 4)];
216	}
217	return ~crcu32;
218	}
219
220	int CFbcCommunication::sendDataOneway(int devno, unsigned char *pData, int dataLen, int flags)
221	{
222	int ret = -1;
223	switch (devno) {
224	case COMM_DEV_CEC: {
225	ret = mHdmiCec.writeFile(pData, dataLen);
226	break;
227	}
228	case COMM_DEV_SERIAL: {
229	ret = mSerialPort.writeFile(pData, dataLen);
230	break;
231	}
232	default:
233	break;
234	}
235	return ret;
236	}
237
238	int CFbcCommunication::rmFromRequestList()
239	{
240	return 0;
241	}
242
243	int CFbcCommunication::addToRequestList()
244	{
245	return 0;
246	}
247	//timeout ms
248	int CFbcCommunication::sendDataAndWaitReply(int devno, int waitForDevno, int waitForCmd, unsigned char *pData, int dataLen, int timeout, unsigned char *pReData, int *reDataLen, int flags)
249	{
250	int ret = sendDataOneway(devno, pData, dataLen, flags);
251	if (ret < 0) return ret;
252
253	mReplyList.WaitDevNo = waitForDevno;
254	mReplyList.WaitCmd = waitForCmd;
255	mReplyList.WaitTimeOut = timeout;
256	mReplyList.reDataLen = 0;
257	mReplyList.replyData = mpRevDataBuf;
258	addToRequestList();
259	LOGD("wait dev:%d, cmd:0x%x, timeout:%d", mReplyList.WaitDevNo, mReplyList.WaitCmd, mReplyList.WaitTimeOut);
260
261	mLock.lock();
262	ret = mReplyList.WaitReplyCondition.waitRelative(mLock, timeout);//wait reply
263	LOGD("wait reply return = %d", __FUNCTION__, __LINE__, ret);
264	mLock.unlock();
265
266	//
267	if (mReplyList.reDataLen > 0) { //data have come in
268	*reDataLen = mReplyList.reDataLen;
269	memcpy(pReData, mReplyList.replyData, mReplyList.reDataLen);
270	mReplyList.reDataLen = 0;
271	return *reDataLen;
272	} else {
273	//timeout,not to wait continue
274	mReplyList.WaitDevNo = -1;
275	mReplyList.WaitCmd = 0xff;
276	return -1;//timeout but data not come.
277	}
278	return 0;
279	}
280
281	int CFbcCommunication::closeAll()
282	{
283	mSerialPort.CloseDevice();
284	return 0;
285	}
286
287	int CFbcCommunication::SetUpgradeFlag(int flag)
288	{
289	mUpgradeFlag = flag;
290	return 0;
291	}
292
293	/*
294	** cmd[0] cmd_type; cmd[1] cmd length; cmd[2] para1 cmd[3] para2 ...
295	*/
296	int CFbcCommunication::handleCmd(COMM_DEV_TYPE_E fromDev, int *pData, int *pRetValue)
297	{
298	fbc_command_t cmd_type = VPU_CMD_NULL;
299	int ret_value = 0;
300
301	if ((fromDev != COMM_DEV_SERIAL && fromDev != COMM_DEV_CEC) || pData == NULL || pRetValue == NULL) {
302	//LOGD("para error and returned!");
303	return -1;
304	}
305
306	cmd_type = (fbc_command_t)pData[0];
307	LOGD("the cmd type is:0x%02x\n", cmd_type);
308	switch (cmd_type) {
309	case VPU_CMD_RED_GAIN_DEF:
310	cfbc_Set_Gain_Red(fromDev, pData[2]);
311	break;
312
313	case VPU_CMD_RED_GAIN_DEF|0x80:
314	cfbc_Get_Gain_Red(fromDev, &ret_value);
315	pRetValue[0] = VPU_CMD_RED_GAIN_DEF | 0x80;
316	pRetValue[1] = 3;
317	pRetValue[2] = ret_value;
318	break;
319
320	case VPU_CMD_PATTEN_SEL:
321	cfbc_Set_Test_Pattern(fromDev, pData[2]);
322	break;
323
324	case VPU_CMD_BACKLIGHT_DEF:
325	cfbc_Set_Backlight(fromDev, pData[2]);
326	break;
327
328	case VPU_CMD_PATTEN_SEL|0x80:
329	cfbc_Get_Test_Pattern(fromDev, &ret_value);
330	pRetValue[0] = VPU_CMD_RED_GAIN_DEF | 0x80;
331	pRetValue[1] = 3;
332	pRetValue[2] = ret_value;
333	break;
334
335	default:
336	return -1;
337	}
338
339	return 0;
340	}
341
342	int CFbcCommunication::uartReadStream(unsigned char *retData, int rd_max_len, int timeout)
343	{
344	int readLen = 0, bufIndex = 0, haveRead = 0;
345	clock_t start_tm = clock();
346
347	do {
348	readLen = mSerialPort.readFile(retData + bufIndex, rd_max_len - haveRead);
349	haveRead += readLen;
350	bufIndex += readLen;
351	if (haveRead == rd_max_len) {
352	return haveRead;
353	}
354
355	LOGD("readLen = %d, haveRead = %d\n", readLen, haveRead);
356
357	if (((clock() - start_tm) / (CLOCKS_PER_SEC / 1000)) > timeout) {
358	return haveRead;
359	}
360	} while (true);
361
362	return haveRead;
363	}
364
365	int CFbcCommunication::uartReadData(unsigned char *retData, int *retLen)
366	{
367	unsigned char tempBuf[512];
368	int cmdLen = 0;
369	int bufIndex = 0;
370	int readLen = 0;
371
372	if (retData == NULL) {
373	LOGD("the retData is NULL\n");
374	return 0;
375	}
376
377	//leader codes 2 byte
378	memset(tempBuf, 0, sizeof(tempBuf));
379	do {
380	readLen = mSerialPort.readFile(tempBuf + 0, 1);
381	if (tempBuf[0] == 0x5A) {
382	bufIndex = 1;
383	readLen = mSerialPort.readFile(tempBuf + 1, 1);
384	if (tempBuf[1] == 0x5A) {
385	bufIndex = 2;
386	LOGD("leading code coming...\n");
387	break;
388	} else {
389	continue;
390	}
391	} else {
392	continue;
393	}
394	} while (true);
395
396	//data len 2 byte
397	int needRead = 2, haveRead = 0;
398	do {
399	readLen = mSerialPort.readFile(tempBuf + bufIndex, needRead - haveRead);
400	haveRead += readLen;
401	bufIndex += readLen;
402	if (haveRead == needRead) {
403	break;
404	}
405	} while (true);
406
407	//little endian
408	cmdLen = (tempBuf[3] << 8) + tempBuf[2];
409	//cmd data cmdLen - 2 -2
410	needRead = cmdLen - 4, haveRead = 0;
411	LOGD("cmdLen is:%d\n", cmdLen);
412
413	do {
414	readLen = mSerialPort.readFile(tempBuf + bufIndex, needRead - haveRead);
415	haveRead += readLen;
416	bufIndex += readLen;
417	if (readLen > 0) {
418	LOGD("data readLen is:%d\n", readLen);
419	}
420	if (haveRead == needRead) {
421	break;
422	}
423	} while (true);
424
425	unsigned int crc = 0;
426	if (cmdLen > 4) {
427	crc = Calcrc32(0, tempBuf, cmdLen - 4);//not include crc 4byte
428	}
429	unsigned int bufCrc = tempBuf[cmdLen - 4] |
430	tempBuf[cmdLen - 3] << 8 |
431	tempBuf[cmdLen - 2] << 16 |
432	tempBuf[cmdLen - 1] << 24;
433	int idx = 0;
434
435	if (crc == bufCrc) {
436	memcpy(retData, tempBuf, cmdLen % 512);
437	*retLen = cmdLen;
438	return cmdLen;
439	} else {
440	return -1;
441	}
442	}
443
444	int CFbcCommunication::processData(COMM_DEV_TYPE_E fromDev, unsigned char *pData, int dataLen)
445	{
446	switch (fromDev) {
447	case COMM_DEV_CEC: {
448	if (mReplyList.WaitDevNo == fromDev && mReplyList.WaitCmd == pData[1]) {
449	mReplyList.reDataLen = dataLen;
450	memcpy(mReplyList.replyData, pData, dataLen);
451	mReplyList.WaitReplyCondition.signal();
452	} else if (0) {
453	}
454	break;
455	}
456	case COMM_DEV_SERIAL: {
457	LOGD("to signal wait dataLen:0x%x, cmdId:0x%x\n", dataLen, pData[5]);
458	if (mReplyList.WaitDevNo == fromDev && mReplyList.WaitCmd == pData[5]) {
459	mReplyList.reDataLen = dataLen;
460	memcpy(mReplyList.replyData, pData, dataLen);
461	mReplyList.WaitReplyCondition.signal();
462	} else {
463	unsigned char cmd = pData[5];
464	//just test
465	const char *value;
466	if (!mbSendKeyCode) {
467	value = config_get_str(CFG_SECTION_FBCUART, "fbc_key_event_handle", "null");
468	if ( strcmp ( value, "true" ) == 0 )
469	mbSendKeyCode = true;
470	else mbSendKeyCode = false;
471	}
472	#if(0)
473	switch (cmd) {
474	case 0x14:
475	if (mbSendKeyCode ) {
476	if (pData[6] >= 12 && pData[6] <= 16 ) { //left ---enter
477	unsigned char key = pData[6] ;
478	LOGD(" key:0x%x\n", key);
479
480	//16 key 28 DPAD_CENTER
481	//12 key 103 DPAD_UP
482	//13 key 108 DPAD_DOWN
483	//14 key 105 DPAD_LEFT
484	//15 key 106 DPAD_RIGHT
485	int checkKey = 0;
486	if (key == 16)
487	checkKey = 28 ;
488	else if (key == 12)
489	checkKey = 103 ;
490	else if (key == 13)
491	checkKey = 108 ;
492	else if (key == 14)
493	checkKey = 105 ;
494	else if (key == 15)
495	checkKey = 106 ;
496	mTvInput.sendkeyCode(checkKey);
497	}
498	}
499	break;
500
501	default:
502	break;
503	}
504	#else
505	static long curTime, lastTime;
506	int tmp;
507	static int st = 0, st_key_up = 0;
508	static int st_key_down = 0;
509	static int st_key_left = 0;
510	static int st_key_right = 0;
511	static int checkKey = 0, last_checkKey = 0;
512
513
514	switch (pData[6]) { //different key
515	case 12: //DPAD_UP
516	st_key_up = pData[5];
517	if (st_key_up == 0x1D) { //CMD_INPUT_DOWN
518	last_checkKey = checkKey;
519	checkKey = 103;
520	mTvInput.sendkeyCode(checkKey);
521	} else if (st_key_up == 0x1E) { //CMD_INPUT_UP
522	//checkKey = 103;
523	//mTvInput.sendkeyCode_Up(checkKey);
524	}
525	break;
526
527	case 13: //DPAD_DOWN
528	st_key_down = pData[5];
529	if (st_key_down == 0x1D) { //CMD_INPUT_DOWN
530	last_checkKey = checkKey;
531	checkKey = 108;
532	mTvInput.sendkeyCode(checkKey);
533	} else if (st_key_down == 0x1E) { //CMD_INPUT_UP
534	//checkKey = 108;
535	//mTvInput.sendkeyCode_Up(checkKey);
536	}
537	break;
538
539	case 14: //DPAD_LEFT
540	st = pData[5];
541	if (st == 0x1D) { //CMD_INPUT_DOWN
542	last_checkKey = checkKey;
543	checkKey = 105;
544	lastTime = 0;
545	mbFbcKeyEnterDown = 1;//true
546	mFbcEnterKeyDownTime = mTvInput.getNowMs();
547	mTvInput.sendKeyRepeatStart(15, 1200, 1500);//code 4, dis 3, repeatTime 2
548	} else if (st == 0x1E) { //CMD_INPUT_UP
549	checkKey = 105;
550	if (mbFbcKeyEnterDown == 1) {
551	mbFbcKeyEnterDown = 0;//false
552	mTvInput.sendKeyRepeatStop();
553	int disFbcEnterKeyDown = mTvInput.getNowMs() - mFbcEnterKeyDownTime;
554	LOGD("disFbcEnterKeyDown = %d", disFbcEnterKeyDown);
555	if (disFbcEnterKeyDown > 1200) { //long down
556	} else {
557	mTvInput.sendkeyCode(105);
558	}
559	}
560	//checkKey = 105;
561	//mTvInput.sendkeyCode_Up(checkKey);
562	}
563	break;
564
565	case 15: //DPAD_RIGHT
566	st_key_right = pData[5];
567	if (st_key_right == 0x1D) { //CMD_INPUT_DOWN
568	last_checkKey = checkKey;
569	checkKey = 106;
570	mTvInput.sendkeyCode(checkKey);
571	} else if (st_key_right == 0x1E) { //CMD_INPUT_UP
572	//checkKey = 106;
573	//mTvInput.sendkeyCode_Up(checkKey);
574	}
575	break;
576
577	case 16: //DPAD_ENTER
578	st = pData[5];
579	if (st == 0x1D) { //CMD_INPUT_DOWN
580	last_checkKey = checkKey;
581	checkKey = 28;
582	lastTime = 0;
583	mbFbcKeyEnterDown = 1;//true
584	mFbcEnterKeyDownTime = mTvInput.getNowMs();
585	mTvInput.sendKeyRepeatStart(158, 1200, 1500);//code 4, dis 3, repeatTime 2
586	} else if (st == 0x1E) { //CMD_INPUT_UP
587	checkKey = 28;
588	if (mbFbcKeyEnterDown == 1) {
589	mbFbcKeyEnterDown = 0;//false
590	mTvInput.sendKeyRepeatStop();
591	int disFbcEnterKeyDown = mTvInput.getNowMs() - mFbcEnterKeyDownTime;
592	LOGD("disFbcEnterKeyDown = %d", disFbcEnterKeyDown);
593	if (disFbcEnterKeyDown > 1200) { //long down
594	} else {
595	mTvInput.sendkeyCode(28);
596	}
597	}
598	}
599	break;
600
601	case 20: //7key power
602	st_key_right = pData[5];
603	if (st_key_right == 0x1D) { //CMD_INPUT_DOWN
604	last_checkKey = checkKey;
605	checkKey = 116;
606	//mTvInput.sendIRkeyCode_Down(checkKey);
607	mTvInput.sendIRkeyCode(checkKey);
608	} else if (st_key_right == 0x1E) { //CMD_INPUT_UP
609	checkKey = 116;
610	//mTvInput.sendIRkeyCode_Up(checkKey);
611	}
612	break;
613
614	case 26: //7key source
615	st_key_right = pData[5];
616	if (st_key_right == 0x1D) { //CMD_INPUT_DOWN
617	last_checkKey = checkKey;
618	checkKey = 466;
619	mTvInput.sendIRkeyCode_Down(checkKey);
620	} else if (st_key_right == 0x1E) { //CMD_INPUT_UP
621	checkKey = 466;
622	mTvInput.sendIRkeyCode_Up(checkKey);
623	}
624	break;
625
626	case 27: //7key menu
627	st_key_right = pData[5];
628	if (st_key_right == 0x1D) { //CMD_INPUT_DOWN
629	last_checkKey = checkKey;
630	checkKey = 139;
631	mTvInput.sendkeyCode(checkKey);
632	} else if (st_key_right == 0x1E) { //CMD_INPUT_UP
633	//checkKey = 139;
634	//mTvInput.sendkeyCode_Up(checkKey);
635	}
636	break;
637
638	case 40: //7key vol -
639	st_key_right = pData[5];
640	if (st_key_right == 0x1D) { //CMD_INPUT_DOWN
641	last_checkKey = checkKey;
642	checkKey = 114;
643	mTvInput.sendIRkeyCode_Down(checkKey);
644	} else if (st_key_right == 0x1E) { //CMD_INPUT_UP
645	checkKey = 114;
646	mTvInput.sendIRkeyCode_Up(checkKey);
647	}
648	break;
649
650	case 41: //7key vol +
651	st_key_right = pData[5];
652	if (st_key_right == 0x1D) { //CMD_INPUT_DOWN
653	last_checkKey = checkKey;
654	checkKey = 115;
655	mTvInput.sendIRkeyCode_Down(checkKey);
656	} else if (st_key_right == 0x1E) { //CMD_INPUT_UP
657	checkKey = 115;
658	mTvInput.sendIRkeyCode_Up(checkKey);
659	}
660	break;
661	case 201: //SARADC_DPAD_UP
662	st_key_up = pData[5];
663	if (st_key_up == 0x1D) { //CMD_INPUT_DOWN
664	last_checkKey = checkKey;
665	checkKey = 950;
666	mTvInput.sendkeyCode_Down(checkKey);
667	} else if (st_key_up == 0x1E) { //CMD_INPUT_UP
668	mTvInput.sendkeyCode_Up(checkKey);
669	}
670	break;
671
672	case 202: //SARADC_DOWN
673	st_key_down = pData[5];
674	if (st_key_down == 0x1D) { //CMD_INPUT_DOWN
675	last_checkKey = checkKey;
676	checkKey = 951;
677	mTvInput.sendkeyCode_Down(checkKey);
678	} else if (st_key_down == 0x1E) { //CMD_INPUT_UP
679	mTvInput.sendkeyCode_Up(checkKey);
680	}
681	break;
682
683	case 203: //SARADC_LEFT
684	st = pData[5];
685	if (st == 0x1D) { //CMD_INPUT_DOWN
686	last_checkKey = checkKey;
687	checkKey = 952;
688	lastTime = 0;
689	mbFbcKeyEnterDown = 1;//true
690	mFbcEnterKeyDownTime = mTvInput.getNowMs();
691	mTvInput.sendkeyCode_Down(checkKey);
692	mTvInput.sendKeyRepeatStart(955, 1200, 1500);//code 4, dis 3, repeatTime 2
693	} else if (st == 0x1E) { //CMD_INPUT_UP
694	checkKey = 952;
695	if (mbFbcKeyEnterDown == 1) {
696	mbFbcKeyEnterDown = 0;//false
697	mTvInput.sendKeyRepeatStop();
698	int disFbcEnterKeyDown = mTvInput.getNowMs() - mFbcEnterKeyDownTime;
699	LOGD("disFbcEnterKeyDown = %d", disFbcEnterKeyDown);
700	if (disFbcEnterKeyDown > 1200) { //long down
701	mTvInput.sendkeyCode_Up(955);
702	mTvInput.sendkeyCode_Up(952);
703	} else {
704	mTvInput.sendkeyCode_Up(checkKey);
705	}
706	}
707	}
708	break;
709
710
711	case 204: //SARADC_RIGHT
712	st_key_right = pData[5];
713	if (st_key_right == 0x1D) { //CMD_INPUT_DOWN
714	last_checkKey = checkKey;
715	checkKey = 953;
716	mTvInput.sendkeyCode_Down(checkKey);
717	} else if (st_key_right == 0x1E) { //CMD_INPUT_UP
718	mTvInput.sendkeyCode_Up(checkKey);
719
720	}
721	break;
722
723	case 205: //SARADC_ENTER
724	st_key_right = pData[5];
725	if (st_key_right == 0x1D) { //CMD_INPUT_DOWN
726	last_checkKey = checkKey;
727	checkKey = 954;
728	mTvInput.sendkeyCode_Down(checkKey);
729	} else if (st_key_right == 0x1E) { //CMD_INPUT_UP
730	mTvInput.sendkeyCode_Up(checkKey);
731	}
732
733	break;
734	}
735	#endif
736	}
737	break;
738	}
739	default: {
740	break;
741	}
742	}
743	return 0;
744	}
745	bool CFbcCommunication::threadLoop()
746	{
747	unsigned char readFrameBuf[512];
748	while (!exitPending()) { //requietexit() or requietexitWait() not call
749	while (mUpgradeFlag == 1) {
750	usleep(1000 * 1000);
751	}
752
753	int num = mEpoll.wait();
754
755	while (mUpgradeFlag == 1) {
756	usleep(1000 * 1000);
757	}
758
759	for (int i = 0; i < num; ++i) {
760	int fd = (mEpoll)[i].data.fd;
761	/**
762	* EPOLLIN event
763	*/
764	if ((mEpoll)[i].events & EPOLLIN) {
765	if (fd == mHdmiCec.getFd()) { //ce-----------------------------c
766	int bufIndex = 0;
767	int needRead = 4;
768	int haveRead = 0;
769	int idx = 0, readLen = 0;
770	do {
771	readLen = mHdmiCec.readFile(readFrameBuf + bufIndex, needRead - haveRead);
772	haveRead += readLen;
773	bufIndex += readLen;
774	//if(haveRead == needRead) break;
775	} while (0);
776
777	if (readLen > 0) {
778	processData(COMM_DEV_CEC, readFrameBuf, readLen);
779	} else {
780	}
781	} else if (fd == mSerialPort.getFd()) {
782	//seria---------------------------l
783	int cmdLen = 0, idx = 0;
784	LOGD("serial data come");
785	memset(readFrameBuf, 0, 512);
786	int ret = uartReadData(readFrameBuf, &cmdLen);
787
788	if (ret == -1) { //data error
789	sendAckCmd(false);
790	} else if (readFrameBuf[4] == 0x80) { //ack
791	LOGD("is ack come");
792	#ifdef TV_RESEND_UMUTE_TO_FBC
793	if (((readFrameBuf[7] << 8) | readFrameBuf[6]) == 0x8001 &&
794	readFrameBuf[5] == AUDIO_CMD_SET_MUTE) {
795	LOGD("resend unmute to 101 avoid 101 receiving unmute timeout\n");
796	Fbc_Set_Value_INT8(COMM_DEV_SERIAL, AUDIO_CMD_SET_MUTE, 1);
797	}
798	#endif
799	} else { //not ack
800	sendAckCmd(true);
801	processData(COMM_DEV_SERIAL, readFrameBuf, cmdLen);
802	}
803	}
804	}
805
806	/**
807	* EPOLLOUT event
808	*/
809	if ((mEpoll)[i].events & EPOLLOUT) {
810
811	}
812	}
813	}
814	//exit
815	//return true, run again, return false,not run.
816	LOGD("thread exited..........\n");
817	return false;
818	}
819
820
821
822	int CFbcCommunication::Fbc_Set_Value_INT8(COMM_DEV_TYPE_E toDev, int cmd_type, int value)
823	{
824	if (mUpgradeFlag == 1) {
825	return 0;
826	}
827	LOGD("%s cmd =0x%x, value=%d", __FUNCTION__, cmd_type, value);
828	if (toDev == COMM_DEV_CEC) {
829	unsigned char cmd[16], rxbuf[16];
830	int rxlen = 0, idx = 0;
831	memset(cmd, 0, 16);
832	memset(rxbuf, 0, 16);
833	cmd[0] = 0x40;
834	cmd[1] = cmd_type;
835	cmd[2] = value;
836	sendDataOneway(COMM_DEV_CEC, cmd, 4, 0);
837	} else if (toDev == COMM_DEV_SERIAL) {
838	int crc32value = 0;
839	unsigned char write_buf[512];
840	unsigned char rxbuf[512];
841	int rxlen = 0, idx = 0;
842
843	//leading code
844	write_buf[0] = 0x5a;
845	write_buf[1] = 0x5a;
846	//package length from begin to end
847	write_buf[2] = 0xb;
848	write_buf[3] = 0x0;
849	//Ack byte
850	write_buf[4] = 0x0;
851	//cmd ID
852	write_buf[5] = cmd_type;
853	//parameter
854	write_buf[6] = value;
855	//crc32 little Endian
856	crc32value = Calcrc32(0, write_buf, 7);
857	write_buf[7] = (crc32value >> 0) & 0xFF;
858	write_buf[8] = (crc32value >> 8) & 0xFF;
859	write_buf[9] = (crc32value >> 16) & 0xFF;
860	write_buf[10] = (crc32value >> 24) & 0xFF;
861	sendDataOneway(COMM_DEV_SERIAL, write_buf, write_buf[2], 0);
862	}
863	return 0;
864	}
865	int CFbcCommunication::Fbc_Set_Value_INT32(COMM_DEV_TYPE_E toDev, int cmd_type, int value)
866	{
867	if (mUpgradeFlag == 1) {
868	return 0;
869	}
870
871	if (toDev == COMM_DEV_SERIAL) {
872	int crc32value = 0;
873	unsigned char write_buf[512];
874	unsigned char rxbuf[512];
875	int rxlen = 0, idx = 0;
876
877	//leading code
878	write_buf[0] = 0x5a;
879	write_buf[1] = 0x5a;
880	//package length from begin to end
881	write_buf[2] = 14;
882	write_buf[3] = 0x0;
883	//Ack byte
884	write_buf[4] = 0x0;
885	//cmd ID
886	write_buf[5] = cmd_type;
887	//parameter
888	write_buf[6] = (value >> 0) & 0xFF;
889	write_buf[7] = (value >> 8) & 0xFF;
890	write_buf[8] = (value >> 16) & 0xFF;
891	write_buf[9] = (value >> 24) & 0xFF;
892	//crc32 little Endian
893	crc32value = Calcrc32(0, write_buf, 10);
894	write_buf[10] = (crc32value >> 0) & 0xFF;
895	write_buf[11] = (crc32value >> 8) & 0xFF;
896	write_buf[12] = (crc32value >> 16) & 0xFF;
897	write_buf[13] = (crc32value >> 24) & 0xFF;
898
899	return sendDataOneway(COMM_DEV_SERIAL, write_buf, write_buf[2], 0);
900	}
901	return -1;
902	}
903	int CFbcCommunication::Fbc_Get_Value_INT8(COMM_DEV_TYPE_E fromDev, int cmd_type, int *value)
904	{
905	if (mUpgradeFlag == 1) {
906	return 0;
907	}
908
909	LOGD("%s cmd =0x%x", __FUNCTION__, cmd_type);
910
911	if (fromDev == COMM_DEV_CEC) {
912	unsigned char cmd[16], rxbuf[16];
913	int rxlen = 0, idx = 0;
914	memset(cmd, 0, 16);
915	memset(rxbuf, 0, 16);
916	cmd[0] = 0x40;
917	cmd[1] = cmd_type;
918	sendDataAndWaitReply(COMM_DEV_CEC, COMM_DEV_CEC, cmd[1], cmd, 4, 0, rxbuf, &rxlen, 0);
919	*value = rxbuf[6];
920	} else if (fromDev == COMM_DEV_SERIAL) {
921	int crc32value = 0, idx = 0, rxlen = 0;
922	unsigned char write_buf[16];
923	unsigned char rxbuf[16];
924	memset(rxbuf, 0, 16);
925
926	//leading code
927	idx = 0;
928	write_buf[idx++] = 0x5a;
929	write_buf[idx++] = 0x5a;
930	//package length from begin to end
931	write_buf[idx++] = 0xa;
932	write_buf[idx++] = 0x0;
933	//Ack byte
934	write_buf[idx++] = 0x0;
935	//cmd ID
936	write_buf[idx++] = cmd_type;
937	//crc32 little Endian
938	crc32value = Calcrc32(0, write_buf, idx);
939	write_buf[idx++] = (crc32value >> 0) & 0xFF;
940	write_buf[idx++] = (crc32value >> 8) & 0xFF;
941	write_buf[idx++] = (crc32value >> 16) & 0xFF;
942	write_buf[idx++] = (crc32value >> 24) & 0xFF;
943
944	sendDataAndWaitReply(COMM_DEV_SERIAL, COMM_DEV_SERIAL, write_buf[5], write_buf, write_buf[2], 2000, rxbuf, &rxlen, 0);
945	*value = rxbuf[6];
946	}
947	return 0;
948	}
949
950	int CFbcCommunication::Fbc_Set_BatchValue(COMM_DEV_TYPE_E toDev, unsigned char *cmd_buf, int count)
951	{
952	if (mUpgradeFlag == 1) {
953	return 0;
954	}
955
956	if ( 512 <= count) {
957	return -1;
958	}
959
960	if (toDev == COMM_DEV_CEC) {
961	unsigned char cmd[512], rxbuf[512];
962	int rxlen = 0, idx = 0;
963	memset(cmd, 0, 512);
964	memset(rxbuf, 0, 512);
965	cmd[0] = 0x40;
966	for (idx = 0; idx < count; idx++) {
967	cmd[idx + 1] = cmd_buf[idx];
968	}
969	sendDataOneway(COMM_DEV_CEC, cmd, count + 1, 0);
970	} else if (toDev == COMM_DEV_SERIAL) {
971	int crc32value = 0;
972	unsigned char write_buf[512];
973	unsigned char rxbuf[512];
974	int rxlen = 0, idx = 0;
975
976	//leading code
977	write_buf[0] = 0x5a;
978	write_buf[1] = 0x5a;
979	//package length from begin to end
980	write_buf[2] = (count + 9) & 0xFF;
981	write_buf[3] = ((count + 9) >> 8) & 0xFF;
982	//Ack byte : 0x80-> ack package;0x00->normal package;
983	write_buf[4] = 0x00;
984
985	for (idx = 0; idx < count; idx++) {
986	write_buf[idx + 5] = cmd_buf[idx];
987	}
988	//crc32 little Endian
989	crc32value = Calcrc32(0, write_buf, count + 5);
990	write_buf[count + 5] = (crc32value >> 0) & 0xFF;
991	write_buf[count + 6] = (crc32value >> 8) & 0xFF;
992	write_buf[count + 7] = (crc32value >> 16) & 0xFF;
993	write_buf[count + 8] = (crc32value >> 24) & 0xFF;
994	sendDataOneway(COMM_DEV_SERIAL, write_buf, count + 9, 0);
995	}
996	return 0;
997	}
998
999	int CFbcCommunication::Fbc_Get_BatchValue(COMM_DEV_TYPE_E fromDev, unsigned char *cmd_buf, int count)
1000	{
1001	if (mUpgradeFlag == 1) {
1002	return 0;
1003	}
1004
1005	if ( 512 <= count) {
1006	return -1;
1007	}
1008	int ret = 0;
1009	// TODO: read value
1010	if (fromDev == COMM_DEV_CEC) {
1011	unsigned char cmd[512], rxbuf[512];
1012	int rxlen = 0, idx = 0;
1013	memset(cmd, 0, 512);
1014	memset(rxbuf, 0, 512);
1015	cmd[0] = 0x40;
1016	cmd[1] = cmd_buf[0];
1017	sendDataAndWaitReply(COMM_DEV_CEC, COMM_DEV_CEC, cmd[1], cmd, count + 1, 0, rxbuf, &rxlen, 0);
1018
1019	if (rxlen > 2) {
1020	for (idx = 0; idx < rxlen; idx++) {
1021	cmd_buf[idx] = cmd[idx + 1];
1022	}
1023	}
1024	} else if (fromDev == COMM_DEV_SERIAL) {
1025	int crc32value = 0, idx = 0, rxlen = 0;
1026	unsigned char write_buf[512];
1027	unsigned char rxbuf[512];
1028	memset(write_buf, 0, 512);
1029	memset(rxbuf, 0, 512);
1030
1031	//leading code
1032	write_buf[0] = 0x5a;
1033	write_buf[1] = 0x5a;
1034	//package length from begin to end
1035	write_buf[2] = (count + 9) & 0xFF;
1036	write_buf[3] = ((count + 9) >> 8) & 0xFF;
1037	//Ack byte
1038	write_buf[4] = 0x00;
1039	//cmd ID
1040	for (idx = 0; idx < count; idx++) {
1041	write_buf[idx + 5] = cmd_buf[idx];
1042	}
1043	//crc32 little Endian
1044	crc32value = Calcrc32(0, write_buf, count + 5);
1045	write_buf[count + 5] = (crc32value >> 0) & 0xFF;
1046	write_buf[count + 6] = (crc32value >> 8) & 0xFF;
1047	write_buf[count + 7] = (crc32value >> 16) & 0xFF;
1048	write_buf[count + 8] = (crc32value >> 24) & 0xFF;
1049	sendDataAndWaitReply(COMM_DEV_SERIAL, COMM_DEV_SERIAL, write_buf[5], write_buf, write_buf[2], 2000, rxbuf, &rxlen, 0);
1050
1051	if (rxlen > 9) {
1052	for (idx = 0; idx < (rxlen - 9); idx++) {
1053	cmd_buf[idx] = rxbuf[idx + 5];
1054	}
1055	}
1056	ret = rxlen;
1057	}
1058
1059	return ret;
1060	}
1061
1062	int CFbcCommunication::cfbc_Set_Gain_Red(COMM_DEV_TYPE_E fromDev, int value)
1063	{
1064	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_RED_GAIN_DEF, value);
1065	}
1066
1067	int CFbcCommunication::cfbc_Get_Gain_Red(COMM_DEV_TYPE_E fromDev, int *value)
1068	{
1069	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_RED_GAIN_DEF | 0x80, value);
1070	}
1071
1072	int CFbcCommunication::cfbc_Set_Gain_Green(COMM_DEV_TYPE_E fromDev, int value)
1073	{
1074	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_GREEN_GAIN_DEF, value);
1075	}
1076
1077	int CFbcCommunication::cfbc_Get_Gain_Green(COMM_DEV_TYPE_E fromDev, int *value)
1078	{
1079	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_GREEN_GAIN_DEF | 0x80, value);
1080	}
1081
1082	int CFbcCommunication::cfbc_Set_Gain_Blue(COMM_DEV_TYPE_E fromDev, int value)
1083	{
1084	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_BLUE_GAIN_DEF, value);
1085	}
1086
1087	int CFbcCommunication::cfbc_Get_Gain_Blue(COMM_DEV_TYPE_E fromDev, int *value)
1088	{
1089	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_BLUE_GAIN_DEF | 0x80, value);
1090	}
1091
1092	int CFbcCommunication::cfbc_Set_Offset_Red(COMM_DEV_TYPE_E fromDev, int value)
1093	{
1094	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_PRE_RED_OFFSET_DEF, value);
1095	}
1096
1097	int CFbcCommunication::cfbc_Get_Offset_Red(COMM_DEV_TYPE_E fromDev, int *value)
1098	{
1099	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_PRE_RED_OFFSET_DEF | 0x80, value);
1100	}
1101
1102	int CFbcCommunication::cfbc_Set_Offset_Green(COMM_DEV_TYPE_E fromDev, int value)
1103	{
1104	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_PRE_GREEN_OFFSET_DEF, value);
1105	}
1106
1107	int CFbcCommunication::cfbc_Get_Offset_Green(COMM_DEV_TYPE_E fromDev, int *value)
1108	{
1109	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_PRE_GREEN_OFFSET_DEF | 0x80, value);
1110	}
1111
1112	int CFbcCommunication::cfbc_Set_Offset_Blue(COMM_DEV_TYPE_E fromDev, int value)
1113	{
1114	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_PRE_BLUE_OFFSET_DEF, value);
1115	}
1116
1117	int CFbcCommunication::cfbc_Get_Offset_Blue(COMM_DEV_TYPE_E fromDev, int *value)
1118	{
1119	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_PRE_BLUE_OFFSET_DEF | 0x80, value);
1120	}
1121
1122	int CFbcCommunication::cfbc_Set_WB_Initial(COMM_DEV_TYPE_E fromDev, int value)
1123	{
1124	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_WB, value);
1125	}
1126
1127	int CFbcCommunication::cfbc_Get_WB_Initial(COMM_DEV_TYPE_E fromDev, int *value)
1128	{
1129	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_WB | 0x80, value);
1130	}
1131
1132	int CFbcCommunication::cfbc_Set_ColorTemp_Mode(COMM_DEV_TYPE_E fromDev, int value)
1133	{
1134	int fbcValue = value;
1135	switch (value) {
1136	case 0: //standard
1137	fbcValue = 1;
1138	break;
1139	case 1: //warm
1140	fbcValue = 2;
1141	break;
1142	case 2: //cold
1143	fbcValue = 0;
1144	break;
1145	default:
1146	break;
1147	}
1148	LOGD("before set fbcValue = %d", fbcValue);
1149	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_COLOR_TEMPERATURE_DEF, fbcValue);
1150	}
1151
1152	int CFbcCommunication::cfbc_Get_ColorTemp_Mode(COMM_DEV_TYPE_E fromDev, int *value)
1153	{
1154	Fbc_Get_Value_INT8(fromDev, VPU_CMD_COLOR_TEMPERATURE_DEF | 0x80, value);
1155
1156	switch (*value) {
1157	case 0: //cold
1158	*value = 2;
1159	break;
1160	case 1: //standard
1161	*value = 0;
1162	break;
1163	case 2: //warm
1164	*value = 1;
1165	break;
1166	default:
1167	break;
1168	}
1169
1170	return 0;
1171	}
1172
1173	int CFbcCommunication::cfbc_Set_Test_Pattern(COMM_DEV_TYPE_E fromDev, int value)
1174	{
1175	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_PATTEN_SEL, value);
1176	}
1177
1178	int CFbcCommunication::cfbc_Get_Test_Pattern(COMM_DEV_TYPE_E fromDev, int *value)
1179	{
1180	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_PATTEN_SEL | 0x80, value);
1181	}
1182
1183	int CFbcCommunication::cfbc_Set_Picture_Mode(COMM_DEV_TYPE_E fromDev, int value)
1184	{
1185	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_PICTURE_MODE, value);
1186	}
1187
1188	int CFbcCommunication::cfbc_Get_Picture_Mode(COMM_DEV_TYPE_E fromDev, int *value)
1189	{
1190	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_PICTURE_MODE | 0x80, value);
1191	}
1192
1193	int CFbcCommunication::cfbc_Set_Contrast(COMM_DEV_TYPE_E fromDev, int value)
1194	{
1195	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_CONTRAST_DEF, value);
1196	}
1197
1198	int CFbcCommunication::cfbc_Get_Contrast(COMM_DEV_TYPE_E fromDev, int *value)
1199	{
1200	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_CONTRAST_DEF | 0x80, value);
1201	}
1202
1203	int CFbcCommunication::cfbc_Set_Brightness(COMM_DEV_TYPE_E fromDev, int value)
1204	{
1205	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_BRIGHTNESS_DEF, value);
1206	}
1207
1208	int CFbcCommunication::cfbc_Get_Brightness(COMM_DEV_TYPE_E fromDev, int *value)
1209	{
1210	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_BRIGHTNESS_DEF | 0x80, value);
1211	}
1212
1213	int CFbcCommunication::cfbc_Set_Saturation(COMM_DEV_TYPE_E fromDev, int value)
1214	{
1215	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_COLOR_DEF, value);
1216	}
1217
1218	int CFbcCommunication::cfbc_Get_Saturation(COMM_DEV_TYPE_E fromDev, int *value)
1219	{
1220	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_COLOR_DEF | 0x80, value);
1221	}
1222
1223	int CFbcCommunication::cfbc_Set_HueColorTint(COMM_DEV_TYPE_E fromDev, int value)
1224	{
1225	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_HUE_DEF, value);
1226	}
1227
1228	int CFbcCommunication::cfbc_Get_HueColorTint(COMM_DEV_TYPE_E fromDev, int *value)
1229	{
1230	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_HUE_DEF | 0x80, value);
1231	}
1232
1233	int CFbcCommunication::cfbc_Set_Backlight(COMM_DEV_TYPE_E fromDev, int value)
1234	{
1235	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_BACKLIGHT_DEF, value);
1236	}
1237
1238	int CFbcCommunication::cfbc_Get_Backlight(COMM_DEV_TYPE_E fromDev, int *value)
1239	{
1240	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_BACKLIGHT_DEF | 0x80, value);
1241	}
1242
1243	int CFbcCommunication::cfbc_Set_Source(COMM_DEV_TYPE_E fromDev, int value)
1244	{
1245	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_SOURCE, value);
1246	}
1247
1248	int CFbcCommunication::cfbc_Get_Source(COMM_DEV_TYPE_E fromDev, int *value)
1249	{
1250	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_SOURCE | 0x80, value);
1251	}
1252
1253	int CFbcCommunication::cfbc_Set_Mute(COMM_DEV_TYPE_E fromDev, int value)
1254	{
1255	LOGD("cfbc_Set_Mute = %d", value);
1256	return Fbc_Set_Value_INT8(fromDev, AUDIO_CMD_SET_MUTE, value);
1257	}
1258	int CFbcCommunication::cfbc_Set_FBC_Audio_Source(COMM_DEV_TYPE_E fromDev, int value)
1259	{
1260	return Fbc_Set_Value_INT8(fromDev, AUDIO_CMD_SET_SOURCE, value);
1261	}
1262
1263	int CFbcCommunication::cfbc_Get_Mute(COMM_DEV_TYPE_E fromDev, int *value)
1264	{
1265	return Fbc_Get_Value_INT8(fromDev, AUDIO_CMD_GET_MUTE, value);
1266	}
1267
1268	int CFbcCommunication::cfbc_Set_Volume_Bar(COMM_DEV_TYPE_E fromDev, int value)
1269	{
1270	return Fbc_Set_Value_INT8(fromDev, AUDIO_CMD_SET_VOLUME_BAR, value);
1271	}
1272
1273	int CFbcCommunication::cfbc_Get_Volume_Bar(COMM_DEV_TYPE_E fromDev, int *value)
1274	{
1275	return Fbc_Get_Value_INT8(fromDev, AUDIO_CMD_GET_VOLUME_BAR, value);
1276	}
1277
1278	int CFbcCommunication::cfbc_Set_Balance(COMM_DEV_TYPE_E fromDev, int value)
1279	{
1280	return Fbc_Set_Value_INT8(fromDev, AUDIO_CMD_SET_BALANCE, value);
1281	}
1282
1283	int CFbcCommunication::cfbc_Get_Balance(COMM_DEV_TYPE_E fromDev, int *value)
1284	{
1285	return Fbc_Get_Value_INT8(fromDev, AUDIO_CMD_GET_BALANCE, value);
1286	}
1287
1288	int CFbcCommunication::cfbc_Set_Master_Volume(COMM_DEV_TYPE_E fromDev, int value)
1289	{
1290	return Fbc_Set_Value_INT8(fromDev, AUDIO_CMD_SET_MASTER_VOLUME, value);
1291	}
1292
1293	int CFbcCommunication::cfbc_Get_Master_Volume(COMM_DEV_TYPE_E fromDev, int *value)
1294	{
1295	return Fbc_Get_Value_INT8(fromDev, AUDIO_CMD_GET_MASTER_VOLUME, value);
1296	}
1297
1298	int CFbcCommunication::cfbc_Set_CM(COMM_DEV_TYPE_E fromDev, unsigned char value)
1299	{
1300	unsigned char cmd[512];
1301	memset(cmd, 0, 512);
1302
1303	cmd[0] = VPU_CMD_ENABLE;
1304	cmd[1] = VPU_MODULE_CM2;
1305	cmd[2] = value;//value:0~1
1306	return Fbc_Set_BatchValue(fromDev, cmd, 3);
1307	}
1308
1309	int CFbcCommunication::cfbc_Get_CM(COMM_DEV_TYPE_E fromDev, int *value)
1310	{
1311	unsigned char cmd[512];
1312	memset(cmd, 0, 512);
1313
1314	cmd[0] = VPU_CMD_ENABLE | 0x80;
1315	cmd[1] = VPU_MODULE_CM2;
1316
1317	Fbc_Get_BatchValue(fromDev, cmd, 2);
1318	*value = cmd[2];
1319
1320	return 0;
1321	}
1322	int CFbcCommunication::cfbc_Set_DNLP(COMM_DEV_TYPE_E fromDev, unsigned char value)
1323	{
1324	unsigned char cmd[512];
1325	memset(cmd, 0, 512);
1326
1327	cmd[0] = VPU_CMD_ENABLE;
1328	cmd[1] = VPU_MODULE_DNLP;
1329	cmd[2] = value;//value:0~1
1330
1331	return Fbc_Set_BatchValue(fromDev, cmd, 3);
1332	}
1333
1334	int CFbcCommunication::cfbc_Get_DNLP(COMM_DEV_TYPE_E fromDev, int *value)
1335	{
1336	unsigned char cmd[512];
1337	memset(cmd, 0, 512);
1338
1339	cmd[0] = VPU_CMD_ENABLE | 0x80;
1340	cmd[1] = VPU_MODULE_DNLP;
1341
1342	Fbc_Get_BatchValue(fromDev, cmd, 2);
1343	*value = cmd[2];
1344
1345	return 0;
1346	}
1347
1348	int CFbcCommunication::cfbc_Get_FBC_MAINCODE_Version(COMM_DEV_TYPE_E fromDev, char sw_ver[], char build_time[], char git_ver[], char git_branch[], char build_name[])
1349	{
1350	int rx_len = 0, tmp_ind = 0;
1351	unsigned char cmd[512];
1352
1353	if (sw_ver == NULL || build_time == NULL || git_ver == NULL || git_branch == NULL || build_name == NULL) {
1354	return -1;
1355	}
1356
1357	memset(cmd, 0, 512);
1358	cmd[0] = CMD_FBC_MAIN_CODE_VERSION;
1359	rx_len = Fbc_Get_BatchValue(fromDev, cmd, 1);
1360
1361	sw_ver[0] = 0;
1362	build_time[0] = 0;
1363	git_ver[0] = 0;
1364	git_branch[0] = 0;
1365	build_name[0] = 0;
1366
1367	if (rx_len <= 0) {
1368	return -1;
1369	}
1370
1371	if (cmd[0] != CMD_FBC_MAIN_CODE_VERSION || cmd[1] != 0x88 || cmd[2] != 0x99) {
1372	return -1;
1373	}
1374
1375	tmp_ind = 3;
1376
1377	strcpy(sw_ver, (char *)(cmd + tmp_ind));
1378	tmp_ind += strlen(sw_ver);
1379	tmp_ind += 1;
1380
1381	strcpy(build_time, (char *)(cmd + tmp_ind));
1382	tmp_ind += strlen(build_time);
1383	tmp_ind += 1;
1384
1385	strcpy(git_ver, (char *)(cmd + tmp_ind));
1386	tmp_ind += strlen(git_ver);
1387	tmp_ind += 1;
1388
1389	strcpy(git_branch, (char *)(cmd + tmp_ind));
1390	tmp_ind += strlen(git_branch);
1391	tmp_ind += 1;
1392
1393	strcpy(build_name, (char *)(cmd + tmp_ind));
1394	tmp_ind += strlen(build_name);
1395	tmp_ind += 1;
1396	LOGD("sw_ver=%s, buildt=%s, gitv=%s, gitb=%s,bn=%s", sw_ver, build_time, git_ver, git_branch, build_name);
1397	return 0;
1398	}
1399
1400	int CFbcCommunication::cfbc_Set_FBC_Factory_SN(COMM_DEV_TYPE_E fromDev, const char *pSNval)
1401	{
1402	unsigned char cmd[512];
1403	int len = strlen(pSNval);
1404
1405	memset(cmd, 0, 512);
1406
1407	cmd[0] = CMD_SET_FACTORY_SN;
1408
1409	memcpy(cmd + 1, pSNval, len);
1410
1411	LOGD("cmd : %s\n", cmd);
1412
1413	return Fbc_Set_BatchValue(fromDev, cmd, len + 1);
1414	}
1415
1416	int CFbcCommunication::cfbc_Get_FBC_Factory_SN(COMM_DEV_TYPE_E fromDev, char FactorySN[])
1417	{
1418	int rx_len = 0;
1419	unsigned char cmd[512];
1420	memset(cmd, 0, 512);
1421	cmd[0] = CMD_GET_FACTORY_SN;
1422	rx_len = Fbc_Get_BatchValue(fromDev, cmd, 1);
1423	if (rx_len <= 0) {
1424	return -1;
1425	}
1426	strncpy(FactorySN, (char *)(cmd + 1), rx_len);
1427
1428	LOGD("panelModel=%s", FactorySN);
1429	return 0;
1430	}
1431
1432	int CFbcCommunication::cfbc_Get_FBC_Get_PANel_INFO(COMM_DEV_TYPE_E fromDev, char panel_model[])
1433	{
1434	int rx_len = 0;
1435	unsigned char cmd[512];
1436	memset(cmd, 0, 512);
1437	cmd[0] = CMD_DEVICE_ID;
1438	rx_len = Fbc_Get_BatchValue(fromDev, cmd, 1);
1439	if (rx_len <= 0) {
1440	return -1;
1441	}
1442	strcpy(panel_model, (char *)(cmd + 1));
1443
1444	LOGD("panelModel=%s", panel_model);
1445	return 0;
1446	}
1447
1448	int CFbcCommunication::cfbc_Set_FBC_panel_power_switch(COMM_DEV_TYPE_E fromDev, int switch_val)
1449	{
1450	unsigned char cmd[512];
1451
1452	memset(cmd, 0, 512);
1453
1454	cmd[0] = FBC_PANEL_POWER;
1455	cmd[1] = switch_val; //0 is fbc panel power off, 1 is panel power on.
1456
1457	return Fbc_Set_BatchValue(fromDev, cmd, 2);
1458	}
1459
1460	int CFbcCommunication::cfbc_Set_FBC_suspend(COMM_DEV_TYPE_E fromDev, int switch_val)
1461	{
1462	unsigned char cmd[512];
1463
1464	memset(cmd, 0, 512);
1465
1466	cmd[0] = FBC_SUSPEND_POWER;
1467	cmd[1] = switch_val; //0
1468
1469	return Fbc_Set_BatchValue(fromDev, cmd, 2);
1470	}
1471	int CFbcCommunication::cfbc_Set_FBC_User_Setting_Default(COMM_DEV_TYPE_E fromDev, int param)
1472	{
1473	unsigned char cmd[512];
1474
1475	memset(cmd, 0, 512);
1476
1477	cmd[0] = FBC_USER_SETTING_DEFAULT;
1478	cmd[1] = param; //0
1479
1480	return Fbc_Set_BatchValue(fromDev, cmd, 2);
1481	}
1482	int CFbcCommunication::cfbc_SendRebootToUpgradeCmd(COMM_DEV_TYPE_E fromDev, int value)
1483	{
1484	return Fbc_Set_Value_INT32(fromDev, FBC_REBOOT_UPGRADE, value);
1485	}
1486	int CFbcCommunication::cfbc_FBC_Send_Key_To_Fbc(COMM_DEV_TYPE_E fromDev, int keycode, int param)
1487	{
1488	unsigned char cmd[512];
1489
1490	memset(cmd, 0, 512);
1491
1492	cmd[0] = CMD_ACTIVE_KEY;
1493	cmd[1] = keycode; //0
1494
1495	return Fbc_Set_BatchValue(fromDev, cmd, 2);
1496	}
1497
1498	int CFbcCommunication::cfbc_Get_FBC_PANEL_REVERSE(COMM_DEV_TYPE_E fromDev, int *value)
1499	{
1500	unsigned char cmd[512];
1501	memset(cmd, 0, 512);
1502
1503	cmd[0] = CMD_PANEL_INFO;
1504	//0://panel reverse
1505	//1://panel output_mode
1506	//2://panel byte num
1507	cmd[1] = 0;
1508
1509	Fbc_Get_BatchValue(fromDev, cmd, 2);
1510	//cmd[0] cmdid-PANEL-INFO
1511	//cmd[1] param[0] - panel reverse
1512	*value = cmd[2];
1513
1514	return 0;
1515	}
1516
1517	int CFbcCommunication::cfbc_Get_FBC_PANEL_OUTPUT(COMM_DEV_TYPE_E fromDev, int *value)
1518	{
1519	unsigned char cmd[512];
1520	memset(cmd, 0, 512);
1521
1522	cmd[0] = CMD_PANEL_INFO;
1523	//0://panel reverse
1524	//1://panel output_mode
1525	//2://panel byte num
1526	cmd[1] = 1;
1527
1528	Fbc_Get_BatchValue(fromDev, cmd, 2);
1529	//cmd[0] cmdid-PANEL-INFO
1530	//cmd[1] param[0] - panel reverse
1531	*value = cmd[2];
1532
1533	return 0;
1534	}
1535
1536	int CFbcCommunication::cfbc_Set_FBC_project_id(COMM_DEV_TYPE_E fromDev, int prj_id)
1537	{
1538	unsigned char cmd[512];
1539
1540	memset(cmd, 0, 512);
1541
1542	cmd[0] = CMD_SET_PROJECT_SELECT;
1543	cmd[1] = prj_id;
1544
1545	return Fbc_Set_BatchValue(fromDev, cmd, 2);
1546	}
1547
1548	int CFbcCommunication::cfbc_Get_FBC_project_id(COMM_DEV_TYPE_E fromDev, int *prj_id)
1549	{
1550	return Fbc_Get_Value_INT8(fromDev, CMD_GET_PROJECT_SELECT, prj_id);
1551	}
1552
1553	int CFbcCommunication::cfbc_Set_Gamma(COMM_DEV_TYPE_E fromDev, unsigned char value)
1554	{
1555	unsigned char cmd[512];
1556	memset(cmd, 0, 512);
1557
1558	cmd[0] = VPU_CMD_ENABLE;
1559	cmd[1] = VPU_MODULE_GAMMA;
1560	cmd[2] = value;//value:0~1
1561
1562	return Fbc_Set_BatchValue(fromDev, cmd, 3);
1563	}
1564
1565	int CFbcCommunication::cfbc_Get_Gamma(COMM_DEV_TYPE_E fromDev, int *value)
1566	{
1567	unsigned char cmd[512];
1568	memset(cmd, 0, 512);
1569
1570	cmd[0] = VPU_CMD_ENABLE | 0x80;
1571	cmd[1] = VPU_MODULE_GAMMA;
1572
1573	Fbc_Get_BatchValue(fromDev, cmd, 2);
1574	*value = cmd[2];
1575
1576	return 0;
1577	}
1578
1579	int CFbcCommunication::cfbc_Set_VMute(COMM_DEV_TYPE_E fromDev, unsigned char value)
1580	{
1581	unsigned char cmd[512];
1582	memset(cmd, 0, 512);
1583
1584	cmd[0] = VPU_CMD_USER_VMUTE;
1585	cmd[1] = value;
1586	LOGD("cfbc_Set_VMute=%d", cmd[1]);
1587
1588	return Fbc_Set_BatchValue(fromDev, cmd, 2);
1589	}
1590	int CFbcCommunication::cfbc_Set_WhiteBalance_OnOff(COMM_DEV_TYPE_E fromDev, unsigned char value)
1591	{
1592	unsigned char cmd[512];
1593	memset(cmd, 0, 512);
1594
1595	cmd[0] = VPU_CMD_ENABLE;
1596	cmd[1] = VPU_MODULE_WB;
1597	cmd[2] = value;//value:0~1
1598
1599	return Fbc_Set_BatchValue(fromDev, cmd, 3);
1600	}
1601
1602	int CFbcCommunication::cfbc_Get_WhiteBalance_OnOff(COMM_DEV_TYPE_E fromDev, int *value)
1603	{
1604	unsigned char cmd[512];
1605	memset(cmd, 0, 512);
1606
1607	cmd[0] = VPU_CMD_ENABLE | 0x80;
1608	cmd[1] = VPU_MODULE_WB;
1609
1610	Fbc_Get_BatchValue(fromDev, cmd, 2);
1611	*value = cmd[2];
1612
1613	return 0;
1614	}
1615
1616	int CFbcCommunication::cfbc_Set_WB_Batch(COMM_DEV_TYPE_E fromDev, unsigned char mode, unsigned char r_gain, unsigned char g_gain, unsigned char b_gain, unsigned char r_offset, unsigned char g_offset, unsigned char b_offset)
1617	{
1618	unsigned char cmd[512];
1619	memset(cmd, 0, 512);
1620
1621	cmd[0] = VPU_CMD_WB_VALUE;
1622	cmd[1] = mode;
1623	cmd[2] = r_gain;
1624	cmd[3] = g_gain;
1625	cmd[4] = b_gain;
1626	cmd[5] = r_offset;
1627	cmd[6] = g_offset;
1628	cmd[7] = b_offset;
1629
1630	return Fbc_Set_BatchValue(fromDev, cmd, 8);
1631	}
1632
1633	int CFbcCommunication::cfbc_TestPattern_Select(COMM_DEV_TYPE_E fromDev, int value)
1634	{
1635	int ret = -1;
1636	unsigned char cmd[512];
1637	memset(cmd, 0, 512);
1638
1639	LOGD("Call vpp 63 2 1\n");
1640	cmd[0] = VPU_CMD_SRCIF;
1641	cmd[1] = 2;
1642	cmd[2] = 1;
1643
1644	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);//close csc0
1645
1646	if (ret == 0) {
1647	LOGD("Call vpp 9 11 1\n");
1648	memset(cmd, 0, 512);
1649	cmd[0] = VPU_CMD_ENABLE;
1650	cmd[1] = 11;
1651	cmd[2] = 1;
1652	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);
1653	if (ret == 0) {
1654	memset(cmd, 0, 512);
1655	LOGD("Call vpp 42 1-17\n");
1656	Fbc_Set_Value_INT8(fromDev, VPU_CMD_PATTEN_SEL, value);
1657	}
1658	}
1659
1660	return ret;
1661	}
1662	int CFbcCommunication::cfbc_WhiteBalance_GrayPattern_OnOff(COMM_DEV_TYPE_E fromDev, int onOff)
1663	{
1664	int ret = -1;
1665	unsigned char cmd[512];
1666	memset(cmd, 0, 512);
1667	if (onOff == 0) { //On
1668	LOGD("Call vpp 63 2 1");
1669	cmd[0] = VPU_CMD_SRCIF;
1670	cmd[1] = 2;
1671	cmd[2] = 1;
1672	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);//close csc0
1673	if (ret == 0) {
1674	LOGD("Call vpp 9 9 0");
1675	cmd[0] = VPU_CMD_ENABLE;
1676	cmd[1] = 9;
1677	cmd[2] = 0;
1678	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);//close csc1
1679	if (ret == 0) {
1680	LOGD("Call vpp 9 10 0");
1681	cmd[0] = VPU_CMD_ENABLE;
1682	cmd[1] = 10;
1683	cmd[2] = 0;
1684	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);//close dnlp
1685	if (ret == 0) {
1686	LOGD("Call vpp 9 8 0");
1687	cmd[0] = VPU_CMD_ENABLE;
1688	cmd[1] = 8;
1689	cmd[2] = 0;
1690	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);//close cm
1691	}
1692	}
1693	}
1694
1695	} else { //Off
1696	LOGD("Call vpp 63 2 2");
1697	cmd[0] = VPU_CMD_SRCIF;
1698	cmd[1] = 2;
1699	cmd[2] = 2;
1700	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);
1701	if (ret == 0) {
1702	LOGD("Call vpp 9 9 1");
1703	cmd[0] = VPU_CMD_ENABLE;
1704	cmd[1] = 9;
1705	cmd[2] = 1;
1706	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);//open csc1
1707	if (ret == 0) {
1708	LOGD("Call vpp 9 10 1");
1709	cmd[0] = VPU_CMD_ENABLE;
1710	cmd[1] = 10;
1711	cmd[2] = 1;
1712	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);//open dnlp
1713	if (ret == 0) {
1714	LOGD("Call vpp 9 8 1");
1715	cmd[0] = VPU_CMD_ENABLE;
1716	cmd[1] = 8;
1717	cmd[2] = 1;
1718	ret = Fbc_Set_BatchValue(fromDev, cmd, 3);//open cm
1719	}
1720	}
1721	}
1722	}
1723	return ret;
1724	}
1725
1726	int CFbcCommunication::cfbc_WhiteBalance_SetGrayPattern(COMM_DEV_TYPE_E fromDev, unsigned char value)
1727	{
1728	int ret = -1;
1729	unsigned char cmd[512];
1730	memset(cmd, 0, 512);
1731	cmd[0] = VPU_CMD_GRAY_PATTERN;
1732	cmd[1] = value;
1733	cmd[2] = value;
1734	cmd[3] = value;
1735	ret = Fbc_Set_BatchValue(fromDev, cmd, 4);
1736	return ret;
1737	}
1738
1739	int CFbcCommunication::cfbc_Set_Auto_Backlight_OnOff(COMM_DEV_TYPE_E fromDev, unsigned char value)
1740	{
1741	unsigned char cmd[512];
1742	memset(cmd, 0, 512);
1743
1744	cmd[0] = CMD_SET_AUTO_BACKLIGHT_ONFF;
1745	cmd[1] = value;
1746	LOGD("cfbc_Set_naturelight_onoff\n");
1747	return Fbc_Set_BatchValue(fromDev, cmd, 2);
1748	}
1749
1750	int CFbcCommunication::cfbc_Get_Auto_Backlight_OnOff(COMM_DEV_TYPE_E fromDev, int *value)
1751	{
1752	LOGD("cfbc_get_naturelight_onoff\n");
1753	return Fbc_Get_Value_INT8(fromDev, CMD_GET_AUTO_BACKLIGHT_ONFF, value);
1754	}
1755	int CFbcCommunication::cfbc_Get_WB_Batch(COMM_DEV_TYPE_E fromDev, unsigned char mode, unsigned char *r_gain, unsigned char *g_gain, unsigned char *b_gain, unsigned char *r_offset, unsigned char *g_offset, unsigned char *b_offset)
1756	{
1757	unsigned char cmd[512];
1758	memset(cmd, 0, 512);
1759
1760	cmd[0] = VPU_CMD_WB_VALUE | 0x80;
1761	cmd[1] = mode;
1762
1763	Fbc_Get_BatchValue(fromDev, cmd, 2);
1764	//*mode = cmd[1];
1765	*r_gain = cmd[2];
1766	*g_gain = cmd[3];
1767	*b_gain = cmd[4];
1768	*r_offset = cmd[5];
1769	*g_offset = cmd[6];
1770	*b_offset = cmd[7];
1771
1772	return 0;
1773	}
1774
1775	int CFbcCommunication::cfbc_Set_backlight_onoff(COMM_DEV_TYPE_E fromDev, int value)
1776	{
1777	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_BACKLIGHT_EN, value);
1778	}
1779
1780	int CFbcCommunication::cfbc_Get_backlight_onoff(COMM_DEV_TYPE_E fromDev, int *value)
1781	{
1782	return Fbc_Get_Value_INT8(fromDev, VPU_CMD_BACKLIGHT_EN, value);
1783	}
1784
1785	int CFbcCommunication::cfbc_Set_LVDS_SSG_Set(COMM_DEV_TYPE_E fromDev, int value)
1786	{
1787	return Fbc_Set_Value_INT8(fromDev, CMD_LVDS_SSG_SET, value);
1788	}
1789
1790	int CFbcCommunication::cfbc_Set_AUTO_ELEC_MODE(COMM_DEV_TYPE_E fromDev, int value)
1791	{
1792	LOGD("%s cmd =0x%x, value=%d~~~~~~~~", __FUNCTION__, VPU_CMD_SET_ELEC_MODE, value);
1793	return Fbc_Set_Value_INT8(fromDev, VPU_CMD_SET_ELEC_MODE, value);
1794	}
1795
1796	int CFbcCommunication::cfbc_Get_AUTO_ELEC_MODE(COMM_DEV_TYPE_E fromDev, int *value)
1797	{
1798	return 0;
1799	}
1800
1801	int CFbcCommunication::cfbc_Set_Thermal_state(COMM_DEV_TYPE_E fromDev, int value)
1802	{
1803	LOGD("%s cmd =0x%x, data%d ~~~~~~~~~\n", __FUNCTION__, CMD_HDMI_STAT, value);
1804	//return Fbc_Set_Value_INT8(fromDev, CMD_HDMI_STAT, value);
1805	return Fbc_Set_Value_INT32(fromDev, CMD_HDMI_STAT, value);
1806	}
1807
1808	int CFbcCommunication::cfbc_Set_LightSensor_N310(COMM_DEV_TYPE_E fromDev, int value)
1809	{
1810	return Fbc_Set_Value_INT8(fromDev, 0x84, value);
1811	// return Fbc_Set_Value_INT8(fromDev, CMD_LIGHT_SENSOR, value);
1812	}
1813
1814	int CFbcCommunication::cfbc_Get_LightSensor_N310(COMM_DEV_TYPE_E fromDev, int *value)
1815	{
1816	// return Fbc_Get_Value_INT8(fromDev, CMD_LIGHT_SENSOR|0x80, value);
1817	return 0;
1818	}
1819
1820	int CFbcCommunication::cfbc_Set_Dream_Panel_N310(COMM_DEV_TYPE_E fromDev, int value)
1821	{
1822	return Fbc_Set_Value_INT8(fromDev, 0x83, value);
1823	// return Fbc_Set_Value_INT8(fromDev, CMD_DREAM_PANEL, value);
1824	}
1825
1826	int CFbcCommunication::cfbc_Get_Dream_Panel_N310(COMM_DEV_TYPE_E fromDev, int *value)
1827	{
1828	// return Fbc_Get_Value_INT8(fromDev, CMD_DREAM_PANEL|0x80, value);
1829	return 0;
1830	}
1831
1832	int CFbcCommunication::cfbc_Set_MULT_PQ_N310(COMM_DEV_TYPE_E fromDev, int value)
1833	{
1834	return Fbc_Set_Value_INT8(fromDev, 0x81, value);
1835	// return Fbc_Set_Value_INT8(fromDev, CMD_MUTI_PQ, value);
1836	}
1837
1838	int CFbcCommunication::cfbc_Get_MULT_PQ_N310(COMM_DEV_TYPE_E fromDev, int *value)
1839	{
1840	// return Fbc_Get_Value_INT8(fromDev, CMD_MUTI_PQ|0x80, value);
1841	return 0;
1842	}
1843
1844	int CFbcCommunication::cfbc_Set_MEMC_N310(COMM_DEV_TYPE_E fromDev, int value)
1845	{
1846	return Fbc_Set_Value_INT8(fromDev, 0x82, value);
1847	// return Fbc_Set_Value_INT8(fromDev, CMD_MEMC, value);
1848	}
1849
1850	int CFbcCommunication::cfbc_Get_MEMC_N310(COMM_DEV_TYPE_E fromDev, int *value)
1851	{
1852	// return Fbc_Get_Value_INT8(fromDev, CMD_MEMC|0x80, value);
1853	return 0;
1854	}
1855	int CFbcCommunication::cfbc_Set_Bluetooth_IIS_onoff(COMM_DEV_TYPE_E fromDev, int value)
1856	{
1857	return Fbc_Set_Value_INT8(fromDev, CMD_BLUETOOTH_I2S_STATUS, value);
1858	}
1859
1860	int CFbcCommunication::cfbc_Get_Bluetooth_IIS_onoff(COMM_DEV_TYPE_E fromDev, int *value)
1861	{
1862	return Fbc_Get_Value_INT8(fromDev, CMD_BLUETOOTH_I2S_STATUS | 0x80, value);
1863	}
1864	int CFbcCommunication::cfbc_Set_Led_onoff(COMM_DEV_TYPE_E fromDev, int val_1, int val_2, int val_3)
1865	{
1866	unsigned char cmd[512];
1867	memset(cmd, 0, 512);
1868
1869	cmd[0] = CMD_SET_LED_MODE;
1870	cmd[1] = val_1;
1871	cmd[2] = val_2;
1872	cmd[3] = val_3;
1873
1874	return Fbc_Set_BatchValue(fromDev, cmd, 4);
1875	}
1876	int CFbcCommunication::cfbc_Set_LockN_state(COMM_DEV_TYPE_E fromDev, int value)
1877	{
1878	LOGD("%s cmd =0x%x, data%d ~~~~~~~~~\n", __FUNCTION__, CMD_SET_LOCKN_DISABLE, value);
1879	return Fbc_Set_Value_INT8(fromDev, CMD_SET_LOCKN_DISABLE, value);
1880	}
1881
1882	int CFbcCommunication::cfbc_SET_SPLIT_SCREEN_DEMO(COMM_DEV_TYPE_E fromDev, int value)
1883	{
1884	LOGD("%s,cmd[%#x], data[%d]\n", __FUNCTION__, CMD_SET_SPLIT_SCREEN_DEMO, value);
1885	return Fbc_Set_Value_INT8(fromDev, CMD_SET_SPLIT_SCREEN_DEMO, value);
1886	}
1887
1888	int CFbcCommunication::cfbc_Set_AP_STANDBY_N310(COMM_DEV_TYPE_E fromDev, int value)
1889	{
1890	return Fbc_Set_Value_INT8(fromDev, CMD_PANEL_ON_OFF, value);
1891	// return 0;
1892	}
1893
1894	int CFbcCommunication::cfbc_Get_AP_STANDBY_N310(COMM_DEV_TYPE_E fromDev, int *value)
1895	{
1896	return Fbc_Get_Value_INT8(fromDev, CMD_PANEL_ON_OFF | 0x80, value);
1897	// return 0;
1898	}
1899	int CFbcCommunication::cfbc_Set_Fbc_Uboot_Stage(COMM_DEV_TYPE_E fromDev, int value)
1900	{
1901	return Fbc_Set_Value_INT8(fromDev, CMD_SET_UBOOT_STAGE, value);
1902	}
1903
1904	void CFbcCommunication::CFbcMsgQueue::handleMessage ( CMessage &msg )
1905	{
1906	LOGD ( "%s, CFbcCommunication::CFbcMsgQueue::handleMessage type = %d", __FUNCTION__, msg.mType );
1907
1908	switch ( msg.mType ) {
1909	case TV_MSG_COMMON:
1910	break;
1911
1912	case TV_MSG_SEND_KEY: {
1913	LOGD("CFbcMsgQueue msg type = %d", msg.mType);
1914	//CFbcCommunication *pFbc = ( CFbcCommunication * ) ( msg.mpData );
1915	//pFbc->mTvInput.sendkeyCode_Down(4);
1916	//pFbc->mbDownHaveSend = 1;//true
1917	break;
1918	}
1919
1920	default:
1921	break;
1922	}
1923	}
1924