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

DECLARE_GLOBAL_DATA_PTR;

#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);
#define OVERWRITE_CONSOLE overwrite_console ()
#else
#define OVERWRITE_CONSOLE 0
#endif /* CFG_CONSOLE_OVERWRITE_ROUTINE */

#endif /* CFG_CONSOLE_IS_IN_ENV */

static int console_setfile (int file, device_t * dev)
{
	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)
{
	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)
{
	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)
{
#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)
{
#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)
{
	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)
{
	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)
{
	char *stdinname, *stdoutname, *stderrname;
	device_t *inputdev = NULL, *outputdev = NULL, *errdev = NULL;
#ifdef CFG_CONSOLE_ENV_OVERWRITE
	int i;
#endif /* CFG_CONSOLE_ENV_OVERWRITE */

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