Commit 6ae38b8c authored by Wolfgang Denk's avatar Wolfgang Denk
Browse files

Merge branch 'sandbox' of git://git.denx.de/u-boot-blackfin

* 'sandbox' of git://git.denx.de/u-boot-blackfin:
  sandbox: mark os_exit as noreturn
  sandbox: add getopt support
  sandbox: allow processing before main loop
  sandbox: add concept of sandbox state
  sandbox: disable fortification
  sandbox: u-boot.lds: tweak style
  sandbox: add get_{tbclk,ticks}
  sandbox: enable GPIO driver
  sandbox: gpio: add basic driver for simulating GPIOs
  sandbox: add flags for open() call
  sandbox: config: enable fdt and snprintf() options
  sandbox: fdt: add support for CONFIG_OF_CONTROL
  sandbox: add lseek helper
  sandbox: add ifdef protection to os.h
  sandbox: add required header to os.c
  sandbox: sort header files in os.c
parents df25d499 9d72e67b
......@@ -17,5 +17,5 @@
# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
# MA 02111-1307 USA
PLATFORM_CPPFLAGS += -DCONFIG_SANDBOX -D__SANDBOX__
PLATFORM_CPPFLAGS += -DCONFIG_SANDBOX -D__SANDBOX__ -U_FORTIFY_SOURCE
PLATFORM_LIBS += -lrt
......@@ -27,7 +27,7 @@ include $(TOPDIR)/config.mk
LIB = $(obj)lib$(CPU).o
COBJS := cpu.o start.o os.o
COBJS := cpu.o os.o start.o state.o
SRCS := $(COBJS:.o=.c)
OBJS := $(addprefix $(obj),$(COBJS))
......
......@@ -19,17 +19,22 @@
* MA 02111-1307 USA
*/
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <linux/types.h>
#include <asm/getopt.h>
#include <asm/sections.h>
#include <asm/state.h>
#include <os.h>
/* Operating System Interface */
......@@ -44,9 +49,42 @@ ssize_t os_write(int fd, const void *buf, size_t count)
return write(fd, buf, count);
}
int os_open(const char *pathname, int flags)
off_t os_lseek(int fd, off_t offset, int whence)
{
if (whence == OS_SEEK_SET)
whence = SEEK_SET;
else if (whence == OS_SEEK_CUR)
whence = SEEK_CUR;
else if (whence == OS_SEEK_END)
whence = SEEK_END;
else
os_exit(1);
return lseek(fd, offset, whence);
}
int os_open(const char *pathname, int os_flags)
{
return open(pathname, flags);
int flags;
switch (os_flags & OS_O_MASK) {
case OS_O_RDONLY:
default:
flags = O_RDONLY;
break;
case OS_O_WRONLY:
flags = O_WRONLY;
break;
case OS_O_RDWR:
flags = O_RDWR;
break;
}
if (os_flags & OS_O_CREAT)
flags |= O_CREAT;
return open(pathname, flags, 0777);
}
int os_close(int fd)
......@@ -121,3 +159,97 @@ u64 os_get_nsec(void)
return tv.tv_sec * 1000000000ULL + tv.tv_usec * 1000;
#endif
}
static char *short_opts;
static struct option *long_opts;
int os_parse_args(struct sandbox_state *state, int argc, char *argv[])
{
struct sb_cmdline_option **sb_opt = __u_boot_sandbox_option_start;
size_t num_options = __u_boot_sandbox_option_count();
size_t i;
int hidden_short_opt;
size_t si;
int c;
if (short_opts || long_opts)
return 1;
state->argc = argc;
state->argv = argv;
/* dynamically construct the arguments to the system getopt_long */
short_opts = os_malloc(sizeof(*short_opts) * num_options * 2 + 1);
long_opts = os_malloc(sizeof(*long_opts) * num_options);
if (!short_opts || !long_opts)
return 1;
/*
* getopt_long requires "val" to be unique (since that is what the
* func returns), so generate unique values automatically for flags
* that don't have a short option. pick 0x100 as that is above the
* single byte range (where ASCII/ISO-XXXX-X charsets live).
*/
hidden_short_opt = 0x100;
si = 0;
for (i = 0; i < num_options; ++i) {
long_opts[i].name = sb_opt[i]->flag;
long_opts[i].has_arg = sb_opt[i]->has_arg ?
required_argument : no_argument;
long_opts[i].flag = NULL;
if (sb_opt[i]->flag_short) {
short_opts[si++] = long_opts[i].val = sb_opt[i]->flag_short;
if (long_opts[i].has_arg == required_argument)
short_opts[si++] = ':';
} else
long_opts[i].val = sb_opt[i]->flag_short = hidden_short_opt++;
}
short_opts[si] = '\0';
/* we need to handle output ourselves since u-boot provides printf */
opterr = 0;
/*
* walk all of the options the user gave us on the command line,
* figure out what u-boot option structure they belong to (via
* the unique short val key), and call the appropriate callback.
*/
while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
for (i = 0; i < num_options; ++i) {
if (sb_opt[i]->flag_short == c) {
if (sb_opt[i]->callback(state, optarg)) {
state->parse_err = sb_opt[i]->flag;
return 0;
}
break;
}
}
if (i == num_options) {
/*
* store the faulting flag for later display. we have to
* store the flag itself as the getopt parsing itself is
* tricky: need to handle the following flags (assume all
* of the below are unknown):
* -a optopt='a' optind=<next>
* -abbbb optopt='a' optind=<this>
* -aaaaa optopt='a' optind=<this>
* --a optopt=0 optind=<this>
* as you can see, it is impossible to determine the exact
* faulting flag without doing the parsing ourselves, so
* we just report the specific flag that failed.
*/
if (optopt) {
static char parse_err[3] = { '-', 0, '\0', };
parse_err[1] = optopt;
state->parse_err = parse_err;
} else
state->parse_err = argv[optind - 1];
break;
}
}
return 0;
}
/*
* Copyright (c) 2011 The Chromium OS Authors.
* Copyright (c) 2011-2012 The Chromium OS Authors.
* See file CREDITS for list of people who contributed to this
* project.
*
......@@ -20,9 +20,109 @@
*/
#include <common.h>
#include <asm/getopt.h>
#include <asm/sections.h>
#include <asm/state.h>
#include <os.h>
int sandbox_early_getopt_check(void)
{
struct sandbox_state *state = state_get_current();
struct sb_cmdline_option **sb_opt = __u_boot_sandbox_option_start;
size_t num_options = __u_boot_sandbox_option_count();
size_t i;
int max_arg_len, max_noarg_len;
/* parse_err will be a string of the faulting option */
if (!state->parse_err)
return 0;
if (strcmp(state->parse_err, "help")) {
printf("u-boot: error: failed while parsing option: %s\n"
"\ttry running with --help for more information.\n",
state->parse_err);
os_exit(1);
}
printf(
"u-boot, a command line test interface to U-Boot\n\n"
"Usage: u-boot [options]\n"
"Options:\n");
max_arg_len = 0;
for (i = 0; i < num_options; ++i)
max_arg_len = max(strlen(sb_opt[i]->flag), max_arg_len);
max_noarg_len = max_arg_len + 7;
for (i = 0; i < num_options; ++i) {
struct sb_cmdline_option *opt = sb_opt[i];
/* first output the short flag if it has one */
if (opt->flag_short >= 0x100)
printf(" ");
else
printf(" -%c, ", opt->flag_short);
/* then the long flag */
if (opt->has_arg)
printf("--%-*s", max_noarg_len, opt->flag);
else
printf("--%-*s <arg> ", max_arg_len, opt->flag);
/* finally the help text */
printf(" %s\n", opt->help);
}
os_exit(0);
}
static int sb_cmdline_cb_help(struct sandbox_state *state, const char *arg)
{
/* just flag to sandbox_early_getopt_check to show usage */
return 1;
}
SB_CMDLINE_OPT_SHORT(help, 'h', 0, "Display help");
int sandbox_main_loop_init(void)
{
struct sandbox_state *state = state_get_current();
/* Execute command if required */
if (state->cmd) {
/* TODO: redo this when cmd tidy-up series lands */
#ifdef CONFIG_SYS_HUSH_PARSER
run_command(state->cmd, 0);
#else
parse_string_outer(state->cmd, FLAG_PARSE_SEMICOLON |
FLAG_EXIT_FROM_LOOP);
#endif
os_exit(state->exit_type);
}
return 0;
}
static int sb_cmdline_cb_command(struct sandbox_state *state, const char *arg)
{
state->cmd = arg;
return 0;
}
SB_CMDLINE_OPT_SHORT(command, 'c', 1, "Execute U-Boot command");
int main(int argc, char *argv[])
{
struct sandbox_state *state;
int err;
err = state_init();
if (err)
return err;
state = state_get_current();
if (os_parse_args(state, argc, argv))
return 1;
/*
* Do pre- and post-relocation init, then start up U-Boot. This will
* never return.
......
/*
* Copyright (c) 2011-2012 The Chromium OS Authors.
* 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 <asm/state.h>
/* Main state record for the sandbox */
static struct sandbox_state main_state;
static struct sandbox_state *state; /* Pointer to current state record */
void state_record_exit(enum exit_type_id exit_type)
{
state->exit_type = exit_type;
}
struct sandbox_state *state_get_current(void)
{
assert(state);
return state;
}
int state_init(void)
{
state = &main_state;
/*
* Example of how to use GPIOs:
*
* sandbox_gpio_set_direction(170, 0);
* sandbox_gpio_set_value(170, 0);
*/
return 0;
}
/*
* Copyright (c) 2011 The Chromium OS Authors.
* Copyright (c) 2011-2012 The Chromium OS Authors.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
......@@ -24,11 +24,15 @@
SECTIONS
{
__u_boot_cmd_start = .;
.u_boot_cmd : { *(.u_boot_cmd) }
__u_boot_cmd_end = .;
__bss_start = .;
__u_boot_cmd_start = .;
_u_boot_cmd : { *(.u_boot_cmd) }
__u_boot_cmd_end = .;
__u_boot_sandbox_option_start = .;
_u_boot_sandbox_getopt : { *(.u_boot_sandbox_getopt) }
__u_boot_sandbox_option_end = .;
__bss_start = .;
}
INSERT BEFORE .data;
/*
* Code for setting up command line flags like `./u-boot --help`
*
* Copyright (c) 2011 The Chromium OS Authors.
*
* Licensed under the GPL-2 or later.
*/
#ifndef __SANDBOX_GETOPT_H
#define __SANDBOX_GETOPT_H
struct sandbox_state;
/*
* Internal structure for storing details about the flag.
* Most people should not have to dig around in this as
* it only gets parsed by the core sandbox code. End
* consumer code should focus on the macros below and
* the callback function.
*/
struct sb_cmdline_option {
/* The long flag name: "help" for "--help" */
const char *flag;
/* The (optional) short flag name: "h" for "-h" */
int flag_short;
/* The help string shown to the user when processing --help */
const char *help;
/* Whether this flag takes an argument */
int has_arg;
/* Callback into the end consumer code with the option */
int (*callback)(struct sandbox_state *state, const char *opt);
};
/*
* Internal macro to expand the lower macros into the necessary
* magic junk that makes this all work.
*/
#define _SB_CMDLINE_OPT(f, s, ha, h) \
static struct sb_cmdline_option sb_cmdline_option_##f = { \
.flag = #f, \
.flag_short = s, \
.help = h, \
.has_arg = ha, \
.callback = sb_cmdline_cb_##f, \
}; \
/* Ppointer to the struct in a special section for the linker script */ \
static __attribute__((section(".u_boot_sandbox_getopt"), used)) \
struct sb_cmdline_option *sb_cmdline_option_##f##_ptr = \
&sb_cmdline_option_##f
/**
* Macros for end code to declare new command line flags.
*
* @param f The long flag name e.g. help
* @param ha Does the flag have an argument e.g. 0/1
* @param h The help string displayed when showing --help
*
* This invocation:
* SB_CMDLINE_OPT(foo, 0, "The foo arg");
* Will create a new flag named "--foo" (no short option) that takes
* no argument. If the user specifies "--foo", then the callback func
* sb_cmdline_cb_foo() will automatically be called.
*/
#define SB_CMDLINE_OPT(f, ha, h) _SB_CMDLINE_OPT(f, 0, ha, h)
/*
* Same as above, but @s is used to specify a short flag e.g.
* SB_CMDLINE_OPT(foo, 'f', 0, "The foo arg");
*/
#define SB_CMDLINE_OPT_SHORT(f, s, ha, h) _SB_CMDLINE_OPT(f, s, ha, h)
#endif
......@@ -45,6 +45,7 @@ typedef struct global_data {
unsigned long fb_base; /* base address of frame buffer */
u8 *ram_buf; /* emulated RAM buffer */
phys_size_t ram_size; /* RAM size */
const void *fdt_blob; /* Our device tree, NULL if none */
void **jt; /* jump table */
char env_buf[32]; /* buffer for getenv() before reloc. */
} gd_t;
......
/*
* This is the interface to the sandbox GPIO driver for test code which
* wants to change the GPIO values reported to U-Boot.
*
* Copyright (c) 2011 The Chromium OS Authors.
* 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
*/
#ifndef __ASM_SANDBOX_GPIO_H
#define __ASM_SANDBOX_GPIO_H
/*
* We use the generic interface, and add a back-channel.
*
* The back-channel functions are declared in this file. They should not be used
* except in test code.
*
* Test code can, for example, call sandbox_gpio_set_value() to set the value of
* a simulated GPIO. From then on, normal code in U-Boot will see this new
* value when it calls gpio_get_value().
*
* NOTE: DO NOT use the functions in this file except in test code!
*/
#include <asm-generic/gpio.h>
/**
* Return the simulated value of a GPIO (used only in sandbox test code)
*
* @param gp GPIO number
* @return -1 on error, 0 if GPIO is low, >0 if high
*/
int sandbox_gpio_get_value(unsigned gp);
/**
* Set the simulated value of a GPIO (used only in sandbox test code)
*
* @param gp GPIO number
* @param value value to set (0 for low, non-zero for high)
* @return -1 on error, 0 if ok
*/
int sandbox_gpio_set_value(unsigned gp, int value);
/**
* Return the simulated direction of a GPIO (used only in sandbox test code)
*
* @param gp GPIO number
* @return -1 on error, 0 if GPIO is input, >0 if output
*/
int sandbox_gpio_get_direction(unsigned gp);
/**
* Set the simulated direction of a GPIO (used only in sandbox test code)
*
* @param gp GPIO number
* @param output 0 to set as input, 1 to set as output
* @return -1 on error, 0 if ok
*/
int sandbox_gpio_set_direction(unsigned gp, int output);
/* Display information about each GPIO */
void gpio_info(void);
#define gpio_status() gpio_info()
#endif
/*
* decls for symbols defined in the linker script
*
* Copyright (c) 2012 The Chromium OS Authors.
*
* Licensed under the GPL-2 or later.
*/
#ifndef __SANDBOX_SECTIONS_H
#define __SANDBOX_SECTIONS_H
struct sb_cmdline_option;
extern struct sb_cmdline_option *__u_boot_sandbox_option_start[],
*__u_boot_sandbox_option_end[];
static inline size_t __u_boot_sandbox_option_count(void)
{
return __u_boot_sandbox_option_end - __u_boot_sandbox_option_start;
}
#endif
/*
* Copyright (c) 2011-2012 The Chromium OS Authors.
* 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
*/
#ifndef __SANDBOX_STATE_H
#define __SANDBOX_STATE_H
#include <config.h>
/* How we exited U-Boot */
enum exit_type_id {
STATE_EXIT_NORMAL,
STATE_EXIT_COLD_REBOOT,
STATE_EXIT_POWER_OFF,
};
/* The complete state of the test system */
struct sandbox_state {
const char *cmd; /* Command to execute */
enum exit_type_id exit_type; /* How we exited U-Boot */
const char *parse_err; /* Error to report from parsing */
int argc; /* Program arguments */
char **argv;
};
/**
* Record the exit type to be reported by the test program.
*
* @param exit_type Exit type to record
*/
void state_record_exit(enum exit_type_id exit_type);
/**
* Gets a pointer to the current state.
*
* @return pointer to state
*/
struct sandbox_state *state_get_current(void);
/**
* Initialize the test system state
*/
int state_init(void);