[people/ms/u-boot.git] / board / trab / trab.c

/*
 * (C) Copyright 2002
 * Gary Jennejohn, DENX Software Engineering, <garyj@denx.de>
 *
 * 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
 */

/* #define DEBUG */

#include <common.h>
#include <netdev.h>
#include <malloc.h>
#include <asm/arch/s3c24x0_cpu.h>
#include <command.h>

DECLARE_GLOBAL_DATA_PTR;

#ifdef CONFIG_SYS_BRIGHTNESS
static void spi_init(void);
static void wait_transmit_done(void);
static void tsc2000_write(unsigned int page, unsigned int reg,
						  unsigned int data);
static void tsc2000_set_brightness(void);
#endif
#ifdef CONFIG_MODEM_SUPPORT
static int key_pressed(void);
extern void disable_putc(void);
extern int do_mdm_init; /* defined in common/main.c */

/*
 * We need a delay of at least 500 us after turning on the VFD clock
 * before we can read any useful information for the CPLD controlling
 * the keyboard switches. Let's play safe and wait 5 ms. The problem
 * is that timers are not available yet, so we use a manually timed
 * loop.
 */
#define KBD_MDELAY	5000
static void udelay_no_timer (int usec)
{
	int i;
	int delay = usec * 3;

	for (i = 0; i < delay; i ++) gd->bd->bi_arch_number = MACH_TYPE_TRAB;
}
#endif /* CONFIG_MODEM_SUPPORT */

/*
 * Miscellaneous platform dependent initialisations
 */

int board_init ()
{
#if defined(CONFIG_VFD)
	extern int vfd_init_clocks(void);
#endif
	struct s3c24x0_clock_power * const clk_power =
					s3c24x0_get_base_clock_power();
	struct s3c24x0_gpio * const gpio = s3c24x0_get_base_gpio();

	/* memory and cpu-speed are setup before relocation */
#ifdef CONFIG_TRAB_50MHZ
	/* change the clock to be 50 MHz 1:1:1 */
	/* MDIV:0x5c PDIV:4 SDIV:2 */
	clk_power->mpllcon = 0x5c042;
	clk_power->clkdivn = 0;
#else
	/* change the clock to be 133 MHz 1:2:4 */
	/* MDIV:0x7d PDIV:4 SDIV:1 */
	clk_power->mpllcon = 0x7d041;
	clk_power->clkdivn = 3;
#endif

	/* set up the I/O ports */
	gpio->pacon = 0x3ffff;
	gpio->pbcon = 0xaaaaaaaa;
	gpio->pbup  = 0xffff;
	/* INPUT nCTS0 nRTS0 TXD[1] TXD[0] RXD[1] RXD[0]	*/
	/*  00,    10,      10,      10,      10,      10,      10	*/
	gpio->pfcon = (2<<0) | (2<<2) | (2<<4) | (2<<6) | (2<<8) | (2<<10);
#ifdef CONFIG_HWFLOW
	/* do not pull up RXD0, RXD1, TXD0, TXD1, CTS0, RTS0 */
	gpio->pfup  = (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5);
#else
	/* do not pull up RXD0, RXD1, TXD0, TXD1 */
	gpio->pfup  = (1<<0) | (1<<1) | (1<<2) | (1<<3);
#endif
	gpio->pgcon = 0x0;
	gpio->pgup  = 0x0;
	gpio->opencr = 0x0;

	/* suppress flicker of the VFDs */
	gpio->misccr = 0x40;
	gpio->pfcon |= (2<<12);

	gd->bd->bi_arch_number = MACH_TYPE_TRAB;

	/* adress of boot parameters */
	gd->bd->bi_boot_params = 0x0c000100;

	/* Make sure both buzzers are turned off */
	gpio->pdcon |= 0x5400;
	gpio->pddat &= ~0xE0;

#ifdef CONFIG_VFD
	vfd_init_clocks();
#endif /* CONFIG_VFD */

#ifdef CONFIG_MODEM_SUPPORT
	udelay_no_timer (KBD_MDELAY);

	if (key_pressed()) {
		disable_putc();	/* modem doesn't understand banner etc */
		do_mdm_init = 1;
	}
#endif	/* CONFIG_MODEM_SUPPORT */

#ifdef CONFIG_DRIVER_S3C24X0_I2C
	/* Configure I/O ports PG5 und PG6 for I2C */
	gpio->pgcon = (gpio->pgcon & 0x003c00) | 0x003c00;
#endif /* CONFIG_DRIVER_S3C24X0_I2C */

	return 0;
}

