Remove obsolete #include <linux/config.h>
[linux-2.6.git] / arch / ppc / xmon / start.c
1 /*
2  * Copyright (C) 1996 Paul Mackerras.
3  */
4 #include <linux/string.h>
5 #include <asm/machdep.h>
6 #include <asm/io.h>
7 #include <asm/page.h>
8 #include <linux/kernel.h>
9 #include <linux/errno.h>
10 #include <linux/sysrq.h>
11 #include <linux/bitops.h>
12 #include <asm/xmon.h>
13 #include <asm/machdep.h>
14 #include <asm/errno.h>
15 #include <asm/processor.h>
16 #include <asm/delay.h>
17 #include <asm/btext.h>
18
19 static volatile unsigned char *sccc, *sccd;
20 unsigned int TXRDY, RXRDY, DLAB;
21 static int xmon_expect(const char *str, unsigned int timeout);
22
23 static int via_modem;
24
25 #define TB_SPEED        25000000
26
27 static inline unsigned int readtb(void)
28 {
29         unsigned int ret;
30
31         asm volatile("mftb %0" : "=r" (ret) :);
32         return ret;
33 }
34
35 void buf_access(void)
36 {
37         if (DLAB)
38                 sccd[3] &= ~DLAB;       /* reset DLAB */
39 }
40
41
42 #ifdef CONFIG_MAGIC_SYSRQ
43 static void sysrq_handle_xmon(int key, struct pt_regs *regs,
44                               struct tty_struct *tty)
45 {
46         xmon(regs);
47 }
48
49 static struct sysrq_key_op sysrq_xmon_op =
50 {
51         .handler =      sysrq_handle_xmon,
52         .help_msg =     "Xmon",
53         .action_msg =   "Entering xmon",
54 };
55 #endif
56
57 void
58 xmon_map_scc(void)
59 {
60 #ifdef CONFIG_PPC_PREP
61         volatile unsigned char *base;
62
63 #elif defined(CONFIG_GEMINI)
64         /* should already be mapped by the kernel boot */
65         sccc = (volatile unsigned char *) 0xffeffb0d;
66         sccd = (volatile unsigned char *) 0xffeffb08;
67         TXRDY = 0x20;
68         RXRDY = 1;
69         DLAB = 0x80;
70 #elif defined(CONFIG_405GP)
71         sccc = (volatile unsigned char *)0xef600305;
72         sccd = (volatile unsigned char *)0xef600300;
73         TXRDY = 0x20;
74         RXRDY = 1;
75         DLAB = 0x80;
76 #endif /* platform */
77
78         register_sysrq_key('x', &sysrq_xmon_op);
79 }
80
81 static int scc_initialized;
82
83 void xmon_init_scc(void);
84
85 int
86 xmon_write(void *handle, void *ptr, int nb)
87 {
88         char *p = ptr;
89         int i, c, ct;
90
91 #ifdef CONFIG_SMP
92         static unsigned long xmon_write_lock;
93         int lock_wait = 1000000;
94         int locked;
95
96         while ((locked = test_and_set_bit(0, &xmon_write_lock)) != 0)
97                 if (--lock_wait == 0)
98                         break;
99 #endif
100
101         if (!scc_initialized)
102                 xmon_init_scc();
103         ct = 0;
104         for (i = 0; i < nb; ++i) {
105                 while ((*sccc & TXRDY) == 0)
106                         ;
107                 c = p[i];
108                 if (c == '\n' && !ct) {
109                         c = '\r';
110                         ct = 1;
111                         --i;
112                 } else {
113                         ct = 0;
114                 }
115                 buf_access();
116                 *sccd = c;
117                 eieio();
118         }
119
120 #ifdef CONFIG_SMP
121         if (!locked)
122                 clear_bit(0, &xmon_write_lock);
123 #endif
124         return nb;
125 }
126
127 int xmon_wants_key;
128
129
130 int
131 xmon_read(void *handle, void *ptr, int nb)
132 {
133     char *p = ptr;
134     int i;
135
136     if (!scc_initialized)
137         xmon_init_scc();
138     for (i = 0; i < nb; ++i) {
139         while ((*sccc & RXRDY) == 0)
140             ;
141         buf_access();
142         *p++ = *sccd;
143     }
144     return i;
145 }
146
147 int
148 xmon_read_poll(void)
149 {
150         if ((*sccc & RXRDY) == 0) {
151                 ;
152                 return -1;
153         }
154         buf_access();
155         return *sccd;
156 }
157
158 void
159 xmon_init_scc(void)
160 {
161         scc_initialized = 1;
162         if (via_modem) {
163                 for (;;) {
164                         xmon_write(NULL, "ATE1V1\r", 7);
165                         if (xmon_expect("OK", 5)) {
166                                 xmon_write(NULL, "ATA\r", 4);
167                                 if (xmon_expect("CONNECT", 40))
168                                         break;
169                         }
170                         xmon_write(NULL, "+++", 3);
171                         xmon_expect("OK", 3);
172                 }
173         }
174 }
175
176
177 void *xmon_stdin;
178 void *xmon_stdout;
179 void *xmon_stderr;
180
181 void
182 xmon_init(int arg)
183 {
184         xmon_map_scc();
185 }
186
187 int
188 xmon_putc(int c, void *f)
189 {
190     char ch = c;
191
192     if (c == '\n')
193         xmon_putc('\r', f);
194     return xmon_write(f, &ch, 1) == 1? c: -1;
195 }
196
197 int
198 xmon_putchar(int c)
199 {
200     return xmon_putc(c, xmon_stdout);
201 }
202
203 int
204 xmon_fputs(char *str, void *f)
205 {
206     int n = strlen(str);
207
208     return xmon_write(f, str, n) == n? 0: -1;
209 }
210
211 int
212 xmon_readchar(void)
213 {
214     char ch;
215
216     for (;;) {
217         switch (xmon_read(xmon_stdin, &ch, 1)) {
218         case 1:
219             return ch;
220         case -1:
221             xmon_printf("read(stdin) returned -1\r\n", 0, 0);
222             return -1;
223         }
224     }
225 }
226
227 static char line[256];
228 static char *lineptr;
229 static int lineleft;
230
231 int xmon_expect(const char *str, unsigned int timeout)
232 {
233         int c;
234         unsigned int t0;
235
236         timeout *= TB_SPEED;
237         t0 = readtb();
238         do {
239                 lineptr = line;
240                 for (;;) {
241                         c = xmon_read_poll();
242                         if (c == -1) {
243                                 if (readtb() - t0 > timeout)
244                                         return 0;
245                                 continue;
246                         }
247                         if (c == '\n')
248                                 break;
249                         if (c != '\r' && lineptr < &line[sizeof(line) - 1])
250                                 *lineptr++ = c;
251                 }
252                 *lineptr = 0;
253         } while (strstr(line, str) == NULL);
254         return 1;
255 }
256
257 int
258 xmon_getchar(void)
259 {
260     int c;
261
262     if (lineleft == 0) {
263         lineptr = line;
264         for (;;) {
265             c = xmon_readchar();
266             if (c == -1 || c == 4)
267                 break;
268             if (c == '\r' || c == '\n') {
269                 *lineptr++ = '\n';
270                 xmon_putchar('\n');
271                 break;
272             }
273             switch (c) {
274             case 0177:
275             case '\b':
276                 if (lineptr > line) {
277                     xmon_putchar('\b');
278                     xmon_putchar(' ');
279                     xmon_putchar('\b');
280                     --lineptr;
281                 }
282                 break;
283             case 'U' & 0x1F:
284                 while (lineptr > line) {
285                     xmon_putchar('\b');
286                     xmon_putchar(' ');
287                     xmon_putchar('\b');
288                     --lineptr;
289                 }
290                 break;
291             default:
292                 if (lineptr >= &line[sizeof(line) - 1])
293                     xmon_putchar('\a');
294                 else {
295                     xmon_putchar(c);
296                     *lineptr++ = c;
297                 }
298             }
299         }
300         lineleft = lineptr - line;
301         lineptr = line;
302     }
303     if (lineleft == 0)
304         return -1;
305     --lineleft;
306     return *lineptr++;
307 }
308
309 char *
310 xmon_fgets(char *str, int nb, void *f)
311 {
312     char *p;
313     int c;
314
315     for (p = str; p < str + nb - 1; ) {
316         c = xmon_getchar();
317         if (c == -1) {
318             if (p == str)
319                 return NULL;
320             break;
321         }
322         *p++ = c;
323         if (c == '\n')
324             break;
325     }
326     *p = 0;
327     return str;
328 }
329
330 void
331 xmon_enter(void)
332 {
333 }
334
335 void
336 xmon_leave(void)
337 {
338 }