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) {