path: root/tvapi/libtv/tv/CFbcCommunication.cpp (plain)
blob: 8ca5391c168f2c2b4f92d269de88ca1557ac921f

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