cmd_nvedit.c

ARM的bootloader代码.rar

/*
 * (C) Copyright 2000
 * Wolfgang Denk, DENX Software Engineering, [e-mail].
 *
 * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
 * Andreas Heppel <[e-mail]>

 * 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
 */

/*
 * Support for persistent environment data
 */

#include "armboot.h"
#include "command.h"
#include "malloc.h"
#include "cmd_nvedit.h"

#if (CONFIG_COMMANDS & CFG_CMD_NET)
#include "net.h"
#endif

/*
 * Table with supported baudrates (defined in config_xyz.h)
 */
static const unsigned long baudrate_table[] = CFG_BAUDRATE_TABLE;
#define	N_BAUDRATES (sizeof(baudrate_table) / sizeof(baudrate_table[0]))

/*
 * Default settings to be used when no valid environment is found
 */
#define XMK_STR(x)	#x
#define MK_STR(x)	XMK_STR(x)

uchar default_environment[] = {
#ifdef	CONFIG_BOOTARGS
	"bootargs="	CONFIG_BOOTARGS			"\0"
#endif
#ifdef	CONFIG_BOOTCOMMAND
	"bootcmd="	CONFIG_BOOTCOMMAND		"\0"
#endif
#ifdef	CONFIG_RAMBOOTCOMMAND
	"ramboot="	CONFIG_RAMBOOTCOMMAND		"\0"
#endif
#ifdef	CONFIG_NFSBOOTCOMMAND
	"nfsboot="	CONFIG_NFSBOOTCOMMAND		"\0"
#endif
#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
	"bootdelay="	MK_STR(CONFIG_BOOTDELAY)	"\0"
#endif
#if defined(CONFIG_BAUDRATE) && (CONFIG_BAUDRATE >= 0)
	"baudrate="	MK_STR(CONFIG_BAUDRATE)		"\0"
#endif
#ifdef	CONFIG_LOADS_ECHO
	"loads_echo="	MK_STR(CONFIG_LOADS_ECHO)	"\0"
#endif
#ifdef	CONFIG_ETHADDR
	"ethaddr="	MK_STR(CONFIG_ETHADDR)		"\0"
#endif
#ifdef	CONFIG_ETH2ADDR
	"eth2addr="	MK_STR(CONFIG_ETH2ADDR)		"\0"
#endif
#ifdef	CONFIG_ETH3ADDR
	"eth3addr="	MK_STR(CONFIG_ETH3ADDR)		"\0"
#endif
#ifdef	CONFIG_IPADDR
	"ipaddr="	MK_STR(CONFIG_IPADDR)		"\0"
#endif
#ifdef	CONFIG_SERVERIP
	"serverip="	MK_STR(CONFIG_SERVERIP)		"\0"
#endif
#ifdef	CFG_AUTOLOAD
	"autoload="	CFG_AUTOLOAD			"\0"
#endif
#ifdef	CONFIG_PREBOOT
	"preboot="	CONFIG_PREBOOT			"\0"
#endif
#ifdef	CONFIG_ROOTPATH
	"rootpath="	MK_STR(CONFIG_ROOTPATH)		"\0"
#endif
#ifdef	CONFIG_GATEWAYIP
	"gatewayip="	MK_STR(CONFIG_GATEWAYIP)	"\0"
#endif
#ifdef	CONFIG_NETMASK
	"netmask="	MK_STR(CONFIG_NETMASK)		"\0"
#endif
#ifdef	CONFIG_HOSTNAME
	"hostname="	MK_STR(CONFIG_HOSTNAME)		"\0"
#endif
#ifdef	CONFIG_BOOTFILE
	"bootfile="	MK_STR(CONFIG_BOOTFILE)		"\0"
#endif
#ifdef	CONFIG_LOADADDR
	"loadaddr="	MK_STR(CONFIG_LOADADDR)		"\0"
#endif
#ifdef  CONFIG_CLOCKS_IN_MHZ
	"clocks_in_mhz=1\0"
#endif
	"\0"
};

static int envmatch (bd_t *, uchar *, int);

/*
 * return one character from env
 */
static uchar get_env_char(bd_t *bd, int index)
{
    uchar c;
   
    /* use RAM copy, if possible */
    if (bd->bi_env)
    {
	if (index < sizeof(bd->bi_env_data))
	  c = bd->bi_env_data[index];
	else
	  panic("bad size for get_env_char!\n");
    }
    else
    {
	/* try a board specific lookup */
	if (board_env_getchar(bd, index, &c) < 0)
	{
	    if (index < sizeof(default_environment))
	      c = default_environment[index];
	    else 
	      panic("bad size for get_env_char!\n");
	}
    }
    return c;
}

