3 * Erik Theisen, Wave 7 Optics, etheisen@mindspring.com.
5 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
7 * See file CREDITS for list of people who contributed to this
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of
13 * the License, or (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
27 #include <asm/ppc4xx.h>
28 #include <asm/processor.h>
32 /* info for FLASH chips */
33 flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
38 static ulong flash_get_size(vu_long *addr, flash_info_t *info);
39 static int write_word8(flash_info_t *info, ulong dest, ulong data);
40 static int write_word32(flash_info_t *info, ulong dest, ulong data);
41 static void flash_get_offsets(ulong base, flash_info_t *info);
43 unsigned long flash_init(void)
46 unsigned long size_b0, base_b0;
47 unsigned long size_b1, base_b1;
49 /* Init: no FLASHes known */
50 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i)
51 flash_info[i].flash_id = FLASH_UNKNOWN;
53 /* Get Size of Boot and Main Flashes */
54 size_b0 = flash_get_size((vu_long *) FLASH_BASE0_PRELIM,
56 if (flash_info[0].flash_id == FLASH_UNKNOWN) {
57 printf("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
58 size_b0, size_b0 << 20);
62 flash_get_size((vu_long *) FLASH_BASE1_PRELIM,
64 if (flash_info[1].flash_id == FLASH_UNKNOWN) {
65 printf("## Unknown FLASH on Bank 1 - Size = 0x%08lx = %ld MB\n",
66 size_b1, size_b1 << 20);
70 /* Calculate base addresses */
74 /* Setup offsets for Boot Flash */
75 flash_get_offsets(base_b0, &flash_info[0]);
77 /* Protect board level data */
78 (void) flash_protect(FLAG_PROTECT_SET,
80 flash_info[0].start[1] - 1, &flash_info[0]);
82 /* Monitor protection ON by default */
83 (void) flash_protect(FLAG_PROTECT_SET,
84 base_b0 + size_b0 - monitor_flash_len,
85 base_b0 + size_b0 - 1, &flash_info[0]);
87 /* Protect the FPGA image */
88 (void) flash_protect(FLAG_PROTECT_SET,
90 FLASH_BASE1_PRELIM + CONFIG_SYS_FPGA_IMAGE_LEN -
93 /* Protect the default boot image */
94 (void) flash_protect(FLAG_PROTECT_SET,
95 FLASH_BASE1_PRELIM + CONFIG_SYS_FPGA_IMAGE_LEN,
96 FLASH_BASE1_PRELIM + CONFIG_SYS_FPGA_IMAGE_LEN +
97 0x600000 - 1, &flash_info[1]);
99 /* Setup offsets for Main Flash */
100 flash_get_offsets(FLASH_BASE1_PRELIM, &flash_info[1]);
102 return size_b0 + size_b1;
105 static void flash_get_offsets(ulong base, flash_info_t *info)
109 /* set up sector start address table - FOR BOOT ROM ONLY!!! */
110 if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM040) {
111 for (i = 0; i < info->sector_count; i++)
112 info->start[i] = base + (i * 0x00010000);
114 } /* end flash_get_offsets() */
116 void flash_print_info(flash_info_t *info)
122 volatile unsigned long *flash;
124 if (info->flash_id == FLASH_UNKNOWN) {
125 printf("missing or unknown FLASH type\n");
129 switch (info->flash_id & FLASH_VENDMASK) {
136 case FLASH_MAN_INTEL:
137 printf("2 x Intel ");
140 printf("Unknown Vendor ");
143 switch (info->flash_id & FLASH_TYPEMASK) {
145 if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_AMD)
146 printf("AM29LV040 (4096 Kbit, uniform sector size)\n");
147 else if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_STM)
148 printf("M29W040B (4096 Kbit, uniform block size)\n");
150 printf("UNKNOWN 29x040x (4096 Kbit, uniform sector size)\n");
152 case FLASH_28F320J3A:
153 printf("28F320J3A (32 Mbit = 128K x 32)\n");
155 case FLASH_28F640J3A:
156 printf("28F640J3A (64 Mbit = 128K x 64)\n");
158 case FLASH_28F128J3A:
159 printf("28F128J3A (128 Mbit = 128K x 128)\n");
162 printf("Unknown Chip Type\n");
165 if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_STM) {
166 printf(" Size: %ld KB in %d Blocks\n",
167 info->size >> 10, info->sector_count);
169 printf(" Size: %ld KB in %d Sectors\n",
170 info->size >> 10, info->sector_count);
173 printf(" Sector Start Addresses:");
174 for (i = 0; i < info->sector_count; ++i) {
176 * Check if whole sector is erased
178 if (i != (info->sector_count - 1))
179 size = info->start[i + 1] - info->start[i];
181 size = info->start[0] + info->size - info->start[i];
183 flash = (volatile unsigned long *) info->start[i];
184 size = size >> 2; /* divide by 4 for longword access */
185 for (k = 0; k < size; k++) {
186 if (*flash++ != 0xffffffff) {
197 info->protect[i] ? "RO " : " ");
200 } /* end flash_print_info() */
203 * The following code cannot be run from FLASH!
205 static ulong flash_get_size(vu_long *addr, flash_info_t *info)
208 ulong base = (ulong) addr;
210 /* Setup default type */
211 info->flash_id = FLASH_UNKNOWN;
212 info->sector_count = 0;
215 /* Test for Boot Flash */
216 if (base == FLASH_BASE0_PRELIM) {
218 volatile unsigned char *addr2 = (unsigned char *) addr;
220 /* Write auto select command: read Manufacturer ID */
221 *(addr2 + 0x555) = 0xaa;
222 *(addr2 + 0x2aa) = 0x55;
223 *(addr2 + 0x555) = 0x90;
228 case (unsigned char) AMD_MANUFACT:
229 info->flash_id = FLASH_MAN_AMD;
231 case (unsigned char) STM_MANUFACT:
232 info->flash_id = FLASH_MAN_STM;
235 *addr2 = 0xf0; /* no or unknown flash */
240 value = *(addr2 + 1);
242 case (unsigned char) AMD_ID_LV040B:
243 case (unsigned char) STM_ID_29W040B:
244 info->flash_id += FLASH_AM040;
245 info->sector_count = 8;
246 info->size = 0x00080000;
247 break; /* => 512Kb */
249 *addr2 = 0xf0; /* => no or unknown flash */
252 } else { /* MAIN Flash */
254 volatile unsigned long *addr2 = (unsigned long *) addr;
256 /* Write auto select command: read Manufacturer ID */
262 case (unsigned long) INTEL_MANUFACT:
263 info->flash_id = FLASH_MAN_INTEL;
266 *addr2 = 0xff; /* no or unknown flash */
270 /* Device ID - This shit is interleaved... */
271 value = *(addr2 + 1);
273 case (unsigned long) INTEL_ID_28F320J3A:
274 info->flash_id += FLASH_28F320J3A;
275 info->sector_count = 32;
276 info->size = 0x00400000 * 2;
277 break; /* => 2 X 4 MB */
278 case (unsigned long) INTEL_ID_28F640J3A:
279 info->flash_id += FLASH_28F640J3A;
280 info->sector_count = 64;
281 info->size = 0x00800000 * 2;
282 break; /* => 2 X 8 MB */
283 case (unsigned long) INTEL_ID_28F128J3A:
284 info->flash_id += FLASH_28F128J3A;
285 info->sector_count = 128;
286 info->size = 0x01000000 * 2;
287 break; /* => 2 X 16 MB */
289 *addr2 = 0xff; /* => no or unknown flash */
293 /* Make sure we don't exceed CONFIG_SYS_MAX_FLASH_SECT */
294 if (info->sector_count > CONFIG_SYS_MAX_FLASH_SECT) {
295 printf("** ERROR: sector count %d > max (%d) **\n",
296 info->sector_count, CONFIG_SYS_MAX_FLASH_SECT);
297 info->sector_count = CONFIG_SYS_MAX_FLASH_SECT;
300 /* set up sector start address table */
301 switch (info->flash_id & FLASH_TYPEMASK) {
303 for (i = 0; i < info->sector_count; i++)
304 info->start[i] = base + (i * 0x00010000);
306 case FLASH_28F320J3A:
307 case FLASH_28F640J3A:
308 case FLASH_28F128J3A:
309 for (i = 0; i < info->sector_count; i++)
310 info->start[i] = base +
311 (i * 0x00020000 * 2); /* 2 Banks */
315 /* Test for Boot Flash */
316 if (base == FLASH_BASE0_PRELIM) {
317 volatile unsigned char *addr2;
319 /* check for protected sectors */
320 for (i = 0; i < info->sector_count; i++) {
322 * read sector protection at sector address,
324 * D0 = 1 if protected
326 addr2 = (volatile unsigned char *) (info->start[i]);
327 info->protect[i] = *(addr2 + 2) & 1;
330 /* Restore read mode */
331 *(unsigned char *) base = 0xF0; /* Reset NORMAL Flash */
332 } else { /* Main Flash */
333 volatile unsigned long *addr2;
335 /* check for protected sectors */
336 for (i = 0; i < info->sector_count; i++) {
338 * read sector protection at sector address,
340 * D0 = 1 if protected
342 addr2 = (volatile unsigned long *) (info->start[i]);
343 info->protect[i] = *(addr2 + 2) & 0x1;
346 /* Restore read mode */
347 *(unsigned long *) base = 0xFFFFFFFF; /* Reset Flash */
351 } /* end flash_get_size() */
353 static int wait_for_DQ7(ulong addr, uchar cmp_val, ulong tout)
357 volatile uchar *vaddr = (uchar *) addr;
360 for (i = 1; i <= (100 * tout); i++) { /* Wait up to tout ms */
364 /* Check for completion */
365 if ((vaddr[0] & 0x80) == (cmp_val & 0x80))
368 /* KEEP THE LUSER HAPPY - Print a dot every 1.1 seconds */
372 /* Kick the dog if needed */
377 } /* wait_for_DQ7() */
379 static int flash_erase8(flash_info_t *info, int s_first, int s_last)
381 int tcode, rcode = 0;
382 volatile uchar *addr = (uchar *) (info->start[0]);
383 volatile uchar *sector_addr;
384 int flag, prot, sect;
386 /* Validate arguments */
387 if ((s_first < 0) || (s_first > s_last)) {
388 if (info->flash_id == FLASH_UNKNOWN)
389 printf("- missing\n");
391 printf("- no sectors to erase\n");
395 /* Check for KNOWN flash type */
396 if (info->flash_id == FLASH_UNKNOWN) {
397 printf("Can't erase unknown flash type - aborted\n");
401 /* Check for protected sectors */
403 for (sect = s_first; sect <= s_last; ++sect) {
404 if (info->protect[sect])
408 printf("- Warning: %d protected sectors will not be erased!\n",
414 /* Start erase on unprotected sectors */
415 for (sect = s_first; sect <= s_last; sect++) {
416 if (info->protect[sect] == 0) { /* not protected */
417 sector_addr = (uchar *) (info->start[sect]);
419 if ((info->flash_id & FLASH_VENDMASK) ==
421 printf("Erasing block %p\n", sector_addr);
423 printf("Erasing sector %p\n", sector_addr);
425 /* Disable interrupts which might cause timeout */
426 flag = disable_interrupts();
428 *(addr + 0x555) = (uchar) 0xAA;
429 *(addr + 0x2aa) = (uchar) 0x55;
430 *(addr + 0x555) = (uchar) 0x80;
431 *(addr + 0x555) = (uchar) 0xAA;
432 *(addr + 0x2aa) = (uchar) 0x55;
433 *sector_addr = (uchar) 0x30; /* sector erase */
436 * Wait for each sector to complete, it's more
437 * reliable. According to AMD Spec, you must
438 * issue all erase commands within a specified
439 * timeout. This has been seen to fail, especially
440 * if printf()s are included (for debug)!!
441 * Takes up to 6 seconds.
443 tcode = wait_for_DQ7((ulong) sector_addr, 0x80, 6000);
445 /* re-enable interrupts if necessary */
449 /* Make sure we didn't timeout */
457 /* wait at least 80us - let's wait 1 ms */
460 /* reset to read mode */
461 addr = (uchar *) info->start[0];
462 *addr = (uchar) 0xF0; /* reset bank */
466 } /* end flash_erase8() */
468 static int flash_erase32(flash_info_t *info, int s_first, int s_last)
471 ulong start, now, last;
474 /* Validate arguments */
475 if ((s_first < 0) || (s_first > s_last)) {
476 if (info->flash_id == FLASH_UNKNOWN)
477 printf("- missing\n");
479 printf("- no sectors to erase\n");
483 /* Check for KNOWN flash type */
484 if ((info->flash_id & FLASH_VENDMASK) != FLASH_MAN_INTEL) {
485 printf("Can erase only Intel flash types - aborted\n");
489 /* Check for protected sectors */
490 for (sect = s_first; sect <= s_last; ++sect) {
491 if (info->protect[sect])
495 printf("- Warning: %d protected sectors will not be erased!\n",
501 start = get_timer(0);
503 /* Start erase on unprotected sectors */
504 for (sect = s_first; sect <= s_last; sect++) {
506 if (info->protect[sect] == 0) { /* not protected */
507 vu_long *addr = (vu_long *) (info->start[sect]);
508 unsigned long status;
510 /* Disable interrupts which might cause a timeout */
511 flag = disable_interrupts();
513 *addr = 0x00500050; /* clear status register */
514 *addr = 0x00200020; /* erase setup */
515 *addr = 0x00D000D0; /* erase confirm */
517 /* re-enable interrupts if necessary */
521 /* Wait at least 80us - let's wait 1 ms */
524 while (((status = *addr) & 0x00800080) != 0x00800080) {
525 now = get_timer(start);
526 if (now > CONFIG_SYS_FLASH_ERASE_TOUT) {
530 /* reset to read mode */
536 * show that we're waiting
539 if ((now - last) > 990) {
544 *addr = 0x00FF00FF; /* reset to read mode */
551 int flash_erase(flash_info_t *info, int s_first, int s_last)
553 if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM040)
554 return flash_erase8(info, s_first, s_last);
556 return flash_erase32(info, s_first, s_last);
560 * Copy memory to flash, returns:
563 * 2 - Flash not erased
565 static int write_buff8(flash_info_t *info, uchar *src, ulong addr,
572 start = get_timer(0);
574 wp = (addr & ~3); /* get lower word
578 * handle unaligned start bytes
583 for (i = 0, cp = wp; i < l; ++i, ++cp)
584 data = (data << 8) | (*(uchar *) cp);
586 for (; i < 4 && cnt > 0; ++i) {
587 data = (data << 8) | *src++;
592 for (; cnt == 0 && i < 4; ++i, ++cp)
593 data = (data << 8) | (*(uchar *) cp);
595 rc = write_word8(info, wp, data);
603 * handle word aligned part
607 for (i = 0; i < 4; ++i)
608 data = (data << 8) | *src++;
610 rc = write_word8(info, wp, data);
616 if (get_timer(start) > 1000) { /* every second */
619 start = get_timer(0);
627 * handle unaligned tail bytes
630 for (i = 0, cp = wp; i < 4 && cnt > 0; ++i, ++cp) {
631 data = (data << 8) | *src++;
635 for (; i < 4; ++i, ++cp)
636 data = (data << 8) | (*(uchar *) cp);
638 return write_word8(info, wp, data);
641 #define FLASH_WIDTH 4 /* flash bus width in bytes */
642 static int write_buff32(flash_info_t *info, uchar *src, ulong addr,
649 start = get_timer(0);
651 if (info->flash_id == FLASH_UNKNOWN)
654 /* get lower FLASH_WIDTH aligned address */
655 wp = (addr & ~(FLASH_WIDTH - 1));
658 * handle unaligned start bytes
660 if ((l = addr - wp) != 0) {
662 for (i = 0, cp = wp; i < l; ++i, ++cp)
663 data = (data << 8) | (*(uchar *) cp);
665 for (; i < FLASH_WIDTH && cnt > 0; ++i) {
666 data = (data << 8) | *src++;
671 for (; cnt == 0 && i < FLASH_WIDTH; ++i, ++cp)
672 data = (data << 8) | (*(uchar *) cp);
674 rc = write_word32(info, wp, data);
682 * handle FLASH_WIDTH aligned part
684 while (cnt >= FLASH_WIDTH) {
686 for (i = 0; i < FLASH_WIDTH; ++i)
687 data = (data << 8) | *src++;
689 rc = write_word32(info, wp, data);
695 if (get_timer(start) > 990) { /* every second */
697 start = get_timer(0);
705 * handle unaligned tail bytes
708 for (i = 0, cp = wp; i < FLASH_WIDTH && cnt > 0; ++i, ++cp) {
709 data = (data << 8) | *src++;
713 for (; i < FLASH_WIDTH; ++i, ++cp)
714 data = (data << 8) | (*(uchar *) cp);
716 return write_word32(info, wp, data);
719 int write_buff(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
723 if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM040)
724 retval = write_buff8(info, src, addr, cnt);
726 retval = write_buff32(info, src, addr, cnt);
732 * Write a word to Flash, returns:
735 * 2 - Flash not erased
738 static int write_word8(flash_info_t *info, ulong dest, ulong data)
740 volatile uchar *addr2 = (uchar *) (info->start[0]);
741 volatile uchar *dest2 = (uchar *) dest;
742 volatile uchar *data2 = (uchar *) &data;
744 int i, tcode, rcode = 0;
746 /* Check if Flash is (sufficently) erased */
747 if ((*((volatile uchar *)dest) & (uchar)data) != (uchar)data)
750 for (i = 0; i < (4 / sizeof(uchar)); i++) {
751 /* Disable interrupts which might cause a timeout here */
752 flag = disable_interrupts();
754 *(addr2 + 0x555) = (uchar) 0xAA;
755 *(addr2 + 0x2aa) = (uchar) 0x55;
756 *(addr2 + 0x555) = (uchar) 0xA0;
760 /* Wait for write to complete, up to 1ms */
761 tcode = wait_for_DQ7((ulong) &dest2[i], data2[i], 1);
763 /* re-enable interrupts if necessary */
767 /* Make sure we didn't timeout */
775 static int write_word32(flash_info_t *info, ulong dest, ulong data)
777 vu_long *addr = (vu_long *) dest;
782 /* Check if Flash is (sufficiently) erased */
783 if ((*addr & data) != data)
786 /* Disable interrupts which might cause a timeout here */
787 flag = disable_interrupts();
789 *addr = 0x00400040; /* write setup */
792 /* re-enable interrupts if necessary */
796 start = get_timer(0);
798 while (((status = *addr) & 0x00800080) != 0x00800080) {
800 if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
801 *addr = 0x00FF00FF; /* restore read mode */
806 *addr = 0x00FF00FF; /* restore read mode */
811 static int _flash_protect(flash_info_t *info, long sector)
817 volatile long *addr = (long *)sector;
819 switch (info->flash_id & FLASH_TYPEMASK) {
820 case FLASH_28F320J3A:
821 case FLASH_28F640J3A:
822 case FLASH_28F128J3A:
823 /* Disable interrupts which might cause Flash to timeout */
824 flag = disable_interrupts();
827 *addr = 0x00500050L; /* Clear the status register */
828 *addr = 0x00600060L; /* Set lock bit setup */
829 *addr = 0x00010001L; /* Set lock bit confirm */
831 /* Wait for command completion */
832 for (i = 0; i < 10; i++) { /* 75us timeout, wait 100us */
834 if ((*addr & 0x00800080L) == 0x00800080L)
838 /* Not successful? */
840 if (status != 0x00800080L) {
841 printf("Protect %x sector failed: %x\n",
842 (uint) sector, (uint) status);
846 /* Restore read mode */
849 /* re-enable interrupts if necessary */
854 case FLASH_AM040: /* No soft sector protection */
858 /* Turn protection on for this sector */
859 for (i = 0; i < info->sector_count; i++) {
860 if (info->start[i] == sector) {
861 info->protect[i] = 1;
869 static int _flash_unprotect(flash_info_t *info, long sector)
875 volatile long *addr = (long *) sector;
877 switch (info->flash_id & FLASH_TYPEMASK) {
878 case FLASH_28F320J3A:
879 case FLASH_28F640J3A:
880 case FLASH_28F128J3A:
881 /* Disable interrupts which might cause Flash to timeout */
882 flag = disable_interrupts();
884 *addr = 0x00500050L; /* Clear the status register */
885 *addr = 0x00600060L; /* Clear lock bit setup */
886 *addr = 0x00D000D0L; /* Clear lock bit confirm */
888 /* Wait for command completion */
889 for (i = 0; i < 80; i++) { /* 700ms timeout, wait 800 */
890 udelay(10000); /* Delay 10ms */
891 if ((*addr & 0x00800080L) == 0x00800080L)
895 /* Not successful? */
897 if (status != 0x00800080L) {
898 printf("Un-protect %x sector failed: %x\n",
899 (uint) sector, (uint) status);
904 /* restore read mode */
907 /* re-enable interrupts if necessary */
912 case FLASH_AM040: /* No soft sector protection */
917 * Fix Intel's little red wagon. Reprotect
918 * sectors that were protected before we undid
919 * protection on a specific sector.
921 for (i = 0; i < info->sector_count; i++) {
922 if (info->start[i] != sector) {
923 if (info->protect[i]) {
924 if (_flash_protect(info, info->start[i]))
927 } else /* Turn protection off for this sector */
928 info->protect[i] = 0;
934 int flash_real_protect(flash_info_t *info, long sector, int prot)
939 rcode = _flash_protect(info, info->start[sector]);
941 rcode = _flash_unprotect(info, info->start[sector]);