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

/*
 * avr.c
 *
 * AVR functions
 *
 * Copyright (C) 2006 Mihai Georgian <u-boot@linuxnotincluded.org.uk>
 *
 * 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 <ns16550.h>
#include <console.h>

/* Button codes from the AVR */
#define PWRR			0x20		/* Power button release	*/
#define PWRP			0x21		/* Power button push	*/
#define RESR			0x22		/* Reset button release	*/
#define RESP			0x23		/* Reset button push	*/
#define AVRINIT			0x33		/* Init complete	*/
#define AVRRESET		0x31		/* Reset request	*/

/* LED commands */
#define PWRBLINKSTRT		'['		/* Blink power LED	*/
#define PWRBLINKSTOP		'Z'		/* Solid power LED	*/
#define HDDLEDON		'W'		/* HDD LED on		*/
#define HDDLEDOFF		'V'		/* HDD LED off		*/
#define HDDBLINKSTRT		'Y'		/* HDD LED start blink	*/
#define HDDBLINKSTOP		'X'		/* HDD LED stop blink	*/

/* Timings for LEDs blinking to show choice */
#define PULSETIME		250		/* msecs		*/
#define LONGPAUSE		(5 * PULSETIME)

/* Button press times */
#define PUSHHOLD		1000		/* msecs		*/
#define NOBUTTON		(6 * (LONGPAUSE+PULSETIME))

/* Boot and console choices */
#define MAX_BOOT_CHOICE		3

static char *consoles[] = {
	"serial",
#if defined(CONFIG_NETCONSOLE)
	"nc",
#endif
};
#define MAX_CONS_CHOICE		(sizeof(consoles)/sizeof(char *))

#if !defined(CONFIG_NETCONSOLE)
#define DEF_CONS_CHOICE		0
#else
#define DEF_CONS_CHOICE		1
#endif

#define perror(fmt, args...) printf("%s: " fmt, __FUNCTION__ , ##args)

extern void miconCntl_SendCmd(unsigned char dat);
extern void miconCntl_DisWDT(void);

static int boot_stop;

static int boot_choice = 1;
static int cons_choice = DEF_CONS_CHOICE;

static char envbuffer[16];

void init_AVR_DUART (void)
{
	NS16550_t AVR_port = (NS16550_t) CONFIG_SYS_NS16550_COM2;
	int clock_divisor = CONFIG_SYS_NS16550_CLK / 16 / 9600;

	/*
	 * AVR port init sequence taken from
	 * the original Linkstation init code
	 * Normal U-Boot serial reinit doesn't
	 * work because the AVR uses even parity
	 */
	AVR_port->lcr = 0x00;
	AVR_port->ier = 0x00;
	AVR_port->lcr = LCR_BKSE;
	AVR_port->dll = clock_divisor & 0xff;
	AVR_port->dlm = (clock_divisor >> 8) & 0xff;
	AVR_port->lcr = LCR_WLS_8 | LCR_PEN | LCR_EPS;
	AVR_port->mcr = 0x00;
	AVR_port->fcr = FCR_FIFO_EN | FCR_RXSR | FCR_TXSR;

	miconCntl_DisWDT();

	boot_stop = 0;
	miconCntl_SendCmd(PWRBLINKSTRT);
}

static inline int avr_tstc(void)
{
	return (NS16550_tstc((NS16550_t)CONFIG_SYS_NS16550_COM2));
}

static inline char avr_getc(void)
{
	return (NS16550_getc((NS16550_t)CONFIG_SYS_NS16550_COM2));
}

static int push_timeout(char button_code)
{
	ulong push_start = get_timer(0);
	while (get_timer(push_start) <= PUSHHOLD)
		if (avr_tstc() && avr_getc() == button_code)
			return 0;
	return 1;
}

