Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

board/w7o/flash.c: make (mostly) checkpatch clean

Browse Source 
No full cleanup was attempted.  Warnings about "Use of volatile is
usually wrong" were ignored.  One line > 80 char was intentionally
accepted.

Signed-off-by: Wolfgang Denk <wd@denx.de>
master
Wolfgang Denk 14 years ago
parent 96aedd4266
commit 75a69acbe2
1 changed files with 716 additions and 712 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 280
      board/w7o/flash.c

280
board/w7o/flash.c
Unescape View File

@ -29,9 +29,10 @@
#include <watchdog.h> #include <watchdog.h>
flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips */ /* info for FLASH chips */
flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
/*----------------------------------------------------------------------- /*
* Functions * Functions
*/ */
static ulong flash_get_size(vu_long *addr, flash_info_t *info); static ulong flash_get_size(vu_long *addr, flash_info_t *info);
@ -39,9 +40,6 @@ static int write_word8(flash_info_t *info, ulong dest, ulong data);
static int write_word32(flash_info_t *info, ulong dest, ulong data); static int write_word32(flash_info_t *info, ulong dest, ulong data);
static void flash_get_offsets(ulong base, flash_info_t *info); static void flash_get_offsets(ulong base, flash_info_t *info);
/*-----------------------------------------------------------------------
*/
unsigned long flash_init(void) unsigned long flash_init(void)
{ {
int i; int i;
@ -49,18 +47,20 @@ unsigned long flash_init (void)
unsigned long size_b1, base_b1; unsigned long size_b1, base_b1;
/* Init: no FLASHes known */ /* Init: no FLASHes known */
for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) { for (i = 0; i < CONFIG_SYS_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 */ /* Get Size of Boot and Main Flashes */
size_b0 = flash_get_size((vu_long *)FLASH_BASE0_PRELIM, &flash_info[0]); size_b0 = flash_get_size((vu_long *) FLASH_BASE0_PRELIM,
&flash_info[0]);
if (flash_info[0].flash_id == FLASH_UNKNOWN) { if (flash_info[0].flash_id == FLASH_UNKNOWN) {
printf("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n", printf("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
size_b0, size_b0 << 20); size_b0, size_b0 << 20);
return 0; return 0;
} }
size_b1 = flash_get_size((vu_long *)FLASH_BASE1_PRELIM, &flash_info[1]); size_b1 =
flash_get_size((vu_long *) FLASH_BASE1_PRELIM,
&flash_info[1]);
if (flash_info[1].flash_id == FLASH_UNKNOWN) { if (flash_info[1].flash_id == FLASH_UNKNOWN) {
printf("## Unknown FLASH on Bank 1 - Size = 0x%08lx = %ld MB\n", printf("## Unknown FLASH on Bank 1 - Size = 0x%08lx = %ld MB\n",
size_b1, size_b1 << 20); size_b1, size_b1 << 20);
@ -77,36 +77,31 @@ unsigned long flash_init (void)
/* Protect board level data */ /* Protect board level data */
(void) flash_protect(FLAG_PROTECT_SET, (void) flash_protect(FLAG_PROTECT_SET,
base_b0, base_b0,
flash_info[0].start[1] - 1, flash_info[0].start[1] - 1, &flash_info[0]);
&flash_info[0]);
/* Monitor protection ON by default */ /* Monitor protection ON by default */
(void) flash_protect(FLAG_PROTECT_SET, (void) flash_protect(FLAG_PROTECT_SET,
base_b0 + size_b0 - monitor_flash_len, base_b0 + size_b0 - monitor_flash_len,
base_b0 + size_b0 - 1, base_b0 + size_b0 - 1, &flash_info[0]);
&flash_info[0]);
/* Protect the FPGA image */ /* Protect the FPGA image */
(void) flash_protect(FLAG_PROTECT_SET, (void) flash_protect(FLAG_PROTECT_SET,
FLASH_BASE1_PRELIM, FLASH_BASE1_PRELIM,
FLASH_BASE1_PRELIM + CONFIG_SYS_FPGA_IMAGE_LEN - 1, FLASH_BASE1_PRELIM + CONFIG_SYS_FPGA_IMAGE_LEN -
&flash_info[1]); 1, &flash_info[1]);
/* Protect the default boot image */ /* Protect the default boot image */
(void) flash_protect(FLAG_PROTECT_SET, (void) flash_protect(FLAG_PROTECT_SET,
FLASH_BASE1_PRELIM + CONFIG_SYS_FPGA_IMAGE_LEN, FLASH_BASE1_PRELIM + CONFIG_SYS_FPGA_IMAGE_LEN,
FLASH_BASE1_PRELIM + CONFIG_SYS_FPGA_IMAGE_LEN + 0x600000 - 1, FLASH_BASE1_PRELIM + CONFIG_SYS_FPGA_IMAGE_LEN +
&flash_info[1]); 0x600000 - 1, &flash_info[1]);
/* Setup offsets for Main Flash */ /* Setup offsets for Main Flash */
flash_get_offsets(FLASH_BASE1_PRELIM, &flash_info[1]); flash_get_offsets(FLASH_BASE1_PRELIM, &flash_info[1]);
return (size_b0 + size_b1); return size_b0 + size_b1;
} /* end flash_init() */ }
/*-----------------------------------------------------------------------
*/
static void flash_get_offsets(ulong base, flash_info_t *info) static void flash_get_offsets(ulong base, flash_info_t *info)
{ {
int i; int i;
@ -118,8 +113,6 @@ static void flash_get_offsets (ulong base, flash_info_t *info)
} }
} /* end flash_get_offsets() */ } /* end flash_get_offsets() */
/*-----------------------------------------------------------------------
*/
void flash_print_info(flash_info_t *info) void flash_print_info(flash_info_t *info)
{ {
int i; int i;
@ -134,10 +127,17 @@ void flash_print_info (flash_info_t *info)
} }
switch (info->flash_id & FLASH_VENDMASK) { switch (info->flash_id & FLASH_VENDMASK) {
case FLASH_MAN_AMD: printf ("1 x AMD "); break; case FLASH_MAN_AMD:
case FLASH_MAN_STM: printf ("1 x STM "); break; printf("1 x AMD ");
case FLASH_MAN_INTEL: printf ("2 x Intel "); break; break;
default: printf ("Unknown Vendor "); case FLASH_MAN_STM:
printf("1 x STM ");
break;
case FLASH_MAN_INTEL:
printf("2 x Intel ");
break;
default:
printf("Unknown Vendor ");
} }
switch (info->flash_id & FLASH_TYPEMASK) { switch (info->flash_id & FLASH_TYPEMASK) {
@ -182,10 +182,8 @@ void flash_print_info (flash_info_t *info)
erased = 1; erased = 1;
flash = (volatile unsigned long *) info->start[i]; flash = (volatile unsigned long *) info->start[i];
size = size >> 2; /* divide by 4 for longword access */ size = size >> 2; /* divide by 4 for longword access */
for (k=0; k<size; k++) for (k = 0; k < size; k++) {
{ if (*flash++ != 0xffffffff) {
if (*flash++ != 0xffffffff)
{
erased = 0; erased = 0;
break; break;
} }
@ -196,8 +194,7 @@ void flash_print_info (flash_info_t *info)
printf(" %08lX%s%s", printf(" %08lX%s%s",
info->start[i], info->start[i],
erased ? " E" : " ", erased ? " E" : " ",
info->protect[i] ? "RO " : " " info->protect[i] ? "RO " : " ");
);
} }
printf("\n"); printf("\n");
} /* end flash_print_info() */ } /* end flash_print_info() */
@ -252,8 +249,7 @@ static ulong flash_get_size (vu_long *addr, flash_info_t *info)
*addr2 = 0xf0; /* => no or unknown flash */ *addr2 = 0xf0; /* => no or unknown flash */
return 0; return 0;
} }
} } else { /* MAIN Flash */
else { /* MAIN Flash */
unsigned long value; unsigned long value;
volatile unsigned long *addr2 = (unsigned long *) addr; volatile unsigned long *addr2 = (unsigned long *) addr;
@ -311,30 +307,38 @@ static ulong flash_get_size (vu_long *addr, flash_info_t *info)
case FLASH_28F640J3A: case FLASH_28F640J3A:
case FLASH_28F128J3A: case FLASH_28F128J3A:
for (i = 0; i < info->sector_count; i++) for (i = 0; i < info->sector_count; i++)
info->start[i] = base + (i * 0x00020000 * 2); /* 2 Banks */ info->start[i] = base +
(i * 0x00020000 * 2); /* 2 Banks */
break; break;
} }
/* Test for Boot Flash */ /* Test for Boot Flash */
if (base == FLASH_BASE0_PRELIM) { if (base == FLASH_BASE0_PRELIM) {
volatile unsigned char *addr2; volatile unsigned char *addr2;
/* check for protected sectors */ /* check for protected sectors */
for (i = 0; i < info->sector_count; i++) { for (i = 0; i < info->sector_count; i++) {
/* read sector protection at sector address, (AX .. A0) = 0x02 */ /*
/* D0 = 1 if protected */ * read sector protection at sector address,
* (AX .. A0) = 0x02
* D0 = 1 if protected
*/
addr2 = (volatile unsigned char *) (info->start[i]); addr2 = (volatile unsigned char *) (info->start[i]);
info->protect[i] = *(addr2 + 2) & 1; info->protect[i] = *(addr2 + 2) & 1;
} }
/* Restore read mode */ /* Restore read mode */
*(unsigned char *) base = 0xF0; /* Reset NORMAL Flash */ *(unsigned char *) base = 0xF0; /* Reset NORMAL Flash */
} } else { /* Main Flash */
else { /* Main Flash */
volatile unsigned long *addr2; volatile unsigned long *addr2;
/* check for protected sectors */ /* check for protected sectors */
for (i = 0; i < info->sector_count; i++) { for (i = 0; i < info->sector_count; i++) {
/* read sector protection at sector address, (AX .. A0) = 0x02 */ /*
/* D0 = 1 if protected */ * read sector protection at sector address,
* (AX .. A0) = 0x02
* D0 = 1 if protected
*/
addr2 = (volatile unsigned long *) (info->start[i]); addr2 = (volatile unsigned long *) (info->start[i]);
info->protect[i] = *(addr2 + 2) & 0x1; info->protect[i] = *(addr2 + 2) & 0x1;
} }
@ -343,12 +347,9 @@ static ulong flash_get_size (vu_long *addr, flash_info_t *info)
*(unsigned long *) base = 0xFFFFFFFF; /* Reset Flash */ *(unsigned long *) base = 0xFFFFFFFF; /* Reset Flash */
} }
return (info->size); return info->size;
} /* end flash_get_size() */ } /* end flash_get_size() */
/*-----------------------------------------------------------------------
*/
static int wait_for_DQ7(ulong addr, uchar cmp_val, ulong tout) static int wait_for_DQ7(ulong addr, uchar cmp_val, ulong tout)
{ {
int i; int i;
@ -361,9 +362,8 @@ static int wait_for_DQ7(ulong addr, uchar cmp_val, ulong tout)
/* Pause 10 us */ /* Pause 10 us */
/* Check for completion */ /* Check for completion */
if ((vaddr[0] & 0x80) == (cmp_val & 0x80)) { if ((vaddr[0] & 0x80) == (cmp_val & 0x80))
return 0; return 0;
}
/* KEEP THE LUSER HAPPY - Print a dot every 1.1 seconds */ /* KEEP THE LUSER HAPPY - Print a dot every 1.1 seconds */
if (!(i % 110000)) if (!(i % 110000))
@ -376,9 +376,6 @@ static int wait_for_DQ7(ulong addr, uchar cmp_val, ulong tout)
return 1; return 1;
} /* wait_for_DQ7() */ } /* wait_for_DQ7() */
/*-----------------------------------------------------------------------
*/
static int flash_erase8(flash_info_t *info, int s_first, int s_last) static int flash_erase8(flash_info_t *info, int s_first, int s_last)
{ {
int tcode, rcode = 0; int tcode, rcode = 0;
@ -407,22 +404,25 @@ static int flash_erase8(flash_info_t *info, int s_first, int s_last)
if (info->protect[sect]) if (info->protect[sect])
prot++; prot++;
} }
if (prot) if (prot) {
printf ("- Warning: %d protected sectors will not be erased!\n", prot); printf("- Warning: %d protected sectors will not be erased!\n",
else prot);
} else {
printf("\n"); printf("\n");
}
/* Start erase on unprotected sectors */ /* Start erase on unprotected sectors */
for (sect = s_first; sect <= s_last; sect++) { for (sect = s_first; sect <= s_last; sect++) {
if (info->protect[sect] == 0) { /* not protected */ if (info->protect[sect] == 0) { /* not protected */
sector_addr = (uchar *) (info->start[sect]); 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); printf("Erasing block %p\n", sector_addr);
else else
printf("Erasing sector %p\n", sector_addr); printf("Erasing sector %p\n", sector_addr);
/* Disable interrupts which might cause Flash to timeout */ /* Disable interrupts which might cause timeout */
flag = disable_interrupts(); flag = disable_interrupts();
*(addr + 0x555) = (uchar) 0xAA; *(addr + 0x555) = (uchar) 0xAA;
@ -491,10 +491,12 @@ static int flash_erase32(flash_info_t *info, int s_first, int s_last)
if (info->protect[sect]) if (info->protect[sect])
prot++; prot++;
} }
if (prot) if (prot) {
printf ("- Warning: %d protected sectors will not be erased!\n", prot); printf("- Warning: %d protected sectors will not be erased!\n",
else prot);
} else {
printf("\n"); printf("\n");
}
start = get_timer(0); start = get_timer(0);
last = start; last = start;
@ -505,7 +507,7 @@ static int flash_erase32(flash_info_t *info, int s_first, int s_last)
vu_long *addr = (vu_long *) (info->start[sect]); vu_long *addr = (vu_long *) (info->start[sect]);
unsigned long status; unsigned long status;
/* Disable interrupts which might cause a timeout here */ /* Disable interrupts which might cause a timeout */
flag = disable_interrupts(); flag = disable_interrupts();
*addr = 0x00500050; /* clear status register */ *addr = 0x00500050; /* clear status register */
@ -520,15 +522,21 @@ static int flash_erase32(flash_info_t *info, int s_first, int s_last)
udelay(1000); udelay(1000);
while (((status = *addr) & 0x00800080) != 0x00800080) { while (((status = *addr) & 0x00800080) != 0x00800080) {
if ((now = get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) { now = get_timer(start);
if (now > CONFIG_SYS_FLASH_ERASE_TOUT) {
printf("Timeout\n"); printf("Timeout\n");
*addr = 0x00B000B0; /* suspend erase */ /* suspend erase */
*addr = 0x00FF00FF; /* reset to read mode */ *addr = 0x00B000B0;
/* reset to read mode */
*addr = 0x00FF00FF;
return 1; return 1;
} }
/* show that we're waiting */ /*
if ((now - last) > 990) { /* every second */ * show that we're waiting
* every second (?)
*/
if ((now - last) > 990) {
putc('.'); putc('.');
last = now; last = now;
} }
@ -538,7 +546,7 @@ static int flash_erase32(flash_info_t *info, int s_first, int s_last)
} }
printf(" done\n"); printf(" done\n");
return 0; return 0;
} /* end flash_erase32() */ }
int flash_erase(flash_info_t *info, int s_first, int s_last) int flash_erase(flash_info_t *info, int s_first, int s_last)
{ {
@ -546,15 +554,16 @@ int flash_erase(flash_info_t *info, int s_first, int s_last)
return flash_erase8(info, s_first, s_last); return flash_erase8(info, s_first, s_last);
else else
return flash_erase32(info, s_first, s_last); return flash_erase32(info, s_first, s_last);
} /* end flash_erase() */ }
/*----------------------------------------------------------------------- /*
* Copy memory to flash, returns: * Copy memory to flash, returns:
* 0 - OK * 0 - OK
* 1 - write timeout * 1 - write timeout
* 2 - Flash not erased * 2 - Flash not erased
*/ */
static int write_buff8(flash_info_t *info, uchar *src, ulong addr, ulong cnt) static int write_buff8(flash_info_t *info, uchar *src, ulong addr,
ulong cnt)
{ {
ulong cp, wp, data; ulong cp, wp, data;
ulong start; ulong start;
@ -568,23 +577,25 @@ static int write_buff8(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
/* /*
* handle unaligned start bytes * handle unaligned start bytes
*/ */
if ((l = addr - wp) != 0) { l = addr - wp;
if (l != 0) {
data = 0; data = 0;
for (i=0, cp=wp; i<l; ++i, ++cp) { for (i = 0, cp = wp; i < l; ++i, ++cp)
data = (data << 8) | (*(uchar *) cp); data = (data << 8) | (*(uchar *) cp);
}
for (; i < 4 && cnt > 0; ++i) { for (; i < 4 && cnt > 0; ++i) {
data = (data << 8) | *src++; data = (data << 8) | *src++;
--cnt; --cnt;
++cp; ++cp;
} }
for (; cnt==0 && i<4; ++i, ++cp) {
for (; cnt == 0 && i < 4; ++i, ++cp)
data = (data << 8) | (*(uchar *) cp); data = (data << 8) | (*(uchar *) cp);
}
if ((rc = write_word8(info, wp, data)) != 0) { rc = write_word8(info, wp, data);
return (rc); if (rc != 0)
} return rc;
wp += 4; wp += 4;
} }
@ -593,12 +604,13 @@ static int write_buff8(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
*/ */
while (cnt >= 4) { while (cnt >= 4) {
data = 0; data = 0;
for (i=0; i<4; ++i) { for (i = 0; i < 4; ++i)
data = (data << 8) | *src++; data = (data << 8) | *src++;
}
if ((rc = write_word8(info, wp, data)) != 0) { rc = write_word8(info, wp, data);
return (rc); if (rc != 0)
} return rc;
wp += 4; wp += 4;
cnt -= 4; cnt -= 4;
if (get_timer(start) > 1000) { /* every second */ if (get_timer(start) > 1000) { /* every second */
@ -608,9 +620,8 @@ static int write_buff8(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
} }
} }
if (cnt == 0) { if (cnt == 0)
return (0); return 0;
}
/* /*
* handle unaligned tail bytes * handle unaligned tail bytes
@ -620,15 +631,16 @@ static int write_buff8(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
data = (data << 8) | *src++; data = (data << 8) | *src++;
--cnt; --cnt;
} }
for (; i<4; ++i, ++cp) {
for (; i < 4; ++i, ++cp)
data = (data << 8) | (*(uchar *) cp); data = (data << 8) | (*(uchar *) cp);
}
return (write_word8(info, wp, data)); return write_word8(info, wp, data);
} /* end write_buff8() */ }
#define FLASH_WIDTH 4 /* flash bus width in bytes */ #define FLASH_WIDTH 4 /* flash bus width in bytes */
static int write_buff32 (flash_info_t *info, uchar *src, ulong addr, ulong cnt) static int write_buff32(flash_info_t *info, uchar *src, ulong addr,
ulong cnt)
{ {
ulong cp, wp, data; ulong cp, wp, data;
int i, l, rc; int i, l, rc;
@ -636,32 +648,33 @@ static int write_buff32 (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
start = get_timer(0); start = get_timer(0);
if (info->flash_id == FLASH_UNKNOWN) { if (info->flash_id == FLASH_UNKNOWN)
return 4; return 4;
}
wp = (addr & ~(FLASH_WIDTH-1)); /* get lower FLASH_WIDTH aligned address */ /* get lower FLASH_WIDTH aligned address */
wp = (addr & ~(FLASH_WIDTH - 1));
/* /*
* handle unaligned start bytes * handle unaligned start bytes
*/ */
if ((l = addr - wp) != 0) { if ((l = addr - wp) != 0) {
data = 0; data = 0;
for (i=0, cp=wp; i<l; ++i, ++cp) { for (i = 0, cp = wp; i < l; ++i, ++cp)
data = (data << 8) | (*(uchar *) cp); data = (data << 8) | (*(uchar *) cp);
}
for (; i < FLASH_WIDTH && cnt > 0; ++i) { for (; i < FLASH_WIDTH && cnt > 0; ++i) {
data = (data << 8) | *src++; data = (data << 8) | *src++;
--cnt; --cnt;
++cp; ++cp;
} }
for (; cnt==0 && i<FLASH_WIDTH; ++i, ++cp) {
for (; cnt == 0 && i < FLASH_WIDTH; ++i, ++cp)
data = (data << 8) | (*(uchar *) cp); data = (data << 8) | (*(uchar *) cp);
}
if ((rc = write_word32(info, wp, data)) != 0) { rc = write_word32(info, wp, data);
return (rc); if (rc != 0)
} return rc;
wp += FLASH_WIDTH; wp += FLASH_WIDTH;
} }
@ -670,12 +683,13 @@ static int write_buff32 (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
*/ */
while (cnt >= FLASH_WIDTH) { while (cnt >= FLASH_WIDTH) {
data = 0; data = 0;
for (i=0; i<FLASH_WIDTH; ++i) { for (i = 0; i < FLASH_WIDTH; ++i)
data = (data << 8) | *src++; data = (data << 8) | *src++;
}
if ((rc = write_word32(info, wp, data)) != 0) { rc = write_word32(info, wp, data);
return (rc); if (rc != 0)
} return rc;
wp += FLASH_WIDTH; wp += FLASH_WIDTH;
cnt -= FLASH_WIDTH; cnt -= FLASH_WIDTH;
if (get_timer(start) > 990) { /* every second */ if (get_timer(start) > 990) { /* every second */
@ -684,9 +698,8 @@ static int write_buff32 (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
} }
} }
if (cnt == 0) { if (cnt == 0)
return (0); return 0;
}
/* /*
* handle unaligned tail bytes * handle unaligned tail bytes
@ -696,12 +709,12 @@ static int write_buff32 (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
data = (data << 8) | *src++; data = (data << 8) | *src++;
--cnt; --cnt;
} }
for (; i<FLASH_WIDTH; ++i, ++cp) {
for (; i < FLASH_WIDTH; ++i, ++cp)
data = (data << 8) | (*(uchar *) cp); data = (data << 8) | (*(uchar *) cp);
}
return (write_word32(info, wp, data)); return write_word32(info, wp, data);
} /* write_buff32() */ }
int write_buff(flash_info_t *info, uchar *src, ulong addr, ulong cnt) int write_buff(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
{ {
@ -713,9 +726,9 @@ int write_buff(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
retval = write_buff32(info, src, addr, cnt); retval = write_buff32(info, src, addr, cnt);
return retval; return retval;
} /* end write_buff() */ }
/*----------------------------------------------------------------------- /*
* Write a word to Flash, returns: * Write a word to Flash, returns:
* 0 - OK * 0 - OK
* 1 - write timeout * 1 - write timeout
@ -731,10 +744,8 @@ static int write_word8(flash_info_t *info, ulong dest, ulong data)
int i, tcode, rcode = 0; int i, tcode, rcode = 0;
/* Check if Flash is (sufficently) erased */ /* Check if Flash is (sufficently) erased */
if ((*((volatile uchar *)dest) & if ((*((volatile uchar *)dest) & (uchar)data) != (uchar)data)
(uchar)data) != (uchar)data) { return 2;
return (2);
}
for (i = 0; i < (4 / sizeof(uchar)); i++) { for (i = 0; i < (4 / sizeof(uchar)); i++) {
/* Disable interrupts which might cause a timeout here */ /* Disable interrupts which might cause a timeout here */
@ -754,13 +765,12 @@ static int write_word8(flash_info_t *info, ulong dest, ulong data)
enable_interrupts(); enable_interrupts();
/* Make sure we didn't timeout */ /* Make sure we didn't timeout */
if (tcode) { if (tcode)
rcode = 1; rcode = 1;
} }
}
return rcode; return rcode;
} /* end write_word8() */ }
static int write_word32(flash_info_t *info, ulong dest, ulong data) static int write_word32(flash_info_t *info, ulong dest, ulong data)
{ {
@ -770,9 +780,9 @@ static int write_word32(flash_info_t *info, ulong dest, ulong data)
int flag; int flag;
/* Check if Flash is (sufficiently) erased */ /* Check if Flash is (sufficiently) erased */
if ((*addr & data) != data) { if ((*addr & data) != data)
return (2); return 2;
}
/* Disable interrupts which might cause a timeout here */ /* Disable interrupts which might cause a timeout here */
flag = disable_interrupts(); flag = disable_interrupts();
@ -789,15 +799,14 @@ static int write_word32(flash_info_t *info, ulong dest, ulong data)
WATCHDOG_RESET(); WATCHDOG_RESET();
if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) { if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
*addr = 0x00FF00FF; /* restore read mode */ *addr = 0x00FF00FF; /* restore read mode */
return (1); return 1;
} }
} }
*addr = 0x00FF00FF; /* restore read mode */ *addr = 0x00FF00FF; /* restore read mode */
return (0); return 0;
} /* end write_word32() */ }
static int _flash_protect(flash_info_t *info, long sector) static int _flash_protect(flash_info_t *info, long sector)
{ {
@ -855,7 +864,7 @@ static int _flash_protect(flash_info_t *info, long sector)
} }
return rcode; return rcode;
} /* end _flash_protect() */ }
static int _flash_unprotect(flash_info_t *info, long sector) static int _flash_unprotect(flash_info_t *info, long sector)
{ {
@ -915,14 +924,12 @@ static int _flash_unprotect(flash_info_t *info, long sector)
if (_flash_protect(info, info->start[i])) if (_flash_protect(info, info->start[i]))
rcode = 1; rcode = 1;
} }
} } else /* Turn protection off for this sector */
else /* Turn protection off for this sector */
info->protect[i] = 0; info->protect[i] = 0;
} }
return rcode; return rcode;
} /* end _flash_unprotect() */ }
int flash_real_protect(flash_info_t *info, long sector, int prot) int flash_real_protect(flash_info_t *info, long sector, int prot)
{ {
@ -934,7 +941,4 @@ int flash_real_protect(flash_info_t *info, long sector, int prot)
rcode = _flash_unprotect(info, info->start[sector]); rcode = _flash_unprotect(info, info->start[sector]);
return rcode; return rcode;
} /* end flash_real_protect() */ }
/*-----------------------------------------------------------------------
*/

Write Preview
Loading…
Cancel
Save