mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-20 08:58:52 +09:00
![Stefan Roese](/assets/img/avatar_default.png)
As discussed on the list, move "arch/ppc" to "arch/powerpc" to better match the Linux directory structure. Please note that this patch also changes the "ppc" target in MAKEALL to "powerpc" to match this new infrastructure. But "ppc" is kept as an alias for now, to not break compatibility with scripts using this name. Signed-off-by: Stefan Roese <sr@denx.de> Acked-by: Wolfgang Denk <wd@denx.de> Acked-by: Detlev Zundel <dzu@denx.de> Acked-by: Kim Phillips <kim.phillips@freescale.com> Cc: Peter Tyser <ptyser@xes-inc.com> Cc: Anatolij Gustschin <agust@denx.de>
717 lines
18 KiB
C
717 lines
18 KiB
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) */
|