phone-side
/
uboot-mt623x
9
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Code cleanup for GCC-3.3.x compilers

This commit is contained in:
wdenk 2004-10-17 21:12:06 +00:00
parent 8b74bf31fe
commit e86e5a0748
22 changed files with 969 additions and 998 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
README
View File

@ -25,9 +25,10 @@ Summary:
======== ========
This directory contains the source code for U-Boot, a boot loader for This directory contains the source code for U-Boot, a boot loader for
Embedded boards based on PowerPC and ARM processors, which can be Embedded boards based on PowerPC, ARM, MIPS and several other
installed in a boot ROM and used to initialize and test the hardware processors, which can be installed in a boot ROM and used to
or to download and run application code. initialize and test the hardware or to download and run application
code.
The development of U-Boot is closely related to Linux: some parts of The development of U-Boot is closely related to Linux: some parts of
the source code originate in the Linux source tree, we have some the source code originate in the Linux source tree, we have some

2
board/ep7312/flash.c
View File

@ -109,7 +109,7 @@ void flash_print_info (flash_info_t * info)
} }
printf ("\n"); printf ("\n");
Done: Done: ;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------

3
board/evb4510/flash.c
View File

@ -362,8 +362,7 @@ unsigned long flash_init (void)
} }
#endif #endif
else { else {
printf (__FUNCTION__ printf ("flash_init(): Unable to detect PHYS_FLASH_1: 0x%08x\n",
"(): Unable to detect PHYS_FLASH_1: 0x%08x\n",
PHYS_FLASH_1); PHYS_FLASH_1);
} }

154
board/impa7/flash.c
View File

