[people/ms/u-boot.git] / board / pcs440ep / pcs440ep.c

/*
 * (C) Copyright 2006
 * Stefan Roese, DENX Software Engineering, sr@denx.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 <ppc4xx.h>
#include <malloc.h>
#include <command.h>
#include <crc.h>
#include <asm/processor.h>
#include <spd_sdram.h>
#include <status_led.h>
#include <sha1.h>
#include <asm/io.h>
#include <net.h>

DECLARE_GLOBAL_DATA_PTR;

extern flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips	*/

unsigned char	sha1_checksum[SHA1_SUM_LEN];

/* swap 4 Bits (Bit0 = Bit3, Bit1 = Bit2, Bit2 = Bit1 and Bit3 = Bit0) */
unsigned char swapbits[16] = {0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
			      0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf};

static void set_leds (int val)
{
	out32(GPIO0_OR, (in32 (GPIO0_OR) & ~0x78000000) | (val << 27));
}

#define GET_LEDS ((in32 (GPIO0_OR) & 0x78000000) >> 27)

void __led_init (led_id_t mask, int state)
{
	int	val = GET_LEDS;

	if (state == STATUS_LED_ON)
		val |= mask;
	else
		val &= ~mask;
	set_leds (val);
}

void __led_set (led_id_t mask, int state)
{
	int	val = GET_LEDS;

	if (state == STATUS_LED_ON)
		val |= mask;
	else if (state == STATUS_LED_OFF)
		val &= ~mask;
	set_leds (val);
}

void __led_toggle (led_id_t mask)
{
	int	val = GET_LEDS;

	val ^= mask;
	set_leds (val);
}

static void status_led_blink (void)
{
	int	i;
	int	val = GET_LEDS;

	/* set all LED which are on, to state BLINKING */
	for (i = 0; i < 4; i++) {
		if (val & 0x01) status_led_set (3 - i, STATUS_LED_BLINKING);
		else status_led_set (3 - i, STATUS_LED_OFF);
		val = val >> 1;
	}
}

#if defined(CONFIG_SHOW_BOOT_PROGRESS)
void show_boot_progress (int val)
{
	/* find all valid Codes for val in README */
	if (val == -30) return;
	if (val < 0) {
		/* smthing goes wrong */
		status_led_blink ();
		return;
	}
	switch (val) {
		case 1:
			/* validating Image */
			status_led_set (0, STATUS_LED_OFF);
			status_led_set (1, STATUS_LED_ON);
			status_led_set (2, STATUS_LED_ON);
			break;
		case 15:
			/* booting */
			status_led_set (0, STATUS_LED_ON);
			status_led_set (1, STATUS_LED_ON);
			status_led_set (2, STATUS_LED_ON);
			break;
#if 0
		case 64:
			/* starting Ethernet configuration */
			status_led_set (0, STATUS_LED_OFF);
			status_led_set (1, STATUS_LED_OFF);
			status_led_set (2, STATUS_LED_ON);
			break;
#endif
		case 80:
			/* loading Image */
			status_led_set (0, STATUS_LED_ON);
			status_led_set (1, STATUS_LED_OFF);
			status_led_set (2, STATUS_LED_ON);
			break;
	}
}
#endif

int board_early_init_f(void)
{
	register uint reg;

	set_leds(0);			/* display boot info counter */

	/*--------------------------------------------------------------------
	 * Setup the external bus controller/chip selects
	 *-------------------------------------------------------------------*/
	mtdcr(EBC0_CFGADDR, EBC0_CFG);
	reg = mfdcr(EBC0_CFGDATA);
	mtdcr(EBC0_CFGDATA, reg | 0x04000000);	/* Set ATC */

	/*--------------------------------------------------------------------
	 * GPIO's are alreay setup in arch/powerpc/cpu/ppc4xx/cpu_init.c
	 * via define from board config file.
	 *-------------------------------------------------------------------*/

	/*--------------------------------------------------------------------
	 * Setup the interrupt controller polarities, triggers, etc.
	 *-------------------------------------------------------------------*/
	mtdcr(UIC0SR, 0xffffffff);	/* clear all */
	mtdcr(UIC0ER, 0x00000000);	/* disable all */
	mtdcr(UIC0CR, 0x00000001);	/* UIC1 crit is critical */
	mtdcr(UIC0PR, 0xfffffe1f);	/* per ref-board manual */
	mtdcr(UIC0TR, 0x01c00000);	/* per ref-board manual */
	mtdcr(UIC0VR, 0x00000001);	/* int31 highest, base=0x000 */
	mtdcr(UIC0SR, 0xffffffff);	/* clear all */

	mtdcr(UIC1SR, 0xffffffff);	/* clear all */
	mtdcr(UIC1ER, 0x00000000);	/* disable all */
	mtdcr(UIC1CR, 0x00000000);	/* all non-critical */
	mtdcr(UIC1PR, 0xffffe0ff);	/* per ref-board manual */
	mtdcr(UIC1TR, 0x00ffc000);	/* per ref-board manual */
	mtdcr(UIC1VR, 0x00000001);	/* int31 highest, base=0x000 */
	mtdcr(UIC1SR, 0xffffffff);	/* clear all */

	/*--------------------------------------------------------------------
	 * Setup other serial configuration
	 *-------------------------------------------------------------------*/
	mfsdr(SDR0_PCI0, reg);
	mtsdr(SDR0_PCI0, 0x80000000 | reg);	/* PCI arbiter enabled */
	mtsdr(SDR0_PFC0, 0x00000000);	/* Pin function: enable GPIO49-63 */
	mtsdr(SDR0_PFC1, 0x00048000);	/* Pin function: UART0 has 4 pins, select IRQ5 */

	return 0;
}