/*
 * return address into environment
 */
static uchar *get_env_addr(bd_t *bd, int index)
{
    uchar *p = 0;
   
    /* use RAM copy, if possible */
    if (bd->bi_env)
    {
	if (index < sizeof(bd->bi_env_data))
	  p = &bd->bi_env_data[index];
	else
	  panic("bad size for get_env_char!\n");
    }
    else
    {
	/* try a board specific lookup */
	if ((p = board_env_getaddr(bd, index)) == 0)
	{
	    if (index < sizeof(default_environment))
	      p = &default_environment[index];
	    else 
	      panic("bad size for get_env_char!\n");
	}
    }
    return p;
}

/************************************************************************
 * Command interface: print one or all environment variables
 */

int do_printenv (cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char *argv[])
{
    int i, j, k, nxt;
    
    if (argc == 1) {		/* Print all env variables	*/
	for (i=0; get_env_char(bd, i) != '\0'; i=nxt+1) {
	    for (nxt=i; get_env_char(bd, nxt) != '\0'; ++nxt)
	      ;
	    for (k=i; k<nxt; ++k)
	      putc(get_env_char(bd, k));
	    putc  ('\n');
	    
	    if (ctrlc()) {
		printf ("\n ** Abort\n");
		return 1;
	    }
	}
	
	printf("\nEnvironment size: %d/%d bytes\n", i, sizeof(bd->bi_env_data));
	
	return 0;
    }
    
    for (i=1; i<argc; ++i) {	/* print single env variables	*/
	char *name = argv[i];
	
	k = -1;
	
	for (j=0; get_env_char(bd, j) != '\0'; j=nxt+1) {
	    
	    for (nxt=j; get_env_char(bd, nxt) != '\0'; ++nxt)
	      ;
	    k = envmatch(bd, name, j);
	    if (k < 0) {
		continue;
	    }
	    puts (name);
	    putc ('=');
	    while (k < nxt)
	      putc(get_env_char(bd, k++));
	    putc ('\n');
	    break;
	}
	if (k < 0)
	{
	  printf ("## Error: \"%s\" not defined\n", name);
	  return 1;
	}
    }
    return 0;
}

/************************************************************************
 * Set a new environment variable,
 * or replace or delete an existing one.
 *
 * This function will ONLY work with a in-RAM copy of the environment
 */

