[moodlight.git] / console.c

/* $Id: console.c,v 1.1 2010/06/26 12:28:08 simimeie Exp $
 * Functions for a serial console.
 */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/version.h>
#include <util/delay.h>
#include <stdio.h>
#include "console.h"

/* PD0 is RXD, PD1 is TXD, but we don't need to address them manually */

/* Formula for calculating the value of UBRR from baudrate and cpufreq */
#define UBRRCALC ((CPUFREQ / (16 * BAUDRATE)) - 1)

#define INPUTBUFSIZE 30
static uint8_t inputbuf[INPUTBUFSIZE];
static uint8_t inputpos = 0;
#define OUTPUTBUFSIZE 400
static uint8_t outputbuf[OUTPUTBUFSIZE];
static uint16_t outputhead = 0; /* WARNING cannot be modified atomically */
static uint16_t outputtail = 0;
static uint8_t opinprog = 0;
static uint8_t escstatus = 0;
static prog_uint8_t CRLF[] = "\r\n";
static prog_uint8_t WELCOMEMSG[] = "\r\n"\
				   "\r\n ******************************************"\
				   "\r\n * universal mainboard v1                 *"\
				   "\r\n * (C) Michael 'PoempelFox' Meier 05/2010 *"\
				   "\r\n ******************************************"\
				   "\r\n"\
				   "\r\nProcessor: atmega328"\
				   "\r\nAVR-libc: " __AVR_LIBC_VERSION_STRING__ " (" __AVR_LIBC_DATE_STRING__ ")"\
				   "\r\nSoftware Version 0.1, Compiled " __DATE__ " " __TIME__;
static prog_uint8_t PROMPT[] = "\r\nroot@mbv1# ";

/* Handler for TXC (TX Complete) IRQ */
ISR(USART_TX_vect) {
	if (outputhead == outputtail) { /* Nothing more to send! */
		opinprog = 0;
	} else {
		UDR0 = outputbuf[outputhead];
		outputhead++;
		if (outputhead >= OUTPUTBUFSIZE) {
			outputhead = 0;
		}
	}
}

#if defined __GNUC__
/* Unfortunately, gcc is very very dumb, and despite -Os tries to inline this
 * function even though it is called about a thousand times, when only
 * NETCONSOLE is defined, costing us more than 2.5 KiloBytes of Flash.
 * Way to go, gcc "optimization". Though NETCONSOLE does not exist
 * in this copy of the console code, it certainly can't hurt. */
static void appendchar(uint8_t what) __attribute__((noinline));
#endif /* __GNUC__ */
/* This can only be called safely with interrupts disabled - remember that! */
static void appendchar(uint8_t what) {
  uint16_t newpos;
  newpos = (outputtail + 1);
  if (newpos >= OUTPUTBUFSIZE) {
    newpos = 0;
  }
  if (newpos != outputhead) {
    outputbuf[outputtail] = what;
    outputtail = newpos;
  }
  if (!opinprog) {
    /* Send the byte */
    UDR0 = what;
    outputhead++;
    if (outputhead >= OUTPUTBUFSIZE) {
      outputhead = 0;
    }
    opinprog = 1;
  }
}

void console_printchar_noirq(uint8_t what) {
  appendchar(what);
}

/* This can only be called safely with interrupts disabled - remember that! */
void console_printhex8_noirq(uint8_t what) {
	uint8_t buf;
	uint8_t i;
	for (i=0; i<2; i++) {
		buf = (uint8_t)(what & (uint8_t)0xF0) >> 4;
		if (buf <= 9) {
			buf += '0';
		} else {
			buf += 'A' - 10;
		}
		appendchar(buf);
		what <<= 4;
	}
}

/* This can only be called safely with interrupts disabled - remember that! */
void console_printdec_noirq(uint8_t what) {
  uint8_t buf;
  buf = what / 100;
  appendchar(buf + '0');
  what %= 100;
  buf = what / 10;
  appendchar(buf + '0');
  buf = what % 10;
  appendchar(buf + '0');
}

/* This can only be called safely with interrupts disabled - remember that! */
void console_printbin8_noirq(uint8_t what) {
	uint8_t i;
	for (i = 0; i < 8; i++) {
		if (what & 0x80) {
			appendchar('1');
		} else {
			appendchar('0');
		}
		what <<= 1;
	}
}

