* Code cleanup:

  - remove trailing white space, trailing empty lines, C++ comments, etc.
  - split cmd_boot.c (separate cmd_bdinfo.c and cmd_load.c)

* Patches by Kenneth Johansson, 25 Jun 2003:
  - major rework of command structure
    (work done mostly by Michal Cendrowski and Joakim Kristiansen)

1 files changed, 423 insertions, 424 deletions

diff --git a/board/w7o/flash.c b/board/w7o/flash.c
index 5651e1c..d6ea635 100644
--- a/board/w7o/flash.c
+++ b/board/w7o/flash.c
@@ -50,21 +50,21 @@ unsigned long flash_init (void)
 
     /* Init: no FLASHes known */
     for (i = 0; i < CFG_MAX_FLASH_BANKS; ++i) {
-        flash_info[i].flash_id = FLASH_UNKNOWN;
+	flash_info[i].flash_id = FLASH_UNKNOWN;
     }
 
     /* Get Size of Boot and Main Flashes */
     size_b0 = flash_get_size((vu_long *)FLASH_BASE0_PRELIM, &flash_info[0]);
     if (flash_info[0].flash_id == FLASH_UNKNOWN) {
-        printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
-            size_b0, size_b0<<20);
-        return 0;
+	printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
+	    size_b0, size_b0<<20);
+	return 0;
     }
     size_b1 = flash_get_size((vu_long *)FLASH_BASE1_PRELIM, &flash_info[1]);
     if (flash_info[1].flash_id == FLASH_UNKNOWN) {
-        printf ("## Unknown FLASH on Bank 1 - Size = 0x%08lx = %ld MB\n",
-            size_b1, size_b1<<20);
-        return 0;
+	printf ("## Unknown FLASH on Bank 1 - Size = 0x%08lx = %ld MB\n",
+	    size_b1, size_b1<<20);
+	return 0;
     }
 
     /* Calculate base addresses */
@@ -83,21 +83,21 @@ unsigned long flash_init (void)
 
     /* Monitor protection ON by default */
     (void)flash_protect(FLAG_PROTECT_SET,
-                        base_b0 + size_b0 - monitor_flash_len,
-                        base_b0 + size_b0 - 1,
-                        &flash_info[0]);
+			base_b0 + size_b0 - monitor_flash_len,
+			base_b0 + size_b0 - 1,
+			&flash_info[0]);
 
     /* Protect the FPGA image */
     (void)flash_protect(FLAG_PROTECT_SET,
-                        FLASH_BASE1_PRELIM,
-                        FLASH_BASE1_PRELIM + CFG_FPGA_IMAGE_LEN - 1,
-                        &flash_info[1]);
+			FLASH_BASE1_PRELIM,
+			FLASH_BASE1_PRELIM + CFG_FPGA_IMAGE_LEN - 1,
+			&flash_info[1]);
 
     /* Protect the default boot image */
     (void)flash_protect(FLAG_PROTECT_SET,
-                        FLASH_BASE1_PRELIM + CFG_FPGA_IMAGE_LEN,
-                        FLASH_BASE1_PRELIM + CFG_FPGA_IMAGE_LEN + 0x600000 - 1,
-                        &flash_info[1]);
+			FLASH_BASE1_PRELIM + CFG_FPGA_IMAGE_LEN,
+			FLASH_BASE1_PRELIM + CFG_FPGA_IMAGE_LEN + 0x600000 - 1,
+			&flash_info[1]);
 
     /* Setup offsets for Main Flash */
     flash_get_offsets (FLASH_BASE1_PRELIM, &flash_info[1]);
@@ -113,8 +113,8 @@ static void flash_get_offsets (ulong base, flash_info_t *info)
 
     /* set up sector start address table - FOR BOOT ROM ONLY!!! */
     if ((info->flash_id & FLASH_TYPEMASK)  == FLASH_AM040) {
-        for (i = 0; i < info->sector_count; i++)
-            info->start[i] = base + (i * 0x00010000);
+	for (i = 0; i < info->sector_count; i++)
+	    info->start[i] = base + (i * 0x00010000);
     }
 } /* end flash_get_offsets() */
 
@@ -129,75 +129,75 @@ void flash_print_info  (flash_info_t *info)
     volatile unsigned long *flash;
 
     if (info->flash_id == FLASH_UNKNOWN) {
-        printf ("missing or unknown FLASH type\n");
-        return;
+	printf ("missing or unknown FLASH type\n");
+	return;
     }
 
     switch (info->flash_id & FLASH_VENDMASK) {
-        case FLASH_MAN_AMD:     printf ("1 x AMD ");    break;
+	case FLASH_MAN_AMD:     printf ("1 x AMD ");    break;
 	case FLASH_MAN_STM:	printf ("1 x STM ");	break;
-        case FLASH_MAN_INTEL:   printf ("2 x Intel ");  break;
-        default:                printf ("Unknown Vendor ");
+	case FLASH_MAN_INTEL:   printf ("2 x Intel ");  break;
+	default:                printf ("Unknown Vendor ");
     }
 
     switch (info->flash_id & FLASH_TYPEMASK) {
-        case FLASH_AM040:
+	case FLASH_AM040:
 	    if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_AMD)
