2 * (C) Copyright 2004-2005
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * (C) Copyright 2002 Jun Gu <jung@artesyncp.com>
6 * Add support for Am29F016D and dynamic switch setting.
8 * See file CREDITS for list of people who contributed to this
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 of
14 * the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
29 * Wait for completion of each sector erase command issued
31 * Chris Hallinan - DS4.COM, Inc. - clh@net1plus.com
35 #include <asm/ppc4xx.h>
36 #include <asm/processor.h>
38 flash_info_t flash_info
[CONFIG_SYS_MAX_FLASH_BANKS
]; /* info for FLASH chips */
40 /*-----------------------------------------------------------------------
43 static int write_word(flash_info_t
* info
, ulong dest
, ulong data
);
44 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
45 static int write_word_1(flash_info_t
* info
, ulong dest
, ulong data
);
46 static int write_word_2(flash_info_t
* info
, ulong dest
, ulong data
);
47 static int flash_erase_1(flash_info_t
* info
, int s_first
, int s_last
);
48 static int flash_erase_2(flash_info_t
* info
, int s_first
, int s_last
);
49 static ulong
flash_get_size_1(vu_long
* addr
, flash_info_t
* info
);
50 static ulong
flash_get_size_2(vu_long
* addr
, flash_info_t
* info
);
53 void flash_print_info(flash_info_t
* info
)
59 volatile unsigned long *flash
;
61 if (info
->flash_id
== FLASH_UNKNOWN
) {
62 printf("missing or unknown FLASH type\n");
66 switch (info
->flash_id
& FLASH_VENDMASK
) {
83 printf("Unknown Vendor ");
87 switch (info
->flash_id
& FLASH_TYPEMASK
) {
89 printf("AM29F040 (512 Kbit, uniform sector size)\n");
92 printf("AM29LV400B (4 Mbit, bottom boot sect)\n");
95 printf("AM29LV400T (4 Mbit, top boot sector)\n");
98 printf("AM29LV800B (8 Mbit, bottom boot sect)\n");
101 printf("AM29LV800T (8 Mbit, top boot sector)\n");
104 printf("AM29F016D (16 Mbit, uniform sector size)\n");
107 printf("AM29LV160B (16 Mbit, bottom boot sect)\n");
110 printf("AM29LV160T (16 Mbit, top boot sector)\n");
113 printf("AM29LV320B (32 Mbit, bottom boot sect)\n");
116 printf("AM29LV320T (32 Mbit, top boot sector)\n");
119 printf("AM29LV033C (32 Mbit, top boot sector)\n");
122 printf("SST39LF/VF800 (8 Mbit, uniform sector size)\n");
125 printf("SST39LF/VF160 (16 Mbit, uniform sector size)\n");
127 case FLASH_STMW320DT
:
128 printf ("M29W320DT (32 M, top sector)\n");
131 printf ("MXLV320T (32 Mbit, top sector)\n");
134 printf("Unknown Chip Type\n");
138 printf(" Size: %ld KB in %d Sectors\n",
139 info
->size
>> 10, info
->sector_count
);
141 printf(" Sector Start Addresses:");
142 for (i
= 0; i
< info
->sector_count
; ++i
) {
144 * Check if whole sector is erased
146 if (i
!= (info
->sector_count
- 1))
147 size
= info
->start
[i
+ 1] - info
->start
[i
];
149 size
= info
->start
[0] + info
->size
- info
->start
[i
];
151 flash
= (volatile unsigned long *)info
->start
[i
];
152 size
= size
>> 2; /* divide by 4 for longword access */
153 for (k
= 0; k
< size
; k
++) {
154 if (*flash
++ != 0xffffffff) {
164 erased
? " E" : " ", info
->protect
[i
] ? "RO " : " ");
172 * The following code cannot be run from FLASH!
174 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
175 static ulong
flash_get_size(vu_long
* addr
, flash_info_t
* info
)
177 /* bit 0 used for big flash marking */
178 if ((ulong
)addr
& 0x1) {
179 return flash_get_size_2((vu_long
*)((ulong
)addr
& 0xfffffffe), info
);
181 return flash_get_size_1(addr
, info
);
185 static ulong
flash_get_size_1(vu_long
* addr
, flash_info_t
* info
)
187 static ulong
flash_get_size(vu_long
* addr
, flash_info_t
* info
)
191 CONFIG_SYS_FLASH_WORD_SIZE value
;
192 ulong base
= (ulong
) addr
;
193 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr2
= (CONFIG_SYS_FLASH_WORD_SIZE
*) addr
;
195 DEBUGF("FLASH ADDR: %08x\n", (unsigned)addr
);
197 /* Write auto select command: read Manufacturer ID */
198 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
199 addr2
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
200 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00900090;
204 DEBUGF("FLASH MANUFACT: %x\n", value
);
207 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_MANUFACT
:
208 info
->flash_id
= FLASH_MAN_AMD
;
210 case (CONFIG_SYS_FLASH_WORD_SIZE
) FUJ_MANUFACT
:
211 info
->flash_id
= FLASH_MAN_FUJ
;
213 case (CONFIG_SYS_FLASH_WORD_SIZE
) SST_MANUFACT
:
214 info
->flash_id
= FLASH_MAN_SST
;
216 case (CONFIG_SYS_FLASH_WORD_SIZE
) STM_MANUFACT
:
217 info
->flash_id
= FLASH_MAN_STM
;
220 info
->flash_id
= FLASH_UNKNOWN
;
221 info
->sector_count
= 0;
223 return (0); /* no or unknown flash */
226 value
= addr2
[1]; /* device ID */
227 DEBUGF("\nFLASH DEVICEID: %x\n", value
);
230 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_LV040B
:
231 info
->flash_id
+= FLASH_AM040
;
232 info
->sector_count
= 8;
233 info
->size
= 0x0080000; /* => 512 KiB */
236 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_F040B
:
237 info
->flash_id
+= FLASH_AM040
;
238 info
->sector_count
= 8;
239 info
->size
= 0x0080000; /* => 512 KiB */
242 case (CONFIG_SYS_FLASH_WORD_SIZE
) STM_ID_M29W040B
:
243 info
->flash_id
+= FLASH_AM040
;
244 info
->sector_count
= 8;
245 info
->size
= 0x0080000; /* => 512 KiB */
248 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_F016D
:
249 info
->flash_id
+= FLASH_AMD016
;
250 info
->sector_count
= 32;
251 info
->size
= 0x00200000; /* => 2 MiB */
254 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_LV033C
:
255 info
->flash_id
+= FLASH_AMDLV033C
;
256 info
->sector_count
= 64;
257 info
->size
= 0x00400000; /* => 4 MiB */
260 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_LV400T
:
261 info
->flash_id
+= FLASH_AM400T
;
262 info
->sector_count
= 11;
263 info
->size
= 0x00080000; /* => 512 KiB */
266 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_LV400B
:
267 info
->flash_id
+= FLASH_AM400B
;
268 info
->sector_count
= 11;
269 info
->size
= 0x00080000; /* => 512 KiB */
272 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_LV800T
:
273 info
->flash_id
+= FLASH_AM800T
;
274 info
->sector_count
= 19;
275 info
->size
= 0x00100000; /* => 1 MiB */
278 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_LV800B
:
279 info
->flash_id
+= FLASH_AM800B
;
280 info
->sector_count
= 19;
281 info
->size
= 0x00100000; /* => 1 MiB */
284 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_LV160T
:
285 info
->flash_id
+= FLASH_AM160T
;
286 info
->sector_count
= 35;
287 info
->size
= 0x00200000; /* => 2 MiB */
290 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_ID_LV160B
:
291 info
->flash_id
+= FLASH_AM160B
;
292 info
->sector_count
= 35;
293 info
->size
= 0x00200000; /* => 2 MiB */
297 info
->flash_id
= FLASH_UNKNOWN
;
298 return (0); /* => no or unknown flash */
301 /* set up sector start address table */
302 if (((info
->flash_id
& FLASH_VENDMASK
) == FLASH_MAN_SST
) ||
303 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_AM040
) ||
304 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_AMD016
)) {
305 for (i
= 0; i
< info
->sector_count
; i
++)
306 info
->start
[i
] = base
+ (i
* 0x00010000);
308 if (info
->flash_id
& FLASH_BTYPE
) {
309 /* set sector offsets for bottom boot block type */
310 info
->start
[0] = base
+ 0x00000000;
311 info
->start
[1] = base
+ 0x00004000;
312 info
->start
[2] = base
+ 0x00006000;
313 info
->start
[3] = base
+ 0x00008000;
314 for (i
= 4; i
< info
->sector_count
; i
++) {
316 base
+ (i
* 0x00010000) - 0x00030000;
319 /* set sector offsets for top boot block type */
320 i
= info
->sector_count
- 1;
321 info
->start
[i
--] = base
+ info
->size
- 0x00004000;
322 info
->start
[i
--] = base
+ info
->size
- 0x00006000;
323 info
->start
[i
--] = base
+ info
->size
- 0x00008000;
324 for (; i
>= 0; i
--) {
325 info
->start
[i
] = base
+ i
* 0x00010000;
330 /* check for protected sectors */
331 for (i
= 0; i
< info
->sector_count
; i
++) {
332 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
333 /* D0 = 1 if protected */
334 addr2
= (volatile CONFIG_SYS_FLASH_WORD_SIZE
*)(info
->start
[i
]);
336 /* For AMD29033C flash we need to resend the command of *
337 * reading flash protection for upper 8 Mb of flash */
339 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0xAAAAAAAA;
340 addr2
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x55555555;
341 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x90909090;
344 if ((info
->flash_id
& FLASH_VENDMASK
) == FLASH_MAN_SST
)
345 info
->protect
[i
] = 0;
347 info
->protect
[i
] = addr2
[2] & 1;
350 /* issue bank reset to return to read mode */
351 addr2
[0] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00F000F0;
356 static int wait_for_DQ7_1(flash_info_t
* info
, int sect
)
358 ulong start
, now
, last
;
359 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr
=
360 (CONFIG_SYS_FLASH_WORD_SIZE
*) (info
->start
[sect
]);
362 start
= get_timer(0);
364 while ((addr
[0] & (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080) !=
365 (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080) {
366 if ((now
= get_timer(start
)) > CONFIG_SYS_FLASH_ERASE_TOUT
) {
370 /* show that we're waiting */
371 if ((now
- last
) > 1000) { /* every second */
379 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
380 int flash_erase(flash_info_t
* info
, int s_first
, int s_last
)
382 if (((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_AM320B
) ||
383 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_AM320T
) ||
384 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_MXLV320T
) ||
385 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_STMW320DT
)) {
386 return flash_erase_2(info
, s_first
, s_last
);
388 return flash_erase_1(info
, s_first
, s_last
);
392 static int flash_erase_1(flash_info_t
* info
, int s_first
, int s_last
)
394 int flash_erase(flash_info_t
* info
, int s_first
, int s_last
)
397 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr
= (CONFIG_SYS_FLASH_WORD_SIZE
*) (info
->start
[0]);
398 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr2
;
399 int flag
, prot
, sect
;
402 if ((s_first
< 0) || (s_first
> s_last
)) {
403 if (info
->flash_id
== FLASH_UNKNOWN
) {
404 printf("- missing\n");
406 printf("- no sectors to erase\n");
411 if (info
->flash_id
== FLASH_UNKNOWN
) {
412 printf("Can't erase unknown flash type - aborted\n");
417 for (sect
= s_first
; sect
<= s_last
; ++sect
) {
418 if (info
->protect
[sect
]) {
424 printf("- Warning: %d protected sectors will not be erased!\n",
430 /* Disable interrupts which might cause a timeout here */
431 flag
= disable_interrupts();
433 /* Start erase on unprotected sectors */
434 for (sect
= s_first
; sect
<= s_last
; sect
++) {
435 if (info
->protect
[sect
] == 0) { /* not protected */
436 addr2
= (CONFIG_SYS_FLASH_WORD_SIZE
*) (info
->start
[sect
]);
438 if ((info
->flash_id
& FLASH_VENDMASK
) == FLASH_MAN_SST
) {
439 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
440 addr
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
441 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080;
442 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
443 addr
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
444 addr2
[0] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00500050; /* block erase */
445 for (i
= 0; i
< 50; i
++)
446 udelay(1000); /* wait 1 ms */
448 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
449 addr
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
450 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080;
451 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
452 addr
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
453 addr2
[0] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00300030; /* sector erase */
456 * Wait for each sector to complete, it's more
457 * reliable. According to AMD Spec, you must
458 * issue all erase commands within a specified
459 * timeout. This has been seen to fail, especially
460 * if printf()s are included (for debug)!!
462 wait_for_DQ7_1(info
, sect
);
466 /* re-enable interrupts if necessary */
470 /* wait at least 80us - let's wait 1 ms */
473 /* reset to read mode */
474 addr
= (CONFIG_SYS_FLASH_WORD_SIZE
*) info
->start
[0];
475 addr
[0] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00F000F0; /* reset bank */
481 /*-----------------------------------------------------------------------
482 * Copy memory to flash, returns:
485 * 2 - Flash not erased
487 int write_buff(flash_info_t
* info
, uchar
* src
, ulong addr
, ulong cnt
)
492 wp
= (addr
& ~3); /* get lower word aligned address */
495 * handle unaligned start bytes
497 if ((l
= addr
- wp
) != 0) {
499 for (i
= 0, cp
= wp
; i
< l
; ++i
, ++cp
) {
500 data
= (data
<< 8) | (*(uchar
*) cp
);
502 for (; i
< 4 && cnt
> 0; ++i
) {
503 data
= (data
<< 8) | *src
++;
507 for (; cnt
== 0 && i
< 4; ++i
, ++cp
) {
508 data
= (data
<< 8) | (*(uchar
*) cp
);
511 if ((rc
= write_word(info
, wp
, data
)) != 0) {
518 * handle word aligned part
522 for (i
= 0; i
< 4; ++i
) {
523 data
= (data
<< 8) | *src
++;
525 if ((rc
= write_word(info
, wp
, data
)) != 0) {
537 * handle unaligned tail bytes
540 for (i
= 0, cp
= wp
; i
< 4 && cnt
> 0; ++i
, ++cp
) {
541 data
= (data
<< 8) | *src
++;
544 for (; i
< 4; ++i
, ++cp
) {
545 data
= (data
<< 8) | (*(uchar
*) cp
);
548 return (write_word(info
, wp
, data
));
551 /*-----------------------------------------------------------------------
552 * Copy memory to flash, returns:
555 * 2 - Flash not erased
557 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
558 static int write_word(flash_info_t
* info
, ulong dest
, ulong data
)
560 if (((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_AM320B
) ||
561 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_AM320T
) ||
562 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_MXLV320T
) ||
563 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_STMW320DT
)) {
564 return write_word_2(info
, dest
, data
);
566 return write_word_1(info
, dest
, data
);
570 static int write_word_1(flash_info_t
* info
, ulong dest
, ulong data
)
572 static int write_word(flash_info_t
* info
, ulong dest
, ulong data
)
575 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr2
= (CONFIG_SYS_FLASH_WORD_SIZE
*) (info
->start
[0]);
576 volatile CONFIG_SYS_FLASH_WORD_SIZE
*dest2
= (CONFIG_SYS_FLASH_WORD_SIZE
*) dest
;
577 volatile CONFIG_SYS_FLASH_WORD_SIZE
*data2
= (CONFIG_SYS_FLASH_WORD_SIZE
*) & data
;
581 /* Check if Flash is (sufficiently) erased */
582 if ((*((vu_long
*)dest
) & data
) != data
) {
586 for (i
= 0; i
< 4 / sizeof(CONFIG_SYS_FLASH_WORD_SIZE
); i
++) {
589 /* Disable interrupts which might cause a timeout here */
590 flag
= disable_interrupts();
592 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
593 addr2
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
594 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00A000A0;
598 /* re-enable interrupts if necessary */
602 /* data polling for D7 */
603 start
= get_timer(0);
604 while ((dest2
[i
] & (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080) !=
605 (data2
[i
] & (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080)) {
607 if (get_timer(start
) > CONFIG_SYS_FLASH_WRITE_TOUT
) {
616 #ifdef CONFIG_SYS_FLASH_2ND_16BIT_DEV
618 #undef CONFIG_SYS_FLASH_WORD_SIZE
619 #define CONFIG_SYS_FLASH_WORD_SIZE unsigned short
622 * The following code cannot be run from FLASH!
624 static ulong
flash_get_size_2(vu_long
* addr
, flash_info_t
* info
)
628 CONFIG_SYS_FLASH_WORD_SIZE value
;
629 ulong base
= (ulong
) addr
;
630 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr2
= (CONFIG_SYS_FLASH_WORD_SIZE
*) addr
;
632 DEBUGF("FLASH ADDR: %08x\n", (unsigned)addr
);
634 /* Write auto select command: read Manufacturer ID */
635 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
636 addr2
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
637 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00900090;
641 DEBUGF("FLASH MANUFACT: %x\n", value
);
644 case (CONFIG_SYS_FLASH_WORD_SIZE
) AMD_MANUFACT
:
645 info
->flash_id
= FLASH_MAN_AMD
;
647 case (CONFIG_SYS_FLASH_WORD_SIZE
) FUJ_MANUFACT
:
648 info
->flash_id
= FLASH_MAN_FUJ
;
650 case (CONFIG_SYS_FLASH_WORD_SIZE
) SST_MANUFACT
:
651 info
->flash_id
= FLASH_MAN_SST
;
653 case (CONFIG_SYS_FLASH_WORD_SIZE
) STM_MANUFACT
:
654 info
->flash_id
= FLASH_MAN_STM
;
656 case (CONFIG_SYS_FLASH_WORD_SIZE
) MX_MANUFACT
:
657 info
->flash_id
= FLASH_MAN_MX
;
660 info
->flash_id
= FLASH_UNKNOWN
;
661 info
->sector_count
= 0;
663 return (0); /* no or unknown flash */
666 value
= addr2
[1]; /* device ID */
668 DEBUGF("\nFLASH DEVICEID: %x\n", value
);
672 case (CONFIG_SYS_FLASH_WORD_SIZE
)AMD_ID_LV320T
:
673 info
->flash_id
+= FLASH_AM320T
;
674 info
->sector_count
= 71;
675 info
->size
= 0x00400000; break; /* => 4 MiB */
677 case (CONFIG_SYS_FLASH_WORD_SIZE
)AMD_ID_LV320B
:
678 info
->flash_id
+= FLASH_AM320B
;
679 info
->sector_count
= 71;
680 info
->size
= 0x00400000; break; /* => 4 MiB */
682 case (CONFIG_SYS_FLASH_WORD_SIZE
)STM_ID_29W320DT
:
683 info
->flash_id
+= FLASH_STMW320DT
;
684 info
->sector_count
= 67;
685 info
->size
= 0x00400000; break; /* => 4 MiB */
687 case (CONFIG_SYS_FLASH_WORD_SIZE
)MX_ID_LV320T
:
688 info
->flash_id
+= FLASH_MXLV320T
;
689 info
->sector_count
= 71;
690 info
->size
= 0x00400000;
694 info
->flash_id
= FLASH_UNKNOWN
;
695 return (0); /* => no or unknown flash */
698 /* set up sector start address table */
699 if (((info
->flash_id
& FLASH_VENDMASK
) == FLASH_MAN_SST
) ||
700 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_AM040
) ||
701 ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_AMD016
)) {
702 for (i
= 0; i
< info
->sector_count
; i
++)
703 info
->start
[i
] = base
+ (i
* 0x00010000);
704 } else if ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_STMW320DT
) {
705 /* set sector offsets for top boot block type */
707 i
= info
->sector_count
;
708 /* 1 x 16k boot sector */
711 info
->start
[i
] = base
;
712 /* 2 x 8k boot sectors */
713 for (n
=0; n
<2; ++n
) {
716 info
->start
[i
] = base
;
718 /* 1 x 32k boot sector */
721 info
->start
[i
] = base
;
723 while (i
> 0) { /* 64k regular sectors */
726 info
->start
[i
] = base
;
728 } else if ((info
->flash_id
& FLASH_TYPEMASK
) == FLASH_MXLV320T
) {
729 i
= info
->sector_count
- 1;
730 info
->start
[i
--] = base
+ info
->size
- 0x00002000;
731 info
->start
[i
--] = base
+ info
->size
- 0x00004000;
732 info
->start
[i
--] = base
+ info
->size
- 0x00006000;
733 info
->start
[i
--] = base
+ info
->size
- 0x00008000;
734 info
->start
[i
--] = base
+ info
->size
- 0x0000a000;
735 info
->start
[i
--] = base
+ info
->size
- 0x0000c000;
736 info
->start
[i
--] = base
+ info
->size
- 0x0000e000;
737 info
->start
[i
--] = base
+ info
->size
- 0x00010000;
740 info
->start
[i
] = base
+ i
* 0x00010000;
742 if (info
->flash_id
& FLASH_BTYPE
) {
743 /* set sector offsets for bottom boot block type */
744 info
->start
[0] = base
+ 0x00000000;
745 info
->start
[1] = base
+ 0x00002000;
746 info
->start
[2] = base
+ 0x00004000;
747 info
->start
[3] = base
+ 0x00006000;
748 info
->start
[4] = base
+ 0x00008000;
749 info
->start
[5] = base
+ 0x0000a000;
750 info
->start
[6] = base
+ 0x0000c000;
751 info
->start
[7] = base
+ 0x0000e000;
752 for (i
= 8; i
< info
->sector_count
; i
++) {
754 base
+ ((i
-7) * 0x00010000);
757 /* set sector offsets for top boot block type */
758 i
= info
->sector_count
- 1;
759 info
->start
[i
--] = base
+ info
->size
- 0x00002000;
760 info
->start
[i
--] = base
+ info
->size
- 0x00004000;
761 info
->start
[i
--] = base
+ info
->size
- 0x00006000;
762 info
->start
[i
--] = base
+ info
->size
- 0x00008000;
763 info
->start
[i
--] = base
+ info
->size
- 0x0000a000;
764 info
->start
[i
--] = base
+ info
->size
- 0x0000c000;
765 info
->start
[i
--] = base
+ info
->size
- 0x0000e000;
766 for (; i
>= 0; i
--) {
767 info
->start
[i
] = base
+ i
* 0x00010000;
772 /* check for protected sectors */
773 for (i
= 0; i
< info
->sector_count
; i
++) {
774 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
775 /* D0 = 1 if protected */
776 addr2
= (volatile CONFIG_SYS_FLASH_WORD_SIZE
*)(info
->start
[i
]);
778 /* For AMD29033C flash we need to resend the command of *
779 * reading flash protection for upper 8 Mb of flash */
781 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0xAAAAAAAA;
782 addr2
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x55555555;
783 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x90909090;
786 if ((info
->flash_id
& FLASH_VENDMASK
) == FLASH_MAN_SST
)
787 info
->protect
[i
] = 0;
789 info
->protect
[i
] = addr2
[2] & 1;
792 /* issue bank reset to return to read mode */
793 addr2
[0] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00F000F0;
798 static int wait_for_DQ7_2(flash_info_t
* info
, int sect
)
800 ulong start
, now
, last
;
801 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr
=
802 (CONFIG_SYS_FLASH_WORD_SIZE
*) (info
->start
[sect
]);
804 start
= get_timer(0);
806 while ((addr
[0] & (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080) !=
807 (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080) {
808 if ((now
= get_timer(start
)) > CONFIG_SYS_FLASH_ERASE_TOUT
) {
812 /* show that we're waiting */
813 if ((now
- last
) > 1000) { /* every second */
821 static int flash_erase_2(flash_info_t
* info
, int s_first
, int s_last
)
823 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr
= (CONFIG_SYS_FLASH_WORD_SIZE
*) (info
->start
[0]);
824 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr2
;
825 int flag
, prot
, sect
;
828 if ((s_first
< 0) || (s_first
> s_last
)) {
829 if (info
->flash_id
== FLASH_UNKNOWN
) {
830 printf("- missing\n");
832 printf("- no sectors to erase\n");
837 if (info
->flash_id
== FLASH_UNKNOWN
) {
838 printf("Can't erase unknown flash type - aborted\n");
843 for (sect
= s_first
; sect
<= s_last
; ++sect
) {
844 if (info
->protect
[sect
]) {
850 printf("- Warning: %d protected sectors will not be erased!\n",
856 /* Disable interrupts which might cause a timeout here */
857 flag
= disable_interrupts();
859 /* Start erase on unprotected sectors */
860 for (sect
= s_first
; sect
<= s_last
; sect
++) {
861 if (info
->protect
[sect
] == 0) { /* not protected */
862 addr2
= (CONFIG_SYS_FLASH_WORD_SIZE
*) (info
->start
[sect
]);
864 if ((info
->flash_id
& FLASH_VENDMASK
) == FLASH_MAN_SST
) {
865 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
866 addr
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
867 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080;
868 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
869 addr
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
870 addr2
[0] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00500050; /* block erase */
871 for (i
= 0; i
< 50; i
++)
872 udelay(1000); /* wait 1 ms */
874 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
875 addr
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
876 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080;
877 addr
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
878 addr
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
879 addr2
[0] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00300030; /* sector erase */
882 * Wait for each sector to complete, it's more
883 * reliable. According to AMD Spec, you must
884 * issue all erase commands within a specified
885 * timeout. This has been seen to fail, especially
886 * if printf()s are included (for debug)!!
888 wait_for_DQ7_2(info
, sect
);
892 /* re-enable interrupts if necessary */
896 /* wait at least 80us - let's wait 1 ms */
899 /* reset to read mode */
900 addr
= (CONFIG_SYS_FLASH_WORD_SIZE
*) info
->start
[0];
901 addr
[0] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00F000F0; /* reset bank */
907 static int write_word_2(flash_info_t
* info
, ulong dest
, ulong data
)
909 ulong
*data_ptr
= &data
;
910 volatile CONFIG_SYS_FLASH_WORD_SIZE
*addr2
= (CONFIG_SYS_FLASH_WORD_SIZE
*)(info
->start
[0]);
911 volatile CONFIG_SYS_FLASH_WORD_SIZE
*dest2
= (CONFIG_SYS_FLASH_WORD_SIZE
*)dest
;
912 volatile CONFIG_SYS_FLASH_WORD_SIZE
*data2
= (CONFIG_SYS_FLASH_WORD_SIZE
*)data_ptr
;
916 /* Check if Flash is (sufficiently) erased */
917 if ((*((vu_long
*)dest
) & data
) != data
) {
921 for (i
= 0; i
< 4 / sizeof(CONFIG_SYS_FLASH_WORD_SIZE
); i
++) {
924 /* Disable interrupts which might cause a timeout here */
925 flag
= disable_interrupts();
927 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00AA00AA;
928 addr2
[CONFIG_SYS_FLASH_ADDR1
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00550055;
929 addr2
[CONFIG_SYS_FLASH_ADDR0
] = (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00A000A0;
933 /* re-enable interrupts if necessary */
937 /* data polling for D7 */
938 start
= get_timer(0);
939 while ((dest2
[i
] & (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080) !=
940 (data2
[i
] & (CONFIG_SYS_FLASH_WORD_SIZE
) 0x00800080)) {
942 if (get_timer(start
) > CONFIG_SYS_FLASH_WRITE_TOUT
) {
950 #endif /* CONFIG_SYS_FLASH_2ND_16BIT_DEV */