]> git.ipfire.org Git - people/ms/u-boot.git/blob - board/amcc/yucca/flash.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
rename CFG_ENV macros to CONFIG_ENV
[people/ms/u-boot.git] / board / amcc / yucca / flash.c
1 /*
2 * (C) Copyright 2006
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * (C) Copyright 2002 Jun Gu <jung@artesyncp.com>
6 * Add support for Am29F016D and dynamic switch setting.
7 *
8 * See file CREDITS for list of people who contributed to this
9 * project.
10 *
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.
15 *
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.
20 *
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,
24 * MA 02111-1307 USA
25 */
26
27 /*
28 * Modified 4/5/2001
29 * Wait for completion of each sector erase command issued
30 * 4/5/2001
31 * Chris Hallinan - DS4.COM, Inc. - clh@net1plus.com
32 */
33
34 #include <common.h>
35 #include <ppc4xx.h>
36 #include <asm/processor.h>
37 #include <ppc440.h>
38 #include "yucca.h"
39
40 #ifdef DEBUG
41 #define DEBUGF(x...) printf(x)
42 #else
43 #define DEBUGF(x...)
44 #endif /* DEBUG */
45
46 flash_info_t flash_info[CFG_MAX_FLASH_BANKS]; /* info for FLASH chips */
47
48 /*
49 * Mark big flash bank (16 bit instead of 8 bit access) in address with bit 0
50 */
51 static unsigned long flash_addr_table[][CFG_MAX_FLASH_BANKS] = {
52 {0xfff00000, 0xfff80000, 0xe7c00001}, /* 0:boot from small flash */
53 {0x00000000, 0x00000000, 0x00000000}, /* 1:boot from pci 66 */
54 {0x00000000, 0x00000000, 0x00000000}, /* 2:boot from nand flash */
55 {0xe7F00000, 0xe7F80000, 0xFFC00001}, /* 3:boot from big flash 33*/
56 {0xe7F00000, 0xe7F80000, 0xFFC00001}, /* 4:boot from big flash 66*/
57 {0x00000000, 0x00000000, 0x00000000}, /* 5:boot from */
58 {0x00000000, 0x00000000, 0x00000000}, /* 6:boot from pci 66 */
59 {0x00000000, 0x00000000, 0x00000000}, /* 7:boot from */
60 {0xfff00000, 0xfff80000, 0xe7c00001}, /* 8:boot from small flash */
61 };
62
63 /*
64 * include common flash code (for amcc boards)
65 */
66 /*-----------------------------------------------------------------------
67 * Functions
68 */
69 static int write_word(flash_info_t * info, ulong dest, ulong data);
70 #ifdef CFG_FLASH_2ND_16BIT_DEV
71 static int write_word_1(flash_info_t * info, ulong dest, ulong data);
72 static int write_word_2(flash_info_t * info, ulong dest, ulong data);
73 static int flash_erase_1(flash_info_t * info, int s_first, int s_last);
74 static int flash_erase_2(flash_info_t * info, int s_first, int s_last);
75 static ulong flash_get_size_1(vu_long * addr, flash_info_t * info);
76 static ulong flash_get_size_2(vu_long * addr, flash_info_t * info);
77 #endif
78
79 void flash_print_info(flash_info_t * info)
80 {
81 int i;
82 int k;
83 int size;
84 int erased;
85 volatile unsigned long *flash;
86
87 if (info->flash_id == FLASH_UNKNOWN) {
88 printf("missing or unknown FLASH type\n");
89 return;
90 }
91
92 switch (info->flash_id & FLASH_VENDMASK) {
93 case FLASH_MAN_AMD:
94 printf("AMD ");
95 break;
96 case FLASH_MAN_STM:
97 printf("STM ");
98 break;
99 case FLASH_MAN_FUJ:
100 printf("FUJITSU ");
101 break;
102 case FLASH_MAN_SST:
103 printf("SST ");
104 break;
105 case FLASH_MAN_MX:
106 printf("MIXC ");
107 break;
108 default:
109 printf("Unknown Vendor ");
110 break;
111 }
112
113 switch (info->flash_id & FLASH_TYPEMASK) {
114 case FLASH_AM040:
115 printf("AM29F040 (512 Kbit, uniform sector size)\n");
116 break;
117 case FLASH_AM400B:
118 printf("AM29LV400B (4 Mbit, bottom boot sect)\n");
119 break;
120 case FLASH_AM400T:
121 printf("AM29LV400T (4 Mbit, top boot sector)\n");
122 break;
123 case FLASH_AM800B:
124 printf("AM29LV800B (8 Mbit, bottom boot sect)\n");
125 break;
126 case FLASH_AM800T:
127 printf("AM29LV800T (8 Mbit, top boot sector)\n");
128 break;
129 case FLASH_AMD016:
130 printf("AM29F016D (16 Mbit, uniform sector size)\n");
131 break;
132 case FLASH_AM160B:
133 printf("AM29LV160B (16 Mbit, bottom boot sect)\n");
134 break;
135 case FLASH_AM160T:
136 printf("AM29LV160T (16 Mbit, top boot sector)\n");
137 break;
138 case FLASH_AM320B:
139 printf("AM29LV320B (32 Mbit, bottom boot sect)\n");
140 break;
141 case FLASH_AM320T:
142 printf("AM29LV320T (32 Mbit, top boot sector)\n");
143 break;
144 case FLASH_AM033C:
145 printf("AM29LV033C (32 Mbit, top boot sector)\n");
146 break;
147 case FLASH_SST800A:
148 printf("SST39LF/VF800 (8 Mbit, uniform sector size)\n");
149 break;
150 case FLASH_SST160A:
151 printf("SST39LF/VF160 (16 Mbit, uniform sector size)\n");
152 break;
153 case FLASH_STMW320DT:
154 printf ("M29W320DT (32 M, top sector)\n");
155 break;
156 case FLASH_MXLV320T:
157 printf ("MXLV320T (32 Mbit, top sector)\n");
158 break;
159 default:
160 printf("Unknown Chip Type\n");
161 break;
162 }
163
164 printf(" Size: %ld KB in %d Sectors\n",
165 info->size >> 10, info->sector_count);
166
167 printf(" Sector Start Addresses:");
168 for (i = 0; i < info->sector_count; ++i) {
169 /*
170 * Check if whole sector is erased
171 */
172 if (i != (info->sector_count - 1))
173 size = info->start[i + 1] - info->start[i];
174 else
175 size = info->start[0] + info->size - info->start[i];
176 erased = 1;
177 flash = (volatile unsigned long *)info->start[i];
178 size = size >> 2; /* divide by 4 for longword access */
179 for (k = 0; k < size; k++) {
180 if (*flash++ != 0xffffffff) {
181 erased = 0;
182 break;
183 }
184 }
185
186 if ((i % 5) == 0)
187 printf("\n ");
188 printf(" %08lX%s%s",
189 info->start[i],
190 erased ? " E" : " ",
191 info->protect[i] ? "RO " : " ");
192 }
193 printf("\n");
194 return;
195 }
196
197
198 /*
199 * The following code cannot be run from FLASH!
200 */
201 #ifdef CFG_FLASH_2ND_16BIT_DEV
202 static ulong flash_get_size(vu_long * addr, flash_info_t * info)
203 {
204 /* bit 0 used for big flash marking */
205 if ((ulong)addr & 0x1)
206 return flash_get_size_2((vu_long *)((ulong)addr & 0xfffffffe), info);
207 else
208 return flash_get_size_1(addr, info);
209 }
210
211 static ulong flash_get_size_1(vu_long * addr, flash_info_t * info)
212 #else
213 static ulong flash_get_size(vu_long * addr, flash_info_t * info)
214 #endif
215 {
216 short i;
217 CFG_FLASH_WORD_SIZE value;
218 ulong base = (ulong) addr;
219 volatile CFG_FLASH_WORD_SIZE *addr2 = (CFG_FLASH_WORD_SIZE *) addr;
220
221 DEBUGF("FLASH ADDR: %08x\n", (unsigned)addr);
222
223 /* Write auto select command: read Manufacturer ID */
224 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
225 addr2[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
226 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00900090;
227 udelay(1000);
228
229 value = addr2[0];
230 DEBUGF("FLASH MANUFACT: %x\n", value);
231
232 switch (value) {
233 case (CFG_FLASH_WORD_SIZE) AMD_MANUFACT:
234 info->flash_id = FLASH_MAN_AMD;
235 break;
236 case (CFG_FLASH_WORD_SIZE) FUJ_MANUFACT:
237 info->flash_id = FLASH_MAN_FUJ;
238 break;
239 case (CFG_FLASH_WORD_SIZE) SST_MANUFACT:
240 info->flash_id = FLASH_MAN_SST;
241 break;
242 case (CFG_FLASH_WORD_SIZE) STM_MANUFACT:
243 info->flash_id = FLASH_MAN_STM;
244 break;
245 default:
246 info->flash_id = FLASH_UNKNOWN;
247 info->sector_count = 0;
248 info->size = 0;
249 return (0); /* no or unknown flash */
250 }
251
252 value = addr2[1]; /* device ID */
253 DEBUGF("\nFLASH DEVICEID: %x\n", value);
254
255 switch (value) {
256 case (CFG_FLASH_WORD_SIZE) AMD_ID_LV040B:
257 info->flash_id += FLASH_AM040;
258 info->sector_count = 8;
259 info->size = 0x0080000; /* => 512 ko */
260 break;
261
262 case (CFG_FLASH_WORD_SIZE) AMD_ID_F040B:
263 info->flash_id += FLASH_AM040;
264 info->sector_count = 8;
265 info->size = 0x0080000; /* => 512 ko */
266 break;
267
268 case (CFG_FLASH_WORD_SIZE) STM_ID_M29W040B:
269 info->flash_id += FLASH_AM040;
270 info->sector_count = 8;
271 info->size = 0x0080000; /* => 512 ko */
272 break;
273
274 case (CFG_FLASH_WORD_SIZE) AMD_ID_F016D:
275 info->flash_id += FLASH_AMD016;
276 info->sector_count = 32;
277 info->size = 0x00200000;
278 break; /* => 2 MB */
279
280 case (CFG_FLASH_WORD_SIZE) AMD_ID_LV033C:
281 info->flash_id += FLASH_AMDLV033C;
282 info->sector_count = 64;
283 info->size = 0x00400000;
284 break; /* => 4 MB */
285
286 case (CFG_FLASH_WORD_SIZE) AMD_ID_LV400T:
287 info->flash_id += FLASH_AM400T;
288 info->sector_count = 11;
289 info->size = 0x00080000;
290 break; /* => 0.5 MB */
291
292 case (CFG_FLASH_WORD_SIZE) AMD_ID_LV400B:
293 info->flash_id += FLASH_AM400B;
294 info->sector_count = 11;
295 info->size = 0x00080000;
296 break; /* => 0.5 MB */
297
298 case (CFG_FLASH_WORD_SIZE) AMD_ID_LV800T:
299 info->flash_id += FLASH_AM800T;
300 info->sector_count = 19;
301 info->size = 0x00100000;
302 break; /* => 1 MB */
303
304 case (CFG_FLASH_WORD_SIZE) AMD_ID_LV800B:
305 info->flash_id += FLASH_AM800B;
306 info->sector_count = 19;
307 info->size = 0x00100000;
308 break; /* => 1 MB */
309
310 case (CFG_FLASH_WORD_SIZE) AMD_ID_LV160T:
311 info->flash_id += FLASH_AM160T;
312 info->sector_count = 35;
313 info->size = 0x00200000;
314 break; /* => 2 MB */
315
316 case (CFG_FLASH_WORD_SIZE) AMD_ID_LV160B:
317 info->flash_id += FLASH_AM160B;
318 info->sector_count = 35;
319 info->size = 0x00200000;
320 break; /* => 2 MB */
321
322 default:
323 info->flash_id = FLASH_UNKNOWN;
324 return (0); /* => no or unknown flash */
325 }
326
327 /* set up sector start address table */
328 if (((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) ||
329 ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM040) ||
330 ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMD016)) {
331 for (i = 0; i < info->sector_count; i++)
332 info->start[i] = base + (i * 0x00010000);
333 } else {
334 if (info->flash_id & FLASH_BTYPE) {
335 /* set sector offsets for bottom boot block type */
336 info->start[0] = base + 0x00000000;
337 info->start[1] = base + 0x00004000;
338 info->start[2] = base + 0x00006000;
339 info->start[3] = base + 0x00008000;
340 for (i = 4; i < info->sector_count; i++) {
341 info->start[i] =
342 base + (i * 0x00010000) - 0x00030000;
343 }
344 } else {
345 /* set sector offsets for top boot block type */
346 i = info->sector_count - 1;
347 info->start[i--] = base + info->size - 0x00004000;
348 info->start[i--] = base + info->size - 0x00006000;
349 info->start[i--] = base + info->size - 0x00008000;
350 for (; i >= 0; i--) {
351 info->start[i] = base + i * 0x00010000;
352 }
353 }
354 }
355
356 /* check for protected sectors */
357 for (i = 0; i < info->sector_count; i++) {
358 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
359 /* D0 = 1 if protected */
360 addr2 = (volatile CFG_FLASH_WORD_SIZE *)(info->start[i]);
361
362 /* For AMD29033C flash we need to resend the command of *
363 * reading flash protection for upper 8 Mb of flash */
364 if (i == 32) {
365 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0xAAAAAAAA;
366 addr2[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x55555555;
367 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x90909090;
368 }
369
370 if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST)
371 info->protect[i] = 0;
372 else
373 info->protect[i] = addr2[2] & 1;
374 }
375
376 /* issue bank reset to return to read mode */
377 addr2[0] = (CFG_FLASH_WORD_SIZE) 0x00F000F0;
378
379 return (info->size);
380 }
381
382 static int wait_for_DQ7_1(flash_info_t * info, int sect)
383 {
384 ulong start, now, last;
385 volatile CFG_FLASH_WORD_SIZE *addr =
386 (CFG_FLASH_WORD_SIZE *) (info->start[sect]);
387
388 start = get_timer(0);
389 last = start;
390 while ((addr[0] & (CFG_FLASH_WORD_SIZE) 0x00800080) !=
391 (CFG_FLASH_WORD_SIZE) 0x00800080) {
392 if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
393 printf("Timeout\n");
394 return -1;
395 }
396 /* show that we're waiting */
397 if ((now - last) > 1000) { /* every second */
398 putc('.');
399 last = now;
400 }
401 }
402 return 0;
403 }
404
405 #ifdef CFG_FLASH_2ND_16BIT_DEV
406 int flash_erase(flash_info_t * info, int s_first, int s_last)
407 {
408 if (((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320B) ||
409 ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320T) ||
410 ((info->flash_id & FLASH_TYPEMASK) == FLASH_STMW320DT) ||
411 ((info->flash_id & FLASH_TYPEMASK) == FLASH_MXLV320T)) {
412 return flash_erase_2(info, s_first, s_last);
413 } else {
414 return flash_erase_1(info, s_first, s_last);
415 }
416 }
417
418 static int flash_erase_1(flash_info_t * info, int s_first, int s_last)
419 #else
420 int flash_erase(flash_info_t * info, int s_first, int s_last)
421 #endif
422 {
423 volatile CFG_FLASH_WORD_SIZE *addr = (CFG_FLASH_WORD_SIZE *) (info->start[0]);
424 volatile CFG_FLASH_WORD_SIZE *addr2;
425 int flag, prot, sect, l_sect;
426 int i;
427
428 if ((s_first < 0) || (s_first > s_last)) {
429 if (info->flash_id == FLASH_UNKNOWN)
430 printf("- missing\n");
431 else
432 printf("- no sectors to erase\n");
433 return 1;
434 }
435
436 if (info->flash_id == FLASH_UNKNOWN) {
437 printf("Can't erase unknown flash type - aborted\n");
438 return 1;
439 }
440
441 prot = 0;
442 for (sect = s_first; sect <= s_last; ++sect) {
443 if (info->protect[sect])
444 prot++;
445 }
446
447 if (prot)
448 printf("- Warning: %d protected sectors will not be erased!", prot);
449
450 printf("\n");
451
452 l_sect = -1;
453
454 /* Disable interrupts which might cause a timeout here */
455 flag = disable_interrupts();
456
457 /* Start erase on unprotected sectors */
458 for (sect = s_first; sect <= s_last; sect++) {
459 if (info->protect[sect] == 0) { /* not protected */
460 addr2 = (CFG_FLASH_WORD_SIZE *) (info->start[sect]);
461
462 if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) {
463 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
464 addr[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
465 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00800080;
466 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
467 addr[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
468 addr2[0] = (CFG_FLASH_WORD_SIZE) 0x00500050; /* block erase */
469 for (i = 0; i < 50; i++)
470 udelay(1000); /* wait 1 ms */
471 } else {
472 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
473 addr[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
474 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00800080;
475 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
476 addr[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
477 addr2[0] = (CFG_FLASH_WORD_SIZE) 0x00300030; /* sector erase */
478 }
479 l_sect = sect;
480 /*
481 * Wait for each sector to complete, it's more
482 * reliable. According to AMD Spec, you must
483 * issue all erase commands within a specified
484 * timeout. This has been seen to fail, especially
485 * if printf()s are included (for debug)!!
486 */
487 wait_for_DQ7_1(info, sect);
488 }
489 }
490
491 /* re-enable interrupts if necessary */
492 if (flag)
493 enable_interrupts();
494
495 /* wait at least 80us - let's wait 1 ms */
496 udelay(1000);
497
498 /* reset to read mode */
499 addr = (CFG_FLASH_WORD_SIZE *) info->start[0];
500 addr[0] = (CFG_FLASH_WORD_SIZE) 0x00F000F0; /* reset bank */
501
502 printf(" done\n");
503 return 0;
504 }
505
506 /*-----------------------------------------------------------------------
507 * Copy memory to flash, returns:
508 * 0 - OK
509 * 1 - write timeout
510 * 2 - Flash not erased
511 */
512 int write_buff(flash_info_t * info, uchar * src, ulong addr, ulong cnt)
513 {
514 ulong cp, wp, data;
515 int i, l, rc;
516
517 wp = (addr & ~3); /* get lower word aligned address */
518
519 /*
520 * handle unaligned start bytes
521 */
522 if ((l = addr - wp) != 0) {
523 data = 0;
524 for (i = 0, cp = wp; i < l; ++i, ++cp)
525 data = (data << 8) | (*(uchar *) cp);
526
527 for (; i < 4 && cnt > 0; ++i) {
528 data = (data << 8) | *src++;
529 --cnt;
530 ++cp;
531 }
532
533 for (; cnt == 0 && i < 4; ++i, ++cp)
534 data = (data << 8) | (*(uchar *) cp);
535
536 if ((rc = write_word(info, wp, data)) != 0)
537 return (rc);
538
539 wp += 4;
540 }
541
542 /*
543 * handle word aligned part
544 */
545 while (cnt >= 4) {
546 data = 0;
547 for (i = 0; i < 4; ++i)
548 data = (data << 8) | *src++;
549
550 if ((rc = write_word(info, wp, data)) != 0)
551 return (rc);
552
553 wp += 4;
554 cnt -= 4;
555 }
556
557 if (cnt == 0)
558 return (0);
559
560 /*
561 * handle unaligned tail bytes
562 */
563 data = 0;
564 for (i = 0, cp = wp; i < 4 && cnt > 0; ++i, ++cp) {
565 data = (data << 8) | *src++;
566 --cnt;
567 }
568 for (; i < 4; ++i, ++cp)
569 data = (data << 8) | (*(uchar *) cp);
570
571 return (write_word(info, wp, data));
572 }
573
574 /*-----------------------------------------------------------------------
575 * Copy memory to flash, returns:
576 * 0 - OK
577 * 1 - write timeout
578 * 2 - Flash not erased
579 */
580 #ifdef CFG_FLASH_2ND_16BIT_DEV
581 static int write_word(flash_info_t * info, ulong dest, ulong data)
582 {
583 if (((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320B) ||
584 ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320T) ||
585 ((info->flash_id & FLASH_TYPEMASK) == FLASH_STMW320DT) ||
586 ((info->flash_id & FLASH_TYPEMASK) == FLASH_MXLV320T)) {
587 return write_word_2(info, dest, data);
588 } else {
589 return write_word_1(info, dest, data);
590 }
591 }
592
593 static int write_word_1(flash_info_t * info, ulong dest, ulong data)
594 #else
595 static int write_word(flash_info_t * info, ulong dest, ulong data)
596 #endif
597 {
598 volatile CFG_FLASH_WORD_SIZE *addr2 = (CFG_FLASH_WORD_SIZE *) (info->start[0]);
599 volatile CFG_FLASH_WORD_SIZE *dest2 = (CFG_FLASH_WORD_SIZE *) dest;
600 volatile CFG_FLASH_WORD_SIZE *data2 = (CFG_FLASH_WORD_SIZE *) & data;
601 ulong start;
602 int i, flag;
603
604 /* Check if Flash is (sufficiently) erased */
605 if ((*((vu_long *)dest) & data) != data)
606 return (2);
607
608 for (i = 0; i < 4 / sizeof(CFG_FLASH_WORD_SIZE); i++) {
609 /* Disable interrupts which might cause a timeout here */
610 flag = disable_interrupts();
611
612 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
613 addr2[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
614 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00A000A0;
615
616 dest2[i] = data2[i];
617
618 /* re-enable interrupts if necessary */
619 if (flag)
620 enable_interrupts();
621
622 /* data polling for D7 */
623 start = get_timer(0);
624 while ((dest2[i] & (CFG_FLASH_WORD_SIZE) 0x00800080) !=
625 (data2[i] & (CFG_FLASH_WORD_SIZE) 0x00800080)) {
626
627 if (get_timer(start) > CFG_FLASH_WRITE_TOUT)
628 return (1);
629 }
630 }
631
632 return (0);
633 }
634
635 #ifdef CFG_FLASH_2ND_16BIT_DEV
636
637 #undef CFG_FLASH_WORD_SIZE
638 #define CFG_FLASH_WORD_SIZE unsigned short
639
640 /*
641 * The following code cannot be run from FLASH!
642 */
643 static ulong flash_get_size_2(vu_long * addr, flash_info_t * info)
644 {
645 short i;
646 int n;
647 CFG_FLASH_WORD_SIZE value;
648 ulong base = (ulong) addr;
649 volatile CFG_FLASH_WORD_SIZE *addr2 = (CFG_FLASH_WORD_SIZE *) addr;
650
651 DEBUGF("FLASH ADDR: %08x\n", (unsigned)addr);
652
653 /* issue bank reset to return to read mode */
654 addr2[0] = (CFG_FLASH_WORD_SIZE) 0x00F000F0;
655 /* Write auto select command: read Manufacturer ID */
656 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
657 addr2[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
658 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00900090;
659 udelay(1000);
660
661 value = addr2[0];
662 DEBUGF("FLASH MANUFACT: %x\n", value);
663
664 switch (value) {
665 case (CFG_FLASH_WORD_SIZE) AMD_MANUFACT:
666 info->flash_id = FLASH_MAN_AMD;
667 break;
668 case (CFG_FLASH_WORD_SIZE) FUJ_MANUFACT:
669 info->flash_id = FLASH_MAN_FUJ;
670 break;
671 case (CFG_FLASH_WORD_SIZE) SST_MANUFACT:
672 info->flash_id = FLASH_MAN_SST;
673 break;
674 case (CFG_FLASH_WORD_SIZE) STM_MANUFACT:
675 info->flash_id = FLASH_MAN_STM;
676 break;
677 case (CFG_FLASH_WORD_SIZE) MX_MANUFACT:
678 info->flash_id = FLASH_MAN_MX;
679 break;
680 default:
681 info->flash_id = FLASH_UNKNOWN;
682 info->sector_count = 0;
683 info->size = 0;
684 return (0); /* no or unknown flash */
685 }
686
687 value = addr2[1]; /* device ID */
688 DEBUGF("\nFLASH DEVICEID: %x\n", value);
689
690 switch (value) {
691 case (CFG_FLASH_WORD_SIZE)AMD_ID_LV320T:
692 info->flash_id += FLASH_AM320T;
693 info->sector_count = 71;
694 info->size = 0x00400000;
695 break; /* => 4 MB */
696 case (CFG_FLASH_WORD_SIZE)AMD_ID_LV320B:
697 info->flash_id += FLASH_AM320B;
698 info->sector_count = 71;
699 info->size = 0x00400000;
700 break; /* => 4 MB */
701 case (CFG_FLASH_WORD_SIZE)STM_ID_29W320DT:
702 info->flash_id += FLASH_STMW320DT;
703 info->sector_count = 67;
704 info->size = 0x00400000;
705 break; /* => 4 MB */
706 case (CFG_FLASH_WORD_SIZE)MX_ID_LV320T:
707 info->flash_id += FLASH_MXLV320T;
708 info->sector_count = 71;
709 info->size = 0x00400000;
710 break; /* => 4 MB */
711 default:
712 info->flash_id = FLASH_UNKNOWN;
713 return (0); /* => no or unknown flash */
714 }
715
716 /* set up sector start address table */
717 if (((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) ||
718 ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM040) ||
719 ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMD016)) {
720 for (i = 0; i < info->sector_count; i++)
721 info->start[i] = base + (i * 0x00010000);
722 } else if ((info->flash_id & FLASH_TYPEMASK) == FLASH_STMW320DT) {
723 /* set sector offsets for top boot block type */
724 base += info->size;
725 i = info->sector_count;
726 /* 1 x 16k boot sector */
727 base -= 16 << 10;
728 --i;
729 info->start[i] = base;
730 /* 2 x 8k boot sectors */
731 for (n = 0; n < 2; ++n) {
732 base -= 8 << 10;
733 --i;
734 info->start[i] = base;
735 }
736 /* 1 x 32k boot sector */
737 base -= 32 << 10;
738 --i;
739 info->start[i] = base;
740
741 while (i > 0) { /* 64k regular sectors */
742 base -= 64 << 10;
743 --i;
744 info->start[i] = base;
745 }
746 } else if ((info->flash_id & FLASH_TYPEMASK) == FLASH_MXLV320T) {
747 i = info->sector_count - 1;
748 info->start[i--] = base + info->size - 0x00002000;
749 info->start[i--] = base + info->size - 0x00004000;
750 info->start[i--] = base + info->size - 0x00006000;
751 info->start[i--] = base + info->size - 0x00008000;
752 info->start[i--] = base + info->size - 0x0000a000;
753 info->start[i--] = base + info->size - 0x0000c000;
754 info->start[i--] = base + info->size - 0x0000e000;
755 info->start[i--] = base + info->size - 0x00010000;
756
757 for (; i >= 0; i--)
758 info->start[i] = base + i * 0x00010000;
759 } else {
760 if (info->flash_id & FLASH_BTYPE) {
761 /* set sector offsets for bottom boot block type */
762 info->start[0] = base + 0x00000000;
763 info->start[1] = base + 0x00004000;
764 info->start[2] = base + 0x00006000;
765 info->start[3] = base + 0x00008000;
766
767 for (i = 4; i < info->sector_count; i++)
768 info->start[i] = base + (i * 0x00010000) - 0x00030000;
769 } else {
770 /* set sector offsets for top boot block type */
771 i = info->sector_count - 1;
772 info->start[i--] = base + info->size - 0x00004000;
773 info->start[i--] = base + info->size - 0x00006000;
774 info->start[i--] = base + info->size - 0x00008000;
775
776 for (; i >= 0; i--)
777 info->start[i] = base + i * 0x00010000;
778 }
779 }
780
781 /* check for protected sectors */
782 for (i = 0; i < info->sector_count; i++) {
783 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
784 /* D0 = 1 if protected */
785 addr2 = (volatile CFG_FLASH_WORD_SIZE *)(info->start[i]);
786
787 /* For AMD29033C flash we need to resend the command of *
788 * reading flash protection for upper 8 Mb of flash */
789 if (i == 32) {
790 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0xAAAAAAAA;
791 addr2[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x55555555;
792 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x90909090;
793 }
794
795 if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST)
796 info->protect[i] = 0;
797 else
798 info->protect[i] = addr2[2] & 1;
799 }
800
801 /* issue bank reset to return to read mode */
802 addr2[0] = (CFG_FLASH_WORD_SIZE) 0x00F000F0;
803
804 return (info->size);
805 }
806
807 static int wait_for_DQ7_2(flash_info_t * info, int sect)
808 {
809 ulong start, now, last;
810 volatile CFG_FLASH_WORD_SIZE *addr =
811 (CFG_FLASH_WORD_SIZE *) (info->start[sect]);
812
813 start = get_timer(0);
814 last = start;
815 while ((addr[0] & (CFG_FLASH_WORD_SIZE) 0x00800080) !=
816 (CFG_FLASH_WORD_SIZE) 0x00800080) {
817 if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
818 printf("Timeout\n");
819 return -1;
820 }
821 /* show that we're waiting */
822 if ((now - last) > 1000) { /* every second */
823 putc('.');
824 last = now;
825 }
826 }
827 return 0;
828 }
829
830 static int flash_erase_2(flash_info_t * info, int s_first, int s_last)
831 {
832 volatile CFG_FLASH_WORD_SIZE *addr = (CFG_FLASH_WORD_SIZE *) (info->start[0]);
833 volatile CFG_FLASH_WORD_SIZE *addr2;
834 int flag, prot, sect, l_sect;
835 int i;
836
837 if ((s_first < 0) || (s_first > s_last)) {
838 if (info->flash_id == FLASH_UNKNOWN)
839 printf("- missing\n");
840 else
841 printf("- no sectors to erase\n");
842 return 1;
843 }
844
845 if (info->flash_id == FLASH_UNKNOWN) {
846 printf("Can't erase unknown flash type - aborted\n");
847 return 1;
848 }
849
850 prot = 0;
851 for (sect = s_first; sect <= s_last; ++sect) {
852 if (info->protect[sect])
853 prot++;
854 }
855
856 if (prot)
857 printf("- Warning: %d protected sectors will not be erased!", prot);
858
859 printf("\n");
860
861 l_sect = -1;
862
863 /* Disable interrupts which might cause a timeout here */
864 flag = disable_interrupts();
865
866 /* Start erase on unprotected sectors */
867 for (sect = s_first; sect <= s_last; sect++) {
868 if (info->protect[sect] == 0) { /* not protected */
869 addr2 = (CFG_FLASH_WORD_SIZE *) (info->start[sect]);
870
871 if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) {
872 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
873 addr[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
874 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00800080;
875 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
876 addr[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
877 addr2[0] = (CFG_FLASH_WORD_SIZE) 0x00500050; /* block erase */
878 for (i = 0; i < 50; i++)
879 udelay(1000); /* wait 1 ms */
880 } else {
881 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
882 addr[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
883 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00800080;
884 addr[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
885 addr[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
886 addr2[0] = (CFG_FLASH_WORD_SIZE) 0x00300030; /* sector erase */
887 }
888 l_sect = sect;
889 /*
890 * Wait for each sector to complete, it's more
891 * reliable. According to AMD Spec, you must
892 * issue all erase commands within a specified
893 * timeout. This has been seen to fail, especially
894 * if printf()s are included (for debug)!!
895 */
896 wait_for_DQ7_2(info, sect);
897 }
898 }
899
900 /* re-enable interrupts if necessary */
901 if (flag)
902 enable_interrupts();
903
904 /* wait at least 80us - let's wait 1 ms */
905 udelay(1000);
906
907 /* reset to read mode */
908 addr = (CFG_FLASH_WORD_SIZE *) info->start[0];
909 addr[0] = (CFG_FLASH_WORD_SIZE) 0x00F000F0; /* reset bank */
910
911 printf(" done\n");
912 return 0;
913 }
914
915 static int write_word_2(flash_info_t * info, ulong dest, ulong data)
916 {
917 volatile CFG_FLASH_WORD_SIZE *addr2 = (CFG_FLASH_WORD_SIZE *) (info->start[0]);
918 volatile CFG_FLASH_WORD_SIZE *dest2 = (CFG_FLASH_WORD_SIZE *) dest;
919 volatile CFG_FLASH_WORD_SIZE *data2 = (CFG_FLASH_WORD_SIZE *) & data;
920 ulong start;
921 int i;
922
923 /* Check if Flash is (sufficiently) erased */
924 if ((*((vu_long *)dest) & data) != data)
925 return (2);
926
927 for (i = 0; i < 4 / sizeof(CFG_FLASH_WORD_SIZE); i++) {
928 int flag;
929
930 /* Disable interrupts which might cause a timeout here */
931 flag = disable_interrupts();
932
933 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00AA00AA;
934 addr2[CFG_FLASH_ADDR1] = (CFG_FLASH_WORD_SIZE) 0x00550055;
935 addr2[CFG_FLASH_ADDR0] = (CFG_FLASH_WORD_SIZE) 0x00A000A0;
936
937 dest2[i] = data2[i];
938
939 /* re-enable interrupts if necessary */
940 if (flag)
941 enable_interrupts();
942
943 /* data polling for D7 */
944 start = get_timer(0);
945 while ((dest2[i] & (CFG_FLASH_WORD_SIZE) 0x00800080) !=
946 (data2[i] & (CFG_FLASH_WORD_SIZE) 0x00800080)) {
947
948 if (get_timer(start) > CFG_FLASH_WRITE_TOUT)
949 return (1);
950 }
951 }
952
953 return (0);
954 }
955 #endif /* CFG_FLASH_2ND_16BIT_DEV */
956
957 /*-----------------------------------------------------------------------
958 * Functions
959 */
960 static ulong flash_get_size(vu_long * addr, flash_info_t * info);
961 static int write_word(flash_info_t * info, ulong dest, ulong data);
962
963 /*-----------------------------------------------------------------------
964 */
965
966 unsigned long flash_init(void)
967 {
968 unsigned long total_b = 0;
969 unsigned long size_b[CFG_MAX_FLASH_BANKS];
970 unsigned short index = 0;
971 int i;
972 unsigned long val;
973 unsigned long ebc_boot_size;
974 unsigned long boot_selection;
975
976 mfsdr(sdr_pstrp0, val);
977 index = (val & SDR0_PSTRP0_BOOTSTRAP_MASK) >> 28;
978
979 if ((index == 0xc) || (index == 8)) {
980 /*
981 * Boot Settings in IIC EEprom address 0xA8 or 0xA0
982 * Read Serial Device Strap Register1 in PPC440SPe
983 */
984 mfsdr(sdr_sdstp1, val);
985 boot_selection = val & SDR0_SDSTP1_BOOT_SEL_MASK;
986 ebc_boot_size = val & SDR0_SDSTP1_EBC_ROM_BS_MASK;
987
988 switch(boot_selection) {
989 case SDR0_SDSTP1_BOOT_SEL_EBC:
990 switch(ebc_boot_size) {
991 case SDR0_SDSTP1_EBC_ROM_BS_16BIT:
992 index = 3;
993 break;
994 case SDR0_SDSTP1_EBC_ROM_BS_8BIT:
995 index = 0;
996 break;
997 }
998 break;
999
1000 case SDR0_SDSTP1_BOOT_SEL_PCI:
1001 index = 1;
1002 break;
1003
1004 }
1005 } /*else if (index == 0) {*/
1006 /* if (in8(FPGA_SETTING_REG) & FPGA_SET_REG_OP_CODE_FLASH_ABOVE)*/
1007 /* index = 8;*/ /* sram below op code flash -> new index 8*/
1008 /* }*/
1009
1010 DEBUGF("\n");
1011 DEBUGF("FLASH: Index: %d\n", index);
1012
1013 /* Init: no FLASHes known */
1014 for (i = 0; i < CFG_MAX_FLASH_BANKS; ++i) {
1015 flash_info[i].flash_id = FLASH_UNKNOWN;
1016 flash_info[i].sector_count = -1;
1017 flash_info[i].size = 0;
1018
1019 /* check whether the address is 0 */
1020 if (flash_addr_table[index][i] == 0)
1021 continue;
1022
1023 /* call flash_get_size() to initialize sector address */
1024 size_b[i] = flash_get_size((vu_long *) flash_addr_table[index][i],
1025 &flash_info[i]);
1026
1027 flash_info[i].size = size_b[i];
1028
1029 if (flash_info[i].flash_id == FLASH_UNKNOWN) {
1030 printf("## Unknown FLASH on Bank %d - Size = 0x%08lx = %ld MB\n",
1031 i, size_b[i], size_b[i] << 20);
1032 flash_info[i].sector_count = -1;
1033 flash_info[i].size = 0;
1034 }
1035
1036 /* Monitor protection ON by default */
1037 (void)flash_protect(FLAG_PROTECT_SET, CFG_MONITOR_BASE,
1038 CFG_MONITOR_BASE + CFG_MONITOR_LEN - 1,
1039 &flash_info[i]);
1040 #if defined(CONFIG_ENV_IS_IN_FLASH)
1041 (void)flash_protect(FLAG_PROTECT_SET, CONFIG_ENV_ADDR,
1042 CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1,
1043 &flash_info[i]);
1044 #if defined(CONFIG_ENV_ADDR_REDUND)
1045 (void)flash_protect(FLAG_PROTECT_SET, CONFIG_ENV_ADDR_REDUND,
1046 CONFIG_ENV_ADDR_REDUND + CONFIG_ENV_SECT_SIZE - 1,
1047 &flash_info[i]);
1048 #endif
1049 #endif
1050 total_b += flash_info[i].size;
1051 }
1052
1053 return total_b;
1054 }
"Das U-Boot" Source Tree