#define EEPROM_LEN	256
static void load_ethaddr(void)
{
	int	ok_ethaddr, ok_eth1addr;
	int	ret;
	uchar	buf[EEPROM_LEN];
	char	*use_eeprom;
	u16	checksumcrc16 = 0;

	/* If the env is sane, then nothing for us to do */
	ok_ethaddr = eth_getenv_enetaddr("ethaddr", buf);
	ok_eth1addr = eth_getenv_enetaddr("eth1addr", buf);
	if (ok_ethaddr && ok_eth1addr)
		return;

	/* read the MACs from EEprom */
	status_led_set (0, STATUS_LED_ON);
	status_led_set (1, STATUS_LED_ON);
	ret = eeprom_read (CONFIG_SYS_I2C_EEPROM_ADDR, 0, buf, EEPROM_LEN);
	if (ret == 0) {
		checksumcrc16 = cyg_crc16 (buf, EEPROM_LEN - 2);
		/* check, if the EEprom is programmed:
		 * - The Prefix(Byte 0,1,2) is equal to "ATR"
		 * - The checksum, stored in the last 2 Bytes, is correct
		 */
		if ((strncmp ((char *)buf,"ATR",3) != 0) ||
		    ((checksumcrc16 >> 8) != buf[EEPROM_LEN - 2]) ||
		    ((checksumcrc16 & 0xff) != buf[EEPROM_LEN - 1])) {
			/* EEprom is not programmed */
			printf("%s: EEPROM Checksum not OK\n", __FUNCTION__);
		} else {
			/* get the MACs */
			if (!ok_ethaddr)
				eth_setenv_enetaddr("ethaddr", &buf[3]);
			if (!ok_eth1addr)
				eth_setenv_enetaddr("eth1addr", &buf[9]);
			return;
		}
	}

	/* some error reading the EEprom */
	if ((use_eeprom = getenv ("use_eeprom_ethaddr")) == NULL) {
		/* dont use bootcmd */
		setenv("bootdelay", "-1");
		return;
	}
	/* == default ? use standard */
	if (strncmp (use_eeprom, "default", 7) == 0) {
		return;
	}
	/* Env doesnt exist -> hang */
	status_led_blink ();
	/* here we do this "handy" because we have no interrupts
	   at this time */
	puts ("### EEPROM ERROR ### Please RESET the board ###\n");
	for (;;) {
		__led_toggle (12);
		udelay (100000);
	}
	return;
}

#ifdef CONFIG_PREBOOT

static uchar kbd_magic_prefix[]		= "key_magic";
static uchar kbd_command_prefix[]	= "key_cmd";

struct kbd_data_t {
	char s1;
	char s2;
};

struct kbd_data_t* get_keys (struct kbd_data_t *kbd_data)
{
	char *val;
	unsigned long tmp;

	/* use the DIPs for some bootoptions */
	val = getenv (ENV_NAME_DIP);
	tmp = simple_strtoul (val, NULL, 16);

	kbd_data->s2 = (tmp & 0x0f);
	kbd_data->s1 = (tmp & 0xf0) >> 4;
	return kbd_data;
}

static int compare_magic (const struct kbd_data_t *kbd_data, char *str)
{
	char s1 = str[0];

	if (s1 >= '0' && s1 <= '9')
		s1 -= '0';
	else if (s1 >= 'a' && s1 <= 'f')
		s1 = s1 - 'a' + 10;
	else if (s1 >= 'A' && s1 <= 'F')
		s1 = s1 - 'A' + 10;
	else
		return -1;

	if (s1 != kbd_data->s1) return -1;

	s1 = str[1];
	if (s1 >= '0' && s1 <= '9')
		s1 -= '0';
	else if (s1 >= 'a' && s1 <= 'f')
		s1 = s1 - 'a' + 10;
	else if (s1 >= 'A' && s1 <= 'F')
		s1 = s1 - 'A' + 10;
	else
		return -1;

	if (s1 != kbd_data->s2) return -1;
	return 0;
}

static char *key_match (const struct kbd_data_t *kbd_data)
{
	char magic[sizeof (kbd_magic_prefix) + 1];
	char *suffix;
	char *kbd_magic_keys;

	/*
	 * The following string defines the characters that can be appended
	 * to "key_magic" to form the names of environment variables that
	 * hold "magic" key codes, i. e. such key codes that can cause
	 * pre-boot actions. If the string is empty (""), then only
	 * "key_magic" is checked (old behaviour); the string "125" causes
	 * checks for "key_magic1", "key_magic2" and "key_magic5", etc.
	 */
	if ((kbd_magic_keys = getenv ("magic_keys")) == NULL)
		kbd_magic_keys = "";

	/* loop over all magic keys;
	 * use '\0' suffix in case of empty string
	 */
	for (suffix = kbd_magic_keys; *suffix ||
		     suffix == kbd_magic_keys; ++suffix) {
		sprintf (magic, "%s%c", kbd_magic_prefix, *suffix);
		if (compare_magic (kbd_data, getenv (magic)) == 0) {
			char cmd_name[sizeof (kbd_command_prefix) + 1];
			char *cmd;

			sprintf (cmd_name, "%s%c", kbd_command_prefix, *suffix);
			cmd = getenv (cmd_name);

			return (cmd);
		}
	}
	return (NULL);
}

#endif /* CONFIG_PREBOOT */

static int pcs440ep_readinputs (void)
{
	int	i;
	char	value[20];

	/* read the inputs and set the Envvars */
	/* Revision Level Bit 26 - 29 */
	i = ((in32 (GPIO0_IR) & 0x0000003c) >> 2);
	i = swapbits[i];
	sprintf (value, "%02x", i);
	setenv (ENV_NAME_REVLEV, value);
	/* Solder Switch Bit 30 - 33 */
	i = (in32 (GPIO0_IR) & 0x00000003) << 2;
	i += (in32 (GPIO1_IR) & 0xc0000000) >> 30;
	i = swapbits[i];
	sprintf (value, "%02x", i);
	setenv (ENV_NAME_SOLDER, value);
	/* DIP Switch Bit 49 - 56 */
	i = ((in32 (GPIO1_IR) & 0x00007f80) >> 7);
	i = (swapbits[i & 0x0f] << 4) + swapbits[(i & 0xf0) >> 4];
	sprintf (value, "%02x", i);
	setenv (ENV_NAME_DIP, value);
	return 0;
}


#if defined(CONFIG_SHA1_CHECK_UB_IMG)
/*************************************************************************
 * calculate a SHA1 sum for the U-Boot image in Flash.
 *
 ************************************************************************/
static int pcs440ep_sha1 (int docheck)
{
	unsigned char *data;
	unsigned char *ptroff;
	unsigned char output[20];
	unsigned char org[20];
	int	i, len = CONFIG_SHA1_LEN;

	memcpy ((char *)CONFIG_SYS_LOAD_ADDR, (char *)CONFIG_SHA1_START, len);
	data = (unsigned char *)CONFIG_SYS_LOAD_ADDR;
	ptroff = &data[len + SHA1_SUM_POS];

	for (i = 0; i < SHA1_SUM_LEN; i++) {
		org[i] = ptroff[i];
		ptroff[i] = 0;
	}

	sha1_csum ((unsigned char *) data, len, (unsigned char *)output);

	if (docheck == 2) {
		for (i = 0; i < 20 ; i++) {
			printf("%02X ", output[i]);
		}
		printf("\n");
	}
	if (docheck == 1) {
		for (i = 0; i < 20 ; i++) {
			if (org[i] != output[i]) return 1;
		}
	}
	return 0;
}

/*************************************************************************
 * do some checks after the SHA1 checksum from the U-Boot Image was
 * calculated.
 *
 ************************************************************************/
static void pcs440ep_checksha1 (void)
{
	int	ret;
	char	*cs_test;

	status_led_set (0, STATUS_LED_OFF);
	status_led_set (1, STATUS_LED_OFF);
	status_led_set (2, STATUS_LED_ON);
	ret = pcs440ep_sha1 (1);
	if (ret == 0) return;

	if ((cs_test = getenv ("cs_test")) == NULL) {
		/* Env doesnt exist -> hang */
		status_led_blink ();
		/* here we do this "handy" because we have no interrupts
		   at this time */
		puts ("### SHA1 ERROR ### Please RESET the board ###\n");
		for (;;) {
			__led_toggle (2);
			udelay (100000);
		}
	}

	if (strncmp (cs_test, "off", 3) == 0) {
		printf ("SHA1 U-Boot sum NOT ok!\n");
		setenv ("bootdelay", "-1");
	}
}
#else
static __inline__ void pcs440ep_checksha1 (void) { do {} while (0);}
#endif

int misc_init_r (void)
{
	uint pbcr;
	int size_val = 0;

	load_ethaddr();

	/* Re-do sizing to get full correct info */
	mtdcr(EBC0_CFGADDR, PB0CR);
	pbcr = mfdcr(EBC0_CFGDATA);
	switch (gd->bd->bi_flashsize) {
	case 1 << 20:
		size_val = 0;
		break;
	case 2 << 20:
		size_val = 1;
		break;
	case 4 << 20:
		size_val = 2;
		break;
	case 8 << 20:
		size_val = 3;
		break;
	case 16 << 20:
		size_val = 4;
		break;
	case 32 << 20:
		size_val = 5;
		break;
	case 64 << 20:
		size_val = 6;
		break;
	case 128 << 20:
		size_val = 7;
		break;
	}
	pbcr = (pbcr & 0x0001ffff) | gd->bd->bi_flashstart | (size_val << 17);
	mtdcr(EBC0_CFGADDR, PB0CR);
	mtdcr(EBC0_CFGDATA, pbcr);

	/* adjust flash start and offset */
	gd->bd->bi_flashstart = 0 - gd->bd->bi_flashsize;
	gd->bd->bi_flashoffset = 0;

	/* Monitor protection ON by default */
	(void)flash_protect(FLAG_PROTECT_SET,
			    -CONFIG_SYS_MONITOR_LEN,
			    0xffffffff,
			    &flash_info[1]);

	/* Env protection ON by default */
	(void)flash_protect(FLAG_PROTECT_SET,
			    CONFIG_ENV_ADDR_REDUND,
			    CONFIG_ENV_ADDR_REDUND + 2*CONFIG_ENV_SECT_SIZE - 1,
			    &flash_info[1]);

	pcs440ep_readinputs ();
	pcs440ep_checksha1 ();
#ifdef CONFIG_PREBOOT
	{
		struct kbd_data_t kbd_data;
		/* Decode keys */
		char *str = strdup (key_match (get_keys (&kbd_data)));
		/* Set or delete definition */
		setenv ("preboot", str);
		free (str);
	}
#endif /* CONFIG_PREBOOT */
	return 0;
}

int checkboard(void)
{
	char *s = getenv("serial#");

	printf("Board: PCS440EP");
	if (s != NULL) {
		puts(", serial# ");
		puts(s);
	}
	putc('\n');

	return (0);
}

void spd_ddr_init_hang (void)
{
	status_led_set (0, STATUS_LED_OFF);
	status_led_set (1, STATUS_LED_ON);
	/* we cannot use hang() because we are still running from
	   Flash, and so the status_led driver is not initialized */
	puts ("### SDRAM ERROR ### Please RESET the board ###\n");
	for (;;) {
		__led_toggle (4);
		udelay (100000);
	}
}

phys_size_t initdram (int board_type)
{
	long dram_size = 0;

	status_led_set (0, STATUS_LED_ON);
	status_led_set (1, STATUS_LED_OFF);
	dram_size = spd_sdram();
	status_led_set (0, STATUS_LED_OFF);
	status_led_set (1, STATUS_LED_ON);
	if (dram_size == 0) {
		hang();
	}

	return dram_size;
}

/*************************************************************************
 *  hw_watchdog_reset
 *
 *	This routine is called to reset (keep alive) the watchdog timer
 *
 ************************************************************************/
#if defined(CONFIG_HW_WATCHDOG)
void hw_watchdog_reset(void)
{

}
#endif

/*************************************************************************
 * "led" Commando for the U-Boot shell
 *
 ************************************************************************/
int do_led (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	int	rcode = 0, i;
	ulong	pattern = 0;

	pattern = simple_strtoul (argv[1], NULL, 16);
	if (pattern > 0x400) {
		int	val = GET_LEDS;
		printf ("led: %x\n", val);
		return rcode;
	}
	if (pattern > 0x200) {
		status_led_blink ();
		hang ();
		return rcode;
	}
	if (pattern > 0x100) {
		status_led_blink ();
		return rcode;
	}
	pattern &= 0x0f;
	for (i = 0; i < 4; i++) {
		if (pattern & 0x01) status_led_set (i, STATUS_LED_ON);
		else status_led_set (i, STATUS_LED_OFF);
		pattern = pattern >> 1;
	}
	return rcode;
}

U_BOOT_CMD(
	led,	2,	1,	do_led,
	"set the DIAG-LED",
	"[bitmask] 0x01 = DIAG 1 on\n"
	"              0x02 = DIAG 2 on\n"
	"              0x04 = DIAG 3 on\n"
	"              0x08 = DIAG 4 on\n"
	"              > 0x100 set the LED, who are on, to state blinking"
);

#if defined(CONFIG_SHA1_CHECK_UB_IMG)
/*************************************************************************
 * "sha1" Commando for the U-Boot shell
 *
 ************************************************************************/
