[people/ms/u-boot.git] / common / console.c

/*
 * (C) Copyright 2000
 * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
 *
 * 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 <stdarg.h>
#include <malloc.h>
#include <console.h>
#include <exports.h>

#ifdef CONFIG_AMIGAONEG3SE
int console_changed = 0;
#endif

#ifdef CFG_CONSOLE_IS_IN_ENV
/*
 * if overwrite_console returns 1, the stdin, stderr and stdout
 * are switched to the serial port, else the settings in the
 * environment are used
 */
#ifdef CFG_CONSOLE_OVERWRITE_ROUTINE
extern int overwrite_console (void);
#else
int overwrite_console (void)
{
	return (0);
}
#endif /* CFG_CONSOLE_OVERWRITE_ROUTINE */

#endif /* CFG_CONSOLE_IS_IN_ENV */

static int console_setfile (int file, device_t * dev)
{
	DECLARE_GLOBAL_DATA_PTR;
	int error = 0;

	if (dev == NULL)
		return -1;

	switch (file) {
	case stdin:
	case stdout:
	case stderr:
		/* Start new device */
		if (dev->start) {
			error = dev->start ();
			/* If it's not started dont use it */
			if (error < 0)
				break;
		}

		/* Assign the new device (leaving the existing one started) */
		stdio_devices[file] = dev;

		/*
		 * Update monitor functions
		 * (to use the console stuff by other applications)
		 */
		switch (file) {
		case stdin:
			gd->jt[XF_getc] = dev->getc;
			gd->jt[XF_tstc] = dev->tstc;
			break;
		case stdout:
			gd->jt[XF_putc] = dev->putc;
			gd->jt[XF_puts] = dev->puts;
			gd->jt[XF_printf] = printf;
			break;
		}
		break;

	default:		/* Invalid file ID */
		error = -1;
	}
	return error;
}

/** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/

void serial_printf (const char *fmt, ...)
{
	va_list args;
	uint i;
	char printbuffer[CFG_PBSIZE];

	va_start (args, fmt);

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf (printbuffer, fmt, args);
	va_end (args);

	serial_puts (printbuffer);
}

int fgetc (int file)
{
	if (file < MAX_FILES)
		return stdio_devices[file]->getc ();

	return -1;
}

int ftstc (int file)
{
	if (file < MAX_FILES)
		return stdio_devices[file]->tstc ();

	return -1;
}

void fputc (int file, const char c)
{
	if (file < MAX_FILES)
		stdio_devices[file]->putc (c);
}

void fputs (int file, const char *s)
{
	if (file < MAX_FILES)
		stdio_devices[file]->puts (s);
}

void fprintf (int file, const char *fmt, ...)
{
	va_list args;
	uint i;
	char printbuffer[CFG_PBSIZE];

	va_start (args, fmt);

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf (printbuffer, fmt, args);
	va_end (args);

	/* Send to desired file */
	fputs (file, printbuffer);
}

/** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/

int getc (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->flags & GD_FLG_DEVINIT) {
		/* Get from the standard input */
		return fgetc (stdin);
	}

	/* Send directly to the handler */
	return serial_getc ();
}

int tstc (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->flags & GD_FLG_DEVINIT) {
		/* Test the standard input */
		return ftstc (stdin);
	}

	/* Send directly to the handler */
	return serial_tstc ();
}

void putc (const char c)
{
	DECLARE_GLOBAL_DATA_PTR;

#ifdef CONFIG_SILENT_CONSOLE
	if (gd->flags & GD_FLG_SILENT)
		return;
#endif

	if (gd->flags & GD_FLG_DEVINIT) {
		/* Send to the standard output */
		fputc (stdout, c);
	} else {
		/* Send directly to the handler */
		serial_putc (c);
	}
}

void puts (const char *s)
{
	DECLARE_GLOBAL_DATA_PTR;

#ifdef CONFIG_SILENT_CONSOLE
	if (gd->flags & GD_FLG_SILENT)
		return;
#endif

	if (gd->flags & GD_FLG_DEVINIT) {
		/* Send to the standard output */
		fputs (stdout, s);
	} else {
		/* Send directly to the handler */
		serial_puts (s);
	}
}