@ -34,35 +34,33 @@ flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
*/ */
ulong flash_init(void) ulong flash_init (void)
{ {
int i, j; int i, j;
ulong size = 0; ulong size = 0;
for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) {
{
ulong flashbase = 0; ulong flashbase = 0;
flash_info[i].flash_id = flash_info[i].flash_id =
(INTEL_MANUFACT & FLASH_VENDMASK) | (INTEL_MANUFACT & FLASH_VENDMASK) |
(INTEL_ID_28F320B3T & FLASH_TYPEMASK); (INTEL_ID_28F320B3T & FLASH_TYPEMASK);
flash_info[i].size = FLASH_BANK_SIZE; flash_info[i].size = FLASH_BANK_SIZE;
flash_info[i].sector_count = CFG_MAX_FLASH_SECT; flash_info[i].sector_count = CFG_MAX_FLASH_SECT;
memset(flash_info[i].protect, 0, CFG_MAX_FLASH_SECT); memset (flash_info[i].protect, 0, CFG_MAX_FLASH_SECT);
if (i == 0) if (i == 0)
flashbase = PHYS_FLASH_1; flashbase = PHYS_FLASH_1;
else if (i == 1) else if (i == 1)
flashbase = PHYS_FLASH_2; flashbase = PHYS_FLASH_2;
else else
panic("configured too many flash banks!\n"); panic ("configured too many flash banks!\n");
for (j = 0; j < flash_info[i].sector_count; j++) for (j = 0; j < flash_info[i].sector_count; j++) {
{ if (j <= 7) {
if (j <= 7) flash_info[i].start[j] =
{ flashbase + j * PARAM_SECT_SIZE;
flash_info[i].start[j] = flashbase + j * PARAM_SECT_SIZE; } else {
} flash_info[i].start[j] =
else flashbase + (j - 7) * MAIN_SECT_SIZE;
{
flash_info[i].start[j] = flashbase + (j - 7)*MAIN_SECT_SIZE;
} }
} }
size += flash_info[i].size; size += flash_info[i].size;
@ -70,54 +68,49 @@ ulong flash_init(void)
/* Protect monitor and environment sectors /* Protect monitor and environment sectors
*/ */
flash_protect(FLAG_PROTECT_SET, flash_protect (FLAG_PROTECT_SET,
CFG_FLASH_BASE, CFG_FLASH_BASE,
CFG_FLASH_BASE + monitor_flash_len - 1, CFG_FLASH_BASE + monitor_flash_len - 1,
&flash_info[0]); &flash_info[0]);
flash_protect(FLAG_PROTECT_SET, flash_protect (FLAG_PROTECT_SET,
CFG_ENV_ADDR, CFG_ENV_ADDR,
CFG_ENV_ADDR + CFG_ENV_SIZE - 1, CFG_ENV_ADDR + CFG_ENV_SIZE - 1, &flash_info[0]);
&flash_info[0]);
return size; return size;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
*/ */
void flash_print_info (flash_info_t *info) void flash_print_info (flash_info_t * info)
{ {
int i; int i;
switch (info->flash_id & FLASH_VENDMASK) switch (info->flash_id & FLASH_VENDMASK) {
{
case (INTEL_MANUFACT & FLASH_VENDMASK): case (INTEL_MANUFACT & FLASH_VENDMASK):
printf("Intel: "); printf ("Intel: ");
break; break;
default: default:
printf("Unknown Vendor "); printf ("Unknown Vendor ");
break; break;
} }
switch (info->flash_id & FLASH_TYPEMASK) switch (info->flash_id & FLASH_TYPEMASK) {
{
case (INTEL_ID_28F320B3T & FLASH_TYPEMASK): case (INTEL_ID_28F320B3T & FLASH_TYPEMASK):
printf("28F320F3B (16Mbit)\n"); printf ("28F320F3B (16Mbit)\n");
break; break;
default: default:
printf("Unknown Chip Type\n"); printf ("Unknown Chip Type\n");
goto Done; goto Done;
break; break;
} }
printf(" Size: %ld MB in %d Sectors\n", printf (" Size: %ld MB in %d Sectors\n",
info->size >> 20, info->sector_count); info->size >> 20, info->sector_count);
printf(" Sector Start Addresses:"); printf (" Sector Start Addresses:");
for (i = 0; i < info->sector_count; i++) for (i = 0; i < info->sector_count; i++) {
{ if ((i % 5) == 0) {
if ((i % 5) == 0)
{
printf ("\n "); printf ("\n ");
} }
printf (" %08lX%s", info->start[i], printf (" %08lX%s", info->start[i],
@ -125,13 +118,13 @@ void flash_print_info (flash_info_t *info)
} }
printf ("\n"); printf ("\n");
Done: Done:;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
*/ */
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)
{ {
int flag, prot, sect; int flag, prot, sect;
int rc = ERR_OK; int rc = ERR_OK;
@ -149,7 +142,7 @@ int flash_erase (flash_info_t *info, int s_first, int s_last)
} }
prot = 0; prot = 0;
for (sect=s_first; sect<=s_last; ++sect) { for (sect = s_first; sect <= s_last; ++sect) {
if (info->protect[sect]) { if (info->protect[sect]) {
prot++; prot++;
} }
@ -164,24 +157,25 @@ int flash_erase (flash_info_t *info, int s_first, int s_last)
* (ticker) exception to happen while the flash * (ticker) exception to happen while the flash
* chip is in programming mode. * chip is in programming mode.
*/ */
flag = disable_interrupts(); flag = disable_interrupts ();
/* Start erase on unprotected sectors */ /* Start erase on unprotected sectors */
for (sect = s_first; sect<=s_last && !ctrlc(); sect++) { for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
printf("Erasing sector %2d ... ", sect); printf ("Erasing sector %2d ... ", sect);
/* arm simple, non interrupt dependent timer */ /* arm simple, non interrupt dependent timer */
reset_timer_masked(); reset_timer_masked ();
if (info->protect[sect] == 0) { /* not protected */ if (info->protect[sect] == 0) { /* not protected */
vu_long *addr = (vu_long *)(info->start[sect]); vu_long *addr = (vu_long *) (info->start[sect]);
*addr = 0x00200020; /* erase setup */ *addr = 0x00200020; /* erase setup */
*addr = 0x00D000D0; /* erase confirm */ *addr = 0x00D000D0; /* erase confirm */
while ((*addr & 0x00800080) != 0x00800080) { while ((*addr & 0x00800080) != 0x00800080) {
if (get_timer_masked() > CFG_FLASH_ERASE_TOUT) { if (get_timer_masked () >
CFG_FLASH_ERASE_TOUT) {
*addr = 0x00B000B0; /* suspend erase */ *addr = 0x00B000B0; /* suspend erase */
*addr = 0x00FF00FF; /* reset to read mode */ *addr = 0x00FF00FF; /* reset to read mode */
rc = ERR_TIMOUT; rc = ERR_TIMOUT;
@ -191,18 +185,18 @@ int flash_erase (flash_info_t *info, int s_first, int s_last)
*addr = 0x00FF00FF; /* reset to read mode */ *addr = 0x00FF00FF; /* reset to read mode */
} }
printf("ok.\n"); printf ("ok.\n");
} }
if (ctrlc()) if (ctrlc ())
printf("User Interrupt!\n"); printf ("User Interrupt!\n");
outahere: outahere:
/* allow flash to settle - wait 10 ms */ /* allow flash to settle - wait 10 ms */
udelay_masked(10000); udelay_masked (10000);
if (flag) if (flag)
enable_interrupts(); enable_interrupts ();
return rc; return rc;
} }
@ -211,9 +205,9 @@ outahere:
* Copy memory to flash * Copy memory to flash
*/ */
static int write_word (flash_info_t *info, ulong dest, ulong data) static int write_word (flash_info_t * info, ulong dest, ulong data)
{ {
vu_long *addr = (vu_long *)dest; vu_long *addr = (vu_long *) dest;
ulong barf; ulong barf;
int rc = ERR_OK; int rc = ERR_OK;
int flag; int flag;
@ -230,7 +224,7 @@ static int write_word (flash_info_t *info, ulong dest, ulong data)
* (ticker) exception to happen while the flash * (ticker) exception to happen while the flash
* chip is in programming mode. * chip is in programming mode.
*/ */
flag = disable_interrupts(); flag = disable_interrupts ();
/* clear status register command */ /* clear status register command */
*addr = 0x00500050; *addr = 0x00500050;
@ -242,42 +236,40 @@ static int write_word (flash_info_t *info, ulong dest, ulong data)
*addr = data; *addr = data;
/* arm simple, non interrupt dependent timer */ /* arm simple, non interrupt dependent timer */
reset_timer_masked(); reset_timer_masked ();
/* read status register command */ /* read status register command */
*addr = 0x00700070; *addr = 0x00700070;
/* wait while polling the status register */ /* wait while polling the status register */
while((*addr & 0x00800080) != 0x00800080) while ((*addr & 0x00800080) != 0x00800080) {
{ if (get_timer_masked () > CFG_FLASH_WRITE_TOUT) {
if (get_timer_masked() > CFG_FLASH_WRITE_TOUT) {
rc = ERR_TIMOUT; rc = ERR_TIMOUT;
/* suspend program command */ /* suspend program command */
*addr = 0x00B000B0; *addr = 0x00B000B0;
goto outahere; goto outahere;
} }
if( *addr & 0x003A003A) { /* check for error */ if (*addr & 0x003A003A) { /* check for error */
barf = *addr; barf = *addr;
if( barf & 0x003A0000) { if (barf & 0x003A0000) {
barf >>=16; barf >>= 16;
} else { } else {
barf &= 0x0000003A; barf &= 0x0000003A;
} }
printf("\nFlash write error %02lx at address %08lx\n", printf ("\nFlash write error %02lx at address %08lx\n", barf, (unsigned long) dest);
barf, (unsigned long)dest); if (barf & 0x0002) {
if(barf & 0x0002) { printf ("Block locked, not erased.\n");
printf("Block locked, not erased.\n");
rc = ERR_NOT_ERASED; rc = ERR_NOT_ERASED;
goto outahere; goto outahere;
} }
if(barf & 0x0010) { if (barf & 0x0010) {
printf("Programming error.\n"); printf ("Programming error.\n");
rc = ERR_PROG_ERROR; rc = ERR_PROG_ERROR;
goto outahere; goto outahere;
} }
if(barf & 0x0008) { if (barf & 0x0008) {
printf("Vpp Low error.\n"); printf ("Vpp Low error.\n");
rc = ERR_PROG_ERROR; rc = ERR_PROG_ERROR;
goto outahere; goto outahere;
} }
@ -287,12 +279,12 @@ static int write_word (flash_info_t *info, ulong dest, ulong data)
} }
outahere: outahere:
/* read array command */ /* read array command */
*addr = 0x00FF00FF; *addr = 0x00FF00FF;
if (flag) if (flag)
enable_interrupts(); enable_interrupts ();
return rc; return rc;
} }
@ -301,7 +293,7 @@ outahere:
* Copy memory to flash. * Copy memory to flash.
*/ */
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)
{ {
ulong cp, wp, data; ulong cp, wp, data;
int l; int l;
@ -314,19 +306,19 @@ int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
*/ */
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 << 24); data = (data >> 8) | (*(uchar *) cp << 24);
} }
for (; i<4 && cnt>0; ++i) { for (; i < 4 && cnt > 0; ++i) {
data = (data >> 8) | (*src++ << 24); data = (data >> 8) | (*src++ << 24);
--cnt; --cnt;
++cp; ++cp;
} }
for (; cnt==0 && i<4; ++i, ++cp) { for (; cnt == 0 && i < 4; ++i, ++cp) {
data = (data >> 8) | (*(uchar *)cp << 24); data = (data >> 8) | (*(uchar *) cp << 24);
} }
if ((rc = write_word(info, wp, data)) != 0) { if ((rc = write_word (info, wp, data)) != 0) {
return (rc); return (rc);
} }
wp += 4; wp += 4;
@ -336,8 +328,8 @@ int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
* handle word aligned part * handle word aligned part
*/ */
while (cnt >= 4) { while (cnt >= 4) {
data = *((vu_long*)src); data = *((vu_long *) src);
if ((rc = write_word(info, wp, data)) != 0) { if ((rc = write_word (info, wp, data)) != 0) {
return (rc); return (rc);
} }
src += 4; src += 4;
@ -353,13 +345,13 @@ int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
* handle unaligned tail bytes * handle unaligned tail bytes
*/ */
data = 0; data = 0;
for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) { for (i = 0, cp = wp; i < 4 && cnt > 0; ++i, ++cp) {
data = (data >> 8) | (*src++ << 24); data = (data >> 8) | (*src++ << 24);
--cnt; --cnt;
} }
for (; i<4; ++i, ++cp) { for (; i < 4; ++i, ++cp) {
data = (data >> 8) | (*(uchar *)cp << 24); data = (data >> 8) | (*(uchar *) cp << 24);
} }
return write_word(info, wp, data); return write_word (info, wp, data);
} }

1
board/lart/flash.c
View File

@ -159,6 +159,7 @@ void flash_print_info (flash_info_t *info)
printf ("\n"); printf ("\n");
Done: Done:
;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------

199
board/mpl/vcma9/flash.c
View File

@ -24,7 +24,7 @@
#include <common.h> #include <common.h>
ulong myflush(void); ulong myflush (void);
#define FLASH_BANK_SIZE PHYS_FLASH_SIZE #define FLASH_BANK_SIZE PHYS_FLASH_SIZE
@ -56,14 +56,14 @@ flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
*/ */
ulong flash_init(void) ulong flash_init (void)
{ {
int i, j; int i, j;
ulong size = 0; ulong size = 0;
for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) {
{
ulong flashbase = 0; ulong flashbase = 0;
flash_info[i].flash_id = flash_info[i].flash_id =
#if defined(CONFIG_AMD_LV400) #if defined(CONFIG_AMD_LV400)
(AMD_MANUFACT & FLASH_VENDMASK) | (AMD_MANUFACT & FLASH_VENDMASK) |
@ -76,106 +76,100 @@ ulong flash_init(void)
#endif #endif
flash_info[i].size = FLASH_BANK_SIZE; flash_info[i].size = FLASH_BANK_SIZE;
flash_info[i].sector_count = CFG_MAX_FLASH_SECT; flash_info[i].sector_count = CFG_MAX_FLASH_SECT;
memset(flash_info[i].protect, 0, CFG_MAX_FLASH_SECT); memset (flash_info[i].protect, 0, CFG_MAX_FLASH_SECT);
if (i == 0) if (i == 0)
flashbase = PHYS_FLASH_1; flashbase = PHYS_FLASH_1;
else else
panic("configured too many flash banks!\n"); panic ("configured too many flash banks!\n");
for (j = 0; j < flash_info[i].sector_count; j++) for (j = 0; j < flash_info[i].sector_count; j++) {
{ if (j <= 3) {
if (j <= 3)
{
/* 1st one is 16 KB */ /* 1st one is 16 KB */
if (j == 0) if (j == 0) {
{ flash_info[i].start[j] =
flash_info[i].start[j] = flashbase + 0; flashbase + 0;
} }
/* 2nd and 3rd are both 8 KB */ /* 2nd and 3rd are both 8 KB */
if ((j == 1) || (j == 2)) if ((j == 1) || (j == 2)) {
{ flash_info[i].start[j] =
flash_info[i].start[j] = flashbase + 0x4000 + (j-1)*0x2000; flashbase + 0x4000 + (j -
1) *
0x2000;
} }
/* 4th 32 KB */ /* 4th 32 KB */
if (j == 3) if (j == 3) {
{ flash_info[i].start[j] =
flash_info[i].start[j] = flashbase + 0x8000; flashbase + 0x8000;
} }
} } else {
else flash_info[i].start[j] =
{ flashbase + (j - 3) * MAIN_SECT_SIZE;
flash_info[i].start[j] = flashbase + (j - 3)*MAIN_SECT_SIZE;
} }
} }
size += flash_info[i].size; size += flash_info[i].size;
} }
flash_protect(FLAG_PROTECT_SET, flash_protect (FLAG_PROTECT_SET,
CFG_FLASH_BASE, CFG_FLASH_BASE,
CFG_FLASH_BASE + monitor_flash_len - 1, CFG_FLASH_BASE + monitor_flash_len - 1,
&flash_info[0]); &flash_info[0]);
flash_protect(FLAG_PROTECT_SET, flash_protect (FLAG_PROTECT_SET,
CFG_ENV_ADDR, CFG_ENV_ADDR,
CFG_ENV_ADDR + CFG_ENV_SIZE - 1, CFG_ENV_ADDR + CFG_ENV_SIZE - 1, &flash_info[0]);
&flash_info[0]);
return size; return size;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
*/ */
void flash_print_info (flash_info_t *info) void flash_print_info (flash_info_t * info)
{ {
int i; int i;
switch (info->flash_id & FLASH_VENDMASK) switch (info->flash_id & FLASH_VENDMASK) {
{
case (AMD_MANUFACT & FLASH_VENDMASK): case (AMD_MANUFACT & FLASH_VENDMASK):
puts("AMD: "); puts ("AMD: ");
break; break;
default: default:
puts("Unknown Vendor "); puts ("Unknown Vendor ");
break; break;
} }
switch (info->flash_id & FLASH_TYPEMASK) switch (info->flash_id & FLASH_TYPEMASK) {
{
case (AMD_ID_LV400B & FLASH_TYPEMASK): case (AMD_ID_LV400B & FLASH_TYPEMASK):
puts("1x Amd29LV400BB (4Mbit)\n"); puts ("1x Amd29LV400BB (4Mbit)\n");
break; break;
case (AMD_ID_LV800B & FLASH_TYPEMASK): case (AMD_ID_LV800B & FLASH_TYPEMASK):
puts("1x Amd29LV800BB (8Mbit)\n"); puts ("1x Amd29LV800BB (8Mbit)\n");
break; break;
default: default:
puts("Unknown Chip Type\n"); puts ("Unknown Chip Type\n");
goto Done; goto Done;
break; break;
} }
printf(" Size: %ld MB in %d Sectors\n", printf (" Size: %ld MB in %d Sectors\n",
info->size >> 20, info->sector_count); info->size >> 20, info->sector_count);
puts(" Sector Start Addresses:"); puts (" Sector Start Addresses:");
for (i = 0; i < info->sector_count; i++) for (i = 0; i < info->sector_count; i++) {
{ if ((i % 5) == 0) {
if ((i % 5) == 0) puts ("\n ");
{
puts("\n ");
} }
printf (" %08lX%s", info->start[i], printf (" %08lX%s", info->start[i],
info->protect[i] ? " (RO)" : " "); info->protect[i] ? " (RO)" : " ");
} }
puts("\n"); puts ("\n");
Done: Done: ;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
*/ */
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)
{ {
ushort result; ushort result;
int iflag, cflag, prot, sect; int iflag, cflag, prot, sect;
@ -197,7 +191,7 @@ int flash_erase (flash_info_t *info, int s_first, int s_last)
} }
prot = 0; prot = 0;
for (sect=s_first; sect<=s_last; ++sect) { for (sect = s_first; sect <= s_last; ++sect) {
if (info->protect[sect]) { if (info->protect[sect]) {
prot++; prot++;
} }
@ -212,21 +206,19 @@ int flash_erase (flash_info_t *info, int s_first, int s_last)
* (ticker) exception to happen while the flash * (ticker) exception to happen while the flash
* chip is in programming mode. * chip is in programming mode.
*/ */
cflag = icache_status(); cflag = icache_status ();
icache_disable(); icache_disable ();
iflag = disable_interrupts(); iflag = disable_interrupts ();
/* Start erase on unprotected sectors */ /* Start erase on unprotected sectors */
for (sect = s_first; sect<=s_last && !ctrlc(); sect++) for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
{ printf ("Erasing sector %2d ... ", sect);
printf("Erasing sector %2d ... ", sect);
/* arm simple, non interrupt dependent timer */ /* arm simple, non interrupt dependent timer */
reset_timer_masked(); reset_timer_masked ();
if (info->protect[sect] == 0) if (info->protect[sect] == 0) { /* not protected */
{ /* not protected */ vu_short *addr = (vu_short *) (info->start[sect]);
vu_short *addr = (vu_short *)(info->start[sect]);
MEM_FLASH_ADDR1 = CMD_UNLOCK1; MEM_FLASH_ADDR1 = CMD_UNLOCK1;
MEM_FLASH_ADDR2 = CMD_UNLOCK2; MEM_FLASH_ADDR2 = CMD_UNLOCK2;
@ -239,59 +231,57 @@ int flash_erase (flash_info_t *info, int s_first, int s_last)
/* wait until flash is ready */ /* wait until flash is ready */
chip = 0; chip = 0;
do do {
{
result = *addr; result = *addr;
/* check timeout */ /* check timeout */
if (get_timer_masked() > CFG_FLASH_ERASE_TOUT) if (get_timer_masked () >
{ CFG_FLASH_ERASE_TOUT) {
MEM_FLASH_ADDR1 = CMD_READ_ARRAY; MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
chip = TMO; chip = TMO;
break; break;
} }
if (!chip && (result & 0xFFFF) & BIT_ERASE_DONE) if (!chip
&& (result & 0xFFFF) & BIT_ERASE_DONE)
chip = READY; chip = READY;
if (!chip && (result & 0xFFFF) & BIT_PROGRAM_ERROR) if (!chip
&& (result & 0xFFFF) & BIT_PROGRAM_ERROR)
chip = ERR; chip = ERR;
} while (!chip); } while (!chip);
MEM_FLASH_ADDR1 = CMD_READ_ARRAY; MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
if (chip == ERR) if (chip == ERR) {
{
rc = ERR_PROG_ERROR; rc = ERR_PROG_ERROR;
goto outahere; goto outahere;
} }
if (chip == TMO) if (chip == TMO) {
{
rc = ERR_TIMOUT; rc = ERR_TIMOUT;
goto outahere; goto outahere;
} }
puts("ok.\n"); puts ("ok.\n");
} } else { /* it was protected */
else /* it was protected */
{ puts ("protected!\n");
puts("protected!\n");
} }
} }
if (ctrlc()) if (ctrlc ())
puts("User Interrupt!\n"); puts ("User Interrupt!\n");
outahere: outahere:
/* allow flash to settle - wait 10 ms */ /* allow flash to settle - wait 10 ms */
udelay_masked(10000); udelay_masked (10000);
if (iflag) if (iflag)
enable_interrupts(); enable_interrupts ();
if (cflag) if (cflag)
icache_enable(); icache_enable ();
return rc; return rc;
} }
@ -300,9 +290,9 @@ outahere:
* Copy memory to flash * Copy memory to flash
*/ */
volatile static int write_hword (flash_info_t *info, ulong dest, ushort data) volatile static int write_hword (flash_info_t * info, ulong dest, ushort data)
{ {
vu_short *addr = (vu_short *)dest; vu_short *addr = (vu_short *) dest;
ushort result; ushort result;
int rc = ERR_OK; int rc = ERR_OK;
int cflag, iflag; int cflag, iflag;
@ -323,9 +313,9 @@ volatile static int write_hword (flash_info_t *info, ulong dest, ushort data)
* (ticker) exception to happen while the flash * (ticker) exception to happen while the flash
* chip is in programming mode. * chip is in programming mode.
*/ */
cflag = icache_status(); cflag = icache_status ();
icache_disable(); icache_disable ();
iflag = disable_interrupts(); iflag = disable_interrupts ();
MEM_FLASH_ADDR1 = CMD_UNLOCK1; MEM_FLASH_ADDR1 = CMD_UNLOCK1;
MEM_FLASH_ADDR2 = CMD_UNLOCK2; MEM_FLASH_ADDR2 = CMD_UNLOCK2;
@ -333,25 +323,22 @@ volatile static int write_hword (flash_info_t *info, ulong dest, ushort data)
*addr = data; *addr = data;
/* arm simple, non interrupt dependent timer */ /* arm simple, non interrupt dependent timer */
reset_timer_masked(); reset_timer_masked ();
/* wait until flash is ready */ /* wait until flash is ready */
chip = 0; chip = 0;
do do {
{
result = *addr; result = *addr;
/* check timeout */ /* check timeout */
if (get_timer_masked() > CFG_FLASH_ERASE_TOUT) if (get_timer_masked () > CFG_FLASH_ERASE_TOUT) {
{
chip = ERR | TMO; chip = ERR | TMO;
break; break;
} }
if (!chip && ((result & 0x80) == (data & 0x80))) if (!chip && ((result & 0x80) == (data & 0x80)))
chip = READY; chip = READY;
if (!chip && ((result & 0xFFFF) & BIT_PROGRAM_ERROR)) if (!chip && ((result & 0xFFFF) & BIT_PROGRAM_ERROR)) {
{
result = *addr; result = *addr;
if ((result & 0x80) == (data & 0x80)) if ((result & 0x80) == (data & 0x80))
@ -368,10 +355,10 @@ volatile static int write_hword (flash_info_t *info, ulong dest, ushort data)
rc = ERR_PROG_ERROR; rc = ERR_PROG_ERROR;
if (iflag) if (iflag)
enable_interrupts(); enable_interrupts ();
if (cflag) if (cflag)
icache_enable(); icache_enable ();
return rc; return rc;
} }
@ -380,7 +367,7 @@ volatile static int write_hword (flash_info_t *info, ulong dest, ushort data)
* Copy memory to flash. * Copy memory to flash.
*/ */
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)
{ {
ulong cp, wp; ulong cp, wp;
int l; int l;
@ -394,19 +381,19 @@ int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
*/ */
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 << 8); data = (data >> 8) | (*(uchar *) cp << 8);
} }
for (; i<2 && cnt>0; ++i) { for (; i < 2 && cnt > 0; ++i) {
data = (data >> 8) | (*src++ << 8); data = (data >> 8) | (*src++ << 8);
--cnt; --cnt;
++cp; ++cp;
} }
for (; cnt==0 && i<2; ++i, ++cp) { for (; cnt == 0 && i < 2; ++i, ++cp) {
data = (data >> 8) | (*(uchar *)cp << 8); data = (data >> 8) | (*(uchar *) cp << 8);
} }
if ((rc = write_hword(info, wp, data)) != 0) { if ((rc = write_hword (info, wp, data)) != 0) {
return (rc); return (rc);
} }
wp += 2; wp += 2;
@ -416,8 +403,8 @@ int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
* handle word aligned part * handle word aligned part
*/ */
while (cnt >= 2) { while (cnt >= 2) {
data = *((vu_short*)src); data = *((vu_short *) src);
if ((rc = write_hword(info, wp, data)) != 0) { if ((rc = write_hword (info, wp, data)) != 0) {
return (rc); return (rc);
} }
src += 2; src += 2;
@ -433,13 +420,13 @@ int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
* handle unaligned tail bytes * handle unaligned tail bytes
*/ */
data = 0; data = 0;
for (i=0, cp=wp; i<2 && cnt>0; ++i, ++cp) { for (i = 0, cp = wp; i < 2 && cnt > 0; ++i, ++cp) {
data = (data >> 8) | (*src++ << 8); data = (data >> 8) | (*src++ << 8);
--cnt; --cnt;
} }
for (; i<2; ++i, ++cp) { for (; i < 2; ++i, ++cp) {
data = (data >> 8) | (*(uchar *)cp << 8); data = (data >> 8) | (*(uchar *) cp << 8);
} }
return write_hword(info, wp, data); return write_hword (info, wp, data);
} }

1
board/shannon/flash.c
View File

@ -178,6 +178,7 @@ void flash_print_info (flash_info_t *info)
printf ("\n"); printf ("\n");
Done: Done:
;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------

2
board/smdk2400/flash.c
View File

@ -149,7 +149,7 @@ void flash_print_info (flash_info_t * info)
} }
printf ("\n"); printf ("\n");
Done: Done: ;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------

195
board/smdk2410/flash.c
View File

@ -24,7 +24,7 @@
#include <common.h> #include <common.h>
ulong myflush(void); ulong myflush (void);
#define FLASH_BANK_SIZE PHYS_FLASH_SIZE #define FLASH_BANK_SIZE PHYS_FLASH_SIZE
@ -56,14 +56,14 @@ flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
*/ */
ulong flash_init(void) ulong flash_init (void)
{ {
int i, j; int i, j;
ulong size = 0; ulong size = 0;
for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) {
{
ulong flashbase = 0; ulong flashbase = 0;
flash_info[i].flash_id = flash_info[i].flash_id =
#if defined(CONFIG_AMD_LV400) #if defined(CONFIG_AMD_LV400)
(AMD_MANUFACT & FLASH_VENDMASK) | (AMD_MANUFACT & FLASH_VENDMASK) |
@ -76,92 +76,86 @@ ulong flash_init(void)
#endif #endif
flash_info[i].size = FLASH_BANK_SIZE; flash_info[i].size = FLASH_BANK_SIZE;
flash_info[i].sector_count = CFG_MAX_FLASH_SECT; flash_info[i].sector_count = CFG_MAX_FLASH_SECT;
memset(flash_info[i].protect, 0, CFG_MAX_FLASH_SECT); memset (flash_info[i].protect, 0, CFG_MAX_FLASH_SECT);
if (i == 0) if (i == 0)
flashbase = PHYS_FLASH_1; flashbase = PHYS_FLASH_1;
else else
panic("configured too many flash banks!\n"); panic ("configured too many flash banks!\n");
for (j = 0; j < flash_info[i].sector_count; j++) for (j = 0; j < flash_info[i].sector_count; j++) {
{ if (j <= 3) {
if (j <= 3)
{
/* 1st one is 16 KB */ /* 1st one is 16 KB */
if (j == 0) if (j == 0) {
{ flash_info[i].start[j] =
flash_info[i].start[j] = flashbase + 0; flashbase + 0;
} }
/* 2nd and 3rd are both 8 KB */ /* 2nd and 3rd are both 8 KB */
if ((j == 1) || (j == 2)) if ((j == 1) || (j == 2)) {
{ flash_info[i].start[j] =
flash_info[i].start[j] = flashbase + 0x4000 + (j-1)*0x2000; flashbase + 0x4000 + (j -
1) *
0x2000;
} }
/* 4th 32 KB */ /* 4th 32 KB */
if (j == 3) if (j == 3) {
{ flash_info[i].start[j] =
flash_info[i].start[j] = flashbase + 0x8000; flashbase + 0x8000;
} }
} } else {
else flash_info[i].start[j] =
{ flashbase + (j - 3) * MAIN_SECT_SIZE;
flash_info[i].start[j] = flashbase + (j - 3)*MAIN_SECT_SIZE;
} }
} }
size += flash_info[i].size; size += flash_info[i].size;
} }
flash_protect(FLAG_PROTECT_SET, flash_protect (FLAG_PROTECT_SET,
CFG_FLASH_BASE, CFG_FLASH_BASE,
CFG_FLASH_BASE + monitor_flash_len - 1, CFG_FLASH_BASE + monitor_flash_len - 1,
&flash_info[0]); &flash_info[0]);
flash_protect(FLAG_PROTECT_SET, flash_protect (FLAG_PROTECT_SET,
CFG_ENV_ADDR, CFG_ENV_ADDR,
CFG_ENV_ADDR + CFG_ENV_SIZE - 1, CFG_ENV_ADDR + CFG_ENV_SIZE - 1, &flash_info[0]);
&flash_info[0]);
return size; return size;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
*/ */
void flash_print_info (flash_info_t *info) void flash_print_info (flash_info_t * info)
{ {
int i; int i;
switch (info->flash_id & FLASH_VENDMASK) switch (info->flash_id & FLASH_VENDMASK) {
{
case (AMD_MANUFACT & FLASH_VENDMASK): case (AMD_MANUFACT & FLASH_VENDMASK):
printf("AMD: "); printf ("AMD: ");
break; break;
default: default:
printf("Unknown Vendor "); printf ("Unknown Vendor ");
break; break;
} }
switch (info->flash_id & FLASH_TYPEMASK) switch (info->flash_id & FLASH_TYPEMASK) {
{
case (AMD_ID_LV400B & FLASH_TYPEMASK): case (AMD_ID_LV400B & FLASH_TYPEMASK):
printf("1x Amd29LV400BB (4Mbit)\n"); printf ("1x Amd29LV400BB (4Mbit)\n");
break; break;
case (AMD_ID_LV800B & FLASH_TYPEMASK): case (AMD_ID_LV800B & FLASH_TYPEMASK):
printf("1x Amd29LV800BB (8Mbit)\n"); printf ("1x Amd29LV800BB (8Mbit)\n");
break; break;
default: default:
printf("Unknown Chip Type\n"); printf ("Unknown Chip Type\n");
goto Done; goto Done;
break; break;
} }
printf(" Size: %ld MB in %d Sectors\n", printf (" Size: %ld MB in %d Sectors\n",
info->size >> 20, info->sector_count); info->size >> 20, info->sector_count);
printf(" Sector Start Addresses:"); printf (" Sector Start Addresses:");
for (i = 0; i < info->sector_count; i++) for (i = 0; i < info->sector_count; i++) {
{ if ((i % 5) == 0) {
if ((i % 5) == 0)
{
printf ("\n "); printf ("\n ");
} }
printf (" %08lX%s", info->start[i], printf (" %08lX%s", info->start[i],
@ -169,13 +163,13 @@ void flash_print_info (flash_info_t *info)
} }
printf ("\n"); printf ("\n");
Done: Done:;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------
*/ */
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)
{ {
ushort result; ushort result;
int iflag, cflag, prot, sect; int iflag, cflag, prot, sect;
@ -197,7 +191,7 @@ int flash_erase (flash_info_t *info, int s_first, int s_last)
} }
prot = 0; prot = 0;
for (sect=s_first; sect<=s_last; ++sect) { for (sect = s_first; sect <= s_last; ++sect) {
if (info->protect[sect]) { if (info->protect[sect]) {
prot++; prot++;
} }
@ -212,21 +206,19 @@ int flash_erase (flash_info_t *info, int s_first, int s_last)
* (ticker) exception to happen while the flash * (ticker) exception to happen while the flash
* chip is in programming mode. * chip is in programming mode.
*/ */
cflag = icache_status(); cflag = icache_status ();
icache_disable(); icache_disable ();
iflag = disable_interrupts(); iflag = disable_interrupts ();
/* Start erase on unprotected sectors */ /* Start erase on unprotected sectors */
for (sect = s_first; sect<=s_last && !ctrlc(); sect++) for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
{ printf ("Erasing sector %2d ... ", sect);
printf("Erasing sector %2d ... ", sect);
/* arm simple, non interrupt dependent timer */ /* arm simple, non interrupt dependent timer */
reset_timer_masked(); reset_timer_masked ();
if (info->protect[sect] == 0) if (info->protect[sect] == 0) { /* not protected */
{ /* not protected */ vu_short *addr = (vu_short *) (info->start[sect]);
vu_short *addr = (vu_short *)(info->start[sect]);
MEM_FLASH_ADDR1 = CMD_UNLOCK1; MEM_FLASH_ADDR1 = CMD_UNLOCK1;
MEM_FLASH_ADDR2 = CMD_UNLOCK2; MEM_FLASH_ADDR2 = CMD_UNLOCK2;
@ -239,59 +231,57 @@ int flash_erase (flash_info_t *info, int s_first, int s_last)
/* wait until flash is ready */ /* wait until flash is ready */
chip = 0; chip = 0;
do do {
{
result = *addr; result = *addr;
/* check timeout */ /* check timeout */
if (get_timer_masked() > CFG_FLASH_ERASE_TOUT) if (get_timer_masked () >
{ CFG_FLASH_ERASE_TOUT) {
MEM_FLASH_ADDR1 = CMD_READ_ARRAY; MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
chip = TMO; chip = TMO;
break; break;
} }
if (!chip && (result & 0xFFFF) & BIT_ERASE_DONE) if (!chip
&& (result & 0xFFFF) & BIT_ERASE_DONE)
chip = READY; chip = READY;
if (!chip && (result & 0xFFFF) & BIT_PROGRAM_ERROR) if (!chip
&& (result & 0xFFFF) & BIT_PROGRAM_ERROR)
chip = ERR; chip = ERR;
} while (!chip); } while (!chip);
MEM_FLASH_ADDR1 = CMD_READ_ARRAY; MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
if (chip == ERR) if (chip == ERR) {
{
rc = ERR_PROG_ERROR; rc = ERR_PROG_ERROR;
goto outahere; goto outahere;
} }
if (chip == TMO) if (chip == TMO) {
{
rc = ERR_TIMOUT; rc = ERR_TIMOUT;
goto outahere; goto outahere;
} }
printf("ok.\n"); printf ("ok.\n");
} } else { /* it was protected */
else /* it was protected */
{ printf ("protected!\n");
printf("protected!\n");
} }
} }
if (ctrlc()) if (ctrlc ())
printf("User Interrupt!\n"); printf ("User Interrupt!\n");
outahere: outahere:
/* allow flash to settle - wait 10 ms */ /* allow flash to settle - wait 10 ms */
udelay_masked(10000); udelay_masked (10000);
if (iflag) if (iflag)
enable_interrupts(); enable_interrupts ();
if (cflag) if (cflag)
icache_enable(); icache_enable ();
return rc; return rc;
} }
@ -300,9 +290,9 @@ outahere:
* Copy memory to flash * Copy memory to flash
*/ */
volatile static int write_hword (flash_info_t *info, ulong dest, ushort data) volatile static int write_hword (flash_info_t * info, ulong dest, ushort data)
{ {
vu_short *addr = (vu_short *)dest; vu_short *addr = (vu_short *) dest;
ushort result; ushort result;
int rc = ERR_OK; int rc = ERR_OK;
int cflag, iflag; int cflag, iflag;
@ -323,9 +313,9 @@ volatile static int write_hword (flash_info_t *info, ulong dest, ushort data)
* (ticker) exception to happen while the flash * (ticker) exception to happen while the flash
* chip is in programming mode. * chip is in programming mode.
*/ */
cflag = icache_status(); cflag = icache_status ();
icache_disable(); icache_disable ();
iflag = disable_interrupts(); iflag = disable_interrupts ();
MEM_FLASH_ADDR1 = CMD_UNLOCK1; MEM_FLASH_ADDR1 = CMD_UNLOCK1;
MEM_FLASH_ADDR2 = CMD_UNLOCK2; MEM_FLASH_ADDR2 = CMD_UNLOCK2;
@ -334,25 +324,22 @@ volatile static int write_hword (flash_info_t *info, ulong dest, ushort data)
*addr = data; *addr = data;
/* arm simple, non interrupt dependent timer */ /* arm simple, non interrupt dependent timer */
reset_timer_masked(); reset_timer_masked ();
/* wait until flash is ready */ /* wait until flash is ready */
chip = 0; chip = 0;
do do {
{
result = *addr; result = *addr;
/* check timeout */ /* check timeout */
if (get_timer_masked() > CFG_FLASH_ERASE_TOUT) if (get_timer_masked () > CFG_FLASH_ERASE_TOUT) {
{
chip = ERR | TMO; chip = ERR | TMO;
break; break;
} }
if (!chip && ((result & 0x80) == (data & 0x80))) if (!chip && ((result & 0x80) == (data & 0x80)))
chip = READY; chip = READY;
if (!chip && ((result & 0xFFFF) & BIT_PROGRAM_ERROR)) if (!chip && ((result & 0xFFFF) & BIT_PROGRAM_ERROR)) {
{
result = *addr; result = *addr;
if ((result & 0x80) == (data & 0x80)) if ((result & 0x80) == (data & 0x80))
@ -369,10 +356,10 @@ volatile static int write_hword (flash_info_t *info, ulong dest, ushort data)
rc = ERR_PROG_ERROR; rc = ERR_PROG_ERROR;
if (iflag) if (iflag)
enable_interrupts(); enable_interrupts ();
if (cflag) if (cflag)
icache_enable(); icache_enable ();
return rc; return rc;
} }
@ -381,7 +368,7 @@ volatile static int write_hword (flash_info_t *info, ulong dest, ushort data)
* Copy memory to flash. * Copy memory to flash.
*/ */
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)
{ {
ulong cp, wp; ulong cp, wp;
int l; int l;
@ -395,19 +382,19 @@ int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
*/ */
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 << 8); data = (data >> 8) | (*(uchar *) cp << 8);
} }
for (; i<2 && cnt>0; ++i) { for (; i < 2 && cnt > 0; ++i) {
data = (data >> 8) | (*src++ << 8); data = (data >> 8) | (*src++ << 8);
--cnt; --cnt;
++cp; ++cp;
} }
for (; cnt==0 && i<2; ++i, ++cp) { for (; cnt == 0 && i < 2; ++i, ++cp) {
data = (data >> 8) | (*(uchar *)cp << 8); data = (data >> 8) | (*(uchar *) cp << 8);
} }
if ((rc = write_hword(info, wp, data)) != 0) { if ((rc = write_hword (info, wp, data)) != 0) {
return (rc); return (rc);
} }
wp += 2; wp += 2;
@ -417,8 +404,8 @@ int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
* handle word aligned part * handle word aligned part
*/ */
while (cnt >= 2) { while (cnt >= 2) {
data = *((vu_short*)src); data = *((vu_short *) src);
if ((rc = write_hword(info, wp, data)) != 0) { if ((rc = write_hword (info, wp, data)) != 0) {
return (rc); return (rc);
} }
src += 2; src += 2;
@ -434,13 +421,13 @@ int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
* handle unaligned tail bytes * handle unaligned tail bytes
*/ */
data = 0; data = 0;
for (i=0, cp=wp; i<2 && cnt>0; ++i, ++cp) { for (i = 0, cp = wp; i < 2 && cnt > 0; ++i, ++cp) {
data = (data >> 8) | (*src++ << 8); data = (data >> 8) | (*src++ << 8);
--cnt; --cnt;
} }
for (; i<2; ++i, ++cp) { for (; i < 2; ++i, ++cp) {
data = (data >> 8) | (*(uchar *)cp << 8); data = (data >> 8) | (*(uchar *) cp << 8);
} }
return write_hword(info, wp, data); return write_hword (info, wp, data);
} }

1
board/trab/cmd_trab.c
View File

@ -718,6 +718,7 @@ static void led_set (unsigned int state)
gpio->PADAT &= ~(1 << 12); gpio->PADAT &= ~(1 << 12);
break; break;
default: default:
break;
} }
} }

2
board/trab/flash.c
View File

@ -166,7 +166,7 @@ void flash_print_info (flash_info_t * info)
} }
printf ("\n"); printf ("\n");
Done: Done: ;
} }
/*----------------------------------------------------------------------- /*-----------------------------------------------------------------------

2
board/trab/memory.c
View File

@ -479,7 +479,7 @@ int memory_post_test (int flags)
return ret; return ret;
} }
#endif 0 #endif /* 0 */
/* #endif */ /* CONFIG_POST & CFG_POST_MEMORY */ /* #endif */ /* CONFIG_POST & CFG_POST_MEMORY */
/* #endif */ /* CONFIG_POST */ /* #endif */ /* CONFIG_POST */

2
board/trab/trab_fkt.c
View File

@ -35,7 +35,7 @@
* command do_touch is invoked and the touch is not pressed within an specific * command do_touch is invoked and the touch is not pressed within an specific
* interval. * interval.
*/ */
#undef CONFIG_TOUCH_WAIT_PRESSED 1 #undef CONFIG_TOUCH_WAIT_PRESSED
/* max time to wait for touch is pressed */ /* max time to wait for touch is pressed */
#ifndef CONFIG_TOUCH_WAIT_PRESSED #ifndef CONFIG_TOUCH_WAIT_PRESSED

1
board/versatile/flash.c
View File

@ -239,7 +239,6 @@ static ulong flash_get_size (FPW * addr, flash_info_t * info)
info->flash_id += FLASH_28F256K3; info->flash_id += FLASH_28F256K3;
info->sector_count = 256; info->sector_count = 256;
info->size = 0x02000000; info->size = 0x02000000;
printf ("\Intel StrataFlash 28F256K3C device initialized\n");
break; break;
default: default:

2
board/xsengine/Makefile
View File

@ -40,7 +40,7 @@ distclean: clean
######################################################################### #########################################################################
.depend: Makefile $(SOBJS:.o=.S) $(OBJS:.o=.c) .depend: Makefile $(SOBJS:.o=.S) $(OBJS:.o=.c)
$(CC) -M --disassemble-all $(CPPFLAGS) $(SOBJS:.o=.S) $(OBJS:.o=.c) > $@ $(CC) -M $(CPPFLAGS) $(SOBJS:.o=.S) $(OBJS:.o=.c) > $@
-include .depend -include .depend

4
common/usb.c
View File

@ -925,7 +925,9 @@ int usb_hub_configure(struct usb_device *dev)
} }
descriptor = (struct usb_hub_descriptor *)buffer; descriptor = (struct usb_hub_descriptor *)buffer;
if (descriptor->bLength > USB_BUFSIZ) { /* silence compiler warning if USB_BUFSIZ is > 256 [= sizeof(char)] */
i = descriptor->bLength;
if (i > USB_BUFSIZ) {
USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor - too long: %d\N", USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor - too long: %d\N",
descriptor->bLength); descriptor->bLength);
return -1; return -1;

1
cpu/arm720t/serial_netarm.c
View File

@ -169,6 +169,7 @@ int serial_getc (void)
break; break;
default: default:
/* panic, be never here */ /* panic, be never here */
break;
} }
serial_reg_ch1->status_a |= NETARM_SER_STATA_RX_CLOSED; serial_reg_ch1->status_a |= NETARM_SER_STATA_RX_CLOSED;

2
cpu/s3c44b0/cpu.c
View File

@ -272,7 +272,7 @@ int i2c_probe(uchar chip)
not implemented not implemented
*/ */
printf(__FUNCTION__ " chip %d\n", (int) chip); printf("i2c_probe chip %d\n", (int) chip);
return -1; return -1;
} }

