arch/x86/boot/compressed/head_32.S

   1 /*
   2  *  linux/boot/head.S
   3  *
   4  *  Copyright (C) 1991, 1992, 1993  Linus Torvalds
   5  */
   6
   7 /*
   8  *  head.S contains the 32-bit startup code.
   9  *
  10  * NOTE!!! Startup happens at absolute address 0x00001000, which is also where
  11  * the page directory will exist. The startup code will be overwritten by
  12  * the page directory. [According to comments etc elsewhere on a compressed
  13  * kernel it will end up at 0x1000 + 1Mb I hope so as I assume this. - AC]
  14  *
  15  * Page 0 is deliberately kept safe, since System Management Mode code in
  16  * laptops may need to access the BIOS data stored there.  This is also
  17  * useful for future device drivers that either access the BIOS via VM86
  18  * mode.
  19  */
  20
  21 /*
  22  * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
  23  */
  24         .text
  25
  26 #include <linux/linkage.h>
  27 #include <asm/segment.h>
  28 #include <asm/page_types.h>
  29 #include <asm/boot.h>
  30 #include <asm/asm-offsets.h>
  31
  32         .section ".text.head","ax",@progbits
  33 ENTRY(startup_32)
  34         cld
  35         /*
  36          * Test KEEP_SEGMENTS flag to see if the bootloader is asking
  37          * us to not reload segments
  38          */
  39         testb   $(1<<6), BP_loadflags(%esi)
  40         jnz     1f
  41
  42         cli
  43         movl    $__BOOT_DS, %eax
  44         movl    %eax, %ds
  45         movl    %eax, %es
  46         movl    %eax, %fs
  47         movl    %eax, %gs
  48         movl    %eax, %ss
  49 1:
  50
  51 /*
  52  * Calculate the delta between where we were compiled to run
  53  * at and where we were actually loaded at.  This can only be done
  54  * with a short local call on x86.  Nothing  else will tell us what
  55  * address we are running at.  The reserved chunk of the real-mode
  56  * data at 0x1e4 (defined as a scratch field) are used as the stack
  57  * for this calculation. Only 4 bytes are needed.
  58  */
  59         leal    (BP_scratch+4)(%esi), %esp
  60         call    1f
  61 1:      popl    %ebp
  62         subl    $1b, %ebp
  63
  64 /*
  65  * %ebp contains the address we are loaded at by the boot loader and %ebx
  66  * contains the address where we should move the kernel image temporarily
  67  * for safe in-place decompression.
  68  */
  69
  70 #ifdef CONFIG_RELOCATABLE
  71         movl    %ebp, %ebx
  72         addl    $(CONFIG_PHYSICAL_ALIGN - 1), %ebx
  73         andl    $(~(CONFIG_PHYSICAL_ALIGN - 1)), %ebx
  74 #else
  75         movl    $LOAD_PHYSICAL_ADDR, %ebx
  76 #endif
  77
  78         /* Replace the compressed data size with the uncompressed size */
  79         subl    input_len(%ebp), %ebx
  80         movl    output_len(%ebp), %eax
  81         addl    %eax, %ebx
  82         /* Add 8 bytes for every 32K input block */
  83         shrl    $12, %eax
  84         addl    %eax, %ebx
  85         /* Add 32K + 18 bytes of extra slack */
  86         addl    $(32768 + 18), %ebx
  87         /* Align on a 4K boundary */
  88         addl    $4095, %ebx
  89         andl    $~4095, %ebx
  90
  91         /* Set up the stack */
  92         leal    boot_stack_end(%ebx), %esp
  93
  94         /* Zero EFLAGS */
  95         pushl   $0
  96         popfl
  97
  98 /*
  99  * Copy the compressed kernel to the end of our buffer
 100  * where decompression in place becomes safe.
 101  */
 102         pushl   %esi
 103         leal    (_bss-4)(%ebp), %esi
 104         leal    (_bss-4)(%ebx), %edi
 105         movl    $(_bss - startup_32), %ecx
 106         shrl    $2, %ecx
 107         std
 108         rep     movsl
 109         cld
 110         popl    %esi
 111
 112 /*
 113  * Compute the kernel start address.
 114  */
 115 #ifdef CONFIG_RELOCATABLE
 116         addl    $(CONFIG_PHYSICAL_ALIGN - 1), %ebp
 117         andl    $(~(CONFIG_PHYSICAL_ALIGN - 1)), %ebp
 118 #else
 119         movl    $LOAD_PHYSICAL_ADDR, %ebp
 120 #endif
 121
 122 /*
 123  * Jump to the relocated address.
 124  */
 125         leal    relocated(%ebx), %eax
 126         jmp     *%eax
 127 ENDPROC(startup_32)
 128
 129         .text
 130 relocated:
 131
 132 /*
 133  * Clear BSS (stack is currently empty)
 134  */
 135         xorl    %eax, %eax
 136         leal    _bss(%ebx), %edi
 137         leal    _ebss(%ebx), %ecx
 138         subl    %edi, %ecx
 139         shrl    $2, %ecx
 140         rep     stosl
 141
 142 /*
 143  * Do the decompression, and jump to the new kernel..
 144  */
 145         movl    output_len(%ebx), %eax
 146         pushl   %eax
 147                                 /* push arguments for decompress_kernel: */
 148         pushl   %ebp            /* output address */
 149         movl    input_len(%ebx), %eax
 150         pushl   %eax            /* input_len */
 151         leal    input_data(%ebx), %eax
 152         pushl   %eax            /* input_data */
 153         leal    boot_heap(%ebx), %eax
 154         pushl   %eax            /* heap area */
 155         pushl   %esi            /* real mode pointer */
 156         call    decompress_kernel
 157         addl    $20, %esp
 158         popl    %ecx
 159
 160 #if CONFIG_RELOCATABLE
 161 /*
 162  * Find the address of the relocations.
 163  */
 164         movl    %ebp, %edi
 165         addl    %ecx, %edi
 166
 167 /*
 168  * Calculate the delta between where vmlinux was compiled to run
 169  * and where it was actually loaded.
 170  */
 171         movl    %ebp, %ebx
 172         subl    $LOAD_PHYSICAL_ADDR, %ebx
 173         jz      2f      /* Nothing to be done if loaded at compiled addr. */
 174 /*
 175  * Process relocations.
 176  */
 177
 178 1:      subl    $4, %edi
 179         movl    (%edi), %ecx
 180         testl   %ecx, %ecx
 181         jz      2f
 182         addl    %ebx, -__PAGE_OFFSET(%ebx, %ecx)
 183         jmp     1b
 184 2:
 185 #endif
 186
 187 /*
 188  * Jump to the decompressed kernel.
 189  */
 190         xorl    %ebx, %ebx
 191         jmp     *%ebp
 192
 193 /*
 194  * Stack and heap for uncompression
 195  */
 196         .bss
 197         .balign 4
 198 boot_heap:
 199         .fill BOOT_HEAP_SIZE, 1, 0
 200 boot_stack:
 201         .fill BOOT_STACK_SIZE, 1, 0
 202 boot_stack_end: