]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * arch/alpha/boot/bootpz.c | |
3 | * | |
4 | * Copyright (C) 1997 Jay Estabrook | |
5 | * | |
6 | * This file is used for creating a compressed BOOTP file for the | |
7 | * Linux/AXP kernel | |
8 | * | |
9 | * based significantly on the arch/alpha/boot/main.c of Linus Torvalds | |
10 | * and the decompression code from MILO. | |
11 | */ | |
12 | #include <linux/kernel.h> | |
5a0e3ad6 | 13 | #include <linux/slab.h> |
1da177e4 | 14 | #include <linux/string.h> |
273b281f | 15 | #include <generated/utsrelease.h> |
1da177e4 LT |
16 | #include <linux/mm.h> |
17 | ||
1da177e4 LT |
18 | #include <asm/console.h> |
19 | #include <asm/hwrpb.h> | |
20 | #include <asm/pgtable.h> | |
21 | #include <asm/io.h> | |
22 | ||
23 | #include <stdarg.h> | |
24 | ||
25 | #include "kzsize.h" | |
26 | ||
27 | /* FIXME FIXME FIXME */ | |
28 | #define MALLOC_AREA_SIZE 0x200000 /* 2MB for now */ | |
29 | /* FIXME FIXME FIXME */ | |
30 | ||
31 | ||
32 | /* | |
33 | WARNING NOTE | |
34 | ||
35 | It is very possible that turning on additional messages may cause | |
36 | kernel image corruption due to stack usage to do the printing. | |
37 | ||
38 | */ | |
39 | ||
40 | #undef DEBUG_CHECK_RANGE | |
41 | #undef DEBUG_ADDRESSES | |
42 | #undef DEBUG_LAST_STEPS | |
43 | ||
44 | extern unsigned long switch_to_osf_pal(unsigned long nr, | |
45 | struct pcb_struct * pcb_va, struct pcb_struct * pcb_pa, | |
46 | unsigned long *vptb); | |
47 | ||
48 | extern int decompress_kernel(void* destination, void *source, | |
49 | size_t ksize, size_t kzsize); | |
50 | ||
51 | extern void move_stack(unsigned long new_stack); | |
52 | ||
53 | struct hwrpb_struct *hwrpb = INIT_HWRPB; | |
54 | static struct pcb_struct pcb_va[1]; | |
55 | ||
56 | /* | |
57 | * Find a physical address of a virtual object.. | |
58 | * | |
59 | * This is easy using the virtual page table address. | |
60 | */ | |
61 | #define VPTB ((unsigned long *) 0x200000000) | |
62 | ||
63 | static inline unsigned long | |
64 | find_pa(unsigned long address) | |
65 | { | |
66 | unsigned long result; | |
67 | ||
68 | result = VPTB[address >> 13]; | |
69 | result >>= 32; | |
70 | result <<= 13; | |
71 | result |= address & 0x1fff; | |
72 | return result; | |
73 | } | |
74 | ||
75 | int | |
76 | check_range(unsigned long vstart, unsigned long vend, | |
77 | unsigned long kstart, unsigned long kend) | |
78 | { | |
79 | unsigned long vaddr, kaddr; | |
80 | ||
81 | #ifdef DEBUG_CHECK_RANGE | |
82 | srm_printk("check_range: V[0x%lx:0x%lx] K[0x%lx:0x%lx]\n", | |
83 | vstart, vend, kstart, kend); | |
84 | #endif | |
85 | /* do some range checking for detecting an overlap... */ | |
86 | for (vaddr = vstart; vaddr <= vend; vaddr += PAGE_SIZE) | |
87 | { | |
88 | kaddr = (find_pa(vaddr) | PAGE_OFFSET); | |
89 | if (kaddr >= kstart && kaddr <= kend) | |
90 | { | |
91 | #ifdef DEBUG_CHECK_RANGE | |
92 | srm_printk("OVERLAP: vaddr 0x%lx kaddr 0x%lx" | |
93 | " [0x%lx:0x%lx]\n", | |
94 | vaddr, kaddr, kstart, kend); | |
95 | #endif | |
96 | return 1; | |
97 | } | |
98 | } | |
99 | return 0; | |
100 | } | |
101 | ||
102 | /* | |
103 | * This function moves into OSF/1 pal-code, and has a temporary | |
104 | * PCB for that. The kernel proper should replace this PCB with | |
105 | * the real one as soon as possible. | |
106 | * | |
107 | * The page table muckery in here depends on the fact that the boot | |
108 | * code has the L1 page table identity-map itself in the second PTE | |
109 | * in the L1 page table. Thus the L1-page is virtually addressable | |
110 | * itself (through three levels) at virtual address 0x200802000. | |
111 | */ | |
112 | ||
113 | #define L1 ((unsigned long *) 0x200802000) | |
114 | ||
115 | void | |
116 | pal_init(void) | |
117 | { | |
118 | unsigned long i, rev; | |
119 | struct percpu_struct * percpu; | |
120 | struct pcb_struct * pcb_pa; | |
121 | ||
122 | /* Create the dummy PCB. */ | |
123 | pcb_va->ksp = 0; | |
124 | pcb_va->usp = 0; | |
125 | pcb_va->ptbr = L1[1] >> 32; | |
126 | pcb_va->asn = 0; | |
127 | pcb_va->pcc = 0; | |
128 | pcb_va->unique = 0; | |
129 | pcb_va->flags = 1; | |
130 | pcb_va->res1 = 0; | |
131 | pcb_va->res2 = 0; | |
132 | pcb_pa = (struct pcb_struct *)find_pa((unsigned long)pcb_va); | |
133 | ||
134 | /* | |
135 | * a0 = 2 (OSF) | |
136 | * a1 = return address, but we give the asm the vaddr of the PCB | |
137 | * a2 = physical addr of PCB | |
138 | * a3 = new virtual page table pointer | |
139 | * a4 = KSP (but the asm sets it) | |
140 | */ | |
141 | srm_printk("Switching to OSF PAL-code... "); | |
142 | ||
143 | i = switch_to_osf_pal(2, pcb_va, pcb_pa, VPTB); | |
144 | if (i) { | |
145 | srm_printk("failed, code %ld\n", i); | |
146 | __halt(); | |
147 | } | |
148 | ||
149 | percpu = (struct percpu_struct *) | |
150 | (INIT_HWRPB->processor_offset + (unsigned long) INIT_HWRPB); | |
151 | rev = percpu->pal_revision = percpu->palcode_avail[2]; | |
152 | ||
153 | srm_printk("OK (rev %lx)\n", rev); | |
154 | ||
155 | tbia(); /* do it directly in case we are SMP */ | |
156 | } | |
157 | ||
158 | /* | |
159 | * Start the kernel. | |
160 | */ | |
161 | static inline void | |
162 | runkernel(void) | |
163 | { | |
164 | __asm__ __volatile__( | |
165 | "bis %0,%0,$27\n\t" | |
166 | "jmp ($27)" | |
167 | : /* no outputs: it doesn't even return */ | |
168 | : "r" (START_ADDR)); | |
169 | } | |
170 | ||
171 | /* Must record the SP (it is virtual) on entry, so we can make sure | |
172 | not to overwrite it during movement or decompression. */ | |
173 | unsigned long SP_on_entry; | |
174 | ||
175 | /* Calculate the kernel image address based on the end of the BOOTP | |
176 | bootstrapper (ie this program). | |
177 | */ | |
178 | extern char _end; | |
179 | #define KERNEL_ORIGIN \ | |
180 | ((((unsigned long)&_end) + 511) & ~511) | |
181 | ||
182 | /* Round address to next higher page boundary. */ | |
183 | #define NEXT_PAGE(a) (((a) | (PAGE_SIZE - 1)) + 1) | |
184 | ||
185 | #ifdef INITRD_IMAGE_SIZE | |
186 | # define REAL_INITRD_SIZE INITRD_IMAGE_SIZE | |
187 | #else | |
188 | # define REAL_INITRD_SIZE 0 | |
189 | #endif | |
190 | ||
191 | /* Defines from include/asm-alpha/system.h | |
192 | ||
193 | BOOT_ADDR Virtual address at which the consoles loads | |
194 | the BOOTP image. | |
195 | ||
196 | KERNEL_START KSEG address at which the kernel is built to run, | |
197 | which includes some initial data pages before the | |
198 | code. | |
199 | ||
200 | START_ADDR KSEG address of the entry point of kernel code. | |
201 | ||
202 | ZERO_PGE KSEG address of page full of zeroes, but | |
203 | upon entry to kerne cvan be expected | |
204 | to hold the parameter list and possible | |
205 | INTRD information. | |
206 | ||
207 | These are used in the local defines below. | |
208 | */ | |
209 | ||
210 | ||
211 | /* Virtual addresses for the BOOTP image. Note that this includes the | |
212 | bootstrapper code as well as the compressed kernel image, and | |
213 | possibly the INITRD image. | |
214 | ||
215 | Oh, and do NOT forget the STACK, which appears to be placed virtually | |
216 | beyond the end of the loaded image. | |
217 | */ | |
218 | #define V_BOOT_IMAGE_START BOOT_ADDR | |
219 | #define V_BOOT_IMAGE_END SP_on_entry | |
220 | ||
221 | /* Virtual addresses for just the bootstrapper part of the BOOTP image. */ | |
222 | #define V_BOOTSTRAPPER_START BOOT_ADDR | |
223 | #define V_BOOTSTRAPPER_END KERNEL_ORIGIN | |
224 | ||
225 | /* Virtual addresses for just the data part of the BOOTP | |
226 | image. This may also include the INITRD image, but always | |
227 | includes the STACK. | |
228 | */ | |
229 | #define V_DATA_START KERNEL_ORIGIN | |
230 | #define V_INITRD_START (KERNEL_ORIGIN + KERNEL_Z_SIZE) | |
231 | #define V_INTRD_END (V_INITRD_START + REAL_INITRD_SIZE) | |
232 | #define V_DATA_END V_BOOT_IMAGE_END | |
233 | ||
234 | /* KSEG addresses for the uncompressed kernel. | |
235 | ||
236 | Note that the end address includes workspace for the decompression. | |
237 | Note also that the DATA_START address is ZERO_PGE, to which we write | |
238 | just before jumping to the kernel image at START_ADDR. | |
239 | */ | |
240 | #define K_KERNEL_DATA_START ZERO_PGE | |
241 | #define K_KERNEL_IMAGE_START START_ADDR | |
242 | #define K_KERNEL_IMAGE_END (START_ADDR + KERNEL_SIZE) | |
243 | ||
244 | /* Define to where we may have to decompress the kernel image, before | |
245 | we move it to the final position, in case of overlap. This will be | |
246 | above the final position of the kernel. | |
247 | ||
248 | Regardless of overlap, we move the INITRD image to the end of this | |
249 | copy area, because there needs to be a buffer area after the kernel | |
250 | for "bootmem" anyway. | |
251 | */ | |
252 | #define K_COPY_IMAGE_START NEXT_PAGE(K_KERNEL_IMAGE_END) | |
253 | /* Reserve one page below INITRD for the new stack. */ | |
254 | #define K_INITRD_START \ | |
255 | NEXT_PAGE(K_COPY_IMAGE_START + KERNEL_SIZE + PAGE_SIZE) | |
256 | #define K_COPY_IMAGE_END \ | |
257 | (K_INITRD_START + REAL_INITRD_SIZE + MALLOC_AREA_SIZE) | |
258 | #define K_COPY_IMAGE_SIZE \ | |
259 | NEXT_PAGE(K_COPY_IMAGE_END - K_COPY_IMAGE_START) | |
260 | ||
261 | void | |
262 | start_kernel(void) | |
263 | { | |
264 | int must_move = 0; | |
265 | ||
266 | /* Initialize these for the decompression-in-place situation, | |
267 | which is the smallest amount of work and most likely to | |
268 | occur when using the normal START_ADDR of the kernel | |
269 | (currently set to 16MB, to clear all console code. | |
270 | */ | |
271 | unsigned long uncompressed_image_start = K_KERNEL_IMAGE_START; | |
272 | unsigned long uncompressed_image_end = K_KERNEL_IMAGE_END; | |
273 | ||
274 | unsigned long initrd_image_start = K_INITRD_START; | |
275 | ||
276 | /* | |
277 | * Note that this crufty stuff with static and envval | |
278 | * and envbuf is because: | |
279 | * | |
280 | * 1. Frequently, the stack is short, and we don't want to overrun; | |
281 | * 2. Frequently the stack is where we are going to copy the kernel to; | |
282 | * 3. A certain SRM console required the GET_ENV output to stack. | |
283 | * ??? A comment in the aboot sources indicates that the GET_ENV | |
284 | * destination must be quadword aligned. Might this explain the | |
285 | * behaviour, rather than requiring output to the stack, which | |
286 | * seems rather far-fetched. | |
287 | */ | |
288 | static long nbytes; | |
289 | static char envval[256] __attribute__((aligned(8))); | |
290 | register unsigned long asm_sp asm("30"); | |
291 | ||
292 | SP_on_entry = asm_sp; | |
293 | ||
294 | srm_printk("Linux/Alpha BOOTPZ Loader for Linux " UTS_RELEASE "\n"); | |
295 | ||
296 | /* Validity check the HWRPB. */ | |
297 | if (INIT_HWRPB->pagesize != 8192) { | |
298 | srm_printk("Expected 8kB pages, got %ldkB\n", | |
299 | INIT_HWRPB->pagesize >> 10); | |
300 | return; | |
301 | } | |
302 | if (INIT_HWRPB->vptb != (unsigned long) VPTB) { | |
303 | srm_printk("Expected vptb at %p, got %p\n", | |
304 | VPTB, (void *)INIT_HWRPB->vptb); | |
305 | return; | |
306 | } | |
307 | ||
308 | /* PALcode (re)initialization. */ | |
309 | pal_init(); | |
310 | ||
311 | /* Get the parameter list from the console environment variable. */ | |
312 | nbytes = callback_getenv(ENV_BOOTED_OSFLAGS, envval, sizeof(envval)); | |
313 | if (nbytes < 0 || nbytes >= sizeof(envval)) { | |
314 | nbytes = 0; | |
315 | } | |
316 | envval[nbytes] = '\0'; | |
317 | ||
318 | #ifdef DEBUG_ADDRESSES | |
319 | srm_printk("START_ADDR 0x%lx\n", START_ADDR); | |
320 | srm_printk("KERNEL_ORIGIN 0x%lx\n", KERNEL_ORIGIN); | |
321 | srm_printk("KERNEL_SIZE 0x%x\n", KERNEL_SIZE); | |
322 | srm_printk("KERNEL_Z_SIZE 0x%x\n", KERNEL_Z_SIZE); | |
323 | #endif | |
324 | ||
325 | /* Since all the SRM consoles load the BOOTP image at virtual | |
326 | * 0x20000000, we have to ensure that the physical memory | |
327 | * pages occupied by that image do NOT overlap the physical | |
328 | * address range where the kernel wants to be run. This | |
329 | * causes real problems when attempting to cdecompress the | |
330 | * former into the latter... :-( | |
331 | * | |
332 | * So, we may have to decompress/move the kernel/INITRD image | |
333 | * virtual-to-physical someplace else first before moving | |
334 | * kernel /INITRD to their final resting places... ;-} | |
335 | * | |
336 | * Sigh... | |
337 | */ | |
338 | ||
339 | /* First, check to see if the range of addresses occupied by | |
340 | the bootstrapper part of the BOOTP image include any of the | |
341 | physical pages into which the kernel will be placed for | |
342 | execution. | |
343 | ||
344 | We only need check on the final kernel image range, since we | |
345 | will put the INITRD someplace that we can be sure is not | |
346 | in conflict. | |
347 | */ | |
348 | if (check_range(V_BOOTSTRAPPER_START, V_BOOTSTRAPPER_END, | |
349 | K_KERNEL_DATA_START, K_KERNEL_IMAGE_END)) | |
350 | { | |
351 | srm_printk("FATAL ERROR: overlap of bootstrapper code\n"); | |
352 | __halt(); | |
353 | } | |
354 | ||
355 | /* Next, check to see if the range of addresses occupied by | |
356 | the compressed kernel/INITRD/stack portion of the BOOTP | |
357 | image include any of the physical pages into which the | |
358 | decompressed kernel or the INITRD will be placed for | |
359 | execution. | |
360 | */ | |
361 | if (check_range(V_DATA_START, V_DATA_END, | |
362 | K_KERNEL_IMAGE_START, K_COPY_IMAGE_END)) | |
363 | { | |
364 | #ifdef DEBUG_ADDRESSES | |
365 | srm_printk("OVERLAP: cannot decompress in place\n"); | |
366 | #endif | |
367 | uncompressed_image_start = K_COPY_IMAGE_START; | |
368 | uncompressed_image_end = K_COPY_IMAGE_END; | |
369 | must_move = 1; | |
370 | ||
371 | /* Finally, check to see if the range of addresses | |
372 | occupied by the compressed kernel/INITRD part of | |
373 | the BOOTP image include any of the physical pages | |
374 | into which that part is to be copied for | |
375 | decompression. | |
376 | */ | |
377 | while (check_range(V_DATA_START, V_DATA_END, | |
378 | uncompressed_image_start, | |
379 | uncompressed_image_end)) | |
380 | { | |
381 | #if 0 | |
382 | uncompressed_image_start += K_COPY_IMAGE_SIZE; | |
383 | uncompressed_image_end += K_COPY_IMAGE_SIZE; | |
384 | initrd_image_start += K_COPY_IMAGE_SIZE; | |
385 | #else | |
386 | /* Keep as close as possible to end of BOOTP image. */ | |
387 | uncompressed_image_start += PAGE_SIZE; | |
388 | uncompressed_image_end += PAGE_SIZE; | |
389 | initrd_image_start += PAGE_SIZE; | |
390 | #endif | |
391 | } | |
392 | } | |
393 | ||
394 | srm_printk("Starting to load the kernel with args '%s'\n", envval); | |
395 | ||
396 | #ifdef DEBUG_ADDRESSES | |
397 | srm_printk("Decompressing the kernel...\n" | |
398 | "...from 0x%lx to 0x%lx size 0x%x\n", | |
399 | V_DATA_START, | |
400 | uncompressed_image_start, | |
401 | KERNEL_SIZE); | |
402 | #endif | |
403 | decompress_kernel((void *)uncompressed_image_start, | |
404 | (void *)V_DATA_START, | |
405 | KERNEL_SIZE, KERNEL_Z_SIZE); | |
406 | ||
407 | /* | |
408 | * Now, move things to their final positions, if/as required. | |
409 | */ | |
410 | ||
411 | #ifdef INITRD_IMAGE_SIZE | |
412 | ||
413 | /* First, we always move the INITRD image, if present. */ | |
414 | #ifdef DEBUG_ADDRESSES | |
415 | srm_printk("Moving the INITRD image...\n" | |
416 | " from 0x%lx to 0x%lx size 0x%x\n", | |
417 | V_INITRD_START, | |
418 | initrd_image_start, | |
419 | INITRD_IMAGE_SIZE); | |
420 | #endif | |
421 | memcpy((void *)initrd_image_start, (void *)V_INITRD_START, | |
422 | INITRD_IMAGE_SIZE); | |
423 | ||
424 | #endif /* INITRD_IMAGE_SIZE */ | |
425 | ||
426 | /* Next, we may have to move the uncompressed kernel to the | |
427 | final destination. | |
428 | */ | |
429 | if (must_move) { | |
430 | #ifdef DEBUG_ADDRESSES | |
431 | srm_printk("Moving the uncompressed kernel...\n" | |
432 | "...from 0x%lx to 0x%lx size 0x%x\n", | |
433 | uncompressed_image_start, | |
434 | K_KERNEL_IMAGE_START, | |
435 | (unsigned)KERNEL_SIZE); | |
436 | #endif | |
437 | /* | |
438 | * Move the stack to a safe place to ensure it won't be | |
439 | * overwritten by kernel image. | |
440 | */ | |
441 | move_stack(initrd_image_start - PAGE_SIZE); | |
442 | ||
443 | memcpy((void *)K_KERNEL_IMAGE_START, | |
444 | (void *)uncompressed_image_start, KERNEL_SIZE); | |
445 | } | |
446 | ||
447 | /* Clear the zero page, then move the argument list in. */ | |
448 | #ifdef DEBUG_LAST_STEPS | |
449 | srm_printk("Preparing ZERO_PGE...\n"); | |
450 | #endif | |
451 | memset((char*)ZERO_PGE, 0, PAGE_SIZE); | |
452 | strcpy((char*)ZERO_PGE, envval); | |
453 | ||
454 | #ifdef INITRD_IMAGE_SIZE | |
455 | ||
456 | #ifdef DEBUG_LAST_STEPS | |
457 | srm_printk("Preparing INITRD info...\n"); | |
458 | #endif | |
459 | /* Finally, set the INITRD paramenters for the kernel. */ | |
460 | ((long *)(ZERO_PGE+256))[0] = initrd_image_start; | |
461 | ((long *)(ZERO_PGE+256))[1] = INITRD_IMAGE_SIZE; | |
462 | ||
463 | #endif /* INITRD_IMAGE_SIZE */ | |
464 | ||
465 | #ifdef DEBUG_LAST_STEPS | |
466 | srm_printk("Doing 'runkernel()'...\n"); | |
467 | #endif | |
468 | runkernel(); | |
469 | } | |
eb2bce7f IK |
470 | |
471 | /* dummy function, should never be called. */ | |
472 | void *__kmalloc(size_t size, gfp_t flags) | |
473 | { | |
474 | return (void *)NULL; | |
475 | } |