int _do_setenv (bd_t *bd, int flag, int argc, char *argv[])
{
    int   i, len, oldval;
    uchar *env, *nxt = 0;
    uchar *name;
    
    /* need writable copy in RAM */
    if (!bd->bi_env_data)
      return 1;

    name = argv[1];
    
    /*
     * search if variable with this name already exists
     */
    oldval = -1;
    for (env = bd->bi_env_data; *env; env = nxt+1) {
	for (nxt = env; *nxt; ++nxt)
	  ;
	if ((oldval = envmatch(bd, name, (ulong)env - (ulong)bd->bi_env_data)) >= 0)
	  break;
    }
    
    /*
     * Delete any existing definition
     */
    if (oldval >= 0) {
#ifndef CONFIG_ENV_OVERWRITE
	
	/*
	 * Ethernet Address and serial# can be set only once
	 */
	if ( (strcmp (name, "serial#") == 0) ||
	    ((strcmp (name, "ethaddr") == 0)
# if defined(CONFIG_OVERWRITE_ETHADDR_ONCE) && defined(CONFIG_ETHADDR)
	     && (strcmp (get_env_addr(bd, oldval),MK_STR(CONFIG_ETHADDR)) != 0)
# endif	/* CONFIG_OVERWRITE_ETHADDR_ONCE && CONFIG_ETHADDR */
	     ) ) {
	    printf ("Can't overwrite \"%s\"\n", name);
	    return 1;
	}
#endif
	
	/*
	 * Switch to new baudrate if new baudrate is supported
	 */
	if (strcmp(argv[1],"baudrate") == 0) {
	    int baudrate = simple_strtoul(argv[2], NULL, 10);
	    int i;
	    for (i=0; i<N_BAUDRATES; ++i) {
		if (baudrate == baudrate_table[i])
		  break;
	    }
	    if (i == N_BAUDRATES) {
		printf ("## Baudrate %d bps not supported\n",
			baudrate);
		return 1;
	    }
	    printf ("## Switch baudrate to %d bps and press ENTER ...\n",
		    baudrate);
	    udelay(50000);
	    serial_setbrg (bd, baudrate);
	    udelay(50000);
	    for (;;) {
		if (getc() == '\r')
		  break;
	    }
	    bd->bi_baudrate = baudrate;
	}
	
	if (*++nxt == '\0') {
	    if ((ulong)env > (ulong)bd->bi_env_data) {
		env--;
	    } else {
		*env = '\0';
	    }
	} else {
	    for (;;) {
		*env = *nxt++;
		if ((*env == '\0') && (*nxt == '\0'))
		  break;
		++env;
	    }
	}
	*++env = '\0';
    }
    /* Delete only ? */
    if ((argc < 3) || argv[2] == NULL) {    
	/* Update CRC */
	bd->bi_env_crc = crc32(0, bd->bi_env_data, sizeof(bd->bi_env_data));
	return 0;
    }

    /*
     * Append new definition at the end
     */
    for (env = bd->bi_env_data; *env || *(env+1); ++env)
      ;
    if ((ulong)env > (ulong)bd->bi_env_data)
      ++env;
    /*
     * Overflow when:
     * "name" + "=" + "val" +"\0\0"  > 
     *      sizeof(bd->bi_env_data) - (env-bd->bi_env_data)
     */
    len = strlen(name) + 2;
    /* add '=' for first arg, ' ' for all others */
    for (i=2; i<argc; ++i) {
	len += strlen(argv[i]) + 1;
    }
    if (len > sizeof(bd->bi_env_data)) {
	printf ("## Error: environment overflow, \"%s\" deleted\n", name);
	return 1;
    }
    while ((*env = *name++) != '\0')
      env++;
    for (i=2; i<argc; ++i) {
	char *val = argv[i];
	
	*env = (i==2) ? '=' : ' ';
	while ((*++env = *val++) != '\0')
	  ;
    }
    
    /* end is marked with double '\0' */
    *++env = '\0';
    
    /* Update CRC */
    bd->bi_env_crc = crc32(0, bd->bi_env_data, sizeof(bd->bi_env_data));

    /*
     * Some variables should be updated when the corresponding
     * entry in the enviornment is changed
     */
    
    if (strcmp(argv[1],"ethaddr") == 0) {
	char *s = argv[2];	/* always use only one arg */
	char *e;
	for (i=0; i<6; ++i) {
	    bd->bi_enetaddr[i] = s ? simple_strtoul(s, &e, 16) : 0;
	    if (s) s = (*e) ? e+1 : e;
	}
	return 0;
    }

    if (strcmp(argv[1],"ipaddr") == 0) {
	char *s = argv[2];	/* always use only one arg */
	char *e;
	bd->bi_ip_addr = 0;
	for (i=0; i<4; ++i) {
	    ulong val = s ? simple_strtoul(s, &e, 10) : 0;
	    bd->bi_ip_addr <<= 8;
	    bd->bi_ip_addr  |= (val & 0xFF);
	    if (s) s = (*e) ? e+1 : e;
	}
	return 0;
    }

    if (strcmp(argv[1],"loadaddr") == 0) {
	load_addr = simple_strtoul(argv[2], NULL, 16);
	return 0;
    }

#if (CONFIG_COMMANDS & CFG_CMD_NET)
    if (strcmp(argv[1],"bootfile") == 0) {
	copy_filename (BootFile, argv[2], sizeof(BootFile));
	return 0;
    }
#endif	/* CFG_CMD_NET */

    return 0;
}

void setenv (bd_t * bd, char *varname, char *varvalue)
{
    char *argv[4] = { "setenv", varname, varvalue, NULL };
    _do_setenv (bd, 0, 3, argv);
}

int do_setenv (cmd_tbl_t * cmdtp, bd_t * bd, int flag, int argc,
		char *argv[])
{
    if (argc < 2) {
	printf ("Usage:\n%s\n", cmdtp->usage);
	return 1;
    }

    return _do_setenv (bd, flag, argc, argv);
}

/************************************************************************
 * Prompt for environment variable
 */