6
cpu/s3c44b0/serial.c
View File

@ -112,7 +112,7 @@ void serial_setbrg (void)
divisor = 121; divisor = 121;
#else #else
# error CONFIG_S3C44B0_CLOCK_SPEED undefined # error CONFIG_S3C44B0_CLOCK_SPEED undefined
#endif break; #endif /* break; */
case 57600: case 57600:
#if CONFIG_S3C44B0_CLOCK_SPEED==66 #if CONFIG_S3C44B0_CLOCK_SPEED==66
@ -121,7 +121,7 @@ void serial_setbrg (void)
divisor = 80; divisor = 80;
#else #else
# error CONFIG_S3C44B0_CLOCK_SPEED undefined # error CONFIG_S3C44B0_CLOCK_SPEED undefined
#endif break; #endif /* break; */
case 115200: case 115200:
#if CONFIG_S3C44B0_CLOCK_SPEED==66 #if CONFIG_S3C44B0_CLOCK_SPEED==66
@ -130,7 +130,7 @@ void serial_setbrg (void)
divisor = 40; divisor = 40;
#else #else
# error CONFIG_S3C44B0_CLOCK_SPEED undefined # error CONFIG_S3C44B0_CLOCK_SPEED undefined
#endif break; #endif /* break; */
} }
serial_flush_output(); serial_flush_output();