-            	printf ("AM29LV040 (4096 Kbit, uniform sector size)\n");
+		printf ("AM29LV040 (4096 Kbit, uniform sector size)\n");
 	    else if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_STM)
-            	printf ("M29W040B (4096 Kbit, uniform block size)\n");
+		printf ("M29W040B (4096 Kbit, uniform block size)\n");
 	    else
-            	printf ("UNKNOWN 29x040x (4096 Kbit, uniform sector size)\n");
-            break;
-        case FLASH_28F320J3A:
-            printf ("28F320J3A (32 Mbit = 128K x 32)\n");
-            break;
-        case FLASH_28F640J3A:
-            printf ("28F640J3A (64 Mbit = 128K x 64)\n");
-            break;
-        case FLASH_28F128J3A:
-            printf ("28F128J3A (128 Mbit = 128K x 128)\n");
-            break;
-        default:
-            printf ("Unknown Chip Type\n");
+		printf ("UNKNOWN 29x040x (4096 Kbit, uniform sector size)\n");
+	    break;
+	case FLASH_28F320J3A:
+	    printf ("28F320J3A (32 Mbit = 128K x 32)\n");
+	    break;
+	case FLASH_28F640J3A:
+	    printf ("28F640J3A (64 Mbit = 128K x 64)\n");
+	    break;
+	case FLASH_28F128J3A:
+	    printf ("28F128J3A (128 Mbit = 128K x 128)\n");
+	    break;
+	default:
+	    printf ("Unknown Chip Type\n");
     }
 
     if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_STM) {
-    	printf ("  Size: %ld KB in %d Blocks\n",
-        	info->size >> 10, info->sector_count);
+	printf ("  Size: %ld KB in %d Blocks\n",
+		info->size >> 10, info->sector_count);
     } else {
-    	printf ("  Size: %ld KB in %d Sectors\n",
-        	info->size >> 10, info->sector_count);
+	printf ("  Size: %ld KB in %d Sectors\n",
+		info->size >> 10, info->sector_count);
     }
 
     printf ("  Sector Start Addresses:");
     for (i=0; i<info->sector_count; ++i) {
-        /*
-         * Check if whole sector is erased
-         */
-        if (i != (info->sector_count-1))
-            size = info->start[i+1] - info->start[i];
-        else
-            size = info->start[0] + info->size - info->start[i];
-        erased = 1;
-        flash = (volatile unsigned long *)info->start[i];
-        size = size >> 2;        /* divide by 4 for longword access */
-        for (k=0; k<size; k++)
-        {
-            if (*flash++ != 0xffffffff)
-            {
-                erased = 0;
-                break;
-            }
-        }
-
-        if ((i % 5) == 0)
-            printf ("\n   ");
-        printf (" %08lX%s%s",
-            info->start[i],
-            erased ? " E" : "  ",
-            info->protect[i] ? "RO " : "   "
-        );
+	/*
+	 * Check if whole sector is erased
+	 */
+	if (i != (info->sector_count-1))
+	    size = info->start[i+1] - info->start[i];
+	else
+	    size = info->start[0] + info->size - info->start[i];
+	erased = 1;
+	flash = (volatile unsigned long *)info->start[i];
+	size = size >> 2;        /* divide by 4 for longword access */
+	for (k=0; k<size; k++)
+	{
+	    if (*flash++ != 0xffffffff)
+	    {
+		erased = 0;
+		break;
+	    }
+	}
+
+	if ((i % 5) == 0)
+	    printf ("\n   ");
+	printf (" %08lX%s%s",
+	    info->start[i],
+	    erased ? " E" : "  ",
+	    info->protect[i] ? "RO " : "   "
+	);
     }
     printf ("\n");
 } /* end flash_print_info() */