int do_sha1 (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	int	rcode = -1;

	if (argc < 2) {
  usage:
		cmd_usage(cmdtp);
		return 1;
	}

	if (argc >= 3) {
		unsigned char *data;
		unsigned char output[20];
		int	len;
		int	i;

		data = (unsigned char *)simple_strtoul (argv[1], NULL, 16);
		len = simple_strtoul (argv[2], NULL, 16);
		sha1_csum (data, len, (unsigned char *)output);
		printf ("U-Boot sum:\n");
		for (i = 0; i < 20 ; i++) {
			printf ("%02X ", output[i]);
		}
		printf ("\n");
		if (argc == 4) {
			data = (unsigned char *)simple_strtoul (argv[3], NULL, 16);
			memcpy (data, output, 20);
		}
		return 0;
	}
	if (argc == 2) {
		char *ptr = argv[1];
		if (*ptr != '-') goto usage;
		ptr++;
		if ((*ptr == 'c') || (*ptr == 'C')) {
			rcode = pcs440ep_sha1 (1);
			printf ("SHA1 U-Boot sum %sok!\n", (rcode != 0) ? "not " : "");
		} else if ((*ptr == 'p') || (*ptr == 'P')) {
			rcode = pcs440ep_sha1 (2);
		} else {
			rcode = pcs440ep_sha1 (0);
		}
		return rcode;
	}
	return rcode;
}

U_BOOT_CMD(
	sha1,	4,	1,	do_sha1,
	"calculate the SHA1 Sum",
	"address len [addr]  calculate the SHA1 sum [save at addr]\n"
	"     -p calculate the SHA1 sum from the U-Boot image in flash and print\n"
	"     -c check the U-Boot image in flash"
);
#endif

#if defined (CONFIG_CMD_IDE)
/* These addresses need to be shifted one place to the left
 * ( bus per_addr 20 -30 is connectsd on CF bus A10-A0)
 * These values are shifted
 */
extern ulong *ide_bus_offset;
void inline ide_outb(int dev, int port, unsigned char val)
{
	debug ("ide_outb (dev= %d, port= 0x%x, val= 0x%02x) : @ 0x%08lx\n",
		dev, port, val, (ATA_CURR_BASE(dev)+port));

	out_be16((u16 *)(ATA_CURR_BASE(dev)+(port << 1)), val);
}
unsigned char inline ide_inb(int dev, int port)
{
	uchar val;
	val = in_be16((u16 *)(ATA_CURR_BASE(dev)+(port << 1)));
	debug ("ide_inb (dev= %d, port= 0x%x) : @ 0x%08lx -> 0x%02x\n",
		dev, port, (ATA_CURR_BASE(dev)+port), val);
	return (val);
}
#endif

#ifdef CONFIG_IDE_PREINIT
int ide_preinit (void)
{
	/* Set True IDE Mode */
	out32 (GPIO0_OR, (in32 (GPIO0_OR) | 0x00100000));
	out32 (GPIO0_OR, (in32 (GPIO0_OR) | 0x00200000));
	out32 (GPIO1_OR, (in32 (GPIO1_OR) & ~0x00008040));
	udelay (100000);
	return 0;
}
#endif

#if defined (CONFIG_CMD_IDE) && defined (CONFIG_IDE_RESET)
void ide_set_reset (int idereset)
{
	debug ("ide_reset(%d)\n", idereset);
	if (idereset == 0) {
		out32 (GPIO0_OR, (in32 (GPIO0_OR) | 0x00200000));
	} else {
		out32 (GPIO0_OR, (in32 (GPIO0_OR) & ~0x00200000));
	}
	udelay (10000);
}
#endif /* defined (CONFIG_CMD_IDE) && defined (CONFIG_IDE_RESET) */
Commit	Line	Data
a4c8d138 SR	1	/*
	2	* (C) Copyright 2006
	3	* Stefan Roese, DENX Software Engineering, sr@denx.de.
	4	*
	5	* See file CREDITS for list of people who contributed to this
	6	* project.
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation; either version 2 of
	11	* the License, or (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	21	* MA 02111-1307 USA
	22	*/
	23
	24	#include <common.h>
	25	#include <ppc4xx.h>
566a494f HS	26	#include <malloc.h>
	27	#include <command.h>
	28	#include <crc.h>
a4c8d138 SR	29	#include <asm/processor.h>
a4c8d138 SR	30	#include <spd_sdram.h>
566a494f HS	31	#include <status_led.h>
566a494f HS	32	#include <sha1.h>
f98984cb	33	#include <asm/io.h>
d2567be9	34	#include <net.h>
a4c8d138 SR	35
	36	DECLARE_GLOBAL_DATA_PTR;
	37
6d0f6bcf	38	extern flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips */
a4c8d138	39
566a494f HS	40	unsigned char sha1_checksum[SHA1_SUM_LEN];
	41
	42	/* swap 4 Bits (Bit0 = Bit3, Bit1 = Bit2, Bit2 = Bit1 and Bit3 = Bit0) */
	43	unsigned char swapbits[16] = {0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
	44	0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf};
	45
	46	static void set_leds (int val)
	47	{
	48	out32(GPIO0_OR, (in32 (GPIO0_OR) & ~0x78000000) \| (val << 27));
	49	}
	50
	51	#define GET_LEDS ((in32 (GPIO0_OR) & 0x78000000) >> 27)
	52
	53	void __led_init (led_id_t mask, int state)
	54	{
	55	int val = GET_LEDS;
	56
	57	if (state == STATUS_LED_ON)
	58	val \|= mask;
	59	else
	60	val &= ~mask;
	61	set_leds (val);
	62	}
	63
	64	void __led_set (led_id_t mask, int state)
	65	{
	66	int val = GET_LEDS;
	67
	68	if (state == STATUS_LED_ON)
	69	val \|= mask;
	70	else if (state == STATUS_LED_OFF)
	71	val &= ~mask;
	72	set_leds (val);
	73	}
	74
	75	void __led_toggle (led_id_t mask)
a4c8d138	76	{
566a494f HS	77	int val = GET_LEDS;
	78
	79	val ^= mask;
	80	set_leds (val);
a4c8d138 SR	81	}
a4c8d138 SR	82
566a494f HS	83	static void status_led_blink (void)
	84	{
	85	int i;
	86	int val = GET_LEDS;
	87
	88	/* set all LED which are on, to state BLINKING */
	89	for (i = 0; i < 4; i++) {
96e1d75b HS	90	if (val & 0x01) status_led_set (3 - i, STATUS_LED_BLINKING);
	91	else status_led_set (3 - i, STATUS_LED_OFF);
	92	val = val >> 1;
566a494f HS	93	}
	94	}
	95
	96	#if defined(CONFIG_SHOW_BOOT_PROGRESS)
	97	void show_boot_progress (int val)
