flash.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491
  1. /*
  2. * (C) Copyright 2000-2004
  3. * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  4. *
  5. * SPDX-License-Identifier: GPL-2.0+
  6. */
  7. /*
  8. * Modified 4/5/2001
  9. * Wait for completion of each sector erase command issued
  10. * 4/5/2001
  11. * Chris Hallinan - DS4.COM, Inc. - clh@net1plus.com
  12. */
  13. #include <common.h>
  14. #include <asm/ppc4xx.h>
  15. #include <asm/processor.h>
  16. #if CONFIG_SYS_MAX_FLASH_BANKS != 1
  17. #error "CONFIG_SYS_MAX_FLASH_BANKS must be 1"
  18. #endif
  19. flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips */
  20. /*-----------------------------------------------------------------------
  21. * Functions
  22. */
  23. static ulong flash_get_size (vu_long * addr, flash_info_t * info);
  24. static int write_word (flash_info_t * info, ulong dest, ulong data);
  25. static void flash_get_offsets (ulong base, flash_info_t * info);
  26. #define ADDR0 0x5555
  27. #define ADDR1 0x2aaa
  28. #define FLASH_WORD_SIZE unsigned char
  29. /*-----------------------------------------------------------------------
  30. */
  31. unsigned long flash_init (void)
  32. {
  33. unsigned long size_b0;
  34. /* Init: no FLASHes known */
  35. flash_info[0].flash_id = FLASH_UNKNOWN;
  36. /* Static FLASH Bank configuration here - FIXME XXX */
  37. size_b0 = flash_get_size ((vu_long *) FLASH_BASE0_PRELIM, &flash_info[0]);
  38. if (flash_info[0].flash_id == FLASH_UNKNOWN) {
  39. printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
  40. size_b0, size_b0 << 20);
  41. }
  42. /* Only one bank */
  43. /* Setup offsets */
  44. flash_get_offsets (FLASH_BASE0_PRELIM, &flash_info[0]);
  45. /* Monitor protection ON by default */
  46. (void) flash_protect (FLAG_PROTECT_SET,
  47. FLASH_BASE0_PRELIM,
  48. FLASH_BASE0_PRELIM + monitor_flash_len - 1,
  49. &flash_info[0]);
  50. flash_info[0].size = size_b0;
  51. return size_b0;
  52. }
  53. /*-----------------------------------------------------------------------
  54. */
  55. /*
  56. * This implementation assumes that the flash chips are uniform sector
  57. * devices. This is true for all likely JSE devices.
  58. */
  59. static void flash_get_offsets (ulong base, flash_info_t * info)
  60. {
  61. unsigned idx;
  62. unsigned long sector_size = info->size / info->sector_count;
  63. for (idx = 0; idx < info->sector_count; idx += 1) {
  64. info->start[idx] = base + (idx * sector_size);
  65. }
  66. }
  67. /*-----------------------------------------------------------------------
  68. */
  69. void flash_print_info (flash_info_t * info)
  70. {
  71. int i;
  72. int k;
  73. int size;
  74. int erased;
  75. volatile unsigned long *flash;
  76. if (info->flash_id == FLASH_UNKNOWN) {
  77. printf ("missing or unknown FLASH type\n");
  78. return;
  79. }
  80. switch (info->flash_id & FLASH_VENDMASK) {
  81. case FLASH_MAN_AMD:
  82. printf ("AMD ");
  83. break;
  84. case FLASH_MAN_FUJ:
  85. printf ("FUJITSU ");
  86. break;
  87. case FLASH_MAN_SST:
  88. printf ("SST ");
  89. break;
  90. case FLASH_MAN_STM:
  91. printf ("ST Micro ");
  92. break;
  93. default:
  94. printf ("Unknown Vendor ");
  95. break;
  96. }
  97. /* (Reduced table of only parts expected in JSE boards.) */
  98. switch (info->flash_id) {
  99. case FLASH_MAN_AMD | FLASH_AM040:
  100. printf ("AM29F040 (512 Kbit, uniform sector size)\n");
  101. break;
  102. case FLASH_MAN_STM | FLASH_AM040:
  103. printf ("MM29W040W (512 Kbit, uniform sector size)\n");
  104. break;
  105. default:
  106. printf ("Unknown Chip Type\n");
  107. break;
  108. }
  109. printf (" Size: %ld KB in %d Sectors\n",
  110. info->size >> 10, info->sector_count);
  111. printf (" Sector Start Addresses:");
  112. for (i = 0; i < info->sector_count; ++i) {
  113. /*
  114. * Check if whole sector is erased
  115. */
  116. if (i != (info->sector_count - 1))
  117. size = info->start[i + 1] - info->start[i];
  118. else
  119. size = info->start[0] + info->size - info->start[i];
  120. erased = 1;
  121. flash = (volatile unsigned long *) info->start[i];
  122. size = size >> 2; /* divide by 4 for longword access */
  123. for (k = 0; k < size; k++) {
  124. if (*flash++ != 0xffffffff) {
  125. erased = 0;
  126. break;
  127. }
  128. }
  129. if ((i % 5) == 0)
  130. printf ("\n ");
  131. printf (" %08lX%s%s",
  132. info->start[i],
  133. erased ? " E" : " ", info->protect[i] ? "RO " : " "
  134. );
  135. }
  136. printf ("\n");
  137. return;
  138. }
  139. /*-----------------------------------------------------------------------
  140. */
  141. /*-----------------------------------------------------------------------
  142. */
  143. /*
  144. * The following code cannot be run from FLASH!
  145. */
  146. static ulong flash_get_size (vu_long * addr, flash_info_t * info)
  147. {
  148. short i;
  149. FLASH_WORD_SIZE value;
  150. ulong base = (ulong) addr;
  151. volatile FLASH_WORD_SIZE *addr2 = (FLASH_WORD_SIZE *) addr;
  152. /* Write auto select command: read Manufacturer ID */
  153. addr2[ADDR0] = (FLASH_WORD_SIZE) 0x00AA00AA;
  154. addr2[ADDR1] = (FLASH_WORD_SIZE) 0x00550055;
  155. addr2[ADDR0] = (FLASH_WORD_SIZE) 0x00900090;
  156. value = addr2[0];
  157. switch (value) {
  158. case (FLASH_WORD_SIZE) AMD_MANUFACT:
  159. info->flash_id = FLASH_MAN_AMD;
  160. break;
  161. case (FLASH_WORD_SIZE) FUJ_MANUFACT:
  162. info->flash_id = FLASH_MAN_FUJ;
  163. break;
  164. case (FLASH_WORD_SIZE) SST_MANUFACT:
  165. info->flash_id = FLASH_MAN_SST;
  166. break;
  167. case (FLASH_WORD_SIZE)STM_MANUFACT:
  168. info->flash_id = FLASH_MAN_STM;
  169. break;
  170. default:
  171. info->flash_id = FLASH_UNKNOWN;
  172. info->sector_count = 0;
  173. info->size = 0;
  174. printf("Unknown flash manufacturer code: 0x%x\n", value);
  175. return (0); /* no or unknown flash */
  176. }
  177. value = addr2[1]; /* device ID */
  178. switch (value) {
  179. case (FLASH_WORD_SIZE) AMD_ID_F040B:
  180. info->flash_id += FLASH_AM040;
  181. info->sector_count = 8;
  182. info->size = 0x0080000; /* => 512 ko */
  183. break;
  184. case (FLASH_WORD_SIZE) AMD_ID_LV040B:
  185. info->flash_id += FLASH_AM040;
  186. info->sector_count = 8;
  187. info->size = 0x0080000; /* => 512 ko */
  188. break;
  189. case (FLASH_WORD_SIZE)STM_ID_M29W040B: /* most likele JSE chip */
  190. info->flash_id += FLASH_AM040;
  191. info->sector_count = 8;
  192. info->size = 0x0080000; /* => 512 ko */
  193. break;
  194. default:
  195. info->flash_id = FLASH_UNKNOWN;
  196. return (0); /* => no or unknown flash */
  197. }
  198. /* Calculate the sector offsets (Use JSE Optimized code). */
  199. flash_get_offsets(base, info);
  200. /* check for protected sectors */
  201. for (i = 0; i < info->sector_count; i++) {
  202. /* read sector protection at sector address, (A7 .. A0) = 0x02 */
  203. /* D0 = 1 if protected */
  204. addr2 = (volatile FLASH_WORD_SIZE *) (info->start[i]);
  205. if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST)
  206. info->protect[i] = 0;
  207. else
  208. info->protect[i] = addr2[2] & 1;
  209. }
  210. /*
  211. * Prevent writes to uninitialized FLASH.
  212. */
  213. if (info->flash_id != FLASH_UNKNOWN) {
  214. addr2 = (FLASH_WORD_SIZE *) info->start[0];
  215. *addr2 = (FLASH_WORD_SIZE) 0x00F000F0; /* reset bank */
  216. }
  217. return (info->size);
  218. }
  219. int wait_for_DQ7 (flash_info_t * info, int sect)
  220. {
  221. ulong start, now, last;
  222. volatile FLASH_WORD_SIZE *addr =
  223. (FLASH_WORD_SIZE *) (info->start[sect]);
  224. start = get_timer (0);
  225. last = start;
  226. while ((addr[0] & (FLASH_WORD_SIZE) 0x00800080) !=
  227. (FLASH_WORD_SIZE) 0x00800080) {
  228. if ((now = get_timer (start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
  229. printf ("Timeout\n");
  230. return -1;
  231. }
  232. /* show that we're waiting */
  233. if ((now - last) > 1000) { /* every second */
  234. putc ('.');
  235. last = now;
  236. }
  237. }
  238. return 0;
  239. }
  240. /*-----------------------------------------------------------------------
  241. */
  242. int flash_erase (flash_info_t * info, int s_first, int s_last)
  243. {
  244. volatile FLASH_WORD_SIZE *addr = (FLASH_WORD_SIZE *) (info->start[0]);
  245. volatile FLASH_WORD_SIZE *addr2;
  246. int flag, prot, sect;
  247. int i;
  248. if ((s_first < 0) || (s_first > s_last)) {
  249. if (info->flash_id == FLASH_UNKNOWN) {
  250. printf ("- missing\n");
  251. } else {
  252. printf ("- no sectors to erase\n");
  253. }
  254. return 1;
  255. }
  256. if (info->flash_id == FLASH_UNKNOWN) {
  257. printf ("Can't erase unknown flash type - aborted\n");
  258. return 1;
  259. }
  260. prot = 0;
  261. for (sect = s_first; sect <= s_last; ++sect) {
  262. if (info->protect[sect]) {
  263. prot++;
  264. }
  265. }
  266. if (prot) {
  267. printf ("- Warning: %d protected sectors will not be erased!\n", prot);
  268. } else {
  269. printf ("\n");
  270. }
  271. /* Disable interrupts which might cause a timeout here */
  272. flag = disable_interrupts ();
  273. /* Start erase on unprotected sectors */
  274. for (sect = s_first; sect <= s_last; sect++) {
  275. if (info->protect[sect] == 0) { /* not protected */
  276. addr2 = (FLASH_WORD_SIZE *) (info->start[sect]);
  277. printf ("Erasing sector %p\n", addr2); /* CLH */
  278. if ((info->flash_id & FLASH_VENDMASK) ==
  279. FLASH_MAN_SST) {
  280. addr[ADDR0] = (FLASH_WORD_SIZE) 0x00AA00AA;
  281. addr[ADDR1] = (FLASH_WORD_SIZE) 0x00550055;
  282. addr[ADDR0] = (FLASH_WORD_SIZE) 0x00800080;
  283. addr[ADDR0] = (FLASH_WORD_SIZE) 0x00AA00AA;
  284. addr[ADDR1] = (FLASH_WORD_SIZE) 0x00550055;
  285. addr2[0] = (FLASH_WORD_SIZE) 0x00500050; /* block erase */
  286. for (i = 0; i < 50; i++)
  287. udelay (1000); /* wait 1 ms */
  288. } else {
  289. addr[ADDR0] = (FLASH_WORD_SIZE) 0x00AA00AA;
  290. addr[ADDR1] = (FLASH_WORD_SIZE) 0x00550055;
  291. addr[ADDR0] = (FLASH_WORD_SIZE) 0x00800080;
  292. addr[ADDR0] = (FLASH_WORD_SIZE) 0x00AA00AA;
  293. addr[ADDR1] = (FLASH_WORD_SIZE) 0x00550055;
  294. addr2[0] = (FLASH_WORD_SIZE) 0x00300030; /* sector erase */
  295. }
  296. /*
  297. * Wait for each sector to complete, it's more
  298. * reliable. According to AMD Spec, you must
  299. * issue all erase commands within a specified
  300. * timeout. This has been seen to fail, especially
  301. * if printf()s are included (for debug)!!
  302. */
  303. wait_for_DQ7 (info, sect);
  304. }
  305. }
  306. /* re-enable interrupts if necessary */
  307. if (flag)
  308. enable_interrupts ();
  309. /* wait at least 80us - let's wait 1 ms */
  310. udelay (1000);
  311. /* reset to read mode */
  312. addr = (FLASH_WORD_SIZE *) info->start[0];
  313. addr[0] = (FLASH_WORD_SIZE) 0x00F000F0; /* reset bank */
  314. printf (" done\n");
  315. return 0;
  316. }
  317. /*-----------------------------------------------------------------------
  318. * Copy memory to flash, returns:
  319. * 0 - OK
  320. * 1 - write timeout
  321. * 2 - Flash not erased
  322. */
  323. int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
  324. {
  325. ulong cp, wp, data;
  326. int i, l, rc;
  327. wp = (addr & ~3); /* get lower word aligned address */
  328. /*
  329. * handle unaligned start bytes
  330. */
  331. if ((l = addr - wp) != 0) {
  332. data = 0;
  333. for (i = 0, cp = wp; i < l; ++i, ++cp) {
  334. data = (data << 8) | (*(uchar *) cp);
  335. }
  336. for (; i < 4 && cnt > 0; ++i) {
  337. data = (data << 8) | *src++;
  338. --cnt;
  339. ++cp;
  340. }
  341. for (; cnt == 0 && i < 4; ++i, ++cp) {
  342. data = (data << 8) | (*(uchar *) cp);
  343. }
  344. if ((rc = write_word (info, wp, data)) != 0) {
  345. return (rc);
  346. }
  347. wp += 4;
  348. }
  349. /*
  350. * handle word aligned part
  351. */
  352. while (cnt >= 4) {
  353. data = 0;
  354. for (i = 0; i < 4; ++i) {
  355. data = (data << 8) | *src++;
  356. }
  357. if ((rc = write_word (info, wp, data)) != 0) {
  358. return (rc);
  359. }
  360. wp += 4;
  361. cnt -= 4;
  362. }
  363. if (cnt == 0) {
  364. return (0);
  365. }
  366. /*
  367. * handle unaligned tail bytes
  368. */
  369. data = 0;
  370. for (i = 0, cp = wp; i < 4 && cnt > 0; ++i, ++cp) {
  371. data = (data << 8) | *src++;
  372. --cnt;
  373. }
  374. for (; i < 4; ++i, ++cp) {
  375. data = (data << 8) | (*(uchar *) cp);
  376. }
  377. return (write_word (info, wp, data));
  378. }
  379. /*-----------------------------------------------------------------------
  380. * Write a word to Flash, returns:
  381. * 0 - OK
  382. * 1 - write timeout
  383. * 2 - Flash not erased
  384. */
  385. static int write_word (flash_info_t * info, ulong dest, ulong data)
  386. {
  387. volatile FLASH_WORD_SIZE *addr2 =
  388. (FLASH_WORD_SIZE *) (info->start[0]);
  389. volatile FLASH_WORD_SIZE *dest2 = (FLASH_WORD_SIZE *) dest;
  390. volatile FLASH_WORD_SIZE *data2 = (FLASH_WORD_SIZE *) & data;
  391. ulong start;
  392. int i;
  393. /* Check if Flash is (sufficiently) erased */
  394. if ((*((volatile FLASH_WORD_SIZE *) dest) &
  395. (FLASH_WORD_SIZE) data) != (FLASH_WORD_SIZE) data) {
  396. return (2);
  397. }
  398. for (i = 0; i < 4 / sizeof (FLASH_WORD_SIZE); i++) {
  399. int flag;
  400. /* Disable interrupts which might cause a timeout here */
  401. flag = disable_interrupts ();
  402. addr2[ADDR0] = (FLASH_WORD_SIZE) 0x00AA00AA;
  403. addr2[ADDR1] = (FLASH_WORD_SIZE) 0x00550055;
  404. addr2[ADDR0] = (FLASH_WORD_SIZE) 0x00A000A0;
  405. dest2[i] = data2[i];
  406. /* re-enable interrupts if necessary */
  407. if (flag)
  408. enable_interrupts ();
  409. /* data polling for D7 */
  410. start = get_timer (0);
  411. while ((dest2[i] & (FLASH_WORD_SIZE) 0x00800080) !=
  412. (data2[i] & (FLASH_WORD_SIZE) 0x00800080)) {
  413. if (get_timer (start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
  414. return (1);
  415. }
  416. }
  417. }
  418. return (0);
  419. }