static void next_boot_choice(void)
{
	ulong return_start;
	ulong pulse_start;
	int on_times;
	int button_on;
	int led_state;
	char c;

	button_on = 0;
	return_start = get_timer(0);

	on_times = boot_choice;
	led_state = 0;
	miconCntl_SendCmd(HDDLEDOFF);
	pulse_start = get_timer(0);

	while (get_timer(return_start) <= NOBUTTON || button_on) {
		if (avr_tstc()) {
			c = avr_getc();
			if (c == PWRP)
				button_on = 1;
			else if (c == PWRR) {
				button_on = 0;
				return_start = get_timer(0);
				if (++boot_choice > MAX_BOOT_CHOICE)
					boot_choice = 1;
				sprintf(envbuffer, "bootcmd%d", boot_choice);
				if (getenv(envbuffer)) {
					sprintf(envbuffer, "run bootcmd%d", boot_choice);
					setenv("bootcmd", envbuffer);
				}
				on_times = boot_choice;
				led_state = 1;
				miconCntl_SendCmd(HDDLEDON);
				pulse_start = get_timer(0);
			} else {
				perror("Unexpected code: 0x%02X\n", c);
			}
		}
		if (on_times && get_timer(pulse_start) > PULSETIME) {
			if (led_state == 1) {
				--on_times;
				led_state = 0;
				miconCntl_SendCmd(HDDLEDOFF);
			} else {
				led_state = 1;
				miconCntl_SendCmd(HDDLEDON);
			}
			pulse_start = get_timer(0);
		}
		if (!on_times && get_timer(pulse_start) > LONGPAUSE) {
			on_times = boot_choice;
			led_state = 1;
			miconCntl_SendCmd(HDDLEDON);
			pulse_start = get_timer(0);
		}
	}
	if (led_state)
		miconCntl_SendCmd(HDDLEDOFF);
}

void next_cons_choice(int console)
{
	ulong return_start;
	ulong pulse_start;
	int on_times;
	int button_on;
	int led_state;
	char c;

	button_on = 0;
	cons_choice = console;
	return_start = get_timer(0);

	on_times = cons_choice+1;
	led_state = 1;
	miconCntl_SendCmd(HDDLEDON);
	pulse_start = get_timer(0);

	while (get_timer(return_start) <= NOBUTTON || button_on) {
		if (avr_tstc()) {
			c = avr_getc();
			if (c == RESP)
				button_on = 1;
			else if (c == RESR) {
				button_on = 0;
				return_start = get_timer(0);
				cons_choice = (cons_choice + 1) % MAX_CONS_CHOICE;
				console_assign(stdin, consoles[cons_choice]);
				console_assign(stdout, consoles[cons_choice]);
				console_assign(stderr, consoles[cons_choice]);
				on_times = cons_choice+1;
				led_state = 0;
				miconCntl_SendCmd(HDDLEDOFF);
				pulse_start = get_timer(0);
			} else {
				perror("Unexpected code: 0x%02X\n", c);
			}
		}
		if (on_times && get_timer(pulse_start) > PULSETIME) {
			if (led_state == 0) {
				--on_times;
				led_state = 1;
				miconCntl_SendCmd(HDDLEDON);
			} else {
				led_state = 0;
				miconCntl_SendCmd(HDDLEDOFF);
			}
			pulse_start = get_timer(0);
		}
		if (!on_times && get_timer(pulse_start) > LONGPAUSE) {
			on_times = cons_choice+1;
			led_state = 0;
			miconCntl_SendCmd(HDDLEDOFF);
			pulse_start = get_timer(0);
		}
	}
	if (led_state);
	miconCntl_SendCmd(HDDLEDOFF);
}

int avr_input(void)
{
	char avr_button;

	if (!avr_tstc())
		return 0;

	avr_button = avr_getc();
	switch (avr_button) {
	case PWRP:
		if (push_timeout(PWRR)) {
			/* Timeout before power button release */
			boot_stop = ~boot_stop;
			if (boot_stop)
				miconCntl_SendCmd(PWRBLINKSTOP);
			else
				miconCntl_SendCmd(PWRBLINKSTRT);
			/* Wait for power button release */
			while (avr_getc() != PWRR)
				;
		} else
			/* Power button released */
			next_boot_choice();
		break;
	case RESP:
		/* Wait for Reset button release */
		while (avr_getc() != RESR)
			;
		next_cons_choice(cons_choice);
		break;
	case AVRINIT:
		return 0;
	default:
		perror("Unexpected code: 0x%02X\n", avr_button);
		return 0;
	}
	if (boot_stop)
		return (-3);
	else
		return (-2);
}

void avr_StopBoot(void)
{
	boot_stop = ~0;
	miconCntl_SendCmd(PWRBLINKSTOP);
}
Commit	Line	Data
61525f2f GL	1	/*
	2	* avr.c
	3	*
	4	* AVR functions
	5	*
	6	* Copyright (C) 2006 Mihai Georgian <u-boot@linuxnotincluded.org.uk>
	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	#include <common.h>
	24	#include <ns16550.h>
	25	#include <console.h>
	26
	27	/* Button codes from the AVR */
	28	#define PWRR 0x20 /* Power button release */
	29	#define PWRP 0x21 /* Power button push */
	30	#define RESR 0x22 /* Reset button release */
	31	#define RESP 0x23 /* Reset button push */
	32	#define AVRINIT 0x33 /* Init complete */
	33	#define AVRRESET 0x31 /* Reset request */
	34
	35	/* LED commands */
	36	#define PWRBLINKSTRT '[' /* Blink power LED */
	37	#define PWRBLINKSTOP 'Z' /* Solid power LED */