a4c8d138	98	{
566a494f HS	99	/* find all valid Codes for val in README */
	100	if (val == -30) return;
	101	if (val < 0) {
	102	/* smthing goes wrong */
	103	status_led_blink ();
	104	return;
	105	}
	106	switch (val) {
	107	case 1:
	108	/* validating Image */
	109	status_led_set (0, STATUS_LED_OFF);
	110	status_led_set (1, STATUS_LED_ON);
	111	status_led_set (2, STATUS_LED_ON);
	112	break;
	113	case 15:
	114	/* booting */
	115	status_led_set (0, STATUS_LED_ON);
	116	status_led_set (1, STATUS_LED_ON);
	117	status_led_set (2, STATUS_LED_ON);
	118	break;
96e1d75b	119	#if 0
566a494f HS	120	case 64:
	121	/* starting Ethernet configuration */
	122	status_led_set (0, STATUS_LED_OFF);
	123	status_led_set (1, STATUS_LED_OFF);
	124	status_led_set (2, STATUS_LED_ON);
	125	break;
96e1d75b	126	#endif
566a494f HS	127	case 80:
	128	/* loading Image */
	129	status_led_set (0, STATUS_LED_ON);
	130	status_led_set (1, STATUS_LED_OFF);
	131	status_led_set (2, STATUS_LED_ON);
	132	break;
	133	}
a4c8d138	134	}
566a494f	135	#endif
a4c8d138 SR	136
	137	int board_early_init_f(void)
	138	{
	139	register uint reg;
	140
	141	set_leds(0); /* display boot info counter */
	142
	143	/*--------------------------------------------------------------------
	144	* Setup the external bus controller/chip selects
	145	-------------------------------------------------------------------/
d1c3b275 SR	146	mtdcr(EBC0_CFGADDR, EBC0_CFG);
	147	reg = mfdcr(EBC0_CFGDATA);
	148	mtdcr(EBC0_CFGDATA, reg \| 0x04000000); /* Set ATC */
a4c8d138 SR	149
a4c8d138 SR	150	/*--------------------------------------------------------------------
a47a12be	151	* GPIO's are alreay setup in arch/powerpc/cpu/ppc4xx/cpu_init.c
a4c8d138 SR	152	* via define from board config file.
	153	-------------------------------------------------------------------/
	154
	155	/*--------------------------------------------------------------------
	156	* Setup the interrupt controller polarities, triggers, etc.
	157	-------------------------------------------------------------------/
952e7760 SR	158	mtdcr(UIC0SR, 0xffffffff); /* clear all */
	159	mtdcr(UIC0ER, 0x00000000); /* disable all */
	160	mtdcr(UIC0CR, 0x00000001); /* UIC1 crit is critical */
	161	mtdcr(UIC0PR, 0xfffffe1f); /* per ref-board manual */
	162	mtdcr(UIC0TR, 0x01c00000); /* per ref-board manual */
	163	mtdcr(UIC0VR, 0x00000001); /* int31 highest, base=0x000 */
	164	mtdcr(UIC0SR, 0xffffffff); /* clear all */
	165
	166	mtdcr(UIC1SR, 0xffffffff); /* clear all */
	167	mtdcr(UIC1ER, 0x00000000); /* disable all */
	168	mtdcr(UIC1CR, 0x00000000); /* all non-critical */
	169	mtdcr(UIC1PR, 0xffffe0ff); /* per ref-board manual */
	170	mtdcr(UIC1TR, 0x00ffc000); /* per ref-board manual */
	171	mtdcr(UIC1VR, 0x00000001); /* int31 highest, base=0x000 */
	172	mtdcr(UIC1SR, 0xffffffff); /* clear all */
a4c8d138 SR	173
	174	/*--------------------------------------------------------------------
	175	* Setup other serial configuration
	176	-------------------------------------------------------------------/
d1c3b275 SR	177	mfsdr(SDR0_PCI0, reg);
	178	mtsdr(SDR0_PCI0, 0x80000000 \| reg); /* PCI arbiter enabled */
	179	mtsdr(SDR0_PFC0, 0x00000000); /* Pin function: enable GPIO49-63 */
	180	mtsdr(SDR0_PFC1, 0x00048000); /* Pin function: UART0 has 4 pins, select IRQ5 */
a4c8d138 SR	181
	182	return 0;
	183	}
	184
