arch/x86_64/kernel/acpi/wakeup.S

   1 .text
   2 #include <linux/linkage.h>
   3 #include <asm/segment.h>
   4 #include <asm/pgtable.h>
   5 #include <asm/page.h>
   6 #include <asm/msr.h>
   7
   8 # Copyright 2003 Pavel Machek <pavel@suse.cz>, distribute under GPLv2
   9 #
  10 # wakeup_code runs in real mode, and at unknown address (determined at run-time).
  11 # Therefore it must only use relative jumps/calls.
  12 #
  13 # Do we need to deal with A20? It is okay: ACPI specs says A20 must be enabled
  14 #
  15 # If physical address of wakeup_code is 0x12345, BIOS should call us with
  16 # cs = 0x1234, eip = 0x05
  17 #
  18
  19 #define BEEP \
  20         inb     $97, %al;       \
  21         outb    %al, $0x80;     \
  22         movb    $3, %al;        \
  23         outb    %al, $97;       \
  24         outb    %al, $0x80;     \
  25         movb    $-74, %al;      \
  26         outb    %al, $67;       \
  27         outb    %al, $0x80;     \
  28         movb    $-119, %al;     \
  29         outb    %al, $66;       \
  30         outb    %al, $0x80;     \
  31         movb    $15, %al;       \
  32         outb    %al, $66;
  33
  34
  35 ALIGN
  36         .align  16
  37 ENTRY(wakeup_start)
  38 wakeup_code:
  39         wakeup_code_start = .
  40         .code16
  41
  42 # Running in *copy* of this code, somewhere in low 1MB.
  43
  44         movb    $0xa1, %al      ;  outb %al, $0x80
  45         cli
  46         cld
  47         # setup data segment
  48         movw    %cs, %ax
  49         movw    %ax, %ds                # Make ds:0 point to wakeup_start
  50         movw    %ax, %ss
  51
  52         # Data segment must be set up before we can see whether to beep.
  53         testl   $1, beep_flags - wakeup_code
  54         jz      1f
  55         BEEP
  56 1:
  57
  58                                         # Private stack is needed for ASUS board
  59         mov     $(wakeup_stack - wakeup_code), %sp
  60
  61         pushl   $0                      # Kill any dangerous flags
  62         popfl
  63
  64         movl    real_magic - wakeup_code, %eax
  65         cmpl    $0x12345678, %eax
  66         jne     bogus_real_magic
  67
  68         call    verify_cpu                      # Verify the cpu supports long
  69                                                 # mode
  70         testl   %eax, %eax
  71         jnz     no_longmode
  72
  73         testl   $1, video_flags - wakeup_code
  74         jz      1f
  75         lcall   $0xc000,$3
  76         movw    %cs, %ax
  77         movw    %ax, %ds                # Bios might have played with that
  78         movw    %ax, %ss
  79 1:
  80
  81         testl   $2, video_flags - wakeup_code
  82         jz      1f
  83         mov     video_mode - wakeup_code, %ax
  84         call    mode_seta
  85 1:
  86
  87         movw    $0xb800, %ax
  88         movw    %ax,%fs
  89         movw    $0x0e00 + 'L', %fs:(0x10)
  90
  91         movb    $0xa2, %al      ;  outb %al, $0x80
  92
  93         mov     %ds, %ax                        # Find 32bit wakeup_code addr
  94         movzx   %ax, %esi                       # (Convert %ds:gdt to a liner ptr)
  95         shll    $4, %esi
  96                                                 # Fix up the vectors
  97         addl    %esi, wakeup_32_vector - wakeup_code
  98         addl    %esi, wakeup_long64_vector - wakeup_code
  99         addl    %esi, gdt_48a + 2 - wakeup_code # Fixup the gdt pointer
 100
 101         lidtl   %ds:idt_48a - wakeup_code
 102         lgdtl   %ds:gdt_48a - wakeup_code       # load gdt with whatever is
 103                                                 # appropriate
 104
 105         movl    $1, %eax                        # protected mode (PE) bit
 106         lmsw    %ax                             # This is it!
 107         jmp     1f
 108 1:
 109
 110         ljmpl   *(wakeup_32_vector - wakeup_code)
 111
 112         .balign 4
 113 wakeup_32_vector:
 114         .long   wakeup_32 - wakeup_code
 115         .word   __KERNEL32_CS, 0
 116
 117         .code32
 118 wakeup_32:
 119 # Running in this code, but at low address; paging is not yet turned on.
 120         movb    $0xa5, %al      ;  outb %al, $0x80
 121
 122         movl    $__KERNEL_DS, %eax
 123         movl    %eax, %ds
 124
 125         movw    $0x0e00 + 'i', %ds:(0xb8012)
 126         movb    $0xa8, %al      ;  outb %al, $0x80;
 127
 128         /*
 129          * Prepare for entering 64bits mode
 130          */
 131
 132         /* Enable PAE */
 133         xorl    %eax, %eax
 134         btsl    $5, %eax
 135         movl    %eax, %cr4
 136
 137         /* Setup early boot stage 4 level pagetables */
 138         leal    (wakeup_level4_pgt - wakeup_code)(%esi), %eax
 139         movl    %eax, %cr3
 140
 141         /* Check if nx is implemented */
 142         movl    $0x80000001, %eax
 143         cpuid
 144         movl    %edx,%edi
 145
 146         /* Enable Long Mode */
 147         xorl    %eax, %eax
 148         btsl    $_EFER_LME, %eax
 149
 150         /* No Execute supported? */
 151         btl     $20,%edi
 152         jnc     1f
 153         btsl    $_EFER_NX, %eax
 154
 155         /* Make changes effective */
 156 1:      movl    $MSR_EFER, %ecx
 157         xorl    %edx, %edx
 158         wrmsr
 159
 160         xorl    %eax, %eax
 161         btsl    $31, %eax                       /* Enable paging and in turn activate Long Mode */
 162         btsl    $0, %eax                        /* Enable protected mode */
 163
 164         /* Make changes effective */
 165         movl    %eax, %cr0
 166
 167         /* At this point:
 168                 CR4.PAE must be 1
 169                 CS.L must be 0
 170                 CR3 must point to PML4
 171                 Next instruction must be a branch
 172                 This must be on identity-mapped page
 173         */
 174         /*
 175          * At this point we're in long mode but in 32bit compatibility mode
 176          * with EFER.LME = 1, CS.L = 0, CS.D = 1 (and in turn
 177          * EFER.LMA = 1). Now we want to jump in 64bit mode, to do that we load
 178          * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
 179          */
 180
 181         /* Finally jump in 64bit mode */
 182         ljmp    *(wakeup_long64_vector - wakeup_code)(%esi)
 183
 184         .balign 4
 185 wakeup_long64_vector:
 186         .long   wakeup_long64 - wakeup_code
 187         .word   __KERNEL_CS, 0
 188
 189 .code64
 190
 191         /* Hooray, we are in Long 64-bit mode (but still running in
 192          * low memory)
 193          */
 194 wakeup_long64:
 195         /*
 196          * We must switch to a new descriptor in kernel space for the GDT
 197          * because soon the kernel won't have access anymore to the userspace
 198          * addresses where we're currently running on. We have to do that here
 199          * because in 32bit we couldn't load a 64bit linear address.
 200          */
 201         lgdt    cpu_gdt_descr
 202
 203         movw    $0x0e00 + 'n', %ds:(0xb8014)
 204         movb    $0xa9, %al      ;  outb %al, $0x80
 205
 206         movq    saved_magic, %rax
 207         movq    $0x123456789abcdef0, %rdx
 208         cmpq    %rdx, %rax
 209         jne     bogus_64_magic
 210
 211         movw    $0x0e00 + 'u', %ds:(0xb8016)
 212
 213         nop
 214         nop
 215         movw    $__KERNEL_DS, %ax
 216         movw    %ax, %ss
 217         movw    %ax, %ds
 218         movw    %ax, %es
 219         movw    %ax, %fs
 220         movw    %ax, %gs
 221         movq    saved_rsp, %rsp
 222
 223         movw    $0x0e00 + 'x', %ds:(0xb8018)
 224         movq    saved_rbx, %rbx
 225         movq    saved_rdi, %rdi
 226         movq    saved_rsi, %rsi
 227         movq    saved_rbp, %rbp
 228
 229         movw    $0x0e00 + '!', %ds:(0xb801a)
 230         movq    saved_rip, %rax
 231         jmp     *%rax
 232
 233 .code32
 234
 235         .align  64
 236 gdta:
 237         /* Its good to keep gdt in sync with one in trampoline.S */
 238         .word   0, 0, 0, 0                      # dummy
 239         /* ??? Why I need the accessed bit set in order for this to work? */
 240         .quad   0x00cf9b000000ffff              # __KERNEL32_CS
 241         .quad   0x00af9b000000ffff              # __KERNEL_CS
 242         .quad   0x00cf93000000ffff              # __KERNEL_DS
 243
 244 idt_48a:
 245         .word   0                               # idt limit = 0
 246         .word   0, 0                            # idt base = 0L
 247
 248 gdt_48a:
 249         .word   0x800                           # gdt limit=2048,
 250                                                 #  256 GDT entries
 251         .long   gdta - wakeup_code              # gdt base (relocated in later)
 252
 253 real_magic:     .quad 0
 254 beep_flags:     .quad 0
 255 video_mode:     .quad 0
 256 video_flags:    .quad 0
 257
 258 .code16
 259 bogus_real_magic:
 260         movb    $0xba,%al       ;  outb %al,$0x80
 261         jmp bogus_real_magic
 262
 263 .code64
 264 bogus_64_magic:
 265         movb    $0xb3,%al       ;  outb %al,$0x80
 266         jmp bogus_64_magic
 267
 268 .code16
 269 no_longmode:
 270         movb    $0xbc,%al       ;  outb %al,$0x80
 271         jmp no_longmode
 272
 273 #include "../verify_cpu.S"
 274
 275 /* This code uses an extended set of video mode numbers. These include:
 276  * Aliases for standard modes
 277  *      NORMAL_VGA (-1)
 278  *      EXTENDED_VGA (-2)
 279  *      ASK_VGA (-3)
 280  * Video modes numbered by menu position -- NOT RECOMMENDED because of lack
 281  * of compatibility when extending the table. These are between 0x00 and 0xff.
 282  */
 283 #define VIDEO_FIRST_MENU 0x0000
 284
 285 /* Standard BIOS video modes (BIOS number + 0x0100) */
 286 #define VIDEO_FIRST_BIOS 0x0100
 287
 288 /* VESA BIOS video modes (VESA number + 0x0200) */
 289 #define VIDEO_FIRST_VESA 0x0200
 290
 291 /* Video7 special modes (BIOS number + 0x0900) */
 292 #define VIDEO_FIRST_V7 0x0900
 293
 294 # Setting of user mode (AX=mode ID) => CF=success
 295 .code16
 296 mode_seta:
 297         movw    %ax, %bx
 298 #if 0
 299         cmpb    $0xff, %ah
 300         jz      setalias
 301
 302         testb   $VIDEO_RECALC>>8, %ah
 303         jnz     _setrec
 304
 305         cmpb    $VIDEO_FIRST_RESOLUTION>>8, %ah
 306         jnc     setres
 307
 308         cmpb    $VIDEO_FIRST_SPECIAL>>8, %ah
 309         jz      setspc
 310
 311         cmpb    $VIDEO_FIRST_V7>>8, %ah
 312         jz      setv7
 313 #endif
 314
 315         cmpb    $VIDEO_FIRST_VESA>>8, %ah
 316         jnc     check_vesaa
 317 #if 0
 318         orb     %ah, %ah
 319         jz      setmenu
 320 #endif
 321
 322         decb    %ah
 323 #       jz      setbios                           Add bios modes later
 324
 325 setbada:        clc
 326         ret
 327
 328 check_vesaa:
 329         subb    $VIDEO_FIRST_VESA>>8, %bh
 330         orw     $0x4000, %bx                    # Use linear frame buffer
 331         movw    $0x4f02, %ax                    # VESA BIOS mode set call
 332         int     $0x10
 333         cmpw    $0x004f, %ax                    # AL=4f if implemented
 334         jnz     _setbada                                # AH=0 if OK
 335
 336         stc
 337         ret
 338
 339 _setbada: jmp setbada
 340
 341 wakeup_stack_begin:     # Stack grows down
 342
 343 .org    0xff0
 344 wakeup_stack:           # Just below end of page
 345
 346 .org   0x1000
 347 ENTRY(wakeup_level4_pgt)
 348         .quad   level3_ident_pgt - __START_KERNEL_map + _KERNPG_TABLE
 349         .fill   510,8,0
 350         /* (2^48-(2*1024*1024*1024))/(2^39) = 511 */
 351         .quad   level3_kernel_pgt - __START_KERNEL_map + _KERNPG_TABLE
 352
 353 ENTRY(wakeup_end)
 354
 355 ##
 356 # acpi_copy_wakeup_routine
 357 #
 358 # Copy the above routine to low memory.
 359 #
 360 # Parameters:
 361 # %rdi: place to copy wakeup routine to
 362 #
 363 # Returned address is location of code in low memory (past data and stack)
 364 #
 365         .code64
 366 ENTRY(acpi_copy_wakeup_routine)
 367         pushq   %rax
 368         pushq   %rdx
 369
 370         movl    s2ram_beep, %edx
 371         movl    %edx, beep_flags - wakeup_start (,%rdi)
 372         movl    saved_video_mode, %edx
 373         movl    %edx, video_mode - wakeup_start (,%rdi)
 374         movl    acpi_video_flags, %edx
 375         movl    %edx, video_flags - wakeup_start (,%rdi)
 376         movq    $0x12345678, real_magic - wakeup_start (,%rdi)
 377         movq    $0x123456789abcdef0, %rdx
 378         movq    %rdx, saved_magic
 379
 380         movq    saved_magic, %rax
 381         movq    $0x123456789abcdef0, %rdx
 382         cmpq    %rdx, %rax
 383         jne     bogus_64_magic
 384
 385         # restore the regs we used
 386         popq    %rdx
 387         popq    %rax
 388 ENTRY(do_suspend_lowlevel_s4bios)
 389         ret
 390
 391         .align 2
 392         .p2align 4,,15
 393 .globl do_suspend_lowlevel
 394         .type   do_suspend_lowlevel,@function
 395 do_suspend_lowlevel:
 396 .LFB5:
 397         subq    $8, %rsp
 398         xorl    %eax, %eax
 399         call    save_processor_state
 400
 401         movq %rsp, saved_context_esp(%rip)
 402         movq %rax, saved_context_eax(%rip)
 403         movq %rbx, saved_context_ebx(%rip)
 404         movq %rcx, saved_context_ecx(%rip)
 405         movq %rdx, saved_context_edx(%rip)
 406         movq %rbp, saved_context_ebp(%rip)
 407         movq %rsi, saved_context_esi(%rip)
 408         movq %rdi, saved_context_edi(%rip)
 409         movq %r8,  saved_context_r08(%rip)
 410         movq %r9,  saved_context_r09(%rip)
 411         movq %r10, saved_context_r10(%rip)
 412         movq %r11, saved_context_r11(%rip)
 413         movq %r12, saved_context_r12(%rip)
 414         movq %r13, saved_context_r13(%rip)
 415         movq %r14, saved_context_r14(%rip)
 416         movq %r15, saved_context_r15(%rip)
 417         pushfq ; popq saved_context_eflags(%rip)
 418
 419         movq    $.L97, saved_rip(%rip)
 420
 421         movq %rsp,saved_rsp
 422         movq %rbp,saved_rbp
 423         movq %rbx,saved_rbx
 424         movq %rdi,saved_rdi
 425         movq %rsi,saved_rsi
 426
 427         addq    $8, %rsp
 428         movl    $3, %edi
 429         xorl    %eax, %eax
 430         jmp     acpi_enter_sleep_state
 431 .L97:
 432         .p2align 4,,7
 433 .L99:
 434         .align 4
 435         movl    $24, %eax
 436         movw %ax, %ds
 437         movq    saved_context+58(%rip), %rax
 438         movq %rax, %cr4
 439         movq    saved_context+50(%rip), %rax
 440         movq %rax, %cr3
 441         movq    saved_context+42(%rip), %rax
 442         movq %rax, %cr2
 443         movq    saved_context+34(%rip), %rax
 444         movq %rax, %cr0
 445         pushq saved_context_eflags(%rip) ; popfq
 446         movq saved_context_esp(%rip), %rsp
 447         movq saved_context_ebp(%rip), %rbp
 448         movq saved_context_eax(%rip), %rax
 449         movq saved_context_ebx(%rip), %rbx
 450         movq saved_context_ecx(%rip), %rcx
 451         movq saved_context_edx(%rip), %rdx
 452         movq saved_context_esi(%rip), %rsi
 453         movq saved_context_edi(%rip), %rdi
 454         movq saved_context_r08(%rip), %r8
 455         movq saved_context_r09(%rip), %r9
 456         movq saved_context_r10(%rip), %r10
 457         movq saved_context_r11(%rip), %r11
 458         movq saved_context_r12(%rip), %r12
 459         movq saved_context_r13(%rip), %r13
 460         movq saved_context_r14(%rip), %r14
 461         movq saved_context_r15(%rip), %r15
 462
 463         xorl    %eax, %eax
 464         addq    $8, %rsp
 465         jmp     restore_processor_state
 466 .LFE5:
 467 .Lfe5:
 468         .size   do_suspend_lowlevel,.Lfe5-do_suspend_lowlevel
 469
 470 .data
 471 ALIGN
 472 ENTRY(saved_rbp)        .quad   0
 473 ENTRY(saved_rsi)        .quad   0
 474 ENTRY(saved_rdi)        .quad   0
 475 ENTRY(saved_rbx)        .quad   0
 476
 477 ENTRY(saved_rip)        .quad   0
 478 ENTRY(saved_rsp)        .quad   0
 479
 480 ENTRY(saved_magic)      .quad   0