void printf (const char *fmt, ...)
{
	va_list args;
	uint i;
	char printbuffer[CFG_PBSIZE];

	va_start (args, fmt);

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf (printbuffer, fmt, args);
	va_end (args);

	/* Print the string */
	puts (printbuffer);
}

void vprintf (const char *fmt, va_list args)
{
	uint i;
	char printbuffer[CFG_PBSIZE];

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf (printbuffer, fmt, args);

	/* Print the string */
	puts (printbuffer);
}

/* test if ctrl-c was pressed */
static int ctrlc_disabled = 0;	/* see disable_ctrl() */
static int ctrlc_was_pressed = 0;
int ctrlc (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (!ctrlc_disabled && gd->have_console) {
		if (tstc ()) {
			switch (getc ()) {
			case 0x03:		/* ^C - Control C */
				ctrlc_was_pressed = 1;
				return 1;
			default:
				break;
			}
		}
	}
	return 0;
}

/* pass 1 to disable ctrlc() checking, 0 to enable.
 * returns previous state
 */
int disable_ctrlc (int disable)
{
	int prev = ctrlc_disabled;	/* save previous state */

	ctrlc_disabled = disable;
	return prev;
}

int had_ctrlc (void)
{
	return ctrlc_was_pressed;
}

void clear_ctrlc (void)
{
	ctrlc_was_pressed = 0;
}

#ifdef CONFIG_MODEM_SUPPORT_DEBUG
char	screen[1024];
char *cursor = screen;
int once = 0;
inline void dbg(const char *fmt, ...)
{
	va_list	args;
	uint	i;
	char	printbuffer[CFG_PBSIZE];

	if (!once) {
		memset(screen, 0, sizeof(screen));
		once++;
	}

	va_start(args, fmt);

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf(printbuffer, fmt, args);
	va_end(args);

	if ((screen + sizeof(screen) - 1 - cursor) < strlen(printbuffer)+1) {
		memset(screen, 0, sizeof(screen));
		cursor = screen;
	}
	sprintf(cursor, printbuffer);
	cursor += strlen(printbuffer);

}
#else
inline void dbg(const char *fmt, ...)
{
}
#endif

/** U-Boot INIT FUNCTIONS *************************************************/

int console_assign (int file, char *devname)
{
	int flag, i;

	/* Check for valid file */
	switch (file) {
	case stdin:
		flag = DEV_FLAGS_INPUT;
		break;
	case stdout:
	case stderr:
		flag = DEV_FLAGS_OUTPUT;
		break;
	default:
		return -1;
	}

	/* Check for valid device name */

	for (i = 1; i <= ListNumItems (devlist); i++) {
		device_t *dev = ListGetPtrToItem (devlist, i);

		if (strcmp (devname, dev->name) == 0) {
			if (dev->flags & flag)
				return console_setfile (file, dev);

			return -1;
		}
	}

	return -1;
}

/* Called before relocation - use serial functions */
int console_init_f (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	gd->have_console = 1;

#ifdef CONFIG_SILENT_CONSOLE
	if (getenv("silent") != NULL)
		gd->flags |= GD_FLG_SILENT;
#endif

	return (0);
}

#if defined(CFG_CONSOLE_IS_IN_ENV) || defined(CONFIG_SPLASH_SCREEN) || defined(CONFIG_SILENT_CONSOLE)
/* search a device */
device_t *search_device (int flags, char *name)
{
	int i, items;
	device_t *dev = NULL;

	items = ListNumItems (devlist);
	if (name == NULL)
		return dev;

	for (i = 1; i <= items; i++) {
		dev = ListGetPtrToItem (devlist, i);
		if ((dev->flags & flags) && (strcmp (name, dev->name) == 0)) {
			break;
		}
	}
	return dev;
}
#endif /* CFG_CONSOLE_IS_IN_ENV || CONFIG_SPLASH_SCREEN */