566a494f	185	#define EEPROM_LEN 256
9c150102	186	static void load_ethaddr(void)
566a494f	187	{
9c150102	188	int ok_ethaddr, ok_eth1addr;
566a494f	189	int ret;
d2567be9	190	uchar buf[EEPROM_LEN];
566a494f HS	191	char *use_eeprom;
	192	u16 checksumcrc16 = 0;
	193
9c150102 MF	194	/* If the env is sane, then nothing for us to do */
	195	ok_ethaddr = eth_getenv_enetaddr("ethaddr", buf);
	196	ok_eth1addr = eth_getenv_enetaddr("eth1addr", buf);
	197	if (ok_ethaddr && ok_eth1addr)
	198	return;
	199
566a494f HS	200	/* read the MACs from EEprom */
	201	status_led_set (0, STATUS_LED_ON);
	202	status_led_set (1, STATUS_LED_ON);
d2567be9	203	ret = eeprom_read (CONFIG_SYS_I2C_EEPROM_ADDR, 0, buf, EEPROM_LEN);
566a494f	204	if (ret == 0) {
d2567be9	205	checksumcrc16 = cyg_crc16 (buf, EEPROM_LEN - 2);
566a494f HS	206	/* check, if the EEprom is programmed:
	207	* - The Prefix(Byte 0,1,2) is equal to "ATR"
	208	* - The checksum, stored in the last 2 Bytes, is correct
	209	*/
d2567be9	210	if ((strncmp ((char *)buf,"ATR",3) != 0) \|\|
4ef218f6 WD	211	((checksumcrc16 >> 8) != buf[EEPROM_LEN - 2]) \|\|
4ef218f6 WD	212	((checksumcrc16 & 0xff) != buf[EEPROM_LEN - 1])) {
566a494f HS	213	/* EEprom is not programmed */
	214	printf("%s: EEPROM Checksum not OK\n", __FUNCTION__);
	215	} else {
	216	/* get the MACs */
9c150102 MF	217	if (!ok_ethaddr)
	218	eth_setenv_enetaddr("ethaddr", &buf[3]);
	219	if (!ok_eth1addr)
	220	eth_setenv_enetaddr("eth1addr", &buf[9]);
566a494f HS	221	return;
	222	}
	223	}
	224
	225	/* some error reading the EEprom */
	226	if ((use_eeprom = getenv ("use_eeprom_ethaddr")) == NULL) {
	227	/* dont use bootcmd */
	228	setenv("bootdelay", "-1");
	229	return;
	230	}
	231	/* == default ? use standard */
	232	if (strncmp (use_eeprom, "default", 7) == 0) {
	233	return;
	234	}
	235	/* Env doesnt exist -> hang */
	236	status_led_blink ();
90790247 HS	237	/* here we do this "handy" because we have no interrupts
	238	at this time */
	239	puts ("### EEPROM ERROR ### Please RESET the board ###\n");
	240	for (;;) {
	241	__led_toggle (12);
	242	udelay (100000);
	243	}
566a494f HS	244	return;
	245	}
	246
	247	#ifdef CONFIG_PREBOOT
	248
	249	static uchar kbd_magic_prefix[] = "key_magic";
	250	static uchar kbd_command_prefix[] = "key_cmd";
	251
	252	struct kbd_data_t {
	253	char s1;
	254	char s2;
	255	};
	256
	257	struct kbd_data_t* get_keys (struct kbd_data_t *kbd_data)
	258	{
	259	char *val;
	260	unsigned long tmp;
	261
	262	/* use the DIPs for some bootoptions */
	263	val = getenv (ENV_NAME_DIP);
	264	tmp = simple_strtoul (val, NULL, 16);
	265
	266	kbd_data->s2 = (tmp & 0x0f);
	267	kbd_data->s1 = (tmp & 0xf0) >> 4;
	268	return kbd_data;
	269	}
	270
	271	static int compare_magic (const struct kbd_data_t kbd_data, char str)
	272	{
	273	char s1 = str[0];
	274
	275	if (s1 >= '0' && s1 <= '9')
	276	s1 -= '0';
	277	else if (s1 >= 'a' && s1 <= 'f')
	278	s1 = s1 - 'a' + 10;
	279	else if (s1 >= 'A' && s1 <= 'F')
	280	s1 = s1 - 'A' + 10;
	281	else
	282	return -1;
	283
	284	if (s1 != kbd_data->s1) return -1;
	285
	286	s1 = str[1];
	287	if (s1 >= '0' && s1 <= '9')
	288	s1 -= '0';
	289	else if (s1 >= 'a' && s1 <= 'f')
	290	s1 = s1 - 'a' + 10;
	291	else if (s1 >= 'A' && s1 <= 'F')
	292	s1 = s1 - 'A' + 10;
	293	else
	294	return -1;
	295
	296	if (s1 != kbd_data->s2) return -1;
	297	return 0;
	298	}
	299
	300	static char key_match (const struct kbd_data_t kbd_data)
	301	{
	302	char magic[sizeof (kbd_magic_prefix) + 1];
	303	char *suffix;
	304	char *kbd_magic_keys;
	305
	306	/*
	307	* The following string defines the characters that can be appended
308	* to "key_magic" to form the names of environment variables that
309	* hold "magic" key codes, i. e. such key codes that can cause
310	* pre-boot actions. If the string is empty (""), then only
311	* "key_magic" is checked (old behaviour); the string "125" causes
312	* checks for "key_magic1", "key_magic2" and "key_magic5", etc.
313	*/
314	if ((kbd_magic_keys = getenv ("magic_keys")) == NULL)
315	kbd_magic_keys = "";
316
317	/* loop over all magic keys;
318	* use '\0' suffix in case of empty string
319	*/
320	for (suffix = kbd_magic_keys; *suffix \|\|
321	suffix == kbd_magic_keys; ++suffix) {
322	sprintf (magic, "%s%c", kbd_magic_prefix, *suffix);
323	if (compare_magic (kbd_data, getenv (magic)) == 0) {
324	char cmd_name[sizeof (kbd_command_prefix) + 1];
325	char *cmd;
326
327	sprintf (cmd_name, "%s%c", kbd_command_prefix, *suffix);
328	cmd = getenv (cmd_name);
329
330	return (cmd);
331	}
332	}
333	return (NULL);
334	}
335
336	#endif /* CONFIG_PREBOOT */
337
338	static int pcs440ep_readinputs (void)
339	{
340	int i;
341	char value[20];
342
343	/* read the inputs and set the Envvars */
344	/* Revision Level Bit 26 - 29 */
345	i = ((in32 (GPIO0_IR) & 0x0000003c) >> 2);
346	i = swapbits[i];
347	sprintf (value, "%02x", i);
348	setenv (ENV_NAME_REVLEV, value);
349	/* Solder Switch Bit 30 - 33 */
350	i = (in32 (GPIO0_IR) & 0x00000003) << 2;
351	i += (in32 (GPIO1_IR) & 0xc0000000) >> 30;
352	i = swapbits[i];
353	sprintf (value, "%02x", i);
354	setenv (ENV_NAME_SOLDER, value);
355	/* DIP Switch Bit 49 - 56 */
356	i = ((in32 (GPIO1_IR) & 0x00007f80) >> 7);
357	i = (swapbits[i & 0x0f] << 4) + swapbits[(i & 0xf0) >> 4];
358	sprintf (value, "%02x", i);
359	setenv (ENV_NAME_DIP, value);
360	return 0;
361	}
362
363
364	#if defined(CONFIG_SHA1_CHECK_UB_IMG)
365	/*************************************************************************
366	* calculate a SHA1 sum for the U-Boot image in Flash.
367	*
368	************************************************************************/
369	static int pcs440ep_sha1 (int docheck)
370	{
371	unsigned char *data;
372	unsigned char *ptroff;
373	unsigned char output[20];
374	unsigned char org[20];
375	int i, len = CONFIG_SHA1_LEN;
376
6d0f6bcf JCPV	377	memcpy ((char )CONFIG_SYS_LOAD_ADDR, (char )CONFIG_SHA1_START, len);
6d0f6bcf JCPV	378	data = (unsigned char *)CONFIG_SYS_LOAD_ADDR;
566a494f HS	379	ptroff = &data[len + SHA1_SUM_POS];
	380
	381	for (i = 0; i < SHA1_SUM_LEN; i++) {
	382	org[i] = ptroff[i];
	383	ptroff[i] = 0;
	384	}
4ef218f6	385
566a494f HS	386	sha1_csum ((unsigned char ) data, len, (unsigned char )output);
	387
	388	if (docheck == 2) {
	389	for (i = 0; i < 20 ; i++) {
	390	printf("%02X ", output[i]);
	391	}
	392	printf("\n");
	393	}
	394	if (docheck == 1) {
	395	for (i = 0; i < 20 ; i++) {
	396	if (org[i] != output[i]) return 1;
	397	}
	398	}
	399	return 0;
	400	}
	401
	402	/*************************************************************************
	403	* do some checks after the SHA1 checksum from the U-Boot Image was
	404	* calculated.
	405	*
	406	************************************************************************/
	407	static void pcs440ep_checksha1 (void)
	408	{
	409	int ret;
	410	char *cs_test;
	411
96e1d75b HS	412	status_led_set (0, STATUS_LED_OFF);
	413	status_led_set (1, STATUS_LED_OFF);
	414	status_led_set (2, STATUS_LED_ON);
566a494f HS	415	ret = pcs440ep_sha1 (1);
	416	if (ret == 0) return;
	417
	418	if ((cs_test = getenv ("cs_test")) == NULL) {
	419	/* Env doesnt exist -> hang */
	420	status_led_blink ();
90790247 HS	421	/* here we do this "handy" because we have no interrupts
	422	at this time */
	423	puts ("### SHA1 ERROR ### Please RESET the board ###\n");
	424	for (;;) {
	425	__led_toggle (2);
	426	udelay (100000);
	427	}
566a494f HS	428	}
	429
	430	if (strncmp (cs_test, "off", 3) == 0) {
	431	printf ("SHA1 U-Boot sum NOT ok!\n");
	432	setenv ("bootdelay", "-1");
	433	}
	434	}
	435	#else
	436	static __inline__ void pcs440ep_checksha1 (void) { do {} while (0);}
	437	#endif
	438