2
drivers/s3c4510b_eth.c
View File

@ -170,7 +170,7 @@ s32 eth_send(volatile void *packet, s32 length)
ETH *eth = &m_eth; ETH *eth = &m_eth;
if ( eth->m_curTX_FD->m_frameDataPtr.bf.owner) { if ( eth->m_curTX_FD->m_frameDataPtr.bf.owner) {
printf(__FUNCTION__"(): TX Frame. CPU not owner.\n"); printf("eth_send(): TX Frame. CPU not owner.\n");
return -1; return -1;
} }

122
include/cmd_confdefs.h
View File

@ -30,68 +30,68 @@
/* /*
* Configurable monitor commands * Configurable monitor commands
*/ */
#define CFG_CMD_BDI 0x00000001U /* bdinfo */ #define CFG_CMD_BDI 0x00000001ULL /* bdinfo */
#define CFG_CMD_LOADS 0x00000002U /* loads */ #define CFG_CMD_LOADS 0x00000002ULL /* loads */
#define CFG_CMD_LOADB 0x00000004U /* loadb */ #define CFG_CMD_LOADB 0x00000004ULL /* loadb */
#define CFG_CMD_IMI 0x00000008U /* iminfo */ #define CFG_CMD_IMI 0x00000008ULL /* iminfo */
#define CFG_CMD_CACHE 0x00000010U /* icache, dcache */ #define CFG_CMD_CACHE 0x00000010ULL /* icache, dcache */
#define CFG_CMD_FLASH 0x00000020U /* flinfo, erase, protect */ #define CFG_CMD_FLASH 0x00000020ULL /* flinfo, erase, protect */
#define CFG_CMD_MEMORY 0x00000040U /* md, mm, nm, mw, cp, cmp, */ #define CFG_CMD_MEMORY 0x00000040ULL /* md, mm, nm, mw, cp, cmp, */
/* crc, base, loop, mtest */ /* crc, base, loop, mtest */
#define CFG_CMD_NET 0x00000080U /* bootp, tftpboot, rarpboot */ #define CFG_CMD_NET 0x00000080ULL /* bootp, tftpboot, rarpboot */
#define CFG_CMD_ENV 0x00000100U /* saveenv */ #define CFG_CMD_ENV 0x00000100ULL /* saveenv */
#define CFG_CMD_KGDB 0x00000200U /* kgdb */ #define CFG_CMD_KGDB 0x00000200ULL /* kgdb */
#define CFG_CMD_PCMCIA 0x00000400U /* PCMCIA support */ #define CFG_CMD_PCMCIA 0x00000400ULL /* PCMCIA support */
#define CFG_CMD_IDE 0x00000800U /* IDE harddisk support */ #define CFG_CMD_IDE 0x00000800ULL /* IDE harddisk support */
#define CFG_CMD_PCI 0x00001000U /* pciinfo */ #define CFG_CMD_PCI 0x00001000ULL /* pciinfo */
#define CFG_CMD_IRQ 0x00002000U /* irqinfo */ #define CFG_CMD_IRQ 0x00002000ULL /* irqinfo */
#define CFG_CMD_BOOTD 0x00004000U /* bootd */ #define CFG_CMD_BOOTD 0x00004000ULL /* bootd */
#define CFG_CMD_CONSOLE 0x00008000U /* coninfo */ #define CFG_CMD_CONSOLE 0x00008000ULL /* coninfo */
#define CFG_CMD_EEPROM 0x00010000U /* EEPROM read/write support */ #define CFG_CMD_EEPROM 0x00010000ULL /* EEPROM read/write support */
#define CFG_CMD_ASKENV 0x00020000U /* ask for env variable */ #define CFG_CMD_ASKENV 0x00020000ULL /* ask for env variable */
#define CFG_CMD_RUN 0x00040000U /* run command in env variable */ #define CFG_CMD_RUN 0x00040000ULL /* run command in env variable */
#define CFG_CMD_ECHO 0x00080000U /* echo arguments */ #define CFG_CMD_ECHO 0x00080000ULL /* echo arguments */
#define CFG_CMD_I2C 0x00100000U /* I2C serial bus support */ #define CFG_CMD_I2C 0x00100000ULL /* I2C serial bus support */
#define CFG_CMD_REGINFO 0x00200000U /* Register dump */ #define CFG_CMD_REGINFO 0x00200000ULL /* Register dump */
#define CFG_CMD_IMMAP 0x00400000U /* IMMR dump support */ #define CFG_CMD_IMMAP 0x00400000ULL /* IMMR dump support */
#define CFG_CMD_DATE 0x00800000U /* support for RTC, date/time...*/ #define CFG_CMD_DATE 0x00800000ULL /* support for RTC, date/time...*/
#define CFG_CMD_DHCP 0x01000000U /* DHCP Support */ #define CFG_CMD_DHCP 0x01000000ULL /* DHCP Support */
#define CFG_CMD_BEDBUG 0x02000000U /* Include BedBug Debugger */ #define CFG_CMD_BEDBUG 0x02000000ULL /* Include BedBug Debugger */
#define CFG_CMD_FDC 0x04000000U /* Floppy Disk Support */ #define CFG_CMD_FDC 0x04000000ULL /* Floppy Disk Support */
#define CFG_CMD_SCSI 0x08000000U /* SCSI Support */ #define CFG_CMD_SCSI 0x08000000ULL /* SCSI Support */
#define CFG_CMD_AUTOSCRIPT 0x10000000U /* Autoscript Support */ #define CFG_CMD_AUTOSCRIPT 0x10000000ULL /* Autoscript Support */
#define CFG_CMD_MII 0x20000000U /* MII support */ #define CFG_CMD_MII 0x20000000ULL /* MII support */
#define CFG_CMD_SETGETDCR 0x40000000U /* DCR support on 4xx */ #define CFG_CMD_SETGETDCR 0x40000000ULL /* DCR support on 4xx */
#define CFG_CMD_BSP 0x80000000U /* Board Specific functions */ #define CFG_CMD_BSP 0x80000000ULL /* Board Specific functions */
#define CFG_CMD_ELF 0x0000000100000000U /* ELF (VxWorks) load/boot cmd */ #define CFG_CMD_ELF 0x0000000100000000ULL /* ELF (VxWorks) load/boot cmd */
#define CFG_CMD_MISC 0x0000000200000000U /* Misc functions like sleep etc*/ #define CFG_CMD_MISC 0x0000000200000000ULL /* Misc functions like sleep etc*/
#define CFG_CMD_USB 0x0000000400000000U /* USB Support */ #define CFG_CMD_USB 0x0000000400000000ULL /* USB Support */
#define CFG_CMD_DOC 0x0000000800000000U /* Disk-On-Chip Support */ #define CFG_CMD_DOC 0x0000000800000000ULL /* Disk-On-Chip Support */
#define CFG_CMD_JFFS2 0x0000001000000000U /* JFFS2 Support */ #define CFG_CMD_JFFS2 0x0000001000000000ULL /* JFFS2 Support */
#define CFG_CMD_DTT 0x0000002000000000U /* Digital Therm and Thermostat */ #define CFG_CMD_DTT 0x0000002000000000ULL /* Digital Therm and Thermostat */
#define CFG_CMD_SDRAM 0x0000004000000000U /* SDRAM DIMM SPD info printout */ #define CFG_CMD_SDRAM 0x0000004000000000ULL /* SDRAM DIMM SPD info printout */
#define CFG_CMD_DIAG 0x0000008000000000U /* Diagnostics */ #define CFG_CMD_DIAG 0x0000008000000000ULL /* Diagnostics */
#define CFG_CMD_FPGA 0x0000010000000000U /* FPGA configuration Support */ #define CFG_CMD_FPGA 0x0000010000000000ULL /* FPGA configuration Support */
#define CFG_CMD_HWFLOW 0x0000020000000000U /* RTS/CTS hw flow control */ #define CFG_CMD_HWFLOW 0x0000020000000000ULL /* RTS/CTS hw flow control */
#define CFG_CMD_SAVES 0x0000040000000000U /* save S record dump */ #define CFG_CMD_SAVES 0x0000040000000000ULL /* save S record dump */
#define CFG_CMD_SPI 0x0000100000000000U /* SPI utility */ #define CFG_CMD_SPI 0x0000100000000000ULL /* SPI utility */
#define CFG_CMD_FDOS 0x0000200000000000U /* Floppy DOS support */ #define CFG_CMD_FDOS 0x0000200000000000ULL /* Floppy DOS support */
#define CFG_CMD_VFD 0x0000400000000000U /* VFD support (TRAB) */ #define CFG_CMD_VFD 0x0000400000000000ULL /* VFD support (TRAB) */
#define CFG_CMD_NAND 0x0000800000000000U /* NAND support */ #define CFG_CMD_NAND 0x0000800000000000ULL /* NAND support */
#define CFG_CMD_BMP 0x0001000000000000U /* BMP support */ #define CFG_CMD_BMP 0x0001000000000000ULL /* BMP support */
#define CFG_CMD_PORTIO 0x0002000000000000U /* Port I/O */ #define CFG_CMD_PORTIO 0x0002000000000000ULL /* Port I/O */
#define CFG_CMD_PING 0x0004000000000000U /* ping support */ #define CFG_CMD_PING 0x0004000000000000ULL /* ping support */
#define CFG_CMD_MMC 0x0008000000000000U /* MMC support */ #define CFG_CMD_MMC 0x0008000000000000ULL /* MMC support */
#define CFG_CMD_FAT 0x0010000000000000U /* FAT support */ #define CFG_CMD_FAT 0x0010000000000000ULL /* FAT support */
#define CFG_CMD_IMLS 0x0020000000000000U /* List all found images */ #define CFG_CMD_IMLS 0x0020000000000000ULL /* List all found images */
#define CFG_CMD_ITEST 0x0040000000000000U /* Integer (and string) test */ #define CFG_CMD_ITEST 0x0040000000000000ULL /* Integer (and string) test */
#define CFG_CMD_NFS 0x0080000000000000U /* NFS support */ #define CFG_CMD_NFS 0x0080000000000000ULL /* NFS support */
#define CFG_CMD_REISER 0x0100000000000000U /* Reiserfs support */ #define CFG_CMD_REISER 0x0100000000000000ULL /* Reiserfs support */
#define CFG_CMD_CDP 0x0200000000000000U /* Cisco Discovery Protocol */ #define CFG_CMD_CDP 0x0200000000000000ULL /* Cisco Discovery Protocol */
#define CFG_CMD_XIMG 0x0400000000000000U /* Load part of Multi Image */ #define CFG_CMD_XIMG 0x0400000000000000ULL /* Load part of Multi Image */
#define CFG_CMD_ALL 0xFFFFFFFFFFFFFFFFU /* ALL commands */ #define CFG_CMD_ALL 0xFFFFFFFFFFFFFFFFULL /* ALL commands */
/* Commands that are considered "non-standard" for some reason /* Commands that are considered "non-standard" for some reason
* (memory hogs, requires special hardware, not fully tested, etc.) * (memory hogs, requires special hardware, not fully tested, etc.)
@ -101,6 +101,7 @@
CFG_CMD_BMP | \ CFG_CMD_BMP | \
CFG_CMD_BSP | \ CFG_CMD_BSP | \
CFG_CMD_CACHE | \ CFG_CMD_CACHE | \
CFG_CMD_CDP | \
CFG_CMD_DATE | \ CFG_CMD_DATE | \
CFG_CMD_DHCP | \ CFG_CMD_DHCP | \
CFG_CMD_DIAG | \ CFG_CMD_DIAG | \
@ -133,8 +134,7 @@
CFG_CMD_SDRAM | \ CFG_CMD_SDRAM | \
CFG_CMD_SPI | \ CFG_CMD_SPI | \
CFG_CMD_USB | \ CFG_CMD_USB | \
CFG_CMD_VFD | \ CFG_CMD_VFD )
CFG_CMD_CDP )
/* Default configuration /* Default configuration
*/ */

2
include/configs/xaeniax.h
View File

@ -69,7 +69,7 @@
#define CFG_BAUDRATE_TABLE { 9600, 19200, 38400, 57600, 115200 } /* valid baudrates */ #define CFG_BAUDRATE_TABLE { 9600, 19200, 38400, 57600, 115200 } /* valid baudrates */
#define CONFIG_COMMANDS (CONFIG_CMD_DFL | CFG_CMD_DIAG | CFG_CMD_SDRAM & ~CONFIG_CMD_DTT) #define CONFIG_COMMANDS ((CONFIG_CMD_DFL | CFG_CMD_DIAG | CFG_CMD_SDRAM) & ~CFG_CMD_DTT)
/* this must be included AFTER the definition of CONFIG_COMMANDS (if any) */ /* this must be included AFTER the definition of CONFIG_COMMANDS (if any) */
#include <cmd_confdefs.h> #include <cmd_confdefs.h>