53e2d7c5551ef9f190ff5beff099cb8873ee7e6a
[people/asdlkf/gpxe.git] / 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