@@ -217,130 +217,130 @@ static ulong flash_get_size (vu_long *addr, flash_info_t *info)
 
     /* Test for Boot Flash */
     if (base == FLASH_BASE0_PRELIM) {
-        unsigned char value;
-        volatile unsigned char * addr2 = (unsigned char *)addr;
-
-        /* Write auto select command: read Manufacturer ID */
-        *(addr2 + 0x555) = 0xaa;
-        *(addr2 + 0x2aa) = 0x55;
-        *(addr2 + 0x555) = 0x90;
-
-        /* Manufacture ID */
-        value = *addr2;
-        switch (value) {
-            case (unsigned char)AMD_MANUFACT:
-                info->flash_id = FLASH_MAN_AMD;
-                break;
+	unsigned char value;
+	volatile unsigned char * addr2 = (unsigned char *)addr;
+
+	/* Write auto select command: read Manufacturer ID */
+	*(addr2 + 0x555) = 0xaa;
+	*(addr2 + 0x2aa) = 0x55;
+	*(addr2 + 0x555) = 0x90;
+
+	/* Manufacture ID */
+	value = *addr2;
+	switch (value) {
+	    case (unsigned char)AMD_MANUFACT:
+		info->flash_id = FLASH_MAN_AMD;
+		break;
 	    case (unsigned char)STM_MANUFACT:
 		info->flash_id = FLASH_MAN_STM;
 		break;
-            default:
-                *addr2 = 0xf0;              /* no or unknown flash  */
-                return 0;
-        }
-
-        /* Device ID */
-        value = *(addr2 + 1);
-        switch (value) {
-            case (unsigned char)AMD_ID_LV040B:
+	    default:
+		*addr2 = 0xf0;              /* no or unknown flash  */
+		return 0;
+	}
+
+	/* Device ID */
+	value = *(addr2 + 1);
+	switch (value) {
+	    case (unsigned char)AMD_ID_LV040B:
 	    case (unsigned char)STM_ID_29W040B:
-                info->flash_id += FLASH_AM040;
-                info->sector_count = 8;
-                info->size = 0x00080000;
-                break;                       /* => 512Kb */
-            default:
-                *addr2 = 0xf0;               /* => no or unknown flash */
-                return 0;
-        }
+		info->flash_id += FLASH_AM040;
+		info->sector_count = 8;
+		info->size = 0x00080000;
+		break;                       /* => 512Kb */
+	    default:
+		*addr2 = 0xf0;               /* => no or unknown flash */
+		return 0;
+	}
     }
     else { /* MAIN Flash */
-        unsigned long value;
-        volatile unsigned long * addr2 = (unsigned long *)addr;
-
-        /* Write auto select command: read Manufacturer ID */
-        *addr2 = 0x90909090;
-
-        /* Manufacture ID */
-        value = *addr2;
-        switch (value) {
-            case (unsigned long)INTEL_MANUFACT:
-                info->flash_id = FLASH_MAN_INTEL;
-                break;
-            default:
-                *addr2 = 0xff;              /* no or unknown flash  */
-                return 0;
-        }
-
-        /* Device ID - This shit is interleaved... */
-        value = *(addr2 + 1);
-        switch (value) {
-            case (unsigned long)INTEL_ID_28F320J3A:
-                info->flash_id += FLASH_28F320J3A;
-                info->sector_count = 32;
-                info->size = 0x00400000 * 2;
-                break;                       /* => 2 X 4 MB */
-            case (unsigned long)INTEL_ID_28F640J3A:
-                info->flash_id += FLASH_28F640J3A;
-                info->sector_count = 64;
-                info->size = 0x00800000 * 2;
-                break;                       /* => 2 X 8 MB */
-            case (unsigned long)INTEL_ID_28F128J3A:
-                info->flash_id += FLASH_28F128J3A;
-                info->sector_count = 128;
-                info->size = 0x01000000 * 2;
-                break;                       /* => 2 X 16 MB */
-            default:
-                *addr2 = 0xff;               /* => no or unknown flash */
-        }
+	unsigned long value;
+	volatile unsigned long * addr2 = (unsigned long *)addr;
+
+	/* Write auto select command: read Manufacturer ID */
+	*addr2 = 0x90909090;
+
+	/* Manufacture ID */
+	value = *addr2;
+	switch (value) {
+	    case (unsigned long)INTEL_MANUFACT:
+		info->flash_id = FLASH_MAN_INTEL;
+		break;
+	    default:
+		*addr2 = 0xff;              /* no or unknown flash  */
+		return 0;
+	}
+
+	/* Device ID - This shit is interleaved... */
+	value = *(addr2 + 1);
+	switch (value) {
+	    case (unsigned long)INTEL_ID_28F320J3A:
+		info->flash_id += FLASH_28F320J3A;
+		info->sector_count = 32;
+		info->size = 0x00400000 * 2;
+		break;                       /* => 2 X 4 MB */
+	    case (unsigned long)INTEL_ID_28F640J3A:
+		info->flash_id += FLASH_28F640J3A;
+		info->sector_count = 64;
+		info->size = 0x00800000 * 2;
+		break;                       /* => 2 X 8 MB */
+	    case (unsigned long)INTEL_ID_28F128J3A:
+		info->flash_id += FLASH_28F128J3A;
+		info->sector_count = 128;
+		info->size = 0x01000000 * 2;
+		break;                       /* => 2 X 16 MB */
+	    default:
+		*addr2 = 0xff;               /* => no or unknown flash */
+	}
     }
 
     /* Make sure we don't exceed CFG_MAX_FLASH_SECT */
     if (info->sector_count > CFG_MAX_FLASH_SECT) {
-        printf ("** ERROR: sector count %d > max (%d) **\n",
-                info->sector_count, CFG_MAX_FLASH_SECT);
-        info->sector_count = CFG_MAX_FLASH_SECT;
+	printf ("** ERROR: sector count %d > max (%d) **\n",
+		info->sector_count, CFG_MAX_FLASH_SECT);
+	info->sector_count = CFG_MAX_FLASH_SECT;
     }
 
     /* set up sector start address table */
     switch (info->flash_id & FLASH_TYPEMASK) {
-        case FLASH_AM040:
-            for (i = 0; i < info->sector_count; i++)
-                info->start[i] = base + (i * 0x00010000);
-            break;
-        case FLASH_28F320J3A:
-        case FLASH_28F640J3A:
-        case FLASH_28F128J3A:
-            for (i = 0; i < info->sector_count; i++)
-                info->start[i] = base + (i * 0x00020000 * 2); /* 2 Banks */
-            break;
+	case FLASH_AM040:
+	    for (i = 0; i < info->sector_count; i++)
+		info->start[i] = base + (i * 0x00010000);
+	    break;
+	case FLASH_28F320J3A:
+	case FLASH_28F640J3A:
+	case FLASH_28F128J3A:
+	    for (i = 0; i < info->sector_count; i++)
+		info->start[i] = base + (i * 0x00020000 * 2); /* 2 Banks */
+	    break;
     }
 
     /* Test for Boot Flash */
     if (base == FLASH_BASE0_PRELIM) {
-        volatile unsigned char *addr2;
-        /* check for protected sectors */
-        for (i = 0; i < info->sector_count; i++) {
-            /* read sector protection at sector address, (AX .. A0) = 0x02 */
-            /* D0 = 1 if protected */
-            addr2 = (volatile unsigned char *)(info->start[i]);
-            info->protect[i] = *(addr2 + 2) & 1;
-        }
-
-        /* Restore read mode */
-        *(unsigned char *)base = 0xF0;       /* Reset NORMAL Flash */
+	volatile unsigned char *addr2;
+	/* check for protected sectors */
+	for (i = 0; i < info->sector_count; i++) {
+	    /* read sector protection at sector address, (AX .. A0) = 0x02 */
+	    /* D0 = 1 if protected */
+	    addr2 = (volatile unsigned char *)(info->start[i]);
+	    info->protect[i] = *(addr2 + 2) & 1;
+	}
+
+	/* Restore read mode */
+	*(unsigned char *)base = 0xF0;       /* Reset NORMAL Flash */
     }
     else { /* Main Flash */
-        volatile unsigned long *addr2;
-        /* check for protected sectors */
-        for (i = 0; i < info->sector_count; i++) {
-            /* read sector protection at sector address, (AX .. A0) = 0x02 */
-            /* D0 = 1 if protected */
-            addr2 = (volatile unsigned long *)(info->start[i]);
-            info->protect[i] = *(addr2 + 2) & 0x1;
-        }
+	volatile unsigned long *addr2;
+	/* check for protected sectors */
+	for (i = 0; i < info->sector_count; i++) {
+	    /* read sector protection at sector address, (AX .. A0) = 0x02 */
+	    /* D0 = 1 if protected */
+	    addr2 = (volatile unsigned long *)(info->start[i]);
+	    info->protect[i] = *(addr2 + 2) & 0x1;
+	}
 
-        /* Restore read mode */
-        *(unsigned long *)base = 0xFFFFFFFF; /* Reset  Flash */
+	/* Restore read mode */
+	*(unsigned long *)base = 0xFFFFFFFF; /* Reset  Flash */
     }
 
     return (info->size);