#ifdef CFG_CONSOLE_IS_IN_ENV
/* Called after the relocation - use desired console functions */
int console_init_r (void)
{
	DECLARE_GLOBAL_DATA_PTR;
	char *stdinname, *stdoutname, *stderrname;
	device_t *inputdev = NULL, *outputdev = NULL, *errdev = NULL;

	/* set default handlers at first */
	gd->jt[XF_getc] = serial_getc;
	gd->jt[XF_tstc] = serial_tstc;
	gd->jt[XF_putc] = serial_putc;
	gd->jt[XF_puts] = serial_puts;
	gd->jt[XF_printf] = serial_printf;

	/* stdin stdout and stderr are in environment */
	/* scan for it */
	stdinname  = getenv ("stdin");
	stdoutname = getenv ("stdout");
	stderrname = getenv ("stderr");

	if (overwrite_console () == 0) { /* if not overwritten by config switch */
		inputdev  = search_device (DEV_FLAGS_INPUT,  stdinname);
		outputdev = search_device (DEV_FLAGS_OUTPUT, stdoutname);
		errdev    = search_device (DEV_FLAGS_OUTPUT, stderrname);
	}
	/* if the devices are overwritten or not found, use default device */
	if (inputdev == NULL) {
		inputdev  = search_device (DEV_FLAGS_INPUT,  "serial");
	}
	if (outputdev == NULL) {
		outputdev = search_device (DEV_FLAGS_OUTPUT, "serial");
	}
	if (errdev == NULL) {
		errdev    = search_device (DEV_FLAGS_OUTPUT, "serial");
	}
	/* Initializes output console first */
	if (outputdev != NULL) {
		console_setfile (stdout, outputdev);
	}
	if (errdev != NULL) {
		console_setfile (stderr, errdev);
	}
	if (inputdev != NULL) {
		console_setfile (stdin, inputdev);
	}

	gd->flags |= GD_FLG_DEVINIT;	/* device initialization completed */

#ifndef CFG_CONSOLE_INFO_QUIET
	/* Print information */
	puts ("In:    ");
	if (stdio_devices[stdin] == NULL) {
		puts ("No input devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stdin]->name);
	}

	puts ("Out:   ");
	if (stdio_devices[stdout] == NULL) {
		puts ("No output devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stdout]->name);
	}

	puts ("Err:   ");
	if (stdio_devices[stderr] == NULL) {
		puts ("No error devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stderr]->name);
	}
#endif /* CFG_CONSOLE_INFO_QUIET */

#ifdef CFG_CONSOLE_ENV_OVERWRITE
	/* set the environment variables (will overwrite previous env settings) */
	for (i = 0; i < 3; i++) {
		setenv (stdio_names[i], stdio_devices[i]->name);
	}
#endif /*  CFG_CONSOLE_ENV_OVERWRITE */

#if 0
	/* If nothing usable installed, use only the initial console */
	if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
		return (0);
#endif
	return (0);
}

#else /* CFG_CONSOLE_IS_IN_ENV */

/* Called after the relocation - use desired console functions */
int console_init_r (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	device_t *inputdev = NULL, *outputdev = NULL;
	int i, items = ListNumItems (devlist);

#ifdef CONFIG_SPLASH_SCREEN
	/* suppress all output if splash screen is enabled and we have
	   a bmp to display                                            */
	if (getenv("splashimage") != NULL)
		outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
#endif

#ifdef CONFIG_SILENT_CONSOLE
	/* Suppress all output if "silent" mode requested		*/
	if (gd->flags & GD_FLG_SILENT)
		outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
#endif

	/* Scan devices looking for input and output devices */
	for (i = 1;
	     (i <= items) && ((inputdev == NULL) || (outputdev == NULL));
	     i++
	    ) {
		device_t *dev = ListGetPtrToItem (devlist, i);

		if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
			inputdev = dev;
		}
		if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
			outputdev = dev;
		}
	}

	/* Initializes output console first */
	if (outputdev != NULL) {
		console_setfile (stdout, outputdev);
		console_setfile (stderr, outputdev);
	}

	/* Initializes input console */
	if (inputdev != NULL) {
		console_setfile (stdin, inputdev);
	}

	gd->flags |= GD_FLG_DEVINIT;	/* device initialization completed */

#ifndef CFG_CONSOLE_INFO_QUIET
	/* Print information */
	puts ("In:    ");
	if (stdio_devices[stdin] == NULL) {
		puts ("No input devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stdin]->name);
	}

	puts ("Out:   ");
	if (stdio_devices[stdout] == NULL) {
		puts ("No output devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stdout]->name);
	}

	puts ("Err:   ");
	if (stdio_devices[stderr] == NULL) {
		puts ("No error devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stderr]->name);
	}
#endif /* CFG_CONSOLE_INFO_QUIET */

	/* Setting environment variables */
	for (i = 0; i < 3; i++) {
		setenv (stdio_names[i], stdio_devices[i]->name);
	}

#if 0
	/* If nothing usable installed, use only the initial console */
	if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
		return (0);
#endif

	return (0);
}

#endif /* CFG_CONSOLE_IS_IN_ENV */
Commit	Line	Data
47d1a6e1 WD	1	/*
	2	* (C) Copyright 2000
	3	* Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
	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 <stdarg.h>
	26	#include <malloc.h>
	27	#include <console.h>
27b207fd	28	#include <exports.h>
47d1a6e1	29
c7de829c WD	30	#ifdef CONFIG_AMIGAONEG3SE
	31	int console_changed = 0;
	32	#endif
	33
47d1a6e1 WD	34	#ifdef CFG_CONSOLE_IS_IN_ENV
	35	/*
	36	* if overwrite_console returns 1, the stdin, stderr and stdout
	37	* are switched to the serial port, else the settings in the
	38	* environment are used
	39	*/
	40	#ifdef CFG_CONSOLE_OVERWRITE_ROUTINE
	41	extern int overwrite_console (void);
	42	#else
	43	int overwrite_console (void)
	44	{
	45	return (0);
	46	}
	47	#endif /* CFG_CONSOLE_OVERWRITE_ROUTINE */
	48
	49	#endif /* CFG_CONSOLE_IS_IN_ENV */
	50
	51	static int console_setfile (int file, device_t * dev)
	52	{
27b207fd	53	DECLARE_GLOBAL_DATA_PTR;
47d1a6e1 WD	54	int error = 0;
	55
	56	if (dev == NULL)
	57	return -1;
	58
	59	switch (file) {
	60	case stdin:
	61	case stdout:
	62	case stderr:
	63	/* Start new device */
	64	if (dev->start) {
	65	error = dev->start ();
	66	/* If it's not started dont use it */
	67	if (error < 0)
	68	break;
	69	}
	70
	71	/* Assign the new device (leaving the existing one started) */
	72	stdio_devices[file] = dev;
	73
	74	/*
	75	* Update monitor functions
	76	* (to use the console stuff by other applications)
	77	*/
	78	switch (file) {
	79	case stdin:
27b207fd WD	80	gd->jt[XF_getc] = dev->getc;
27b207fd WD	81	gd->jt[XF_tstc] = dev->tstc;
47d1a6e1 WD	82	break;
47d1a6e1 WD	83	case stdout:
27b207fd WD	84	gd->jt[XF_putc] = dev->putc;
	85	gd->jt[XF_puts] = dev->puts;
	86	gd->jt[XF_printf] = printf;
47d1a6e1 WD	87	break;
	88	}
	89	break;
	90
	91	default: /* Invalid file ID */
	92	error = -1;
	93	}
	94	return error;
	95	}
	96
	97	/ U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS ***********************/
	98
	99	void serial_printf (const char *fmt, ...)
	100	{
	101	va_list args;
	102	uint i;
	103	char printbuffer[CFG_PBSIZE];
	104
	105	va_start (args, fmt);
	106
	107	/* For this to work, printbuffer must be larger than
	108	* anything we ever want to print.
	109	*/
	110	i = vsprintf (printbuffer, fmt, args);
	111	va_end (args);
	112
	113	serial_puts (printbuffer);
	114	}
	115
	116	int fgetc (int file)
	117	{
	118	if (file < MAX_FILES)
	119	return stdio_devices[file]->getc ();
	120
	121	return -1;
	122	}
	123
	124	int ftstc (int file)
	125	{
	126	if (file < MAX_FILES)
	127	return stdio_devices[file]->tstc ();
	128
	129	return -1;
	130	}
	131
	132	void fputc (int file, const char c)
	133	{
	134	if (file < MAX_FILES)
	135	stdio_devices[file]->putc (c);
	136	}
	137
	138	void fputs (int file, const char *s)
	139	{
	140	if (file < MAX_FILES)
	141	stdio_devices[file]->puts (s);
	142	}
	143
	144	void fprintf (int file, const char *fmt, ...)
	145	{
	146	va_list args;
	147	uint i;
	148	char printbuffer[CFG_PBSIZE];
	149
	150	va_start (args, fmt);
151
152	/* For this to work, printbuffer must be larger than
153	* anything we ever want to print.
154	*/
155	i = vsprintf (printbuffer, fmt, args);
156	va_end (args);
157
158	/* Send to desired file */
159	fputs (file, printbuffer);
160	}
161
162	/ U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION ***************************/
163
164	int getc (void)
165	{
166	DECLARE_GLOBAL_DATA_PTR;
167
168	if (gd->flags & GD_FLG_DEVINIT) {
169	/* Get from the standard input */
170	return fgetc (stdin);
171	}
172
173	/* Send directly to the handler */
174	return serial_getc ();
175	}
176
177	int tstc (void)
178	{
179	DECLARE_GLOBAL_DATA_PTR;
180
181	if (gd->flags & GD_FLG_DEVINIT) {
182	/* Test the standard input */
183	return ftstc (stdin);
184	}
185
186	/* Send directly to the handler */
187	return serial_tstc ();
188	}
189
190	void putc (const char c)
191	{
192	DECLARE_GLOBAL_DATA_PTR;
193
a6cccaea WD	194	#ifdef CONFIG_SILENT_CONSOLE
a6cccaea WD	195	if (gd->flags & GD_FLG_SILENT)
f6e20fc6	196	return;
a6cccaea WD	197	#endif
a6cccaea WD	198
47d1a6e1 WD	199	if (gd->flags & GD_FLG_DEVINIT) {
	200	/* Send to the standard output */
	201	fputc (stdout, c);
	202	} else {
	203	/* Send directly to the handler */
	204	serial_putc (c);
	205	}
	206	}
	207
	208	void puts (const char *s)
	209	{
	210	DECLARE_GLOBAL_DATA_PTR;
	211
a6cccaea WD	212	#ifdef CONFIG_SILENT_CONSOLE
	213	if (gd->flags & GD_FLG_SILENT)
	214	return;
	215	#endif
	216
47d1a6e1 WD	217	if (gd->flags & GD_FLG_DEVINIT) {
	218	/* Send to the standard output */
	219	fputs (stdout, s);
	220	} else {
	221	/* Send directly to the handler */
	222	serial_puts (s);
	223	}
	224	}
	225
	226	void printf (const char *fmt, ...)
	227	{
	228	va_list args;
	229	uint i;
	230	char printbuffer[CFG_PBSIZE];
	231
	232	va_start (args, fmt);
	233
	234	/* For this to work, printbuffer must be larger than
	235	* anything we ever want to print.
	236	*/
	237	i = vsprintf (printbuffer, fmt, args);
	238	va_end (args);
	239
	240	/* Print the string */
	241	puts (printbuffer);
	242	}
	243
6dd652fa WD	244	void vprintf (const char *fmt, va_list args)
	245	{
	246	uint i;
	247	char printbuffer[CFG_PBSIZE];
	248
	249	/* For this to work, printbuffer must be larger than
	250	* anything we ever want to print.
	251	*/
	252	i = vsprintf (printbuffer, fmt, args);
	253
	254	/* Print the string */
	255	puts (printbuffer);
	256	}
	257
47d1a6e1 WD	258	/* test if ctrl-c was pressed */
	259	static int ctrlc_disabled = 0; /* see disable_ctrl() */
	260	static int ctrlc_was_pressed = 0;
	261	int ctrlc (void)
	262	{
	263	DECLARE_GLOBAL_DATA_PTR;
	264
	265	if (!ctrlc_disabled && gd->have_console) {
	266	if (tstc ()) {
	267	switch (getc ()) {
	268	case 0x03: /* ^C - Control C */
	269	ctrlc_was_pressed = 1;
	270	return 1;
	271	default:
	272	break;
	273	}
	274	}
	275	}
	276	return 0;
	277	}
	278
	279	/* pass 1 to disable ctrlc() checking, 0 to enable.
	280	* returns previous state
	281	*/
	282	int disable_ctrlc (int disable)
	283	{
	284	int prev = ctrlc_disabled; /* save previous state */
	285
	286	ctrlc_disabled = disable;
	287	return prev;
	288	}
	289
	290	int had_ctrlc (void)
	291	{
	292	return ctrlc_was_pressed;
	293	}
	294
	295	void clear_ctrlc (void)
	296	{
	297	ctrlc_was_pressed = 0;
	298	}
	299
	300	#ifdef CONFIG_MODEM_SUPPORT_DEBUG
	301	char screen[1024];
	302	char *cursor = screen;
	303	int once = 0;
	304	inline void dbg(const char *fmt, ...)
	305	{
	306	va_list args;
	307	uint i;
	308	char printbuffer[CFG_PBSIZE];
	309
	310	if (!once) {
	311	memset(screen, 0, sizeof(screen));
	312	once++;
	313	}
	314
	315	va_start(args, fmt);
	316
	317	/* For this to work, printbuffer must be larger than
	318	* anything we ever want to print.
	319	*/
	320	i = vsprintf(printbuffer, fmt, args);
	321	va_end(args);
322
323	if ((screen + sizeof(screen) - 1 - cursor) < strlen(printbuffer)+1) {
324	memset(screen, 0, sizeof(screen));
325	cursor = screen;
326	}
327	sprintf(cursor, printbuffer);
328	cursor += strlen(printbuffer);
329
330	}
331	#else
332	inline void dbg(const char *fmt, ...)
333	{
334	}
335	#endif
336
337	/ U-Boot INIT FUNCTIONS ***********************************************/
338
339	int console_assign (int file, char *devname)
340	{
341	int flag, i;
342
343	/* Check for valid file */
344	switch (file) {
345	case stdin:
346	flag = DEV_FLAGS_INPUT;
347	break;
348	case stdout:
349	case stderr:
350	flag = DEV_FLAGS_OUTPUT;
351	break;
352	default:
353	return -1;
354	}
355
356	/* Check for valid device name */
357
358	for (i = 1; i <= ListNumItems (devlist); i++) {
359	device_t *dev = ListGetPtrToItem (devlist, i);
360
361	if (strcmp (devname, dev->name) == 0) {
362	if (dev->flags & flag)
363	return console_setfile (file, dev);
364
365	return -1;
366	}
367	}
368
369	return -1;
370	}
371
372	/* Called before relocation - use serial functions */
373	int console_init_f (void)
374	{
375	DECLARE_GLOBAL_DATA_PTR;
376
377	gd->have_console = 1;
f72da340 WD	378
	379	#ifdef CONFIG_SILENT_CONSOLE
	380	if (getenv("silent") != NULL)
	381	gd->flags \|= GD_FLG_SILENT;
	382	#endif
	383
47d1a6e1 WD	384	return (0);
	385	}
	386
f72da340	387	#if defined(CFG_CONSOLE_IS_IN_ENV) \|\| defined(CONFIG_SPLASH_SCREEN) \|\| defined(CONFIG_SILENT_CONSOLE)
47d1a6e1 WD	388	/* search a device */
	389	device_t search_device (int flags, char name)
	390	{
	391	int i, items;
	392	device_t *dev = NULL;
	393
	394	items = ListNumItems (devlist);
	395	if (name == NULL)
	396	return dev;
	397
	398	for (i = 1; i <= items; i++) {
	399	dev = ListGetPtrToItem (devlist, i);
	400	if ((dev->flags & flags) && (strcmp (name, dev->name) == 0)) {
	401	break;
	402	}
	403	}
	404	return dev;
	405	}
d791b1dc	406	#endif /* CFG_CONSOLE_IS_IN_ENV \|\| CONFIG_SPLASH_SCREEN */
47d1a6e1 WD	407
	408	#ifdef CFG_CONSOLE_IS_IN_ENV
	409	/* Called after the relocation - use desired console functions */
	410	int console_init_r (void)
	411	{
27b207fd	412	DECLARE_GLOBAL_DATA_PTR;
47d1a6e1 WD	413	char stdinname, stdoutname, *stderrname;
	414	device_t inputdev = NULL, outputdev = NULL, *errdev = NULL;
	415
	416	/* set default handlers at first */
27b207fd WD	417	gd->jt[XF_getc] = serial_getc;
	418	gd->jt[XF_tstc] = serial_tstc;
	419	gd->jt[XF_putc] = serial_putc;
	420	gd->jt[XF_puts] = serial_puts;
	421	gd->jt[XF_printf] = serial_printf;
47d1a6e1 WD	422
	423	/* stdin stdout and stderr are in environment */
	424	/* scan for it */
	425	stdinname = getenv ("stdin");
	426	stdoutname = getenv ("stdout");
	427	stderrname = getenv ("stderr");
	428
	429	if (overwrite_console () == 0) { /* if not overwritten by config switch */
	430	inputdev = search_device (DEV_FLAGS_INPUT, stdinname);
	431	outputdev = search_device (DEV_FLAGS_OUTPUT, stdoutname);
	432	errdev = search_device (DEV_FLAGS_OUTPUT, stderrname);
	433	}
	434	/* if the devices are overwritten or not found, use default device */
	435	if (inputdev == NULL) {
	436	inputdev = search_device (DEV_FLAGS_INPUT, "serial");
	437	}
	438	if (outputdev == NULL) {
	439	outputdev = search_device (DEV_FLAGS_OUTPUT, "serial");
	440	}
	441	if (errdev == NULL) {
	442	errdev = search_device (DEV_FLAGS_OUTPUT, "serial");
	443	}
	444	/* Initializes output console first */
	445	if (outputdev != NULL) {
	446	console_setfile (stdout, outputdev);
	447	}
	448	if (errdev != NULL) {
	449	console_setfile (stderr, errdev);
	450	}
	451	if (inputdev != NULL) {
	452	console_setfile (stdin, inputdev);
	453	}
	454
5f535fe1 WD	455	gd->flags \|= GD_FLG_DEVINIT; /* device initialization completed */
5f535fe1 WD	456
47d1a6e1 WD	457	#ifndef CFG_CONSOLE_INFO_QUIET
47d1a6e1 WD	458	/* Print information */
4b9206ed	459	puts ("In: ");
47d1a6e1	460	if (stdio_devices[stdin] == NULL) {
4b9206ed	461	puts ("No input devices available!\n");
47d1a6e1 WD	462	} else {
	463	printf ("%s\n", stdio_devices[stdin]->name);
	464	}
	465
4b9206ed	466	puts ("Out: ");
47d1a6e1	467	if (stdio_devices[stdout] == NULL) {
4b9206ed	468	puts ("No output devices available!\n");
47d1a6e1 WD	469	} else {
	470	printf ("%s\n", stdio_devices[stdout]->name);
	471	}
	472
4b9206ed	473	puts ("Err: ");
47d1a6e1	474	if (stdio_devices[stderr] == NULL) {
4b9206ed	475	puts ("No error devices available!\n");
47d1a6e1 WD	476	} else {
	477	printf ("%s\n", stdio_devices[stderr]->name);
	478	}
	479	#endif /* CFG_CONSOLE_INFO_QUIET */
	480
	481	#ifdef CFG_CONSOLE_ENV_OVERWRITE
	482	/* set the environment variables (will overwrite previous env settings) */
	483	for (i = 0; i < 3; i++) {
	484	setenv (stdio_names[i], stdio_devices[i]->name);
	485	}
	486	#endif /* CFG_CONSOLE_ENV_OVERWRITE */
	487
	488	#if 0
	489	/* If nothing usable installed, use only the initial console */
	490	if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
	491	return (0);
	492	#endif
	493	return (0);
	494	}
	495
	496	#else /* CFG_CONSOLE_IS_IN_ENV */
	497
	498	/* Called after the relocation - use desired console functions */
	499	int console_init_r (void)
	500	{
5f535fe1 WD	501	DECLARE_GLOBAL_DATA_PTR;
5f535fe1 WD	502
47d1a6e1 WD	503	device_t inputdev = NULL, outputdev = NULL;
	504	int i, items = ListNumItems (devlist);
	505
d791b1dc	506	#ifdef CONFIG_SPLASH_SCREEN
87970ebe	507	/* suppress all output if splash screen is enabled and we have
42d1f039	508	a bmp to display */
87970ebe	509	if (getenv("splashimage") != NULL)
87970ebe	510	outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
d791b1dc WD	511	#endif
d791b1dc WD	512
f72da340 WD	513	#ifdef CONFIG_SILENT_CONSOLE
	514	/* Suppress all output if "silent" mode requested */
	515	if (gd->flags & GD_FLG_SILENT)
	516	outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
	517	#endif
	518
47d1a6e1 WD	519	/* Scan devices looking for input and output devices */
	520	for (i = 1;
	521	(i <= items) && ((inputdev == NULL) \|\| (outputdev == NULL));
	522	i++
	523	) {
	524	device_t *dev = ListGetPtrToItem (devlist, i);
	525
	526	if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
	527	inputdev = dev;
	528	}
	529	if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
	530	outputdev = dev;
	531	}
	532	}
	533
	534	/* Initializes output console first */
	535	if (outputdev != NULL) {
	536	console_setfile (stdout, outputdev);
	537	console_setfile (stderr, outputdev);
	538	}
	539
	540	/* Initializes input console */
	541	if (inputdev != NULL) {
	542	console_setfile (stdin, inputdev);
	543	}
	544
5f535fe1 WD	545	gd->flags \|= GD_FLG_DEVINIT; /* device initialization completed */
5f535fe1 WD	546
47d1a6e1	547	#ifndef CFG_CONSOLE_INFO_QUIET
47cd00fa	548	/* Print information */
4b9206ed	549	puts ("In: ");
47d1a6e1	550	if (stdio_devices[stdin] == NULL) {
4b9206ed	551	puts ("No input devices available!\n");
47d1a6e1 WD	552	} else {
	553	printf ("%s\n", stdio_devices[stdin]->name);
	554	}
	555
4b9206ed	556	puts ("Out: ");
47d1a6e1	557	if (stdio_devices[stdout] == NULL) {
4b9206ed	558	puts ("No output devices available!\n");
47d1a6e1 WD	559	} else {
	560	printf ("%s\n", stdio_devices[stdout]->name);
	561	}
	562
4b9206ed	563	puts ("Err: ");
47d1a6e1	564	if (stdio_devices[stderr] == NULL) {
4b9206ed	565	puts ("No error devices available!\n");
47d1a6e1 WD	566	} else {
	567	printf ("%s\n", stdio_devices[stderr]->name);
	568	}
	569	#endif /* CFG_CONSOLE_INFO_QUIET */
	570
	571	/* Setting environment variables */
	572	for (i = 0; i < 3; i++) {
	573	setenv (stdio_names[i], stdio_devices[i]->name);
	574	}
	575
	576	#if 0
	577	/* If nothing usable installed, use only the initial console */
	578	if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
	579	return (0);
	580	#endif
	581
	582	return (0);
	583	}
	584
	585	#endif /* CFG_CONSOLE_IS_IN_ENV */