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

arch/sandbox/config.mk

@@ -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

arch/sandbox/cpu/Makefile

@@ -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))

arch/sandbox/cpu/os.c

@@ -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;
+}

arch/sandbox/cpu/start.c

@@ -1,5 +1,5 @@
 /*
- * 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.

arch/sandbox/cpu/state.c

@@ -0,0 +1,51 @@
+/*
+ * 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;
+}

arch/sandbox/cpu/u-boot.lds

@@ -1,5 +1,5 @@
 /*
- * 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;

arch/sandbox/include/asm/getopt.h

@@ -0,0 +1,71 @@
+/*
+ * 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

arch/sandbox/include/asm/global_data.h

@@ -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;

arch/sandbox/include/asm/gpio.h

@@ -0,0 +1,81 @@
+/*
+ * 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

arch/sandbox/include/asm/sections.h

@@ -0,0 +1,22 @@
+/*
+ * 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

arch/sandbox/include/asm/state.h

@@ -0,0 +1,62 @@
+/*
+ * 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);
+
+#endif

arch/sandbox/include/asm/u-boot-sandbox.h

@@ -35,4 +35,8 @@
 int board_init(void);
 int dram_init(void);
 
+/* start.c */
+int sandbox_early_getopt_check(void);
+int sandbox_main_loop_init(void);
+
 #endif	/* _U_BOOT_SANDBOX_H_ */

arch/sandbox/lib/board.c