@@ -357,20 +357,20 @@ static int wait_for_DQ7(ulong addr, uchar cmp_val, ulong tout)
 
     /* Loop X times */
     for (i = 1; i <= (100 * tout); i++) {    /* Wait up to tout ms */
-        udelay(10);
-        /* Pause 10 us */
+	udelay(10);
+	/* Pause 10 us */
 
-        /* Check for completion */
-        if ((vaddr[0] & 0x80) == (cmp_val & 0x80)) {
-            return 0;
-        }
+	/* Check for completion */
+	if ((vaddr[0] & 0x80) == (cmp_val & 0x80)) {
+	    return 0;
+	}
 
-        /* KEEP THE LUSER HAPPY - Print a dot every 1.1 seconds */
-        if (!(i % 110000))
-            putc('.');
+	/* KEEP THE LUSER HAPPY - Print a dot every 1.1 seconds */
+	if (!(i % 110000))
+	    putc('.');
 
-        /* Kick the dog if needed */
-        WATCHDOG_RESET();
+	/* Kick the dog if needed */
+	WATCHDOG_RESET();
     }
 
     return 1;
@@ -388,70 +388,70 @@ static int flash_erase8(flash_info_t *info, int s_first, int s_last)
 
     /* Validate arguments */
     if ((s_first < 0) || (s_first > s_last)) {
-        if (info->flash_id == FLASH_UNKNOWN)
-            printf ("- missing\n");
-        else
-            printf ("- no sectors to erase\n");
-        return 1;
+	if (info->flash_id == FLASH_UNKNOWN)
+	    printf ("- missing\n");
+	else
+	    printf ("- no sectors to erase\n");
+	return 1;
     }
 
     /* Check for KNOWN flash type */
     if (info->flash_id == FLASH_UNKNOWN) {
-        printf ("Can't erase unknown flash type - aborted\n");
-        return 1;
+	printf ("Can't erase unknown flash type - aborted\n");
+	return 1;
     }
 
     /* Check for protected sectors */
     prot = 0;
     for (sect = s_first; sect <= s_last; ++sect) {
-        if (info->protect[sect])
-            prot++;
+	if (info->protect[sect])
+	    prot++;
     }
     if (prot)
-        printf ("- Warning: %d protected sectors will not be erased!\n", prot);
+	printf ("- Warning: %d protected sectors will not be erased!\n", prot);
     else