a4c8d138 SR	439	int misc_init_r (void)
	440	{
	441	uint pbcr;
	442	int size_val = 0;
	443
9c150102 MF	444	load_ethaddr();
9c150102 MF	445
a4c8d138	446	/* Re-do sizing to get full correct info */
d1c3b275 SR	447	mtdcr(EBC0_CFGADDR, PB0CR);
d1c3b275 SR	448	pbcr = mfdcr(EBC0_CFGDATA);
a4c8d138 SR	449	switch (gd->bd->bi_flashsize) {
	450	case 1 << 20:
	451	size_val = 0;
	452	break;
	453	case 2 << 20:
	454	size_val = 1;
	455	break;
	456	case 4 << 20:
	457	size_val = 2;
	458	break;
	459	case 8 << 20:
	460	size_val = 3;
	461	break;
	462	case 16 << 20:
	463	size_val = 4;
	464	break;
	465	case 32 << 20:
	466	size_val = 5;
	467	break;
	468	case 64 << 20:
	469	size_val = 6;
	470	break;
	471	case 128 << 20:
	472	size_val = 7;
	473	break;
	474	}
	475	pbcr = (pbcr & 0x0001ffff) \| gd->bd->bi_flashstart \| (size_val << 17);
d1c3b275 SR	476	mtdcr(EBC0_CFGADDR, PB0CR);
d1c3b275 SR	477	mtdcr(EBC0_CFGDATA, pbcr);
a4c8d138 SR	478
	479	/* adjust flash start and offset */
	480	gd->bd->bi_flashstart = 0 - gd->bd->bi_flashsize;
	481	gd->bd->bi_flashoffset = 0;
	482
	483	/* Monitor protection ON by default */
	484	(void)flash_protect(FLAG_PROTECT_SET,
6d0f6bcf	485	-CONFIG_SYS_MONITOR_LEN,
a4c8d138 SR	486	0xffffffff,
	487	&flash_info[1]);
	488
	489	/* Env protection ON by default */
	490	(void)flash_protect(FLAG_PROTECT_SET,
0e8d1586 JCPV	491	CONFIG_ENV_ADDR_REDUND,
0e8d1586 JCPV	492	CONFIG_ENV_ADDR_REDUND + 2*CONFIG_ENV_SECT_SIZE - 1,
4526c87e	493	&flash_info[1]);
a4c8d138	494
566a494f HS	495	pcs440ep_readinputs ();
	496	pcs440ep_checksha1 ();
	497	#ifdef CONFIG_PREBOOT
	498	{
	499	struct kbd_data_t kbd_data;
	500	/* Decode keys */
	501	char *str = strdup (key_match (get_keys (&kbd_data)));
	502	/* Set or delete definition */
	503	setenv ("preboot", str);
	504	free (str);
	505	}
	506	#endif /* CONFIG_PREBOOT */
a4c8d138 SR	507	return 0;
	508	}
	509
	510	int checkboard(void)
	511	{
	512	char *s = getenv("serial#");
	513
	514	printf("Board: PCS440EP");
	515	if (s != NULL) {
	516	puts(", serial# ");
	517	puts(s);
	518	}
	519	putc('\n');
	520
	521	return (0);
	522	}
	523
566a494f HS	524	void spd_ddr_init_hang (void)
	525	{
	526	status_led_set (0, STATUS_LED_OFF);
	527	status_led_set (1, STATUS_LED_ON);
	528	/* we cannot use hang() because we are still running from
	529	Flash, and so the status_led driver is not initialized */
90790247	530	puts ("### SDRAM ERROR ### Please RESET the board ###\n");
566a494f HS	531	for (;;) {
	532	__led_toggle (4);
	533	udelay (100000);
	534	}
	535	}
566a494f	536
9973e3c6	537	phys_size_t initdram (int board_type)
a4c8d138 SR	538	{
	539	long dram_size = 0;
	540
566a494f HS	541	status_led_set (0, STATUS_LED_ON);
566a494f HS	542	status_led_set (1, STATUS_LED_OFF);
a4c8d138	543	dram_size = spd_sdram();
566a494f HS	544	status_led_set (0, STATUS_LED_OFF);
	545	status_led_set (1, STATUS_LED_ON);
	546	if (dram_size == 0) {
	547	hang();
	548	}
a4c8d138 SR	549
	550	return dram_size;
	551	}
	552
a4c8d138 SR	553	/*************************************************************************
	554	* hw_watchdog_reset
	555	*
	556	* This routine is called to reset (keep alive) the watchdog timer
	557	*
	558	************************************************************************/
	559	#if defined(CONFIG_HW_WATCHDOG)
	560	void hw_watchdog_reset(void)
	561	{
	562
	563	}
	564	#endif
