flash.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473
  1. /*
  2. * U-Boot - flash.c Flash driver for PSD4256GV
  3. *
  4. * Copyright (c) 2005-2007 Analog Devices Inc.
  5. * This file is based on BF533EzFlash.c originally written by Analog Devices, Inc.
  6. *
  7. * (C) Copyright 2000-2004
  8. * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  9. *
  10. * SPDX-License-Identifier: GPL-2.0+
  11. */
  12. #include <asm/io.h>
  13. #include "flash-defines.h"
  14. int AFP_NumSectors = 40;
  15. long AFP_SectorSize1 = 0x10000;
  16. int AFP_SectorSize2 = 0x4000;
  17. void flash_reset(void)
  18. {
  19. reset_flash();
  20. }
  21. unsigned long flash_get_size(ulong baseaddr, flash_info_t * info, int bank_flag)
  22. {
  23. int id = 0, i = 0;
  24. static int FlagDev = 1;
  25. id = get_codes();
  26. if (FlagDev) {
  27. #ifdef DEBUG
  28. printf("Device ID of the Flash is %x\n", id);
  29. #endif
  30. FlagDev = 0;
  31. }
  32. info->flash_id = id;
  33. switch (bank_flag) {
  34. case 0:
  35. for (i = PriFlashABegin; i < SecFlashABegin; i++)
  36. info->start[i] = (baseaddr + (i * AFP_SectorSize1));
  37. info->size = 0x200000;
  38. info->sector_count = 32;
  39. break;
  40. case 1:
  41. info->start[0] = baseaddr + SecFlashASec1Off;
  42. info->start[1] = baseaddr + SecFlashASec2Off;
  43. info->start[2] = baseaddr + SecFlashASec3Off;
  44. info->start[3] = baseaddr + SecFlashASec4Off;
  45. info->size = 0x10000;
  46. info->sector_count = 4;
  47. break;
  48. case 2:
  49. info->start[0] = baseaddr + SecFlashBSec1Off;
  50. info->start[1] = baseaddr + SecFlashBSec2Off;
  51. info->start[2] = baseaddr + SecFlashBSec3Off;
  52. info->start[3] = baseaddr + SecFlashBSec4Off;
  53. info->size = 0x10000;
  54. info->sector_count = 4;
  55. break;
  56. }
  57. return (info->size);
  58. }
  59. unsigned long flash_init(void)
  60. {
  61. unsigned long size_b0, size_b1, size_b2;
  62. int i;
  63. size_b0 = size_b1 = size_b2 = 0;
  64. #ifdef DEBUG
  65. printf("Flash Memory Start 0x%x\n", CONFIG_SYS_FLASH_BASE);
  66. printf("Memory Map for the Flash\n");
  67. printf("0x20000000 - 0x200FFFFF Flash A Primary (1MB)\n");
  68. printf("0x20100000 - 0x201FFFFF Flash B Primary (1MB)\n");
  69. printf("0x20200000 - 0x2020FFFF Flash A Secondary (64KB)\n");
  70. printf("0x20280000 - 0x2028FFFF Flash B Secondary (64KB)\n");
  71. printf("Please type command flinfo for information on Sectors \n");
  72. #endif
  73. for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
  74. flash_info[i].flash_id = FLASH_UNKNOWN;
  75. }
  76. size_b0 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[0], 0);
  77. size_b1 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[1], 1);
  78. size_b2 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[2], 2);
  79. if (flash_info[0].flash_id == FLASH_UNKNOWN || size_b0 == 0) {
  80. printf("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
  81. size_b0, size_b0 >> 20);
  82. }
  83. (void)flash_protect(FLAG_PROTECT_SET, CONFIG_SYS_FLASH0_BASE,
  84. (flash_info[0].start[2] - 1), &flash_info[0]);
  85. return (size_b0 + size_b1 + size_b2);
  86. }
  87. void flash_print_info(flash_info_t * info)
  88. {
  89. int i;
  90. if (info->flash_id == FLASH_UNKNOWN) {
  91. printf("missing or unknown FLASH type\n");
  92. return;
  93. }
  94. switch (info->flash_id) {
  95. case FLASH_PSD4256GV:
  96. printf("ST Microelectronics ");
  97. break;
  98. default:
  99. printf("Unknown Vendor: (0x%08lX) ", info->flash_id);
  100. break;
  101. }
  102. for (i = 0; i < info->sector_count; ++i) {
  103. if ((i % 5) == 0)
  104. printf("\n ");
  105. printf(" %08lX%s",
  106. info->start[i], info->protect[i] ? " (RO)" : " ");
  107. }
  108. printf("\n");
  109. return;
  110. }
  111. int flash_erase(flash_info_t * info, int s_first, int s_last)
  112. {
  113. int cnt = 0, i;
  114. int prot, sect;
  115. prot = 0;
  116. for (sect = s_first; sect <= s_last; ++sect) {
  117. if (info->protect[sect])
  118. prot++;
  119. }
  120. if (prot)
  121. printf("- Warning: %d protected sectors will not be erased!\n",
  122. prot);
  123. else
  124. printf("\n");
  125. cnt = s_last - s_first + 1;
  126. if (cnt == FLASH_TOT_SECT) {
  127. printf("Erasing flash, Please Wait \n");
  128. if (erase_flash() < 0) {
  129. printf("Erasing flash failed \n");
  130. return FLASH_FAIL;
  131. }
  132. } else {
  133. printf("Erasing Flash locations, Please Wait\n");
  134. for (i = s_first; i <= s_last; i++) {
  135. if (info->protect[i] == 0) { /* not protected */
  136. if (erase_block_flash(i, info->start[i]) < 0) {
  137. printf("Error Sector erasing \n");
  138. return FLASH_FAIL;
  139. }
  140. }
  141. }
  142. }
  143. return FLASH_SUCCESS;
  144. }
  145. int write_buff(flash_info_t * info, uchar * src, ulong addr, ulong cnt)
  146. {
  147. int ret;
  148. int d;
  149. if (addr % 2) {
  150. read_flash(addr - 1 - CONFIG_SYS_FLASH_BASE, &d);
  151. d = (int)((d & 0x00FF) | (*src++ << 8));
  152. ret = write_data(addr - 1, 2, (uchar *) & d);
  153. if (ret == FLASH_FAIL)
  154. return ERR_NOT_ERASED;
  155. ret = write_data(addr + 1, cnt - 1, src);
  156. } else
  157. ret = write_data(addr, cnt, src);
  158. if (ret == FLASH_FAIL)
  159. return ERR_NOT_ERASED;
  160. return FLASH_SUCCESS;
  161. }
  162. int write_data(long lStart, long lCount, uchar * pnData)
  163. {
  164. long i = 0;
  165. unsigned long ulOffset = lStart - CONFIG_SYS_FLASH_BASE;
  166. int d;
  167. int nSector = 0;
  168. int flag = 0;
  169. if (lCount % 2) {
  170. flag = 1;
  171. lCount = lCount - 1;
  172. }
  173. for (i = 0; i < lCount - 1; i += 2, ulOffset += 2) {
  174. get_sector_number(ulOffset, &nSector);
  175. read_flash(ulOffset, &d);
  176. if (d != 0xffff) {
  177. printf
  178. ("Flash not erased at offset 0x%lx Please erase to reprogram\n",
  179. ulOffset);
  180. return FLASH_FAIL;
  181. }
  182. unlock_flash(ulOffset);
  183. d = (int)(pnData[i] | pnData[i + 1] << 8);
  184. write_flash(ulOffset, d);
  185. if (poll_toggle_bit(ulOffset) < 0) {
  186. printf("Error programming the flash \n");
  187. return FLASH_FAIL;
  188. }
  189. if ((i > 0) && (!(i % AFP_SectorSize2)))
  190. printf(".");
  191. }
  192. if (flag) {
  193. get_sector_number(ulOffset, &nSector);
  194. read_flash(ulOffset, &d);
  195. if (d != 0xffff) {
  196. printf
  197. ("Flash not erased at offset 0x%lx Please erase to reprogram\n",
  198. ulOffset);
  199. return FLASH_FAIL;
  200. }
  201. unlock_flash(ulOffset);
  202. d = (int)(pnData[i] | (d & 0xFF00));
  203. write_flash(ulOffset, d);
  204. if (poll_toggle_bit(ulOffset) < 0) {
  205. printf("Error programming the flash \n");
  206. return FLASH_FAIL;
  207. }
  208. }
  209. return FLASH_SUCCESS;
  210. }
  211. int read_data(long ulStart, long lCount, long lStride, int *pnData)
  212. {
  213. long i = 0;
  214. int j = 0;
  215. long ulOffset = ulStart;
  216. int iShift = 0;
  217. int iNumWords = 2;
  218. int nLeftover = lCount % 4;
  219. int nHi, nLow;
  220. int nSector = 0;
  221. for (i = 0; (i < lCount / 4) && (i < BUFFER_SIZE); i++) {
  222. for (iShift = 0, j = 0; j < iNumWords; j += 2) {
  223. if ((ulOffset >= INVALIDLOCNSTART)
  224. && (ulOffset < INVALIDLOCNEND))
  225. return FLASH_FAIL;
  226. get_sector_number(ulOffset, &nSector);
  227. read_flash(ulOffset, &nLow);
  228. ulOffset += (lStride * 2);
  229. read_flash(ulOffset, &nHi);
  230. ulOffset += (lStride * 2);
  231. pnData[i] = (nHi << 16) | nLow;
  232. }
  233. }
  234. if (nLeftover > 0) {
  235. if ((ulOffset >= INVALIDLOCNSTART)
  236. && (ulOffset < INVALIDLOCNEND))
  237. return FLASH_FAIL;
  238. get_sector_number(ulOffset, &nSector);
  239. read_flash(ulOffset, &pnData[i]);
  240. }
  241. return FLASH_SUCCESS;
  242. }
  243. int write_flash(long nOffset, int nValue)
  244. {
  245. long addr;
  246. addr = (CONFIG_SYS_FLASH_BASE + nOffset);
  247. SSYNC();
  248. *(unsigned volatile short *)addr = nValue;
  249. SSYNC();
  250. if (poll_toggle_bit(nOffset) < 0)
  251. return FLASH_FAIL;
  252. return FLASH_SUCCESS;
  253. }
  254. int read_flash(long nOffset, int *pnValue)
  255. {
  256. int nValue = 0x0;
  257. long addr = (CONFIG_SYS_FLASH_BASE + nOffset);
  258. if (nOffset != 0x2)
  259. reset_flash();
  260. SSYNC();
  261. nValue = *(volatile unsigned short *)addr;
  262. SSYNC();
  263. *pnValue = nValue;
  264. return true;
  265. }
  266. int poll_toggle_bit(long lOffset)
  267. {
  268. unsigned int u1, u2;
  269. unsigned long timeout = 0xFFFFFFFF;
  270. volatile unsigned long *FB =
  271. (volatile unsigned long *)(0x20000000 + lOffset);
  272. while (1) {
  273. if (timeout < 0)
  274. break;
  275. u1 = *(volatile unsigned short *)FB;
  276. u2 = *(volatile unsigned short *)FB;
  277. if ((u1 & 0x0040) == (u2 & 0x0040))
  278. return FLASH_SUCCESS;
  279. if ((u2 & 0x0020) == 0x0000)
  280. continue;
  281. u1 = *(volatile unsigned short *)FB;
  282. if ((u2 & 0x0040) == (u1 & 0x0040))
  283. return FLASH_SUCCESS;
  284. else {
  285. reset_flash();
  286. return FLASH_FAIL;
  287. }
  288. timeout--;
  289. }
  290. printf("Time out occured \n");
  291. if (timeout < 0)
  292. return FLASH_FAIL;
  293. }
  294. void reset_flash(void)
  295. {
  296. write_flash(WRITESEQ1, RESET_VAL);
  297. /* Wait for 10 micro seconds */
  298. udelay(10);
  299. }
  300. int erase_flash(void)
  301. {
  302. write_flash(WRITESEQ1, WRITEDATA1);
  303. write_flash(WRITESEQ2, WRITEDATA2);
  304. write_flash(WRITESEQ3, WRITEDATA3);
  305. write_flash(WRITESEQ4, WRITEDATA4);
  306. write_flash(WRITESEQ5, WRITEDATA5);
  307. write_flash(WRITESEQ6, WRITEDATA6);
  308. if (poll_toggle_bit(0x0000) < 0)
  309. return FLASH_FAIL;
  310. write_flash(SecFlashAOff + WRITESEQ1, WRITEDATA1);
  311. write_flash(SecFlashAOff + WRITESEQ2, WRITEDATA2);
  312. write_flash(SecFlashAOff + WRITESEQ3, WRITEDATA3);
  313. write_flash(SecFlashAOff + WRITESEQ4, WRITEDATA4);
  314. write_flash(SecFlashAOff + WRITESEQ5, WRITEDATA5);
  315. write_flash(SecFlashAOff + WRITESEQ6, WRITEDATA6);
  316. if (poll_toggle_bit(SecFlashASec1Off) < 0)
  317. return FLASH_FAIL;
  318. write_flash(PriFlashBOff + WRITESEQ1, WRITEDATA1);
  319. write_flash(PriFlashBOff + WRITESEQ2, WRITEDATA2);
  320. write_flash(PriFlashBOff + WRITESEQ3, WRITEDATA3);
  321. write_flash(PriFlashBOff + WRITESEQ4, WRITEDATA4);
  322. write_flash(PriFlashBOff + WRITESEQ5, WRITEDATA5);
  323. write_flash(PriFlashBOff + WRITESEQ6, WRITEDATA6);
  324. if (poll_toggle_bit(PriFlashBOff) < 0)
  325. return FLASH_FAIL;
  326. write_flash(SecFlashBOff + WRITESEQ1, WRITEDATA1);
  327. write_flash(SecFlashBOff + WRITESEQ2, WRITEDATA2);
  328. write_flash(SecFlashBOff + WRITESEQ3, WRITEDATA3);
  329. write_flash(SecFlashBOff + WRITESEQ4, WRITEDATA4);
  330. write_flash(SecFlashBOff + WRITESEQ5, WRITEDATA5);
  331. write_flash(SecFlashBOff + WRITESEQ6, WRITEDATA6);
  332. if (poll_toggle_bit(SecFlashBOff) < 0)
  333. return FLASH_FAIL;
  334. return FLASH_SUCCESS;
  335. }
  336. int erase_block_flash(int nBlock, unsigned long address)
  337. {
  338. long ulSectorOff = 0x0;
  339. if ((nBlock < 0) || (nBlock > AFP_NumSectors))
  340. return false;
  341. ulSectorOff = (address - CONFIG_SYS_FLASH_BASE);
  342. write_flash((WRITESEQ1 | ulSectorOff), WRITEDATA1);
  343. write_flash((WRITESEQ2 | ulSectorOff), WRITEDATA2);
  344. write_flash((WRITESEQ3 | ulSectorOff), WRITEDATA3);
  345. write_flash((WRITESEQ4 | ulSectorOff), WRITEDATA4);
  346. write_flash((WRITESEQ5 | ulSectorOff), WRITEDATA5);
  347. write_flash(ulSectorOff, BlockEraseVal);
  348. if (poll_toggle_bit(ulSectorOff) < 0)
  349. return FLASH_FAIL;
  350. return FLASH_SUCCESS;
  351. }
  352. void unlock_flash(long ulOffset)
  353. {
  354. unsigned long ulOffsetAddr = ulOffset;
  355. ulOffsetAddr &= 0xFFFF0000;
  356. write_flash((WRITESEQ1 | ulOffsetAddr), UNLOCKDATA1);
  357. write_flash((WRITESEQ2 | ulOffsetAddr), UNLOCKDATA2);
  358. write_flash((WRITESEQ3 | ulOffsetAddr), UNLOCKDATA3);
  359. }
  360. int get_codes()
  361. {
  362. int dev_id = 0;
  363. write_flash(WRITESEQ1, GETCODEDATA1);
  364. write_flash(WRITESEQ2, GETCODEDATA2);
  365. write_flash(WRITESEQ3, GETCODEDATA3);
  366. read_flash(0x0002, &dev_id);
  367. dev_id &= 0x00FF;
  368. reset_flash();
  369. return dev_id;
  370. }
  371. void get_sector_number(long ulOffset, int *pnSector)
  372. {
  373. int nSector = 0;
  374. if (ulOffset >= SecFlashAOff) {
  375. if ((ulOffset < SecFlashASec1Off)
  376. && (ulOffset < SecFlashASec2Off)) {
  377. nSector = SECT32;
  378. } else if ((ulOffset >= SecFlashASec2Off)
  379. && (ulOffset < SecFlashASec3Off)) {
  380. nSector = SECT33;
  381. } else if ((ulOffset >= SecFlashASec3Off)
  382. && (ulOffset < SecFlashASec4Off)) {
  383. nSector = SECT34;
  384. } else if ((ulOffset >= SecFlashASec4Off)
  385. && (ulOffset < SecFlashAEndOff)) {
  386. nSector = SECT35;
  387. }
  388. } else if (ulOffset >= SecFlashBOff) {
  389. if ((ulOffset < SecFlashBSec1Off)
  390. && (ulOffset < SecFlashBSec2Off)) {
  391. nSector = SECT36;
  392. }
  393. if ((ulOffset < SecFlashBSec2Off)
  394. && (ulOffset < SecFlashBSec3Off)) {
  395. nSector = SECT37;
  396. }
  397. if ((ulOffset < SecFlashBSec3Off)
  398. && (ulOffset < SecFlashBSec4Off)) {
  399. nSector = SECT38;
  400. }
  401. if ((ulOffset < SecFlashBSec4Off)
  402. && (ulOffset < SecFlashBEndOff)) {
  403. nSector = SECT39;
  404. }
  405. } else if ((ulOffset >= PriFlashAOff) && (ulOffset < SecFlashAOff)) {
  406. nSector = ulOffset & 0xffff0000;
  407. nSector = ulOffset >> 16;
  408. nSector = nSector & 0x000ff;
  409. }
  410. if ((nSector >= 0) && (nSector < AFP_NumSectors)) {
  411. *pnSector = nSector;
  412. }
  413. }