#if (CONFIG_COMMANDS & CFG_CMD_ASKENV)
int do_askenv (cmd_tbl_t * cmdtp, bd_t * bd, int flag, int argc,
		char *argv[])
{
    extern char console_buffer[CFG_CBSIZE];
    char message[CFG_CBSIZE];
    int size = CFG_CBSIZE - 1;
    int len;
    char *local_args[4];
    
    local_args[0] = argv[0];
    local_args[1] = argv[1];
    local_args[2] = NULL;
    local_args[3] = NULL;
    
    if (argc < 2) {
	printf ("Usage:\n%s\n", cmdtp->usage);
	return 1;
    }
    /* Check the syntax */
    switch (argc) {
    case 1:
	printf ("Usage:\n%s\n", cmdtp->usage);
	return 1;
	
    case 2:		/* askenv envname */
	sprintf (message, "Please enter '%s':", argv[1]);
	break;
	
    case 3:		/* askenv envname size */
	sprintf (message, "Please enter '%s':", argv[1]);
	size = simple_strtoul (argv[2], NULL, 10);
	break;
	
    default:	/* askenv envname message1 ... messagen size */
	{
	    int i;
	    int pos = 0;
	    
	    for (i = 2; i < argc - 1; i++) {
		if (pos) {
		    message[pos++] = ' ';
		}
		strcpy (message+pos, argv[i]);
		pos += strlen(argv[i]);
	    }
	    message[pos] = '\0';
	    size = simple_strtoul (argv[argc - 1], NULL, 10);
	}
    }
    
    if (size >= CFG_CBSIZE)
      size = CFG_CBSIZE - 1;

    if (size <= 0)
      return 1;

    /* prompt for input */
    len = readline (message);

    if (size < len)
      console_buffer[size] = '\0';

    len = 2;
    if (console_buffer[0] != '\0') {
	local_args[2] = console_buffer;
	len = 3;
    }
    
    // Continue calling setenv code
    return _do_setenv (bd, flag, len, local_args);
}
#endif	/* CFG_CMD_ASKENV */

/************************************************************************
 * Look up variable from environment,
 * return address of storage for that variable,
 * or NULL if not found
 */

char *getenv (bd_t * bd, uchar *name)
{
    int i, nxt;
    
    for (i=0; get_env_char(bd, i) != '\0'; i=nxt+1) {
	int val;
	
	for (nxt=i; get_env_char(bd, nxt) != '\0'; ++nxt) {
	    if (nxt >= sizeof(bd->bi_env_data)) {
		return (NULL);
	    }
	}
	if ((val=envmatch(bd, name, i)) < 0)
	  continue;
	return (get_env_addr(bd, val));
    }
    
    return (NULL);
}


/************************************************************************
 * Match a name / name=value pair
 *
 * s1 is either a simple 'name', or a 'name=value' pair.
 * i2 is the environment index for a 'name2=value2' pair.
 * If the names match, return the index for the value2, else NULL.
 */

static int envmatch (bd_t *bd, uchar *s1, int i2)
{

	while (*s1 == get_env_char(bd, i2++))
		if (*s1++ == '=')
			return(i2);
	if (*s1 == '\0' && get_env_char(bd, i2-1) == '=')
		return(i2);
	return(-1);
}


#if (CONFIG_COMMANDS & CFG_CMD_ENV)

int do_saveenv  (cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char *argv[])
{
    return (board_env_save(bd, bd->bi_env, sizeof(env_t))) ? 1 : 0;
}

#endif	/* CFG_CMD_ENV */


void env_init(bd_t *bd)
{
    bd->bi_env = 0;
}

void env_relocate(bd_t *bd)
{
    char *s, *e;
    int reg;
   
    bd->bi_env = malloc(sizeof(env_t));

    if (board_env_copy(bd, bd->bi_env, sizeof(env_t)) < 0)
    {
	printf("*** Using default environment\n");
	memcpy(bd->bi_env_data, default_environment, 
	       sizeof(default_environment));
	bd->bi_env_crc = crc32(0, bd->bi_env_data, sizeof(bd->bi_env_data));
    }
    
    /* now initialise some variables */
    
    /* MAC address */
    s = getenv(bd, "ethaddr");
    for (reg=0; reg<6; reg++) 
    {
	bd->bi_enetaddr[reg] = s ? simple_strtoul(s, &e, 16) : 0;
	if (s)
	  s = (*e) ? e+1 : e;
    }

    /* IP address */
    bd->bi_ip_addr = 0;
    s = getenv(bd, "ipaddr");
    for (reg=0; reg<4; ++reg) {    
        ulong val = s ? simple_strtoul(s, &e, 10) : 0;
        bd->bi_ip_addr <<= 8;
        bd->bi_ip_addr  |= (val & 0xFF);
        if (s)
	  s = (*e) ? e+1 : e;
    }
    
    if ((s = getenv(bd, "loadaddr")) != NULL) {    
        load_addr = simple_strtoul(s, NULL, 16);
    }
    
#if (CONFIG_COMMANDS & CFG_CMD_NET)
    if ((s = getenv(bd, "bootfile")) != NULL) {    
        copy_filename (BootFile, s, sizeof(BootFile));
    }
#endif  /* CFG_CMD_NET */
}