Initial revision
This commit is contained in:
wdenk
parent
f18f47f4d4
commit
afd7f3d0de
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,523 @@
|
|||
/*
|
||||
* (C) Copyright 2000
|
||||
* Marius Groeger <mgroeger@sysgo.de>
|
||||
* Sysgo Real-Time Solutions, GmbH <www.elinos.com>
|
||||
*
|
||||
* (C) Copyright 2000, 2001
|
||||
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
||||
*
|
||||
* (C) Copyright 2001
|
||||
* Advent Networks, Inc. <http://www.adventnetworks.com>
|
||||
* Oliver Brown <oliverb@alumni.utexas.net>
|
||||
*
|
||||
*--------------------------------------------------------------------
|
||||
* See file CREDITS for list of people who contributed to this
|
||||
* project.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
||||
* MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
/*********************************************************************/
|
||||
/* DESCRIPTION:
|
||||
* This file contains the flash routines for the GW8260 board.
|
||||
*
|
||||
*
|
||||
*
|
||||
* MODULE DEPENDENCY:
|
||||
* None
|
||||
*
|
||||
*
|
||||
* RESTRICTIONS/LIMITATIONS:
|
||||
*
|
||||
* Only supports the following flash devices:
|
||||
* AMD 29F080B
|
||||
* AMD 29F016D
|
||||
*
|
||||
* Copyright (c) 2001, Advent Networks, Inc.
|
||||
*
|
||||
*/
|
||||
/*********************************************************************/
|
||||
|
||||
#include <common.h>
|
||||
#include <mpc8260.h>
|
||||
|
||||
flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
|
||||
|
||||
static ulong flash_get_size (vu_long *addr, flash_info_t *info);
|
||||
static int write_word (flash_info_t *info, ulong dest, ulong data);
|
||||
|
||||
/*********************************************************************/
|
||||
/* functions */
|
||||
/*********************************************************************/
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: flash_init() - initializes flash banks */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* This function initializes the flash bank(s). */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* The size in bytes of the flash */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
unsigned long flash_init (void)
|
||||
{
|
||||
unsigned long size;
|
||||
int i;
|
||||
|
||||
/* Init: no FLASHes known */
|
||||
for (i=0; i<CFG_MAX_FLASH_BANKS; ++i) {
|
||||
flash_info[i].flash_id = FLASH_UNKNOWN;
|
||||
}
|
||||
|
||||
/* for now, only support the 4 MB Flash SIMM */
|
||||
size = flash_get_size((vu_long *)CFG_FLASH0_BASE, &flash_info[0]);
|
||||
|
||||
/*
|
||||
* protect monitor and environment sectors
|
||||
*/
|
||||
|
||||
#if CFG_MONITOR_BASE >= CFG_FLASH0_BASE
|
||||
flash_protect(FLAG_PROTECT_SET,
|
||||
CFG_MONITOR_BASE,
|
||||
CFG_MONITOR_BASE+CFG_MONITOR_LEN-1,
|
||||
&flash_info[0]);
|
||||
#endif
|
||||
|
||||
#if (CFG_ENV_IS_IN_FLASH == 1) && defined(CFG_ENV_ADDR)
|
||||
# ifndef CFG_ENV_SIZE
|
||||
# define CFG_ENV_SIZE CFG_ENV_SECT_SIZE
|
||||
# endif
|
||||
flash_protect(FLAG_PROTECT_SET,
|
||||
CFG_ENV_ADDR,
|
||||
CFG_ENV_ADDR + CFG_ENV_SIZE - 1,
|
||||
&flash_info[0]);
|
||||
#endif
|
||||
|
||||
return (CFG_FLASH0_SIZE * 1024 * 1024); /*size*/
|
||||
}
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: flash_print_info() - prints flash imformation */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* This function prints the flash information. */
|
||||
/* */
|
||||
/* INPUTS: */
|
||||
/* flash_info_t *info - flash information structure */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* Displays flash information to console */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* None */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
void flash_print_info (flash_info_t *info)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (info->flash_id == FLASH_UNKNOWN) {
|
||||
printf ("missing or unknown FLASH type\n");
|
||||
return;
|
||||
}
|
||||
|
||||
switch ((info->flash_id >> 16) & 0xff) {
|
||||
case 0x1:
|
||||
printf ("AMD ");
|
||||
break;
|
||||
default:
|
||||
printf ("Unknown Vendor ");
|
||||
break;
|
||||
}
|
||||
|
||||
switch (info->flash_id & FLASH_TYPEMASK) {
|
||||
case AMD_ID_F040B:
|
||||
printf ("AM29F040B (4 Mbit)\n");
|
||||
break;
|
||||
case AMD_ID_F080B:
|
||||
printf ("AM29F080B (8 Mbit)\n");
|
||||
break;
|
||||
case AMD_ID_F016D:
|
||||
printf ("AM29F016D (16 Mbit)\n");
|
||||
break;
|
||||
default:
|
||||
printf ("Unknown Chip Type\n");
|
||||
break;
|
||||
}
|
||||
|
||||
printf (" Size: %ld MB in %d Sectors\n",
|
||||
info->size >> 20, info->sector_count);
|
||||
|
||||
printf (" Sector Start Addresses:");
|
||||
for (i=0; i<info->sector_count; ++i) {
|
||||
if ((i % 5) == 0)
|
||||
printf ("\n ");
|
||||
printf (" %08lX%s",
|
||||
info->start[i],
|
||||
info->protect[i] ? " (RO)" : " "
|
||||
);
|
||||
}
|
||||
printf ("\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/*********************************************************************/
|
||||
/* The following code cannot be run from FLASH! */
|
||||
/*********************************************************************/
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: flash_get_size() - detects the flash size */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* 1) Reads vendor ID and devices ID from the flash devices. */
|
||||
/* 2) Initializes flash info struct. */
|
||||
/* 3) Return the flash size */
|
||||
/* */
|
||||
/* INPUTS: */
|
||||
/* vu_long *addr - pointer to start of flash */
|
||||
/* flash_info_t *info - flash information structure */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* None */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* Size of the flash in bytes, or 0 if device id is unknown. */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* Only supports the following devices: */
|
||||
/* AM29F080D */
|
||||
/* AM29F016D */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
static ulong flash_get_size (vu_long *addr, flash_info_t *info)
|
||||
{
|
||||
short i;
|
||||
vu_long vendor, devid;
|
||||
ulong base = (ulong)addr;
|
||||
|
||||
/*printf("addr = %08lx\n", (unsigned long)addr); */
|
||||
|
||||
/* Reset and Write auto select command: read Manufacturer ID */
|
||||
addr[0x0000] = 0xf0f0f0f0;
|
||||
addr[0x0555] = 0xAAAAAAAA;
|
||||
addr[0x02AA] = 0x55555555;
|
||||
addr[0x0555] = 0x90909090;
|
||||
udelay (1000);
|
||||
|
||||
vendor = addr[0];
|
||||
/*printf("vendor = %08lx\n", vendor); */
|
||||
if (vendor != 0x01010101) {
|
||||
info->size = 0;
|
||||
goto out;
|
||||
}
|
||||
|
||||
devid = addr[1];
|
||||
/*printf("devid = %08lx\n", devid); */
|
||||
|
||||
if ((devid & 0xff) == AMD_ID_F080B) {
|
||||
info->flash_id = (vendor & 0xff) << 16 | AMD_ID_F080B;
|
||||
/* we have 16 sectors with 64KB each x 4 */
|
||||
info->sector_count = 16;
|
||||
info->size = 4 * info->sector_count * 64*1024;
|
||||
} else if ((devid & 0xff) == AMD_ID_F016D){
|
||||
info->flash_id = (vendor & 0xff) << 16 | AMD_ID_F016D;
|
||||
/* we have 32 sectors with 64KB each x 4 */
|
||||
info->sector_count = 32;
|
||||
info->size = 4 * info->sector_count * 64*1024;
|
||||
} else {
|
||||
info->size = 0;
|
||||
goto out;
|
||||
}
|
||||
/*printf("sector count = %08x\n", info->sector_count); */
|
||||
/* check for protected sectors */
|
||||
for (i = 0; i < info->sector_count; i++) {
|
||||
/* sector base address */
|
||||
info->start[i] = base + i * (info->size / info->sector_count);
|
||||
/* read sector protection at sector address, (A7 .. A0) = 0x02 */
|
||||
/* D0 = 1 if protected */
|
||||
addr = (volatile unsigned long *)(info->start[i]);
|
||||
info->protect[i] = addr[2] & 1;
|
||||
}
|
||||
|
||||
/* reset command */
|
||||
addr = (vu_long *)info->start[0];
|
||||
|
||||
out:
|
||||
addr[0] = 0xf0f0f0f0;
|
||||
|
||||
/*printf("size = %08x\n", info->size); */
|
||||
return info->size;
|
||||
}
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: flash_erase() - erases flash by sector */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* This function erases flash sectors starting for s_first to */
|
||||
/* s_last. */
|
||||
/* */
|
||||
/* INPUTS: */
|
||||
/* flash_info_t *info - flash information structure */
|
||||
/* int s_first - first sector to erase */
|
||||
/* int s_last - last sector to erase */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* None */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* Returns 0 for success, 1 for failure. */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
int flash_erase (flash_info_t *info, int s_first, int s_last)
|
||||
{
|
||||
vu_long *addr = (vu_long*)(info->start[0]);
|
||||
int flag, prot, sect, l_sect;
|
||||
ulong start, now, last;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
prot = 0;
|
||||
for (sect = s_first; sect <= s_last; sect++) {
|
||||
if (info->protect[sect]) {
|
||||
prot++;
|
||||
}
|
||||
}
|
||||
|
||||
if (prot) {
|
||||
printf ("- Warning: %d protected sectors will not be erased!\n",
|
||||
prot);
|
||||
} else {
|
||||
printf ("\n");
|
||||
}
|
||||
|
||||
l_sect = -1;
|
||||
|
||||
/* Disable interrupts which might cause a timeout here */
|
||||
flag = disable_interrupts();
|
||||
|
||||
addr[0x0555] = 0xAAAAAAAA;
|
||||
addr[0x02AA] = 0x55555555;
|
||||
addr[0x0555] = 0x80808080;
|
||||
addr[0x0555] = 0xAAAAAAAA;
|
||||
addr[0x02AA] = 0x55555555;
|
||||
udelay (100);
|
||||
|
||||
/* Start erase on unprotected sectors */
|
||||
for (sect = s_first; sect <= s_last; sect++) {
|
||||
if (info->protect[sect] == 0) { /* not protected */
|
||||
addr = (vu_long*)(info->start[sect]);
|
||||
addr[0] = 0x30303030;
|
||||
l_sect = sect;
|
||||
}
|
||||
}
|
||||
|
||||
/* re-enable interrupts if necessary */
|
||||
if (flag)
|
||||
enable_interrupts();
|
||||
|
||||
/* wait at least 80us - let's wait 1 ms */
|
||||
udelay (1000);
|
||||
|
||||
/*
|
||||
* We wait for the last triggered sector
|
||||
*/
|
||||
if (l_sect < 0)
|
||||
goto DONE;
|
||||
|
||||
start = get_timer (0);
|
||||
last = start;
|
||||
addr = (vu_long*)(info->start[l_sect]);
|
||||
while ((addr[0] & 0x80808080) != 0x80808080) {
|
||||
if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
|
||||
printf ("Timeout\n");
|
||||
return 1;
|
||||
}
|
||||
/* show that we're waiting */
|
||||
if ((now - last) > 1000) { /* every second */
|
||||
serial_putc ('.');
|
||||
last = now;
|
||||
}
|
||||
}
|
||||
|
||||
DONE:
|
||||
/* reset to read mode */
|
||||
addr = (volatile unsigned long *)info->start[0];
|
||||
addr[0] = 0xF0F0F0F0; /* reset bank */
|
||||
|
||||
printf (" done\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: write_buff() - writes a buffer to flash */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* This function copies a buffer, *src, to flash. */
|
||||
/* */
|
||||
/* INPUTS: */
|
||||
/* flash_info_t *info - flash information structure */
|
||||
/* uchar *src - pointer to buffer to write to flash */
|
||||
/* ulong addr - address to start write at */
|
||||
/* ulong cnt - number of bytes to write to flash */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* None */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* 0 - OK */
|
||||
/* 1 - write timeout */
|
||||
/* 2 - Flash not erased */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
|
||||
{
|
||||
ulong cp, wp, data;
|
||||
int i, l, rc;
|
||||
|
||||
wp = (addr & ~3); /* get lower word 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_word(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_word(info, wp, data)) != 0) {
|
||||
return (rc);
|
||||
}
|
||||
wp += 4;
|
||||
cnt -= 4;
|
||||
}
|
||||
|
||||
if (cnt == 0) {
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* handle unaligned tail bytes
|
||||
*/
|
||||
data = 0;
|
||||
for (i = 0, cp = wp; (i < 4) && (cnt > 0); ++i, ++cp) {
|
||||
data = (data << 8) | *src++;
|
||||
--cnt;
|
||||
}
|
||||
for (; (i < 4); ++i, ++cp) {
|
||||
data = (data << 8) | (*(uchar *)cp);
|
||||
}
|
||||
|
||||
return (write_word(info, wp, data));
|
||||
}
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: write_word() - writes a word to flash */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* This writes a single word to flash. */
|
||||
/* */
|
||||
/* INPUTS: */
|
||||
/* flash_info_t *info - flash information structure */
|
||||
/* ulong dest - address to write */
|
||||
/* ulong data - data to write */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* None */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* 0 - OK */
|
||||
/* 1 - write timeout */
|
||||
/* 2 - Flash not erased */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
static int write_word (flash_info_t *info, ulong dest, ulong data)
|
||||
{
|
||||
vu_long *addr = (vu_long*)(info->start[0]);
|
||||
ulong start;
|
||||
int flag;
|
||||
|
||||
/* Check if Flash is (sufficiently) erased */
|
||||
if ((*((vu_long *)dest) & data) != data) {
|
||||
return (2);
|
||||
}
|
||||
/* Disable interrupts which might cause a timeout here */
|
||||
flag = disable_interrupts();
|
||||
|
||||
addr[0x0555] = 0xAAAAAAAA;
|
||||
addr[0x02AA] = 0x55555555;
|
||||
addr[0x0555] = 0xA0A0A0A0;
|
||||
|
||||
*((vu_long *)dest) = data;
|
||||
|
||||
/* re-enable interrupts if necessary */
|
||||
if (flag)
|
||||
enable_interrupts();
|
||||
|
||||
/* data polling for D7 */
|
||||
start = get_timer (0);
|
||||
while ((*((vu_long *)dest) & 0x80808080) != (data & 0x80808080)) {
|
||||
if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
|
||||
return (1);
|
||||
}
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
/*********************************************************************/
|
||||
/* End of flash.c */
|
||||
/*********************************************************************/
|
||||
|
|
@ -0,0 +1,659 @@
|
|||
/*
|
||||
* (C) Copyright 2000
|
||||
* Sysgo Real-Time Solutions, GmbH <www.elinos.com>
|
||||
* Marius Groeger <mgroeger@sysgo.de>
|
||||
*
|
||||
* (C) Copyright 2001
|
||||
* Advent Networks, Inc. <http://www.adventnetworks.com>
|
||||
* Jay Monkman <jtm@smoothsmoothie.com>
|
||||
*
|
||||
* (C) Copyright 2001
|
||||
* Advent Networks, Inc. <http://www.adventnetworks.com>
|
||||
* Oliver Brown <oliverb@alumni.utexas.net>
|
||||
*
|
||||
* See file CREDITS for list of people who contributed to this
|
||||
* project.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
||||
* MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
/*********************************************************************/
|
||||
/* DESCRIPTION:
|
||||
* This file contains the board routines for the GW8260 board.
|
||||
*
|
||||
* MODULE DEPENDENCY:
|
||||
* None
|
||||
*
|
||||
* RESTRICTIONS/LIMITATIONS:
|
||||
* None
|
||||
*
|
||||
* Copyright (c) 2001, Advent Networks, Inc.
|
||||
*/
|
||||
/*********************************************************************/
|
||||
|
||||
#include <common.h>
|
||||
#include <ioports.h>
|
||||
#include <mpc8260.h>
|
||||
|
||||
/*
|
||||
* I/O Port configuration table
|
||||
*
|
||||
*/
|
||||
const iop_conf_t iop_conf_tab[4][32] = {
|
||||
|
||||
/* Port A configuration */
|
||||
{ /* conf ppar psor pdir podr pdat */
|
||||
/* PA31 */ { 1, 0, 0, 1, 0, 0 }, /* TP14 */
|
||||
/* PA30 */ { 1, 1, 1, 1, 0, 0 }, /* US_RTS */
|
||||
/* PA29 */ { 1, 0, 0, 1, 0, 1 }, /* LSSI_DATA */
|
||||
/* PA28 */ { 1, 0, 0, 1, 0, 1 }, /* LSSI_CLK */
|
||||
/* PA27 */ { 1, 0, 0, 1, 0, 0 }, /* TP12 */
|
||||
/* PA26 */ { 1, 0, 0, 0, 0, 0 }, /* IO_STATUS */
|
||||
/* PA25 */ { 1, 0, 0, 0, 0, 0 }, /* IO_CLOCK */
|
||||
/* PA24 */ { 1, 0, 0, 0, 0, 0 }, /* IO_CONFIG */
|
||||
/* PA23 */ { 1, 0, 0, 0, 0, 0 }, /* IO_DONE */
|
||||
/* PA22 */ { 1, 0, 0, 0, 0, 0 }, /* IO_DATA */
|
||||
/* PA21 */ { 1, 1, 0, 1, 0, 0 }, /* US_TXD3 */
|
||||
/* PA20 */ { 1, 1, 0, 1, 0, 0 }, /* US_TXD2 */
|
||||
/* PA19 */ { 1, 1, 0, 1, 0, 0 }, /* US_TXD1 */
|
||||
/* PA18 */ { 1, 1, 0, 1, 0, 0 }, /* US_TXD0 */
|
||||
/* PA17 */ { 1, 1, 0, 0, 0, 0 }, /* DS_RXD0 */
|
||||
/* PA16 */ { 1, 1, 0, 0, 0, 0 }, /* DS_RXD1 */
|
||||
/* PA15 */ { 1, 1, 0, 0, 0, 0 }, /* DS_RXD2 */
|
||||
/* PA14 */ { 1, 1, 0, 0, 0, 0 }, /* DS_RXD3 */
|
||||
/* PA13 */ { 1, 0, 0, 1, 0, 0 }, /* SPARE7 */
|
||||
/* PA12 */ { 1, 0, 0, 1, 0, 0 }, /* SPARE6 */
|
||||
/* PA11 */ { 1, 0, 0, 1, 0, 0 }, /* SPARE5 */
|
||||
/* PA10 */ { 1, 0, 0, 1, 0, 0 }, /* SPARE4 */
|
||||
/* PA9 */ { 1, 0, 0, 1, 0, 0 }, /* SPARE3 */
|
||||
/* PA8 */ { 1, 0, 0, 1, 0, 0 }, /* SPARE2 */
|
||||
/* PA7 */ { 1, 0, 0, 0, 0, 0 }, /* LSSI_IN */
|
||||
/* PA6 */ { 1, 0, 0, 1, 0, 0 }, /* SPARE0 */
|
||||
/* PA5 */ { 1, 0, 0, 1, 0, 0 }, /* DEMOD_RESET_ */
|
||||
/* PA4 */ { 1, 0, 0, 1, 0, 0 }, /* MOD_RESET_ */
|
||||
/* PA3 */ { 1, 0, 0, 1, 0, 0 }, /* IO_RESET */
|
||||
/* PA2 */ { 1, 0, 0, 1, 0, 0 }, /* TX_ENABLE */
|
||||
/* PA1 */ { 1, 0, 0, 0, 0, 0 }, /* RX_LOCK */
|
||||
/* PA0 */ { 1, 0, 0, 1, 0, 1 } /* MPC_RESET_ */
|
||||
},
|
||||
|
||||
/* Port B configuration */
|
||||
{ /* conf ppar psor pdir podr pdat */
|
||||
/* PB31 */ { 1, 1, 0, 1, 0, 0 }, /* FETH0_TX_ER */
|
||||
/* PB30 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_RX_DV */
|
||||
/* PB29 */ { 1, 1, 1, 1, 0, 0 }, /* FETH0_TX_EN */
|
||||
/* PB28 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_RX_ER */
|
||||
/* PB27 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_COL */
|
||||
/* PB26 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_CRS */
|
||||
/* PB25 */ { 1, 1, 0, 1, 0, 0 }, /* FETH0_TXD3 */
|
||||
/* PB24 */ { 1, 1, 0, 1, 0, 0 }, /* FETH0_TXD2 */
|
||||
/* PB23 */ { 1, 1, 0, 1, 0, 0 }, /* FETH0_TXD1 */
|
||||
/* PB22 */ { 1, 1, 0, 1, 0, 0 }, /* FETH0_TXD0 */
|
||||
/* PB21 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_RXD0 */
|
||||
/* PB20 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_RXD1 */
|
||||
/* PB19 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_RXD2 */
|
||||
/* PB18 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_RXD3 */
|
||||
/* PB17 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_RX_DV */
|
||||
/* PB16 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_RX_ER */
|
||||
/* PB15 */ { 1, 1, 0, 1, 0, 0 }, /* FETH1_TX_ER */
|
||||
/* PB14 */ { 1, 1, 0, 1, 0, 0 }, /* FETH1_TX_EN */
|
||||
/* PB13 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_COL */
|
||||
/* PB12 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_CRS */
|
||||
/* PB11 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_RXD3 */
|
||||
/* PB10 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_RXD2 */
|
||||
/* PB9 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_RXD1 */
|
||||
/* PB8 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_RXD0 */
|
||||
/* PB7 */ { 1, 1, 0, 1, 0, 0 }, /* FETH1_TXD0 */
|
||||
/* PB6 */ { 1, 1, 0, 1, 0, 0 }, /* FETH1_TXD1 */
|
||||
/* PB5 */ { 1, 1, 0, 1, 0, 0 }, /* FETH1_TXD2 */
|
||||
/* PB4 */ { 1, 1, 0, 1, 0, 0 }, /* FETH1_TXD3 */
|
||||
/* PB3 */ { 0, 0, 0, 0, 0, 0 }, /* pin doesn't exist */
|
||||
/* PB2 */ { 0, 0, 0, 0, 0, 0 }, /* pin doesn't exist */
|
||||
/* PB1 */ { 0, 0, 0, 0, 0, 0 }, /* pin doesn't exist */
|
||||
/* PB0 */ { 0, 0, 0, 0, 0, 0 } /* pin doesn't exist */
|
||||
},
|
||||
|
||||
/* Port C */
|
||||
{ /* conf ppar psor pdir podr pdat */
|
||||
/* PC31 */ { 1, 0, 0, 1, 0, 1 }, /* FAST_RESET_ */
|
||||
/* PC30 */ { 1, 0, 0, 1, 0, 1 }, /* FAST_PAUSE_ */
|
||||
/* PC29 */ { 1, 0, 0, 1, 0, 0 }, /* FAST_SLEW1 */
|
||||
/* PC28 */ { 1, 0, 0, 1, 0, 0 }, /* FAST_SLEW0 */
|
||||
/* PC27 */ { 1, 0, 0, 1, 0, 0 }, /* TP13 */
|
||||
/* PC26 */ { 1, 0, 0, 0, 0, 0 }, /* RXDECDFLG */
|
||||
/* PC25 */ { 1, 0, 0, 0, 0, 0 }, /* RXACQFAIL */
|
||||
/* PC24 */ { 1, 0, 0, 0, 0, 0 }, /* RXACQFLG */
|
||||
/* PC23 */ { 1, 0, 0, 1, 0, 0 }, /* WD_TCL */
|
||||
/* PC22 */ { 1, 0, 0, 1, 0, 0 }, /* WD_EN */
|
||||
/* PC21 */ { 1, 0, 0, 1, 0, 0 }, /* US_TXCLK */
|
||||
/* PC20 */ { 1, 0, 0, 0, 0, 0 }, /* DS_RXCLK */
|
||||
/* PC19 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_RX_CLK */
|
||||
/* PC18 */ { 1, 1, 0, 0, 0, 0 }, /* FETH0_TX_CLK */
|
||||
/* PC17 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_RX_CLK */
|
||||
/* PC16 */ { 1, 1, 0, 0, 0, 0 }, /* FETH1_TX_CLK */
|
||||
/* PC15 */ { 1, 0, 0, 1, 0, 0 }, /* TX_SHUTDOWN_ */
|
||||
/* PC14 */ { 1, 0, 0, 0, 0, 0 }, /* RS_232_DTR_ */
|
||||
/* PC13 */ { 1, 0, 0, 0, 0, 0 }, /* TXERR */
|
||||
/* PC12 */ { 1, 0, 0, 1, 0, 1 }, /* FETH1_MDDIS */
|
||||
/* PC11 */ { 1, 0, 0, 1, 0, 1 }, /* FETH0_MDDIS */
|
||||
/* PC10 */ { 1, 0, 0, 1, 0, 0 }, /* MDC */
|
||||
/* PC9 */ { 1, 0, 0, 1, 1, 1 }, /* MDIO */
|
||||
/* PC8 */ { 1, 0, 0, 1, 1, 1 }, /* SER_NUM */
|
||||
/* PC7 */ { 1, 1, 0, 0, 0, 0 }, /* US_CTS */
|
||||
/* PC6 */ { 1, 1, 0, 0, 0, 0 }, /* DS_CD_ */
|
||||
/* PC5 */ { 1, 0, 0, 1, 0, 0 }, /* FETH1_PWRDWN */
|
||||
/* PC4 */ { 1, 0, 0, 1, 0, 0 }, /* FETH0_PWRDWN */
|
||||
/* PC3 */ { 1, 0, 0, 1, 0, 0 }, /* MPULED3 */
|
||||
/* PC2 */ { 1, 0, 0, 1, 0, 0 }, /* MPULED2 */
|
||||
/* PC1 */ { 1, 0, 0, 1, 0, 0 }, /* MPULED1 */
|
||||
/* PC0 */ { 1, 0, 0, 1, 0, 1 }, /* MPULED0 */
|
||||
},
|
||||
|
||||
/* Port D */
|
||||
{ /* conf ppar psor pdir podr pdat */
|
||||
/* PD31 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD30 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD29 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD28 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD27 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD26 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD25 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD24 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD23 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD22 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD21 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD20 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD19 */ { 1, 1, 1, 0, 0, 0 }, /* not used */
|
||||
/* PD18 */ { 1, 1, 1, 0, 0, 0 }, /* not used */
|
||||
/* PD17 */ { 1, 1, 1, 0, 0, 0 }, /* not used */
|
||||
/* PD16 */ { 1, 1, 1, 0, 0, 0 }, /* not used */
|
||||
/* PD15 */ { 1, 1, 1, 0, 1, 1 }, /* SDRAM_SDA */
|
||||
/* PD14 */ { 1, 1, 1, 0, 1, 1 }, /* SDRAM_SCL */
|
||||
/* PD13 */ { 1, 0, 0, 1, 0, 0 }, /* MPULED7 */
|
||||
/* PD12 */ { 1, 0, 0, 1, 0, 0 }, /* MPULED6 */
|
||||
/* PD11 */ { 1, 0, 0, 1, 0, 0 }, /* MPULED5 */
|
||||
/* PD10 */ { 1, 0, 0, 1, 0, 0 }, /* MPULED4 */
|
||||
/* PD9 */ { 1, 1, 0, 1, 0, 0 }, /* RS232_TXD */
|
||||
/* PD8 */ { 1, 1, 0, 0, 0, 0 }, /* RD232_RXD */
|
||||
/* PD7 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD6 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD5 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD4 */ { 1, 0, 0, 0, 0, 0 }, /* not used */
|
||||
/* PD3 */ { 0, 0, 0, 0, 0, 0 }, /* pin doesn't exist */
|
||||
/* PD2 */ { 0, 0, 0, 0, 0, 0 }, /* pin doesn't exist */
|
||||
/* PD1 */ { 0, 0, 0, 0, 0, 0 }, /* pin doesn't exist */
|
||||
/* PD0 */ { 0, 0, 0, 0, 0, 0 } /* pin doesn't exist */
|
||||
}
|
||||
};
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: checkboard() - Displays the board type and serial number */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* Displays the board type and serial number */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* Always returns 1 */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
int checkboard(void)
|
||||
{
|
||||
char *str;
|
||||
puts ("Board: Advent Networks gw8260\n");
|
||||
|
||||
str = getenv("serial#");
|
||||
if (str != NULL) {
|
||||
printf("SN: %s\n", str);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#if defined (CFG_DRAM_TEST)
|
||||
/*********************************************************************/
|
||||
/* NAME: move64() - moves a double word (64-bit) */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* this function performs a double word move from the data at */
|
||||
/* the source pointer to the location at the destination pointer. */
|
||||
/* */
|
||||
/* INPUTS: */
|
||||
/* unsigned long long *src - pointer to data to move */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* unsigned long long *dest - pointer to locate to move data */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* None */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* May cloober fr0. */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
static void move64(unsigned long long *src, unsigned long long *dest)
|
||||
{
|
||||
asm ("lfd 0, 0(3)\n\t" /* fpr0 = *scr */
|
||||
"stfd 0, 0(4)" /* *dest = fpr0 */
|
||||
: : : "fr0" ); /* Clobbers fr0 */
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
#if defined (CFG_DRAM_TEST_DATA)
|
||||
|
||||
unsigned long long pattern[]= {
|
||||
0xaaaaaaaaaaaaaaaa,
|
||||
0xcccccccccccccccc,
|
||||
0xf0f0f0f0f0f0f0f0,
|
||||
0xff00ff00ff00ff00,
|
||||
0xffff0000ffff0000,
|
||||
0xffffffff00000000,
|
||||
0x00000000ffffffff,
|
||||
0x0000ffff0000ffff,
|
||||
0x00ff00ff00ff00ff,
|
||||
0x0f0f0f0f0f0f0f0f,
|
||||
0x3333333333333333,
|
||||
0x5555555555555555};
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: mem_test_data() - test data lines for shorts and opens */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* Tests data lines for shorts and opens by forcing adjacent data */
|
||||
/* to opposite states. Because the data lines could be routed in */
|
||||
/* an arbitrary manner the must ensure test patterns ensure that */
|
||||
/* every case is tested. By using the following series of binary */
|
||||
/* patterns every combination of adjacent bits is test regardless */
|
||||
/* of routing. */
|
||||
/* */
|
||||
/* ...101010101010101010101010 */
|
||||
/* ...110011001100110011001100 */
|
||||
/* ...111100001111000011110000 */
|
||||
/* ...111111110000000011111111 */
|
||||
/* */
|
||||
/* Carrying this out, gives us six hex patterns as follows: */
|
||||
/* */
|
||||
/* 0xaaaaaaaaaaaaaaaa */
|
||||
/* 0xcccccccccccccccc */
|
||||
/* 0xf0f0f0f0f0f0f0f0 */
|
||||
/* 0xff00ff00ff00ff00 */
|
||||
/* 0xffff0000ffff0000 */
|
||||
/* 0xffffffff00000000 */
|
||||
/* */
|
||||
/* The number test patterns will always be given by: */
|
||||
/* */
|
||||
/* log(base 2)(number data bits) = log2 (64) = 6 */
|
||||
/* */
|
||||
/* To test for short and opens to other signals on our boards. we */
|
||||
/* simply */
|
||||
/* test with the 1's complemnt of the paterns as well. */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* Displays failing test pattern */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* 0 - Passed test */
|
||||
/* 1 - Failed test */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* Assumes only one one SDRAM bank */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
int mem_test_data(void)
|
||||
{
|
||||
unsigned long long * pmem =
|
||||
(unsigned long long *)CFG_SDRAM_BASE ;
|
||||
unsigned long long temp64;
|
||||
int num_patterns = sizeof(pattern)/ sizeof(pattern[0]);
|
||||
int i;
|
||||
unsigned int hi, lo;
|
||||
|
||||
for ( i = 0; i < num_patterns; i++) {
|
||||
move64(&(pattern[i]), pmem);
|
||||
move64(pmem, &temp64);
|
||||
|
||||
/* hi = (temp64>>32) & 0xffffffff; */
|
||||
/* lo = temp64 & 0xffffffff; */
|
||||
/* printf("\ntemp64 = 0x%08x%08x", hi, lo); */
|
||||
|
||||
hi = (pattern[i]>>32) & 0xffffffff;
|
||||
lo = pattern[i] & 0xffffffff;
|
||||
/* printf("\npattern[%d] = 0x%08x%08x", i, hi, lo); */
|
||||
|
||||
if (temp64 != pattern[i]){
|
||||
printf ("\n Data Test Failed, pattern 0x%08x%08x", hi, lo);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif /* CFG_DRAM_TEST_DATA */
|
||||
|
||||
#if defined (CFG_DRAM_TEST_ADDRESS)
|
||||
/*********************************************************************/
|
||||
/* NAME: mem_test_address() - test address lines */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* This function performs a test to verify that each word im */
|
||||
/* memory is uniquly addressable. The test sequence is as follows: */
|
||||
/* */
|
||||
/* 1) write the address of each word to each word. */
|
||||
/* 2) verify that each location equals its address */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* Displays failing test pattern and address */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* 0 - Passed test */
|
||||
/* 1 - Failed test */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
int mem_test_address(void)
|
||||
{
|
||||
volatile unsigned int * pmem = (volatile unsigned int *)CFG_SDRAM_BASE ;
|
||||
const unsigned int size = (CFG_SDRAM_SIZE * 1024 * 1024)/4;
|
||||
unsigned int i;
|
||||
|
||||
/* write address to each location */
|
||||
for ( i = 0; i < size; i++) {
|
||||
pmem[i] = i;
|
||||
}
|
||||
|
||||
/* verify each loaction */
|
||||
for ( i = 0; i < size; i++) {
|
||||
if (pmem[i] != i) {
|
||||
printf("\n Address Test Failed at 0x%x", i);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif /* CFG_DRAM_TEST_ADDRESS */
|
||||
|
||||
#if defined (CFG_DRAM_TEST_WALK)
|
||||
/*********************************************************************/
|
||||
/* NAME: mem_march() - memory march */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* Marches up through memory. At each location verifies rmask if */
|
||||
/* read = 1. At each location write wmask if write = 1. Displays */
|
||||
/* failing address and pattern. */
|
||||
/* */
|
||||
/* INPUTS: */
|
||||
/* volatile unsigned long long * base - start address of test */
|
||||
/* unsigned int size - number of dwords(64-bit) to test */
|
||||
/* unsigned long long rmask - read verify mask */
|
||||
/* unsigned long long wmask - wrtie verify mask */
|
||||
/* short read - verifies rmask if read = 1 */
|
||||
/* short write - writes wmask if write = 1 */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* Displays failing test pattern and address */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* 0 - Passed test */
|
||||
/* 1 - Failed test */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
int mem_march(volatile unsigned long long * base,
|
||||
unsigned int size,
|
||||
unsigned long long rmask,
|
||||
unsigned long long wmask,
|
||||
short read,
|
||||
short write)
|
||||
{
|
||||
unsigned int i;
|
||||
unsigned long long temp;
|
||||
unsigned int hitemp, lotemp, himask, lomask;
|
||||
|
||||
for (i = 0 ; i < size ; i++) {
|
||||
if (read != 0) {
|
||||
/* temp = base[i]; */
|
||||
move64 ((unsigned long long *)&(base[i]), &temp);
|
||||
if (rmask != temp) {
|
||||
hitemp = (temp>>32) & 0xffffffff;
|
||||
lotemp = temp & 0xffffffff;
|
||||
himask = (rmask>>32) & 0xffffffff;
|
||||
lomask = rmask & 0xffffffff;
|
||||
|
||||
printf("\n Walking one's test failed: address = 0x%08x,"
|
||||
"\n\texpected 0x%08x%08x, found 0x%08x%08x",
|
||||
i<<3, himask, lomask, hitemp, lotemp);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
if ( write != 0 ) {
|
||||
/* base[i] = wmask; */
|
||||
move64 (&wmask, (unsigned long long *)&(base[i]));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif /* CFG_DRAM_TEST_WALK */
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: mem_test_walk() - a simple walking ones test */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* Performs a walking ones through entire physical memory. The */
|
||||
/* test uses as series of memory marches, mem_march(), to verify */
|
||||
/* and write the test patterns to memory. The test sequence is as */
|
||||
/* follows: */
|
||||
/* 1) march writing 0000...0001 */
|
||||
/* 2) march verifying 0000...0001 , writing 0000...0010 */
|
||||
/* 3) repeat step 2 shifting masks left 1 bit each time unitl */
|
||||
/* the write mask equals 1000...0000 */
|
||||
/* 4) march verifying 1000...0000 */
|
||||
/* The test fails if any of the memory marches return a failure. */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* Displays which pass on the memory test is executing */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* 0 - Passed test */
|
||||
/* 1 - Failed test */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
int mem_test_walk(void)
|
||||
{
|
||||
unsigned long long mask;
|
||||
volatile unsigned long long * pmem =
|
||||
(volatile unsigned long long *)CFG_SDRAM_BASE ;
|
||||
const unsigned long size = (CFG_SDRAM_SIZE * 1024 * 1024)/8;
|
||||
|
||||
unsigned int i;
|
||||
mask = 0x01;
|
||||
|
||||
printf("Initial Pass");
|
||||
mem_march(pmem,size,0x0,0x1,0,1);
|
||||
|
||||
printf("\b\b\b\b\b\b\b\b\b\b\b\b");
|
||||
printf(" ");
|
||||
printf("\b\b\b\b\b\b\b\b\b\b\b\b");
|
||||
|
||||
for (i = 0 ; i < 63 ; i++) {
|
||||
printf("Pass %2d", i+2);
|
||||
if ( mem_march(pmem,size, mask,mask << 1, 1, 1) != 0 ){
|
||||
/*printf("mask: 0x%x, pass: %d, ", mask, i);*/
|
||||
return 1;
|
||||
}
|
||||
mask = mask<<1;
|
||||
printf("\b\b\b\b\b\b\b");
|
||||
}
|
||||
|
||||
printf("Last Pass");
|
||||
if (mem_march(pmem, size, 0, mask, 0, 1) != 0) {
|
||||
/* printf("mask: 0x%x", mask); */
|
||||
return 1;
|
||||
}
|
||||
printf("\b\b\b\b\b\b\b\b\b");
|
||||
printf(" ");
|
||||
printf("\b\b\b\b\b\b\b\b\b");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: testdram() - calls any enabled memory tests */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* Runs memory tests if the environment test variables are set to */
|
||||
/* 'y'. */
|
||||
/* */
|
||||
/* INPUTS: */
|
||||
/* testdramdata - If set to 'y', data test is run. */
|
||||
/* testdramaddress - If set to 'y', address test is run. */
|
||||
/* testdramwalk - If set to 'y', walking ones test is run */
|
||||
/* */
|
||||
/* OUTPUTS: */
|
||||
/* None */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* 0 - Passed test */
|
||||
/* 1 - Failed test */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
int testdram(void)
|
||||
{
|
||||
char *s;
|
||||
int rundata, runaddress, runwalk;
|
||||
|
||||
s = getenv ("testdramdata");
|
||||
rundata = (s && (*s == 'y')) ? 1 : 0;
|
||||
s = getenv ("testdramaddress");
|
||||
runaddress = (s && (*s == 'y')) ? 1 : 0;
|
||||
s = getenv ("testdramwalk");
|
||||
runwalk = (s && (*s == 'y')) ? 1 : 0;
|
||||
|
||||
if ((rundata == 1) || (runaddress == 1) || (runwalk == 1)) {
|
||||
printf("Testing RAM ... ");
|
||||
}
|
||||
#ifdef CFG_DRAM_TEST_DATA
|
||||
if (rundata == 1) {
|
||||
if (mem_test_data() == 1){
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef CFG_DRAM_TEST_ADDRESS
|
||||
if (runaddress == 1) {
|
||||
if (mem_test_address() == 1){
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef CFG_DRAM_TEST_WALK
|
||||
if (runwalk == 1) {
|
||||
if (mem_test_walk() == 1){
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if ((rundata == 1) || (runaddress == 1) || (runwalk == 1)) {
|
||||
printf("passed");
|
||||
}
|
||||
return 0;
|
||||
|
||||
}
|
||||
#endif /* CFG_DRAM_TEST */
|
||||
|
||||
/*********************************************************************/
|
||||
/* NAME: initdram() - initializes SDRAM controller */
|
||||
/* */
|
||||
/* DESCRIPTION: */
|
||||
/* Initializes the MPC8260's SDRAM controller. */
|
||||
/* */
|
||||
/* INPUTS: */
|
||||
/* CFG_IMMR - MPC8260 Internal memory map */
|
||||
/* CFG_SDRAM_BASE - Physical start address of SDRAM */
|
||||
/* CFG_PSDMR - SDRAM mode register */
|
||||
/* CFG_MPTPR - Memory refresh timer prescaler register */
|
||||
/* CFG_SDRAM0_SIZE - SDRAM size */
|
||||
/* */
|
||||
/* RETURNS: */
|
||||
/* SDRAM size in bytes */
|
||||
/* */
|
||||
/* RESTRICTIONS/LIMITATIONS: */
|
||||
/* */
|
||||
/* */
|
||||
/*********************************************************************/
|
||||
long int initdram(int board_type)
|
||||
{
|
||||
volatile immap_t *immap = (immap_t *)CFG_IMMR;
|
||||
volatile memctl8260_t *memctl = &immap->im_memctl;
|
||||
volatile uchar c = 0, *ramaddr = (uchar *)(CFG_SDRAM_BASE + 0x8);
|
||||
ulong psdmr = CFG_PSDMR;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* Quote from 8260 UM (10.4.2 SDRAM Power-On Initialization, 10-35):
|
||||
*
|
||||
* "At system reset, initialization software must set up the
|
||||
* programmable parameters in the memory controller banks registers
|
||||
* (ORx, BRx, P/LSDMR). After all memory parameters are configured,
|
||||
* system software should execute the following initialization sequence
|
||||
* for each SDRAM device.
|
||||
*
|
||||
* 1. Issue a PRECHARGE-ALL-BANKS command
|
||||
* 2. Issue eight CBR REFRESH commands
|
||||
* 3. Issue a MODE-SET command to initialize the mode register
|
||||
*
|
||||
* The initial commands are executed by setting P/LSDMR[OP] and
|
||||
* accessing the SDRAM with a single-byte transaction."
|
||||
*
|
||||
* The appropriate BRx/ORx registers have already been set when we
|
||||
* get here. The SDRAM can be accessed at the address CFG_SDRAM_BASE.
|
||||
*/
|
||||
|
||||
memctl->memc_psrt = CFG_PSRT;
|
||||
memctl->memc_mptpr = CFG_MPTPR;
|
||||
|
||||
memctl->memc_psdmr = psdmr | PSDMR_OP_PREA;
|
||||
*ramaddr = c;
|
||||
|
||||
memctl->memc_psdmr = psdmr | PSDMR_OP_CBRR;
|
||||
for (i = 0; i < 8; i++){
|
||||
*ramaddr = c;
|
||||
}
|
||||
memctl->memc_psdmr = psdmr | PSDMR_OP_MRW;
|
||||
*ramaddr = c;
|
||||
|
||||
memctl->memc_psdmr = psdmr | PSDMR_OP_NORM | PSDMR_RFEN;
|
||||
*ramaddr = c;
|
||||
|
||||
/* return total ram size */
|
||||
return (CFG_SDRAM0_SIZE * 1024 * 1024);
|
||||
}
|
||||
|
||||
/*********************************************************************/
|
||||
/* End of gw8260.c */
|
||||
/*********************************************************************/
|
||||
|
|
@ -0,0 +1,719 @@
|
|||
/*
|
||||
* (C) Copyright 2000
|
||||
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
||||
*
|
||||
* Changes for MATRIX Vision MVsensor (C) Copyright 2001
|
||||
* MATRIX Vision GmbH / hg, info@matrix-vision.de
|
||||
*
|
||||
* See file CREDITS for list of people who contributed to this
|
||||
* project.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation; either version 2 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
||||
* MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <common.h>
|
||||
#include <mpc8xx.h>
|
||||
|
||||
#undef MVDEBUG
|
||||
#ifdef MVDEBUG
|
||||
#define mvdebug debug
|
||||
#else
|
||||
#define mvdebug(p) do {} while (0)
|
||||
#endif
|
||||
|
||||
|
||||
flash_info_t flash_info[CFG_MAX_FLASH_BANKS]; /* info for FLASH chips */
|
||||
|
||||
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
#define FLASH_DATA_MASK 0xffff
|
||||
#define FLASH_SHIFT 0
|
||||
#else
|
||||
#define FLASH_DATA_MASK 0xffffffff
|
||||
#define FLASH_SHIFT 1
|
||||
#endif
|
||||
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Functions
|
||||
*/
|
||||
static ulong flash_get_size (vu_long *address, flash_info_t *info);
|
||||
static int write_word (flash_info_t *info, ulong dest, ulong data);
|
||||
static void flash_get_offsets (ulong base, flash_info_t *info);
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
unsigned long flash_init (void)
|
||||
{
|
||||
volatile immap_t *immap = (immap_t *)CFG_IMMR;
|
||||
volatile memctl8xx_t *memctl = &immap->im_memctl;
|
||||
unsigned long size_b0, size_b1;
|
||||
int i;
|
||||
|
||||
/* Init: no FLASHes known */
|
||||
for (i=0; i<CFG_MAX_FLASH_BANKS; ++i) {
|
||||
flash_info[i].flash_id = FLASH_UNKNOWN;
|
||||
}
|
||||
|
||||
/* Static FLASH Bank configuration here - FIXME XXX */
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
#if defined (FLASH_BASE1_PRELIM)
|
||||
size_b1 = flash_get_size((vu_long *)FLASH_BASE1_PRELIM, &flash_info[1]);
|
||||
|
||||
if (size_b1 > size_b0) {
|
||||
printf ("## ERROR: "
|
||||
"Bank 1 (0x%08lx = %ld MB) > Bank 0 (0x%08lx = %ld MB)\n",
|
||||
size_b1, size_b1<<20,
|
||||
size_b0, size_b0<<20
|
||||
);
|
||||
flash_info[0].flash_id = FLASH_UNKNOWN;
|
||||
flash_info[1].flash_id = FLASH_UNKNOWN;
|
||||
flash_info[0].sector_count = -1;
|
||||
flash_info[1].sector_count = -1;
|
||||
flash_info[0].size = 0;
|
||||
flash_info[1].size = 0;
|
||||
return (0);
|
||||
}
|
||||
#else
|
||||
size_b1 = 0;
|
||||
#endif
|
||||
|
||||
/* Remap FLASH according to real size */
|
||||
memctl->memc_or0 = CFG_OR_TIMING_FLASH | (-size_b0 & 0xFFFF8000);
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
memctl->memc_br0 = (CFG_FLASH_BASE & BR_BA_MSK) | BR_PS_16 | BR_MS_GPCM | BR_V;
|
||||
#else
|
||||
memctl->memc_br0 = (CFG_FLASH_BASE & BR_BA_MSK) | BR_PS_32 | BR_MS_GPCM | BR_V;
|
||||
#endif
|
||||
|
||||
/* Re-do sizing to get full correct info */
|
||||
size_b0 = flash_get_size((vu_long *)CFG_FLASH_BASE, &flash_info[0]);
|
||||
|
||||
flash_get_offsets (CFG_FLASH_BASE, &flash_info[0]);
|
||||
|
||||
/* monitor protection ON by default */
|
||||
flash_protect(FLAG_PROTECT_SET,
|
||||
CFG_FLASH_BASE,
|
||||
CFG_FLASH_BASE+CFG_MONITOR_LEN-1,
|
||||
&flash_info[0]);
|
||||
|
||||
if (size_b1) {
|
||||
memctl->memc_or1 = CFG_OR_TIMING_FLASH | (-size_b1 & 0xFFFF8000);
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
memctl->memc_br1 = ((CFG_FLASH_BASE + size_b0) & BR_BA_MSK) |
|
||||
BR_PS_16 | BR_MS_GPCM | BR_V;
|
||||
#else
|
||||
memctl->memc_br1 = ((CFG_FLASH_BASE + size_b0) & BR_BA_MSK) |
|
||||
BR_PS_32 | BR_MS_GPCM | BR_V;
|
||||
#endif
|
||||
/* Re-do sizing to get full correct info */
|
||||
size_b1 = flash_get_size((vu_long *)(CFG_FLASH_BASE + size_b0),
|
||||
&flash_info[1]);
|
||||
|
||||
flash_get_offsets (CFG_FLASH_BASE + size_b0, &flash_info[1]);
|
||||
|
||||
/* monitor protection ON by default */
|
||||
flash_protect(FLAG_PROTECT_SET,
|
||||
CFG_FLASH_BASE,
|
||||
CFG_FLASH_BASE+CFG_MONITOR_LEN-1,
|
||||
&flash_info[1]);
|
||||
} else {
|
||||
memctl->memc_br1 = 0; /* invalidate bank */
|
||||
|
||||
flash_info[1].flash_id = FLASH_UNKNOWN;
|
||||
flash_info[1].sector_count = -1;
|
||||
}
|
||||
|
||||
flash_info[0].size = size_b0;
|
||||
flash_info[1].size = size_b1;
|
||||
|
||||
return (size_b0 + size_b1);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/
|
||||
static void flash_get_offsets (ulong base, flash_info_t *info)
|
||||
{
|
||||
int i;
|
||||
|
||||
/* set up sector start address table */
|
||||
if (info->flash_id & FLASH_BTYPE)
|
||||
{ /* bottom boot sector types - these are the useful ones! */
|
||||
/* set sector offsets for bottom boot block type */
|
||||
if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320B)
|
||||
{ /* AMDLV320B has 8 x 8k bottom boot sectors */
|
||||
for (i = 0; i < 8; i++) /* +8k */
|
||||
info->start[i] = base + (i * (0x00002000 << FLASH_SHIFT));
|
||||
for (; i < info->sector_count; i++) /* +64k */
|
||||
info->start[i] = base + (i * (0x00010000 << FLASH_SHIFT)) - (0x00070000 << FLASH_SHIFT);
|
||||
}
|
||||
else
|
||||
{ /* other types have 4 bottom boot sectors (16,8,8,32) */
|
||||
i = 0;
|
||||
info->start[i++] = base + 0x00000000; /* - */
|
||||
info->start[i++] = base + (0x00004000 << FLASH_SHIFT); /* +16k */
|
||||
info->start[i++] = base + (0x00006000 << FLASH_SHIFT); /* +8k */
|
||||
info->start[i++] = base + (0x00008000 << FLASH_SHIFT); /* +8k */
|
||||
info->start[i++] = base + (0x00010000 << FLASH_SHIFT); /* +32k */
|
||||
for (; i < info->sector_count; i++) /* +64k */
|
||||
info->start[i] = base + (i * (0x00010000 << FLASH_SHIFT)) - (0x00030000 << FLASH_SHIFT);
|
||||
}
|
||||
}
|
||||
else
|
||||
{ /* top boot sector types - not so useful */
|
||||
/* set sector offsets for top boot block type */
|
||||
if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320T)
|
||||
{ /* AMDLV320T has 8 x 8k top boot sectors */
|
||||
for (i = 0; i < info->sector_count - 8; i++) /* +64k */
|
||||
info->start[i] = base + (i * (0x00010000 << FLASH_SHIFT));
|
||||
for (; i < info->sector_count; i++) /* +8k */
|
||||
info->start[i] = base + (i * (0x00002000 << FLASH_SHIFT));
|
||||
}
|
||||
else
|
||||
{ /* other types have 4 top boot sectors (32,8,8,16) */
|
||||
for (i = 0; i < info->sector_count - 4; i++) /* +64k */
|
||||
info->start[i] = base + (i * (0x00010000 << FLASH_SHIFT));
|
||||
|
||||
info->start[i++] = base + info->size - (0x00010000 << FLASH_SHIFT); /* -32k */
|
||||
info->start[i++] = base + info->size - (0x00008000 << FLASH_SHIFT); /* -8k */
|
||||
info->start[i++] = base + info->size - (0x00006000 << FLASH_SHIFT); /* -8k */
|
||||
info->start[i] = base + info->size - (0x00004000 << FLASH_SHIFT); /* -16k */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/
|
||||
void flash_print_info (flash_info_t *info)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (info->flash_id == FLASH_UNKNOWN) {
|
||||
printf ("missing or unknown FLASH type\n");
|
||||
return;
|
||||
}
|
||||
|
||||
switch (info->flash_id & FLASH_VENDMASK) {
|
||||
case FLASH_MAN_AMD: printf ("AMD "); break;
|
||||
case FLASH_MAN_FUJ: printf ("FUJITSU "); break;
|
||||
case FLASH_MAN_STM: printf ("ST "); break;
|
||||
default: printf ("Unknown Vendor "); break;
|
||||
}
|
||||
|
||||
switch (info->flash_id & FLASH_TYPEMASK) {
|
||||
case FLASH_AM160B: printf ("AM29LV160B (16 Mbit, bottom boot sect)\n");
|
||||
break;
|
||||
case FLASH_AM160T: printf ("AM29LV160T (16 Mbit, top boot sector)\n");
|
||||
break;
|
||||
case FLASH_AM320B: printf ("AM29LV320B (32 Mbit, bottom boot sect)\n");
|
||||
break;
|
||||
case FLASH_AM320T: printf ("AM29LV320T (32 Mbit, top boot sector)\n");
|
||||
break;
|
||||
case FLASH_STMW320DB: printf ("M29W320B (32 Mbit, bottom boot sect)\n");
|
||||
break;
|
||||
case FLASH_STMW320DT: printf ("M29W320T (32 Mbit, top boot sector)\n");
|
||||
break;
|
||||
default: printf ("Unknown Chip Type\n");
|
||||
break;
|
||||
}
|
||||
|
||||
printf (" Size: %ld MB in %d Sectors\n",
|
||||
info->size >> 20, info->sector_count);
|
||||
|
||||
printf (" Sector Start Addresses:");
|
||||
for (i=0; i<info->sector_count; ++i) {
|
||||
if ((i % 5) == 0)
|
||||
printf ("\n ");
|
||||
printf (" %08lX%s",
|
||||
info->start[i],
|
||||
info->protect[i] ? " (RO)" : " "
|
||||
);
|
||||
}
|
||||
printf ("\n");
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/*
|
||||
* The following code cannot be run from FLASH!
|
||||
*/
|
||||
|
||||
#define AMD_ID_LV160T_MVS (AMD_ID_LV160T & FLASH_DATA_MASK)
|
||||
#define AMD_ID_LV160B_MVS (AMD_ID_LV160B & FLASH_DATA_MASK)
|
||||
#define AMD_ID_LV320T_MVS (AMD_ID_LV320T & FLASH_DATA_MASK)
|
||||
#define AMD_ID_LV320B_MVS (AMD_ID_LV320B & FLASH_DATA_MASK)
|
||||
#define STM_ID_W320DT_MVS (STM_ID_29W320DT & FLASH_DATA_MASK)
|
||||
#define STM_ID_W320DB_MVS (STM_ID_29W320DB & FLASH_DATA_MASK)
|
||||
#define AMD_MANUFACT_MVS (AMD_MANUFACT & FLASH_DATA_MASK)
|
||||
#define FUJ_MANUFACT_MVS (FUJ_MANUFACT & FLASH_DATA_MASK)
|
||||
#define STM_MANUFACT_MVS (STM_MANUFACT & FLASH_DATA_MASK)
|
||||
|
||||
#define AUTOSELECT_ADDR1 0x0555
|
||||
#define AUTOSELECT_ADDR2 0x02AA
|
||||
#define AUTOSELECT_ADDR3 AUTOSELECT_ADDR1
|
||||
|
||||
#define AUTOSELECT_DATA1 (0x00AA00AA & FLASH_DATA_MASK)
|
||||
#define AUTOSELECT_DATA2 (0x00550055 & FLASH_DATA_MASK)
|
||||
#define AUTOSELECT_DATA3 (0x00900090 & FLASH_DATA_MASK)
|
||||
|
||||
#define RESET_BANK_DATA (0x00F000F0 & FLASH_DATA_MASK)
|
||||
|
||||
static ulong flash_get_size (vu_long *address, flash_info_t *info)
|
||||
{
|
||||
short i;
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
ushort value;
|
||||
vu_short *addr = (vu_short *)address;
|
||||
#else
|
||||
ulong value;
|
||||
vu_long *addr = (vu_long *)address;
|
||||
#endif
|
||||
ulong base = (ulong)address;
|
||||
|
||||
/* Write auto select command: read Manufacturer ID */
|
||||
addr[AUTOSELECT_ADDR1] = AUTOSELECT_DATA1;
|
||||
addr[AUTOSELECT_ADDR2] = AUTOSELECT_DATA2;
|
||||
addr[AUTOSELECT_ADDR3] = AUTOSELECT_DATA3;
|
||||
|
||||
value = addr[0]; /* manufacturer ID */
|
||||
switch (value) {
|
||||
case AMD_MANUFACT_MVS:
|
||||
info->flash_id = FLASH_MAN_AMD;
|
||||
break;
|
||||
case FUJ_MANUFACT_MVS:
|
||||
info->flash_id = FLASH_MAN_FUJ;
|
||||
break;
|
||||
case STM_MANUFACT_MVS:
|
||||
info->flash_id = FLASH_MAN_STM;
|
||||
break;
|
||||
default:
|
||||
info->flash_id = FLASH_UNKNOWN;
|
||||
info->sector_count = 0;
|
||||
info->size = 0;
|
||||
return (0); /* no or unknown flash */
|
||||
}
|
||||
|
||||
value = addr[1]; /* device ID */
|
||||
switch (value) {
|
||||
case AMD_ID_LV160T_MVS:
|
||||
info->flash_id += FLASH_AM160T;
|
||||
info->sector_count = 37;
|
||||
info->size = (0x00200000 << FLASH_SHIFT);
|
||||
break; /* => 2 or 4 MB */
|
||||
|
||||
case AMD_ID_LV160B_MVS:
|
||||
info->flash_id += FLASH_AM160B;
|
||||
info->sector_count = 37;
|
||||
info->size = (0x00200000 << FLASH_SHIFT);
|
||||
break; /* => 2 or 4 MB */
|
||||
|
||||
case AMD_ID_LV320T_MVS:
|
||||
info->flash_id += FLASH_AM320T;
|
||||
info->sector_count = 71;
|
||||
info->size = (0x00400000 << FLASH_SHIFT);
|
||||
break; /* => 4 or 8 MB */
|
||||
|
||||
case AMD_ID_LV320B_MVS:
|
||||
info->flash_id += FLASH_AM320B;
|
||||
info->sector_count = 71;
|
||||
info->size = (0x00400000 << FLASH_SHIFT);
|
||||
break; /* => 4 or 8MB */
|
||||
|
||||
case STM_ID_W320DT_MVS:
|
||||
info->flash_id += FLASH_STMW320DT;
|
||||
info->sector_count = 67;
|
||||
info->size = (0x00400000 << FLASH_SHIFT);
|
||||
break; /* => 4 or 8 MB */
|
||||
|
||||
case STM_ID_W320DB_MVS:
|
||||
info->flash_id += FLASH_STMW320DB;
|
||||
info->sector_count = 67;
|
||||
info->size = (0x00400000 << FLASH_SHIFT);
|
||||
break; /* => 4 or 8MB */
|
||||
|
||||
default:
|
||||
info->flash_id = FLASH_UNKNOWN;
|
||||
return (0); /* => no or unknown flash */
|
||||
|
||||
}
|
||||
|
||||
/* set up sector start address table */
|
||||
flash_get_offsets (base, info);
|
||||
|
||||
/* check for protected sectors */
|
||||
for (i = 0; i < info->sector_count; i++) {
|
||||
/* read sector protection at sector address, (A7 .. A0) = 0x02 */
|
||||
/* D0 = 1 if protected */
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
addr = (vu_short *)(info->start[i]);
|
||||
#else
|
||||
addr = (vu_long *)(info->start[i]);
|
||||
#endif
|
||||
info->protect[i] = addr[2] & 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Prevent writes to uninitialized FLASH.
|
||||
*/
|
||||
if (info->flash_id != FLASH_UNKNOWN) {
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
addr = (vu_short *)info->start[0];
|
||||
#else
|
||||
addr = (vu_long *)info->start[0];
|
||||
#endif
|
||||
*addr = RESET_BANK_DATA; /* reset bank */
|
||||
}
|
||||
|
||||
return (info->size);
|
||||
}
|
||||
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#define ERASE_ADDR1 0x0555
|
||||
#define ERASE_ADDR2 0x02AA
|
||||
#define ERASE_ADDR3 ERASE_ADDR1
|
||||
#define ERASE_ADDR4 ERASE_ADDR1
|
||||
#define ERASE_ADDR5 ERASE_ADDR2
|
||||
|
||||
#define ERASE_DATA1 (0x00AA00AA & FLASH_DATA_MASK)
|
||||
#define ERASE_DATA2 (0x00550055 & FLASH_DATA_MASK)
|
||||
#define ERASE_DATA3 (0x00800080 & FLASH_DATA_MASK)
|
||||
#define ERASE_DATA4 ERASE_DATA1
|
||||
#define ERASE_DATA5 ERASE_DATA2
|
||||
|
||||
#define ERASE_SECTOR_DATA (0x00300030 & FLASH_DATA_MASK)
|
||||
#define ERASE_CHIP_DATA (0x00100010 & FLASH_DATA_MASK)
|
||||
#define ERASE_CONFIRM_DATA (0x00800080 & FLASH_DATA_MASK)
|
||||
|
||||
int flash_erase (flash_info_t *info, int s_first, int s_last)
|
||||
{
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
vu_short *addr = (vu_short *)(info->start[0]);
|
||||
#else
|
||||
vu_long *addr = (vu_long *)(info->start[0]);
|
||||
#endif
|
||||
int flag, prot, sect, l_sect;
|
||||
ulong start, now, last;
|
||||
|
||||
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) ||
|
||||
(info->flash_id > FLASH_AMD_COMP)) {
|
||||
printf ("Can't erase unknown flash type %08lx - aborted\n",
|
||||
info->flash_id);
|
||||
return 1;
|
||||
}
|
||||
|
||||
prot = 0;
|
||||
for (sect=s_first; sect<=s_last; ++sect) {
|
||||
if (info->protect[sect]) {
|
||||
prot++;
|
||||
}
|
||||
}
|
||||
|
||||
if (prot) {
|
||||
printf ("- Warning: %d protected sectors will not be erased!\n",
|
||||
prot);
|
||||
} else {
|
||||
printf ("\n");
|
||||
}
|
||||
|
||||
l_sect = -1;
|
||||
|
||||
/* Disable interrupts which might cause a timeout here */
|
||||
flag = disable_interrupts();
|
||||
|
||||
addr[ERASE_ADDR1] = ERASE_DATA1;
|
||||
addr[ERASE_ADDR2] = ERASE_DATA2;
|
||||
addr[ERASE_ADDR3] = ERASE_DATA3;
|
||||
addr[ERASE_ADDR4] = ERASE_DATA4;
|
||||
addr[ERASE_ADDR5] = ERASE_DATA5;
|
||||
|
||||
/* Start erase on unprotected sectors */
|
||||
for (sect = s_first; sect<=s_last; sect++) {
|
||||
if (info->protect[sect] == 0) { /* not protected */
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
addr = (vu_short *)(info->start[sect]);
|
||||
#else
|
||||
addr = (vu_long *)(info->start[sect]);
|
||||
#endif
|
||||
addr[0] = ERASE_SECTOR_DATA;
|
||||
l_sect = sect;
|
||||
}
|
||||
}
|
||||
|
||||
/* re-enable interrupts if necessary */
|
||||
if (flag)
|
||||
enable_interrupts();
|
||||
|
||||
/* wait at least 80us - let's wait 1 ms */
|
||||
udelay (1000);
|
||||
|
||||
/*
|
||||
* We wait for the last triggered sector
|
||||
*/
|
||||
if (l_sect < 0)
|
||||
goto DONE;
|
||||
|
||||
start = get_timer (0);
|
||||
last = start;
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
addr = (vu_short *)(info->start[l_sect]);
|
||||
#else
|
||||
addr = (vu_long *)(info->start[l_sect]);
|
||||
#endif
|
||||
while ((addr[0] & ERASE_CONFIRM_DATA) != ERASE_CONFIRM_DATA) {
|
||||
if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
|
||||
printf ("Timeout\n");
|
||||
return 1;
|
||||
}
|
||||
/* show that we're waiting */
|
||||
if ((now - last) > 1000) { /* every second */
|
||||
putc ('.');
|
||||
last = now;
|
||||
}
|
||||
}
|
||||
|
||||
DONE:
|
||||
/* reset to read mode */
|
||||
#ifdef CONFIG_MVS_16BIT_FLASH
|
||||
addr = (vu_short *)info->start[0];
|
||||
#else
|
||||
addr = (vu_long *)info->start[0];
|
||||
#endif
|
||||
addr[0] = RESET_BANK_DATA; /* reset bank */
|
||||
|
||||
printf (" done\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Copy memory to flash, returns:
|
||||
* 0 - OK
|
||||
* 1 - write timeout
|
||||
* 2 - Flash not erased
|
||||
*/
|
||||
|
||||
int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
|
||||
{
|
||||
#define BUFF_INC 4
|
||||
ulong cp, wp, data;
|
||||
int i, l, rc;
|
||||
|
||||
mvdebug (("+write_buff %p ==> 0x%08lx, count = 0x%08lx\n", src, addr, cnt));
|
||||
|
||||
wp = (addr & ~3); /* get lower word aligned address */
|
||||
/*
|
||||
* handle unaligned start bytes
|
||||
*/
|
||||
if ((l = addr - wp) != 0) {
|
||||
mvdebug ((" handle unaligned start bytes (cnt = 0x%08%lx)\n", cnt));
|
||||
data = 0;
|
||||
for (i=0, cp=wp; i<l; ++i, ++cp) {
|
||||
data = (data << 8) | (*(uchar *)cp);
|
||||
}
|
||||
for (; i<BUFF_INC && cnt>0; ++i) {
|
||||
data = (data << 8) | *src++;
|
||||
--cnt;
|
||||
++cp;
|
||||
}
|
||||
for (; cnt==0 && i<BUFF_INC; ++i, ++cp) {
|
||||
data = (data << 8) | (*(uchar *)cp);
|
||||
}
|
||||
|
||||
if ((rc = write_word(info, wp, data)) != 0) {
|
||||
return (rc);
|
||||
}
|
||||
wp += BUFF_INC;
|
||||
}
|
||||
|
||||
/*
|
||||
* handle (half)word aligned part
|
||||
*/
|
||||
mvdebug ((" handle word aligned part (cnt = 0x%08%lx)\n", cnt));
|
||||
while (cnt >= BUFF_INC) {
|
||||
data = 0;
|
||||
for (i=0; i<BUFF_INC; ++i) {
|
||||
data = (data << 8) | *src++;
|
||||
}
|
||||
if ((rc = write_word(info, wp, data)) != 0) {
|
||||
return (rc);
|
||||
}
|
||||
wp += BUFF_INC;
|
||||
cnt -= BUFF_INC;
|
||||
}
|
||||
|
||||
if (cnt == 0) {
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* handle unaligned tail bytes
|
||||
*/
|
||||
mvdebug ((" handle unaligned tail bytes (cnt = 0x%08%lx)\n", cnt));
|
||||
data = 0;
|
||||
for (i=0, cp=wp; i<BUFF_INC && cnt>0; ++i, ++cp) {
|
||||
data = (data << 8) | *src++;
|
||||
--cnt;
|
||||
}
|
||||
for (; i<BUFF_INC; ++i, ++cp) {
|
||||
data = (data << 8) | (*(uchar *)cp);
|
||||
}
|
||||
|
||||
return (write_word(info, wp, data));
|
||||
}
|
||||
|
||||
#define WRITE_ADDR1 0x0555
|
||||
#define WRITE_ADDR2 0x02AA
|
||||
#define WRITE_ADDR3 WRITE_ADDR1
|
||||
|
||||
#define WRITE_DATA1 (0x00AA00AA & FLASH_DATA_MASK)
|
||||
#define WRITE_DATA2 (0x00550055 & FLASH_DATA_MASK)
|
||||
#define WRITE_DATA3 (0x00A000A0 & FLASH_DATA_MASK)
|
||||
|
||||
#define WRITE_CONFIRM_DATA ERASE_CONFIRM_DATA
|
||||
|
||||
#ifndef CONFIG_MVS_16BIT_FLASH
|
||||
/*-----------------------------------------------------------------------
|
||||
* Write a word to Flash, returns:
|
||||
* 0 - OK
|
||||
* 1 - write timeout
|
||||
* 2 - Flash not erased
|
||||
*/
|
||||
static int write_word (flash_info_t *info, ulong dest, ulong data)
|
||||
{
|
||||
vu_long *addr = (vu_long *)(info->start[0]);
|
||||
ulong start;
|
||||
int flag;
|
||||
|
||||
mvdebug (("+write_word (to 0x%08lx)\n", dest));
|
||||
/* Check if Flash is (sufficiently) erased */
|
||||
if ((*((vu_long *)dest) & data) != data) {
|
||||
return (2);
|
||||
}
|
||||
/* Disable interrupts which might cause a timeout here */
|
||||
flag = disable_interrupts();
|
||||
|
||||
addr[WRITE_ADDR1] = WRITE_DATA1;
|
||||
addr[WRITE_ADDR2] = WRITE_DATA2;
|
||||
addr[WRITE_ADDR3] = WRITE_DATA3;
|
||||
|
||||
*((vu_long *)dest) = data;
|
||||
|
||||
/* re-enable interrupts if necessary */
|
||||
if (flag)
|
||||
enable_interrupts();
|
||||
|
||||
/* data polling for D7 */
|
||||
start = get_timer (0);
|
||||
addr = (vu_long *)dest;
|
||||
while ((*addr & WRITE_CONFIRM_DATA) != (data & WRITE_CONFIRM_DATA)) {
|
||||
if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
|
||||
return (1);
|
||||
}
|
||||
}
|
||||
|
||||
mvdebug (("-write_word\n"));
|
||||
return (0);
|
||||
}
|
||||
#else /* CONFIG_MVS_16BIT_FLASH */
|
||||
/*-----------------------------------------------------------------------
|
||||
* Write a halfword to Flash, returns:
|
||||
* 0 - OK
|
||||
* 1 - write timeout
|
||||
* 2 - Flash not erased
|
||||
*/
|
||||
static int write_halfword (flash_info_t *info, ulong dest, ushort data)
|
||||
{
|
||||
vu_short *addr = (vu_short *)(info->start[0]);
|
||||
ulong start;
|
||||
int flag;
|
||||
|
||||
mvdebug (("+write_halfword (to 0x%08lx)\n", dest));
|
||||
/* Check if Flash is (sufficiently) erased */
|
||||
if ((*((vu_short *)dest) & data) != data) {
|
||||
return (2);
|
||||
}
|
||||
/* Disable interrupts which might cause a timeout here */
|
||||
flag = disable_interrupts();
|
||||
|
||||
addr[WRITE_ADDR1] = WRITE_DATA1;
|
||||
addr[WRITE_ADDR2] = WRITE_DATA2;
|
||||
addr[WRITE_ADDR3] = WRITE_DATA3;
|
||||
|
||||
*((vu_short *)dest) = data;
|
||||
|
||||
/* re-enable interrupts if necessary */
|
||||
if (flag)
|
||||
enable_interrupts();
|
||||
|
||||
/* data polling for D7 */
|
||||
start = get_timer (0);
|
||||
addr = (vu_short *)dest;
|
||||
while ((*addr & WRITE_CONFIRM_DATA) != (data & WRITE_CONFIRM_DATA)) {
|
||||
if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
|
||||
return (1);
|
||||
}
|
||||
}
|
||||
mvdebug (("-write_halfword\n"));
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Write a word to Flash, returns:
|
||||
* 0 - OK
|
||||
* 1 - write timeout
|
||||
* 2 - Flash not erased
|
||||
*/
|
||||
static int write_word (flash_info_t *info, ulong dest, ulong data)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
if (write_halfword (info, dest, (data & ~FLASH_DATA_MASK) >> 16) == 0)
|
||||
{
|
||||
dest += 2;
|
||||
data = data & FLASH_DATA_MASK;
|
||||
result = write_halfword (info, dest, data);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
/*-----------------------------------------------------------------------
|
||||
*/
|
||||
Loading…
Reference in New Issue