ARM: Merge next-samsung-s3c2443-clock
[linux-2.6.git] / arch / arm / boot / compressed / misc.c
1 /*
2  * misc.c
3  * 
4  * This is a collection of several routines from gzip-1.0.3 
5  * adapted for Linux.
6  *
7  * malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994
8  *
9  * Modified for ARM Linux by Russell King
10  *
11  * Nicolas Pitre <nico@visuaide.com>  1999/04/14 :
12  *  For this code to run directly from Flash, all constant variables must
13  *  be marked with 'const' and all other variables initialized at run-time 
14  *  only.  This way all non constant variables will end up in the bss segment,
15  *  which should point to addresses in RAM and cleared to 0 on start.
16  *  This allows for a much quicker boot time.
17  */
18
19 unsigned int __machine_arch_type;
20
21 #define _LINUX_STRING_H_
22
23 #include <linux/compiler.h>     /* for inline */
24 #include <linux/types.h>        /* for size_t */
25 #include <linux/stddef.h>       /* for NULL */
26 #include <asm/string.h>
27 #include <linux/linkage.h>
28
29 #include <asm/unaligned.h>
30
31 #ifdef STANDALONE_DEBUG
32 #define putstr printf
33 #else
34
35 static void putstr(const char *ptr);
36
37 #include <mach/uncompress.h>
38
39 #ifdef CONFIG_DEBUG_ICEDCC
40
41 #ifdef CONFIG_CPU_V6
42
43 static void icedcc_putc(int ch)
44 {
45         int status, i = 0x4000000;
46
47         do {
48                 if (--i < 0)
49                         return;
50
51                 asm volatile ("mrc p14, 0, %0, c0, c1, 0" : "=r" (status));
52         } while (status & (1 << 29));
53
54         asm("mcr p14, 0, %0, c0, c5, 0" : : "r" (ch));
55 }
56 #elif defined(CONFIG_CPU_XSCALE)
57
58 static void icedcc_putc(int ch)
59 {
60         int status, i = 0x4000000;
61
62         do {
63                 if (--i < 0)
64                         return;
65
66                 asm volatile ("mrc p14, 0, %0, c14, c0, 0" : "=r" (status));
67         } while (status & (1 << 28));
68
69         asm("mcr p14, 0, %0, c8, c0, 0" : : "r" (ch));
70 }
71
72 #else
73
74 static void icedcc_putc(int ch)
75 {
76         int status, i = 0x4000000;
77
78         do {
79                 if (--i < 0)
80                         return;
81
82                 asm volatile ("mrc p14, 0, %0, c0, c0, 0" : "=r" (status));
83         } while (status & 2);
84
85         asm("mcr p14, 0, %0, c1, c0, 0" : : "r" (ch));
86 }
87
88 #endif
89
90 #define putc(ch)        icedcc_putc(ch)
91 #define flush() do { } while (0)
92 #endif
93
94 static void putstr(const char *ptr)
95 {
96         char c;
97
98         while ((c = *ptr++) != '\0') {
99                 if (c == '\n')
100                         putc('\r');
101                 putc(c);
102         }
103
104         flush();
105 }
106
107 #endif
108
109 #define __ptr_t void *
110
111 #define memzero(s,n) __memzero(s,n)
112
113 /*
114  * Optimised C version of memzero for the ARM.
115  */
116 void __memzero (__ptr_t s, size_t n)
117 {
118         union { void *vp; unsigned long *ulp; unsigned char *ucp; } u;
119         int i;
120
121         u.vp = s;
122
123         for (i = n >> 5; i > 0; i--) {
124                 *u.ulp++ = 0;
125                 *u.ulp++ = 0;
126                 *u.ulp++ = 0;
127                 *u.ulp++ = 0;
128                 *u.ulp++ = 0;
129                 *u.ulp++ = 0;
130                 *u.ulp++ = 0;
131                 *u.ulp++ = 0;
132         }
133
134         if (n & 1 << 4) {
135                 *u.ulp++ = 0;
136                 *u.ulp++ = 0;
137                 *u.ulp++ = 0;
138                 *u.ulp++ = 0;
139         }
140
141         if (n & 1 << 3) {
142                 *u.ulp++ = 0;
143                 *u.ulp++ = 0;
144         }
145
146         if (n & 1 << 2)
147                 *u.ulp++ = 0;
148
149         if (n & 1 << 1) {
150                 *u.ucp++ = 0;
151                 *u.ucp++ = 0;
152         }
153
154         if (n & 1)
155                 *u.ucp++ = 0;
156 }
157
158 static inline __ptr_t memcpy(__ptr_t __dest, __const __ptr_t __src,
159                             size_t __n)
160 {
161         int i = 0;
162         unsigned char *d = (unsigned char *)__dest, *s = (unsigned char *)__src;
163
164         for (i = __n >> 3; i > 0; i--) {
165                 *d++ = *s++;
166                 *d++ = *s++;
167                 *d++ = *s++;
168                 *d++ = *s++;
169                 *d++ = *s++;
170                 *d++ = *s++;
171                 *d++ = *s++;
172                 *d++ = *s++;
173         }
174
175         if (__n & 1 << 2) {
176                 *d++ = *s++;
177                 *d++ = *s++;
178                 *d++ = *s++;
179                 *d++ = *s++;
180         }
181
182         if (__n & 1 << 1) {
183                 *d++ = *s++;
184                 *d++ = *s++;
185         }
186
187         if (__n & 1)
188                 *d++ = *s++;
189
190         return __dest;
191 }
192
193 /*
194  * gzip delarations
195  */
196 #define STATIC static
197
198 /* Diagnostic functions */
199 #ifdef DEBUG
200 #  define Assert(cond,msg) {if(!(cond)) error(msg);}
201 #  define Trace(x) fprintf x
202 #  define Tracev(x) {if (verbose) fprintf x ;}
203 #  define Tracevv(x) {if (verbose>1) fprintf x ;}
204 #  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
205 #  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
206 #else
207 #  define Assert(cond,msg)
208 #  define Trace(x)
209 #  define Tracev(x)
210 #  define Tracevv(x)
211 #  define Tracec(c,x)
212 #  define Tracecv(c,x)
213 #endif
214
215 static void error(char *m);
216
217 extern char input_data[];
218 extern char input_data_end[];
219
220 static unsigned char *output_data;
221 static unsigned long output_ptr;
222
223 static void error(char *m);
224
225 static void putstr(const char *);
226
227 static unsigned long free_mem_ptr;
228 static unsigned long free_mem_end_ptr;
229
230 #ifdef STANDALONE_DEBUG
231 #define NO_INFLATE_MALLOC
232 #endif
233
234 #define ARCH_HAS_DECOMP_WDOG
235
236 #ifdef CONFIG_KERNEL_GZIP
237 #include "../../../../lib/decompress_inflate.c"
238 #endif
239
240 #ifdef CONFIG_KERNEL_LZO
241 #include "../../../../lib/decompress_unlzo.c"
242 #endif
243
244 #ifndef arch_error
245 #define arch_error(x)
246 #endif
247
248 static void error(char *x)
249 {
250         arch_error(x);
251
252         putstr("\n\n");
253         putstr(x);
254         putstr("\n\n -- System halted");
255
256         while(1);       /* Halt */
257 }
258
259 asmlinkage void __div0(void)
260 {
261         error("Attempting division by 0!");
262 }
263
264 #ifndef STANDALONE_DEBUG
265
266 unsigned long
267 decompress_kernel(unsigned long output_start, unsigned long free_mem_ptr_p,
268                 unsigned long free_mem_ptr_end_p,
269                 int arch_id)
270 {
271         unsigned char *tmp;
272
273         output_data             = (unsigned char *)output_start;
274         free_mem_ptr            = free_mem_ptr_p;
275         free_mem_end_ptr        = free_mem_ptr_end_p;
276         __machine_arch_type     = arch_id;
277
278         arch_decomp_setup();
279
280         tmp = (unsigned char *) (((unsigned long)input_data_end) - 4);
281         output_ptr = get_unaligned_le32(tmp);
282
283         putstr("Uncompressing Linux...");
284         decompress(input_data, input_data_end - input_data,
285                         NULL, NULL, output_data, NULL, error);
286         putstr(" done, booting the kernel.\n");
287         return output_ptr;
288 }
289 #else
290
291 char output_buffer[1500*1024];
292
293 int main()
294 {
295         output_data = output_buffer;
296
297         putstr("Uncompressing Linux...");
298         decompress(input_data, input_data_end - input_data,
299                         NULL, NULL, output_data, NULL, error);
300         putstr("done.\n");
301         return 0;
302 }
303 #endif