1 /*
2 * (C) Copyright 2017 Fuzhou Rockchip Electronics Co., Ltd
3 * Seth Liu 2017.03.01
4 *
5 * SPDX-License-Identifier: GPL-2.0+
6 */
7
8 #include "RKDevice.h"
9
10 const char* szManufName[] =
11 {
12 "SAMSUNG",
13 "TOSHIBA",
14 "HYNIX",
15 "INFINEON",
16 "MICRON",
17 "RENESAS",
18 "ST",
19 "INTEL"
20 };
21
SetVendorID(USHORT value)22 void CRKDevice::SetVendorID(USHORT value)
23 {
24 m_vid = value;
25 }
SetProductID(USHORT value)26 void CRKDevice::SetProductID(USHORT value)
27 {
28 m_pid = value;
29 }
SetDeviceType(ENUM_RKDEVICE_TYPE value)30 void CRKDevice::SetDeviceType(ENUM_RKDEVICE_TYPE value)
31 {
32 m_device = value;
33 }
SetOsType(ENUM_OS_TYPE value)34 void CRKDevice::SetOsType(ENUM_OS_TYPE value)
35 {
36 m_os = value;
37 }
38
SetUsbType(ENUM_RKUSB_TYPE value)39 void CRKDevice::SetUsbType(ENUM_RKUSB_TYPE value)
40 {
41 m_usb = value;
42 }
SetBcdUsb(USHORT value)43 void CRKDevice::SetBcdUsb(USHORT value)
44 {
45 m_bcdUsb = value;
46 }
SetLayerName(char * value)47 void CRKDevice::SetLayerName(char *value)
48 {
49 strcpy(m_layerName,value);
50 }
SetLocationID(DWORD value)51 void CRKDevice::SetLocationID(DWORD value)
52 {
53 m_locationID = value;
54 }
55
SetCallBackPointer(ProgressPromptCB value)56 void CRKDevice::SetCallBackPointer(ProgressPromptCB value)
57 {
58 if (value)
59 {
60 m_callBackProc = value;
61 }
62 }
GetLogObjectPointer()63 CRKLog* CRKDevice::GetLogObjectPointer()
64 {
65 return m_pLog;
66 }
67
GetCommObjectPointer()68 CRKComm* CRKDevice::GetCommObjectPointer()
69 {
70 return m_pComm;
71 }
72
GetVendorID()73 USHORT CRKDevice::GetVendorID()
74 {
75 return m_vid;
76 }
GetProductID()77 USHORT CRKDevice::GetProductID()
78 {
79 return m_pid;
80 }
GetDeviceType()81 ENUM_RKDEVICE_TYPE CRKDevice::GetDeviceType()
82 {
83 return m_device;
84 }
GetOsType()85 ENUM_OS_TYPE CRKDevice::GetOsType()
86 {
87 return m_os;
88 }
89
GetUsbType()90 ENUM_RKUSB_TYPE CRKDevice::GetUsbType()
91 {
92 return m_usb;
93 }
94
GetBcdUsb()95 USHORT CRKDevice::GetBcdUsb()
96 {
97 return m_bcdUsb;
98 }
GetLocationID()99 DWORD CRKDevice::GetLocationID()
100 {
101 return m_locationID;
102 }
GetLayerName()103 char* CRKDevice::GetLayerName()
104 {
105 return m_layerName;
106 }
107
GetLayerString(UINT dwLocationID)108 string CRKDevice::GetLayerString(UINT dwLocationID)
109 {
110 char szLocation[32] = "\0";
111 snprintf(szLocation, sizeof(szLocation), "%d-%d", dwLocationID >> 8, dwLocationID & 0xff);
112 return szLocation;
113 }
114
CRKDevice(STRUCT_RKDEVICE_DESC & device)115 CRKDevice::CRKDevice(STRUCT_RKDEVICE_DESC &device)
116 {
117 VendorID.setContainer(this);
118 VendorID.getter(&CRKDevice::GetVendorID);
119 VendorID.setter(&CRKDevice::SetVendorID);
120
121 ProductID.setContainer(this);
122 ProductID.getter(&CRKDevice::GetProductID);
123 ProductID.setter(&CRKDevice::SetProductID);
124
125 DeviceType.setContainer(this);
126 DeviceType.getter(&CRKDevice::GetDeviceType);
127 DeviceType.setter(&CRKDevice::SetDeviceType);
128
129 UsbType.setContainer(this);
130 UsbType.getter(&CRKDevice::GetUsbType);
131 UsbType.setter(&CRKDevice::SetUsbType);
132
133 LayerName.setContainer(this);
134 LayerName.getter(&CRKDevice::GetLayerName);
135 LayerName.setter(&CRKDevice::SetLayerName);
136
137 BcdUsb.setContainer(this);
138 BcdUsb.getter(&CRKDevice::GetBcdUsb);
139 BcdUsb.setter(&CRKDevice::SetBcdUsb);
140
141 LocationID.setContainer(this);
142 LocationID.getter(&CRKDevice::GetLocationID);
143 LocationID.setter(&CRKDevice::SetLocationID);
144
145 OsType.setContainer(this);
146 OsType.getter(&CRKDevice::GetOsType);
147 OsType.setter(&CRKDevice::SetOsType);
148
149 LogObjectPointer.setContainer(this);
150 LogObjectPointer.getter(&CRKDevice::GetLogObjectPointer);
151
152 CommObjectPointer.setContainer(this);
153 CommObjectPointer.getter(&CRKDevice::GetCommObjectPointer);
154
155 CallBackPointer.setContainer(this);
156 CallBackPointer.setter(&CRKDevice::SetCallBackPointer);
157
158 m_vid = device.usVid;
159 m_pid = device.usPid;
160 m_usb = device.emUsbType;
161 m_device = device.emDeviceType;
162 m_bcdUsb = device.usbcdUsb;
163 m_locationID = device.uiLocationID;
164 strcpy(m_layerName, GetLayerString(m_locationID).c_str());
165
166 memset(m_flashInfo.blockState, 0, IDBLOCK_TOP);
167 m_flashInfo.usPhyBlokcPerIDB = 1;
168 m_flashInfo.uiSecNumPerIDB = 0;
169 m_callBackProc = NULL;
170 m_chipData = NULL;
171 m_pImage = NULL;
172 m_pLog = NULL;
173 m_pComm = NULL;
174 m_pFlashInfoData = NULL;
175 m_usFlashInfoDataLen = 0;
176 m_usFlashInfoDataOffset = 0;
177 m_bEmmc = false;
178 m_bDirectLba = false;
179 m_bFirst4mAccess = false;
180 }
~CRKDevice()181 CRKDevice::~CRKDevice()
182 {
183 if (m_pComm) {
184 delete m_pComm;
185 m_pComm = NULL;
186 }
187 if (m_chipData) {
188 delete []m_chipData;
189 m_chipData = NULL;
190 }
191
192 if (m_pFlashInfoData) {
193 delete []m_pFlashInfoData;
194 m_pFlashInfoData = NULL;
195 }
196 }
SetObject(CRKImage * pImage,CRKComm * pComm,CRKLog * pLog)197 bool CRKDevice::SetObject(CRKImage *pImage, CRKComm *pComm, CRKLog *pLog)
198 {
199 if (!pComm) {
200 return false;
201 }
202 m_pImage = pImage;
203 m_pComm = pComm;
204 m_pLog = pLog;
205 if (m_pImage) {
206 m_os = m_pImage->OsType;
207 } else
208 m_os = RK_OS;
209 return true;
210 }
EraseEmmcBlock(UCHAR ucFlashCS,DWORD dwPos,DWORD dwCount)211 int CRKDevice::EraseEmmcBlock(UCHAR ucFlashCS, DWORD dwPos, DWORD dwCount)
212 {
213 int sectorOffset,nWrittenBlcok,iRet;
214 BYTE emptyData[4 * (SECTOR_SIZE+SPARE_SIZE)];
215 memset(emptyData, 0xff, 4 * (SECTOR_SIZE + SPARE_SIZE));
216 nWrittenBlcok = 0;
217 while (dwCount > 0) {
218 sectorOffset = (ucFlashCS * m_flashInfo.uiBlockNum + dwPos + nWrittenBlcok) * m_flashInfo.uiSectorPerBlock;
219 iRet = m_pComm->RKU_WriteSector(sectorOffset, 4, emptyData);
220 if ((iRet != ERR_SUCCESS) && (iRet != ERR_FOUND_BAD_BLOCK)) {
221 if (m_pLog) {
222 m_pLog->Record("<LAYER %s> ERROR:EraseEmmcBlock-->RKU_WriteSector failed, RetCode(%d)", m_layerName, iRet);
223 }
224 return iRet;
225 }
226 dwCount--;
227 nWrittenBlcok++;
228 }
229 return ERR_SUCCESS;
230 }
EraseEmmcByWriteLBA(DWORD dwSectorPos,DWORD dwCount)231 int CRKDevice::EraseEmmcByWriteLBA(DWORD dwSectorPos, DWORD dwCount)
232 {
233 int nWritten,iRet;
234 BYTE emptyData[32 * SECTOR_SIZE];
235 memset(emptyData, 0xff, 32 * SECTOR_SIZE);
236
237 while (dwCount > 0) {
238 nWritten = (dwCount < 32) ? dwCount : 32;
239 iRet = m_pComm->RKU_WriteLBA(dwSectorPos, nWritten, emptyData);
240 if (iRet != ERR_SUCCESS) {
241 if (m_pLog) {
242 m_pLog->Record("<LAYER %s> ERROR:EraseEmmcByWriteLBA-->RKU_WriteLBA failed, RetCode(%d)", m_layerName, iRet);
243 }
244 return iRet;
245 }
246 dwCount -= nWritten;
247 dwSectorPos += nWritten;
248 }
249 return ERR_SUCCESS;
250 }
EraseEmmc()251 bool CRKDevice::EraseEmmc()
252 {
253 UINT uiCount,uiEraseCount,uiSectorOffset,uiTotalCount;
254 UINT uiErase=1024*32;
255 int iRet=ERR_SUCCESS,iLoopTimes=0;
256 uiTotalCount = uiCount = m_flashInfo.uiFlashSize*2*1024;
257 uiSectorOffset = 0;
258 DWORD dwLayerID;
259 dwLayerID = m_locationID;
260 ENUM_CALL_STEP emCallStep = CALL_FIRST;
261
262 while (uiCount)
263 {
264 if (uiCount >= uiErase)
265 {
266 uiEraseCount = uiErase;
267 }
268 else
269 uiEraseCount = uiCount;
270 iRet = m_pComm->RKU_EraseLBA(uiSectorOffset, uiEraseCount);
271
272 if (iRet != ERR_SUCCESS) {
273 if (m_pLog) {
274 m_pLog->Record("ERROR:EraseEmmc-->RKU_EraseLBA failed,RetCode(%d),offset=0x%x,count=0x%x",iRet, uiSectorOffset, uiEraseCount);
275 }
276 return false;
277 }
278 uiCount -= uiEraseCount;
279 uiSectorOffset += uiEraseCount;
280 iLoopTimes++;
281 if (iLoopTimes % 8 == 0) {
282 if (m_callBackProc) {
283 m_callBackProc(dwLayerID, ERASEFLASH_PROGRESS, uiTotalCount, uiSectorOffset, emCallStep);
284 emCallStep = CALL_MIDDLE;
285 }
286 }
287 }
288 if (m_callBackProc) {
289 emCallStep = CALL_LAST;
290 m_callBackProc(dwLayerID, ERASEFLASH_PROGRESS, uiTotalCount, uiTotalCount, emCallStep);
291 }
292 return true;
293 }
GetFlashInfo()294 bool CRKDevice::GetFlashInfo()
295 {
296 STRUCT_FLASHINFO_CMD info;
297 BYTE flashID[5];
298 int iRet;
299 UINT uiRead;
300 iRet = m_pComm->RKU_ReadFlashInfo((PBYTE)&info, &uiRead);
301 if( ERR_SUCCESS == iRet ) {
302 if ((info.usBlockSize == 0) || (info.bPageSize == 0)) {
303 if (m_pLog) {
304 m_pLog->Record("<LAYER %s> ERROR:GetFlashInfo-->RKU_ReadFlashInfo failed,pagesize or blocksize is zero", m_layerName);
305 }
306 return false;
307 }
308 if (info.bManufCode <= 7) {
309 strcpy(m_flashInfo.szManufacturerName, szManufName[info.bManufCode]);
310 } else {
311 strcpy(m_flashInfo.szManufacturerName, "UNKNOWN");
312 }
313 m_flashInfo.uiFlashSize = info.uiFlashSize / 2 / 1024;
314 m_flashInfo.uiPageSize = info.bPageSize / 2;
315 m_flashInfo.usBlockSize = info.usBlockSize / 2;
316 m_flashInfo.bECCBits = info.bECCBits;
317 m_flashInfo.bAccessTime = info.bAccessTime;
318 m_flashInfo.uiBlockNum = m_flashInfo.uiFlashSize * 1024 / m_flashInfo.usBlockSize;
319 m_flashInfo.uiSectorPerBlock = info.usBlockSize;
320 m_flashInfo.bFlashCS = info.bFlashCS;
321 m_flashInfo.usValidSecPerBlock = (info.usBlockSize / info.bPageSize) * 4;
322 if (m_pFlashInfoData) {
323 delete []m_pFlashInfoData;
324 m_pFlashInfoData = NULL;
325 }
326 m_usFlashInfoDataLen = BYTE2SECTOR(uiRead);
327 m_pFlashInfoData = new BYTE[SECTOR_SIZE * m_usFlashInfoDataLen];
328 memset(m_pFlashInfoData, 0, SECTOR_SIZE * m_usFlashInfoDataLen);
329 memcpy(m_pFlashInfoData, (PBYTE)&info, uiRead);
330 if (m_pLog) {
331 string strFlashInfo;
332 m_pLog->PrintBuffer(strFlashInfo, m_pFlashInfoData, 11);
333 m_pLog->Record("<LAYER %s> INFO:FlashInfo:%s", m_layerName, strFlashInfo.c_str());
334 }
335 } else {
336 if (m_pLog) {
337 m_pLog->Record("<LAYER %s> ERROR:GetFlashInfo-->RKU_ReadFlashInfo failed, RetCode(%d)", m_layerName, iRet);
338 }
339 return false;
340 }
341 iRet = m_pComm->RKU_ReadFlashID(flashID);
342 if( ERR_SUCCESS == iRet ) {
343 DWORD *pID = (DWORD *)flashID;
344 if (*pID==0x434d4d45)/*emmc*/ {
345 m_bEmmc = true;
346 } else
347 m_bEmmc = false;
348 } else {
349 if (m_pLog) {
350 m_pLog->Record("<LAYER %s> ERROR:GetFlashInfo-->RKU_ReadFlashID failed, RetCode(%d)", m_layerName, iRet);
351 }
352 return false;
353 }
354 return true;
355 }
TestDevice()356 bool CRKDevice::TestDevice()
357 {
358 int iResult, iTryCount;
359 DWORD dwTotal, dwCurrent, dwLayerID;
360 dwLayerID = m_locationID;
361 ENUM_CALL_STEP emCallStep = CALL_FIRST;
362 do {
363 iTryCount = 3;
364 while (iTryCount > 0) {
365 iResult = m_pComm->RKU_TestDeviceReady(&dwTotal, &dwCurrent);
366 if ((iResult == ERR_SUCCESS) || (iResult == ERR_DEVICE_UNREADY)) {
367 break;
368 }
369 if (m_pLog) {
370 m_pLog->Record("<LAYER %s> ERROR:TestDevice-->RKU_TestDeviceReady failed, RetCode(%d)", m_layerName, iResult);
371 }
372 iTryCount--;
373 sleep(1);
374 }
375 if (iTryCount <= 0) {
376 return false;
377 }
378
379 if (iResult == ERR_SUCCESS) {
380 if (emCallStep == CALL_MIDDLE) {
381 if (m_callBackProc) {
382 dwCurrent = dwTotal;
383 emCallStep = CALL_LAST;
384 m_callBackProc(dwLayerID, TESTDEVICE_PROGRESS, dwTotal, dwCurrent, emCallStep);
385 }
386 }
387 break;
388 }
389 if (dwCurrent>dwTotal) {
390 if (m_pLog) {
391 m_pLog->Record("<LAYER %s> ERROR:TestDevice-->RKU_TestDeviceReady failed,Total=%d, Current=%d", m_layerName, dwTotal, dwCurrent);
392 }
393 return false;
394 }
395 if (UsbType == RKUSB_LOADER) {
396 if (dwTotal == 0) {
397 if (m_pLog)
398 {
399 m_pLog->Record("<LAYER %s> ERROR:TestDevice-->RKU_TestDeviceReady failed, Total is zero", m_layerName);
400 }
401 return false;
402 }
403 }
404 if (m_callBackProc)
405 {
406 m_callBackProc(dwLayerID, TESTDEVICE_PROGRESS, dwTotal, dwCurrent, emCallStep);
407 emCallStep = CALL_MIDDLE;
408 }
409 sleep(1);
410 }while(iResult == ERR_DEVICE_UNREADY);
411 return true;
412 }
ResetDevice()413 bool CRKDevice::ResetDevice()
414 {
415 int iRet;
416 iRet = m_pComm->RKU_ResetDevice();
417 if (iRet == ERR_SUCCESS) {
418 return true;
419 } else {
420 bool bRet = false;
421 if ((iRet == -2) || (iRet == -4)) {
422 bRet = true;
423 }
424 if (m_pLog) {
425 m_pLog->Record("<LAYER %s> ERROR:ResetDevice-->RKU_ResetDevice failed, RetCode(%d)", m_layerName, iRet);
426 }
427 return bRet;
428 }
429 }
430
PowerOffDevice()431 bool CRKDevice::PowerOffDevice()
432 {
433 int iRet;
434 iRet = m_pComm->RKU_ResetDevice(RST_POWEROFF_SUBCODE);
435 if (iRet == ERR_SUCCESS) {
436 return true;
437 } else {
438 if (m_pLog) {
439 m_pLog->Record("<LAYER %s> ERROR:PowerOffDevice-->RKU_ResetDevice failed, RetCode(%d)", m_layerName, iRet);
440 }
441 return false;
442 }
443 }
CheckChip()444 bool CRKDevice::CheckChip()
445 {
446 int iRet;
447 BYTE bChipInfo[CHIPINFO_LEN];
448 ENUM_RKDEVICE_TYPE curDeviceType = RKNONE_DEVICE;
449 memset(bChipInfo, 0, CHIPINFO_LEN);
450 iRet = m_pComm->RKU_ReadChipInfo(bChipInfo);
451 if (iRet == ERR_SUCCESS) {
452 if (!m_chipData) {
453 m_chipData = new BYTE[CHIPINFO_LEN];
454 }
455 memset(m_chipData, 0, CHIPINFO_LEN);
456 memcpy(m_chipData, bChipInfo, CHIPINFO_LEN);
457 DWORD *pValue;
458 pValue = (DWORD *)(&bChipInfo[0]);
459
460 if ((ENUM_RKDEVICE_TYPE)(*pValue) == m_device) {
461 return true;
462 }
463 if (*pValue == 0x524B3237) {
464 curDeviceType = RK27_DEVICE;
465 } else if (*pValue == 0x32373341) {
466 curDeviceType = RKCAYMAN_DEVICE;
467 } else if (*pValue == 0x524B3238) {
468 curDeviceType = RK28_DEVICE;
469 } else if (*pValue == 0x32383158) {
470 curDeviceType = RK281X_DEVICE;
471 } else if (*pValue == 0x32383242) {
472 curDeviceType = RKPANDA_DEVICE;
473 } else if (*pValue == 0x32393058) {
474 curDeviceType = RK29_DEVICE;
475 } else if (*pValue == 0x32393258) {
476 curDeviceType = RK292X_DEVICE;
477 } else if (*pValue == 0x33303041) {
478 curDeviceType = RK30_DEVICE;
479 } else if (*pValue == 0x33313041) {
480 curDeviceType = RK30B_DEVICE;
481 } else if (*pValue == 0x33313042) {
482 curDeviceType = RK31_DEVICE;
483 } else if (*pValue == 0x33323041) {
484 curDeviceType = RK32_DEVICE;
485 } else if (*pValue == 0x32363243) {
486 curDeviceType = RKSMART_DEVICE;
487 } else if (*pValue == 0x6E616E6F) {
488 curDeviceType = RKNANO_DEVICE;
489 } else if (*pValue == 0x4E4F5243) {
490 curDeviceType = RKCROWN_DEVICE;
491 }
492
493 if (curDeviceType == m_device){
494 return true;
495 } else {
496 if (m_pLog) {
497 m_pLog->Record("<LAYER %s> ERROR:CheckChip-->Chip is not match, firmware(0x%x), device(0x%x)", m_layerName, m_device, *pValue);
498 }
499 return false;
500 }
501 }
502 else {
503 if (m_pLog) {
504 m_pLog->Record("<LAYER %s> ERROR:CheckChip-->RKU_ReadChipInfo failed,RetCode(%d)", m_layerName, iRet);
505 }
506 return false;
507 }
508 }
509
DownloadBoot()510 int CRKDevice::DownloadBoot()
511 {
512 UCHAR i;
513 DWORD dwSize, dwDelay;
514 PBYTE pBuffer = NULL;
515 for ( i = 0; i < m_pImage->m_bootObject->Entry471Count; i++ ) {
516 if ( !m_pImage->m_bootObject->GetEntryProperty(ENTRY471, i, dwSize, dwDelay) ) {
517 if (m_pLog) {
518 m_pLog->Record("<LAYER %s> ERROR:DownloadBoot-->GetEntry471Property failed,index(%d)", m_layerName, i);
519 }
520 return -2;
521 }
522 if (dwSize>0) {
523 pBuffer = new BYTE[dwSize];
524 if ( !m_pImage->m_bootObject->GetEntryData(ENTRY471, i, pBuffer) ) {
525 if (m_pLog) {
526 m_pLog->Record("<LAYER %s> ERROR:DownloadBoot-->GetEntry471Data failed,index(%d)", m_layerName, i);
527 }
528 delete []pBuffer;
529 return -3;
530 }
531 if ( !Boot_VendorRequest(0x0471,pBuffer,dwSize) ) {
532 if (m_pLog) {
533 m_pLog->Record("<LAYER %s> ERROR:DownloadBoot-->Boot_VendorRequest471 failed,index(%d)", m_layerName, i);
534 }
535 delete []pBuffer;
536 return -4;
537 }
538 delete []pBuffer;
539 pBuffer = NULL;
540 if (dwDelay>0) {
541 usleep(dwDelay * 1000);
542 }
543
544 }
545 }
546
547 for ( i=0; i < m_pImage->m_bootObject->Entry472Count; i++ ) {
548 if ( !m_pImage->m_bootObject->GetEntryProperty(ENTRY472, i, dwSize, dwDelay) ) {
549 if (m_pLog) {
550 m_pLog->Record("<LAYER %s> ERROR:DownloadBoot-->GetEntry472Property failed,index(%d)", m_layerName, i);
551 }
552 return -2;
553 }
554 if (dwSize > 0) {
555 pBuffer = new BYTE[dwSize];
556 if ( !m_pImage->m_bootObject->GetEntryData(ENTRY472, i, pBuffer) ) {
557 if (m_pLog) {
558 m_pLog->Record("<LAYER %s> ERROR:DownloadBoot-->GetEntry472Data failed,index(%d)", m_layerName, i);
559 }
560 delete []pBuffer;
561 return -3;
562 }
563 if ( !Boot_VendorRequest(0x0472, pBuffer, dwSize) ) {
564 if (m_pLog) {
565 m_pLog->Record("<LAYER %s> ERROR:DownloadBoot-->Boot_VendorRequest472 failed,index(%d)", m_layerName, i);
566 }
567 delete []pBuffer;
568 return -4;
569 }
570 delete []pBuffer;
571 pBuffer = NULL;
572 if (dwDelay > 0) {
573 usleep(dwDelay * 1000);
574 }
575 }
576 }
577 sleep(1);
578 return 0;
579
580 }
Boot_VendorRequest(DWORD requestCode,PBYTE pBuffer,DWORD dwDataSize)581 bool CRKDevice::Boot_VendorRequest( DWORD requestCode, PBYTE pBuffer, DWORD dwDataSize)
582 {
583 int iRet;
584 iRet = m_pComm->RKU_DeviceRequest(requestCode, pBuffer, dwDataSize);
585 return (iRet == ERR_SUCCESS) ? true : false;
586 }
EraseAllBlocks(bool force_block_erase)587 int CRKDevice::EraseAllBlocks(bool force_block_erase)
588 {
589 int i;
590 UINT uiBlockCount;
591 int iRet = ERR_SUCCESS, iErasePos = 0, iEraseBlockNum = 0, iEraseTimes = 0, iCSIndex = 0;
592 BYTE bCSCount = 0;
593 for (i = 0; i < 8; i++) {
594 if ( m_flashInfo.bFlashCS & (1 << i) ) {
595 bCSCount++;
596 }
597 }
598 ReadCapability();
599 DWORD dwLayerID;
600 dwLayerID = LocationID;
601 ENUM_CALL_STEP emCallStep = CALL_FIRST;
602 if (!force_block_erase) {
603 if ((m_bEmmc)||(m_bDirectLba)) {
604 if (!EraseEmmc()) {
605 if (m_pLog) {
606 m_pLog->Record("<LAYER %s> ERROR:EraseAllBlocks-->EraseEmmc failed", m_layerName);
607 }
608 return -1;
609 }
610 return 0;
611 }
612 }
613 for (i = 0; i < 8; i++) {
614 if ( m_flashInfo.bFlashCS & (1 << i) ) {
615 uiBlockCount = m_flashInfo.uiBlockNum;
616 iErasePos = 0;
617 iEraseTimes = 0;
618 while (uiBlockCount > 0) {
619 iEraseBlockNum = (uiBlockCount < MAX_ERASE_BLOCKS) ? uiBlockCount : MAX_ERASE_BLOCKS;
620 iRet = m_pComm->RKU_EraseBlock(i, iErasePos, iEraseBlockNum, ERASE_FORCE);
621 if ((iRet != ERR_SUCCESS) && (iRet != ERR_FOUND_BAD_BLOCK)) {
622 if (m_pLog) {
623 m_pLog->Record("<LAYER %s> ERROR:EraseAllBlocks-->RKU_EraseBlock failed,RetCode(%d)", m_layerName, iRet);
624 }
625 return -1;
626 }
627 iErasePos += iEraseBlockNum;
628 uiBlockCount -= iEraseBlockNum;
629 iEraseTimes++;
630 if (iEraseTimes % 8 == 0) {
631 if (m_callBackProc) {
632 m_callBackProc(dwLayerID, ERASEFLASH_PROGRESS, m_flashInfo.uiBlockNum * bCSCount, iCSIndex * m_flashInfo.uiBlockNum + iErasePos, emCallStep);
633 emCallStep = CALL_MIDDLE;
634 }
635 }
636 }
637 iCSIndex++;
638 }
639 }
640
641 if (m_callBackProc) {
642 emCallStep = CALL_LAST;
643 m_callBackProc(dwLayerID, ERASEFLASH_PROGRESS, m_flashInfo.uiBlockNum * bCSCount, iCSIndex * m_flashInfo.uiBlockNum, emCallStep);
644 }
645 return 0;
646 }
ReadCapability()647 bool CRKDevice::ReadCapability()
648 {
649 int ret;
650 BYTE data[8];
651 ret = m_pComm->RKU_ReadCapability(data);
652 if (ret != ERR_SUCCESS)
653 {
654 if (m_pLog)
655 {
656 m_pLog->Record("ERROR:ReadCapability-->RKU_ReadCapability failed,err(%d)", ret);
657 }
658 return false;
659 }
660 if (data[0] & 0x1)
661 {
662 m_bDirectLba = true;
663 }
664 else
665 m_bDirectLba = false;
666 if (data[0] & 0x4)
667 {
668 m_bFirst4mAccess = true;
669 }
670 else
671 m_bFirst4mAccess = false;
672 return true;
673 }
674
675
676