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