566a494f HS	565
	566	/*************************************************************************
	567	* "led" Commando for the U-Boot shell
	568	*
	569	************************************************************************/
	570	int do_led (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
	571	{
96e1d75b	572	int rcode = 0, i;
566a494f HS	573	ulong pattern = 0;
566a494f HS	574
96e1d75b HS	575	pattern = simple_strtoul (argv[1], NULL, 16);
	576	if (pattern > 0x400) {
	577	int val = GET_LEDS;
	578	printf ("led: %x\n", val);
	579	return rcode;
	580	}
	581	if (pattern > 0x200) {
566a494f HS	582	status_led_blink ();
	583	hang ();
	584	return rcode;
	585	}
96e1d75b	586	if (pattern > 0x100) {
566a494f HS	587	status_led_blink ();
	588	return rcode;
	589	}
	590	pattern &= 0x0f;
96e1d75b HS	591	for (i = 0; i < 4; i++) {
	592	if (pattern & 0x01) status_led_set (i, STATUS_LED_ON);
	593	else status_led_set (i, STATUS_LED_OFF);
	594	pattern = pattern >> 1;
	595	}
566a494f HS	596	return rcode;
	597	}
	598
	599	U_BOOT_CMD(
53677ef1	600	led, 2, 1, do_led,
2fb2604d	601	"set the DIAG-LED",
96e1d75b HS	602	"[bitmask] 0x01 = DIAG 1 on\n"
	603	" 0x02 = DIAG 2 on\n"
	604	" 0x04 = DIAG 3 on\n"
	605	" 0x08 = DIAG 4 on\n"
a89c33db	606	" > 0x100 set the LED, who are on, to state blinking"
566a494f HS	607	);
	608
	609	#if defined(CONFIG_SHA1_CHECK_UB_IMG)
	610	/*************************************************************************
	611	* "sha1" Commando for the U-Boot shell
	612	*
	613	************************************************************************/
	614	int do_sha1 (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
	615	{
	616	int rcode = -1;
	617
	618	if (argc < 2) {
	619	usage:
62c3ae7c	620	cmd_usage(cmdtp);
566a494f HS	621	return 1;
	622	}
	623
	624	if (argc >= 3) {
	625	unsigned char *data;
	626	unsigned char output[20];
	627	int len;
	628	int i;
4ef218f6	629
566a494f HS	630	data = (unsigned char *)simple_strtoul (argv[1], NULL, 16);
	631	len = simple_strtoul (argv[2], NULL, 16);
	632	sha1_csum (data, len, (unsigned char *)output);
	633	printf ("U-Boot sum:\n");
	634	for (i = 0; i < 20 ; i++) {
	635	printf ("%02X ", output[i]);
	636	}
	637	printf ("\n");
	638	if (argc == 4) {
	639	data = (unsigned char *)simple_strtoul (argv[3], NULL, 16);
	640	memcpy (data, output, 20);
	641	}
	642	return 0;
	643	}
	644	if (argc == 2) {
	645	char *ptr = argv[1];
	646	if (*ptr != '-') goto usage;
	647	ptr++;
	648	if ((ptr == 'c') \|\| (ptr == 'C')) {
	649	rcode = pcs440ep_sha1 (1);
	650	printf ("SHA1 U-Boot sum %sok!\n", (rcode != 0) ? "not " : "");
	651	} else if ((ptr == 'p') \|\| (ptr == 'P')) {
	652	rcode = pcs440ep_sha1 (2);
	653	} else {
	654	rcode = pcs440ep_sha1 (0);
	655	}
4ef218f6	656	return rcode;
566a494f HS	657	}
	658	return rcode;
	659	}
	660
	661	U_BOOT_CMD(
53677ef1	662	sha1, 4, 1, do_sha1,
2fb2604d	663	"calculate the SHA1 Sum",
566a494f HS	664	"address len [addr] calculate the SHA1 sum [save at addr]\n"
566a494f HS	665	" -p calculate the SHA1 sum from the U-Boot image in flash and print\n"
a89c33db	666	" -c check the U-Boot image in flash"
566a494f HS	667	);
	668	#endif
	669
f98984cb HS	670	#if defined (CONFIG_CMD_IDE)
	671	/* These addresses need to be shifted one place to the left
	672	* ( bus per_addr 20 -30 is connectsd on CF bus A10-A0)
	673	* These values are shifted
	674	*/
	675	extern ulong *ide_bus_offset;
	676	void inline ide_outb(int dev, int port, unsigned char val)
	677	{
	678	debug ("ide_outb (dev= %d, port= 0x%x, val= 0x%02x) : @ 0x%08lx\n",
	679	dev, port, val, (ATA_CURR_BASE(dev)+port));
	680
	681	out_be16((u16 *)(ATA_CURR_BASE(dev)+(port << 1)), val);
	682	}
	683	unsigned char inline ide_inb(int dev, int port)
	684	{
	685	uchar val;
	686	val = in_be16((u16 *)(ATA_CURR_BASE(dev)+(port << 1)));
	687	debug ("ide_inb (dev= %d, port= 0x%x) : @ 0x%08lx -> 0x%02x\n",
	688	dev, port, (ATA_CURR_BASE(dev)+port), val);
	689	return (val);
	690	}
	691	#endif
	692
566a494f HS	693	#ifdef CONFIG_IDE_PREINIT
	694	int ide_preinit (void)
	695	{
	696	/* Set True IDE Mode */
	697	out32 (GPIO0_OR, (in32 (GPIO0_OR) \| 0x00100000));
	698	out32 (GPIO0_OR, (in32 (GPIO0_OR) \| 0x00200000));
	699	out32 (GPIO1_OR, (in32 (GPIO1_OR) & ~0x00008040));
	700	udelay (100000);
	701	return 0;
	702	}
	703	#endif
	704
afaac86f	705	#if defined (CONFIG_CMD_IDE) && defined (CONFIG_IDE_RESET)
566a494f HS	706	void ide_set_reset (int idereset)
	707	{
	708	debug ("ide_reset(%d)\n", idereset);
	709	if (idereset == 0) {
	710	out32 (GPIO0_OR, (in32 (GPIO0_OR) \| 0x00200000));
	711	} else {
	712	out32 (GPIO0_OR, (in32 (GPIO0_OR) & ~0x00200000));
	713	}
	714	udelay (10000);
	715	}
afaac86f	716	#endif /* defined (CONFIG_CMD_IDE) && defined (CONFIG_IDE_RESET) */