[pcbios] Allow for larger-than-20-byte buffers in e820mangler.S
[people/sha0/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_text
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_text:           .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         pushw   %es
272         pushw   %di
273         pushw   %ds
274         popw    %es
275         movw    $underlying_e820_cache, %di
276         cmpl    $E820MAXSIZE, %ecx
277         jbe     1f
278         movl    $E820MAXSIZE, %ecx
279 1:      movl    underlying_e820_ebx, %ebx
280         stc
281         pushfw
282         lcall   *%cs:int15_vector
283         popw    %di
284         popw    %es
285         /* Check for error return from underlying e820 call */
286         jc      2f /* CF set: error */
287         cmpl    $SMAP, %eax
288         je      3f /* 'SMAP' missing: error */
289 2:      /* An error occurred: return values returned by underlying e820 call */
290         stc     /* Force CF set if SMAP was missing */
291         addr32 leal 16(%esp), %esp /* avoid changing other flags */
292         ret
293 3:      /* No error occurred */
294         movl    %ebx, underlying_e820_ebx
295         movl    %ecx, underlying_e820_cache_size
296         popl    %edx
297         popl    %ecx
298         popl    %ebx
299         popl    %eax
300         /* Mark cache as containing this result */
301         incw    underlying_e820_index
302
303         /* Loop until found */
304         jmp     get_underlying_e820
305         .size   get_underlying_e820, . - get_underlying_e820
306
307         .section ".data16"
308 underlying_e820_index:
309         .word   0xffff /* Initialise to an invalid value */
310         .size underlying_e820_index, . - underlying_e820_index
311
312         .section ".bss16"
313 underlying_e820_ebx:
314         .long   0
315         .size underlying_e820_ebx, . - underlying_e820_ebx
316
317         .section ".bss16"
318 underlying_e820_cache:
319         .space  E820MAXSIZE
320         .size underlying_e820_cache, . - underlying_e820_cache
321
322         .section ".bss16"
323 underlying_e820_cache_size:
324         .long   0
325         .size   underlying_e820_cache_size, . - underlying_e820_cache_size
326
327 /****************************************************************************
328  * Get windowed e820 region, without empty region stripping
329  *
330  * Parameters:
331  *   As for INT 15,e820
332  * Returns:
333  *   As for INT 15,e820
334  *
335  * Wraps the underlying INT 15,e820 call so that each underlying
336  * region is returned N times, windowed to fit within N visible-memory
337  * windows.  Termination is always via CF=1.
338  *
339  ****************************************************************************
340  */
341         .section ".text16"
342 get_windowed_e820:
343
344         /* Preserve registers */
345         pushl   %esi
346         pushw   %bp
347
348         /* Split %ebx into %si:%bx, store original %bx in %bp */
349         pushl   %ebx
350         popw    %bp
351         popw    %si
352
353         /* %si == 0 => start of memory_windows list */
354         testw   %si, %si
355         jne     1f
356         movw    $memory_windows, %si
357 1:      
358         /* Get (cached) underlying e820 region to buffer */
359         call    get_underlying_e820
360         jc      99f /* Abort on error */
361
362         /* Preserve registers */
363         pushal
364         /* start => %edx:%eax, len => %ecx:%ebx */
365         movl    %es:0(%di), %eax
366         movl    %es:4(%di), %edx
367         movl    %es:8(%di), %ebx
368         movl    %es:12(%di), %ecx
369         /* Truncate region to current window */
370         call    window_region
371 1:      /* Store modified values in e820 map entry */
372         movl    %eax, %es:0(%di)
373         movl    %edx, %es:4(%di)
374         movl    %ebx, %es:8(%di)
375         movl    %ecx, %es:12(%di)
376         /* Restore registers */
377         popal
378
379         /* Derive continuation value for next call */
380         addw    $16, %si
381         cmpw    $memory_windows_end, %si
382         jne     1f
383         /* End of memory windows: reset %si and allow %bx to continue */
384         xorw    %si, %si
385         jmp     2f
386 1:      /* More memory windows to go: restore original %bx */
387         movw    %bp, %bx
388 2:      /* Construct %ebx from %si:%bx */
389         pushw   %si
390         pushw   %bx
391         popl    %ebx
392
393 98:     /* Clear CF */
394         clc
395 99:     /* Restore registers and return */
396         popw    %bp
397         popl    %esi
398         ret
399         .size get_windowed_e820, . - get_windowed_e820
400
401 /****************************************************************************
402  * Get windowed e820 region, with empty region stripping
403  *
404  * Parameters:
405  *   As for INT 15,e820
406  * Returns:
407  *   As for INT 15,e820
408  *
409  * Wraps the underlying INT 15,e820 call so that each underlying
410  * region is returned up to N times, windowed to fit within N
411  * visible-memory windows.  Empty windows are never returned.
412  * Termination is always via CF=1.
413  *
414  ****************************************************************************
415  */
416         .section ".text16"
417 get_nonempty_e820:
418
419         /* Record entry parameters */
420         pushl   %eax
421         pushl   %ecx
422         pushl   %edx
423
424         /* Get next windowed region */
425         call    get_windowed_e820
426         jc      99f /* abort on error */
427
428         /* If region is non-empty, finish here */
429         cmpl    $0, %es:8(%di)
430         jne     98f
431         cmpl    $0, %es:12(%di)
432         jne     98f
433
434         /* Region was empty: restore entry parameters and go to next region */
435         popl    %edx
436         popl    %ecx
437         popl    %eax
438         jmp     get_nonempty_e820
439
440 98:     /* Clear CF */
441         clc
442 99:     /* Return values from underlying call */
443         addr32 leal 12(%esp), %esp /* avoid changing flags */
444         ret
445         .size get_nonempty_e820, . - get_nonempty_e820
446
447 /****************************************************************************
448  * Get mangled e820 region, with empty region stripping
449  *
450  * Parameters:
451  *   As for INT 15,e820
452  * Returns:
453  *   As for INT 15,e820
454  *
455  * Wraps the underlying INT 15,e820 call so that underlying regions
456  * are windowed to the allowed memory regions.  Empty regions are
457  * stripped from the map.  Termination is always via %ebx=0.
458  *
459  ****************************************************************************
460  */
461         .section ".text16"
462 get_mangled_e820:
463
464         /* Get a nonempty region */
465         call    get_nonempty_e820
466         jc      99f /* Abort on error */
467
468         /* Peek ahead to see if there are any further nonempty regions */
469         pushal
470         pushw   %es
471         movw    %sp, %bp
472         subw    %cx, %sp
473         movl    $0xe820, %eax
474         movl    $SMAP, %edx
475         pushw   %ss
476         popw    %es
477         movw    %sp, %di
478         call    get_nonempty_e820
479         movw    %bp, %sp
480         popw    %es
481         popal
482         jnc     99f /* There are further nonempty regions */
483
484         /* No futher nonempty regions: zero %ebx and clear CF */
485         xorl    %ebx, %ebx
486         
487 99:     /* Return */
488         ret
489         .size get_mangled_e820, . - get_mangled_e820
490
491 /****************************************************************************
492  * INT 15,e820 handler
493  ****************************************************************************
494  */
495         .section ".text16"
496 int15_e820:
497         pushw   %ds
498         pushw   %cs:rm_ds
499         popw    %ds
500         call    get_mangled_e820
501         popw    %ds
502         lret    $2
503         .size int15_e820, . - int15_e820
504         
505 /****************************************************************************
506  * INT 15,e801 handler
507  ****************************************************************************
508  */
509         .section ".text16"
510 int15_e801:
511         /* Call previous handler */
512         pushfw
513         lcall   *%cs:int15_vector
514         pushfw
515         /* Edit result */
516         pushw   %ds
517         pushw   %cs:rm_ds
518         popw    %ds
519         call    patch_1m_16m
520         xchgw   %ax, %cx
521         xchgw   %bx, %dx
522         call    patch_1m_16m
523         xchgw   %ax, %cx
524         xchgw   %bx, %dx
525         popw    %ds
526         /* Restore flags returned by previous handler and return */
527         popfw
528         lret    $2
529         .size int15_e801, . - int15_e801
530         
531 /****************************************************************************
532  * INT 15,88 handler
533  ****************************************************************************
534  */
535         .section ".text16"
536 int15_88:
537         /* Call previous handler */
538         pushfw
539         lcall   *%cs:int15_vector
540         pushfw
541         /* Edit result */
542         pushw   %ds
543         pushw   %cs:rm_ds
544         popw    %ds
545         call    patch_1m
546         popw    %ds
547         /* Restore flags returned by previous handler and return */
548         popfw
549         lret    $2
550         .size int15_88, . - int15_88
551                 
552 /****************************************************************************
553  * INT 15 handler
554  ****************************************************************************
555  */
556         .section ".text16"
557         .globl int15
558 int15:
559         /* See if we want to intercept this call */
560         pushfw
561         cmpw    $0xe820, %ax
562         jne     1f
563         cmpl    $SMAP, %edx
564         jne     1f
565         popfw
566         jmp     int15_e820
567 1:      cmpw    $0xe801, %ax
568         jne     2f
569         popfw
570         jmp     int15_e801
571 2:      cmpb    $0x88, %ah
572         jne     3f
573         popfw
574         jmp     int15_88
575 3:      popfw
576         ljmp    *%cs:int15_vector
577         .size int15, . - int15
578         
579         .section ".text16.data"
580         .globl int15_vector
581 int15_vector:
582         .long 0
583         .size int15_vector, . - int15_vector