src/cpu/x86/smm/smmhandler.S

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2008 coresystems GmbH
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; version 2 of
   9  * the License.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  19  * MA 02110-1301 USA
  20  */
  21
  22 /* NOTE: This handler assumes the SMM window goes from 0xa0000
  23  * to 0xaffff. In fact, at least on Intel Core CPUs (i945 chipset)
  24  * the SMM window is 128K big, covering 0xa0000 to 0xbffff.
  25  * So there is a lot of potential for growth in here. Let's stick
  26  * to 64k if we can though.
  27  */
  28
  29 /*
  30  * +--------------------------------+ 0xaffff
  31  * |  Save State Map Node 0         |
  32  * |  Save State Map Node 1         |
  33  * |  Save State Map Node 2         |
  34  * |  Save State Map Node 3         |
  35  * |  ...                           |
  36  * +--------------------------------+ 0xaf000
  37  * |                                |
  38  * |                                |
  39  * |                                |
  40  * +--------------------------------+ 0xa8400
  41  * | SMM Entry Node 0 (+ stack)     |
  42  * +--------------------------------+ 0xa8000
  43  * | SMM Entry Node 1 (+ stack)     |
  44  * | SMM Entry Node 2 (+ stack)     |
  45  * | SMM Entry Node 3 (+ stack)     |
  46  * | ...                            |
  47  * +--------------------------------+ 0xa7400
  48  * |                                |
  49  * | SMM Handler                    |
  50  * |                                |
  51  * +--------------------------------+ 0xa0000
  52  *
  53  */
  54
  55 #define LAPIC_ID 0xfee00020
  56
  57 /* SMM_HANDLER_OFFSET is the 16bit offset within the ASEG
  58  * at which smm_handler_start lives. At the moment the handler
  59  * lives right at 0xa0000, so the offset is 0.
  60  */
  61
  62 #define SMM_HANDLER_OFFSET 0x0000
  63
  64 /* initially SMM is some sort of real mode. Let gcc know
  65  * how to treat the SMM handler stub
  66  */
  67
  68 .section ".handler", "a", @progbits
  69
  70 .code16
  71
  72 /**
  73  * SMM code to enable protected mode and jump to the
  74  * C-written function void smi_handler(u32 smm_revision)
  75  *
  76  * All the bad magic is not all that bad after all.
  77  */
  78 smm_handler_start:
  79         movw    $(smm_gdtptr16 - smm_handler_start + SMM_HANDLER_OFFSET), %bx
  80         data32  lgdt %cs:(%bx)
  81
  82         movl    %cr0, %eax
  83         andl    $0x7FFAFFD1, %eax /* PG,AM,WP,NE,TS,EM,MP = 0 */
  84         orl     $0x60000001, %eax /* CD, NW, PE = 1 */
  85         movl    %eax, %cr0
  86
  87         /* Enable protected mode */
  88         data32  ljmp    $0x08, $1f
  89
  90 .code32
  91 1:
  92         /* flush the cache after disabling it */
  93         wbinvd
  94
  95         /* Use flat data segment */
  96         movw    $0x10, %ax
  97         movw    %ax, %ds
  98         movw    %ax, %es
  99         movw    %ax, %ss
 100         movw    %ax, %fs
 101         movw    %ax, %gs
 102
 103         /* Get this CPU's LAPIC ID */
 104         movl $LAPIC_ID, %esi
 105         movl (%esi), %ecx
 106         shr  $24, %ecx
 107
 108         /* calculate stack offset by multiplying the APIC ID
 109          * by 1024 (0x400), and save that offset in ebp.
 110          */
 111         shl $10, %ecx
 112         movl %ecx, %ebp
 113
 114         /* We put the stack for each core right above
 115          * its SMM entry point. Core 0 starts at 0xa8000,
 116          * we spare 0x10 bytes for the jump to be sure.
 117          */
 118         movl $0xa8010, %eax
 119         subl %ecx, %eax         /* subtract offset, see above */
 120         movl %eax, %ebx         /* Save bottom of stack in ebx */
 121
 122 #define SMM_STACK_SIZE  (0x400 - 0x10)
 123         /* clear stack */
 124         cld
 125         movl    %eax, %edi
 126         movl    $(SMM_STACK_SIZE >> 2), %ecx
 127         xorl    %eax, %eax
 128         rep     stosl
 129
 130         /* set new stack */
 131         addl    $SMM_STACK_SIZE, %ebx
 132         movl    %ebx, %esp
 133
 134         /* Get SMM revision */
 135         movl $0xa8000 + 0x7efc, %ebx    /* core 0 address */
 136         subl %ebp, %ebx                 /* subtract core X offset */
 137         movl (%ebx), %eax
 138         pushl %eax
 139
 140         /* Call 32bit C handler */
 141         call smi_handler
 142
 143         /* To return, just do rsm. It will "clean up" protected mode */
 144         rsm
 145
 146 .code16
 147
 148 .align  4, 0xff
 149
 150 smm_gdtptr16:
 151         .word   smm_gdt_end - smm_gdt - 1
 152         .long   smm_gdt - smm_handler_start + 0xa0000 + SMM_HANDLER_OFFSET
 153
 154 .code32
 155
 156 smm_gdt:
 157         /* The first GDT entry can not be used. Keep it zero */
 158         .long   0x00000000, 0x00000000
 159
 160         /* gdt selector 0x08, flat code segment */
 161         .word   0xffff, 0x0000
 162         .byte   0x00, 0x9b, 0xcf, 0x00 /* G=1 and 0x0f, 4GB limit */
 163
 164         /* gdt selector 0x10, flat data segment */
 165         .word   0xffff, 0x0000
 166         .byte   0x00, 0x93, 0xcf, 0x00
 167
 168 smm_gdt_end:
 169
 170
 171 .section ".jumptable", "a", @progbits
 172
 173 /* This is the SMM jump table. All cores use the same SMM handler
 174  * for simplicity. But SMM Entry needs to be different due to the
 175  * save state area. The jump table makes sure all CPUs jump into the
 176  * real handler on SMM entry.
 177  */
 178
 179 /* This code currently supports up to 4 CPU cores. If more than 4 CPU cores
 180  * shall be used, below table has to be updated, as well as smm.ld
 181  */
 182
 183 /* GNU AS/LD will always generate code that assumes CS is 0xa000. In reality
 184  * CS will be set to SMM_BASE[19:4] though. Knowing that the smm handler is the
 185  * first thing in the ASEG, we do a far jump here, to set CS to 0xa000.
 186  */
 187
 188 .code16
 189 jumptable:
 190         /* core 3 */
 191         ljmp $0xa000, $SMM_HANDLER_OFFSET
 192 .align 1024, 0x00
 193         /* core 2 */
 194         ljmp $0xa000, $SMM_HANDLER_OFFSET
 195 .align 1024, 0x00
 196         /* core 1 */
 197         ljmp $0xa000, $SMM_HANDLER_OFFSET
 198 .align 1024, 0x00
 199         /* core 0 */
 200         ljmp $0xa000, $SMM_HANDLER_OFFSET
 201 .align 1024, 0x00
 202