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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
flashdrv.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：49k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

flashdrv.c：源码内容
  1. /* flashdrv.c - FLASH memory functions and definitions*/
  3. /* Copyright Galileo Technology. */
  5. /*
  6. DESCRIPTION
  7. This flash driver gives the user a convenient interface to FLASH memory located
  8. on the user`s board, it supports various layout configurations such as:
  9. 1. One pure 8 bit device (Such as AMD`s AM29LV040B).
  10. 2. 1,2,4 or 8 devices 16 bit wide configured to operate in 8 bit mode.
  11. 3. 1,2 or 4 devices each 16 bit wide.
  12. Before using the driver you must call the initialization function at least once
  13. or when ever you are changing the FLASH base address.
  14. The list bellow contains the supported FLASH memory devices, new devices can be
  15. added easily in the future.
  16. */
  18. /*includes*/
  19. #ifdef __linux__
  20. #include <asm/galileo-boards/evb64120A/flashdrv.h>
  21. #else
  22. #include "flashdrv.h"
  23. #endif
  24. /* locals */
  26. #ifdef __MIPSEB__ // skranz, add
  27. #define BE // skranz, add
  28. #endif // skranz, add
  30. /******************************************************************************
  31. * Those two tables contain the supported flash devices information needed by
  32. * the driver:
  33. * The first table "flashParametrs" starts with 10 shared fields
  34. *  (currently 6 are reserved):
  35. *   index 0 => Pointer to an entry in the second table list
  36. *   index 1 => baseAddress - Flash memory device base address.
  37. *   index 2 => width - 1, 2, 4 or 8 Bytes.
  38. *   index 3 => mode - PURE8, X8 or X16 flash configuration (for X16 devices only)
  39. * The second table (flashTypes) contains:
  40. * Entry`s structure:
  41. *   Manufacture ID,Device ID,number of sectors,list of sector`s sizes
  42. *   (in Kbytes starting with sector number 0).
  43. * The end of the list is pointed with a zero.
  44. ******************************************************************************/
  45. unsigned int flashParametrs[10]; /* 0  Entry pointer */
  46.  /* 0  Base address  */
  47.  /* 0  Width         */
  48.  /* 0  Mode          */
  49.  /* 0,0,0,0,0,0, spare entries. */
  50. unsigned int flashTypes[] = {
  52. /* 0 */ AMD_FLASH, AM29F400BB, 11, 16, 8, 8, 32, 64, 64, 64, 64,
  53.     64, 64, 64,
  54. /* 1 */ AMD_FLASH, AM29F400BT, 11, 64, 64, 64, 64, 64, 64, 64, 32,
  55.     8, 8, 16,
  56. /* 2 */ ST_FLASH, M29W040, 8, 64, 64, 64, 64, 64, 64, 64, 64,
  57. /* 3 */ AMD_FLASH, AM29LV040B, 8, 64, 64, 64, 64, 64, 64, 64, 64,
  58. /* 4 */ AMD_FLASH, AM29LV800BT, 19, 64, 64, 64, 64, 64, 64, 64, 64,
  59.     64, 64,
  60. 64, 64, 64, 64, 64, 32, 8, 8, 16,
  61. /* 5 */ INTEL_FLASH, I28F320J3A, 32, 128, 128, 128, 128, 128, 128,
  62.     128, 128,
  63. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  64. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  65. 128, 128, 128, 128,
  66. /* 6 */ INTEL_FLASH, I28F640J3A, 64, 128, 128, 128, 128, 128, 128,
  67.     128, 128,
  68. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  69. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  70. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  71. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  72. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  73. 128, 128, 128, 128, 128, 128,
  74. /* 7 */ INTEL_FLASH, I28F128J3A, 128, 128, 128, 128, 128, 128, 128,
  75.     128, 128,
  76. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  77. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  78. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  79. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  80. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  81. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  82. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  83. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  84. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  85. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  86. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  87. 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  88. /* 8 */ AMD_FLASH, AM29LV400BB, 11, 16, 8, 8, 32, 64, 64, 64, 64,
  89.     64, 64, 64,
  90. /* 9 */ AMD_FLASH, AM29LV400BT, 11, 64, 64, 64, 64, 64, 64, 64, 32,
  91.     8, 8, 16,
  92. /* 10 */ INTEL_FLASH, I28F320B3_T, 71, 64, 64, 64, 64, 64, 64, 64,
  93.     64, 64,
  94. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  95. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  96. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  97. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  98. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  99. 64, 64, 64, 64, 8, 8, 8, 8, 8, 8, 8, 8,
  100. /* 11 */ INTEL_FLASH, I28F320B3_B, 71, 8, 8, 8, 8, 8, 8, 8, 8, 64,
  101.     64, 64,
  102. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  103. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  104. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  105. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  106. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  107. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  108. /* 12 */ INTEL_FLASH, I28F160B3_B, 39, 8, 8, 8, 8, 8, 8, 8, 8, 64,
  109.     64, 64,
  110. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  111. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  112. 64, 64, 64, 64, 64, 64, 64, 64,
  113. /* 13 */ INTEL_FLASH, I28F160B3_T, 39, 64, 64, 64, 64, 64, 64, 64,
  114.     64, 64,
  115. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  116. 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  117. 64, 64, 8, 8, 8, 8, 8, 8, 8, 8,
  119. 0 /* End of list indicator */
  120. };
  122. /********************************************************************
  123. * flashInit - Initializes the FLASH memory driver`s parameters, this function
  124. *             must be called at least once before using the FLASH memory.
  125. *             If you are changing the FLASH base address call this function
  126. *             again.
  127. *
  128. * INPUTS:     unsigned int flashBaseAddress - The flash base Address.
  129. *             unsigned int flashWidth - Flash bus width in Bytes: 1,2,4 or 8.
  130. *             flashMode - PURE8, X8 or X16.
  131. * RETURNS:    Flash Size, zero when operation (flashInit) failed.
  132. *********************************************************************/
  133. unsigned int flashInit(unsigned int flashBaseAddress,
  134.        unsigned int flashWidth, FLASHmode flashMode)
  135. {
  136. unsigned short mfrId = 0;
  137. unsigned short devId = 0xffff;
  138. unsigned int FirstAddr, SecondAddr, ThirdAddr;
  139. unsigned int pArray = 0;
  140. unsigned int counter;
  141. unsigned int flashSize = 0;
  143. /* update the list with relevant parametrs */
  144. flashParametrs[0] = 0; /* Default initialization */
  145. flashParametrs[1] = flashBaseAddress;
  146. flashParametrs[2] = flashWidth;
  147. flashParametrs[3] = flashMode;
  148. /* Get the FLASH`s ID */
  149. switch (FLASH_WIDTH) {
  150. case 1:
  151. /* AMD or ST ?? * */
  152. if (flashMode == PURE8) { /* Boot Flash */
  153. FirstAddr = 0x5555;
  154. SecondAddr = 0x2aaa;
  155. ThirdAddr = 0x5555;
  156. } else { /* X16 device configured to 8bit Mode */
  158. FirstAddr = 0xaaaa;
  159. SecondAddr = 0x5555;
  160. ThirdAddr = 0xaaaa;
  161. }
  162. flashReset();
  163. WRITE_CHAR(FLASH_BASE_ADDRESS + FirstAddr, 0xAA);
  164. WRITE_CHAR(FLASH_BASE_ADDRESS + SecondAddr, 0x55);
  165. WRITE_CHAR(FLASH_BASE_ADDRESS + ThirdAddr, 0x90);
  166. READ_CHAR(FLASH_BASE_ADDRESS + 0x0, &mfrId);
  167. if (mfrId == AMD_FLASH || mfrId == ST_FLASH) {
  168. flashReset();
  169. WRITE_CHAR(FLASH_BASE_ADDRESS + FirstAddr, 0xAA);
  170. WRITE_CHAR(FLASH_BASE_ADDRESS + SecondAddr, 0x55);
  171. WRITE_CHAR(FLASH_BASE_ADDRESS + ThirdAddr, 0x90);
  172. READ_CHAR(FLASH_BASE_ADDRESS + 0x1, &devId);
  173. break;
  174. }
  175. /* Micron or Intel ?? * */
  176. WRITE_CHAR(FLASH_BASE_ADDRESS, 0xff); /* Read Array */
  177. /* Flash reset for Intel/Micron */
  178. WRITE_CHAR(FLASH_BASE_ADDRESS, 0x90); /* IDENTIFY Device */
  179. READ_CHAR(FLASH_BASE_ADDRESS + 0x0, &mfrId); /*Address for ManufactureID */
  180. if (mfrId == INTEL_FLASH || mfrId == MICRON_FLASH) {
  181. WRITE_CHAR(FLASH_BASE_ADDRESS, 0xff); /* Read Array */
  182. /*Flash reset for Intel/Micron */
  183. WRITE_CHAR(FLASH_BASE_ADDRESS, 0x90); /* IDENTIFY Device */
  184. READ_CHAR(FLASH_BASE_ADDRESS + 0x1, &devId); /*Address for DeviceID */
  185. }
  186. break;
  187. case 2:
  188. case 4:
  189. case 8:
  190. /* AMD or ST ??? */
  191. flashReset();
  192. WRITE_SHORT(FLASH_BASE_ADDRESS + 0x5555 * FLASH_WIDTH,
  193.     0xaa);
  194. WRITE_SHORT(FLASH_BASE_ADDRESS + 0x2aaa * FLASH_WIDTH,
  195.     0x55);
  196. WRITE_SHORT(FLASH_BASE_ADDRESS + 0x5555 * FLASH_WIDTH,
  197.     0x90);
  198. READ_SHORT(FLASH_BASE_ADDRESS, &mfrId);
  199. flashReset();
  200. /* Read the device ID */
  201. if (mfrId == AMD_FLASH || mfrId == ST_FLASH) {
  202. WRITE_SHORT(FLASH_BASE_ADDRESS +
  203.     0x5555 * FLASH_WIDTH, 0xaa);
  204. WRITE_SHORT(FLASH_BASE_ADDRESS +
  205.     0x2aaa * FLASH_WIDTH, 0x55);
  206. WRITE_SHORT(FLASH_BASE_ADDRESS +
  207.     0x5555 * FLASH_WIDTH, 0x90);
  208. READ_SHORT(FLASH_BASE_ADDRESS + 0x1 * FLASH_WIDTH,
  209.    &devId);
  210. break;
  211. }
  212. /* Micron or Intel ?? * */
  213. WRITE_WORD(FLASH_BASE_ADDRESS, 0x00ff00ff);
  214. WRITE_WORD(FLASH_BASE_ADDRESS, 0x00900090);
  215. if ((FLASH_WIDTH == 4) || (FLASH_WIDTH == 8)) { /* 32 or 64 bit */
  216. READ_SHORT(FLASH_BASE_ADDRESS, &mfrId);
  217. } else { /* FLASH_WIDTH = 2 */
  219. READ_SHORT(FLASH_BASE_ADDRESS, &mfrId);
  220. }
  221. if ((mfrId == INTEL_FLASH) || (mfrId == MICRON_FLASH)) {
  222. /* Flash reset for Intel/Micron */
  223. flashReset();
  224. WRITE_WORD(FLASH_BASE_ADDRESS, 0x00ff00ff);
  225. WRITE_WORD(FLASH_BASE_ADDRESS, 0x00900090);
  226. READ_SHORT(FLASH_BASE_ADDRESS + 0x1 * FLASH_WIDTH,
  227.    &devId);
  228. }
  229. break;
  231. }
  232. /* Try to locate the device in the supported flashes list (FLASH_TYPE).
  233.    according to the keys:
  234.    1) mfrId - manufactor ID.
  235.    2) devId - device ID.
  236.  */
  238. while (true) {
  239. if (flashTypes[pArray] == 0) {
  240. flashReset();
  241. return 0; /* Device not in the list */
  242. }
  243. if ((flashTypes[pArray] == mfrId) &&
  244.     (flashTypes[pArray + 1] == devId)) {
  245. POINTER_TO_FLASH = pArray;
  246. for (counter = 0;
  247.      counter < flashTypes[NUMBER_OF_SECTORS];
  248.      counter++) {
  249. flashSize =
  250.     flashSize +
  251.     flashTypes[FIRST_SECTOR_SIZE +
  252.        counter];
  253. }
  254. if (FLASH_MODE != PURE8) {
  255. flashReset();
  256. return (flashSize * _1K *
  257. (FLASH_WIDTH / (FLASH_MODE / 8)));
  258. } else {
  259. flashReset();
  260. return (flashSize * _1K * FLASH_WIDTH);
  261. }
  262. }
  263. pArray += (3 + flashTypes[pArray + 2]); /* Move to next entry */
  264. }
  265. }
  267. /********************************************************************
  268. * flashReset - Resets the Flash memory (FLASH`s internal protocol reset).
  269. *
  270. * INTPUTS:  N/A
  271. * OUTPUT:   N/A
  272. *********************************************************************/
  273. void flashReset()
  274. {
  275. unsigned char ucData;
  276. unsigned short usData;
  277. unsigned int uiData;
  279. if ((flashTypes[POINTER_TO_FLASH] == AMD_FLASH) ||
  280.     (flashTypes[POINTER_TO_FLASH]) == ST_FLASH) {
  281. if (FLASH_MODE == X16) {
  282. ucData = 0xf0;
  283. usData = 0xf0;
  284. uiData = 0x00f000f0;
  285. } else { /* case of PURE8 or X8 */
  287. ucData = 0xf0;
  288. usData = 0xf0f0;
  289. uiData = 0xf0f0f0f0;
  290. }
  291. } else {
  292. if (FLASH_MODE == X16) {
  293. ucData = 0xff;
  294. usData = 0xff;
  295. uiData = 0x00ff00ff;
  296. } else { /* case of PURE8 or X8 */
  298. ucData = 0xff;
  299. usData = 0xffff;
  300. uiData = 0xffffffff;
  301. }
  302. }
  303. switch (FLASH_WIDTH) {
  304. case 1:
  305. WRITE_CHAR(FLASH_BASE_ADDRESS, ucData);
  306. break;
  307. case 2:
  308. WRITE_SHORT(FLASH_BASE_ADDRESS, usData);
  309. break;
  310. case 4:
  311. WRITE_WORD(FLASH_BASE_ADDRESS, uiData);
  312. break;
  313. case 8:
  314. WRITE_WORD(FLASH_BASE_ADDRESS, uiData);
  315. WRITE_WORD(FLASH_BASE_ADDRESS + 0x4, uiData);
  316. break;
  317. }
  318. }
  320. /********************************************************************
  321. * flashErase - The function erases the WHOLE flash memory.
  322. *
  323. *
  324. * RETURNS: true on success,false on failure
  325. *********************************************************************/
  326. bool flashErase()
  327. {
  328. unsigned int totalFlashSize;
  329. unsigned int address;
  330. unsigned int readData;
  331. unsigned int nextSector;
  333. flashReset();
  334. totalFlashSize = flashGetSize();
  335. /* scan all flash memory space. */
  336. address = 0;
  337. while (address < totalFlashSize) {
  338. readData = flashReadWord(address);
  339. if (readData != 0xffffffff) { /* offset with dirty data. */
  340. flashEraseSector(flashInWhichSector(address));
  341. nextSector = flashInWhichSector(address) + 1;
  342. if (nextSector < flashTypes[NUMBER_OF_SECTORS])
  343. /* jump to next sector. */
  344. address = flashGetSectorOffset(nextSector);
  345. else
  346. /* end of erasing. */
  347. address = totalFlashSize;
  348. } else
  349. address += 4;
  350. }
  351. return true;
  352. }
  354. /********************************************************************
  355. * flashEraseSector - The function erases a specific sector in the flash memory.
  356. *
  357. * INPUTS:  Sector number.
  358. * RETURNS: true on success,false on failure.
  359. *********************************************************************/
  360. bool flashEraseSector(unsigned int sectorNumber)
  361. {
  362. volatile unsigned int spin;
  363. unsigned int regValue;
  364. unsigned int sectorBaseAddress = 0;
  365. unsigned int i;
  366. unsigned int data20, dataD0, data70;
  367. unsigned int dataPoll;
  368. unsigned int FirstAddr, SecondAddr, ThirdAddr, FourthAddr,
  369.     FifthAddr;
  370. unsigned int FirstData, SecondData, ThirdData;
  371. unsigned int FourthData, FifthData, SixthData;
  373. /* calculate the sector base Address according to the following parametrs:
  374.    1: FLASH_WIDTH
  375.    2: the size of each sector which it detailed in the table */
  377. /* checking the if the sectorNumber is legal. */
  378. if (sectorNumber > flashTypes[NUMBER_OF_SECTORS] - 1)
  379. return false;
  380. /* now the calculation begining of the sector Address */
  381. for (i = 0; i < sectorNumber; i++) {
  382. sectorBaseAddress =
  383.     sectorBaseAddress + flashTypes[FIRST_SECTOR_SIZE + i];
  384. }
  385. /* In case of X8 wide the address should be */
  386. if (FLASH_MODE == PURE8)
  387. sectorBaseAddress = _1K * sectorBaseAddress;
  388. if (FLASH_MODE == X8)
  389. sectorBaseAddress = _1K * sectorBaseAddress;
  390. /* In case of X16 wide the address should be */
  391. if (FLASH_MODE == X16)
  392. sectorBaseAddress = _1K * sectorBaseAddress / 2;
  393. flashReset();
  394. if ((flashTypes[POINTER_TO_FLASH] == AMD_FLASH) || 
  395.     (flashTypes[POINTER_TO_FLASH] == ST_FLASH)) {
  396. switch (FLASH_WIDTH) {
  397. case 1:
  398. if (FLASH_MODE == PURE8) { /* Boot Flash PURE8 */
  399. FirstAddr = 0x5555;
  400. SecondAddr = 0x2aaa;
  401. ThirdAddr = 0x5555;
  402. FourthAddr = 0x5555;
  403. FifthAddr = 0x2aaa;
  404. } else {
  405. FirstAddr = 0xaaaa;
  406. SecondAddr = 0x5555;
  407. ThirdAddr = 0xaaaa;
  408. FourthAddr = 0xaaaa;
  409. FifthAddr = 0x5555;
  410. }
  411. WRITE_CHAR(FLASH_BASE_ADDRESS + FirstAddr, 0xAA);
  412. WRITE_CHAR(FLASH_BASE_ADDRESS + SecondAddr, 0x55);
  413. WRITE_CHAR(FLASH_BASE_ADDRESS + ThirdAddr, 0x80);
  414. WRITE_CHAR(FLASH_BASE_ADDRESS + FourthAddr, 0xAA);
  415. WRITE_CHAR(FLASH_BASE_ADDRESS + FifthAddr, 0x55);
  416. WRITE_CHAR(
  417.    (FLASH_BASE_ADDRESS +
  418.     (sectorBaseAddress & 0xffffff00)),
  419.    0x30);
  420. /* Poll on the flash */
  421. do {
  422. READ_CHAR(FLASH_BASE_ADDRESS +
  423.   sectorBaseAddress, &regValue);
  424. } while ((regValue & 0x80) != 0x80);
  426. break;
  427. case 2:
  428. if (FLASH_MODE == X16) {
  429. FirstData = 0xaa; /* Data for the First  Cycle */
  430. SecondData = 0x55; /* Data for the Second Cycle */
  431. ThirdData = 0x80; /* Data for the Third  Cycle */
  432. FourthData = 0xaa; /* Data for the Fourth Cycle */
  433. FifthData = 0x55; /* Data for the Fifth  Cycle */
  434. SixthData = 0x30; /* Data for the Sixth  Cycle */
  435. FirstAddr = 0x5555; /* Address for the First  Cycle */
  436. SecondAddr = 0x2aaa; /* Address for the Second Cycle */
  437. ThirdAddr = 0x5555; /* Address for the Third  Cycle */
  438. FourthAddr = 0x5555; /* Address for the Fourth Cycle */
  439. FifthAddr = 0x2aaa; /* Address for the Fifth  Cycle */
  440. } else { /* (FLASH_MODE = 8) */
  442. FirstData = 0xaaaa; /* Data for the First  Cycle */
  443. SecondData = 0x5555; /* Data for the Second Cycle */
  444. ThirdData = 0x8080; /* Data for the Third  Cycle */
  445. FourthData = 0xaaaa; /* Data for the Fourth Cycle */
  446. FifthData = 0x5555; /* Data for the Fifth  Cycle */
  447. SixthData = 0x3030; /* Data for the Sixth  Cycle */
  448. FirstAddr = 0xaaaa; /* Address for the First  Cycle */
  449. SecondAddr = 0x5555; /* Address for the Second Cycle */
  450. ThirdAddr = 0xaaaa; /* Address for the Third  Cycle */
  451. FourthAddr = 0xaaaa; /* Address for the Fourth Cycle */
  452. FifthAddr = 0x5555; /* Address for the Fifth  Cycle */
  453. }
  454. WRITE_SHORT(FLASH_BASE_ADDRESS +
  455.     FirstAddr * FLASH_WIDTH, FirstData);
  456. WRITE_SHORT(FLASH_BASE_ADDRESS +
  457.     SecondAddr * FLASH_WIDTH, SecondData);
  458. WRITE_SHORT(FLASH_BASE_ADDRESS +
  459.     ThirdAddr * FLASH_WIDTH, ThirdData);
  460. WRITE_SHORT(FLASH_BASE_ADDRESS +
  461.     FourthAddr * FLASH_WIDTH, FourthData);
  462. WRITE_SHORT(FLASH_BASE_ADDRESS +
  463.     FifthAddr * FLASH_WIDTH, FifthData);
  464. WRITE_SHORT(FLASH_BASE_ADDRESS +
  465.     (sectorBaseAddress & 0xffffff00) *
  466.     FLASH_WIDTH, SixthData);
  467. /* Poll on the flash */
  468. if (FLASH_MODE == X16) { /* 1 device of 16 bit */
  469. dataPoll = 0x0080;
  470. } else { /* (FLASH_MODE = 8) ==> 2 devices , 8 bit each => 16bit */
  472. dataPoll = 0x8080;
  473. }
  474. do {
  475. READ_SHORT(FLASH_BASE_ADDRESS +
  476.    sectorBaseAddress * FLASH_WIDTH,
  477.    &regValue);
  478. for (spin = 0; spin < 100; spin++) {
  479. } // skranz, added spin loop.
  480. } while ((regValue & dataPoll) != dataPoll);
  481. break;
  482. case 4:
  483. if (FLASH_MODE == X16) {
  484. FirstData = 0x00aa00aa; /* Data for the First  Cycle */
  485. SecondData = 0x00550055; /* Data for the Second Cycle */
  486. ThirdData = 0x00800080; /* Data for the Third  Cycle */
  487. FourthData = 0x00aa00aa; /* Data for the Fourth Cycle */
  488. FifthData = 0x00550055; /* Data for the Fifth  Cycle */
  489. SixthData = 0x00300030; /* Data for the Sixth  Cycle */
  490. FirstAddr = 0x5555; /* Address for the First  Cycle */
  491. SecondAddr = 0x2aaa; /* Address for the Second Cycle */
  492. ThirdAddr = 0x5555; /* Address for the Third  Cycle */
  493. FourthAddr = 0x5555; /* Address for the Fourth Cycle */
  494. FifthAddr = 0x2aaa; /* Address for the Fifth  Cycle */
  495. } else { /* if (FLASH_MODE == 8) */
  497. FirstData = 0xaaaaaaaa; /* Data for the First  Cycle */
  498. SecondData = 0x55555555; /* Data for the Second Cycle */
  499. ThirdData = 0x80808080; /* Data for the Third  Cycle */
  500. FourthData = 0xAAAAAAAA; /* Data for the Fourth Cycle */
  501. FifthData = 0x55555555; /* Data for the Fifth  Cycle */
  502. SixthData = 0x30303030; /* Data for the Sixth  Cycle */
  503. FirstAddr = 0xaaaa; /* Address for the First  Cycle */
  504. SecondAddr = 0x5555; /* Address for the Second Cycle */
  505. ThirdAddr = 0xaaaa; /* Address for the Third  Cycle */
  506. FourthAddr = 0xaaaa; /* Address for the Fourth Cycle */
  507. FifthAddr = 0x5555; /* Address for the Fifth  Cycle */
  508. }
  509. WRITE_WORD(FLASH_BASE_ADDRESS +
  510.    FirstAddr * FLASH_WIDTH, FirstData);
  511. WRITE_WORD(FLASH_BASE_ADDRESS +
  512.    SecondAddr * FLASH_WIDTH, SecondData);
  513. WRITE_WORD(FLASH_BASE_ADDRESS +
  514.    ThirdAddr * FLASH_WIDTH, ThirdData);
  515. WRITE_WORD(FLASH_BASE_ADDRESS +
  516.    FourthAddr * FLASH_WIDTH, FourthData);
  517. WRITE_WORD(FLASH_BASE_ADDRESS +
  518.    FifthAddr * FLASH_WIDTH, FifthData);
  519. WRITE_WORD(FLASH_BASE_ADDRESS +
  520.    (sectorBaseAddress & 0xffffff00) *
  521.    FLASH_WIDTH, SixthData);
  522. /* Poll on the flash */
  523. if (FLASH_MODE == X16) { /* 4 devices , 16 bit each => 64bit */
  524. dataPoll = 0x00800080;
  525. } else { /* (FLASH_MODE = 8) ==> 8 devices , 8 bit each => 64bit */
  527. dataPoll = 0x80808080;
  528. }
  529. do {
  530. READ_WORD(FLASH_BASE_ADDRESS +
  531.   sectorBaseAddress * FLASH_WIDTH,
  532.   &regValue);
  533. } while ((regValue & dataPoll) != dataPoll);
  534. break;
  535. case 8: /* In case of 64bit width the transformation is 1->8 */
  536. if (FLASH_MODE == X16) {
  537. FirstData = 0x00aa00aa; /* Data for the First  Cycle */
  538. SecondData = 0x00550055; /* Data for the Second Cycle */
  539. ThirdData = 0x00800080; /* Data for the Third  Cycle */
  540. FourthData = 0x00aa00aa; /* Data for the Fourth Cycle */
  541. FifthData = 0x00550055; /* Data for the Fifth  Cycle */
  542. SixthData = 0x00300030; /* Data for the Sixth  Cycle */
  543. FirstAddr = 0x5555; /* Address for the First  Cycle */
  544. SecondAddr = 0x2aaa; /* Address for the Second Cycle */
  545. ThirdAddr = 0x5555; /* Address for the Third  Cycle */
  546. FourthAddr = 0x5555; /* Address for the Fourth Cycle */
  547. FifthAddr = 0x2aaa; /* Address for the Fifth  Cycle */
  548. } else { /* (FLASH_MODE = 8 */
  550. FirstData = 0xaaaaaaaa; /* Data for the First  Cycle */
  551. SecondData = 0x55555555; /* Data for the Second Cycle */
  552. ThirdData = 0x80808080; /* Data for the Third  Cycle */
  553. FourthData = 0xAAAAAAAA; /* Data for the Fourth Cycle */
  554. FifthData = 0x55555555; /* Data for the Fifth  Cycle */
  555. SixthData = 0x30303030; /* Data for the Sixth  Cycle */
  556. FirstAddr = 0xaaaa; /* Address for the First  Cycle */
  557. SecondAddr = 0x5555; /* Address for the Second Cycle */
  558. ThirdAddr = 0xaaaa; /* Address for the Third  Cycle */
  559. FourthAddr = 0xaaaa; /* Address for the Fourth Cycle */
  560. FifthAddr = 0x5555; /* Address for the Fifth  Cycle */
  561. }
  562. WRITE_WORD(FLASH_BASE_ADDRESS +
  563.    FirstAddr * FLASH_WIDTH, FirstData);
  564. WRITE_WORD(FLASH_BASE_ADDRESS +
  565.    SecondAddr * FLASH_WIDTH, SecondData);
  566. WRITE_WORD(FLASH_BASE_ADDRESS +
  567.    ThirdAddr * FLASH_WIDTH, ThirdData);
  568. WRITE_WORD(FLASH_BASE_ADDRESS +
  569.    FourthAddr * FLASH_WIDTH, FourthData);
  570. WRITE_WORD(FLASH_BASE_ADDRESS +
  571.    FifthAddr * FLASH_WIDTH, FifthData);
  572. WRITE_WORD(FLASH_BASE_ADDRESS +
  573.    (sectorBaseAddress & 0xffffff00) *
  574.    FLASH_WIDTH, SixthData);
  575. WRITE_WORD(FLASH_BASE_ADDRESS +
  576.    FirstAddr * FLASH_WIDTH + 4, FirstData);
  577. WRITE_WORD(FLASH_BASE_ADDRESS +
  578.    SecondAddr * FLASH_WIDTH + 4,
  579.    SecondData);
  580. WRITE_WORD(FLASH_BASE_ADDRESS +
  581.    ThirdAddr * FLASH_WIDTH + 4, ThirdData);
  582. WRITE_WORD(FLASH_BASE_ADDRESS +
  583.    FourthAddr * FLASH_WIDTH + 4,
  584.    FourthData);
  585. WRITE_WORD(FLASH_BASE_ADDRESS +
  586.    FifthAddr * FLASH_WIDTH + 4, FifthData);
  587. WRITE_WORD(FLASH_BASE_ADDRESS +
  588.    (sectorBaseAddress & 0xffffff00)
  589.    * FLASH_WIDTH + 4, SixthData);
  590. /* Poll on the flash */
  591. if (FLASH_MODE == X16) { /* 4 devices , 16 bit each => 64bit */
  592. dataPoll = 0x00800080;
  593. } else { /* (FLASH_MODE = 8) ==> 8 devices , 8 bit each => 64bit */
  595. dataPoll = 0x80808080;
  596. }
  597. do {
  598. READ_WORD(FLASH_BASE_ADDRESS +
  599.   sectorBaseAddress * FLASH_WIDTH,
  600.   &regValue);
  601. } while ((regValue & dataPoll) != dataPoll);
  602. do {
  603. READ_WORD(FLASH_BASE_ADDRESS +
  604.   sectorBaseAddress * FLASH_WIDTH +
  605.   4, &regValue);
  606. } while ((regValue & dataPoll) != dataPoll);
  607. break;
  608. default:
  609. return false;
  610. }
  611. } /* End of 'flash erase sector' for AMD/ST */
  612. else { /* Intel/Micron */
  614. switch (FLASH_WIDTH) {
  615. case 1:
  616. WRITE_CHAR(FLASH_BASE_ADDRESS, 0x20);
  617. WRITE_CHAR(
  618.    (FLASH_BASE_ADDRESS +
  619.     (sectorBaseAddress & 0xffffff00)),
  620.    0xd0);
  621. /* Poll on the flash */
  622. while (true) {
  623. WRITE_CHAR(FLASH_BASE_ADDRESS, 0x70);
  624. READ_CHAR(FLASH_BASE_ADDRESS, &regValue);
  625. if ((regValue & 0x80) == 0x80)
  626. break;
  627. }
  628. break;
  629. case 2:
  630. if (FLASH_MODE == X16) { /* 1 device 16 bit.  */
  631. data20 = 0x0020;;
  632. dataD0 = 0x00d0;;
  633. } else { /* (FLASH_MODE = 8) ==> 2 devices , 8 bit each => 16bit */
  635. data20 = 0x2020;
  636. dataD0 = 0xd0d0;
  637. }
  638. WRITE_SHORT(FLASH_BASE_ADDRESS, data20);
  639. WRITE_SHORT(
  640.     (FLASH_BASE_ADDRESS +
  641.      ((sectorBaseAddress * 2) &
  642.       0xffffff00)), dataD0);
  643. /* Poll on the flash */
  644. if (FLASH_MODE == X16) {
  645. dataPoll = 0x0080;
  646. data70 = 0x0070;
  647. } else { /* (FLASH_MODE = 8) */
  649. dataPoll = 0x8080;
  650. data70 = 0x7070;
  651. }
  652. while (true) {
  653. WRITE_SHORT(FLASH_BASE_ADDRESS +
  654.     sectorBaseAddress * 2, data70);
  655. READ_SHORT(FLASH_BASE_ADDRESS +
  656.    sectorBaseAddress * 2,
  657.    &regValue);
  658. if ((regValue & 0x0080) == 0x0080)
  659. break;
  660. }
  661. break;
  662. case 4:
  663. if (FLASH_MODE == X16) { /* 2 devices , 16 bit each => 32bit */
  664. data20 = 0x00200020;
  665. dataD0 = 0x00d000d0;
  666. } else { /* (FLASH_MODE = 8) ==> 4 devices , 8 bit each => 32bit */
  668. data20 = 0x20202020;
  669. dataD0 = 0xd0d0d0d0;
  670. }
  671. WRITE_WORD(FLASH_BASE_ADDRESS, data20);
  672. WRITE_WORD(
  673.    (FLASH_BASE_ADDRESS +
  674.     ((sectorBaseAddress * 4) &
  675.      0xffffff00)), dataD0);
  676. /* Poll on the flash */
  677. if (FLASH_MODE == X16) {
  678. dataPoll = 0x0080;
  679. data70 = 0x0070;
  680. } else { /* (FLASH_MODE = 8) */
  682. dataPoll = 0x8080;
  683. data70 = 0x7070;
  684. }
  685. while (true) {
  686. WRITE_SHORT(FLASH_BASE_ADDRESS, data70);
  687. READ_SHORT(FLASH_BASE_ADDRESS, &regValue);
  688. if ((regValue & dataPoll) == dataPoll)
  689. break;
  690. }
  691. while (true) {
  692. WRITE_SHORT(FLASH_BASE_ADDRESS + 2,
  693.     data70);
  694. READ_SHORT(FLASH_BASE_ADDRESS + 2,
  695.    &regValue);
  696. if ((regValue & dataPoll) == dataPoll)
  697. break;
  698. }
  699. break;
  700. case 8:
  701. if (FLASH_MODE == X16) { /* 4 devices , 16 bit each => 64bit */
  702. data20 = 0x00200020;
  703. dataD0 = 0x00d000d0;
  704. } else { /* (FLASH_MODE = 8) ==> 8 devices , 8 bit each => 64bit */
  706. data20 = 0x20202020;
  707. dataD0 = 0xd0d0d0d0;
  708. }
  709. WRITE_WORD(FLASH_BASE_ADDRESS, data20);
  710. WRITE_WORD(
  711.    (FLASH_BASE_ADDRESS +
  712.     ((sectorBaseAddress * 8) &
  713.      0xffffff00)), dataD0);
  714. WRITE_WORD(FLASH_BASE_ADDRESS + 4, data20);
  715. WRITE_WORD(
  716.    (FLASH_BASE_ADDRESS +
  717.     ((sectorBaseAddress * 8) & 0xffffff00 +
  718.      4)), dataD0);
  719. /* Poll on the flash */
  720. if (FLASH_MODE == X16) {
  721. dataPoll = 0x0080;
  722. data70 = 0x0070;
  723. } else { /* (FLASH_MODE = 8) */
  725. dataPoll = 0x8080;
  726. data70 = 0x7070;
  727. }
  728. while (true) {
  729. WRITE_SHORT(FLASH_BASE_ADDRESS +
  730.     sectorBaseAddress * 8, data70);
  731. READ_SHORT(FLASH_BASE_ADDRESS +
  732.    sectorBaseAddress * 8,
  733.    &regValue);
  734. if ((regValue & dataPoll) == dataPoll)
  735. break;
  736. }
  737. while (true) {
  738. WRITE_SHORT(FLASH_BASE_ADDRESS + 2,
  739.     data70);
  740. READ_SHORT(FLASH_BASE_ADDRESS + 2,
  741.    &regValue);
  742. if ((regValue & dataPoll) == dataPoll)
  743. break;
  744. }
  745. while (true) {
  746. WRITE_SHORT(FLASH_BASE_ADDRESS + 4,
  747.     data70);
  748. READ_SHORT(FLASH_BASE_ADDRESS + 4,
  749.    &regValue);
  750. if ((regValue & dataPoll) == dataPoll)
  751. break;
  752. }
  753. while (true) {
  754. WRITE_SHORT(FLASH_BASE_ADDRESS + 6,
  755.     data70);
  756. READ_SHORT(FLASH_BASE_ADDRESS + 6,
  757.    &regValue);
  758. if ((regValue & dataPoll) == dataPoll)
  759. break;
  760. }
  761. break;
  762. default:
  763. return false;
  764. }
  765. }
  766. flashReset();
  767. return true;
  768. }
  770. /********************************************************************
  771. * flashWriteWord - Write 32Bit to the FLASH memory at the given offset from the
  772. *                  FLASH base address.
  773. *       address 0 = 0x00000000 !!
  774. *    Attention!!! data "0" cannot be programed back to
  775. *                  "1" (only by first performing an earase operation).
  776. *                  The function takes care of Big/Little endian conversion
  777. *
  778. * INPUTS:  offset - The offset from the flash`s base address.
  779. *          data   - The data that should be written.
  780. * RETURNS: true on success,false on failure
  781. *********************************************************************/
  782. bool flashWriteWord(unsigned int offset, unsigned int data)
  783. {
  784. unsigned char c, rc;
  785. unsigned short s, rs;
  786. register unsigned int rw;
  787. register unsigned int regValue;
  788. register unsigned int FirstAddr, SecondAddr, ThirdAddr;
  789. register unsigned int FirstData, SecondData, ThirdData;
  790. register unsigned int data10, data20, data70, data80;
  792. if ((flashTypes[POINTER_TO_FLASH] == AMD_FLASH) || 
  793.     (flashTypes[POINTER_TO_FLASH] == ST_FLASH)) {
  794. switch (FLASH_WIDTH) {
  795. case 1: /* Split the 32 bit write into four 8bit Writings */
  796. if (FLASH_MODE == PURE8) { /* Boot Flash */
  797. FirstAddr = 0x5555;
  798. SecondAddr = 0x2aaa;
  799. ThirdAddr = 0x5555;
  800. } else {
  801. FirstAddr = 0xaaaa;
  802. SecondAddr = 0x5555;
  803. ThirdAddr = 0xaaaa;
  804. }
  805. WRITE_CHAR(FLASH_BASE_ADDRESS + FirstAddr, 0xaa);
  806. WRITE_CHAR(FLASH_BASE_ADDRESS + SecondAddr, 0x55);
  807. WRITE_CHAR(FLASH_BASE_ADDRESS + ThirdAddr, 0xa0);
  808. #ifdef BE
  809. c = (data >> 24);
  810. #else
  811. c = data;
  812. #endif
  813. WRITE_CHAR(FLASH_BASE_ADDRESS + offset, c);
  814. /* Writing first Byte */
  815. while (true) {
  816. READ_CHAR(FLASH_BASE_ADDRESS + offset,
  817.   &rc);
  818. if ((rc & 0x80) == (c & 0x80)) /* DQ7 =? DATA */
  819. break; /* DQ7 =  DATA */
  820. if ((rc & 0x20) == 0x20) { /* DQ5 =? '1'  */
  821. READ_CHAR(FLASH_BASE_ADDRESS +
  822.   offset, &rc);
  823. if ((rc & 0x80) == (c & 0x80))
  824. break; /* DQ7 = DATA  */
  825. else
  826. return false; /* DQ7 != DATA */
  827. }
  828. }
  829. WRITE_CHAR(FLASH_BASE_ADDRESS + FirstAddr, 0xaa);
  830. WRITE_CHAR(FLASH_BASE_ADDRESS + SecondAddr, 0x55);
  831. WRITE_CHAR(FLASH_BASE_ADDRESS + ThirdAddr, 0xa0);
  832. #ifdef BE
  833. c = (data >> 16);
  834. #else
  835. c = (data >> 8);
  836. #endif
  837. WRITE_CHAR(FLASH_BASE_ADDRESS + offset + 1, c);
  838. /* Writing second Byte */
  839. while (true) {
  840. READ_CHAR(FLASH_BASE_ADDRESS + offset + 1,
  841.   &rc);
  842. if ((rc & 0x80) == (c & 0x80)) /* DQ7 =? DATA */
  843. break; /* DQ7 = DATA  */
  844. if ((rc & 0x20) == 0x20) { /* DQ5 =? '1'  */
  845. READ_CHAR(FLASH_BASE_ADDRESS +
  846.   offset + 1, &rc);
  847. if ((rc & 0x80) == (c & 0x80))
  848. break; /* DQ7 = DATA  */
  849. else
  850. return false; /* DQ7 != DATA */
  851. }
  852. }
  853. WRITE_CHAR(FLASH_BASE_ADDRESS + FirstAddr, 0xaa);
  854. WRITE_CHAR(FLASH_BASE_ADDRESS + SecondAddr, 0x55);
  855. WRITE_CHAR(FLASH_BASE_ADDRESS + ThirdAddr, 0xa0);
  856. #ifdef BE
  857. c = (data >> 8);
  858. #else
  859. c = (data >> 16);
  860. #endif
  861. WRITE_CHAR(FLASH_BASE_ADDRESS + offset + 2, c);
  862. /* Writing third Byte */
  863. while (true) {
  864. READ_CHAR(FLASH_BASE_ADDRESS + offset + 2,
  865.   &rc);
  866. if ((rc & 0x80) == (c & 0x80)) /* DQ7 =? DATA */
  867. break; /* DQ7 = DATA  */
  868. if ((rc & 0x20) == 0x20) { /* DQ5 =? '1'  */
  869. READ_CHAR(FLASH_BASE_ADDRESS +
  870.   offset + 2, &rc);
  871. if ((rc & 0x80) == (c & 0x80))
  872. break; /* DQ7 = DATA  */
  873. else
  874. return false; /* DQ7 != DATA */
  875. }
  876. }
  877. WRITE_CHAR(FLASH_BASE_ADDRESS + FirstAddr, 0xaa);
  878. WRITE_CHAR(FLASH_BASE_ADDRESS + SecondAddr, 0x55);
  879. WRITE_CHAR(FLASH_BASE_ADDRESS + ThirdAddr, 0xa0);
  880. #ifdef BE
  881. c = data;
  882. #else
  883. c = (data >> 24);
  884. #endif
  885. WRITE_CHAR(FLASH_BASE_ADDRESS + offset + 3, c);
  886. /* Writing fourth Byte */
  887. while (true) {
  888. READ_CHAR(FLASH_BASE_ADDRESS + offset + 3,
  889.   &rc);
  890. if ((rc & 0x80) == (c & 0x80)) /* DQ7 =? DATA */
  891. break; /* DQ7 = DATA  */
  892. if ((rc & 0x20) == 0x20) { /* DQ5 =? '1'  */
  893. READ_CHAR(FLASH_BASE_ADDRESS +
  894.   offset + 3, &rc);
  895. if ((rc & 0x80) == (c & 0x80))
  896. break; /* DQ7 = DATA  */
  897. else
  898. return false; /* DQ7 != DATA */
  899. }
  900. }
  901. break;
  902. case 2: /* Split the 32 bit write into two 8/16 bit Writings
  903.    (16bit width). */
  904. if (FLASH_MODE == X16) {
  905. FirstData = 0xaa; /* Data for the First  Cycle    */
  906. SecondData = 0x55; /* Data for the Second Cycle    */
  907. ThirdData = 0xa0; /* Data for the Third  Cycle    */
  908. FirstAddr = 0x5555; /* Address for the First  Cycle */
  909. SecondAddr = 0x2aaa; /* Address for the Second Cycle */
  910. ThirdAddr = 0x5555; /* Address for the Third  Cycle */
  911. } else { /* if (FLASH_MODE == 8) */
  913. FirstData = 0xaaaa; /* Data for the First  Cycle    */
  914. SecondData = 0x5555; /* Data for the Second Cycle    */
  915. ThirdData = 0xa0a0; /* Data for the Third  Cycle    */
  916. FirstAddr = 0xaaaa; /* Address for the First  Cycle */
  917. SecondAddr = 0x5555; /* Address for the Second Cycle */
  918. ThirdAddr = 0xaaaa; /* Address for the Third  Cycle */
  919. }
  920. WRITE_SHORT(FLASH_BASE_ADDRESS +
  921.     FirstAddr * FLASH_WIDTH, FirstData);
  922. WRITE_SHORT(FLASH_BASE_ADDRESS +
  923.     SecondAddr * FLASH_WIDTH, SecondData);
  924. WRITE_SHORT(FLASH_BASE_ADDRESS +
  925.     ThirdAddr * FLASH_WIDTH, ThirdData);
  926. #ifdef BE
  927. s = (data >> 16);
  928. #else
  929. s = data;
  930. #endif
  931. WRITE_SHORT(FLASH_BASE_ADDRESS + offset, s);
  932. /* Writing Two Bytes */
  933. if (FLASH_MODE == X16) {
  934. data80 = 0x80;;
  935. data20 = 0x20;;
  936. } else { /* if (FLASH_MODE == 8) */
  938. data80 = 0x8080;
  939. data20 = 0x2020;
  940. }
  941. while (true) {
  942. READ_SHORT(FLASH_BASE_ADDRESS + offset,
  943.    &rs);
  944. if ((rs & data80) == (s & data80)) /* DQ7 =? DATA */
  945. break; /* DQ7 =  DATA */
  946. if ((rs & data20) == data20) { /* DQ5 =? DATA */
  947. READ_SHORT(FLASH_BASE_ADDRESS +
  948.    offset, &rs);
  949. if ((rs & data80) == (s & data80))
  950. break; /* DQ7 = DATA  */
  951. else {
  952. flashReset();
  953. return false; /* DQ7 != DATA */
  954. }
  955. }
  956. }
  957. WRITE_SHORT(FLASH_BASE_ADDRESS +
  958.     FirstAddr * FLASH_WIDTH, FirstData);
  959. WRITE_SHORT(FLASH_BASE_ADDRESS +
  960.     SecondAddr * FLASH_WIDTH, SecondData);
  961. WRITE_SHORT(FLASH_BASE_ADDRESS +
  962.     ThirdAddr * FLASH_WIDTH, ThirdData);
  963. #ifdef BE
  964. s = data;
  965. #else
  966. s = (data >> 16);
  967. #endif
  968. WRITE_SHORT(FLASH_BASE_ADDRESS + offset + 2, s);
  969. /* Writing Two Bytes */
  970. while (true) {
  971. READ_SHORT(FLASH_BASE_ADDRESS + offset + 2,
  972.    &rs);
  973. if ((rs & data80) == (s & data80)) /* DQ7 =? DATA */
  974. break; /* DQ7 =  DATA */
  975. if ((rs & data20) == data20) { /* DQ5 =? '1'  */
  976. READ_SHORT(FLASH_BASE_ADDRESS +
  977.    offset + 2, &rs);
  978. if ((rs & data80) == (s & data80))
  979. break; /* DQ7 = DATA  */
  980. else {
  981. flashReset();
  982. return false; /* DQ7 != DATA */
  983. }
  984. }
  985. }
  986. return true;
  987. case 4:
  988. case 8:
  989. if (FLASH_MODE == X16) {
  990. FirstData = 0x00aa00aa;
  991. SecondData = 0x00550055;
  992. ThirdData = 0x00a000a0;
  993. FirstAddr = 0x5555;
  994. SecondAddr = 0x2aaa;
  995. ThirdAddr = 0x5555;
  996. } else { /* (FLASH_MODE == 8) */
  998. FirstData = 0xaaaaaaaa; /* Data for the First  Cycle    */
  999. SecondData = 0x55555555; /* Data for the Second Cycle    */
  1000. ThirdData = 0xa0a0a0a0; /* Data for the Third  Cycle    */
  1001. FirstAddr = 0xaaaaaaaa; /* Address for the First  Cycle */
  1002. SecondAddr = 0x55555555; /* Address for the Second Cycle */
  1003. ThirdAddr = 0xaaaaaaaa; /* Address for the Third  Cycle */
  1004. }
  1005. WRITE_WORD(FLASH_BASE_ADDRESS + FirstAddr *
  1006.    FLASH_WIDTH + offset % FLASH_WIDTH,
  1007.    FirstData);
  1008. WRITE_WORD(FLASH_BASE_ADDRESS +
  1009.    SecondAddr * FLASH_WIDTH +
  1010.    offset % FLASH_WIDTH, SecondData);
  1011. WRITE_WORD(FLASH_BASE_ADDRESS +
  1012.    ThirdAddr * FLASH_WIDTH +
  1013.    offset % FLASH_WIDTH, ThirdData);
  1014. /* writting the word. */
  1015. WRITE_WORD(FLASH_BASE_ADDRESS + offset, data);
  1016. /* preparing the polling patterns. */
  1017. if (FLASH_MODE == X16) {
  1018. data80 = 0x00800080;
  1019. data20 = 0x00200020;
  1020. } else { /* (FLASH_MODE == 8) */
  1022. data80 = 0x80808080;
  1023. data20 = 0x20202020;
  1024. }
  1025. while (true) { /* polling loop. */
  1026. rw = READWORD(FLASH_BASE_ADDRESS + offset);
  1027. /* DQ7 =? DATA */
  1028. if ((rw & data80) == (data & data80))
  1029. break; /* DQ7 =  DATA */
  1030. if ((rw & data20) == data20) { /* DQ5 =? '1'  */
  1031. rw =
  1032.     READWORD(FLASH_BASE_ADDRESS +
  1033.      offset);
  1034. if ((rw & data80) ==
  1035.     (data & data80)) break; /* DQ7 = DATA  */
  1036. else
  1037. return false; /* DQ7 != DATA */
  1038. }
  1039. }
  1040. return true;
  1041. default:
  1042. return false; /* case of invalid flash Width. */
  1043. }
  1044. } else { /* Intel/Micron */
  1046. switch (FLASH_WIDTH) {
  1047. case 1:
  1048. /* Writing First Byte */
  1049. WRITE_CHAR(FLASH_BASE_ADDRESS, 0x10);
  1050. #ifdef BE
  1051. c = (data >> 24);
  1052. #else
  1053. c = data;
  1054. #endif
  1055. WRITE_CHAR(FLASH_BASE_ADDRESS + offset, c);
  1056. while (true) {
  1057. /* Reading STATUS Register */
  1058. WRITE_CHAR(FLASH_BASE_ADDRESS, 0x70);
  1059. regValue = READCHAR(FLASH_BASE_ADDRESS);
  1060. if ((regValue & 0x80) == 0x80)
  1061. break; /* Case of Write-Operation had Ended */
  1062. }
  1063. /* Reading STATUS Register for Writing Verification */
  1064. WRITE_CHAR(FLASH_BASE_ADDRESS, 0x70);
  1065. regValue = READCHAR(FLASH_BASE_ADDRESS);
  1066. if ((regValue & 0x10) == 0x10)
  1067. return false; /* Write failure */
  1069. /* Writing Second Byte */
  1070. WRITE_CHAR(FLASH_BASE_ADDRESS + 1, 0x10);
  1071. #ifdef BE
  1072. c = (data >> 16);
  1073. #else
  1074. c = (data >> 8);
  1075. #endif
  1076. WRITE_CHAR(FLASH_BASE_ADDRESS + offset + 1, c);
  1077. while (true) {
  1078. /* Reading STATUS Register */
  1079. WRITE_CHAR(FLASH_BASE_ADDRESS + 1, 0x70);
  1080. regValue =
  1081.     READCHAR(FLASH_BASE_ADDRESS + 1);
  1082. if ((regValue & 0x80) == 0x80)
  1083. break; /* Write operation ended */
  1084. }
  1085. /* Reading STATUS Register for Writing verification */
  1086. WRITE_CHAR(FLASH_BASE_ADDRESS + 1, 0x70);
  1087. regValue = READCHAR(FLASH_BASE_ADDRESS + 1);
  1088. if ((regValue & 0x10) == 0x10)
  1089. return false; /* Write failure */
  1091. /* Writing Third Byte */
  1092. WRITE_CHAR(FLASH_BASE_ADDRESS + 2, 0x10);
  1093. #ifdef BE
  1094. c = (data >> 8);
  1095. #else
  1096. c = (data >> 16);
  1097. #endif
  1098. WRITE_CHAR(FLASH_BASE_ADDRESS + offset + 2, c);
  1099. while (true) {
  1100. /* Reading STATUS Register */
  1101. WRITE_CHAR(FLASH_BASE_ADDRESS + 2, 0x70);
  1102. regValue =
  1103.     READCHAR(FLASH_BASE_ADDRESS + 2);
  1104. if ((regValue & 0x80) == 0x80)
  1105. break; /* Write operation ended */
  1106. }
  1107. /* Reading STATUS Register for Writing Verification */
  1108. WRITE_CHAR(FLASH_BASE_ADDRESS + 2, 0x70);
  1109. regValue = READCHAR(FLASH_BASE_ADDRESS + 2);
  1110. if ((regValue & 0x10) == 0x10)
  1111. return false; /* Write failure */
  1113. /* Writing Fourth Byte */
  1114. WRITE_CHAR(FLASH_BASE_ADDRESS + 3, 0x10);
  1115. #ifdef BE
  1116. c = data;
  1117. #else
  1118. c = (data >> 24);
  1119. #endif
  1120. WRITE_CHAR(FLASH_BASE_ADDRESS + offset + 3, c);
  1121. while (true) {
  1122. /* Reading STATUS Register */
  1123. WRITE_CHAR(FLASH_BASE_ADDRESS + 3, 0x70);
  1124. regValue =
  1125.     READCHAR(FLASH_BASE_ADDRESS + 3);
  1126. if ((regValue & 0x80) == 0x80)
  1127. break; /* Write operation ended */
  1128. }
  1129. /* Reading STATUS Register for Writing Verification */
  1130. WRITE_CHAR(FLASH_BASE_ADDRESS + 3, 0x70);
  1131. regValue = READCHAR(FLASH_BASE_ADDRESS + 3);
  1132. if ((regValue & 0x10) == 0x10)
  1133. return false; /* Write failure */
  1134. flashReset();
  1135. return true;
  1136. case 2:
  1137. if (FLASH_MODE == X16) { /* Case of one X16 bit device */
  1138. FirstData = 0x0010; /* Data for the First  Cycle  */
  1139. } else { /* if (FLASH_MODE == 8) ==> Case of two X8 bit devices */
  1141. FirstData = 0x1010; /* Data for the First  Cycle  */
  1142. }
  1143. /* Writing First two Bytes */
  1144. WRITE_SHORT(FLASH_BASE_ADDRESS, FirstData);
  1145. #ifdef BE
  1146. s = (data >> 16);
  1147. #else
  1148. s = data;
  1149. #endif
  1150. WRITE_SHORT(FLASH_BASE_ADDRESS + offset, s);
  1151. if (FLASH_MODE == X16) {
  1152. data70 = 0x0070;
  1153. data80 = 0x0080;
  1154. data10 = 0x0010;
  1155. } else { /* case of (FLASH_MODE == X8) */
  1157. data70 = 0x7070;
  1158. data80 = 0x8080;
  1159. data10 = 0x1010;
  1160. }
  1161. /* polling on writing action => when done break. */
  1162. while (true) {
  1163. WRITE_SHORT(FLASH_BASE_ADDRESS, data70);
  1164. regValue = READSHORT(FLASH_BASE_ADDRESS);
  1165. if ((regValue & data80) == data80)
  1166. break;
  1167. }
  1168. /* Reading STATUS Register for Writing Verification */
  1169. WRITE_CHAR(FLASH_BASE_ADDRESS, data70);
  1170. regValue = READCHAR(FLASH_BASE_ADDRESS);
  1171. if ((regValue & data10) == data10)
  1172. return false; /* Write failure */
  1173. /* Writing Last two Bytes */
  1174. WRITE_SHORT(FLASH_BASE_ADDRESS + 2, FirstData);
  1175. #ifdef BE
  1176. s = data;
  1177. #else
  1178. s = (data >> 16);
  1179. #endif
  1180. WRITE_SHORT(FLASH_BASE_ADDRESS + offset + 2, s);
  1181. /* polling on writing action => when done break. */
  1182. while (true) {
  1183. WRITE_SHORT(FLASH_BASE_ADDRESS + 2,
  1184.     data70);
  1185. regValue =
  1186.     READSHORT(FLASH_BASE_ADDRESS + 2);
  1187. if ((regValue & data80) == data80)
  1188. break;
  1189. }
  1190. /* Reading STATUS Register for Writing Verification */
  1191. WRITE_CHAR(FLASH_BASE_ADDRESS, data70);
  1192. regValue = READCHAR(FLASH_BASE_ADDRESS);
  1193. if ((regValue & data10) == data10)
  1194. return false; /* Write failure */
  1195. flashReset();
  1196. return true;
  1197. case 4:
  1198. case 8:
  1199. if (FLASH_MODE == X16) { /* Case of one X16 bit device */
  1200. FirstData = 0x00100010; /* Data for the First  Cycle  */
  1201. } else { /* (FLASH_MODE == 8) ==> Case of two X8 bit devices */
  1203. FirstData = 0x10101010; /* Data for the First  Cycle  */
  1204. }
  1205. /* Writing First two Bytes */
  1206. WRITE_WORD(FLASH_BASE_ADDRESS +
  1207.    offset % FLASH_WIDTH, FirstData);
  1208. #ifdef BE
  1209. s = (data >> 16);
  1210. #else
  1211. s = data;
  1212. #endif
  1213. /* writing the 32-bit data to flash. */
  1214. WRITE_WORD(FLASH_BASE_ADDRESS + offset, data);
  1215. if (FLASH_MODE == X16) {
  1216. data70 = 0x0070;
  1217. data80 = 0x0080;
  1218. data10 = 0x0010;
  1219. } else { /* (FLASH_MODE == 8) */
  1221. data70 = 0x7070;
  1222. data80 = 0x8080;
  1223. data10 = 0x1010;
  1224. }
  1225. while (true) {
  1226. WRITE_SHORT(FLASH_BASE_ADDRESS +
  1227.     offset % FLASH_WIDTH, data70);
  1228. regValue = READSHORT(FLASH_BASE_ADDRESS);
  1229. if ((regValue & data80) == data80)
  1230. break;
  1231. }
  1232. /* Reading STATUS Register for Writing Verification */
  1233. WRITE_CHAR(FLASH_BASE_ADDRESS, data70);
  1234. regValue = READCHAR(FLASH_BASE_ADDRESS);
  1235. if ((regValue & data10) == data10)
  1236. return false; /* Write failure */
  1238. /* Writing Last two Bytes */
  1239. #ifdef BE
  1240. s = data;
  1241. #else
  1242. s = (data >> 16);
  1243. #endif
  1244. while (true) {
  1245. WRITE_SHORT(FLASH_BASE_ADDRESS +
  1246.     offset % FLASH_WIDTH + 2,
  1247.     data70);
  1248. regValue =
  1249.     READSHORT(FLASH_BASE_ADDRESS +
  1250.       offset % FLASH_WIDTH + 2);
  1251. if ((regValue & data80) == data80)
  1252. break;
  1253. }
  1254. /* Reading STATUS Register for Writing Verification */
  1255. WRITE_CHAR(FLASH_BASE_ADDRESS, data70);
  1256. regValue = READCHAR(FLASH_BASE_ADDRESS);
  1257. if ((regValue & data10) == data10)
  1258. return false; /* Write failure */
  1260. flashReset();
  1261. return true;
  1262. default:
  1263. flashReset();
  1264. return false;
  1265. }
  1266. }
  1267. flashReset();
  1268. return true;
  1269. }
  1271. /********************************************************************
  1272. * flashReadWord - Read 32Bit from the FLASH memory at a given offset
  1273. *                 from the FLASH base address.
  1274. *    address 0 = 0x00000000 !!
  1275. *                 The function takes care of Big/Little endian conversion
  1276. * INPUTS:  offset,the offset from the flash`s base address
  1277. * RETURNS: data
  1278. *********************************************************************/
  1279. unsigned int flashReadWord(unsigned int offset)
  1280. {
  1281. unsigned int regValue;
  1282. flashReset();
  1283. READ_WORD(FLASH_BASE_ADDRESS + offset, &regValue);
  1284. return regValue;
  1285. }
  1287. /********************************************************************
  1288. * flashInWhichSector - Returns the sector`s number at which offset is at.
  1289. *
  1290. * INPUTS:  Offset
  1291. * RETURNS: Sector number,or 0xffffffff in case the address is out of range or
  1292. *          flash wasn't initialize.
  1293. *********************************************************************/
  1294. unsigned int flashInWhichSector(unsigned int offset)
  1295. {
  1296. unsigned int sectorNumber, numberOfDevices;
  1297. unsigned int accMemory = 0;
  1299. if ((FLASH_MODE == PURE8) || (FLASH_MODE == X8)) {
  1300. numberOfDevices = FLASH_WIDTH;
  1301. } else { /* X16 mode */
  1303. numberOfDevices = FLASH_WIDTH / 2;
  1304. }
  1305. for (sectorNumber = 0;
  1306.      sectorNumber < flashTypes[NUMBER_OF_SECTORS]; sectorNumber++) {
  1307. accMemory =
  1308.     accMemory + flashTypes[FIRST_SECTOR_SIZE +
  1309.    sectorNumber];
  1310. if (offset < accMemory * numberOfDevices * 1024)
  1311. return sectorNumber;
  1312. }
  1313. return 0xffffffff;
  1314. }
  1316. /********************************************************************
  1317. * flashGetSectorSize - When given a Valid sector Number returns its Size.
  1318. *
  1319. * INPUTS:  unsigned int sectorNumber.
  1320. * RETURNS: Sector size. (if Sector number isn't valid or flash wasn't
  1321. *          initialize return 0.)
  1322. *********************************************************************/
  1323. unsigned int flashGetSectorSize(unsigned int sectorNumber)
  1324. {
  1325. if (sectorNumber >= flashTypes[NUMBER_OF_SECTORS])
  1326. return 0;
  1327. else {
  1328. if (FLASH_MODE != PURE8)
  1329. return (flashTypes
  1330. [FIRST_SECTOR_SIZE +
  1331.  sectorNumber] * _1K * (FLASH_WIDTH * 8 /
  1332. FLASH_MODE));
  1333. else /* in case of PUR8 */
  1334. return (flashTypes
  1335. [FIRST_SECTOR_SIZE +
  1336.  sectorNumber] * _1K * FLASH_WIDTH);
  1337. }
  1338. }
  1340. /********************************************************************
  1341. * getFlashSize - Return Total flash size.
  1342. *
  1343. * INPUTS:  N/A.
  1344. * RETURNS: Flash size. (If flash wasn't initialize return 0)
  1345. *********************************************************************/
  1346. unsigned int flashGetSize()
  1347. {
  1348. unsigned int sectorNum;
  1349. unsigned int totalSize = 0;
  1351. if (POINTER_TO_FLASH == 0)
  1352. return 0; /* case of flash not initialize */
  1353. for (sectorNum = 0; sectorNum < flashTypes[NUMBER_OF_SECTORS];
  1354.      sectorNum++) {
  1355. totalSize += flashGetSectorSize(sectorNum);
  1356. }
  1357. return (totalSize);
  1359. }
  1361. /********************************************************************
  1362. * flashGetSectorOffset - Returns sector base address.
  1363. *
  1364. * INPUTS:  unsigned int sectorNum.
  1365. * RETURNS: Sector Base Address.
  1366. *********************************************************************/
  1367. unsigned int flashGetSectorOffset(unsigned int sectorNum)
  1368. {
  1369. unsigned int i;
  1370. unsigned int sectorBaseAddress = 0;
  1371. unsigned int numOfDevices;
  1373. if (sectorNum > (flashParametrs[NUMBER_OF_SECTORS] - 1))
  1374. return 0xffffffff;
  1375. for (i = 0; i < sectorNum; i++) {
  1376. sectorBaseAddress =
  1377.     sectorBaseAddress + flashTypes[FIRST_SECTOR_SIZE + i];
  1378. }
  1379. if (FLASH_MODE == X16)
  1380. numOfDevices = FLASH_WIDTH * 8 / FLASH_MODE;
  1381. else
  1382. numOfDevices = FLASH_WIDTH;
  1383. return (_1K * sectorBaseAddress * numOfDevices);
  1385. }
  1387. /********************************************************************
  1388. * flashWriteBlock - Write block of chars to flash.
  1389. *
  1390. * INPUTS:  unsigned int offset - flash destination address.
  1391. *          unsigned int numOfByte - block size.
  1392. *          unsigned char * blockAddress - block source address.
  1393. * RETURNS: Number of Bytes written.
  1394. *********************************************************************/
  1395. unsigned int flashWriteBlock(unsigned int offset, unsigned int numOfByte,
  1396.      unsigned char *blockAddress)
  1397. {
  1398. register unsigned int flashWrite;
  1399. register unsigned int align;
  1400. register unsigned int num;
  1401. register unsigned int i;
  1403. if ((offset + numOfByte) > flashGetSize())
  1404. numOfByte = flashGetSize() - offset; /* getting to flash boundary. */
  1405. num = numOfByte;
  1406. align = offset % 4; /* alignment toward flash.    */
  1407. /* writes chars until the offset toward flash will be align. */
  1408. for (i = align; (i < 4) && (numOfByte > 0) && (align != 0); i++) {
  1409. flashWriteChar(offset, blockAddress[0]);
  1410. numOfByte--;
  1411. offset++;
  1412. blockAddress++;
  1413. }
  1414. while (numOfByte > 3) {
  1415. #ifdef LE
  1416. flashWrite = blockAddress[0] | (blockAddress[1] << 8) |
  1417.     (blockAddress[2] << 16) | (blockAddress[3] << 24);
  1418. #else
  1419. flashWrite = blockAddress[3] | (blockAddress[2] << 8) |
  1420.     (blockAddress[1] << 16) | (blockAddress[0] << 24);
  1421. #endif
  1422. if (flashWrite != 0xffffffff) /* for optimization. */
  1423. flashWriteWord(offset, flashWrite);
  1424. numOfByte -= 4;
  1425. blockAddress += 4;
  1426. offset += 4;
  1427. }
  1428. while (numOfByte > 0) {
  1429. flashWriteChar(offset, blockAddress[0]);
  1430. numOfByte--;
  1431. blockAddress++;
  1432. offset++;
  1433. }
  1434. return num;
  1435. }
  1437. /********************************************************************
  1438. * flashReadBlock - Read block of chars from flash.
  1439. *
  1440. * INPUTS:  unsigned int offset - flash source address.
  1441. *          unsigned int numOfByte - block size.
  1442. *          unsigned char * blockAddress - block destination address.
  1443. * RETURNS: Number of Bytes written.
  1444. *********************************************************************/
  1445. unsigned int flashReadBlock(unsigned int offset, unsigned int numOfByte,
  1446.     unsigned char *blockAddress)
  1447. {
  1448. unsigned int i;
  1449. for (i = 0; i < numOfByte; i++) {
  1450. blockAddress[i] = flashReadChar(offset + i);
  1451. }
  1452. return numOfByte;
  1453. }
  1455. /********************************************************************
  1456. * flashReadChar - read one charecter form given flash offset.
  1457. *
  1458. * INPUTS:  unsigned int offset - required offset to be read from.
  1459. * RETURNS: read charecter.
  1460. *********************************************************************/
  1461. unsigned char flashReadChar(unsigned int offset)
  1462. {
  1463. unsigned char regValue;
  1465. flashReset();
  1466. READ_CHAR(FLASH_BASE_ADDRESS + offset, &regValue);
  1467. return regValue;
  1468. }
  1470. /********************************************************************
  1471. * flashReadShort - read 16bit form given flash offset.
  1472. *
  1473. * INPUTS:  unsigned int offset - required offset to be read from.
  1474. * RETURNS: 16bit data.
  1475. *********************************************************************/
  1476. unsigned short flashReadShort(unsigned int offset)
  1477. {
  1478. unsigned short regValue;
  1480. flashReset();
  1481. READ_SHORT(FLASH_BASE_ADDRESS + offset, &regValue);
  1482. return regValue;
  1483. }
  1485. /********************************************************************
  1486. * flashWriteShort - write 16bit data to a given flash offset.
  1487. *                  It reads the whole word 32bit wide, modify the  short
  1488. *                  and write back the word.
  1489. *
  1490. * INPUTS:  unsigned int offset - required offset to be write to.
  1491. *          unsigned short sdata - data to be written.
  1492. * RETURNS: true if writting successesed false otherwise.
  1493. *********************************************************************/
  1494. bool flashWriteShort(unsigned int offset, unsigned short sdata)
  1495. {
  1496. unsigned int align;
  1497. unsigned int flashWrite;
  1498. unsigned int flashRead;
  1500. align = offset % 4;
  1501. if ((align == 1) || (align == 3))
  1502. return false; /* offset misaligned. */
  1503. flashRead = flashReadWord(offset - align);
  1504. if (align == 0)
  1505. #ifdef BE
  1506. flashWrite = (flashRead & 0x0000ffff) | (sdata << 16);
  1507. #else
  1508. flashWrite = (flashRead & 0xffff0000) | sdata;
  1509. #endif
  1510. else /* (align == 2) */
  1511. #ifdef BE
  1512. flashWrite = (flashRead & 0xffff0000) | sdata;
  1513. #else
  1514. flashWrite = (flashRead & 0x0000ffff) | (sdata << 16);
  1515. #endif
  1516. flashWriteWord(offset - align, flashWrite);
  1517. return true;
  1519. }
  1521. /********************************************************************
  1522. * flashWriteChar - write one charecter (8 bit) to a given flash offset.
  1523. *                  It reads the whole word 32bit wide, modify the charecter
  1524. *                  and write back the word.
  1525. *
  1526. * INPUTS:  unsigned int offset - required offset to be write to.
  1527. *          unsigned short sdata - data to be written.
  1528. * RETURNS: true if writting successed.
  1529. *********************************************************************/
  1530. bool flashWriteChar(unsigned int offset, unsigned char cdata)
  1531. {
  1532. unsigned int align;
  1533. unsigned int flashWrite;
  1534. unsigned int flashRead;
  1536. align = offset % 4;
  1537. flashRead = flashReadWord(offset - align);
  1538. #ifdef BE
  1539. flashWrite = (flashRead & ~(0xff000000 >> (8 * align))) |
  1540.     (cdata << (8 * (3 - align)));
  1541. #else
  1542. flashWrite = (flashRead & ~(0xff000000 << (8 * align))) |
  1543.     (cdata << (8 * align));
  1544. #endif
  1545. flashWriteWord(offset - align, flashWrite);
  1546. return true;
  1547. }
  1549. /********************************************************************
  1550. * flashGetNumOfSectors - write one charecter (8 bit) to a given flash offset.
  1551. *                        It reads the whole word 32bit wide, modify the
  1552. *                        charecter and write back the word.
  1553. *
  1554. * INPUTS:  N/A.
  1555. * RETURNS: Number of sectors.
  1556. *********************************************************************/
  1557. unsigned int flashGetNumOfSectors(void)
  1558. {
  1559. return (flashTypes[NUMBER_OF_SECTORS]);
  1560. }