LXR uboot/board/prodrive/common/flash.c

   1/*
   2 * (C) Copyright 2006
   3 * Stefan Roese, DENX Software Engineering, sr@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#include <common.h>
  25#include <asm/processor.h>
  26
  27flash_info_t    flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips */
  28
  29/*
  30 * Functions
  31 */
  32static int write_word(flash_info_t *info, ulong dest, ulong data);
  33
  34void flash_print_info(flash_info_t *info)
  35{
  36        int i;
  37        int k;
  38        int size;
  39        int erased;
  40        volatile unsigned long *flash;
  41
  42        if (info->flash_id == FLASH_UNKNOWN) {
  43                printf ("missing or unknown FLASH type\n");
  44                return;
  45        }
  46
  47        switch (info->flash_id & FLASH_VENDMASK) {
  48        case FLASH_MAN_AMD:     printf ("AMD ");                break;
  49        case FLASH_MAN_FUJ:     printf ("FUJITSU ");            break;
  50        case FLASH_MAN_SST:     printf ("SST ");                break;
  51        case FLASH_MAN_STM:     printf ("ST ");                 break;
  52        case FLASH_MAN_EXCEL:   printf ("Excel Semiconductor "); break;
  53        default:                printf ("Unknown Vendor ");     break;
  54        }
  55
  56        switch (info->flash_id & FLASH_TYPEMASK) {
  57        case FLASH_AM400B:      printf ("AM29LV400B (4 Mbit, bottom boot sect)\n");
  58                break;
  59        case FLASH_AM400T:      printf ("AM29LV400T (4 Mbit, top boot sector)\n");
  60                break;
  61        case FLASH_AM800B:      printf ("AM29LV800B (8 Mbit, bottom boot sect)\n");
  62                break;
  63        case FLASH_AM800T:      printf ("AM29LV800T (8 Mbit, top boot sector)\n");
  64                break;
  65        case FLASH_AM160B:      printf ("AM29LV160B (16 Mbit, bottom boot sect)\n");
  66                break;
  67        case FLASH_AM160T:      printf ("AM29LV160T (16 Mbit, top boot sector)\n");
  68                break;
  69        case FLASH_AM320T:      printf ("AM29LV320T (32 M, top sector)\n");
  70                break;
  71        case FLASH_AM320B:      printf ("AM29LV320B (32 M, bottom sector)\n");
  72                break;
  73        case FLASH_AMDL322T:    printf ("AM29DL322T (32 M, top sector)\n");
  74                break;
  75        case FLASH_AMDL322B:    printf ("AM29DL322B (32 M, bottom sector)\n");
  76                break;
  77        case FLASH_AMDL323T:    printf ("AM29DL323T (32 M, top sector)\n");
  78                break;
  79        case FLASH_AMDL323B:    printf ("AM29DL323B (32 M, bottom sector)\n");
  80                break;
  81        case FLASH_SST020:      printf ("SST39LF/VF020 (2 Mbit, uniform sector size)\n");
  82                break;
  83        case FLASH_SST040:      printf ("SST39LF/VF040 (4 Mbit, uniform sector size)\n");
  84                break;
  85        default:                printf ("Unknown Chip Type\n");
  86                break;
  87        }
  88
  89        printf ("  Size: %ld MB in %d Sectors\n",
  90                info->size >> 20, info->sector_count);
  91
  92        printf ("  Sector Start Addresses:");
  93        for (i=0; i<info->sector_count; ++i) {
  94#ifdef CONFIG_SYS_FLASH_EMPTY_INFO
  95                /*
  96                 * Check if whole sector is erased
  97                 */
  98                if (i != (info->sector_count-1))
  99                        size = info->start[i+1] - info->start[i];
 100                else
 101                        size = info->start[0] + info->size - info->start[i];
 102                erased = 1;
 103                flash = (volatile unsigned long *)info->start[i];
 104                size = size >> 2;        /* divide by 4 for longword access */
 105                for (k=0; k<size; k++) {
 106                        if (*flash++ != 0xffffffff) {
 107                                erased = 0;
 108                                break;
 109                        }
 110                }
 111
 112                if ((i % 5) == 0)
 113                        printf ("\n   ");
 114                /* print empty and read-only info */
 115                printf (" %08lX%s%s",
 116                        info->start[i],
 117                        erased ? " E" : "  ",
 118                        info->protect[i] ? "RO " : "   ");
 119#else
 120                if ((i % 5) == 0)
 121                        printf ("\n   ");
 122                printf (" %08lX%s",
 123                        info->start[i],
 124                        info->protect[i] ? " (RO)" : "     ");
 125#endif
 126
 127        }
 128        printf ("\n");
 129        return;
 130}
 131
 132/*
 133 * The following code cannot be run from FLASH!
 134 */
 135static ulong flash_get_size(vu_long *addr, flash_info_t *info)
 136{
 137        short i;
 138        short n;
 139        CONFIG_SYS_FLASH_WORD_SIZE value;
 140        ulong base = (ulong)addr;
 141        volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *)addr;
 142
 143        /* Write auto select command: read Manufacturer ID */
 144        addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
 145        addr2[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
 146        addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00900090;
 147
 148        value = addr2[CONFIG_SYS_FLASH_READ0];
 149
 150        switch (value) {
 151        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_MANUFACT:
 152                info->flash_id = FLASH_MAN_AMD;
 153                break;
 154        case (CONFIG_SYS_FLASH_WORD_SIZE)FUJ_MANUFACT:
 155                info->flash_id = FLASH_MAN_FUJ;
 156                break;
 157        case (CONFIG_SYS_FLASH_WORD_SIZE)SST_MANUFACT:
 158                info->flash_id = FLASH_MAN_SST;
 159                break;
 160        case (CONFIG_SYS_FLASH_WORD_SIZE)STM_MANUFACT:
 161                info->flash_id = FLASH_MAN_STM;
 162                break;
 163        case (CONFIG_SYS_FLASH_WORD_SIZE)EXCEL_MANUFACT:
 164                info->flash_id = FLASH_MAN_EXCEL;
 165                break;
 166        default:
 167                info->flash_id = FLASH_UNKNOWN;
 168                info->sector_count = 0;
 169                info->size = 0;
 170                return (0);                     /* no or unknown flash  */
 171        }
 172
 173        value = addr2[CONFIG_SYS_FLASH_READ1];          /* device ID            */
 174
 175        switch (value) {
 176        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV400T:
 177                info->flash_id += FLASH_AM400T;
 178                info->sector_count = 11;
 179                info->size = 0x00080000;
 180                break;                          /* => 0.5 MB            */
 181
 182        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV400B:
 183                info->flash_id += FLASH_AM400B;
 184                info->sector_count = 11;
 185                info->size = 0x00080000;
 186                break;                          /* => 0.5 MB            */
 187
 188        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV800T:
 189                info->flash_id += FLASH_AM800T;
 190                info->sector_count = 19;
 191                info->size = 0x00100000;
 192                break;                          /* => 1 MB              */
 193
 194        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV800B:
 195                info->flash_id += FLASH_AM800B;
 196                info->sector_count = 19;
 197                info->size = 0x00100000;
 198                break;                          /* => 1 MB              */
 199
 200        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV160T:
 201                info->flash_id += FLASH_AM160T;
 202                info->sector_count = 35;
 203                info->size = 0x00200000;
 204                break;                          /* => 2 MB              */
 205
 206        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV160B:
 207                info->flash_id += FLASH_AM160B;
 208                info->sector_count = 35;
 209                info->size = 0x00200000;
 210                break;                          /* => 2 MB              */
 211
 212        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV320T:
 213                info->flash_id += FLASH_AM320T;
 214                info->sector_count = 71;
 215                info->size = 0x00400000;  break;        /* => 4 MB      */
 216
 217        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV320B:
 218                info->flash_id += FLASH_AM320B;
 219                info->sector_count = 71;
 220                info->size = 0x00400000;  break;        /* => 4 MB      */
 221
 222        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_DL322T:
 223                info->flash_id += FLASH_AMDL322T;
 224                info->sector_count = 71;
 225                info->size = 0x00400000;  break;        /* => 4 MB      */
 226
 227        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_DL322B:
 228                info->flash_id += FLASH_AMDL322B;
 229                info->sector_count = 71;
 230                info->size = 0x00400000;  break;        /* => 4 MB      */
 231
 232        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_DL323T:
 233                info->flash_id += FLASH_AMDL323T;
 234                info->sector_count = 71;
 235                info->size = 0x00400000;  break;        /* => 4 MB      */
 236
 237        case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_DL323B:
 238                info->flash_id += FLASH_AMDL323B;
 239                info->sector_count = 71;
 240                info->size = 0x00400000;  break;        /* => 4 MB      */
 241
 242        case (CONFIG_SYS_FLASH_WORD_SIZE)SST_ID_xF020:
 243                info->flash_id += FLASH_SST020;
 244                info->sector_count = 64;
 245                info->size = 0x00040000;
 246                break;                          /* => 256 kB            */
 247
 248        case (CONFIG_SYS_FLASH_WORD_SIZE)SST_ID_xF040:
 249                info->flash_id += FLASH_SST040;
 250                info->sector_count = 128;
 251                info->size = 0x00080000;
 252                break;                          /* => 512 kB            */
 253
 254        default:
 255                info->flash_id = FLASH_UNKNOWN;
 256                return (0);                     /* => no or unknown flash */
 257
 258        }
 259
 260        /* set up sector start address table */
 261        if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) {
 262                for (i = 0; i < info->sector_count; i++)
 263                        info->start[i] = base + (i * 0x00001000);
 264        } else if (((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL322B) ||
 265                   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL323B) ||
 266                   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320B) ||
 267                   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL324B)) {
 268                /* set sector offsets for bottom boot block type        */
 269                for (i=0; i<8; ++i) {           /*  8 x 8k boot sectors */
 270                        info->start[i] = base;
 271                        base += 8 << 10;
 272                }
 273                while (i < info->sector_count) {        /* 64k regular sectors  */
 274                        info->start[i] = base;
 275                        base += 64 << 10;
 276                        ++i;
 277                }
 278        } else if (((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL322T) ||
 279                   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL323T) ||
 280                   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320T) ||
 281                   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL324T)) {
 282                /* set sector offsets for top boot block type           */
 283                base += info->size;
 284                i = info->sector_count;
 285                for (n=0; n<8; ++n) {           /*  8 x 8k boot sectors */
 286                        base -= 8 << 10;
 287                        --i;
 288                        info->start[i] = base;
 289                }
 290                while (i > 0) {                 /* 64k regular sectors  */
 291                        base -= 64 << 10;
 292                        --i;
 293                        info->start[i] = base;
 294                }
 295        } else {
 296                if (info->flash_id & FLASH_BTYPE) {
 297                        /* set sector offsets for bottom boot block type        */
 298                        info->start[0] = base + 0x00000000;
 299                        info->start[1] = base + 0x00004000;
 300                        info->start[2] = base + 0x00006000;
 301                        info->start[3] = base + 0x00008000;
 302                        for (i = 4; i < info->sector_count; i++) {
 303                                info->start[i] = base + (i * 0x00010000) - 0x00030000;
 304                        }
 305                } else {
 306                        /* set sector offsets for top boot block type           */
 307                        i = info->sector_count - 1;
 308                        info->start[i--] = base + info->size - 0x00004000;
 309                        info->start[i--] = base + info->size - 0x00006000;
 310                        info->start[i--] = base + info->size - 0x00008000;
 311                        for (; i >= 0; i--) {
 312                                info->start[i] = base + i * 0x00010000;
 313                        }
 314                }
 315        }
 316
 317        /* check for protected sectors */
 318        for (i = 0; i < info->sector_count; i++) {
 319                /* read sector protection at sector address, (A7 .. A0) = 0x02 */
 320                /* D0 = 1 if protected */
 321                addr2 = (volatile CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[i]);
 322                if ((info->flash_id & FLASH_VENDMASK) != FLASH_MAN_AMD)
 323                        info->protect[i] = 0;
 324                else
 325                        info->protect[i] = addr2[CONFIG_SYS_FLASH_READ2] & 1;
 326        }
 327
 328        /*
 329         * Prevent writes to uninitialized FLASH.
 330         */
 331        if (info->flash_id != FLASH_UNKNOWN) {
 332                addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *)info->start[0];
 333                *addr2 = (CONFIG_SYS_FLASH_WORD_SIZE)0x00F000F0;        /* reset bank */
 334        }
 335
 336        return (info->size);
 337}
 338
 339
 340int flash_erase(flash_info_t *info, int s_first, int s_last)
 341{
 342        volatile CONFIG_SYS_FLASH_WORD_SIZE *addr = (CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[0]);
 343        volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2;
 344        int flag, prot, sect, l_sect;
 345        ulong start, now, last;
 346
 347        if ((s_first < 0) || (s_first > s_last)) {
 348                if (info->flash_id == FLASH_UNKNOWN)
 349                        printf ("- missing\n");
 350                else
 351                        printf ("- no sectors to erase\n");
 352                return 1;
 353        }
 354
 355        if (info->flash_id == FLASH_UNKNOWN) {
 356                printf ("Can't erase unknown flash type - aborted\n");
 357                return 1;
 358        }
 359
 360        prot = 0;
 361        for (sect=s_first; sect<=s_last; ++sect)
 362                if (info->protect[sect])
 363                        prot++;
 364
 365        if (prot)
 366                printf ("- Warning: %d protected sectors will not be erased!\n", prot);
 367        else
 368                printf ("\n");
 369
 370        l_sect = -1;
 371
 372        /* Disable interrupts which might cause a timeout here */
 373        flag = disable_interrupts();
 374
 375        /* Start erase on unprotected sectors */
 376        for (sect = s_first; sect<=s_last; sect++) {
 377                if (info->protect[sect] == 0) { /* not protected */
 378                        addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[sect]);
 379                        if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) {
 380                                addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
 381                                addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
 382                                addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080;
 383                                addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
 384                                addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
 385                                addr2[0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00300030;  /* sector erase */
 386
 387                                /* re-enable interrupts if necessary */
 388                                if (flag) {
 389                                        enable_interrupts();
 390                                        flag = 0;
 391                                }
 392
 393                                /* data polling for D7 */
 394                                start = get_timer (0);
 395                                while ((addr2[0] & (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) !=
 396                                       (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) {
 397                                        if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT)
 398                                                return (1);
 399                                }
 400                        } else {
 401                                if (sect == s_first) {
 402                                        addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
 403                                        addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
 404                                        addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080;
 405                                        addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
 406                                        addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
 407                                }
 408                                addr2[0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00300030;  /* sector erase */
 409                        }
 410                        l_sect = sect;
 411                }
 412        }
 413
 414        /* re-enable interrupts if necessary */
 415        if (flag)
 416                enable_interrupts();
 417
 418        /* wait at least 80us - let's wait 1 ms */
 419        udelay (1000);
 420
 421        /*
 422         * We wait for the last triggered sector
 423         */
 424        if (l_sect < 0)
 425                goto DONE;
 426
 427        start = get_timer (0);
 428        last  = start;
 429        addr = (CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[l_sect]);
 430        while ((addr[0] & (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) != (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) {
 431                if ((now = get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
 432                        printf ("Timeout\n");
 433                        return 1;
 434                }
 435                /* show that we're waiting */
 436                if ((now - last) > 1000) {      /* every second */
 437                        putc ('.');
 438                        last = now;
 439                }
 440        }
 441
 442DONE:
 443        /* reset to read mode */
 444        addr = (CONFIG_SYS_FLASH_WORD_SIZE *)info->start[0];
 445        addr[0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00F000F0;       /* reset bank */
 446
 447        printf (" done\n");
 448        return 0;
 449}
 450
 451/*
 452 * Copy memory to flash, returns:
 453 * 0 - OK
 454 * 1 - write timeout
 455 * 2 - Flash not erased
 456 */
 457int write_buff(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
 458{
 459        ulong cp, wp, data;
 460        int i, l, rc;
 461
 462        wp = (addr & ~3);       /* get lower word aligned address */
 463
 464        /*
 465         * handle unaligned start bytes
 466         */
 467        if ((l = addr - wp) != 0) {
 468                data = 0;
 469                for (i=0, cp=wp; i<l; ++i, ++cp) {
 470                        data = (data << 8) | (*(uchar *)cp);
 471                }
 472                for (; i<4 && cnt>0; ++i) {
 473                        data = (data << 8) | *src++;
 474                        --cnt;
 475                        ++cp;
 476                }
 477                for (; cnt==0 && i<4; ++i, ++cp) {
 478                        data = (data << 8) | (*(uchar *)cp);
 479                }
 480
 481                if ((rc = write_word(info, wp, data)) != 0) {
 482                        return (rc);
 483                }
 484                wp += 4;
 485        }
 486
 487        /*
 488         * handle word aligned part
 489         */
 490        while (cnt >= 4) {
 491                data = 0;
 492                for (i=0; i<4; ++i)
 493                        data = (data << 8) | *src++;
 494                if ((rc = write_word(info, wp, data)) != 0)
 495                        return (rc);
 496                wp  += 4;
 497                cnt -= 4;
 498        }
 499
 500        if (cnt == 0)
 501                return (0);
 502
 503        /*
 504         * handle unaligned tail bytes
 505         */
 506        data = 0;
 507        for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) {
 508                data = (data << 8) | *src++;
 509                --cnt;
 510        }
 511        for (; i<4; ++i, ++cp)
 512                data = (data << 8) | (*(uchar *)cp);
 513
 514        return (write_word(info, wp, data));
 515}
 516
 517/*
 518 * Write a word to Flash, returns:
 519 * 0 - OK
 520 * 1 - write timeout
 521 * 2 - Flash not erased
 522 */
 523static int write_word(flash_info_t *info, ulong dest, ulong data)
 524{
 525        volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[0]);
 526        volatile CONFIG_SYS_FLASH_WORD_SIZE *dest2 = (CONFIG_SYS_FLASH_WORD_SIZE *)dest;
 527        volatile CONFIG_SYS_FLASH_WORD_SIZE *data2 = (CONFIG_SYS_FLASH_WORD_SIZE *)&data;
 528        ulong start;
 529        int flag;
 530        int i;
 531
 532        /* Check if Flash is (sufficiently) erased */
 533        if ((*((vu_long *)dest) & data) != data)
 534                return (2);
 535
 536        /* Disable interrupts which might cause a timeout here */
 537        flag = disable_interrupts();
 538
 539        for (i=0; i<4/sizeof(CONFIG_SYS_FLASH_WORD_SIZE); i++) {
 540                addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
 541                addr2[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
 542                addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00A000A0;
 543
 544                dest2[i] = data2[i];
 545
 546                /* re-enable interrupts if necessary */
 547                if (flag)
 548                        enable_interrupts();
 549
 550                /* data polling for D7 */
 551                start = get_timer (0);
 552                while ((dest2[i] & (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) !=
 553                       (data2[i] & (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080)) {
 554                        if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT)
 555                                return (1);
 556                }
 557        }
 558
 559        return (0);
 560}
 561