blob: bf59abf82a2e070f998e3384d63406d8d4f8bd6a
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 | |
18 | CUpgradeFBC::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 | |
34 | CUpgradeFBC::~CUpgradeFBC() |
35 | { |
36 | if (mBinFileBuf != NULL) { |
37 | delete mBinFileBuf; |
38 | mBinFileBuf = NULL; |
39 | } |
40 | } |
41 | |
42 | int 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 | |
53 | int CUpgradeFBC::stop() |
54 | { |
55 | requestExit(); |
56 | mState = STATE_STOPED; |
57 | |
58 | return 0; |
59 | } |
60 | |
61 | int CUpgradeFBC::GetUpgradeFBCProgress() |
62 | { |
63 | return 0; |
64 | } |
65 | |
66 | int 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 | |
77 | int CUpgradeFBC::SetUpgradeFileSize(int file_size) |
78 | { |
79 | mBinFileSize = file_size; |
80 | return 0; |
81 | } |
82 | |
83 | int CUpgradeFBC::SetUpgradeBlockSize(int block_size) |
84 | { |
85 | mUpgradeBlockSize = block_size; |
86 | return 0; |
87 | } |
88 | |
89 | int 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 | |
99 | int 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 | |
112 | bool 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 |