int dram_init (void)
{
	gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
	gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
	return 0;
}

/*-----------------------------------------------------------------------
 * Keyboard Controller
 */

/* Maximum key number */
#define KEYBD_KEY_NUM		4

#define KBD_DATA	(((*(volatile ulong *)0x04020000) >> 16) & 0xF)

static char *key_match (ulong);

int misc_init_r (void)
{
	ulong kbd_data = KBD_DATA;
	char *str;
	char keybd_env[KEYBD_KEY_NUM + 1];
	int i;

#ifdef CONFIG_VERSION_VARIABLE
	{
		/* Set version variable. Please note, that this variable is
		 * also set in main_loop() later in the boot process. The
		 * version variable has to be set this early, because so it
		 * could be used in script files on an usb stick, which
		 * might be called during do_auto_update() */
		extern char version_string[];

		setenv ("ver", version_string);
	}
#endif /* CONFIG_VERSION_VARIABLE */

#ifdef CONFIG_AUTO_UPDATE
	{
		extern int do_auto_update(void);
		/* this has priority over all else */
		do_auto_update();
	}
#endif

	for (i = 0; i < KEYBD_KEY_NUM; ++i) {
		keybd_env[i] = '0' + ((kbd_data >> i) & 1);
	}
	keybd_env[i] = '\0';
	debug ("** Setting keybd=\"%s\"\n", keybd_env);
	setenv ("keybd", keybd_env);

	str = strdup (key_match (kbd_data));	/* decode keys */

#ifdef CONFIG_PREBOOT	/* automatically configure "preboot" command on key match */
	debug ("** Setting preboot=\"%s\"\n", str);
	setenv ("preboot", str);	/* set or delete definition */
#endif /* CONFIG_PREBOOT */
	if (str != NULL) {
		free (str);
	}

#ifdef CONFIG_SYS_BRIGHTNESS
	tsc2000_set_brightness();
#endif
	return (0);
}

#ifdef CONFIG_PREBOOT

static uchar kbd_magic_prefix[] = "key_magic";
static uchar kbd_command_prefix[] = "key_cmd";

static int compare_magic (ulong kbd_data, char *str)
{
	uchar key_mask;

	debug ("compare_magic: kbd: %04lx  str: \"%s\"\n",kbd_data,str);
	for (; *str; str++)
	{
		uchar c = *str - '1';

		if (c >= KEYBD_KEY_NUM)		/* bad key number */
			return -1;

		key_mask = 1 << c;

		if (!(kbd_data & key_mask)) {	/* key not pressed */
			debug ( "compare_magic: "
				"kbd: %04lx mask: %04lx - key not pressed\n",
				kbd_data, key_mask );
			return -1;
		}

		kbd_data &= ~key_mask;
	}

	if (kbd_data) {				/* key(s) not released */
		debug ( "compare_magic: "
			"kbd: %04lx - key(s) not released\n", kbd_data);
		return -1;
	}

	return 0;
}

/*-----------------------------------------------------------------------
 * Check if pressed key(s) match magic sequence,
 * and return the command string associated with that key(s).
 *
 * If no key press was decoded, NULL is returned.
 *
 * Note: the first character of the argument will be overwritten with
 * the "magic charcter code" of the decoded key(s), or '\0'.
 *
 *
 * Note: the string points to static environment data and must be
 * saved before you call any function that modifies the environment.
 */
static char *key_match (ulong kbd_data)
{
	char magic[sizeof (kbd_magic_prefix) + 1];
	char cmd_name[sizeof (kbd_command_prefix) + 1];
	char *suffix;
	char *kbd_magic_keys;

	/*
	 * The following string defines the characters that can pe appended
	 * to "key_magic" to form the names of environment variables that
	 * hold "magic" key codes, i. e. such key codes that can cause
	 * pre-boot actions. If the string is empty (""), then only
	 * "key_magic" is checked (old behaviour); the string "125" causes
	 * checks for "key_magic1", "key_magic2" and "key_magic5", etc.
	 */
	if ((kbd_magic_keys = getenv ("magic_keys")) == NULL)
		kbd_magic_keys = "";

	debug ("key_match: magic_keys=\"%s\"\n", kbd_magic_keys);

	/* loop over all magic keys;
	 * use '\0' suffix in case of empty string
	 */
	for (suffix=kbd_magic_keys; *suffix || suffix==kbd_magic_keys; ++suffix)
	{
		sprintf (magic, "%s%c", kbd_magic_prefix, *suffix);

		debug ("key_match: magic=\"%s\"\n",
			getenv(magic) ? getenv(magic) : "<UNDEFINED>");

		if (compare_magic(kbd_data, getenv(magic)) == 0)
		{
			sprintf (cmd_name, "%s%c", kbd_command_prefix, *suffix);
			debug ("key_match: cmdname %s=\"%s\"\n",
				cmd_name,
				getenv (cmd_name) ?
					getenv (cmd_name) :
					"<UNDEFINED>");
			return (getenv (cmd_name));
		}
	}
	debug ("key_match: no match\n");
	return (NULL);
}
#endif							/* CONFIG_PREBOOT */

/* Read Keyboard status */
int do_kbd (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	ulong kbd_data = KBD_DATA;
	char keybd_env[KEYBD_KEY_NUM + 1];
	int i;

	puts ("Keys:");
	for (i = 0; i < KEYBD_KEY_NUM; ++i) {
		keybd_env[i] = '0' + ((kbd_data >> i) & 1);
		printf (" %c", keybd_env[i]);
	}
	keybd_env[i] = '\0';
	putc ('\n');
	setenv ("keybd", keybd_env);
	return 0;
}

U_BOOT_CMD(
	kbd,	1,	1,	do_kbd,
	"read keyboard status",
	""
);

#ifdef CONFIG_MODEM_SUPPORT
static int key_pressed(void)
{
	return (compare_magic(KBD_DATA, CONFIG_MODEM_KEY_MAGIC) == 0);
}
#endif	/* CONFIG_MODEM_SUPPORT */

#ifdef CONFIG_SYS_BRIGHTNESS

static inline void SET_CS_TOUCH(void)
{
	struct s3c24x0_gpio * const gpio = s3c24x0_get_base_gpio();

	gpio->pddat &= 0x5FF;
}

static inline void CLR_CS_TOUCH(void)
{
	struct s3c24x0_gpio * const gpio = s3c24x0_get_base_gpio();

	gpio->pddat |= 0x200;
}

static void spi_init(void)
{
	struct s3c24x0_gpio * const gpio = s3c24x0_get_base_gpio();
	struct s3c24x0_spi * const spi = s3c24x0_get_base_spi();
	int i;

	/* Configure I/O ports. */
	gpio->pdcon = (gpio->pdcon & 0xF3FFFF) | 0x040000;
	gpio->pgcon = (gpio->pgcon & 0x0F3FFF) | 0x008000;
	gpio->pgcon = (gpio->pgcon & 0x0CFFFF) | 0x020000;
	gpio->pgcon = (gpio->pgcon & 0x03FFFF) | 0x080000;

	CLR_CS_TOUCH();

	spi->ch[0].sppre = 0x1F; /* Baudrate ca. 514kHz */
	spi->ch[0].sppin = 0x01;  /* SPI-MOSI holds Level after last bit */
	spi->ch[0].spcon = 0x1A; /* Polling, Prescale, Master, CPOL=0, CPHA=1 */

	/* Dummy byte ensures clock to be low. */
	for (i = 0; i < 10; i++) {
		spi->ch[0].sptdat = 0xFF;
	}
	wait_transmit_done();
}

static void wait_transmit_done(void)
{
	struct s3c24x0_spi * const spi = s3c24x0_get_base_spi();

	while (!(spi->ch[0].spsta & 0x01)) /* wait until transfer is done */
		;
}

static void tsc2000_write(unsigned int page, unsigned int reg,
						  unsigned int data)
{
	struct s3c24x0_spi * const spi = s3c24x0_get_base_spi();
	unsigned int command;

	SET_CS_TOUCH();
	command = 0x0000;
	command |= (page << 11);
	command |= (reg << 5);

	spi->ch[0].sptdat = (command & 0xFF00) >> 8;
	wait_transmit_done();
	spi->ch[0].sptdat = (command & 0x00FF);
	wait_transmit_done();
	spi->ch[0].sptdat = (data & 0xFF00) >> 8;
	wait_transmit_done();
	spi->ch[0].sptdat = (data & 0x00FF);
	wait_transmit_done();

	CLR_CS_TOUCH();
}

static void tsc2000_set_brightness(void)
{
	char tmp[10];
	int i, br;

	spi_init();
	tsc2000_write(1, 2, 0x0); /* Power up DAC */

	i = getenv_f("brightness", tmp, sizeof(tmp));
	br = (i > 0)
		? (int) simple_strtoul (tmp, NULL, 10)
		: CONFIG_SYS_BRIGHTNESS;

	tsc2000_write(0, 0xb, br & 0xff);
}
#endif

#ifdef CONFIG_CMD_NET
int board_eth_init(bd_t *bis)
{
	int rc = 0;
#ifdef CONFIG_CS8900
	rc = cs8900_initialize(0, CONFIG_CS8900_BASE);
#endif
	return rc;
}
#endif
Commit	Line	Data
c609719b WD	1	/*
c609719b WD	2	* (C) Copyright 2002
792a09eb	3	* Gary Jennejohn, DENX Software Engineering, <garyj@denx.de>
c609719b WD	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	/* #define DEBUG */
	25
	26	#include <common.h>
b1c0eaac	27	#include <netdev.h>
c609719b	28	#include <malloc.h>
ac67804f	29	#include <asm/arch/s3c24x0_cpu.h>
8bde7f77	30	#include <command.h>
c609719b	31
d87080b7	32	DECLARE_GLOBAL_DATA_PTR;
c609719b	33
6d0f6bcf	34	#ifdef CONFIG_SYS_BRIGHTNESS
1cb8e980 WD	35	static void spi_init(void);
1cb8e980 WD	36	static void wait_transmit_done(void);
82226bf4	37	static void tsc2000_write(unsigned int page, unsigned int reg,
1cb8e980 WD	38	unsigned int data);
	39	static void tsc2000_set_brightness(void);
	40	#endif
c609719b WD	41	#ifdef CONFIG_MODEM_SUPPORT
	42	static int key_pressed(void);
	43	extern void disable_putc(void);
	44	extern int do_mdm_init; /* defined in common/main.c */
	45
	46	/*
	47	* We need a delay of at least 500 us after turning on the VFD clock
	48	* before we can read any useful information for the CPLD controlling
	49	* the keyboard switches. Let's play safe and wait 5 ms. The problem
	50	* is that timers are not available yet, so we use a manually timed
	51	* loop.
	52	*/
