3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * See file CREDITS for list of people who contributed to this
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
26 #include <asm/processor.h>
28 #if defined(CONFIG_CAM5200) && defined(CONFIG_CAM5200_NIOSFLASH)
31 #define DEBUGF(x...) printf(x)
36 #define swap16(x) __swab16(x)
38 flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips */
41 * CAM5200 is a TQM5200B based board. Additionally it also features
42 * a NIOS cpu. The NIOS CPU peripherals are accessible through MPC5xxx
43 * Local Bus on CS5. This includes 32 bit wide RAM and SRAM as well as
44 * 16 bit wide flash device. Big Endian order on a 32 bit CS5 makes
45 * access to flash chip slightly more complicated as additional byte
46 * swapping is necessary within each 16 bit wide flash 'word'.
48 * This driver's task is to handle both flash devices: 32 bit TQM5200B
49 * flash chip and 16 bit NIOS cpu flash chip. In the below
50 * flash_addr_table table we use least significant address bit to mark
51 * 16 bit flash bank and two sets of routines *_32 and *_16 to handle
52 * specifics of both flashes.
54 static unsigned long flash_addr_table[][CONFIG_SYS_MAX_FLASH_BANKS] = {
55 {CONFIG_SYS_BOOTCS_START, CONFIG_SYS_CS5_START | 1}
58 /*-----------------------------------------------------------------------
61 static int write_word(flash_info_t * info, ulong dest, ulong data);
62 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
63 static int write_word_32(flash_info_t * info, ulong dest, ulong data);
64 static int write_word_16(flash_info_t * info, ulong dest, ulong data);
65 static int flash_erase_32(flash_info_t * info, int s_first, int s_last);
66 static int flash_erase_16(flash_info_t * info, int s_first, int s_last);
67 static ulong flash_get_size_32(vu_long * addr, flash_info_t * info);
68 static ulong flash_get_size_16(vu_long * addr, flash_info_t * info);
71 void flash_print_info(flash_info_t * info)
75 volatile unsigned long *flash;
77 if (info->flash_id == FLASH_UNKNOWN) {
78 printf("missing or unknown FLASH type\n");
82 switch (info->flash_id & FLASH_VENDMASK) {
90 printf("Unknown Vendor ");
94 switch (info->flash_id & FLASH_TYPEMASK) {
96 printf ("S29GL128N (256 Mbit, uniform sector size)\n");
99 printf ("29LV320B (32 Mbit, bottom boot sect)\n");
102 printf ("29LV320T (32 Mbit, top boot sect)\n");
105 printf("Unknown Chip Type\n");
109 printf(" Size: %ld KB in %d Sectors\n",
110 info->size >> 10, info->sector_count);
112 printf(" Sector Start Addresses:");
113 for (i = 0; i < info->sector_count; ++i) {
115 * Check if whole sector is erased
117 if (i != (info->sector_count - 1))
118 size = info->start[i + 1] - info->start[i];
120 size = info->start[0] + info->size - info->start[i];
123 flash = (volatile unsigned long *)info->start[i];
124 size = size >> 2; /* divide by 4 for longword access */
126 for (k = 0; k < size; k++) {
127 if (*flash++ != 0xffffffff) {
136 printf(" %08lX%s%s", info->start[i],
138 info->protect[i] ? "RO " : " ");
146 * The following code cannot be run from FLASH!
148 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
149 static ulong flash_get_size(vu_long * addr, flash_info_t * info)
152 DEBUGF("get_size: FLASH ADDR %08lx\n", addr);
154 /* bit 0 used for big flash marking */
155 if ((ulong)addr & 0x1)
156 return flash_get_size_16((vu_long *)((ulong)addr & 0xfffffffe), info);
158 return flash_get_size_32(addr, info);
161 static ulong flash_get_size_32(vu_long * addr, flash_info_t * info)
163 static ulong flash_get_size(vu_long * addr, flash_info_t * info)
167 CONFIG_SYS_FLASH_WORD_SIZE value;
168 ulong base = (ulong) addr;
169 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *) addr;
171 DEBUGF("get_size32: FLASH ADDR: %08x\n", (unsigned)addr);
173 /* Write auto select command: read Manufacturer ID */
174 addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00AA00AA;
175 addr2[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00550055;
176 addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00900090;
180 DEBUGF("FLASH MANUFACT: %x\n", value);
183 case (CONFIG_SYS_FLASH_WORD_SIZE) AMD_MANUFACT:
184 info->flash_id = FLASH_MAN_AMD;
187 info->flash_id = FLASH_UNKNOWN;
188 info->sector_count = 0;
190 return (0); /* no or unknown flash */
193 value = addr2[1]; /* device ID */
194 DEBUGF("\nFLASH DEVICEID: %x\n", value);
198 DEBUGF("Mirror Bit flash: addr[14] = %08lX addr[15] = %08lX\n",
201 case AMD_ID_GL128N_2:
202 if (addr[15] != AMD_ID_GL128N_3) {
203 DEBUGF("Chip: S29GL128N -> unknown\n");
204 info->flash_id = FLASH_UNKNOWN;
206 DEBUGF("Chip: S29GL128N\n");
207 info->flash_id += FLASH_S29GL128N;
208 info->sector_count = 128;
209 info->size = 0x02000000;
213 info->flash_id = FLASH_UNKNOWN;
219 info->flash_id = FLASH_UNKNOWN;
220 return (0); /* => no or unknown flash */
223 /* set up sector start address table */
224 for (i = 0; i < info->sector_count; i++)
225 info->start[i] = base + (i * 0x00040000);
227 /* check for protected sectors */
228 for (i = 0; i < info->sector_count; i++) {
229 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
230 /* D0 = 1 if protected */
231 addr2 = (volatile CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[i]);
233 info->protect[i] = addr2[2] & 1;
236 /* issue bank reset to return to read mode */
237 addr2[0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00F000F0;
242 static int wait_for_DQ7_32(flash_info_t * info, int sect)
244 ulong start, now, last;
245 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr =
246 (CONFIG_SYS_FLASH_WORD_SIZE *) (info->start[sect]);
248 start = get_timer(0);
250 while ((addr[0] & (CONFIG_SYS_FLASH_WORD_SIZE) 0x00800080) !=
251 (CONFIG_SYS_FLASH_WORD_SIZE) 0x00800080) {
252 if ((now = get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
256 /* show that we're waiting */
257 if ((now - last) > 1000) { /* every second */
265 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
266 int flash_erase(flash_info_t * info, int s_first, int s_last)
268 if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320B) {
269 return flash_erase_16(info, s_first, s_last);
271 return flash_erase_32(info, s_first, s_last);
275 static int flash_erase_32(flash_info_t * info, int s_first, int s_last)
277 int flash_erase(flash_info_t * info, int s_first, int s_last)
280 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr = (CONFIG_SYS_FLASH_WORD_SIZE *) (info->start[0]);
281 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2;
282 int flag, prot, sect, l_sect;
284 if ((s_first < 0) || (s_first > s_last)) {
285 if (info->flash_id == FLASH_UNKNOWN)
286 printf("- missing\n");
288 printf("- no sectors to erase\n");
292 if (info->flash_id == FLASH_UNKNOWN) {
293 printf("Can't erase unknown flash type - aborted\n");
298 for (sect = s_first; sect <= s_last; ++sect) {
299 if (info->protect[sect])
304 printf("- Warning: %d protected sectors will not be erased!", prot);
310 /* Disable interrupts which might cause a timeout here */
311 flag = disable_interrupts();
313 /* Start erase on unprotected sectors */
314 for (sect = s_first; sect <= s_last; sect++) {
315 if (info->protect[sect] == 0) { /* not protected */
316 addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *) (info->start[sect]);
318 addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00AA00AA;
319 addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00550055;
320 addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00800080;
321 addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00AA00AA;
322 addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00550055;
323 addr2[0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00300030; /* sector erase */
327 * Wait for each sector to complete, it's more
328 * reliable. According to AMD Spec, you must
329 * issue all erase commands within a specified
330 * timeout. This has been seen to fail, especially
331 * if printf()s are included (for debug)!!
333 wait_for_DQ7_32(info, sect);
337 /* re-enable interrupts if necessary */
341 /* wait at least 80us - let's wait 1 ms */
344 /* reset to read mode */
345 addr = (CONFIG_SYS_FLASH_WORD_SIZE *) info->start[0];
346 addr[0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00F000F0; /* reset bank */
352 /*-----------------------------------------------------------------------
353 * Copy memory to flash, returns:
356 * 2 - Flash not erased
358 int write_buff(flash_info_t * info, uchar * src, ulong addr, ulong cnt)
363 wp = (addr & ~3); /* get lower word aligned address */
366 * handle unaligned start bytes
368 if ((l = addr - wp) != 0) {
370 for (i = 0, cp = wp; i < l; ++i, ++cp)
371 data = (data << 8) | (*(uchar *) cp);
373 for (; i < 4 && cnt > 0; ++i) {
374 data = (data << 8) | *src++;
379 for (; cnt == 0 && i < 4; ++i, ++cp)
380 data = (data << 8) | (*(uchar *) cp);
382 if ((rc = write_word(info, wp, data)) != 0)
389 * handle word aligned part
393 for (i = 0; i < 4; ++i)
394 data = (data << 8) | *src++;
396 if ((rc = write_word(info, wp, data)) != 0)
407 * handle unaligned tail bytes
410 for (i = 0, cp = wp; i < 4 && cnt > 0; ++i, ++cp) {
411 data = (data << 8) | *src++;
414 for (; i < 4; ++i, ++cp)
415 data = (data << 8) | (*(uchar *) cp);
417 return (write_word(info, wp, data));
420 /*-----------------------------------------------------------------------
421 * Copy memory to flash, returns:
424 * 2 - Flash not erased
426 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
427 static int write_word(flash_info_t * info, ulong dest, ulong data)
429 if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320B) {
430 return write_word_16(info, dest, data);
432 return write_word_32(info, dest, data);
436 static int write_word_32(flash_info_t * info, ulong dest, ulong data)
438 static int write_word(flash_info_t * info, ulong dest, ulong data)
441 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *) (info->start[0]);
442 volatile CONFIG_SYS_FLASH_WORD_SIZE *dest2 = (CONFIG_SYS_FLASH_WORD_SIZE *) dest;
443 ulong *datap = &data;
444 volatile CONFIG_SYS_FLASH_WORD_SIZE *data2 =
445 (volatile CONFIG_SYS_FLASH_WORD_SIZE *)datap;
449 /* Check if Flash is (sufficiently) erased */
450 if ((*((vu_long *)dest) & data) != data)
453 for (i = 0; i < 4 / sizeof(CONFIG_SYS_FLASH_WORD_SIZE); i++) {
454 /* Disable interrupts which might cause a timeout here */
455 flag = disable_interrupts();
457 addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00AA00AA;
458 addr2[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00550055;
459 addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x00A000A0;
463 /* re-enable interrupts if necessary */
467 /* data polling for D7 */
468 start = get_timer(0);
469 while ((dest2[i] & (CONFIG_SYS_FLASH_WORD_SIZE) 0x00800080) !=
470 (data2[i] & (CONFIG_SYS_FLASH_WORD_SIZE) 0x00800080)) {
472 if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT)
480 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
482 #undef CONFIG_SYS_FLASH_WORD_SIZE
483 #define CONFIG_SYS_FLASH_WORD_SIZE unsigned short
486 * The following code cannot be run from FLASH!
488 static ulong flash_get_size_16(vu_long * addr, flash_info_t * info)
491 CONFIG_SYS_FLASH_WORD_SIZE value;
492 ulong base = (ulong) addr;
493 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *) addr;
495 DEBUGF("get_size16: FLASH ADDR: %08x\n", (unsigned)addr);
497 /* issue bank reset to return to read mode */
498 addr2[0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0xF000F000;
500 /* Write auto select command: read Manufacturer ID */
501 addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0xAA00AA00;
502 addr2[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x55005500;
503 addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x90009000;
506 value = swap16(addr2[0]);
507 DEBUGF("FLASH MANUFACT: %x\n", value);
510 case (CONFIG_SYS_FLASH_WORD_SIZE) AMD_MANUFACT:
511 info->flash_id = FLASH_MAN_AMD;
513 case (CONFIG_SYS_FLASH_WORD_SIZE) FUJ_MANUFACT:
514 info->flash_id = FLASH_MAN_FUJ;
517 info->flash_id = FLASH_UNKNOWN;
518 info->sector_count = 0;
520 return (0); /* no or unknown flash */
523 value = swap16(addr2[1]); /* device ID */
524 DEBUGF("\nFLASH DEVICEID: %x\n", value);
527 case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV320B:
528 info->flash_id += FLASH_AM320B;
529 info->sector_count = 71;
530 info->size = 0x00400000;
532 case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV320T:
533 info->flash_id += FLASH_AM320T;
534 info->sector_count = 71;
535 info->size = 0x00400000;
538 info->flash_id = FLASH_UNKNOWN;
539 return (0); /* => no or unknown flash */
542 if (info->flash_id & FLASH_BTYPE) {
543 /* set sector offsets for bottom boot block type */
544 info->start[0] = base + 0x00000000;
545 info->start[1] = base + 0x00002000;
546 info->start[2] = base + 0x00004000;
547 info->start[3] = base + 0x00006000;
548 info->start[4] = base + 0x00008000;
549 info->start[5] = base + 0x0000a000;
550 info->start[6] = base + 0x0000c000;
551 info->start[7] = base + 0x0000e000;
553 for (i = 8; i < info->sector_count; i++)
554 info->start[i] = base + (i * 0x00010000) - 0x00070000;
556 /* set sector offsets for top boot block type */
557 i = info->sector_count - 1;
558 info->start[i--] = base + info->size - 0x00002000;
559 info->start[i--] = base + info->size - 0x00004000;
560 info->start[i--] = base + info->size - 0x00006000;
561 info->start[i--] = base + info->size - 0x00008000;
562 info->start[i--] = base + info->size - 0x0000a000;
563 info->start[i--] = base + info->size - 0x0000c000;
564 info->start[i--] = base + info->size - 0x0000e000;
567 info->start[i] = base + i * 0x00010000;
570 /* check for protected sectors */
571 for (i = 0; i < info->sector_count; i++) {
572 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
573 /* D0 = 1 if protected */
574 addr2 = (volatile CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[i]);
576 info->protect[i] = addr2[2] & 1;
579 /* issue bank reset to return to read mode */
580 addr2[0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0xF000F000;
585 static int wait_for_DQ7_16(flash_info_t * info, int sect)
587 ulong start, now, last;
588 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr =
589 (CONFIG_SYS_FLASH_WORD_SIZE *) (info->start[sect]);
591 start = get_timer(0);
593 while ((addr[0] & (CONFIG_SYS_FLASH_WORD_SIZE) 0x80008000) !=
594 (CONFIG_SYS_FLASH_WORD_SIZE) 0x80008000) {
595 if ((now = get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
599 /* show that we're waiting */
600 if ((now - last) > 1000) { /* every second */
608 static int flash_erase_16(flash_info_t * info, int s_first, int s_last)
610 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr = (CONFIG_SYS_FLASH_WORD_SIZE *) (info->start[0]);
611 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2;
612 int flag, prot, sect, l_sect;
614 if ((s_first < 0) || (s_first > s_last)) {
615 if (info->flash_id == FLASH_UNKNOWN)
616 printf("- missing\n");
618 printf("- no sectors to erase\n");
622 if (info->flash_id == FLASH_UNKNOWN) {
623 printf("Can't erase unknown flash type - aborted\n");
628 for (sect = s_first; sect <= s_last; ++sect) {
629 if (info->protect[sect])
634 printf("- Warning: %d protected sectors will not be erased!", prot);
640 /* Disable interrupts which might cause a timeout here */
641 flag = disable_interrupts();
643 /* Start erase on unprotected sectors */
644 for (sect = s_first; sect <= s_last; sect++) {
645 if (info->protect[sect] == 0) { /* not protected */
646 addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *) (info->start[sect]);
648 addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0xAA00AA00;
649 addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x55005500;
650 addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x80008000;
651 addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0xAA00AA00;
652 addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x55005500;
653 addr2[0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x30003000; /* sector erase */
657 * Wait for each sector to complete, it's more
658 * reliable. According to AMD Spec, you must
659 * issue all erase commands within a specified
660 * timeout. This has been seen to fail, especially
661 * if printf()s are included (for debug)!!
663 wait_for_DQ7_16(info, sect);
667 /* re-enable interrupts if necessary */
671 /* wait at least 80us - let's wait 1 ms */
674 /* reset to read mode */
675 addr = (CONFIG_SYS_FLASH_WORD_SIZE *) info->start[0];
676 addr[0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0xF000F000; /* reset bank */
682 static int write_word_16(flash_info_t * info, ulong dest, ulong data)
684 volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *) (info->start[0]);
685 volatile CONFIG_SYS_FLASH_WORD_SIZE *dest2 = (CONFIG_SYS_FLASH_WORD_SIZE *) dest;
686 ulong *datap = &data;
687 volatile CONFIG_SYS_FLASH_WORD_SIZE *data2 =
688 (volatile CONFIG_SYS_FLASH_WORD_SIZE *)datap;
692 /* Check if Flash is (sufficiently) erased */
693 for (i = 0; i < 4 / sizeof(CONFIG_SYS_FLASH_WORD_SIZE); i++) {
694 if ((dest2[i] & swap16(data2[i])) != swap16(data2[i]))
698 for (i = 0; i < 4 / sizeof(CONFIG_SYS_FLASH_WORD_SIZE); i++) {
701 /* Disable interrupts which might cause a timeout here */
702 flag = disable_interrupts();
704 addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0xAA00AA00;
705 addr2[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE) 0x55005500;
706 addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE) 0xA000A000;
708 dest2[i] = swap16(data2[i]);
710 /* re-enable interrupts if necessary */
714 /* data polling for D7 */
715 start = get_timer(0);
716 while ((dest2[i] & (CONFIG_SYS_FLASH_WORD_SIZE) 0x80008000) !=
717 (swap16(data2[i]) & (CONFIG_SYS_FLASH_WORD_SIZE) 0x80008000)) {
719 if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
727 #endif /* CONFIG_SYS_FLASH_2ND_16BIT_DEV */
729 /*-----------------------------------------------------------------------
732 static ulong flash_get_size(vu_long * addr, flash_info_t * info);
733 static int write_word(flash_info_t * info, ulong dest, ulong data);
735 /*-----------------------------------------------------------------------
738 unsigned long flash_init(void)
740 unsigned long total_b = 0;
741 unsigned long size_b[CONFIG_SYS_MAX_FLASH_BANKS];
742 unsigned short index = 0;
746 DEBUGF("FLASH: Index: %d\n", index);
748 /* Init: no FLASHes known */
749 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
750 flash_info[i].flash_id = FLASH_UNKNOWN;
751 flash_info[i].sector_count = -1;
752 flash_info[i].size = 0;
754 /* check whether the address is 0 */
755 if (flash_addr_table[index][i] == 0)
758 /* call flash_get_size() to initialize sector address */
759 size_b[i] = flash_get_size((vu_long *) flash_addr_table[index][i],
762 flash_info[i].size = size_b[i];
764 if (flash_info[i].flash_id == FLASH_UNKNOWN) {
765 printf("## Unknown FLASH on Bank %d - Size = 0x%08lx = %ld MB\n",
766 i+1, size_b[i], size_b[i] << 20);
767 flash_info[i].sector_count = -1;
768 flash_info[i].size = 0;
771 /* Monitor protection ON by default */
772 (void)flash_protect(FLAG_PROTECT_SET, CONFIG_SYS_MONITOR_BASE,
773 CONFIG_SYS_MONITOR_BASE + CONFIG_SYS_MONITOR_LEN - 1,
775 #if defined(CONFIG_ENV_IS_IN_FLASH)
776 (void)flash_protect(FLAG_PROTECT_SET, CONFIG_ENV_ADDR,
777 CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1,
779 #if defined(CONFIG_ENV_ADDR_REDUND)
780 (void)flash_protect(FLAG_PROTECT_SET, CONFIG_ENV_ADDR_REDUND,
781 CONFIG_ENV_ADDR_REDUND + CONFIG_ENV_SECT_SIZE - 1,
785 total_b += flash_info[i].size;
790 #endif /* if defined(CONFIG_CAM5200) && defined(CONFIG_CAM5200_NIOSFLASH) */