-        printf ("\n");
+	printf ("\n");
 
     /* Start erase on unprotected sectors */
     for (sect = s_first; sect <= s_last; sect++) {
-        if (info->protect[sect] == 0) {      /* not protected */
-            sector_addr = (uchar *)(info->start[sect]);
+	if (info->protect[sect] == 0) {      /* not protected */
+	    sector_addr = (uchar *)(info->start[sect]);
 
-    		if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_STM)
+		if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_STM)
 		    printf("Erasing block %p\n", sector_addr);
 		else
 		    printf("Erasing sector %p\n", sector_addr);
 
-            /* Disable interrupts which might cause Flash to timeout */
-            flag = disable_interrupts();
-
-            *(addr + 0x555) = (uchar)0xAA;
-            *(addr + 0x2aa) = (uchar)0x55;
-            *(addr + 0x555) = (uchar)0x80;
-            *(addr + 0x555) = (uchar)0xAA;
-            *(addr + 0x2aa) = (uchar)0x55;
-            *sector_addr = (uchar)0x30;      /* sector erase */
-
-            /*
-             * Wait for each sector to complete, it's more
-             * reliable.  According to AMD Spec, you must
-             * issue all erase commands within a specified
-             * timeout.  This has been seen to fail, especially
-             * if printf()s are included (for debug)!!
-             * Takes up to 6 seconds.
-             */
-            tcode  = wait_for_DQ7((ulong)sector_addr, 0x80, 6000);
-
-            /* re-enable interrupts if necessary */
-            if (flag)
-                enable_interrupts();
-
-            /* Make sure we didn't timeout */
-            if (tcode) {
-                printf ("Timeout\n");
-                rcode = 1;
-            }
-        }
+	    /* Disable interrupts which might cause Flash to timeout */
+	    flag = disable_interrupts();
+
+	    *(addr + 0x555) = (uchar)0xAA;
+	    *(addr + 0x2aa) = (uchar)0x55;
+	    *(addr + 0x555) = (uchar)0x80;
+	    *(addr + 0x555) = (uchar)0xAA;
+	    *(addr + 0x2aa) = (uchar)0x55;
+	    *sector_addr = (uchar)0x30;      /* sector erase */
+
+	    /*
+	     * Wait for each sector to complete, it's more
+	     * reliable.  According to AMD Spec, you must
+	     * issue all erase commands within a specified
+	     * timeout.  This has been seen to fail, especially
+	     * if printf()s are included (for debug)!!
+	     * Takes up to 6 seconds.
+	     */
+	    tcode  = wait_for_DQ7((ulong)sector_addr, 0x80, 6000);
+
+	    /* re-enable interrupts if necessary */
+	    if (flag)
+		enable_interrupts();
+
+	    /* Make sure we didn't timeout */
+	    if (tcode) {
+		printf ("Timeout\n");
+		rcode = 1;
+	    }
+	}
     }
 
     /* wait at least 80us - let's wait 1 ms */
@@ -473,68 +473,68 @@ static int flash_erase32(flash_info_t *info, int s_first, int s_last)
 
     /* Validate arguments */
     if ((s_first < 0) || (s_first > s_last)) {
-        if (info->flash_id == FLASH_UNKNOWN)
-            printf ("- missing\n");
-        else
-            printf ("- no sectors to erase\n");
-        return 1;
+	if (info->flash_id == FLASH_UNKNOWN)
+	    printf ("- missing\n");
+	else
+	    printf ("- no sectors to erase\n");
+	return 1;
     }
 
     /* Check for KNOWN flash type */
     if ((info->flash_id & FLASH_VENDMASK) != FLASH_MAN_INTEL) {
-        printf ("Can erase only Intel flash types - aborted\n");
-        return 1;
+	printf ("Can erase only Intel flash types - aborted\n");
+	return 1;
     }
 
     /* Check for protected sectors */
     for (sect = s_first; sect <= s_last; ++sect) {
-        if (info->protect[sect])
-            prot++;
+	if (info->protect[sect])
+	    prot++;
     }
     if (prot)
-        printf ("- Warning: %d protected sectors will not be erased!\n", prot);
+	printf ("- Warning: %d protected sectors will not be erased!\n", prot);
     else