e95b61cf WD	53	#define KBD_MDELAY 5000
e95b61cf WD	54	static void udelay_no_timer (int usec)
c609719b	55	{
c609719b	56	int i;
e95b61cf	57	int delay = usec * 3;
c609719b	58
731215eb	59	for (i = 0; i < delay; i ++) gd->bd->bi_arch_number = MACH_TYPE_TRAB;
c609719b WD	60	}
	61	#endif /* CONFIG_MODEM_SUPPORT */
	62
	63	/*
	64	* Miscellaneous platform dependent initialisations
	65	*/
	66
	67	int board_init ()
	68	{
6069ff26 WD	69	#if defined(CONFIG_VFD)
6069ff26 WD	70	extern int vfd_init_clocks(void);
a6c7ad2f	71	#endif
eb0ae7f5	72	struct s3c24x0_clock_power * const clk_power =
	73	s3c24x0_get_base_clock_power();
	74	struct s3c24x0_gpio * const gpio = s3c24x0_get_base_gpio();
c609719b WD	75
	76	/* memory and cpu-speed are setup before relocation */
	77	#ifdef CONFIG_TRAB_50MHZ
	78	/* change the clock to be 50 MHz 1:1:1 */
	79	/* MDIV:0x5c PDIV:4 SDIV:2 */
d9abba82 N	80	clk_power->mpllcon = 0x5c042;
d9abba82 N	81	clk_power->clkdivn = 0;
c609719b WD	82	#else
	83	/* change the clock to be 133 MHz 1:2:4 */
	84	/* MDIV:0x7d PDIV:4 SDIV:1 */
d9abba82 N	85	clk_power->mpllcon = 0x7d041;
d9abba82 N	86	clk_power->clkdivn = 3;
c609719b WD	87	#endif
	88
	89	/* set up the I/O ports */
d9abba82 N	90	gpio->pacon = 0x3ffff;
	91	gpio->pbcon = 0xaaaaaaaa;
	92	gpio->pbup = 0xffff;
c609719b	93	/* INPUT nCTS0 nRTS0 TXD[1] TXD[0] RXD[1] RXD[0] */
53677ef1	94	/* 00, 10, 10, 10, 10, 10, 10 */
d9abba82	95	gpio->pfcon = (2<<0) \| (2<<2) \| (2<<4) \| (2<<6) \| (2<<8) \| (2<<10);
c609719b WD	96	#ifdef CONFIG_HWFLOW
c609719b WD	97	/* do not pull up RXD0, RXD1, TXD0, TXD1, CTS0, RTS0 */
d9abba82	98	gpio->pfup = (1<<0) \| (1<<1) \| (1<<2) \| (1<<3) \| (1<<4) \| (1<<5);
c609719b WD	99	#else
c609719b WD	100	/* do not pull up RXD0, RXD1, TXD0, TXD1 */
d9abba82	101	gpio->pfup = (1<<0) \| (1<<1) \| (1<<2) \| (1<<3);
c609719b	102	#endif
d9abba82 N	103	gpio->pgcon = 0x0;
	104	gpio->pgup = 0x0;
	105	gpio->opencr = 0x0;
c609719b	106
149dded2	107	/* suppress flicker of the VFDs */
d9abba82 N	108	gpio->misccr = 0x40;
d9abba82 N	109	gpio->pfcon \|= (2<<12);
149dded2	110
731215eb	111	gd->bd->bi_arch_number = MACH_TYPE_TRAB;
c609719b WD	112
	113	/* adress of boot parameters */
	114	gd->bd->bi_boot_params = 0x0c000100;
	115
1cb8e980	116	/* Make sure both buzzers are turned off */
d9abba82 N	117	gpio->pdcon \|= 0x5400;
d9abba82 N	118	gpio->pddat &= ~0xE0;
1cb8e980	119
a6c7ad2f	120	#ifdef CONFIG_VFD
6069ff26	121	vfd_init_clocks();
a6c7ad2f	122	#endif /* CONFIG_VFD */
c609719b	123
6069ff26	124	#ifdef CONFIG_MODEM_SUPPORT
e95b61cf	125	udelay_no_timer (KBD_MDELAY);
c609719b WD	126
	127	if (key_pressed()) {
	128	disable_putc(); /* modem doesn't understand banner etc */
	129	do_mdm_init = 1;
	130	}
	131	#endif /* CONFIG_MODEM_SUPPORT */
	132
6dff5529 WD	133	#ifdef CONFIG_DRIVER_S3C24X0_I2C
6dff5529 WD	134	/* Configure I/O ports PG5 und PG6 for I2C */
d9abba82	135	gpio->pgcon = (gpio->pgcon & 0x003c00) \| 0x003c00;
6dff5529 WD	136	#endif /* CONFIG_DRIVER_S3C24X0_I2C */
6dff5529 WD	137
c609719b WD	138	return 0;
	139	}
	140
	141	int dram_init (void)
	142	{
c609719b WD	143	gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
	144	gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
	145	return 0;
	146	}
	147
	148	/*-----------------------------------------------------------------------
	149	* Keyboard Controller
	150	*/
	151
	152	/* Maximum key number */
	153	#define KEYBD_KEY_NUM 4
	154
	155	#define KBD_DATA ((((volatile ulong )0x04020000) >> 16) & 0xF)
	156
