]> git.ipfire.org Git - u-boot.git/blob - board/mpl/common/flash.c
projects / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* Code cleanup:
[u-boot.git] / board / mpl / common / flash.c
1 /*
2 * (C) Copyright 2000, 2001
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
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.
12 *
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.
17 *
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,
21 * MA 02111-1307 USA
22 */
23
24 /*
25 * Modified 4/5/2001
26 * Wait for completion of each sector erase command issued
27 * 4/5/2001
28 * Chris Hallinan - DS4.COM, Inc. - clh@net1plus.com
29 */
30
31 /*
32 * Modified 3/7/2001
33 * - adapted for pip405, Denis Peter, MPL AG Switzerland
34 * TODO:
35 * clean-up
36 */
37
38 #include <common.h>
39 #include <ppc4xx.h>
40 #include <asm/processor.h>
41 #include "common_util.h"
42
43 flash_info_t flash_info[CFG_MAX_FLASH_BANKS]; /* info for FLASH chips */
44 /*-----------------------------------------------------------------------
45 * Functions
46 */
47 static ulong flash_get_size (vu_long *addr, flash_info_t *info);
48 static int write_word (flash_info_t *info, ulong dest, ulong data);
49
50 void unlock_intel_sectors(flash_info_t *info,ulong addr,ulong cnt);
51
52
53 #ifdef CONFIG_PIP405
54 #define ADDR0 0x5555
55 #define ADDR1 0x2aaa
56 #define FLASH_WORD_SIZE unsigned short
57 #endif
58
59 #ifdef CONFIG_MIP405
60 #define ADDR0 0x5555
61 #define ADDR1 0x2aaa
62 #define FLASH_WORD_SIZE unsigned short
63 #endif
64
65 #define FALSE 0
66 #define TRUE 1
67
68 /*-----------------------------------------------------------------------
69 */
70
71
72 unsigned long flash_init (void)
73 {
74 unsigned long size_b0, size_b1;
75 int i;
76
77 /* Since we are relocated, we can set-up the CS finally */
78 setup_cs_reloc();
79 /* get and display boot mode */
80 i=get_boot_mode();
81 if(i & BOOT_PCI)
82 printf("(PCI Boot %s Map) ",(i & BOOT_MPS) ?
83 "MPS" : "Flash");
84 else
85 printf("(%s Boot) ",(i & BOOT_MPS) ?
86 "MPS" : "Flash");
87 /* Init: no FLASHes known */
88 for (i=0; i<CFG_MAX_FLASH_BANKS; ++i) {
89 flash_info[i].flash_id = FLASH_UNKNOWN;
90 }
91
92 /* Static FLASH Bank configuration here - FIXME XXX */
93
94 size_b0 = flash_get_size((vu_long *)FLASH_BASE0_PRELIM, &flash_info[0]);
95
96 if (flash_info[0].flash_id == FLASH_UNKNOWN) {
97 printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
98 size_b0, size_b0<<20);
99 }
100 /* protect the bootloader */
101 /* Monitor protection ON by default */
102 #if CFG_MONITOR_BASE >= CFG_FLASH_BASE
103 flash_protect(FLAG_PROTECT_SET,
104 CFG_MONITOR_BASE,
105 CFG_MONITOR_BASE+monitor_flash_len-1,
106 &flash_info[0]);
107 #endif
108 size_b1 = 0 ;
109 flash_info[0].size = size_b0;
110 #if 0
111 /* include this if you want to test if
112 the relocation has be done ok.
113 This will disable both Chipselects */
114 mtdcr (ebccfga, pb0cr);
115 mtdcr (ebccfgd, 0L);
116 mtdcr (ebccfga, pb1cr);
117 mtdcr (ebccfgd, 0L);
118 printf("CS0 & CS1 switched off for test\n");
119 #endif
120 return (size_b0);
121 }
122
123
124 /*-----------------------------------------------------------------------
125 */
126 void flash_print_info (flash_info_t *info)
127 {
128 int i;
129 int k;
130 int size;
131 int erased;
132 volatile unsigned long *flash;
133
134 if (info->flash_id == FLASH_UNKNOWN) {
135 printf ("missing or unknown FLASH type\n");
136 return;
137 }
138
139 switch (info->flash_id & FLASH_VENDMASK) {
140 case FLASH_MAN_AMD: printf ("AMD "); break;
141 case FLASH_MAN_FUJ: printf ("FUJITSU "); break;
142 case FLASH_MAN_SST: printf ("SST "); break;
143 case FLASH_MAN_INTEL: printf ("Intel "); break;
144 default: printf ("Unknown Vendor "); break;
145 }
146
147 switch (info->flash_id & FLASH_TYPEMASK) {
148 case FLASH_AM040: printf ("AM29F040 (512 Kbit, uniform sector size)\n");
149 break;
150 case FLASH_AM400B: printf ("AM29LV400B (4 Mbit, bottom boot sect)\n");
151 break;
152 case FLASH_AM400T: printf ("AM29LV400T (4 Mbit, top boot sector)\n");
153 break;
154 case FLASH_AM800B: printf ("AM29LV800B (8 Mbit, bottom boot sect)\n");
155 break;
156 case FLASH_AM800T: printf ("AM29LV800T (8 Mbit, top boot sector)\n");
157 break;
158 case FLASH_AM160B: printf ("AM29LV160B (16 Mbit, bottom boot sect)\n");
159 break;
160 case FLASH_AM160T: printf ("AM29LV160T (16 Mbit, top boot sector)\n");
161 break;
162 case FLASH_AM320B: printf ("AM29LV320B (32 Mbit, bottom boot sect)\n");
163 break;
164 case FLASH_AM320T: printf ("AM29LV320T (32 Mbit, top boot sector)\n");
165 break;
166 case FLASH_SST800A: printf ("SST39LF/VF800 (8 Mbit, uniform sector size)\n");
167 break;
168 case FLASH_SST160A: printf ("SST39LF/VF160 (16 Mbit, uniform sector size)\n");
169 break;
170 case FLASH_INTEL320T: printf ("TE28F320C3 (32 Mbit, top sector size)\n");
171 break;
172 default: printf ("Unknown Chip Type\n");
173 break;
174 }
175
176 printf (" Size: %ld KB in %d Sectors\n",
177 info->size >> 10, info->sector_count);
178
179 printf (" Sector Start Addresses:");
180 for (i=0; i<info->sector_count; ++i) {
181 /*
182 * Check if whole sector is erased
183 */
184 if (i != (info->sector_count-1))
185 size = info->start[i+1] - info->start[i];
186 else
187 size = info->start[0] + info->size - info->start[i];
188 erased = 1;
189 flash = (volatile unsigned long *)info->start[i];
190 size = size >> 2; /* divide by 4 for longword access */
191 for (k=0; k<size; k++) {
192 if (*flash++ != 0xffffffff) {
193 erased = 0;
194 break;
195 }
196 }
197 if ((i % 5) == 0)
198 printf ("\n ");
199 printf (" %08lX%s%s",
200 info->start[i],
201 erased ? " E" : " ",
202 info->protect[i] ? "RO " : " ");
203 }
204 printf ("\n");
205 }
206
207 /*-----------------------------------------------------------------------
208 */
209
210
211 /*-----------------------------------------------------------------------
212 */
213
214 /*
215 * The following code cannot be run from FLASH!
216 */
217 static ulong flash_get_size (vu_long *addr, flash_info_t *info)
218 {
219 short i;
220 FLASH_WORD_SIZE value;
221 ulong base = (ulong)addr;
222 volatile FLASH_WORD_SIZE *addr2 = (FLASH_WORD_SIZE *)addr;
223
224 /* Write auto select command: read Manufacturer ID */
225 addr2[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
226 addr2[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
227 addr2[ADDR0] = (FLASH_WORD_SIZE)0x00900090;
228
229 value = addr2[0];
230 /* printf("flash_get_size value: %x\n",value); */
231 switch (value) {
232 case (FLASH_WORD_SIZE)AMD_MANUFACT:
233 info->flash_id = FLASH_MAN_AMD;
234 break;
235 case (FLASH_WORD_SIZE)FUJ_MANUFACT:
236 info->flash_id = FLASH_MAN_FUJ;
237 break;
238 case (FLASH_WORD_SIZE)INTEL_MANUFACT:
239 info->flash_id = FLASH_MAN_INTEL;
240 break;
241 case (FLASH_WORD_SIZE)SST_MANUFACT:
242 info->flash_id = FLASH_MAN_SST;
243 break;
244 default:
245 info->flash_id = FLASH_UNKNOWN;
246 info->sector_count = 0;
247 info->size = 0;
248 return (0); /* no or unknown flash */
249 }
250 value = addr2[1]; /* device ID */
251 /* printf("Device value %x\n",value); */
252 switch (value) {
253 case (FLASH_WORD_SIZE)AMD_ID_F040B:
254 info->flash_id += FLASH_AM040;
255 info->sector_count = 8;
256 info->size = 0x0080000; /* => 512 ko */
257 break;
258 case (FLASH_WORD_SIZE)AMD_ID_LV400T:
259 info->flash_id += FLASH_AM400T;
260 info->sector_count = 11;
261 info->size = 0x00080000;
262 break; /* => 0.5 MB */
263
264 case (FLASH_WORD_SIZE)AMD_ID_LV400B:
265 info->flash_id += FLASH_AM400B;
266 info->sector_count = 11;
267 info->size = 0x00080000;
268 break; /* => 0.5 MB */
269
270 case (FLASH_WORD_SIZE)AMD_ID_LV800T:
271 info->flash_id += FLASH_AM800T;
272 info->sector_count = 19;
273 info->size = 0x00100000;
274 break; /* => 1 MB */
275
276 case (FLASH_WORD_SIZE)AMD_ID_LV800B:
277 info->flash_id += FLASH_AM800B;
278 info->sector_count = 19;
279 info->size = 0x00100000;
280 break; /* => 1 MB */
281
282 case (FLASH_WORD_SIZE)AMD_ID_LV160T:
283 info->flash_id += FLASH_AM160T;
284 info->sector_count = 35;
285 info->size = 0x00200000;
286 break; /* => 2 MB */
287
288 case (FLASH_WORD_SIZE)AMD_ID_LV160B:
289 info->flash_id += FLASH_AM160B;
290 info->sector_count = 35;
291 info->size = 0x00200000;
292 break; /* => 2 MB */
293 #if 0 /* enable when device IDs are available */
294 case (FLASH_WORD_SIZE)AMD_ID_LV320T:
295 info->flash_id += FLASH_AM320T;
296 info->sector_count = 67;
297 info->size = 0x00400000;
298 break; /* => 4 MB */
299
300 case (FLASH_WORD_SIZE)AMD_ID_LV320B:
301 info->flash_id += FLASH_AM320B;
302 info->sector_count = 67;
303 info->size = 0x00400000;
304 break; /* => 4 MB */
305 #endif
306 case (FLASH_WORD_SIZE)SST_ID_xF800A:
307 info->flash_id += FLASH_SST800A;
308 info->sector_count = 16;
309 info->size = 0x00100000;
310 break; /* => 1 MB */
311 case (FLASH_WORD_SIZE)INTEL_ID_28F320C3T:
312 info->flash_id += FLASH_INTEL320T;
313 info->sector_count = 71;
314 info->size = 0x00400000;
315 break; /* => 4 MB */
316
317
318 case (FLASH_WORD_SIZE)SST_ID_xF160A:
319 info->flash_id += FLASH_SST160A;
320 info->sector_count = 32;
321 info->size = 0x00200000;
322 break; /* => 2 MB */
323
324 default:
325 info->flash_id = FLASH_UNKNOWN;
326 return (0); /* => no or unknown flash */
327
328 }
329
330 /* set up sector start address table */
331 if (((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) ||
332 (info->flash_id == FLASH_AM040)){
333 for (i = 0; i < info->sector_count; i++)
334 info->start[i] = base + (i * 0x00010000);
335 }
336 else {
337 if (info->flash_id & FLASH_BTYPE) {
338 /* set sector offsets for bottom boot block type */
339 info->start[0] = base + 0x00000000;
340 info->start[1] = base + 0x00004000;
341 info->start[2] = base + 0x00006000;
342 info->start[3] = base + 0x00008000;
343 for (i = 4; i < info->sector_count; i++)
344 info->start[i] = base + (i * 0x00010000) - 0x00030000;
345 }
346 else {
347 /* set sector offsets for top boot block type */
348 i = info->sector_count - 1;
349 if(info->sector_count==71) {
350
351 info->start[i--] = base + info->size - 0x00002000;
352 info->start[i--] = base + info->size - 0x00004000;
353 info->start[i--] = base + info->size - 0x00006000;
354 info->start[i--] = base + info->size - 0x00008000;
355 info->start[i--] = base + info->size - 0x0000A000;
356 info->start[i--] = base + info->size - 0x0000C000;
357 info->start[i--] = base + info->size - 0x0000E000;
358 for (; i >= 0; i--)
359 info->start[i] = base + i * 0x000010000;
360 }
361 else {
362 info->start[i--] = base + info->size - 0x00004000;
363 info->start[i--] = base + info->size - 0x00006000;
364 info->start[i--] = base + info->size - 0x00008000;
365 for (; i >= 0; i--)
366 info->start[i] = base + i * 0x00010000;
367 }
368 }
369 }
370
371 /* check for protected sectors */
372 for (i = 0; i < info->sector_count; i++) {
373 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
374 /* D0 = 1 if protected */
375 addr2 = (volatile FLASH_WORD_SIZE *)(info->start[i]);
376 if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL)
377 info->protect[i] = 0;
378 else
379 info->protect[i] = addr2[2] & 1;
380 }
381
382 /*
383 * Prevent writes to uninitialized FLASH.
384 */
385 if (info->flash_id != FLASH_UNKNOWN) {
386 addr2 = (FLASH_WORD_SIZE *)info->start[0];
387 *addr2 = (FLASH_WORD_SIZE)0x00F000F0; /* reset bank */
388 }
389 return (info->size);
390 }
391
392
393 int wait_for_DQ7(flash_info_t *info, int sect)
394 {
395 ulong start, now, last;
396 volatile FLASH_WORD_SIZE *addr = (FLASH_WORD_SIZE *)(info->start[sect]);
397
398 start = get_timer (0);
399 last = start;
400 while ((addr[0] & (FLASH_WORD_SIZE)0x00800080) != (FLASH_WORD_SIZE)0x00800080) {
401 if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
402 printf ("Timeout\n");
403 return -1;
404 }
405 /* show that we're waiting */
406 if ((now - last) > 1000) { /* every second */
407 putc ('.');
408 last = now;
409 }
410 }
411 return 0;
412 }
413
414 int intel_wait_for_DQ7(flash_info_t *info, int sect)
415 {
416 ulong start, now, last;
417 volatile FLASH_WORD_SIZE *addr = (FLASH_WORD_SIZE *)(info->start[sect]);
418
419 start = get_timer (0);
420 last = start;
421 while ((addr[0] & (FLASH_WORD_SIZE)0x00800080) != (FLASH_WORD_SIZE)0x00800080) {
422 if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
423 printf ("Timeout\n");
424 return -1;
425 }
426 /* show that we're waiting */
427 if ((now - last) > 1000) { /* every second */
428 putc ('.');
429 last = now;
430 }
431 }
432 addr[0]=(FLASH_WORD_SIZE)0x00500050;
433 return 0;
434 }
435
436 /*-----------------------------------------------------------------------
437 */
438
439 int flash_erase (flash_info_t *info, int s_first, int s_last)
440 {
441 volatile FLASH_WORD_SIZE *addr = (FLASH_WORD_SIZE *)(info->start[0]);
442 volatile FLASH_WORD_SIZE *addr2;
443 int flag, prot, sect, l_sect;
444 int i;
445
446
447 if ((s_first < 0) || (s_first > s_last)) {
448 if (info->flash_id == FLASH_UNKNOWN) {
449 printf ("- missing\n");
450 } else {
451 printf ("- no sectors to erase\n");
452 }
453 return 1;
454 }
455
456 if (info->flash_id == FLASH_UNKNOWN) {
457 printf ("Can't erase unknown flash type - aborted\n");
458 return 1;
459 }
460
461 prot = 0;
462 for (sect=s_first; sect<=s_last; ++sect) {
463 if (info->protect[sect]) {
464 prot++;
465 }
466 }
467
468 if (prot) {
469 printf ("- Warning: %d protected sectors will not be erased!\n",
470 prot);
471 } else {
472 printf ("\n");
473 }
474
475 l_sect = -1;
476
477 /* Disable interrupts which might cause a timeout here */
478 flag = disable_interrupts();
479
480 /* Start erase on unprotected sectors */
481 for (sect = s_first; sect<=s_last; sect++) {
482 if (info->protect[sect] == 0) { /* not protected */
483 addr2 = (FLASH_WORD_SIZE *)(info->start[sect]);
484 /* printf("Erasing sector %p\n", addr2); */ /* CLH */
485 if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) {
486 addr[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
487 addr[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
488 addr[ADDR0] = (FLASH_WORD_SIZE)0x00800080;
489 addr[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
490 addr[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
491 addr2[0] = (FLASH_WORD_SIZE)0x00500050; /* block erase */
492 for (i=0; i<50; i++)
493 udelay(1000); /* wait 1 ms */
494 wait_for_DQ7(info, sect);
495 }
496 else {
497 if((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL){
498 addr2[0] = (FLASH_WORD_SIZE)0x00600060; /* unlock sector */
499 addr2[0] = (FLASH_WORD_SIZE)0x00D000D0; /* sector erase */
500 intel_wait_for_DQ7(info, sect);
501 addr2[0] = (FLASH_WORD_SIZE)0x00200020; /* sector erase */
502 addr2[0] = (FLASH_WORD_SIZE)0x00D000D0; /* sector erase */
503 intel_wait_for_DQ7(info, sect);
504 }
505 else {
506 addr[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
507 addr[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
508 addr[ADDR0] = (FLASH_WORD_SIZE)0x00800080;
509 addr[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
510 addr[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
511 addr2[0] = (FLASH_WORD_SIZE)0x00300030; /* sector erase */
512 wait_for_DQ7(info, sect);
513 }
514 }
515 l_sect = sect;
516 /*
517 * Wait for each sector to complete, it's more
518 * reliable. According to AMD Spec, you must
519 * issue all erase commands within a specified
520 * timeout. This has been seen to fail, especially
521 * if printf()s are included (for debug)!!
522 */
523 /* wait_for_DQ7(info, sect); */
524 }
525 }
526
527 /* re-enable interrupts if necessary */
528 if (flag)
529 enable_interrupts();
530
531 /* wait at least 80us - let's wait 1 ms */
532 udelay (1000);
533
534 #if 0
535 /*
536 * We wait for the last triggered sector
537 */
538 if (l_sect < 0)
539 goto DONE;
540 wait_for_DQ7(info, l_sect);
541
542 DONE:
543 #endif
544 /* reset to read mode */
545 addr = (FLASH_WORD_SIZE *)info->start[0];
546 addr[0] = (FLASH_WORD_SIZE)0x00F000F0; /* reset bank */
547
548 printf (" done\n");
549 return 0;
550 }
551
552
553 void unlock_intel_sectors(flash_info_t *info,ulong addr,ulong cnt)
554 {
555 int i;
556 volatile FLASH_WORD_SIZE *addr2;
557 long c;
558 c= (long)cnt;
559 for(i=info->sector_count-1;i>0;i--)
560 {
561 if(addr>=info->start[i])
562 break;
563 }
564 do {
565 addr2 = (FLASH_WORD_SIZE *)(info->start[i]);
566 addr2[0] = (FLASH_WORD_SIZE)0x00600060; /* unlock sector setup */
567 addr2[0] = (FLASH_WORD_SIZE)0x00D000D0; /* unlock sector */
568 intel_wait_for_DQ7(info, i);
569 i++;
570 c-=(info->start[i]-info->start[i-1]);
571 }while(c>0);
572 }
573
574
575 /*-----------------------------------------------------------------------
576 * Copy memory to flash, returns:
577 * 0 - OK
578 * 1 - write timeout
579 * 2 - Flash not erased
580 */
581
582 int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
583 {
584 ulong cp, wp, data;
585 int i, l, rc;
586
587 if((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL){
588 unlock_intel_sectors(info,addr,cnt);
589 }
590 wp = (addr & ~3); /* get lower word aligned address */
591 /*
592 * handle unaligned start bytes
593 */
594 if ((l = addr - wp) != 0) {
595 data = 0;
596 for (i=0, cp=wp; i<l; ++i, ++cp) {
597 data = (data << 8) | (*(uchar *)cp);
598 }
599 for (; i<4 && cnt>0; ++i) {
600 data = (data << 8) | *src++;
601 --cnt;
602 ++cp;
603 }
604 for (; cnt==0 && i<4; ++i, ++cp) {
605 data = (data << 8) | (*(uchar *)cp);
606 }
607
608 if ((rc = write_word(info, wp, data)) != 0) {
609 return (rc);
610 }
611 wp += 4;
612 }
613
614 /*
615 * handle word aligned part
616 */
617 while (cnt >= 4) {
618 data = 0;
619 for (i=0; i<4; ++i) {
620 data = (data << 8) | *src++;
621 }
622 if ((rc = write_word(info, wp, data)) != 0) {
623 return (rc);
624 }
625 wp += 4;
626 if((wp % 0x10000)==0)
627 printf("."); /* show Progress */
628 cnt -= 4;
629 }
630
631 if (cnt == 0) {
632 return (0);
633 }
634
635 /*
636 * handle unaligned tail bytes
637 */
638 data = 0;
639 for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) {
640 data = (data << 8) | *src++;
641 --cnt;
642 }
643 for (; i<4; ++i, ++cp) {
644 data = (data << 8) | (*(uchar *)cp);
645 }
646 rc=write_word(info, wp, data);
647 return rc;
648 }
649
650 /*-----------------------------------------------------------------------
651 * Write a word to Flash, returns:
652 * 0 - OK
653 * 1 - write timeout
654 * 2 - Flash not erased
655 */
656 static FLASH_WORD_SIZE *read_val = (FLASH_WORD_SIZE *)0x200000;
657
658 static int write_word (flash_info_t *info, ulong dest, ulong data)
659 {
660 volatile FLASH_WORD_SIZE *addr2 = (FLASH_WORD_SIZE *)(info->start[0]);
661 volatile FLASH_WORD_SIZE *dest2 = (FLASH_WORD_SIZE *)dest;
662 volatile FLASH_WORD_SIZE *data2 = (FLASH_WORD_SIZE *)&data;
663 ulong start;
664 int flag;
665 int i;
666
667 /* Check if Flash is (sufficiently) erased */
668 if ((*((volatile FLASH_WORD_SIZE *)dest) &
669 (FLASH_WORD_SIZE)data) != (FLASH_WORD_SIZE)data) {
670 return (2);
671 }
672 /* Disable interrupts which might cause a timeout here */
673 flag = disable_interrupts();
674 for (i=0; i<4/sizeof(FLASH_WORD_SIZE); i++)
675 {
676 if((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL){
677 /* intel style writting */
678 dest2[i] = (FLASH_WORD_SIZE)0x00500050;
679 dest2[i] = (FLASH_WORD_SIZE)0x00400040;
680 *read_val++ = data2[i];
681 dest2[i] = data2[i];
682 if (flag)
683 enable_interrupts();
684 /* data polling for D7 */
685 start = get_timer (0);
686 udelay(10);
687 while ((dest2[i] & (FLASH_WORD_SIZE)0x00800080) != (FLASH_WORD_SIZE)0x00800080)
688 {
689 if (get_timer(start) > CFG_FLASH_WRITE_TOUT)
690 return (1);
691 }
692 dest2[i] = (FLASH_WORD_SIZE)0x00FF00FF; /* return to read mode */
693 udelay(10);
694 dest2[i] = (FLASH_WORD_SIZE)0x00FF00FF; /* return to read mode */
695 if(dest2[i]!=data2[i])
696 printf("Error at %p 0x%04X != 0x%04X\n",&dest2[i],dest2[i],data2[i]);
697 }
698 else {
699 addr2[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
700 addr2[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
701 addr2[ADDR0] = (FLASH_WORD_SIZE)0x00A000A0;
702 dest2[i] = data2[i];
703 /* re-enable interrupts if necessary */
704 if (flag)
705 enable_interrupts();
706 /* data polling for D7 */
707 start = get_timer (0);
708 while ((dest2[i] & (FLASH_WORD_SIZE)0x00800080) !=
709 (data2[i] & (FLASH_WORD_SIZE)0x00800080)) {
710 if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
711 return (1);
712 }
713 }
714 }
715 }
716 return (0);
717 }
718
719 /*-----------------------------------------------------------------------
720 */
"Das U-Boot" Source Tree