-        printf ("\n");
+	printf ("\n");
 
     start = get_timer (0);
     last  = start;
     /* Start erase on unprotected sectors */
     for (sect = s_first; sect <= s_last; sect++) {
-        WATCHDOG_RESET();
-        if (info->protect[sect] == 0) {      /* not protected */
-            vu_long *addr = (vu_long *)(info->start[sect]);
-            unsigned long status;
-
-            /* Disable interrupts which might cause a timeout here */
-            flag = disable_interrupts();
-
-            *addr = 0x00500050;              /* clear status register */
-            *addr = 0x00200020;              /* erase setup */
-            *addr = 0x00D000D0;              /* erase confirm */
-
-            /* re-enable interrupts if necessary */
-            if (flag)
-                enable_interrupts();
-
-            /* Wait at least 80us - let's wait 1 ms */
-            udelay (1000);
-
-            while (((status = *addr) & 0x00800080) != 0x00800080) {
-                if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
-                    printf ("Timeout\n");
-                    *addr = 0x00B000B0;      /* suspend erase      */
-                    *addr = 0x00FF00FF;      /* reset to read mode */
-                    return 1;
-                }
-
-                /* show that we're waiting */
-                if ((now - last) > 990) {   /* every second */
-                    putc ('.');
-                    last = now;
-                }
-            }
-            *addr = 0x00FF00FF;              /* reset to read mode */
-        }
+	WATCHDOG_RESET();
+	if (info->protect[sect] == 0) {      /* not protected */
+	    vu_long *addr = (vu_long *)(info->start[sect]);
+	    unsigned long status;
+
+	    /* Disable interrupts which might cause a timeout here */
+	    flag = disable_interrupts();
+
+	    *addr = 0x00500050;              /* clear status register */
+	    *addr = 0x00200020;              /* erase setup */
+	    *addr = 0x00D000D0;              /* erase confirm */
+
+	    /* re-enable interrupts if necessary */
+	    if (flag)
+		enable_interrupts();
+
+	    /* Wait at least 80us - let's wait 1 ms */
+	    udelay (1000);
+
+	    while (((status = *addr) & 0x00800080) != 0x00800080) {
+		if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
+		    printf ("Timeout\n");
+		    *addr = 0x00B000B0;      /* suspend erase      */
+		    *addr = 0x00FF00FF;      /* reset to read mode */
+		    return 1;
+		}
+
+		/* show that we're waiting */
+		if ((now - last) > 990) {   /* every second */
+		    putc ('.');
+		    last = now;
+		}
+	    }
+	    *addr = 0x00FF00FF;              /* reset to read mode */
+	}
     }
     printf (" done\n");
     return 0;
@@ -543,9 +543,9 @@ static int flash_erase32(flash_info_t *info, int s_first, int s_last)
 int flash_erase(flash_info_t *info, int s_first, int s_last)
 {
     if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM040)
-        return flash_erase8(info, s_first, s_last);
+	return flash_erase8(info, s_first, s_last);
     else
-        return flash_erase32(info, s_first, s_last);
+	return flash_erase32(info, s_first, s_last);
 } /* end flash_erase() */
 
 /*-----------------------------------------------------------------------
@@ -563,53 +563,53 @@ static int write_buff8(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
     start = get_timer (0);
 
     wp = (addr & ~3);                        /* get lower word
-                                                aligned address */
+						aligned address */
 
     /*
      * handle unaligned start bytes
      */
     if ((l = addr - wp) != 0) {
-        data = 0;
-        for (i=0, cp=wp; i<l; ++i, ++cp) {
-            data = (data << 8) | (*(uchar *)cp);
-        }
-        for (; i<4 && cnt>0; ++i) {
-            data = (data << 8) | *src++;
-            --cnt;
-            ++cp;
-        }
-        for (; cnt==0 && i<4; ++i, ++cp) {
-            data = (data << 8) | (*(uchar *)cp);
-        }
-
-        if ((rc = write_word8(info, wp, data)) != 0) {
-            return (rc);
-        }
-        wp += 4;
+	data = 0;
+	for (i=0, cp=wp; i<l; ++i, ++cp) {
+	    data = (data << 8) | (*(uchar *)cp);
+	}
+	for (; i<4 && cnt>0; ++i) {
+	    data = (data << 8) | *src++;
+	    --cnt;
+	    ++cp;
+	}
+	for (; cnt==0 && i<4; ++i, ++cp) {
+	    data = (data << 8) | (*(uchar *)cp);
+	}
+
+	if ((rc = write_word8(info, wp, data)) != 0) {
+	    return (rc);
+	}
+	wp += 4;
     }
 
     /*
      * handle word aligned part
      */
     while (cnt >= 4) {
-        data = 0;
-        for (i=0; i<4; ++i) {
-            data = (data << 8) | *src++;
-        }
-        if ((rc = write_word8(info, wp, data)) != 0) {
-            return (rc);
-        }
-        wp  += 4;
-        cnt -= 4;
-        if (get_timer(start) > 1000) {   /* every second */
-           WATCHDOG_RESET();
-           putc ('.');
-           start = get_timer(0);
-        }
+	data = 0;
+	for (i=0; i<4; ++i) {
+	    data = (data << 8) | *src++;
+	}
+	if ((rc = write_word8(info, wp, data)) != 0) {
+	    return (rc);
+	}
+	wp  += 4;
+	cnt -= 4;
+	if (get_timer(start) > 1000) {   /* every second */
+	   WATCHDOG_RESET();
+	   putc ('.');
+	   start = get_timer(0);
+	}
     }
 
     if (cnt == 0) {
-        return (0);
+	return (0);
     }
 
     /*
@@ -617,11 +617,11 @@ static int write_buff8(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
      */
     data = 0;
     for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) {
-        data = (data << 8) | *src++;
-        --cnt;
+	data = (data << 8) | *src++;
+	--cnt;
     }
     for (; i<4; ++i, ++cp) {
-        data = (data << 8) | (*(uchar *)cp);
+	data = (data << 8) | (*(uchar *)cp);
     }
 
     return (write_word8(info, wp, data));
@@ -678,7 +678,7 @@ static int write_buff32 (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
 		}
 		wp  += FLASH_WIDTH;
 		cnt -= FLASH_WIDTH;