/* This can only be called safely with interrupts disabled - remember that! */
static void console_printtext_noirq(const uint8_t * what) {
	while (*what) {
		appendchar(*what);
		what++;
	}
}

/* This can only be called safely with interrupts disabled - remember that! */
static void console_printpgm_noirq_P(PGM_P what) {
	uint8_t t;
	while ((t = pgm_read_byte(what++))) {
		appendchar(t);
	}
}

/* These are wrappers for our internal functions, disabling IRQs before
 * calling them. */
void console_printtext(const uint8_t * what) {
	cli();
	console_printtext_noirq(what);
	sei();
}

void console_printpgm_P(PGM_P what) {
	cli();
	console_printpgm_noirq_P(what);
	sei();
}

void console_printhex8(uint8_t what) {
	cli();
	console_printhex8_noirq(what);
	sei();
}

void console_printdec(uint8_t what) {
	cli();
	console_printdec_noirq(what);
	sei();
}

void console_init(void) {
	/* Set Baud Rate */
	UBRR0H = (uint8_t)(UBRRCALC >> 8);
	UBRR0L = (uint8_t)(UBRRCALC);
	/* Set 8 Bit mode - how braindead is it to default to 5 bit?! */
	UCSR0C = /* _BV(URSEL) | */ _BV(UCSZ00) | _BV(UCSZ01);
	/* Enable Send and Receive and IRQs */
	UCSR0B = _BV(TXEN0) | _BV(RXEN0) | _BV(TXCIE0) | _BV(RXCIE0);
	console_printpgm_noirq_P(WELCOMEMSG);
	console_printpgm_noirq_P(PROMPT);
	return;
}

