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