438 lines
10 KiB
C
438 lines
10 KiB
C
/*
|
|
* (C) Copyright 2005
|
|
* Thomas.Lange@corelatus.se
|
|
*
|
|
* 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 <command.h>
|
|
#include <asm/au1x00.h>
|
|
#include <asm/addrspace.h>
|
|
#include <asm/mipsregs.h>
|
|
#include <asm/io.h>
|
|
#include <watchdog.h>
|
|
|
|
#include "ee_access.h"
|
|
|
|
static int wdi_status = 0;
|
|
|
|
#define SDRAM_SIZE ((64*1024*1024)-(12*4096))
|
|
|
|
|
|
#define SERIAL_LOG_BUFFER CKSEG1ADDR(SDRAM_SIZE + (8*4096))
|
|
|
|
void inline log_serial_char(char c){
|
|
char *serial_log_buffer = (char*)SERIAL_LOG_BUFFER;
|
|
int serial_log_offset;
|
|
u32 *serial_log_offsetp = (u32*)SERIAL_LOG_BUFFER;
|
|
|
|
serial_log_offset = *serial_log_offsetp;
|
|
|
|
*(serial_log_buffer + serial_log_offset) = c;
|
|
|
|
serial_log_offset++;
|
|
|
|
if(serial_log_offset >= 4096){
|
|
serial_log_offset = 4;
|
|
}
|
|
*serial_log_offsetp = serial_log_offset;
|
|
}
|
|
|
|
void init_log_serial(void){
|
|
char *serial_log_buffer = (char*)SERIAL_LOG_BUFFER;
|
|
u32 *serial_log_offsetp = (u32*)SERIAL_LOG_BUFFER;
|
|
|
|
/* Copy buffer from last run */
|
|
memcpy(serial_log_buffer + 4096,
|
|
serial_log_buffer,
|
|
4096);
|
|
|
|
memset(serial_log_buffer, 0, 4096);
|
|
|
|
*serial_log_offsetp = 4;
|
|
}
|
|
|
|
|
|
void hw_watchdog_reset(void){
|
|
volatile u32 *sys_outputset = (volatile u32*)SYS_OUTPUTSET;
|
|
volatile u32 *sys_outputclear = (volatile u32*)SYS_OUTPUTCLR;
|
|
if(wdi_status){
|
|
*sys_outputset = GPIO_CPU_LED|GPIO_WDI;
|
|
wdi_status = 0;
|
|
}
|
|
else{
|
|
*sys_outputclear = GPIO_CPU_LED|GPIO_WDI;
|
|
wdi_status = 1;
|
|
}
|
|
}
|
|
|
|
phys_size_t initdram(int board_type)
|
|
{
|
|
/* Sdram is setup by assembler code */
|
|
/* If memory could be changed, we should return the true value here */
|
|
|
|
WATCHDOG_RESET();
|
|
|
|
return (SDRAM_SIZE);
|
|
}
|
|
|
|
/* In cpu/mips/cpu.c */
|
|
void write_one_tlb( int index, u32 pagemask, u32 hi, u32 low0, u32 low1 );
|
|
|
|
void set_ledcard(u32 value){
|
|
/* Clock 24 bits to led card */
|
|
int i;
|
|
volatile u32 *sys_outputset = (volatile u32*)SYS_OUTPUTSET;
|
|
volatile u32 *sys_outputclr = (volatile u32*)SYS_OUTPUTCLR;
|
|
|
|
/* Start with known values */
|
|
*sys_outputclr = GPIO_LEDCLK|GPIO_LEDD;
|
|
|
|
for(i=0;i<24;i++){
|
|
if(value&0x00800000){
|
|
*sys_outputset = GPIO_LEDD;
|
|
}
|
|
else{
|
|
*sys_outputclr = GPIO_LEDD;
|
|
}
|
|
udelay(1);
|
|
*sys_outputset = GPIO_LEDCLK;
|
|
udelay(1);
|
|
*sys_outputclr = GPIO_LEDCLK;
|
|
udelay(1);
|
|
|
|
value<<=1;
|
|
}
|
|
/* Data is enable output */
|
|
*sys_outputset = GPIO_LEDD;
|
|
}
|
|
|
|
int checkboard (void)
|
|
{
|
|
volatile u32 *sys_counter = (volatile u32*)SYS_COUNTER_CNTRL;
|
|
volatile u32 *sys_outputset = (volatile u32*)SYS_OUTPUTSET;
|
|
volatile u32 *sys_outputclr = (volatile u32*)SYS_OUTPUTCLR;
|
|
u32 proc_id;
|
|
|
|
WATCHDOG_RESET();
|
|
|
|
*sys_counter = 0x100; /* Enable 32 kHz oscillator for RTC/TOY */
|
|
|
|
proc_id = read_c0_prid();
|
|
|
|
switch (proc_id >> 24) {
|
|
case 0:
|
|
puts ("Board: GTH2\n");
|
|
printf ("CPU: Au1000 500 MHz, id: 0x%02x, rev: 0x%02x\n",
|
|
(proc_id >> 8) & 0xFF, proc_id & 0xFF);
|
|
break;
|
|
default:
|
|
printf ("Unsupported cpu %d, proc_id=0x%x\n", proc_id >> 24, proc_id);
|
|
}
|
|
|
|
set_io_port_base(0);
|
|
|
|
#ifdef CONFIG_IDE_PCMCIA
|
|
/* PCMCIA is on a 36 bit physical address.
|
|
We need to map it into a 32 bit addresses */
|
|
write_one_tlb(20, /* index */
|
|
0x01ffe000, /* Pagemask, 16 MB pages */
|
|
CONFIG_SYS_PCMCIA_IO_BASE, /* Hi */
|
|
0x3C000017, /* Lo0 */
|
|
0x3C200017); /* Lo1 */
|
|
|
|
write_one_tlb(21, /* index */
|
|
0x01ffe000, /* Pagemask, 16 MB pages */
|
|
CONFIG_SYS_PCMCIA_ATTR_BASE, /* Hi */
|
|
0x3D000017, /* Lo0 */
|
|
0x3D200017); /* Lo1 */
|
|
|
|
write_one_tlb(22, /* index */
|
|
0x01ffe000, /* Pagemask, 16 MB pages */
|
|
CONFIG_SYS_PCMCIA_MEM_ADDR, /* Hi */
|
|
0x3E000017, /* Lo0 */
|
|
0x3E200017); /* Lo1 */
|
|
|
|
#endif /* CONFIG_IDE_PCMCIA */
|
|
|
|
/* Wait for GPIO ports to become stable */
|
|
udelay(5000); /* FIXME */
|
|
|
|
/* Release reset of ethernet PHY chips */
|
|
/* Always do this, because linux does not know about it */
|
|
*sys_outputset = GPIO_ERESET;
|
|
|
|
/* Kill FPGA:s */
|
|
*sys_outputclr = GPIO_CACONFIG|GPIO_DPACONFIG;
|
|
udelay(2);
|
|
*sys_outputset = GPIO_CACONFIG|GPIO_DPACONFIG;
|
|
|
|
/* Turn front led yellow */
|
|
set_ledcard(0x00100000);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define POWER_OFFSET 0xF0000
|
|
#define SW_WATCHDOG_REASON 13
|
|
|
|
#define BOOTDATA_OFFSET 0xF8000
|
|
#define MAX_ATTEMPTS 5
|
|
|
|
#define FAILSAFE_BOOT 1
|
|
#define SYSTEM_BOOT 2
|
|
#define SYSTEM2_BOOT 3
|
|
|
|
#define WRITE_FLASH16(a, d) \
|
|
do \
|
|
{ \
|
|
*((volatile u16 *) (a)) = (d);\
|
|
} while(0)
|
|
|
|
static void write_bootdata (volatile u16 * addr, u8 System, u8 Count)
|
|
{
|
|
u16 data;
|
|
volatile u16 *flash = (u16 *) (CONFIG_SYS_FLASH_BASE);
|
|
|
|
switch(System){
|
|
case FAILSAFE_BOOT:
|
|
printf ("Setting failsafe boot in flash\n");
|
|
break;
|
|
case SYSTEM_BOOT:
|
|
printf ("Setting system boot in flash\n");
|
|
break;
|
|
case SYSTEM2_BOOT:
|
|
printf ("Setting system2 boot in flash\n");
|
|
break;
|
|
default:
|
|
printf ("Invalid system data %u, setting failsafe\n", System);
|
|
System = FAILSAFE_BOOT;
|
|
}
|
|
|
|
if ((Count < 1) | (Count > MAX_ATTEMPTS)) {
|
|
printf ("Invalid boot count %u, setting 1\n", Count);
|
|
Count = 1;
|
|
}
|
|
|
|
printf ("Boot attempt %d\n", Count);
|
|
|
|
data = (System << 8) | Count;
|
|
/* AMD 16 bit */
|
|
WRITE_FLASH16 (&flash[0x555], 0xAAAA);
|
|
WRITE_FLASH16 (&flash[0x2AA], 0x5555);
|
|
WRITE_FLASH16 (&flash[0x555], 0xA0A0);
|
|
|
|
WRITE_FLASH16 (addr, data);
|
|
}
|
|
|
|
static int random_system(void){
|
|
/* EEPROM read failed. Just try to choose one
|
|
system release and hope it works */
|
|
|
|
/* FIXME */
|
|
return(SYSTEM_BOOT);
|
|
}
|
|
|
|
static int switch_system(int old_system){
|
|
u8 Rx[10];
|
|
u8 Tx[5];
|
|
int valid_release;
|
|
|
|
if(old_system==FAILSAFE_BOOT){
|
|
/* Find out which system release to use */
|
|
|
|
/* Copy from nvram to scratchpad */
|
|
Tx[0] = RECALL_MEMORY;
|
|
Tx[1] = 7; /* Page */
|
|
if (ee_do_cpu_command (Tx, 2, NULL, 0, 1)) {
|
|
printf ("EE user page 7 recall failed\n");
|
|
return (random_system());
|
|
}
|
|
|
|
Tx[0] = READ_SCRATCHPAD;
|
|
if (ee_do_cpu_command (Tx, 2, Rx, 9, 1)) {
|
|
printf ("EE user page 7 read failed\n");
|
|
return (random_system());
|
|
}
|
|
/* Crc in 9:th byte */
|
|
if (!ee_crc_ok (Rx, 8, *(Rx + 8))) {
|
|
printf ("EE read failed, page 7. CRC error\n");
|
|
return (random_system());
|
|
}
|
|
|
|
valid_release = Rx[7];
|
|
if((valid_release==0xFF)|
|
|
((valid_release&1) == 0)){
|
|
return(SYSTEM_BOOT);
|
|
}
|
|
else{
|
|
return(SYSTEM2_BOOT);
|
|
}
|
|
}
|
|
else{
|
|
return(FAILSAFE_BOOT);
|
|
}
|
|
}
|
|
|
|
static void check_boot_tries (void)
|
|
{
|
|
/* Count the number of boot attemps
|
|
switch system if too many */
|
|
|
|
int i;
|
|
volatile u16 *addr;
|
|
volatile u16 data;
|
|
u8 system = FAILSAFE_BOOT;
|
|
u8 count;
|
|
|
|
addr = (u16 *) (CONFIG_SYS_FLASH_BASE + BOOTDATA_OFFSET);
|
|
|
|
if (*addr == 0xFFFF) {
|
|
printf ("*** No bootdata exists. ***\n");
|
|
write_bootdata (addr, FAILSAFE_BOOT, 1);
|
|
} else {
|
|
/* Search for latest written bootdata */
|
|
i = 0;
|
|
while ((*(addr + 1) != 0xFFFF) & (i < 8000)) {
|
|
addr++;
|
|
i++;
|
|
}
|
|
if (i >= 8000) {
|
|
/* Whoa, dont write any more */
|
|
printf ("*** No bootdata found. Not updating flash***\n");
|
|
} else {
|
|
/* See how many times we have tried to boot real system */
|
|
data = *addr;
|
|
system = data >> 8;
|
|
count = data & 0xFF;
|
|
if ((system != SYSTEM_BOOT) &
|
|
(system != SYSTEM2_BOOT) &
|
|
(system != FAILSAFE_BOOT)) {
|
|
printf ("*** Wrong system %d\n", system);
|
|
system = FAILSAFE_BOOT;
|
|
count = 1;
|
|
} else {
|
|
switch (count) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
/* Try same system again if needed */
|
|
count++;
|
|
break;
|
|
|
|
case 5:
|
|
/* Switch system and reset tries */
|
|
count = 1;
|
|
system = switch_system(system);
|
|
printf ("***Too many boot attempts, switching system***\n");
|
|
break;
|
|
default:
|
|
/* Switch system, start over and hope it works */
|
|
printf ("***Unexpected data on addr 0x%x, %u***\n",
|
|
(u32) addr, data);
|
|
count = 1;
|
|
system = switch_system(system);
|
|
}
|
|
}
|
|
write_bootdata (addr + 1, system, count);
|
|
}
|
|
}
|
|
switch(system){
|
|
case FAILSAFE_BOOT:
|
|
printf ("Booting failsafe system\n");
|
|
setenv ("bootargs", "panic=1 root=/dev/hda7");
|
|
setenv ("bootcmd", "ide reset;disk 0x81000000 0:5;run addmisc;bootm");
|
|
break;
|
|
|
|
case SYSTEM_BOOT:
|
|
printf ("Using normal system\n");
|
|
setenv ("bootargs", "panic=1 root=/dev/hda4");
|
|
setenv ("bootcmd", "ide reset;disk 0x81000000 0:2;run addmisc;bootm");
|
|
break;
|
|
|
|
case SYSTEM2_BOOT:
|
|
printf ("Using normal system2\n");
|
|
setenv ("bootargs", "panic=1 root=/dev/hda9");
|
|
setenv ("bootcmd", "ide reset;disk 0x81000000 0:8;run addmisc;bootm");
|
|
break;
|
|
default:
|
|
printf ("Invalid system %d\n", system);
|
|
printf ("Hanging\n");
|
|
while(1);
|
|
}
|
|
}
|
|
|
|
int misc_init_r(void){
|
|
u8 Rx[80];
|
|
u8 Tx[5];
|
|
int page;
|
|
int read = 0;
|
|
|
|
WATCHDOG_RESET();
|
|
|
|
if (ee_init_cpu_data ()) {
|
|
printf ("EEPROM init failed\n");
|
|
return (0);
|
|
}
|
|
|
|
/* Check which release to boot */
|
|
check_boot_tries ();
|
|
|
|
/* Read the pages where ethernet address is stored */
|
|
|
|
for (page = EE_USER_PAGE_0; page <= EE_USER_PAGE_0 + 2; page++) {
|
|
/* Copy from nvram to scratchpad */
|
|
Tx[0] = RECALL_MEMORY;
|
|
Tx[1] = page;
|
|
if (ee_do_cpu_command (Tx, 2, NULL, 0, 1)) {
|
|
printf ("EE user page %d recall failed\n", page);
|
|
return (0);
|
|
}
|
|
|
|
Tx[0] = READ_SCRATCHPAD;
|
|
if (ee_do_cpu_command (Tx, 2, Rx + read, 9, 1)) {
|
|
printf ("EE user page %d read failed\n", page);
|
|
return (0);
|
|
}
|
|
/* Crc in 9:th byte */
|
|
if (!ee_crc_ok (Rx + read, 8, *(Rx + read + 8))) {
|
|
printf ("EE read failed, page %d. CRC error\n", page);
|
|
return (0);
|
|
}
|
|
read += 8;
|
|
}
|
|
|
|
/* Add eos after eth addr */
|
|
Rx[17] = 0;
|
|
|
|
printf ("Ethernet addr read from eeprom: %s\n\n", Rx);
|
|
|
|
if ((Rx[2] != ':') |
|
|
(Rx[5] != ':') |
|
|
(Rx[8] != ':') | (Rx[11] != ':') | (Rx[14] != ':')) {
|
|
printf ("*** ethernet addr invalid, using default ***\n");
|
|
} else {
|
|
setenv ("ethaddr", (char *)Rx);
|
|
}
|
|
return (0);
|
|
}
|