开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
cfi.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：58k
源码类别：

DVD

开发平台：

C/C++

cfi.c：源码内容
  1. #include "gendef.h"
  2. #include "cfi.h"
  3. #include "osp.h"
  5. #ifndef SUCCESS
  6. #define SUCCESS RETOK
  7. #endif
  9. #ifndef FAILURE
  10. #define FAILURE RETFIAL1
  11. #endif
  13. #define WORDREG volatile UINT16 * 
  14. #define BYTEREG volatile UINT8 * 
  16. #define CFI_COMMAND_PREAMBLE_1  (0x5555)
  17. #define CFI_COMMAND_PREAMBLE_2  (0x2AAA)
  18. #define CFI_COMMAND_TYPE        (0x5555)
  19. #define CFI_COMMAND_PREAMBLE_1_DATA  (0xAA)
  20. #define CFI_COMMAND_PREAMBLE_2_DATA  (0x55)
  21. #define CFI_IDENTIFIER_CODES_ADDRESS  (0x5555)
  22. #define CFI_IDENTIFIER_CODES_COMMAND  (0x90)
  23. #define CFI_MANUF_ID            (0x0)
  24. #define CFI_DEVICE_ID           (0x1)
  25. #define CFI_SECTOR_PROTECT      (0x2)
  27. #define CFI_QUERY_ADDRESS  (0x55)
  28. #define CFI_QUERY_COMMAND  (0x98)
  30. #define CFI_QUERY_Q                     (0x10)
  31. #define CFI_QUERY_R                     (0x11)
  32. #define CFI_QUERY_Y                     (0x12)
  33. #define CFI_VENDOR_COMMAND_SET          (0x13)
  34. #define CFI_EXT_QUERY_TABLE_ADDRESS     (0x15)
  35. #define CFI_ALT_VENDOR_COMMAND_SET      (0x17)
  36. #define CFI_ALT_EXT_QUERY_TABLE_ADDRESS (0x19)
  38. #define CFI_2N_DEVICE_SIZE          (0x27)
  39. #define CFI_INTERFACE_CODE          (0x28)
  40. #define CFI_2N_MAX_BUFFER_BYTES     (0x2A)
  41. #define CFI_NUM_ERASE_BLOCK_REGIONS (0x2C)
  42. #define CFI_ERASE_BLOCK_REGION_INFO (0x2D)
  44. #define CFI_NUM_BLOCKS_IN_REGION_LO (0x0)
  45. #define CFI_NUM_BLOCKS_IN_REGION_HI (0x1)
  46. #define CFI_256X_BLOCK_SIZE_LO    (0x2)
  47. #define CFI_256X_BLOCK_SIZE_HI    (0x3)
  49. #define CFI_BOOT_SECTOR_FLAG        (0x4F)
  50. #define CFI_BOTTOM_BOOT             (0x02)
  51. #define CFI_TOP_BOOT                (0x03)
  53. #define CFI_NO_COMMAND_SET             (0)
  54. #define CFI_INTEL_EXTENDED_COMMAND_SET (1)
  55. #define CFI_AMD_STANDARD_COMMAND_SET   (2)
  56. #define CFI_INTEL_STANDARD_COMMAND_SET (3)
  57. #define CFI_AMD_EXTENDED_COMMAND_SET   (4)
  58. #define CFI_SST_COMMAND_SET            (0x0701)
  60. #define CFI_INTEL_ERASE_COMMAND_SETUP   (0x20)
  61. #define CFI_INTEL_ERASE_COMMAND_CONFIRM (0xD0)
  62. #define CFI_INTEL_STATUS_BUSY           (0x80)
  63. #define CFI_INTEL_RESET_TO_READ         (0xFF)
  64. #define CFI_INTEL_READ_STATUS           (0x70)
  65. #define CFI_INTEL_CLEAR_STATUS          (0x50)
  66. #define CFI_INTEL_COMMAND_ERROR         (0x30)
  67. #define CFI_INTEL_WRITE_WORD            (0x40)
  68. #define CFI_INTEL_WRITE_BUFFER_SETUP    (0xE8)
  69. #define CFI_INTEL_WRITE_CONFIRM         (0xD0)
  70. #define CFI_INTEL_READ_IDENTIFIER_CODES (0x90)
  72. #define CFI_AMD_COMMAND_PROGRAM       (0xA0)
  73. #define CFI_AMD_COMMAND_UNLOCK_BYPASS (0x20)
  74. #define CFI_AMD_COMMAND_ERASE         (0x80)
  75. #define CFI_AMD_UNLOCK_BYPASS_RESET_1 (0x90)
  76. #define CFI_AMD_UNLOCK_BYPASS_RESET_2 (0x00)
  77. #define CFI_AMD_ERASE_COMMAND_CHIP    (0x10)
  78. #define CFI_AMD_ERASE_COMMAND_SECTOR  (0x30)
  79. #define CFI_AMD_DQ7_BIT_MASK          (0x80)
  80. #define CFI_AMD_TOGGLE_BIT_MASK       (0x40)
  81. #define CFI_AMD_TIMEOUT_BIT_MASK      (0x20)
  83. INT32 CFIAMDBusy(T_CFIRomDevice *this);
  84. INT32 CFIAMDEraseChip(T_CFIRomDevice *this, UINT32 blocking);
  85. INT32 CFIAMDEraseSector(T_CFIRomDevice *this, UINT16 *targetAddress,
  86.                         UINT32 blocking);
  87. INT32 CFIAMDExtendedProgram(T_CFIRomDevice *this, UINT16 *targetAddress,
  88.                             UINT8 *sourceData, UINT32 numBytes);
  89. INT32 CFIAMDExtendedProgram(T_CFIRomDevice *this, UINT16 *targetAddress,
  90.                             UINT8 *sourceData, UINT32 numBytes);
  91. void  CFIAMDIDCodesEntry(T_CFIRomDevice *this);
  92. INT32 CFIAMDProgram(T_CFIRomDevice *this, UINT16 *targetAddress,
  93.                     UINT8 *sourceData, UINT32 numBytes);
  94. void  CFIAMDReset(T_CFIRomDevice *this);
  95. INT32 CFIIntelBusy(T_CFIRomDevice *this);
  96. INT32 CFIIntelEraseSector(T_CFIRomDevice *this, UINT16 *targetAddress,
  97.                           UINT32 block);
  98. INT32 CFIIntelExtendedProgram(T_CFIRomDevice *this, UINT16 *targetAddress,
  99.                               UINT8 *sourceData, UINT32 numBytes);
  100. void  CFIIntelIDCodesEntry(T_CFIRomDevice *this);
  101. INT32 CFIIntelProgram(T_CFIRomDevice *this, UINT16 *targetAddress,
  102.                       UINT8 *sourceData, UINT32 numBytes);
  103. void  CFIIntelReset(T_CFIRomDevice *this);
  104. UINT16 CFISetEndian(UINT16 value);
  106. static UINT32 EXCStartCriticalSection(void)
  107. {
  108. KB_OSPTaskDelay(1);
  109. return 0;
  110. }
  112. static void EXCEndCriticalSection(UINT32 State)
  113. {
  114. State = State;
  115. KB_OSPTaskDelay(1);
  116. }
  118. /****************************************************************************
  119. ** Functions
  120. ****************************************************************************/
  121. INT32 CFIIdentify(UINT16 *intRomAddress, T_CFIRomDevice *romDevice)
  122. {
  123. UINT32 numEraseBlockRegions;
  124. UINT32 index;
  125. UINT32 whichSector, numSectors, sectorSize;
  126. UINT32 sectorBaseAddress;
  127. UINT32 boolInvertGeometry;
  128. UINT32 bootSectorFlag;
  129. UINT32 irqState;
  131. irqState = EXCStartCriticalSection();
  133. /*
  134. ** Issue CFI Query command by writing 0x98 to address 0x55
  135. */
  136. ((WORDREG)intRomAddress)[CFI_QUERY_ADDRESS] = CFI_QUERY_COMMAND;
  138. if (((((WORDREG)intRomAddress)[CFI_QUERY_Q] & 0xFF) != 'Q') ||
  139. ((((WORDREG)intRomAddress)[CFI_QUERY_R] & 0xFF) != 'R') ||
  140. ((((WORDREG)intRomAddress)[CFI_QUERY_Y] & 0xFF) != 'Y'))
  141. {
  142. /*
  143. ** This doesn't appear to be a CFI ROM. However, there is a
  144. ** chance that we have an SST device. SST devices implement the CFI
  145. ** standard in a proprietary way. Test for this first before
  146. ** we give up.
  147. */
  148. ((WORDREG)intRomAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  149. ((WORDREG)intRomAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  150. ((WORDREG)intRomAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_QUERY_COMMAND;
  152. if (((((WORDREG)intRomAddress)[CFI_QUERY_Q] & 0xFF) != 'Q') ||
  153. ((((WORDREG)intRomAddress)[CFI_QUERY_R] & 0xFF) != 'R') ||
  154. ((((WORDREG)intRomAddress)[CFI_QUERY_Y] & 0xFF) != 'Y'))
  155. {    
  156. /*
  157. ** Not a CFI ROM, so return.
  158. */
  159. romDevice->baseAddress = 0;
  160. EXCEndCriticalSection(irqState);
  161. return FAILURE;
  162. }
  163. }
  165. /*
  166. ** Read the rom size.
  167. */  
  168. romDevice->romSize = (1 << ((WORDREG)intRomAddress)[CFI_2N_DEVICE_SIZE]);
  170. /*
  171. ** The rom base address mask will be the same as the
  172. ** inversion of the rom size -1. E.g. A 64 MBit rom
  173. ** will have a rom size of 0x800000, this makes the
  174. ** base address mask 0xFF800000.
  175. */
  176. romDevice->romBaseMask = ~(romDevice->romSize - 1);
  178. /*
  179. ** We should already have the ROM base address, but calculate
  180. ** it anyway.
  181. */
  182. romDevice->baseAddress = ((UINT32)intRomAddress & romDevice->romBaseMask);
  184. /*  
  185. ** Find the supported command set.
  186. */
  187. romDevice->commandSet = (0xFF & ((WORDREG)romDevice->baseAddress)[CFI_VENDOR_COMMAND_SET]);
  188. romDevice->commandSet |= (0xFF & ((WORDREG)romDevice->baseAddress)[CFI_VENDOR_COMMAND_SET+1]) << 8;
  190. /*
  191. ** Read the number of erase block regions.
  192. */
  193. numEraseBlockRegions = ((WORDREG)(romDevice->baseAddress))[CFI_NUM_ERASE_BLOCK_REGIONS];
  195. /*
  196. ** For each erase block region read the details on the sectors (blocks)
  197. ** contained in it and expand to fill the romDevice structure.
  198. */
  199. whichSector = 0;
  201. for(index=0; index < numEraseBlockRegions; index++)
  202. {
  203. numSectors = (0xFF & ((WORDREG)(romDevice->baseAddress))[CFI_ERASE_BLOCK_REGION_INFO + (4 * index) + CFI_NUM_BLOCKS_IN_REGION_LO]);
  204. numSectors |= (0xFF & ((WORDREG)(romDevice->baseAddress))[CFI_ERASE_BLOCK_REGION_INFO + (4 * index) + CFI_NUM_BLOCKS_IN_REGION_HI]) << 8;
  205. numSectors++;
  207. sectorSize = (0xFF & ((WORDREG)(romDevice->baseAddress))[CFI_ERASE_BLOCK_REGION_INFO + (4 * index) + CFI_256X_BLOCK_SIZE_LO]);
  208. sectorSize |= (0xFF & ((WORDREG)(romDevice->baseAddress))[CFI_ERASE_BLOCK_REGION_INFO + (4 * index) + CFI_256X_BLOCK_SIZE_HI]) << 8;
  209. sectorSize *= 256;
  211. do
  212. {
  213. romDevice->sectorSize[whichSector++] = sectorSize;
  214. numSectors--;
  215. }
  216. while(numSectors > 0 );
  217. }
  218. romDevice->numSectors = whichSector;  
  220. /*
  221. ** AMD and Fujitsu always list the device geometry for bottom boot devices.
  222. ** This then has to be inverted for top boot devices. Knowing if a device
  223. ** is top boot is an issue. For some devices you can read a CFI register,
  224. ** for others it has to be determined based on the device ID.
  225. */
  226. bootSectorFlag = ((WORDREG)(romDevice->baseAddress))[CFI_BOOT_SECTOR_FLAG];
  227. boolInvertGeometry = (bootSectorFlag == CFI_TOP_BOOT);
  229. /*
  230. ** Read max write buffer size.
  231. */
  232. romDevice->writeBufferDepth = (1 << ((WORDREG)(romDevice->baseAddress))[CFI_2N_MAX_BUFFER_BYTES]);
  234. /*
  235. ** Determine the programming algorithms to use and write the
  236. ** relevant function pointers to the romDevice structure.
  237. */  
  238. switch (romDevice->commandSet)
  239. {
  240.     case CFI_INTEL_EXTENDED_COMMAND_SET:
  241. romDevice->Busy = CFIIntelBusy;
  242. romDevice->Reset = CFIIntelReset;
  243. romDevice->IDCodesEntry = CFIIntelIDCodesEntry;
  244. romDevice->Program = CFIIntelExtendedProgram;
  245. romDevice->EraseSector = CFIIntelEraseSector;
  246. break;
  248.     case CFI_INTEL_STANDARD_COMMAND_SET:
  249. romDevice->Busy = CFIIntelBusy;
  250. romDevice->Reset = CFIIntelReset;
  251. romDevice->IDCodesEntry = CFIIntelIDCodesEntry;
  252. romDevice->Program = CFIIntelProgram;
  253. romDevice->EraseSector = CFIIntelEraseSector;
  254. break;
  256.     case CFI_AMD_STANDARD_COMMAND_SET:
  257. romDevice->Busy = CFIAMDBusy;
  258. romDevice->Reset = CFIAMDReset;
  259. romDevice->IDCodesEntry = CFIAMDIDCodesEntry;
  260. romDevice->Program = CFIAMDProgram;
  261. romDevice->EraseSector = CFIAMDEraseSector;
  262. break;
  264.     case CFI_AMD_EXTENDED_COMMAND_SET:
  265.     case CFI_SST_COMMAND_SET:
  266. romDevice->Busy = CFIAMDBusy;
  267. romDevice->Reset = CFIAMDReset;
  268. romDevice->IDCodesEntry = CFIAMDIDCodesEntry;
  269. romDevice->Program = CFIAMDExtendedProgram;
  270. romDevice->EraseSector = CFIAMDEraseSector;
  271. break;
  273.     default:
  274. /*      {
  275. UINT8 string[9];
  276. SUIPutMessage("nbaseAddress: 0x");
  277. APPIntToHexString(romDevice->baseAddress, string);
  278. SUIPutMessage(string);
  279. SUIPutMessage("tromSize: 0x");
  280. APPIntToHexString(romDevice->romSize, string);
  281. SUIPutMessage(string);
  282. SUIPutMessage("ncommandSet: 0x");
  283. APPIntToHexString(romDevice->commandSet, string);
  284. SUIPutMessage(string);
  285. SUIPutMessage("nnumSectors: 0x");
  286. APPIntToHexString(romDevice->numSectors, string);
  287. SUIPutMessage(string);
  288. SUIPutMessage("n0x13: 0x");
  289. APPIntToHexString(((WORDREG)romDevice->baseAddress)[CFI_VENDOR_COMMAND_SET], string);
  290. SUIPutMessage(string);
  291. SUIPutMessage("t0x14: 0x");
  292. APPIntToHexString(((WORDREG)romDevice->baseAddress)[CFI_VENDOR_COMMAND_SET + 1], string);
  293. SUIPutMessage(string);
  294. } */
  295. /*
  296. ** Put the ROM back into read array mode and return.
  297. */
  298. CFIAMDReset(romDevice);
  299. CFIIntelReset(romDevice);
  301. EXCEndCriticalSection(irqState);
  302. return(FAILURE);
  303. }
  305. /*
  306. ** Issue the read identifier codes command.
  307. */
  308. romDevice->Reset(romDevice);
  309. romDevice->IDCodesEntry(romDevice);
  310.     
  311. /*
  312. ** Read the manufacturer and device id.
  313. */
  314. romDevice->manufacturerID = ((WORDREG)(romDevice->baseAddress))[CFI_MANUF_ID];
  315. romDevice->deviceID = ((WORDREG)(romDevice->baseAddress))[CFI_DEVICE_ID];
  317. /*
  318. ** Set the name parameter of the ROM.
  319. **
  320. ** We also use this point to catch the special case for AMD top boot
  321. ** ROMs where the device geometry has to be inverted.
  322. */
  323. switch (romDevice->manufacturerID)
  324. {
  325. case CFI_MANUF_AMD:
  326. switch (romDevice->deviceID)
  327. {    
  328. case CFI_DEVICE_AM29LV400BT:
  329. romDevice->name = "AMD AM29LV400BT";
  330. break;
  331. case CFI_DEVICE_AM29LV400BB:
  332. romDevice->name = "AMD AM29LV400BB";
  333. break;
  334. case CFI_DEVICE_AM29LV800BT:
  335. romDevice->name = "AMD AM29LV800BT";
  336. break;
  337. case CFI_DEVICE_AM29LV800BB:
  338. romDevice->name = "AMD AM29LV800BB";
  339. break;
  340. case CFI_DEVICE_AM29LV160DB:
  341. romDevice->name = "AMD AM29LV160DB";
  342. break;
  343. case CFI_DEVICE_AM29LV160DT:
  344. romDevice->name = "AMD AM29LV160DT";
  345. boolInvertGeometry = TRUE; /* Special case */
  346. break;
  347. case CFI_DEVICE_AM29LV320DT:
  348. romDevice->name = "AMD AM29LV320DT";
  349. break;
  350. case CFI_DEVICE_AM29LV320DB:
  351. romDevice->name = "AMD AM29LV320DB";
  352. break;
  353. case CFI_DEVICE_AM29LV640DU:
  354. romDevice->name = "AMD AM29LV640DU";
  355. break;
  356. case CFI_DEVICE_AM29DL322DT:
  357. romDevice->name = "AMD AM29DL322DT";
  358. break;
  359. case CFI_DEVICE_AM29DL322DB:
  360. romDevice->name = "AMD AM29DL322DB";
  361. break;
  362. case CFI_DEVICE_AM29DL323DT:
  363. romDevice->name = "AMD AM29DL323DT";
  364. break;
  365. case CFI_DEVICE_AM29DL323DB:
  366. romDevice->name = "AMD AM29DL323DB";
  367. break;
  368. case CFI_DEVICE_AM29DL324DT:
  369. romDevice->name = "AMD AM29DL324DT";
  370. break;
  371. case CFI_DEVICE_AM29DL324DB:
  372. romDevice->name = "AMD AM29DL324DB";
  373. break;
  374. default:
  375. romDevice->name = "Unknown AMD";
  376. break;
  377. }                     
  378. break;
  380. case CFI_MANUF_FUJITSU:
  381. switch (romDevice->deviceID)
  382. {    
  383. case CFI_DEVICE_MBM29LV160BE:
  384. romDevice->name = "Fujitsu MBM29LV160BE";
  385. break;
  386. case CFI_DEVICE_MBM29LV160TE:
  387. romDevice->name = "Fujitsu MBM29LV160TE";
  388. boolInvertGeometry = TRUE; /* Special case */
  389. break;
  390. case CFI_DEVICE_MBM29DL32TF_BF:
  391. if(boolInvertGeometry)
  392. {
  393. romDevice->name = "Fujitsu MBM29DL32TF";
  394. }
  395. else
  396. {
  397. romDevice->name = "Fujitsu MBM29DL32BF";
  398. }
  399. break;
  400. default:
  401. romDevice->name = "Unknown Fujitsu";
  402. break;
  403. }
  404. break;
  406. case CFI_MANUF_INTEL:
  407. switch (romDevice->deviceID)
  408. {    
  409. case CFI_DEVICE_28F800C3T:
  410. romDevice->name = "Intel 28F800C3-T";
  411. break;
  412. case CFI_DEVICE_28F800C3B:
  413. romDevice->name = "Intel 28F800C3-B";
  414. break;
  415. case CFI_DEVICE_28F160C3T:
  416. romDevice->name = "Intel 28F160C3-T";
  417. break;
  418. case CFI_DEVICE_28F160C3B:
  419. romDevice->name = "Intel 28F160C3-B";
  420. break;
  421. case CFI_DEVICE_28F320C3T:
  422. romDevice->name = "Intel 28F320C3-T";
  423. break;
  424. case CFI_DEVICE_28F320C3B:
  425. romDevice->name = "Intel 28F320C3-B";
  426. break;
  427. case CFI_DEVICE_28F640C3T:
  428. romDevice->name = "Intel 28F640C3-T";
  429. break;
  430. case CFI_DEVICE_28F640C3B:
  431. romDevice->name = "Intel 28F640C3-B";
  432. break;
  433. case CFI_DEVICE_28F128J3A:
  434. romDevice->name = "Intel 28F128J3A";
  435. break;
  436. case CFI_DEVICE_28F320J3A:
  437. romDevice->name = "Intel 28F320J3A";
  438. break;
  439. case CFI_DEVICE_28F640J3A:
  440. romDevice->name = "Intel 28F640J3A";
  441. break;
  442. default:
  443. romDevice->name = "Unknown Intel";
  444. break;
  445. }
  446. break;
  448. case CFI_MANUF_SHARP:
  449. switch (romDevice->deviceID)
  450. {    
  451. case CFI_DEVICE_LH28F800BJ:
  452. romDevice->name = "Sharp LH28F800BJ";
  453. break;
  454. case CFI_DEVICE_LH28F160BJ:
  455. romDevice->name = "Sharp LH28F160BJ";
  456. break;
  457. case CFI_DEVICE_LH28F320BJ:
  458. romDevice->name = "Sharp LH28F320BJ";
  459. break;
  460. case CFI_DEVICE_LH28F160S3:
  461. romDevice->name = "Sharp LH28F160S3";
  462. break;
  463. default:
  464. romDevice->name = "Unknown Sharp";
  465. break;
  466. }
  467. break;
  469. case CFI_MANUF_ST:
  470. switch (romDevice->deviceID)
  471. {    
  472. case CFI_DEVICE_M29W160DT:
  473. romDevice->name = "ST M29W160DT";
  474. break;
  475. case CFI_DEVICE_M29W160DB:
  476. romDevice->name = "ST M29W160DB";
  477. break;
  478. case CFI_DEVICE_M29W320DT:
  479. romDevice->name = "ST M29W320DT";
  480. break;
  481. case CFI_DEVICE_M29W320DB:
  482. romDevice->name = "ST M29W320DB";
  483. break;
  484. case CFI_DEVICE_M29W640FT:
  485. romDevice->name = "ST M29W640FT";
  486. break;
  487. default:
  488. romDevice->name = "Unknown ST";
  489. break;
  490. }
  491. break;
  493. case CFI_MANUF_SST:
  494. switch (romDevice->deviceID)
  495. {    
  496. case CFI_DEVICE_SST39xF200A:
  497. romDevice->name = "SST SST39LF200/SST39VF200";
  498. break;
  499. case CFI_DEVICE_SST39xF400A:
  500. romDevice->name = "SST SST39LF400/SST39VF400";
  501. break;
  502. case CFI_DEVICE_SST39xF800A:
  503. romDevice->name = "SST SST39LF800/SST39VF800";
  504. break;
  505. case CFI_DEVICE_SST39xF160:
  506. romDevice->name = "SST SST39LF160/SST39VF160";
  507. break;
  508. default:
  509. romDevice->name = "Unknown SST";
  510. break;
  511. }
  512. break;
  514. case CFI_MANUF_TOSHIBA:
  515. switch (romDevice->deviceID)
  516. {    
  517. case CFI_DEVICE_TC58FVT160:
  518. romDevice->name = "Toshiba TC58FVT160";
  519. break;
  520. case CFI_DEVICE_TC58FVB160:
  521. romDevice->name = "Toshiba TC58FVB160";
  522. break;
  523. case CFI_DEVICE_TC58FVT321:
  524. romDevice->name = "Toshiba TC58FVT321";
  525. break;
  526. case CFI_DEVICE_TC58FVB321:
  527. romDevice->name = "Toshiba TC58FVB321";
  528. break;
  529. case CFI_DEVICE_TC58FVT641:
  530. romDevice->name = "Toshiba TC58FVT641";
  531. break;
  532. case CFI_DEVICE_TC58FVB641:
  533. romDevice->name = "Toshiba TC58FVB641";
  534. break;
  535. default:
  536. romDevice->name = "Unknown Toshiba";
  537. break;
  538. }
  539. break;
  541. default:
  542. romDevice->name = "Unknown Manufacturer";
  543. break;
  544. }
  545.   
  546. /*
  547. ** Specifically for AMD and Fujitsu ROMs invert the device geometry
  548. ** if required.
  549. */ 
  550. if (((romDevice->manufacturerID == CFI_MANUF_AMD) || (romDevice->manufacturerID == CFI_MANUF_FUJITSU)) && (boolInvertGeometry != FALSE))
  551. { 
  552. for(index=0; index < ((romDevice->numSectors - 1) / 2); index++)
  553. {
  554. sectorSize = romDevice->sectorSize[index];
  555. romDevice->sectorSize[index] = romDevice->sectorSize[romDevice->numSectors - index - 1];
  556. romDevice->sectorSize[romDevice->numSectors - index - 1] = sectorSize;
  557. }
  558. }
  559.   
  560. /*
  561. ** Determine what sectors are protected and get each sector base address.
  562. */
  563. sectorBaseAddress = romDevice->baseAddress;
  564. for (index=0; index < (romDevice->numSectors) ; index++)
  565. {
  566. romDevice->sector[index] = ((WORDREG)sectorBaseAddress)[CFI_SECTOR_PROTECT] & 0x1;
  567. romDevice->sectorAddr[index] = sectorBaseAddress;
  568. sectorBaseAddress += romDevice->sectorSize[index];
  569. }
  570.   
  571. /*
  572. ** Put the ROM back into read array mode and return.
  573. */
  574. romDevice->Reset(romDevice);
  576. EXCEndCriticalSection(irqState);
  577. return(SUCCESS);  
  578. }
  580. /****************************************************************************
  581. ** Function CFIAMDBusy(): This function tests to see if a FLASH ROM command is
  582. ** currently being executed. It will also test if a command has failed.
  583. **
  584. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  585. **
  586. ** Outputs:     None
  587. **
  588. ** Returns:     TRUE if the ROM is busy.
  589. **              FALSE if the ROM is not busy.
  590. **              FAILURE if the command failed.
  591. ****************************************************************************/
  592. INT32 CFIAMDBusy(T_CFIRomDevice *this)
  593. {
  594. UINT16 toggleOdd, toggleEven;
  595. INT32 nret;
  596. UINT32 irqState;
  598. irqState = EXCStartCriticalSection();
  600. /*
  601. ** If the toggle bit is still toggling then the ROM is still
  602. ** attempting to execute a command.
  603. */
  604. toggleOdd = (*((WORDREG)this->baseAddress) & CFI_AMD_TOGGLE_BIT_MASK);
  605. toggleEven = (*((WORDREG)this->baseAddress) & CFI_AMD_TOGGLE_BIT_MASK); 
  607. if (toggleOdd != toggleEven)
  608. {  
  609. /*
  610. ** The ROM is busy so set the return value to TRUE.
  611. ** This will change if the command has timed out..
  612. */
  613. nret = TRUE;
  615. /*
  616. ** Test to see if the command has timed out.
  617. */
  618. if ((*((WORDREG)this->baseAddress) & CFI_AMD_TIMEOUT_BIT_MASK) != 0)
  619. {
  620. /*
  621. ** Just because the operation has timed out
  622. ** does not necessarily mean that it has failed.
  623. ** Test to see if it has succeeded before returning.
  624. ** If the toggle bit is still toggling then it has failed.
  625. */
  626. toggleOdd = (*((WORDREG)this->baseAddress) & CFI_AMD_TOGGLE_BIT_MASK);
  627. toggleEven = (*((WORDREG)this->baseAddress) & CFI_AMD_TOGGLE_BIT_MASK); 
  629. if (toggleOdd != toggleEven)
  630. {
  631. /*
  632. ** Put the ROM back into normal read mode.
  633. */
  634. CFIAMDReset(this);
  636. /*
  637. ** Return FAILURE.
  638. */
  639. nret = FAILURE;
  640. }
  641. else
  642. {
  643. /*
  644. ** Return FALSE as the ROM is no longer busy.
  645. */
  646. nret = FALSE;
  647. }
  648. }
  649. }
  650. else
  651. {
  652. /*
  653. ** Return FALSE as the ROM is no longer busy.
  654. */
  655. nret = FALSE;
  656. }
  658. EXCEndCriticalSection(irqState);
  659. return nret;
  660. }
  662. /****************************************************************************
  663. ** Function CFIAMDEraseChip(): This function will erase all unprotected sectors
  664. ** of the specified AMD FLASH ROM. This is function can be either blocking
  665. ** or non-blocking. If the blocking mode is used then this function will not
  666. ** return control until either the ROM is erased or an error occurs. If a 
  667. ** non-blocking mode is used then the CFIAMDBusy() should be used to poll for
  668. ** completion.
  669. **
  670. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  671. **              block, CFI_BLOCKING if this function should block waiting
  672. **               for completion, or CFI_NON_BLOCKING if this function should
  673. **               return immediately after initiating the command.
  674. **
  675. ** Outputs:     None
  676. **
  677. ** Returns:     SUCCESS if the ROM is successfully erased.
  678. **              FAILURE if this function is not running in RAM, or the
  679. **               erase failed.
  680. ****************************************************************************/
  681. INT32 CFIAMDEraseChip(T_CFIRomDevice *this, UINT32 blocking)
  682. {
  683. INT32 nret;
  684. INT32 busy;
  685. UINT32 irqState;
  687. irqState = EXCStartCriticalSection();
  689. /*
  690. ** Enter the chip erase command.
  691. ** Pre-amble first, then erase command, then pre-amble again,
  692. ** then chip erase command.
  693. */
  694. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  695. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  696. ((WORDREG)this->baseAddress)[CFI_COMMAND_TYPE] = CFI_AMD_COMMAND_ERASE;
  697. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  698. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  699. ((WORDREG)this->baseAddress)[CFI_COMMAND_TYPE] = CFI_AMD_ERASE_COMMAND_CHIP;
  701. /*
  702. ** If this function was called in the non-blocking mode then
  703. ** return immediately, otherwise wait for the erase command
  704. ** to be completed.
  705. */
  706. if (blocking == CFI_BLOCKING)
  707. {
  708. /*
  709. ** Wait for the erase command to complete. CFIAMDBusy() will
  710. ** also report if the operation failed.
  711. */
  712. while ((busy = CFIAMDBusy(this)) == TRUE);
  713. if (busy == FAILURE)
  714. {
  715. nret = FAILURE;
  716. }
  717. else
  718. {
  719. nret = SUCCESS;
  720. }
  721. }
  722. else
  723. {
  724. nret = SUCCESS;
  725. }
  727. EXCEndCriticalSection(irqState);
  728. return nret;
  729. }
  731. /****************************************************************************
  732. ** Function CFIAMDEraseSector(): This function will erase the specified sector
  733. ** of an AMD FLASH ROM. This is function can be either blocking or
  734. ** non-blocking. If the blocking mode is used then this function will not
  735. ** return control until either the sector is erased or an error occurs. If a 
  736. ** non-blocking mode is used then the CFIAMDBusy() should be used to poll for
  737. ** completion.
  738. **
  739. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  740. **              targetAddress, an address inside the sector to be erased.
  741. **              blocking, CFI_BLOCKING or CFI_NON_BLOCKING
  742. **
  743. ** Outputs:     None
  744. **
  745. ** Returns:     SUCCESS if the ROM is successfully erased.
  746. **              FAILURE if this function is not running in RAM, or the
  747. **               erase failed.
  748. ****************************************************************************/
  749. INT32 CFIAMDEraseSector(T_CFIRomDevice *this, UINT16 *targetAddress,
  750.                         UINT32 blocking)
  751. {
  752. INT32 nret;
  753. INT32 busy;
  754. UINT32 irqState;
  756. irqState = EXCStartCriticalSection();
  758. /*
  759. ** Enter sector erase mode.
  760. ** Pre-amble first, then erase command, then pre-amble again,
  761. ** then sector to erase.
  762. */
  763. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  764. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  765. ((WORDREG)this->baseAddress)[CFI_COMMAND_TYPE] = CFI_AMD_COMMAND_ERASE;
  766. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  767. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  768. *((WORDREG)targetAddress) = CFI_AMD_ERASE_COMMAND_SECTOR;
  770. /*
  771. ** If this function was called in the non-blocking mode then
  772. ** return immediately, otherwise wait for the erase command
  773. ** to be completed.
  774. */
  775. if (blocking == CFI_BLOCKING)
  776. {
  777. /*
  778. ** Wait for the erase command to complete. CFIAMDBusy() will
  779. ** also report if the operation failed.
  780. */
  781. while ((busy = CFIAMDBusy(this)) == TRUE);
  782. if (busy == FAILURE)
  783. {
  784. nret = FAILURE;
  785. }
  786. else
  787. {
  788. nret = SUCCESS;
  789. }
  790. }
  791. else
  792. {
  793. nret = SUCCESS;
  794. }
  796. EXCEndCriticalSection(irqState);
  797. return nret;
  798. }
  800. /****************************************************************************
  801. ** Function CFIAMDExtendedProgram(): This function will program the
  802. ** specified area of an AMD FLASH ROM. This is a blocking function and will
  803. ** not return control until either the programming is complete or an error
  804. ** occurs.
  805. **
  806. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  807. **              targetAddress, the start address to program to in the ROM.
  808. **              sourceData, a pointer to the start of the data to be
  809. **               programmed.
  810. **              numBytes, the number of bytes to be programmed.
  811. **
  812. ** Outputs:     None
  813. **
  814. ** Returns:     SUCCESS if the programming is successful.
  815. **              FAILURE if this function is not running in RAM, or the
  816. **               programming failed. The programming is likely to fail
  817. **               if an attempt is made to program an area of memory that
  818. **               has not been erased. Specifically if an attempt is made
  819. **               to change a 0 to a 1.
  820. ****************************************************************************/
  821. INT32 CFIAMDExtendedProgram(T_CFIRomDevice *this, UINT16 *targetAddress,
  822.                             UINT8 *sourceData, UINT32 numBytes)
  823. {
  824. UINT32 i=0;
  825. UINT16 tempWord;
  826. UINT16 *writeAddress;
  827. UINT32 irqState;
  829. irqState = EXCStartCriticalSection();
  831. /************************************************************************
  832. ** Mis-aligned write detection and handling.
  833. ************************************************************************/
  835. /*
  836. ** Our FLASH ROM is a 16-bit device, however we may be asked to write an
  837. ** odd number of bytes, or the target address may not be on a 16-bit
  838. ** boundary. If this is the case write use read/modify/write cycles to
  839. ** write the misaligned data.
  840. */
  842. /*
  843. ** If the start address is mis-aligned, write the first
  844. ** byte to align the start address.
  845. */
  846. if (((UINT32)targetAddress & 1) != 0)
  847. {
  848. /*
  849. ** Calculate what to write to where, i.e. do the read and modify.
  850. ** The function parameters will also be adapted ready for the
  851. ** main body of this function.
  852. */
  853. targetAddress = (UINT16 *)((UINT32)targetAddress & ~1);
  854. tempWord = targetAddress[0] & CFISetEndian(0xFF00); // We are masking off the lowest addressed byte which is a different part of the 16-bit word on big and little endian machines.
  855. tempWord |= CFISetEndian((UINT16)sourceData[0]);
  857. writeAddress = targetAddress;
  858. targetAddress++;
  859. numBytes--;
  860. sourceData++;
  862. /*
  863. ** Write the data.
  864. */
  865. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  866. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  867. ((WORDREG)this->baseAddress)[CFI_COMMAND_TYPE] = CFI_AMD_COMMAND_PROGRAM;
  868. *((WORDREG)writeAddress) = tempWord;
  870. /*
  871. ** Poll for the programming completion.
  872. */
  873. while ( (*((WORDREG)writeAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  874. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  875. {
  876. /*
  877. ** Test to see if the programming operation
  878. ** has timed out.
  879. */
  880. if ((*((WORDREG)targetAddress) & CFI_AMD_TIMEOUT_BIT_MASK) != 0)
  881. {
  882. /*
  883. ** Just because the programming operation has timed
  884. ** out does not necessarily mean that it has failed.
  885. ** If DQ7 (data bit 7) is still the inverse of the data
  886. ** being programmed then the operation has failed.
  887. */
  888. if ( (*((WORDREG)targetAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  889. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  890. {
  891. /*
  892. ** Reset the FLASH ROM back to read mode.
  893. */
  894. CFIAMDReset(this);
  896. /*
  897. ** Test to see if the word actually programmed.
  898. */
  899. if(*((WORDREG)writeAddress) == tempWord)
  900. {
  901. break;
  902. }
  904. /*
  905. ** Return FAILURE, as the programming failed.
  906. ** The most likely reason being that an attempt
  907. ** was made to program a '0' to a '1'.
  908. */
  909. EXCEndCriticalSection(irqState);
  910. return FAILURE;
  911. }
  912. }
  913. }
  914. }
  916. /*
  917. ** If there is now an odd number of bytes to write, the last
  918. ** byte has to be written to align the data length.
  919. */
  920. if ((numBytes & 1) != 0)
  921. {
  922. tempWord = targetAddress[((numBytes-1) >> 1)] & CFISetEndian(0x00FF);
  923. tempWord |= CFISetEndian((UINT16)(sourceData[(numBytes-1)] << 8));
  924. writeAddress = &(targetAddress[((numBytes-1) >> 1)]);
  925. numBytes--;
  927. /*
  928. ** Write the data.
  929. */
  930. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  931. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  932. ((WORDREG)this->baseAddress)[CFI_COMMAND_TYPE] = CFI_AMD_COMMAND_PROGRAM;
  933. *((WORDREG)writeAddress) = tempWord;
  935. /*
  936. ** Poll for the programming completion.
  937. */
  938. while ( (*((WORDREG)writeAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  939. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  940. {
  941. /*
  942. ** Test to see if the programming operation
  943. ** has timed out.
  944. */
  945. if ((*((WORDREG)targetAddress) & CFI_AMD_TIMEOUT_BIT_MASK) != 0)
  946. {
  947. /*
  948. ** Just because the programming operation has timed
  949. ** out does not necessarily mean that it has failed.
  950. ** If DQ7 (data bit 7) is still the inverse of the data
  951. ** being programmed then the operation has failed.
  952. */
  953. if ( (*((WORDREG)targetAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  954. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  955. {
  956. /*
  957. ** Reset the FLASH ROM back to read mode.
  958. */
  959. CFIAMDReset(this);
  961. /*
  962. ** Test to see if the word actually programmed.
  963. */
  964. if(*((WORDREG)writeAddress) == tempWord)
  965. {
  966. break;
  967. }
  969. /*
  970. ** Return FAILURE, as the programming failed.
  971. ** The most likely reason being that an attempt
  972. ** was made to program a '0' to a '1'.
  973. */
  974. EXCEndCriticalSection(irqState);
  975. return FAILURE;
  976. }
  977. }
  978. }
  979. }
  981. /************************************************************************
  982. ** Aligned writes.
  983. ************************************************************************/
  985. /*
  986. ** Enter unlock bypass mode.
  987. ** Pre-amble first, then unlock bypass command.
  988. */
  989. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  990. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  991. ((WORDREG)this->baseAddress)[CFI_COMMAND_TYPE] = CFI_AMD_COMMAND_UNLOCK_BYPASS;
  993. while(i < numBytes)
  994. {
  995. /*
  996. ** Issue the program command
  997. */
  998. ((WORDREG)this->baseAddress)[0x0] = CFI_AMD_COMMAND_PROGRAM;
  1000. /*
  1001. ** Write the word. 
  1002. */
  1003. tempWord = CFISetEndian((UINT16)((sourceData[i]<<8) | sourceData[i+1]));
  1004. *((WORDREG)targetAddress) = tempWord;
  1006. /*
  1007. ** Poll for the programming completion.
  1008. */
  1009. while ( (*((WORDREG)targetAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  1010.             (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  1011. {
  1012. /*
  1013. ** Test to see if the programming operation
  1014. ** has timed out.
  1015. */
  1016. if ((*((WORDREG)targetAddress) & CFI_AMD_TIMEOUT_BIT_MASK) != 0)
  1017. {
  1018. /*
  1019. ** Just because the programming operation has timed
  1020. ** out does not necessarily mean that it has failed.
  1021. ** If DQ7 (data bit 7) is still the inverse of the data
  1022. ** being programmed then the operation has failed.
  1023. */
  1024. if ( (*((WORDREG)targetAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  1025. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  1026. {
  1027. /*
  1028. ** Reset the FLASH ROM back to read mode.
  1029. */
  1030. *((WORDREG)this->baseAddress) = CFI_AMD_UNLOCK_BYPASS_RESET_1;
  1031. *((WORDREG)this->baseAddress) = CFI_AMD_UNLOCK_BYPASS_RESET_2;
  1033. /*
  1034. ** Return FAILURE, as the programming failed.
  1035. ** The most likely reason being that an attempt
  1036. ** was made to program a '0' to a '1'.
  1037. */
  1038. EXCEndCriticalSection(irqState);
  1039. return FAILURE;
  1040. }
  1041. }
  1042. }
  1044. /*
  1045. ** Increment the source and target addresses.
  1046. */
  1047. targetAddress++;
  1048. i += 2;
  1049. }
  1051. /*
  1052. ** Reset the FLASH ROM back to read mode.
  1053. */
  1054. *((WORDREG)this->baseAddress) = CFI_AMD_UNLOCK_BYPASS_RESET_1;
  1055. *((WORDREG)this->baseAddress) = CFI_AMD_UNLOCK_BYPASS_RESET_2;
  1057. /*
  1058. ** Return SUCCESS.
  1059. */
  1060. EXCEndCriticalSection(irqState);
  1061. return SUCCESS;
  1062. }
  1064. /****************************************************************************
  1065. ** Function CFIAMDIDCodesEntry(): This function places an AMD compatible
  1066. ** FLASH ROM in the read indentify codes mode,
  1067. **
  1068. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  1069. **
  1070. ** Outputs:     None
  1071. **
  1072. ** Returns:     Nothing.
  1073. ****************************************************************************/
  1074. void CFIAMDIDCodesEntry(T_CFIRomDevice *this)
  1075. {
  1076. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  1077. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  1078. ((WORDREG)this->baseAddress)[CFI_IDENTIFIER_CODES_ADDRESS] = CFI_IDENTIFIER_CODES_COMMAND;
  1079. }
  1081. /****************************************************************************
  1082. ** Function CFIAMDProgram(): This function will program the
  1083. ** specified area of an AMD FLASH ROM. This is a blocking function and will
  1084. ** not return control until either the programming is complete or an error
  1085. ** occurs.
  1086. **
  1087. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  1088. **              targetAddress, the start address to program to in the ROM.
  1089. **              sourceData, a pointer to the start of the data to be
  1090. **               programmed.
  1091. **              numBytes, the number of bytes to be programmed.
  1092. **
  1093. ** Outputs:     None
  1094. **
  1095. ** Returns:     SUCCESS if the programming is successful.
  1096. **              FAILURE if this function is not running in RAM, or the
  1097. **               programming failed. The programming is likely to fail
  1098. **               if an attempt is made to program an area of memory that
  1099. **               has not been erased. Specifically if an attempt is made
  1100. **               to change a 0 to a 1.
  1101. ****************************************************************************/
  1102. INT32 CFIAMDProgram(T_CFIRomDevice *this, UINT16 *targetAddress,
  1103.                     UINT8 *sourceData, UINT32 numBytes)
  1104. {
  1105. UINT32 i=0;
  1106. UINT16 tempWord;
  1107. UINT16 *writeAddress;
  1108. UINT32 irqState;
  1110. irqState = EXCStartCriticalSection();
  1112. /************************************************************************
  1113. ** Mis-aligned write detection and handling.
  1114. ************************************************************************/
  1116. /*
  1117. ** Our FLASH ROM is a 16-bit device, however we may be asked to write an
  1118. ** odd number of bytes, or the target address may not be on a 16-bit
  1119. ** boundary. If this is the case write use read/modify/write cycles to
  1120. ** write the misaligned data.
  1121. */
  1123. /*
  1124. ** If the start address is mis-aligned, write the first
  1125. ** byte to align the start address.
  1126. */
  1127. if (((UINT32)targetAddress & 1) != 0)
  1128. {
  1129. /*
  1130. ** Calculate what to write to where, i.e. do the read and modify.
  1131. ** The function parameters will also be adapted ready for the
  1132. ** main body of this function.
  1133. */
  1134. targetAddress = (UINT16 *)((UINT32)targetAddress & ~1);
  1135. tempWord = targetAddress[0] & CFISetEndian(0xFF00); // We are masking off the lowest addressed byte which is a different part of the 16-bit word on big and little endian machines.
  1136. tempWord |= CFISetEndian((UINT16)sourceData[0]);
  1138. writeAddress = targetAddress;
  1139. targetAddress++;
  1140. numBytes--;
  1141. sourceData++;
  1143. /*
  1144. ** Write the data.
  1145. */
  1146. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  1147. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  1148. ((WORDREG)this->baseAddress)[CFI_COMMAND_TYPE] = CFI_AMD_COMMAND_PROGRAM;
  1149. *((WORDREG)writeAddress) = tempWord;
  1151. /*
  1152. ** Poll for the programming completion.
  1153. */
  1154. while ( (*((WORDREG)writeAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  1155. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  1156. {
  1157. /*
  1158. ** Test to see if the programming operation
  1159. ** has timed out.
  1160. */
  1161. if ((*((WORDREG)targetAddress) & CFI_AMD_TIMEOUT_BIT_MASK) != 0)
  1162. {
  1163. /*
  1164. ** Just because the programming operation has timed
  1165. ** out does not necessarily mean that it has failed.
  1166. ** If DQ7 (data bit 7) is still the inverse of the data
  1167. ** being programmed then the operation has failed.
  1168. */
  1169. if ( (*((WORDREG)targetAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  1170. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  1171. {
  1172. /*
  1173. ** Reset the FLASH ROM back to read mode.
  1174. */
  1175. CFIAMDReset(this);
  1177. /*
  1178. ** Test to see if the word actually programmed.
  1179. */
  1180. if(*((WORDREG)writeAddress) == tempWord)
  1181. {
  1182. break;
  1183. }
  1185. /*
  1186. ** Return FAILURE, as the programming failed.
  1187. ** The most likely reason being that an attempt
  1188. ** was made to program a '0' to a '1'.
  1189. */
  1190. EXCEndCriticalSection(irqState);
  1191. return FAILURE;
  1192. }
  1193. }
  1194. }
  1195. }
  1197. /*
  1198. ** If there is now an odd number of bytes to write, the last
  1199. ** byte has to be written to align the data length.
  1200. */
  1201. if ((numBytes & 1) != 0)
  1202. {
  1203. tempWord = targetAddress[((numBytes-1) >> 1)] & CFISetEndian(0x00FF);
  1204. tempWord |= CFISetEndian((UINT16)(sourceData[(numBytes-1)] << 8));
  1205. writeAddress = &(targetAddress[((numBytes-1) >> 1)]);
  1206. numBytes--;
  1208. /*
  1209. ** Write the data.
  1210. */
  1211. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  1212. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  1213. ((WORDREG)this->baseAddress)[CFI_COMMAND_TYPE] = CFI_AMD_COMMAND_PROGRAM;
  1214. *((WORDREG)writeAddress) = tempWord;
  1216. /*
  1217. ** Poll for the programming completion.
  1218. */
  1219. while ( (*((WORDREG)writeAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  1220. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  1221. {
  1222. /*
  1223. ** Test to see if the programming operation
  1224. ** has timed out.
  1225. */
  1226. //if ((*((WORDREG)targetAddress) & CFI_AMD_TIMEOUT_BIT_MASK) != 0)
  1227. if ((*((WORDREG)writeAddress) & CFI_AMD_TIMEOUT_BIT_MASK) != 0)
  1228. {
  1229. /*
  1230. ** Just because the programming operation has timed
  1231. ** out does not necessarily mean that it has failed.
  1232. ** If DQ7 (data bit 7) is still the inverse of the data
  1233. ** being programmed then the operation has failed.
  1234. */
  1235. //if ( (*((WORDREG)targetAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  1236. if ( (*((WORDREG)writeAddress) & CFI_AMD_DQ7_BIT_MASK) !=
  1237. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  1238. {
  1239. /*
  1240. ** Reset the FLASH ROM back to read mode.
  1241. */
  1242. CFIAMDReset(this);
  1244. /*
  1245. ** Return FAILURE, as the programming failed.
  1246. ** The most likely reason being that an attempt
  1247. ** was made to program a '0' to a '1'.
  1248. */
  1249. EXCEndCriticalSection(irqState);
  1250. return FAILURE;
  1251. }
  1252. }
  1253. }
  1254. }
  1256. /************************************************************************
  1257. ** Aligned writes.
  1258. ************************************************************************/
  1259. while(i < numBytes)
  1260. {
  1261. /*
  1262. ** Write the data.
  1263. */
  1264. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_1] = CFI_COMMAND_PREAMBLE_1_DATA;
  1265. ((WORDREG)this->baseAddress)[CFI_COMMAND_PREAMBLE_2] = CFI_COMMAND_PREAMBLE_2_DATA;
  1266. ((WORDREG)this->baseAddress)[CFI_COMMAND_TYPE] = CFI_AMD_COMMAND_PROGRAM;
  1267. tempWord = CFISetEndian((UINT16)((sourceData[i]<<8) | sourceData[i+1]));
  1268. *((WORDREG)targetAddress) = tempWord;
  1269. /*
  1270. ** Poll for the programming completion.
  1271. */
  1272. while ( (*((WORDREG)targetAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  1273.             (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  1274. {
  1275. /*
  1276. ** Test to see if the programming operation
  1277. ** has timed out.
  1278. */
  1279. if ((*((WORDREG)targetAddress) & CFI_AMD_TIMEOUT_BIT_MASK) != 0)
  1280. {
  1281. /*
  1282. ** Just because the programming operation has timed
  1283. ** out does not necessarily mean that it has failed.
  1284. ** If DQ7 (data bit 7) is still the inverse of the data
  1285. ** being programmed then the operation has failed.
  1286. */
  1287. if ( (*((WORDREG)targetAddress) & CFI_AMD_DQ7_BIT_MASK) != 
  1288. (tempWord & CFI_AMD_DQ7_BIT_MASK) )
  1289. {
  1290. /*
  1291. ** Reset the FLASH ROM back to read mode.
  1292. */
  1293. CFIAMDReset(this);
  1295. /*
  1296. ** Return FAILURE, as the programming failed.
  1297. ** The most likely reason being that an attempt
  1298. ** was made to program a '0' to a '1'.
  1299. */
  1300. EXCEndCriticalSection(irqState);
  1301. return FAILURE;
  1302. }
  1303. }
  1304. }
  1306. /*
  1307. ** Increment the source and target addresses.
  1308. */
  1309. targetAddress++;
  1310. i += 2;
  1311. }
  1313. /*
  1314. ** Reset the FLASH ROM back to read mode.
  1315. */
  1316. CFIAMDReset(this);
  1318. /*
  1319. ** Return SUCCESS.
  1320. */
  1321. EXCEndCriticalSection(irqState);
  1322. return SUCCESS;
  1323. }
  1325. /****************************************************************************
  1326. ** Function CFIAMDReset(): This function resets an AMD compatible FLASH ROM
  1327. ** back to read array mode.. 
  1328. **
  1329. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  1330. **
  1331. ** Outputs:     None
  1332. **
  1333. ** Returns:     Nothing.
  1334. ****************************************************************************/
  1335. void CFIAMDReset(T_CFIRomDevice *this)
  1336. {
  1337. *(WORDREG)this->baseAddress = 0xF0;
  1338. }
  1340. /****************************************************************************
  1341. ** Function CFIIntelBusy(): This function tests to see if a FLASH ROM command
  1342. ** is currently being executed. 
  1343. **
  1344. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  1345. **
  1346. ** Outputs:     None
  1347. **
  1348. ** Returns:     TRUE if the ROM is busy.
  1349. **              FALSE if the ROM is not busy.
  1350. ****************************************************************************/
  1351. INT32 CFIIntelBusy(T_CFIRomDevice *this)
  1352. {
  1353. return !(*((WORDREG)this->baseAddress) & CFI_INTEL_STATUS_BUSY);
  1354. }
  1356. /****************************************************************************
  1357. ** Function CFIIntelEraseSector(): This function will erase the specified
  1358. ** sector of an Intel FLASH ROM. This is function can be either blocking or
  1359. ** non-blocking. If the blocking mode is used then this function will not
  1360. ** return control until either the sector is erased or an error occurs. If a 
  1361. ** non-blocking mode is used then the CFIIntelBusy() should be used to poll for
  1362. ** completion.
  1363. **
  1364. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  1365. **              targetAddress, an address inside the sector to be erased.
  1366. **              blocking, CFI_BLOCKING or CFI_NON_BLOCKING
  1367. **
  1368. ** Outputs:     None
  1369. **
  1370. ** Returns:     SUCCESS if the ROM is successfully erased.
  1371. **              FAILURE if this function is not running in RAM, or the
  1372. **               erase failed.
  1373. ****************************************************************************/
  1374. INT32 CFIIntelEraseSector(T_CFIRomDevice *this, UINT16 *targetAddress,
  1375.                           UINT32 blocking)
  1376. {  
  1377. INT32 nret;
  1378. UINT32 irqState;
  1380. irqState = EXCStartCriticalSection();
  1382. /*
  1383. ** Enter sector erase mode.
  1384. ** Block erase setup first, then block erase confirm.
  1385. */
  1386. *((WORDREG)targetAddress) = CFI_INTEL_ERASE_COMMAND_SETUP;
  1387. *((WORDREG)targetAddress) = CFI_INTEL_ERASE_COMMAND_CONFIRM;
  1389. /*
  1390. ** If this function was called in the non-blocking mode then
  1391. ** return immediately, otherwise wait for the erase command
  1392. ** to be completed.
  1393. */
  1394. if (blocking == CFI_BLOCKING)
  1395. {
  1396. /*
  1397. ** Wait for the erase command to be completed.
  1398. */
  1399. while (CFIIntelBusy(this));
  1401. /*
  1402. ** Test for an error.
  1403. */
  1404. if (*((WORDREG)targetAddress) != 0x80)
  1405. {
  1406. /*
  1407. ** An error occurred. Clear the status register, put 
  1408. ** the device back into read mode and return.
  1409. */
  1410. *((WORDREG)this->baseAddress) = CFI_INTEL_CLEAR_STATUS;
  1411. *((WORDREG)this->baseAddress) = CFI_INTEL_RESET_TO_READ;
  1413. nret = FAILURE;
  1414. }
  1415. else
  1416. {
  1417. /*
  1418. ** The erase command completed successfully. Put the 
  1419. ** device back into read mode and return.
  1420. */
  1421. CFIIntelReset(this);
  1423. nret = SUCCESS;
  1424. }
  1425. }
  1426. else
  1427. {
  1428. nret = SUCCESS;
  1429. }
  1431. EXCEndCriticalSection(irqState);
  1432. return nret;
  1433. }
  1435. /****************************************************************************
  1436. ** Function CFIIntelExtendedProgram(): This function will program the specified area
  1437. ** of an Intel FLASH ROM. This is a blocking function and will not
  1438. ** return control until either the programming is complete or an error occurs.
  1439. **
  1440. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  1441. **              targetAddress, the start address to program in the ROM.
  1442. **              sourceData, a pointer to the start of the data to be
  1443. **               programmed.
  1444. **              numBytes, the number of bytes to be programmed.
  1445. **
  1446. ** Outputs:     None
  1447. **
  1448. ** Returns:     SUCCESS if the programming is successful.
  1449. **              FAILURE if this function is not running in RAM, or the
  1450. **               programming failed. The programming is likely to fail
  1451. **               if an attempt is made to program an area of memory that
  1452. **               has not been erased. Specifically if an attempt is made
  1453. **               to change a 0 to a 1.
  1454. ****************************************************************************/
  1455. INT32 CFIIntelExtendedProgram(T_CFIRomDevice *this, UINT16 *targetAddress, 
  1456.                               UINT8 *sourceData, UINT32 numBytes)
  1457. {
  1458. UINT32 i=0, count;
  1459. INT32 nret;
  1460. UINT16 tempWord;
  1461. UINT16 *sectorAddress;
  1462. UINT32 irqState;
  1464. irqState = EXCStartCriticalSection();
  1466. /************************************************************************
  1467. ** Mis-aligned write detection and handling.
  1468. ************************************************************************/
  1470. /*
  1471. ** Our FLASH ROM is a 16-bit device, however we may be asked to write an
  1472. ** odd number of bytes, or the target address may not be on a 16-bit
  1473. ** boundary. If this is the case write use read/modify/write cycles to
  1474. ** write the misaligned data.
  1475. */
  1476. if (((UINT32)targetAddress & 1) != 0)
  1477. {
  1478. /*
  1479. ** The start address is mis-aligned, write the first
  1480. ** byte to align the start address.
  1481. */
  1483. /*
  1484. ** Read and modify the first word.
  1485. */
  1486. targetAddress = (UINT16 *)((UINT32)targetAddress & ~1);
  1487. tempWord = targetAddress[0] & CFISetEndian(0xFF00);
  1488. tempWord |= CFISetEndian(sourceData[0]);
  1490. /*
  1491. ** Write the word write command.
  1492. */
  1493. *((WORDREG)targetAddress) = CFI_INTEL_WRITE_WORD;
  1495. /*
  1496. ** Write the data
  1497. */
  1498. *((WORDREG)targetAddress) = tempWord;
  1500. /*
  1501. ** Poll for completion.
  1502. */
  1503. while (CFIIntelBusy(this));
  1505. targetAddress++;
  1506. numBytes--;
  1507. sourceData++;
  1508. }
  1510. if ((numBytes & 1) != 0)
  1511. {
  1512. /*
  1513. ** The data length is now mis-aligned, write the last byte
  1514. ** to align to data length.
  1515. */
  1517. /*
  1518. ** Put the device back into read mode.
  1519. */
  1520. *((WORDREG)this->baseAddress) = CFI_INTEL_RESET_TO_READ;
  1522. tempWord = targetAddress[((numBytes-1) >> 1)] & CFISetEndian(0x00FF);
  1523. tempWord |= CFISetEndian((UINT16)(sourceData[(numBytes-1)] << 8));
  1525. /*
  1526. ** Write the word write command.
  1527. */
  1528. ((WORDREG)targetAddress)[((numBytes-1) >> 1)] = CFI_INTEL_WRITE_WORD;
  1530. /*
  1531. ** Write the data
  1532. */
  1533. ((WORDREG)targetAddress)[((numBytes-1) >> 1)] = tempWord;
  1535. /*
  1536. ** Poll for completion.
  1537. */
  1538. while (CFIIntelBusy(this));
  1540. numBytes--;
  1541. }
  1543. /************************************************************************
  1544. **  Aligned writes over sector boundaries.
  1545. ************************************************************************/
  1547. /*
  1548. ** We cannot do buffered writes over sector boundaries. This may
  1549. ** happen if the targetAddress is not on a 32 byte boundary. If
  1550. ** this is the case the first X bytes before a 32 byte boundary
  1551. ** are written a word at a time. Buffered writes will then
  1552. ** happen on sector boundaries.
  1553. */
  1554. if (((UINT32)targetAddress & 0x1F) != 0)
  1555. {
  1556. /*
  1557. ** Calculate the number of words to write to
  1558. ** get to a 32 bytes boundary. Also test to 
  1559. ** see that this isn't greater than the 
  1560. ** number of bytes to transfer.
  1561. */
  1562. count = (0x20 - ((UINT32)targetAddress & 0x1F)) >> 1;
  1563. if (count > (numBytes >> 1))
  1564. {
  1565. count = numBytes >> 1;
  1566. }
  1568. /*
  1569. ** Write the data.
  1570. */
  1571. while (count-- != 0)
  1572. {
  1573. /*
  1574. ** Write the word write command.
  1575. */
  1576. *((WORDREG)targetAddress) = CFI_INTEL_WRITE_WORD;
  1578. /*
  1579. ** Write the data
  1580. */
  1581. *((WORDREG)targetAddress) = CFISetEndian((UINT16)((sourceData[i]<<8) | sourceData[i+1]));
  1583. /*
  1584. ** Poll for completion.
  1585. */
  1586. while (CFIIntelBusy(this));
  1588. targetAddress++;
  1589. i += 2;
  1590. }
  1591. }
  1593. /************************************************************************
  1594. **  Aligned writes not over sector boundaries.
  1595. ************************************************************************/
  1597. while(i < numBytes)
  1598. {
  1599. /*
  1600. ** We write 16 bits at a time, so convert the byte count to a word
  1601. ** count.
  1602. */
  1603. count = (numBytes - i) >> 1;
  1605. /*
  1606. ** We can only write a maximum of 32 bytes (16 words) at a time.
  1607. */
  1608. if (count > 16)
  1609. {
  1610. count = 16;
  1611. }
  1613. /*
  1614. ** Store the sector address.
  1615. */
  1616. sectorAddress = targetAddress;
  1618. /*
  1619. ** Write the buffer setup command until it is accepted.
  1620. */
  1621. do 
  1622. {
  1623. *((WORDREG)targetAddress) = CFI_INTEL_WRITE_BUFFER_SETUP;
  1624. } while ((*((WORDREG)targetAddress) & CFI_INTEL_STATUS_BUSY) == 0);
  1626. /*
  1627. ** Write the word count - 1.
  1628. */
  1629. *((WORDREG)targetAddress) = (UINT16)(count - 1);
  1631. /*
  1632. ** Write the data.
  1633. */
  1634. while (count-- != 0)
  1635. {
  1636. *((WORDREG)targetAddress) = CFISetEndian((UINT16)((sourceData[i]<<8) | sourceData[i+1]));
  1637. targetAddress++;
  1638. i += 2;
  1639. }
  1641. /*
  1642. ** Issue the write confirm command.
  1643. */
  1644. *((WORDREG)sectorAddress) = CFI_INTEL_WRITE_CONFIRM;
  1645. }
  1647. /*
  1648. ** Poll for completion of the write.
  1649. */
  1650. while (CFIIntelBusy(this));
  1652. /*
  1653. ** Test for an error.
  1654. */
  1655. if (*((WORDREG)this->baseAddress) != 0x80)
  1656. {
  1657. /*
  1658. ** An error occurred. Clear the status register, put 
  1659. ** the device back into read mode and return.
  1660. */
  1661. *((WORDREG)this->baseAddress) = CFI_INTEL_CLEAR_STATUS;
  1662. *((WORDREG)this->baseAddress) = CFI_INTEL_RESET_TO_READ;
  1664. nret = FAILURE;
  1665. }
  1666. else
  1667. {
  1668. /*
  1669. ** The erase command completed successfully. Put the 
  1670. ** device back into read mode and return.
  1671. */
  1672. *((WORDREG)this->baseAddress) = CFI_INTEL_RESET_TO_READ;
  1674. nret = SUCCESS;
  1675. }
  1677. EXCEndCriticalSection(irqState);
  1678. return nret;
  1679. }
  1681. /****************************************************************************
  1682. ** Function CFIIntelIDCodesEntry(): This function places an Intel compatible
  1683. ** FLASH ROM in the read indentify codes mode,
  1684. **
  1685. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  1686. **
  1687. ** Outputs:     None
  1688. **
  1689. ** Returns:     Nothing.
  1690. ****************************************************************************/
  1691. void CFIIntelIDCodesEntry(T_CFIRomDevice *this)
  1692. {
  1693. ((WORDREG)this->baseAddress)[CFI_IDENTIFIER_CODES_ADDRESS] = CFI_IDENTIFIER_CODES_COMMAND;
  1694. }
  1696. /****************************************************************************
  1697. ** Function CFIIntelProgram(): This function will program the specified area
  1698. ** of an Intel compatible FLASH ROM. This is a blocking function and will not
  1699. ** return control until either the programming is complete or an error occurs.
  1700. **
  1701. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  1702. **              targetAddress, the start address to program to in the ROM.
  1703. **              sourceData, a pointer to the start of the data to be
  1704. **               programmed.
  1705. **              numBytes, the number of bytes to be programmed.
  1706. **
  1707. ** Outputs:     None
  1708. **
  1709. ** Returns:     SUCCESS if the programming is successful.
  1710. **              FAILURE if this function is not running in RAM, or the
  1711. **               programming failed. The programming is likely to fail
  1712. **               if an attempt is made to program an area of memory that
  1713. **               has not been erased. Specifically if an attempt is made
  1714. **               to change a 0 to a 1.
  1715. ****************************************************************************/
  1716. INT32 CFIIntelProgram(T_CFIRomDevice *this, UINT16 *targetAddress, 
  1717.                       UINT8 *sourceData, UINT32 numBytes)
  1718. {
  1719. UINT32 count;
  1720. INT32 nret;
  1721. UINT16 tempWord;
  1722. UINT32 irqState;
  1724. irqState = EXCStartCriticalSection();
  1726. /************************************************************************
  1727. ** Mis-aligned write detection and handling.
  1728. ************************************************************************/
  1730. /*
  1731. ** Our FLASH ROM is a 16-bit device, however we may be asked to write an
  1732. ** odd number of bytes, or the target address may not be on a 16-bit
  1733. ** boundary. If this is the case use read/modify/write cycles to
  1734. ** write the misaligned data.
  1735. */
  1736. if (((UINT32)targetAddress & 1) != 0)
  1737. {
  1738. /*
  1739. ** The start address is mis-aligned, write the first
  1740. ** byte to align the start address.
  1741. */
  1743. /*
  1744. ** Read and modify the first word.
  1745. */
  1746. targetAddress = (UINT16 *)((UINT32)targetAddress & ~1);
  1747. tempWord = targetAddress[0] & CFISetEndian(0xFF00);
  1748. tempWord |= CFISetEndian(sourceData[0]);
  1750. /*
  1751. ** Write the word write command.
  1752. */
  1753. *((WORDREG)targetAddress) = CFI_INTEL_WRITE_WORD;
  1755. /*
  1756. ** Write the data
  1757. */
  1758. *((WORDREG)targetAddress) = tempWord;
  1760. /*
  1761. ** Poll for completion.
  1762. */
  1763. while (CFIIntelBusy(this));
  1765. targetAddress++;
  1766. numBytes--;
  1767. sourceData++;
  1768. }
  1770. if ((numBytes & 1) != 0)
  1771. {
  1772. /*
  1773. ** The data length is now mis-aligned, write the last byte
  1774. ** to align to data length.
  1775. */
  1777. /*
  1778. ** Put the device back into read mode.
  1779. */
  1780. *((WORDREG)this->baseAddress) = CFI_INTEL_RESET_TO_READ;
  1782. tempWord = targetAddress[((numBytes-1) >> 1)] & CFISetEndian(0x00FF);
  1783. tempWord |= CFISetEndian((UINT16)(sourceData[(numBytes-1)] << 8));
  1785. /*
  1786. ** Write the word write command.
  1787. */
  1788. ((WORDREG)targetAddress)[((numBytes-1) >> 1)] = CFI_INTEL_WRITE_WORD;
  1790. /*
  1791. ** Write the data
  1792. */
  1793. ((WORDREG)targetAddress)[((numBytes-1) >> 1)] = tempWord;
  1795. /*
  1796. ** Poll for completion.
  1797. */
  1798. while (CFIIntelBusy(this));
  1800. numBytes--;
  1801. }
  1803. /************************************************************************
  1804. ** Main programming loop.
  1805. ************************************************************************/
  1807. /*
  1808. ** Convert the number of bytes to program to a number of 
  1809. ** 16-bit words to program.
  1810. */
  1811. count = numBytes >> 1;
  1813. /*
  1814. ** Write the data.
  1815. */
  1816. while (count-- != 0)
  1817. {
  1818. /*
  1819. ** Wait for the device to be ready.
  1820. */
  1821. while (CFIIntelBusy(this));
  1823. /*
  1824. ** Write the word write command.
  1825. */
  1826. *((WORDREG)targetAddress) = CFI_INTEL_WRITE_WORD;
  1828. /*
  1829. ** Write the data
  1830. */
  1831. *((WORDREG)targetAddress) = CFISetEndian((UINT16)((sourceData[0]<<8) | sourceData[1]));
  1832. targetAddress++;
  1833. sourceData += 2;
  1834. }
  1836. /*
  1837. ** Poll for completion of the write.
  1838. */
  1839. while (CFIIntelBusy(this));
  1841. /*
  1842. ** Test for an error.
  1843. */
  1844. if (*((WORDREG)this->baseAddress) != 0x80)
  1845. {
  1846. /*
  1847. ** An error occurred. Clear the status register, put 
  1848. ** the device back into read mode and return.
  1849. */
  1850. *((WORDREG)this->baseAddress) = CFI_INTEL_CLEAR_STATUS;
  1851. *((WORDREG)this->baseAddress) = CFI_INTEL_RESET_TO_READ;
  1853. nret = FAILURE;
  1854. }
  1855. else
  1856. {
  1857. /*
  1858. ** The program command completed successfully. Put the 
  1859. ** device back into read mode and return.
  1860. */
  1861. *((WORDREG)this->baseAddress) = CFI_INTEL_RESET_TO_READ;
  1863. nret = SUCCESS;
  1864. }
  1866. EXCEndCriticalSection(irqState);
  1867. return nret;
  1868. }
  1870. /****************************************************************************
  1871. ** Function CFIIntelReset(): This function resets an Intel compatible FLASH
  1872. ** ROM back to read array mode.
  1873. **
  1874. ** Inputs:      this, pointer to a T_CFIROMDevice structure.
  1875. **
  1876. ** Outputs:     None
  1877. **
  1878. ** Returns:     Nothing.
  1879. ****************************************************************************/
  1880. void CFIIntelReset(T_CFIRomDevice *this)
  1881. {
  1882. *(WORDREG)this->baseAddress = CFI_INTEL_RESET_TO_READ;
  1883. }
  1885. /****************************************************************************
  1886. ** Function CFISetEndian(): This function swaps the byte order of a 16-bit
  1887. ** word only if this image has been compiled for little endian operation.
  1888. ** The reason this function is required is that our ROMs are 16-bit devices,
  1889. ** but yet we program them with byte data. This means that we have endian
  1890. ** issues to deal with. All of the functions in this module assume big endian
  1891. ** rules for converting byte data to half-word data. This function is called
  1892. ** in those cases to make sure that they work for little endian operation.
  1893. **
  1894. ** Big endian vs. Little endian example
  1895. ** Say memory contains for following data in byte order 0xAA, 0xBB, 0xCC, 0xDD.
  1896. ** If you read the lowest address as a half word then for a big endian machine
  1897. ** the result will be 0xAABB and 0xBBAA for a little endian machine. If you
  1898. ** want to perform a read, modify, write cycle to replace 0xBB with 0xEE then
  1899. ** the sequence of operations is different for big and little endian. For big
  1900. ** endian you would perform 'new_data = ((old_data & 0xFF00) | 0xEE);'. For
  1901. ** little endian you would perform 'new_data = ((old_data & 0x00FF) | 0xEE00);'
  1902. **
  1903. ** Inputs:      value, the 16-bit word to swap or not.
  1904. **
  1905. ** Outputs:     None
  1906. **
  1907. ** Returns:     value byte swapped if compiled for little endian, or
  1908. **                unaltered if compiled for big endian.
  1909. ****************************************************************************/
  1910. UINT16 CFISetEndian(UINT16 value)
  1911. {
  1912. /*
  1913. ** ST5105 platform is little endian, and maybe other ST platforms are
  1914. ** little endian also. Please make sure that
  1915. */
  1917. #if 1 /* __MIPSEL */
  1918. return((UINT16)((value & 0xFF) << 8) | (UINT16)(value >> 8));
  1919. #else
  1920. return(value);
  1921. #endif
  1922. }