2 * (C) Copyright 2000-2004
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * SPDX-License-Identifier: GPL-2.0+
10 * Wait for completion of each sector erase command issued
12 * Chris Hallinan - DS4.COM, Inc. - clh@net1plus.com
16 #include <asm/ppc4xx.h>
17 #include <asm/processor.h>
19 #if CONFIG_SYS_MAX_FLASH_BANKS != 1
20 #error "CONFIG_SYS_MAX_FLASH_BANKS must be 1"
22 flash_info_t flash_info
[CONFIG_SYS_MAX_FLASH_BANKS
]; /* info for FLASH chips */
24 /*-----------------------------------------------------------------------
27 static ulong
flash_get_size (vu_long
* addr
, flash_info_t
* info
);
28 static int write_word (flash_info_t
* info
, ulong dest
, ulong data
);
29 static void flash_get_offsets (ulong base
, flash_info_t
* info
);
33 #define FLASH_WORD_SIZE unsigned char
35 /*-----------------------------------------------------------------------
38 unsigned long flash_init (void)
40 unsigned long size_b0
;
42 /* Init: no FLASHes known */
43 flash_info
[0].flash_id
= FLASH_UNKNOWN
;
45 /* Static FLASH Bank configuration here - FIXME XXX */
47 size_b0
= flash_get_size ((vu_long
*) FLASH_BASE0_PRELIM
, &flash_info
[0]);
49 if (flash_info
[0].flash_id
== FLASH_UNKNOWN
) {
50 printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
51 size_b0
, size_b0
<< 20);
56 flash_get_offsets (FLASH_BASE0_PRELIM
, &flash_info
[0]);
58 /* Monitor protection ON by default */
59 (void) flash_protect (FLAG_PROTECT_SET
,
61 FLASH_BASE0_PRELIM
+ monitor_flash_len
- 1,
63 flash_info
[0].size
= size_b0
;
69 /*-----------------------------------------------------------------------
72 * This implementation assumes that the flash chips are uniform sector
73 * devices. This is true for all likely JSE devices.
75 static void flash_get_offsets (ulong base
, flash_info_t
* info
)
78 unsigned long sector_size
= info
->size
/ info
->sector_count
;
80 for (idx
= 0; idx
< info
->sector_count
; idx
+= 1) {
81 info
->start
[idx
] = base
+ (idx
* sector_size
);
85 /*-----------------------------------------------------------------------
87 void flash_print_info (flash_info_t
* info
)
93 volatile unsigned long *flash
;
95 if (info
->flash_id
== FLASH_UNKNOWN
) {
96 printf ("missing or unknown FLASH type\n");
100 switch (info
->flash_id
& FLASH_VENDMASK
) {
111 printf ("ST Micro ");
114 printf ("Unknown Vendor ");
118 /* (Reduced table of only parts expected in JSE boards.) */
119 switch (info
->flash_id
) {
120 case FLASH_MAN_AMD
| FLASH_AM040
:
121 printf ("AM29F040 (512 Kbit, uniform sector size)\n");
123 case FLASH_MAN_STM
| FLASH_AM040
:
124 printf ("MM29W040W (512 Kbit, uniform sector size)\n");
127 printf ("Unknown Chip Type\n");
131 printf (" Size: %ld KB in %d Sectors\n",
132 info
->size
>> 10, info
->sector_count
);
134 printf (" Sector Start Addresses:");
135 for (i
= 0; i
< info
->sector_count
; ++i
) {
137 * Check if whole sector is erased
139 if (i
!= (info
->sector_count
- 1))
140 size
= info
->start
[i
+ 1] - info
->start
[i
];
142 size
= info
->start
[0] + info
->size
- info
->start
[i
];
144 flash
= (volatile unsigned long *) info
->start
[i
];
145 size
= size
>> 2; /* divide by 4 for longword access */
146 for (k
= 0; k
< size
; k
++) {
147 if (*flash
++ != 0xffffffff) {
155 printf (" %08lX%s%s",
157 erased
? " E" : " ", info
->protect
[i
] ? "RO " : " "
164 /*-----------------------------------------------------------------------
168 /*-----------------------------------------------------------------------
172 * The following code cannot be run from FLASH!
174 static ulong
flash_get_size (vu_long
* addr
, flash_info_t
* info
)
177 FLASH_WORD_SIZE value
;
178 ulong base
= (ulong
) addr
;
179 volatile FLASH_WORD_SIZE
*addr2
= (FLASH_WORD_SIZE
*) addr
;
181 /* Write auto select command: read Manufacturer ID */
182 addr2
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00AA00AA;
183 addr2
[ADDR1
] = (FLASH_WORD_SIZE
) 0x00550055;
184 addr2
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00900090;
189 case (FLASH_WORD_SIZE
) AMD_MANUFACT
:
190 info
->flash_id
= FLASH_MAN_AMD
;
192 case (FLASH_WORD_SIZE
) FUJ_MANUFACT
:
193 info
->flash_id
= FLASH_MAN_FUJ
;
195 case (FLASH_WORD_SIZE
) SST_MANUFACT
:
196 info
->flash_id
= FLASH_MAN_SST
;
198 case (FLASH_WORD_SIZE
)STM_MANUFACT
:
199 info
->flash_id
= FLASH_MAN_STM
;
202 info
->flash_id
= FLASH_UNKNOWN
;
203 info
->sector_count
= 0;
205 printf("Unknown flash manufacturer code: 0x%x\n", value
);
206 return (0); /* no or unknown flash */
209 value
= addr2
[1]; /* device ID */
212 case (FLASH_WORD_SIZE
) AMD_ID_F040B
:
213 info
->flash_id
+= FLASH_AM040
;
214 info
->sector_count
= 8;
215 info
->size
= 0x0080000; /* => 512 ko */
217 case (FLASH_WORD_SIZE
) AMD_ID_LV040B
:
218 info
->flash_id
+= FLASH_AM040
;
219 info
->sector_count
= 8;
220 info
->size
= 0x0080000; /* => 512 ko */
222 case (FLASH_WORD_SIZE
)STM_ID_M29W040B
: /* most likele JSE chip */
223 info
->flash_id
+= FLASH_AM040
;
224 info
->sector_count
= 8;
225 info
->size
= 0x0080000; /* => 512 ko */
228 info
->flash_id
= FLASH_UNKNOWN
;
229 return (0); /* => no or unknown flash */
233 /* Calculate the sector offsets (Use JSE Optimized code). */
234 flash_get_offsets(base
, info
);
236 /* check for protected sectors */
237 for (i
= 0; i
< info
->sector_count
; i
++) {
238 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
239 /* D0 = 1 if protected */
240 addr2
= (volatile FLASH_WORD_SIZE
*) (info
->start
[i
]);
241 if ((info
->flash_id
& FLASH_VENDMASK
) == FLASH_MAN_SST
)
242 info
->protect
[i
] = 0;
244 info
->protect
[i
] = addr2
[2] & 1;
248 * Prevent writes to uninitialized FLASH.
250 if (info
->flash_id
!= FLASH_UNKNOWN
) {
251 addr2
= (FLASH_WORD_SIZE
*) info
->start
[0];
252 *addr2
= (FLASH_WORD_SIZE
) 0x00F000F0; /* reset bank */
258 int wait_for_DQ7 (flash_info_t
* info
, int sect
)
260 ulong start
, now
, last
;
261 volatile FLASH_WORD_SIZE
*addr
=
262 (FLASH_WORD_SIZE
*) (info
->start
[sect
]);
264 start
= get_timer (0);
266 while ((addr
[0] & (FLASH_WORD_SIZE
) 0x00800080) !=
267 (FLASH_WORD_SIZE
) 0x00800080) {
268 if ((now
= get_timer (start
)) > CONFIG_SYS_FLASH_ERASE_TOUT
) {
269 printf ("Timeout\n");
272 /* show that we're waiting */
273 if ((now
- last
) > 1000) { /* every second */
281 /*-----------------------------------------------------------------------
284 int flash_erase (flash_info_t
* info
, int s_first
, int s_last
)
286 volatile FLASH_WORD_SIZE
*addr
= (FLASH_WORD_SIZE
*) (info
->start
[0]);
287 volatile FLASH_WORD_SIZE
*addr2
;
288 int flag
, prot
, sect
;
291 if ((s_first
< 0) || (s_first
> s_last
)) {
292 if (info
->flash_id
== FLASH_UNKNOWN
) {
293 printf ("- missing\n");
295 printf ("- no sectors to erase\n");
300 if (info
->flash_id
== FLASH_UNKNOWN
) {
301 printf ("Can't erase unknown flash type - aborted\n");
306 for (sect
= s_first
; sect
<= s_last
; ++sect
) {
307 if (info
->protect
[sect
]) {
313 printf ("- Warning: %d protected sectors will not be erased!\n", prot
);
318 /* Disable interrupts which might cause a timeout here */
319 flag
= disable_interrupts ();
321 /* Start erase on unprotected sectors */
322 for (sect
= s_first
; sect
<= s_last
; sect
++) {
323 if (info
->protect
[sect
] == 0) { /* not protected */
324 addr2
= (FLASH_WORD_SIZE
*) (info
->start
[sect
]);
325 printf ("Erasing sector %p\n", addr2
); /* CLH */
327 if ((info
->flash_id
& FLASH_VENDMASK
) ==
329 addr
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00AA00AA;
330 addr
[ADDR1
] = (FLASH_WORD_SIZE
) 0x00550055;
331 addr
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00800080;
332 addr
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00AA00AA;
333 addr
[ADDR1
] = (FLASH_WORD_SIZE
) 0x00550055;
334 addr2
[0] = (FLASH_WORD_SIZE
) 0x00500050; /* block erase */
335 for (i
= 0; i
< 50; i
++)
336 udelay (1000); /* wait 1 ms */
338 addr
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00AA00AA;
339 addr
[ADDR1
] = (FLASH_WORD_SIZE
) 0x00550055;
340 addr
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00800080;
341 addr
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00AA00AA;
342 addr
[ADDR1
] = (FLASH_WORD_SIZE
) 0x00550055;
343 addr2
[0] = (FLASH_WORD_SIZE
) 0x00300030; /* sector erase */
346 * Wait for each sector to complete, it's more
347 * reliable. According to AMD Spec, you must
348 * issue all erase commands within a specified
349 * timeout. This has been seen to fail, especially
350 * if printf()s are included (for debug)!!
352 wait_for_DQ7 (info
, sect
);
356 /* re-enable interrupts if necessary */
358 enable_interrupts ();
360 /* wait at least 80us - let's wait 1 ms */
363 /* reset to read mode */
364 addr
= (FLASH_WORD_SIZE
*) info
->start
[0];
365 addr
[0] = (FLASH_WORD_SIZE
) 0x00F000F0; /* reset bank */
371 /*-----------------------------------------------------------------------
372 * Copy memory to flash, returns:
375 * 2 - Flash not erased
378 int write_buff (flash_info_t
* info
, uchar
* src
, ulong addr
, ulong cnt
)
383 wp
= (addr
& ~3); /* get lower word aligned address */
386 * handle unaligned start bytes
388 if ((l
= addr
- wp
) != 0) {
390 for (i
= 0, cp
= wp
; i
< l
; ++i
, ++cp
) {
391 data
= (data
<< 8) | (*(uchar
*) cp
);
393 for (; i
< 4 && cnt
> 0; ++i
) {
394 data
= (data
<< 8) | *src
++;
398 for (; cnt
== 0 && i
< 4; ++i
, ++cp
) {
399 data
= (data
<< 8) | (*(uchar
*) cp
);
402 if ((rc
= write_word (info
, wp
, data
)) != 0) {
409 * handle word aligned part
413 for (i
= 0; i
< 4; ++i
) {
414 data
= (data
<< 8) | *src
++;
416 if ((rc
= write_word (info
, wp
, data
)) != 0) {
428 * handle unaligned tail bytes
431 for (i
= 0, cp
= wp
; i
< 4 && cnt
> 0; ++i
, ++cp
) {
432 data
= (data
<< 8) | *src
++;
435 for (; i
< 4; ++i
, ++cp
) {
436 data
= (data
<< 8) | (*(uchar
*) cp
);
439 return (write_word (info
, wp
, data
));
442 /*-----------------------------------------------------------------------
443 * Write a word to Flash, returns:
446 * 2 - Flash not erased
448 static int write_word (flash_info_t
* info
, ulong dest
, ulong data
)
450 volatile FLASH_WORD_SIZE
*addr2
=
451 (FLASH_WORD_SIZE
*) (info
->start
[0]);
452 volatile FLASH_WORD_SIZE
*dest2
= (FLASH_WORD_SIZE
*) dest
;
453 volatile FLASH_WORD_SIZE
*data2
= (FLASH_WORD_SIZE
*) & data
;
457 /* Check if Flash is (sufficiently) erased */
458 if ((*((volatile FLASH_WORD_SIZE
*) dest
) &
459 (FLASH_WORD_SIZE
) data
) != (FLASH_WORD_SIZE
) data
) {
463 for (i
= 0; i
< 4 / sizeof (FLASH_WORD_SIZE
); i
++) {
466 /* Disable interrupts which might cause a timeout here */
467 flag
= disable_interrupts ();
469 addr2
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00AA00AA;
470 addr2
[ADDR1
] = (FLASH_WORD_SIZE
) 0x00550055;
471 addr2
[ADDR0
] = (FLASH_WORD_SIZE
) 0x00A000A0;
475 /* re-enable interrupts if necessary */
477 enable_interrupts ();
479 /* data polling for D7 */
480 start
= get_timer (0);
481 while ((dest2
[i
] & (FLASH_WORD_SIZE
) 0x00800080) !=
482 (data2
[i
] & (FLASH_WORD_SIZE
) 0x00800080)) {
484 if (get_timer (start
) > CONFIG_SYS_FLASH_WRITE_TOUT
) {