summaryrefslogtreecommitdiff
path: root/tvapi/libtv/tv/CUpgradeFBC.cpp (plain)
blob: 6847a551d9e6b13db3762b4ce16701ca9f0b9103
1#define LOG_TAG "CUpgradeFBC"
2
3#include <CTvLog.h>
4#include <stdio.h>
5#include <stdlib.h>
6#include <unistd.h>
7#include <sys/prctl.h>
8#include <fcntl.h>
9#include <errno.h>
10
11#include <cutils/log.h>
12
13#include "CUpgradeFBC.h"
14
15CUpgradeFBC::CUpgradeFBC()
16{
17 mUpgradeMode = CC_UPGRADE_MODE_MAIN;
18 mFileName[0] = 0;
19
20 mOPTotalSize = 0;
21 mBinFileSize = 0;
22 mBinFileBuf = NULL;
23 mUpgradeBlockSize = 0x10000;
24
25 mpObserver = NULL;
26 mState = STATE_STOPED;
27 mCfbcIns = GetSingletonFBC();
28 mCfbcIns->SetUpgradeFlag(0);
29}
30
31CUpgradeFBC::~CUpgradeFBC()
32{
33 if (mBinFileBuf != NULL) {
34 delete mBinFileBuf;
35 mBinFileBuf = NULL;
36 }
37}
38
39int CUpgradeFBC::start()
40{
41 if (mState == STATE_STOPED || mState == STATE_ABORT || mState == STATE_FINISHED) {
42 mCfbcIns->SetUpgradeFlag(1);
43
44 this->run();
45 }
46
47 return 0;
48}
49
50int CUpgradeFBC::stop()
51{
52 requestExit();
53 mState = STATE_STOPED;
54
55 return 0;
56}
57
58int CUpgradeFBC::GetUpgradeFBCProgress()
59{
60 return 0;
61}
62
63int CUpgradeFBC::SetUpgradeFileName(char *file_name)
64{
65 if (file_name == NULL) {
66 return -1;
67 }
68
69 strcpy(mFileName, file_name);
70
71 return 0;
72}
73
74int CUpgradeFBC::SetUpgradeFileSize(int file_size)
75{
76 mBinFileSize = file_size;
77 return 0;
78}
79
80int CUpgradeFBC::SetUpgradeBlockSize(int block_size)
81{
82 mUpgradeBlockSize = block_size;
83 return 0;
84}
85
86int CUpgradeFBC::SetUpgradeMode(int mode)
87{
88 int tmp_val = 0;
89
90 tmp_val = mUpgradeMode;
91 mUpgradeMode = mode;
92
93 return tmp_val;
94}
95
96int CUpgradeFBC::AddCRCToDataBuf(unsigned char data_buf[], int data_len)
97{
98 unsigned int tmp_crc = 0;
99
100 tmp_crc = mCfbcIns->Calcrc32(0, data_buf, data_len);
101 data_buf[data_len + 0] = (tmp_crc >> 0) & 0xFF;
102 data_buf[data_len + 1] = (tmp_crc >> 8) & 0xFF;
103 data_buf[data_len + 2] = (tmp_crc >> 16) & 0xFF;
104 data_buf[data_len + 3] = (tmp_crc >> 24) & 0xFF;
105
106 return 0;
107}
108
109bool CUpgradeFBC::threadLoop()
110{
111 int file_handle = -1;
112 int i = 0, tmp_flag = 0, cmd_len = 0, tmp_prog = 0, total_item = 0;
113 int start_off = 0, end_off = 0, cur_off = 0, old_off = 0, rw_size = 0;
114 int upgrade_version = 0, upgrade_flag = 0, upgrade_err_code = 0, upgrade_try_cnt = 0;
115 int upgrade_pq_wb_flag = 0;
116 unsigned char tmp_buf[128] = {0};
117
118 if (mpObserver == NULL) {
119 return false;
120 }
121
122 LOGD("%s, entering...\n", "TV");
123
124 prctl(PR_SET_NAME, (unsigned long)"CUpgradeFBC thread loop");
125
126 mState = STATE_RUNNING;
127
128 LOGD("%s, upgrade mode = %d\n", __FUNCTION__, mUpgradeMode);
129 if (mUpgradeMode != CC_UPGRADE_MODE_BOOT_MAIN && mUpgradeMode != CC_UPGRADE_MODE_BOOT &&
130 mUpgradeMode != CC_UPGRADE_MODE_MAIN && mUpgradeMode != CC_UPGRADE_MODE_COMPACT_BOOT &&
131 mUpgradeMode != CC_UPGRADE_MODE_ALL && mUpgradeMode != CC_UPGRADE_MODE_MAIN_PQ_WB &&
132 mUpgradeMode != CC_UPGRADE_MODE_ALL_PQ_WB && mUpgradeMode != CC_UPGRADE_MODE_MAIN_WB &&
133 mUpgradeMode != CC_UPGRADE_MODE_ALL_WB && mUpgradeMode != CC_UPGRADE_MODE_MAIN_PQ &&
134 mUpgradeMode != CC_UPGRADE_MODE_ALL_PQ && mUpgradeMode != CC_UPGRADE_MODE_PQ_WB_ONLY &&
135 mUpgradeMode != CC_UPGRADE_MODE_WB_ONLY && mUpgradeMode != CC_UPGRADE_MODE_PQ_ONLY &&
136 mUpgradeMode != CC_UPGRADE_MODE_CUR_PQ_BIN && mUpgradeMode != CC_UPGRADE_MODE_BURN &&
137 mUpgradeMode != CC_UPGRADE_MODE_DUMMY) {
138 mState = STATE_ABORT;
139 upgrade_err_code = ERR_NOT_SUPPORT_UPGRADE_MDOE;
140 mpObserver->onUpgradeStatus(mState, upgrade_err_code);
141 mCfbcIns->SetUpgradeFlag(0);
142
143 return false;
144 }
145
146 if (mUpgradeBlockSize % 0x1000 != 0) {
147 mState = STATE_ABORT;
148 upgrade_err_code = ERR_NOT_CORRECT_UPGRADE_BLKSIZE;
149 mpObserver->onUpgradeStatus(mState, upgrade_err_code);
150 mCfbcIns->SetUpgradeFlag(0);
151
152 return false;
153 }
154
155 struct stat tmp_st;
156 stat(mFileName, &tmp_st);
157 if (tmp_st.st_size == CC_FBC_V01_FILE_SIZE) {
158 upgrade_version = CC_FBC_V01_00_VAL;
159 mOPTotalSize = CC_UPGRADE_V01_ALL_LENGTH;
160 mBinFileSize = CC_FBC_V01_FILE_SIZE;
161 } else if (tmp_st.st_size == CC_FBC_V02_FILE_SIZE) {
162 upgrade_version = CC_FBC_V02_00_VAL;
163 mOPTotalSize = CC_UPGRADE_V02_ALL_LENGTH;
164 mBinFileSize = CC_FBC_V02_FILE_SIZE;
165 } else if (tmp_st.st_size == CC_FBC_V02_CUR_PQ_BIN_FILE_SIZE) {
166 upgrade_version = CC_FBC_V02_01_VAL;
167 mOPTotalSize = CC_UPGRADE_V02_ALL_LENGTH;
168 mBinFileSize = CC_FBC_V02_CUR_PQ_BIN_FILE_SIZE;
169 } else if (tmp_st.st_size == CC_FBC_V03_FILE_SIZE) {
170 upgrade_version = CC_FBC_V03_00_VAL;
171 mOPTotalSize = CC_UPGRADE_V03_ALL_LENGTH;
172 mBinFileSize = CC_FBC_V03_FILE_SIZE;
173 } else if (tmp_st.st_size == CC_FBC_V03_CUR_PQ_BIN_FILE_SIZE) {
174 upgrade_version = CC_FBC_V03_01_VAL;
175 mOPTotalSize = CC_UPGRADE_V03_ALL_LENGTH;
176 mBinFileSize = CC_FBC_V03_CUR_PQ_BIN_FILE_SIZE;
177 } else {
178 upgrade_version = 0;
179 mOPTotalSize = 0;
180 mBinFileSize = 0;
181 mState = STATE_ABORT;
182 upgrade_err_code = ERR_BIN_FILE_SIZE;
183 mpObserver->onUpgradeStatus(mState, upgrade_err_code);
184 mCfbcIns->SetUpgradeFlag(0);
185 return false;
186 }
187
188 //open upgrade source file and read it to temp buffer.
189 file_handle = open(mFileName, O_RDONLY);
190 if (file_handle < 0) {
191 LOGE("%s, Can't Open file %s\n", __FUNCTION__, mFileName);
192 mState = STATE_ABORT;
193 upgrade_err_code = ERR_OPEN_BIN_FILE;
194 mpObserver->onUpgradeStatus(mState, upgrade_err_code);
195 mCfbcIns->SetUpgradeFlag(0);
196 return false;
197 }
198
199 lseek(file_handle, 0, SEEK_SET);
200
201 mBinFileBuf = new unsigned char[mOPTotalSize];
202
203 memset(mBinFileBuf, 0, mOPTotalSize);
204 rw_size = read(file_handle, mBinFileBuf, mBinFileSize);
205 if (rw_size != mBinFileSize || rw_size <= 0) {
206 LOGE("%s, read file %s error(%d, %d)\n", __FUNCTION__, mFileName, mBinFileSize, rw_size);
207 mState = STATE_ABORT;
208 upgrade_err_code = ERR_READ_BIN_FILE;
209 mpObserver->onUpgradeStatus(mState, upgrade_err_code);
210 mCfbcIns->SetUpgradeFlag(0);
211
212 if (mBinFileBuf != NULL) {
213 delete mBinFileBuf;
214 mBinFileBuf = NULL;
215 }
216 return false;
217 }
218
219 close(file_handle);
220 file_handle = -1;
221
222 if (upgrade_version == CC_FBC_V02_00_VAL) {
223 memcpy((void *)(mBinFileBuf + CC_UPGRADE_V02_BOOT_BAK_OFFSET), (void *)(mBinFileBuf + CC_UPGRADE_V02_BOOT_OFFSET), CC_UPGRADE_V02_BOOT_LEN);
224 memcpy((void *)(mBinFileBuf + CC_UPGRADE_V02_MAIN_BAK_OFFSET), (void *)(mBinFileBuf + CC_UPGRADE_V02_MAIN_OFFSET), CC_UPGRADE_V02_MAIN_LEN);
225 } else if (upgrade_version == CC_FBC_V02_01_VAL) {
226 memcpy((void *)(mBinFileBuf + CC_UPGRADE_V02_CUR_PQ_OFFSET), (void *)(mBinFileBuf + 0), CC_FBC_V02_CUR_PQ_BIN_FILE_SIZE);
227 } else if (upgrade_version == CC_FBC_V03_01_VAL) {
228 memcpy((void *)(mBinFileBuf + CC_UPGRADE_V03_CUR_PQ_OFFSET), (void *)(mBinFileBuf + 0), CC_FBC_V03_CUR_PQ_BIN_FILE_SIZE);
229 }
230
231 //calculate start addr
232 if (upgrade_version == CC_FBC_V01_00_VAL) {
233 start_off = CC_UPGRADE_V01_MAIN_OFFSET;
234 end_off = 0;
235 if (mUpgradeMode == CC_UPGRADE_MODE_ALL || mUpgradeMode == CC_UPGRADE_MODE_BOOT_MAIN) {
236 start_off = CC_UPGRADE_V01_BOOT_OFFSET;
237 end_off = CC_UPGRADE_V01_BOOT_OFFSET + CC_UPGRADE_V01_ALL_LENGTH;
238 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
239 } else if (mUpgradeMode == CC_UPGRADE_MODE_BOOT) {
240 start_off = CC_UPGRADE_V01_BOOT_OFFSET;
241 end_off = CC_UPGRADE_V01_BOOT_OFFSET + CC_UPGRADE_V01_BOOT_LEN;
242 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
243 } else if (mUpgradeMode == CC_UPGRADE_MODE_MAIN) {
244 start_off = CC_UPGRADE_V01_MAIN_OFFSET;
245 end_off = CC_UPGRADE_V01_MAIN_OFFSET + CC_UPGRADE_V01_MAIN_LEN;
246 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
247 }
248 } else if (upgrade_version == CC_FBC_V02_00_VAL) {
249 start_off = CC_UPGRADE_V02_MAIN_OFFSET;
250 end_off = 0;
251 if (mUpgradeMode == CC_UPGRADE_MODE_ALL || mUpgradeMode == CC_UPGRADE_MODE_ALL_PQ_WB ||
252 mUpgradeMode == CC_UPGRADE_MODE_ALL_WB || mUpgradeMode == CC_UPGRADE_MODE_ALL_PQ) {
253 start_off = CC_UPGRADE_V02_COMPACT_BOOT_OFFSET;
254 end_off = CC_UPGRADE_V02_COMPACT_BOOT_OFFSET + CC_UPGRADE_V02_ALL_LENGTH;
255 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
256 } else if (mUpgradeMode == CC_UPGRADE_MODE_BOOT) {
257 start_off = CC_UPGRADE_V02_BOOT_OFFSET;
258 end_off = CC_UPGRADE_V02_BOOT_OFFSET + CC_UPGRADE_V02_BOOT_LEN;
259 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
260 } else if (mUpgradeMode == CC_UPGRADE_MODE_MAIN || mUpgradeMode == CC_UPGRADE_MODE_MAIN_PQ_WB ||
261 mUpgradeMode == CC_UPGRADE_MODE_MAIN_WB || mUpgradeMode == CC_UPGRADE_MODE_MAIN_PQ ) {
262 start_off = CC_UPGRADE_V02_MAIN_OFFSET;
263 end_off = CC_UPGRADE_V02_MAIN_OFFSET + CC_UPGRADE_V02_MAIN_LEN;
264 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
265 } else if (mUpgradeMode == CC_UPGRADE_MODE_COMPACT_BOOT) {
266 start_off = CC_UPGRADE_V02_COMPACT_BOOT_OFFSET;
267 end_off = CC_UPGRADE_V02_COMPACT_BOOT_OFFSET + CC_UPGRADE_V02_COMPACT_BOOT_LEN;
268 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
269 } else if (mUpgradeMode == CC_UPGRADE_MODE_BOOT_MAIN) {
270 start_off = CC_UPGRADE_V02_BOOT_OFFSET;
271 end_off = CC_UPGRADE_V02_BOOT_OFFSET + CC_UPGRADE_V02_BOOT_LEN + CC_UPGRADE_V02_MAIN_LEN;
272 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
273 }
274 } else if (upgrade_version == CC_FBC_V02_01_VAL) {
275 start_off = CC_UPGRADE_V02_CUR_PQ_OFFSET;
276 end_off = 0;
277 if (mUpgradeMode == CC_UPGRADE_MODE_CUR_PQ_BIN) {
278 start_off = CC_UPGRADE_V02_CUR_PQ_OFFSET;
279 end_off = CC_UPGRADE_V02_CUR_PQ_OFFSET + CC_FBC_V02_CUR_PQ_BIN_FILE_SIZE;
280 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
281 }
282 } else if (upgrade_version == CC_FBC_V03_00_VAL) {
283 start_off = CC_UPGRADE_V03_MAIN_OFFSET;
284 end_off = 0;
285 if (mUpgradeMode == CC_UPGRADE_MODE_ALL || mUpgradeMode == CC_UPGRADE_MODE_ALL_PQ_WB ||
286 mUpgradeMode == CC_UPGRADE_MODE_ALL_WB || mUpgradeMode == CC_UPGRADE_MODE_ALL_PQ) {
287 start_off = CC_UPGRADE_V03_COMPACT_BOOT_OFFSET;
288 end_off = CC_UPGRADE_V03_COMPACT_BOOT_OFFSET + CC_UPGRADE_V03_ALL_LENGTH;
289 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
290 } else if (mUpgradeMode == CC_UPGRADE_MODE_BOOT) {
291 start_off = CC_UPGRADE_V03_BOOT_OFFSET;
292 end_off = CC_UPGRADE_V03_BOOT_OFFSET + CC_UPGRADE_V03_BOOT_LEN;
293 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
294 } else if (mUpgradeMode == CC_UPGRADE_MODE_MAIN || mUpgradeMode == CC_UPGRADE_MODE_MAIN_PQ_WB ||
295 mUpgradeMode == CC_UPGRADE_MODE_MAIN_WB || mUpgradeMode == CC_UPGRADE_MODE_MAIN_PQ ) {
296 start_off = CC_UPGRADE_V03_MAIN_OFFSET;
297 end_off = CC_UPGRADE_V03_MAIN_OFFSET + CC_UPGRADE_V03_MAIN_LEN;
298 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
299 } else if (mUpgradeMode == CC_UPGRADE_MODE_COMPACT_BOOT) {
300 start_off = CC_UPGRADE_V03_COMPACT_BOOT_OFFSET;
301 end_off = CC_UPGRADE_V03_COMPACT_BOOT_OFFSET + CC_UPGRADE_V03_COMPACT_BOOT_LEN;
302 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
303 } else if (mUpgradeMode == CC_UPGRADE_MODE_BOOT_MAIN) {
304 start_off = CC_UPGRADE_V03_BOOT_OFFSET;
305 end_off = CC_UPGRADE_V03_BOOT_OFFSET + CC_UPGRADE_V03_BOOT_LEN + CC_UPGRADE_V03_MAIN_LEN;
306 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
307 } else if (mUpgradeMode == CC_UPGRADE_MODE_BURN) {
308 start_off = CC_UPGRADE_V03_COMPACT_BOOT_OFFSET;
309 end_off = CC_UPGRADE_V03_COMPACT_BOOT_OFFSET + CC_FBC_V03_FILE_SIZE;
310 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
311 }
312 } else if (upgrade_version == CC_FBC_V03_01_VAL) {
313 start_off = CC_UPGRADE_V03_CUR_PQ_OFFSET;
314 end_off = 0;
315 if (mUpgradeMode == CC_UPGRADE_MODE_CUR_PQ_BIN) {
316 start_off = CC_UPGRADE_V03_CUR_PQ_OFFSET;
317 end_off = CC_UPGRADE_V03_CUR_PQ_OFFSET + CC_FBC_V03_CUR_PQ_BIN_FILE_SIZE;
318 total_item = (end_off - start_off) / mUpgradeBlockSize + 2;
319 }
320 }
321
322 //let's try set default pq & wb
323 if (upgrade_version == CC_FBC_V02_00_VAL || upgrade_version == CC_FBC_V03_00_VAL) {
324 if (mUpgradeMode == CC_UPGRADE_MODE_ALL_PQ_WB || mUpgradeMode == CC_UPGRADE_MODE_MAIN_PQ_WB ||
325 mUpgradeMode == CC_UPGRADE_MODE_PQ_WB_ONLY) {
326 mDataBuf[6] = 3;
327 upgrade_pq_wb_flag = 1;
328 } else if (mUpgradeMode == CC_UPGRADE_MODE_MAIN_WB || mUpgradeMode == CC_UPGRADE_MODE_ALL_WB ||
329 mUpgradeMode == CC_UPGRADE_MODE_WB_ONLY) {
330 mDataBuf[6] = 2;
331 upgrade_pq_wb_flag = 1;
332 } else if (mUpgradeMode == CC_UPGRADE_MODE_MAIN_PQ || mUpgradeMode == CC_UPGRADE_MODE_ALL_PQ ||
333 mUpgradeMode == CC_UPGRADE_MODE_PQ_ONLY) {
334 mDataBuf[6] = 1;
335 upgrade_pq_wb_flag = 1;
336 } else {
337 upgrade_pq_wb_flag = 0;
338 }
339
340 if (upgrade_pq_wb_flag == 1) {
341 cmd_len = 7;
342 mDataBuf[0] = 0x5A;
343 mDataBuf[1] = 0x5A;
344 mDataBuf[2] = cmd_len + 4;
345 mDataBuf[3] = 0x00;
346 mDataBuf[4] = 0x00;
347 mDataBuf[5] = CMD_CLR_SETTINGS_DEFAULT;
348
349 AddCRCToDataBuf(mDataBuf, cmd_len);
350 if (mCfbcIns->sendDataOneway(COMM_DEV_SERIAL, mDataBuf, cmd_len + 4, 0) <= 0) {
351 mState = STATE_ABORT;
352 upgrade_err_code = ERR_SERIAL_CONNECT;
353 mpObserver->onUpgradeStatus(mState, upgrade_err_code);
354 mCfbcIns->SetUpgradeFlag(0);
355
356 if (mBinFileBuf != NULL) {
357 delete mBinFileBuf;
358 mBinFileBuf = NULL;
359 }
360 return false;
361 }
362
363 usleep(3000 * 1000);
364
365 if (mUpgradeMode == CC_UPGRADE_MODE_PQ_WB_ONLY || mUpgradeMode == CC_UPGRADE_MODE_WB_ONLY ||
366 mUpgradeMode == CC_UPGRADE_MODE_PQ_ONLY) {
367 system("reboot");
368 return false;
369 }
370 }
371 }
372
373 //send upgrade command
374 cmd_len = 10;
375 mDataBuf[0] = 0x5A;
376 mDataBuf[1] = 0x5A;
377 mDataBuf[2] = cmd_len + 4;
378 mDataBuf[3] = 0x00;
379 mDataBuf[4] = 0x00;
380 mDataBuf[5] = 0x01;
381 mDataBuf[6] = 0x88;
382 mDataBuf[7] = 0x88;
383 mDataBuf[8] = 0x88;
384 mDataBuf[9] = 0x88;
385 AddCRCToDataBuf(mDataBuf, cmd_len);
386 if (mCfbcIns->sendDataOneway(COMM_DEV_SERIAL, mDataBuf, cmd_len + 4, 0) <= 0) {
387 mState = STATE_ABORT;
388 upgrade_err_code = ERR_SERIAL_CONNECT;
389 mpObserver->onUpgradeStatus(mState, upgrade_err_code);
390 mCfbcIns->SetUpgradeFlag(0);
391
392 if (mBinFileBuf != NULL) {
393 delete mBinFileBuf;
394 mBinFileBuf = NULL;
395 }
396 return false;
397 }
398
399 //waiting fbc restart
400 usleep(5000 * 1000);
401
402 if (mUpgradeMode == CC_UPGRADE_MODE_DUMMY) {
403 //dummy test mode
404
405 //wait 10 second
406 usleep(10000 * 1000);
407
408 //send reboot command to reboot fbc
409 sprintf((char *)tmp_buf, "reboot\n");
410 cmd_len = strlen((char *)tmp_buf);
411 mCfbcIns->sendDataOneway(COMM_DEV_SERIAL, tmp_buf, cmd_len, 0);
412 usleep(400 * 1000);
413
414 mpObserver->onUpgradeStatus(mState, 100);
415
416 usleep(100 * 1000);
417 mState = STATE_FINISHED;
418 mpObserver->onUpgradeStatus(mState, 0);
419
420 if (mBinFileBuf != NULL) {
421 delete mBinFileBuf;
422 mBinFileBuf = NULL;
423 }
424 return false;
425 }
426
427 tmp_prog += 1;
428 mpObserver->onUpgradeStatus(mState, tmp_prog * 100 / total_item);
429
430 cur_off = start_off;
431 old_off = cur_off;
432
433 upgrade_flag = 0;
434 while (!exitPending()) { //requietexit() or requietexitWait() not call
435 if (cur_off >= end_off) {
436 upgrade_flag = 1;
437 break;
438 }
439
440 //copy data from file temp buffer
441 if (end_off - cur_off < mUpgradeBlockSize) {
442 rw_size = end_off - cur_off;
443 } else {
444 rw_size = mUpgradeBlockSize;
445 }
446
447 memcpy(mDataBuf, mBinFileBuf + cur_off, rw_size);
448
449 //send upgrade start addr and write size
450 sprintf((char *)tmp_buf, "upgrade 0x%x 0x%x\n", cur_off, rw_size);
451 LOGD("\n\n%s, %s\n", __FUNCTION__, tmp_buf);
452 cmd_len = strlen((char *)tmp_buf);
453 if (mCfbcIns->sendDataOneway(COMM_DEV_SERIAL, tmp_buf, cmd_len, 0) <= 0) {
454 mState = STATE_ABORT;
455 upgrade_err_code = ERR_SERIAL_CONNECT;
456 upgrade_flag = 0;
457 break;
458 }
459 usleep(500 * 1000);
460
461 //send upgrade data
462 if (mCfbcIns->sendDataOneway(COMM_DEV_SERIAL, mDataBuf, rw_size, 0) <= 0) {
463 mState = STATE_ABORT;
464 upgrade_err_code = ERR_SERIAL_CONNECT;
465 upgrade_flag = 0;
466 break;
467 }
468
469 //send upgrade data crc
470 AddCRCToDataBuf(mDataBuf, rw_size);
471 if (mCfbcIns->sendDataOneway(COMM_DEV_SERIAL, mDataBuf + rw_size, 4, 0) <= 0) {
472 mState = STATE_ABORT;
473 upgrade_err_code = ERR_SERIAL_CONNECT;
474 upgrade_flag = 0;
475 break;
476 }
477
478 old_off = cur_off;
479 cur_off += rw_size;
480
481 //deal with fbc response
482 tmp_flag = 0;
483 memset(mDataBuf, 0, CC_UPGRADE_DATA_BUF_SIZE);
484 rw_size = mCfbcIns->uartReadStream(mDataBuf, CC_UPGRADE_DATA_BUF_SIZE, 2000);
485 for (i = 0; i < rw_size - 3; i++) {
486 if ((0x5A == mDataBuf[i]) && (0x5A == mDataBuf[i + 1]) && (0x5A == mDataBuf[i + 2])) {
487 LOGD("%s, fbc write data at 0x%x ok!\n", __FUNCTION__, old_off);
488 tmp_flag = 1;
489 break;
490 }
491 }
492
493 if (tmp_flag == 0) {
494 LOGE("%s, fbc write data at 0x%x error! rewrite!\n", __FUNCTION__, old_off);
495 if (upgrade_try_cnt < 6) {
496 cur_off = old_off;
497 upgrade_try_cnt += 1;
498
499 mpObserver->onUpgradeStatus(mState, ERR_DATA_CRC_ERROR);
500 } else {
501 LOGE("%s, we have rewrite more than %d times, abort.\n", __FUNCTION__, upgrade_try_cnt);
502 mState = STATE_ABORT;
503 upgrade_err_code = ERR_SERIAL_CONNECT;
504 upgrade_flag = 0;
505 break;
506 }
507 } else {
508 tmp_prog += 1;
509 upgrade_try_cnt = 0;
510 }
511
512 usleep(3000 * 1000);
513
514 mpObserver->onUpgradeStatus(mState, tmp_prog * 100 / total_item);
515 }
516
517 if (mState == STATE_ABORT) {
518 mpObserver->onUpgradeStatus(mState, upgrade_err_code);
519 } else if (mState == STATE_RUNNING) {
520 if (upgrade_flag == 1) {
521 sprintf((char *)tmp_buf, "reboot\n");
522 cmd_len = strlen((char *)tmp_buf);
523 mCfbcIns->sendDataOneway(COMM_DEV_SERIAL, tmp_buf, cmd_len, 0);
524 usleep(400 * 1000);
525
526 tmp_prog += 1;
527 mpObserver->onUpgradeStatus(mState, tmp_prog * 100 / total_item);
528
529 usleep(100 * 1000);
530 mState = STATE_FINISHED;
531 mpObserver->onUpgradeStatus(mState, 0);
532 }
533 } else {
534 if (upgrade_flag == 1) {
535 tmp_prog += 1;
536 mpObserver->onUpgradeStatus(mState, tmp_prog * 100 / total_item);
537 }
538 }
539
540 mState = STATE_STOPED;
541
542 mCfbcIns->SetUpgradeFlag(0);
543
544 if (mBinFileBuf != NULL) {
545 delete mBinFileBuf;
546 mBinFileBuf = NULL;
547 }
548
549 LOGD("%s, exiting...\n", "TV");
550 system("reboot");
551 //return true, run again, return false,not run.
552 return false;
553}
554
generated by cgit at 2024-05-09 20:42:19 (GMT)