a63c31cf	157	static char *key_match (ulong);
c609719b WD	158
	159	int misc_init_r (void)
	160	{
	161	ulong kbd_data = KBD_DATA;
a63c31cf WD	162	char *str;
a63c31cf WD	163	char keybd_env[KEYBD_KEY_NUM + 1];
c609719b WD	164	int i;
c609719b WD	165
4bdb53ca WD	166	#ifdef CONFIG_VERSION_VARIABLE
	167	{
	168	/* Set version variable. Please note, that this variable is
	169	* also set in main_loop() later in the boot process. The
	170	* version variable has to be set this early, because so it
	171	* could be used in script files on an usb stick, which
	172	* might be called during do_auto_update() */
	173	extern char version_string[];
	174
	175	setenv ("ver", version_string);
	176	}
	177	#endif /* CONFIG_VERSION_VARIABLE */
	178
f54ebdfa	179	#ifdef CONFIG_AUTO_UPDATE
a3d9181e WD	180	{
	181	extern int do_auto_update(void);
	182	/* this has priority over all else */
	183	do_auto_update();
	184	}
f54ebdfa WD	185	#endif
f54ebdfa WD	186
c609719b WD	187	for (i = 0; i < KEYBD_KEY_NUM; ++i) {
	188	keybd_env[i] = '0' + ((kbd_data >> i) & 1);
	189	}
	190	keybd_env[i] = '\0';
	191	debug ("** Setting keybd=\"%s\"\n", keybd_env);
	192	setenv ("keybd", keybd_env);
	193
	194	str = strdup (key_match (kbd_data)); /* decode keys */
	195
	196	#ifdef CONFIG_PREBOOT /* automatically configure "preboot" command on key match */
	197	debug ("** Setting preboot=\"%s\"\n", str);
	198	setenv ("preboot", str); /* set or delete definition */
	199	#endif /* CONFIG_PREBOOT */
	200	if (str != NULL) {
	201	free (str);
	202	}
	203
6d0f6bcf	204	#ifdef CONFIG_SYS_BRIGHTNESS
1cb8e980 WD	205	tsc2000_set_brightness();
1cb8e980 WD	206	#endif
c609719b WD	207	return (0);
	208	}
	209
	210	#ifdef CONFIG_PREBOOT
	211
	212	static uchar kbd_magic_prefix[] = "key_magic";
	213	static uchar kbd_command_prefix[] = "key_cmd";
	214
a63c31cf	215	static int compare_magic (ulong kbd_data, char *str)
c609719b WD	216	{
	217	uchar key_mask;
	218
	219	debug ("compare_magic: kbd: %04lx str: \"%s\"\n",kbd_data,str);
	220	for (; *str; str++)
	221	{
	222	uchar c = *str - '1';
	223
	224	if (c >= KEYBD_KEY_NUM) /* bad key number */
	225	return -1;
	226
	227	key_mask = 1 << c;
	228
	229	if (!(kbd_data & key_mask)) { /* key not pressed */
	230	debug ( "compare_magic: "
	231	"kbd: %04lx mask: %04lx - key not pressed\n",
	232	kbd_data, key_mask );
	233	return -1;
	234	}
	235
	236	kbd_data &= ~key_mask;
	237	}
	238
	239	if (kbd_data) { /* key(s) not released */
	240	debug ( "compare_magic: "
	241	"kbd: %04lx - key(s) not released\n", kbd_data);
	242	return -1;
	243	}
	244
	245	return 0;
	246	}
	247
	248	/*-----------------------------------------------------------------------
	249	* Check if pressed key(s) match magic sequence,
	250	* and return the command string associated with that key(s).
	251	*
	252	* If no key press was decoded, NULL is returned.
	253	*
	254	* Note: the first character of the argument will be overwritten with
	255	* the "magic charcter code" of the decoded key(s), or '\0'.
	256	*
	257	*
	258	* Note: the string points to static environment data and must be
	259	* saved before you call any function that modifies the environment.
	260	*/
