arch/x86_64/kernel/head.S

   1 /*
   2  *  linux/arch/x86_64/kernel/head.S -- start in 32bit and switch to 64bit
   3  *
   4  *  Copyright (C) 2000 Andrea Arcangeli <andrea@suse.de> SuSE
   5  *  Copyright (C) 2000 Pavel Machek <pavel@suse.cz>
   6  *  Copyright (C) 2000 Karsten Keil <kkeil@suse.de>
   7  *  Copyright (C) 2001,2002 Andi Kleen <ak@suse.de>
   8  *
   9  *  $Id: head.S,v 1.49 2002/03/19 17:39:25 ak Exp $
  10  */
  11
  12
  13 #include <linux/linkage.h>
  14 #include <linux/threads.h>
  15 #include <asm/desc.h>
  16 #include <asm/segment.h>
  17 #include <asm/page.h>
  18 #include <asm/msr.h>
  19 #include <asm/cache.h>
  20
  21 /* we are not able to switch in one step to the final KERNEL ADRESS SPACE
  22  * because we need identity-mapped pages on setup so define __START_KERNEL to
  23  * 0x100000 for this stage
  24  *
  25  */
  26
  27         .text
  28         .code32
  29         .globl startup_32
  30 /* %bx:  1 if coming from smp trampoline on secondary cpu */
  31 startup_32:
  32
  33         /*
  34          * At this point the CPU runs in 32bit protected mode (CS.D = 1) with
  35          * paging disabled and the point of this file is to switch to 64bit
  36          * long mode with a kernel mapping for kerneland to jump into the
  37          * kernel virtual addresses.
  38          * There is no stack until we set one up.
  39          */
  40
  41         /* Initialize the %ds segment register */
  42         movl $__KERNEL_DS,%eax
  43         movl %eax,%ds
  44
  45         /* Load new GDT with the 64bit segments using 32bit descriptor */
  46         lgdt    pGDT32 - __START_KERNEL_map
  47
  48         /* If the CPU doesn't support CPUID this will double fault.
  49          * Unfortunately it is hard to check for CPUID without a stack.
  50          */
  51
  52         /* Check if extended functions are implemented */
  53         movl    $0x80000000, %eax
  54         cpuid
  55         cmpl    $0x80000000, %eax
  56         jbe     no_long_mode
  57         /* Check if long mode is implemented */
  58         mov     $0x80000001, %eax
  59         cpuid
  60         btl     $29, %edx
  61         jnc     no_long_mode
  62
  63         /*
  64          * Prepare for entering 64bits mode
  65          */
  66
  67         /* Enable PAE mode */
  68         xorl    %eax, %eax
  69         btsl    $5, %eax
  70         movl    %eax, %cr4
  71
  72         /* Setup early boot stage 4 level pagetables */
  73         movl    $(init_level4_pgt - __START_KERNEL_map), %eax
  74         movl    %eax, %cr3
  75
  76         /* Setup EFER (Extended Feature Enable Register) */
  77         movl    $MSR_EFER, %ecx
  78         rdmsr
  79
  80         /* Enable Long Mode */
  81         btsl    $_EFER_LME, %eax
  82
  83         /* Make changes effective */
  84         wrmsr
  85
  86         xorl    %eax, %eax
  87         btsl    $31, %eax                       /* Enable paging and in turn activate Long Mode */
  88         btsl    $0, %eax                        /* Enable protected mode */
  89         /* Make changes effective */
  90         movl    %eax, %cr0
  91         /*
  92          * At this point we're in long mode but in 32bit compatibility mode
  93          * with EFER.LME = 1, CS.L = 0, CS.D = 1 (and in turn
  94          * EFER.LMA = 1). Now we want to jump in 64bit mode, to do that we use
  95          * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
  96          */
  97         ljmp    $__KERNEL_CS, $(startup_64 - __START_KERNEL_map)
  98
  99         .code64
 100         .org 0x100
 101         .globl startup_64
 102 startup_64:
 103         /* We come here either from startup_32
 104          * or directly from a 64bit bootloader.
 105          * Since we may have come directly from a bootloader we
 106          * reload the page tables here.
 107          */
 108
 109         /* Enable PAE mode and PGE */
 110         xorq    %rax, %rax
 111         btsq    $5, %rax
 112         btsq    $7, %rax
 113         movq    %rax, %cr4
 114
 115         /* Setup early boot stage 4 level pagetables. */
 116         movq    $(init_level4_pgt - __START_KERNEL_map), %rax
 117         movq    %rax, %cr3
 118
 119         /* Check if nx is implemented */
 120         movl    $0x80000001, %eax
 121         cpuid
 122         movl    %edx,%edi
 123
 124         /* Setup EFER (Extended Feature Enable Register) */
 125         movl    $MSR_EFER, %ecx
 126         rdmsr
 127
 128         /* Enable System Call */
 129         btsl    $_EFER_SCE, %eax
 130
 131         /* No Execute supported? */
 132         btl     $20,%edi
 133         jnc     1f
 134         btsl    $_EFER_NX, %eax
 135 1:
 136         /* Make changes effective */
 137         wrmsr
 138
 139         /* Setup cr0 */
 140 #define CR0_PM                          1               /* protected mode */
 141 #define CR0_MP                          (1<<1)
 142 #define CR0_ET                          (1<<4)
 143 #define CR0_NE                          (1<<5)
 144 #define CR0_WP                          (1<<16)
 145 #define CR0_AM                          (1<<18)
 146 #define CR0_PAGING                      (1<<31)
 147         movl $CR0_PM|CR0_MP|CR0_ET|CR0_NE|CR0_WP|CR0_AM|CR0_PAGING,%eax
 148         /* Make changes effective */
 149         movq    %rax, %cr0
 150
 151         /* Setup a boot time stack */
 152         movq init_rsp(%rip),%rsp
 153
 154         /* zero EFLAGS after setting rsp */
 155         pushq $0
 156         popfq
 157
 158         /*
 159          * We must switch to a new descriptor in kernel space for the GDT
 160          * because soon the kernel won't have access anymore to the userspace
 161          * addresses where we're currently running on. We have to do that here
 162          * because in 32bit we couldn't load a 64bit linear address.
 163          */
 164         lgdt    cpu_gdt_descr
 165
 166         /*
 167          * Setup up a dummy PDA. this is just for some early bootup code
 168          * that does in_interrupt()
 169          */
 170         movl    $MSR_GS_BASE,%ecx
 171         movq    $empty_zero_page,%rax
 172         movq    %rax,%rdx
 173         shrq    $32,%rdx
 174         wrmsr
 175
 176         /* set up data segments. actually 0 would do too */
 177         movl $__KERNEL_DS,%eax
 178         movl %eax,%ds
 179         movl %eax,%ss
 180         movl %eax,%es
 181
 182         /* esi is pointer to real mode structure with interesting info.
 183            pass it to C */
 184         movl    %esi, %edi
 185
 186         /* Finally jump to run C code and to be on real kernel address
 187          * Since we are running on identity-mapped space we have to jump
 188          * to the full 64bit address , this is only possible as indirect
 189          * jump
 190          */
 191         movq    initial_code(%rip),%rax
 192         jmp     *%rax
 193
 194         /* SMP bootup changes these two */
 195         .globl  initial_code
 196 initial_code:
 197         .quad   x86_64_start_kernel
 198         .globl init_rsp
 199 init_rsp:
 200         .quad  init_thread_union+THREAD_SIZE-8
 201
 202 ENTRY(early_idt_handler)
 203         cmpl $2,early_recursion_flag(%rip)
 204         jz  1f
 205         incl early_recursion_flag(%rip)
 206         xorl %eax,%eax
 207         movq 8(%rsp),%rsi       # get rip
 208         movq (%rsp),%rdx
 209         movq %cr2,%rcx
 210         leaq early_idt_msg(%rip),%rdi
 211         call early_printk
 212         cmpl $2,early_recursion_flag(%rip)
 213         jz  1f
 214         call dump_stack
 215 1:      hlt
 216         jmp 1b
 217 early_recursion_flag:
 218         .long 0
 219
 220 early_idt_msg:
 221         .asciz "PANIC: early exception rip %lx error %lx cr2 %lx\n"
 222
 223 .code32
 224 ENTRY(no_long_mode)
 225         /* This isn't an x86-64 CPU so hang */
 226 1:
 227         jmp     1b
 228
 229 .org 0xf00
 230         .globl pGDT32
 231 pGDT32:
 232         .word   gdt_end-cpu_gdt_table
 233         .long   cpu_gdt_table-__START_KERNEL_map
 234
 235 .org 0xf10
 236 ljumpvector:
 237         .long   startup_64-__START_KERNEL_map
 238         .word   __KERNEL_CS
 239
 240 ENTRY(stext)
 241 ENTRY(_stext)
 242
 243         /*
 244          * This default setting generates an ident mapping at address 0x100000
 245          * and a mapping for the kernel that precisely maps virtual address
 246          * 0xffffffff80000000 to physical address 0x000000. (always using
 247          * 2Mbyte large pages provided by PAE mode)
 248          */
 249 .org 0x1000
 250 ENTRY(init_level4_pgt)
 251         .quad   0x0000000000002007 + __PHYSICAL_START   /* -> level3_ident_pgt */
 252         .fill   255,8,0
 253         .quad   0x000000000000a007 + __PHYSICAL_START
 254         .fill   254,8,0
 255         /* (2^48-(2*1024*1024*1024))/(2^39) = 511 */
 256         .quad   0x0000000000003007 + __PHYSICAL_START   /* -> level3_kernel_pgt */
 257
 258 .org 0x2000
 259 ENTRY(level3_ident_pgt)
 260         .quad   0x0000000000004007 + __PHYSICAL_START
 261         .fill   511,8,0
 262
 263 .org 0x3000
 264 ENTRY(level3_kernel_pgt)
 265         .fill   510,8,0
 266         /* (2^48-(2*1024*1024*1024)-((2^39)*511))/(2^30) = 510 */
 267         .quad   0x0000000000005007 + __PHYSICAL_START   /* -> level2_kernel_pgt */
 268         .fill   1,8,0
 269
 270 .org 0x4000
 271 ENTRY(level2_ident_pgt)
 272         /* 40MB for bootup.     */
 273         .quad   0x0000000000000283
 274         .quad   0x0000000000200183
 275         .quad   0x0000000000400183
 276         .quad   0x0000000000600183
 277         .quad   0x0000000000800183
 278         .quad   0x0000000000A00183
 279         .quad   0x0000000000C00183
 280         .quad   0x0000000000E00183
 281         .quad   0x0000000001000183
 282         .quad   0x0000000001200183
 283         .quad   0x0000000001400183
 284         .quad   0x0000000001600183
 285         .quad   0x0000000001800183
 286         .quad   0x0000000001A00183
 287         .quad   0x0000000001C00183
 288         .quad   0x0000000001E00183
 289         .quad   0x0000000002000183
 290         .quad   0x0000000002200183
 291         .quad   0x0000000002400183
 292         .quad   0x0000000002600183
 293         /* Temporary mappings for the super early allocator in arch/x86_64/mm/init.c */
 294         .globl temp_boot_pmds
 295 temp_boot_pmds:
 296         .fill   492,8,0
 297
 298 .org 0x5000
 299 ENTRY(level2_kernel_pgt)
 300         /* 40MB kernel mapping. The kernel code cannot be bigger than that.
 301            When you change this change KERNEL_TEXT_SIZE in page.h too. */
 302         /* (2^48-(2*1024*1024*1024)-((2^39)*511)-((2^30)*510)) = 0 */
 303         .quad   0x0000000000000183
 304         .quad   0x0000000000200183
 305         .quad   0x0000000000400183
 306         .quad   0x0000000000600183
 307         .quad   0x0000000000800183
 308         .quad   0x0000000000A00183
 309         .quad   0x0000000000C00183
 310         .quad   0x0000000000E00183
 311         .quad   0x0000000001000183
 312         .quad   0x0000000001200183
 313         .quad   0x0000000001400183
 314         .quad   0x0000000001600183
 315         .quad   0x0000000001800183
 316         .quad   0x0000000001A00183
 317         .quad   0x0000000001C00183
 318         .quad   0x0000000001E00183
 319         .quad   0x0000000002000183
 320         .quad   0x0000000002200183
 321         .quad   0x0000000002400183
 322         .quad   0x0000000002600183
 323         /* Module mapping starts here */
 324         .fill   492,8,0
 325
 326 .org 0x6000
 327 ENTRY(empty_zero_page)
 328
 329 .org 0x7000
 330 ENTRY(empty_bad_page)
 331
 332 .org 0x8000
 333 ENTRY(empty_bad_pte_table)
 334
 335 .org 0x9000
 336 ENTRY(empty_bad_pmd_table)
 337
 338 .org 0xa000
 339 ENTRY(level3_physmem_pgt)
 340         .quad   0x0000000000005007 + __PHYSICAL_START   /* -> level2_kernel_pgt (so that __va works even before pagetable_init) */
 341
 342         .org 0xb000
 343 #ifdef CONFIG_ACPI_SLEEP
 344 ENTRY(wakeup_level4_pgt)
 345         .quad   0x0000000000002007 + __PHYSICAL_START   /* -> level3_ident_pgt */
 346         .fill   255,8,0
 347         .quad   0x000000000000a007 + __PHYSICAL_START
 348         .fill   254,8,0
 349         /* (2^48-(2*1024*1024*1024))/(2^39) = 511 */
 350         .quad   0x0000000000003007 + __PHYSICAL_START   /* -> level3_kernel_pgt */
 351 #endif
 352
 353         .data
 354
 355         .align 16
 356         .globl cpu_gdt_descr
 357 cpu_gdt_descr:
 358         .word   gdt_end-cpu_gdt_table
 359 gdt:
 360         .quad   cpu_gdt_table
 361 #ifdef CONFIG_SMP
 362         .rept   NR_CPUS-1
 363         .word   0
 364         .quad   0
 365         .endr
 366 #endif
 367
 368 /* We need valid kernel segments for data and code in long mode too
 369  * IRET will check the segment types  kkeil 2000/10/28
 370  * Also sysret mandates a special GDT layout
 371  */
 372
 373 .align L1_CACHE_BYTES
 374
 375 /* The TLS descriptors are currently at a different place compared to i386.
 376    Hopefully nobody expects them at a fixed place (Wine?) */
 377
 378 ENTRY(cpu_gdt_table)
 379         .quad   0x0000000000000000      /* NULL descriptor */
 380         .quad   0x008f9a000000ffff      /* __KERNEL_COMPAT32_CS */
 381         .quad   0x00af9a000000ffff      /* __KERNEL_CS */
 382         .quad   0x00cf92000000ffff      /* __KERNEL_DS */
 383         .quad   0x00cffa000000ffff      /* __USER32_CS */
 384         .quad   0x00cff2000000ffff      /* __USER_DS, __USER32_DS  */
 385         .quad   0x00affa000000ffff      /* __USER_CS */
 386         .quad   0x00cf9a000000ffff      /* __KERNEL32_CS */
 387         .quad   0,0                     /* TSS */
 388         .quad   0,0                     /* LDT */
 389         .quad   0,0,0                   /* three TLS descriptors */
 390         .quad   0x00009a000000ffff      /* __KERNEL16_CS - 16bit PM for S3 wakeup. */
 391                                         /* base must be patched for real base address. */
 392 gdt_end:
 393         /* asm/segment.h:GDT_ENTRIES must match this */
 394         /* This should be a multiple of the cache line size */
 395         /* GDTs of other CPUs: */
 396         .fill (GDT_SIZE * NR_CPUS) - (gdt_end - cpu_gdt_table)
 397
 398         .align  L1_CACHE_BYTES
 399 ENTRY(idt_table)
 400         .rept   256
 401         .quad   0
 402         .quad   0
 403         .endr
 404