-          if (get_timer(start) > 990) {   /* every second */
+	  if (get_timer(start) > 990) {   /* every second */
 			putc ('.');
 			start = get_timer(0);
 		}
@@ -708,9 +708,9 @@ int write_buff(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
     int retval;
 
     if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM040)
-        retval = write_buff8(info, src, addr, cnt);
+	retval = write_buff8(info, src, addr, cnt);
     else
-        retval = write_buff32(info, src, addr, cnt);
+	retval = write_buff32(info, src, addr, cnt);
 
     return retval;
 } /* end write_buff() */
@@ -732,31 +732,31 @@ static int write_word8(flash_info_t *info, ulong dest, ulong data)
 
     /* Check if Flash is (sufficently) erased */
     if ((*((volatile uchar *)dest) &
-        (uchar)data) != (uchar)data) {
-        return (2);
+	(uchar)data) != (uchar)data) {
+	return (2);
     }
 
     for (i=0; i < (4 / sizeof(uchar)); i++) {
-        /* Disable interrupts which might cause a timeout here */
-        flag = disable_interrupts();
+	/* Disable interrupts which might cause a timeout here */
+	flag = disable_interrupts();
 
-        *(addr2 + 0x555) = (uchar)0xAA;
-        *(addr2 + 0x2aa) = (uchar)0x55;
-        *(addr2 + 0x555) = (uchar)0xA0;
+	*(addr2 + 0x555) = (uchar)0xAA;
+	*(addr2 + 0x2aa) = (uchar)0x55;
+	*(addr2 + 0x555) = (uchar)0xA0;
 
-        dest2[i] = data2[i];
+	dest2[i] = data2[i];
 
-        /* Wait for write to complete, up to 1ms */
-        tcode = wait_for_DQ7((ulong)&dest2[i], data2[i], 1);
+	/* Wait for write to complete, up to 1ms */
+	tcode = wait_for_DQ7((ulong)&dest2[i], data2[i], 1);
 
-        /* re-enable interrupts if necessary */
-        if (flag)
-            enable_interrupts();
+	/* re-enable interrupts if necessary */
+	if (flag)
+	    enable_interrupts();
 
-        /* Make sure we didn't timeout */
-        if (tcode) {
-            rcode = 1;
-        }
+	/* Make sure we didn't timeout */
+	if (tcode) {
+	    rcode = 1;
+	}
     }
 
     return rcode;
@@ -771,7 +771,7 @@ static int write_word32(flash_info_t *info, ulong dest, ulong data)
 
     /* Check if Flash is (sufficiently) erased */
     if ((*addr & data) != data) {
-        return (2);
+	return (2);
     }
     /* Disable interrupts which might cause a timeout here */
     flag = disable_interrupts();
@@ -781,16 +781,16 @@ static int write_word32(flash_info_t *info, ulong dest, ulong data)
 
     /* re-enable interrupts if necessary */
     if (flag)
-        enable_interrupts();
+	enable_interrupts();
 
     start = get_timer (0);
 
     while (((status = *addr) & 0x00800080) != 0x00800080) {
-        WATCHDOG_RESET();
-        if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
-            *addr = 0x00FF00FF;              /* restore read mode */
-            return (1);
-        }
+	WATCHDOG_RESET();
+	if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
+	    *addr = 0x00FF00FF;              /* restore read mode */
+	    return (1);
+	}
     }
 
     *addr = 0x00FF00FF;                      /* restore read mode */
@@ -808,50 +808,50 @@ static int _flash_protect(flash_info_t *info, long sector)
     volatile long *addr = (unsigned long *)sector;
 
     switch(info->flash_id & FLASH_TYPEMASK) {
-        case FLASH_28F320J3A:
-        case FLASH_28F640J3A:
-        case FLASH_28F128J3A:
-            /* Disable interrupts which might cause Flash to timeout */
-            flag = disable_interrupts();
-
-            /* Issue command */
-            *addr = 0x00500050L;             /* Clear the status register */
-            *addr = 0x00600060L;             /* Set lock bit setup */
-            *addr = 0x00010001L;             /* Set lock bit confirm */
-
-            /* Wait for command completion */
-            for (i = 0; i < 10; i++) {       /* 75us timeout, wait 100us */
-                udelay(10);
-                if ((*addr & 0x00800080L) == 0x00800080L)
-                    break;
-            }
-
-            /* Not successful? */
-            status = *addr;
-            if (status != 0x00800080L) {
-                printf("Protect %x sector failed: %x\n",
-                       (uint)sector, (uint)status);
-                rcode = 1;
-            }
-
-            /* Restore read mode */
-            *addr = 0x00ff00ffL;
-
-            /* re-enable interrupts if necessary */
-            if (flag)
-                enable_interrupts();
-
-            break;
-        case FLASH_AM040:                    /* No soft sector protection */
-            break;
+	case FLASH_28F320J3A:
+	case FLASH_28F640J3A:
+	case FLASH_28F128J3A:
+	    /* Disable interrupts which might cause Flash to timeout */
+	    flag = disable_interrupts();
+
+	    /* Issue command */
+	    *addr = 0x00500050L;             /* Clear the status register */
+	    *addr = 0x00600060L;             /* Set lock bit setup */
+	    *addr = 0x00010001L;             /* Set lock bit confirm */
+
+	    /* Wait for command completion */
+	    for (i = 0; i < 10; i++) {       /* 75us timeout, wait 100us */
+		udelay(10);
+		if ((*addr & 0x00800080L) == 0x00800080L)
+		    break;
+	    }
+
+	    /* Not successful? */
+	    status = *addr;
+	    if (status != 0x00800080L) {
+		printf("Protect %x sector failed: %x\n",
+		       (uint)sector, (uint)status);
+		rcode = 1;
+	    }
+
+	    /* Restore read mode */
+	    *addr = 0x00ff00ffL;
+
+	    /* re-enable interrupts if necessary */
+	    if (flag)
+		enable_interrupts();
+
+	    break;
+	case FLASH_AM040:                    /* No soft sector protection */
+	    break;
     }
 
     /* Turn protection on for this sector */
     for (i = 0; i < info->sector_count; i++) {
-        if (info->start[i] == sector) {
-            info->protect[i] = 1;
-            break;
-        }
+	if (info->start[i] == sector) {
+	    info->protect[i] = 1;
+	    break;
+	}
     }
 
     return rcode;
