source: SVN/rincon/u-boot/board/xpedite1k/flash.c @ 55

Last change on this file since 55 was 55, checked in by Tim Harvey, 22 months ago

rincon: added latest u-boot source

restored form server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 15.1 KB
Line 
1/*
2 * (C) Copyright 2002-2004
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/*
35 * Ported to XPedite1000, 1/2 mb boot flash only
36 * Travis B. Sawyer, <travis.sawyer@sandburst.com>
37 */
38
39#include <common.h>
40#include <ppc4xx.h>
41#include <asm/processor.h>
42
43
44#undef DEBUG
45#ifdef DEBUG
46#define DEBUGF(x...) printf(x)
47#else
48#define DEBUGF(x...)
49#endif /* DEBUG */
50
51#define BOOT_SMALL_FLASH        32              /* 00100000 */
52#define FLASH_ONBD_N            2               /* 00000010 */
53#define FLASH_SRAM_SEL          1               /* 00000001 */
54
55#define BOOT_SMALL_FLASH_VAL    4
56#define FLASH_ONBD_N_VAL        2
57#define FLASH_SRAM_SEL_VAL      1
58
59
60flash_info_t flash_info[CFG_MAX_FLASH_BANKS]; /* info for FLASH chips   */
61
62static unsigned long flash_addr_table[8][CFG_MAX_FLASH_BANKS] = {
63        {0xfff80000},   /* 0:000: configuraton 3 */
64        {0xfff90000},   /* 1:001: configuraton 4 */
65        {0xfffa0000},   /* 2:010: configuraton 7 */
66        {0xfffb0000},   /* 3:011: configuraton 8 */
67        {0xfffc0000},   /* 4:100: configuraton 1 */
68        {0xfffd0000},   /* 5:101: configuraton 2 */
69        {0xfffe0000},   /* 6:110: configuraton 5 */
70        {0xffff0000}    /* 7:111: configuraton 6 */
71};
72
73/*-----------------------------------------------------------------------
74 * Functions
75 */
76static ulong flash_get_size (vu_long *addr, flash_info_t *info);
77static int write_word (flash_info_t *info, ulong dest, ulong data);
78
79
80#ifdef CONFIG_XPEDITE1K
81#define ADDR0           0x5555
82#define ADDR1           0x2aaa
83#define FLASH_WORD_SIZE unsigned char
84#endif
85
86/*-----------------------------------------------------------------------
87 */
88
89unsigned long flash_init (void)
90{
91        unsigned long total_b = 0;
92        unsigned long size_b[CFG_MAX_FLASH_BANKS];
93        unsigned short index = 0;
94        int i;
95
96
97        DEBUGF("\n");
98        DEBUGF("FLASH: Index: %d\n", index);
99
100        /* Init: no FLASHes known */
101        for (i=0; i<CFG_MAX_FLASH_BANKS; ++i) {
102                flash_info[i].flash_id = FLASH_UNKNOWN;
103                flash_info[i].sector_count = -1;
104                flash_info[i].size = 0;
105
106                /* check whether the address is 0 */
107                if (flash_addr_table[index][i] == 0) {
108                        continue;
109                }
110
111                /* call flash_get_size() to initialize sector address */
112                size_b[i] = flash_get_size(
113                        (vu_long *)flash_addr_table[index][i], &flash_info[i]);
114                flash_info[i].size = size_b[i];
115                if (flash_info[i].flash_id == FLASH_UNKNOWN) {
116                        printf ("## Unknown FLASH on Bank %d - Size = 0x%08lx = %ld MB\n",
117                                i, size_b[i], size_b[i]<<20);
118                        flash_info[i].sector_count = -1;
119                        flash_info[i].size = 0;
120                }
121
122                total_b += flash_info[i].size;
123        }
124
125        return total_b;
126}
127
128
129/*-----------------------------------------------------------------------
130 */
131void flash_print_info  (flash_info_t *info)
132{
133        int i;
134        int k;
135        int size;
136        int erased;
137        volatile unsigned long *flash;
138
139        if (info->flash_id == FLASH_UNKNOWN) {
140                printf ("missing or unknown FLASH type\n");
141                return;
142        }
143
144        switch (info->flash_id & FLASH_VENDMASK) {
145        case FLASH_MAN_AMD:     printf ("AMD ");                break;
146        case FLASH_MAN_FUJ:     printf ("FUJITSU ");            break;
147        case FLASH_MAN_SST:     printf ("SST ");                break;
148        default:                printf ("Unknown Vendor ");     break;
149        }
150
151        switch (info->flash_id & FLASH_TYPEMASK) {
152        case FLASH_AMD016:      printf ("AM29F016D (16 Mbit, uniform sector size)\n");
153                break;
154        case FLASH_AM040:       printf ("AM29F040 (512 Kbit, uniform sector size)\n");
155                break;
156        case FLASH_AM400B:      printf ("AM29LV400B (4 Mbit, bottom boot sect)\n");
157                break;
158        case FLASH_AM400T:      printf ("AM29LV400T (4 Mbit, top boot sector)\n");
159                break;
160        case FLASH_AM800B:      printf ("AM29LV800B (8 Mbit, bottom boot sect)\n");
161                break;
162        case FLASH_AM800T:      printf ("AM29LV800T (8 Mbit, top boot sector)\n");
163                break;
164        case FLASH_AM160B:      printf ("AM29LV160B (16 Mbit, bottom boot sect)\n");
165                break;
166        case FLASH_AM160T:      printf ("AM29LV160T (16 Mbit, top boot sector)\n");
167                break;
168        case FLASH_AM320B:      printf ("AM29LV320B (32 Mbit, bottom boot sect)\n");
169                break;
170        case FLASH_AM320T:      printf ("AM29LV320T (32 Mbit, top boot sector)\n");
171                break;
172        case FLASH_SST800A:     printf ("SST39LF/VF800 (8 Mbit, uniform sector size)\n");
173                break;
174        case FLASH_SST160A:     printf ("SST39LF/VF160 (16 Mbit, uniform sector size)\n");
175                break;
176        default:                printf ("Unknown Chip Type\n");
177                break;
178        }
179
180        printf ("  Size: %ld KB in %d Sectors\n",
181                info->size >> 10, info->sector_count);
182
183        printf ("  Sector Start Addresses:");
184        for (i=0; i<info->sector_count; ++i) {
185                /*
186                 * Check if whole sector is erased
187                 */
188                if (i != (info->sector_count-1))
189                        size = info->start[i+1] - info->start[i];
190                else
191                        size = info->start[0] + info->size - info->start[i];
192                erased = 1;
193                flash = (volatile unsigned long *)info->start[i];
194                size = size >> 2;        /* divide by 4 for longword access */
195                for (k=0; k<size; k++)
196                {
197                        if (*flash++ != 0xffffffff)
198                        {
199                                erased = 0;
200                                break;
201                        }
202                }
203
204                if ((i % 5) == 0)
205                        printf ("\n   ");
206                        printf (" %08lX%s%s",
207                                info->start[i],
208                                erased ? " E" : "  ",
209                                info->protect[i] ? "RO " : "   "
210                                );
211                        }
212                printf ("\n");
213                return;
214        }
215
216/*-----------------------------------------------------------------------
217 */
218
219
220/*-----------------------------------------------------------------------
221 */
222
223/*
224 * The following code cannot be run from FLASH!
225 */
226static ulong flash_get_size (vu_long *addr, flash_info_t *info)
227{
228        short i;
229        FLASH_WORD_SIZE value;
230        ulong base = (ulong)addr;
231        volatile FLASH_WORD_SIZE *addr2 = (FLASH_WORD_SIZE *)addr;
232
233        DEBUGF("FLASH ADDR: %08x\n", (unsigned)addr );
234
235        /* Write auto select command: read Manufacturer ID */
236        udelay(10000);
237        addr2[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
238        udelay(1000);
239        addr2[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
240        udelay(1000);
241        addr2[ADDR0] = (FLASH_WORD_SIZE)0x00900090;
242        udelay(1000);
243
244#ifdef CONFIG_ADCIOP
245        value = addr2[2];
246#else
247        value = addr2[0];
248#endif
249
250        DEBUGF("FLASH MANUFACT: %x\n", value);
251
252        switch (value) {
253        case (FLASH_WORD_SIZE)AMD_MANUFACT:
254                info->flash_id = FLASH_MAN_AMD;
255                break;
256        case (FLASH_WORD_SIZE)FUJ_MANUFACT:
257                info->flash_id = FLASH_MAN_FUJ;
258                break;
259        case (FLASH_WORD_SIZE)SST_MANUFACT:
260                info->flash_id = FLASH_MAN_SST;
261                break;
262        case (FLASH_WORD_SIZE)STM_MANUFACT:
263                info->flash_id = FLASH_MAN_STM;
264                break;
265        default:
266                info->flash_id = FLASH_UNKNOWN;
267                info->sector_count = 0;
268                info->size = 0;
269                return (0);                     /* no or unknown flash  */
270        }
271
272#ifdef CONFIG_ADCIOP
273        value = addr2[0];                       /* device ID            */
274        debug ("\ndev_code=%x\n", value);
275#else
276        value = addr2[1];                       /* device ID            */
277#endif
278
279        DEBUGF("\nFLASH DEVICEID: %x\n", value);
280
281        switch (value) {
282        case (FLASH_WORD_SIZE)AMD_ID_LV040B:
283                info->flash_id += FLASH_AM040;
284                info->sector_count = 8;
285                info->size = 0x00080000; /* => 512 kb */
286                break;
287
288        default:
289                info->flash_id = FLASH_UNKNOWN;
290                return (0);                     /* => no or unknown flash */
291
292        }
293
294        /* set up sector start address table */
295        if (((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) ||
296                    (info->flash_id  == FLASH_AM040) ||
297                    (info->flash_id  == FLASH_AMD016)) {
298                for (i = 0; i < info->sector_count; i++)
299                        info->start[i] = base + (i * 0x00010000);
300        } else {
301                if (info->flash_id & FLASH_BTYPE) {
302                        /* set sector offsets for bottom boot block type        */
303                        info->start[0] = base + 0x00000000;
304                        info->start[1] = base + 0x00004000;
305                        info->start[2] = base + 0x00006000;
306                        info->start[3] = base + 0x00008000;
307                        for (i = 4; i < info->sector_count; i++) {
308                                info->start[i] = base + (i * 0x00010000) - 0x00030000;
309                        }
310                } else {
311                        /* set sector offsets for top boot block type           */
312                        i = info->sector_count - 1;
313                        info->start[i--] = base + info->size - 0x00004000;
314                        info->start[i--] = base + info->size - 0x00006000;
315                        info->start[i--] = base + info->size - 0x00008000;
316                        for (; i >= 0; i--) {
317                                info->start[i] = base + i * 0x00010000;
318                        }
319                }
320        }
321
322        /* check for protected sectors */
323        for (i = 0; i < info->sector_count; i++) {
324                /* read sector protection at sector address, (A7 .. A0) = 0x02 */
325                /* D0 = 1 if protected */
326#ifdef CONFIG_ADCIOP
327                addr2 = (volatile FLASH_WORD_SIZE *)(info->start[i]);
328                info->protect[i] = addr2[4] & 1;
329#else
330                addr2 = (volatile FLASH_WORD_SIZE *)(info->start[i]);
331                if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST)
332                        info->protect[i] = 0;
333                else
334                        info->protect[i] = addr2[2] & 1;
335#endif
336        }
337
338        /*
339         * Prevent writes to uninitialized FLASH.
340         */
341        if (info->flash_id != FLASH_UNKNOWN) {
342#if 0 /* test-only */
343#ifdef CONFIG_ADCIOP
344                addr2 = (volatile unsigned char *)info->start[0];
345                addr2[ADDR0] = 0xAA;
346                addr2[ADDR1] = 0x55;
347                addr2[ADDR0] = 0xF0;  /* reset bank */
348#else
349                addr2 = (FLASH_WORD_SIZE *)info->start[0];
350                *addr2 = (FLASH_WORD_SIZE)0x00F000F0;   /* reset bank */
351#endif
352#else /* test-only */
353                addr2 = (FLASH_WORD_SIZE *)info->start[0];
354                *addr2 = (FLASH_WORD_SIZE)0x00F000F0;   /* reset bank */
355#endif /* test-only */
356        }
357
358        return (info->size);
359}
360
361int wait_for_DQ7(flash_info_t *info, int sect)
362{
363        ulong start, now, last;
364        volatile FLASH_WORD_SIZE *addr = (FLASH_WORD_SIZE *)(info->start[sect]);
365
366        start = get_timer (0);
367        last  = start;
368        while ((addr[0] & (FLASH_WORD_SIZE)0x00800080) != (FLASH_WORD_SIZE)0x00800080) {
369                if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
370                        printf ("Timeout\n");
371                        return -1;
372                }
373                /* show that we're waiting */
374                if ((now - last) > 1000) {  /* every second */
375                        putc ('.');
376                        last = now;
377                }
378        }
379        return 0;
380}
381
382/*-----------------------------------------------------------------------
383 */
384
385int     flash_erase (flash_info_t *info, int s_first, int s_last)
386{
387        volatile FLASH_WORD_SIZE *addr = (FLASH_WORD_SIZE *)(info->start[0]);
388        volatile FLASH_WORD_SIZE *addr2;
389        int flag, prot, sect, l_sect;
390        int i;
391
392        if ((s_first < 0) || (s_first > s_last)) {
393                if (info->flash_id == FLASH_UNKNOWN) {
394                        printf ("- missing\n");
395                } else {
396                        printf ("- no sectors to erase\n");
397                }
398                return 1;
399        }
400
401        if (info->flash_id == FLASH_UNKNOWN) {
402                printf ("Can't erase unknown flash type - aborted\n");
403                return 1;
404        }
405
406        prot = 0;
407        for (sect=s_first; sect<=s_last; ++sect) {
408                if (info->protect[sect]) {
409                        prot++;
410                }
411        }
412
413        if (prot) {
414                printf ("- Warning: %d protected sectors will not be erased!\n",
415                        prot);
416        } else {
417                printf ("\n");
418        }
419
420        l_sect = -1;
421
422        /* Disable interrupts which might cause a timeout here */
423        flag = disable_interrupts();
424
425        /* Start erase on unprotected sectors */
426        for (sect = s_first; sect<=s_last; sect++) {
427                if (info->protect[sect] == 0) { /* not protected */
428                        addr2 = (FLASH_WORD_SIZE *)(info->start[sect]);
429                        printf("Erasing sector %p\n", addr2);
430
431                        if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) {
432                                addr[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
433                                addr[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
434                                addr[ADDR0] = (FLASH_WORD_SIZE)0x00800080;
435                                addr[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
436                                addr[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
437                                addr2[0] = (FLASH_WORD_SIZE)0x00500050;  /* block erase */
438                                for (i=0; i<50; i++)
439                                        udelay(1000);  /* wait 1 ms */
440                        } else {
441                                addr[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
442                                addr[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
443                                addr[ADDR0] = (FLASH_WORD_SIZE)0x00800080;
444                                addr[ADDR0] = (FLASH_WORD_SIZE)0x00AA00AA;
445                                addr[ADDR1] = (FLASH_WORD_SIZE)0x00550055;
446                                addr2[0] = (FLASH_WORD_SIZE)0x00300030;  /* sector erase */
447                        }
448                        l_sect = sect;
449                        /*
450                         * Wait for each sector to complete, it's more
451                         * reliable.  According to AMD Spec, you must
452                         * issue all erase commands within a specified
453                         * timeout.  This has been seen to fail, especially
454                         * if printf()s are included (for debug)!!
455                         */
456                        wait_for_DQ7(info, sect);
457                }
458        }
459
460        /* re-enable interrupts if necessary */
461        if (flag)
462                enable_interrupts();
463
464        /* wait at least 80us - let's wait 1 ms */
465        udelay (1000);
466
467#if 0
468        /*
469         * We wait for the last triggered sector
470         */
471        if (l_sect < 0)
472                goto DONE;
473        wait_for_DQ7(info, l_sect);
474
475DONE:
476#endif
477        /* reset to read mode */
478        addr = (FLASH_WORD_SIZE *)info->start[0];
479        addr[0] = (FLASH_WORD_SIZE)0x00F000F0;  /* reset bank */
480
481        printf (" done\n");
482        return 0;
483}
484
485/*-----------------------------------------------------------------------
486 * Copy memory to flash, returns:
487 * 0 - OK
488 * 1 - write timeout
489 * 2 - Flash not erased
490 */
491
492int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
493{
494        ulong cp, wp, data;
495        int i, l, rc;
496
497        wp = (addr & ~3);       /* get lower word aligned address */
498
499        /*
500         * handle unaligned start bytes
501         */
502        if ((l = addr - wp) != 0) {
503                data = 0;
504                for (i=0, cp=wp; i<l; ++i, ++cp) {
505                        data = (data << 8) | (*(uchar *)cp);
506                }
507                for (; i<4 && cnt>0; ++i) {
508                        data = (data << 8) | *src++;
509                        --cnt;
510                        ++cp;
511                }
512                for (; cnt==0 && i<4; ++i, ++cp) {
513                        data = (data << 8) | (*(uchar *)cp);
514                }
515
516                if ((rc = write_word(info, wp, data)) != 0) {
517                        return (rc);
518                }
519                wp += 4;
520        }
521
522        /*
523         * handle word aligned part
524         */
525        while (cnt >= 4) {
526                data = 0;
527                for (i=0; i<4; ++i) {
528                        data = (data << 8) | *src++;
529                }
530                if ((rc = write_word(info, wp, data)) != 0) {
531                        return (rc);
532                }
533                wp  += 4;
534                cnt -= 4;
535        }
536
537        if (cnt == 0) {
538                return (0);
539        }
540
541        /*
542         * handle unaligned tail bytes
543         */
544        data = 0;
545        for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) {
546                data = (data << 8) | *src++;
547                --cnt;
548        }
549        for (; i<4; ++i, ++cp) {
550                data = (data << 8) | (*(uchar *)cp);
551        }
552
553        return (write_word(info, wp, data));
554}
555
556/*-----------------------------------------------------------------------
557 * Write a word to Flash, returns:
558 * 0 - OK
559 * 1 - write timeout
560 * 2 - Flash not erased
561 */
562static int write_word (flash_info_t * info, ulong dest, ulong data)
563{
564        volatile FLASH_WORD_SIZE *addr2 = (FLASH_WORD_SIZE *) (info->start[0]);
565        volatile FLASH_WORD_SIZE *dest2 = (FLASH_WORD_SIZE *) dest;
566        volatile FLASH_WORD_SIZE *data2 = (FLASH_WORD_SIZE *) & data;
567        ulong start;
568        int i;
569
570        /* Check if Flash is (sufficiently) erased */
571        if ((*((volatile FLASH_WORD_SIZE *) dest) &
572             (FLASH_WORD_SIZE) data) != (FLASH_WORD_SIZE) data) {
573                return (2);
574        }
575
576        for (i = 0; i < 4 / sizeof (FLASH_WORD_SIZE); i++) {
577                int flag;
578
579                /* Disable interrupts which might cause a timeout here */
580                flag = disable_interrupts ();
581
582                addr2[ADDR0] = (FLASH_WORD_SIZE) 0x00AA00AA;
583                addr2[ADDR1] = (FLASH_WORD_SIZE) 0x00550055;
584                addr2[ADDR0] = (FLASH_WORD_SIZE) 0x00A000A0;
585
586                dest2[i] = data2[i];
587
588                /* re-enable interrupts if necessary */
589                if (flag)
590                        enable_interrupts ();
591
592                /* data polling for D7 */
593                start = get_timer (0);
594                while ((dest2[i] & (FLASH_WORD_SIZE) 0x00800080) !=
595                       (data2[i] & (FLASH_WORD_SIZE) 0x00800080)) {
596
597                        if (get_timer (start) > CFG_FLASH_WRITE_TOUT) {
598                                return (1);
599                        }
600                }
601        }
602
603        return (0);
604}
605
606/*-----------------------------------------------------------------------
607 */
Note: See TracBrowser for help on using the repository browser.