NorFlashHw.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628
  1. /** @file
  2. *
  3. * Copyright (c) 2015, Hisilicon Limited. All rights reserved.
  4. * Copyright (c) 2015, Linaro Limited. All rights reserved.
  5. *
  6. * This program and the accompanying materials
  7. * are licensed and made available under the terms and conditions of the BSD License
  8. * which accompanies this distribution. The full text of the license may be found at
  9. * http://opensource.org/licenses/bsd-license.php
  10. *
  11. * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13. *
  14. **/
  15. #include <PiDxe.h>
  16. #include <Library/DebugLib.h>
  17. #include <Library/UefiBootServicesTableLib.h>
  18. #include <Library/IoLib.h>
  19. #include "NorFlashHw.h"
  20. BOOLEAN gFlashBusy = FALSE;
  21. FLASH_INDEX gIndex = {
  22. 0,
  23. 0,
  24. 0,
  25. 0,
  26. 0,
  27. 0
  28. };
  29. UINT32 PortReadData (
  30. UINT32 Index,
  31. UINT32 FlashAddr
  32. )
  33. {
  34. switch (gFlashInfo[Index].ParallelNum)
  35. {
  36. case 2:
  37. return MmioRead32 (FlashAddr);
  38. case 1:
  39. return MmioRead16 (FlashAddr);
  40. default:
  41. DEBUG ((EFI_D_ERROR, "[%a]:[%dL]:illegal PortWidth!\n", __FUNCTION__,__LINE__));
  42. return 0xffffffff;
  43. }
  44. }
  45. EFI_STATUS
  46. PortWriteData (
  47. UINT32 Index,
  48. UINT32 FlashAddr,
  49. UINT32 InputData
  50. )
  51. {
  52. switch (gFlashInfo[Index].ParallelNum)
  53. {
  54. case 2:
  55. MmioWrite32 (FlashAddr, InputData);
  56. break;
  57. case 1:
  58. MmioWrite16 (FlashAddr, InputData);
  59. break;
  60. default:
  61. DEBUG ((EFI_D_ERROR, "[%a]:[%dL]:illegal PortWidth!\n", __FUNCTION__,__LINE__));
  62. return EFI_DEVICE_ERROR;
  63. }
  64. return EFI_SUCCESS;
  65. }
  66. UINT32 PortAdjustData(
  67. UINT32 Index,
  68. UINT32 ulInputData
  69. )
  70. {
  71. switch (gFlashInfo[Index].ParallelNum)
  72. {
  73. case 2:
  74. return ulInputData;
  75. case 1:
  76. return (0x0000ffff & ulInputData );
  77. default:
  78. DEBUG((EFI_D_ERROR,"[FLASH_S29GL256N_PortAdjustData]: Error--illegal g_ulFlashS29Gl256NPortWidth!\n\r"));
  79. return 0xffffffff;
  80. }
  81. }
  82. EFI_STATUS GetCommandIndex(
  83. UINT32 Index
  84. )
  85. {
  86. UINT32 CommandCount = 0;
  87. UINT32 i;
  88. UINT8 Flag = 1;
  89. CommandCount = sizeof(gFlashCommandReset) / sizeof(FLASH_COMMAND_RESET);
  90. for(i = 0;i < CommandCount; i ++ )
  91. {
  92. if(gFlashInfo[Index].CommandType & gFlashCommandReset[i].CommandType)
  93. {
  94. Flag = 0;
  95. gIndex.ReIndex = i;
  96. break;
  97. }
  98. }
  99. if(Flag)
  100. {
  101. DEBUG ((EFI_D_ERROR, "[%a]:[%dL]:Can not Get Reset Command!\n", __FUNCTION__,__LINE__));
  102. return EFI_DEVICE_ERROR;
  103. }
  104. CommandCount = sizeof(gFlashCommandId) / sizeof(FLASH_COMMAND_ID);
  105. for(Flag = 1,i = 0;i < CommandCount; i ++ )
  106. {
  107. if(gFlashInfo[Index].CommandType & gFlashCommandId[i].CommandType)
  108. {
  109. Flag = 0;
  110. gIndex.IdIndex = i;
  111. break;
  112. }
  113. }
  114. if(Flag)
  115. {
  116. DEBUG ((EFI_D_ERROR, "[%a]:[%dL]:Can not Get ID Command!\n", __FUNCTION__,__LINE__));
  117. return EFI_DEVICE_ERROR;
  118. }
  119. CommandCount = sizeof(gFlashCommandWrite) / sizeof(FLASH_COMMAND_WRITE);
  120. for(Flag = 1, i = 0;i < CommandCount; i ++ )
  121. {
  122. if(gFlashInfo[Index].CommandType & gFlashCommandWrite[i].CommandType)
  123. {
  124. Flag = 0;
  125. gIndex.WIndex = i;
  126. break;
  127. }
  128. }
  129. if(Flag)
  130. {
  131. DEBUG ((EFI_D_ERROR, "[%a]:[%dL]:Can not Get Write Command!\n", __FUNCTION__,__LINE__));
  132. return EFI_DEVICE_ERROR;
  133. }
  134. CommandCount = sizeof(gFlashCommandErase) / sizeof(FLASH_COMMAND_ERASE);
  135. for(Flag = 1, i = 0;i < CommandCount; i ++ )
  136. {
  137. if(gFlashInfo[Index].CommandType & gFlashCommandErase[i].CommandType)
  138. {
  139. Flag = 0;
  140. gIndex.WIndex = i;
  141. break;
  142. }
  143. }
  144. if(Flag)
  145. {
  146. DEBUG ((EFI_D_ERROR, "[%a]:[%dL]:Can not Get Erase Command!\n", __FUNCTION__,__LINE__));
  147. return EFI_DEVICE_ERROR;
  148. }
  149. return EFI_SUCCESS;
  150. }
  151. VOID FlashReset(UINT32 Base)
  152. {
  153. (VOID)PortWriteData(gIndex.InfIndex, Base, gFlashCommandReset[gIndex.ReIndex].ResetData);
  154. (void)gBS->Stall(20000);
  155. }
  156. void GetManufacturerID(UINT32 Index, UINT32 Base, UINT8 *pbyData)
  157. {
  158. UINT32 dwAddr;
  159. FlashReset(Base);
  160. dwAddr = Base + (gFlashCommandId[gIndex.IdIndex].ManuIDAddressStep1 << gFlashInfo[Index].ParallelNum);
  161. (VOID)PortWriteData(Index, dwAddr, gFlashCommandId[gIndex.IdIndex].ManuIDDataStep1);
  162. dwAddr = Base + (gFlashCommandId[gIndex.IdIndex].ManuIDAddressStep2 << gFlashInfo[Index].ParallelNum);
  163. (VOID)PortWriteData(Index, dwAddr, gFlashCommandId[gIndex.IdIndex].ManuIDDataStep2);
  164. dwAddr = Base + (gFlashCommandId[gIndex.IdIndex].ManuIDAddressStep3 << gFlashInfo[Index].ParallelNum);
  165. (VOID)PortWriteData(Index, dwAddr, gFlashCommandId[gIndex.IdIndex].ManuIDDataStep3);
  166. *pbyData = (UINT8)PortReadData(Index, Base + (gFlashCommandId[gIndex.IdIndex].ManuIDAddress << gFlashInfo[Index].ParallelNum));
  167. FlashReset(Base); //must reset to return to the read mode
  168. }
  169. EFI_STATUS FlashInit(UINT32 Base)
  170. {
  171. UINT32 FlashCount = 0;
  172. UINT32 i = 0;
  173. EFI_STATUS Status;
  174. UINT8 Flag = 1;
  175. UINT32 TempData = 0;
  176. UINT32 TempDev1 = 0;
  177. UINT32 TempDev2 = 0;
  178. UINT32 TempDev3 = 0;
  179. UINT32 dwAddr;
  180. FlashCount = sizeof(gFlashInfo) / sizeof(NOR_FLASH_INFO_TABLE);
  181. for(;i < FlashCount; i ++ )
  182. {
  183. Status = GetCommandIndex(i);
  184. if (EFI_ERROR(Status))
  185. {
  186. DEBUG ((EFI_D_ERROR, "[%a]:[%dL]:Get Command Index %r!\n", __FUNCTION__,__LINE__, Status));
  187. return Status;
  188. }
  189. FlashReset(Base);
  190. dwAddr = Base + (gFlashCommandId[gIndex.IdIndex].ManuIDAddressStep1 << gFlashInfo[i].ParallelNum);
  191. (VOID)PortWriteData(i, dwAddr, gFlashCommandId[gIndex.IdIndex].ManuIDDataStep1);
  192. dwAddr = Base + (gFlashCommandId[gIndex.IdIndex].ManuIDAddressStep2 << gFlashInfo[i].ParallelNum);
  193. (VOID)PortWriteData(i, dwAddr, gFlashCommandId[gIndex.IdIndex].ManuIDDataStep2);
  194. dwAddr = Base + (gFlashCommandId[gIndex.IdIndex].ManuIDAddressStep3 << gFlashInfo[i].ParallelNum);
  195. (VOID)PortWriteData(i, dwAddr, gFlashCommandId[gIndex.IdIndex].ManuIDDataStep3);
  196. //Get manufacture ID
  197. TempData = PortReadData(i, Base + (gFlashCommandId[gIndex.IdIndex].ManuIDAddress << gFlashInfo[i].ParallelNum));
  198. //Get Device Id
  199. TempDev1 = PortReadData(i, Base + (gFlashCommandId[gIndex.IdIndex].DeviceIDAddress1 << gFlashInfo[i].ParallelNum));
  200. TempDev2 = PortReadData(i, Base + (gFlashCommandId[gIndex.IdIndex].DeviceIDAddress2 << gFlashInfo[i].ParallelNum));
  201. TempDev3 = PortReadData(i, Base + (gFlashCommandId[gIndex.IdIndex].DeviceIDAddress3 << gFlashInfo[i].ParallelNum));
  202. DEBUG ((EFI_D_ERROR, "[cdtest]manufactor ID 0x%x!\n",TempData));
  203. DEBUG ((EFI_D_ERROR, "[cdtest]Device ID 1 0x%x!\n",TempDev1));
  204. DEBUG ((EFI_D_ERROR, "[cdtest]Device ID 2 0x%x!\n",TempDev2));
  205. DEBUG ((EFI_D_ERROR, "[cdtest]Device ID 3 0x%x!\n",TempDev3));
  206. FlashReset(Base);
  207. if((0xffffffff != TempData)
  208. && (PortAdjustData(i, gFlashInfo[i].ManufacturerID) == TempData))
  209. {
  210. if((0xffffffff != TempDev1)
  211. && (PortAdjustData(i, gFlashInfo[i].DeviceID1) == TempDev1))
  212. {
  213. if((0xffffffff != TempDev2)
  214. && (PortAdjustData(i, gFlashInfo[i].DeviceID2) == TempDev2))
  215. {
  216. if((0xffffffff != TempDev3)
  217. && (PortAdjustData(i, gFlashInfo[i].DeviceID3) == TempDev3))
  218. {
  219. Flag = 0;
  220. gIndex.InfIndex = i;
  221. break;
  222. }
  223. }
  224. }
  225. }
  226. }
  227. if(Flag)
  228. {
  229. return EFI_DEVICE_ERROR;
  230. }
  231. return EFI_SUCCESS;
  232. }
  233. static BOOLEAN width8IsAll(
  234. const UINT64 Base,
  235. const UINT64 Offset,
  236. const UINT64 Length,
  237. const UINT8 Value
  238. )
  239. {
  240. UINT64 NewAddr = Base + Offset;
  241. UINT64 NewLength = Length;
  242. while (NewLength --)
  243. {
  244. if (*(UINT8 *)(UINTN)NewAddr == Value)
  245. {
  246. NewAddr ++;
  247. continue;
  248. }
  249. else
  250. {
  251. return FALSE;
  252. }
  253. }
  254. return TRUE;
  255. }
  256. EFI_STATUS BufferWriteCommand(UINTN Base, UINTN Offset, void *pData)
  257. {
  258. UINT32 dwCommAddr;
  259. UINT32 *pdwData;
  260. UINT16 *pwData;
  261. UINT32 dwLoop;
  262. UINT32 ulWriteWordCount;
  263. UINT32 dwAddr;
  264. if(gFlashBusy)
  265. {
  266. DEBUG((EFI_D_ERROR, "[%a]:[%dL]:Flash is busy!\n", __FUNCTION__,__LINE__));
  267. return EFI_NOT_READY;
  268. }
  269. gFlashBusy = TRUE;
  270. if(2 == gFlashInfo[gIndex.InfIndex].ParallelNum)
  271. {
  272. pdwData = (UINT32 *)pData;
  273. dwAddr = (UINT32)Base + (gFlashCommandWrite[gIndex.WIndex].BufferProgramAddressStep1 << gFlashInfo[gIndex.InfIndex].ParallelNum);
  274. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandWrite[gIndex.WIndex].BufferProgramDataStep1);
  275. dwAddr = (UINT32)Base + (gFlashCommandWrite[gIndex.WIndex].BufferProgramAddressStep2 << gFlashInfo[gIndex.InfIndex].ParallelNum);
  276. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandWrite[gIndex.WIndex].BufferProgramDataStep2);
  277. //dwAddr = Base + (Offset << gFlashInfo[gIndex.InfIndex].ParallelNum);
  278. dwAddr = (UINT32)Base + Offset;
  279. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandWrite[gIndex.WIndex].BufferProgramDataStep3);
  280. ulWriteWordCount = ((gFlashInfo[gIndex.InfIndex].BufferProgramSize - 1) << 16) | (gFlashInfo[gIndex.InfIndex].BufferProgramSize - 1);
  281. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, ulWriteWordCount);
  282. for (dwLoop = 0; dwLoop < gFlashInfo[gIndex.InfIndex].BufferProgramSize; dwLoop ++)
  283. {
  284. dwCommAddr = (UINT32)Base + (UINT32)Offset + (dwLoop << gFlashInfo[gIndex.InfIndex].ParallelNum);
  285. MmioWrite32 (dwCommAddr, *pdwData);
  286. pdwData ++;
  287. }
  288. dwAddr = (UINT32)Base + (UINT32)Offset + ((gFlashInfo[gIndex.InfIndex].BufferProgramSize - 1) << gFlashInfo[gIndex.InfIndex].ParallelNum);
  289. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandWrite[gIndex.WIndex].BufferProgramtoFlash);
  290. }
  291. else
  292. {
  293. pwData = (UINT16 *)pData;
  294. dwAddr = (UINT32)Base + (gFlashCommandWrite[gIndex.WIndex].BufferProgramAddressStep1 << gFlashInfo[gIndex.InfIndex].ParallelNum);
  295. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandWrite[gIndex.WIndex].BufferProgramDataStep1);
  296. dwAddr = (UINT32)Base + (gFlashCommandWrite[gIndex.WIndex].BufferProgramAddressStep2 << gFlashInfo[gIndex.InfIndex].ParallelNum);
  297. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandWrite[gIndex.WIndex].BufferProgramDataStep2);
  298. //dwAddr = Base + (Offset << gFlashInfo[gIndex.InfIndex].ParallelNum);
  299. dwAddr = (UINT32)Base + Offset;
  300. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandWrite[gIndex.WIndex].BufferProgramDataStep3);
  301. ulWriteWordCount = gFlashInfo[gIndex.InfIndex].BufferProgramSize - 1;
  302. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, ulWriteWordCount);
  303. for (dwLoop = 0; dwLoop < gFlashInfo[gIndex.InfIndex].BufferProgramSize; dwLoop ++)
  304. {
  305. dwCommAddr = (UINT32)Base + (UINT32)Offset + (dwLoop << gFlashInfo[gIndex.InfIndex].ParallelNum);
  306. MmioWrite16 (dwCommAddr, *pwData);
  307. pwData ++;
  308. }
  309. dwAddr = (UINT32)Base + (UINT32)Offset + ((gFlashInfo[gIndex.InfIndex].BufferProgramSize - 1) << gFlashInfo[gIndex.InfIndex].ParallelNum);
  310. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandWrite[gIndex.WIndex].BufferProgramtoFlash);
  311. }
  312. (void)gBS->Stall(200);
  313. gFlashBusy = FALSE;
  314. return EFI_SUCCESS;
  315. }
  316. EFI_STATUS SectorEraseCommand(UINTN Base, UINTN Offset)
  317. {
  318. UINT32 dwAddr;
  319. if(gFlashBusy)
  320. {
  321. DEBUG((EFI_D_ERROR, "[%a]:[%dL]:Flash is busy!\n", __FUNCTION__,__LINE__));
  322. return EFI_NOT_READY;
  323. }
  324. gFlashBusy = TRUE;
  325. dwAddr = (UINT32)Base + (gFlashCommandErase[gIndex.EIndex].SectorEraseAddressStep1 << gFlashInfo[gIndex.InfIndex].ParallelNum);
  326. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandErase[gIndex.EIndex].SectorEraseDataStep1);
  327. dwAddr = (UINT32)Base + (gFlashCommandErase[gIndex.EIndex].SectorEraseAddressStep2 << gFlashInfo[gIndex.InfIndex].ParallelNum);
  328. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandErase[gIndex.EIndex].SectorEraseDataStep2);
  329. dwAddr = (UINT32)Base + (gFlashCommandErase[gIndex.EIndex].SectorEraseAddressStep3 << gFlashInfo[gIndex.InfIndex].ParallelNum);
  330. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandErase[gIndex.EIndex].SectorEraseDataStep3);
  331. dwAddr = (UINT32)Base + (gFlashCommandErase[gIndex.EIndex].SectorEraseAddressStep4 << gFlashInfo[gIndex.InfIndex].ParallelNum);
  332. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandErase[gIndex.EIndex].SectorEraseDataStep4);
  333. dwAddr = (UINT32)Base + (gFlashCommandErase[gIndex.EIndex].SectorEraseAddressStep5 << gFlashInfo[gIndex.InfIndex].ParallelNum);
  334. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandErase[gIndex.EIndex].SectorEraseDataStep5);
  335. dwAddr = (UINT32)Base + Offset;
  336. (VOID)PortWriteData(gIndex.InfIndex, dwAddr, gFlashCommandErase[gIndex.EIndex].SectorEraseDataStep6);
  337. (void)gBS->Stall(500000);
  338. gFlashBusy = FALSE;
  339. return EFI_SUCCESS;
  340. }
  341. EFI_STATUS CompleteCheck(UINT32 Base, UINT32 Offset, void *pData, UINT32 Length)
  342. {
  343. UINT32 dwTestAddr;
  344. UINT32 dwTestData;
  345. UINT32 dwTemp = 0;
  346. UINT32 dwTemp1 = 0;
  347. UINT32 i;
  348. UINT32 dwTimeOut = 3000000;
  349. if(gFlashBusy)
  350. {
  351. DEBUG((EFI_D_ERROR, "[%a]:[%dL]:Flash is busy!\n", __FUNCTION__,__LINE__));
  352. return EFI_NOT_READY;
  353. }
  354. gFlashBusy = TRUE;
  355. if(2 == gFlashInfo[gIndex.InfIndex].ParallelNum)
  356. {
  357. dwTestAddr = Base + Offset + Length - sizeof(UINT32);
  358. dwTestData = *((UINT32 *)((UINT8 *)pData + Length - sizeof(UINT32)));
  359. while(dwTimeOut--)
  360. {
  361. dwTemp1 = MmioRead32 (dwTestAddr);
  362. if (dwTestData == dwTemp1)
  363. {
  364. dwTemp = MmioRead32 (dwTestAddr);
  365. dwTemp1 = MmioRead32 (dwTestAddr);
  366. if ((dwTemp == dwTemp1) && (dwTestData == dwTemp1))
  367. {
  368. gFlashBusy = FALSE;
  369. return EFI_SUCCESS;
  370. }
  371. }
  372. (void)gBS->Stall(1);
  373. }
  374. if((UINT16)(dwTemp1 >> 16) != (UINT16)(dwTestData >> 16))
  375. {
  376. DEBUG((EFI_D_ERROR, "CompleteCheck ERROR: chip1 address %x, buffer %x, flash %x!\n", Offset, dwTestData, dwTemp1));
  377. }
  378. if((UINT16)(dwTemp1) != (UINT16)(dwTestData))
  379. {
  380. DEBUG((EFI_D_ERROR, "CompleteCheck ERROR: chip2 address %x, buffer %x, flash %x!\n", Offset, dwTestData, dwTemp1));
  381. }
  382. }
  383. else
  384. {
  385. dwTestAddr = Base + Offset + Length - sizeof(UINT16);
  386. dwTestData = *((UINT16 *)((UINT8 *)pData + Length - sizeof(UINT16)));
  387. while(dwTimeOut--)
  388. {
  389. dwTemp1 = MmioRead16 (dwTestAddr);
  390. if (dwTestData == dwTemp1)
  391. {
  392. dwTemp = MmioRead16 (dwTestAddr);
  393. dwTemp1 = MmioRead16 (dwTestAddr);
  394. if ((dwTemp == dwTemp1) && (dwTestData == dwTemp1))
  395. {
  396. gFlashBusy = FALSE;
  397. return EFI_SUCCESS;
  398. }
  399. }
  400. (void)gBS->Stall(1);
  401. }
  402. }
  403. for(i = 0; i < 5; i ++)
  404. {
  405. DEBUG((EFI_D_ERROR, "CompleteCheck ERROR: flash %x\n",PortReadData(gIndex.InfIndex, dwTestAddr)));
  406. }
  407. FlashReset(Base);
  408. gFlashBusy = FALSE;
  409. DEBUG((EFI_D_ERROR, "CompleteCheck ERROR: timeout address %x, buffer %x, flash %x\n", Offset, dwTestData, dwTemp1));
  410. return EFI_TIMEOUT;
  411. }
  412. EFI_STATUS IsNeedToWrite(
  413. IN UINT32 Base,
  414. IN UINT32 Offset,
  415. IN UINT8 *Buffer,
  416. IN UINT32 Length
  417. )
  418. {
  419. UINTN NewAddr = Base + Offset;
  420. UINT8 FlashData = 0;
  421. UINT8 BufferData = 0;
  422. for(; Length > 0; Length --)
  423. {
  424. BufferData = *Buffer;
  425. //lint -epn -e511
  426. FlashData = *(UINT8 *)NewAddr;
  427. if (BufferData != FlashData)
  428. {
  429. return TRUE;
  430. }
  431. NewAddr ++;
  432. Buffer ++;
  433. }
  434. return FALSE;
  435. }
  436. EFI_STATUS BufferWrite(UINT32 Offset, void *pData, UINT32 Length)
  437. {
  438. EFI_STATUS Status;
  439. UINT32 dwLoop;
  440. UINT32 Retry = 3;
  441. if (FALSE == IsNeedToWrite(gIndex.Base, Offset, (UINT8 *)pData, Length))
  442. {
  443. return EFI_SUCCESS;
  444. }
  445. do
  446. {
  447. (void)BufferWriteCommand(gIndex.Base, Offset, pData);
  448. Status = CompleteCheck(gIndex.Base, Offset, pData, Length);
  449. if (EFI_SUCCESS == Status)
  450. {
  451. for (dwLoop = 0; dwLoop < Length; dwLoop ++)
  452. {
  453. if (*(UINT8 *)(UINTN)(gIndex.Base + Offset + dwLoop) != *((UINT8 *)pData + dwLoop))
  454. {
  455. DEBUG((EFI_D_ERROR, "Flash_WriteUnit ERROR: address %x, buffer %x, flash %x\n", Offset, *((UINT8 *)pData + dwLoop), *(UINT8 *)(UINTN)(gIndex.Base + Offset + dwLoop)));
  456. Status = EFI_ABORTED;
  457. continue;
  458. }
  459. }
  460. }
  461. else
  462. {
  463. DEBUG((EFI_D_ERROR, "Flash_WriteUnit ERROR: complete check failed, %r\n", Status));
  464. continue;
  465. }
  466. } while ((Retry--) && EFI_ERROR(Status));
  467. return Status;
  468. }
  469. EFI_STATUS SectorErase(UINT32 Base, UINT32 Offset)
  470. {
  471. UINT8 gTemp[FLASH_MAX_UNIT];
  472. UINT64 dwLoop = FLASH_MAX_UNIT - 1;
  473. UINT32 Retry = 3;
  474. EFI_STATUS Status;
  475. do
  476. {
  477. gTemp[dwLoop] = 0xFF;
  478. }while (dwLoop --);
  479. do
  480. {
  481. (void)SectorEraseCommand(Base, Offset);
  482. Status = CompleteCheck(Base, Offset, (void *)gTemp, FLASH_MAX_UNIT);
  483. if (EFI_SUCCESS == Status)
  484. {
  485. if (width8IsAll(Base,Offset - (Offset % gFlashInfo[gIndex.InfIndex].BlockSize), gFlashInfo[gIndex.InfIndex].BlockSize, 0xFF))
  486. {
  487. return EFI_SUCCESS;
  488. }
  489. else
  490. {
  491. DEBUG((EFI_D_ERROR, "Flash_SectorErase ERROR: not all address equal 0xFF\n"));
  492. Status = EFI_ABORTED;
  493. continue;
  494. }
  495. }
  496. else
  497. {
  498. DEBUG((EFI_D_ERROR, "Flash_SectorErase ERROR: complete check failed, %r\n", Status));
  499. continue;
  500. }
  501. }while ((Retry--) && EFI_ERROR(Status));
  502. if(Retry)
  503. {
  504. //do nothing for pclint
  505. }
  506. return Status;
  507. }