PageRenderTime 21ms CodeModel.GetById 2ms app.highlight 15ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/ppc/xmon/start_8xx.c

https://bitbucket.org/evzijst/gittest
C | 287 lines | 236 code | 42 blank | 9 comment | 47 complexity | e903d19fdb898eb8a03928c15f95929b MD5 | raw file
  1/*
  2 * Copyright (C) 1996 Paul Mackerras.
  3 * Copyright (C) 2000 Dan Malek.
  4 * Quick hack of Paul's code to make XMON work on 8xx processors.  Lots
  5 * of assumptions, like the SMC1 is used, it has been initialized by the
  6 * loader at some point, and we can just stuff and suck bytes.
  7 * We rely upon the 8xx uart driver to support us, as the interface
  8 * changes between boot up and operational phases of the kernel.
  9 */
 10#include <linux/string.h>
 11#include <asm/machdep.h>
 12#include <asm/io.h>
 13#include <asm/page.h>
 14#include <linux/kernel.h>
 15#include <asm/8xx_immap.h>
 16#include <asm/mpc8xx.h>
 17#include <asm/commproc.h>
 18
 19extern void xmon_printf(const char *fmt, ...);
 20extern int xmon_8xx_write(char *str, int nb);
 21extern int xmon_8xx_read_poll(void);
 22extern int xmon_8xx_read_char(void);
 23void prom_drawhex(uint);
 24void prom_drawstring(const char *str);
 25
 26static int use_screen = 1; /* default */
 27
 28#define TB_SPEED	25000000
 29
 30static inline unsigned int readtb(void)
 31{
 32	unsigned int ret;
 33
 34	asm volatile("mftb %0" : "=r" (ret) :);
 35	return ret;
 36}
 37
 38void buf_access(void)
 39{
 40}
 41
 42void
 43xmon_map_scc(void)
 44{
 45
 46	cpmp = (cpm8xx_t *)&(((immap_t *)IMAP_ADDR)->im_cpm);
 47	use_screen = 0;
 48	
 49	prom_drawstring("xmon uses serial port\n");
 50}
 51
 52static int scc_initialized = 0;
 53
 54void xmon_init_scc(void);
 55
 56int
 57xmon_write(void *handle, void *ptr, int nb)
 58{
 59	char *p = ptr;
 60	int i, c, ct;
 61
 62	if (!scc_initialized)
 63		xmon_init_scc();
 64
 65	return(xmon_8xx_write(ptr, nb));
 66}
 67
 68int xmon_wants_key;
 69
 70int
 71xmon_read(void *handle, void *ptr, int nb)
 72{
 73	char *p = ptr;
 74	int i;
 75
 76	if (!scc_initialized)
 77		xmon_init_scc();
 78
 79	for (i = 0; i < nb; ++i) {
 80		*p++ = xmon_8xx_read_char();
 81	}
 82	return i;
 83}
 84
 85int
 86xmon_read_poll(void)
 87{
 88	return(xmon_8xx_read_poll());
 89}
 90
 91void
 92xmon_init_scc()
 93{
 94	scc_initialized = 1;
 95}
 96
 97#if 0
 98extern int (*prom_entry)(void *);
 99
100int
101xmon_exit(void)
102{
103    struct prom_args {
104	char *service;
105    } args;
106
107    for (;;) {
108	args.service = "exit";
109	(*prom_entry)(&args);
110    }
111}
112#endif
113
114void *xmon_stdin;
115void *xmon_stdout;
116void *xmon_stderr;
117
118void
119xmon_init(void)
120{
121}
122
123int
124xmon_putc(int c, void *f)
125{
126    char ch = c;
127
128    if (c == '\n')
129	xmon_putc('\r', f);
130    return xmon_write(f, &ch, 1) == 1? c: -1;
131}
132
133int
134xmon_putchar(int c)
135{
136    return xmon_putc(c, xmon_stdout);
137}
138
139int
140xmon_fputs(char *str, void *f)
141{
142    int n = strlen(str);
143
144    return xmon_write(f, str, n) == n? 0: -1;
145}
146
147int
148xmon_readchar(void)
149{
150    char ch;
151
152    for (;;) {
153	switch (xmon_read(xmon_stdin, &ch, 1)) {
154	case 1:
155	    return ch;
156	case -1:
157	    xmon_printf("read(stdin) returned -1\r\n", 0, 0);
158	    return -1;
159	}
160    }
161}
162
163static char line[256];
164static char *lineptr;
165static int lineleft;
166
167#if 0
168int xmon_expect(const char *str, unsigned int timeout)
169{
170	int c;
171	unsigned int t0;
172
173	timeout *= TB_SPEED;
174	t0 = readtb();
175	do {
176		lineptr = line;
177		for (;;) {
178			c = xmon_read_poll();
179			if (c == -1) {
180				if (readtb() - t0 > timeout)
181					return 0;
182				continue;
183			}
184			if (c == '\n')
185				break;
186			if (c != '\r' && lineptr < &line[sizeof(line) - 1])
187				*lineptr++ = c;
188		}
189		*lineptr = 0;
190	} while (strstr(line, str) == NULL);
191	return 1;
192}
193#endif
194
195int
196xmon_getchar(void)
197{
198    int c;
199
200    if (lineleft == 0) {
201	lineptr = line;
202	for (;;) {
203	    c = xmon_readchar();
204	    if (c == -1 || c == 4)
205		break;
206	    if (c == '\r' || c == '\n') {
207		*lineptr++ = '\n';
208		xmon_putchar('\n');
209		break;
210	    }
211	    switch (c) {
212	    case 0177:
213	    case '\b':
214		if (lineptr > line) {
215		    xmon_putchar('\b');
216		    xmon_putchar(' ');
217		    xmon_putchar('\b');
218		    --lineptr;
219		}
220		break;
221	    case 'U' & 0x1F:
222		while (lineptr > line) {
223		    xmon_putchar('\b');
224		    xmon_putchar(' ');
225		    xmon_putchar('\b');
226		    --lineptr;
227		}
228		break;
229	    default:
230		if (lineptr >= &line[sizeof(line) - 1])
231		    xmon_putchar('\a');
232		else {
233		    xmon_putchar(c);
234		    *lineptr++ = c;
235		}
236	    }
237	}
238	lineleft = lineptr - line;
239	lineptr = line;
240    }
241    if (lineleft == 0)
242	return -1;
243    --lineleft;
244    return *lineptr++;
245}
246
247char *
248xmon_fgets(char *str, int nb, void *f)
249{
250    char *p;
251    int c;
252
253    for (p = str; p < str + nb - 1; ) {
254	c = xmon_getchar();
255	if (c == -1) {
256	    if (p == str)
257		return 0;
258	    break;
259	}
260	*p++ = c;
261	if (c == '\n')
262	    break;
263    }
264    *p = 0;
265    return str;
266}
267
268void
269prom_drawhex(uint val)
270{
271	unsigned char buf[10];
272
273	int i;
274	for (i = 7;  i >= 0;  i--)
275	{
276		buf[i] = "0123456789abcdef"[val & 0x0f];
277		val >>= 4;
278	}
279	buf[8] = '\0';
280	xmon_fputs(buf, xmon_stdout);
281}
282
283void
284prom_drawstring(const char *str)
285{
286	xmon_fputs(str, xmon_stdout);
287}