a63c31cf	261	static char *key_match (ulong kbd_data)
c609719b	262	{
a63c31cf WD	263	char magic[sizeof (kbd_magic_prefix) + 1];
	264	char cmd_name[sizeof (kbd_command_prefix) + 1];
	265	char *suffix;
	266	char *kbd_magic_keys;
c609719b WD	267
	268	/*
	269	* The following string defines the characters that can pe appended
	270	* to "key_magic" to form the names of environment variables that
	271	* hold "magic" key codes, i. e. such key codes that can cause
	272	* pre-boot actions. If the string is empty (""), then only
	273	* "key_magic" is checked (old behaviour); the string "125" causes
	274	* checks for "key_magic1", "key_magic2" and "key_magic5", etc.
	275	*/
	276	if ((kbd_magic_keys = getenv ("magic_keys")) == NULL)
	277	kbd_magic_keys = "";
	278
	279	debug ("key_match: magic_keys=\"%s\"\n", kbd_magic_keys);
	280
	281	/* loop over all magic keys;
	282	* use '\0' suffix in case of empty string
	283	*/
	284	for (suffix=kbd_magic_keys; *suffix \|\| suffix==kbd_magic_keys; ++suffix)
	285	{
	286	sprintf (magic, "%s%c", kbd_magic_prefix, *suffix);
	287
	288	debug ("key_match: magic=\"%s\"\n",
	289	getenv(magic) ? getenv(magic) : "<UNDEFINED>");
	290
	291	if (compare_magic(kbd_data, getenv(magic)) == 0)
	292	{
	293	sprintf (cmd_name, "%s%c", kbd_command_prefix, *suffix);
	294	debug ("key_match: cmdname %s=\"%s\"\n",
	295	cmd_name,
	296	getenv (cmd_name) ?
	297	getenv (cmd_name) :
	298	"<UNDEFINED>");
	299	return (getenv (cmd_name));
	300	}
	301	}
	302	debug ("key_match: no match\n");
	303	return (NULL);
	304	}
	305	#endif /* CONFIG_PREBOOT */
	306
	307	/* Read Keyboard status */