53677ef1	38	#define HDDLEDON 'W' /* HDD LED on */
61525f2f GL	39	#define HDDLEDOFF 'V' /* HDD LED off */
	40	#define HDDBLINKSTRT 'Y' /* HDD LED start blink */
	41	#define HDDBLINKSTOP 'X' /* HDD LED stop blink */
	42
	43	/* Timings for LEDs blinking to show choice */
	44	#define PULSETIME 250 /* msecs */
	45	#define LONGPAUSE (5 * PULSETIME)
	46
	47	/* Button press times */
	48	#define PUSHHOLD 1000 /* msecs */
	49	#define NOBUTTON (6 * (LONGPAUSE+PULSETIME))
	50
	51	/* Boot and console choices */
	52	#define MAX_BOOT_CHOICE 3
	53
	54	static char *consoles[] = {
	55	"serial",
	56	#if defined(CONFIG_NETCONSOLE)
	57	"nc",
	58	#endif
	59	};
53677ef1	60	#define MAX_CONS_CHOICE (sizeof(consoles)/sizeof(char *))
61525f2f GL	61
	62	#if !defined(CONFIG_NETCONSOLE)
	63	#define DEF_CONS_CHOICE 0
	64	#else
	65	#define DEF_CONS_CHOICE 1
	66	#endif
	67
	68	#define perror(fmt, args...) printf("%s: " fmt, __FUNCTION__ , ##args)
	69
	70	extern void miconCntl_SendCmd(unsigned char dat);
	71	extern void miconCntl_DisWDT(void);
	72
	73	static int boot_stop;
	74
	75	static int boot_choice = 1;
	76	static int cons_choice = DEF_CONS_CHOICE;
	77
	78	static char envbuffer[16];
	79
	80	void init_AVR_DUART (void)
	81	{
6d0f6bcf JCPV	82	NS16550_t AVR_port = (NS16550_t) CONFIG_SYS_NS16550_COM2;
6d0f6bcf JCPV	83	int clock_divisor = CONFIG_SYS_NS16550_CLK / 16 / 9600;
61525f2f GL	84
	85	/*
	86	* AVR port init sequence taken from
	87	* the original Linkstation init code
	88	* Normal U-Boot serial reinit doesn't
	89	* work because the AVR uses even parity
	90	*/
	91	AVR_port->lcr = 0x00;
	92	AVR_port->ier = 0x00;
	93	AVR_port->lcr = LCR_BKSE;
	94	AVR_port->dll = clock_divisor & 0xff;
	95	AVR_port->dlm = (clock_divisor >> 8) & 0xff;
	96	AVR_port->lcr = LCR_WLS_8 \| LCR_PEN \| LCR_EPS;
	97	AVR_port->mcr = 0x00;
	98	AVR_port->fcr = FCR_FIFO_EN \| FCR_RXSR \| FCR_TXSR;
	99
	100	miconCntl_DisWDT();
	101
	102	boot_stop = 0;
	103	miconCntl_SendCmd(PWRBLINKSTRT);
	104	}
	105
	106	static inline int avr_tstc(void)
	107	{
6d0f6bcf	108	return (NS16550_tstc((NS16550_t)CONFIG_SYS_NS16550_COM2));
61525f2f GL	109	}
	110
	111	static inline char avr_getc(void)
	112	{
6d0f6bcf	113	return (NS16550_getc((NS16550_t)CONFIG_SYS_NS16550_COM2));
61525f2f GL	114	}
	115
	116	static int push_timeout(char button_code)
	117	{
	118	ulong push_start = get_timer(0);
	119	while (get_timer(push_start) <= PUSHHOLD)
	120	if (avr_tstc() && avr_getc() == button_code)
	121	return 0;
	122	return 1;
	123	}
	124
	125	static void next_boot_choice(void)
	126	{
	127	ulong return_start;
	128	ulong pulse_start;
	129	int on_times;
	130	int button_on;
	131	int led_state;
	132	char c;
	133
	134	button_on = 0;
	135	return_start = get_timer(0);
	136
	137	on_times = boot_choice;
	138	led_state = 0;
	139	miconCntl_SendCmd(HDDLEDOFF);
	140	pulse_start = get_timer(0);
	141
	142	while (get_timer(return_start) <= NOBUTTON \|\| button_on) {
	143	if (avr_tstc()) {
	144	c = avr_getc();
	145	if (c == PWRP)
	146	button_on = 1;
	147	else if (c == PWRR) {
	148	button_on = 0;
	149	return_start = get_timer(0);
	150	if (++boot_choice > MAX_BOOT_CHOICE)
	151	boot_choice = 1;
	152	sprintf(envbuffer, "bootcmd%d", boot_choice);
	153	if (getenv(envbuffer)) {
	154	sprintf(envbuffer, "run bootcmd%d", boot_choice);
	155	setenv("bootcmd", envbuffer);
	156	}
	157	on_times = boot_choice;
	158	led_state = 1;
	159	miconCntl_SendCmd(HDDLEDON);
	160	pulse_start = get_timer(0);
	161	} else {
	162	perror("Unexpected code: 0x%02X\n", c);
	163	}
	164	}
	165	if (on_times && get_timer(pulse_start) > PULSETIME) {
	166	if (led_state == 1) {
	167	--on_times;
	168	led_state = 0;
	169	miconCntl_SendCmd(HDDLEDOFF);
	170	} else {
	171	led_state = 1;
	172	miconCntl_SendCmd(HDDLEDON);
	173	}
	174	pulse_start = get_timer(0);
	175	}
	176	if (!on_times && get_timer(pulse_start) > LONGPAUSE) {
	177	on_times = boot_choice;
178	led_state = 1;
179	miconCntl_SendCmd(HDDLEDON);
180	pulse_start = get_timer(0);
181	}
182	}
183	if (led_state)
184	miconCntl_SendCmd(HDDLEDOFF);
185	}
186
187	void next_cons_choice(int console)
188	{
189	ulong return_start;
190	ulong pulse_start;
191	int on_times;
192	int button_on;
193	int led_state;
194	char c;
195
196	button_on = 0;
197	cons_choice = console;
198	return_start = get_timer(0);
199
200	on_times = cons_choice+1;
201	led_state = 1;
202	miconCntl_SendCmd(HDDLEDON);
203	pulse_start = get_timer(0);
204
205	while (get_timer(return_start) <= NOBUTTON \|\| button_on) {
206	if (avr_tstc()) {
207	c = avr_getc();
208	if (c == RESP)
209	button_on = 1;
210	else if (c == RESR) {
211	button_on = 0;
212	return_start = get_timer(0);
213	cons_choice = (cons_choice + 1) % MAX_CONS_CHOICE;
214	console_assign(stdin, consoles[cons_choice]);
215	console_assign(stdout, consoles[cons_choice]);
216	console_assign(stderr, consoles[cons_choice]);
217	on_times = cons_choice+1;
218	led_state = 0;
219	miconCntl_SendCmd(HDDLEDOFF);
220	pulse_start = get_timer(0);
221	} else {
222	perror("Unexpected code: 0x%02X\n", c);
223	}
224	}
225	if (on_times && get_timer(pulse_start) > PULSETIME) {
226	if (led_state == 0) {
227	--on_times;
228	led_state = 1;
229	miconCntl_SendCmd(HDDLEDON);
230	} else {
231	led_state = 0;
232	miconCntl_SendCmd(HDDLEDOFF);
233	}
234	pulse_start = get_timer(0);
235	}
236	if (!on_times && get_timer(pulse_start) > LONGPAUSE) {
237	on_times = cons_choice+1;
238	led_state = 0;
239	miconCntl_SendCmd(HDDLEDOFF);
240	pulse_start = get_timer(0);
241	}
242	}
243	if (led_state);
244	miconCntl_SendCmd(HDDLEDOFF);
245	}
246
247	int avr_input(void)
248	{
249	char avr_button;
250
251	if (!avr_tstc())
252	return 0;
253
254	avr_button = avr_getc();
255	switch (avr_button) {
256	case PWRP:
257	if (push_timeout(PWRR)) {
258	/* Timeout before power button release */
259	boot_stop = ~boot_stop;
260	if (boot_stop)
261	miconCntl_SendCmd(PWRBLINKSTOP);
262	else
263	miconCntl_SendCmd(PWRBLINKSTRT);
264	/* Wait for power button release */
265	while (avr_getc() != PWRR)
266	;
267	} else
268	/* Power button released */
269	next_boot_choice();
270	break;
271	case RESP:
272	/* Wait for Reset button release */
273	while (avr_getc() != RESR)
274	;
275	next_cons_choice(cons_choice);
276	break;
277	case AVRINIT:
278	return 0;
279	default:
280	perror("Unexpected code: 0x%02X\n", avr_button);
281	return 0;
282	}
283	if (boot_stop)
284	return (-3);
285	else
286	return (-2);
287	}
288
289	void avr_StopBoot(void)
290	{
291	boot_stop = ~0;
292	miconCntl_SendCmd(PWRBLINKSTOP);
293	}