@@ -866,42 +866,42 @@ static int _flash_unprotect(flash_info_t *info, long sector)
     volatile long *addr = (unsigned long *)sector;
 
     switch(info->flash_id & FLASH_TYPEMASK) {
-        case FLASH_28F320J3A:
-        case FLASH_28F640J3A:
-        case FLASH_28F128J3A:
-            /* Disable interrupts which might cause Flash to timeout */
-            flag = disable_interrupts();
-
-            *addr = 0x00500050L;             /* Clear the status register */
-            *addr = 0x00600060L;             /* Clear lock bit setup */
-            *addr = 0x00D000D0L;             /* Clear lock bit confirm */
-
-            /* Wait for command completion */
-            for (i = 0; i < 80 ; i++) {      /* 700ms timeout, wait 800 */
-                udelay(10000);               /* Delay 10ms */
-                if ((*addr & 0x00800080L) == 0x00800080L)
-                    break;
-            }
-
-            /* Not successful? */
-            status = *addr;
-            if (status != 0x00800080L) {
-                printf("Un-protect %x sector failed: %x\n",
-                       (uint)sector, (uint)status);
-                *addr = 0x00ff00ffL;
-                rcode = 1;
-            }
-
-            /* restore read mode */
-            *addr = 0x00ff00ffL;
-
-            /* re-enable interrupts if necessary */
-            if (flag)
-                enable_interrupts();
-
-            break;
-        case FLASH_AM040:                    /* No soft sector protection */
-            break;
+	case FLASH_28F320J3A:
+	case FLASH_28F640J3A:
+	case FLASH_28F128J3A:
+	    /* Disable interrupts which might cause Flash to timeout */
+	    flag = disable_interrupts();
+
+	    *addr = 0x00500050L;             /* Clear the status register */
+	    *addr = 0x00600060L;             /* Clear lock bit setup */
+	    *addr = 0x00D000D0L;             /* Clear lock bit confirm */
+
+	    /* Wait for command completion */
+	    for (i = 0; i < 80 ; i++) {      /* 700ms timeout, wait 800 */
+		udelay(10000);               /* Delay 10ms */
+		if ((*addr & 0x00800080L) == 0x00800080L)
+		    break;
+	    }
+
+	    /* Not successful? */
+	    status = *addr;
+	    if (status != 0x00800080L) {
+		printf("Un-protect %x sector failed: %x\n",
+		       (uint)sector, (uint)status);
+		*addr = 0x00ff00ffL;
+		rcode = 1;
+	    }
+
+	    /* restore read mode */
+	    *addr = 0x00ff00ffL;
+
+	    /* re-enable interrupts if necessary */
+	    if (flag)
+		enable_interrupts();
+
+	    break;
+	case FLASH_AM040:                    /* No soft sector protection */
+	    break;
     }
 
     /*
@@ -910,14 +910,14 @@ static int _flash_unprotect(flash_info_t *info, long sector)
      * protection on a specific sector.
      */
     for (i = 0; i < info->sector_count; i++) {
-        if (info->start[i] != sector) {
-            if (info->protect[i]) {
-                if (_flash_protect(info, info->start[i]))
-                    rcode = 1;
+	if (info->start[i] != sector) {
+	    if (info->protect[i]) {
+		if (_flash_protect(info, info->start[i]))
+		    rcode = 1;
 	    }
-        }
-        else /* Turn protection off for this sector */
-            info->protect[i] = 0;
+	}
+	else /* Turn protection off for this sector */
+	    info->protect[i] = 0;
     }
 
     return rcode;
@@ -929,13 +929,12 @@ int flash_real_protect(flash_info_t *info, long sector, int prot)
     int rcode;
 
     if (prot)
-        rcode = _flash_protect(info, info->start[sector]);
+	rcode = _flash_protect(info, info->start[sector]);
     else
-        rcode = _flash_unprotect(info, info->start[sector]);
+	rcode = _flash_unprotect(info, info->start[sector]);
 
     return rcode;
 } /* end flash_real_protect() */
 
 /*-----------------------------------------------------------------------
  */
-