/* Handler for RXC (RX Complete) IRQ. */
/* We do all query processing here. */
ISR(USART_RX_vect) {
	uint8_t inpb;
	
	inpb = UDR0;
	if (escstatus == 1) {
		if (inpb == '[') {
			escstatus = 2;
		} else {
			escstatus = 0;
			appendchar(7); /* Bell */
		}
		return;
	}
	if (escstatus == 2) {
		switch (inpb) {
		case 'A': /* Up */
			/* Try to restore the last comnmand */
			for (; inputpos > 0; inputpos--) {
				appendchar(8);
			}
			while (inputbuf[inputpos]) {
				appendchar(inputbuf[inputpos++]);
			}
			break;
		case 'B': /* Down */
			/* New empty command line */
			for (; inputpos > 0; inputpos--) {
				appendchar(8);
				appendchar(' ');
				appendchar(8);
			}
			break;
		case 'C': /* Left */
		case 'D': /* Right */
		default:
			appendchar(7); /* Bell */
			break;
		};
		escstatus = 0;
		return;
	}
	/* escstatus == 0, i.e. not in an escape */
	switch (inpb) {
	case 0 ... 7: /* Nonprinting characters. Ignore. */
	case 11 ... 12: /* Nonprinting characters. Ignore. */
	case 14 ... 26: /* Nonprinting characters. Ignore. */
	case 28 ... 31: /* Nonprinting characters. Ignore. */
	case 0x7f ... 0xff: /* Nonprinting characters. Ignore. */
		console_printhex8_noirq(inpb);
		appendchar(7); /* Bell */
		break;
	case 9: /* tab. Should be implemented some day? */
		appendchar(7); /* Bell */
		break;
	case 27: /* Escape */
		escstatus = 1;
		break;
	case 8: /* Backspace */
		if (inputpos > 0) {
			inputpos--;
			appendchar(inpb);
			appendchar(' ');
			appendchar(inpb);
		}
		break;
	case '\r': /* 13 */
	case '\n': /* 10 */
		if (inputpos == 0) {
			console_printpgm_noirq_P(PROMPT);
			break;
		}
		inputbuf[inputpos] = 0; /* Null-terminate the string */
		console_printpgm_noirq_P(CRLF);
		/* now lets see what it is */
		if        (strcmp_P(inputbuf, PSTR("help")) == 0) {
			console_printpgm_noirq_P(PSTR("Available commands:"));
			console_printpgm_noirq_P(PSTR("\r\n motd             repeat welcome message"));
			console_printpgm_noirq_P(PSTR("\r\n showpins [x]     shows the avrs inputpins"));
			console_printpgm_noirq_P(PSTR("\r\n status           show status / counters"));
			/* console_printpgm_noirq_P(PSTR("\r\n save             saves settings to EEPROM")); */
		} else if (strcmp_P(inputbuf, PSTR("motd")) == 0) {
			console_printpgm_noirq_P(WELCOMEMSG);
		} else if (strncmp_P(inputbuf, PSTR("showpins"), 8) == 0) {
			uint8_t which = 0;
			uint8_t stal = 1; uint8_t endl = 4;
			if (inputpos == 10) {
				switch (inputbuf[9]) {
				case 'a':
				case 'A':
					which = 1; break;
				case 'b':
				case 'B':
					which = 2; break;
				case 'c':
				case 'C':
					which = 3; break;
				case 'd':
				case 'D':
					which = 4; break;
				};
			}
			if (which) {
				stal = which;
				endl = which;
			}
			for (which = stal; which <= endl; which++) {
				uint8_t pstatus;
				switch (which) {
/*				case 1: pstatus = PINA;
					console_printpgm_noirq_P(PSTR("PINA: 0x"));
					break;*/
				case 2: pstatus = PINB;
					console_printpgm_noirq_P(PSTR("PINB: 0x"));
					break;
				case 3: pstatus = PINC;
					console_printpgm_noirq_P(PSTR("PINC: 0x"));
					break;
				case 4: pstatus = PIND;
					console_printpgm_noirq_P(PSTR("PIND: 0x"));
					break;
				default:
					pstatus = 0;
					console_printpgm_noirq_P(PSTR("NOPIN: 0x"));
					break;
				};
				console_printhex8_noirq(pstatus);
				appendchar(' ');
				console_printbin8_noirq(pstatus);
				if (which < endl) {
					appendchar('\r'); appendchar('\n');
				}
			}
/*		} else if (strcmp_P(inputbuf, PSTR("save")) == 0) {
			saveeepromsettings();
			console_printpgm_noirq_P(PSTR("Settings written to EEPROM."));*/
		} else if (strcmp_P(inputbuf, PSTR("status")) == 0) {
			console_printpgm_noirq_P(PSTR("Current status:\r\n"));
			console_printpgm_noirq_P(PSTR("none. nothing implemented yet."));
#ifdef JOKECMDS
		} else if (strncmp_P(inputbuf, PSTR("ls"), 2) == 0) {
			console_printpgm_noirq_P(PSTR("Total 4711\r\n"));
			console_printpgm_noirq_P(PSTR("----r-xr--  1 root root 42234223666 Dec 18  2004 duschcam1.avi"));
		} else if (strncmp_P(inputbuf, PSTR("cat"), 3) == 0) {
			if (inputpos > 4) {
				console_printtext_noirq(&inputbuf[4]);
				console_printpgm_noirq_P(PSTR(": Permission denied"));
			} else {
				console_printpgm_noirq_P(PSTR("Usage: cat filename"));
			}
#endif /* JOKECMDS */
		} else {
#ifdef JOKECMDS
			console_printpgm_noirq_P(PSTR("bash: "));
			console_printtext_noirq(inputbuf);
			console_printpgm_noirq_P(PSTR(": command not found."));
#else /* JOKECMDS */
			console_printpgm_noirq_P(PSTR("Unknown command: "));
			console_printtext_noirq(inputbuf);
#endif /* JOKECMDS */
		}
		/* show PROMPT and go back to start. */
		console_printpgm_noirq_P(PROMPT);
		inputpos = 0;
		break;
	default:
		if (inputpos < (INPUTBUFSIZE - 1)) { /* -1 for terminating \0 */
			inputbuf[inputpos++] = inpb;
			/* Echo the character */
			appendchar(inpb);
		} else {
			appendchar(7); /* Bell */
		}
	};
}
Commit	Line	Data
2d3643ee	1	/* $Id: console.c,v 1.1 2010/06/26 12:28:08 simimeie Exp $
	2	* Functions for a serial console.
	3	*/
	4
	5	#include <avr/io.h>
	6	#include <avr/interrupt.h>
	7	#include <avr/pgmspace.h>
	8	#include <avr/version.h>
	9	#include <util/delay.h>
	10	#include <stdio.h>
	11	#include "console.h"
	12
	13	/* PD0 is RXD, PD1 is TXD, but we don't need to address them manually */
	14
	15	/* Formula for calculating the value of UBRR from baudrate and cpufreq */
	16	#define UBRRCALC ((CPUFREQ / (16 * BAUDRATE)) - 1)
	17
	18	#define INPUTBUFSIZE 30
	19	static uint8_t inputbuf[INPUTBUFSIZE];
	20	static uint8_t inputpos = 0;
	21	#define OUTPUTBUFSIZE 400
	22	static uint8_t outputbuf[OUTPUTBUFSIZE];
	23	static uint16_t outputhead = 0; /* WARNING cannot be modified atomically */
	24	static uint16_t outputtail = 0;
	25	static uint8_t opinprog = 0;
	26	static uint8_t escstatus = 0;
	27	static prog_uint8_t CRLF[] = "\r\n";
	28	static prog_uint8_t WELCOMEMSG[] = "\r\n"\
	29	"\r\n ******************************************"\
	30	"\r\n * universal mainboard v1 *"\
	31	"\r\n * (C) Michael 'PoempelFox' Meier 05/2010 *"\
	32	"\r\n ******************************************"\
	33	"\r\n"\
	34	"\r\nProcessor: atmega328"\
	35	"\r\nAVR-libc: " __AVR_LIBC_VERSION_STRING__ " (" __AVR_LIBC_DATE_STRING__ ")"\
	36	"\r\nSoftware Version 0.1, Compiled " __DATE__ " " __TIME__;
	37	static prog_uint8_t PROMPT[] = "\r\nroot@mbv1# ";
	38
	39	/* Handler for TXC (TX Complete) IRQ */
	40	ISR(USART_TX_vect) {
	41	if (outputhead == outputtail) { /* Nothing more to send! */
	42	opinprog = 0;
	43	} else {
	44	UDR0 = outputbuf[outputhead];
	45	outputhead++;
	46	if (outputhead >= OUTPUTBUFSIZE) {
	47	outputhead = 0;
	48	}
	49	}
	50	}
	51
	52	#if defined __GNUC__
	53	/* Unfortunately, gcc is very very dumb, and despite -Os tries to inline this
	54	* function even though it is called about a thousand times, when only
	55	* NETCONSOLE is defined, costing us more than 2.5 KiloBytes of Flash.
	56	* Way to go, gcc "optimization". Though NETCONSOLE does not exist
	57	* in this copy of the console code, it certainly can't hurt. */
	58	static void appendchar(uint8_t what) __attribute__((noinline));
	59	#endif /* __GNUC__ */
	60	/* This can only be called safely with interrupts disabled - remember that! */
	61	static void appendchar(uint8_t what) {
	62	uint16_t newpos;
	63	newpos = (outputtail + 1);
	64	if (newpos >= OUTPUTBUFSIZE) {
65	newpos = 0;
66	}
67	if (newpos != outputhead) {
68	outputbuf[outputtail] = what;
69	outputtail = newpos;
70	}
71	if (!opinprog) {
72	/* Send the byte */
73	UDR0 = what;
74	outputhead++;
75	if (outputhead >= OUTPUTBUFSIZE) {
76	outputhead = 0;
77	}
78	opinprog = 1;
79	}
80	}
81
82	void console_printchar_noirq(uint8_t what) {
83	appendchar(what);
84	}
85
86	/* This can only be called safely with interrupts disabled - remember that! */
87	void console_printhex8_noirq(uint8_t what) {
88	uint8_t buf;
89	uint8_t i;
90	for (i=0; i<2; i++) {
91	buf = (uint8_t)(what & (uint8_t)0xF0) >> 4;
92	if (buf <= 9) {
93	buf += '0';
94	} else {
95	buf += 'A' - 10;
96	}
97	appendchar(buf);
98	what <<= 4;
99	}
100	}
101
102	/* This can only be called safely with interrupts disabled - remember that! */
103	void console_printdec_noirq(uint8_t what) {
104	uint8_t buf;
105	buf = what / 100;
106	appendchar(buf + '0');
107	what %= 100;
108	buf = what / 10;
109	appendchar(buf + '0');
110	buf = what % 10;
111	appendchar(buf + '0');
112	}
113
114	/* This can only be called safely with interrupts disabled - remember that! */
115	void console_printbin8_noirq(uint8_t what) {
116	uint8_t i;
117	for (i = 0; i < 8; i++) {
118	if (what & 0x80) {
119	appendchar('1');
120	} else {
121	appendchar('0');
122	}
123	what <<= 1;
124	}
125	}
126
127	/* This can only be called safely with interrupts disabled - remember that! */
128	static void console_printtext_noirq(const uint8_t * what) {
129	while (*what) {
130	appendchar(*what);
131	what++;
132	}
133	}
134
135	/* This can only be called safely with interrupts disabled - remember that! */
136	static void console_printpgm_noirq_P(PGM_P what) {
137	uint8_t t;
138	while ((t = pgm_read_byte(what++))) {
139	appendchar(t);
140	}
141	}
142
143	/* These are wrappers for our internal functions, disabling IRQs before
144	* calling them. */
145	void console_printtext(const uint8_t * what) {
146	cli();
147	console_printtext_noirq(what);
148	sei();
149	}
150
151	void console_printpgm_P(PGM_P what) {
152	cli();
153	console_printpgm_noirq_P(what);
154	sei();
155	}
156
157	void console_printhex8(uint8_t what) {
158	cli();
159	console_printhex8_noirq(what);
160	sei();
161	}
162
163	void console_printdec(uint8_t what) {
164	cli();
165	console_printdec_noirq(what);
166	sei();
167	}
168
169	void console_init(void) {
170	/* Set Baud Rate */
171	UBRR0H = (uint8_t)(UBRRCALC >> 8);
172	UBRR0L = (uint8_t)(UBRRCALC);
173	/* Set 8 Bit mode - how braindead is it to default to 5 bit?! */
174	UCSR0C = /* _BV(URSEL) \| */ _BV(UCSZ00) \| _BV(UCSZ01);
175	/* Enable Send and Receive and IRQs */
176	UCSR0B = _BV(TXEN0) \| _BV(RXEN0) \| _BV(TXCIE0) \| _BV(RXCIE0);
177	console_printpgm_noirq_P(WELCOMEMSG);
178	console_printpgm_noirq_P(PROMPT);
179	return;
180	}
181
182	/* Handler for RXC (RX Complete) IRQ. */
183	/* We do all query processing here. */
184	ISR(USART_RX_vect) {
185	uint8_t inpb;
186
187	inpb = UDR0;
188	if (escstatus == 1) {
189	if (inpb == '[') {
190	escstatus = 2;
191	} else {
192	escstatus = 0;
193	appendchar(7); /* Bell */
194	}
195	return;
196	}
197	if (escstatus == 2) {
198	switch (inpb) {
199	case 'A': /* Up */
200	/* Try to restore the last comnmand */
201	for (; inputpos > 0; inputpos--) {
202	appendchar(8);
203	}
204	while (inputbuf[inputpos]) {
205	appendchar(inputbuf[inputpos++]);
206	}
207	break;
208	case 'B': /* Down */
209	/* New empty command line */
210	for (; inputpos > 0; inputpos--) {
211	appendchar(8);
212	appendchar(' ');
213	appendchar(8);
214	}
215	break;
216	case 'C': /* Left */
217	case 'D': /* Right */
218	default:
219	appendchar(7); /* Bell */
220	break;
221	};
222	escstatus = 0;
223	return;
224	}
225	/* escstatus == 0, i.e. not in an escape */
226	switch (inpb) {
227	case 0 ... 7: /* Nonprinting characters. Ignore. */
228	case 11 ... 12: /* Nonprinting characters. Ignore. */
229	case 14 ... 26: /* Nonprinting characters. Ignore. */
230	case 28 ... 31: /* Nonprinting characters. Ignore. */
231	case 0x7f ... 0xff: /* Nonprinting characters. Ignore. */
232	console_printhex8_noirq(inpb);
233	appendchar(7); /* Bell */
234	break;
235	case 9: /* tab. Should be implemented some day? */
236	appendchar(7); /* Bell */
237	break;
238	case 27: /* Escape */
239	escstatus = 1;
240	break;
241	case 8: /* Backspace */
242	if (inputpos > 0) {
243	inputpos--;
244	appendchar(inpb);
245	appendchar(' ');
246	appendchar(inpb);
247	}
248	break;
249	case '\r': /* 13 */
250	case '\n': /* 10 */
251	if (inputpos == 0) {
252	console_printpgm_noirq_P(PROMPT);
253	break;
254	}
255	inputbuf[inputpos] = 0; /* Null-terminate the string */
256	console_printpgm_noirq_P(CRLF);
257	/* now lets see what it is */
258	if (strcmp_P(inputbuf, PSTR("help")) == 0) {
259	console_printpgm_noirq_P(PSTR("Available commands:"));
260	console_printpgm_noirq_P(PSTR("\r\n motd repeat welcome message"));
261	console_printpgm_noirq_P(PSTR("\r\n showpins [x] shows the avrs inputpins"));
262	console_printpgm_noirq_P(PSTR("\r\n status show status / counters"));
263	/* console_printpgm_noirq_P(PSTR("\r\n save saves settings to EEPROM")); */
264	} else if (strcmp_P(inputbuf, PSTR("motd")) == 0) {
265	console_printpgm_noirq_P(WELCOMEMSG);
266	} else if (strncmp_P(inputbuf, PSTR("showpins"), 8) == 0) {
267	uint8_t which = 0;
268	uint8_t stal = 1; uint8_t endl = 4;
269	if (inputpos == 10) {
270	switch (inputbuf[9]) {
271	case 'a':
272	case 'A':
273	which = 1; break;
274	case 'b':
275	case 'B':
276	which = 2; break;
277	case 'c':
278	case 'C':
279	which = 3; break;
280	case 'd':
281	case 'D':
282	which = 4; break;
283	};
284	}
285	if (which) {
286	stal = which;
287	endl = which;
288	}
289	for (which = stal; which <= endl; which++) {
290	uint8_t pstatus;
291	switch (which) {
292	/* case 1: pstatus = PINA;
293	console_printpgm_noirq_P(PSTR("PINA: 0x"));
294	break;*/
295	case 2: pstatus = PINB;
296	console_printpgm_noirq_P(PSTR("PINB: 0x"));
297	break;
298	case 3: pstatus = PINC;
299	console_printpgm_noirq_P(PSTR("PINC: 0x"));
300	break;
301	case 4: pstatus = PIND;
302	console_printpgm_noirq_P(PSTR("PIND: 0x"));
303	break;
304	default:
305	pstatus = 0;
306	console_printpgm_noirq_P(PSTR("NOPIN: 0x"));
307	break;
308	};
309	console_printhex8_noirq(pstatus);
310	appendchar(' ');
311	console_printbin8_noirq(pstatus);
312	if (which < endl) {
313	appendchar('\r'); appendchar('\n');
314	}
315	}
316	/* } else if (strcmp_P(inputbuf, PSTR("save")) == 0) {
317	saveeepromsettings();
318	console_printpgm_noirq_P(PSTR("Settings written to EEPROM."));*/
319	} else if (strcmp_P(inputbuf, PSTR("status")) == 0) {
320	console_printpgm_noirq_P(PSTR("Current status:\r\n"));
321	console_printpgm_noirq_P(PSTR("none. nothing implemented yet."));
322	#ifdef JOKECMDS
323	} else if (strncmp_P(inputbuf, PSTR("ls"), 2) == 0) {
324	console_printpgm_noirq_P(PSTR("Total 4711\r\n"));
325	console_printpgm_noirq_P(PSTR("----r-xr-- 1 root root 42234223666 Dec 18 2004 duschcam1.avi"));
326	} else if (strncmp_P(inputbuf, PSTR("cat"), 3) == 0) {
327	if (inputpos > 4) {
328	console_printtext_noirq(&inputbuf[4]);
329	console_printpgm_noirq_P(PSTR(": Permission denied"));
330	} else {
331	console_printpgm_noirq_P(PSTR("Usage: cat filename"));
332	}
333	#endif /* JOKECMDS */
334	} else {
335	#ifdef JOKECMDS
336	console_printpgm_noirq_P(PSTR("bash: "));
337	console_printtext_noirq(inputbuf);
338	console_printpgm_noirq_P(PSTR(": command not found."));
339	#else /* JOKECMDS */
340	console_printpgm_noirq_P(PSTR("Unknown command: "));
341	console_printtext_noirq(inputbuf);
342	#endif /* JOKECMDS */
343	}
344	/* show PROMPT and go back to start. */
345	console_printpgm_noirq_P(PROMPT);
346	inputpos = 0;
347	break;
348	default:
349	if (inputpos < (INPUTBUFSIZE - 1)) { /* -1 for terminating \0 */
350	inputbuf[inputpos++] = inpb;
351	/* Echo the character */
352	appendchar(inpb);
353	} else {
354	appendchar(7); /* Bell */
355	}
356	};
357	}