src/arch/i386/firmware/pcbios/e820mangler.S

   1 /*
   2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19         .text
  20         .arch i386
  21         .section ".text16", "ax", @progbits
  22         .section ".data16", "aw", @progbits
  23         .section ".text16.data", "aw", @progbits
  24         .code16
  25
  26 #define SMAP 0x534d4150
  27
  28 /* Most documentation refers to the E820 buffer as being 20 bytes, and
  29  * the API makes it perfectly legitimate to pass only a 20-byte buffer
  30  * and expect to get valid data.  However, some morons at ACPI decided
  31  * to extend the data structure by adding an extra "extended
  32  * attributes" field and by including critical information within this
  33  * field, such as whether or not the region is enabled.  A caller who
  34  * passes in only a 20-byte buffer therefore risks getting very, very
  35  * misleading information.
  36  *
  37  * I have personally witnessed an HP BIOS that returns a value of
  38  * 0x0009 in the extended attributes field.  If we don't pass this
  39  * value through to the caller, 32-bit WinPE will die, usually with a
  40  * PAGE_FAULT_IN_NONPAGED_AREA blue screen of death.
  41  *
  42  * Allow a ridiculously large maximum value (64 bytes) for the E820
  43  * buffer as a guard against insufficiently creative idiots in the
  44  * future.
  45  */
  46 #define E820MAXSIZE     64
  47
  48 /****************************************************************************
  49  *
  50  * Allowed memory windows
  51  *
  52  * There are two ways to view this list.  The first is as a list of
  53  * (non-overlapping) allowed memory regions, sorted by increasing
  54  * address.  The second is as a list of (non-overlapping) hidden
  55  * memory regions, again sorted by increasing address.  The second
  56  * view is offset by half an entry from the first: think about this
  57  * for a moment and it should make sense.
  58  *
  59  * xxx_memory_window is used to indicate an "allowed region"
  60  * structure, hidden_xxx_memory is used to indicate a "hidden region"
  61  * structure.  Each structure is 16 bytes in length.
  62  *
  63  ****************************************************************************
  64  */
  65         .section ".data16"
  66         .align 16
  67         .globl hidemem_base
  68         .globl hidemem_umalloc
  69         .globl hidemem_textdata
  70 memory_windows:
  71 base_memory_window:     .long 0x00000000, 0x00000000 /* Start of memory */
  72
  73 hidemem_base:           .long 0x000a0000, 0x00000000 /* Changes at runtime */
  74 ext_memory_window:      .long 0x000a0000, 0x00000000 /* 640kB mark */
  75
  76 hidemem_umalloc:        .long 0xffffffff, 0xffffffff /* Changes at runtime */
  77                         .long 0xffffffff, 0xffffffff /* Changes at runtime */
  78
  79 hidemem_textdata:       .long 0xffffffff, 0xffffffff /* Changes at runtime */
  80                         .long 0xffffffff, 0xffffffff /* Changes at runtime */
  81
  82                         .long 0xffffffff, 0xffffffff /* End of memory */
  83 memory_windows_end:
  84
  85 /****************************************************************************
  86  * Truncate region to memory window
  87  *
  88  * Parameters:
  89  *  %edx:%eax   Start of region
  90  *  %ecx:%ebx   Length of region
  91  *  %si         Memory window
  92  * Returns:
  93  *  %edx:%eax   Start of windowed region
  94  *  %ecx:%ebx   Length of windowed region
  95  ****************************************************************************
  96  */
  97         .section ".text16"
  98 window_region:
  99         /* Convert (start,len) to (start, end) */
 100         addl    %eax, %ebx
 101         adcl    %edx, %ecx
 102         /* Truncate to window start */
 103         cmpl    4(%si), %edx
 104         jne     1f
 105         cmpl    0(%si), %eax
 106 1:      jae     2f
 107         movl    4(%si), %edx
 108         movl    0(%si), %eax
 109 2:      /* Truncate to window end */
 110         cmpl    12(%si), %ecx
 111         jne     1f
 112         cmpl    8(%si), %ebx
 113 1:      jbe     2f
 114         movl    12(%si), %ecx
 115         movl    8(%si), %ebx
 116 2:      /* Convert (start, end) back to (start, len) */
 117         subl    %eax, %ebx
 118         sbbl    %edx, %ecx
 119         /* If length is <0, set length to 0 */
 120         jae     1f
 121         xorl    %ebx, %ebx
 122         xorl    %ecx, %ecx
 123         ret
 124         .size   window_region, . - window_region
 125
 126 /****************************************************************************
 127  * Patch "memory above 1MB" figure
 128  *
 129  * Parameters:
 130  *  %ax         Memory above 1MB, in 1kB blocks
 131  * Returns:
 132  *  %ax         Modified memory above 1M in 1kB blocks
 133  ****************************************************************************
 134  */
 135         .section ".text16"
 136 patch_1m:
 137         pushal
 138         /* Convert to (start,len) format and call truncate */
 139         xorl    %ecx, %ecx
 140         movzwl  %ax, %ebx
 141         shll    $10, %ebx
 142         xorl    %edx, %edx
 143         movl    $0x100000, %eax
 144         movw    $ext_memory_window, %si
 145         call    window_region
 146         /* Convert back to "memory above 1MB" format and return via %ax */
 147         pushfw
 148         shrl    $10, %ebx
 149         popfw
 150         movw    %sp, %bp
 151         movw    %bx, 28(%bp)
 152         popal
 153         ret
 154         .size patch_1m, . - patch_1m
 155
 156 /****************************************************************************
 157  * Patch "memory above 16MB" figure
 158  *
 159  * Parameters:
 160  *  %bx         Memory above 16MB, in 64kB blocks
 161  * Returns:
 162  *  %bx         Modified memory above 16M in 64kB blocks
 163  ****************************************************************************
 164  */
 165         .section ".text16"
 166 patch_16m:
 167         pushal
 168         /* Convert to (start,len) format and call truncate */
 169         xorl    %ecx, %ecx
 170         shll    $16, %ebx
 171         xorl    %edx, %edx
 172         movl    $0x1000000, %eax
 173         movw    $ext_memory_window, %si
 174         call    window_region
 175         /* Convert back to "memory above 16MB" format and return via %bx */
 176         pushfw
 177         shrl    $16, %ebx
 178         popfw
 179         movw    %sp, %bp
 180         movw    %bx, 16(%bp)
 181         popal
 182         ret
 183         .size patch_16m, . - patch_16m
 184
 185 /****************************************************************************
 186  * Patch "memory between 1MB and 16MB" and "memory above 16MB" figures
 187  *
 188  * Parameters:
 189  *  %ax         Memory between 1MB and 16MB, in 1kB blocks
 190  *  %bx         Memory above 16MB, in 64kB blocks
 191  * Returns:
 192  *  %ax         Modified memory between 1MB and 16MB, in 1kB blocks
 193  *  %bx         Modified memory above 16MB, in 64kB blocks
 194  ****************************************************************************
 195  */
 196         .section ".text16"
 197 patch_1m_16m:
 198         call    patch_1m
 199         call    patch_16m
 200         /* If 1M region is no longer full-length, kill off the 16M region */
 201         cmpw    $( 15 * 1024 ), %ax
 202         je      1f
 203         xorw    %bx, %bx
 204 1:      ret
 205         .size patch_1m_16m, . - patch_1m_16m
 206
 207 /****************************************************************************
 208  * Get underlying e820 memory region to underlying_e820 buffer
 209  *
 210  * Parameters:
 211  *   As for INT 15,e820
 212  * Returns:
 213  *   As for INT 15,e820
 214  *
 215  * Wraps the underlying INT 15,e820 call so that the continuation
 216  * value (%ebx) is a 16-bit simple sequence counter (with the high 16
 217  * bits ignored), and termination is always via CF=1 rather than
 218  * %ebx=0.
 219  *
 220  ****************************************************************************
 221  */
 222         .section ".text16"
 223 get_underlying_e820:
 224
 225         /* If the requested region is in the cache, return it */
 226         cmpw    %bx, underlying_e820_index
 227         jne     2f
 228         pushw   %di
 229         pushw   %si
 230         movw    $underlying_e820_cache, %si
 231         cmpl    underlying_e820_cache_size, %ecx
 232         jbe     1f
 233         movl    underlying_e820_cache_size, %ecx
 234 1:      pushl   %ecx
 235         rep movsb
 236         popl    %ecx
 237         popw    %si
 238         popw    %di
 239         incw    %bx
 240         movl    %edx, %eax
 241         ret
 242 2:
 243         /* If the requested region is earlier than the cached region,
 244          * invalidate the cache.
 245          */
 246         cmpw    %bx, underlying_e820_index
 247         jbe     1f
 248         movw    $0xffff, underlying_e820_index
 249 1:
 250         /* If the cache is invalid, reset the underlying %ebx */
 251         cmpw    $0xffff, underlying_e820_index
 252         jne     1f
 253         andl    $0, underlying_e820_ebx
 254 1:
 255         /* If the cache is valid but the continuation value is zero,
 256          * this means that the previous underlying call returned with
 257          * %ebx=0.  Return with CF=1 in this case.
 258          */
 259         cmpw    $0xffff, underlying_e820_index
 260         je      1f
 261         cmpl    $0, underlying_e820_ebx
 262         jne     1f
 263         stc
 264         ret
 265 1:
 266         /* Get the next region into the cache */
 267         pushl   %eax
 268         pushl   %ebx
 269         pushl   %ecx
 270         pushl   %edx
 271         pushl   %esi    /* Some implementations corrupt %esi, so we     */
 272         pushl   %edi    /* preserve %esi, %edi and %ebp to be paranoid  */
 273         pushl   %ebp
 274         pushw   %es
 275         pushw   %ds
 276         popw    %es
 277         movw    $underlying_e820_cache, %di
 278         cmpl    $E820MAXSIZE, %ecx
 279         jbe     1f
 280         movl    $E820MAXSIZE, %ecx
 281 1:      movl    underlying_e820_ebx, %ebx
 282         stc
 283         pushfw
 284         lcall   *%cs:int15_vector
 285         popw    %es
 286         popl    %ebp
 287         popl    %edi
 288         popl    %esi
 289         /* Check for error return from underlying e820 call */
 290         jc      2f /* CF set: error */
 291         cmpl    $SMAP, %eax
 292         je      3f /* 'SMAP' missing: error */
 293 2:      /* An error occurred: return values returned by underlying e820 call */
 294         stc     /* Force CF set if SMAP was missing */
 295         addr32 leal 16(%esp), %esp /* avoid changing other flags */
 296         ret
 297 3:      /* No error occurred */
 298         movl    %ebx, underlying_e820_ebx
 299         movl    %ecx, underlying_e820_cache_size
 300         popl    %edx
 301         popl    %ecx
 302         popl    %ebx
 303         popl    %eax
 304         /* Mark cache as containing this result */
 305         incw    underlying_e820_index
 306
 307         /* Loop until found */
 308         jmp     get_underlying_e820
 309         .size   get_underlying_e820, . - get_underlying_e820
 310
 311         .section ".data16"
 312 underlying_e820_index:
 313         .word   0xffff /* Initialise to an invalid value */
 314         .size underlying_e820_index, . - underlying_e820_index
 315
 316         .section ".bss16"
 317 underlying_e820_ebx:
 318         .long   0
 319         .size underlying_e820_ebx, . - underlying_e820_ebx
 320
 321         .section ".bss16"
 322 underlying_e820_cache:
 323         .space  E820MAXSIZE
 324         .size underlying_e820_cache, . - underlying_e820_cache
 325
 326         .section ".bss16"
 327 underlying_e820_cache_size:
 328         .long   0
 329         .size   underlying_e820_cache_size, . - underlying_e820_cache_size
 330
 331 /****************************************************************************
 332  * Get windowed e820 region, without empty region stripping
 333  *
 334  * Parameters:
 335  *   As for INT 15,e820
 336  * Returns:
 337  *   As for INT 15,e820
 338  *
 339  * Wraps the underlying INT 15,e820 call so that each underlying
 340  * region is returned N times, windowed to fit within N visible-memory
 341  * windows.  Termination is always via CF=1.
 342  *
 343  ****************************************************************************
 344  */
 345         .section ".text16"
 346 get_windowed_e820:
 347
 348         /* Preserve registers */
 349         pushl   %esi
 350         pushw   %bp
 351
 352         /* Split %ebx into %si:%bx, store original %bx in %bp */
 353         pushl   %ebx
 354         popw    %bp
 355         popw    %si
 356
 357         /* %si == 0 => start of memory_windows list */
 358         testw   %si, %si
 359         jne     1f
 360         movw    $memory_windows, %si
 361 1:
 362         /* Get (cached) underlying e820 region to buffer */
 363         call    get_underlying_e820
 364         jc      99f /* Abort on error */
 365
 366         /* Preserve registers */
 367         pushal
 368         /* start => %edx:%eax, len => %ecx:%ebx */
 369         movl    %es:0(%di), %eax
 370         movl    %es:4(%di), %edx
 371         movl    %es:8(%di), %ebx
 372         movl    %es:12(%di), %ecx
 373         /* Truncate region to current window */
 374         call    window_region
 375 1:      /* Store modified values in e820 map entry */
 376         movl    %eax, %es:0(%di)
 377         movl    %edx, %es:4(%di)
 378         movl    %ebx, %es:8(%di)
 379         movl    %ecx, %es:12(%di)
 380         /* Restore registers */
 381         popal
 382
 383         /* Derive continuation value for next call */
 384         addw    $16, %si
 385         cmpw    $memory_windows_end, %si
 386         jne     1f
 387         /* End of memory windows: reset %si and allow %bx to continue */
 388         xorw    %si, %si
 389         jmp     2f
 390 1:      /* More memory windows to go: restore original %bx */
 391         movw    %bp, %bx
 392 2:      /* Construct %ebx from %si:%bx */
 393         pushw   %si
 394         pushw   %bx
 395         popl    %ebx
 396
 397 98:     /* Clear CF */
 398         clc
 399 99:     /* Restore registers and return */
 400         popw    %bp
 401         popl    %esi
 402         ret
 403         .size get_windowed_e820, . - get_windowed_e820
 404
 405 /****************************************************************************
 406  * Get windowed e820 region, with empty region stripping
 407  *
 408  * Parameters:
 409  *   As for INT 15,e820
 410  * Returns:
 411  *   As for INT 15,e820
 412  *
 413  * Wraps the underlying INT 15,e820 call so that each underlying
 414  * region is returned up to N times, windowed to fit within N
 415  * visible-memory windows.  Empty windows are never returned.
 416  * Termination is always via CF=1.
 417  *
 418  ****************************************************************************
 419  */
 420         .section ".text16"
 421 get_nonempty_e820:
 422
 423         /* Record entry parameters */
 424         pushl   %eax
 425         pushl   %ecx
 426         pushl   %edx
 427
 428         /* Get next windowed region */
 429         call    get_windowed_e820
 430         jc      99f /* abort on error */
 431
 432         /* If region is non-empty, finish here */
 433         cmpl    $0, %es:8(%di)
 434         jne     98f
 435         cmpl    $0, %es:12(%di)
 436         jne     98f
 437
 438         /* Region was empty: restore entry parameters and go to next region */
 439         popl    %edx
 440         popl    %ecx
 441         popl    %eax
 442         jmp     get_nonempty_e820
 443
 444 98:     /* Clear CF */
 445         clc
 446 99:     /* Return values from underlying call */
 447         addr32 leal 12(%esp), %esp /* avoid changing flags */
 448         ret
 449         .size get_nonempty_e820, . - get_nonempty_e820
 450
 451 /****************************************************************************
 452  * Get mangled e820 region, with empty region stripping
 453  *
 454  * Parameters:
 455  *   As for INT 15,e820
 456  * Returns:
 457  *   As for INT 15,e820
 458  *
 459  * Wraps the underlying INT 15,e820 call so that underlying regions
 460  * are windowed to the allowed memory regions.  Empty regions are
 461  * stripped from the map.  Termination is always via %ebx=0.
 462  *
 463  ****************************************************************************
 464  */
 465         .section ".text16"
 466 get_mangled_e820:
 467
 468         /* Get a nonempty region */
 469         call    get_nonempty_e820
 470         jc      99f /* Abort on error */
 471
 472         /* Peek ahead to see if there are any further nonempty regions */
 473         pushal
 474         pushw   %es
 475         movw    %sp, %bp
 476         subw    %cx, %sp
 477         movl    $0xe820, %eax
 478         movl    $SMAP, %edx
 479         pushw   %ss
 480         popw    %es
 481         movw    %sp, %di
 482         call    get_nonempty_e820
 483         movw    %bp, %sp
 484         popw    %es
 485         popal
 486         jnc     99f /* There are further nonempty regions */
 487
 488         /* No futher nonempty regions: zero %ebx and clear CF */
 489         xorl    %ebx, %ebx
 490
 491 99:     /* Return */
 492         ret
 493         .size get_mangled_e820, . - get_mangled_e820
 494
 495 /****************************************************************************
 496  * INT 15,e820 handler
 497  ****************************************************************************
 498  */
 499         .section ".text16"
 500 int15_e820:
 501         pushw   %ds
 502         pushw   %cs:rm_ds
 503         popw    %ds
 504         call    get_mangled_e820
 505         popw    %ds
 506         lret    $2
 507         .size int15_e820, . - int15_e820
 508
 509 /****************************************************************************
 510  * INT 15,e801 handler
 511  ****************************************************************************
 512  */
 513         .section ".text16"
 514 int15_e801:
 515         /* Call previous handler */
 516         pushfw
 517         lcall   *%cs:int15_vector
 518         pushfw
 519         /* Edit result */
 520         pushw   %ds
 521         pushw   %cs:rm_ds
 522         popw    %ds
 523         call    patch_1m_16m
 524         xchgw   %ax, %cx
 525         xchgw   %bx, %dx
 526         call    patch_1m_16m
 527         xchgw   %ax, %cx
 528         xchgw   %bx, %dx
 529         popw    %ds
 530         /* Restore flags returned by previous handler and return */
 531         popfw
 532         lret    $2
 533         .size int15_e801, . - int15_e801
 534
 535 /****************************************************************************
 536  * INT 15,88 handler
 537  ****************************************************************************
 538  */
 539         .section ".text16"
 540 int15_88:
 541         /* Call previous handler */
 542         pushfw
 543         lcall   *%cs:int15_vector
 544         pushfw
 545         /* Edit result */
 546         pushw   %ds
 547         pushw   %cs:rm_ds
 548         popw    %ds
 549         call    patch_1m
 550         popw    %ds
 551         /* Restore flags returned by previous handler and return */
 552         popfw
 553         lret    $2
 554         .size int15_88, . - int15_88
 555
 556 /****************************************************************************
 557  * INT 15 handler
 558  ****************************************************************************
 559  */
 560         .section ".text16"
 561         .globl int15
 562 int15:
 563         /* See if we want to intercept this call */
 564         pushfw
 565         cmpw    $0xe820, %ax
 566         jne     1f
 567         cmpl    $SMAP, %edx
 568         jne     1f
 569         popfw
 570         jmp     int15_e820
 571 1:      cmpw    $0xe801, %ax
 572         jne     2f
 573         popfw
 574         jmp     int15_e801
 575 2:      cmpb    $0x88, %ah
 576         jne     3f
 577         popfw
 578         jmp     int15_88
 579 3:      popfw
 580         ljmp    *%cs:int15_vector
 581         .size int15, . - int15
 582
 583         .section ".text16.data"
 584         .globl int15_vector
 585 int15_vector:
 586         .long 0
 587         .size int15_vector, . - int15_vector