54841ab5	308	int do_kbd (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
c609719b WD	309	{
c609719b WD	310	ulong kbd_data = KBD_DATA;
a63c31cf	311	char keybd_env[KEYBD_KEY_NUM + 1];
c609719b WD	312	int i;
	313
	314	puts ("Keys:");
	315	for (i = 0; i < KEYBD_KEY_NUM; ++i) {
	316	keybd_env[i] = '0' + ((kbd_data >> i) & 1);
	317	printf (" %c", keybd_env[i]);
	318	}
	319	keybd_env[i] = '\0';
	320	putc ('\n');
	321	setenv ("keybd", keybd_env);
	322	return 0;
	323	}
	324
0d498393	325	U_BOOT_CMD(
53677ef1	326	kbd, 1, 1, do_kbd,
2fb2604d	327	"read keyboard status",
a89c33db	328	""
8bde7f77 WD	329	);
8bde7f77 WD	330
c609719b WD	331	#ifdef CONFIG_MODEM_SUPPORT
	332	static int key_pressed(void)
	333	{
	334	return (compare_magic(KBD_DATA, CONFIG_MODEM_KEY_MAGIC) == 0);
	335	}
	336	#endif /* CONFIG_MODEM_SUPPORT */
1cb8e980	337
6d0f6bcf	338	#ifdef CONFIG_SYS_BRIGHTNESS
1cb8e980	339
48b42616 WD	340	static inline void SET_CS_TOUCH(void)
48b42616 WD	341	{
eb0ae7f5	342	struct s3c24x0_gpio * const gpio = s3c24x0_get_base_gpio();
48b42616	343
d9abba82	344	gpio->pddat &= 0x5FF;
48b42616 WD	345	}
	346
	347	static inline void CLR_CS_TOUCH(void)
	348	{
eb0ae7f5	349	struct s3c24x0_gpio * const gpio = s3c24x0_get_base_gpio();
48b42616	350
d9abba82	351	gpio->pddat \|= 0x200;
48b42616	352	}
1cb8e980 WD	353
	354	static void spi_init(void)
	355	{
eb0ae7f5	356	struct s3c24x0_gpio * const gpio = s3c24x0_get_base_gpio();
eb0ae7f5	357	struct s3c24x0_spi * const spi = s3c24x0_get_base_spi();
1cb8e980 WD	358	int i;
	359
	360	/* Configure I/O ports. */
d9abba82 N	361	gpio->pdcon = (gpio->pdcon & 0xF3FFFF) \| 0x040000;
	362	gpio->pgcon = (gpio->pgcon & 0x0F3FFF) \| 0x008000;
	363	gpio->pgcon = (gpio->pgcon & 0x0CFFFF) \| 0x020000;
	364	gpio->pgcon = (gpio->pgcon & 0x03FFFF) \| 0x080000;
1cb8e980	365
48b42616	366	CLR_CS_TOUCH();
1cb8e980	367
d9abba82 N	368	spi->ch[0].sppre = 0x1F; /* Baudrate ca. 514kHz */
	369	spi->ch[0].sppin = 0x01; /* SPI-MOSI holds Level after last bit */
	370	spi->ch[0].spcon = 0x1A; /* Polling, Prescale, Master, CPOL=0, CPHA=1 */
1cb8e980 WD	371
	372	/* Dummy byte ensures clock to be low. */
	373	for (i = 0; i < 10; i++) {
d9abba82	374	spi->ch[0].sptdat = 0xFF;
1cb8e980	375	}
82226bf4	376	wait_transmit_done();
1cb8e980 WD	377	}
	378
	379	static void wait_transmit_done(void)
	380	{
eb0ae7f5	381	struct s3c24x0_spi * const spi = s3c24x0_get_base_spi();
48b42616	382
d9abba82 N	383	while (!(spi->ch[0].spsta & 0x01)) /* wait until transfer is done */
d9abba82 N	384	;
1cb8e980 WD	385	}
1cb8e980 WD	386
82226bf4	387	static void tsc2000_write(unsigned int page, unsigned int reg,
1cb8e980 WD	388	unsigned int data)
1cb8e980 WD	389	{
eb0ae7f5	390	struct s3c24x0_spi * const spi = s3c24x0_get_base_spi();
1cb8e980 WD	391	unsigned int command;
1cb8e980 WD	392
48b42616	393	SET_CS_TOUCH();
1cb8e980 WD	394	command = 0x0000;
	395	command \|= (page << 11);
	396	command \|= (reg << 5);
	397
d9abba82	398	spi->ch[0].sptdat = (command & 0xFF00) >> 8;
1cb8e980	399	wait_transmit_done();
d9abba82	400	spi->ch[0].sptdat = (command & 0x00FF);
1cb8e980	401	wait_transmit_done();
d9abba82	402	spi->ch[0].sptdat = (data & 0xFF00) >> 8;
1cb8e980	403	wait_transmit_done();
d9abba82	404	spi->ch[0].sptdat = (data & 0x00FF);
1cb8e980 WD	405	wait_transmit_done();
1cb8e980 WD	406
48b42616	407	CLR_CS_TOUCH();
1cb8e980 WD	408	}
	409
	410	static void tsc2000_set_brightness(void)
	411	{
a63c31cf	412	char tmp[10];
1cb8e980 WD	413	int i, br;
	414
	415	spi_init();
	416	tsc2000_write(1, 2, 0x0); /* Power up DAC */
	417
cdb74977	418	i = getenv_f("brightness", tmp, sizeof(tmp));
1cb8e980 WD	419	br = (i > 0)
1cb8e980 WD	420	? (int) simple_strtoul (tmp, NULL, 10)
6d0f6bcf	421	: CONFIG_SYS_BRIGHTNESS;
1cb8e980 WD	422
	423	tsc2000_write(0, 0xb, br & 0xff);
	424	}
	425	#endif
b1c0eaac BW	426
	427	#ifdef CONFIG_CMD_NET
	428	int board_eth_init(bd_t *bis)
	429	{
	430	int rc = 0;
	431	#ifdef CONFIG_CS8900
	432	rc = cs8900_initialize(0, CONFIG_CS8900_BASE);
	433	#endif
	434	return rc;
	435	}
	436	#endif