diff options
author | Paul Mackerras <paulus@samba.org> | 2008-06-09 00:01:46 -0400 |
---|---|---|
committer | Paul Mackerras <paulus@samba.org> | 2008-06-10 07:40:22 -0400 |
commit | 917f0af9e5a9ceecf9e72537fabb501254ba321d (patch) | |
tree | 1ef207755c6d83ce4af93ef2b5e4645eebd65886 /arch/ppc/boot/common/misc-common.c | |
parent | 0f3d6bcd391b058c619fc30e8022e8a29fbf4bef (diff) |
powerpc: Remove arch/ppc and include/asm-ppc
All the maintained platforms are now in arch/powerpc, so the old
arch/ppc stuff can now go away.
Acked-by: Adrian Bunk <bunk@kernel.org>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Acked-by: Becky Bruce <becky.bruce@freescale.com>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Acked-by: Geert Uytterhoeven <geert@linux-m68k.org>
Acked-by: Grant Likely <grant.likely@secretlab.ca>
Acked-by: Jochen Friedrich <jochen@scram.de>
Acked-by: John Linn <john.linn@xilinx.com>
Acked-by: Jon Loeliger <jdl@freescale.com>
Acked-by: Josh Boyer <jwboyer@linux.vnet.ibm.com>
Acked-by: Kumar Gala <galak@kernel.crashing.org>
Acked-by: Olof Johansson <olof@lixom.net>
Acked-by: Peter Korsgaard <jacmet@sunsite.dk>
Acked-by: Scott Wood <scottwood@freescale.com>
Acked-by: Sean MacLennan <smaclennan@pikatech.com>
Acked-by: Segher Boessenkool <segher@kernel.crashing.org>
Acked-by: Stefan Roese <sr@denx.de>
Acked-by: Stephen Neuendorffer <stephen.neuendorffer@xilinx.com>
Acked-by: Wolfgang Denk <wd@denx.de>
Signed-off-by: Paul Mackerras <paulus@samba.org>
Diffstat (limited to 'arch/ppc/boot/common/misc-common.c')
-rw-r--r-- | arch/ppc/boot/common/misc-common.c | 555 |
1 files changed, 0 insertions, 555 deletions
diff --git a/arch/ppc/boot/common/misc-common.c b/arch/ppc/boot/common/misc-common.c deleted file mode 100644 index 9589969cec72..000000000000 --- a/arch/ppc/boot/common/misc-common.c +++ /dev/null | |||
@@ -1,555 +0,0 @@ | |||
1 | /* | ||
2 | * Misc. bootloader code (almost) all platforms can use | ||
3 | * | ||
4 | * Author: Johnnie Peters <jpeters@mvista.com> | ||
5 | * Editor: Tom Rini <trini@mvista.com> | ||
6 | * | ||
7 | * Derived from arch/ppc/boot/prep/misc.c | ||
8 | * | ||
9 | * 2000-2001 (c) MontaVista, Software, Inc. This file is licensed under | ||
10 | * the terms of the GNU General Public License version 2. This program | ||
11 | * is licensed "as is" without any warranty of any kind, whether express | ||
12 | * or implied. | ||
13 | */ | ||
14 | |||
15 | #include <stdarg.h> /* for va_ bits */ | ||
16 | #include <linux/string.h> | ||
17 | #include <linux/zlib.h> | ||
18 | #include "nonstdio.h" | ||
19 | |||
20 | /* If we're on a PReP, assume we have a keyboard controller | ||
21 | * Also note, if we're not PReP, we assume you are a serial | ||
22 | * console - Tom */ | ||
23 | #if defined(CONFIG_PPC_PREP) && defined(CONFIG_VGA_CONSOLE) | ||
24 | extern void cursor(int x, int y); | ||
25 | extern void scroll(void); | ||
26 | extern char *vidmem; | ||
27 | extern int lines, cols; | ||
28 | extern int orig_x, orig_y; | ||
29 | extern int keyb_present; | ||
30 | extern int CRT_tstc(void); | ||
31 | extern int CRT_getc(void); | ||
32 | #else | ||
33 | int cursor(int x, int y) {return 0;} | ||
34 | void scroll(void) {} | ||
35 | char vidmem[1]; | ||
36 | #define lines 0 | ||
37 | #define cols 0 | ||
38 | int orig_x = 0; | ||
39 | int orig_y = 0; | ||
40 | #define keyb_present 0 | ||
41 | int CRT_tstc(void) {return 0;} | ||
42 | int CRT_getc(void) {return 0;} | ||
43 | #endif | ||
44 | |||
45 | extern char *avail_ram; | ||
46 | extern char *end_avail; | ||
47 | extern char _end[]; | ||
48 | |||
49 | void puts(const char *); | ||
50 | void putc(const char c); | ||
51 | void puthex(unsigned long val); | ||
52 | void gunzip(void *, int, unsigned char *, int *); | ||
53 | static int _cvt(unsigned long val, char *buf, long radix, char *digits); | ||
54 | |||
55 | void _vprintk(void(*putc)(const char), const char *fmt0, va_list ap); | ||
56 | unsigned char *ISA_io = NULL; | ||
57 | |||
58 | #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \ | ||
59 | || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \ | ||
60 | || defined(CONFIG_SERIAL_MPSC_CONSOLE) \ | ||
61 | || defined(CONFIG_SERIAL_UARTLITE_CONSOLE) | ||
62 | extern unsigned long com_port; | ||
63 | |||
64 | extern int serial_tstc(unsigned long com_port); | ||
65 | extern unsigned char serial_getc(unsigned long com_port); | ||
66 | extern void serial_putc(unsigned long com_port, unsigned char c); | ||
67 | #endif | ||
68 | |||
69 | void pause(void) | ||
70 | { | ||
71 | puts("pause\n"); | ||
72 | } | ||
73 | |||
74 | void exit(void) | ||
75 | { | ||
76 | puts("exit\n"); | ||
77 | while(1); | ||
78 | } | ||
79 | |||
80 | int tstc(void) | ||
81 | { | ||
82 | #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \ | ||
83 | || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \ | ||
84 | || defined(CONFIG_SERIAL_MPSC_CONSOLE) \ | ||
85 | || defined(CONFIG_SERIAL_UARTLITE_CONSOLE) | ||
86 | if(keyb_present) | ||
87 | return (CRT_tstc() || serial_tstc(com_port)); | ||
88 | else | ||
89 | return (serial_tstc(com_port)); | ||
90 | #else | ||
91 | return CRT_tstc(); | ||
92 | #endif | ||
93 | } | ||
94 | |||
95 | int getc(void) | ||
96 | { | ||
97 | while (1) { | ||
98 | #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \ | ||
99 | || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \ | ||
100 | || defined(CONFIG_SERIAL_MPSC_CONSOLE) \ | ||
101 | || defined(CONFIG_SERIAL_UARTLITE_CONSOLE) | ||
102 | if (serial_tstc(com_port)) | ||
103 | return (serial_getc(com_port)); | ||
104 | #endif /* serial console */ | ||
105 | if (keyb_present) | ||
106 | if(CRT_tstc()) | ||
107 | return (CRT_getc()); | ||
108 | } | ||
109 | } | ||
110 | |||
111 | void | ||
112 | putc(const char c) | ||
113 | { | ||
114 | int x,y; | ||
115 | |||
116 | #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \ | ||
117 | || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \ | ||
118 | || defined(CONFIG_SERIAL_MPSC_CONSOLE) \ | ||
119 | || defined(CONFIG_SERIAL_UARTLITE_CONSOLE) | ||
120 | serial_putc(com_port, c); | ||
121 | if ( c == '\n' ) | ||
122 | serial_putc(com_port, '\r'); | ||
123 | #endif /* serial console */ | ||
124 | |||
125 | x = orig_x; | ||
126 | y = orig_y; | ||
127 | |||
128 | if ( c == '\n' ) { | ||
129 | x = 0; | ||
130 | if ( ++y >= lines ) { | ||
131 | scroll(); | ||
132 | y--; | ||
133 | } | ||
134 | } else if (c == '\r') { | ||
135 | x = 0; | ||
136 | } else if (c == '\b') { | ||
137 | if (x > 0) { | ||
138 | x--; | ||
139 | } | ||
140 | } else { | ||
141 | vidmem [ ( x + cols * y ) * 2 ] = c; | ||
142 | if ( ++x >= cols ) { | ||
143 | x = 0; | ||
144 | if ( ++y >= lines ) { | ||
145 | scroll(); | ||
146 | y--; | ||
147 | } | ||
148 | } | ||
149 | } | ||
150 | |||
151 | cursor(x, y); | ||
152 | |||
153 | orig_x = x; | ||
154 | orig_y = y; | ||
155 | } | ||
156 | |||
157 | void puts(const char *s) | ||
158 | { | ||
159 | int x,y; | ||
160 | char c; | ||
161 | |||
162 | x = orig_x; | ||
163 | y = orig_y; | ||
164 | |||
165 | while ( ( c = *s++ ) != '\0' ) { | ||
166 | #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \ | ||
167 | || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \ | ||
168 | || defined(CONFIG_SERIAL_MPSC_CONSOLE) \ | ||
169 | || defined(CONFIG_SERIAL_UARTLITE_CONSOLE) | ||
170 | serial_putc(com_port, c); | ||
171 | if ( c == '\n' ) serial_putc(com_port, '\r'); | ||
172 | #endif /* serial console */ | ||
173 | |||
174 | if ( c == '\n' ) { | ||
175 | x = 0; | ||
176 | if ( ++y >= lines ) { | ||
177 | scroll(); | ||
178 | y--; | ||
179 | } | ||
180 | } else if (c == '\b') { | ||
181 | if (x > 0) { | ||
182 | x--; | ||
183 | } | ||
184 | } else { | ||
185 | vidmem [ ( x + cols * y ) * 2 ] = c; | ||
186 | if ( ++x >= cols ) { | ||
187 | x = 0; | ||
188 | if ( ++y >= lines ) { | ||
189 | scroll(); | ||
190 | y--; | ||
191 | } | ||
192 | } | ||
193 | } | ||
194 | } | ||
195 | |||
196 | cursor(x, y); | ||
197 | |||
198 | orig_x = x; | ||
199 | orig_y = y; | ||
200 | } | ||
201 | |||
202 | void error(char *x) | ||
203 | { | ||
204 | puts("\n\n"); | ||
205 | puts(x); | ||
206 | puts("\n\n -- System halted"); | ||
207 | |||
208 | while(1); /* Halt */ | ||
209 | } | ||
210 | |||
211 | static void *zalloc(unsigned size) | ||
212 | { | ||
213 | void *p = avail_ram; | ||
214 | |||
215 | size = (size + 7) & -8; | ||
216 | avail_ram += size; | ||
217 | if (avail_ram > end_avail) { | ||
218 | puts("oops... out of memory\n"); | ||
219 | pause(); | ||
220 | } | ||
221 | return p; | ||
222 | } | ||
223 | |||
224 | #define HEAD_CRC 2 | ||
225 | #define EXTRA_FIELD 4 | ||
226 | #define ORIG_NAME 8 | ||
227 | #define COMMENT 0x10 | ||
228 | #define RESERVED 0xe0 | ||
229 | |||
230 | void gunzip(void *dst, int dstlen, unsigned char *src, int *lenp) | ||
231 | { | ||
232 | z_stream s; | ||
233 | int r, i, flags; | ||
234 | |||
235 | /* skip header */ | ||
236 | i = 10; | ||
237 | flags = src[3]; | ||
238 | if (src[2] != Z_DEFLATED || (flags & RESERVED) != 0) { | ||
239 | puts("bad gzipped data\n"); | ||
240 | exit(); | ||
241 | } | ||
242 | if ((flags & EXTRA_FIELD) != 0) | ||
243 | i = 12 + src[10] + (src[11] << 8); | ||
244 | if ((flags & ORIG_NAME) != 0) | ||
245 | while (src[i++] != 0) | ||
246 | ; | ||
247 | if ((flags & COMMENT) != 0) | ||
248 | while (src[i++] != 0) | ||
249 | ; | ||
250 | if ((flags & HEAD_CRC) != 0) | ||
251 | i += 2; | ||
252 | if (i >= *lenp) { | ||
253 | puts("gunzip: ran out of data in header\n"); | ||
254 | exit(); | ||
255 | } | ||
256 | |||
257 | /* Initialize ourself. */ | ||
258 | s.workspace = zalloc(zlib_inflate_workspacesize()); | ||
259 | r = zlib_inflateInit2(&s, -MAX_WBITS); | ||
260 | if (r != Z_OK) { | ||
261 | puts("zlib_inflateInit2 returned "); puthex(r); puts("\n"); | ||
262 | exit(); | ||
263 | } | ||
264 | s.next_in = src + i; | ||
265 | s.avail_in = *lenp - i; | ||
266 | s.next_out = dst; | ||
267 | s.avail_out = dstlen; | ||
268 | r = zlib_inflate(&s, Z_FINISH); | ||
269 | if (r != Z_OK && r != Z_STREAM_END) { | ||
270 | puts("inflate returned "); puthex(r); puts("\n"); | ||
271 | exit(); | ||
272 | } | ||
273 | *lenp = s.next_out - (unsigned char *) dst; | ||
274 | zlib_inflateEnd(&s); | ||
275 | } | ||
276 | |||
277 | void | ||
278 | puthex(unsigned long val) | ||
279 | { | ||
280 | |||
281 | unsigned char buf[10]; | ||
282 | int i; | ||
283 | for (i = 7; i >= 0; i--) | ||
284 | { | ||
285 | buf[i] = "0123456789ABCDEF"[val & 0x0F]; | ||
286 | val >>= 4; | ||
287 | } | ||
288 | buf[8] = '\0'; | ||
289 | puts(buf); | ||
290 | } | ||
291 | |||
292 | #define FALSE 0 | ||
293 | #define TRUE 1 | ||
294 | |||
295 | void | ||
296 | _printk(char const *fmt, ...) | ||
297 | { | ||
298 | va_list ap; | ||
299 | |||
300 | va_start(ap, fmt); | ||
301 | _vprintk(putc, fmt, ap); | ||
302 | va_end(ap); | ||
303 | return; | ||
304 | } | ||
305 | |||
306 | #define is_digit(c) ((c >= '0') && (c <= '9')) | ||
307 | |||
308 | void | ||
309 | _vprintk(void(*putc)(const char), const char *fmt0, va_list ap) | ||
310 | { | ||
311 | char c, sign, *cp = 0; | ||
312 | int left_prec, right_prec, zero_fill, length = 0, pad, pad_on_right; | ||
313 | char buf[32]; | ||
314 | long val; | ||
315 | while ((c = *fmt0++)) | ||
316 | { | ||
317 | if (c == '%') | ||
318 | { | ||
319 | c = *fmt0++; | ||
320 | left_prec = right_prec = pad_on_right = 0; | ||
321 | if (c == '-') | ||
322 | { | ||
323 | c = *fmt0++; | ||
324 | pad_on_right++; | ||
325 | } | ||
326 | if (c == '0') | ||
327 | { | ||
328 | zero_fill = TRUE; | ||
329 | c = *fmt0++; | ||
330 | } else | ||
331 | { | ||
332 | zero_fill = FALSE; | ||
333 | } | ||
334 | while (is_digit(c)) | ||
335 | { | ||
336 | left_prec = (left_prec * 10) + (c - '0'); | ||
337 | c = *fmt0++; | ||
338 | } | ||
339 | if (c == '.') | ||
340 | { | ||
341 | c = *fmt0++; | ||
342 | zero_fill++; | ||
343 | while (is_digit(c)) | ||
344 | { | ||
345 | right_prec = (right_prec * 10) + (c - '0'); | ||
346 | c = *fmt0++; | ||
347 | } | ||
348 | } else | ||
349 | { | ||
350 | right_prec = left_prec; | ||
351 | } | ||
352 | sign = '\0'; | ||
353 | switch (c) | ||
354 | { | ||
355 | case 'd': | ||
356 | case 'x': | ||
357 | case 'X': | ||
358 | val = va_arg(ap, long); | ||
359 | switch (c) | ||
360 | { | ||
361 | case 'd': | ||
362 | if (val < 0) | ||
363 | { | ||
364 | sign = '-'; | ||
365 | val = -val; | ||
366 | } | ||
367 | length = _cvt(val, buf, 10, "0123456789"); | ||
368 | break; | ||
369 | case 'x': | ||
370 | length = _cvt(val, buf, 16, "0123456789abcdef"); | ||
371 | break; | ||
372 | case 'X': | ||
373 | length = _cvt(val, buf, 16, "0123456789ABCDEF"); | ||
374 | break; | ||
375 | } | ||
376 | cp = buf; | ||
377 | break; | ||
378 | case 's': | ||
379 | cp = va_arg(ap, char *); | ||
380 | length = strlen(cp); | ||
381 | break; | ||
382 | case 'c': | ||
383 | c = va_arg(ap, long /*char*/); | ||
384 | (*putc)(c); | ||
385 | continue; | ||
386 | default: | ||
387 | (*putc)('?'); | ||
388 | } | ||
389 | pad = left_prec - length; | ||
390 | if (sign != '\0') | ||
391 | { | ||
392 | pad--; | ||
393 | } | ||
394 | if (zero_fill) | ||
395 | { | ||
396 | c = '0'; | ||
397 | if (sign != '\0') | ||
398 | { | ||
399 | (*putc)(sign); | ||
400 | sign = '\0'; | ||
401 | } | ||
402 | } else | ||
403 | { | ||
404 | c = ' '; | ||
405 | } | ||
406 | if (!pad_on_right) | ||
407 | { | ||
408 | while (pad-- > 0) | ||
409 | { | ||
410 | (*putc)(c); | ||
411 | } | ||
412 | } | ||
413 | if (sign != '\0') | ||
414 | { | ||
415 | (*putc)(sign); | ||
416 | } | ||
417 | while (length-- > 0) | ||
418 | { | ||
419 | (*putc)(c = *cp++); | ||
420 | if (c == '\n') | ||
421 | { | ||
422 | (*putc)('\r'); | ||
423 | } | ||
424 | } | ||
425 | if (pad_on_right) | ||
426 | { | ||
427 | while (pad-- > 0) | ||
428 | { | ||
429 | (*putc)(c); | ||
430 | } | ||
431 | } | ||
432 | } else | ||
433 | { | ||
434 | (*putc)(c); | ||
435 | if (c == '\n') | ||
436 | { | ||
437 | (*putc)('\r'); | ||
438 | } | ||
439 | } | ||
440 | } | ||
441 | } | ||
442 | |||
443 | int | ||
444 | _cvt(unsigned long val, char *buf, long radix, char *digits) | ||
445 | { | ||
446 | char temp[80]; | ||
447 | char *cp = temp; | ||
448 | int length = 0; | ||
449 | if (val == 0) | ||
450 | { /* Special case */ | ||
451 | *cp++ = '0'; | ||
452 | } else | ||
453 | while (val) | ||
454 | { | ||
455 | *cp++ = digits[val % radix]; | ||
456 | val /= radix; | ||
457 | } | ||
458 | while (cp != temp) | ||
459 | { | ||
460 | *buf++ = *--cp; | ||
461 | length++; | ||
462 | } | ||
463 | *buf = '\0'; | ||
464 | return (length); | ||
465 | } | ||
466 | |||
467 | void | ||
468 | _dump_buf_with_offset(unsigned char *p, int s, unsigned char *base) | ||
469 | { | ||
470 | int i, c; | ||
471 | if ((unsigned int)s > (unsigned int)p) | ||
472 | { | ||
473 | s = (unsigned int)s - (unsigned int)p; | ||
474 | } | ||
475 | while (s > 0) | ||
476 | { | ||
477 | if (base) | ||
478 | { | ||
479 | _printk("%06X: ", (int)p - (int)base); | ||
480 | } else | ||
481 | { | ||
482 | _printk("%06X: ", p); | ||
483 | } | ||
484 | for (i = 0; i < 16; i++) | ||
485 | { | ||
486 | if (i < s) | ||
487 | { | ||
488 | _printk("%02X", p[i] & 0xFF); | ||
489 | } else | ||
490 | { | ||
491 | _printk(" "); | ||
492 | } | ||
493 | if ((i % 2) == 1) _printk(" "); | ||
494 | if ((i % 8) == 7) _printk(" "); | ||
495 | } | ||
496 | _printk(" |"); | ||
497 | for (i = 0; i < 16; i++) | ||
498 | { | ||
499 | if (i < s) | ||
500 | { | ||
501 | c = p[i] & 0xFF; | ||
502 | if ((c < 0x20) || (c >= 0x7F)) c = '.'; | ||
503 | } else | ||
504 | { | ||
505 | c = ' '; | ||
506 | } | ||
507 | _printk("%c", c); | ||
508 | } | ||
509 | _printk("|\n"); | ||
510 | s -= 16; | ||
511 | p += 16; | ||
512 | } | ||
513 | } | ||
514 | |||
515 | void | ||
516 | _dump_buf(unsigned char *p, int s) | ||
517 | { | ||
518 | _printk("\n"); | ||
519 | _dump_buf_with_offset(p, s, 0); | ||
520 | } | ||
521 | |||
522 | /* Very simple inb/outb routines. We declare ISA_io to be 0 above, and | ||
523 | * then modify it on platforms which need to. We do it like this | ||
524 | * because on some platforms we give inb/outb an exact location, and | ||
525 | * on others it's an offset from a given location. -- Tom | ||
526 | */ | ||
527 | |||
528 | void ISA_init(unsigned long base) | ||
529 | { | ||
530 | ISA_io = (unsigned char *)base; | ||
531 | } | ||
532 | |||
533 | void | ||
534 | outb(int port, unsigned char val) | ||
535 | { | ||
536 | /* Ensure I/O operations complete */ | ||
537 | __asm__ volatile("eieio"); | ||
538 | ISA_io[port] = val; | ||
539 | } | ||
540 | |||
541 | unsigned char | ||
542 | inb(int port) | ||
543 | { | ||
544 | /* Ensure I/O operations complete */ | ||
545 | __asm__ volatile("eieio"); | ||
546 | return (ISA_io[port]); | ||
547 | } | ||
548 | |||
549 | /* | ||
550 | * Local variables: | ||
551 | * c-indent-level: 8 | ||
552 | * c-basic-offset: 8 | ||
553 | * tab-width: 8 | ||
554 | * End: | ||
555 | */ | ||