@@ -134,6 +134,7 @@ init_fnc_t *init_sequence[] = {
 	env_init,		/* initialize environment */
 	serial_init,		/* serial communications setup */
 	console_init_f,		/* stage 1 init of console */
+	sandbox_early_getopt_check,	/* process command line flags (err/help) */
 	display_banner,		/* say that we are here */
 #if defined(CONFIG_DISPLAY_CPUINFO)
 	print_cpuinfo,		/* display cpu info (and speed) */
@@ -156,6 +157,14 @@ void board_init_f(ulong bootflag)
 
 	memset((void *)gd, 0, sizeof(gd_t));
 
+#if defined(CONFIG_OF_EMBED)
+	/* Get a pointer to the FDT */
+	gd->fdt_blob = _binary_dt_dtb_start;
+#elif defined(CONFIG_OF_SEPARATE)
+	/* FDT is at end of image */
+	gd->fdt_blob = (void *)(_end_ofs + _TEXT_BASE);
+#endif
+
 	for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
 		if ((*init_fnc_ptr)() != 0)
 			hang();
@@ -261,6 +270,8 @@ void board_init_r(gd_t *id, ulong dest_addr)
 	post_run(NULL, POST_RAM | post_bootmode_get(0));
 #endif
 
+	sandbox_main_loop_init();
+
 	/*
 	 * For now, run the main loop. Later we might let this be done
 	 * in the main program.

board/sandbox/sandbox/sandbox.c

@@ -34,6 +34,16 @@ void flush_cache(unsigned long start, unsigned long size)
 {
 }
 
+ulong get_tbclk(void)
+{
+	return CONFIG_SYS_HZ;
+}
+
+unsigned long long get_ticks(void)
+{
+	return get_timer(0);
+}
+
 ulong get_timer(ulong base)
 {
 	return (os_get_nsec() / 1000000) - base;

drivers/gpio/Makefile

@@ -34,6 +34,7 @@ COBJS-$(CONFIG_MXS_GPIO)	+= mxs_gpio.o
 COBJS-$(CONFIG_PCA953X)		+= pca953x.o
 COBJS-$(CONFIG_PCA9698)		+= pca9698.o
 COBJS-$(CONFIG_S5P)		+= s5p_gpio.o
+COBJS-$(CONFIG_SANDBOX_GPIO)	+= sandbox.o
 COBJS-$(CONFIG_TEGRA2_GPIO)	+= tegra2_gpio.o
 COBJS-$(CONFIG_DA8XX_GPIO)	+= da8xx_gpio.o
 COBJS-$(CONFIG_ALTERA_PIO)	+= altera_pio.o

drivers/gpio/sandbox.c

@@ -0,0 +1,209 @@
+/*
+ * 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
+ */
+
+#include <common.h>
+#include <asm/gpio.h>
+
+/* Flags for each GPIO */
+#define GPIOF_OUTPUT	(1 << 0)	/* Currently set as an output */
+#define GPIOF_HIGH	(1 << 1)	/* Currently set high */
+#define GPIOF_RESERVED	(1 << 2)	/* Is in use / requested */
+
+struct gpio_state {
+	const char *label;	/* label given by requester */
+	u8 flags;		/* flags (GPIOF_...) */
+};
+
+/*
+ * State of GPIOs
+ * TODO: Put this into sandbox state
+ */
+static struct gpio_state state[CONFIG_SANDBOX_GPIO_COUNT];
+
+/* Access routines for GPIO state */
+static u8 *get_gpio_flags(unsigned gp)
+{
+	/* assert()'s could be disabled, so make sure we handle that */
+	assert(gp < ARRAY_SIZE(state));
+	if (gp >= ARRAY_SIZE(state)) {
+		static u8 invalid_flags;
+		printf("sandbox_gpio: error: invalid gpio %u\n", gp);
+		return &invalid_flags;
+	}
+
+	return &state[gp].flags;
+}
+
+static int get_gpio_flag(unsigned gp, int flag)
+{
+	return (*get_gpio_flags(gp) & flag) != 0;
+}
+
+static int set_gpio_flag(unsigned gp, int flag, int value)
+{
+	u8 *gpio = get_gpio_flags(gp);
+
+	if (value)
+		*gpio |= flag;
+	else
+		*gpio &= ~flag;
+
+	return 0;
+}
+
+static int check_reserved(unsigned gpio, const char *func)
+{
+	if (!get_gpio_flag(gpio, GPIOF_RESERVED)) {
+		printf("sandbox_gpio: %s: error: gpio %u not reserved\n",
+			func, gpio);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Back-channel sandbox-internal-only access to GPIO state
+ */
+
+int sandbox_gpio_get_value(unsigned gp)
+{
+	if (get_gpio_flag(gp, GPIOF_OUTPUT))
+		debug("sandbox_gpio: get_value on output gpio %u\n", gp);
+	return get_gpio_flag(gp, GPIOF_HIGH);
+}
+
+int sandbox_gpio_set_value(unsigned gp, int value)
+{
+	return set_gpio_flag(gp, GPIOF_HIGH, value);
+}
+
+int sandbox_gpio_get_direction(unsigned gp)
+{
+	return get_gpio_flag(gp, GPIOF_OUTPUT);
+}
+
+int sandbox_gpio_set_direction(unsigned gp, int output)
+{
+	return set_gpio_flag(gp, GPIOF_OUTPUT, output);
+}
+
+/*
+ * These functions implement the public interface within U-Boot
+ */
+
+/* set GPIO port 'gp' as an input */
+int gpio_direction_input(unsigned gp)
+{
+	debug("%s: gp:%u\n", __func__, gp);
+
+	if (check_reserved(gp, __func__))
+		return -1;
+
+	return sandbox_gpio_set_direction(gp, 0);
+}
+
+/* set GPIO port 'gp' as an output, with polarity 'value' */
+int gpio_direction_output(unsigned gp, int value)
+{
+	debug("%s: gp:%u, value = %d\n", __func__, gp, value);
+
+	if (check_reserved(gp, __func__))
+		return -1;
+
+	return sandbox_gpio_set_direction(gp, 1) |
+		sandbox_gpio_set_value(gp, value);
+}
+
+/* read GPIO IN value of port 'gp' */
+int gpio_get_value(unsigned gp)
+{
+	debug("%s: gp:%u\n", __func__, gp);
+
+	if (check_reserved(gp, __func__))
+		return -1;
+
+	return sandbox_gpio_get_value(gp);
+}
+
+/* write GPIO OUT value to port 'gp' */
+int gpio_set_value(unsigned gp, int value)
+{
+	debug("%s: gp:%u, value = %d\n", __func__, gp, value);
+
+	if (check_reserved(gp, __func__))
+		return -1;
+
+	if (!sandbox_gpio_get_direction(gp)) {
+		printf("sandbox_gpio: error: set_value on input gpio %u\n", gp);
+		return -1;
+	}
+
+	return sandbox_gpio_set_value(gp, value);
+}
+
+int gpio_request(unsigned gp, const char *label)
+{
+	debug("%s: gp:%u, label:%s\n", __func__, gp, label);
+
+	if (gp >= ARRAY_SIZE(state)) {
+		printf("sandbox_gpio: error: invalid gpio %u\n", gp);
+		return -1;
+	}
+
+	if (get_gpio_flag(gp, GPIOF_RESERVED)) {
+		printf("sandbox_gpio: error: gpio %u already reserved\n", gp);
+		return -1;
+	}
+
+	state[gp].label = label;
+	return set_gpio_flag(gp, GPIOF_RESERVED, 1);
+}
+
+int gpio_free(unsigned gp)
+{
+	debug("%s: gp:%u\n", __func__, gp);
+
+	if (check_reserved(gp, __func__))
+		return -1;
+
+	state[gp].label = NULL;
+	return set_gpio_flag(gp, GPIOF_RESERVED, 0);
+}
+
+/* Display GPIO information */
+void gpio_info(void)
+{
+	unsigned gpio;
+
+	puts("Sandbox GPIOs\n");
+
+	for (gpio = 0; gpio < ARRAY_SIZE(state); ++gpio) {
+		const char *label = state[gpio].label;
+
+		printf("%4d: %s: %d [%c] %s\n",
+			gpio,
+			sandbox_gpio_get_direction(gpio) ? "out" : " in",
+			sandbox_gpio_get_value(gpio),
+			get_gpio_flag(gpio, GPIOF_RESERVED) ? 'x' : ' ',
+			label ? label : "");
+	}
+}

include/configs/sandbox.h

@@ -28,6 +28,16 @@
 /* Number of bits in a C 'long' on this architecture */
 #define CONFIG_SANDBOX_BITS_PER_LONG	64
 
+#define CONFIG_OF_CONTROL
+#define CONFIG_OF_LIBFDT
+#define CONFIG_LMB
+
+#define CONFIG_SYS_VSNPRINTF
+
+#define CONFIG_CMD_GPIO
+#define CONFIG_SANDBOX_GPIO
+#define CONFIG_SANDBOX_GPIO_COUNT	20
+
 /*
  * Size of malloc() pool, although we don't actually use this yet.
  */

include/os.h

@@ -1,4 +1,9 @@
 /*
+ * Operating System Interface
+ *
+ * This provides access to useful OS routines for the sandbox architecture.
+ * They are kept in a separate file so we can include system headers.
+ *
  * Copyright (c) 2011 The Chromium OS Authors.
  * See file CREDITS for list of people who contributed to this
  * project.
@@ -19,11 +24,10 @@
  * MA 02111-1307 USA
  */
 
-/*
- * Operating System Interface
- *
- * This provides access to useful OS routines from the sandbox architecture
- */
+#ifndef __OS_H__
+#define __OS_H__
+
+struct sandbox_state;
 
 /**
  * Access to the OS read() system call
@@ -45,6 +49,21 @@ ssize_t os_read(int fd, void *buf, size_t count);
  */
 ssize_t os_write(int fd, const void *buf, size_t count);
 
+/**
+ * Access to the OS lseek() system call
+ *
+ * \param fd	File descriptor as returned by os_open()
+ * \param offset	File offset (based on whence)
+ * \param whence	Position offset is relative to (see below)
+ * \return new file offset
+ */
+off_t os_lseek(int fd, off_t offset, int whence);
+
+/* Defines for "whence" in os_lseek() */
+#define OS_SEEK_SET	0
+#define OS_SEEK_CUR	1
+#define OS_SEEK_END	2
+
 /**
  * Access to the OS open() system call
  *
@@ -54,6 +73,12 @@ ssize_t os_write(int fd, const void *buf, size_t count);
  */
 int os_open(const char *pathname, int flags);
 
+#define OS_O_RDONLY	0
+#define OS_O_WRONLY	1
+#define OS_O_RDWR	2
+#define OS_O_MASK	3	/* Mask for read/write flags */
+#define OS_O_CREAT	0100
+
 /**
  * Access to the OS close() system call
  *
@@ -70,7 +95,7 @@ int os_close(int fd);
  *
  * @param exit_code	exit code for U-Boot
  */
-void os_exit(int exit_code);
+void os_exit(int exit_code) __attribute__((noreturn));
 
 /**
  * Put tty into raw mode to mimic serial console better
@@ -98,3 +123,17 @@ void os_usleep(unsigned long usec);
  * \return A monotonic increasing time scaled in nano seconds
  */
 u64 os_get_nsec(void);
+
+/**
+ * Parse arguments and update sandbox state.
+ *
+ * @param state		Sandbox state to update
+ * @param argc		Argument count
+ * @param argv		Argument vector
+ * @return 0 if ok, and program should continue;
+ *	1 if ok, but program should stop;
+ *	-1 on error: program should terminate.
+ */
+int os_parse_args(struct sandbox_state *state, int argc, char *argv[]);
+
+#endif