kern/i386/realmode.S

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 1999,2000,2001,2002,2003,2005,2006,2007,2009 Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19
  20 /*
  21  * Note: These functions defined in this file may be called from C.
  22  *       Be careful of that you must not modify some registers. Quote
  23  *       from gcc-2.95.2/gcc/config/i386/i386.h:
  24
  25    1 for registers not available across function calls.
  26    These must include the FIXED_REGISTERS and also any
  27    registers that can be used without being saved.
  28    The latter must include the registers where values are returned
  29    and the register where structure-value addresses are passed.
  30    Aside from that, you can include as many other registers as you like.
  31
  32   ax,dx,cx,bx,si,di,bp,sp,st,st1,st2,st3,st4,st5,st6,st7,arg
  33 {  1, 1, 1, 0, 0, 0, 0, 1, 1,  1,  1,  1,  1,  1,  1,  1,  1 }
  34  */
  35
  36 /*
  37  * Note: GRUB is compiled with the options -mrtd and -mregparm=3.
  38  *       So the first three arguments are passed in %eax, %edx, and %ecx,
  39  *       respectively, and if a function has a fixed number of arguments
  40  *       and the number if greater than three, the function must return
  41  *       with "ret $N" where N is ((the number of arguments) - 3) * 4.
  42  */
  43
  44 /*
  45  *  This is the area for all of the special variables.
  46  */
  47
  48         .p2align        2       /* force 4-byte alignment */
  49
  50 protstack:
  51         .long   GRUB_MEMORY_MACHINE_PROT_STACK
  52
  53 /*
  54  * This is the Global Descriptor Table
  55  *
  56  *  An entry, a "Segment Descriptor", looks like this:
  57  *
  58  * 31          24         19   16                 7           0
  59  * ------------------------------------------------------------
  60  * |             | |B| |A|       | |   |1|0|E|W|A|            |
  61  * | BASE 31..24 |G|/|L|V| LIMIT |P|DPL|  TYPE   | BASE 23:16 |  4
  62  * |             | |D| |L| 19..16| |   |1|1|C|R|A|            |
  63  * ------------------------------------------------------------
  64  * |                             |                            |
  65  * |        BASE 15..0           |       LIMIT 15..0          |  0
  66  * |                             |                            |
  67  * ------------------------------------------------------------
  68  *
  69  *  Note the ordering of the data items is reversed from the above
  70  *  description.
  71  */
  72
  73         .p2align        2       /* force 4-byte alignment */
  74 gdt:
  75         .word   0, 0
  76         .byte   0, 0, 0, 0
  77
  78         /* -- code segment --
  79          * base = 0x00000000, limit = 0xFFFFF (4 KiB Granularity), present
  80          * type = 32bit code execute/read, DPL = 0
  81          */
  82         .word   0xFFFF, 0
  83         .byte   0, 0x9A, 0xCF, 0
  84
  85         /* -- data segment --
  86          * base = 0x00000000, limit 0xFFFFF (4 KiB Granularity), present
  87          * type = 32 bit data read/write, DPL = 0
  88          */
  89         .word   0xFFFF, 0
  90         .byte   0, 0x92, 0xCF, 0
  91
  92         /* -- 16 bit real mode CS --
  93          * base = 0x00000000, limit 0x0FFFF (1 B Granularity), present
  94          * type = 16 bit code execute/read only/conforming, DPL = 0
  95          */
  96         .word   0xFFFF, 0
  97         .byte   0, 0x9E, 0, 0
  98
  99         /* -- 16 bit real mode DS --
 100          * base = 0x00000000, limit 0x0FFFF (1 B Granularity), present
 101          * type = 16 bit data read/write, DPL = 0
 102          */
 103         .word   0xFFFF, 0
 104         .byte   0, 0x92, 0, 0
 105
 106
 107 /* this is the GDT descriptor */
 108 gdtdesc:
 109         .word   0x27                    /* limit */
 110         .long   gdt                     /* addr */
 111
 112 /*
 113  *  These next two routines, "real_to_prot" and "prot_to_real" are structured
 114  *  in a very specific way.  Be very careful when changing them.
 115  *
 116  *  NOTE:  Use of either one messes up %eax and %ebp.
 117  */
 118
 119 real_to_prot:
 120         .code16
 121         cli
 122
 123         /* load the GDT register */
 124         xorw    %ax, %ax
 125         movw    %ax, %ds
 126         DATA32  ADDR32  lgdt    gdtdesc
 127
 128         /* turn on protected mode */
 129         movl    %cr0, %eax
 130         orl     $GRUB_MEMORY_MACHINE_CR0_PE_ON, %eax
 131         movl    %eax, %cr0
 132
 133         /* jump to relocation, flush prefetch queue, and reload %cs */
 134         DATA32  ljmp    $GRUB_MEMORY_MACHINE_PROT_MODE_CSEG, $protcseg
 135
 136         .code32
 137 protcseg:
 138         /* reload other segment registers */
 139         movw    $GRUB_MEMORY_MACHINE_PROT_MODE_DSEG, %ax
 140         movw    %ax, %ds
 141         movw    %ax, %es
 142         movw    %ax, %fs
 143         movw    %ax, %gs
 144         movw    %ax, %ss
 145
 146         /* put the return address in a known safe location */
 147         movl    (%esp), %eax
 148         movl    %eax, GRUB_MEMORY_MACHINE_REAL_STACK
 149
 150         /* get protected mode stack */
 151         movl    protstack, %eax
 152         movl    %eax, %esp
 153         movl    %eax, %ebp
 154
 155         /* get return address onto the right stack */
 156         movl    GRUB_MEMORY_MACHINE_REAL_STACK, %eax
 157         movl    %eax, (%esp)
 158
 159         /* zero %eax */
 160         xorl    %eax, %eax
 161
 162         /* return on the old (or initialized) stack! */
 163         ret
 164
 165 prot_to_real:
 166         /* just in case, set GDT */
 167         lgdt    gdtdesc
 168
 169         /* save the protected mode stack */
 170         movl    %esp, %eax
 171         movl    %eax, protstack
 172
 173         /* get the return address */
 174         movl    (%esp), %eax
 175         movl    %eax, GRUB_MEMORY_MACHINE_REAL_STACK
 176
 177         /* set up new stack */
 178         movl    $GRUB_MEMORY_MACHINE_REAL_STACK, %eax
 179         movl    %eax, %esp
 180         movl    %eax, %ebp
 181
 182         /* set up segment limits */
 183         movw    $GRUB_MEMORY_MACHINE_PSEUDO_REAL_DSEG, %ax
 184         movw    %ax, %ds
 185         movw    %ax, %es
 186         movw    %ax, %fs
 187         movw    %ax, %gs
 188         movw    %ax, %ss
 189
 190         /* this might be an extra step */
 191         /* jump to a 16 bit segment */
 192         ljmp    $GRUB_MEMORY_MACHINE_PSEUDO_REAL_CSEG, $tmpcseg
 193
 194 tmpcseg:
 195         .code16
 196
 197         /* clear the PE bit of CR0 */
 198         movl    %cr0, %eax
 199         andl    $(~GRUB_MEMORY_MACHINE_CR0_PE_ON), %eax
 200         movl    %eax, %cr0
 201
 202         /* flush prefetch queue, reload %cs */
 203         DATA32  ljmp    $0, $realcseg
 204
 205 realcseg:
 206         /* we are in real mode now
 207          * set up the real mode segment registers : DS, SS, ES
 208          */
 209         /* zero %eax */
 210         xorl    %eax, %eax
 211
 212         movw    %ax, %ds
 213         movw    %ax, %es
 214         movw    %ax, %fs
 215         movw    %ax, %gs
 216         movw    %ax, %ss
 217
 218         /* restore interrupts */
 219         sti
 220
 221         /* return on new stack! */
 222         DATA32  ret
 223
 224         .code32