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/init.h>
  27 #include <linux/linkage.h>
  28 #include <asm/segment.h>
  29 #include <asm/page_types.h>
  30 #include <asm/boot.h>
  31 #include <asm/asm-offsets.h>
  32
  33         __HEAD
  34 ENTRY(startup_32)
  35 #ifdef CONFIG_EFI_STUB
  36         jmp     preferred_addr
  37
  38         /*
  39          * We don't need the return address, so set up the stack so
  40          * efi_main() can find its arguments.
  41          */
  42 ENTRY(efi_pe_entry)
  43         add     $0x4, %esp
  44
  45         call    make_boot_params
  46         cmpl    $0, %eax
  47         je      1f
  48         movl    0x4(%esp), %esi
  49         movl    (%esp), %ecx
  50         pushl   %eax
  51         pushl   %esi
  52         pushl   %ecx
  53
  54         call    reloc
  55 reloc:
  56         popl    %ecx
  57         subl    reloc, %ecx
  58         movl    %ecx, BP_code32_start(%eax)
  59
  60         sub     $0x4, %esp
  61
  62 ENTRY(efi_stub_entry)
  63         add     $0x4, %esp
  64         call    efi_main
  65         cmpl    $0, %eax
  66         movl    %eax, %esi
  67         jne     2f
  68 1:
  69         /* EFI init failed, so hang. */
  70         hlt
  71         jmp     1b
  72 2:
  73         movl    BP_code32_start(%esi), %eax
  74         leal    preferred_addr(%eax), %eax
  75         jmp     *%eax
  76
  77 preferred_addr:
  78 #endif
  79         cld
  80         /*
  81          * Test KEEP_SEGMENTS flag to see if the bootloader is asking
  82          * us to not reload segments
  83          */
  84         testb   $(1<<6), BP_loadflags(%esi)
  85         jnz     1f
  86
  87         cli
  88         movl    $__BOOT_DS, %eax
  89         movl    %eax, %ds
  90         movl    %eax, %es
  91         movl    %eax, %fs
  92         movl    %eax, %gs
  93         movl    %eax, %ss
  94 1:
  95
  96 /*
  97  * Calculate the delta between where we were compiled to run
  98  * at and where we were actually loaded at.  This can only be done
  99  * with a short local call on x86.  Nothing  else will tell us what
 100  * address we are running at.  The reserved chunk of the real-mode
 101  * data at 0x1e4 (defined as a scratch field) are used as the stack
 102  * for this calculation. Only 4 bytes are needed.
 103  */
 104         leal    (BP_scratch+4)(%esi), %esp
 105         call    1f
 106 1:      popl    %ebp
 107         subl    $1b, %ebp
 108
 109 /*
 110  * %ebp contains the address we are loaded at by the boot loader and %ebx
 111  * contains the address where we should move the kernel image temporarily
 112  * for safe in-place decompression.
 113  */
 114
 115 #ifdef CONFIG_RELOCATABLE
 116         movl    %ebp, %ebx
 117         movl    BP_kernel_alignment(%esi), %eax
 118         decl    %eax
 119         addl    %eax, %ebx
 120         notl    %eax
 121         andl    %eax, %ebx
 122         cmpl    $LOAD_PHYSICAL_ADDR, %ebx
 123         jge     1f
 124 #endif
 125         movl    $LOAD_PHYSICAL_ADDR, %ebx
 126 1:
 127
 128         /* Target address to relocate to for decompression */
 129         addl    $z_extract_offset, %ebx
 130
 131         /* Set up the stack */
 132         leal    boot_stack_end(%ebx), %esp
 133
 134         /* Zero EFLAGS */
 135         pushl   $0
 136         popfl
 137
 138 /*
 139  * Copy the compressed kernel to the end of our buffer
 140  * where decompression in place becomes safe.
 141  */
 142         pushl   %esi
 143         leal    (_bss-4)(%ebp), %esi
 144         leal    (_bss-4)(%ebx), %edi
 145         movl    $(_bss - startup_32), %ecx
 146         shrl    $2, %ecx
 147         std
 148         rep     movsl
 149         cld
 150         popl    %esi
 151
 152 /*
 153  * Jump to the relocated address.
 154  */
 155         leal    relocated(%ebx), %eax
 156         jmp     *%eax
 157 ENDPROC(startup_32)
 158
 159         .text
 160 relocated:
 161
 162 /*
 163  * Clear BSS (stack is currently empty)
 164  */
 165         xorl    %eax, %eax
 166         leal    _bss(%ebx), %edi
 167         leal    _ebss(%ebx), %ecx
 168         subl    %edi, %ecx
 169         shrl    $2, %ecx
 170         rep     stosl
 171
 172 /*
 173  * Adjust our own GOT
 174  */
 175         leal    _got(%ebx), %edx
 176         leal    _egot(%ebx), %ecx
 177 1:
 178         cmpl    %ecx, %edx
 179         jae     2f
 180         addl    %ebx, (%edx)
 181         addl    $4, %edx
 182         jmp     1b
 183 2:
 184
 185 /*
 186  * Do the decompression, and jump to the new kernel..
 187  */
 188                                 /* push arguments for decompress_kernel: */
 189         pushl   $z_run_size     /* size of kernel with .bss and .brk */
 190         pushl   $z_output_len   /* decompressed length, end of relocs */
 191         leal    z_extract_offset_negative(%ebx), %ebp
 192         pushl   %ebp            /* output address */
 193         pushl   $z_input_len    /* input_len */
 194         leal    input_data(%ebx), %eax
 195         pushl   %eax            /* input_data */
 196         leal    boot_heap(%ebx), %eax
 197         pushl   %eax            /* heap area */
 198         pushl   %esi            /* real mode pointer */
 199         call    decompress_kernel /* returns kernel location in %eax */
 200         addl    $28, %esp
 201
 202 /*
 203  * Jump to the decompressed kernel.
 204  */
 205         xorl    %ebx, %ebx
 206         jmp     *%eax
 207
 208 /*
 209  * Stack and heap for uncompression
 210  */
 211         .bss
 212         .balign 4
 213 boot_heap:
 214         .fill BOOT_HEAP_SIZE, 1, 0
 215 boot_stack:
 216         .fill BOOT_STACK_SIZE, 1, 0
 217 boot_stack_end: